Cette page a été traduite par l'API Cloud Translation.

Accès rapide à votre carte de paiement

La fonctionnalité de portefeuille en accès rapide, disponible à partir d'Android 11, permet à l'utilisateur d'accéder aux cartes de paiement et aux autres cartes pertinentes directement depuis le menu Marche/Arrêt. Les principaux cas d'utilisation incluent la sélection du mode de paiement approprié avant d'effectuer une transaction sur un terminal NFC et l'accès rapide aux vols et autres cartes pour les événements à venir.

Sous Android 12 ou version ultérieure, la fonctionnalité Portefeuille d'accès rapide est disponible dans le volet, comme illustré dans les figures 1 et 2.

Fonctionnalité Accès rapide à Wallet dans le volet des notifications — **Figure 1.** Fonctionnalité Accès rapide à Wallet (appareil verrouillé).

Sous Android 11, la fonctionnalité est disponible dans le menu d'alimentation, comme illustré dans la figure 3.

Fonctionnalité Wallet d'accès rapide dans le menu Marche/Arrêt — **Figure 3.** Fonctionnalité Wallet en accès rapide dans le menu Marche/Arrêt.

Conditions requises

Votre appareil doit être équipé de la technologie NFC pour utiliser la fonctionnalité Portefeuille Accès rapide. La fonctionnalité se lie à QuickAccessWalletService de l'application de paiement NFC par défaut, ce qui signifie que l'appareil doit également être compatible avec l'émulation de carte hôte (HCE, Host Card Emulation) NFC.

Présentation des fonctionnalités

L'accès rapide à Wallet se compose de deux parties: l'interface utilisateur de l'accès rapide à Wallet et le fournisseur de cartes d'accès rapide à Wallet.

Sous Android 12 ou version ultérieure, l'UI Wallet s'exécute dans l'UI système et se trouve dans frameworks/base/packages/SystemUI/src/com/android/systemui/wallet. Sous Android 11, l'UI Wallet, qui se trouve dans platform/packages/apps/QuickAccessWallet, doit être installée et ajoutée à la liste blanche.

Le fournisseur de cartes Quick Access Wallet est l'application de paiement NFC par défaut. Les utilisateurs peuvent installer plusieurs applications de paiement NFC simultanément, mais seule l'application de paiement NFC par défaut peut afficher des cartes dans le menu d'alimentation. Vous pouvez spécifier quelle application de paiement NFC est définie initialement comme application par défaut, mais les utilisateurs peuvent sélectionner une autre application dans les paramètres. Si une seule application de paiement NFC est installée, elle devient automatiquement l'application par défaut (voir CardEmulationManager).

Implémentation

Pour fournir des cartes à l'interface utilisateur de Wallet en accès rapide, les applications de paiement NFC doivent implémenter QuickAccessWalletService. Les applications de paiement doivent inclure une entrée de fichier manifeste faisant la promotion du service.

Pour garantir que seule l'UI du système peut être liée à QuickAccessWalletService, l'application de paiement NFC doit exiger l'autorisation android.permission.BIND_QUICK_ACCESS_WALLET_SERVICE. L'exigence de cette autorisation garantit que seule l'UI système peut se lier à QuickAccessWalletService.

<service
     android:name=".MyQuickAccessWalletService"
     android:label="@string/my_default_tile_label"
     android:icon="@drawable/my_default_icon_label"
     android:logo="@drawable/my_wallet_logo"
     android:permission="android.permission.BIND_QUICK_ACCESS_WALLET_SERVICE">
     <intent-filter>
         <action android:name="android.service.quickaccesswallet.QuickAccessWalletService" />
         <category android:name="android.intent.category.DEFAULT"/>
     </intent-filter>
     <meta-data android:name="android.quickaccesswallet"
          android:resource="@xml/quickaccesswallet_configuration" />
     <meta-data
          android:name="android.quickaccesswallet.tile"
          android:resource="@drawable/my_default_tile_icon"/>
</service>

Des informations supplémentaires sur le portefeuille sont incluses dans le fichier XML associé:

<quickaccesswallet-service
   xmlns:android="http://schemas.android.com/apk/res/android"
   android:settingsActivity="com.example.android.SettingsActivity"
   android:shortcutLongLabel="@string/my_wallet_empty_state_text"
   android:shortcutShortLabel="@string/my_wallet_button_text"
   android:targetActivity="com.example.android.WalletActivity"/>

Ensuite, l'application de paiement doit implémenter QuickAccessWalletService:

