Rust dans le développement mobile : modules natifs et SDK multiplateformes

Qu'est-ce que Rust ?

Rust est un langage de programmation système typé statiquement avec des abstractions à coût nul. Rust garantit la sécurité mémoire sans ramasse-miettes grâce à son système de possession (ownership), d'emprunt (borrowing) et de durées de vie (lifetimes). Le compilateur Rust est l'un des plus stricts : il rejette le code qui provoquerait un comportement indéfini en C++.

Rust compile via LLVM en code natif pour toutes les architectures : ARM, x86, RISC-V, WebAssembly. La boîte à outils comprend : rustup (installateur), rustc (compilateur), cargo (gestionnaire de paquets et constructeur). Cargo.toml — analogue à package.json, contient les dépendances de crates.io. La version stable actuelle est Rust 1.81 (2025).

Domaines d'application clés de Rust dans le développement mobile : bibliothèques natives (Android NDK, iOS), SDK multiplateformes (Firefox, Dropbox), remplacement du C++ dans les sections critiques en performance, WebAssembly pour les applications hybrides. Google utilise Rust dans AOSP (Android Open Source Project) pour les composants Bluetooth, Wi-Fi et NFC.

Installation et configuration de Rust pour le développement mobile

Pour la compilation croisée vers Android, des chaînes d'outils cibles sont nécessaires : rustup target add aarch64-linux-android armv7-linux-androideabi. Pour iOS — aarch64-apple-ios x86_64-apple-ios. cargo-ndk (pour Android) et cargo-lipo (pour iOS) simplifient le processus de compilation.

# Installation de Rust et des plateformes cibles pour le développement mobile
$ 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

# Installation de cargo-ndk pour les builds Android
$ cargo install cargo-ndk

# Build pour Android
$ cargo ndk -t arm64-v8a -o ./jniLibs build --release

Système de possession : ownership, borrowing et lifetimes

Ownership (possession) est le concept fondamental de Rust. Chaque valeur a exactement un propriétaire. Lors de l'affectation ou du passage à une fonction, la possession est transférée (move). Après le transfert, l'ancien propriétaire ne peut pas utiliser la valeur. Cela élimine la double libération de mémoire et les pointeurs pendants.

Borrowing (emprunt) permet d'utiliser temporairement une référence à une valeur sans transférer la possession. La référence &T (immuable) — n'importe quel nombre de lecteurs. La référence &mut T (muable) — exactement un écrivain, sans lecteurs. Le compilateur vérifie ces règles à la compilation.

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];  // emprunt immuable
    println!("First: {}", first);
}

process_data prend une référence muable sur Vec et double chaque élément. iter_mut() retourne un itérateur avec des références muables. *item déréférence la référence pour l'affectation. Après process_data, numbers reste accessible — la possession n'a pas été transférée, seulement empruntée.

Lifetimes : durée de vie des références

Lifetimes ('a) — des annotations qui lient les durées de vie des références. Le compilateur les utilise pour vérifier qu'une référence ne survit pas aux données qu'elle pointe. Dans la plupart des cas, les lifetimes sont inférées automatiquement — vous ne devez les spécifier que dans les signatures de fonctions avec des références.

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 vit jusqu'à cette accolade, result est valide à l'intérieur
    // println!("{}", result); // erreur : string2 est mort
}

Rust pour les modules natifs Android et iOS

Rust compile en bibliothèques natives pour Android (.so via NDK) et iOS (.a bibliothèques statiques). Google prend officiellement en charge Rust dans Android Open Source Project (AOSP) — Rust est utilisé pour les composants Bluetooth (ava), DNS-over-HTTP3 et CriticalNotification. Selon Google (2025), Rust dans Android a éliminé 70 % des vulnérabilités mémoire dans les composants ciblés.

Pour Android, on utilise cargo-ndk, qui enveloppe Cargo avec la chaîne d'outils correcte pour l'ABI choisi. La compilation pour Android inclut : aarch64-linux-android (ARM 64 bits, appareils modernes), armv7-linux-androideabi (ARM 32 bits), x86_64-linux-android (émulateurs).

