¿Cómo verificar si la actividad está en primer plano o en un fondo visible?

Tengo una pantalla de bienvenida en un temporizador. Mi problema es que antes de finish() mi actividad necesito verificar que la siguiente actividad haya comenzado porque aparece un cuadro de diálogo del sistema y solo quiero finish() ; una vez que el usuario ha seleccionado una opción del cuadro de diálogo?

Sé que hay muchas preguntas sobre cómo ver si tu actividad está en primer plano, pero no sé si esto permite cuadros de diálogo en la parte superior de la actividad también.

Aquí está el problema, el rojo es mi actividad que está en el fondo mientras el diálogo está en primer plano:

el rojo es mi actividad que está en el fondo mientras el diálogo está en primer plano

EDITAR: Intenté simplemente no usar finish() pero luego mi actividad puede volver a la stack de aplicaciones que trato de evitar.

Esto es lo que se recomienda como la solución correcta :

La solución correcta (los créditos van a Dan, CommonsWare y NeTeInStEiN) Haga un seguimiento de la visibilidad de su aplicación usted mismo usando los métodos Activity.onPause, Activity.onResume. Almacenar el estado de “visibilidad” en alguna otra clase. Las buenas elecciones son su propia implementación de la Aplicación o un Servicio (también hay algunas variaciones de esta solución si desea verificar la visibilidad de la actividad desde el servicio).

Ejemplo Implementar clase de aplicación personalizada (tenga en cuenta el método isActivityVisible () static):

 public class MyApplication extends Application { public static boolean isActivityVisible() { return activityVisible; } public static void activityResumed() { activityVisible = true; } public static void activityPaused() { activityVisible = false; } private static boolean activityVisible; } 

Registre su clase de aplicación en AndroidManifest.xml:

  

Agregue OnPause y OnResume a cada actividad en el proyecto (puede crear un ancestro común para sus actividades si lo desea, pero si su actividad ya está extendida desde MapActivity / ListActivity, debe escribir lo siguiente a mano) :

 @Override protected void onResume() { super.onResume(); MyApplication.activityResumed(); } @Override protected void onPause() { super.onPause(); MyApplication.activityPaused(); } 

En su método finish() , desea usar isActivityVisible() para verificar si la actividad es visible o no. Allí también puede verificar si el usuario ha seleccionado una opción o no. Continúa cuando se cumplan ambas condiciones.

La fuente también menciona dos soluciones incorrectas … así que evita hacer eso.

Fuente: stackoverflow

Si se dirige al nivel de API 14 o superior, se puede usar android.app.Application.ActivityLifecycleCallbacks

 public class MyApplication extends Application implements ActivityLifecycleCallbacks { private static boolean isInterestingActivityVisible; @Override public void onCreate() { super.onCreate(); // Register to be notified of activity state changes registerActivityLifecycleCallbacks(this); .... } public boolean isInterestingActivityVisible() { return isInterestingActivityVisible; } @Override public void onActivityResumed(Activity activity) { if (activity instanceof MyInterestingActivity) { isInterestingActivityVisible = true; } } @Override public void onActivityStopped(Activity activity) { if (activity instanceof MyInterestingActivity) { isInterestingActivityVisible = false; } } // Other state change callback stubs .... } 

Esa es exactamente la diferencia entre los eventos onPause y onStop de la actividad como se describe en la documentación de la clase Activity .

Si lo entiendo correctamente, lo que quiere hacer es llamar a finish() desde su actividad en onStop para terminarlo. Vea la imagen adjunta de la aplicación Activity Lifecycle Demo . Así es como se ve cuando la Actividad B se lanza desde la Actividad A. El orden de los eventos es de abajo hacia arriba para que pueda ver que se llama a Actividad A onStop después de que ya se haya llamado a la Actividad B en onResume .

Demo del ciclo de vida de la actividad

En caso de que se muestre un cuadro de diálogo, su actividad se atenúa en segundo plano y solo se llama a onPause .

Dos posibles soluciones:

1) Actividad CallCycle Callbacks

Use una aplicación que implemente ActivityLifecycleCallbacks y úsela para rastrear eventos de ciclo de vida de actividades en su aplicación. Tenga en cuenta que ActivityLifecycleCallbacks es para api de Android> = 14. Para la API previa de Android, deberá implementarla usted mismo en todas sus actividades 😉

Use la aplicación cuando necesite compartir / almacenar estados en diferentes actividades.

2) Verifica la ejecución de las informaciones del proceso

