Android: Wie überprüfe ich, ob Aktivität ausgeführt wird?

Gibt es eine einfache Möglichkeit festzustellen, ob eine bestimmte Aktivität aktiv ist oder nicht? Ich möchte bestimmte Dinge tun, je nachdem welche Aktivität aktiv ist. z.B:

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

Sie können eine staticVariable innerhalb der Aktivität verwenden.

class MyActivity extends Activity {
     static boolean active = false;

      @Override
      public void onStart() {
         super.onStart();
         active = true;
      } 

      @Override
      public void onStop() {
         super.onStop();
         active = false;
      }
}

Das einzige Problem ist, dass, wenn Sie es in zwei Aktivitäten verwenden, die miteinander verknüpft sind, onStopdie erste manchmal onStartin der zweiten aufgerufen wird . Beides könnte also kurz zutreffen.

Je nachdem, was Sie versuchen (aktuelle Aktivität von einem Dienst aktualisieren?). Sie können einfach einen statischen Listener im Dienst in Ihrer Aktivitätsmethode registrieren. onStartDann ist der richtige Listener verfügbar, wenn Ihr Dienst die Benutzeroberfläche aktualisieren möchte.

Mir ist klar, dass dieses Problem ziemlich alt ist, aber ich denke, es lohnt sich immer noch, meine Lösung zu teilen, da sie für andere nützlich sein könnte.

Diese Lösung war vor der Veröffentlichung von Android Architecture Components nicht verfügbar.

Aktivität ist zumindest teilweise sichtbar

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

Aktivität steht im Vordergrund

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

Ich denke so klarer:

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

Eine Option ohne Verwendung einer Hilfsvariablen ist:

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

wo Aktivität ist zB: this oder getActivity ().

Der von diesem Ausdruck zurückgegebene Wert ändert sich in onStart () / onStop (). Hierbei handelt es sich um Ereignisse, bei denen das Layout der Aktivität auf dem Telefon gestartet / gestoppt wird.

Ich habe die Methoden MyActivity.class und getCanonicalName verwendet und eine Antwort erhalten.

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

Weitaus besser als eine statische Variable zu verwenden und OOP zu folgen

Shared Preferenceskann verwendet werden, um Variablen mit anderen activitiesund Diensten von einem zu teilenapplication

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

    }
}

Verwenden Sie gemeinsame Einstellungen. Es verfügt über die zuverlässigsten Statusinformationen, weniger Probleme beim Wechseln / Zerstören von Anwendungen, erspart uns die Anforderung einer weiteren Erlaubnis und gibt uns mehr Kontrolle darüber, wann unsere Aktivität tatsächlich die oberste ist. siehe Details bitte hier abd hier auch

Dies ist ein Code zum Überprüfen, ob ein bestimmter Dienst ausgeführt wird. Ich bin mir ziemlich sicher, dass es auch für eine Aktivität funktionieren kann, solange Sie getRunningServices mit getRunningAppProcesses () oder getRunningTasks () ändern. Schauen Sie hier http://developer.android.com/reference/android/app/ActivityManager.html#getRunningAppProcesses ()

Ändern Sie Constants.PACKAGE und Constants.BACKGROUND_SERVICE_CLASS entsprechend

    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;

}

Es gibt einen viel einfacheren Weg als alles oben Genannte, und dieser Ansatz erfordert nicht die Verwendung android.permission.GET_TASKSim Manifest oder das Problem der Rennbedingungen oder Speicherlecks, auf das in der akzeptierten Antwort hingewiesen wird.

1. Erstellen Sie in der Hauptaktivität eine STATIC-Variable. Mit Static können andere Aktivitäten die Daten einer anderen Aktivität empfangen. onPause()setzen Sie diese Variable falsch , onResumeund onCreate()setzen Sie diese Variable wahr .

   private static boolean mainActivityIsOpen;

2. Weisen Sie Getter und Setter dieser Variablen zu.

   public static boolean mainActivityIsOpen() {
       return mainActivityIsOpen;
   }
   
   public static void mainActivityIsOpen(boolean mainActivityIsOpen) {
       DayView.mainActivityIsOpen = mainActivityIsOpen;
   }

3. Und dann von einer anderen Aktivität oder einem anderen Dienst

   if (MainActivity.mainActivityIsOpen() == false)
   {
                   //do something
   }
   else if(MainActivity.mainActivityIsOpen() == true)
   {//or just else. . . ( or else if, does't matter)
           //do something
   }

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

Aus den offiziellen Dokumenten:

Aktivität # isFinishing ()

Überprüfen Sie, ob diese Aktivität gerade beendet wird, entweder weil Sie finish () aufgerufen haben oder weil jemand anderes die Beendigung angefordert hat. Dies wird häufig in onPause () verwendet, um festzustellen, ob die Aktivität einfach angehalten oder vollständig beendet wird.

Aktivität # isDestroyed ()

Gibt true zurück, wenn der letzte Aufruf von onDestroy () für die Aktivität erfolgt ist, sodass diese Instanz jetzt tot ist.

danke kkudi! Ich konnte Ihre Antwort an die Arbeit für eine Aktivität anpassen. Hier ist, was in meiner App funktioniert hat.

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

In diesem Beispiel erhalten Sie ein Richtig oder Falsch, wenn die topActivity mit dem übereinstimmt, was der Benutzer tut. Wenn also die Aktivität, nach der Sie suchen, nicht angezeigt wird (dh onPause ist), erhalten Sie keine Übereinstimmung. Dazu müssen Sie Ihrem Manifest die Berechtigung hinzufügen.

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

