אירועים

בחירת פלטפורמה: Android iOS JavaScript

ה-SDK של מפות Google ל-Android מאפשר להאזין לאירועים במפה.

דוגמאות קוד

מאגר ApiDemos ב-GitHub כולל דוגמאות שמדגימות אירועים ומאזינים:

Java

• EventDemoActivity: אירועי קליקים על מפות ושינויים במצלמה
• CameraDemoActivity: אירועים של שינוי מצלמה
• CourDemoActivity: אירועי לחיצה וגרירה
• GroundLayerDemoActivity: אירועי קליקים על שכבת-על של קרקע
• IndoorDemoActivity: אירועים במפה פנימית
• MarkerDemoActivity: אירועים של סמן וחלון מידע
• PolygonDemoActivity: אירועי פוליגון

קוטלין

• EventDemoActivity: אירועי קליקים על מפות ושינויים במצלמה
• CameraDemoActivity: אירועים של שינוי מצלמה
• CourDemoActivity: אירועי לחיצה וגרירה
• GroundLayerDemoActivity: אירועי קליקים על שכבת-על של קרקע
• IndoorDemoActivity: אירועים במפה פנימית
• MarkerDemoActivity: אירועים של סמן וחלון מידע
• PolygonDemoActivity: אירועי פוליגון

לחיצה על מפה / אירועי לחיצה ארוכה

אם רוצים להגיב למשתמש שמקישים על נקודה במפה, אפשר להשתמש ב-OnMapClickListener שרוצים להגדיר במפה על ידי קריאה ל-GoogleMap.setOnMapClickListener(OnMapClickListener). כשמשתמש לוחץ (מקישים) במקום כלשהו במפה, מתקבל אירוע onMapClick(LatLng) שמציין את המיקום במפה שעליו המשתמש לחץ. שימו לב שאם אתם צריכים להשתמש במיקום המתאים במסך (בפיקסלים), תוכלו למצוא מפה Projection מהמפה שתאפשר לכם להמיר בין קואורדינטות קו רוחב/קו אורך לבין קואורדינטות של פיקסלים במסך.

אפשר גם להאזין לאירועים ארוכים באמצעות OnMapLongClickListener, שניתן להגדיר במפה על ידי קריאה ל-GoogleMap.setOnMapLongClickListener(OnMapLongClickListener). ה-listener הזה מתנהג כמו ה-clicklist של הקליק, ותתעדכן לגבי אירועים של לחיצה ארוכה עם קריאה חוזרת ל-onMapLongClick(LatLng).

השבתת אירועי קליק במצב בסיסי

כדי להשבית אירועי קליקים במפה במצב בסיסי, צריך להתקשר אל setClickable() בתצוגה שמכילה את ה-MapView או ה-MapFragment. האפשרות הזו שימושית, למשל כשמציגים מפה או מפות בתצוגת רשימה, שבה רוצים שפעולת הקליק תפעיל פעולה שאינה קשורה למפה.

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

עבור MapView:

Java

MapView mapView = findViewById(R.id.mapView);
mapView.setClickable(false);

      

Kotlin

val mapView = findViewById<MapView>(R.id.mapView)
mapView.isClickable = false

      

עבור MapFragment:

Java

SupportMapFragment mapFragment = (SupportMapFragment) getSupportFragmentManager()
    .findFragmentById(R.id.map);
View view = mapFragment.getView();
view.setClickable(false);

      

Kotlin

val mapFragment = supportFragmentManager
    .findFragmentById(R.id.map) as SupportMapFragment
val view = mapFragment.view
view?.isClickable = false

      

אירועים של החלפת מצלמה

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

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

הדוגמה הבאה ממחישה את הפונקציות הזמינות של פונקציות event listener של מצלמות:

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.graphics.Color;
import android.os.Bundle;
import android.util.Log;
import android.view.View;
import android.widget.CompoundButton;
import android.widget.SeekBar;
import android.widget.Toast;

import androidx.appcompat.app.AppCompatActivity;

