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)
{
}
}
} //singleton
public void Initialize(Context context)
{
GoogleSignInOptions gso = new GoogleSignInOptions.Builder(GoogleSignInOptions.DefaultSignIn)
.RequestEmail()
.RequestProfile()
.Build();
//_googleApiClient = new GoogleApiClient.Builder(context)
// //.AddApi(Auth.GOOGLE_SIGN_IN_API, gso)
// .AddConnectionCallbacks(this)
// .AddOnConnectionFailedListener(this)
// .AddApi(DriveClass.API).AddScope(new Scope(Scopes.DriveFile))
// .Build();
//
//auth
_googleApiClient = new GoogleApiClient.Builder(context)
.AddConnectionCallbacks(this)
.AddOnConnectionFailedListener(this)
.AddApi(Auth.GOOGLE_SIGN_IN_API, gso)
.Build();
if (!_googleApiClient.IsConnected)
{
_googleApiClient.Connect(); //logout: GoogleManager._googleApiClient.Disconnect();
}
}
//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
}
}
static GoogleApiClient BuildApiClient()
{
var c = new GoogleApiClient.Builder(Application.Context).
AddApi(LocationServices.API)
.Build();
c.Connect();
return(c);
}
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);
}
private async Task OnDataChangedAsync(DataEventBuffer dataEvents)
{
if (localNodeId == null)
{
GoogleApiClient googleApiClient = new GoogleApiClient.Builder(this)
.AddApi(WearableClass.API)
.Build();
googleApiClient.Connect();
localNodeId = (await WearableClass.NodeApi.GetLocalNodeAsync(googleApiClient).ConfigureAwait(false)).Node.Id;
}
ISharedPreferences settings = string.IsNullOrEmpty(sharedPrefsName) ?
PreferenceManager.GetDefaultSharedPreferences(this) :
GetSharedPreferences(sharedPrefsName, FileCreationMode.Private);
ISharedPreferencesEditor editor = settings.Edit();
IDictionary <string, object> allPrefs = settings.All;
try
{
foreach (IDataEvent ev in dataEvents)
{
IDataItem dataItem = ev.DataItem;
Android.Net.Uri uri = dataItem.Uri;
var nodeId = uri.Host;
if (nodeId.Equals(localNodeId))
{
// Change originated on this device.
continue;
}
if (uri.Path.StartsWith(DATA_SETTINGS_PATH))
{
if (ev.Type == DataEvent.TypeDeleted)
{
DeleteItem(uri, editor, allPrefs);
}
else
{
SaveItem(dataItem, editor, allPrefs);
}
}
}
}
finally
{
// We don't use Apply() because we don't know what thread we're on.
editor.Commit();
}
base.OnDataChanged(dataEvents);
}
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 FusedGeolocator()
{
//_manager = (LocationManager)Application.Context.GetSystemService(Context.LocationService);
//_providers = _manager.GetProviders(false).Where(s => s != LocationManager.PassiveProvider).ToArray();
mGoogleApiClient = new GoogleApiClient.Builder((Activity)Xamarin.Forms.Forms.Context)
.AddApi(LocationServices.API)
.AddConnectionCallbacks(this)
.AddOnConnectionFailedListener(this)
.Build();
mGoogleApiClient.Connect();
}
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 Task <bool> TurnOnLocationSettings()
{
try
{
Cts = new TaskCompletionSource <bool>();
var client = new GoogleApiClient.Builder(CrossCurrentActivity.Current.Activity).AddApi(LocationServices.API).Build();
client.Connect();
var locationRequest = LocationRequest.Create();
locationRequest.SetPriority(LocationRequest.PriorityBalancedPowerAccuracy);
locationRequest.SetInterval(30 * 1000);
locationRequest.SetFastestInterval(5 * 1000);
var builder = new LocationSettingsRequest.Builder().AddLocationRequest(locationRequest);
//builder.SetAlwaysShow(true);
//CrossCurrentActivity.Current.ActivityStateChanged += (sender, args) =>
//{};
var result = await LocationServices.SettingsApi.CheckLocationSettingsAsync(client, builder.Build());
if (result.Status.StatusCode == CommonStatusCodes.Success)
{
return(true);
}
if (result.Status.StatusCode == CommonStatusCodes.ResolutionRequired)
{
result.Status.StartResolutionForResult(CrossCurrentActivity.Current.Activity, 0x1); //REQUEST_CHECK_SETTINGS
}
else
{
var settingIntent = new Intent(Android.Provider.Settings.ActionLocationSourceSettings);
CrossCurrentActivity.Current.Activity.StartActivity(settingIntent);
return(false);
}
}
catch
{
return(false);
}
return(await Cts.Task);
}
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;
}
}
});
}
public void Login(Action <GoogleUser, string> onLoginComplete)
{
GoogleSignInOptions gso = new GoogleSignInOptions.Builder(GoogleSignInOptions.DefaultSignIn)
.RequestEmail()
.Build();
_googleApiClient = new GoogleApiClient.Builder((_context).ApplicationContext)
.AddConnectionCallbacks(this)
.AddOnConnectionFailedListener(this)
.AddApi(Auth.GOOGLE_SIGN_IN_API, gso)
.AddScope(new Scope(Scopes.Profile))
.Build();
_onLoginComplete = onLoginComplete;
Intent signInIntent = Auth.GoogleSignInApi.GetSignInIntent(_googleApiClient);
((MainActivity)Forms.Context).StartActivityForResult(signInIntent, 1);
_googleApiClient.Connect();
}
