Come verificare se i servizi di localizzazione sono abilitati?


228

Sto sviluppando un'app sul sistema operativo Android. Non so come verificare se i servizi di localizzazione sono abilitati o meno.

Ho bisogno di un metodo che ritorni "vero" se sono abilitati e "falso" in caso contrario (quindi nell'ultimo caso posso mostrare una finestra di dialogo per abilitarli).


3
So che questo è un vecchio argomento, ma per coloro che potrebbero seguire ... Google ha rilasciato un'API per questo; vedi developers.google.com/android/reference/com/google/android/gms/…
Peter McLennan,


Cordiali saluti: SettingsApi è ora obsoleto. Utilizza invece gli sviluppatori.google.com/android/reference/com/google/android/gms/… .
Rajiv

Risposte:


361

È possibile utilizzare il codice seguente per verificare se il provider GPS e i provider di rete sono abilitati o meno.

LocationManager lm = (LocationManager)context.getSystemService(Context.LOCATION_SERVICE);
boolean gps_enabled = false;
boolean network_enabled = false;

try {
    gps_enabled = lm.isProviderEnabled(LocationManager.GPS_PROVIDER);
} catch(Exception ex) {}

try {
    network_enabled = lm.isProviderEnabled(LocationManager.NETWORK_PROVIDER);
} catch(Exception ex) {}

if(!gps_enabled && !network_enabled) {
    // notify user
    new AlertDialog.Builder(context)
        .setMessage(R.string.gps_network_not_enabled)
        .setPositiveButton(R.string.open_location_settings, new DialogInterface.OnClickListener() {
            @Override
            public void onClick(DialogInterface paramDialogInterface, int paramInt) {
                context.startActivity(new Intent(Settings.ACTION_LOCATION_SOURCE_SETTINGS));
            }
        }
        .setNegativeButton(R.string.Cancel,null)
        .show();    
}

E nel file manifest, dovrai aggiungere le seguenti autorizzazioni

<uses-permission android:name="android.permission.ACCESS_FINE_LOCATION"/>
<uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION"/>

Grazie per il codice Verifica del gestore della posizione: lm.getAllProviders().contains(LocationManager.GPS_PROVIDER)(o NETWORK_PROVIDER) assicurarsi che non si passi l'utente a una pagina delle impostazioni in cui non è presente alcuna opzione di rete.
petter

26
Inoltre: Settings.ACTION_SECURITY_SETTINGSdovrebbe essereSettings.ACTION_LOCATION_SOURCE_SETTINGS
petter il

2
è possibile verificare se il telefono è in modalità aereo e gestirlo .... stackoverflow.com/questions/4319212/…
John,

2
Ho avuto alcuni problemi con lm.isProviderEnabled (LocationManager.GPS_PROVIDER) che restituiva sempre false. Questo sembra accadere quando usi la nuova versione di Play Services: quella che mostra una finestra di dialogo in cui puoi attivare il tuo gps direttamente dalla finestra di dialogo, senza mostrare l'attività delle impostazioni. Quando l'utente gps gps da quella finestra di dialogo,
quell'istruzione

7
inoltre non dovrebbe mettere blocchi vuoti, confusi, inutili da provare
Chisko,

225

Uso questo codice per controllare:

public static boolean isLocationEnabled(Context context) {
    int locationMode = 0;
    String locationProviders;

    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT){
        try {
            locationMode = Settings.Secure.getInt(context.getContentResolver(), Settings.Secure.LOCATION_MODE);

        } catch (SettingNotFoundException e) {
            e.printStackTrace();
            return false;
        }

        return locationMode != Settings.Secure.LOCATION_MODE_OFF;

    }else{
        locationProviders = Settings.Secure.getString(context.getContentResolver(), Settings.Secure.LOCATION_PROVIDERS_ALLOWED);
        return !TextUtils.isEmpty(locationProviders);
    }


} 

7
Per chiarezza, potrebbe essere necessario restituire false nel blocco catch. Altrimenti inizializza locationMode su Settings.Secure.LOCATION_MODE_OFF.
RyanLeonard,

2
Questa è una buona risposta perché funziona con le vecchie e nuove API di localizzazione Android.
Diederik,

2
LOCATION_PROVIDERS_ALLOWED - link Questa costante è stata deprecata nel livello API 19. Dobbiamo usare LOCATION_MODE e MODE_CHANGED_ACTION (o PROVIDERS_CHANGED_ACTION)
Choletski

3
Questa risposta avrebbe dovuto essere accettata come risposta corretta. Il metodo locationManager.isProviderEnabled () non è affidabile sul mio dispositivo 4.4 (e come ho visto altri sviluppatori hanno avuto lo stesso problema anche su altre versioni del sistema operativo). Nel mio caso restituisce true per il GPS in ogni caso (non importa se i servizi di localizzazione sono abilitati o meno). Grazie per questa ottima soluzione!
strongmayer,

2
Questo non ha funzionato sul mio dispositivo di prova, Samsung SHV-E160K, Android 4.1.2, API 16. Anche se faccio il GPS offline, questa funzione torna comunque vera. Ho testato su Android Nougat, API 7.1 funziona
HendraWD il

38

Come ora nel 2020

Il modo più recente, migliore e più breve è

public static Boolean isLocationEnabled(Context context)
    {
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P) {
// This is new method provided in API 28
            LocationManager lm = (LocationManager) context.getSystemService(Context.LOCATION_SERVICE);
            return lm.isLocationEnabled();
        } else {
// This is Deprecated in API 28
            int mode = Settings.Secure.getInt(context.getContentResolver(), Settings.Secure.LOCATION_MODE,
                    Settings.Secure.LOCATION_MODE_OFF);
            return  (mode != Settings.Secure.LOCATION_MODE_OFF);

        }
    }

