Android sprawdza uprawnienia dla LocationManager

97

Próbuję wyświetlić współrzędne GPS, gdy kliknę przycisk w moim układzie aktywności. Oto metoda wywoływana po kliknięciu przycisku:

public void getLocation(View view) {
    TextView tv = (TextView) findViewById(R.id.gps_coord_view);
    LocationManager lm = (LocationManager) getSystemService(LOCATION_SERVICE);
    Location loc = lm.getLastKnownLocation(LocationManager.GPS_PROVIDER);
    tv.setText("Latitude: " + loc.getLatitude() + "\nLongitude: " + loc.getLongitude());
}

Otrzymuję komunikat o błędzie

Połączenie wymaga pozwolenia, które może zostać odrzucone przez użytkownika. Kod powinien jawnie sprawdzać, czy zezwolenie jest dostępne.

Udzieliłem już tych uprawnień w moim AndroidManifest. Błąd jest usuwany, a aplikacja kompiluje się, gdy przed wywołaniem dodam lm.getLastKnownLocation:

if (checkSelfPermission(Manifest.permission.ACCESS_FINE_LOCATION) != PackageManager.PERMISSION_GRANTED
        && checkSelfPermission(Manifest.permission.ACCESS_COARSE_LOCATION) != PackageManager.PERMISSION_GRANTED) {
    return;
}

Jednak aplikacja ulega awarii, gdy naciskam przycisk wywołujący getLocation po kliknięciu. Co się dzieje? Czy istnieje lepszy / prostszy sposób na pobranie współrzędnych GPS urządzenia?

android locationmanager użytkownik
źródło
Prawdopodobnie możesz dołączyć dziennik wyjątków.
Mediolan
1
Użyj ContextCompat.checkSelfPermission (kontekst, pozwolenie) i upewnij się, że wspomniałeś o odpowiednich uprawnieniach w manifeście
Snehal Poyrekar

Odpowiedzi:

150

Na poziomie Android API (23) musimy sprawdzić uprawnienia. https://developer.android.com/training/permissions/requesting.html

Miałem ten sam problem, ale poniższe zadziałały i mogę pomyślnie pobrać dane lokalizacji:

(1) Upewnij się, że masz swoje uprawnienia wymienione w Manifeście: 

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

(2) Upewnij się, że żądasz uprawnień od użytkownika: 

if ( ContextCompat.checkSelfPermission( this, android.Manifest.permission.ACCESS_COARSE_LOCATION ) != PackageManager.PERMISSION_GRANTED ) {

            ActivityCompat.requestPermissions( this, new String[] {  android.Manifest.permission.ACCESS_COARSE_LOCATION  },
                                                LocationService.MY_PERMISSION_ACCESS_COURSE_LOCATION );
        }

(3) Upewnij się, że używasz ContextCompat, ponieważ ma on kompatybilność ze starszymi poziomami API.

(4) W Twojej usłudze lokalizacyjnej lub klasie, która inicjuje LocationManager i pobiera ostatnią znaną lokalizację, musimy sprawdzić uprawnienia: 

if ( Build.VERSION.SDK_INT >= 23 &&
             ContextCompat.checkSelfPermission( context, android.Manifest.permission.ACCESS_FINE_LOCATION ) != PackageManager.PERMISSION_GRANTED &&
             ContextCompat.checkSelfPermission( context, android.Manifest.permission.ACCESS_COARSE_LOCATION) != PackageManager.PERMISSION_GRANTED) {
            return  ;
        }

(5) To podejście zadziałało dla mnie dopiero po włączeniu @TargetApi (23) na początku mojej metody initLocationService.

(6) Dodałem również to do mojej kompilacji gradle: 

compile 'com.android.support:support-v4:23.0.1'

Oto moja usługa lokalizacji w celach informacyjnych: 

public class LocationService implements LocationListener  {

    //The minimum distance to change updates in meters
    private static final long MIN_DISTANCE_CHANGE_FOR_UPDATES = 0; // 10 meters

    //The minimum time between updates in milliseconds
    private static final long MIN_TIME_BW_UPDATES = 0;//1000 * 60 * 1; // 1 minute

    private final static boolean forceNetwork = false;

    private static LocationService instance = null;

    private LocationManager locationManager;
    public Location location;
    public double longitude;
    public double latitude; 


    /**
     * Singleton implementation
     * @return
     */
    public static LocationService getLocationManager(Context context)     {
        if (instance == null) {
            instance = new LocationService(context);
        }
        return instance;
    }

    /**
     * Local constructor
     */
    private LocationService( Context context )     {

        initLocationService(context); 
        LogService.log("LocationService created");
    }



