Scrivere test automatici con Automator di UI

UI Automator è un framework di test della UI adatto a UI funzionali tra app di test nel sistema e nelle app installate. Le API UI Automator ti consentono di interagire con elementi visibili su un dispositivo, indipendentemente dal dispositivo Activity lo stato attivo, per consentirti di eseguire operazioni come l'apertura del menu Impostazioni o in Avvio applicazioni su un dispositivo di test. Il test può cercare un componente dell'interfaccia utente tramite usando comodi descrittori come il testo visualizzato all'interno del componente o descrizione dei contenuti.

Il framework di test di UI Automator è un'API basata su strumentazione e funziona con l'esecutore del test AndroidJUnitRunner. È adatto alla scrittura test automatici in stile riquadro opaco, in cui il codice di test non si basa su dettagli di implementazione dell'app di destinazione.

Le funzionalità principali del framework di test di UI Automator includono quanto segue:

• Un'API per recuperare le informazioni sullo stato ed eseguire operazioni sulla destinazione dispositivo. Per ulteriori informazioni, vedi Accesso allo stato del dispositivo.
• API che supportano i test dell'interfaccia utente tra app. Per ulteriori informazioni, vedi UI API Automator.

Accesso allo stato del dispositivo

Il framework di test di UI Automator fornisce una classe UiDevice a cui accedere ed eseguire operazioni sul dispositivo su cui è in esecuzione l'app di destinazione. Puoi chiamare i propri metodi per accedere alle proprietà del dispositivo come l'orientamento corrente dimensioni di visualizzazione. Il corso UiDevice ti consente inoltre di: azioni:

1. Cambia la rotazione del dispositivo.
2. Premi i tasti hardware, ad esempio "Alza il volume".
3. Premi i pulsanti Indietro, Home o Menu.
4. Apri l'area notifiche.
5. Acquisisci uno screenshot della finestra corrente.

Ad esempio, per simulare la pressione di un pulsante Home, richiama UiDevice.pressHome() .

API UI Automator

Le API UI Automator consentono di scrivere test affidabili senza dover conoscere sui dettagli di implementazione dell'app scelta come target. Puoi utilizzare la modalità queste API per acquisire e manipolare i componenti dell'interfaccia utente in più app:

• UiObject2: rappresenta un elemento UI visibile sul dispositivo.
• BySelector: specifica i criteri per gli elementi UI corrispondenti.
• By: crea BySelector in modo conciso.
• Configurator: consente di impostare i parametri chiave per l'esecuzione dei test di UI Automator.

Ad esempio, il seguente codice mostra come scrivere uno script di test che apre un'app Gmail nel dispositivo:

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

Configura UI Automator

Prima di creare il test della UI con UI Automator, assicurati di configurarlo della posizione del codice sorgente e delle dipendenze del progetto, come descritto in Configurare il progetto per AndroidX Test.

Nel file build.gradle del modulo dell'app Android, devi impostare una dipendenza riferimento alla libreria di UI Automator:

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

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

Per ottimizzare i test dello strumento di automazione dell'interfaccia utente, devi prima controllare la componenti UI e garantire che siano accessibili. Questi suggerimenti per l'ottimizzazione descritti nelle prossime due sezioni.

Ispezionare l'UI su un dispositivo

Prima di progettare il test, ispeziona i componenti dell'interfaccia utente visibili sul dispositivo. Per assicurarti che i test di Automator dell'UI possano accedere a questi componenti, controlla che questi componenti abbiano etichette di testo visibili android:contentDescription o entrambi.

Lo strumento uiautomatorviewer offre una comoda interfaccia visiva per ispezionare la gerarchia del layout e le proprietà dei componenti dell'interfaccia utente visibili in primo piano. Queste informazioni consentono di creare test granulari utilizzando l'Automator dell'interfaccia utente. Ad esempio, puoi creare un selettore di UI che corrisponde a una specifica proprietà visibile.

Per avviare lo strumento uiautomatorviewer:

1. Avvia l'app di destinazione su un dispositivo fisico.
2. Connetti il dispositivo al tuo computer di sviluppo.
3. Apri una finestra del terminale e vai alla directory <android-sdk>/tools/.
4. Esegui lo strumento con questo comando:

 $ uiautomatorviewer

Per visualizzare le proprietà dell'interfaccia utente per la tua applicazione:

1. Nell'interfaccia di uiautomatorviewer, fai clic sul pulsante Screenshot dispositivo.
2. Passa il mouse sopra l'istantanea nel riquadro a sinistra per visualizzare i componenti dell'interfaccia utente. identificati dallo strumento uiautomatorviewer. Le proprietà sono elencate nella inferiore riquadro a destra e la gerarchia del layout nel riquadro in alto a destra.
3. Facoltativamente, fai clic sul pulsante Attiva/disattiva nodi NAF per visualizzare i componenti dell'interfaccia utente. non accessibili da UI Automator. Solo alcune informazioni disponibili per questi componenti.

Per conoscere i tipi comuni di componenti dell'interfaccia utente forniti da Android, consulta Interfaccia.

