【Android服务】制作无法销毁的Service

今天面试没表现好啊，现在来好好研究下这个问题：如何制作Android无法销毁的Service？（虽然在用户的角度上看，这样的开发显得很无赖，但是很多场景下，需要这样去设计APP，例如某APP每天在某个固定时间段向用户推送信息，那么手机端这个接收推送服务必须要提前启动，所以做这样的事还是很有必要的）
事实上，解决这个还需要一个帮助，运用广播。
在启动Service，调用startService（）时，都会调用OnStartCommand（intent，int，int），在其中运行一些方法。来深入了解下OnStartCommand（）的四种返回值。

 /**     * Constant to return from {@link #onStartCommand}: if this service's     * process is killed while it is started (after returning from     * {@link #onStartCommand}), then leave it in the started state but     * don't retain this delivered intent.  Later the system will try to     * re-create the service.  Because it is in the started state, it will     * guarantee to call {@link #onStartCommand} after creating the new     * service instance; if there are not any pending start commands to be     * delivered to the service, it will be called with a null intent     * object, so you must take care to check for this.     *      * <p>This mode makes sense for things that will be explicitly started     * and stopped to run for arbitrary periods of time, such as a service     * performing background music playback.     */    public static final int START_STICKY = 1;

1.第一种：START_STICKY
public static final int START_STICKY = 1;
如果Service服务被销毁掉，那么保留Service的状态为开始状态，但是并不保留intent对象。然后系统会创新创建Service，而且之前状态是被保存的开始状态，所以创建Sevice后一定会调用OnStartCommand（intent，int，int），如果在此期间没有其他操作传递到Service，那么intent会为null(因为之前也为保存intent对象，所以会为空)。

 /**     * Constant to return from {@link #onStartCommand}: if this service's     * process is killed while it is started (after returning from     * {@link #onStartCommand}), and there are no new start intents to     * deliver to it, then take the service out of the started state and     * don't recreate until a future explicit call to     * {@link Context#startService Context.startService(Intent)}.  The     * service will not receive a {@link #onStartCommand(Intent, int, int)}     * call with a null Intent because it will not be re-started if there     * are no pending Intents to deliver.     *      * <p>This mode makes sense for things that want to do some work as a     * result of being started, but can be stopped when under memory pressure     * and will explicit start themselves again later to do more work.  An     * example of such a service would be one that polls for data from     * a server: it could schedule an alarm to poll every N minutes by having     * the alarm start its service.  When its {@link #onStartCommand} is     * called from the alarm, it schedules a new alarm for N minutes later,     * and spawns a thread to do its networking.  If its process is killed     * while doing that check, the service will not be restarted until the     * alarm goes off.     */    public static final int START_NOT_STICKY = 2;

第二种：START_NOT_STICKY
public static final int START_NOT_STICKY = 2;
相当于第一种的对立，“非粘性”，在执行完OnStartCommand后，如服务被异常销毁掉，那么该服务将无法自动重新启动。

/**     * Constant to return from {@link #onStartCommand}: if this service's     * process is killed while it is started (after returning from     * {@link #onStartCommand}), then it will be scheduled for a restart     * and the last delivered Intent re-delivered to it again via     * {@link #onStartCommand}.  This Intent will remain scheduled for     * redelivery until the service calls {@link #stopSelf(int)} with the     * start ID provided to {@link #onStartCommand}.  The     * service will not receive a {@link #onStartCommand(Intent, int, int)}     * call with a null Intent because it will will only be re-started if     * it is not finished processing all Intents sent to it (and any such     * pending events will be delivered at the point of restart).     */    public static final int START_REDELIVER_INTENT = 3;

