Android四大组件之Service

Service启动过程

1. 相关简介

ActiveServices: 管理所有services
启动过程通过context->AMS->ActiveServices实现
通过ActivityThread的applicationThread实现
process的回调
activityThread中的token为AMS中ProcessRecord的远端
activityThread中有mServices存放了该进程下的所有service，以toke binder作为key，该token为AMS对应的ServiceRecord

2. 流程

Service绑定过程

1. 相关简介

ServiceRecord: 描述一个正在运行的service，其中bindings描述目前绑在该service的intent集合
connections存放所有的service connection
ServiceRecord包含：
- 一个IntentBindRecord的list，每个IntentBindRecord中存放了一个intent和对应的service的binder，以及以这个intent绑定的AppBindRecord的list
- 一个ConnectionRecord的hashmap，该hashmap以ServiceConnection的binder对象为key，存放了以改binder绑定的CR对象。一个CR对象内部有一个AppBindRecord，activity以及ConnectionService对象（封装成了ServiceDispatcher）。
IntentBindRecord: intent和service和app的绑定关系，存放了intent和service的对应关系，以及绑定在该service上的所有app和process
AppBindRecord: 描述service和client的绑定关系，存放在IntentBindRecord
ConnectionRecord: 描述一个service的绑定，包含activity信息等等。描述AppBindRecord到ServiceRecord的绑定关系。即使相同的AppBindRecord（app与service的一个绑定），activity不同也算两个ConnectionRecord，考虑到同一个ServiceConnection可能被不同的activity共用

2. 流程

Service组件暴露 - exported属性

---

一、android:exported

该属性用来标示，其他应用的组件是否可以唤醒Service或者和这个Service进行交互

1. true

表示可以

2. false

【1】表示不可以，只有同一个应用的组件或者有着同样user ID的应用可以启动这个Service或者绑定这个Service

【2】关于user ID的参考链接

http://yelinsen.iteye.com/blog/977683

3. 默认值

【1】 根据当前Service是否有intent filter标签来定

-  没有intent filter - 默认值为false

没有任何的filter意味着这个Service只有在详细的描述了它的class name后才会被唤起，这表示当前Service只能在应用内部使用，因为其它应用程序并不知道这个class的存在，所以在这种情况下，它的默认值是false

-  有intent filter - 默认值为true

如果Service里面至少有一个filter的话，意味着该Service可以被外部应用使用，这个时候它的默认值是true

4. 权限控制

【1】不只有exported这个属性可以指定Service是否暴露给其它应用，也可以使用permission来限制外部实体唤醒当前Service

【2】android:permission

  指定唤醒Service或与Service交互所需要的权限名称

5. 参考链接

http://blog.csdn.net/watermusicyes/article/details/46460347

二、触发条件

1. 定位AndroidManifest.xml文件中的Service组件

【1】对应的特征：<service

2. exported属性的判断

【1】android:permission 如果设置权限控制，就认为不存在安全风险

【2】exported属性设置为true

  显示设置 android:exported="true"

  默认值为true，也就是具有intent filter标签，对应的特征：<intent-filter

三、漏洞原理

【1】导出的Service组件可以被第三方APP任意调用，导致敏感信息泄露，并可能受到权限提升、拒绝服务等攻击风险

【2】详细的原理&POC

http://drops.wooyun.org/tips/4907

四、修复建议

【1】如果应用的Service组件不必要导出，或者组件配置了intent filter标签，建议显示设置组件的“android:exported”属性为false

【2】如果组件必须要提供给外部应用使用，建议对组件进行权限控制

Service是android四大组件之一，它与Activity非常类似，最大的区别就是Activity在前台运行，主要作用于界面的交互，而Service是在后台运行的一个服务，它没有界面。

Service的创建步骤：

（1）定义一个继承Service的子类；

（2）在AndroidManifest.xml文件中配置该Service。

