पृष्ठभूमि कार्य या सेवा से वर्तमान अग्रभूमि अनुप्रयोग का निर्धारण

Question

मेरी इच्छा है कि पृष्ठभूमि में चलने वाला एक अनुप्रयोग हो, जो जानता हो कि कब कोई अंतर्निहित एप्लिकेशन (संदेश, संपर्क आदि) चल रहा है।

तो मेरे सवाल हैं:

1. मुझे पृष्ठभूमि में अपना आवेदन कैसे चलाना चाहिए।

2. मेरा बैकग्राउंड एप्लिकेशन कैसे जान सकता है कि वर्तमान में अग्रभूमि में चल रहा एप्लिकेशन क्या है।

अनुभव वाले लोगों की प्रतिक्रियाओं की बहुत सराहना की जाएगी।

Comments

मुझे नहीं लगता कि आपने जो करने की कोशिश की है उसका पर्याप्त विवरण दिया है। आपका बैकग्राउंड एप्लिकेशन क्या करने की कोशिश कर रहा है? किन तरीकों से उपयोगकर्ता के साथ बातचीत करने में सक्षम होना चाहिए? क्यों आप को पता है वर्तमान अग्रभूमि एप्लिकेशन क्या है की जरूरत है? आदि

— चार्ल्स डफी

codingaffairs.blogspot.com/2016/05/…

— विकासशील

अग्रभूमि ऐप का पता लगाने के लिए, आप github.com/ricvalerio/foregroundappchecker

— rvalerio

Answer 1

के संबंध में "2. मेरा बैकग्राउंड एप्लिकेशन कैसे जान सकता है कि वर्तमान में अग्रभूमि में चल रहा एप्लिकेशन क्या है।"

इस getRunningAppProcesses()पद्धति का उपयोग न करें क्योंकि यह मेरे अनुभव से सभी प्रकार के सिस्टम को बकवास करता है और आपको कई परिणाम मिलेंगे RunningAppProcessInfo.IMPORTANCE_FOREGROUND। getRunningTasks()इसके बजाय उपयोग करें

यह वर्तमान अग्रभूमि अनुप्रयोग की पहचान करने के लिए मेरी सेवा में उपयोग किया जाने वाला कोड है, यह वास्तव में आसान है:

ActivityManager am = (ActivityManager) AppService.this.getSystemService(ACTIVITY_SERVICE);
// The first in the list of RunningTasks is always the foreground task.
RunningTaskInfo foregroundTaskInfo = am.getRunningTasks(1).get(0);

Thats यह है, तो आप आसानी से अग्रभूमि एप्लिकेशन / गतिविधि के विवरण का उपयोग कर सकते हैं:

String foregroundTaskPackageName = foregroundTaskInfo .topActivity.getPackageName();
PackageManager pm = AppService.this.getPackageManager();
PackageInfo foregroundAppPackageInfo = pm.getPackageInfo(foregroundTaskPackageName, 0);
String foregroundTaskAppName = foregroundAppPackageInfo.applicationInfo.loadLabel(pm).toString();

यह गतिविधि में एक अतिरिक्त अनुमति की आवश्यकता है और पूरी तरह से काम करता है।

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

Comments

इसे सही उत्तर के रूप में चिह्नित किया जाना चाहिए। आवश्यक अनुमति: android.permission.GET_TASKS अन्य तरीकों से केवल बहुत ही मामूली है जो इससे बच सकता है।

— ब्रैंडल

इस संस्करण को संपादित करें: ध्यान दें: यह विधि केवल डिबगिंग और कार्य प्रबंधन उपयोगकर्ता इंटरफ़ेस प्रस्तुत करने के लिए है। <- अभी जावा डॉट में देखा गया है। तो भविष्य में बिना सूचना के यह तरीका बदल सकता है।

— ब्रांडल

नोट: getRunningTasks()एपीआई 21 (लॉलीपॉप) - डेवलपर.

— android.com/reference/android/app/…

@ डिटलर, ठीक है फिर। क्या इसके बजाय कोई और तरीका है? हालाँकि Google नहीं चाहता है कि तृतीय-पक्ष एप्लिकेशन संवेदनशील जानकारी प्राप्त करें, मेरे पास डिवाइस की प्लेटफ़ॉर्म कुंजी है। अगर मेरे पास सिस्टम विशेषाधिकार है तो क्या कोई और तरीका है?

— युंग

