• 🎯 Cross-platform: Single codebase for Android, iOS & Desktop (JVM)
• 🚀 Easy Integration: Auto-initialization on Android, one-line setup on iOS
• 🔐 Complete Authentication:
  • Email/Password (Sign up & Sign in)
  • Google Sign-In
  • Apple Sign-In (iOS)
  • Anonymous Authentication
  • Facebook Sign-In
• 🔄 Real-time Auth State: Flow-based auth state monitoring
• 🛡️ Type-safe: Kotlin-first API with sealed classes for results
• 🧪 Testable: Includes FakeAuthBackend for unit testing
• 📱 Platform-optimized: Native Firebase SDKs on Android/iOS, REST API on Desktop
• 💎 Production-ready: Published on Maven Central

⚡ Super fast? See QUICKSTART.md (30 seconds)

📖 Detailed setup: See below (2 minutes)

kotlin {
    sourceSets {
        commonMain.dependencies {
            implementation("dev.com3run:firebase-auth-kmp:1.0.3")
        }
    }
}

For JitPack, if you have a jvm("desktop") target, use platform-specific dependencies:

repositories {
    maven("https://jitpack.io")
}

kotlin {
    sourceSets {
        androidMain.dependencies {
            implementation("com.github.com3run.firebase-auth-kmp:firebase-auth-kmp-android:v1.0.3")
        }
        iosMain.dependencies {
            implementation("com.github.com3run.firebase-auth-kmp:firebase-auth-kmp-iosarm64:v1.0.3")
        }
        val desktopMain by getting {
            dependencies {
                implementation("com.github.com3run.firebase-auth-kmp:firebase-auth-kmp-jvm:v1.0.3")
            }
        }
    }
}

Note: JitPack requires platform-specific artifacts for desktopMain source sets. For automatic resolution, use Maven Central instead.

No code needed! Just add your google-services.json file.

❌ OLD: You had to manually set ActivityHolder.current ✅ NEW: Auto-initializes via ContentProvider!

class MainActivity : ComponentActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        // That's it! No Firebase Auth initialization needed! 🎉
        setContent {
            App()
        }
    }
}

1. Copy FirebaseAuthBridge.swift from the library to your iOS app
2. Add to AppDelegate:

import FirebaseCore

class AppDelegate: NSObject, UIApplicationDelegate {
    func application(_ application: UIApplication,
                     didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey : Any]? = nil) -> Bool {
        FirebaseApp.configure()
        FirebaseAuthBridge.shared.start()  // ← ONE LINE!
        return true
    }
}

Get the bridge file →

Create firebase-config.json in your project root:

{
  "apiKey": "YOUR_FIREBASE_API_KEY",
  "projectId": "your-project-id"
}

Find your API key in Firebase Console →

🎯 Want detailed setup? See EASY-INTEGRATION.md

import dev.com3run.firebaseauthkmp.*
import org.koin.core.context.startKoin

// Initialize Koin
startKoin {
    modules(module {
        single<AuthBackend> { platformAuthBackend() }
        single { AuthRepository(get()) }
    })
}

// Use auth repository
val authRepository = get<AuthRepository>()

// Monitor auth state
authRepository.authState.collect { user ->
    if (user != null) {
        println("Signed in: ${user.email}")
    } else {
        println("Signed out")
    }
}

val result = authRepository.signInWithEmailAndPassword(
    email = "user@example.com",
    password = "password123"
)

when (result) {
    is AuthResult.Success -> println("Welcome ${result.data.displayName}!")
    is AuthResult.Failure -> when (result.error) {
        AuthError.InvalidCredential -> println("Wrong email or password")
        AuthError.UserNotFound -> println("No account found")
        else -> println("Error: ${result.error}")
    }
}

// Request ID token (platform-specific UI flow)
val idToken = requestGoogleIdToken()

