@capawesome/capacitor-google-sign-in 0.0.1

package/android/src/main/java/io/capawesome/capacitorjs/plugins/googlesignin/GoogleSignIn.java

@@ -0,0 +1,300 @@
+package io.capawesome.capacitorjs.plugins.googlesignin;
+
+import android.app.PendingIntent;
+import android.util.Base64;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.credentials.ClearCredentialStateRequest;
+import androidx.credentials.Credential;
+import androidx.credentials.CredentialManager;
+import androidx.credentials.CustomCredential;
+import androidx.credentials.GetCredentialRequest;
+import androidx.credentials.GetCredentialResponse;
+import com.google.android.gms.auth.api.identity.AuthorizationRequest;
+import com.google.android.gms.auth.api.identity.AuthorizationResult;
+import com.google.android.gms.auth.api.identity.Identity;
+import com.google.android.libraries.identity.googleid.GetSignInWithGoogleOption;
+import com.google.android.libraries.identity.googleid.GoogleIdTokenCredential;
+import io.capawesome.capacitorjs.plugins.googlesignin.classes.CustomExceptions;
+import io.capawesome.capacitorjs.plugins.googlesignin.classes.options.InitializeOptions;
+import io.capawesome.capacitorjs.plugins.googlesignin.classes.options.SignInOptions;
+import io.capawesome.capacitorjs.plugins.googlesignin.classes.results.SignInResult;
+import io.capawesome.capacitorjs.plugins.googlesignin.interfaces.EmptyCallback;
+import io.capawesome.capacitorjs.plugins.googlesignin.interfaces.NonEmptyResultCallback;
+import java.util.Arrays;
+import java.util.List;
+import org.json.JSONObject;
+
+public class GoogleSignIn {
+
+    private final GoogleSignInPlugin plugin;
+
+    @Nullable
+    private String clientId;
+
+    @Nullable
+    private String[] scopes;
+
+    @Nullable
+    private NonEmptyResultCallback<SignInResult> pendingSignInCallback;
+
+    @Nullable
+    private String pendingIdToken;
+
+    @Nullable
+    private String pendingUserId;
+
+    @Nullable
+    private String pendingEmail;
+
+    @Nullable
+    private String pendingDisplayName;
+
+    @Nullable
+    private String pendingGivenName;
+
+    @Nullable
+    private String pendingFamilyName;
+
+    @Nullable
+    private String pendingImageUrl;
+
+    public GoogleSignIn(@NonNull GoogleSignInPlugin plugin) {
+        this.plugin = plugin;
+    }
+
+    public void initialize(@NonNull InitializeOptions options, @NonNull EmptyCallback callback) {
+        this.clientId = options.getClientId();
+        this.scopes = options.getScopes();
+        callback.success();
+    }
+
+    public void signIn(@NonNull SignInOptions options, @NonNull NonEmptyResultCallback<SignInResult> callback) {
+        if (clientId == null) {
+            callback.error(CustomExceptions.NOT_INITIALIZED);
+            return;
+        }
+
+        GetSignInWithGoogleOption.Builder optionBuilder = new GetSignInWithGoogleOption.Builder(clientId);
+        String nonce = options.getNonce();
+        if (nonce != null) {
+            optionBuilder.setNonce(nonce);
+        }
+        GetSignInWithGoogleOption signInOption = optionBuilder.build();
+
+        GetCredentialRequest request = new GetCredentialRequest.Builder().addCredentialOption(signInOption).build();
+
+        CredentialManager credentialManager = CredentialManager.create(plugin.getContext());
+        credentialManager.getCredentialAsync(
+            plugin.getActivity(),
+            request,
+            null,
+            Runnable::run,
+            new androidx.credentials.CredentialManagerCallback<
+                GetCredentialResponse,
+                androidx.credentials.exceptions.GetCredentialException
+            >() {
+                @Override
+                public void onResult(@NonNull GetCredentialResponse response) {
+                    handleCredentialResponse(response, callback);
+                }
+
+                @Override
+                public void onError(@NonNull androidx.credentials.exceptions.GetCredentialException e) {
+                    if (e instanceof androidx.credentials.exceptions.GetCredentialCancellationException) {
+                        callback.error(CustomExceptions.SIGN_IN_CANCELED);
+                    } else {
+                        callback.error(new Exception(e.getMessage()));
+                    }
+                }
+            }
+        );
+    }
+
+    public void signOut(@NonNull EmptyCallback callback) {
+        CredentialManager credentialManager = CredentialManager.create(plugin.getContext());
+        ClearCredentialStateRequest request = new ClearCredentialStateRequest();
+        credentialManager.clearCredentialStateAsync(
+            request,
+            null,
+            Runnable::run,
+            new androidx.credentials.CredentialManagerCallback<Void, androidx.credentials.exceptions.ClearCredentialException>() {
+                @Override
+                public void onResult(@NonNull Void result) {
+                    callback.success();
+                }
+
+                @Override
+                public void onError(@NonNull androidx.credentials.exceptions.ClearCredentialException e) {
+                    callback.error(new Exception(e.getMessage()));
+                }
+            }
+        );
+    }
+
+    public void handleAuthorizationResult(@NonNull AuthorizationResult authResult) {
+        if (pendingSignInCallback == null) {
+            return;
+        }
+        NonEmptyResultCallback<SignInResult> callback = pendingSignInCallback;
+        String accessToken = authResult.getAccessToken();
+        String serverAuthCode = authResult.getServerAuthCode();
+        SignInResult result = new SignInResult(
+            pendingIdToken,
+            pendingUserId,
+            pendingEmail,
+            pendingDisplayName,
+            pendingGivenName,
+            pendingFamilyName,
+            pendingImageUrl,
+            accessToken,
+            serverAuthCode
+        );
+        clearPendingState();
+        callback.success(result);
+    }
+
+    public void handleAuthorizationCanceled() {
+        if (pendingSignInCallback == null) {
+            return;
+        }
+        NonEmptyResultCallback<SignInResult> callback = pendingSignInCallback;
+        clearPendingState();
+        callback.error(CustomExceptions.SIGN_IN_CANCELED);
+    }
+
+    private void handleCredentialResponse(@NonNull GetCredentialResponse response, @NonNull NonEmptyResultCallback<SignInResult> callback) {
+        Credential credential = response.getCredential();
+        if (!(credential instanceof CustomCredential)) {
+            callback.error(new Exception("Unexpected credential type."));
+            return;
+        }
+        CustomCredential customCredential = (CustomCredential) credential;
+        if (!GoogleIdTokenCredential.TYPE_GOOGLE_ID_TOKEN_CREDENTIAL.equals(customCredential.getType())) {
+            callback.error(new Exception("Unexpected credential type."));
+            return;
+        }
+
+        GoogleIdTokenCredential googleCredential = GoogleIdTokenCredential.createFrom(customCredential.getData());
+        String idToken = googleCredential.getIdToken();
+        String userId = parseUserIdFromIdToken(idToken);
+        if (userId == null) {
+            callback.error(new Exception("Failed to parse user ID from ID token."));
+            return;
+        }
+
+        String email = googleCredential.getId();
+        String displayName = googleCredential.getDisplayName();
+        String givenName = googleCredential.getGivenName();
+        String familyName = googleCredential.getFamilyName();
+        android.net.Uri profilePictureUri = googleCredential.getProfilePictureUri();
+        String imageUrl = profilePictureUri != null ? profilePictureUri.toString() : null;
+
+        if (scopes != null && scopes.length > 0) {
+            authorize(idToken, userId, email, displayName, givenName, familyName, imageUrl, callback);
+        } else {
+            SignInResult result = new SignInResult(idToken, userId, email, displayName, givenName, familyName, imageUrl, null, null);
+            callback.success(result);
+        }
+    }
+
+    private void authorize(
+        @NonNull String idToken,
+        @NonNull String userId,
+        @Nullable String email,
+        @Nullable String displayName,
+        @Nullable String givenName,
+        @Nullable String familyName,
+        @Nullable String imageUrl,
+        @NonNull NonEmptyResultCallback<SignInResult> callback
+    ) {
+        List<com.google.android.gms.common.api.Scope> scopeList = new java.util.ArrayList<>();
+        for (String scope : scopes) {
+            scopeList.add(new com.google.android.gms.common.api.Scope(scope));
+        }
+
+        AuthorizationRequest authRequest = AuthorizationRequest.builder()
+            .setRequestedScopes(scopeList)
+            .requestOfflineAccess(clientId)
+            .build();
+
+        Identity.getAuthorizationClient(plugin.getActivity())
+            .authorize(authRequest)
+            .addOnSuccessListener(authResult -> {
+                if (authResult.hasResolution()) {
+                    PendingIntent pendingIntent = authResult.getPendingIntent();
+                    if (pendingIntent != null) {
+                        savePendingState(idToken, userId, email, displayName, givenName, familyName, imageUrl, callback);
+                        plugin.launchAuthorizationIntent(pendingIntent);
+                    } else {
+                        callback.error(new Exception("Authorization resolution has no pending intent."));
+                    }
+                } else {
+                    String accessToken = authResult.getAccessToken();
+                    String serverAuthCode = authResult.getServerAuthCode();
+                    SignInResult result = new SignInResult(
+                        idToken,
+                        userId,
+                        email,
+                        displayName,
+                        givenName,
+                        familyName,
+                        imageUrl,
+                        accessToken,
+                        serverAuthCode
+                    );
+                    callback.success(result);
+                }
+            })
+            .addOnFailureListener(e -> {
+                callback.error(new Exception(e.getMessage()));
+            });
+    }
+
+    @Nullable
+    private String parseUserIdFromIdToken(@NonNull String idToken) {
+        try {
+            String[] parts = idToken.split("\\.");
+            if (parts.length != 3) {
+                return null;
+            }
+            byte[] decodedBytes = Base64.decode(parts[1], Base64.URL_SAFE | Base64.NO_PADDING | Base64.NO_WRAP);
+            String payload = new String(decodedBytes, "UTF-8");
+            JSONObject json = new JSONObject(payload);
+            return json.optString("sub", null);
+        } catch (Exception e) {
+            return null;
+        }
+    }
+
+    private void savePendingState(
+        @NonNull String idToken,
+        @NonNull String userId,
+        @Nullable String email,
+        @Nullable String displayName,
+        @Nullable String givenName,
+        @Nullable String familyName,
+        @Nullable String imageUrl,
+        @NonNull NonEmptyResultCallback<SignInResult> callback
+    ) {
+        this.pendingSignInCallback = callback;
+        this.pendingIdToken = idToken;
+        this.pendingUserId = userId;
+        this.pendingEmail = email;
+        this.pendingDisplayName = displayName;
+        this.pendingGivenName = givenName;
+        this.pendingFamilyName = familyName;
+        this.pendingImageUrl = imageUrl;
+    }
+
+    private void clearPendingState() {
+        this.pendingSignInCallback = null;
+        this.pendingIdToken = null;
+        this.pendingUserId = null;
+        this.pendingEmail = null;
+        this.pendingDisplayName = null;
+        this.pendingGivenName = null;
+        this.pendingFamilyName = null;
+        this.pendingImageUrl = null;
+    }
+}

