Mobil inkişafda Rust: native modullar və platformalararası SDK

Rust nədir?

Rust — sıfır xərc abstraksiyaları (zero-cost abstractions) ilə statik tipli sistem proqramlaşdırma dilidir. Rust mülkiyyət (ownership), borc alma (borrowing) və ömürlük (lifetimes) sistemi sayəsində zibil yığıcısı olmadan yaddaş təhlükəsizliyini təmin edir. Rust kompilyatoru ən sərt kompilyatorlardan biridir — C++-da qeyri-müəyyən davranışa səbəb olacaq kodu rədd edir.

Rust LLVM vasitəsilə bütün arxitekturalar üçün native koduna kompilasiya olunur: ARM, x86, RISC-V, WebAssembly. Alətlər: rustup (qurucu), rustc (kompilyator), cargo (paket meneceri və qurucu). cargo.toml — package.json-un analoqudur, crates.io-dan asılılıqları ehtiva edir. Cari versiya — Rust 1.81 (2025).

Rust-un mobil inkişafda əsas tətbiq sahələri: native kitabxanalar (Android NDK, iOS), platformalararası SDK (Firefox, Dropbox), performance-critical hissələrdə C++-ın əvəz edilməsi, hibrid tətbiqlər üçün WebAssembly. Google AOSP-də (Android Open Source Project) Bluetooth, Wi-Fi və NFC komponentləri üçün Rust-dan istifadə edir.

Mobil inkişaf üçün Rust-un qurulması və konfiqurasiyası

Android üçün cross-kompilasiya üçün hədəf toolchain-lər lazımdır: rustup target add aarch64-linux-android armv7-linux-androideabi. iOS üçün — aarch64-apple-ios x86_64-apple-ios. cargo-ndk (Android üçün) və cargo-lipo (iOS üçün) qurulmanı asanlaşdırır.

# Mobil inkişaf üçün Rust və hədəf platformaların qurulması
$ 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 qurulması üçün cargo-ndk-nin qurulması
$ cargo install cargo-ndk

# Android altında qurulma
$ cargo ndk -t arm64-v8a -o ./jniLibs build --release

Mülkiyyət sistemi: ownership, borrowing və lifetimes

Ownership (mülkiyyət) — Rust-un əsas anlayışıdır. Hər bir dəyərin dəqiq bir sahibi var. Təyinat və ya funksiyaya ötürmə zamanı mülkiyyət köçürülür (move). Köçürmədən sonra köhnə sahib dəyərdən istifadə edə bilməz. Bu, yaddaşın ikiqat boşaldılmasını və asılı göstəriciləri aradan qaldırır.

Borrowing (borc alma) mülkiyyəti köçürmədən dəyərə müvəqqəti istinad etməyə imkan verir. &T istinadı (immutabəl) — istənilən sayda oxucu. &mut T istinadı (mutabəl) — dəqiq bir yazıçı, oxucu yoxdur. Kompilyator bu qaydaları qurulma mərhələsində yoxlayır.

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

    let first = &numbers[0];  // immutabəl borc alma
    println!("Birinci: {}", first);
}

process_data Vec-ə mutabəl istinad qəbul edir və hər bir elementi ikiqat artırır. iter_mut() mutabəl istinadlarla iterator qaytarır. *item təyinat üçün istinadı dereferens edir. process_data-dan sonra numbers əlçatan qalır — mülkiyyət köçürülməyib, yalnız borc alınıb.

Lifetimes: istinadların ömürlük müddəti

Lifetimes ('a) — istinadların ömürlük müddətlərini bağlamaq üçün annotasiyalar. Kompilyator onlardan istinadın göstərdiyi məlumatdan daha uzun yaşamadığını yoxlamaq üçün istifadə edir. Əksər hallarda lifetimes avtomatik çıxarılır — onları yalnız istinadları olan funksiya imzalarında göstərmək lazımdır.

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!("Ən uzun: {}", result);
    } // string2 bu mötərizəyə qədər yaşayır, result daxildə etibarlıdır
    // println!("{}", result); // xəta: string2 öldü
}

Android və iOS native modulları üçün Rust

Rust Android üçün native kitabxanalara (.so NDK vasitəsilə) və iOS üçün (.a statik kitabxanalar) kompilasiya olunur. Google Android Open Source Project (AOSP)-də Rust-ı rəsmi olaraq dəstəkləyir — Bluetooth (ava), DNS-over-HTTP3 və CriticalNotification komponentləri Rust-da yazılmışdır. Google (2025) məlumatlarına görə, Rust Android-də hədəf komponentlərdə yaddaş zəifliklərini 70% azaldıb.

Android üçün cargo-ndk istifadə olunur, o, seçilmiş ABI üçün düzgün toolchain ilə Cargo-nu sarır. Android altında qurulma daxildir: aarch64-linux-android (64-bit ARM, müasir cihazlar), armv7-linux-androideabi (32-bit ARM), x86_64-linux-android (emulyatorlar).

