El sistema de compilación admite la generación de interfaces protobuf a través del tipo de módulo rust_protobuf .
La generación básica de código protobuf se realiza con la caja rust-protobuf . Para ver la documentación sobre este uso, consulte la página del proyecto GitHub con los ejemplos de protobuf correspondientes.
Los protobufs gRPC también son compatibles, y la generación la proporciona la caja grpc-rs . Para ver la documentación sobre este uso, consulte la documentación en la página del proyecto gRPC GitHub correspondiente.
Uso básico de la compilación rust_protobuf
A continuación se proporciona un ejemplo de cómo definir un módulo protobuf y utilizar ese módulo como una caja. Más detalles sobre propiedades importantes y cómo se usan se encuentran en la sección Definición de un rust_protobuf .
Si necesita utilizar código generado por protobuf a través de una macro include!() , como código de terceros, consulte la página Generadores de código fuente para ver un ejemplo. (El ejemplo utiliza un módulo rust_bindgen , pero los medios para incluir el código fuente son los mismos para todos los generadores de código fuente).
Definir un módulo Rust_protobuf Android.bp
Asuma algún proto en src/protos/my.proto relativo a su Android.bp; El módulo se define entonces de la siguiente manera:
rust_protobuf {
name: "libmy_proto",
// Crate name that's used to generate the rust_library variants.
crate_name: "my_proto",
// Relative paths to the protobuf source files
protos: ["src/protos/my.proto"],
// If protobufs define gRPCs, then they should go in grpc_protos
// instead.
// grpc_protos: ["src/protos/my.proto"],
// 'source_stem' controls the output filename.
// This is the filename that's used in an include! macro.
source_stem: "my_proto_source",
}
Una biblioteca que utiliza esta caja se define haciendo referencia a ella como si fuera cualquier otra dependencia de biblioteca:
rust_binary {
name: "hello_rust_proto",
srcs: ["src/main.rs"],
rustlibs: ["libmy_proto"],
}
Estructura de caja de módulos rust_protobuf
Cada archivo protobuf se organiza como su propio módulo dentro de la caja, tomando el nombre del archivo protobuf. Esto significa que todos los nombres de archivos protobase deben ser únicos. Por ejemplo, tomemos un rust_protobuf definido de la siguiente manera:
rust_protobuf {
name: "libfoo",
crate_name: "foo",
protos: ["a.proto", "b.proto"],
grpc_protos: ["c.proto"],
source_stem: "my_proto_source",
}
Se accedería a los diferentes protos dentro de esta caja de la siguiente manera:
// use <crate_name>::<proto_filename>
use foo::a; // protobuf interface defined in a.proto
use foo::b; // protobuf interface defined in b.proto
use foo::c; // protobuf interface defined in c.proto
use foo::c_grpc; // grpc interface defined in c.proto
Propiedades notables de rust_protobuf
Las propiedades definidas a continuación se suman a las propiedades comunes importantes que se aplican a todos los módulos. Estos son particularmente importantes para los módulos Rust protobuf o exhiben un comportamiento único específico del tipo de módulo rust_protobuf .
tallo, nombre, nombre_caja
rust_protobuf produce variantes de biblioteca, por lo que existen los mismos requisitos para estas tres propiedades que para los módulos rust_library . Consulte las propiedades rust_library para obtener más detalles.
proto
Esta es una lista de rutas relativas a los archivos protobuf para generar la interfaz protobuf. Los nombres de archivos base deben ser únicos en protos y grpc_protos .
grpc_protos
grpc_protos consta de una lista de rutas relativas a los archivos protobuf que definen grpcs para generar la interfaz protobuf. Los nombres de archivos base deben ser únicos en protos y grpc_protos .
fuente_tallo
source_stem es el nombre del archivo fuente generado que se puede incluir. Esta es una definición de campo obligatoria, incluso si utiliza los enlaces como una caja, ya que la propiedad stem solo controla el nombre del archivo de salida para las variantes de biblioteca generadas. A diferencia de otros generadores de código fuente, el nombre del archivo tiene el prefijo mod_ , lo que hace que el nombre del archivo final sea mod_<stem> . Esto evita colisiones de nombres con fuentes generadas por cada proto.
Además, al igual que el módulo de enlaces bindgen, el conjunto completo de propiedades de la biblioteca también está disponible para controlar la compilación de la biblioteca, aunque rara vez es necesario definirlas o cambiarlas.