Rust ในการพัฒนาโมบาย: โมดูลเนทีฟและ SDK ข้ามแพลตฟอร์ม

Rust คืออะไร?

Rust เป็นภาษาโปรแกรมมิ่งระบบที่ถูกตรวจจับชนิดแบบสแตติกพร้อมนามธรรมแบบไม่มีค่าใช้จ่าย (zero-cost abstractions) Rust รับประกันความปลอดภัยของหน่วยความจำโดยไม่ต้องมีตัวเก็บขยะ ต้องขอบคุณระบบความเป็นเจ้าของ (ownership), การยืม (borrowing) และอายุขัย (lifetimes) คอมไพเลอร์ Rust เป็นหนึ่งในคอมไพเลอร์ที่เข้มงวดที่สุด: มันปฏิเสธโค้ดที่จะทำให้เกิดพฤติกรรมที่ไม่แน่นอนใน C++

Rust คอมไพล์ผ่าน LLVM เป็นโค้ดเนทีฟสำหรับทุกสถาปัตยกรรม: ARM, x86, RISC-V, WebAssembly ชุดเครื่องมือประกอบด้วย: rustup (ตัวติดตั้ง), rustc (คอมไพเลอร์), cargo (ตัวจัดการแพ็คเกจและเครื่องมือ build) Cargo.toml — คล้ายกับ package.json ประกอบด้วย dependencies จาก crates.io เวอร์ชันเสถียรล่าสุดคือ Rust 1.81 (2025)

พื้นที่การประยุกต์ใช้หลักของ Rust ในการพัฒนาโมบาย: ไลบรารีเนทีฟ (Android NDK, iOS), SDK ข้ามแพลตฟอร์ม (Firefox, Dropbox), การแทนที่ C++ ในส่วนที่สำคัญต่อประสิทธิภาพ, WebAssembly สำหรับแอปพลิเคชันแบบไฮบริด Google ใช้ Rust ใน AOSP (Android Open Source Project) สำหรับส่วนประกอบ Bluetooth, Wi-Fi และ NFC

การติดตั้งและกำหนดค่า Rust สำหรับการพัฒนาโมบาย

สำหรับการคอมไพล์ข้ามไปยัง Android จำเป็นต้องใช้ toolchains เป้าหมาย: rustup target add aarch64-linux-android armv7-linux-androideabi สำหรับ iOS — aarch64-apple-ios x86_64-apple-ios cargo-ndk (สำหรับ Android) และ cargo-lipo (สำหรับ iOS) ทำให้กระบวนการ build ง่ายขึ้น

# การติดตั้ง 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 สำหรับ build Android
$ cargo install cargo-ndk

# Build สำหรับ 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() ส่งคืน iterator พร้อมการอ้างอิงแบบเปลี่ยนรูปได้ *item dereference การอ้างอิงสำหรับการกำหนดค่า หลังจาก 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 สำหรับโมดูลเนทีฟ Android และ iOS

Rust คอมไพล์เป็นไลบรารีเนทีฟสำหรับ Android (.so ผ่าน NDK) และ iOS (.a ไลบรารีสแตติก) Google สนับสนุน Rust อย่างเป็นทางการใน Android Open Source Project (AOSP) — Rust ถูกใช้สำหรับส่วนประกอบ Bluetooth (ava), DNS-over-HTTP3 และ CriticalNotification ตามข้อมูลของ Google (2025) Rust ใน Android กำจัดช่องโหว่หน่วยความจำ 70% ในส่วนประกอบเป้าหมาย

สำหรับ Android ใช้ cargo-ndk ซึ่งห่อหุ้ม Cargo ด้วย toolchain ที่ถูกต้องสำหรับ ABI ที่เลือก การ build สำหรับ 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 สำหรับ ABI ที่เข้ากันได้กับ C extern "C" ระบุข้อตกลงการเรียกแบบ C unsafe — ตัวบ่งชี้ว่าการเรียกจากภายนอก Rust ไม่รับประกันความปลอดภัย std::ptr::copy_nonoverlapping คัดลอกไบต์ผลลัพธ์ไปยังบัฟเฟอร์ผลลัพธ์

