Android Service（一）--浅谈Service

标签：android   service   remote service   

一．Service简介

service可以说是一个在后台运行的Activity，它不是一个单独的进程，它只需要应用告诉它要在后台做什么就可以了，它要实现和用户的交互的话需要通过通知栏或则是发送广播，UI去接收显示。它的应用十分广泛，尤其是在框架层，应用更多的是对系统服务的调用。它用于处理一些不干扰用户使用的后台操作。如下载，网络获取。播放音乐，他可以通过INTENT来开启，同时也可以绑定到宿主对象（调用者例如ACTIVITY上）来使用。服务是一个应用程序组件代表应用程序执行一个长时间操作的行为，虽然不与用户交互或供应功能供其它应用程序使用。每个服务类必须有一个相应的包的AndroidManifest.xml中 <Service>声明。服务可以通过Context.startService()和Context.bindService()开始工作。它和其他的应用对象一样，在他的宿主进程的主线程中运行。

二．服务的类型

按使用范围分为本地服务个远程服务两种。

本地服务：用于应用程序内部，实现应用程序自己的一些耗时任务，比如查询升级信息，并不占用应用程序比如Activity所属线程，而是单开线程后台执行，这样用户体验比较好。

在Service可以调用Context.startService()启动，调用Context.stopService()结束。在内部可以调用Service.stopSelf() 或 Service.stopSelfResult()来自己停止。无论调用了多少次startService()，都只需调用一次stopService()来停止。

远程服务：用于android系统内部的应用程序之间，可被其他应用程序复用，比如天气预报服务，其他应用程序不需要再写这样的服务，调用已有的即可。可以定义接口并把接口暴露出来，以便其他应用进行操作。客户端建立到服务对象的连接，并通过那个连接来调用服务。调用Context.bindService()方法建立连接，并启动，以调用 Context.unbindService()关闭连接。多个客户端可以绑定至同一个服务。如果服务此时还没有加载，bindService()会先加载它。

按运行类别分为前台服务和后台服务两种。

前台服务：前台服务需要调用 startForeground （ android 2.0 及其以后版本 ）或 setForeground （android 2.0 以前的版本）使服务成为 前台服务。

使用前台服务可以避免服务在后台运行的时候被系统KILL。

后台服务：后台服务就是处于后台运行的。

三．Service生命周期

注意：本地服务中，onStart已经被onStartCommand方法取代，Service和Activity都是由Context类派生的，可以通过getApplicationContext()方法获取上下文对象，和Activity一样，它有着自己的生命周期，可是和Activity相比，它所执行的过程略有不同，如上图所示。

四．3种服务通信类型

3种服务通信类型，分别是通过startService()直接启动服务，通过bindService()的方式启动和使用AIDL方式的Service。

1. context.startService() 启动流程（后台处理工作），只能实现启动和停止服务

流程：UI ——>Service

操作：使用Intent进行数据传递，通过服务中的onStartCommand方法进行接受（和Activity间传递方式一样）

启动流程：

context.startService() -> onCreate() -> onStartCommand() -> Service running -> context.stopService() -> onDestroy() -> Service stop 

所以调用startService的生命周期大致为：

onCreate（只在创建的时候调用一次直到被摧毁） --> onStartCommand (服务开启后，可多次调用) --> onDestroy

服务中的onStartCommand(Intent intent, int flags, int startId)方法会返回一个唯一的整数标识符来识别启动请求，启动请求可以是START_STICKY、START_STICKY_COMPATIBILITY、START_NOT_STICKY、START_REDELIVER_INTENT等，标志位可以是START_FLAG_REDELIVERY、START_FLAG_RETRY。

通过这种方式，服务并不会随着绑定组建的摧毁而摧毁，而是服务自我摧毁。（所以这种方式适用于文件下载，上传等请求自行运行的场景）。

从生命周期图中我们可以看出，onCreate方法只在创建时候被调用了一次，这说明：Service被启动时只调用一次onCreate()方法，如果服务已经被启动，在次启动的Service组件将直接调用onStartCommand()方法，通过这样的生命周期，可以根据自身需求将指定操作分配进onCreate()方法或onStartCommand()方法中。

使用方法：

（1）创建服务类

public class MyService extends Service {
	@Override
	public void onCreate() {
	}

