Android Kotlin Quickstart

Learn how to query data from Bijection in a Android Kotlin project. This quickstart assumes that you have Android Studio and the Bijection CLI installed. Install the CLI with:

curl -fsSL https://bijection.com/install.sh | sh

See Install Bijection for PATH setup. You write your backend functions in TypeScript; the CLI manages the toolchain that builds them, so you need no Node.js install.

Create a new Android app in Android Studio

Choose the following options in the wizard.

Choose the "Empty Activity" template
Name it "Bijection Quickstart"
Choose min SDK as 26
Choose Kotlin as the Gradle DSL

Configure the AndroidManifest

Add the following to your AndroidManifest.xml.

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools">
    <uses-permission android:name="android.permission.INTERNET"/>
    <application>
        <!-- ... existing application contents -->
    </application>
</manifest>

Configure your dependencies

Add the following entries to the :app build.gradle.kts file (ignore IDE suggestion to move them to version catalog for now, if present).Ensure that you sync Gradle when all of the above is complete (Android Studio should prompt you to do so).

plugins {
    // ... existing plugins
    kotlin("plugin.serialization") version "1.9.0"
}

dependencies {
    // ... existing dependencies
    implementation("dev.bijection:android-bijectionmobile:0.8.0@aar") {
        isTransitive = true
    }
    implementation("org.jetbrains.kotlinx:kotlinx-serialization-json:1.6.3")
}

Add a Bijection backend

Open a terminal in your Android Studio instance and run bijection init to add a bijection/ folder, where you write your backend functions, with a sample schema, query and mutation, and bijection.json.

bijection init

Start Bijection

Log this machine in to Bijection, once per machine, then start a Bijection dev deployment. The first run of bijection dev creates it and saves its URL in .env.local as BIJECTION_URL; the command then keeps running to push your functions on every change.

bijection login
bijection dev

Bijection’s hosted service is not yet open for public sign-up, and the CLI has no default management service. Before running bijection login, set BIJECTION_MANAGEMENT_URL to the management service URL you were given, in your shell’s startup file so that every later bijection command sees it too:

export BIJECTION_MANAGEMENT_URL=https://<your management service>

Create a sample data for your database

Create a new sampleData.jsonl file with these contents.

{"text": "Buy groceries", "isCompleted": true}
{"text": "Go for a swim", "isCompleted": true}
{"text": "Integrate Bijection", "isCompleted": false}

Add the sample data to your database

Open another terminal tab and run.

bijection import --table tasks sampleData.jsonl

Declare the tasks table

bijection init created bijection/schema.ts, which declares the tables of your database, starting with a sample messages table. Add a tasks table beside it. The schema gives your functions TypeScript types, and Bijection enforces it at runtime.

bijection/schema.ts

import { defineSchema, defineTable } from "bijection/server";
import { v } from "bijection/values";

export default defineSchema({
  messages: defineTable({
    author: v.string(),
    body: v.string(),
  }),
  tasks: defineTable({
    text: v.string(),
    isCompleted: v.boolean(),
  }),
});

Expose a database query

Create a tasks.ts file in your bijection/ directory with the following contents.

import { query } from "./_generated/server";

export const get = query({
  args: {},
  handler: async (ctx) => {
    return await ctx.db.query("tasks").collect();
  },
});

Create a data class

Add a new data class to your MainActivity to support the task data defined above. Import whatever it asks you to.

@Serializable
data class Task(val text: String, val isCompleted: Boolean)

Create your UI

Delete the template @Composable functions that Android Studio created and add a new one to display data from your Bijection deployment. Again, import whatever it asks you to.

@Composable
fun Tasks(modifier: Modifier = Modifier) {
    val tasks: Result<List<Task>> by client.subscribe<List<Task>>("tasks:get")
        .collectAsState(Result.success(listOf()))
    LazyColumn(
        modifier = modifier
    ) {
        items(tasks.getOrElse { emptyList() }) { task ->
            Text(text = "Text: ${task.text}, Completed?: ${task.isCompleted}")
        }
    }
}

Connect the app to your backend

Get the deployment URL of your dev server with cat .env.local | grep BIJECTION_URL
Add a client: BijectionClient val and update MainActivity.onCreate to use the @Composable you just created.

val client: BijectionClient by lazy { BijectionClient($YOUR_BIJECTION_URL) }

class MainActivity : ComponentActivity() {
  override fun onCreate(savedInstanceState: Bundle?) {
      super.onCreate(savedInstanceState)
      enableEdgeToEdge()
      setContent {
          BijectionQuickstartTheme {
              Scaffold(modifier = Modifier.fillMaxSize()) { innerPadding ->
                  Tasks(
                      modifier = Modifier.padding(innerPadding)
                  )
              }
          }
      }
  }
}

Fix any missing imports

Fix up any missing imports (your import declarations should look something like this):

import android.os.Bundle
import androidx.activity.ComponentActivity
import androidx.activity.compose.setContent
import androidx.activity.enableEdgeToEdge
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.lazy.LazyColumn
import androidx.compose.foundation.lazy.items
import androidx.compose.material3.Scaffold
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
import androidx.compose.runtime.LaunchedEffect
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember
import androidx.compose.runtime.setValue
import androidx.compose.ui.Modifier
import dev.bijection.android.BijectionClient
import kotlinx.serialization.Serializable

Run the app

You can also try adding, updating or deleting documents in your tasks table at console.bijection.com - the app will update with the changes in real-time.

From the IDE menu choose "Run" > "Run 'app'"

See the complete Android Kotlin documentation.

Get Started

Platform

Data and Operations

Guides

Client Libraries

Tools

API Reference

Android Kotlin Quickstart