Migrate Media enhancement, HDR, projection, and spatial audio snippets

gradle/libs.versions.toml

@@ -94,6 +94,7 @@ mockitoKotlin = "5.3.1"
 okHttp = "5.4.0"
 playServicesFitness = "21.3.0"
 playServicesLocation = "21.4.0"
+playServicesMediaEffectEnhancement = "16.0.0-beta04"
 playServicesWearable = "20.0.1"
 playbilling = "9.1.0"
 protobuf = "4.35.1"
@@ -334,6 +335,7 @@ mockito-kotlin = { module = "org.mockito.kotlin:mockito-kotlin", version.ref = "
 okhttp = { module = "com.squareup.okhttp3:okhttp", version.ref = "okHttp" }
 play-services-fitness = { module = "com.google.android.gms:play-services-fitness", version.ref = "playServicesFitness" }
 play-services-location = { module = "com.google.android.gms:play-services-location", version.ref = "playServicesLocation" }
+play-services-media-effect-enhancement = { module = "com.google.android.gms:play-services-media-effect-enhancement", version.ref = "playServicesMediaEffectEnhancement" }
 play-services-wearable = { module = "com.google.android.gms:play-services-wearable", version.ref = "playServicesWearable" }
 reactive-streams = { module = "org.reactivestreams:reactive-streams", version.ref = "reactive-streams" }
 robolectric = { module = "org.robolectric:robolectric", version.ref = "robolectric" }

media/build.gradle.kts

@@ -23,8 +23,19 @@ android {
         sourceCompatibility = JavaVersion.VERSION_17
         targetCompatibility = JavaVersion.VERSION_17
     }
+
+    buildFeatures {
+        viewBinding = true
+    }
 }
 
 dependencies {
+    implementation(libs.androidx.activity.ktx)
+    implementation(libs.androidx.fragment.ktx)
+    implementation(libs.androidx.lifecycle.viewmodel.ktx)
+    implementation(libs.androidx.media3.common)
     implementation(libs.androidx.media3.exoplayer)
+    implementation(libs.kotlinx.coroutines.android)
+    implementation(libs.kotlinx.coroutines.play.services)
+    implementation(libs.play.services.media.effect.enhancement)
 }

media/src/main/java/com/example/media/BitmapModeLifecycle.kt