第三种：START_REDELIVER_INTENT
public static final int START_REDELIVER_INTENT = 3;
可以从简单的字面上理解，重传intent启动服务，执行完OnStartCommand（intent，int，int）后，如果服务被异常销毁掉，系统会自动重启服务，并将intent对象传入。

 /**     * Constant to return from {@link #onStartCommand}: compatibility     * version of {@link #START_STICKY} that does not guarantee that     * {@link #onStartCommand} will be called again after being killed.     */    public static final int START_STICKY_COMPATIBILITY = 0;

第四种：START_STICKY_COMPATIBILITY
public static final int START_STICKY_COMPATIBILITY = 0;
从字面上理解是，是第一种的通用类型，不过并不能完全做到能自动重启服务。

制作一个销毁的Service，也许我们可以不钻牛角尖，做一个可以无限制唤醒的Service，（虽然可被销毁，但服务会再次被创建）
方法一：利用计时，例如60s间隔时间再次启动Service。
如下：
MyService：

package com.yyc.servicedemo.services;import android.app.AlarmManager;import android.app.PendingIntent;import android.app.Service;import android.content.Intent;import android.os.IBinder;import android.widget.Toast;public class MyService extends Service{    AlarmManager mAlarmManager = null;    PendingIntent mPendingIntent = null;    @Override    public void onCreate() {        //start the service through alarm repeatly        Intent intent = new Intent(getApplicationContext(), MyService.class);        mAlarmManager = (AlarmManager)getSystemService(ALARM_SERVICE);        mPendingIntent = PendingIntent.getService(this, 0, intent, Intent.FLAG_ACTIVITY_NEW_TASK);        long now = System.currentTimeMillis();        mAlarmManager.setInexactRepeating(AlarmManager.RTC, now, 60000, mPendingIntent);        super.onCreate();    }    @Override    public int onStartCommand(Intent intent, int flags, int startId) {        Toast.makeText(getApplicationContext(), "服务启动", Toast.LENGTH_SHORT).show();        return START_STICKY;    }    @Override    public IBinder onBind(Intent intent) {        return null;    }    @Override    public void onDestroy() {        Toast.makeText(getApplicationContext(),"服务销毁",Toast.LENGTH_SHORT).show();//        /**//         * 第二种方法//         *///        Intent intent = new Intent();//        intent.setClass(this, MyService.class); // 销毁时重新启动Service (虽然方法很流氓)        super.onDestroy();    }}

MyBroadcastReceiver：

package com.yyc.servicedemo.broadcastReceivers;import android.content.BroadcastReceiver;import android.content.Context;import android.content.Intent;import com.yyc.servicedemo.services.MyService;/** * Created by Administrator on 2016/1/24. */public class MyBroadcastReceiver extends BroadcastReceiver{    private final String TAG=MyBroadcastReceiver.class.getSimpleName();    @Override    public void onReceive(Context context, Intent intent) {        if (Intent.ACTION_BOOT_COMPLETED.equals(intent.getAction()))        {            Intent startServiceIntent = new Intent(context, MyService.class);            startServiceIntent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);            context.startService(startServiceIntent);        }    }}

第二种方法：销毁时立刻再次创建：
在MySerice内这么写（相比第一种更灵活）：

 @Override    public void onDestroy() {        Toast.makeText(getApplicationContext(),"服务销毁",Toast.LENGTH_SHORT).show();        /**         * 第二种方法         */        Intent intent = new Intent();        intent.setClass(this, MyService.class); // 销毁时重新启动Service (虽然方法很流氓)        super.onDestroy();    }

第三种：类似第二种，我们可以先看张图片：

我们可以注意到微博的方式，不妨做个假设，微博的服务相互监听，微博的服务只要其中一个服务被销毁，另外的服务就立刻创建它，这样的“互助”式监听，在一定程度上可以避免APP服务的异常销毁，造成服务无法重启，引起APP的异常。

以上这些方面当然还无法去做到真正意义上的无法销毁的服务，假设手机重启，所有服务都被销毁了，服务又将如何自启动呢？那么继续往底层深入的探讨这个问题，个人从网上收集了部分资料，“守护进程”深入到C底层的写法了