Rédiger des tests automatisés avec UI Automator

UI Automator est un framework de test d'interface utilisateur adapté aux tests fonctionnels de l'interface utilisateur entre les applications du système et les applications installées. Les API UI Automator vous permettent d'interagir avec les éléments visibles d'un appareil, quel que soit l'élément Activity sélectionné. Vous pouvez ainsi effectuer des opérations telles que l'ouverture du menu des 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.

Remarque :Ce framework nécessite Android 4.3 (niveau d'API 18) ou version ultérieure.

Le framework de test UI Automator est une API basée sur l'instrumentation et fonctionne avec le lanceur de test AndroidJUnitRunner. Il est particulièrement adapté à l'écriture de tests automatisés opaques de type boîte, 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 d'état et d'effectuer des opérations sur l'appareil cible. Pour en savoir plus, consultez la section Accéder à l'état de l'appareil.
• API compatibles avec les tests de l'interface utilisateur entre les applications. Pour en savoir plus, consultez la section API UI Automator.

Remarque :UI Automator et Espresso présentent des fonctionnalités en chevauchement, mais Espresso dispose de plus de mécanismes de synchronisation. Il est donc préférable pour les tests d'interface utilisateur courants.

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. Modifier l'orientation de l'appareil.
2. Appuyer sur des touches physiques, comme "Augmenter le volume"
3. Appuyez sur les boutons Retour, Accueil ou Menu.
4. Ouvrez le volet des notifications.
5. Prendre 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 à connaître les détails de l'implémentation de l'application que vous ciblez. Vous pouvez utiliser ces API pour capturer et manipuler des 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: crée BySelector de manière concise.
• Configurator: vous permet de définir des paramètres clés pour exécuter des tests UI Automator.

Remarque :Certaines API existantes, y compris UiCollection, UiObject, UiScrollable et UiSelector, seront abandonnées dans une prochaine version. Pour bénéficier d'une assistance continue, vous ne devez utiliser que les API mentionnées dans ce document.

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

KotlinJava Plus

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()

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 de votre code source de test et les dépendances de votre projet, comme décrit dans la section 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:

KotlinGroovy Plus

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

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

Remarque :Consultez les notes de version pour obtenir les dernières informations.

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'interface utilisateur 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'interface utilisateur 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 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 listé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 Activer/Désactiver les nœuds NAF pour afficher les composants d'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'UI fournis par Android, consultez la section Interface utilisateur.

Assurer l'accessibilité de votre activité

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 à partir du SDK, vous n'avez pas besoin d'implémenter la prise en charge de 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é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 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 d'assertions et d'annotations JUnit 4, consultez Créer une classe de test unitaire instrumentée.

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 la section 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'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 scrollUntil() pour faire défiler l'écran et setText() pour modifier un champ de texte. Vous pouvez appeler les API des étapes 2 et 3 de manière répétée si nécessaire pour tester des interactions utilisateur plus complexes impliquant plusieurs composants d'interface utilisateur ou séquences d'actions utilisateur.
4. Vérifiez que l'UI reflète l'état ou le comportement attendu après ces interactions utilisateur.

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

Accéder aux composants d'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 diverses 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, telles que forcer la rotation de l'appareil, appuyer sur les boutons physiques de la croix directionnelle et appuyer sur les boutons "Accueil" et "Menu".

Il est recommandé de commencer le test depuis l'écran d'accueil de l'appareil. Depuis l'écran d'accueil (ou tout 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 et interagir avec des éléments d'interface utilisateur spécifiques.

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

KotlinJava Plus

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
    )
  }
}

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écutent 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, si nécessaire. Notez que le framework de test UI Automator recherche une correspondance dans 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 de code suivant montre comment votre test peut créer des instances UiObject2 représentant un bouton "Annuler" et un bouton "OK" dans une application.

KotlinJava Plus

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()
}

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 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é, null est renvoyé.

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 ayant un élément d'UI enfant avec la propriété de texte.

KotlinJava Plus

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

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 de sélection. Par exemple, si vous souhaitez sélectionner la liste de tous les éléments cochés afin de pouvoir les décocher, 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 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 éditable 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 activité 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 ne souhaitez tester que l'application Calculatrice et que vous vous moquez du lanceur.

KotlinJava Plus

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)
}

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 d'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 calculatrice, cliquer dessus dans l'ordre, puis vérifier que le résultat correct s'affiche.

KotlinJava Plus

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)
}

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'UI du système

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

KotlinJava Plus

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

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

KotlinJava Plus

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

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

KotlinJava Plus

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

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

KotlinJava Plus

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

// 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

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 la prédiction de leur durée n'est pas fiable. Vous devez donc demander à UI Automator d'attendre après avoir effectué des opérations. UI Automator propose plusieurs méthodes pour cela:

• UiDevice.performActionAndWait(Runnable action, EventCondition<U> condition, long timeout): par exemple, pour cliquer sur un bouton et attendre qu'une nouvelle fenêtre s'affiche, appelez device.performActionAndWait(() -> button.click(), Until.newWindow(), timeout).
• UiDevice.wait(Condition<Object, U> condition, long timeout): par exemple, pour attendre qu'un UiObject2 spécifique soit présent sur l'appareil, appelez device.wait(Until.hasObject(By.text("my_text")), timeout);.
• UiObject2.wait(@NonNull Condition<Object, U> condition, long timeout): par exemple, pour attendre qu'une case à cocher soit cochée, appelez checkbox.wait(Until.checked(true), timeout);.
• UiObject2.clickAndWait(@NonNull EventCondition<U> condition, long timeout): par exemple, pour cliquer sur un bouton et attendre qu'une nouvelle fenêtre s'affiche, appelez button.clickAndWait(Until.newWindow(), timeout);.
• UiObject2.scrollUntil(@NonNull Direction direction, @NonNull Condition<Object, U> condition): par exemple, pour faire défiler l'écran vers le bas jusqu'à ce qu'un nouvel objet apparaisse, appelez object.scrollUntil(Direction.DOWN, Until.hasObject(By.text('new_obj')));.
• UiObject2.scrollUntil(@NonNull Direction direction, @NonNull EventCondition<U> condition): par exemple, pour faire défiler l'écran vers le bas, appelez object.scrollUntil(Direction.DOWN, Until.scrollFinished(Direction.DOWN));.

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:

KotlinJava Plus

@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))
}

@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:

• Documentation de référence de l'API UI Automator

Exemples

• BasicSample: exemple d'UI Automator de base.