Android Service组件在进程内绑定(bindService)过程

最新推荐文章于 2022-07-11 19:45:28 发布
原创 最新推荐文章于 2022-07-11 19:45:28 发布 · 2.3k 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文详细解析了Android中Service组件在进程内的绑定(bindService)过程，包括从应用程序主线程向ActivityManagerService发送请求，ServiceRecord和connections的初始化，创建并调用Service的onCreate方法，以及获取Service的Binder对象并进行PUBLISH_SERVICE_TRANSACTION的过程。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

      本文参考Android应用程序绑定服务（bindService）的过程源代码分析http://blog.youkuaiyun.com/luoshengyang/article/details/6745181和《Android系统源代码情景分析》，作者罗升阳

一、Android Service组件在进程内绑定(bindService)过程

      0、总图流程图如下：



       1、Counter和CounterService所在应用程序主线程向ActivityManagerService进程发送BIND_SERVICE_TARNSATION

       如下图：



      如图：第一步

      ~/Android/frameworks/base/core/java/android/app

      ----ActivityManagerNative.java

class ActivityManagerProxy implements IActivityManager
{
	......

	public int bindService(IApplicationThread caller, IBinder token,
			Intent service, String resolvedType, IServiceConnection connection,
			int flags) throws RemoteException {
		Parcel data = Parcel.obtain();
		Parcel reply = Parcel.obtain();
		data.writeInterfaceToken(IActivityManager.descriptor);
		data.writeStrongBinder(caller != null ? caller.asBinder() : null);
		data.writeStrongBinder(token);
		service.writeToParcel(data, 0);
		data.writeString(resolvedType);
		data.writeStrongBinder(connection.asBinder());
		data.writeInt(flags);
		mRemote.transact(BIND_SERVICE_TRANSACTION, data, reply, 0);
		reply.readException();
		int res = reply.readInt();
		data.recycle();
		reply.recycle();
		return res;
	}

	......
}

       其中connection.asBinder()为InnerConnection对象。还有intent，主要关注这两个参数。



      如图：第二步，省略binder_transaction传输过程，因为上面已经分析过了。


       如图：第三步

      ~/Android/frameworks/base/core/java/android/app

      ----ActivityManagerNative.java

