W1 D2: 사용자의 현재 위치 가져오기 및 저장 👤📍

    // MapsActivity.kt

    private lateinit var placesClient: PlacesClient
    private lateinit var fusedLocationProviderClient: FusedLocationProviderClient

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

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

        // Create FusedLocationProviderClient
        fusedLocationProviderClient = LocationServices.getFusedLocationProviderClient(this)
    }

    // AndroidManifest.xml

    <!--
         The ACCESS_COARSE/FINE_LOCATION permissions are not required to use
         Google Maps Android API v2, but you must specify either coarse or fine
         location permissions for the "MyLocation" functionality.
    -->
    <uses-permissionandroid:name="android.permission.ACCESS_FINE_LOCATION" />

            // MapsActivity.kt

                private var locationPermissionGranted = false

                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, 
                        android.Manifest.permission.ACCESS_FINE_LOCATION) == PackageManager.PERMISSION_GRANTED) {
                    locationPermissionGranted = true
                } else {
                    ActivityCompat.requestPermissions(this, 
                        arrayOf(android.Manifest.permission.ACCESS_FINE_LOCATION), 
                        PERMISSIONS_REQUEST_ACCESS_FINE_LOCATION
                    )
                }
            }

                companion object {
                    private const val PERMISSIONS_REQUEST_ACCESS_FINE_LOCATION = 111
                }

                // MapsActivity.kt      

                override fun onRequestPermissionsResult(requestCode: Int,
                                                    permissions: Array<String>,
                                                    grantResults: IntArray) {
                super.onRequestPermissionsResult(requestCode, permissions, grantResults)
                locationPermissionGranted = false
                when (requestCode) {
                    PERMISSIONS_REQUEST_ACCESS_FINE_LOCATION -> {

                        // If request is cancelled, the result arrays are empty. But if the user has now
                        // granted the permission (after we requested), the result array contains that permission.
                        if (grantResults.isNotEmpty() &&
                            grantResults[0] == PackageManager.PERMISSION_GRANTED) {
                            locationPermissionGranted = true
                        }
                    }
                }
            }

    // mAPSaCTIVITY.KT
    private var lastKnownLocation = null

    override fun onMapReady(googleMap: GoogleMap) {
        ...
        // Turn on the My Location layer and the related control on the map.
        updateLocationUI()
    }

    override fun onRequestPermissionsResult(...) {
        ...
        updateLocationUI()
    }       

    private fun updateLocationUI() {
        /**
         * If the user has granted the FINE_LOCATION permission, update the UI else don't
         */
        if (mMap == null) {
            return
        }
        try {
            if (locationPermissionGranted) {
                mMap.isMyLocationEnabled = true
                mMap.uiSettings.isMyLocationButtonEnabled = true
            } else {
                mMap.isMyLocationEnabled = false
                mMap.uiSettings.isMyLocationButtonEnabled = false
                lastKnownLocation = null
                getLocationPermission()
            }
        } catch (e: SecurityException) {
            Log.e("Exception: %s", e.message, e)
        }
    }

        // MapsActivity.kt

            private var lastKnownLocation: Location? = null
            private val defaultLocation = LatLng(-34.0, 151.0)      // Sydney       

            override fun onMapReady(googleMap: GoogleMap) {
                    ...
                // Get the current location of the device and set the position of the map.
                getDeviceLocation()
            }

            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) {
                                mMap.moveCamera(CameraUpdateFactory.newLatLngZoom(
                                    LatLng(lastKnownLocation!!.latitude,
                                        lastKnownLocation!!.longitude), DEFAULT_ZOOM))
                            }
                        } else {
                            Log.d(TAG, "Current location is null. Using defaults.")
                            Log.e(TAG, "Exception: %s", task.exception)
                            mMap.moveCamera(CameraUpdateFactory
                                .newLatLngZoom(defaultLocation, DEFAULT_ZOOM))
                            mMap.uiSettings.isMyLocationButtonEnabled = false
                        }
                    }
                }
            } catch (e: SecurityException) {
                Log.e("Exception: %s", e.message, e)
            }
        }

        companion object {
             private const val DEFAULT_ZOOM = 50F
         }

    ```
{% endraw %}

Now run the app. After allowing the app to get your location, you'll see that the map zooms in to your current location, displaying a blue circle at your precise latitude & longitude. Great! 🍻
![55.png](https://cdn.hashnode.com/res/hashnode/image/upload/v1631373417221/GE0fvfGUg.png)
![44.png](https://cdn.hashnode.com/res/hashnode/image/upload/v1631373423561/r2MR9A-Ry.png)

// MapsActivity.kt      

private var cameraPosition: CameraPosition? = CameraPosition(defaultLocation, DEFAULT_ZOOM, 0.0F, 0.0F)

    override fun onCreate(savedInstanceState: Bundle?) {
        ...
        // Retrieve the user's saved map state & camera position
        if (savedInstanceState != null) {
            lastKnownLocation = savedInstanceState.getParcelable(KEY_LOCATION)
            cameraPosition = savedInstanceState.getParcelable(KEY_CAMERA_POSITION)
        }
    }

    override fun onSaveInstanceState(outState: Bundle) {
        /**
         * Save the map's state & camera position when the activity is destroyed
         * (like in a configuration change)
         */
        mMap.let { map ->
            outState.putParcelable(KEY_CAMERA_POSITION, map.cameraPosition)
            outState.putParcelable(KEY_LOCATION, lastKnownLocation)
        }
        super.onSaveInstanceState(outState)
    }

    companion object {
        ...
        private const val KEY_CAMERA_POSITION = "camera_position"
        private const val KEY_LOCATION = "location"
    }