Comment vérifier si les services de localisation sont activés?

228

Je développe une application sur Android OS. Je ne sais pas comment vérifier si les services de localisation sont activés ou non.

J'ai besoin d'une méthode qui renvoie "true" si elles sont activées et "false" sinon (donc dans le dernier cas, je peux afficher une boîte de dialogue pour les activer).

Meroelyth
la source
3
Je sais que c'est un vieux sujet, mais pour ceux qui pourraient suivre ... Google a publié une API pour cela; voir developers.google.com/android/reference/com/google/android/gms/…
Peter McLennan
FYI: SettingsApi est obsolète maintenant. Utilisez plutôt developers.google.com/android/reference/com/google/android/gms/… .
Rajiv

Réponses:

361

Vous pouvez utiliser le code ci-dessous pour vérifier si le fournisseur gps et les fournisseurs réseau sont activés ou non.

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();    
}

Et dans le fichier manifeste, vous devrez ajouter les autorisations suivantes

<uses-permission android:name="android.permission.ACCESS_FINE_LOCATION"/>
<uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION"/>
Shankar Agarwal
la source
Merci pour le code. La vérification du gestionnaire d'emplacement: lm.getAllProviders().contains(LocationManager.GPS_PROVIDER)(ou NETWORK_PROVIDER) garantirait que vous ne jetez pas l'utilisateur à une page de paramètres où il n'y a pas d'option réseau.
Petter
26
Aussi: Settings.ACTION_SECURITY_SETTINGSdevrait êtreSettings.ACTION_LOCATION_SOURCE_SETTINGS
Petter
2
vous pouvez vérifier si le téléphone est en mode avion et le gérer .... stackoverflow.com/questions/4319212/…
John
2
J'ai eu quelques problèmes avec lm.isProviderEnabled (LocationManager.GPS_PROVIDER) qui retournait toujours faux. Cela semble se produire lorsque vous utilisez la nouvelle version de Play Services: celle qui affiche une boîte de dialogue dans laquelle vous pouvez activer votre gps directement depuis la boîte de dialogue, sans afficher l'activité des paramètres. Lorsque l'utilisateur transforme le gps à partir de cette boîte de dialogue, cette déclaration retourne toujours false, même lorsque le gps est
activé
7
ne devrait pas non plus mettre des blocs d'essai vides, déroutants et inutiles
Chisko
225

J'utilise ce code pour vérifier:

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);
    }


} 
Sapin de Slava
la source
7
Pour plus de clarté, vous pourriez vouloir retourner false dans le bloc catch. Sinon, initialisez locationMode sur Settings.Secure.LOCATION_MODE_OFF.
RyanLeonard
2
C'est une bonne réponse car elle fonctionne avec les anciennes et les nouvelles API de localisation Android.
Diederik
2
LOCATION_PROVIDERS_ALLOWED - lien Cette constante était déconseillée au niveau API 19. Nous devons utiliser LOCATION_MODE et MODE_CHANGED_ACTION (ou PROVIDERS_CHANGED_ACTION)
Choletski
3
Cette réponse aurait dû être acceptée comme la bonne réponse. La méthode locationManager.isProviderEnabled () n'est pas fiable sur mon appareil 4.4 (et comme je l'ai vu, d'autres développeurs ont eu le même problème sur d'autres versions de système d'exploitation). Dans mon cas, cela retourne vrai pour le GPS dans chaque cas (peu importe si les services de localisation sont activés ou non). Merci pour cette excellente solution!
strongmayer
2
Cela n'a pas fonctionné sur mon appareil de test, Samsung SHV-E160K, android 4.1.2, API 16. Bien que je rende le GPS hors ligne, cette fonction reste vraie. J'ai testé sur Android Nougat, l'API 7.1 ça marche
HendraWD
38

Comme maintenant en 2020

Dernier moyen, le meilleur et le plus court

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);

        }
    }
