Gestionar notificaciones push

NFC Wallet usa notificaciones push para notificarte aplicación de cartera digital. Las notificaciones son enviadas por el backend de NFC Wallet.

Es necesario gestionar las notificaciones push de NFC Wallet para admitir LCM, las notificaciones de transacciones y los flujos de inscripción de tarjetas en los que la tarjeta digital se activa directamente por el emisor.

Enruta las notificaciones usando remitente

Leer remitente la clave del payload del mensaje datos y enruta la notificación al controlador correcto:

• CPS: operaciones de tarjeta digital (LCM)
• TNS: notificaciones de transacciones
• MG: reposición de claves de pago activada por el TSP

private static final String KEY_SENDER = "sender";

public void processIncomingMessage(@NonNull final Context context,
                                   @NonNull final Map<String, String> data) {
     
    String sender = "";
    if (!data.isEmpty()) {
        for (String key : data.keySet()) {
            if (KEY_SENDER.equalsIgnoreCase( key )) {
                sender = data.get(key);
            }
        }
    }
     
    switch (sender) {
    case "CPS":
        // Operaciones de tarjeta digital (LCM).
        // Consulta `ProvisioningBusinessService.processIncomingMessage`
        break;
  
    case "TNS":
         // Notificaciones de transacciones.
         // Actualiza el historial de transacciones. Consulta `MGTransactionHistoryService` en la referencia de la API.
         break;
                  
    case "MG":
         // Reposición de claves activada por el TSP.
         // Activa la reposición. Consulta `ReplenishmentService` en la referencia de la API.
        break;

    default:
        // Notificaciones no SDK
        break;
    }     
}

Procesar notificaciones CPS (operaciones de tarjeta digital)

Reenviar CPS notificaciones usando ProvisioningBusinessService.processIncomingMessage().

