Rédiger des tests automatisés avec UI Automator (ancienne documentation)

UI Automator est un framework de test d'UI adapté aux tests fonctionnels d'UI entre applications, qu'il s'agisse d'applications système ou installées. Les API UI Automator vous permettent d'interagir avec les éléments visibles sur un appareil, quel que soit le Activity sélectionné. Vous pouvez ainsi effectuer des opérations telles que l'ouverture du menu "Paramètres" ou du lanceur d'applications sur un appareil de test. Votre test peut rechercher un composant d'UI à l'aide de descripteurs pratiques tels que le texte affiché dans ce composant ou sa description du contenu.

Le framework de test UI Automator est une API basée sur l'instrumentation et fonctionne avec le test runner AndroidJUnitRunner. Il est bien adapté à l'écriture de tests automatisés de type boîte opaque, où le code de test ne repose pas sur les détails d'implémentation internes de l'application cible.

Voici les principales fonctionnalités du framework de test UI Automator :

  • API permettant de récupérer des informations sur l'état et d'effectuer des opérations sur l'appareil cible. Pour en savoir plus, consultez Accéder à l'état de l'appareil.
  • API compatibles avec les tests d'UI entre applications. Pour en savoir plus, consultez API UI Automator.

Accéder à l'état de l'appareil

Le framework de test UI Automator fournit une classe UiDevice pour accéder à l'appareil sur lequel l'application cible s'exécute et effectuer des opérations dessus. Vous pouvez appeler ses méthodes pour accéder aux propriétés de l'appareil, telles que l'orientation actuelle ou la taille de l'écran. La classe UiDevice vous permet également d'effectuer les actions suivantes :

  1. Modifiez la rotation de l'appareil.
  2. Appuyez sur les touches physiques, comme "volume +".
  3. Appuyez sur les boutons "Retour", "Accueil" ou "Menu".
  4. Ouvrez le volet des notifications.
  5. Prenez une capture d'écran de la fenêtre actuelle.

Par exemple, pour simuler une pression sur le bouton Accueil, appelez la méthode UiDevice.pressHome().

API UI Automator

Les API UI Automator vous permettent d'écrire des tests robustes sans avoir besoin de connaître les détails d'implémentation de l'application que vous ciblez. Vous pouvez utiliser ces API pour capturer et manipuler des composants d'UI dans plusieurs applications :

  • UiObject2 : représente un élément d'UI visible sur l'appareil.
  • BySelector : spécifie les critères de correspondance des éléments d'UI.
  • By : construit BySelector de manière concise.
  • Configurator : vous permet de définir des paramètres clés pour exécuter des tests UI Automator.

Par exemple, le code suivant montre comment écrire un script de test qui ouvre une application Gmail sur l'appareil :

Kotlin

device = UiDevice.getInstance(InstrumentationRegistry.getInstrumentation())
device.pressHome()

val gmail: UiObject2 = device.findObject(By.text("Gmail"))
// Perform a click and wait until the app is opened.
val opened: Boolean = gmail.clickAndWait(Until.newWindow(), 3000)
assertThat(opened).isTrue()

Java

device = UiDevice.getInstance(InstrumentationRegistry.getInstrumentation());
device.pressHome();

UiObject2 gmail = device.findObject(By.text("Gmail"));
// Perform a click and wait until the app is opened.
Boolean opened = gmail.clickAndWait(Until.newWindow(), 3000);
assertTrue(opened);

Configurer UI Automator

Avant de créer votre test d'UI avec UI Automator, veillez à configurer l'emplacement du code source de votre test et les dépendances du projet, comme décrit dans Configurer un projet pour AndroidX Test.

Dans le fichier build.gradle de votre module d'application Android, vous devez définir une référence de dépendance à la bibliothèque UI Automator :

Kotlin

dependencies { ... androidTestImplementation("androidx.test.uiautomator:uiautomator:2.3.0") }

Groovy

dependencies { ... androidTestImplementation "androidx.test.uiautomator:uiautomator:2.3.0" }

Pour optimiser vos tests UI Automator, vous devez d'abord inspecter les composants d'UI de l'application cible et vous assurer qu'ils sont accessibles. Ces conseils d'optimisation sont décrits dans les deux sections suivantes.

Inspecter l'UI sur un appareil

