אירועים

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

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

דוגמאות קוד

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

Kotlin

Java

אירועים מסוג קליק / קליק ארוך במפה

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

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

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

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

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

עבור MapView:

Kotlin

mapView?.isClickable = false

Java

if (mapView != null) {
    mapView.setClickable(false);
}

עבור MapFragment:

Kotlin

if (context is FragmentActivity) {
    val mapFragment = context.supportFragmentManager
        .findFragmentById(R.id.map) as? SupportMapFragment
    val view = mapFragment?.view
    view?.isClickable = false
}

Java

if (context instanceof FragmentActivity) {
    SupportMapFragment mapFragment = (SupportMapFragment) ((FragmentActivity) context)
        .getSupportFragmentManager().findFragmentById(R.id.map);
    if (mapFragment != null) {
        View view = mapFragment.getView();
        if (view != null) {
            view.setClickable(false);
        }
    }
}

אירועים של שינוי מצלמה

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

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

הדוגמה הבאה ממחישה את כל רכיבי ה-event listener הזמינים של המצלמה:

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 com.example.common_ui.catalog.Sample
import com.example.common_ui.catalog.Complexity
import com.example.common_ui.catalog.Framework

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 com.example.common_ui.R

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.MarkerOptions
import com.example.common_ui.databinding.CameraDemoBinding
import com.google.android.gms.maps.model.PolylineOptions

/**
 * This shows how to change the camera position for the map.
 */
@Sample(
    id = "com.example.kotlindemos.CameraDemoActivity",
    title = "Camera Controls & Animation",
    description = "Programmatic camera panning, zooming, tilt, bearing, and smooth animations.",
    category = "Camera Controls",
    complexity = Complexity.SIMPLE,
    tags = ["#camera", "#animation", "#bearing", "#tilt", "#zoom", "#pan"],
    apiCalls = [
        "GoogleMap.animateCamera(CameraUpdate)",
        "GoogleMap.moveCamera(CameraUpdate)",
        "GoogleMap.addMarker(MarkerOptions)",
        "CameraUpdateFactory.newCameraPosition(CameraPosition)"
    ],
    purpose = "Demonstrates programmatic camera movements, animated transitions, tilt angles, and bearing rotations.",
    successCriteria = "Buttons animate camera smoothly with custom durations, stops, and rotation angles.",
    failureIndicators = "Jerky animations, unexpected camera jumps, or tilt angle exceeding platform constraints.",
    framework = Framework.KOTLIN_VIEWS
)
class CameraDemoActivity :
        SamplesBaseActivity(),
        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
    private lateinit var binding: CameraDemoBinding

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        binding = CameraDemoBinding.inflate(layoutInflater)
        setContentView(binding.root)
        animateToggle = binding.animate
        customDurationToggle = binding.durationToggle
        customDurationBar = binding.durationBar

        updateEnabledState()

        val mapFragment = supportFragmentManager.findFragmentById(R.id.map) as SupportMapFragment
        mapFragment.getMapAsync(this)
        applyInsets(binding.mapContainer)

        binding.bondi.setOnClickListener(this::onGoToBondi)
        binding.sydney.setOnClickListener(this::onGoToSydney)
        binding.stopAnimation.setOnClickListener(this::onStopAnimation)
        binding.animate.setOnClickListener(this::onToggleAnimate)
        binding.scrollLeft.setOnClickListener(this::onScrollLeft)
        binding.scrollUp.setOnClickListener(this::onScrollUp)
        binding.scrollDown.setOnClickListener(this::onScrollDown)
        binding.scrollRight.setOnClickListener(this::onScrollRight)
        binding.zoomIn.setOnClickListener(this::onZoomIn)
        binding.zoomOut.setOnClickListener(this::onZoomOut)
        binding.tiltMore.setOnClickListener(this::onTiltMore)
        binding.tiltLess.setOnClickListener(this::onTiltLess)
        binding.durationToggle.setOnClickListener(this::onToggleCustomDuration)
    }

    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))
            addMarker(MarkerOptions().position(sydneyLatLng).title("Sydney"))
            addMarker(MarkerOptions().position(LatLng(-33.891614, 151.276417)).title("Bondi Beach"))
        }
    }

    /**
     * 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)
    }
}

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 com.example.common_ui.catalog.Sample;
import com.example.common_ui.catalog.Complexity;
import com.example.common_ui.catalog.Framework;

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.MarkerOptions;
import com.example.common_ui.databinding.CameraDemoBinding;
import com.google.android.gms.maps.model.PolylineOptions;

/**
 * This shows how to change the camera position for the map.
 */