与activity类似，Service也有自己的生命周期方法，具体如下：

     abstract IBinder onBind（Intent intent）：该方法是重写Service必须实现的一个方法，方法中返回一个Binder对象，我们可以通过该Binder对象与Service进行通信。

     void onCreate （）：当Service第一次被创建成功后，将会回调该方法，主要做一些初始化操作。

     void onDestroy（）：当Service被关闭之前会调用改方法，主要做一些Service的清理与保存工作。

     void onStartCommand（）：每次客户端调用startService（Intent）后方法启动Service时，Service都会回调改方法进行相关操作。

    boolean onUnbind（）：当绑定改Service上的所有客户端全都断开连接时，将会调用改回回调方法。

下面举例子介绍一下Service组件的简单应用

1、Service的创建、配置、启动与停止

MyService类：这个类只是重写了一些方法，并打印一些log，为了清楚说明Service启动时的方法回调

<span style="font-family:FangSong_GB2312;font-size:18px;">import android.app.Service;
import android.content.Intent;
import android.os.IBinder;
import android.util.Log;

public class MyService extends Service{
	private String TAG = "MyService";
	
	//必须实现，返回IBinder对象，用于与Service组件进行通信，此处返回null，具体后面详细介绍
	@Override
	public IBinder onBind(Intent intent) {
		return null;
	}
	
	//Service被创建时回调的方法
	@Override
	public void onCreate(){
		Log.i(TAG, "创建Service调用onCreate()");
	}
	
	//Service被启动时回调的方法
	@Override
	public int onStartCommand(Intent intent, int flags, int startId){
		Log.i(TAG, "启动Service调用onStartCommand");
         /*  
         * 这里返回状态有三个值，分别是:  
         * 1、START_STICKY：当服务进程在运行时被杀死，系统将会把它置为started状态，但是不保存其传递的Intent对象，之后，系统会尝试重新创建服务;  
         * 2、START_NOT_STICKY：当服务进程在运行时被杀死，并且没有新的Intent对象传递过来的话，系统将会把它置为started状态，  
         *   但是系统不会重新创建服务，直到startService(Intent intent)方法再次被调用;  
         * 3、START_REDELIVER_INTENT：当服务进程在运行时被杀死，它将会在隔一段时间后自动创建，并且最后一个传递的Intent对象将会再次传递过来。  
         */ 
		return START_STICKY;
	}

	//Service销毁时回调的方法
	@Override
	public void onDestroy(){
		super.onDestroy();
		Log.i(TAG, "销毁Service调用onDestroy()");
	}
}</span>

定义了Service之后需要在AndroidManifest.xml文件中配置该Service，即在AndroidManifest.xml文件中application标签内增加如下的配置片段来配置service：

<span style="font-family:FangSong_GB2312;font-size:18px;"><!--  配置一个service组件 -->
        <service android:name=".MyService">
            <intent-filter>
                <!-- 为该组件的intent-filter配置action -->
                <action android:name="com.example.MY_SERVER"/>
            </intent-filter>
        </service></span>

当service开发完成之后，接下来就可以在程序中运行service了，android中运行service有如下两种方法：

1）通过Context的startService（）方法来启动service，用该方法启动的service，访问者与改Service没有关联，当访问者退出了，Service仍然运行。

2）通过Context的bindService（）方法启动service，用该方法启动service，访问者与Service绑定在一起，访问者一旦退出，service也就终止。

下面程序使用activity作为service的访问者，界面中有两个按钮，布局文件很简单，这里就不给出，一个按钮用于启动service，一个按钮用于关闭service

代码如下MainActivity：

<span style="font-family:FangSong_GB2312;font-size:18px;">public class MainActivity extends Activity implements OnClickListener{

	private Button start_service;
	private Button stop_service;
	private TextView text;
	private Intent intent;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        initView();
    }
	private void initView() {
		text = (TextView) findViewById(R.id.text);
		start_service = (Button) findViewById(R.id.start_service);
		stop_service = (Button) findViewById(R.id.stop_service);
		start_service.setOnClickListener(this);
		stop_service.setOnClickListener(this);
		//创建启动service的Intent
		intent = new Intent(MainActivity.this, MyService.class);
	}
	@Override
	public void onClick(View v) {
		switch(v.getId()){
		case R.id.start_service:
			//启动service
			startService(intent);
			text.setText("start_service");
			break;
		case R.id.stop_service:
			//停止service
			stopService(intent);
			text.setText("stop_service");
			break;
		}
	}
}</span>