	@Override
	public int onStartCommand(Intent intent, int flags, int startId) {
		//接受传递过来的intent的数据等
		return START_STICKY;
	}

	@Override
	public void onDestroy() {
		
	}
}

（2）在AndroidManifest.xml文件中注册Service

<service android:name="服务类所在的包名.MyService" />

（3）启动服务

Intent intent = new Intent(getApplicationContext(), MyService.class);
startService(intent);

2. context.bindService()启动流程（在本地同一进程内与Activity交互），单向交互

流程：UI ——>Service

启动流程：

context.bindService() -> onCreate() -> onBind() -> Service running -> onUnbind() -> onDestroy() -> Service stop

bindService的生命周期简化为为： onCreate --> onBind --> onUnbind --> onDestory。

通过该方法，服务启动时会调用onCreate()来启动服务，可是它不会调用onStartCommand() 方法，并且只有在所有的服务都接触了后，服务才会自动停止运行。通过服务的onBind()方法，可以获的一个客户端与服务器进行通信的IBdiner接口。IBind允许客户端回调服务的方法，比如得到Service的实例、运行状态或其他操作。这个时候把调用者（Context，例如Activity）会和Service绑定在一起，Context退出了，Srevice就会调用onUnbind->onDestroy相应退出。 

注：绑定服务的Android组建在摧毁前应解除绑定，否则会造成内存泄漏。

使用方法：

（1）创建服务类

private LocalService extends Service{
	@Override
	public void onCreate() {
		
	}
	/** 绑定的IBinder */
	private final IBinder mBinder = new LocalBinder();
	
	public class LocalBinder extends Binder {
		public LocalService getService() {
			return LocalService.this;
		}
	}

	@Override
	public IBinder onBind(Intent intent) {
		return mBinder;
	}
	
	@Override
	public boolean onUnbind(Intent intent) {
		// TODO Auto-generated method stub
		return super.onUnbind(intent);
	}
}

（2）在AndroidManifest.xml文件中注册Service

同startService的一样。

（3）绑定服务

绑定服务需要需要设置ServiceConnection和标志位，方法如下：

bindService(Intent service, ServiceConnection conn, int flags)

ServiceConnection可以监听服务的状态，在进行服务绑定的时，其标志位可以为以下几种（这里列出3种）：

1).Context.BIND_AUTO_CREATE 

说明：表示收到绑定请求的时候，如果服务尚未创建，则即刻创建，在系统内存不足需要先摧毁优先级组件来释放内存，且只有驻留该服务的进程成为被摧毁对象时，服务才被摧毁

2).Context.BIND_DEBUG_UNBIND 

说明：通常用于调试场景中判断绑定的服务是否正确，但容易引起内存泄漏，因此非调试目的的时候不建议使用

3).Context.BIND_NOT_FOREGROUND 

说明：表示系统将阻止驻留该服务的进程具有前台优先级，仅在后台运行，该标志位位于Froyo中引入。

注意：绑定服务的以异步方式运行的。绑定服务必须在当前的上下文环境中运行，某些场景中，通过上下文进行添加绑定接触方法如下：

getApplicationContext().bindService(service, conn, flags)

Activity中代码如下：

/** 是否绑定 */
boolean mIsBound = false;

/** 绑定服务 */
public void doBindService() {
	bindService(new Intent(MainActivity.this, LocalService.class), mConnection,Context.BIND_AUTO_CREATE);
	mIsBound = true;
}

/** 解除绑定服务 */
public void doUnbindService() {
	if (mIsBound) {
		// Detach our existing connection.
		unbindService(mConnection);
		mIsBound = false;
	}
}

private ServiceConnection mConnection = new ServiceConnection() {

	@Override
	public void onServiceConnected(ComponentName name, IBinder service) {
		mBoundService = ((LocalService.LocalBinder) service).getService();
		Toast.makeText(MainActivity.this, "服务连接", Toast.LENGTH_SHORT)
				.show();
	}

	@Override
	public void onServiceDisconnected(ComponentName name) {
		mBoundService = null;
		Toast.makeText(MainActivity.this, "服务未连接", Toast.LENGTH_SHORT)
				.show();
	}
};

3. 使用AIDL方式的Service（进行跨进程通信），双向交互