SDK ข้ามแพลตฟอร์มใน Rust

Rust เป็นตัวเลือกที่เหมาะสำหรับ SDK ข้ามแพลตฟอร์มที่ทำงานบน Android และ iOS จากโค้ดเบสเดียว บริษัทอย่าง Mozilla (Firefox), Dropbox (การซิงค์ไฟล์) และ Meta (บล็อกเชน Libra) เลือก Rust สำหรับส่วนประกอบสำคัญของแอปพลิเคชันมือถือของพวกเขา

ข้อดีของไลบรารี Rust เหนือ C++: คอมไพเลอร์รับประกันว่าไม่มีหน่วยความจำรั่วและเรซข้อมูลในโค้ดข้ามแพลตฟอร์ม โค้ดที่เขียนและทดสอบใน Rust ครั้งเดียวทำงานเหมือนกันบนทุกแพลตฟอร์ม Cargo จัดการ dependencies อย่างเป็นธรรมชาติ โดยไม่ต้องใช้ CMake หรือ vcpkg

Rust และ WebAssembly สำหรับแอปมือถือ

Rust คอมไพล์เป็น WebAssembly (Wasm) — รูปแบบไบนารีที่ทำงานได้ในเบราว์เซอร์และบนอุปกรณ์เคลื่อนที่ Wasm มอบประสิทธิภาพใกล้เคียงเนทีฟในสภาพแวดล้อมเว็บ ในการพัฒนาโมบาย Wasm ถูกใช้ในแอปพลิเคชันแบบไฮบริด (WebView + Wasm) สำหรับการคำนวณที่ซับซ้อน: การเรนเดอร์ 3 มิติ, การรู้จำภาพ, การเข้ารหัส

wasm-pack คอมไพล์ Rust เป็น .wasm และสร้าง wrapper 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] สร้าง wrapper JavaScript สำหรับฟังก์ชัน fibonacci ในเบราว์เซอร์ การเรียกดูเหมือน wasm.fibonacci(10) ชนิด u32/u64 จะถูกแปลงเป็น Number/BigInt โดยอัตโนมัติ โมดูล Wasm มีน้ำหนักเพียง ~5 KB สำหรับฟังก์ชันดังกล่าว — ค่าใช้จ่ายเพียงเล็กน้อย

FFI: การเรียก Rust จาก Kotlin และ Swift

FFI (Foreign Function Interface) — กลไกสำหรับเรียกโค้ด Rust จากภาษาอื่น ฟังก์ชัน Rust ที่มี extern "C" และ #[no_mangle] ถูกส่งออกด้วย ABI ที่เข้ากันได้กับ C จาก Kotlin ฟังก์ชันเหล่านี้ถูกเรียกผ่าน JNI จาก Swift — ผ่าน @_cdecl ("name") หรือ CBridge.h

UniFFI — เครื่องมือ Mozilla สำหรับสร้าง binding FFI คุณอธิบาย API ในไฟล์ .udl และ UniFFI สร้าง wrapper 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 ผ่าน C ABI ความแตกต่างหลักคือโมเดลความปลอดภัยของหน่วยความจำ: Rust ตรวจสอบในเวลาคอมไพล์ C++ ขึ้นอยู่กับวินัยของนักพัฒนา

Rust ปลอดภัยกว่า C++ และมีประสิทธิผลมากกว่า — คอมไพเลอร์จับข้อผิดพลาดที่ใน C++ จะแสดงที่รันไทม์ C++ มีระบบนิเวศไลบรารีมือถือที่สมบูรณ์กว่า สำหรับโปรเจกต์ใหม่ Rust เป็นที่นิยมมากกว่า; โค้ด C++ ที่มีอยู่ถูกพอร์ตทีละน้อย