feat: Improved Place Details Compose sample (#964)

* * Enhance map screen with live location and improved UX
* Implement immersive mode and enhance map interaction

Key changes:

- **Live Location Tracking**:
- **Improved Map Interaction & UX**:
  - When a place is selected, a `Circle` is now drawn on the map to visually highlight its location.
  - The camera animates to a position slightly offset to the south of the selected place, preventing the details view from obscuring the marker.
    - The app now supports an edge-to-edge display by setting a transparent status bar.

- **Architecture & Initialization**:
  - A custom `PlaceDetailsComposeApplication` class has been added to handle application-wide setup.
  - The application now performs a startup check to ensure the Google Maps API key is correctly configured, throwing a `RuntimeException` if it's missing or invalid.
  - Google Maps initialization is now handled explicitly in `MainActivity`, displaying a progress indicator until the map is ready.

- **Dependency Updates**:
  - Upgraded several dependencies, including Places SDK to `5.0.0`, Maps Compose to `6.12.1`, and various Kotlin and Jetpack Compose libraries.
  - Added new dependencies for `maps-compose-widgets`, `maps-utils-ktx`, and `material-icons-extended` to support the new features.

* fix: fix deprecated places fields

* chore: Fix typos and update map ID placeholder

This commit addresses several minor issues and inconsistencies across the projects.

Key changes:

-   **Gradle Wrapper**: Corrected a typo in the `distributionSha256Sum` by removing a trailing 'n' in the `gradle-wrapper.properties` files for all modules.
-   **Map ID Placeholder**: Updated the placeholder value for the map ID from `UNSET_MAP_ID` to `YOUR_MAP_ID`. This change is reflected in:
    -   `PlaceDetailsCompose/app/src/main/res/values/strings.xml`
    -   `PlaceDetailsCompose/local.defaults.properties`
    -   The validation logic within `PlaceDetailsComposeApplication.kt`.
-   **Code Style**: Renamed the `Context` variable from `ctx` to `context` in `PlaceDetailsView.kt` for improved clarity.

* chore: update gradle-wrapper.jar files\nAdd missing POST_NOTIFICATIONS permission

Author: dkhawk

PlaceDetailsCompose/app/build.gradle.kts

@@ -124,6 +124,8 @@ dependencies {
     implementation(libs.places) // The SDK for the Places UI Kit (PlaceDetails fragments).
     implementation(libs.play.services.location) // Needed for the FusedLocationProviderClient to get the device's location.
     implementation(libs.maps.compose)
+    implementation(libs.maps.compose.widgets)
+    implementation(libs.maps.utils.ktx)
     implementation(libs.material) // For Material Design components (used in XML layouts).
 
     // --- Jetpack Compose ---
@@ -132,6 +134,7 @@ dependencies {
     implementation(platform(libs.androidx.compose.bom)) // The Compose Bill of Materials (BOM) ensures all Compose libraries use compatible versions.
     implementation(libs.androidx.ui.tooling.preview) // For displaying @Preview composables in Android Studio.
     implementation(libs.androidx.ui.viewbinding)
+    implementation(libs.androidx.material.icons.extended)
     debugImplementation(libs.androidx.ui.tooling) // Provides tools for inspecting Compose UIs.
 
     // --- Testing Libraries ---

PlaceDetailsCompose/app/src/main/AndroidManifest.xml

@@ -20,8 +20,10 @@ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 
     <uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />
     <uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION" />
+    <uses-permission android:name="android.permission.POST_NOTIFICATIONS" />
 
     <application
+        android:name=".PlaceDetailsComposeApplication"
         android:allowBackup="true"
         android:dataExtractionRules="@xml/data_extraction_rules"
         android:fullBackupContent="@xml/backup_rules"

PlaceDetailsCompose/app/src/main/java/com/example/placedetailscompose/MainActivity.kt

@@ -20,9 +20,23 @@ import android.widget.Toast
 import androidx.activity.compose.setContent
 import androidx.activity.enableEdgeToEdge
 import androidx.appcompat.app.AppCompatActivity
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.material3.CircularProgressIndicator
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.SideEffect
+import androidx.compose.runtime.getValue
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.platform.LocalContext
+import androidx.core.view.WindowCompat
+import androidx.core.view.WindowInsetsCompat
+import androidx.core.view.WindowInsetsControllerCompat
 import com.example.placedetailscompose.ui.map.MapScreen
 import com.example.placedetailscompose.ui.theme.PlaceDetailsComposeTheme
 import com.google.android.libraries.places.api.Places
+import com.google.maps.android.compose.internal.InitializationState
+import com.google.maps.android.compose.internal.LocalGoogleMapsInitializer
 
 class MainActivity : AppCompatActivity() {
     override fun onCreate(savedInstanceState: Bundle?) {
@@ -48,8 +62,35 @@ class MainActivity : AppCompatActivity() {
 
         enableEdgeToEdge()
         setContent {
+            val googleMapsInitializer = LocalGoogleMapsInitializer.current
+            val initializationState by googleMapsInitializer.state
+            val window = this.window
+            val insetsController = WindowCompat.getInsetsController(window, window.decorView)
+
+            SideEffect {
+                insetsController.hide(WindowInsetsCompat.Type.systemBars())
+                insetsController.systemBarsBehavior =
+                    WindowInsetsControllerCompat.BEHAVIOR_SHOW_TRANSIENT_BARS_BY_SWIPE
+            }
+
+            if (initializationState != InitializationState.SUCCESS) {
+                val context = LocalContext.current
+                LaunchedEffect(Unit) {
+                    googleMapsInitializer.initialize(context)
+                }
+            }
+
             PlaceDetailsComposeTheme {
-                MapScreen()
+                if (initializationState == InitializationState.SUCCESS) {
+                    MapScreen()
+                } else {
+                    Box(
+                        modifier = Modifier.fillMaxSize(),
+                        contentAlignment = Alignment.Center
+                    ) {
+                        CircularProgressIndicator()
+                    }
+                }
             }
         }
     }

PlaceDetailsCompose/app/src/main/java/com/example/placedetailscompose/PlaceDetailsComposeApplication.kt

@@ -0,0 +1,100 @@
+/*
+* Copyright 2025 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.placedetailscompose
+
+import android.app.Application
+import android.content.pm.PackageManager
+import android.util.Log
+import android.widget.Toast
+import java.util.Objects
+import kotlin.text.isBlank
+
+/**
+ * `PlaceDetailsComposeApplication` is a custom Application class.
+ *
+ * This class is responsible for application-wide initialization and setup,
+ * such as checking for the presence and validity of the API key during the
+ * application's startup.
+ *
+ * It extends the [Application] class and overrides the [.onCreate]
+ * method to perform these initialization tasks.
+ */
+class PlaceDetailsComposeApplication : Application() {
+
+    override fun onCreate() {
+        super.onCreate()
+        checkApiKey()
+    }
+
+    /**
+     * Checks if the API key for Google Maps is properly configured in the application's metadata.
+     *
+     * This method retrieves the API key from the application's metadata, specifically looking for
+     * a string value associated with the key "com.google.android.geo.API_KEY".
+     * The key must be present, not blank, and not set to the placeholder value "DEFAULT_API_KEY".
+     *
+     * If any of these checks fail, a Toast message is displayed indicating that the API key is missing or
+     * incorrectly configured, and a RuntimeException is thrown.
+     */
+    private fun checkApiKey() {
+        try {
+            val appInfo =
+                packageManager.getApplicationInfo(packageName, PackageManager.GET_META_DATA)
+            val bundle = Objects.requireNonNull(appInfo.metaData)
+
+            val apiKey =
+                bundle.getString("com.google.android.geo.API_KEY") // Key name is important!
+
+            if (apiKey == null || apiKey.isBlank() || apiKey == "DEFAULT_API_KEY") {
+                Toast.makeText(
+                    this,
+                    "API Key was not set in secrets.properties",
+                    Toast.LENGTH_LONG
+                ).show()
+                throw RuntimeException("API Key was not set in secrets.properties")
+            }
+        } catch (e: PackageManager.NameNotFoundException) {
+            Log.e(TAG, "Package name not found.", e)
+            throw RuntimeException("Error getting package info.", e)
+        } catch (e: NullPointerException) {
+            Log.e(TAG, "Error accessing meta-data.", e) // Handle the case where meta-data is completely missing.
+            throw RuntimeException("Error accessing meta-data in manifest", e)
+        }
+    }
+
+    /**
+     * Retrieves the map ID from the BuildConfig or string resource.
+     *
+     * @return The valid map ID or null if no valid map ID is found.
+     */
+    val mapId: String? by lazy {
+        if (BuildConfig.MAP_ID != "YOUR_MAP_ID") {
+            BuildConfig.MAP_ID
+        } else if (getString(R.string.map_id) != "YOUR_MAP_ID") {
+            getString(R.string.map_id)
+        } else {
+            Log.w(TAG, "Map ID is not set. See README for instructions.")
+            Toast.makeText(this, "Map ID is not set. Some features may not work. See README for instructions.", Toast.LENGTH_LONG)
+                .show()
+            null
+        }
+    }
+
+    companion object {
+        private const val TAG = "ApiDemoApplication"
+    }
+}

PlaceDetailsCompose/app/src/main/java/com/example/placedetailscompose/repository/LocationRepository.kt

@@ -0,0 +1,59 @@
+// Copyright 2025 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.placedetailscompose.repository
+
+import android.annotation.SuppressLint
+import android.content.Context
+import android.location.Location
+import android.os.Looper
+import com.google.android.gms.location.FusedLocationProviderClient
+import com.google.android.gms.location.LocationCallback
+import com.google.android.gms.location.LocationRequest
+import com.google.android.gms.location.LocationResult
+import com.google.android.gms.location.LocationServices
+import com.google.android.gms.location.Priority
+import kotlinx.coroutines.channels.awaitClose
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.callbackFlow
+
+class LocationRepository(context: Context) {
+
+    private val fusedLocationClient: FusedLocationProviderClient =
+        LocationServices.getFusedLocationProviderClient(context)
+
+    @SuppressLint("MissingPermission")
+    fun getDeviceLocation(): Flow<Location> = callbackFlow {
+        val locationRequest = LocationRequest.Builder(Priority.PRIORITY_HIGH_ACCURACY, 10000L)
+            .setWaitForAccurateLocation(false)
+            .setMinUpdateIntervalMillis(5000L)
+            .build()
+
+        val locationCallback = object : LocationCallback() {
+            override fun onLocationResult(locationResult: LocationResult) {
+                locationResult.lastLocation?.let { trySend(it) }
+            }
+        }
+
+        fusedLocationClient.requestLocationUpdates(
+            locationRequest,
+            locationCallback,
+            Looper.getMainLooper()
+        )
+
+        awaitClose {
+            fusedLocationClient.removeLocationUpdates(locationCallback)
+        }
+    }
+}