流程：UI <——>Service

操作：注册绑定广播接受器，之后通过广播来进行2者间通信

启动流程：和bindService一样，实现上是在bindService 的基础上使用AIDL进行通信。

使用方法：

远程绑定调用service主要是用来不同进程的信息共享。就比如服务器和客户端，在服务器端设置好一个service提供方法或信息，然后客户端可以直接调用服务器端service提供方法或信息。这里有个前提是客户端必须有和服务器端一份一样的AIDL，然后服务器端在客户端使用的系统上有注册过（也就是安装运行过一次），之后客户端就可以远程绑定调用服务器端的service了。

具体的步骤如下：

1.首先，是服务器的

1）创建一个android应用工程 ,命名为AidlServer

2) 在主Aitivity所在的包里新建个AIDL文件，这是ADT会自动帮你在gen目录下生成一个和AIDL文件同名的JAVA文件（这里的AidlService.java是下一步骤生成的，这里可以先忽略）

3）如上图所示，创建一个用来使用service的类(AidlService.java）

具体每个文件的代码如下：

IAidlService.idal文件：

package com.example.aidlserver;
interface IAidlService {     
    String getValue(); 
} 

AidlService.java文件：

public class AidlService extends Service {

	private class MyBinder extends IAidlService.Stub {  

		@Override
		public String getValue() throws RemoteException {
			// TODO Auto-generated method stub
			return "test remote service";
		}  
    }  

	@Override
	public void onCreate() {
		super.onCreate();
		Log.i("AidlService","onCreate");
	}	
		
	@Override
	public IBinder onBind(Intent intent) {
		// TODO Auto-generated method stub
		Log.i("AidlService","service on bind");
		return new MyBinder();
	}
	
	@Override
	public void onDestroy() {
		Log.i("AidlService","service on destroy");
		super.onDestroy();
	}

}

MainActivity.java文件：

public class MainActivity extends Activity {
	private TextView show;
	private IAidlService  iservice;

	@Override
	protected void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);
		setContentView(R.layout.activity_main);
		
		show = (TextView)findViewById(R.id.show);
	}
	
	/*点击第二次的时候次可以改变TextView的值，因为第一次只是绑定，返回的对象是空。*/
	public void onGetAidlServerDataBtnClick(View v){
		Intent service = new Intent(IAidlService.class.getName());  
        bindService(service, connection, BIND_AUTO_CREATE);  
        if (iservice != null) {    
            try {  
                show.setText(iservice.getValue());
            } catch (RemoteException e) {  
                e.printStackTrace();  
            }  
        }  
	}
	
	private ServiceConnection connection = new ServiceConnection() {  
		  
        public void onServiceConnected(ComponentName name, IBinder service) {  
            // TODO Auto-generated method stub   
        	/*获取Service对象*/
        	iservice = (IAidlService) IAidlService.Stub.asInterface(service);  
            Log.i("Client","Bind Success:" + service);  
        }    
  
        public void onServiceDisconnected(ComponentName name) {  
            // TODO Auto-generated method stub   
        	iservice = null;  
            Log.i("Client","onServiceDisconnected");  
        }  
    };  



}

AndroidManifest.xml

<service
            android:name=".AidlService"
            android:enabled="true"
            android:process=":remote">
            <intent-filter>
                <!-- AIDL完整路径名。必须指明，客户端能够通过AIDL类名查找到它的实现类 -->  
                <action android:name="com.example.aidlserver.IAidlService"/>
                <category android:name="android.intent.category.DEFAULT"/>   
            </intent-filter>
 </service>

这里，服务器端的工作做好了，接下来是客户端的工作。

2.接着，是客户端的：

1）首先，创建一个工程，命名为AidlClient

2）接着，把服务器端的一些文件拷贝过来（创建com.ds.server这个包，然后往里面复制进入如下图的服务器端的文件（IAidlService.java)

下面是个文件的内容

AidlClientActivity.java

public class MainActivity extends Activity {
	private TextView show;
	private IAidlService  iservice;

