Android native 双进程保护

首先，Android的进程管理，是管不到native层的进程的，接下来需要明白的就是Linux socket的原理,明白这两点就可以开始native层的双进程保活了，最后就是am命令,其他的废话都不说了。
在Java层我们首先需要创建一个service.

public class ProcessService extends Service {
    public static final String TAG = ProcessService.class.getName();

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

    @Override
    public void onCreate() {
        super.onCreate();

        Watcher watcher = new Watcher();
        watcher.createWatcher(String.valueOf(Process.myUid()));
        watcher.connectMonitor();

        Timer timer = new Timer();
        timer.scheduleAtFixedRate(new TimerTask() {
            @Override
            public void run() {
                Log.w(TAG, "ProcessService 我还活着" );
            }
        }, 0, 1000 * 3);

    }

}



public class NativeWatcher {
    public native void createWatcher(String userId);
    public native void connectMonitor();
    static {
        System.loadLibrary("native-lib");
    }
}

native层代码，主要是利用socket的原理，摒弃轮询的方式。
fork()方法创建子进程，也就是服务端

extern "C"
JNIEXPORT void JNICALL
Java_per_zkingcobra_demo_doublenativeprocess_NativeWatcher_createWatcher(JNIEnv *env, jobject instance, jstring userId_) {
    userId = env->GetStringUTFChars(userId_, 0);
    // 开双进程,
    pid_t pid = fork();
    if (pid < 0) {
        // fork失败
    } else if (pid == 0) {
        LOGE("创建守护进程");
        // 子进程 守护进程
        child_do_work();
    } else if (pid > 0) {
        //父进程

    }


    env->ReleaseStringUTFChars(userId_, userId);
}

在子进程中接着实现服务端其他代码

/**
 * 创建服务端的socket
 */
void child_listen_msg() {
    fd_set rfds;
    // 超时设置3秒
    struct timeval timeout = {3, 0};

    while (1) {
        // 清空内容
        FD_ZERO(&rfds);
        FD_SET(m_child, &rfds);
        // 4个客户端
        int r = select(m_child + 1, &rfds, NULL, NULL, &timeout);
//        LOGE("读取消息前 %d", r);
        if (r > 0) {
            // 缓冲区
            char buff[256] = {0};
            // 保证所读的信息是指定的apk客户端
            if (FD_ISSET(m_child, &rfds)) {
                // 阻塞式函数 读什么？什么都不读
                int result = read(m_child, buff, sizeof(buff));

                LOGE("userId %s   ", userId);


                // 客户端一旦断开链接，说明白被干掉了，这里就不在阻塞
                // 开启服务
                execlp("am", "am", "startservice", "--user", userId,
                       "per.zkingcobra.demo.doublenativeprocess/per.zkingcobra.demo.doublenativeprocess.ProcessService",
                       (char *) NULL);
                break;
            }
        }
    }
}

/**
 * 服务端读取消息
 * @return
 */
int child_create_channel() {

    int listenfd = socket(AF_LOCAL, SOCK_STREAM, 0);

    // 清空sock，
    unlink(PATH);

    //address ---> 内存区域
    struct sockaddr_un address;


    // 清空内存
    memset(&address, 0, sizeof(sockaddr_un));
    // 协议
    address.sun_family = AF_LOCAL;

    // 相当于端口号，如果不同就不能链接了，所以这就是可以守护其他进程的原因
    strcpy(address.sun_path, PATH);
    LOGE("listenfd 的值 %d" ,listenfd);

    // 绑定
    if (bind(listenfd, (const sockaddr*)(&address), sizeof(sockaddr_un)) < 0) {
        LOGE("绑定错误");
        return 0;
    }

    int connfd = 0;
    // 最大监听5个
    listen(listenfd, 5);

    // 保证宿主进程链接成功
    while (1) {
        //返回 客户端的地址 阻塞式函数
        if ((connfd = accept(listenfd, NULL, NULL)) < 0) {
            if (errno == EINTR) {
                continue;
            } else {
                LOGE("读取错误");
                return 0;
            }
        }
        m_child = connfd;
        LOGE("链接上来了%d ", m_child);
        break;
    }


    return 1;
}


void child_do_work() {
    // 开启socket 服务端
    LOGE("进入child_do_work");
    if (child_create_channel()) {
        LOGE("进入监听");
        child_listen_msg();
    }
}

我们在主进程中开启客户端,不断地循环连接。

extern "C"
JNIEXPORT void JNICALL
Java_per_zkingcobra_demo_doublenativeprocess_NativeWatcher_connectMonitor(JNIEnv *env, jobject instance) {

    int socked;
    // 这里是主进程
    while (1) {
        LOGE("客户端 主进程开始连接");
        socked = socket(AF_LOCAL, SOCK_STREAM, 0);

        if (socked < 0) {
            LOGE("socked < 0 socket失败");
            return;
        }

        struct sockaddr_un address;
        // 清空内存
        memset(&address, 0, sizeof(sockaddr_un));
        // 协议
        address.sun_family = AF_LOCAL;
        // 相当于端口号，如果不同就不能链接了，所以这就是可以守护其他进程的原因
        strcpy(address.sun_path, PATH);
        if (connect(socked, reinterpret_cast<const sockaddr *>(&address), sizeof(sockaddr_un)) < 0) {
            LOGE("连接失败");
            close(socked);
            sleep(1);
            // 再来下一次尝试
            continue;
        }
        LOGE("连接成功");
        break;
    }
}

好了单工制的双进程保活就完成了，而系统层的进程保活是开启的双工制，互相拉起。