Service是Android中一个类，它是Android四大组件之一，使用Service可以在后台执行长时间的操作（ perform long-running operations in the background ），Service并不与用户产生UI交互。其他的应用组件可以启动Service，即便用户切换了其他应用，启动的Service仍可在后台运行。一个组件可以与Service绑定并与之交互，甚至是跨进程通信（IPC）。例如，一个Service可以在后台执行网络请求、播放音乐、执行文件读写操作或者与 content provider交互 等。

Services

• Started：其他组件调用startService()方法启动一个Service。一旦启动，Service将一直运行在后台（run in the background indefinitely）即便启动Service的组件已被destroy。通常，一个被start的Service会在后台执行单独的操作，也并不给启动它的组件返回结果。比如说，一个start的Service执行在后台下载或上传一个文件的操作，完成之后，Service应自己停止。
• Bound：其他组件调用bindService()方法绑定一个Service。通过绑定方式启动的Service是一个client-server结构，该Service可以与绑定它的组件进行交互。一个bound service仅在有组件与其绑定时才会运行（A bound service runs only as long as another application component is bound to it），多个组件可与一个service绑定，service不再与任何组件绑定时，该service会被destroy。

Service是一个运行在后台的组件，并不与用户交互。您仅在需要的时候创建Service（ create a service only if that is what you need）。

当用户正在与UI交互时，需要执行一些主线程无法完成的工作，应当创建一个线程。例如当activity正在运行时，需要播放音乐，此时需要在Activity的onCreate()中创建线程并在onStart()中开启。最后在onStop()中停止。您也可以考虑使用AsyncTask 或 HandlerThread来替代Thread创建线程。

Service基础（The Basics）

• onStartCommand()：当其他组件调用startService()方法请求启动Service时，该方法被回调。一旦Service启动，它会在后台独立运行。当Service执行完以后，需调用stopSelf() 或 stopService()方法停止Service。（若您只希望bind Service，则无需调用这些方法）
• onBind()：当其他组件调用bindService()方法请求绑定Service时，该方法被回调。该方法返回一个IBinder接口，该接口是Service与绑定的组件进行交互的桥梁。若Service未绑定其他组件，该方法应返回null。
• onCreate()：当Service第一次创建时，回调该方法。该方法只被回调一次，并在onStartCommand() 或 onBind()方法被回调之前执行。若Service处于运行状态，该方法不会回调。
• onDestroy()：当Service被销毁时回调，在该方法中应清除一些占用的资源，如停止线程、接触绑定注册的监听器或broadcast receiver 等。该方法是Service中的最后一个回调。

在manifest文件中注册service（Declaring a service in the manifest）

<manifest ... >
  ...
  <application ... >
      <service android:name=".ExampleService" />
      ...
  </application>
</manifest>

注：setPackage()方法传入一个String参数，代表一个包名。该方法表示该Intent对象只能在传入的这个包名下寻找符合条件的组件，若传入null，则表示可以在任意包下寻找。

使用start方式启动Service（Creating a Started Service）

比如说，Activity需要向在线数据库中上传数据，那么可以调用startService()启动一个Service，并将数据传入Intent的data中，接着，onStartCommand()方法会接收这个Intent并开启一个线程将数据上传至网络，当数据上传完成后，该Service将停止并被destroy。

• 继承Service类：请务必在Service中开启线程来执行耗时操作，因为Service运行在主线程中。
• 继承IntentService类：IntentService继承于Service，若Service不需要同时处理多个请求，那么使用IntentService将是最好选择：您只需要重写onHandleIntent()方法，该方法接收一个回传的Intent参数，您可以在方法内进行耗时操作，因为它默认开启了一个子线程，操作执行完成后也无需手动调用stopSelf()方法，onHandleIntent()会自动调用该方法。

继承IntentService类（Extending the IntentService class）

• 默认在子线程中处理回传到onStartCommand()方法中的Intent；
• 在重写的onHandleIntent()方法中处理按时间排序的Intent队列，所以不用担心多线程（multi-threading）带来的问题。
• 当所有请求处理完成后，自动停止service，无需手动调用stopSelf()方法；
• 默认实现了onBind()方法，病返回null；
• 默认实现了onStartCommand()方法，病讲回传的Intent以序列的形式发送给onHandleIntent()，您只需重写该方法并处理Intent即可。

public class HelloIntentService extends IntentService {

  /**
   * A constructor is required, and must call the super IntentService(String)
   * constructor with a name for the worker thread.
   */
  public HelloIntentService() {
      super("HelloIntentService");
  }

  /**
   * The IntentService calls this method from the default worker thread with
   * the intent that started the service. When this method returns, IntentService
   * stops the service, as appropriate.
   */
  @Override
  protected void onHandleIntent(Intent intent) {
      // Normally we would do some work here, like download a file.
      // For our sample, we just sleep for 5 seconds.
      try {
          Thread.sleep(5000);
      } catch (InterruptedException e) {
          // Restore interrupt status.
          Thread.currentThread().interrupt();
      }
  }
}

比如，要实现onStartCommand()方法，需返回其父类方法：

@Override
public int onStartCommand(Intent intent, int flags, int startId) {
    Toast.makeText(this, "service starting", Toast.LENGTH_SHORT).show();
    return super.onStartCommand(intent,flags,startId);
}

继承Service类（Extending the Service class）

public class HelloService extends Service {
  private Looper mServiceLooper;
  private ServiceHandler mServiceHandler;

