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.

Why the default Play Core review flow is awkward

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.

What ReviewFlow does

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.

Install from Maven Central

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.

Basic usage in Kotlin

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

    )

)

Jetpack Compose integration

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.

Important runtime caveat

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.

Why I built it

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.

Try ReviewFlow

ReviewFlow 0.1.0 is available now on Maven Central as an early public release.

• GitHub: https://github.com/klemensz/android-review-flow 

• 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.

I appreciate your feedback, e.g. via X or here in the comments - all further contact information can be found here.