Mayank Sharma
la source
1
Excellent! Mais encore mieux, se débarrasser de la coulée et passer directement LocationManager.classen getSystemServiceméthode parce que l' appel nécessite API 23 ;-)
Mackovich
6
Vous pouvez également utiliser LocationManagerCompat à la place. :)
Mokkun
Utilisez return lm! = Null && lm.isLocationEnabled (); au lieu de renvoyer lm.isLocationEnabled ();
Dr DS
35

Vous pouvez utiliser ce code pour diriger les utilisateurs vers les paramètres, où ils peuvent activer le 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();
    }
lenik
la source
1
Merci beaucoup, mais je n'ai pas besoin du code pour vérifier le GPS mais seulement des services de localisation.
Meroelyth
1
les services de localisation sont toujours disponibles, mais les différents fournisseurs peuvent ne pas être disponibles.
lenik
4
@lenik, certains appareils fournissent un paramètre (sous "Paramètres> Personnel> Services de localisation> Accès à ma position") qui semble activer / désactiver complètement la détection de position, même si des fournisseurs spécifiques sont activés. J'ai vu cela de première main avec un téléphone avec lequel je testais, et même si le Wifi et le GPS étaient activés, ils semblaient morts ... à mon application. Malheureusement, j'ai depuis activé le paramètre et je ne peux plus reproduire le scénario d'origine, même en désactivant ce paramètre "Accès à mon emplacement". Je ne peux donc pas dire si ce paramètre affecte les méthodes isProviderEnabled()et getProviders(true).
The Awnry Bear
... Je voulais juste jeter ça là-bas au cas où quelqu'un d'autre rencontrerait le même problème. Je n'avais jamais vu le paramètre auparavant sur d'autres appareils avec lesquels j'ai testé. Il semble s'agir d'une sorte de coupe-circuit de détection d'emplacement à l'échelle du système. Si quelqu'un a une expérience concernant la façon dont les méthodes isProviderEnabled()et getProviders(true)réagissent lorsqu'un tel paramètre est activé (ou désactivé, selon la façon dont vous le regardez), je serais très curieux de savoir ce que vous avez rencontré.
The Awnry Bear
25

Migrer vers Android X et utiliser

implementation 'androidx.appcompat:appcompat:1.1.0'

et utilisez LocationManagerCompat

En java

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

À Kotlin

private fun isLocationEnabled(context: Context): Boolean {
    val locationManager = context.getSystemService(Context.LOCATION_SERVICE) as LocationManager
    return LocationManagerCompat.isLocationEnabled(locationManager)
}
Ensoleillé
la source
Cela fonctionne pour toutes les versions d'Android depuis Android 1.0. Mais notez Before API version LOLLIPOP [API Level 21], this method would throw SecurityException if the location permissions were not sufficient to use the specified provider.donc que si vous n'avez pas d'autorisation pour le réseau ou le fournisseur gps, il peut lever une exception, selon ce qui est activé. Vérifiez le code source pour plus d'informations.
xuiqzy à 9h37
15

En partant de la réponse ci-dessus, dans l'API 23, vous devez ajouter des vérifications d'autorisations "dangereuses" ainsi que la vérification du système lui-même:

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);
}
ZaBlanc
la source
Impossible de résoudre le symbole Manifest.permission.ACCESS_COARSE_LOCATION et Manifest.permission.ACCESS_FINE_LOCATION
Gennady Kozlov
Utilisez android.Manifest.permission.ACCESS_FINE_LOCATION
aLIEz
7

Si aucun fournisseur n'est activé, «passif» est le meilleur fournisseur renvoyé. Voir 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));
    }
Risadinha
la source
7

Oui, vous pouvez vérifier ci-dessous le code:

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

avec l'autorisation dans le fichier manifeste:

<uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />
Arun kumar
la source
6

Cette clause if vérifie facilement si les services de localisation sont disponibles à mon avis:

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

}
tsemann
la source
4

J'utilise de cette façon pour NETWORK_PROVIDER mais vous pouvez ajouter et pour GPS .

LocationManager locationManager;

