Rust в мобилната разработка: native модули и междуплатформени SDK

Какво е Rust?

Rust — статично типизиран системен език за програмиране с нулева абстракция (zero-cost abstractions). Rust гарантира безопасност на паметта без garbage collector благодарение на системата за собственост (ownership), заемане (borrowing) и време на живот (lifetimes). Компилаторът на Rust е един от най-строгите — отхвърля код, който в C++ би предизвикал недефинирано поведение.

Rust се компилира чрез LLVM до native код за всички архитектури: ARM, x86, RISC-V, WebAssembly. Инструменти: rustup (инсталатор), rustc (компилатор), cargo (мениджър на пакети и строител). cargo.toml — аналог на package.json, съдържа зависимости от crates.io. Текуща версия — Rust 1.81 (2025).

Ключови области на приложение на Rust в мобилната разработка: native библиотеки (Android NDK, iOS), междуплатформени SDK (Firefox, Dropbox), замяна на C++ в критични за производителността участъци, WebAssembly за хибридни приложения. Google използва Rust в AOSP (Android Open Source Project) за компонентите Bluetooth, Wi-Fi и NFC.

Инсталиране и конфигуриране на Rust за мобилна разработка

За кръстосана компилация за Android са необходими целеви toolchain-ове: rustup target add aarch64-linux-android armv7-linux-androideabi. За iOS — aarch64-apple-ios x86_64-apple-ios. cargo-ndk (за Android) и cargo-lipo (за iOS) опростяват изграждането.

# Инсталиране на Rust и целеви платформи за мобилна разработка
$ 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 за Android изграждане
$ cargo install cargo-ndk

# Изграждане за Android
$ cargo ndk -t arm64-v8a -o ./jniLibs build --release

Система на собственост: ownership, borrowing и lifetimes

Ownership (собственост) — фундаменталното понятие на Rust. Всяка стойност има точно един собственик. При присвояване или предаване на функция, собствеността се прехвърля (move). След прехвърлянето старият собственик не може да използва стойността. Това елиминира двойното освобождаване на памет и висящите указатели.

Borrowing (заемане) позволява временно използване на референция към стойност без прехвърляне на собственост. Референция &T (непроменяема) — произволен брой читатели. Референция &mut T (променяема) — точно един писател, без читатели. Компилаторът проверява тези правила на етапа на изграждане.

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!("Обработено: {:?}", numbers);

    let first = &numbers[0];  // непроменяемо заемане
    println!("Първо: {}", first);
}

process_data приема променяема референция към Vec и удвоява всеки елемент. iter_mut() връща итератор с променяеми референции. *item дереференцира референцията за присвояване. След process_data, numbers остава достъпен — собствеността не е прехвърлена, а само заета.

Lifetimes: време на живот на референциите

Lifetimes ('a) — анотации за свързване на времената на живот на референциите. Компилаторът ги използва, за да провери дали референцията не надживява данните, към които сочи. В повечето случаи lifetimes се извеждат автоматично — трябва да се указват само в сигнатурите на функции с референции.

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!("Най-дълъг: {}", result);
    } // string2 живее до тази скоба, result е валиден вътре
    // println!("{}", result); // грешка: string2 умря
}

Rust за native модули на Android и iOS

Rust се компилира до native библиотеки за Android (.so чрез NDK) и iOS (.a статични библиотеки). Google официално поддържа Rust в Android Open Source Project (AOSP) — компонентите Bluetooth (ava), DNS-over-HTTP3 и CriticalNotification са написани на Rust. Според Google (2025), Rust в Android е елиминирал 70% от уязвимостите на паметта в целевите компоненти.

За Android се използва cargo-ndk, който обвива Cargo с правилния toolchain за избрания ABI. Изграждането за Android включва: aarch64-linux-android (64-bit ARM, съвременни устройства), armv7-linux-androideabi (32-bit ARM), x86_64-linux-android (емулатори).

// Cargo.toml — конфигурация на библиотека за 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 — за iOS (.a), cdylib — за Android (.so). serde — сериализация за обмен на данни с Kotlin/Swift. libc — C-съвместими типове за FFI.

Пример: обработка на изображение в Rust

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

/// C-съвместима функция за обработка на изображение
#[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] изключва name mangling за C-съвместим ABI. extern "C" задава C конвенция за извикване. unsafe — маркер, че извикването извън Rust не гарантира безопасност. std::ptr::copy_nonoverlapping копира байтовете на резултата в изходния буфер.

Междуплатформени SDK в Rust

Rust — идеалният кандидат за междуплатформени SDK, работещи на Android и iOS от една кодова база. Компаниите Mozilla (Firefox), Dropbox (синхронизация на файлове) и Meta (Libra blockchain) избраха Rust за критични компоненти на своите мобилни приложения.

Предимства на Rust библиотеката пред C++: компилаторът гарантира липса на изтичане на памет и състезания на данни в междуплатформен код. Код, написан и тестван веднъж на Rust, работи идентично на всички платформи. Cargo управлява зависимостите native, без CMake и vcpkg.

Rust и WebAssembly за мобилни приложения

Rust се компилира до WebAssembly (Wasm) — двоичен формат, изпълним в браузъра и на мобилни устройства. Wasm осигурява производителност near-native в уеб среда. В мобилната разработка Wasm се използва в хибридни приложения (WebView + Wasm) за сложни изчисления: 3D рендиране, разпознаване на образи, криптиране.

wasm-pack компилира Rust до .wasm и генерира JS обвивка. wasm-bindgen свързва Rust функции с JavaScript извиквания. На мобилно устройство Wasm-runner може да работи в WebView или чрез Wasmer/Wasmtime SDK.

use wasm_bindgen::prelude::*;

/// Изчисляване на число на Фибоначи в Wasm (извиква се от 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] генерира JavaScript обвивка за функцията fibonacci. В браузъра извикването изглежда като wasm.fibonacci(10). Типовете u32/u64 автоматично се конвертират в Number/BigInt. Wasm модулът тежи ~5 KB за такава функция — минимален overhead.

FFI: извикване на Rust от Kotlin и Swift

FFI (Foreign Function Interface) — механизмът за извикване на Rust код от други езици. Rust функции с extern "C" и #[no_mangle] се експортират с C-съвместим ABI. От Kotlin такива функции се извикват чрез JNI, от Swift — чрез @_cdecl ("name") или CBridge.h.

UniFFI — инструментът на Mozilla за генериране на FFI връзки. Описвате API в .udl файл, UniFFI автоматично генерира Kotlin и Swift обвивки. Това е стандартният подход за Rust компоненти във Firefox Android и Firefox iOS.

// Rust библиотека с 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> {
    // имплементация на AES-256-GCM
    todo!()
}

UniFFI генерира Kotlin клас с метод encrypt, който приема ByteArray и връща EncryptedData. В Swift се създава struct EncryptedData с полета ciphertext (Data) и nonce (Data). Грешките се преобразуват в изключения на Kotlin/Swift.

Rust срещу C++: сравнение за мобилна разработка

Rust и C++ — двата основни езика за системно програмиране в мобилната разработка. И двата се компилират до native код за ARM и поддържат FFI чрез C ABI. Основната разлика — моделът за безопасност на паметта: Rust го проверява на етапа на компилация, C++ разчита на дисциплината на разработчика.

Rust е по-безопасен от C++ и по-продуктивен — компилаторът хваща грешки, които в C++ биха се проявили по време на изпълнение. C++ има по-богата екосистема от мобилни библиотеки. За нови проекти Rust е предпочитан; съществуващият C++ код се пренася постепенно.