作为android四大组件之一,Services主要用作后台的、耗时操作。它没有UI。它跟Activity的级别差不多,从某种意义上说,Service可以理解为”没有用户界面的Activity”,但是他不能自己运行,只能后台运行,虽然Service不提供界面与用户进行交互,但是可以和其他组件进行交互,甚至实现进程间通信(IPC)。Service和其他的应用组件一样,运行在进程的主线程中。这就是说如果Service需要很多耗时或者阻塞的操作,需要在其子线程中实现。应用程序的其他组件可以启动Service,此时Service 即会在后台持续运行,即使用户切换到了其他应用程序,service也依旧运行。一般:网络传输、播放音乐、执行文件I/O,或者和内容提供者(content provider)交互,都可以放到Service中到后台来执行。

一、Service的分类

按运行地点分类:

类别区别 优点缺点 应用
本地服务(Local)该服务依附在主进程上, 服务依附在主进程上而不是独立的进程,这样在一定程度上节约了资源,另外Local服务因为是在同一进程因此不需要IPC,也不需要AIDL。相应bindService会方便很多。 主进程被Kill后,服务便会终止。 非常常见的应用如:HTC的音乐播放服务,天天动听音乐播放服务。
远程服务(Remote)该服务是独立的进程, 服务为独立的进程,对应进程名格式为所在包名加上你指定的android:process字符串。由于是独立的进程,因此在Activity所在进程被Kill的时候,该服务依然在运行,不受其他进程影响,有利于为多个进程提供服务具有较高的灵活性。 该服务是独立的进程,会占用一定资源,并且使用AIDL进行IPC稍微麻烦一点。 一些提供系统服务的Service,这种Service是常驻的。
其实remote服务还是很少见的,并且一般都是系统服务。

按运行类型分类:

类别区别应用
前台服务会在通知一栏显示 ONGOING 的 Notification,当服务被终止的时候,通知一栏的 Notification 也会消失,这样对于用户有一定的通知作用。常见的如音乐播放服务。
后台服务默认的服务即为后台服务,即不会在通知一栏显示 ONGOING 的 Notification。当服务被终止的时候,用户是看不到效果的。某些不需要运行或终止提示的服务,如天气更新,日期同步,邮件同步等。
有同学可能会问,后台服务我们可以自己创建 ONGOING 的 Notification 这样就成为前台服务吗?答案是否定的,前台服务是在做了上述工作之后需要调用 startForeground ( android 2.0 及其以后版本 )或 setForeground (android 2.0 以前的版本)使服务成为 前台服务。这样做的好处在于,当服务被外部强制终止掉的时候,ONGOING 的 Notification 任然会移除掉。

按使用方式分类:

类别区别
startService 启动的服务主要用于启动一个服务执行后台任务,不进行通信。停止服务使用stopService
bindService 启动的服务该方法启动的服务要进行通信。停止服务使用unbindService
startService 同时也 bindService 启动的服务停止服务应同时使用stepService与unbindService

二、Service 与 Thread 的区别

  很多时候,你可能会问,为什么要用 Service,而不用 Thread 呢,因为用 Thread 是很方便的,比起 Service 也方便多了,下面我详细的来解释一下。

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 做不到的。

 

三、Service的生命周期

1). 被启动的服务的生命周期:如果一个Service被某个Activity 调用 Context.startService 方法启动,那么不管是否有Activity使用bindService绑定或unbindService解除绑定到该Service,该Service都在后台运行。如果一个Service被startService 方法多次启动,那么onCreate方法只会调用一次,onStart将会被调用多次(对应调用startService的次数),并且系统只会创建Service的一个实例(因此你应该知道只需要一次stopService调用)。该Service将会一直在后台运行,而不管对应程序的Activity是否在运行,直到被调用stopService,或自身的stopSelf方法。当然如果系统资源不足,android系统也可能结束服务。

2). 被绑定的服务的生命周期:如果一个Service被某个Activity 调用 Context.bindService 方法绑定启动,不管调用 bindService 调用几次,onCreate方法都只会调用一次,同时onStart方法始终不会被调用。当连接建立之后,Service将会一直运行,除非调用Context.unbindService 断开连接或者之前调用bindService 的 Context 不存在了(如Activity被finish的时候),系统将会自动停止Service,对应onDestroy将被调用。

