Android 5.0 以下Native进程保活尝试

最新推荐文章于 2024-06-05 23:08:13 发布
最新推荐文章于 2024-06-05 23:08:13 发布
阅读量2.5k 收藏 1
点赞数 1
分类专栏： Android 文章标签： Android native 进程保活
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/superxlcr/article/details/72764581
版权

最近博主尝试了Android 5.0 以下版本的Native保活机制，感觉收获颇丰，在此写下一篇博客记录一下。

首先把整个保活流程通过图片的形式描述下：

Native进程保活流程


首先是AndroidManifest 中注册的控件：

        <activity android:name=".MainActivity">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />

                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>
        <service android:name=".PersistService"
            android:process=":persist" />
        <receiver android:name=".WakeUpBroadcastReceiver"
            android:process=":wake_up"
            android:exported="true"/>

主要有三个控件：一个用于启动服务的Activity，一个在:persist 子进程中的运行任务的服务Service，以及一个在:wake_up 子进程中用于拉活Service的BroadcastReceiver


MainActivity过于简单在此就不做介绍了，PersistService的代码如下：

public class PersistService extends Service {

    private static final String TAG = "MyLog";

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

    @Override
    public void onCreate() {
        super.onCreate();
        // 运行守护Daemon
        Log.d(TAG, "run daemon");
        Daemon.run(this, WakeUpBroadcastReceiver.class);
        new Thread(new Runnable() {
            @Override
            public void run() {
                int i = 0;
                while (true) {
                    Log.d("TestLive", "number is " + i++);
                    try {
                        Thread.sleep(5000);
                    } catch (InterruptedException e) {}
                }
            }
        }).start();
    }

    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        Log.d(TAG, "onStartCommand");
        return super.onStartCommand(intent, flags, startId);
    }
}

在PersistService的onCreate方法中，调用了Daemon类启动守护进程对PersistService类进行守护，并启动了新线程计数模拟工作。

Daemon类代码如下：

    private static final String DIR_NAME = "bin";
    private static final String FILE_NAME = "serviceDaemon";

    private static AlarmManager alarmManager;
    public static PendingIntent wakeUpIntent;

    static {
        System.loadLibrary("daemon-lib");
    }

    /**
     * 运行守护进程
     * @param context 上下文
     * @param wakeUpClass 唤醒Service类
     */
    public static void run(final Context context, final Class wakeUpClass) {
        // 初始化闹钟与唤醒用的intent
        alarmManager = ((AlarmManager)context.getSystemService(Context.ALARM_SERVICE));
        Intent intent = new Intent(context, wakeUpClass);
        wakeUpIntent = PendingIntent.getBroadcast(context, 0, intent, 0);
        // 启动守护进程
        new Thread(new Runnable() {
            @Override
            public void run() {
                // 复制binary文件
                String binaryFilePath = Command.install(context, DIR_NAME, FILE_NAME);
                if (binaryFilePath != null) {
                    // 运行
                    start(context.getPackageName(), wakeUpClass.getSimpleName(), binaryFilePath);
                }
            }
        }).start();
    }

    private native static void start(String packageName, String serviceClassName, String binaryFilePath);

在run方法中，首先调用了Command工具类根据系统ABI获取在assets文件夹下相应的二进制文件，复制到特定地点后更改权限等待执行：


然后启动子线程通过JNI调用native的start方法，传入包名、需要唤醒的类名以及二进制文件的路径：

