public static void SetLocationTrackingEnabled(bool enabled)
{
if (enabled)
{
var request = new LocationRequest();
request.SetInterval(20 * 1_000);
request.SetFastestInterval(10 * 1_000);
request.SetPriority(LocationRequest.PriorityHighAccuracy);
//Probably not needed
_fusedLocationProviderClient.RequestLocationUpdates(request, Callback, Looper.MainLooper);
if (_locationPendingIntent == null)
{
var intent = new Intent(mContext, typeof(LocationUpdateReceiver));
_locationPendingIntent =
PendingIntent.GetBroadcast(mContext, 123, intent, PendingIntentFlags.UpdateCurrent);
_fusedLocationProviderClient.RequestLocationUpdates(request, _locationPendingIntent);
}
}
else
{
_fusedLocationProviderClient.RemoveLocationUpdates(Callback);
_fusedLocationProviderClient.RemoveLocationUpdates(_locationPendingIntent);
_locationPendingIntent = null;
}
if (MainActivity.Adapter != null)
{
int pos = MainActivity.Adapter.categories.FindIndex(s => s == DataHolder.LocationCategory);
MainActivity.Adapter.NotifyItemChanged(pos);
}
}
//This API is used to remove location updates for the designated PendingIntent object.
private void RemoveLocationUpdatesWithIntent()
{
Task removeTask = fusedLocationProviderClient.RemoveLocationUpdates(pendingIntent);
removeTask.AddOnSuccessListener(new RemoveLocationIntentOnSuccessListener(this))
.AddOnFailureListener((new RemoveLocationIntentOnFailureListener(this)));
}
public void RemoveLocationUpdatesWithCallback()
{
Task removeTask = fusedLocationProviderClient.RemoveLocationUpdates(locationCallback);
removeTask.AddOnSuccessListener(new RemoveLocationCallbackOnSuccessListener(this))
.AddOnFailureListener((new RemoveLocationCallbackOnFailureListener(this)));
}
void StopLocationUpdates()
{
if (locationClient != null && mLocationCallback != null)
{
locationClient.RemoveLocationUpdates(mLocationCallback);
}
}
void StopLocationUpdate()
{
if (locApiClient != null && myLocationCallbackHelper != null)
{
locApiClient.RemoveLocationUpdates(myLocationCallbackHelper);
}
}
private void StopLocationUpdates()
{
if (!_requestingLocationUpdates)
{
return;
}
FusedLocationProviderClient.RemoveLocationUpdates(LocationRequestCallback);
_requestingLocationUpdates = false;
}
public void StopLocationUpdates()
{
if (!mRequestingLocationUpdates)
{
Log.Debug(Tag, "stopLocationUpdates: updates never requested, no-op.");
return;
}
mFusedLocationClient.RemoveLocationUpdates(mLocationCallback).AddOnCompleteListener(this, new StopLocationUpdatesOnCompleteListener {
Activity = this
});
}
private void RemoveLocationUpdatesWithCallback()
{
try
{
Task voidTask = mFusedLocationProviderClient.RemoveLocationUpdates(mLocationCallback);
voidTask
.AddOnSuccessListener(new RemoveLocCallUpdateOnSuccessListener())
.AddOnFailureListener(new RemoveLocCallUpdateOnFailureListener());
}
catch (Exception e)
{
LocationLog.Error(TAG, "removeLocatonUpdatesWithCallback exception:" + e.Message);
}
}
/**
* Removes location updates. Note that in this sample we merely log the
* {@link SecurityException}.
*/
public void RemoveLocationUpdates()
{
Log.Info(Tag, "Removing location updates");
try
{
FusedLocationClient.RemoveLocationUpdates(LocationCallback);
Utils.SetRequestingLocationUpdates(this, false);
StopSelf();
}
catch (SecurityException unlikely)
{
Utils.SetRequestingLocationUpdates(this, true);
Log.Error(Tag, "Lost location permission. Could not remove updates. " + unlikely);
}
}
private async System.Threading.Tasks.Task UpdateLocationAsync(bool turnOn)
{
BuildLocationRequest();
fusedLocationProviderClient = LocationServices.GetFusedLocationProviderClient(this);
if (await CrossPermissions.Current.CheckPermissionStatusAsync(Permission.Location) != PermissionStatus.Granted)
{
return;
}
if (turnOn)
{
fusedLocationProviderClient.RequestLocationUpdates(locationRequest, GetPendingIntent());
}
else
{
fusedLocationProviderClient.RemoveLocationUpdates(GetPendingIntent());
}
}
public void GetLocation()
{
LocationRequest locationRequest = new LocationRequest();
locationRequest.SetInterval(1000).SetPriority(LocationRequest.PriorityHighAccuracy);
_locationCallback = new DelegateLocationCallback(locationResult =>
{
if (locationResult != null && locationResult.HWLocationList.Count > 0)
{
var location = locationResult.HWLocationList[0];
MoveToUserLocation(new LatLng(location.Latitude, location.Longitude));
_fusedLocationProviderClient.RemoveLocationUpdates(_locationCallback);
}
});
_fusedLocationProviderClient.RequestLocationUpdates(locationRequest, _locationCallback, MainLooper);
}
void StopLocationUpdates()
{
locationProviderClient.RemoveLocationUpdates(mLocationCallback);
}
public void StopLocationProvider()
{
_fusedLocationClient.RemoveLocationUpdates(this);
}
public override void OnDestroy()
{
base.OnDestroy();
_fusedLocationClient.RemoveLocationUpdates(_callback);
}
public override bool StopService(Intent name)
{
fusedLocationProviderClient.RemoveLocationUpdates(LocationCallback);
return(base.StopService(name));
}
public void RemoveLocation()
{
UpdateLocation();
providerClient.RemoveLocationUpdates(GetPendingIntent());
}
/**
* Handles the Remove Updates button, and requests removal of location updates.
*/
public void RemoveLocationUpdates(View view)
{
Log.Info(Tag, "Removing location updates");
Utils.SetRequestingLocationUpdates(this, false);
mFusedLocationClient.RemoveLocationUpdates(GetPendingIntent());
}
private IObservable <LocationEvent> CreateLocationObservable(LocationOptions options)
{
return(Observable.Create <LocationEvent>(async(o) =>
{
var lc = new MyLocationCallback((lr) =>
{
foreach (var item in lr.Locations)
{
double?verticalAccuracy = null;
if (Android.OS.Build.VERSION.SdkInt >= Android.OS.BuildVersionCodes.O)
{
if (item.HasVerticalAccuracy)
{
verticalAccuracy = item.VerticalAccuracyMeters;
}
}
var location = new Location(item.Latitude, item.Longitude,
item.HasAccuracy ? item.Accuracy : (double?)null,
item.HasAltitude ? item.Altitude : (double?)null,
verticalAccuracy,
item.HasBearing ? item.Bearing : (double?)null,
item.HasSpeed ? item.Speed : (double?)null);
DateTimeOffset dto;
if (Android.OS.Build.VERSION.SdkInt >= Android.OS.BuildVersionCodes.JellyBeanMr1)
{
var en = item.ElapsedRealtimeNanos;
var sn = SystemClock.ElapsedRealtimeNanos();
var age = (sn - en) / 1000000;
dto = DateTimeOffset.FromUnixTimeMilliseconds(
DateTimeOffset.UtcNow.ToUnixTimeMilliseconds() - age);
}
else
{
dto = DateTimeOffset.Now;
}
var locationEvent = new LocationEvent(dto, location);
o.OnNext(locationEvent);
}
});
var request = CreateRequest(options);
await _fusedLocationProviderClient.RequestLocationUpdatesAsync(request, lc, _context.MainLooper).ConfigureAwait(false);
Interlocked.Increment(ref NoActiveObservables);
return Disposable.Create(() =>
{
Interlocked.Decrement(ref NoActiveObservables);
_fusedLocationProviderClient.RemoveLocationUpdates(lc);
});
}));
}
internal void StopLocationUpdates()
{
mFusedLocationProviderClient.RemoveLocationUpdates(GeofenceLocationListener.SharedInstance);
}
