探讨一种新型的双进程守护应用保活方法

 

作者：	蒋东国
时间：	2016年12月5日 星期一
应用来源：	lcb APP    (测试机型：华为荣耀4X)
博客地址：	http://blog.csdn.NET/andrexpert/article/details/53485360

      

       情景再现：“在高版本Android系统中，应用能否常驻内存，我想一直以来都是某些APP头疼的事情。虽然APP常驻内存对于用户来说比较”恶心”，但是在一些特殊情况来说，APP的常驻内存却有尤其重要，很多时候用户也会要求APP能够保证长久运行。因此，这里只研究APP应用在一些特殊场合的保活方法，内容仅供参考。”

1. 浅析常见应用保活方法

(1)  监听广播方式

    通过监听一些全局的静态广播，比如开机广播、解锁屏广播、网络状态广播等，来启动应用的后台服务。目前，在高版本的Android系统中已经失效，因为高版本的Android系统规定应用必须在系统开机后运行一次才能监听这些系统广播，一般而言，应用被系统杀死后，基本无法接收系统广播。

(2) 提高Service的优先级

    以前提高Service优先级方法很多，比如onStartCommand返回START_STICKY使系统内存足够的时候Service能够自动启动、弹出通知、配置service的优先级等，这些方式只能在一定程度上缓解service被立马回收，但只要用户一键清理或者系统回收照样无效。

(3) 全局定时器

     还有一种方法就是在设置一种全局定时器，定时检测启动后台服务，但这种方法目前也已经无效，因为应用只要被系统杀死，全局定时器最后也只成了摆设。

(4) 应用中的双service拉起

    经过测试，只要当前应用被杀，任何后台service都无法运行，也无法自行启动。

(5) 应用中的双进程拉起

     这种方式就是传说中的使用NDK在底层fork出一个子进程，来实现与父进程之间的互拉。在Android4.x还是非常有效的，但是高版本的Android系统的系统回收策略已经改成进程组的形式了，如果系统要回收一个应用，必然会杀死同属于一个进程组的所有进程，因此最后导致双进程无法拉起。 

2、 新型双进程守护应用保活原理

(1)  Service特征剖析

      Service的特征类似于Activity，其区别是它没有交互界面，且可长时间运行在后台，即使它所属的应用已经退出，Service仍然可以继续在后台运行。Service无法自行启动，访问者启动它的方式分为两种，即startService(绑定式)和bindService (非绑定式)，相关介绍如下：

    * startService：即非绑定式。访问者使用这种方式启动service后，被启动的service将不受访问者控制，也无法与访问者进行数据通信，它会无限地运行下去，必须调用stopSelf()方法或者其他组件(包括访问者)调用stopService()方法来停止。它的生命周期：onCreate->onStartCommand()->……>onDestory()，其中，onCreate用于初始化工作，多次调用startService启动同一个服务，onCreate方法只会被调用一次，onStartCommand会被调用多次，onDestory在销毁时也只会被调用一次。

    * bindService：即绑定式。访问者使用这种方式启动service后，被启动的service受访问者的控制，访问者将通过一个IBinder接口的对象与被绑定的service进行通信，并且可以通过unbindService()方法随时关闭service。一个service可以同时被多个访问者绑定，只有当多个访问者都主动解除绑定关系之后，系统才会销毁service。它的生命周期：onCreate->onBind->....>onUnbind->onDestory，其中，onBind用于返回一个通信对象(IBinder)给访问者，访问者可以通过该IBinder对象调用service的相关方法。当多个访问者绑定同一个service时，onCreate只会被调用一次，onBind、unOnbind方法会被调用与访问者数目相关的次数，onDestory在销毁时只会被调用一次。

     有一点需要注意的是：如果一个service被startService启动，然后其他组件再执行bindService绑定该service，service的onCreate不会再被回调，而是直接回调onBind方法；当该组件unBindService时，service的onUnbind方法被回调，但是service不会被销毁，直到自己调用stopSelf方法或者其他组件调用stopService方法时才会被销毁。