public class MyQuickAccessWalletService extends QuickAccessWalletService {

    @Override
    public void onWalletCardsRequested(
            GetWalletCardsRequest request,
            GetWalletCardsCallback callback) {
        GetWalletCardsResponse response = // generate response
        callback.onSuccess(response);
    }

    @Override
    public void onWalletCardSelected(SelectWalletCardRequest request) {
        // selecting a card should ensure that it is used when making an NFC payment
    }

    @Override
    public void onWalletDismissed() {
        // May un-select card if the wallet app has the concept of a 'default'
        // payment method
    }
}

Si HostApduService commence à gérer une transaction NFC et, par conséquent, démarre une activité pour afficher la progression et le résultat du paiement, il doit également essayer d'obtenir une référence au QuickAccessWalletService lié et d'appeler QuickAccessWalletService#sendEvent avec un type d'événement TYPE_NFC_PAYMENT_STARTED. L'UI Wallet d'accès rapide est alors fermée, ce qui permet à l'utilisateur de voir l'activité de paiement sans entrave.

Pour en savoir plus sur l'implémentation de QuickAccessWalletService, consultez QuickAccessWalletService et le test CTS TestQuickAccessWalletService.

Activer l'UI d'accès rapide à Wallet sous Android 11

Pour configurer le portefeuille d'accès rapide afin qu'il soit disponible dans le menu Marche/Arrêt d'Android 11, incluez la cible QuickAccessWallet dans la compilation et activez le plug-in globalactions.wallet en ajoutant au fichier overlay/frameworks/base/packages/SystemUI/res/values/config.xml la ligne en gras dans l'exemple de code ci-dessous.

<resources>
    ...
    <!-- SystemUI Plugins that can be loaded on user builds. -->
    <string-array name="config_pluginWhitelist" translatable="false">
        <item>com.android.systemui</item>
        <item>com.android.systemui.plugin.globalactions.wallet</item>
    </string-array>
</resources>

Spécifiez l'application de paiement NFC par défaut dans le fichier de configuration des paramètres à l'aide de def_nfc_payment_component.

L'application de paiement NFC par défaut doit exposer QuickAccessWalletService pour fournir des cartes au portefeuille Quick Access. Si l'application de paiement NFC par défaut n'exporte pas ce service, l'interface utilisateur du portefeuille est masquée.

Détails de l'implémentation de QuickAccessWalletService

QuickAccessWalletService comporte trois méthodes abstraites qui doivent être implémentées : onWalletCardsRequested, onWalletCardSelected et onWalletDismissed. Le diagramme de séquence ci-dessous illustre une séquence d'appels lorsque le portefeuille d'accès rapide s'affiche immédiatement avant un paiement NFC.

Diagramme de séquence de l'accès rapide à Wallet

Exemple de séquence d'appels lorsque l'Accès rapide à votre carte de paiement s'affiche — **Figure 4** : Exemple de séquence d'appels lorsque l'accès rapide à Google Wallet est consulté.

Toutes les vues du portefeuille Accès rapide ne sont pas suivies d'un paiement NFC, mais la figure 4 ci-dessus illustre toutes les fonctionnalités de QuickAccessWalletService. Dans cet exemple, le fournisseur de cartes Quick Access Wallet implémente les éléments en bleu. On suppose que les cartes de paiement sont stockées sur l'appareil dans une base de données et qu'elles sont accessibles via une interface nommée PaymentCardManager. On suppose en outre qu'une activité appelée PaymentActivity affiche le résultat d'un paiement NFC. Le flux se déroule comme suit:

L'utilisateur effectue un geste pour afficher l'Accès rapide à Google Wallet.
L'interface utilisateur du portefeuille Quick Access (qui fait partie de l'UI système) vérifie le gestionnaire de paquets pour voir si l'application de paiement NFC par défaut exporte QuickAccessWalletService.
- Si le service n'est pas exporté, le portefeuille Accès rapide ne s'affiche pas.
L'interface utilisateur de Wallet d'accès rapide se lie au QuickAccessWalletService et appelle onWalletCardsRequested. Cette méthode utilise un objet de requête contenant des données sur le nombre et la taille des cartes pouvant être fournies, ainsi qu'un rappel. Le rappel peut être appelé à partir d'un thread d'arrière-plan.
QuickAccessWalletService calcule les fiches qu'il souhaite afficher, puis appelle la méthode onSuccess sur le rappel fourni. Nous vous recommandons que le service effectue ces actions sur un thread d'arrière-plan.
Dès que les fiches s'affichent, l'UI du système informe QuickAccessWalletService que la première fiche a été sélectionnée en appelant onWalletCardSelected.
- onWalletCardSelected est appelé chaque fois que l'utilisateur sélectionne une nouvelle fiche.
- onWalletCardSelected peut être appelé même si la carte actuellement sélectionnée n'a pas changé.
Lorsque l'utilisateur ferme le portefeuille d'accès rapide, l'UI du système informe QuickAccessWalletService en appelant onWalletDismissed.

