Android 从底层实现让应用杀不死（1）

最新推荐文章于 2018-07-24 15:51:39 发布
最新推荐文章于 2018-07-24 15:51:39 发布
阅读量3.9k 收藏 4
点赞数
分类专栏： Android开发

情景还原：

我的应用调用了Notification，但是如果被流氓清理软件杀死，在有些机型出现Notification没有被抹除的情况，因为丧失了对Notification的引用，用户也无法抹除这个Notification，这将大大降低用户体验。于是，我想出了如果我的应用可以不死，主动清除Notification。

既然开始做了，干脆做了个小调查。

经获取Root权限TaskManager清除之后能重生的应用使用的方式（测试机型：魅蓝Note  ） 

 

那么个推可能是那样的，然后我从网上找到了一个有关Daemon进程，即守护进程。原作者分析地址http://coolerfall.com/android/android-app-daemon/，原作者github地址https://github.com/Coolerfall/Android-AppDaemon

使用方法

public class YourDaemonService
  {
       public void onCreate()
        {
          Daemon.run( this ,YourDaemonService. class , 60 );
        }
}

 

原理分析：

 

一、首先调用这个函数 开启守护进程

Daemon.run(this, DaemonService.class, Daemon.INTERVAL_ONE_MINUTE * 2);
public class Daemon {
     /**
      * Run daemon process.
      *
      * @param context            context
      * @param daemonServiceClazz the name of daemon service class
      * @param interval           the interval to check
      */
     public static void run( final Context context, final Class<?> daemonServiceClazz,
                            final int interval) {
         new Thread( new Runnable() {
             @Override
             public void run() {
                 Command.install(context, BIN_DIR_NAME, DAEMON_BIN_NAME);
                 start(context, daemonServiceClazz, interval);
             }
         }).start();
     }
}

二、install 安装库

public class Daemon {
     /**
      * Install specified binary into destination directory.
      *
      * @param  context  context
      * @param  destDir  destionation directory
      * @param  filename filename of binary
      * @return          true if install successfully, otherwise return false
      */
     @SuppressWarnings ( "deprecation" )
     public static boolean install(Context context, String destDir, String filename)
}

这个函数类似

    public final class System {
    /**
      * See {@link Runtime#load}.
      */
 
     public static void load(String pathName) {
         Runtime.getRuntime().load(pathName, VMStack.getCallingClassLoader());
     }
}

三、调用核心函数

public class Daemon {
     /** start daemon */
     private static void start(Context context, Class<?> daemonClazzName, int interval) {
         String cmd = context.getDir(BIN_DIR_NAME, Context.MODE_PRIVATE)
                 .getAbsolutePath() + File.separator + DAEMON_BIN_NAME;
 
         /* create the command string */
         StringBuilder cmdBuilder = new StringBuilder();
         cmdBuilder.append(cmd);
         cmdBuilder.append( " -p " );
         cmdBuilder.append(context.getPackageName());
         cmdBuilder.append( " -s " );
         cmdBuilder.append(daemonClazzName.getName());
         cmdBuilder.append( " -t " );
         cmdBuilder.append(interval);
 
         try {
             Runtime.getRuntime().exec(cmdBuilder.toString()).waitFor();
         } catch (IOException | InterruptedException e) {
             Log.e(TAG, "start daemon error: " + e.getMessage());
         }
     }
}

有必要解释一下Runtime.exec(String prog)函数,指令加上几个参数，

public class Runtime {
  /**
      * Executes the specified program in a separate native process. The new
      * process inherits the environment of the caller. Calling this method is
      * equivalent to calling {@code exec(prog, null, null)}.
      *
      * @param prog
      *            the name of the program to execute.
      * @return the new {@code Process} object that represents the native
      *         process.
      * @throws IOException
      *             if the requested program can not be executed.
      */
     public Process exec(String prog) throws java.io.IOException {
         return exec(prog, null , null );
     }
}

四、调用了Daemon的main函数

