Überprüfen Android-Anwendung ist im Vordergrund oder nicht?

Ich habe eine Menge Antworten für diese Frage durchgemacht. Aber es geht um die Einzelaktivität. Wie kann man überprüfen, ob die ganze App im Vordergrund läuft oder nicht?

  • Wie kann ich mehrere Widget-Größen in einem Apk setzen?
  • Wie man ein Doppel mit zwei Dezimalstellen in Android drucken?
  • Wie listet man alle Dateien und Ordner auf der sd-Karte auf
  • Samsung galaxy emulator
  • Werkzeug, um Speicherlecks in android zu überprüfen
  • Android Vector Drawable Absturz
  • Android Studio - Task 'Assemble' nicht im Projekt gefunden ': google-play-services_lib'
  • Cordova Android Plugin: config.xml überschrieben von cordova vorbereiten?
  • Meine Phonegap-Anwendung sieht kleiner in Android HD-Handys, HDPI und XHDPI-Handys
  • Android4OpenCV: Einstellungsauflösung beim Start
  • Laden von Bildern aus dem Festplattencache mit Picasso, wenn offline
  • Kann nicht auf einem HTML5 Canvas mit Phonegap 2.7 zeichnen
  • 11 Solutions collect form web for “Überprüfen Android-Anwendung ist im Vordergrund oder nicht?”

    Ich verstehe nicht, was du willst, aber du kannst derzeit die Vordergrund / Hintergrund-Anwendung mit ActivityManager.getRunningAppProcesses() Aufruf erkennen.

    Etwas wie,

     class ForegroundCheckTask extends AsyncTask<Context, Void, Boolean> { @Override protected Boolean doInBackground(Context... params) { final Context context = params[0].getApplicationContext(); return isAppOnForeground(context); } private boolean isAppOnForeground(Context context) { ActivityManager activityManager = (ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE); List<RunningAppProcessInfo> appProcesses = activityManager.getRunningAppProcesses(); if (appProcesses == null) { return false; } final String packageName = context.getPackageName(); for (RunningAppProcessInfo appProcess : appProcesses) { if (appProcess.importance == RunningAppProcessInfo.IMPORTANCE_FOREGROUND && appProcess.processName.equals(packageName)) { return true; } } return false; } } // Use like this: boolean foregroud = new ForegroundCheckTask().execute(context).get(); 

    Lassen Sie mich auch wissen, ob ich falsch verstehe ..

    UPDATE: Betrachten Sie diese SO-Frage Bestimmen der aktuellen Vordergrund-Anwendung aus einer Hintergrund-Task oder Service vor mehr Informationen ..

    Vielen Dank..

    @ User370305's Antwort ist fehleranfällig und entmutigt von Android OS Developers (siehe https://groups.google.com/forum/#!msg/android-developers/zH-2bovZSLg/L2YM8Z1N-HwJ )

    Es gibt einen viel einfacheren Ansatz:

    Auf einer BaseActivity, die alle Aktivitäten erweitern :

     protected static boolean isVisible = false; @Override public void onResume() { super.onResume(); setVisible(true); } @Override public void onPause() { super.onPause(); setVisible(false); } 

    Wann immer Sie überprüfen müssen, ob eine Ihrer Bewerbungsaktivitäten im Vordergrund ist, überprüfen Sie isVisible();

    Um diesen Ansatz zu verstehen, überprüfen Sie diese Antwort von Seite-an-Seite-Aktivität Lebenszyklus: Aktivität Seite-an-Seite-Lebenszyklus

    Ich habe mit Paketfilter aus dem laufenden Prozess versucht. Aber das ist sehr komisch. Stattdessen versuche ich neue Lösung und diese Arbeit perfekt. Ich habe viele Male überprüft und bekommen perfektes Ergebnis durch dieses Modul.

     private int numRunningActivities = 0; public void onCreate() { super.onCreate(); this.registerActivityLifecycleCallbacks(new ActivityLifecycleCallbacks() { @Override public void onActivityStarted(Activity activity) { numRunningActivities++; if (numRunningActivities == 1) { LogUtils.d("APPLICATION", "APP IN FOREGROUND"); } } @Override public void onActivityStopped(Activity activity) { numRunningActivities--; if (numRunningActivities == 0) { Log.e("", "App is in BACKGROUND") } } @Override public void onActivitySaveInstanceState(Activity activity, Bundle outState) { } @Override public void onActivityResumed(Activity activity) { } @Override public void onActivityPaused(Activity activity) { } @Override public void onActivityDestroyed(Activity activity) { } @Override public void onActivityCreated(Activity activity, Bundle savedInstanceState) { } }); } 

    Die gemerkte und nicht veraltete Art und Weise, die ich bisher gefunden habe, um dies zu tun, wie folgt:

     @Override public boolean foregrounded() { ActivityManager.RunningAppProcessInfo appProcessInfo = new ActivityManager.RunningAppProcessInfo(); ActivityManager.getMyMemoryState(appProcessInfo); return (appProcessInfo.importance == IMPORTANCE_FOREGROUND || appProcessInfo.importance == IMPORTANCE_VISIBLE) } 

    Es funktioniert nur mit SDK 16+.

    EDIT :

    Ich habe den folgenden Code aus der Lösung entfernt:

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

    Da das nicht die Benachrichtigungen erhält, wenn der Bildschirm gesperrt ist. Ich hatte einen Blick auf den Rahmen und der Zweck von diesem ist nicht ganz klar. Ich würde es entfernen. Die Überprüfung des Prozeßinformationszustandes wäre genug 🙂

    Überprüfen Sie, ob die App im Hintergrund oder Vordergrund ist. Diese Methode wird true zurückgegeben, wenn die App im Hintergrund ist.

    Zuerst füge die GET_TASKS-Berechtigung deinem AndroidManifest.xml hinzu

     private boolean isAppIsInBackground(Context context) { boolean isInBackground = true; ActivityManager am = (ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE); if (Build.VERSION.SDK_INT > Build.VERSION_CODES.KITKAT_WATCH) { List<ActivityManager.RunningAppProcessInfo> runningProcesses = am.getRunningAppProcesses(); for (ActivityManager.RunningAppProcessInfo processInfo : runningProcesses) { if (processInfo.importance == ActivityManager.RunningAppProcessInfo.IMPORTANCE_FOREGROUND) { for (String activeProcess : processInfo.pkgList) { if (activeProcess.equals(context.getPackageName())) { isInBackground = false; } } } } } else { List<ActivityManager.RunningTaskInfo> taskInfo = am.getRunningTasks(1); ComponentName componentInfo = taskInfo.get(0).topActivity; if (componentInfo.getPackageName().equals(context.getPackageName())) { isInBackground = false; } } return isInBackground; } 

    Ich habe eine einfache Lösung für diese durch die Schaffung einer Basis-Aktivität Klasse gefunden, müssen Sie alle Ihre Aktivitätsklassen aus diesem:

     public class BaseActivity extends ActionBarActivity { @Override protected void onResume() { ApplicationStateChecker.view_resumed(this); super.onResume(); } @Override protected void onStop() { ApplicationStateChecker.view_stopped(this); super.onStop(); } @Override protected void onPause() { ApplicationStateChecker.view_paused(this); super.onPause(); } } 

    ApplicationStateChecker-Klasse:

     public class ApplicationStateChecker { private static final String _pause_string = "paused"; private static final String _resume_string = "resumed"; private static String _view_lastState; private static boolean _from_background = true; public static void view_paused(Activity activity){ _view_lastState = _pause_string; } public static void view_stopped(Activity activity){ if ( _view_lastState.equals(_pause_string) ){ //if stop called and last event was pause then app is brought to background _from_background = true; } //if } public static void view_resumed(Activity activity){ if ( _from_background ) { //Do your stuff here , app is brought to foreground } //if _from_background = false; _view_lastState = _resume_string; } 

    Es gibt keinen globalen Rückruf dafür, aber für jede Aktivität ist es onStop (). Du brauchst dich nicht mit einem Atom int zu verwirren. Nur eine globale int mit der Anzahl der gestarteten Aktivitäten, in jeder Aktivität inkrementieren sie in onStart () und dekrementieren sie in onStop ().

     public class BaseActivity extends ActionBarActivity { public static int count = 0; public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); } @Override protected void onStart() { super.onStart(); count = count + 1; Log.d(TAG, "onStart" + count); if (count == 1) { Toast.makeText(getApplicationContext(), "online", Toast.LENGTH_SHORT).show(); } } protected void onStop() { super.onStop(); count = count - 1; if (count == 0) { Toast.makeText(getApplicationContext(), "offline", Toast.LENGTH_SHORT).show(); } } } 

    Cesards Antwort ist richtig, aber nur für API> 15. Für niedrigere API-Versionen entschied ich mich, die Methode getRunningTasks() verwenden:

      private boolean isAppInForeground(Context context) { if (android.os.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(); } } 

    Bitte lassen Sie mich wissen, ob es für Sie alle funktioniert.

    Versuchen Sie ActivityLifecycleCallbacks in Ihrer Anwendungsklasse.

    Keine der Lösungsbasis auf getRunningTasks () funktioniert in den letzten Android-Versionen, getRunningTasks () wurde auf API-Ebene 21 veraltet. Auch wenn es noch verwendet wird, gibt es nicht genügend Informationen, um festzustellen, ob die App im Vordergrund steht.

    Stattdessen erweitern Sie die Anwendungsklasse und verwenden ApplicationActivityLifecycleCallbacks, um den Anwendungssichtbarkeitsstatus zu verfolgen.

     public class MyApplication extends Application { static final String APP_STATE_FOREGROUND = "com.xxx.appstate.FOREGROUND"; static final String APP_STATE_BACKGROUND = "com.xxx.appstate.BACKGROUND"; private static int m_foreground = -1; private Handler m_handler = new Handler(); private Runnable m_guard; public static boolean isForeground() { return m_foreground == 1; } @Override public void onCreate() { super.onCreate(); registerActivityLifecycleCallbacks(new Application.ActivityLifecycleCallbacks() { @Override public void onActivityCreated(Activity activity, Bundle bundle) { } @Override public void onActivityStarted(Activity activity) { } @Override public void onActivityResumed(Activity activity) { if(m_guard != null) { m_handler.removeCallbacks(m_guard); m_guard = null; } if(m_foreground == 1) return; m_foreground = 1; sendBroadcast(new Intent(APP_STATE_FOREGROUND)); } @Override public void onActivityPaused(Activity activity) { if(m_foreground == 0) return; /* * Use a 400ms guard to protect against jitter * when switching between two activities * in the same app */ m_guard = new Runnable() { @Override public void run() { if(m_foreground == 1) { m_foreground = 0; sendBroadcast(new Intent(APP_STATE_BACKGROUND)); } } }; m_handler.postDelayed(m_guard, 400); } @Override public void onActivityStopped(Activity activity) { } @Override public void onActivitySaveInstanceState(Activity activity, Bundle bundle) { } @Override public void onActivityDestroyed(Activity activity) { } }); } } 

    Mit dem 400ms Guard Timer eliminiert falsche Erkennung von Hintergrundzustand beim Umschalten zwischen Aktivitäten in der gleichen App. Der Hintergrund / Vordergrundzustand kann jederzeit abgefragt werden:

     MyApplication.isForeground(); 

    Eine Klasse kann auch auf die Sendungsveranstaltungen hören, wenn sie an den Zustandsübergängen interessiert ist:

     private static IntentFilter m_appStateFilter; static { m_appStateFilter = new IntentFilter(); m_appStateFilter.addAction(MyApplication.APP_STATE_FOREGROUND); m_appStateFilter.addAction(MyApplication.APP_STATE_BACKGROUND); } private BroadcastReceiver m_appStateReceiver = new BroadcastReceiver() { @Override public void onReceive(Context context, Intent intent) { String action = intent.getAction(); if (action.equals(MyApplication.APP_STATE_FOREGROUND)) { /* application entered foreground */ } else if (action.equals(MyApplication.APP_STATE_BACKGROUND)) { /* application entered background */ } } }; registerReceiver(m_appStateReceiver, m_appStateFilter); 

    Unten ist aktualisierte Lösung für das neueste Android SDK.

     String PackageName = context.getPackageName(); ActivityManager manager = (ActivityManager) context.getSystemService(ACTIVITY_SERVICE); ComponentName componentInfo; if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) { List<ActivityManager.AppTask> tasks = manager.getAppTasks(); componentInfo = tasks.get(0).getTaskInfo().topActivity; } else { List<ActivityManager.RunningTaskInfo> tasks = manager.getRunningTasks(1); componentInfo = tasks.get(0).topActivity; } if (componentInfo.getPackageName().equals(PackageName)) return true; return false; 

    Hoffe das hilft, danke.

    Das Android ist ein Google Android Fan-Website, Alles über Android Phones, Android Wear, Android Dev und Android Spiele Apps und so weiter.