Rust in mobiele ontwikkeling: native modules en cross-platform SDK's

Wat is Rust?

Rust — een statisch getypeerde systeemprogrammeertaal met zero-cost abstractions. Rust garandeert geheugenveiligheid zonder garbage collector dankzij het systeem van ownership, borrowing en lifetimes. De Rust-compiler is een van de strengste — hij wijst code af die in C++ ongedefinieerd gedrag zou veroorzaken.

Rust compileert via LLVM naar native code voor alle architecturen: ARM, x86, RISC-V, WebAssembly. Tools: rustup (installatie), rustc (compiler), cargo (pakketbeheerder en bouwsysteem). cargo.toml — analoog aan package.json, bevat afhankelijkheden van crates.io. Huidige versie — Rust 1.81 (2025).

Belangrijkste toepassingsgebieden van Rust in mobiele ontwikkeling: native bibliotheken (Android NDK, iOS), cross-platform SDK's (Firefox, Dropbox), vervanging van C++ in performance-critical secties, WebAssembly voor hybride apps. Google gebruikt Rust in AOSP (Android Open Source Project) voor Bluetooth-, Wi-Fi- en NFC-componenten.

Installatie en configuratie van Rust voor mobiele ontwikkeling

Voor cross-compilatie naar Android zijn doel-toolchains nodig: rustup target add aarch64-linux-android armv7-linux-androideabi. Voor iOS — aarch64-apple-ios x86_64-apple-ios. cargo-ndk (voor Android) en cargo-lipo (voor iOS) vereenvoudigen de build.

# Installatie van Rust en doelplatformen voor mobiele ontwikkeling
$ 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

# Installatie van cargo-ndk voor Android-build
$ cargo install cargo-ndk

# Builden voor Android
$ cargo ndk -t arm64-v8a -o ./jniLibs build --release

Eigenaarschap: ownership, borrowing en lifetimes

Ownership (eigenaarschap) — het fundamentele concept van Rust. Elke waarde heeft precies één eigenaar. Bij toewijzing of overdracht aan een functie wordt het eigenaarschap verplaatst (move). Na verplaatsing kan de oude eigenaar de waarde niet meer gebruiken. Dit elimineert dubbel vrijgeven van geheugen en dangling pointers.

Borrowing (lenen) maakt tijdelijk gebruik van een referentie naar een waarde mogelijk zonder overdracht van eigenaarschap. Referentie &T (immutable) — onbeperkt aantal lezers. Referentie &mut T (mutable) — precies één schrijver, geen lezers. De compiler controleert deze regels tijdens de buildfase.

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

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

process_data neemt een mutable referentie naar Vec en verdubbelt elk element. iter_mut() retourneert een iterator met mutable referenties. *item derefereert de referentie voor toewijzing. Na process_data blijft numbers beschikbaar — eigenaarschap is niet verplaatst, alleen geleend.

Lifetimes: levensduur van referenties

Lifetimes ('a) — annotaties om levensduren van referenties te koppelen. De compiler gebruikt ze om te controleren of een referentie niet langer leeft dan de data waarnaar hij verwijst. In de meeste gevallen worden lifetimes automatisch afgeleid — ze moeten alleen worden opgegeven in functiehandtekeningen met referenties.

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!("Langste: {}", result);
    } // string2 leeft tot deze haak, result is geldig binnenin
    // println!("{}", result); // fout: string2 is dood
}

Rust voor native Android- en iOS-modules

Rust compileert naar native bibliotheken voor Android (.so via NDK) en iOS (.a statische bibliotheken). Google ondersteunt Rust officieel in Android Open Source Project (AOSP) — Bluetooth (ava), DNS-over-HTTP3 en CriticalNotification zijn in Rust geschreven. Volgens Google (2025) heeft Rust in Android 70% van de geheugenkwetsbaarheden in doelcomponenten geëlimineerd.

Voor Android wordt cargo-ndk gebruikt, dat Cargo omhult met de juiste toolchain voor de gekozen ABI. Builden voor Android omvat: aarch64-linux-android (64-bit ARM, moderne apparaten), armv7-linux-androideabi (32-bit ARM), x86_64-linux-android (emulators).