1
Eccellente! Ma ancora meglio, sbarazzarsi di fusione e di passare direttamente LocationManager.classnel getSystemServicemetodo perché chiamata richiede API 23 ;-)
Mackovich

6
In alternativa, è possibile utilizzare LocationManagerCompat . :)
Mokkun,

Usa return lm! = Null && lm.isLocationEnabled (); invece di return lm.isLocationEnabled ();
Dr. DS,

35

Puoi utilizzare questo codice per indirizzare gli utenti alle Impostazioni, dove possono abilitare il GPS:

    locationManager = (LocationManager) context.getSystemService(Context.LOCATION_SERVICE);
    if( !locationManager.isProviderEnabled(LocationManager.GPS_PROVIDER) ) {
        new AlertDialog.Builder(context)
            .setTitle(R.string.gps_not_found_title)  // GPS not found
            .setMessage(R.string.gps_not_found_message) // Want to enable?
            .setPositiveButton(R.string.yes, new DialogInterface.OnClickListener() {
                public void onClick(DialogInterface dialogInterface, int i) {
                    owner.startActivity(new Intent(android.provider.Settings.ACTION_LOCATION_SOURCE_SETTINGS));
                }
            })
            .setNegativeButton(R.string.no, null)
            .show();
    }

1
Mille grazie, ma non ho bisogno del codice per controllare il GPS, ma solo i servizi di localizzazione.
Meroelyth,

1
i servizi di localizzazione sono sempre disponibili, ma i diversi provider potrebbero non essere disponibili.
lenik,

4
@lenik, alcuni dispositivi forniscono un'impostazione (in "Impostazioni> Personali> Servizi di localizzazione> Accesso alla mia posizione") che sembra abilitare / disabilitare del tutto il rilevamento della posizione, anche se specifici provider sono abilitati. L'ho visto di prima mano con un telefono con cui stavo testando e, sebbene sia il Wifi che il GPS fossero abilitati, sembravano morti ... alla mia app. Sfortunatamente, da allora ho abilitato l'impostazione e non riesco più a riprodurre lo scenario originale, anche quando disabilito l'impostazione "Accesso alla mia posizione". Quindi non posso dire se questa impostazione influisce sui metodi isProviderEnabled()e getProviders(true).
The Awnry Bear,

... Volevo solo buttarlo là fuori nel caso qualcun altro si imbattesse nello stesso problema. Non avevo mai visto l'impostazione prima su altri dispositivi con cui ho provato. Sembra essere una sorta di interruttore di interruzione del rilevamento della posizione a livello di sistema. Se qualcuno ha qualche esperienza su come rispondono i metodi isProviderEnabled()e getProviders(true)quando tale impostazione è abilitata (o disabilitata, a seconda di come la guardi), sarei molto curioso di sapere cosa hai riscontrato.
The Awnry Bear,

25

Migrare su Android X e utilizzarlo