21 में पेश किए गए "यूज़ स्टैटिस्टिक्स एपी" का एक तरीका है

— कुणाल

Answer 2

मुझे सही उपाय का पता लगाना था। नीचे दिए गए कोड cyanogenMod7 (टैबलेट tweaks) का हिस्सा है और Android 2.3.3 / जिंजरब्रेड पर परीक्षण किया गया है।

विधि:

• getForegroundApp - अग्रभूमि आवेदन लौटाता है।
• getActivityForApp - पाया गया ऐप की गतिविधि लौटाता है।
• isStillActive - यह निर्धारित करता है कि पहले पाया गया ऐप अभी भी सक्रिय ऐप है या नहीं।
• isRunningService - getForegroundApp के लिए एक सहायक फ़ंक्शन

यह उम्मीद है कि सभी विस्तार में इस मुद्दे का जवाब:

private RunningAppProcessInfo getForegroundApp() {
    RunningAppProcessInfo result=null, info=null;

    if(mActivityManager==null)
        mActivityManager = (ActivityManager)mContext.getSystemService(Context.ACTIVITY_SERVICE);
    List <RunningAppProcessInfo> l = mActivityManager.getRunningAppProcesses();
    Iterator <RunningAppProcessInfo> i = l.iterator();
    while(i.hasNext()){
        info = i.next();
        if(info.importance == RunningAppProcessInfo.IMPORTANCE_FOREGROUND
                && !isRunningService(info.processName)){
            result=info;
            break;
        }
    }
    return result;
}

private ComponentName getActivityForApp(RunningAppProcessInfo target){
    ComponentName result=null;
    ActivityManager.RunningTaskInfo info;

    if(target==null)
        return null;

    if(mActivityManager==null)
        mActivityManager = (ActivityManager)mContext.getSystemService(Context.ACTIVITY_SERVICE);
    List <ActivityManager.RunningTaskInfo> l = mActivityManager.getRunningTasks(9999);
    Iterator <ActivityManager.RunningTaskInfo> i = l.iterator();

    while(i.hasNext()){
        info=i.next();
        if(info.baseActivity.getPackageName().equals(target.processName)){
            result=info.topActivity;
            break;
        }
    }

    return result;
}

private boolean isStillActive(RunningAppProcessInfo process, ComponentName activity)
{
    // activity can be null in cases, where one app starts another. for example, astro
    // starting rock player when a move file was clicked. we dont have an activity then,
    // but the package exits as soon as back is hit. so we can ignore the activity
    // in this case
    if(process==null)
        return false;

    RunningAppProcessInfo currentFg=getForegroundApp();
    ComponentName currentActivity=getActivityForApp(currentFg);

    if(currentFg!=null && currentFg.processName.equals(process.processName) &&
            (activity==null || currentActivity.compareTo(activity)==0))
        return true;

    Slog.i(TAG, "isStillActive returns false - CallerProcess: " + process.processName + " CurrentProcess: "
            + (currentFg==null ? "null" : currentFg.processName) + " CallerActivity:" + (activity==null ? "null" : activity.toString())
            + " CurrentActivity: " + (currentActivity==null ? "null" : currentActivity.toString()));
    return false;
}

private boolean isRunningService(String processname){
    if(processname==null || processname.isEmpty())
        return false;

    RunningServiceInfo service;

    if(mActivityManager==null)
        mActivityManager = (ActivityManager)mContext.getSystemService(Context.ACTIVITY_SERVICE);
    List <RunningServiceInfo> l = mActivityManager.getRunningServices(9999);
    Iterator <RunningServiceInfo> i = l.iterator();
    while(i.hasNext()){
        service = i.next();
        if(service.process.equals(processname))
            return true;
    }

    return false;
}

Comments

यदि आप मुझसे यह पूछने में कोई आपत्ति नहीं करते हैं, तो आपको यह देखने की विधियों की आवश्यकता है कि क्या यह सेवा चला रहा है, अभी भी सक्रिय है, और केवल अग्रभूमि अनुप्रयोग प्राप्त करने के लिए गतिविधि प्राप्त करने के लिए?

क्षमा करें, लेकिन यह काम नहीं कर रहा है। कुछ ऐप्स को बिना किसी कारण के फ़िल्टर किया जाता है, मुझे लगता है कि जब वे कुछ सेवा चलाते हैं। तो .RunningService उन्हें बाहर निकाल रहा है।

— seb