Avant de concevoir votre test, inspectez les composants d'interface utilisateur visibles sur l'appareil. Pour vous assurer que vos tests UI Automator peuvent accéder à ces composants, vérifiez qu'ils comportent des libellés de texte visibles, des valeurs android:contentDescription ou les deux.

L'outil uiautomatorviewer fournit une interface visuelle pratique pour inspecter la hiérarchie de la mise en page et afficher les propriétés des composants d'UI qui sont visibles au premier plan de l'appareil. Ces informations vous permettent de créer des tests plus précis à l'aide d'UI Automator. Par exemple, vous pouvez créer un sélecteur d'UI correspondant à une propriété visible spécifique.

Pour lancer l'outil uiautomatorviewer :

  1. Lancez l'application cible sur un appareil physique.
  2. Connectez l'appareil à votre ordinateur de développement.
  3. Ouvrez une fenêtre de terminal et accédez au répertoire <android-sdk>/tools/.
  4. Exécutez l'outil avec cette commande :
 $ uiautomatorviewer

Pour afficher les propriétés de l'UI de votre application :

  1. Dans l'interface uiautomatorviewer, cliquez sur le bouton Device Screenshot (Capture d'écran de l'appareil).
  2. Pointez sur le snapshot dans le panneau de gauche pour afficher les composants d'UI identifiés par l'outil uiautomatorviewer. Les propriétés sont listées dans le panneau inférieur droit et la hiérarchie de la mise en page dans le panneau supérieur droit.
  3. Vous pouvez également cliquer sur le bouton Afficher/Masquer les nœuds NAF pour afficher les composants d'UI qui ne sont pas accessibles à UI Automator. Seules des informations limitées peuvent être disponibles pour ces composants.

Pour en savoir plus sur les types courants de composants d'UI fournis par Android, consultez Interface utilisateur.

Veiller à ce que votre activité soit accessible

Le framework de test UI Automator fonctionne mieux sur les applications qui ont implémenté des fonctionnalités d'accessibilité Android. Lorsque vous utilisez des éléments d'interface utilisateur de type View ou une sous-classe de View du SDK, vous n'avez pas besoin d'implémenter la compatibilité avec l'accessibilité, car ces classes l'ont déjà fait pour vous.

Toutefois, certaines applications utilisent des éléments d'interface utilisateur personnalisés pour offrir une expérience utilisateur plus riche. Ces éléments ne sont pas compatibles avec l'accessibilité automatique. Si votre application contient des instances d'une sous-classe de View qui ne provient pas du SDK, assurez-vous d'ajouter des fonctionnalités d'accessibilité à ces éléments en procédant comme suit :

  1. Créez une classe concrète qui étend ExploreByTouchHelper.
  2. Associez une instance de votre nouvelle classe à un élément d'interface utilisateur personnalisé spécifique en appelant setAccessibilityDelegate().

Pour obtenir des conseils supplémentaires sur l'ajout de fonctionnalités d'accessibilité aux éléments de vue personnalisés, consultez Créer des vues personnalisées accessibles. Pour en savoir plus sur les bonnes pratiques générales en matière d'accessibilité sur Android, consultez Rendre les applications plus accessibles.

Créer une classe de test UI Automator

Votre classe de test UI Automator doit être écrite de la même manière qu'une classe de test JUnit 4. Pour en savoir plus sur la création de classes de test JUnit 4 et l'utilisation des assertions et des annotations JUnit 4, consultez Créer une classe de test unitaire instrumenté.

Ajoutez l'annotation @RunWith(AndroidJUnit4.class) au début de la définition de votre classe de test. Vous devez également spécifier la classe AndroidJUnitRunner, fournie dans AndroidX Test, comme exécuteur de test par défaut. Cette étape est décrite plus en détail dans Exécuter des tests UI Automator sur un appareil ou un émulateur.

Implémentez le modèle de programmation suivant dans votre classe de test UI Automator :

  1. Obtenez un objet UiDevice pour accéder à l'appareil que vous souhaitez tester en appelant la méthode getInstance() et en lui transmettant un objet Instrumentation comme argument.
  2. Obtenez un objet UiObject2 pour accéder à un composant d'UI affiché sur l'appareil (par exemple, la vue actuelle au premier plan) en appelant la méthode findObject().
  3. Simulez une interaction utilisateur spécifique à effectuer sur ce composant d'UI en appelant une méthode UiObject2. Par exemple, appelez scrollUntil() pour faire défiler et setText() pour modifier un champ de texte. Vous pouvez appeler les API des étapes 2 et 3 à plusieurs reprises si nécessaire pour tester des interactions utilisateur plus complexes impliquant plusieurs composants d'UI ou séquences d'actions utilisateur.
  4. Vérifiez que l'UI reflète l'état ou le comportement attendus après l'exécution de ces interactions utilisateur.

