服务是什么？
Service是Android系统中的四大组件之一，主要有两个应用场景：后台运行和跨进程访问。
Service可以在后台执行长时间运行操作而不提供用户界面，除非系统必须回收内存资源，否则系统不会停止或销毁服务。服务可由其他应用组件启动，而且即使用户切换到其他应用，服务仍将在后台继续运行。 此外，组件可以绑定到服务，以与之进行交互，甚至是执行进程间通信 (IPC)

值得注意的是：

1. 服务并不是运行在一个独立的进程中的，而是依赖于创建服务时所在的应用程序进程。当某个应用程序进程被杀掉时，所有依赖于该进程的服务也会停止运行。
2. 服务并不会自动开启线程，所有代码都是默认运行在主线程当中的。我们需要在服务的内部手动创建子线程，并在这里执行具体的任务，否则就有可能造成主线程被阻塞的情况

注册服务

服务Service作为四大组件，当然也要在AndroidManifest.xml文件中注册才能生效。

<manifest xmlns:android="http://schemas.android.com/apk/res/android"
      package="com.example.myservicetest">
    <application
        ...
         //注册服务
        <service
            android:name=".MyService"
            android:enabled="true"
            android:exported="true">
        </service>
    </application>
</manifest>

定义一个服务

要创建服务，必须创建Service的子类或使用它的一个现有子类。
右击项目包名->New->Service->Service新建服务。
Exported属性表示是否允许除了当前程序之外的其他程序访问这个服务
Enable属性表示是否启用这个服务

public class MyService extends Service {
    public MyService() {
    }

    @Override
    public IBinder onBind(Intent intent) {
        // TODO: Return the communication channel to the service.
        throw new UnsupportedOperationException("Not yet implemented");
    }

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

    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        return super.onStartCommand(intent, flags, startId);
    }
    
    @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() {
        super.onDestroy();
    }
}

myService继承自Service，其中onBind()方法是Service中唯一的一个抽象方法，必须在子类中实现。

重写生命周期的回调方法

1. onCreate()
   何时：首次创建服务时。
   注意：若服务已在运行，则不会调用此方法。
2. onDestroy()
   何时：当服务不再使用且将被销毁时。
   作用：清理所有资源，如线程、注册的侦听器、接收器等。
   注意：这是服务接收的最后一个调用。
3. int onStartCommand(Intent intent, int flags, int startId)
   何时：当另一个组件调用startService()请求启动服务时。
   参数：
   intent：startService()启动服务时传入的Intent；
   startId：唯一id标识此次服务的启动请求。
   返回值：描述系统应该如何在服务终止的情况下继续运行服务。
4. IBinder onBind(Intent it)
   何时：当另一个组件调用bindService()与服务绑定时。
   返回值：供客户端与服务进行通信。

启动和停止服务：

public class MainActivity extends AppCompatActivity implements View.OnClickListener{

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

        Button startService = (Button)findViewById(R.id.start_service);
        Button stopService = (Button)findViewById(R.id.stop_service);

        startService.setOnClickListener(this);
        stopService.setOnClickListener(this);
    }

    @Override
    public void onClick(View v) {
        switch (v.getId()){
            case R.id.start_service:
                Intent startIntent = new Intent(this,MyService.class);
                startService(startIntent);
                break;
            case R.id.stop_service:
                Intent stopIntent = new Intent(this,MyService.class);
                stopService(stopIntent);
                break;
            default:
                break;
        }
    }
}

启动服务：

Intent startIntent = new Intent(this,MyService.class);
startService(startIntent);

停止服务：
服务必须通过调用stopSelf()自行停止运行，或者由另一个组件通过调用stopService()来停止它。

服务的销毁

1. 调用startService()启动服务，则服务将一直运行，直到其自身使用stopSelf()或由其他组件调用stopService()来停止。
2. 调用bindService()创建并绑定服务，则服务只会在该组件与其绑定时运行。一旦该服务与所有客户端之间的绑定全部取消，系统会销毁它。
3. 同时被启动和绑定的服务，要经历上面两种才能被销毁。
4. 仅当内存过低且必须回收系统资源以供具有用户焦点的Activity使用时，系统才会强制停止服务（前台运行的服务除外）。

