關于Android程序保活

最近開發了個需要程序不被殺死的功能，很麻煩，我在網上找了很久關于程序常駐、程序保活等等的文章，很多文章寫得都很亂，而且也很雜亂。而且很多都是過時了的方法，有很多都是Android5.0之前的方法。

程序保活就需要先了解一下Android的程序回收機制Low Memory Killer:

Low Memory Killer基于Linux核心的 OOM Killer機制誕生的程序回收記憶體的機制。在系統記憶體不足的情況下，系統開始依據自身的一套程序回收機制來判斷要kill掉哪些程序，以騰出記憶體來供給需要的app

我看很多文章都列舉了黑灰白的保活方法，在這裡先介紹一下這三種方法:

黑色保活

黑色保活手段主要是指利用不同的app程序廣播來進行互相的喚醒。有的是利用系統的廣播來喚醒他的app，有的是在你介入第三方SDK就會喚醒他們的app程序，如微信sdk會喚醒微信，支付寶sdk會喚醒支付寶。還有類似阿裡騰訊等等公司都有自己一個系列的app，那麼如果你打開他們這個系列的app。他們這個系列其他的app也會被喚醒。

這種喚醒方法很消耗手機，安卓手機比蘋果手機用起來卡很大原因就是因為這一塊互相喚醒導緻的，用很多類似安全管家之類的都可以看到這些喚醒啟動，但是一般要有root權限才能關閉喚醒自啟。

白色保活

白色保活手段是指啟動service時會發出一個notification消息在通知欄，用于和service綁定，這樣提高service的優先級，被推遲收回，保證service存活。

service的onCreate方法裡面添加如下代碼：

Notification.Builder builder = new Notification.Builder(this);
        builder.setContentInfo("補充内容");
        builder.setContentText("正在運作...");
        builder.setContentTitle("進行标題");
        builder.setSmallIcon(R.mipmap.appicon);
        builder.setTicker("新消息");
        builder.setAutoCancel(true);
        builder.setWhen(System.currentTimeMillis());
        Intent notificationIntent = new Intent(this, TaskDetailActivity.class);


        PendingIntent pendingIntent = PendingIntent.getActivity(this, 0, notificationIntent, 0);
        builder.setContentIntent(pendingIntent);
        Notification notification = null;
        if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.JELLY_BEAN) {
            notification = builder.build();
        }else{
            notification = builder.getNotification();
        }
        //把該service建立為前台service
        startForeground(1, notification);

這段代碼就是建立一個notification然後利用startForeground來讓你的服務在前台運作，要從前台删除服務，需要調用stopForeground()方法，這個方法需要一個布爾型參數，訓示是否删除狀态欄通知。這個方法不終止服務。但是，如果你終止了正在運作的前台服務，那麼通知也會被删除。

前台服務是哪些被認為使用者知道的并且在記憶體低的時候不允許系統殺死的服務。前台服務必須給狀态欄提供一個通知，他被放到了“正在進行中（Ongoing）”标題之下，這就意味着直到這個服務被終止或從前台删除通知才能被解除。

灰色保活

灰色保活，這種保活手段是應用範圍最廣泛。它是利用系統的漏洞來啟動一個前台的Service程序，與普通的啟動方式差別在于，它不會在系統通知欄處出現一個Notification，看起來就如同運作着一個背景Service程序一樣。這樣做帶來的好處就是，使用者無法察覺到你運作着一個前台程序（因為看不到Notification）,但你的程序優先級又是高于普通背景程序的。那麼如何利用系統的漏洞呢，大緻的實作思路和代碼如下：

public class GrayService extends Service {

    private final static int GRAY_SERVICE_ID = 1001;

    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        if (Build.VERSION.SDK_INT < 18) {
            startForeground(GRAY_SERVICE_ID, new Notification());//API < 18 ，此方法能有效隐藏Notification上的圖示
        } else {
            Intent innerIntent = new Intent(this, GrayInnerService.class);
            startService(innerIntent);
            startForeground(GRAY_SERVICE_ID, new Notification());
        }

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

    ...
    ...

    /**
     * 給 API >= 18 的平台上用的灰色保活手段
     */
    public static class GrayInnerService extends Service {

        @Override
        public int onStartCommand(Intent intent, int flags, int startId) {
            startForeground(GRAY_SERVICE_ID, new Notification());
            stopForeground(true);
            stopSelf();
            return super.onStartCommand(intent, flags, startId);
        }

    }
}

