android - programacion - Detecta si una aplicación se inicia/reanuda desde ''afuera'' de la aplicación

se cayo twitter hoy 2018

Question

Actualmente estoy diseñando una función para una aplicación, donde me gustaría un método / enfoque general para detectar si la aplicación se inició o se reanudó desde " fuera " de la aplicación.

'' Afuera '', en este caso, significa:

• la aplicación fue iniciada / reanudada por el ícono del iniciador
• la aplicación se inició / reanudó presionando el ''botón de la aplicación'' desde una barra de navegación / tecla (como en un nexo 7)
• la aplicación se inició / reanudó a partir de una notificación
• la aplicación se inició / reanudó desde ''otro lado''

El caso de uso para esta característica es el siguiente:

• La aplicación tiene una "capacidad multiusuario" que permite a los usuarios crear uno o más perfiles para sus datos
• Un solo perfil puede estar protegido por contraseña / contraseña para ''ocultar'' los datos de otros usuarios de la aplicación u ''ocultar'' datos de otros usuarios del dispositivo donde está instalada la aplicación
  • Si un perfil tiene una contraseña establecida, la aplicación mostrará algún tipo de pantalla de bloqueo para el usuario actual cuando la aplicación se inicie / reanude
    • Si se ingresa correctamente, la aplicación comenzará normalmente mostrando los datos del último perfil seleccionado
    • Si se ingresa incorrectamente, la aplicación comenzará con un perfil ''neutral'' o sin perfil en absoluto

Busqué en la web ideas y encontré publicaciones relevantes solo en stackoverflow:

• ¿Hay alguna forma de distinguir entre una actividad de Android onResume desde la pantalla de inicio?
• Android: detección del lanzamiento de la aplicación desde su hogar o su historial
• Determinar si la aplicación se inició desde la pantalla de inicio

De lo que he leído y aprendido hasta ahora es que una solución parece ser más compleja de lo que pensaba y que no hay una solución lista para usar.

Actualmente estoy pensando en un enfoque basado en el tiempo para implementar esta función:

• establecer una marca de tiempo como una variable miembro de una actividad afectada
• onCreate(Bundle savedInstanceState) -> flag se establece en ''nulo'' antes de verificar el SavedInstanceState Budle para los datos
  • esto detecta un inicio de actividad -> si la contraseña está configurada -> muestra la pantalla de bloqueo
• onSaveInstanceState(Bundle) -> establece el indicador de tiempo en la ''hora actual''
• Si se onCreate(Bundle savedInstanceState) , savedInstanceState contendrá una marca de tiempo
  • calcule una diferencia entre la hora actual y la hora en que se detuvo la aplicación por última vez
  • si esta diferencia está por encima de un cierto umbral, por ejemplo, 30 minutos -> y si la contraseña está configurada -> muestra la pantalla de bloqueo

Tal vez algunos de ustedes ya hayan implementado algo similar o tengan algún aporte a este asunto / enfoque. Me gustaría escuchar tus ideas.

Aclamaciones

Answer 1

Es una pregunta anterior, pero sigue siendo relevante. Hay una solución simple usando ActivityLifeCycleCallbacks. Esta respuesta se deriva de esta publicación de blog de Micahel Bradshaw. Él explica el concepto

La clave está en entender cómo las actividades se coordinan entre sí. Al cambiar entre las actividades A y B, sus métodos se llaman en este orden:

A.onPause();

B.onCreate();

B.onStart();

B.onResume(); (La actividad B ahora tiene foco de usuario)

A.onStop(); (si la actividad A ya no es visible en la pantalla)

Solución: crea una clase que implementa la interfaz Application.ActivityLifecycleCallbacks y lleva el recuento de las actividades reanudadas y detenidas.

public class AppLifecycleHelper implements Application.ActivityLifecycleCallbacks {

// I use two separate variables here. You can, of course, just use one and
// increment/decrement it instead of using two and incrementing both.
private static int resumed;
private static int stopped;

    public void onActivityCreated(Activity activity, Bundle savedInstanceState) {
    }

    public void onActivityDestroyed(Activity activity) {
    }

    public void onActivityResumed(Activity activity) {
        ++resumed;
    }

    public void onActivityPaused(Activity activity) {
    }

    public void onActivitySaveInstanceState(Activity activity, Bundle     outState) {
    }

    public void onActivityStarted(Activity activity) {
        if (!isApplicationInForeground()){
            // resumed and stopped both are 0,
            // that means it is the first activity to come on display
            // i.e. App is launched from outside the app
        }
    }

    public void onActivityStopped(Activity activity) {
        ++stopped;
        if (!isApplicationInForeground()){
            // resumed and stopped both are 0
            // That means there is NO Activity in resumed state when this activity stopped
            // i.e. User came out of the App, perform all Application wide persistence tasks over here
        }
    }

    /**
     * Checks whether App is visible to the user or not
     * @return true if visible and false otherwise
     */
    public static boolean isApplicationInForeground() {
        return resumed > stopped;
    }

}

Y luego en la aplicación onCreate () registra esta clase para devolución de llamadas de actividad como esta

registerActivityLifecycleCallbacks(new AppLifecycleHelper());

¡y eso es! No es necesario agregar ningún código a cada actividad. Todo está contenido en AppLifecycleHelper con solo unas pocas líneas de código.