extern "C"
JNIEXPORT void JNICALL Java_com_app_superxlcr_mynativetest_Daemon_start
        (JNIEnv *env, jclass clazz, jstring jPackageName, jstring jWakeUpClassName,
         jstring jBinaryFilePath) {
    // 获取Java参数
    const char *packageName = env->GetStringUTFChars(jPackageName, 0);
    const char *wakeUpClassName = env->GetStringUTFChars(jWakeUpClassName, 0);
    const char *binaryFilePath = env->GetStringUTFChars(jBinaryFilePath, 0);
    LOGD(MY_NATIVE_TAG, "packageName is %s", packageName);
    LOGD(MY_NATIVE_TAG, "wakeUpCLassName is %s", wakeUpClassName);
    LOGD(MY_NATIVE_TAG, "binaryFilePath is %s", binaryFilePath);
    // 建立管道，pipe1用于父进程监听子进程，pipe2用于子进程监听父进程
    int pipe1Fd[2];
    int pipe2Fd[2];
    if (pipe(pipe1Fd) == -1) {
        LOGE(MY_NATIVE_TAG, "create pipe1 error");
    }
    if (pipe(pipe2Fd) == -1) {
        LOGE(MY_NATIVE_TAG, "create pipe2 error");
    }
    // 执行二进制文件
    pid_t result = fork();
    if (result > 0) { // 父进程
        // 关闭pipe1的写端
        close(pipe1Fd[1]);
        // 关闭pipe2的读端
        close(pipe2Fd[0]);
        // 监听子进程情况
        char readBuffer[100];
        int readResult = read(pipe1Fd[0], readBuffer, 100);
        LOGD(MY_NATIVE_TAG, "readResult is %d, errno is %d", readResult, errno);
        // 阻塞中断，子进程已退出
        LOGD(MY_NATIVE_TAG, "child process is dead");
        // 释放Java参数内存
        env->ReleaseStringUTFChars(jPackageName, packageName);
        env->ReleaseStringUTFChars(jWakeUpClassName, wakeUpClassName);
        env->ReleaseStringUTFChars(jBinaryFilePath, binaryFilePath);
        // 拉活处理，回调Java方法
        jmethodID methodID = env->GetStaticMethodID(clazz, "onDaemonDead", "()V");
        env->CallStaticVoidMethod(clazz, methodID, NULL);
        return;
    } else if (result == 0) { // 子进程
        // 管道描述符转为字符串
        char strP1r[10];
        char strP1w[10];
        char strP2r[10];
        char strP2w[10];
        sprintf(strP1r, "%d", pipe1Fd[0]);
        sprintf(strP1w, "%d", pipe1Fd[1]);
        sprintf(strP2r, "%d", pipe2Fd[0]);
        sprintf(strP2w, "%d", pipe2Fd[1]);
        // 执行二进制文件
        LOGD(MY_NATIVE_TAG, "execute binary file");
        LOGD(MY_NATIVE_TAG, "binary file argv ：%s %s %s %s %s %s %s %s %s %s %s %s %s",
             BINARY_FILE_NAME,
             PACKAGE_NAME, packageName,
             SERVICE_CLASS_NAME, wakeUpClassName,
             PIPE_1_READ, strP1r,
             PIPE_1_WRITE, strP1w,
             PIPE_2_READ, strP2r,
             PIPE_2_WRITE, strP2w);
        execlp(binaryFilePath,
               BINARY_FILE_NAME,
               PACKAGE_NAME, packageName,
               SERVICE_CLASS_NAME, wakeUpClassName,
               PIPE_1_READ, strP1r,
               PIPE_1_WRITE, strP1w,
               PIPE_2_READ, strP2r,
               PIPE_2_WRITE, strP2w,
               NULL);
        // 函数返回，执行失败
        LOGE(MY_NATIVE_TAG, "execute binary file fail, errno is %d", errno);
    } else {
        LOGE(MY_NATIVE_TAG, "fork fail!");
    }
    // 释放Java参数内存
    env->ReleaseStringUTFChars(jPackageName, packageName);
    env->ReleaseStringUTFChars(jWakeUpClassName, wakeUpClassName);
    env->ReleaseStringUTFChars(jBinaryFilePath, binaryFilePath);
}

在start方法中，我们首先获取了从Java层传过来的参数，然后通过pipe函数开启了两条匿名管道用于服务进程与其后代守护进程监听存活情况：

  • pipe1：管道1，用于父进程监听子进程的存活情况，父进程关闭pipe1的写端，子进程关闭pipe1的读端
  • pipe2：管道2，用于子进程监听父进程的存活情况，父进程关闭pipe2的读端，子进程关闭pipe2的写端
然后通过fork创建相应的子进程，在父进程中通过管道监听子进程的状况，在子进程中通过exec函数执行二进制文件重生为守护进程。

当父进程管道读取返回时，代表子进程已被销毁。此时，父进程通过回调Java层的onDeamonDead方法唤醒拉活进程并自杀等待重启： 
    public static void onDaemonDead() {
        Log.d(TAG, "call onDaemonDead!");
        // 闹钟启动拉活进程
        alarmManager.set(AlarmManager.ELAPSED_REALTIME, SystemClock.elapsedRealtime() + 5000, wakeUpIntent);
        // 自杀
        Process.killProcess(Process.myPid());
    }