(1)  AIDL和远程Service调用
    bindService绑定方式启动service分为两种：本地service和远程service。本地service是指绑定启动的service实现在它所属的应用进程中，其他组件访问者与本地service之间的通信是通过IBinder接口对象实现的；远程service是指绑定启动的service实现在其他应用进程中，也就是另一个APP中，他们之间的通信则是通过IBinder接口的代理对象实现的，而这个代理对象必须通过AIDL方式来构造。
     AIDL(Android Interface DefinitionLanguage，接口描述语言)使用用于约束两个进程之间通讯的规则，可以实现Android终端上两个不同应用(进程)之间的通信(IPC)。AIDL实现的步骤非常简单，阐述如下：
      a) 在A应用创建IPerson.aidl接口文件(注意AIDL语言的编写规则，这里不详解)；
      b) 将创建的IPerson.aidl接口文件拷贝到B应用中；

[java] view plain copy

1. packagecom.person.aidl  
2. interfaceIPerson{  
3.        String getName();  
4.        int getAge();  
5. }  

       然后，我们只需要保存.aidl文件，编译器就会自动生成所需的IPerson.Java文件，保存在gen目录下，该文件包含一个内部类IPerson.Stub，它实际上继承于Binder对象，即充当通信所需的IBinder代理对象。这里有几点需要注意，将会影响两进程之间是否能够通讯成功：

      ※ 接口名与aidl文件名相同

     ※ 应用A、应用B中的.aidl文件必须相同，并且它们所属的包名也必须要一样；

(2)  单进程守护

     我们先分析一下绑定方式启动Service流程，以路痴宝中的守护Service启动保活助手A的守护Service为例：当路痴宝中的Service通过bindService绑定保活助手A的Service时，保活助手A会回调onBind方法返回一个IPerson.Stub的代理对象给路痴宝，当路痴宝Service中的onServiceConnected被回调时，说明路痴宝绑定保活助手A的Service成功。当解绑时，路痴宝中的onServiceDisconnected和保活助手A中的onUnbind被调用。

     有了前面的基础，接下来就分析如何在不同的应用进程中创建守护service，通过检测彼此的绑定情况来唤醒彼此。当路痴宝绑定保活助手A时(浅绿色字体)，如果保活助手A被系统杀死，路痴宝的onServiceDisConnected被回调，我们可以在该方法中执行bindService方法再次尝试绑定唤醒保活助手A；当保活助手A绑定路痴宝时(橙色字体)，如果路痴宝被系统杀死，保活助手A的onServiceDisconnected被回调，我们可以在该方法中执行bindService方法再次尝试绑定唤醒路痴宝。至此，经过这种双重绑定守护来到达应用保活的目的。 

    a)逻辑图解

     

a)  项目工程源码

 * MainActivity.java

[java] view plain copy

1. /** 
2.  *@decrible  
3.  * 
4.  * Create by jiangdongguo on 2016-12-6 上午9:34:10 
5.  */  
6. public class MainActivity extends Activity {  
7.   
8.     @Override  
9.     protected void onCreate(Bundle savedInstanceState) {  
10.         super.onCreate(savedInstanceState);  
11.         setContentView(R.layout.activity_main);  
12.         //启动保活后台服务  
13.         Intent intent = new Intent(MainActivity.this,LcbAliveService.class);  
14.         startService(intent);  
15.     }  
16. }  

 * LcbAliveService.java

[java] view plain copy

