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

Portefeuille à accès rapide

La fonction Quick Access Wallet, disponible à partir d'Android 11, permet à l'utilisateur d'accéder aux cartes de paiement et aux laissez-passer pertinents directement depuis le menu d'alimentation. 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 laissez-passer pour les événements à venir.

Sous Android 12 ou version ultérieure, la fonctionnalité Quick Access Wallet est disponible à partir de l'ombre, comme illustré dans la Figure 1 et la Figure 2.

Fonctionnalité de portefeuille à accès rapide à l'ombre — **Figure 1.** Fonctionnalité de portefeuille d'accès rapide (appareil verrouillé).

Sous Android 11, la fonctionnalité est disponible à partir du menu d'alimentation, comme le montre la figure 3.

**Figure 3.** Fonctionnalité de portefeuille d'accès rapide dans le menu d'alimentation.

Exigences

Votre appareil doit disposer de NFC pour utiliser la fonction Quick Access Wallet. La fonctionnalité se lie à QuickAccessWalletService de l'application de paiement NFC par défaut, ce qui signifie que l'appareil doit également prendre en charge l'émulation de carte basée sur l'hôte NFC (HCE) .

Présentation des fonctionnalités

Le portefeuille Quick Access comprend deux parties : l'interface utilisateur du portefeuille Quick Access et le fournisseur de carte Quick Access Wallet.

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

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

Mise en œuvre

Pour fournir des cartes à l'interface utilisateur de Quick Access Wallet, les applications de paiement NFC doivent implémenter QuickAccessWalletService . Les applications de paiement doivent inclure une entrée manifeste annonçant le service.

Pour garantir que seule l'interface utilisateur du système peut se lier à QuickAccessWalletService , l'application de paiement NFC doit nécessiter l'autorisation android.permission.BIND_QUICK_ACCESS_WALLET_SERVICE . Exiger cette autorisation garantit que seule l’interface utilisateur 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 lié :

<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 appeler QuickAccessWalletService#sendEvent avec un type d'événement TYPE_NFC_PAYMENT_STARTED . . Cela entraîne la fermeture de l'interface utilisateur du portefeuille d'accès rapide, permettant ainsi à l'utilisateur une vue dégagée sur l'activité de paiement.

Pour obtenir une documentation supplémentaire sur l’implémentation QuickAccessWalletService , consultez QuickAccessWalletService et le test CTS TestQuickAccessWalletService .

Activation de l'interface utilisateur du portefeuille à accès rapide dans Android 11

Pour configurer le portefeuille d'accès rapide afin qu'il soit disponible à partir du menu d'alimentation d'Android 11, incluez la cible QuickAccessWallet dans la version et activez le plugin globalactions.wallet en ajoutant la ligne en gras dans l'exemple de code ci-dessous au overlay/frameworks/base/packages/SystemUI/res/values/config.xml fichiers overlay/frameworks/base/packages/SystemUI/res/values/config.xml .

<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 la mise en œuvre de QuickAccessWalletService

QuickAccessWalletService dispose de 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'appel lorsque le portefeuille à accès rapide est consulté immédiatement avant un paiement NFC.

Diagramme de séquence du portefeuille à accès rapide

**Figure 4.** Exemple de séquence d'appel lorsque Quick Access Wallet est affiché.

