android中会使用很多监听本应用是处于前台还是后台的场景,接下来我介绍两种,不需要权限申请的。
第一种:使用ActivityManager,获取手机应用的所有进程,筛选出自己本应用的,根据importance来判断是否处于后台。
/**
* 判断当前程序是否在前台
*
* @param context
* @return
*/
public static boolean isAppOnForeground(Context context) {
ActivityManager activityManager = (ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE);
List<RunningAppProcessInfo> appProcesses = activityManager.getRunningAppProcesses();
if (appProcesses == null || appProcesses.size() <= 0) {
return true;
}
for (RunningAppProcessInfo appProcess : appProcesses) {
if (appProcess == null) {
PLog.w("getProcess == null");
return true;
} else if (appProcess.processName.equals(context.getPackageName())) {
PLog.i("isAppOnForeground importance = " + appProcess.importance);
return appProcess.importance == RunningAppProcessInfo.IMPORTANCE_FOREGROUND || appProcess.importance == RunningAppProcessInfo.IMPORTANCE_VISIBLE;
}
}
return false;
}
第二种:由前面那种也能看出来,有很多地方要进行异常处理,这样在某些情况下,获取到的前后台应用并不准确,所以我推荐第二种方法。本方法使用的是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);
}
使用的是activity的声明周期。接下来先上代码:
package com.example.testandroidmethod.utils;
import java.util.List;
import java.util.concurrent.CopyOnWriteArrayList;
import android.app.Activity;
import android.app.Application;
import android.content.Context;
import android.os.Bundle;
import android.os.Handler;
import android.os.HandlerThread;
import com.example.testandroidmethod.PLog;
/**
* 监听前台后台应用的方法
* @author boshuai.li
* @date 创建时间:2018-7-10 上午10:09:37
* @describe
*/
public class ForegroundCallbacks implements Application.ActivityLifecycleCallbacks {
public static final long CHECK_DELAY = 500;
public static final String TAG = ForegroundCallbacks.class.getName();
public interface Listener {
public void onBecameForeground();
public void onBecameBackground();
}
private static ForegroundCallbacks instance;
/**
* 默认启动时在前台
*/
private boolean foreground = true, paused = false;
private static Handler handler = null;
private List<Listener> listeners = new CopyOnWriteArrayList<Listener>();
private Runnable check;
/**
* 可使用context强转Application
* @param application
* @return
*/
public static ForegroundCallbacks init(Application application) {
if (instance == null) {
instance = new ForegroundCallbacks();
application.registerActivityLifecycleCallbacks(instance);
HandlerThread handlerThread = new HandlerThread("thread_foregroundcallbacks");
handlerThread.start();
handler = new Handler(handlerThread.getLooper());
}
return instance;
}
public static void uninit(Application application) {
if (instance != null) {
application.unregisterActivityLifecycleCallbacks(instance);
instance = null;
}
}
public static ForegroundCallbacks get(Application application) {
if (instance == null) {
init(application);
}
return instance;
}
public static ForegroundCallbacks 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 ForegroundCallbacks 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) {
PLog.i("onActivityResumed activity =" + activity);
paused = false;
boolean wasBackground = !foreground;
foreground = true;
if (check != null)
handler.removeCallbacks(check);
if (wasBackground) {
PLog.e("went foreground");
handler.post(new Runnable() {
@Override
public void run() {
for (Listener l : listeners) {
try {
l.onBecameForeground();
} catch (Exception exc) {
PLog.e("Listener threw exception!", exc);
}
}
}
});
} else {
PLog.e("still foreground");
}
}
@Override
public void onActivityPaused(Activity activity) {
PLog.i("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;
PLog.e("went background");
for (Listener l : listeners) {
try {
l.onBecameBackground();
} catch (Exception exc) {
PLog.e("Listener threw exception!", exc);
}
}
} else {
PLog.e("still foreground");
}
}
}, CHECK_DELAY);
}
@Override
public void onActivityCreated(Activity activity, Bundle savedInstanceState) {
PLog.i("onActivityCreated activity =" + activity);
}
@Override
public void onActivityStarted(Activity activity) {
PLog.i("onActivityStarted activity =" + activity);
}
@Override
public void onActivityStopped(Activity activity) {
PLog.i("onActivityStopped activity =" + activity);
}
@Override
public void onActivitySaveInstanceState(Activity activity, Bundle outState) {
PLog.i("onActivitySaveInstanceState activity =" + activity);
}
@Override
public void onActivityDestroyed(Activity activity) {
PLog.i("onActivityDestroyed activity =" + activity);
}
}
测试方法:
private void testIsForegroundApp() {
final ForegroundCallbacks foregroundCallbacks = ForegroundCallbacks.get(this.getApplication());
Timer timer = new Timer();
TimerTask task = new TimerTask() {
@Override
public void run() {
boolean isForeground = foregroundCallbacks.isForeground();
if (isForeground) {
PLog.i("当前是在前台");
} else {
PLog.i("当前是在后台");
}
}
};
timer.schedule(task, 0, 1000L);
}
由于本方法使用的是activity的生命周期,所以判断比较准确,但是如果要判断当前顶端正在使用的是那个应用,那还是别想了,现在很多机型都做了限制,在一些机子上还是可以用一些方法获取的,以上就是全部。