  // Handler that receives messages from the thread
  private final class ServiceHandler extends Handler {
      public ServiceHandler(Looper looper) {
          super(looper);
      }
      @Override
      public void handleMessage(Message msg) {
          // Normally we would do some work here, like download a file.
          // For our sample, we just sleep for 5 seconds.
          try {
              Thread.sleep(5000);
          } catch (InterruptedException e) {
              // Restore interrupt status.
              Thread.currentThread().interrupt();
          }
          // Stop the service using the startId, so that we don‘t stop
          // the service in the middle of handling another job
          stopSelf(msg.arg1);
      }
  }

  @Override
  public void onCreate() {
    // Start up the thread running the service.  Note that we create a
    // separate thread because the service normally runs in the process‘s
    // main thread, which we don‘t want to block.  We also make it
    // background priority so CPU-intensive work will not disrupt our UI.
    HandlerThread thread = new HandlerThread("ServiceStartArguments",
            Process.THREAD_PRIORITY_BACKGROUND);
    thread.start();

    // Get the HandlerThread‘s Looper and use it for our Handler
    mServiceLooper = thread.getLooper();
    mServiceHandler = new ServiceHandler(mServiceLooper);
  }

  @Override
  public int onStartCommand(Intent intent, int flags, int startId) {
      Toast.makeText(this, "service starting", Toast.LENGTH_SHORT).show();

      // For each start request, send a message to start a job and deliver the
      // start ID so we know which request we‘re stopping when we finish the job
      Message msg = mServiceHandler.obtainMessage();
      msg.arg1 = startId;
      mServiceHandler.sendMessage(msg);

      // If we get killed, after returning from here, restart
      return START_STICKY;
  }

  @Override
  public IBinder onBind(Intent intent) {
      // We don‘t provide binding, so return null
      return null;
  }

  @Override
  public void onDestroy() {
    Toast.makeText(this, "service done", Toast.LENGTH_SHORT).show();
  }
}

• START_NOT_STICKY：若执行完onStartCommand()方法后，系统就kill了service，不要再重新创建service，除非系统回传了一个pending intent。这避免了在不必要的时候运行service，您的应用也可以restart任何未完成的操作。

• START_STICKY：若系统在onStartCommand()执行并返回后kill了service，那么service会被recreate并回调onStartCommand()。dangerous不要重新传递最后一个Intent（do not redeliver the last intent）。相反，系统回调onStartCommand()时回传一个空的Intent，除非有 pending intents传递，否则Intent将为null。该模式适合做一些类似播放音乐的操作。

• START_REDELIVER_INTENT：若系统在onStartCommand()执行并返回后kill了service，那么service会被recreate并回调onStartCommand()并将最后一个Intent回传至该方法。任何 pending intents都会被轮流传递。该模式适合做一些类似下载文件的操作。

启动服务（Starting a Service）

Intent intent = new Intent(this, HelloService.class);
startService(intent);

停止服务（Stopping a service）

创建绑定Service（Creating a Bound Service）

向用户发送通知（Sending Notifications to the User）

通常，Status Bar用于通知某些操作已经完成，如下载文件完成。当用户下拉状态栏后，点击该通知，可获取详细内容，如查看该下载的文件。

运行前台Service（Running a Service in the Foreground）

Notification notification = new Notification(R.drawable.icon, getText(R.string.ticker_text),
        System.currentTimeMillis());
Intent notificationIntent = new Intent(this, ExampleActivity.class);
PendingIntent pendingIntent = PendingIntent.getActivity(this, 0, notificationIntent, 0);
notification.setLatestEventInfo(this, getText(R.string.notification_title),
        getText(R.string.notification_message), pendingIntent);
startForeground(ONGOING_NOTIFICATION_ID, notification);

Service生命周期（Managing the Lifecycle of a Service）

• A started service：需手动停止
• A bound service：可自动停止

实现Service的生命周期回调（Implementing the lifecycle callbacks）

    int mStartMode;       // indicates how to behave if the service is killed
    IBinder mBinder;      // interface for clients that bind
    boolean mAllowRebind; // indicates whether onRebind should be used

    @Override
    public void onCreate() {
        // The service is being created
    }
    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        // The service is starting, due to a call to startService()
        return mStartMode;
    }
    @Override
    public IBinder onBind(Intent intent) {
        // A client is binding to the service with bindService()
        return mBinder;
    }
    @Override
    public boolean onUnbind(Intent intent) {
        // All clients have unbound with unbindService()
        return mAllowRebind;
    }
    @Override
    public void onRebind(Intent intent) {
        // A client is binding to the service with bindService(),
        // after onUnbind() has already been called
    }
    @Override
    public void onDestroy() {
        // The service is no longer used and is being destroyed
    }
}

• 完整生命周期（ entire lifetime ）：从onCreate()被调用到onDestroy()返回。与Activity类似，一般在onCreate()中做一些初始化工作，而在onDestroy()做一些资源释放工作。如，若Service在后台播放一个音乐，就需要在onCreate()方法中开启一个线程启动音乐，并在onDestroy()中结束线程。

-

无论是startService() 还是 bindService()启动Service，onCreate() 和 onDestroy()均会被回调。

• 活动生命周期（active lifetime）：从onStartCommand() 或 onBind()回调开始。由相应的startService() 或 bindService()调用。

  若是Start Service，那么Service的活动生命周期结束就意味着其完整生命周期结束 （the active lifetime ends the same time that the entire lifetime ends），即便onStartCommand()返回后，Service仍处于活动状态；若是bound Service，那么当onUnbind()返回时，Service的活动生命周期结束。

  ！请注意：针对Start Service，由于Service中没有类似onStop()的回调，所以在调用stopSelf() 或 stopService()后，只有onDestroy()被回调标志着Service已停止。