Upgrade to latest APIS and add SnapshotListenOptions support

TODO: The Java SDK should be updated

Author: Daeda88

build.gradle.kts

@@ -32,7 +32,7 @@ buildscript {
 
 val compileSdkVersion by extra(34)
 val targetSdkVersion by extra(34)
-val minSdkVersion by extra(21)
+val minSdkVersion by extra(23)
 
 tasks {
     register("updateVersions") {

firebase-app/src/appleMain/kotlin/dev/gitlive/firebase/firebase.kt

@@ -29,7 +29,7 @@ public actual data class FirebaseApp internal constructor(internal val ios: FIRA
     actual val name: String
         get() = ios.name
     actual val options: FirebaseOptions
-        get() = ios.options.run { FirebaseOptions(bundleID, APIKey!!, databaseURL!!, trackingID, storageBucket, projectID, GCMSenderID) }
+        get() = ios.options.run { FirebaseOptions(bundleID, APIKey!!, databaseURL!!, null, storageBucket, projectID, GCMSenderID) }
 
     public actual suspend fun delete() {
         val deleted = CompletableDeferred<Unit>()
@@ -46,7 +46,6 @@ public actual fun Firebase.apps(context: Any?): List<FirebaseApp> = FIRApp.allAp
 private fun FirebaseOptions.toIos() = FIROptions(this@toIos.applicationId, this@toIos.gcmSenderId ?: "").apply {
     APIKey = this@toIos.apiKey
     databaseURL = this@toIos.databaseUrl
-    trackingID = this@toIos.gaTrackingId
     storageBucket = this@toIos.storageBucket
     projectID = this@toIos.projectId
 }

firebase-auth/src/androidMain/kotlin/dev/gitlive/firebase/auth/auth.kt

@@ -91,18 +91,25 @@ public actual class FirebaseAuth internal constructor(internal val android: com.
         @Suppress("UNCHECKED_CAST")
         return when (result.operation) {
             SIGN_IN_WITH_EMAIL_LINK -> ActionCodeResult.SignInWithEmailLink
+
             VERIFY_EMAIL -> ActionCodeResult.VerifyEmail(result.info!!.email)
+
             PASSWORD_RESET -> ActionCodeResult.PasswordReset(result.info!!.email)
+
             RECOVER_EMAIL -> (result.info as ActionCodeEmailInfo).run {
                 ActionCodeResult.RecoverEmail(email, previousEmail)
             }
+
             VERIFY_BEFORE_CHANGE_EMAIL -> (result.info as ActionCodeEmailInfo).run {
                 ActionCodeResult.VerifyBeforeChangeEmail(email, previousEmail)
             }
+
             REVERT_SECOND_FACTOR_ADDITION -> (result.info as ActionCodeMultiFactorInfo).run {
                 ActionCodeResult.RevertSecondFactorAddition(email, MultiFactorInfo(multiFactorInfo))
             }
+
             ERROR -> throw UnsupportedOperationException(result.operation.toString())
+
             else -> throw UnsupportedOperationException(result.operation.toString())
         } as T
     }

firebase-auth/src/appleMain/kotlin/dev/gitlive/firebase/auth/auth.kt

@@ -266,5 +266,6 @@ private fun NSError.toException() = when (domain) {
 
         else -> FirebaseAuthException(toString())
     }
+
     else -> FirebaseAuthException(toString())
 }

firebase-auth/src/jsMain/kotlin/dev/gitlive/firebase/auth/auth.kt

@@ -104,17 +104,23 @@ public actual class FirebaseAuth internal constructor(internal val js: Auth) {
         @Suppress("UNCHECKED_CAST")
         return when (result.operation) {
             "EMAIL_SIGNIN" -> ActionCodeResult.SignInWithEmailLink
+
             "VERIFY_EMAIL" -> ActionCodeResult.VerifyEmail(result.data.email!!)
+
             "PASSWORD_RESET" -> ActionCodeResult.PasswordReset(result.data.email!!)
+
             "RECOVER_EMAIL" -> ActionCodeResult.RecoverEmail(result.data.email!!, result.data.previousEmail!!)
+
             "VERIFY_AND_CHANGE_EMAIL" -> ActionCodeResult.VerifyBeforeChangeEmail(
                 result.data.email!!,
                 result.data.previousEmail!!,
             )
+
             "REVERT_SECOND_FACTOR_ADDITION" -> ActionCodeResult.RevertSecondFactorAddition(
                 result.data.email!!,
                 result.data.multiFactorInfo?.let { MultiFactorInfo(it) },
             )
+
             else -> throw UnsupportedOperationException(result.operation)
         } as T
     }
@@ -208,26 +214,39 @@ private inline fun <R> rethrow(function: () -> R): R {
 
 private fun errorToException(cause: dynamic) = when (val code = cause.code?.toString()?.lowercase()) {
     "auth/invalid-user-token" -> FirebaseAuthInvalidUserException(code, cause.unsafeCast<Throwable>())
+
     "auth/requires-recent-login" -> FirebaseAuthRecentLoginRequiredException(code, cause.unsafeCast<Throwable>())
+
     "auth/user-disabled" -> FirebaseAuthInvalidUserException(code, cause.unsafeCast<Throwable>())
+
     "auth/user-token-expired" -> FirebaseAuthInvalidUserException(code, cause.unsafeCast<Throwable>())
+
     "auth/web-storage-unsupported" -> FirebaseAuthWebException(code, cause.unsafeCast<Throwable>())
+
     "auth/network-request-failed" -> FirebaseNetworkException(code, cause.unsafeCast<Throwable>())
+
     "auth/timeout" -> FirebaseNetworkException(code, cause.unsafeCast<Throwable>())
+
     "auth/weak-password" -> FirebaseAuthWeakPasswordException(code, cause.unsafeCast<Throwable>())
+
     "auth/invalid-credential",
     "auth/invalid-verification-code",
     "auth/missing-verification-code",
     "auth/invalid-verification-id",
     "auth/missing-verification-id",
     -> FirebaseAuthInvalidCredentialsException(code, cause.unsafeCast<Throwable>())
+
     "auth/maximum-second-factor-count-exceeded",
     "auth/second-factor-already-in-use",
     -> FirebaseAuthMultiFactorException(code, cause.unsafeCast<Throwable>())
+
     "auth/credential-already-in-use" -> FirebaseAuthUserCollisionException(code, cause.unsafeCast<Throwable>())
+
     "auth/email-already-in-use" -> FirebaseAuthUserCollisionException(code, cause.unsafeCast<Throwable>())
+
     "auth/invalid-email" -> FirebaseAuthEmailException(code, cause.unsafeCast<Throwable>())
-//                "auth/app-deleted" ->
+
+    //                "auth/app-deleted" ->
 //                "auth/app-not-authorized" ->
 //                "auth/argument-error" ->
 //                "auth/invalid-api-key" ->

firebase-auth/src/jvmMain/kotlin/dev/gitlive/firebase/auth/auth.kt

@@ -98,18 +98,25 @@ public actual class FirebaseAuth internal constructor(internal val android: com.
         @Suppress("UNCHECKED_CAST")
         return when (result.operation) {
             SIGN_IN_WITH_EMAIL_LINK -> ActionCodeResult.SignInWithEmailLink
+
             VERIFY_EMAIL -> ActionCodeResult.VerifyEmail(result.info!!.email)
+
             PASSWORD_RESET -> ActionCodeResult.PasswordReset(result.info!!.email)
+
             RECOVER_EMAIL -> (result.info as ActionCodeEmailInfo).run {
                 ActionCodeResult.RecoverEmail(email, previousEmail)
             }
+
             VERIFY_BEFORE_CHANGE_EMAIL -> (result.info as ActionCodeEmailInfo).run {
                 ActionCodeResult.VerifyBeforeChangeEmail(email, previousEmail)
             }
+
             REVERT_SECOND_FACTOR_ADDITION -> (result.info as ActionCodeMultiFactorInfo).run {
                 ActionCodeResult.RevertSecondFactorAddition(email, MultiFactorInfo(multiFactorInfo))
             }
+
             ERROR -> throw UnsupportedOperationException(result.operation.toString())
+
             else -> throw UnsupportedOperationException(result.operation.toString())
         } as T
     }

firebase-common-internal/build.gradle.kts

@@ -155,7 +155,7 @@ kotlin {
         if (supportedPlatforms.contains(TargetPlatform.Js)) {
             getByName("jsMain") {
                 dependencies {
-                    api(npm("firebase", "10.12.2"))
+                    api(npm("firebase", libs.versions.firebase.npm.get()))
                 }
             }
         }

firebase-common-internal/src/androidMain/kotlin/dev/gitlive/firebase/internal/_decoders.kt

@@ -11,6 +11,7 @@ import kotlinx.serialization.encoding.CompositeDecoder
 
 internal actual fun FirebaseDecoderImpl.structureDecoder(descriptor: SerialDescriptor, polymorphicIsNested: Boolean): CompositeDecoder = when (descriptor.kind) {
     StructureKind.CLASS, StructureKind.OBJECT -> decodeAsMap(false)
+
     StructureKind.LIST -> (value as? List<*>).orEmpty().let {
         FirebaseCompositeDecoder(it.size, settings) { _, index -> it[index] }
     }
@@ -23,6 +24,7 @@ internal actual fun FirebaseDecoderImpl.structureDecoder(descriptor: SerialDescr
     }
 
     is PolymorphicKind -> decodeAsMap(polymorphicIsNested)
+
     else -> TODO("The firebase-kotlin-sdk does not support $descriptor for serialization yet")
 }
 

firebase-common-internal/src/androidMain/kotlin/dev/gitlive/firebase/internal/_encoders.kt

@@ -13,10 +13,14 @@ internal actual fun FirebaseEncoderImpl.structureEncoder(descriptor: SerialDescr
     StructureKind.LIST -> mutableListOf<Any?>()
         .also { value = it }
         .let { FirebaseCompositeEncoder(settings) { _, index, value -> it.add(index, value) } }
+
     StructureKind.MAP -> mutableListOf<Any?>()
         .let { FirebaseCompositeEncoder(settings, { value = it.chunked(2).associate { (k, v) -> k to v } }) { _, _, value -> it.add(value) } }
+
     StructureKind.CLASS, StructureKind.OBJECT -> encodeAsMap(descriptor)
+
     is PolymorphicKind -> encodeAsMap(descriptor)
+
     else -> TODO("The firebase-kotlin-sdk does not support $descriptor for serialization yet")
 }
 

firebase-common-internal/src/appleMain/kotlin/dev/gitlive/firebase/internal/_decoders.kt

@@ -12,11 +12,15 @@ import kotlin.collections.get
 
 internal actual fun FirebaseDecoderImpl.structureDecoder(descriptor: SerialDescriptor, polymorphicIsNested: Boolean): CompositeDecoder = when (descriptor.kind) {
     StructureKind.CLASS, StructureKind.OBJECT -> decodeAsMap(false)
+
     StructureKind.LIST -> decodeAsList()
+
     StructureKind.MAP -> (value as? Map<*, *>).orEmpty().entries.toList().let {
         FirebaseCompositeDecoder(it.size, settings) { _, index -> it[index / 2].run { if (index % 2 == 0) key else value } }
     }
+
     is PolymorphicKind -> decodeAsMap(polymorphicIsNested)
+
     else -> TODO("The firebase-kotlin-sdk does not support $descriptor for serialization yet")
 }