Ich hoffe das war hilfreich!

Ich denke, die akzeptierte Antwort ist eine schreckliche Art, damit umzugehen.

Ich weiß nicht, was der Anwendungsfall ist, aber bitte ziehen Sie eine geschützte Methode in der Basisklasse in Betracht

@protected
void doSomething() {
}

und überschreiben Sie es in der abgeleiteten Klasse.

Wenn das Ereignis eintritt, rufen Sie diese Methode einfach in der Basisklasse auf. Die richtige 'aktive' Klasse wird dann damit umgehen. Die Klasse selbst kann dann prüfen, ob dies nicht der Fall ist Paused().

Besser noch, verwenden Sie einen Eventbus wie den von GreenRobot , Square , aber dieser ist veraltet und schlägt die Verwendung von RxJava vor

Ich habe einen Scheck benutzt if (!a.isFinishing())und er scheint zu tun, was ich brauche. aist die Aktivitätsinstanz. Ist das falsch Warum hat das niemand versucht?

wie wäre es mit activity.isFinishing()

ActivityLifecycleCallbacks ist eine großartige Möglichkeit, alle Aktivitäten in App zu verfolgen:

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

Erweitern Sie die Anwendungsklasse und geben Sie ihre Referenz in der Android Manifest-Datei an:

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

Überprüfen Sie irgendwo von Aktivität den Status einer anderen Aktivität:

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

Ich bin mir nicht sicher, ob es ein "richtiger" Weg ist, "Dinge zu tun".
Wenn es keinen API-Weg gibt, um die (oder eine) Frage zu lösen, als Sie sich ein wenig überlegen sollten, machen Sie vielleicht etwas falsch und lesen stattdessen mehr Dokumente usw.
(Wie ich verstanden habe, sind statische Variablen in Android ein häufig falscher Weg. Natürlich es könnte funktionieren, aber es wird definitiv Fälle geben, in denen es nicht funktioniert (zum Beispiel in der Produktion auf Millionen Geräten).
Genau in Ihrem Fall schlage ich vor zu überlegen, warum Sie wissen müssen, ob eine andere Aktivität aktiv ist. Sie können eine andere Aktivität starten, damit das Ergebnis ihre Funktionalität erhält. Oder Sie können die Klasse ableiten, um ihre Funktionalität zu erhalten, und so weiter.
Freundliche Grüße.

Wenn Sie am Lebenszyklusstatus der spezifischen Instanz der Aktivität interessiert sind, sieht die Lösung von siliconeagle korrekt aus, außer dass die neue "aktive" Variable eine Instanzvariable und keine statische sein sollte.

Verwenden Sie eine bestellte Sendung. Siehe http://android-developers.blogspot.nl/2011/01/processing-ordered-broadcasts.html

Registrieren Sie in Ihrer Aktivität einen Empfänger in onStart und heben Sie die Registrierung in onStop auf. Wenn ein Dienst beispielsweise etwas verarbeiten muss, das die Aktivität möglicherweise besser ausführen kann, senden Sie eine bestellte Sendung vom Dienst (mit einem Standardhandler im Dienst selbst). Sie können jetzt in der Aktivität antworten, wenn sie ausgeführt wird. Der Dienst kann die Ergebnisdaten überprüfen, um festzustellen, ob die Übertragung verarbeitet wurde, und gegebenenfalls geeignete Maßnahmen ergreifen.

Wenn Sie mehrere Instanzen der Aktivität haben, können Sie zusätzlich zur akzeptierten Antwort stattdessen einen Zähler verwenden:

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

Hast du es versucht..

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

Mit dem folgenden Code wurde eine einfache Problemumgehung gefunden

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

Verwenden Sie die Variable isActivity, um zu überprüfen, ob die Aktivität aktiv ist oder nicht.

private boolean activityState = true;

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

Dann überprüfe

if(activityState){
//add your code
}

Wenn Sie überprüfen möchten, ob sich die Aktivität im Backstack befindet, führen Sie einfach die nächsten Schritte aus. 1. Deklarierte eine ArrayList in Ihrer Anwendungsklasse [Die Anwendungsklasse ist in Ihrer Hauptfestdatei im Anwendungs-Tag definiert]

private ArrayList<Class> runningActivities = new ArrayList<>();

2. Fügen Sie die folgenden öffentlichen Methoden hinzu, um auf diese Liste zuzugreifen und sie zu ändern.

   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. Überschreiben Sie in Ihrer BaseActivity, in der alle Aktivitäten sie erweitern, die Methoden onCreate und onDestroy, damit Sie Aktivitäten wie folgt zum Backstack hinzufügen und daraus entfernen können.

   @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. Wenn Sie abschließend überprüfen möchten, ob sich die Aktivität im Backstack befindet oder nicht, rufen Sie einfach diese Funktion isActivityInBackStack auf.

Beispiel: Ich möchte überprüfen, ob sich die HomeActivity im Backstack befindet oder nicht:

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

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

Dies funktioniert, wenn Sie nicht die gleiche Aktivität im Vordergrund haben. Wenn Sie von der Benachrichtigung öffnen, funktioniert nicht, habe ich einige Anpassungen vorgenommen und kam mit diesem:

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

Das funktioniert bei mir, wenn mehrere Aktivitäten gleichzeitig geöffnet sind.