@@ -0,0 +1,218 @@
+/*
+ * Copyright 2026 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.example.media
+
+import android.app.Application
+import android.graphics.Bitmap
+import androidx.lifecycle.AndroidViewModel
+import androidx.lifecycle.viewModelScope
+import com.google.android.gms.common.api.Status
+import com.google.android.gms.media.effect.enhancement.Enhancement
+import com.google.android.gms.media.effect.enhancement.EnhancementCallback
+import com.google.android.gms.media.effect.enhancement.EnhancementClient
+import com.google.android.gms.media.effect.enhancement.EnhancementMode
+import com.google.android.gms.media.effect.enhancement.EnhancementOptions
+import com.google.android.gms.media.effect.enhancement.EnhancementSession
+import com.google.android.gms.media.effect.enhancement.EnhancementSessionCallback
+import java.util.concurrent.Executor
+import java.util.concurrent.Executors
+import kotlin.coroutines.resume
+import kotlin.coroutines.resumeWithException
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.asStateFlow
+import kotlinx.coroutines.flow.update
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.suspendCancellableCoroutine
+import kotlinx.coroutines.tasks.await
+import kotlinx.coroutines.withContext
+
+// [START android_media_ai_enhancement_bitmap_initialize_engine]
+class MediaSetupViewModel(application: Application) : AndroidViewModel(application) {
+    private val enhancementClient = Enhancement.getClient(application)
+    fun initializeEnhancementEngine() {
+        viewModelScope.launch {
+            try {
+                // 1. Verify hardware capability.
+                val isSupported = enhancementClient.isDeviceSupportedAsync()
+                if (!isSupported) {
+                    notifyUiDeviceIncompatible()
+                    return@launch
+                }
+                // 2. Verify and download the Google Play services ML modules.
+                val isInstalled = enhancementClient.isModuleInstalledAsync()
+                if (!isInstalled) {
+                    notifyUiDownloadingModels()
+                    enhancementClient.installModule(installStatusCallback).await()
+                }
+                notifyUiEngineReady()
+            } catch (e: Exception) {
+
+                // Handle potential errors during session creation or image processing.
+                handleInitializationError(e)
+            }
+        }
+    }
+}
+// [END android_media_ai_enhancement_bitmap_initialize_engine]
+
+// [START android_media_ai_enhancement_bitmap_wrappers]
+// Wraps the task-based createSession callback into a suspending function.
+suspend fun EnhancementClient.createSessionAsync(
+    options: EnhancementOptions,
+    executor: Executor
+): EnhancementSession = withContext(Dispatchers.Main) {
+    suspendCancellableCoroutine { continuation ->
+
+        // EnhancementSessionCallback handles session success or failure.
+        val callback = object : EnhancementSessionCallback {
+            override fun onSessionCreated(session: EnhancementSession) {
+                continuation.resume(session)
+            }
+            override fun onSessionCreationFailed(status: Status) {
+                continuation.resumeWithException(
+                    Exception("Session creation failed: ${status.statusMessage} (${status.statusCode})")
+                )
+            }
+            override fun onSessionDestroyed() {}
+            override fun onSessionDisconnected(status: Status) {}
+        }
+
+        // Handles errors during the initial request trigger.
+        createSession(options, callback).addOnFailureListener(executor) { e ->
+            if (continuation.isActive) {
+                continuation.resumeWithException(e)
+            }
+        }
+    }
+}
+
+// Wraps this process in a suspending function for cleaner execution.
+suspend fun EnhancementSession.processBitmapAsync(
+    bitmap: Bitmap,
+    options: EnhancementOptions
+): Bitmap = suspendCancellableCoroutine { continuation ->
+
+    // EnhancementCallback returns the processed bitmap or an error code.
+    val callback = object : EnhancementCallback {
+        override fun onBitmapProcessed(enhancedBitmap: Bitmap) {
+            continuation.resume(enhancedBitmap)
+        }
+        override fun onError(statusCode: Int) {
+            continuation.resumeWithException(
+                Exception("Bitmap processing failed with status code: $statusCode")
+            )
+        }
+        override fun onSurfaceProcessed(timestamp: Long) {}
+    }
+    this.process(bitmap, options, callback)
+}
+// [END android_media_ai_enhancement_bitmap_wrappers]
+
+// [START android_media_ai_enhancement_bitmap_viewmodel]
+// Define a data class to hold image information.
+data class ImageInfo(val bitmap: Bitmap)
+// Define a UI state class to hold loading status, errors, and enhanced image.
+data class EnhancementUiState(
+    val isLoading: Boolean = false,
+    val enhancementError: String? = null,
+    val enhancedImage: ImageInfo? = null
+)
+
+class EnhancementViewModel(application: Application) : AndroidViewModel(application) {
+
+    // Backing field for UI state, initialized with default values.
+    private val _uiState = MutableStateFlow(EnhancementUiState())
+    // Publicly exposed UI state flow for observation.
+    val uiState: StateFlow<EnhancementUiState> = _uiState.asStateFlow()
+
+    // Initialize client to interact with the Media Enhancement service.
+    private val enhancementClient: EnhancementClient = Enhancement.getClient(application)
+
+    // Single-thread executor for processing background enhancement tasks.
+    private val enhancementExecutor = Executors.newSingleThreadExecutor()
+
+    // Track session state to enable reuse across multiple processing calls.
+    private var enhancementSession: EnhancementSession? = null
+
+    // Primary function to trigger the enhancement workflow for a provided bitmap.
+    fun enhanceImage(bitmap: Bitmap) {
+        viewModelScope.launch(Dispatchers.IO) {
+            _uiState.update { it.copy(isLoading = true, enhancementError = null) }
+            try {
+                // 1. Establish the session lazily on demand.
+
+                // Define enhancement options (for example, enable upscale, tonemapping) based
+                // on bitmap dimensions.
+                val options = EnhancementOptions(
+                    bitmap.width,
+                    bitmap.height,
+                    EnhancementMode.BITMAP,
+                    isTonemappingEnabled = true,
+                    isDeblurAndDenoisePhotoEnabled = true,
+                    isDeblurAndDenoiseVideoEnabled = false,
+                    isUpscalePhotoEnabled = false,
+                    isUpscaleVideoEnabled = false,
+                )
+                if (enhancementSession == null) {
+                    enhancementSession = enhancementClient.createSessionAsync(options, enhancementExecutor)
+                }
+                val session = enhancementSession ?: throw IllegalStateException("Session unavailable.")
+                // 2. Dispatch image through the neural pipeline.
+                val enhancedBitmap = session.processBitmapAsync(bitmap, options)
+                // 3. Render output to UI.
+                _uiState.update {
+                    it.copy(enhancedImage = ImageInfo(bitmap = enhancedBitmap))
+                }
+            } catch (e: Exception) {
+                _uiState.update { it.copy(enhancementError = e.message) }
+            } finally {
+
+                // Ensure loading state is reset regardless of the outcome.
+                _uiState.update { it.copy(isLoading = false) }
+            }
+        }
+    }
+    override fun onCleared() {
+        // 4. Critical: Release native GPU hardware resources.
+        enhancementSession?.release()
+        enhancementSession = null
+        enhancementExecutor.shutdown()
+        super.onCleared()
+    }
+}
+// [END android_media_ai_enhancement_bitmap_viewmodel]
+
+private val installStatusCallback = object : EnhancementClient.InstallStatusCallback {
+    override fun onError(description: String) {}
+    override fun onCancelled() {}
+    override fun onDownloadProgressUpdate(progress: Int) {}
+    override fun onDownloadPending() {}
+    override fun onDownloadStart() {}
+    override fun onDownloadPaused() {}
+    override fun onDownloadComplete() {}
+    override fun onInstalled() {}
+}
+
+private fun notifyUiDeviceIncompatible() {}
+
+private fun notifyUiDownloadingModels() {}
+
+private fun notifyUiEngineReady() {}
+
+private fun handleInitializationError(e: Exception) {}

media/src/main/java/com/example/media/GetStartedEnhancement.kt

@@ -0,0 +1,37 @@
+/*
+ * Copyright 2026 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.example.media
+
+import com.google.android.gms.media.effect.enhancement.EnhancementClient
+import kotlin.coroutines.resume
+import kotlin.coroutines.resumeWithException
+import kotlinx.coroutines.suspendCancellableCoroutine
+
+// [START android_media_ai_enhancement_get_started_checks]
+// Verifies if host hardware supports NPU/GPU acceleration.
+suspend fun EnhancementClient.isDeviceSupportedAsync(): Boolean = suspendCancellableCoroutine { continuation ->
+    this.isDeviceSupported()
+        .addOnSuccessListener { result -> continuation.resume(result) }
+        .addOnFailureListener { exception -> continuation.resumeWithException(exception) }
+}
+// Verifies the presence of required neural network models.
+suspend fun EnhancementClient.isModuleInstalledAsync(): Boolean = suspendCancellableCoroutine { continuation ->
+    this.isModuleInstalled()
+        .addOnSuccessListener { result -> continuation.resume(result) }
+        .addOnFailureListener { exception -> continuation.resumeWithException(exception) }
+}
+// [END android_media_ai_enhancement_get_started_checks]

media/src/main/java/com/example/media/HdrLut.kt

@@ -0,0 +1,35 @@
+/*
+ * Copyright 2026 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.example.media
+
+import android.hardware.DisplayLuts
+import android.hardware.LutProperties
+import android.view.SurfaceControl
+
+private fun applyLutExample() {
+    // [START android_media_hdr_lut_apply]
+    val sc = SurfaceControl.Builder().build()
+    val luts = DisplayLuts()
+    val entry = DisplayLuts.Entry(
+        floatArrayOf(0.5f, 0.5f, 0.5f, 0.5f),
+        LutProperties.ONE_DIMENSION,
+        LutProperties.SAMPLING_KEY_MAX_RGB
+    )
+    luts.set(entry)
+    SurfaceControl.Transaction().setLuts(sc, luts).apply()
+    // [END android_media_hdr_lut_apply]
+}