Add JVM credential sign-in and account linking support

build.gradle.kts

@@ -138,6 +138,7 @@ dependencies {
     testImplementation(libs.kotlinx.coroutines.play.services)
     testImplementation(libs.kotlinx.coroutines.swing)
     testImplementation(libs.kotlinx.coroutines.test)
+    testImplementation(libs.okhttp.mockwebserver)
     // firebase aars
     aar(platform(libs.google.firebase.bom))
     aar(libs.google.firebase.firestore)

gradle/libs.versions.toml

@@ -33,6 +33,7 @@ kotlinx-coroutines-test = { module = "org.jetbrains.kotlinx:kotlinx-coroutines-t
 kotlinx-serialization-core = { module = "org.jetbrains.kotlinx:kotlinx-serialization-core", version.ref = "kotlinx-serialization" }
 kotlinx-serialization-json = { module = "org.jetbrains.kotlinx:kotlinx-serialization-json", version.ref = "kotlinx-serialization" }
 okhttp = { module = "com.squareup.okhttp3:okhttp", version = "3.12.13" }
+okhttp-mockwebserver = { module = "com.squareup.okhttp3:mockwebserver", version = "3.12.13" }
 robolectric-android-all = { module = "org.robolectric:android-all", version = "14-robolectric-10818077" }
 xerial-sqlite-jdbc = { module = "org.xerial:sqlite-jdbc", version = "3.46.1.0" }
 

src/main/java/android/os/AsyncTask.kt

@@ -1,6 +1,6 @@
 package android.os
 
-import kotlinx.coroutines.Dispatchers
+import com.google.firebase.FirebasePlatform
 import kotlinx.coroutines.GlobalScope
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.withContext
@@ -19,9 +19,9 @@ abstract class AsyncTask {
 
     fun execute(vararg params: Any): AsyncTask {
         GlobalScope.launch {
-            withContext(Dispatchers.Main) { onPreExecute() }
+            withContext(FirebasePlatform.firebasePlatform.mainDispatcher) { onPreExecute() }
             val result = doInBackground(*params)
-            withContext(Dispatchers.Main) { onPostExecute(result) }
+            withContext(FirebasePlatform.firebasePlatform.mainDispatcher) { onPostExecute(result) }
         }
         return this
     }

src/main/java/android/os/Handler.kt

@@ -1,7 +1,6 @@
 package android.os
 
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.GlobalScope
+import com.google.firebase.FirebasePlatform
 import kotlinx.coroutines.delay
 import kotlinx.coroutines.launch
 
@@ -10,14 +9,14 @@ open class Handler(looper: Looper?, callback: Handler.Callback?) {
     constructor(looper: Looper) : this(looper, null)
 
     fun post(runnable: Runnable): Boolean {
-        GlobalScope.launch(Dispatchers.Main) {
+        FirebasePlatform.firebasePlatform.mainScope.launch {
             runnable.run()
         }
         return true
     }
 
     fun postDelayed(runnable: Runnable, time: Long): Boolean {
-        GlobalScope.launch(Dispatchers.Main) {
+        FirebasePlatform.firebasePlatform.mainScope.launch {
             delay(time)
             runnable.run()
         }

src/main/java/com/google/firebase/FirebasePlatform.kt

@@ -1,9 +1,20 @@
 package com.google.firebase
 
+import kotlinx.coroutines.CoroutineDispatcher
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.SupervisorJob
 import java.io.File
 
 abstract class FirebasePlatform {
 
+    open val mainDispatcher: CoroutineDispatcher
+        get() = Dispatchers.Default
+
+    internal val mainScope: CoroutineScope by lazy(LazyThreadSafetyMode.SYNCHRONIZED) {
+        CoroutineScope(SupervisorJob() + mainDispatcher)
+    }
+
     companion object {
 
         internal lateinit var firebasePlatform: FirebasePlatform

src/main/java/com/google/firebase/auth/AuthCredential.java

@@ -1,9 +1,75 @@
 package com.google.firebase.auth;
 
-import kotlin.NotImplementedError;
+import java.net.URLEncoder;
+import java.nio.charset.StandardCharsets;
+import java.util.ArrayList;
+import java.util.List;
+
+public abstract class AuthCredential {
+    private final String provider;
+    private final String idToken;
+    private final String accessToken;
+    private final String rawNonce;
+
+    protected AuthCredential(String provider) {
+        this(provider, null, null, null);
+    }
+
+    protected AuthCredential(String provider, String idToken, String accessToken, String rawNonce) {
+        this.provider = requireValue(provider, "provider");
+        this.idToken = optionalValue(idToken, "idToken");
+        this.accessToken = optionalValue(accessToken, "accessToken");
+        this.rawNonce = optionalValue(rawNonce, "rawNonce");
+
+        if (this.rawNonce != null && this.idToken == null) {
+            throw new IllegalArgumentException("An ID token is required when a raw nonce is supplied.");
+        }
+    }
 
-public class AuthCredential {
     public String getProvider() {
-        throw new NotImplementedError();
+        return provider;
+    }
+
+    public String getSignInMethod() {
+        return provider;
+    }
+
+    String toIdpPostBody() {
+        List<String> values = new ArrayList<>();
+        values.add(formValue("providerId", provider));
+        if (idToken != null) {
+            values.add(formValue("id_token", idToken));
+        }
+        if (accessToken != null) {
+            values.add(formValue("access_token", accessToken));
+        }
+        if (rawNonce != null) {
+            values.add(formValue("nonce", rawNonce));
+        }
+        return String.join("&", values);
+    }
+
+    @Override
+    public String toString() {
+        return getClass().getSimpleName() + "{provider='" + provider + "'}";
+    }
+
+    static String requireValue(String value, String name) {
+        if (value == null || value.trim().isEmpty()) {
+            throw new IllegalArgumentException(name + " must not be null or blank.");
+        }
+        return value;
+    }
+
+    static String optionalValue(String value, String name) {
+        if (value != null && value.trim().isEmpty()) {
+            throw new IllegalArgumentException(name + " must not be blank.");
+        }
+        return value;
+    }
+
+    private static String formValue(String name, String value) {
+        return URLEncoder.encode(name, StandardCharsets.UTF_8) + "=" +
+            URLEncoder.encode(value, StandardCharsets.UTF_8);
     }
 }