Collection migration guide

const filter = new GroupChannelfilter();
filter.includeEmpty = true;

const groupChannelCollection = sb.groupChannel.createGroupChannelCollection({
  filter,
  order: GroupChannelListOrder.LATEST_LAST_MESSAGE,
});

// Check whether there are more channels to load before calling loadMore().
if (groupChannelCollection.hasMore) {
  const moreGroupChannels = await groupChannelCollection.loadMore();
  // use received channels or groupChannelcollection.channels
}

const query = sb.groupChannel.createMyGroupChannelListQuery({
  includeEmpty: true,
  order: GroupChannelListOrder.LATEST_LAST_MESSAGE,
  ...
});


const channels = await query.next();

groupChannelCollection.setGroupChannelCollectionHandler({
  onChannelsAdded: (context, channels) => {
    ...
  },
  onChannelsUpdated: (context, channels) => {
    // `updatedChannels` carries latest typing status and last message for channels that have had updates.
  },
  onChannelsDeleted: (context, channels) => {
    ...
  }
});

const groupChannelHandler = new GroupChannelHandler({
  ...
  onTypingStatusUpdated: (channel) => {
    // update channel
  }
  ...
});

sb.groupChannel.addGroupChannelHandler(EVENT_KEY, groupChannelHandler);

groupChannelCollection.setGroupChannelCollectionHandler({
  onChannelsAdded: (context, channels) => {
    ...
  },
  onChannelsUpdated: (context, channels) => {
    if (context.source === GroupChannelEventSource.EVENT_CHANNEL_TYPING_STATUS_UPDATE) {
      // update typing status.
    }
  },
  onChannelsDeleted: (context, channels) => {
    ...
  }
});

groupChannelCollection.setGroupChannelCollectionHandler({
  onChannelsAdded: (context, channels) => {
    if (context.source === GroupChannelEventSource.SYNC_CHANNEL_CHANGELOGS) {
      // add channels
    }
  },
  onChannelsUpdated: (context, channels) => {
    if (context.source === GroupChannelEventSource.SYNC_CHANNEL_CHANGELOGS) {
      // update channels
    }
  },
  onChannelsDeleted: (context, channels) => {
    if (context.source === GroupChannelEventSource.SYNC_CHANNEL_CHANGELOGS) {
      // delete channels
    }
  }
});

const connectionHandler = new ConnectionHandler();

handler.onReconnectSucceeded = () => {
  const channelChangelogs = await sb.groupChannel.getMyGroupChannelChangeLogsByTimestamp(TIMESTAMP);

  const updatedChannels = channelChangelogs.updatedChannels;
  // update channels using updatedChannels

  const deletedChannelUrls = channelChangelogs.deletedChannelUrls;
  // delete channels using deletedChannels

  const hasMore = channelChangelogs.hasMore;
  const token = channelChangelogs.token;
};
...
sendbird.addConnectionHandler(EVENT_KEY, handler);

const filter = new MessageFilter();
const limit = 100;
const startingPoint = Date.now();
const collection = channel.createMessageCollection({
    filter,
    limit,
    startingPoint,
});
collection.initialize(MessageCollectionInitPolicy.CACHE_AND_REPLACE_BY_API)
  .onCacheResult((err, messages) => {
      // Messages are retrieved from the local cache.
      // They might be too outdated or far from the startingPoint.
  })
  .onApiResult((err, messages) => {
      // Messages are retrieved from the Sendbird server through API.
      // According to MessageCollectionInitPolicy.CACHE_AND_REPLACE_BY_API,
      // the existing data source needs to be cleared
      // before adding retrieved messages to the local cache.
  });

// ...

if (messageCollection.hasNext) {
  const nextMessages = await messageCollection.loadNext();
}

if (messageCollection.hasPrevious) {
  const prevMessages = await messageCollection.loadPrevious();
}

const messages = await groupChannel.getMessagesByTimestamp(TimeStamp, {
  prevResultSize: prevSize,
  nextResultSize: nextSize,
});
    
// A list of previous and next messages of a specified timestamp is successfully retrieved.
// Through the messages returned,
// you can access and display the data of each message from the result list.

const messages = await groupChannel.getMessagesByMessageId(messageId, {
  prevResultSize: prevSize,
  nextResultSize: nextSize,
});

// A list of previous and next messages of a specified message ID is successfully retrieved.
// Through the messages returned,
// you can access and display the data of each message from the result list.

groupChannel.setMessagecollectionHandler({
  onChannelUpdated: (context, channel) => {
    // update channel with latest member data.
  },
  ...
})

const groupChannelHandler = new GroupChannelHandler({
  ...
  onUserJoined: (channel, user) => {
    // update channel with latest member data.
  },
  onUserLeft: (channel, user) => {
    // update channel with latest member data.
  },
  ...
});

sb.groupChannel.addGroupChannelHandler(EVENT_KEY, groupChannelHandler);

