首先，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;
}
}
好了单工制的双进程保活就完成了，而系统层的进程保活是开启的双工制，互相拉起。
