Mobil ishlanmada Rust: native modullar va platformalararo SDK

Rust nima?

Rust — nol xarajat abstraksiyalari (zero-cost abstractions) bilan statik tipli tizim dasturlash tili. Rust egalik (ownership), qarz olish (borrowing) va umr davomiyligi (lifetimes) tizimi tufayli axlat yig'uvchisiz xotira xavfsizligini kafolatlaydi. Rust kompilyatori eng qattiq kompilyatorlardan biri — C++ da noaniq xatti-harakatga olib keladigan kodni rad etadi.

Rust LLVM orqali barcha arxitekturalar uchun native kodga kompilyatsiya qilinadi: ARM, x86, RISC-V, WebAssembly. Asboblar: rustup (o'rnatuvchi), rustc (kompilyator), cargo (paket menejeri va quruvchi). cargo.toml — package.json ning analogi, crates.io dan bog'liqliklarni o'z ichiga oladi. Joriy versiya — Rust 1.81 (2025).

Rust-ning mobil ishlanmadagi asosiy qo'llanish sohalari: native kutubxonalar (Android NDK, iOS), platformalararo SDK (Firefox, Dropbox), performance-critical qismlarda C++ ni almashtirish, gibrid ilovalar uchun WebAssembly. Google AOSP (Android Open Source Project) da Bluetooth, Wi-Fi va NFC komponentlari uchun Rust dan foydalanadi.

Mobil ishlanma uchun Rust-ni o'rnatish va sozlash

Android uchun o'zaro kompilyatsiya uchun maqsadli toolchain-lar kerak: rustup target add aarch64-linux-android armv7-linux-androideabi. iOS uchun — aarch64-apple-ios x86_64-apple-ios. cargo-ndk (Android uchun) va cargo-lipo (iOS uchun) qurilishni soddalashtiradi.

# Mobil ishlanma uchun Rust va maqsadli platformalarni o'rnatish
$ 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

# Android qurilishi uchun cargo-ndk ni o'rnatish
$ cargo install cargo-ndk

# Android uchun qurilish
$ cargo ndk -t arm64-v8a -o ./jniLibs build --release

Egalik tizimi: ownership, borrowing va lifetimes

Ownership (egalik) — Rust-ning asosiy tushunchasi. Har bir qiymatning aniq bir egasi bor. Tayinlash yoki funksiyaga uzatishda egalik ko'chiriladi (move). Ko'chirishdan so'ng eski egasi qiymatdan foydalana olmaydi. Bu xotirani ikki marta bo'shatish va osilib qolgan ko'rsatkichlarni yo'q qiladi.

Borrowing (qarz olish) egalikni ko'chirmasdan qiymatga vaqtinchalik havola qilish imkonini beradi. &T havolasi (o'zgarmas) — istalgancha o'quvchi. &mut T havolasi (o'zgaruvchan) — aniq bir yozuvchi, o'quvchilar yo'q. Kompilyator bu qoidalarni qurilish bosqichida tekshiradi.

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

    let first = &numbers[0];  // o'zgarmas qarz olish
    println!("Birinchi: {}", first);
}

process_data Vec ga o'zgaruvchan havola qabul qiladi va har bir elementni ikki barobarga oshiradi. iter_mut() o'zgaruvchan havolalar bilan iterator qaytaradi. *item tayinlash uchun havolani dereferens qiladi. process_data dan so'ng numbers mavjud bo'lib qoladi — egalik ko'chirilmagan, faqat qarz olingan.

Lifetimes: havolalarning umr davomiyligi

Lifetimes ('a) — havolalarning umr davomiyliklarini bog'lash uchun annotatsiyalar. Kompilyator ulardan havola ishora qilgan ma'lumotdan uzoqroq yashamasligini tekshirish uchun foydalanadi. Aksariyat hollarda lifetimes avtomatik ravishda chiqariladi — ularni faqat havolalari bo'lgan funksiya imzolarida ko'rsatish kerak.

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!("Eng uzun: {}", result);
    } // string2 bu qavsgacha yashaydi, result ichida haqiqiy
    // println!("{}", result); // xato: string2 o'ldi
}

Android va iOS native modullari uchun Rust

Rust Android uchun native kutubxonalarga (.so NDK orqali) va iOS uchun (.a statik kutubxonalar) kompilyatsiya qilinadi. Google Android Open Source Project (AOSP) da Rust-ni rasman qo'llab-quvvatlaydi — Bluetooth (ava), DNS-over-HTTP3 va CriticalNotification komponentlari Rust da yozilgan. Google (2025) ma'lumotlariga ko'ra, Rust Android da maqsadli komponentlarda xotira zaifliklarini 70% ga kamaytirdi.

Android uchun cargo-ndk ishlatiladi, u tanlangan ABI uchun to'g'ri toolchain bilan Cargo-ni o'rab oladi. Android uchun qurilish o'z ichiga oladi: aarch64-linux-android (64-bit ARM, zamonaviy qurilmalar), armv7-linux-androideabi (32-bit ARM), x86_64-linux-android (emulyatorlar).

