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 à partir du 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.

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

Fonction de portefeuille à accès rapide à l'ombre — **Figure 1.** Fonction Quick Access Wallet (appareil verrouillé).

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

**Figure 3.** Fonction Quick Access Wallet dans le menu d'alimentation.

Exigences

Votre appareil doit avoir 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 d'accès rapide comprend deux parties : l'interface utilisateur du portefeuille d'accès rapide et le fournisseur de cartes du portefeuille d'accès rapide.

Dans Android 12 ou supérieur, 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 mise sur liste blanche.

Le fournisseur de cartes Quick Access Wallet est l'application de paiement NFC par défaut. Les utilisateurs peuvent avoir plusieurs applications de paiement NFC installées simultanément, 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 application différente dans les paramètres. Si une seule application de paiement NFC est installée, elle devient automatiquement la valeur par défaut (voir CardEmulationManager ).

Mise en œuvre

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

Pour garantir que seule l'interface utilisateur système peut se lier à 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'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 de 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 de l'activité de paiement.

Pour obtenir de la documentation supplémentaire sur l'implémentation QuickAccessWalletService , consultez QuickAccessWalletService et le test TestQuickAccessWalletService CTS.

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

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

<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 def_nfc_payment_component .

L'application de paiement NFC par défaut doit exposer QuickAccessWalletService pour fournir des cartes au portefeuille d'accès rapide. 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 a 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 Quick Access Wallet est visualisé juste 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 portefeuille d'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 carte Quick Access Wallet implémente les éléments soulignés en bleu. Il est supposé 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 faire apparaître 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 et 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 d'arrière-plan.
Dès que les cartes sont affichées, l'interface utilisateur du 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 système notifie QuickAccessWalletService en appelant onWalletDismissed .

Dans l'exemple ci-dessus, l'utilisateur amène le téléphone à portée d'un terminal de paiement NFC pendant que le portefeuille est affiché. Un élément clé de la gestion des paiements NFC est HostApduService , qui doit être implémenté pour traiter les APDU fournis 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 s'affiche 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 à cela, 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 demander 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é que le service vérifie la version de construction dans onCreate et active 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 d'é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 à l'ombre, les utilisateurs doivent le modifier manuellement dans l'ombre des paramètres rapides.

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

Figure 5. Afficher le basculement du portefeuille dans la page de l'écran de verrouillage dans les paramètres.

Paramètres dans Android 11

Les utilisateurs peuvent désactiver la fonction 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 des paramètres pour activer ou désactiver la fonction Quick Access Wallet — **Figure 6.** Page Paramètres pour activer ou désactiver la fonction Quick Access Wallet.

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 plug-in système . Bien que l'implémentation AOSP l'utilise dans GlobalActionsDialog (affiché sur un appui long), vous pouvez déplacer la fonctionnalité derrière un geste différent tant que vous maintenez 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 du portefeuille d'accès rapide implémente GlobalActionsPanelPlugin et PanelViewController . GlobalActionsDialog obtient une instance du plugin de portefeuille 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 plug-in 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 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 de la construction 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 génération 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 d'accès rapide est toujours visible dans l'ombre des paramètres 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 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 portefeuille d'accès rapide est contrôlé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 fonction peut être activée et 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 construction, 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 les 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 doivent également exercer les tests robotiques inclus.

Essais CTS

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

Tests manuels pour Android 12

Le test des principales fonctionnalités du Quick Access Wallet nécessite un terminal de paiement NFC (vrai ou faux) et une application de paiement NFC qui implémente QuickAccessWalletService (application de portefeuille). Les principales fonctionnalités 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 la fonctionnalité, le portefeuille d'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 la fonctionnalité, le portefeuille d'accès rapide est accessible dans l'ombre 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 d'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 d'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 illustré dans l'exemple de la figure 7. Cliquer sur la vignette ouvre l'application de paiement NFC par défaut.
Figure 7. Exemple de mosaïque à l'ombre montrant l'application de paiement NFC par défaut.
Cliquer sur la vue d'état vide comme illustré à 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.

Affichage de l'état vide dans le portefeuille d'accès rapide

Figure 8. Affichage de l'é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 à l'ombre apparaît comme illustré à la figure 9.
Figure 9. Exemple de mosaïque à l'ombre lorsque l'application 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 d'accès rapide avec une carte affichée.
Si la carte affichée représente un mode de paiement NFC, le fait de tenir le téléphone devant 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 passer d'une carte à l'autre.
Le menu de 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 .

Verrouiller les tests d'état

Si le téléphone est verrouillé, le portefeuille est visible dans l'ombre 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 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 les 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 une nouvelle requête des cartes, ce qui peut entraîner un contenu de carte différent.

Essais d'accessibilité

Les utilisateurs de Talkback peuvent naviguer dans la vue du portefeuille en glissant vers la gauche et la droite et en écoutant les descriptions de contenu des cartes.
Glisser vers la gauche et vers 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 principales fonctionnalités du Quick Access Wallet nécessite un terminal de paiement NFC (vrai ou faux) et une application de paiement NFC qui implémente QuickAccessWalletService (application de portefeuille). Les principales fonctionnalités 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.