3). 被启动又被绑定的服务的生命周期:如果一个Service又被启动又被绑定,则该Service将会一直在后台运行。并且不管如何调用,onCreate始终只会调用一次,对应startService调用多少次,Service的onStart便会调用多少次。调用unbindService将不会停止Service,而必须调用 stopService 或 Service的 stopSelf 来停止服务。

4). 当服务被停止时清除服务:当一个Service被终止(1、调用stopService;2、调用stopSelf;3、不再有绑定的连接(没有被启动))时,onDestroy方法将会被调用,在这里你应当做一些清除工作,如停止在Service中创建并运行的线程。

特别注意: 1、你应当知道在调用 bindService 绑定到Service的时候,你就应当保证在某处调用 unbindService 解除绑定(尽管 Activity 被 finish 的时候绑定会自动解除,并且Service会自动停止); 2、你应当注意 使用 startService 启动服务之后,一定要使用 stopService停止服务,不管你是否使用bindService; 3、同时使用 startService 与 bindService 要注意到,Service 的终止,需要unbindService与stopService同时调用,才能终止 Service,不管 startService 与 bindService 的调用顺序,如果先调用 unbindService 此时服务不会自动终止,再调用 stopService 之后服务才会停止,如果先调用 stopService 此时服务也不会终止,而再调用 unbindService 或者 之前调用 bindService 的 Context 不存在了(如Activity 被 finish 的时候)之后服务才会自动停止; 4、当在旋转手机屏幕的时候,当手机屏幕在”横”“竖”变换时,此时如果你的 Activity 如果会自动旋转的话,旋转其实是 Activity 的重新创建,因此旋转之前的使用 bindService 建立的连接便会断开(Context 不存在了),对应服务的生命周期与上述相同。 5、在 sdk 2.0 及其以后的版本中,对应的 onStart 已经被否决变为了 onStartCommand,不过之前的 onStart 任然有效。这意味着,如果你开发的应用程序用的 sdk 为 2.0 及其以后的版本,那么你应当使用 onStartCommand 而不是 onStart。  

结合上面的说明,下面的这副图你应该很容易理解:

ServiceLifetime
ServiceLifetime

 

官方文档告诉我们,一个service可以同时start并且bind,在这样的情况,系统会一直保持service的运行状态如果service已经start了或者BIND_AUTO_CREATE标志被设置。如果没有一个条件满足,那么系统将会调用onDestory方法来终止service.所有的清理工作(终止线程,反注册接收器)都在onDestory中完成。

拥有service的进程具有较高的优先级 Android系统会尽量保持拥有service的进程运行,只要在该service已经被启动(start)或者客户端连接(bindService)到它。当内存不足时,需要保持,拥有service的进程具有较高的优先级。

1. 如果service正在调用onCreate,onStartCommand或者onDestory方法,那么用于当前service的进程则变为前台进程以避免被killed。

2. 如果当前service已经被启动(start),拥有它的进程则比那些用户可见的进程优先级低一些,但是比那些不可见的进程更重要,这就意味着service一般不会被killed.

3. 如果客户端已经连接到service (bindService),那么拥有Service的进程则拥有最高的优先级,可以认为service是可见的。

4. 如果service可以使用startForeground(int, Notification)方法来将service设置为前台状态,那么系统就认为是对用户可见的,并不会在内存不足时killed。

如果有其他的应用组件作为Service,Activity等运行在相同的进程中,那么将会增加该进程的重要性。

五、startService 启动服务,不需和Activity交互的本地服务

Service与Activity的使用方式也相似,为了创建一个Service,必须创建一个继承自android.app.Service 类或者它的子类,然后在AndroidManifest.xml文件中的 节点中注册,只不过服务使用的是 ,下面看一个简单的例子:

LocalService.java

package com.liuzhichao.service;

import android.app.Activity;
import android.content.Intent;
import android.os.Bundle;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;

public class ServiceDemoActivity extends Activity {
    private Button btn_StartService;
    private Button btn_StopService;
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);

        btn_StartService = (Button)findViewById(R.id.btn_startService);
        btn_StopService = (Button)findViewById(R.id.btn_stopService);

        btn_StartService.setOnClickListener(new OnClickListener() {
			public void onClick(View v) {
				Intent intent = new Intent(ServiceDemoActivity.this,LocalService.class);
				//Start Service
				startService(intent);
			}
		});

        btn_StopService.setOnClickListener(new OnClickListener() {
			public void onClick(View v) {
				//Stop Service
				Intent intent = new Intent(ServiceDemoActivity.this,LocalService.class);
				stopService(intent);
			}
		});
    }
}

ServiceDemoActivity.java

