public void TestGetPointsWithOffsetGreaterThenPointsCount()
{
double startingLat = 60;
double startingLong = 10;
int maxPoints = 10;
SetDefinedCategory(GetRandomCategory());
Dictionary <string, string> meta = GetRandomSimpleMetadata();
for (int i = 0; i < maxPoints; i++)
{
Backendless.Geo.SavePoint(startingLat, startingLong + i, GetDefinedCategories(), meta);
}
BackendlessGeoQuery geoQuery = new BackendlessGeoQuery(GetDefinedCategories());
geoQuery.Offset = maxPoints * 2;
try
{
Backendless.Geo.GetPoints(geoQuery);
Assert.Fail("Server accepted request");
}
catch (System.Exception e)
{
CheckErrorCode(4003, e);
}
}
public void TestGetPointsWithOffsetGreaterThenPointsCount()
{
RunAndAwait(() =>
{
double startingLat = 60;
double startingLong = -60;
int maxPoints = 1;
SetDefinedCategory(GetRandomCategory());
Dictionary <String, String> meta = GetRandomSimpleMetadata();
CountdownEvent latch = new CountdownEvent(maxPoints);
for (int i = 0; i < maxPoints; i++)
{
Backendless.Geo.SavePoint(startingLat, startingLong + i, GetDefinedCategories(), meta,
new AsyncCallback <GeoPoint>(response => latch.Signal(), fault =>
{
for (int j = 0; j < latch.CurrentCount; j++)
{
latch.Signal();
}
}));
}
latch.Wait();
var geoQuery = new BackendlessGeoQuery(GetDefinedCategories())
{
Offset = maxPoints * 2
};
Backendless.Geo.GetPoints(geoQuery,
new AsyncCallback <BackendlessCollection <GeoPoint> >(
response => FailCountDownWith("Server accepted request"),
fault => CheckErrorCode(4003, fault)));
});
}
public BackendlessCollection <SearchMatchesResult> RelativeFind(BackendlessGeoQuery geoQuery)
{
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);
}
Invoker.Api api = Invoker.Api.UNKNOWN;
string query = GetGetPointsQuery(geoQuery, out api);
BackendlessCollection <SearchMatchesResult> result = null;
Dictionary <string, BackendlessCollection <SearchMatchesResult> > r = Invoker.InvokeSync <Dictionary <string, BackendlessCollection <SearchMatchesResult> > >(Invoker.Api.GEOSERVICE_RELATIVEFIND, new Object[] { null, query });
if (r != null && r.ContainsKey(COLLECTION))
{
result = (BackendlessCollection <SearchMatchesResult>)r[COLLECTION];
result.Query = geoQuery;
}
return(result);
}
public void TestGetPointsByRadiusIn100Yards()
{
RunAndAwait(() =>
{
double startingLat = 10;
double startingLong = 15;
int maxPoints = 10;
double offset = 0;
SetDefinedCategory(GetRandomCategory());
Dictionary <String, String> meta = GetRandomSimpleMetadata();
CountdownEvent latch = new CountdownEvent(maxPoints);
for (int i = 0; i < maxPoints; i++)
{
offset += METER * 0.914399998610112;
Backendless.Geo.SavePoint(startingLat, startingLong + offset, GetDefinedCategories(), meta,
new AsyncCallback <GeoPoint>(response => latch.Signal(), fault =>
{
for (int j = 0; j < latch.CurrentCount; j++)
{
latch.Signal();
}
}));
}
latch.Wait();
BackendlessGeoQuery geoQuery = new BackendlessGeoQuery(startingLat, startingLong + offset / 2, 100, Units.YARDS);
GetCollectionAndCheck(startingLat, startingLong, maxPoints, maxPoints, meta, geoQuery);
});
}
public void TestGetPointsForRectangle()
{
RunAndAwait(() =>
{
double startingLat = 10;
double startingLong = 10;
int maxPoints = 10;
SetDefinedCategory(GetRandomCategory());
Dictionary <String, String> meta = GetRandomSimpleMetadata();
CountdownEvent latch = new CountdownEvent(maxPoints);
for (int i = 0; i < maxPoints; i++)
{
Backendless.Geo.SavePoint(startingLat, startingLong + i, GetDefinedCategories(), meta,
new AsyncCallback <GeoPoint>(response => latch.Signal(), fault =>
{
for (int j = 0; j < latch.CurrentCount; j++)
{
latch.Signal();
}
}));
}
latch.Wait();
var geoQuery = new BackendlessGeoQuery(startingLat + 1, startingLong - 1, startingLat - 1,
startingLong + maxPoints + 1);
GetCollectionAndCheck(startingLat, startingLong, maxPoints, maxPoints, meta, geoQuery);
});
}
public IList <GeoPoint> GetPoints(string geofenceName, BackendlessGeoQuery query)
{
checkGeoQuery(query);
var args = new object[] { geofenceName, query };
return(Invoker.InvokeSync <IList <GeoPoint> >(GEO_MANAGER_SERVER_ALIAS, "getPoints", args));
}
void GetPoints()
{
mWaiting.SetActive(true);
List <string> categories = new List <string>();
categories.Add("geoservice_sample");
BackendlessGeoQuery query = new BackendlessGeoQuery(mLatitude, mLongitude, mRadius, Units.KILOMETERS, categories);
AsyncCallback <BackendlessCollection <GeoPoint> > callback = new AsyncCallback <BackendlessCollection <GeoPoint> >(
collection =>
{
mPoints = "";
foreach (GeoPoint point in collection.GetCurrentPage())
{
mPoints += "City:" + point.Metadata["city"] + ", Lat:" + point.Latitude + ", Lon:" + point.Longitude + "\n";
}
mIsGetPointsFinish = true;
mIsGetPointsSuccess = false;
},
fault =>
{
mResultMessage = "Error\n\nCode = " + fault.FaultCode + "\nmessage = " + fault.Message;
mIsGetPointsFinish = true;
mIsGetPointsSuccess = true;
});
Backendless.Geo.GetPoints(query, callback);
}
public void RelativeFind(BackendlessGeoQuery geoQuery, AsyncCallback <BackendlessCollection <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);
}
Invoker.Api api = Invoker.Api.UNKNOWN;
string query = GetGetPointsQuery(geoQuery, out api);
var responder = new AsyncCallback <Dictionary <string, BackendlessCollection <SearchMatchesResult> > >(r =>
{
BackendlessCollection <SearchMatchesResult> result = null;
if (r != null && r.ContainsKey(COLLECTION))
{
result = (BackendlessCollection <SearchMatchesResult>)r[COLLECTION];
result.Query = geoQuery;
}
if (callback != null)
{
callback.ResponseHandler.Invoke(result);
}
}, f =>
{
if (callback != null)
{
callback.ErrorHandler.Invoke(f);
}
else
{
throw new BackendlessException(f);
}
});
Invoker.InvokeAsync <Dictionary <string, BackendlessCollection <SearchMatchesResult> > >(Invoker.Api.GEOSERVICE_RELATIVEFIND, new Object[] { null, query }, responder);
}
catch (System.Exception ex)
{
if (callback != null)
{
callback.ErrorHandler.Invoke(new BackendlessFault(ex));
}
else
{
throw;
}
}
}
public void GetCollectionAndCheck(double startingLat, double startingLong, int maxPoints, double offset,
Dictionary <string, string> meta, BackendlessGeoQuery geoQuery)
{
int counter = maxPoints;
if (geoQuery.Categories.Count == 0 && GetDefinedCategories() != null)
{
geoQuery.Categories = GetDefinedCategories();
}
Backendless.Geo.GetPoints(geoQuery,
new ResponseCallback <IList <GeoPoint> >(this)
{
ResponseHandler = geoPointBackendlessCollection =>
{
Assert.IsNotNull(geoPointBackendlessCollection,
"Server returned a null collection");
foreach (GeoPoint geoPoint in geoPointBackendlessCollection)
{
if (meta == null || meta.Count == 0)
{
Assert.IsTrue(geoPoint.Metadata.Count == 0,
"Server returned points with unexpected metadata");
}
else
{
foreach (KeyValuePair <string, string> keyValuePair in meta)
{
Assert.IsTrue(geoPoint.Metadata.ContainsKey(keyValuePair.Key),
"Server returned points with unexpected metadata");
Assert.IsTrue(
geoPoint.Metadata[keyValuePair.Key].Equals(keyValuePair.Value),
"Server returned points with unexpected metadata");
}
}
Assert.AreEqual(startingLat, geoPoint.Latitude, 0.0000000001d,
"Server returned points from unexpected latitude range");
Assert.IsTrue(
geoPoint.Longitude >= startingLong &&
geoPoint.Longitude <= startingLong + offset,
"Server returned points from unexpected longitude range");
counter--;
}
Assert.AreEqual(counter, 0, "Server found wrong total points count");
CountDown();
}
});
}
public IList <SearchMatchesResult> RelativeFind(BackendlessGeoQuery geoQuery)
{
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);
}
return(Invoker.InvokeSync <IList <SearchMatchesResult> >(GEO_MANAGER_SERVER_ALIAS, "relativeFind",
new object[] { geoQuery }));
}
public void GetPoints(BackendlessGeoQuery geoQuery, AsyncCallback <BackendlessCollection <GeoPoint> > callback)
{
try
{
checkGeoQuery(geoQuery);
Invoker.Api api = Invoker.Api.UNKNOWN;
string query = GetGetPointsQuery(geoQuery, out api);
var responder = new AsyncCallback <Dictionary <string, BackendlessCollection <GeoPoint> > >(r =>
{
BackendlessCollection <GeoPoint> result = null;
if (r != null && r.ContainsKey(COLLECTION))
{
result = (BackendlessCollection <GeoPoint>)r[COLLECTION];
result.Query = geoQuery;
}
if (callback != null)
{
callback.ResponseHandler.Invoke(result);
}
}, f =>
{
if (callback != null)
{
callback.ErrorHandler.Invoke(f);
}
else
{
throw new BackendlessException(f);
}
});
Invoker.InvokeAsync <Dictionary <string, BackendlessCollection <GeoPoint> > >(api, new Object[] { null, query }, responder);
}
catch (System.Exception ex)
{
if (callback != null)
{
callback.ErrorHandler.Invoke(new BackendlessFault(ex));
}
else
{
throw;
}
}
}
public IList <GeoPoint> GetPoints(BackendlessGeoQuery geoQuery)
{
checkGeoQuery(geoQuery);
var methodArgs = new object[] { geoQuery };
var result = Invoker.InvokeSync <IList <GeoPoint> >(GEO_MANAGER_SERVER_ALIAS, "getPoints", methodArgs);
foreach (var geoPoint in result)
{
if (geoPoint is GeoCluster cluster)
{
cluster.GeoQuery = geoQuery;
}
}
return(result);
}
public void TestGetPointsWithBothRectAndRadiusQuery()
{
RunAndAwait(() =>
{
var geoQuery = new BackendlessGeoQuery(10, 10, 20, 20)
{
Radius = 10, Latitude = 10, Longitude = 10, Units = Units.KILOMETERS
};
Backendless.Geo.GetPoints(geoQuery,
new AsyncCallback <BackendlessCollection <GeoPoint> >(
response =>
FailCountDownWith(
"Client send a query with both rectangle and radius search query"),
fault => CheckErrorCode(ExceptionMessage.INCONSISTENT_GEO_QUERY, fault)));
});
}
public void GetPoints(BackendlessGeoQuery geoQuery, AsyncCallback <IList <GeoPoint> > callback)
{
try
{
checkGeoQuery(geoQuery);
var responder = new AsyncCallback <IList <GeoPoint> >(r =>
{
foreach (GeoPoint geoPoint in r)
{
if (geoPoint is GeoCluster)
{
((GeoCluster)geoPoint).GeoQuery = geoQuery;
}
}
if (callback != null)
{
callback.ResponseHandler.Invoke(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 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 =>
{
if (callback != null)
{
callback.ResponseHandler.Invoke(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 PointsPage()
{
InitializeComponent();
_cityPointsList = new CityPointsList();
_backendlessGeoQuery = new BackendlessGeoQuery();
CityPointsDataGrid.DataContext = _cityPointsList;
AsyncStartedEvent += () =>
{
ProgressBar.Visibility = Visibility.Visible;
};
AsyncFinishedEvent += () =>
{
ProgressBar.Visibility = Visibility.Collapsed;
};
}
public void TestGetPointsWithBothRectAndRadiusQuery()
{
try
{
BackendlessGeoQuery geoQuery = new BackendlessGeoQuery(10d, 10d, 20d, 20d);
geoQuery.Radius = 10d;
geoQuery.Latitude = 10d;
geoQuery.Longitude = 10d;
Backendless.Geo.GetPoints(geoQuery);
Assert.Fail("Client send a query with both rectangle and radius search query");
}
catch (System.Exception e)
{
CheckErrorCode(ExceptionMessage.INCONSISTENT_GEO_QUERY, e);
}
}
public BackendlessCollection <GeoPoint> GetPoints(BackendlessGeoQuery geoQuery)
{
checkGeoQuery(geoQuery);
Invoker.Api api = Invoker.Api.UNKNOWN;
string query = GetGetPointsQuery(geoQuery, out api);
BackendlessCollection <GeoPoint> result = null;
Dictionary <string, BackendlessCollection <GeoPoint> > r = Invoker.InvokeSync <Dictionary <string, BackendlessCollection <GeoPoint> > >(api, new Object[] { null, query });
if (r != null && r.ContainsKey(COLLECTION))
{
result = (BackendlessCollection <GeoPoint>)r[COLLECTION];
result.Query = geoQuery;
}
return(result);
}
public void TestGetPointsForRectangle()
{
double startingLat = 10;
double startingLong = 10;
int maxPoints = 10;
SetDefinedCategory(GetRandomCategory());
Dictionary <string, string> meta = GetRandomSimpleMetadata();
for (int i = 0; i < maxPoints; i++)
{
Backendless.Geo.SavePoint(startingLat, startingLong + i, GetDefinedCategories(), meta);
}
BackendlessGeoQuery geoQuery = new BackendlessGeoQuery(startingLat + 1, startingLong - 1, startingLat - 1,
startingLong + maxPoints + 1);
GetCollectionAndCheck(startingLat, startingLong, maxPoints, maxPoints, meta, geoQuery);
}
public void TestGetPointsByRadiusIn100Yards()
{
double startingLat = 10;
double startingLong = 30;
int maxPoints = 10;
double offset = 0;
SetDefinedCategory(GetRandomCategory());
Dictionary <string, string> meta = GetRandomSimpleMetadata();
for (int i = 0; i < maxPoints; i++)
{
offset += METER * 0.914399998610112;
Backendless.Geo.SavePoint(startingLat, startingLong + offset, GetDefinedCategories(), meta);
}
BackendlessGeoQuery geoQuery = new BackendlessGeoQuery(startingLat, startingLong + offset / 2, 100, Units.YARDS);
GetCollectionAndCheck(startingLat, startingLong, maxPoints, offset, meta, geoQuery);
}
public void TestGetPointsWithoutMetadata()
{
double startingLat = 50;
double startingLong = 10;
int maxPoints = 10;
Dictionary <string, string> meta = GetRandomSimpleMetadata();
SetDefinedCategory(GetRandomCategory());
for (int i = 0; i < maxPoints; i++)
{
Backendless.Geo.SavePoint(startingLat, startingLong + i, GetDefinedCategories(), meta);
}
meta = null;
BackendlessGeoQuery geoQuery = new BackendlessGeoQuery(GetDefinedCategories());
geoQuery.IncludeMeta = false;
GetCollectionAndCheck(startingLat, startingLong, maxPoints, maxPoints, meta, geoQuery);
}
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 async Task <IList <GeoPoint> > GetPointsAsync(string geofenceName, BackendlessGeoQuery query)
{
return(await Task.Run(() => GetPoints( geofenceName, query )).ConfigureAwait(false));
}
public async Task <IList <SearchMatchesResult> > RelativeFindAsync(BackendlessGeoQuery geoQuery)
{
return(await Task.Run(() => RelativeFind( geoQuery )).ConfigureAwait(false));
}
public async Task <int> GetGeopointCountAsync(BackendlessGeoQuery query)
{
return(await Task.Run(() => GetGeopointCount( query )).ConfigureAwait(false));
}
public async Task <int> GetGeopointCountAsync(string geoFenceName, BackendlessGeoQuery query)
{
return(await Task.Run(() => GetGeopointCount( geoFenceName, query )).ConfigureAwait(false));
}
private static string GetGetPointsQuery(BackendlessGeoQuery geoQuery, out Invoker.Api api)
{
string query = null;
if (geoQuery != null)
{
double[] searchRectangle = geoQuery.SearchRectangle;
if (searchRectangle != null)
{
api = Invoker.Api.GEOSERVICE_GETRECT;
if (searchRectangle.Length == 4)
{
AddQuery(ref query, "nwlat=" + searchRectangle[0]);
AddQuery(ref query, "nwlon=" + searchRectangle[1]);
AddQuery(ref query, "selat=" + searchRectangle[2]);
AddQuery(ref query, "selon=" + searchRectangle[3]);
}
}
else
{
api = Invoker.Api.GEOSERVICE_GETPOINTS;
Dictionary <string, string> relativeFindMetadataList = geoQuery.RelativeFindMetadata;
if (relativeFindMetadataList != null && relativeFindMetadataList.Count > 0)
{
api = Invoker.Api.GEOSERVICE_RELATIVEFIND;
string metadata = JsonMapper.ToJson(relativeFindMetadataList);
if (string.IsNullOrEmpty(metadata) == false)
{
AddQuery(ref query, "relativeFindMetadata=" + UnityEngine.WWW.EscapeURL(metadata));
}
AddQuery(ref query, "relativeFindPercentThreshold=" + geoQuery.RelativeFindPercentThreshold);
}
if (Double.NaN.Equals(geoQuery.Latitude) == false)
{
AddQuery(ref query, "lat=" + geoQuery.Latitude);
}
if (Double.NaN.Equals(geoQuery.Longitude) == false)
{
AddQuery(ref query, "lon=" + geoQuery.Longitude);
}
if (Double.NaN.Equals(geoQuery.Radius) == false)
{
AddQuery(ref query, "r=" + geoQuery.Radius);
}
Units?unit = geoQuery.Units;
if (unit != null)
{
AddQuery(ref query, "units=" + unit.ToString());
}
}
List <string> categoriesList = geoQuery.Categories;
if (categoriesList != null && categoriesList.Count > 0)
{
string categories = "";
foreach (string category in categoriesList)
{
if (string.IsNullOrEmpty(categories) == false)
{
categories += ",";
}
categories += category;
}
if (string.IsNullOrEmpty(categories) == false)
{
AddQuery(ref query, "categories=" + categories);
}
}
Dictionary <string, string> metadataList = geoQuery.Metadata;
if (metadataList != null && metadataList.Count > 0)
{
string metadata = JsonMapper.ToJson(metadataList);
if (string.IsNullOrEmpty(metadata) == false)
{
AddQuery(ref query, "metadata=" + UnityEngine.WWW.EscapeURL(metadata));
}
}
AddQuery(ref query, "includemetadata=" + geoQuery.IncludeMeta.ToString().ToLower());
AddQuery(ref query, "pagesize=" + geoQuery.PageSize);
AddQuery(ref query, "offset=" + geoQuery.Offset);
}
else
{
api = Invoker.Api.UNKNOWN;
}
return(query);
}
private void checkGeoQuery(BackendlessGeoQuery geoQuery)
{
if (geoQuery == null)
{
throw new ArgumentNullException(ExceptionMessage.NULL_GEO_QUERY);
}
if (geoQuery.SearchRectangle != null)
{
if (geoQuery.SearchRectangle.Length != 4)
{
throw new ArgumentException(ExceptionMessage.WRONG_SEARCH_RECTANGLE_QUERY);
}
if (!Double.IsNaN(geoQuery.Radius))
{
throw new ArgumentException(ExceptionMessage.INCONSISTENT_GEO_QUERY);
}
if (!Double.IsNaN(geoQuery.Latitude))
{
throw new ArgumentException(ExceptionMessage.INCONSISTENT_GEO_QUERY);
}
if (!Double.IsNaN(geoQuery.Longitude))
{
throw new ArgumentException(ExceptionMessage.INCONSISTENT_GEO_QUERY);
}
}
else if (!Double.IsNaN(geoQuery.Radius))
{
if (geoQuery.Radius <= 0)
{
throw new ArgumentException(ExceptionMessage.WRONG_RADIUS);
}
if (Double.IsNaN(geoQuery.Latitude))
{
throw new ArgumentNullException(ExceptionMessage.WRONG_LATITUDE_VALUE);
}
if (Double.IsNaN(geoQuery.Longitude))
{
throw new ArgumentNullException(ExceptionMessage.WRONG_LONGITUDE_VALUE);
}
CheckCoordinates(geoQuery.Latitude, geoQuery.Longitude);
if (geoQuery.Units == null)
{
throw new ArgumentNullException(ExceptionMessage.NULL_UNIT);
}
}
else if (geoQuery.Categories == null && geoQuery.Metadata == null)
{
throw new ArgumentNullException(ExceptionMessage.WRONG_GEO_QUERY);
}
if (geoQuery.Categories != null)
{
foreach (string categoryName in geoQuery.Categories)
{
CheckCategoryName(categoryName);
}
}
if (geoQuery.Offset < 0)
{
throw new ArgumentException(ExceptionMessage.WRONG_OFFSET);
}
if (geoQuery.PageSize < 0)
{
throw new ArgumentException(ExceptionMessage.WRONG_PAGE_SIZE);
}
}
public void GetGeopointCount(string geoFenceName, BackendlessGeoQuery query, AsyncCallback <int> responder)
{
Object[] args = new Object[] { geoFenceName, query };
Invoker.InvokeAsync <int>(GEO_MANAGER_SERVER_ALIAS, "count", args, responder);
}
public async Task <IList <GeoPoint> > GetPointsAsync(BackendlessGeoQuery query)
{
return(await Task.Run(() => GetPoints( query )).ConfigureAwait(false));
}