	@Override
	protected void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);
		setContentView(R.layout.activity_main);
		
		show = (TextView)findViewById(R.id.show);
	}
	
	/*点击第二次的时候次可以改变TextView的值，因为第一次只是绑定，返回的对象是空。*/
	public void onGetAidlServerDataBtnClick(View v){
		Intent service = new Intent(IAidlService.class.getName());  
        bindService(service, connection, BIND_AUTO_CREATE);  
        if (iservice != null) {    
            try {  
                show.setText(iservice.getValue());
            } catch (RemoteException e) {  
                e.printStackTrace();  
            }  
        }  
	}
	
	private ServiceConnection connection = new ServiceConnection() {  
		  
        public void onServiceConnected(ComponentName name, IBinder service) {  
            // TODO Auto-generated method stub   
        	/*获取Service对象*/
        	iservice = (IAidlService) IAidlService.Stub.asInterface(service);  
            Log.i("Client","Bind Success:" + service);  
        }    
  
        public void onServiceDisconnected(ComponentName name) {  
            // TODO Auto-generated method stub   
        	iservice = null;  
            Log.i("Client","onServiceDisconnected");  
        }  
    };  
}

注意：使用广播进行双向交互的时候，在服务退出的时候记得unregisterReceiver(receiver);注销广播接收器。

五．停止服务

1. 启动服务停止有2种方法：

（1）stopSelf() 自我停止服务

（2）stopService(Intent name) 被动停止服务

2. 绑定服务的解除绑定方法如下

unbindService(ServiceConnection conn)

六．拓展

1. 如何检查Android后台服务线程（Service类）是否正在运行

Android系统自己提供了一个函数ActivityManager.getRunningServices，可以列出当前正在运行的后台服务线程。

代码如下：

private boolean isServiceRunning() {
    ActivityManager manager = (ActivityManager) getSystemService(ACTIVITY_SERVICE);
    for (RunningServiceInfo service : manager.getRunningServices(Integer.MAX_VALUE)) {
        if ("com.example.MyService".equals(service.service.getClassName())) {
            return true;
        }
    }
    return false;
}

2. Service和Thread的区别

我们拿服务来进行一个后台长时间的动作，为了不阻塞线程，然而，Thread就可以达到这个效果，为什么我们不直接使用Thread去代替服务呢？

1). Thread：Thread 是程序执行的最小单元，它是分配CPU的基本单位。可以用 Thread 来执行一些异步的操作。 
2). Service：Service 是android的一种机制，当它运行的时候如果是Local Service，那么对应的 Service 是运行在主进程的 main 线程上的。如：onCreate，onStart 这些函数在被系统调用的时候都是在主进程的 main 线程上运行的。如果是Remote Service，那么对应的 Service 则是运行在独立进程的 main 线程上。因此请不要把 Service 理解成线程。

既然这样，那么我们为什么要用 Service 呢？其实这跟 android 的系统机制有关，我们先拿 Thread 来说。Thread 的运行是独立于 Activity 的，也就是说当一个 Activity 被 finish 之后，如果你没有主动停止 Thread 或者 Thread 里的 run 方法没有执行完毕的话，Thread 也会一直执行。因此这里会出现一个问题：当 Activity 被 finish 之后，你不再持有该 Thread 的引用。另一方面，你没有办法在不同的 Activity 中对同一 Thread 进行控制。
举个例子：如果你的 Thread 需要不停地隔一段时间就要连接服务器做某种同步的话，该 Thread 需要在 Activity 没有start的时候也在运行。这个时候当你 start 一个 Activity 就没有办法在该 Activity 里面控制之前创建的 Thread。因此你便需要创建并启动一个 Service ，在 Service 里面创建、运行并控制该 Thread，这样便解决了该问题（因为任何 Activity 都可以控制同一 Service，而系统也只会创建一个对应 Service 的实例）。
因此你可以把 Service 想象成一种消息服务，而你可以在任何有 Context 的地方调用 Context.startService、Context.stopService、Context.bindService，Context.unbindService，来控制它，你也可以在 Service 里注册 BroadcastReceiver，在其他地方通过发送 broadcast 来控制它，当然这些都是 Thread 做不到的。

七．参考网址

1. http://blog.csdn.net/vipzjyno1/article/details/26004831  服务介绍

2. http://blog.csdn.net/kernel_jim_wu/article/details/8479070  aidl clent server

Android Service（一）--浅谈Service

标签：android   service   remote service   

原文地址：http://blog.csdn.net/li1500742101/article/details/45029045