Quickstart: Android (Jetpack Compose)

dependencies {
    implementation("in.sovaria:sovaria:1.0.0")
    implementation("androidx.security:security-crypto:1.1.0-alpha06")
    implementation("androidx.lifecycle:lifecycle-viewmodel-compose:2.8.7")
}

import android.content.Context
import androidx.security.crypto.EncryptedSharedPreferences
import androidx.security.crypto.MasterKey
import `in`.sovaria.SessionStorage

class KeystoreStore(context: Context) : SessionStorage {
    private val prefs = EncryptedSharedPreferences.create(
        context, "sovaria",
        MasterKey.Builder(context).setKeyScheme(MasterKey.KeyScheme.AES256_GCM).build(),
        EncryptedSharedPreferences.PrefKeyEncryptionScheme.AES256_SIV,
        EncryptedSharedPreferences.PrefValueEncryptionScheme.AES256_GCM,
    )
    override suspend fun read(key: String): String? = prefs.getString(key, null)
    override suspend fun write(key: String, value: String) { prefs.edit().putString(key, value).apply() }
    override suspend fun delete(key: String) { prefs.edit().remove(key).apply() }
}

import android.app.Application
import androidx.lifecycle.AndroidViewModel
import androidx.lifecycle.viewModelScope
import `in`.sovaria.*
import kotlinx.coroutines.flow.MutableStateFlow
import kotlinx.coroutines.launch

class NotesViewModel(app: Application) : AndroidViewModel(app) {
    val signedIn = MutableStateFlow(false)
    val notes = MutableStateFlow<List<Map<String, Any?>>>(emptyList())
    val error = MutableStateFlow("")
    private lateinit var sovaria: Sovaria

    init {
        viewModelScope.launch {
            // Restores the saved session (refreshing it if it's about to expire).
            sovaria = Sovaria.initialize(
                url = "https://<project-ref>.sovarias.in",
                anonKey = "<anon-key>",
                storage = KeystoreStore(app),
            )
            sovaria.auth.changes.collect { state ->      // first event: INITIAL_SESSION
                signedIn.value = state.session != null
                if (signedIn.value) load()
            }
        }
    }

    private fun run(block: suspend () -> Unit) = viewModelScope.launch {
        try { block() } catch (e: SovariaException) { error.value = e.message }
    }

    fun signIn(email: String, password: String, create: Boolean) = run {
        if (create) sovaria.auth.signUp(email, password) else sovaria.auth.signInWithPassword(email, password)
    }

    // Rows come back keyed by column name. The row rules add "where owner_id = auth.uid()".
    private suspend fun load() { notes.value = sovaria.db.sql("select id, body from notes order by id desc").rows }

    fun add(body: String) = run {
        sovaria.db.sql("insert into notes (body) values (\$1)", listOf(body))
        load()
    }

    fun signOut() = run { sovaria.auth.signOut() }
}

import android.os.Bundle
import androidx.activity.ComponentActivity
import androidx.activity.compose.setContent
import androidx.compose.foundation.layout.*
import androidx.compose.foundation.lazy.LazyColumn
import androidx.compose.foundation.lazy.items
import androidx.compose.material3.*
import androidx.compose.runtime.*
import androidx.compose.ui.Modifier
import androidx.compose.ui.text.input.PasswordVisualTransformation
import androidx.compose.ui.unit.dp
import androidx.lifecycle.viewmodel.compose.viewModel

class MainActivity : ComponentActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContent { MaterialTheme { NotesScreen() } }
    }
}

@Composable
fun NotesScreen(vm: NotesViewModel = viewModel()) {
    val signedIn by vm.signedIn.collectAsState()
    val notes by vm.notes.collectAsState()
    val error by vm.error.collectAsState()
    var email by remember { mutableStateOf("") }
    var password by remember { mutableStateOf("") }
    var body by remember { mutableStateOf("") }

    Column(Modifier.padding(24.dp), verticalArrangement = Arrangement.spacedBy(8.dp)) {
        if (!signedIn) {
            OutlinedTextField(email, { email = it }, label = { Text("Email") })
            OutlinedTextField(password, { password = it }, label = { Text("Password") },
                visualTransformation = PasswordVisualTransformation())
            Button({ vm.signIn(email, password, create = false) }) { Text("Sign in") }
            TextButton({ vm.signIn(email, password, create = true) }) { Text("Create account") }
        } else {
            Row {
                OutlinedTextField(body, { body = it }, Modifier.weight(1f), placeholder = { Text("Write a note") })
                Button({ vm.add(body); body = "" }) { Text("Add") }
            }
            LazyColumn(Modifier.weight(1f)) { items(notes) { Text(it["body"]?.toString() ?: "") } }
            TextButton({ vm.signOut() }) { Text("Sign out") }
        }
        if (error.isNotEmpty()) Text(error, color = MaterialTheme.colorScheme.error)
    }
}