Geçerli Yeri Seçin ve Haritadaki Ayrıntıları Göster

Android cihazın mevcut konumunu nasıl bulacağınızı öğrenin ve yerle ilgili (işletme veya önemli başka bir nokta) bulunan ayrıntıları otomatik olarak oluşturulur. Android için Haritalar SDK'sı Android için Yerler SDK'sı ve çok kaynaklı Google Play Hizmetleri konum API'lerindeki konum sağlayıcı

Not: Bu eğitim için Google Play Hizmetleri gereklidir 11.2.0 veya daha yeni bir sürüme sahip olmanız gerekir.

Kodu alın

Bu dosyayı klonlayın veya Google Maps Android API v2 Samples deposu'na gidin.

Etkinliğin Java sürümünü görüntüleyin:

Kodu Göster / Gizle

    // 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.currentplacedetailsonmap;

import android.content.DialogInterface;
import android.content.pm.PackageManager;
import android.location.Location;
import android.os.Bundle;

import android.util.Log;
import android.view.Menu;
import android.view.MenuItem;
import android.view.View;
import android.widget.FrameLayout;
import android.widget.TextView;

import androidx.annotation.NonNull;
import androidx.appcompat.app.AlertDialog;
import androidx.appcompat.app.AppCompatActivity;
import androidx.core.app.ActivityCompat;
import androidx.core.content.ContextCompat;

import com.google.android.gms.location.FusedLocationProviderClient;
import com.google.android.gms.location.LocationServices;
import com.google.android.gms.maps.CameraUpdateFactory;
import com.google.android.gms.maps.GoogleMap;
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.Marker;
import com.google.android.gms.maps.model.MarkerOptions;
import com.google.android.gms.tasks.OnCompleteListener;
import com.google.android.gms.tasks.Task;

import com.google.android.libraries.places.api.Places;
import com.google.android.libraries.places.api.model.Place;
import com.google.android.libraries.places.api.model.PlaceLikelihood;
import com.google.android.libraries.places.api.net.FindCurrentPlaceRequest;
import com.google.android.libraries.places.api.net.FindCurrentPlaceResponse;
import com.google.android.libraries.places.api.net.PlacesClient;

import java.util.Arrays;
import java.util.List;

/**
 * An activity that displays a map showing the place at the device's current location.
 */
