android双进程守护，让程序崩溃后一定可以重启

由于我们做的是机器人上的软件，而机器人是24小时不间断服务的，这就要求我们的软件不能退出到系统桌面。当然最好是能够做到程序能够不卡顿，不崩溃，自己不退出。由于我们引用了很多第三方的开发包，也不能保证他们的稳定性，所以，要做到完全不崩溃也是不可能的。

退而求其次，如果崩溃了我们就要保证程序能够被拉起来，期间也看过很多保活的方案，比如service前台的方法，比如jni里写守护进程，比如接收系统广播唤醒，比如用alarmmanager唤醒等等，感觉不是效率底，就是被系统屏蔽了。经过不断筛选，我认为使用aidl进行双进程守护其实是效率很好的一个解决方案。

其实这个原理也很简单，简单的说就是创建两个service，其中一个再程序主进程，另外一个在其他进程，这两个进程通过aidl通信，一旦其中一个进程断开连接，那么就重启该服务，两个程序互相监听，就能够做到一方被杀死，另一方被启动了。当然，如果使用 adb shell force-stop packageName的方法杀死程序，肯定是不能够重启的。这种方式仅仅是为了避免ndk层崩溃，java抓不到从而不能使用java层重启应用的一种补充方式。要想做到完全不被杀死，那就太流氓了。

说了这么多，看代码吧

两个service，localservice和remoteservice

LocalService.java

package guide.yunji.com.guide.processGuard;

import android.app.Application;
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;
import android.util.Log;
import android.widget.Toast;

import guide.yunji.com.guide.MyApplication;
import guide.yunji.com.guide.activity.MainActivity;
import guide.yunji.com.guide.testFace.IMyAidlInterface;

public class LocalService extends Service {
    private static final String TAG = LocalService.class.getName();
    private MyBinder mBinder;

    private ServiceConnection connection = new ServiceConnection() {
        @Override
        public void onServiceConnected(ComponentName name, IBinder service) {
            IMyAidlInterface iMyAidlInterface = IMyAidlInterface.Stub.asInterface(service);
            try {
                Log.e("LocalService", "connected with " + iMyAidlInterface.getServiceName());
                //TODO whh 本地service被拉起，检测如果mainActivity不存在则拉起
                if (MyApplication.getMainActivity() == null) {
                    Intent intent = new Intent(LocalService.this.getBaseContext(), MainActivity.class);
                    intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
                    getApplication().startActivity(intent);
                }
            } catch (RemoteException e) {
                e.printStackTrace();
            }
        }

        @Override
        public void onServiceDisconnected(ComponentName name) {
            Toast.makeText(LocalService.this, "链接断开，重新启动 RemoteService", Toast.LENGTH_LONG).show();
            Log.e(TAG, "onServiceDisconnected: 链接断开，重新启动 RemoteService");
            startService(new Intent(LocalService.this, RemoteService.class));
            bindService(new Intent(LocalService.this, RemoteService.class), connection, Context.BIND_IMPORTANT);
        }
    };

    public LocalService() {
    }

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

    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        Log.e(TAG, "onStartCommand: LocalService 启动");
        Toast.makeText(this, "LocalService 启动", Toast.LENGTH_LONG).show();
        startService(new Intent(LocalService.this, RemoteService.class));
        bindService(new Intent(LocalService.this, RemoteService.class), connection, Context.BIND_IMPORTANT);
        return START_STICKY;
    }

    @Override
    public IBinder onBind(Intent intent) {
        mBinder = new MyBinder();
        return mBinder;
    }

    private class MyBinder extends IMyAidlInterface.Stub {

        @Override
        public String getServiceName() throws RemoteException {
            return LocalService.class.getName();
        }

        @Override
        public void basicTypes(int anInt, long aLong, boolean aBoolean, float aFloat, double aDouble, String aString) throws RemoteException {

        }
    }
}

RemoteService.java

package guide.yunji.com.guide.processGuard;

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;
import android.util.Log;
import android.widget.Toast;


import guide.yunji.com.guide.testFace.IMyAidlInterface;

public class RemoteService extends Service {
    private static final String TAG = RemoteService.class.getName();
    private MyBinder mBinder;

    private ServiceConnection connection = new ServiceConnection() {
        @Override
        public void onServiceConnected(ComponentName name, IBinder service) {
            IMyAidlInterface iMyAidlInterface = IMyAidlInterface.Stub.asInterface(service);
            try {
                Log.e(TAG, "connected with " + iMyAidlInterface.getServiceName());
            } catch (RemoteException e) {
                e.printStackTrace();
            }
        }

        @Override
        public void onServiceDisconnected(ComponentName name) {
            Log.e(TAG, "onServiceDisconnected: 链接断开，重新启动 LocalService");
            Toast.makeText(RemoteService.this, "链接断开，重新启动 LocalService", Toast.LENGTH_LONG).show();
            startService(new Intent(RemoteService.this, LocalService.class));
            bindService(new Intent(RemoteService.this, LocalService.class), connection, Context.BIND_IMPORTANT);
        }
    };

    public RemoteService() {
    }


    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        Log.e(TAG, "onStartCommand: RemoteService 启动");
        Toast.makeText(this, "RemoteService 启动", Toast.LENGTH_LONG).show();
        bindService(new Intent(this, LocalService.class), connection, Context.BIND_IMPORTANT);
        return START_STICKY;
    }

    @Override
    public IBinder onBind(Intent intent) {
        mBinder = new MyBinder();
        return mBinder;
    }

    private class MyBinder extends IMyAidlInterface.Stub {

        @Override
        public String getServiceName() throws RemoteException {
            return RemoteService.class.getName();
        }

        @Override
        public void basicTypes(int anInt, long aLong, boolean aBoolean, float aFloat, double aDouble, String aString) throws RemoteException {

        }
    }
}

