shekhar23/claude-zero-to-hero-android-kmp/android-crash-reporting

// build.gradle.kts (:app)
plugins {
    id("com.google.gms.google-services")
    id("com.google.firebase.crashlytics")
}
 
dependencies {
    implementation(platform(libs.firebase.bom))
    implementation(libs.firebase.crashlytics)
}

// build.gradle.kts (:app)
buildTypes {
    debug {
        manifestPlaceholders["crashlyticsEnabled"] = false
    }
    release {
        manifestPlaceholders["crashlyticsEnabled"] = true
    }
}

<!-- AndroidManifest.xml -->
<meta-data
    android:name="firebase_crashlytics_collection_enabled"
    android:value="${crashlyticsEnabled}" />

FirebaseCrashlytics.getInstance()
    .setCrashlyticsCollectionEnabled(!BuildConfig.DEBUG)

// domain layer
interface CrashReporter {
    fun recordException(throwable: Throwable)
    fun log(message: String)
    fun setKey(key: String, value: String)
    fun setUserId(anonymousId: String) // NEVER real name/email
}
 
// data layer
class CrashlyticsReporter : CrashReporter {
    private val c get() = FirebaseCrashlytics.getInstance()
    override fun recordException(t: Throwable) = c.recordException(t)
    override fun log(message: String) = c.log(message)
    override fun setKey(key: String, value: String) = c.setCustomKey(key, value)
    override fun setUserId(anonymousId: String) = c.setUserId(anonymousId)
}

single<CrashReporter> { CrashlyticsReporter() }

class NotesViewModel(
    private val repository: NoteRepository,
    private val crashReporter: CrashReporter,
) : ViewModel() {
 
    fun loadNotes() {
        viewModelScope.launch {
            when (val result = repository.getNotes()) {
                is Result.Success -> { /* update state */ }
                is Result.Error -> {
                    crashReporter.log("loadNotes failed: ${result.error}")
                    crashReporter.recordException(RuntimeException("loadNotes: ${result.error}"))
                    // update error UI state — do not rethrow
                }
            }
        }
    }
}

fun syncNotes() {
    viewModelScope.launch {
        crashReporter.setKey("sync_trigger", "manual")
        crashReporter.setKey("note_count", noteCount.toString())
        crashReporter.log("Starting note sync")
 
        when (val result = repository.sync()) {
            is Result.Error -> crashReporter.recordException(RuntimeException("sync: ${result.error}"))
            is Result.Success -> crashReporter.log("Sync complete")
        }
    }
}

class App : Application() {
    override fun onCreate() {
        super.onCreate()
        if (BuildConfig.DEBUG) {
            StrictMode.setThreadPolicy(
                StrictMode.ThreadPolicy.Builder()
                    .detectAll()
                    .penaltyLog()
                    .penaltyDeath()
                    .build()
            )
            StrictMode.setVmPolicy(
                StrictMode.VmPolicy.Builder()
                    .detectAll()
                    .penaltyLog()
                    .build()
            )
        }
    }
}

class BaseViewModel(private val crashReporter: CrashReporter) : ViewModel() {
 
    protected fun safeLaunch(block: suspend CoroutineScope.() -> Unit): Job =
        viewModelScope.launch(
            CoroutineExceptionHandler { _, throwable ->
                crashReporter.log("Unhandled ViewModel exception: ${throwable.message}")
                crashReporter.recordException(throwable)
            }
        ) { block() }
}