import com.google.android.gms.maps.CameraUpdate;
import com.google.android.gms.maps.CameraUpdateFactory;
import com.google.android.gms.maps.GoogleMap;
import com.google.android.gms.maps.GoogleMap.CancelableCallback;
import com.google.android.gms.maps.GoogleMap.OnCameraIdleListener;
import com.google.android.gms.maps.GoogleMap.OnCameraMoveCanceledListener;
import com.google.android.gms.maps.GoogleMap.OnCameraMoveListener;
import com.google.android.gms.maps.GoogleMap.OnCameraMoveStartedListener;
import com.google.android.gms.maps.OnMapReadyCallback;
import com.google.android.gms.maps.SupportMapFragment;
import com.google.android.gms.maps.model.CameraPosition;
import com.google.android.gms.maps.model.LatLng;
import com.google.android.gms.maps.model.PolylineOptions;

/**
 * This shows how to change the camera position for the map.
 */
public class CameraDemoActivity extends AppCompatActivity implements
        OnCameraMoveStartedListener,
        OnCameraMoveListener,
        OnCameraMoveCanceledListener,
        OnCameraIdleListener,
        OnMapReadyCallback {
    private static final String TAG = CameraDemoActivity.class.getName();

    /**
     * The amount by which to scroll the camera. Note that this amount is in raw pixels, not dp
     * (density-independent pixels).
     */
    private static final int SCROLL_BY_PX = 100;

    public static final CameraPosition BONDI =
            new CameraPosition.Builder().target(new LatLng(-33.891614, 151.276417))
                    .zoom(15.5f)
                    .bearing(300)
                    .tilt(50)
                    .build();

    public static final CameraPosition SYDNEY =
            new CameraPosition.Builder().target(new LatLng(-33.87365, 151.20689))
                    .zoom(15.5f)
                    .bearing(0)
                    .tilt(25)
                    .build();

    private GoogleMap map;
    private CompoundButton animateToggle;
    private CompoundButton customDurationToggle;
    private SeekBar customDurationBar;
    private PolylineOptions currPolylineOptions;
    private boolean isCanceled = false;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.camera_demo);
        animateToggle = findViewById(R.id.animate);
        customDurationToggle = findViewById(R.id.duration_toggle);
        customDurationBar = findViewById(R.id.duration_bar);

        updateEnabledState();

        SupportMapFragment mapFragment =
                (SupportMapFragment) getSupportFragmentManager().findFragmentById(R.id.map);
        mapFragment.getMapAsync(this);
    }

    @Override
    protected void onResume() {
        super.onResume();
        updateEnabledState();
    }

    @Override
    public void onMapReady(GoogleMap googleMap) {
        map = googleMap;

        map.setOnCameraIdleListener(this);
        map.setOnCameraMoveStartedListener(this);
        map.setOnCameraMoveListener(this);
        map.setOnCameraMoveCanceledListener(this);
        // We will provide our own zoom controls.
        map.getUiSettings().setZoomControlsEnabled(false);
        map.getUiSettings().setMyLocationButtonEnabled(true);

        // Show Sydney
        map.moveCamera(CameraUpdateFactory.newLatLngZoom(new LatLng(-33.87365, 151.20689), 10));
    }

    /**
     * When the map is not ready the CameraUpdateFactory cannot be used. This should be called on
     * all entry points that call methods on the Google Maps API.
     */
    private boolean checkReady() {
        if (map == null) {
            Toast.makeText(this, R.string.map_not_ready, Toast.LENGTH_SHORT).show();
            return false;
        }
        return true;
    }

    /**
     * Called when the Go To Bondi button is clicked.
     */
    public void onGoToBondi(View view) {
        if (!checkReady()) {
            return;
        }

        changeCamera(CameraUpdateFactory.newCameraPosition(BONDI));
    }

    /**
     * Called when the Animate To Sydney button is clicked.
     */
    public void onGoToSydney(View view) {
        if (!checkReady()) {
            return;
        }

        changeCamera(CameraUpdateFactory.newCameraPosition(SYDNEY), new CancelableCallback() {
            @Override
            public void onFinish() {
                Toast.makeText(getBaseContext(), "Animation to Sydney complete", Toast.LENGTH_SHORT)
                        .show();
            }

            @Override
            public void onCancel() {
                Toast.makeText(getBaseContext(), "Animation to Sydney canceled", Toast.LENGTH_SHORT)
                        .show();
            }
        });
    }

    /**
     * Called when the stop button is clicked.
     */
    public void onStopAnimation(View view) {
        if (!checkReady()) {
            return;
        }

        map.stopAnimation();
    }

    /**
     * Called when the zoom in button (the one with the +) is clicked.
     */
    public void onZoomIn(View view) {
        if (!checkReady()) {
            return;
        }

        changeCamera(CameraUpdateFactory.zoomIn());
    }

    /**
     * Called when the zoom out button (the one with the -) is clicked.
     */
    public void onZoomOut(View view) {
        if (!checkReady()) {
            return;
        }

        changeCamera(CameraUpdateFactory.zoomOut());
    }

    /**
     * Called when the tilt more button (the one with the /) is clicked.
     */
    public void onTiltMore(View view) {
        if (!checkReady()) {
            return;
        }

        CameraPosition currentCameraPosition = map.getCameraPosition();
        float currentTilt = currentCameraPosition.tilt;
        float newTilt = currentTilt + 10;

        newTilt = (newTilt > 90) ? 90 : newTilt;

        CameraPosition cameraPosition = new CameraPosition.Builder(currentCameraPosition)
                .tilt(newTilt).build();

        changeCamera(CameraUpdateFactory.newCameraPosition(cameraPosition));
    }

    /**
     * Called when the tilt less button (the one with the \) is clicked.
     */
    public void onTiltLess(View view) {
        if (!checkReady()) {
            return;
        }

        CameraPosition currentCameraPosition = map.getCameraPosition();

        float currentTilt = currentCameraPosition.tilt;

        float newTilt = currentTilt - 10;
        newTilt = (newTilt > 0) ? newTilt : 0;

        CameraPosition cameraPosition = new CameraPosition.Builder(currentCameraPosition)
                .tilt(newTilt).build();

        changeCamera(CameraUpdateFactory.newCameraPosition(cameraPosition));
    }

    /**
     * Called when the left arrow button is clicked. This causes the camera to move to the left
     */
    public void onScrollLeft(View view) {
        if (!checkReady()) {
            return;
        }

        changeCamera(CameraUpdateFactory.scrollBy(-SCROLL_BY_PX, 0));
    }

    /**
     * Called when the right arrow button is clicked. This causes the camera to move to the right.
     */
    public void onScrollRight(View view) {
        if (!checkReady()) {
            return;
        }

        changeCamera(CameraUpdateFactory.scrollBy(SCROLL_BY_PX, 0));
    }

    /**
     * Called when the up arrow button is clicked. The causes the camera to move up.
     */
    public void onScrollUp(View view) {
        if (!checkReady()) {
            return;
        }

        changeCamera(CameraUpdateFactory.scrollBy(0, -SCROLL_BY_PX));
    }

    /**
     * Called when the down arrow button is clicked. This causes the camera to move down.
     */
    public void onScrollDown(View view) {
        if (!checkReady()) {
            return;
        }

        changeCamera(CameraUpdateFactory.scrollBy(0, SCROLL_BY_PX));
    }

    /**
     * Called when the animate button is toggled
     */
    public void onToggleAnimate(View view) {
        updateEnabledState();
    }

    /**
     * Called when the custom duration checkbox is toggled
     */
    public void onToggleCustomDuration(View view) {
        updateEnabledState();
    }

    /**
     * Update the enabled state of the custom duration controls.
     */
    private void updateEnabledState() {
        customDurationToggle.setEnabled(animateToggle.isChecked());
        customDurationBar
                .setEnabled(animateToggle.isChecked() && customDurationToggle.isChecked());
    }

    private void changeCamera(CameraUpdate update) {
        changeCamera(update, null);
    }

    /**
     * Change the camera position by moving or animating the camera depending on the state of the
     * animate toggle button.
     */
    private void changeCamera(CameraUpdate update, CancelableCallback callback) {
        if (animateToggle.isChecked()) {
            if (customDurationToggle.isChecked()) {
                int duration = customDurationBar.getProgress();
                // The duration must be strictly positive so we make it at least 1.
                map.animateCamera(update, Math.max(duration, 1), callback);
            } else {
                map.animateCamera(update, callback);
            }
        } else {
            map.moveCamera(update);
        }
    }

    @Override
    public void onCameraMoveStarted(int reason) {
        if (!isCanceled) {
            map.clear();
        }

        String reasonText = "UNKNOWN_REASON";
        currPolylineOptions = new PolylineOptions().width(5);
        switch (reason) {
            case OnCameraMoveStartedListener.REASON_GESTURE:
                currPolylineOptions.color(Color.BLUE);
                reasonText = "GESTURE";
                break;
            case OnCameraMoveStartedListener.REASON_API_ANIMATION:
                currPolylineOptions.color(Color.RED);
                reasonText = "API_ANIMATION";
                break;
            case OnCameraMoveStartedListener.REASON_DEVELOPER_ANIMATION:
                currPolylineOptions.color(Color.GREEN);
                reasonText = "DEVELOPER_ANIMATION";
                break;
        }
        Log.d(TAG, "onCameraMoveStarted(" + reasonText + ")");
        addCameraTargetToPath();
    }

    @Override
    public void onCameraMove() {
        // When the camera is moving, add its target to the current path we'll draw on the map.
        if (currPolylineOptions != null) {
            addCameraTargetToPath();
        }
        Log.d(TAG, "onCameraMove");
    }

    @Override
    public void onCameraMoveCanceled() {
        // When the camera stops moving, add its target to the current path, and draw it on the map.
        if (currPolylineOptions != null) {
            addCameraTargetToPath();
            map.addPolyline(currPolylineOptions);
        }
        isCanceled = true;  // Set to clear the map when dragging starts again.
        currPolylineOptions = null;
        Log.d(TAG, "onCameraMoveCancelled");
    }

    @Override
    public void onCameraIdle() {
        if (currPolylineOptions != null) {
            addCameraTargetToPath();
            map.addPolyline(currPolylineOptions);
        }
        currPolylineOptions = null;
        isCanceled = false;  // Set to *not* clear the map when dragging starts again.
        Log.d(TAG, "onCameraIdle");
    }

    private void addCameraTargetToPath() {
        LatLng target = map.getCameraPosition().target;
        currPolylineOptions.add(target);
    }
}
CameraDemoActivity.java

