UI Automator ist ein Framework für UI-Tests, das sich für appübergreifende Funktionstests auf System- und installierten Apps eignet. Über die UI Automator APIs können Sie mit sichtbaren Elementen auf einem Gerät interagieren, unabhängig davon, welches Activity
im Fokus ist. So können Sie z. B. das Menü „Einstellungen“ oder den App Launcher auf einem Testgerät öffnen. Ihr Test kann eine UI-Komponente mithilfe praktischer Deskriptoren wie dem in der Komponente angezeigten Text oder der Inhaltsbeschreibung nachschlagen.
Das UI Automator-Test-Framework ist eine instrumentierungsbasierte API und funktioniert mit dem Test-Runner AndroidJUnitRunner
. Sie eignet sich gut zum Schreiben automatisierter Tests im opaque-box-Stil, bei denen der Testcode nicht von internen Implementierungsdetails der Ziel-App abhängt.
Zu den wichtigsten Funktionen des UI Automator-Test-Frameworks gehören:
- Eine API zum Abrufen von Statusinformationen und zum Ausführen von Vorgängen auf dem Zielgerät. Weitere Informationen finden Sie unter Auf Gerätestatus zugreifen.
- APIs, die App-übergreifende UI-Tests unterstützen Weitere Informationen finden Sie unter UI Automator APIs.
Auf Gerätestatus zugreifen
Das UI Automator-Test-Framework bietet eine UiDevice
-Klasse für den Zugriff und das Ausführen von Vorgängen auf dem Gerät, auf dem die Ziel-App ausgeführt wird. Sie können die zugehörigen Methoden aufrufen, um auf Geräteeigenschaften wie die aktuelle Ausrichtung oder die Anzeigegröße zuzugreifen. Mit der Klasse UiDevice
können Sie außerdem folgende Aktionen ausführen:
- Ändern Sie die Geräteausrichtung.
- Drücken Sie Hardwaretasten, z. B. die Lautertaste.
- Drücken Sie die Zurück-Taste, die Taste für den Startbildschirm oder die Menü-Taste.
- Öffnen Sie die Benachrichtigungsleiste.
- Machen Sie einen Screenshot des aktuellen Fensters.
Wenn Sie beispielsweise das Drücken der Startbildschirmtaste simulieren möchten, rufen Sie die Methode UiDevice.pressHome()
auf.
UI Automator APIs
Mit den UI Automator APIs können Sie zuverlässige Tests schreiben, ohne sich über die Implementierungsdetails der Zielanwendung informieren zu müssen. Mit diesen APIs können Sie UI-Komponenten in mehreren Apps erfassen und bearbeiten:
UiObject2
: Stellt ein UI-Element dar, das auf dem Gerät sichtbar ist.BySelector
: gibt Kriterien für übereinstimmende UI-Elemente an.By
: KonstruiertBySelector
auf prägnante Weise.Configurator
: Hiermit können Sie wichtige Parameter zum Ausführen von UI Automator-Tests festlegen.
Der folgende Code zeigt beispielsweise, wie Sie ein Testskript schreiben, mit dem eine Gmail-App auf dem Gerät geöffnet wird:
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);
UI Automator einrichten
Bevor Sie den UI-Test mit UI Automator erstellen, müssen Sie den Speicherort des Testquellcodes und die Projektabhängigkeiten konfigurieren, wie unter Projekt für AndroidX Test einrichten beschrieben.
Legen Sie in der Datei build.gradle
Ihres Android-App-Moduls einen Abhängigkeitsverweis auf die UI Automator-Bibliothek fest:
Kotlin
dependencies {
...
androidTestImplementation('androidx.test.uiautomator:uiautomator:2.3.0-alpha03')
}
Groovig
dependencies {
...
androidTestImplementation 'androidx.test.uiautomator:uiautomator:2.3.0-alpha03'
}
Zur Optimierung der UI Automator-Tests sollten Sie zuerst die UI-Komponenten der Ziel-App prüfen und dafür sorgen, dass sie zugänglich sind. Diese Optimierungstipps werden in den nächsten beiden Abschnitten beschrieben.
Benutzeroberfläche eines Geräts prüfen
Prüfen Sie vor dem Entwerfen des Tests die UI-Komponenten, die auf dem Gerät sichtbar sind. Damit Ihre UI Automator-Tests auf diese Komponenten zugreifen können, müssen diese Komponenten sichtbare Textlabels, android:contentDescription
-Werte oder beides haben.
Das uiautomatorviewer
-Tool bietet eine praktische visuelle Oberfläche, um die Layouthierarchie zu prüfen und die Eigenschaften von UI-Komponenten aufzurufen, die im Vordergrund des Geräts sichtbar sind. Anhand dieser Informationen können Sie mit UI Automator präzisere Tests erstellen. Sie können beispielsweise einen UI-Selektor erstellen, der einem bestimmten sichtbaren Attribut entspricht.
So starten Sie das uiautomatorviewer
-Tool:
- Starten Sie die Ziel-App auf einem physischen Gerät.
- Verbinden Sie das Gerät mit Ihrem Entwicklungscomputer.
- Öffnen Sie ein Terminalfenster und gehen Sie zum Verzeichnis
<android-sdk>/tools/
. - Führen Sie das Tool mit diesem Befehl aus:
$ uiautomatorviewer
So rufen Sie die UI-Attribute für Ihre Anwendung auf:
- Klicken Sie auf der Benutzeroberfläche von
uiautomatorviewer
auf die Schaltfläche Geräte-Screenshot. - Bewegen Sie den Mauszeiger im linken Bereich auf den Snapshot, um die vom
uiautomatorviewer
-Tool erkannten UI-Komponenten zu sehen. Die Eigenschaften sind unten rechts und die Layouthierarchie oben rechts aufgeführt. - Klicken Sie optional auf die Schaltfläche NAF-Knoten ein-/ausblenden, um UI-Komponenten zu sehen, auf die UI Automator nicht zugreifen kann. Für diese Komponenten sind möglicherweise nur begrenzte Informationen verfügbar.
Informationen zu den gängigen Typen von UI-Komponenten, die von Android bereitgestellt werden, finden Sie unter Benutzeroberfläche.
Sicherstellen, dass Ihre Aktivität zugänglich ist
Das UI Automator-Test-Framework funktioniert besser bei Apps, in denen Android-Bedienungshilfen implementiert sind. Wenn du UI-Elemente vom Typ View
oder eine abgeleitete Klasse von View
aus dem SDK verwendest, musst du keine Unterstützung für Bedienungshilfen implementieren, da diese Klassen das bereits für dich übernommen haben.
Einige Apps verwenden jedoch benutzerdefinierte UI-Elemente, um die Nutzererfahrung zu verbessern.
Solche Elemente bieten keine automatische Unterstützung für Bedienungshilfen. Wenn deine App Instanzen einer Unterklasse von View
enthält, die nicht aus dem SDK stammt, musst du diesen Elementen Bedienungshilfen hinzufügen. Führe dazu die folgenden Schritte aus:
- Erstellen Sie eine konkrete Klasse, die ExploreByTouchHelper erweitert.
- Rufen Sie setAccessibilityDelegate() auf, um eine Instanz der neuen Klasse mit einem bestimmten benutzerdefinierten UI-Element zu verknüpfen.
Weitere Informationen zum Hinzufügen von Bedienungshilfen zu benutzerdefinierten Ansichtselementen finden Sie unter Barrierefreie benutzerdefinierte Ansichten erstellen. Weitere Informationen zu allgemeinen Best Practices für Bedienungshilfen unter Android findest du unter Apps barrierefrei gestalten.
UI Automator-Testklasse erstellen
Ihre UI Automator-Testklasse sollte genauso geschrieben werden wie eine JUnit 4-Testklasse. Weitere Informationen zum Erstellen von JUnit 4-Testklassen und zum Verwenden von JUnit 4-Assertions und -Annotationen finden Sie unter Instrumentierte Einheitentestklasse erstellen.
Fügen Sie die Annotation @RunWith(AndroidJUnit4.class) am Anfang der Definition der Testklasse hinzu. Außerdem müssen Sie die in AndroidX Test bereitgestellte Klasse AndroidJUnitRunner als Standard-Test-Runner angeben. Dieser Schritt wird unter UI Automator-Tests auf einem Gerät oder Emulator ausführen ausführlicher beschrieben.
Implementieren Sie das folgende Programmiermodell in Ihrer UI Automator-Testklasse:
- Rufen Sie ein
UiDevice
-Objekt für den Zugriff auf das zu testende Gerät ab. Dazu rufen Sie die Methode getInstance() auf und übergeben ein Instrumentation-Objekt als Argument. - Rufen Sie ein
UiObject2
-Objekt ab, um auf eine UI-Komponente zuzugreifen, die auf dem Gerät angezeigt wird (z. B. die aktuelle Ansicht im Vordergrund), indem Sie die Methode findObject() aufrufen. - Sie können eine bestimmte Nutzerinteraktion für diese UI-Komponente simulieren, indem Sie eine
UiObject2
-Methode aufrufen. Rufen Sie z. B. scrollUntil() zum Scrollen und setText() auf, um ein Textfeld zu bearbeiten. Sie können die APIs in den Schritten 2 und 3 bei Bedarf wiederholt aufrufen, um komplexere Nutzerinteraktionen zu testen, die mehrere UI-Komponenten oder Abfolgen von Nutzeraktionen umfassen. - Prüfen Sie, ob die UI dem erwarteten Status oder Verhalten entspricht, nachdem diese Nutzerinteraktionen ausgeführt wurden.
Diese Schritte werden in den folgenden Abschnitten ausführlicher behandelt.
Auf UI-Komponenten zugreifen
Das UiDevice
-Objekt ist die primäre Methode, um auf den Gerätestatus zuzugreifen und ihn zu bearbeiten. In Ihren Tests können Sie UiDevice
-Methoden aufrufen, um den Status verschiedener Attribute wie die aktuelle Ausrichtung oder die Anzeigegröße zu prüfen.
Der Test kann das UiDevice
-Objekt verwenden, um Aktionen auf Geräteebene auszuführen. So kann das Gerät z. B. in eine bestimmte Drehung versetzt, die Hardwaretasten auf dem Steuerkreuz drückt und die Startbildschirm- und die Menütaste gedrückt werden.
Es empfiehlt sich, den Test vom Startbildschirm des Geräts aus zu starten. Sie können auf dem Startbildschirm (oder an einer anderen Startposition, die Sie auf dem Gerät ausgewählt haben) die von der UI Automator API bereitgestellten Methoden aufrufen, um bestimmte UI-Elemente auszuwählen und mit ihnen zu interagieren.
Das folgende Code-Snippet zeigt, wie Ihr Test eine Instanz von UiDevice
erhalten und das Drücken der Startbildschirmtaste simulieren könnte:
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); } }
Im Beispiel wird mit der Anweisung @SdkSuppress(minSdkVersion = 18) sichergestellt, dass Tests nur auf Geräten mit Android 4.3 (API-Level 18) oder höher ausgeführt werden, wie vom UI Automator-Framework gefordert.
Verwenden Sie die Methode findObject()
, um ein UiObject2
abzurufen, das eine Ansicht darstellt, die einem bestimmten Auswahlkriterium entspricht. Sie können die UiObject2
-Instanzen, die Sie in anderen Teilen Ihrer App-Tests erstellt haben, nach Bedarf wiederverwenden.
Das UI Automator-Test-Framework sucht in der aktuellen Anzeige jedes Mal nach einer Übereinstimmung, wenn Ihr Test eine UiObject2
-Instanz verwendet, um auf ein UI-Element zu klicken oder ein Attribut abzufragen.
Das folgende Snippet zeigt, wie mit dem Test UiObject2
-Instanzen erstellt werden können, die in einer App die Schaltflächen „Abbrechen“ und „OK“ darstellen.
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(); }
Selector angeben
Wenn Sie auf eine bestimmte UI-Komponente in einer App zugreifen möchten, verwenden Sie die Klasse By
, um eine BySelector
-Instanz zu erstellen. BySelector
steht für eine Abfrage für bestimmte Elemente in der angezeigten UI.
Wenn mehr als ein übereinstimmendes Element gefunden wird, wird das erste übereinstimmende Element in der Layouthierarchie als Ziel-UiObject2
zurückgegeben. Beim Erstellen einer BySelector
können Sie mehrere Attribute verketten, um Ihre Suche zu verfeinern. Wenn kein übereinstimmendes UI-Element gefunden wird, wird ein null
zurückgegeben.
Sie können die Methode hasChild()
oder hasDescendant()
verwenden, um mehrere BySelector
-Instanzen zu verschachteln. Das folgende Codebeispiel zeigt, wie für den Test eine Suche angegeben werden könnte, um das erste ListView
-Element zu finden, das ein untergeordnetes UI-Element mit dem Attribut „Text“ hat.
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") ) );
Es kann sinnvoll sein, den Objektstatus in Ihren Auswahlkriterien anzugeben. Wenn Sie beispielsweise eine Liste aller geprüften Elemente auswählen möchten, um die Häkchen zu entfernen, rufen Sie die Methode checked()
auf und setzen Sie das Argument auf „true“.
Aktionen durchführen
Sobald der Test ein UiObject2
-Objekt erhalten hat, können Sie die Methoden in der UiObject2
-Klasse aufrufen, um Nutzerinteraktionen mit der UI-Komponente auszuführen, die durch dieses Objekt dargestellt wird. Sie können folgende Aktionen festlegen:
click()
: Klickt auf die Mitte der sichtbaren Begrenzungen des UI-Elements.drag()
: Zieht dieses Objekt auf beliebige Koordinaten.setText()
: Legt den Text in einem bearbeitbaren Feld fest, nachdem der Inhalt des Felds gelöscht wurde. Umgekehrt löscht die Methodeclear()
den vorhandenen Text in einem bearbeitbaren Feld.swipe()
: Die Wischbewegung wird in die angegebene Richtung ausgeführt.scrollUntil()
: Das Scrollen wird in die angegebene Richtung ausgeführt, bisCondition
oderEventCondition
erfüllt ist.
Mit dem UI Automator-Test-Framework können Sie einen Intent senden oder eine Activity starten, ohne Shell-Befehle zu verwenden, indem Sie über getContext()
ein Context-Objekt abrufen.
Das folgende Snippet zeigt, wie der Test einen Intent verwenden kann, um die zu testende App zu starten. Dieser Ansatz ist nützlich, wenn Sie nur die Rechner-App testen möchten, der Launcher aber nicht so wichtig ist.
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); }
Ergebnisse überprüfen
Der InstrumentationTestCase erweitert TestCase. Sie können also mit den standardmäßigen Assert-Methoden von JUnit testen, ob UI-Komponenten in der App die erwarteten Ergebnisse zurückgeben.
Das folgende Snippet zeigt, wie Sie mit Ihrem Test mehrere Schaltflächen in einer Rechner-App finden, der Reihe nach auf sie klicken und dann prüfen können, ob das richtige Ergebnis angezeigt wird.
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()); }
UI Automator-Tests auf einem Gerät oder Emulator ausführen
Sie können UI Automator-Tests über Android Studio oder über die Befehlszeile ausführen. Geben Sie AndroidJUnitRunner
als Standard-Instrumentierungs-Runner in Ihrem Projekt an.
Weitere Beispiele
Mit der System-UI interagieren
UI Automator kann mit allen Inhalten auf dem Bildschirm interagieren, auch mit Systemelementen außerhalb Ihrer App, wie in den folgenden Code-Snippets gezeigt:
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());
Auf Umstellungen warten
![„Bitte nicht stören“ deaktivieren](https://developer.android.com/static/images/testing/uiautomator_turn_off_disturb.gif?authuser=6&hl=de)
Bildschirmübergänge können Zeit in Anspruch nehmen und voraussagen, dass ihre Dauer unzuverlässig ist. Daher sollten Sie UI Automator nach dem Ausführen von Vorgängen warten lassen. UI Automator bietet dafür mehrere Methoden:
UiDevice.performActionAndWait(Runnable action, EventCondition<U> condition, long timeout)
: Wenn Sie beispielsweise auf eine Schaltfläche klicken und warten möchten, bis ein neues Fenster angezeigt wird, rufen Siedevice.performActionAndWait(() -> button.click(), Until.newWindow(), timeout)
auf.UiDevice.wait(Condition<Object, U> condition, long timeout)
: Wenn Sie beispielsweise warten möchten, bis eine bestimmteUiObject2
auf dem Gerät erscheint, rufen Siedevice.wait(device.hasObject(By.text("my_text")), timeout);
auf.UiObject2.wait(@NonNull Condition<Object, U> condition, long timeout)
: Rufen Sie beispielsweisecheckbox.wait(Until.checked(true), timeout);
auf, wenn Sie warten möchten, bis ein Kästchen angeklickt wird.UiObject2.clickAndWait(@NonNull EventCondition<U> condition, long timeout)
: Wenn Sie beispielsweise auf eine Schaltfläche klicken und warten möchten, bis ein neues Fenster angezeigt wird, rufen Siebutton.clickAndWait(Until.newWindow(), timeout);
auf.UiObject2.scrollUntil(@NonNull Direction direction, @NonNull Condition<Object, U> condition)
: Wenn Sie beispielsweise nach unten scrollen möchten, bis ein neues Objekt angezeigt wird, rufen Sieobject.scrollUntil(Direction.DOWN, Until.hasObject(By.text('new_obj')));
auf.UiObject2.scrollUntil(@NonNull Direction direction, @NonNull EventCondition<U> condition)
: Wenn Sie beispielsweise nach unten scrollen möchten, rufen Sieobject.scrollUntil(Direction.DOWN, Until.scrollFinished(Direction.DOWN));
auf.
Das folgende Code-Snippet zeigt, wie Sie mit UI Automator den „Bitte nicht stören“-Modus in den Systemeinstellungen deaktivieren. Dazu verwenden Sie die Methode performActionAndWait()
, die auf Übergänge wartet:
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)); }
Weitere Informationen
Weitere Informationen zur Verwendung von UI Automator in Android-Tests finden Sie in den folgenden Ressourcen.
Referenzdokumentation:
Produktproben
- BasicSample: Basisbeispiel für UI Automator.