二进制文件代码： 
int main(int argc, char *argv[]) {
    // 参数个数检查
    if (argc < 13) {
        LOGE(MY_NATIVE_TAG, "argc number is %d, expected 13!", argc);
        return 0;
    }
    char *processName = argv[0];
    char *packageName = NULL;
    char *wakeUpClassName = NULL;
    int pipe1Fd[2];
    int pipe2Fd[2];
    for (int i = 0; i < argc; i++) {
        if (!strcmp(PACKAGE_NAME, argv[i])) {
            packageName = argv[i + 1];
            LOGD(MY_NATIVE_TAG, "packageName is : %s", packageName);
        }
        if (!strcmp(SERVICE_CLASS_NAME, argv[i])) {
            wakeUpClassName = argv[i + 1];
            LOGD(MY_NATIVE_TAG, "wakeUpClassName is : %s", wakeUpClassName);
        }
        if (!strcmp(PIPE_1_READ, argv[i])) {
            pipe1Fd[0] = atoi(argv[i + 1]);
            LOGD(MY_NATIVE_TAG, "pipe1r is : %d", pipe1Fd[0]);
        }
        if (!strcmp(PIPE_1_WRITE, argv[i])) {
            pipe1Fd[1] = atoi(argv[i + 1]);
            LOGD(MY_NATIVE_TAG, "pipe1w is : %d", pipe1Fd[1]);
        }
        if (!strcmp(PIPE_2_READ, argv[i])) {
            pipe2Fd[0] = atoi(argv[i + 1]);
            LOGD(MY_NATIVE_TAG, "pipe2r is : %d", pipe2Fd[0]);
        }
        if (!strcmp(PIPE_2_WRITE, argv[i])) {
            pipe2Fd[1] = atoi(argv[i + 1]);
            LOGD(MY_NATIVE_TAG, "pipe2w is : %d", pipe2Fd[1]);
        }
    }

    // 成为守护进程
    int forkResult = fork();
    if (forkResult == 0) {
        // 成为会话组长
        setsid();
        // 改变工作目录
        chdir("/");

        // 清理僵尸进程
        cleanZombieProcess(processName);

        // 管道处理
        // 关闭pipe1的读端
        close(pipe1Fd[0]);
        // 关闭pipe2的写端
        close(pipe2Fd[1]);

        // 管道监听，监听父进程情况
        char readBuffer[100];
        int readResult = read(pipe2Fd[0], readBuffer, 100);
        LOGD(MY_NATIVE_TAG, "readResult is %d, errno is %d", readResult, errno);
        // 阻塞中断，父进程已退出
        LOGD(MY_NATIVE_TAG, "parent process is dead");
        // 拉活处理
        pid_t childPid = fork();
        if (childPid == 0) {
            // 唤醒广播拉活
            char *wakeUpName = new char[strlen(packageName) + strlen(wakeUpClassName) + 1];
            sprintf(wakeUpName, "%s/.%s", packageName, wakeUpClassName);
            LOGD(MY_NATIVE_TAG, "wakeUpName is %s", wakeUpName);
            int result = execlp("am", "am", "broadcast",
                                "--user", "0", "-n", wakeUpName, (char *) NULL);
            LOGD(MY_NATIVE_TAG, "execute am broadcast result is %d", result);
        } else if (childPid > 0) {
            waitpid(childPid, NULL, 0);
            LOGD(MY_NATIVE_TAG, "execute am broadcast over");
        } else {
            LOGE(MY_NATIVE_TAG, "fork fail!");
        }
        return 0;
    } else if (forkResult > 0) {
        return 0;
    } else {
        LOGE(MY_NATIVE_TAG, "fork fail!");
    }
}



在二进制文件中，首先检查了传入的参数，然后使该进程成为Linux的守护进程（没有关闭标准输入输出错误、关闭后执行am指令会出问题），并清理了以前剩下的僵尸守护进程，然后通过管道监听父进程的存活情况，当父进程死亡时，通过exec函数执行am指令发送广播唤醒拉活进程，并退出程序关闭守护进程。

负责拉活进程的广播接收器如下： 
public class WakeUpBroadcastReceiver extends BroadcastReceiver {

    private static final String TAG = "MyLog";

    @Override
    public void onReceive(Context context, Intent intent) {
        // 拉活处理
        Log.d(TAG, "Receiver Start Service");
        Intent serviceIntent = new Intent(context, PersistService.class);
        context.startService(serviceIntent);
    }
}

下面是在Android 4.3 CoolPad手机上测试的效果：
首次启动：
首次启动

