Usa la API heredada de UI Automator

UI Automator es un framework de prueba de la IU adecuado para pruebas funcionales de IU entre aplicaciones en todo el sistema y en apps instaladas. Las API de UI Automator te permiten interactuar con elementos visibles en un dispositivo, independientemente de qué Activity esté en foco, por lo que te permite realizar operaciones como abrir el menú Configuración o el selector de aplicaciones en un dispositivo de prueba. La prueba puede buscar un componente de la IU mediante descriptores adecuados, como el texto que se muestra en ese componente o su descripción de contenido.

El framework de prueba de UI Automator es una API basada en instrumentación y funciona con el AndroidJUnitRunner ejecutor de pruebas. Es adecuado para escribir pruebas automatizadas de estilo "caja negra", donde el código de prueba no se basa en detalles de implementación internos de la app de destino.

Estas son algunas de las funciones clave del framework de prueba de UI Automator:

• Una API para obtener información de estado y realizar operaciones en el dispositivo de destino. Para obtener más información, consulta Cómo acceder al estado del dispositivo.
• API compatibles con pruebas de IU entre apps. Para obtener más información, consulta UI Automator APIs.

Cómo acceder al estado del dispositivo

El framework de prueba de UI Automator proporciona una UiDevice clase para acceder al dispositivo en el cual se ejecuta una app de destino y realizar operaciones en él. Puedes llamar a sus métodos para acceder a las propiedades del dispositivo, como la orientación o el tamaño de visualización actuales. La clase UiDevice también te permite realizar las siguientes acciones:

1. Cambiar la rotación del dispositivo.
2. Presionar teclas de hardware, como "subir volumen".
3. Presionar los botones Atrás, Página principal o Menú.
4. Abrir el panel de notificaciones.
5. Tomar una captura de pantalla de la ventana actual.

Por ejemplo, para simular la acción de presionar del botón de inicio, llama al método UiDevice.pressHome().

API de UI Automator

Las API de UI Automator te permiten escribir pruebas eficaces sin necesidad de conocer detalles sobre la implementación de la app a la que apuntas. Puedes usar estas API para capturar y manipular los componentes de la IU en varias apps:

• UiObject2: representa un elemento de la IU que es visible en el dispositivo.
• BySelector: especifica criterios para hacer coincidir elementos de la IU.
• By: construye BySelector de manera concisa.
• Configurator: te permite establecer parámetros clave para ejecutar pruebas de UI Automator.

Por ejemplo, en el siguiente código, se muestra cómo escribir una secuencia de comandos de prueba que abre una app de Gmail en el 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);

Cómo configurar UI Automator

Antes de compilar la prueba de la IU con UI Automator, asegúrate de configurar la ubicación del código fuente de prueba y las dependencias del proyecto, según se describe en Cómo configurar el proyecto para AndroidX Test.

En el archivo build.gradle del módulo de la app para Android, debes establecer una referencia de dependencia a la biblioteca de UI Automator:

Para optimizar las pruebas de UI Automator, primero debes inspeccionar los componentes de UI de la app de destino y asegurarte de que se pueda acceder a ellos. Estas sugerencias de optimización se describen en las siguientes dos secciones.

Cómo inspeccionar la IU en un dispositivo

Antes de diseñar la prueba, inspecciona los componentes de la IU que están visibles en el dispositivo. Para asegurarte de que las pruebas de UI Automator puedan acceder a estos componentes, comprueba que los componentes tengan etiquetas de texto visibles, android:contentDescription valores o ambos.

La herramienta uiautomatorviewer proporciona una interfaz visual práctica para inspeccionar la jerarquía de diseño y ver las propiedades de los componentes de la IU que son visibles en primer plano en el dispositivo. Esta información te permite crear pruebas más específicas mediante UI Automator. Por ejemplo, puedes crear un selector de IU que coincida con una propiedad visible específica.

Para iniciar la herramienta uiautomatorviewer, haz lo siguiente:

1. Inicia la app de destino en un dispositivo físico.
2. Conecta el dispositivo a la máquina de desarrollo.
3. Abre una ventana de terminal y navega al directorio <android-sdk>/tools/.
4. Ejecuta la herramienta con este comando:

 $ uiautomatorviewer

Para ver las propiedades de la IU de tu aplicación, haz lo siguiente:

1. En la interfaz de uiautomatorviewer, haz clic en el botón Device Screenshot.
2. Desplázate sobre la instantánea, en el panel de la izquierda, para ver los componentes de la IU identificados por la herramienta uiautomatorviewer. Las propiedades se muestran en el panel inferior derecho y la jerarquía de diseño, en el panel superior derecho.
3. Opcionalmente, puedes hacer clic en el botón Toggle NAF Nodes para ver los componentes de la IU a los que no puede acceder UI Automator. Es posible que solo haya información limitada disponible para estos componentes.

Para obtener información sobre los tipos comunes de componentes de la IU proporcionados por Android, consulta Interfaz de usuario.