除了這三種保活以外還有其它幾種，不過感覺沒啥用：

1.雙程序守護

首先是一個AIDL接口，兩邊的Service都要通過繼承Service_1.Stub來實作AIDL接口中的方法，這裡做一個空實作，目的是為了實作程序通信。接口聲明如下：

package com.ph.myservice;


interface Service_1 {
    String getName();
}

然後是兩個Service，為了保持連接配接，内部寫一個内部類實作ServiceConnection的接口，當外部殺了其中一個程序的時候，會進入onDisConnection中，那麼此時要做的就是start和bind另一個程序，因為Service的啟動是可以多次的，是以這樣是沒問題的，代碼如下：

package com.ph.myservice;

import android.app.ActivityManager;
import android.app.ActivityManager.RunningServiceInfo;
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.widget.Toast;

import java.util.List;

public class LocalService extends Service {
    private ServiceConnection conn;
    private MyService myService;

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


    @Override
    public void onCreate() {
        super.onCreate();
        init();

    }

    private void init() {
        if (conn == null) {
            conn = new MyServiceConnection();
        }
        myService = new MyService();
    }

    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        Toast.makeText(getApplicationContext(), "本地程序啟動", Toast.LENGTH_LONG).show();
        Intent intents = new Intent();
        intents.setClass(this, RemoteService.class);
        bindService(intents, conn, Context.BIND_IMPORTANT);
        return START_STICKY;
    }

    class MyService extends Service_1.Stub {


        @Override
        public String getName() throws RemoteException {
            return null;
        }
    }

    class MyServiceConnection implements ServiceConnection {

        @Override
        public void onServiceConnected(ComponentName name, IBinder service) {
            System.out.println("擷取連接配接");

        }

        @Override
        public void onServiceDisconnected(ComponentName name) {
            Toast.makeText(LocalService.this, "遠端連接配接被幹掉了", Toast.LENGTH_SHORT).show();
            LocalService.this.startService(new Intent(LocalService.this,
                    RemoteService.class));
            LocalService.this.bindService(new Intent(LocalService.this,
                    RemoteService.class), conn, Context.BIND_IMPORTANT);

        }

    }

}

遠端服務類如下：

package com.ph.myservice;

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.widget.Toast;

public class RemoteService extends Service {
    private MyBinder binder;
    private ServiceConnection conn;

    @Override
    public void onCreate() {
        super.onCreate();
        // System.out.println("遠端程序開啟");
        init();

    }

    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        Toast.makeText(getApplicationContext(), "遠端程序啟動", Toast.LENGTH_LONG).show();
        Intent intents = new Intent();
        intents.setClass(this, LocalService.class);
        bindService(intents, conn, Context.BIND_IMPORTANT);
        return START_STICKY;
    }

    private void init() {
        if (conn == null) {
            conn = new MyConnection();
        }
        binder = new MyBinder();
    }

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

    static class MyBinder extends Service_1.Stub {


        @Override
        public String getName() throws RemoteException {
            return "遠端連接配接";
        }
    }

    class MyConnection implements ServiceConnection {

        @Override
        public void onServiceConnected(ComponentName name, IBinder service) {
            System.out.println("擷取遠端連接配接");
        }

        @Override
        public void onServiceDisconnected(ComponentName nme) {
            Toast.makeText(RemoteService.this, "本地連接配接被幹掉了", Toast.LENGTH_SHORT).show();
            RemoteService.this.startService(new Intent(RemoteService.this,
                    LocalService.class));
            RemoteService.this.bindService(new Intent(RemoteService.this,
                    LocalService.class), conn, Context.BIND_IMPORTANT);
        }
    }

}

布局檔案：

<service android:name=".LocalService" />
        <service
            android:name=".RemoteService"
            android:process=":remote" />

這種方法在Android5.0以後并沒有用。

2.JobScheduler執行任務排程保活

JobScheduler這個類是21版本google新出來的api，我們看他的文檔可以知道大緻這個類的作用如下：

架構将智能當你收到你的回調,并嘗試批并盡可能推遲。通常如果你不指定期限在你的工作,它可以運作在任何時候根據作業排程器的目前狀态的内部隊列,然而它可能是延遲隻要直到下一次裝置被連接配接到一個電源。

