Rust στην ανάπτυξη εφαρμογών για κινητά: native modules και cross-platform SDK

Τι είναι το Rust;

Rust — μια στατικά τυποποιημένη γλώσσα προγραμματισμού συστήματος με αφαιρέσεις μηδενικού κόστους (zero-cost abstractions). Το Rust εγγυάται ασφάλεια μνήμης χωρίς garbage collector χάρη στο σύστημα ιδιοκτησίας (ownership), δανεισμού (borrowing) και διάρκειας ζωής (lifetimes). Ο μεταγλωττιστής Rust είναι ένας από τους πιο αυστηρούς — απορρίπτει κώδικα που σε C++ θα προκαλούσε απροσδιόριστη συμπεριφορά.

Το Rust μεταγλωττίζεται μέσω LLVM σε native κώδικα για όλες τις αρχιτεκτονικές: ARM, x86, RISC-V, WebAssembly. Εργαλεία: rustup (εγκαταστάτης), rustc (μεταγλωττιστής), cargo (διαχειριστής πακέτων και κατασκευαστής). Το cargo.toml — ανάλογο του package.json, περιέχει εξαρτήσεις από το crates.io. Τρέχουσα έκδοση — Rust 1.81 (2025).

Βασικοί τομείς εφαρμογής του Rust στην ανάπτυξη κινητών: native βιβλιοθήκες (Android NDK, iOS), cross-platform SDK (Firefox, Dropbox), αντικατάσταση C++ σε τμήματα performance-critical, WebAssembly για υβριδικές εφαρμογές. Η Google χρησιμοποιεί Rust στο AOSP (Android Open Source Project) για τα στοιχεία Bluetooth, Wi-Fi και NFC.

Εγκατάσταση και διαμόρφωση του Rust για ανάπτυξη κινητών

Για cross-compilation για 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

# Εγκατάσταση cargo-ndk για κατασκευή Android
$ 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!("Επεξεργάστηκε: {:?}", numbers);

    let first = &numbers[0];  // αμετάβλητος δανεισμός
    println!("Πρώτο: {}", 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!("Μεγαλύτερο: {}", result);
    } // το string2 ζει μέχρι αυτήν την αγκύλη, το result είναι έγκυρο εντός
    // println!("{}", result); // σφάλμα: το string2 πέθανε
}

Rust για native modules Android και iOS

Rust μεταγλωττίζεται σε native βιβλιοθήκες για Android (.so μέσω NDK) και iOS (.a στατικές βιβλιοθήκες). Η Google υποστηρίζει επίσημα το Rust στο Android Open Source Project (AOSP) — τα στοιχεία Bluetooth (ava), DNS-over-HTTP3 και CriticalNotification είναι γραμμένα σε Rust. Σύμφωνα με την Google (2025), το Rust στο Android εξάλειψε το 70% των τρωτών σημείων μνήμης στα στοιχεία-στόχους.

Για Android χρησιμοποιείται το cargo-ndk, το οποίο περιβάλλει το Cargo με τη σωστή εργαλειοθήκη για το επιλεγμένο ABI. Η κατασκευή για Android περιλαμβάνει: aarch64-linux-android (ARM 64-bit, σύγχρονες συσκευές), armv7-linux-androideabi (ARM 32-bit), 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 — τύποι συμβατοί με 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 για C-συμβατό ABI. extern "C" ορίζει τη σύμβαση κλήσης C. unsafe — δείκτης ότι η κλήση από έξω από το Rust δεν εγγυάται ασφάλεια. std::ptr::copy_nonoverlapping αντιγράφει τα byte του αποτελέσματος στο buffer εξόδου.

Cross-platform SDK σε Rust

Rust — ο ιδανικός υποψήφιος για cross-platform SDK που λειτουργούν σε Android και iOS από μία βάση κώδικα. Οι εταιρείες Mozilla (Firefox), Dropbox (συγχρονισμός αρχείων) και Meta (Libra blockchain) επέλεξαν το Rust για κρίσιμα στοιχεία των εφαρμογών τους για κινητά.

Πλεονεκτήματα της βιβλιοθήκης Rust έναντι C++: ο μεταγλωττιστής εγγυάται την απουσία διαρροών μνήμης και συνθηκών ανταγωνισμού δεδομένων στον cross-platform κώδικα. Ο κώδικας που γράφτηκε και δοκιμάστηκε μία φορά σε Rust λειτουργεί πανομοιότυπα σε όλες τις πλατφόρμες. Το Cargo διαχειρίζεται τις εξαρτήσεις εγγενώς, χωρίς CMake και vcpkg.

Rust και WebAssembly για εφαρμογές κινητών

Rust μεταγλωττίζεται σε WebAssembly (Wasm) — μια δυαδική μορφή που εκτελείται στο πρόγραμμα περιήγησης και σε κινητές συσκευές. Το Wasm παρέχει απόδοση near-native στο περιβάλλον ιστού. Στην ανάπτυξη κινητών, το Wasm χρησιμοποιείται σε υβριδικές εφαρμογές (WebView + Wasm) για σύνθετους υπολογισμούς: 3D απόδοση, αναγνώριση εικόνας, κρυπτογράφηση.

Το wasm-pack μεταγλωττίζει το Rust σε .wasm και δημιουργεί ένα περιτύλιγμα JS. Το wasm-bindgen συνδέει τις συναρτήσεις Rust με κλήσεις JavaScript. Σε μια κινητή συσκευή, το Wasm-runner μπορεί να εκτελείται σε WebView ή μέσω SDK Wasmer/Wasmtime.

use wasm_bindgen::prelude::*;

/// Υπολογισμός αριθμού Fibonacci σε 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 module ζυγίζει ~5 KB για μια τέτοια συνάρτηση — ελάχιστη επιβάρυνση.

FFI: κλήση Rust από Kotlin και Swift

FFI (Foreign Function Interface) — ο μηχανισμός κλήσης κώδικα Rust από άλλες γλώσσες. Οι συναρτήσεις Rust με extern "C" και #[no_mangle] εξάγονται με C-συμβατό ABI. Από 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 δημιουργείται μια struct EncryptedData με πεδία ciphertext (Data) και nonce (Data). Τα σφάλματα μετατρέπονται σε εξαιρέσεις Kotlin/Swift.

Rust εναντίον C++: σύγκριση για ανάπτυξη κινητών

Rust και C++ — οι δύο κύριες γλώσσες για προγραμματισμό συστήματος στην ανάπτυξη κινητών. Και οι δύο μεταγλωττίζονται σε native κώδικα για ARM και υποστηρίζουν FFI μέσω C ABI. Η κύρια διαφορά — το μοντέλο ασφάλειας μνήμης: το Rust το ελέγχει κατά τη μεταγλώττιση, το C++ βασίζεται στην πειθαρχία του προγραμματιστή.

Το Rust είναι ασφαλέστερο από το C++ και πιο παραγωγικό — ο μεταγλωττιστής πιάνει σφάλματα που στο C++ θα εμφανίζονταν κατά το runtime. Το C++ έχει πλουσιότερο οικοσύστημα βιβλιοθηκών κινητών. Για νέα έργα, το Rust προτιμάται· ο υπάρχων κώδικας C++ μεταφέρεται σταδιακά.