Android基础总结六：Sevice

文章出处：https://blog.csdn.net/shift_wwx/article/details/9952045

请转载的朋友标明出处~~

 

前言：

android四大控件之前介绍了两个了，其实重要性不分彼此，但是个人感觉复杂度的话service是肯定是之最，所以，在总结的时候肯定会有所遗漏，希望大家不吝赐教。

service 在AMS 中详解可以看：Android 中service 详解

 

一、介绍

service众所周知，就是服务的意思，是运行在后台的。例如，一些音乐播放器，就可以放在后台运行，这样，我们就可以一边操作其他的一边听音乐。当我们的应用程序需要做一个长耗时的操作，还有可能需要和别的程序交互的时候，我们就需要使用Service。

1. service类别

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

 

2. Service不是一个单独的进程，除非单独声明（android:process可以声明），否则它不会运行在单独的进程中，而是和启动它的程序运行在同一个进程中。

3. Service不是线程，这意味著它将在主线程里运行。

也就是说Service既不是进程也不是线程，它们之间的关系如下：

 

二、service和Thread

可能有的朋友会问了，既然是长耗时的操作，那么Thread也可以完成啊。没错，在程序里面很多耗时工作我们也可以通过Thread来完成，那么还需要Service干嘛呢。接下来就为大家解释以下Service和Thread的区别。

首先要说明的是，进程是系统最小资源分配单位，而线程是则是最小的执行单位，线程需要的资源通过它所在的进程获取。

1. service是android的一种机制，当它运行的时候如果是Local Service，那么对应的service是运行在主进程的；如果是Remote Service，那么对应的service则是运行在独立进程的main线程上，service和调用者之间的通讯都是同步的（不论是远程service还是本地service），它跟线程一点关系都没有！

2. Thread 的运行是独立的，也就是说当一个 Activity 被 finish 之后，如果没有主动停止 Thread 或者 Thread 里的 run 方法没有执行完毕的话，Thread 也会一直执行。因此这里会出现一个问题：当 Activity 被 finish 之后，不再持有该 Thread 的引用，也就是不能再控制该Thread。另一方面，没有办法在不同的 Activity 中对同一 Thread 进行控制。

例如：如果 一个Thread 需要每隔一段时间连接服务器校验数据，该Thread需要在后台一直运行。这时候如果创建该Thread的Activity被结束了而该Thread没有停止，那么将没有办法再控制该Thread，除非kill掉该程序的进程。这时候如果创建并启动一个 Service ，在 Service 里面创建、运行并控制该 Thread，这样便解决了该问题(因为任何 Activity 都可以控制同一个Service，而系统也只会创建一个对应 Service 的实例)。

因此可以把 Service 想象成一种消息服务，可以在任何有 Context 的地方调用 Context.startService、Context.stopService、Context.bindService、Context.unbindService来控制它，也可以在 Service 里注册 BroadcastReceiver，通过发送 broadcast 来达到控制的目的，这些都是 Thread 做不到的。

 

三、service生命周期

service不能自己启动，必须要外界才能启动。

一共有两种启动方式：startService、bindService

一共有两种停止方式：stopService或者是stopSelf()、unbindService

 

因此就会出现如下几种情况：

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、服务的整个生命周期从调用 onCreate() 开始起，到 onDestroy() 返回时结束。与 Activity 类似，服务也在 onCreate() 中完成初始设置，并在 onDestroy() 中释放所有剩余资源。例如，音乐播放服务可以在 onCreate() 中创建用于播放音乐的线程，然后在 onDestroy() 中停止该线程。
2、无论服务是通过 startService() 还是 bindService() 创建，都会为所有服务调用 onCreate() 和 onDestroy() 方法。
3、服务的有效生命周期从调用 onStartCommand() 或 onBind() 方法开始。每种方法均有 Intent 对象，该对象分别传递到 startService() 或 bindService()。
4、对于启动服务，有效生命周期与整个生命周期同时结束（即便是在 onStartCommand() 返回之后，服务仍然处于活动状态）。对于绑定服务，有效生命周期在 onUnbind() 返回时结束。

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

 

