Określanie bieżącej aplikacji na pierwszym planie na podstawie zadania lub usługi w tle

Chciałbym mieć jedną aplikację działającą w tle, która wie, kiedy jest uruchomiona którakolwiek z wbudowanych aplikacji (wiadomości, kontakty itp.).

Więc moje pytania to:

1. Jak uruchomić aplikację w tle.

2. Skąd moja aplikacja działająca w tle może wiedzieć, jaka aplikacja jest aktualnie uruchomiona na pierwszym planie.

Mile widziane będą odpowiedzi osób z doświadczeniem.

W odniesieniu do „2. Skąd moja aplikacja w tle może wiedzieć, jaka aplikacja jest aktualnie uruchomiona na pierwszym planie”.

NIE używaj tej getRunningAppProcesses()metody, ponieważ zwraca to wszelkiego rodzaju śmieci systemowe z mojego doświadczenia, a otrzymasz wiele wyników, które mają RunningAppProcessInfo.IMPORTANCE_FOREGROUND. Użyj getRunningTasks()zamiast tego

Oto kod, którego używam w mojej usłudze, aby zidentyfikować bieżącą aplikację na pierwszym planie, jest naprawdę łatwy:

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

To wszystko, możesz łatwo uzyskać dostęp do szczegółów aplikacji / aktywności na pierwszym planie:

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

Wymaga to dodatkowego zezwolenia w działaniu menifestu i działa doskonale.

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

Musiałem znaleźć właściwe rozwiązanie na własnej skórze. poniższy kod jest częścią cyanogenmod7 (modyfikacje tabletu) i jest testowany na Androidzie 2.3.3 / gingerbread.

metody:

• getForegroundApp - zwraca aplikację pierwszoplanową.
• getActivityForApp - zwraca aktywność znalezionej aplikacji.
• isStillActive - określa, czy wcześniej znaleziona aplikacja jest nadal aktywną aplikacją.
• isRunningService - funkcja pomocnicza dla getForegroundApp

mam nadzieję, że to rozwiąże ten problem w całym zakresie (:

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

Wypróbuj następujący kod:

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

Nazwa procesu to nazwa pakietu aplikacji działającej na pierwszym planie. Porównaj go z nazwą pakietu swojej aplikacji. Jeśli jest taki sam, oznacza to, że aplikacja działa na pierwszym planie.

Mam nadzieję, że to odpowiada na twoje pytanie.

Od Lollipopa to się zmieniło. Proszę znaleźć poniższy kod, zanim ten użytkownik będzie musiał przejść Ustawienia -> Bezpieczeństwo -> (Przewiń w dół do ostatniego) Aplikacje z dostępem do użytkowania -> Nadaj uprawnienia naszej aplikacji

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

W przypadkach, gdy musimy sprawdzić z naszej własnej usługi / wątku w tle, czy nasza aplikacja jest na pierwszym planie, czy nie. Tak to zaimplementowałem i działa dobrze:

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
}

Teraz, aby sprawdzić z innych klas, czy aplikacja jest na pierwszym planie, czy nie, po prostu zadzwoń:

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

Aktualizacja (jak wskazała SHS ):

Nie zapomnij zarejestrować się do wywołań zwrotnych w onCreatemetodzie klasy aplikacji .

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

Aby określić aplikację pierwszoplanową, której możesz użyć do wykrywania aplikacji pierwszego planu, możesz użyć https://github.com/ricvalerio/foregroundappchecker . Używa różnych metod w zależności od wersji Androida urządzenia.

Jeśli chodzi o usługę, repozytorium zapewnia również potrzebny do niej kod. Zasadniczo pozwól Android Studio stworzyć usługę za Ciebie, a następnie onCreate dodaj fragment kodu korzystający z appChecker. Będziesz jednak musiał poprosić o pozwolenie.

Biorąc pod uwagę, że getRunningTasks()jest to przestarzałe i getRunningAppProcesses()nie jest wiarygodne, zdecydowałem się połączyć 2 podejścia wymienione w StackOverflow:

   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 klasa jest odpowiednim narzędziem, aby zobaczyć, jakie procesy są uruchomione.

Aby działać w tle, zazwyczaj chcesz użyć usługi .

To zadziałało dla mnie. Ale podaje tylko nazwę menu głównego. Oznacza to, że jeśli użytkownik otworzył ekran Ustawienia -> Bluetooth -> Nazwa urządzenia, RunningAppProcessInfo nazywa to po prostu Ustawieniami. Nie mogę wydobyć furthura

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

Zrób coś takiego:

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

W Lollipop i nowszych:

Dodaj do mainfest:

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

I zrób coś takiego:

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

W ten sposób sprawdzam, czy moja aplikacja jest na pierwszym planie. Uwaga Używam AsyncTask zgodnie z sugestią oficjalnego Androida dokumentacją

`

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

i wykonaj AsyncTask w ten sposób. new CheckIfForeground().execute();

Połączyłem dwa rozwiązania w jedną metodę i działa u mnie na API 24 i na API 21. Inne nie testowałem.

Kod w Kotlinie:

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

iw Manifest

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