Assicurati che la tua attività sia accessibile

Il framework di test di UI Automator ha prestazioni migliori sulle app che hanno implementato Funzioni di accessibilità Android. Quando utilizzi elementi UI di tipo View oppure una sottoclasse View dell'SDK, non devi implementare l'accessibilità di formazione, poiché questi corsi l'hanno già fatto per te.

Alcune app, tuttavia, utilizzano elementi UI personalizzati per offrire un'esperienza utente più ricca. Questi elementi non forniranno supporto automatico per l'accessibilità. Se la tua app contiene istanze di una sottoclasse di View che non provengono dall'SDK, assicurati di aggiungere funzioni di accessibilità a questi elementi completando il seguenti passaggi:

1. Crea un corso concreto che estenda EsploraByTouchHelper.
2. Associa un'istanza della nuova classe a un elemento UI personalizzato specifico chiamata a setAccessibilityDelegate().

Per ulteriori indicazioni sull'aggiunta delle funzioni di accessibilità alla visualizzazione personalizzata consulta la sezione Creazione di viste personalizzate accessibili. Per scoprire di più su best practice generali per l'accessibilità su Android, leggi l'articolo Rendere più disponibili le app Accessibilità.

Crea una classe di test UI Automator

La classe di test dell'Automator UI deve essere scritta allo stesso modo di un test JUnit 4 . Per ulteriori informazioni sulla creazione di classi di test JUnit 4 e sull'utilizzo della JUnit 4 asserzioni e annotazioni, consulta l'articolo Creare una classe di test dell'unità strumentale.

Aggiungi l'annotazione @RunWith(AndroidJUnit4.class) all'inizio del test definizione della classe. Devi anche specificare la classe AndroidJUnitRunner, fornito in AndroidX Test, come runner predefinito per il test. Questo passaggio viene descritto in modo più dettagliato in Eseguire i test di UI Automator su un dispositivo o un emulatore.

Implementa il seguente modello di programmazione nella classe di test di UI Automator:

1. Richiedi un oggetto UiDevice per accedere al dispositivo che vuoi testare chiamando il metodo getInstance() e passargli un oggetto Instrumentation come l'argomento.
2. Ottenere un oggetto UiObject2 per accedere a un componente UI che viene visualizzato nella dispositivo (ad esempio, la visualizzazione corrente in primo piano), richiamando il metodo Metodo findObject().
3. Per simulare un'interazione utente specifica da eseguire su quel componente dell'interfaccia utente, chiamata a un metodo UiObject2; ad esempio, richiama scrollUntil() per scorrere e setText() per modificare un campo di testo. Puoi chiamare le API nei passaggi 2 e 3 ripetutamente se necessario per testare interazioni più complesse degli utenti che comportano più componenti UI o sequenze di azioni utente.
4. Controlla che la UI rifletta lo stato o il comportamento previsto, dopo che questi utenti e interazioni.

Questi passaggi sono descritti in modo più dettagliato nelle sezioni di seguito.

Accesso ai componenti dell'interfaccia utente

L'oggetto UiDevice è il modo principale per accedere e manipolare l'oggetto stato del dispositivo. Nei test, puoi chiamare i metodi UiDevice per verificare lo stato di varie proprietà, come l'orientamento o le dimensioni di visualizzazione correnti. Il test può utilizzare l'oggetto UiDevice per eseguire azioni a livello di dispositivo, ad esempio forzare una rotazione specifica del dispositivo, premere l'hardware del D-pad e premendo i pulsanti Home e Menu.

