Jedną z unikalnych funkcji aplikacji mobilnych jest świadomość lokalizacji. Użytkownicy zawsze mają przy sobie swoje urządzenia mobilne, dlatego dodanie do aplikacji informacji o lokalizacji zwiększa jej kontekst.
Przykładowe fragmenty kodu
Repozytorium ApiDemos w GitHubie zawiera przykłady, które obrazują użycie lokalizacji na mapie:
Java
- MyLocationDemoActivity: korzystanie z warstwy Moja lokalizacja, w tym uprawnień czasu działania.
- LocationSourceDemoActivity: korzystanie z niestandardowego parametru
LocationSource
- CurrentPlaceDetailsOnMap: znajdowanie bieżącej lokalizacji urządzenia z Androidem i wyświetlanie szczegółów danego miejsca (firmy lub innego ciekawego miejsca). Zobacz samouczek na temat wyświetlania aktualnych informacji o miejscach na mapie.
Kotlin
- MyLocationDemoActivity: korzystanie z warstwy Moja lokalizacja, w tym uprawnień czasu działania.
- LocationSourceDemoActivity: korzystanie z niestandardowego parametru
LocationSource
- CurrentPlaceDetailsOnMap: znajdowanie bieżącej lokalizacji urządzenia z Androidem i wyświetlanie szczegółów danego miejsca (firmy lub innego ciekawego miejsca). Zobacz samouczek na temat wyświetlania aktualnych informacji o miejscach na mapie.
Praca z danymi o lokalizacji
Dane o lokalizacji dostępne dla urządzeń z Androidem obejmują aktualną lokalizację urządzenia – określoną z użyciem różnych technologii – kierunek i metodę ruchu oraz to, czy urządzenie przesunęło się we wstępnie określoną granicę geograficzną lub geofencing. W zależności od potrzeb aplikacji możesz wybrać jedną z kilku metod pracy z danymi o lokalizacji:
- Warstwa Moja lokalizacja umożliwia proste wyświetlanie lokalizacji urządzenia na mapie. Nie zapewnia on danych.
- Interfejs Google Play Services Location API jest zalecany w przypadku wszystkich automatycznych żądań danych o lokalizacji.
- Interfejs
LocationSource
umożliwia podanie niestandardowego dostawcy lokalizacji.
Dostęp do lokalizacji
Jeśli Twoja aplikacja potrzebuje dostępu do lokalizacji użytkownika, musisz o nią poprosić, dodając do niej odpowiednie uprawnienia dotyczące lokalizacji na Androidzie.
Android oferuje 2 uprawnienia do określania lokalizacji: ACCESS_COARSE_LOCATION
i ACCESS_FINE_LOCATION
. Wybrane uprawnienie określa dokładność lokalizacji zwróconej przez interfejs API.
android.permission.ACCESS_COARSE_LOCATION
– Umożliwia interfejsowi API zwracanie przybliżonej lokalizacji urządzenia. Te uprawnienia pozwalają na określanie przybliżonej lokalizacji urządzenia z usług lokalizacyjnych, jak opisano w dokumentacji dotyczącej przybliżonej dokładności lokalizacji.android.permission.ACCESS_FINE_LOCATION
– pozwala interfejsowi API na jak najdokładniejsze określanie lokalizacji od dostępnych dostawców, w tym z systemu pozycjonowania globalnego (GPS) oraz danych komórkowych i Wi-Fi.
Dodaj uprawnienia do pliku manifestu aplikacji
Jeśli przybliżona lokalizacja jest potrzebna tylko do działania aplikacji, dodaj uprawnienie ACCESS_COARSE_LOCATION
do pliku manifestu aplikacji:
<manifest xmlns:android="http://schemas.android.com/apk/res/android" package="com.example.myapp" > ... <uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION"/> ... </manifest>
Jeśli jednak potrzebujesz dokładnej lokalizacji, do pliku manifestu aplikacji dodaj uprawnienia ACCESS_COARSE_LOCATION
i ACCESS_FINE_LOCATION
:
<manifest xmlns:android="http://schemas.android.com/apk/res/android" package="com.example.myapp" > ... <uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION"/> <uses-permission android:name="android.permission.ACCESS_FINE_LOCATION"/> ... </manifest>
Poproś o uprawnienia w czasie działania
Android 6.0 (Marshmallow) wprowadza nowy model obsługi uprawnień, który upraszcza użytkownikom proces instalowania i aktualizowania aplikacji. Jeśli Twoja aplikacja jest kierowana na interfejs API na poziomie 23 lub nowszym, możesz używać nowego modelu uprawnień.
Jeśli Twoja aplikacja obsługuje nowy model uprawnień, a na urządzeniu jest zainstalowany Android w wersji 6.0 (Marshmallow) lub nowszej, podczas instalowania lub uaktualniania aplikacji użytkownik nie musi przyznawać żadnych uprawnień. Aplikacja musi sprawdzić, czy ma wymagane uprawnienia w czasie działania, a jeśli nie, może poprosić o ich przyznanie. System wyświetli użytkownikowi okno z prośbą o pozwolenie.
Aby zadbać o jak najlepsze wrażenia użytkowników, musisz poprosić o uprawnienia w kontekście. Jeśli lokalizacja ma kluczowe znaczenie dla działania aplikacji, poproś o jej udostępnienie przy uruchamianiu aplikacji. Dobrym sposobem na to jest umieszczenie ekranu powitalnego lub kreatora informującego użytkowników o konieczności przyznania tego uprawnienia.
Jeśli aplikacja wymaga dostępu do niektórych funkcji, musisz poprosić o dostęp do lokalizacji w momencie, gdy aplikacja wykonuje działanie, które wymaga tego uprawnienia.
Aplikacja musi zachwycić sytuację, w której użytkownik nie przyzna uprawnień. Jeśli na przykład uprawnienia są potrzebne dla określonej funkcji, aplikacja może ją wyłączyć. Jeśli uprawnienie jest niezbędne, aby aplikacja mogła działać, może wyłączyć wszystkie jej funkcje i powiadomić użytkownika, że musi udzielić zgody.
Poniższy przykład kodu sprawdza uprawnienia przy użyciu biblioteki AndroidX, zanim włączysz warstwę Moja lokalizacja. Następnie obsługuje wynik prośby o zgodę, implementując element ActivityCompat.OnRequestPermissionsResultCallback
z biblioteki pomocy:
Java
// Copyright 2020 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. package com.example.mapdemo; import android.Manifest.permission; import android.annotation.SuppressLint; import com.google.android.gms.maps.GoogleMap; import com.google.android.gms.maps.GoogleMap.OnMyLocationButtonClickListener; import com.google.android.gms.maps.GoogleMap.OnMyLocationClickListener; import com.google.android.gms.maps.OnMapReadyCallback; import com.google.android.gms.maps.SupportMapFragment; import android.Manifest; import android.content.pm.PackageManager; import android.location.Location; import android.os.Bundle; import androidx.annotation.NonNull; import androidx.appcompat.app.AppCompatActivity; import androidx.core.app.ActivityCompat; import androidx.core.content.ContextCompat; import android.widget.Toast; /** * This demo shows how GMS Location can be used to check for changes to the users location. The "My * Location" button uses GMS Location to set the blue dot representing the users location. * Permission for {@link android.Manifest.permission#ACCESS_FINE_LOCATION} and {@link * android.Manifest.permission#ACCESS_COARSE_LOCATION} are requested at run time. If either * permission is not granted, the Activity is finished with an error message. */ public class MyLocationDemoActivity extends AppCompatActivity implements OnMyLocationButtonClickListener, OnMyLocationClickListener, OnMapReadyCallback, ActivityCompat.OnRequestPermissionsResultCallback { /** * Request code for location permission request. * * @see #onRequestPermissionsResult(int, String[], int[]) */ private static final int LOCATION_PERMISSION_REQUEST_CODE = 1; /** * Flag indicating whether a requested permission has been denied after returning in {@link * #onRequestPermissionsResult(int, String[], int[])}. */ private boolean permissionDenied = false; private GoogleMap map; @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.my_location_demo); SupportMapFragment mapFragment = (SupportMapFragment) getSupportFragmentManager().findFragmentById(R.id.map); mapFragment.getMapAsync(this); } @Override public void onMapReady(@NonNull GoogleMap googleMap) { map = googleMap; map.setOnMyLocationButtonClickListener(this); map.setOnMyLocationClickListener(this); enableMyLocation(); } /** * Enables the My Location layer if the fine location permission has been granted. */ @SuppressLint("MissingPermission") private void enableMyLocation() { // 1. Check if permissions are granted, if so, enable the my location layer if (ContextCompat.checkSelfPermission(this, Manifest.permission.ACCESS_FINE_LOCATION) == PackageManager.PERMISSION_GRANTED || ContextCompat.checkSelfPermission(this, permission.ACCESS_COARSE_LOCATION) == PackageManager.PERMISSION_GRANTED) { map.setMyLocationEnabled(true); return; } // 2. Otherwise, request location permissions from the user. PermissionUtils.requestLocationPermissions(this, LOCATION_PERMISSION_REQUEST_CODE, true); } @Override public boolean onMyLocationButtonClick() { Toast.makeText(this, "MyLocation button clicked", Toast.LENGTH_SHORT).show(); // Return false so that we don't consume the event and the default behavior still occurs // (the camera animates to the user's current position). return false; } @Override public void onMyLocationClick(@NonNull Location location) { Toast.makeText(this, "Current location:\n" + location, Toast.LENGTH_LONG).show(); } @Override public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) { if (requestCode != LOCATION_PERMISSION_REQUEST_CODE) { super.onRequestPermissionsResult(requestCode, permissions, grantResults); return; } if (PermissionUtils.isPermissionGranted(permissions, grantResults, Manifest.permission.ACCESS_FINE_LOCATION) || PermissionUtils .isPermissionGranted(permissions, grantResults, Manifest.permission.ACCESS_COARSE_LOCATION)) { // Enable the my location layer if the permission has been granted. enableMyLocation(); } else { // Permission was denied. Display an error message // Display the missing permission error dialog when the fragments resume. permissionDenied = true; } } @Override protected void onResumeFragments() { super.onResumeFragments(); if (permissionDenied) { // Permission was not granted, display error dialog. showMissingPermissionError(); permissionDenied = false; } } /** * Displays a dialog with error message explaining that the location permission is missing. */ private void showMissingPermissionError() { PermissionUtils.PermissionDeniedDialog .newInstance(true).show(getSupportFragmentManager(), "dialog"); } }
Kotlin
// Copyright 2020 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. package com.example.kotlindemos import android.Manifest import android.annotation.SuppressLint import android.content.pm.PackageManager import android.location.Location import android.os.Bundle import android.widget.Toast import androidx.appcompat.app.AppCompatActivity import androidx.core.app.ActivityCompat import androidx.core.app.ActivityCompat.OnRequestPermissionsResultCallback import androidx.core.content.ContextCompat import com.example.kotlindemos.PermissionUtils.PermissionDeniedDialog.Companion.newInstance import com.example.kotlindemos.PermissionUtils.isPermissionGranted import com.google.android.gms.maps.GoogleMap import com.google.android.gms.maps.GoogleMap.OnMyLocationButtonClickListener import com.google.android.gms.maps.GoogleMap.OnMyLocationClickListener import com.google.android.gms.maps.OnMapReadyCallback import com.google.android.gms.maps.SupportMapFragment /** * This demo shows how GMS Location can be used to check for changes to the users location. The * "My Location" button uses GMS Location to set the blue dot representing the users location. * Permission for [Manifest.permission.ACCESS_FINE_LOCATION] and [Manifest.permission.ACCESS_COARSE_LOCATION] * are requested at run time. If either permission is not granted, the Activity is finished with an error message. */ class MyLocationDemoActivity : AppCompatActivity(), OnMyLocationButtonClickListener, OnMyLocationClickListener, OnMapReadyCallback, OnRequestPermissionsResultCallback { /** * Flag indicating whether a requested permission has been denied after returning in * [.onRequestPermissionsResult]. */ private var permissionDenied = false private lateinit var map: GoogleMap override fun onCreate(savedInstanceState: Bundle?) { super.onCreate(savedInstanceState) setContentView(R.layout.my_location_demo) val mapFragment = supportFragmentManager.findFragmentById(R.id.map) as SupportMapFragment? mapFragment?.getMapAsync(this) } override fun onMapReady(googleMap: GoogleMap) { map = googleMap googleMap.setOnMyLocationButtonClickListener(this) googleMap.setOnMyLocationClickListener(this) enableMyLocation() } /** * Enables the My Location layer if the fine location permission has been granted. */ @SuppressLint("MissingPermission") private fun enableMyLocation() { // 1. Check if permissions are granted, if so, enable the my location layer if (ContextCompat.checkSelfPermission( this, Manifest.permission.ACCESS_FINE_LOCATION ) == PackageManager.PERMISSION_GRANTED || ContextCompat.checkSelfPermission( this, Manifest.permission.ACCESS_COARSE_LOCATION ) == PackageManager.PERMISSION_GRANTED ) { map.isMyLocationEnabled = true return } // 2. If if a permission rationale dialog should be shown if (ActivityCompat.shouldShowRequestPermissionRationale( this, Manifest.permission.ACCESS_FINE_LOCATION ) || ActivityCompat.shouldShowRequestPermissionRationale( this, Manifest.permission.ACCESS_COARSE_LOCATION ) ) { PermissionUtils.RationaleDialog.newInstance( LOCATION_PERMISSION_REQUEST_CODE, true ).show(supportFragmentManager, "dialog") return } // 3. Otherwise, request permission ActivityCompat.requestPermissions( this, arrayOf( Manifest.permission.ACCESS_FINE_LOCATION, Manifest.permission.ACCESS_COARSE_LOCATION ), LOCATION_PERMISSION_REQUEST_CODE ) } override fun onMyLocationButtonClick(): Boolean { Toast.makeText(this, "MyLocation button clicked", Toast.LENGTH_SHORT) .show() // Return false so that we don't consume the event and the default behavior still occurs // (the camera animates to the user's current position). return false } override fun onMyLocationClick(location: Location) { Toast.makeText(this, "Current location:\n$location", Toast.LENGTH_LONG) .show() } override fun onRequestPermissionsResult( requestCode: Int, permissions: Array<String>, grantResults: IntArray ) { if (requestCode != LOCATION_PERMISSION_REQUEST_CODE) { super.onRequestPermissionsResult( requestCode, permissions, grantResults ) return } if (isPermissionGranted( permissions, grantResults, Manifest.permission.ACCESS_FINE_LOCATION ) || isPermissionGranted( permissions, grantResults, Manifest.permission.ACCESS_COARSE_LOCATION ) ) { // Enable the my location layer if the permission has been granted. enableMyLocation() } else { // Permission was denied. Display an error message // Display the missing permission error dialog when the fragments resume. permissionDenied = true } } override fun onResumeFragments() { super.onResumeFragments() if (permissionDenied) { // Permission was not granted, display error dialog. showMissingPermissionError() permissionDenied = false } } /** * Displays a dialog with error message explaining that the location permission is missing. */ private fun showMissingPermissionError() { newInstance(true).show(supportFragmentManager, "dialog") } companion object { /** * Request code for location permission request. * * @see .onRequestPermissionsResult */ private const val LOCATION_PERMISSION_REQUEST_CODE = 1 } }
Warstwa Moja lokalizacja
Aby pokazać użytkownikowi bieżącą lokalizację na mapie, możesz użyć warstwy Moja lokalizacja i przycisku Moja lokalizacja. Wywołaj mMap.setMyLocationEnabled()
, aby włączyć warstwę Moja lokalizacja na mapie.
Poniższy przykład przedstawia proste użycie warstwy Moja lokalizacja:
Java
// Copyright 2020 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. package com.google.maps.example; import android.annotation.SuppressLint; import android.location.Location; import android.os.Bundle; import android.widget.Toast; import androidx.annotation.NonNull; import androidx.appcompat.app.AppCompatActivity; import com.google.android.gms.maps.GoogleMap; import com.google.android.gms.maps.OnMapReadyCallback; import com.google.android.gms.maps.SupportMapFragment; class MyLocationLayerActivity extends AppCompatActivity implements GoogleMap.OnMyLocationButtonClickListener, GoogleMap.OnMyLocationClickListener, OnMapReadyCallback { @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_my_location); SupportMapFragment mapFragment = (SupportMapFragment) getSupportFragmentManager().findFragmentById(R.id.map); mapFragment.getMapAsync(this); } @SuppressLint("MissingPermission") @Override public void onMapReady(GoogleMap map) { // TODO: Before enabling the My Location layer, you must request // location permission from the user. This sample does not include // a request for location permission. map.setMyLocationEnabled(true); map.setOnMyLocationButtonClickListener(this); map.setOnMyLocationClickListener(this); } @Override public void onMyLocationClick(@NonNull Location location) { Toast.makeText(this, "Current location:\n" + location, Toast.LENGTH_LONG) .show(); } @Override public boolean onMyLocationButtonClick() { Toast.makeText(this, "MyLocation button clicked", Toast.LENGTH_SHORT) .show(); // Return false so that we don't consume the event and the default behavior still occurs // (the camera animates to the user's current position). return false; } }
Kotlin
// Copyright 2020 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. package com.google.maps.example.kotlin import android.annotation.SuppressLint import android.location.Location import android.os.Bundle import android.widget.Toast import androidx.appcompat.app.AppCompatActivity import com.google.android.gms.maps.GoogleMap import com.google.android.gms.maps.GoogleMap.OnMyLocationButtonClickListener import com.google.android.gms.maps.GoogleMap.OnMyLocationClickListener import com.google.android.gms.maps.OnMapReadyCallback import com.google.android.gms.maps.SupportMapFragment import com.google.maps.example.R internal class MyLocationLayerActivity : AppCompatActivity(), OnMyLocationButtonClickListener, OnMyLocationClickListener, OnMapReadyCallback { override fun onCreate(savedInstanceState: Bundle?) { super.onCreate(savedInstanceState) setContentView(R.layout.activity_my_location) val mapFragment = supportFragmentManager.findFragmentById(R.id.map) as SupportMapFragment mapFragment.getMapAsync(this) } @SuppressLint("MissingPermission") override fun onMapReady(map: GoogleMap) { // TODO: Before enabling the My Location layer, you must request // location permission from the user. This sample does not include // a request for location permission. map.isMyLocationEnabled = true map.setOnMyLocationButtonClickListener(this) map.setOnMyLocationClickListener(this) } override fun onMyLocationClick(location: Location) { Toast.makeText(this, "Current location:\n$location", Toast.LENGTH_LONG) .show() } override fun onMyLocationButtonClick(): Boolean { Toast.makeText(this, "MyLocation button clicked", Toast.LENGTH_SHORT) .show() // Return false so that we don't consume the event and the default behavior still occurs // (the camera animates to the user's current position). return false } }
Po włączeniu warstwy Moja lokalizacja w prawym górnym rogu mapy wyświetlany jest przycisk Moja lokalizacja. Gdy użytkownik kliknie przycisk, kamera wyśrodkuje mapę do bieżącej lokalizacji urządzenia, o ile jest ono znane. Lokalizacja jest oznaczona na mapie małą niebieską kropką, jeśli urządzenie jest w ruchu lub jako szewron, gdy urządzenie się porusza.
Na następującym zrzucie ekranu widać przycisk Moja lokalizacja w prawym górnym rogu mapy i niebieską kropkę na środku mapy:
Aby zapobiec wyświetlaniu przycisku Moja lokalizacja, wywołaj funkcję UiSettings.setMyLocationButtonEnabled(false)
.
Aplikacja może reagować na te zdarzenia:
- Jeśli użytkownik kliknie przycisk Moja lokalizacja, aplikacja otrzyma wywołanie zwrotne
onMyLocationButtonClick()
zGoogleMap.OnMyLocationButtonClickListener
. - Jeśli użytkownik kliknie niebieski punkt mojej lokalizacji, aplikacja odbierze wywołanie
onMyLocationClick()
zGoogleMap.OnMyLocationClickListener
.
Interfejs Google Play Services Location API
Interfejs Location API z Usługami Google Play to preferowana metoda dodawania lokalizacji do aplikacji na Androida. Zawiera on funkcje, które pozwalają:
- Określ lokalizację urządzenia.
- Wykrywaj zmiany lokalizacji.
- Określ środek transportu, jeśli urządzenie się porusza.
- Twórz i monitoruj wstępnie zdefiniowane regiony geograficzne (nazywane geofencingami).
Interfejsy API lokalizacji ułatwiają tworzenie energooszczędnych aplikacji zorientowanych na lokalizację. Podobnie jak Maps SDK na Androida, interfejs Location API jest rozpowszechniany jako część pakietu Google Play Services SDK. Więcej informacji o interfejsie Location API znajdziesz w kursie dotyczącym ustalania lokalizacji aplikacji lub w dokumentacji interfejsu Location API. Przykładowe fragmenty kodu są częścią pakietu SDK usług Google Play.