Como verificar se os Serviços de Localização estão habilitados?

228

Estou desenvolvendo um aplicativo no sistema operacional Android. Não sei como verificar se os Serviços de Localização estão habilitados ou não.

Eu preciso de um método que retorne "true" se eles estiverem habilitados e "false" se não (por isso, no último caso, posso mostrar uma caixa de diálogo para habilitá-los).

Meroelyth
fonte
3
Sei que esse é um tópico antigo, mas para quem pode seguir ... O Google lançou uma API para isso; consulte developers.google.com/android/reference/com/google/android/gms/…
Peter McLennan em
FYI: SettingsApi está obsoleto agora. Use developers.google.com/android/reference/com/google/android/gms/… .
Rajiv

Respostas:

361

Você pode usar o código abaixo para verificar se o provedor de GPS e os provedores de rede estão ativados ou não.

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 no arquivo de manifesto, você precisará adicionar as seguintes permissões

<uses-permission android:name="android.permission.ACCESS_FINE_LOCATION"/>
<uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION"/>
Shankar Agarwal
fonte
Obrigado pelo código. A verificação do gerenciador de localização: lm.getAllProviders().contains(LocationManager.GPS_PROVIDER)(ou NETWORK_PROVIDER) garantiria que você não jogasse o usuário em uma página de configurações onde não há opção de rede.
petter
26
Também: Settings.ACTION_SECURITY_SETTINGSdeve serSettings.ACTION_LOCATION_SOURCE_SETTINGS
petter
2
você pode verificar se o telefone está no modo avião e manipulá-lo .... stackoverflow.com/questions/4319212/…
John
2
Eu tive alguns problemas com o lm.isProviderEnabled (LocationManager.GPS_PROVIDER), que costumava retornar sempre false. Isso parece ocorrer quando você usa a nova versão do Play Services: aquela que mostra uma caixa de diálogo onde você pode ativar seus gps diretamente na caixa de diálogo, sem mostrar a atividade de configurações. Quando o usuário gira gps daquele diálogo, essa afirmação retorna sempre falsas, mesmo quando o GPS on
Marcelo Noguti
7
Também não deve colocar, confuso, inúteis blocos try-catch vazio
Chisko
225

Eu uso esse 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);
    }


} 
Slava Fir
fonte
7
Para maior clareza, talvez você queira retornar false no bloco catch. Caso contrário, inicialize locationMode para Settings.Secure.LOCATION_MODE_OFF.
RyanLeonard
2
Essa é uma boa resposta, pois funciona com as APIs de localização Android antigas e novas.
Diederik
2
LOCATION_PROVIDERS_ALLOWED - ligação Esta constante foi reprovado no nível API 19. Devemos usar LOCATION_MODE e MODE_CHANGED_ACTION (ou PROVIDERS_CHANGED_ACTION)
Choletski
3
Esta resposta deveria ter sido aceita como a resposta correta. O método locationManager.isProviderEnabled () não é confiável no meu dispositivo 4.4 (e como eu vi outros desenvolvedores também tiveram o mesmo problema em outras versões do sistema operacional). No meu caso, ele retorna verdadeiro para GPS em cada caso (não importa se os serviços de localização estão ativados ou não). Obrigado por esta ótima solução!
strongmayer
2
Isso não funcionou no meu dispositivo de teste, Samsung SHV-E160K, Android 4.1.2, API 16. Embora eu desligue o GPS, essa função ainda retorna verdadeira. Eu testei no Android Nougat, API 7.1 funciona
HendraWD 23/11
38

Como agora em 2020

A maneira mais recente, melhor e mais curta é

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
fonte
1
Excelente! Mas ainda melhor, se livrar de fundição e passar diretamente LocationManager.classno getSystemServicemétodo porque chamada requer API 23 ;-)
Mackovich
6
Ou você pode usar o LocationManagerCompat . :)
Mokkun
Use return lm! = Null && lm.isLocationEnabled (); em vez de retornar lm.isLocationEnabled ();
Dr. DS
35

Você pode usar esse código para direcionar os usuários para as Configurações, onde eles podem ativar o 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
fonte
1
Muito obrigado, mas não preciso do código para verificar o GPS, mas apenas os serviços de localização.
Meroelyth
1
os serviços de localização estão sempre disponíveis, mas os diferentes fornecedores podem estar indisponíveis.
22812
4
@lenik, alguns dispositivos fornecem uma configuração (em "Configurações> Pessoal> Serviços de localização> Acesso à minha localização") que parece ativar / desativar completamente a detecção de localização, mesmo se provedores específicos estiverem habilitados. Eu vi isso em primeira mão com um telefone com o qual estava testando e, embora o Wi-Fi e o GPS estivessem ativados, eles pareciam mortos ... para o meu aplicativo. Infelizmente, habilitei a configuração e não consigo mais reproduzir o cenário original, mesmo ao desativar a configuração "Acesso ao meu local". Portanto, não posso dizer se essa configuração afeta os métodos isProviderEnabled()e getProviders(true).
The Bear Awnry
... Eu só queria lançar isso lá fora, caso alguém encontre o mesmo problema. Eu nunca tinha visto a configuração antes em outros dispositivos com os quais testei. Parece ser um tipo de comutador de detecção de localização em todo o sistema. Se alguém tiver alguma experiência sobre como os métodos isProviderEnabled()e getProviders(true)respondem quando essa configuração é ativada (ou desativada, dependendo de como você a vê), ficaria muito curioso para saber o que encontrou.
The Awnry Bear
25

