Jedną z unikalnych funkcji aplikacji mobilnych jest to, że mogą one wykrywać lokalizację. Użytkownicy mobilni wszędzie zabierają ze sobą swoje urządzenia. Dzięki dodaniu informacji o lokalizacji do aplikacji aplikacja zapewnia im bardziej spersonalizowane wrażenia.
Przykładowe fragmenty kodu
Repozytorium ApiDemos w GitHubie zawiera przykłady, które pokazują użycie lokalizacji na mapie:
Kotlin
- MyLocationDemoActivity: za pomocą warstwy Moja lokalizacja, w tym uprawnień w czasie działania.
- LocationSourceDemoActivity: za pomocą niestandardowego elementu
LocationSource
. - CurrentPlaceDetailsOnMap: określanie bieżącej lokalizacji urządzenia z Androidem i wyświetlanie szczegółowych informacji o miejscu (firmie lub innym ciekawym miejscu) w tej lokalizacji. Zapoznaj się z samouczkiem dotyczącym wyświetlania informacji o bieżącym miejscu na mapie.
Java
- MyLocationDemoActivity: za pomocą warstwy Moja lokalizacja, w tym uprawnień w czasie działania.
- LocationSourceDemoActivity: za pomocą niestandardowego elementu
LocationSource
. - CurrentPlaceDetailsOnMap: określanie bieżącej lokalizacji urządzenia z Androidem i wyświetlanie szczegółowych informacji o miejscu (firmie lub innym ciekawym miejscu) w tej lokalizacji. Zapoznaj się z samouczkiem dotyczącym wyświetlania informacji o bieżącym miejscu na mapie.
Praca z danymi o lokalizacji
Dane o lokalizacji dostępne dla urządzenia z Androidem obejmują bieżącą lokalizację urządzenia określoną za pomocą kombinacji technologii – kierunek i metodę ruchu, a także informacje o tym, czy urządzenie poruszało się po wstępnie zdefiniowanej granicy geograficznej lub geofencingu. W zależności od potrzeb aplikacji możesz wybrać 1 z kilku sposobów pracy z danymi o lokalizacji:
- Warstwa Moja lokalizacja ułatwia wyświetlanie lokalizacji urządzenia na mapie. Nie zawiera danych.
- Interfejs Google Play Services Location API jest zalecany w przypadku wszystkich zautomatyzowanych żądań danych o lokalizacji.
- Interfejs
LocationSource
umożliwia Ci określenie niestandardowego dostawcy lokalizacji.
Dostęp do lokalizacji
Jeśli Twoja aplikacja potrzebuje dostępu do lokalizacji użytkownika, musisz poprosić o ich przyznanie, dodając do niej odpowiednie uprawnienia do lokalizacji.
Android zapewnia 2 dostęp do lokalizacji: ACCESS_COARSE_LOCATION
i ACCESS_FINE_LOCATION
. Od wybranych uprawnień zależy dokładność lokalizacji zwracanej przez interfejs API.
android.permission.ACCESS_COARSE_LOCATION
– umożliwia interfejsowi API zwrócenie przybliżonej lokalizacji urządzenia. Uprawnienia zapewniają oszacowanie lokalizacji urządzenia uzyskiwane z usług lokalizacyjnych zgodnie z opisem w dokumentacji dotyczącej przybliżonej dokładności lokalizacji.android.permission.ACCESS_FINE_LOCATION
– umożliwia interfejsowi API określenie możliwie najbardziej dokładnej lokalizacji od dostępnych dostawców lokalizacji, w tym z globalnego systemu pozycjonowania (GPS) oraz sieci Wi-Fi i komórkowych danych komórkowych.
Dodaj uprawnienia do pliku manifestu aplikacji
Jeśli do działania aplikacji potrzebna jest tylko przybliżona lokalizacja, dodaj do pliku manifestu aplikacji uprawnienie ACCESS_COARSE_LOCATION
:
<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 potrzebna jest dokładna lokalizacja, dodaj do pliku manifestu aplikacji 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 aplikacji
Android 6.0 (Marshmallow) wprowadza nowy model obsługi uprawnień, który upraszcza proces instalowania i uaktualniania 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 działa Android 6.0 (Marshmallow) lub nowszy, użytkownik nie musi przyznawać żadnych uprawnień podczas instalowania lub uaktualniania aplikacji. Aplikacja musi sprawdzać, czy ma niezbędne uprawnienia w czasie działania, a jeśli ich nie ma – prosić o przyznanie uprawnień. System wyświetli użytkownikowi prośbę o przyznanie uprawnień.
Ze względu na wygodę użytkowników ważne jest, aby prosić o uprawnienia w kontekście. Jeśli lokalizacja jest niezbędna do działania aplikacji, podczas jej uruchamiania poproś o jej dostęp. Dobrym sposobem jest wyświetlenie ekranu powitalnego lub kreatora, który poinformuje użytkowników, dlaczego dane uprawnienia są wymagane.
Jeśli aplikacja wymaga uprawnień tylko w przypadku niektórych funkcji, należy o niego poprosić podczas wykonywania działania, które wymaga tego uprawnienia.
Aplikacja musi płynnie obsłużyć przypadek, gdy użytkownik nie przyzna uprawnień. Jeśli na przykład uprawnienia są potrzebne do konkretnej funkcji, aplikacja może ją wyłączyć. Jeśli uprawnienie jest niezbędne do działania aplikacji, może ona wyłączyć wszystkie funkcje i informować użytkownika, że musi je przyznać.
Poniższy przykładowy kod sprawdza uprawnienia przy użyciu biblioteki AndroidX przed włączeniem warstwy Moja lokalizacja. Następnie obsługuje wynik prośby o uprawnienia, implementując 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
Korzystając z warstwy Moja lokalizacja i przycisku Moja lokalizacja, można pokazać użytkownikowi aktualną pozycję na mapie. Zadzwoń pod numer mMap.setMyLocationEnabled()
,
aby włączyć warstwę Moja lokalizacja na mapie.
Poniższy przykład przedstawia proste wykorzystanie 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 warstwa Moja lokalizacja jest włączona, w prawym górnym rogu mapy pojawia się przycisk Moja lokalizacja. Gdy użytkownik kliknie przycisk, kamera wyśrodkuje mapę na bieżącej lokalizacji urządzenia, jeśli jest ona znana. Lokalizacja jest oznaczona na mapie małą niebieską kropką, jeśli urządzenie jest nieruchome, lub szewronem, jeśli się porusza.
Poniższy zrzut ekranu przedstawia przycisk Moja lokalizacja w prawym górnym rogu i niebieski punkt Moja lokalizacja na środku mapy:
Możesz wyłączyć wyświetlanie przycisku Moja lokalizacja, dzwoniąc 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()
z protokołuGoogleMap.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 Location API Usług Google Play to preferowana metoda dodawania informacji o lokalizacji do aplikacji na Androida. Zawiera funkcje, które umożliwiają:
- Ustalać lokalizację urządzenia.
- Wykrywaj zmiany lokalizacji.
- Ustal środek transportu, jeśli urządzenie jest w ruchu.
- Tworzenie i monitorowanie zdefiniowanych wcześniej regionów geograficznych tzw. geofence.
Interfejsy API lokalizacji ułatwiają tworzenie energooszczędnych aplikacji rozpoznających lokalizację. Podobnie jak pakiet SDK Map Google na Androida, interfejs Location API jest częścią pakietu SDK Usług Google Play. Więcej informacji o interfejsie Location API znajdziesz na lekcji szkoleniowej dotyczącej Androida Making Your App Location Aware lub w dokumentacji interfejsu Location API. Przykładowe fragmenty kodu wchodzą w skład pakietu SDK Usług Google Play.