Android 进程保活,点击home键 或者 点击back键盘 、锁屏、息屏保证服务器定时器不会阻塞

点击home键 或者 点击back键盘 、锁屏、息屏，保活，保证定时器不会被阻塞，如果用户直接杀死App，那么无法保活

 进程保护状态：
  android 进程优先级：
https://www.cnblogs.com/lixiansheng/p/11359937.html
 前台进程
 可视进程： activy有弹框
 服务进程： activity退出,后台服务在运行
 后台进程:  没有服务，activity退出
 空进程

 **进程管理策略：
进程启动分为 冷启动和热启动  
 热启动：当用户退出某一个进程的时候,并不会真正的进程退出,而是把这个进程放入后台,已便下次启动的时候可以马上启动起来,
 这个是 Android设置理念之一,  这个机制带来问题, 每个进程都有自己独立内存，打开数量增多，系统内存越来越大,导致系统内存不足,
 解决：   系统引入 LowmemoryKiller(简称:lmk)  来管理所有进程, 根据一定策略kill某个进程 释放占用内存，保证系统正常运行

 ** LMK 基本原理
 所有进程都是从zygote 孵化出来的, 记录在AMS的 mLruProcess 列表中, 由于AMS统一 管理, 
AMS 中会根据 进程状态更新进程的 oom_odj 值 ，这个值会传递到 kernel中， kernel中 有 低内存回收机制，
在内存 达到一定阀 值的时候触发 清理 oom_odj值 腾出更多空间  

**  LMK 杀进程标准

1. 1px Activity

屏幕熄灭的时候 启动一个 1px Activity ,在灭屏的时候关闭，提高进程的优先级，进程保活【具体看源码实现】

2.    前台Service startForeground， 提高service 的服务的优先级

ForegroundService.java文件 

package ndkdemo.denganzhi.com.myapplication.service;

import android.app.Notification;
import android.app.NotificationChannel;
import android.app.NotificationManager;
import android.app.Service;
import android.content.Context;
import android.content.Intent;
import android.os.Build;
import android.os.Handler;
import android.os.IBinder;
import android.support.annotation.Nullable;
import android.support.v4.app.NotificationCompat;
import android.util.Log;

/**
 * @author Damon
 * @Date 2019/5/30 22:45
 */
public class ForegroundService extends Service {
    @Nullable
    @Override
    public IBinder onBind(Intent intent) {
        return null;
    }

    private static final String TAG = "ForegroundService";
    final Handler mHandler = new Handler();
    Runnable r = new Runnable() {
        @Override
        public void run() {
             Log.e(TAG,"ForegroundService-->定时器在运行......");
            //do something
            //每隔1s循环执行run方法
            mHandler.postDelayed(this, 1000);
        }
    };


    @Override
    public void onCreate() {
        super.onCreate();
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
            NotificationChannel channel = new NotificationChannel("deamon", "deamon",
                    NotificationManager.IMPORTANCE_LOW);
            NotificationManager manager = (NotificationManager) getSystemService(Context.NOTIFICATION_SERVICE);
            if (manager == null)
                return;
            manager.createNotificationChannel(channel);

            Notification notification = new NotificationCompat.Builder(this, "deamon").setAutoCancel(true).setCategory(
                    Notification.CATEGORY_SERVICE).setOngoing(true).setPriority(
                    NotificationManager.IMPORTANCE_LOW).build();
            startForeground(10, notification);
        } else if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN_MR2) {
            //如果 18 以上的设备 启动一个Service startForeground给相同的id
            //然后结束那个Service
            // 结果 启动 ForegroundService  关闭通知
            startForeground(10, new Notification());
            startService(new Intent(this, InnnerService.class));
        } else {
            /**
             * 在API18以下，直接调用startForeground(ID， new Notification())，发送空的Notification ，将后台服务推到前台成为前台Service，这样即使退出应用，或者在Recent Task中删除该应用，前台Service依然存在，应用的优先级依然很高
             * 这样能实现的原理其实是Android的一个漏洞，发送一个空的Notification，通知栏并不会显示我们发送的Notification，这样用户就不知道你的应用还是在运行了，真正的做到了用户无感知下的进程保活
             */
            startForeground(10, new Notification());
        }


        //主线程中调用：
        mHandler.postDelayed(r, 100);//延时100毫秒

    }

    public static class InnnerService extends Service {

        @Override
        public void onCreate() {
            super.onCreate();
            startForeground(10, new Notification());
            stopSelf();
        }

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

配置文件： 

<service
            android:name="ndkdemo.denganzhi.com.myapplication.service.ForegroundService"
            android:enabled="true"
            android:exported="true"></service>

启动前台服务： 

btn1.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
             //   2.    前台Service， 提高service 的服务的优先级
                Intent service=new Intent(MainActivity.this,ForegroundService.class);
                if (Build.VERSION.SDK_INT >= 26) {
                    startForegroundService(service);
                } else {
                    startService(service);
                }

            }
        });