Asegúrate de que se pueda acceder a tu actividad

El framework de prueba de UI Automator brinda un mejor rendimiento en apps que tienen funciones de accesibilidad de Android implementadas. Cuando usas elementos de IU del tipo View o una subclase de View del SDK, no necesitas implementar la compatibilidad de accesibilidad , ya que esas clases lo hacen por ti.

Sin embargo, algunas apps usan elementos de IU personalizados para proporcionar una experiencia del usuario enriquecida. Estos elementos no proporcionarán compatibilidad de accesibilidad automática. Si tu app contiene instancias de una subclase de View que no es del SDK, sigue los pasos que se indican a continuación para asegurarte de agregar funciones de accesibilidad a estos elementos:

1. Crea una clase concreta que extienda ExploreByTouchHelper.
2. Asocia una instancia de tu nueva clase con un elemento de la IU personalizado específico llamando a setAccessibilityDelegate().

Para acceder a pautas adicionales sobre cómo agregar funciones de accesibilidad a los elementos de vista personalizada, consulta Cómo compilar vistas personalizadas accesibles. Para obtener más información sobre las prácticas recomendadas generales de accesibilidad en Android, consulta Cómo crear apps más accesibles.

Cómo crear una clase de prueba de UI Automator

Debes escribir la clase de prueba de UI Automator de la misma manera que una clase de prueba de JUnit 4. Para obtener más información sobre la creación de clases de prueba de JUnit 4 y el uso de aserciones y anotaciones de JUnit 4, consulta Cómo crear una clase de prueba de unidades instrumentada.

Agrega la anotación @RunWith(AndroidJUnit4.class) al comienzo de la definición de la clase de prueba. También debes especificar la clase AndroidJUnitRunner, proporcionada en AndroidX Test, como el panel de prueba predeterminado. Este paso se describe con más detalle en Cómo ejecutar pruebas de UI Automator en un dispositivo o emulador.

Implementa el siguiente modelo de programación en la clase de prueba de UI Automator:

1. Obtén un UiDevice objeto para acceder al dispositivo que deseas probar llamando al método getInstance() y pasándole un objeto Instrumentation como argumento.
2. Obtén un objeto UiObject2 para acceder a un componente de la IU que se muestra en el dispositivo (por ejemplo, la vista actual en primer plano) llamando al findObject() método.
3. Simula una interacción de usuario específica para ejecutar en ese componente de la IU mediante una llamada a un método UiObject2; por ejemplo, llama a scrollUntil() para desplazarte y a setText() para editar un campo de texto. Puedes llamar a las API de los pasos 2 y 3 repetidamente según sea necesario, con el fin de probar interacciones de usuario más complejas que involucren varios componentes de la IU o secuencias de acciones del usuario.
4. Tras la ejecución de las interacciones del usuario, comprueba si la IU refleja el estado o el comportamiento esperados.

Estos pasos se explican con más detalles en las siguientes secciones.

Cómo acceder a los componentes de la IU

El objeto UiDevice es la forma principal de acceder al estado del dispositivo y manipularlo. En las pruebas, puedes llamar a los métodos UiDevice para comprobar el estado de varias propiedades, como la orientación actual o el tamaño de visualización. La prueba puede usar el objeto UiDevice para ejecutar acciones a nivel del dispositivo, como forzar una rotación específica del dispositivo, presionar botones de hardware del pad direccional y presionar los botones de Inicio y Menú.

Se recomienda comenzar la prueba desde la pantalla principal del dispositivo. Desde esa pantalla (o alguna otra ubicación de inicio que hayas elegido en el dispositivo), puedes llamar a los métodos proporcionados por la API de UI Automator para seleccionar elementos específicos de la IU e interactuar con ellos.

El siguiente fragmento de código muestra la forma en que la prueba podría obtener una instancia de UiDevice y simular la acción de presionar el botón de inicio:

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

En el ejemplo, @SdkSuppress(minSdkVersion = 18) ayuda a garantizar que las pruebas solo se ejecutarán en dispositivos con Android 4.3 (nivel de API 18) o versiones posteriores, según lo requiera el framework de UI Automator.

Usa el método findObject() para recuperar un UiObject2 que represente una vista que coincida con un criterio de selección determinado. Puedes volver a usar las instancias de UiObject2 que creaste en otras partes de la prueba de la app, según sea necesario. Ten en cuenta que el framework de UI Automator busca una coincidencia en la pantalla actual cada vez que la prueba usa una instancia UiObject2 para hacer clic en un elemento de la IU o consultar una propiedad.

En el siguiente fragmento, se muestra la forma en que la prueba podría crear instancias de UiObject2 que representen un botón Cancelar y un botón Aceptar en una 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();
}

Cómo especificar un selector

Si deseas acceder a un componente de IU específico de una app, usa la By clase para construir una BySelector instancia. BySelector representa una consulta de elementos específicos de la IU que se muestra actualmente.

