expo-android-otp-autofill 0.1.0

package/README.md

@@ -0,0 +1,150 @@
+# expo-android-otp-autofill
+
+Android-only Expo module that auto-detects OTP from SMS (READ_SMS and native code included). No third-party OTP library required.
+
+## Features
+
+- **Android only** — READ_SMS permission and native OTP reader; use `textContentType="oneTimeCode"` on iOS.
+- **Expo module** — Native code in the package (autolinked); READ_SMS and Play Services Auth are declared in the module.
+- **Event-based** — Native module emits `onOtpReceived` when an OTP (4–8 digits, configurable) is found.
+- **Two modes** — Use **READ_SMS** (any SMS format) or **SMS Retriever API** (no permission; message must include your app hash).
+
+## Installation
+
+```bash
+npx expo install expo-android-otp-autofill
+```
+
+## Setup
+
+### 1. Prebuild (native module is included when you install the package)
+
+```bash
+npx expo prebuild --platform android
+```
+
+### 2. Use the API in your verify-otp screen
+
+**Recommended – useOtpVerify** (SMS Retriever, no permission):
+
+```ts
+import { useOtpVerify } from 'expo-android-otp-autofill';
+
+const { hash, otp, message, timeoutError, startListener, stopListener } = useOtpVerify({
+  numberOfDigits: 4,
+  onOtpReceived: (otp) => setValue('user_entered_otp', otp, { shouldValidate: true }),
+});
+// hash for your SMS template; otp/message when SMS arrives; timeoutError for "Resend".
+```
+
+**READ_SMS mode (imperative API):**
+
+```ts
+import {
+  addOtpListener,
+  startOtpListener,
+  stopOtpListener,
+} from 'expo-android-otp-autofill';
+
+useEffect(() => {
+  const remove = addOtpListener((otp) => setValue('user_entered_otp', otp, { shouldValidate: true }));
+  startOtpListener({ length: 6 });
+  return () => {
+    stopOtpListener();
+    remove();
+  };
+}, []);
+```
+
+## API
+
+| Name | Description |
+|------|-------------|
+| `useOtpVerify(options)` | Hook (SMS Retriever): `numberOfDigits`, `onOtpReceived`; returns `hash`, `otp`, `message`, `timeoutError`, `startListener`, `stopListener`. |
+| `OTP_EVENT_NAME` | `'onOtpReceived'` |
+| `startOtpListener(options?)` | Starts SMS polling (READ_SMS); optional `length` (4–8, default 6). Requests permission if needed. |
+| `stopOtpListener()` | Stops the READ_SMS listener. |
+| `getAppHash()` | **Promise\<string | null\>** — Returns the 11-char app hash for SMS Retriever messages. |
+| `startSmsRetrieverListener(options?)` | Starts SMS Retriever (no permission). Message must include app hash; ~5 min timeout. |
+| `stopSmsRetrieverListener()` | Stops the SMS Retriever listener. |
+| `addSmsRetrieverTimeoutListener(callback)` | Called when SMS Retriever times out (~5 min). Use for "Resend" / "Didn't get code?". |
+| `addOtpListener(callback)` | Subscribes to OTP events; returns unsubscribe function. |
+| `SMS_RETRIEVER_TIMEOUT_EVENT_NAME` | `'onSmsRetrieverTimeout'` — event name for timeout. |
+
+---
+
+## Automatic SMS verification with the SMS Retriever API (no permission)
+
+The **SMS Retriever API** lets you verify users via SMS **without READ_SMS**. The user does not grant any extra permissions; your server sends an SMS that contains a unique hash identifying your app, and the system delivers that message only to your app.
+
+### 1. Get your app hash
+
+Call `getAppHash()` and pass the value to your backend (e.g. at build time or via a one-time setup endpoint):
+
+```ts
+import { getAppHash } from 'expo-android-otp-autofill';
+
+const hash = await getAppHash();
+// e.g. "AbCdEfGhIjK" — give this to your server so it can include it in SMS
+```
+
+### 2. Message format / structure
+
+The verification SMS **must**:
+
+- Be **no longer than 140 bytes**
+- Contain a **one-time code** (e.g. 4–8 digits)
+- Include the **11-character hash** that identifies your app (from `getAppHash()`)
+
+The exact format is flexible. Example:
+
+```
+Your verification code is 123456
+
+AbCdEfGhIjK
+```
+
+(Replace `AbCdEfGhIjK` with your actual hash.)
+
+For the full rules and how to compute the hash on the server, see the official guide:  
+**[SMS Retriever API – Construct a verification message](https://developers.google.com/identity/sms-retriever/verify#1_construct_a_verification_message)** (Google for Developers).
+
+### 3. Use the hook or imperative API
+
+**Easiest:** use `useOtpVerify` — it starts the retriever on mount and gives you `hash`, `otp`, `message`, `timeoutError`, `startListener`, `stopListener`:
+
+```ts
+const { hash, otp, timeoutError, startListener, stopListener } = useOtpVerify({
+  numberOfDigits: 6,
+  onOtpReceived: (otp) => setCode(otp),
+});
+// On timeout, show "Resend" and call startListener() to retry.
+```
+
+Or use the imperative API (`addOtpListener`, `addSmsRetrieverTimeoutListener`, `startSmsRetrieverListener`, `stopSmsRetrieverListener`) if you prefer.
+
+The retriever waits for a matching SMS for about **5 minutes**, then sets `timeoutError`. Call `startListener()` to retry.
+
+---
+
+## READ_SMS mode (any SMS format)
+
+If you prefer to use the **READ_SMS** permission, the module reads the **most recent SMS** from the **last 2 minutes** and matches an OTP of the length you set (default 6; 4–8 supported). No special message format required. Example formats:
+
+- `991233 is your OTP for …`
+- `Your code is 991233`
+
+---
+
+## Phone number (optional)
+
+For **phone number retrieval** without the user typing it, use the **Phone Number Hint API** (Android). This module does not implement it; you can use it alongside this one. See: [Request a phone number](https://developers.google.com/identity/sms-retriever/request#request_a_phone_number) (Google for Developers).
+
+## Supported versions
+
+- **Expo**: 50+
+- **React Native**: 0.72+
+
+## License
+
+MIT

package/android/build.gradle

@@ -0,0 +1,20 @@
+plugins {
+  id 'com.android.library'
+  id 'expo-module-gradle-plugin'
+}
+
+group = 'expo.modules.androidotpautofill'
+version = '0.1.0'
+
+android {
+  namespace "expo.modules.androidotpautofill"
+  defaultConfig {
+    versionCode 1
+    versionName '0.1.0'
+  }
+}
+
+dependencies {
+  implementation 'com.google.android.gms:play-services-auth:20.7.0'
+  implementation 'com.google.android.gms:play-services-auth-api-phone:18.0.2'
+}

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,4 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+  <!-- Required for reading SMS to auto-detect OTP -->
+  <uses-permission android:name="android.permission.READ_SMS" />
+</manifest>

package/android/src/main/java/expo/modules/androidotpautofill/AppSignatureHelper.kt

@@ -0,0 +1,51 @@
+package expo.modules.androidotpautofill
+
+import android.content.Context
+import android.content.pm.PackageManager
+import android.os.Build
+import java.security.MessageDigest
+import java.util.Arrays
+
+/**
+ * Computes the 11-character app hash string required for SMS Retriever API verification messages.
+ * Your server must include this hash in the SMS so the API can deliver the message to your app.
+ * See: https://developers.google.com/identity/sms-retriever/verify#1_construct_a_verification_message
+ */
+object AppSignatureHelper {
+  private const val HASH_LENGTH = 11
+
+  fun getAppHash(context: Context): String? {
+    val packageName = context.packageName
+    val signature = getSigningCertificateHex(context, packageName) ?: return null
+    val appInfo = "$packageName $signature"
+    val digest = MessageDigest.getInstance("SHA-256").apply {
+      update(appInfo.toByteArray(Charsets.UTF_8))
+    }.digest()
+    val hashBytes = Arrays.copyOfRange(digest, 0, 9)
+    val base64 = android.util.Base64.encodeToString(hashBytes, android.util.Base64.NO_PADDING or android.util.Base64.NO_WRAP)
+    return base64.take(HASH_LENGTH)
+  }
+
+  private fun getSigningCertificateHex(context: Context, packageName: String): String? {
+    return try {
+      val pm = context.packageManager
+      @Suppress("DEPRECATION")
+      val flags = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P) {
+        PackageManager.GET_SIGNING_CERTIFICATES
+      } else {
+        PackageManager.GET_SIGNATURES
+      }
+      val packageInfo = pm.getPackageInfo(packageName, flags)
+      val signatures = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P) {
+        packageInfo.signingInfo?.apkContentsSigners
+      } else {
+        @Suppress("DEPRECATION")
+        packageInfo.signatures
+      }
+      val sig = signatures?.firstOrNull() ?: return null
+      sig.toByteArray().joinToString("") { "%02x".format(it) }
+    } catch (e: Exception) {
+      null
+    }
+  }
+}