Kotlin

/*
 * Copyright 2018 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
 *
 *     https://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.graphics.Color
import android.os.Bundle
import android.util.Log
import android.view.View
import android.widget.CompoundButton
import android.widget.SeekBar
import android.widget.Toast
import androidx.appcompat.app.AppCompatActivity
import com.google.android.gms.maps.CameraUpdate
import com.google.android.gms.maps.CameraUpdateFactory
import com.google.android.gms.maps.GoogleMap
import com.google.android.gms.maps.GoogleMap.CancelableCallback
import com.google.android.gms.maps.GoogleMap.OnCameraIdleListener
import com.google.android.gms.maps.GoogleMap.OnCameraMoveCanceledListener
import com.google.android.gms.maps.GoogleMap.OnCameraMoveListener
import com.google.android.gms.maps.GoogleMap.OnCameraMoveStartedListener
import com.google.android.gms.maps.OnMapReadyCallback
import com.google.android.gms.maps.SupportMapFragment
import com.google.android.gms.maps.model.CameraPosition
import com.google.android.gms.maps.model.LatLng
import com.google.android.gms.maps.model.PolylineOptions

/**
 * This shows how to change the camera position for the map.
 */
class CameraDemoActivity :
        AppCompatActivity(),
        OnCameraMoveStartedListener,
        OnCameraMoveListener,
        OnCameraMoveCanceledListener,
        OnCameraIdleListener,
        OnMapReadyCallback {
    /**
     * The amount by which to scroll the camera. Note that this amount is in raw pixels, not dp
     * (density-independent pixels).
     */
    private val SCROLL_BY_PX = 100
    private val TAG = CameraDemoActivity::class.java.name
    private val sydneyLatLng = LatLng(-33.87365, 151.20689)
    private val bondiLocation: CameraPosition = CameraPosition.Builder()
            .target(LatLng(-33.891614, 151.276417))
            .zoom(15.5f)
            .bearing(300f)
            .tilt(50f)
            .build()

    private val sydneyLocation: CameraPosition = CameraPosition.Builder().
            target(LatLng(-33.87365, 151.20689))
            .zoom(15.5f)
            .bearing(0f)
            .tilt(25f)
            .build()

    private lateinit var map: GoogleMap
    private lateinit var animateToggle: CompoundButton
    private lateinit var customDurationToggle: CompoundButton
    private lateinit var customDurationBar: SeekBar
    private var currPolylineOptions: PolylineOptions? = null
    private var isCanceled = false

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.camera_demo)
        animateToggle = findViewById(R.id.animate)
        customDurationToggle = findViewById(R.id.duration_toggle)
        customDurationBar = findViewById(R.id.duration_bar)

        updateEnabledState()

        val mapFragment = supportFragmentManager.findFragmentById(R.id.map) as SupportMapFragment
        mapFragment.getMapAsync(this)
    }

    override fun onResume() {
        super.onResume()
        updateEnabledState()
    }

    override fun onMapReady(googleMap: GoogleMap) {
        map = googleMap
        // return early if the map was not initialised properly
        with(googleMap) {
            setOnCameraIdleListener(this@CameraDemoActivity)
            setOnCameraMoveStartedListener(this@CameraDemoActivity)
            setOnCameraMoveListener(this@CameraDemoActivity)
            setOnCameraMoveCanceledListener(this@CameraDemoActivity)
            // We will provide our own zoom controls.
            uiSettings.isZoomControlsEnabled = false
            uiSettings.isMyLocationButtonEnabled = true

            // Show Sydney
            moveCamera(CameraUpdateFactory.newLatLngZoom(sydneyLatLng, 10f))
        }
    }

    /**
     * When the map is not ready the CameraUpdateFactory cannot be used. This should be used to wrap
     * all entry points that call methods on the Google Maps API.
     *
     * @param stuffToDo the code to be executed if the map is initialised
     */
    private fun checkReadyThen(stuffToDo: () -> Unit) {
        if (!::map.isInitialized) {
            Toast.makeText(this, R.string.map_not_ready, Toast.LENGTH_SHORT).show()
        } else {
            stuffToDo()
        }
    }

    /**
     * Called when the Go To Bondi button is clicked.
     */
    @Suppress("UNUSED_PARAMETER")
    fun onGoToBondi(view: View) {
        checkReadyThen {
            changeCamera(CameraUpdateFactory.newCameraPosition(bondiLocation))
        }
    }

    /**
     * Called when the Animate To Sydney button is clicked.
     */
    @Suppress("UNUSED_PARAMETER")
    fun onGoToSydney(view: View) {
        checkReadyThen {
            changeCamera(CameraUpdateFactory.newCameraPosition(sydneyLocation),
                    object : CancelableCallback {
                        override fun onFinish() {
                            Toast.makeText(baseContext, "Animation to Sydney complete",
                                    Toast.LENGTH_SHORT).show()
                        }

                        override fun onCancel() {
                            Toast.makeText(baseContext, "Animation to Sydney canceled",
                                    Toast.LENGTH_SHORT).show()
                        }
                    })
        }
    }

    /**
     * Called when the stop button is clicked.
     */
    @Suppress("UNUSED_PARAMETER")
    fun onStopAnimation(view: View) = checkReadyThen { map.stopAnimation() }

    /**
     * Called when the zoom in button (the one with the +) is clicked.
     */
    @Suppress("UNUSED_PARAMETER")
    fun onZoomIn(view: View) = checkReadyThen { changeCamera(CameraUpdateFactory.zoomIn()) }

    /**
     * Called when the zoom out button (the one with the -) is clicked.
     */
    @Suppress("UNUSED_PARAMETER")
    fun onZoomOut(view: View) = checkReadyThen { changeCamera(CameraUpdateFactory.zoomOut()) }

    /**
     * Called when the tilt more button (the one with the /) is clicked.
     */
    @Suppress("UNUSED_PARAMETER")
    fun onTiltMore(view: View) {
        checkReadyThen {

            val newTilt = Math.min(map.cameraPosition.tilt + 10, 90F)
            val cameraPosition = CameraPosition.Builder(map.cameraPosition).tilt(newTilt).build()

            changeCamera(CameraUpdateFactory.newCameraPosition(cameraPosition))
        }
    }

    /**
     * Called when the tilt less button (the one with the \) is clicked.
     */
    @Suppress("UNUSED_PARAMETER")
    fun onTiltLess(view: View) {
        checkReadyThen {

            val newTilt = Math.max(map.cameraPosition.tilt - 10, 0F)
            val cameraPosition = CameraPosition.Builder(map.cameraPosition).tilt(newTilt).build()

            changeCamera(CameraUpdateFactory.newCameraPosition(cameraPosition))
        }
    }

    /**
     * Called when the left arrow button is clicked. This causes the camera to move to the left
     */
    @Suppress("UNUSED_PARAMETER")
    fun onScrollLeft(view: View) {
        checkReadyThen {
            changeCamera(CameraUpdateFactory.scrollBy((-SCROLL_BY_PX).toFloat(),0f))
        }
    }

    /**
     * Called when the right arrow button is clicked. This causes the camera to move to the right.
     */
    @Suppress("UNUSED_PARAMETER")
    fun onScrollRight(view: View) {
        checkReadyThen {
            changeCamera(CameraUpdateFactory.scrollBy(SCROLL_BY_PX.toFloat(), 0f))
        }
    }

    /**
     * Called when the up arrow button is clicked. The causes the camera to move up.
     */
    @Suppress("UNUSED_PARAMETER")
    fun onScrollUp(view: View) {
        checkReadyThen {
            changeCamera(CameraUpdateFactory.scrollBy(0f, (-SCROLL_BY_PX).toFloat()))
        }
    }

    /**
     * Called when the down arrow button is clicked. This causes the camera to move down.
     */
    @Suppress("UNUSED_PARAMETER")
    fun onScrollDown(view: View) {
        checkReadyThen {
            changeCamera(CameraUpdateFactory.scrollBy(0f, SCROLL_BY_PX.toFloat()))
        }
    }

    /**
     * Called when the animate button is toggled
     */
    @Suppress("UNUSED_PARAMETER")
    fun onToggleAnimate(view: View) = updateEnabledState()

    /**
     * Called when the custom duration checkbox is toggled
     */
    @Suppress("UNUSED_PARAMETER")
    fun onToggleCustomDuration(view: View) = updateEnabledState()

    /**
     * Update the enabled state of the custom duration controls.
     */
    private fun updateEnabledState() {
        customDurationToggle.isEnabled = animateToggle.isChecked
        customDurationBar.isEnabled = animateToggle.isChecked && customDurationToggle.isChecked
    }

    /**
     * Change the camera position by moving or animating the camera depending on the state of the
     * animate toggle button.
     */
    private fun changeCamera(update: CameraUpdate, callback: CancelableCallback? = null) {
        if (animateToggle.isChecked) {
            if (customDurationToggle.isChecked) {
                // The duration must be strictly positive so we make it at least 1.
                map.animateCamera(update, Math.max(customDurationBar.progress, 1), callback)
            } else {
                map.animateCamera(update, callback)
            }
        } else {
            map.moveCamera(update)
        }
    }

    override fun onCameraMoveStarted(reason: Int) {
        if (!isCanceled) map.clear()

        var reasonText = "UNKNOWN_REASON"
        currPolylineOptions = PolylineOptions().width(5f)
        when (reason) {
            OnCameraMoveStartedListener.REASON_GESTURE -> {
                currPolylineOptions?.color(Color.BLUE)
                reasonText = "GESTURE"
            }
            OnCameraMoveStartedListener.REASON_API_ANIMATION -> {
                currPolylineOptions?.color(Color.RED)
                reasonText = "API_ANIMATION"
            }
            OnCameraMoveStartedListener.REASON_DEVELOPER_ANIMATION -> {
                currPolylineOptions?.color(Color.GREEN)
                reasonText = "DEVELOPER_ANIMATION"
            }
        }
        Log.d(TAG, "onCameraMoveStarted($reasonText)")
        addCameraTargetToPath()
    }

    /**
     * Ensures that currPolyLine options is not null before accessing it
     *
     * @param stuffToDo the code to be executed if currPolylineOptions is not null
     */
    private fun checkPolylineThen(stuffToDo: () -> Unit) {
        if (currPolylineOptions != null) stuffToDo()
    }

    override fun onCameraMove() {
        Log.d(TAG, "onCameraMove")
        // When the camera is moving, add its target to the current path we'll draw on the map.
        checkPolylineThen { addCameraTargetToPath() }
    }

    override fun onCameraMoveCanceled() {
        // When the camera stops moving, add its target to the current path, and draw it on the map.
        checkPolylineThen {
            addCameraTargetToPath()
            map.addPolyline(currPolylineOptions!!)
        }

        isCanceled = true  // Set to clear the map when dragging starts again.
        currPolylineOptions = null
        Log.d(TAG, "onCameraMoveCancelled")
    }

    override fun onCameraIdle() {
        checkPolylineThen {
            addCameraTargetToPath()
            map.addPolyline(currPolylineOptions!!)
        }

        currPolylineOptions = null
        isCanceled = false  // Set to *not* clear the map when dragging starts again.
        Log.d(TAG, "onCameraIdle")
    }
    private fun addCameraTargetToPath() {
        currPolylineOptions?.add(map.cameraPosition.target)
    }
}
CameraDemoActivity.kt