Toutes les vues du Quick Access Wallet 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 carte Quick Access Wallet implémente les éléments indiqués en bleu. On suppose que les cartes de paiement sont stockées sur l'appareil dans une base de données et 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 le portefeuille d'accès rapide.
L'interface utilisateur du portefeuille d'accès rapide (qui fait partie de l'interface utilisateur du système) vérifie le gestionnaire de packages pour voir si l'application de paiement NFC par défaut exporte QuickAccessWalletService .
- Si le service n'est pas exporté, le portefeuille d'accès rapide ne s'affiche pas.
L’interface utilisateur du portefeuille d’accès rapide se lie au QuickAccessWalletService et appelle onWalletCardsRequested . Cette méthode prend un objet de requête contenant des données sur le nombre et la taille des cartes qui peuvent être fournies ainsi qu'un rappel. Le rappel peut être appelé à partir d’un thread d’arrière-plan.
QuickAccessWalletService calcule les cartes qu'il souhaite afficher, puis appelle la méthode onSuccess sur le rappel fourni. Il est recommandé que le service effectue ces actions sur un thread en arrière-plan.
Dès que les cartes sont affichées, l'interface utilisateur système informe QuickAccessWalletService que la première carte a été sélectionnée en appelant onWalletCardSelected .
- onWalletCardSelected est appelé chaque fois que l'utilisateur sélectionne une nouvelle carte.
- onWalletCardSelected peut être appelé même si la carte actuellement sélectionnée n'a pas changé.
Lorsque l'utilisateur rejette le portefeuille d'accès rapide, l'interface utilisateur du système informe QuickAccessWalletService en appelant onWalletDismissed .

Dans l'exemple ci-dessus, l'utilisateur met son téléphone à portée d'un terminal de paiement NFC pendant l'affichage du portefeuille. Un élément clé du traitement des paiements NFC est HostApduService , qui doit être implémenté pour traiter les APDU fournies par le lecteur NFC (pour plus d'informations, voir Émulation de carte basée sur l'hôte ). On suppose que l'application de paiement démarre une activité pour afficher la progression et le résultat de l'interaction avec le terminal NFC. Cependant, l'interface utilisateur du portefeuille d'accès rapide est affichée en haut de la fenêtre de l'application, ce qui signifie que l'activité de paiement est masquée par l'interface utilisateur du portefeuille d'accès rapide. Pour remédier à ce problème, l'application doit informer l'interface utilisateur du système que l'interface utilisateur du portefeuille d'accès rapide doit être fermée. Il peut le faire en obtenant une référence au QuickAccessWalletService lié et en appelant 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 plus de détails sur QuickAccessWalletService , consultez la référence de l'API QuickAccessWalletService .

Autorisations

L'entrée du 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'interface utilisateur système, ce qui signifie que seul le processus de l'interface utilisateur système peut se lier aux implémentations de QuickAccessWalletService . Sachez que les applications chargées latéralement peuvent revendiquer cette autorisation et obtenir un accès complet aux données QuickAccessWalletService sur les appareils exécutant Android 10 ou une version antérieure. Pour éviter cela, il est recommandé au service de vérifier la version de build dans onCreate et d'activer le service uniquement sur les appareils exécutant Android 11 et versions ultérieures. Aucune autre autorisation d'application n'est requise au-delà 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 du portefeuille d'accès rapide ne s'affiche pas.

Paramètres dans Android 12

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

Basculer pour activer ou désactiver le portefeuille depuis l'écran de verrouillage

Figure 5. Afficher la bascule du portefeuille sur la page Écran de verrouillage dans Paramètres.

Paramètres dans Android 11

Les utilisateurs peuvent désactiver la fonctionnalité Quick Access Wallet à partir de l'application Paramètres. La page des paramètres se trouve dans Paramètres > Système > Gestes > Cartes et laissez-passer .

Page Paramètres pour activer ou désactiver la fonctionnalité Quick Access Wallet — **Figure 6.** Page Paramètres pour activer ou désactiver la fonctionnalité Portefeuille d'accès rapide.

Personnalisation

Ajout de la vue Portefeuille d'accès rapide à un autre emplacement dans l'interface utilisateur système

L' interface utilisateur de Quick Access Wallet est conçue comme un plugin système . Bien que l'implémentation AOSP l'utilise dans GlobalActionsDialog (affiché lors d'un appui long), vous pouvez déplacer la fonctionnalité derrière un geste différent tant que vous conservez le contrat spécifié par l'interface du plugin.

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 du portefeuille d'accès rapide implémente GlobalActionsPanelPlugin et PanelViewController . GlobalActionsDialog obtient une instance du plugin wallet en utilisant 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 plugin n'est pas nul et que le PanelViewController renvoyé par onPanelShown n'est pas nul, la boîte de dialogue attache la View fournie par getPanelContent à sa propre View et fournit des 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 Quick Access Wallet du menu d’alimentation, omettez la cible QuickAccessWallet de la version du système. Pour supprimer le portefeuille d'accès rapide du menu d'alimentation mais l'ajouter à une autre vue fournie par l'interface utilisateur système, incluez la cible de construction et supprimez les références au GlobalActionsPanelPlugin de GlobalActionsImpl .

Définition des configurations par défaut

Android 12

Sous Android 12 ou version ultérieure, le portefeuille à accès rapide est toujours visible dans la zone des paramètres rapides. La visibilité du portefeuille d'accès rapide dans l'écran de verrouillage est contrôlée par le paramètre sécurisé suivant : LOCKSCREEN_SHOW_WALLET . Ce paramètre contrôle si l'icône Quick Access Wallet s'affiche en bas à droite de l'écran de verrouillage. Ce paramètre est défini sur true par défaut, mais peut être désactivé par l'utilisateur dans Paramètres > Affichage > Écran de verrouillage > Afficher le portefeuille .

Android 11

Dans Android 11, la visibilité du Quick Access Wallet est limitée par deux paramètres sécurisés : GLOBAL_ACTIONS_PANEL_ENABLED et GLOBAL_ACTIONS_PANEL_AVAILABLE . Le paramètre AVAILABLE contrôle si la fonctionnalité peut être activée et désactivée dans Paramètres. Ce paramètre est défini sur true par WalletPluginService . Si QuickAccessWallet n’est pas inclus dans la build, le paramètre reste false . Le paramètre ENABLED est défini sur true par défaut au même endroit, mais peut être désactivé par l'utilisateur dans Paramètres. Pour modifier le comportement par défaut, modifiez WalletPluginService#enableFeatureInSettings .

