Rust în dezvoltarea mobilă: module native și SDK multi-platformă

Ce este Rust?

Rust — un limbaj de programare de sistem tipizat static cu abstracții cu cost zero (zero-cost abstractions). Rust garantează securitatea memoriei fără garbage collector datorită sistemului de ownership, borrowing și lifetimes. Compilatorul Rust este unul dintre cele mai stricte — respinge codul care în C++ ar provoca comportament nedefinit.

Rust se compilează prin LLVM în cod nativ pentru toate arhitecturile: ARM, x86, RISC-V, WebAssembly. Instrumente: rustup (instalator), rustc (compilator), cargo (manager de pachete și constructor). cargo.toml — analogul package.json, conține dependințe din crates.io. Versiunea curentă — Rust 1.81 (2025).

Domenii cheie de aplicare a Rust în dezvoltarea mobilă: biblioteci native (Android NDK, iOS), SDK-uri multi-platformă (Firefox, Dropbox), înlocuirea C++ în secțiunile performance-critical, WebAssembly pentru aplicații hibride. Google folosește Rust în AOSP (Android Open Source Project) pentru componentele Bluetooth, Wi-Fi și NFC.

Instalarea și configurarea Rust pentru dezvoltare mobilă

Pentru cross-compilare sub Android sunt necesare toolchain-uri țintă: rustup target add aarch64-linux-android armv7-linux-androideabi. Pentru iOS — aarch64-apple-ios x86_64-apple-ios. cargo-ndk (pentru Android) și cargo-lipo (pentru iOS) simplifică construirea.

# Instalarea Rust și a platformelor țintă pentru dezvoltare mobilă
$ 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

# Instalarea cargo-ndk pentru construirea Android
$ cargo install cargo-ndk

# Construirea pentru Android
$ cargo ndk -t arm64-v8a -o ./jniLibs build --release

Sistemul de ownership: ownership, borrowing și lifetimes

Ownership (posesiunea) — conceptul fundamental al Rust. Fiecare valoare are exact un proprietar. La atribuire sau transmitere către o funcție, posesia este transferată (move). După transfer, vechiul proprietar nu poate folosi valoarea. Aceasta elimină dubla eliberare a memoriei și pointerii dangling.

Borrowing (împrumutul) permite utilizarea temporară a unei referințe la o valoare fără transferul posesiei. Referința &T (imutabilă) — oricâți cititori. Referința &mut T (mutabilă) — exact un scriitor, fără cititori. Compilatorul verifică aceste reguli în faza de construire.

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

    let first = &numbers[0];  // împrumut imutabil
    println!("Primul: {}", first);
}

process_data primește o referință mutabilă la Vec și dublează fiecare element. iter_mut() returnează un iterator cu referințe mutabile. *item dereferențiază referința pentru atribuire. După process_data, numbers rămâne accesibil — posesia nu a fost transferată, ci doar împrumutată.

Lifetimes: durata de viață a referințelor

Lifetimes ('a) — adnotări pentru legarea duratelor de viață ale referințelor. Compilatorul le folosește pentru a verifica dacă referința nu supraviețuiește datelor la care indică. În majoritatea cazurilor, lifetimes sunt deduse automat — trebuie specificate doar în semnăturile funcțiilor cu referințe.

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!("Cel mai lung: {}", result);
    } // string2 trăiește până la această paranteză, result este valid în interior
    // println!("{}", result); // eroare: string2 a murit
}

Rust pentru module native Android și iOS

Rust se compilează în biblioteci native pentru Android (.so prin NDK) și iOS (.a biblioteci statice). Google suportă oficial Rust în Android Open Source Project (AOSP) — în Rust sunt scrise componentele Bluetooth (ava), DNS-over-HTTP3 și CriticalNotification. Conform Google (2025), Rust în Android a eliminat 70% din vulnerabilitățile de memorie în componentele țintă.

Pentru Android se folosește cargo-ndk, care îmbracă Cargo cu toolchain-ul corect pentru ABI-ul selectat. Construirea pentru Android include: aarch64-linux-android (ARM 64-bit, dispozitive moderne), armv7-linux-androideabi (ARM 32-bit), x86_64-linux-android (emulatoare).