注意，两个service要在不通的进程

 <service
            android:name=".processGuard.LocalService"
            android:enabled="true"
            android:exported="true" />
        <service
            android:name=".processGuard.RemoteService"
            android:enabled="true"
            android:exported="true"
            android:process=":RemoteProcess" />

两个service通过aidl连接，如下

// IMyAidlInterface.aidl
package guide.yunji.com.guide.testFace;

// Declare any non-default types here with import statements

interface IMyAidlInterface {
    /**
     * Demonstrates some basic types that you can use as parameters
     * and return values in AIDL.
     */
    void basicTypes(int anInt, long aLong, boolean aBoolean, float aFloat,
            double aDouble, String aString);
               String getServiceName();
}

此外还要注意一点，程序的service初始化的时候如果在自定义的application的时候要注意多进程的问题，本来LocalService是在主进程中启动的，所以要做一下进程的判断，如下：

package com.honghe.guardtest;

import android.app.ActivityManager;
import android.app.Application;
import android.content.Context;
import android.content.Intent;

public class MyApplication extends Application {
    private static MainActivity mainActivity = null;

    public static MainActivity getMainActivity() {
        return mainActivity;
    }

    public static void setMainActivity(MainActivity activity) {
        mainActivity = activity;
    }

    @Override
    public void onCreate() {
        super.onCreate();
        if (isMainProcess(getApplicationContext())) {
            startService(new Intent(this, LocalService.class));
        } else {
            return;
        }
    }

    /**
     * 获取当前进程名
     */
    public String getCurrentProcessName(Context context) {
        int pid = android.os.Process.myPid();
        String processName = "";
        ActivityManager manager = (ActivityManager) context.getApplicationContext().getSystemService
                (Context.ACTIVITY_SERVICE);
        for (ActivityManager.RunningAppProcessInfo process : manager.getRunningAppProcesses()) {
            if (process.pid == pid) {
                processName = process.processName;
            }
        }
        return processName;
    }

    public boolean isMainProcess(Context context) {
        /**
         * 是否为主进程
         */
        boolean isMainProcess;
        isMainProcess = context.getApplicationContext().getPackageName().equals
                (getCurrentProcessName(context));
        return isMainProcess;
    }
}

然后LocalService重启后，可以判断是否要开启程序的主界面，上面的localService已经写了，就不多介绍了。

代码已经有了，我们怎么测试呢？

当然是伪造一个ndk的崩溃来验证程序的可行性了。

我们写一个jni，如下

 

写一个Jni的类

JniLoaderndk.cpp

#include <string.h>
#include <jni.h>
#include <stdio.h>

//#include "yue_excample_hello_JniLoader.h"
//按照C语言规则编译。jni依照C的规则查找函数，而不是C++，没有这一句运行时会崩溃报错：
// java.lang.UnsatisfiedLinkError: Native method not found:
extern "C"{

JNIEXPORT jstring JNICALL Java_com_honghe_guardtest_JniLoader_getHelloString
(JNIEnv *env, jobject _this)
{
int m=30;
int n=0;
int j=m/n;
printf("hello %d",j);
Java_com_honghe_guardtest_JniLoader_getHelloString(env,_this);
//return (*env)->NewStringUTF(env, "Hello world from jni)");//C语言格式，文件名应为xxx.c
return env->NewStringUTF((char *)("hello whh"));//C++格式，文件名应为xxx.cpp
}


}

为什么这么写，因为我本来想通过除0来制造异常，但是ndk本身并不向上层因为除0崩溃，后来无奈只好使用递归来制造崩溃了。

android.mk

LOCAL_PATH := $(call my-dir)
include $(CLEAR_VARS)

# 要生成的.so库名称。java代码System.loadLibrary("firstndk");加载的就是它
LOCAL_MODULE := firstndk

# C++文件
LOCAL_SRC_FILES := JniLoaderndk.cpp

include $(BUILD_SHARED_LIBRARY)

application.mk

# 注释掉了，不写会生成全部支持的平台。目前支持：
 APP_ABI := armeabi arm64-v8a armeabi-v7a mips mips64 x86 x86_64
#APP_ABI := armeabi-v7a

写完了ndk后需要到jni的目录下执行一个 ndk-build 的命令，这样会在main目录下生成libs文件夹，文件夹中有目标平台的so文件，但是android默认不会读取该目录的so文件，所以我们需要在app/build.gradle中加入路径，使程序能够识别so

sourceSets {
        main {
            jniLibs.srcDirs = ['src/main/libs']//默认为jniLibs
        }
    }

弄好后，就可以在安卓程序中找到ndk中的方法了。

创建调用类

JniLoader.java

package com.honghe.guardtest;

public class JniLoader {
    static {
        System.loadLibrary("firstndk");
    }

    public native String getHelloString();
}

 

调用该方法就能够发现程序在ndk影响下崩溃了，如图

看logcat

说明旧的进程由于ndk崩溃被杀死了，但是看界面里程序已经重启了，然后还多出了一个不通pid的同名进程，如下

证明ndk崩溃后我们的软件重启成功了。

代码全部在github，如下

https://github.com/dongweiq/guardTest

我的github地址：https://github.com/dongweiq/study

欢迎关注，欢迎star o(∩_∩)o 。有什么问题请邮箱联系 dongweiqmail@gmail.com qq714094450