// Cargo.toml — Android/iOS üçün kitabxana konfiqurasiyası
[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 üçün (.a), cdylib — Android üçün (.so). serde — Kotlin/Swift ilə məlumat mübadiləsi üçün serializasiya. libc — FFI üçün C-uyğun tiplər.

Nümunə: Rust-da təsvirin işlənməsi

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

/// Təsvirin işlənməsi üçün C-uyğun 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-uyğun ABI üçün name mangling-i söndürür. extern "C" çağırış konvensiyasını təyin edir. unsafe — Rust xaricindən çağırışın təhlükəsizliyə zəmanət vermədiyini bildirən marker. std::ptr::copy_nonoverlapping nəticə baytlarını çıxış buferinə kopyalayır.

Rust-da platformalararası SDK

Rust — bir kod bazasından Android və iOS-da işləyən platformalararası SDK üçün ideal namizəddir. Mozilla (Firefox), Dropbox (fayl sinxronizasiyası) və Meta (Libra blockchain) şirkətləri mobil tətbiqlərinin kritik komponentləri üçün Rust-u seçmişlər.

Rust kitabxanasının C++ ilə müqayisədə üstünlükləri: kompilyator platformalararası kodda yaddaş sızmalarının və məlumat yarışlarının olmamasına zəmanət verir. Rust-da bir dəfə yazılmış və test edilmiş kod bütün platformalarda eyni işləyir. Cargo asılılıqları CMake və vcpkg olmadan native şəkildə idarə edir.

Rust və WebAssembly mobil tətbiqlər üçün

Rust WebAssembly (Wasm) — brauzerdə və mobil cihazlarda icra olunan ikili formata kompilasiya olunur. Wasm veb mühitdə near-native performans təmin edir. Mobil inkişafda Wasm hibrid tətbiqlərdə (WebView + Wasm) mürəkkəb hesablamalar üçün istifadə olunur: 3D renderinq, təsvirin tanınması, şifrələmə.

wasm-pack Rust-u .wasm-ə kompilasiya edir və JS sarğısı yaradır. wasm-bindgen Rust funksiyalarını JavaScript çağırışları ilə əlaqələndirir. Mobil cihazda Wasm-runner WebView-də və ya Wasmer/Wasmtime SDK vasitəsilə işlədilə bilər.

use wasm_bindgen::prelude::*;

/// Wasm-da Fibonaççi ədədinin hesablanması (JS-dən çağrılır)
#[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 funksiyası üçün JavaScript sarğısı yaradır. Brauzerdə çağırış wasm.fibonacci(10) kimi görünür. u32/u64 tipləri avtomatik olaraq Number/BigInt-ə çevrilir. Wasm modulu belə bir funksiya üçün ~5 KB çəkir — minimal overhead.

FFI: Rust-u Kotlin və Swift-dən çağırmaq

FFI (Foreign Function Interface) — Rust kodunu digər dillərdən çağırma mexanizmidir. extern "C" və #[no_mangle] ilə Rust funksiyaları C-uyğun ABI ilə ixrac olunur. Kotlin-dən belə funksiyalar JNI vasitəsilə, Swift-dən isə @_cdecl ("name") və ya CBridge.h vasitəsilə çağrılır.

UniFFI — FFI bağlamaları yaratmaq üçün Mozilla alətidir. API-ni .udl faylında təsvir edirsiniz, UniFFI avtomatik olaraq Kotlin və Swift sarğıları yaradır. Bu, Firefox Android və Firefox iOS-da Rust komponentləri üçün standart yanaşmadır.

// UniFFI interfeysi ilə Rust kitabxanası
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 tətbiqi
    todo!()
}

UniFFI ByteArray qəbul edən və EncryptedData qaytaran encrypt metodu ilə Kotlin sinfi yaradır. Swift-də ciphertext (Data) və nonce (Data) sahələri olan EncryptedData strukturu yaradılır. Xətalar Kotlin/Swift istisnalarına çevrilir.

Rust vs C++: mobil inkişaf üçün müqayisə

Rust və C++ — mobil inkişafda sistem proqramlaşdırması üçün iki əsas dildir. Hər ikisi ARM üçün native koduna kompilasiya olunur və C ABI vasitəsilə FFI dəstəkləyir. Əsas fərq — yaddaş təhlükəsizliyi modeli: Rust onu kompilasiya mərhələsində yoxlayır, C++ proqramçının intizamına güvənir.

Rust C++-dan daha təhlükəsiz və daha məhsuldardır — kompilyator C++-da icra zamanı ortaya çıxacaq səhvləri tutur. C++ daha zəngin mobil kitabxana ekosisteminə malikdir. Yeni layihələr üçün Rust üstünlük təşkil edir; mövcud C++ kodu tədricən port edilir.