3.   JobScheduler 使用   就是一个定时器

package ndkdemo.denganzhi.com.myapplication.jobscheduler;

import android.annotation.SuppressLint;
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.os.Build;
import android.os.IBinder;
import android.support.annotation.Nullable;
import android.support.annotation.RequiresApi;
import android.util.Log;

import java.util.Date;

/***
 *  就是一个定时器
 */
@SuppressLint("NewApi")
public class MyJobService extends JobService {
    private static final String TAG = "MyJobService";

    public static void startJob(Context context) {
        JobScheduler jobScheduler = (JobScheduler) context.getSystemService(
                Context.JOB_SCHEDULER_SERVICE);
        JobInfo.Builder builder = new JobInfo.Builder(10,
                new ComponentName(context.getPackageName(),
                        MyJobService.class.getName())).setPersisted(true);
        /**
         * I was having this problem and after review some blogs and the official documentation,
         * I realised that JobScheduler is having difference behavior on Android N(24 and 25).
         * JobScheduler works with a minimum periodic of 15 mins.
         * android7 以后
         *
         */
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N){
            //7.0以上延迟1s执行， api 调用
            builder.setMinimumLatency(1000);
        }else{
            //每隔1s执行一次job
            builder.setPeriodic(1000);
        }
        jobScheduler.schedule(builder.build());
    }

    @Override
    public boolean onStartJob(JobParameters jobParameters) {
        Log.e(TAG,"开启job:"+ new Date());
        //7.0以上轮询
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N){
            startJob(this);
        }

        return false;
    }

    @Override
    public boolean onStopJob(JobParameters jobParameters) {
        return false;
    }
}

 配置文件： 

 <!--  jobSchdule  需要权限  -->
    <uses-permission android:name="android.permission.RECEIVE_BOOT_COMPLETED" />  
 <!-- JobSevice 服务 --> 
 <service android:name=".jobscheduler.MyJobService"
            android:permission="android.permission.BIND_JOB_SERVICE"/>

 启动JobSchduleService:  

 btn2.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
            //     3.   JobScheduler 使用   就是一个定时器
                MyJobService.startJob(MainActivity.this);
            }
        });

4.  双进程守护 

成活率是最高的 上面几种   双服务+ JobSchdule

 LocalService.java   A 服务， A 绑定B 服务，监听到 B服务 onServiceDisconnected ，重新启动B 服务

package ndkdemo.denganzhi.com.myapplication.twoservice;

import android.app.Notification;
import android.app.NotificationChannel;
import android.app.NotificationManager;
import android.app.Service;
import android.content.ComponentName;
import android.content.Context;
import android.content.Intent;
import android.content.ServiceConnection;
import android.os.Build;
import android.os.Handler;
import android.os.IBinder;
import android.os.RemoteException;
import android.support.annotation.Nullable;
import android.support.v4.app.NotificationCompat;
import android.util.Log;

import ndkdemo.denganzhi.com.myapplication.IMyAidlInterface;


public class LocalService extends Service {
    private MyBinder myBinder;

    private static final String TAG = "twoservice";

    final Handler mHandler = new Handler();
    Runnable r = new Runnable() {
        @Override
        public void run() {
            Log.e(TAG,"LocalService-->定时器在运行......");
            //do something
            //每隔1s循环执行run方法
            mHandler.postDelayed(this, 1000);
        }
    };


