Pola Android Rust

Halaman ini berisi informasi tentang Android Logging , memberikan contoh Rust AIDL , memberi tahu Anda cara memanggil Rust dari C , dan memberikan instruksi untuk Rust/C++ Interop Menggunakan CXX .

pencatatan Android

Contoh berikut menunjukkan bagaimana Anda dapat mencatat pesan ke logcat (di perangkat) atau stdout (di host).

Di modul Android.bp Anda, tambahkan liblogger dan liblog_rust sebagai dependensi:

rust_binary {
    name: "logging_test",
    srcs: ["src/main.rs"],
    rustlibs: [
        "liblogger",
        "liblog_rust",
    ],
}

Selanjutnya, di sumber Rust Anda, tambahkan kode ini:

use log::{debug, error, Level};

fn main() {
    let init_success = logger::init(
        logger::Config::default()
            .with_tag_on_device("mytag")
            .with_min_level(Level::Trace),
    );
    debug!("This is a debug message.");
    error!("Something went wrong!");
}

Artinya, tambahkan dua dependensi yang ditunjukkan di atas ( liblogger dan liblog_rust ), panggil metode init satu kali (Anda dapat memanggilnya lebih dari sekali jika perlu), dan catat pesan menggunakan makro yang disediakan. Lihat peti logger untuk daftar opsi konfigurasi yang mungkin.

Peti logger menyediakan API untuk menentukan apa yang ingin Anda catat. Bergantung pada apakah kode berjalan di perangkat atau di host (seperti bagian dari pengujian sisi host), pesan dicatat menggunakan android_logger atau env_logger .

Contoh karat AIDL

Bagian ini memberikan contoh gaya Hello World dalam menggunakan AIDL dengan Rust.

Menggunakan bagian Ikhtisar AIDL Panduan Pengembang Android sebagai titik awal, buat external/rust/binder_example/aidl/com/example/android/IRemoteService.aidl dengan konten berikut di file IRemoteService.aidl :

// IRemoteService.aidl
package com.example.android;

// Declare any non-default types here with import statements

/** Example service interface */
interface IRemoteService {
    /** Request the process ID of this service, to do evil things with it. */
    int getPid();

    /**
     * Demonstrates some basic types that you can use as parameters
     * and return values in AIDL.
     */
    void basicTypes(int anInt, long aLong, boolean aBoolean, float aFloat,
            double aDouble, String aString);
}

Kemudian, di dalam file external/rust/binder_example/aidl/Android.bp , tentukan modul aidl_interface . Anda harus mengaktifkan backend Rust secara eksplisit karena tidak diaktifkan secara default.

aidl_interface {
    name: "com.example.android.remoteservice",
    srcs: [ "aidl/com/example/android/*.aidl", ],
    unstable: true, // Add during development until the interface is stabilized.
    backend: {
        rust: {
            // By default, the Rust backend is not enabled
            enabled: true,
        },
    },
}

Backend AIDL adalah generator sumber Rust, sehingga beroperasi seperti generator sumber Rust lainnya dan menghasilkan perpustakaan Rust. Modul perpustakaan Rust yang dihasilkan dapat digunakan oleh modul Rust lainnya sebagai ketergantungan. Sebagai contoh penggunaan perpustakaan yang dihasilkan sebagai ketergantungan, rust_library dapat didefinisikan sebagai berikut di external/rust/binder_example/Android.bp :

rust_library {
    name: "libmyservice",
    srcs: ["src/lib.rs"],
    crate_name: "myservice",
    rustlibs: [
        "com.example.android.remoteservice-rust",
        "libbinder_rs",
    ],
}

Perhatikan bahwa format nama modul untuk perpustakaan yang dihasilkan AIDL yang digunakan di rustlibs adalah nama modul aidl_interface diikuti oleh -rust ; dalam hal ini, com.example.android.remoteservice-rust .