@Sample(
    id = "camera_demo",
    title = "Camera Controls & Animation",
    description = "Programmatic camera panning, zooming, tilt, bearing, and smooth animations.",
    category = "Camera Controls",
    complexity = Complexity.SIMPLE,
    tags = {"#camera", "#animation", "#bearing", "#tilt", "#zoom", "#pan"},
    apiCalls = {
        "GoogleMap.animateCamera(CameraUpdate)",
        "GoogleMap.moveCamera(CameraUpdate)",
        "GoogleMap.addMarker(MarkerOptions)",
        "CameraUpdateFactory.newCameraPosition(CameraPosition)"
    },
    purpose = "Demonstrates programmatic camera movements, animated transitions, tilt angles, and bearing rotations.",
    successCriteria = "Buttons animate camera smoothly with custom durations, stops, and rotation angles.",
    failureIndicators = "Jerky animations, unexpected camera jumps, or tilt angle exceeding platform constraints.",
    framework = Framework.JAVA_VIEWS
)
public class CameraDemoActivity extends SamplesBaseActivity 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;
    private CameraDemoBinding binding;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        binding = CameraDemoBinding.inflate(getLayoutInflater());
        setContentView(binding.getRoot());
        animateToggle = binding.animate;
        customDurationToggle = binding.durationToggle;
        customDurationBar = binding.durationBar;

        updateEnabledState();

        SupportMapFragment mapFragment =
                (SupportMapFragment) getSupportFragmentManager().findFragmentById(com.example.common_ui.R.id.map);
        mapFragment.getMapAsync(this);
        applyInsets(binding.mapContainer);

        binding.bondi.setOnClickListener(this::onGoToBondi);
        binding.sydney.setOnClickListener(this::onGoToSydney);
        binding.stopAnimation.setOnClickListener(this::onStopAnimation);
        binding.animate.setOnClickListener(this::onToggleAnimate);
        binding.scrollLeft.setOnClickListener(this::onScrollLeft);
        binding.scrollUp.setOnClickListener(this::onScrollUp);
        binding.scrollDown.setOnClickListener(this::onScrollDown);
        binding.scrollRight.setOnClickListener(this::onScrollRight);
        binding.zoomIn.setOnClickListener(this::onZoomIn);
        binding.zoomOut.setOnClickListener(this::onZoomOut);
        binding.tiltMore.setOnClickListener(this::onTiltMore);
        binding.tiltLess.setOnClickListener(this::onTiltLess);
        binding.durationToggle.setOnClickListener(this::onToggleCustomDuration);
    }

    @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
        LatLng sydneyLatLng = new LatLng(-33.87365, 151.20689);
        LatLng bondiLatLng = new LatLng(-33.891614, 151.276417);
        map.moveCamera(CameraUpdateFactory.newLatLngZoom(sydneyLatLng, 10));
        map.addMarker(new MarkerOptions().position(sydneyLatLng).title("Sydney"));
        map.addMarker(new MarkerOptions().position(bondiLatLng).title("Bondi Beach"));
    }

    public GoogleMap getMap() {
        return map;
    }


    /**
     * 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, com.example.common_ui.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);
    }
}

אלה מאזיני המצלמה שזמינים:

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

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

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

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

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

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

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

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

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

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

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

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

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

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

אפשר לראות את הרמה הפעילה הנוכחית על ידי הפעלת הפקודה IndoorBuilding.getActiveLevelIndex().

Kotlin

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

Java

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

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

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

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

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

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

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

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

אירועים שקשורים למיקום

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

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

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