java - tipos - ciclo de vida de una aplicacion android ejemplo

¿Registrar automáticamente los eventos del ciclo de vida de Android usando ActivityLifecycleCallbacks?

Question

Estoy tratando de capturar y registrar automáticamente los eventos del ciclo de vida de Android usando ActivityLifecycleCallbacks, sin embargo, la documentación sobre este asunto es escasa, por decir lo menos:

    public void registerActivityLifecycleCallbacks (Application.ActivityLifecycleCallbacks callback)

No quiero tener que extender la clase de actividad o anular los métodos de ciclo de vida existentes (onCreate, onResume, etc.). Busco tener una clase separada para escuchar estos eventos y actuar en consecuencia.

¿Alguien tiene alguna experiencia en esto, o tiene enlaces a buena documentación sólida o tutoriales sobre cómo funciona esto? Específicamente, ¿cómo registrarse para ActivityLifecycleCallbacks y cómo manejarlos?

Answer 1

Hice mi propia implementación de Application.ActivityLifecycleCallbacks . Estoy usando SherlockActivity , pero para la clase de actividad normal podría funcionar.

Primero, estoy creando una interfaz que tiene todos los métodos para rastrear el ciclo de vida de las actividades:

public interface ActivityLifecycleCallbacks{
    public void onActivityStopped(Activity activity);
    public void onActivityStarted(Activity activity);
    public void onActivitySaveInstanceState(Activity activity, Bundle outState);
    public void onActivityResumed(Activity activity);
    public void onActivityPaused(Activity activity);
    public void onActivityDestroyed(Activity activity);
    public void onActivityCreated(Activity activity, Bundle savedInstanceState);
}

Segundo, implementé esta interfaz en la clase de mi aplicación:

public class MyApplication extends Application implements my.package.ActivityLifecycleCallbacks{

    @Override
    public void onCreate() {
        super.onCreate();           
    }

    @Override
    public void onActivityStopped(Activity activity) {
        Log.i("Tracking Activity Stopped", activity.getLocalClassName());

    }

    @Override
    public void onActivityStarted(Activity activity) {
        Log.i("Tracking Activity Started", activity.getLocalClassName());

    }

    @Override
    public void onActivitySaveInstanceState(Activity activity, Bundle outState) {
        Log.i("Tracking Activity SaveInstanceState", activity.getLocalClassName());
    }

    @Override
    public void onActivityResumed(Activity activity) {
        Log.i("Tracking Activity Resumed", activity.getLocalClassName());
    }

    @Override
    public void onActivityPaused(Activity activity) {
        Log.i("Tracking Activity Paused", activity.getLocalClassName());
    }

    @Override
    public void onActivityDestroyed(Activity activity) {
        Log.i("Tracking Activity Destroyed", activity.getLocalClassName());
    }

    @Override
    public void onActivityCreated(Activity activity, Bundle savedInstanceState) {
        Log.i("Tracking Activity Created", activity.getLocalClassName());
    }
}

Tercero, estoy creando una clase que se extiende desde SherlockActivity:

public class MySherlockActivity extends SherlockActivity {

    protected MyApplication nMyApplication;

    protected void onCreate(Bundle savedInstanceState) {
        // TODO Auto-generated method stub
        super.onCreate(savedInstanceState);
        nMyApplication = (MyApplication) getApplication();
        nMyApplication.onActivityCreated(this, savedInstanceState);
    }

    protected void onResume() {
        // TODO Auto-generated method stub
        nMyApplication.onActivityResumed(this);
        super.onResume();

    }

    @Override
    protected void onPause() {
        // TODO Auto-generated method stub
        nMyApplication.onActivityPaused(this);
        super.onPause();
    }

    @Override
    protected void onDestroy() {
        // TODO Auto-generated method stub
        nMyApplication.onActivityDestroyed(this);
        super.onDestroy();
    }

    @Override
    protected void onStart() {
        nMyApplication.onActivityStarted(this);
        super.onStart();
    }

    @Override
    protected void onStop() {
        nMyApplication.onActivityStopped(this);
        super.onStop();
    }

    @Override
    protected void onSaveInstanceState(Bundle outState) {
        nMyApplication.onActivitySaveInstanceState(this, outState);
        super.onSaveInstanceState(outState);
    }   
}

Cuarto, todas las clases que se extienden desde SherlockActivity, reemplazé por MySherlockActivity:

