Il sistema di compilazione supporta la generazione di interfacce protobuf tramite il
rust_protobuf tipo di modulo.
La generazione di codice protobuf di base viene eseguita con il crate rust-protobuf.
Per visualizzare la documentazione su questo utilizzo, consulta la pagina del progetto GitHub con gli esempi di protobuf corrispondenti.
Sono supportati anche i protobuf gRPC, con la generazione fornita dalla cassa 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
dell'utilizzo di questo modulo come crate. Ulteriori dettagli sulle proprietà importanti e sul loro utilizzo sono disponibili nella sezione Definire un rust_protobuf.
Se devi utilizzare il codice generato da protobuf tramite una macro include!(), ad esempio per il codice di terze parti, consulta la pagina Generatori di codice sorgente per un esempio. (nell'esempio viene utilizzato un modulo rust_bindgen, ma le modalità di inclusione delle fonti sono le stesse per tutti i generatori di codice sorgente).
Definisci un modulo Android.bp rust_protobuf
Supponi di eseguire un protocollo in src/protos/my.proto rispetto ad Android.bp; il
modulo è 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 questo crate viene definita facendovi riferimento come se fosse qualsiasi altra dipendenza della libreria:
rust_binary {
name: "hello_rust_proto",
srcs: ["src/main.rs"],
rustlibs: ["libmy_proto"],
}
Struttura della cassa dei moduli rust_protobuf
Ogni file protobuf è organizzato come modulo all'interno della cassetta, assumendo il nome del file protobuf. Ciò significa che tutti i nomi file di base del protocollo devono essere univoci. Ad
esempio, prendi in considerazione un valore 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",
}
I diversi proto all'interno di questa cassetta verrebbero acceduti come segue:
// 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 importanti
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 Rust o presentano un comportamento univoco specifico per il tipo di modulo rust_protobuf.
stem, name, crate_name
rust_protobuf produce varianti della libreria, pertanto per queste tre proprietà esistono gli stessi requisiti che hanno per i moduli rust_library. Per informazioni dettagliate, consulta le proprietà rust_library.
proto
Questo è un elenco di percorsi relativi ai file protobuf per generare l'interfaccia protobuf. I nomi 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 file di base devono essere univoci
in protos e grpc_protos.
source_stem
source_stem è il nome del file di origine generato che può essere incluso.
Questa è una definizione di campo obbligatoria, anche se utilizzi le associazioni come
crate, poiché la proprietà stem controlla solo il nome file di output per le
varianti della raccolta generate. A differenza di altri generatori di codice sorgente, il nome del file viene preceduto da mod_, il che rende il nome file finale mod_<stem>. In questo modo si evitano conflitti di nomi con le origini generate da ciascun protocollo.
Inoltre, come per il modulo delle associazioni bindgen, è disponibile anche l'intero insieme di proprietà della libreria per controllare la compilazione della libreria, anche se raramente è necessario definirle o modificarle.