@capawesome/capacitor-passkeys 0.0.1

package/android/src/main/java/io/capawesome/capacitorjs/plugins/passkeys/Passkeys.java

@@ -0,0 +1,173 @@
+package io.capawesome.capacitorjs.plugins.passkeys;
+
+import android.os.Build;
+import androidx.annotation.NonNull;
+import androidx.credentials.CreateCredentialResponse;
+import androidx.credentials.CreatePublicKeyCredentialRequest;
+import androidx.credentials.CreatePublicKeyCredentialResponse;
+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.CreateCredentialCancellationException;
+import androidx.credentials.exceptions.CreateCredentialException;
+import androidx.credentials.exceptions.CreateCredentialProviderConfigurationException;
+import androidx.credentials.exceptions.CreateCredentialUnsupportedException;
+import androidx.credentials.exceptions.GetCredentialCancellationException;
+import androidx.credentials.exceptions.GetCredentialException;
+import androidx.credentials.exceptions.GetCredentialProviderConfigurationException;
+import androidx.credentials.exceptions.GetCredentialUnsupportedException;
+import androidx.credentials.exceptions.NoCredentialException;
+import androidx.credentials.exceptions.domerrors.SecurityError;
+import androidx.credentials.exceptions.publickeycredential.CreatePublicKeyCredentialDomException;
+import androidx.credentials.exceptions.publickeycredential.GetPublicKeyCredentialDomException;
+import io.capawesome.capacitorjs.plugins.passkeys.classes.CustomException;
+import io.capawesome.capacitorjs.plugins.passkeys.classes.CustomExceptions;
+import io.capawesome.capacitorjs.plugins.passkeys.classes.options.CreatePasskeyOptions;
+import io.capawesome.capacitorjs.plugins.passkeys.classes.options.GetPasskeyOptions;
+import io.capawesome.capacitorjs.plugins.passkeys.classes.results.CreatePasskeyResult;
+import io.capawesome.capacitorjs.plugins.passkeys.classes.results.GetPasskeyResult;
+import io.capawesome.capacitorjs.plugins.passkeys.classes.results.IsAvailableResult;
+import io.capawesome.capacitorjs.plugins.passkeys.interfaces.NonEmptyResultCallback;
+
+public class Passkeys {
+
+    @NonNull
+    private final PasskeysPlugin plugin;
+
+    public Passkeys(@NonNull PasskeysPlugin plugin) {
+        this.plugin = plugin;
+    }
+
+    public void createPasskey(@NonNull CreatePasskeyOptions options, @NonNull NonEmptyResultCallback<CreatePasskeyResult> callback) {
+        CreatePublicKeyCredentialRequest request = new CreatePublicKeyCredentialRequest(options.getRequestJson());
+        CredentialManager credentialManager = CredentialManager.create(plugin.getContext());
+        credentialManager.createCredentialAsync(
+            plugin.getActivity(),
+            request,
+            null,
+            Runnable::run,
+            new CredentialManagerCallback<CreateCredentialResponse, CreateCredentialException>() {
+                @Override
+                public void onResult(@NonNull CreateCredentialResponse response) {
+                    handleCreateCredentialResponse(response, callback);
+                }
+
+                @Override
+                public void onError(@NonNull CreateCredentialException exception) {
+                    callback.error(mapCreateCredentialException(exception));
+                }
+            }
+        );
+    }
+
+    public void getPasskey(@NonNull GetPasskeyOptions options, @NonNull NonEmptyResultCallback<GetPasskeyResult> callback) {
+        GetPublicKeyCredentialOption option = new GetPublicKeyCredentialOption(options.getRequestJson());
+        GetCredentialRequest request = new GetCredentialRequest.Builder().addCredentialOption(option).build();
+        CredentialManager credentialManager = CredentialManager.create(plugin.getContext());
+        credentialManager.getCredentialAsync(
+            plugin.getActivity(),
+            request,
+            null,
+            Runnable::run,
+            new CredentialManagerCallback<GetCredentialResponse, GetCredentialException>() {
+                @Override
+                public void onResult(@NonNull GetCredentialResponse response) {
+                    handleGetCredentialResponse(response, callback);
+                }
+
+                @Override
+                public void onError(@NonNull GetCredentialException exception) {
+                    callback.error(mapGetCredentialException(exception));
+                }
+            }
+        );
+    }
+
+    public void isAvailable(@NonNull NonEmptyResultCallback<IsAvailableResult> callback) {
+        boolean available = Build.VERSION.SDK_INT >= Build.VERSION_CODES.P;
+        IsAvailableResult result = new IsAvailableResult(available);
+        callback.success(result);
+    }
+
+    private void handleCreateCredentialResponse(
+        @NonNull CreateCredentialResponse response,
+        @NonNull NonEmptyResultCallback<CreatePasskeyResult> callback
+    ) {
+        if (response instanceof CreatePublicKeyCredentialResponse) {
+            try {
+                String registrationResponseJson = ((CreatePublicKeyCredentialResponse) response).getRegistrationResponseJson();
+                CreatePasskeyResult result = new CreatePasskeyResult(registrationResponseJson);
+                callback.success(result);
+            } catch (Exception exception) {
+                callback.error(exception);
+            }
+        } else {
+            callback.error(CustomExceptions.CREATE_FAILED);
+        }
+    }
+
+    private void handleGetCredentialResponse(
+        @NonNull GetCredentialResponse response,
+        @NonNull NonEmptyResultCallback<GetPasskeyResult> callback
+    ) {
+        if (response.getCredential() instanceof PublicKeyCredential) {
+            try {
+                String authenticationResponseJson = ((PublicKeyCredential) response.getCredential()).getAuthenticationResponseJson();
+                GetPasskeyResult result = new GetPasskeyResult(authenticationResponseJson);
+                callback.success(result);
+            } catch (Exception exception) {
+                callback.error(exception);
+            }
+        } else {
+            callback.error(CustomExceptions.GET_FAILED);
+        }
+    }
+
+    private static Exception mapCreateCredentialException(@NonNull CreateCredentialException exception) {
+        if (exception instanceof CreateCredentialCancellationException) {
+            return CustomExceptions.OPERATION_CANCELED;
+        }
+        String message = exception.getMessage();
+        if (message == null) {
+            message = CustomExceptions.CREATE_FAILED.getMessage();
+        }
+        if (
+            exception instanceof CreatePublicKeyCredentialDomException &&
+            ((CreatePublicKeyCredentialDomException) exception).getDomError() instanceof SecurityError
+        ) {
+            return new CustomException("DOMAIN_NOT_ASSOCIATED", message);
+        }
+        if (
+            exception instanceof CreateCredentialProviderConfigurationException || exception instanceof CreateCredentialUnsupportedException
+        ) {
+            return new CustomException("NOT_SUPPORTED", message);
+        }
+        return new CustomException("CREATE_FAILED", message);
+    }
+
+    private static Exception mapGetCredentialException(@NonNull GetCredentialException exception) {
+        if (exception instanceof GetCredentialCancellationException) {
+            return CustomExceptions.OPERATION_CANCELED;
+        }
+        String message = exception.getMessage();
+        if (message == null) {
+            message = CustomExceptions.GET_FAILED.getMessage();
+        }
+        if (exception instanceof NoCredentialException) {
+            return new CustomException("NO_CREDENTIAL", message);
+        }
+        if (
+            exception instanceof GetPublicKeyCredentialDomException &&
+            ((GetPublicKeyCredentialDomException) exception).getDomError() instanceof SecurityError
+        ) {
+            return new CustomException("DOMAIN_NOT_ASSOCIATED", message);
+        }
+        if (exception instanceof GetCredentialProviderConfigurationException || exception instanceof GetCredentialUnsupportedException) {
+            return new CustomException("NOT_SUPPORTED", message);
+        }
+        return new CustomException("GET_FAILED", message);
+    }
+}