implementation 'androidx.appcompat:appcompat:1.1.0'

e usa LocationManagerCompat

A java

private boolean isLocationEnabled(Context context) {
    LocationManager locationManager = (LocationManager) context.getSystemService(Context.LOCATION_SERVICE);
    return LocationManagerCompat.isLocationEnabled(locationManager);
}

A Kotlin

private fun isLocationEnabled(context: Context): Boolean {
    val locationManager = context.getSystemService(Context.LOCATION_SERVICE) as LocationManager
    return LocationManagerCompat.isLocationEnabled(locationManager)
}

Funziona con tutte le versioni di Android da Android 1.0. Ma nota Before API version LOLLIPOP [API Level 21], this method would throw SecurityException if the location permissions were not sufficient to use the specified provider.Quindi se non si dispone dell'autorizzazione per la rete o il provider GPS, potrebbe generare un'eccezione, a seconda di quale è abilitato. Controlla il codice sorgente per maggiori informazioni.
xuiqzy

15

A partire dalla risposta sopra, in API 23 è necessario aggiungere controlli di autorizzazioni "pericolose" e verificare il sistema stesso:

public static boolean isLocationServicesAvailable(Context context) {
    int locationMode = 0;
    String locationProviders;
    boolean isAvailable = false;

    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT){
        try {
            locationMode = Settings.Secure.getInt(context.getContentResolver(), Settings.Secure.LOCATION_MODE);
        } catch (Settings.SettingNotFoundException e) {
            e.printStackTrace();
        }

        isAvailable = (locationMode != Settings.Secure.LOCATION_MODE_OFF);
    } else {
        locationProviders = Settings.Secure.getString(context.getContentResolver(), Settings.Secure.LOCATION_PROVIDERS_ALLOWED);
        isAvailable = !TextUtils.isEmpty(locationProviders);
    }

    boolean coarsePermissionCheck = (ContextCompat.checkSelfPermission(context, Manifest.permission.ACCESS_COARSE_LOCATION) == PackageManager.PERMISSION_GRANTED);
    boolean finePermissionCheck = (ContextCompat.checkSelfPermission(context, Manifest.permission.ACCESS_FINE_LOCATION) == PackageManager.PERMISSION_GRANTED);

    return isAvailable && (coarsePermissionCheck || finePermissionCheck);
}

Impossibile risolvere il simbolo Manifest.permission.ACCESS_COARSE_LOCATION e Manifest.permission.ACCESS_FINE_LOCATION
Gennady Kozlov,

Usa android.Manifest.permission.ACCESS_FINE_LOCATION
aLIEz

7

Se nessun provider è abilitato, "passivo" è il miglior provider restituito. Vedi https://stackoverflow.com/a/4519414/621690

    public boolean isLocationServiceEnabled() {
        LocationManager lm = (LocationManager)
                this.getSystemService(Context.LOCATION_SERVICE);
        String provider = lm.getBestProvider(new Criteria(), true);
        return (StringUtils.isNotBlank(provider) &&
                !LocationManager.PASSIVE_PROVIDER.equals(provider));
    }

7

Sì, puoi controllare di seguito il codice:

public boolean isGPSEnabled(Context mContext) 
{
    LocationManager lm = (LocationManager)
    mContext.getSystemService(Context.LOCATION_SERVICE);
    return lm.isProviderEnabled(LocationManager.GPS_PROVIDER);
}

con l'autorizzazione nel file manifest:

<uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />

6

Questa clausola if verifica facilmente se i servizi di localizzazione sono disponibili secondo me:

LocationManager locationManager = (LocationManager) getSystemService(Context.LOCATION_SERVICE);
if(!locationManager.isProviderEnabled(LocationManager.GPS_PROVIDER) && !locationManager.isProviderEnabled(LocationManager.NETWORK_PROVIDER)) {
        //All location services are disabled

}

4

Uso questo modo per NETWORK_PROVIDER ma è possibile aggiungere e per GPS .

LocationManager locationManager;

