Rust v mobilním vývoji: nativní moduly a multiplatformní SDK

Co je Rust?

Rust — staticky typovaný systémový programovací jazyk s nulovou abstrakcí (zero-cost abstractions). Rust zaručuje bezpečnost paměti bez garbage collectoru díky systému vlastnictví (ownership), výpůjček (borrowing) a životností (lifetimes). Kompilátor Rustu je jedním z nejpřísnějších — odmítá kód, který by v C++ způsobil nedefinované chování.

Rust se kompiluje přes LLVM do nativního kódu pro všechny architektury: ARM, x86, RISC-V, WebAssembly. Nástroje: rustup (instalátor), rustc (kompilátor), cargo (správce balíčků a stavitel). cargo.toml — analogie package.json, obsahuje závislosti z crates.io. Aktuální verze — Rust 1.81 (2025).

Klíčové oblasti použití Rustu v mobilním vývoji: nativní knihovny (Android NDK, iOS), multiplatformní SDK (Firefox, Dropbox), nahrazení C++ v performance-critical částech, WebAssembly pro hybridní aplikace. Google používá Rust v AOSP (Android Open Source Project) pro komponenty Bluetooth, Wi-Fi a NFC.

Instalace a konfigurace Rustu pro mobilní vývoj

Pro cross-kompilaci pro Android jsou potřeba cílové toolchainy: rustup target add aarch64-linux-android armv7-linux-androideabi. Pro iOS — aarch64-apple-ios x86_64-apple-ios. cargo-ndk (pro Android) a cargo-lipo (pro iOS) zjednodušují sestavení.

# Instalace Rustu a cílových platforem pro mobilní vývoj
$ 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

# Instalace cargo-ndk pro sestavení pro Android
$ cargo install cargo-ndk

# Sestavení pro Android
$ cargo ndk -t arm64-v8a -o ./jniLibs build --release

Systém vlastnictví: ownership, borrowing a lifetimes

Ownership (vlastnictví) — základní koncept Rustu. Každá hodnota má právě jednoho vlastníka. Při přiřazení nebo předání funkci je vlastnictví přesunuto (move). Po přesunu nemůže starý vlastník hodnotu používat. To eliminuje dvojité uvolnění paměti a visící ukazatele.

Borrowing (výpůjčka) umožňuje dočasné použití reference na hodnotu bez přesunu vlastnictví. Reference &T (neměnná) — libovolný počet čtenářů. Reference &mut T (měnná) — právě jeden zapisovatel, bez čtenářů. Kompilátor tato pravidla kontroluje ve fázi sestavení.

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

    let first = &numbers[0];  // neměnná výpůjčka
    println!("První: {}", first);
}

process_data přijímá měnnou referenci na Vec a zdvojnásobuje každý prvek. iter_mut() vrací iterátor s měnnými referencemi. *item dereferencuje referenci pro přiřazení. Po process_data zůstává numbers přístupný — vlastnictví nebylo přesunuto, pouze vypůjčeno.

Lifetimes: životnost referencí

Lifetimes ('a) — anotace pro svázání životností referencí. Kompilátor je používá ke kontrole, že reference nežije déle než data, na která ukazuje. Ve většině případů jsou lifetimes odvozeny automaticky — je třeba je uvádět pouze v signaturách funkcí s referencemi.

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!("Nejdelší: {}", result);
    } // string2 žije do této závorky, result je platný uvnitř
    // println!("{}", result); // chyba: string2 zemřel
}

Rust pro nativní moduly Android a iOS

Rust se kompiluje do nativních knihoven pro Android (.so přes NDK) a iOS (.a statické knihovny). Google oficiálně podporuje Rust v Android Open Source Project (AOSP) — v Rustu jsou napsány komponenty Bluetooth (ava), DNS-over-HTTP3 a CriticalNotification. Podle Google (2025) Rust v Androidu eliminoval 70 % paměťových zranitelností v cílových komponentech.

Pro Android se používá cargo-ndk, který obaluje Cargo se správným toolchainem pro vybrané ABI. Sestavení pro Android zahrnuje: aarch64-linux-android (64-bit ARM, moderní zařízení), armv7-linux-androideabi (32-bit ARM), x86_64-linux-android (emulátory).

