react-native-nitro-auth 0.1.0

package/android/src/main/cpp/PlatformAuth+Android.cpp

@@ -0,0 +1,293 @@
+#include "PlatformAuth.hpp"
+#include "AuthUser.hpp"
+#include "AuthTokens.hpp"
+#include "AuthCache.hpp"
+#include <fbjni/fbjni.h>
+#include <NitroModules/NitroLogger.hpp>
+#include <NitroModules/Promise.hpp>
+
+namespace margelo::nitro::NitroAuth {
+
+using namespace facebook::jni;
+
+struct JContext : JavaClass<JContext> {
+    static constexpr auto kJavaDescriptor = "Landroid/content/Context;";
+};
+
+struct JAuthAdapter : JavaClass<JAuthAdapter> {
+    static constexpr auto kJavaDescriptor = "Lcom/auth/AuthAdapter;";
+};
+
+static std::shared_ptr<Promise<AuthUser>> gLoginPromise;
+static std::shared_ptr<Promise<AuthUser>> gScopesPromise;
+static std::shared_ptr<Promise<AuthTokens>> gRefreshPromise;
+static std::shared_ptr<Promise<std::optional<AuthUser>>> gSilentPromise;
+static std::mutex gMutex;
+
+std::shared_ptr<Promise<AuthUser>> PlatformAuth::login(AuthProvider provider, const std::vector<std::string>& scopes, const std::optional<std::string>& loginHint) {
+    auto promise = Promise<AuthUser>::create();
+    auto contextPtr = static_cast<jobject>(AuthCache::getAndroidContext());
+    if (!contextPtr) {
+        promise->reject(std::make_exception_ptr(std::runtime_error("Android Context not initialized")));
+        return promise;
+    }
+    
+    {
+        std::lock_guard<std::mutex> lock(gMutex);
+        gLoginPromise = promise;
+    }
+    
+    std::string providerStr = (provider == AuthProvider::GOOGLE) ? "google" : "apple";
+    JNIEnv* env = Environment::current();
+    jclass stringClass = env->FindClass("java/lang/String");
+    jobjectArray jScopes = env->NewObjectArray(scopes.size(), stringClass, nullptr);
+    for (size_t i = 0; i < scopes.size(); i++) {
+        env->SetObjectArrayElement(jScopes, i, make_jstring(scopes[i]).get());
+    }
+    
+    jstring jLoginHint = loginHint.has_value() ? make_jstring(loginHint.value()).get() : nullptr;
+    jclass adapterClass = env->FindClass("com/auth/AuthAdapter");
+    jmethodID loginMethod = env->GetStaticMethodID(adapterClass, "loginSync", 
+        "(Landroid/content/Context;Ljava/lang/String;Ljava/lang/String;[Ljava/lang/String;Ljava/lang/String;)V");
+    env->CallStaticVoidMethod(adapterClass, loginMethod, 
+        contextPtr, 
+        make_jstring(providerStr).get(),
+        nullptr,
+        jScopes,
+        jLoginHint);
+    
+    return promise;
+}
+
+std::shared_ptr<Promise<AuthUser>> PlatformAuth::requestScopes(const std::vector<std::string>& scopes) {
+    auto promise = Promise<AuthUser>::create();
+    auto contextPtr = static_cast<jobject>(AuthCache::getAndroidContext());
+    if (!contextPtr) {
+        promise->reject(std::make_exception_ptr(std::runtime_error("Android Context not initialized")));
+        return promise;
+    }
+    
+    {
+        std::lock_guard<std::mutex> lock(gMutex);
+        gScopesPromise = promise;
+    }
+    
+    JNIEnv* env = Environment::current();
+    jclass stringClass = env->FindClass("java/lang/String");
+    jobjectArray jScopes = env->NewObjectArray(scopes.size(), stringClass, nullptr);
+    for (size_t i = 0; i < scopes.size(); i++) {
+        env->SetObjectArrayElement(jScopes, i, make_jstring(scopes[i]).get());
+    }
+    
+    jclass adapterClass = env->FindClass("com/auth/AuthAdapter");
+    jmethodID requestMethod = env->GetStaticMethodID(adapterClass, "requestScopesSync", 
+        "(Landroid/content/Context;[Ljava/lang/String;)V");
+    env->CallStaticVoidMethod(adapterClass, requestMethod, contextPtr, jScopes);
+    return promise;
+}
+
+std::shared_ptr<Promise<AuthTokens>> PlatformAuth::refreshToken() {
+    auto promise = Promise<AuthTokens>::create();
+    auto contextPtr = static_cast<jobject>(AuthCache::getAndroidContext());
+    if (!contextPtr) {
+        promise->reject(std::make_exception_ptr(std::runtime_error("Android Context not initialized")));
+        return promise;
+    }
+    
+    {
+        std::lock_guard<std::mutex> lock(gMutex);
+        gRefreshPromise = promise;
+    }
+    
+    auto jContext = wrap_alias(contextPtr);
+    static auto refreshMethod = JAuthAdapter::javaClassStatic()->getStaticMethod<void(alias_ref<JContext>)>("refreshTokenSync");
+    refreshMethod(JAuthAdapter::javaClassStatic(), static_ref_cast<JContext>(jContext));
+    return promise;
+}
+
+std::shared_ptr<Promise<std::optional<AuthUser>>> PlatformAuth::silentRestore() {
+    auto promise = Promise<std::optional<AuthUser>>::create();
+    auto contextPtr = static_cast<jobject>(AuthCache::getAndroidContext());
+    if (!contextPtr) {
+        promise->resolve(std::nullopt);
+        return promise;
+    }
+
+    {
+        std::lock_guard<std::mutex> lock(gMutex);
+        gSilentPromise = promise;
+    }
+
+    auto jContext = wrap_alias(contextPtr);
+    static auto restoreMethod = JAuthAdapter::javaClassStatic()->getStaticMethod<void(alias_ref<JContext>)>("restoreSession");
+    restoreMethod(JAuthAdapter::javaClassStatic(), static_ref_cast<JContext>(jContext));
+    return promise;
+}
+
+bool PlatformAuth::hasPlayServices() {
+    auto contextPtr = static_cast<jobject>(AuthCache::getAndroidContext());
+    if (!contextPtr) return false;
+    
+    auto jContext = wrap_alias(contextPtr);
+    static auto hasPlayMethod = JAuthAdapter::javaClassStatic()->getStaticMethod<jboolean(alias_ref<JContext>)>("hasPlayServices");
+    return hasPlayMethod(JAuthAdapter::javaClassStatic(), static_ref_cast<JContext>(jContext));
+}
+
+void PlatformAuth::logout() {
+    auto contextPtr = static_cast<jobject>(AuthCache::getAndroidContext());
+    if (!contextPtr) return;
+
+    auto jContext = wrap_alias(contextPtr);
+    static auto logoutMethod = JAuthAdapter::javaClassStatic()->getStaticMethod<void(alias_ref<JContext>)>("logoutSync");
+    logoutMethod(JAuthAdapter::javaClassStatic(), static_ref_cast<JContext>(jContext));
+}
+
+extern "C" JNIEXPORT void JNICALL Java_com_auth_AuthAdapter_nativeInitialize(JNIEnv* env, jclass, jobject context) {
+    AuthCache::setAndroidContext(env->NewGlobalRef(context));
+}
+
+extern "C" JNIEXPORT void JNICALL Java_com_auth_AuthAdapter_nativeOnLoginSuccess(
+    JNIEnv* env, jclass, 
+    jstring provider, jstring email, jstring name, jstring photo, jstring idToken, jstring accessToken, jobjectArray scopes, jobject expirationTime) {
+    
+    std::shared_ptr<Promise<AuthUser>> loginPromise;
+    std::shared_ptr<Promise<AuthUser>> scopesPromise;
+    std::shared_ptr<Promise<std::optional<AuthUser>>> silentPromise;
+    {
+        std::lock_guard<std::mutex> lock(gMutex);
+        loginPromise = gLoginPromise;
+        gLoginPromise = nullptr;
+        scopesPromise = gScopesPromise;
+        gScopesPromise = nullptr;
+        silentPromise = gSilentPromise;
+        gSilentPromise = nullptr;
+    }
+    
+    AuthUser user;
+    const char* providerCStr = env->GetStringUTFChars(provider, nullptr);
+    user.provider = (std::string(providerCStr) == "google") ? AuthProvider::GOOGLE : AuthProvider::APPLE;
+    env->ReleaseStringUTFChars(provider, providerCStr);
+    
+    if (email) {
+        const char* s = env->GetStringUTFChars(email, nullptr);
+        user.email = std::string(s);
+        env->ReleaseStringUTFChars(email, s);
+    }
+    if (name) {
+        const char* s = env->GetStringUTFChars(name, nullptr);
+        user.name = std::string(s);
+        env->ReleaseStringUTFChars(name, s);
+    }
+    if (photo) {
+        const char* s = env->GetStringUTFChars(photo, nullptr);
+        user.photo = std::string(s);
+        env->ReleaseStringUTFChars(photo, s);
+    }
+    if (idToken) {
+        const char* s = env->GetStringUTFChars(idToken, nullptr);
+        user.idToken = std::string(s);
+        env->ReleaseStringUTFChars(idToken, s);
+    }
+    if (accessToken) {
+        const char* s = env->GetStringUTFChars(accessToken, nullptr);
+        user.accessToken = std::string(s);
+        env->ReleaseStringUTFChars(accessToken, s);
+    }
+    if (scopes) {
+        int len = env->GetArrayLength(scopes);
+        std::vector<std::string> scopeVec;
+        for (int i = 0; i < len; i++) {
+            jstring jstr = (jstring)env->GetObjectArrayElement(scopes, i);
+            const char* s = env->GetStringUTFChars(jstr, nullptr);
+            scopeVec.push_back(std::string(s));
+            env->ReleaseStringUTFChars(jstr, s);
+        }
+        user.scopes = scopeVec;
+    }
+    if (expirationTime) {
+        jclass longClass = env->FindClass("java/lang/Long");
+        jmethodID longValueMethod = env->GetMethodID(longClass, "longValue", "()J");
+        user.expirationTime = (double)env->CallLongMethod(expirationTime, longValueMethod);
+    }
+    if (loginPromise) loginPromise->resolve(user);
+    if (scopesPromise) scopesPromise->resolve(user);
+    if (silentPromise) silentPromise->resolve(user);
+}
+
+extern "C" JNIEXPORT void JNICALL Java_com_auth_AuthAdapter_nativeOnLoginError(
+    JNIEnv* env, jclass, jstring error) {
+    
+    std::shared_ptr<Promise<AuthUser>> loginPromise;
+    std::shared_ptr<Promise<AuthUser>> scopesPromise;
+    std::shared_ptr<Promise<std::optional<AuthUser>>> silentPromise;
+    {
+        std::lock_guard<std::mutex> lock(gMutex);
+        loginPromise = gLoginPromise;
+        gLoginPromise = nullptr;
+        scopesPromise = gScopesPromise;
+        gScopesPromise = nullptr;
+        silentPromise = gSilentPromise;
+        gSilentPromise = nullptr;
+    }
+    
+    const char* errorCStr = env->GetStringUTFChars(error, nullptr);
+    std::string errorStr(errorCStr);
+    env->ReleaseStringUTFChars(error, errorCStr);
+
+    if (loginPromise) loginPromise->reject(std::make_exception_ptr(std::runtime_error(errorStr)));
+    if (scopesPromise) scopesPromise->reject(std::make_exception_ptr(std::runtime_error(errorStr)));
+    if (silentPromise) {
+        if (errorStr == "No session") silentPromise->resolve(std::nullopt);
+        else silentPromise->reject(std::make_exception_ptr(std::runtime_error(errorStr)));
+    }
+}
+
+extern "C" JNIEXPORT void JNICALL Java_com_auth_AuthAdapter_nativeOnRefreshSuccess(
+    JNIEnv* env, jclass, jstring idToken, jstring accessToken, jobject expirationTime) {
+    
+    std::shared_ptr<Promise<AuthTokens>> refreshPromise;
+    {
+        std::lock_guard<std::mutex> lock(gMutex);
+        refreshPromise = gRefreshPromise;
+        gRefreshPromise = nullptr;
+    }
+    
+    if (refreshPromise) {
+        AuthTokens tokens;
+        if (idToken) {
+            const char* s = env->GetStringUTFChars(idToken, nullptr);
+            tokens.idToken = std::string(s);
+            env->ReleaseStringUTFChars(idToken, s);
+        }
+        if (accessToken) {
+            const char* s = env->GetStringUTFChars(accessToken, nullptr);
+            tokens.accessToken = std::string(s);
+            env->ReleaseStringUTFChars(accessToken, s);
+        }
+        if (expirationTime) {
+            jclass longClass = env->FindClass("java/lang/Long");
+            jmethodID longValueMethod = env->GetMethodID(longClass, "longValue", "()J");
+            tokens.expirationTime = (double)env->CallLongMethod(expirationTime, longValueMethod);
+        }
+        refreshPromise->resolve(tokens);
+    }
+}
+
+extern "C" JNIEXPORT void JNICALL Java_com_auth_AuthAdapter_nativeOnRefreshError(
+    JNIEnv* env, jclass, jstring error) {
+    
+    std::shared_ptr<Promise<AuthTokens>> refreshPromise;
+    {
+        std::lock_guard<std::mutex> lock(gMutex);
+        refreshPromise = gRefreshPromise;
+        gRefreshPromise = nullptr;
+    }
+    if (refreshPromise) {
+        const char* errorCStr = env->GetStringUTFChars(error, nullptr);
+        std::string errorStr(errorCStr);
+        env->ReleaseStringUTFChars(error, errorCStr);
+        refreshPromise->reject(std::make_exception_ptr(std::runtime_error(errorStr)));
+    }
+}
+
+} // namespace margelo::nitro::NitroAuth

