在系统内存不足的情况下，有一套杀进程回收内存的机制叫Low Memory Killer。
内存阈值，单位是4KB。

如何判断继承优先级：
通过oom_adj值，判断进程的优先级，不同的手机oom_adj值可能不同。

adj算法：状态、内存占用。

一像素保活法：

在后台的时候，把状态改成前台的。
手机关闭屏幕时，偷偷创建一个Activity，让应用成为前台进程；打开屏幕时，关闭该Activity。

缺点：存在一个Activity不够干净，同时也需要在锁屏后才能实现。

image.png

<style name="KeepTheme">
  // 设置背景，透明
    <item name="android:windowBackground">@null</item>
    <item name="android:windowIsTranslucent">true</item>
</style>
<activity  android:name=".activity.KeepActivity"
  android:excludeFromRecents="true"
  android:taskAffinity="com.enjoy.daemon.keep"
  android:theme="@style/KeepTheme"
/>
// android:excludeFromRecents 最近清单，隐藏activity最近清单。
// taskAffinity 专门创建新的后台任务栈，来管理1像素activity。

public class KeepReceiver extends BroadcastReceiver {
    private static final String TAG = "KeepReceiver";
    @Override
    public void onReceiver(Context context,  Intent intent) {
        String action = intent.getAction();
        Log.e(TAG, "onReceiver："+action);
        if(TextUtils.equals(action, Intent.ACTION_SCREEN_OFF)) {
          // 关闭屏幕时，开启1像素activity
          KeepManager.getInstance().startKeep(context);
        } else if(TextUtils.equals(action, Intent.ACTION_SCREEN_ON){
          // 打开屏幕时，关闭1像素activity
          KeepManager.getInstance().finishKeep();
        }
   } 
}

MainActivity注册：

protected void onCreate(Bundle savedInstance) {
    super.onCreate(savedInstance);
    setContentView(R.layout.activity_main);
    KeepManager.getInstance().registerKeep(this);
}

KeepManager

public  class KeepManager {
    private static final KeepManager mInstance = new KeepManager();
    private KeepReceiver mKeepReceiver;
    // 当jvm回收垃圾时，无论内存是否充足，都回收弱引用关联的对象。     
    private WeekReference<Activity> mKeepActivity;
    private KeepManager() {}
    public static KeepManager getInstance() { return mInstance;}

// 注册开屏，关屏幕广播
    public void registerKeep(Context context) {
      IntentFilter filter = new IntentFilter();
      filter.addAction(Intent.ACTION_SCREEN_ON);
      filter.addAction(Intent.ACTION_SCREEN_OFF);
       mKeepReceiver = new KeepReceiver();
      context.registerReceiver(mKeepReceiver, filter);
    }
// 注销广播接受者
    public void unregisterKeep(Context context) {
      if(mKeepReceiver != null) {
          context.unregisterReceiver(mKeepReceiver);
      }
    }
  // 开启1像素activity
  public void startKeep(Context context) {
    Intent intent = new Intent(context, KeepActivity.class);
    intent.setFlags(Intent.FLAG_ACTIVIEY_NEW_TASK); // 关键。
    context.startActivity(intent);
  }
  // 关闭1像素activity 
  public void finishKeep() {
    if(mKeepActivity !=null) {
        Activity activity = mKeepActivity.get();
        if(activity !=null) {
          activity.finish();
        }
        mKeepActivity = null;
    }
  }
  // 设置弱引用
  public void setKeep(KeepActivity keep) {
      mKeepActivity = new WeakReference<Activity>(keep);
  }
}

KeepActivity.java

public class KeepActivity extends Activity {
  private static final String TAG = "KeepActivity";
  @Override
  protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    Log.e(TAG, "启动keep");
    
    Window window = getWindow();
    window.setGravity(Gravity.START | Gravity.TOP);
    WindowManager.LayoutParams params = window.getAttributes();
    params.width =1; // 设置宽高，坐标。
    params.height =1;
    params.x =params.y =0;
    window.setAttributes(params);
    KeepManager.getInstance().setKeep(this);
  }  
  @Override
  protected void onDestroy() {
    super.onDestroy();
    Log.e(TAG, "关闭keep");
  }
}

2 前台服务保活。系统认可的保活。

原理：启动一个前台服务，从而拉高整个应用的优先级。
需要适配：
API < 18 通知图标不会显示
API >=18 && API <26 可以启动双服务，绑定同样的ID，然后stop一个服务，通知图标将不显示。
API >=26,后暂时没有方式能隐藏通知。

1. 前台进程。
   用户当前操作必须的进程，如果一个进程满足以下任一条件，即视为前台进程：

• 托管用户正在交互的activity(已调用Activity的onResume方法)
• 托管某个Service，后者绑定到用户正在交互的Activity。
• 托管正在“前台”运行的Service(服务已调用startForeground())
• 托管正执行一个声明周期回调的Service(onCreate, onStart,onDestroy)
• 托管正执行其onReceive方法的BroadcastReceiver。

