Włącz usługi lokalizacyjne bez przechodzenia do strony ustawień

121

W przeciwieństwie do tradycyjnego podejścia polegającego na zachęcaniu użytkownika do przejścia do strony ustawień, włączenia usług lokalizacyjnych i powrotu, zauważyłem prostszy sposób zrobienia tego samego w niektórych najnowszych aplikacjach.

Nawiązując do poniższego zrzutu ekranu, wyświetla okno dialogowe do użytkownika, aby włączyć usługi lokalizacyjne za pomocą jednego kliknięcia i działa w tych aplikacjach.

Jak mogę osiągnąć to samo?

wprowadź opis obrazu tutaj

GAMA
źródło
13
Czy wyborcy negatywni mogą podać powód?
GAMA
3
Dziękuję za zadanie tego pytania.
Głosowanie w
@GAMA Tak działa stackoverflow! Ludzie nie potrzebują powodu, aby nie głosować. Taka wroga i jednocześnie wspaniała społeczność!

Odpowiedzi:

150

To okno dialogowe jest tworzone przez LocationSettingsRequest.Builder dostępny w usługach Google Play.

Musisz dodać zależność do swojej aplikacji build.gradle:

compile 'com.google.android.gms:play-services-location:10.0.1'

Następnie możesz użyć tego minimalnego przykładu:

private void displayLocationSettingsRequest(Context context) {
    GoogleApiClient googleApiClient = new GoogleApiClient.Builder(context)
            .addApi(LocationServices.API).build();
    googleApiClient.connect();

    LocationRequest locationRequest = LocationRequest.create();
    locationRequest.setPriority(LocationRequest.PRIORITY_HIGH_ACCURACY);
    locationRequest.setInterval(10000);
    locationRequest.setFastestInterval(10000 / 2);

    LocationSettingsRequest.Builder builder = new LocationSettingsRequest.Builder().addLocationRequest(locationRequest);
    builder.setAlwaysShow(true);

    PendingResult<LocationSettingsResult> result = LocationServices.SettingsApi.checkLocationSettings(googleApiClient, builder.build());
    result.setResultCallback(new ResultCallback<LocationSettingsResult>() {
        @Override
        public void onResult(LocationSettingsResult result) {
            final Status status = result.getStatus();
            switch (status.getStatusCode()) {
                case LocationSettingsStatusCodes.SUCCESS:
                    Log.i(TAG, "All location settings are satisfied.");
                    break;
                case LocationSettingsStatusCodes.RESOLUTION_REQUIRED:
                    Log.i(TAG, "Location settings are not satisfied. Show the user a dialog to upgrade location settings ");

                    try {
                        // Show the dialog by calling startResolutionForResult(), and check the result
                        // in onActivityResult().
                        status.startResolutionForResult(MainActivity.this, REQUEST_CHECK_SETTINGS);
                    } catch (IntentSender.SendIntentException e) {
                        Log.i(TAG, "PendingIntent unable to execute request.");
                    }
                    break;
                case LocationSettingsStatusCodes.SETTINGS_CHANGE_UNAVAILABLE:
                    Log.i(TAG, "Location settings are inadequate, and cannot be fixed here. Dialog not created.");
                    break;
            }
        }
    });
}

Pełny przykład można znaleźć tutaj .

Mattia Maestrini
źródło
1
Przepraszam, ale nie zrozumiałem pierwszych dwóch wersów:You need to add a dependency to your app build.gradle: compile 'com.google.android.gms:play-services:8.1.0'
GAMA
Więcej informacji o tym, jak skonfigurować usługę Google Play, można znaleźć tutaj
Mattia Maestrini
gdzie znajduje się build.gradle ?
GAMA
W katalogu modułu aplikacji. Zwykle nazwa katalogu toapp
Mattia Maestrini
3
UstawieniaApi są teraz pozbawione funkcji.
Sagar Kacha
27

Wykonaj czynności wymienione poniżej

1) Utwórz LocationRequestzgodnie ze swoim życzeniem

LocationRequest mLocationRequest = LocationRequest.create()
           .setPriority(LocationRequest.PRIORITY_HIGH_ACCURACY)
           .setInterval(10 * 1000)
           .setFastestInterval(1 * 1000);

