Android松耦合监听前后台切换框架

应用处于后台满足什么条件

要判断当前应用是否处于后台，有个很简单的标准，当应用处于后台的时候，应用中所有的activity肯定都不处于运行中状态，并且应用所有处于运行中的activity在切后台时肯定会执行onPause方法。因此通过判断应用中所有的activity都不处于运行状态就可以知道当前应用处于后台，当有一个应用或多个activity处于运行状态时应用就处于前台。下面是很经典的activity的生命周期图。

activity和application的关系

由上面可知，要判断一个应用是否处于后台状态，就是要判断应用中所有的activity都不处于运行状态。怎样判断应用中的activity都不处于运行状态呢？由于一个应用只有application，并且这个application是所有activity所公有的。下面由activity和application的关系来看怎么判断应用中的所有activity都不处于运行状态。 下面是Activity在执行时onCreate()时的代码，可知在activity的onCreate中调用了Application的dispatchActivityCreated方法。

 @MainThread
    @CallSuper
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        mFragments.dispatchCreate();
      	getApplication().dispatchActivityCreated(this, savedInstanceState);
    }
复制代码

其实在Activity执行的每个生命周期都会调用Application中相应的方法，对应的关系如下图：

当应用中执行onResume方法的次数和执行onPause的次数一样时，可以判断所有活跃的activity都执行了onPause方法此时应用中所有的activity都不活跃，肯定处于后台。因为每一个activity执行onPause方法的时候都会调用application中的disPatchActivityOnPause方法，执行onResume方法的时候都会调用application中的disPatchActivityOnResume方法，因此可以在这两个方法中进行统计，当两种方法的执行次数相同时此时切应用切后台，当onResume的次数大于onPause的次数1时此时从后台切到前台。

application和ActivityLifecycleCallbacks 关系

