กิจกรรม

เลือกแพลตฟอร์ม: Android iOS JavaScript

เมื่อใช้ Maps SDK สําหรับ Android คุณจะสามารถฟังเหตุการณ์บนแผนที่ได้

ตัวอย่างโค้ด

ที่เก็บ ApiDemos ใน GitHub จะมีตัวอย่างที่แสดงถึงเหตุการณ์และผู้ฟัง ดังนี้

Java

  • EventsDemoActivity: จับคู่เหตุการณ์การคลิกและกิจกรรมจากกล้อง
  • CameraDemoActivity: เหตุการณ์การเปลี่ยนแปลงของกล้อง
  • CircleDemoActivity: เหตุการณ์การคลิกและลากของตัวทําเครื่องหมาย
  • GroundOverlayDemoActivity: เหตุการณ์การคลิกบนพื้น
  • IndoorDemoActivity: กิจกรรมในอาคารในอาคาร
  • MarkerDemoActivity: เหตุการณ์ตัวทําเครื่องหมายและหน้าต่างข้อมูล
  • PolygonDemoActivity: สร้างรูปหลายเหลี่ยม

โคตลิน

  • EventsDemoActivity: จับคู่เหตุการณ์การคลิกและกิจกรรมจากกล้อง
  • CameraDemoActivity: เหตุการณ์การเปลี่ยนแปลงของกล้อง
  • CircleDemoActivity: เหตุการณ์การคลิกและลากของตัวทําเครื่องหมาย
  • GroundOverlayDemoActivity: เหตุการณ์การคลิกบนพื้น
  • IndoorDemoActivity: กิจกรรมในอาคารในอาคาร
  • MarkerDemoActivity: เหตุการณ์ตัวทําเครื่องหมายและหน้าต่างข้อมูล
  • PolygonDemoActivity: สร้างรูปหลายเหลี่ยม

กิจกรรมการคลิก / คลิกในแผนที่นาน

หากต้องการตอบกลับผู้ใช้ที่แตะจุดบนแผนที่ คุณสามารถใช้ OnMapClickListener ซึ่งคุณสามารถตั้งค่าบนแผนที่โดยเรียกใช้ GoogleMap.setOnMapClickListener(OnMapClickListener) เมื่อผู้ใช้คลิก (แตะ) ที่ใดที่หนึ่งบนแผนที่ คุณจะได้รับเหตุการณ์ onMapClick(LatLng) ซึ่งระบุสถานที่บนแผนที่ที่ผู้ใช้คลิก โปรดทราบว่าหากคุณต้องการตําแหน่งที่เกี่ยวข้องบนหน้าจอ (เป็นพิกเซล) คุณสามารถรับ Projection จากแผนที่ซึ่งช่วยให้คุณแปลงพิกัดละติจูด/ลองจิจูดและพิกัดพิกเซลบนหน้าจอได้

นอกจากนี้ ยังฟังเหตุการณ์ที่มีการคลิกนานด้วย OnMapLongClickListener ซึ่งคุณตั้งค่าในแผนที่ได้โดยการโทรหา GoogleMap.setOnMapLongClickListener(OnMapLongClickListener) Listener นี้มีลักษณะการทํางานคล้ายกับ Listener การคลิก และจะได้รับการแจ้งเตือนบนเหตุการณ์คลิกแบบยาวที่มีโค้ดเรียกกลับ onMapLongClick(LatLng)

การปิดใช้กิจกรรมการคลิกในโหมด Lite

หากต้องการปิดกิจกรรมการคลิกบนแผนที่ในโหมด Lite ให้เรียกใช้ setClickable() ในมุมมองที่มี MapView หรือ MapFragment ซึ่งมีประโยชน์ เช่น เมื่อแสดงแผนที่หรือแผนที่ในมุมมองรายการ ที่คุณต้องการให้เหตุการณ์การคลิกเรียกการทํางานที่ไม่เกี่ยวข้องกับแผนที่

ตัวเลือกในการปิดใช้กิจกรรมการคลิกจะอยู่ในโหมด Lite เท่านั้น และการปิดใช้กิจกรรมการคลิกจะทําให้เครื่องหมายเป็นแบบคลิกไม่ได้เช่นกัน ซึ่งจะไม่ส่งผลต่อการควบคุมอื่นๆ บนแผนที่

สําหรับ 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 ในตัว หรือการเคลื่อนไหวที่ควบคุมโดยนักพัฒนาซอฟต์แวร์

ตัวอย่างต่อไปนี้จะแสดง 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

