Rust sa mobile development: native module at cross-platform SDK

Ano ang Rust?

Rust — isang statically-typed system programming language na may zero-cost abstractions. Ginagarantiya ng Rust ang kaligtasan ng memory na walang garbage collector dahil sa sistema ng ownership, borrowing at lifetimes. Ang Rust compiler ay isa sa pinakamahigpit — tinatanggihan nito ang code na sa C++ ay magdudulot ng undefined behavior.

Nagko-compile ang Rust sa pamamagitan ng LLVM sa native code para sa lahat ng arkitektura: ARM, x86, RISC-V, WebAssembly. Mga tool: rustup (installer), rustc (compiler), cargo (package manager at builder). Ang cargo.toml — katulad ng package.json, naglalaman ng mga dependency mula sa crates.io. Kasalukuyang bersyon — Rust 1.81 (2025).

Mga pangunahing lugar ng aplikasyon ng Rust sa mobile development: native library (Android NDK, iOS), cross-platform SDK (Firefox, Dropbox), pagpapalit ng C++ sa mga performance-critical na bahagi, WebAssembly para sa hybrid apps. Ginagamit ng Google ang Rust sa AOSP (Android Open Source Project) para sa mga component ng Bluetooth, Wi-Fi at NFC.

Pag-install at configuration ng Rust para sa mobile development

Para sa cross-compilation para sa Android, kailangan ang target toolchain: rustup target add aarch64-linux-android armv7-linux-androideabi. Para sa iOS — aarch64-apple-ios x86_64-apple-ios. Pinapadali ng cargo-ndk (para sa Android) at cargo-lipo (para sa iOS) ang pag-build.

# Pag-install ng Rust at target platform para sa mobile development
$ 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

# Pag-install ng cargo-ndk para sa Android build
$ cargo install cargo-ndk

# Pag-build para sa Android
$ cargo ndk -t arm64-v8a -o ./jniLibs build --release

Sistema ng pagmamay-ari: ownership, borrowing at lifetimes

Ownership (pagmamay-ari) — ang pangunahing konsepto ng Rust. Ang bawat halaga ay may eksaktong isang may-ari. Sa pagtatalaga o pagpasa sa function, ang pagmamay-ari ay inililipat (move). Pagkatapos ng paglipat, hindi magagamit ng lumang may-ari ang halaga. Inaalis nito ang dobleng pagpapalaya ng memory at mga dangling pointer.

Borrowing (panghihiram) ay nagpapahintulot ng pansamantalang paggamit ng reference sa isang halaga nang hindi inililipat ang pagmamay-ari. Reference &T (immutable) — kahit ilang mambabasa. Reference &mut T (mutable) — eksaktong isang manunulat, walang mambabasa. Sinusuri ng compiler ang mga patakarang ito sa yugto ng pag-build.

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!("Naproseso: {:?}", numbers);

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

Ang process_data ay tumatanggap ng mutable reference sa Vec at dinodoble ang bawat elemento. Ang iter_mut() ay nagbabalik ng iterator na may mutable references. Ang *item ay dini-dereference ang reference para sa pagtatalaga. Pagkatapos ng process_data, nananatiling accessible ang numbers — hindi inilipat ang pagmamay-ari, tayo ay humiram lamang.

Lifetimes: habang-buhay ng mga reference

Lifetimes ('a) — mga annotation para sa pagbubuklod ng habang-buhay ng mga reference. Ginagamit sila ng compiler upang suriin na ang reference ay hindi mas mahaba ang buhay kaysa sa data na tinutukoy nito. Sa karamihan ng mga kaso, ang lifetimes ay awtomatikong nadeduce — kailangan lamang tukuyin sa mga signature ng function na may mga reference.

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!("Pinakamahaba: {}", result);
    } // si string2 ay nabubuhay hanggang sa bracket na ito, valid ang result sa loob
    // println!("{}", result); // error: patay na si string2
}

Rust para sa native module ng Android at iOS

Rust ay nagko-compile sa native library para sa Android (.so sa pamamagitan ng NDK) at iOS (.a static library). Opisyal na sinusuportahan ng Google ang Rust sa Android Open Source Project (AOSP) — ang mga component ng Bluetooth (ava), DNS-over-HTTP3 at CriticalNotification ay isinulat sa Rust. Ayon sa Google (2025), inalis ng Rust sa Android ang 70% ng mga kahinaan sa memory sa mga target na component.

Para sa Android ginagamit ang cargo-ndk, na bumabalot sa Cargo ng tamang toolchain para sa napiling ABI. Ang pag-build para sa Android ay kinabibilangan ng: aarch64-linux-android (64-bit ARM, modernong device), armv7-linux-androideabi (32-bit ARM), x86_64-linux-android (emulator).