activity的界面展示如下：

点击“开启SERVER”按钮，控制台输出的log如下：

再次点击“开启SERVER”按钮，控制台会打印启动"Service调用onStartCommand"；

点击“停止SERVICE”按钮，控制台会打印“销毁Service调用onDestroy()”。

这里就不截图了，读者可以自己运行上面代码

2、绑定本地的Service并与之通信

在现实应用中，我们经常需要在Service执行一些操作，并在activity中获取操作的返回值，也就是要求能与Service进行通信。

我们前面写的程序通过startService（）和stopService（）启动、关闭Service时，Service和访问者之间基本不存在太多的关联，因此Service和访问者之间也就无法进行通信和数据交换。

如果我们需要访问者和Service之间能进行通信，则可以使用bindService（）和unbindService（）方法启动和关闭服务。

bindService方法：bindService(Intent service, ServiceConnection conn, int flags)，该方法有三个参数，下面对这三个参数逐一介绍：

1）service：该参数通过Intent指向要启动的Service。

2）conn：该参数是一个ServiceConnection对象，该对象用于监听访问者与Service之间的连接情况。当连接成功是会回调该对象的onServiceConnected（ComponentName name， IBinder service）方法，其中service就是Service类OnBind的返回值；当连接断开时将会回调该对象的onServiceDiscinnected（ComponentName name）方法。

3）flags：指定绑定时是否自创建Service（如果Service还未创建）。0为不创建、BIND_AUTO_CREATE为自创建。

注意上面第二个参数对象的onServiceConnected方法有个IBinder对象，该对象即可实现与绑定的Server进行通讯。

在实际开发中，我们通常会继承Binder（IBinder的实现类）来实现自己的IBinder对象，下面我们来看一个实例：

