Automatisierte Tests mit UI Automator schreiben

UI Automator ist ein UI-Test-Framework, das sich für funktionale UI-Tests für mehrere Apps im gesamten System und in installierten Apps eignet. Mit den UI Automator APIs können Sie mit sichtbaren Elementen auf einem Gerät interagieren, unabhängig davon, welches Activity sich im Fokus befindet. So können Sie beispielsweise das Menü „Einstellungen“ oder den App Launcher auf einem Testgerät öffnen. In Ihrem Test können Sie eine UI-Komponente anhand von praktischen Beschreibungen wie dem in der Komponente angezeigten Text oder der Inhaltsbeschreibung suchen.

Hinweis: Für dieses Framework ist Android 4.3 (API-Level 18) oder höher erforderlich.

Das UI Automator-Testframework ist eine instrumentierungsbasierte API und funktioniert mit dem AndroidJUnitRunner-Test-Runner. Es eignet sich gut zum Schreiben von nicht transparenten automatisierten Box-Tests, bei denen der Testcode nicht auf internen Implementierungsdetails der Ziel-App basiert.

Zu den wichtigsten Funktionen des UI Automator-Test-Frameworks gehören:

• Eine API zum Abrufen von Statusinformationen und Ausführen von Vorgängen auf dem Zielgerät. Weitere Informationen finden Sie unter Auf den Gerätestatus zugreifen.
• APIs, die App-übergreifende UI-Tests unterstützen. Weitere Informationen finden Sie unter UI Automator APIs.

Hinweis: UI Automator und Espresso überschneiden sich in einigen Funktionen. Espresso bietet jedoch mehr Synchronisierungsmechanismen und wird daher für gängige UI-Tests bevorzugt.

Zugriff auf den Gerätestatus

Das UI Automator-Testframework bietet eine UiDevice-Klasse, um auf das Gerät zuzugreifen und Vorgänge darauf auszuführen, auf dem die Ziel-App ausgeführt wird. Sie können die Methoden aufrufen, um auf Geräteeigenschaften wie die aktuelle Ausrichtung oder die Displaygröße zuzugreifen. Mit der Klasse UiDevice können Sie außerdem Folgendes tun:

1. Ändern Sie die Gerätedrehung.
2. Hardwaretasten drücken, z. B. „Lautstärke erhöhen“
3. Drücken Sie die Schaltfläche „Zurück“, die Startbildschirmtaste oder die Menütaste.
4. Öffnen Sie die Benachrichtigungsleiste.
5. 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 robuste Tests schreiben, ohne die Implementierungsdetails der App zu kennen, auf die Sie abzielen. 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 die Übereinstimmung von UI-Elementen an.
• By: Ermöglicht die kompakte Erstellung von BySelector.
• Configurator: Hier können Sie wichtige Parameter für das Ausführen von UI Automator-Tests festlegen.

Hinweis :Einige vorhandene APIs, darunter UiCollection, UiObject, UiScrollable und UiSelector, werden in einem zukünftigen Release eingestellt. Wenn Sie weiterhin Support erhalten möchten, sollten Sie stattdessen nur die in diesem Dokument genannten APIs verwenden.

Im folgenden Code wird beispielsweise gezeigt, wie Sie ein Testskript schreiben, mit dem die Gmail App auf dem Gerät geöffnet wird:

KotlinJava Mehr

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

UI Automator einrichten

Bevor Sie Ihren UI-Test mit UI Automator erstellen, müssen Sie den Speicherort des Test-Quellcodes und die Projektabhängigkeiten konfigurieren, wie unter Projekt für AndroidX-Test einrichten beschrieben.

In der build.gradle-Datei Ihres Android-App-Moduls müssen Sie einen Abhängigkeitsverweis auf die UI Automator-Bibliothek festlegen:

KotlinGroovy Mehr

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

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

Hinweis: Die neuesten Updates finden Sie in den Versionshinweisen.

Um Ihre UI Automator-Tests zu optimieren, sollten Sie zuerst die UI-Komponenten der Ziel-App prüfen und dafür sorgen, dass sie barrierefrei sind. Diese Optimierungstipps werden in den nächsten beiden Abschnitten beschrieben.