פונקציות ההאזנה הבאות זמינות:

• הקריאה החוזרת (onCameraMoveStarted()) של OnCameraMoveStartedListener מופעלת כשהמצלמה מתחילה לנוע. לשיטת הקריאה החוזרת (callback) מתקבל הערך reason עבור תנועת המצלמה. הסיבה יכולה להיות אחת מהאפשרויות הבאות:

  • REASON_GESTURE מציינת שהמצלמה זזה בתגובה לתנועות של המשתמש במפה, כמו הזזת המצלמה, הטיה, תנועת צביטה כדי לשנות את מרחק התצוגה או סיבוב המפה.
  • ב-REASON_API_ANIMATION, ממשק ה-API העביר את המצלמה בתגובה לפעולה שאינה של תנועות, כמו הקשה על לחצן הזום, הקשה על הלחצן 'המיקום שלי' או לחיצה על סמן.
  • REASON_DEVELOPER_ANIMATION זהו סימן לכך שהאפליקציה יזמה את תנועת המצלמה.

• הקריאה החוזרת (callback) של onCameraMove(), מופעלת ב-OnCameraMoveListener כמה פעמים, כשהמצלמה זזה או שהמשתמש מקיים אינטראקציה עם מסך המגע. כדי לדעת באיזו תדירות מופעלת הקריאה החוזרת (callback), חשוב לדעת שה-API מפעיל קריאה חוזרת פעם אחת לכל מסגרת. עם זאת, חשוב לדעת שהקריאה החוזרת הזו מופעלת באופן אסינכרוני ולכן היא לא מסונכרנת עם מה שמוצג במסך. כמו כן, יכול להיות שמיקום המצלמה לא ישתנה בין קריאה אחת (onCameraMove()) לקריאה הבאה.