Dans l'exemple ci-dessus, l'utilisateur met le téléphone à portée d'un terminal de paiement NFC pendant que le portefeuille est affiché. HostApduService est un composant clé de la gestion des paiements NFC. Il doit être implémenté pour traiter les APDU fournies par le lecteur NFC (pour en savoir plus, consultez la section Émulation de carte basée sur l'hôte). On suppose que l'application de paiement lance une activité pour afficher la progression et le résultat de l'interaction avec le terminal NFC. Toutefois, l'interface utilisateur de Wallet d'accès rapide s'affiche au-dessus de la fenêtre de l'application, ce qui signifie que l'activité de paiement est masquée par l'interface utilisateur de Wallet d'accès rapide. Pour y remédier, l'application doit informer l'UI du système que l'UI Wallet d'accès rapide doit être fermée. Pour ce faire, elle peut obtenir une référence à la QuickAccessWalletService liée et appeler sendWalletServiceEvent avec le type d'événement TYPE_NFC_PAYMENT_STARTED.

Exemple d'implémentation de QuickAccessWalletService

/** Sample implementation of {@link QuickAccessWalletService} */
@RequiresApi(VERSION_CODES.R)
public class MyQuickAccessWalletService extends QuickAccessWalletService {

  private static final String TAG = "QAWalletSvc";
  private ExecutorService executor;
  private PaymentCardManager paymentCardManager;

  @Override
  public void onCreate() {
    super.onCreate();
    if (Build.VERSION.SDK_INT < Build.VERSION_CODES.R) {
      Log.w(TAG, "Should not run on pre-R devices");
      stopSelf();
      return;
    }
    executor = Executors.newSingleThreadExecutor();
    paymentCardManager = new PaymentCardManager();
  }

  @Override
  public void onDestroy() {
    if (Build.VERSION.SDK_INT < Build.VERSION_CODES.R) {
      return;
    }
    executor.shutdownNow();
  }

  @Override
  public void onWalletCardsRequested(
      @NonNull GetWalletCardsRequest request, @NonNull GetWalletCardsCallback callback) {
    if (Build.VERSION.SDK_INT < Build.VERSION_CODES.R) {
      return;
    }
    executor.submit(
        () -> {
          List<PaymentCard> paymentCards = paymentCardManager.getCards();
          int maxCards = Math.min(paymentCards.size(), request.getMaxCards());
          List<WalletCard> walletCards = new ArrayList<>(maxCards);
          int selectedIndex = 0;
          int cardWidthPx = request.getCardWidthPx();
          int cardHeightPx = request.getCardHeightPx();
          for (int index = 0; index < maxCards; index++) {
            PaymentCard paymentCard = paymentCards.get(index);
            WalletCard walletCard =
                new WalletCard.Builder(
                        paymentCard.getCardId(),
                        paymentCard.getCardImage(cardWidthPx, cardHeightPx),
                        paymentCard.getContentDescription(),
                        paymentCard.getPendingIntent())
                    .build();
            walletCards.add(walletCard);
            if (paymentCard.isSelected()) {
              selectedIndex = index;
            }
          }
          GetWalletCardsResponse response =
              new GetWalletCardsResponse(walletCards, selectedIndex);
          callback.onSuccess(response);
        });
  }

  @Override
  public void onWalletCardSelected(@NonNull SelectWalletCardRequest request) {
    if (Build.VERSION.SDK_INT < Build.VERSION_CODES.R) {
      return;
    }
    executor.submit(
        () -> paymentCardManager.selectCardById(request.getCardId()));
  }

  @Override
  public void onWalletDismissed() {
    if (Build.VERSION.SDK_INT < Build.VERSION_CODES.R) {
      return;
    }
    executor.submit(() -> {
      paymentCardManager.removeCardOverrides();
    });
  }
}

Pour en savoir plus sur QuickAccessWalletService, consultez la documentation de référence de l'API QuickAccessWalletService.

