Migration from SyncManager
Local caching is available with Sendbird Chat SDK. Both local caching and SyncManager enables Sendbird Chat SDK for Android to locally cache and retrieve data related to group channels and messages. However, local caching is integrated into Chat SDK while SyncManager is an external add-on. Being internally integrated into Chat SDK allows for easier maintenance, improved stability, and enhanced usability.
The existing SyncManager for Android will be deprecated soon, so it is highly recommended to migrate from SyncManager to the Chat SDK with local caching. In the meantime, SyncManager will continue to work if the dependency to SyncManager is not removed. The dependency should be deleted once the migration to local caching is completed.
Initialization
There are two ways to initialize the Chat SDK, with local caching or without local caching. During the initialization, the useLocalCaching
determines whether the client app will use local caching with Sendbird Chat SDK or not. Its default value is false meaning the Chat SDK will be initialized without local caching.
In local caching, the InitResultHandler()
is added to the SendBird.init()
method, which receives the initialization status through different event handlers. The onMigrationStarted()
is called when there's a change in the local cache. Meanwhile, the onInitSucceeded()
and the onInitFailed()
informs the client app of whether the initialization is successful or not.
Note: If initialization fails to complete and the
onInitFailed()
is called while theuseLocalCaching
is set to true, Chat SDK will operate as if theuseLocalCaching
is set to false.
Connect to Sendbird server
The difference between local caching and SyncManager in terms of the SendBird.connect()
is whether it is necessary to call the SendBird.connect()
during initialization or not. Both local caching and SyncManager ensure that your client app is operational during offline mode. However, to use the offline mode in SyncManager, calling the SendBird.connect()
during the initialization process was optional. Instead, you only had to call the SyncManager.setup()
after the SendBird.init()
. In local caching, however, calling the SendBird.connect()
after the SendBird.init()
is required during the initialization process.
Group channel collection
A GroupChannelCollection
allows you to swiftly create a channel list without missing any channel-related updates by retrieving group channels from both the local cache and Sendbird server. This page explains how to make a channel list using the collection and serves as a migration guide.
Create a collection
SyncManager's ChannelCollection
is changed to the GroupChannelCollection
in local caching. The GroupChannelCollection
instance can be created through the createGroupChannelCollection()
method.
Create a GroupChannelListQuery
instance through the createMyGroupChannelListQuery()
method and query setters. This will determine the number of channels to retrieve for the channel list.
Channel events
In local caching, the GroupChannelCollectionHandler()
is used to determine how the client app would react to channel-related events. SyncManager's onChannelEvent()
, which is used to handle real-time events, should be changed as shown in the code below.
The following table shows when to call each event handler.
Event | Called when |
---|---|
| - A new group channel is created as a real-time event. |
| - The channel information that is included in the user's current chat view is updated as a real-time event. |
| - A group channel is deleted as a real-time event. |
List channels
SyncManager's fetch()
method retrieves channels from the local cache and delivers them to the ChannelCollectionHandler
instance. In local caching, the GroupChannelCollection
can retrieve channels through two new interfaces, hasMore()
and loadMore()
.
By default, cached channels are listed in reverse chronological order, meaning the channel that most recently received a message appears at the top of the list. The channel order is automatically updated in the local cache when a new message arrives.
Methods | Description |
---|---|
| - Checks if there are more channels to load. |
| - If |
Dispose of the collection
SyncManager's ChannelCollection
has a remove()
method that clears all the channels managed by the collection and stops synchronization process of the collection.
On the other hand, local caching uses the dispose()
method to clear the existing channel list view. This method should be called when the user closes the channel list so the GroupChannelCollectionHandler
won't make any change to the channel list.
Message collection
A MessageCollection
allows you to swiftly create a chat view without missing any message-related updates by retrieving data from both the local cache and Sendbird server. This page explains how to create a chat view using the collection and serves as a migration guide.
Create a collection
In local caching, the MessageListParams
is used instead of SyncManager's MessageFilter
.
A MessageListParams
instance will determine how to sort and order the retrieved messages. Then, specify the starting point of the message list in the chat view using the collection's builder.
Message events
Use the setMessageCollectionHandler()
to determine how the client app would react to message-related events.
A new addition to local caching is onHugeGapDetected
. If more than 300 messages are missing in the local cache compared to the remote server, Sendbird Chat SDK determines that there is a huge gap. For further information, see Gap and synchronization.
The following table shows when to call each event handler.
Handler | Called when |
---|---|
| - A new message is created as a real-time event. |
| - A message is deleted as a real-time event. |
| - A message is updated as a real-time event. |
| - The channel information that is included in the user's current chat view is updated as a real-time event. |
| - The current channel is deleted as a rea-time event. |
| - A huge gap is detected when more than 300 messages are missing in the local cache compared to the remote server. In this case, you need to dispose of the view and create a new |
SyncManager's onSucceededMessageEvent()
,onPendingMessageEvent()
, and onFailedMessageEvent()
should be changed as shown in the code below.
SyncManager's onNewMessage()
used to notify a new message that had arrived should also be changed with the code below.
List messages
SyncManager's fetchSucceededMessages()
method retrieves messages from the local cache and delivers them to the MessageCollectionHandler
instance. In local caching, the MessageCollection
can retrieve and display messages through four new interfaces, hasPrevious()
, hasNext()
, loadPrevious()
, and loadNext()
.
Unlike the GroupChannelCollection
, pagination works in both directions for messages because messages can be shown in either chronological or reverse chronological order depending on how you set the value of startingPoint
.
Method | Description |
---|---|
| - Checks if there are more messages to load from the previous page. |
| - If |
| - Checks if there are more messages to load in the next page. |
| - If |
Policy
In a MessageCollection
, the initialization is dictated by the MessageCollectionInitPolicy
. The MessageCollectionInitPolicy
determines how initialization deals with the message data retrieved from the local cache and API calls. Because we only support the InitPolicy.CACHE_AND_REPLACE_BY_API
at this time, an additional implementation is required to clear the messages in the local cache before adding the messages from the remote server. Messages will first be retrieved from the cached list using the onCacheResult()
. Next, the onApiResult()
calls the API result list which then replaces the cached message list with messages received from the API call.
SyncManager's resetViewpointTimestamp
is used to reset the current message collection to the specified time. To reset a viewpoint timestamp in local caching, it is suggested that you dispose the current message collection and create a new collection.
Send a message
In local caching, the result of sending a message is handled internally through the MessageCollectionHandler
. First, pending messages are delivered to local caching's MessageCollectionHandler.onMessagesAdded()
. Whether the message succeeds or fails in sending, the result will be delivered to the MessageCollectionHandler.onMessagesUpdated()
. Thus, the process of using a onSent()
callback from the sendUserMessage()
and the sendFileMessage()
to manually input the send result in SyncManager is no longer needed.
Note: Don't add the pending, succeeded or failed message objects of the
sendMessage()
callback to your message list data source. This can cause duplicate messages in the chat view.
Resend a failed message
In local caching, the result of resending a message is handled internally through the MessageCollectionHandler
. First, pending messages are delivered to local caching's MessageCollectionHandler.onMessagesUpdated()
. Whether the message has succeeded or failed in sending, the result will be delivered to the MessageCollectionHandler.onMessagesUpdated()
. Thus, the process of using a onSent()
callback from the resendMessage()
to manually input the send result in SyncManager is no longer needed.
Note: Don't add the pending, succeeded or failed message objects of the
resendMessage()
callback to your message list data source. This can cause duplicate messages in the chat view.
Update a message
SyncManager uses the onUpdated()
callback to manually update message in collection after updating the same message in a channel. In local caching, however, updating messages is handled internally and is delivered to the MessageCollectionHandler.onMessagesUpdated()
.
Delete a message
There are two cases in deleting a message:
Deleting a sent message.
In SyncManager, the process of delivering the result of message deletion through the deleteMessage()
was required. However, this process is not needed in local caching.
Deleting a failed message.
The process is the same for both SyncManager and local caching where the failed message object is deleted explicitly from the local cache. In SyncManager, failed messages are deleted through the deleteMessage()
. The same can be done through the removeFailedMessages()
in local caching.
Dispose of the collection
SyncManager's MessageCollection
has a remove()
method that clears all the messages managed by the collection and stops synchronization processes in the collection instance.
On the other hand, local caching uses the dispose()
method to clear the existing chat view. You should call this method when the current user leaves the channel or when a new collection has to be created due to a huge gap detected by the onHugeGapDetected()
.
Other methods
The following are new cache-related interfaces that come with local caching. Local caching's clearCachedData()
replaces the functionality of SyncManager's clearCache()
, which is used to delete the entire data file. In addition, the clearCachedMessages()
and the getCachedDataSize()
is available in local caching. The following table describes each method and when it should be called in regards to the SendBird.init()
.
Method | Description |
---|---|
| - Deletes the entire data file. |
| - Clears cached messages in a specific channel. |
| - Checks for the current cached data size. |
In addition, SyncManager's messageCollection.getMessageCount()
and messageCollection.contains(message)
are replaced with messageCollection.getSucceededMessages()
in local caching. It is used to count the number of succeeded messages in the collection.