//This procedure calls
//not sure if im calling this right.
//1) is it OK to pass in mainactivity like this?
//2) any way to get a callback after they enable? (ie, to reload webview)
//3) any way to delay the initial load of the webview until they hit the OK button to load fixity?
//https://forums.xamarin.com/discussion/118189/gps-location-enable-in-xamarin-forms
//https://stackoverflow.com/questions/33251373/turn-on-location-services-without-navigating-to-settings-page
//https://stackoverflow.com/questions/43138788/ask-user-to-turn-on-location/43139125
//https://forums.xamarin.com/discussion/140325/how-to-check-every-time-for-gps-connectivity (code based on this)
public async void turnOnGps(MainActivity activity)
{
try
{
//MainActivity activity = Xamarin.Forms.Context as MainActivity;
GoogleApiClient googleApiClient = new GoogleApiClient.Builder(activity)
.AddApi(LocationServices.API).Build();
googleApiClient.Connect();
LocationRequest locationRequest = LocationRequest.Create();
locationRequest.SetPriority(LocationRequest.PriorityHighAccuracy);
locationRequest.SetInterval(10000);
locationRequest.SetFastestInterval(10000 / 2);
LocationSettingsRequest.Builder
locationSettingsRequestBuilder = new LocationSettingsRequest.Builder()
.AddLocationRequest(locationRequest);
locationSettingsRequestBuilder.SetAlwaysShow(false);
LocationSettingsResult locationSettingsResult = await LocationServices.SettingsApi.CheckLocationSettingsAsync(
googleApiClient, locationSettingsRequestBuilder.Build());
if (locationSettingsResult.Status.StatusCode == LocationSettingsStatusCodes.ResolutionRequired)
{
locationSettingsResult.Status.StartResolutionForResult(activity, 0);
}
}
catch (Java.Lang.Exception ex)
{
Xamarin.Forms.DependencyService.Get <IMessage>().LongAlert(ex.Message); //show error
}
}
public async void turnOnGps()
{
try
{
MainActivity activity = global::Xamarin.Forms.Forms.Context as MainActivity;
GoogleApiClient googleApiClient = new GoogleApiClient.Builder(activity).AddApi(LocationServices.API).Build();
googleApiClient.Connect();
LocationRequest locationRequest = LocationRequest.Create();
locationRequest.SetPriority(LocationRequest.PriorityHighAccuracy);
locationRequest.SetInterval(10000);
locationRequest.SetFastestInterval(10000 / 2);
LocationSettingsRequest.Builder
locationSettingsRequestBuilder = new LocationSettingsRequest.Builder().AddLocationRequest(locationRequest);
locationSettingsRequestBuilder.SetAlwaysShow(false);
LocationSettingsResult locationSettingsResult = await LocationServices.SettingsApi.CheckLocationSettingsAsync(
googleApiClient, locationSettingsRequestBuilder.Build());
if (locationSettingsResult.Status.StatusCode == LocationSettingsStatusCodes.ResolutionRequired)
{
locationSettingsResult.Status.StartResolutionForResult(activity, 0);
}
var result = await LocationServices.SettingsApi.CheckLocationSettingsAsync(googleApiClient, locationSettingsRequestBuilder.Build());
}
catch (Exception ex)
{
}
}
private void CheckLocationSettings()
{
LocationSettingsRequest.Builder builder = new LocationSettingsRequest.Builder()
.AddLocationRequest(mLocationRequest);
builder.SetAlwaysShow(true);
var task = LocationServices.GetSettingsClient(Activity).CheckLocationSettings(builder.Build());
task.AddOnSuccessListener(new OnSuccessListener(t =>
{
mLocationCallback.MyLocation += MLocationCallback_MyLocation;
})).AddOnFailureListener(new OnFailureListener(e =>
{
int statusCode = ((ApiException)e).StatusCode;
switch (statusCode)
{
case CommonStatusCodes.ResolutionRequired:
try
{
ResolvableApiException resolvable = (ResolvableApiException)e;
StartIntentSenderForResult(resolvable.Resolution.IntentSender, RequestCode, null, 0, 0, 0, null);
}
catch (SendIntentException)
{
}
catch (ClassCastException)
{
}
break;
case LocationSettingsStatusCodes.SettingsChangeUnavailable:
break;
}
}));
}
public async Task DisplayLocationSettingsRequest()
{
var activity = Xamarin.Essentials.Platform.CurrentActivity;
LocationSettingsResponse locationSettingsResponse;
try
{
var locationRequest = LocationRequest.Create();
locationRequest.SetPriority(LocationRequest.PriorityHighAccuracy);
locationRequest.SetInterval(2000);
locationRequest.SetFastestInterval(1250);
var locationSettingsRequestBuilder = new LocationSettingsRequest.Builder().AddLocationRequest(locationRequest);
locationSettingsRequestBuilder.SetAlwaysShow(false);
locationSettingsResponse = await LocationServices.GetSettingsClient(activity).CheckLocationSettingsAsync(locationSettingsRequestBuilder.Build());
}
catch (ApiException ex)
{
switch (ex.StatusCode)
{
case CommonStatusCodes.ResolutionRequired:
var resolvable = (ResolvableApiException)ex;
resolvable.StartResolutionForResult(activity, 0x1);
break;
default:
break;
}
}
}
LocationSettingsRequest.Builder CreateLocationSettingsRequestBuilder()
{
var builder = new LocationSettingsRequest.Builder();
builder.SetAlwaysShow(!ShowNeverButtonOnUseLocationDialog);
builder.AddLocationRequest(CreateLocationRequest());
return(builder);
}
private bool DisplayLocationSettingsRequest()
{
bool islocationOn = false;
var googleApiClient = new GoogleApiClient.Builder(this).AddApi(LocationServices.API).Build();
googleApiClient.Connect();
var locationRequest = LocationRequest.Create();
locationRequest.SetPriority(LocationRequest.PriorityHighAccuracy);
locationRequest.SetInterval(10000);
locationRequest.SetFastestInterval(10000 / 2);
var builder = new LocationSettingsRequest.Builder().AddLocationRequest(locationRequest);
builder.SetAlwaysShow(true);
var result = LocationServices.SettingsApi.CheckLocationSettings(googleApiClient, builder.Build());
result.SetResultCallback((LocationSettingsResult callback) =>
{
switch (callback.Status.StatusCode)
{
case LocationSettingsStatusCodes.Success:
{
islocationOn = true;
//DoStuffWithLocation();
break;
}
case LocationSettingsStatusCodes.ResolutionRequired:
{
try
{
// Show the dialog by calling startResolutionForResult(), and check the result
// in onActivityResult().
callback.Status.StartResolutionForResult(this, 100);
}
catch (IntentSender.SendIntentException e)
{
}
break;
}
default:
{
// If all else fails, take the user to the android location settings
StartActivity(new Intent(Android.Provider.Settings.ActionLocationSourceSettings));
break;
}
}
});
return(islocationOn);
}
protected override async Task <bool> EnableDeviceLocationService()
{
var context = Forms.Context;
var activity = (MainActivity)context;
var listener = new ActivityResultListener(activity);
var googleApiClient = new GoogleApiClient.Builder(activity).AddApi(LocationServices.API).Build();
googleApiClient.Connect();
var locationRequest = LocationRequest.Create();
locationRequest.SetPriority(LocationRequest.PriorityHighAccuracy);
locationRequest.SetInterval(10000);
locationRequest.SetFastestInterval(10000 / 2);
var builder = new LocationSettingsRequest.Builder().AddLocationRequest(locationRequest);
builder.SetAlwaysShow(true);
var result = LocationServices.SettingsApi.CheckLocationSettings(googleApiClient, builder.Build());
result.SetResultCallback((LocationSettingsResult callback) =>
{
switch (callback.Status.StatusCode)
{
case LocationSettingsStatusCodes.Success:
{
break;
}
case LocationSettingsStatusCodes.ResolutionRequired:
{
try
{
// Show the dialog by calling startResolutionForResult(), and check the result
// in onActivityResult().
callback.Status.StartResolutionForResult(activity, REQUEST_CHECK_SETTINGS);
}
catch (IntentSender.SendIntentException e)
{
}
break;
}
default:
{
// If all else fails, take the user to the android location settings
activity.StartActivity(new Intent(Android.Provider.Settings.ActionLocationSourceSettings));
break;
}
}
});
return(await listener.Task);
}
public async void OpenSettings()
{
LocationManager LM = (LocationManager)Android.App.Application.Context.GetSystemService(Context.LocationService);
if (LM.IsProviderEnabled(LocationManager.GpsProvider) == false)
{
Context ctx = Android.App.Application.Context;
p0 = Platform.CurrentActivity;
//-----------------------------------------------------------------------------------------------------------------
try
{
GoogleApiClient
googleApiClient = new GoogleApiClient.Builder(ctx)
.AddApi(LocationServices.API)
.Build();
googleApiClient.Connect();
LocationRequest
locationRequest = LocationRequest.Create()
.SetPriority(LocationRequest.PriorityBalancedPowerAccuracy)
.SetInterval(interval)
.SetFastestInterval(fastestInterval);
LocationSettingsRequest.Builder
locationSettingsRequestBuilder = new LocationSettingsRequest.Builder()
.AddLocationRequest(locationRequest);
locationSettingsRequestBuilder.SetAlwaysShow(false);
LocationSettingsResult locationSettingsResult = await LocationServices.SettingsApi.CheckLocationSettingsAsync(googleApiClient, locationSettingsRequestBuilder.Build());
if (locationSettingsResult.Status.StatusCode == LocationSettingsStatusCodes.ResolutionRequired)
{
locationSettingsResult.Status.StartResolutionForResult(p0, 0);
}
}
catch (Exception exception)
{
// Log exception
}
//-----------------------------------------------------------------------------------------------------------------
//ctx.StartActivity(new Intent(Android.Provider.Settings.ActionLocationSourceSettings).SetFlags(ActivityFlags.NewTask));
//Application.Context.StartActivity(new Android.Content.Intent(Android.Provider.Settings.ActionLocationSourceSettings));
}
else
{
//this is handled in the PCL
}
}
public async Task CheckAndTurnOnGPS(Page page)
{
this.page = page;
Int64 interval = 1000 * 60 * 1, fastestInterval = 1000 * 50;
try
{
GoogleApiClient
googleApiClient = new GoogleApiClient.Builder(MainActivity.Instance)
.AddApi(LocationServices.API)
.Build();
googleApiClient.Connect();
LocationRequest
locationRequest = LocationRequest.Create()
.SetPriority(LocationRequest.PriorityBalancedPowerAccuracy)
.SetInterval(interval)
.SetFastestInterval(fastestInterval);
LocationSettingsRequest.Builder
locationSettingsRequestBuilder = new LocationSettingsRequest.Builder()
.AddLocationRequest(locationRequest);
locationSettingsRequestBuilder.SetAlwaysShow(false);
LocationSettingsResult
locationSettingsResult = await LocationServices.SettingsApi.CheckLocationSettingsAsync(
googleApiClient, locationSettingsRequestBuilder.Build());
if (locationSettingsResult.Status.StatusCode == LocationSettingsStatusCodes.ResolutionRequired)
{
locationSettingsResult.Status.StartResolutionForResult(MainActivity.Instance, 0);
}
}
catch (Exception exception)
{
Console.Write(exception.Message);
}
/*(if ((int)Build.VERSION.SdkInt < 23)
* {
* await MainActivity.Instance.GetLocationAsync();
* return;
* }
*
* await MainActivity.Instance.GetLocationPermissionAsync(this);*/
}
public async static void AskForLocation()
{
if (!CheckIsGPSEnabled())
{
Int64
interval = 1000 * 60 * 1,
fastestInterval = 1000 * 50;
try
{
GoogleApiClient
googleApiClient = new GoogleApiClient.Builder(MainActivity.AndroidContext)
.AddApi(LocationServices.API)
.Build();
googleApiClient.Connect();
LocationRequest
locationRequest = LocationRequest.Create()
.SetPriority(LocationRequest.PriorityBalancedPowerAccuracy)
.SetInterval(interval)
.SetFastestInterval(fastestInterval);
LocationSettingsRequest.Builder
locationSettingsRequestBuilder = new LocationSettingsRequest.Builder()
.AddLocationRequest(locationRequest);
locationSettingsRequestBuilder.SetAlwaysShow(false);
LocationSettingsResult
locationSettingsResult = await LocationServices.SettingsApi.CheckLocationSettingsAsync(
googleApiClient, locationSettingsRequestBuilder.Build());
if (locationSettingsResult.Status.StatusCode == LocationSettingsStatusCodes.ResolutionRequired)
{
locationSettingsResult.Status.StartResolutionForResult(MainActivity.CurrentActivity, 0);
}
}
catch (Exception)
{
// Log exception
}
}
}
public async void StartWatcher(int accuracy, int interval, int fastestInterval, LocationCallback callback)
{
if (this.Running)
{
return;
}
this.callback = callback;
var locationRequest = new LocationRequest()
.SetInterval(interval)
.SetFastestInterval(fastestInterval)
.SetPriority(accuracy);
//location settings dialog
GoogleApiClient
googleApiClient = new GoogleApiClient.Builder(Application.Context)
.AddApi(LocationServices.API)
.Build();
googleApiClient.Connect();
LocationSettingsRequest.Builder locationSettingsRequestBuilder = new LocationSettingsRequest.Builder();
locationSettingsRequestBuilder.AddLocationRequest(locationRequest);
locationSettingsRequestBuilder.SetAlwaysShow(false);
LocationSettingsResult locationSettingsResult = await LocationServices.SettingsApi
.CheckLocationSettingsAsync(googleApiClient,
locationSettingsRequestBuilder.Build());
if (locationSettingsResult.Status.StatusCode == LocationSettingsStatusCodes.ResolutionRequired)
{
locationSettingsResult.Status.StartResolutionForResult(activity, 0);
}
//
await client.RequestLocationUpdatesAsync(locationRequest, this.callback).ContinueWith(t =>
{
this.Running = true;
});
}
public void PedirGps()
{
var googleApiClient = new GoogleApiClient.Builder(Context).AddApi(LocationServices.API).Build();
googleApiClient.Connect();
var locationRequest = LocationRequest.Create();
locationRequest.SetPriority(LocationRequest.PriorityHighAccuracy);
locationRequest.SetInterval(10000);
locationRequest.SetFastestInterval(10000 / 2);
var builder = new LocationSettingsRequest.Builder().AddLocationRequest(locationRequest);
builder.SetAlwaysShow(true);
var result = LocationServices.SettingsApi.CheckLocationSettings(googleApiClient, builder.Build());
result.SetResultCallback(async(LocationSettingsResult callback) =>
{
switch (callback.Status.StatusCode)
{
case LocationSettingsStatusCodes.Success:
{
await Utils.PedirPermissaoLocalizacao();
break;
}
case LocationSettingsStatusCodes.ResolutionRequired:
{
try
{
callback.Status.StartResolutionForResult((Activity)Context, Utils.REQUEST_CHECK_SETTINGS);
await Utils.PedirPermissaoLocalizacao();
}
catch (IntentSender.SendIntentException)
{
}
break;
}
}
});
}
protected async override void Work()
{
try
{
if (!googleApiClient.IsConnected)
{
this.OnStart(null);
}
LocationRequest lr = LocationRequest.Create();
LocationSettingsRequest.Builder builder = new LocationSettingsRequest.Builder().AddLocationRequest(lr);
builder.SetAlwaysShow(true);
var result = await LocationServices.SettingsApi.CheckLocationSettingsAsync(googleApiClient, builder.Build());
var res = LocationServices.FusedLocationApi.GetLastLocation(googleApiClient);
if (res != null)
{
this.genericTCPPacketSender = new GenericTCPPacketSender <ConnectedClientInfoPacket>(this.networkClient);
this.genericTCPPacketSender.Send(new ConnectedClientInfoPacket()
{
ConnectedClientViewModel = new ConnectedClientViewModel()
{
IsAdmin = false,
Latitude = res.Latitude,
Longitude = res.Longitude,
Machine = CrossDeviceInfo.Current.Model,
Name = "Antek"
}
});
}
}
catch (FeatureNotEnabledException ex)
{
throw;
}
catch (Exception ex)
{
throw ex;
}
}
void BuildLocationRequest()
{
_locRequest = new LocationRequest();
_locRequest.SetPriority(LocationRequest.PriorityHighAccuracy);
_locRequest.SetFastestInterval(1 * 1000);
_locRequest.SetInterval(2 * 1000);
int sdk = (int)Android.OS.Build.VERSION.SdkInt;
if (sdk < 23 ||
(this.CheckCallingOrSelfPermission(Android.Manifest.Permission.AccessFineLocation) == Permission.Granted &&
this.CheckCallingOrSelfPermission(Android.Manifest.Permission.AccessCoarseLocation) == Permission.Granted))
{
LocationSettingsRequest.Builder builder = new LocationSettingsRequest.Builder().AddLocationRequest(_locRequest);
builder.SetAlwaysShow(true);
var result = LocationServices.SettingsApi.CheckLocationSettings(_apiClient, builder.Build());
result.SetResultCallback(this);
}
else
{
Android.Support.V4.App.ActivityCompat.RequestPermissions(this, new System.String[] { Android.Manifest.Permission.AccessFineLocation, Android.Manifest.Permission.AccessCoarseLocation }, 1);
}
}
public async Task DisplayLocationSettingsRequest()
{
LocationSettingsResponse locationSettingsResponse;
var activity = Xamarin.Essentials.Platform.CurrentActivity;
try
{
var locationRequest = LocationRequest.Create();
locationRequest.SetPriority(LocationRequest.PriorityHighAccuracy);
locationRequest.SetInterval(10000);
locationRequest.SetFastestInterval(5000);
var locationSettingsRequestBuilder = new LocationSettingsRequest.Builder().AddLocationRequest(locationRequest);
locationSettingsRequestBuilder.SetAlwaysShow(false);
locationSettingsResponse = await LocationServices.GetSettingsClient(activity).CheckLocationSettingsAsync(locationSettingsRequestBuilder.Build());
}
catch (ApiException ex)
{
switch (ex.StatusCode)
{
case CommonStatusCodes.ResolutionRequired:
var resolvable = (ResolvableApiException)ex;
resolvable.StartResolutionForResult(activity, 0x1);
break;
default:
break;
}
}
//var googleApiClient = new GoogleApiClient.Builder(this).AddApi(LocationServices.API).Build();
//googleApiClient.Connect();
//var locationRequest = LocationRequest.Create();
//locationRequest.SetPriority(LocationRequest.PriorityHighAccuracy);
//locationRequest.SetInterval(10000);
//locationRequest.SetFastestInterval(10000 / 2);
//var builder = new LocationSettingsRequest.Builder().AddLocationRequest(locationRequest);
//builder.SetAlwaysShow(true);
//var result = LocationServices.SettingsApi.CheckLocationSettings(googleApiClient, builder.Build());
//result.SetResultCallback((LocationSettingsResult callback) =>
//{
// switch (callback.Status.StatusCode)
// {
// case CommonStatusCodes.Success:
// {
// //DoStuffWithLocation();
// break;
// }
// case CommonStatusCodes.ResolutionRequired:
// {
// try
// {
// callback.Status.StartResolutionForResult(this, REQUEST_CHECK_SETTINGS);
// }
// catch (IntentSender.SendIntentException e)
// {
// }
// break;
// }
// default:
// {
// // If all else fails, take the user to the android location settings
// StartActivity(new Intent(Android.Provider.Settings.ActionLocationSourceSettings));
// break;
// }
// }
//});
}
public void GetLocation(bool requestLocationPermission = true)
{
mRequestLocationPermission = requestLocationPermission;
if (GoogleApiClient.IsConnected)
{
if (mRequestLocationPermission)
{
try
{
LocationSettingsRequest.Builder builder = new LocationSettingsRequest.Builder().AddLocationRequest(mLocationRequest);
builder.SetAlwaysShow(true);
var result = LocationServices.SettingsApi.CheckLocationSettings(mGoogleApiClient, builder.Build());
result.SetResultCallback(new Android.Gms.Common.Apis.ResultCallback <LocationSettingsResult>((locationSettingsResult) =>
{
var status = locationSettingsResult.Status;
var state = locationSettingsResult.LocationSettingsStates;
switch (status.StatusCode)
{
case LocationSettingsStatusCodes.Success:
// All location settings are satisfied. The client can initialize location requests here.
StartLocationUpdates();
break;
case LocationSettingsStatusCodes.ResolutionRequired:
// Location settings are not satisfied. But could be fixed by showing the user a dialog.
try
{
// Show the dialog by calling startResolutionForResult(), and check the result in onActivityResult().
status.StartResolutionForResult(this, REQUEST_CHECK_SETTINGS);
}
catch (IntentSender.SendIntentException)
{
// Ignore the error.
appServices.RaiseAppOnLocationChanged(false);
}
break;
case LocationSettingsStatusCodes.SettingsChangeUnavailable:
// Location settings are not satisfied. However, we have no way to fix the
// settings so we won't show the dialog.
appServices.RaiseAppOnLocationChanged(false);
break;
}
}));
}
catch (Exception e)
{
ExceptionHandler.Catch(e);
}
}
else
{
StartLocationUpdates();
}
}
else
{
GoogleApiClient.Connect();
}
}