Mobil geliştirmede Rust: yerel modüller ve platformlar arası SDK

Rust Nedir?

Rust, sıfır maliyetli soyutlamalara (zero-cost abstractions) sahip statik tipli bir sistem programlama dilidir. Rust, sahiplik (ownership), ödünç alma (borrowing) ve yaşam süreleri (lifetimes) sistemi sayesinde çöp toplayıcı olmadan bellek güvenliğini garanti eder. Rust derleyicisi en katı derleyicilerden biridir: C++'da tanımsız davranışa neden olacak kodu reddeder.

Rust, LLVM aracılığıyla tüm mimariler için yerel koda derlenir: ARM, x86, RISC-V, WebAssembly. Araç seti şunları içerir: rustup (yükleyici), rustc (derleyici), cargo (paket yöneticisi ve derleme aracı). Cargo.toml — package.json'a benzer, crates.io'dan bağımlılıkları içerir. En son kararlı sürüm Rust 1.81'dir (2025).

Mobil geliştirmede Rust'ın temel uygulama alanları: yerel kütüphaneler (Android NDK, iOS), platformlar arası SDK (Firefox, Dropbox), performans kritik bölümlerde C++'ın yerini alma, hibrit uygulamalar için WebAssembly. Google, AOSP'de (Android Open Source Project) Bluetooth, Wi-Fi ve NFC bileşenleri için Rust kullanır.

Mobil geliştirme için Rust'ı kurma ve yapılandırma

Android için çapraz derleme için hedef araç zincirleri gerekir: rustup target add aarch64-linux-android armv7-linux-androideabi. iOS için — aarch64-apple-ios x86_64-apple-ios. cargo-ndk (Android için) ve cargo-lipo (iOS için) derleme sürecini basitleştirir.

# Mobil geliştirme için Rust ve hedef platformların kurulumu
$ 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 derlemesi için cargo-ndk kurulumu
$ cargo install cargo-ndk

# Android için derleme
$ cargo ndk -t arm64-v8a -o ./jniLibs build --release

Sahiplik sistemi: ownership, borrowing ve lifetimes

Ownership (sahiplik) Rust'ın temel kavramıdır. Her değerin tam olarak bir sahibi vardır. Atandığında veya bir fonksiyona geçirildiğinde, sahiplik taşınır (move). Taşıma işleminden sonra eski sahip değeri kullanamaz. Bu, çift bellek serbest bırakma ve sarkan işaretçileri ortadan kaldırır.

Borrowing (ödünç alma), sahipliği devretmeden bir değere geçici olarak referans kullanılmasına izin verir. &T referansı (değişmez) — herhangi sayıda okuyucu. &mut T referansı (değişebilir) — tam olarak bir yazıcı, okuyucu yok. Derleyici bu kuralları derleme zamanında kontrol eder.

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];  // değişmez ödünç alma
    println!("First: {}", first);
}

process_data, Vec'e değişebilir bir referans alır ve her öğeyi ikiye katlar. iter_mut(), değişebilir referanslarla bir yineleyici döndürür. *item, atama için referansı referanstan çıkarır. process_data'dan sonra numbers erişilebilir kalır — sahiplik taşınmadı, sadece ödünç alındı.

Lifetimes: referansların yaşam süresi

Lifetimes ('a) — referansların yaşam sürelerini birbirine bağlayan ek açıklamalardır. Derleyici, bir referansın işaret ettiği veriden daha uzun yaşamadığını doğrulamak için bunları kullanır. Çoğu durumda, lifetimes otomatik olarak çıkarılır — yalnızca referanslı fonksiyon imzalarında belirtmeniz gerekir.

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 bu paranteze kadar yaşar, result içinde geçerlidir
    // println!("{}", result); // hata: string2 öldü
}

Android ve iOS yerel modülleri için Rust

Rust, Android (.so, NDK aracılığıyla) ve iOS (.a statik kütüphaneler) için yerel kütüphanelere derlenir. Google, Android Open Source Project (AOSP)'te Rust'ı resmi olarak destekler — Rust, Bluetooth (ava), DNS-over-HTTP3 ve CriticalNotification bileşenleri için kullanılır. Google'a (2025) göre, Android'deki Rust, hedef bileşenlerdeki bellek güvenlik açıklarının %70'ini ortadan kaldırdı.

Android için, seçilen ABI için doğru araç zinciriyle Cargo'yu sarmalayan cargo-ndk kullanılır. Android için derleme şunları içerir: aarch64-linux-android (64-bit ARM, modern cihazlar), armv7-linux-androideabi (32-bit ARM), x86_64-linux-android (emülatörler).

