@exodus/react-native-biometrics 0.3.0 → 0.4.1

package/CHANGELOG.md

@@ -2,3 +2,7 @@
 
 All notable changes to this projected will be documented in this file.
 See [Conventional Commits](https://www.conventionalcommits.org) for commit guidelines.
+
+## 0.4.1 (2026-09-11)
+
+- Fix authentication failing before the prompt appears on Android 9–10 when device passcode fallback is enabled ([#9](https://github.com/ExodusMovement/react-native-biometrics/pull/9)).

package/README.md

@@ -30,7 +30,24 @@ const valid = await Biometrics.authenticate(
 | title | string | The title of the biometric prompt |
 | subtitle | string | The subtitle of the biometric prompt |
 | cancelButtonText | string | The text of the cancel button |
+| fallbackToPasscode | boolean | Allow the device PIN, pattern, or password as an alternative to biometrics (default: `false`) |
 
+With passcode fallback enabled, Android 9–10 (API 28–29) accepts Class 2 (weak) or
+Class 3 (strong) biometrics alongside device credentials. AndroidX does not support
+`BIOMETRIC_STRONG | DEVICE_CREDENTIAL` on these versions. Other Android versions,
+and biometric-only authentication on all versions, continue to require Class 3
+biometrics. Authentication does not use a `CryptoObject`.
+
+## Android tests
+
+With JDK 17, Gradle 8.12, Android SDK 36, and build tools 36.0.0 installed:
+
+```sh
+gradle -p test/android :biometrics:testDebugUnitTest
+```
+
+The tests use the library's AndroidX dependency and Robolectric to validate prompt
+creation on API 27, 28, 29, and 30, including the previously rejected combination.
 
 ## License
 

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

@@ -1,23 +1,34 @@
 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.Build;
+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;
@@ -28,6 +39,28 @@ public final class RNBiometricsModule extends ReactContextBaseJavaModule {
         return NAME;
     }
 
+    static BiometricPrompt.PromptInfo createPromptInfo(String title, String subtitle, String cancelButtonText, boolean fallbackToPasscode) {
+        int authenticators = BiometricManager.Authenticators.BIOMETRIC_STRONG;
+        if (fallbackToPasscode) {
+            // AndroidX cannot combine strong biometrics with device credentials on API 28-29.
+            if (Build.VERSION.SDK_INT >= 28 && Build.VERSION.SDK_INT <= 29) {
+                authenticators = BiometricManager.Authenticators.BIOMETRIC_WEAK;
+            }
+            authenticators |= BiometricManager.Authenticators.DEVICE_CREDENTIAL;
+        }
+
+        BiometricPrompt.PromptInfo.Builder builder = new BiometricPrompt.PromptInfo.Builder()
+            .setAllowedAuthenticators(authenticators)
+            .setTitle(title)
+            .setSubtitle(subtitle);
+
+        if (!fallbackToPasscode) {
+            builder.setNegativeButtonText(cancelButtonText);
+        }
+
+        return builder.build();
+    }
+
     @ReactMethod
     public void isSupported(Promise promise) {
         try {
@@ -40,47 +73,107 @@ public final class RNBiometricsModule extends ReactContextBaseJavaModule {
     }
 
     @ReactMethod
-    public void authenticate(String title, String subtitle, String cancelButtonText, boolean fallbackToPasscode, 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 {
-                    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);
-
-                    // Negative button text cannot be set when DEVICE_CREDENTIAL is allowed.
-                    if (!fallbackToPasscode) {
-                        promptInfoBuilder.setNegativeButtonText(cancelButtonText);
+                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);
+                        }
                     }
 
-                    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);
-                            }
+                    @Override
+                    public void onAuthenticationSucceeded(BiometricPrompt.AuthenticationResult result) {
+                        super.onAuthenticationSucceeded(result);
+                        if (settled.compareAndSet(false, true)) {
+                            clearSlotIfMatches(promise);
+                            promise.resolve(true);
                         }
-                    ).authenticate(promptInfoBuilder.build());
+                    }
+                };
+
+                try {
+                    BiometricPrompt prompt = new BiometricPrompt(
+                        fragmentActivity,
+                        ContextCompat.getMainExecutor(context),
+                        callback
+                    );
+
+                    activePrompt = prompt;
+                    activePromise = promise;
+                    activeSettled = settled;
 
+                    prompt.authenticate(createPromptInfo(title, subtitle, cancelButtonText, fallbackToPasscode));
                 } 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.3.0",
+  "version": "0.4.1",
   "description": "React Native Biometrics",
   "main": "index.js",
   "files": [

package/src/Biometrics.android.js

@@ -8,5 +8,10 @@ export default {
   },
   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: () => {},
 }