package/android/src/main/java/expo/modules/androidotpautofill/ExpoAndroidOtpAutofillModule.kt

@@ -0,0 +1,177 @@
+package expo.modules.androidotpautofill
+
+import android.app.Activity
+import android.Manifest
+import android.content.BroadcastReceiver
+import android.content.ContentResolver
+import android.content.Context
+import android.content.Intent
+import android.content.IntentFilter
+import android.content.pm.PackageManager
+import android.net.Uri
+import android.os.Build
+import android.os.Handler
+import android.os.Looper
+import android.provider.Telephony
+import androidx.core.app.ActivityCompat
+import com.google.android.gms.auth.api.phone.SmsRetriever
+import com.google.android.gms.common.api.CommonStatusCodes
+import expo.modules.kotlin.exception.Exceptions
+import expo.modules.kotlin.modules.Module
+import expo.modules.kotlin.modules.ModuleDefinition
+import java.util.regex.Pattern
+
+class ExpoAndroidOtpAutofillModule : Module() {
+  private val context: android.content.Context
+    get() = appContext.reactContext ?: throw Exceptions.ReactContextLost()
+
+  private val handler = Handler(Looper.getMainLooper())
+  private var pollRunnable: Runnable? = null
+  private var lastCheckedMessageId: Long = -1
+  private var otpLength: Int = 6
+
+  private var smsRetrieverReceiver: BroadcastReceiver? = null
+
+  override fun definition() = ModuleDefinition {
+    Name("ExpoAndroidOtpAutofill")
+
+    Events("onOtpReceived", "onSmsRetrieverTimeout")
+
+    AsyncFunction("getAppHash") {
+      AppSignatureHelper.getAppHash(context)
+    }
+
+    AsyncFunction("startOtpListener") { length: Int? ->
+      if (length != null && length in 4..8) {
+        otpLength = length
+      }
+      if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
+        if (ActivityCompat.checkSelfPermission(context, Manifest.permission.READ_SMS) != PackageManager.PERMISSION_GRANTED) {
+          appContext.currentActivity?.let { activity: Activity ->
+            ActivityCompat.requestPermissions(activity, arrayOf(Manifest.permission.READ_SMS), 1001)
+          }
+          handler.postDelayed({ startPolling() }, 2000)
+          return@AsyncFunction
+        }
+      }
+      startPolling()
+    }
+
+    AsyncFunction<Unit>("removeListener") {
+      stopPolling()
+    }
+
+    AsyncFunction("startSmsRetrieverListener") { length: Int? ->
+      if (length != null && length in 4..8) {
+        otpLength = length
+      }
+      startSmsRetriever()
+    }
+
+    AsyncFunction<Unit>("removeSmsRetrieverListener") {
+      unregisterSmsRetrieverReceiver()
+    }
+  }
+
+  private fun startPolling() {
+    if (pollRunnable != null) return
+    pollRunnable = object : Runnable {
+      override fun run() {
+        val otp = readOtpFromLastSms()
+        if (otp != null) {
+          stopPolling()
+          sendEvent("onOtpReceived", mapOf("otp" to otp))
+        } else {
+          handler.postDelayed(this, 2500)
+        }
+      }
+    }
+    handler.post(pollRunnable!!)
+  }
+
+  private fun stopPolling() {
+    pollRunnable?.let { handler.removeCallbacks(it) }
+    pollRunnable = null
+  }
+
+  private fun readOtpFromLastSms(): String? {
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M &&
+      ActivityCompat.checkSelfPermission(context, Manifest.permission.READ_SMS) != PackageManager.PERMISSION_GRANTED
+    ) {
+      return null
+    }
+    val cr: ContentResolver = context.contentResolver
+    val uri: Uri = Telephony.Sms.CONTENT_URI
+    val cursor = cr.query(
+      uri,
+      arrayOf(Telephony.Sms._ID, Telephony.Sms.BODY, Telephony.Sms.DATE),
+      null,
+      null,
+      Telephony.Sms.DEFAULT_SORT_ORDER
+    ) ?: return null
+    try {
+      if (cursor.moveToFirst()) {
+        val id = cursor.getLong(cursor.getColumnIndexOrThrow(Telephony.Sms._ID))
+        if (id == lastCheckedMessageId) return null
+        lastCheckedMessageId = id
+        val body = cursor.getString(cursor.getColumnIndexOrThrow(Telephony.Sms.BODY)) ?: return null
+        val date = cursor.getLong(cursor.getColumnIndexOrThrow(Telephony.Sms.DATE))
+        val twoMinutesAgo = System.currentTimeMillis() - 2 * 60 * 1000
+        if (date < twoMinutesAgo) return null
+        val pattern = Pattern.compile("\\d{$otpLength}")
+        val matcher = pattern.matcher(body)
+        if (matcher.find()) return matcher.group()
+      }
+    } finally {
+      cursor.close()
+    }
+    return null
+  }
+
+  private fun startSmsRetriever() {
+    unregisterSmsRetrieverReceiver()
+    val client = SmsRetriever.getClient(context)
+    client.startSmsRetriever().addOnSuccessListener {
+      val receiver = object : BroadcastReceiver() {
+        override fun onReceive(ctx: Context?, intent: Intent?) {
+          if (intent?.action != SmsRetriever.SMS_RETRIEVED_ACTION) return
+          val extras = intent.extras ?: return
+          @Suppress("DEPRECATION")
+          val status = extras.get(SmsRetriever.EXTRA_STATUS) as? com.google.android.gms.common.api.Status ?: return
+          when (status.statusCode) {
+            CommonStatusCodes.SUCCESS -> {
+              val message = extras.getString(SmsRetriever.EXTRA_SMS_MESSAGE) ?: return
+              val pattern = Pattern.compile("\\d{$otpLength}")
+              val matcher = pattern.matcher(message)
+              if (matcher.find()) {
+                unregisterSmsRetrieverReceiver()
+                sendEvent("onOtpReceived", mapOf("otp" to matcher.group()!!, "message" to message))
+              }
+            }
+            CommonStatusCodes.TIMEOUT -> {
+              sendEvent("onSmsRetrieverTimeout", mapOf("timedOut" to true))
+              unregisterSmsRetrieverReceiver()
+            }
+          }
+        }
+      }
+      smsRetrieverReceiver = receiver
+      val filter = IntentFilter(SmsRetriever.SMS_RETRIEVED_ACTION)
+      val appContext = context.applicationContext
+      if (Build.VERSION.SDK_INT >= 33) {
+        appContext.registerReceiver(receiver, filter, Context.RECEIVER_NOT_EXPORTED)
+      } else {
+        @Suppress("DEPRECATION")
+        appContext.registerReceiver(receiver, filter)
+      }
+    }
+  }
+
+  private fun unregisterSmsRetrieverReceiver() {
+    val receiver = smsRetrieverReceiver ?: return
+    try {
+      context.applicationContext.unregisterReceiver(receiver)
+    } catch (_: Exception) {}
+    smsRetrieverReceiver = null
+  }
+}