// Cargo.toml — Android/iOS uchun kutubxona konfiguratsiyasi
[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 uchun (.a), cdylib — Android uchun (.so). serde — Kotlin/Swift bilan ma'lumot almashish uchun serializatsiya. libc — FFI uchun C-mos tiplar.

Misol: Rust da tasvirni qayta ishlash

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

/// Tasvirni qayta ishlash uchun C-mos funksiya
#[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] C-mos ABI uchun name mangling ni o'chiradi. extern "C" chaqirish konvensiyasini o'rnatadi. unsafe — Rust tashqarisidan chaqirish xavfsizlikni kafolatlamasligini bildiruvchi marker. std::ptr::copy_nonoverlapping natija baytlarini chiqish buferiga nusxalaydi.

Rust-da platformalararo SDK

Rust — bir kod bazasidan Android va iOS da ishlaydigan platformalararo SDK uchun ideal nomzod. Mozilla (Firefox), Dropbox (fayl sinxronizatsiyasi) va Meta (Libra blockchain) kompaniyalari mobil ilovalarining muhim komponentlari uchun Rust-ni tanlagan.

Rust kutubxonasining C++ ga nisbatan afzalliklari: kompilyator platformalararo kodda xotira oqishi va ma'lumotlar poygalari yo'qligini kafolatlaydi. Rust da bir marta yozilgan va sinovdan o'tgan kod barcha platformalarda bir xil ishlaydi. Cargo bog'liqliklarni CMake va vcpkg siz native boshqaradi.

Rust va WebAssembly mobil ilovalar uchun

Rust WebAssembly (Wasm) — brauzerda va mobil qurilmalarda bajariladigan ikkilik formatga kompilyatsiya qilinadi. Wasm veb muhitda near-native unumdorlikni ta'minlaydi. Mobil ishlanmada Wasm gibrid ilovalarda (WebView + Wasm) murakkab hisoblashlar uchun ishlatiladi: 3D renderlash, tasvirni tanib olish, shifrlash.

wasm-pack Rust-ni .wasm ga kompilyatsiya qiladi va JS o'ramini yaratadi. wasm-bindgen Rust funksiyalarini JavaScript chaqiruvlari bilan bog'laydi. Mobil qurilmada Wasm-runner WebView da yoki Wasmer/Wasmtime SDK orqali ishlashi mumkin.

use wasm_bindgen::prelude::*;

/// Wasm da Fibonachchi sonini hisoblash (JS dan chaqiriladi)
#[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] fibonacci funksiyasi uchun JavaScript o'ramini yaratadi. Brauzerda chaqiruv wasm.fibonacci(10) ko'rinishida bo'ladi. u32/u64 tiplari avtomatik ravishda Number/BigInt ga o'zgartiriladi. Wasm moduli bunday funksiya uchun ~5 KB og'irlikda — minimal qo'shimcha yuk.

FFI: Rust-ni Kotlin va Swift dan chaqirish

FFI (Foreign Function Interface) — Rust kodini boshqa tillardan chaqirish mexanizmi. extern "C" va #[no_mangle] bilan Rust funksiyalari C-mos ABI bilan eksport qilinadi. Kotlin dan bunday funksiyalar JNI orqali, Swift dan @_cdecl ("name") yoki CBridge.h orqali chaqiriladi.

UniFFI — FFI bog'lamalarini yaratish uchun Mozilla asbobi. API ni .udl faylida tasvirlaysiz, UniFFI avtomatik ravishda Kotlin va Swift o'ramlarini yaratadi. Bu Firefox Android va Firefox iOS da Rust komponentlari uchun standart yondashuvdir.

// UniFFI interfeysi bilan Rust kutubxonasi
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 implementatsiyasi
    todo!()
}

UniFFI ByteArray qabul qiluvchi va EncryptedData qaytaruvchi encrypt metodi bilan Kotlin sinfini yaratadi. Swift da ciphertext (Data) va nonce (Data) maydonlari bilan EncryptedData strukturasi yaratiladi. Xatolar Kotlin/Swift istisnolariga aylantiriladi.

Rust vs C++: mobil ishlanma uchun taqqoslash

Rust va C++ — mobil ishlanmada tizim dasturlash uchun ikkita asosiy til. Ikkalasi ARM uchun native kodga kompilyatsiya qilinadi va C ABI orqali FFI ni qo'llab-quvvatlaydi. Asosiy farq — xotira xavfsizligi modeli: Rust uni kompilyatsiya bosqichida tekshiradi, C++ dasturchining intizomiga tayanadi.

Rust C++ dan xavfsizroq va samaraliroq — kompilyator C++ da ish vaqtida paydo bo'ladigan xatolarni ushlaydi. C++ mobil kutubxonalarning boy ekotizimiga ega. Yangi loyihalar uchun Rust afzal; mavjud C++ kodi asta-sekin ko'chiriladi.