Puede verificar el estado de un proceso en ejecución con esta clase RunningAppProcessInfo

Obtenga la lista de procesos en ejecución con ActivityManager.getRunningAppProcesses () y filtre la lista de resultados para verificar el RunningAppProcessInfo deseado y verifique su “importancia”

Activity :: hasWindowFocus () le devuelve el booleano que necesita.

 public class ActivityForegroundChecker extends TimerTask { private static final long FOREGROUND_CHECK_PERIOD = 5000; private static final long FIRST_DELAY = 3000; private Activity m_activity; private Timer m_timer; public ActivityForegroundChecker (Activity p_activity) { m_activity = p_activity; } @Override public void run() { if (m_activity.hasWindowFocus() == true) { // Activity is on foreground return; } // Activity is on background. } public void start () { if (m_timer != null) { return; } m_timer = new Timer(); m_timer.schedule(this, FIRST_DELAY, FOREGROUND_CHECK_PERIOD); } public void stop () { if (m_timer == null) { return; } m_timer.cancel(); m_timer.purge(); m_timer = null; } } 

Aquí hay una clase de ejemplo para verificar la visibilidad de sus actividades desde donde se encuentre.

Recuerde que si muestra un cuadro de diálogo , el resultado será falso ya que el cuadro de diálogo tendrá el foco principal. Aparte de eso, es realmente útil y más confiable que las soluciones sugeridas.

Tengo un proyecto de creación en github app-foreground-background-listen

que usa una lógica muy simple y funciona bien con todos los niveles API de Android.

Usa el intervalo de tiempo entre pausa y currículum desde el fondo para determinar si está despierto desde el fondo

En aplicación personalizada

 private static boolean isInBackground; private static boolean isAwakeFromBackground; private static final int backgroundAllowance = 10000; public static void activityPaused() { isInBackground = true; final Handler handler = new Handler(); handler.postDelayed(new Runnable() { @Override public void run() { if (isInBackground) { isAwakeFromBackground = true; } } }, backgroundAllowance); Log.v("activity status", "activityPaused"); } public static void activityResumed() { isInBackground = false; if(isAwakeFromBackground){ // do something when awake from background Log.v("activity status", "isAwakeFromBackground"); } isAwakeFromBackground = false; Log.v("activity status", "activityResumed"); } 

En la clase BaseActivity

 @Override protected void onResume() { super.onResume(); MyApplication.activityResumed(); } @Override protected void onPause() { super.onPause(); MyApplication.activityPaused(); } 

Creo que tengo una mejor solución. Porque puedes comstackr simplemente MyApplication.activityResumed (); a cada actividad por una extensión.

En primer lugar, debe crear (como CyberneticTwerkGuruOrc)

 public class MyApplication extends Application { public static boolean isActivityVisible() { return activityVisible; } public static void activityResumed() { activityVisible = true; } public static void activityPaused() { activityVisible = false; } private static boolean activityVisible; } 

A continuación, debe agregar la clase de aplicación a AndroidManifest.xml

  

Luego, crea la clase ActivityBase

 public class ActivityBase extends Activity { @Override protected void onPause() { super.onPause(); MyApplication.activityPaused(); } @Override protected void onResume() { super.onResume(); MyApplication.activityResumed(); } } 

Finalmente, cuando crea una nueva actividad, puede simplemente ampliarla por ActivityBase en lugar de Activity.

 public class Main extends ActivityBase { @Override protected void onResume() { super.onResume(); } @Override protected void onPause() { super.onPause(); } } 

Para mí es un método mejor porque tienes que recordar acerca de extender por ActivityBase. Además, puedes expandir tu función base en el futuro. En mi caso, agregué receptores para mi servicio y alertas sobre la red en una clase.

Si quiere verificar la visibilidad de su aplicación, simplemente puede llamar

 MyApplication.isActivityVisible() 

¿Intentó no llamar al final y poner “android: noHistory =” true “en el manifiesto? Esto evitará que la actividad vaya a la stack.

Debo decir que su flujo de trabajo no está en una forma estándar de Android. En Android, no necesita finish() su actividad si desea abrir otra actividad desde Intent. En cuanto a la conveniencia del usuario, Android le permite al usuario usar la tecla ‘atrás’ para retroceder desde la actividad que abrió en su aplicación.

Deje que el sistema detenga su actividad y guarde todo lo que necesite cuando su actividad sea devuelta.

No sé por qué nadie habló sobre las Preferencias compartidas, para la Actividad A, estableciendo una SharedPreference así (por ejemplo en onPause ()):

 SharedPreferences pref = context.getSharedPreferences(SHARED_PREF, 0); SharedPreferences.Editor editor = pref.edit(); editor.putBoolean("is_activity_paused_a", true); editor.commit(); 

Creo que esta es la manera confiable de rastrear la visibilidad de las actividades.

Si desea saber si alguna actividad de su aplicación es visible en la pantalla, puede hacer algo como esto:

 public class MyAppActivityCallbacks implements Application.ActivityLifecycleCallbacks { private Set> visibleActivities = new HashSet<>(); @Override public void onActivityResumed(Activity activity) { visibleActivities.add((Class) activity.getClass()); } @Override public void onActivityStopped(Activity activity) { visibleActivities.remove(activity.getClass()); } public boolean isAnyActivityVisible() { return !visibleActivities.isEmpty(); } @Override public void onActivityCreated(Activity activity, Bundle savedInstanceState) {} @Override public void onActivityStarted(Activity activity) {} @Override public void onActivityPaused(Activity activity) {} @Override public void onActivityDestroyed(Activity activity) {} @Override public void onActivitySaveInstanceState(Activity activity, Bundle outState) {}} 

Solo crea un singleton de esta clase y configúralo en tu instancia de aplicación como se muestra a continuación:

 class App extends Application{ @Override public void onCreate() { registerActivityLifecycleCallbacks(myAppActivityCallbacks); } } 

¡Entonces puede usar el método isAnyActivityVisible () de su instancia de MyAppActivityCallbacks en cualquier lugar!

Guarde una bandera si está en pausa o reanudada. Si se reanuda significa que estás en primer plano

 boolean isResumed = false; @Override public void onPause() { super.onPause(); isResumed = false; } @Override public void onResume() { super.onResume(); isResumed = true; } private void finishIfForeground() { if (isResumed) { finish(); } } 

Una posible solución podría ser establecer un indicador mientras se muestra el diálogo del sistema y luego, en el método onStop del ciclo de vida de la actividad, verificar que el indicador, si es verdadero, termine la actividad.

Por ejemplo, si el cuadro de diálogo del sistema se activa mediante un clic, entonces el oyente onclick podría ser como

 private OnClickListener btnClickListener = new OnClickListener() { @Override public void onClick(View v) { Intent intent = new Intent(); intent.setAction(Intent.ACTION_SEND); intent.setType("text/plain"); CheckActivity.this.startActivity(Intent.createChooser(intent, "Complete action using")); checkFlag = true; //flag used to check } }; 

y en la parte superior de la actividad:

 @Override protected void onStop() { if(checkFlag){ finish(); } super.onStop(); } 

¿Por qué no usar transmisiones para esto? la segunda actividad (la que debe estar activa) puede enviar una transmisión local como esta:

 //put this in onCreate(..) or any other lifecycle method that suits you best //notice the string sent to the intent, it will be used to register a receiver! Intent result = new Intent("broadcast identifier"); result.putString("some message");//this is optional LocalBroadcastManager.getInstance(getApplicationContext()).sendBroadcast(result); 

luego escribe un receptor simple dentro de la actividad splash:

 //this goes on the class level (like a class/instance variable, not in a method) of your splash activity: private BroadcastReceiver receiver = new BroadcastReceiver() { @Override public void onReceive(Context context, Intent intent) { //kill activity here!!! //mission accomplished! } }; 

y registre su nuevo receptor con LocalBroadcastManager para escuchar la transmisión de su segunda actividad:

 //notice the string sent to the intent filter, this is where you tell the BroadcastManager which broadcasts you want to listen to! LocalBroadcastManager.getInstance(getApplicationContext()).registerReceiver(receiver, new IntentFilter("broadcast identifier")); 

TEN EN CUENTA que puedes usar una constante o un recurso de cadena para la cadena “identificador de difusión”.

Si usa finish() solo para evitar que la nueva aplicación comience en la stack (tarea) de su aplicación, puede usar el indicador Intent.FLAG_ACTIVITY_NEW_TASK , cuando comience una nueva aplicación y no llame a finish() en absoluto. De acuerdo con la documentación , esta es la bandera que se utilizará para implementar un comportamiento de estilo “iniciador”.

 // just add this line before you start an activity intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK); startActivity(intent); 

Esto puede lograr esto de una manera eficiente mediante el uso de Application.ActivityLifecycleCallbacks

Por ejemplo, tomemos el nombre de clase de actividad, ya que ProfileActivity permite determinar si está en primer plano o en segundo plano.

primero tenemos que crear nuestra clase de aplicación extendiendo la clase de aplicación

que implementa

Application.ActivityLifecycleCallbacks

Permite ser mi clase de aplicación de la siguiente manera

Clase de aplicación

 public class AppController extends Application implements Application.ActivityLifecycleCallbacks { private boolean activityInForeground; @Override public void onCreate() { super.onCreate(); //register ActivityLifecycleCallbacks registerActivityLifecycleCallbacks(this); } public static boolean isActivityVisible() { return activityVisible; } public static void activityResumed() { activityVisible = true; } public static void activityPaused() { activityVisible = false; } private static boolean activityVisible; @Override public void onActivityCreated(Activity activity, Bundle savedInstanceState) { } @Override public void onActivityStarted(Activity activity) { } @Override public void onActivityResumed(Activity activity) { //Here you can add all Activity class you need to check whether its on screen or not activityInForeground = activity instanceof ProfileActivity; } @Override public void onActivityPaused(Activity activity) { } @Override public void onActivityStopped(Activity activity) { } @Override public void onActivitySaveInstanceState(Activity activity, Bundle outState) { } @Override public void onActivityDestroyed(Activity activity) { } public boolean isActivityInForeground() { return activityInForeground; } } 

en la clase anterior hay un método de anulación en la ActividadResultado de ActivityLifecycleCallbacks

  @Override public void onActivityResumed(Activity activity) { //Here you can add all Activity class you need to check whether its on screen or not activityInForeground = activity instanceof ProfileActivity; } 

donde se puede encontrar toda la instancia de actividad que se muestra actualmente en la pantalla, simplemente verifique si Su actividad está en pantalla o no por el método anterior.

Registre su clase de aplicación en manifest.xml

  

Para verificar si la actividad meteorológica está en primer plano o en segundo plano según la solución anterior, llame al siguiente método en los lugares que necesite verificar

 AppController applicationControl = (AppController) getApplicationContext(); if(applicationControl.isActivityInForeground()){ Log.d("TAG","Activity is in foreground") } else { Log.d("TAG","Activity is in background") } 

Usa estos métodos dentro de una Activity .

isDestroyed()

Agregado en Api 17
Devuelve verdadero si la llamada final onDestroy () se realizó en la Actividad, por lo que esta instancia ahora está muerta.

isFinishing()

Agregado en Api 1
Compruebe si esta actividad está en proceso de finalización, ya sea porque ha llamado a finish () o porque alguien más ha solicitado que termine. Esto se usa a menudo en onPause () para determinar si la actividad simplemente está pausando o terminando por completo.

De la documentación de Memory Leaks

Un error común con AsyncTask es capturar una referencia fuerte a la Activity del host (o Fragment ):

 class MyActivity extends Activity { private AsyncTask myTask = new AsyncTask() { // Don't do this! Inner classes implicitly keep a pointer to their // parent, which in this case is the Activity! } } 

Esto es un problema porque AsyncTask puede sobrevivir fácilmente a la Activity principal, por ejemplo, si ocurre un cambio de configuración mientras se está ejecutando la tarea.

La forma correcta de hacer esto es hacer que su tarea sea una clase static , que no capture el elemento principal, y manteniendo una referencia débil a la Activity :

 class MyActivity extends Activity { static class MyTask extends AsyncTask { // Weak references will still allow the Activity to be garbage-collected private final WeakReference weakActivity; MyTask(MyActivity myActivity) { this.weakActivity = new WeakReference<>(myActivity); } @Override public Void doInBackground(Void... params) { // do async stuff here } @Override public void onPostExecute(Void result) { // Re-acquire a strong reference to the activity, and verify // that it still exists and is active. MyActivity activity = weakActivity.get(); if (activity == null || activity.isFinishing() || activity.isDestroyed()) { // activity is no longer valid, don't do anything! return; } // The activity is still valid, do main-thread stuff here } } } 

Aquí hay una solución que usa la clase de Application .

 public class AppSingleton extends Application implements Application.ActivityLifecycleCallbacks { private WeakReference foregroundActivity; @Override public void onActivityResumed(Activity activity) { foregroundActivity=new WeakReference(activity); } @Override public void onActivityPaused(Activity activity) { String class_name_activity=activity.getClass().getCanonicalName(); if (foregroundActivity != null && foregroundActivity.get().getClass().getCanonicalName().equals(class_name_activity)) { foregroundActivity = null; } } //............................ public boolean isOnForeground(@NonNull Context activity_cntxt) { return isOnForeground(activity_cntxt.getClass().getCanonicalName()); } public boolean isOnForeground(@NonNull String activity_canonical_name) { if (foregroundActivity != null && foregroundActivity.get() != null) { return foregroundActivity.get().getClass().getCanonicalName().equals(activity_canonical_name); } return false; } } 

Simplemente puede usarlo de la siguiente manera

 ((AppSingleton)context.getApplicationContext()).isOnForeground(context_activity); 

Si tiene una referencia a la Actividad requerida o usa el nombre canónico de la Actividad, puede averiguar si está en primer plano o no. Esta solución puede no ser infalible. Por lo tanto, sus comentarios son realmente bienvenidos.

¿Sería útil Activity.onWindowFocusChanged(boolean hasFocus) aquí? Eso, más un indicador de nivel de clase, algo así como que se onWindowFocusChanged conjuntos onWindowFocusChanged , sería una manera fácil de contar en cualquier punto de tu actividad si está enfocado o no. Después de leer los documentos, parece que establecerá correctamente “falso” en cualquier situación donde la actividad no esté directamente en el “primer plano” físico, como si se muestra un cuadro de diálogo o se tira hacia abajo la bandeja de notificaciones.

Ejemplo:

 boolean isFocused; @Override void onWindowFocusChanged (boolean hasFocus) { super.onWindowFocusChanged(hasFocus); isFocused = hasFocus; } void someMethod() { if (isFocused) { // The activity is the foremost object on the screen } else { // The activity is obscured or otherwise not visible } } 

Solía ​​hacer,

si la actividad no está en primer plano

getIntent ()

devolverá nulo. : = P

    Intereting Posts