package/android/src/main/java/expo/modules/androidotpautofill/ExpoAndroidOtpAutofillView.kt

@@ -0,0 +1,30 @@
+package expo.modules.androidotpautofill
+
+import android.content.Context
+import android.webkit.WebView
+import android.webkit.WebViewClient
+import expo.modules.kotlin.AppContext
+import expo.modules.kotlin.viewevent.EventDispatcher
+import expo.modules.kotlin.views.ExpoView
+
+class ExpoAndroidOtpAutofillView(context: Context, appContext: AppContext) : ExpoView(context, appContext) {
+  // Creates and initializes an event dispatcher for the `onLoad` event.
+  // The name of the event is inferred from the value and needs to match the event name defined in the module.
+  private val onLoad by EventDispatcher()
+
+  // Defines a WebView that will be used as the root subview.
+  internal val webView = WebView(context).apply {
+    layoutParams = LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT)
+    webViewClient = object : WebViewClient() {
+      override fun onPageFinished(view: WebView, url: String) {
+        // Sends an event to JavaScript. Triggers a callback defined on the view component in JavaScript.
+        onLoad(mapOf("url" to url))
+      }
+    }
+  }
+
+  init {
+    // Adds the WebView to the view hierarchy.
+    addView(webView)
+  }
+}

package/build/ExpoAndroidOtpAutofill.d.ts