// Cargo.toml — configuration ng library para sa 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 — para sa iOS (.a), cdylib — para sa Android (.so). serde — serialization para sa pagpapalitan ng data sa Kotlin/Swift. libc — mga type na compatible sa C para sa FFI.

Halimbawa: pagproseso ng imahe sa Rust

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

/// C-compatible na function para sa pagproseso ng imahe
#[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;
}

Ang #[no_mangle] ay nagdi-disable ng name mangling para sa C-compatible na ABI. Ang extern "C" ay nagtatakda ng C calling convention. unsafe — marker na ang tawag mula sa labas ng Rust ay hindi ginagarantiya ang kaligtasan. Ang std::ptr::copy_nonoverlapping ay kumokopya ng mga byte ng resulta sa output buffer.

Cross-platform SDK sa Rust

Rust — ang perpektong kandidato para sa cross-platform SDK na tumatakbo sa Android at iOS mula sa iisang codebase. Pinili ng mga kumpanyang Mozilla (Firefox), Dropbox (file sync) at Meta (Libra blockchain) ang Rust para sa mga kritikal na component ng kanilang mobile apps.

Mga bentahe ng Rust library kumpara sa C++: ginagarantiya ng compiler ang kawalan ng memory leaks at data races sa cross-platform code. Ang code na isinulat at nasubukan nang isang beses sa Rust ay gumagana nang pareho sa lahat ng platform. Pinamamahalaan ng Cargo ang mga dependency nang native, walang CMake at vcpkg.

Rust at WebAssembly para sa mga mobile app

Rust ay nagko-compile sa WebAssembly (Wasm) — isang binary format na naisasagawa sa browser at sa mga mobile device. Ang Wasm ay nagbibigay ng near-native performance sa web environment. Sa mobile development, ginagamit ang Wasm sa hybrid apps (WebView + Wasm) para sa mga kumplikadong computation: 3D rendering, image recognition, encryption.

Ang wasm-pack ay nagco-compile ng Rust sa .wasm at bumubuo ng JS wrapper. Ang wasm-bindgen ay nag-uugnay ng Rust functions sa JavaScript calls. Sa mobile device, ang Wasm-runner ay maaaring tumakbo sa WebView o sa pamamagitan ng Wasmer/Wasmtime SDK.

use wasm_bindgen::prelude::*;

/// Pagkalkula ng Fibonacci number sa Wasm (tinatawag mula sa 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
        }
    }
}

Ang #[wasm_bindgen] ay bumubuo ng JavaScript wrapper para sa function na fibonacci. Sa browser, ang tawag ay mukhang wasm.fibonacci(10). Ang mga type na u32/u64 ay awtomatikong kino-convert sa Number/BigInt. Ang Wasm module ay tumitimbang ng ~5 KB para sa ganoong function — minimal na overhead.

FFI: pagtawag ng Rust mula sa Kotlin at Swift

FFI (Foreign Function Interface) — mekanismo ng pagtawag ng Rust code mula sa ibang mga wika. Ang mga Rust function na may extern "C" at #[no_mangle] ay ini-export na may C-compatible na ABI. Mula sa Kotlin, ang mga naturang function ay tinatawag sa pamamagitan ng JNI, mula sa Swift — sa pamamagitan ng @_cdecl ("name") o CBridge.h.

UniFFI — tool ng Mozilla para sa pagbuo ng FFI binding. Inilalarawan mo ang API sa isang .udl file, awtomatikong bumubuo ang UniFFI ng Kotlin at Swift wrappers. Ito ang karaniwang approach para sa Rust component sa Firefox Android at Firefox iOS.

// Rust library na may UniFFI interface
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> {
    // implementasyon ng AES-256-GCM
    todo!()
}

Ang UniFFI ay bumubuo ng Kotlin class na may method na encrypt na tumatanggap ng ByteArray at nagbabalik ng EncryptedData. Sa Swift, nilikha ang isang struct EncryptedData na may mga field na ciphertext (Data) at nonce (Data). Ang mga error ay kino-convert sa mga exception ng Kotlin/Swift.

Rust laban sa C++: paghahambing para sa mobile development

Rust at C++ — ang dalawang pangunahing wika para sa system programming sa mobile development. Pareho silang nagco-compile sa native code para sa ARM at sumusuporta sa FFI sa pamamagitan ng C ABI. Ang pangunahing pagkakaiba — modelo ng kaligtasan ng memory: sinusuri ito ng Rust sa oras ng compilation, ang C++ ay umaasa sa disiplina ng developer.

Ang Rust ay mas ligtas kaysa sa C++ at mas produktibo — nahuhuli ng compiler ang mga error na sa C++ ay lilitaw sa runtime. Ang C++ ay may mas mayamang ecosystem ng mobile library. Para sa mga bagong proyekto, mas gusto ang Rust; ang umiiral na C++ code ay ini-port nang paunti-unti.