【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底层的写法了