    /**
     * Sets up location service after permissions is granted
     */
    @TargetApi(23)
    private void initLocationService(Context context) {


        if ( Build.VERSION.SDK_INT >= 23 &&
             ContextCompat.checkSelfPermission( context, android.Manifest.permission.ACCESS_FINE_LOCATION ) != PackageManager.PERMISSION_GRANTED &&
             ContextCompat.checkSelfPermission( context, android.Manifest.permission.ACCESS_COARSE_LOCATION) != PackageManager.PERMISSION_GRANTED) {
            return  ;
        }

        try   {
            this.longitude = 0.0;
            this.latitude = 0.0;
            this.locationManager = (LocationManager) context.getSystemService(Context.LOCATION_SERVICE);

            // Get GPS and network status
            this.isGPSEnabled = locationManager.isProviderEnabled(LocationManager.GPS_PROVIDER);
            this.isNetworkEnabled = locationManager.isProviderEnabled(LocationManager.NETWORK_PROVIDER);

            if (forceNetwork) isGPSEnabled = false;

            if (!isNetworkEnabled && !isGPSEnabled)    {
                // cannot get location
                this.locationServiceAvailable = false;
            }
            //else
            {
                this.locationServiceAvailable = true;

                if (isNetworkEnabled) {
                    locationManager.requestLocationUpdates(LocationManager.NETWORK_PROVIDER,
                            MIN_TIME_BW_UPDATES,
                            MIN_DISTANCE_CHANGE_FOR_UPDATES, this);
                    if (locationManager != null)   {
                        location = locationManager.getLastKnownLocation(LocationManager.NETWORK_PROVIDER);
                        updateCoordinates();
                    }
                }//end if

                if (isGPSEnabled)  {
                    locationManager.requestLocationUpdates(LocationManager.GPS_PROVIDER,
                            MIN_TIME_BW_UPDATES,
                            MIN_DISTANCE_CHANGE_FOR_UPDATES, this);

                    if (locationManager != null)  {
                        location = locationManager.getLastKnownLocation(LocationManager.GPS_PROVIDER);
                        updateCoordinates();
                    }
                }
            }
        } catch (Exception ex)  {
            LogService.log( "Error creating location service: " + ex.getMessage() );

        }
    }       


    @Override
    public void onLocationChanged(Location location)     {
        // do stuff here with location object 
    }
}

Do tej pory testowałem tylko z urządzeniem z Androidem Lollipop. Mam nadzieję, że to działa dla Ciebie.

keshav.bahadoor
źródło
2
Podoba mi się twoje rozwiązanie, ale powinieneś sprawdzić, czy locationManager jest pusty przed jego użyciem, a nie później.
Fer
9
LocationService.MY_PERMISSION_ACCESS_COURSE_LOCATION ta linia nie działa wersja 23
4
LocationService.MY_PERMISSION_ACCESS_COURSE_LOCATION również nie działa dla mnie.
Kairi San
1
@delive, LocationService.MY_PERMISSION_ACCESS_COURSE_LOCATION -> musisz zdefiniować ten kod int we własnej klasie (która zaimplementowała ActivityCompat.OnRequestPermissionsResultCallback), po szczegóły sprawdź ten link .
David Cheung
11
GRUBY NIE KURS
Chris Cox
46

PROSTE ROZWIĄZANIE

Chciałem obsługiwać aplikacje przed api 23 i zamiast checkSelfPermissionużywać try / catch

try {
   location = locationManager.getLastKnownLocation(LocationManager.GPS_PROVIDER);
} catch (SecurityException e) {
   dialogGPS(this.getContext()); // lets the user know there is a problem with the gps
}
Jacksonkr
źródło
39

Ostatnia część zacytowanego komunikatu o błędzie brzmi: ...with ("checkPermission") or explicitly handle a potential "SecurityException"

O wiele szybszym / prostszym sposobem sprawdzenia, czy masz uprawnienia, jest otoczenie kodu try { ... } catch (SecurityException e) { [insert error handling code here] }. Jeśli masz uprawnienia, zostanie wykonana część „try”, a jeśli nie, część „catch” będzie.

VikingGlen
źródło
1
Przydatne, jeśli nie masz obiektu Activity lub Context, do którego możesz sprawdzić uprawnienia.
Nublodeveloper
6

Użyj mojej klasy custome, aby sprawdzić lub poprosić o pozwolenie

public class Permissons {