package/android/src/main/java/io/capawesome/capacitorjs/plugins/googlesignin/GoogleSignInPlugin.java

@@ -0,0 +1,159 @@
+package io.capawesome.capacitorjs.plugins.googlesignin;
+
+import android.app.Activity;
+import android.app.PendingIntent;
+import android.content.IntentSender;
+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 com.google.android.gms.auth.api.identity.AuthorizationResult;
+import com.google.android.gms.auth.api.identity.Identity;
+import io.capawesome.capacitorjs.plugins.googlesignin.classes.CustomException;
+import io.capawesome.capacitorjs.plugins.googlesignin.classes.options.InitializeOptions;
+import io.capawesome.capacitorjs.plugins.googlesignin.classes.options.SignInOptions;
+import io.capawesome.capacitorjs.plugins.googlesignin.classes.results.SignInResult;
+import io.capawesome.capacitorjs.plugins.googlesignin.interfaces.EmptyCallback;
+import io.capawesome.capacitorjs.plugins.googlesignin.interfaces.NonEmptyResultCallback;
+import io.capawesome.capacitorjs.plugins.googlesignin.interfaces.Result;
+
+@CapacitorPlugin(name = "GoogleSignIn")
+public class GoogleSignInPlugin extends Plugin {
+
+    public static final String ERROR_UNKNOWN_ERROR = "An unknown error has occurred.";
+    public static final String TAG = "GoogleSignInPlugin";
+
+    private GoogleSignIn implementation;
+    private ActivityResultLauncher<IntentSenderRequest> authorizationLauncher;
+
+    @Override
+    public void load() {
+        super.load();
+        this.implementation = new GoogleSignIn(this);
+        this.authorizationLauncher = getActivity()
+            .registerForActivityResult(new ActivityResultContracts.StartIntentSenderForResult(), this::handleAuthorizationActivityResult);
+    }
+
+    @PluginMethod
+    public void initialize(PluginCall call) {
+        try {
+            InitializeOptions options = new InitializeOptions(call);
+            EmptyCallback callback = new EmptyCallback() {
+                @Override
+                public void success() {
+                    resolveCall(call);
+                }
+
+                @Override
+                public void error(Exception exception) {
+                    rejectCall(call, exception);
+                }
+            };
+            implementation.initialize(options, callback);
+        } catch (Exception exception) {
+            rejectCall(call, exception);
+        }
+    }
+
+    @PluginMethod
+    public void signIn(PluginCall call) {
+        try {
+            SignInOptions options = new SignInOptions(call);
+            NonEmptyResultCallback<SignInResult> callback = new NonEmptyResultCallback<>() {
+                @Override
+                public void success(@NonNull SignInResult result) {
+                    resolveCall(call, result);
+                }
+
+                @Override
+                public void error(Exception exception) {
+                    rejectCall(call, exception);
+                }
+            };
+            implementation.signIn(options, callback);
+        } catch (Exception exception) {
+            rejectCall(call, exception);
+        }
+    }
+
+    @PluginMethod
+    public void handleRedirectCallback(PluginCall call) {
+        rejectCallAsUnimplemented(call);
+    }
+
+    @PluginMethod
+    public void signOut(PluginCall call) {
+        try {
+            EmptyCallback callback = new EmptyCallback() {
+                @Override
+                public void success() {
+                    resolveCall(call);
+                }
+
+                @Override
+                public void error(Exception exception) {
+                    rejectCall(call, exception);
+                }
+            };
+            implementation.signOut(callback);
+        } catch (Exception exception) {
+            rejectCall(call, exception);
+        }
+    }
+
+    public void launchAuthorizationIntent(@NonNull PendingIntent pendingIntent) {
+        IntentSenderRequest request = new IntentSenderRequest.Builder(pendingIntent).build();
+        authorizationLauncher.launch(request);
+    }
+
+    private void handleAuthorizationActivityResult(@NonNull ActivityResult result) {
+        if (result.getResultCode() == Activity.RESULT_OK && result.getData() != null) {
+            try {
+                AuthorizationResult authResult = Identity.getAuthorizationClient(getActivity()).getAuthorizationResultFromIntent(
+                    result.getData()
+                );
+                implementation.handleAuthorizationResult(authResult);
+            } catch (Exception e) {
+                implementation.handleAuthorizationCanceled();
+            }
+        } else {
+            implementation.handleAuthorizationCanceled();
+        }
+    }
+
+    private void rejectCallAsUnimplemented(@NonNull PluginCall call) {
+        call.unimplemented("This method is not available on this platform.");
+    }
+
+    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) {
+        call.resolve();
+    }
+
+    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/googlesignin/classes/CustomException.java