public void processIncomingMessage(@NonNull final Context context,
                                   @NonNull final Map<String, String> data) {
    // ...
    // Procesamiento del remitente CPS
    // 1 - Construir el bundle a partir de los datos del payload push
    final Bundle bundle = new Bundle();
    if (!data.isEmpty()) {
        for (String key : data.keySet()) {
            if (null != data.get(key)) {
                 bundle.putString(key, data.get(key));    
            }
        }
    }

    // 2 - Procesar el push del remitente CPS
    My_PushServiceListener pushListener = new My_PushServiceListener();
    final ProvisioningBusinessService provService 
                = ProvisioningServiceManager.getProvisioningBusinessService();                
    provService.processIncomingMessage( bundle, pushListener );

El SDK de NFC Wallet procesa el push e interactúa con el backend de NFC Wallet.

Implemente PushServiceListener

Implemente PushServiceListener para gestionar la devolución de llamada y seguir la operación de la tarjeta digital.

Callbacks compatibles:

• onUnsupportedPushContent: Se activa cuando el payload push no es compatible con el SDK.
• onComplete: Se activa cuando el procesamiento finaliza correctamente (por ejemplo, después de aprovisionar un perfil de tarjeta y claves de pago).
• serverMessage: Se activa cuando el backend devuelve un mensaje del servidor. El SDK proporciona un ProvisioningServiceMessage objeto y un tokenizedCardId.

Cuando reciba ProvisioningServiceMessage, llame a getMsgCode para determinar qué operación está ejecutando el backend:

• REQUEST_INSTALL_CARD: el mensaje indica una solicitud para instalar la tarjeta.
• REQUEST_REPLENISH_KEYS: el mensaje indica una solicitud de reposición.
• REQUEST_RESUME_CARD: el mensaje indica una solicitud para mover una tarjeta de suspendida a activa.
• REQUEST_SUSPEND_CARD: el mensaje indica una solicitud para mover una tarjeta de activa a suspendida.
• REQUEST_DELETE_CARD: el mensaje indica una solicitud para eliminar una tarjeta.
• REQUEST_RENEW_CARD: el mensaje indica una solicitud para renovar una tarjeta

public class My_PushServiceListener implements PushServiceListener {

  @Override
  public void onServerMessage(String tokenizedCardId, ProvisioningServiceMessage message) {
    /*
    Se activa durante los pasos del flujo de aprovisionamiento, durante una operación de gestión del ciclo de vida y durante la reposición de claves.

    Para entender qué acción se ha realizado, analiza el objeto ProvisioningServiceMessage.
    **/

      //Ejemplo
    	String messageCode = provisioningServiceMessage.getMsgCode();

      switch (messageCode) {
          case KnownMessageCode.REQUEST_INSTALL_CARD:
              // 1.ª notificación push para instalar la tarjeta
          case KnownMessageCode.REQUEST_REPLENISH_KEYS:
              // 2.ª notificación push para instalar las claves de pago y las reposiciones posteriores
          case KnownMessageCode.REQUEST_RESUME_CARD:
              // tarjeta que se reanudará
          case KnownMessageCode.REQUEST_SUSPEND_CARD:
              // tarjeta que se suspenderá
          case KnownMessageCode.REQUEST_RENEW_CARD:
              // token que se renovará (actualización del perfil)
          case KnownMessageCode.REQUEST_DELETE_CARD:
              // tarjeta que se eliminará.
              LocalBroadcastManager.getInstance(this).sendBroadcast(new Intent(ACTION_RELOAD_CARDS));
              break;
          default:
      }
  }

  @Override
  public void onUnsupportedPushContent(Bundle pushMessageBundle) {
    /*
    Se activa si el mensaje pasado no se ha entendido o no es compatible
    **/
  }

  @Override
  public void onComplete() {
    /*
    Se activa una vez que la sesión de aprovisionamiento se ha completado con éxito. La tarjeta está lista para el pago.
    **/
  }

  @Override
  public void onError(ProvisioningServiceError error) {
    /*
    Se activa cuando ocurre un error. El desarrollador debe analizar el error y tomar las acciones apropiadas.
    **/
  }
}

Procesar notificaciones TNS (transacciones)

Las notificaciones de transacciones proporcionan detalles sobre las transacciones de pago completadas. Usa MGTransactionHistoryService para recuperar los registros de transacciones.

A través de la notificación push, el aplicación de cartera digital obtiene la siguiente información a través del payload del mensaje datos :

• Clave remitente: TNS.
• Clave action: TNS:PaymentTransactionNotification.
• Clave digitalCardId: Identificador de la tarjeta digital. Úsalo con MGTransactionHistoryService.refreshHistory() para obtener la transacción
• Clave transactionRecordType: Solo presente para tarjetas co-marcadas. Pásalo a MGTransactionHistoryService.refreshHistory() para obtener solo los registros relevantes (principal o auxiliar).

private static final String KEY_SENDER = "sender";
private static final String KEY_ACTION = "action";
private static final String KEY_DIGITALIZED_CARD_ID = "digitalCardID";
private static final String KEY_TRANSACTION_RECORD_TYPE = "transactionRecordType";

public void processIncomingMessage(@NonNull final Context context,
                                   @NonNull final Map<String, String> data) {
    
    String action = "";
    String digitalCardID = "";
    String transactionRecordType = "";
    
    // ...
    // Procesamiento del remitente TNS
    // 1 - Extraer los valores de la notificación del remitente TNS
    final Bundle bundle = new Bundle();
    if (!data.isEmpty()) {
        for (String key : data.keySet()) {
            if (KEY_DIGITALIZED_CARD_ID.equalsIgnoreCase( key )) {
                 digitalCardID = data.get(key);
            }
            else if (KEY_ACTION.equalsIgnoreCase( key )) {
                 action = data.get(key);
            }
            else if (KEY_TRANSACTION_RECORD_TYPE .equalsIgnoreCase( key )) {
                 transactionRecordType = data.get(key);
            }
        }
    }
    
    // 2 - comprobar parámetros
    if( ! "TNS:PaymentTransactionNotification".equals( action ) || digitalCardID == null ) {
         // registrar error
    }
    else {
         // 3 - Llamar al servicio de historial de transacciones de MG         
         final MGTransactionHistoryService tnsService 
                = MobileGatewayManager.INSTANCE.getTransactionHistoryService();
                
         // 3a - primero debes obtener un token de acceso
         final ProvisioningBusinessService provService 
                = ProvisioningServiceManager.getProvisioningBusinessService();
         provService.getAccessToken(digitalCardID, 
              GetAccessTokenMode.REFRESH, new AccessTokenListener() {
                 @Override
                 public void onSuccess(String digitalCardId, String accessToken) {
                      // 3b - usando el token de acceso puedes obtener la transacción
                      tnsService.refreshHistory(accessToken, 
                                               digitalCardID, null, transactionRecordType , new TransactionHistoryListener() {
                              
                              @Override
                              public void onSuccess(List<MGTransactionRecord> list, String digitalCardId, String timeStamp) {
                                  // Éxito
                                  // puedes analizar la lista de registros de transacciones
                              }

                              @Override
                              public void onError(String s, MobileGatewayError mobileGatewayError) {
                                  // Registrar un error
                              }
                      });              
                 }
                 
                 @Override
                 public void onError(String digitalCardId, ProvisioningServiceError provisioningServiceError) {
                       // No se pudo obtener el token de acceso
                       // Registrar un error
                  }
             });
      } 
}

Procesar notificaciones MG (reposición)

El TSP puede solicitar la reposición de claves de pago. Usa ProvisioningServiceManager.sendRequestForReplenishment para reponer claves.

A través de la notificación push, el aplicación de cartera digital obtiene la siguiente información a través del payload del mensaje datos

• remitente: MG.
• action: MG:ReplenishmentNeededNotification.
• "digitalCardId: Identificador de la tarjeta digital. Úsalo con ReplenishmentService.replenish(digitalCardID:isForced:).

private static final String KEY_SENDER = "sender";
private static final String KEY_ACTION = "action";
private static final String KEY_DIGITALIZED_CARD_ID = "digitalCardID";

public void processIncomingMessage(@NonNull final Context context,
                                   @NonNull final Map<String, String> data) {
    
    String action = "";
    String digitalCardID = "";
    String transactionRecordType = "";
    
    // ...
    // Procesamiento del remitente MG
    // 1 - Extraer los valores de la notificación del remitente TNS
    final Bundle bundle = new Bundle();
    if (!data.isEmpty()) {
        for (String key : data.keySet()) {
            if (KEY_DIGITALIZED_CARD_ID.equalsIgnoreCase( key )) {
                 digitalCardID = data.get(key);
            }
            else if (KEY_ACTION.equalsIgnoreCase( key )) {
                 action = data.get(key);
            }
        }
    }
    
    // 2 - comprobar parámetros
    if( ! "MG:ReplenishmentNeededNotification".equals( action ) || digitalCardID == null ) {
         // registrar error
    }
    else {
         // 3 - Llamar al servicio de negocio de aprovisionamiento
         final ProvisioningBusinessService provService 
                = ProvisioningServiceManager.getProvisioningBusinessService();
         provService.sendRequestForReplenishment( digitalCardID, new ReplenishmentListener(), true);                             
    }
}

/**
 * Al usar este listener, solo observaremos el resultado
 * de llamar a la API ProvisioningBusinessService#sendRequestForReplenishment() que usa
 * la misma API PushServiceListener, pero no implica procesamiento de mensajes push.
 */
private static class ReplenishmentListener implements PushServiceListener {

        public ReplenishmentListener(){
        }


        @Override
        public void onError(final ProvisioningServiceError provisioningServiceError) {
            // Registrar error
        }

        @Override
        public void onUnsupportedPushContent(final Bundle bundle) {
            // Esto nunca debería ocurrir en el caso de uso de reposición, ya que no estamos pasando
            // Registrar error
        }

        @Override
        public void onServerMessage(final String tokenizedCardId,
                                    final ProvisioningServiceMessage provisioningServiceMessage) {
            //  Esto nunca debería ocurrir en la reposición
            // Registrar error
         }

        @Override
        public void onComplete() {

            // Para tarjetas Mastercard y PURE (EMV de marca blanca) solo significa que hemos enviado la solicitud de reposición y debemos esperar
            // a que llegue un mensaje push una vez que los SUK estén preparados para recuperarse del backend.
 
            // Para una tarjeta Visa, esto significa que hemos terminado y que la tarjeta está lista con un nuevo LUK
            // Así que comprobaremos si es una tarjeta Visa y, si lo es, reutilizaremos el código de gestión de mensajes push para notificar al usuario
        }
    }