（五）Binder分析·下篇

最新推荐文章于 2023-02-08 01:05:19 发布
最新推荐文章于 2023-02-08 01:05:19 发布
阅读量194 收藏
点赞数
分类专栏： Android framework学习笔记 文章标签： binder android java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_33427070/article/details/128671647
版权

（五）Binder使用·下篇

通过一个BinderDemo项目，学习binder在java层的使用。

文章目录

一、获取Service Manager远程接口

Service Manager的Java远程接口是一个ServiceManagerProxy对象的IServiceManager接口，ServiceManagerProxy类实现了IServiceManager接口，IServiceManager提供了getService和addService两个成员函数来管理系统中的Service。

//frameworks/base/core/java/android/os/ServiceManager.java
public final class ServiceManager {  
    ......  
    private static IServiceManager sServiceManager;  
    ......  
    private static IServiceManager getIServiceManager() {  
        if (sServiceManager != null) {  
            return sServiceManager;  
        }  
  
        // Find the service manager  
        //相当于 new ServiceManagerProxy(new BinderProxy);
        sServiceManager = ServiceManagerNative.asInterface(BinderInternal.getContextObject());  
        return sServiceManager;  
    }  
    ......  
}

1.1 BinderInternal.getContextObject()

//frameworks/base/core/java/com/android/internal/os/BinderInternal.java
// 88
public static final native IBinder getContextObject();



//frameworks/base/core/jni/android_util_Binder.cpp
// 899
static jobject android_os_BinderInternal_getContextObject(JNIEnv* env, jobject clazz)
{
	/* 打开 binder驱动（ ProcessState是单例的） ， 创建 BpBinder(handle) 对象， 并返回 */
	sp<IBinder> b = ProcessState::self()->getContextObject(NULL);
	return javaObjectForIBinder(env, b);
} 


//frameworks/base/core/jni/android_util_Binder.cpp
// 547
jobject javaObjectForIBinder(JNIEnv* env, const sp<IBinder>& val)
// 563 从 BpBinder中查找 BinderProxy对象， 第一次为 null
jobject object = (jobject)val->findObject(&gBinderProxyOffsets);
// 576 创建 BinderProxy对象
object = env->NewObject(gBinderProxyOffsets.mClass, gBinderProxyOffsets.mConstructor);
// 580 BinderProxy.mObject成员变量记录 BpBinder对象
env->SetLongField(object, gBinderProxyOffsets.mObject, (jlong)val.get());
// 587 将 BinderProxy对象信息添加到 BpBinder的成员变量 mObjects中
val->attachObject(&gBinderProxyOffsets, refObject,
jnienv_to_javavm(env), proxy_cleanup);
// 593 BinderProxy.mOrgue成员变量记录死亡通知对象
env->SetLongField(object, gBinderProxyOffsets.mOrgue, reinterpret_cast<jlong>(drl.get()));

1.2 ServiceManagerNative.asInterface

//frameworks/base/core/java/android/os/ServiceManagerNative.java
// 这里的参数obj是一个BinderProxy对象，它的queryLocalInterface函数返回null。因此，最终以这个
//BinderProxy对象为参数创建一个ServiceManagerProxy对象。
static public IServiceManager asInterface(IBinder obj)
	// 38 因为 obj为 BinderProxy， 默认返回 null
	IServiceManager in =
	(IServiceManager)obj.queryLocalInterface(descriptor);
	// 44
	return new ServiceManagerProxy(obj);

1.3 ServiceManagerProxy

class ServiceManagerProxy implements IServiceManager {
    ...
    public IBinder getService(String name) throws RemoteException {
        Parcel data = Parcel.obtain();
        Parcel reply = Parcel.obtain();
        data.writeInterfaceToken(IServiceManager.descriptor);
        data.writeString(name);
        mRemote.transact(GET_SERVICE_TRANSACTION, data, reply, 0);
        IBinder binder = reply.readStrongBinder();
        reply.recycle();
        data.recycle();
        return binder;
    }
    ...
    public void addService(String name, IBinder service, boolean allowIsolated, int dumpPriority)
            throws RemoteException {
        Parcel data = Parcel.obtain();
        Parcel reply = Parcel.obtain();
        data.writeInterfaceToken(IServiceManager.descriptor);
        data.writeString(name);
        data.writeStrongBinder(service);
        data.writeInt(allowIsolated ? 1 : 0);
        data.writeInt(dumpPriority);
        mRemote.transact(ADD_SERVICE_TRANSACTION, data, reply, 0);
        reply.recycle();
        data.recycle();
    }
}
...

