Fahrkarten unterstützen das Rendern von Vorlagen. Wenn keine Vorlage definiert ist, wird die Standardvorlage verwendet.
Vorlagendefinition
Eine Kartenvorlage wird auf Klassenebene definiert und dazu verwendet, ein mit der Klasse verknüpftes Objekt anzuzeigen. In der Vorlage wird definiert, welche Felder in den verschiedenen Abschnitten der Karte angezeigt werden.
Die Vorlage ist in folgende Abschnitte unterteilt:
Android
Web
Titel der Karte
Android
|
|
Web
|
|
Im Abschnitt des Kartentitels werden das Logo, der Name des Verkehrsunternehmens und die Fahrtzusammenfassung angezeigt. Alle drei Elemente sind erforderlich. Weder die Feldverweise, die zum Ausfüllen verwendet werden, noch ihre Position können verändert werden.
Die Rendering-Logik räumt bei der ersten Zeile allerdings eine gewisse Flexibilität ein. Die erste Zeile der Fahrkarte enthält die Fahrtzusammenfassung und wird bei einer einfachen Strecke durch folgende Felder im TransitObject gesteuert:
object.tripTypeobject.ticketLeg.originNameobject.ticketLeg.destinationNameobject.ticketLeg.originStationCodeobject.ticketLeg.destinationStationCode
Wie die Fahrkarte gerendert wird, richtet sich danach, welche Felder nicht leer sind. Für das Rendering gibt es folgende Möglichkeiten:
- Nur Name des Abreiseorts: Der Name des Abreiseorts ist die einzige Angabe. Das ist insbesondere für Fahrkarten nützlich, die nicht für eine bestimmte Fahrt gelten, sondern für einen bestimmten Bereich.
- Abreise- und Zielort: Der Abreiseort ist auf der linken Seite und der Zielort auf der rechten Seite. Das Symbol zwischen beiden Orten richtet sich nach der Art der Fahrt. Abreise- und Zielort können auf unterschiedliche Weise angezeigt werden:
- Namen und Bahnhofscodes: Oberhalb der Bahnhofscodes werden die Namen in kleinerer Schrift angezeigt.
- Nur Namen: Die Namen werden angezeigt.
- Nur Bahnhofscodes: Die Bahnhofscodes werden angezeigt.
TransitObject-Objekte mit mehreren Etappen funktionieren ähnlich. Verwende object.ticketLeg in diesem Fall nicht. Stattdessen musst du die Liste object.ticketLegs[] nutzen. Sowohl die Abreiseorte als auch die Zielorte müssen definiert sein. In jeder Etappe müssen einheitlich die Namen oder die Bahnhofscodes (oder beides) angegeben sein. Der angezeigte Abreiseort ist der Abreiseort des ersten Elements im Array, während der angezeigte Zielort dem Zielort des letzten Elements im Array entspricht.
Die Hintergrundfarbe der Fahrkarte ist kein Pflichtfeld und kann auf Klassen- oder auf Objektebene definiert werden. Das Objektfeld hat höhere Priorität und kann das Klassenfeld überschreiben.
Kartenvorlage
Android
Web
Im Abschnitt „Kartenvorlage“ werden zusätzliche Zeilen angezeigt. Diese Zeilen können textbasierte strukturierte Datenfelder oder Textmodulfelder enthalten.
Du kannst die Anzahl der Zeilen festlegen, die die Menge der Objekte in der class.classTemplateInfo.cardTemplateOverride.cardRowTemplateInfos[]-Liste definieren. Es muss mindestens ein Element angegeben werden, empfohlen werden maximal zwei. Jedes Element muss einen der folgenden Typen haben:
-
oneItemfür ein Element:item
-
twoItemsfür zwei Elemente:startItemendItem
-
threeItemsfür drei Elemente:startItemmiddleItemendItem
Jedes Element kann entweder als ein einzelner Feldselektor (.firstValue), als zwei Feldselektoren (.firstValue und .secondValue) oder als vordefiniertes Element (.predefinedItem) festgelegt werden. Es werden sowohl die Werte des ausgewählten Feldes als auch die jeweiligen Labels angezeigt. Werden zwei Feldselektoren definiert, werden die Werte in den ausgewählten Feldern mit einem „/“ als Trennzeichen angezeigt. Dasselbe gilt für die Labels der gewählten Felder. Vordefinierte Elemente werden zum Festlegen von komplexeren Renderingaufgaben verwendet.
Das folgende Codebeispiel zeigt, wie die Zeilenabschnitte der Kartenvorlage überschrieben werden können, um zwei Zeilen festzulegen. Jede Zeile enthält drei Elemente, die jeweils auf sechs benutzerdefinierte textModuleData-Felder auf Klassenebene und ihre Header als Labels verweisen:
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);
Mit dem Code wird eine Karte im folgenden Format im Codevorlagenabschnitt erstellt:
Leere Elemente werden nicht angezeigt. Weitere Informationen findest du im Bereich Feldverweise. Wenn alle Elemente in einer Zeile leer sind, wird die Zeile nicht angezeigt. Sind nur einige Elemente in einer Zeile leer, werden die vorhandenen Elemente neu geordnet und als Zeile mit weniger Elementen angezeigt.
Wird die Kartenvorlage nicht überschrieben, werden die standardmäßige Anzahl an Zeilen und Elementen sowie die standardmäßigen Feldverweise verwendet. Weitere Informationen findest du im Bereich Standardvorlage.
Nachdem du ein Hero-Image definiert hast, kann es nach der ersten Zeile angezeigt werden, falls die cardRowTemplateInfos-Liste mehrere Zeilen enthält, oder über der Zeile, falls es nur eine gibt.
Kartenbarcode
Android
|
|
Web
|
|
Im Abschnitt „Kartenbarcode“ werden zusätzliche Textangaben oder Bilder ober- und unterhalb des Barcodes angezeigt. Keines der Felder in diesem Abschnitt ist erforderlich.
Es stehen drei Feldselektoren zur Auswahl, mit denen zwei nebeneinanderliegende Felder oberhalb des Barcodes und eines darunter definiert werden können. Sie werden ohne Label angezeigt und können entweder textbasierte strukturierte Datenfelder, Textmodulfelder oder Bildmodulfelder sein. Bei Verwendung von Bildern müssen die Markenrichtlinien eingehalten werden.
Der Barcode wird nach Typ und Wert definiert. Eine Liste der unterstützten Barcodetypen findest du im Bereich Referenz. Außerdem kann unterhalb des Barcodes ein Text angezeigt werden. Dadurch lässt sich unter anderem der Barcode leichter scannen.
Das folgende Codebeispiel zeigt, wie der Barcodeabschnitt einer Karte überschrieben werden kann, um ein Bild über dem Barcode anzuzeigen:
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);
Mit dem Code wird eine Karte mit folgendem Format im Barcodeabschnitt erstellt:
Wird der Barcodeabschnitt nicht überschrieben, werden die standardmäßigen Barcodefelder verwendet. Weitere Informationen findest du im Bereich Standardvorlage.
Vorlage für Details
Android
|
|
Web
|
|
Der Abschnitt „Vorlage für Details“ besteht aus einer Liste mit class.classTemplateInfo.detailsTemplateOverride.detailsItemInfos[]-Elementen. Die Elemente können beliebige strukturierte Datenfelder, Textmodulfelder, Linkmodulfelder, Bildmodulfelder oder Nachrichten sein.
Jedes Element kann entweder als ein einzelner Feldselektor (.firstValue), als zwei Feldselektoren (.firstValue und .secondValue) oder als vordefiniertes Element (.predefinedItem) festgelegt werden. Es werden sowohl die Werte des ausgewählten Feldes als auch ihre jeweiligen Labels angezeigt. Werden zwei Feldselektoren definiert, werden die Werte in den ausgewählten Feldern mit einem „/“ als Trennzeichen angezeigt. Dasselbe gilt für die Labels der ausgewählten Felder. Vordefinierte Elemente werden zum Festlegen von komplexeren Renderingaufgaben verwendet. Bildmodulfelder werden in voller Breite ohne Label gerendert.
Das folgende Codebeispiel zeigt, wie der Detailabschnitt der Karte überschrieben werden kann, um ein einzelnes linksModuleData-Feld mit Label anzuzeigen:
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
Mit dem Code wird eine Karte mit folgendem Format im Detailabschnitt erstellt:
Leere Elemente werden nicht angezeigt. Weitere Informationen findest du im Bereich Feldverweise.
Wird die Detailvorlage nicht überschrieben, wird die Standardliste der Verweisfelder in der standardmäßigen Reihenfolge angezeigt. Weitere Informationen findest du im Bereich Standardvorlage.
Wenn die Fahrt aus mehreren Etappen besteht, wird oben im Abschnitt ein einfacher Reiseplan angezeigt, der nicht verschoben werden kann. Umfasst die Fahrt nur eine einfache Strecke, kann ein einfacher Reiseplan mit class.enableSingleLegItinerary angezeigt werden.
|
|
Listenvorlage
|
|
Im Abschnitt „Listenvorlage“ wird ausgewählt, welches Feld in der Ansicht „Karten/Tickets“ der Google Wallet App verwendet wird. Die Karte oder das Ticket wird in der Liste mit dem Logo, der Hintergrundfarbe und drei Zeilen dargestellt.
Das folgende Codebeispiel zeigt, wie die Listenvorlage überschrieben werden kann, um das Feld mit dem Ablaufdatum für ein Objekt einer einzelnen Karte oder eines einzelnen Tickets in der ersten Zeile der Listenvorlage anzeigen zu lassen:
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
Mit dem Code wird eine Karte mit der folgenden Listenvorlagenversion erstellt:
Die erste Zeile kann mit einem Feldselektor definiert werden oder zeigt die Fahrtzusammenfassung an. Folgende Formate für die Zusammenfassung sind möglich:
originAndDestinationCodesoriginAndDestinationNamesoriginName
Die zweite und dritte Zeile können nur mit einem Feldselektor definiert werden. Die Felder werden ohne Label angezeigt. Bei gruppierten Karten/Tickets zeigt die zweite Zeile immer das Startdatum und die dritte Zeile immer die Anzahl der gruppierten Karten/Tickets an.
Labels
Alle strukturierten Datenfelder haben ein von Google zugewiesenes Label. Google ist für eine Übersetzung der Labels in alle unterstützten Sprachen verantwortlich.
Mit einem der class.custom<name_of_the_field>Label-Felder kannst du einige der Labels individuell anpassen. Wenn du ein Label anpasst, liegt die Verantwortung, das jeweilige Label in alle gewünschten Sprachen übersetzen zu lassen, bei dir.
Feldverweise
Feldverweise werden in verschiedenen Bereichen der Vorlage im Format class.classTemplateInfo.*.fields[] verwendet. Ein Feldverweis umfasst eine Liste mit Pfaden zu strukturierten Datenfeldern, Textmodulfeldern, Linkmodulfeldern, Bildmodulfeldern oder Mitteilungen.
Nicht alle Pfadtypen sind in jedem Feldverweis zulässig. So erlauben manche Feldverweise beispielsweise nur Pfade zu textbasierten strukturierten Datenfeldern oder Textmodulfeldern. Textbasierte strukturierte Felder sind strukturierte Datenfelder des Typs String, lokalisierter String, Datum oder Geld.
Über die Liste kann eine Fallback-Logik implementiert werden. Das bedeutet: Falls der erste Pfad in der Liste zu einem leeren Feld führt, wird der nächste Pfad ausgewertet. Die Fallback-Logik zielt hauptsächlich auf textbasierte strukturierte Datenfelder oder Textmodulfelder ab. Unterschiedliche Feldtypen dürfen nicht in einer Liste vermischt werden. Die Fallback-Logik sollte mit Bedacht und nur in bestimmten Situationen verwendet werden, wenn ein einheitliches Feldmuster erwartet wird, das in einigen Objekten vorkommt, in anderen aber nicht. Meist ist es einfacher, separate Klassen für separate Anwendungsfälle zu erstellen.
Falls alle Pfade in der Feldverweisliste zu leeren Feldern führen, wird das zum Feldverweis gehörende Element nicht angezeigt. Wenn das Element, das den Feldverweis verwendet, immer angezeigt werden soll, darf mindestens ein Pfad nicht leer sein. Es empfiehlt sich, ein Feld auf ein Sonderzeichen wie „-“ einzustellen, um einen Nullwert darzustellen, selbst wenn einige Felder Strings mit nur einem Leerzeichen zulassen.
Wenn du auf ein Feld in einer Liste verweisen möchtest, kannst du entweder den Index des entsprechenden Feldes oder üblicherweise eine Referenz-ID verwenden. Elemente einer Liste, auf die mit einer ID verwiesen werden kann, haben ein .id-Feld. Es empfiehlt sich, eine Referenz-ID über den Index des Felds in der Liste zu verwenden, soweit verfügbar.
Hier ist ein Beispiel dafür, wie auf Felder in einer Liste verwiesen werden kann.
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 diesem Fall ist das erste Element im Abschnitt „Details“ der Karte das zweite Bild, das im Objekt deklariert wurde. Das zweite Element im Abschnitt „Details“ der Karte ist dagegen das erste Bild, das im Objekt deklariert wurde.
Standardvorlage
Android
|
|
Web
|
|
Es werden jeweils nur ein Bildmodulfeld der Klasse und ein Bildmodulfeld des Objekts angezeigt. Wenn mehr als ein Bildmodulfeld auf einer Ebene benötigt wird, muss die Standardvorlage überschrieben werden.
Es werden maximal 20 Textmodulfelder der Klasse und 20 Textmodulfelder des Objekts angezeigt. Die Felder werden in der gleichen Reihenfolge angezeigt, in der sie im Array definiert sind. Wenn mehr als 20 Textmodulfelder auf einer Ebene benötigt werden, muss die Standardvorlage überschrieben werden.
Es werden nur maximal 20 Nachrichten der Klasse und 20 Nachrichten des Objekts angezeigt. Die Reihenfolge der Nachrichten kann nicht fest zugesichert werden. Wenn mehr als 20 Nachrichten auf einer Ebene oder eine feste Reihenfolge notwendig sind, muss die Standardvorlage überschrieben werden.
Die Anzahl der URIs, die für das Modulfeld „Links“ definiert werden können, ist nicht beschränkt. Die URIs werden in der folgenden Reihenfolge für jede Ebene (Klasse oder Objekt) gruppiert angezeigt:
- Kartenkoordinaten
- Telefonnummern
- E-Mail-Adressen
- Webseiten
Die URIs werden für jede Gruppe in der gleichen Reihenfolge angezeigt, in der sie im Array definiert sind. Wenn eine andere Reihenfolge benötigt wird, muss die Standardvorlage überschrieben werden.
|
|
|