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

// [START maps_current_place_on_create]

override fun onCreate(savedInstanceState: Bundle?) {

super.onCreate(savedInstanceState)

// [START_EXCLUDE silent]

// Retrieve location and camera position from saved instance state.

// [START maps_current_place_on_create_save_instance_state]

if (savedInstanceState != null) {

lastKnownLocation = savedInstanceState.getParcelable(KEY_LOCATION)

cameraPosition = savedInstanceState.getParcelable(KEY_CAMERA_POSITION)

}

// [END maps_current_place_on_create_save_instance_state]

// [END_EXCLUDE]

// Retrieve the content view that renders the map.

setContentView(R.layout.activity_maps)

// [START_EXCLUDE silent]

// Construct a PlacesClient

Places.initialize(applicationContext, BuildConfig.MAPS_API_KEY)

placesClient = Places.createClient(this)

// Construct a FusedLocationProviderClient.

fusedLocationProviderClient = LocationServices.getFusedLocationProviderClient(this)

// Build the map.

// [START maps_current_place_map_fragment]

val mapFragment = supportFragmentManager

.findFragmentById(R.id.map) as SupportMapFragment?

mapFragment?.getMapAsync(this)

// [END maps_current_place_map_fragment]

// [END_EXCLUDE]

}

// [END maps_current_place_on_create]

/**

* Saves the state of the map when the activity is paused.

*/

// [START maps_current_place_on_save_instance_state]

override fun onSaveInstanceState(outState: Bundle) {

map?.let { map ->

outState.putParcelable(KEY_CAMERA_POSITION, map.cameraPosition)

outState.putParcelable(KEY_LOCATION, lastKnownLocation)

}

super.onSaveInstanceState(outState)

}

// [END maps_current_place_on_save_instance_state]

/**

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

*/

// [START maps_current_place_on_options_item_selected]

override fun onOptionsItemSelected(item: MenuItem): Boolean {

if (item.itemId == R.id.option_get_place) {

showCurrentPlace()

}

return true

}

// [END maps_current_place_on_options_item_selected]

/**

* Manipulates the map when it's available.

* This callback is triggered when the map is ready to be used.

*/

// [START maps_current_place_on_map_ready]

override fun onMapReady(map: GoogleMap) {

this.map = map

// [START_EXCLUDE]

// [START map_current_place_set_info_window_adapter]

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

}

})

// [END map_current_place_set_info_window_adapter]

// Prompt the user for permission.

getLocationPermission()

// [END_EXCLUDE]

// 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()

}

// [END maps_current_place_on_map_ready]

/**

* Gets the current location of the device, and positions the map's camera.

*/

// [START maps_current_place_get_device_location]

@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)

}

}

// [END maps_current_place_get_device_location]

/**

* Prompts the user for permission to use the device location.

*/

// [START maps_current_place_location_permission]

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)

}

}

// [END maps_current_place_location_permission]

/**

* Handles the result of the request for location permissions.

*/

// [START maps_current_place_on_request_permissions_result]

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()

}

// [END maps_current_place_on_request_permissions_result]

/**

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

*/

// [START maps_current_place_show_current_place]

@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()

}

}

// [END maps_current_place_show_current_place]

/**

* Displays a form allowing the user to select a place from a list of likely places.

*/

// [START maps_current_place_open_places_dialog]

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()

}

// [END maps_current_place_open_places_dialog]

/**

* Updates the map's UI settings based on whether the user has granted location permission.

*/

// [START maps_current_place_update_location_ui]

@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)

}

}

// [END maps_current_place_update_location_ui]

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.

// [START maps_current_place_state_keys]

private const val KEY_CAMERA_POSITION = "camera_position"

private const val KEY_LOCATION = "location"

// [END maps_current_place_state_keys]

// Used for selecting the current place.

private const val M_MAX_ENTRIES = 5

}

}