Ces étapes sont décrites plus en détail dans les sections ci-dessous.

Accéder aux composants de l'UI

L'objet UiDevice est le principal moyen d'accéder à l'état de l'appareil et de le manipuler. Dans vos tests, vous pouvez appeler des méthodes UiDevice pour vérifier l'état de différentes propriétés, telles que l'orientation actuelle ou la taille de l'écran. Votre test peut utiliser l'objet UiDevice pour effectuer des actions au niveau de l'appareil, comme forcer l'appareil à adopter une rotation spécifique, appuyer sur les boutons matériels du pavé directionnel, et appuyer sur les boutons "Accueil" et "Menu".

Il est recommandé de commencer votre test à partir de l'écran d'accueil de l'appareil. À partir de l'écran d'accueil (ou d'un autre emplacement de départ que vous avez choisi sur l'appareil), vous pouvez appeler les méthodes fournies par l'API UI Automator pour sélectionner des éléments d'interface utilisateur spécifiques et interagir avec eux.

L'extrait de code suivant montre comment votre test peut obtenir une instance de UiDevice et simuler une pression sur le bouton Accueil :

Kotlin

import org.junit.Before
import androidx.test.runner.AndroidJUnit4
import androidx.test.uiautomator.UiDevice
import androidx.test.uiautomator.By
import androidx.test.uiautomator.Until
...

private const val BASIC_SAMPLE_PACKAGE = "com.example.android.testing.uiautomator.BasicSample"
private const val LAUNCH_TIMEOUT = 5000L
private const val STRING_TO_BE_TYPED = "UiAutomator"

@RunWith(AndroidJUnit4::class)
@SdkSuppress(minSdkVersion = 18)
class ChangeTextBehaviorTest2 {

private lateinit var device: UiDevice

@Before
fun startMainActivityFromHomeScreen() {
  // Initialize UiDevice instance
  device = UiDevice.getInstance(InstrumentationRegistry.getInstrumentation())

  // Start from the home screen
  device.pressHome()

  // Wait for launcher
  val launcherPackage: String = device.launcherPackageName
  assertThat(launcherPackage, notNullValue())
  device.wait(
    Until.hasObject(By.pkg(launcherPackage).depth(0)),
    LAUNCH_TIMEOUT
  )

  // Launch the app
  val context = ApplicationProvider.getApplicationContext<Context>()
  val intent = context.packageManager.getLaunchIntentForPackage(
  BASIC_SAMPLE_PACKAGE).apply {
    // Clear out any previous instances
    addFlags(Intent.FLAG_ACTIVITY_CLEAR_TASK)
  }
  context.startActivity(intent)

  // Wait for the app to appear
  device.wait(
    Until.hasObject(By.pkg(BASIC_SAMPLE_PACKAGE).depth(0)),
    LAUNCH_TIMEOUT
    )
  }
}

Java

import org.junit.Before;
import androidx.test.runner.AndroidJUnit4;
import androidx.test.uiautomator.UiDevice;
import androidx.test.uiautomator.By;
import androidx.test.uiautomator.Until;
...

@RunWith(AndroidJUnit4.class)
@SdkSuppress(minSdkVersion = 18)
public class ChangeTextBehaviorTest {

  private static final String BASIC_SAMPLE_PACKAGE
  = "com.example.android.testing.uiautomator.BasicSample";
  private static final int LAUNCH_TIMEOUT = 5000;
  private static final String STRING_TO_BE_TYPED = "UiAutomator";
  private UiDevice device;

  @Before
  public void startMainActivityFromHomeScreen() {
    // Initialize UiDevice instance
    device = UiDevice.getInstance(InstrumentationRegistry.getInstrumentation());

    // Start from the home screen
    device.pressHome();

    // Wait for launcher
    final String launcherPackage = device.getLauncherPackageName();
    assertThat(launcherPackage, notNullValue());
    device.wait(Until.hasObject(By.pkg(launcherPackage).depth(0)),
    LAUNCH_TIMEOUT);

    // Launch the app
    Context context = ApplicationProvider.getApplicationContext();
    final Intent intent = context.getPackageManager()
    .getLaunchIntentForPackage(BASIC_SAMPLE_PACKAGE);
    // Clear out any previous instances
    intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TASK);
    context.startActivity(intent);