        //Request Permisson
        public static void Request_STORAGE(Activity act,int code)
        {

            ActivityCompat.requestPermissions(act, new
                    String[]{android.Manifest.permission.WRITE_EXTERNAL_STORAGE},code);
        }
        public static void Request_CAMERA(Activity act,int code)
        {
            ActivityCompat.requestPermissions(act, new
                    String[]{Manifest.permission.CAMERA},code);
        }
        public static void Request_FINE_LOCATION(Activity act,int code)
        {
            ActivityCompat.requestPermissions(act, new
                    String[]{Manifest.permission.ACCESS_FINE_LOCATION},code);
        }
        public static void Request_READ_SMS(Activity act,int code)
        {
            ActivityCompat.requestPermissions(act, new
                    String[]{Manifest.permission.READ_SMS},code);
        }
        public static void Request_READ_CONTACTS(Activity act,int code)
        {
            ActivityCompat.requestPermissions(act, new
                    String[]{Manifest.permission.READ_CONTACTS},code);
        }
        public static void Request_READ_CALENDAR(Activity act,int code)
        {
            ActivityCompat.requestPermissions(act, new
                    String[]{Manifest.permission.READ_CALENDAR},code);
        }
        public static void Request_RECORD_AUDIO(Activity act,int code)
        {
            ActivityCompat.requestPermissions(act, new
                    String[]{Manifest.permission.RECORD_AUDIO},code);
        }

        //Check Permisson
        public static boolean Check_STORAGE(Activity act)
        {
            int result = ContextCompat.checkSelfPermission(act,android.Manifest.permission.WRITE_EXTERNAL_STORAGE);
            return result == PackageManager.PERMISSION_GRANTED;
        }
        public static boolean Check_CAMERA(Activity act)
        {
            int result = ContextCompat.checkSelfPermission(act, Manifest.permission.CAMERA);
            return result == PackageManager.PERMISSION_GRANTED;
        }
        public static boolean Check_FINE_LOCATION(Activity act)
        {
            int result = ContextCompat.checkSelfPermission(act, Manifest.permission.ACCESS_FINE_LOCATION);
            return result == PackageManager.PERMISSION_GRANTED;
        }
        public static boolean Check_READ_SMS(Activity act)
        {
            int result = ContextCompat.checkSelfPermission(act, Manifest.permission.READ_SMS);
            return result == PackageManager.PERMISSION_GRANTED;
        }
        public static boolean Check_READ_CONTACTS(Activity act)
        {
            int result = ContextCompat.checkSelfPermission(act, Manifest.permission.READ_CONTACTS);
            return result == PackageManager.PERMISSION_GRANTED;
        }
        public static boolean Check_READ_CALENDAR(Activity act)
        {
            int result = ContextCompat.checkSelfPermission(act, Manifest.permission.READ_CALENDAR);
            return result == PackageManager.PERMISSION_GRANTED;
        }
        public static boolean Check_RECORD_AUDIO(Activity act)
        {
            int result = ContextCompat.checkSelfPermission(act, Manifest.permission.RECORD_AUDIO);
            return result == PackageManager.PERMISSION_GRANTED;
        }
    }

Przykład

if(!Permissons.Check_STORAGE(MainActivity.this))
{
   //if not permisson granted so request permisson with request code
   Permissons.Request_STORAGE(MainActivity.this,22);
}
milan pithadia
źródło
dzięki, ale chcę zapytać, jaka jest funkcja „kodu int”?
Hendro Pramono
ten kod służy do przyzwolenia wyniku przyznanego lub
odrzuconego w
4

jeśli pracujesz z uprawnieniami dynamicznymi i jakimkolwiek zezwoleniem, takim jak ACCESS_FINE_LOCATION, ACCESS_COARSE_LOCATION, dając błąd „nie można rozwiązać metody PERMISSION_NAME”, w tym przypadku napisz kod z nazwą uprawnienia, a następnie odbuduj projekt, spowoduje to ponowne wygenerowanie pliku manifestu (Manifest.permission).

anoopbryan2
źródło
0

Jeśli chcesz po prostu sprawdzić uprawnienia (zamiast poprosić o uprawnienia), napisałem proste rozszerzenie, takie jak:

fun BaseActivity.checkPermission(permissionName: String): Boolean {
        return if (Build.VERSION.SDK_INT >= 23) {
            val granted =
                ContextCompat.checkSelfPermission(this, permissionName)
            granted == PackageManager.PERMISSION_GRANTED
        } else {
            val granted =
                PermissionChecker.checkSelfPermission(this, permissionName)
            granted == PermissionChecker.PERMISSION_GRANTED
        }
    }

Teraz, jeśli chcę sprawdzić pozwolenie, mogę po prostu przekazać zezwolenie w następujący sposób:

checkPermission(Manifest.permission.READ_CONTACTS)
azwethinkweiz
źródło