// Cargo.toml — configuration de bibliothèque pour 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 — pour iOS (.a), cdylib — pour Android (.so). serde — sérialisation pour l'échange de données avec Kotlin/Swift. libc — types compatibles C pour FFI.

Exemple : traitement d'image en Rust

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

/// Fonction compatible C pour le traitement d'image
#[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] désactive le name mangling pour un ABI compatible C. extern "C" spécifie la convention d'appel C. unsafe — un marqueur que l'appel depuis l'extérieur de Rust ne garantit pas la sécurité. std::ptr::copy_nonoverlapping copie les octets du résultat dans le tampon de sortie.

SDK multiplateformes en Rust

Rust est le candidat idéal pour les SDK multiplateformes qui fonctionnent sur Android et iOS à partir d'une seule base de code. Des entreprises comme Mozilla (Firefox), Dropbox (synchronisation de fichiers) et Meta (blockchain Libra) ont choisi Rust pour les composants critiques de leurs applications mobiles.

Avantages des bibliothèques Rust par rapport au C++ : le compilateur garantit l'absence de fuites mémoire et de conditions de course dans le code multiplateforme. Le code écrit et testé en Rust fonctionne à l'identique sur toutes les plateformes. Cargo gère les dépendances nativement, sans CMake ni vcpkg.

Rust et WebAssembly pour les applications mobiles

Rust compile en WebAssembly (Wasm) — un format binaire exécutable dans le navigateur et sur les appareils mobiles. Wasm offre des performances quasi natives dans l'environnement web. Dans le développement mobile, Wasm est utilisé dans les applications hybrides (WebView + Wasm) pour des calculs complexes : rendu 3D, reconnaissance d'image, chiffrement.

wasm-pack compile Rust en .wasm et génère un wrapper JS. wasm-bindgen relie les fonctions Rust aux appels JavaScript. Sur un appareil mobile, l'exécuteur Wasm peut fonctionner dans WebView ou via le SDK Wasmer/Wasmtime.

use wasm_bindgen::prelude::*;

/// Calcul des nombres de Fibonacci en Wasm (appelé depuis 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] génère un wrapper JavaScript pour la fonction fibonacci. Dans le navigateur, l'appel ressemble à wasm.fibonacci(10). Les types u32/u64 sont automatiquement convertis en Number/BigInt. Le module Wasm ne pèse qu'environ 5 Ko pour une telle fonction — un overhead minimal.

FFI : appeler Rust depuis Kotlin et Swift

FFI (Foreign Function Interface) — un mécanisme pour appeler du code Rust depuis d'autres langages. Les fonctions Rust avec extern "C" et #[no_mangle] sont exportées avec un ABI compatible C. Depuis Kotlin, ces fonctions sont appelées via JNI, depuis Swift — via @_cdecl ("name") ou CBridge.h.

UniFFI — un outil Mozilla pour générer des liaisons FFI. Vous décrivez l'API dans un fichier .udl, et UniFFI génère automatiquement des wrappers Kotlin et Swift. C'est l'approche standard pour les composants Rust dans Firefox Android et Firefox iOS.

// Bibliothèque Rust avec interface 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> {
    // implémentation AES-256-GCM
    todo!()
}

UniFFI génère une classe Kotlin avec la méthode encrypt, qui prend un ByteArray et retourne EncryptedData. En Swift, une structure EncryptedData est créée avec les champs ciphertext (Data) et nonce (Data). Les erreurs sont converties en exceptions Kotlin/Swift.

Rust vs C++ : comparaison pour le développement mobile

Rust et C++ sont les deux principaux langages de programmation système dans le développement mobile. Les deux compilent en code natif ARM et supportent FFI via l'ABI C. La principale différence est le modèle de sécurité mémoire : Rust le vérifie à la compilation, C++ repose sur la discipline du développeur.

Rust est plus sûr que C++ et plus productif — le compilateur détecte les erreurs qui se manifesteraient à l'exécution en C++. C++ dispose d'un écosystème de bibliothèques mobiles plus riche. Pour les nouveaux projets, Rust est préférable ; le code C++ existant est porté progressivement.