這個任務其實是在裝置空閑期執行的，而且系統設計的這個api不會很耗電，本意是用來執行一些任務排程的，但是我們設想一下，如果用這個類來執行我們的開啟雙程序，那麼也是一定會在裝置空閑期執行的，是以我們寫一個類繼承JobService，在onstart裡聲明建立JobScheduler對象，并設定多就執行一次和開機自啟動，這樣就能確定及時在息屏狀态，也能夠執行重新開機程序，是以我們在JobService的onStopJob方法裡判斷我們的程序是否被回收了，如果被回收了就重新開機程序，這樣子就可以實作5.0以上的程序保活了。具體代碼如下：

package com.ph.myservice;

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.Context;
import android.content.Intent;
import android.os.Build;
import android.widget.Toast;

import java.util.List;

/**
 * Created by 86119 on 2017/1/6.
 */

@SuppressLint("NewApi")
public class JobHandlerService extends JobService {
    private JobScheduler mJobScheduler;

    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        System.out.println("服務被建立");

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

        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
            mJobScheduler = (JobScheduler) getSystemService(Context.JOB_SCHEDULER_SERVICE);
            JobInfo.Builder builder = new JobInfo.Builder(startId++,
                    new ComponentName(getPackageName(), JobHandlerService.class.getName()));

            builder.setPeriodic(5000); //每隔5秒運作一次
            builder.setRequiresCharging(true);
            builder.setPersisted(true);  //設定裝置重新開機後，是否重新執行任務
            builder.setRequiresDeviceIdle(true);

            if (mJobScheduler.schedule(builder.build()) <= 0) {
                //If something goes wrong
                System.out.println("工作失敗");
            } else {
                System.out.println("工作成功");
            }
        }
        return START_STICKY;
    }


    @Override
    public boolean onStartJob(JobParameters params) {

        Toast.makeText(this, "服務啟動", Toast.LENGTH_SHORT).show();
//        || isServiceRunning(this, "com.ph.myservice.RemoteService") == false
        System.out.println("開始工作");
//        if (!isServiceRunning(getApplicationContext(), "com.ph.myservice") || !isServiceRunning(getApplicationContext(), "com.ph.myservice:remote")) {
//            startService(new Intent(this, LocalService.class));
//            startService(new Intent(this, RemoteService.class));
//        }

       /* boolean serviceRunning = isServiceRunning(getApplicationContext(), "com.ph.myservice");
        System.out.println("程序一" + serviceRunning);

        boolean serviceRunning2 = isServiceRunning(getApplicationContext(), "com.ph.myservice:remote");
        System.out.println("程序二" + serviceRunning2);*/
        return false;
    }

    @Override
    public boolean onStopJob(JobParameters params) {
        if (!isServiceRunning(this, "com.ph.myservice.LocalService") || !isServiceRunning(this, "com.ph.myservice.RemoteService")) {
            startService(new Intent(this, LocalService.class));
            startService(new Intent(this, RemoteService.class));
        }
        return false;
    }

    // 服務是否運作
    public boolean isServiceRunning(Context context, String serviceName) {
        boolean isRunning = false;
        ActivityManager am = (ActivityManager) this
                .getSystemService(Context.ACTIVITY_SERVICE);
        List<ActivityManager.RunningAppProcessInfo> lists = am.getRunningAppProcesses();


        for (ActivityManager.RunningAppProcessInfo info : lists) {// 擷取運作服務再啟動
            System.out.println(info.processName);
            if (info.processName.equals(serviceName)) {
                isRunning = true;
            }
        }
        return isRunning;

    }


}
package com.ph.myservice;

import android.content.Intent;
import android.os.Build;
import android.os.Bundle;
import android.support.v7.app.AppCompatActivity;

public class MainActivity extends AppCompatActivity {

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

        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
            openJobService();
        } else {
            openTwoService();
        }

    }

    private void openTwoService() {
        startService(new Intent(this, LocalService.class));
        startService(new Intent(this, RemoteService.class));
    }

    private void openJobService() {

        Intent intent = new Intent();
        intent.setClass(MainActivity.this, JobHandlerService.class);
        startService(intent);

    }
}

3、開啟一個像素的Activity

據說這個是手Q的程序保活方案，基本思想，系統一般是不會殺死前台程序的。是以要使得程序常駐，我們隻需要在鎖屏的時候在本程序開啟一個Activity，為了欺騙使用者，讓這個Activity的大小是1像素，并且透明無切換動畫，在開螢幕的時候，把這個Activity關閉掉，是以這個就需要監聽系統鎖屏廣播

