@exodus/react-native-biometrics 0.2.1 → 0.4.0

package/android/src/main/java/org/exodusmovement/rn/biometrics/RNBiometricsModule.java

@@ -1,23 +1,33 @@
 package org.exodusmovement.rn.biometrics;
 
-import java.util.concurrent.Executor;
-import com.facebook.react.bridge.Promise;
-import com.facebook.react.bridge.ReactMethod;
-import com.facebook.react.bridge.ReactApplicationContext;
-import com.facebook.react.bridge.ReactContextBaseJavaModule;
-import com.facebook.react.module.annotations.ReactModule;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+import android.app.Activity;
+import android.os.Handler;
+import android.os.Looper;
 
+import androidx.annotation.Nullable;
 import androidx.biometric.BiometricPrompt;
 import androidx.biometric.BiometricManager;
 import androidx.core.content.ContextCompat;
 import androidx.fragment.app.FragmentActivity;
 
+import com.facebook.react.bridge.Promise;
+import com.facebook.react.bridge.ReactMethod;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReactContextBaseJavaModule;
+import com.facebook.react.module.annotations.ReactModule;
+
 @ReactModule(name = RNBiometricsModule.NAME)
 public final class RNBiometricsModule extends ReactContextBaseJavaModule {
     public static final String NAME = "Biometrics";
 
     private final ReactApplicationContext context;
 
+    @Nullable private BiometricPrompt activePrompt;
+    @Nullable private Promise activePromise;
+    @Nullable private AtomicBoolean activeSettled;
+
     public RNBiometricsModule(ReactApplicationContext context) {
         super(context);
         this.context = context;
@@ -40,40 +50,120 @@ public final class RNBiometricsModule extends ReactContextBaseJavaModule {
     }
 
     @ReactMethod
-    public void authenticate(String title, String subtitle, String cancelButtonText, Promise promise) {
-        context.getCurrentActivity().runOnUiThread(new Runnable() {
+    public void authenticate(final String title, final String subtitle, final String cancelButtonText, final boolean fallbackToPasscode, final Promise promise) {
+        final Activity activity = context.getCurrentActivity();
+        if (!(activity instanceof FragmentActivity)) {
+            promise.reject("E_NO_ACTIVITY", "No FragmentActivity available to host BiometricPrompt");
+            return;
+        }
+
+        final FragmentActivity fragmentActivity = (FragmentActivity) activity;
+
+        fragmentActivity.runOnUiThread(new Runnable() {
             @Override
             public void run() {
-                try {
-                    new BiometricPrompt(
-                        (FragmentActivity) context.getCurrentActivity(),
-                        ContextCompat.getMainExecutor(context),
-                        new BiometricPrompt.AuthenticationCallback() {
-                            @Override
-                            public void onAuthenticationError(int errorCode, CharSequence errString) {
-                                super.onAuthenticationError(errorCode, errString);
-                                promise.resolve(false);
-                            }
-
-                            @Override
-                            public void onAuthenticationSucceeded(BiometricPrompt.AuthenticationResult result) {
-                                super.onAuthenticationSucceeded(result);
-                                promise.resolve(true);
-                            }
+                cancelInternal();
+
+                final AtomicBoolean settled = new AtomicBoolean(false);
+
+                BiometricPrompt.AuthenticationCallback callback = new BiometricPrompt.AuthenticationCallback() {
+                    @Override
+                    public void onAuthenticationError(int errorCode, CharSequence errString) {
+                        super.onAuthenticationError(errorCode, errString);
+                        if (settled.compareAndSet(false, true)) {
+                            clearSlotIfMatches(promise);
+                            promise.resolve(false);
+                        }
+                    }
+
+                    @Override
+                    public void onAuthenticationSucceeded(BiometricPrompt.AuthenticationResult result) {
+                        super.onAuthenticationSucceeded(result);
+                        if (settled.compareAndSet(false, true)) {
+                            clearSlotIfMatches(promise);
+                            promise.resolve(true);
                         }
-                    ).authenticate(
-                        new BiometricPrompt.PromptInfo.Builder()
-                        .setAllowedAuthenticators(BiometricManager.Authenticators.BIOMETRIC_STRONG)
+                    }
+                };
+
+                try {
+                    int authenticators = fallbackToPasscode
+                        ? BiometricManager.Authenticators.BIOMETRIC_STRONG | BiometricManager.Authenticators.DEVICE_CREDENTIAL
+                        : BiometricManager.Authenticators.BIOMETRIC_STRONG;
+
+                    BiometricPrompt.PromptInfo.Builder promptInfoBuilder = new BiometricPrompt.PromptInfo.Builder()
+                        .setAllowedAuthenticators(authenticators)
                         .setTitle(title)
-                        .setSubtitle(subtitle)
-                        .setNegativeButtonText(cancelButtonText)
-                        .build()
+                        .setSubtitle(subtitle);
+
+                    if (!fallbackToPasscode) {
+                        promptInfoBuilder.setNegativeButtonText(cancelButtonText);
+                    }
+
+                    BiometricPrompt prompt = new BiometricPrompt(
+                        fragmentActivity,
+                        ContextCompat.getMainExecutor(context),
+                        callback
                     );
 
+                    activePrompt = prompt;
+                    activePromise = promise;
+                    activeSettled = settled;
+
+                    prompt.authenticate(promptInfoBuilder.build());
                 } catch (Exception e) {
-                    promise.reject(e);
+                    if (settled.compareAndSet(false, true)) {
+                        clearSlotIfMatches(promise);
+                        promise.reject(e);
+                    }
                 }
             }
         });
     }
-}
+
+    @ReactMethod
+    public void cancel() {
+        final Runnable runnable = new Runnable() {
+            @Override
+            public void run() {
+                cancelInternal();
+            }
+        };
+
+        final Activity activity = context.getCurrentActivity();
+        if (activity != null) {
+            activity.runOnUiThread(runnable);
+        } else {
+            new Handler(Looper.getMainLooper()).post(runnable);
+        }
+    }
+
+    private void cancelInternal() {
+        BiometricPrompt prompt = activePrompt;
+        Promise promise = activePromise;
+        AtomicBoolean settled = activeSettled;
+
+        activePrompt = null;
+        activePromise = null;
+        activeSettled = null;
+
+        if (prompt != null) {
+            try {
+                prompt.cancelAuthentication();
+            } catch (Exception ignored) {
+            }
+        }
+
+        if (promise != null && settled != null && settled.compareAndSet(false, true)) {
+            promise.resolve(false);
+        }
+    }
+
+    private void clearSlotIfMatches(Promise promise) {
+        if (activePromise == promise) {
+            activePrompt = null;
+            activePromise = null;
+            activeSettled = null;
+        }
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exodus/react-native-biometrics",
-  "version": "0.2.1",
+  "version": "0.4.0",
   "description": "React Native Biometrics",
   "main": "index.js",
   "files": [

package/src/Biometrics.android.js

@@ -6,7 +6,12 @@ export default {
   isSupported: async () => {
     return AndroidBiometrics.isSupported();
   },
-  authenticate: async ({ title, subtitle, cancelButtonText }) => {
-    return AndroidBiometrics.authenticate(title, subtitle, cancelButtonText);
-  }
+  authenticate: async ({ title, subtitle, cancelButtonText, fallbackToPasscode = false }) => {
+    return AndroidBiometrics.authenticate(title, subtitle, cancelButtonText, fallbackToPasscode);
+  },
+  cancel: () => {
+    if (typeof AndroidBiometrics?.cancel === 'function') {
+      AndroidBiometrics.cancel();
+    }
+  },
 }

package/src/Biometrics.ios.js

@@ -4,5 +4,6 @@ export default {
   },
   authenticate: async () => {
     return Promise.reject('Biometrics is not supported on this platform');
-  }
+  },
+  cancel: () => {},
 }