2) Utwórz plikLocationSettingsRequest.Builder

LocationSettingsRequest.Builder settingsBuilder = new LocationSettingsRequest.Builder()
               .addLocationRequest(mLocationRequest);
settingsBuilder.setAlwaysShow(true);

3) Pobierz LocationSettingsResponse Taskponiższy kod

Task<LocationSettingsResponse> result = LocationServices.getSettingsClient(this)
              .checkLocationSettings(settingsBuilder.build());

Uwaga: LocationServices.SettingsApi jest przestarzałe, więc użyj SettingsClientZamiast tego.

4) Dodaj, OnCompleteListeneraby uzyskać wynik z zadania. Po Taskzakończeniu klient może sprawdzić ustawienia lokalizacji, patrząc na kod stanu z LocationSettingsResponseobiektu.

result.addOnCompleteListener(new OnCompleteListener<LocationSettingsResponse>() {
    @Override
    public void onComplete(@NonNull Task<LocationSettingsResponse> task) {
    try {
        LocationSettingsResponse response = 
                          task.getResult(ApiException.class);
        } catch (ApiException ex) {
            switch (ex.getStatusCode()) {
                case LocationSettingsStatusCodes.RESOLUTION_REQUIRED:
                    try {
                        ResolvableApiException resolvableApiException = 
                                 (ResolvableApiException) ex;
                            resolvableApiException
                                   .startResolutionForResult(MapsActivity.this, 
                                         LOCATION_SETTINGS_REQUEST);
                    } catch (IntentSender.SendIntentException e) {

                    }
                    break;
                case LocationSettingsStatusCodes.SETTINGS_CHANGE_UNAVAILABLE:

                    break;
            }
        }
    }
});  

PRZYPADEK 1:: LocationSettingsStatusCodes.RESOLUTION_REQUIRED Lokalizacja nie jest włączona, ale możemy poprosić użytkownika o włączenie lokalizacji, zachęcając go do włączenia lokalizacji za pomocą okna dialogowego (dzwoniąc startResolutionForResult).

Prośba o ustawienia lokalizacji mapy Google

PRZYPADEK 2:: LocationSettingsStatusCodes.SETTINGS_CHANGE_UNAVAILABLE ustawienia lokalizacji są niezadowalające. Nie mamy jednak możliwości naprawienia ustawień, więc nie pokażemy tego okna.

5) OnActivityResult możemy uzyskać akcję użytkownika w oknie dialogowym ustawień lokalizacji. RESULT_OK=> Użytkownik włączył lokalizację. RESULT_CANCELLED- Użytkownik odrzucił prośbę o ustawienie lokalizacji.

RevanthKrishnaKumar V.
źródło
11

Działa podobnie do map Google

Dodaj zależności w pliku build.gradle

compile 'com.google.android.gms:play-services:8.3.0'

to czy tamto

compile 'com.google.android.gms:play-services-location:10.0.1'

wprowadź opis obrazu tutaj

import android.content.Context;
import android.content.IntentSender;
import android.location.LocationManager;
import android.os.Bundle;
import android.support.v7.app.AppCompatActivity;
import android.util.Log;
import android.widget.Button;
import android.widget.TextView;
import android.widget.Toast;

import com.google.android.gms.common.ConnectionResult;
import com.google.android.gms.common.api.GoogleApiClient;
import com.google.android.gms.common.api.PendingResult;
import com.google.android.gms.common.api.ResultCallback;
import com.google.android.gms.common.api.Status;
import com.google.android.gms.location.LocationRequest;
import com.google.android.gms.location.LocationServices;
import com.google.android.gms.location.LocationSettingsRequest;
import com.google.android.gms.location.LocationSettingsResult;
import com.google.android.gms.location.LocationSettingsStatusCodes;

import java.util.List;

public class LocationOnOff_Similar_To_Google_Maps extends AppCompatActivity {

    protected static final String TAG = "LocationOnOff";

    private GoogleApiClient googleApiClient;
    final static int REQUEST_LOCATION = 199;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        this.setFinishOnTouchOutside(true);

