Rust in der mobilen Entwicklung: native Module und plattformübergreifende SDKs

Was ist Rust?

Rust ist eine statisch typisierte Systemprogrammiersprache mit Zero-Cost-Abstractions. Rust garantiert Speichersicherheit ohne Garbage Collector dank seines Ownership-, Borrowing- und Lifetimes-Systems. Der Rust-Compiler ist einer der strengsten: Er lehnt Code ab, der in C++ undefiniertes Verhalten verursachen würde.

Rust kompiliert über LLVM in nativen Code für alle Architekturen: ARM, x86, RISC-V, WebAssembly. Das Toolset umfasst: rustup (Installationsprogramm), rustc (Compiler), cargo (Paketmanager und Build-Tool). Cargo.toml — analog zu package.json, enthält Abhängigkeiten von crates.io. Die aktuelle stabile Version ist Rust 1.81 (2025).

Haupteinsatzbereiche von Rust in der mobilen Entwicklung: native Bibliotheken (Android NDK, iOS), plattformübergreifende SDKs (Firefox, Dropbox), Ersatz von C++ in leistungskritischen Bereichen, WebAssembly für hybride Anwendungen. Google verwendet Rust in AOSP (Android Open Source Project) für Bluetooth-, Wi-Fi- und NFC-Komponenten.

Installation und Konfiguration von Rust für die mobile Entwicklung

Für die Cross-Kompilierung nach Android werden Ziel-Toolchains benötigt: rustup target add aarch64-linux-android armv7-linux-androideabi. Für iOS — aarch64-apple-ios x86_64-apple-ios. cargo-ndk (für Android) und cargo-lipo (für iOS) vereinfachen den Build-Prozess.

# Installation von Rust und Zielplattformen für die mobile Entwicklung
$ 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

# Installation von cargo-ndk für Android-Builds
$ cargo install cargo-ndk

# Build für Android
$ cargo ndk -t arm64-v8a -o ./jniLibs build --release

Ownership-System: Ownership, Borrowing und Lifetimes

Ownership (Eigentümerschaft) ist das grundlegende Konzept von Rust. Jeder Wert hat genau einen Besitzer. Bei Zuweisung oder Übergabe an eine Funktion wird das Eigentum verschoben (move). Nach der Verschiebung kann der alte Besitzer den Wert nicht mehr verwenden. Dadurch werden doppelte Speicherfreigaben und baumelnde Zeiger vermieden.

Borrowing (Ausleihe) ermöglicht die temporäre Nutzung einer Referenz auf einen Wert ohne Übertragung des Eigentums. Die &T-Referenz (unveränderlich) — beliebig viele Leser. Die &mut T-Referenz (veränderlich) — genau ein Schreiber, keine Leser. Der Compiler prüft diese Regeln zur Kompilierzeit.

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

    let first = &numbers[0];  // unveränderliche Ausleihe
    println!("First: {}", first);
}

process_data nimmt eine veränderliche Referenz auf Vec und verdoppelt jedes Element. iter_mut() gibt einen Iterator mit veränderlichen Referenzen zurück. *item dereferenziert die Referenz für die Zuweisung. Nach process_data bleibt numbers zugänglich — das Eigentum wurde nicht übertragen, nur ausgeliehen.

Lifetimes: Lebensdauer von Referenzen

Lifetimes ('a) — Annotationen zur Verknüpfung der Lebensdauer von Referenzen. Der Compiler verwendet sie, um zu überprüfen, dass eine Referenz nicht länger lebt als die Daten, auf die sie zeigt. In den meisten Fällen werden Lifetimes automatisch abgeleitet — sie müssen nur in Funktionssignaturen mit Referenzen angegeben werden.

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!("Longest: {}", result);
    } // string2 lebt bis zu dieser Klammer, result ist innen gültig
    // println!("{}", result); // Fehler: string2 ist tot
}

Rust für native Android- und iOS-Module

Rust kompiliert in native Bibliotheken für Android (.so über NDK) und iOS (.a statische Bibliotheken). Google unterstützt Rust offiziell im Android Open Source Project (AOSP) — Rust wird für Bluetooth (ava), DNS-over-HTTP3 und CriticalNotification-Komponenten verwendet. Laut Google (2025) hat Rust in Android 70% der Speicherschwachstellen in den Zielkomponenten beseitigt.

Für Android wird cargo-ndk verwendet, das Cargo mit der richtigen Toolchain für das ausgewählte ABI umschließt. Der Build für Android umfasst: aarch64-linux-android (64-Bit-ARM, moderne Geräte), armv7-linux-androideabi (32-Bit-ARM), x86_64-linux-android (Emulatoren).

