Rust в мобильной разработке: native-модули и кроссплатформенные SDK

Что такое Rust?

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

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

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

Установка и настройка Rust для мобильной разработки

Для кросс-компиляции под Android нужны целевые тулчейны: 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!("Processed: {:?}", numbers);

    let first = &numbers[0];  // иммутабельное заимствование
    println!("First: {}", 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!("Longest: {}", result);
    } // string2 живёт до этой скобки, result валиден внутри
    // println!("{}", result); // ошибка: string2 умер
}

Rust для native-модулей Android и iOS

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

Для Android используется cargo-ndk, который оборачивает Cargo с правильным тулчейном для выбранного 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 управляет зависимостями нативно, без 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 КБ для такой функции — минимальный 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++ — два основных языка для системного программирования в мобильной разработке. Оба компилируются в нативный код для ARM и поддерживают FFI через C ABI. Главное отличие — модель безопасности памяти: Rust проверяет её на этапе компиляции, C++ полагается на дисциплину разработчика.

Rust безопаснее C++ и продуктивнее — компилятор ловит ошибки, которые в C++ проявились бы в рантайме. C++ имеет более богатую экосистему мобильных библиотек. Для новых проектов Rust предпочтительнее; для существующих C++-код портируют постепенно.