<span style="font-family:FangSong_GB2312;font-size:18px;">public class BindService extends Service{

	private int count;
	private boolean quit;
	private MyBinder binder = new MyBinder();
	public class MyBinder extends Binder{
		public int getCount(){
			//获取Service中的count
			return count;
		}
	}
	//必须实现的方法，返回IBinder对象
	@Override
	public IBinder onBind(Intent intent) {
		
		return binder;
	}
	@Override
	public void onCreate() {
		Log.i("BindService", "onCreate");
		super.onCreate();
		count = 0;
		quit = false;
		//启动一个线程，动态更新count的值
		new Thread(){
			@Override
			public void run(){
				while(!quit){
					try {
						Thread.sleep(1000);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
					count++;
					//Log.i("BindService", count+"-------");
				}
			}
		}.start();
	}
	
	@Override
	public boolean onUnbind(Intent intent) {
		
		return super.onUnbind(intent);
	}
	
	@Override
	public void onDestroy() {
		this.quit = true;
		super.onDestroy();
	}
}</span>

上面的Service类中我们必须实现onBind方法返回一颗可以访问Service的count值得IBinder对象，该对象会被Service返回给调用者。在oncreate方法中，我们创建另一个线程，用时更新count的值。值得注意的事，由于server也是运行在主线程的，所以不能做耗时的操作，如果需要执行耗时的操作，需要创建子线程开完成。

下面我们来看一下通过Activity绑定Service，具体代码如下：

<span style="font-family:FangSong_GB2312;font-size:18px;">public class SeconActivity extends Activity implements View.OnClickListener{
	private TextView text;
	private Button bind;
	private Button unbind;
	private Intent intent;
	private boolean quit = false;
	private BindService.MyBinder binder;
	private Handler hander = new Handler(){
		@Override
		public void handleMessage(Message msg) {
			//收到消息后更新UI（关于Handler，后面的博客会具体讲解）
			text.setText(msg.arg1+"");
		}
		
	};
	private ServiceConnection conn = new ServiceConnection() {
		//访问者与Service连接成功时将回调此方法，得到IBinder对象来与Service进行通信
		@Override
		public void onServiceConnected(ComponentName name, IBinder service) {
			Log.i("Activity", "---onServiceConnected----");
			quit = true;
			binder = (MyBinder) service;
			//拿到binder后，启动一个新线程，来每个一秒从Service取出count的值
			new Thread(action).start();
			
		}
		//访问者与Service断开连接将回调此方法
		@Override
		public void onServiceDisconnected(ComponentName name) {
			quit = false;
			Log.i("Activity", "---onServiceDisconnected----");
		}
		
		
	};
	private Runnable action = new Runnable() {
		@Override
		public void run() {
			while(quit){
				try {
					Thread.sleep(1000);
					if(binder != null){
						//取到count值后，向主线程发送一个消息，让主线程来更新UI
						Message message = new Message();
						message.arg1 = binder.getCount();
						hander.sendMessage(message);
					}
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
				
			}
		}
	};
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_two);
        initView();
    }
	private void initView() {
		intent = new Intent();
		intent.setAction("com.example.MY_SERVER");
		bind = (Button) findViewById(R.id.bind);
		unbind = (Button) findViewById(R.id.unbind);
		text = (TextView) findViewById(R.id.text);
		bind.setOnClickListener(this);
		unbind.setOnClickListener(this);
	}
	@Override
	public void onClick(View v) {
		switch (v.getId()) {
		case R.id.bind:
			//绑定Service
			if (!bindService(intent, conn, Service.BIND_AUTO_CREATE)) {
	               Log.e("bindService", "Could not bind to Bluetooth AVRCP CT Service");
	            }
	            else
	            {
	                Log.d("bindService","bind successfully"+binder);
	            }
			//bindService(intent, conn, Service.BIND_AUTO_CREATE);
			break;
			
		case R.id.unbind:
			text.setText("取消绑定");
			unbindService(conn);
			break;

		default:
			break;
		}
	}
}</span>

代码中有详细的解释，大家可以研读一下。代码主要做的事情就是通过Activity绑定一个Service，然后通过得到的Binder来访问Service中的资源。

对于Service的onBind()方法所返回的IBinder对象来讲，他可以被当成该Service组件遂返回的回调对象，Service允许客户端用户通过IBinder对象来访问内部的数据，这样就可以实现客户端与Service之间通信。

3.跨进程调用Service

Android中，各应用程序都运行在自己的进程中，进程之间一般无法直接进行数据交换的，我们上面是现在的代码是指Activity和Service在同一个进程，这样就可以方便的通信，可如果不在一个进程，那么要进行通信就不是那么容易了。

android跨进程通信的方式很多，比如Bundle、文件共享、AIDL、Messenger、ContentProvider、Socket以及Broadcast方式。其中AIDL和Messenger用的是比较多的，他们都是基于binder实现的，具体细节这里就不多讲了，我以后会专门出类似的博客，请关注。

由于AIDL比较复杂，这里我选用Messenger来实现跨进程Server通信，Messenger实际是对AIDL的一次封装。

首先我们看一下服务端，我们创建一个Service来处理客户端请求，并且收到用户请求后向用户返回一条消息，具体代码如下：

