android保活进程总结--双进程保活策略

最新推荐文章于 2024-08-02 20:22:23 发布
最新推荐文章于 2024-08-02 20:22:23 发布
阅读量4.4k 收藏 4
点赞数 3
分类专栏： android 文章标签： android
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_25497621/article/details/78865549
版权

进程的保活，在很多资讯类的App和即时通讯App的用处很大，奈何谷歌的推送服务在国内是被阉割了！据说是在8.0（奥利奥）相关政府机构已经将开放这项功能提上了日程，嗯，没错8.0，预计再过三五年就可以像苹果那样自由自在的推送了！但是一点不鸡冻，不知道我这秃头的码农还能不能挨到，哈哈！

先看看效果图：

这里写图片描述

这张图片的主要操作是杀死后台所有的应用进程，之后在状态栏上面弹出被拉起来的程！

测试机参数：

这里写图片描述

service：是一个后台服务，专门用来处理常驻后台的工作的组件。

一、优先级

进程的重要性优先级：（越往后的就越容易被系统杀死）
1.前台进程；Foreground process
1）用户正在交互的Activity（onResume（））
2）当某个Service绑定正在交互的Activity。
3）被主动调用为前台Service（startForeground()）
4）组件正在执行生命周期的回调（onCreate()/onStart()/onDestroy()）
5）BroadcastReceiver 正在执行onReceive();

2.可见进程；Visible process
1)我们的Activity处在onPause()（没有进入onStop()）
2)绑定到前台Activity的Service。

3.服务进程；Service process
简单的startService()启动。
4.后台进程；Background process
对用户没有直接影响的进程—-Activity出于onStop()的时候。
android:process=”:xxx”
5.空进程； Empty process
不含有任何的活动的组件。（android设计的，为了第二次启动更快，采取的一个权衡）

好了，基础知识回顾的差不多了！进入正题吧！

事先声明哈！其实是没有真正的进程的保活的，在手动杀死后台的时候，运行在系统后台的所有进程都是一一被杀死的，注意的是，一个一个被杀死的，所以我们才利用这个特性来做的！额。。中心思想即是，在应用被打开的时候，启动两个后台服务，这两个后台服务是相互依存的，也就是说，当一个进程被干掉的时候，另一个存活的进程就立马将其拉起唤醒，也就是打一个时间差！

嗯，上代码！

远程服务代码：

import android.app.Notification;
import android.app.PendingIntent;
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.support.v4.app.NotificationCompat;
import android.util.Log;
import android.widget.Toast;

public class RemoteService extends Service {

    public static final String TAG = "tianchuangxin";
    private MyBinder binder;
    private MyServiceConnection conn;

    @Override
    public IBinder onBind(Intent intent) {
        // TODO Auto-generated method stub
        return binder;
    }

    @Override
    public void onCreate() {
        // TODO Auto-generated method stub
        super.onCreate();
        if(binder ==null){
            binder = new MyBinder();
        }
        conn = new MyServiceConnection();
    }

    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        RemoteService.this.bindService(new Intent(RemoteService.this, LocalService.class), conn, Context.BIND_IMPORTANT);

        PendingIntent contentIntent = PendingIntent.getService(this, 0, intent, 0);
        NotificationCompat.Builder builder = new NotificationCompat.Builder(this);
        builder.setTicker("XXX")
        .setContentIntent(contentIntent)
        .setContentTitle("我是XXX，我怕谁!")
        .setAutoCancel(true)
        .setContentText("哈哈")
        .setWhen( System.currentTimeMillis());

        //把service设置为前台运行，避免手机系统自动杀掉改服务。
        startForeground(startId, builder.build());
        return START_STICKY;
    }

    class MyBinder extends RemoteConnection.Stub{

        @Override
        public String getProcessName() throws RemoteException {
            // TODO Auto-generated method stub
            return "LocalService";
        }

    }

    class MyServiceConnection implements ServiceConnection{

        @Override
        public void onServiceConnected(ComponentName name, IBinder service) {
            Log.i(TAG, "建立连接成功！");

        }

        @Override
        public void onServiceDisconnected(ComponentName name) {
            Log.i(TAG, "LocalService服务被干掉了~~~~断开连接！");
            Toast.makeText(RemoteService.this, "断开连接", 0).show();
            //启动被干掉的
            RemoteService.this.startService(new Intent(RemoteService.this, LocalService.class));
            RemoteService.this.bindService(new Intent(RemoteService.this, LocalService.class), conn, Context.BIND_IMPORTANT);
        }

    }


}

本地服务代码：

import com.dn.keepliveprocess.RemoteService.MyBinder;
import com.dn.keepliveprocess.RemoteService.MyServiceConnection;

import android.app.Notification;
import android.app.PendingIntent;
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.support.v4.app.NotificationCompat;
import android.util.Log;
import android.widget.Toast;

public class LocalService extends Service {

    public static final String TAG = "tianchaungxin";
    private MyBinder binder;
    private MyServiceConnection conn;

