예제 #1
0
 public UnityRequestException(UnityMessage errorMessage,
                              [CallerMemberName] string memberName    = "",
                              [CallerFilePath] string sourceFilePath  = "",
                              [CallerLineNumber] int sourceLineNumber = 0)
     : this(null, null, null, errorMessage, memberName, sourceFilePath, sourceLineNumber)
 {
 }
예제 #2
0
        /// <summary>
        /// Tries to find and resolve awaiting outbound request handler.
        /// </summary>
        /// <param name="id">The unity response message.</param>
        private void TryResolveOutboundRequest(UnityMessage unityMessage)
        {
            var uuid = unityMessage.uuid.Value;

            lock (this.stateLock)
            {
                // Response (success or failure) to sent request
                if (this.RemoveOutboundRequest(uuid, out UniTaskCompletionSource <UnityMessage> awaiter))
                {
                    if (unityMessage.IsResponse)
                    {
                        awaiter.TrySetResult(unityMessage);
                    }
                    else if (unityMessage.IsCanceled)
                    {
                        awaiter.TrySetCanceled();
                    }
                    else if (unityMessage.IsError)
                    {
                        awaiter.TrySetException(new UnityRequestException(unityMessage));
                    }
                    else
                    {
                        Debug.unityLogger.LogError("messaging", $"Unknown response message type: {unityMessage.type}", instance);
                    }
                }
                else
                {
                    Debug.unityLogger.LogError("messaging", $"Unknown outbound request to resolve [uuid: {unityMessage.uuid}]", instance);
                }
            }
        }
        /// <summary>
        /// Send serialized message to React Native app (MOCK)
        /// </summary>
        /// <param name="message">The serialized message to send.</param>
        private static void onUnityMessage(string message)
        {
            if (!message.StartsWith(MessagePrefix))
            {
                Debug.unityLogger.Log("messaging", $"Unknown type: {message}");
                return;
            }

            message = message.Substring(MessagePrefix.Length);

            UnityMessage unityMessage = JsonConvert.DeserializeObject <UnityMessage>(message);

            if (unityMessage.IsRequestCompletion)
            {
                Debug.unityLogger.Log("messaging", $"response[{unityMessage.uuid}] {message}");
                if (instance.sentRequests.ContainsKey(unityMessage.uuid.Value))
                {
                    instance.TryResolveOutboundRequest(unityMessage);
                }
                else
                {
                    instance.MOCK_TryResolveInjectedRequest(unityMessage);
                }
            }
            else if (unityMessage.IsCancel)
            {
                Debug.unityLogger.Log("messaging", $"cancel[{unityMessage.uuid}] {message}");
                instance.TryCancelRequest(unityMessage);
            }
            else
            {
                Debug.unityLogger.Log("messaging", $"request[{unityMessage.uuid}] {message}");
                UnityMessageManager.OnMessageSent?.Invoke(instance, unityMessage);
            }
        }
 private UnityRequestException(string message,
                               Exception innerException,
                               UnityMessage errorMessage,
                               [CallerMemberName] string memberName    = "",
                               [CallerFilePath] string sourceFilePath  = "",
                               [CallerLineNumber] int sourceLineNumber = 0)
     : base(message, innerException)
 {
     this.error            = errorMessage;
     this.memberName       = memberName;
     this.sourceFilePath   = sourceFilePath;
     this.sourceLineNumber = sourceLineNumber;
 }
예제 #5
0
 private UnityRequestException(string message,
                               string rawInput,
                               Exception innerException,
                               UnityMessage errorMessage,
                               string memberName     = "",
                               string sourceFilePath = "",
                               int sourceLineNumber  = 0)
     : base(message, innerException)
 {
     this.rawInput         = rawInput;
     this.error            = errorMessage;
     this.memberName       = memberName;
     this.sourceFilePath   = sourceFilePath;
     this.sourceLineNumber = sourceLineNumber;
 }
예제 #6
0
        private void TryCancelRequest(UnityMessage unityMessage)
        {
            var uuid = unityMessage.uuid.Value;

            lock (this.stateLock)
            {
                // Cancellation of received request
                if (this.RemoveIncommingRequest(uuid, out UnityMessageHandlerImpl handler))
                {
                    handler.NotifyCancelled();
                }
                else
                if (this.RemoveOutboundRequest(uuid, out UniTaskCompletionSource <UnityMessage> awaiter))
                {
                    awaiter.TrySetCanceled();
                }
                else
                {
                    Debug.unityLogger.LogError("messaging", $"Unknown request to cancel. [uuid: {uuid}]", this);
                }
            }
        }
예제 #7
0
        private void onRNMessage(string message)
        {
            try
            {
                if (!message.StartsWith(MessagePrefix))
                {
                    Debug.unityLogger.LogWarning("messaging", $"Invalid message format.");
                    return;
                }

                message = message.Substring(MessagePrefix.Length);

                Subscription[] subscriptionList;
                UnityMessage   unityMessage = JsonConvert.DeserializeObject <UnityMessage>(message);
                if (unityMessage.IsRequestCompletion)
                {
                    // Handle as request response/error/cancellation
                    this.TryResolveOutboundRequest(unityMessage);
                }
                else if (unityMessage.IsCancel)
                {
                    // Handle as request cancellation
                    this.TryCancelRequest(unityMessage);
                }
                else
                {
                    lock (this.stateLock)
                    {
                        var args = new UnityMessageHandlerImpl(unityMessage, message);

                        try
                        {
                            // Handle as incomming message or request
                            if (this.subscriptions.TryGetValue(unityMessage.id, out subscriptionList) && subscriptionList.Length > 0)
                            {
                                if (unityMessage.IsRequest)
                                {
                                    // Remember request for incomming cancelation handling
                                    this.AddIncommingRequest(unityMessage.uuid.Value, args);
                                }

                                try
                                {
                                    foreach (Subscription s in subscriptionList)
                                    {
                                        s.handler.Invoke(args);
                                    }
                                }
                                catch (Exception e)
                                {
                                    Debug.unityLogger.LogError("messaging", $"Failed to handle incoming message:\n{e}", this);

                                    if (args.IsRequest && !args.IsDeferred && !args.ResponseSent)
                                    {
                                        args.SendError(e);
                                    }
                                }
                            }
                            else
                            {
                                if (args.IsRequest)
                                {
                                    args.SendError(new ArgumentException("Invalid message ID.", nameof(UnityMessage.id)));
                                }

                                Debug.unityLogger.LogError("messaging", $"Unknown message id: {unityMessage.id}.", this);
                            }
                        }
                        finally
                        {
                            if (!args.IsDeferred)
                            {
                                args.Dispose();
                            }
                        }
                    }
                }
            }
            catch (Exception e)
            {
                Debug.unityLogger.LogError("messaging", $"Failed to parse incoming message:\n{e}", this);
            }
        }
예제 #8
0
 public UnityMessageHandlerImpl(UnityMessage message, string raw)
 {
     this.raw     = raw;
     this.Message = message;
 }
예제 #9
0
 public UnityMessageHandlerImpl(UnityMessage message)
 {
     this.Message = message;
 }