public class MapsActivityCurrentPlace extends AppCompatActivity
        implements OnMapReadyCallback {

    private static final String TAG = MapsActivityCurrentPlace.class.getSimpleName();
    private GoogleMap map;
    private CameraPosition cameraPosition;

    // The entry point to the Places API.
    private PlacesClient placesClient;

    // The entry point to the Fused Location Provider.
    private FusedLocationProviderClient fusedLocationProviderClient;

    // A default location (Sydney, Australia) and default zoom to use when location permission is
    // not granted.
    private final LatLng defaultLocation = new LatLng(-33.8523341, 151.2106085);
    private static final int DEFAULT_ZOOM = 15;
    private static final int PERMISSIONS_REQUEST_ACCESS_FINE_LOCATION = 1;
    private boolean locationPermissionGranted;

    // The geographical location where the device is currently located. That is, the last-known
    // location retrieved by the Fused Location Provider.
    private Location lastKnownLocation;

    // Keys for storing activity state.
    private static final String KEY_CAMERA_POSITION = "camera_position";
    private static final String KEY_LOCATION = "location";

    // Used for selecting the current place.
    private static final int M_MAX_ENTRIES = 5;
    private String[] likelyPlaceNames;
    private String[] likelyPlaceAddresses;
    private List[] likelyPlaceAttributions;
    private LatLng[] likelyPlaceLatLngs;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        // Retrieve location and camera position from saved instance state.
        if (savedInstanceState != null) {
            lastKnownLocation = savedInstanceState.getParcelable(KEY_LOCATION);
            cameraPosition = savedInstanceState.getParcelable(KEY_CAMERA_POSITION);
        }

        // Retrieve the content view that renders the map.
        setContentView(R.layout.activity_maps);

        // Construct a PlacesClient
        Places.initialize(getApplicationContext(), BuildConfig.PLACES_API_KEY);
        placesClient = Places.createClient(this);

        // Construct a FusedLocationProviderClient.
        fusedLocationProviderClient = LocationServices.getFusedLocationProviderClient(this);

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

    /**
     * Saves the state of the map when the activity is paused.
     */
    @Override
    protected void onSaveInstanceState(Bundle outState) {
        if (map != null) {
            outState.putParcelable(KEY_CAMERA_POSITION, map.getCameraPosition());
            outState.putParcelable(KEY_LOCATION, lastKnownLocation);
        }
        super.onSaveInstanceState(outState);
    }

    /**
     * Sets up the options menu.
     * @param menu The options menu.
     * @return Boolean.
     */
    @Override
    public boolean onCreateOptionsMenu(Menu menu) {
        getMenuInflater().inflate(R.menu.current_place_menu, menu);
        return true;
    }

    /**
     * Handles a click on the menu option to get a place.
     * @param item The menu item to handle.
     * @return Boolean.
     */
    @Override
    public boolean onOptionsItemSelected(MenuItem item) {
        if (item.getItemId() == R.id.option_get_place) {
            showCurrentPlace();
        }
        return true;
    }

    /**
     * Manipulates the map when it's available.
     * This callback is triggered when the map is ready to be used.
     */
    @Override
    public void onMapReady(GoogleMap map) {
        this.map = map;

        // Use a custom info window adapter to handle multiple lines of text in the
        // info window contents.
        this.map.setInfoWindowAdapter(new GoogleMap.InfoWindowAdapter() {

            @Override
            // Return null here, so that getInfoContents() is called next.
            public View getInfoWindow(Marker arg0) {
                return null;
            }

            @Override
            public View getInfoContents(Marker marker) {
                // Inflate the layouts for the info window, title and snippet.
                View infoWindow = getLayoutInflater().inflate(R.layout.custom_info_contents,
                        (FrameLayout) findViewById(R.id.map), false);

                TextView title = infoWindow.findViewById(R.id.title);
                title.setText(marker.getTitle());

                TextView snippet = infoWindow.findViewById(R.id.snippet);
                snippet.setText(marker.getSnippet());

                return infoWindow;
            }
        });

        // Prompt the user for permission.
        getLocationPermission();

        // Turn on the My Location layer and the related control on the map.
        updateLocationUI();

        // Get the current location of the device and set the position of the map.
        getDeviceLocation();
    }

    /**
     * Gets the current location of the device, and positions the map's camera.
     */
    private void getDeviceLocation() {
        /*
         * Get the best and most recent location of the device, which may be null in rare
         * cases when a location is not available.
         */
        try {
            if (locationPermissionGranted) {
                Task<Location> locationResult = fusedLocationProviderClient.getLastLocation();
                locationResult.addOnCompleteListener(this, new OnCompleteListener<Location>() {
                    @Override
                    public void onComplete(@NonNull Task<Location> task) {
                        if (task.isSuccessful()) {
                            // Set the map's camera position to the current location of the device.
                            lastKnownLocation = task.getResult();
                            if (lastKnownLocation != null) {
                                map.moveCamera(CameraUpdateFactory.newLatLngZoom(
                                        new LatLng(lastKnownLocation.getLatitude(),
                                                lastKnownLocation.getLongitude()), DEFAULT_ZOOM));
                            }
                        } else {
                            Log.d(TAG, "Current location is null. Using defaults.");
                            Log.e(TAG, "Exception: %s", task.getException());
                            map.moveCamera(CameraUpdateFactory
                                    .newLatLngZoom(defaultLocation, DEFAULT_ZOOM));
                            map.getUiSettings().setMyLocationButtonEnabled(false);
                        }
                    }
                });
            }
        } catch (SecurityException e)  {
            Log.e("Exception: %s", e.getMessage(), e);
        }
    }

    /**
     * Prompts the user for permission to use the device location.
     */
    private void getLocationPermission() {
        /*
         * Request location permission, so that we can get the location of the
         * device. The result of the permission request is handled by a callback,
         * onRequestPermissionsResult.
         */
        if (ContextCompat.checkSelfPermission(this.getApplicationContext(),
                android.Manifest.permission.ACCESS_FINE_LOCATION)
                == PackageManager.PERMISSION_GRANTED) {
            locationPermissionGranted = true;
        } else {
            ActivityCompat.requestPermissions(this,
                    new String[]{android.Manifest.permission.ACCESS_FINE_LOCATION},
                    PERMISSIONS_REQUEST_ACCESS_FINE_LOCATION);
        }
    }

    /**
     * Handles the result of the request for location permissions.
     */
    @Override
    public void onRequestPermissionsResult(int requestCode,
                                           @NonNull String[] permissions,
                                           @NonNull int[] grantResults) {
        locationPermissionGranted = false;
        if (requestCode
            == PERMISSIONS_REQUEST_ACCESS_FINE_LOCATION) {// If request is cancelled, the result arrays are empty.
            if (grantResults.length > 0
                && grantResults[0] == PackageManager.PERMISSION_GRANTED) {
                locationPermissionGranted = true;
            }
        } else {
            super.onRequestPermissionsResult(requestCode, permissions, grantResults);
        }
        updateLocationUI();
    }

    /**
     * Prompts the user to select the current place from a list of likely places, and shows the
     * current place on the map - provided the user has granted location permission.
     */
    private void showCurrentPlace() {
        if (map == null) {
            return;
        }

        if (locationPermissionGranted) {
            // Use fields to define the data types to return.
            List<Place.Field> placeFields = Arrays.asList(Place.Field.NAME, Place.Field.ADDRESS,
                    Place.Field.LAT_LNG);

            // Use the builder to create a FindCurrentPlaceRequest.
            FindCurrentPlaceRequest request =
                    FindCurrentPlaceRequest.newInstance(placeFields);

            // Get the likely places - that is, the businesses and other points of interest that
            // are the best match for the device's current location.
            @SuppressWarnings("MissingPermission") final
            Task<FindCurrentPlaceResponse> placeResult =
                    placesClient.findCurrentPlace(request);
            placeResult.addOnCompleteListener (new OnCompleteListener<FindCurrentPlaceResponse>() {
                @Override
                public void onComplete(@NonNull Task<FindCurrentPlaceResponse> task) {
                    if (task.isSuccessful() && task.getResult() != null) {
                        FindCurrentPlaceResponse likelyPlaces = task.getResult();

                        // Set the count, handling cases where less than 5 entries are returned.
                        int count;
                        if (likelyPlaces.getPlaceLikelihoods().size() < M_MAX_ENTRIES) {
                            count = likelyPlaces.getPlaceLikelihoods().size();
                        } else {
                            count = M_MAX_ENTRIES;
                        }

                        int i = 0;
                        likelyPlaceNames = new String[count];
                        likelyPlaceAddresses = new String[count];
                        likelyPlaceAttributions = new List[count];
                        likelyPlaceLatLngs = new LatLng[count];

                        for (PlaceLikelihood placeLikelihood : likelyPlaces.getPlaceLikelihoods()) {
                            // Build a list of likely places to show the user.
                            likelyPlaceNames[i] = placeLikelihood.getPlace().getName();
                            likelyPlaceAddresses[i] = placeLikelihood.getPlace().getAddress();
                            likelyPlaceAttributions[i] = placeLikelihood.getPlace()
                                    .getAttributions();
                            likelyPlaceLatLngs[i] = placeLikelihood.getPlace().getLatLng();

                            i++;
                            if (i > (count - 1)) {
                                break;
                            }
                        }

                        // Show a dialog offering the user the list of likely places, and add a
                        // marker at the selected place.
                        MapsActivityCurrentPlace.this.openPlacesDialog();
                    }
                    else {
                        Log.e(TAG, "Exception: %s", task.getException());
                    }
                }
            });
        } else {
            // The user has not granted permission.
            Log.i(TAG, "The user did not grant location permission.");

            // Add a default marker, because the user hasn't selected a place.
            map.addMarker(new MarkerOptions()
                    .title(getString(R.string.default_info_title))
                    .position(defaultLocation)
                    .snippet(getString(R.string.default_info_snippet)));

            // Prompt the user for permission.
            getLocationPermission();
        }
    }

    /**
     * Displays a form allowing the user to select a place from a list of likely places.
     */
    private void openPlacesDialog() {
        // Ask the user to choose the place where they are now.
        DialogInterface.OnClickListener listener = new DialogInterface.OnClickListener() {
            @Override
            public void onClick(DialogInterface dialog, int which) {
                // The "which" argument contains the position of the selected item.
                LatLng markerLatLng = likelyPlaceLatLngs[which];
                String markerSnippet = likelyPlaceAddresses[which];
                if (likelyPlaceAttributions[which] != null) {
                    markerSnippet = markerSnippet + "\n" + likelyPlaceAttributions[which];
                }

                // Add a marker for the selected place, with an info window
                // showing information about that place.
                map.addMarker(new MarkerOptions()
                        .title(likelyPlaceNames[which])
                        .position(markerLatLng)
                        .snippet(markerSnippet));

                // Position the map's camera at the location of the marker.
                map.moveCamera(CameraUpdateFactory.newLatLngZoom(markerLatLng,
                        DEFAULT_ZOOM));
            }
        };

        // Display the dialog.
        AlertDialog dialog = new AlertDialog.Builder(this)
                .setTitle(R.string.pick_place)
                .setItems(likelyPlaceNames, listener)
                .show();
    }

    /**
     * Updates the map's UI settings based on whether the user has granted location permission.
     */
    private void updateLocationUI() {
        if (map == null) {
            return;
        }
        try {
            if (locationPermissionGranted) {
                map.setMyLocationEnabled(true);
                map.getUiSettings().setMyLocationButtonEnabled(true);
            } else {
                map.setMyLocationEnabled(false);
                map.getUiSettings().setMyLocationButtonEnabled(false);
                lastKnownLocation = null;
                getLocationPermission();
            }
        } catch (SecurityException e)  {
            Log.e("Exception: %s", e.getMessage());
        }
    }
}

    

Etkinliğin Kotlin sürümünü görüntüleyin:

Kodu Göster / Gizle

    // 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.currentplacedetailsonmap

import android.Manifest
import android.annotation.SuppressLint
import android.content.DialogInterface
import android.content.pm.PackageManager
import android.location.Location
import android.os.Bundle
import android.util.Log
import android.view.Menu
import android.view.MenuItem
import android.view.View
import android.widget.FrameLayout
import android.widget.TextView
import androidx.appcompat.app.AlertDialog
import androidx.appcompat.app.AppCompatActivity
import androidx.core.app.ActivityCompat
import androidx.core.content.ContextCompat
import com.google.android.gms.location.FusedLocationProviderClient
import com.google.android.gms.location.LocationServices
import com.google.android.gms.maps.CameraUpdateFactory
import com.google.android.gms.maps.GoogleMap
import com.google.android.gms.maps.GoogleMap.InfoWindowAdapter
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.Marker
import com.google.android.gms.maps.model.MarkerOptions
import com.google.android.libraries.places.api.Places
import com.google.android.libraries.places.api.model.Place
import com.google.android.libraries.places.api.net.FindCurrentPlaceRequest
import com.google.android.libraries.places.api.net.PlacesClient