        // Todo Location Already on  ... start
        final LocationManager manager = (LocationManager) LocationOnOff_Similar_To_Google_Maps.this.getSystemService(Context.LOCATION_SERVICE);
        if (manager.isProviderEnabled(LocationManager.GPS_PROVIDER) && hasGPSDevice(LocationOnOff_Similar_To_Google_Maps.this)) {
            Toast.makeText(LocationOnOff_Similar_To_Google_Maps.this,"Gps already enabled",Toast.LENGTH_SHORT).show();
            finish();
        }
        // Todo Location Already on  ... end

        if(!hasGPSDevice(LocationOnOff_Similar_To_Google_Maps.this)){
            Toast.makeText(LocationOnOff_Similar_To_Google_Maps.this,"Gps not Supported",Toast.LENGTH_SHORT).show();
        }

        if (!manager.isProviderEnabled(LocationManager.GPS_PROVIDER) && hasGPSDevice(LocationOnOff_Similar_To_Google_Maps.this)) {
            Log.e("keshav","Gps already enabled");
            Toast.makeText(LocationOnOff_Similar_To_Google_Maps.this,"Gps not enabled",Toast.LENGTH_SHORT).show();
            enableLoc();
        }else{
            Log.e("keshav","Gps already enabled");
            Toast.makeText(LocationOnOff_Similar_To_Google_Maps.this,"Gps already enabled",Toast.LENGTH_SHORT).show();
        }
    }


    private boolean hasGPSDevice(Context context) {
        final LocationManager mgr = (LocationManager) context
                .getSystemService(Context.LOCATION_SERVICE);
        if (mgr == null)
            return false;
        final List<String> providers = mgr.getAllProviders();
        if (providers == null)
            return false;
        return providers.contains(LocationManager.GPS_PROVIDER);
    }

    private void enableLoc() {

        if (googleApiClient == null) {
            googleApiClient = new GoogleApiClient.Builder(LocationOnOff_Similar_To_Google_Maps.this)
                    .addApi(LocationServices.API)
                    .addConnectionCallbacks(new GoogleApiClient.ConnectionCallbacks() {
                        @Override
                        public void onConnected(Bundle bundle) {

                        }

                        @Override
                        public void onConnectionSuspended(int i) {
                            googleApiClient.connect();
                        }
                    })
                    .addOnConnectionFailedListener(new GoogleApiClient.OnConnectionFailedListener() {
                        @Override
                        public void onConnectionFailed(ConnectionResult connectionResult) {

                            Log.d("Location error","Location error " + connectionResult.getErrorCode());
                        }
                    }).build();
            googleApiClient.connect();

            LocationRequest locationRequest = LocationRequest.create();
            locationRequest.setPriority(LocationRequest.PRIORITY_HIGH_ACCURACY);
            locationRequest.setInterval(30 * 1000);
            locationRequest.setFastestInterval(5 * 1000);
            LocationSettingsRequest.Builder builder = new LocationSettingsRequest.Builder()
                    .addLocationRequest(locationRequest);

            builder.setAlwaysShow(true);

            PendingResult<LocationSettingsResult> result =
                    LocationServices.SettingsApi.checkLocationSettings(googleApiClient, builder.build());
            result.setResultCallback(new ResultCallback<LocationSettingsResult>() {
                @Override
                public void onResult(LocationSettingsResult result) {
                    final Status status = result.getStatus();
                    switch (status.getStatusCode()) {
                        case LocationSettingsStatusCodes.RESOLUTION_REQUIRED:
                            try {
                                // Show the dialog by calling startResolutionForResult(),
                                // and check the result in onActivityResult().
                                status.startResolutionForResult(LocationOnOff_Similar_To_Google_Maps.this, REQUEST_LOCATION);

                                finish();
                            } catch (IntentSender.SendIntentException e) {
                                // Ignore the error.
                            }
                            break;
                    }
                }
            });
        }
    }

}
Keshav Gera
źródło
2
UstawieniaApi jest teraz pozbawione praw
Sagar Kacha
2
SettingsApi jest teraz przestarzałe. Teraz użyj SettingsClient: developers.google.com/android/reference/com/google/android/gms/…
Rishabh Chandel
9
implementation 'com.google.android.gms:play-services-location:16.0.0'