在Java层，就有拥有了一个Service Manager远程接口ServiceManagerProxy。

二、AIDL接口定义(一个例子)

服务接口定义在frameworks/base/core/java/android/os/IBinderDemo.aidl文件中：

package android.os;  
  
interface IBinderDemoService  
{  
    void setText(int val);  
    int getText();  
}

aidl文件，编译后会生成一个IBinderDemo.java文件：

/* 
 * This file is auto-generated.  DO NOT MODIFY. 
 * Original file: frameworks/base/core/java/android/os/IHelloService.aidl 
 */  
package android.os;  
public interface IBinderDemoService  extends android.os.IInterface  
{  
    /** Local-side IPC implementation stub class. */  
    public static abstract class Stub extends android.os.Binder implements android.os.IBinderDemoService  
    {  
        private static final java.lang.String DESCRIPTOR = "android.os.IBinderDemoService  ";  
        /** Construct the stub at attach it to the interface. */  
        public Stub()  
        {  
            this.attachInterface(this, DESCRIPTOR);  
        }  
  
        /** 
        * Cast an IBinder object into an android.os.IHelloService interface, 
        * generating a proxy if needed. 
        */  
        public static android.os.IBinderDemoService  asInterface(android.os.IBinder obj)  
        {  
            if ((obj==null)) {  
                return null;  
            }  
            android.os.IInterface iin = (android.os.IInterface)obj.queryLocalInterface(DESCRIPTOR);  
            if (((iin!=null)&&(iin instanceof android.os.IBinderDemoService  ))) {  
                return ((android.os.IBinderDemoService  )iin);  
            }  
            return new android.os.IBinderDemoService.Stub.Proxy(obj);  
        }  
  
        public android.os.IBinder asBinder()  
        {  
            return this;  
        }  
  
        @Override   
        public boolean onTransact(int code, android.os.Parcel data, android.os.Parcel reply, int flags) throws android.os.RemoteException  
        {  
            switch (code)  
            {  
                case INTERFACE_TRANSACTION:  
                {  
                    reply.writeString(DESCRIPTOR);  
                    return true;  
                }  
                case TRANSACTION_setText:  
                {  
                    data.enforceInterface(DESCRIPTOR);  
                    int _arg0;  
                    _arg0 = data.readInt();  
                    this.setText(_arg0);  
                    reply.writeNoException();  
                    return true;  
                }  
                case TRANSACTION_getText:  
                {  
                    data.enforceInterface(DESCRIPTOR);  
                    int _result = this.getText();  
                    reply.writeNoException();  
                    reply.writeInt(_result);  
                    return true;  
                }  
            }  
            return super.onTransact(code, data, reply, flags);  
        }  
  
        private static class Proxy implements android.os.IBinderDemoService
        {  
            private android.os.IBinder mRemote;  
  
            Proxy(android.os.IBinder remote)  
            {  
                mRemote = remote;  
            }  
  
            public android.os.IBinder asBinder()  
            {  
                return mRemote;  
            }  
  
            public java.lang.String getInterfaceDescriptor()  
            {  
                return DESCRIPTOR;  
            }  
  
            public void setText(int val) throws android.os.RemoteException  
            {  
                android.os.Parcel _data = android.os.Parcel.obtain();  
                android.os.Parcel _reply = android.os.Parcel.obtain();  
                try {  
                    _data.writeInterfaceToken(DESCRIPTOR);  
                    _data.writeInt(val);  
                    mRemote.transact(Stub.TRANSACTION_setText, _data, _reply, 0);  
                    _reply.readException();  
                }  
                finally {  
                    _reply.recycle();  
                    _data.recycle();  
                }  
            }  
  
            public int getText() throws android.os.RemoteException  
            {  
                android.os.Parcel _data = android.os.Parcel.obtain();  
                android.os.Parcel _reply = android.os.Parcel.obtain();  
                int _result;  
                try {  
                    _data.writeInterfaceToken(DESCRIPTOR);  
                    mRemote.transact(Stub.TRANSACTION_getText, _data, _reply, 0);  
                    _reply.readException();  
                    _result = _reply.readInt();  
                }  
                finally {  
                    _reply.recycle();  
                    _data.recycle();  
                }  
                return _result;  
            }  
        }  
  