दुर्भाग्य से, एंड्रॉइड एल (एपीआई 20) के बाद से getRunningTasks () को हटा दिया गया है। एल के रूप में, यह विधि अब तीसरे पक्ष के अनुप्रयोगों के लिए उपलब्ध नहीं है: दस्तावेज़-केंद्रित रिकेट्स की शुरूआत का अर्थ है कि यह व्यक्ति की जानकारी कॉलर को लीक कर सकता है। पीछे की संगतता के लिए, यह अभी भी अपने डेटा का एक छोटा सबसेट लौटाएगा: कम से कम कॉलर के स्वयं के कार्य, और संभवतः घर जैसे कुछ अन्य कार्य जो संवेदनशील नहीं होने के लिए जाने जाते हैं।

— सैम लू

किसी को पता है कि यह दृष्टिकोण बस करने से बेहतर कैसे है mActivityManager.getRunningTasks(1).get(0).topActivity?

— सैम

Answer 3

निम्नलिखित कोड का प्रयास करें:

ActivityManager activityManager = (ActivityManager) newContext.getSystemService( Context.ACTIVITY_SERVICE );
List<RunningAppProcessInfo> appProcesses = activityManager.getRunningAppProcesses();
for(RunningAppProcessInfo appProcess : appProcesses){
    if(appProcess.importance == RunningAppProcessInfo.IMPORTANCE_FOREGROUND){
        Log.i("Foreground App", appProcess.processName);
    }
}

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

हम उम्मीद करते है कि यह आपके सवाल का जवाब दे देगा।

Comments

Android संस्करण L पर से, यह एकमात्र समाधान है जो अन्य समाधानों में उपयोग की जाने वाली विधियों के रूप में काम करता है।

— androidGuy

हालाँकि, यह काम नहीं कर रहा है कि ऐप अग्रभूमि में है और स्क्रीन लॉक है

— Krit

सही उत्तर पर टिक करना चाहिए

— A_rmas

क्या इसे स्वीकृत उत्तर की तरह अतिरिक्त अनुमति की आवश्यकता है?

— wonsuc

यह काफी सही नहीं है। एक प्रक्रिया का नाम हमेशा संबंधित ऐप पैकेज नाम के समान नहीं होता है।

— सैम

Answer 4

लॉलीपॉप के बाद से यह बदल गया। कृपया नीचे दिए गए कोड को देखें, इससे पहले कि उपयोगकर्ता को सेटिंग्स -> सुरक्षा -> (स्क्रॉल डाउन टू लास्ट) उपयोग एक्सेस वाले ऐप्स -> हमारे ऐप को अनुमति दें

private void printForegroundTask() {
    String currentApp = "NULL";
    if(android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.LOLLIPOP) {
        UsageStatsManager usm = (UsageStatsManager) this.getSystemService(Context.USAGE_STATS_SERVICE);
        long time = System.currentTimeMillis();
        List<UsageStats> appList = usm.queryUsageStats(UsageStatsManager.INTERVAL_DAILY,  time - 1000*1000, time);
        if (appList != null && appList.size() > 0) {
            SortedMap<Long, UsageStats> mySortedMap = new TreeMap<Long, UsageStats>();
            for (UsageStats usageStats : appList) {
                mySortedMap.put(usageStats.getLastTimeUsed(), usageStats);
            }
            if (mySortedMap != null && !mySortedMap.isEmpty()) {
                currentApp = mySortedMap.get(mySortedMap.lastKey()).getPackageName();
            }
        }
    } else {
        ActivityManager am = (ActivityManager)this.getSystemService(Context.ACTIVITY_SERVICE);
        List<ActivityManager.RunningAppProcessInfo> tasks = am.getRunningAppProcesses();
        currentApp = tasks.get(0).processName;
    }

    Log.e(TAG, "Current App in foreground is: " + currentApp);
}

Comments

कठबोली इस उपयोग के आँकड़े प्रोग्रामेटिक रूप से सेट किए जाने चाहिए?

— रग्म

@rubmz क्या आपको इस पर कोई समाधान मिला है?

— VVB

एंड्रॉइड 5.1 के साथ मेरे

— डोगी में

यह 100% सटीक परिणाम नहीं देता है ... यह ज्यादातर समय सही है

— कैमहार्ट

