मोबाइल डेवलपमेंट में Rust: नेटिव मॉड्यूल और क्रॉस-प्लेटफ़ॉर्म SDK

Rust क्या है?

Rust जीरो-कॉस्ट एब्स्ट्रैक्शन वाली स्टैटिकली टाइप की गई सिस्टम प्रोग्रामिंग भाषा है। 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++ का प्रतिस्थापन, हाइब्रिड अनुप्रयोगों के लिए WebAssembly। Google AOSP (Android Open Source Project) में Bluetooth, Wi-Fi और NFC घटकों के लिए Rust का उपयोग करता है।

मोबाइल डेवलपमेंट के लिए 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

# Android बिल्ड के लिए cargo-ndk स्थापित करना
$ 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 मर गया
}

Android और iOS नेटिव मॉड्यूल के लिए Rust

Rust Android (.so NDK के माध्यम से) और iOS (.a स्थैतिक लाइब्रेरी) के लिए नेटिव लाइब्रेरी में कंपाइल होता है। Google Android Open Source Project (AOSP) में Rust का आधिकारिक रूप से समर्थन करता है — Rust का उपयोग Bluetooth (ava), DNS-over-HTTP3 और CriticalNotification घटकों के लिए किया जाता है। Google (2025) के अनुसार, Rust ने Android में लक्षित घटकों में 70% मेमोरी कमजोरियों को समाप्त कर दिया।

Android के लिए cargo-ndk का उपयोग किया जाता है, जो चयनित ABI के लिए सही टूलचेन के साथ Cargo को रैप करता है। 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 — FFI के लिए C-संगत प्रकार।

उदाहरण: 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] C-संगत ABI के लिए नेम मैंगलिंग को अक्षम करता है। extern "C" C कॉलिंग कन्वेंशन निर्दिष्ट करता है। unsafe — एक मार्कर कि Rust के बाहर से कॉल सुरक्षा की गारंटी नहीं देता। std::ptr::copy_nonoverlapping परिणाम बाइट्स को आउटपुट बफर में कॉपी करता है।

Rust में क्रॉस-प्लेटफ़ॉर्म SDK

Rust उन क्रॉस-प्लेटफ़ॉर्म SDK के लिए आदर्श उम्मीदवार है जो एक कोडबेस से Android और iOS पर काम करते हैं। Mozilla (Firefox), Dropbox (फ़ाइल सिंक्रनाइज़ेशन) और Meta (Libra blockchain) जैसी कंपनियों ने अपने मोबाइल एप्लिकेशन के महत्वपूर्ण घटकों के लिए Rust को चुना।

C++ पर Rust लाइब्रेरी के लाभ: कंपाइलर क्रॉस-प्लेटफ़ॉर्म कोड में मेमोरी लीक और डेटा रेस की अनुपस्थिति की गारंटी देता है। Rust में एक बार लिखा और परीक्षण किया गया कोड सभी प्लेटफ़ॉर्म पर समान रूप से काम करता है। Cargo बिना CMake या vcpkg के मूल रूप से निर्भरताओं का प्रबंधन करता है।

मोबाइल ऐप्स के लिए Rust और WebAssembly

Rust WebAssembly (Wasm) में कंपाइल होता है — एक बाइनरी प्रारूप जो ब्राउज़र और मोबाइल उपकरणों पर निष्पादित होता है। Wasm वेब वातावरण में नियर-नेटिव प्रदर्शन प्रदान करता है। मोबाइल डेवलपमेंट में, Wasm का उपयोग हाइब्रिड एप्लिकेशन (WebView + Wasm) में जटिल गणनाओं के लिए किया जाता है: 3D रेंडरिंग, इमेज रिकॉग्निशन, एन्क्रिप्शन।

wasm-pack Rust को .wasm में कंपाइल करता है और JS रैपर उत्पन्न करता है। wasm-bindgen Rust फ़ंक्शन को JavaScript कॉल से जोड़ता है। मोबाइल उपकरण पर, Wasm रनर 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] fibonacci फ़ंक्शन के लिए JavaScript रैपर उत्पन्न करता है। ब्राउज़र में, कॉल wasm.fibonacci(10) जैसा दिखता है। u32/u64 प्रकार स्वचालित रूप से Number/BigInt में परिवर्तित होते हैं। ऐसे फ़ंक्शन के लिए Wasm मॉड्यूल का आकार केवल ~5 KB है — न्यूनतम ओवरहेड।

FFI: Kotlin और Swift से Rust को कॉल करना

FFI (Foreign Function Interface) — अन्य भाषाओं से Rust कोड को कॉल करने की एक तंत्र। extern "C" और #[no_mangle] वाले Rust फ़ंक्शन C-संगत ABI के साथ निर्यात किए जाते हैं। Kotlin से, ऐसे फ़ंक्शन JNI के माध्यम से कॉल किए जाते हैं, Swift से — @_cdecl ("name") या CBridge.h के माध्यम से।

UniFFI — FFI बाइंडिंग उत्पन्न करने के लिए Mozilla उपकरण। आप .udl फ़ाइल में API का वर्णन करते हैं, और UniFFI स्वचालित रूप से Kotlin और Swift रैपर उत्पन्न करता है। Firefox Android और Firefox iOS में Rust घटकों के लिए यह मानक दृष्टिकोण है।

// UniFFI इंटरफ़ेस के साथ Rust लाइब्रेरी
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 encrypt विधि के साथ Kotlin क्लास उत्पन्न करता है, जो ByteArray लेता है और EncryptedData लौटाता है। Swift में, ciphertext (Data) और nonce (Data) फ़ील्ड के साथ EncryptedData स्ट्रक्चर बनाया जाता है। त्रुटियाँ Kotlin/Swift अपवादों में परिवर्तित होती हैं।

Rust बनाम C++: मोबाइल डेवलपमेंट के लिए तुलना

Rust और C++ मोबाइल डेवलपमेंट में सिस्टम प्रोग्रामिंग के लिए दो मुख्य भाषाएँ हैं। दोनों ARM के लिए नेटिव कोड में कंपाइल होती हैं और C ABI के माध्यम से FFI का समर्थन करती हैं। मुख्य अंतर मेमोरी सुरक्षा मॉडल है: Rust कंपाइल-टाइम पर इसकी जाँच करता है, C++ डेवलपर अनुशासन पर निर्भर करता है।

Rust C++ से अधिक सुरक्षित और अधिक उत्पादक है — कंपाइलर उन त्रुटियों को पकड़ता है जो C++ में रनटाइम पर प्रकट होंगी। C++ के पास समृद्ध मोबाइल लाइब्रेरी पारिस्थितिकी तंत्र है। नई परियोजनाओं के लिए, Rust बेहतर है; मौजूदा C++ कोड को धीरे-धीरे पोर्ट किया जाता है।