Android: ¿cómo verifico si la actividad se está ejecutando?

¿Hay alguna forma simple de determinar si una determinada actividad está activa o no? Quiero hacer ciertas cosas dependiendo de qué actividad esté activa. p.ej:

if(activityrunning == activity1)
//do this
else if (activityrunning == activity2)
//do something else

Puedes usar una staticvariable dentro de la actividad.

class MyActivity extends Activity {
     static boolean active = false;

      @Override
      public void onStart() {
         super.onStart();
         active = true;
      } 

      @Override
      public void onStop() {
         super.onStop();
         active = false;
      }
}

El único inconveniente es que si lo usa en dos actividades que se vinculan entre sí, onStopla primera a veces se llama después onStarten la segunda. Entonces, ambas podrían ser ciertas brevemente.

Dependiendo de lo que intente hacer (¿actualizar la actividad actual de un servicio?). Simplemente puede registrar un escucha estático en el servicio en su onStartmétodo de actividad y luego el escucha correcto estará disponible cuando su servicio quiera actualizar la IU.

Me doy cuenta de que este problema es bastante antiguo, pero creo que aún vale la pena compartir mi solución, ya que podría ser útil para otros.

Esta solución no estaba disponible antes de que se lanzaran los Componentes de Arquitectura de Android.

La actividad es al menos parcialmente visible

getLifecycle().getCurrentState().isAtLeast(STARTED)

La actividad está en primer plano

getLifecycle().getCurrentState().isAtLeast(RESUMED)

Creo que más claro así:

  public boolean isRunning(Context ctx) {
        ActivityManager activityManager = (ActivityManager) ctx.getSystemService(Context.ACTIVITY_SERVICE);
        List<RunningTaskInfo> tasks = activityManager.getRunningTasks(Integer.MAX_VALUE);

        for (RunningTaskInfo task : tasks) {
            if (ctx.getPackageName().equalsIgnoreCase(task.baseActivity.getPackageName())) 
                return true;                                  
        }

        return false;
    }

Una opción sin usar ninguna variable auxiliar es:

activity.getWindow().getDecorView().getRootView().isShown()

donde la actividad es fe: this o getActivity ().

El valor devuelto por esta expresión cambia en onStart () / onStop (), que son los eventos que comienzan / detienen mostrando el diseño de la actividad en el teléfono.

Usé el método MyActivity.class y getCanonicalName y obtuve una respuesta.

protected Boolean isActivityRunning(Class activityClass)
{
        ActivityManager activityManager = (ActivityManager) getBaseContext().getSystemService(Context.ACTIVITY_SERVICE);
        List<ActivityManager.RunningTaskInfo> tasks = activityManager.getRunningTasks(Integer.MAX_VALUE);

        for (ActivityManager.RunningTaskInfo task : tasks) {
            if (activityClass.getCanonicalName().equalsIgnoreCase(task.baseActivity.getClassName()))
                return true;
        }

        return false;
}

Mucho mejor manera que usar una variable estática y seguir OOP

Shared Preferencesse puede usar para compartir variables con otros activitiesy servicios de unoapplication

    public class example extends Activity {

    @Override
    protected void onStart() {
        super.onStart();

        // Store our shared preference
        SharedPreferences sp = getSharedPreferences("OURINFO", MODE_PRIVATE);
        Editor ed = sp.edit();
        ed.putBoolean("active", true);
        ed.commit();
    }

    @Override
    protected void onStop() {
        super.onStop();

        // Store our shared preference
        SharedPreferences sp = getSharedPreferences("OURINFO", MODE_PRIVATE);
        Editor ed = sp.edit();
        ed.putBoolean("active", false);
        ed.commit();

    }
}

Usa las preferencias compartidas. Tiene la información de estado más confiable, menos problemas de cambio / destrucción de aplicaciones, nos ahorra pedir otro permiso y nos da más control para decidir cuándo nuestra actividad es realmente la más importante. ver detalles aquí abd aquí también

Este es un código para verificar si se está ejecutando un servicio en particular. Estoy bastante seguro de que también puede funcionar para una actividad siempre que cambie getRunningServices con getRunningAppProcesses () o getRunningTasks (). Echa un vistazo aquí http://developer.android.com/reference/android/app/ActivityManager.html#getRunningAppProcesses ()

