Rust no desenvolvimento móvel: módulos nativos e SDK multiplataforma

O que é Rust?

Rust é uma linguagem de programação de sistemas estaticamente tipada com abstrações de custo zero. Rust garante segurança de memória sem coletor de lixo graças ao seu sistema de ownership, borrowing e lifetimes. O compilador Rust é um dos mais rigorosos: ele rejeita código que causaria comportamento indefinido em C++.

Rust compila via LLVM para código nativo para todas as arquiteturas: ARM, x86, RISC-V, WebAssembly. O conjunto de ferramentas inclui: rustup (instalador), rustc (compilador), cargo (gerenciador de pacotes e construtor). Cargo.toml — semelhante ao package.json, contém dependências do crates.io. A versão estável mais recente é Rust 1.81 (2025).

Áreas-chave de aplicação de Rust no desenvolvimento móvel: bibliotecas nativas (Android NDK, iOS), SDK multiplataforma (Firefox, Dropbox), substituição de C++ em seções críticas de desempenho, WebAssembly para aplicações híbridas. Google usa Rust no AOSP (Android Open Source Project) para componentes Bluetooth, Wi-Fi e NFC.

Instalação e configuração do Rust para desenvolvimento móvel

Para compilação cruzada para Android, são necessários toolchains de destino: rustup target add aarch64-linux-android armv7-linux-androideabi. Para iOS — aarch64-apple-ios x86_64-apple-ios. cargo-ndk (para Android) e cargo-lipo (para iOS) simplificam o processo de compilação.

# Instalando Rust e plataformas alvo para desenvolvimento móvel
$ 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

# Instalando cargo-ndk para compilação Android
$ cargo install cargo-ndk

# Compilação para Android
$ cargo ndk -t arm64-v8a -o ./jniLibs build --release

Sistema de ownership: ownership, borrowing e lifetimes

Ownership (propriedade) é o conceito fundamental de Rust. Cada valor tem exatamente um dono. Ao ser atribuído ou passado para uma função, a propriedade é transferida (move). Após a transferência, o antigo dono não pode usar o valor. Isso elimina a dupla liberação de memória e ponteiros pendentes.

Borrowing (empréstimo) permite usar temporariamente uma referência a um valor sem transferir a propriedade. A referência &T (imutável) — qualquer número de leitores. A referência &mut T (mutável) — exatamente um escritor, sem leitores. O compilador verifica essas regras em tempo de compilação.

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];  // empréstimo imutável
    println!("First: {}", first);
}

process_data recebe uma referência mutável para Vec dobra cada elemento. iter_mut() retorna um iterador com referências mutáveis. *item desreferencia a referência para atribuição. Após process_data, numbers permanece acessível — a propriedade não foi transferida, apenas emprestada.

Lifetimes: tempo de vida das referências

Lifetimes ('a) — anotações que vinculam os tempos de vida das referências. O compilador as usa para verificar se uma referência não sobrevive aos dados que aponta. Na maioria dos casos, os lifetimes são inferidos automaticamente — você só precisa especificá-los em assinaturas de funções com referências.

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 vive até esta chave, result é válido dentro
    // println!("{}", result); // erro: string2 morreu
}

Rust para módulos nativos Android e iOS

Rust compila em bibliotecas nativas para Android (.so via NDK) e iOS (.a bibliotecas estáticas). Google suporta oficialmente Rust no Android Open Source Project (AOSP) — Rust é usado para componentes Bluetooth (ava), DNS-over-HTTP3 e CriticalNotification. De acordo com a Google (2025), Rust no Android eliminou 70% das vulnerabilidades de memória em componentes direcionados.

Para Android, usa-se cargo-ndk, que envolve o Cargo com o toolchain correto para o ABI escolhido. A compilação para Android inclui: aarch64-linux-android (ARM 64-bit, dispositivos modernos), armv7-linux-androideabi (ARM 32-bit), x86_64-linux-android (emuladores).

