/// <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;
}
