How do I handle initialization and connection when using Sendbird Live and Sendbird UIKit together?

[tezpark]

Summary

• How do I handle initialization and connection when using Sendbird Live and Sendbird UIKit together?

Guide & Snippet

Live uses the term authenticate and UIKit uses the term connect, but I will use the term connect in the following discussion.

• When using Sendbird Live with Sendbird UIKit, the order in which you request initialization and connection are important.
• This is because some configs in UIKit are updated during the connect flow, and UIKit's connect will not attempt to reconnect if already connected to avoid duplicate connect requests. and the SendbirdUI initialization action is required because UIKit configurations can only be received by UIKit users on the server.
• Also, because both Live connect and UIKit connect use the same connection internally, the connection state is shared.
• So if you use Live connect first, UIKit's connect behavior will be ignored and the properties needed to use UIKit features will not be updated.
• So if you're using Live with UIKit, you'll need to use UIKit's connect first.

• The logic below is a custom snippet with a simple example.

SendbirdUI.initialize(applicationId: appId) { error in
    SendbirdLive.initialize(
        params: .init(applicationId: appId),
        migrationStartHandler: nil) { _ in
            SendbirdLive.executeOn(.main)
            SendbirdUI.connect { user, error in
                SendbirdLive.authenticate(
                    userId: userId,
                    accessToken: accessToken
                ) { result in
                    DispatchQueue.main.async {
                        switch result {
                        case .success:
                            // Do something
                            break
                        case .failure(let error):
                            // Do something
                            break
                        }
                    }
                }
            }
        }
    }

Reference

• UIKit: Connect to Sendbird server
• Live: Authenticate a user
• (internal)SBISSUE-17276

[abhishekarora117]

Hi @tezpark ,

After following the guide precisely, the supergroup reactions are now working. However, the callback for reactions from Sendbird Live is still not triggering.

[tezpark]

Hi @abhishekarora117
I've checked that using two different SDKs together affects the initialization and connection timing. I updated the documentation a while ago, can you check it again?
I modified the initialization and connection/authentication order as shown below.

1. SendbirdUI.initialize
2. SendbirdLive.initialize
3. SendbirdUI.connect
4. SendbirdLive.authenticate

[abhishekarora117]

Hi @tezpark ,

Thank you for promptly addressing this issue. However, with the latest solution you provided, neither the supergroup reactions nor the callback from Sendbird Live are triggering as expected.

At Playfora, we found a workaround that enables both features, though it unfortunately leads to frequent internal SQLite crashes. Since you know the implementation details of these initializations, we’re hopeful that a more stable solution can be found. Our primary challenge with the workaround has been its instability due to these crashes.

Moving forward, we would appreciate it if suggested solutions could be tested on your end before recommending them to us, as we’ve spent significant time trying numerous approaches without achieving a stable outcome. We believe this could streamline the process and make troubleshooting more effective.

In the meantime, here’s the current approach we’re using. If possible, we’d appreciate it if you could also try this solution on your end and let us know of any refinements or improvements you would suggest.

This approach initializes the PlayforaChat, PlayforaUI, and PlayforaLive modules sequentially in the main flow, ensuring that each module is properly configured with user data before the main app screen is displayed.

Main Flow Coordinator Code
The following code is executed in the main flow of the app, before the first screen is displayed to a logged-in user:

Task { @MainActor in
           let chatResult = await PlayforaChat.initialize(user: user)
           let uiResult = await PlayforaUI.initialize(user: user)
           let liveResult = await PlayforaLive.shared.initialize(user: user)

// following takes to the opens screen of the app
           gotoDashboard(with: user, hostID: hostID, withDeeplink: deeplink)
       }

This Task block runs initialization tasks for PlayforaChat, PlayforaUI, and PlayforaLive sequentially. Once completed, the app navigates to the dashboard screen.

PlayforaChat Initialization Code
The initialize function in PlayforaChat sets up SendbirdChat with caching enabled.

        private class func initialize(user: User, completion: @escaping ((_ result: Result<Bool, Error>) -> Void)) {
        let APP_ID = ConfigurationManager().sendbirdApplicationId()
        SendbirdChat.initialize(params: .init(applicationId: APP_ID,
                                              isLocalCachingEnabled: true), completionHandler:  { error in
            if let error = error {
                completion(.failure(error))
            } else {
                SendbirdChat.setLogLevel(.verbose)
                setupCurrentUser(user: user)
                completion(.success(true))
            }
        })
    }

Async Wrapper for PlayforaChat Initialization
An async version of initialize is provided, allowing it to be called using Swift’s concurrency features.

    class func initialize(user: User) async -> Bool {
        await withCheckedContinuation { continuation in
            initialize(user: user) { result in
                switch result {
                case .success(let success):
                    continuation.resume(returning: success)
                case .failure(let failure):
                    continuation.resume(returning: false)
                }
            }
        }
    }

PlayforaUI Initialization Code
The PlayforaUI initialization configures SendbirdUI.

            @MainActor
    static func initialize(user: User) async -> SendbirdChatSDK.User? {
        await withCheckedContinuation { continuation in
            initialize(user: user) { result in
                switch result {
                case .success(let success):
                    continuation.resume(returning: success)
                case .failure(let failure):
                    continuation.resume(returning: nil)
                }
            }
        }
    }
    
    private static func initialize(user: User, completion: @escaping SendbirdLiveSDK.UserHandler) {

        let APP_ID = ConfigurationManager().sendbirdApplicationId()
        SBUGlobals.currentUser = SBUUser(userId: user.userId, nickname:user.userName, profileURL: user.profilePhotoURL)
        SBUGlobals.applicationId = APP_ID
        SendbirdUI.initialize(applicationId: APP_ID) { error in
            print(error?.localizedDescription ?? "no Error")
            if let error = error {
                completion(.failure(error))
            } else {
                setupCurrentUser(user: user)
                SendbirdUI.connect { user, error in
                    if let error = error {
                        print(error)
                        completion(.failure(error))
                    } else if let user = user {
                        completion(.success(user))
                    } else {
                        let error = SBError(domain: "PlayforaUI", code: 0, userInfo: [NSLocalizedDescriptionKey: "user not found"])
                        completion(.failure(error))
                    }
                }
            }
        }
    }

PlayforaLive Initialization Code
The PlayforaLive singleton is initialized here, along with its associated user setup.

   static let shared = PlayforaLive()
    private init() {}
    
    private func initialize(user: User, completion: @escaping SendbirdLiveSDK.UserHandler) {
        let APP_ID = ConfigurationManager().sendbirdApplicationId()
        // Update app ID
        SendbirdLive.initialize(params: .init(applicationId: APP_ID), migrationStartHandler: nil, completionHandler: { error in
            if let error = error {
                completion(.failure(error))
            } else {
                SendbirdLive.setLogLevel(.verbose)
                SendbirdLive.executeOn(.main)
                self.setupCurrentUser(user: user) { result in
                    completion(result)
                }
            }
        })
    }

    func initialize(user: User) async -> SendbirdChatSDK.User? {
        await withCheckedContinuation { continuation in
            initialize(user: user) { result in
                switch result {
                case .success(let success):
                    continuation.resume(returning: success)
                case .failure(let failure):
                    continuation.resume(returning: nil)
                }
            }
        }
    }

    private func setupCurrentUser(user: User, completion: @escaping SendbirdLiveSDK.UserHandler) {
        sbduid = user.userId
        authenticateUser(userUuid: sbduid) { result in
            switch result {
            case .success:
                self.currentPlayforaUser = user
                self.userAuthenticationDone = true
            case .failure(let error):
                print(error)
            }
            completion(result)
        }
    }