Listener กล้องพร้อมใช้งาน:

  • ระบบจะเรียกโค้ด onCameraMoveStarted() ของ OnCameraMoveStartedListener เมื่อกล้องเริ่มเคลื่อนไหว วิธีเรียกกลับจะได้รับ reason สําหรับการเคลื่อนไหวของกล้อง สาเหตุอาจเกิดจากข้อใดข้อหนึ่งต่อไปนี้

    • REASON_GESTURE บ่งบอกว่ามีการย้ายกล้องตามท่าทางสัมผัสของผู้ใช้บนแผนที่ เช่น การเลื่อน การเอียง การบีบเพื่อซูม หรือการหมุนแผนที่
    • REASON_API_ANIMATION บ่งชี้ว่า API ได้ย้ายกล้องเพื่อเป็นการตอบสนองต่อการดําเนินการของผู้ใช้ที่ไม่ใช่ท่าทางสัมผัส เช่น การแตะปุ่มซูม การแตะปุ่มตําแหน่งของฉัน หรือคลิกเครื่องหมาย
    • REASON_DEVELOPER_ANIMATION บ่งชี้ว่าแอปของคุณเริ่ม การเคลื่อนไหวของกล้อง

  • มีการเรียกใช้โค้ด onCameraMove() ของ OnCameraMoveListener หลายครั้งขณะที่กล้องกําลังเคลื่อนที่หรือเมื่อผู้ใช้กําลังโต้ตอบกับหน้าจอสัมผัส เพื่อเป็นแนวทางว่าการเรียกการเรียกกลับเกิดขึ้นบ่อยเพียงใด คุณควรทราบว่า API เรียกการเรียกกลับหนึ่งครั้งต่อเฟรม อย่างไรก็ตาม โปรดทราบว่าการเรียกกลับนี้จะถูกเรียกใช้แบบไม่พร้อมกัน จึงทําให้ไม่สอดคล้องกับข้อมูลที่มองเห็นได้บนหน้าจอ นอกจากนี้ ยังเป็นไปได้ว่าตําแหน่งของกล้อง ไม่เปลี่ยนแปลงระหว่างฟังก์ชัน onCameraMove() โค้ดเรียกกลับและโค้ดถัดไป

  • ระบบจะเรียกโค้ด OnCameraIdle() ของ OnCameraIdleListener กลับมา เมื่อกล้องหยุดเคลื่อนที่และผู้ใช้ได้หยุดการโต้ตอบกับแผนที่

  • ระบบจะเรียกใช้โค้ดเรียกกลับ OnCameraMoveCanceled() ของ OnCameraMoveCanceledListener เมื่อการเคลื่อนไหวของกล้องปัจจุบันหยุดชะงัก ทันทีที่โค้ดเรียกกลับ OnCameraMoveCanceled() โค้ดเรียกกลับ onCameraMoveStarted() ถูกเรียกใช้ด้วย reason ใหม่

    หากแอปเรียกใช้ GoogleMap.stopAnimation() อย่างชัดเจน ระบบจะเรียกใช้การเรียก OnCameraMoveCanceled() คืน แต่การเรียก onCameraMoveStarted() จะไม่ทํางาน

ในการตั้งค่า Listener บนแผนที่ ให้เรียกเมธอด Listener ที่เกี่ยวข้อง ตัวอย่างเช่น หากต้องการขอให้ติดต่อกลับจาก OnCameraMoveStartedListener ให้เรียกใช้ GoogleMap.setOnCameraMoveStartedListener()

คุณสามารถดูเป้าหมายของกล้อง (ละติจูด/ลองจิจูด) การซูม ทิศทาง และเอียงจาก CameraPosition ได้ โปรดดูรายละเอียดเกี่ยวกับคุณสมบัติเหล่านี้ในตําแหน่งกล้อง

กิจกรรมในธุรกิจและจุดสนใจอื่นๆ

โดยค่าเริ่มต้น จุดสนใจ (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 ที่มีเครื่องหมายอยู่ ดูคู่มือทําเครื่องหมายเหตุการณ์

นอกจากนี้ คุณยังฟังเหตุการณ์ในหน้าต่างข้อมูลได้ด้วย

เหตุการณ์รูปร่างและโฆษณาซ้อนทับ

คุณฟังและตอบสนองต่อกิจกรรมการคลิกในรูปหลายเหลี่ยม รูปหลายเหลี่ยม วงกลม และพื้นดินได้

เหตุการณ์เกี่ยวกับตําแหน่ง

แอปพลิเคชันของคุณสามารถตอบสนองต่อเหตุการณ์ต่อไปนี้ที่เกี่ยวข้องกับเลเยอร์ตําแหน่งของฉัน

  • หากผู้ใช้คลิกปุ่มตําแหน่งของฉัน แอปของคุณจะได้รับการเรียกกลับ onMyLocationButtonClick() จาก GoogleMap.OnMyLocationButtonClickListener
  • หากผู้ใช้คลิกจุดสีน้ําเงินที่ตําแหน่งของฉัน แอปจะได้รับการเรียก onMyLocationClick() คืนจาก GoogleMap.OnMyLocationClickListener

สําหรับรายละเอียด โปรดดูคําแนะนําเกี่ยวกับเลเยอร์ตําแหน่งของฉัน