        static final int TRANSACTION_setText = (android.os.IBinder.FIRST_CALL_TRANSACTION + 0);  
        static final int TRANSACTION_getText = (android.os.IBinder.FIRST_CALL_TRANSACTION + 1);  
    }  
  
    public void setText(int val) throws android.os.RemoteException;  
    public int getText() throws android.os.RemoteException;  
}

三、addService注册服务

定义一个Service，frameworks/base/services/java/com/android/server目录下新增了一个BinderDemoService.java文件：

package com.android.server;  
  
import android.content.Context;  
import android.os.IBinderDemoService;  
import android.util.Slog;  
  
public class BinderDemoService extends IBinderDemoService.Stub {  
    private static final String TAG = "BinderDemoService ";  
  
    BinderDemoService() {  
        init_native();  
    }  
  
    public void setText(int val) {  
       setText_native(val);  
    }     
  
    public int getText() {  
        return getText_native();  
    }  
      
    private static native boolean init_native();  
    private static native void setText_native(int val);  
   	private static native int getText_native();  
}

定义Service完成之后，将BinderDemoService 注册到ServiceManager。

//frameworks\base\services\core\java\com\android\server\am\ActivityManagerService.java
public class ActivityManagerService extends ...{
 	public void setSystemProcess() {
            ...
        try {
			...
            ServiceManager.addService("binderdemo", new BinderDemoService ());
            ...
            }
            ...
}

public final class ServiceManager {  
    ......  
  
    private static IServiceManager sServiceManager;  
  
    ......  
  
    public static void addService(String name, IBinder service) {  
        try {  
            getIServiceManager().addService(name, service);  
        } catch (RemoteException e) {  
            Log.e(TAG, "error in addService", e);  
        }  
    }  
  
    ......  
  
}

getIServiceManager()在前面已经分析过了，下面继续分析addService函数调用流程：

class ServiceManagerProxy implements IServiceManager {  
    public ServiceManagerProxy(IBinder remote) {  
        mRemote = remote;  
    }  
  
    ......  
  
    public void addService(String name, IBinder service)  
        throws RemoteException {  
            Parcel data = Parcel.obtain();  
            Parcel reply = Parcel.obtain();  
            data.writeInterfaceToken(IServiceManager.descriptor);  
            data.writeString(name);  
            data.writeStrongBinder(service);  //此处 service == AMS
            mRemote.transact(ADD_SERVICE_TRANSACTION, data, reply, 0);  
            reply.recycle();  
            data.recycle();  
    }  
  
    ......  
  
    private IBinder mRemote;  
}

writeStrongBinder函数又是一个JNI方法，它定义在frameworks/base/core/jni/android_util_Binder.cpp文件中：


static void android_os_Parcel_writeStrongBinder(JNIEnv* env, jobject clazz, jobject object)  
{  
    Parcel* parcel = parcelForJavaObject(env, clazz);  
    if (parcel != NULL) {  
        const status_t err = parcel->writeStrongBinder(ibinderForJavaObject(env, object));  
        if (err != NO_ERROR) {  
            jniThrowException(env, "java/lang/OutOfMemoryError", NULL);  
        }  
    }  
}

这里的object参数是一个Java语言实现的Binder对象，在调用C++语言实现的Parcel::writeStrongBinder把这个对象写入到parcel对象时，首先通过ibinderForJavaObject函数把这个Java语言实现的Binder对象转换为C++语言实现的JavaBBinderHolder对象：

frameworks/base/core/jni/android_util_Binder.cpp
sp<IBinder> ibinderForJavaObject(JNIEnv* env, jobject obj)  
{  
    if (obj == NULL) return NULL;  
  
    if (env->IsInstanceOf(obj, gBinderOffsets.mClass)) {  
        JavaBBinderHolder* jbh = (JavaBBinderHolder*)  
            env->GetIntField(obj, gBinderOffsets.mObject);  
        return jbh != NULL ? jbh->get(env) : NULL;   // 返回 JavaBBinder对象
    }  
  
    if (env->IsInstanceOf(obj, gBinderProxyOffsets.mClass)) {  
        return (IBinder*)  
            env->GetIntField(obj, gBinderProxyOffsets.mObject);  
    }  
  
    LOGW("ibinderForJavaObject: %p is not a Binder object", obj);  
    return NULL;  
}

ServiceManagerProxy.addService这个函数中，还有一个比较重要的函数transact。 mRemote.transact(ADD_SERVICE_TRANSACTION, data, reply, 0)，mRemote成员变量实际上是一个BinderProxy对象，我们再来看看BinderProxy.transact函数的实现：

final class BinderProxy implements IBinder {  
    ......  
  