由上面可知，要判断application是否处于后台，就要用到application中的disPatchActivityOnPause方法和disPatchActivityOnResume方法，统计这两个方法执行的次数是否相同，下面是application中的dispatchActivityResumed和dispatchActivityPaused方法，由于dispatchActivityResumed和dispatchActivityPaused是package权限的因此我们并不能继承application并且重写dispatchActivityResumed和dispatchActivityPaused方法在dispatchActivityResumed和dispatchActivityPaused方法中进行计数和判断是否切后台。

    /* package */ void dispatchActivityResumed(Activity activity) {
        Object[] callbacks = collectActivityLifecycleCallbacks();
        if (callbacks != null) {
            for (int i=0; i/* package */ void dispatchActivityPaused(Activity activity) {
        Object[] callbacks = collectActivityLifecycleCallbacks();
        if (callbacks != null) {
            for (int i=0; i复制代码

但是在这两个方法中都调用了ActivityLifecycleCallbacks中相应的方法，因此可以从ActivityLifecycleCallbacks和application关系入手处理。查看application中的代码可知，ActivityLifecycleCallbacks 是application中的内部类，下面是ActivityLifecycleCallbacks 中的方法。

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

其中application和ActivityLifecycleCallbacks 的方法的关系如下图：

再看看application和ActivityLifecycleCallbacks的关系，

//将ActivityLifecycleCallbacks 注册到application中
    public void registerActivityLifecycleCallbacks(ActivityLifecycleCallbacks callback) {
        synchronized (mActivityLifecycleCallbacks) {
            mActivityLifecycleCallbacks.add(callback);
        }
    }
//注销注册
    public void unregisterActivityLifecycleCallbacks(ActivityLifecycleCallbacks callback) {
        synchronized (mActivityLifecycleCallbacks) {
            mActivityLifecycleCallbacks.remove(callback);
        }
    }
    
复制代码

由于我们不能直接在application中的方法中进行处理统计，但是根据application和ActivityLifecycleCallbacks 关系，可以自己定义一个ActivityLifecycleCallbacks 然后注册到application中，然后在ActivityLifecycleCallbacks 的方法中进行统计处理判断应用是否切前后台。其中activity和application和ActivityLifecycleCallbacks 三个的关系如下图：

实现前后台切换监听框架

由上面可知，可以通过实现ActivityLifecycleCallbacks接口，并将其注入到application中，根据activity，application，和ActivityLifecycleCallbacks的关系，只要在ActivityLifecycleCallbacks接口中实现相应的判断切换前后台逻辑就可以了。

方法1 判断是否处于前后台

1、实现Application.ActivityLifecycleCallbacks接口中的onActivityPaused和onActivityResumed方法

class Foreground
implements Application.ActivityLifecycleCallbacks {
	private boolean foreground;//是否处于前台
    private static Foreground instance;

    public static void init(Application app){
        if (instance == null){
            instance = new Foreground();
            app.registerActivityLifecycleCallbacks(instance);
        }
    }

    public static Foreground get(){
        return instance;
    }

	public boolean isForeground(){
    return foreground;
	}

	public boolean isBackground(){
    return !foreground;
	}

	public void onActivityPaused(Activity activity){
    foreground = false;
	}

	public void onActivityResumed(Activity activity){
    foreground = true;
	}
}
复制代码

在Foreground类中，通过init方法将Foreground注入到当前的application中，监听application中所有activity的生命周期变化状态。由于判断是否切换前后台只需要在onActivityPaused，和onActivityResumed方法中进行，所以对这两个方法进行重写。 使用方法：在任何一个activity中可以使用：

    Foreground.get(context.getApplication()).isForeground()
复制代码

来判断当前应用是否处于前后台，但是这个方法有两个缺点：

1、只能判断当前应用是否是前后台，但是不能监听到前后台变换，也就是说如果要实时监听前后台变换，是不能的。

2、当用户在进行两个activity切换的时候，在第一个activity执行完onPause方法，而第二个activity还没执行到onResume方法的时候，此时isForeground()方法返回的值是false，但此时应用是处于前台的。

方法2 改进的前后台监听方法

上面的方法1中，存在的第一点问题是应用是否处于前后台需要在代码中实时的获取，不能得到切换前后台变化的通知，因此可以使用监听的方式，往Foreground类中注入监听，当应用切换前后台时遍历注册了监听的类，通知其前后台切换变化。

class Foreground
implements Application.ActivityLifecycleCallbacks {

    public interface Listener {
        public void onBecameForeground();//当应用切前台，调用onBecameForeground()方法
        public void onBecameBackground();//当应用切后台时，调用onBecameBackground()方法
    }

    ...
}

复制代码

在ActivityLifecycleCallbacks 中定义了监听Listener ，和两个方法用于监听切后台和切前台操作。下面提供注册监听和注销监听的方法。

private List listeners =
    new CopyOnWriteArrayList();

public void addListener(Listener listener){
    listeners.add(listener);
}

public void removeListener(Listener listener){
    listeners.remove(listener);
}
复制代码

然后在ActivityLifecycleCallbacks 的onActivityResumed方法和onActivityPaused方法中进行如下处理：

@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);
}

复制代码

在上面的代码中提供了一个paused ，和wasBackground 的bool变量，这两个变量非常重要。

1、wasBackground变量 当有activity执行onResume方法触发了onActivityResumed方法时，此时要先判断应用之前是否处于后台，如果应用处于后台才通知所有的监听此时应用从后台切到了前台。否则如果应用本来就在前台，执行onActivityResumed方法时不能通知所有的监听。

2、paused 变量 前面提到过当两个activity进行切换的时候，一个activity会执行onPause和另一个activity会执行onResume方法，在执行onPause方法和onResume方法之间的间隔里面，应用处于前台，但是isForeground的值此时会是false，所以要对这个时间间隔进行处理，使得在这个间隔内，后台监听不能够回调。 3、handler 由于onPause和onResume执行的时间间隔内可能会出现错误的通知，所以把onPause方法中的通知延后一个时间间隔再执行，延后一个时间间隔后如果此时应用还处于前台并且没执行onActivityResumed方法，此时就通知切后台监听。

注意

虽然在onPause方法中增加了Handler来延时执行切后台监听通知，但是还是存在问题的，比如用户快速切后台并返回，如果在速度在handler延迟的时间间隔之内，此时后台监听是收不到回调的。

完整代码

public class Foreground implements Application.ActivityLifecycleCallbacks {

    public static final long CHECK_DELAY = 500;
    public static final String TAG = Foreground.class.getName();

    public interface Listener {

        void onBecameForeground();

        void onBecameBackground();

    }

    private static Foreground instance;

    private boolean foreground = false, paused = true;
    private Handler handler = new Handler();
    private List listeners = new CopyOnWriteArrayList<>();
    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);
            } else {
                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) {
    }
}
复制代码

使用方法

可以在任何一个activity中注册监听前后台切换监听，并且在回调中进行相应的处理如下：

 public class MainActivity extends AppCompatActivity {
    Foreground.Listener foregroundListener = new Foreground.Listener() {
        @Override
        public void onBecameForeground() {
            Log.d("foreground", "onBecomeForeground");
        }

        @Override
        public void onBecameBackground() {
            Log.d("foreground", "onBecameBackground");
        }
    };

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        Foreground.get(this).addListener(foregroundListener);
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        Foreground.get(this).removeListener(foregroundListener);
    }
}
复制代码

补充

补充1： 切换前后台最重要的是利用了activity和application的生命周期的关系进行的，因为每一个activity执行生命周期函数的时候都会调用到application中对应的方法，所以可以在application中对所有执行过的activity的生命周期函数的执行做一个统计处理，利用这个统计判断应用是否处于前后台。三者的关系图：

补充2：

当时在处理切换前后台时的思路首先想到的是根据application的状态来判断。但是发现application其实并没有提供一个方法来判断应用是否处于前后台。application其实是一个进程然后看下这个进行中有哪些状态。

更简单完美的方法

上面的方法太复杂要根据全部的activity的状态来判断application的状态，Android提供了一个更加方便的方法来监听应用的前后台切换。 使用ProcessLifecycleOwner来处理 ProcessLifecycleOwner会监听application的状态。其中给出的说明如下：

 * It is useful for use cases where you would like to react on your app coming to the foreground or
 * going to the background and you don't need a milliseconds accuracy in receiving lifecycle
 * events.
复制代码

ProcessLifecycleOwner这个类就是专门用来进行监听application的切换前后台状态的。 使用方法 定义ApplicationObserver 方法实现LifecycleObserver 接口，在里面定义onForeground()，和onBackground()方法来处理切换前后台的操作。

static class ApplicationObserver implements LifecycleObserver {
        @OnLifecycleEvent(Lifecycle.Event.ON_START)
        void onForeground() {
            Log.d(TAG, "onForeground!");
        }

        @OnLifecycleEvent(Lifecycle.Event.ON_STOP)
        void onBackground() {
            Log.d(TAG, "onBackground!");
        }
    }
    
复制代码

在要监听的地方加上

ProcessLifecycleOwner.get().getLifecycle().addObserver(new ApplicationObserver());
复制代码

使用的一个完整例子：

public class MainActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        ProcessLifecycleOwner.get().getLifecycle().addObserver(new ApplicationObserver());
        setContentView(R.layout.activity_main);
    }

    class ApplicationObserver implements LifecycleObserver {
        @OnLifecycleEvent(Lifecycle.Event.ON_START)
        void onForeground() {
            Log.d(TAG, "onForeground!");
        }

        @OnLifecycleEvent(Lifecycle.Event.ON_STOP)
        void onBackground() {
            Log.d(TAG, "onBackground!");
        }
    }
}

复制代码

非常简单 注意 使用ProcessLifecycleOwner需要在项目的build.gradle中进行配置：

 implementation "android.arch.lifecycle:extensions:1.1.1"
复制代码

参考文献

1、steveliles.github.io/is_my_andro…

2、developer.android.com/guide/compo…

3、medium.com/@arturogdg/…