//Start Service
	startService(new Intent(ServiceDemoActivity.this,LocalService.class));
		............
	//Stop Service
	stopService(new Intent(ServiceDemoActivity.this,LocalService.class));

在AndroidManifest.xml添加: <service android:name=".LocalService"/> 对于这类不需和Activity交互的本地服务,是使用startService/stopService的最好例子。运行时可以发现第一次startService时,会调用onCreate和onStart(sdk2.0之后换成了onStartCommand,下同),在没有stopService前,无论点击多少次startService,都只会调用onStart。而stopService时调用onDestroy。再次点击stopService,会发现不会进入service的生命周期的,即不会再调用onCreate,onStart和onDestroy。 而onBind在startService/stopService中没有调用。

六、Local 与 Remote 服务绑定

同样记得在 Androidmanifest.xml 中注册 service

1). Local 服务绑定:Local 服务的绑定较简单,首先在 Service 中我们需要实现 Service 的抽象方法 onBind,并返回一个实现 IBinder 接口的对象。

Service 中的代码:

package com.liuzhichao.service;

import android.app.Service;
import android.content.Intent;
import android.os.Binder;
import android.os.IBinder;
import android.util.Log;

public class LocalService2 extends Service {

	private static final String TAG_STRING="LocalService2";

	public LocalBinder mLocalBinder;
         /**
	 * 在 Local Service 中我们直接继承 Binder 而不是 IBinder,
	 * 因为 Binder 实现了 IBinder 接口
	 */
	public class LocalBinder extends Binder {
		/**
		 * 获取 Service 实例
		 * @return
		 */
		public LocalService2 getService() {
			return LocalService2.this;
		}

		public int add(int a,int b) {
			return a+b;
		}
	}

	@Override
	public IBinder onBind(Intent intent) {
		Log.i(TAG_STRING, "onBind");
		// 返回 LocalBinder
		return mLocalBinder;
	}

	@Override
	public void onCreate() {
		Log.i(TAG_STRING, "onCreate");
		// 创建 LocalBinder
		mLocalBinder = new LocalBinder();
		super.onCreate();
	}

	@Override
	public void onStart(Intent intent, int startId) {
		Log.i(TAG_STRING, "onStart");
		super.onStart(intent, startId);
	}

	@Override
	public int onStartCommand(Intent intent, int flags, int startId) {
		Log.i(TAG_STRING, "onStartCommand");
		return super.onStartCommand(intent, flags, startId);
	}

	@Override
	public void onDestroy() {
		Log.i(TAG_STRING, "onDestroy");
		super.onDestroy();
	}

	@Override
	public boolean onUnbind(Intent intent) {
		Log.i(TAG_STRING, "onUnbind");
		return super.onUnbind(intent);
	}
}

上面的代码关键之处,在于 onBind(Intent) 这个方法 返回了一个实现了 IBinder 接口的对象,这个对象将用于绑定Service 的 Activity 与 Local Service 通信.

也就是说和上一例子LocalService不同的是:

  • 1. 添加了一个public内部类继承Binder,并添加getService方法来返回当前的Service对象;
  • 2. 新建一个IBinder对象——new那个Binder内部类;
  • 3. onBind方法返还那个IBinder对象。

下面是 Activity 中的代码:

package com.liuzhichao.service;

import android.app.Activity;
import android.content.ComponentName;
import android.content.Context;
import android.content.Intent;
import android.content.ServiceConnection;
import android.os.Bundle;
import android.os.IBinder;
import android.util.Log;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;

public class ServiceDemoActivity extends Activity {

	private static final String TAG_STRING = "ServiceDemoActivity";
	private Button btn_StartService;
	private Button btn_StopService;
	private Button btn_BindService;
	private Button btn_UnBindService;

	private boolean mIsBound;
	private ServiceConnection connection;