Antarmuka AIDL kemudian dapat direferensikan di src/lib.rs sebagai berikut:

// Note carefully the AIDL crates structure:
// * the AIDL module name: "com_example_android_remoteservice"
// * next "::aidl"
// * next the AIDL package name "::com::example::android"
// * the interface: "::IRemoteService"
// * finally, the 'BnRemoteService' and 'IRemoteService' submodules

//! This module implements the IRemoteService AIDL interface
use com_example_android_remoteservice::aidl::com::example::android::{
  IRemoteService::{BnRemoteService, IRemoteService}
};
use binder::{
    BinderFeatures, Interface, Result as BinderResult, Strong,
};

/// This struct is defined to implement IRemoteService AIDL interface.
pub struct MyService;

impl Interface for MyService {}

impl IRemoteService for MyService {
    fn getPid(&self) -> BinderResult<i32> {
        Ok(42)
    }

    fn basicTypes(&self, _: i32, _: i64, _: bool, _: f32, _: f64, _: &str) -> BinderResult<()> {
        // Do something interesting...
        Ok(())
    }
}

Terakhir, mulai layanan dalam biner Rust seperti yang ditunjukkan di bawah ini:

use myservice::MyService;

fn main() {
    // [...]
    let my_service = MyService;
    let my_service_binder = BnRemoteService::new_binder(
        my_service,
        BinderFeatures::default(),
    );
    binder::add_service("myservice", my_service_binder.as_binder())
        .expect("Failed to register service?");
    // Does not return - spawn or perform any work you mean to do before this call.
    binder::ProcessState::join_thread_pool()
}

Contoh AIDL Karat Async

Bagian ini memberikan contoh gaya Hello World dalam menggunakan AIDL dengan async Rust.

Melanjutkan contoh RemoteService , pustaka backend AIDL yang dihasilkan mencakup antarmuka asinkron yang dapat digunakan untuk mengimplementasikan implementasi server asinkron untuk antarmuka AIDL RemoteService .

Antarmuka server async yang dihasilkan IRemoteServiceAsyncServer dapat diimplementasikan sebagai berikut:

use com_example_android_remoteservice::aidl::com::example::android::IRemoteService::{
    BnRemoteService, IRemoteServiceAsyncServer,
};
use binder::{BinderFeatures, Interface, Result as BinderResult};

/// This struct is defined to implement IRemoteServiceAsyncServer AIDL interface.
pub struct MyAsyncService;

impl Interface for MyAsyncService {}

#[async_trait]
impl IRemoteServiceAsyncServer for MyAsyncService {
    async fn getPid(&self) -> BinderResult<i32> {
        //Do something interesting...
        Ok(42)
    }

    async fn basicTypes(&self, _: i32, _: i64, _: bool, _: f32, _: f64,_: &str,) -> BinderResult<()> {
        //Do something interesting...
        Ok(())
    }
}

Implementasi server async dapat dimulai sebagai berikut:

#[tokio::main(flavor = "multi_thread", worker_threads = 2)]
async fn main() {
    binder::ProcessState::start_thread_pool();

    let my_service = MyAsyncService;
    let my_service_binder = BnRemoteService::new_async_binder(
        my_service,
        TokioRuntime(Handle::current()),
        BinderFeatures::default(),
    );

    binder::add_service("myservice", my_service_binder.as_binder())
        .expect("Failed to register service?");

    task::block_in_place(move || {
        binder::ProcessState::join_thread_pool();
    });
}

Perhatikan bahwa block_in_place diperlukan untuk meninggalkan konteks async yang memungkinkan join_thread_pool menggunakan block_on secara internal. Hal ini karena #[tokio::main] membungkus kode dalam panggilan ke block_on , dan join_thread_pool mungkin memanggil block_on saat menangani transaksi masuk. Memanggil block_on dari dalam block_on menghasilkan kepanikan. Hal ini juga dapat dihindari dengan membuat runtime tokio secara manual daripada menggunakan #[tokio::main] lalu memanggil join_thread_pool di luar metode block_on .