/**
 * An activity that displays a map showing the place at the device's current location.
 */
class MapsActivityCurrentPlace : AppCompatActivity(), OnMapReadyCallback {
    private var map: GoogleMap? = null
    private var cameraPosition: CameraPosition? = null

    // The entry point to the Places API.
    private lateinit var placesClient: PlacesClient

    // The entry point to the Fused Location Provider.
    private lateinit var fusedLocationProviderClient: FusedLocationProviderClient

    // A default location (Sydney, Australia) and default zoom to use when location permission is
    // not granted.
    private val defaultLocation = LatLng(-33.8523341, 151.2106085)
    private var locationPermissionGranted = false

    // The geographical location where the device is currently located. That is, the last-known
    // location retrieved by the Fused Location Provider.
    private var lastKnownLocation: Location? = null
    private var likelyPlaceNames: Array<String?> = arrayOfNulls(0)
    private var likelyPlaceAddresses: Array<String?> = arrayOfNulls(0)
    private var likelyPlaceAttributions: Array<List<*>?> = arrayOfNulls(0)
    private var likelyPlaceLatLngs: Array<LatLng?> = arrayOfNulls(0)

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)

        // Retrieve location and camera position from saved instance state.
        if (savedInstanceState != null) {
            lastKnownLocation = savedInstanceState.getParcelable(KEY_LOCATION)
            cameraPosition = savedInstanceState.getParcelable(KEY_CAMERA_POSITION)
        }

        // Retrieve the content view that renders the map.
        setContentView(R.layout.activity_maps)

        // Construct a PlacesClient
        Places.initialize(applicationContext, BuildConfig.MAPS_API_KEY)
        placesClient = Places.createClient(this)

        // Construct a FusedLocationProviderClient.
        fusedLocationProviderClient = LocationServices.getFusedLocationProviderClient(this)

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

    /**
     * Saves the state of the map when the activity is paused.
     */
    override fun onSaveInstanceState(outState: Bundle) {
        map?.let { map ->
            outState.putParcelable(KEY_CAMERA_POSITION, map.cameraPosition)
            outState.putParcelable(KEY_LOCATION, lastKnownLocation)
        }
        super.onSaveInstanceState(outState)
    }

    /**
     * Sets up the options menu.
     * @param menu The options menu.
     * @return Boolean.
     */
    override fun onCreateOptionsMenu(menu: Menu): Boolean {
        menuInflater.inflate(R.menu.current_place_menu, menu)
        return true
    }

    /**
     * Handles a click on the menu option to get a place.
     * @param item The menu item to handle.
     * @return Boolean.
     */
    override fun onOptionsItemSelected(item: MenuItem): Boolean {
        if (item.itemId == R.id.option_get_place) {
            showCurrentPlace()
        }
        return true
    }

    /**
     * Manipulates the map when it's available.
     * This callback is triggered when the map is ready to be used.
     */
    override fun onMapReady(map: GoogleMap) {
        this.map = map

        // Use a custom info window adapter to handle multiple lines of text in the
        // info window contents.
        this.map?.setInfoWindowAdapter(object : InfoWindowAdapter {
            // Return null here, so that getInfoContents() is called next.
            override fun getInfoWindow(arg0: Marker): View? {
                return null
            }

            override fun getInfoContents(marker: Marker): View {
                // Inflate the layouts for the info window, title and snippet.
                val infoWindow = layoutInflater.inflate(R.layout.custom_info_contents,
                    findViewById<FrameLayout>(R.id.map), false)
                val title = infoWindow.findViewById<TextView>(R.id.title)
                title.text = marker.title
                val snippet = infoWindow.findViewById<TextView>(R.id.snippet)
                snippet.text = marker.snippet
                return infoWindow
            }
        })

        // Prompt the user for permission.
        getLocationPermission()

        // Turn on the My Location layer and the related control on the map.
        updateLocationUI()

        // Get the current location of the device and set the position of the map.
        getDeviceLocation()
    }

    /**
     * Gets the current location of the device, and positions the map's camera.
     */
    @SuppressLint("MissingPermission")
    private fun getDeviceLocation() {
        /*
         * Get the best and most recent location of the device, which may be null in rare
         * cases when a location is not available.
         */
        try {
            if (locationPermissionGranted) {
                val locationResult = fusedLocationProviderClient.lastLocation
                locationResult.addOnCompleteListener(this) { task ->
                    if (task.isSuccessful) {
                        // Set the map's camera position to the current location of the device.
                        lastKnownLocation = task.result
                        if (lastKnownLocation != null) {
                            map?.moveCamera(CameraUpdateFactory.newLatLngZoom(
                                LatLng(lastKnownLocation!!.latitude,
                                    lastKnownLocation!!.longitude), DEFAULT_ZOOM.toFloat()))
                        }
                    } else {
                        Log.d(TAG, "Current location is null. Using defaults.")
                        Log.e(TAG, "Exception: %s", task.exception)
                        map?.moveCamera(CameraUpdateFactory
                            .newLatLngZoom(defaultLocation, DEFAULT_ZOOM.toFloat()))
                        map?.uiSettings?.isMyLocationButtonEnabled = false
                    }
                }
            }
        } catch (e: SecurityException) {
            Log.e("Exception: %s", e.message, e)
        }
    }

    /**
     * Prompts the user for permission to use the device location.
     */
    private fun getLocationPermission() {
        /*
         * Request location permission, so that we can get the location of the
         * device. The result of the permission request is handled by a callback,
         * onRequestPermissionsResult.
         */
        if (ContextCompat.checkSelfPermission(this.applicationContext,
                Manifest.permission.ACCESS_FINE_LOCATION)
            == PackageManager.PERMISSION_GRANTED) {
            locationPermissionGranted = true
        } else {
            ActivityCompat.requestPermissions(this, arrayOf(Manifest.permission.ACCESS_FINE_LOCATION),
                PERMISSIONS_REQUEST_ACCESS_FINE_LOCATION)
        }
    }

    /**
     * Handles the result of the request for location permissions.
     */
    override fun onRequestPermissionsResult(requestCode: Int,
                                            permissions: Array<String>,
                                            grantResults: IntArray) {
        locationPermissionGranted = false
        when (requestCode) {
            PERMISSIONS_REQUEST_ACCESS_FINE_LOCATION -> {

                // If request is cancelled, the result arrays are empty.
                if (grantResults.isNotEmpty() &&
                    grantResults[0] == PackageManager.PERMISSION_GRANTED) {
                    locationPermissionGranted = true
                }
            }
            else -> super.onRequestPermissionsResult(requestCode, permissions, grantResults)
        }
        updateLocationUI()
    }

    /**
     * Prompts the user to select the current place from a list of likely places, and shows the
     * current place on the map - provided the user has granted location permission.
     */
    @SuppressLint("MissingPermission")
    private fun showCurrentPlace() {
        if (map == null) {
            return
        }
        if (locationPermissionGranted) {
            // Use fields to define the data types to return.
            val placeFields = listOf(Place.Field.NAME, Place.Field.ADDRESS, Place.Field.LAT_LNG)

            // Use the builder to create a FindCurrentPlaceRequest.
            val request = FindCurrentPlaceRequest.newInstance(placeFields)

            // Get the likely places - that is, the businesses and other points of interest that
            // are the best match for the device's current location.
            val placeResult = placesClient.findCurrentPlace(request)
            placeResult.addOnCompleteListener { task ->
                if (task.isSuccessful && task.result != null) {
                    val likelyPlaces = task.result

                    // Set the count, handling cases where less than 5 entries are returned.
                    val count = if (likelyPlaces != null && likelyPlaces.placeLikelihoods.size < M_MAX_ENTRIES) {
                        likelyPlaces.placeLikelihoods.size
                    } else {
                        M_MAX_ENTRIES
                    }
                    var i = 0
                    likelyPlaceNames = arrayOfNulls(count)
                    likelyPlaceAddresses = arrayOfNulls(count)
                    likelyPlaceAttributions = arrayOfNulls<List<*>?>(count)
                    likelyPlaceLatLngs = arrayOfNulls(count)
                    for (placeLikelihood in likelyPlaces?.placeLikelihoods ?: emptyList()) {
                        // Build a list of likely places to show the user.
                        likelyPlaceNames[i] = placeLikelihood.place.name
                        likelyPlaceAddresses[i] = placeLikelihood.place.address
                        likelyPlaceAttributions[i] = placeLikelihood.place.attributions
                        likelyPlaceLatLngs[i] = placeLikelihood.place.latLng
                        i++
                        if (i > count - 1) {
                            break
                        }
                    }

                    // Show a dialog offering the user the list of likely places, and add a
                    // marker at the selected place.
                    openPlacesDialog()
                } else {
                    Log.e(TAG, "Exception: %s", task.exception)
                }
            }
        } else {
            // The user has not granted permission.
            Log.i(TAG, "The user did not grant location permission.")

            // Add a default marker, because the user hasn't selected a place.
            map?.addMarker(MarkerOptions()
                .title(getString(R.string.default_info_title))
                .position(defaultLocation)
                .snippet(getString(R.string.default_info_snippet)))

            // Prompt the user for permission.
            getLocationPermission()
        }
    }

    /**
     * Displays a form allowing the user to select a place from a list of likely places.
     */
    private fun openPlacesDialog() {
        // Ask the user to choose the place where they are now.
        val listener = DialogInterface.OnClickListener { dialog, which -> // The "which" argument contains the position of the selected item.
            val markerLatLng = likelyPlaceLatLngs[which]
            var markerSnippet = likelyPlaceAddresses[which]
            if (likelyPlaceAttributions[which] != null) {
                markerSnippet = """
                    $markerSnippet
                    ${likelyPlaceAttributions[which]}
                    """.trimIndent()
            }

            if (markerLatLng == null) {
                return@OnClickListener
            }

            // Add a marker for the selected place, with an info window
            // showing information about that place.
            map?.addMarker(MarkerOptions()
                .title(likelyPlaceNames[which])
                .position(markerLatLng)
                .snippet(markerSnippet))

            // Position the map's camera at the location of the marker.
            map?.moveCamera(CameraUpdateFactory.newLatLngZoom(markerLatLng,
                DEFAULT_ZOOM.toFloat()))
        }

        // Display the dialog.
        AlertDialog.Builder(this)
            .setTitle(R.string.pick_place)
            .setItems(likelyPlaceNames, listener)
            .show()
    }

    /**
     * Updates the map's UI settings based on whether the user has granted location permission.
     */
    @SuppressLint("MissingPermission")
    private fun updateLocationUI() {
        if (map == null) {
            return
        }
        try {
            if (locationPermissionGranted) {
                map?.isMyLocationEnabled = true
                map?.uiSettings?.isMyLocationButtonEnabled = true
            } else {
                map?.isMyLocationEnabled = false
                map?.uiSettings?.isMyLocationButtonEnabled = false
                lastKnownLocation = null
                getLocationPermission()
            }
        } catch (e: SecurityException) {
            Log.e("Exception: %s", e.message, e)
        }
    }

    companion object {
        private val TAG = MapsActivityCurrentPlace::class.java.simpleName
        private const val DEFAULT_ZOOM = 15
        private const val PERMISSIONS_REQUEST_ACCESS_FINE_LOCATION = 1

        // Keys for storing activity state.
        private const val KEY_CAMERA_POSITION = "camera_position"
        private const val KEY_LOCATION = "location"

        // Used for selecting the current place.
        private const val M_MAX_ENTRIES = 5
    }
}

    