四、绑定服务的声明周期

当服务与所有客户端之间的绑定全部取消时，Android 系统便会销毁服务（除非还使用 onStartCommand() 启动了该服务）。因此，如果您的服务是纯粹的绑定服务，则无需对其生命周期进行管理 — Android 系统会根据它是否绑定到任何客户端代您管理。

不过，如果您选择实现 onStartCommand() 回调方法，则您必须显式停止服务，因为系统现在已将服务视为已启动。在此情况下，服务将一直运行到其通过 stopSelf() 自行停止，或其他组件调用 stopService() 为止，无论其是否绑定到任何客户端。

此外，如果您的服务已启动并接受绑定，则当系统调用您的 onUnbind() 方法时，如果您想在客户端下一次绑定到服务时接收 onRebind() 调用，则可选择返回 true。onRebind() 返回空值，但客户端仍在其 onServiceConnected() 回调中接收 IBinder。下文图 1 说明了这种生命周期的逻辑。

 

五、实例运用

之前将的基本上都是一些基础理论知识，现在通过实例来介绍一下service。

1. startService 启动服务
想要用 startService 启动服务，不管Local 还是 Remote 我们需要做的工作都是一样简单。当然要记得在 Androidmanifest.xml 中注册 service。

<service
    android:name=".MyTestService">
    <intent-filter>
         <action android:name="com.amlogic.service.MyTest" />
    </intent-filter>
</service>

package com.shift.testservice;

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

public class ServiceActivity extends Activity {
	Context mContext;
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
        
        mContext = getApplicationContext();
        
        Button start = (Button)findViewById(R.id.start);
        start.setOnClickListener(new OnClickListener() {			
			@Override
			public void onClick(View v) {
				Intent intent = new Intent(ServiceActivity.this, MyTestService.class);
				mContext.startService(intent);//start可以指定特定的class或者是action,Intent是启动的关键
			}
		});       
        Button stop = (Button)findViewById(R.id.stop);
        stop.setOnClickListener(new OnClickListener() {
			
			@Override
			public void onClick(View v) {
				Intent intent = new Intent(ServiceActivity.this, MyTestService.class);
				mContext.stopService(intent);		
			}
		});
    }
}

2. bindService启动服务

我这里做了一个client的类，这样可以将client端的需要的接口都封装起来。

public class VideoServiceClient {
	private static final String TAG = "VideoServiceClient";
	private static final String SERVICE_ACTION="shift.video.service";
	public IVideoPlay mService;
	
	private ServiceConnection mVideoCon = new ServiceConnection() {		
		@Override
		public void onServiceDisconnected(ComponentName name) {
			mService = null;
		}
		
		@Override
		public void onServiceConnected(ComponentName name, IBinder service) {
			Log.d(TAG, "====onServiceConnected=======");
			mService = IVideoPlay.Stub.asInterface(service);
		}
	};
	
	public void bindService(Context context){
		Intent intent = new Intent();
		intent.setClassName("com.shift.videoplayer", "com.shift.service.VideoService");
		context.bindService(intent, mVideoCon, Context.BIND_AUTO_CREATE);
	}
	
	public void unBindService(Context context){
		context.unbindService(mVideoCon);
	}

