Rust a mobilfejlesztésben: natív modulok és platformfüggetlen SDK-k

Mi az a Rust?

Rust — egy statikusan típusos rendszerprogramozási nyelv nulla költségű absztrakciókkal (zero-cost abstractions). A Rust memóriabiztonságot garantál szemétgyűjtő nélkül a tulajdonlási (ownership), kölcsönzési (borrowing) és élettartam (lifetimes) rendszernek köszönhetően. A Rust fordító az egyik legszigorúbb — elutasítja azt a kódot, amely C++-ban nem definiált viselkedést okozna.

A Rust LLVM-en keresztül natív kóddá fordul minden architektúrára: ARM, x86, RISC-V, WebAssembly. Eszközök: rustup (telepítő), rustc (fordító), cargo (csomagkezelő és építő). A cargo.toml a package.json analógja, függőségeket tartalmaz a crates.io-ból. Jelenlegi verzió — Rust 1.81 (2025).

A Rust mobilfejlesztésben való alkalmazásának kulcsterületei: natív könyvtárak (Android NDK, iOS), platformfüggetlen SDK-k (Firefox, Dropbox), a C++ helyettesítése performance-critical részeken, WebAssembly hibrid alkalmazásokhoz. A Google a Rust-ot használja az AOSP-ben (Android Open Source Project) a Bluetooth, Wi-Fi és NFC komponensekhez.

A Rust telepítése és konfigurálása mobilfejlesztéshez

Az Androidhoz való keresztfordításhoz cél-toolchain-ek szükségesek: rustup target add aarch64-linux-android armv7-linux-androideabi. iOS-hez — aarch64-apple-ios x86_64-apple-ios. A cargo-ndk (Androidhoz) és a cargo-lipo (iOS-hez) egyszerűsítik az építést.

# Rust és célplatformok telepítése mobilfejlesztéshez
$ 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 telepítése Android építéshez
$ cargo install cargo-ndk

# Építés Androidra
$ cargo ndk -t arm64-v8a -o ./jniLibs build --release

Tulajdonlási rendszer: ownership, borrowing és lifetimes

Ownership (tulajdonlás) — a Rust alapvető fogalma. Minden értéknek pontosan egy tulajdonosa van. Hozzárendeléskor vagy függvénybe adáskor a tulajdonlás átkerül (move). Az átkerülés után a régi tulajdonos nem használhatja az értéket. Ez kiküszöböli a memória dupla felszabadítását és a lógó pointereket.

Borrowing (kölcsönzés) lehetővé teszi egy értékre mutató referenciák ideiglenes használatát a tulajdonlás átadása nélkül. &T referencia (immutable) — tetszőleges számú olvasó. &mut T referencia (mutable) — pontosan egy író, olvasók nélkül. A fordító ezeket a szabályokat az építési fázisban ellenőrzi.

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

    let first = &numbers[0];  // immutable kölcsönzés
    println!("Első: {}", first);
}

A process_data egy mutable referenciát fogad Vec-re és megduplázza az egyes elemeket. Az iter_mut() egy iterátort ad vissza mutable referenciákkal. A *item dereferencia a referenciát a hozzárendeléshez. A process_data után a numbers elérhető marad — a tulajdonlás nem került átadásra, csak kölcsönzésre.

Lifetimes: a referenciák élettartama

Lifetimes ('a) — annotációk a referenciák élettartamának összekapcsolásához. A fordító ezeket használja annak ellenőrzésére, hogy a referencia nem éli túl az adatokat, amelyekre mutat. A legtöbb esetben a lifetimes automatikusan kikövetkeztethető — csak a referenciákkal rendelkező függvények aláírásaiban kell megadni.

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!("Leghosszabb: {}", result);
    } // a string2 eddig a zárójelig él, a result belül érvényes
    // println!("{}", result); // hiba: a string2 meghalt
}

Rust Android és iOS natív modulokhoz

Rust natív könyvtárakká fordul Androidhoz (.so az NDK-n keresztül) és iOS-hez (.a statikus könyvtárak). A Google hivatalosan támogatja a Rust-ot az Android Open Source Project-ben (AOSP) — a Bluetooth (ava), DNS-over-HTTP3 és CriticalNotification komponensek Rust-ban íródtak. A Google (2025) szerint a Rust az Androidban 70%-kal csökkentette a memória-sebezhetőségeket a célkomponensekben.

Androidhoz a cargo-ndk-t használják, amely a Cargo-t a kiválasztott ABI-hoz megfelelő toolchain-nel burkolja. Az Androidos építés magában foglalja: aarch64-linux-android (64-bit ARM, modern eszközök), armv7-linux-androideabi (32-bit ARM), x86_64-linux-android (emulátorok).