package/android/src/main/java/io/capawesome/capacitorjs/plugins/passkeys/PasskeysPlugin.java

@@ -0,0 +1,115 @@
+package io.capawesome.capacitorjs.plugins.passkeys;
+
+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.passkeys.classes.CustomException;
+import io.capawesome.capacitorjs.plugins.passkeys.classes.options.CreatePasskeyOptions;
+import io.capawesome.capacitorjs.plugins.passkeys.classes.options.GetPasskeyOptions;
+import io.capawesome.capacitorjs.plugins.passkeys.classes.results.CreatePasskeyResult;
+import io.capawesome.capacitorjs.plugins.passkeys.classes.results.GetPasskeyResult;
+import io.capawesome.capacitorjs.plugins.passkeys.classes.results.IsAvailableResult;
+import io.capawesome.capacitorjs.plugins.passkeys.interfaces.NonEmptyResultCallback;
+import io.capawesome.capacitorjs.plugins.passkeys.interfaces.Result;
+
+@CapacitorPlugin(name = "Passkeys")
+public class PasskeysPlugin extends Plugin {
+
+    public static final String ERROR_UNKNOWN_ERROR = "An unknown error has occurred.";
+    public static final String TAG = "PasskeysPlugin";
+
+    private Passkeys implementation;
+
+    @Override
+    public void load() {
+        super.load();
+        this.implementation = new Passkeys(this);
+    }
+
+    @PluginMethod
+    public void createPasskey(PluginCall call) {
+        try {
+            CreatePasskeyOptions options = new CreatePasskeyOptions(call);
+            NonEmptyResultCallback<CreatePasskeyResult> callback = new NonEmptyResultCallback<>() {
+                @Override
+                public void success(@NonNull CreatePasskeyResult result) {
+                    resolveCall(call, result);
+                }
+
+                @Override
+                public void error(Exception exception) {
+                    rejectCall(call, exception);
+                }
+            };
+            implementation.createPasskey(options, callback);
+        } catch (Exception exception) {
+            rejectCall(call, exception);
+        }
+    }
+
+    @PluginMethod
+    public void getPasskey(PluginCall call) {
+        try {
+            GetPasskeyOptions options = new GetPasskeyOptions(call);
+            NonEmptyResultCallback<GetPasskeyResult> callback = new NonEmptyResultCallback<>() {
+                @Override
+                public void success(@NonNull GetPasskeyResult result) {
+                    resolveCall(call, result);
+                }
+
+                @Override
+                public void error(Exception exception) {
+                    rejectCall(call, exception);
+                }
+            };
+            implementation.getPasskey(options, callback);
+        } catch (Exception exception) {
+            rejectCall(call, exception);
+        }
+    }
+
+    @PluginMethod
+    public void isAvailable(PluginCall call) {
+        try {
+            NonEmptyResultCallback<IsAvailableResult> callback = new NonEmptyResultCallback<>() {
+                @Override
+                public void success(@NonNull IsAvailableResult result) {
+                    resolveCall(call, result);
+                }
+
+                @Override
+                public void error(Exception exception) {
+                    rejectCall(call, exception);
+                }
+            };
+            implementation.isAvailable(callback);
+        } catch (Exception exception) {
+            rejectCall(call, exception);
+        }
+    }
+
+    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 resolveCall(@NonNull PluginCall call, @Nullable Result result) {
+        if (result == null) {
+            call.resolve();
+        } else {
+            call.resolve(result.toJSObject());
+        }
+    }
+}