Validation

Pour valider votre implémentation du Quick Access Wallet, exécutez des tests CTS et manuels. Les modifications apportées au plugin devraient également exercer les tests robolectriques inclus.

Essais CTS

Exécutez les tests CTS situés dans cts/tests/quickaccesswallet .

Tests manuels pour Android 12

Le test des fonctionnalités de base du Quick Access Wallet nécessite un terminal de paiement NFC (réel ou faux) et une application de paiement NFC qui implémente 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.

Disponibilité

Si l'application de paiement NFC par défaut ne prend pas en charge cette fonctionnalité, le portefeuille à accès rapide n'est accessible ni dans les paramètres rapides ni dans l'écran de verrouillage.
Si l'application de paiement NFC par défaut prend en charge cette fonctionnalité, le portefeuille à accès rapide est accessible dans la zone des paramètres rapides.
Si l'application de paiement NFC par défaut prend en charge la fonctionnalité et si le paramètre LOCKSCREEN_SHOW_WALLET est true , le portefeuille à accès rapide est accessible sur l'écran de verrouillage.
Si l'application de paiement NFC par défaut prend en charge la fonctionnalité et si le paramètre LOCKSCREEN_SHOW_WALLET est 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 vignette dans l'ombre apparaît comme indiqué dans l'exemple de la figure 7. Cliquer sur la vignette ouvre l'application de paiement NFC par défaut.
Figure 7. Exemple de vignette dans l'ombre montrant l'application de paiement NFC par défaut.
Cliquer sur la vue d'état vide, comme le montre la figure 8, ouvre l'application de paiement NFC par défaut. Cette vue d'état vide s'affiche uniquement lorsque l'utilisateur a encore une carte dans le portefeuille, supprime la carte de la page de détails de la carte, puis revient à la vue du portefeuille.
L'écran de verrouillage affiche l'icône du portefeuille.

Vue d'état vide dans le portefeuille à accès rapide

Figure 8. Vue d'état vide dans l'interface utilisateur du portefeuille d'accès rapide.

État non nul

Si l'application de portefeuille fournit une ou plusieurs cartes, la vignette dans l'ombre apparaît comme le montre la figure 9.
Figure 9. Exemple de vignette à l'ombre lorsque l'application de portefeuille contient une ou plusieurs cartes.
Cliquer sur la vignette affiche un carrousel de cartes.
L'écran de verrouillage affiche un bouton qui ouvre le portefeuille d'accès rapide.
Figure 10. Interface utilisateur du portefeuille à accès rapide avec une carte affichée.
Si la carte affichée représente un mode de paiement NFC, le fait de rapprocher le téléphone d'un terminal de paiement NFC entraîne l'utilisation de ce mode de paiement et la vue du portefeuille est fermée.
Cliquer sur une carte affichée ouvre l'activité détaillée de cette carte.
Si plusieurs cartes sont fournies par QuickAccessWalletService , l'utilisateur peut glisser entre les cartes.
Le menu à débordement contient une entrée : ouvrez les paramètres de l'écran de verrouillage afin que l'utilisateur puisse modifier l'option Afficher le portefeuille .

Tests d'état de verrouillage

Si le téléphone est verrouillé, le portefeuille est visible dans le volet des paramètres rapides, avec une description Ajouter une carte si aucune carte n'existe dans l'application de paiement par défaut, ou Déverrouiller pour l'utiliser si des cartes existent dans 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 Paramètres.
Si le téléphone est verrouillé, LOCKSCREEN_SHOW_WALLET est 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é, LOCKSCREEN_SHOW_WALLET est true et qu'aucune carte n'existe dans l'application de paiement NFC par défaut, le portefeuille n'est pas affiché sur l'écran de verrouillage.
Si le téléphone est verrouillé, 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.
Le déverrouillage du téléphone alors que le portefeuille est affiché sur l'écran de verrouillage entraîne la réinterrogation des cartes, ce qui peut entraîner un contenu de carte différent.

Tests d'accessibilité

Les utilisateurs de Talkback peuvent naviguer dans la vue du portefeuille en faisant glisser leur doigt vers la gauche et la droite et en écoutant les descriptions du contenu des cartes.
Faire glisser votre doigt vers la gauche et la droite avec Talkback activé sélectionne chaque carte à 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

Le test des fonctionnalités de base du Quick Access Wallet nécessite un terminal de paiement NFC (réel ou faux) et une application de paiement NFC qui implémente 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 carte et le comportement de l'écran de verrouillage.