进程保活之双进程守护

上一篇文章讲到一个像素保活线程。没有看的小伙伴可以去看看。地址：http://www.jianshu.com/p/a61ecc016aa5

原理：

杀进程是一个一个杀的。我们可以定义两个进程，两个进程相互监听。A进程被杀死，Ｂ进程监听到就启动A进程。否则相反。

实现：

1，创建MainActivity。一上来就启动两个服务。

package com.zsj.doubleprocess;

import android.app.Activity;
import android.content.Intent;
import android.os.Bundle;
import android.view.Menu;
import android.view.MenuItem;

public class MainActivity extends Activity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        // 一上来就启动两个服务。
        startService(new Intent(this, LocalService.class));
        startService(new Intent(this, RemoteService.class));
    }
}

2，创建两个进程的服务LocalService和RemoteService，并相互绑定。在连接断开的启动对方的进程的服务。

LocalService.java

package com.zsj.doubleprocess;

import android.app.Service;
import android.content.ComponentName;
import android.content.Context;
import android.content.Intent;
import android.content.ServiceConnection;
import android.os.IBinder;
import android.os.RemoteException;

/**
 * 第一个服务。本地服务
 * 
 * @author zsj
 *
 */
public class LocalService extends Service {

    private MyBind bind;
    private MyServiceConnection conn;

    @Override
    public void onCreate() {
        super.onCreate();
        if (bind == null) {
            bind = new MyBind();
        }
        if (conn == null) {
            conn = new MyServiceConnection();
        }
    }

    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        // 绑定另外进程的服务RemoteService,并设置BIND_IMPORTANT为重要绑定
        bindService(new Intent(LocalService.this, RemoteService.class), conn,
                Context.BIND_IMPORTANT);

        return super.onStartCommand(intent, flags, startId);
    }

    @Override
    public IBinder onBind(Intent intent) {
        return bind;
    }

    public class MyBind extends RemoteConn.Stub {
        @Override
        public String getProcessName() throws RemoteException {
            return "LocalService";
        }
    }

    public class MyServiceConnection implements ServiceConnection {

        @Override
        public void onServiceConnected(ComponentName name, IBinder service) {
            // 远程服务连接成功回调
        }

        @Override
        public void onServiceDisconnected(ComponentName name) {
            // 被绑定的服务断开连接的时候回调
            // 启动被绑定的服务。
            startService(new Intent(LocalService.this, RemoteService.class));
            bindService(new Intent(LocalService.this, RemoteService.class),
                    conn, Context.BIND_IMPORTANT);
        }
    }

}

RemoteService.java

package com.zsj.doubleprocess;

import android.app.Service;
import android.content.ComponentName;
import android.content.Context;
import android.content.Intent;
import android.content.ServiceConnection;
import android.os.IBinder;
import android.os.RemoteException;

public class RemoteService extends Service {

    private MyBind bind;
    private MyServiceConnection conn;

    @Override
    public void onCreate() {
        super.onCreate();
        if (bind == null) {
            bind = new MyBind();
        }
        if (conn == null) {
            conn = new MyServiceConnection();
        }
    }

    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        // 绑定另外进程的服务LocalService,并设置BIND_IMPORTANT为重要绑定
        bindService(new Intent(RemoteService.this, LocalService.class), conn,
                Context.BIND_IMPORTANT);

        return super.onStartCommand(intent, flags, startId);
    }

    @Override
    public IBinder onBind(Intent intent) {
        return bind;
    }

    public class MyBind extends RemoteConn.Stub {
        @Override
        public String getProcessName() throws RemoteException {
            return "RemoteService";
        }
    }

    public class MyServiceConnection implements ServiceConnection {

        @Override
        public void onServiceConnected(ComponentName name, IBinder service) {
            // 远程服务连接成功回调

        }

        @Override
        public void onServiceDisconnected(ComponentName name) {
            // 被绑定的服务断开连接的时候回调
            // 启动被绑定的服务。
            startService(new Intent(RemoteService.this, LocalService.class));
            bindService(new Intent(RemoteService.this, LocalService.class),
                    conn, Context.BIND_IMPORTANT);
        }
    }
}‘

3,因为两个服务在不同的进程里面.所以在AndroidManifest.xml配置：

图片发自App

4.在不同的进程通信。用到Aidl.定义一个通信接口RemoteConn.aidl。

RemoteConn.aidl

package com.zsj.doubleprocess;

interface RemoteConn {
    String getProcessName();
}

双进程守护就完成了。
因为这两个服务都是后台服务。为了提高更加不容易被杀死。可以提升为前台服务。就不给实现了。很简单。

优点：

可以防止360等第三方清理工具杀死。

弊端：

但是当用户手动点击强制停止。进程真的就停止了。

下次写就算用户手动点击强制停止。也能自动唤醒进程。

demo下载：
https://github.com/zsj1225/DoubleProcess