package/android/src/main/java/io/capawesome/capacitorjs/plugins/passkeys/classes/CustomException.java

@@ -0,0 +1,20 @@
+package io.capawesome.capacitorjs.plugins.passkeys.classes;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+
+public class CustomException extends Exception {
+
+    @Nullable
+    private final String code;
+
+    public CustomException(@Nullable String code, @NonNull String message) {
+        super(message);
+        this.code = code;
+    }
+
+    @Nullable
+    public String getCode() {
+        return code;
+    }
+}

package/android/src/main/java/io/capawesome/capacitorjs/plugins/passkeys/classes/CustomExceptions.java

@@ -0,0 +1,12 @@
+package io.capawesome.capacitorjs.plugins.passkeys.classes;
+
+public class CustomExceptions {
+
+    public static final CustomException CHALLENGE_MISSING = new CustomException(null, "challenge must be provided.");
+    public static final CustomException CREATE_FAILED = new CustomException("CREATE_FAILED", "The passkey could not be created.");
+    public static final CustomException GET_FAILED = new CustomException("GET_FAILED", "The passkey could not be retrieved.");
+    public static final CustomException OPERATION_CANCELED = new CustomException("CANCELED", "The operation was canceled by the user.");
+    public static final CustomException RP_ID_MISSING = new CustomException(null, "rp.id must be provided.");
+    public static final CustomException RP_ID_TOP_LEVEL_MISSING = new CustomException(null, "rpId must be provided.");
+    public static final CustomException USER_ID_MISSING = new CustomException(null, "user.id must be provided.");
+}