@@ -0,0 +1,3 @@
+declare const _default: any;
+export default _default;
+//# sourceMappingURL=ExpoAndroidOtpAutofill.d.ts.map

package/build/ExpoAndroidOtpAutofill.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ExpoAndroidOtpAutofill.d.ts","sourceRoot":"","sources":["../src/ExpoAndroidOtpAutofill.ts"],"names":[],"mappings":";AAEA,wBAAqE"}

package/build/ExpoAndroidOtpAutofill.types.d.ts

@@ -0,0 +1,27 @@
+import type { StyleProp, ViewStyle } from 'react-native';
+export type OnLoadEventPayload = {
+    url: string;
+};
+export type OnOtpReceivedPayload = {
+    otp: string;
+    /** Full SMS body when received via SMS Retriever API; not set for READ_SMS. */
+    message?: string;
+};
+export type OnSmsRetrieverTimeoutPayload = {
+    timedOut: boolean;
+};
+export type ExpoAndroidOtpAutofillModuleEvents = {
+    onOtpReceived: (payload: OnOtpReceivedPayload) => void;
+    onSmsRetrieverTimeout: (payload: OnSmsRetrieverTimeoutPayload) => void;
+};
+export type ChangeEventPayload = {
+    value: string;
+};
+export type ExpoAndroidOtpAutofillViewProps = {
+    url: string;
+    onLoad: (event: {
+        nativeEvent: OnLoadEventPayload;
+    }) => void;
+    style?: StyleProp<ViewStyle>;
+};
+//# sourceMappingURL=ExpoAndroidOtpAutofill.types.d.ts.map