<span style="font-family:FangSong_GB2312;font-size:18px;">public class MessengerService extends Service{

	private Handler MessengerHandler = new Handler(){

		@Override
		public void handleMessage(Message msg) {
			switch (msg.what) {
			case 1:
				Log.i("MessengerService", msg.getData().getString("msg"));
				//拿到客户端传过来的Messenger对象
				Messenger client = msg.replyTo;
				//封装要反悔给客户端的消息
				Message replyMessage = Message.obtain(null, 2);
				Bundle bundle = new Bundle();
				bundle.putString("reply", "恩，收到您的消息！");
				replyMessage.setData(bundle);
				try {
					//利用客户端的Messenger为客户端发送消息
					client.send(replyMessage);
				} catch (RemoteException e) {
					e.printStackTrace();
				}
				break;

			default:
				super.handleMessage(msg);
			}
		}
	};
	//创建服务端Messenger
	private final Messenger mMessenger = new Messenger(MessengerHandler);
	@Override
	public IBinder onBind(Intent intent) {
		Log.i("Service", "onBind");
		//向客户端返回Ibinder对象，客户端利用该对象访问服务端
		return mMessenger.getBinder();
	}
	@Override
	public void onCreate() {
		Log.i("Service", "onCreate");
		super.onCreate();
	}
}</span>

然后注册Service，让其在单独的进程中运行

<span style="font-family:FangSong_GB2312;font-size:18px;"><span style="white-space:pre">	</span><service android:name=".Messager.MessengerService"
             android:process=":remote">  
            <intent-filter>
                <action android:name="com.example.MESSENGER_SERVER"/>  
            </intent-filter>  
        </service> </span>

接下来就看客户端了，客户端实现也比较简单，首先绑定远程进程的Service，绑定成功后，根据Service返回的IBinder对象创建Messenger对象，并使用此对象发送消息，为了能收到Service端返回的消息，客户端创建了一个资深的Messenger发送给Service端，Service端就可以通过客户端的Messenger想客户端发送消息了，具体代码如下：

<span style="font-family:FangSong_GB2312;font-size:18px;">public class MessengerActivity extends Activity{

	private Messenger mService;
	private Button bind;
	private TextView text;
	private Intent intent;
	private ServiceConnection conn = new ServiceConnection(){
		@Override
		public void onServiceConnected(ComponentName name, IBinder service) {
			//根据得到的IBinder对象创建Messenger
			mService = new Messenger(service);
			Message msg = Message.obtain(null, 1);
			Bundle bundle = new Bundle();
			bundle.putString("msg", "您好，Service");
			msg.setData(bundle);
			msg.replyTo = mGetMessenger;
			try {
				mService.send(msg);
			} catch (RemoteException e) {
				e.printStackTrace();
			}
		}
		@Override
		public void onServiceDisconnected(ComponentName name) {
			
		}	
	};
	
	//为了收到Service的回复，客户端需要创建一个接收消息的Messenger和Handler
	private Handler MessengerHander = new Handler(){
		@Override
		public void handleMessage(Message msg) {
			switch (msg.what) {
			case 2:
				Log.i("MessengerActivity", msg.getData().getString("reply"));
				text.setText(msg.getData().getString("reply"));
				break;
			default:
				super.handleMessage(msg);
			}
		}
	};
	private Messenger mGetMessenger = new Messenger(MessengerHander);
	@Override
	protected void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);
		setContentView(R.layout.activity_messenger);
		init();
	}
	private void init() {
		intent = new Intent(MessengerActivity.this, MessengerService.class);
		bind = (Button) findViewById(R.id.bind);
		text = (TextView) findViewById(R.id.text);
		bind.setOnClickListener(new View.OnClickListener() {
			@Override
			public void onClick(View v) {
				
				//bindService(intent, conn, Context.BIND_AUTO_CREATE);
				if (!bindService(intent, conn, Context.BIND_AUTO_CREATE)) {
		               Log.e("bindService", "Could not bind to Bluetooth AVRCP CT Service");
		            }
		            else
		            {
		                Log.d("bindService","bind successfully");
		            }
			}
		});
	}
	@Override
	protected void onDestroy(){
		unbindService(conn);
		super.onDestroy();
	}
}
</span>

代码看起来比较长，可是很简单，相信读者都能读懂。我们运行程序后，看一下log，很闲人客户端向Service发送了一条消息，也收到了Service返回的消息，这说明我们跨进程和Service通信实现成功。

到这里，android的四大组件之一Service就介绍完毕，谢谢大家的阅读！