@capgo/capacitor-android-sms-retriever 8.0.1

package/android/src/main/java/app/capgo/androidsmsretriever/AndroidSmsRetrieverPlugin.java

@@ -0,0 +1,224 @@
+package app.capgo.androidsmsretriever;
+
+import android.app.Activity;
+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 com.getcapacitor.JSObject;
+import com.getcapacitor.Logger;
+import com.getcapacitor.Plugin;
+import com.getcapacitor.PluginCall;
+import com.getcapacitor.PluginMethod;
+import com.getcapacitor.annotation.CapacitorPlugin;
+import com.google.android.gms.auth.api.identity.GetPhoneNumberHintIntentRequest;
+import com.google.android.gms.auth.api.identity.Identity;
+import com.google.android.gms.common.api.ApiException;
+
+@CapacitorPlugin(name = "AndroidSmsRetriever")
+public class AndroidSmsRetrieverPlugin extends Plugin {
+
+    private static final String TAG = "AndroidSmsRetriever";
+    private static final String EVENT_SMS_RECEIVED = "smsReceived";
+    private static final String EVENT_SMS_TIMEOUT = "smsRetrieverTimeout";
+    private static final String EVENT_SMS_ERROR = "smsRetrieverError";
+    private static final String STATUS_DONE = "SMS_RETRIEVER_DONE";
+
+    private final String pluginVersion = "8.0.1";
+    private AndroidSmsRetriever implementation;
+    private ActivityResultLauncher<IntentSenderRequest> phoneNumberHintLauncher;
+    private String pendingPhoneNumberCallId;
+
+    @Override
+    public void load() {
+        super.load();
+        implementation = new AndroidSmsRetriever(getContext());
+        implementation.setListener(
+            new AndroidSmsRetriever.SmsRetrieverListener() {
+                @Override
+                public void onSmsReceived(String message) {
+                    JSObject data = new JSObject();
+                    data.put("message", message);
+                    notifyListeners(EVENT_SMS_RECEIVED, data, true);
+                }
+
+                @Override
+                public void onTimeout() {
+                    notifyListeners(EVENT_SMS_TIMEOUT, new JSObject(), true);
+                }
+
+                @Override
+                public void onError(String message) {
+                    JSObject data = new JSObject();
+                    data.put("message", message);
+                    notifyListeners(EVENT_SMS_ERROR, data, true);
+                }
+            }
+        );
+        phoneNumberHintLauncher = bridge.registerForActivityResult(
+            new ActivityResultContracts.StartIntentSenderForResult(),
+            this::handlePhoneNumberHintResult
+        );
+    }
+
+    @PluginMethod
+    public void startWatch(PluginCall call) {
+        if (implementation == null) {
+            call.reject("Plugin is not initialized.");
+            return;
+        }
+
+        implementation.startWatch(
+            new AndroidSmsRetriever.StartWatchCallback() {
+                @Override
+                public void success(String status) {
+                    JSObject ret = new JSObject();
+                    ret.put("status", status);
+                    call.resolve(ret);
+                }
+
+                @Override
+                public void error(String message, Exception exception) {
+                    Logger.error(TAG, message, exception);
+                    call.reject(resolveMessage(message, exception), exception);
+                }
+            }
+        );
+    }
+
+    @PluginMethod
+    public void stopWatch(PluginCall call) {
+        if (implementation != null) {
+            implementation.stopWatch();
+        }
+
+        JSObject ret = new JSObject();
+        ret.put("status", STATUS_DONE);
+        call.resolve(ret);
+    }
+
+    @PluginMethod
+    public void getHashString(PluginCall call) {
+        if (implementation == null) {
+            call.reject("Plugin is not initialized.");
+            return;
+        }
+
+        try {
+            JSObject ret = new JSObject();
+            ret.put("hash", implementation.getHashString());
+            call.resolve(ret);
+        } catch (Exception exception) {
+            call.reject(resolveMessage("Could not get app signature hash.", exception), exception);
+        }
+    }
+
+    @PluginMethod
+    public void getPhoneNumber(PluginCall call) {
+        if (phoneNumberHintLauncher == null) {
+            call.reject("Phone Number Hint is not ready.");
+            return;
+        }
+
+        if (pendingPhoneNumberCallId != null) {
+            call.reject("Another Phone Number Hint request is already in progress.");
+            return;
+        }
+
+        Activity activity = getActivity();
+        if (activity == null) {
+            call.reject("Activity reference is unavailable.");
+            return;
+        }
+
+        GetPhoneNumberHintIntentRequest request = GetPhoneNumberHintIntentRequest.builder().build();
+        Identity.getSignInClient(activity)
+            .getPhoneNumberHintIntent(request)
+            .addOnSuccessListener((pendingIntent) -> {
+                try {
+                    bridge.saveCall(call);
+                    pendingPhoneNumberCallId = call.getCallbackId();
+                    IntentSenderRequest intentSenderRequest = new IntentSenderRequest.Builder(pendingIntent.getIntentSender()).build();
+                    phoneNumberHintLauncher.launch(intentSenderRequest);
+                } catch (Exception exception) {
+                    pendingPhoneNumberCallId = null;
+                    bridge.releaseCall(call);
+                    call.reject(resolveMessage("Unable to launch Phone Number Hint.", exception), exception);
+                }
+            })
+            .addOnFailureListener((exception) -> call.reject(resolveMessage("Unable to start Phone Number Hint.", exception), exception));
+    }
+
+    @PluginMethod
+    public void getPluginVersion(PluginCall call) {
+        JSObject ret = new JSObject();
+        ret.put("version", this.pluginVersion);
+        call.resolve(ret);
+    }
+
+    @Override
+    protected void handleOnDestroy() {
+        if (implementation != null) {
+            implementation.stopWatch();
+        }
+        super.handleOnDestroy();
+    }
+
+    private void handlePhoneNumberHintResult(ActivityResult result) {
+        PluginCall call = getPendingPhoneNumberCall();
+        if (call == null) {
+            pendingPhoneNumberCallId = null;
+            return;
+        }
+
+        try {
+            if (result.getResultCode() != Activity.RESULT_OK) {
+                call.reject("Phone number was not selected.");
+                return;
+            }
+
+            Intent data = result.getData();
+            if (data == null) {
+                call.reject("Phone Number Hint returned no data.");
+                return;
+            }
+
+            Activity activity = getActivity();
+            if (activity == null) {
+                call.reject("Activity reference is unavailable.");
+                return;
+            }
+
+            String phoneNumber = Identity.getSignInClient(activity).getPhoneNumberFromIntent(data);
+            JSObject ret = new JSObject();
+            ret.put("phoneNumber", phoneNumber);
+            call.resolve(ret);
+        } catch (ApiException exception) {
+            call.reject(resolveMessage("Could not read selected phone number.", exception), exception);
+        } finally {
+            releasePendingPhoneNumberCall(call);
+        }
+    }
+
+    private PluginCall getPendingPhoneNumberCall() {
+        if (pendingPhoneNumberCallId == null) {
+            return null;
+        }
+        return bridge.getSavedCall(pendingPhoneNumberCallId);
+    }
+
+    private void releasePendingPhoneNumberCall(PluginCall call) {
+        if (pendingPhoneNumberCallId != null) {
+            bridge.releaseCall(call);
+            pendingPhoneNumberCallId = null;
+        }
+    }
+
+    private String resolveMessage(String fallback, Exception exception) {
+        if (exception != null && exception.getMessage() != null && !exception.getMessage().isEmpty()) {
+            return exception.getMessage();
+        }
+        return fallback;
+    }
+}