// Cargo.toml — configuração de biblioteca para 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 — para iOS (.a), cdylib — para Android (.so). serde — serialização para troca de dados com Kotlin/Swift. libc — tipos compatíveis com C para FFI.

Exemplo: processamento de imagem em Rust

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

/// Função compatível com C para processamento de imagem
#[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] desativa o name mangling para ABI compatível com C. extern "C" especifica a convenção de chamada C. unsafe — um marcador de que a chamada de fora do Rust não garante segurança. std::ptr::copy_nonoverlapping copia os bytes do resultado para o buffer de saída.

SDK multiplataforma em Rust

Rust é o candidato ideal para SDK multiplataforma que funcionam no Android e iOS a partir de uma única base de código. Empresas como Mozilla (Firefox), Dropbox (sincronização de arquivos) e Meta (blockchain Libra) escolheram Rust para componentes críticos de seus aplicativos móveis.

Vantagens das bibliotecas Rust sobre C++: o compilador garante a ausência de vazamentos de memória e condições de corrida no código multiplataforma. Código escrito e testado em Rust funciona de forma idêntica em todas as plataformas. O Cargo gerencia dependências nativamente, sem CMake ou vcpkg.

Rust e WebAssembly para aplicativos móveis

Rust compila para WebAssembly (Wasm) — um formato binário executável no navegador e em dispositivos móveis. Wasm oferece desempenho quase nativo em ambientes web. No desenvolvimento móvel, Wasm é usado em aplicações híbridas (WebView + Wasm) para cálculos complexos: renderização 3D, reconhecimento de imagem, criptografia.

wasm-pack compila Rust para .wasm e gera um wrapper JS. wasm-bindgen conecta funções Rust com chamadas JavaScript. Num dispositivo móvel, o executor Wasm pode rodar no WebView ou através do SDK Wasmer/Wasmtime.

use wasm_bindgen::prelude::*;

/// Cálculo de números de Fibonacci em Wasm (chamado do 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] gera um wrapper JavaScript para a função fibonacci. No navegador, a chamada parece wasm.fibonacci(10). Os tipos u32/u64 são convertidos automaticamente para Number/BigInt. O módulo Wasm pesa apenas ~5 KB para tal função — sobrecarga mínima.

FFI: chamar Rust de Kotlin e Swift

FFI (Foreign Function Interface) — um mecanismo para chamar código Rust de outras linguagens. Funções Rust com extern "C" e #[no_mangle] são exportadas com um ABI compatível com C. Do Kotlin, essas funções são chamadas via JNI, do Swift — via @_cdecl ("name") ou CBridge.h.

UniFFI — uma ferramenta Mozilla para gerar bindings FFI. Você descreve a API em um arquivo .udl, e o UniFFI gera wrappers Kotlin e Swift automaticamente. Esta é a abordagem padrão para componentes Rust no Firefox Android e Firefox iOS.

// Biblioteca Rust com 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> {
    // implementação AES-256-GCM
    todo!()
}

UniFFI gera uma classe Kotlin com o método encrypt, que recebe um ByteArray e retorna EncryptedData. Em Swift, uma struct EncryptedData é criada com campos ciphertext (Data) e nonce (Data). Erros são convertidos em exceções Kotlin/Swift.

Rust vs C++: comparação para desenvolvimento móvel

Rust e C++ são as duas principais linguagens para programação de sistemas no desenvolvimento móvel. Ambas compilam para código nativo ARM e suportam FFI através do ABI C. A principal diferença é o modelo de segurança de memória: Rust verifica em tempo de compilação, C++ depende da disciplina do desenvolvedor.

Rust é mais seguro que C++ e mais produtivo — o compilador captura erros que se manifestariam em tempo de execução em C++. C++ tem um ecossistema de bibliotecas móveis mais rico. Para novos projetos, Rust é preferível; código C++ existente é portado gradualmente.