public abstract class ActivityManagerNative extends Binder implements IActivityManager
{
    ......
    public boolean onTransact(int code, Parcel data, Parcel reply, int flags)
            throws RemoteException {
        switch (code) {
        case BIND_SERVICE_TRANSACTION: {
            data.enforceInterface(IActivityManager.descriptor);
            IBinder b = data.readStrongBinder();
            IApplicationThread app = ApplicationThreadNative.asInterface(b);
            IBinder token = data.readStrongBinder();
            Intent service = Intent.CREATOR.createFromParcel(data);
            String resolvedType = data.readString();
            b = data.readStrongBinder();
            int fl = data.readInt();
            IServiceConnection conn = IServiceConnection.Stub.asInterface(b);
            int res = bindService(app, token, service, resolvedType, conn, fl); 
            reply.writeNoException();
            reply.writeInt(res);
            return true;
        }   
    .......
}
       其中conn为上图中IServiceConnection.Stub.Proxy对象，引用了 InnerConnection对象。 还有intent，主要关注这两个参数。

       如图：第四步

       ～/Android/frameworks/base/services/java/com/android/server/am

       ----ActivityManagerService.java

public final class ActivityManagerService extends ActivityManagerNative
		implements Watchdog.Monitor, BatteryStatsImpl.BatteryCallback {
	......

	public int bindService(IApplicationThread caller, IBinder token,
			Intent service, String resolvedType,
			IServiceConnection connection, int flags) {
		......

		synchronized(this) {
			......
			final ProcessRecord callerApp = getRecordForAppLocked(caller);
			......

			ActivityRecord activity = null;
			if (token != null) {
				int aindex = mMainStack.indexOfTokenLocked(token);
				......
				activity = (ActivityRecord)mMainStack.mHistory.get(aindex);
			}
			
			......

			ServiceLookupResult res =
				retrieveServiceLocked(service, resolvedType,
				Binder.getCallingPid(), Binder.getCallingUid());
			
			......

			ServiceRecord s = res.record;

			final long origId = Binder.clearCallingIdentity();

			......

			AppBindRecord b = s.retrieveAppBindingLocked(service, callerApp);
			ConnectionRecord c = new ConnectionRecord(b, activity,
				connection, flags, clientLabel, clientIntent);

			IBinder binder = connection.asBinder();
			ArrayList<ConnectionRecord> clist = s.connections.get(binder);

			if (clist == null) {
				clist = new ArrayList<ConnectionRecord>();
				s.connections.put(binder, clist);
			}
			clist.add(c);
			.......

			if ((flags&Context.BIND_AUTO_CREATE) != 0) {
				......
				if (!bringUpServiceLocked(s, service.getFlags(), false)) {
					return 0;
				}
			}

			......
		}

		return 1;
	}			

	......
}

       主要做了以下几件事：

     （1）创建ServiceRecord对象，并初始化它bindings变量，这个变量主要用来描述传递过来的intent。

     （2）初始化它connections变量，这个变量主要用来描述传递过来的IServiceConnection.Stub.Proxy对象。

     （3）ActivityManagerService进程向Counter和CounterService子线程发送SCHEDULE_CREATE_SERVICE_TRANSACTION。


       2、ActivityManagerService进程向Counter和CounterService子线程发送SCHEDULE_CREATE_SERVICE_TRANSACTION

       如总图中的第2步，过程可参考Android Activity组件的启动过程http://blog.youkuaiyun.com/jltxgcy/article/details/35984557中的第2步。

 

       3、在Counter和CounterService主线程创建CounterService，并调用了它的onCreate方法

       需要说明的一点是：

mServices.put(data.token, service);
       把刚创建的CounterService加入到mServices中了。
 

       4、返回到ActivityManagerService进程

   

       5、ActivityManagerService进程向Counter和CounterService子线程发送SCHEDULE_BIND_SERVICE_TRANSACTION



        如图：第一步

        ~/Android/frameworks/base/core/java/android/app

        ----ApplicationThreadNative.java，ApplicationThreadProxy类

class ApplicationThreadProxy implements IApplicationThread {
	......
	
	public final void scheduleBindService(IBinder token, Intent intent, boolean rebind)
			throws RemoteException {
		Parcel data = Parcel.obtain();
		data.writeInterfaceToken(IApplicationThread.descriptor);
		data.writeStrongBinder(token);
		intent.writeToParcel(data, 0);
		data.writeInt(rebind ? 1 : 0);
		mRemote.transact(SCHEDULE_BIND_SERVICE_TRANSACTION, data, null,
			IBinder.FLAG_ONEWAY);
		data.recycle();
	}

	......
}

        其中token为ServiceRecord对象，如下图，还有intent，主要关注这两个参数。

 

                                                                                             图1

 
       如图：第二步，省略binder_transaction传输过程，因为上面已经分析过了。


       如图：第三步
       ~/Android/frameworks/base/core/java/android/app

       ----ApplicationThreadNative.java

public abstract class ApplicationThreadNative extends Binder
        implements IApplicationThread {
    ........
    public boolean onTransact(int code, Parcel data, Parcel reply, int flags)
            throws RemoteException {
        switch (code) {
        case SCHEDULE_BIND_SERVICE_TRANSACTION: {
            data.enforceInterface(IApplicationThread.descriptor);
            IBinder token = data.readStrongBinder();
            Intent intent = Intent.CREATOR.createFromParcel(data);
            boolean rebind = data.readInt() != 0;
            scheduleBindService(token, intent, rebind);
            return true;
        } 
   .......
}
      其中token为上图中的BinderProxy对象，引用了ServiceRecord。 还有intent，主要关注这两个参数。


      如图：第四步

      ~/Android/frameworks/base/core/java/android/app

      ----ActivityThread.java

public final class ActivityThread {
	......

	public final void scheduleBindService(IBinder token, Intent intent,
			boolean rebind) {
		BindServiceData s = new BindServiceData();
		s.token = token;
		s.intent = intent;
		s.rebind = rebind;

		queueOrSendMessage(H.BIND_SERVICE, s);
	}

	......
}

      6、在Counter和CounterService主线程绑定CounterService，并调用了它的onBind方法     

      主要做了以下几件事：

    （1）获取了刚刚创建的service，并且调用onBind获取了CounterBinder对象，如下图：

                                                                                      图2 

  

   （2）Counter和CounterService主线程向ServiceManager进程发送PUBLISH_SERVICE_TRANSACTION

      代码如下：

      ~/Android/frameworks/base/core/java/android/app

      ----ActivityThread.java

public final class ActivityThread {
	......

	private final void handleBindService(BindServiceData data) {
		Service s = mServices.get(data.token);
		if (s != null) {
			try {
				data.intent.setExtrasClassLoader(s.getClassLoader());
				try {
					if (!data.rebind) {
						IBinder binder = s.onBind(data.intent);
						ActivityManagerNative.getDefault().publishService(
							data.token, data.intent, binder);
					} else {
						......
					}
					......
				} catch (RemoteException ex) {
				}
			} catch (Exception e) {
				......
			}
		}
	}

	......
}
public class CounterService extends Service implements ICounterService {
	......

	private final IBinder binder = new CounterBinder();  

	public class CounterBinder extends Binder {  
		public CounterService getService() {  
			return CounterService.this;  
		}  
	}  

	@Override  
	public IBinder onBind(Intent intent) {  
		return binder;  
	}  

	......
}

       7、Counter和CounterService主线程向ServiceManager进程发送PUBLISH_SERVICE_TRANSACTION

      如图：第一步

      ~/Android/frameworks/base/core/java/android/app

      ----ActivityManagerNative.java

class ActivityManagerProxy implements IActivityManager
{
	......

	public void publishService(IBinder token,
            Intent intent, IBinder service) throws RemoteException {
        Parcel data = Parcel.obtain();
        Parcel reply = Parcel.obtain();
        data.writeInterfaceToken(IActivityManager.descriptor);
        data.writeStrongBinder(token);
        intent.writeToParcel(data, 0);
        data.writeStrongBinder(service);
        mRemote.transact(PUBLISH_SERVICE_TRANSACTION, data, reply, 0);
        reply.readException();
        data.recycle();
        reply.recycle();
    } 

	......
}

       其中service为刚刚创建的 CounterBinder对象，如图2。其中token为其中token为上图中的BinderProxy对象，引用了ServiceRecord对象。如图1。


       如图：第二步，省略binder_transaction传输过程，因为上面已经分析过了。


       如图：第三步

      ~/Android/frameworks/base/core/java/android/app

      ----ActivityManagerNative.java

public abstract class ActivityManagerNative extends Binder implements IActivityManager
{
    ......
    public boolean onTransact(int code, Parcel data, Parcel reply, int flags)
            throws RemoteException {
        switch (code) {
        case PUBLISH_SERVICE_TRANSACTION: {
            data.enforceInterface(IActivityManager.descriptor);
            IBinder token = data.readStrongBinder();
            Intent intent = Intent.CREATOR.createFromParcel(data);
            IBinder service = data.readStrongBinder();
            publishService(token, intent, service);
            reply.writeNoException();
            return true;
        }  
    .......
}
       其中service为BinderProxy对象，引用了CounterBinder对象，如图2。token为 ServiceRecord对象，如图1。


       如图：第四步

       ～/Android/frameworks/base/services/java/com/android/server/am

       ----ActivityManagerService.java

public final class ActivityManagerService extends ActivityManagerNative
		implements Watchdog.Monitor, BatteryStatsImpl.BatteryCallback {
	......

	public void publishService(IBinder token, Intent intent, IBinder service) {
		......
		synchronized(this) {
			......
			ServiceRecord r = (ServiceRecord)token;
			......

			......
			if (r != null) {
				Intent.FilterComparison filter
					= new Intent.FilterComparison(intent);
				IntentBindRecord b = r.bindings.get(filter);
				if (b != null && !b.received) {
					b.binder = service;
					b.requested = true;
					b.received = true;
					if (r.connections.size() > 0) {
						Iterator<ArrayList<ConnectionRecord>> it
							= r.connections.values().iterator();
						while (it.hasNext()) {
							ArrayList<ConnectionRecord> clist = it.next();
							for (int i=0; i<clist.size(); i++) {
								ConnectionRecord c = clist.get(i);
								......
								try {
									c.conn.connected(r.name, service);
								} catch (Exception e) {
									......
								}
							}
						}
					}
				}

				......
			}
		}
	}

	......
}

        主要是获取ServiceRecord里面的ConnectionRecord对象，它的成员变量conn为 IServiceConnection.Stub.Proxy对象，引用了 InnerConnection对象。调用connected函数。


      8、ActivityManagerS ervice进程向Counter和CounterService主线程发送connected命令



      相关代码，请参考http://grepcode.com/file_/repository.grepcode.com/java/ext/com.google.android/android/2.0_r1/android/app/IServiceConnection.java/?v=source
      经过一系列的传递，最终执行：

      ～/Android/frameworks/base/core/java/android/app

      ----LoadedApk.java

final class LoadedApk {
	......

	static final class ServiceDispatcher {
		......

		private static class InnerConnection extends IServiceConnection.Stub {
			......

			public void connected(ComponentName name, IBinder service) throws RemoteException {
				LoadedApk.ServiceDispatcher sd = mDispatcher.get();
				if (sd != null) {
					sd.connected(name, service);
				}
			}
			......
		}

		......
	}

	......
}

       由于执行了进程间通信，此时service为CounterBinder对象，如图2。所以可以向下转型。 

public class MainActivity extends Activity implements OnClickListener {  
	......

	private ServiceConnection serviceConnection = new ServiceConnection() {  
		public void onServiceConnected(ComponentName className, IBinder service) {  
			counterService = ((CounterService.CounterBinder)service).getService();  

			Log.i(LOG_TAG, "Counter Service Connected");  
		}  
		......
	};  
	
	......
}

Android Service 使用bindservice和startservice 区别
wulong756273的博客
01-07 1529
Android四大组件之一。Service并不与用户产生UI交互。其他的应用组件可以启动Service，即便用户切换了其他应用，启动的Service仍可在后台运行。一个组件可以与Service绑定并与之交互，甚至是跨进程通信(IPC)。基础使用startservice启动服务后，程序退出stopservice,服务依旧存在。而bindservice启动服务后程序退出unbindservice，服务就会销毁。而同时调用两种方法启动同一个方法，只会启动一个服务，但是其生命周期。
Android Service启动（二） bindService()启动过程以及原理解析
生死看淡_不服就干的博客
03-13 4492
本篇文章主要讲解bindService()绑定Service的过程。（android的版本依旧是26） 通过bindService()绑定一个Service时，最终都是调用的ContextWrapper的bindService()方法，我们来看下这个方法 @Override public boolean bindService(Intent service, ServiceConnectio...
Android中Service的绑定过程时序图
handy周
07-06 795
Android中Service的绑定过程时序图 参考： 《Android源代码情景分析》
Android面试题：bindService获取代理是同步还是异步
weixin_33682790的博客
01-16 369
Android中bindService是一个异步的过程，什么意思呢？使用bindService无非是想获得一个Binder服务的Proxy，但这个代理获取到的时机并非由bindService发起端控制，而是由Service端来控制，也就是说bindService之后，APP端并不会立刻获得Proxy，而是要等待Service通知APP端，具体流程可简化如下： APP端先通过bindService...
Android Binder框架实现之bindService详解
IT先森
09-10 4378
关于bindService我们将从两个知识点出发，第一就是从进程之间的交互，第二就是匿名Binder之间的传递角度来探讨！当然小伙们也可以抛开上面的匿名/实名Binder等相关知识点，单纯当成是bindService的源码分析也不为过，这个就看小伙们的出发点了，是分析匿名Binder的应用还是bindService的流程就看小伙们各取所需了。
Android Service两种启动方式详解（总结版）
热门推荐
imxiangzi的专栏
07-25 11万+
Service生命周期.png 第一种方式：通过StartService启动Service 通过startService启动后，service会一直无限期运行下去，只有外部调用了stopService()或stopSelf()方法时，该Service才会停止运行并销毁。 要创建一个这样的Service，你需要让该类继承Service类，然后重写以下方法： onCreate()
Android进程间通信之bindService篇
Misdirection_XG的博客
07-11 1526
在Android中binder是一种非常重要的进程间通信方式。基于binder实现的进程间通信形态非常多，其中Android的四大组件之一Service，可以用来和binder机制结合，来实现跨进程通信。这种方式就是bindservice，在bindservice这个场景里面，Service作为一个服务端，给调用端也就是client端提供接口。这种方式一般用于Java端和Java端的跨进程通信。下面来详细讲解一下这种实现方式。首先，我们需要创建一个service，这个service是用来给client端提供
Android Service绑定过程完整分析
09-01
在Android系统中，Service是一种用于执行长时间运行操作的组件，它可以独立于用户界面在后台运行。Service绑定过程是Android应用程序与Service交互的重要方式之一，它允许客户端应用与Service建立连接，进而通过...
Android四大组件系列6 bindService流程
liuwg1226的专栏
12-22 1914
一　概述 bindService 和 startService 过程差不多, 差别主要是在创建 Service 实例后一个是执行 bind 操作, 一个是执行 start 操作. 涉及代码如下： frameworks/base/services/core/java/com/android/server/am/ActivityManagerService.java frameworks/base/services/core/java/com/android/server/am/ActiveServices.j
Android 进程间通信：Service与bindService的运用
本文将介绍如何利用Service在Android中实现进程间通信，重点是bindService方法的使用。 ### Service和IPC简介 在Android中，Service主要有两种类型：Started Service和Bound Service。Started Service是由其他组件...
Android应用程序绑定服务（bindService）的过程源代码分析
oraclestudy
09-07 455
Android应用程序组件Service与Activity一样，既可以在新的进程中启动，也可以在应用程序进程内部启动；前面我们已经分析了在新的进程中启动Service的过程，本文将要介绍在应用程序内部绑定Service的过程，这是一种在应用程序进程内部启动Service的方法。 在前面一篇文章Android进程间通信（IPC）机制Binder简要介绍和学习计划中，我们就曾经提到，在A...
Android开发时，我们的应用绑定第三方aidl提供的服务进程，隔一段时间绑定的这个服务就会断开。谁可以帮我分析下。
weiqingsong150的博客
01-28 852
虽然怀疑绑定的这个第三方服务被系统杀死了，但是没有直接依据。也有可能是其他原因。麻烦大神教我分析一下，帮我找出这个服务断开的真实原因。
android service与子线程之浅谈
coolke wang的专栏
05-28 3630
转载自:http://www.360doc.com/content/14/0319/20/12928831_361969514.shtml 最近在做一个android的项目，有一个操作是首先将接收的数据处理分析，然后将处理过的数据存储到数据库中。这将是一个十分耗时的工作。我直接将这一操作写在了UI主线程中。结果log中提示不要把耗时的工作在主线程中完成。于是在网上查阅了一下，发现网上有两种说
主线程阻塞导致子线程里bindService或者handler的handleMessage被阻塞
hanxx3380的博客
02-28 2313
开发中通过FeatrueTask来同步拿到异步执行的结果。但是FeatrueTask的get方法会阻塞线程。如果是在主线程调用get方法的话，就会阻塞主线程，导致主线程的handler的handleMessage被阻塞。 案例一： 通过FeatrueTask的get方法去等待AbsMediaEngine的init方法的异步回调结果。AbsMediaEngine的init里调用的SEServic...
Android 绑定服务 bindService
Yp_Nothing的博客
06-06 3万+
绑定服务是客户端--服务器接口中的服务器。组件（如activity）和服务进行绑定后，可以发送请求、接收响应、执行进程间通信（IPC）。不会无限期在后台运行。要提供服务绑定，必须实现onBind()回调方法，该方法返回的IBinder对象定义了客户端用来与服务进行交互的编程接口。客户端可以通过调用bindService()绑定到服务。调用时，必须提供ServiceConnection的实现，后者会...
Android中bindService的细节之四：bindService时，你所忽略的代码流程细节
Abracadabra的专栏
01-30 4138
Android中bindService的细节之四：bindService时，你所忽略的代码流程细节0. 说明事先声明：本文所讲的内容，即使被你忽略了，也不影响对bindService()代码流程的理解。**场景：**App A绑定App B的MyService时，App B进程之前没有启动，即需要创建App B进程。本文要讲的内容是，从App B的ActivityThread的main()执行开始到
在android framework中添加自定义系统服务
On The Way
01-11 8921
添加系统服务需要添加aidl,service,manager文件,需要修改SystemServer,Context,ContextImpl 下面举例进行说明,主要添加一个服务,用于获取系统时间和版本号 1.在frameworks/base/core/java/android/app/下添加aidl文件 frameworks/base/core/java/android/a
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值