如何在android中获取当前的前台活动上下文？

Question

每当我的广播执行时，我都想对前台活动显示警报。

Answer 1

（注意： API 14 中添加了官方 API：请参阅此答案https://stackoverflow.com/a/29786451/119733）

不要使用以前的 (waqas716) 答案。

由于对活动的静态引用，您将遇到内存泄漏问题。更多详情请看以下链接http://android-developers.blogspot.fr/2009/01/avoiding-memory-leaks.html

为避免这种情况，您应该管理活动引用。 在清单文件中添加应用程序的名称：

<application
    android:name=".MyApp"
    ....
 </application>

您的应用程序类：

  public class MyApp extends Application {
        public void onCreate() {
              super.onCreate();
        }

        private Activity mCurrentActivity = null;
        public Activity getCurrentActivity(){
              return mCurrentActivity;
        }
        public void setCurrentActivity(Activity mCurrentActivity){
              this.mCurrentActivity = mCurrentActivity;
        }
  }

创建一个新的活动：

public class MyBaseActivity extends Activity {
    protected MyApp mMyApp;

    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        mMyApp = (MyApp)this.getApplicationContext();
    }
    protected void onResume() {
        super.onResume();
        mMyApp.setCurrentActivity(this);
    }
    protected void onPause() {
        clearReferences();
        super.onPause();
    }
    protected void onDestroy() {        
        clearReferences();
        super.onDestroy();
    }

    private void clearReferences(){
        Activity currActivity = mMyApp.getCurrentActivity();
        if (this.equals(currActivity))
            mMyApp.setCurrentActivity(null);
    }
}

所以，现在不要为您的活动扩展 Activity 类，只需扩展 MyBaseActivity。现在，您可以像这样从应用程序或活动上下文中获取当前活动：

Activity currentActivity = ((MyApp)context.getApplicationContext()).getCurrentActivity();

Answer 2

我在@gezdy 的答案的顶部展开。

在每个活动中，我们不必通过手动编码向Application“注册”自己，而是可以使用从级别 14 开始的以下 API，以帮助我们以更少的手动编码实现类似的目的。

public void registerActivityLifecycleCallbacks (Application.ActivityLifecycleCallbacks callback)

http://developer.android.com/reference/android/app/Application.html#registerActivityLifecycleCallbacks%28android.app.Application.ActivityLifecycleCallbacks%29

在Application.ActivityLifecycleCallbacks 中，您可以获取哪个Activity 与此Application“连接”或“分离”。

但是，此技术仅从 API 级别 14 开始可用。

Answer 3

更新3：官方为此添加了一个api，请使用ActivityLifecycleCallbacks代替。

Answer 4

@lockwobr感谢更新

如果您阅读 github上的代码函数“currentActivityThread”发生了变化 Kitkat，所以我想说版本 19ish，有点难以匹配 api 在 github 上发布版本。

访问当前的Activity 非常方便。如果有一个静态的getActivity 方法返回当前的 Activity 而没有不必要的问题不是很好吗？

Activity 类非常有用。它允许访问应用程序的 UI 线程、视图、资源等等。很多方法都需要Context，但是如何获取指针呢？以下是一些方法：

• 使用覆盖的生命周期方法跟踪应用程序的状态。 您必须将当前 Activity 存储在静态变量中，然后 需要访问所有活动的代码。
• 使用 Instrumentation 跟踪应用程序的状态。宣布 清单中的检测，实现它并使用它的方法 跟踪活动变化。将 Activity 指针传递给方法和 您的活动中使用的类。使用其中之一注入指针 代码注入库。 所有这些方法都相当 不方便； 幸运的是，有一种更简单的方法可以获取 当前活动。
• 似乎系统需要在没有 上面提到的问题。所以，很可能有办法得到 仅使用静态调用的活动。我花了很多时间挖掘 通过 grepcode.com 上的 Android 资源，我找到了自己 寻找。有一个类叫做ActivityThread。这个班有 访问所有活动，更好的是，有一个静态方法 获取当前的ActivityThread。只有一点点 问题 - 活动列表具有包访问权限。

