Rust inom mobilutveckling: nativa moduler och plattformsoberoende SDK

Vad är Rust?

Rust — ett statiskt typat systemprogrammeringsspråk med nollkostnadsabstraktioner (zero-cost abstractions). Rust garanterar minnessäkerhet utan skräpsamlare tack vare systemet med ägarskap (ownership), lån (borrowing) och livslängder (lifetimes). Rust-kompilatorn är en av de strängaste — den avvisar kod som i C++ skulle orsaka odefinierat beteende.

Rust kompileras via LLVM till nativ kod för alla arkitekturer: ARM, x86, RISC-V, WebAssembly. Verktyg: rustup (installatör), rustc (kompilator), cargo (pakethanterare och byggare). cargo.toml — analog till package.json, innehåller beroenden från crates.io. Aktuell version — Rust 1.81 (2025).

Nyckelområden för Rust inom mobilutveckling: nativa bibliotek (Android NDK, iOS), plattformsoberoende SDK (Firefox, Dropbox), ersättning av C++ i prestandakritiska delar, WebAssembly för hybridappar. Google använder Rust i AOSP (Android Open Source Project) för Bluetooth-, Wi-Fi- och NFC-komponenter.

Installation och konfiguration av Rust för mobilutveckling

För korskompilering för Android behövs målverktygskedjor: rustup target add aarch64-linux-android armv7-linux-androideabi. För iOS — aarch64-apple-ios x86_64-apple-ios. cargo-ndk (för Android) och cargo-lipo (för iOS) förenklar bygget.

# Installation av Rust och målplattformar för mobilutveckling
$ 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 av cargo-ndk för Android-bygge
$ cargo install cargo-ndk

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

Ägarskapssystem: ownership, borrowing och lifetimes

Ownership (ägarskap) — det grundläggande konceptet i Rust. Varje värde har exakt en ägare. Vid tilldelning eller överföring till en funktion flyttas ägarskapet (move). Efter flytten kan den gamla ägaren inte använda värdet. Detta eliminerar dubbel frigöring av minne och dinglande pekare.

Borrowing (lån) gör det möjligt att tillfälligt använda en referens till ett värde utan att överföra ägarskap. Referens &T (oföränderlig) — valfritt antal läsare. Referens &mut T (föränderlig) — exakt en skribent, inga läsare. Kompilatorn kontrollerar dessa regler i byggfasen.

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

    let first = &numbers[0];  // oföränderligt lån
    println!("Första: {}", first);
}

process_data tar en föränderlig referens till Vec och dubblar varje element. iter_mut() returnerar en iterator med föränderliga referenser. *item avrefererar referensen för tilldelning. Efter process_data är numbers fortfarande tillgängligt — ägarskapet överfördes inte, bara lånades.

Lifetimes: referensers livslängd

Lifetimes ('a) — annoteringar för att binda referensers livslängder. Kompilatorn använder dem för att kontrollera att referensen inte överlever de data den pekar på. I de flesta fall härleds lifetimes automatiskt — de behöver bara anges i funktionssignaturer med referenser.

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!("Längst: {}", result);
    } // string2 lever till denna parentes, result är giltigt inuti
    // println!("{}", result); // fel: string2 dog
}

Rust för nativa Android- och iOS-moduler

Rust kompileras till nativa bibliotek för Android (.so via NDK) och iOS (.a statiska bibliotek). Google stöder officiellt Rust i Android Open Source Project (AOSP) — Bluetooth (ava), DNS-over-HTTP3 och CriticalNotification är skrivna i Rust. Enligt Google (2025) har Rust i Android eliminerat 70 % av minnessårbarheterna i målkomponenter.

För Android används cargo-ndk, som omsluter Cargo med rätt verktygskedja för valt ABI. Bygge för Android omfattar: aarch64-linux-android (64-bitars ARM, moderna enheter), armv7-linux-androideabi (32-bitars ARM), x86_64-linux-android (emulatorer).

