Android: अगर गतिविधि चल रही है तो मैं कैसे जांच करूं?

Question

क्या कोई निश्चित गतिविधि सक्रिय है या नहीं, यह निर्धारित करने का कोई सरल तरीका है? मैं कुछ चीजें करना चाहता हूं, जिसके आधार पर गतिविधि सक्रिय है। उदाहरण के लिए:

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

Comments

यह जांचने के लिए कि कोई गतिविधि चल रही है या नहीं, आप इस उत्तर के माध्यम से जा सकते हैं: stackoverflow.com/a/39079627/4531507

— राहुल शर्मा

Answer 1

आप 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पद्धति में सेवा में केवल एक स्थिर श्रोता को पंजीकृत कर सकते हैं, तब सही श्रोता तब उपलब्ध होगा जब आपकी सेवा यूआई को अपडेट करना चाहती है।

Comments

कुछ लोगों ने मुझे इस ओर इशारा किया कि स्मृति रिसाव की समस्याओं के कारण एक स्थिर वैरिएबल पर साझाकरण को प्राथमिकता दी जानी चाहिए।

— आयुष गोयल

यदि एक ही वर्ग की विभिन्न गतिविधियाँ चल रही हों तो क्या होगा? आप क्या विस्तार करता है, तो MyActivityसाथ MyChildactivityऔर अगर बच्चे सक्रिय है जाँच करना चाहते हैं?

— मिस्टर स्मिथ

"रनिंग" की अपनी परिभाषा के आधार पर आप वेरिएबल की स्थिति को onResume और onPause में बदलना चाह सकते हैं ....

— जी। ब्लेक

यह समाधान एक अच्छा समाधान नहीं है। कहते हैं कि आपकी गतिविधि को एक फ़्रैगमेंट कहते हैं, उदाहरण के लिए, फ़्रेगमेंट गतिविधि के ऊपर होगा, फिर भी गतिविधि ऑनपॉज़ को कॉल नहीं करेगी, और यदि आप फ़ॉरेस्ट को onStop, onStart, या किसी अन्य जीवनचक्र के तरीकों को बंद करते हैं, तो उसे कॉल नहीं किया जाएगा। सबसे अच्छा समाधान आपके एप्लिकेशन वर्ग में दृश्यता की जाँच करना है जैसा कि यहाँ वर्णित है: stackoverflow.com/questions/18038399/…

— portfoliobuilder

यदि आप स्टैटिक्स सुझाते हैं, तो आपको मेरे से -1 मिलता है

— मेटी सुइका

Answer 2

मुझे लगता है कि यह मुद्दा काफी पुराना है, लेकिन मुझे लगता है कि यह अभी भी मेरे समाधान को साझा करने के लायक है क्योंकि यह दूसरों के लिए उपयोगी हो सकता है।

Android आर्किटेक्चर घटक जारी होने से पहले यह समाधान उपलब्ध नहीं था।

गतिविधि कम से कम आंशिक रूप से दिखाई देती है

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

गतिविधि अग्रभूमि में है

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

Comments

getLifecycle ()। getCurrentState () .AtLeast (Lifecycle.State.RESUMED)

— राधे

Answer 3

मुझे लगता है कि इस तरह अधिक स्पष्ट:

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

Comments

मैं 'लूप' के लिए अस्थायी चर बनाने से बचने की कोशिश करता हूं; के लिए (RunningTaskInfo कार्य: ActivityManager.getRunningTasks (Integer.MAX_VALUE)) {...

— mikebabcock

मैं इस फ़ंक्शन को कैसे कह सकता हूं?

— बेहजाद

हमेशा की तरह, एक मेथोड है जिसे आप अपनी कक्षा में 'फ़ंक्शन' के रूप में कह सकते हैं, क्या आपको एक उदाहरण की आवश्यकता है?

— क्लेनिओन नोव

से developer.android.com/reference/android/app/... "यह कभी नहीं कोर तर्क के लिए एक आवेदन में, इस तरह के बारे में जानकारी यहां पाया आधार पर अलग अलग व्यवहार के बीच तय रूप में इस्तेमाल किया जाना चाहिए। इस तरह का उपयोग करता है समर्थित नहीं हैं, और तोड़ने की संभावना होगा भविष्य में।"

— joe_deniable

एपीआई स्तर 21 (एंड्रॉइड 5.0 लॉलीपॉप) के रूप में इस पद्धति को पदावनत किया गया है।

— एक्सईफेक्ट

Answer 4

किसी भी अपरिवर्तनीय चर का उपयोग किए बिना एक विकल्प है:

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

जहां गतिविधि fe: यह या getActivity () है।

इस अभिव्यक्ति द्वारा लौटाए गए मूल्य onStart () / onStop () में बदल जाते हैं, जो ऐसी घटनाएं हैं जो फोन पर गतिविधि के लेआउट को दिखाने / शुरू करने से रोकती हैं।

Comments

क्यों नहीं jsut का उपयोग करें Activity#getWindow().getDecorView().isShown()?

— गियानलूका पी।

Answer 5

मैंने 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;
}