if (idToken != null) {
    val result = authRepository.signInWithGoogle(idToken)
    when (result) {
        is AuthResult.Success -> println("Google sign-in successful!")
        is AuthResult.Failure -> println("Error: ${result.error}")
    }
}

val result = authRepository.signInAnonymously()

when (result) {
    is AuthResult.Success -> println("Signed in as guest!")
    is AuthResult.Failure -> println("Error: ${result.error}")
}

authRepository.signOut()

• 🚀 Easy Integration Guide - 5-minute setup for all platforms
• 📘 Library Integration Guide - Detailed setup instructions
• 📖 Usage Examples - More code examples

• 🤖 Android Setup - Auto-initialization details
• 🍎 iOS Setup - Bridge configuration
• 💻 Desktop Setup - JVM configuration & limitations

• 🔧 Troubleshooting - Common issues and solutions
• 🏗️ Architecture - Clean architecture design
• 👨‍💻 Coding Guidelines - Best practices
• 🔄 Migration Guide - Upgrading from v1.0.0/1.0.1

The library follows clean architecture principles:

┌─────────────────────────────────────┐
│      AuthRepository                 │  ← Validation + High-level API
└──────────────┬──────────────────────┘
               │
               ▼
┌─────────────────────────────────────┐
│      AuthBackend (Interface)        │  ← Platform-agnostic contract
└──────────────┬──────────────────────┘
               │
       ┌───────┴────────┬─────────────┐
       ▼                ▼              ▼
┌──────────────┐  ┌─────────────┐  ┌──────────────┐
│  Android     │  │     iOS     │  │   Desktop    │
│  Firebase    │  │  Firebase   │  │  Firebase    │
│  SDK         │  │  Bridge     │  │  REST API    │
└──────────────┘  └─────────────┘  └──────────────┘

• AuthRepository: High-level API with input validation
• AuthBackend: Platform-specific interface (Android/iOS/Desktop)
• AuthModels: Common data models (AuthUser, AuthResult, AuthError)

The library includes FakeAuthBackend for unit testing:

import dev.com3run.firebaseauthkmp.FakeAuthBackend
import dev.com3run.firebaseauthkmp.AuthRepository

@Test
fun `test sign in success`() = runTest {
    val fakeBackend = FakeAuthBackend()
    val authRepository = AuthRepository(fakeBackend)

    fakeBackend.setAuthResult(AuthResult.Success(testUser))

    val result = authRepository.signInWithEmailAndPassword("test@example.com", "password")

    assertTrue(result is AuthResult.Success)
}

This repository includes a complete sample app demonstrating all authentication methods:

• ✅ Email/Password authentication
• ✅ Google Sign-In
• ✅ Apple Sign-In (iOS)
• ✅ Anonymous authentication
• ✅ Profile management
• ✅ Password reset

Run the composeApp module to see it in action!

• Kotlin 2.0+
• Android API 24+ (Android 7.0)
• iOS 13.0+
• JVM 11+ (Desktop)
• Firebase project with Authentication enabled

• ✨ Desktop/JVM support - Run on Windows, macOS, Linux
• 🚀 Android auto-initialization - Zero manual setup required!
• 📱 Simplified iOS setup - Ready-to-use bridge template
• 📚 Easy Integration Guide - Get started in 2 minutes
• 🔧 Better error messages - Clear, actionable feedback

See full changelog →

Contributions are welcome! Please feel free to submit a Pull Request.

1. Fork the repository
2. Create your feature branch (git checkout -b feature/amazing-feature)
3. Commit your changes (git commit -m 'Add amazing feature')
4. Push to the branch (git push origin feature/amazing-feature)
5. Open a Pull Request

This project is licensed under the MIT License - see the LICENSE file for details.

• 📦 Maven Central
• 📚 Full Documentation
• 🐛 Report Issues
• ⭐ Star on GitHub
• 💬 Discussions

Created by Kamran Mammadov

Special thanks to all contributors!

Made with ❤️ using Kotlin Multiplatform

⭐ If you find this library helpful, please star the repo!