// Cargo.toml — könyvtár konfigurációja Android/iOS rendszerekhez
[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-hez (.a), cdylib — Androidhoz (.so). serde — szerializáció adatcseréhez Kotlin/Swift nyelvekkel. libc — C-kompatibilis típusok az FFI-hez.

Példa: képfeldolgozás Rust-ban

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

/// C-kompatibilis függvény képfeldolgozáshoz
#[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] kikapcsolja a name mangling-et a C-kompatibilis ABI-hoz. extern "C" beállítja a C hívási konvenciót. unsafe — jelző, hogy a Rust-on kívüli hívás nem garantálja a biztonságot. std::ptr::copy_nonoverlapping átmásolja az eredmény bájtjait a kimeneti pufferbe.

Platformfüggetlen SDK-k Rust-ban

Rust — ideális jelölt platformfüggetlen SDK-khoz, amelyek Androidon és iOS-en futnak egyetlen kódbázisból. A Mozilla (Firefox), Dropbox (fájlszinkronizálás) és Meta (Libra blockchain) cégek a Rust-ot választották mobilalkalmazásaik kritikus komponenseihez.

A Rust könyvtár előnyei a C++-hoz képest: a fordító garantálja a memóriaszivárgások és adatversenyek hiányát a platformfüggetlen kódban. A Rust-ban egyszer megírt és tesztelt kód minden platformon azonosan működik. A Cargo natívan kezeli a függőségeket, CMake és vcpkg nélkül.

Rust és WebAssembly mobilalkalmazásokhoz

Rust WebAssembly-vé (Wasm) fordul — egy bináris formátummá, amely böngészőben és mobileszközökön végrehajtható. A Wasm near-native teljesítményt nyújt a webes környezetben. A mobilfejlesztésben a Wasm-ot hibrid alkalmazásokban (WebView + Wasm) használják összetett számításokhoz: 3D megjelenítés, képfelismerés, titkosítás.

A wasm-pack Rust-ot .wasm-mé fordít és JS burkolót generál. A wasm-bindgen összeköti a Rust függvényeket JavaScript-hívásokkal. Mobileszközön a Wasm-runner futhat WebView-ban vagy Wasmer/Wasmtime SDK-n keresztül.

use wasm_bindgen::prelude::*;

/// Fibonacci-szám számítása Wasm-ban (JS-ből hívva)
#[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 burkolót generál a fibonacci függvényhez. Böngészőben a hívás így néz ki: wasm.fibonacci(10). Az u32/u64 típusok automatikusan Number/BigInt-té alakulnak. A Wasm modul ~5 KB súlyú egy ilyen függvényhez — minimális többletterhelés.

FFI: Rust hívása Kotlin és Swift nyelvekből

FFI (Foreign Function Interface) — a Rust-kód más nyelvekből való hívásának mechanizmusa. Az extern "C" és #[no_mangle] deklarációval ellátott Rust függvények C-kompatibilis ABI-val exportálódnak. Kotlinból az ilyen függvények JNI-n keresztül, Swiftből @_cdecl ("name") vagy CBridge.h segítségével hívhatók.

UniFFI — a Mozilla eszköze FFI-kötések generálásához. Leírja az API-t egy .udl fájlban, az UniFFI automatikusan generál Kotlin és Swift burkolókat. Ez a standard megközelítés a Rust komponensekhez a Firefox Androidban és Firefox iOS-ben.

// Rust könyvtár UniFFI interfésszel
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 implementáció
    todo!()
}

Az UniFFI egy Kotlin osztályt generál az encrypt metódussal, amely ByteArray-t fogad és EncryptedData-t ad vissza. Swift-ben egy EncryptedData struktúra jön létre ciphertext (Data) és nonce (Data) mezőkkel. A hibák Kotlin/Swift kivételekké alakulnak.

Rust kontra C++: összehasonlítás mobilfejlesztéshez

Rust és C++ — a két fő nyelv a rendszerprogramozáshoz a mobilfejlesztésben. Mindkettő natív kóddá fordul ARM-re és támogatja az FFI-t C ABI-n keresztül. A fő különbség — a memóriabiztonsági modell: a Rust ezt fordítási időben ellenőrzi, a C++ a fejlesztő fegyelmére hagyatkozik.

A Rust biztonságosabb, mint a C++ és termelékenyebb — a fordító elkapja azokat a hibákat, amelyek a C++-ban futásidőben jelentkeznének. A C++ gazdagabb mobil könyvtár ökoszisztémával rendelkezik. Új projektekhez a Rust az előnyösebb; a meglévő C++ kódot fokozatosan portolják.