package/android/src/main/java/io/capawesome/capacitorjs/plugins/passkeys/classes/options/CreatePasskeyOptions.java

@@ -0,0 +1,38 @@
+package io.capawesome.capacitorjs.plugins.passkeys.classes.options;
+
+import androidx.annotation.NonNull;
+import com.getcapacitor.JSObject;
+import com.getcapacitor.PluginCall;
+import io.capawesome.capacitorjs.plugins.passkeys.classes.CustomExceptions;
+
+public class CreatePasskeyOptions {
+
+    @NonNull
+    private final String requestJson;
+
+    public CreatePasskeyOptions(@NonNull PluginCall call) throws Exception {
+        this.requestJson = CreatePasskeyOptions.getRequestJsonFromCall(call);
+    }
+
+    @NonNull
+    public String getRequestJson() {
+        return requestJson;
+    }
+
+    @NonNull
+    private static String getRequestJsonFromCall(@NonNull PluginCall call) throws Exception {
+        JSObject data = call.getData();
+        if (data.getString("challenge") == null) {
+            throw CustomExceptions.CHALLENGE_MISSING;
+        }
+        JSObject rp = data.getJSObject("rp");
+        if (rp == null || rp.getString("id") == null) {
+            throw CustomExceptions.RP_ID_MISSING;
+        }
+        JSObject user = data.getJSObject("user");
+        if (user == null || user.getString("id") == null) {
+            throw CustomExceptions.USER_ID_MISSING;
+        }
+        return data.toString();
+    }
+}

package/android/src/main/java/io/capawesome/capacitorjs/plugins/passkeys/classes/options/GetPasskeyOptions.java

@@ -0,0 +1,33 @@
+package io.capawesome.capacitorjs.plugins.passkeys.classes.options;
+
+import androidx.annotation.NonNull;
+import com.getcapacitor.JSObject;
+import com.getcapacitor.PluginCall;
+import io.capawesome.capacitorjs.plugins.passkeys.classes.CustomExceptions;
+
+public class GetPasskeyOptions {
+
+    @NonNull
+    private final String requestJson;
+
+    public GetPasskeyOptions(@NonNull PluginCall call) throws Exception {
+        this.requestJson = GetPasskeyOptions.getRequestJsonFromCall(call);
+    }
+
+    @NonNull
+    public String getRequestJson() {
+        return requestJson;
+    }
+
+    @NonNull
+    private static String getRequestJsonFromCall(@NonNull PluginCall call) throws Exception {
+        JSObject data = call.getData();
+        if (data.getString("challenge") == null) {
+            throw CustomExceptions.CHALLENGE_MISSING;
+        }
+        if (data.getString("rpId") == null) {
+            throw CustomExceptions.RP_ID_TOP_LEVEL_MISSING;
+        }
+        return data.toString();
+    }
+}