Autorisations

L'entrée du fichier manifeste pour QuickAccessWalletService doit nécessiter l'autorisation android.permission.BIND_QUICK_ACCESS_WALLET_SERVICE introduite dans Android 11. Il s'agit d'une autorisation au niveau de la signature détenue par l'UI du système, ce qui signifie que seul le processus d'UI du système peut être lié aux implémentations de QuickAccessWalletService. Sachez que les applications installées en mode hors connexion peuvent revendiquer cette autorisation et obtenir un accès complet aux données QuickAccessWalletService sur les appareils équipés d'Android 10 ou version antérieure. Pour éviter cela, il est recommandé que le service vérifie la version de compilation dans onCreate et n'active le service que sur les appareils équipés d'Android 11 ou version ultérieure. Aucune autre autorisation d'application n'est requise en plus de celles nécessaires pour fournir des services de paiement par émulation de carte hôte.

Si l'application de paiement NFC par défaut n'implémente pas ou n'exporte pas QuickAccessWalletService, l'interface utilisateur de Wallet en accès rapide ne s'affiche pas.

Paramètres sous Android 12

Pour activer ou désactiver le portefeuille d'accès rapide depuis l'écran de verrouillage, les utilisateurs peuvent utiliser l'option Afficher le portefeuille dans Paramètres > Affichage > Écran de verrouillage. Pour désactiver le portefeuille dans le volet, les utilisateurs doivent le modifier manuellement dans le volet des paramètres rapides.

Activer ou désactiver le portefeuille depuis l'écran de verrouillage

Figure 5. Bouton d'activation du portefeuille sur la page "Écran de verrouillage" dans les paramètres.

Paramètres sous Android 11

Les utilisateurs peuvent désactiver la fonctionnalité Wallet Accès rapide dans l'application Paramètres. La page des paramètres se trouve dans Paramètres > Système > Gestes > Cartes et cartes.

Page de paramètres permettant d'activer ou de désactiver la fonctionnalité Accès rapide de Wallet — **Figure 6** : Page des paramètres pour activer ou désactiver la fonctionnalité de portefeuille d'accès rapide.

Personnalisation

Ajouter la vue Wallet en accès rapide à un autre emplacement dans l'UI du système

