Merge branch 'main' into nav-cujs

Author: wardlauren

compose/snippets/src/main/java/com/example/compose/snippets/animations/AnimationSnippets.kt

@@ -280,14 +280,15 @@ private fun AnimateAsStateSimple() {
     // [START android_compose_animations_animate_as_state]
     var enabled by remember { mutableStateOf(true) }
 
-    val alpha: Float by animateFloatAsState(if (enabled) 1f else 0.5f, label = "alpha")
+    val animatedAlpha: Float by animateFloatAsState(if (enabled) 1f else 0.5f, label = "alpha")
     Box(
         Modifier
             .fillMaxSize()
-            .graphicsLayer(alpha = alpha)
+            .graphicsLayer { alpha = animatedAlpha }
             .background(Color.Red)
     )
     // [END android_compose_animations_animate_as_state]
+    { Button(onClick = { enabled = !enabled }) { Text("Animate me!") } }
 }
 
 @Preview

gradle/libs.versions.toml

@@ -27,6 +27,7 @@ androidx-window-java = "1.3.0"
 androidxHiltNavigationCompose = "1.2.0"
 appcompat = "1.7.0"
 coil = "2.7.0"
+android-googleid = "1.1.1"
 # @keep
 compileSdk = "35"
 compose-latest = "1.7.8"