在adb shell中通过force-stop关闭服务进程：
force-stop

守护进程检测到Service进程被杀死，进行拉活处理：
子进程唤醒

此次守护进程的pid为21561，我们尝试通过kill命令杀死守护进程：


Service进程检测到守护进程被杀死，进行拉活处理：
父进程唤醒

通过测试发现，无论是Service进程死亡还是守护进程死亡，另一方都能通过唤醒拉活进程将其救活，真正实现了Native层的双进程守护功能。

然而，在Android 5.0以上版本该方法并没有效果……目前博主正在进行进一步的学习研究。

superxlcr
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
Android 进程常驻（4）----native保活5.0以上方案推演过程以及代码详述
猫九爷阳果果
03-17 3万+
Android常驻进程，进程保活，通过native实现进程守护，低耗电，在root360，rootCM，系统forceclose 下均可存活，测试系统从2.3到5.1，机型为三星、华为、小米、亲儿子。本文记录了笔者从开始调研，到一步一步的试验的基本全部思路。ps：只为服务用户，只为技术交流，流氓绕行。
Android Native进程保活工程解析
superxlcr的博客
05-09 1362
最近学习了一个关于Android Native进程保活的工程，在此进行一下总结。
Android 进程常驻（3）----native保活5.0以下方案推演过程以及代码详述
热门推荐
猫九爷阳果果
03-15 1万+
Android常驻进程，进程保活，通过native实现进程守护，低耗电，在root360，rootCM，系统forceclose 下均可存活，测试系统从2.3到5.1，机型为三星、华为、小米、亲儿子。本文记录了我从开始调研，到一步一步的试验的基本全部思路。ps：只为服务用户，只为技术交流，流氓绕行。
android native是什么
最新发布
牛肉胡辣汤
06-05 1007
Android Native 是指在 Android 平台上使用原生编程语言（如C、C++）进行开发的应用程序。相对于使用Java或Kotlin等高级语言开发的应用程序，Android Native 应用充分利用了底层的系统资源和硬件功能，可以实现更高性能和更好的设备适配性。Android Native 是在 Android 平台上使用原生编程语言进行开发的应用程序。它通过充分利用底层的系统资源和硬件功能，提供了更高性能和更好的设备适配性。
Android 进程常驻（3）----native保活5.0以下方案推演过程以及代码
限量发行的专栏
07-16 1905
这是一个轻量级的库，配置几行代码，就可以实现在android上实现进程常驻，也就是在系统强杀下，以及360获取root权限下，clean master获取root权限下都无法杀死进程 支持系统2.3到6.0 支持大部分设备，包括三星，华为，oppo，nexus，魅族等等 可以简单对开机广播进行保护 github地址： https://github.com/
使用native程序来守护android进程
nicebooks的专栏
09-11 1万+
问题的提出 目前android的系统，我们的程序常常由于几种原因被停掉或杀掉而不能及时重启，这对于一个安全程序来说是有相当的隐患的。例如 当用户从程序管理里面停掉程序。 其他程序优化系统时杀掉程序。 程序崩溃。 在android系统里，其他程序还能禁掉我们程序各种广播接受器，导致我们程序不能根据广播来启动。 问题的解决 因此，这里我想了一个办法来解决这个问题。
详解Android进程保活的方法
08-31
" Android进程保活方法详解" Android进程保活是Android开发者关心的一大块，网上有很多第三方库和技术声称可以实现进程保活，但很多都是不靠谱的。实现进程保活需要了解Android系统的机制和漏洞，本文将介绍Android...
Android 5.0系统以上获取运行进程demo
04-08
在这个特定的案例中，描述中提到提供了一个已经封装好的jar包，这可能是为了解决在Android 5.0及以上版本无法直接获取运行进程的问题。这个jar包可能包含了实现绕过限制、获取运行进程信息的替代方法。使用这样的第...
Android 5.0 源码下载
09-23
Android 5.0 源码
基于socket的Native层守护进程
01-21
这是基于socket连接来判断服务是否存在的一个守护进程。使用方法： NDKFork port 包名/.服务名 被守护的服务需要创建一个监听socket 其它保活方案的测试情况可以看我的测试总结： http://blog.csdn.net/pvlking/article/details/50503803
【Android】进程保活
qq_30885821的博客
04-26 110
1 Android进程的优先级 Foreground process Visible process Service process Background process Empty process 唯一目的：做缓存，缩短下次运行组件所需的启动时间 2 Android进程的回收策略 Low memory killer：通过比较复杂的评分机制，对进程打分，将分数高的进程判定为bad进程，杀死并释放内存。 OOM_ODJ：判别进程的优先级。 3 进程保活方案 利用系统广播拉活 缺点：可以通过在And
进程保活（一：JNI层初探）：单向循环式启动服务
07-23
http://blog.csdn.net/fei20121106/article/details/52005691 技术关键点：开启native子进程，循环间隔的不停去启动下服务，也不判断服务是否die了。而且，如果die了，但是间隔还没到，还是不会启动服务 结论：单杀可以杀死，force close 5.0以上无效，5.0以下部分手机无效，第三方软件下无效，且无法保证实时常驻，且费电 这是要建立在保证c进程不挂的基础上，才能轮询，但是就目前来看，只有5.0以下的非国产机才会有这样的漏洞。也就是说在force close的时候，系统忽略c进程的存在，5.0以上包括5.0的哪怕源生系统也会连同c进程一起清理掉，国产机就更不用说了。就算是这样，在5.0以下的非国产机上，如果安装了获取root权限的360\cm的话，也是可以直接清理掉，也就是说会失效 而且他不但不算守护，而且还是单向的，也就是说只能a保b，b保不了a；a保b也不是在b死了立刻拉起来，要等到了时间才会去拉。
Android 通过JNI实现双守护进程，保证服务不被杀死 源码
01-19
对应博文链接：http://blog.csdn.net/yyh352091626/article/details/50542554 杀不死的服务一直是一件很头疼的问题，这边给出源码：Android 通过JNI实现双守护进程，保证服务不被杀死。完美运行在谷歌原生Android5.0系统
java安卓j建立进程_Android: 一个简单的app – 创建native进程并重定向stdout & stderr...
weixin_39643865的博客
02-28 231
一直以为在Android app中是无法使用fork()创建进程的。因为将native app拷贝到sdcard中，再通过adb shell无法执行此命令。并且android.os.Process类中也没有提供创建进程的相关方法。抱着试试看的心里，在JNI中fork一个进程出来，没相到成功了。无意中发现在java.lang.Process类中有创建进程的相关方法，难怪在android.os.Pro...
Android 系统Native进程创建示例
以后会多把工作中总结的知识、问题处理思路和方法通过博客分享出来,欢迎大家关注和共同探讨!
06-19 702
(1)、在device/qcom/sepolicy/qva/private/file_contexts中添加如下代码。（2）、在device/qcom/sepolicy/qva/private/目录中添加 testinit.te。（3)、在device/qcom/sepolicy/qva/public/目录中添加testinit.te。如果进程不存在，可以查看下/system/bin/目录下，testinit二进制文件是否存在。6、将我们的模块加入到工程的编译文件中。4、Android.mk代码如下。
Android native进程的创建实例
weixin_44205232的博客
06-22 1336
Android 系统创建 native进程并随系统开机启动的实例
linux查看native进程,Android 分析应用程序占用native内存
weixin_29207533的博客
04-30 441
Android 应用开发大家都知道可以通过DDMS来查看应用程序进程占用的内存大小；然而Native 内存并不能在虚拟堆上看到；Android系统基于Linux,这样的话其具备Linux的大多数特性；在Linux当中有不少方法可以查看进程占用的内存，可以采用图形界面工具，也可以采用命令，具体如何查看这边就不介绍了。Android Native 内存查看：1.首先需要确保你的PC上装了adb工具；不...
android从native启动java程序
wyzzgo的技术博客
03-27 668
从native启动/data/local/tmp/myapp.apk文件中com.myapp类的Main方法,
Android最强进程保活黑科技实现原理解密及方法
m0_66640396的博客
04-27 718
启动Service: mRemote.transact(transactCode, mServiceData, null, 1); 在 native 层进行 binder 通信 在Java层做进程复活的工作，这个方式是比较低效的，最好的方式是在 native 层使用纯 C/C++来复活进程。方案有两个。 其一，维术大佬给出的方案是利用libbinder.so, 利用Android提供的C++接口，跟ActivityManagerService通信，以唤醒新进程。 Java 层创建 Parcel （含 In
android 进程保活6.0
11-18
以下是一些保活进程的方法： 1. 前台服务：通过启动一个前台服务，可以让应用程序的进程变成前台进程，从而提高进程的优先级，减少被系统杀死的概率。 2. JobScheduler：JobScheduler是Android 5.0引入的一种新的...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值