public void SendCommand(String type, Object data, AsyncCallback <Object> callback)
{
Log.log(Backendless.BACKENDLESSLOG, String.Format("Send command with type {0}", type));
CommandRequest rtMethodRequest = CreateCommandRequest(new RTCallback <Object>(callback, result =>
{
Log.log(Backendless.BACKENDLESSLOG, "command sent");
if (callback != null)
{
callback.ResponseHandler(null);
}
}, fault =>
{
Log.log(Backendless.BACKENDLESSLOG, String.Format("error when sending command {0}", fault));
if (callback != null)
{
callback.ErrorHandler(fault);
}
}));
rtMethodRequest.SetData(data).SetType(type);
if (IsConnected())
{
rtClient.Invoke(rtMethodRequest);
}
else
{
commandsToSend.Enqueue(rtMethodRequest);
}
}
public void AddConnectListener(AsyncCallback <Object> callback)
{
if (connected)
{
callback.ResponseHandler(null);
}
connectedCallbacks.Add(callback);
}
public void IsValidLogin(AsyncCallback <Boolean> callback)
{
if (LoginStorage.HasData && LoginStorage.UserToken != null && LoginStorage.UserToken.Length > 0)
{
Invoker.InvokeAsync <Boolean>(USER_MANAGER_SERVER_ALIAS, "isValidUserToken",
new object[] { LoginStorage.UserToken }, callback);
}
else
{
callback.ResponseHandler(CurrentUser != null);
}
}
public void Get <T>(String key, AsyncCallback <T> callback)
{
AsyncCallback <byte[]> interimCallback = new AsyncCallback <byte[]>(
result =>
{
callback.ResponseHandler((T)deserialize <T>(result));
},
fault =>
{
callback.ErrorHandler(fault);
});
Invoker.InvokeAsync(CACHE_SERVER_ALIAS, "getBytes", new Object[] { key }, interimCallback);
}
public void Create(IList <Dictionary <String, Object> > objects, AsyncCallback <IList <String> > callback)
{
if (objects == null)
{
throw new ArgumentNullException(String.Format(ExceptionMessage.NULL_OR_EMPTY_TEMPLATE,
"Object collection"));
}
if (objects.Count == 0)
{
callback.ResponseHandler(new List <String>());
}
Object[] args = new Object[] { tableName, objects };
Invoker.InvokeAsync(PERSISTENCE_MANAGER_SERVER_ALIAS, "createBulk", args, callback);
}
public void Listing(string path, string pattern, bool recursive, int pagesize, int offset,
AsyncCallback <IList <FileInfo> > responder)
{
AsyncCallback <IList <FileInfo> > listingCallback = new AsyncCallback <IList <FileInfo> >(
files =>
{
responder?.ResponseHandler(files);
},
error =>
{
responder?.ErrorHandler(error);
}
);
object[] args = { path, pattern, recursive, pagesize, offset };
Invoker.InvokeAsync(FILE_MANAGER_SERVER_ALIAS, "listing", args, listingCallback);
}
public void RelativeFind(BackendlessGeoQuery geoQuery, AsyncCallback <IList <SearchMatchesResult> > callback)
{
try
{
if (geoQuery == null)
{
throw new ArgumentNullException(ExceptionMessage.NULL_GEO_QUERY);
}
if (geoQuery.RelativeFindMetadata.Count == 0 || geoQuery.RelativeFindPercentThreshold == 0)
{
throw new ArgumentException(ExceptionMessage.INCONSISTENT_GEO_RELATIVE);
}
var responder = new AsyncCallback <IList <SearchMatchesResult> >(r =>
{
callback?.ResponseHandler(r);
}, f =>
{
if (callback != null)
{
callback.ErrorHandler.Invoke(f);
}
else
{
throw new BackendlessException(f);
}
});
Invoker.InvokeAsync(GEO_MANAGER_SERVER_ALIAS, "relativeFind",
new object[] { geoQuery }, responder);
}
catch (System.Exception ex)
{
if (callback != null)
{
callback.ErrorHandler.Invoke(new BackendlessFault(ex));
}
else
{
throw;
}
}
}
public void GetPoints(BackendlessGeoQuery geoQuery, AsyncCallback <IList <GeoPoint> > callback)
{
try
{
checkGeoQuery(geoQuery);
var responder = new AsyncCallback <IList <GeoPoint> >(r =>
{
foreach (var geoPoint in r)
{
if (geoPoint is GeoCluster cluster)
{
cluster.GeoQuery = geoQuery;
}
}
callback?.ResponseHandler(r);
}, f =>
{
if (callback != null)
{
callback.ErrorHandler.Invoke(f);
}
else
{
throw new BackendlessException(f);
}
});
Invoker.InvokeAsync(GEO_MANAGER_SERVER_ALIAS, "getPoints",
new object[] { geoQuery }, responder);
}
catch (System.Exception ex)
{
if (callback != null)
{
callback.ErrorHandler.Invoke(new BackendlessFault(ex));
}
else
{
throw;
}
}
}
public void LoadMetadata(GeoPoint point, AsyncCallback <GeoPoint> callback)
{
AsyncCallback <Dictionary <string, object> > loadMetaCallback = new AsyncCallback <Dictionary <string, object> >(
result =>
{
point.Metadata = result;
callback?.ResponseHandler(point);
},
fault =>
{
callback?.ErrorHandler(fault);
});
try
{
object[] methodArgs = null;
if (point is GeoCluster cluster)
{
methodArgs = new object[] { cluster.ObjectId, cluster.GeoQuery }
}
;
else
{
methodArgs = new object[] { point.ObjectId, null }
};
Invoker.InvokeAsync(GEO_MANAGER_SERVER_ALIAS, "loadMetadata", methodArgs, loadMetaCallback);
}
catch (System.Exception ex)
{
if (callback != null)
{
callback.ErrorHandler.Invoke(new BackendlessFault(ex));
}
else
{
throw;
}
}
}
public void RunOnExitAction(string geoFenceName, GeoPoint geoPoint, AsyncCallback <object> callback)
{
var args = new object[] { geoFenceName, geoPoint };
var responder = new AsyncCallback <int>(r =>
{
callback?.ResponseHandler(r);
}, f =>
{
if (callback != null)
{
callback.ErrorHandler.Invoke(f);
}
else
{
throw new BackendlessException(f);
}
});
Invoker.InvokeAsync(GEO_MANAGER_SERVER_ALIAS, "runOnExitAction", args, responder);
}
public void GetPoints(string geofenceName, BackendlessGeoQuery query, AsyncCallback <IList <GeoPoint> > callback)
{
checkGeoQuery(query);
var args = new object[] { geofenceName, query };
var responder = new AsyncCallback <IList <GeoPoint> >(r =>
{
callback?.ResponseHandler(r);
}, f =>
{
if (callback != null)
{
callback.ErrorHandler.Invoke(f);
}
else
{
throw new BackendlessException(f);
}
});
Invoker.InvokeAsync(GEO_MANAGER_SERVER_ALIAS, "getPoints", args, responder);
}
public void IsValidLogin( AsyncCallback<Boolean> callback )
{
LoginStorage loginStorage = new LoginStorage();
if( !loginStorage.NewPrefs && loginStorage.UserToken != null && loginStorage.UserToken.Length > 0 )
Invoker.InvokeAsync<Boolean>( USER_MANAGER_SERVER_ALIAS, "isValidUserToken",
new object[] { Backendless.AppId, Backendless.VersionNum, loginStorage.UserToken }, callback );
else
callback.ResponseHandler( CurrentUser != null );
}
