Rédiger des tests automatisés avec UI Automator

UI Automator est un framework de test d'UI adapté aux tests fonctionnels de l'interface utilisateur entre les applications système et 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é. Elles vous permettent donc d'effectuer des opérations telles que l'ouverture du menu "Settings" (Paramètres) ou du lanceur d'applications sur un appareil de test. Votre test peut rechercher un composant d'interface utilisateur à l'aide de descripteurs pratiques, tels que le texte affiché dans ce composant ou sa description de contenu.

Le framework de test UI Automator est une API basée sur une instrumentation et compatible avec le lanceur de test AndroidJUnitRunner. Il est particulièrement adapté à l'écriture de tests automatisés de type boîte opaque, où le code de test ne s'appuie pas sur les détails de l'implémentation interne de l'application cible.

Les principales fonctionnalités du framework de test UI Automator sont les suivantes:

  • API permettant de récupérer des informations d'état et d'effectuer des opérations sur l'appareil cible. Pour en savoir plus, consultez Accéder à l'état des appareils.
  • API compatibles avec les tests d'interface utilisateur entre applications. Pour en savoir plus, consultez les 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 est exécutée et y effectuer des opérations. Vous pouvez appeler ses méthodes pour accéder aux propriétés de l'appareil telles que l'orientation actuelle ou la taille d'affichage. La classe UiDevice vous permet également d'effectuer les actions suivantes:

  1. Modifiez la rotation de l'appareil.
  2. Appuyez sur les touches physiques (par exemple, "augmente le 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 d'accueil, appelez la méthode UiDevice.pressHome().

API UI Automator

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

  • UiObject2: représente un élément d'interface utilisateur visible sur l'appareil.
  • BySelector: spécifie les critères de correspondance des éléments d'interface utilisateur.
  • By: construit BySelector de manière concise.
  • Configurator: permet de définir des paramètres clés pour l'exécution des tests de l'outil 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'interface utilisateur 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-alpha03')
}

Groovy

dependencies {
  ...
  androidTestImplementation 'androidx.test.uiautomator:uiautomator:2.3.0-alpha03'
}

Pour optimiser les tests de votre UI Automator, vous devez d'abord inspecter les composants de l'interface utilisateur 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'interface utilisateur 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 ont 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 mise en page et afficher les propriétés des composants d'interface utilisateur 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 qui correspond à 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 à l'aide de la commande suivante:
 $ uiautomatorviewer

Pour afficher les propriétés de l'interface utilisateur de votre application, procédez comme suit:

  1. Dans l'interface uiautomatorviewer, cliquez sur le bouton Capture d'écran de l'appareil.
  2. Pointez sur l'instantané dans le panneau de gauche pour afficher les composants d'interface utilisateur identifiés par l'outil uiautomatorviewer. Les propriétés sont répertoriées dans le panneau inférieur droit et la hiérarchie de mise en page dans le panneau supérieur droit.
  3. Vous pouvez également cliquer sur le bouton Toggle NAF Nodes (Activer/Désactiver les nœuds NAF) pour afficher les composants de l'interface utilisateur 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'interface utilisateur fournis par Android, consultez la section Interface utilisateur.

Assurez-vous que votre activité est 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 une fonctionnalité d'accessibilité, car ces classes l'ont déjà fait pour vous.

Cependant, certaines applications utilisent des éléments d'interface utilisateur personnalisés pour offrir une expérience utilisateur plus riche. Ces éléments ne fourniront pas de prise en charge automatique de l'accessibilité. Si votre application contient des instances d'une sous-classe de View qui ne provient pas du SDK, veillez à 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 en savoir plus sur l'ajout de fonctionnalités d'accessibilité aux éléments de vue personnalisée, 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 la page 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 la page Créer une classe de test d'unité d'instrumentation.

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 en tant qu'argument.
  2. Obtenez un objet UiObject2 pour accéder à un composant d'interface utilisateur 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'interface utilisateur en appelant une méthode UiObject2. Par exemple, appelez scrollJusqu'() pour le défilement et setText() pour modifier un champ de texte. Vous pouvez appeler les API aux étapes 2 et 3 de façon répétée si nécessaire pour tester des interactions utilisateur plus complexes impliquant plusieurs composants d'interface utilisateur ou des séquences d'actions utilisateur.
  4. Vérifiez que l'interface utilisateur reflète l'état ou le comportement attendus, une fois ces interactions utilisateur effectuées.

Ces étapes sont abordées 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 d'affichage. Votre test peut utiliser l'objet UiDevice pour effectuer des actions au niveau de l'appareil, comme forcer l'appareil à effectuer une rotation spécifique, appuyer sur les boutons matériels du pavé directionnel, et appuyer sur les boutons Accueil et Menu.

Une bonne pratique consiste à démarrer le test depuis l'écran d'accueil de l'appareil. À partir de l'écran d'accueil (ou d'un autre point 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 d'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 cet exemple, l'instruction @SdkSuppress(minSdkVersion = 18) permet de s'assurer que les tests ne s'exécutent que sur les appareils équipés d'Android 4.3 (niveau d'API 18) ou version ultérieure, comme l'exige UI Automator.

Utilisez la méthode findObject() pour récupérer un UiObject2 qui représente une vue correspondant à un critère de sélecteur donné. Si nécessaire, vous pouvez réutiliser les instances UiObject2 que vous avez créées dans d'autres parties des tests de votre application. Notez que le framework de test UI Automator recherche une correspondance dans l'affichage 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 de code suivant montre comment votre test peut construire des instances UiObject2 représentant 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 créer une instance BySelector. BySelector représente une requête pour des éléments spécifiques dans l'interface utilisateur 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 associer plusieurs propriétés pour affiner votre recherche. Si aucun élément d'interface utilisateur correspondant n'est trouvé, une 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 comportant un élément d'interface utilisateur 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 les critères du sélecteur. Par exemple, si vous souhaitez sélectionner une liste de tous les éléments cochés afin de pouvoir les désélectionner, 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'interface utilisateur représenté par cet objet. Vous pouvez spécifier les actions suivantes:

  • 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 un intent ou de lancer une Activity sans utiliser de commandes shell, en obtenant un objet Context via getContext().

L'extrait de code suivant montre comment votre test peut utiliser un intent pour lancer l'application testée. Cette approche est utile lorsque vous souhaitez uniquement tester l'application de calculatrice et que vous ne vous souciez pas du lanceur d'applications.

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 vérifier que les composants de l'interface utilisateur de l'application renvoient les résultats attendus.

L'extrait de code suivant montre comment votre test peut localiser plusieurs boutons dans une application de calcul, cliquer dessus dans l'ordre, puis vérifier que le résultat correct 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 est affiché à 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 n'est pas fiable de prédire leur durée. Vous devez donc faire en sorte que l'outil UI Automator attende après avoir effectué les 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