Etkinlikler

Platform seçin: Android iOS JavaScript

Android için Haritalar SDK'sını kullanarak haritadaki etkinlikleri dinleyebilirsiniz.

Kod örnekleri

GitHub'daki ApiDemos deposunda, etkinlikleri ve dinleyicileri gösteren örnekler bulunur:

Kotlin

• EventsDemoActivity: Harita tıklama ve kamera değiştirme etkinlikleri
• CameraDemoActivity: Kamera değişikliği etkinlikleri
• CircleDemoActivity: İşaretçi tıklama ve sürükleme etkinlikleri
• GroundOverlayDemoActivity: Zemin yer paylaşımı tıklama etkinlikleri
• IndoorDemoActivity: İç mekan haritası etkinlikleri
• MarkerDemoActivity: İşaretçi ve bilgi penceresi etkinlikleri
• PolygonDemoActivity: Poligon etkinlikleri

Java

• EventsDemoActivity: Harita tıklama ve kamera değiştirme etkinlikleri
• CameraDemoActivity: Kamera değişikliği etkinlikleri
• CircleDemoActivity: İşaretçi tıklama ve sürükleme etkinlikleri
• GroundOverlayDemoActivity: Zemin yer paylaşımı tıklama etkinlikleri
• IndoorDemoActivity: İç mekan haritası etkinlikleri
• MarkerDemoActivity: İşaretçi ve bilgi penceresi etkinlikleri
• PolygonDemoActivity: Poligon etkinlikleri

Harita tıklama / uzun tıklama etkinlikleri

Kullanıcının haritada bir noktaya dokunmasına yanıt vermek istiyorsanız GoogleMap.setOnMapClickListener(OnMapClickListener) işlevini çağırarak haritada ayarlayabileceğiniz bir OnMapClickListener kullanabilirsiniz. Kullanıcı haritada bir yeri tıkladığında (dokunduğunda) kullanıcının haritada tıkladığı konumu belirten bir onMapClick(LatLng) etkinliği alırsınız. Ekrandaki (piksellerle) ilgili konuma ihtiyacınız varsa enlem/boylam koordinatları ile ekran piksel koordinatları arasında dönüşüm yapmanıza olanak tanıyan bir Projection edinebileceğinizi unutmayın.

Ayrıca, GoogleMap.setOnMapLongClickListener(OnMapLongClickListener) işlevini çağırarak haritada ayarlayabileceğiniz bir OnMapLongClickListener ile uzun tıklama etkinliklerini de dinleyebilirsiniz. Bu işleyici, tıklama işleyicisine benzer şekilde çalışır ve onMapLongClick(LatLng) geri çağırma işleviyle uzun tıklama etkinlikleri hakkında bilgilendirilir.

Basit modda tıklama etkinliklerini devre dışı bırakma

Lite modda bir haritada tıklama etkinliklerini devre dışı bırakmak için setClickable() öğesini MapView veya MapFragment içeren görünümde çağırın. Örneğin, bir liste görünümünde harita veya haritalar gösterirken tıklama etkinliğinin haritayla ilgili olmayan bir işlemi çağırmasını istediğinizde bu özellik kullanışlıdır.

Tıklama etkinliklerini devre dışı bırakma seçeneği yalnızca lite modunda kullanılabilir. Tıklama etkinliklerinin devre dışı bırakılması, işaretçilerin de tıklanamamasına neden olur. Bu işlem, haritadaki diğer kontrolleri etkilemez.

MapView için:

Kotlin

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

      

Java

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

      

MapFragment için:

Kotlin

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

      

Java

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

      

Kamera değişikliği etkinlikleri

Harita görünümü, düz bir düzleme yukarıdan bakan bir kamera olarak modellenir. Haritanın yakınlaştırma düzeyini, görünüm alanını ve perspektifini etkilemek için kameranın özelliklerini değiştirebilirsiniz. Kamera kılavuzuna bakın. Kullanıcılar el hareketleri yaparak da kamerayı etkileyebilir.