Geliştirme projenizi oluşturma

Android Studio'da eğitim projesini oluşturmak için aşağıdaki adımları uygulayın.

1. İndir ve yükleme Android Studio'ya gidin.
2. Android Studio'ya Google Play Hizmetleri paketini ekleyin.
3. Klonlama veya Google Maps Android API v2 Samples deposunu indirin. , bu eğiticiyi okumaya başladığınızda bunu yapmadınız.

4. Eğitim projesini içe aktarın:

   • Android Studio'da Dosya > Yeni > İçe aktarma Proje.
   • Google Haritalar Android API v2 Sana Özel deposu, indirdikten sonra
   • CurrentPlaceDetailsOnMap projesini şurada bulun: konum:
     PATH-TO-SAVED-REPO/android-samples/tutorials/java/CurrentPlaceDetailsOnMap (Java) veya
     PATH-TO-SAVED-REPO/android-samples/tutorials/kotlin/CurrentPlaceDetailsOnMap (Kotlin)
   • Proje dizinini seçip Aç'ı tıklayın. Android Studio, artık Gradle derleme aracını kullanarak projenizi derliyor.

Gerekli API'leri etkinleştirin ve bir API anahtarı alın

Bu eğiticiyi tamamlamak için gerekli koşulları içeren bir Google Cloud projenize ihtiyacınız var: Etkinleştirilen API'ler ve Android için Haritalar SDK'sını kullanma yetkisi olan bir API anahtarı. Ayrıntılı bilgi için:

• Google Cloud projenizi oluşturma
• API anahtarı kullanma

Not: Bu eğitim için Android için Haritalar SDK'sının yanı sıra Yerler API'sini de etkinleştirmeniz gerekir.

Etkin API'lerinizin API'lerini görüntülemek için Google Haritalar Platformu sayfasına gidin açın ve projenizi seçin:

Google Haritalar Platformu sayfasına gidin

Places API'nin projenizde etkinleştirildiğini görmüyorsanız, bu API'yi etkinleştirmeniz gerekir:

Yerler API'sini etkinleştirme

API anahtarınıza kısıtlama eklerseniz anahtara Places API'yi eklediğinizden emin olun. Daha fazla bilgi için API anahtarlarını kullanma başlıklı makaleyi inceleyin.

API anahtarını uygulamanıza ekleyin

1. Projenizin local.properties dosyasını açın.

2. Aşağıdaki dizeyi ekleyin ve YOUR_API_KEY değerini API anahtarınızın değeriyle değiştirin:

   MAPS_API_KEY=YOUR_API_KEY

   Uygulamanızı oluştururken Android için Secrets Gradle Plugin API anahtarını kopyalar ve Android manifest dosyasında bir derleme değişkeni olarak kullanılabilir hale getirir.

Uygulamanızı derleyip çalıştırma

1. Bilgisayarınıza bir Android cihaz bağlayın. Şunu izleyin: talimatları Android cihazınızda geliştirici seçeneklerini etkinleştirin ve sisteminizi yapılandırın algılamasını sağlar.

   Alternatif olarak, Android Sanal Cihaz (AVD) Yöneticisi'ni seçin. Emülatör seçerken Google API'lerini içeren bir resim seçtiğinizden emin olun. Daha fazla bilgi için Android Studio Projesi Oluşturma

2. Android Studio'da Çalıştır menü seçeneğini (veya oynatma düğmesi simgesini) tıklayın. İstendiği şekilde bir cihaz seçin.

Android Studio, uygulamayı derlemek için Gradle'i çağırır ve ardından uygulamayı cihazda veya emülatörde çalıştırır. Bir dizi işaretçi bulunan bir harita göreceksiniz mevcut konumunuzu merkeze alır.

