react-native-credentials-manager 0.2.1 → 0.3.0

package/README.md

@@ -2,7 +2,7 @@
 
 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.
 
 ## Features
 
@@ -236,7 +236,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,26 @@ 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']
+            }
+        }
     }
-  }
+    
+  // sourceSets {
+  //   main {
+  //     if (isNewArchitectureEnabled()) {
+  //         java.srcDirs += [
+  //           "generated/java",
+  //           "generated/jni"
+  //         ]
+  //     }
+  //   }
+  // }
 }
 
 repositories {

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,91 @@
+package com.credentialsmanager.handlers
+
+import android.content.Context
+import androidx.credentials.CreatePasswordRequest
+import androidx.credentials.CreatePublicKeyCredentialRequest
+import androidx.credentials.CreatePublicKeyCredentialResponse
+import androidx.credentials.CredentialManager
+import androidx.credentials.GetCredentialRequest
+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 org.json.JSONObject
+
+class CredentialHandler(
+  private val context: Context,
+) {
+  private val credentialManager = CredentialManager.create(context)
+
+  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 when (result.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)
+        }
+      }
+      else -> null
+    }
+  }
+}

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

@@ -0,0 +1,36 @@
+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.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}")
+    }
+  }
+}

package/android/src/newarch/java/com/credentialsmanager/CredentialsManagerModule.kt

@@ -0,0 +1,71 @@
+package com.credentialsmanager
+import androidx.credentials.CredentialManager
+import androidx.credentials.exceptions.CreateCredentialException
+import com.credentialsmanager.handlers.CredentialHandler
+import com.credentialsmanager.handlers.ErrorHandler
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReadableMap
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.launch
+
+class CredentialsManagerModule(
+  reactContext: ReactApplicationContext,
+) : NativeCredentialsManagerSpec(reactContext) {
+  private val coroutineScope = CoroutineScope(Dispatchers.IO)
+  val credentialManager = CredentialManager.create(getReactApplicationContext())
+  private val credentialHandler = CredentialHandler(reactContext)
+
+  private var implementation: CredentialsManagerModuleImpl = CredentialsManagerModuleImpl()
+
+  override fun getName(): String = CredentialsManagerModuleImpl.NAME
+
+  override fun signUpWithPasskeys(
+    requestJson: ReadableMap,
+    preferImmediatelyAvailableCredentials: Boolean,
+    promise: Promise,
+  ) {
+    val jsonString = requestJson.toString()
+
+    coroutineScope.launch {
+      try {
+        val response =
+          credentialHandler.createPasskey(
+            jsonString,
+            preferImmediatelyAvailableCredentials,
+          )
+
+        response?.let {
+          promise.resolve(it)
+        } ?: promise.reject("ERROR", "No response received")
+      } catch (e: CreateCredentialException) {
+        ErrorHandler.handleCredentialError(e)
+        promise.reject("ERROR", e.message.toString())
+      }
+    }
+  }
+
+  override fun signUpWithPassword(credObject: ReadableMap) {
+    val username = credObject.getString("username") ?: ""
+    val password = credObject.getString("password") ?: ""
+    coroutineScope.launch {
+      try {
+        credentialHandler.createPassword(username, password)
+      } catch (e: CreateCredentialException) {
+        ErrorHandler.handleCredentialError(e)
+      }
+    }
+  }
+
+  override fun signInWithSavedCredentials(
+    requestJson: ReadableMap,
+    promise: Promise,
+  ) {
+    val jsonString = requestJson.toString()
+    coroutineScope.launch {
+      val data = credentialHandler.getSavedCredentials(jsonString)
+      promise.resolve(data)
+    }
+  }
+}

package/android/src/oldarch/java/com/credentialsmanager/CredentialsManagerModule.kt

