Android：如何检查活动是否正在运行？

有没有简单的方法来确定某个活动是否活跃？我想根据正在进行的活动来做某些事情。例如：

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

您可以static在活动中使用变量。

class MyActivity extends Activity {
     static boolean active = false;

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

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

唯一的陷阱是，如果在两个相互链接的活动中使用它，onStop则有时onStart在第二个活动中调用第一个活动。因此，两者可能短暂地是对的。

根据您要执行的操作（从服务中更新当前活动？）。您可以使用活动onStart方法在服务中注册一个静态侦听器，然后当您的服务要更新UI时正确的侦听器将可用。

我意识到这个问题已经很久了，但是我认为仍然值得分享我的解决方案，因为它可能对其他人有用。

在发布Android体系结构组件之前，该解决方案不可用。

活动至少部分可见

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

活动处于前台

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

我认为这样更清楚：

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

不使用任何辅助变量的选项是：

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

活动是fe的地方：this或getActivity（）。

此表达式返回的值在onStart（）/ onStop（）中发生更改，这些事件是开始/停止显示电话上的活动布局的事件。

我使用了MyActivity.class和getCanonicalName方法，并得到了答案。

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

比使用静态变量并遵循OOP更好的方法

Shared Preferences可用于与他人共享变量，activities并从一个共享服务application

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

    }
}

使用共享的首选项。它具有最可靠的状态信息，减少了应用程序切换/销毁问题，使我们不必再寻求其他权限，并且它使我们可以更好地控制何时确定活动实际上是最高的。看细节了这里 ABD 这里还

这是用于检查特定服务是否正在运行的代码。我相当确定，只要您使用getRunningAppProcesses（）或getRunningTasks（）更改getRunningServices，它也可以对活动起作用。在这里看看http://developer.android.com/reference/android/app/ActivityManager.html#getRunningAppProcesses（）

相应地更改Constants.PACKAGE和Constants.BACKGROUND_SERVICE_CLASS

    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;

}

有一种比上面所有方法都简单得多的方法，该方法不需要android.permission.GET_TASKS在清单中使用，或者在公认的答案中指出了竞争条件或内存泄漏的问题。

1. 在主活动中创建一个STATIC变量。静态允许其他活动从另一个活动接收数据。onPause()将此变量设置为false，onResume并将onCreate()此变量设置为true。

   private static boolean mainActivityIsOpen;

2. 分配此变量的获取器和设置器。

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

3. 然后从另一个活动或服务

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

从官方文档：

活动#isFinishing（）

检查此活动是否正在完成中，这是因为您在该活动上调用了finish（）还是其他人已要求完成该活动。通常在onPause（）中使用它来确定活动是只是暂停还是完全结束。

活动#isDestroyed（）

如果对Activity进行了最后的onDestroy（）调用，则返回true，因此该实例现在已失效。

谢谢kkudi！我能够调整您的答案以使其适合某项活动……这就是我的应用程序中有效的方法。

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

如果topActivity与用户正在执行的操作匹配，则此示例将为true或false。因此，如果未显示您所检查的活动（即onPause），那么您将不会获得匹配。另外，要执行此操作，您需要将权限添加到清单中。

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

我希望这可以帮到你！

我认为公认的答案是处理此问题的一种糟糕方法。

我不知道用例是什么，但是请在基类中考虑一个受保护的方法

@protected
void doSomething() {
}

并在派生类中重写它。

事件发生时，只需在基类中调用此方法。正确的“活动”类将对其进行处理。然后，类本身可以检查是否不是Paused()。

更重要的是，使用一个事件像公交车GreenRobot的，方形的，而是一个已被弃用，并使用建议RxJava

我用了一张支票if (!a.isFinishing())，它似乎可以满足我的需求。a是活动实例。这不正确吗？为什么没有人尝试呢？

关于什么 activity.isFinishing()

ActivityLifecycleCallbacks是跟踪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;
}
}

活动状态：

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

扩展Application类，并在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;
}
}

在“活动”中的任意位置查看其他活动的状态：

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

不确定这是“做事”的“正确”方法。
如果没有一种API方法可以解决您的问题，那么您可能做错了，请阅读更多文档等等。
（据我所知，静态变量在android中通常是错误的方法。它可能会起作用，但肯定会在某些情况下无法起作用（例如，在生产中，在数百万个设备上））。
正是在您的情况下，我建议考虑一下为什么您需要知道另一个活动是否还存在吗？..您可以启动另一个活动以获得结果以获取其功能。或者，您可以派生该类以获得其功能，等等。
最好的祝福。

如果您对活动的特定实例的生命周期状态感兴趣，那么siliconeagle的解决方案看起来是正确的，只是新的“活动”变量应该是实例变量而不是静态变量。

使用有序广播。参见http://android-developers.blogspot.nl/2011/01/processing-ordered-broadcasts.html

在您的活动中，在onStart中注册一个接收者，在onStop中注销。现在，例如，当服务需要处理活动可能能够做得更好的事情时，请从服务发送有序广播（服务本身具有默认处理程序）。现在，您可以在活动运行时对其进行响应。该服务可以检查结果数据，以查看是否处理了广播，如果没有，请采取适当的措施。

除了可接受的答案外，如果您有活动的多个实例，则可以使用计数器来代替：

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

你有没有尝试过..

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

使用以下代码找到了一个简单的解决方法

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

使用isActivity变量检查活动是否有效。

private boolean activityState = true;

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

然后检查

if(activityState){
//add your code
}

如果要检查活动是否在堆栈中，请执行以下步骤。1.在Application类中声明一个ArrayList [Application类在application标签的mainfest文件中定义]

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

2. 并添加以下公共方法来访问和修改此列表。

   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. 在所有活动将其扩展的BaseActivity中，重写onCreate和onDestroy方法，以便您可以按如下所示从后堆栈中添加和删除活动。

   @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. 最后，如果要检查活动是否在后堆栈中，则只需调用此函数isActivityInBackStack。

例如：我想检查HomeActivity是否在后堆栈中：

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

如果您在前台没有相同的活动，则可以进行此工作。如果您从通知中打开不起作用，我会进行一些调整并附带以下内容：

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

这对我有效，同时有几个活动。