ActivityLifecycleCallbacks简单介绍

ActivityLifecycleCallbacks是干什么的?

• 以往若需监测Activity的生命周期事件代码，你可能是这样做的，重写每一个Acivity的onResume()，然后作统计和处理：
• 或者创建一个BaseActivity,重写onResume().这些都不是很方便,对控制比较分散.
• 这个可以做到集中化管理.

ActivityLifecycleCallbacks怎么用？

• android.app.Application.ActivityLifecycleCallbacks
• 要求API 14+ （Android 4.0+）
• 继承Application
• 在AndroidManifest里起用自定义Application
• <application android:name=".MyApplication"  

• 重写Application的onCreate()方法，或在Application的无参构造方法内，

  调用Application.registerActivityLifecycleCallbacks()方法，并实现ActivityLifecycleCallbacks接口

  
  

  <span style="font-family:microsoft yahei;">public class MyApplication extends Application {
      @Override
      public void onCreate() {
          super.onCreate();
         registerActivityLifecycleCallbacks(MyLifeCycleCallback)
      }
  }

  
  

  //实际的使用可以借鉴下面写法!

  public class MyApplication extends Application {
   
      private static final String TAG = "MyApp";
  
      @Override
      public void onCreate() {
          super.onCreate();
          Foreground.init(this);         
      }
  }

  
  
  //Foreground.class
• //通过这个,以后就可以判断程序是否在运行等操作
  
  

  import android.app.Activity;
  import android.app.Application;
  import android.content.Context;
  import android.os.Bundle;
  import android.os.Handler;
  
  import java.util.List;
  import java.util.concurrent.CopyOnWriteArrayList;
  
  /**
   * Usage:
   * <p/>
   * 1. Get the Foreground Singleton, passing a Context or Application object unless you
   * are sure that the Singleton has definitely already been initialised elsewhere.
   * <p/>
   * 2.a) Perform a direct, synchronous check: Foreground.isForeground() / .isBackground()
   * <p/>
   * or
   * <p/>
   * 2.b) Register to be notified (useful in Service or other non-UI components):
   * <p/>
   * Foreground.Listener myListener = new Foreground.Listener(){
   * public void onBecameForeground(){
   * // ... whatever you want to do
   * }
   * public void onBecameBackground(){
   * // ... whatever you want to do
   * }
   * }
   * <p/>
   * public void onCreate(){
   * super.onCreate();
   * Foreground.get(this).addListener(listener);
   * }
   * <p/>
   * public void onDestroy(){
   * super.onCreate();
   * Foreground.get(this).removeListener(listener);
   * }
   */
  public class Foreground implements Application.ActivityLifecycleCallbacks {
  
      public static final long CHECK_DELAY = 500;
      public static final String TAG = Foreground.class.getName();
      private static Foreground instance;
      private boolean foreground = false, paused = true;
      private Handler handler = new Handler();
      private List<Listener> listeners = new CopyOnWriteArrayList<Listener>();
      private Runnable check;
  
      /**
       * Its not strictly necessary to use this method - _usually_ invoking
       * get with a Context gives us a path to retrieve the Application and
       * initialise, but sometimes (e.g. in test harness) the ApplicationContext
       * is != the Application, and the docs make no guarantees.
       *
       * @param application
       * @return an initialised Foreground instance
       */
      public static Foreground init(Application application) {
          if (instance == null) {
              instance = new Foreground();
              application.registerActivityLifecycleCallbacks(instance);
          }
          return instance;
      }
  
      public static Foreground get(Application application) {
          if (instance == null) {
              init(application);
          }
          return instance;
      }
  
      public static Foreground get(Context ctx) {
          if (instance == null) {
              Context appCtx = ctx.getApplicationContext();
              if (appCtx instanceof Application) {
                  init((Application) appCtx);
              }
              throw new IllegalStateException(
                      "Foreground is not initialised and " +
                              "cannot obtain the Application object");
          }
          return instance;
      }
  
      public static Foreground get() {
          if (instance == null) {
              throw new IllegalStateException(
                      "Foreground is not initialised - invoke " +
                              "at least once with parameterised init/get");
          }
          return instance;
      }
  
      public boolean isForeground() {
          return foreground;
      }
  
      public boolean isBackground() {
          return !foreground;
      }
  
      public void addListener(Listener listener) {
          listeners.add(listener);
      }
  
      public void removeListener(Listener listener) {
          listeners.remove(listener);
      }
  
      @Override
      public void onActivityResumed(Activity activity) {
          paused = false;
          boolean wasBackground = !foreground;
          foreground = true;
  
          if (check != null)
              handler.removeCallbacks(check);
  
          if (wasBackground) {
  //            Log.i(TAG, "went foreground");
              for (Listener l : listeners) {
                  try {
                      l.onBecameForeground();
                  } catch (Exception exc) {
  //                    Log.e(TAG, "Listener threw exception!", exc);
                  }
              }
          } else {
  //            Log.i(TAG, "still foreground");
          }
      }
  
      @Override
      public void onActivityPaused(Activity activity) {
          paused = true;
  
          if (check != null)
              handler.removeCallbacks(check);
  
          handler.postDelayed(check = new Runnable() {
              @Override
              public void run() {
                  if (foreground && paused) {
                      foreground = false;
  //                    Log.i(TAG, "went background");
                      for (Listener l : listeners) {
                          try {
                              l.onBecameBackground();
                          } catch (Exception exc) {
  //                            Log.e(TAG, "Listener threw exception!", exc);
                          }
                      }
                  } else {
  //                    Log.i(TAG, "still foreground");
                  }
              }
          }, CHECK_DELAY);
      }
  
      @Override
      public void onActivityCreated(Activity activity, Bundle savedInstanceState) {
      }
  
      @Override
      public void onActivityStarted(Activity activity) {
      }
  
      @Override
      public void onActivityStopped(Activity activity) {
      }
  
      @Override
      public void onActivitySaveInstanceState(Activity activity, Bundle outState) {
      }
  
      @Override
      public void onActivityDestroyed(Activity activity) {
      }
  
      public interface Listener {
  
          public void onBecameForeground();
  
          public void onBecameBackground();
  
      }
  }