Cambie Constants.PACKAGE y Constants.BACKGROUND_SERVICE_CLASS en consecuencia

    public static boolean isServiceRunning(Context context) {

    Log.i(TAG, "Checking if service is running");

    ActivityManager activityManager = (ActivityManager)context.getSystemService(Context.ACTIVITY_SERVICE);

    List<RunningServiceInfo> services = activityManager.getRunningServices(Integer.MAX_VALUE);

    boolean isServiceFound = false;

    for (int i = 0; i < services.size(); i++) {

        if (Constants.PACKAGE.equals(services.get(i).service.getPackageName())){

            if (Constants.BACKGROUND_SERVICE_CLASS.equals(services.get(i).service.getClassName())){
                isServiceFound = true;
            }
        }
    }

    Log.i(TAG, "Service was" + (isServiceFound ? "" : " not") + " running");

    return isServiceFound;

}

Hay una manera mucho más fácil que todo lo anterior y este enfoque no requiere el uso android.permission.GET_TASKSen el manifiesto, o tiene el problema de las condiciones de carrera o las pérdidas de memoria señaladas en la respuesta aceptada.

1. Hacer una variable ESTÁTICA en la Actividad principal. Static permite que otras actividades reciban los datos de otra actividad. onPause()establecer esta variable falsa , onResumey onCreate()establecer esta variable verdadera .

   private static boolean mainActivityIsOpen;

2. Asigna getters y setters de esta variable.

   public static boolean mainActivityIsOpen() {
       return mainActivityIsOpen;
   }
   
   public static void mainActivityIsOpen(boolean mainActivityIsOpen) {
       DayView.mainActivityIsOpen = mainActivityIsOpen;
   }
   

3. Y luego de otra actividad o servicio

   if (MainActivity.mainActivityIsOpen() == false)
   {
                   //do something
   }
   else if(MainActivity.mainActivityIsOpen() == true)
   {//or just else. . . ( or else if, does't matter)
           //do something
   }
   

if(!activity.isFinishing() && !activity.isDestroyed())

De los documentos oficiales:

Activity # isFinishing ()

Verifique si esta actividad está en proceso de finalización, ya sea porque llamó a finish () o porque alguien más ha solicitado que finalice. Esto se usa a menudo en onPause () para determinar si la actividad es simplemente pausar o terminar por completo.

Activity # isDestroyed ()

Devuelve verdadero si la última llamada onDestroy () se ha realizado en la Actividad, por lo que esta instancia ahora está muerta.

gracias kkudi! Pude adaptar tu respuesta al trabajo para una actividad ... esto es lo que funcionó en mi aplicación ...

public boolean isServiceRunning() { 

ActivityManager activityManager = (ActivityManager)Monitor.this.getSystemService (Context.ACTIVITY_SERVICE); 
    List<RunningTaskInfo> services = activityManager.getRunningTasks(Integer.MAX_VALUE); 
    isServiceFound = false; 
    for (int i = 0; i < services.size(); i++) { 
        if (services.get(i).topActivity.toString().equalsIgnoreCase("ComponentInfo{com.lyo.AutoMessage/com.lyo.AutoMessage.TextLogList}")) {
            isServiceFound = true;
        }
    } 
    return isServiceFound; 
} 

este ejemplo le dará un verdadero o falso si topActivity coincide con lo que está haciendo el usuario. Entonces, si la actividad que está buscando no se muestra (es decir, está en Pausa), no obtendrá una coincidencia. Además, para hacer esto, debe agregar el permiso a su manifiesto.

<uses-permission  android:name="android.permission.GET_TASKS"/>

¡Espero que esto haya sido útil!

Creo que la respuesta aceptada es una forma horrible de manejar esto.

No sé cuál es el caso de uso, pero considere un método protegido en la clase base

@protected
void doSomething() {
}

y anularlo en la clase derivada.

Cuando se produce el evento, simplemente llame a este método en la clase base. La clase 'activa' correcta lo manejará entonces. La clase misma puede verificar si no es así Paused().

Mejor aún, use un bus de eventos como GreenRobot's , Square's , pero ese está en desuso y sugiere usar RxJava

Usé un cheque if (!a.isFinishing())y parece hacer lo que necesito. aes la instancia de actividad. ¿Es esto incorrecto? ¿Por qué nadie intentó esto?