    class MyBinder extends IMyAidlInterface.Stub{

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

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

    @Override
    public void onCreate() {
        super.onCreate();
        myBinder = new MyBinder();
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
            NotificationChannel channel = new NotificationChannel("deamon", "deamon",
                    NotificationManager.IMPORTANCE_LOW);
            NotificationManager manager = (NotificationManager) getSystemService(
                    Context.NOTIFICATION_SERVICE);
            if (manager == null)
                return;
            manager.createNotificationChannel(channel);

            Notification notification = new NotificationCompat.Builder(this,
                    "deamon").setAutoCancel(true).setCategory(
                    Notification.CATEGORY_SERVICE).setOngoing(true).setPriority(
                    NotificationManager.IMPORTANCE_LOW).build();
            startForeground(10, notification);
        } else if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN_MR2) {
            //如果 18 以上的设备 启动一个Service startForeground给相同的id
            //然后结束那个Service
            startForeground(10, new Notification());
            startService(new Intent(this, InnnerService.class));
        } else {
            startForeground(10, new Notification());
        }
    }

    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {

        //主线程中调用：
        mHandler.postDelayed(r, 100);//延时100毫秒

        bindService(new Intent(this, RemoteService.class), new MyServiceConnection(),
                BIND_AUTO_CREATE);
        return super.onStartCommand(intent, flags, startId);
    }

    private class MyServiceConnection implements ServiceConnection {

        @Override
        public void onServiceConnected(ComponentName componentName, IBinder iBinder) {
            //回调

        }

        @Override
        public void onServiceDisconnected(ComponentName componentName) {
            //
            startService(new Intent(LocalService.this, RemoteService.class));
            bindService(new Intent(LocalService.this, RemoteService.class), new MyServiceConnection(),
                    BIND_AUTO_CREATE);
        }
    }

    public static class InnnerService extends Service {

        @Override
        public void onCreate() {
            super.onCreate();
            startForeground(10, new Notification());
            stopSelf();
        }

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

 RemoteService .java   B 服务，B 绑定 A服务，监听到 A 服务 onServiceDisconnected ，重新启动 A服务

package ndkdemo.denganzhi.com.myapplication.twoservice;

import android.app.Notification;
import android.app.NotificationChannel;
import android.app.NotificationManager;
import android.app.Service;
import android.content.ComponentName;
import android.content.Context;
import android.content.Intent;
import android.content.ServiceConnection;
import android.os.Build;
import android.os.Handler;
import android.os.IBinder;
import android.os.RemoteException;
import android.support.annotation.Nullable;
import android.support.v4.app.NotificationCompat;
import android.util.Log;

import ndkdemo.denganzhi.com.myapplication.IMyAidlInterface;


public class RemoteService extends Service {
    private MyBinder myBinder;


    private static final String TAG = "twoservice";

    final Handler mHandler = new Handler();
    Runnable r = new Runnable() {
        @Override
        public void run() {
            Log.e(TAG,"RemoteService-->定时器在运行......");
            //do something
            //每隔1s循环执行run方法
            mHandler.postDelayed(this, 1000);
        }
    };

    class MyBinder extends IMyAidlInterface.Stub {

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

        }
    }

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

    @Override
    public void onCreate() {
        super.onCreate();
        myBinder = new MyBinder();
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
            NotificationChannel channel = new NotificationChannel("deamon", "deamon",
                    NotificationManager.IMPORTANCE_LOW);
            NotificationManager manager = (NotificationManager) getSystemService(
                    Context.NOTIFICATION_SERVICE);
            if (manager == null)
                return;
            manager.createNotificationChannel(channel);

            Notification notification = new NotificationCompat.Builder(this,
                    "deamon").setAutoCancel(true).setCategory(
                    Notification.CATEGORY_SERVICE).setOngoing(true).setPriority(
                    NotificationManager.IMPORTANCE_LOW).build();
            startForeground(10, notification);
        } else if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN_MR2) {
            //如果 18 以上的设备 启动一个Service startForeground给相同的id
            //然后结束那个Service
            startForeground(10, new Notification());
            startService(new Intent(this, InnnerService.class));
        } else {
            startForeground(10, new Notification());
        }
    }

    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        bindService(new Intent(this, LocalService.class), new MyServiceConnection(),
                BIND_AUTO_CREATE);

        //主线程中调用：
        mHandler.postDelayed(r, 100);//延时100毫秒

        return super.onStartCommand(intent, flags, startId);
    }

    private class MyServiceConnection implements ServiceConnection {

        @Override
        public void onServiceConnected(ComponentName componentName, IBinder iBinder) {

        }

        @Override
        public void onServiceDisconnected(ComponentName componentName) {
            startService(new Intent(RemoteService.this, LocalService.class));
            // 当服务死了，断开，重新互相绑定， 重新唤醒服务
            bindService(new Intent(RemoteService.this, LocalService.class),
                    new MyServiceConnection(), BIND_AUTO_CREATE);
        }
    }

    public static class InnnerService extends Service {

        @Override
        public void onCreate() {
            super.onCreate();
            startForeground(10, new Notification());
            stopSelf();
        }

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

StartMyJobService.java JobSchdule中监听服务是否被杀死，如果服务不在了启动服务，3向保证

package ndkdemo.denganzhi.com.myapplication.twoservice;

import android.annotation.SuppressLint;
import android.app.ActivityManager;
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.ContentResolver;
import android.content.Context;
import android.content.Intent;
import android.os.Build;
import android.text.TextUtils;
import android.util.Log;

import java.util.List;



@SuppressLint("NewApi")
public class StartMyJobService extends JobService {
    private static final String TAG = "twoservice";

    public static void startJob(Context context) {
        JobScheduler jobScheduler = (JobScheduler) context.getSystemService(
                Context.JOB_SCHEDULER_SERVICE);
        JobInfo.Builder builder = new JobInfo.Builder(10,
                new ComponentName(context.getPackageName(),
                        StartMyJobService.class.getName())).setPersisted(true);
        /**
         * I was having this problem and after review some blogs and the official documentation,
         * I realised that JobScheduler is having difference behavior on Android N(24 and 25).
         * JobScheduler works with a minimum periodic of 15 mins.
         *
         */
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
            //7.0以上延迟1s执行
            builder.setMinimumLatency(1000);
        } else {
            //每隔1s执行一次job
            builder.setPeriodic(1000);
        }
        jobScheduler.schedule(builder.build());
    }

    @Override
    public boolean onStartJob(JobParameters jobParameters) {
        Log.e(TAG, "StartMyJobService-->开启job");
        //7.0以上轮询
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
            startJob(this);
        }
        //判断服务是否在运行
        boolean isLocalServiceRun = isServiceRunning(this, LocalService.class.getName());
        boolean isRemoteServiceRun = isServiceRunning(this, RemoteService.class.getName());
        // 在jdbschdule 中如果服务死了，立刻拉活
        if (!isLocalServiceRun || !isRemoteServiceRun) {

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

    private boolean isServiceRunning(Context context, String serviceName) {
        ActivityManager am = (ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE);
        List<ActivityManager.RunningServiceInfo> runningServices = am.getRunningServices(10);
        for (ActivityManager.RunningServiceInfo runningService : runningServices) {
            if (TextUtils.equals(runningService.service.getClassName(), serviceName)) {
                return true;
            }
        }

        return false;
    }

    @Override
    public boolean onStopJob(JobParameters jobParameters) {
        return false;
    }
}

IMyAidlInterface.aidl

// IMyAidlInterface.aidl
package ndkdemo.denganzhi.com.myapplication;

// 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);
}

 启动A，B 服务，启动JobSchdule:

       btn3.setOnClickListener(new View.OnClickListener() {
           @Override
           public void onClick(View v) {

               //  4.  双进程  成活率是最高的
               startService(new Intent(MainActivity.this, LocalService.class));
               startService(new Intent(MainActivity.this, RemoteService.class));
               StartMyJobService.startJob(MainActivity.this);
           }
       });

