tutorial - Obtener actividad actual en espresso android

test ui android

Question

En el caso de una prueba que cruza múltiples actividades, ¿hay alguna manera de obtener actividad actual?

El método getActivtiy () simplemente da una actividad que se usó para comenzar la prueba.

Intenté algo como abajo,

public Activity getCurrentActivity() {
    Activity activity = null;
    ActivityManager am = (ActivityManager) this.getActivity().getSystemService(Context.ACTIVITY_SERVICE);
    List<ActivityManager.RunningTaskInfo> taskInfo = am.getRunningTasks(1);
    try {
        Class<?> myClass = taskInfo.get(0).topActivity.getClass();
        activity = (Activity) myClass.newInstance();
    }
    catch (Exception e) {

    }
    return activity;
}

pero obtengo un objeto nulo

Answer 1

En Espresso, puede usar ActivityLifecycleMonitorRegistry pero no es oficialmente compatible, por lo que puede no funcionar en versiones futuras.

Así es como funciona:

Activity getCurrentActivity() throws Throwable {
  getInstrumentation().waitForIdleSync();
  final Activity[] activity = new Activity[1];
  runTestOnUiThread(new Runnable() {
    @Override
    public void run() {
      java.util.Collection<Activity> activities = ActivityLifecycleMonitorRegistry.getInstance().getActivitiesInStage(Stage.RESUMED);
      activity[0] = Iterables.getOnlyElement(activities);
  }});
  return activity[0];
}

Answer 2

La respuesta aceptada puede no funcionar en muchas pruebas de espresso. Lo siguiente funciona con espresso versión 2.2.2 y Android compile / target SDK 27 ejecutándose en dispositivos API 25:

@Nullable
private Activity getActivity() {
    Activity currentActivity = null;

    Collection resumedActivities = ActivityLifecycleMonitorRegistry.getInstance().getActivitiesInStage(RESUMED);
    if (resumedActivities.iterator().hasNext()){
        currentActivity = (Activity) resumedActivities.iterator().next();
    }
    return currentActivity;
}

Answer 3

La solución propuesta por @lacton no funcionó para mí, probablemente porque la actividad no estaba en un estado que fue reportado por ActivityLifecycleMonitorRegistry .

Incluso intenté Stage.PRE_ON_CREATE todavía no Stage.PRE_ON_CREATE ninguna actividad.

Nota : no pude usar ActivityTestRule o IntentTestRule porque estaba iniciando mi actividad usando activitiy-alias y no tenía ningún sentido usar la clase real en las pruebas cuando quiero hacer una prueba para ver si el alias funciona.

Mi solución para esto fue suscribirme a los cambios del ciclo de vida a través de ActivityLifecycleMonitorRegistry y bloquear el hilo de prueba hasta que se inicie la actividad:

// NOTE: make sure this is a strong reference (move up as a class field) otherwise will be GCed and you will not stably receive updates.
ActivityLifecycleCallback lifeCycleCallback = new ActivityLifecycleCallback() {
            @Override
            public void onActivityLifecycleChanged(Activity activity, Stage stage) {
                classHolder.setValue(((MyActivity) activity).getClass());

                // release the test thread
                lock.countDown();
            }
         };

// used to block the test thread until activity is launched
final CountDownLatch lock = new CountDownLatch(1);
final Holder<Class<? extends MyActivity>> classHolder = new Holder<>();
instrumentation.runOnMainSync(new Runnable() {
   @Override
    public void run() {
        ActivityLifecycleMonitorRegistry.getInstance().addLifecycleCallback(lifeCycleCallback);
     }
});

// start the Activity
intent.setClassName(context, MyApp.class.getPackage().getName() + ".MyActivityAlias");
context.startActivity(intent);
// wait for activity to start
lock.await();

// continue with the tests
assertTrue(classHolder.hasValue());
assertTrue(classHolder.getValue().isAssignableFrom(MyActivity.class));

Holder es básicamente un objeto envoltorio. Puede usar una matriz o cualquier otra cosa para capturar un valor dentro de la clase anónima.

Answer 4

Me gusta la versión de @ Ryan porque no usa elementos internos no documentados, pero puedes escribir esto aún más corto:

private Activity getCurrentActivity() {
    final Activity[] activity = new Activity[1];
    onView(isRoot()).check(new ViewAssertion() {
        @Override
        public void check(View view, NoMatchingViewException noViewFoundException) {
            activity[0] = (Activity) view.getContext();
        }
    });
    return activity[0];
}

Tenga en cuenta que esto no funcionará al ejecutar sus pruebas en Firebase Test Lab. Que falla con