    @Override
    public IBinder onBind(Intent intent) {
        // TODO Auto-generated method stub
        return binder;
    }

    @Override
    public void onCreate() {
        // TODO Auto-generated method stub
        super.onCreate();
        if(binder ==null){
            binder = new MyBinder();
        }
        conn = new MyServiceConnection();
    }

    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        LocalService.this.bindService(new Intent(LocalService.this, RemoteService.class), conn, Context.BIND_IMPORTANT);

        PendingIntent contentIntent = PendingIntent.getService(this, 0, intent, 0);
        NotificationCompat.Builder builder = new NotificationCompat.Builder(this);
        builder.setTicker("XXX")
        .setContentIntent(contentIntent)
        .setContentTitle("我是XXX，我怕谁!")
        .setAutoCancel(true)
        .setContentText("哈哈")
        .setWhen( System.currentTimeMillis());

        //把service设置为前台运行，避免手机系统自动杀掉改服务。
        startForeground(startId, builder.build());
        return START_STICKY;
    }


    class MyBinder extends RemoteConnection.Stub{

        @Override
        public String getProcessName() throws RemoteException {
            // TODO Auto-generated method stub
            return "LocalService";
        }

    }

    class MyServiceConnection implements ServiceConnection{

        @Override
        public void onServiceConnected(ComponentName name, IBinder service) {
            Log.i(TAG, "建立连接成功！");

        }

        @Override
        public void onServiceDisconnected(ComponentName name) {
            Log.i(TAG, "RemoteService服务被干掉了~~~~断开连接！");
            Toast.makeText(LocalService.this, "断开连接", 0).show();
            //启动被干掉的
            LocalService.this.startService(new Intent(LocalService.this, RemoteService.class));
            LocalService.this.bindService(new Intent(LocalService.this, RemoteService.class), conn, Context.BIND_IMPORTANT);
        }

    }


}

JobService保证在息屏后，CPU进入休眠状态时进行唤醒

import java.util.List;

import android.annotation.SuppressLint;
import android.app.ActivityManager;
import android.app.ActivityManager.RunningServiceInfo;
import android.app.job.JobInfo;
import android.app.job.JobParameters;
import android.app.job.JobScheduler;
import android.app.job.JobService;
import android.content.ComponentName;
import android.content.Context;
import android.content.Intent;
import android.util.Log;
import android.widget.Toast;

@SuppressLint("NewApi")
public class JobHandleService extends JobService{
    private int kJobId = 0;
    @Override
    public void onCreate() {
        super.onCreate();
        Log.i("tianchuangxin", "jobService create");

    }

    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        Log.i("tianchuangxin", "jobService start");
        scheduleJob(getJobInfo());
        return START_NOT_STICKY;
    }

    @Override
    public void onDestroy() {
        // TODO Auto-generated method stub
        super.onDestroy();
    }

    @Override
    public boolean onStartJob(JobParameters params) {
        // TODO Auto-generated method stub
        Log.i("tianchuangxin", "job start");
//      scheduleJob(getJobInfo());
        boolean isLocalServiceWork = isServiceWork(this, 你的本地服务ref----XXXX.LocalService);
        boolean isRemoteServiceWork = isServiceWork(this, 你的远程服务ref----XXXX.RemoteService);
//      Log.i("INFO", "localSericeWork:"+isLocalServiceWork);
//      Log.i("INFO", "remoteSericeWork:"+isRemoteServiceWork);
        if(!isLocalServiceWork||
           !isRemoteServiceWork){
            this.startService(new Intent(this,LocalService.class));
            this.startService(new Intent(this,RemoteService.class));
            Toast.makeText(this, "process start", Toast.LENGTH_SHORT).show();
        }
        return true;
    }

    @Override
    public boolean onStopJob(JobParameters params) {
        Log.i("tianchuangxin", "job stop");
//      Toast.makeText(this, "process stop", Toast.LENGTH_SHORT).show();
        scheduleJob(getJobInfo());
        return true;
    }

    /** Send job to the JobScheduler. */
    public void scheduleJob(JobInfo t) {
        Log.i("tianchuangxin", "Scheduling job");
        JobScheduler tm =
                (JobScheduler) getSystemService(Context.JOB_SCHEDULER_SERVICE);
        tm.schedule(t);
    }

    public JobInfo getJobInfo(){
        JobInfo.Builder builder = new JobInfo.Builder(kJobId++, new ComponentName(this, JobHandleService.class));
        builder.setRequiredNetworkType(JobInfo.NETWORK_TYPE_ANY);
        builder.setPersisted(true);
        builder.setRequiresCharging(false);
        builder.setRequiresDeviceIdle(false);
        builder.setPeriodic(10);//间隔时间--周期
        return builder.build();
    }


    /** 
     * 判断某个服务是否正在运行的方法 
     *  
     * @param mContext 
     * @param serviceName 
     *            是包名+服务的类名（例如：net.loonggg.testbackstage.TestService） 
     * @return true代表正在运行，false代表服务没有正在运行 
     */  
    public boolean isServiceWork(Context mContext, String serviceName) {  
        boolean isWork = false;  
        ActivityManager myAM = (ActivityManager) mContext  
                .getSystemService(Context.ACTIVITY_SERVICE);  
        List<RunningServiceInfo> myList = myAM.getRunningServices(100);  
        if (myList.size() <= 0) {  
            return false;  
        }  
        for (int i = 0; i < myList.size(); i++) {  
            String mName = myList.get(i).service.getClassName().toString();  
            if (mName.equals(serviceName)) {  
                isWork = true;  
                break;  
            }  
        }  
        return isWork;  
    }  
}