Dans onCreate je mets

   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();
    } 

Et méthode de vérification

protected boolean isLocationEnabled(){
    String le = Context.LOCATION_SERVICE;
    locationManager = (LocationManager) getSystemService(le);
    if(!locationManager.isProviderEnabled(LocationManager.NETWORK_PROVIDER)){
        return false;
    } else {
        return true;
    }
}
P. Dm
la source
2
Vous n'avez pas besoin de if-then-else, vous pouvez simplement revenirlocationManager.isProviderEnabled(LocationManager.NETWORK_PROVIDER);
LadyWoodi
4

C'est une méthode très utile qui retourne " true" si les Location servicessont activés:

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;
}
Jorgesys
la source
3

Pour obtenir l' emplacement géographique actuel dans Android Google Maps, vous devez activer l' option de localisation de votre appareil.Pour vérifier si l'emplacement est activé ou non, vous pouvez simplement appeler cette méthode à partir de votre onCreate()méthode.

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();
    }
}
Ashana.Jackol
la source
3

Pour 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)
 }

dialogue

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()
}

appeler comme ça

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

Astuce: la boîte de dialogue a besoin des importations suivantes (Android Studio devrait gérer cela pour vous)

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

Et dans le manifeste, vous avez besoin des autorisations suivantes

<uses-permission android:name="android.permission.ACCESS_FINE_LOCATION"/>
<uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION"/>
kuzdu
la source
2

Vous pouvez demander les mises à jour de l'emplacement et afficher la boîte de dialogue ensemble, comme les doas GoogleMaps également. Voici le code:

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;
            }
        }
    });
}

Si vous avez besoin de plus d'informations, consultez la classe LocationRequest .

bendaf
la source
Bonjour, j'ai du mal depuis deux jours à obtenir l'emplacement actuel de l'utilisateur. J'ai besoin de la lat lat actuelle de l'utilisateur, je sais que cela peut être fait en utilisant le client google api. Mais comment y intégrer l'autorisation de guimauve. De plus, si les services de localisation de l'utilisateur sont désactivés, comment l'activer. Pouvez-vous m'aider?
Chetna
Salut! vous avez beaucoup de questions, ce que je ne peux pas répondre dans les commentaires. Veuillez poser une nouvelle question pour que je puisse y répondre plus officiellement!
bendaf
J'ai posté ma question ici: stackoverflow.com/questions/39327480/…
Chetna
2

j'utilise le premier code commence la méthode de création 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;
        }
    }

et je vérifie Condition si tu ouvres la carte et donne une fausse intention 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();
    }

entrez la description de l'image ici

Pong Petrung
la source
1

Peut faire de la manière la plus simple

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;
}
Vinayak
la source
1

Si vous utilisez AndroidX, utilisez le code ci-dessous pour vérifier que le service de localisation est activé ou non:

fun isNetworkServiceEnabled(context: Context) = LocationManagerCompat.isLocationEnabled(context.getSystemService(LocationManager::class.java))
btimalsina
la source
0

Pour vérifier le fournisseur de réseau, il vous suffit de remplacer la chaîne transmise à isProviderEnabled par LocationManager.NETWORK_PROVIDER si vous vérifiez les valeurs de retour pour le fournisseur GPS et le fournisseur NETwork - les deux false signifie aucun service de localisation

gheese
la source
0
private boolean isGpsEnabled()
{
    LocationManager service = (LocationManager) getSystemService(LOCATION_SERVICE);
    return service.isProviderEnabled(LocationManager.GPS_PROVIDER)&&service.isProviderEnabled(LocationManager.NETWORK_PROVIDER);
}
Rahul
la source
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();
    }
Adarsh ​​D
la source
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";
    }
}

}

Utilisez la méthode isLocationEnabled pour détecter que les services de localisation sont activés.

https://github.com/Polidea/RxAndroidBle/issues/327# page donnera plus d'informations pourquoi ne pas utiliser le fournisseur passif, utilisez plutôt le mode de localisation.

alperk01
la source