qué pasa activity.isFinishing()

ActivityLifecycleCallbacks es una excelente manera de realizar un seguimiento de todas las actividades en la aplicación:

public class BaseActivityLifecycleCallbacks implements Application.ActivityLifecycleCallbacks {

private ActivityState homeState, contentState;

@Override
public void onActivityCreated(Activity activity, Bundle bundle) {
    if (activity instanceof HomeActivityv2) {
        homeState = ActivityState.CREATED;
    } else if (activity instanceof ContentDisplayActivity) {
        contentState = ActivityState.CREATED;
    }
}

@Override
public void onActivityStarted(Activity activity) {
    if (activity instanceof HomeActivityv2) {
        homeState = ActivityState.STARTED;
    } else if (activity instanceof ContentDisplayActivity) {
        contentState = ActivityState.STARTED;
    }
}

@Override
public void onActivityResumed(Activity activity) {
    if (activity instanceof HomeActivityv2) {
        homeState = ActivityState.RESUMED;
    } else if (activity instanceof ContentDisplayActivity) {
        contentState = ActivityState.RESUMED;
    }
}

@Override
public void onActivityPaused(Activity activity) {
    if (activity instanceof HomeActivityv2) {
        homeState = ActivityState.PAUSED;
    } else if (activity instanceof ContentDisplayActivity) {
        contentState = ActivityState.PAUSED;
    }
}

@Override
public void onActivityStopped(Activity activity) {
    if (activity instanceof HomeActivityv2) {
        homeState = ActivityState.STOPPED;
    } else if (activity instanceof ContentDisplayActivity) {
        contentState = ActivityState.STOPPED;
    }
}

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

@Override
public void onActivityDestroyed(Activity activity) {
    if (activity instanceof HomeActivityv2) {
        homeState = ActivityState.DESTROYED;
    } else if (activity instanceof ContentDisplayActivity) {
        contentState = ActivityState.DESTROYED;
    }
}

public ActivityState getHomeState() {
    return homeState;
}

public ActivityState getContentState() {
    return contentState;
}
}

ActivityState:

public enum ActivityState {
    CREATED, STARTED, RESUMED, PAUSED, STOPPED, DESTROYED;
}

Extienda la clase de aplicación y proporcione su referencia en el archivo de manifiesto de Android:

import android.app.Application;

public final class BaseApplication extends Application {
private BaseActivityLifecycleCallbacks baseALC;

@Override
public void onCreate() {
    super.onCreate();
    baseALC = new BaseActivityLifecycleCallbacks();
    this.registerActivityLifecycleCallbacks(baseALC);

}

public BaseActivityLifecycleCallbacks getBaseALC() {
    return baseALC;
}
}

Haga clic en cualquier lugar de Actividad para ver el estado de otra actividad:

private void checkAndLaunchHomeScreen() {
    Application application = getApplication();
    if (application instanceof BaseApplication) {
        BaseApplication baseApplication = (BaseApplication) application;
        if (baseApplication.getBaseALC().getHomeState() == null || baseApplication.getBaseALC().getHomeState() == ActivityState.DESTROYED) {
            //Do anything you want
        }
    }
}

https://developer.android.com/reference/android/app/Application.ActivityLifecycleCallbacks.html

No estoy seguro de que sea una forma "adecuada" de "hacer cosas".
Si no hay una forma API para resolver la (o una) pregunta de lo que debería pensar un poco, tal vez esté haciendo algo mal y lea más documentos, etc.
(Como entendí, las variables estáticas son una forma comúnmente incorrecta en Android. Por causa podría funcionar, pero definitivamente habrá casos en los que no funcionará [por ejemplo, en producción, en millones de dispositivos]).
Exactamente en su caso, le sugiero que piense por qué necesita saber si otra actividad está viva ... puede comenzar otra actividad para obtener resultados para obtener su funcionalidad. O puede derivar la clase para obtener su funcionalidad, etc.
Atentamente.

Si está interesado en el estado del ciclo de vida de la instancia específica de la actividad, la solución de siliconagle se ve correcta, excepto que la nueva variable "activa" debería ser una variable de instancia, en lugar de estática.