    // Wait for the app to appear
    device.wait(Until.hasObject(By.pkg(BASIC_SAMPLE_PACKAGE).depth(0)),
    LAUNCH_TIMEOUT);
    }
}

Dans l'exemple, l'instruction @SdkSuppress(minSdkVersion = 18) permet de s'assurer que les tests ne s'exécuteront que sur les appareils équipés d'Android 4.3 (niveau d'API 18) ou version ultérieure, comme l'exige le framework UI Automator.

Utilisez la méthode findObject() pour récupérer un UiObject2 qui représente une vue correspondant à des critères de sélecteur donnés. Vous pouvez réutiliser les instances UiObject2 que vous avez créées dans d'autres parties de vos tests d'application, selon vos besoins. Notez que le framework de test UI Automator recherche une correspondance sur l'écran actuel chaque fois que votre test utilise une instance UiObject2 pour cliquer sur un élément d'interface utilisateur ou interroger une propriété.

L'extrait suivant montre comment votre test peut construire des instances UiObject2 qui représentent un bouton "Annuler" et un bouton "OK" dans une application.

Kotlin

val okButton: UiObject2 = device.findObject(
    By.text("OK").clazz("android.widget.Button")
)

// Simulate a user-click on the OK button, if found.
if (okButton != null) {
    okButton.click()
}

Java

UiObject2 okButton = device.findObject(
    By.text("OK").clazz("android.widget.Button")
);

// Simulate a user-click on the OK button, if found.
if (okButton != null) {
    okButton.click();
}

Spécifier un sélecteur

Si vous souhaitez accéder à un composant d'interface utilisateur spécifique dans une application, utilisez la classe By pour construire une instance BySelector. BySelector représente une requête pour des éléments spécifiques de l'UI affichée.

Si plusieurs éléments correspondants sont trouvés, le premier élément correspondant dans la hiérarchie de mise en page est renvoyé en tant que UiObject2 cible. Lorsque vous créez un BySelector, vous pouvez enchaîner plusieurs propriétés pour affiner votre recherche. Si aucun élément d'interface utilisateur correspondant n'est trouvé, une valeur null est renvoyée.

Vous pouvez utiliser la méthode hasChild() ou hasDescendant() pour imbriquer plusieurs instances BySelector. Par exemple, l'exemple de code suivant montre comment votre test peut spécifier une recherche pour trouver le premier ListView qui comporte un élément d'UI enfant avec la propriété de texte.

Kotlin

val listView: UiObject2 = device.findObject(
    By.clazz("android.widget.ListView")
        .hasChild(
            By.text("Apps")
        )
)

Java

UiObject2 listView = device.findObject(
    By.clazz("android.widget.ListView")
        .hasChild(
            By.text("Apps")
        )
);

Il peut être utile de spécifier l'état de l'objet dans vos critères de sélecteur. Par exemple, si vous souhaitez sélectionner une liste de tous les éléments cochés pour pouvoir les effacer, appelez la méthode checked() avec l'argument défini sur "true".

Effectuer des actions

Une fois que votre test a obtenu un objet UiObject2, vous pouvez appeler les méthodes de la classe UiObject2 pour effectuer des interactions utilisateur sur le composant d'UI représenté par cet objet. Vous pouvez spécifier des actions telles que :

  • click() : clique au centre des limites visibles de l'élément d'interface utilisateur.
  • drag() : fait glisser cet objet vers des coordonnées arbitraires.
  • setText() : définit le texte dans un champ modifiable, après avoir effacé le contenu du champ. À l'inverse, la méthode clear() efface le texte existant dans un champ modifiable.
  • swipe() : effectue l'action de balayage dans la direction spécifiée.
  • scrollUntil() : effectue l'action de défilement dans la direction spécifiée jusqu'à ce que Condition ou EventCondition soit satisfait.

Le framework de test UI Automator vous permet d'envoyer une Intent ou de lancer une Activity sans utiliser de commandes shell, en obtenant un objet Context via getContext().

