¿Cómo verificar si los servicios de ubicación están habilitados?

228

Estoy desarrollando una aplicación en el sistema operativo Android. No sé cómo verificar si los Servicios de ubicación están habilitados o no.

Necesito un método que devuelva "verdadero" si están habilitados y "falso" si no (así que en el último caso puedo mostrar un diálogo para habilitarlos).

Meroelyth
fuente
3
Sé que este es un tema antiguo, pero para aquellos que puedan seguir ... Google ha lanzado una API para esto; ver developers.google.com/android/reference/com/google/android/gms/…
Peter McLennan
Tengo una pregunta similar aquí con códigos. Echale un vistazo. Muy útil.
S bruce
FYI: SettingsApi está en desuso ahora. Utilice developers.google.com/android/reference/com/google/android/gms/… en su lugar.
Rajiv

Respuestas:

361

Puede usar el siguiente código para verificar si el proveedor gps y los proveedores de la red están habilitados o no.

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

Y en el archivo de manifiesto, deberá agregar los siguientes permisos

<uses-permission android:name="android.permission.ACCESS_FINE_LOCATION"/>
<uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION"/>
Shankar Agarwal
fuente
Gracias por el codigo. Verificando el administrador de ubicación: lm.getAllProviders().contains(LocationManager.GPS_PROVIDER)(o NETWORK_PROVIDER) se aseguraría de no lanzar al usuario a una página de configuración donde no hay una opción de red.
petter
26
También: Settings.ACTION_SECURITY_SETTINGSdebería serSettings.ACTION_LOCATION_SOURCE_SETTINGS
petter
2
puede verificar si el teléfono está en modo avión y manejarlo ... stackoverflow.com/questions/4319212/…
John
2
Tuve algunos problemas con lm.isProviderEnabled (LocationManager.GPS_PROVIDER) que solía devolver siempre falso. Esto parece ocurrir cuando usa la nueva versión de Play Services: aquella que muestra un cuadro de diálogo en el que puede activar su GPS directamente desde el cuadro de diálogo, sin mostrar la actividad de configuración. Cuando el usuario cambia a gps desde ese diálogo, esa declaración siempre es falsa, incluso cuando gps está
activado
77
tampoco debería poner bloques vacíos, confusos e inútiles de try-catch
Chisko
225

Yo uso este código para verificar:

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


} 
Abeto Slava
fuente
77
Para mayor claridad, es posible que desee devolver falso en el bloque catch. De lo contrario, inicialice locationMode a Settings.Secure.LOCATION_MODE_OFF.
RyanLeonard
2
Esta es una buena respuesta porque funciona con las API de ubicación de Android antiguas y nuevas.
Diederik
2
LOCATION_PROVIDERS_ALLOWED: enlace Esta constante fue obsoleta en el nivel 19 de API. Debemos usar LOCATION_MODE y MODE_CHANGED_ACTION (o PROVIDERS_CHANGED_ACTION)
Choletski el
3
Esta respuesta debería haber sido aceptada como la respuesta correcta. El método locationManager.isProviderEnabled () no es confiable en mi dispositivo 4.4 (y como vi, otros desarrolladores también tuvieron el mismo problema en otras versiones del sistema operativo). En mi caso, devuelve verdadero para GPS en cada caso (no importa si los servicios de ubicación están habilitados o no). ¡Gracias por esta gran solución!
strongmayer
2
Esto no funcionó en mi dispositivo de prueba, Samsung SHV-E160K, Android 4.1.2, API 16. Aunque pongo el GPS fuera de línea, esta función sigue siendo verdadera.
Probé
38

Como ahora en 2020

El último, mejor y más corto camino es

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
fuente
1
Excelente! Pero aún mejor, deshacerse de fundición y pasar directamente LocationManager.classen el getSystemServicemétodo porque llamada requiere API 23 ;-)
Mackovich
66
O podría usar LocationManagerCompat en su lugar. :)
Mokkun
Utilice return lm! = Null && lm.isLocationEnabled (); en lugar de return lm.isLocationEnabled ();
Dr. DS
35

Puede usar este código para dirigir a los usuarios a la Configuración, donde pueden habilitar el 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
fuente
1
Muchas gracias, pero no necesito el código para verificar el GPS, solo los servicios de ubicación.
Meroelyth
1
los servicios de ubicación siempre están disponibles, pero los diferentes proveedores pueden no estar disponibles.
lenik
44
@lenik, algunos dispositivos proporcionan una configuración (en "Configuración> Personal> Servicios de ubicación> Acceso a mi ubicación") que parece habilitar / deshabilitar la detección de ubicación por completo, incluso si los proveedores específicos están habilitados. Vi esto de primera mano con un teléfono con el que estaba probando, y aunque tanto Wifi como GPS estaban habilitados, parecían muertos ... para mi aplicación. Desafortunadamente, desde entonces habilité la configuración y ya no puedo reproducir el escenario original, incluso al deshabilitar esa configuración de "Acceso a mi ubicación". Así que no puedo decir si esa configuración afecta los métodos isProviderEnabled()y getProviders(true).
The Awnry Bear
... Solo quería tirar eso por si alguien más se encuentra con el mismo problema. Nunca antes había visto la configuración en otros dispositivos con los que he probado. Parece ser un interruptor de matar de detección de ubicación en todo el sistema. Si alguien tiene alguna experiencia con respecto a cómo responden los métodos isProviderEnabled()y getProviders(true)cuando esta configuración está habilitada (o deshabilitada, dependiendo de cómo lo mire), me gustaría saber qué ha encontrado.
The Awnry Bear
25

