דף זה תורגם על ידי Cloud Translation API.

נתוני מיקום

אחת התכונות הייחודיות של אפליקציות לנייד היא היכולת לזהות מיקום. משתמשים בנייד לוקחים את המכשירים שלהם לכל מקום, והוספת מידע על המיקום לאפליקציה מאפשרת למשתמשים ליהנות מחוויה יותר רלוונטית.

דוגמאות קוד

מאגר ApiDemos ב-GitHub כולל דוגמאות שממחישות את השימוש במיקום במפה:

Kotlin

‫MyLocationDemoActivity: שימוש בשכבת המיקום שלי, כולל הרשאות בזמן ריצה
‫LocationSourceDemoActivity: שימוש ב-LocationSource מותאם אישית
‫CurrentPlaceDetailsOnMap: מציאת המיקום הנוכחי של מכשיר Android והצגת פרטים של המקום (עסק או נקודת עניין אחרת) במיקום הזה. אפשר לעיין במדריך בנושא הצגת פרטים של המקום הנוכחי במפה.

Java

‫MyLocationDemoActivity: שימוש בשכבת המיקום שלי, כולל הרשאות בזמן ריצה
‫LocationSourceDemoActivity: שימוש ב-LocationSource מותאם אישית
‫CurrentPlaceDetailsOnMap: מציאת המיקום הנוכחי של מכשיר Android והצגת פרטים של המקום (עסק או נקודת עניין אחרת) במיקום הזה. אפשר לעיין במדריך בנושא הצגת פרטים של המקום הנוכחי במפה.

עבודה עם נתוני מיקום

נתוני המיקום שזמינים למכשיר Android כוללים את המיקום הנוכחי של המכשיר – שנקבע באמצעות שילוב של טכנולוגיות – את כיוון התנועה ואת שיטת התנועה, ואם המכשיר עבר גבול גיאוגרפי מוגדר מראש, או גדר וירטואלית. בהתאם לצרכים של האפליקציה, אפשר לבחור בין כמה דרכים לעבודה עם נתוני מיקום:

שכבת המיקום שלי מאפשרת להציג בקלות את מיקום המכשיר במפה. הוא לא מספק נתונים.
מומלץ להשתמש ב-Google Play services Location API לכל הבקשות לנתוני מיקום שמוגשות באופן פרוגרמטי.
ממשק LocationSource מאפשר לכם לספק ספק מיקום בהתאמה אישית.

הרשאות מיקום

אם האפליקציה שלך צריכה לגשת למיקום של המשתמש, עליך לבקש הרשאה על ידי הוספת הרשאות המיקום הרלוונטיות של Android לאפליקציה.

ב-Android יש שתי הרשאות מיקום: ACCESS_COARSE_LOCATION ו-ACCESS_FINE_LOCATION. ההרשאה שתבחרו תקבע את רמת הדיוק של המיקום שיוחזר על ידי ה-API.

‫android.permission.ACCESS_COARSE_LOCATION – מאפשרת ל-API להחזיר את המיקום המשוער של המכשיר. ההרשאה מספקת הערכה של מיקום המכשיר משירותי המיקום, כפי שמתואר במסמכי התיעוד בנושא דיוק משוער של המיקום.
‫android.permission.ACCESS_FINE_LOCATION – מאפשר ל-API לקבוע מיקום מדויק ככל האפשר מספקי המיקום הזמינים, כולל מערכת המיקום הגלובלית (GPS) וגם נתונים של Wi-Fi ותאים סלולריים.

הערה: ב-Android מגרסה 12 (רמת API‏ 31) ואילך, המשתמשים יכולים לבקש שהאפליקציה תאחזר רק מידע על מיקום משוער, גם אם האפליקציה מבקשת את הרשאת זמן הריצה ACCESS_FINE_LOCATION. כדי לטפל בזה, צריך לבקש את ההרשאות ACCESS_FINE_LOCATION ו-ACCESS_COARSE_LOCATION בבקשה אחת להרשאה בזמן ריצה. כדאי לעיין במאמר המשתמש יכול להעניק רק מיקום משוער.

הוספת ההרשאות למניפסט של האפליקציה

אם המיקום המשוער נדרש רק כדי שהאפליקציה תפעל, צריך להוסיף את ההרשאה 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>

עם זאת, אם נדרש מיקום מדויק, צריך להוסיף את ההרשאות ACCESS_COARSE_LOCATION ו-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>

בקשת הרשאות בזמן ריצה

‫Android 6.0 (Marshmallow) כולל מודל חדש לטיפול בהרשאות, שמייעל את התהליך עבור המשתמשים כשהם מתקינים ומעדכנים אפליקציות. אם האפליקציה שלכם מטרגטת רמת API‏ 23 ומעלה, אתם יכולים להשתמש במודל ההרשאות החדש.

אם האפליקציה תומכת במודל ההרשאות החדש והמכשיר מריץ Android 6.0 (Marshmallow) ואילך, המשתמש לא צריך להעניק הרשאות כלשהן כשהוא מתקין או משדרג את האפליקציה. האפליקציה צריכה לבדוק אם יש לה את ההרשאה הנדרשת בזמן הריצה, ולבקש את ההרשאה אם היא לא קיימת. המערכת מציגה למשתמש תיבת דו-שיח שבה הוא מתבקש לתת הרשאה.