Comments

जैसा कि पहले उल्लेख किया गया है, यह उपयोग करने के लिए एक अच्छा विचार नहीं हो सकता है getRunningTasks()क्योंकि यह पदावनत किया गया था: androidxref.com/9.0.0_r3/xref/frameworks/base/core/java/android/…

— विटाली दिमित्री

Answer 6

एक स्थिर चर का उपयोग करने और OOP का पालन करने की तुलना में बेहतर तरीका है

Shared Preferencesactivitiesएक से दूसरे और सेवाओं के साथ चर साझा करने के लिए इस्तेमाल किया जा सकता है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();

    }
}

साझा प्राथमिकताओं का उपयोग करें। इसमें सबसे विश्वसनीय राज्य जानकारी है, कम आवेदन स्विच / मुद्दों को नष्ट, हमें अभी तक एक और अनुमति मांगने के लिए बचाता है और यह हमें यह तय करने के लिए अधिक नियंत्रण देता है कि हमारी गतिविधि वास्तव में सबसे ऊपर है। यहाँ देखें विवरण यहाँ भी पेट

Comments

धन्यवाद। लेकिन क्या आंसू की आवश्यकता है?

यह इस बात पर निर्भर करता है कि आप सक्रिय होकर क्या समझते हैं। मेरे कोड के अनुसार, गतिविधि स्टैक में है तो यह सक्रिय है। और अगर आप दृश्यमान को संभालना चाहते हैं या नहीं तो आप onResume

— Zar E Ahmer

यह तब टूट जाता है जब गतिविधि को कॉल किए बिना मार दिया जाता हैonStop()

— मार्सेल ब्रो

ऐप क्रैश होने पर क्या होता है?

— ucMedia

यह एक बहुत ही खतरनाक "समाधान" है।

— फ़िरोज़ेन

Answer 7

यह जाँचने के लिए कोड है कि क्या कोई विशेष सेवा चल रही है। मुझे पूरा यकीन है कि यह एक गतिविधि के लिए भी काम कर सकता है जब तक कि आप getRunningAppervices getRunningAppProcesses () या getRunningTasks () के साथ बदलते हैं। यहाँ एक नज़र है http://developer.android.com/reference/android/app/ActivityManager.html#getRunningAppProcesses ()

तदनुसार स्थिरांक। बैकएज और स्थिरांक बदलें। 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;

}

Comments

लेकिन ध्यान रखें कि आप जो लिंक देते हैं, वह बताता है "यह विधि केवल डिबगिंग या उपयोगकर्ता-सामना करने की प्रक्रिया प्रबंधन UI बनाने के लिए है।"

— joe_deniable

getRunningTasks अब हटा दिया गया है।

— आदि

Answer 8

उपरोक्त सभी चीजों की तुलना में बहुत आसान तरीका है और इस दृष्टिकोण android.permission.GET_TASKSको प्रकट में उपयोग करने की आवश्यकता नहीं है , या स्वीकृत उत्तर में दौड़ की स्थिति या मेमोरी लीक का मुद्दा है।

1. मुख्य गतिविधि में एक स्टेटिक वैरिएबल बनाएं। स्टेटिक अन्य गतिविधियों को किसी अन्य गतिविधि से डेटा प्राप्त करने की अनुमति देता है। onPause()इस चर को गलत सेट करें , onResumeऔर onCreate()इस चर को सही सेट करें ।

   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
   }

Comments

क्या आप कह रहे हैं कि कच्चे सार्वजनिक स्थैतिक चर का उपयोग करने की तुलना में एक्सेसर विधियों का उपयोग करना बेहतर है?

— इगोरगानापोलस्की

जावा में अपने चर को निजी रखने के लिए बसने और गेटर्स का उपयोग करना बेहतर है। हालांकि, मेरा मानना ​​है कि एंड्रॉइड में सार्वजनिक चर को सीधे एक्सेस करना आम है ...

— स्टीफन