package/build/ExpoAndroidOtpAutofill.types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ExpoAndroidOtpAutofill.types.d.ts","sourceRoot":"","sources":["../src/ExpoAndroidOtpAutofill.types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAEzD,MAAM,MAAM,kBAAkB,GAAG;IAC/B,GAAG,EAAE,MAAM,CAAC;CACb,CAAC;AAEF,MAAM,MAAM,oBAAoB,GAAG;IACjC,GAAG,EAAE,MAAM,CAAC;IACZ,+EAA+E;IAC/E,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB,CAAC;AAEF,MAAM,MAAM,4BAA4B,GAAG;IACzC,QAAQ,EAAE,OAAO,CAAC;CACnB,CAAC;AAEF,MAAM,MAAM,kCAAkC,GAAG;IAC/C,aAAa,EAAE,CAAC,OAAO,EAAE,oBAAoB,KAAK,IAAI,CAAC;IACvD,qBAAqB,EAAE,CAAC,OAAO,EAAE,4BAA4B,KAAK,IAAI,CAAC;CACxE,CAAC;AAEF,MAAM,MAAM,kBAAkB,GAAG;IAC/B,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAEF,MAAM,MAAM,+BAA+B,GAAG;IAC5C,GAAG,EAAE,MAAM,CAAC;IACZ,MAAM,EAAE,CAAC,KAAK,EAAE;QAAE,WAAW,EAAE,kBAAkB,CAAA;KAAE,KAAK,IAAI,CAAC;IAC7D,KAAK,CAAC,EAAE,SAAS,CAAC,SAAS,CAAC,CAAC;CAC9B,CAAC"}

package/build/ExpoAndroidOtpAutofillView.d.ts

@@ -0,0 +1,4 @@
+import * as React from 'react';
+import { ExpoAndroidOtpAutofillViewProps } from './ExpoAndroidOtpAutofill.types';
+export default function ExpoAndroidOtpAutofillView(props: ExpoAndroidOtpAutofillViewProps): React.JSX.Element;
+//# sourceMappingURL=ExpoAndroidOtpAutofillView.d.ts.map