Kamera değişikliği dinleyicilerini kullanarak kamera hareketlerini takip edebilirsiniz. Uygulamanız, kamera hareketinin başlangıcı, devam etmesi ve bitişiyle ilgili bildirimler alabilir. Kameranın hareket etmesinin nedenini de görebilirsiniz. Bu hareketler kullanıcı hareketlerinden, yerleşik API animasyonlarından veya geliştirici tarafından kontrol edilen hareketlerden kaynaklanabilir.

Aşağıdaki örnekte, kullanılabilen tüm kamera etkinlik işleyicileri gösterilmektedir:

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 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.PolylineOptions

/**
 * This shows how to change the camera position for the map.
 */
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

    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)
        applyInsets(findViewById<View?>(R.id.map_container))
    }

    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

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 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;

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

        updateEnabledState();

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

    @Override
    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, 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);
    }
}
CameraDemoActivity.java

Aşağıdaki kamera dinleyicileri kullanılabilir:

• Kamera hareket etmeye başladığında onCameraMoveStarted() OnCameraMoveStartedListener geri çağırma işlemi başlatılır. Geri çağırma yöntemi, kamera hareketi için reason alır. Bunun nedeni aşağıdakilerden biri olabilir:

  • REASON_GESTURE, kameranın, kullanıcının harita üzerinde yaptığı bir harekete (ör. kaydırma, eğme, yakınlaştırmak için parmakla sıkıştırma veya haritayı döndürme) yanıt olarak hareket ettiğini gösterir.
  • REASON_API_ANIMATION, API'nin, yakınlaştırma düğmesine dokunma, Konumum düğmesine dokunma veya bir işaretçiyi tıklama gibi hareket içermeyen bir kullanıcı işlemine yanıt olarak kamerayı hareket ettirdiğini gösterir.
  • REASON_DEVELOPER_ANIMATION, uygulamanızın kamera hareketini başlattığını gösterir.

• Kamera hareket ederken veya kullanıcı dokunmatik ekranla etkileşimde bulunurken OnCameraMoveListener öğesinin onCameraMove() geri çağırma işlemi birden çok kez çağrılıyor. Geri çağırmanın ne sıklıkta çağrıldığına dair bir kılavuz olarak, API'nin geri çağırmayı kare başına bir kez çağırdığını bilmek faydalıdır. Ancak bu geri çağırmanın eşzamansız olarak çağrıldığını ve bu nedenle ekranda görünenlerle senkronize olmadığını unutmayın. Kamera konumunun bir onCameraMove() geri arama ile bir sonraki geri arama arasında değişmeden kalabileceğini de unutmayın.

• Kamera hareket etmeyi bıraktığında ve kullanıcı haritayla etkileşimi durdurduğunda OnCameraIdle() OnCameraIdleListener geri çağırma işlemi çağrılır.

• Mevcut kamera hareketi kesintiye uğradığında OnCameraMoveCanceledListener öğesinin OnCameraMoveCanceled() geri çağırması çağrılır. OnCameraMoveCanceled() geri çağırmasından hemen sonra, onCameraMoveStarted() geri çağırması yeni reason ile çağrılır.

  Uygulamanız açıkça GoogleMap.stopAnimation() işlevini çağırıyorsa OnCameraMoveCanceled() geri çağırma işlevi çağrılır ancak onCameraMoveStarted() geri çağırma işlevi çağrılmaz.

Haritada bir işleyici ayarlamak için ilgili set-listener yöntemini çağırın. Örneğin, OnCameraMoveStartedListener ekibinin sizi araması için GoogleMap.setOnCameraMoveStartedListener() numaralı telefonu arayın.

Kameranın hedefini (enlem/boylam), yakınlaştırmasını, yönünü ve eğimini CameraPosition üzerinden alabilirsiniz. Bu özelliklerle ilgili ayrıntılar için kamera konumu kılavuzuna bakın.

Kullanımdan kaldırma bildirimi: Yukarıda açıklanan dinleyiciler (OnCameraMoveStartedListener, OnCameraMoveListener, OnCameraMoveCanceledListener ve OnCameraIdleListener) lehine OnCameraChangeListener kullanımdan kaldırıldı.