Lebih lanjut, pustaka yang dihasilkan backend karat menyertakan antarmuka yang memungkinkan penerapan klien async IRemoteServiceAsync untuk RemoteService yang dapat diimplementasikan sebagai berikut:

use com_example_android_remoteservice::aidl::com::example::android::IRemoteService::IRemoteServiceAsync;
use binder_tokio::Tokio;

#[tokio::main(flavor = "current_thread")]
async fn main() {
    let binder_service = binder_tokio::get_interface::<dyn IRemoteServiceAsync<Tokio>>("myservice");

    let my_client = binder_service.await.expect("Cannot find Remote Service");

    let result = my_client.getPid().await;

    match result {
        Err(err) => panic!("Cannot get the process id from Remote Service {:?}", err),
        Ok(p_id) => println!("PID = {}", p_id),
    }
}

Hubungi Rust dari C

Contoh ini menunjukkan cara memanggil Rust dari C.

Contoh perpustakaan Rust

Definisikan file libsimple_printer di external/rust/simple_printer/libsimple_printer.rs sebagai berikut:

//! A simple hello world example that can be called from C

#[no_mangle]
/// Print "Hello Rust!"
pub extern fn print_c_hello_rust() {
    println!("Hello Rust!");
}

Pustaka Rust harus mendefinisikan header yang dapat digunakan oleh modul C yang bergantung, jadi tentukan header external/rust/simple_printer/simple_printer.h sebagai berikut:

#ifndef SIMPLE_PRINTER_H
#define SIMPLE_PRINTER_H

void print_c_hello_rust();


#endif

Definisikan external/rust/simple_printer/Android.bp seperti yang Anda lihat di sini:

rust_ffi {
    name: "libsimple_c_printer",
    crate_name: "simple_c_printer",
    srcs: ["libsimple_c_printer.rs"],

    // Define include_dirs so cc_binary knows where the headers are.
    include_dirs: ["."],
}

Contoh C biner

Definisikan external/rust/c_hello_rust/main.c sebagai berikut:

#include "simple_printer.h"

int main() {
  print_c_hello_rust();
  return 0;
}

Definisikan external/rust/c_hello_rust/Android.bp sebagai berikut:

cc_binary {
    name: "c_hello_rust",
    srcs: ["main.c"],
    shared_libs: ["libsimple_c_printer"],
}

Terakhir, buat dengan memanggil m c_hello_rust .

Interop Rust-Java

Peti jni menyediakan interoperabilitas Rust dengan Java melalui Java Native Interface (JNI). Ini mendefinisikan definisi tipe yang diperlukan Rust untuk menghasilkan perpustakaan cdylib Rust yang dihubungkan langsung ke JNI Java ( JNIEnv , JClass , JString , dan seterusnya). Tidak seperti pengikatan C++ yang menjalankan codegen melalui cxx , interoperabilitas Java melalui JNI tidak memerlukan langkah pembuatan kode selama pembuatan. Oleh karena itu tidak memerlukan dukungan sistem build khusus. Kode Java memuat cdylib yang disediakan Rust seperti perpustakaan asli lainnya.

Penggunaan

Penggunaan kode Rust dan Java tercakup dalam dokumentasi peti jni . Silakan ikuti contoh Memulai yang disediakan di sana. Setelah Anda menulis src/lib.rs , kembali ke halaman ini untuk mempelajari cara membangun perpustakaan dengan sistem pembangunan Android.

Membangun definisi

Java memerlukan perpustakaan Rust untuk disediakan sebagai cdylib agar dapat dimuat secara dinamis. Definisi perpustakaan Rust di Soong adalah sebagai berikut:

rust_ffi_shared {
    name: "libhello_jni",
    crate_name: "hello_jni",
    srcs: ["src/lib.rs"],

    // The jni crate is required
    rustlibs: ["libjni"],
}