// Cargo.toml — Bibliothekskonfiguration für 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 — für iOS (.a), cdylib — für Android (.so). serde — Serialisierung für den Datenaustausch mit Kotlin/Swift. libc — C-kompatible Typen für FFI.

Beispiel: Bildverarbeitung in Rust

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

/// C-kompatible Funktion zur Bildverarbeitung
#[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] deaktiviert das Namens-Mangling für ein C-kompatibles ABI. extern "C" gibt die C-Aufrufkonvention an. unsafe — ein Marker, dass ein Aufruf von außerhalb von Rust keine Sicherheit garantiert. std::ptr::copy_nonoverlapping kopiert die Ergebnis-Bytes in den Ausgabepuffer.

Plattformübergreifende SDKs in Rust

Rust ist der ideale Kandidat für plattformübergreifende SDKs, die von einer einzigen Codebasis aus auf Android und iOS funktionieren. Unternehmen wie Mozilla (Firefox), Dropbox (Dateisynchronisation) und Meta (Libra-Blockchain) haben Rust für kritische Komponenten ihrer mobilen Anwendungen gewählt.

Vorteile von Rust-Bibliotheken gegenüber C++: Der Compiler garantiert das Fehlen von Speicherlecks und Datenrennen im plattformübergreifenden Code. Einmal in Rust geschriebener und getesteter Code funktioniert auf allen Plattformen identisch. Cargo verwaltet Abhängigkeiten nativ, ohne CMake oder vcpkg.

Rust und WebAssembly für mobile Apps

Rust kompiliert zu WebAssembly (Wasm) — einem binären Format, das im Browser und auf mobilen Geräten ausgeführt werden kann. Wasm bietet nahezu native Leistung in der Web-Umgebung. In der mobilen Entwicklung wird Wasm in hybriden Anwendungen (WebView + Wasm) für komplexe Berechnungen verwendet: 3D-Rendering, Bilderkennung, Verschlüsselung.

wasm-pack kompiliert Rust zu .wasm und generiert einen JS-Wrapper. wasm-bindgen verbindet Rust-Funktionen mit JavaScript-Aufrufen. Auf einem mobilen Gerät kann die Wasm-Laufzeitumgebung im WebView oder über das Wasmer/Wasmtime SDK ausgeführt werden.

use wasm_bindgen::prelude::*;

/// Berechnung von Fibonacci-Zahlen in Wasm (wird von JS aufgerufen)
#[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] generiert einen JavaScript-Wrapper für die Fibonacci-Funktion. Im Browser sieht der Aufruf wie wasm.fibonacci(10) aus. Die Typen u32/u64 werden automatisch in Number/BigInt konvertiert. Das Wasm-Modul wiegt nur ~5 KB für eine solche Funktion — minimaler Overhead.

FFI: Rust aus Kotlin und Swift aufrufen

FFI (Foreign Function Interface) — ein Mechanismus zum Aufruf von Rust-Code aus anderen Sprachen. Rust-Funktionen mit extern "C" und #[no_mangle] werden mit einem C-kompatiblen ABI exportiert. Aus Kotlin werden solche Funktionen über JNI aufgerufen, aus Swift — über @_cdecl ("name") oder CBridge.h.

UniFFI — ein Mozilla-Tool zur Generierung von FFI-Bindings. Sie beschreiben die API in einer .udl-Datei, und UniFFI generiert automatisch Kotlin- und Swift-Wrapper. Dies ist der Standardansatz für Rust-Komponenten in Firefox Android und Firefox iOS.

// Rust-Bibliothek mit UniFFI-Schnittstelle
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-Implementierung
    todo!()
}

UniFFI generiert eine Kotlin-Klasse mit der Methode encrypt, die ein ByteArray entgegennimmt und EncryptedData zurückgibt. In Swift wird eine EncryptedData-Struktur mit den Feldern ciphertext (Data) und nonce (Data) erstellt. Fehler werden in Kotlin/Swift-Ausnahmen umgewandelt.

Rust vs C++: Vergleich für die mobile Entwicklung

Rust und C++ sind die beiden wichtigsten Sprachen für die Systemprogrammierung in der mobilen Entwicklung. Beide kompilieren in nativen ARM-Code und unterstützen FFI über das C-ABI. Der Hauptunterschied ist das Speichersicherheitsmodell: Rust prüft es zur Kompilierzeit, C++ verlässt sich auf die Disziplin des Entwicklers.

Rust ist sicherer als C++ und produktiver — der Compiler fängt Fehler, die sich in C++ zur Laufzeit zeigen würden. C++ hat ein reichhaltigeres mobiles Bibliotheks-Ökosystem. Für neue Projekte ist Rust vorzuziehen; vorhandener C++-Code wird schrittweise portiert.