之前公司需求做一款类似滴滴打车派单的app，其中需要app退到后台后能一直上传定位的坐标，当有任务派发时，可以进行语音提醒和dialog弹窗提醒。根据以上的需求，这个需求应用长期在后台定位，必须保证应用是存活的，之前做过一款滑雪测速的项目，也需要后台不停的采集gps坐标。关于应用保活我尝试过过一下几种方案：
- 1.使用aidl双进程守护
- 2.使用系统的alarmmanager机制进行唤醒保活
- 3.提升应用的优先级
- 4.模仿百度导航进行保活
这里的几种方案我测试得出的结论是第四种方案存活时间最长，但不能保证100%的存活率，我使用的是提升service优先级和模仿百度导航来实现的，百度导航如果长期置于后台关屏运行也会被系统干掉
我先说下百度导航的方案和思路，我反复查看了百度导航app在后台运行的效果，发现百度导航在后台播放音频文件，来让系统得知它在运行，提升了应用的优先级，不让系统kill掉它。在不播放路线的时候，它在后台播放无声的音频文件。在得知它的保活方式后，我也开始仿照它的做法来进行实现，发现这样的方式确实可以让应用存活的时间更长，但是这样会比较费电，系统会进行提示高耗电。
首先进入应用我会判断当前状态是否为可接收任务状态，如果可接收则开启service，在后台进行定位，每两秒上传一次定位坐标给后台。直接上代码：
管理是否开启定位服务
public class PollingUtils {
//开启轮询服务
public static void startPollingService(Context context, int seconds, Class<?> cls, String action) {
//获取AlarmManager系统服务
AlarmManager manager = (AlarmManager) context
.getSystemService(Context.ALARM_SERVICE);
//包装需要执行Service的Intent
Intent intent = new Intent(context, cls);
intent.setAction(action);
PendingIntent pendingIntent = PendingIntent.getService(context, 0,
intent, PendingIntent.FLAG_UPDATE_CURRENT);
//触发服务的起始时间
long triggerAtTime = SystemClock.elapsedRealtime();
//使用AlarmManger的setRepeating方法设置定期执行的时间间隔（seconds秒）和需要执行的Service
manager.setRepeating(AlarmManager.ELAPSED_REALTIME_WAKEUP, triggerAtTime,
seconds * 1000, pendingIntent);
}
//停止轮询服务
public static void stopPollingService(Context context, Class<?> cls, String action) {
AlarmManager manager = (AlarmManager) context
.getSystemService(Context.ALARM_SERVICE);
Intent intent = new Intent(context, cls);
intent.setAction(action);
PendingIntent pendingIntent = PendingIntent.getService(context, 0,
intent, PendingIntent.FLAG_UPDATE_CURRENT);
//取消正在执行的服务
manager.cancel(pendingIntent);
context.stopService(intent);
}
}
复制代码定位service
public class CourierLocationService extends BaseService implements AMapLocationListener {
// // 定位相关
// private LocationClient mLocClient;
// //
private int msgId = -1;
private PowerManager.WakeLock wakeLock = null;
private AMapLocation mLocation = null;
private MediaPlayer mediaPlayer = null;
//
// @Override
// public void onCreate() {
// super.onCreate();
// // 定位初始化
//// mLocClient = new LocationClient(this);
//// mLocClient.registerLocationListener(this);
//// LocationClientOption option = new LocationClientOption();
//// option.setIsNeedAddress(true);// 设置以后,请求结果 BDLocation#getCity 就不为null了
//// option.setOpenGps(true);// 打开gps
//// option.setCoorType("bd09ll"); // 设置坐标类型
//// option.setScanSpan(10000);// 定位频率
//// mLocClient.setLocOption(option);
//// mLocClient.start();
// initBaiDu();
// //
// isStarted = true;
// }
//
// @Override
// public int onStartCommand(Intent intent, int flags, int startId) {
// if (intent != null) {
// msgId = intent.getIntExtra("msgId", -1);
// }
// // 刷新定位
// if (mLocClient != null && mLocClient.isStarted()) {
// mLocClient.requestLocation();
// }
// return super.onStartCommand(intent, flags, startId);
// }
//
// /**
// * 初始化百度地图
// */
// private void initBaiDu() {
// // 定位初始化
// mLocClient = new LocationClient(this);
// mLocClient.registerLocationListener(locationListener);
// LocationClientOption option = new LocationClientOption();
// option.setIsNeedAddress(true);// 设置以后,请求结果 BDLocation#getCity 就不为null了
//// option.setOpenGps(true);// 打开gps
// option.setLocationMode(LocationClientOption.LocationMode.Hight_Accuracy);
// option.setCoorType("bd09ll"); // 设置坐标类型
// option.setScanSpan(20000);// 定位频率
// //可选，定位SDK内部是一个service，并放到了独立进程。
// //设置是否在stop的时候杀死这个进程，默认（建议）不杀死，即setIgnoreKillProcess(true)
// option.setIgnoreKillProcess(true);
// mLocClient.setLocOption(option);
// mLocClient.start();
// }
//
// /**
// * 定位SDK监听函数
// */
// LocationListener locationListener = new LocationListener() {
// @Override
// public void onReceiveLocation(BDLocation location) {
// int errorCode = location.getLocType();
// Log.d("33333", "错误码：" + errorCode);
// if (location == null || Str.isEmpty(location.getCity())) {
// // 刷新定位
// if (mLocClient != null) {
// SDKInitializer.initialize(BeeApplication.getContext());
// mLocClient.unRegisterLocationListener(locationListener);
// mLocClient.stop();
// mLocClient = null;
// initBaiDu();
// } else {
// initBaiDu();
// }
// } else {
// Message msg = Message.obtain();
// if (msgId == -1) {
// msg.what = MsgID.location_baidu;
// } else {
// msg.what = msgId;
// if (msgId != MsgID.courier_location_upload_data) {
// msgId = -1;// reset
// }
// }
// msg.obj = location;
// HandlerMgr.sendMessage(msg, 0);
// }
// //
// // int userId = ((BeeApplication) getApplication()).getUser().getId();
// // AppHttp.getInstance().beat(userId, location.getLatitude(), location.getLongitude());
// }
// };
//
// @Override
// public void onDestroy() {
// super.onDestroy();
// msgId = -1;// reset
// mLocClient.unRegisterLocationListener(locationListener);
// // 退出时销毁定位
// mLocClient.stop();
// //
// isStarted = false;
// }
//声明AMapLocationClient类对象
private AMapLocationClient mLocationClient = null;
@Override
public void onCreate() {
super.onCreate();
Notify.getInstance().startForeground(this);
initGaoDe();
}
private void initGaoDe() {
//初始化定位
mLocationClient = new AMapLocationClient(getApplicationContext());
//设置定位回调监听
mLocationClient.setLocationListener(this);
AMapLocationClientOption option = new AMapLocationClientOption();
/**
* 设置定位场景，目前支持三种场景（签到、出行、运动，默认无场景）
*/
option.setLocationPurpose(AMapLocationClientOption.AMapLocationPurpose.Sport);
//设置定位模式为AMapLocationMode.Device_Sensors，仅设备模式。
// option.setLocationMode(AMapLocationClientOption.AMapLocationMode.Device_Sensors);
//获取一次定位结果：
//该方法默认为false。
option.setOnceLocation(false);
//获取最近3s内精度最高的一次定位结果：
//设置setOnceLocationLatest(boolean b)接口为true，启动定位时SDK会返回最近3s内精度最高的一次定位结果。如果设置其为true，setOnceLocation(boolean b)接口也会被设置为true，反之不会，默认为false。
// option.setOnceLocationLatest(true);
//设置定位间隔,单位毫秒,默认为2000ms，最低1000ms。
option.setInterval(10000);
//设置是否返回地址信息（默认返回地址信息）
option.setNeedAddress(true);
//设置是否允许模拟位置,默认为true，允许模拟位置
option.setMockEnable(true);
// option.setGpsFirst(true);
//单位是毫秒，默认30000毫秒，建议超时时间不要低于8000毫秒。
// option.setHttpTimeOut(20000);
//关闭缓存机制
// option.setLocationCacheEnable(false);
if (null != mLocationClient) {
mLocationClient.setLocationOption(option);
//设置场景模式后最好调用一次stop，再调用start以保证场景模式生效
mLocationClient.stopLocation();
mLocationClient.startLocation();
}
}
//
@Override
public int onStartCommand(Intent intent, int flags, int startId) {
if (intent != null) {
msgId = intent.getIntExtra("msgId", -1);
}
flags = START_STICKY;
acquireWakeLock();
// 刷新定位
if (mLocationClient != null && mLocationClient.isStarted()) {
mLocationClient.startLocation();
}
return super.onStartCommand(intent, flags, startId);
}
@Override
public void onLocationChanged(AMapLocation location) {
int errorCode = location.getErrorCode();
// DealTaskService.writerLogToFile("定位的错误码：" + errorCode + ",定位的 MSGID:" + msgId);
Log.d("33333", "错误码：" + errorCode);
if (location == null || Str.isEmpty(location.getCity()) || errorCode != 0) {
mLocationClient.stopLocation();
mLocationClient.startLocation();
} else {
mLocation = location;
}
if (mLocation != null) {
Message msg = Message.obtain();
if (msgId == -1) {
msg.what = MsgID.location_baidu;
} else {
msg.what = msgId;
if (msgId != MsgID.courier_location_upload_data) {
msgId = MsgID.courier_location_upload_data;// reset
}
}
msg.obj = location;
HandlerMgr.sendMessage(msg, 0);
}
//
// int userId = ((BeeApplication) getApplication()).getUser().getId();
// AppHttp.getInstance().beat(userId, location.getLatitude(), location.getLongitude());
}
@Override
public void onDestroy() {
super.onDestroy();
releaseWakeLock();
if (mLocationClient != null) {
mLocationClient.unRegisterLocationListener(this);
mLocationClient.stopLocation();//停止定位后，本地定位服务并不会被销毁
mLocationClient.onDestroy();//销毁定位客户端，同时销毁本地定位服务。
}
pausePlayer();
}
/**
* PARTIAL_WAKE_LOCK:保持CPU 运转，屏幕和键盘灯有可能是关闭的。
* SCREEN_DIM_WAKE_LOCK：保持CPU 运转，允许保持屏幕显示但有可能是灰的，允许关闭键盘灯
* SCREEN_BRIGHT_WAKE_LOCK：保持CPU 运转，允许保持屏幕高亮显示，允许关闭键盘灯
* FULL_WAKE_LOCK：保持CPU 运转，保持屏幕高亮显示，键盘灯也保持亮度
* ACQUIRE_CAUSES_WAKEUP：强制使屏幕亮起，这种锁主要针对一些必须通知用户的操作.
* ON_AFTER_RELEASE：当锁被释放时，保持屏幕亮起一段时间
*/
private void acquireWakeLock() {
if (null == wakeLock) {
PowerManager pm = (PowerManager) getSystemService(Context.POWER_SERVICE);
wakeLock = pm.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK
| PowerManager.ON_AFTER_RELEASE, getClass()
.getCanonicalName());
if (null != wakeLock) {
// Log.i(TAG, "call acquireWakeLock");
Log.d("33333", "call acquireWakeLock");
wakeLock.acquire();
}
}
}
// 释放设备电源锁
private void releaseWakeLock() {
if (null != wakeLock && wakeLock.isHeld()) {
Log.d("33333", "call releaseWakeLock");
// Log.i(TAG, "call releaseWakeLock");
wakeLock.release();
wakeLock = null;
}
}
// /**
// * 设置应用进入后台，播放音频来进行cpu不休眠，进行应用保活
// */
// private void setAppBackgroundPlayer() {
// MediaPlayerUtils.getInstance().playerMusic("courier_silence.mp3", true);
// }
private void pausePlayer() {
MediaPlayerUtils.getInstance().destoryPlayer();
}
}
复制代码后台播放音视频文件工具类
public class MediaPlayerUtils {
private static final String TAG = MediaPlayerUtils.class.getSimpleName();
private static MediaPlayer mediaPlayer = null;
private static MediaPlayerUtils mediaPlayerUtils = null;
private PlayerMediaAsync playerMediaAsync = null;
private boolean isLooping = true;
public static MediaPlayerUtils getInstance() {
if (mediaPlayerUtils == null) {
synchronized (MediaPlayerUtils.class) {
if (mediaPlayerUtils == null) {
mediaPlayerUtils = new MediaPlayerUtils();
mediaPlayer = new MediaPlayer();
}
}
}
return mediaPlayerUtils;
}
public MediaPlayer getMediaPlayer() {
if (mediaPlayer == null) {
mediaPlayer = new MediaPlayer();
}
return mediaPlayer;
}
public synchronized void playerMusic(String fileName, boolean isLooping) {
this.isLooping = isLooping;
if (playerMediaAsync != null) {
playerMediaAsync.cancel(true);
playerMediaAsync = null;
}
playerMediaAsync = new PlayerMediaAsync();
playerMediaAsync.execute(fileName);
}
class PlayerMediaAsync extends AsyncTask<String, String, String> {
@Override
protected String doInBackground(String... params) {
try {
getMediaPlayer();
if (mediaPlayer.isPlaying()) {
mediaPlayer.stop();
mediaPlayer.reset();
}
AssetFileDescriptor fileDescriptor = BeeApplication.getContext().getAssets().openFd(params[0]);
mediaPlayer.setDataSource(fileDescriptor.getFileDescriptor(),
fileDescriptor.getStartOffset(),
fileDescriptor.getLength());
mediaPlayer.setAudioStreamType(AudioManager.STREAM_MUSIC);//STREAM_ALARM
mediaPlayer.prepare();
mediaPlayer.setLooping(isLooping);
mediaPlayer.start();
} catch (Exception e) {
e.printStackTrace();
}
return null;
}
}
public void destoryPlayer() {
if (mediaPlayer != null) {
mediaPlayer.stop();
mediaPlayer.release();
mediaPlayer = null;
}
if (playerMediaAsync != null) {
playerMediaAsync.cancel(true);
playerMediaAsync = null;
}
}
}
复制代码使用定时器进行cpu唤醒
public class TimerService extends Service {
public static final String ACTION = "com.iseastar.guojiang.app.TimerService";
private Timer timer = null;
@Nullable
@Override
public IBinder onBind(Intent intent) {
return null;
}
@Override
public void onCreate() {
super.onCreate();
Notify.getInstance().startForeground(this);
}
@Override
public int onStartCommand(Intent intent, int flags, int startId) {
if (timer == null) {
timer = new Timer(true);
}
timer.schedule(new TimerTask() {
@Override
public void run() {
Log.d("33333", "TimerService：onHandleIntent（）");
Log.d("33333", ActivityMgr.isServiceRunning(BeeApplication.getContext(), "com.iseastar.guojiang.newcabinet.DealTaskService"));
if (!ActivityMgr.isServiceRunning(BeeApplication.getContext(), "com.iseastar.guojiang.newcabinet.DealTaskService")) {
Intent intent = new Intent(getApplication(), DealTaskService.class);
intent.setPackage(getPackageName());
intent.putExtra("isStop", false);
startService(intent);
DealTaskService.startWorkLocation(false);
}
}
}, new Date(), 10000);
flags = START_STICKY;
return super.onStartCommand(intent, flags, startId);
}
@Override
public void onDestroy() {
if (timer != null) {
timer.cancel();
timer = null;
}
super.onDestroy();
}
}
复制代码经过我多次验证，发现使用timer唤醒cpu并不好使，大家可以选择不实用TimerService和PollingUtils这两个类，使用上后效果并不明显。
通过做这个项目，我也思考过一些问题，比如使用websocket长链接，考虑到定位是基于百度或者高德的，也是每隔几秒定位一次，就直接使用了普通的接口。gps定位也不是每秒都定位一次的，并且还容易受到干扰，所以选择了第三方的定位方式，增加定位的准确度。之前我做过一款基于gps定位进行滑雪测速相关项目，对于gps定位进行过一些研究，所以这里不采用手机原始的gps定位。
转载于:https://juejin.im/post/5d076a3c6fb9a07f091ba398