Android: como verifico se a atividade está em execução?

Existe alguma maneira simples de determinar se uma determinada atividade está ativa ou não? Quero fazer certas coisas, dependendo de qual atividade está ativa. por exemplo:

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

Você pode usar uma staticvariável dentro da atividade.

class MyActivity extends Activity {
     static boolean active = false;

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

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

O único problema é que, se você usá-lo em duas atividades que se vinculam, onStopo primeiro é chamado às vezes onStartno segundo. Então, ambos podem ser verdadeiros brevemente.

Dependendo do que você está tentando fazer (atualize a atividade atual de um serviço?). Você pode simplesmente registrar um ouvinte estático no serviço no seu onStartmétodo de atividade e , em seguida, o ouvinte correto estará disponível quando seu serviço desejar atualizar a interface do usuário.

Sei que esse problema é bastante antigo, mas acho que ainda vale a pena compartilhar minha solução, pois pode ser útil para outras pessoas.

Esta solução não estava disponível antes do lançamento do Android Architecture Components.

A atividade é pelo menos parcialmente visível

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

A atividade está em primeiro plano

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

Eu acho mais claro assim:

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

Uma opção sem usar nenhuma variável auxiliar é:

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

onde a atividade é fe: this ou getActivity ().

O valor retornado por essa expressão muda em onStart () / onStop (), que são os eventos que iniciam / param de mostrar o layout da atividade no telefone.

Usei o método MyActivity.class e getCanonicalName e obtive resposta.

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

Maneira muito melhor do que usar uma variável estática e seguir o POO

Shared Preferencespode ser usado para compartilhar variáveis ​​com outros activitiese serviços de umapplication

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

    }
}

Use preferências compartilhadas. Ele possui as informações mais confiáveis ​​do estado, menos problemas de troca / destruição de aplicativos, economiza a solicitação de mais uma permissão e nos dá mais controle para decidir quando nossa atividade é realmente a mais alta. veja detalhes aqui abd aqui também

Este é um código para verificar se um serviço específico está sendo executado. Tenho certeza de que ele pode funcionar para uma atividade também desde que você altere getRunningServices com getRunningAppProcesses () ou getRunningTasks (). Dê uma olhada aqui http://developer.android.com/reference/android/app/ActivityManager.html#getRunningAppProcesses ()

Altere Constants.PACKAGE e Constants.BACKGROUND_SERVICE_CLASS de acordo

    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;

}

Existe uma maneira muito mais fácil do que tudo acima e essa abordagem não requer o uso do android.permission.GET_TASKSmanifesto, ou tem o problema de condições de corrida ou vazamento de memória apontado na resposta aceita.

1. Faça uma variável estática na atividade principal. Estático permite que outras atividades recebam os dados de outra atividade. onPause()definir esta variável falsa , onResumee onCreate()definir esta variável verdadeira .

   private static boolean mainActivityIsOpen;

2. Atribua getters e setters dessa variável.

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

3. E depois de outra atividade ou serviço

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

Dos documentos oficiais:

Atividade # isFinishing ()

Verifique se esta atividade está em processo de finalização, porque você chamou finish () ou se alguém solicitou a conclusão. Isso é frequentemente usado em onPause () para determinar se a atividade está simplesmente pausando ou terminando completamente.

Atividade # isDestroyed ()

Retorna true se a chamada final onDestroy () tiver sido feita na Activity, portanto, esta instância está morta.

obrigado kkudi! Consegui adaptar sua resposta para trabalhar em uma atividade ... eis o que funcionou no meu aplicativo ..

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 exemplo fornecerá um valor verdadeiro ou falso se topActivity corresponder ao que o usuário está fazendo. Portanto, se a atividade que você está verificando não está sendo exibida (ou seja, está na Pausa), você não terá uma correspondência. Além disso, para fazer isso, você precisa adicionar a permissão ao seu manifesto.

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

Eu espero que isso tenha sido útil!

Eu acho que a resposta aceita é uma maneira terrível de lidar com isso.

Não sei qual é o caso de uso, mas considere um método protegido na classe base

@protected
void doSomething() {
}

e substitua-o na classe derivada.

Quando o evento ocorrer, basta chamar esse método na classe base. A classe 'ativa' correta irá lidar com isso então. A própria classe pode então verificar se não está Paused().

Melhor ainda, use um barramento de eventos como o GreenRobot , o Square , mas esse está obsoleto e sugere o uso do RxJava

Eu usei um cheque if (!a.isFinishing())e parece fazer o que eu preciso. aé a instância da atividade. Isso está incorreto? Por que ninguém tentou isso?

A respeito activity.isFinishing()

ActivityLifecycleCallbacks é uma ótima maneira de acompanhar todas as atividades no App:

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

Estenda a classe Application e forneça sua referência no arquivo Android Manifest:

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

Verifique em qualquer lugar da Atividade o status de outra atividade:

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

Não tenho certeza se é uma maneira "adequada" de "fazer as coisas".
Se não há nenhuma maneira API para resolver o (ou a) pergunta que você deve pensar um pouco, talvez você está fazendo algo errado e leia mais docs vez etc.
(Como eu entendi variáveis estáticas é uma forma comumente errado no android. De causa poderia funcionar, mas definitivamente haverá casos em que não funcionará [por exemplo, na produção, em milhões de dispositivos]).
Exatamente no seu caso, sugiro pensar por que você precisa saber se outra atividade está viva? ... você pode iniciar outra atividade para obter a funcionalidade. Ou você pode derivar a classe para obter sua funcionalidade e assim por diante.
Cumprimentos.

Se você estiver interessado no estado do ciclo de vida da instância específica da atividade, a solução siliconeagle parece correta, exceto que a nova variável "ativa" deve ser uma variável de instância, e não estática.

Use uma transmissão ordenada. Consulte http://android-developers.blogspot.nl/2011/01/processing-ordered-broadcasts.html

Em sua atividade, registre um receptor no onStart, cancele o registro no onStop. Agora, quando, por exemplo, um serviço precisar lidar com algo que a atividade possa executar melhor, envie uma transmissão ordenada a partir do serviço (com um manipulador padrão no próprio serviço). Agora você pode responder na atividade quando ela estiver em execução. O serviço pode verificar os dados do resultado para ver se a transmissão foi manipulada e se não tomar as medidas apropriadas.

Além da resposta aceita , se você tiver várias instâncias da atividade, poderá usar um contador:

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

Você tentou..

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

Foi encontrada uma solução fácil com o seguinte 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 a variável isActivity para verificar se a atividade está ativa ou não.

private boolean activityState = true;

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

Então verifique

if(activityState){
//add your code
}

Se você quiser verificar se a atividade está na pilha de trás, siga as próximas etapas. 1. Declarou um ArrayList na sua classe Application [A classe Application é definida no seu arquivo principal na tag do aplicativo]

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

2. E adicione os seguintes métodos públicos para acessar e 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. Na BaseActivity, onde todas as atividades a estendem, substitua os métodos onCreate e onDestroy para que você possa adicionar e remover atividades da pilha traseira como a seguir.

   @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. Por fim, se você deseja verificar se a atividade está na pilha de trás ou não, basta chamar esta função comoActivityInBackStack.

Ex: desejo verificar se o HomeActivity está na pilha de trás ou não:

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

Este trabalho se você não tiver a mesma atividade em primeiro plano. Se você abrir a partir da notificação, não funcione, fiz alguns ajustes e viemos com isso:

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

Isso funciona para mim com várias atividades abertas ao mesmo tempo.