package/build/ExpoAndroidOtpAutofillView.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ExpoAndroidOtpAutofillView.d.ts","sourceRoot":"","sources":["../src/ExpoAndroidOtpAutofillView.tsx"],"names":[],"mappings":"AACA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAE/B,OAAO,EAAE,+BAA+B,EAAE,MAAM,gCAAgC,CAAC;AAKjF,MAAM,CAAC,OAAO,UAAU,0BAA0B,CAAC,KAAK,EAAE,+BAA+B,qBAExF"}

package/build/OtpAutofill.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Event name emitted by the native module when an OTP is read from SMS.
+ * Subscribe with `addOtpListener()`.
+ */
+export declare const OTP_EVENT_NAME = "onOtpReceived";
+/**
+ * Event name emitted when the SMS Retriever API times out (~5 minutes without a matching SMS).
+ * Subscribe with `addSmsRetrieverTimeoutListener()`.
+ */
+export declare const SMS_RETRIEVER_TIMEOUT_EVENT_NAME = "onSmsRetrieverTimeout";
+/** True when running on Android (OTP from SMS is only supported on Android). */
+export declare function isAndroid(): boolean;
+/** Default OTP length used when not specified (common for SMS codes). */
+export declare const DEFAULT_OTP_LENGTH = 6;
+/** Supported OTP length (4–8 digits). Used to match OTP in SMS body. */
+export type OtpLength = 4 | 5 | 6 | 7 | 8;
+export type StartOtpListenerOptions = {
+    /** Number of digits to match (4–8). Default 6. */
+    length?: OtpLength;
+};
+/**
+ * Start listening for incoming SMS and parsing OTP of the given length.
+ * Requests READ_SMS permission if needed. Call `stopOtpListener()` when done.
+ * No-op on iOS and web.
+ * @param options Optional `{ length: 4|5|6|7|8 }`. Default 6 when omitted.
+ */
+export declare function startOtpListener(options?: StartOtpListenerOptions): void;
+/**
+ * Stop the SMS listener and polling.
+ * No-op on iOS and web.
+ */
+export declare function stopOtpListener(): void;
+/**
+ * Get the 11-character app hash required for SMS Retriever API verification messages.
+ * Your backend must include this hash in the SMS so the message can be delivered to your app.
+ * No permission required. Returns null on iOS/web or if unavailable.
+ * @see https://developers.google.com/identity/sms-retriever/verify
+ */
+export declare function getAppHash(): Promise<string | null>;
+/**
+ * Start listening via SMS Retriever API (no READ_SMS permission).
+ * The SMS must contain your app hash (from getAppHash()) and be ≤140 bytes.
+ * Times out after ~5 minutes. Same onOtpReceived events as startOtpListener.
+ * No-op on iOS and web.
+ */
+export declare function startSmsRetrieverListener(options?: StartOtpListenerOptions): void;
+/**
+ * Stop the SMS Retriever listener (unregister receiver).
+ * No-op on iOS and web.
+ */
+export declare function stopSmsRetrieverListener(): void;
+/**
+ * Subscribe to OTP events. Call the returned function to unsubscribe.
+ * @param callback Called with the OTP string (4–8 digits) when detected from SMS.
+ * @returns Unsubscribe function.
+ */
+export declare function addOtpListener(callback: (otp: string) => void): () => void;
+/**
+ * Subscribe to SMS Retriever timeout events (fired when no matching SMS is received within ~5 minutes).
+ * Use this to show "Didn't get the code?" / "Resend" when using startSmsRetrieverListener().
+ * @param callback Called when the retriever times out.
+ * @returns Unsubscribe function.
+ */
+export declare function addSmsRetrieverTimeoutListener(callback: () => void): () => void;
+//# sourceMappingURL=OtpAutofill.d.ts.map

