initialize method

Future<void> initialize()

Initializes this collection from startingPoint.

Implementation

Future<void> initialize() async {
  if (_isDisposed) throw InvalidCollectionDisposedException();
  if (_isInitialized) throw InvalidInitializationException();

  sbLog.i(StackTrace.current, 'initialize()');
  _isInitialized = true;

  //+ [DBManager]
  if (_chat.dbManager.isEnabled()) {
    _oldestSyncedTimestamp = null;
    _latestSyncedTimestamp = null;
  }
  //- [DBManager]

  //+ [DBManager]
  bool isCacheHit = false;
  final List<RootMessage> localMessages = [];

  if (_chat.dbManager.isEnabled()) {
    final localInitializeParams = MessageListParams()
      ..copyWith(_initializeParams);

    final localPreviousMessages = await _chat.dbManager.getMessages(
      channelType: _channel.channelType,
      channelUrl: _channel.channelUrl,
      sendingStatus: SendingStatus.succeeded,
      timestamp: _startingPoint,
      params: localInitializeParams..inclusive = false,
      isPrevious: true,
    );

    List<RootMessage> localStartingPointMessages = [];
    if (_initializeParams.inclusive) {
      final messages = await _chat.dbManager.getStartingPointMessages(
        channelType: _channel.channelType,
        channelUrl: _channel.channelUrl,
        timestamp: _startingPoint,
      );
      localStartingPointMessages.addAll(messages);
    }

    final localNextMessages = await _chat.dbManager.getMessages(
      channelType: _channel.channelType,
      channelUrl: _channel.channelUrl,
      sendingStatus: SendingStatus.succeeded,
      timestamp: _startingPoint,
      params: localInitializeParams..inclusive = false,
      isPrevious: false,
    );

    if (_initializeParams.reverse) {
      localMessages.addAll(localNextMessages);
      localMessages.addAll(localStartingPointMessages);
      localMessages.addAll(localPreviousMessages);
    } else {
      localMessages.addAll(localPreviousMessages);
      localMessages.addAll(localStartingPointMessages);
      localMessages.addAll(localNextMessages);
    }

    isCacheHit = await _chat.dbManager.isCacheHit(
      collection: this,
      params: _initializeParams,
      localMessages: localMessages,
      lastSyncedTimeStamp: null,
      loadType: MessageCollectionLoadType.initialize,
    );

    _setValuesForInitialize(
        messages: localMessages, noMoreApiCall: isCacheHit);

    if (localMessages.isNotEmpty) {
      await _chat.collectionManager.sendEventsToMessageCollection(
        messageCollection: this,
        baseChannel: _channel,
        eventSource: CollectionEventSource.messageCacheInitialize,
        sendingStatus: SendingStatus.succeeded,
        addedMessages: localMessages,
        isReversedAddedMessages: _initializeParams.reverse,
      );
    }

    //+ Failed messages
    final failedMessages = await _chat.dbManager.getFailedMessages(
      channelType: _channel.channelType,
      channelUrl: _channel.channelUrl,
      reverse: _initializeParams.reverse,
    );

    if (failedMessages.isNotEmpty) {
      await _chat.collectionManager.sendEventsToMessageCollection(
        messageCollection: this,
        baseChannel: _channel,
        eventSource: CollectionEventSource.messageCacheInitialize,
        sendingStatus: SendingStatus.failed,
        addedMessages: failedMessages,
        isReversedAddedMessages: _initializeParams.reverse,
      );
    }
    //- Failed messages

    _initializeParams.includeMetaArray = true;
    _initializeParams.includeReactions = true;
    _initializeParams.includeThreadInfo = true;
    _initializeParams.includeParentMessageInfo = true;
  }
  //- [DBManager]

  List<RootMessage> messages = [];
  ChannelMessagesGetResponse? res;
  Object? exception;

  if (isCacheHit == false) {
    try {
      res = await _chat.apiClient
          .send<ChannelMessagesGetResponse>(ChannelMessagesGetRequest(
        _chat,
        channelType: ChannelType.group,
        channelUrl: _channel.channelUrl,
        params: _initializeParams.toJson(),
        timestamp: _startingPoint,
        checkingHasNext: true,
        checkingContinuousMessages:
            _chat.dbManager.isEnabled(), // [DBManager]
      ));

      messages.addAll(res.messages);
    } catch (e) {
      exception = e;
    }
  }

  if (_isDisposed) {
    if (exception != null && !_chat.apiClient.throwExceptionForTest) {
      if (_chat.dbManager.isEnabled() == false) {
        throw exception;
      }
    }
    return;
  }

  if (res != null) {
    _setValuesForInitialize(messages: messages, noMoreApiCall: true);
  }

  if (res?.hasNext != null) _hasNext = res!.hasNext!;

  if (messages.isNotEmpty) {
    //+ [DBManager]
    if (_chat.dbManager.isEnabled()) {
      final List<RootMessage> addedMessages = [...messages];
      final Set<String> deletedMessageIds = messageList
          .where((message) {
            if (message is BaseMessage &&
                message.sendingStatus == SendingStatus.succeeded) {
              return true;
            }
            return false;
          })
          .map((message) => message.rootId)
          .toSet();

      await _chat.collectionManager.sendEventsToMessageCollection(
        messageCollection: this,
        baseChannel: _channel,
        eventSource: CollectionEventSource.messageInitialize,
        sendingStatus: SendingStatus.succeeded,
        addedMessages: addedMessages,
        isReversedAddedMessages: _initializeParams.reverse,
        isContinuousAddedMessages: (_channel.channelType == ChannelType.feed)
            ? true
            : (res?.isContinuous ?? false),
        deletedMessageIds: deletedMessageIds.toList(),
      );
    }
    //- [DBManager]
    else {
      await _chat.collectionManager.sendEventsToMessageCollection(
        messageCollection: this,
        baseChannel: _channel,
        eventSource: CollectionEventSource.messageInitialize,
        sendingStatus: SendingStatus.succeeded,
        addedMessages: messages,
        isReversedAddedMessages: _initializeParams.reverse,
      );
    }
  }

  if (exception != null && !_chat.apiClient.throwExceptionForTest) {
    if (_chat.dbManager.isEnabled() == false) {
      throw exception;
    }
  }
}