Deklaracja zmiennej

private SettingsClient mSettingsClient;
private LocationSettingsRequest mLocationSettingsRequest;
private static final int REQUEST_CHECK_SETTINGS = 214;
private static final int REQUEST_ENABLE_GPS = 516;

Otwórz okno dialogowe, używając poniższego kodu

LocationSettingsRequest.Builder builder = new LocationSettingsRequest.Builder();
builder.addLocationRequest(new LocationRequest().setPriority(LocationRequest.PRIORITY_HIGH_ACCURACY));
builder.setAlwaysShow(true);
mLocationSettingsRequest = builder.build();

mSettingsClient = LocationServices.getSettingsClient(YourActivity.this);

mSettingsClient
    .checkLocationSettings(mLocationSettingsRequest)
    .addOnSuccessListener(new OnSuccessListener<LocationSettingsResponse>() {
        @Override
        public void onSuccess(LocationSettingsResponse locationSettingsResponse) {
            //Success Perform Task Here
        }
    })
    .addOnFailureListener(new OnFailureListener() {
        @Override
        public void onFailure(@NonNull Exception e) {
            int statusCode = ((ApiException) e).getStatusCode();
            switch (statusCode) {
                case LocationSettingsStatusCodes.RESOLUTION_REQUIRED:
                    try {
                        ResolvableApiException rae = (ResolvableApiException) e;
                        rae.startResolutionForResult(YourActivity.this, REQUEST_CHECK_SETTINGS);
                    } catch (IntentSender.SendIntentException sie) {
                        Log.e("GPS","Unable to execute request.");
                    }
                    break;
                case LocationSettingsStatusCodes.SETTINGS_CHANGE_UNAVAILABLE:
                    Log.e("GPS","Location settings are inadequate, and cannot be fixed here. Fix in Settings.");
            }
        }
    })
    .addOnCanceledListener(new OnCanceledListener() {
        @Override
        public void onCanceled() {
            Log.e("GPS","checkLocationSettings -> onCanceled");
        }
    });

onActivityResult

@Override
public void onActivityResult(int requestCode, int resultCode, @Nullable Intent data) {
    super.onActivityResult(requestCode, resultCode, data);

    if (requestCode == REQUEST_CHECK_SETTINGS) {
        switch (resultCode) {
            case Activity.RESULT_OK:
                //Success Perform Task Here
                break;
            case Activity.RESULT_CANCELED:
                Log.e("GPS","User denied to access location");
                openGpsEnableSetting();
                break;
        }
    } else if (requestCode == REQUEST_ENABLE_GPS) {
        LocationManager locationManager = (LocationManager) getSystemService(Context.LOCATION_SERVICE);
        boolean isGpsEnabled = locationManager.isProviderEnabled(LocationManager.GPS_PROVIDER);

        if (!isGpsEnabled) {
            openGpsEnableSetting();
        } else {
            navigateToUser();
        }
    }
}

private void openGpsEnableSetting() {
    Intent intent = new Intent(Settings.ACTION_LOCATION_SOURCE_SETTINGS);
    startActivityForResult(intent, REQUEST_ENABLE_GPS);
}   
Ketan Ramani
źródło
Dzięki! Jeśli używasz tego kodu we fragmencie, zobacz stackoverflow.com/a/39579124/2914140 : zamiast rae.startResolutionForResult(activity, REQUEST_CHECK_SETTINGS)call startIntentSenderForResult(rae.getResolution().getIntentSender(), REQUEST_CHECK_SETTINGS, null, 0, 0, 0, null), w przeciwnym razie onActivityResult()nie zostanie wywołany.
CoolMind
@CoolMind Dzięki może być użyta dla kogoś, kto potrzebuje tego do fragmentu
Ketan Ramani
@CoolMind, czy można użyć startIntentSenderForResultw metodzie czegoś podobnego openGpsEnableSetting()?
Aliton Oliveira
@AlitonOliveira, czy mógłbyś szczegółowo opisać? W kodzie openGpsEnableSetting()po prostu uruchamia się okno dialogowe umożliwiające włączenie ustawień GPS. Po zakończeniu onActivityResult()jest wywoływana za pomocą requestCode == REQUEST_ENABLE_GPS.
CoolMind
onActivityResult()jest wywoływana z Activity i zastanawiałem się, czy możliwe jest zwrócenie wyniku do Fragmentpodobnego startIntentSenderForResult.
Aliton Oliveira
8

