Bir arka plan görevinden veya hizmetinden mevcut ön plan uygulamasını belirleme

Arka planda çalışan ve yerleşik uygulamalardan herhangi birinin (mesajlaşma, kişiler, vb.) Ne zaman çalıştığını bilen bir uygulamaya sahip olmak istiyorum.

Yani sorularım:

1. Uygulamamı arka planda nasıl çalıştırmalıyım.

2. Arka plan uygulamam, o anda ön planda çalışan uygulamanın ne olduğunu nasıl anlayabilir?

Tecrübeli kişilerden gelen yanıtlar çok takdir edilecektir.

"2. Arka plan uygulamam, o anda ön planda çalışan uygulamanın ne olduğunu nasıl bilebilir?"

getRunningAppProcesses()Yöntemi KULLANMAYIN çünkü bu benim deneyimlerime göre her türlü sistem çöpünü döndürür ve birden fazla sonuç alırsınız RunningAppProcessInfo.IMPORTANCE_FOREGROUND. getRunningTasks()Bunun yerine kullanın

Bu, mevcut ön plan uygulamasını tanımlamak için hizmetimde kullandığım kod, gerçekten çok kolay:

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

İşte bu, daha sonra ön plan uygulamasının / etkinliğinin ayrıntılarına kolayca erişebilirsiniz:

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

Bu, etkinlik menüsünde ek bir izin gerektirir ve mükemmel çalışır.

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

Doğru çözümü zor yoldan bulmalıydım. Aşağıdaki kod cyanogenmod7'nin (tablet ince ayarları) bir parçasıdır ve android 2.3.3 / gingerbread üzerinde test edilmiştir.

yöntemleri:

• getForegroundApp - ön plan uygulamasını döndürür.
• getActivityForApp - bulunan uygulamanın etkinliğini döndürür.
• isStillActive - daha önce bulunan bir uygulamanın hala etkin uygulama olup olmadığını belirler.
• isRunningService - getForegroundApp için bir yardımcı işlev

umarım bu sorunu her yönden yanıtlar (:

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

Aşağıdaki kodu deneyin:

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

İşlem adı, ön planda çalışan uygulamanın paket adıdır. Bunu uygulamanızın paket adıyla karşılaştırın. Eğer aynıysa uygulamanız ön planda çalışıyor demektir.

Umarım bu, sorunuzu yanıtlamıştır.

Lolipoptan itibaren bu değişti. Lütfen aşağıdaki kodu bulun, bu kullanıcının Ayarlar -> Güvenlik -> (En sona kaydır) Kullanım erişimi olan uygulamalar -> Uygulamamıza izinler verin

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

Uygulamamızın ön planda olup olmadığını kendi hizmetimizden / arka plan iş parçacığından kontrol etmemiz gereken durumlar için. Bunu nasıl uyguladım ve benim için iyi çalışıyor:

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
}

Şimdi, uygulamanın ön planda olup olmadığını diğer sınıflardan kontrol etmek için şunu arayın:

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

Güncelleme ( SHS tarafından belirtildiği gibi ):

Uygulama sınıfınızın onCreateyönteminde geri aramalar için kaydolmayı unutmayın .

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

Ön plan uygulamasını belirlemek için ön plan uygulamasını tespit etmek için kullanabilir, https://github.com/ricvalerio/foregroundappchecker kullanabilirsiniz . Cihazın android sürümüne bağlı olarak farklı yöntemler kullanır.

Hizmete gelince, repo da bunun için ihtiyacınız olan kodu sağlar. Esasen, android stüdyosunun hizmeti sizin için oluşturmasına izin verin ve ardından onCreate appChecker'ı kullanan parçacığı ekleyin. Ancak izin istemeniz gerekecek.

Kullanımdan getRunningTasks()kaldırıldığını ve getRunningAppProcesses()güvenilir olmadığını göz önünde bulundurarak , StackOverflow'da belirtilen 2 yaklaşımı birleştirmeye karar verdim:

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

ActivityManager sınıf süreçleri çalıştıran görmek için uygun bir araçtır.

Arka planda çalışmak için, genellikle bir Hizmet kullanmak istersiniz .

Bu benim için çalıştı. Ancak yalnızca ana menü adını verir. Yani, kullanıcı Ayarlar -> Bluetooth -> Cihaz Adı ​​ekranını açtıysa, RunningAppProcessInfo onu sadece Ayarlar olarak çağırır. Furthur'u delemiyor

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

Bunun gibi bir şey yapın:

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

Lolipopta ve üzeri:

Ana festivale ekle:

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

Ve bunun gibi bir şey yapın:

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

Uygulamamın ön planda olup olmadığını bu şekilde kontrol ediyorum. Not Resmi Android belgelerinde önerildiği gibi AsyncTask kullanıyorum.`

'

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

ve AsyncTask'ı bu şekilde çalıştırın. new CheckIfForeground().execute();

İki çözümü tek bir yöntemde birleştirdim ve benim için API 24 ve API 21 için çalışıyor. Diğerlerini test etmedim.

Kotlin'deki kod:

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

ve Manifest'te

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