Rust dalam pengembangan mobile: modul native dan SDK lintas platform

Apa itu Rust?

Rust — bahasa pemrograman sistem dengan tipe statis dan abstraksi biaya nol (zero-cost abstractions). Rust menjamin keamanan memori tanpa garbage collector berkat sistem kepemilikan (ownership), peminjaman (borrowing), dan masa hidup (lifetimes). Kompiler Rust adalah salah satu yang paling ketat — ia menolak kode yang dalam C++ akan menyebabkan perilaku tidak terdefinisi.

Rust dikompilasi melalui LLVM menjadi kode native untuk semua arsitektur: ARM, x86, RISC-V, WebAssembly. Perangkat: rustup (penginstal), rustc (kompiler), cargo (manajer paket dan pembangun). cargo.toml — analog dari package.json, berisi dependensi dari crates.io. Versi saat ini — Rust 1.81 (2025).

Bidang utama penerapan Rust dalam pengembangan mobile: pustaka native (Android NDK, iOS), SDK lintas platform (Firefox, Dropbox), penggantian C++ di bagian performance-critical, WebAssembly untuk aplikasi hybrid. Google menggunakan Rust di AOSP (Android Open Source Project) untuk komponen Bluetooth, Wi-Fi, dan NFC.

Instalasi dan konfigurasi Rust untuk pengembangan mobile

Untuk kompilasi silang ke Android, diperlukan toolchain target: rustup target add aarch64-linux-android armv7-linux-androideabi. Untuk iOS — aarch64-apple-ios x86_64-apple-ios. cargo-ndk (untuk Android) dan cargo-lipo (untuk iOS) menyederhanakan pembangunan.

# Instalasi Rust dan platform target untuk pengembangan mobile
$ curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
$ rustup target add aarch64-linux-android
$ rustup target add armv7-linux-androideabi
$ rustup target add aarch64-apple-ios
$ rustup target add x86_64-apple-ios

# Instalasi cargo-ndk untuk pembangunan Android
$ cargo install cargo-ndk

# Pembangunan untuk Android
$ cargo ndk -t arm64-v8a -o ./jniLibs build --release

Sistem kepemilikan: ownership, borrowing, dan lifetimes

Ownership (kepemilikan) — konsep fundamental Rust. Setiap nilai memiliki tepat satu pemilik. Saat penugasan atau pengiriman ke fungsi, kepemilikan dipindahkan (move). Setelah pemindahan, pemilik lama tidak dapat menggunakan nilai tersebut. Ini menghilangkan pembebasan memori ganda dan pointer menggantung.

Borrowing (peminjaman) memungkinkan penggunaan sementara referensi ke nilai tanpa pemindahan kepemilikan. Referensi &T (immutable) — berapa pun pembaca. Referensi &mut T (mutable) — tepat satu penulis, tanpa pembaca. Kompiler memeriksa aturan ini pada tahap pembangunan.

fn process_data(data: &mut Vec<i32>) {
    for item in data.iter_mut() {
        *item *= 2;
    }
}

fn main() {
    let mut numbers = vec![1, 2, 3, 4, 5];
    process_data(&mut numbers);
    println!("Diproses: {:?}", numbers);

    let first = &numbers[0];  // peminjaman immutable
    println!("Pertama: {}", first);
}

process_data menerima referensi mutable ke Vec dan menggandakan setiap elemen. iter_mut() mengembalikan iterator dengan referensi mutable. *item melakukan dereference referensi untuk penugasan. Setelah process_data, numbers tetap dapat diakses — kepemilikan tidak dipindahkan, hanya dipinjamkan.

Lifetimes: masa hidup referensi