İşletmeler ve diğer önemli yerlerle ilgili etkinlikler

Varsayılan olarak ilgi alanları (İA), temel haritada ilgili simgeleriyle birlikte görünür. ÖY'ler arasında parklar, okullar, devlet binaları ve daha fazlasının yanı sıra mağazalar, restoranlar ve oteller gibi işletme ÖY'leri yer alır.

Bir ÖY'deki tıklama etkinliklerine yanıt verebilirsiniz. İşletmeler ve diğer ilgi çekici yerler hakkındaki rehbere göz atın.

İç mekan haritası etkinlikleri

Etkin bir iç mekan haritasının seviyesini bulmak ve özelleştirmek için etkinlikleri kullanabilirsiniz. Bir binaya odaklanıldığında veya bir binada yeni bir seviye etkinleştirildiğinde çağrılacak bir dinleyici ayarlamak için OnIndoorStateChangeListener arayüzünü kullanın.

GoogleMap.getFocusedBuilding() işlevini çağırarak şu anda odaklanılan binayı alın. Haritayı belirli bir enlem/boylam üzerinde ortalamak genellikle o enlem/boylamdaki binayı gösterir ancak bu garanti edilmez.

Ardından IndoorBuilding.getActiveLevelIndex() numarasını arayarak şu anda etkin olan seviyeyi öğrenebilirsiniz.

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

      

Bu, etkin seviye için özel işaretleme göstermek istediğinizde (ör. işaretçiler, yer paylaşımları, döşeme paylaşımları, poligonlar, çoklu çizgiler ve diğer şekiller) kullanışlıdır.

İpucu: Cadde düzeyine geri dönmek için IndoorBuilding.getDefaultLevelIndex() ile varsayılan düzeyi alın ve IndoorBuilding.getDefaultLevelIndex() ile etkin düzey olarak ayarlayın.IndoorLevel.activate()

İşaretçi ve bilgi penceresi etkinlikleri

İşaretçinin ait olduğu GoogleMap nesnesinde ilgili işleyiciyi ayarlayarak işaretçi tıklama ve sürükleme etkinlikleri de dahil olmak üzere işaretçi etkinliklerini dinleyebilir ve bunlara yanıt verebilirsiniz. İşaretleyici etkinlikler kılavuzuna bakın.

Ayrıca bilgi pencerelerindeki etkinlikleri de dinleyebilirsiniz.

Etkinlikleri şekillendirme ve yerleştirme

Çoklu çizgiler, poligonlar, daireler ve yer paylaşımlarındaki tıklama etkinliklerini dinleyip yanıtlayabilirsiniz.

Not: Birden fazla yer paylaşımı veya şekil (işaretçiler, çoklu çizgiler, poligonlar, daireler ve/veya yer paylaşımı) üst üste yerleştirilmişse tıklama etkinliği önce işaretçi kümesinde döngüye alınır, ardından z-endeksi değerlerine göre diğer tıklanabilir yer paylaşımları veya şekiller için tetiklenir. Tıklama başına en fazla bir etkinlik tetiklenir. Başka bir deyişle, tıklama daha düşük z-endeksi değerlerine sahip yer paylaşımlarına veya şekillere aktarılmaz. İşaretçi z-indeksi ve tıklama etkinlikleri hakkında daha fazla bilgi edinin.

Konum etkinlikleri

Uygulamanız, Konum Katmanım ile ilgili aşağıdaki etkinliklere yanıt verebilir:

• Kullanıcı Konumum düğmesini tıklarsa uygulamanız GoogleMap.OnMyLocationButtonClickListener'dan bir onMyLocationButtonClick() geri çağırma alır.
• Kullanıcı Mavi Nokta'yı tıklarsa uygulamanız GoogleMap.OnMyLocationClickListener'dan bir onMyLocationClick() geri çağırma alır.

Ayrıntılar için Konumum katmanı ile ilgili kılavuza bakın.