配置文件

public class MpaasConfigs {
    /*ActivityLifecycle*/
    public static final int ON_FORNTGROUND = 0;
    public static final int ON_BACKGROUND = 1;
    public static final int ON_CHANGE = 2;
    public static final int ON_ACTIVITY_CREATED = 3;
    public static final int ON_ACTIVITY_PAUSED = 4;
    public static final int ON_ACTIVITY_RESUMED = 5;
    public static final int ON_ACTIVITY_STARTED = 6;
    public static final int ON_ACTIVITY_STOPED = 7;
    public static final int ON_APP_FORNTGROUND = 8;
    public static final int ON_APP_BACKGROUND = 9;
    public static final long CHECK_DELAY = 600;
}

被观察者

 /* 说明:生命周期监控类 单例模式 观察者模式
 * java.util.Observable
 * Observable就是可以被观察的，程序中的被观察者类，需要继承这个类。
1.当onActivityResumed()被调用时表示app处于前台通知观察者
2.在onActivityStart调用时activityCount++
3.在onActivityStop调用时activityCount--并判断activityCount是否等于0，是的话说明app处于后台，通知观察者
因为被观察者是单例,为了防止保存activity信息出现内存泄漏情况，使用weakReference弱引用保存
 * ******************************
 */

public class ApplicationLifecycleObservable extends Observable implements Application.ActivityLifecycleCallbacks {

    //activity事件回调需要在ui线程中操作
    private Handler mMainHandler = null;
    private Activity mCurrentActivity = null;
    private int activityCount = 0;
    private boolean mIsPaused = false;
    private boolean mIsForeground = false;
    private String mCurActivityHash = null;
    private Runnable mCheckRunnable = null;

    private ApplicationLifecycleObservable() {
    }

    private static class ApplicationLifecycleObservableHolder {
        private static ApplicationLifecycleObservable INSTANCE = new ApplicationLifecycleObservable();
    }

    public static ApplicationLifecycleObservable getInstance() {
        return ApplicationLifecycleObservableHolder.INSTANCE;
    }

    public void initApplication(Application application){
        if(application != null){
            application.unregisterActivityLifecycleCallbacks(this);
            application.registerActivityLifecycleCallbacks(this);
        }

        mMainHandler = new Handler(Looper.getMainLooper());
    }

    @Override
    public void onActivityCreated(@NonNull Activity activity, @Nullable Bundle savedInstanceState) {
        Log.d("ApplicationLifecycleObservable  -->  onActivityCreated  Lifecycle : " + System.currentTimeMillis() +"   activity name   "+activity.getLocalClassName());
        this.mCurrentActivity = activity;
        notifyObservers(MpaasConfigs.ON_ACTIVITY_CREATED);
    }

    @Override
    public void onActivityStarted(@NonNull Activity activity) {
        Log.d("ApplicationLifecycleObservable  -->  onActivityStarted  Lifecycle : " + System.currentTimeMillis() +"   activity name   "+activity.getLocalClassName());
        this.mCurrentActivity = activity;
        notifyObservers(MpaasConfigs.ON_ACTIVITY_STARTED);
        if(activityCount == 0){
            Log.d("ApplicationLifecycleObservable  -->  Lifecycle >>>>>>>>>>>>>>>>>>> APP  Foreground");
            notifyObservers(MpaasConfigs.ON_APP_FORNTGROUND);
        }
        activityCount++;
    }

    @Override
    public void onActivityResumed(@NonNull Activity activity) {
        Log.d("ApplicationLifecycleObservable  -->  onActivityResumed  Lifecycle : " + System.currentTimeMillis() +"   activity name   "+activity.getLocalClassName());
        this.mCurrentActivity = activity;
        notifyObservers(MpaasConfigs.ON_ACTIVITY_RESUMED);
        mIsPaused = false;
        boolean wasBackground = !mIsForeground;
        mIsForeground = true;
        String activityHash = getActivityHash(activity);
        if(!activityHash.equals(mCurActivityHash)){
            notifyObservers(MpaasConfigs.ON_CHANGE);
            mCurActivityHash = activityHash;
        }

        final WeakReference<Activity> mActivityWeakReference = new WeakReference<>(activity);

        //通知用户应用到达前台, 延迟600ms
        mMainHandler.postDelayed(mCheckRunnable = new Runnable() {
            @Override
            public void run() {
                //如果应用之前在后台状态则通知应用已经到达前台
                if(wasBackground){
                    Activity ac = mActivityWeakReference.get();
                    if(null == ac){
                        Log.d("ApplicationLifecycleObservable  -->  onFront activity is null!");
                        return;
                    }
                    notifyObservers(MpaasConfigs.ON_FORNTGROUND);
                }
            }
        },MpaasConfigs.CHECK_DELAY);
    }

    @Override
    public void onActivityPaused(@NonNull Activity activity) {
        Log.d("ApplicationLifecycleObservable  -->  onActivityPaused  Lifecycle : " + System.currentTimeMillis() +"   activity name   "+activity.getLocalClassName());
        this.mCurrentActivity = activity;
        notifyObservers(MpaasConfigs.ON_ACTIVITY_PAUSED);
        mIsPaused = true;
        if(mCheckRunnable != null){
            mMainHandler.removeCallbacks(mCheckRunnable);
        }
        final WeakReference<Activity> mActivityWeakReference = new WeakReference<>(activity);
        mMainHandler.postDelayed(mCheckRunnable = new Runnable() {
            @Override
            public void run() {
                if(mIsForeground && mIsPaused){
                    mIsForeground = false;
                    Activity ac = mActivityWeakReference.get();
                    if(null == ac){
                        Log.d("ApplicationLifecycleObservable  -->  onBackground activity is null!");
                        return;
                    }
                    notifyObservers(MpaasConfigs.ON_BACKGROUND);
                }
            }
        },MpaasConfigs.CHECK_DELAY);
    }