package/android/src/main/java/com/auth/AuthAdapter.kt

@@ -0,0 +1,286 @@
+package com.auth
+
+import android.app.Activity
+import android.app.Application
+import android.content.Context
+import android.os.Bundle
+import android.util.Log
+import com.google.android.gms.auth.api.signin.GoogleSignIn
+import com.google.android.gms.auth.api.signin.GoogleSignInAccount
+import com.google.android.gms.auth.api.signin.GoogleSignInClient
+import com.google.android.gms.auth.api.signin.GoogleSignInOptions
+import com.google.android.gms.common.GoogleApiAvailability
+import com.google.android.gms.common.ConnectionResult
+import com.google.android.gms.common.api.Scope
+import java.lang.ref.WeakReference
+
+object AuthAdapter : Application.ActivityLifecycleCallbacks {
+    private const val TAG = "AuthAdapter"
+    private const val PREF_NAME = "nitro_auth"
+    
+    private var appContext: Context? = null
+    private var currentActivityRef: WeakReference<Activity>? = null
+    private var googleSignInClient: GoogleSignInClient? = null
+    private var pendingScopes: List<String> = emptyList()
+
+    @JvmStatic
+    private external fun nativeInitialize(context: Context)
+    
+    @JvmStatic
+    private external fun nativeOnLoginSuccess(
+        provider: String, 
+        email: String?, 
+        name: String?, 
+        photo: String?, 
+        idToken: String?,
+        accessToken: String?,
+        scopes: Array<String>?,
+        expirationTime: Long?
+    )
+    
+    @JvmStatic
+    private external fun nativeOnLoginError(error: String)
+
+    @JvmStatic
+    private external fun nativeOnRefreshSuccess(idToken: String?, accessToken: String?, expirationTime: Long?)
+
+    @JvmStatic
+    private external fun nativeOnRefreshError(error: String)
+
+    fun initialize(context: Context) {
+        appContext = context.applicationContext
+        (appContext as? Application)?.registerActivityLifecycleCallbacks(this)
+        try {
+            System.loadLibrary("NitroAuth")
+            nativeInitialize(appContext!!)
+        } catch (e: Exception) {
+            Log.e(TAG, "Failed to load NitroAuth library", e)
+        }
+    }
+
+    override fun onActivityCreated(activity: Activity, savedInstanceState: Bundle?) {
+        currentActivityRef = WeakReference(activity)
+    }
+    override fun onActivityStarted(activity: Activity) {
+        currentActivityRef = WeakReference(activity)
+    }
+    override fun onActivityResumed(activity: Activity) {
+        currentActivityRef = WeakReference(activity)
+    }
+    override fun onActivityPaused(activity: Activity) {}
+    override fun onActivityStopped(activity: Activity) {}
+    override fun onActivitySaveInstanceState(activity: Activity, outState: Bundle) {}
+    override fun onActivityDestroyed(activity: Activity) {
+        if (currentActivityRef?.get() == activity) {
+            currentActivityRef = null
+        }
+    }
+
+    fun onSignInSuccess(account: GoogleSignInAccount, scopes: List<String>) {
+        val ctx = appContext ?: return
+        saveUser(ctx, "google", account.email, account.displayName,
+                 account.photoUrl?.toString(), account.idToken, scopes)
+        nativeOnLoginSuccess("google", account.email, account.displayName,
+                            account.photoUrl?.toString(), account.idToken, null, scopes.toTypedArray(), null)
+    }
+
+    fun onSignInError(errorCode: Int, message: String?) {
+        val mappedError = when (errorCode) {
+            12501 -> "cancelled"
+            7 -> "network_error"
+            8, 10 -> "configuration_error"
+            else -> message ?: "unknown"
+        }
+        nativeOnLoginError(mappedError)
+    }
+
+    @JvmStatic
+    fun loginSync(context: Context, provider: String, googleClientId: String?, scopes: Array<String>?, loginHint: String?) {
+        if (provider == "apple") {
+            nativeOnLoginError("Apple Sign-In is not supported on Android.")
+            return
+        }
+
+        if (provider != "google") {
+            nativeOnLoginError("Unsupported provider: $provider")
+            return
+        }
+
+        val ctx = appContext ?: context.applicationContext
+        val clientId = googleClientId ?: getClientIdFromResources(ctx)
+        if (clientId == null) {
+            nativeOnLoginError("Google Client ID is required. Set it in app.json plugins.")
+            return
+        }
+
+        val requestedScopes = scopes?.toList() ?: listOf("email", "profile")
+        pendingScopes = requestedScopes
+
+        val intent = GoogleSignInActivity.createIntent(ctx, clientId, requestedScopes.toTypedArray(), loginHint)
+        ctx.startActivity(intent)
+    }
+
+    @JvmStatic
+    fun requestScopesSync(context: Context, scopes: Array<String>) {
+        val ctx = appContext ?: context.applicationContext
+        val account = GoogleSignIn.getLastSignedInAccount(ctx)
+        if (account == null) {
+            nativeOnLoginError("No user logged in")
+            return
+        }
+
+        val newScopes = scopes.map { Scope(it) }
+        if (GoogleSignIn.hasPermissions(account, *newScopes.toTypedArray())) {
+            onSignInSuccess(account, (pendingScopes + scopes.toList()).distinct())
+            return
+        }
+
+        val clientId = getClientIdFromResources(ctx)
+        if (clientId == null) {
+            nativeOnLoginError("Google Client ID not configured")
+            return
+        }
+
+        val allScopes = (pendingScopes + scopes.toList()).distinct()
+        val intent = GoogleSignInActivity.createIntent(ctx, clientId, allScopes.toTypedArray(), account.email)
+        ctx.startActivity(intent)
+    }
+
+    @JvmStatic
+    fun refreshTokenSync(context: Context) {
+        val ctx = appContext ?: context.applicationContext
+        if (googleSignInClient == null) {
+            val account = GoogleSignIn.getLastSignedInAccount(ctx)
+            if (account == null) {
+                nativeOnRefreshError("No user logged in")
+                return
+            }
+            val clientId = getClientIdFromResources(ctx)
+            if (clientId == null) {
+                nativeOnRefreshError("Google Client ID not configured")
+                return
+            }
+            val gso = GoogleSignInOptions.Builder(GoogleSignInOptions.DEFAULT_SIGN_IN)
+                .requestIdToken(clientId)
+                .requestEmail()
+                .build()
+            googleSignInClient = GoogleSignIn.getClient(ctx, gso)
+        }
+
+        googleSignInClient!!.silentSignIn().addOnCompleteListener { task ->
+            if (task.isSuccessful) {
+                val account = task.result
+                nativeOnRefreshSuccess(account?.idToken, null, null)
+            } else {
+                nativeOnRefreshError(task.exception?.message ?: "Silent sign-in failed")
+            }
+        }
+    }
+
+    @JvmStatic
+    fun hasPlayServices(context: Context): Boolean {
+        val ctx = context.applicationContext ?: appContext ?: return false
+        val availability = GoogleApiAvailability.getInstance()
+        val result = availability.isGooglePlayServicesAvailable(ctx)
+        return result == ConnectionResult.SUCCESS
+    }
+
+    @JvmStatic
+    fun logoutSync(context: Context) {
+        val ctx = appContext ?: context.applicationContext
+        val clientId = getClientIdFromResources(ctx)
+        if (clientId != null) {
+            val gso = GoogleSignInOptions.Builder(GoogleSignInOptions.DEFAULT_SIGN_IN)
+                .requestIdToken(clientId)
+                .requestEmail()
+                .build()
+            GoogleSignIn.getClient(ctx, gso).signOut()
+        }
+        clearUser(ctx)
+    }
+
+    @JvmStatic
+    fun revokeAccessSync(context: Context) {
+        val ctx = appContext ?: context.applicationContext
+        val clientId = getClientIdFromResources(ctx)
+        if (clientId != null) {
+            val gso = GoogleSignInOptions.Builder(GoogleSignInOptions.DEFAULT_SIGN_IN)
+                .requestIdToken(clientId)
+                .requestEmail()
+                .build()
+            GoogleSignIn.getClient(ctx, gso).revokeAccess()
+        }
+        clearUser(ctx)
+    }
+
+    private fun getClientIdFromResources(context: Context): String? {
+        val resId = context.resources.getIdentifier("nitro_auth_google_client_id", "string", context.packageName)
+        return if (resId != 0) context.getString(resId) else null
+    }
+
+    @JvmStatic
+    fun getUserJson(context: Context): String? {
+        val pref = context.getSharedPreferences(PREF_NAME, Context.MODE_PRIVATE)
+        return pref.getString("user_json", null)
+    }
+
+    @JvmStatic
+    fun setUserJson(context: Context, json: String) {
+        val pref = context.getSharedPreferences(PREF_NAME, Context.MODE_PRIVATE)
+        pref.edit().putString("user_json", json).apply()
+    }
+
+    @JvmStatic
+    fun clearUser(context: Context) {
+        val pref = context.getSharedPreferences(PREF_NAME, Context.MODE_PRIVATE)
+        pref.edit().clear().apply()
+    }
+
+    @JvmStatic
+    fun restoreSession(context: Context) {
+        val ctx = context.applicationContext ?: appContext ?: context
+        val account = GoogleSignIn.getLastSignedInAccount(ctx)
+        if (account != null) {
+            nativeOnLoginSuccess("google", account.email, account.displayName,
+                                account.photoUrl?.toString(), account.idToken, null,
+                                account.grantedScopes?.map { it.scopeUri }?.toTypedArray(), null)
+        } else {
+            val json = getUserJson(ctx)
+            if (json != null) {
+                val provider = if (json.contains("\"provider\":\"google\"")) "google" else "apple"
+                val email = extractJsonValue(json, "email")
+                val name = extractJsonValue(json, "name")
+                val photo = extractJsonValue(json, "photo")
+                val idToken = extractJsonValue(json, "idToken")
+                nativeOnLoginSuccess(provider, email, name, photo, idToken, null, null, null)
+            } else {
+                nativeOnLoginError("No session")
+            }
+        }
+    }
+
+    private fun extractJsonValue(json: String, key: String): String? {
+        val pattern = "\"$key\":\"([^\"]*)\""
+        val regex = Regex(pattern)
+        return regex.find(json)?.groupValues?.get(1)
+    }
+
+    private fun saveUser(context: Context, provider: String, email: String?, name: String?, 
+                          photo: String?, idToken: String?, scopes: List<String>?) {
+        val pref = context.getSharedPreferences(PREF_NAME, Context.MODE_PRIVATE)
+        val json = StringBuilder()
+        json.append("{")
+        json.append("\"provider\":\"$provider\"")
+        if (email != null) json.append(",\"email\":\"$email\"")
+        if (name != null) json.append(",\"name\":\"$name\"")
+        if (photo != null) json.append(",\"photo\":\"$photo\"")
+        if (idToken != null) json.append(",\"idToken\":\"$idToken\"")
+        if (scopes != null) {
+            json.append(",\"scopes\":[")
+            json.append(scopes.joinToString(",") { "\"$it\"" })
+            json.append("]")
+        }
+        json.append("}")
+        pref.edit().putString("user_json", json.toString()).apply()
+    }
+}