使用反射很容易解决：

public static Activity getActivity() {
    Class activityThreadClass = Class.forName("android.app.ActivityThread");
    Object activityThread = activityThreadClass.getMethod("currentActivityThread").invoke(null);
    Field activitiesField = activityThreadClass.getDeclaredField("mActivities");
    activitiesField.setAccessible(true);

    Map<Object, Object> activities = (Map<Object, Object>) activitiesField.get(activityThread);
    if (activities == null)
        return null;

    for (Object activityRecord : activities.values()) {
        Class activityRecordClass = activityRecord.getClass();
        Field pausedField = activityRecordClass.getDeclaredField("paused");
        pausedField.setAccessible(true);
        if (!pausedField.getBoolean(activityRecord)) {
            Field activityField = activityRecordClass.getDeclaredField("activity");
            activityField.setAccessible(true);
            Activity activity = (Activity) activityField.get(activityRecord);
            return activity;
        }
    }

    return null;
}

这种方法可以在应用程序的任何地方使用，它比所有提到的方法都方便得多。此外，它似乎并不像看起来那么不安全。它不会引入任何新的潜在泄漏或空指针。

上面的代码 sn-p 缺少异常处理，并且天真地假设第一个运行的 Activity 就是我们正在寻找的那个。您可能需要添加一些额外的检查。

Blog Post

Answer 5

知道 ActivityManager 管理 Activity，因此我们可以从 ActivityManager 获取信息。我们通过

获取当前前台运行的Activity

ActivityManager am = (ActivityManager)context.getSystemService(Context.ACTIVITY_SERVICE);
ComponentName cn = am.getRunningTasks(1).get(0).topActivity;

2018 年 10 月 3 日更新
getRunningTasks() 已弃用。请参阅下面的解决方案。

此方法在 API 级别 21 中已弃用。 从 Build.VERSION_CODES.LOLLIPOP 开始，此方法不再可用于第三方应用程序：引入以文档为中心的最新消息意味着它可以将人员信息泄露给调用者。为了向后兼容，它仍然会返回一小部分数据：至少是调用者自己的任务，可能还有其他一些已知不敏感的任务，例如 home。

Answer 6

我在 Kotlin 中做了以下操作

1. 创建应用程序类

2. 如下编辑应用程序类

   class FTApplication: MultiDexApplication() {
   override fun attachBaseContext(base: Context?) {
       super.attachBaseContext(base)
       MultiDex.install(this)
   }
   
   init {
       instance = this
   }
   
   val mFTActivityLifecycleCallbacks = FTActivityLifecycleCallbacks()
   
   override fun onCreate() {
       super.onCreate()
   
       registerActivityLifecycleCallbacks(mFTActivityLifecycleCallbacks)
   }
   
   companion object {
       private var instance: FTApplication? = null
   
       fun currentActivity(): Activity? {
   
           return instance!!.mFTActivityLifecycleCallbacks.currentActivity
       }
   }
   
    }
   

3. 创建ActivityLifecycleCallbacks类

   class FTActivityLifecycleCallbacks: Application.ActivityLifecycleCallbacks {
   
   var currentActivity: Activity? = null
   
   override fun onActivityPaused(activity: Activity?) {
       currentActivity = activity
   }
   
   override fun onActivityResumed(activity: Activity?) {
       currentActivity = activity
   }
   
   override fun onActivityStarted(activity: Activity?) {
       currentActivity = activity
   }
   
   override fun onActivityDestroyed(activity: Activity?) {
   }
   
   override fun onActivitySaveInstanceState(activity: Activity?, outState: Bundle?) {
   }
   
   override fun onActivityStopped(activity: Activity?) {
   }
   
   override fun onActivityCreated(activity: Activity?, savedInstanceState: Bundle?) {
       currentActivity = activity
   }
   
   }
   

