Osama Raddad

FireCrasher replaces Android’s main-thread message loop with one that dispatches each message inside a try/catch. When something throws, your onCrash handler gets the exception first, so crash reporting still works, and then the library recovers in steps. The main-loop interception is adapted from SafeLooper (mmin18, 2013); the recovery ladder, back-stack tracking and handler API are FireCrasher’s own. I started it in 2016 and moved most of it to Kotlin in 2019. It was modernized, and made fully Kotlin, in 2026.

• Recovery ladder: the first two crashes restart the activity. The third goes back if there is a screen behind it, and relaunches the app from its launcher activity if there isn’t.
• On API 30+, the recovery level and retry count are saved with the process (a 5-byte state summary). If the process dies mid-recovery and the app relaunches within 30 seconds, the next crash picks up the ladder where it left off. (On master.)
• Native crashes and ANRs kill the process before any handler runs. On API 30+, FireCrasher reads the system’s exit record on the next launch and passes it to onPreviousProcessExit { }. context.lastAbnormalExit() and context.historicalExitReasons() query the same records on demand. (On master.)
• The public API is locked down with Kotlin explicit-API mode and a committed binary-compatibility baseline, both checked on every CI build. 34 JUnit and Robolectric tests. (On master.)
• 7 merged pull requests from 5 outside contributors, 2016 to 2022.

installFireCrasher {
    onCrash {
        FirebaseCrashlytics.getInstance().recordException(throwable)   // or Sentry, Bugsnag, …
        recover()
    }
}

repositories { maven { url 'https://jitpack.io' } }

dependencies {
    implementation 'com.github.osama-raddad:FireCrasher:2.0.0'
}

Warehouse wires dependencies with nested warehouse { module { factory { } } } blocks and hands them out through property delegation (by mainDI()). A warehouse can include other warehouses, and its accessibility level (OPEN, LOCAL or ISOLATED) decides which bindings pass up to the warehouse that includes it. Each factory can be named, exposed as an interface, and limited to the classes allowed to receive it. It runs on the JVM.

• injectsIn { Demo::class } limits who can receive a binding. Injecting it anywhere else fails with an error that names both classes.
• @Named picks between bindings of the same type, and constructor parameters resolve from the graph with param() or param(name).
• Three creation patterns: NEW, SINGLETON and REUSABLE.
• Tests with JaCoCo coverage, Detekt and Dokka API docs were set up in GitHub Actions in 2022.

val mainDI = warehouse(Accessibility.LOCAL) {
    warehouse { namesDI }
    module {
        factory {
            name { "GoodPerson" }
            constructor { GoodPerson(param(FIRST_NAME), param(LAST_NAME)) }
            injectsIn { Demo::class }
            contract { Person::class }
        }
    }
}

class Demo {
    @Named("GoodPerson")
    private val goodPerson: Person by mainDI()
}

repositories { maven { url 'https://jitpack.io' } }

dependencies {
    implementation 'com.github.osama-raddad:Warehouse:1.6.8x'
}

A Holdfast store holds state, and its unit of consistency is the transaction. Inside action { } mutations are buffered and observers only see committed values. If the block throws, the whole action rolls back and nothing leaks. atomic(a, b) { } stretches that guarantee across stores: they all commit, or none of them do.

It grew out of Vault (December 2024), a JVM Kotlin state container on my own GitHub where action { } blocks already rolled back on an exception.

• action { } returns TransactionResult.Success or TransactionResult.Error. A failed transaction rolls back and its observers never fire.
• atomic() and suspendAtomic() run an in-memory two-phase commit across stores, taking locks in one global order so frames can’t deadlock each other.
• The frame is enforced: writing to a store you didn’t enroll throws, so it can’t commit on its own.
• Separate modules for coroutines (Flow and StateFlow adapters, suspendAction), Compose (collectAsState) and tests (storeTest { }).
• CI runs the tests on JVM, Android (host tests) and the iOS simulator. The wasmJs target is experimental.

Install: Not yet published

val transfer = atomic(accountA, accountB) {
    accountA.action { balance update { it - 30 } }
    accountB.action { balance update { it + 30 } }
    "transferred"
}