Android: Wie überprüfe ich, ob Aktivitäten ausgeführt werden?

Ich denke klarer so:

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

Weitaus besser als eine statische Variable und OOP

Shared Preferences kann verwendet werden, um Variablen mit anderen activities und Services von einer application zu teilen.

    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 und Zerstören von Anwendungen, erspart uns die Erteilung einer weiteren Erlaubnis und gibt uns mehr Kontrolle, um zu entscheiden, wann unsere Aktivität tatsächlich die höchste ist. Details hier abd hier auch

Ich habe die Methode MyActivity.class und getCanonicalName verwendet und erhielt die Antwort.

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

Eine Option ohne Zusatzvariable lautet:

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

wobei Aktivität f.e .: this oder getActivity () ist.

Der von diesem Ausdruck zurückgegebene Wert ändert sich in onStart ()/onStop (). Hierbei handelt es sich um die Ereignisse, die das Layout der Aktivität auf dem Telefon starten oder stoppen.

Dies ist ein Code zum Überprüfen, ob ein bestimmter Dienst ausgeführt wird. Ich bin 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;

}

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

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 true oder false, wenn topActivity mit dem übereinstimmt, was der Benutzer gerade tut. Wenn also die Aktivität, für die Sie eine Prüfung durchführen, nicht angezeigt wird (d. H. "OnPause"), 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 berücksichtigen Sie eine geschützte Methode in der Basisklasse

@protected
void doSomething() {
}

und überschreiben Sie es in der abgeleiteten Klasse. 

Wenn das Ereignis eintritt, rufen Sie einfach diese Methode in der Basisklasse auf. Die korrekte "aktive" Klasse wird dann damit umgehen. Die Klasse selbst kann dann prüfen, ob es sich nicht um Paused() handelt.

Besser noch, verwenden Sie einen Event-Bus wie GreenRobot's , Square's , aber dieser ist veraltet und schlägt vor, RxJava zu verwenden.

Mir ist klar, dass dieses Problem ziemlich alt ist, aber ich denke, es lohnt sich immer noch, meine Lösung zu teilen, da es 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)

Es gibt einen viel einfacheren Weg als alles oben genannte und dieser Ansatz erfordert nicht die Verwendung von Android.permission.GET_TASKS im Manifest oder das Problem der Rassenbedingungen oder des Speicherlecks in der akzeptierten Antwort.

1. Machen Sie eine STATIC-Variable in der Hauptaktivität. Mit Static können andere Aktivitäten die Daten von einer anderen Aktivität erhalten. onPause() diese Variable setzen false , onResume und onCreate() diese Variable true setzen.

   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 Dienstleistung

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

was ist mit activity.isFinishing()

ActivityLifecycleCallbacks ist eine großartige Möglichkeit, um 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;
}
}

Aktivitätsstatus:

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

Checkt irgendwo aus Aktivität für Status der 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

Zusätzlich zu der akzeptierten Antwort können Sie stattdessen einen Zähler verwenden, wenn Sie mehrere Aktivitäten haben

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

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

Verwenden Sie eine geordnete 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 die Registrierung in onStop. Wenn ein Dienst beispielsweise mit etwas umgehen muss, das durch die Aktivität möglicherweise besser erreicht werden kann, senden Sie eine vom Dienst bestellte Rundsendung (mit einem Standardhandler im Dienst selbst). Sie können jetzt auf die Aktivität reagieren, wenn sie ausgeführt wird. Der Dienst kann die Ergebnisdaten überprüfen, um zu sehen, ob die Übertragung abgewickelt wurde, und wenn nicht, können Sie geeignete Maßnahmen ergreifen.

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

Hast du es versucht.. 

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

Nicht sicher, ob es sich um eine "richtige" Art handelt, "Dinge zu tun".
Wenn es keine API-Methode gibt, um die (oder eine) Frage zu lösen, als Sie ein wenig bedenken sollten, machen Sie vielleicht etwas falsch und lesen stattdessen mehr Dokumente usw.
(Wie ich verstanden habe, sind statische Variablen in Android ein allgemein falscher Weg. Natürlich könnte es 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, warum zu prüfen, ob Sie wissen müssen, ob eine andere Aktivität am Leben ist? Oder Sie können die Klasse ableiten, um ihre Funktionalität usw. zu erhalten.
Freundliche Grüße.

Wenn Sie an dem Lebenszyklusstatus der bestimmten 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.

Es wurde eine einfache Problemumgehung mit dem folgenden Code 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 prüfen, ob 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
}