4. 您现在可以通过调用以下命令在任何类中使用它：FTApplication.currentActivity()

Answer 7

getCurrentActivity() 也在 ReactContextBaseJavaModule 中。
（自从最初提出这个问题以来，许多Android应用也有ReactNative组件-混合应用。）

ReactNative 中的 ReactContext 类拥有一整套逻辑来维护在 getCurrentActivity() 中返回的 mCurrentActivity。

注意：我希望 getCurrentActivity() 在 Android Application 类中实现。

Answer 8

为了向后兼容：

ComponentName cn;
ActivityManager am = (ActivityManager) getApplicationContext().getSystemService(Context.ACTIVITY_SERVICE);
if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.M) {
    cn = am.getAppTasks().get(0).getTaskInfo().topActivity;
} else {
    //noinspection deprecation
    cn = am.getRunningTasks(1).get(0).topActivity;
}

Answer 9

我找不到我们的团队会满意的解决方案，所以我们推出了自己的解决方案。我们使用ActivityLifecycleCallbacks 来跟踪当前活动，然后通过服务公开它。更多细节在这里：https://stackoverflow.com/a/38650587/10793

Answer 10

我个人按照“Cheok Yan Cheng”说的做了，但是我用了一个“列表”来有一个我所有活动的“Backstack”。

如果您想检查当前活动是哪个，您只需要获取列表中的最后一个活动类。

创建一个扩展“应用程序”的应用程序并执行以下操作：

public class MyApplication extends Application implements Application.ActivityLifecycleCallbacks,
EndSyncReceiver.IEndSyncCallback {

private List<Class> mActivitiesBackStack;
private EndSyncReceiver mReceiver;
    private Merlin mMerlin;
    private boolean isMerlinBound;
    private boolean isReceiverRegistered;

@Override
    public void onCreate() {
        super.onCreate();
        [....]
RealmHelper.initInstance();
        initMyMerlin();
        bindMerlin();
        initEndSyncReceiver();
        mActivitiesBackStack = new ArrayList<>();
    }

/* START Override ActivityLifecycleCallbacks Methods */
    @Override
    public void onActivityCreated(Activity activity, Bundle bundle) {
        mActivitiesBackStack.add(activity.getClass());
    }

    @Override
    public void onActivityStarted(Activity activity) {
        if(!isMerlinBound){
            bindMerlin();
        }
        if(!isReceiverRegistered){
            registerEndSyncReceiver();
        }
    }

    @Override
    public void onActivityResumed(Activity activity) {

    }

    @Override
    public void onActivityPaused(Activity activity) {

    }

    @Override
    public void onActivityStopped(Activity activity) {
        if(!AppUtils.isAppOnForeground(this)){
            if(isMerlinBound) {
                unbindMerlin();
            }
            if(isReceiverRegistered){
                unregisterReceiver(mReceiver);
            }
            if(RealmHelper.getInstance() != null){
                RealmHelper.getInstance().close();
                RealmHelper.getInstance().logRealmInstanceCount("AppInBackground");
                RealmHelper.setMyInstance(null);
            }
        }
    }

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

    }

    @Override
    public void onActivityDestroyed(Activity activity) {
        if(mActivitiesBackStack.contains(activity.getClass())){
            mActivitiesBackStack.remove(activity.getClass());
        }
    }
    /* END Override ActivityLifecycleCallbacks Methods */

/* START Override IEndSyncCallback Methods */
    @Override
    public void onEndSync(Intent intent) {
        Constants.SyncType syncType = null;
        if(intent.hasExtra(Constants.INTENT_DATA_SYNC_TYPE)){
            syncType = (Constants.SyncType) intent.getSerializableExtra(Constants.INTENT_DATA_SYNC_TYPE);
        }
        if(syncType != null){
            checkSyncType(syncType);
        }
    }
    /* END IEndSyncCallback Methods */