// Cargo.toml — configurația bibliotecii pentru 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 — pentru iOS (.a), cdylib — pentru Android (.so). serde — serializare pentru schimbul de date cu Kotlin/Swift. libc — tipuri compatibile C pentru FFI.

Exemplu: procesarea imaginii în Rust

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

/// Funcție compatibilă C pentru procesarea imaginii
#[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] dezactivează name mangling pentru ABI compatibil C. extern "C" setează convenția de apel C. unsafe — marker că apelul din afara Rust nu garantează securitatea. std::ptr::copy_nonoverlapping copiază octeții rezultatului în bufferul de ieșire.

SDK-uri multi-platformă în Rust

Rust — candidatul ideal pentru SDK-uri multi-platformă care funcționează pe Android și iOS dintr-o singură bază de cod. Companiile Mozilla (Firefox), Dropbox (sincronizare fișiere) și Meta (Libra blockchain) au ales Rust pentru componentele critice ale aplicațiilor lor mobile.

Avantajele bibliotecii Rust față de C++: compilatorul garantează absența scurgerilor de memorie și a curselor de date în codul multi-platformă. Codul scris și testat o dată în Rust funcționează identic pe toate platformele. Cargo gestionează dependințele nativ, fără CMake și vcpkg.

Rust și WebAssembly pentru aplicații mobile

Rust se compilează în WebAssembly (Wasm) — un format binar executabil în browser și pe dispozitive mobile. Wasm oferă performanță near-native în mediul web. În dezvoltarea mobilă, Wasm este folosit în aplicații hibride (WebView + Wasm) pentru calcule complexe: randare 3D, recunoaștere a imaginilor, criptare.

wasm-pack compilează Rust în .wasm și generează un înveliș JS. wasm-bindgen leagă funcțiile Rust cu apelurile JavaScript. Pe un dispozitiv mobil, Wasm-runner poate rula în WebView sau prin SDK-urile Wasmer/Wasmtime.

use wasm_bindgen::prelude::*;

/// Calculul numărului Fibonacci în Wasm (apelat din 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] generează un wrapper JavaScript pentru funcția fibonacci. În browser, apelul arată ca wasm.fibonacci(10). Tipurile u32/u64 sunt convertite automat în Number/BigInt. Modulul Wasm cântărește ~5 KB pentru o astfel de funcție — un overhead minim.

FFI: apelarea Rust din Kotlin și Swift

FFI (Foreign Function Interface) — mecanismul de apelare a codului Rust din alte limbaje. Funcțiile Rust cu extern "C" și #[no_mangle] sunt exportate cu ABI compatibil C. Din Kotlin, astfel de funcții sunt apelate prin JNI, din Swift — prin @_cdecl ("name") sau CBridge.h.

UniFFI — instrumentul Mozilla pentru generarea legăturilor FFI. Descrieți API-ul într-un fișier .udl, iar UniFFI generează automat wrappere Kotlin și Swift. Aceasta este abordarea standard pentru componentele Rust în Firefox Android și Firefox iOS.

// Bibliotecă Rust cu interfață 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> {
    // implementare AES-256-GCM
    todo!()
}

UniFFI generează o clasă Kotlin cu metoda encrypt, care primește ByteArray și returnează EncryptedData. În Swift se creează o structură EncryptedData cu câmpurile ciphertext (Data) și nonce (Data). Erorile sunt transformate în excepții Kotlin/Swift.

Rust vs C++: comparație pentru dezvoltare mobilă

Rust și C++ — cele două limbaje principale pentru programarea de sistem în dezvoltarea mobilă. Ambele se compilează în cod nativ pentru ARM și suportă FFI prin C ABI. Diferența principală — modelul de securitate a memoriei: Rust o verifică la compilare, C++ se bazează pe disciplina programatorului.

Rust este mai sigur decât C++ și mai productiv — compilatorul prinde erori care în C++ s-ar manifesta în runtime. C++ are un ecosistem mai bogat de biblioteci mobile. Pentru proiecte noi, Rust este preferat; codul C++ existent este portat treptat.