@@ -0,0 +1,77 @@
+package com.credentialsmanager
+import androidx.credentials.CredentialManager
+import androidx.credentials.exceptions.CreateCredentialException
+import com.credentialsmanager.handlers.CredentialHandler
+import com.credentialsmanager.handlers.ErrorHandler
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReactContextBaseJavaModule
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.module.annotations.ReactModule
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.launch
+
+@ReactModule(name = CredentialsManagerModuleImpl.NAME)
+class CredentialsManagerModule(
+  reactContext: ReactApplicationContext,
+) : ReactContextBaseJavaModule(reactContext) {
+  private val coroutineScope = CoroutineScope(Dispatchers.IO)
+  val credentialManager = CredentialManager.create(getReactApplicationContext())
+  private val credentialHandler = CredentialHandler(reactContext)
+
+  private var implementation: CredentialsManagerModuleImpl = CredentialsManagerModuleImpl()
+
+  override fun getName(): String = CredentialsManagerModuleImpl.NAME
+
+  @ReactMethod
+  fun signUpWithPasskeys(
+    requestJson: ReadableMap,
+    preferImmediatelyAvailableCredentials: Boolean,
+    promise: Promise,
+  ) {
+    val jsonString = requestJson.toString()
+
+    coroutineScope.launch {
+      try {
+        val response =
+          credentialHandler.createPasskey(
+            jsonString,
+            preferImmediatelyAvailableCredentials,
+          )
+
+        response?.let {
+          promise.resolve(it)
+        } ?: promise.reject("ERROR", "No response received")
+      } catch (e: CreateCredentialException) {
+        ErrorHandler.handleCredentialError(e)
+        promise.reject("ERROR", e.message.toString())
+      }
+    }
+  }
+
+  @ReactMethod
+  fun signUpWithPassword(credObject: ReadableMap) {
+    val username = credObject.getString("username") ?: ""
+    val password = credObject.getString("password") ?: ""
+    coroutineScope.launch {
+      try {
+        credentialHandler.createPassword(username, password)
+      } catch (e: CreateCredentialException) {
+        ErrorHandler.handleCredentialError(e)
+      }
+    }
+  }
+
+  @ReactMethod
+  fun signInWithSavedCredentials(
+    requestJson: ReadableMap,
+    promise: Promise,
+  ) {
+    val jsonString = requestJson.toString()
+    coroutineScope.launch {
+      val data = credentialHandler.getSavedCredentials(jsonString)
+      promise.resolve(data)
+    }
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-credentials-manager",
-  "version": "0.2.1",
+  "version": "0.3.0",
   "description": "A React Native library that implements the Credential Manager API for Android. This library allows you to manage passwords and passkeys in your React Native applications.",
   "source": "./src/index.tsx",
   "main": "./lib/commonjs/index.js",

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

@@ -1,212 +0,0 @@
-package com.credentialsmanager
-
-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.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.publickeycredential.CreatePublicKeyCredentialDomException
-import com.facebook.react.bridge.Arguments
-import com.facebook.react.bridge.Promise
-import com.facebook.react.bridge.ReactApplicationContext
-import com.facebook.react.bridge.ReadableMap
-import com.facebook.react.module.annotations.ReactModule
-import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.launch
-import org.json.JSONObject
-
-@ReactModule(name = CredentialsManagerModule.NAME)
-class CredentialsManagerModule(
-  reactContext: ReactApplicationContext,
-) : NativeCredentialsManagerSpec(reactContext) {
-  private val coroutineScope = CoroutineScope(Dispatchers.IO)
-  val credentialManager = CredentialManager.create(getReactApplicationContext())
-
-  override fun getName(): String = NAME
-
-  override fun signUpWithPasskeys(
-    requestJson: ReadableMap,
-    preferImmediatelyAvailableCredentials: Boolean,
-    promise: Promise,
-  ) {
-    val jsonString = requestJson.toString()
-
-    val request =
-      CreatePublicKeyCredentialRequest(
-        requestJson = jsonString,
-        preferImmediatelyAvailableCredentials = preferImmediatelyAvailableCredentials,
-      )
-
-    coroutineScope.launch {
-      try {
-        val response =
-          credentialManager.createCredential(
-            getReactApplicationContext(),
-            request,
-          ) as CreatePublicKeyCredentialResponse
-
-        response?.let {
-          val dataBundle = it.data
-          val responseJson = dataBundle.getString("androidx.credentials.BUNDLE_KEY_REGISTRATION_RESPONSE_JSON")
-          responseJson?.let { json ->
-
-            val jsonObject = Arguments.createMap()
-            val parsedObject = JSONObject(json)
-
-            parsedObject.keys().forEach { key ->
-              jsonObject.putString(key, parsedObject.getString(key))
-            }
-
-            Log.d("CredentialManager", "Passkey creation result: $jsonObject")
-            promise.resolve(jsonObject)
-          } ?: run {
-            promise.reject("ERROR", "Response JSON is null")
-          }
-        } ?: run {
-          promise.reject("ERROR", "No response received")
-        }
-      } catch (e: CreateCredentialException) {
-        handleFailure(e)
-        promise.reject("ERROR", e.message.toString())
-      }
-    }
-  }
-
-  override fun signUpWithPassword(credObject: ReadableMap) {
-    val username = credObject.getString("username") ?: ""
-    val password = credObject.getString("password") ?: ""
-    coroutineScope.launch {
-      createPassword(username, password)
-    }
-  }
-
-  override fun signInWithSavedCredentials(
-    requestJson: ReadableMap,
-    promise: Promise,
-  ) {
-    val jsonString = requestJson.toString()
-    coroutineScope.launch {
-      val data = getSavedCredentials(jsonString)
-      promise.resolve(data)
-    }
-  }
-
-  private suspend fun getSavedCredentials(jsonString: String): ReadableMap? {
-    val getPublicKeyCredentialOption =
-      GetPublicKeyCredentialOption(jsonString, null)
-
-    val getPasswordOption = GetPasswordOption()
-
-    val result =
-      try {
-        credentialManager.getCredential(
-          getReactApplicationContext(),
-          GetCredentialRequest(
-            listOf(
-              getPublicKeyCredentialOption,
-              getPasswordOption,
-            ),
-          ),
-        )
-      } catch (e: Exception) {
-        Log.e("CredentialManager", "getCredential failed with exception: " + e.message.toString())
-
-        return null
-      }
-
-    val resultMap = Arguments.createMap()
-    when (result.credential) {
-      is PublicKeyCredential -> {
-        val cred = result.credential as PublicKeyCredential
-        resultMap.putString("type", "passkey")
-        resultMap.putString("authenticationResponseJson", cred.authenticationResponseJson)
-        Log.d("CredentialManager", "Passkey: ${cred.authenticationResponseJson}")
-      }
-      is PasswordCredential -> {
-        val cred = result.credential as PasswordCredential
-        resultMap.putString("type", "password")
-        resultMap.putString("username", cred.id)
-        resultMap.putString("password", cred.password)
-        Log.d("CredentialManager", "Got Password - User:${cred.id} Password: ${cred.password}")
-      }
-      is CustomCredential -> {
-        return null
-      }
-      else -> return null
-    }
-
-    return resultMap
-  }
-
-  private suspend fun createPassword(
-    username: String,
-    password: String,
-  ) {
-    val createPasswordRequest =
-      CreatePasswordRequest(id = username, password = password)
-
-    try {
-      val result =
-        credentialManager.createCredential(
-          getReactApplicationContext(),
-          createPasswordRequest,
-        )
-    } catch (e: CreateCredentialException) {
-      handleFailure(e)
-    }
-  }
-
-  private fun handleFailure(e: CreateCredentialException) {
-    when (e) {
-      is CreatePublicKeyCredentialDomException -> {
-        // Handle the passkey DOM errors thrown according to the
-        // WebAuthn spec.
-        Log.d("CredentialManager", "passkey DOM errors")
-        // handlePasskeyError(e.domError)
-      }
-      is CreateCredentialCancellationException -> {
-        // The user intentionally canceled the operation and chose not
-        // to register the credential.
-        Log.d("CredentialManager", "User cancelled")
-      }
-      is CreateCredentialInterruptedException -> {
-        // Retry-able error. Consider retrying the call.
-        Log.d("CredentialManager", "Retry process")
-      }
-      is CreateCredentialProviderConfigurationException -> {
-        // Your app is missing the provider configuration dependency.
-        // Most likely, you're missing the
-        // "credentials-play-services-auth" module.
-      }
-      is CreateCredentialUnknownException -> {
-        Log.d("CredentialManager", "Unknown error")
-      }
-      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("CredentialManager", "Unexpected exception type ${e::class.java.name}")
-    }
-  }
-
-  companion object {
-    const val NAME = "CredentialsManager"
-  }
-}