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 Rust في AOSP (مشروع أندرويد مفتوح المصدر) لمكونات Bluetooth وWi-Fi وNFC.

تثبيت وتكوين Rust لتطوير التطبيقات المحمولة

للترجمة المتقاطعة لأندرويد، تحتاج إلى سلاسل أدوات مستهدفة: rustup target add aarch64-linux-android armv7-linux-androideabi. لنظام iOS — aarch64-apple-ios x86_64-apple-ios. cargo-ndk (لأندرويد) و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 لبناء أندرويد
$ cargo install cargo-ndk

# البناء لأندرويد
$ 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 للوحدات الأصلية لأندرويد وiOS

Rust تُترجم إلى مكتبات أصلية لأندرويد (.so عبر NDK) وiOS (.a مكتبات ثابتة). تدعم Google Rust رسميًا في مشروع أندرويد مفتوح المصدر (AOSP) — تُستخدم Rust لمكونات Bluetooth (ava) وDNS-over-HTTP3 وCriticalNotification. وفقًا لـGoogle (2025)، قضت Rust في أندرويد على 70% من ثغرات الذاكرة في المكونات المستهدفة.

لأندرويد يُستخدم cargo-ndk، الذي يغلف Cargo مع سلسلة الأدوات الصحيحة لـABI المختار. البناء لأندرويد يشمل: aarch64-linux-android (ARM 64-bit، الأجهزة الحديثة)، armv7-linux-androideabi (ARM 32-bit)، x86_64-linux-android (المحاكيات).

// Cargo.toml — تكوين المكتبة لأندرويد/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 — لأندرويد (.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 لـABI متوافق مع C. extern "C" يُحدد اتفاقية استدعاء C. unsafe — علامة أن الاستدعاء من خارج Rust لا يضمن الأمان. std::ptr::copy_nonoverlapping ينسخ بايتات النتيجة إلى المخزن المؤقت الناتج.

SDK عبر المنصات في Rust

Rust هي المرشح المثالي لـSDK عبر المنصات التي تعمل على أندرويد وiOS من قاعدة كود واحدة. شركات مثل Mozilla (Firefox) وDropbox (مزامنة الملفات) وMeta (سلسلة كتل Libra) اختارت Rust للمكونات الحرجة في تطبيقاتها المحمولة.

مزايا مكتبات Rust على C++: المُجمّع يضمن عدم وجود تسرب للذاكرة وسباقات البيانات في الكود عبر المنصات. الكود المكتوب والمختبر في Rust يعمل بشكل متطابق على جميع المنصات. يدير Cargo التبعيات بشكل أصلي، بدون CMake أو vcpkg.

Rust وWebAssembly للتطبيقات المحمولة

Rust تُترجم إلى WebAssembly (Wasm) — تنسيق ثنائي يُنفذ في المتصفح وعلى الأجهزة المحمولة. يوفر Wasm أداءً قريبًا من الأصلي في البيئات الويب. في تطوير التطبيقات المحمولة، يُستخدم Wasm في التطبيقات الهجينة (WebView + Wasm) للحسابات المعقدة: التصيير ثلاثي الأبعاد، التعرف على الصور، التشفير.

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] يُولد غلاف JavaScript لدالة fibonacci. في المتصفح، يبدو الاستدعاء كـ wasm.fibonacci(10). الأنواع u32/u64 تُحول تلقائيًا إلى Number/BigInt. يزن وحدة Wasm ~5 كيلوبايت فقط لمثل هذه الدالة — حمل إضافي ضئيل.

FFI: استدعاء Rust من Kotlin وSwift

FFI (واجهة الدوال الخارجية) — آلية لاستدعاء كود Rust من لغات أخرى. دوال Rust مع extern "C" و#[no_mangle] تُصدر مع ABI متوافق مع C. من 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، يُنشأ هيكل EncryptedData بحقول ciphertext (Data) وnonce (Data). تُحول الأخطاء إلى استثناءات Kotlin/Swift.

Rust ضد C++: مقارنة لتطوير التطبيقات المحمولة

Rust وC++ هما اللغتان الرئيسيتان لبرمجة الأنظمة في تطوير التطبيقات المحمولة. كلاهما يُترجم إلى كود أصلي لـARM ويدعمان FFI عبر ABI لـC. الفرق الرئيسي هو نموذج أمان الذاكرة: Rust تتحقق منه في وقت الترجمة، C++ تعتمد على انضباط المطور.

Rust أكثر أمانًا من C++ وأكثر إنتاجية — المُجمّع يلتقط الأخطاء التي ستظهر في وقت التشغيل في C++. C++ لديها نظام بيئي أغنى للمكتبات المحمولة. للمشاريع الجديدة، Rust مفضلة؛ كود C++ الحالي يُنقل تدريجيًا.