public static void Emit(string eventType, object[] args, int targetId = -1, EventDataSerialization eventDataSerialization = EventDataSerialization.JsonUtility)
{
const bool notifyWildcard = true;
var req = CreateRequest(k_EventMsg, eventType, targetId, -1, args, eventDataSerialization);
// TODO: do we want to ensure that all local listeners received json as payload? This means we could recycle handlers... If so we need to serialize/deserialize... ugly. real ugly...
var reqStr = Json.Serialize(req);
var reqJson = Json.Deserialize(reqStr) as Dictionary <string, object>;
object dataInfos = null;
reqJson.TryGetValue("dataInfos", out dataInfos);
var data = GetDataArray(reqJson["data"], dataInfos);
NotifyLocalListeners(eventType, data, notifyWildcard);
m_Client.Send(reqStr);
}
internal static object[] CreateDataInfosAndFormatDataForSerialization(object[] args, EventDataSerialization eventDataSerialization)
{
if (eventDataSerialization == EventDataSerialization.StandardJson)
{
return(null);
}
// if the data is null we still send an empty dataInfo to know it uses JsonUtility (useful on a request to keep that info when sending answer)
if (args == null)
{
return new object[] {}
}
;
List <object> dataInfos = new List <object>();
for (int i = 0; i < args.Length; i++)
{
if (args[i] == null)
{
continue;
}
var dataString = JsonUtility.ToJson(args[i]);
if (!string.IsNullOrEmpty(dataString) && dataString != "{}" && args[i].GetType().IsSerializable)
{
// add index and class type in the info
dataInfos.Add(new object[2] {
i, args[i].GetType().AssemblyQualifiedName
});
// format the object
args[i] = dataString;
}
}
return(dataInfos.ToArray());
}
internal static Dictionary <string, object> CreateRequest(string msgType, string eventType, int targetId, int?requestId, object[] args, EventDataSerialization eventDataSerialization)
{
var dataInfos = CreateDataInfosAndFormatDataForSerialization(args, eventDataSerialization);
return(CreateRequest(msgType, eventType, targetId, requestId, args, dataInfos));
}
public static void Request(string eventType, Action <Exception, object[]> promiseHandler, object[] args, long timeoutInMs = k_RequestDefaultTimeout, EventDataSerialization eventDataSerialization = EventDataSerialization.JsonUtility)
{
RequestData request;
if (s_Requests.TryGetValue(eventType, out request))
{
request.promises.Add(promiseHandler);
return;
}
request = new RequestData {
eventType = eventType, promises = new List <Action <Exception, object[]> >(1), timeoutInMs = timeoutInMs
};
request.promises.Add(promiseHandler);
if (HasHandlers(eventType))
{
var results = NotifyLocalListeners(eventType, args, false);
var exception = results.FirstOrDefault(r => r is Exception);
if (exception != null)
{
Reject(request, exception as Exception);
}
else
{
if (results.Length == 1)
{
Resolve(request, results);
}
else
{
Resolve(request, results);
}
}
}
else
{
request.offerStartTime = Stopwatch.GetTimestamp();
var requestId = m_Client.NewRequestId();
request.id = requestId;
var msg = CreateRequest(k_RequestMsg, eventType, -1, requestId, args, eventDataSerialization);
m_Client.Send(Json.Serialize(msg));
s_Requests.Add(eventType, request);
request.data = Json.Serialize(msg["data"]);
request.dataInfos = (object[])msg["dataInfos"];
}
}
public static void Request(string eventType, Action <Exception, object[]> promiseHandler, object args = null, long timeoutInMs = k_RequestDefaultTimeout, EventDataSerialization eventDataSerialization = EventDataSerialization.JsonUtility)
{
if (args == null)
{
Request(eventType, promiseHandler, null, timeoutInMs, eventDataSerialization);
}
else
{
Request(eventType, promiseHandler, new object[] { args }, timeoutInMs, eventDataSerialization);
}
}
public static void Emit(string eventType, object args = null, int targetId = -1, EventDataSerialization eventDataSerialization = EventDataSerialization.JsonUtility)
{
if (args == null)
{
Emit(eventType, null, targetId, eventDataSerialization);
}
else
{
Emit(eventType, new object[] { args }, targetId, eventDataSerialization);
}
}