Pustaka Java mencantumkan pustaka Rust sebagai ketergantungan required ; ini memastikannya diinstal ke perangkat bersama perpustakaan Java meskipun itu bukan ketergantungan waktu pembangunan:

java_library {
        name: "libhelloworld",
        [...]
        required: ["libhellorust"]
        [...]
}

Alternatifnya, jika Anda harus menyertakan pustaka Rust dalam file AndroidManifest.xml , tambahkan pustaka tersebut ke uses_libs sebagai berikut:

java_library {
        name: "libhelloworld",
        [...]
        uses_libs: ["libhellorust"]
        [...]
}

Interop Rust–C++ menggunakan CXX

Peti CXX menyediakan FFI yang aman antara Rust dan subset C++. Dokumentasi CXX memberikan contoh yang baik tentang cara kerjanya secara umum dan kami menyarankan untuk membacanya terlebih dahulu agar terbiasa dengan perpustakaan dan cara menjembatani C++ dan Rust. Contoh berikut menunjukkan cara menggunakannya di Android.

Agar CXX menghasilkan kode C++ yang dipanggil Rust, tentukan genrule untuk memanggil CXX dan cc_library_static untuk menggabungkannya ke dalam perpustakaan. Jika Anda berencana membuat C++ memanggil kode Rust, atau menggunakan tipe yang digunakan bersama antara C++ dan Rust, tentukan genrule kedua (untuk menghasilkan header C++ yang berisi binding Rust).

cc_library_static {
    name: "libcxx_test_cpp",
    srcs: ["cxx_test.cpp"],
    generated_headers: [
        "cxx-bridge-header",
        "libcxx_test_bridge_header"
    ],
    generated_sources: ["libcxx_test_bridge_code"],
}

// Generate the C++ code that Rust calls into.
genrule {
    name: "libcxx_test_bridge_code",
    tools: ["cxxbridge"],
    cmd: "$(location cxxbridge) $(in) > $(out)",
    srcs: ["lib.rs"],
    out: ["libcxx_test_cxx_generated.cc"],
}

// Generate a C++ header containing the C++ bindings
// to the Rust exported functions in lib.rs.
genrule {
    name: "libcxx_test_bridge_header",
    tools: ["cxxbridge"],
    cmd: "$(location cxxbridge) $(in) --header > $(out)",
    srcs: ["lib.rs"],
    out: ["lib.rs.h"],
}

Alat cxxbridge digunakan di atas untuk menghasilkan sisi jembatan C++. Pustaka statis libcxx_test_cpp selanjutnya digunakan sebagai dependensi untuk executable Rust kami:

rust_binary {
    name: "cxx_test",
    srcs: ["lib.rs"],
    rustlibs: ["libcxx"],
    static_libs: ["libcxx_test_cpp"],
}

Pada file .cpp dan .hpp , tentukan fungsi C++ sesuai keinginan, menggunakan tipe wrapper CXX sesuai keinginan. Misalnya, definisi cxx_test.hpp berisi hal berikut:

#pragma once

#include "rust/cxx.h"
#include "lib.rs.h"

int greet(rust::Str greetee);

Sedangkan cxx_test.cpp berisi

#include "cxx_test.hpp"
#include "lib.rs.h"

#include <iostream>

int greet(rust::Str greetee) {
  std::cout << "Hello, " << greetee << std::endl;
  return get_num();
}

Untuk menggunakan ini dari Rust, tentukan jembatan CXX seperti di bawah ini di lib.rs :

#[cxx::bridge]
mod ffi {
    unsafe extern "C++" {
        include!("cxx_test.hpp");
        fn greet(greetee: &str) -> i32;
    }
    extern "Rust" {
        fn get_num() -> i32;
    }
}

fn main() {
    let result = ffi::greet("world");
    println!("C++ returned {}", result);
}

fn get_num() -> i32 {
    return 42;
}