1. Yer (işletme veya başka bir önemli yer) listesini açmak için Yer Al'ı seçin mevcut konumunuza yakın.
2. Listeden bir yer seçin. Seçilen yer için haritaya bir işaretçi eklenir.

Sorun Giderme:

• Harita görmüyorsanız bir API anahtarı edinip eklediğinizden emin olun yukarıda açıklandığı gibi uygulamaya eklemeniz gerekir. Giriş yapmayı kontrol edin Android Studio'nun Android API anahtarıyla ilgili hata mesajlarını izleyin.
• Haritada Sidney Liman Köprüsü'nde yalnızca bir işaretçi gösteriliyorsa (uygulamada belirtilen varsayılan konum) her ikisine de izin verdiğinizden emin olun: konum iznini kullanmanız gerekir. Uygulama şunları istiyor: şu konumda açıklanan kalıbı uygulayarak çalışma zamanında konum izni: Android izin rehberini inceleyin. İzinleri doğrudan şurada da ayarlayabilirsiniz: Ayarlar > Uygulamalar > uygulama adı > İzinler > Konum. Kodunuzda izinleri nasıl kullanacağınızla ilgili ayrıntılar için uygulamanızda konum izni isteme başlıklı aşağıdaki kılavuza bakın.
• Şunu kullanın: Android Günlükleri görüntülemek ve uygulamada hata ayıklamak için Studio hata ayıklama araçları

Kodu anlama

Eğiticinin bu bölümünde, çevrimiçi görüntülü reklam kampanyalarınızın CurrentPlaceDetailsOnMap uygulamasında geliştirmenizi sağlar.

Places API istemcisini örneklendirme

Aşağıdaki nesneler, Android için Yerler SDK'sının birincil giriş noktalarıdır:

• İlgili içeriği oluşturmak için kullanılan Places class, Android için Yerler SDK'sına ilişkin istemciler oluşturur ve yönetir.
• İlgili içeriği oluşturmak için kullanılan PlacesClient arayüz, cihazın mevcut konumunu ve konumun yakınındaki yerleri alır.

LocationServices arayüzü, Android konum hizmetleri için ana giriş noktasıdır.

API'leri kullanmak için onCreate() hakkında daha fazla bilgi edinin:

1. Bir Places nesnesini başlatın.
2. Bir PlacesClient nesnesi oluşturun.
3. Bir FusedLocationProviderClient nesnesi oluşturun.

Örneğin:

Java

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);

    // ...

    // Retrieve the content view that renders the map.
    setContentView(R.layout.activity_maps);

    // Construct a PlacesClient
    Places.initialize(getApplicationContext(), getString(R.string.maps_api_key));
    placesClient = Places.createClient(this);

    // Construct a FusedLocationProviderClient.
    fusedLocationProviderClient = LocationServices.getFusedLocationProviderClient(this);
}

Kotlin

override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)

    // ...

    // Retrieve the content view that renders the map.
    setContentView(R.layout.activity_maps)

    // Construct a PlacesClient
    Places.initialize(applicationContext, getString(R.string.maps_api_key))
    placesClient = Places.createClient(this)

    // Construct a FusedLocationProviderClient.
    fusedLocationProviderClient = LocationServices.getFusedLocationProviderClient(this)

}

Konum izni iste

Uygulamanızın, konumu ve kullanıcının Konumum'a dokunmasına izin vermek için tıklayın.

Bu eğitimde, hassas konum izni istemek için ihtiyacınız olan kod sağlanmaktadır. Daha fazla bilgi edinmek için Android izinleriyle ilgili daha fazla bilgi edinin.

1. İzni, Android manifest'inizdeki <manifest> öğesinin alt öğesi olarak ekleyin:

   <manifest xmlns:android="http://schemas.android.com/apk/res/android"
       package="com.example.currentplacedetailsonmap">
       <uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />
   </manifest>

2. Uygulamanızda çalışma zamanında istenen izinleri isteme, izin verme veya reddetme fırsatı verir. Aşağıdaki kod kontrolleri Kullanıcının hassas konum izni verip vermediği. Aksi takdirde izin istenir:

   Java

   private void getLocationPermission() {
       /*
        * Request location permission, so that we can get the location of the
        * device. The result of the permission request is handled by a callback,
        * onRequestPermissionsResult.
        */
       if (ContextCompat.checkSelfPermission(this.getApplicationContext(),
               android.Manifest.permission.ACCESS_FINE_LOCATION)
               == PackageManager.PERMISSION_GRANTED) {
           locationPermissionGranted = true;
       } else {
           ActivityCompat.requestPermissions(this,
                   new String[]{android.Manifest.permission.ACCESS_FINE_LOCATION},
                   PERMISSIONS_REQUEST_ACCESS_FINE_LOCATION);
       }
   }
   MapsActivityCurrentPlace.java

   Kotlin

   private fun getLocationPermission() {
       /*
        * Request location permission, so that we can get the location of the
        * device. The result of the permission request is handled by a callback,
        * onRequestPermissionsResult.
        */
       if (ContextCompat.checkSelfPermission(this.applicationContext,
               Manifest.permission.ACCESS_FINE_LOCATION)
           == PackageManager.PERMISSION_GRANTED) {
           locationPermissionGranted = true
       } else {
           ActivityCompat.requestPermissions(this, arrayOf(Manifest.permission.ACCESS_FINE_LOCATION),
               PERMISSIONS_REQUEST_ACCESS_FINE_LOCATION)
       }
   }
   MapsActivityCurrentPlace.kt

3. İzin isteği sonucunu işlemek için onRequestPermissionsResult() geri çağırma işlevini geçersiz kılın:

   Java

   @Override
   public void onRequestPermissionsResult(int requestCode,
                                          @NonNull String[] permissions,
                                          @NonNull int[] grantResults) {
       locationPermissionGranted = false;
       if (requestCode
           == PERMISSIONS_REQUEST_ACCESS_FINE_LOCATION) {// If request is cancelled, the result arrays are empty.
           if (grantResults.length > 0
               && grantResults[0] == PackageManager.PERMISSION_GRANTED) {
               locationPermissionGranted = true;
           }
       } else {
           super.onRequestPermissionsResult(requestCode, permissions, grantResults);
       }
       updateLocationUI();
   }
   MapsActivityCurrentPlace.java

   Kotlin

   override fun onRequestPermissionsResult(requestCode: Int,
                                           permissions: Array<String>,
                                           grantResults: IntArray) {
       locationPermissionGranted = false
       when (requestCode) {
           PERMISSIONS_REQUEST_ACCESS_FINE_LOCATION -> {
   
               // If request is cancelled, the result arrays are empty.
               if (grantResults.isNotEmpty() &&
                   grantResults[0] == PackageManager.PERMISSION_GRANTED) {
                   locationPermissionGranted = true
               }
           }
           else -> super.onRequestPermissionsResult(requestCode, permissions, grantResults)
       }
       updateLocationUI()
   }
   MapsActivityCurrentPlace.kt

   Bu eğiticinin sonraki bölümlerinde updateLocationUI() yöntemini çağırın.

Harita ekleme

Android için Haritalar SDK'sını kullanarak bir harita görüntüleyin.

1. Etkinliğinizin düzenine <fragment> öğesi ekleyin dosyası, activity_maps.xml. Bu öğe, bir SupportMapFragment harita için bir kapsayıcı görevi görmek ve GoogleMap nesne. Eğitimde, Android çerçevesinin önceki sürümleriyle geriye dönük uyumluluk sağlamak için harita parçasının Android destek kitaplığı sürümü kullanılmaktadır.

   <!--
    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.
   -->
   
   <fragment xmlns:android="http://schemas.android.com/apk/res/android"
       xmlns:tools="http://schemas.android.com/tools"
       android:id="@+id/map"
       android:name="com.google.android.gms.maps.SupportMapFragment"
       android:layout_width="match_parent"
       android:layout_height="match_parent"
       tools:context="com.example.currentplacedetailsonmap.MapsActivityCurrentPlace" />