Dzięki Mattia Maestrini +1

Rozwiązanie Xamarin:

using Android.Gms.Common.Apis;
using Android.Gms.Location;

public const int REQUEST_CHECK_SETTINGS = 0x1;

private void DisplayLocationSettingsRequest()
{
    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:
                {
                    DoStuffWithLocation();
                    break;
                }
            case LocationSettingsStatusCodes.ResolutionRequired:
                {
                    try
                    {
                        // Show the dialog by calling startResolutionForResult(), and check the result
                        // in onActivityResult().
                        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;
                }
        }
    });
}

protected override void OnActivityResult(int requestCode, Android.App.Result resultCode, Intent data)
{
    switch (requestCode)
    {
        case REQUEST_CHECK_SETTINGS:
            {
                switch (resultCode)
                {
                    case Android.App.Result.Ok:
                        {
                            DoStuffWithLocation();
                            break;
                        }
                    case Android.App.Result.Canceled:
                        {
                            //No location
                            break;
                        }
                }
                break;
            }
    }
}

UWAGA:

To nie zadziała z Huawei ani innymi urządzeniami, na których nie zainstalowano usług Google.

Pierre
źródło
To nie działa!! Czy możesz udostępnić cały kod
Omkar
Próbuję wywołać metodę DisplayLocationSettingsRequest () z metody OnCreate Android Activity. Ale niestety nie mogę wyświetlić wyskakującego okienka żądania ustawienia lokalizacji, które włącza lokalizację. Czy możesz mi pomóc?
Omkar
@Omkar czy zainstalowałeś Xamarin.GooglePlayServices.Location przez Nuget? Czy umieściłeś powyższe dwie linie using android.Gms.Common.Apis; using Android.Gms.Location;? Czy po zakończeniu rozmowy LocationServices.SettingsApi.CheckLocationSettingsotrzymasz oddzwonienie w ciągu result.SetResultCallback(? Umieść punkt przerwania w każdym z nich i sprawdź, co robi kod
Pierre
Tak, dodałem wszystkie wymagania wstępne. Otrzymałem wynik jako Id = 1, Status = WaitingForActivation, Method = (null). Ale ten czas oczekiwania jest nieskończony, jak oczekiwano przez długi czas i nie przyniósł rezultatu.
Omkar
4

Android Marshmallow 6 obsługuje uprawnienia wykonawcze. Uprawnienia wykonawcze działają tylko na Marshmallow, a na wersji przed Marshmallow nadal działa w stary sposób.

Możesz dowiedzieć się więcej na ten temat w tym oficjalnym filmie dla programistów Androida:

https://www.youtube.com/watch?v=C8lUdPVSzDk

I prośba o pozwolenie: http://developer.android.com/training/permissions/requesting.html

Sharj
źródło
Czy interfejs API Marshmallow jest dostępny do celów programistycznych?
GAMA
czy to oznacza, że ​​przepływ pracy pokazany na zrzucie ekranu można osiągnąć tylko Marshmallow i później?
GAMA
Tak, jak stwierdzono w dokumentacji, ma poziom API 23, więc będzie działać tylko na Marshmallow i nowszych.
Sharj
jakikolwiek sposób na osiągnięcie tego samego zachowania w moim własnym niestandardowym oknie dialogowym
Srishti Roy,
4

Dziękuję Mattii Maestrini za odpowiedź, chciałbym to dodać używając

compile 'com.google.android.gms:play-services-location:8.1.0'

wystarczy. Zapobiega to dołączaniu do aplikacji niepotrzebnych bibliotek i pomaga utrzymać niską liczbę metod.

Vuong Pham
źródło
2

Rozwiązanie Kotlin

Dodaj build.gradle(Module:app)

implementation 'com.google.android.gms:play-services-location:17.0.0'
implementation 'com.google.android.gms:play-services-maps:17.0.0'

następnie utwórz tę funkcję

fun enablegps() {

    val mLocationRequest = LocationRequest.create()
        .setPriority(LocationRequest.PRIORITY_HIGH_ACCURACY)
        .setInterval(2000)
        .setFastestInterval(1000)

    val settingsBuilder = LocationSettingsRequest.Builder()
        .addLocationRequest(mLocationRequest)
    settingsBuilder.setAlwaysShow(true)

    val result = LocationServices.getSettingsClient(this).checkLocationSettings(settingsBuilder.build())
    result.addOnCompleteListener { task ->

        //getting the status code from exception
        try {
            task.getResult(ApiException::class.java)
        } catch (ex: ApiException) {

            when (ex.statusCode) {

                LocationSettingsStatusCodes.RESOLUTION_REQUIRED -> try {

                    Toast.makeText(this,"GPS IS OFF",Toast.LENGTH_SHORT).show()

                    // Show the dialog by calling startResolutionForResult(), and check the result
                    // in onActivityResult().
                    val resolvableApiException = ex as ResolvableApiException
                    resolvableApiException.startResolutionForResult(this,REQUEST_CHECK_SETTINGS
                    )
                } catch (e: IntentSender.SendIntentException) {
                    Toast.makeText(this,"PendingIntent unable to execute request.",Toast.LENGTH_SHORT).show()

                }

                LocationSettingsStatusCodes.SETTINGS_CHANGE_UNAVAILABLE -> {

                    Toast.makeText(
                        this,
                        "Something is wrong in your GPS",
                        Toast.LENGTH_SHORT
                    ).show()

                }


            }
        }



    }


}
Jimale Abdi
źródło
1

Dzięki ostatniej aktualizacji Marshmallow, nawet gdy ustawienie Lokalizacja jest włączone, Twoja aplikacja będzie wymagać wyraźnego zapytania o pozwolenie. Zalecanym sposobem, aby to zrobić, jest wyświetlenie sekcji Uprawnienia aplikacji, w której użytkownik może przełączać uprawnienia zgodnie z wymaganiami. Fragment kodu służący do tego jest następujący:

if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {if (this.checkSelfPermission(Manifest.permission.ACCESS_COARSE_LOCATION) != PackageManager.PERMISSION_GRANTED) {final AlertDialog.Builder builder = new AlertDialog.Builder(this);
        builder.setTitle("Location Permission");
        builder.setMessage("The app needs location permissions. Please grant this permission to continue using the features of the app.");
        builder.setPositiveButton(android.R.string.yes, new DialogInterface.OnClickListener() {
            @Override
            public void onClick(DialogInterface dialogInterface, int i) {
                requestPermissions(new String[]{Manifest.permission.ACCESS_COARSE_LOCATION}, PERMISSION_REQUEST_COARSE_LOCATION);}
        });
        builder.setNegativeButton(android.R.string.no, null);
        builder.show();
    }
} else {
    // do programatically as show in the other answer 
}

I nadpisz onRequestPermissionsResultmetodę jak poniżej:

@Override
public void onRequestPermissionsResult(int requestCode, String permissions[], int[] grantResults) {
        switch (requestCode) {
            case PERMISSION_REQUEST_COARSE_LOCATION: {
                if (grantResults[0] == PackageManager.PERMISSION_GRANTED) {
                    Log.d(TAG, "coarse location permission granted");
                } else {
                    Intent intent = new Intent();
                    intent.setAction(Settings.ACTION_APPLICATION_DETAILS_SETTINGS);
                    Uri uri = Uri.fromParts("package", getPackageName(), null);
                    intent.setData(uri);
                    startActivity(intent);
                }
            }
        }
    }

Innym podejściem jest to, że możesz również użyć SettingsApi, aby zapytać, którzy dostawcy lokalizacji są włączeni. Jeśli żadna nie jest włączona, możesz wyświetlić okno dialogowe, aby zmienić ustawienie z poziomu aplikacji.

Mahendra Liya
źródło
1

Najprostszym sposobem, jaki znalazłem podczas moich badań, jest utworzenie klasy Util dla tego procesu żądającego lokalizacji, a następnie wywołanie jej, aby włączyć GPS.

Sprawdź ten blog! Opowiedział całą historię.

Harpreet
źródło