L'extrait suivant montre comment votre test peut utiliser un Intent pour lancer l'application en cours de test. Cette approche est utile lorsque vous ne souhaitez tester que l'application Calculatrice et que le lanceur d'applications ne vous intéresse pas.

Kotlin

fun setUp() {
...

  // Launch a simple calculator app
  val context = getInstrumentation().context
  val intent = context.packageManager.getLaunchIntentForPackage(CALC_PACKAGE).apply {
    addFlags(Intent.FLAG_ACTIVITY_CLEAR_TASK)
  }
  // Clear out any previous instances
  context.startActivity(intent)
  device.wait(Until.hasObject(By.pkg(CALC_PACKAGE).depth(0)), TIMEOUT)
}

Java

public void setUp() {
...

  // Launch a simple calculator app
  Context context = getInstrumentation().getContext();
  Intent intent = context.getPackageManager()
  .getLaunchIntentForPackage(CALC_PACKAGE);
  intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TASK);

  // Clear out any previous instances
  context.startActivity(intent);
  device.wait(Until.hasObject(By.pkg(CALC_PACKAGE).depth(0)), TIMEOUT);
}

Vérifier les résultats

InstrumentationTestCase étend TestCase. Vous pouvez donc utiliser les méthodes Assert JUnit standards pour tester que les composants d'UI de l'application renvoient les résultats attendus.

L'extrait suivant montre comment votre test peut localiser plusieurs boutons dans une application de calculatrice, cliquer dessus dans l'ordre, puis vérifier que le bon résultat s'affiche.

Kotlin

private const val CALC_PACKAGE = "com.myexample.calc"

fun testTwoPlusThreeEqualsFive() {
  // Enter an equation: 2 + 3 = ?
  device.findObject(By.res(CALC_PACKAGE, "two")).click()
  device.findObject(By.res(CALC_PACKAGE, "plus")).click()
  device.findObject(By.res(CALC_PACKAGE, "three")).click()
  device.findObject(By.res(CALC_PACKAGE, "equals")).click()

  // Verify the result = 5
  val result: UiObject2 = device.findObject(By.res(CALC_PACKAGE, "result"))
  assertEquals("5", result.text)
}

Java

private static final String CALC_PACKAGE = "com.myexample.calc";

public void testTwoPlusThreeEqualsFive() {
  // Enter an equation: 2 + 3 = ?
  device.findObject(By.res(CALC_PACKAGE, "two")).click();
  device.findObject(By.res(CALC_PACKAGE, "plus")).click();
  device.findObject(By.res(CALC_PACKAGE, "three")).click();
  device.findObject(By.res(CALC_PACKAGE, "equals")).click();

  // Verify the result = 5
  UiObject2 result = device.findObject(By.res(CALC_PACKAGE, "result"));
  assertEquals("5", result.getText());
}

Exécuter des tests UI Automator sur un appareil ou un émulateur

Vous pouvez exécuter des tests UI Automator à partir d'Android Studio ou de la ligne de commande. Veillez à spécifier AndroidJUnitRunner comme exécuteur d'instrumentation par défaut dans votre projet.

Autres exemples

Interagir avec l'interface utilisateur du système

UI Automator peut interagir avec tout ce qui se trouve à l'écran, y compris les éléments système en dehors de votre application, comme indiqué dans les extraits de code suivants :

Kotlin

// Opens the System Settings.
device = UiDevice.getInstance(InstrumentationRegistry.getInstrumentation())
device.executeShellCommand("am start -a android.settings.SETTINGS")

Java

// Opens the System Settings.
device = UiDevice.getInstance(InstrumentationRegistry.getInstrumentation());
device.executeShellCommand("am start -a android.settings.SETTINGS");

Kotlin

// Opens the notification shade.
device = UiDevice.getInstance(InstrumentationRegistry.getInstrumentation())
device.openNotification()

Java

// Opens the notification shade.
device = UiDevice.getInstance(InstrumentationRegistry.getInstrumentation());
device.openNotification();

Kotlin

// Opens the Quick Settings shade.
device = UiDevice.getInstance(InstrumentationRegistry.getInstrumentation())
device.openQuickSettings()

Java

// Opens the Quick Settings shade.
device = UiDevice.getInstance(InstrumentationRegistry.getInstrumentation());
device.openQuickSettings();

Kotlin

// Get the system clock.
device = UiDevice.getInstance(InstrumentationRegistry.getInstrumentation())
UiObject2 clock = device.findObject(By.res("com.android.systemui:id/clock"))
print(clock.getText())

