Service简述

Service即为服务，像在后台完成一些下载任务的时候会用到，和别的组件进行通信的时候会用到。其实在刚开始学android的时候我几乎没怎么用到过，但是到后面写一些复杂的项目的时候就需要用到。所以总结一下。

1.Service是什么

Service是一种应用程序组件，一般在不希望和用户交互但又需要长时间运行的时候使用。每个服务类在其包的AndroidManifest.xml中必须具有相应的<Service>声明。

Service在主线程中运行。意思就是如果服务要执行任何占用大量CPU资源或阻塞的操作，服务应产生自己的线程来执行。有一个类——IntentService，有自己的线程。

也可以换一种方式说：

Service不是独立的过程。Service对象本身不是在它自己的进程中运行;除非另有说明，否则它将与它所属的应用程序在同一进程中运行。

Service也不是线程。它本身并不是在主线程之外工作。

Service的两种功能

• Context.startService()调用

该调用是系统安排服务的工作计划，直到运行该服务或其他人明确停止它为止。通过stopService停止或在服务内通过stopSelf停止。

• Context.bindService()调用

该调用允许与该服务建立长期连接以便与其进行交互。例如：服务和activity之间的通信。

Service在AndroidManifext的声明

<service
    android:name=".MyService">
</service>

在清单文件中声明了服务，就可以强制对服务进行全局访问。多个activity都可以和服务进行通信。当其他应用程序向访问时，需要在其自己的清单文件中声明一个相应的<user-permission>元素，以便能够启动，停止或绑定到该服务。

刚才说service里不能执行耗时的操作。特殊情况，可以在清单文件中配置service执行所在的进程，让service在另外的进程中运行。

<service
    android:name="com.lxy.service.MyService"
    //true系统默认启动 false不设置为默认
    android:enabled="true"
    //设置为远程服务
    android:process=":remote">
</service>

Service的创建与启动

• 启动服务

public void MyService extends Service{
     public static final String TAG = "MyService";
    
     @Override
     public void onCreate(){
         Log.d(TAG,"onCreate()");
         super.onCreate();
     }
     
     /**
     * @param intent 启动时组件传递过来的intent
     * @param flags 表示启动请求时是否有额外数据
     * @param startId 指明当前服务的唯一id 可能会有多个启动service的请求，通过startId来区分它们
     */
     @Override
     public int onStartCommand(Intent intent,int flags,int startId){
        Log.d(TAG,"onStartCommand()");
        return super.onStartCommand(intent,flags,startId);
     }
     
     @Override
     public void onDestory(){
         Log.d(TAG,"onDestory()");
         super.onDestory();
     }
     
    @Nullable
    @Override
    public IBinder onBind(Intent intent) {
        return null;
    }
} 

public class MainActivity extends AppCompatActivity implements View.OnClickListener{
    private static final String TAG = "MainAcitvity";
    private Button start;
    private Button stop;
    
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        start = findViewById(R.id.start);
        stop = findViewById(R.id.stop);
        start.setOnClickListener(this);
        stop.setOnClickListener(this);
    }
    
     @Override
    public void onClick(View v) {
        Intent intent = new Intent(this,MyService.class);
        int id = v.getId();
        switch (id){
            case R.id.start:
                startService(intent);
                Log.d(TAG,"startService()");
                break;
            case R.id.stop:
                stopService(intent);
                break;
        }
    }
} 

这是上面启动服务的运行结果：

image

可以看到：
调用startService(intent),系统检索服务，也就是创建服务并调用其onCreate()方法，然后使用客户端提供的参数调用其onStartCommand(intent,int,int)方法。此时服务会一直运行，直到调用stopService()和stopSelf()。还可以发现，除第一次启动服务会调用onCreate()方法外，再次启动则不会调用只会调用服务的onStartCommand()方法。不管启动多少次，一旦stopService()或stopSelf()都会停止服务。

还有一点，服务可以使用stopSelf(int)来确保有新的请求启动服务之前不停止服务。

onStartCommand()返回的常量

两个常见的常量：

• START_STICKY:服务所在的进程被kill(在onStartCommand()方法之后)，会保留其为启动状态，但不保存intent。稍后，系统会尝试创建新的服务。因为处于启动状态，会调用onStartCommand(intent,int,int),如果没有待处理的启动命令传递给服务，则intent为null,所以必须注意进行检查。

对于在任意时间段内将明确启动和停止运行的事物，此模式适用。

• START_NOT_STICKY:如果服务的进程被kill,并且没有新的intent传递给它，则将服务从启动状态中移除。直到显示调用startService才重新创建。该服务不会遇到intent==null。因为如果没有intent传递，服务不会重新启动。

对于希望由于启动某些工作的事情来说，此模式很有意义。例如：需要实现一个轮询数据的服务。安排警报的启动，每n分钟轮询一次警报。

• 绑定服务

public class MyService extends Service {
    private static final String TAG = "MyService";
    private int count = 0;
    private IBinder myBinder;
    private boolean quit = false;

    class MyBinder extends Binder{
        MyService getService(){
            return MyService.this;
        }
    }

    /**
     * 可以对一些数据进行初始化 只会调用一次
     */
    @Override
    public void onCreate() {
        Log.d(TAG,"onCreate()");
        super.onCreate();
        myBinder = new MyBinder();
    }