Android  Studio模拟现象：

5.  广播拉活， 比如自家的2个APP，自定义广播
6.  厂商推送拉活

 参考： https://blog.csdn.net/ck15221693760/article/details/94391699

 源码地址：https://download.csdn.net/download/dreams_deng/12438758

 

5.  闹钟

 alarmManager 是一个全局定时器 ，可以在指定时间或 指定周期 启动其他组件 Activity,Service,broadReciver ， 不仅仅是闹钟，但是实际没有什么软用

package com.denganzhi.guestmodel;

import android.app.AlarmManager;
import android.app.PendingIntent;
import android.app.TimePickerDialog;
import android.content.Context;
import android.content.Intent;
import android.os.Build;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.widget.Button;
import android.widget.Toast;

import java.util.Calendar;

public class NaoZhongActivity extends AppCompatActivity {
    private AlarmManager aManager;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_nao_zhong);

        // 获取AlarmManager对象
        aManager = (AlarmManager) getSystemService(Context.ALARM_SERVICE);
        // 获取程序界面上的按钮
        Button setTimeBn = findViewById(R.id.setTime);
        // 为“设置闹铃”按钮绑定监听器
        setTimeBn.setOnClickListener(view -> {
            Calendar currentTime = Calendar.getInstance();
            // 创建一个TimePickerDialog实例，并把它显示出来
            new TimePickerDialog(NaoZhongActivity.this, 0, // 绑定监听器
                    (dialog, hourOfDay, minute) -> {
                        // 指定启动AlarmActivity组件
                        // 这里可以启动一个 Activity ，比如播放音乐
                        Intent intent = new Intent(NaoZhongActivity.this, AlarmActivity.class);
                        // 创建PendingIntent对象
                        PendingIntent pi = PendingIntent.getActivity(NaoZhongActivity.this, 0, intent, 0);
                        Calendar c = Calendar.getInstance();
                        // 根据用户选择时间来设置Calendar对象
                        c.set(Calendar.HOUR_OF_DAY, hourOfDay);
                        c.set(Calendar.MINUTE, minute);
                        // 设置AlarmManager将在Calendar对应的时间启动指定组件
                        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) { // 6.0及以上
                            /***
                             *  alarmManager 是一个全局定时器 ，可以在指定时间或 指定周期 启动其他组件 Activity,Service,broadReciver
                             *
                             * set(@AlarmType int type, long triggerAtMillis, PendingIntent operation) {
                             *         setImpl(type, triggerAtMillis, legacyExactLength(), 0, 0, operation, null, null,
                             *                 null, null, null)
                             *
                             *  type：枚举,
                             *      AlarmManager.ELAPSED_REALTIME:
                             *      执行从现在开始 时间 过了 一定时间 后启动 operate对应组件
                             *         AlarmManager.ELAPSED_REALTIME_WAKEUP:
                             *          上面 的扩展 即使 系统处于 休眠状态
                             *
                             *     RTC_WAKEUP :  指定系统 调用 System.currentTimeMillis() 方法的 返回值 与  triggerAtMillis 相等时
                             *     启动 pi 对应组件 ， 系统处于休眠状态 也会执行 即使
                             *
                             */


                            aManager.setExactAndAllowWhileIdle(AlarmManager.RTC_WAKEUP,
                                    c.getTimeInMillis(), pi);
                        } else if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT) { // 4.4及以上
                            aManager.setExact(AlarmManager.RTC_WAKEUP, c.getTimeInMillis(), pi);
                        }
                        else {
                            aManager.set(AlarmManager.RTC_WAKEUP, c.getTimeInMillis(), pi);
                        }


                        /**
                         * setInexactRepeating (@AlarmType int type, long triggerAtMillis,
                         *             long intervalMillis, PendingIntent operation)
                         *             每小时启动过一次 比如
                         *  setRepeating(@AlarmType int type, long triggerAtMillis,
                         *             long intervalMillis, PendingIntent operation)
                         *             设置一个周期定时任务
                         *
                         */

                        // 显示闹铃设置成功的提示信息
                        Toast.makeText(NaoZhongActivity.this, "闹铃设置成功啦",
                                Toast.LENGTH_SHORT).show();
                    },currentTime.get(Calendar.HOUR_OF_DAY),
                    currentTime.get(Calendar.MINUTE), false).show();
        });

    }
}