Proteger imagens particulares

Contexto

Com o recurso de imagens particulares seguras, você pode definir imagens em cartões que não precisam ser acessíveis por um URL público (um requisito para que as imagens comuns sejam renderizadas corretamente nos cartões). Você usa a API Wallet para fazer upload de uma imagem e receber um identificador que pode ser usado para referenciar essa imagem em um objeto de cartão da Carteira.

Os seguintes tipos de cartão são aceitos:

• Ingresso de evento
• Cartão de embarque
• Cartão de transporte público
• Cartão de oferta
• Vale-presente
• Cartão de fidelidade
• Cartão genérico

Exemplo de recurso

Cartão de sócio usando imagem particular segura

Casos de uso

As imagens privadas seguras permitem o uso de imagens que não precisam ser acessíveis publicamente e, portanto, podem ser usadas para coisas como uma foto de perfil. Isso permite casos de uso como, entre outros:

• Passe de assinatura anual
• Cartão de visita
• Cartão de transporte público

Observação: as imagens particulares seguras não devem ser usadas para representar documentos como identificação emitida pelo governo, além de outras diretrizes definidas na política de uso aceitável.

Algumas considerações ao usar o recurso da Carteira

• Não pode ser usado com passes privados genéricos
• Só pode ser adicionado a objetos de cartão (não a classes)
• Só pode ser usado com um único objeto
• Só pode ser usado com ImageModuleData (não outras imagens, como logotipo e logotipo de cabeçalho amplo)

Recursos em desenvolvimento

• Suporte na Web
• Imagens particulares em imagens principais

Etapas de integração

1. Faça upload da sua imagem particular usando a API Google Wallet para receber um privateImageId.
2. Adicione uma imagem ao objeto de cartão (por exemplo, ImageModuleData). Em vez de definir o campo sourceUri na imagem, defina o campo privateImageId com o valor obtido na etapa anterior.

Diagrama de sequência

Sequência de imagens privadas seguras

Exemplo de código

Faça upload da imagem

String issuerId = "12345";
String keyFilePath = "/path/to/key.json";
GoogleCredential credential =
    GoogleCredential.fromStream(new FileInputStream(keyFilePath))
        .createScoped(Arrays.asList("https://www.googleapis.com/auth/wallet_object.issuer"));
HttpTransport httpTransport = GoogleNetHttpTransport.newTrustedTransport();

// Prepare request to upload image
String contentType = "image/jpeg";  // MIME type of image
String imageFilePath = "/path/to/image.jpg";
HttpContent content =
    new ByteArrayContent(
        contentType, ByteStreams.toByteArray(new FileInputStream(imageFilePath)));

String url =
    String.format(
        "https://walletobjects.googleapis.com/upload/walletobjects/v1/privateContent/%s/uploadPrivateImage",
        issuerId);

// Make request to upload image
HttpResponse response =
    httpTransport
        .createRequestFactory(credential)
        .buildPostRequest(new GenericUrl(url), content)
        .execute();

// Get privateImageId from response
Gson gson = new Gson();
JsonObject jsonObject = gson.fromJson(response.parseAsString(), JsonObject.class);
String privateImageId = jsonObject.get("privateImageId").getAsString();

Usar a imagem particular no objeto de cartão

// Build GenericObject with privateImageId in ImageModuleData (also adding an optional TextModuleData)
Image image = new Image().setPrivateImageId(privateImageId);
ImageModuleData imageModuleData = new ImageModuleData().setId("imageId").setMainImage(image);
TextModuleData textModuleData =
    new TextModuleData().setId("textId").setHeader("Card holder").setBody("John Doe");
GenericObject genericObject =
    new GenericObject()
        .setId(issuerId + ".objectId")
        // class must be inserted before inserting object
        .setClassId(issuerId + ".classId")
        .setCardTitle("Business name")
        .setHeader("My membership card")
        .setImageModulesData(Arrays.asList(imageModuleData))
        .setTextModulesData(Arrays.asList(textModuleData));

// Insert GenericObject (or can use in JWT without inserting ahead of time)
Walletobjects service =
    new Walletobjects.Builder(httpTransport, GsonFactory.getDefaultInstance(), credential)
        .setApplicationName("My Application")
        .build();

service.genericobject().insert(genericObject).execute();

Atualizar o cartão para mostrar a imagem na frente

É possível usar a imagem particular segura em qualquer campo imageModulesData. Confira a seguir um exemplo de como usar um campo imageModulesData para posicionar a imagem na frente do card usando uma substituição de modelo. Confira um exemplo de inserção de uma classe com uma substituição de modelo:

CardTemplateOverride cardTemplateOverride =
    new CardTemplateOverride()
        .setCardRowTemplateInfos(
            Arrays.asList(
                new CardRowTemplateInfo()
                    .setTwoItems(
                        new CardRowTwoItems()
                            // The ids chosen here must be set on the object's TextModuleData and ImageModuleData
                            .setStartItem(
                                createTemplateItem("object.textModulesData['textId']"))
                            .setEndItem(
                                createTemplateItem("object.imageModulesData['imageId']")))));
GenericClass genericClass =
    new GenericClass()
        .setId(issuerId + ".classId")
        .setClassTemplateInfo(
            new ClassTemplateInfo().setCardTemplateOverride(cardTemplateOverride));

service.genericclass().insert(genericClass);


...


private static TemplateItem createTemplateItem(String fieldPath) {
  return new TemplateItem()
      .setFirstValue(
          new FieldSelector()
              .setFields(Arrays.asList(new FieldReference().setFieldPath(fieldPath))));
}

Como processar exceções

Erros podem ocorrer com o uso incorreto da Wallet FeatureAPI, incluindo:

Mensagem	Motivo
A imagem não pode ter source_uri e private_image_id	O emissor tentou definir um source_uri e um private_image_id em uma única imagem, o que não é permitido.
Não foi possível encontrar a imagem particular com o ID %s para o emissor %s	Definir um ID de imagem particular inexistente em um objeto
Não foi possível adicionar a imagem particular com o ID %s para o emissor %s ao objeto %s porque ela já está sendo usada com o objeto %s. Uma imagem particular só pode ser usada com um objeto.	Tentativa de usar a mesma imagem particular em mais de um objeto. Para usar a mesma imagem particular com mais de um objeto, ela precisa ser enviada novamente, e você vai receber um novo ID de imagem particular, que pode ser usado com o segundo objeto.