Use snake_case in UDL

uniffi automatically converts to camelCase for Kotlin,
but it won't convert to snake_case for Rust.

.idea/codeStyles/Project.xml

@@ -1,6 +1,7 @@
 <component name="ProjectCodeStyleConfiguration">
   <code_scheme name="Project" version="173">
     <JetCodeStyleSettings>
+      <option name="ALLOW_TRAILING_COMMA" value="true" />
       <option name="CODE_STYLE_DEFAULTS" value="KOTLIN_OFFICIAL" />
     </JetCodeStyleSettings>
     <codeStyleSettings language="XML">

app/build.gradle

@@ -57,6 +57,7 @@ dependencies {
     implementation "androidx.compose.ui:ui-tooling-preview:$compose_ui_version"
     implementation 'androidx.compose.material:material:1.2.1'
     implementation "androidx.navigation:navigation-compose:2.5.2"
+    implementation "net.java.dev.jna:jna:5.12.0@aar"
     testImplementation 'junit:junit:4.13.2'
     androidTestImplementation 'androidx.test.ext:junit:1.1.3'
     androidTestImplementation 'androidx.test.espresso:espresso-core:3.4.0'
@@ -68,7 +69,7 @@ dependencies {
 // See https://github.com/mozilla/rust-android-gradle for other targets and required toolchains
 cargo {
     module = "../native"
-    libname = "talaria"
+    libname = "uniffi_talaria"
     targets = ["arm64"]
     profile = 'release'
 }
@@ -78,3 +79,14 @@ tasks.whenTaskAdded { task ->
         task.dependsOn 'cargoBuild'
     }
 }
+
+// See https://mozilla.github.io/uniffi-rs/kotlin/gradle.html for more details on this snippet
+android.applicationVariants.all { variant ->
+    def t = tasks.register("generate${variant.name.capitalize()}UniFFIBindings", Exec) {
+        workingDir "${project.projectDir}"
+        commandLine 'uniffi-bindgen', 'generate', '../native/src/talaria.udl', '--language', 'kotlin', '--no-format', '--out-dir', "${buildDir}/generated/source/uniffi/${variant.name}/java"
+    }
+    variant.javaCompileProvider.get().dependsOn(t)
+    def sourceSet = variant.sourceSets.find { it.name == variant.name }
+    sourceSet.java.srcDir new File(buildDir, "generated/source/uniffi/${variant.name}/java")
+}

app/src/main/java/dev/lonami/talaria/MainActivity.kt

@@ -7,8 +7,9 @@ import androidx.compose.foundation.layout.fillMaxSize
 import androidx.compose.material.MaterialTheme
 import androidx.compose.material.Surface
 import androidx.compose.ui.Modifier
-import dev.lonami.talaria.bindings.Native
 import dev.lonami.talaria.ui.theme.TalariaTheme
+import uniffi.talaria.initClient
+import uniffi.talaria.initDatabase
 
 class MainActivity : ComponentActivity() {
     override fun onCreate(savedInstanceState: Bundle?) {
@@ -24,7 +25,7 @@ class MainActivity : ComponentActivity() {
             }
         }
 
-        Native.initDatabase(getDatabasePath("talaria.db").path)
-        Native.initClient()
+        initDatabase(getDatabasePath("talaria.db").path)
+        initClient()
     }
 }

app/src/main/java/dev/lonami/talaria/TalariaApp.kt

@@ -18,11 +18,11 @@ import androidx.navigation.compose.NavHost
 import androidx.navigation.compose.composable
 import androidx.navigation.compose.currentBackStackEntryAsState
 import androidx.navigation.compose.rememberNavController
-import dev.lonami.talaria.bindings.Native
 import dev.lonami.talaria.ui.screens.ChatScreen
 import dev.lonami.talaria.ui.screens.DialogScreen
 import dev.lonami.talaria.ui.screens.LoginScreen
 import kotlinx.coroutines.launch
