Android 从底层实现让应用杀不死(1)

转载 2015年11月18日 10:53:33

情景还原:

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

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

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

 

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

使用方法

publicclass YourDaemonService
 {
      publicvoid onCreate()
       {
         Daemon.run(this,YourDaemonService.class,60);
       }
}

 

原理分析:

 

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

Daemon.run(this, DaemonService.class, Daemon.INTERVAL_ONE_MINUTE * 2);
publicclass Daemon {
    /**
     * Run daemon process.
     *
     * @param context            context
     * @param daemonServiceClazz the name of daemon service class
     * @param interval           the interval to check
     */
    publicstatic void run(finalContext context, finalClass<?> daemonServiceClazz,
                           finalint interval) {
        newThread(newRunnable() {
            @Override
            publicvoid run() {
                Command.install(context, BIN_DIR_NAME, DAEMON_BIN_NAME);
                start(context, daemonServiceClazz, interval);
            }
        }).start();
    }
}

二、install 安装库

publicclass 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")
    publicstatic boolean install(Context context, String destDir, String filename)
}

这个函数类似

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

三、调用核心函数

publicclass Daemon {
    /** start daemon */
    privatestatic void start(Context context, Class<?> daemonClazzName, intinterval) {
        String cmd = context.getDir(BIN_DIR_NAME, Context.MODE_PRIVATE)
                .getAbsolutePath() + File.separator + DAEMON_BIN_NAME;
 
        /* create the command string */
        StringBuilder cmdBuilder = newStringBuilder();
        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)函数,指令加上几个参数,

publicclass 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.
     */
    publicProcess exec(String prog) throwsjava.io.IOException {
        returnexec(prog, null,null);
    }
}

四、调用了Daemon的main函数

Daemon.c
intmain(intargc, char*argv[])
{
    inti;
    pid_t pid;
        //包名
    char*package_name = NULL;
        //Service名
    char*service_name = NULL;
        //daemon文件目录
    char*daemon_file_dir = NULL;
        ////daemon休眠时间
    intinterval = 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);
    }
        //子
    elseif (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 */
        intpid_list[100];
        inttotal_num = find_pid_by_name(argv[0], pid_list);
        LOGD(LOG_TAG,"total num %d", total_num);
        for(i = 0; i < total_num; i ++)
        {
            intretval = 0;
            intdaemon_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 */
staticvoid start_service(char*package_name, char*service_name)
{
    /* get the sdk version */
    intversion = get_version();
 
    pid_t pid;
 
    if((pid = fork()) < 0)
    {
        exit(EXIT_SUCCESS);
    }
    elseif (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)
        {
            intret = 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
    publicvoid onCreate() {
        super.onCreate();
        Log.e(TAG,"onCreate");
        ACache cache = CustomApplication.getInstance().getCache();;
        intm=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 字段的进程对探索一二

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

相关文章推荐

Android应用进程防杀指南1-常用套路

> 1.如果service正在调用onCreate,onStartCommand或者onDestory方法,那么用于当前service的进程则变为前台进程以避免被killed。 > 2.如果当前ser...

android 后台杀不死的进行实现

1. 要想永远不被系统kill掉,那你只能是升级成系统应用(例如launcher,systemUI这些应用怎么杀,也是杀不死的)。 我们写的当然不是系统应用,只能说,在很大概率上不被杀死。也就是说也不...

Android Service 双进程常驻后台(2)

最近项目用到Service常驻后台,研究了一下发现手Q和微信都是使用了双进程来保证一键清理后自动复活,copy网上双进程Service的例子,再结合onTrimMemory(),基本实现一键清理后自动...

保持Service不被Kill掉的方法--双Service守护 && Android实现双进程守护

保持Service不被Kill掉的方法--双Service守护 AndroidManifest.xml:

android杀不死服务实现

  • 2014-04-13 09:37
  • 1.18MB
  • 下载

android杀不死服务一种实现

  • 2015-06-01 10:29
  • 1.18MB
  • 下载

浅谈Android内存泄漏&&实现杀不死的无界面后台Service

以前看大神的博客,都说没有碰到过内存泄漏或者OOM就不算真正的搞过Android…以前我觉得这事离我还好远…. 没想到,这次真的是遇上了!! 项目需求是这样的:app开机自启,启动之后app就一直...

Android 不死的应用程序service

原理性的东西就不多空谈了,自己根据下面我给的提示一步一步看代码,然后就能实现了、 方案1:集成第三方信鸽 (一般的杀不死,360 能杀死) 方案2: 自己有这方面的一个开发需求,所以这里就贴一下类...

Android 不死的应用程序service

原理性的东西就不多空谈了,自己根据下面我给的提示一步一步看代码,然后就能实现了、 方案1:集成第三方信鸽 (一般的杀不死,360 能杀死) 方案2: 自己有这方面的一个开发需求,所以这里就...

android 杀不死的服务 ,主要是即时通讯,通知及时传送

原本我是不想写的,但是看到网上各种稀奇古怪的方法,对于那些我早都测试过,测试结果,我早都忘记了,但是这样的demo(2014.7)做的这个demo..自己写的 ,还是别人给的建议我就忘记了,说重点,对...
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:深度学习:神经网络中的前向传播和反向传播算法推导
举报原因:
原因补充:

(最多只允许输入30个字)