/// <summary> /// Creates and sends plain message type. /// </summary> /// <param name="id">The unity message ID.</param> /// <param name="type">The type of the request.</param> /// <param name="data">The optional request data.</param> private static void SendPlainInternal(string id, int type, object data) { string json = SerializeMessage(id, type, data); CheckMainThreadAccess(); UnityMessageManager.onUnityMessage(MessagePrefix + json); }
/// <summary> /// Creates and sends request message type. /// </summary> /// <param name="id">The unity message ID.</param> /// <param name="uuid">The unique request ID.</param> /// <param name="type">The type of the request.</param> /// <param name="data">The optional request data.</param> private static async UniTask SendRequestInternalAsync(string id, int uuid, int type, object data, CancellationToken cancellationToken) { string json = SerializeRequest(id, uuid, type, data); await MainThreadBoundaryAsync( () => UnityMessageManager.onUnityMessage(MessagePrefix + json), cancellationToken); }
/// <summary> /// Creates cancellation notification message in JSON format. /// </summary> /// <param name="id">The unity message ID.</param> /// <param name="uuid">The unique request ID.</param> private static void SendCanceled(string id, int uuid) { string json = "{" + $"\"{nameof(UnityMessage.id)}\":{JsonConvert.SerializeObject(id)}" + $",\"{nameof(UnityMessage.type)}\":{(int)UnityMessageType.Canceled}" + $",\"{nameof(UnityMessage.uuid)}\":{uuid}" + "}"; CheckMainThreadAccess(); UnityMessageManager.onUnityMessage(MessagePrefix + json); }
static UnityMessageManager() { if (instance == null && !instanceDestroyed) { GameObject go = GameObject.Find(GameObjectName) ?? new GameObject(GameObjectName); UnityEngine.Object.DontDestroyOnLoad(go); instance = go.AddComponent <UnityMessageManager>(); } #if UNITY_WSA && !UNITY_EDITOR && ENABLE_WINMD_SUPPORT RNUnityViewBridge.BridgeBootstrapper.SetIL2CPPBridge(new UnityMessageManager.IL2CPPBridge()); #endif }
/// <summary> /// Creates response message in JSON format. /// </summary> /// <param name="id">The unity message ID.</param> /// <param name="uuid">The unique request ID.</param> /// <param name="data">THe optional response data.</param> private static void SendResponse(string id, int uuid, object data) { string json = "{" + $"\"{nameof(UnityMessage.id)}\":{JsonConvert.SerializeObject(id)}" + $",\"{nameof(UnityMessage.type)}\":{(int)UnityMessageType.Response}" + $",\"{nameof(UnityMessage.uuid)}\":{uuid}" + (data != null ? $",\"{nameof(UnityMessage.data)}\":{JsonConvert.SerializeObject(data)}" : string.Empty) + "}"; CheckMainThreadAccess(); UnityMessageManager.onUnityMessage(MessagePrefix + json); }
/// <summary> /// Creates error message in JSON format. /// </summary> /// <param name="id">The unity message ID.</param> /// <param name="uuid">The unique request ID.</param> /// <param name="error">The optional response data.</param> private static void SendError(string id, int uuid, Exception error) { string json = "{" + $"\"{nameof(UnityMessage.id)}\":{JsonConvert.SerializeObject(id)}" + $",\"{nameof(UnityMessage.type)}\":{(int)UnityMessageType.Error}" + $",\"{nameof(UnityMessage.uuid)}\":{uuid}" + (error != null ? $",\"{nameof(UnityMessage.data)}\":{JsonConvert.SerializeObject(error)}" : string.Empty) + "}"; CheckMainThreadAccess(); UnityMessageManager.onUnityMessage(MessagePrefix + json); }
public void SendCanceled() { if (this.IsRequest) { this.ResponseSent = true; UnityMessageManager.SendCanceled( this.Message.id, this.Message.uuid.Value); } else { Debug.unityLogger.LogError("messaging", "This message is not a request type."); } }
public void SendError(UnityRequestException error) { if (this.IsRequest) { this.ResponseSent = true; UnityMessageManager.SendError( this.Message.id, this.Message.uuid.Value, error); } else { Debug.unityLogger.LogError("messaging", "This message is not a request type."); } }
public void Dispose() { if (this.IsRequest) { instance?.RemoveIncommingRequest(this.Message.uuid.Value); if (!this.ResponseSent) { Debug.unityLogger.LogWarning("messaging", $"Missing request response: id={this.Message.id} type={this.Message.type} uuid={this.Message.uuid.Value}"); this.ResponseSent = true; UnityMessageManager.SendResponse( this.Message.id, this.Message.uuid.Value, null); } } }
public void SendError(UnityRequestException error) { if (this.IsRequest) { this.ResponseSent = true; if (string.IsNullOrEmpty(error.rawInput)) { error.rawInput = this.raw; } Debug.LogError(error); UnityMessageManager.SendError( this.Message.id, this.Message.uuid.Value, error); } else { Debug.unityLogger.LogError("messaging", "This message is not a request type."); } }
private async UniTask <T> InjectInternalAsync <T>(string id, int uuid, int type, object data, CancellationToken cancellationToken) { cancellationToken.ThrowIfCancellationRequested(); var awaiter = new UniTaskCompletionSource <UnityMessage>(); string json = UnityMessageManager.SerializeRequest(id, uuid, type, data); cancellationToken.ThrowIfCancellationRequested(); try { if (type >= (int)UnityMessageType.Request) { this.MOCK_AddInjectedRequest(uuid, awaiter); } UnityMessage unityMessage; using (cancellationToken.Register(() => SendCancel(id, uuid))) { this.onRNMessage(MessagePrefix + json); unityMessage = await awaiter.Task; } if (typeof(T) == typeof(UnityMessage)) { return((T)Convert.ChangeType(unityMessage, typeof(UnityMessage))); } else { return(unityMessage.GetData <T>()); } } finally { this.MOCK_RemoveInjectedRequest(uuid); } }
/// <summary> /// Sends unformatted message to the React Native engine. /// </summary> /// <param name="message">The unformatted message.</param> /// <remarks> /// Message is expected to be in UTF8 encoding. /// </remarks> public static void Send(string message) { CheckMainThreadAccess(); UnityMessageManager.onUnityMessage(message); }
public static UniTask SendAsync <TMessageType>(string id, IUnityMessage <TMessageType> message, CancellationToken cancellationToken = default) where TMessageType : Enum => UnityMessageManager.SendPlainInternalAsync(id, (int)(object)message.Type(), message, cancellationToken);
/// <summary> /// Sends message with data. /// </summary> /// <param name="id">The message id (identifying target).</param> /// <param name="message">The message data.</param> /// <remarks> /// Message format: /// { /// "id": MESSAGE_TARGET_ID, // <paramref name="id" /> /// "type": SERIALIZED_TYPE, // <paramref name="message.Type" /> /// "data": SERIALIZED_DATA, // <paramref name="message" /> /// } /// /// Raw message is automatically prefixed with <see cref="UnityMessageManager.MessagePrefix" /> /// constant to distinguish it from unformatted messages. /// </remarks> public static void Send <TMessageType>(string id, IUnityMessage <TMessageType> message) where TMessageType : Enum { CheckMainThreadAccess(); UnityMessageManager.SendPlainInternal(id, (int)(object)message.Type(), message); }
private void InjectInternal(string id, object data) { string json = UnityMessageManager.SerializeMessage(id, data); this.onRNMessage(MessagePrefix + json); }
public static UniTask SendAsync(string message, CancellationToken cancellationToken = default) { return(MainThreadBoundaryAsync( () => UnityMessageManager.onUnityMessage(message), cancellationToken)); }
public static UniTask SendAsync(string id, int type, object data = null, CancellationToken cancellationToken = default) => UnityMessageManager.SendPlainInternalAsync(id, type, data, cancellationToken);
/// <summary> /// Sends message with optional data. /// </summary> /// <param name="id">The message id (identifying target).</param> /// <param name="data">(optional) The data attached to the message.</param> /// <remarks> /// Message format: /// { /// "id": MESSAGE_TARGET_ID, // <paramref name="id" /> /// "data": SERIALIZED_DATA, // <paramref name="data" /> /// } /// /// Raw message is automatically prefixed with <see cref="UnityMessageManager.MessagePrefix" /> /// constant to distinguish it from unformatted messages. /// </remarks> public static void Send(string id, object data = null) { CheckMainThreadAccess(); UnityMessageManager.SendPlainInternal(id, data); }
private void OnDestroy() { UnityMessageManager.instanceDestroyed = true; UnityMessageManager.instance = null; }