private void checkSyncType(Constants.SyncType){
    [...]
    if( mActivitiesBackStack.contains(ActivityClass.class) ){
         doOperation()     }
}

}

就我而言，我使用“Application.ActivityLifecycleCallbacks”来：

• 绑定/取消绑定 Merlin 实例（用于在应用程序丢失或获得连接时获取事件，例如当您关闭移动数据或打开它时）。在禁用“OnConnectivityChanged”意图操作后很有用。 有关 MERLIN 的更多信息，请参阅：MERLIN INFO LINK

• 当应用程序关闭时关闭我的最后一个 Realm 实例；我将在 BaseActivity 中对其进行初始化，该 BaseActivity 是从所有其他活动扩展而来的，并且具有私有 RealmHelper 实例。 有关 REALM 的更多信息，请参阅：REALM INFO LINK 例如，我的“RealmHelper”类中有一个静态“RealmHelper”实例，该实例在我的应用程序“onCreate”中实例化。我有一个同步服务，我在其中创建了新的“RealmHelper”，因为 Realm 是“线程链接的”，并且 Realm 实例不能在不同的线程中工作。 因此，为了遵循领域文档“您需要关闭所有打开的领域实例以避免系统资源泄漏”，为了完成这件事，我使用了“Application.ActivityLifecycleCallbacks”，如您所见。

1234563我的 ActivitiesBackStack 列表，因为如果同步更新了视图上的数据，我需要更新它们，并且我可能需要在应用同步后执行其他操作。

就是这样，希望对您有所帮助。见你:)

Answer 11

您可以使用此Class 进行灵活的生命周期处理

用法：

    //Initialization
    val lifeCycleHandler = ActivityLifeCycleHandler<Activity>()

    //Detect only a specific type of activities
    val lifeCycleHandler = ActivityLifeCycleHandler<MainActivity>()

    //Get current activity
    val instance = lifeCycleHandler.currentReference

    //Get current activity state
    val state = lifeCycleHandler.currentState

    //Use listeners
    lifeCycleHandler.addStateChangeListener { newState ->
        //TODO: handle new state
    }

    lifeCycleHandler.addSpecificStateChangeListener(ActivityLifeCycleHandler.ActivityState.STARTED) {
        //TODO: handle new state
    }

    //Removable listeners
    val listener = { newState: Int ->

    }

    lifeCycleHandler.addStateChangeListener(listener)
    lifeCycleHandler.removeStateChageListener(listener)


    //Start listening
    App.app.registerActivityLifecycleCallbacks(lifeCycleHandler)

    //Stop listening
    lifeCycleHandler.releaseListeners()
    App.app.unregisterActivityLifecycleCallbacks(lifeCycleHandler)

Answer 12

通过使用这部分代码，您可以检测应用何时进入后台/前台并访问当前活动名称和上下文。

我的回答基于这篇文章：Android: How to detect when App goes background/foreground

首先，创建一个扩展android.app.Application 并实现ActivityLifecycleCallbacks 接口的类。在Application.onCreate()，注册回调。

public class App extends Application implements ActivityLifecycleCallbacks
@Override
public void onCreate() {
    super.onCreate();
    registerActivityLifecycleCallbacks(this);
}

如下在Manifest中注册“App”类，

<application
    android:name=".App"

ActivityLifecycleCallbacks 接口是这样的，

public interface ActivityLifecycleCallbacks {
    void onActivityCreated(Activity activity, Bundle savedInstanceState);
    void onActivityStarted(Activity activity);
    void onActivityResumed(Activity activity);
    void onActivityPaused(Activity activity);
    void onActivityStopped(Activity activity);
    void onActivitySaveInstanceState(Activity activity, Bundle outState);
    void onActivityDestroyed(Activity activity);
}