+import uniffi.talaria.needLogin
 
 enum class TalariaScreen(@StringRes val title: Int) {
     Login(title = R.string.app_name),
@@ -148,7 +148,7 @@ fun TalariaApp(modifier: Modifier = Modifier) {
     val currentScreen =
         TalariaScreen.valueOf(backStackEntry?.destination?.route ?: TalariaScreen.Login.name)
 
-    val loggedIn by remember { mutableStateOf(!Native.needLogin()) }
+    val loggedIn by remember { mutableStateOf(!needLogin()) }
     var selectedDialog by remember { mutableStateOf("") }
 
     val drawerState = rememberDrawerState(DrawerValue.Closed)

app/src/main/java/dev/lonami/talaria/bindings/Native.kt

@@ -1,24 +0,0 @@
-package dev.lonami.talaria.bindings
-
-object Native {
-    init {
-        System.loadLibrary("talaria")
-    }
-
-    external fun initDatabase(path: String)
-    external fun initClient()
-    external fun needLogin(): Boolean
-    external fun requestLoginCode(phone: String): Long
-    external fun signIn(tokenPtr: Long, code: String)
-    external fun getDialogs(): Long
-    external fun dialogCount(dialogsPtr: Long): Int
-    external fun dialogPacked(dialogsPtr: Long, index: Int): String
-    external fun dialogTitle(dialogsPtr: Long, index: Int): String
-    external fun dialogSender(dialogsPtr: Long, index: Int): String
-    external fun dialogText(dialogsPtr: Long, index: Int): String
-    external fun dialogTime(dialogsPtr: Long, index: Int): String
-    external fun dialogAck(dialogsPtr: Long, index: Int): Int
-    external fun dialogPin(dialogsPtr: Long, index: Int): Int
-    external fun freeDialogs(dialogsPtr: Long)
-    external fun sendMessage(packed: String, text: String)
-}

app/src/main/java/dev/lonami/talaria/data/DialogRepository.kt

@@ -1,11 +1,10 @@
 package dev.lonami.talaria.data
 
-import dev.lonami.talaria.bindings.Native
-import dev.lonami.talaria.models.Dialog
-import dev.lonami.talaria.models.MessageAck
-import dev.lonami.talaria.models.MessagePreview
-import java.time.LocalDateTime
-import java.time.format.DateTimeFormatter
+import uniffi.talaria.Dialog
+import uniffi.talaria.MessageAck
+import uniffi.talaria.MessagePreview
+import uniffi.talaria.getDialogs
+import java.time.Instant
 
 interface DialogRepository {
     fun loadDialogs(): List<Dialog>
@@ -13,39 +12,7 @@ interface DialogRepository {
 
 class NativeDialogRepository : DialogRepository {
     override fun loadDialogs(): List<Dialog> {
-        val dialogs = mutableListOf<Dialog>()
-
-        val dialogPtr = Native.getDialogs()
-        try {
-            val dialogCount = Native.dialogCount(dialogPtr)
-            for (i in 0 until dialogCount) {
-                dialogs.add(
-                    Dialog(
-                        id = Native.dialogPacked(dialogPtr, i),
-                        title = Native.dialogTitle(dialogPtr, i),
-                        lastMessage = MessagePreview(
-                            sender = Native.dialogSender(dialogPtr, i),
-                            text = Native.dialogText(dialogPtr, i),
-                            date = LocalDateTime.parse(
-                                Native.dialogTime(dialogPtr, i),
-                                DateTimeFormatter.ISO_OFFSET_DATE_TIME
-                            ),
-                            ack = when (Native.dialogAck(dialogPtr, i)) {
-                                0 -> MessageAck.RECEIVED
-                                1 -> MessageAck.SENT
-                                2 -> MessageAck.SEEN
-                                else -> MessageAck.RECEIVED
-                            }
-                        ),
-                        pinned = Native.dialogPin(dialogPtr, i) != 0
-                    )
-                )
-            }
-        } finally {
-            Native.freeDialogs(dialogPtr)
-        }
-
-        return dialogs
+        return getDialogs()
     }
 }
 
@@ -71,7 +38,7 @@ class MockDialogRepository : DialogRepository {
                             } else {
                                 "Sample Message $i"
                             },
-                            date = LocalDateTime.now(),
+                            date = Instant.now(),
                             ack = when (i % 3) {
                                 0 -> MessageAck.RECEIVED
                                 1 -> MessageAck.SENT

app/src/main/java/dev/lonami/talaria/models/Dialog.kt

@@ -1,8 +0,0 @@
-package dev.lonami.talaria.models
-
-data class Dialog(
-    val id: String,
-    val title: String,
-    val lastMessage: MessagePreview?,
-    val pinned: Boolean
-)

app/src/main/java/dev/lonami/talaria/models/MessageAck.kt

@@ -1,7 +0,0 @@
-package dev.lonami.talaria.models
-
-enum class MessageAck {
-    RECEIVED,
-    SENT,
-    SEEN,
-}

app/src/main/java/dev/lonami/talaria/models/MessagePreview.kt

@@ -1,10 +0,0 @@
-package dev.lonami.talaria.models
-
-import java.time.LocalDateTime
-
-data class MessagePreview(
-    val sender: String,
-    val text: String,
-    val date: LocalDateTime,
-    val ack: MessageAck
-)

app/src/main/java/dev/lonami/talaria/ui/screens/DialogScreen.kt

@@ -23,10 +23,12 @@ import androidx.compose.ui.unit.dp
 import androidx.lifecycle.viewmodel.compose.viewModel
 import dev.lonami.talaria.R
 import dev.lonami.talaria.data.MockDialogRepository
-import dev.lonami.talaria.models.Dialog
-import dev.lonami.talaria.models.MessageAck
 import dev.lonami.talaria.ui.state.DialogViewModel
 import dev.lonami.talaria.ui.theme.TalariaTheme
+import uniffi.talaria.Dialog
+import uniffi.talaria.MessageAck
+import java.time.LocalDateTime
+import java.time.ZoneOffset
 import java.time.format.DateTimeFormatter
 import java.time.format.FormatStyle
 
@@ -54,8 +56,8 @@ fun Dialog(dialog: Dialog, onDialogSelected: () -> Unit, modifier: Modifier = Mo
                 Text(
                     stringResource(
                         R.string.message_preview,
-                        dialog.lastMessage.sender,
-                        dialog.lastMessage.text
+                        dialog.lastMessage!!.sender,
+                        dialog.lastMessage!!.text
                     ),
                     maxLines = 1,
                     overflow = TextOverflow.Ellipsis,
@@ -65,7 +67,7 @@ fun Dialog(dialog: Dialog, onDialogSelected: () -> Unit, modifier: Modifier = Mo
         Column {
             if (dialog.lastMessage != null) {
                 Row {
-                    when (dialog.lastMessage.ack) {
+                    when (dialog.lastMessage!!.ack) {
                         MessageAck.RECEIVED -> {}
                         MessageAck.SENT -> Icon(
                             painterResource(R.drawable.sent),
@@ -78,7 +80,7 @@ fun Dialog(dialog: Dialog, onDialogSelected: () -> Unit, modifier: Modifier = Mo
                     }
                     Spacer(Modifier.width(8.dp))
                     Text(
-                        dialog.lastMessage.date.format(
+                        LocalDateTime.ofInstant(dialog.lastMessage!!.date, ZoneOffset.UTC).format(
                             DateTimeFormatter.ofLocalizedTime(
                                 FormatStyle.SHORT
                             )

app/src/main/java/dev/lonami/talaria/ui/screens/LoginScreen.kt

@@ -18,8 +18,9 @@ import androidx.compose.ui.tooling.preview.Preview
 import androidx.compose.ui.unit.dp
 import androidx.compose.ui.unit.sp
 import dev.lonami.talaria.R
-import dev.lonami.talaria.bindings.Native
 import dev.lonami.talaria.ui.theme.TalariaTheme
+import uniffi.talaria.requestLoginCode
+import uniffi.talaria.signIn
 
 enum class LoginStage {
     ASK_PHONE,
@@ -105,7 +106,7 @@ fun LoginScreen(onConfirmOtp: () -> Unit, modifier: Modifier = Modifier) {
     var phone by remember { mutableStateOf("") }
     var otp by remember { mutableStateOf("") }
 
-    var tokenPtr by remember { mutableStateOf(0L) }
+    var tokenPtr by remember { mutableStateOf(0UL) }
 
     Column(
         modifier = modifier
@@ -127,7 +128,7 @@ fun LoginScreen(onConfirmOtp: () -> Unit, modifier: Modifier = Modifier) {
                 phone,
                 onPhoneChanged = { phone = it },
                 onSendCode = {
-                    tokenPtr = Native.requestLoginCode(phone)
+                    tokenPtr = requestLoginCode(phone)
                     stage = LoginStage.ASK_CODE
                 }
             )
@@ -135,7 +136,7 @@ fun LoginScreen(onConfirmOtp: () -> Unit, modifier: Modifier = Modifier) {
                 otp,
                 onOtpChanged = { otp = it },
                 onConfirmOtp = {
-                    Native.signIn(tokenPtr, otp)
+                    signIn(tokenPtr, otp)
                     onConfirmOtp()
                 }
             )

app/src/main/java/dev/lonami/talaria/ui/state/ChatViewModel.kt

@@ -1,7 +1,6 @@
 package dev.lonami.talaria.ui.state
 
 import androidx.lifecycle.ViewModel
-import dev.lonami.talaria.bindings.Native
 import dev.lonami.talaria.data.MessageRepository
 import dev.lonami.talaria.models.Message
 import kotlinx.coroutines.flow.MutableStateFlow
@@ -18,7 +17,7 @@ class ChatViewModel : ViewModel() {
     }
 
     fun sendMessage(dialog: String, message: String) {
-        Native.sendMessage(dialog, message)
+        sendMessage(dialog, message)
         _uiState.update { state ->
             state.messages.add(Message("You", message))
             state

app/src/main/java/dev/lonami/talaria/ui/state/DialogUiState.kt

@@ -1,5 +1,5 @@
 package dev.lonami.talaria.ui.state
 
-import dev.lonami.talaria.models.Dialog
+import uniffi.talaria.Dialog
 
 data class DialogUiState(val dialogs: List<Dialog> = listOf())

build.gradle

@@ -4,8 +4,10 @@ buildscript {
     }
 }// Top-level build file where you can add configuration options common to all sub-projects/modules.
 plugins {
-    id 'com.android.application' version '7.3.0' apply false
-    id 'com.android.library' version '7.3.0' apply false
+    // uniffi-recommended Gradle script fails with Android plugin 7.3.1.
+    // See https://github.com/mozilla/uniffi-rs/issues/1386 for details.
+    id 'com.android.application' version '7.2.2' apply false
+    id 'com.android.library' version '7.2.2' apply false
     id 'org.jetbrains.kotlin.android' version '1.6.10' apply false
     id "org.mozilla.rust-android-gradle.rust-android" version "0.9.3"
 }

native/Cargo.toml

@@ -4,11 +4,12 @@ version = "0.1.0"
 edition = "2021"
 
 [lib]
-name = "talaria"
+name = "uniffi_talaria"
 crate-type = ["cdylib"]
 
 [dependencies]
 jni = { version = "0.10.2", default-features = false }
+uniffi = "0.21.0"
 # v0.4 of grammers-* is currently unreleased; clone the project and use path dependencies
 grammers-client = { version = "0.4.1" }
 grammers-tl-types = { version = "0.4.0" }
@@ -19,5 +20,8 @@ android_logger = "0.11.1"
 once_cell = "1.15.0"
 sqlite = "0.27.0"
 
+[build-dependencies]
+uniffi_build = "0.21.0"
+
 [profile.release]
 lto = true

native/build.rs

@@ -0,0 +1,3 @@
+fn main() {
+    uniffi_build::generate_scaffolding("src/talaria.udl").unwrap();
+}

native/src/lib.rs

@@ -3,26 +3,24 @@
 
 mod db;
 
-use grammers_client::types::{Dialog, LoginToken};
+use grammers_client::types::LoginToken;
 use grammers_client::{Client, Config, InitParams};
 use grammers_session::{PackedChat, Session, UpdateState};
 use grammers_tl_types as tl;
-use jni::objects::{JObject, JString};
-use jni::sys::{jboolean, jint, jlong, jstring};
-use jni::JNIEnv;
 use log;
 use log::{error, info, Level};
 use once_cell::sync::OnceCell;
 use std::collections::HashMap;
-use std::ffi::{CStr, CString};
+use std::fmt;
 use std::future::Future;
 use std::net::SocketAddr;
 use std::net::{Ipv4Addr, Ipv6Addr};
 use std::sync::Mutex;
+use std::time::SystemTime;
 use tokio::runtime;
 use tokio::runtime::Runtime;
 
-type Result<T> = std::result::Result<T, Box<dyn std::error::Error>>;
+include!(concat!(env!("OUT_DIR"), "/talaria.uniffi.rs"));
 
 const LOG_MIN_LEVEL: Level = Level::Trace;
 const LOG_TAG: &str = ".native.talari";
@@ -47,6 +45,50 @@ static RUNTIME: OnceCell<Runtime> = OnceCell::new();
 static CLIENT: OnceCell<Client> = OnceCell::new();
 static DATABASE: Mutex<Option<sqlite::Connection>> = Mutex::new(None);
 
+#[derive(Debug, Clone, Copy)]
+pub enum NativeError {
+    Initialization,
+    Database,
+    Network,
+}
+
+impl fmt::Display for NativeError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Self::Initialization => write!(f, "a resource could not be initialized correctly"),
+            Self::Database => write!(f, "a query to the local database failed"),
+            Self::Network => write!(f, "a network request could not complete successfully"),
+        }
+    }
+}
+
+impl std::error::Error for NativeError {}
+
+#[derive(Debug, Clone, Copy)]
+pub enum MessageAck {
+    Received,
+    Seen,
+    Sent,
+}
+
+#[derive(Debug, Clone)]
+pub struct MessagePreview {
+    sender: String,
+    text: String,
+    date: SystemTime,
+    ack: MessageAck,
+}
+
+#[derive(Debug, Clone)]
+pub struct Dialog {
+    id: String,
+    title: String,
+    last_message: Option<MessagePreview>,
+    pinned: bool,
+}
+
+type Result<T> = std::result::Result<T, NativeError>;
+
 fn block_on<F: Future>(future: F) -> F::Output {
     if RUNTIME.get().is_none() {
         RUNTIME
@@ -62,7 +104,22 @@ fn block_on<F: Future>(future: F) -> F::Output {
     RUNTIME.get().unwrap().block_on(future)
 }
 
-async fn init_client() -> Result<()> {
+pub fn init_database(path: String) -> Result<()> {
+    let mut guard = DATABASE.lock().unwrap();
+    if guard.is_some() {
+        info!("Database is already initialized");
+    }
+
+    match db::init_connection(&path) {
+        Ok(conn) => {
+            *guard = Some(conn);
+            Ok(())
+        }
+        Err(_) => Err(NativeError::Database),
+    }
+}
+
+pub fn init_client() -> Result<()> {
     android_logger::init_once(
         android_logger::Config::default()
             .with_min_level(LOG_MIN_LEVEL)
@@ -78,7 +135,8 @@ async fn init_client() -> Result<()> {
     let conn = match guard.as_ref() {
         Some(c) => c,
         None => {
-            return Err("Database was not initialized".into());
+            error!("Database was not initialized");
+            return Err(NativeError::Initialization);
         }
     };
 
@@ -86,7 +144,7 @@ async fn init_client() -> Result<()> {
 
     let session = Session::new();
 
-    let sessions = db::get_sessions(conn)?;
+    let sessions = db::get_sessions(conn).map_err(|_| NativeError::Database)?;
     if let Some(s) = sessions.get(0) {
         match (s.user_id, s.dc_id, s.bot) {
             (Some(id), Some(dc), Some(bot)) => session.set_user(id, dc, bot),
@@ -112,7 +170,7 @@ async fn init_client() -> Result<()> {
         }
     }
 
-    let client = Client::connect(Config {
+    let client = block_on(Client::connect(Config {
         session,
         api_id: API_ID,
         api_hash: API_HASH.to_string(),
@@ -124,42 +182,46 @@ async fn init_client() -> Result<()> {
             },
             ..Default::default()
         },
-    })
-    .await?;
+    }))
+    .map_err(|_| NativeError::Network)?;
 
     info!("Connected!");
 
     CLIENT
         .set(client)
-        .map_err(|_| "Client was already initialized")?;
+        .map_err(|_| NativeError::Initialization)?;
 
     Ok(())
 }
 
-async fn need_login() -> Result<bool> {
-    let client = CLIENT.get().ok_or("Client not initialized")?;
-    Ok(client.is_authorized().await?)
+pub fn need_login() -> Result<bool> {
+    let client = CLIENT.get().ok_or(NativeError::Initialization)?;
+    block_on(client.is_authorized()).map_err(|_| NativeError::Network)
 }
 
-async fn request_login_code(phone: &str) -> Result<LoginToken> {
-    let client = CLIENT.get().ok_or("Client not initialized")?;
-    let token = client.request_login_code(&phone, API_ID, API_HASH).await?;
-    Ok(token)
+pub fn request_login_code(phone: String) -> Result<u64> {
+    let client = CLIENT.get().ok_or(NativeError::Initialization)?;
+    block_on(client.request_login_code(&phone, API_ID, API_HASH))
+        .map(|token| Box::into_raw(Box::new(token)) as u64)
+        .map_err(|_| NativeError::Network)
 }
 
-async fn sign_in(token: LoginToken, code: &str) -> Result<()> {
-    let client = CLIENT.get().ok_or("Client not initialized")?;
-    client.sign_in(&token, &code).await?;
+pub fn sign_in(token_ptr: u64, code: String) -> Result<()> {
+    let token = unsafe { *Box::from_raw(token_ptr as *mut LoginToken) };
+    let client = CLIENT.get().ok_or(NativeError::Initialization)?;
+
+    block_on(client.sign_in(&token, &code)).map_err(|_| NativeError::Network)?;
 
     let guard = DATABASE.lock().unwrap();
     let conn = match guard.as_ref() {
         Some(c) => c,
         None => {
-            return Err("Database was not initialized".into());
+            error!("Database was not initialized");
+            return Err(NativeError::Initialization);
         }
     };
 
-    let mut session = db::create_session(conn)?;
+    let mut session = db::create_session(conn).map_err(|_| NativeError::Database)?;
     let s = client.session();
     if let Some(user) = s.get_user() {
         session.user_id = Some(user.id);
@@ -189,280 +251,63 @@ async fn sign_in(token: LoginToken, code: &str) -> Result<()> {
         }
     }
 
-    db::update_session(conn, &session)?;
+    db::update_session(conn, &session).map_err(|_| NativeError::Database)?;
 
     Ok(())
 }
 
-async fn get_dialogs() -> Result<Vec<Dialog>> {
-    let client = CLIENT.get().ok_or("Client not initialized")?;
+pub fn get_dialogs() -> Result<Vec<Dialog>> {
+    let client = CLIENT.get().ok_or(NativeError::Initialization)?;
 
+    block_on(async {
         let mut result = Vec::new();
         let mut dialogs = client.iter_dialogs();
-    while let Some(dialog) = dialogs.next().await? {
+        while let Some(dialog) = dialogs.next().await.map_err(|_| NativeError::Network)? {
             result.push(dialog);
         }
         Ok(result)
-}
-
-async fn send_message(chat: PackedChat, text: &str) -> Result<()> {
-    let client = CLIENT.get().ok_or("Client not initialized")?;
-    client.send_message(chat, text).await?;
-    Ok(())
-}
-
-#[no_mangle]
-pub unsafe extern "C" fn Java_dev_lonami_talaria_bindings_Native_initDatabase(
-    env: JNIEnv,
-    _: JObject,
-    path: JString,
-) {
-    let mut guard = DATABASE.lock().unwrap();
-    if guard.is_some() {
-        info!("Database is already initialized");
-    }
-
-    let path = CString::from(CStr::from_ptr(env.get_string(path).unwrap().as_ptr()));
-    match db::init_connection(path.to_str().unwrap()) {
-        Ok(conn) => *guard = Some(conn),
-        Err(e) => error!("Failed to initialize database: {}", e),
-    }
-}
-
-#[no_mangle]
-pub unsafe extern "C" fn Java_dev_lonami_talaria_bindings_Native_initClient(_: JNIEnv, _: JObject) {
-    match block_on(init_client()) {
-        Ok(_) => info!("Client initialized"),
-        Err(e) => error!("Failed to initialize client: {}", e),
-    }
-}
-
-#[no_mangle]
-pub unsafe extern "C" fn Java_dev_lonami_talaria_bindings_Native_needLogin(
-    _: JNIEnv,
-    _: JObject,
-) -> jboolean {
-    match block_on(need_login()) {
-        Ok(login) => login.into(),
-        Err(e) => {
-            error!("Failed to check if user is authorized: {}", e);
-            false.into()
-        }
-    }
-}
-
-#[no_mangle]
-pub unsafe extern "C" fn Java_dev_lonami_talaria_bindings_Native_requestLoginCode(
-    env: JNIEnv,
-    _: JObject,
-    phone: JString,
-) -> jlong {
-    let phone = CString::from(CStr::from_ptr(env.get_string(phone).unwrap().as_ptr()));
-
-    match block_on(request_login_code(phone.to_str().unwrap())) {
-        Ok(token) => Box::into_raw(Box::new(token)) as jlong,
-        Err(e) => {
-            error!("Failed to request login code: {}", e);
-            0 as jlong
-        }
-    }
-}
-
-#[no_mangle]
-pub unsafe extern "C" fn Java_dev_lonami_talaria_bindings_Native_signIn(
-    env: JNIEnv,
-    _: JObject,
-    token_ptr: jlong,
-    code: JString,
-) {
-    let token = *Box::from_raw(token_ptr as *mut LoginToken);
-    let code = CString::from(CStr::from_ptr(env.get_string(code).unwrap().as_ptr()));
-
-    match block_on(sign_in(token, code.to_str().unwrap())) {
-        Ok(_) => info!("Sign in success"),
-        Err(e) => error!("Failed to sign in: {}", e),
-    }
-}
-
-#[no_mangle]
-pub unsafe extern "C" fn Java_dev_lonami_talaria_bindings_Native_getDialogs(
-    _: JNIEnv,
-    _: JObject,
-) -> jlong {
-    match block_on(get_dialogs()) {
-        Ok(dialogs) => Box::into_raw(Box::new(dialogs)) as jlong,
-        Err(e) => {
-            error!("Failed to get dialogs: {}", e);
-            0 as jlong
-        }
-    }
-}
-
-#[no_mangle]
-pub unsafe extern "C" fn Java_dev_lonami_talaria_bindings_Native_dialogCount(
-    _: JNIEnv,
-    _: JObject,
-    dialogs_ptr: jlong,
-) -> jint {
-    let dialogs = &mut *(dialogs_ptr as *mut Vec<Dialog>);
-    dialogs.len() as jint
-}
-
-#[no_mangle]
-pub unsafe extern "C" fn Java_dev_lonami_talaria_bindings_Native_dialogPacked(
-    env: JNIEnv,
-    _: JObject,
-    dialogs_ptr: jlong,
-    index: jint,
-) -> jstring {
-    let dialogs = &mut *(dialogs_ptr as *mut Vec<Dialog>);
-
-    let packed = dialogs[index as usize].chat().pack().to_hex();
-    let output = env.new_string(packed).unwrap();
-    output.into_inner()
-}
-
-#[no_mangle]
-pub unsafe extern "C" fn Java_dev_lonami_talaria_bindings_Native_dialogTitle(
-    env: JNIEnv,
-    _: JObject,
-    dialogs_ptr: jlong,
-    index: jint,
-) -> jstring {
-    let dialogs = &mut *(dialogs_ptr as *mut Vec<Dialog>);
-
-    let title = dialogs[index as usize].chat().name();
-    let output = env.new_string(title).unwrap();
-    output.into_inner()
-}
-
-#[no_mangle]
-pub unsafe extern "C" fn Java_dev_lonami_talaria_bindings_Native_dialogSender(
-    env: JNIEnv,
-    _: JObject,
-    dialogs_ptr: jlong,
-    index: jint,
-) -> jstring {
-    let dialogs = &mut *(dialogs_ptr as *mut Vec<Dialog>);
-
-    let sender = if let Some(msg) = dialogs[index as usize].last_message.as_ref() {
-        if let Some(sender) = msg.sender() {
+    })
+    .map(|dialogs| {
+        dialogs
+            .into_iter()
+            .map(|d| Dialog {
+                id: d.chat().pack().to_hex(),
+                title: d.chat().name().to_string(),
+                last_message: d.last_message.map(|m| MessagePreview {
+                    sender: if let Some(sender) = m.sender() {
                         sender.name().to_string()
                     } else {
                         "unknown".to_string()
-        }
-    } else {
-        String::new()
-    };
-    let output = env.new_string(sender).unwrap();
-    output.into_inner()
-}
-
-#[no_mangle]
-pub unsafe extern "C" fn Java_dev_lonami_talaria_bindings_Native_dialogText(
-    env: JNIEnv,
-    _: JObject,
-    dialogs_ptr: jlong,
-    index: jint,
-) -> jstring {
-    let dialogs = &mut *(dialogs_ptr as *mut Vec<Dialog>);
-
-    let text = if let Some(msg) = dialogs[index as usize].last_message.as_ref() {
-        msg.text()
-    } else {
-        ""
-    };
-    let output = env.new_string(text).unwrap();
-    output.into_inner()
-}
-
-#[no_mangle]
-pub unsafe extern "C" fn Java_dev_lonami_talaria_bindings_Native_dialogTime(
-    env: JNIEnv,
-    _: JObject,
-    dialogs_ptr: jlong,
-    index: jint,
-) -> jstring {
-    let dialogs = &mut *(dialogs_ptr as *mut Vec<Dialog>);
-
-    let time = if let Some(msg) = dialogs[index as usize].last_message.as_ref() {
-        msg.date().to_rfc3339().to_string()
-    } else {
-        String::new()
-    };
-    let output = env.new_string(time).unwrap();
-    output.into_inner()
-}
-
-#[no_mangle]
-pub unsafe extern "C" fn Java_dev_lonami_talaria_bindings_Native_dialogAck(
-    _: JNIEnv,
-    _: JObject,
-    dialogs_ptr: jlong,
-    index: jint,
-) -> jint {
-    let dialogs = &mut *(dialogs_ptr as *mut Vec<Dialog>);
-
-    let dialog = &dialogs[index as usize];
-    let ack = if let Some(msg) = dialog.last_message.as_ref() {
-        if msg.outgoing() {
-            match &dialog.dialog {
+                    },
+                    text: m.text().to_string(),
+                    date: m.date().into(),
+                    ack: if m.outgoing() {
+                        match &d.dialog {
                             tl::enums::Dialog::Dialog(d) => {
-                    if msg.id() <= d.read_inbox_max_id {
-                        2
+                                if m.id() <= d.read_inbox_max_id {
+                                    MessageAck::Seen
                                 } else {
-                        1
+                                    MessageAck::Sent
                                 }
                             }
-                tl::enums::Dialog::Folder(_) => 0,
+                            tl::enums::Dialog::Folder(_) => MessageAck::Received,
                         }
                     } else {
-            0
-        }
-    } else {
-        0
-    };
-    ack
-}
-
-#[no_mangle]
-pub unsafe extern "C" fn Java_dev_lonami_talaria_bindings_Native_dialogPin(
-    _: JNIEnv,
-    _: JObject,
-    dialogs_ptr: jlong,
-    index: jint,
-) -> jint {
-    let dialogs = &mut *(dialogs_ptr as *mut Vec<Dialog>);
-
-    let pinned = match &dialogs[index as usize].dialog {
+                        MessageAck::Received
+                    },
+                }),
+                pinned: match d.dialog {
                     tl::enums::Dialog::Dialog(d) => d.pinned,
                     tl::enums::Dialog::Folder(f) => f.pinned,
-    };
-    pinned as jint
+                },
+            })
+            .collect()
+    })
 }
 
-#[no_mangle]
-pub unsafe extern "C" fn Java_dev_lonami_talaria_bindings_Native_freeDialogs(
-    _: JNIEnv,
-    _: JObject,
-    dialogs_ptr: jlong,
-) {
-    let _ = Box::from_raw(dialogs_ptr as *mut Vec<Dialog>);
-}
-
-#[no_mangle]
-pub unsafe extern "C" fn Java_dev_lonami_talaria_bindings_Native_sendMessage(
-    env: JNIEnv,
-    _: JObject,
-    packed: JString,
-    text: JString,
-) {
-    let packed = CString::from(CStr::from_ptr(env.get_string(packed).unwrap().as_ptr()));
-    let text = CString::from(CStr::from_ptr(env.get_string(text).unwrap().as_ptr()));
-
-    let packed = PackedChat::from_hex(packed.to_str().unwrap()).unwrap();
-    match block_on(send_message(packed, text.to_str().unwrap())) {
-        Ok(_) => info!("Message sent"),
-        Err(e) => error!("Failed to send message: {}", e),
-    }
+pub fn send_message(packed: String, text: String) -> Result<()> {
+    let chat = PackedChat::from_hex(&packed).unwrap();
+    let client = CLIENT.get().ok_or(NativeError::Initialization)?;
+    block_on(client.send_message(chat, text)).map_err(|_| NativeError::Network)?;
+    Ok(())
 }

native/src/talaria.udl

@@ -0,0 +1,43 @@
+[Error]
+enum NativeError {
+  "Initialization",
+  "Database",
+  "Network",
+};
+
+enum MessageAck {
+    "Received",
+    "Seen",
+    "Sent",
+};
+
+dictionary MessagePreview {
+    string sender;
+    string text;
+    timestamp date;
+    MessageAck ack;
+};
+
+dictionary Dialog {
+    string id;
+    string title;
+    MessagePreview? last_message;
+    boolean pinned;
+};
+
+namespace talaria {
+    [Throws=NativeError]
+    void init_database(string path);
+    [Throws=NativeError]
+    void init_client();
+    [Throws=NativeError]
+    boolean need_login();
+    [Throws=NativeError]
+    u64 request_login_code(string phone);
+    [Throws=NativeError]
+    void sign_in(u64 tokenPtr, string code);
+    [Throws=NativeError]
+    sequence<Dialog> get_dialogs();
+    [Throws=NativeError]
+    void send_message(string packed, string text);
+};