• הקריאה החוזרת (OnCameraIdle()) של OnCameraIdleListener מופעלת כשהמצלמה מפסיקה לזוז והמשתמש מפסיק ליצור אינטראקציה עם המפה.

• הקריאה החוזרת (callback) של OnCameraMoveCanceled() של OnCameraMoveCanceledListener מופעלת כשמתבצעת הפרעה לתנועת המצלמה הנוכחית. מיד אחרי הקריאה החוזרת (callback) של OnCameraMoveCanceled(), הקריאה החוזרת (callback) של onCameraMoveStarted() מופעלת עם reason החדש.

  אם האפליקציה קוראת באופן מפורש ל-GoogleMap.stopAnimation(), הקריאה החוזרת (callback) של OnCameraMoveCanceled() מופעלת, אבל הקריאה החוזרת (callback) onCameraMoveStarted() לא מופעלת.

כדי להגדיר רכיב listener במפה, יש לקרוא לשיטה הרלוונטית של מאזין המכשיר. לדוגמה, כדי לבקש שיחה חוזרת מ-OnCameraMoveStartedListener, צריך להתקשר אל GoogleMap.setOnCameraMoveStartedListener().

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

הודעה על הוצאה משימוש: הOnCameraChangeListener הוצא משימוש לטובת המאזינים המתוארים למעלה, כלומר OnCameraMoveStartedListener, OnCameraMoveListener, OnCameraMoveCanceledListener וגם OnCameraIdleListener.

