Android SDK

Add the repository and dependency #

The SDK publishes to a private Maven repository, so Gradle needs a credential before it can resolve anything. Moov supplies a dedicated GitHub account for your team.

Sign in to the GitHub account Moov gave you and create a personal access token with the read:packages scope. Keep it out of version control: put it in your user-level ~/.gradle/gradle.properties:

moovGitHubUsername=your-github-username
moovGitHubToken=your-personal-access-token

Then declare the repository in settings.gradle.kts:

dependencyResolutionManagement {
    repositories {
        google()
        mavenCentral()
        maven {
            url = uri("https://maven.pkg.github.com/moov-sdk/moov-money-android")
            credentials {
                username = providers.gradleProperty("moovGitHubUsername")
                    .orElse(providers.environmentVariable("MOOV_GITHUB_USERNAME")).get()
                password = providers.gradleProperty("moovGitHubToken")
                    .orElse(providers.environmentVariable("MOOV_GITHUB_TOKEN")).get()
            }
        }
    }
}

The environment variable fallback is there for CI, where no user-level gradle.properties exists. Set MOOV_GITHUB_USERNAME and MOOV_GITHUB_TOKEN as secrets on your build.

Add the dependency in your app’s build.gradle.kts:

dependencies {
    implementation("io.moov:moov-money-android:0.1.0-alpha02")
}

Pin the exact version. The SDK is pre-1.0, so releases can contain breaking changes, and pinning keeps an upgrade a deliberate act.

The SDK ships consumer ProGuard rules, so no additional R8 configuration is needed.

Declare permissions #

The SDK doesn’t declare the permissions it needs at runtime. Add them to your app’s AndroidManifest.xml:

<uses-permission android:name="android.permission.INTERNET" />
<uses-permission android:name="android.permission.READ_CONTACTS" />
<uses-permission android:name="android.permission.READ_PHONE_STATE" />
<uses-permission android:name="android.permission.USE_BIOMETRIC" />
<uses-permission android:name="android.permission.USE_FINGERPRINT" />

These are yours to declare rather than the SDK’s because several are install-time permissions that appear in your Play Store listing. That’s a disclosure about your app, so it shouldn’t arrive silently through a dependency. You only declare them; the SDK requests the runtime ones itself when the flow reaches the screen that needs them.

Mint a session token #

The SDK authenticates with a short-lived token minted by your backend for the currently signed-in user, supplied per invocation. Your session model stays the authority on who can send or request. See sender authentication for how to mint it.

// Your backend endpoint exchanges your session for a Moov Money token.
val sessionToken = myBackend.fetchMoovSessionToken()

There’s no environment switch to configure. The SDK reads the token’s audience claim and routes to the matching environment, so pointing at staging instead of production is just a matter of minting a token there.

Build the SDK instance #

Construct MoovMoney once, in your Application class or a DI module, passing your Application to the builder:

val moovMoney = MoovMoney.Builder(application)
    .configuration(
        MoovMoneyConfiguration(
            lightColors = MoovMoneyColors(primary = BrandBlue, background = Color.White),
            darkColors = MoovMoneyColors(primary = BrandBlueDark, background = Color.Black),
        )
    )
    .logger { priority, tag, message, throwable ->
        Timber.tag(tag).log(priority, throwable, message)
    }
    .build()

Both configuration and logger are optional. Omit the configuration and the SDK uses its own brand palette; omit the logger and nothing is surfaced to you. Supply the logger; see Diagnostics below.

Launch the flow #

Start the flow with the token you minted:

moovMoney.startPayout(token = sessionToken)

This launches a full-screen, portrait-locked activity covering recipient selection, amount entry, and confirmation. It’s self-contained: participant identity and the user’s eligible funding methods (the ones you registered against the participant) are both resolved server-side from the token, so you don’t need to make any FI-specific calls to drive it.

startPayout returns immediately and reports nothing back. The activity closes itself when the user finishes or backs out, and there’s no completion result delivered to your app.