1. /** 
2.  *@decrible 路痴宝保活后台服务，绑定启动保活助手A的服务 
3.  * 
4.  * Create by jiangdongguo on 2016-12-6 上午9:41:36 
5.  */  
6. public class LcbAliveService extends Service {  
7.     private final String A_PackageName = "com.alive.coreone";  
8.     private final String A_ServicePath = "com.alive.coreone.AssistantAService";  
9.     private ICat mBinderFromA;  
10.       
11.     private ServiceConnection conn = new ServiceConnection() {  
12.           
13.         @Override  
14.         public void onServiceDisconnected(ComponentName name) {  
15.             bindAliveA();  
16.         }  
17.           
18.         @Override  
19.         public void onServiceConnected(ComponentName name, IBinder service) {  
20.             mBinderFromA = ICat.Stub.asInterface(service);  
21.             if (mBinderFromA != null) {  
22.                 try {  
23.                     Log.d("Debug",  
24.                             "收到保活助手A的数据：name="  
25.                                     + mBinderFromA.getName() + "；age="  
26.                                     + mBinderFromA.getAge() + "----");  
27.                 } catch (RemoteException e) {  
28.                     e.printStackTrace();  
29.                 }  
30.             }  
31.         }  
32.     };  
33.       
34.     private ICat.Stub mBinderToA = new ICat.Stub() {      
35.         @Override  
36.         public String getName() throws RemoteException {  
37.             return "我是路痴宝";  
38.         }  
39.           
40.         @Override  
41.         public int getAge() throws RemoteException {  
42.             return 3;  
43.         }  
44.     };  
45.       
46.     @Override  
47.     public IBinder onBind(Intent intent) {  
48.         return mBinderToA;  
49.     }  
50.       
51.     @Override  
52.     public boolean onUnbind(Intent intent) {  
53.         return super.onUnbind(intent);  
54.     }  
55.   
56.     @Override  
57.     public void onCreate() {  
58.         super.onCreate();  
59.         if(!isApkInstalled(A_PackageName)){  
60.             Log.d("Debug","----保活助手A未安装----");  
61.             stopSelf();  
62.             return;  
63.         }  
64.         bindAliveA();  
65.     }  
66.       
67.     @Override  
68.     public int onStartCommand(Intent intent, int flags, int startId) {  
69.         return START_STICKY;  
70.     }  
71.       
72.     @Override  
73.     public void onDestroy() {  
74.         super.onDestroy();  
75.     }  
76.   
77.     private void bindAliveA() {  
78.         Intent serverIntent = new Intent();  
79.         serverIntent.setClassName(A_PackageName, A_ServicePath);  
80.         bindService(serverIntent, conn, Context.BIND_AUTO_CREATE);  
81.     }  
82.       
83.     private boolean isApkInstalled(String packageName){  
84.         PackageManager mPackageManager = getPackageManager();  
85.         //获得所有已经安装的包信息  
86.         List<PackageInfo> infos = mPackageManager.getInstalledPackages(0);  
87.         for(int i=0;i<infos.size();i++){  
88.             if(infos.get(i).packageName.equalsIgnoreCase(packageName)){  
89.                 return true;  
90.             }  
91.         }  
92.         return false;  
93.     }  
94. }  

 * AssistantAService.java

[java] view plain copy

