Список & quot; иметь & quot; Backstack & quot; всей моей деятельности.

If you want to check Which is the Current Activity you just need to get the last activity class in the list.

Создайте приложение, которое расширяет «Приложение». и сделать это:

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» чтобы:

Bind/Unbind Merlin Instance (used to get event when the app lose or get connection, for example when you close mobile data or when you open it). It is useful after the "OnConnectivityChanged" intent action was disabled. For more info about MERLIN see: MERLIN INFO LINK

Close my last Realm Instance when the application is closed; I will init it inside a BaseActivity wich is extended from all others activities and which has a private RealmHelper Instance. For more info about REALM see: REALM INFO LINK For instance I have a static "RealmHelper" instance inside my "RealmHelper" class which is instantiated inside my application "onCreate". I have a synchronization service in which I create I new "RealmHelper" because Realm is "Thread-Linked" and a Realm Instance can't work inside a different Thread. So in order to follow Realm Documentation "You Need To Close All Opened Realm Instances to avoid System Resources Leaks", to accomplish this thing I used the "Application.ActivityLifecycleCallbacks" as you can see up.

Finally I have a receiver wich is triggered when I finish to synchronize my application, then when the sync end it will call the "IEndSyncCallback" "onEndSync" method in which I look if I have a specific Activity Class inside my ActivitiesBackStack List because I need to do some operation if I already have passed this point inside my application.

Это все, надеюсь, это полезно. Увидимся :)

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

в котором вы можете хранить ссылку на одно или несколько действий или что-то еще, к чему вы хотите получить доступ во всем приложении.

ВызовUberManager.getInstance().setMainActivity( activity ); в основной деятельности по созданию.

ВызовUberManager.getInstance().getMainActivity(); в любом месте вашего приложения, чтобы получить его. (Я использую это, чтобы иметь возможность использовать тост из потока не пользовательского интерфейса.)

Убедитесь, что вы добавили вызов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;
    }
}

но все равно отвечу, если кто-то найдет это, как я.

Я решил это, просто используя это:

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

Обратите внимание, что & quot; getIntent (). ToString () & quot; включает в себя кучу другого текста, такого как имя вашего пакета и любые фильтры намерений для вашей деятельности. Технически мы проверяем текущее намерение, а не деятельность, но результат тот же. Просто используйте, например, Log.d (& quot; test & quot ;, getIntent (). ToString ()); если вы хотите увидеть весь текст. Это решение немного хакерское, но оно гораздо чище в вашем коде и функциональность та же.

ля получения текущей активности. Суперклассификация и в зависимости от onDestroy также хрупкая и не самый лучший дизайн.

Честно говоря, лучшее из того, что я придумал до сих пор, - это просто поддерживать enum в моем приложении, которое устанавливается при создании действия.

Другая рекомендация может заключаться в том, чтобы просто избегать использования нескольких видов деятельности, если это возможно. Это можно сделать либо с помощью фрагментов, либо в моих предпочтениях пользовательских представлений.

(Поскольку этот вопрос был задан изначально, многие приложения для Android также имеют компонент ReactNative - гибридное приложение.)

Класс ReactContext в ReactNative имеет полный набор логики для поддержки mCurrentActivity, который возвращается в getCurrentActivity ().

Примечание. Мне бы хотелось, чтобы getCurrentActivity () была реализована в классе приложений Android.

I did the Following in Kotlin

Edit the Application Class as Follows

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

 }

Create the ActivityLifecycleCallbacks class

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
}

}

you can now use it in any class by calling the following: FTApplication.currentActivity()

Update 2: Для этого добавлен официальный API, пожалуйста, используйтеActivityLifecycleCallbacks вместо.

UPDATE:

Как указано @gezdy, и я благодарен за это.set reference to null too для текущей активности вместо обновления только для каждого onResume установите для него значение null в каждом onDestroy действия, чтобы избежать проблемы утечки памяти.

Некоторое время назад мне нужна была та же функциональность, и вот метод, как я этого добился. В каждой вашей деятельности переопределите эти методы жизненного цикла.

@Override
protected void onResume() {
    super.onResume();
    appConstantsObj.setCurrentActivity(this);

}

@Override
protected void onPause() {
   clearReferences();
   super.onPause();
}

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

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

Теперь в вашем классе вещания вы можете получить доступ к текущей активности, чтобы показать предупреждение о ней.

В каждой деятельности вместо того, чтобы «регистрироваться» сам сApplication с помощью ручного кодирования мы можем использовать следующий API начиная с уровня 14, чтобы помочь нам достичь аналогичной цели с меньшим количеством ручного кодирования.

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.

However, this technique is only available since API level 14.

Note: Официальный API был добавлен в API 14: см. Этот ответ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 setCurrentActivityActivity mCurrentActivity){
              this.mCurrentActivity = mCurrentActivity;
        }
  }

Создать новую активность:

public class MyBaseActivity extends Activity {
    protected MyApp mMyApp;

    public void onCreateBundle savedInstanceState) {
        super.onCreatesavedInstanceState);
        mMyApp = MyApp)this.getApplicationContext);
    }
    protected void onResume) {
        super.onResume);
        mMyApp.setCurrentActivitythis);
    }
    protected void onPause) {
        clearReferences);
        super.onPause);
    }
    protected void onDestroy) {        
        clearReferences);
        super.onDestroy);
    }

    private void clearReferences){
        Activity currActivity = mMyApp.getCurrentActivity);
        if this.equalscurrActivity))
            mMyApp.setCurrentActivitynull);
    }
}

Итак, теперь вместо расширения класса Activity для ваших действий просто расширьте MyBaseActivity. Теперь вы можете получить текущую активность из приложения или из контекста активности следующим образом:

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

@lockwobr Спасибо за обновление

This does not work 100% of the time in api version 16, if you read the code on github the function "currentActivityThread" was change in Kitkat, so I want to say version 19ish, kind of hard to match api version to releases in github.

Имея доступ к текущемуActivity очень удобно Не было бы неплохо иметь статическийgetActivity метод, возвращающий текущую активность без лишних вопросов?

Activity класс очень полезен. Он предоставляет доступ к потоку пользовательского интерфейса приложения, представлениям, ресурсам и многому другому. Многочисленные методы требуютContextа как получить указатель? Вот несколько способов:

Легко решить с помощью отражения:

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

Такой метод можно использовать в любом месте приложения, и он намного удобнее, чем все упомянутые выше подходы. Более того, кажется, что это не так небезопасно, как кажется. Он не вводит каких-либо новых потенциальных утечек или нулевых указателей.

В приведенном выше фрагменте кода отсутствует обработка исключений, и он наивно предполагает, что первое запущенное действие - это то, что мы ищем. Возможно, вы захотите добавить некоторые дополнительные проверки.

Сообщение блога

которым наша команда была бы довольна, поэтому мы сделали свое дело. Мы используемActivityLifecycleCallbacks отслеживать текущую активность, а затем выставлять ее через сервис. Подробнее здесь:https://stackoverflow.com/a/38650587/10793