@capawesome/capacitor-android-sms-retriever 0.0.1

package/CapawesomeCapacitorAndroidSmsRetriever.podspec

@@ -0,0 +1,17 @@
+require 'json'
+
+package = JSON.parse(File.read(File.join(__dir__, 'package.json')))
+
+Pod::Spec.new do |s|
+  s.name = 'CapawesomeCapacitorAndroidSmsRetriever'
+  s.version = package['version']
+  s.summary = package['description']
+  s.license = package['license']
+  s.homepage = package['repository']['url']
+  s.author = package['author']
+  s.source = { :git => package['repository']['url'], :tag => s.version.to_s }
+  s.source_files = 'ios/Plugin/**/*.{swift,h,m,c,cc,mm,cpp}'
+  s.ios.deployment_target = '15.0'
+  s.dependency 'Capacitor'
+  s.swift_version = '5.1'
+end

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Robin Genz
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/Package.swift

@@ -0,0 +1,28 @@
+// swift-tools-version: 5.9
+import PackageDescription
+
+let package = Package(
+    name: "CapawesomeCapacitorAndroidSmsRetriever",
+    platforms: [.iOS(.v15)],
+    products: [
+        .library(
+            name: "CapawesomeCapacitorAndroidSmsRetriever",
+            targets: ["AndroidSmsRetrieverPlugin"])
+    ],
+    dependencies: [
+        .package(url: "https://github.com/ionic-team/capacitor-swift-pm.git", from: "8.0.0")
+    ],
+    targets: [
+        .target(
+            name: "AndroidSmsRetrieverPlugin",
+            dependencies: [
+                .product(name: "Capacitor", package: "capacitor-swift-pm"),
+                .product(name: "Cordova", package: "capacitor-swift-pm")
+            ],
+            path: "ios/Plugin"),
+        .testTarget(
+            name: "AndroidSmsRetrieverPluginTests",
+            dependencies: ["AndroidSmsRetrieverPlugin"],
+            path: "ios/PluginTests")
+    ]
+)

package/README.md

