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

有没有简单的方法来确定某项活动是否处于活动状态？ 我想做一些事情，这取决于哪个活动是活跃的。 例如：

---

这是用于检查特定服务是否正在运行的代码。我敢肯定，只要使用getRunningAppProcesses（）或getRunningTasks（）更改getRunningServices，它也可以用于活动。看看这里

相应地更改Constants.PACKAGE和Constants.BACKGROUND\u服务\u类

    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;

}

公共静态布尔IServiceRunning（上下文）{
Log.i（标记“检查服务是否正在运行”）；
ActivityManager ActivityManager=（ActivityManager）context.getSystemService（context.ACTIVITY_服务）；
List services=activityManager.getRunningServices（Integer.MAX_值）；
布尔值IsServiceFund=false；
对于（int i=0；i

您可以在活动中使用

静态

变量

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

之后调用。因此，这两种说法可能都是正确的

---

取决于您尝试执行的操作（从服务更新当前活动？）。您只需在activity

onStart

方法中的服务中注册一个静态侦听器，那么当您的服务想要更新UI时，正确的侦听器将可用。

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

public boolean isServiceRunning（）{
ActivityManager ActivityManager=（ActivityManager）Monitor.this.getSystemService（Context.ACTIVITY_服务）；
列表服务=activityManager.getRunningTasks（整数.MAX_值）；
IsServiceFund=false；
对于（inti=0；i

如果topActivity与用户正在执行的操作相匹配，则此示例将为您提供true或false。因此，如果您检查的活动未显示（即，处于暂停状态），则您将无法获得匹配项。此外，要执行此操作，您需要将权限添加到清单中

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

---

我希望这是有帮助的

我想更清楚的是：

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

public boolean正在运行（上下文ctx）{
ActivityManager ActivityManager=（ActivityManager）ctx.getSystemService（Context.ACTIVITY_服务）；
列表任务=activityManager.getRunningTasks（整数.MAX_值）；
用于（RunningTaskInfo任务：任务）{
if（ctx.getPackageName（）.equalsIgnoreCase（task.baseActivity.getPackageName（））
返回true；
}
返回false；
}

有一种比上述方法简单得多的方法，这种方法不需要使用android.permission.GET_TASKS，也不需要在清单中指出竞争条件或内存泄漏问题

在主活动中创建一个静态变量。静态允许其他活动从其他活动接收数据

onPause（）

设置此变量false、

onResume

和

onCreate（）

设置此变量true

private static boolean mainActivityIsOpen;

分配此变量的getter和setter

public static boolean mainActivityIsOpen() {
    return mainActivityIsOpen;
}

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

然后从另一个活动或服务

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

---

我使用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;
}

受保护的布尔值isActivityRunning（类activityClass）
{
ActivityManager ActivityManager=（ActivityManager）getBaseContext（）.getSystemService（Context.ACTIVITY_服务）；
列表任务=activityManager.getRunningTasks（整数.MAX_值）；
对于（ActivityManager.RunningTaskInfo任务：任务）{
if（activityClass.getCanonicalName（）.equalsIgnoreCase（task.baseActivity.getClassName（）））
返回true；
}
返回false；
}

不确定这是“做事”的“正确”方式。
如果没有API方法来解决这个（或一个）问题，而不是你应该想一想，那么可能是你做错了什么，而是读了更多的文档等等。
（据我所知，静态变量在android中是一种常见的错误方式。当然，它可以工作，但肯定会有不工作的情况[例如，在生产中，在百万台设备上]。
正是在你的情况下，我建议你想想，为什么你需要知道另一个活动是否还活着？。。您可以为result启动另一个活动以获取其功能。或者您可以派生类以获得其功能等。

---

致以最诚挚的问候。

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

比使用静态变量并遵循OOP好得多。

共享首选项

可用于与其他

活动

和来自一个

应用程序的服务共享变量

    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使用有序广播。看

在活动中，注册接收

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

    }
}

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

class MyActivity extends Activity {

     static int activeInstances = 0;

     static boolean isActive() {
        return (activeInstances > 0);
     }

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

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

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

@protected
void doSomething() {
}

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

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

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

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

private boolean activityState = true;

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

if(activityState){
//add your code
}

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

getLifecycle().getCurrentState().isAtLeast(Lifecycle.State.STARTED)

getLifecycle().getCurrentState().isAtLeast(Lifecycle.State.RESUMED)

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

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

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

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

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

    for (ActivityManager.RunningTaskInfo task : tasks) {
        if (task.topActivity.getClassName().equals(NotificationsActivity.class.getCanonicalName()))
            return true;
    }

    return false;
}

class IPC {

    companion object {
        private val appContext : Context by lazy { /*genericApplicationContext*/ }

        fun initIPC(process: String){
            var file : File? = null
            file = File(appContext.cacheDir.absolutePath + "/$process")
            var output : OutputStream? = null
            try {
                output = FileOutputStream(file!!)
                output.write(0)
            } finally {
                output?.close()
            }
        }

        fun destroyIPC(process: String){
            var file : File? = null
            file = File(appContext.cacheDir.absolutePath + "/$process")
            file.delete()
        }

        fun checkForIPC(process: String) : Boolean {
            var file : File? = null
            file = File(appContext.cacheDir.absolutePath + "/$process")
            if(file.exists()) return true
            return false
        }
    }

}