Il sistema di compilazione supporta la generazione di interfacce protobuf tramite il tipo di modulo rust_protobuf.
La generazione di codice protobuf di base viene eseguita con la crate rust-protobuf.
Per visualizzare la documentazione su questo utilizzo, consulta la pagina del progetto GitHub
con gli esempi protobuf corrispondenti.
Sono supportati anche i protobuf gRPC, con la generazione fornita dalla crate grpc-rs.
Per visualizzare la documentazione su questo utilizzo, consulta la documentazione nella pagina del progetto GitHub gRPC corrispondente.
Utilizzo di base della build rust_protobuf
Di seguito è riportato un esempio di definizione di un modulo protobuf e
del suo utilizzo come crate. Ulteriori dettagli sulle proprietà importanti e sul loro utilizzo sono disponibili nella sezione Definizione di un rust_protobuf.
Se devi utilizzare il codice generato da protobuf tramite una macro include!(), ad esempio per codice di terze parti, consulta la pagina Generatori di origine per un esempio. L'esempio utilizza un modulo rust_bindgen, ma il metodo di inclusione dell'origine è lo stesso per tutti i generatori di origine.
Definisci un modulo Android.bp rust_protobuf
Supponiamo che alcuni proto si trovino in src/protos/my.proto rispetto al tuo Android.bp; il
modulo viene quindi definito come segue:
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 libreria che utilizza questa crate viene definita facendo riferimento a essa come se fosse qualsiasi altra dipendenza della libreria:
rust_binary {
name: "hello_rust_proto",
srcs: ["src/main.rs"],
rustlibs: ["libmy_proto"],
}
Struttura delle casse dei moduli rust_protobuf
Ogni file protobuf è organizzato come modulo separato all'interno della crate, prendendo il
nome del file protobuf. Ciò significa che tutti i nomi di base dei file proto devono essere univoci. Ad esempio, prendi un rust_protobuf definito come segue:
rust_protobuf {
name: "libfoo",
crate_name: "foo",
protos: ["a.proto", "b.proto"],
grpc_protos: ["c.proto"],
source_stem: "my_proto_source",
}
Si accede ai diversi proto all'interno di questo crate nel seguente modo:
// 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
Proprietà rust_protobuf degne di nota
Le proprietà definite di seguito si aggiungono alle proprietà comuni importanti
che si applicano a tutti i moduli. Questi sono particolarmente importanti per i moduli protobuf di Rust o mostrano un comportamento unico specifico per il tipo di modulo rust_protobuf.
stem, name, crate_name
rust_protobuf genera varianti della libreria, pertanto per queste tre proprietà esistono gli stessi requisiti previsti per i moduli rust_library. Per i dettagli, consulta le proprietà rust_library.
protos
Si tratta di un elenco di percorsi relativi ai file protobuf per generare l'interfaccia protobuf. I nomi dei file di base devono essere univoci in protos e grpc_protos.
grpc_protos
grpc_protos è costituito da un elenco di percorsi relativi ai file protobuf che
definiscono grpcs per generare l'interfaccia protobuf. I nomi dei file di base devono essere univoci
in protos e grpc_protos.
source_stem
source_stem è il nome del file sorgente generato che può essere incluso.
Si tratta di una definizione di campo obbligatoria, anche se utilizzi i binding come
crate, poiché la proprietà stem controlla solo il nome file di output per le
varianti della libreria generate. A differenza di altri generatori di origine, il nome file
viene preceduto da mod_, il che rende il nome file finale mod_<stem>. In questo modo si evitano
collisioni di nomi con le origini generate da ogni proto.
Inoltre, come il modulo di binding bindgen, è disponibile anche l'intero set di proprietà della libreria per controllare la compilazione della libreria, anche se raramente è necessario definirle o modificarle.