package/android/src/main/java/app/capgo/androidsmsretriever/AppSignatureHashHelper.java

@@ -0,0 +1,78 @@
+package app.capgo.androidsmsretriever;
+
+import android.content.Context;
+import android.content.ContextWrapper;
+import android.content.pm.PackageInfo;
+import android.content.pm.PackageManager;
+import android.content.pm.Signature;
+import android.content.pm.SigningInfo;
+import android.os.Build;
+import android.util.Base64;
+import android.util.Log;
+import java.nio.charset.StandardCharsets;
+import java.security.MessageDigest;
+import java.security.NoSuchAlgorithmException;
+import java.util.ArrayList;
+import java.util.Arrays;
+
+public class AppSignatureHashHelper extends ContextWrapper {
+
+    private static final String LOG_TAG = AppSignatureHashHelper.class.getSimpleName();
+    private static final String HASH_TYPE = "SHA-256";
+    private static final int NUM_HASHED_BYTES = 9;
+    private static final int NUM_BASE64_CHAR = 11;
+
+    public AppSignatureHashHelper(Context context) {
+        super(context);
+    }
+
+    public ArrayList<String> getAppSignatures() {
+        ArrayList<String> appCodes = new ArrayList<>();
+        try {
+            String packageName = getPackageName();
+            Signature[] signatures = getSignatures(packageName);
+            for (Signature signature : signatures) {
+                String hash = hash(packageName, signature.toCharsString());
+                if (hash != null) {
+                    appCodes.add(hash);
+                }
+            }
+        } catch (PackageManager.NameNotFoundException exception) {
+            Log.e(LOG_TAG, "Unable to find package for SMS Retriever hash.", exception);
+        }
+        return appCodes;
+    }
+
+    private Signature[] getSignatures(String packageName) throws PackageManager.NameNotFoundException {
+        PackageManager packageManager = getPackageManager();
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P) {
+            PackageInfo packageInfo = packageManager.getPackageInfo(packageName, PackageManager.GET_SIGNING_CERTIFICATES);
+            SigningInfo signingInfo = packageInfo.signingInfo;
+            if (signingInfo == null) {
+                return new Signature[0];
+            }
+            if (signingInfo.hasMultipleSigners()) {
+                return signingInfo.getApkContentsSigners();
+            }
+            return signingInfo.getSigningCertificateHistory();
+        }
+
+        PackageInfo packageInfo = packageManager.getPackageInfo(packageName, PackageManager.GET_SIGNATURES);
+        return packageInfo.signatures;
+    }
+
+    private static String hash(String packageName, String signature) {
+        String appInfo = packageName + " " + signature;
+        try {
+            MessageDigest messageDigest = MessageDigest.getInstance(HASH_TYPE);
+            messageDigest.update(appInfo.getBytes(StandardCharsets.UTF_8));
+            byte[] hashSignature = messageDigest.digest();
+            hashSignature = Arrays.copyOfRange(hashSignature, 0, NUM_HASHED_BYTES);
+            String base64Hash = Base64.encodeToString(hashSignature, Base64.NO_PADDING | Base64.NO_WRAP);
+            return base64Hash.substring(0, NUM_BASE64_CHAR);
+        } catch (NoSuchAlgorithmException exception) {
+            Log.e(LOG_TAG, "Unable to calculate SMS Retriever hash.", exception);
+            return null;
+        }
+    }
+}