Si se encuentra más de un elemento coincidente, el primero de la jerarquía de diseño se mostrará como el UiObject2 de destino. Cuando creas un BySelector, puedes encadenar varias propiedades para definir mejor la búsqueda. Si no se encuentra ningún elemento de la IU que coincida, se muestra un null.

Puedes usar el método hasChild() o hasDescendant() para anidar varias instancias BySelector. Por ejemplo, en el siguiente ejemplo de código, se ilustra la especificación en la prueba de una búsqueda para hallar la primera ListView que tenga un elemento de IU secundario con la propiedad de texto.

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

Puede ser útil especificar el estado del objeto en los criterios del selector. Por ejemplo, si deseas seleccionar una lista de todos los elementos marcados para desmarcarlos, llama al checked() método con el argumento establecido en true.

Realiza acciones

Una vez que la prueba haya obtenido un objeto UiObject2, puedes llamar a los métodos de la clase UiObject2 para ejecutar interacciones del usuario en el componente de IU que representa ese objeto. Puedes especificar acciones como las siguientes:

• click() : hace clic en el centro de los límites visibles del elemento de la IU.
• drag() : arrastra el objeto a coordenadas arbitrarias.
• setText() : establece el texto en un campo editable después de borrar el contenido del campo. Por el contrario, el método clear() borra el texto existente en un campo editable.
• swipe() : ejecuta la acción de deslizar hacia la dirección especificada.
• scrollUntil(): ejecuta la acción de desplazamiento hacia la dirección especificada hasta que se cumpla Condition o EventCondition.

El framework de prueba de UI Automator te permite enviar un Intent o iniciar una Activity sin usar comandos de shell mediante la obtención de un objeto Context a través de getContext().

En el siguiente fragmento, se muestra cómo la prueba puede usar un Intent para iniciar la aplicación en modo de prueba. Este enfoque es útil si solo te interesa probar la app de la calculadora y no el selector.

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 los resultados

El InstrumentationTestCase extiende TestCase para que puedas usar métodos estándar de JUnit Assert y probar que los componentes de la IU en la app muestren los resultados esperados.

En el siguiente fragmento, se especifica el código que puede incluir la prueba para ubicar varios botones en una app de calculadora, hacer clic en ellos por orden y luego verificar que se muestra el resultado correcto.

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

Cómo ejecutar pruebas de UI Automator en un dispositivo o emulador

Puedes ejecutar pruebas de UI Automator desde Android Studio o desde la línea de comandos. Asegúrate de especificar AndroidJUnitRunner como el comparador de instrumentación predeterminado en el proyecto.

Más ejemplos

Cómo interactuar con la IU del sistema

UI Automator puede interactuar con todo lo que aparece en la pantalla, incluidos los elementos del sistema fuera de tu app, como se muestra en los siguientes fragmentos de código:

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

Espera las transiciones

Las transiciones de pantalla pueden llevar tiempo y predecir su duración no es confiable, por lo que debes hacer que UI Automator espere después de realizar operaciones. UI Automator proporciona varios métodos para esto:

• UiDevice.performActionAndWait(Runnable action, EventCondition<U> condition, long timeout): Por ejemplo, para hacer clic en un botón y esperar hasta que aparezca una ventana nueva, llama a device.performActionAndWait(() -> button.click(), Until.newWindow(), timeout)
• UiDevice.wait(Condition<Object, U> condition, long timeout): Por ejemplo, para esperar hasta que haya un UiObject2 determinado en el dispositivo, llama a device.wait(Until.hasObject(By.text("my_text")), timeout);
• UiObject2.wait(@NonNull Condition<Object, U> condition, long timeout): Por ejemplo, para esperar hasta que se marque una casilla de verificación, llama a checkbox.wait(Until.checked(true), timeout);
• UiObject2.clickAndWait(@NonNull EventCondition<U> condition, long timeout): Por ejemplo, para hacer clic en un botón y esperar hasta que aparezca una ventana nueva, llama a button.clickAndWait(Until.newWindow(), timeout);
• UiObject2.scrollUntil(@NonNull Direction direction, @NonNull Condition<Object, U> condition): Por ejemplo, para desplazarte hacia abajo hasta que aparezca un objeto nuevo, llama a object.scrollUntil(Direction.DOWN, Until.hasObject(By.text('new_obj')));
• UiObject2.scrollUntil(@NonNull Direction direction, @NonNull EventCondition<U> condition): Por ejemplo, para desplazarte hacia abajo hasta el final, llama a object.scrollUntil(Direction.DOWN, Until.scrollFinished(Direction.DOWN));

En el siguiente fragmento de código, se muestra cómo usar UI Automator para desactivar el modo No molestar en la configuración del sistema con el método performActionAndWait() que espera las transiciones:

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

Recursos adicionales

Para obtener más información sobre el uso de UI Automator en las pruebas de Android, consulta los siguientes recursos.

Documentación de referencia:

• Referencia de la API de UI Automator

Ejemplos

• BasicSample: ejemplo básico de UI Automator