groupChannel.setMessagecollectionHandler({
  onChannelUpdated: (context, channel) => {
    // update channel with latest member data.
    switch(context.source) {
      case GroupChannelEventSource.EVENT_CHANNEL_JOINED:
        // update channel with latest member data.
      break;
      case GroupChannelEventSource.EVENT_CHANNEL_LEFT:
        // update channel with latest member data.
      break;
    }
  },
  ...
})

groupChannel.sendUserMessage({
  message: 'hello',
});

groupChannel.setMessageCollectionHandler({
  ...
  onMessagesAdded: (context, channel, messages) => {
    switch(context.source) {
      case MessageEventSource.EVENT_MESSAGE_SENT_PENDING:
        // add pending message to View
      break;
    }
  },
  onMessagesUpdated: (context, channel, messages) => {
    switch(context.source) {
      case MessageEventSource.EVENT_MESSAGE_SENT_SUCCESS:
        // message sent successfully
      break;
      case MessageEventSource.EVENT_MESSAGE_SENT_FAILED:
        // Failed to message sent
      break;
      case MessageEventSource.LOCAL_MESSAGE_CANCELED:
        // Cancel message sending
      break;
      case MessageEventSource.LOCAL_MESSAGE_FAILED:
        // Auto-Resend Fail.
      break;
      case MessageEventSource.LOCAL_MESSAGE_RESEND_STARTED:
        // Resend Start
      break;
    }
  },
  ...
})

groupChannel.sendUserMessage({
  message: 'hello',
})
.onPending((message) => {
  // Add the view with the pending message.
})
.onSucceeded((message) => {
  // message is successfully sent.
  // Update the view with the succeeded message.
})
.onFailed((error, failedMessage) => {
  // message failed to be sent, handle error 
});

groupChannel.setMessageCollectionHandler({
  ...
  onMessagesUpdated: (context, channel, messages) => {
    // update message
  },
  ...
})

const groupChannelHandler = new GroupChannelHandler({
  ...
  onMessageUpdated: (channel, message) => {
    // update message
  },
  onReactionUpdated: (channel, reactionEvent) => {
    // update message Reaction
  },
  onPollUpdated:(channel, event) => {
    // update poll
  }
  ...
});

sb.groupChannel.addGroupChannelHandler(EVENT_KEY, groupChannelHandler);

groupChannel.setMessageCollectionHandler({
  ...
  onMessagesUpdated: (context, channel, messages) => {
    switch(context.source) {
      case MessageEventSource.EVENT_POLL_UPDATED:
        // update poll
      break;
    }
  },
  ...
})

// Previously, you needed to call channel.refresh() manually upon reconnection.

const connectionHandler = new ConnectionHandler();
handler.onReconnectSucceeded = () => {
  const refreshedChannel = await groupChannel.refresh();
};
...
sendbird.addConnectionHandler(EVENT_KEY, handler);

groupChannel.setMessageCollectionHandler({
  ...
  onMessagesAdded: (context, channel, messages) => {
    switch(context.source) {
      case MessageEventSource.SYNC_MESSAGE_CHANGELOGS:
        // add messages
      break;
    }
  },
  onMessagesUpdated: (context, channel, messages) => {
    switch(context.source) {
      case MessageEventSource.SYNC_MESSAGE_CHANGELOGS:
        // update messages
      break;
    }
  },
  onMessagesDeleted: (
    context,
    channel,
    messageIds,
    messages) => {
    switch(context.source) {
      case MessageEventSource.SYNC_MESSAGE_CHANGELOGS:
        // delete messages
        // It is recommended to use messages not messageIds to delete messages.
      break;
    }
  },
});

const connectionHandler = new ConnectionHandler();

handler.onReconnectSucceeded = () => {
  const messageChangeLogs = await groupChannel.getMessageChangeLogsSinceToken(TOKEN, {
    replyType: REPLY_TYPE,
    includeParentMessageInfo: INCLUDE_PARENT_MESSAGE_INFO,
    includeThreadInfo: INCLUDE_THREAD_INFO,
  });

  const updatedMessages = messageChangeLogs.updatedMessages;
  // update message

  const deletedMessageIds = messageChangeLogs.deletedMessageIds;
  // delete message

  const hasMore = messageChangeLogs.hasMore;
  const token = messageChangeLogs.token;

  --- or ---

  const messageChangeLogs = await groupChannel.getMessageChangeLogsSinceTimestamp(TIMESTAMP, {
    replyType: REPLY_TYPE,
    includeParentMessageInfo: INCLUDE_PARENT_MESSAGE_INFO,
    includeThreadInfo: INCLUDE_THREAD_INFO,
  });

  const updatedMessages = messageChangeLogs.updatedMessages;
  // update message

  const deletedMessageIds = messageChangeLogs.deletedMessageIds;
  // delete message

  const hasMore = messageChangeLogs.hasMore;
  const token = messageChangeLogs.token;
};