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:
- Modifiez la rotation de l'appareil.
- Appuyez sur les touches physiques (par exemple, "augmente le volume").
- Appuyez sur les boutons Retour, Accueil ou Menu.
- Ouvrez le volet des notifications.
- 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
: construitBySelector
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
:
- Lancez l'application cible sur un appareil physique.
- Connectez l'appareil à votre ordinateur de développement.
- Ouvrez une fenêtre de terminal et accédez au répertoire
<android-sdk>/tools/
. - 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:
- Dans l'interface
uiautomatorviewer
, cliquez sur le bouton Capture d'écran de l'appareil. - 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. - 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:
- Créez une classe concrète qui étend ExploreByTouchHelper.
- 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:
- 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. - 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(). - 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. - 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éthodeclear()
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 queCondition
ouEventCondition
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
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:
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, appelezdevice.performActionAndWait(() -> button.click(), Until.newWindow(), timeout)
.UiDevice.wait(Condition<Object, U> condition, long timeout)
: par exemple, pour attendre qu'un certainUiObject2
soit présent sur l'appareil, appelezdevice.wait(device.hasObject(By.text("my_text")), timeout);
.UiObject2.wait(@NonNull Condition<Object, U> condition, long timeout)
: par exemple, pour attendre qu'une case soit cochée, appelezcheckbox.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, appelezbutton.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, appelezobject.scrollUntil(Direction.DOWN, Until.hasObject(By.text('new_obj')));
.UiObject2.scrollUntil(@NonNull Direction direction, @NonNull EventCondition<U> condition)
: par exemple, pour faire défiler la page jusqu'en bas, appelezobject.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:
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
- BasicSample: un exemple d'UI de base avec Automator.