    /**
     * @param intent 启动时组件传递过来的intent
     * @param flags 表示启动请求时是否有额外数据
     * @param startId 指明当前服务的唯一id 可能会有多个启动service的请求，通过startId来区分它们
     */
    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        Log.d(TAG,"startCommand()");
        new Thread(){
            @Override
            public void run() {
                while (!quit){
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    count++;
                }
            }
        }.start();
        return super.onStartCommand(intent, flags, startId);
    }

    @Override
    public void onDestroy() {
        this.quit = true;
        Log.d(TAG,"onDestory()");
        super.onDestroy();
    }

    /**
     * 绑定服务时才会调用
     */
    @Nullable
    @Override
    public IBinder onBind(Intent intent) {
        Log.d(TAG,"onBind()");
        return myBinder;
    }

    @Override
    public boolean onUnbind(Intent intent) {
        Log.d(TAG,"onUnbind()");
        return true;
    }

    @Override
    public void onRebind(Intent intent) {
        Log.d(TAG,"onRebind()");
        super.onRebind(intent);
    }

    public int getCount(){
        return count;
    }
}

public class MainActivity extends AppCompatActivity implements View.OnClickListener {
    private Button start;
    private Button stop;
    private ServiceConnection mServiceConnection;
    private MyService myService;
    private Button bind;
    private Button unbind;
    private Button data;

    private static final String TAG = "MainAcitvity";

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        start = findViewById(R.id.start);
        stop = findViewById(R.id.stop);
        bind = findViewById(R.id.bind);
        unbind = findViewById(R.id.unbind);
        data = findViewById(R.id.data);
        start.setOnClickListener(this);
        stop.setOnClickListener(this);
        bind.setOnClickListener(this);
        unbind.setOnClickListener(this);
        data.setOnClickListener(this);

        mServiceConnection = new ServiceConnection() {
            @Override
            public void onServiceConnected(ComponentName name, IBinder service) {
                Log.d(TAG,"绑定成功后调用onServiceConnected()");
                MyService.MyBinder myBinder = (MyService.MyBinder) service;
                myService = myBinder.getService();
            }

            @Override
            public void onServiceDisconnected(ComponentName name) {
                Log.d(TAG,"onServiceDisconnected()");
                myService = null;
            }
        };
    }

    @Override
    public void onClick(View v) {
        Intent intent = new Intent(this,MyService.class);
        int id = v.getId();
        switch (id){
            case R.id.start:
                startService(intent);
                Log.d(TAG,"startService()");
                break;
            case R.id.stop:
                stopService(intent);
                break;
            case R.id.bind:
                //BIND_AUTO_CREATE 表示在活动和服务进行绑定后自动启动服务
                bindService(intent,mServiceConnection, Service.BIND_AUTO_CREATE);
                break;
            case R.id.unbind:
                if(myService != null){
                    myService = null;
                    unbindService(mServiceConnection);
                }
                break;
            case R.id.data:
                if(myService != null){
                    Log.d(TAG,"从服务端获取数据："+ myService.getCount());
                }else {
                    Log.d(TAG,"还没绑定呢，不绑定，无法从服务端获取数据");
                }
                break;
        }
    }
}

这是调用bindService和unbindService的运行过程：

image

从上面我们可以看到：
客户端通过bindService发起和服务的绑定，服务调用onCreate()方法，但不会调用onStartCommand()。客户端将从其onBind(intent)方法接收服务返回的IBinder对象，从而允许客户端随后调用该服务。只要建立连接，该服务就将保持运行状态。

Service的生命周期

image

服务既可以启动也可以绑定，同时这两种情况也可以混用。

• 先启动服务后绑定服务

执行顺序：

startService()--->onCreate()--->startCommand()--->onBind()--->绑定成功后调用onServiceConnected()--->onUnbind()--->onDestory()

进行绑定的时候不会再执行onCreate(),onUnbind()和onDestory()是解绑服务时候调用的，在这种情况下关闭服务是没有任何反应的。

• 先绑定服务后启动服务

执行顺序：

onCreate()--->onBind()--->onServiceConnected()--->startService()--->startCommand()--->startService()--->startCommand()--->onUnbind()--->onDestory()

这里多次启动了服务，只解绑服务只执行onUnbind(),还必须stopService才会销毁服务。但如果只启动服务一次，则只解绑服务就可以。

三种绑定服务

1.继承Binder类

服务端通过实现继承Binder类，创建出Service当前的对象。客户端通过IBinder接口将服务端onBind方法传递过来Binder对象获得。Binder是android中的一种跨进程通信方式，但是一般service中的Binder是不会涉及进程间通信的。

2.使用Messenger

Messenger是基于AIDL的，就是说Messenger的底层是AIDL,通过对AIDL的封装使得我们更方便的使用。不过Messenger是不支持并发的，当有多个消息时，服务端也只会一个一个处理。实现的大概思路是：

• 服务端创建Messenger对象，同时也要创建Handler用于接收客户端传来的消息
• 服务端通过Messenger得到一个IBinder对象，并将其通过onBind方法返回给客户端
• 客户端在onServiceConnected方法中接收传来的IBinder，将Messenger实例化，使用Messenger将Message对象发送给服务端
• 服务端通过Handler接收客户端发来的消息

3.使用AIDL

AIDL会在后面的篇章进行说明与分析