private Emitter MetReq(RTMethodRequest methodRequest)
{
Emitter emitter = connectionManager.Socket.Emit("MET_REQ", WeborbSerializationHelper.Serialize(methodRequest.ToArgs()));
Log.log(Backendless.BACKENDLESSLOG, "metReq called");
return(emitter);
}
private Emitter SubOff(String subscriptionId)
{
Emitter emitter = connectionManager.Socket.Emit("SUB_OFF", WeborbSerializationHelper.Serialize(subscriptionId));
Log.log(Backendless.BACKENDLESSLOG, "subOff called");
return(emitter);
}
private Emitter SubOn(RTSubscription subscription)
{
Emitter emitter = connectionManager.Socket.Emit("SUB_ON", WeborbSerializationHelper.Serialize(subscription.ToArgs()));
Log.log(Backendless.BACKENDLESSLOG, "subOn called");
return(emitter);
}
public void AddMessageListener <T>(string selector, MessageReceived <T> callback)
{
IRTCallback rtCallback = new RTCallback <T>((Delegate)callback, result =>
{
try
{
IAdaptingType message;
if (!typeof(T).Equals(typeof(Message)))
{
message = WeborbSerializationHelper.AsAdaptingType(result, "message");
}
else
{
message = result;
}
T adaptedResponse = (T)message.adapt(typeof(T));
callback(adaptedResponse);
}
catch (System.Exception ex)
{
ErrorHandler?.Invoke(RTErrorType.MESSAGELISTENER, new Exception.BackendlessFault(ex));
}
}, fault =>
{
ErrorHandler?.Invoke(RTErrorType.MESSAGELISTENER, fault);
});
AddMessageListener(selector, rtCallback);
}
public void AddCommandListener <TR>(CommandReceived <TR> callback, IChannel channel)
{
IRTCallback rtCallback = new RTCallback <TR>(callback, result =>
{
try
{
Command <TR> command = new Command <TR>();
UserInfo userInfo = new UserInfo();
command.UserInfo = userInfo;
userInfo.ConnectionId = WeborbSerializationHelper.AsString(result, "connectionId");
userInfo.UserId = WeborbSerializationHelper.AsString(result, "userId");
command.Type = WeborbSerializationHelper.AsString(result, "type");
IAdaptingType data = WeborbSerializationHelper.AsAdaptingType(result, "data");
command.Data = (TR)data.adapt(typeof(TR));
callback(command);
}
catch (System.Exception e)
{
channel.ErrorHandler?.Invoke(RTErrorType.COMMAND, new BackendlessFault(e));
}
}, fault =>
{
channel.ErrorHandler?.Invoke(RTErrorType.COMMAND, fault);
});
AddCommandListener(rtCallback);
}
private IRTRequest HandleResult <T>(Object[] args, IDictionary <String, T> requestMap, String resultKey) where T : IRTRequest
{
if (args == null || args.Length < 1)
{
Log.log(Backendless.BACKENDLESSLOG, "subscription result is null or empty");
return(null);
}
AnonymousObject result = (AnonymousObject)WeborbSerializationHelper.Deserialize((byte[])args[0]);
String id = WeborbSerializationHelper.AsString(result, "id");
Log.log(Backendless.BACKENDLESSLOG, String.Format("Got result for subscription {0}", id));
IRTRequest request = requestMap[id];
if (request == null)
{
Log.log(Backendless.BACKENDLESSLOG, String.Format("There is no handler for subscription {0}", id));
return(null);
}
Object error = WeborbSerializationHelper.AsObject(result, "error");
if (error != null)
{
Log.log(Backendless.BACKENDLESSLOG, String.Format("got error {0}", error));
BackendlessFault fault = new BackendlessFault(error.ToString());
request.Callback.errorHandler(fault);
return(request);
}
IAdaptingType data = WeborbSerializationHelper.AsAdaptingType(result, resultKey);
request.Callback.responseHandler(data);
return(request);
}