public class MainActivity extends AppCompatActivity {

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

如果直接啟動一個Activity，當我們按下back鍵傳回桌面的時候，oom_adj的值是8，上面已經提到過，這個程序在資源不夠的情況下是容易被回收的。現在造一個一個像素的Activity。

public class LiveActivity extends Activity {

    public static final String TAG = LiveActivity.class.getSimpleName();

    public static void actionToLiveActivity(Context pContext) {
        Intent intent = new Intent(pContext, LiveActivity.class);
        intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
        pContext.startActivity(intent);
    }

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        Log.d(TAG, "onCreate");
        setContentView(R.layout.activity_live);

        Window window = getWindow();
        //放在左上角
        window.setGravity(Gravity.START | Gravity.TOP);
        WindowManager.LayoutParams attributes = window.getAttributes();
        //寬高設計為1個像素
        attributes.width = 1;
        attributes.height = 1;
        //起始坐标
        attributes.x = 0;
        attributes.y = 0;
        window.setAttributes(attributes);

        ScreenManager.getInstance(this).setActivity(this);
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        Log.d(TAG, "onDestroy");
    }
}

為了做的更隐藏，最好設定一下這個Activity的主題，當然也無所謂了

<style name="LiveStyle">
        <item name="android:windowIsTranslucent">true</item>
        <item name="android:windowBackground">@android:color/transparent</item>
        <item name="android:windowAnimationStyle">@null</item>
        <item name="android:windowNoTitle">true</item>
   </style>

在螢幕關閉的時候把LiveActivity啟動起來，在開屏的時候把LiveActivity 關閉掉，是以要監聽系統鎖屏廣播，以接口的形式通知MainActivity啟動或者關閉LiveActivity。

public class ScreenBroadcastListener {

    private Context mContext;

    private ScreenBroadcastReceiver mScreenReceiver;

    private ScreenStateListener mListener;

    public ScreenBroadcastListener(Context context) {
        mContext = context.getApplicationContext();
        mScreenReceiver = new ScreenBroadcastReceiver();
    }

    interface ScreenStateListener {

        void onScreenOn();

        void onScreenOff();
    }

    /**
     * screen狀态廣播接收者
     */
    private class ScreenBroadcastReceiver extends BroadcastReceiver {
        private String action = null;

        @Override
        public void onReceive(Context context, Intent intent) {
            action = intent.getAction();
            if (Intent.ACTION_SCREEN_ON.equals(action)) { // 開屏
                mListener.onScreenOn();
            } else if (Intent.ACTION_SCREEN_OFF.equals(action)) { // 鎖屏
                mListener.onScreenOff();
            }
        }
    }

    public void registerListener(ScreenStateListener listener) {
        mListener = listener;
        registerListener();
    }

    private void registerListener() {
        IntentFilter filter = new IntentFilter();
        filter.addAction(Intent.ACTION_SCREEN_ON);
        filter.addAction(Intent.ACTION_SCREEN_OFF);
        mContext.registerReceiver(mScreenReceiver, filter);
    }
}

public class ScreenManager {

    private Context mContext;

    private WeakReference<Activity> mActivityWref;

    public static ScreenManager gDefualt;

    public static ScreenManager getInstance(Context pContext) {
        if (gDefualt == null) {
            gDefualt = new ScreenManager(pContext.getApplicationContext());
        }
        return gDefualt;
    }
    private ScreenManager(Context pContext) {
        this.mContext = pContext;
    }

    public void setActivity(Activity pActivity) {
        mActivityWref = new WeakReference<Activity>(pActivity);
    }

    public void startActivity() {
            LiveActivity.actionToLiveActivity(mContext);
    }

    public void finishActivity() {
        //結束掉LiveActivity
        if (mActivityWref != null) {
            Activity activity = mActivityWref.get();
            if (activity != null) {
                activity.finish();
            }
        }
    }
}

現在MainActivity改成如下

public class MainActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        final ScreenManager screenManager = ScreenManager.getInstance(MainActivity.this);
        ScreenBroadcastListener listener = new ScreenBroadcastListener(this);
         listener.registerListener(new ScreenBroadcastListener.ScreenStateListener() {
            @Override
            public void onScreenOn() {
                screenManager.finishActivity();
            }

            @Override
            public void onScreenOff() {
                screenManager.startActivity();
            }
        });
    }
}