Migrar a Android X y usar

implementation 'androidx.appcompat:appcompat:1.1.0'

y usar LocationManagerCompat

En java

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

En kotlin

private fun isLocationEnabled(context: Context): Boolean {
    val locationManager = context.getSystemService(Context.LOCATION_SERVICE) as LocationManager
    return LocationManagerCompat.isLocationEnabled(locationManager)
}
Soleado
fuente
Esto funciona para todas las versiones de Android desde Android 1.0. Pero tenga en cuenta Before API version LOLLIPOP [API Level 21], this method would throw SecurityException if the location permissions were not sufficient to use the specified provider.que si no tiene permiso para la red o el proveedor de gps, podría lanzar una excepción, dependiendo de cuál esté habilitado. Consulte el código fuente para más información.
xuiqzy
15

A partir de la respuesta anterior, en API 23 necesita agregar verificaciones de permisos "peligrosos", así como verificar el propio sistema:

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
fuente
No se puede resolver el símbolo Manifest.permission.ACCESS_COARSE_LOCATION y Manifest.permission.ACCESS_FINE_LOCATION
Gennady Kozlov el
Utilice android.Manifest.permission.ACCESS_FINE_LOCATION
aLIEz el
7

Si no se habilita ningún proveedor, "pasivo" es el mejor proveedor devuelto. Ver 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
fuente
7

Sí, puedes consultar a continuación el código:

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

con el permiso en el archivo de manifiesto:

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

Esta cláusula if comprueba fácilmente si los servicios de ubicación están disponibles en mi opinión:

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

}
tsemann
fuente
4

Lo uso para NETWORK_PROVIDER, pero puede agregarlo y para GPS .

LocationManager locationManager;

En onCreate pongo

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

Y método de verificación

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
fuente
2
No necesita si, entonces, puede regresarlocationManager.isProviderEnabled(LocationManager.NETWORK_PROVIDER);
LadyWoodi
4

Este es un método muy útil que devuelve " true" si Location servicesestán habilitados:

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
fuente
3

Para obtener la ubicación geográfica actual en google google maps, debe activar la opción de ubicación de su dispositivo. Para verificar si la ubicación está activada o no, simplemente puede llamar a este método desde su onCreate()método.

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
fuente
3

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

diálogo

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

llama así

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

Sugerencia: el diálogo necesita las siguientes importaciones (Android Studio debería manejar esto por usted)

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

Y en el manifiesto necesitas los siguientes permisos

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

Puede solicitar las actualizaciones de ubicación y mostrar el cuadro de diálogo juntos, como también las mapas de GoogleMaps. Aquí está el código:

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 necesita más información, consulte la clase LocationRequest .

bendaf
fuente
Hola, he estado luchando desde los últimos dos días para obtener la ubicación actual del usuario. Necesito el lat actual del usuario, sé que se puede hacer con el cliente API de Google. Pero cómo integrar el permiso de malvavisco en él. Además, si se desactivan los servicios de ubicación del usuario, cómo habilitarlo. ¿Puede usted ayudar?
Chetna
¡Hola! Tienes muchas preguntas, lo que no puedo responder en los comentarios. ¡Haga una nueva pregunta para que pueda responderla más oficialmente!
bendaf
He publicado mi pregunta aquí: stackoverflow.com/questions/39327480/…
Chetna
2

utilizo el primer código para comenzar a crear el método 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;
        }
    }

y verifico Condición si está abierto el mapa y la intención falsa de dar 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();
    }

ingrese la descripción de la imagen aquí

Pong Petrung
fuente
1

Puede hacerlo de la manera más 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
fuente
1

Si está utilizando AndroidX, use el siguiente código para verificar que el Servicio de ubicación esté habilitado o no:

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

Para verificar el proveedor de red, solo necesita cambiar la cadena que se pasa a isProviderEnabled a LocationManager.NETWORK_PROVIDER si verifica los valores de retorno para el proveedor de GPS y el proveedor de NETwork; ambos falsos significa que no hay servicios de ubicación

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

}

Utilice el método isLocationEnabled para detectar si los servicios de ubicación están habilitados.

La página https://github.com/Polidea/RxAndroidBle/issues/327# le dará más información sobre por qué no usar un proveedor pasivo, en su lugar use el modo de ubicación.

alperk01
fuente