	public synchronized void videoPlay(){
		if(mService != null){
			try {
				mService.videoPlay();
			} catch (RemoteException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
	}
	
	public synchronized void videoPause(){
		if(mService != null){
			try {
				mService.videoPause();
			} catch (RemoteException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
	}

	public synchronized void videoNext(){
		if(mService != null){
			try {
				mService.videoNext();
			} catch (RemoteException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
	}
	
	public synchronized void videoPre(){
		if(mService != null){
			try {
				mService.videoPre();
			} catch (RemoteException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
	}
	
	public synchronized void videoStop(){
		if(mService != null){
			try {
				mService.videoStop();
			} catch (RemoteException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
	}

	public synchronized void videoSeek(int time){
		if(mService != null){
			try {
				mService.videoSeek(time);
			} catch (RemoteException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
	}
}

 

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

3.  创建前台服务
前台服务的优点上面已经说明，但设置服务为前台服务，我们需要注意在 sdk 2.0 及其以后版本使用的方法是 startForeground 与 stopForeground，之前版本使用的是 setForeground ，因此如果你应用程序的最低运行环境要求是 2.0，那么这里可以直接运用新方法，如果运行环境是2.0以下，那么为了保证向后兼容性，这里必须使用反射技术来调用新方法。

public class ForegroundService extends Service { 
private static final Class[] mStartForegroundSignature = new Class[] { 
int.class, Notification.class}; 
private static final Class[] mStopForegroundSignature = new Class[] { 
boolean.class}; 
private NotificationManager mNM; 
private Method mStartForeground; 
private Method mStopForeground; 
private Object[] mStartForegroundArgs = new Object[2]; 
private Object[] mStopForegroundArgs = new Object[1]; 
@Override 
public IBinder onBind(Intent intent) { 
    return null; 
} 
@Override 
public void onCreate() { 
    super.onCreate(); 
    mNM = (NotificationManager)getSystemService(Context.NOTIFICATION_SERVICE); 
    try { 
        mStartForeground = ForegroundService.class.getMethod("startForeground", mStartForegroundSignature); 
        mStopForeground = ForegroundService.class.getMethod("stopForeground", mStopForegroundSignature); 
    } catch (NoSuchMethodException e) { 
        mStartForeground = mStopForeground = null; 
    } 
    // 我们并不需要为 notification.flags 设置 FLAG_ONGOING_EVENT，因为 
    // 前台服务的 notification.flags 总是默认包含了那个标志位 
    Notification notification = new Notification(R.drawable.icon, "Foreground Service Started.", 
    System.currentTimeMillis()); 
    PendingIntent contentIntent = PendingIntent.getActivity(this, 0, 
    new Intent(this, Main.class), 0); 
    notification.setLatestEventInfo(this, "Foreground Service", "Foreground Service Started.", contentIntent); 
    // 注意使用 startForeground ，id 为 0 将不会显示 notification 
    startForegroundCompat(1, notification); 
} 
@Override 
public void onDestroy() { 
    super.onDestroy(); 
    stopForegroundCompat(1); 
} 
// 以兼容性方式开始前台服务 
private void startForegroundCompat(int id, Notification n){ 
    if(mStartForeground != null){ 
        mStartForegroundArgs[0] = id; 
        mStartForegroundArgs[1] = n; 
        try { 
             mStartForeground.invoke(this, mStartForegroundArgs); 
        } catch (IllegalArgumentException e) { 
            e.printStackTrace(); 
        } catch (IllegalAccessException e) { 
            e.printStackTrace(); 
        } catch (InvocationTargetException e) { 
            e.printStackTrace(); 
        } 
        return; 
    } 
    setForeground(true); 
    mNM.notify(id, n); 
} 
// 以兼容性方式停止前台服务 
private void stopForegroundCompat(int id){ 
    if(mStopForeground != null){ 
        mStopForegroundArgs[0] = Boolean.TRUE; 
        try { 
            mStopForeground.invoke(this, mStopForegroundArgs); 
        } catch (IllegalArgumentException e) { 
            e.printStackTrace(); 
        } catch (IllegalAccessException e) { 
            e.printStackTrace(); 
        } catch (InvocationTargetException e) { 
            e.printStackTrace(); 
        } 
        return; 
    } 
    // 在 setForeground 之前调用 cancel，因为我们有可能在取消前台服务之后 
    // 的那一瞬间被kill掉。这个时候 notification 便永远不会从通知一栏移除 
    mNM.cancel(id); 
    setForeground(false); 
} 
} 

特别注意： 1、使用 startForeground ，如果 id 为 0 ，那么 notification 将不会显示。

4. 进程间通信

一般用到的是BroadcastReceiver或者是AIDL，broadcastreceiver一般很好理解，但是中间存在优先级和延迟。

AIDL我会在另一篇文档中介绍。 

 

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

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