אירועים בעסקים ונקודות עניין אחרות

כברירת מחדל, נקודות עניין (POI) מופיעות במפה הבסיסית יחד עם הסמלים שלהן. נקודות עניין כוללות פארקים, בתי ספר, בנייני ממשלה ועוד, וכן נקודות עניין עסקיות כמו חנויות, מסעדות ומלונות.

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

אירועים במפה פנימית

אתם יכולים להשתמש באירועים כדי למצוא את הרמה הפעילה של מפת הפנים ולהתאים אותה אישית. להשתמש בממשק של OnIndoorStateChangeListener כדי להגדיר את ה-listener לצורך קריאה כשמתמקדים בבניינים חדשים או כשמופעלת רמה חדשה במבנה.

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

לאחר מכן תוכלו למצוא את הרמה הפעילה כרגע על ידי קריאה ל-IndoorBuilding.getActiveLevelIndex().

Java

IndoorBuilding building = map.getFocusedBuilding();
if (building != null) {
    int activeLevelIndex = building.getActiveLevelIndex();
    IndoorLevel activeLevel = building.getLevels().get(activeLevelIndex);
}

      

Kotlin

map.focusedBuilding?.let { building: IndoorBuilding ->
    val activeLevelIndex = building.activeLevelIndex
    val activeLevel = building.levels[activeLevelIndex]
}

      