È buona norma avviare il test dalla schermata Home del dispositivo. Da la schermata Home (o un'altra posizione iniziale scelta nel dispositivo), puoi chiamare i metodi forniti dall'API UI Automator per selezionare e interagire con specifici elementi UI.

Il seguente snippet di codice mostra in che modo il test potrebbe ottenere un'istanza di UiDevice e simula la pressione di un pulsante Home:

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

Nell'esempio, l'istruzione @SdkSuppress(minSdkVersion = 18) aiuta a garantire i test verranno eseguiti solo su dispositivi con Android 4.3 (livello API 18) o versioni successive, come richiesto dal framework di automazione dell'interfaccia utente.

Usa il metodo findObject() per recuperare un UiObject2 che rappresenta una vista che corrisponde a un determinato criterio del selettore. Puoi riutilizzare UiObject2 create in altre parti dei test dell'app, se necessario. Tieni presente che il framework di test dell'Automator dell'interfaccia utente cerca nella visualizzazione corrente ogni volta che il test utilizza un'istanza UiObject2 per fare clic su una UI o eseguire una query su una proprietà.

Il seguente snippet mostra in che modo il tuo test potrebbe generare UiObject2 le istanze che rappresentano un pulsante Annulla e un pulsante OK in un'app.

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

Specifica un selettore

Se desideri accedere a uno specifico componente dell'interfaccia utente in un'app, utilizza la By per creare un'istanza BySelector. BySelector rappresenta una query per elementi specifici nell'interfaccia utente visualizzata.

Se viene trovato più di un elemento corrispondente, viene usato il primo elemento corrispondente nella la gerarchia del layout viene restituita come UiObject2 di destinazione. Quando crei un BySelector, puoi collegare più proprietà per perfezionare il eseguire una ricerca. Se non viene trovato alcun elemento UI corrispondente, viene restituito null.

Per nidificare puoi usare il metodo hasChild() o hasDescendant() più istanze di BySelector. Il seguente esempio di codice mostra in che modo il test potrebbe specificare una ricerca per trovare il primo ListView che ha un elemento UI secondario con la proprietà di testo.

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

Può essere utile specificare lo stato dell'oggetto nei criteri del selettore. Per Ad esempio, se vuoi selezionare un elenco di tutti gli elementi selezionati in modo da poter deselezionali, chiama il metodo checked() con l'argomento impostato su true.

Esegui azioni

Una volta che il test ha ottenuto un oggetto UiObject2, puoi chiamare i metodi in classe UiObject2 per eseguire interazioni degli utenti sul componente dell'interfaccia utente rappresentato da quell'oggetto. Puoi specificare azioni quali:

• click() : fa clic al centro dei limiti visibili dell'elemento UI.
• drag() : trascina l'oggetto in coordinate arbitrarie.
• setText() : imposta il testo in un campo modificabile, dopo aver cancellato il pulsante i contenuti del campo. Al contrario, il metodo clear() cancella il testo esistente in un campo modificabile.
• swipe() : esegue l'azione di scorrimento verso la direzione specificata.
• scrollUntil(): esegue l'azione di scorrimento verso la direzione specificata fino a quando Condition o EventCondition non è soddisfatto.

Il framework di test di UI Automator ti consente di inviare un intent o un'attività senza utilizzare i comandi shell, ottenendo un valore Context tramite getContext().

Lo snippet seguente mostra come il test può utilizzare un intent per avviare lo app in fase di test. Questo approccio è utile quando ti interessa eseguire test l'app Calcolatrice e non è interessato ad Avvio app.

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

Verifica i risultati

InstrumentationTestCase estende TestCase, quindi puoi utilizzare metodi JUnit Assert standard per testare i componenti dell'interfaccia utente nell'app i risultati attesi.

Lo snippet seguente mostra in che modo il tuo test è in grado di individuare diversi pulsanti in un Calcolatrice, fai clic sulle app nell'ordine corretto e verifica che il risultato corretto sia visualizzati.

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

Esegui test di UI Automator su un dispositivo o un emulatore

Puoi eseguire test di UI Automator da Android Studio o dal dalla riga di comando. Assicurati di specificare AndroidJUnitRunner come valore predefinito di strumentazione nel tuo progetto.

Altri esempi

Interagire con l'UI di sistema

UI Automator può interagire con tutto ciò che compare sullo schermo, incluso il sistema esterni all'app, come mostrato negli snippet di codice che seguono:

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

Attendi le transizioni

Le transizioni sullo schermo possono richiedere tempo e prevederne la durata non è affidabile, quindi dopo l'esecuzione delle operazioni dovresti attendere il completamento delle operazioni. Automatizzatore UI offre diversi metodi per farlo:

• UiDevice.performActionAndWait(Runnable action, EventCondition<U> condition, long timeout): ad esempio, per fare clic su un pulsante e attendere la visualizzazione di una nuova finestra, chiama device.performActionAndWait(() -> button.click(), Until.newWindow(), timeout)
• UiDevice.wait(Condition<Object, U> condition, long timeout): ad esempio, per attendere che venga visualizzato un determinato UiObject2 sul dispositivo, chiama device.wait(device.hasObject(By.text("my_text")), timeout);
• UiObject2.wait(@NonNull Condition<Object, U> condition, long timeout): ad esempio, per attendere la selezione di una casella di controllo, chiama checkbox.wait(Until.checked(true), timeout);
• UiObject2.clickAndWait(@NonNull EventCondition<U> condition, long timeout): ad esempio, per fare clic su un pulsante e attendere la visualizzazione di una nuova finestra, chiama button.clickAndWait(Until.newWindow(), timeout);
• UiObject2.scrollUntil(@NonNull Direction direction, @NonNull Condition<Object, U> condition): ad esempio, per scorrere verso il basso finché non viene visualizzato un nuovo oggetto, richiama object.scrollUntil(Direction.DOWN, Until.hasObject(By.text('new_obj')));
• UiObject2.scrollUntil(@NonNull Direction direction, @NonNull EventCondition<U> condition): ad esempio, per scorrere fino in fondo, chiama object.scrollUntil(Direction.DOWN, Until.scrollFinished(Direction.DOWN));

Il seguente snippet di codice mostra come utilizzare UI Automator per disattivare Non consentire La modalità Disturbo nelle Impostazioni di sistema usando il metodo performActionAndWait() che attende le transizioni:

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

Risorse aggiuntive

Per ulteriori informazioni sull'utilizzo di UI Automator nei test di Android, consulta le seguenti risorse.

Documentazione di riferimento:

• Riferimento API UI Automator

Campioni

• BasicSample: esempio di base di UI Automator.