android三大类service,Android四大组件之——Service

Service简述

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

1.Service是什么

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

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

也可以换一种方式说：

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

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

Service的两种功能

Context.startService()调用

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

Context.bindService()调用

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

Service在AndroidManifext的声明

android:name=".MyService">

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

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

android:name="com.lxy.service.MyService"

//true系统默认启动 false不设置为默认

android:enabled="true"

//设置为远程服务

android:process=":remote">

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会在后面的篇章进行说明与分析