L'interface utilisateur de Wallet pour l'accès rapide est conçue en tant que plug-in système. Bien que l'implémentation AOSP l'utilise dans GlobalActionsDialog (affichée lors d'une pression prolongée sur le bouton Marche/Arrêt), vous pouvez déplacer la fonctionnalité derrière un autre geste tant que vous respectez le contrat spécifié par l'interface du plug-in.

public interface GlobalActionsPanelPlugin extends Plugin {

  /** Invoked when the view is shown */
  PanelViewController onPanelShown(Callbacks callbacks, boolean deviceLocked);

  /** Callbacks for interacting with the view container */
  interface Callbacks {
    /** Dismisses the view */
    void dismissGlobalActionsMenu();

    /** Starts a PendingIntent, dismissing the keyguard if necessary. */
    void startPendingIntentDismissingKeyguard(PendingIntent pendingIntent);
  }

  /** Provides the Quick Access Wallet view */
  interface PanelViewController {

    /** Returns the QuickAccessWallet view, which may take any size */
    View getPanelContent();

    /** Invoked when the view is dismissed */
    void onDismissed();

    /** Invoked when the device is either locked or unlocked. */
    void onDeviceLockStateChanged(boolean locked);
  }
}

L'interface utilisateur de l'accès rapide à Wallet implémente GlobalActionsPanelPlugin et PanelViewController. GlobalActionsDialog obtient une instance du plug-in Wallet à l'aide de com.android.systemui.Dependency:

GlobalActionsPanelPlugin mPanelPlugin =
    Dependency.get(ExtensionController.class)
        .newExtension(GlobalActionsPanelPlugin.class)
        .withPlugin(GlobalActionsPanelPlugin.class)
        .build()
        .get();

Après avoir vérifié que le plug-in n'est pas nul et que le PanelViewController renvoyé par onPanelShown n'est pas nul, la boîte de dialogue associe le View fourni par getPanelContent à son propre View et fournit les rappels appropriés pour les événements système.

// Construct a Wallet PanelViewController.
// `this` implements GlobalActionsPanelPlugin.Callbacks
GlobalActionsPanelPlugin.PanelViewController mPanelController =
    mPanelPlugin.onPanelShown(this, !mKeyguardStateController.isUnlocked());

// Attach the view
FrameLayout panelContainer = findViewById(R.id.my_panel_container);
FrameLayout.LayoutParams panelParams =
    new FrameLayout.LayoutParams(
        FrameLayout.LayoutParams.MATCH_PARENT,
        FrameLayout.LayoutParams.MATCH_PARENT);
panelContainer.addView(mPanelController.getPanelContent(), panelParams);

// Respond to unlock events (if the view can be accessed while the phone is locked)
keyguardStateController.addCallback(new KeyguardStateController.Callback() {
  @Override
  public void onUnlockedChanged() {
    boolean unlocked = keyguardStateController.isUnlocked()
        || keyguardStateController.canDismissLockScreen();
    mPanelController.onDeviceLockStateChanged(unlocked);
  }
});

// Implement GlobalActionsPanelPlugin.Callbacks
@Override
public void dismissGlobalActionsMenu() {
  dismissDialog();
}
@Override
public void startPendingIntentDismissingKeyguard(PendingIntent pendingIntent) {
  mActivityStarter.startPendingIntentDismissingKeyguard(pendingIntent);
}

// Notify the wallet when the container view is dismissed
mPanelController.onDismissed();

Pour supprimer le portefeuille d'accès rapide du menu d'alimentation, omettez la cible QuickAccessWallet du build du système. Pour supprimer le portefeuille d'accès rapide du menu d'alimentation, mais l'ajouter à une autre vue fournie par l'UI du système, incluez la cible de compilation et supprimez les références à GlobalActionsPanelPlugin de GlobalActionsImpl.

Définir des configurations par défaut

Android 12

Sous Android 12 ou version ultérieure, Wallet en accès rapide est toujours visible dans la fenêtre des réglages rapides. La visibilité du portefeuille d'accès rapide sur l'écran de verrouillage est limitée par le paramètre sécurisé suivant : LOCKSCREEN_SHOW_WALLET. Ce paramètre détermine si l'icône Wallet d'accès rapide s'affiche en bas à droite de l'écran de verrouillage. Ce paramètre est défini sur true par défaut, mais l'utilisateur peut le désactiver dans Settings > Display > Lock screen > Show wallet (Paramètres > Affichage > Écran de verrouillage > Afficher le portefeuille).

Android 11

Dans Android 11, la visibilité de Wallet pour l'accès rapide est limitée par deux paramètres sécurisés : GLOBAL_ACTIONS_PANEL_ENABLED et GLOBAL_ACTIONS_PANEL_AVAILABLE. Le paramètre AVAILABLE détermine si la fonctionnalité peut être activée ou désactivée dans les paramètres. Ce paramètre est défini sur true par WalletPluginService. Si QuickAccessWallet n'est pas inclus dans la compilation, le paramètre reste false. Le paramètre ENABLED est défini sur true par défaut au même endroit, mais l'utilisateur peut le désactiver dans les paramètres. Pour modifier le comportement par défaut, modifiez WalletPluginService#enableFeatureInSettings.

Validation

Pour valider votre implémentation du portefeuille d'accès rapide, exécutez CTS et des tests manuels. Les modifications apportées au plug-in doivent également exécuter les tests robolectriques inclus.

Tests CTS

Exécutez les tests CTS situés à l'adresse cts/tests/quickaccesswallet.

Tests manuels pour Android 12

Pour tester les principales fonctionnalités du portefeuille d'accès rapide, vous avez besoin d'un terminal de paiement NFC (réel ou factice) et d'une application de paiement NFC implémentant QuickAccessWalletService (application de portefeuille). Les principales fonctionnalités à tester incluent la disponibilité, l'état zéro, la sélection de carte et le comportement de l'écran de verrouillage.

Disponibilité

Si l'application de paiement NFC par défaut n'est pas compatible avec cette fonctionnalité, le portefeuille Accès rapide n'est pas accessible dans les Réglages rapides ni sur l'écran de verrouillage.
Si l'application de paiement NFC par défaut est compatible avec cette fonctionnalité, le portefeuille d'accès rapide est accessible dans le volet des réglages rapides.
Si l'application de paiement NFC par défaut est compatible avec cette fonctionnalité et si le paramètre LOCKSCREEN_SHOW_WALLET est défini sur true, le portefeuille d'accès rapide est accessible sur l'écran de verrouillage.
Si l'application de paiement NFC par défaut est compatible avec cette fonctionnalité et que le paramètre LOCKSCREEN_SHOW_WALLET est défini sur false, le portefeuille Accès rapide n'est pas accessible sur l'écran de verrouillage.

État zéro

Si QuickAccessWalletService est activé et exporté, mais ne fournit aucune carte, la carte dans l'ombre s'affiche comme illustré dans l'exemple de la figure 7. Cliquez sur la carte pour ouvrir l'application de paiement NFC par défaut.

Figure 7. Exemple de vignette dans le volet affichant l'application de paiement NFC par défaut.
Cliquez sur la vue d'état vide, comme illustré dans la figure 8, pour ouvrir l'application de paiement NFC par défaut. Cette vue d'état vide ne s'affiche que lorsque l'utilisateur ne dispose plus que d'une carte dans le portefeuille, la supprime de la page d'informations sur la carte, puis revient à la vue du portefeuille.
L'écran de verrouillage affiche l'icône portefeuille.

Vue de l'état vide dans l'Accès rapide à Wallet

Figure 8. Vue d'état vide dans l'interface utilisateur de Wallet pour l'accès rapide.

État non nul

Si l'application Wallet fournit une ou plusieurs cartes, la vignette en demi-teinte s'affiche comme illustré dans la figure 9.

Figure 9. Exemple de carte en demi-teinte lorsque l'application Wallet contient une ou plusieurs cartes.
Cliquez sur la carte pour afficher un carrousel de fiches.
L'écran de verrouillage affiche un bouton qui ouvre Wallet en accès rapide.

Figure 10. Interface utilisateur de Wallet en accès rapide avec une carte affichée
Si la carte affichée représente un mode de paiement NFC, si vous placez le téléphone sur un terminal de paiement NFC, ce mode de paiement est utilisé et la vue portefeuille est ignorée.
Cliquez sur une fiche affichée pour ouvrir l'activité détaillée correspondante.
Si plusieurs cartes sont fournies par QuickAccessWalletService, l'utilisateur peut balayer l'écran pour passer d'une carte à l'autre.
Le menu à développer contient une seule entrée: ouvrir les paramètres de l'écran de verrouillage afin que l'utilisateur puisse modifier l'option Afficher le portefeuille.

Tests de l'état de la serrure

Si le téléphone est verrouillé, le portefeuille est visible dans le volet des Réglages rapides, avec la description Ajouter une carte si aucune carte n'est associée à l'application de paiement par défaut, ou Déverrouiller pour utiliser si des cartes sont associées à l'application de paiement par défaut.
Si le téléphone est verrouillé, la visibilité du portefeuille sur l'écran de verrouillage est contrôlée par le paramètre Secure.LOCKSCREEN_SHOW_WALLET, qui est contrôlé dans les paramètres.
Si le téléphone est verrouillé, que LOCKSCREEN_SHOW_WALLET est sur false et qu'aucune carte n'existe dans l'application de paiement NFC par défaut, le portefeuille ne s'affiche pas sur l'écran de verrouillage.
Si le téléphone est verrouillé, que LOCKSCREEN_SHOW_WALLET est true et qu'aucune carte n'existe dans l'application de paiement NFC par défaut, le portefeuille ne s'affiche pas sur l'écran de verrouillage.
Si le téléphone est verrouillé, que LOCKSCREEN_SHOW_WALLET est true et que des cartes existent dans l'application de paiement NFC par défaut, le portefeuille s'affiche sur l'écran de verrouillage.
Lorsque vous déverrouillez le téléphone alors que le portefeuille s'affiche sur l'écran de verrouillage, les cartes sont à nouveau demandées, ce qui peut entraîner un contenu différent.

Tests d'accessibilité

Les utilisateurs de TalkBack peuvent parcourir la vue Portefeuille en balayant l'écran vers la gauche et vers la droite, et en écoutant les descriptions de contenu des cartes.
Balayez l'écran vers la gauche ou la droite lorsque TalkBack est activé pour sélectionner chaque fiche à tour de rôle. Les utilisateurs de TalkBack peuvent sélectionner et utiliser un mode de paiement NFC sur un terminal de paiement NFC.

Tests manuels pour Android 11

Pour tester les principales fonctionnalités du portefeuille d'accès rapide, vous avez besoin d'un terminal de paiement NFC (réel ou factice) et d'une application de paiement NFC implémentant QuickAccessWalletService (application de portefeuille). Les fonctionnalités de base qui doivent être testées incluent la disponibilité, l'état zéro, la sélection de la carte et le comportement de l'écran de verrouillage.