כדי ליצור את חוויית המשתמש הטובה ביותר, חשוב לבקש את ההרשאה בהקשר. אם המיקום חיוני לפעולת האפליקציה, צריך לבקש את הרשאת המיקום בהפעלת האפליקציה. דרך טובה לעשות את זה היא באמצעות מסך פתיחה או אשף שמסבירים למשתמשים למה נדרשת ההרשאה.

אם האפליקציה דורשת את ההרשאה רק לחלק מהפונקציונליות שלה, צריך לבקש את הרשאת המיקום בזמן שהאפליקציה מבצעת את הפעולה שדורשת את ההרשאה.

האפליקציה צריכה לטפל בצורה תקינה במקרה שבו המשתמש לא מעניק הרשאה. לדוגמה, אם ההרשאה נדרשת לתכונה ספציפית, האפליקציה יכולה להשבית את התכונה הזו. אם ההרשאה חיונית לפעולת האפליקציה, האפליקציה יכולה להשבית את כל הפונקציונליות שלה וליידע את המשתמש שהוא צריך להעניק את ההרשאה.

בדוגמת הקוד הבאה נעשה שימוש בספריית AndroidX כדי לבדוק אם יש הרשאה לפני שמפעילים את שכבת 'המיקום שלי'. לאחר מכן, הוא מטפל בתוצאה של בקשת ההרשאה באמצעות הטמעה של ActivityCompat.OnRequestPermissionsResultCallback מספריית התמיכה:

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.view.View
import android.widget.Toast

import androidx.core.app.ActivityCompat
import androidx.core.app.ActivityCompat.OnRequestPermissionsResultCallback
import androidx.core.content.ContextCompat
import com.example.common_ui.R
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 : SamplesBaseActivity(),
    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)
        applyInsets(findViewById<View?>(R.id.map_container))
    }

    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
    }
}MyLocationDemoActivity.kt

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 SamplesBaseActivity
    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(com.example.common_ui.R.layout.my_location_demo);

        SupportMapFragment mapFragment =
            (SupportMapFragment) getSupportFragmentManager().findFragmentById(com.example.common_ui.R.id.map);
        mapFragment.getMapAsync(this);
        applyInsets(findViewById(com.example.common_ui.R.id.map_container));
    }

    @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");
    }

}MyLocationDemoActivity.java

השכבה 'המיקום שלי'

אפשר להשתמש בשכבת 'המיקום שלי' ובלחצן 'המיקום שלי' כדי להציג למשתמש את המיקום הנוכחי שלו במפה. מתקשרים אל mMap.setMyLocationEnabled() כדי להפעיל את שכבת המיקום שלי במפה.

בדוגמה הבאה מוצג שימוש פשוט בשכבת המיקום שלי:

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
    }
}
MyLocationLayerActivity.kt

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;
    }
}
MyLocationLayerActivity.java

כשהשכבה 'המיקום שלי' מופעלת, לחצן 'המיקום שלי' מופיע בפינה השמאלית העליונה של המפה. כשמשתמש לוחץ על הלחצן, המפה מתמקדת במיקום הנוכחי של המכשיר, אם הוא ידוע. המיקום מסומן במפה כנקודה כחולה קטנה אם המכשיר נייח, או כחץ אם המכשיר בתנועה.

בצילום המסך הבא מוצג לחצן 'המיקום שלי' בפינה השמאלית העליונה, והנקודה הכחולה של 'המיקום שלי' במרכז המפה:

כדי למנוע את הצגת הלחצן 'המיקום שלי', צריך להתקשר אל UiSettings.setMyLocationButtonEnabled(false).

האפליקציה יכולה להגיב לאירועים הבאים:

אם המשתמש לוחץ על הלחצן 'המיקום שלי', האפליקציה מקבלת קריאה חוזרת (callback) של onMyLocationButtonClick() מ-GoogleMap.OnMyLocationButtonClickListener.
אם המשתמש לוחץ על הנקודה הכחולה 'המיקום שלי', האפליקציה מקבלת קריאה חוזרת (callback) של onMyLocationClick() מ-GoogleMap.OnMyLocationClickListener.

‫Google Play services Location API

Location API של Google Play Services היא השיטה המומלצת להוספת יכולת זיהוי מיקום לאפליקציית Android. היא כוללת פונקציות שמאפשרות לכם:

לבדוק מה המיקום של המכשיר.
האזנה לשינויים במיקום.
קביעת אמצעי התחבורה, אם המכשיר נמצא בתנועה.
יצירה ומעקב אחרי אזורים גיאוגרפיים מוגדרים מראש, שנקראים גדרות וירטואליות.

ממשקי ה-API למיקום מאפשרים לכם לבנות בקלות אפליקציות יעילות בצריכת החשמל שמודעות למיקום. בדומה ל-Maps SDK ל-Android, ‏ Location API מופץ כחלק מ-Google Play Services SDK. מידע נוסף על Location API זמין בשיעור ההדרכה בנושא Android Making Your App Location Aware או בLocation API Reference. דוגמאות לקוד כלולות כחלק מ-Google Play Services SDK.

נתוני מיקום קל לארגן דפים בעזרת אוספים אפשר לשמור ולסווג תוכן על סמך ההעדפות שלך.

דוגמאות קוד

עבודה עם נתוני מיקום

הרשאות מיקום

הוספת ההרשאות למניפסט של האפליקציה

בקשת הרשאות בזמן ריצה

Kotlin

Java

השכבה 'המיקום שלי'

Kotlin

Java

‫Google Play services Location API

נתוני מיקום