AIDL定义


interface RemoteConnection{
    String getProcessName();
}

我们再在MainActivity中进行调用：

public class MainActivity extends Activity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        startService(new Intent(this, LocalService.class));
        startService(new Intent(this, RemoteService.class));
        startService(new Intent(this, JobHandleService.class));
    }

OK，所有代码基本在这了！哈哈！有问题的话留言交流！

每天进步一点点，时间会让你成为巨人！

我的Github地址：
https://github.com/T-chuangxin

一个貌似正经的屌丝
关注
专栏目录
探讨一种新型的双进程守护应用保活
老蒋也疯狂
12-06 2万+
在高版本Android系统中，应用能否常驻内存，我想一直以来都是某些APP头疼的事情。虽然APP常驻内存对于用户来说比较”恶心”，但是在一些特殊情况来说，APP的常驻内存却有尤其重要，很多时候用户也会要求APP能够保证长久运行。因此，这里只研究APP应用在一些特殊场合的保活方法，内容仅供参考。
android 进程保活
10-31
android 进程保活 , 保证后台提交数据的服务一 直运行
Android进程保活
baidu_33575737的博客
02-25 264
http://blog.csdn.net/marswin89/article/details/50917098
Android进程保活：如何让app一直运行
最新发布
qq_40853919的博客
08-02 1569
1）为什么需要进行进程保活呢？需求是什么？2）进程分类3）进程的优先级4）如何提高进程优先级5）如何进行进程保活。
Android 推送进程保活
汨卅的博客
02-28 3975
https://www.jianshu.com/p/63aafe3c12af# http://blog.csdn.net/jhl122/article/details/53433594 https://www.jianshu.com/p/b7b9316c57cd https://www.jianshu.com/p/b16631a2fe3c http://pp1230.github.io/2...
安卓进程保活
qq_32664007的博客
06-10 3953
进程保活的方式安卓杀死进程的一些机制保活的一些方式一像素保活法前台服务保活法 安卓杀死进程的一些机制 安卓中的进程主要分为以下五种： 1、前台进程 Foreground Process 2、可见进程 Visible Process 3、服务进程 Service Process 4、后台进程 Background Process 5、空进程 Empty Process 安卓的机制是在内存达到一定的阈值时就会杀死对应的等级进程。查看阈值的方法如下图（单位是4KB）。当然，这是在不同的定制系统上会有差异，手机厂商
【Android 进程保活】应用进程拉活 ( 双进程守护保活 ) 修改.zip
04-11
【Android 进程保活】应用进程拉活 ( 双进程守护保活 ) https://hanshuliang.blog.csdn.net/article/details/115604667 博客源码快照
【Android 进程保活】应用进程拉活 ( 双进程守护 + JobScheduler 保活 ).zip
04-11
【Android 进程保活】应用进程拉活 ( 双进程守护 + JobScheduler 保活 | 成功率最高 | 推荐使用 ) https://hanshuliang.blog.csdn.net/article/details/115607584 博客源码快照
Android JNI 进程保活
07-16
4. 系统限制：Android系统有防止应用滥用后台进程的策略，过度的进程保活可能导致应用被系统标记为恶意，影响用户评分和应用商店的推荐。 综上所述，Android JNI进程保活涉及对Android系统进程管理、服务、JNI以及...
android 进程保活，
01-24
提高应用在后台被杀死后，提高进程的等级，防止程序到了后台被意外杀死
Android 进程保活
Memory_of_the_wind的博客
03-28 241
在系统内存不足的情况下，系统会依据自身的一套进程回收机制来回收掉一些进程，以腾出内存来供给需要的app，这套进程回收机制就叫做Low Memory Killer。然而某些应用需要在后台常驻以满足一些需求，比如后台接收推送消息等。那么如何保持进程常驻呢，总结了如下方案： 1.利用Android前台Service的漏洞，之前看Tinker源码发现也是使用这种方式。 具体步骤：对于Api < 18...
Android进程保活技术解析
本文将探讨几种常见的Android进程保活策略，并强调了对用户体验和系统性能的影响。 首先，我们了解下Android系统中的进程管理机制。Android系统会根据进程的重要性对其进行分类，从高到低分别为前台进程、可见进程...
评论 7
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值