java.lang.ClassCastException: com.android.internal.policy.DecorContext cannot be cast to android.app.Activity

Answer 5

Mejoré la respuesta de @Fabian Streitel para que pueda utilizar este método sin ClassCastException

public static Activity getCurrentActivity() { final Activity[] activity = new Activity[1]; onView(isRoot()).check((view, noViewFoundException) -> { View checkedView = view; while (checkedView instanceof ViewGroup && ((ViewGroup) checkedView).getChildCount() > 0) { checkedView = ((ViewGroup) checkedView).getChildAt(0); if (checkedView.getContext() instanceof Activity) { activity[0] = (Activity) checkedView.getContext(); return; } } }); return activity[0]; }

Answer 6

No pude hacer funcionar ninguna de las otras soluciones, así que terminé teniendo que hacer esto:

Declare su ActivityTestRule :

@Rule
public ActivityTestRule<MainActivity> mainActivityTestRule =
        new ActivityTestRule<>(MainActivity.class);

Declare una matriz de actividad final para almacenar sus actividades:

private final Activity[] currentActivity = new Activity[1];

Agregue un método auxiliar para registrarse con el contexto de la aplicación para obtener actualizaciones del ciclo de vida:

private void monitorCurrentActivity() {
    mainActivityTestRule.getActivity().getApplication()
            .registerActivityLifecycleCallbacks(new Application.ActivityLifecycleCallbacks() {
                @Override
                public void onActivityCreated(final Activity activity, final Bundle savedInstanceState) { }

                @Override
                public void onActivityStarted(final Activity activity) { }

                @Override
                public void onActivityResumed(final Activity activity) {
                    currentActivity[0] = activity;
                }

                @Override
                public void onActivityPaused(final Activity activity) { }

                @Override
                public void onActivityStopped(final Activity activity) { }

                @Override
                public void onActivitySaveInstanceState(final Activity activity, final Bundle outState) { }

                @Override
                public void onActivityDestroyed(final Activity activity) { }
            });
}

Agrega un método de ayuda para obtener la actividad actual

private Activity getCurrentActivity() {
    return currentActivity[0];
}

Entonces, una vez que haya lanzado su primera actividad, simplemente llame a monitorCurrentActivity() y luego cuando necesite una referencia a la actividad actual, simplemente llame a getCurrentActivity()

Answer 7

Si tiene la única actividad en su caso de prueba, puede hacer:

1. declarar la Rule prueba

public static Activity getActivity() {
    final Activity[] currentActivity = new Activity[1];
    onView(allOf(withId(android.R.id.content), isDisplayed())).perform(new ViewAction() {
        @Override
        public Matcher<View> getConstraints() {
            return isAssignableFrom(View.class);
        }

        @Override
        public String getDescription() {
            return "getting text from a TextView";
        }

        @Override
        public void perform(UiController uiController, View view) {
            if (view.getContext() instanceof Activity) {
                Activity activity1 = ((Activity)view.getContext());
                currentActivity[0] = activity1;
            }
        }
    });
    return currentActivity[0];
}

2. obtener tu Activity :

@Rule
public ActivityTestRule<TestActivity> mActivityTestRule = new ActivityTestRule<>(TestActivity.class);

Eso es un pedazo de pastel!

Answer 8

Si todo lo que necesita es verificar la Activity actual, el uso puede llevarse bien con el one-liner nativo de Espresso para verificar que se lanzó el intento esperado:

intended(hasComponent(new ComponentName(getTargetContext(), ExpectedActivity.class)));

Espresso también te mostrará los intentos disparados mientras tanto si no coinciden con los tuyos.

La única configuración que necesita es reemplazar ActivityTestRule con IntentsTestRule en la prueba para permitirle realizar un seguimiento de los intentos de lanzamiento. Y asegúrese de que esta biblioteca esté en sus dependencias build.gradle :

androidTestCompile ''com.android.support.test.espresso:espresso-intents:2.2.1''

Answer 9

build.gradle

androidTestCompile(''com.android.support.test.espresso:espresso-core:2.2.2'',
                {
            exclude group: ''com.android.support'', module: ''support-annotations''
        })

Y, en tu clase de prueba instrumentada

 @Rule
    public ActivityTestRule<MainActivity> intentsTestRule = new ActivityTestRule<>(MainActivity.class);

    MainActivity mainActivity;

    @Before
    public void setUp() throws Exception {
        mainActivity = intentsTestRule.getActivity(); //now Activity''s view gets created
        //Because Activity''s view creation happens in UI Thread, so all the test cases, here, are used by UI Thread
    }

Answer 10

mActivityTestRule.getActivity()