2. Etkinliğinizin onCreate() yönteminde düzen dosyasını ayarlayın iki yöntem vardır:

   Java

   @Override
   protected void onCreate(Bundle savedInstanceState) {
       super.onCreate(savedInstanceState);
   
   
       // Retrieve the content view that renders the map.
       setContentView(R.layout.activity_maps);
   
   }
   MapsActivityCurrentPlace.java

   Kotlin

   override fun onCreate(savedInstanceState: Bundle?) {
       super.onCreate(savedInstanceState)
   
   
       // Retrieve the content view that renders the map.
       setContentView(R.layout.activity_maps)
   
   }
   MapsActivityCurrentPlace.kt

3. Şunu uygulayın: OnMapReadyCallback arayüzünü ayarlamak ve onMapReady() yöntemini geçersiz kılmak için GoogleMap nesnesi kullanılabilir olduğunda harita oluşturun:

   Java

   @Override
   public void onMapReady(GoogleMap map) {
       this.map = map;
   
       // ...
   
       // Turn on the My Location layer and the related control on the map.
       updateLocationUI();
   
       // Get the current location of the device and set the position of the map.
       getDeviceLocation();
   }
   MapsActivityCurrentPlace.java

   Kotlin

   override fun onMapReady(map: GoogleMap) {
       this.map = map
   
       // ...
   
       // Turn on the My Location layer and the related control on the map.
       updateLocationUI()
   
       // Get the current location of the device and set the position of the map.
       getDeviceLocation()
   }
   MapsActivityCurrentPlace.kt

4. Etkinliğinizin onCreate() yönteminde herkese açık kullanıcı adı alın. harita parçasını çağırarak FragmentManager.findFragmentById() Daha sonra getMapAsync() harita geri çağırmasına kaydolmak için:

   Java

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

   Kotlin

   val mapFragment = supportFragmentManager
       .findFragmentById(R.id.map) as SupportMapFragment?
   mapFragment?.getMapAsync(this)
   MapsActivityCurrentPlace.kt

5. Konumu ayarlamak için bir updateLocationUI() yöntemi yazın haritada daha fazla kontrol edin. Kullanıcı konum izni verdiyse üzerindeki Konumum katmanını ve haritadaki ilgili denetimi katmanını ve kontrolü ekleyip geçerli konumu null değerine ayarlayın:

   Java

   private void updateLocationUI() {
       if (map == null) {
           return;
       }
       try {
           if (locationPermissionGranted) {
               map.setMyLocationEnabled(true);
               map.getUiSettings().setMyLocationButtonEnabled(true);
           } else {
               map.setMyLocationEnabled(false);
               map.getUiSettings().setMyLocationButtonEnabled(false);
               lastKnownLocation = null;
               getLocationPermission();
           }
       } catch (SecurityException e)  {
           Log.e("Exception: %s", e.getMessage());
       }
   }
   MapsActivityCurrentPlace.java

   Kotlin

   @SuppressLint("MissingPermission")
   private fun updateLocationUI() {
       if (map == null) {
           return
       }
       try {
           if (locationPermissionGranted) {
               map?.isMyLocationEnabled = true
               map?.uiSettings?.isMyLocationButtonEnabled = true
           } else {
               map?.isMyLocationEnabled = false
               map?.uiSettings?.isMyLocationButtonEnabled = false
               lastKnownLocation = null
               getLocationPermission()
           }
       } catch (e: SecurityException) {
           Log.e("Exception: %s", e.message, e)
       }
   }
   MapsActivityCurrentPlace.kt

Android cihazın konumunu alma ve haritayı konumlandırma

Cihazın en son bilinen konumunu bulmak için çok kaynaklı konum sağlayıcısını kullanın. ardından haritayı konumlandırmak için bu konumu kullanın. Eğiticide, bu bilgilerin gerekiyor. Cihazın konumunu alma hakkında daha fazla bilgi için çok kaynaklı konum sağlayıcıyı Google Play Hizmetleri konum API'lerinde bulabilirsiniz.

Java

private void getDeviceLocation() {
    /*
     * Get the best and most recent location of the device, which may be null in rare
     * cases when a location is not available.
     */
    try {
        if (locationPermissionGranted) {
            Task<Location> locationResult = fusedLocationProviderClient.getLastLocation();
            locationResult.addOnCompleteListener(this, new OnCompleteListener<Location>() {
                @Override
                public void onComplete(@NonNull Task<Location> task) {
                    if (task.isSuccessful()) {
                        // Set the map's camera position to the current location of the device.
                        lastKnownLocation = task.getResult();
                        if (lastKnownLocation != null) {
                            map.moveCamera(CameraUpdateFactory.newLatLngZoom(
                                    new LatLng(lastKnownLocation.getLatitude(),
                                            lastKnownLocation.getLongitude()), DEFAULT_ZOOM));
                        }
                    } else {
                        Log.d(TAG, "Current location is null. Using defaults.");
                        Log.e(TAG, "Exception: %s", task.getException());
                        map.moveCamera(CameraUpdateFactory
                                .newLatLngZoom(defaultLocation, DEFAULT_ZOOM));
                        map.getUiSettings().setMyLocationButtonEnabled(false);
                    }
                }
            });
        }
    } catch (SecurityException e)  {
        Log.e("Exception: %s", e.getMessage(), e);
    }
}
MapsActivityCurrentPlace.java

Kotlin

@SuppressLint("MissingPermission")
private fun getDeviceLocation() {
    /*
     * Get the best and most recent location of the device, which may be null in rare
     * cases when a location is not available.
     */
    try {
        if (locationPermissionGranted) {
            val locationResult = fusedLocationProviderClient.lastLocation
            locationResult.addOnCompleteListener(this) { task ->
                if (task.isSuccessful) {
                    // Set the map's camera position to the current location of the device.
                    lastKnownLocation = task.result
                    if (lastKnownLocation != null) {
                        map?.moveCamera(CameraUpdateFactory.newLatLngZoom(
                            LatLng(lastKnownLocation!!.latitude,
                                lastKnownLocation!!.longitude), DEFAULT_ZOOM.toFloat()))
                    }
                } else {
                    Log.d(TAG, "Current location is null. Using defaults.")
                    Log.e(TAG, "Exception: %s", task.exception)
                    map?.moveCamera(CameraUpdateFactory
                        .newLatLngZoom(defaultLocation, DEFAULT_ZOOM.toFloat()))
                    map?.uiSettings?.isMyLocationButtonEnabled = false
                }
            }
        }
    } catch (e: SecurityException) {
        Log.e("Exception: %s", e.message, e)
    }
}
MapsActivityCurrentPlace.kt

Geçerli yeri bulma

Android için Yerler SDK'sını kullanarak cihazınızın mevcut konumuna bağlıdır. Bu bağlamda yer, bir işletmedir veya başka bir önemli yere ekleyin.

Bu eğitimde, kullanıcı bir Yer Al düğmesi. Kullanıcıya olası yerlerin bir listesini sunar seçim yapar, ardından seçilen yerin konumuna haritaya bir işaretçi ekler yer. Eğitici, Android için Yerler SDK'sı. Daha fazla bilgi edinmek için geçerli yeri öğrenmeniz gerekir.