// Cargo.toml — konfigurace knihovny pro 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 — pro iOS (.a), cdylib — pro Android (.so). serde — serializace pro výměnu dat s Kotlinem/Swiftem. libc — C-kompatibilní typy pro FFI.

Příklad: zpracování obrazu v Rustu

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

/// C-kompatibilní funkce pro zpracování obrazu
#[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] vypíná name mangling pro C-kompatibilní ABI. extern "C" nastavuje C konvenci volání. unsafe — značka, že volání z vnějšku Rustu nezaručuje bezpečnost. std::ptr::copy_nonoverlapping kopíruje bajty výsledku do výstupního bufferu.

Multiplatformní SDK v Rustu

Rust — ideální kandidát pro multiplatformní SDK fungující na Androidu a iOS z jedné kódové báze. Společnosti Mozilla (Firefox), Dropbox (synchronizace souborů) a Meta (Libra blockchain) zvolily Rust pro kritické komponenty svých mobilních aplikací.

Výhody Rust knihovny oproti C++: kompilátor zaručuje absenci úniků paměti a datových závitů v multiplatformním kódu. Kód napsaný a otestovaný jednou v Rustu funguje stejně na všech platformách. Cargo spravuje závislosti nativně, bez CMake a vcpkg.

Rust a WebAssembly pro mobilní aplikace

Rust se kompiluje do WebAssembly (Wasm) — binárního formátu spustitelného v prohlížeči a na mobilních zařízeních. Wasm poskytuje výkon near-native ve webovém prostředí. V mobilním vývoji se Wasm používá v hybridních aplikacích (WebView + Wasm) pro složité výpočty: 3D rendering, rozpoznávání obrazu, šifrování.

wasm-pack kompiluje Rust do .wasm a generuje JS obálku. wasm-bindgen propojuje Rust funkce s JavaScriptovými voláními. Na mobilním zařízení může Wasm-runner běžet v WebView nebo přes SDK Wasmer/Wasmtime.

use wasm_bindgen::prelude::*;

/// Výpočet Fibonacciho čísla ve Wasmu (voláno z 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] generuje JavaScriptovou obálku pro funkci fibonacci. V prohlížeči volání vypadá jako wasm.fibonacci(10). Typy u32/u64 jsou automaticky konvertovány na Number/BigInt. Wasm modul váží ~5 KB pro takovou funkci — minimální režie.

FFI: volání Rustu z Kotlinu a Swiftu

FFI (Foreign Function Interface) — mechanismus volání Rust kódu z jiných jazyků. Rust funkce s extern "C" a #[no_mangle] jsou exportovány s C-kompatibilním ABI. Z Kotlinu se takové funkce volají přes JNI, ze Swiftu — přes @_cdecl ("name") nebo CBridge.h.

UniFFI — nástroj Mozilly pro generování FFI vazeb. Popíšete API v .udl souboru, UniFFI automaticky generuje Kotlin a Swift obálky. To je standardní přístup pro Rust komponenty ve Firefox Android a Firefox iOS.

// Rust knihovna s rozhraním 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> {
    // implementace AES-256-GCM
    todo!()
}

UniFFI generuje Kotlin třídu s metodou encrypt, která přijímá ByteArray a vrací EncryptedData. Ve Swiftu je vytvořena struct EncryptedData s poli ciphertext (Data) a nonce (Data). Chyby jsou převedeny na výjimky Kotlinu/Swiftu.

Rust vs C++: srovnání pro mobilní vývoj

Rust a C++ — dva hlavní jazyky pro systémové programování v mobilním vývoji. Oba se kompilují do nativního kódu pro ARM a podporují FFI přes C ABI. Hlavní rozdíl — model bezpečnosti paměti: Rust jej kontroluje v době kompilace, C++ spoléhá na disciplínu vývojáře.

Rust je bezpečnější než C++ a produktivnější — kompilátor zachytí chyby, které by se v C++ projevily za běhu. C++ má bohatší ekosystém mobilních knihoven. Pro nové projekty je Rust preferován; stávající C++ kód je portován postupně.