react-native-credentials-manager 0.2.1 → 0.4.0

package/README.md

@@ -1,14 +1,16 @@
 # react-native-credentials-manager
 
+> 📚 **Documentation has moved!** The complete documentation is now available at [https://docs.benjamineruvieru.com/docs/react-native-credentials-manager/](https://docs.benjamineruvieru.com/docs/react-native-credentials-manager/)
+
 A React Native library that implements the [Credential Manager API](https://developer.android.com/identity/sign-in/credential-manager) for Android. This library allows you to manage passwords and passkeys in your React Native applications.
 
-> ⚠️ **Note**: This library is actively under development. iOS support using Authentication Services is coming soon. Support for the old React Native architecture is also in progress. Google Sign-In integration with Credential Manager will be added shortly.
+> ⚠️ **Note**: This library is actively under development. iOS support using Authentication Services is coming soon. ~~Support for the old React Native architecture is also in progress.~~ Supports old architecture now. ~~Google Sign-In integration with Credential Manager will be added shortly.~~ Google Sign-In is now supported.
 
 ## Features
 
 - ✨ Passkey Authentication
 - 🔐 Password Credential Management
-- 📱 Google Signing (coming soon)
+- 📱 Google Signing
 - 🤖 [iOS Authentication Services](https://developer.apple.com/documentation/authenticationservices?language=objc) (coming soon)
 
 ## Installation
@@ -225,6 +227,66 @@ try {
 }
 ```
 
+### [Google Sign-In](https://developer.android.com/identity/sign-in/credential-manager-siwg#instantiate-google)
+
+**Function**: `signInWithGoogle(params)`
+
+**Description**: Authenticates users using Google Sign-In through the Credential Manager.
+
+**Parameters**:
+
+| Parameter           | Type      | Description                                                                 |
+| ------------------- | --------- | --------------------------------------------------------------------------- |
+| `serverClientId`    | `string`  | Your application's web client ID from the Google Cloud Console              |
+| `nonce`             | `string?` | Optional nonce for additional security                                      |
+| `autoSelectEnabled` | `boolean` | Whether to automatically select the Google account if only one is available |
+
+**Example**:
+
+```typescript
+import { signInWithGoogle } from 'react-native-credentials-manager';
+
+try {
+  const credential = await signInWithGoogle({
+    serverClientId: 'YOUR_WEB_CLIENT_ID',
+    autoSelectEnabled: true,
+  });
+
+  if (credential.type === 'google-signin') {
+    console.log('Google credentials:', {
+      id: credential.id,
+      idToken: credential.idToken,
+      displayName: credential.displayName,
+      familyName: credential.familyName,
+      givenName: credential.givenName,
+      profilePicture: credential.profilePicture,
+      phoneNumber: credential.phoneNumber,
+    });
+  }
+} catch (error) {
+  console.error('Google Sign-In failed:', error);
+}
+```
+
+### Sign Out
+
+Function : signOut()
+
+Description : Signs out the current user and clears credentials.
+
+Example :
+
+```typescript
+import { signOut } from 'react-native-credentials-manager';
+
+try {
+  await signOut();
+  console.log('Successfully signed out');
+} catch (error) {
+  console.error('Sign out failed:', error);
+}
+```
+
 ## Documentation
 
 For more detailed information about the underlying APIs, refer to:
@@ -236,7 +298,7 @@ For more detailed information about the underlying APIs, refer to:
 
 ## Roadmap
 
-- Old Architecture Support
+- ~~Old Architecture Support~~ ✅
 - iOS Support using [Authentication Services](https://developer.apple.com/documentation/authenticationservices?language=objc)
 - Additional Authentication Methods
 - Comprehensive Documentation

package/android/build.gradle

@@ -79,16 +79,15 @@ android {
     targetCompatibility JavaVersion.VERSION_1_8
   }
 
-  sourceSets {
-    main {
-      if (isNewArchitectureEnabled()) {
-          java.srcDirs += [
-            "generated/java",
-            "generated/jni"
-          ]
-      }
+ sourceSets {
+       main {
+            if (isNewArchitectureEnabled()) {
+                java.srcDirs += ['src/newarch',"generated/java",]
+            } else {
+                java.srcDirs += ['src/oldarch']
+            }
+        }
     }
-  }
 }
 
 repositories {
@@ -105,6 +104,7 @@ dependencies {
     implementation "androidx.credentials:credentials-play-services-auth:1.5.0-rc01"
     implementation "org.jetbrains.kotlinx:kotlinx-coroutines-core:1.6.4"
     implementation "org.jetbrains.kotlinx:kotlinx-coroutines-android:1.6.4"
+     implementation "com.google.android.libraries.identity.googleid:googleid:1.1.1"
 }
 
 if (isNewArchitectureEnabled()) {

package/android/generated/java/com/credentialsmanager/NativeCredentialsManagerSpec.java

@@ -44,4 +44,12 @@ public abstract class NativeCredentialsManagerSpec extends ReactContextBaseJavaM
   @ReactMethod
   @DoNotStrip
   public abstract void signInWithSavedCredentials(ReadableMap requestJson, Promise promise);
+
+  @ReactMethod
+  @DoNotStrip
+  public abstract void signInWithGoogle(ReadableMap params, Promise promise);
+
+  @ReactMethod
+  @DoNotStrip
+  public abstract void signOut(Promise promise);
 }

package/android/generated/jni/RNCredentialsManagerSpec-generated.cpp

@@ -27,11 +27,23 @@ static facebook::jsi::Value __hostFunction_NativeCredentialsManagerSpecJSI_signI
   return static_cast<JavaTurboModule &>(turboModule).invokeJavaMethod(rt, PromiseKind, "signInWithSavedCredentials", "(Lcom/facebook/react/bridge/ReadableMap;Lcom/facebook/react/bridge/Promise;)V", args, count, cachedMethodId);
 }
 
+static facebook::jsi::Value __hostFunction_NativeCredentialsManagerSpecJSI_signInWithGoogle(facebook::jsi::Runtime& rt, TurboModule &turboModule, const facebook::jsi::Value* args, size_t count) {
+  static jmethodID cachedMethodId = nullptr;
+  return static_cast<JavaTurboModule &>(turboModule).invokeJavaMethod(rt, PromiseKind, "signInWithGoogle", "(Lcom/facebook/react/bridge/ReadableMap;Lcom/facebook/react/bridge/Promise;)V", args, count, cachedMethodId);
+}
+
+static facebook::jsi::Value __hostFunction_NativeCredentialsManagerSpecJSI_signOut(facebook::jsi::Runtime& rt, TurboModule &turboModule, const facebook::jsi::Value* args, size_t count) {
+  static jmethodID cachedMethodId = nullptr;
+  return static_cast<JavaTurboModule &>(turboModule).invokeJavaMethod(rt, PromiseKind, "signOut", "(Lcom/facebook/react/bridge/Promise;)V", args, count, cachedMethodId);
+}
+
 NativeCredentialsManagerSpecJSI::NativeCredentialsManagerSpecJSI(const JavaTurboModule::InitParams &params)
   : JavaTurboModule(params) {
   methodMap_["signUpWithPasskeys"] = MethodMetadata {2, __hostFunction_NativeCredentialsManagerSpecJSI_signUpWithPasskeys};
   methodMap_["signUpWithPassword"] = MethodMetadata {1, __hostFunction_NativeCredentialsManagerSpecJSI_signUpWithPassword};
   methodMap_["signInWithSavedCredentials"] = MethodMetadata {1, __hostFunction_NativeCredentialsManagerSpecJSI_signInWithSavedCredentials};
+  methodMap_["signInWithGoogle"] = MethodMetadata {1, __hostFunction_NativeCredentialsManagerSpecJSI_signInWithGoogle};
+  methodMap_["signOut"] = MethodMetadata {0, __hostFunction_NativeCredentialsManagerSpecJSI_signOut};
 }
 
 std::shared_ptr<TurboModule> RNCredentialsManagerSpec_ModuleProvider(const std::string &moduleName, const JavaTurboModule::InitParams &params) {

package/android/generated/jni/react/renderer/components/RNCredentialsManagerSpec/RNCredentialsManagerSpecJSI-generated.cpp

@@ -31,12 +31,25 @@ static jsi::Value __hostFunction_NativeCredentialsManagerCxxSpecJSI_signInWithSa
     count <= 0 ? throw jsi::JSError(rt, "Expected argument in position 0 to be passed") : args[0].asObject(rt)
   );
 }
+static jsi::Value __hostFunction_NativeCredentialsManagerCxxSpecJSI_signInWithGoogle(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value* args, size_t count) {
+  return static_cast<NativeCredentialsManagerCxxSpecJSI *>(&turboModule)->signInWithGoogle(
+    rt,
+    count <= 0 ? throw jsi::JSError(rt, "Expected argument in position 0 to be passed") : args[0].asObject(rt)
+  );
+}
+static jsi::Value __hostFunction_NativeCredentialsManagerCxxSpecJSI_signOut(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value* args, size_t count) {
+  return static_cast<NativeCredentialsManagerCxxSpecJSI *>(&turboModule)->signOut(
+    rt
+  );
+}
 
 NativeCredentialsManagerCxxSpecJSI::NativeCredentialsManagerCxxSpecJSI(std::shared_ptr<CallInvoker> jsInvoker)
   : TurboModule("CredentialsManager", jsInvoker) {
   methodMap_["signUpWithPasskeys"] = MethodMetadata {2, __hostFunction_NativeCredentialsManagerCxxSpecJSI_signUpWithPasskeys};
   methodMap_["signUpWithPassword"] = MethodMetadata {1, __hostFunction_NativeCredentialsManagerCxxSpecJSI_signUpWithPassword};
   methodMap_["signInWithSavedCredentials"] = MethodMetadata {1, __hostFunction_NativeCredentialsManagerCxxSpecJSI_signInWithSavedCredentials};
+  methodMap_["signInWithGoogle"] = MethodMetadata {1, __hostFunction_NativeCredentialsManagerCxxSpecJSI_signInWithGoogle};
+  methodMap_["signOut"] = MethodMetadata {0, __hostFunction_NativeCredentialsManagerCxxSpecJSI_signOut};
 }
 
 

package/android/generated/jni/react/renderer/components/RNCredentialsManagerSpec/RNCredentialsManagerSpecJSI.h

@@ -62,6 +62,106 @@ struct NativeCredentialsManagerCredObjectBridging {
   }
 };
 
+
+
+#pragma mark - NativeCredentialsManagerGoogleCredential
+
+template <typename P0, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7>
+struct NativeCredentialsManagerGoogleCredential {
+  P0 type;
+  P1 id;
+  P2 idToken;
+  P3 displayName;
+  P4 familyName;
+  P5 givenName;
+  P6 profilePicture;
+  P7 phoneNumber;
+  bool operator==(const NativeCredentialsManagerGoogleCredential &other) const {
+    return type == other.type && id == other.id && idToken == other.idToken && displayName == other.displayName && familyName == other.familyName && givenName == other.givenName && profilePicture == other.profilePicture && phoneNumber == other.phoneNumber;
+  }
+};
+
+template <typename T>
+struct NativeCredentialsManagerGoogleCredentialBridging {
+  static T types;
+
+  static T fromJs(
+      jsi::Runtime &rt,
+      const jsi::Object &value,
+      const std::shared_ptr<CallInvoker> &jsInvoker) {
+    T result{
+      bridging::fromJs<decltype(types.type)>(rt, value.getProperty(rt, "type"), jsInvoker),
+      bridging::fromJs<decltype(types.id)>(rt, value.getProperty(rt, "id"), jsInvoker),
+      bridging::fromJs<decltype(types.idToken)>(rt, value.getProperty(rt, "idToken"), jsInvoker),
+      bridging::fromJs<decltype(types.displayName)>(rt, value.getProperty(rt, "displayName"), jsInvoker),
+      bridging::fromJs<decltype(types.familyName)>(rt, value.getProperty(rt, "familyName"), jsInvoker),
+      bridging::fromJs<decltype(types.givenName)>(rt, value.getProperty(rt, "givenName"), jsInvoker),
+      bridging::fromJs<decltype(types.profilePicture)>(rt, value.getProperty(rt, "profilePicture"), jsInvoker),
+      bridging::fromJs<decltype(types.phoneNumber)>(rt, value.getProperty(rt, "phoneNumber"), jsInvoker)};
+    return result;
+  }
+
+#ifdef DEBUG
+  static jsi::String typeToJs(jsi::Runtime &rt, decltype(types.type) value) {
+    return bridging::toJs(rt, value);
+  }
+
+  static jsi::String idToJs(jsi::Runtime &rt, decltype(types.id) value) {
+    return bridging::toJs(rt, value);
+  }
+
+  static jsi::String idTokenToJs(jsi::Runtime &rt, decltype(types.idToken) value) {
+    return bridging::toJs(rt, value);
+  }
+
+  static jsi::String displayNameToJs(jsi::Runtime &rt, decltype(types.displayName) value) {
+    return bridging::toJs(rt, value);
+  }
+
+  static jsi::String familyNameToJs(jsi::Runtime &rt, decltype(types.familyName) value) {
+    return bridging::toJs(rt, value);
+  }
+
+  static jsi::String givenNameToJs(jsi::Runtime &rt, decltype(types.givenName) value) {
+    return bridging::toJs(rt, value);
+  }
+
+  static jsi::String profilePictureToJs(jsi::Runtime &rt, decltype(types.profilePicture) value) {
+    return bridging::toJs(rt, value);
+  }
+
+  static jsi::String phoneNumberToJs(jsi::Runtime &rt, decltype(types.phoneNumber) value) {
+    return bridging::toJs(rt, value);
+  }
+#endif
+
+  static jsi::Object toJs(
+      jsi::Runtime &rt,
+      const T &value,
+      const std::shared_ptr<CallInvoker> &jsInvoker) {
+    auto result = facebook::jsi::Object(rt);
+    result.setProperty(rt, "type", bridging::toJs(rt, value.type, jsInvoker));
+    result.setProperty(rt, "id", bridging::toJs(rt, value.id, jsInvoker));
+    result.setProperty(rt, "idToken", bridging::toJs(rt, value.idToken, jsInvoker));
+    if (value.displayName) {
+      result.setProperty(rt, "displayName", bridging::toJs(rt, value.displayName.value(), jsInvoker));
+    }
+    if (value.familyName) {
+      result.setProperty(rt, "familyName", bridging::toJs(rt, value.familyName.value(), jsInvoker));
+    }
+    if (value.givenName) {
+      result.setProperty(rt, "givenName", bridging::toJs(rt, value.givenName.value(), jsInvoker));
+    }
+    if (value.profilePicture) {
+      result.setProperty(rt, "profilePicture", bridging::toJs(rt, value.profilePicture.value(), jsInvoker));
+    }
+    if (value.phoneNumber) {
+      result.setProperty(rt, "phoneNumber", bridging::toJs(rt, value.phoneNumber.value(), jsInvoker));
+    }
+    return result;
+  }
+};
+
 class JSI_EXPORT NativeCredentialsManagerCxxSpecJSI : public TurboModule {
 protected:
   NativeCredentialsManagerCxxSpecJSI(std::shared_ptr<CallInvoker> jsInvoker);
@@ -70,6 +170,8 @@ public:
   virtual jsi::Value signUpWithPasskeys(jsi::Runtime &rt, jsi::Object requestJson, bool preferImmediatelyAvailableCredentials) = 0;
   virtual void signUpWithPassword(jsi::Runtime &rt, jsi::Object credObject) = 0;
   virtual jsi::Value signInWithSavedCredentials(jsi::Runtime &rt, jsi::Object requestJson) = 0;
+  virtual jsi::Value signInWithGoogle(jsi::Runtime &rt, jsi::Object params) = 0;
+  virtual jsi::Value signOut(jsi::Runtime &rt) = 0;
 
 };
 
@@ -124,6 +226,22 @@ private:
       return bridging::callFromJs<jsi::Value>(
           rt, &T::signInWithSavedCredentials, jsInvoker_, instance_, std::move(requestJson));
     }
+    jsi::Value signInWithGoogle(jsi::Runtime &rt, jsi::Object params) override {
+      static_assert(
+          bridging::getParameterCount(&T::signInWithGoogle) == 2,
+          "Expected signInWithGoogle(...) to have 2 parameters");
+
+      return bridging::callFromJs<jsi::Value>(
+          rt, &T::signInWithGoogle, jsInvoker_, instance_, std::move(params));
+    }
+    jsi::Value signOut(jsi::Runtime &rt) override {
+      static_assert(
+          bridging::getParameterCount(&T::signOut) == 1,
+          "Expected signOut(...) to have 1 parameters");
+
+      return bridging::callFromJs<jsi::Value>(
+          rt, &T::signOut, jsInvoker_, instance_);
+    }
 
   private:
     friend class NativeCredentialsManagerCxxSpec;

package/android/src/main/java/com/credentialsmanager/CredentialsManagerModuleImpl.kt

@@ -0,0 +1,7 @@
+package com.credentialsmanager
+
+class CredentialsManagerModuleImpl {
+  companion object {
+    const val NAME = "CredentialsManager"
+  }
+}

package/android/src/main/java/com/credentialsmanager/CredentialsManagerPackage.kt

@@ -12,7 +12,7 @@ class CredentialsManagerPackage : BaseReactPackage() {
     name: String,
     reactContext: ReactApplicationContext,
   ): NativeModule? =
-    if (name == CredentialsManagerModule.NAME) {
+    if (name == CredentialsManagerModuleImpl.NAME) {
       CredentialsManagerModule(reactContext)
     } else {
       null
@@ -21,14 +21,15 @@ class CredentialsManagerPackage : BaseReactPackage() {
   override fun getReactModuleInfoProvider(): ReactModuleInfoProvider =
     ReactModuleInfoProvider {
       val moduleInfos: MutableMap<String, ReactModuleInfo> = HashMap()
-      moduleInfos[CredentialsManagerModule.NAME] =
+      val isTurboModule = BuildConfig.IS_NEW_ARCHITECTURE_ENABLED
+      moduleInfos[CredentialsManagerModuleImpl.NAME] =
         ReactModuleInfo(
-          CredentialsManagerModule.NAME,
-          CredentialsManagerModule.NAME,
+          CredentialsManagerModuleImpl.NAME,
+          CredentialsManagerModuleImpl.NAME,
           false, // canOverrideExistingModule
           false, // needsEagerInit
           false, // isCxxModule
-          true, // isTurboModule
+          isTurboModule, // isTurboModule
         )
       moduleInfos
     }

package/android/src/main/java/com/credentialsmanager/handlers/CredentialHandler.kt

@@ -0,0 +1,178 @@
+package com.credentialsmanager.handlers
+
+import android.content.Context
+import android.util.Log
+import androidx.credentials.CreatePasswordRequest
+import androidx.credentials.CreatePublicKeyCredentialRequest
+import androidx.credentials.CreatePublicKeyCredentialResponse
+import androidx.credentials.CredentialManager
+import androidx.credentials.CustomCredential
+import androidx.credentials.GetCredentialRequest
+import androidx.credentials.GetCredentialResponse
+import androidx.credentials.GetPasswordOption
+import androidx.credentials.GetPublicKeyCredentialOption
+import androidx.credentials.PasswordCredential
+import androidx.credentials.PublicKeyCredential
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.ReadableMap
+import com.google.android.libraries.identity.googleid.GetGoogleIdOption
+import com.google.android.libraries.identity.googleid.GoogleIdTokenCredential
+import com.google.android.libraries.identity.googleid.GoogleIdTokenParsingException
+import org.json.JSONObject
+import androidx.credentials.ClearCredentialStateRequest
+
+class CredentialHandler(
+  private val context: Context,
+) {
+  private val credentialManager = CredentialManager.create(context)
+
+  suspend fun signOut(){
+
+    credentialManager.clearCredentialState(ClearCredentialStateRequest())
+
+  }
+  suspend fun createPasskey(
+    jsonString: String,
+    preferImmediatelyAvailableCredentials: Boolean,
+  ): ReadableMap? {
+    val request =
+      CreatePublicKeyCredentialRequest(
+        requestJson = jsonString,
+        preferImmediatelyAvailableCredentials = preferImmediatelyAvailableCredentials,
+      )
+
+    val response =
+      credentialManager.createCredential(
+        context,
+        request,
+      ) as CreatePublicKeyCredentialResponse
+
+    return response.data.getString("androidx.credentials.BUNDLE_KEY_REGISTRATION_RESPONSE_JSON")?.let { json ->
+      val jsonObject = Arguments.createMap()
+      val parsedObject = JSONObject(json)
+
+      parsedObject.keys().forEach { key ->
+        jsonObject.putString(key, parsedObject.getString(key))
+      }
+      jsonObject
+    }
+  }
+
+  suspend fun createPassword(
+    username: String,
+    password: String,
+  ) {
+    val createPasswordRequest = CreatePasswordRequest(id = username, password = password)
+    credentialManager.createCredential(context, createPasswordRequest)
+  }
+
+  suspend fun getSavedCredentials(jsonString: String): ReadableMap? {
+    val getPublicKeyCredentialOption = GetPublicKeyCredentialOption(jsonString, null)
+    val getPasswordOption = GetPasswordOption()
+
+    val result =
+      credentialManager.getCredential(
+        context,
+        GetCredentialRequest(
+          listOf(
+            getPublicKeyCredentialOption,
+            getPasswordOption,
+          ),
+        ),
+      )
+
+    return handleSignInResult(result)
+  }
+
+  fun handleSignInResult(result: GetCredentialResponse): ReadableMap? {
+    // Handle the successfully returned credential.
+    val credential = result.credential
+    Log.d("CredentialManager", "Handle results called")
+
+    return when (credential) {
+      is PublicKeyCredential -> {
+        val cred = result.credential as PublicKeyCredential
+        Arguments.createMap().apply {
+          putString("type", "passkey")
+          putString("authenticationResponseJson", cred.authenticationResponseJson)
+        }
+      }
+      is PasswordCredential -> {
+        val cred = result.credential as PasswordCredential
+        Arguments.createMap().apply {
+          putString("type", "password")
+          putString("username", cred.id)
+          putString("password", cred.password)
+        }
+      }
+      // GoogleIdToken credential
+      is CustomCredential -> {
+        if (credential.type == GoogleIdTokenCredential.TYPE_GOOGLE_ID_TOKEN_CREDENTIAL) {
+          try {
+            val googleIdTokenCredential =
+              GoogleIdTokenCredential
+                .createFrom(credential.data)
+            Log.d("CredentialManager", "Google ID Token Credential ID: ${googleIdTokenCredential.id}")
+
+            return Arguments.createMap().apply {
+              putString("type", "google-signin")
+              putString("id", googleIdTokenCredential.id)
+              putString("idToken", googleIdTokenCredential.idToken)
+              googleIdTokenCredential.displayName?.let { putString("displayName", it) }
+              googleIdTokenCredential.familyName?.let { putString("familyName", it) }
+              googleIdTokenCredential.givenName?.let { putString("givenName", it) }
+              googleIdTokenCredential.profilePictureUri?.let { putString("profilePicture", it.toString()) }
+              googleIdTokenCredential.phoneNumber?.let { putString("phoneNumber", it) }
+            }
+          } catch (e: GoogleIdTokenParsingException) {
+            Log.e("CredentialManager", "Received an invalid google id token response", e)
+            return null
+          }
+        } else {
+          Log.e("CredentialManager", "Received an unexpected credential type")
+          return null
+        }
+      }
+
+      else -> {
+        // Catch any unrecognized credential type here.
+        Log.e("CredentialManager", "Unexpected type of credential")
+        return null
+      }
+    }
+  }
+
+  fun getGoogleId(
+    setFilterByAuthorizedAccounts: Boolean,
+    nonce: String,
+    serverClientId: String,
+    autoSelectEnabled: Boolean,
+  ): GetGoogleIdOption {
+    Log.d("CredentialManager", "getGoogleId - setFilterByAuthorizedAccounts: $setFilterByAuthorizedAccounts")
+
+    return GetGoogleIdOption
+      .Builder()
+      .setFilterByAuthorizedAccounts(setFilterByAuthorizedAccounts)
+      .setServerClientId(serverClientId)
+      .setAutoSelectEnabled(autoSelectEnabled)
+      .setNonce(nonce)
+      .build()
+  }
+
+
+  suspend fun googleSignInRequest(googleIdOption: GetGoogleIdOption): GetCredentialResponse {
+    val request: GetCredentialRequest =
+      GetCredentialRequest
+        .Builder()
+        .addCredentialOption(googleIdOption)
+        .build()
+
+    val result =
+      credentialManager.getCredential(
+        request = request,
+        context = context,
+      )
+
+    return result
+  }
+}

package/android/src/main/java/com/credentialsmanager/handlers/ErrorHandler.kt

@@ -0,0 +1,56 @@
+package com.credentialsmanager.handlers
+
+import android.util.Log
+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.GetCredentialCancellationException
+import androidx.credentials.exceptions.GetCredentialException
+import androidx.credentials.exceptions.GetCredentialInterruptedException
+import androidx.credentials.exceptions.GetCredentialUnknownException
+import androidx.credentials.exceptions.publickeycredential.CreatePublicKeyCredentialDomException
+
+object ErrorHandler {
+  fun handleCredentialError(e: CreateCredentialException) {
+    when (e) {
+      is CreatePublicKeyCredentialDomException -> {
+        Log.d("CredentialManager", "passkey DOM errors")
+      }
+      is CreateCredentialCancellationException -> {
+        Log.d("CredentialManager", "User cancelled")
+      }
+      is CreateCredentialInterruptedException -> {
+        Log.d("CredentialManager", "Retry process")
+      }
+      is CreateCredentialProviderConfigurationException -> {
+        Log.d("CredentialManager", "Missing provider configuration")
+      }
+      is CreateCredentialUnknownException -> {
+        Log.d("CredentialManager", "Unknown error")
+      }
+      is CreateCredentialCustomException -> {
+        Log.d("CredentialManager", "Custom credential error")
+      }
+      else -> Log.w("CredentialManager", "Unexpected exception type ${e::class.java.name}")
+    }
+  }
+
+  fun handleGetCredentialError(e: GetCredentialException) {
+    when (e) {
+      is GetCredentialCancellationException -> {
+        Log.d("CredentialManager", "GetCredentialCancellationException")
+      }
+      is GetCredentialInterruptedException -> {
+        Log.d("CredentialManager", "User interputted")
+      }
+      is GetCredentialUnknownException -> {
+        Log.d("CredentialManager", "Unknown error")
+      }
+
+      else -> Log.w("CredentialManager", "Unexpected exception type ${e::class.java.name}")
+    }
+  }
+}