If you have implemented the Google Play In-App Review API before, you already know the rough edges. The official Play Core flow works, but it is task-based, awkward to test, hard to coordinate, and easy to trigger at the wrong time.
ReviewFlow is a small Android library that wraps that experience in a coroutine-first API with explicit rules, observable state, and optional Jetpack Compose support. Instead of wiring ad-hoc checks around the Play Core review flow, you define when review prompts are allowed and let the orchestrator handle the rest.
Android in-app review sounds simple at first: request a ReviewInfo, launch the flow, and let Google Play decide whether to show a dialog.
In practice, there are a few problems:
the API is callback- and Task-oriented rather than coroutine-first
the visible dialog is server-controlled and non-deterministic
apps often need cooldown logic and once-per-version behavior on top
it is easy to spam the flow accidentally from multiple triggers
the integration is not especially pleasant to test
That is the gap ReviewFlow is meant to close.
ReviewFlow is a Kotlin library for Android in-app review orchestration. It keeps the Google Play review flow underneath, but adds a cleaner integration model on top:
coroutine-first API
StateFlow for state and SharedFlow for events
built-in app start, success moment, cooldown, and once-per-version rules
single-flight tryShow(...) behavior under concurrent calls
testable design with fake clocks and fake review clients
optional Jetpack Compose layer for trigger-driven UI flows
The result is less review prompt glue code in your app and a much clearer place to express your product rules.
Add Maven Central to your repositories:
repositories {
google()
mavenCentral()
}
For the core library:
implementation("com.zleptnig:reviewflow-core:0.1.0")
For the Compose integration:
implementation("com.zleptnig:reviewflow-compose:0.1.0")
reviewflow-compose depends on reviewflow-core, so you only need one dependency based on your use case.
Create the orchestrator once and register app starts:
val reviewOrchestrator = ReviewOrchestrator.create(context)
lifecycleScope.launch {
reviewOrchestrator.onAppStart()
}
When the user reaches a meaningful positive action, register that moment:
lifecycleScope.launch {
reviewOrchestrator.onSuccessMoment()
}
Then try to show the review flow:
lifecycleScope.launch {
val launched = reviewOrchestrator.tryShow(activity)
if (!launched) {
// Another call is already running, rules failed, or the request failed.
}
}
By default, ReviewFlow uses these rules:
minimum app starts: 3
minimum success moments: 1
cooldown: 30 days
once per app version: enabled
You can also customize them:
ReviewOrchestrator.create(
context,
rules = ReviewRules(
minAppStarts = 5,
minSuccessMoments = 3,
cooldown = 14.days
)
)
If your trigger comes from Compose state or a one-shot ViewModel event, the optional Compose layer keeps the integration concise:
val orchestrator = rememberReviewOrchestrator()
var trigger by remember { mutableStateOf(false) }
Button(onClick = { trigger = true }) {
Text("Rate app")
}
ReviewEffect(
orchestrator = orchestrator,
trigger = trigger,
onConsumed = { trigger = false }
)
That gives you a recomposition-safe way to launch the review flow once per trigger edge without moving business logic into UI code.
Google Play still controls whether a visible review dialog is shown.
That means a successful tryShow(...) does not guarantee that the user actually saw a dialog. It means the review flow completed successfully from the app's perspective. This distinction matters for analytics, product expectations, and test design.
In other words: ReviewFlow improves the orchestration layer, but it does not bypass Google Play behavior or policy.
I wanted a cleaner way to integrate Android in-app review in Kotlin without scattering timing rules, version checks, and concurrency guards across app code. I also wanted something that felt natural in coroutine- and Flow-based apps, with an optional Compose layer that stays thin.
ReviewFlow is the result: a small library focused on making the Play Core review flow easier to integrate, reason about, and test.
ReviewFlow 0.1.0 is available now on Maven Central as an early public release.
Maven Central:
com.zleptnig:reviewflow-core:0.1.0
com.zleptnig:reviewflow-compose:0.1.0
If you are building an Android app and want a more structured way to handle in-app review prompts, give it a try. Feedback from early adopters is especially useful at this stage.