@capgo/capacitor-passkey 8.2.0

package/android/build.gradle

@@ -0,0 +1,61 @@
+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'
+}
+
+buildscript {
+    repositories {
+        google()
+        mavenCentral()
+    }
+    dependencies {
+        classpath 'com.android.tools.build:gradle:8.13.0'
+    }
+}
+
+apply plugin: 'com.android.library'
+
+android {
+    namespace = "app.capgo.passkey"
+    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-optimize.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')
+    annotationProcessor project(':capacitor-android')
+    implementation "androidx.appcompat:appcompat:$androidxAppCompatVersion"
+    implementation "androidx.credentials:credentials:1.5.0"
+    implementation "androidx.credentials:credentials-play-services-auth:1.5.0"
+    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,2 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+</manifest>

package/android/src/main/java/app/capgo/passkey/CapacitorPasskey.java

@@ -0,0 +1,21 @@
+package app.capgo.passkey;
+
+import androidx.credentials.webauthn.PublicKeyCredentialCreationOptions;
+import androidx.credentials.webauthn.PublicKeyCredentialRequestOptions;
+
+public class CapacitorPasskey {
+
+    public static final String PLUGIN_VERSION = "8.0.0";
+
+    public String getPluginVersion() {
+        return PLUGIN_VERSION;
+    }
+
+    public void validateCreationRequestJson(String requestJson) {
+        new PublicKeyCredentialCreationOptions(requestJson);
+    }
+
+    public void validateAssertionRequestJson(String requestJson) {
+        new PublicKeyCredentialRequestOptions(requestJson);
+    }
+}

package/android/src/main/java/app/capgo/passkey/CapacitorPasskeyPlugin.java

@@ -0,0 +1,299 @@
+package app.capgo.passkey;
+
+import android.app.Activity;
+import android.os.Build;
+import androidx.core.content.ContextCompat;
+import androidx.credentials.CreateCredentialResponse;
+import androidx.credentials.CreatePublicKeyCredentialRequest;
+import androidx.credentials.CreatePublicKeyCredentialResponse;
+import androidx.credentials.Credential;
+import androidx.credentials.CredentialManager;
+import androidx.credentials.CredentialManagerCallback;
+import androidx.credentials.GetCredentialRequest;
+import androidx.credentials.GetCredentialResponse;
+import androidx.credentials.GetPublicKeyCredentialOption;
+import androidx.credentials.PublicKeyCredential;
+import androidx.credentials.exceptions.CreateCredentialException;
+import androidx.credentials.exceptions.GetCredentialException;
+import androidx.credentials.exceptions.NoCredentialException;
+import androidx.credentials.exceptions.domerrors.DomError;
+import androidx.credentials.exceptions.publickeycredential.CreatePublicKeyCredentialDomException;
+import androidx.credentials.exceptions.publickeycredential.GetPublicKeyCredentialDomException;
+import com.getcapacitor.JSObject;
+import com.getcapacitor.Plugin;
+import com.getcapacitor.PluginCall;
+import com.getcapacitor.PluginConfig;
+import com.getcapacitor.PluginMethod;
+import com.getcapacitor.annotation.CapacitorPlugin;
+import java.net.URI;
+import java.net.URISyntaxException;
+import java.util.ArrayList;
+import java.util.LinkedHashSet;
+import java.util.List;
+import org.json.JSONException;
+import org.json.JSONObject;
+
+@CapacitorPlugin(name = "CapacitorPasskey")
+public class CapacitorPasskeyPlugin extends Plugin {
+
+    private final CapacitorPasskey implementation = new CapacitorPasskey();
+    private CredentialManager credentialManager;
+
+    @Override
+    public void load() {
+        super.load();
+        try {
+            credentialManager = CredentialManager.create(getContext());
+        } catch (Exception exception) {
+            credentialManager = null;
+        }
+    }
+
+    @PluginMethod
+    public void createCredential(final PluginCall call) {
+        if (!isCredentialManagerAvailable(call)) {
+            return;
+        }
+
+        final String requestJson = call.getString("requestJson");
+        if (requestJson == null || requestJson.isBlank()) {
+            rejectDom(call, "DataError", "requestJson is required.", null);
+            return;
+        }
+
+        try {
+            implementation.validateCreationRequestJson(requestJson);
+        } catch (Exception exception) {
+            rejectDom(call, "SyntaxError", "Invalid passkey registration request JSON.", exception);
+            return;
+        }
+
+        final CreatePublicKeyCredentialRequest request;
+        try {
+            request = new CreatePublicKeyCredentialRequest(requestJson);
+        } catch (Exception exception) {
+            rejectDom(call, "SyntaxError", "Could not create the native registration request.", exception);
+            return;
+        }
+
+        bridge.executeOnMainThread(() -> {
+            Activity activity = getActivity();
+            if (activity == null) {
+                rejectDom(call, "NotAllowedError", "Activity not available.", null);
+                return;
+            }
+
+            credentialManager.createCredentialAsync(
+                activity,
+                request,
+                null,
+                ContextCompat.getMainExecutor(getContext()),
+                new CredentialManagerCallback<CreateCredentialResponse, CreateCredentialException>() {
+                    @Override
+                    public void onResult(CreateCredentialResponse response) {
+                        if (!(response instanceof CreatePublicKeyCredentialResponse)) {
+                            rejectDom(call, "UnknownError", "Unexpected native registration response.", null);
+                            return;
+                        }
+
+                        resolveJson(call, ((CreatePublicKeyCredentialResponse) response).getRegistrationResponseJson());
+                    }
+
+                    @Override
+                    public void onError(CreateCredentialException exception) {
+                        rejectCreateException(call, exception);
+                    }
+                }
+            );
+        });
+    }
+
+    @PluginMethod
+    public void getCredential(final PluginCall call) {
+        if (!isCredentialManagerAvailable(call)) {
+            return;
+        }
+
+        final String requestJson = call.getString("requestJson");
+        if (requestJson == null || requestJson.isBlank()) {
+            rejectDom(call, "DataError", "requestJson is required.", null);
+            return;
+        }
+
+        try {
+            implementation.validateAssertionRequestJson(requestJson);
+        } catch (Exception exception) {
+            rejectDom(call, "SyntaxError", "Invalid passkey authentication request JSON.", exception);
+            return;
+        }
+
+        final GetCredentialRequest request;
+        try {
+            request = new GetCredentialRequest(List.of(new GetPublicKeyCredentialOption(requestJson)));
+        } catch (Exception exception) {
+            rejectDom(call, "SyntaxError", "Could not create the native authentication request.", exception);
+            return;
+        }
+
+        bridge.executeOnMainThread(() -> {
+            Activity activity = getActivity();
+            if (activity == null) {
+                rejectDom(call, "NotAllowedError", "Activity not available.", null);
+                return;
+            }
+
+            credentialManager.getCredentialAsync(
+                activity,
+                request,
+                null,
+                ContextCompat.getMainExecutor(getContext()),
+                new CredentialManagerCallback<GetCredentialResponse, GetCredentialException>() {
+                    @Override
+                    public void onResult(GetCredentialResponse response) {
+                        Credential credential = response.getCredential();
+                        if (!(credential instanceof PublicKeyCredential)) {
+                            rejectDom(call, "UnknownError", "Unexpected native authentication response.", null);
+                            return;
+                        }
+
+                        resolveJson(call, ((PublicKeyCredential) credential).getAuthenticationResponseJson());
+                    }
+
+                    @Override
+                    public void onError(GetCredentialException exception) {
+                        rejectGetException(call, exception);
+                    }
+                }
+            );
+        });
+    }
+
+    @PluginMethod
+    public void getConfiguration(final PluginCall call) {
+        PluginConfig config = getConfig();
+        JSObject result = new JSObject();
+        String origin = normalizeOrigin(config.getString("origin"));
+        result.put("autoShim", config.getBoolean("autoShim", true));
+        result.put("domains", normalizeDomains(config.getArray("domains"), origin));
+        result.put("origin", origin);
+        result.put("platform", "android");
+        call.resolve(result);
+    }
+
+    @PluginMethod
+    public void isSupported(final PluginCall call) {
+        JSObject result = new JSObject();
+        result.put("available", credentialManager != null && Build.VERSION.SDK_INT >= Build.VERSION_CODES.P);
+        result.put("conditionalMediation", false);
+        result.put("platform", "android");
+        call.resolve(result);
+    }
+
+    @PluginMethod
+    public void getPluginVersion(final PluginCall call) {
+        JSObject result = new JSObject();
+        result.put("version", implementation.getPluginVersion());
+        call.resolve(result);
+    }
+
+    private boolean isCredentialManagerAvailable(PluginCall call) {
+        if (credentialManager == null) {
+            rejectDom(call, "NotSupportedError", "Credential Manager is not available on this device.", null);
+            return false;
+        }
+
+        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.P) {
+            rejectDom(call, "NotSupportedError", "Passkeys require Android API level 28 or higher.", null);
+            return false;
+        }
+
+        return true;
+    }
+
+    private void resolveJson(PluginCall call, String json) {
+        try {
+            call.resolve(JSObject.fromJSONObject(new JSONObject(json)));
+        } catch (JSONException exception) {
+            rejectDom(call, "UnknownError", "Native passkey response was not valid JSON.", exception);
+        }
+    }
+
+    private void rejectCreateException(PluginCall call, CreateCredentialException exception) {
+        if (exception instanceof CreatePublicKeyCredentialDomException) {
+            DomError domError = ((CreatePublicKeyCredentialDomException) exception).getDomError();
+            rejectDom(call, domError.getClass().getSimpleName(), messageFor(exception, "Passkey registration failed."), exception);
+            return;
+        }
+
+        rejectDom(call, "UnknownError", messageFor(exception, "Passkey registration failed."), exception);
+    }
+
+    private void rejectGetException(PluginCall call, GetCredentialException exception) {
+        if (exception instanceof GetPublicKeyCredentialDomException) {
+            DomError domError = ((GetPublicKeyCredentialDomException) exception).getDomError();
+            rejectDom(call, domError.getClass().getSimpleName(), messageFor(exception, "Passkey authentication failed."), exception);
+            return;
+        }
+
+        if (exception instanceof NoCredentialException) {
+            rejectDom(call, "NotFoundError", "No matching passkey was found.", exception);
+            return;
+        }
+
+        rejectDom(call, "UnknownError", messageFor(exception, "Passkey authentication failed."), exception);
+    }
+
+    private String messageFor(CreateCredentialException exception, String fallback) {
+        CharSequence message = exception.getErrorMessage();
+        return message != null ? message.toString() : fallback;
+    }
+
+    private String messageFor(GetCredentialException exception, String fallback) {
+        CharSequence message = exception.getErrorMessage();
+        return message != null ? message.toString() : fallback;
+    }
+
+    private void rejectDom(PluginCall call, String name, String message, Exception exception) {
+        JSObject data = new JSObject();
+        data.put("name", name);
+        call.reject(message, name, exception, data);
+    }
+
+    private ArrayList<String> normalizeDomains(String[] configuredDomains, String origin) {
+        LinkedHashSet<String> domains = new LinkedHashSet<>();
+        if (configuredDomains != null) {
+            for (String value : configuredDomains) {
+                String normalized = normalizeDomain(value);
+                if (normalized != null) {
+                    domains.add(normalized);
+                }
+            }
+        }
+
+        String originDomain = normalizeDomain(origin);
+        if (originDomain != null) {
+            domains.add(originDomain);
+        }
+
+        return new ArrayList<>(domains);
+    }
+
+    private String normalizeOrigin(String value) {
+        return value == null || value.isBlank() ? null : value;
+    }
+
+    private String normalizeDomain(String value) {
+        if (value == null || value.isBlank()) {
+            return null;
+        }
+
+        try {
+            URI uri = new URI(value);
+            if (uri.getHost() != null && !uri.getHost().isBlank()) {
+                return uri.getHost();
+            }
+        } catch (URISyntaxException ignored) {}
+
+        return value;
+    }
+}