    public native boolean transact(int code, Parcel data, Parcel reply,  
                                int flags) throws RemoteException;  
  
    ......  
}  

//frameworks/base/core/jni/android_util_Binder.cpp
static jboolean android_os_BinderProxy_transact(JNIEnv* env, jobject obj,  
                        jint code, jobject dataObj,  
                        jobject replyObj, jint flags)  
{  
    ......  
  
    Parcel* data = parcelForJavaObject(env, dataObj);  
    if (data == NULL) {  
        return JNI_FALSE;  
    }  
    Parcel* reply = parcelForJavaObject(env, replyObj);  
    if (reply == NULL && replyObj != NULL) {  
        return JNI_FALSE;  
    }  
  
    IBinder* target = (IBinder*)  
        env->GetIntField(obj, gBinderProxyOffsets.mObject);  //得到这个BpBinder对象的IBinder接口
    if (target == NULL) {  
        jniThrowException(env, "java/lang/IllegalStateException", "Binder has been finalized!");  
        return JNI_FALSE;  
    }  
  
    ......  
  //有了这个IBinder接口后，通过BpBinder::transact函数进入到Binder驱动程序，然后Binder驱动程序唤醒Service Manager响应这个ADD_SERVICE_TRANSACTION
    status_t err = target->transact(code, *data, reply, flags);  
  
    ......  
  
    if (err == NO_ERROR) {  
        return JNI_TRUE;  
    } else if (err == UNKNOWN_TRANSACTION) {  
        return JNI_FALSE;  
    }  
  
    signalExceptionForError(env, obj, err);  
    return JNI_FALSE;  
}

Service Manager收到这个ADD_SERVICE_TRANSACTION请求时，就会把这个Binder实体纳入到自己内部进行管理。
这样，实现BinderDemoService 的Server的启动过程就完成了。

四、getService获取远程接口

在BinderDemo 这个Activity的onCreate函数，通过IServiceManager.getService函数来获得HelloService的远程接口：

public class BinderDemo extends Activity implements OnClickListener {    
    ......   
  
    private BinderDemoService binderService = null;    
  
    ......  
  
    @Override    
    public void onCreate(Bundle savedInstanceState) {    
  
        binderService = BinderDemoService .Stub.asInterface(    
                            ServiceManager.getService("binderdemo"));  
    }  
  
    ......  
}

ServiceManager.getService实际上是调用了ServiceManagerProxy.getService函数：


class ServiceManagerProxy implements IServiceManager {  
    public ServiceManagerProxy(IBinder remote) {  
        mRemote = remote;  
    }  
  
    ......  
  
    public IBinder getService(String name) throws RemoteException {  
        Parcel data = Parcel.obtain();  
        Parcel reply = Parcel.obtain();  
        data.writeInterfaceToken(IServiceManager.descriptor);  
        data.writeString(name);  
        mRemote.transact(GET_SERVICE_TRANSACTION, data, reply, 0);  
        IBinder binder = reply.readStrongBinder();  
        reply.recycle();  
        data.recycle();  
        return binder;  
    }  
  
    ......  
  
    private IBinder mRemote;  
}

reply它是一个Parcel对象，从下面语句返回：

mRemote.transact(GET_SERVICE_TRANSACTION, data, reply, 0);  


//引用reply
IBinder binder = reply.readStrongBinder(); 

//frameworks/base/core/jni/android_util_Binder.cpp
//把Java语言实现的Parcel对象class转换成C++语言实现的Parcel对象parcel，接着
static jobject android_os_Parcel_readStrongBinder(JNIEnv* env, jobject clazz)  
{  
    Parcel* parcel = parcelForJavaObject(env, clazz);  
    if (parcel != NULL) {  
        //相当于return javaObjectForIBinder(env, new BpBinder(handle));  
        return javaObjectForIBinder(env, parcel->readStrongBinder());  
    }  
    return NULL;  
}

javaObjectForIBinder这个函数，主要作用就是创建一个BinderProxy对象，并且把刚才获得的BpBinder对象的地址保存在这个BinderProxy对象的mObject成员变量中。

回到onCreate()函数：

helloService = IHelloService.Stub.asInterface(    
                    ServiceManager.getService("hello"))

相当于：

helloService = IHelloService.Stub.asInterface(new BinderProxy()));