Use una transmisión ordenada. Ver http://android-developers.blogspot.nl/2011/01/processing-ordered-broadcasts.html

En su actividad, registre un receptor en onStart, anule el registro en onStop. Ahora, por ejemplo, cuando un servicio necesita manejar algo que la actividad podría hacer mejor, envíe una transmisión ordenada desde el servicio (con un controlador predeterminado en el propio servicio). Ahora puede responder en la actividad cuando se está ejecutando. El servicio puede verificar los datos de resultados para ver si se manejó la transmisión y, si no, tomar las medidas apropiadas.

Además de la respuesta aceptada , si tiene varias instancias de la actividad, puede usar un contador en su lugar:

class MyActivity extends Activity {

     static int activeInstances = 0;

     static boolean isActive() {
        return (activeInstance > 0)
     }

      @Override
      public void onStart() {
         super.onStart();
         activeInstances++;
      } 

      @Override
      public void onStop() {
         super.onStop();
         activeInstances--;
      }
}

Has probado..

    if (getActivity() instanceof NameOfYourActivity){
        //Do something
    }

Encontramos una solución fácil con el siguiente código

@Override 
protected void onCreate(Bundle savedInstanceState) { 
            super.onCreate(savedInstanceState); 
            if ((getIntent().getFlags() & Intent.FLAG_ACTIVITY_BROUGHT_TO_FRONT) != 0) { 
                // Activity is being brought to front and not being  created again, 
                // Thus finishing this activity will bring the last viewed activity to foreground
                finish(); 
            } 
    }

Use la variable isActivity para verificar si la actividad está viva o no.

private boolean activityState = true;

 @Override
protected void onDestroy() {
    super.onDestroy();
    activityState = false;
}

Entonces revisa

if(activityState){
//add your code
}

Si desea verificar si la actividad está en la pila posterior, simplemente siga los siguientes pasos. 1. Declarado una ArrayList en su clase de Aplicación [La clase de aplicación se define en su archivo mainfest en la etiqueta de la aplicación]

private ArrayList<Class> runningActivities = new ArrayList<>();

2. Y agregue los siguientes métodos públicos para acceder y modificar esta lista.

   public void addActivityToRunningActivityies (Class cls) {
   if (!runningActivities.contains(cls)) runningActivities.add(cls);
   }
   
   public void removeActivityFromRunningActivities (Class cls) {
   if (runningActivities.contains(cls)) runningActivities.remove(cls);
   }
   
   public boolean isActivityInBackStack (Class cls) {
   return runningActivities.contains(cls);
   }

3. En su BaseActivity, donde todas las actividades lo extienden, anule los métodos onCreate y onDestroy para que pueda agregar y eliminar actividades de la pila posterior de la siguiente manera.

   @Override
   protected void onCreate(@Nullable Bundle savedInstanceState) {
   super.onCreate(savedInstanceState);
   
   ((MyApplicationClass)getApplication()).addActivityToRunningActivityies
   (this.getClass());
   }
   
   @Override
   protected void onDestroy() {
   super.onDestroy();
   
   ((MyApplicationClass)getApplication()).removeActivityFromRunningActivities
   (this.getClass());
   }

4. Finalmente, si desea verificar si la actividad está en la pila posterior o no, simplemente llame a esta función esActivityInBackStack.

Por ejemplo: quiero verificar si HomeActivity está en la pila posterior o no:

if (((MyApplicationClass) 
getApplication()).isActivityInBackStack(HomeActivity.class)) {
       // Activity is in the back stack
    } else {
       // Activity is not in the back stack
    }

public static boolean isActivityActive(Activity activity) {
    return !activity.isFinishing() &&
            (SDK_INT < JELLY_BEAN_MR1 || !activity.isDestroyed());
}

Esto funciona si no tienes la misma actividad en primer plano. Si abres desde la notificación no funciona, hice algunos ajustes y vine con esto:

public static boolean ativo = false;
public static int counter = 0;

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    ...
    counter++;
}

@Override
protected void onStart() {
    super.onStart();
    ativo = true;
}

@Override
protected void onStop() {
    super.onStop();
    if (counter==1) ativo = false;
}

@Override
protected void onDestroy() {
    counter--;
    super.onDestroy();
}

Eso funciona para mí con varias actividades abiertas al mismo tiempo.