package/android/src/main/java/io/capawesome/capacitorjs/plugins/passkeys/classes/results/CreatePasskeyResult.java

@@ -0,0 +1,22 @@
+package io.capawesome.capacitorjs.plugins.passkeys.classes.results;
+
+import androidx.annotation.NonNull;
+import com.getcapacitor.JSObject;
+import io.capawesome.capacitorjs.plugins.passkeys.interfaces.Result;
+import org.json.JSONException;
+
+public class CreatePasskeyResult implements Result {
+
+    @NonNull
+    private final JSObject registrationResponse;
+
+    public CreatePasskeyResult(@NonNull String registrationResponseJson) throws JSONException {
+        this.registrationResponse = new JSObject(registrationResponseJson);
+    }
+
+    @Override
+    @NonNull
+    public JSObject toJSObject() {
+        return registrationResponse;
+    }
+}

package/android/src/main/java/io/capawesome/capacitorjs/plugins/passkeys/classes/results/GetPasskeyResult.java

@@ -0,0 +1,22 @@
+package io.capawesome.capacitorjs.plugins.passkeys.classes.results;
+
+import androidx.annotation.NonNull;
+import com.getcapacitor.JSObject;
+import io.capawesome.capacitorjs.plugins.passkeys.interfaces.Result;
+import org.json.JSONException;
+
+public class GetPasskeyResult implements Result {
+
+    @NonNull
+    private final JSObject authenticationResponse;
+
+    public GetPasskeyResult(@NonNull String authenticationResponseJson) throws JSONException {
+        this.authenticationResponse = new JSObject(authenticationResponseJson);
+    }
+
+    @Override
+    @NonNull
+    public JSObject toJSObject() {
+        return authenticationResponse;
+    }
+}

package/android/src/main/java/io/capawesome/capacitorjs/plugins/passkeys/classes/results/IsAvailableResult.java

@@ -0,0 +1,22 @@
+package io.capawesome.capacitorjs.plugins.passkeys.classes.results;
+
+import androidx.annotation.NonNull;
+import com.getcapacitor.JSObject;
+import io.capawesome.capacitorjs.plugins.passkeys.interfaces.Result;
+
+public class IsAvailableResult implements Result {
+
+    private final boolean available;
+
+    public IsAvailableResult(boolean available) {
+        this.available = available;
+    }
+
+    @Override
+    @NonNull
+    public JSObject toJSObject() {
+        JSObject result = new JSObject();
+        result.put("available", available);
+        return result;
+    }
+}

package/android/src/main/java/io/capawesome/capacitorjs/plugins/passkeys/interfaces/Callback.java

@@ -0,0 +1,5 @@
+package io.capawesome.capacitorjs.plugins.passkeys.interfaces;
+
+public interface Callback {
+    void error(Exception exception);
+}

package/android/src/main/java/io/capawesome/capacitorjs/plugins/passkeys/interfaces/NonEmptyResultCallback.java

@@ -0,0 +1,7 @@
+package io.capawesome.capacitorjs.plugins.passkeys.interfaces;
+
+import androidx.annotation.NonNull;
+
+public interface NonEmptyResultCallback<T extends Result> extends Callback {
+    void success(@NonNull T result);
+}

package/android/src/main/java/io/capawesome/capacitorjs/plugins/passkeys/interfaces/Result.java

@@ -0,0 +1,7 @@
+package io.capawesome.capacitorjs.plugins.passkeys.interfaces;
+
+import com.getcapacitor.JSObject;
+
+public interface Result {
+    JSObject toJSObject();
+}