package/build/OtpAutofill.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"OtpAutofill.d.ts","sourceRoot":"","sources":["../src/OtpAutofill.ts"],"names":[],"mappings":"AAKA;;;GAGG;AACH,eAAO,MAAM,cAAc,kBAAkB,CAAC;AAE9C;;;GAGG;AACH,eAAO,MAAM,gCAAgC,0BAA0B,CAAC;AAExE,gFAAgF;AAChF,wBAAgB,SAAS,IAAI,OAAO,CAEnC;AAED,yEAAyE;AACzE,eAAO,MAAM,kBAAkB,IAAI,CAAC;AAEpC,wEAAwE;AACxE,MAAM,MAAM,SAAS,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;AAE1C,MAAM,MAAM,uBAAuB,GAAG;IACpC,kDAAkD;IAClD,MAAM,CAAC,EAAE,SAAS,CAAC;CACpB,CAAC;AAEF;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,CAAC,EAAE,uBAAuB,GAAG,IAAI,CAQxE;AAED;;;GAGG;AACH,wBAAgB,eAAe,IAAI,IAAI,CAItC;AAED;;;;;GAKG;AACH,wBAAsB,UAAU,IAAI,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAGzD;AAED;;;;;GAKG;AACH,wBAAgB,yBAAyB,CAAC,OAAO,CAAC,EAAE,uBAAuB,GAAG,IAAI,CAQjF;AAED;;;GAGG;AACH,wBAAgB,wBAAwB,IAAI,IAAI,CAI/C;AAED;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,QAAQ,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,IAAI,GAAG,MAAM,IAAI,CAK1E;AAED;;;;;GAKG;AACH,wBAAgB,8BAA8B,CAAC,QAAQ,EAAE,MAAM,IAAI,GAAG,MAAM,IAAI,CAK/E"}

package/build/index.d.ts

@@ -0,0 +1,9 @@
+export { startOtpListener, stopOtpListener, addOtpListener, getAppHash, startSmsRetrieverListener, stopSmsRetrieverListener, addSmsRetrieverTimeoutListener, OTP_EVENT_NAME, SMS_RETRIEVER_TIMEOUT_EVENT_NAME, DEFAULT_OTP_LENGTH, } from './OtpAutofill';
+export type { OtpLength, StartOtpListenerOptions } from './OtpAutofill';
+export { useOtpVerify } from './useOtpVerify';
+export type { UseOtpVerifyOptions, UseOtpVerifyResult } from './useOtpVerify';
+export { default } from './ExpoAndroidOtpAutofill';
+export { default as ExpoAndroidOtpAutofillView } from './ExpoAndroidOtpAutofillView';
+export type { ExpoAndroidOtpAutofillModuleEvents, OnOtpReceivedPayload, OnSmsRetrieverTimeoutPayload } from './ExpoAndroidOtpAutofill.types';
+export * from './ExpoAndroidOtpAutofill.types';
+//# sourceMappingURL=index.d.ts.map

package/build/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,gBAAgB,EAChB,eAAe,EACf,cAAc,EACd,UAAU,EACV,yBAAyB,EACzB,wBAAwB,EACxB,8BAA8B,EAC9B,cAAc,EACd,gCAAgC,EAChC,kBAAkB,GACnB,MAAM,eAAe,CAAC;AACvB,YAAY,EAAE,SAAS,EAAE,uBAAuB,EAAE,MAAM,eAAe,CAAC;AACxE,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAC9C,YAAY,EAAE,mBAAmB,EAAE,kBAAkB,EAAE,MAAM,gBAAgB,CAAC;AAC9E,OAAO,EAAE,OAAO,EAAE,MAAM,0BAA0B,CAAC;AACnD,OAAO,EAAE,OAAO,IAAI,0BAA0B,EAAE,MAAM,8BAA8B,CAAC;AACrF,YAAY,EAAE,kCAAkC,EAAE,oBAAoB,EAAE,4BAA4B,EAAE,MAAM,gCAAgC,CAAC;AAC7I,cAAc,gCAAgC,CAAC"}

package/build/useOtpVerify.d.ts