यह अंतिम ऐप को अग्रभूमि में नहीं दिखाएगा, लेकिन हो सकता है कि अंतिम "उपयोग किया गया" एक तरह से - यदि आप एक गतिविधि छोड़ते हैं और किसी अन्य पर जाते हैं, तो ऊपर से लॉन्चर मेनू खींचें, और इसे जारी करें, आप "में" होंगे गलत "गतिविधि जब तक आप एक दूसरे के पास नहीं जाते। इससे कोई फर्क नहीं पड़ता कि आप स्क्रीन स्क्रॉल करते हैं या नहीं, यह गलत गतिविधि की रिपोर्ट करता है जब तक कि आप एक और लॉन्च नहीं करते।

— अज़ुरलेक

Answer 5

ऐसे मामलों के लिए जब हमें अपनी सेवा / बैकग्राउंड-थ्रेड से जांचने की आवश्यकता होती है कि हमारा ऐप अग्रभूमि में है या नहीं। मैंने इसे कैसे लागू किया, और यह मेरे लिए ठीक काम करता है:

public class TestApplication extends Application implements Application.ActivityLifecycleCallbacks {

    public static WeakReference<Activity> foregroundActivityRef = null;

    @Override
    public void onActivityStarted(Activity activity) {
        foregroundActivityRef = new WeakReference<>(activity);
    }

    @Override
    public void onActivityStopped(Activity activity) {
        if (foregroundActivityRef != null && foregroundActivityRef.get() == activity) {
            foregroundActivityRef = null;
        }
    }

    // IMPLEMENT OTHER CALLBACK METHODS
}

अब अन्य वर्गों से जाँच करने के लिए कि क्या ऐप अग्रभूमि में है या नहीं, बस कॉल करें:

if(TestApplication.foregroundActivityRef!=null){
    // APP IS IN FOREGROUND!
    // We can also get the activity that is currently visible!
}

अपडेट (जैसा कि SHS द्वारा बताया गया है ):

अपने आवेदन वर्ग की onCreateविधि में कॉलबैक के लिए पंजीकरण करना न भूलें ।

@Override
public void onCreate() {
    ...
    registerActivityLifecycleCallbacks(this);
}

Comments

यही कारण है कि मैं पिछले दो घंटों से देख रहा हूं। धन्यवाद! :)

— ४

हमें "registerActivityLifecycleCallbacks (यह);" ओवरराइड विधि "onCreate ()" अनुप्रयोग वर्ग (TestApplication) के अंदर। यह हमारी एप्लिकेशन क्लास में कॉलबैक शुरू करेगा।

— SHS

@SarthakMittal, यदि कोई उपकरण स्टैंडबाय मोड में चला जाता है या जब हम इसे लॉक करते हैं, तो onActivityStontin () कहा जाएगा। आपके कोड के आधार पर, यह इंगित करेगा कि एप्लिकेशन पृष्ठभूमि में है। लेकिन यह वास्तव में अग्रभूमि में है।

— बजे अयाज अलिफोव सेप

@AyazAlifov यदि फोन स्टैंडबाय पर है या फोन लॉक है, तो मैं इसे अग्रभूमि में नहीं मानूंगा, लेकिन फिर से यह वरीयता पर निर्भर करता है।

— सार्थक मित्तल

Answer 6

अग्रभूमि अनुप्रयोग का निर्धारण करने के लिए, आप अग्रभूमि ऐप का पता लगाने के लिए उपयोग कर सकते हैं, आप https://github.com/ricvalerio/foregroundappchecker का उपयोग कर सकते हैं । यह डिवाइस के एंड्रॉइड वर्जन के आधार पर विभिन्न तरीकों का उपयोग करता है।

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

Comments

उत्तम!! एंड्रॉइड 7 पर परीक्षण किया गया

— प्रतीक टैंक

बहुत बहुत धन्यवाद। यह एकमात्र उत्तर है जिसने उन समस्याओं को हल किया है जो हम ऐप्स की सूचनाओं के साथ सामना कर रहे थे। जब कोई नोटिफिकेशन पॉप अप होता है, तो अन्य सभी उत्तर नोटिफिकेशन भेजने वाले ऐप का पैकेज नाम वापस दे देंगे। आपके लॉलीपॉपडेक्टर ने इस मुद्दे को हल किया। एक संकेत: एपीआई 29 से, MOVE_TO_FOREGROUND का उपयोग UseEvents.Event में किया गया है, इसलिए Android Q से बाद में किसी को ACTIVITY_RESUMED का उपयोग करना चाहिए। तब यह एक आकर्षण की तरह काम करेगा!

— जोर्न रिग्टर

Answer 7

