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