deserializeFromString method

AbstractMessage? deserializeFromString(String jsonMessage)

Converts a string JSON message into a WAMP message object.

Implementation

AbstractMessage? deserializeFromString(String jsonMessage) {
  final singleBinaryPayload = _deserializeSingleBinaryPayloadFromString(
    jsonMessage,
  );
  if (singleBinaryPayload != null) {
    return singleBinaryPayload;
  }
  Object? message = json.decode(jsonMessage);
  if (message is List) {
    int messageId = message[0];
    if (messageId == MessageTypes.codeHello) {
      return Hello(
        message[1] as String?,
        _decodeDetailsMap(
          _normalizeJsonStringKeyMap(message[2] as Map<dynamic, dynamic>),
        ),
      );
    }
    if (messageId == MessageTypes.codeChallenge) {
      final extraMap = message[2] is Map
          ? _normalizeJsonStringKeyMap(message[2] as Map<dynamic, dynamic>)
          : const <String, dynamic>{};
      return Challenge(message[1], Extra.fromMap(extraMap));
    }
    if (messageId == MessageTypes.codeAuthenticate) {
      return Authenticate(signature: message[1] as String?)
        ..extra = message[2] is Map
            ? Map<String, Object?>.from(
                _normalizeJsonStringKeyMap(
                  message[2] as Map<dynamic, dynamic>,
                ),
              )
            : <String, Object?>{};
    }
    if (messageId == MessageTypes.codeWelcome) {
      return Welcome(
        message[1],
        _decodeDetailsMap(
          _normalizeJsonStringKeyMap(message[2] as Map<dynamic, dynamic>),
        ),
      );
    }
    if (messageId == MessageTypes.codeRegister) {
      return Register(
        message[1],
        message[3],
        options: _decodeRegisterOptions(
          message[2] is Map
              ? _normalizeJsonStringKeyMap(
                  message[2] as Map<dynamic, dynamic>,
                )
              : null,
        ),
      );
    }
    if (messageId == MessageTypes.codeUnregister) {
      return Unregister(message[1], message[2]);
    }
    if (messageId == MessageTypes.codeCall) {
      return _addPayload(
        Call(
          message[1],
          message[3],
          options: _decodeCallOptions(
            message[2] is Map
                ? _normalizeJsonStringKeyMap(
                    message[2] as Map<dynamic, dynamic>,
                  )
                : null,
          ),
        ),
        message,
        4,
      );
    }
    if (messageId == MessageTypes.codeYield) {
      return _addPayload(
        Yield(
          message[1],
          options: _decodeYieldOptions(
            message[2] is Map
                ? _normalizeJsonStringKeyMap(
                    message[2] as Map<dynamic, dynamic>,
                  )
                : null,
          ),
        ),
        message,
        3,
      );
    }
    if (messageId == MessageTypes.codePublish) {
      return _addPayload(
        Publish(
          message[1],
          message[3],
          options: _decodePublishOptions(
            message[2] is Map
                ? _normalizeJsonStringKeyMap(
                    message[2] as Map<dynamic, dynamic>,
                  )
                : null,
          ),
        ),
        message,
        4,
      );
    }
    if (messageId == MessageTypes.codeRegistered) {
      return registered_msg.Registered(message[1], message[2]);
    }
    if (messageId == MessageTypes.codeUnregistered) {
      return unregistered_msg.Unregistered(message[1]);
    }
    if (messageId == MessageTypes.codeInvocation) {
      final detailsMap = message[3] as Map<dynamic, dynamic>;
      final caller = detailsMap['caller'];
      final procedure = detailsMap['procedure'];
      final progress = detailsMap['progress'];
      final receiveProgress = detailsMap['receive_progress'];
      final pptScheme = detailsMap['ppt_scheme'];
      final pptSerializer = detailsMap['ppt_serializer'];
      final pptCipher = detailsMap['ppt_cipher'];
      final pptKeyId = detailsMap['ppt_keyid'];
      return _addPayload(
        Invocation(
          message[1],
          message[2],
          InvocationDetails(
              caller,
              procedure,
              receiveProgress,
              pptScheme,
              pptSerializer,
              pptCipher,
              pptKeyId,
              _extractCustomDetails(detailsMap, _invocationDetailKeys),
            )
            ..progress = progress
            ..timeout = detailsMap['timeout'] as int?,
        ),
        message,
        4,
      );
    }
    if (messageId == MessageTypes.codeInterrupt) {
      final optionsMap = message.length > 2 && message[2] is Map
          ? message[2] as Map<dynamic, dynamic>
          : null;
      return interrupt_msg.Interrupt(
        message[1],
        options: optionsMap == null
            ? null
            : (() {
                final options = interrupt_msg.InterruptOptions();
                options.mode = optionsMap['mode'] as String?;
                return options;
              })(),
      );
    }
    if (messageId == MessageTypes.codeCancel) {
      final optionsMap = message.length > 2 && message[2] is Map
          ? message[2] as Map<dynamic, dynamic>
          : null;
      return cancel_msg.Cancel(
        message[1],
        options: optionsMap == null
            ? null
            : (() {
                final options = cancel_msg.CancelOptions();
                options.mode = optionsMap['mode'] as String?;
                return options;
              })(),
      );
    }
    if (messageId == MessageTypes.codeResult) {
      final detailsMap = message[2] as Map<dynamic, dynamic>;
      final progress = detailsMap['progress'];
      final pptScheme = detailsMap['ppt_scheme'];
      final pptSerializer = detailsMap['ppt_serializer'];
      final pptCipher = detailsMap['ppt_cipher'];
      final pptKeyId = detailsMap['ppt_keyid'];
      return _addPayload(
        Result(
          message[1],
          ResultDetails(
            progress: progress,
            pptScheme: pptScheme,
            pptSerializer: pptSerializer,
            pptCipher: pptCipher,
            pptKeyId: pptKeyId,
            custom: _extractCustomDetails(detailsMap, _resultDetailKeys),
          ),
        ),
        message,
        3,
      );
    }
    if (messageId == MessageTypes.codePublished) {
      return Published(message[1], message[2]);
    }
    if (messageId == MessageTypes.codeSubscribe) {
      return Subscribe(
        message[1],
        message[3],
        options: _decodeSubscribeOptions(
          message[2] is Map
              ? _normalizeJsonStringKeyMap(
                  message[2] as Map<dynamic, dynamic>,
                )
              : null,
        ),
      );
    }
    if (messageId == MessageTypes.codeSubscribed) {
      return Subscribed(message[1], message[2]);
    }
    if (messageId == MessageTypes.codeUnsubscribe) {
      return Unsubscribe(message[1], message[2]);
    }
    if (messageId == MessageTypes.codeUnsubscribed) {
      return Unsubscribed(
        message[1],
        message.length == 2
            ? null
            : UnsubscribedDetails(
                message[2]['subscription'],
                message[2]['reason'],
              ),
      );
    }
    if (messageId == MessageTypes.codeEvent) {
      final detailsMap = message[3] as Map<dynamic, dynamic>;
      final publisher = detailsMap['publisher'];
      final trustlevel = detailsMap['trustlevel'];
      final topic = detailsMap['topic'];
      final pptScheme = detailsMap['ppt_scheme'];
      final pptSerializer = detailsMap['ppt_serializer'];
      final pptCipher = detailsMap['ppt_cipher'];
      final pptKeyId = detailsMap['ppt_keyid'];
      return _addPayload(
        Event(
          message[1],
          message[2],
          EventDetails(
            publisher: publisher,
            trustlevel: trustlevel,
            topic: topic,
            pptScheme: pptScheme,
            pptSerializer: pptSerializer,
            pptCipher: pptCipher,
            pptKeyid: pptKeyId,
            custom: _extractCustomDetails(detailsMap, _eventDetailKeys),
          ),
        ),
        message,
        4,
      );
    }
    if (messageId == MessageTypes.codeError) {
      return _addPayload(
        Error(
          message[1],
          message[2],
          _normalizeJsonStringKeyMap(message[3] as Map<dynamic, dynamic>),
          message[4],
        ),
        message,
        5,
      );
    }
    if (messageId == MessageTypes.codeAbort) {
      final details = message.length > 1 && message[1] != null
          ? _normalizeJsonStringKeyMap(message[1] as Map<dynamic, dynamic>)
          : <String, Object?>{};
      final reason = message.length > 2 ? message[2] as String : '';
      List<dynamic>? arguments;
      Map<String, Object?>? argumentsKeywords;
      if (message.length > 3 && message[3] != null) {
        arguments = List<dynamic>.from(message[3] as List);
      }
      if (message.length > 4 && message[4] != null) {
        argumentsKeywords = Map<String, Object?>.from(
          message[4] as Map<String, dynamic>,
        );
      }
      final messageText = details['message'] as String?;
      return Abort(
        reason,
        details: details,
        message: messageText,
        arguments: arguments,
        argumentsKeywords: argumentsKeywords,
      );
    }
    if (messageId == MessageTypes.codeGoodbye) {
      return Goodbye(
        _decodeGoodbyeMessage(
          message.length > 1 && message[1] is Map
              ? message[1] as Map<dynamic, dynamic>
              : null,
        ),
        message[2],
      );
    }
  }
  _logger.shout('Could not deserialize the message: $jsonMessage');
  // TODO respond with an error
  return null;
}