    @Override
    public void onActivityStopped(@NonNull Activity activity) {
        Log.d("ApplicationLifecycleObservable  -->  onActivityStopped  Lifecycle : " + System.currentTimeMillis() +"   activity name   "+activity.getLocalClassName());
        this.mCurrentActivity = activity;
        notifyObservers(MpaasConfigs.ON_ACTIVITY_STOPED);
        activityCount--;
        if(activityCount == 0){
            Log.d("ApplicationLifecycleObservable  -->  >>>>>>>>>>>>>>>>>>> APP  Background ");
            notifyObservers(MpaasConfigs.ON_APP_BACKGROUND);
        }
    }

    @Override
    public void onActivitySaveInstanceState(@NonNull Activity activity, @NonNull Bundle outState) {

    }

    @Override
    public void onActivityDestroyed(@NonNull Activity activity) {
        Log.d("ApplicationLifecycleObservable  -->  onActivityDestroyed  Lifecycle : " + System.currentTimeMillis() +"   activity name   "+activity.getLocalClassName());
        if(getActivityHash(activity).equals(mCurActivityHash)) {
            mCurActivityHash = null;
        }

        this.mCurrentActivity = null;
    }

    @Override
    public void notifyObservers(Object arg) {
        setChanged();
        super.notifyObservers(arg);
    }

    private String getActivityHash(Activity activity){
        return activity.getClass().getName() + activity.hashCode();
    }

    public Activity getmCurrentActivity() {
        return mCurrentActivity;
    }

观察者

/**
 * 说明:java.util.Observer
 * 这个是观察者，是接口。程序中的观察者类，需要实现这个接口中的update()方法。
 * 这个是观察者base类
 * ******************************
 */

public class BaseLifecycleObserver implements Observer {

    public void onActivityFrontground(Activity activity) {

    }

    public void onActivityBackground(Activity activity) {

    }

    public void onChange(Activity activity) {

    }

    void onActivityCreated(Activity activity) {

    }

    void onActivityStarted(Activity activity) {

    }

    void onActivityResumed(Activity activity) {

    }

    void onActivityPaused(Activity activity) {

    }

    void onActivityStopped(Activity activity) {

    }

    public void onAppForeground() {

    }

    public void onAppBackground() {

    }

    @Override
    public void update(Observable o, Object arg) {
        try {
            ApplicationLifecycleObservable observable = (ApplicationLifecycleObservable) o;
            int index = (int) arg;
            Activity activity = observable.getmCurrentActivity();
            switch (index) {
                case MpaasConfigs.ON_FORNTGROUND:
                    if(activity != null){
                        onActivityFrontground(activity);
                    }
                    break;
                case MpaasConfigs.ON_BACKGROUND:
                    if(activity != null){
                        onActivityBackground(activity);
                    }
                    break;
                case MpaasConfigs.ON_CHANGE:
                    if(activity != null){
                        onChange(activity);
                    }
                    break;
                case MpaasConfigs.ON_ACTIVITY_CREATED:
                    if(activity != null){
                        onActivityCreated(activity);
                    }
                    break;
                case MpaasConfigs.ON_ACTIVITY_PAUSED:
                    if(activity != null){
                        onActivityPaused(activity);
                    }
                    break;
                case MpaasConfigs.ON_ACTIVITY_RESUMED:
                    if(activity != null){
                        onActivityResumed(activity);
                    }
                    break;
                case MpaasConfigs.ON_ACTIVITY_STARTED:
                    if(activity != null){
                        onActivityStarted(activity);
                    }
                    break;
                case MpaasConfigs.ON_ACTIVITY_STOPED:
                    if(activity != null){
                        onActivityStopped(activity);
                    }
                    break;
                case MpaasConfigs.ON_APP_FORNTGROUND:
                    if(activity != null){
                        onAppForeground();
                    }
                    break;
                case MpaasConfigs.ON_APP_BACKGROUND:
                    if(activity != null){
                        onAppBackground();
                    }
                    break;
                default:
                    break;
            }
        } catch (Throwable throwable) {
            throwable.printStackTrace();
        }
    }
}

AppForegroundMonitor

public class AppForegroundMonitor extends BaseLifecycleObserver {

    private static AppForegroundMonitor appForegroundMonitor;

    private AppForegroundMonitor() {}

    public static AppForegroundMonitor getInstance() {
        if (appForegroundMonitor == null) {
            synchronized (AppForegroundMonitor.class) {
                if (appForegroundMonitor == null) {
                    appForegroundMonitor = new AppForegroundMonitor();
                }
            }
        }

        return appForegroundMonitor;
    }

    private long appForegroundTime;

    @Override
    public void onAppForeground() {
        appForegroundTime =  SystemClock.elapsedRealtime();
    }

    @Override
    public void onAppBackground() {
        if (appForegroundTime == 0) return;
        //app在前台停留的时间
        long appForegroundStayTime = SystemClock.elapsedRealtime() - appForegroundTime;
        appForegroundTime = 0;
 
        if (appForegroundStayTime <= 0) return;
        //根据上传策略进行上报
    }
}

使用

// 初始化生命周期监听类
 ApplicationLifecycleObservable.init(app);

 // 应用前台时长统计 添加观察者
ApplicationLifecycleObservable.getInstance().addObserver(AppForegroundMonitor.getInstance());