@@ -0,0 +1,206 @@
+# @capawesome/capacitor-android-sms-retriever
+
+Capacitor plugin for OTP autofill on Android via the SMS User Consent and Phone Number Hint APIs.
+
+<div class="capawesome-z29o10a">
+  <a href="https://cloud.capawesome.io/" target="_blank">
+    <img alt="Deliver Live Updates to your Capacitor app with Capawesome Cloud" src="https://cloud.capawesome.io/assets/banners/cloud-build-and-deploy-capacitor-apps.png?t=1" />
+  </a>
+</div>
+
+## Features
+
+- 💬 **SMS User Consent**: Read an incoming verification SMS after a one-tap system consent dialog.
+- 📞 **Phone Number Hint**: Prefill the user's phone number via the system bottom sheet.
+- 🔒 **No SMS permissions**: Uses Play-policy-safe APIs that require no SMS permissions.
+- 🔁 **Up-to-date**: Always supports the latest Capacitor version.
+
+Missing a feature? Just [open an issue](https://github.com/capawesome-team/capacitor-plugins/issues) and we'll take a look!
+
+## Newsletter
+
+Stay up to date with the latest news and updates about the Capawesome, Capacitor, and Ionic ecosystem by subscribing to our [Capawesome Newsletter](https://cloud.capawesome.io/newsletter/).
+
+## Compatibility
+
+| Plugin Version | Capacitor Version | Status         |
+| -------------- | ----------------- | -------------- |
+| 0.x.x          | >=8.x.x           | Active support |
+
+## Installation
+
+You can use our **AI-Assisted Setup** to install the plugin.
+Add the [Capawesome Skills](https://github.com/capawesome-team/skills) to your AI tool using the following command:
+
+```bash
+npx skills add capawesome-team/skills --skill capacitor-plugins
+```
+
+Then use the following prompt:
+
+```
+ Use the `capacitor-plugins` skill from `capawesome-team/skills` to install the `@capawesome/capacitor-android-sms-retriever` plugin in my project.
+```
+
+If you prefer **Manual Setup**, install the plugin by running the following commands and follow the platform-specific instructions below:
+
+```bash
+npm install @capawesome/capacitor-android-sms-retriever
+npx cap sync
+```
+
+This plugin is only available on **Android**. On iOS and Web, all methods reject as unimplemented (see [iOS](#ios) below).
+
+### Android
+
+#### Variables
+
+This plugin will use the following project variables (defined in your app's `variables.gradle` file):
+
+- `$playServicesAuthVersion` version of `com.google.android.gms:play-services-auth` (default: `21.5.0`)
+- `$playServicesAuthApiPhoneVersion` version of `com.google.android.gms:play-services-auth-api-phone` (default: `18.3.0`)
+
+### iOS
+
+This plugin has **no iOS implementation** and you don't need one. iOS already autofills one-time codes from incoming SMS messages in `WKWebView` when the input field uses `autocomplete="one-time-code"`:
+
+```html
+<input autocomplete="one-time-code" />
+```
+
+All methods reject as unimplemented on iOS.
+
+## Configuration
+
+No configuration required for this plugin.
+
+## Usage
+
+```typescript
+import { AndroidSmsRetriever } from '@capawesome/capacitor-android-sms-retriever';
+
+const requestPhoneNumber = async () => {
+  const { phoneNumber } = await AndroidSmsRetriever.requestPhoneNumber();
+  return phoneNumber;
+};
+
+const retrieveSms = async () => {
+  const { message } = await AndroidSmsRetriever.retrieveSms();
+  // Extract the one-time code from the message.
+  const code = message.match(/\d{6}/)?.[0];
+  return code;
+};
+```
+
+## API
+
+<docgen-index>
+
+* [`requestPhoneNumber()`](#requestphonenumber)
+* [`retrieveSms(...)`](#retrievesms)
+* [Interfaces](#interfaces)
+
+</docgen-index>
+
+<docgen-api>
+<!--Update the source file JSDoc comments and rerun docgen to update the docs below-->
+
+### requestPhoneNumber()
+
+```typescript
+requestPhoneNumber() => Promise<RequestPhoneNumberResult>
+```
+
+Request the user's phone number via the Phone Number Hint API.
+
+A system bottom sheet is displayed that lets the user pick one of the
+phone numbers associated with the device. The selected phone number is
+returned so it can be used to prefill a phone number input field.
+
+Only available on Android.
+
+**Returns:** <code>Promise&lt;<a href="#requestphonenumberresult">RequestPhoneNumberResult</a>&gt;</code>
+
+**Since:** 0.1.0
+
+--------------------
+
+
+### retrieveSms(...)
+
+```typescript
+retrieveSms(options?: RetrieveSmsOptions | undefined) => Promise<RetrieveSmsResult>
+```
+
+Retrieve an incoming verification SMS via the SMS User Consent API.
+
+A system consent dialog is displayed when a matching SMS is received.
+The promise resolves with the full message text once the user consents,
+so the app can extract the one-time code itself.
+
+The underlying broadcast waits up to 5 minutes for a matching SMS. If no
+SMS is received within this time, the promise rejects with the error
+code `TIMEOUT`.
+
+Only available on Android.
+
+| Param         | Type                                                              |
+| ------------- | ----------------------------------------------------------------- |
+| **`options`** | <code><a href="#retrievesmsoptions">RetrieveSmsOptions</a></code> |
+
+**Returns:** <code>Promise&lt;<a href="#retrievesmsresult">RetrieveSmsResult</a>&gt;</code>
+
+**Since:** 0.1.0
+
+--------------------
+
+
+### Interfaces
+
+
+#### RequestPhoneNumberResult
+
+| Prop              | Type                | Description                            | Since |
+| ----------------- | ------------------- | -------------------------------------- | ----- |
+| **`phoneNumber`** | <code>string</code> | The phone number selected by the user. | 0.1.0 |
+
+
+#### RetrieveSmsResult
+
+| Prop          | Type                | Description                                                                                                           | Since |
+| ------------- | ------------------- | --------------------------------------------------------------------------------------------------------------------- | ----- |
+| **`message`** | <code>string</code> | The full text of the retrieved SMS message. The app is responsible for extracting the one-time code from the message. | 0.1.0 |
+
+
+#### RetrieveSmsOptions
+
+| Prop                    | Type                | Description                                                                                                           | Since |
+| ----------------------- | ------------------- | --------------------------------------------------------------------------------------------------------------------- | ----- |
+| **`senderPhoneNumber`** | <code>string</code> | The phone number of the sender to filter incoming messages by. If not provided, the SMS from any sender is retrieved. | 0.1.0 |
+
+</docgen-api>
+
+## Extracting the One-Time Code
+
+The `retrieveSms(...)` method resolves with the full text of the incoming SMS message. Your app is responsible for extracting the one-time code from the message, for example with a regular expression:
+
+```typescript
+const { message } = await AndroidSmsRetriever.retrieveSms();
+const code = message.match(/\d{6}/)?.[0];
+```
+
+For the SMS User Consent API to detect a message, the SMS must:
+
+- contain a one-time code that the user sends back to your server to complete the verification,
+- be no longer than 140 bytes,
+- not originate from a phone number in the user's contacts.
+
+The underlying broadcast waits up to 5 minutes for a matching SMS. If no message is received within this time, the promise rejects with the error code `TIMEOUT`.
+
+## Changelog
+
+See [CHANGELOG.md](https://github.com/capawesome-team/capacitor-plugins/blob/main/packages/android-sms-retriever/CHANGELOG.md).
+
+## License
+
+See [LICENSE](https://github.com/capawesome-team/capacitor-plugins/blob/main/packages/android-sms-retriever/LICENSE).

package/android/build.gradle

@@ -0,0 +1,62 @@
+ext {
+    junitVersion = project.hasProperty('junitVersion') ? rootProject.ext.junitVersion : '4.13.2'
+    androidxAppCompatVersion = project.hasProperty('androidxAppCompatVersion') ? rootProject.ext.androidxAppCompatVersion : '1.7.1'
+    androidxJunitVersion = project.hasProperty('androidxJunitVersion') ? rootProject.ext.androidxJunitVersion : '1.3.0'
+    androidxEspressoCoreVersion = project.hasProperty('androidxEspressoCoreVersion') ? rootProject.ext.androidxEspressoCoreVersion : '3.7.0'
+    playServicesAuthVersion = project.hasProperty('playServicesAuthVersion') ? rootProject.ext.playServicesAuthVersion : '21.5.0'
+    playServicesAuthApiPhoneVersion = project.hasProperty('playServicesAuthApiPhoneVersion') ? rootProject.ext.playServicesAuthApiPhoneVersion : '18.3.0'
+}
+
+buildscript {
+    repositories {
+        google()
+        mavenCentral()
+    }
+    dependencies {
+        classpath 'com.android.tools.build:gradle:8.13.0'
+    }
+}
+
+apply plugin: 'com.android.library'
+
+android {
+    namespace = "io.capawesome.capacitorjs.plugins.androidsmsretriever"
+    compileSdk = project.hasProperty('compileSdkVersion') ? rootProject.ext.compileSdkVersion : 36
+    defaultConfig {
+        minSdkVersion project.hasProperty('minSdkVersion') ? rootProject.ext.minSdkVersion : 24
+        targetSdkVersion project.hasProperty('targetSdkVersion') ? rootProject.ext.targetSdkVersion : 36
+        versionCode 1
+        versionName "1.0"
+        testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
+    }
+    buildTypes {
+        release {
+            minifyEnabled false
+            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
+        }
+    }
+    lintOptions {
+        abortOnError = false
+    }
+    compileOptions {
+        sourceCompatibility JavaVersion.VERSION_21
+        targetCompatibility JavaVersion.VERSION_21
+    }
+}
+
+repositories {
+    google()
+    mavenCentral()
+}
+
+
+dependencies {
+    implementation fileTree(dir: 'libs', include: ['*.jar'])
+    implementation project(':capacitor-android')
+    implementation "androidx.appcompat:appcompat:$androidxAppCompatVersion"
+    implementation "com.google.android.gms:play-services-auth:$playServicesAuthVersion"
+    implementation "com.google.android.gms:play-services-auth-api-phone:$playServicesAuthApiPhoneVersion"
+    testImplementation "junit:junit:$junitVersion"
+    androidTestImplementation "androidx.test.ext:junit:$androidxJunitVersion"
+    androidTestImplementation "androidx.test.espresso:espresso-core:$androidxEspressoCoreVersion"
+}

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"></manifest>

package/android/src/main/java/io/capawesome/capacitorjs/plugins/androidsmsretriever/AndroidSmsRetriever.java

@@ -0,0 +1,194 @@
+package io.capawesome.capacitorjs.plugins.androidsmsretriever;
+
+import android.content.BroadcastReceiver;
+import android.content.Context;
+import android.content.Intent;
+import android.content.IntentFilter;
+import android.os.Bundle;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.core.content.ContextCompat;
+import com.google.android.gms.auth.api.identity.GetPhoneNumberHintIntentRequest;
+import com.google.android.gms.auth.api.identity.Identity;
+import com.google.android.gms.auth.api.phone.SmsRetriever;
+import com.google.android.gms.common.ConnectionResult;
+import com.google.android.gms.common.GoogleApiAvailability;
+import com.google.android.gms.common.api.CommonStatusCodes;
+import com.google.android.gms.common.api.Status;
+import io.capawesome.capacitorjs.plugins.androidsmsretriever.classes.CustomExceptions;
+import io.capawesome.capacitorjs.plugins.androidsmsretriever.classes.options.RetrieveSmsOptions;
+import io.capawesome.capacitorjs.plugins.androidsmsretriever.classes.results.RequestPhoneNumberResult;
+import io.capawesome.capacitorjs.plugins.androidsmsretriever.classes.results.RetrieveSmsResult;
+import io.capawesome.capacitorjs.plugins.androidsmsretriever.interfaces.NonEmptyResultCallback;
+
+public class AndroidSmsRetriever {
+
+    @NonNull
+    private final AndroidSmsRetrieverPlugin plugin;
+
+    @Nullable
+    private NonEmptyResultCallback<RequestPhoneNumberResult> pendingPhoneNumberCallback;
+
+    @Nullable
+    private NonEmptyResultCallback<RetrieveSmsResult> pendingRetrieveSmsCallback;
+
+    @Nullable
+    private BroadcastReceiver smsBroadcastReceiver;
+
+    public AndroidSmsRetriever(@NonNull AndroidSmsRetrieverPlugin plugin) {
+        this.plugin = plugin;
+    }
+
+    public void handleOnDestroy() {
+        unregisterSmsBroadcastReceiver();
+        pendingPhoneNumberCallback = null;
+        pendingRetrieveSmsCallback = null;
+    }
+
+    public void handlePhoneNumberCanceled() {
+        if (pendingPhoneNumberCallback == null) {
+            return;
+        }
+        NonEmptyResultCallback<RequestPhoneNumberResult> callback = pendingPhoneNumberCallback;
+        pendingPhoneNumberCallback = null;
+        callback.error(CustomExceptions.CANCELED);
+    }
+
+    public void handlePhoneNumberResult(@Nullable Intent data) {
+        if (pendingPhoneNumberCallback == null) {
+            return;
+        }
+        NonEmptyResultCallback<RequestPhoneNumberResult> callback = pendingPhoneNumberCallback;
+        pendingPhoneNumberCallback = null;
+        try {
+            String phoneNumber = Identity.getSignInClient(plugin.getActivity()).getPhoneNumberFromIntent(data);
+            callback.success(new RequestPhoneNumberResult(phoneNumber));
+        } catch (Exception exception) {
+            callback.error(CustomExceptions.PHONE_NUMBER_HINT_FAILED);
+        }
+    }
+
+    public void handleSmsConsentCanceled() {
+        rejectPendingRetrieveSms(CustomExceptions.USER_DENIED);
+    }
+
+    public void handleSmsConsentResult(@Nullable Intent data) {
+        if (pendingRetrieveSmsCallback == null) {
+            return;
+        }
+        NonEmptyResultCallback<RetrieveSmsResult> callback = pendingRetrieveSmsCallback;
+        pendingRetrieveSmsCallback = null;
+        String message = data == null ? null : data.getStringExtra(SmsRetriever.EXTRA_SMS_MESSAGE);
+        if (message == null) {
+            callback.error(CustomExceptions.RETRIEVE_FAILED);
+        } else {
+            callback.success(new RetrieveSmsResult(message));
+        }
+    }
+
+    public boolean isGooglePlayServicesAvailable() {
+        int result = GoogleApiAvailability.getInstance().isGooglePlayServicesAvailable(plugin.getContext());
+        return result == ConnectionResult.SUCCESS;
+    }
+
+    public void requestPhoneNumber(@NonNull NonEmptyResultCallback<RequestPhoneNumberResult> callback) {
+        if (pendingPhoneNumberCallback != null) {
+            callback.error(CustomExceptions.OPERATION_IN_PROGRESS);
+            return;
+        }
+        GetPhoneNumberHintIntentRequest request = GetPhoneNumberHintIntentRequest.builder().build();
+        Identity.getSignInClient(plugin.getActivity())
+            .getPhoneNumberHintIntent(request)
+            .addOnSuccessListener(pendingIntent -> {
+                pendingPhoneNumberCallback = callback;
+                plugin.launchPhoneNumberHintIntent(pendingIntent);
+            })
+            .addOnFailureListener(exception -> callback.error(CustomExceptions.PHONE_NUMBER_HINT_FAILED));
+    }
+
+    public void retrieveSms(@NonNull RetrieveSmsOptions options, @NonNull NonEmptyResultCallback<RetrieveSmsResult> callback) {
+        if (pendingRetrieveSmsCallback != null) {
+            callback.error(CustomExceptions.OPERATION_IN_PROGRESS);
+            return;
+        }
+        pendingRetrieveSmsCallback = callback;
+        registerSmsBroadcastReceiver();
+        SmsRetriever.getClient(plugin.getContext())
+            .startSmsUserConsent(options.getSenderPhoneNumber())
+            .addOnFailureListener(exception -> rejectPendingRetrieveSms(CustomExceptions.RETRIEVE_FAILED));
+    }
+
+    private void handleSmsBroadcast(@NonNull Intent intent) {
+        if (!SmsRetriever.SMS_RETRIEVED_ACTION.equals(intent.getAction())) {
+            return;
+        }
+        Bundle extras = intent.getExtras();
+        if (extras == null) {
+            rejectPendingRetrieveSms(CustomExceptions.RETRIEVE_FAILED);
+            return;
+        }
+        Status status = (Status) extras.get(SmsRetriever.EXTRA_STATUS);
+        if (status == null) {
+            rejectPendingRetrieveSms(CustomExceptions.RETRIEVE_FAILED);
+            return;
+        }
+        switch (status.getStatusCode()) {
+            case CommonStatusCodes.SUCCESS:
+                Intent consentIntent = (Intent) extras.get(SmsRetriever.EXTRA_CONSENT_INTENT);
+                unregisterSmsBroadcastReceiver();
+                if (consentIntent == null) {
+                    rejectPendingRetrieveSms(CustomExceptions.RETRIEVE_FAILED);
+                } else {
+                    plugin.launchSmsConsentIntent(consentIntent);
+                }
+                break;
+            case CommonStatusCodes.TIMEOUT:
+                rejectPendingRetrieveSms(CustomExceptions.TIMEOUT);
+                break;
+            default:
+                rejectPendingRetrieveSms(CustomExceptions.RETRIEVE_FAILED);
+                break;
+        }
+    }
+
+    private void registerSmsBroadcastReceiver() {
+        unregisterSmsBroadcastReceiver();
+        smsBroadcastReceiver = new BroadcastReceiver() {
+            @Override
+            public void onReceive(Context context, Intent intent) {
+                handleSmsBroadcast(intent);
+            }
+        };
+        IntentFilter filter = new IntentFilter(SmsRetriever.SMS_RETRIEVED_ACTION);
+        ContextCompat.registerReceiver(
+            plugin.getContext(),
+            smsBroadcastReceiver,
+            filter,
+            SmsRetriever.SEND_PERMISSION,
+            null,
+            ContextCompat.RECEIVER_EXPORTED
+        );
+    }
+
+    private void rejectPendingRetrieveSms(@NonNull Exception exception) {
+        unregisterSmsBroadcastReceiver();
+        if (pendingRetrieveSmsCallback == null) {
+            return;
+        }
+        NonEmptyResultCallback<RetrieveSmsResult> callback = pendingRetrieveSmsCallback;
+        pendingRetrieveSmsCallback = null;
+        callback.error(exception);
+    }
+
+    private void unregisterSmsBroadcastReceiver() {
+        if (smsBroadcastReceiver == null) {
+            return;
+        }
+        try {
+            plugin.getContext().unregisterReceiver(smsBroadcastReceiver);
+        } catch (IllegalArgumentException exception) {
+            // The receiver was not registered.
+        }
+        smsBroadcastReceiver = null;
+    }
+}

package/android/src/main/java/io/capawesome/capacitorjs/plugins/androidsmsretriever/AndroidSmsRetrieverPlugin.java

@@ -0,0 +1,153 @@
+package io.capawesome.capacitorjs.plugins.androidsmsretriever;
+
+import android.app.Activity;
+import android.app.PendingIntent;
+import android.content.Intent;
+import androidx.activity.result.ActivityResult;
+import androidx.activity.result.ActivityResultLauncher;
+import androidx.activity.result.IntentSenderRequest;
+import androidx.activity.result.contract.ActivityResultContracts;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import com.getcapacitor.Logger;
+import com.getcapacitor.Plugin;
+import com.getcapacitor.PluginCall;
+import com.getcapacitor.PluginMethod;
+import com.getcapacitor.annotation.CapacitorPlugin;
+import io.capawesome.capacitorjs.plugins.androidsmsretriever.classes.CustomException;
+import io.capawesome.capacitorjs.plugins.androidsmsretriever.classes.options.RetrieveSmsOptions;
+import io.capawesome.capacitorjs.plugins.androidsmsretriever.classes.results.RequestPhoneNumberResult;
+import io.capawesome.capacitorjs.plugins.androidsmsretriever.classes.results.RetrieveSmsResult;
+import io.capawesome.capacitorjs.plugins.androidsmsretriever.interfaces.NonEmptyResultCallback;
+import io.capawesome.capacitorjs.plugins.androidsmsretriever.interfaces.Result;
+
+@CapacitorPlugin(name = "AndroidSmsRetriever")
+public class AndroidSmsRetrieverPlugin extends Plugin {
+
+    public static final String ERROR_UNKNOWN_ERROR = "An unknown error occurred.";
+    public static final String TAG = "AndroidSmsRetrieverPlugin";
+
+    private AndroidSmsRetriever implementation;
+    private ActivityResultLauncher<IntentSenderRequest> phoneNumberHintLauncher;
+    private ActivityResultLauncher<Intent> smsConsentLauncher;
+
+    @Override
+    public void load() {
+        implementation = new AndroidSmsRetriever(this);
+        phoneNumberHintLauncher = getActivity()
+            .registerForActivityResult(new ActivityResultContracts.StartIntentSenderForResult(), this::handlePhoneNumberHintResult);
+        smsConsentLauncher = getActivity()
+            .registerForActivityResult(new ActivityResultContracts.StartActivityForResult(), this::handleSmsConsentResult);
+    }
+
+    @Override
+    protected void handleOnDestroy() {
+        super.handleOnDestroy();
+        if (implementation != null) {
+            implementation.handleOnDestroy();
+        }
+    }
+
+    public void launchPhoneNumberHintIntent(@NonNull PendingIntent pendingIntent) {
+        IntentSenderRequest request = new IntentSenderRequest.Builder(pendingIntent).build();
+        phoneNumberHintLauncher.launch(request);
+    }
+
+    public void launchSmsConsentIntent(@NonNull Intent intent) {
+        smsConsentLauncher.launch(intent);
+    }
+
+    @PluginMethod
+    public void requestPhoneNumber(PluginCall call) {
+        try {
+            if (!implementation.isGooglePlayServicesAvailable()) {
+                rejectCallAsUnavailable(call);
+                return;
+            }
+
+            NonEmptyResultCallback<RequestPhoneNumberResult> callback = new NonEmptyResultCallback<>() {
+                @Override
+                public void success(@NonNull RequestPhoneNumberResult result) {
+                    resolveCall(call, result);
+                }
+
+                @Override
+                public void error(@NonNull Exception exception) {
+                    rejectCall(call, exception);
+                }
+            };
+
+            implementation.requestPhoneNumber(callback);
+        } catch (Exception exception) {
+            rejectCall(call, exception);
+        }
+    }
+
+    @PluginMethod
+    public void retrieveSms(PluginCall call) {
+        try {
+            if (!implementation.isGooglePlayServicesAvailable()) {
+                rejectCallAsUnavailable(call);
+                return;
+            }
+
+            RetrieveSmsOptions options = new RetrieveSmsOptions(call);
+            NonEmptyResultCallback<RetrieveSmsResult> callback = new NonEmptyResultCallback<>() {
+                @Override
+                public void success(@NonNull RetrieveSmsResult result) {
+                    resolveCall(call, result);
+                }
+
+                @Override
+                public void error(@NonNull Exception exception) {
+                    rejectCall(call, exception);
+                }
+            };
+
+            implementation.retrieveSms(options, callback);
+        } catch (Exception exception) {
+            rejectCall(call, exception);
+        }
+    }
+
+    private void handlePhoneNumberHintResult(@NonNull ActivityResult result) {
+        if (result.getResultCode() == Activity.RESULT_OK) {
+            implementation.handlePhoneNumberResult(result.getData());
+        } else {
+            implementation.handlePhoneNumberCanceled();
+        }
+    }
+
+    private void handleSmsConsentResult(@NonNull ActivityResult result) {
+        if (result.getResultCode() == Activity.RESULT_OK) {
+            implementation.handleSmsConsentResult(result.getData());
+        } else {
+            implementation.handleSmsConsentCanceled();
+        }
+    }
+
+    private void rejectCall(@NonNull PluginCall call, @NonNull Exception exception) {
+        String message = exception.getMessage();
+        if (message == null) {
+            message = ERROR_UNKNOWN_ERROR;
+        }
+        String code = null;
+        if (exception instanceof CustomException) {
+            code = ((CustomException) exception).getCode();
+        }
+        Logger.error(TAG, message, exception);
+        call.reject(message, code);
+    }
+
+    private void rejectCallAsUnavailable(@NonNull PluginCall call) {
+        call.unavailable("Google Play services is not available on this device.");
+    }
+
+    private void resolveCall(@NonNull PluginCall call, @Nullable Result result) {
+        if (result == null) {
+            call.resolve();
+        } else {
+            call.resolve(result.toJSObject());
+        }
+    }
+}