具体定义：


public interface IBinderDemoService  extends android.os.IInterface  
{  
    /** Local-side IPC implementation stub class. */  
    public static abstract class Stub extends android.os.Binder implements android.os.IBinderDemoService  
    {  
        ......  
  
        public static android.os.IBinderDemoService asInterface(android.os.IBinder obj)  
        {  
            if ((obj==null)) {  
                return null;  
            }  
            android.os.IInterface iin = (android.os.IInterface)obj.queryLocalInterface(DESCRIPTOR);  
            if (((iin!=null)&&(iin instanceof android.os.IHelloService))) {  
                return ((android.os.IBinderDemoService )iin);  
            }  
            //相当于return new android.os.IHelloService.Stub.Proxy(new BinderProxy());  
            return new android.os.IBinderDemoService .Stub.Proxy(obj);  
        }  
  
        ......  
    }  
}

这样，就获得了BinderDemoService 的远程接口了，其实就是一个实现了IBinderDemoService 接口的IBinderDemoService .Stub.Proxy对象。

五、Client通过远程接口使用BinderDemoService提供的服务

上面获得远程接口后，就可以使用接口了：

public class BinderDemoextends Activity implements OnClickListener {  
    ......  
    @Override  
    public void onClick(View v) {  
        if(v.equals(readButton)) {  
            int val = binderService.getVal();    
            ......  
        }  
    }  
    ......  
}

binderService接口实际上是一个IBinderDemoService.Stub.Proxy对象，因此，我们进入到IBinderDemoService.Stub.Proxy类的getText函数中：

public interface BinderDemoService extends android.os.IInterface  
{  
    /** Local-side IPC implementation stub class. */  
    public static abstract class Stub extends android.os.Binder implements android.os.IBinderDemoService  
    {  
        ......  
  
        private static class Proxy implements android.os.IBinderDemoService   
        {  
            private android.os.IBinder mRemote;  
  
            ......  
  
            public int getText() throws android.os.RemoteException  
            {  
                android.os.Parcel _data = android.os.Parcel.obtain();  
                android.os.Parcel _reply = android.os.Parcel.obtain();  
                int _result;  
                try {  
                    _data.writeInterfaceToken(DESCRIPTOR);  
                    mRemote.transact(Stub.TRANSACTION_getText, _data, _reply, 0);  
                    _reply.readException();  
                    _result = _reply.readInt();  
                }  
                finally {  
                    _reply.recycle();  
                    _data.recycle();  
                }  
                return _result;  
            }  
        }  
  
        ......  
        static final int TRANSACTION_getText = (android.os.IBinder.FIRST_CALL_TRANSACTION + 1);  
    }  
  
    ......  
}

最终，经过层层返回，就回到IBinderDemoService.Stub.Proxy.getVal函数中来了，从下面语句返回：

mRemote.transact(Stub.TRANSACTION_getText, _data, _reply, 0);

并将结果读出来：

_result = _reply.readInt();

总结

以上通过一个BinderDemo例子详细讲解了binder的使用，本文仅仅简单介绍了binder的使用，而binder具体详细调用流程还得去阅读Android源代码。