Lifetimes ('a) — anotasi untuk mengikat masa hidup referensi. Kompiler menggunakannya untuk memeriksa bahwa referensi tidak hidup lebih lama dari data yang ditunjuknya. Dalam banyak kasus, lifetimes disimpulkan secara otomatis — hanya perlu ditentukan dalam tanda tangan fungsi dengan referensi.

fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {
    if x.len() > y.len() { x } else { y }
}

fn main() {
    let string1 = String::from("rust");
    let result;
    {
        let string2 = String::from("mobile");
        result = longest(string1.as_str(), string2.as_str());
        println!("Terpanjang: {}", result);
    } // string2 hidup sampai kurung ini, result valid di dalam
    // println!("{}", result); // kesalahan: string2 mati
}

Rust untuk modul native Android dan iOS

Rust dikompilasi menjadi pustaka native untuk Android (.so melalui NDK) dan iOS (.a pustaka statis). Google secara resmi mendukung Rust di Android Open Source Project (AOSP) — komponen Bluetooth (ava), DNS-over-HTTP3, dan CriticalNotification ditulis dalam Rust. Menurut Google (2025), Rust di Android telah menghilangkan 70% kerentanan memori di komponen target.

Untuk Android digunakan cargo-ndk, yang membungkus Cargo dengan toolchain yang tepat untuk ABI yang dipilih. Pembangunan untuk Android meliputi: aarch64-linux-android (ARM 64-bit, perangkat modern), armv7-linux-androideabi (ARM 32-bit), x86_64-linux-android (emulator).

// Cargo.toml — konfigurasi pustaka untuk Android/iOS
[package]
name = "mobile_crypto"
version = "0.1.0"

[lib]
crate-type = ["staticlib", "cdylib"]

[dependencies]
serde = { version = "1", features = ["derive"] }
libc = "0.2"

crate-type: staticlib — untuk iOS (.a), cdylib — untuk Android (.so). serde — serialisasi untuk pertukaran data dengan Kotlin/Swift. libc — tipe yang kompatibel dengan C untuk FFI.

Contoh: pemrosesan gambar di Rust

use std::ffi::{CStr, CString};
use std::os::raw::c_char;

/// Fungsi kompatibel C untuk pemrosesan gambar
#[no_mangle]
pub unsafe extern "C" fn process_image(
    input: *const u8,
    len: usize,
    output: *mut u8,
    out_len: *mut usize,
) {
    let input_slice = std::slice::from_raw_parts(input, len);
    let result: Vec<u8> = input_slice.iter()
        .map(|b| b ^ 0xFF)
        .collect();
    let result_len = result.len();
    std::ptr::copy_nonoverlapping(result.as_ptr(), output, result_len);
    *out_len = result_len;
}

#[no_mangle] menonaktifkan name mangling untuk ABI yang kompatibel dengan C. extern "C" mengatur konvensi pemanggilan C. unsafe — penanda bahwa panggilan dari luar Rust tidak menjamin keamanan. std::ptr::copy_nonoverlapping menyalin byte hasil ke buffer keluaran.

SDK lintas platform di Rust

Rust — kandidat ideal untuk SDK lintas platform yang berjalan di Android dan iOS dari satu basis kode. Perusahaan Mozilla (Firefox), Dropbox (sinkronisasi file), dan Meta (Libra blockchain) memilih Rust untuk komponen kritis aplikasi mobile mereka.

Keunggulan pustaka Rust dibandingkan C++: kompiler menjamin tidak adanya kebocoran memori dan race condition data dalam kode lintas platform. Kode yang ditulis dan diuji sekali di Rust bekerja identik di semua platform. Cargo mengelola dependensi secara native, tanpa CMake dan vcpkg.

Rust dan WebAssembly untuk aplikasi mobile

Rust dikompilasi menjadi WebAssembly (Wasm) — format biner yang dapat dijalankan di browser dan perangkat mobile. Wasm memberikan performa near-native di lingkungan web. Dalam pengembangan mobile, Wasm digunakan di aplikasi hybrid (WebView + Wasm) untuk komputasi kompleks: rendering 3D, pengenalan gambar, enkripsi.

wasm-pack mengompilasi Rust menjadi .wasm dan menghasilkan wrapper JS. wasm-bindgen menghubungkan fungsi Rust dengan panggilan JavaScript. Di perangkat mobile, Wasm-runner dapat berjalan di WebView atau melalui SDK Wasmer/Wasmtime.

use wasm_bindgen::prelude::*;

/// Perhitungan bilangan Fibonacci di Wasm (dipanggil dari JS)
#[wasm_bindgen]
pub fn fibonacci(n: u32) -> u64 {
    match n {
        0 => 0,
        1 => 1,
        _ => {
            let mut a = 0;
            let mut b = 1;
            for _ in 2..=n {
                let temp = a + b;
                a = b;
                b = temp;
            }
            b
        }
    }
}

#[wasm_bindgen] menghasilkan wrapper JavaScript untuk fungsi fibonacci. Di browser, panggilan terlihat seperti wasm.fibonacci(10). Tipe u32/u64 secara otomatis dikonversi menjadi Number/BigInt. Modul Wasm berbobot ~5 KB untuk fungsi semacam itu — overhead minimal.

FFI: memanggil Rust dari Kotlin dan Swift

FFI (Foreign Function Interface) — mekanisme pemanggilan kode Rust dari bahasa lain. Fungsi Rust dengan extern "C" dan #[no_mangle] diekspor dengan ABI kompatibel C. Dari Kotlin, fungsi tersebut dipanggil melalui JNI, dari Swift — melalui @_cdecl ("name") atau CBridge.h.

UniFFI — alat Mozilla untuk menghasilkan binding FFI. Anda mendeskripsikan API dalam file .udl, UniFFI secara otomatis menghasilkan wrapper Kotlin dan Swift. Ini adalah pendekatan standar untuk komponen Rust di Firefox Android dan Firefox iOS.

// Pustaka Rust dengan antarmuka UniFFI
uniffi::setup_scaffolding!();

#[derive(uniffi::Enum)]
pub enum EncryptionError {
    InvalidKey,
    EncryptionFailed,
}

#[derive(uniffi::Record)]
pub struct EncryptedData {
    pub ciphertext: Vec<u8>,
    pub nonce: Vec<u8>,
}

#[uniffi::export]
pub fn encrypt(key: &[u8], plaintext: &[u8]) -> Result<EncryptedData, EncryptionError> {
    // implementasi AES-256-GCM
    todo!()
}

UniFFI menghasilkan kelas Kotlin dengan metode encrypt yang menerima ByteArray dan mengembalikan EncryptedData. Di Swift, dibuat struct EncryptedData dengan bidang ciphertext (Data) dan nonce (Data). Kesalahan diubah menjadi eksepsi Kotlin/Swift.

Rust vs C++: perbandingan untuk pengembangan mobile

Rust dan C++ — dua bahasa utama untuk pemrograman sistem dalam pengembangan mobile. Keduanya dikompilasi menjadi kode native untuk ARM dan mendukung FFI melalui C ABI. Perbedaan utama — model keamanan memori: Rust memeriksanya pada tahap kompilasi, C++ mengandalkan disiplin pengembang.

Rust lebih aman daripada C++ dan lebih produktif — kompiler menangkap kesalahan yang di C++ akan muncul saat runtime. C++ memiliki ekosistem pustaka mobile yang lebih kaya. Untuk proyek baru, Rust lebih disukai; kode C++ yang ada diporting secara bertahap.