ध्यान में रखा getRunningTasks()गया है और getRunningAppProcesses()विश्वसनीय नहीं है, यह ध्यान में रखते हुए , मैं StackOverflow में उल्लिखित 2 दृष्टिकोणों को संयोजित करने का निर्णय लेने आया:

   private boolean isAppInForeground(Context context)
    {
        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.LOLLIPOP)
        {
            ActivityManager am = (ActivityManager) context.getSystemService(ACTIVITY_SERVICE);
            ActivityManager.RunningTaskInfo foregroundTaskInfo = am.getRunningTasks(1).get(0);
            String foregroundTaskPackageName = foregroundTaskInfo.topActivity.getPackageName();

            return foregroundTaskPackageName.toLowerCase().equals(context.getPackageName().toLowerCase());
        }
        else
        {
            ActivityManager.RunningAppProcessInfo appProcessInfo = new ActivityManager.RunningAppProcessInfo();
            ActivityManager.getMyMemoryState(appProcessInfo);
            if (appProcessInfo.importance == IMPORTANCE_FOREGROUND || appProcessInfo.importance == IMPORTANCE_VISIBLE)
            {
                return true;
            }

            KeyguardManager km = (KeyguardManager) context.getSystemService(Context.KEYGUARD_SERVICE);
            // App is foreground, but screen is locked, so show notification
            return km.inKeyguardRestrictedInputMode();
        }
    }

Comments

आपको प्रकट अनुमति को जोड़ने के लिए उल्लेख करने की आवश्यकता है <उपयोग-अनुमति एंड्रॉइड: नाम = "android.permission.GET_TASKS" /> अन्यथा ऐप क्रैश हो जाएगा

— RJFares

android.permission.GET_TASKS - वर्तमान में प्ले स्टोर

— ड्यूना

Answer 8

ActivityManager वर्ग जो प्रक्रियाओं चल रहे हैं देखने के लिए उचित उपकरण है।

पृष्ठभूमि में चलाने के लिए, आप आमतौर पर एक सेवा का उपयोग करना चाहते हैं ।

Answer 9

इसने मेरे लिए काम किया। लेकिन यह केवल मुख्य मेनू नाम देता है। यदि उपयोगकर्ता ने सेटिंग्स -> ब्लूटूथ -> डिवाइस नाम स्क्रीन खोल दी है, तो RunAppProcessInfo इसे सिर्फ सेटिंग्स के रूप में कहता है। फर्राटेदार ड्रिल करने में सक्षम नहीं

ActivityManager activityManager = (ActivityManager) context.getSystemService( Context.ACTIVITY_SERVICE );
                PackageManager pm = context.getPackageManager();
                List<RunningAppProcessInfo> appProcesses = activityManager.getRunningAppProcesses();
                for(RunningAppProcessInfo appProcess : appProcesses) {              
                    if(appProcess.importance == RunningAppProcessInfo.IMPORTANCE_FOREGROUND) {
                        CharSequence c = pm.getApplicationLabel(pm.getApplicationInfo(appProcess.processName, PackageManager.GET_META_DATA));
                        Log.i("Foreground App", "package: " + appProcess.processName + " App: " + c.toString());
                    }               
                }

Comments

मुझे लगता है कि यह केवल तभी काम करता है जब आपका अपना ऐप अग्रभूमि में चल रहा हो। यह कुछ भी रिपोर्ट नहीं करता है जब कोई अन्य ऐप अग्रभूमि पर है।

— एलिस वान डेर लैंड

Answer 10

कुछ इस तरह से करें:

int showLimit = 20;

/* Get all Tasks available (with limit set). */
ActivityManager mgr = (ActivityManager) getSystemService(Context.ACTIVITY_SERVICE);
List<ActivityManager.RunningTaskInfo> allTasks = mgr.getRunningTasks(showLimit);
/* Loop through all tasks returned. */
for (ActivityManager.RunningTaskInfo aTask : allTasks) 
{                  
    Log.i("MyApp", "Task: " + aTask.baseActivity.getClassName()); 
    if (aTask.baseActivity.getClassName().equals("com.android.email.activity.MessageList")) 
        running=true;
}

Comments

Google संभवतः एक ऐप को अस्वीकार कर देगा जो ActivManager.getRunningTasks () का उपयोग करता है। प्रलेखन में कहा गया है कि यह केवल शत्रु उद्देश्य है: developer.android.com/reference/android/app/…।

— अंतरंग