In onCreate ho messo

   isLocationEnabled();
   if(!isLocationEnabled()) {
        AlertDialog.Builder builder = new AlertDialog.Builder(MainActivity.this);
        builder.setTitle(R.string.network_not_enabled)
                .setMessage(R.string.open_location_settings)
                .setPositiveButton(R.string.yes,
                        new DialogInterface.OnClickListener() {
                            public void onClick(DialogInterface dialog, int id) {
                                startActivity(new Intent(Settings.ACTION_LOCATION_SOURCE_SETTINGS));
                            }
                        })
                .setNegativeButton(R.string.cancel,
                        new DialogInterface.OnClickListener() {
                            public void onClick(DialogInterface dialog, int id) {
                                dialog.cancel();
                            }
                        });
        AlertDialog alert = builder.create();
        alert.show();
    } 

E metodo di controllo

protected boolean isLocationEnabled(){
    String le = Context.LOCATION_SERVICE;
    locationManager = (LocationManager) getSystemService(le);
    if(!locationManager.isProviderEnabled(LocationManager.NETWORK_PROVIDER)){
        return false;
    } else {
        return true;
    }
}

2
Non hai bisogno di if-then-else, puoi semplicemente tornarelocationManager.isProviderEnabled(LocationManager.NETWORK_PROVIDER);
LadyWoodi,

4

Questo è un metodo molto utile che restituisce " true" se Location servicessono abilitati:

public static boolean locationServicesEnabled(Context context) {
        LocationManager lm = (LocationManager) context.getSystemService(Context.LOCATION_SERVICE);
        boolean gps_enabled = false;
        boolean net_enabled = false;

        try {
            gps_enabled = lm.isProviderEnabled(LocationManager.GPS_PROVIDER);
        } catch (Exception ex) {
            Log.e(TAG,"Exception gps_enabled");
        }

        try {
            net_enabled = lm.isProviderEnabled(LocationManager.NETWORK_PROVIDER);
        } catch (Exception ex) {
            Log.e(TAG,"Exception network_enabled");
        }
        return gps_enabled || net_enabled;
}

3

Per ottenere la posizione geografica corrente su google maps Android, devi attivare l' opzione di posizione del dispositivo. Per verificare se la posizione è attiva o meno, puoi semplicemente chiamare questo metodo dal tuo onCreate()metodo.

private void checkGPSStatus() {
    LocationManager locationManager = null;
    boolean gps_enabled = false;
    boolean network_enabled = false;
    if ( locationManager == null ) {
        locationManager = (LocationManager) getSystemService(Context.LOCATION_SERVICE);
    }
    try {
        gps_enabled = locationManager.isProviderEnabled(LocationManager.GPS_PROVIDER);
    } catch (Exception ex){}
    try {
        network_enabled = locationManager.isProviderEnabled(LocationManager.NETWORK_PROVIDER);
    } catch (Exception ex){}
    if ( !gps_enabled && !network_enabled ){
        AlertDialog.Builder dialog = new AlertDialog.Builder(MyActivity.this);
        dialog.setMessage("GPS not enabled");
        dialog.setPositiveButton("Ok", new DialogInterface.OnClickListener() {

            @Override
            public void onClick(DialogInterface dialog, int which) {
                //this will navigate user to the device location settings screen
                Intent intent = new Intent(Settings.ACTION_LOCATION_SOURCE_SETTINGS);
                startActivity(intent);
            }
        });
        AlertDialog alert = dialog.create();
        alert.show();
    }
}

3

Per kotlin

 private fun isLocationEnabled(mContext: Context): Boolean {
    val lm = mContext.getSystemService(Context.LOCATION_SERVICE) as LocationManager
    return lm.isProviderEnabled(LocationManager.GPS_PROVIDER) || lm.isProviderEnabled(
            LocationManager.NETWORK_PROVIDER)
 }

dialogo

private fun showLocationIsDisabledAlert() {
    alert("We can't show your position because you generally disabled the location service for your device.") {
        yesButton {
        }
        neutralPressed("Settings") {
            startActivity(Intent(Settings.ACTION_LOCATION_SOURCE_SETTINGS))
        }
    }.show()
}

chiama così

 if (!isLocationEnabled(this.context)) {
        showLocationIsDisabledAlert()
 }

Suggerimento: la finestra di dialogo richiede le seguenti importazioni (Android Studio dovrebbe gestirlo per te)

import org.jetbrains.anko.alert
import org.jetbrains.anko.noButton

E nel manifest sono necessarie le seguenti autorizzazioni

<uses-permission android:name="android.permission.ACCESS_FINE_LOCATION"/>
<uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION"/>

2