Java

// Get the system clock.
device = UiDevice.getInstance(InstrumentationRegistry.getInstrumentation());
UiObject2 clock = device.findObject(By.res("com.android.systemui:id/clock"));
print(clock.getText());

Attendre les transitions

Désactiver le mode déranger
Figure 1. UI Automator désactive le mode Ne pas déranger sur un appareil de test.

Les transitions d'écran peuvent prendre du temps et il est difficile de prédire leur durée. Vous devez donc demander à UI Automator d'attendre après avoir effectué des opérations. UI Automator propose plusieurs méthodes pour cela :

L'extrait de code suivant montre comment utiliser UI Automator pour désactiver le mode Ne pas déranger dans les paramètres système à l'aide de la méthode performActionAndWait() qui attend les transitions :

Kotlin

@Test
@SdkSuppress(minSdkVersion = 21)
@Throws(Exception::class)
fun turnOffDoNotDisturb() {
    device = UiDevice.getInstance(InstrumentationRegistry.getInstrumentation())
    device.performActionAndWait({
        try {
            device.executeShellCommand("am start -a android.settings.SETTINGS")
        } catch (e: IOException) {
            throw RuntimeException(e)
        }
    }, Until.newWindow(), 1000)
    // Check system settings has been opened.
    Assert.assertTrue(device.hasObject(By.pkg("com.android.settings")))

    // Scroll the settings to the top and find Notifications button
    var scrollableObj: UiObject2 = device.findObject(By.scrollable(true))
    scrollableObj.scrollUntil(Direction.UP, Until.scrollFinished(Direction.UP))
    val notificationsButton = scrollableObj.findObject(By.text("Notifications"))

    // Click the Notifications button and wait until a new window is opened.
    device.performActionAndWait({ notificationsButton.click() }, Until.newWindow(), 1000)
    scrollableObj = device.findObject(By.scrollable(true))
    // Scroll down until it finds a Do Not Disturb button.
    val doNotDisturb = scrollableObj.scrollUntil(
        Direction.DOWN,
        Until.findObject(By.textContains("Do Not Disturb"))
    )
    device.performActionAndWait({ doNotDisturb.click() }, Until.newWindow(), 1000)
    // Turn off the Do Not Disturb.
    val turnOnDoNotDisturb = device.findObject(By.text("Turn on now"))
    turnOnDoNotDisturb?.click()
    Assert.assertTrue(device.wait(Until.hasObject(By.text("Turn off now")), 1000))
}

Java

@Test
@SdkSuppress(minSdkVersion = 21)
public void turnOffDoNotDisturb() throws Exception{
    device = UiDevice.getInstance(InstrumentationRegistry.getInstrumentation());
    device.performActionAndWait(() -> {
        try {
            device.executeShellCommand("am start -a android.settings.SETTINGS");
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }, Until.newWindow(), 1000);
    // Check system settings has been opened.
    assertTrue(device.hasObject(By.pkg("com.android.settings")));

    // Scroll the settings to the top and find Notifications button
    UiObject2 scrollableObj = device.findObject(By.scrollable(true));
    scrollableObj.scrollUntil(Direction.UP, Until.scrollFinished(Direction.UP));
    UiObject2 notificationsButton = scrollableObj.findObject(By.text("Notifications"));

    // Click the Notifications button and wait until a new window is opened.
    device.performActionAndWait(() -> notificationsButton.click(), Until.newWindow(), 1000);
    scrollableObj = device.findObject(By.scrollable(true));
    // Scroll down until it finds a Do Not Disturb button.
    UiObject2 doNotDisturb = scrollableObj.scrollUntil(Direction.DOWN,
            Until.findObject(By.textContains("Do Not Disturb")));
    device.performActionAndWait(()-> doNotDisturb.click(), Until.newWindow(), 1000);
    // Turn off the Do Not Disturb.
    UiObject2 turnOnDoNotDisturb = device.findObject(By.text("Turn on now"));
    if(turnOnDoNotDisturb != null) {
        turnOnDoNotDisturb.click();
    }
    assertTrue(device.wait(Until.hasObject(By.text("Turn off now")), 1000));
}

Ressources supplémentaires

Pour en savoir plus sur l'utilisation d'UI Automator dans les tests Android, consultez les ressources suivantes.

Documentation de référence :

Exemples