@@ -0,0 +1,20 @@
+package io.capawesome.capacitorjs.plugins.googlesignin.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/googlesignin/classes/CustomExceptions.java

@@ -0,0 +1,11 @@
+package io.capawesome.capacitorjs.plugins.googlesignin.classes;
+
+public class CustomExceptions {
+
+    public static final CustomException CLIENT_ID_MISSING = new CustomException(null, "clientId must be provided.");
+    public static final CustomException NOT_INITIALIZED = new CustomException(
+        null,
+        "Google Sign-In is not initialized. Call initialize() first."
+    );
+    public static final CustomException SIGN_IN_CANCELED = new CustomException("SIGN_IN_CANCELED", "The user canceled the sign-in flow.");
+}

package/android/src/main/java/io/capawesome/capacitorjs/plugins/googlesignin/classes/options/InitializeOptions.java

@@ -0,0 +1,56 @@
+package io.capawesome.capacitorjs.plugins.googlesignin.classes.options;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import com.getcapacitor.JSArray;
+import com.getcapacitor.PluginCall;
+import io.capawesome.capacitorjs.plugins.googlesignin.classes.CustomExceptions;
+import java.util.ArrayList;
+import java.util.List;
+
+public class InitializeOptions {
+
+    @NonNull
+    private final String clientId;
+
+    @Nullable
+    private final String[] scopes;
+
+    public InitializeOptions(@NonNull PluginCall call) throws Exception {
+        this.clientId = getClientIdFromCall(call);
+        this.scopes = getScopesFromCall(call);
+    }
+
+    @NonNull
+    public String getClientId() {
+        return clientId;
+    }
+
+    @Nullable
+    public String[] getScopes() {
+        return scopes;
+    }
+
+    @NonNull
+    private static String getClientIdFromCall(@NonNull PluginCall call) throws Exception {
+        String clientId = call.getString("clientId");
+        if (clientId == null) {
+            throw CustomExceptions.CLIENT_ID_MISSING;
+        }
+        return clientId;
+    }
+
+    @Nullable
+    private static String[] getScopesFromCall(@NonNull PluginCall call) {
+        JSArray scopesArray = call.getArray("scopes");
+        if (scopesArray == null) {
+            return null;
+        }
+        try {
+            List<String> scopesList = scopesArray.toList();
+            return scopesList.toArray(new String[0]);
+        } catch (Exception e) {
+            return null;
+        }
+    }
+}

