I pass per il trasporto pubblico supportano il rendering del modello. Se non è definito alcun modello, viene utilizzato quello predefinito.
Definizione del modello
Un modello di tessera viene definito a livello di classe e viene utilizzato per visualizzare qualsiasi oggetto associato alla classe. Il modello definisce i campi da visualizzare nelle diverse sezioni della tessera.
Il modello è suddiviso nelle seguenti sezioni:
Android
Web
Titolo della scheda
Android
|
Titolo della scheda predefinito
Titolo della scheda con logo largo
|
Web
|
|
La sezione del titolo della carta mostra il logo, il nome dell'operatore di trasporto pubblico e il riepilogo del viaggio. Tutti questi tre elementi sono obbligatori e né i riferimenti ai campi utilizzati per compilarli né la loro posizione possono essere modificati.
Tuttavia, la logica di rendering consente una certa flessibilità per la riga superiore. La riga superiore del pass, che rappresenta un riepilogo del viaggio, è controllata dai seguenti campi in TransitObject per un percorso di una sola tappa:
object.tripTypeobject.ticketLeg.originNameobject.ticketLeg.destinationNameobject.ticketLeg.originStationCodeobject.ticketLeg.destinationStationCode
La modalità di rendering della tessera dipende dai campi non vuoti. Può essere eseguito nei seguenti modi:
- Solo nome origine: il nome dell'origine è l'unica informazione visualizzata. Ciò è particolarmente utile per i biglietti che coprono un'area anziché un viaggio specifico.
- Origine e destinazione: l'origine è a sinistra e la destinazione è a destra. Il simbolo tra i due luoghi dipende dal tipo di corsa. I valori di origine e destinazione sono indicati in uno dei seguenti modi:
- Nomi e codici delle stazioni: vengono visualizzati i codici delle stazioni con i nomi sotto forma di testo più piccolo nella parte superiore.
- Solo nomi: mostriamo i nomi.
- Solo codici delle stazioni: mostriamo i codici delle stazioni.
Gli oggetti TransitObject con più gambe funzionano in modo molto simile. In questo caso, non utilizzare object.ticketLeg. Devi invece utilizzare l'elenco
object.ticketLegs[]. È necessario definire sia le origini che le destinazioni. I nomi, i codici delle stazioni o entrambi devono essere utilizzati in modo coerente in ogni tratto. L'origine visualizzata è l'origine del primo elemento nell'array, mentre la destinazione visualizzata è quella dell'ultimo elemento dell'array.
Il colore di sfondo della tessera non è un campo obbligatorio e può essere definito sia a livello di classe che a livello di oggetto. Il campo dell'oggetto ha una priorità più alta e può essere utilizzato per sostituire il campo della classe.
Quando è impostato il campo del logo largo, sui dispositivi Android l'intestazione predefinita del modello con il logo e il nome dell'emittente viene sostituita con il logo largo.
Segui le linee guida per l'immagine del logo largo quando crei il logo dell'intestazione larga per visualizzare in modo ottimale l'immagine sulle tessere.
Modello di scheda
Android
Web
La sezione del modello di scheda viene utilizzata per visualizzare righe aggiuntive. Queste righe possono contenere campi di dati strutturati basati su testo o campi di moduli di testo.
Puoi specificare il numero di righe che definiscono il numero di oggetti nell'elenco
class.classTemplateInfo.cardTemplateOverride.cardRowTemplateInfos[]. L'elenco richiede almeno un elemento e consigliamo di utilizzarne al massimo
due. Ogni elemento deve essere di uno dei seguenti tipi:
-
oneItem, che accetta un elemento:item
-
twoItems, che accetta due elementi:startItemendItem
-
threeItems, che accetta tre elementi:startItemmiddleItemendItem
Ogni elemento può essere definito come un selettore di campo singolo (.firstValue), due selettori di campo (.firstValue e .secondValue) o un elemento predefinito (.predefinedItem). Vengono visualizzati sia i valori del campo selezionato che le rispettive etichette. Quando definisci due selettori di campi, i valori dei campi selezionati vengono visualizzati con un separatore "/". Lo stesso vale per le etichette dei campi selezionati. Gli elementi predefiniti vengono utilizzati per definire un rendering più complesso.
Il seguente esempio di codice mostra come eseguire l'override delle sezioni delle righe della scheda del modello di scheda per specificare due righe. Ogni riga include tre elementi che fanno riferimento a sei campi personalizzati textModuleData a livello di classe e alle relative intestazioni come etichette:
Python
{
... //Rest of class
"textModulesData": [
{
"header": "Label 1",
"body": "Some info 1",
"id": "myfield1"
},
{
"header": "Label 2",
"body": "Some info 2",
"id": "myfield2"
},
{
"header": "Label 3",
"body": "Some info 3",
"id": "myfield3"
},
{
"header": "Label 4",
"body": "Some info 4",
"id": "myfield4"
},
{
"header": "Label 5",
"body": "Some info 5",
"id": "myfield5"
},
{
"header": "Label 6",
"body": "Some info 6",
"id": "myfield6"
}
],
"classTemplateInfo": {
"cardTemplateOverride": {
"cardRowTemplateInfos": [{
"threeItems": {
"startItem": {
"firstValue": {
"fields": [{
"fieldPath": "class.textModulesData['myfield1']"
}]
}
},
"middleItem": {
"firstValue": {
"fields": [{
"fieldPath": "class.textModulesData['myfield2']"
}]
}
},
"endItem": {
"firstValue": {
"fields": [{
"fieldPath": "class.textModulesData['myfield3']"
}]
}
},
}
},{
"threeItems": {
"startItem": {
"firstValue": {
"fields": [{
"fieldPath": "class.textModulesData['myfield4']"
}]
}
},
"middleItem": {
"firstValue": {
"fields": [{
"fieldPath": "class.textModulesData['myfield5']"
}]
}
},
"endItem": {
"firstValue": {
"fields": [{
"fieldPath": "class.textModulesData['myfield6']"
}]
}
},
}
}]
}
}
}
Java
// Rest of class
.setTextModulesData((new ArrayList<TextModuleData>() {
{
add((new TextModuleData()).setHeader("Label 1")
.setBody("Some info 1")
.setId("myfield1"));
add((new TextModuleData()).setHeader("Label 2")
.setBody("Some info 1")
.setId("myfield2"));
add((new TextModuleData()).setHeader("Label 3")
.setBody("Some info 3")
.setId("myfield3"));
add((new TextModuleData()).setHeader("Label 4")
.setBody("Some info 4")
.setId("myfield4"));
add((new TextModuleData()).setHeader("Label 5")
.setBody("Some info 5")
.setId("myfield5"));
add((new TextModuleData()).setHeader("Label 6")
.setBody("Some info 5")
.setId("myfield6"));
}
}))
.setClassTemplateInfo((new ClassTemplateInfo())
.setCardTemplateOverride((new CardTemplateOverride())
.setCardRowTemplateInfos(new ArrayList<CardRowTemplateInfo>() {
{
add((new CardRowTemplateInfo()).setThreeItems((new CardRowThreeItems())
.setStartItem((new TemplateItem()).setFirstValue((new FieldSelector()).setFields(new ArrayList<FieldReference>(){
{
add((new FieldReference()).setFieldPath("class.textModulesData['myfield1']"));
}
})))
.setMiddleItem((new TemplateItem()).setFirstValue((new FieldSelector()).setFields(new ArrayList<FieldReference>(){
{
add((new FieldReference()).setFieldPath("class.textModulesData['myfield2']"));
}
})))
.setEndItem((new TemplateItem()).setFirstValue((new FieldSelector()).setFields(new ArrayList<FieldReference>(){
{
add((new FieldReference()).setFieldPath("class.textModulesData['myfield3']"));
}
})))
));
add((new CardRowTemplateInfo()).setThreeItems((new CardRowThreeItems())
.setStartItem((new TemplateItem()).setFirstValue((new FieldSelector()).setFields(new ArrayList<FieldReference>(){
{
add((new FieldReference()).setFieldPath("class.textModulesData['myfield4']"));
}
})))
.setMiddleItem((new TemplateItem()).setFirstValue((new FieldSelector()).setFields(new ArrayList<FieldReference>(){
{
add((new FieldReference()).setFieldPath("class.textModulesData['myfield5']"));
}
})))
.setEndItem((new TemplateItem()).setFirstValue((new FieldSelector()).setFields(new ArrayList<FieldReference>(){
{
add((new FieldReference()).setFieldPath("class.textModulesData['myfield6']"));
}
})))
));
}
})))
PHP
// Rest of class
$textModulesData1 = new Google_Service_Walletobjects_TextModuleData();
$textModulesData1->setBody("Some info 1");
$textModulesData1->setHeader("Label 1");
$textModulesData1->setId("myfield1");
$textModulesData2 = new Google_Service_Walletobjects_TextModuleData();
$textModulesData2->setBody("Some info 2");
$textModulesData2->setHeader("Label 2");
$textModulesData2->setId("myfield2");
$textModulesData3 = new Google_Service_Walletobjects_TextModuleData();
$textModulesData3->setBody("Some info 3");
$textModulesData3->setHeader("Label 3");
$textModulesData3->setId("myfield3");
$textModulesData4 = new Google_Service_Walletobjects_TextModuleData();
$textModulesData4->setBody("Some info 4");
$textModulesData4->setHeader("Label 4");
$textModulesData4->setId("myfield4");
$textModulesData5 = new Google_Service_Walletobjects_TextModuleData();
$textModulesData5->setBody("Some info 5");
$textModulesData5->setHeader("Label 5");
$textModulesData5->setId("myfield5");
$textModulesData6 = new Google_Service_Walletobjects_TextModuleData();
$textModulesData6->setBody("Some info 6");
$textModulesData6->setHeader("Label 6");
$textModulesData6->setId("myfield6");
$textModulesDatas = array($textModulesData1, $textModulesData2, $textModulesData3,
$textModulesData4, $textModulesData5, $textModulesData6);
$startItemField = new Google_Service_Walletobjects_FieldReference();
$startItemField->setFieldPath("class.textModulesData['myfield1']");
$startItemFirstValue = new Google_Service_Walletobjects_FieldSelector();
$startItemFirstValue->setFields(array($startItemField));
$startItem = new Google_Service_Walletobjects_TemplateItem();
$startItem->setFirstValue($startItemFirstValue);
$middleItemField = new Google_Service_Walletobjects_FieldReference();
$middleItemField->setFieldPath("class.textModulesData['myfield2']");
$middleItemFirstValue = new Google_Service_Walletobjects_FieldSelector();
$middleItemFirstValue->setFields(array($middleItemField));
$middleItem = new Google_Service_Walletobjects_TemplateItem();
$middleItem->setFirstValue($middleItemFirstValue);
$endItemField = new Google_Service_Walletobjects_FieldReference();
$endItemField->setFieldPath("class.textModulesData['myfield3']");
$endItemFirstValue = new Google_Service_Walletobjects_FieldSelector();
$endItemFirstValue->setFields(array($endItemField));
$endItem = new Google_Service_Walletobjects_TemplateItem();
$endItem->setFirstValue($endItemFirstValue);
$cardRowTemplate = new Google_Service_Walletobjects_CardRowThreeItems();
$cardRowTemplate->setStartItem($startItem);
$cardRowTemplate->setMiddleItem($middleItem);
$cardRowTemplate->setEndItem($endItem);
$cardRowTemplateInfo1 = new Google_Service_Walletobjects_CardRowTemplateInfo();
$cardRowTemplateInfo1->setThreeItems($cardRowTemplate);
$startItemField2 = new Google_Service_Walletobjects_FieldReference();
$startItemField2->setFieldPath("class.textModulesData['myfield4']");
$startItemFirstValue2 = new Google_Service_Walletobjects_FieldSelector();
$startItemFirstValue2->setFields(array($startItemField2));
$startItem2 = new Google_Service_Walletobjects_TemplateItem();
$startItem2->setFirstValue($startItemFirstValue2);
$middleItemField2 = new Google_Service_Walletobjects_FieldReference();
$middleItemField2->setFieldPath("class.textModulesData['myfield5']");
$middleItemFirstValue2 = new Google_Service_Walletobjects_FieldSelector();
$middleItemFirstValue2->setFields(array($middleItemField2));
$middleItem2 = new Google_Service_Walletobjects_TemplateItem();
$middleItem2->setFirstValue($middleItemFirstValue2);
$endItemField2 = new Google_Service_Walletobjects_FieldReference();
$endItemField2->setFieldPath("class.textModulesData['myfield6']");
$endItemFirstValue2 = new Google_Service_Walletobjects_FieldSelector();
$endItemFirstValue2->setFields(array($endItemField2));
$endItem2 = new Google_Service_Walletobjects_TemplateItem();
$endItem2->setFirstValue($endItemFirstValue2);
$cardRowTemplate2 = new Google_Service_Walletobjects_CardRowThreeItems();
$cardRowTemplate2->setStartItem($startItem2);
$cardRowTemplate2->setMiddleItem($middleItem2);
$cardRowTemplate2->setEndItem($endItem2);
$cardRowTemplateInfo2 = new Google_Service_Walletobjects_CardRowTemplateInfo();
$cardRowTemplateInfo2->setThreeItems($cardRowTemplate2);
$cardTemplateOverride = new Google_Service_Walletobjects_CardTemplateOverride();
$cardTemplateOverride->setCardRowTemplateInfos(array($cardRowTemplateInfo1,
$cardRowTemplateInfo2));
$classTemplateInfo = new Google_Service_Walletobjects_ClassTemplateInfo();
$classTemplateInfo->setCardTemplateOverride($cardTemplateOverride);
$payload->setTextModulesData($textModulesDatas);
$payload->setClassTemplateInfo($classTemplateInfo);
Il codice crea una tessera con il seguente formato di sezione del modello di codice:
Se un elemento è vuoto, non viene visualizzato. Per maggiori dettagli, consulta la sezione Riferimenti dei campi. Se tutti gli elementi di una riga sono vuoti, la riga non viene visualizzata. Se solo alcuni elementi di una riga sono vuoti, quelli non vuoti vengono riorganizzati e visualizzati come riga con meno elementi.
Se non esegui l'override del modello di scheda, vengono utilizzati il numero predefinito di righe, il numero predefinito di elementi e i riferimenti di campo predefiniti. Per ulteriori dettagli, consulta Modello predefinito.
Dopo aver definito un'immagine hero, questa può essere visualizzata dopo la prima riga, se sono presenti più righe nell'elenco
cardRowTemplateInfos, o sopra la riga, se è presente
una sola.
Codice a barre della carta
Android
|
|
Web
|
|
La sezione del codice a barre della scheda viene utilizzata per visualizzare testo o immagini extra sopra e sotto il codice a barre. Nessuno dei campi di questa sezione è obbligatorio.
Sono disponibili tre selettori di campo che possono essere utilizzati per definire due campi affiancati sopra e uno sotto il codice a barre. Vengono visualizzati senza etichetta e possono essere campi di dati strutturati basati su testo, campi di moduli di testo o campi di moduli immagine. Se utilizzi immagini, queste devono seguire le linee guida per il branding.
Il codice a barre è definito da un tipo e da un valore. Per un elenco dei tipi di codici a barre supportati, consulta la sezione Riferimenti. Inoltre, è possibile mostrare un testo proprio sotto il codice a barre. Questo testo può semplificare la scansione dei codici a barre, tra gli altri utilizzi.
Il seguente esempio di codice mostra come sostituire la sezione del codice a barre di una tessera per visualizzare un'immagine sopra il codice a barre:
Python
#... rest of class
"imageModulesData": [
{
"mainImage": {
"sourceUri": {
"uri": "http://farm4.staticflickr.com/3738/12440799783_3dc3c20606_b.jpg",
"description": "Coffee"
}
},
"Id": "myimage"
}
],
"classTemplateInfo": {
"cardBarcodeSectionDetails": {
"firstTopDetail": {
"fieldSelector": {
"fields": [
{
"fieldPath": "class.imageModulesData['myimage'].mainImage"
}
]
}
}
}
}
}
Java
//... rest of class
.setImageModulesData((new ArrayList<ImageModuleData>() {
{
add((new ImageModuleData())
.setId("myimage")
.setMainImage((new Image()).setSourceUri((new ImageUri()).setDescription("Coffee beans")
.setUri("http://farm4.staticflickr.com/3738/12440799783_3dc3c20606_b.jpg"))));
}
}))
.setClassTemplateInfo((new ClassTemplateInfo())
.setCardBarcodeSectionDetails((new CardBarcodeSectionDetails())
.setFirstTopDetail((new BarcodeSectionDetail())
.setFieldSelector((new FieldSelector())
.setFields((new ArrayList<FieldReference>(){
{
add((new FieldReference()).setFieldPath("class.imageModulesData['myimage'].mainImage"));
}
})))))
}
PHP
//... rest of class
$imageUri = new Google_Service_Walletobjects_ImageUri();
$imageUri->setUri("https://farm8.staticflickr.com/7340/11177041185_a61a7f2139_o.jpg");
$imageUri->setDescription("Baconrista flights image");
$image = new Google_Service_Walletobjects_Image();
$image->setSourceUri($imageUri);
$imageModulesData = new Google_Service_Walletobjects_ImageModuleData();
$imageModulesData->setMainImage($image);
$imageModulesData->setId("myimage");
$cardBarcodeFieldReference = new Google_Service_Walletobjects_FieldReference();
$cardBarcodeFieldReference->setFieldPath("class.imageModulesData['myimage'].mainImage");
$cardBarcodeFieldSelector = new Google_Service_Walletobjects_FieldSelector();
$cardBarcodeFieldSelector->setFields(array($cardBarcodeFieldReference));
$cardBarcodeDetail = new Google_Service_Walletobjects_BarcodeSectionDetail();
$cardBarcodeDetail->setFieldSelector($cardBarcodeFieldSelector);
$cardBarcodeSectionDetails = new Google_Service_Walletobjects_CardBarcodeSectionDetails();
$cardBarcodeSectionDetails->setFirstTopDetail($cardBarcodeDetail);
$classTemplateInfo = new Google_Service_Walletobjects_ClassTemplateInfo();
$classTemplateInfo->setCardBarcodeSectionDetails($cardBarcodeSectionDetails);
$payload->setClassTemplateInfo($classTemplateInfo);
$payload->setImageModuleData($imageModulesData);
Il codice crea una tessera con il seguente formato di sezione di codice a barre:
Se non sostituisci la sezione del codice a barre, vengono utilizzati i campi del codice a barre predefiniti. Per ulteriori informazioni, vedi Modello predefinito.
Modello di dettagli
Android
|
|
Web
|
|
La sezione del modello di dettagli contiene un elenco di elementi
class.classTemplateInfo.detailsTemplateOverride.detailsItemInfos[]. Gli elementi possono contenere qualsiasi tipo di campi di dati strutturati, di moduli di testo e di moduli link, campi di moduli immagine o messaggi.
Ogni elemento può essere definito come un selettore di campo singolo (.firstValue), due selettori di campo (.firstValue e .secondValue) o un elemento predefinito (.predefinedItem). Vengono visualizzati sia i valori del campo selezionato che le rispettive etichette. Quando definisci due selettori di campi, i valori dei campi selezionati vengono visualizzati con un separatore "/". Lo stesso vale per le etichette dei campi selezionati. Gli elementi predefiniti vengono utilizzati per definire una visualizzazione più complessa. I campi del modulo Immagine vengono visualizzati a larghezza intera senza un'etichetta.
Il seguente esempio di codice mostra come eseguire l'override della sezione dei dettagli della tessera per mostrare un singolo campo linksModuleData con la relativa etichetta:
Python
//... rest of class
"linksModuleData": {
"uris": [
{
"uri": "http://maps.google.com/",
"description": "Nearby Locations",
"id":"mylink"
}
]
},
"classTemplateInfo": {
"detailsTemplateOverride": {
"detailsItemInfos": [
{
"item":{
"firstValue": {
"fields": [{
"fieldPath": "class.linksModuleData.uris['mylink']"
}]
}
}
}
]
}
}
//... rest of class
Java
//... rest of class
.setLinksModuleData((new ArrayList<LinksModuleData>() {
{
add((new LinksModuleData()).setDescription("Nearby Locations")
.setUri("http://maps.google.com/")
.setId("mylink"));
}))
.setClassTemplateInfo((new ClassTemplateInfo())
.setDetailsTemplateOverride((new DetailsTemplateOverride())
.setDetailsItemInfos(new ArrayList<DetailsItemInfo>(){
{
add((new DetailsItemInfo())
.setItem((new TemplateItem()).setFirstValue((new FieldSelector()).setFields(new ArrayList<FieldReference>(){
{
add((new FieldReference()).setFieldPath("class.linksModuleData.uris['mylink']"));
}
}))));
}
}))
//... rest of class
PHP
//... rest of class building
$locationUri = new Google_Service_Walletobjects_Uri();
$locationUri->setUri("http://maps.google.com/");
$locationUri->setDescription("Nearby Locations");
$locationUri->setId("mylink");
$linksModuleData = new Google_Service_Walletobjects_LinksModuleData();
$linksModuleData->setUris(array($locationUri));
$detailItemFieldReference = new Google_Service_Walletobjects_FieldReference();
$detailItemFieldReference->setFieldPath("class.linksModuleData.uris['mylink']");
$detailItemFieldSelector = new Google_Service_Walletobjects_FieldSelector();
$detailItemFieldSelector->setFields(array($detailItemFieldReference));
$detailItem = new Google_Service_Walletobjects_TemplateItem();
$detailItem->setFirstValue($detailItemFieldSelector);
$detailsItemInfo = new Google_Service_Walletobjects_DetailsItemInfo();
$detailsItemInfo->setItem($detailItem);
$cardDetailsTemplateOverride = new Google_Service_Walletobjects_DetailsTemplateOverride();
$cardDetailsTemplateOverride->setDetailsItemInfos(array($detailsItemInfo));
$classTemplateInfo = new Google_Service_Walletobjects_ClassTemplateInfo();
$classTemplateInfo->setDetailsTemplateOverride($cardDetailsTemplateOverride);
$payload->setClassTemplateInfo($classTemplateInfo);
$payload->setLinksModuleData($linksModuleData);
//... rest of class
Il codice crea una tessera con il seguente formato di sezione dei dettagli:
Se un elemento è vuoto, non viene visualizzato. Per maggiori dettagli, consulta la sezione Riferimenti dei campi.
Se non esegui l'override del modello dei dettagli, viene visualizzato l'elenco predefinito dei campi di riferimento nell'ordine predefinito. Per maggiori informazioni, consulta la sezione Modello predefinito.
Se il viaggio comprende più tappe, nella parte superiore della sezione viene visualizzato un itinerario semplice
e non può essere spostato. Se il viaggio include una sola tratta, è possibile mostrare un itinerario semplice
impostando class.enableSingleLegItinerary.
|
|
Modello di elenco
|
|
La sezione del modello di elenco viene utilizzata per selezionare il campo da mostrare nella visualizzazione "Tessere" dell'app Google Wallet. La tessera è rappresentata nell'elenco con il logo, il colore di sfondo e tre righe.
Il seguente esempio di codice mostra come eseguire l'override del modello di elenco di una tessera per mostrare il campo della data di scadenza dell'oggetto di una singola tessera nella prima riga del modello di elenco:
Python
#... rest of class definition
"classTemplateInfo": {
"listTemplateOverride":{
"firstRowOption": {
"fieldOption":{
"fields": [{
"fieldPath": "object.validTimeInterval.end"
}]
}
}
}
}
}
Java
//... rest of class
.setClassTemplateInfo((new ClassTemplateInfo())
.setListTemplateOverride((new ListTemplateOverride())
.setFirstRowOption((new FirstRowOption())
.setFieldOption((new FieldSelector()).setFields(new ArrayList<FieldReference>(){
{
add((new FieldReference()).setFieldPath("object.validTimeInterval.end"));
}
}))))
//... rest of class
PHP
//... rest of class
$fieldReference = new Google_Service_Walletobjects_FieldReference();
$fieldReference->setFieldPath("object.validTimeInterval.end");
$fieldOption = new Google_Service_Walletobjects_FieldSelector();
$fieldOption->setFields(array($fieldReference));
$firstRowOption = new Google_Service_Walletobjects_FirstRowOption();
$firstRowOption->setFieldOption($fieldOption);
$listTemplateOverride = new Google_Service_Walletobjects_ListTemplateOverride();
$listTemplateOverride->setFirstRowOption($firstRowOption);
$classTemplateInfo = new Google_Service_Walletobjects_ClassTemplateInfo();
$classTemplateInfo->setListTemplateOverride($listTemplateOverride);
$payload->setClassTemplateInfo($classTemplateInfo);
//... rest of class
Il codice crea una tessera con la seguente versione del modello di elenco:
La prima riga può essere definita con un selettore di campi o mostra il riepilogo del percorso. Il formato del riepilogo può essere uno dei seguenti:
originAndDestinationCodesoriginAndDestinationNamesoriginName
La seconda e la terza riga possono essere definite solo con un selettore di campi. I campi vengono visualizzati senza etichetta. Per i pass raggruppati, la seconda riga mostra sempre la data di partenza, mentre la terza mostra sempre il numero di pass raggruppati.
Etichette
Tutti i campi di dati strutturati hanno un'etichetta fornita da Google. Google è tenuta a fornire una traduzione per ciascuna di queste etichette in tutte le lingue supportate.
Puoi personalizzare alcune di queste etichette utilizzando uno dei
campi class.custom<name_of_the_field>Label. Quando personalizzi un'etichetta,
ti assumi la responsabilità di fornire le traduzioni dell'etichetta specifica in tutte le lingue
che vuoi supportare.
Riferimenti dei campi
I riferimenti ai campi vengono utilizzati in diverse parti del modello con il formato class.classTemplateInfo.*.fields[]. Un riferimento ai campi contiene un elenco di percorsi a campi di dati strutturati, campi di moduli di testo, campi di moduli link, campi di moduli immagine o messaggi.
Non tutti i tipi di percorso sono consentiti in ogni riferimento di campo. Ad esempio, alcuni riferimenti a campi consentono solo i percorsi di campi di dati strutturati basati su testo o di campi di moduli di testo. I campi strutturati basati su testo sono campi di dati strutturati di tipo stringa, stringa localizzata, data o denaro.
L'elenco può essere utilizzato per implementare una logica di fallback. Ciò significa che se il primo percorso nell'elenco si risolve in un campo vuoto, viene valutato il percorso successivo. La logica di fallback è principalmente mirata a campi di dati strutturati basati su testo o campi di moduli di testo. Non mescolare tipi di campi diversi nello stesso elenco. Utilizza la logica di fallback con cautela e solo in situazioni specifiche quando prevedi un pattern coerente di campi presenti in alcuni oggetti e non in altri. La maggior parte delle volte, è più facile creare classi separate per casi d'uso separati.
Se tutti i percorsi in un elenco di riferimenti di campi si trasformano in campi vuoti, l'elemento che utilizza il riferimento di campo non viene visualizzato. Se vuoi che l'elemento che utilizza il riferimento del campo sia sempre presente, assicurati che almeno un percorso non sia vuoto. Ti consigliamo di impostare un campo su un carattere speciale, come "-", per rappresentare un valore null, anche se alcuni campi consentono stringhe con solo uno spazio.
Per fare riferimento a un campo contenuto in un elenco, puoi utilizzare l'indice del campo nell'elenco o, nella maggior parte dei casi, puoi utilizzare un ID di riferimento. Gli elementi di un elenco a cui può fare riferimento
tramite ID hanno un campo .id. Ti consigliamo di utilizzare un ID di riferimento sull'indice del campo nell'elenco, se disponibile.
Ecco un esempio di come fare riferimento ai campi contenuti in un elenco.
object.imageModulesData[0].id = my-first-idobject.imageModulesData[1].id = my-second-idclass.detailsTemplateOverride.detailsItemInfos[0].item.firstValue.fields[0].fieldPath = object.imageModulesData[‘my-second-id’]class.detailsTemplateOverride.detailsItemInfos[1].item.firstValue.fields[0].fieldPath = object.imageModulesData[0]
In questo caso, il primo elemento nella sezione dei dettagli della tessera è la seconda immagine dichiarata nell'oggetto. Mentre il secondo elemento nella sezione dei dettagli della tessera è la prima immagine dichiarata nell'oggetto.
Modello predefinito
Android
|
|
Web
|
|
Per i campi del modulo immagine, mostriamo un solo campo del modulo immagine della classe e uno e solo un campo del modulo immagine dall'oggetto. Se hai bisogno di più di un campo del modulo immagine a entrambi i livelli, sostituisci il modello predefinito.
Per i campi dei moduli di testo, mostriamo solo un massimo di 20 campi di moduli di testo della classe e 20 campi di moduli di testo dell'oggetto. I campi vengono visualizzati nello stesso ordine in cui sono definiti nell'array. Se sono necessari più di 20 campi di moduli di testo in entrambi i livelli, esegui l'override del modello predefinito.
Per i messaggi, vengono visualizzati solo un massimo di 20 messaggi dalla classe e 20 messaggi dall'oggetto. Non garantiamo l'ordine dei messaggi. Se hai bisogno di più di 20 messaggi in entrambi i livelli o di una garanzia per tutti gli ordini, sostituisci il modello predefinito.
Per il campo del modulo Link, non è previsto alcun limite al numero di URI che puoi definire. Gli URI vengono visualizzati raggruppati nel seguente ordine per ogni livello (classe o oggetto):
- Coordinate mappa
- Numeri di telefono
- Indirizzi email.
- Pagine web
Per ogni gruppo, gli URI vengono visualizzati nello stesso ordine in cui sono definiti nell'array. Se hai bisogno di un ordine diverso, sostituisci il modello predefinito.
|
|
|