इसका कोई मतलब नहीं है कि एक सार्वजनिक सेटर होना चाहिए क्योंकि गतिविधि राज्य को केवल गतिविधि द्वारा ही नियंत्रित किया जाना चाहिए। आपको जावा नामकरण परंपराओं के साथ रहना चाहिए: isActivityOpen एक सही गेटर विधि होगी। अगर बूलियन == सच बेमानी है का उपयोग करना। इसके अलावा, राज्य प्रबंधन को गतिविधि को सौंपना सबसे अच्छा तरीका है।

— लिसेंड्रो

यही कारण है कि यू को आपके पाठ्यक्रमों में अधिक परिश्रम के साथ भाग लेना चाहिए @coolcool;)

— जेरेक थिस

और क्या होगा अगर आपके पास गतिविधि के कई उदाहरण हैं?

— nicmartens1980

Answer 9

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

आधिकारिक डॉक्स से:

गतिविधि # isFinishing ()

यह देखने के लिए जांचें कि क्या यह गतिविधि परिष्करण की प्रक्रिया में है, या तो क्योंकि आपने इस पर फिनिश () कहा है या किसी और ने अनुरोध किया है कि यह समाप्त हो गया है। यह अक्सर ऑनपॉज़ () में निर्धारित करने के लिए उपयोग किया जाता है कि गतिविधि बस रुक रही है या पूरी तरह से खत्म हो रही है।

गतिविधि # isDestroyed ()

यदि गतिविधि पर अंतिम onDestroy () कॉल किया गया है, तो यह सच है, इसलिए यह उदाहरण अब मृत है।

Answer 10

धन्यवाद कुकुड़ी! मैं एक गतिविधि के लिए काम करने के लिए आपके उत्तर को अनुकूलित करने में सक्षम था ... यहाँ मेरे ऐप में क्या काम किया गया है ..

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

यदि उपयोगकर्ता उपयोगकर्ता क्या कर रहा है, तो यह उदाहरण आपको सही या गलत देगा। इसलिए यदि आपके द्वारा की जा रही गतिविधि प्रदर्शित नहीं हो रही है (अर्थात ऑनपॉज़ है) तो आपको मैच नहीं मिलेगा। इसके अलावा, ऐसा करने के लिए आपको अपने प्रकट होने की अनुमति को जोड़ना होगा।

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

मुझे आशा है कि यह मददगार था!

Comments

यह उपयोग-अनुमति एपीआई स्तर 21 में विकसित की गई थी

— लड़के पश्चिम