// 前台服务。
public class ForegroundService extends Service {
    @Nullable
    @Override
    public IBinder onBind(Intent intent) {
        return null;
    }

    @Override
    public void onCreate() {
        super.onCreate();
        // 启动前台服务。
        startForeground(1, new Notification());
        startService(new Intent(this, InnerService.class));
    }

    // 8.0之前去掉通知，不让用户感知。使用双重Service。
    // 8.0之后，启动前台服务，必须告知用户。要自己处理。
    public class InnerService extends Service {
        @Nullable
        @Override
        public IBinder onBind(Intent intent) {
            return null;
        }
        @Override
        public void onCreate() {
            super.onCreate();
            startForeground(1, new Notification());
            // id必须相同
            stopSelf();
        }
    }
}

/// oom_adj
startService(new Intent(this, ForegroundService.class));
8.0之前，再创建一个服务InnerService。

拉活

广播拉活，已经挂掉了，让app起死回生。

在发生特定系统事件时，系统会发出广播，通过AndroidManifest中静态注册对应的广播监听器，即可在发生响应事件时拉活。
但是在7.0开始，对广播就行了限制，8.0更加严格。

• 系统广播拉活-----自己拉活自己。
• 用户广播拉活-----勉强可以使用。eg：大公司产品app相互拉活；

Service系统机制拉活

START_STICKER：
黏性：如果service进程被kill掉，保留service的状态为开启状态，但不保留递送的intent对象。随后系统会尝试重新创建service，由于服务状态为开启状态，所以创建服务后一定会调用onStartCommand方法。如果在此期间任何启动命令被传递到service，那么参数Intent将为null。
START_NOT_STICKER：
"非粘性"：使用这个返回值时，如果在执行完onStartCommand后，服务被异常kill掉。系统不会自动重启该服务。

START_REDELIVER_INTENT：
重传intent。使用这个返回值时，如果在执行完onStartCommand后，服务被异常kill，系统会自动重启该服务，并将Intent的值传入。
START_STICKY_COMPATIBILITY：
START_STICKER的兼容版本，但不保证服务被kill后一定能重启。

只要targetSdkVersion不小于5，默认是START_STICKER。
但是某些ROM系统不会拉活。经测试，Service第一次被异常杀死后，很快会重启，第二次会比第一次慢，第三次又比前一次慢，一旦在短时间内Service被杀死4-5次，则系统不再拉起。

public class StickyService extends Service {
    @Nullable
    @Override
    public IBinder onBind(Intent intent) {
        return null;
    }
    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        return super.onStartCommand(intent, flags, startId);
    }
}

3. 账户同步拉活

通过账户同步机制，同步账户信息。
<user-permission android:name="android.permission.WRITE_SYNC_SETTINGS"/>
action - 是系统找到服务的依据。

AccountHelper.addAccount(this);
AccountHelper.autoSync(); // 同步app，拉活。
系统同步：每隔一段时间，才会同步。一般20~30分钟。
优点：系统唤醒，比较稳定。
缺点：时间不好把控，受系统限制。

4. JobScheduler拉活

JobScheduler允许在特定状态与特定时间间隔周期执行任务。可以利用它的这个特点完成保活的功能，效果如开启一个定时器，与普通定时器不同的是其调度由系统完成。
某些Rom可能不能达到效果。

// 需要增加权限：RECEIVE_BOOT_COMPLETED
JobInfo.Builder builder = new JobInfo.Builder(8, 
  new ComponentName(context.getPackageName(), MyJobService.class.getName())).setPersisted(true);
// 小于7.0
if(Builder.VERSION.SDK_INT < Builder.VERSION_CODES.N) {
  // 每秒执行一次job.版本23开始改进了，最小周期为5s。
  builder.setPeriodic(1000);
} else {
  // 执行延迟任务。
  builder.setMininumLatency(1000);
}
jobScheduler.schedule(builder.build());

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.os.Build;
import android.util.Log;

// 调用： MyJobService.startJob(this);
// <service android:name=".jobscheduler.MyJobService"
//    android:permission="android.permission.BIND_JOB_SERVICE"/>
@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(8,
                new ComponentName(context.getPackageName(), MyJobService.class.getName())).setPersisted(true);
        // 小于7.0
        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.N) {
            // 每秒执行一次job.版本23开始改进了，最小周期为5s。
            builder.setPeriodic(1000);
        } else {
            // 执行延迟任务。
            builder.setMinimumLatency(1000);
        }
        jobScheduler.schedule(builder.build());
    }
    @Override
    public boolean onStartJob(JobParameters params) {
        Log.e(TAG, "onStartJob");
        // 7.0以上，轮询。
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
            startJob(this);
        }
        return false;
    }
    @Override
    public boolean onStopJob(JobParameters params) {
        return false;
    }
}

5. WorkManager 拉活, 推送保活，无声音乐保活，双进程，白名单保活。

多进程， Binder， AIDL