	@Override
	public void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);
		setContentView(R.layout.main);

		btn_StartService = (Button) findViewById(R.id.btn_startService);
		btn_StopService = (Button) findViewById(R.id.btn_stopService);
		btn_BindService = (Button) findViewById(R.id.btn_bindService);
		btn_UnBindService = (Button) findViewById(R.id.btn_unbindService);

		btn_StartService.setOnClickListener(new OnClickListener() {
			public void onClick(View v) {
				// Start Service
				startService(new Intent(ServiceDemoActivity.this,
						LocalService.class));
			}
		});

		btn_StopService.setOnClickListener(new OnClickListener() {
			public void onClick(View v) {
				// Stop Service
				stopService(new Intent(ServiceDemoActivity.this,
						LocalService.class));
			}
		});

		connection = new ServiceConnection() {
			// This is called when the connection with the service has been
                        // unexpectedly disconnected -- that is, its process crashed.
                        // Because it is running in our same process, we should never
                        // see this happen.
			public void onServiceDisconnected(ComponentName name) {
			}

			public void onServiceConnected(ComponentName name, IBinder service) {
				LocalService2.LocalBinder mBinder = (LocalService2.LocalBinder) service;
				Log.i(TAG_STRING, "2+3:" + mBinder.add(2, 3));
			}
		};

		btn_BindService.setOnClickListener(new OnClickListener() {
			public void onClick(View v) {
				bindService(new Intent(ServiceDemoActivity.this,
						LocalService2.class), connection,
						Context.BIND_AUTO_CREATE);
						mIsBound = true;
			}
		});

		btn_UnBindService.setOnClickListener(new OnClickListener() {
			public void onClick(View v) {
				if (mIsBound) {
					unbindService(connection);
					mIsBound = false;
				}
			}
		});
	}

}

在 Activity 中,我们通过 ServiceConnection 接口来取得建立连接 与 连接意外丢失的回调。bindService有三个参数,第一个是用于区分 Service 的Intent 与 startService 中的 Intent 一致,第二个是实现了 ServiceConnection 接口的对象,最后一个是 flag 标志位。有两个flag,BIND_DEBUG_UNBIND 与 BIND_AUTO_CREATE,前者用于调试(详细内容可以查看javadoc 上面描述的很清楚),后者默认使用。unbindService 解除绑定,参数则为之前创建的 ServiceConnection 接口对象。另外,多次调用 unbindService 来释放相同的连接会抛出异常,因此我创建了一个 boolean 变量来判断是否 unbindService 已经被调用过。

运行时,发现调用次序是这样的:

bindService:

1.LocalService2 : onCreate

2.LocalService2 : onBind

3.ServiceDemoActivity: onServiceConnected

unbindService: 只是调用onDestroy 可见,onStart是不会被调用的,而onServiceDisconnected没有调用的原因在上面代码的注释有说明。

** 特别注意: **

1、Service.onBind如果返回null,则调用 bindService 会启动 Service,但不会连接上 Service,因此 ServiceConnection.onServiceConnected 不会被调用,但你任然需要使用 unbindService 函数断开它,这样 Service 才会停止。

2). Remote 服务绑定:Remote 的服务绑定由于服务是在另外一个进程,因此需要用到 android 的 IPC 机制。

七、在什么情况下使用 startService 或 bindService 或 同时使用startService 和 bindService

如果你只是想要启动一个后台服务长期进行某项任务那么使用 startService 便可以了。如果你想要与正在运行的 Service 取得联系,那么有两种方法,一种是使用 broadcast ,另外是使用 bindService ,前者的缺点是如果交流较为频繁,容易造成性能上的问题,并且 BroadcastReceiver 本身执行代码的时间是很短的(也许执行到一半,后面的代码便不会执行),而后者则没有这些问题,因此我们肯定选择使用 bindService(这个时候你便同时在使用 startService 和 bindService 了,这在 Activity 中更新 Service 的某些运行状态是相当有用的)。另外如果你的服务只是公开一个远程接口,供连接上的客服端(android 的 Service 是C/S架构)远程调用执行方法。这个时候你可以不让服务一开始就运行,而只用 bindService ,这样在第一次 bindService 的时候才会创建服务的实例运行它,这会节约很多系统资源,特别是如果你的服务是Remote Service,那么该效果会越明显(当然在 Service 创建的时候会花去一定时间,你应当注意到这点)。

八、在 AndroidManifest.xml 里 Service 元素的常见选项

android:name:服务类名 android:label:服务的名字,如果此项不设置,那么默认显示的服务名则为类名 android:icon:服务的图标 android:permission:申明此服务的权限,这意味着只有提供了该权限的应用才能控制或连接此服务 android:process:表示该服务是否运行在另外一个进程,如果设置了此项,那么将会在包名后面加上这段字符串表示另一进程的名字 android:enabled:如果此项设置为 true,那么 Service 将会默认被系统启动,不设置默认此项为 false android:exported:表示该服务是否能够被其他应用程序所控制或连接,不设置默认此项为 falseiy

注:以上文档参考至:http://www.cnblogs.com/newcj/archive/2011/05/30/2061370.html