1. /** 
2.  *@decrible 保活助手A守护后台服务 
3.  * 
4.  * Create by jiangdongguo on 2016-11-23 上午10:57:59 
5.  */  
6. public class AssistantAService extends Service {  
7.     private final String Lcb_PackageName = "com.luchibao";  
8.     private final String Lcb_ServicePath = "com.luchibao.LcbAliveService";  
9.     private ICat mBinderFromLcb;  
10.       
11.     private ServiceConnection conn = new ServiceConnection() {  
12.   
13.         @Override  
14.         public void onServiceDisconnected(ComponentName name) {  
15.             bindLuChiBao();  
16.         }  
17.   
18.         @Override  
19.         public void onServiceConnected(ComponentName name, IBinder service) {  
20.             mBinderFromLcb = ICat.Stub.asInterface(service);  
21.             if (mBinderFromLcb != null) {  
22.                 try {  
23.                     Log.d("Debug",  
24.                             "收到路痴宝Service返回的数据：name="  
25.                                     + mBinderFromLcb.getName() + "；age="  
26.                                     + mBinderFromLcb.getAge() );  
27.                 } catch (RemoteException e) {  
28.                     e.printStackTrace();  
29.                 }  
30.             }  
31.         }  
32.     };  
33.       
34.     private ICat.Stub mBinderToLcb = new ICat.Stub() {    
35.         @Override  
36.         public String getName() throws RemoteException {  
37.             return "我是保活助手A";  
38.         }  
39.           
40.         @Override  
41.         public int getAge() throws RemoteException {  
42.             return 2;  
43.         }  
44.     };  
45.       
46.     @Override  
47.     public IBinder onBind(Intent intent) {  
48.         return mBinderToLcb;  
49.     }  
50.       
51.     @Override  
52.     public boolean onUnbind(Intent intent) {  
53.         return super.onUnbind(intent);  
54.     }  
55.       
56.     @Override  
57.     public void onCreate() {  
58.         super.onCreate();  
59.         //提升Service的优先级  
60.         Notification notification = new Notification();  
61.         notification.flags = Notification.FLAG_ONGOING_EVENT;  
62.         notification.flags |= Notification.FLAG_NO_CLEAR;  
63.         notification.flags |= Notification.FLAG_FOREGROUND_SERVICE;  
64.         startForeground(1, notification);  
65.           
66.         Log.d("Debug","****保活助手1onCreate：绑定启动路痴宝****");  
67.         bindLuChiBao();  
68.     }  
69.       
70.     @Override  
71.     public int onStartCommand(Intent intent, int flags, int startId) {  
72.         return START_STICKY;  
73.     }  
74.       
75.     @Override  
76.     public void onDestroy() {  
77.         super.onDestroy();  
78.     }  
79.       
80.     private void bindLuChiBao() {  
81.         Intent clientIntent = new Intent();  
82.         clientIntent.setClassName(Lcb_PackageName, Lcb_ServicePath);  
83.         bindService(clientIntent, conn, Context.BIND_AUTO_CREATE);  
84.     }  
85. }  

    到这里也许你会问，为什么只提高保活助手A的service优先级，而不同时提高路痴宝的优先级？这是因为自己在测试的过程中发现，当上述两个进程长时间运行在后台时还是有可能被系统杀死，以致无法实现保活的目的。当时猜想，系统在回收进程时很可能是按顺序回收的，当这两个进程顺序比较接近，或者说内存中可能就只有这两个进程，那么系统在回收的时候一次性将其干掉了。为了缓解这种情况，我采取了一种高低优先级的方式来尽量保证系统不会同一时间回收两个进程，只要有了这个时间差，两个进程就能够实现互相启动保活的目的。单进程守护保活演示如下，测试手机为华为荣耀4X全网通(Android6.0)，其一键清理、强制停止效果分别如下：

           

(4) 双进程守护
     从程度上来说，单进程守护方式差不多可以满足应用长时间保活的要求，虽说让人感觉有
点怪异，但实现起来也不是很难，效果明显。但是，随着进一步的测试，我连续两次强杀路痴宝，路痴宝就无法启动了，这是因为当路痴宝“体积”较大，启动前需要加载诸如大量的静态变量或者Application类中的变量等，导致启动较慢，当我第一次强杀路痴宝时，保活助手A是执行绑定启动路痴宝保活服务的，但我继续第二次强杀路痴宝时，保活助手A可能还未与路痴宝绑定，最终导致保活助手A无法检查路痴宝的绑定状态而失效。
     双进程守护：针对单进程守护出现的问题，当路痴宝“体积”较大时，我们可以采用双进程守护，即实现两个保活助手，它们彼此双向绑定来对路痴宝进行守护。我们采用“环”的形式来进行互拉，无论谁被杀死，只要系统杀掉剩余的任何一个进程，最后活着的进程都能够将其他被杀进程拉起来。当然，这里还有个小技巧，为了防止两个保活助手进程同时被系统杀死，我这里采取高低优先级的方式来解决。
a) 逻辑图解

* MainActivity.java：同上

* LcbAliveService.java：同上

* AssistantAService.java：

[java] view plain copy