// Cargo.toml — konfiguration av bibliotek 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 — serialisering för datautbyte med Kotlin/Swift. libc — C-kompatibla typer för FFI.

Exempel: bildbehandling i Rust

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

/// C-kompatibel funktion för bildbehandling
#[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] inaktiverar name mangling för C-kompatibelt ABI. extern "C" ställer in C-anropskonventionen. unsafe — markering att anrop utifrån Rust inte garanterar säkerhet. std::ptr::copy_nonoverlapping kopierar resultatets byte till utdatabufferten.

Plattformsoberoende SDK i Rust

Rust — den ideala kandidaten för plattformsoberoende SDK som fungerar på Android och iOS från en kodbas. Företagen Mozilla (Firefox), Dropbox (filsynkronisering) och Meta (Libra blockchain) har valt Rust för kritiska komponenter i sina mobilappar.

Fördelar med Rust-bibliotek jämfört med C++: kompilatorn garanterar frånvaro av minnesläckor och datakapplöpningar i plattformsoberoende kod. Kod som skrivits och testats en gång i Rust fungerar identiskt på alla plattformar. Cargo hanterar beroenden native, utan CMake och vcpkg.

Rust och WebAssembly för mobilappar

Rust kompileras till WebAssembly (Wasm) — ett binärt format som kan köras i webbläsaren och på mobila enheter. Wasm ger near-native prestanda i webbmiljön. Inom mobilutveckling används Wasm i hybridappar (WebView + Wasm) för komplexa beräkningar: 3D-rendering, bildigenkänning, kryptering.

wasm-pack kompilerar Rust till .wasm och genererar ett JS-omslag. wasm-bindgen kopplar Rust-funktioner till JavaScript-anrop. På en mobil enhet kan Wasm-runner köras i WebView eller via Wasmer/Wasmtime SDK.

use wasm_bindgen::prelude::*;

/// Beräkning av Fibonacci-tal i Wasm (anropas från 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] genererar ett JavaScript-omslag för funktionen fibonacci. I webbläsaren ser anropet ut som wasm.fibonacci(10). Typerna u32/u64 konverteras automatiskt till Number/BigInt. Wasm-modulen väger ~5 KB för en sådan funktion — minimal overhead.

FFI: anropa Rust från Kotlin och Swift

FFI (Foreign Function Interface) — mekanismen för att anropa Rust-kod från andra språk. Rust-funktioner med extern "C" och #[no_mangle] exporteras med C-kompatibelt ABI. Från Kotlin anropas sådana funktioner via JNI, från Swift — via @_cdecl ("name") eller CBridge.h.

UniFFI — Mozillas verktyg för att generera FFI-bindningar. Du beskriver API:t i en .udl-fil, UniFFI genererar automatiskt Kotlin- och Swift-omslag. Detta är standardmetoden för Rust-komponenter i Firefox Android och Firefox iOS.

// Rust-bibliotek med UniFFI-gränssnitt
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> {
    // implementering av AES-256-GCM
    todo!()
}

UniFFI genererar en Kotlin-klass med metoden encrypt som tar emot ByteArray och returnerar EncryptedData. I Swift skapas en struct EncryptedData med fälten ciphertext (Data) och nonce (Data). Fel omvandlas till Kotlin/Swift-undantag.

Rust mot C++: jämförelse för mobilutveckling

Rust och C++ — de två huvudspråken för systemprogrammering inom mobilutveckling. Båda kompileras till nativ kod för ARM och stöder FFI via C ABI. Huvudskillnaden — modellen för minnessäkerhet: Rust kontrollerar den vid kompilering, C++ förlitar sig på utvecklarens disciplin.

Rust är säkrare än C++ och mer produktivt — kompilatorn fångar fel som i C++ skulle uppträda vid körning. C++ har ett rikare ekosystem av mobila bibliotek. För nya projekt är Rust att föredra; befintlig C++-kod portas gradvis.