Les requêtes adressées à l'API Google Wallet doivent être authentifiées pour que l'API puisse identifier que la requête est effectuée par votre application.
Avant de commencer, vérifiez que vous avez correctement généré et enregistré vos identifiants pour l'API REST Google Wallet et le SDK Google Wallet pour Android.
Requêtes de l'API REST de Google Wallet
Les requêtes adressées à l'API REST de Google Wallet sont authentifiées à l'aide d'une clé de compte de service Google Cloud pour l'API REST Google Wallet afin d'obtenir un jeton d'accès.
Les bibliothèques clientes des API Google gèrent l'authentification et les requêtes API. Veillez à installer la bibliothèque correspondant au langage de programmation de votre choix, qui est utilisé dans les exemples suivants.
Tout d'abord, effectuez les importations de bibliothèques nécessaires et définissez des variables pour le fichier JSON du compte de service, ainsi que des ID pour l'émetteur, la classe, l'utilisateur unique et l'objet qui seront enregistrés.
Java
Pour commencer votre intégration en Java, reportez-vous à notre <ph type="x-smartling-placeholder"></ph> exemples de code sur GitHub.
import com.auth0.jwt.JWT;
import com.auth0.jwt.algorithms.Algorithm;
import com.google.api.client.googleapis.batch.BatchRequest;
import com.google.api.client.googleapis.batch.json.JsonBatchCallback;
import com.google.api.client.googleapis.javanet.GoogleNetHttpTransport;
import com.google.api.client.googleapis.json.GoogleJsonError;
import com.google.api.client.googleapis.json.GoogleJsonResponseException;
import com.google.api.client.http.*;
import com.google.api.client.json.gson.GsonFactory;
import com.google.api.services.walletobjects.*;
import com.google.api.services.walletobjects.model.*;
import com.google.auth.http.HttpCredentialsAdapter;
import com.google.auth.oauth2.GoogleCredentials;
import com.google.auth.oauth2.ServiceAccountCredentials;
import java.io.*;
import java.security.interfaces.RSAPrivateKey;
import java.util.*;
public class DemoTransit {
/**
* Path to service account key file from Google Cloud Console. Environment variable:
* GOOGLE_APPLICATION_CREDENTIALS.
*/
public static String keyFilePath;
/** Service account credentials for Google Wallet APIs. */
public static GoogleCredentials credentials;
/** Google Wallet service client. */
public static Walletobjects service;
public DemoTransit() throws Exception {
keyFilePath =
System.getenv().getOrDefault("GOOGLE_APPLICATION_CREDENTIALS", "/path/to/key.json");
auth();
}
PHP
Pour commencer l'intégration en PHP, reportez-vous à notre <ph type="x-smartling-placeholder"></ph> exemples de code sur GitHub.
use Firebase\JWT\JWT;
use Google\Auth\Credentials\ServiceAccountCredentials;
use Google\Client as GoogleClient;
use Google\Service\Walletobjects;
use Google\Service\Walletobjects\TicketLeg;
use Google\Service\Walletobjects\LatLongPoint;
use Google\Service\Walletobjects\Barcode;
use Google\Service\Walletobjects\ImageModuleData;
use Google\Service\Walletobjects\LinksModuleData;
use Google\Service\Walletobjects\TextModuleData;
use Google\Service\Walletobjects\TransitObject;
use Google\Service\Walletobjects\Message;
use Google\Service\Walletobjects\AddMessageRequest;
use Google\Service\Walletobjects\Uri;
use Google\Service\Walletobjects\TranslatedString;
use Google\Service\Walletobjects\LocalizedString;
use Google\Service\Walletobjects\ImageUri;
use Google\Service\Walletobjects\Image;
use Google\Service\Walletobjects\TransitClass;
/** Demo class for creating and managing Transit passes in Google Wallet. */
class DemoTransit
{
/**
* The Google API Client
* https://github.com/google/google-api-php-client
*/
public GoogleClient $client;
/**
* Path to service account key file from Google Cloud Console. Environment
* variable: GOOGLE_APPLICATION_CREDENTIALS.
*/
public string $keyFilePath;
/**
* Service account credentials for Google Wallet APIs.
*/
public ServiceAccountCredentials $credentials;
/**
* Google Wallet service client.
*/
public Walletobjects $service;
public function __construct()
{
$this->keyFilePath = getenv('GOOGLE_APPLICATION_CREDENTIALS') ?: '/path/to/key.json';
$this->auth();
}
Python
Pour commencer l'intégration dans Python, reportez-vous à notre <ph type="x-smartling-placeholder"></ph> exemples de code sur GitHub.
import json
import os
import uuid
from googleapiclient.discovery import build
from googleapiclient.errors import HttpError
from googleapiclient.http import BatchHttpRequest
from google.oauth2.service_account import Credentials
from google.auth import jwt, crypt
class DemoTransit:
"""Demo class for creating and managing Transit passes in Google Wallet.
Attributes:
key_file_path: Path to service account key file from Google Cloud
Console. Environment variable: GOOGLE_APPLICATION_CREDENTIALS.
base_url: Base URL for Google Wallet API requests.
"""
def __init__(self):
self.key_file_path = os.environ.get('GOOGLE_APPLICATION_CREDENTIALS',
'/path/to/key.json')
# Set up authenticated client
self.auth()
C#
Pour commencer votre intégration en C#, consultez notre <ph type="x-smartling-placeholder"></ph> exemples de code sur GitHub.
using System.IdentityModel.Tokens.Jwt;
using System.Net.Http.Headers;
using System.Text.RegularExpressions;
using Google.Apis.Auth.OAuth2;
using Google.Apis.Services;
using Google.Apis.Walletobjects.v1;
using Google.Apis.Walletobjects.v1.Data;
using Microsoft.IdentityModel.Tokens;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
/// <summary>
/// Demo class for creating and managing Transit passes in Google Wallet.
/// </summary>
class DemoTransit
{
/// <summary>
/// Path to service account key file from Google Cloud Console. Environment
/// variable: GOOGLE_APPLICATION_CREDENTIALS.
/// </summary>
public static string keyFilePath;
/// <summary>
/// Service account credentials for Google Wallet APIs
/// </summary>
public static ServiceAccountCredential credentials;
/// <summary>
/// Google Wallet service client
/// </summary>
public static WalletobjectsService service;
public DemoTransit()
{
keyFilePath = Environment.GetEnvironmentVariable(
"GOOGLE_APPLICATION_CREDENTIALS") ?? "/path/to/key.json";
Auth();
}
Node.js
Pour commencer votre intégration dans Node, reportez-vous à notre <ph type="x-smartling-placeholder"></ph> exemples de code sur GitHub.
const { google } = require('googleapis');
const jwt = require('jsonwebtoken');
const { v4: uuidv4 } = require('uuid');
/**
* Demo class for creating and managing Transit passes in Google Wallet.
*/
class DemoTransit {
constructor() {
/**
* Path to service account key file from Google Cloud Console. Environment
* variable: GOOGLE_APPLICATION_CREDENTIALS.
*/
this.keyFilePath = process.env.GOOGLE_APPLICATION_CREDENTIALS || '/path/to/key.json';
this.auth();
}
Go
Pour commencer votre intégration dans Go, consultez nos exemples de code complets sur GitHub. <ph type="x-smartling-placeholder"></ph> exemples de code sur GitHub.
package main import ( "bytes" "context" "encoding/json" "fmt" "github.com/golang-jwt/jwt" "github.com/google/uuid" "golang.org/x/oauth2" "golang.org/x/oauth2/google" oauthJwt "golang.org/x/oauth2/jwt" "google.golang.org/api/option" "google.golang.org/api/walletobjects/v1" "io" "log" "os" "strings" )
Utilisez ensuite l'une des bibliothèques de framework pour récupérer les identifiants nécessaires pour appeler l'API Google Wallet.
Java
Pour commencer votre intégration en Java, reportez-vous à notre <ph type="x-smartling-placeholder"></ph> exemples de code sur GitHub.
/**
* Create authenticated HTTP client using a service account file.
*
*/
public void auth() throws Exception {
credentials =
GoogleCredentials.fromStream(new FileInputStream(keyFilePath))
.createScoped(List.of(WalletobjectsScopes.WALLET_OBJECT_ISSUER));
credentials.refresh();
HttpTransport httpTransport = GoogleNetHttpTransport.newTrustedTransport();
// Initialize Google Wallet API service
service =
new Walletobjects.Builder(
httpTransport,
GsonFactory.getDefaultInstance(),
new HttpCredentialsAdapter(credentials))
.setApplicationName("APPLICATION_NAME")
.build();
}
PHP
Pour commencer l'intégration en PHP, reportez-vous à notre <ph type="x-smartling-placeholder"></ph> exemples de code sur GitHub.
/**
* Create authenticated HTTP client using a service account file.
*/
public function auth()
{
$this->credentials = new ServiceAccountCredentials(
Walletobjects::WALLET_OBJECT_ISSUER,
$this->keyFilePath
);
// Initialize Google Wallet API service
$this->client = new GoogleClient();
$this->client->setApplicationName('APPLICATION_NAME');
$this->client->setScopes(Walletobjects::WALLET_OBJECT_ISSUER);
$this->client->setAuthConfig($this->keyFilePath);
$this->service = new Walletobjects($this->client);
}
Python
Pour commencer l'intégration dans Python, reportez-vous à notre <ph type="x-smartling-placeholder"></ph> exemples de code sur GitHub.
def auth(self):
"""Create authenticated HTTP client using a service account file."""
self.credentials = Credentials.from_service_account_file(
self.key_file_path,
scopes=['https://www.googleapis.com/auth/wallet_object.issuer'])
self.client = build('walletobjects', 'v1', credentials=self.credentials)
C#
Pour commencer votre intégration en C#, consultez notre <ph type="x-smartling-placeholder"></ph> exemples de code sur GitHub.
/// <summary>
/// Create authenticated service client using a service account file.
/// </summary>
public void Auth()
{
credentials = (ServiceAccountCredential)GoogleCredential
.FromFile(keyFilePath)
.CreateScoped(new List<string>
{
WalletobjectsService.ScopeConstants.WalletObjectIssuer
})
.UnderlyingCredential;
service = new WalletobjectsService(
new BaseClientService.Initializer()
{
HttpClientInitializer = credentials
});
}
Node.js
Pour commencer votre intégration dans Node, reportez-vous à notre <ph type="x-smartling-placeholder"></ph> exemples de code sur GitHub.
/**
* Create authenticated HTTP client using a service account file.
*/
auth() {
const auth = new google.auth.GoogleAuth({
keyFile: this.keyFilePath,
scopes: ['https://www.googleapis.com/auth/wallet_object.issuer'],
});
this.credentials = require(this.keyFilePath);
this.client = google.walletobjects({
version: 'v1',
auth: auth,
});
}
Go
Pour commencer votre intégration dans Go, consultez nos exemples de code complets sur GitHub. <ph type="x-smartling-placeholder"></ph> exemples de code sur GitHub.
// Create authenticated HTTP client using a service account file.
func (d *demoTransit) auth() {
credentialsFile := os.Getenv("GOOGLE_APPLICATION_CREDENTIALS")
b, _ := os.ReadFile(credentialsFile)
credentials, err := google.JWTConfigFromJSON(b, walletobjects.WalletObjectIssuerScope)
if err != nil {
fmt.Println(err)
log.Fatalf("Unable to load credentials: %v", err)
}
d.credentials = credentials
d.service, _ = walletobjects.NewService(context.Background(), option.WithCredentialsFile(credentialsFile))
}
Requêtes du SDK Google Wallet pour Android
Les requêtes utilisant le SDK Google Wallet pour Android sont automatiquement authentifiées à l'aide de votre certificat de signature d'application. Le SDK Android crée automatiquement l'empreinte SHA-1 de votre certificat de signature et l'inclut dans les requêtes adressées à l'API Google Wallet.
Pour savoir comment générer et enregistrer l'empreinte SHA-1 de votre certificat de signature d'application, consultez Autoriser votre application pour le SDK Google Wallet pour Android.