Administrar los objetos View y Class <?> Actuales

Tengo una aplicación de utilidad AppUtils, donde puedo publicar la información relevante de la aplicación en cualquier caso:

Ya sea como un SnackBar, cuando estoy en la aplicación
O por medio del gestor de notificaciones

Por ejemplo, cuando los tableses va como Snackbar, necesito la pista del contenedor de visualización visualizado para usarlo en Snackbar.make(view, text, length); Cuando quiero publicar ese mensaje por medio del NotificationManager.notify(int, Builder); Y necesito la firma Clase aquí

 Intent resultIntent = new Intent(this, ResultActivity.class);

Por lo tanto tengo en mi AppUtils:

 public static void setCurrentViewAndClass(View v, Class<?> c) { view = v; // view is static cls = c; // cls is static }

Donde puedo recordar de todas partes en mi proyecto la vista actual (para el parámetro Snackbar) y cls (para la intención de notificación).

Más adelante, borro esos parámetros, por ejemplo, cuando dejo la aplicación al fondo:

 public static void clearCurrentViewAndClass() { view = null; cls = null; }

R. Cuando esos parámetros NO son nulos , sé que mi aplicación tiene el foco con la vista correspondiente y puedo mostrar el mensaje relevante como una Snackbar. B. Cuando estos parámetros son nulos , sé que mi aplicación está en segundo plano y quiero mostrar el mensaje relevante como una Notificación

Por lo tanto, cuando se crea o se reanuda un Fragmento / Actividad, llamo a setClassAndview() en cada onResume() para recordar los parámetros.

¿Hay una manera más elegante de conseguir la pista de la actividad exhibida actual o de la clase activa?

Como ejemplo … crea una clase de aplicación (MyApp) que está registrada en AndroidManifest:

 <application android:name=".MyApp" ...>

En la clase de aplicación MyApp .onCreate () set:

 registerActivityLifecycleCallbacks(new MyAppActivityLifecycleCallbacks());

En MyApp, cree un campo estático que contenga un recuento de actividades visibles y un método para determinar si la aplicación está en primer plano o no:

 private static int mActivityCount = 0; public static boolean isAppInForeground() { return mActivityCount != 0; }

Y, finalmente, configurar su clase ActivityLifecycleCallbacks para mantener la cuenta de las actividades visibles:

 private static final class MyAppActivityLifecycleCallbacks implements ActivityLifecycleCallbacks { public void onActivityCreated(Activity activity, Bundle bundle) { // No operations } public void onActivityDestroyed(Activity activity) { // No operations } public void onActivityPaused(Activity activity) { // No operations } public void onActivityResumed(Activity activity) { // No operations } public void onActivitySaveInstanceState(Activity activity, Bundle outState) { // No operations } public void onActivityStarted(Activity activity) { mActivityCount++; } public void onActivityStopped(Activity activity) { mActivityCount--; } }

Y ahora deberías poder llamar a MyApp.isAppInForeground () para determinar si alguna de tus Actividades está actualmente en primer plano. Si necesita una referencia a la Actividad visible actual, podría manejarla aquí también.

Puede utilizar ActivityManager para obtener la Actividad actual.

Este enlace explica cómo.

Sin embargo, no se puede obtener Fragmento actual ya que puede haber múltiples fragmentos simultáneamente. Puede encontrar el fragmento actual en un ViewGroup específico utilizando FragmentManager.

 getActivity().getFragmentManager().findFragmentById(R.id.fragment_container);

Esto no es precisamente lo que usted pidió, pero puede mejorar en gran medida la capacidad de mantenimiento de su código actual mediante el patrón de bus de eventos . La suscripción a eventos específicos en las vistas, actividades, servicios, etc. interesados le permitirá manejar cualquier cantidad de notificaciones sin rastrear explícitamente a sus receptores.

Esto funciona así:

Suscribirse a eventos en cada componente interesado después de que se inicialice completamente.
Recibir y manejar el evento, opcionalmente cancelar el evento, si el componente piensa, que otros componentes no lo necesitan.
Anular la suscripción cuando el componente ya no necesita eventos (la vista está oculta / separada, el fragmento se destruye, la actividad se cierra / minimiza).

La belleza de este enfoque reside en la flexibilidad – siempre se puede agregar más lógica alrededor de cada evento sin afectar a otros componentes, que se suscriben a ella. Además, puede elegir el mejor momento para suscribirse o anular la suscripción independientemente de cada componente (p. Ej., Las notificaciones se pueden emitir en cualquier momento, pero las barras de aperitivos sólo se mostrarán cuando la actividad sea visible y se reanude).

Existen varias buenas opciones para implementar un bus de eventos en tu aplicación:

Transmisiones globales de Android : las más adecuadas cuando se dispone de varios componentes de alto orden (actividades, servicios, receptores de difusión), interesados en eventos comunes. Puede utilizar las prioridades de filtro de intenciones y las emisiones ordenadas para cancelar el manejo de eventos a mitad de camino.
LocalBroadcastManager. Muerto simple, pocas funciones, pero también fácil de usar con API familiar.
Varias bibliotecas especializadas en autobuses de eventos , elija su favorito.
Varias API, que pueden usarse como buses de eventos, incluso si éste no es su propósito principal: RxJava (recomiendo leer este artículo ), PendingIntents, ContentResolver.notifyUri, etc.