1. /** 
2.  *@decrible 保活助手A守护后台服务，绑定保活助手B 
3.  * 
4.  * Create by jiangdongguo on 2016-11-23 上午10:57:59 
5.  */  
6. public class AssistantAService extends Service {  
7.     private final String B_PackageName = "com.alive.coretwo";  
8.     private final String B_ServicePath = "com.alive.coretwo.AssistantBService";  
9.     private ICat mBinderFromB;  
10.       
11.     private ServiceConnection conn = new ServiceConnection() {  
12.   
13.         @Override  
14.         public void onServiceDisconnected(ComponentName name) {  
15.             bindAliveB();  
16.         }  
17.   
18.         @Override  
19.         public void onServiceConnected(ComponentName name, IBinder service) {  
20.             mBinderFromB = ICat.Stub.asInterface(service);  
21.             if (mBinderFromB != null) {  
22.                 try {  
23.                     Log.d("Debug",  
24.                             "收到保活助手B Service返回的数据：name="  
25.                                     + mBinderFromB.getName() + "；age="  
26.                                     + mBinderFromB.getAge() );  
27.                 } catch (RemoteException e) {  
28.                     e.printStackTrace();  
29.                 }  
30.             }  
31.         }  
32.     };  
33.       
34.     private ICat.Stub mBinderToB = new ICat.Stub() {      
35.         @Override  
36.         public String getName() throws RemoteException {  
37.             return "我是保活助手A";  
38.         }  
39.           
40.         @Override  
41.         public int getAge() throws RemoteException {  
42.             return 2;  
43.         }  
44.     };  
45.       
46.     @Override  
47.     public IBinder onBind(Intent intent) {  
48.         return mBinderToB;  
49.     }  
50.       
51.     @Override  
52.     public boolean onUnbind(Intent intent) {  
53.         return super.onUnbind(intent);  
54.     }  
55.       
56.     @Override  
57.     public void onCreate() {  
58.         super.onCreate();  
59.         //提升Service的优先级  
60.         Notification notification = new Notification();  
61.         notification.flags = Notification.FLAG_ONGOING_EVENT;  
62.         notification.flags |= Notification.FLAG_NO_CLEAR;  
63.         notification.flags |= Notification.FLAG_FOREGROUND_SERVICE;  
64.         startForeground(1, notification);  
65.           
66.         Log.d("Debug","****保活助手AonCreate：绑定启动保活助手B****");  
67.         bindAliveB();  
68.     }  
69.       
70.     @Override  
71.     public int onStartCommand(Intent intent, int flags, int startId) {  
72.         return START_STICKY;  
73.     }  
74.       
75.     @Override  
76.     public void onDestroy() {  
77.         super.onDestroy();  
78.     }  
79.     private void bindAliveB() {  
80.         Intent clientIntent = new Intent();  
81.         clientIntent.setClassName(B_PackageName,B_ServicePath);  
82.         bindService(clientIntent, conn, Context.BIND_AUTO_CREATE);  
83.     }  
84. }  

* AssistantBService.java

[java] view plain copy

1. /** 
2.  *@decrible 保活助手APK后台服务 
3.  * 
4.  * Create by jiangdongguo on 2016-11-23 上午10:57:59 
5.  */  
6. public class AssistantBService extends Service {  
7.     private final String Lcb_PackageName = "com.luchibao";  
8.     private final String Lcb_ServicePath = "com.luchibao.LcbAliveService";  
9.     private final String A_PackageName = "com.alive.coreone";  
10.     private final String A_ServicePath = "com.alive.coreone.AssistantAService";  
11.       
12.     private ICat mBinderFomAOrLcb;  
13.       
14.     private ServiceConnection conn = new ServiceConnection() {  
15.           
16.         @Override  
17.         public void onServiceDisconnected(ComponentName name) {  
18.             bindAliveA();  
19.             bindLuChiBao();  
20.         }  
21.           
22.         @Override  
23.         public void onServiceConnected(ComponentName name, IBinder service) {  
24.             mBinderFomAOrLcb = ICat.Stub.asInterface(service);  
25.         }  
26.     };  
27.       
28.       
29.     private ICat.Stub mBinderToA = new ICat.Stub() {      
30.         @Override  
31.         public String getName() throws RemoteException {  
32.             return "我是保活助手B";  
33.         }  
34.           
35.         @Override  
36.         public int getAge() throws RemoteException {  
37.             return 1;  
38.         }  
39.     };  
40.       
41.     @Override  
42.     public IBinder onBind(Intent intent) {  
43.         return mBinderToA;  
44.     }  
45.       
46.     @Override  
47.     public boolean onUnbind(Intent intent) {  
48.         return super.onUnbind(intent);  
49.     }  
50.       
51.     @Override  
52.     public void onCreate() {  
53.         super.onCreate();  
54.         bindAliveA();  
55.         bindLuChiBao();  
56.     }  
57.       
58.     @Override  
59.     public int onStartCommand(Intent intent, int flags, int startId) {  
60.         return START_STICKY;  
61.     }  
62.       
63.     @Override  
64.     public void onDestroy() {  
65.         super.onDestroy();  
66.     }  
67.       
68.     private void bindLuChiBao() {  
69.         Intent clientIntent = new Intent();  
70.         clientIntent.setClassName(Lcb_PackageName,Lcb_ServicePath);  
71.         bindService(clientIntent, conn, Context.BIND_AUTO_CREATE);  
72.     }  
73.       
74.     private void bindAliveA() {  
75.         Intent clientIntent = new Intent();  
76.         clientIntent.setClassName(A_PackageName,A_ServicePath);  
77.         bindService(clientIntent, conn, Context.BIND_AUTO_CREATE);  
78.     }  
79. }  

     最后，就是每个应用的AndroidManifest.xml配置，也许你会发现当部署在部分机型时，无法启动保活助手，并且弹出一个“关联启动”权限警告，这是由于部分机型在启动一个外部应用时需要对其进行授权。为了避免这个麻烦，我们可以在AndroidManifest.xml的<manifest ../>标签内添加android:sharedUserId，只要保证每个关联启动的android:sharedUserId的值是一致的，然后都使用同一个密钥进行签名即可无需“关联启动”权限。保活助手A的AndroidManifest.xml参考代码如下：