public class MainActivity extends MySherlockActivity{

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
    }

}

Ahora, en el logcat verá los registros programados en la implementación de la interfaz realizada en MyApplication.

ACTUALIZAR

Esta implementación fue probada desde el nivel de API 9 (Gingerbread), el nivel de API 12 (Honeycomb) y el nivel de API 17 (Jelly Bean) y funciona bien. Podría funcionar en versiones anteriores de Android.

Answer 2

No tengo ninguna experiencia de primera mano, pero a juzgar por la API, puede escribir su propia clase que implementa la interfaz Application.ActivityLifecycleCallbacks y registrar esa clase en la instancia de clase de Application proporcionada.

getApplicaton().registerActivityLifecycleCallbacks(yourCustomClass);

Esta clase recibirá las mismas devoluciones de llamada que sus actividades individuales. Buena suerte.

PD. Esto es API de nivel 14 por cierto, por lo que no funcionará en teléfonos más antiguos.

Answer 3

Pruebe esto: http://engineering.meetme.com/2015/04/android-determine-when-app-is-opened-or-closed/#comment-202

Propone un AppForegroundStateManager al que cada actividad informa a través de sus onStop() y onStart() siguiente manera:

@Override
protected void onStart() {
    super.onStart();
    AppForegroundStateManager.getInstance().onActivityVisible(this);
}

@Override
protected void onStop() {
    AppForegroundStateManager.getInstance().onActivityNotVisible(this);
    super.onStop();
}

Su clase de Application implementa un oyente como este:

public class MyApplication extends Application {
    @Override
    public void onCreate() {
        super.onCreate();
        AppForegroundStateManager.getInstance().addListener(this);
    }

    @Override
    public void onAppForegroundStateChange(AppForegroundStateManager.AppForegroundState newState) {
        if (AppForegroundStateManager.AppForegroundState.IN_FOREGROUND.equals(newState)) {
            // App just entered the foreground. Do something here!
            Log.i(TAG, "App Just Entered the Foreground with launch mechanism of: " + mLaunchMechanism);
        } else {
            // App just entered the background. Set our launch mode back to the default of direct.
            mLaunchMechanism = LaunchMechanism.DIRECT;
        }
    }
}

También incluye consejos y trucos para determinar cómo se abrió la aplicación: desde una notificación, una URL que abre su aplicación o directamente desde el menú Aplicaciones. Esto se hace a través de un Enum en la clase de aplicación:

public enum LaunchMechanism {
    DIRECT,
    NOTIFICATION,
    URL,
    BACKGROUND
}

private LaunchMechanism mLaunchMechanism = LaunchMechanism.DIRECT;

public void setLaunchMechanism(LaunchMechanism launchMechanism) {
    mLaunchMechanism = launchMechanism;
}

En nuestra implementación de esto, tenemos indicadores para cuando iniciamos una actividad que iniciará una actividad de terceros, como si el usuario realiza una llamada telefónica desde nuestra aplicación o si se inicia un navegador. En el onStop() la actividad de lanzamiento, hacemos una comprobación como esta para informar únicamente la no visibilidad de la actividad cuando esas banderas son falsas:

if(!flag_userLaunchedThirdPartyActivity){
     AppForegroundStateManager.getInstance().onActivityNotVisible(this);
     }

Para verificar si la aplicación entra o no en segundo plano, por ejemplo, cuando la pantalla del dispositivo se oscurece o el usuario recibe una llamada telefónica, funciona así:

public static boolean isApplicationGoingToBackground(final Context context) {

    ActivityManager am = (ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE);
    List<RunningTaskInfo> tasks = am.getRunningTasks(1);
    if (!tasks.isEmpty()) {
        ComponentName topActivity = tasks.get(0).topActivity;
        if (!topActivity.getPackageName().equals(context.getPackageName())) {
            setLaunchMechanism(LaunchMechanism.BACKGROUND);
            return true;
        }
    }

    setLaunchMechanism(LaunchMechanism.DIRECT);
    return false;
}

Esta solución no depende de un nivel de API, por lo que debería funcionar hasta el nivel 1 de API.

Answer 4

@Override
public void onCreate() {
    super.onCreate();
    registerActivityLifecycleCallbacks(MyApplication.this/*(Your Application Name)*/);

// registerActivityLifecycleCallbacks (MyApplication.this / (Nombre de su aplicación) / // solo agregar esta línea en la clase de aplicación funciona bien

}