@trainon-inc/capacitor-clerk-native 1.21.0 → 1.22.0

package/README.md

@@ -49,7 +49,7 @@ Alternatively, install from GitHub Packages:
 1. Create a `.npmrc` file in your project root:
 ```
 @trainon-inc:registry=https://npm.pkg.github.com
-//npm.pkg.github.com/:_authToken= YOUR_GITHUB_TOKEN
+//npm.pkg.github.com/:_authToken=YOUR_GITHUB_TOKEN
 ```
 
 2. Install the package:
@@ -414,15 +414,26 @@ function Profile() {
 
 ## Android Setup
 
-Android is supported using the same bridge pattern as iOS. The plugin provides a stub implementation that you can extend with the Clerk Android SDK.
+Android is fully supported with the native Clerk Android SDK integration. Unlike iOS, Android doesn't require a bridge pattern - the plugin directly integrates with the Clerk Android SDK.
 
 ### Prerequisites
 
 - ✅ A [Clerk account](https://dashboard.clerk.com/sign-up)
 - ✅ A Clerk application set up in the dashboard
+- ✅ **Native API enabled** in Clerk Dashboard → Settings → Native Applications
 - ✅ Android Studio with Gradle 8.7+ and AGP 8.5+
+- ✅ JDK 17 or higher
+
+### 1. Register Your Android App with Clerk
 
-### 1. Sync Capacitor
+1. Go to the [**Native Applications**](https://dashboard.clerk.com/last-active?path=native-applications) page in Clerk Dashboard
+2. Click **"Add Application"**
+3. Select **Android** tab
+4. Enter your Android app details:
+   - **Package Name**: Your app's package name (e.g., `com.trainon.member`)
+   - **SHA256 Fingerprint**: Your app's signing certificate fingerprint (get it with `./gradlew signingReport`)
+
+### 2. Sync Capacitor
 
 After installing the plugin, sync your Android project:
 
@@ -433,40 +444,52 @@ npx cap sync android
 This will:
 - Add the plugin to `capacitor.settings.gradle`
 - Add the plugin dependency to `capacitor.build.gradle`
+- Include the Clerk Android SDK automatically
 
-### 2. Plugin Structure
-
-The plugin includes:
+### 3. Configure Clerk in Your App
 
-```
-android/
-├── build.gradle              # Gradle build configuration
-└── src/
-    └── main/
-        ├── AndroidManifest.xml   # Android manifest
-        └── java/
-            └── com/trainon/capacitor/clerk/
-                └── ClerkNativePlugin.java
-```
+The plugin automatically handles Clerk initialization when you call `configure()` from JavaScript. No additional Android-specific setup is required!
 
-### 3. Gradle Configuration
+```typescript
+import { ClerkNative } from '@trainon-inc/capacitor-clerk-native';
 
-The plugin uses these default configurations (which can be overridden by your app's `variables.gradle`):
+// Configure Clerk (call once at app startup)
+await ClerkNative.configure({
+  publishableKey: 'pk_test_your_clerk_key_here'
+});
 
-| Property | Default | Description |
-|----------|---------|-------------|
-| `compileSdkVersion` | 35 | Android compile SDK |
-| `minSdkVersion` | 23 | Minimum Android version |
-| `targetSdkVersion` | 35 | Target Android version |
-| `junitVersion` | 4.13.2 | JUnit test version |
+// Load and check for existing session
+const { user } = await ClerkNative.load();
+```
 
-### 4. Build Requirements
+### 4. Plugin Features
+
+The Android implementation supports all authentication methods:
+
+| Method | Description |
+|--------|-------------|
+| `configure()` | Initialize Clerk with publishable key |
+| `load()` | Load Clerk and check for existing session |
+| `signInWithPassword()` | Sign in with email and password |
+| `signInWithEmail()` | Start email code sign in flow |
+| `verifyEmailCode()` | Verify email code |
+| `signUp()` | Create a new account |
+| `verifySignUpEmail()` | Verify sign up email |
+| `getUser()` | Get current user |
+| `getToken()` | Get authentication token |
+| `signOut()` | Sign out current user |
+| `updateUser()` | Update user profile |
+| `requestPasswordReset()` | Request password reset |
+| `resetPassword()` | Reset password with code |
+| `refreshSession()` | Refresh session token |
+
+### 5. Build Requirements
 
 - **Gradle**: 8.11.1+
 - **Android Gradle Plugin**: 8.7.2+
-- **Java**: 21
-
-These are configured in the plugin's `build.gradle` and are compatible with Capacitor 7.
+- **Java/Kotlin**: 17+
+- **Min SDK**: 23 (Android 6.0)
+- **Target SDK**: 35 (Android 15)
 
 ### Troubleshooting Android
 
@@ -476,19 +499,26 @@ Could not resolve project :trainon-inc-capacitor-clerk-native
 No matching variant of project was found. No variants exist.
 ```
 
-**Solution**: Ensure you have the latest version of the plugin (1.16.0+) which includes the required `build.gradle` and `AndroidManifest.xml` files. Run:
+**Solution**: Ensure you have the latest version of the plugin which includes the required build files:
 ```bash
 npm update @trainon-inc/capacitor-clerk-native
 npx cap sync android
 ```
 
+#### "invalid source release: 21" error
+The plugin uses Java 17 by default. Ensure your Android Studio uses JDK 17+:
+- **File → Project Structure → SDK Location → Gradle JDK** → Select JDK 17+
+
 #### Gradle sync fails
 - Clean the project: **Build → Clean Project**
 - Invalidate caches: **File → Invalidate Caches / Restart**
 - Delete `.gradle` folder and re-sync
 
-#### AGP version mismatch
-If you see AGP version conflicts, ensure your app's `build.gradle` uses AGP 8.5.0 or higher, matching the plugin's requirements.
+#### Network errors
+Ensure INTERNET permission is in your `AndroidManifest.xml`:
+```xml
+<uses-permission android:name="android.permission.INTERNET" />
+```
 
 ## Contributing
 

package/android/build.gradle

@@ -3,6 +3,7 @@ ext {
     androidxAppCompatVersion = project.hasProperty('androidxAppCompatVersion') ? rootProject.ext.androidxAppCompatVersion : '1.7.0'
     androidxJunitVersion = project.hasProperty('androidxJunitVersion') ? rootProject.ext.androidxJunitVersion : '1.2.1'
     androidxEspressoCoreVersion = project.hasProperty('androidxEspressoCoreVersion') ? rootProject.ext.androidxEspressoCoreVersion : '3.6.1'
+    kotlinVersion = project.hasProperty('kotlinVersion') ? rootProject.ext.kotlinVersion : '1.9.25'
 }
 
 buildscript {
@@ -12,10 +13,12 @@ buildscript {
     }
     dependencies {
         classpath 'com.android.tools.build:gradle:8.7.2'
+        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:1.9.25"
     }
 }
 
 apply plugin: 'com.android.library'
+apply plugin: 'kotlin-android'
 
 android {
     namespace "com.trainon.capacitor.clerk"
@@ -37,8 +40,11 @@ android {
         abortOnError false
     }
     compileOptions {
-        sourceCompatibility JavaVersion.VERSION_21
-        targetCompatibility JavaVersion.VERSION_21
+        sourceCompatibility JavaVersion.VERSION_17
+        targetCompatibility JavaVersion.VERSION_17
+    }
+    kotlinOptions {
+        jvmTarget = '17'
     }
 }
 
@@ -51,6 +57,15 @@ dependencies {
     implementation fileTree(dir: 'libs', include: ['*.jar'])
     implementation project(':capacitor-android')
     implementation "androidx.appcompat:appcompat:$androidxAppCompatVersion"
+    
+    // Kotlin
+    implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlinVersion"
+    implementation "org.jetbrains.kotlinx:kotlinx-coroutines-android:1.7.3"
+    
+    // Clerk Android SDK
+    implementation "com.clerk:clerk-android:0.8.0"
+    
+    // Testing
     testImplementation "junit:junit:$junitVersion"
     androidTestImplementation "androidx.test.ext:junit:$androidxJunitVersion"
     androidTestImplementation "androidx.test.espresso:espresso-core:$androidxEspressoCoreVersion"

package/android/src/main/AndroidManifest.xml

@@ -1,2 +1,3 @@
 <manifest xmlns:android="http://schemas.android.com/apk/res/android">
+    <uses-permission android:name="android.permission.INTERNET" />
 </manifest>

package/android/src/main/java/com/trainon/capacitor/clerk/ClerkNativePlugin.kt

@@ -0,0 +1,509 @@
+package com.trainon.capacitor.clerk
+
+import android.util.Log
+import com.clerk.android.Clerk
+import com.clerk.android.models.Session
+import com.clerk.android.models.SignIn
+import com.clerk.android.models.SignUp
+import com.clerk.android.models.User
+import com.getcapacitor.JSObject
+import com.getcapacitor.Plugin
+import com.getcapacitor.PluginCall
+import com.getcapacitor.PluginMethod
+import com.getcapacitor.annotation.CapacitorPlugin
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.launch
+
+@CapacitorPlugin(name = "ClerkNative")
+class ClerkNativePlugin : Plugin() {
+    
+    private val TAG = "ClerkNativePlugin"
+    private val scope = CoroutineScope(Dispatchers.Main + SupervisorJob())
+    private var isConfigured = false
+
+    @PluginMethod
+    fun configure(call: PluginCall) {
+        val publishableKey = call.getString("publishableKey")
+        
+        if (publishableKey.isNullOrEmpty()) {
+            call.reject("Must provide publishableKey")
+            return
+        }
+
+        try {
+            // Initialize Clerk with the publishable key
+            Clerk.configure(context, publishableKey)
+            isConfigured = true
+            Log.d(TAG, "Clerk configured successfully")
+            call.resolve()
+        } catch (e: Exception) {
+            Log.e(TAG, "Failed to configure Clerk", e)
+            call.reject("Failed to configure Clerk: ${e.message}")
+        }
+    }
+
+    @PluginMethod
+    fun load(call: PluginCall) {
+        if (!isConfigured) {
+            call.reject("Clerk not configured. Call configure() first.")
+            return
+        }
+
+        scope.launch {
+            try {
+                val user = Clerk.user
+                val result = JSObject()
+                if (user != null) {
+                    result.put("user", userToJSObject(user))
+                } else {
+                    result.put("user", null)
+                }
+                call.resolve(result)
+            } catch (e: Exception) {
+                Log.e(TAG, "Failed to load Clerk", e)
+                call.reject("Failed to load Clerk: ${e.message}")
+            }
+        }
+    }
+
+    @PluginMethod
+    fun signInWithEmail(call: PluginCall) {
+        val email = call.getString("email")
+        
+        if (email.isNullOrEmpty()) {
+            call.reject("Must provide email")
+            return
+        }
+
+        scope.launch {
+            try {
+                val signIn = SignIn.create(identifier = email)
+                signIn.onSuccess { si ->
+                    // Prepare email code verification
+                    si.prepareFirstFactor(
+                        strategy = SignIn.PrepareFirstFactorStrategy.EmailCode(
+                            emailAddressId = si.supportedFirstFactors
+                                ?.filterIsInstance<SignIn.Factor.EmailCode>()
+                                ?.firstOrNull()
+                                ?.emailAddressId ?: ""
+                        )
+                    ).onSuccess {
+                        val result = JSObject()
+                        result.put("requiresCode", true)
+                        call.resolve(result)
+                    }.onFailure { error ->
+                        call.reject("Failed to prepare email code: ${error.message}")
+                    }
+                }.onFailure { error ->
+                    call.reject("Sign in with email failed: ${error.message}")
+                }
+            } catch (e: Exception) {
+                Log.e(TAG, "Sign in with email failed", e)
+                call.reject("Sign in with email failed: ${e.message}")
+            }
+        }
+    }
+
+    @PluginMethod
+    fun verifyEmailCode(call: PluginCall) {
+        val code = call.getString("code")
+        
+        if (code.isNullOrEmpty()) {
+            call.reject("Must provide code")
+            return
+        }
+
+        scope.launch {
+            try {
+                val signIn = Clerk.client?.signIn
+                if (signIn == null) {
+                    call.reject("No active sign in session")
+                    return@launch
+                }
+
+                signIn.attemptFirstFactor(
+                    strategy = SignIn.AttemptFirstFactorStrategy.EmailCode(code = code)
+                ).onSuccess { si ->
+                    if (si.status == SignIn.Status.COMPLETE) {
+                        // Set active session
+                        Clerk.client?.activeSessions?.firstOrNull()?.let { session ->
+                            Clerk.setActive(sessionId = session.id)
+                        }
+                        
+                        val user = Clerk.user
+                        val result = JSObject()
+                        result.put("user", user?.let { userToJSObject(it) })
+                        call.resolve(result)
+                    } else {
+                        call.reject("Verification incomplete")
+                    }
+                }.onFailure { error ->
+                    call.reject("Email code verification failed: ${error.message}")
+                }
+            } catch (e: Exception) {
+                Log.e(TAG, "Email code verification failed", e)
+                call.reject("Email code verification failed: ${e.message}")
+            }
+        }
+    }
+
+    @PluginMethod
+    fun signInWithPassword(call: PluginCall) {
+        val email = call.getString("email")
+        val password = call.getString("password")
+        
+        if (email.isNullOrEmpty() || password.isNullOrEmpty()) {
+            call.reject("Must provide email and password")
+            return
+        }
+
+        scope.launch {
+            try {
+                val signIn = SignIn.create(identifier = email)
+                signIn.onSuccess { si ->
+                    si.attemptFirstFactor(
+                        strategy = SignIn.AttemptFirstFactorStrategy.Password(password = password)
+                    ).onSuccess { completedSignIn ->
+                        if (completedSignIn.status == SignIn.Status.COMPLETE) {
+                            // Set active session
+                            completedSignIn.createdSessionId?.let { sessionId ->
+                                Clerk.setActive(sessionId = sessionId)
+                            }
+                            
+                            // Get user after sign in
+                            val user = Clerk.user
+                            val result = JSObject()
+                            result.put("user", user?.let { userToJSObject(it) })
+                            call.resolve(result)
+                        } else {
+                            call.reject("Sign in incomplete")
+                        }
+                    }.onFailure { error ->
+                        call.reject("Sign in failed: ${error.message}")
+                    }
+                }.onFailure { error ->
+                    call.reject("Sign in failed: ${error.message}")
+                }
+            } catch (e: Exception) {
+                Log.e(TAG, "Sign in with password failed", e)
+                call.reject("Sign in with password failed: ${e.message}")
+            }
+        }
+    }
+
+    @PluginMethod
+    fun signUp(call: PluginCall) {
+        val emailAddress = call.getString("emailAddress")
+        val password = call.getString("password")
+        val firstName = call.getString("firstName")
+        val lastName = call.getString("lastName")
+        
+        if (emailAddress.isNullOrEmpty() || password.isNullOrEmpty()) {
+            call.reject("Must provide emailAddress and password")
+            return
+        }
+
+        scope.launch {
+            try {
+                val signUp = SignUp.create(
+                    emailAddress = emailAddress,
+                    password = password,
+                    firstName = firstName,
+                    lastName = lastName
+                )
+                
+                signUp.onSuccess { su ->
+                    when (su.status) {
+                        SignUp.Status.COMPLETE -> {
+                            // Sign up complete, set active session
+                            su.createdSessionId?.let { sessionId ->
+                                Clerk.setActive(sessionId = sessionId)
+                            }
+                            
+                            val user = Clerk.user
+                            val result = JSObject()
+                            result.put("user", user?.let { userToJSObject(it) })
+                            result.put("requiresVerification", false)
+                            call.resolve(result)
+                        }
+                        SignUp.Status.MISSING_REQUIREMENTS -> {
+                            // Needs email verification
+                            su.prepareEmailAddressVerification().onSuccess {
+                                val result = JSObject()
+                                result.put("user", null)
+                                result.put("requiresVerification", true)
+                                call.resolve(result)
+                            }.onFailure { error ->
+                                call.reject("Failed to prepare email verification: ${error.message}")
+                            }
+                        }
+                        else -> {
+                            call.reject("Sign up incomplete: ${su.status}")
+                        }
+                    }
+                }.onFailure { error ->
+                    call.reject("Sign up failed: ${error.message}")
+                }
+            } catch (e: Exception) {
+                Log.e(TAG, "Sign up failed", e)
+                call.reject("Sign up failed: ${e.message}")
+            }
+        }
+    }
+
+    @PluginMethod
+    fun verifySignUpEmail(call: PluginCall) {
+        val code = call.getString("code")
+        
+        if (code.isNullOrEmpty()) {
+            call.reject("Must provide code")
+            return
+        }
+
+        scope.launch {
+            try {
+                val signUp = Clerk.client?.signUp
+                if (signUp == null) {
+                    call.reject("No active sign up session")
+                    return@launch
+                }
+
+                signUp.attemptEmailAddressVerification(code = code)
+                    .onSuccess { su ->
+                        if (su.status == SignUp.Status.COMPLETE) {
+                            su.createdSessionId?.let { sessionId ->
+                                Clerk.setActive(sessionId = sessionId)
+                            }
+                            
+                            val user = Clerk.user
+                            val result = JSObject()
+                            result.put("user", user?.let { userToJSObject(it) })
+                            call.resolve(result)
+                        } else {
+                            call.reject("Verification incomplete")
+                        }
+                    }.onFailure { error ->
+                        call.reject("Email verification failed: ${error.message}")
+                    }
+            } catch (e: Exception) {
+                Log.e(TAG, "Email verification failed", e)
+                call.reject("Email verification failed: ${e.message}")
+            }
+        }
+    }
+
+    @PluginMethod
+    fun getUser(call: PluginCall) {
+        scope.launch {
+            try {
+                val user = Clerk.user
+                val result = JSObject()
+                if (user != null) {
+                    result.put("user", userToJSObject(user))
+                } else {
+                    result.put("user", null)
+                }
+                call.resolve(result)
+            } catch (e: Exception) {
+                Log.e(TAG, "Get user failed", e)
+                call.reject("Get user failed: ${e.message}")
+            }
+        }
+    }
+
+    @PluginMethod
+    fun getToken(call: PluginCall) {
+        scope.launch {
+            try {
+                val session = Clerk.session
+                if (session == null) {
+                    val result = JSObject()
+                    result.put("token", null)
+                    call.resolve(result)
+                    return@launch
+                }
+
+                session.getToken().onSuccess { tokenResult ->
+                    val result = JSObject()
+                    result.put("token", tokenResult?.jwt)
+                    call.resolve(result)
+                }.onFailure { error ->
+                    call.reject("Get token failed: ${error.message}")
+                }
+            } catch (e: Exception) {
+                Log.e(TAG, "Get token failed", e)
+                call.reject("Get token failed: ${e.message}")
+            }
+        }
+    }
+
+    @PluginMethod
+    fun signOut(call: PluginCall) {
+        scope.launch {
+            try {
+                val session = Clerk.session
+                if (session != null) {
+                    session.revoke().onSuccess {
+                        call.resolve()
+                    }.onFailure { error ->
+                        call.reject("Sign out failed: ${error.message}")
+                    }
+                } else {
+                    // No active session, consider it signed out
+                    call.resolve()
+                }
+            } catch (e: Exception) {
+                Log.e(TAG, "Sign out failed", e)
+                call.reject("Sign out failed: ${e.message}")
+            }
+        }
+    }
+
+    @PluginMethod
+    fun updateUser(call: PluginCall) {
+        val firstName = call.getString("firstName")
+        val lastName = call.getString("lastName")
+
+        scope.launch {
+            try {
+                val user = Clerk.user
+                if (user == null) {
+                    call.reject("No user signed in")
+                    return@launch
+                }
+
+                user.update(
+                    firstName = firstName,
+                    lastName = lastName
+                ).onSuccess { updatedUser ->
+                    val result = JSObject()
+                    result.put("user", userToJSObject(updatedUser))
+                    call.resolve(result)
+                }.onFailure { error ->
+                    call.reject("Update user failed: ${error.message}")
+                }
+            } catch (e: Exception) {
+                Log.e(TAG, "Update user failed", e)
+                call.reject("Update user failed: ${e.message}")
+            }
+        }
+    }
+
+    @PluginMethod
+    fun requestPasswordReset(call: PluginCall) {
+        val email = call.getString("email")
+        
+        if (email.isNullOrEmpty()) {
+            call.reject("Must provide email")
+            return
+        }
+
+        scope.launch {
+            try {
+                val signIn = SignIn.create(identifier = email)
+                signIn.onSuccess { si ->
+                    si.prepareFirstFactor(
+                        strategy = SignIn.PrepareFirstFactorStrategy.ResetPasswordEmailCode(
+                            emailAddressId = si.supportedFirstFactors
+                                ?.filterIsInstance<SignIn.Factor.ResetPasswordEmailCode>()
+                                ?.firstOrNull()
+                                ?.emailAddressId ?: ""
+                        )
+                    ).onSuccess {
+                        call.resolve()
+                    }.onFailure { error ->
+                        call.reject("Failed to request password reset: ${error.message}")
+                    }
+                }.onFailure { error ->
+                    call.reject("Failed to request password reset: ${error.message}")
+                }
+            } catch (e: Exception) {
+                Log.e(TAG, "Request password reset failed", e)
+                call.reject("Request password reset failed: ${e.message}")
+            }
+        }
+    }
+
+    @PluginMethod
+    fun resetPassword(call: PluginCall) {
+        val code = call.getString("code")
+        val newPassword = call.getString("newPassword")
+        
+        if (code.isNullOrEmpty() || newPassword.isNullOrEmpty()) {
+            call.reject("Must provide code and newPassword")
+            return
+        }
+
+        scope.launch {
+            try {
+                val signIn = Clerk.client?.signIn
+                if (signIn == null) {
+                    call.reject("No active sign in session")
+                    return@launch
+                }
+
+                signIn.attemptFirstFactor(
+                    strategy = SignIn.AttemptFirstFactorStrategy.ResetPasswordEmailCode(code = code)
+                ).onSuccess { si ->
+                    si.resetPassword(newPassword = newPassword).onSuccess { completedSignIn ->
+                        if (completedSignIn.status == SignIn.Status.COMPLETE) {
+                            completedSignIn.createdSessionId?.let { sessionId ->
+                                Clerk.setActive(sessionId = sessionId)
+                            }
+                            call.resolve()
+                        } else {
+                            call.reject("Password reset incomplete")
+                        }
+                    }.onFailure { error ->
+                        call.reject("Failed to reset password: ${error.message}")
+                    }
+                }.onFailure { error ->
+                    call.reject("Failed to verify reset code: ${error.message}")
+                }
+            } catch (e: Exception) {
+                Log.e(TAG, "Reset password failed", e)
+                call.reject("Reset password failed: ${e.message}")
+            }
+        }
+    }
+
+    @PluginMethod
+    fun refreshSession(call: PluginCall) {
+        scope.launch {
+            try {
+                val session = Clerk.session
+                if (session == null) {
+                    val result = JSObject()
+                    result.put("token", null)
+                    call.resolve(result)
+                    return@launch
+                }
+
+                // Force refresh the token
+                session.getToken(forceRefresh = true).onSuccess { tokenResult ->
+                    val result = JSObject()
+                    result.put("token", tokenResult?.jwt)
+                    call.resolve(result)
+                }.onFailure { error ->
+                    call.reject("Refresh session failed: ${error.message}")
+                }
+            } catch (e: Exception) {
+                Log.e(TAG, "Refresh session failed", e)
+                call.reject("Refresh session failed: ${e.message}")
+            }
+        }
+    }
+
+    private fun userToJSObject(user: User): JSObject {
+        val jsObject = JSObject()
+        jsObject.put("id", user.id)
+        jsObject.put("firstName", user.firstName)
+        jsObject.put("lastName", user.lastName)
+        jsObject.put("emailAddress", user.primaryEmailAddress?.emailAddress)
+        jsObject.put("imageUrl", user.imageUrl)
+        jsObject.put("username", user.username)
+        return jsObject
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@trainon-inc/capacitor-clerk-native",
-  "version": "1.21.0",
+  "version": "1.22.0",
   "description": "Capacitor plugin for Clerk native authentication using bridge pattern to integrate Clerk iOS/Android SDKs with CocoaPods/Gradle",
   "main": "dist/index.js",
   "module": "dist/index.js",

package/android/src/main/java/com/trainon/capacitor/clerk/ClerkNativePlugin.java

@@ -1,81 +0,0 @@
-package com.trainon.capacitor.clerk;
-
-import com.getcapacitor.Plugin;
-import com.getcapacitor.PluginCall;
-import com.getcapacitor.PluginMethod;
-import com.getcapacitor.annotation.CapacitorPlugin;
-
-@CapacitorPlugin(name = "ClerkNative")
-public class ClerkNativePlugin extends Plugin {
-
-    @PluginMethod
-    public void configure(PluginCall call) {
-        call.reject("Android not yet implemented");
-    }
-
-    @PluginMethod
-    public void load(PluginCall call) {
-        call.reject("Android not yet implemented");
-    }
-
-    @PluginMethod
-    public void signInWithEmail(PluginCall call) {
-        call.reject("Android not yet implemented");
-    }
-
-    @PluginMethod
-    public void verifyEmailCode(PluginCall call) {
-        call.reject("Android not yet implemented");
-    }
-
-    @PluginMethod
-    public void signInWithPassword(PluginCall call) {
-        call.reject("Android not yet implemented");
-    }
-
-    @PluginMethod
-    public void signUp(PluginCall call) {
-        call.reject("Android not yet implemented");
-    }
-
-    @PluginMethod
-    public void verifySignUpEmail(PluginCall call) {
-        call.reject("Android not yet implemented");
-    }
-
-    @PluginMethod
-    public void getUser(PluginCall call) {
-        call.reject("Android not yet implemented");
-    }
-
-    @PluginMethod
-    public void getToken(PluginCall call) {
-        call.reject("Android not yet implemented");
-    }
-
-    @PluginMethod
-    public void signOut(PluginCall call) {
-        call.reject("Android not yet implemented");
-    }
-
-    @PluginMethod
-    public void updateUser(PluginCall call) {
-        call.reject("Android not yet implemented");
-    }
-
-    @PluginMethod
-    public void requestPasswordReset(PluginCall call) {
-        call.reject("Android not yet implemented");
-    }
-
-    @PluginMethod
-    public void resetPassword(PluginCall call) {
-        call.reject("Android not yet implemented");
-    }
-
-    @PluginMethod
-    public void refreshSession(PluginCall call) {
-        call.reject("Android not yet implemented");
-    }
-}
-