Rédiger des tests automatisés avec UI Automator

UI Automator est un framework de test d'UI adapté aux UI fonctionnelles multi-applications. des tests sur le système et les applications installées. Les API UI Automator vous permettent d'interagir avec des éléments visibles sur un appareil, quel que soit le Activity dans lequel se trouve ce qui vous permet d'effectuer des opérations, comme ouvrir le menu "Paramètres" ou le lanceur d’applications d’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 son la description du contenu.

Le framework de test UI Automator est une API basée sur l'instrumentation qui fonctionne avec le lanceur de test AndroidJUnitRunner. Il est adapté à l'écriture des tests automatisés opaques de type boîte, où le code de test ne s'appuie pas sur des données détails d'implémentation de l'application cible.

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

Accès à l'état de l'appareil

Le framework de test UI Automator fournit une classe UiDevice permettant d'accéder et effectuer des opérations sur l'appareil sur lequel l'application cible s'exécute. 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 opérations suivantes : actions:

  1. Modifiez la rotation de l'appareil.
  2. Appuyez sur des touches matérielles, par exemple pour augmenter le volume.
  3. Appuyez sur les boutons Retour, Accueil ou Menu.
  4. Ouvrez le volet des notifications.
  5. Faites une capture d'écran de la fenêtre actuelle.

Par exemple, pour simuler une pression sur le bouton d'accueil, appelez UiDevice.pressHome() .

API UI Automator

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

  • UiObject2: représente un élément d'interface utilisateur visible sur l'appareil.
  • BySelector: spécifie les critères des éléments d'interface utilisateur correspondants.
  • By: construit BySelector de manière concise.
  • Configurator: 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'interface utilisateur avec UI Automator, veillez à le configurer l'emplacement du code source et les dépendances du projet, comme décrit dans la section Configurer un projet for AndroidX Test.

Dans le fichier build.gradle de votre module d'application Android, vous devez définir une 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 vos tests UI Automator, vous devez d'abord inspecter l'état composants de l'UI et s'assurer qu'ils sont accessibles. Ces conseils d'optimisation décrites dans les deux sections suivantes.

Inspecter l'interface utilisateur d'un appareil

Avant de concevoir votre test, inspectez les composants de l'interface utilisateur visibles sur le appareil. Pour vous assurer que vos tests UI Automator peuvent accéder à ces composants, vérifiez que ces composants ont des étiquettes de texte visibles, 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 visibles au premier plan de l'appareil. Ces informations vous permettent de créer des tests ultraprécis avec UI Automator. Par exemple, vous pouvez créer un sélecteur d'interface utilisateur 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 Device Screenshot (Capture d'écran de l'appareil).
  2. Pointez sur l'instantané dans le panneau de gauche pour afficher les composants de l'interface utilisateur. identifiés par l'outil uiautomatorviewer. Les propriétés sont répertoriées dans moins élevé panneau de droite 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 Cloud Storage.

Assurez-vous que votre activité est accessible

Le framework de test UI Automator fonctionne mieux sur les applications qui ont implémenté 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 l'accessibilité car ces classes l'ont déjà fait.

Toutefois, certaines applications utilisent des éléments d'interface utilisateur personnalisés afin d'enrichir l'expérience utilisateur. Ces éléments ne permettent pas d'accéder automatiquement à l'accessibilité. Si votre application contient des instances d'une sous-classe de View qui ne proviennent pas du SDK, assurez-vous d'ajouter des fonctionnalités d'accessibilité à ces éléments en suivant les en suivant les étapes ci-dessous:

  1. Créez une classe concrète qui étend ExploreByTouchHelper.
  2. Pour associer une instance de votre nouvelle classe à un élément d'interface utilisateur personnalisé spécifique, procédez comme suit : setAccessibilityDelegate().

Pour obtenir des conseils supplémentaires sur l'ajout de fonctionnalités d'accessibilité à la vue personnalisée consultez la page 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 Développer des applications Accessible :

Créer une classe de test UI Automator

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

