UI Automator è un framework di test dell'interfaccia utente adatto per i test funzionali dell'interfaccia utente tra app su app e sistemi installati. Le API UI Automator ti consentono di interagire con gli elementi visibili su un dispositivo, indipendentemente da quale Activity
è attivo, quindi puoi eseguire operazioni come l'apertura del menu Impostazioni o di Avvio applicazioni in un dispositivo di test. Il test può cercare un componente dell'interfaccia utente
utilizzando pratici descrittori come il testo visualizzato nel componente o la
descrizione dei suoi contenuti.
Il framework di test di UI Automator è un'API basata sulla strumentazione e funziona con l'esecutore del test di AndroidJUnitRunner
. È adatto alla scrittura di test automatici in stile riquadro opaco, in cui il codice di test non si basa sui dettagli di implementazione interni dell'app di destinazione.
Le funzionalità principali del framework di test di UI Automator includono quanto segue:
- Un'API per recuperare informazioni sullo stato ed eseguire operazioni sul dispositivo di destinazione. Per ulteriori informazioni, vedi Accesso allo stato dei dispositivi.
- API che supportano i test dell'interfaccia utente tra app. Per ulteriori informazioni, consulta la sezione API UI Automator.
Accesso allo stato del dispositivo
Il framework di test di UI Automator fornisce una classe UiDevice
per accedere ed eseguire operazioni sul dispositivo su cui è in esecuzione l'app di destinazione. Puoi chiamare i relativi metodi per accedere a proprietà del dispositivo come l'orientamento o le dimensioni di visualizzazione correnti. La classe UiDevice
consente inoltre di eseguire le seguenti
azioni:
- Cambiare la rotazione del dispositivo.
- Premi i tasti hardware, ad esempio "Alza il volume".
- Premi i pulsanti Indietro, Home o Menu.
- Apri l'area notifiche.
- Acquisisci uno screenshot della finestra corrente.
Ad esempio, per simulare la pressione del pulsante Home, chiama il
metodo UiDevice.pressHome()
.
API UI Automator
Le API UI Automator consentono di scrivere test affidabili senza dover conoscere i dettagli di implementazione dell'app scelta come target. Puoi utilizzare 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
: creaBySelector
in modo conciso.Configurator
: consente di impostare i parametri chiave per l'esecuzione dei test di automatizzazione dell'interfaccia utente.
Ad esempio, il codice seguente mostra come scrivere uno script di test che apra un'app Gmail nel dispositivo:
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);
Configura UI Automator
Prima di creare il test della UI con UI Automator, assicurati di configurare la posizione del codice sorgente di test e le dipendenze del progetto, come descritto in Configurare il progetto per il test AndroidX.
Nel file build.gradle
del modulo dell'app per Android, devi impostare un riferimento per le dipendenze alla libreria di automatizzazione dell'interfaccia utente:
Kotlin
dependencies {
...
androidTestImplementation('androidx.test.uiautomator:uiautomator:2.3.0-alpha03')
}
Trendy
dependencies {
...
androidTestImplementation 'androidx.test.uiautomator:uiautomator:2.3.0-alpha03'
}
Per ottimizzare i test di Automazione UI, devi prima esaminare i componenti UI dell'app target e assicurarti che siano accessibili. Questi suggerimenti per l'ottimizzazione sono descritti nelle due sezioni successive.
Ispezionare l'UI su un dispositivo
Prima di progettare il test, esamina i componenti dell'interfaccia utente visibili sul
dispositivo. Per assicurarti che i test di automatizzazione dell'interfaccia utente possano accedere a questi componenti, verifica che abbiano etichette di testo visibili, valori android:contentDescription
o entrambi.
Lo strumento uiautomatorviewer
offre una comoda interfaccia visiva per esaminare
la gerarchia del layout e visualizzare le proprietà dei componenti dell'interfaccia utente visibili
in primo piano del dispositivo. Queste informazioni ti consentono di creare test più granulari utilizzando UI Automator. Ad esempio, puoi creare un selettore UI
che corrisponde a una specifica proprietà visibile.
Per avviare lo strumento uiautomatorviewer
:
- Avvia l'app di destinazione su un dispositivo fisico.
- Collega il dispositivo alla macchina di sviluppo.
- Apri una finestra del terminale e vai alla directory
<android-sdk>/tools/
. - Esegui lo strumento con questo comando:
$ uiautomatorviewer
Per visualizzare le proprietà UI della tua applicazione:
- Nell'interfaccia
uiautomatorviewer
, fai clic sul pulsante Screenshot dispositivo. - Passa il mouse sopra l'istantanea nel riquadro di sinistra per visualizzare i componenti dell'interfaccia utente
identificati dallo strumento
uiautomatorviewer
. Le proprietà sono elencate nel riquadro in basso a destra e la gerarchia del layout nel riquadro in alto a destra. - Facoltativamente, fai clic sul pulsante Attiva/disattiva nodi NAF per visualizzare i componenti dell'interfaccia utente non accessibili ad Automazione UI. Per questi componenti potrebbero essere disponibili solo informazioni limitate.
Per conoscere i tipi comuni di componenti dell'interfaccia utente forniti da Android, consulta Interfaccia utente.
Assicurati che le tue attività siano accessibili
Il framework di test di UI Automator ha un rendimento migliore sulle app che hanno implementato le funzioni di accessibilità di Android. Quando utilizzi elementi UI di tipo View
o una sottoclasse View
dell'SDK, non è necessario implementare il supporto per l'accessibilità, in quanto queste classi lo hanno già fatto automaticamente.
Alcune app, tuttavia, utilizzano elementi UI personalizzati per fornire un'esperienza utente più completa.
Questi elementi non forniscono supporto automatico per l'accessibilità. Se la tua app contiene istanze di una sottoclasse di View
che non proviene dall'SDK, assicurati di aggiungere funzioni di accessibilità a questi elementi procedendo nel seguente modo:
- Crea una classe concreta che estenda EsploraByTouchHelper.
- Associa un'istanza della nuova classe a uno specifico elemento personalizzato dell'interfaccia utente chiamando setAccessibilityDelega().
Per ulteriori indicazioni sull'aggiunta di funzioni di accessibilità agli elementi delle viste personalizzate, consulta Creazione di viste personalizzate accessibili. Per scoprire di più sulle best practice generali per l'accessibilità su Android, consulta la sezione Rendere le app più accessibili.
Crea una classe di test di UI Automator
La classe di test di UI Automator deve essere scritta come una classe di test JUnit 4. Per saperne di più sulla creazione di classi di test JUnit 4 e sull'utilizzo di asserzioni e annotazioni JUnit 4, consulta Creare una classe di test delle unità strumentali.
Aggiungi l'annotazione @RunWith(AndroidJUnit4.class) all'inizio della definizione della classe di test. Devi inoltre specificare la classe AndroidJUnitRunner, fornita in AndroidX Test, come esecutore del test predefinito. Questo passaggio è descritto più dettagliatamente in Eseguire test di automatizzazione dell'interfaccia utente su un dispositivo o un emulatore.
Implementa il seguente modello di programmazione nella tua classe di test di UI Automator:
- Ottieni un oggetto
UiDevice
per accedere al dispositivo che vuoi testare chiamando il metodo getInstance() e passando un oggetto Strumentazione come argomento. - Ottieni un oggetto
UiObject2
per accedere a un componente dell'interfaccia utente visualizzato sul dispositivo (ad esempio, la vista corrente in primo piano), chiamando il metodo findObject(). - Simula un'interazione utente specifica da eseguire su quel componente dell'interfaccia utente richiamando un metodo
UiObject2
; ad esempio, chiama scrolluntil() per scorrere e setText() per modificare un campo di testo. Puoi richiamare le API nei passaggi 2 e 3 ripetute volte, se necessario, per testare interazioni più complesse degli utenti che coinvolgono più componenti dell'interfaccia utente o sequenze di azioni dell'utente. - Verifica che l'interfaccia utente rifletta lo stato o il comportamento previsto dopo l'esecuzione di queste interazioni utente.
Questi passaggi sono trattati in maggiore dettaglio nelle sezioni di seguito.
Componenti dell'interfaccia utente di accesso
L'oggetto UiDevice
è il metodo principale per accedere allo
stato del dispositivo e gestirlo. Nei tuoi test, puoi chiamare i metodi UiDevice
per verificare lo stato di varie proprietà, ad esempio 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 il dispositivo in una rotazione specifica, premere i pulsanti hardware del D-pad e premere i pulsanti Home e Menu.
È buona norma avviare il test dalla schermata Home del dispositivo. Dalla schermata Home (o da un'altra posizione di partenza che hai scelto nel dispositivo), puoi chiamare i metodi forniti dall'API UI Automator per selezionare e interagire con elementi dell'interfaccia utente specifici.
Il seguente snippet di codice mostra in che modo il test potrebbe ottenere un'istanza di UiDevice
e simulare la pressione del pulsante Home:
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); } }
Nell'esempio, l'istruzione @SdkSuppress(minSdkVersion = 18) aiuta a garantire che i test vengano eseguiti solo su dispositivi con Android 4.3 (livello API 18) o versioni successive, come richiesto dal framework di UI Automator.
Utilizza il metodo findObject()
per recuperare un UiObject2
che rappresenta una vista che corrisponde a un determinato criterio di selezione. Se necessario, puoi riutilizzare le istanze UiObject2
che hai creato in altre parti dei test dell'app.
Tieni presente che il framework di test di automatizzazione della UI cerca nella visualizzazione corrente
una corrispondenza ogni volta che il test utilizza un'istanza UiObject2
per fare clic su un elemento
dell'interfaccia utente o eseguire query su una proprietà.
Lo snippet seguente mostra come il test potrebbe creare istanze UiObject2
che rappresentano un pulsante Annulla e un pulsante OK in un'app.
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(); }
Specifica un selettore
Se vuoi accedere a un componente specifico dell'interfaccia utente in un'app, utilizza la classe 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, il primo elemento corrispondente nella gerarchia del layout viene restituito come UiObject2
di destinazione. Quando costruisci un elemento BySelector
, puoi concatenare più proprietà per perfezionare la ricerca. Se non viene trovato alcun elemento UI corrispondente, viene restituito un null
.
Puoi utilizzare il metodo hasChild()
o hasDescendant()
per nidificare
più istanze BySelector
. Ad esempio, il seguente esempio di codice mostra come il test potrebbe specificare una ricerca per trovare il primo ListView
che ha un elemento UI secondario con la proprietà text.
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") ) );
Può essere utile specificare lo stato dell'oggetto nei criteri di selezione. Ad esempio, se vuoi selezionare un elenco di tutti gli elementi selezionati in modo da poterli deselezionare, 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 nella
classe UiObject2
per eseguire interazioni utente sul componente UI
rappresentato da quell'oggetto. Puoi specificare azioni come:
click()
: fa clic sul centro dei limiti visibili dell'elemento UI.drag()
: trascina l'oggetto su coordinate arbitrarie.setText()
: imposta il testo in un campo modificabile, dopo aver cancellato i contenuti del campo. Al contrario, il metodoclear()
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 quandoCondition
oEventCondition
non soddisfa.
Il framework di test di UI Automator consente di inviare un intent o avviare un'attività senza utilizzare i comandi della shell, ottenendo un oggetto Context tramite getContext()
.
Lo snippet seguente mostra in che modo il test può utilizzare un intent per avviare l'app in fase di test. Questo approccio è utile solo quando vuoi testare l'app Calcolatrice e non ti interessa Avvio app.
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); }
Verifica i risultati
InstrumentationTestCase estende TestCase, quindi puoi utilizzare i metodi standard di JUnit Assert per verificare che i componenti della UI nell'app restituiscano i risultati previsti.
Lo snippet seguente mostra come il test può individuare diversi pulsanti in un'app di calcolo, fare clic su di essi in ordine, quindi verificare che venga visualizzato il risultato corretto.
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()); }
Esegui test UI Automator su un dispositivo o un emulatore
Puoi eseguire test UI Automator da Android Studio o dalla riga di comando. Assicurati di specificare AndroidJUnitRunner
come
runner di strumentazione predefinito nel tuo progetto.
Altri esempi
Interagire con l'interfaccia utente di sistema
UI Automator può interagire con tutto ciò che compare sullo schermo, inclusi gli elementi di sistema al di fuori dell'app, come mostrato nei seguenti snippet di codice:
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());
Attendi le transizioni
![Disattiva disturbo](https://developer.android.google.cn/static/images/testing/uiautomator_turn_off_disturb.gif?authuser=5&hl=it)
Le transizioni dello schermo possono richiedere tempo e prevedere la loro durata non è affidabile, quindi l'automazione dell'interfaccia utente dovrebbe attendere dopo aver eseguito le operazioni. UI Automator offre più metodi per questo:
UiDevice.performActionAndWait(Runnable action, EventCondition<U> condition, long timeout)
: ad esempio, per fare clic su un pulsante e attendere che venga visualizzata una nuova finestra, chiamadevice.performActionAndWait(() -> button.click(), Until.newWindow(), timeout)
UiDevice.wait(Condition<Object, U> condition, long timeout)
: ad esempio, per attendere la presenza di un determinatoUiObject2
sul dispositivo, chiamadevice.wait(device.hasObject(By.text("my_text")), timeout);
UiObject2.wait(@NonNull Condition<Object, U> condition, long timeout)
: ad esempio, per attendere che venga selezionata una casella di controllo, chiamacheckbox.wait(Until.checked(true), timeout);
UiObject2.clickAndWait(@NonNull EventCondition<U> condition, long timeout)
: ad esempio, per fare clic su un pulsante e attendere che venga visualizzata una nuova finestra, chiamabutton.clickAndWait(Until.newWindow(), timeout);
UiObject2.scrollUntil(@NonNull Direction direction, @NonNull Condition<Object, U> condition)
: ad esempio, per scorrere verso il basso fino alla visualizzazione di un nuovo oggetto, chiamaobject.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, chiamaobject.scrollUntil(Direction.DOWN, Until.scrollFinished(Direction.DOWN));
Il seguente snippet di codice mostra come utilizzare la funzionalità di automatizzazione dell'interfaccia utente per disattivare la modalità Non disturbare nelle impostazioni di sistema con il metodo performActionAndWait()
in attesa delle transizioni:
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)); }
Risorse aggiuntive
Per saperne di più sull'utilizzo di UI Automator nei test di Android, consulta le risorse seguenti.
Documentazione di riferimento:
Samples
- BasicSample: esempio di automazione dell'interfaccia utente di base.