Jedną z wyjątkowych cech aplikacji mobilnych jest to, że mogą one wykrywać lokalizację. Użytkownicy mobilni mają przy sobie swoje urządzenia mobilne. Dodanie funkcji rozpoznawania lokalizacji do aplikacji zapewnia im szerszy kontekst.
Przykładowe fragmenty kodu
Repozytorium API Apigee na GitHubie zawiera przykłady, które pokazują wykorzystanie lokalizacji na mapie:
Kotlin
- MyLocationDemoActivity: za pomocą warstwy Moja lokalizacja, w tym uprawnień czasu działania.
- LocationSourceDemoActivity: używa niestandardowego tagu
LocationSource
- CurrentPlaceDetailsOnMap: znajdowanie bieżącej lokalizacji urządzenia z Androidem i wyświetlanie szczegółowych informacji o tym miejscu (firmie lub innym ciekawym miejscu) w tej lokalizacji. Zapoznaj się z samouczkiem dotyczącym wyświetlania szczegółów bieżących miejsc na mapie.
Java
- MyLocationDemoActivity: za pomocą warstwy Moja lokalizacja, w tym uprawnień czasu działania.
- LocationSourceDemoActivity: używa niestandardowego tagu
LocationSource
- CurrentPlaceDetailsOnMap: znajdowanie bieżącej lokalizacji urządzenia z Androidem i wyświetlanie szczegółowych informacji o tym miejscu (firmie lub innym ciekawym miejscu) w tej lokalizacji. Zapoznaj się z samouczkiem dotyczącym wyświetlania szczegółów bieżących miejsc na mapie.
Praca z danymi o lokalizacji
Dane o lokalizacji dostępne dla urządzenia z Androidem obejmują aktualną lokalizację urządzenia – wskazywaną za pomocą kombinacji technologii – kierunek i metodę ruchu oraz to, czy urządzenie przemieściło się przez wstępnie zdefiniowany obszar geograficzny, czyli geofencing. W zależności od potrzeb swojej aplikacji możesz wybrać jeden z kilku sposobów pracy z danymi o lokalizacji:
- Warstwa Moja lokalizacja umożliwia w prosty sposób wyświetlanie lokalizacji urządzenia na mapie. Nie dostarcza danych.
- Interfejs Google Play Services Location API jest zalecany w przypadku wszystkich zautomatyzowanych żądań danych o lokalizacji.
- W interfejsie
LocationSource
możesz podać własnego dostawcę lokalizacji.
Dostęp do lokalizacji
Jeśli Twoja aplikacja potrzebuje dostępu do lokalizacji użytkownika, musisz o to poprosić, dodając do aplikacji odpowiednie dostęp do lokalizacji na Androidzie.
Android udostępnia 2 rodzaje dostępu do lokalizacji: ACCESS_COARSE_LOCATION
i ACCESS_FINE_LOCATION
. Wybrane uprawnienie decyduje o dokładności lokalizacji zwracanej przez interfejs API.
android.permission.ACCESS_COARSE_LOCATION
– zezwala interfejsowi API na zwrócenie przybliżonej lokalizacji urządzenia. Uprawnienia zawierają przybliżoną lokalizację urządzenia z usług lokalizacyjnych zgodnie z opisem w dokumentacji dotyczącej dokładności przybliżonej lokalizacji.android.permission.ACCESS_FINE_LOCATION
– Zezwala interfejsowi API na możliwie najdokładniejsze określanie lokalizacji spośród dostępnych dostawców lokalizacji, w tym z systemu GPS, a także z sieci Wi-Fi i komórkowej transmisji danych.
Dodaj uprawnienia do pliku manifestu aplikacji
Jeśli aplikacja potrzebuje tylko przybliżonej lokalizacji, 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, dodaj do pliku manifestu aplikacji zarówno uprawnienia ACCESS_COARSE_LOCATION
, jak 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 proces instalowania i aktualizacji aplikacji przez użytkowników. Jeśli Twoja aplikacja jest kierowana na interfejs API na poziomie 23 lub nowszym, możesz użyć nowego modelu uprawnień.
Jeśli aplikacja obsługuje nowy model uprawnień, a na urządzeniu działa Android 6.0 (Marshmallow) lub nowszy, użytkownik nie musi przyznawać żadnych uprawnień podczas instalowania lub uaktualniania aplikacji. Aplikacja musi sprawdzić, czy ma odpowiednie uprawnienia w czasie działania, i poprosić o nie, jeśli ich nie ma. System wyświetli okno z prośbą o przyznanie uprawnień.
Ze względu na wygodę użytkowników prośby o przyznanie uprawnień warto wysyłać w kontekście. Jeśli lokalizacja jest niezbędna do działania aplikacji, poproś o dostęp do niej przy uruchamianiu aplikacji. Warto to zrobić za pomocą ekranu powitalnego lub kreatora, który informuje użytkowników, do czego potrzebne są określone uprawnienia.
Jeśli aplikacja wymaga dostępu tylko do niektórych funkcji, o dostęp do lokalizacji należy poprosić w momencie, gdy wykonuje czynność, która go wymaga.
Aplikacja musi bezproblemowo obsługiwać sprawę, w której użytkownik nie wyrazi zgody. Jeśli na przykład dana funkcja wymaga uprawnień, aplikacja może ją wyłączyć. Jeśli uprawnienie jest niezbędne do działania aplikacji, może ona wyłączyć wszystkie funkcje i powiadomić użytkownika, że musi je przyznać.
Poniższy przykładowy kod sprawdza uprawnienia za pomocą biblioteki AndroidaX przed włączeniem warstwy Moja lokalizacja. Następnie obsługuje wynik prośby o uprawnienia, implementując obiekt ActivityCompat.OnRequestPermissionsResultCallback
z biblioteki pomocy:
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 } }
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"); } }
Warstwa Moja lokalizacja
Aby wyświetlić użytkownikowi aktualną pozycję 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 pokazuje proste zastosowanie warstwy Moja lokalizacja:
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 } }
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; } }
Gdy włączona jest warstwa Moja lokalizacja, w prawym górnym rogu mapy jest wyświetlany przycisk Moja lokalizacja. Po kliknięciu przycisku aparat wyśrodkowuje mapę na aktualnej lokalizacji urządzenia, jeśli jest ona znana. Lokalizacja jest wskazywana na mapie przez małą niebieską kropkę, jeśli urządzenie znajduje się w miejscu, lub szewron, jeśli jest w ruchu.
Poniższy zrzut ekranu przedstawia przycisk Moja lokalizacja w prawym górnym rogu i niebieską kropkę Moja lokalizacja na środku mapy:
Aby zapobiec wyświetlaniu przycisku Moja lokalizacja, zadzwoń pod numer 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 Moja lokalizacja, aplikacja otrzyma wywołanie zwrotne
onMyLocationClick()
zGoogleMap.OnMyLocationClickListener
.
Interfejs Google Play Services Location API
Interfejs API lokalizacji Usług Google Play to preferowana metoda dodawania informacji o lokalizacji do aplikacji na Androida. Zawiera funkcje, które umożliwiają:
- Określ lokalizację urządzenia.
- Wykrywaj zmiany lokalizacji.
- Ustal środek transportu, jeśli urządzenie jest w ruchu.
- Tworzenie i monitorowanie wstępnie zdefiniowanych regionów geograficznych, tzw. geofence.
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 SDK Usług Google Play. Więcej informacji o interfejsie Location API znajdziesz w lekcji szkoleń dotyczących Androida: Making Your App Location Aware (Ułatwianie rozpoznawania lokalizacji w aplikacjach) oraz Location API (Dokumentacja interfejsu Location API). Przykłady kodu są zawarte w pakiecie SDK Usług Google Play.