Migrar para o Android X e usar

implementation 'androidx.appcompat:appcompat:1.1.0'

e use LocationManagerCompat

Em java

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

Na cidade Kotlin

private fun isLocationEnabled(context: Context): Boolean {
    val locationManager = context.getSystemService(Context.LOCATION_SERVICE) as LocationManager
    return LocationManagerCompat.isLocationEnabled(locationManager)
}
Ensolarado
fonte
Isso funciona para todas as versões do Android desde o Android 1.0. Porém, note que, Before API version LOLLIPOP [API Level 21], this method would throw SecurityException if the location permissions were not sufficient to use the specified provider.se você não tiver permissão para a rede ou o provedor de gps, isso poderá gerar uma exceção, dependendo da opção ativada. Verifique o código fonte para mais informações.
xuiqzy 4/03
15

Trabalhando com a resposta acima, na API 23, você precisa adicionar verificações de permissões "perigosas" e verificar o próprio 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
fonte
Não é possível resolver o símbolo Manifest.permission.ACCESS_COARSE_LOCATION e Manifest.permission.ACCESS_FINE_LOCATION
Gennady Kozlov
Use android.Manifest.permission.ACCESS_FINE_LOCATION
aLIEz
7

Se nenhum provedor estiver ativado, "passivo" é o melhor provedor retornado. Consulte 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
fonte
7

Sim, você pode conferir abaixo o código:

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

com a permissão no arquivo de manifesto:

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

Esta cláusula if verifica facilmente se os serviços de localização estão disponíveis na minha opinião:

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

}
tsemann
fonte
4

Eu uso dessa maneira para NETWORK_PROVIDER, mas você pode adicionar e para GPS .

LocationManager locationManager;

No onCreate eu coloquei

   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 método de verificação

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
fonte
2
Você não precisa se-então-outra coisa, você pode simplesmente retornar #locationManager.isProviderEnabled(LocationManager.NETWORK_PROVIDER);
454 LadyWoodi
4

Este é um método muito útil que retorna " true" se Location servicesestiver ativado:

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

Para obter a localização geográfica atual no google maps do Android, você deve ativar a opção de localização do dispositivo. Para verificar se a localização está ativada ou não, basta chamar esse método usando seu 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
fonte
3

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

ligue assim

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

Dica: a caixa de diálogo precisa das seguintes importações (o Android Studio deve lidar com isso para você)

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

E no manifesto você precisa das seguintes permissões

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

Você pode solicitar as atualizações de local e mostrar a caixa de diálogo juntos, como o GoogleMaps também. Aqui está o 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;
            }
        }
    });
}

Se você precisar de mais informações, verifique a classe LocationRequest .

bendaf
fonte
Olá, estou lutando desde os últimos dois dias para obter a localização atual do usuário. Eu preciso da lat atual atual do usuário, eu sei que isso pode ser feito usando o Google API Client. Mas como integrar a permissão de marshmallow nele. Além disso, se os serviços de localização do usuário forem desativados, como ativá-lo. Você pode ajudar?
Chetna
Oi! você tem muita pergunta, o que não posso responder nos comentários. Faça uma nova pergunta para que eu possa respondê-la mais oficialmente!
bendaf 5/09/16
Eu postei minha pergunta aqui: stackoverflow.com/questions/39327480/…
Chetna
2

eu uso o primeiro código begin create method 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 verifico Condition if ture Abra o mapa e falso dê a intenção 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();
    }

insira a descrição da imagem aqui

Pong Petrung
fonte
1

Pode fazer da maneira mais simples

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
fonte
1

Se você estiver usando o AndroidX, use o código abaixo para verificar se o Serviço de Localização está ativado ou não:

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

Para verificar o provedor de rede, basta alterar a cadeia de caracteres passada para isProviderEnabled para LocationManager.NETWORK_PROVIDER se você verificar os valores de retorno para o provedor GPS e o NETwork - ambos false significa que não há serviços de localização

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

}

Use o método isLocationEnabled para detectar que os serviços de localização estão habilitados.

A página https://github.com/Polidea/RxAndroidBle/issues/327# fornecerá mais informações sobre por que não usar o provedor passivo, em vez disso, use o modo de localização.

alperk01
fonte