शीर्ष गतिविधि (सेवाओं [i .topActivity) तक पहुँचने के लिए एंसर्स आरब्यूसे को डाउनवोट करें। हम एपीआई स्तर Q को छोड़ देते हैं।

— देबाशीष घोष

Answer 11

मुझे लगता है कि स्वीकृत उत्तर इसे संभालने का एक भयानक तरीका है।

मुझे नहीं पता कि उपयोग का मामला क्या है, लेकिन कृपया बेस क्लास में एक संरक्षित विधि पर विचार करें

@protected
void doSomething() {
}

और इसे व्युत्पन्न वर्ग में ओवरराइड किया।

जब घटना होती है, तो बस बेस क्लास में इस विधि को कॉल करें। सही 'सक्रिय' वर्ग तो इसे संभाल लेगा। वर्ग स्वयं जांच कर सकता है कि क्या यह नहीं है Paused()।

बेहतर अभी तक, GreenRobot , Square's जैसी एक इवेंट बस का उपयोग करें , लेकिन यह कि एक पदावनत है और RxJava का उपयोग करने का सुझाव देता है

Answer 12

मैंने एक चेक का उपयोग किया if (!a.isFinishing())और यह मुझे लगता है कि मुझे क्या चाहिए। aगतिविधि उदाहरण है। क्या यह गलत है? किसी ने यह कोशिश क्यों नहीं की?

Answer 13

किस बारे में activity.isFinishing()

Comments

यह एक अच्छा समाधान कारण नहीं है। अगर कोई गतिविधि हत्या की प्रक्रिया में है, तो इंगित करें।

— वेलोसिटीपुलसे

Answer 14

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

एप्लिकेशन वर्ग बढ़ाएँ और Android मैनिफ़ेस्ट फ़ाइल में अपना संदर्भ प्रदान करें:

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

Answer 15

यकीन नहीं है कि यह "चीजों को करने" का एक "उचित" तरीका है।
यदि आपके (या क) प्रश्न को हल करने के लिए कोई एपीआई तरीका नहीं है, तो आपको थोड़ा सोचना चाहिए, हो सकता है कि आप कुछ गलत कर रहे हों और इसके बजाय अधिक डॉक्स पढ़ें आदि
(जैसा कि मैंने समझा कि स्थिर चर एंड्रॉइड में आमतौर पर गलत तरीका है।) यह काम कर सकता है, लेकिन निश्चित रूप से ऐसे मामले होंगे जब यह काम नहीं करेगा (उदाहरण के लिए, उत्पादन में, मिलियन उपकरणों पर)।
आपके मामले में सटीक रूप से मैं सोचने का सुझाव देता हूं कि आपको यह जानने की आवश्यकता क्यों है कि क्या कोई अन्य गतिविधि जीवित है? .. आप इसकी कार्यक्षमता प्राप्त करने के लिए परिणाम के लिए एक और गतिविधि शुरू कर सकते हैं। या फिर आप इसकी कार्यक्षमता और इसी तरह से इसे प्राप्त करने के लिए कक्षा को प्राप्त कर सकते हैं।
सादर।

Answer 16

यदि आप गतिविधि के विशिष्ट उदाहरण के जीवनचक्र की स्थिति में रुचि रखते हैं, तो सिलिकॉनइल का समाधान सही दिखता है सिवाय इसके कि नया "सक्रिय" चर स्थिर होने के बजाय एक उदाहरण चर होना चाहिए।

Answer 17

एक आदेशित प्रसारण का उपयोग करें। Http://android-developers.blogspot.nl/2011/01/processing-ordered-broadcasts.html देखें

अपनी गतिविधि में, ऑनस्टार्ट में एक रिसीवर पंजीकृत करें, ऑनटॉप में अपंजीकृत। अब जब उदाहरण के लिए किसी सेवा को कुछ ऐसा करने की आवश्यकता होती है जिसे गतिविधि बेहतर ढंग से करने में सक्षम हो, तो सेवा से एक आदेशित प्रसारण भेजें (सेवा में एक डिफ़ॉल्ट हैंडलर के साथ)। जब आप चल रहे हैं तो आप गतिविधि में प्रतिक्रिया दे सकते हैं। सेवा परिणाम डेटा की जांच कर सकती है कि प्रसारण को संभाला गया है या नहीं, और यदि उचित कार्रवाई नहीं की गई है।

Answer 18

स्वीकृत उत्तर के अलावा , यदि आपके पास गतिविधि के कई उदाहरण हैं, तो आप इसके बजाय एक काउंटर का उपयोग कर सकते हैं:

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

Comments

रिटर्न लाइन में "s" और "; (अर्ध उपनिवेश)" गायब है।

— अली_देव

Answer 19

आपने कोशिश की है..

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

Answer 20

निम्न कोड के साथ एक आसान समाधान मिला

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

Answer 21

गतिविधि जीवित है या नहीं, यह जांचने के लिए isActivity चर का उपयोग करें।

private boolean activityState = true;

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

तो जाँच

if(activityState){
//add your code
}

Answer 22

यदि आप जांचना चाहते हैं कि गतिविधि बैक स्टैक में है या नहीं तो अगले चरणों का पालन करें। 1. आपके एप्लिकेशन वर्ग में एक एरियर लाईक घोषित किया गया है [एप्लीकेशन टैग में एप्लिकेशन क्लास को आपकी मुख्य फाइल में परिभाषित किया गया है]

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. आपकी बेसएक्टिविटी में, जहां सभी गतिविधियाँ इसे बढ़ाती हैं, ऑनक्रिएट और ऑनडेस्ट्रॉय विधियों को ओवरराइड करें ताकि आप निम्न स्टैक से गतिविधियों को जोड़ और हटा सकें।

   @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. अंत में यदि आप यह जांचना चाहते हैं कि गतिविधि बैक स्टैक में है या नहीं तो केवल इस फ़ंक्शन को कॉल करें ।ActivityInBackStack।

Ex: मैं जाँच करना चाहता हूँ कि होमएक्टीविटी बैक स्टैक में है या नहीं:

if (((MyApplicationClass) 
getApplication()).isActivityInBackStack(HomeActivity.class)) {
       // Activity is in the back stack
    } else {
       // Activity is not in the back stack
    }

Answer 23

public static boolean isActivityActive(Activity activity) {
    return !activity.isFinishing() &&
            (SDK_INT < JELLY_BEAN_MR1 || !activity.isDestroyed());
}

Answer 24

यह कार्य यदि आपके पास अग्रभूमि में समान गतिविधि नहीं है। यदि आप अधिसूचना से खुलते हैं तो मैं कुछ समायोजन नहीं करता हूं और इसके साथ आया हूं:

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

यह मेरे लिए एक ही समय में कई गतिविधियों के साथ काम करता है।