1. Seçenekler için bir düzen dosyası (current_place_menu.xml) oluşturun ayarlamak ve onCreateOptionsMenu() yöntemini geçersiz kılmak için seçenekler menüsüne gidin. Kod için ekteki örnek uygulamaya bakın.
2. Kullanıcı Konum Al seçeneğini tıkladığında mevcut konumu almak için onOptionsItemSelected() yöntemini geçersiz kılın:

   Java

   @Override
   public boolean onOptionsItemSelected(MenuItem item) {
       if (item.getItemId() == R.id.option_get_place) {
           showCurrentPlace();
       }
       return true;
   }
   MapsActivityCurrentPlace.java

   Kotlin

   override fun onOptionsItemSelected(item: MenuItem): Boolean {
       if (item.itemId == R.id.option_get_place) {
           showCurrentPlace()
       }
       return true
   }
   MapsActivityCurrentPlace.kt

3. Olası öğelerin listesini almak için showCurrentPlace() yöntemi oluşturun yer, cihazın geçerli konumu:

   Java

   private void showCurrentPlace() {
       if (map == null) {
           return;
       }
   
       if (locationPermissionGranted) {
           // Use fields to define the data types to return.
           List<Place.Field> placeFields = Arrays.asList(Place.Field.NAME, Place.Field.ADDRESS,
                   Place.Field.LAT_LNG);
   
           // Use the builder to create a FindCurrentPlaceRequest.
           FindCurrentPlaceRequest request =
                   FindCurrentPlaceRequest.newInstance(placeFields);
   
           // Get the likely places - that is, the businesses and other points of interest that
           // are the best match for the device's current location.
           @SuppressWarnings("MissingPermission") final
           Task<FindCurrentPlaceResponse> placeResult =
                   placesClient.findCurrentPlace(request);
           placeResult.addOnCompleteListener (new OnCompleteListener<FindCurrentPlaceResponse>() {
               @Override
               public void onComplete(@NonNull Task<FindCurrentPlaceResponse> task) {
                   if (task.isSuccessful() && task.getResult() != null) {
                       FindCurrentPlaceResponse likelyPlaces = task.getResult();
   
                       // Set the count, handling cases where less than 5 entries are returned.
                       int count;
                       if (likelyPlaces.getPlaceLikelihoods().size() < M_MAX_ENTRIES) {
                           count = likelyPlaces.getPlaceLikelihoods().size();
                       } else {
                           count = M_MAX_ENTRIES;
                       }
   
                       int i = 0;
                       likelyPlaceNames = new String[count];
                       likelyPlaceAddresses = new String[count];
                       likelyPlaceAttributions = new List[count];
                       likelyPlaceLatLngs = new LatLng[count];
   
                       for (PlaceLikelihood placeLikelihood : likelyPlaces.getPlaceLikelihoods()) {
                           // Build a list of likely places to show the user.
                           likelyPlaceNames[i] = placeLikelihood.getPlace().getName();
                           likelyPlaceAddresses[i] = placeLikelihood.getPlace().getAddress();
                           likelyPlaceAttributions[i] = placeLikelihood.getPlace()
                                   .getAttributions();
                           likelyPlaceLatLngs[i] = placeLikelihood.getPlace().getLatLng();
   
                           i++;
                           if (i > (count - 1)) {
                               break;
                           }
                       }
   
                       // Show a dialog offering the user the list of likely places, and add a
                       // marker at the selected place.
                       MapsActivityCurrentPlace.this.openPlacesDialog();
                   }
                   else {
                       Log.e(TAG, "Exception: %s", task.getException());
                   }
               }
           });
       } else {
           // The user has not granted permission.
           Log.i(TAG, "The user did not grant location permission.");
   
           // Add a default marker, because the user hasn't selected a place.
           map.addMarker(new MarkerOptions()
                   .title(getString(R.string.default_info_title))
                   .position(defaultLocation)
                   .snippet(getString(R.string.default_info_snippet)));
   
           // Prompt the user for permission.
           getLocationPermission();
       }
   }
   MapsActivityCurrentPlace.java

   Kotlin

   @SuppressLint("MissingPermission")
   private fun showCurrentPlace() {
       if (map == null) {
           return
       }
       if (locationPermissionGranted) {
           // Use fields to define the data types to return.
           val placeFields = listOf(Place.Field.NAME, Place.Field.ADDRESS, Place.Field.LAT_LNG)
   
           // Use the builder to create a FindCurrentPlaceRequest.
           val request = FindCurrentPlaceRequest.newInstance(placeFields)
   
           // Get the likely places - that is, the businesses and other points of interest that
           // are the best match for the device's current location.
           val placeResult = placesClient.findCurrentPlace(request)
           placeResult.addOnCompleteListener { task ->
               if (task.isSuccessful && task.result != null) {
                   val likelyPlaces = task.result
   
                   // Set the count, handling cases where less than 5 entries are returned.
                   val count = if (likelyPlaces != null && likelyPlaces.placeLikelihoods.size < M_MAX_ENTRIES) {
                       likelyPlaces.placeLikelihoods.size
                   } else {
                       M_MAX_ENTRIES
                   }
                   var i = 0
                   likelyPlaceNames = arrayOfNulls(count)
                   likelyPlaceAddresses = arrayOfNulls(count)
                   likelyPlaceAttributions = arrayOfNulls<List<*>?>(count)
                   likelyPlaceLatLngs = arrayOfNulls(count)
                   for (placeLikelihood in likelyPlaces?.placeLikelihoods ?: emptyList()) {
                       // Build a list of likely places to show the user.
                       likelyPlaceNames[i] = placeLikelihood.place.name
                       likelyPlaceAddresses[i] = placeLikelihood.place.address
                       likelyPlaceAttributions[i] = placeLikelihood.place.attributions
                       likelyPlaceLatLngs[i] = placeLikelihood.place.latLng
                       i++
                       if (i > count - 1) {
                           break
                       }
                   }
   
                   // Show a dialog offering the user the list of likely places, and add a
                   // marker at the selected place.
                   openPlacesDialog()
               } else {
                   Log.e(TAG, "Exception: %s", task.exception)
               }
           }
       } else {
           // The user has not granted permission.
           Log.i(TAG, "The user did not grant location permission.")
   
           // Add a default marker, because the user hasn't selected a place.
           map?.addMarker(MarkerOptions()
               .title(getString(R.string.default_info_title))
               .position(defaultLocation)
               .snippet(getString(R.string.default_info_snippet)))
   
           // Prompt the user for permission.
           getLocationPermission()
       }
   }
   MapsActivityCurrentPlace.kt