因此，当您的任何 Activity（您创建或包含在您的库中的 Activity）通过上述任何生命周期方法时，将调用这些回调。 应用在前台时，至少有一个处于已启动状态的Activity，而在应用处于后台时，将没有处于已启动状态的Activity。 在“App”类中声明如下2个变量。

private int activityReferences = 0;
private boolean isActivityChangingConfigurations = false;

activityReferences 将保持活动数量的计数处于启动状态。 isActivityChangingConfigurations 是一个标志，用于指示当前 Activity 是否正在经历配置更改，例如方向切换。 使用以下代码可以检测 App 是否进入前台。

@Override
public void onActivityStarted(Activity activity) {
    if (++activityReferences == 1 && !isActivityChangingConfigurations) {
        // App enters foreground
    }
}

您可以像这样在此方法中访问上下文：

activity.getBaseContext()

这是检测应用程序是否进入后台的方法。

Override
public void onActivityStopped(Activity activity) {

    isActivityChangingConfigurations = activity.isChangingConfigurations();
    if (--activityReferences == 0 && !isActivityChangingConfigurations) {
        // App enters background
    }
}

现在您可以访问当前前台活动名称和上下文。

Answer 13

waqas716 的回答很好。我为需要较少代码和维护的特定案例创建了一种解决方法。

我通过使用静态方法从我怀疑处于前台的活动中获取视图找到了一个特定的解决方法。 您可以遍历所有活动并检查您是否愿意或从 martin's 答案中获取活动名称

ActivityManager am = (ActivityManager)context.getSystemService(Context.ACTIVITY_SERVICE);
ComponentName cn = am.getRunningTasks(1).get(0).topActivity; 

然后我检查视图是否不为空，并通过 getContext() 获取上下文。

View v = SuspectedActivity.get_view();

if(v != null)
{
    // an example for using this context for something not 
    // permissible in global application context. 
    v.getContext().startActivity(new Intent("rubberduck.com.activities.SomeOtherActivity"));
}

Answer 14

我不喜欢任何其他答案。 ActivityManager 并不意味着用于获取当前活动。超级类和依赖于 onDestroy 也是脆弱的，不是最好的设计。

老实说，到目前为止我想出的最好的方法就是在我的应用程序中维护一个枚举，它会在创建活动时设置。

另一个建议可能是尽可能避免使用多项活动。这可以通过使用片段或在我偏好的自定义视图中完成。

Answer 15

一个相当简单的解决方案是创建一个单例管理器类，您可以在其中存储对一个或多个活动的引用，或者您希望在整个应用程序中访问的任何其他内容。

在主Activity的onCreate中调用UberManager.getInstance().setMainActivity( activity );。

在您的应用程序中的任何位置调用 UberManager.getInstance().getMainActivity(); 以检索它。 （我使用它是为了能够在非 UI 线程中使用 Toast。）

确保在您的应用被销毁时添加对 UberManager.getInstance().cleanup(); 的调用。

import android.app.Activity;

public class UberManager
{
    private static UberManager instance = new UberManager();

    private Activity mainActivity = null;

    private UberManager()
    {

    }

    public static UberManager getInstance()
    {
        return instance;
    }

    public void setMainActivity( Activity mainActivity )
    {
        this.mainActivity = mainActivity;
    }

    public Activity getMainActivity()
    {
        return mainActivity;
    }

    public void cleanup()
    {
        mainActivity = null;
    }
}

Answer 16

我迟到了 3 年，但无论如何我都会回答，以防有人像我一样发现这个问题。

我通过简单地使用这个解决了这个问题：

    if (getIntent().toString().contains("MainActivity")) {
        // Do stuff if the current activity is MainActivity
    }

请注意，“getIntent().toString()”包含一堆其他文本，例如您的包名称和您的活动的任何意图过滤器。从技术上讲，我们正在检查当前的意图，而不是活动，但结果是相同的。只需使用例如Log.d("test", getIntent().toString());如果您想查看所有文本。这个解决方案有点老套，但在你的代码中更简洁，功能也是一样的。