Benutzeroberfläche auf einem Gerät 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, prüfen Sie, ob diese Komponenten sichtbare Textlabels, android:contentDescription-Werte oder beides haben.

Das uiautomatorviewer-Tool bietet eine praktische visuelle Oberfläche, mit der Sie die Layouthierarchie prüfen und die Eigenschaften der UI-Komponenten ansehen können, die im Vordergrund des Geräts sichtbar sind. Anhand dieser Informationen können Sie mit UI Automator detailliertere Tests erstellen. Sie können beispielsweise einen UI-Auswähler erstellen, der mit einer bestimmten sichtbaren Property übereinstimmt.

So starten Sie das uiautomatorviewer-Tool:

1. Starten Sie die Ziel-App auf einem physischen Gerät.
2. Verbinden Sie das Gerät mit Ihrem Entwicklungscomputer.
3. Öffnen Sie ein Terminalfenster und wechseln Sie zum Verzeichnis <android-sdk>/tools/.
4. Führen Sie das Tool mit diesem Befehl aus:

 $ uiautomatorviewer

So rufen Sie die UI-Eigenschaften für Ihre Anwendung auf:

1. Klicken Sie in der Benutzeroberfläche uiautomatorviewer auf die Schaltfläche Geräte-Screenshot.
2. Bewegen Sie den Mauszeiger im linken Bereich auf den Screenshot, um die vom Tool uiautomatorviewer erkannten UI-Komponenten zu sehen. Die Properties werden im unteren rechten Bereich und die Layouthierarchie im oberen rechten Bereich aufgeführt.
3. Optional können Sie auf die Schaltfläche NAF-Knoten ein-/ausblenden klicken, um UI-Komponenten zu sehen, auf die der UI-Automator nicht zugreifen kann. Für diese Komponenten sind möglicherweise nur begrenzte Informationen verfügbar.

Informationen zu den gängigen Arten von UI-Komponenten, die von Android bereitgestellt werden, finden Sie unter Benutzeroberfläche.

Sorgen Sie dafür, dass Ihre Aktivitäten barrierefrei sind

Das UI Automator-Testframework funktioniert bei Apps mit implementierten Android-Bedienungshilfen besser. Wenn Sie UI-Elemente vom Typ View oder eine abgeleitete Klasse von View aus dem SDK verwenden, müssen Sie keinen Support für Barrierefreiheit implementieren, da dies bereits für Sie erledigt wurde.

Einige Apps verwenden jedoch benutzerdefinierte UI-Elemente, um die Nutzerfreundlichkeit zu verbessern. Für solche Elemente wird keine automatische Barrierefreiheit unterstützt. Wenn Ihre App Instanzen einer Unterklasse von View enthält, die nicht aus dem SDK stammen, müssen Sie diesen Elementen Funktionen zur Barrierefreiheit hinzufügen. Gehen Sie dazu so vor:

1. Erstellen Sie eine konkrete Klasse, die ExploreByTouchHelper erweitert.
2. Weisen Sie eine Instanz Ihrer neuen Klasse einem bestimmten benutzerdefinierten UI-Element zu, indem Sie setAccessibilityDelegate() aufrufen.

Weitere Informationen zum Hinzufügen von Bedienungshilfen zu Elementen benutzerdefinierter Ansichten finden Sie unter Barrierefreie benutzerdefinierte Ansichten erstellen. Weitere allgemeine Best Practices für die Barrierefreiheit unter Android finden Sie unter Apps barrierefreier 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-Behauptungen und Anmerkungen finden Sie unter Eine instrumentierte Unit-Testklasse erstellen.

Fügen Sie die Annotation @RunWith(AndroidJUnit4.class) zu Beginn der Testklassendefinition hinzu. Außerdem müssen Sie die Klasse AndroidJUnitRunner aus AndroidX Test 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:

1. Rufen Sie die Methode getInstance() auf und übergeben Sie ihr als Argument ein Instrumentation-Objekt, um ein UiDevice-Objekt für den Zugriff auf das Gerät abzurufen, das Sie testen möchten.
2. Rufen Sie die Methode findObject() auf, um ein UiObject2-Objekt abzurufen, um auf eine UI-Komponente zuzugreifen, die auf dem Gerät angezeigt wird (z. B. die aktuelle Ansicht im Vordergrund).
3. Simulieren Sie eine bestimmte Nutzerinteraktion, die auf dieser UI-Komponente ausgeführt werden soll, indem Sie eine UiObject2-Methode aufrufen. Rufen Sie beispielsweise scrollUntil() auf, um zu scrollen, und setText(), um ein Textfeld zu bearbeiten. Sie können die APIs in Schritt 2 und 3 bei Bedarf wiederholt aufrufen, um komplexere Nutzerinteraktionen zu testen, die mehrere UI-Komponenten oder Abfolgen von Nutzeraktionen umfassen.
4. Prüfen Sie, ob die Benutzeroberfläche nach diesen Nutzerinteraktionen den erwarteten Status oder das erwartete Verhalten widerspiegelt.

Diese Schritte werden in den folgenden Abschnitten ausführlicher beschrieben.

Auf UI-Komponenten zugreifen

Über das UiDevice-Objekt greifen Sie hauptsächlich auf den Status des Geräts zu und ändern ihn. In Ihren Tests können Sie UiDevice-Methoden aufrufen, um den Status verschiedener Eigenschaften wie der aktuellen Ausrichtung oder Displaygröße zu prüfen. Mit dem Objekt UiDevice können Sie in Ihrem Test Aktionen auf Geräteebene ausführen, z. B. das Gerät zu einer bestimmten Drehung zwingen, die Hardwaretasten des D-Pads drücken und die Start- und Menütaste drücken.

Es empfiehlt sich, den Test auf dem Startbildschirm des Geräts zu starten. Auf dem Startbildschirm (oder einem anderen Startpunkt, den Sie auf dem Gerät ausgewählt haben) können Sie die Methoden der UI Automator API aufrufen, um bestimmte UI-Elemente auszuwählen und mit ihnen zu interagieren.

Im folgenden Codeausschnitt wird gezeigt, wie Ihr Test eine Instanz von UiDevice abrufen und die Betätigung der Startbildschirmtaste simulieren könnte:

KotlinJava Mehr

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

Im Beispiel sorgt die Anweisung @SdkSuppress(minSdkVersion = 18) dafür, dass Tests nur auf Geräten mit Android 4.3 (API-Ebene 18) oder höher ausgeführt werden, wie vom UI Automator-Framework gefordert.

Verwenden Sie die Methode findObject(), um eine UiObject2 abzurufen, die eine Ansicht darstellt, die den angegebenen Auswahlkriterien entspricht. Sie können die von Ihnen erstellten UiObject2-Instanzen bei Bedarf in anderen Teilen Ihrer App-Tests wiederverwenden. Das UI Automator-Test-Framework sucht jedes Mal nach einer Übereinstimmung im aktuellen Display, wenn in Ihrem Test eine UiObject2-Instanz verwendet wird, um auf ein UI-Element zu klicken oder eine Property abzufragen.

Das folgende Snippet zeigt, wie in Ihrem Test UiObject2-Instanzen erstellt werden können, die eine Schaltfläche „Abbrechen“ und eine Schaltfläche „OK“ in einer App darstellen.

KotlinJava Mehr

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

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 nach bestimmten Elementen in der angezeigten Benutzeroberfläche.

Wenn mehrere übereinstimmende Elemente gefunden werden, wird das erste übereinstimmende Element in der Layouthierarchie als ZielUiObject2 zurückgegeben. Beim Erstellen einer BySelector können Sie mehrere Properties verketten, um die Suche einzugrenzen. Wenn kein übereinstimmendes UI-Element gefunden wird, wird null zurückgegeben.

Mit der Methode hasChild() oder hasDescendant() können Sie mehrere BySelector-Instanzen verschachteln. Im folgenden Codebeispiel wird beispielsweise gezeigt, wie Sie in Ihrem Test eine Suche angeben können, um das erste ListView zu finden, das ein untergeordnetes UI-Element mit der Texteigenschaft hat.

KotlinJava Mehr

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")
        )
);

Es kann nützlich sein, den Objektstatus in den Auswahlkriterien anzugeben. Wenn Sie beispielsweise eine Liste aller angeklickten Elemente auswählen möchten, um die Auswahl aufzuheben, rufen Sie die Methode checked() mit dem Argument „wahr“ auf.