4. Formu görüntülemek için openPlacesDialog() yöntemi oluşturun kullanıcının olası yerler listesinden bir yer seçmesine olanak tanır. Bir haritadaki işaretçiyi kullanın. İşaretçi içeriği, yerin adını ve adresini ve API'nin sağladığı tüm ilişkilendirmeleri içerir:

   Java

   private void openPlacesDialog() {
       // Ask the user to choose the place where they are now.
       DialogInterface.OnClickListener listener = new DialogInterface.OnClickListener() {
           @Override
           public void onClick(DialogInterface dialog, int which) {
               // The "which" argument contains the position of the selected item.
               LatLng markerLatLng = likelyPlaceLatLngs[which];
               String markerSnippet = likelyPlaceAddresses[which];
               if (likelyPlaceAttributions[which] != null) {
                   markerSnippet = markerSnippet + "\n" + likelyPlaceAttributions[which];
               }
   
               // Add a marker for the selected place, with an info window
               // showing information about that place.
               map.addMarker(new MarkerOptions()
                       .title(likelyPlaceNames[which])
                       .position(markerLatLng)
                       .snippet(markerSnippet));
   
               // Position the map's camera at the location of the marker.
               map.moveCamera(CameraUpdateFactory.newLatLngZoom(markerLatLng,
                       DEFAULT_ZOOM));
           }
       };
   
       // Display the dialog.
       AlertDialog dialog = new AlertDialog.Builder(this)
               .setTitle(R.string.pick_place)
               .setItems(likelyPlaceNames, listener)
               .show();
   }
   MapsActivityCurrentPlace.java

   Kotlin

   private fun openPlacesDialog() {
       // Ask the user to choose the place where they are now.
       val listener = DialogInterface.OnClickListener { dialog, which -> // The "which" argument contains the position of the selected item.
           val markerLatLng = likelyPlaceLatLngs[which]
           var markerSnippet = likelyPlaceAddresses[which]
           if (likelyPlaceAttributions[which] != null) {
               markerSnippet = """
                   $markerSnippet
                   ${likelyPlaceAttributions[which]}
                   """.trimIndent()
           }
   
           if (markerLatLng == null) {
               return@OnClickListener
           }
   
           // Add a marker for the selected place, with an info window
           // showing information about that place.
           map?.addMarker(MarkerOptions()
               .title(likelyPlaceNames[which])
               .position(markerLatLng)
               .snippet(markerSnippet))
   
           // Position the map's camera at the location of the marker.
           map?.moveCamera(CameraUpdateFactory.newLatLngZoom(markerLatLng,
               DEFAULT_ZOOM.toFloat()))
       }
   
       // Display the dialog.
       AlertDialog.Builder(this)
           .setTitle(R.string.pick_place)
           .setItems(likelyPlaceNames, listener)
           .show()
   }
   MapsActivityCurrentPlace.kt

5. Bilgi penceresi içeriği için özel bir düzen oluşturun. Bu sayede bilgi penceresinde birden fazla satır içerik gösterilebilir. Öncelikle, bilgi penceresi başlığı için bir metin görünümü ve snippet (yani bilgi penceresinin metin içeriği) için başka bir metin görünümü içeren bir XML düzen dosyası (custom_info_contents.xml) ekleyin:

   <?xml version="1.0" encoding="utf-8"?>
   <!--
    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.
   -->
   
   <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
       android:layout_width="wrap_content"
       android:layout_height="wrap_content"
       android:layoutDirection="locale"
       android:orientation="vertical">
       <TextView
           android:id="@+id/title"
           android:layout_width="wrap_content"
           android:layout_height="wrap_content"
           android:layout_gravity="center_horizontal"
           android:textColor="#ff000000"
           android:textStyle="bold" />
   
       <TextView
           android:id="@+id/snippet"
           android:layout_width="wrap_content"
           android:layout_height="wrap_content"
           android:textColor="#ff7f7f7f" />
   </LinearLayout>

6. Şunu uygulayın: InfoWindowAdapter oluşturmak ve bilgi penceresi içeriğini yüklemek için aşağıdaki adımları uygulayın:

   Java

   // Use a custom info window adapter to handle multiple lines of text in the
   // info window contents.
   this.map.setInfoWindowAdapter(new GoogleMap.InfoWindowAdapter() {
   
       @Override
       // Return null here, so that getInfoContents() is called next.
       public View getInfoWindow(Marker arg0) {
           return null;
       }
   
       @Override
       public View getInfoContents(Marker marker) {
           // Inflate the layouts for the info window, title and snippet.
           View infoWindow = getLayoutInflater().inflate(R.layout.custom_info_contents,
                   (FrameLayout) findViewById(R.id.map), false);
   
           TextView title = infoWindow.findViewById(R.id.title);
           title.setText(marker.getTitle());
   
           TextView snippet = infoWindow.findViewById(R.id.snippet);
           snippet.setText(marker.getSnippet());
   
           return infoWindow;
       }
   });
   MapsActivityCurrentPlace.java

   Kotlin

   // Use a custom info window adapter to handle multiple lines of text in the
   // info window contents.
   this.map?.setInfoWindowAdapter(object : InfoWindowAdapter {
       // Return null here, so that getInfoContents() is called next.
       override fun getInfoWindow(arg0: Marker): View? {
           return null
       }
   
       override fun getInfoContents(marker: Marker): View {
           // Inflate the layouts for the info window, title and snippet.
           val infoWindow = layoutInflater.inflate(R.layout.custom_info_contents,
               findViewById<FrameLayout>(R.id.map), false)
           val title = infoWindow.findViewById<TextView>(R.id.title)
           title.text = marker.title
           val snippet = infoWindow.findViewById<TextView>(R.id.snippet)
           snippet.text = marker.snippet
           return infoWindow
       }
   })
   MapsActivityCurrentPlace.kt

Not: Varsayılan olarak, Android için Haritalar SDK'sı, Kullanıcı bir işaretçiye dokunduğunda. Varsayılan davranışı kullanmak istiyorsanız işaretçi için tıklama dinleyici eklemeniz gerekmez.

Haritanın durumunu kaydetme

Haritanın kamera konumunu ve cihaz konumunu kaydedin. Kullanıcı dönüşümlü yayınladığında veya yapılandırma değişiklikleri yaptığında, Android sistem harita etkinliğini yok eder ve yeniden oluşturur. Sorunsuz bir kullanıcı deneyimi sağlamak için ilgili uygulama durumunu depolamak ve gerektiğinde geri yüklemek iyidir.

Haritanın durumunu kaydetmek için ihtiyacınız olan tüm kodları bu eğiticide bulabilirsiniz. Örneğin, daha fazla ayrıntı için savedInstanceState paketi'ne dokunun.

1. Harita etkinliğinizde, etkinlik durumunu depolamak için anahtar/değer çiftleri ayarlayın:

   Java

   private static final String KEY_CAMERA_POSITION = "camera_position";
   private static final String KEY_LOCATION = "location";
   MapsActivityCurrentPlace.java

   Kotlin

   private const val KEY_CAMERA_POSITION = "camera_position"
   private const val KEY_LOCATION = "location"
   MapsActivityCurrentPlace.kt

2. onSaveInstanceState() geri çağırma işlevini kullanarak Etkinlik durakladığında geçerli olur:

   Java

   @Override
   protected void onSaveInstanceState(Bundle outState) {
       if (map != null) {
           outState.putParcelable(KEY_CAMERA_POSITION, map.getCameraPosition());
           outState.putParcelable(KEY_LOCATION, lastKnownLocation);
       }
       super.onSaveInstanceState(outState);
   }
   MapsActivityCurrentPlace.java

   Kotlin

   override fun onSaveInstanceState(outState: Bundle) {
       map?.let { map ->
           outState.putParcelable(KEY_CAMERA_POSITION, map.cameraPosition)
           outState.putParcelable(KEY_LOCATION, lastKnownLocation)
       }
       super.onSaveInstanceState(outState)
   }
   MapsActivityCurrentPlace.kt

3. Etkinliğinizin onCreate() yönteminde daha önce kaydedilmişse cihazın konumu ve haritanın kamera konumu:

   Java

   // Retrieve location and camera position from saved instance state.
   if (savedInstanceState != null) {
       lastKnownLocation = savedInstanceState.getParcelable(KEY_LOCATION);
       cameraPosition = savedInstanceState.getParcelable(KEY_CAMERA_POSITION);
   }
   MapsActivityCurrentPlace.java

   Kotlin

   if (savedInstanceState != null) {
       lastKnownLocation = savedInstanceState.getParcelable(KEY_LOCATION)
       cameraPosition = savedInstanceState.getParcelable(KEY_CAMERA_POSITION)
   }
   MapsActivityCurrentPlace.kt

Tebrikler! Bir Android oluşturdunuz Google haritasında mevcut yeri gösteren bir uygulama. Ayrıca paydaşların her bir Android için Haritalar SDK'sı Android için Yerler SDK'sı ve çok kaynaklı Konum Sağlayıcı