הוא שימושי אם רוצים להציג תגי עיצוב מותאמים אישית עבור הרמה הפעילה, למשל: סמנים, שכבות-על של קרקע, שכבות-על של משבצות, פוליגונים, פוליגונים וצורות אחרות.

רמז: כדי לחזור לרמת הרחוב, יש לקבל את רמת ברירת המחדל דרך IndoorBuilding.getDefaultLevelIndex(), ולהגדיר אותה כרמה הפעילה דרך IndoorLevel.activate().

אירועים של סמן וחלון מידע

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

אפשר גם להאזין לאירועים בחלונות מידע.

אירועי צורה ושכבת-על

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

הערה: אם שכבות-על או צורות מרובות (סמנים, פוליגונים, פוליגונים, עיגולים ו/או שכבות-על של קרקע) מוצבות בשכבת-על זו מעל זו, אירוע הקליק עובר תחילה בין אשכול הסמנים ואז מופעל על ידי שכבות-על או צורות קליקביליות אחרות על סמך ערכי אינדקס ה-z שלהם. לכל היותר אירוע אחד מופעל לכל קליק. במילים אחרות, הקליק לא יועבר לשכבות-העל או לצורות עם ערכי z-index נמוכים יותר. למידע נוסף על אינדקס z-index ואירועים של קליקים.

אירועי מיקום

האפליקציה שלכם יכולה להגיב לאירועים הבאים שקשורים לשכבת 'המיקום שלי':

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

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