package/android/src/main/java/com/auth/GoogleSignInActivity.kt

@@ -0,0 +1,73 @@
+package com.auth
+
+import android.app.Activity
+import android.content.Context
+import android.content.Intent
+import android.os.Bundle
+import android.util.Log
+import androidx.activity.ComponentActivity
+import androidx.activity.result.contract.ActivityResultContracts
+import com.google.android.gms.auth.api.signin.GoogleSignIn
+import com.google.android.gms.auth.api.signin.GoogleSignInOptions
+import com.google.android.gms.common.api.ApiException
+import com.google.android.gms.common.api.Scope
+
+class GoogleSignInActivity : ComponentActivity() {
+    companion object {
+        private const val TAG = "GoogleSignInActivity"
+        private const val EXTRA_CLIENT_ID = "client_id"
+        private const val EXTRA_SCOPES = "scopes"
+        private const val EXTRA_LOGIN_HINT = "login_hint"
+        
+        fun createIntent(context: Context, clientId: String, scopes: Array<String>, loginHint: String?): Intent {
+            return Intent(context, GoogleSignInActivity::class.java).apply {
+                putExtra(EXTRA_CLIENT_ID, clientId)
+                putExtra(EXTRA_SCOPES, scopes)
+                putExtra(EXTRA_LOGIN_HINT, loginHint)
+                addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
+            }
+        }
+    }
+    
+    private val signInLauncher = registerForActivityResult(
+        ActivityResultContracts.StartActivityForResult()
+    ) { result ->
+        try {
+            val task = GoogleSignIn.getSignedInAccountFromIntent(result.data)
+            val account = task.getResult(ApiException::class.java)
+            val scopes = intent.getStringArrayExtra(EXTRA_SCOPES)?.toList() ?: emptyList()
+            AuthAdapter.onSignInSuccess(account, scopes)
+        } catch (e: ApiException) {
+            AuthAdapter.onSignInError(e.statusCode, e.message)
+        }
+        finish()
+    }
+    
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+        val clientId = intent.getStringExtra(EXTRA_CLIENT_ID)
+        val scopes = intent.getStringArrayExtra(EXTRA_SCOPES) ?: arrayOf("email", "profile")
+        val loginHint = intent.getStringExtra(EXTRA_LOGIN_HINT)
+        
+        if (clientId == null) {
+            AuthAdapter.onSignInError(8, "Missing client ID")
+            finish()
+            return
+        }
+        
+        val gsoBuilder = GoogleSignInOptions.Builder(GoogleSignInOptions.DEFAULT_SIGN_IN)
+            .requestIdToken(clientId)
+            .requestEmail()
+        
+        scopes.forEach { scopeStr ->
+            if (scopeStr != "email" && scopeStr != "profile" && scopeStr != "openid") {
+                gsoBuilder.requestScopes(Scope(scopeStr))
+            }
+        }
+        
+        if (loginHint != null) gsoBuilder.setAccountName(loginHint)
+        
+        val client = GoogleSignIn.getClient(this, gsoBuilder.build())
+        signInLauncher.launch(client.signInIntent)
+    }
+}

package/android/src/main/java/com/auth/NitroAuthModule.kt

@@ -0,0 +1,19 @@
+package com.auth
+
+import android.util.Log
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReactContextBaseJavaModule
+
+class NitroAuthModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaModule(reactContext) {
+    override fun getName(): String = "NitroAuthModule"
+
+    init {
+        try {
+            AuthAdapter.initialize(reactContext)
+            com.margelo.nitro.com.auth.NitroAuthOnLoad.initializeNative()
+            Log.d("NitroAuthModule", "NitroAuth initialized")
+        } catch (e: Exception) {
+            Log.e("NitroAuthModule", "Failed to initialize NitroAuth", e)
+        }
+    }
+}

package/android/src/main/java/com/auth/NitroAuthPackage.kt

@@ -0,0 +1,16 @@
+package com.auth
+
+import com.facebook.react.ReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.uimanager.ViewManager
+
+class NitroAuthPackage : ReactPackage {
+    override fun createNativeModules(reactContext: ReactApplicationContext): List<NativeModule> {
+        return listOf(NitroAuthModule(reactContext))
+    }
+
+    override fun createViewManagers(reactContext: ReactApplicationContext): List<ViewManager<*, *>> {
+        return emptyList()
+    }
+}