但是還有一個問題，記憶體也是一個考慮的因素，記憶體越多會被最先kill掉，是以把上面的業務邏輯放到Service中，而Service是在另外一個程序中，在MainActivity開啟這個服務就行了，這樣這個程序就更加的輕量。

public class LiveService extends Service {

    public  static void toLiveService(Context pContext){
        Intent intent=new Intent(pContext,LiveService.class);
        pContext.startService(intent);
    }

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


    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        //螢幕關閉的時候啟動一個1像素的Activity，開屏的時候關閉Activity
        final ScreenManager screenManager = ScreenManager.getInstance(LiveService.this);
        ScreenBroadcastListener listener = new ScreenBroadcastListener(this);
        listener.registerListener(new ScreenBroadcastListener.ScreenStateListener() {
            @Override
            public void onScreenOn() {
                screenManager.finishActivity();
            }
            @Override
            public void onScreenOff() {
                screenManager.startActivity();
            }
        });
        return START_REDELIVER_INTENT;
    }
}

<service android:name=".LiveService"
            android:process=":live_service"/>

4、粘性服務&與系統服務捆綁

這個是系統自帶的，onStartCommand方法必須具有一個整形的傳回值，這個整形的傳回值用來告訴系統在服務啟動完畢後，如果被Kill，系統将如何操作，這種方案雖然可以，但是在某些情況or某些定制ROM上可能失效，我認為可以多做一種保保守方案。

@Override
public int onStartCommand(Intent intent, int flags, int startId) {
    return START_REDELIVER_INTENT;
}

START_STICKY

如果系統在onStartCommand傳回後被銷毀，系統将會重新建立服務并依次調用onCreate和onStartCommand（注意：根據測試Android2.3.3以下版本隻會調用onCreate根本不會調用onStartCommand，Android4.0可以辦到），這種相當于服務又重新啟動恢複到之前的狀态了）。
START_NOT_STICKY

如果系統在onStartCommand傳回後被銷毀，如果傳回該值，則在執行完onStartCommand方法後如果Service被殺掉系統将不會重新開機該服務。
START_REDELIVER_INTENT

START_STICKY的相容版本，不同的是其不保證服務被殺後一定能重新開機。

相比與粘性服務與系統服務捆綁更厲害一點，這個來自愛哥的研究，這裡說的系統服務很好了解，比如NotificationListenerService，NotificationListenerService就是一個監聽通知的服務，隻要手機收到了通知，NotificationListenerService都能監聽到，即時使用者把程序殺死，也能重新開機，是以說要是把這個服務放到我們的程序之中，那麼就可以呵呵了

@TargetApi(Build.VERSION_CODES.JELLY_BEAN_MR2)
public class LiveService extends NotificationListenerService {

    public LiveService() {

    }

    @Override
    public void onNotificationPosted(StatusBarNotification sbn) {
    }

    @Override
    public void onNotificationRemoved(StatusBarNotification sbn) {
    }
}

但是這種方式需要權限

<service
            android:name=".LiveService"
            android:permission="android.permission.BIND_NOTIFICATION_LISTENER_SERVICE">
            <intent-filter>
                <action android:name="android.service.notification.NotificationListenerService" />
            </intent-filter>
        </service>

關于Android程序保活

黑色保活

白色保活

灰色保活

3、開啟一個像素的Activity

4、粘性服務&與系統服務捆綁

繼續閱讀

Java小案例——随機數猜測随機數猜測

nginx location中斜線的位置的重要性

27 Best Free Eclipse Plug-ins for Java Developer to be ProductiveCode Quality PluginsText Editor PluginsDependency ManagementVersion Control Integration PluginsFramework Development Continuous Integration Related PluginsOther Utility Plugins

Java String.format方法的簡單使用

neo4j之cypher使用文檔

GitHub連夜封殺！這份阿裡 10W 字内部 Java 字面試手冊到底有多強？

spark/scala關于【資源檔案】加載方法概述外部檔案加載方案測試資源檔案打包入jar包中小結

mybatis_入門程式Mybatis入門

AOP程式設計_Android優雅權限架構(1)概念基礎，2021金三銀四前言正文大綱正文

Effective Java 8:通用程式設計

OOM三種類型

工廠模式-三種類型

【遞歸】高效率求2的n次幂

Android APK檔案反編譯Android APK檔案反編譯

win10本地scala和spark安裝安裝scala安裝spark

scala (3) Function 和 Method