@@ -135,6 +136,7 @@ androidx-window = { module = "androidx.window:window", version.ref = "androidx-w
 androidx-window-core = { module = "androidx.window:window-core", version.ref = "androidx-window-core" }
 androidx-window-java = {module = "androidx.window:window-java", version.ref = "androidx-window-java" }
 androidx-work-runtime-ktx = "androidx.work:work-runtime-ktx:2.10.0"
+android-identity-googleid = {module = "com.google.android.libraries.identity.googleid:googleid", version.ref = "android-googleid"}
 appcompat = { module = "androidx.appcompat:appcompat", version.ref = "appcompat" }
 coil-kt-compose = { module = "io.coil-kt:coil-compose", version.ref = "coil" }
 compose-foundation = { module = "androidx.wear.compose:compose-foundation", version.ref = "wearComposeFoundation" }

identity/credentialmanager/build.gradle.kts

@@ -55,6 +55,11 @@ dependencies {
     // Android 13 and below.
     implementation(libs.androidx.credentials.play.services.auth)
     // [END android_identity_gradle_dependencies]
+    // [START android_identity_siwg_gradle_dependencies]
+    implementation(libs.androidx.credentials)
+    implementation(libs.androidx.credentials.play.services.auth)
+    implementation(libs.android.identity.googleid)
+    // [END android_identity_siwg_gradle_dependencies]
     debugImplementation(libs.androidx.compose.ui.tooling)
     debugImplementation(libs.androidx.compose.ui.test.manifest)
 }

identity/credentialmanager/src/main/java/com/example/identity/credentialmanager/PasskeyAndPasswordFunctions.kt

@@ -22,6 +22,8 @@ import android.os.Build
 import android.os.Bundle
 import android.util.Log
 import androidx.annotation.RequiresApi
+import androidx.credentials.CreatePasswordRequest
+import androidx.credentials.CreatePublicKeyCredentialRequest
 import androidx.credentials.CredentialManager
 import androidx.credentials.CustomCredential
 import androidx.credentials.GetCredentialRequest
@@ -30,7 +32,14 @@ import androidx.credentials.GetPasswordOption
 import androidx.credentials.GetPublicKeyCredentialOption
 import androidx.credentials.PasswordCredential
 import androidx.credentials.PublicKeyCredential
+import androidx.credentials.exceptions.CreateCredentialCancellationException
+import androidx.credentials.exceptions.CreateCredentialCustomException
+import androidx.credentials.exceptions.CreateCredentialException
+import androidx.credentials.exceptions.CreateCredentialInterruptedException
+import androidx.credentials.exceptions.CreateCredentialProviderConfigurationException
+import androidx.credentials.exceptions.CreateCredentialUnknownException
 import androidx.credentials.exceptions.GetCredentialException
+import androidx.credentials.exceptions.publickeycredential.CreatePublicKeyCredentialDomException
 import kotlinx.coroutines.coroutineScope
 import kotlinx.coroutines.runBlocking
 import org.json.JSONObject
@@ -43,6 +52,7 @@ class PasskeyAndPasswordFunctions (
   // CredentialManager.
   private val credentialManager = CredentialManager.create(context)
   // [END android_identity_initialize_credman]
+  private val activityContext = context
 
   // Placeholder for TAG log value.
   val TAG = ""
@@ -55,8 +65,7 @@ class PasskeyAndPasswordFunctions (
    */
   @RequiresApi(Build.VERSION_CODES.UPSIDE_DOWN_CAKE)
   fun signInFlow(
-    creationResult: JSONObject,
-    activityContext: Context,
+    creationResult: JSONObject
   ) {
     val requestJson = creationResult.toString()
     // [START android_identity_get_password_passkey_options]
@@ -166,6 +175,93 @@ class PasskeyAndPasswordFunctions (
     }
   }
   // [END android_identity_launch_sign_in_flow_2]
+
+  // [START android_identity_create_passkey]
+  suspend fun createPasskey(requestJson: String, preferImmediatelyAvailableCredentials: Boolean) {
+    val createPublicKeyCredentialRequest = CreatePublicKeyCredentialRequest(
+      // Contains the request in JSON format. Uses the standard WebAuthn
+      // web JSON spec.
+      requestJson = requestJson,
+      // Defines whether you prefer to use only immediately available
+      // credentials, not hybrid credentials, to fulfill this request.
+      // This value is false by default.
+      preferImmediatelyAvailableCredentials = preferImmediatelyAvailableCredentials,
+    )
+
+    // Execute CreateCredentialRequest asynchronously to register credentials
+    // for a user account. Handle success and failure cases with the result and
+    // exceptions, respectively.
+    coroutineScope {
+      try {
+        val result = credentialManager.createCredential(
+          // Use an activity-based context to avoid undefined system
+          // UI launching behavior
+          context = activityContext,
+          request = createPublicKeyCredentialRequest,
+        )
+        //  Handle passkey creation result
+      } catch (e : CreateCredentialException){
+        handleFailure(e)
+      }
+    }
+  }
+  // [END android_identity_create_passkey]
+
+  // [START android_identity_handle_create_passkey_failure]
+  fun handleFailure(e: CreateCredentialException) {
+    when (e) {
+      is CreatePublicKeyCredentialDomException -> {
+        // Handle the passkey DOM errors thrown according to the
+        // WebAuthn spec.
+      }
+      is CreateCredentialCancellationException -> {
+        // The user intentionally canceled the operation and chose not
+        // to register the credential.
+      }
+      is CreateCredentialInterruptedException -> {
+        // Retry-able error. Consider retrying the call.
+      }
+      is CreateCredentialProviderConfigurationException -> {
+        // Your app is missing the provider configuration dependency.
+        // Most likely, you're missing the
+        // "credentials-play-services-auth" module.
+      }
+      is CreateCredentialCustomException -> {
+        // You have encountered an error from a 3rd-party SDK. If you
+        // make the API call with a request object that's a subclass of
+        // CreateCustomCredentialRequest using a 3rd-party SDK, then you
+        // should check for any custom exception type constants within
+        // that SDK to match with e.type. Otherwise, drop or log the
+        // exception.
+      }
+      else -> Log.w(TAG, "Unexpected exception type ${e::class.java.name}")
+    }
+  }
+  // [END android_identity_handle_create_passkey_failure]
+
+  // [START android_identity_register_password]
+  suspend fun registerPassword(username: String, password: String) {
+    // Initialize a CreatePasswordRequest object.
+    val createPasswordRequest =
+      CreatePasswordRequest(id = username, password = password)
+
+    // Create credential and handle result.
+    coroutineScope {
+      try {
+        val result =
+          credentialManager.createCredential(
+            // Use an activity based context to avoid undefined
+            // system UI launching behavior.
+            activityContext,
+            createPasswordRequest
+          )
+        // Handle register password result
+      } catch (e: CreateCredentialException) {
+        handleFailure(e)
+      }
+    }
+  }
+  // [END android_identity_register_password]
 }
 
 sealed class ExampleCustomCredential {

identity/credentialmanager/src/main/java/com/example/identity/credentialmanager/RestoreCredentialsFunctions.kt

@@ -0,0 +1,70 @@
+/*
+ * Copyright 2025 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.identity.credentialmanager
+
+import android.content.Context
+import androidx.credentials.ClearCredentialStateRequest
+import androidx.credentials.ClearCredentialStateRequest.Companion.TYPE_CLEAR_RESTORE_CREDENTIAL
+import androidx.credentials.CreateRestoreCredentialRequest
+import androidx.credentials.CredentialManager
+import androidx.credentials.GetCredentialRequest
+import androidx.credentials.GetRestoreCredentialOption
+
+class RestoreCredentialsFunctions(
+    private val context: Context,
+    private val credentialManager: CredentialManager,
+) {
+    suspend fun createRestoreKey(
+        createRestoreRequest: CreateRestoreCredentialRequest
+    ) {
+        // [START android_identity_restore_cred_create]
+        val credentialManager = CredentialManager.create(context)
+
+        // On a successful authentication create a Restore Key
+        // Pass in the context and CreateRestoreCredentialRequest object
+        val response = credentialManager.createCredential(context, createRestoreRequest)
+        // [END android_identity_restore_cred_create]
+    }
+
+    suspend fun getRestoreKey(
+        fetchAuthenticationJson: () -> String,
+    ) {
+        // [START android_identity_restore_cred_get]
+        // Fetch the Authentication JSON from server
+        val authenticationJson = fetchAuthenticationJson()
+
+        // Create the GetRestoreCredentialRequest object
+        val options = GetRestoreCredentialOption(authenticationJson)
+        val getRequest = GetCredentialRequest(listOf(options))
+
+        // The restore key can be fetched in two scenarios to
+        // 1. On the first launch of app on the device, fetch the Restore Key
+        // 2. In the onRestore callback (if the app implements the Backup Agent)
+        val response = credentialManager.getCredential(context, getRequest)
+        // [END android_identity_restore_cred_get]
+    }
+
+    suspend fun deleteRestoreKey() {
+        // [START android_identity_restore_cred_delete]
+        // Create a ClearCredentialStateRequest object
+        val clearRequest = ClearCredentialStateRequest(TYPE_CLEAR_RESTORE_CREDENTIAL)
+
+        // On user log-out, clear the restore key
+        val response = credentialManager.clearCredentialState(clearRequest)
+        // [END android_identity_restore_cred_delete]
+    }
+}