initializetestmessageStream static method

dynamic initializetestmessageStream()

Implementation

static initializetestmessageStream() {
  nativeStream = eventStreamChannel.receiveBroadcastStream(1).map((e) {
    WidgetsBinding.instance.addPostFrameCallback((_) {
      switch (e["methodName"]) {
      ///Mark -- Message Listeners
        case "onTextMessageReceived":
          BaseMessage receivedMessage = BaseMessage.fromMap(e);
          _messageListeners.values.forEach((element) {
            element.onTextMessageReceived(receivedMessage as TextMessage);
          });
          break;

        case "onMediaMessageReceived":
          BaseMessage receivedMessage = BaseMessage.fromMap(e);
          _messageListeners.values.forEach((element) {
            element.onMediaMessageReceived(receivedMessage as MediaMessage);
          });
          break;

        case "onTypingStarted":
          TypingIndicator typingIndicator = TypingIndicator.fromMap(e);
          _messageListeners.values.forEach((element) {
            element.onTypingStarted(typingIndicator);
          });
          break;

        case "onTypingEnded":
          TypingIndicator typingIndicator = TypingIndicator.fromMap(e);
          _messageListeners.values.forEach((element) {
            element.onTypingEnded(typingIndicator);
          });
          break;

        case "onMessagesDelivered":
          MessageReceipt messageReceipt = MessageReceipt.fromMap(e);
          _messageListeners.values.forEach((element) {
            element.onMessagesDelivered(messageReceipt);
          });
          break;

        case "onMessagesRead":
          MessageReceipt messageReceipt = MessageReceipt.fromMap(e);
          _messageListeners.values.forEach((element) {
            element.onMessagesRead(messageReceipt);
          });
          break;

        case "onMessagesDeliveredToAll":
          MessageReceipt messageReceipt = MessageReceipt.fromMap(e);
          _messageListeners.values.forEach((element) {
            element.onMessagesDeliveredToAll(messageReceipt);
          });
          break;

        case "onMessagesReadByAll":
          MessageReceipt messageReceipt = MessageReceipt.fromMap(e);
          _messageListeners.values.forEach((element) {
            element.onMessagesReadByAll(messageReceipt);
          });
          break;

        case "onMessageEdited":
          BaseMessage receivedMessage = BaseMessage.fromMap(e);
          _messageListeners.values.forEach((element) {
            element.onMessageEdited(receivedMessage);
          });
          break;

        case "onMessageDeleted":
          BaseMessage receivedMessage = BaseMessage.fromMap(e);
          _messageListeners.values.forEach((element) {
            element.onMessageDeleted(receivedMessage);
          });
          break;

        case "onTransientMessageReceived":
          TransientMessage receivedMessage = TransientMessage.fromMap(e);
          _messageListeners.values.forEach((element) {
            element.onTransientMessageReceived(receivedMessage);
          });
          break;

        case "onCustomMessageReceived":
          CustomMessage receivedMessage = CustomMessage.fromMap(e);
          _messageListeners.values.forEach((element) {
            element.onCustomMessageReceived(receivedMessage);
          });
          break;
        case "onInteractiveMessageReceived":
          InteractiveMessage receivedMessage = InteractiveMessage.fromMap(e);
          _messageListeners.values.forEach((element) {
            element.onInteractiveMessageReceived(receivedMessage);
          });
          break;
        case "onInteractionGoalCompleted":
          InteractionReceipt receipt = InteractionReceipt.fromMap(e);
          _messageListeners.values.forEach((element) {
            element.onInteractionGoalCompleted(receipt);
          });
          break;

      ///Mark -- User Listeners
        case "onUserOnline":
          User user = User.fromMap(e);
          _userListeners.values.forEach((element) {
            element.onUserOnline(user);
          });
          break;

        case "onUserOffline":
          User user = User.fromMap(e);
          _userListeners.values.forEach((element) {
            element.onUserOffline(user);
          });
          break;

      ///Mark -- Group Listeners
        case "onGroupMemberJoined":
          action_import.Action action =
          action_import.Action.fromMap(e["action"]);
          User joinedUser = User.fromMap(e["joinedUser"]);
          Group joinedGroup = Group.fromMap(e["joinedGroup"]);
          _groupListeners.values.forEach((element) {
            element.onGroupMemberJoined(action, joinedUser, joinedGroup);
          });
          break;

        case "onGroupMemberLeft":
          action_import.Action action =
          action_import.Action.fromMap(e["action"]);
          User leftUser = User.fromMap(e["leftUser"]);
          Group leftGroup = Group.fromMap(e["leftGroup"]);
          _groupListeners.values.forEach((element) {
            element.onGroupMemberLeft(action, leftUser, leftGroup);
          });
          break;

        case "onGroupMemberKicked":
          action_import.Action action =
          action_import.Action.fromMap(e["action"]);
          User kickedUser = User.fromMap(e["kickedUser"]);
          User kickedBy = User.fromMap(e["kickedBy"]);
          Group kickedFrom = Group.fromMap(e["kickedFrom"]);
          _groupListeners.values.forEach((element) {
            element.onGroupMemberKicked(
                action, kickedUser, kickedBy, kickedFrom);
          });
          break;

        case "onGroupMemberBanned":
          action_import.Action action =
          action_import.Action.fromMap(e["action"]);
          User bannedUser = User.fromMap(e["bannedUser"]);
          User bannedBy = User.fromMap(e["bannedBy"]);
          Group bannedFrom = Group.fromMap(e["bannedFrom"]);
          _groupListeners.values.forEach((element) {
            element.onGroupMemberBanned(
                action, bannedUser, bannedBy, bannedFrom);
          });
          break;

        case "onGroupMemberUnbanned":
          action_import.Action action =
          action_import.Action.fromMap(e["action"]);
          User unbannedUser = User.fromMap(e["unbannedUser"]);
          User unbannedBy = User.fromMap(e["unbannedBy"]);
          Group unbannedFrom = Group.fromMap(e["unbannedFrom"]);
          _groupListeners.values.forEach((element) {
            element.onGroupMemberUnbanned(
                action, unbannedUser, unbannedBy, unbannedFrom);
          });
          break;

        case "onGroupMemberScopeChanged":
          action_import.Action action =
          action_import.Action.fromMap(e["action"]);
          User updatedBy = User.fromMap(e["updatedBy"]);
          User updatedUser = User.fromMap(e["updatedUser"]);
          String scopeChangedTo = e["scopeChangedTo"];
          String scopeChangedFrom = e["scopeChangedFrom"];
          Group group = Group.fromMap(e["group"]);
          _groupListeners.values.forEach((element) {
            element.onGroupMemberScopeChanged(action, updatedBy, updatedUser,
                scopeChangedTo, scopeChangedFrom, group);
          });
          break;

        case "onMemberAddedToGroup":
          action_import.Action action =
          action_import.Action.fromMap(e["action"]);
          User addedby = User.fromMap(e["addedby"]);
          User userAdded = User.fromMap(e["userAdded"]);
          Group addedTo = Group.fromMap(e["addedTo"]);
          _groupListeners.values.forEach((element) {
            element.onMemberAddedToGroup(action, addedby, userAdded, addedTo);
          });
          break;

      ///Mark -- Login Listeners
        case "loginSuccess":
          User user = User.fromMap(e);
          _loginListeners.values.forEach((element) {
            element.loginSuccess(user);
          });
          break;

        case "loginFailure":
          CometChatException excep = CometChatException.fromMap(e);
          _loginListeners.values.forEach((element) {
            element.loginFailure(excep);
          });
          break;

        case "logoutSuccess":
          _loginListeners.values.forEach((element) {
            element.logoutSuccess();
          });
          break;

        case "logoutFailure":
          CometChatException excep = CometChatException.fromMap(e);
          _loginListeners.values.forEach((element) {
            element.loginFailure(excep);
          });
          break;

      ///Mark -- Connection Listeners
        case "onConnected":
          _connectionListeners.values.forEach((element) {
            element.onConnected();
          });
          break;

        case "onConnecting":
          _connectionListeners.values.forEach((element) {
            element.onConnecting();
          });
          break;

        case "onDisconnected":
          _connectionListeners.values.forEach((element) {
            element.onDisconnected();
          });
          break;

        case "onFeatureThrottled":
          _connectionListeners.values.forEach((element) {
            element.onFeatureThrottled();
          });
          break;

        case "onConnectionError":
          _connectionListeners.values.forEach((element) {
            CometChatException error = CometChatException.fromMap(e["error"]);
            element.onConnectionError(error);
          });
          break;

      ///Call-SDK-changes
        case "onIncomingCallReceived":
          _callListener.values.forEach((element) {
            Call call = Call.fromMap(e["call"]);
            element.onIncomingCallReceived(call);
          });
          break;

        case "onOutgoingCallAccepted":
          _callListener.values.forEach((element) {
            Call call = Call.fromMap(e["call"]);
            element.onOutgoingCallAccepted(call);
          });
          break;

        case "onOutgoingCallRejected":
          _callListener.values.forEach((element) {
            Call call = Call.fromMap(e["call"]);
            element.onOutgoingCallRejected(call);
          });
          break;

        case "onIncomingCallCancelled":
          _callListener.values.forEach((element) {
            Call call = Call.fromMap(e["call"]);
            element.onIncomingCallCancelled(call);
          });
          break;

        case "onCallEndedMessageReceived":
          _callListener.values.forEach((element) {
            Call call = Call.fromMap(e["call"]);
            element.onCallEndedMessageReceived(call);
          });
          break;

      ///Reactions
        case "onMessageReactionAdded":
          _messageListeners.values.forEach((element) {
            ReactionEvent reactionEvent =
            ReactionEvent.fromMap(e["reactionEvent"]);
            element.onMessageReactionAdded(reactionEvent);
          });
          break;

        case "onMessageReactionRemoved":
          _messageListeners.values.forEach((element) {
            ReactionEvent reactionEvent =
            ReactionEvent.fromMap(e["reactionEvent"]);
            element.onMessageReactionRemoved(reactionEvent);
          });
          break;
      }
    });
  });
}