package/android/src/main/java/io/capawesome/capacitorjs/plugins/googlesignin/classes/options/SignInOptions.java

@@ -0,0 +1,25 @@
+package io.capawesome.capacitorjs.plugins.googlesignin.classes.options;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import com.getcapacitor.PluginCall;
+
+public class SignInOptions {
+
+    @Nullable
+    private final String nonce;
+
+    public SignInOptions(@NonNull PluginCall call) {
+        this.nonce = getNonceFromCall(call);
+    }
+
+    @Nullable
+    public String getNonce() {
+        return nonce;
+    }
+
+    @Nullable
+    private static String getNonceFromCall(@NonNull PluginCall call) {
+        return call.getString("nonce");
+    }
+}

package/android/src/main/java/io/capawesome/capacitorjs/plugins/googlesignin/classes/results/SignInResult.java

@@ -0,0 +1,75 @@
+package io.capawesome.capacitorjs.plugins.googlesignin.classes.results;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import com.getcapacitor.JSObject;
+import io.capawesome.capacitorjs.plugins.googlesignin.interfaces.Result;
+import org.json.JSONObject;
+
+public class SignInResult implements Result {
+
+    @NonNull
+    private final String idToken;
+
+    @NonNull
+    private final String userId;
+
+    @Nullable
+    private final String email;
+
+    @Nullable
+    private final String displayName;
+
+    @Nullable
+    private final String givenName;
+
+    @Nullable
+    private final String familyName;
+
+    @Nullable
+    private final String imageUrl;
+
+    @Nullable
+    private final String accessToken;
+
+    @Nullable
+    private final String serverAuthCode;
+
+    public SignInResult(
+        @NonNull String idToken,
+        @NonNull String userId,
+        @Nullable String email,
+        @Nullable String displayName,
+        @Nullable String givenName,
+        @Nullable String familyName,
+        @Nullable String imageUrl,
+        @Nullable String accessToken,
+        @Nullable String serverAuthCode
+    ) {
+        this.idToken = idToken;
+        this.userId = userId;
+        this.email = email;
+        this.displayName = displayName;
+        this.givenName = givenName;
+        this.familyName = familyName;
+        this.imageUrl = imageUrl;
+        this.accessToken = accessToken;
+        this.serverAuthCode = serverAuthCode;
+    }
+
+    @Override
+    @NonNull
+    public JSObject toJSObject() {
+        JSObject result = new JSObject();
+        result.put("idToken", idToken);
+        result.put("userId", userId);
+        result.put("email", email == null ? JSONObject.NULL : email);
+        result.put("displayName", displayName == null ? JSONObject.NULL : displayName);
+        result.put("givenName", givenName == null ? JSONObject.NULL : givenName);
+        result.put("familyName", familyName == null ? JSONObject.NULL : familyName);
+        result.put("imageUrl", imageUrl == null ? JSONObject.NULL : imageUrl);
+        result.put("accessToken", accessToken == null ? JSONObject.NULL : accessToken);
+        result.put("serverAuthCode", serverAuthCode == null ? JSONObject.NULL : serverAuthCode);
+        return result;
+    }
+}

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

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

package/android/src/main/java/io/capawesome/capacitorjs/plugins/googlesignin/interfaces/EmptyCallback.java

@@ -0,0 +1,5 @@
+package io.capawesome.capacitorjs.plugins.googlesignin.interfaces;
+
+public interface EmptyCallback extends Callback {
+    void success();
+}

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

@@ -0,0 +1,7 @@
+package io.capawesome.capacitorjs.plugins.googlesignin.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/googlesignin/interfaces/Result.java

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