Daemon.c
int main( int argc, char *argv[])
{
     int i;
     pid_t pid;
         //包名
     char *package_name = NULL;
         //Service名
     char *service_name = NULL;
         //daemon文件目录
     char *daemon_file_dir = NULL;
         daemon休眠时间
     int interval = SLEEP_INTERVAL;
 
     if (argc < 7)
     {
         LOGE(LOG_TAG, "usage: %s -p package-name -s "
          "daemon-service-name -t interval-time" , argv[0]);
         return ;
     }
         //得到参数
     for (i = 0; i < argc; i ++)
     {
         if (! strcmp ( "-p" , argv[i]))
         {
             package_name = argv[i + 1];
             LOGD(LOG_TAG, "package name: %s" , package_name);
         }
 
         if (! strcmp ( "-s" , argv[i]))
         {
             service_name = argv[i + 1];
             LOGD(LOG_TAG, "service name: %s" , service_name);
         }
 
         if (! strcmp ( "-t" , argv[i]))
         {
             interval = atoi (argv[i + 1]);
             LOGD(LOG_TAG, "interval: %d" , interval);
         }
     }
 
     /* package name and service name should not be null */
     if (package_name == NULL || service_name == NULL)
     {
         LOGE(LOG_TAG, "package name or service name is null" );
         return ;
     }
         //调用fork函数
     if ((pid = fork()) < 0)
     {
         exit (EXIT_SUCCESS);
     }
         //子
     else if (pid == 0)
     {
           /* add signal */
         /*  SIGTERM
         程序结束(terminate)信号
         */
               signal (SIGTERM, sigterm_handler);
         /* become session leader */
         setsid();
         /* change work directory */
         chdir( "/" );
 
         for (i = 0; i < MAXFILE; i ++)
         {
             close(i);
         }
 
         /* find pid by name and kill them */
         int pid_list[100];
         int total_num = find_pid_by_name(argv[0], pid_list);
         LOGD(LOG_TAG, "total num %d" , total_num);
         for (i = 0; i < total_num; i ++)
         {
             int retval = 0;
             int daemon_pid = pid_list[i];
             if (daemon_pid > 1 && daemon_pid != getpid())
             {
                 retval = kill(daemon_pid, SIGTERM);
                 if (!retval)
                 {
                     LOGD(LOG_TAG, "kill daemon process success: %d" , daemon_pid);
                 }
                 else
                 {
                     LOGD(LOG_TAG, "kill daemon process %d fail: %s" , daemon_pid, strerror ( errno ));
                     exit (EXIT_SUCCESS);
                 }
             }
         }
 
         LOGD(LOG_TAG, "child process fork ok, daemon start: %d" , getpid());
 
         while (sig_running)
         {
             select_sleep(interval < SLEEP_INTERVAL ? SLEEP_INTERVAL : interval, 0);
 
             LOGD(LOG_TAG, "check the service once" );
 
             /* start service */
             start_service(package_name, service_name);
         }
 
         exit (EXIT_SUCCESS);
     }
     else
     {
         /* parent process */
         exit (EXIT_SUCCESS);
     }

这里有必要其中的函数说明一下

1.signal()函数
void (*signal(int signum, void (*handler))(int)))(int);
该函数有两个参数, signum指定要安装的信号, handler指定信号的处理函数.
SIGTERM 是程序结束(terminate)信号
当程序终止会调用

 

2.fork()函数：
fork()函数通过系统调用创建一个与原来进程几乎完全相同的进程，两个进程可以做相同的事，相当于自己生了个儿子，如果初始参数或者传入的参数不一样，两个进程做的事情也不一样。当前进程调用fork函数之后，系统先给当前进程分配资源，然后再将当前进程的所有变量的值复制到新进程中（只有少数值不一样），相当于克隆了一个自己。
pid_t fpid = fork()被调用前，就一个进程执行该段代码，这条语句执行之后，就将有两个进程执行代码，两个进程执行没有固定先后顺序，主要看系统调度策略，fork函数的特别之处在于调用一次，但是却可以返回两次，甚至是三种的结果
（1）在父进程中返回子进程的进程id（pid）
（2）在子进程中返回0
（3）出现错误，返回小于0的负值
出现错误原因：（1）进程数已经达到系统规定 （2）内存不足，此时返回

 

3.AM命令
Android系统提供的adb工具，在adb的基础上执行adb shell就可以直接对android系统执行shell命令
am命令：在Android系统中通过adb shell 启动某个Activity、Service、拨打电话、启动浏览器等操作Android的命令。
am命令的源码在Am.java中，在shell环境下执行am命令实际是启动一个线程执行Am.java中的主函数（main方法），am命令后跟的参数都会当做运行时参数传递到主函数中，主要实现在Am.java的run方法中。
am命令可以用start子命令，和带指定的参数，start是子命令，不是参数
常见参数：-a:表示动作，-d：表示携带的数据，-t:表示传入的类型，-n:指定的组件名
例如，我们现在在命令行模式下进入adb shell下，使用这个命令去打开一个网页

类似的命令还有这些：
拨打电话
命令：am start -a android.intent.action.CALL -d tel:电话号码
示例：am start -a android.intent.action.CALL -d tel:10086

打开一个网页
命令：am start -a android.intent.action.VIEW -d 网址
示例：am start -a android.intent.action.VIEW -d http://www.baidu.com

启动一个服务
命令：am startservice <服务名称>
示例：am startservice -n com.android.music/com.android.music.MediaPlaybackService