// Cargo.toml — configuratie van bibliotheek voor 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 — voor iOS (.a), cdylib — voor Android (.so). serde — serialisatie voor gegevensuitwisseling met Kotlin/Swift. libc — C-compatibele types voor FFI.

Voorbeeld: beeldverwerking in Rust

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

/// C-compatibele functie voor beeldverwerking
#[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] schakelt name mangling uit voor C-compatibele ABI. extern "C" stelt de C-aanroepconventie in. unsafe — markering dat aanroep van buiten Rust geen veiligheid garandeert. std::ptr::copy_nonoverlapping kopieert resultaatbytes naar de uitvoerbuffer.

Cross-platform SDK's in Rust

Rust — de ideale kandidaat voor cross-platform SDK's die op Android en iOS werken vanaf één codebase. Bedrijven als Mozilla (Firefox), Dropbox (bestandssynchronisatie) en Meta (Libra blockchain) hebben Rust gekozen voor kritieke componenten van hun mobiele apps.

Voordelen van een Rust-bibliotheek ten opzichte van C++: de compiler garandeert afwezigheid van geheugenlekken en dataraces in cross-platform code. Eenmaal geschreven en geteste code in Rust werkt identiek op alle platformen. Cargo beheert afhankelijkheden native, zonder CMake en vcpkg.

Rust en WebAssembly voor mobiele apps

Rust compileert naar WebAssembly (Wasm) — een binair formaat dat uitvoerbaar is in de browser en op mobiele apparaten. Wasm biedt near-native prestaties in de webomgeving. In mobiele ontwikkeling wordt Wasm gebruikt in hybride apps (WebView + Wasm) voor complexe berekeningen: 3D-rendering, beeldherkenning, encryptie.

wasm-pack compileert Rust naar .wasm en genereert een JS-wrapper. wasm-bindgen verbindt Rust-functies met JavaScript-aanroepen. Op een mobiel apparaat kan Wasm-runner draaien in WebView of via Wasmer/Wasmtime SDK's.

use wasm_bindgen::prelude::*;

/// Berekenen van Fibonacci-getal in Wasm (aangeroepen vanuit 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] genereert een JavaScript-wrapper voor de functie fibonacci. In de browser ziet de aanroep eruit als wasm.fibonacci(10). Types u32/u64 worden automatisch geconverteerd naar Number/BigInt. De Wasm-module weegt ~5 KB voor zo'n functie — minimale overhead.

FFI: Rust aanroepen vanuit Kotlin en Swift

FFI (Foreign Function Interface) — het mechanisme om Rust-code aan te roepen vanuit andere talen. Rust-functies met extern "C" en #[no_mangle] worden geëxporteerd met C-compatibele ABI. Vanuit Kotlin worden dergelijke functies aangeroepen via JNI, vanuit Swift via @_cdecl ("name") of CBridge.h.

UniFFI — Mozilla's tool voor het genereren van FFI-bindingen. Je beschrijft de API in een .udl-bestand, UniFFI genereert automatisch Kotlin- en Swift-wrappers. Dit is de standaardaanpak voor Rust-componenten in Firefox Android en Firefox iOS.

// Rust-bibliotheek met 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> {
    // implementatie van AES-256-GCM
    todo!()
}

UniFFI genereert een Kotlin-klasse met de methode encrypt die ByteArray ontvangt en EncryptedData retourneert. In Swift wordt een struct EncryptedData aangemaakt met velden ciphertext (Data) en nonce (Data). Fouten worden omgezet in Kotlin/Swift-uitzonderingen.

Rust versus C++: vergelijking voor mobiele ontwikkeling

Rust en C++ — de twee belangrijkste talen voor systeemprogrammeren in mobiele ontwikkeling. Beide compileren naar native code voor ARM en ondersteunen FFI via C ABI. Het belangrijkste verschil — het geheugenveiligheidsmodel: Rust controleert dit tijdens compilatie, C++ vertrouwt op de discipline van de ontwikkelaar.

Rust is veiliger dan C++ en productiever — de compiler vangt fouten die in C++ tijdens runtime zouden verschijnen. C++ heeft een rijker ecosysteem van mobiele bibliotheken. Voor nieuwe projecten heeft Rust de voorkeur; bestaande C++-code wordt geleidelijk geporteerd.