Rust у мобилном развоју: native модули и вишеплатформски SDK

Шта је Rust?

Rust — статички типизиран језик системског програмирања са нултом апстракцијом (zero-cost abstractions). Rust гарантује безбедност меморије без сакупљача смећа захваљујући систему власништва (ownership), позајмљивања (borrowing) и животног века (lifetimes). Rust компајлер је један од најстрожих — одбија код који би у C++ изазвао недефинисано понашање.

Rust се компилира кроз LLVM у изворни код за све архитектуре: ARM, x86, RISC-V, WebAssembly. Алати: rustup (инсталатер), rustc (компајлер), cargo (менаџер пакета и градитељ). cargo.toml — аналог package.json, садржи зависности из crates.io. Тренутна верзија — Rust 1.81 (2025).

Кључне области примене Rust-а у мобилном развоју: изворне библиотеке (Android NDK, iOS), вишеплатформски SDK (Firefox, Dropbox), замена C++ у performance-critical деловима, WebAssembly за хибридне апликације. Google користи Rust у AOSP (Android Open Source Project) за компоненте Bluetooth, Wi-Fi и NFC.

Инсталација и подешавање Rust-а за мобилни развој

За унакрсну компилацију за Android потребни су циљни алати: rustup target add aarch64-linux-android armv7-linux-androideabi. За iOS — aarch64-apple-ios x86_64-apple-ios. cargo-ndk (за Android) и cargo-lipo (за iOS) поједностављују изградњу.

# Инсталација Rust-а и циљних платформи за мобилни развој
$ 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

# Инсталација cargo-ndk за Android изградњу
$ cargo install cargo-ndk

# Изградња за Android
$ cargo ndk -t arm64-v8a -o ./jniLibs build --release

Систем власништва: ownership, borrowing и lifetimes

Ownership (власништво) — темељни појам Rust-а. Свака вредност има тачно једног власника. При додели или прослеђивању функцији, власништво се преноси (move). Након преноса, стари власник не може користити вредност. Ово елиминише двоструко ослобађање меморије и висеће показиваче.

Borrowing (позајмљивање) омогућава привремено коришћење референце на вредност без преноса власништва. Референца &T (непроменљива) — произвољан број читалаца. Референца &mut T (променљива) — тачно један писац, без читалаца. Компајлер проверава ова правила у фази изградње.

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!("Обрађено: {:?}", numbers);

    let first = &numbers[0];  // непроменљиво позајмљивање
    println!("Први: {}", first);
}

process_data прима променљиву референцу на Vec и удвостручује сваки елемент. iter_mut() враћа итератор са променљивим референцама. *item дереференцира референцу за доделу. Након process_data, numbers остаје доступан — власништво није пренето, само позајмљено.

Lifetimes: животни век референци

Lifetimes ('a) — анотације за повезивање животног века референци. Компајлер их користи да провери да референца не надживи податке на које указује. У већини случајева, lifetimes се закључују аутоматски — треба их наводити само у потписима функција са референцама.

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!("Најдужи: {}", result);
    } // string2 живи до ове заграде, result је важећи унутра
    // println!("{}", result); // грешка: string2 је умро
}

Rust за native модуле Android и iOS

Rust се компилира у изворне библиотеке за Android (.so преко NDK) и iOS (.a статичке библиотеке). Google званично подржава Rust у Android Open Source Project (AOSP) — у Rust-у су написане компоненте Bluetooth (ava), DNS-over-HTTP3 и CriticalNotification. Према Google-у (2025), Rust је у Android-у елиминисао 70% рањивости меморије у циљним компонентама.

За Android се користи cargo-ndk, који обавија Cargo са исправним алатима за изабрани ABI. Изградња за Android укључује: aarch64-linux-android (64-bit ARM, савремени уређаји), armv7-linux-androideabi (32-bit ARM), x86_64-linux-android (емулатори).

// Cargo.toml — конфигурација библиотеке за 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 — за iOS (.a), cdylib — за Android (.so). serde — серијализација за размену података са Kotlin/Swift. libc — C-компатибилни типови за FFI.

Пример: обрада слике у Rust-у

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

/// C-компатибилна функција за обраду слике
#[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] искључује name mangling за C-компатибилни ABI. extern "C" поставља C конвенцију позива. unsafe — маркер да позив изван Rust-а не гарантује безбедност. std::ptr::copy_nonoverlapping копира бајтове резултата у излазни бафер.

Вишеплатформски SDK у Rust-у

Rust — идеалан кандидат за вишеплатформске SDK који раде на Android и iOS из једне кодне базе. Компаније Mozilla (Firefox), Dropbox (синхронизација датотека) и Meta (Libra blockchain) изабрале су Rust за критичне компоненте својих мобилних апликација.

Предности Rust библиотеке у односу на C++: компајлер гарантује одсуство цурења меморије и трка података у вишеплатформском коду. Код написан и тестиран једном у Rust-у ради идентично на свим платформама. Cargo управља зависностима изворно, без CMake-а и vcpkg-а.

Rust и WebAssembly за мобилне апликације

Rust се компилира у WebAssembly (Wasm) — бинарни формат извршив у прегледачу и на мобилним уређајима. Wasm пружа перформансе near-native у веб окружењу. У мобилном развоју, Wasm се користи у хибридним апликацијама (WebView + Wasm) за сложена израчунавања: 3D рендеровање, препознавање слика, шифровање.

wasm-pack компилира Rust у .wasm и генерише JS омот. wasm-bindgen повезује Rust функције са JavaScript позивима. На мобилном уређају, Wasm-runner може да ради у WebView-у или путем Wasmer/Wasmtime SDK-а.

use wasm_bindgen::prelude::*;

/// Израчунавање Фибоначијевог броја у Wasm-у (позива се из 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] генерише JavaScript омот за функцију fibonacci. У прегледачу, позив изгледа као wasm.fibonacci(10). Типови u32/u64 се аутоматски конвертују у Number/BigInt. Wasm модул тежи ~5 KB за такву функцију — минималан overhead.

FFI: позивање Rust-а из Kotlin и Swift

FFI (Foreign Function Interface) — механизам позивања Rust кода из других језика. Rust функције са extern "C" и #[no_mangle] се извозе са C-компатибилним ABI-јем. Из Kotlin-а се такве функције позивају преко JNI, из Swift-а — преко @_cdecl ("name") или CBridge.h.

UniFFI — Mozilla-ин алат за генерисање FFI веза. Опишете API у .udl датотеци, UniFFI аутоматски генерише Kotlin и Swift омоте. Ово је стандардни приступ за Rust компоненте у Firefox Android и Firefox iOS.

// Rust библиотека са 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> {
    // имплементација AES-256-GCM
    todo!()
}

UniFFI генерише Kotlin класу са методом encrypt која прима ByteArray и враћа EncryptedData. У Swift-у се креира struct EncryptedData са пољима ciphertext (Data) и nonce (Data). Грешке се претварају у изузетке Kotlin/Swift.

Rust против C++: поређење за мобилни развој

Rust и C++ — два главна језика за системско програмирање у мобилном развоју. Оба се компилирају у изворни код за ARM и подржавају FFI кроз C ABI. Главна разлика — модел безбедности меморије: Rust га проверава у фази компилације, C++ се ослања на дисциплину програмера.

Rust је безбеднији од C++-а и продуктивнији — компајлер хвата грешке које би се у C++-у појавиле у рантајму. C++ има богатији екосистем мобилних библиотека. За нове пројекте, Rust је пожељнији; постојећи C++ код се преноси постепено.