/* start daemon service */
static void start_service( char *package_name, char *service_name)
{
     /* get the sdk version */
     int version = get_version();
 
     pid_t pid;
 
     if ((pid = fork()) < 0)
     {
         exit (EXIT_SUCCESS);
     }
     else if (pid == 0)
     {
         if (package_name == NULL || service_name == NULL)
         {
             LOGE(LOG_TAG, "package name or service name is null" );
             return ;
         }
 
         char *p_name = str_stitching(package_name, "/" );
         char *s_name = str_stitching(p_name, service_name);
         LOGD(LOG_TAG, "service: %s" , s_name);
 
         if (version >= 17 || version == 0)
         {
             int ret = execlp( "am" , "am" , "startservice" ,
                         "--user" , "0" , "-n" , s_name, ( char *) NULL);
             LOGD(LOG_TAG, "result %d" , ret);
         }
         else
         {
             execlp( "am" , "am" , "startservice" , "-n" , s_name, ( char *) NULL);
         }
 
         LOGD(LOG_TAG , "exit start-service child process" );
         exit (EXIT_SUCCESS);
     }
}

五、让程序彻底终止

如此一来你可能会发现你的程序根本就死不了
但是你又想要退出，那该怎么办呢？
我这里有个解决办法

     @Override
     public void onCreate() {
         super .onCreate();
         Log.e(TAG, "onCreate" );
         ACache cache = CustomApplication.getInstance().getCache();;
         int m= 2 ;
         if (cache.getAsString(Constant.IS_CLEAN) != null ) {
             try {
                 m = Integer.parseInt(cache.getAsString(Constant.IS_CLEAN));
//                L.e(TAG,"   " +  m );
             } catch (NumberFormatException e) {
                 cache.remove(Constant.IS_CLEAN);
                 //e.printStackTrace();
                 m= 1 ;
             }
         }
         if (m> 1 ) {
             Daemon.run( this , NotificationCenter. class , 0 );
             cache.put(Constant.IS_CLEAN, m - 1 + "" );
          }
         if (m== 1 )
         {
//            L.e(TAG, "cancelAll");
             NotificationManager notificationManager = (NotificationManager) this .getSystemService(Context.NOTIFICATION_SERVICE);
             notificationManager.cancelAll();
             cache.put(Constant.IS_CLEAN, 0 );
             stopSelf();
         }
         if (m == 0 ) {
             stopSelf();
         }
 
     }

IS_CLEAN 是个标志位,我将它缓存为文件
每启动一次Service，会对进行一次V操作，即IS_CLEAN--
当IS_CLEAN <=1 时，那么不会再启动守护进程

ps

并不是所有手机都能用此方法实现进程守护，主要是因为现目前的进程清理软件不会清理c层fork出的进程，但有的手机（如小米），自带清理进程会清理掉应用相关的所有进程，故而不能实现进程守护。

如果自发探索守护进程，可以下载android 终端模拟器

输入 ps 命令查看进程

输入 su 命令获取root权限

输入 kill pid 可以杀死进程

看到其中的进程详情，可以对其中含有 Daemon 字段的进程对探索一二

最后一点，希望开发者利用守护进程完及时关闭，不要耍流氓，本人十分讨厌一些以耍流氓为骄傲的行为