Aktionen durchführen

Sobald Ihr 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 beispielsweise folgende Aktionen angeben:

• click() : Klickt auf die Mitte des sichtbaren Bereichs des UI-Elements.
• drag() : Mit dieser Option können Sie dieses Objekt an beliebige Koordinaten ziehen.
• setText() : Legt den Text in einem bearbeitbaren Feld fest, nachdem der Inhalt des Felds gelöscht wurde. Mit der Methode clear() wird dagegen der vorhandene Text in einem bearbeitbaren Feld gelöscht.
• swipe() : Führt das Wischen in die angegebene Richtung aus.
• scrollUntil(): Führt die Scrollaktion in der angegebenen Richtung aus, bis Condition oder EventCondition erfüllt ist.

Mit dem UI Automator-Test-Framework können Sie einen Intent senden oder eine Aktivität starten, ohne Shell-Befehle zu verwenden. Dazu rufen Sie ein Context-Objekt über getContext() ab.

Im folgenden Snippet wird gezeigt, wie in Ihrem Test ein Intent verwendet werden kann, um die zu testende App zu starten. Dieser Ansatz ist nützlich, wenn Sie nur die Taschenrechner-App testen möchten und sich nicht für den Launcher interessieren.

KotlinJava Mehr

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

Ergebnisse prüfen

Die InstrumentationTestCase erweitert die TestCase. Sie können also die standardmäßigen JUnit-Assert-Methoden verwenden, um zu testen, ob die UI-Komponenten in der App die erwarteten Ergebnisse zurückgeben.

Im folgenden Snippet wird gezeigt, wie Ihr Test mehrere Schaltflächen in einer Taschenrechner-App finden, nacheinander darauf klicken und dann prüfen kann, ob das richtige Ergebnis angezeigt wird.

KotlinJava Mehr

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

UI Automator-Tests auf einem Gerät oder Emulator ausführen

Sie können UI Automator-Tests in 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 Elementen auf dem Bildschirm interagieren, einschließlich Systemelementen außerhalb Ihrer App, wie in den folgenden Code-Snippets gezeigt:

KotlinJava Mehr

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

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

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

KotlinJava Mehr

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

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

Auf Übergänge warten

Abbildung 1 UI Automator deaktiviert den Modus „Bitte nicht stören“ auf einem Testgerät.

Bildschirmübergänge können einige Zeit in Anspruch nehmen und die Dauer lässt sich nicht zuverlässig vorhersagen. Daher sollten Sie UI Automator nach der Ausführung 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 Sie device.performActionAndWait(() -> button.click(), Until.newWindow(), timeout) auf.
• UiDevice.wait(Condition<Object, U> condition, long timeout): Wenn Sie beispielsweise warten möchten, bis eine bestimmte UiObject2 auf dem Gerät vorhanden ist, rufen Sie device.wait(Until.hasObject(By.text("my_text")), timeout); auf.
• UiObject2.wait(@NonNull Condition<Object, U> condition, long timeout): Wenn Sie beispielsweise warten möchten, bis ein Kästchen angeklickt wird, rufen Sie checkbox.wait(Until.checked(true), timeout); auf.
• 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 Sie button.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, geben Sie object.scrollUntil(Direction.DOWN, Until.hasObject(By.text('new_obj'))); ein.
• UiObject2.scrollUntil(@NonNull Direction direction, @NonNull EventCondition<U> condition): Wenn Sie beispielsweise ganz nach unten scrollen möchten, geben Sie object.scrollUntil(Direction.DOWN, Until.scrollFinished(Direction.DOWN)); ein.

Im folgenden Code-Snippet wird gezeigt, wie Sie mit UI Automator den Modus „Bitte nicht stören“ in den Systemeinstellungen mit der Methode performActionAndWait() deaktivieren, die auf Übergänge wartet:

KotlinJava Mehr

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

Zusätzliche Ressourcen

Weitere Informationen zur Verwendung von UI Automator in Android-Tests finden Sie in den folgenden Ressourcen.

Referenzdokumentation:

• UI Automator API-Referenz

Produktproben

• BasicSample: Einfaches UI Automator-Beispiel.