Automatisierte Tests mit UI Automator schreiben

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:

1. Ändern Sie die Geräteausrichtung.
2. Drücken Sie Hardwaretasten, z. B. die Lautertaste.
3. Drücken Sie die Zurück-Taste, die Taste für den Startbildschirm 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 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: Konstruiert BySelector 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:

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

dependencies {
  ...
  androidTestImplementation('androidx.test.uiautomator:uiautomator:2.3.0-alpha03')
}

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:

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 gehen Sie zum Verzeichnis <android-sdk>/tools/.
4. Führen Sie das Tool mit diesem Befehl aus:

 $ uiautomatorviewer

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

1. Klicken Sie auf der Benutzeroberfläche von uiautomatorviewer auf die Schaltfläche Geräte-Screenshot.
2. 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.
3. 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:

1. Erstellen Sie eine konkrete Klasse, die ExploreByTouchHelper erweitert.
2. 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:

1. 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.
2. 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.
3. 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.
4. 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:

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

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

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 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 Methode clear() 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, bis Condition oder EventCondition 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.

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 ü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.

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

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

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

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

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

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

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

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 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 erscheint, rufen Sie device.wait(device.hasObject(By.text("my_text")), timeout); auf.
• UiObject2.wait(@NonNull Condition<Object, U> condition, long timeout): Rufen Sie beispielsweise checkbox.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 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, rufen Sie object.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 Sie object.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:

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

Weitere Informationen

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

Referenzdokumentation:

• UI Automator API-Referenz

Produktproben

• BasicSample: Basisbeispiel für UI Automator.