@@ -0,0 +1,30 @@
+import type { OtpLength } from './OtpAutofill';
+export type UseOtpVerifyOptions = {
+    /** Number of OTP digits to match (4–8). Default 6. */
+    numberOfDigits?: OtpLength;
+    /** Called when an OTP is received (e.g. to sync to a form field). */
+    onOtpReceived?: (otp: string) => void;
+};
+export type UseOtpVerifyResult = {
+    /** App hash for SMS Retriever (from getAppHash()). Include in your SMS template. */
+    hash: string | null;
+    /** OTP extracted from the last received SMS, or null. */
+    otp: string | null;
+    /** Full SMS message when received via SMS Retriever; null otherwise. */
+    message: string | null;
+    /** True when SMS Retriever timed out (~5 min). Show "Resend" or "Didn't get code?". */
+    timeoutError: boolean;
+    /** Start listening again (e.g. after timeout or to retry). */
+    startListener: () => void;
+    /** Stop the SMS Retriever listener. */
+    stopListener: () => void;
+};
+/**
+ * Hook for SMS Retriever API (no READ_SMS).
+ * Returns hash, otp, message, timeoutError, startListener, stopListener.
+ *
+ * @example
+ * const { hash, otp, message, timeoutError, startListener, stopListener } = useOtpVerify({ numberOfDigits: 4 });
+ */
+export declare function useOtpVerify(options?: UseOtpVerifyOptions): UseOtpVerifyResult;
+//# sourceMappingURL=useOtpVerify.d.ts.map

package/build/useOtpVerify.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useOtpVerify.d.ts","sourceRoot":"","sources":["../src/useOtpVerify.ts"],"names":[],"mappings":"AAYA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAE/C,MAAM,MAAM,mBAAmB,GAAG;IAChC,sDAAsD;IACtD,cAAc,CAAC,EAAE,SAAS,CAAC;IAC3B,qEAAqE;IACrE,aAAa,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,IAAI,CAAC;CACvC,CAAC;AAEF,MAAM,MAAM,kBAAkB,GAAG;IAC/B,oFAAoF;IACpF,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IACpB,yDAAyD;IACzD,GAAG,EAAE,MAAM,GAAG,IAAI,CAAC;IACnB,wEAAwE;IACxE,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IACvB,uFAAuF;IACvF,YAAY,EAAE,OAAO,CAAC;IACtB,8DAA8D;IAC9D,aAAa,EAAE,MAAM,IAAI,CAAC;IAC1B,uCAAuC;IACvC,YAAY,EAAE,MAAM,IAAI,CAAC;CAC1B,CAAC;AAIF;;;;;;GAMG;AACH,wBAAgB,YAAY,CAAC,OAAO,GAAE,mBAAwB,GAAG,kBAAkB,CAwDlF"}

package/expo-module.config.json

@@ -0,0 +1,6 @@
+{
+  "platforms": ["android"],
+  "android": {
+    "modules": ["expo.modules.androidotpautofill.ExpoAndroidOtpAutofillModule"]
+  }
+}

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "expo-android-otp-autofill",
+  "version": "0.1.0",
+  "description": "Android-only Expo module to auto-detect OTP from SMS and fill your verification field. READ_SMS and Play Services Auth are declared in the module. No config plugin or third-party OTP library required.",
+  "main": "build/index.js",
+  "types": "build/index.d.ts",
+  "scripts": {
+    "build": "expo-module build",
+    "clean": "expo-module clean",
+    "lint": "expo-module lint",
+    "test": "expo-module test",
+    "prepare": "expo-module prepare",
+    "prepublishOnly": "expo-module prepublishOnly",
+    "expo-module": "expo-module",
+    "open:android": "open -a \"Android Studio\" example/android"
+  },
+  "keywords": [
+    "react-native",
+    "expo",
+    "android",
+    "otp",
+    "sms",
+    "autofill",
+    "expo-android-otp-autofill",
+    "ExpoAndroidOtpAutofill"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/mayurbabariya45/expo-android-otp-autofill.git"
+  },
+  "bugs": {
+    "url": "https://github.com/mayurbabariya45/expo-android-otp-autofill/issues"
+  },
+  "author": "Mayur Babaria <mayurbabariya45@gmail.com> (https://github.com/mayurbabariya45)",
+  "license": "MIT",
+  "homepage": "https://github.com/mayurbabariya45/expo-android-otp-autofill#readme",
+  "files": [
+    "build",
+    "android",
+    "expo-module.config.json"
+  ],
+  "dependencies": {},
+  "devDependencies": {
+    "@types/react": "~19.1.1",
+    "expo-module-scripts": "^55.0.2",
+    "expo": "^55.0.5",
+    "react-native": "0.82.1"
+  },
+  "peerDependencies": {
+    "expo": "*",
+    "react": "*",
+    "react-native": "*"
+  }
+}