活动和服务进行通信

上面Service基本用法中，启动Service之后，就可以在onCreate()或onStartCommand()方法里去执行一些具体的逻辑了。不过这样的话Service和Activity的关系并不大，只是Activity通知了Service一下：“你可以启动了。”然后Service就去忙自己的事情了。那么有没有什么办法能让它们俩的关联更多一些呢？比如说在Activity中可以指定让Service去执行什么任务。当然可以，只需要让Activity和Service建立关联就好了。
观察MyService中的代码，你会发现一直有一个onBind()方法我们都没有使用到，这个方法其实就是用于和Activity建立关联的，修改MyService中的代码，如下所示：

public class MyService extends Service {
    //创建继承自Binder类的DownloadBinder
    class DownloadBinder extends Binder{
        public void startDownload(){
            Log.d("MyService","startDownload executed");
        }

        public int getProgress(){
            Log.d("MyService","getProgress executed");
            return 0;
        }

    }
    //mBinder成员
    private DownloadBinder mBinder = new DownloadBinder();

    public MyService() {
    }
    
    //关键是这个onBind方法
    @Override
    public IBinder onBind(Intent intent) {
      return mBinder;
    }
    ...
}

然后在MainActivity中

public class MainActivity extends AppCompatActivity implements View.OnClickListener{
    
    private MyService.DownloadBinder mDownloadBinder;

    //创建一个ServiceConnection的匿名类
    private ServiceConnection connection = new ServiceConnection() {
        //重写onServiceConnected方法
        @Override
        public void onServiceConnected(ComponentName name, IBinder service) {
            mDownloadBinder = (MyService.DownloadBinder)service;
            mDownloadBinder.startDownload();
            mDownloadBinder.getProgress();
        }
        //重写onServiceDisconnected方法
        @Override
        public void onServiceDisconnected(ComponentName name) {

        }
    };

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

        Button startServiceBtn = (Button)findViewById(R.id.start_service);
        Button stopServiceBtn = (Button)findViewById(R.id.stop_service);

        startServiceBtn.setOnClickListener(this);
        stopServiceBtn.setOnClickListener(this);

        Button bindServiceBtn = (Button)findViewById(R.id.bind_service);
        Button unbindServiceBtn = (Button) findViewById(R.id.unbind_service);
        bindServiceBtn.setOnClickListener(this);
        unbindServiceBtn.setOnClickListener(this);
    }

    @Override
    public void onClick(View v) {
        switch (v.getId()){
            case R.id.start_service:
                Intent startIntent = new Intent(this,MyService.class);
                startService(startIntent);
                break;
            case R.id.stop_service:
                Intent stopIntent = new Intent(this,MyService.class);
                stopService(stopIntent);
                break;
            case R.id.bind_service:
                Intent bindIntent = new Intent(this,MyService.class);
                bindService(bindIntent,connection,BIND_AUTO_CREATE);//绑定服务
                break;
            case R.id.unbind_service:
                unbindService(connection); //解绑服务
                break;
            default:
                break;
        }
    }
}

绑定与解绑服务

流程简述

1. 先实现ServiceConnection

   1. 重写onServiceConnected()
   2. 重写onServiceDisconnected()
   3. 再调用bindService()绑定服务

2. 与服务连接时，系统会回调onServiceConnected，要保存IBinder对象，并使用其调用服务。

3. 客户端调用unbindService()解绑服务。
   注意，此时不会回调onServiceDisconnected()，这个方法只会在服务crash或killed才会被回调。

何时绑定与何时解绑

1. 若只需要在Activity可见时与服务交互，则应在onStart()期间绑定，在onStop()期间解绑。
2. 若希望Activity在后台停止运行时仍可接收响应，则在onCreate()期间绑定，在onDestroy()期间解绑。
3. 切勿在onResume()期间绑定和onPause()期间解绑，这是因为每一次生命周期转换都会发生这些回调，频率过高。

bindService()方法接收3个参数

参数1：构建的Intent对象
参数2：ServiceConnection的实例
参数3：标志位，传入BIND_AUTO_CREATE表示在活动和服务进行绑定后自动创建服务。

unbindService()方法接收一个参数