@ForceMagic - Google केवल अविश्वसनीय API का उपयोग करने के लिए ऐप्स को अस्वीकार नहीं करता है ; इसके अलावा, Google Android अनुप्रयोगों के लिए एकमात्र वितरण चैनल नहीं है। उस ने कहा, यह ध्यान में रखने योग्य है कि इस एपीआई की जानकारी भरोसेमंद नहीं है।

— क्रिस स्ट्रैटन

@ChrisStratton दिलचस्प है, लेकिन आप शायद सही हैं, हालांकि इसे कोर लॉजिक के लिए इस्तेमाल करने के लिए हतोत्साहित किया जाता है, क्योंकि उन्होंने ऐप को अस्वीकार कर दिया है। आप टिप्पणी लिंक से आकाश केल्सी को चेतावनी देना चाह सकते हैं।

— ForceMagic

"getRunningTasks" एपी 21and से आगे के लिए काम करता है, इसलिए इसे LOLLIPOP के लिए काम करने के लिए एक और तरीका निकालने का अच्छा विचार हो सकता है (मैं खुद havent इस बारे में खुद को पता चला है :()

— amit

Answer 11

लॉलीपॉप में और ऊपर:

Mainfest में जोड़ें:

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

और कुछ इस तरह से करें:

if( mTaskId < 0 )
{
    List<AppTask> tasks = mActivityManager.getAppTasks(); 
    if( tasks.size() > 0 )
        mTaskId = tasks.get( 0 ).getTaskInfo().id;
}

Comments

इसे

— मार्शमैलो

Answer 12

यदि मेरा ऐप अग्रभूमि में है तो मैं यह देख रहा हूं। नोट मैं आधिकारिक Android द्वारा सुझाए गए AsyncTask का उपयोग कर रहा हूं प्रलेखन

`

    private class CheckIfForeground extends AsyncTask<Void, Void, Void> {
    @Override
    protected Void doInBackground(Void... voids) {

        ActivityManager activityManager = (ActivityManager) mContext.getSystemService(Context.ACTIVITY_SERVICE);
        List<ActivityManager.RunningAppProcessInfo> appProcesses = activityManager.getRunningAppProcesses();
        for (ActivityManager.RunningAppProcessInfo appProcess : appProcesses) {
            if (appProcess.importance == ActivityManager.RunningAppProcessInfo.IMPORTANCE_FOREGROUND) {
                Log.i("Foreground App", appProcess.processName);

                if (mContext.getPackageName().equalsIgnoreCase(appProcess.processName)) {
                    Log.i(Constants.TAG, "foreground true:" + appProcess.processName);
                    foreground = true;
                    // close_app();
                }
            }
        }
        Log.d(Constants.TAG, "foreground value:" + foreground);
        if (foreground) {
            foreground = false;
            close_app();
            Log.i(Constants.TAG, "Close App and start Activity:");

        } else {
            //if not foreground
            close_app();
            foreground = false;
            Log.i(Constants.TAG, "Close App");

        }

        return null;
    }
}

और AsyncTask को इस तरह निष्पादित करें। new CheckIfForeground().execute();

Comments

क्या आपके पास इसके लिए लिंक है?

— user1743524

Answer 13

मैंने एक विधि में दो समाधानों को संयोजित किया और यह मेरे लिए एपीआई 24 और एपीआई 21 के लिए काम करता है। अन्य मैंने परीक्षण नहीं किया।

कोटलिन में कोड:

private fun isAppInForeground(context: Context): Boolean {
    val appProcessInfo = ActivityManager.RunningAppProcessInfo()
    ActivityManager.getMyMemoryState(appProcessInfo)
    if (appProcessInfo.importance == IMPORTANCE_FOREGROUND ||
            appProcessInfo.importance == IMPORTANCE_VISIBLE) {
        return true
    } else if (appProcessInfo.importance == IMPORTANCE_TOP_SLEEPING ||
            appProcessInfo.importance == IMPORTANCE_BACKGROUND) {
        return false
    }

    val am = context.getSystemService(Context.ACTIVITY_SERVICE) as ActivityManager
    val foregroundTaskInfo = am.getRunningTasks(1)[0]
    val foregroundTaskPackageName = foregroundTaskInfo.topActivity.packageName
    return foregroundTaskPackageName.toLowerCase() == context.packageName.toLowerCase()
}

और मेनिफेस्ट में

<!-- Check whether app in background or foreground -->
<uses-permission android:name="android.permission.GET_TASKS" />