[html] view plain copy

1. <?xml version="1.0" encoding="utf-8"?>  
2. <manifest xmlns:android="http://schemas.android.com/apk/res/android"  
3.     package="com.alive.coreone"  
4.     android:sharedUserId="com.alive.app"  
5.     android:versionCode="1"  
6.     android:versionName="1.0" >  
7.   
8.     <uses-sdk  
9.         android:minSdkVersion="8"  
10.         android:targetSdkVersion="21" />  
11.   
12.     <application  
13.         android:allowBackup="true"  
14.         android:icon="@drawable/ic_logo_new_72"  
15.         android:label="@string/app_name" >  
16.         <service  
17.             android:name="com.alive.coreone.AssistantAService"  
18.             android:enabled="true"  
19.             android:exported="true"  
20.             android:process=":remote" >  
21.             <intent-filter android:priority="1000" >  
22.             </intent-filter>  
23.         </service>  
24.     </application>  
25.   
26. </manifest>  

效果演示：

码字不容易，转载请注明出处：http://blog.csdn.Net/andrexpert/article/details/53485360

最后的话：“虽说上述的这种多进程守护的应用保活方式比较有效，实现起来也比较简单，面对一些特殊的应用场合还是不错的。但是，它的局限性也非常明显，我们不可能面对广大用户使用一款应用需要安装两个或者三个APP，有点不现实，但仅供参考！”

关于资料与Demo：单进程守护Demo  双进程守护Demo

关于路痴宝APP：路痴宝APP是自己最近开发的是一款以准确定位、实时导航为目标的地图导航软件，具有便捷、反应灵敏、定位准确以及良好的操作体验等特点。主要功能如下：
1.准确定位、实时导航，定位灵敏度可自由设置；
2.支持三种定位导航模式：普通地位模式、跟随定位模式、3D地图定位模式；
3.方向感应灵敏，提供跟随地图和不跟随地图两种模式选择；
4.支持六种地图模式：室内陆图、热力地图、实时交通地图、卫星地图、3D地图、2D地图；
5.实时显示行走中当前位置，支持地图全屏模式；
6.支持仿真手电筒功能、夜间出行更方便；
7.支持四种可选出行方式：公交、驾车、步行、骑行，其中，公交方式显示转乘站点信息；
8.支持路线信息分节浏览功能，出行做到心中有数；
9.支持附近搜索功能，提供多种搜索快捷键，支持附近信息排序，一键展示、一键到达等功能；
10.支持地图选址功能，以及搜索附近美食能够查看具体的店面详情，支持一键拨打电话功能;

应用宝市场下载方式：

PC端下载：http://sj.qq.com/，应用市场->搜索"路痴宝"

手机端下载：应用宝APP->搜索"路痴宝"