Ajoutez l'annotation @RunWith(AndroidJUnit4.class) au début de votre test définition de la classe. Vous devez également spécifier la classe AndroidJUnitRunner, fourni dans AndroidX Test, en tant qu'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 l'argument.
  2. Obtenez un objet UiObject2 pour accéder à un composant d'interface utilisateur affiché sur la (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 : appeler une méthode UiObject2 ; par exemple, appeler scrollJusqu'à() pour faire défiler et setText() pour modifier un champ de texte. Vous pouvez appeler les API aux étapes 2 et 3 autant de fois que 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 attendu une fois que ces comptes utilisateur des interactions.

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

Accéder aux composants de l'interface utilisateur

L'objet UiDevice est le principal moyen d'accéder à l'objet et de le manipuler l'état de l'appareil. 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 d'affichage. Votre test peut utiliser l'objet UiDevice pour effectuer des actions au niveau de l'appareil. Par exemple, forcer l'appareil dans une rotation spécifique, appuyer sur le matériel du pavé directionnel boutons et en appuyant sur les boutons Accueil et Menu.

Nous vous recommandons de commencer votre test à partir de l'écran d'accueil de l'appareil. De l'écran d'accueil (ou tout autre emplacement de départ choisi dans 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 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 l'exemple, l'instruction @SdkSuppress(minSdkVersion = 18) permet de garantir 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, conformément aux exigences du framework UI Automator.

Utilisez la méthode findObject() pour récupérer un UiObject2 qui représente une vue qui correspond à un critère de sélecteur donné. Vous pouvez réutiliser le UiObject2 que vous avez créées dans d'autres parties du test de votre application, selon les besoins. Notez que le framework de test UI Automator recherche dans l'écran actuel une correspondre à chaque fois que votre test utilise une instance UiObject2 pour cliquer sur une UI un élément ou une requête sur une propriété.

L'extrait de code suivant montre comment votre test peut construire 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 By pour construire une instance BySelector. BySelector représente une requête pour des éléments spécifiques de l'interface utilisateur affichée.

Si plusieurs éléments correspondants sont trouvés, le premier élément correspondant dans la la hiérarchie de mise en page est renvoyée en tant que UiObject2 cible. Lorsque vous créez 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. L'exemple de code suivant montre comment votre test peut spécifier une recherche pour trouver la première ListView qui comporte un élément d'UI enfant avec la propriété "text".

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 de votre sélecteur. Pour par exemple, si vous voulez sélectionner une liste de tous les éléments cochés afin de décochez les cases, 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 dans La classe UiObject2 pour effectuer des interactions utilisateur sur le composant d'UI 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() : déplace cet objet vers des coordonnées arbitraires.
  • setText() : définit le texte dans un champ modifiable après avoir effacé la 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(e).

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 contexte. via getContext().

L'extrait de code suivant montre comment votre test peut utiliser un intent pour lancer le application testée. Cette approche est utile lorsque vous souhaitez uniquement tester l'application Calculatrice, et ne se soucient 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

Le cas InstrumentationTestCase étend le TestCase, ce qui vous permet d'utiliser Les méthodes Assert standards de JUnit pour tester le renvoi de composants d'UI dans l'application les résultats attendus.

L'extrait de code suivant montre comment votre test peut localiser plusieurs boutons dans une l'application Calculatrice, cliquez dessus dans l'ordre, puis vérifiez que le bon résultat est affiché.

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 depuis Android Studio ou depuis de la ligne de commande. Veillez à spécifier AndroidJUnitRunner comme valeur par défaut. l'exécuteur d'instrumentation dans votre projet.

Autres exemples

Interagir avec l'UI du système

UI Automator peut interagir avec tout ce qui est à l'écran, y compris les systèmes 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 déranger
Figure 1. UI Automator désactive le mode Ne pas déranger appareil de test.

Les transitions entre les écrans peuvent prendre du temps, et il n'est pas possible de prévoir leur durée. vous devez faire en sorte que UI Automator attende après avoir effectué des opérations. UI Automator propose plusieurs méthodes:

L'extrait de code suivant montre comment utiliser UI Automator pour désactiver la fonctionnalité Mode déranger dans les paramètres système avec 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 de UI Automator dans les tests Android, consultez le les ressources suivantes.

Documentation de référence:

Exemples