参数1：ServiceConnection的实例，用于解除活动和服务之间的绑定。

任何一个服务在整个应用程序范围内都是通用的，即MyService不仅可以和MainActivity绑定，还可以和任何其他的活动进行绑定，而且绑定后它们都可以获取到相同的DownloadBinder实例。

服务的生命周期

服务的生命周期---从创建到销毁---可以被分为以下两个路径：

1. 启动类型的服务：
   一个组件调用startService()方法创建服务，然后服务无限期的运行，并且必须通过调用stopSelf()方法来终止自己。其他组件也能够通过调用stopService()方法来终止这个服务。当服务被终止，系统就会把它销毁。
2. 绑定类型的服务：
   一个组件（客户端）调用bindService()方法创建服务，客户端通过IBinder接口与服务通信。客户端能够调用unbindService()方法来关闭与服务连接。多个客户端能够绑定到统一个服务，并且当所有的都解绑以后，系统就会销毁这个服务。（服务不需要终止自己）

但是这两个路径不是完全独立的。也就是说，你能够绑定一个已经用startService()方法启动的服务。
例如，一个后台的音乐服务能够调用带有标识要播放的音乐的Itent的startService()方法来启动，稍后，可能在用户想要进行一些播放器的控制时，或想要获取有关当前歌曲信息，那么一个Activity就能够调用bindService()方法来绑定这个服务。在这个场景中，直到所有的客户端解绑，stopService()或stopSelf()方法才能实际终止这个服务。

服务的生命周期.png

图的左边显示了用startService()方法创建服务时的生命周期，图的右边显示了用bindService()方法创建服务时的生命周期。

服务的更多技巧

使用前台服务：

服务的系统优先级比较低，当系统出现内存不足的情况时，就有可能会回收掉正在后台运行的服务。如果希望服务可以一直保持运行状态，而不会由于系统内存不足的原因导致被回收，就可以考虑使用前台服务。

前台服务和普通服务的最大区别就在于：前台服务会一直有一个正在运行的图标在系统的状态栏显示，下拉状态栏后可以看到更加详细的信息，非常类似于通知的效果。

有些项目因为特殊的需求会要求必须使用前台服务，譬如彩云天气预报应用。

 @Override
public void onCreate() {
    super.onCreate();
    Log.d("MyService","onCreate executed");

    Intent intent = new Intent(this,MainActivity.class);
    //PendingIntent倾向于在某个合适的时机去执行某个动作，简单理解为延迟的Intent
    PendingIntent pi = PendingIntent.getActivity(this,0,intent,0);
    
    
    Notification notification = new NotificationCompat.Builder(this)
            .setContentTitle("This is content title")
            .setContentText("This is content text")
            .setWhen(System.currentTimeMillis())
            .setSmallIcon(R.mipmap.ic_launcher)
            .setLargeIcon(BitmapFactory.decodeResource(getResources(),R.mipmap.ic_launcher))
            .setContentIntent(pi)
            .build();
            
    /* 第一个参数是通知的id，第二个参数是构建出的Notification对象，
     * 调用 startForeground()方法后就会让MyService变成一个前台服务，并在系统状态栏显示出来
     */
    startForeground(1,notification);
}

使用IntentService

为了简单地创建一个异步的、会自动停止的服务，Android专门提供了一个IntentService类，这个类就很好地解决了 忘记开启线程或者忘记调用stopSelf()方法的尴尬了。

新建一个继承自IntentService的类

public class MyIntentService extends IntentService {

    public MyIntentService(){
        super("MyIntentService");
    }

    @Override
    protected void onHandleIntent(Intent intent) {
        //打印当前线程ID
        Log.d("MyIntenteService","Thread id is " + Thread.currentThread().getId());
    }

    @Override
    public void onDestroy() {
        super.onDestroy();
        Log.d("MyIntentService","onDestory executed");
    }
}

在MainActivity中调用：

 Intent intentService = new Intent(this,MyIntentService.class);
 startService(intentService);

调用发现MyIntentService和MainActivity不仅所在的线程id不一样，而且onDestory()方法也得到了执行，说明MyIntentService在运行完毕后确实自动停止了。

由此看出：集开启线程和自动停止 于一身，是IntentService最大的优点