package/android/src/main/java/app/capgo/androidsmsretriever/SmsBroadcastReceiver.java

@@ -0,0 +1,79 @@
+package app.capgo.androidsmsretriever;
+
+import android.content.BroadcastReceiver;
+import android.content.Context;
+import android.content.Intent;
+import android.os.Bundle;
+import com.google.android.gms.auth.api.phone.SmsRetriever;
+import com.google.android.gms.common.api.CommonStatusCodes;
+import com.google.android.gms.common.api.Status;
+
+public class SmsBroadcastReceiver extends BroadcastReceiver {
+
+    public interface Listener {
+        void onSmsReceived(String message);
+        void onTimeout();
+        void onError(String message);
+    }
+
+    private Listener listener;
+
+    public void setListener(Listener listener) {
+        this.listener = listener;
+    }
+
+    @Override
+    public void onReceive(Context context, Intent intent) {
+        if (!SmsRetriever.SMS_RETRIEVED_ACTION.equals(intent.getAction())) {
+            return;
+        }
+
+        Bundle extras = intent.getExtras();
+        if (extras == null) {
+            emitError("SMS Retriever returned no extras.");
+            return;
+        }
+
+        Status status = (Status) extras.get(SmsRetriever.EXTRA_STATUS);
+        if (status == null) {
+            emitError("SMS Retriever returned no status.");
+            return;
+        }
+
+        switch (status.getStatusCode()) {
+            case CommonStatusCodes.SUCCESS:
+                String message = (String) extras.get(SmsRetriever.EXTRA_SMS_MESSAGE);
+                if (message == null) {
+                    emitError("SMS Retriever returned no message.");
+                    return;
+                }
+                if (listener != null) {
+                    listener.onSmsReceived(message);
+                }
+                break;
+            case CommonStatusCodes.TIMEOUT:
+                if (listener != null) {
+                    listener.onTimeout();
+                }
+                break;
+            case CommonStatusCodes.API_NOT_CONNECTED:
+                emitError("API_NOT_CONNECTED");
+                break;
+            case CommonStatusCodes.NETWORK_ERROR:
+                emitError("NETWORK_ERROR");
+                break;
+            case CommonStatusCodes.ERROR:
+                emitError("SMS Retriever failed.");
+                break;
+            default:
+                emitError("SMS Retriever failed with status code " + status.getStatusCode() + ".");
+                break;
+        }
+    }
+
+    private void emitError(String message) {
+        if (listener != null) {
+            listener.onError(message);
+        }
+    }
+}