李嘉欣-第四维空间
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
Android底层网络防火墙,Android系统中实现网络防火墙的方法
weixin_34952628的博客
05-26 1250
防火墙顾名思义就是作为内部网与外部网之间的一种访问控制设备， 常常安装在内部网和外部网交界点上。而网络防火墙是一个位于计算机与它所连接的网络之间的软件。所有网络通信在计算机里流入流出都要经过防火墙。而防火墙对流经它的网络通信进行扫描，这样能够过滤掉一些攻击，以免其在目标计算机上被执行。重要的是防火墙还可以关闭不使用的端口，而且它还能禁止特定端口的流出通信，封锁特洛伊木 马，也可以禁止来自特殊站点的...
如何让你的App永远在后台存活：对Android进程守护、闹钟后台被杀死的研究
热门推荐
AMEPRE88的博客
08-15 1万+
相关阅读： 吊炸天！74款APP完整源码！ 123个微信小程序源码分享（附下载） ［干货］2017已来，最全面试总结——这些Android面试题你一定需要 公众号：Java和Android架构 关注回复：Android,iOS,PHP,js,HTML5,Python,机器学习 ，AI，
android杀不死服务一种实现，能过保证第三方软件和系统杀不死他，很好用哦
12-03
android杀不死服务一种实现，能过保证第三方软件和系统杀不死他，很好用哦
android杀不死的app
02-14
杀不死服务实现原理： 1：Android一个app可以启动2个进程 2：进程A与进程B互相守护 3：进程A时刻盯着进程B，通用进程B也时刻盯着进程B 4：进程之间互相盯着，需要用到IPC进程间通信技术（也就是Binder机制AIDL 5：注意配置远程服务启动为一个新的进程，为新进程命名为 android:process=".remoteService" 6：进程A服务绑定进程B服务，进程B服务绑定进程A服务
Android 杀不死的进程（下）
qq_22902079的博客
11-02 620
在上篇http://blog.csdn.net/qq_22902079/article/details/78303332里遗留了一个问题，在5.0以上的机型中测试手动杀死进程，测试结果是能杀死，所以上文中的双进程守护策略还不够，我们需要再进行改进。 在Android5.0之后Android提供了JobService和JobScheduler这两的类。我们可以通过这个JobScheduler来进行
Android手机终端长连接心跳检测自动化测试方案
测试领域专家，多领域测试技术、管理、工具都略懂，略懂一二
07-24 3007
Android心跳检测，为何要心跳检测，什么是心跳检测，这篇文章我给大家讲解下思路，以免跟我一样走过不少的弯路。 android终端心跳检测是跟系统侧进行交互，用作长连接用的，终端隔断时间给系统发包，告诉系统我还在，若是系统没有收到终端的心跳包，就会断掉终端连接，默认该终端已经挂了。说到这里就这都此android终端非公网机，而是有与系统交互的机器。详细相关心跳解析百度下 ......
Android底层驱动开发.pdf
09-27
Android底层驱动开发是一个复杂的工程，涵盖了众多的驱动子系统和相关组件，每一个组件都是Android系统稳定运行不可或缺的一部分。了解和掌握这些组件的原理和实现，对于进行Android底层开发至关重要。
Android通过JNI实现守护进程
09-01
Android 5.0及以上版本在安全方面进行了加强，当应用退出时，不仅会杀死主进程，还会杀死与主进程同组的所有进程，这使得单纯通过Service或广播来实现守护进程变得更为困难。 解决这个问题的一个方案是通过JNI和C/...
android底层4页框架
06-12
在Android系统中，"底层四页框架"通常指的是Android系统的四大核心组件，它们构成了Android应用程序的基础架构。这四大组件包括：活动（Activity）、服务（Service）、广播接收者（Broadcast Receiver）和内容提供者...
不死的Service
01-16
不死的Service，超级强悍的Service，绝对死不了的Service，就是不死哈哈哈！
Android不死Service
12-20
创建一个不死的Service，在被用户终止或者第三方软件清理之后的最短时间内恢复服务
Android 后台服务
05-26
NULL 博文链接：https://w26.iteye.com/blog/511890
修改Android 休眠逻辑使系统关屏而不进入休眠
kevin's cache的专栏
11-30 1万+
近日接到一个比较诡异的产品需求，在我看来需要修改Android PMS。 具体需求如下： 要求在某一Activity界面在灭屏之后也能监听屏幕的手势事件，在我看来这种手势事件需求应该放在TP的驱动中来完成是最合理的，但是无奈硬件选型已过，而且手势不能完全支持我们的产品需求，无奈放弃底层的思路，开始改上层的电源管理逻辑。 首先说一下我修改的思路和逻辑，PMS在走
Android: 通过Runtime.getRuntime().exec调用底层Linux下的程序或脚本
xiaodanpeng的专栏
12-28 2034
Android Runtime使得直接调用底层Linux下的可执行程序或脚本成为可能 比如Linux下写个测试工具，直接编译后apk中通过Runtime来调用 或者写个脚本，apk中直接调用，省去中间层或者JNI 这个至少效率应该比较高吧     代码: [java] view plaincopy public class test extends Activi
怎么让 Android 程序一直后台运行
qq_29598851的博客
10-25 6563
从技术角度概括一下现在普遍的防杀方法 Service设置成START_STICKY，kill 后会被重启（等待5秒左右），重传Intent，保持与重启前一样​通过 startForeground将进程设置为前台进程，做前台服务，优先级和前台应用一个级别​，除非在系统内存非常缺，否则此进程不会被 kill 双进程Service：让2个进程互相保护，其中一个Service被清理后，另外没被清理
Android-打不死的小强永不crash的Android
08-13
自定义Application继承自android的Application，并在Application中装载，越早初始化越好，可以在Aplication的onCreate中初始化，当然也可以根据需要在任意地方（不一定要在主线程）装载，在任意地方卸载。可以多次装载和卸载。
Android应用防杀策略：持久运行与系统权限
总结，为了让Android应用不被系统杀死，可以通过将服务设为前台服务，或者提升应用的系统级别，使其具有持久运行的能力。然而，需要注意的是，这些方法可能会消耗更多的系统资源，影响用户体验，因此在实际开发中，...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值