抱着吉他学Android
关注
专栏目录
Android Binder——Native层介绍（五）
小旭的专栏
04-02 831
Binder Native 层主要负责实现进程间通信（IPC）和远程过程调用（RPC）的机制。在 Native 层中，Binder 架构主要包括服务端和客户端两部分。服务端存在一个 Binder 实体（BBinder）和对应的实体接口（BnInterface），而客户端存在一个 Binder 代理（BpBinder）和对应的代理接口（BpInterface）。服务端通过 Binder 驱动向 ServiceManager 进行注册，将 BBinde r的实体对象存入 ServiceManage r中。
android binder使用demo
weixin_30325793的博客
11-09 427
binder通信参考了以下两点： 1、安卓源码sensor这一块的代码 2、binder双向通信http://blog.csdn.net/brightming/article/details/50133475 基本点：看了网上的binder相关的例子后，大致思路就是如下： 1. 有一个服务端的service 一直提供服务， 客户端可以向服务端发送各种数据 2. 遇到特殊的需...
Anroid 分析：proxy模式理解Manager和Service
span76的专栏
12-05 923
Android 通过 Context提供getSystemService的接口， 而是实现类是 ContextImp ContextImpl.java 的Load时(Static)，会创建一堆 service proxy 对象，而后将其放入HashMap表中， 比如StatusBarManager 当用户调用 Service 方法的时候， Proxy 对象会将其传给真正
【Service】ServiceManager.getService流程总结
明朗晨光的专栏
09-14 8323
参考《深入理解Android内核设计思想》（第2版），对ServiceManager.getService流程分析过程中的一些总结进行记录备忘： ServiceManagerProxy 当某个Binder Server在启动时，会把自己的名称name与对应的Binder句柄值保存在ServiceManager中。调用者通常只知道Binder Server的名称，所以必须先向Se...
Android系统 之 ServiceManager 注册服务
老鹰不捉小鸡
06-13 2771
转 ：https://blog.csdn.net/litao55555/article/details/80597677 转载一篇作为以后学习用 2. ServiceManager 注册服务 以注册WindowManagerService为例 ServiceManager.addService(Context.WINDOW_SERVICE, wm); //向ServiceManager注册WMS，...
ServiceManagerProxy中mRemote变量指的什么？
转载和创作优秀的博客
12-02 194
首先标红的代码Binder.allowBlocking(BinderInternal.getContextObject())，实际上返回的是BinderProxy对象实例 sServiceManager = ServiceManagerNative .asInterface(Binder.allowBlocking(BinderInternal.getContextObject())); static public IServiceManager asInterfa...
Android源码分析 - Framework层的Binder（客户端篇）
m0_62167422的博客
06-27 858
本篇以分支作为基础解析我们在之前的文章中，从驱动层面分析了是怎样工作的，但驱动只涉及传输部分，待传输对象是怎么产生的呢，这就是层的工作了。我们要彻底了解的工作原理，不仅要去看驱动层，还得去看层以及应用层（）我们还是以第一次见到的地方开始分析，我们选取方法来分析（这个方法既有入参也有返回），抛除掉它缓存和的部分，最核心的代码就一句 BinderInternal.getContextObject 我们从开始看起，这个函数是一个函数，他被实现在中 ProcessState 我们在这里可以发现一个比较关键的类，它是
细读《深入理解 Android 内核设计思想》（五）Binder 机制 [下]
yhao的博客
05-17 991
对冗余挑拣重点，对重点深入补充，输出结构清晰的精简版 深入 binder 驱动内部 binder_ioctl binder_get_thread binder_ioctl_write_read binder_thread_write binder_transaction binder_thread_read 小结 binder Q&A 如何找到目标进程 Binder 实体 如何实现 Binder 线程的睡眠与唤醒 最后 深入 binder 驱动内部 前两篇文章都有提到 binder_ioc
Android Binder机制分析(5) Binder_ioctl()分析
Bettarwang的专栏
04-17 6409
在博客Android Binder机制(3)本地服务注册过程这篇博客中我们详细讲解了本地服务的注册过程，除了一个地方之外，那就是IPCThreadState::waitForResponse()方法中的talkWithDriver()，而在talkWithDriver()中调用了binder_ioctl()，由于内容太多，所以专门写一篇博客进行分析。 实际上，不只是在服务注册过程中会调用到Binder Driver中的binder_ioctl()，在服务检索、服务使用阶段都会调用到binder_ioctl
Android Binder机制分析(4) Parcel类分析
Bettarwang的专栏
04-16 5096
在C++层和Java层各有一个Parcel类，它们在Binder通信机制中起传递数据的作用。 在上一篇Blog中，在分析服务注册过程时，往data(Parcel对象)变量写入数据时，有这样的调用路径： BpServiceManager::addService()–>Parcel::writeStrongBinder()–>flatten_binder()–>finish_flatten_binder() 由于finish_flatten_binder()方法中涉及到的东西太多，在上一篇博客就没有展开来
Binder 跨进程通信原理浅析
若瑜的博客
05-12 1145
关于跨进程： 为什么要跨进程呢？在Android系统中，每个进程都有分配自己的内存空间，各进程间是不能直接访问其他进程的内存的，那当一个程序要操作与另一个程序的方法怎么办呢？（比如在应用程序中隐藏SystemUI的导航栏）这时就需要跨进程通信了。Binder就是一个帮助进程进通信的虚拟设备，为什么是虚拟设备呢，因为它没有硬件，只只用代码实现的通信架构。从哪开始说？ Android系统首次开机启动
五分钟读懂Android中的Binder跨进程机制和AIDL工具
caizehui的博客
02-07 3642
做Android开发，迈入高级必须会的技术很多，而且肯定包括Binder技术，关于Binder的了解，笔者最开始只是使用AIDL工具开发接口，生成Service的服务方法，对于其内部的实现细节不太了解。从书本上或者搜索看了好几遍，每次都是似懂非懂，然后日子久了，连那点印象也不见了。所以最近的这次综合了解了这个技术后，决定将自己的理解记录下来，一方面巩固理解，一方面分享给需要的朋友。 Binder ...
分析IBinder体系中getService
Lidong_Zhou的专栏
03-31 1478
IBinder体系中得到一个服务的过程分析： ServiceManager是管理所有服务（如音频，相机）的一个进程，它的handle是0 一、总的来说：得到一个service很简单，分成两步， 1，得到一个默认的serviceManager; 2，然后使用serviceManger->getService（service名称）得到具体的service 二、详细分析 参照网上一些资料
Android BINDER详解
Android系统攻城狮
03-20 3009
1.进程间通信的本质(2个进程) 用户空间的进程如果想相互通信,必须经过内核,因为不同进程的用户地址空间是独立的,但是共享同一个内核空间. 内核为了支持进程间通信,一般会有一个驱动,以字符设备的形式存在（也可以是其它形式,这个驱动的本质就是在不同的进程间传递数据）.两个进程间通信一般以client/server的形式进行,大致流程如下: ser...
Binder 跨进程传递对象的原理
最新发布
Lud的博客
02-08 1031
1. binder 传递有哪些方式 2. binder 在传递过程中是怎样存储的 3. binder 对象序列化和反序列化的过程 4. binder 对象在传递过程中驱动做了什么
Android笔记 - Binder之servicemanager代理对象
yansha的专栏
01-30 1132
1. 前言上一篇文章解答了关于 servicemanager 的三个问题，其中讲到 servicemanager 作为一个特殊的 Service 组件，既负责为系统中其他的 Service 组件提供注册服务，同时又负责为 Client 组件提供获取 Service 组件代理对象的服务。那么 Service 组件和 Client 组件如何才能使用到 servicemanager 提供的服务呢？
ServiceManager远程代理的获取
启程
10-21 692
ServiceManager管理着系统中所有的服务，无论是service 还是client只要跟系统中的服务打交道，必先获取ServiceManager的代理，才能获取ServiceManager提供的各项服务。在安卓系统中Service Manager远程代理是一个特殊的Binder引用，它的引用句柄一定是0。获取远程代理的方法defaultServiceManager()的实现在framewor
ServiceManager 小结
weixin_34049948的博客
10-20 143
  1 ServiceManger 根据name优先从Map中获取IBinder，例如AMS、WMS、PMS；如果Map中没有对应的IBinder，我们获取Serviceanager的代理ServiceManagerNative.asInterface(BinderInternal.getContextObject());　　android_os_BinderInternal_getContex...
由浅入深 学习 Android Binder（五）- binder如何在进程间传递
许佳佳的博客
12-12 2473
概述 前文分析过bindService源码，该文章地址如下： 由浅入深 学习 Android Binder（二）- bindService流程 最终得到时序图如下： 如上图，client进程与server进程是通过系统进程来进行通信的。 实际demo中，有两个场景我们会接触到binder： client进程通过serviceConnection获取到系统进程传递的binder。 server进程将service.onbind()返回的binder传递给系统进程。 我们就以server给系统进程传递bi
Android Binder：深入分析移动操作系统间通信机制
总结来说，这篇论文深入剖析了Android Binder在进程间通信中的核心地位，从基础理论到实际应用，展示了它在Android系统中如何作为关键组件确保应用间的有效交互和系统的稳定性。通过理解这些概念，开发者可以更好地...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值