Puoi richiedere gli aggiornamenti della posizione e mostrare la finestra di dialogo insieme, come anche GoogleMaps doas. Ecco il codice:

googleApiClient = new GoogleApiClient.Builder(getActivity())
                .addApi(LocationServices.API)
                .addConnectionCallbacks(this)
                .addOnConnectionFailedListener(this).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); //this is the key ingredient

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();
        final LocationSettingsStates state = result.getLocationSettingsStates();
        switch (status.getStatusCode()) {
            case LocationSettingsStatusCodes.SUCCESS:
                // All location settings are satisfied. The client can initialize location
                // requests here.
                break;
            case LocationSettingsStatusCodes.RESOLUTION_REQUIRED:
                // 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(getActivity(), 1000);
                } catch (IntentSender.SendIntentException ignored) {}
                break;
            case LocationSettingsStatusCodes.SETTINGS_CHANGE_UNAVAILABLE:
                // Location settings are not satisfied. However, we have no way to fix the
                // settings so we won't show the dialog.
                break;
            }
        }
    });
}

Se hai bisogno di maggiori informazioni controlla la classe LocationRequest .


Ciao, ho avuto difficoltà negli ultimi due giorni per ottenere la posizione corrente dell'utente. Ho bisogno dell'attuale lat long dell'utente, so che può essere fatto utilizzando il client API di Google. Ma come integrare l'autorizzazione marshmallow in esso. Inoltre, se i servizi di localizzazione dell'utente vengono disattivati, come abilitarlo. Puoi aiutare?
Chetna,

Ciao! hai molte domande, a cosa non posso rispondere nei commenti. Per favore, fai una nuova domanda in modo che io possa rispondere più ufficialmente!
Bendaf,

Ho pubblicato la mia domanda qui: stackoverflow.com/questions/39327480/…
Chetna

2

io uso il primo codice inizio creare metodo isLocationEnabled

 private LocationManager locationManager ;

protected boolean isLocationEnabled(){
        String le = Context.LOCATION_SERVICE;
        locationManager = (LocationManager) getSystemService(le);
        if(!locationManager.isProviderEnabled(LocationManager.NETWORK_PROVIDER)){
            return false;
        } else {
            return true;
        }
    }

e controllo Condizione se tura Apri la mappa e false intento ACTION_LOCATION_SOURCE_SETTINGS

    if (isLocationEnabled()) {
        SupportMapFragment mapFragment = (SupportMapFragment) getSupportFragmentManager()
                .findFragmentById(R.id.map);
        mapFragment.getMapAsync(this);

        locationClient = getFusedLocationProviderClient(this);
        locationClient.getLastLocation()
                .addOnSuccessListener(new OnSuccessListener<Location>() {
                    @Override
                    public void onSuccess(Location location) {
                        // GPS location can be null if GPS is switched off
                        if (location != null) {
                            onLocationChanged(location);

                            Log.e("location", String.valueOf(location.getLongitude()));
                        }
                    }
                })
                .addOnFailureListener(new OnFailureListener() {
                    @Override
                    public void onFailure(@NonNull Exception e) {
                        Log.e("MapDemoActivity", e.toString());
                        e.printStackTrace();
                    }
                });


        startLocationUpdates();

    }
    else {
        new AlertDialog.Builder(this)
                .setTitle("Please activate location")
                .setMessage("Click ok to goto settings else exit.")
                .setPositiveButton(android.R.string.yes, new DialogInterface.OnClickListener() {
                    public void onClick(DialogInterface dialog, int which) {
                        Intent intent = new Intent(Settings.ACTION_LOCATION_SOURCE_SETTINGS);
                        startActivity(intent);
                    }
                })
                .setNegativeButton(android.R.string.no, new DialogInterface.OnClickListener() {
                    public void onClick(DialogInterface dialog, int which) {
                        System.exit(0);
                    }
                })
                .show();
    }

inserisci qui la descrizione dell'immagine


1

Può fare nel modo più semplice

private boolean isLocationEnabled(Context context){
int mode =Settings.Secure.getInt(context.getContentResolver(), Settings.Secure.LOCATION_MODE,
                        Settings.Secure.LOCATION_MODE_OFF);
                final boolean enabled = (mode != android.provider.Settings.Secure.LOCATION_MODE_OFF);
return enabled;
}

1

Se si utilizza AndroidX, utilizzare il codice seguente per verificare che il servizio di localizzazione sia abilitato o meno:

fun isNetworkServiceEnabled(context: Context) = LocationManagerCompat.isLocationEnabled(context.getSystemService(LocationManager::class.java))

0

Per verificare la presenza del provider di rete, è sufficiente modificare la stringa passata a isProviderEnabled in LocationManager.NETWORK_PROVIDER se si controllano i valori di ritorno sia per il provider GPS che per il provider NETwork - entrambi false indicano l'assenza di servizi di localizzazione


0
private boolean isGpsEnabled()
{
    LocationManager service = (LocationManager) getSystemService(LOCATION_SERVICE);
    return service.isProviderEnabled(LocationManager.GPS_PROVIDER)&&service.isProviderEnabled(LocationManager.NETWORK_PROVIDER);
}

0
    LocationManager lm = (LocationManager)this.getSystemService(Context.LOCATION_SERVICE);
    boolean gps_enabled = false;
    boolean network_enabled = false;

    try {
        gps_enabled = lm.isProviderEnabled(LocationManager.GPS_PROVIDER);
    } catch(Exception e){
         e.printStackTrace();
    }

    try {
        network_enabled = lm.isProviderEnabled(LocationManager.NETWORK_PROVIDER);
    } catch(Exception e){
         e.printStackTrace();
    }

    if(!gps_enabled && !network_enabled) {
        // notify user
        new AlertDialog.Builder(this)
                .setMessage("Please turn on Location to continue")
                .setPositiveButton("Open Location Settings", new DialogInterface.OnClickListener() {
                    @Override
                    public void onClick(DialogInterface paramDialogInterface, int paramInt) {
                        startActivity(new Intent(Settings.ACTION_LOCATION_SOURCE_SETTINGS));
                    }

                }).
                setNegativeButton("Cancel",null)
                .show();
    }

0
public class LocationUtil {
private static final String TAG = LocationUtil.class.getSimpleName();

public static LocationManager getLocationManager(final Context context) {
    return (LocationManager) context.getSystemService(Context.LOCATION_SERVICE);
}

public static boolean isNetworkProviderEnabled(final Context context) {
    return getLocationManager(context).isProviderEnabled(LocationManager.NETWORK_PROVIDER);
}

public static boolean isGpsProviderEnabled(final Context context) {
    return getLocationManager(context).isProviderEnabled(LocationManager.GPS_PROVIDER);
}

// Returns true even if the location services are disabled. Do not use this method to detect location services are enabled.
private static boolean isPassiveProviderEnabled(final Context context) {
    return getLocationManager(context).isProviderEnabled(LocationManager.PASSIVE_PROVIDER);
}

public static boolean isLocationModeOn(final Context context) throws Exception {
    int locationMode = Settings.Secure.getInt(context.getContentResolver(), Settings.Secure.LOCATION_MODE);
    return locationMode != Settings.Secure.LOCATION_MODE_OFF;
}

public static boolean isLocationEnabled(final Context context) {
    try {
        return isNetworkProviderEnabled(context) || isGpsProviderEnabled(context)  || isLocationModeOn(context);
    } catch (Exception e) {
        Log.e(TAG, "[isLocationEnabled] error:", e);
    }
    return false;
}

public static void gotoLocationSettings(final Activity activity, final int requestCode) {
    Intent intent = new Intent(Settings.ACTION_LOCATION_SOURCE_SETTINGS);
    activity.startActivityForResult(intent, requestCode);
}

public static String getEnabledProvidersLogMessage(final Context context){
    try{
        return "[getEnabledProvidersLogMessage] isNetworkProviderEnabled:"+isNetworkProviderEnabled(context) +
                ", isGpsProviderEnabled:" + isGpsProviderEnabled(context) +
                ", isLocationModeOn:" + isLocationModeOn(context) +
                ", isPassiveProviderEnabled(ignored):" + isPassiveProviderEnabled(context);
    }catch (Exception e){
        Log.e(TAG, "[getEnabledProvidersLogMessage] error:", e);
        return "provider error";
    }
}

}

Utilizzare il metodo isLocationEnabled per rilevare i servizi di localizzazione abilitati.

La pagina https://github.com/Polidea/RxAndroidBle/issues/327# fornirà ulteriori informazioni sul perché non utilizzare il provider passivo, invece utilizzare la modalità di localizzazione.

Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.