// Cargo.toml — Android/iOS için kütüphane yapılandırması
[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) için, cdylib — Android (.so) için. serde — Kotlin/Swift ile veri alışverişi için serileştirme. libc — FFI için C uyumlu tipler.

Örnek: Rust'ta görüntü işleme

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

/// Görüntü işleme için C uyumlu fonksiyon
#[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 uyumlu ABI için ad karıştırmayı (name mangling) devre dışı bırakır. extern "C", C çağrı kuralını belirtir. unsafe — Rust dışından yapılan çağrının güvenliği garanti etmediğini belirten bir işaretleyici. std::ptr::copy_nonoverlapping, sonuç baytlarını çıktı arabelleğine kopyalar.

Rust'ta platformlar arası SDK

Rust, tek bir kod tabanından Android ve iOS'ta çalışan platformlar arası SDK'lar için ideal adaydır. Mozilla (Firefox), Dropbox (dosya senkronizasyonu) ve Meta (Libra blok zinciri) gibi şirketler, mobil uygulamalarının kritik bileşenleri için Rust'ı seçti.

Rust kütüphanelerinin C++'a göre avantajları: derleyici, platformlar arası kodda bellek sızıntısı ve veri yarışı olmadığını garanti eder. Rust'ta bir kez yazılıp test edilen kod tüm platformlarda aynı şekilde çalışır. Cargo, CMake veya vcpkg olmadan bağımlılıkları yerel olarak yönetir.

Mobil uygulamalar için Rust ve WebAssembly

Rust, WebAssembly (Wasm)'e derlenir — tarayıcıda ve mobil cihazlarda çalıştırılabilen ikili bir biçimdir. Wasm, web ortamında neredeyse yerel performans sunar. Mobil geliştirmede Wasm, karmaşık hesaplamalar (3D işleme, görüntü tanıma, şifreleme) için hibrit uygulamalarda (WebView + Wasm) kullanılır.

wasm-pack, Rust'ı .wasm'a derler ve bir JS sarmalayıcı oluşturur. wasm-bindgen, Rust fonksiyonlarını JavaScript çağrılarına bağlar. Bir mobil cihazda Wasm çalıştırıcısı, WebView içinde veya Wasmer/Wasmtime SDK aracılığıyla çalışabilir.

use wasm_bindgen::prelude::*;

/// Wasm'de Fibonacci sayılarının hesaplanması (JS'den ç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 fonksiyonu için bir JavaScript sarmalayıcı oluşturur. Tarayıcıda çağrı wasm.fibonacci(10) şeklinde görünür. u32/u64 türleri otomatik olarak Number/BigInt'e dönüştürülür. Böyle bir fonksiyon için Wasm modülü yalnızca ~5 KB ağırlığındadır — minimum ek yük.

FFI: Kotlin ve Swift'ten Rust'ı çağırma

FFI (Foreign Function Interface) — diğer dillerden Rust kodunu çağırmak için bir mekanizmadır. extern "C" ve #[no_mangle] ile Rust fonksiyonları, C uyumlu bir ABI ile dışa aktarılır. Kotlin'den bu fonksiyonlar JNI aracılığıyla, Swift'ten — @_cdecl ("name") veya CBridge.h aracılığıyla çağrılır.

UniFFI — FFI bağlamaları oluşturmak için bir Mozilla aracıdır. API'yi bir .udl dosyasında tanımlarsınız ve UniFFI otomatik olarak Kotlin ve Swift sarmalayıcıları oluşturur. Bu, Firefox Android ve Firefox iOS'taki Rust bileşenleri için standart yaklaşımdır.

// UniFFI arayüzlü Rust kütüphanesi
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 uygulaması
    todo!()
}

UniFFI, ByteArray alan ve EncryptedData döndüren encrypt yöntemine sahip bir Kotlin sınıfı oluşturur. Swift'te, ciphertext (Data) ve nonce (Data) alanlarına sahip EncryptedData yapısı oluşturulur. Hatalar Kotlin/Swift istisnalarına dönüştürülür.

Rust vs C++: mobil geliştirme için karşılaştırma

Rust ve C++, mobil geliştirmede sistem programlama için iki ana dildir. Her ikisi de ARM için yerel koda derlenir ve C ABI aracılığıyla FFI'yi destekler. Temel fark, bellek güvenliği modelidir: Rust derleme zamanında kontrol eder, C++ geliştirici disiplinine güvenir.

Rust, C++'tan daha güvenli ve daha üretkendir — derleyici, C++'ta çalışma zamanında ortaya çıkacak hataları yakalar. C++ daha zengin bir mobil kütüphane ekosistemine sahiptir. Yeni projeler için Rust tercih edilir; mevcut C++ kodu kademeli olarak taşınır.