Binder(1)--App使用Binder通信.md

最新推荐文章于 2023-12-08 16:44:50 发布
最新推荐文章于 2023-12-08 16:44:50 发布
阅读量604 收藏
点赞数
分类专栏： Android Binder
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u014535072/article/details/109826237
版权

参考资料

  1. Android Binder详解 https://mr-cao.gitbooks.io/android/content/android-binder.html

简介

在初学Android的时候，一般是从四大组件开始学起的。最开始学，是通过追代码流程的方式快速熟悉Android系统框架。

在这个速学的过程中，很多细节部分就被忽略掉了(这也是必须的，否则学起来极其痛苦且缓慢)。

比如四大组件之一的Service，在跨进程通信的时候，我们只知道是通过Binder通信的。至于内部实现是如何就不甚了了。

接下来我们通过一个简单的Demo深入探究这个跨进程通信的过程。

一. 在App之间使用Binder通信

目标是在AppClient中给AppServer发送一个简单的字符串

1.1 创建Interface

首先在服务端提供接口文件：IDemoInterface.

Android Studio中通过"File->New->AIDL"创建这个 aidl 文件。

interface IDemoInterface {
    /**
     * Demonstrates some basic types that you can use as parameters
     * and return values in AIDL.
     */
    void sayHello(long aLong, String aString);
}

创建之后需要在 “Build->Rebuild Project”, 生成对应可用的文件

1.2 实现服务端接口

class DemoService : Service() {
    val mName = "DemoService"

    class DemoBinder:IDemoInterface.Stub() {
        override fun sayHello(aLong: Long, aString: String?) {
            Log.d("DemoService", "$aString:$aLong")
        }
    }

    private val binder = DemoBinder()

    override fun onBind(intent: Intent?): IBinder? {
        return binder
    }
}

很简单，就是将传入的字符串输出出来。但是这个地方就有一个疑问，为啥是继承IDemoInterface.Stub呢？直接看这个文件的内容：

/*
 * This file is auto-generated.  DO NOT MODIFY.
 */
package com.oneplus.opbench.server;
// Declare any non-default types here with import statements

public interface IDemoInterface extends android.os.IInterface
{
  /** Default implementation for IDemoInterface. */
  public static class Default implements com.oneplus.opbench.server.IDemoInterface
  {
    /**
         * Demonstrates some basic types that you can use as parameters
         * and return values in AIDL.
         */
    @Override public void sayHello(long aLong, java.lang.String aString) throws android.os.RemoteException
    {
    }
    @Override
    public android.os.IBinder asBinder() {
      return null;
    }
  }
  /** Local-side IPC implementation stub class. */
  public static abstract class Stub extends android.os.Binder implements com.oneplus.opbench.server.IDemoInterface
  {
    private static final java.lang.String DESCRIPTOR = "com.oneplus.opbench.server.IDemoInterface";
    /** Construct the stub at attach it to the interface. */
    public Stub()
    {
      this.attachInterface(this, DESCRIPTOR);
    }
    /**
     * Cast an IBinder object into an com.oneplus.opbench.server.IDemoInterface interface,
     * generating a proxy if needed.
     */
    public static com.oneplus.opbench.server.IDemoInterface asInterface(android.os.IBinder obj)
    {
      if ((obj==null)) {
        return null;
      }
      android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR);
      if (((iin!=null)&&(iin instanceof com.oneplus.opbench.server.IDemoInterface))) {
        return ((com.oneplus.opbench.server.IDemoInterface)iin);
      }
      return new com.oneplus.opbench.server.IDemoInterface.Stub.Proxy(obj);
    }
    @Override 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
    {
      java.lang.String descriptor = DESCRIPTOR;
      switch (code)
      {
        case INTERFACE_TRANSACTION:
        {
          reply.writeString(descriptor);
          return true;
        }
        case TRANSACTION_sayHello:
        {
          data.enforceInterface(descriptor);
          long _arg0;
          _arg0 = data.readLong();
          java.lang.String _arg1;
          _arg1 = data.readString();
          this.sayHello(_arg0, _arg1);
          reply.writeNoException();
          return true;
        }
        default:
        {
          return super.onTransact(code, data, reply, flags);
        }
      }
    }
    private static class Proxy implements com.oneplus.opbench.server.IDemoInterface
    {
      private android.os.IBinder mRemote;
      Proxy(android.os.IBinder remote)
      {
        mRemote = remote;
      }
      @Override public android.os.IBinder asBinder()
      {
        return mRemote;
      }
      public java.lang.String getInterfaceDescriptor()
      {
        return DESCRIPTOR;
      }
      /**
           * Demonstrates some basic types that you can use as parameters
           * and return values in AIDL.
           */
      @Override public void sayHello(long aLong, java.lang.String aString) 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.writeLong(aLong);
          _data.writeString(aString);
          boolean _status = mRemote.transact(Stub.TRANSACTION_sayHello, _data, _reply, 0);
          if (!_status && getDefaultImpl() != null) {
            getDefaultImpl().sayHello(aLong, aString);
            return;
          }
          _reply.readException();
        }
        finally {
          _reply.recycle();
          _data.recycle();
        }
      }
      public static com.oneplus.opbench.server.IDemoInterface sDefaultImpl;
    }
    static final int TRANSACTION_sayHello = (android.os.IBinder.FIRST_CALL_TRANSACTION + 0);
    public static boolean setDefaultImpl(com.oneplus.opbench.server.IDemoInterface impl) {
      if (Stub.Proxy.sDefaultImpl == null && impl != null) {
        Stub.Proxy.sDefaultImpl = impl;
        return true;
      }
      return false;
    }
    public static com.oneplus.opbench.server.IDemoInterface getDefaultImpl() {
      return Stub.Proxy.sDefaultImpl;
    }
  }
  /**
       * Demonstrates some basic types that you can use as parameters
       * and return values in AIDL.
       */
  public void sayHello(long aLong, java.lang.String aString) throws android.os.RemoteException;
}

注释的就很清楚，是自动生成的文件。Stub是一个静态内部抽象类，继承了Binder和接口IDemoInterface。

1.3 客户端调用

注意把服务端aidl文件夹内容拷贝到客户端项目的aidl文件内，然后客户端也rebuild一下project.

/*
        <!-- for binder(aidl) -->
        <service android:name=".server.DemoService"
            android:process=".DemoService"
            android:enabled="true"
            android:exported="true" >
            <intent-filter>
                <action android:name="android.intent.action.DemoService"/>
            </intent-filter>
        </service>
*/
  private fun attemptToBindService() {
      val intent = Intent()
      Log.e("client", " connected now")
      intent.action = "android.intent.action.DemoService" //服务类的Action
      intent.`package` = "com.oneplus.opbench" //服务端包名
      // 建立通信
      bindService(intent, mServiceConnection, Context.BIND_AUTO_CREATE)
  }

  private val mDemoServiceConnection = object : ServiceConnection {
      override fun onBindingDied(name: ComponentName?) {
          Log.d("Client", "DemoService died!")
      }

      override fun onServiceDisconnected(p0: ComponentName?) {
          Log.d("Client", "DemoService disconnected!")
      }

      override fun onServiceConnected(p0: ComponentName?, p1: IBinder?) {
          Log.d("Client", "DemoService connected")
          // 远程服务连接成功，打个招呼
          val mProxyBinder = IDemoInterface.Stub.asInterface(p1)
          try {
              mProxyBinder.sayHello(5000, "Hello?")
          } catch (e:RemoteException) {

          }
      }
  }

相关类图

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-N9MJC3VO-1605791864261)(res/1_1_DemoInterface类图.png)]

接下来我们从客户端的bindService建立远程连接开始看看是怎么通信的，当然这里我们重点是binder通信，而不是service的bind流程。

二. 通信过程

分析跨进程通信的过程，一定要时刻谨记当前代码所处的进程哦, 为了方便和聚焦, 忽略非紧要代码。

2.1 Client=>ContextImpl.bindService

    @Override
    public boolean bindService(Intent service, ServiceConnection conn, int flags) {
        warnIfCallingFromSystemProcess();
        return bindServiceCommon(service, conn, flags, null, mMainThread.getHandler(), null,
                getUser());
    }

    private boolean bindServiceCommon(Intent service, ServiceConnection conn, int flags,
            String instanceName, Handler handler, Executor executor, UserHandle user) {
        // Keep this in sync with DevicePolicyManager.bindDeviceAdminServiceAsUser.
        IServiceConnection sd;
        // ......
        if (mPackageInfo != null) {
            if (executor != null) {
                sd = mPackageInfo.getServiceDispatcher(conn, getOuterContext(), executor, flags);
            } else {
                // 2.1.1 获取IServiceConnection对象
                sd = mPackageInfo.getServiceDispatcher(conn, getOuterContext(), handler, flags);
            }
        }
        // .......
            // 2.2 看来是先与Android系统中的AMS服务通信
            int res = ActivityManager.getService().bindIsolatedService(
                mMainThread.getApplicationThread(), getActivityToken(), service,
                service.resolveTypeIfNeeded(getContentResolver()),
                sd, flags, instanceName, getOpPackageName(), user.getIdentifier());
        // ......
    }

2.1.1 LoadedApk.getServiceDispatcher

    @UnsupportedAppUsage
    public final IServiceConnection getServiceDispatcher(ServiceConnection c,
            Context context, Handler handler, int flags) {
        return getServiceDispatcherCommon(c, context, handler, null, flags);
    }
  
    private IServiceConnection getServiceDispatcherCommon(ServiceConnection c,
            Context context, Handler handler, Executor executor, int flags) {
        synchronized (mServices) {
            LoadedApk.ServiceDispatcher sd = null;
            ArrayMap<ServiceConnection, LoadedApk.ServiceDispatcher> map = mServices.get(context);
            if (map != null) {
                if (DEBUG) Slog.d(TAG, "Returning existing dispatcher " + sd + " for conn " + c);
                sd = map.get(c);
            }
            if (sd == null) {
                if (executor != null) {
                    sd = new ServiceDispatcher(c, context, executor, flags);
                } else {
                    // 第一次建立连接，当然需要新建
                    sd = new ServiceDispatcher(c, context, handler, flags);
                }
                if (DEBUG) Slog.d(TAG, "Creating new dispatcher " + sd + " for conn " + c);
                if (map == null) {
                    map = new ArrayMap<>();
                    mServices.put(context, map);
                }
                map.put(c, sd);
            } else {
                sd.validate(context, handler, executor);
            }
            // 返回的是ServiceDispatcher里的mIServiceConnection对象,是InnerConnection
            return sd.getIServiceConnection();
        }
    }

这里就是将ServiceConnection做一个打包，存起来，隐藏细节，注意到返回的是 InnerConnection 类型哦。
相关类图如下：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-s7UzTr2X-1605791864263)(res/1_2_InnerConnection类图.png)]

2.2 SytemServer=>AMS.bindIsolatedService

这里其实就存在Binder通信，但是我们先不看，假设直接call过来了（四大组件之Service）.

我们知道，当服务端app进程没有启动时，会先将进程启动，然后继续进行bindService操作，为了方便，这里假设服务端进程已启动。

这里忽略中间一系列调用，走到ActiveServices.bindServiceLocked中:

int bindServiceLocked(IApplicationThread caller, IBinder token, Intent service,
            String resolvedType, final IServiceConnection connection, int flags,
            String instanceName, String callingPackage, final int userId)
            throws TransactionTooLargeException {
    // ......
    // 注意这里传入的connection是IServiceConnection
    // retrieveServiceLocked是从已安装的package中找到对应包以及指定Service组件
    ServiceLookupResult res =
            retrieveServiceLocked(service, instanceName, resolvedType, callingPackage,
                    Binder.getCallingPid(), Binder.getCallingUid(), userId, true,
                    callerFg, isBindExternal, allowInstant);
    // ......
    ServiceRecord s = res.record;
    // ......
        // 根据我们之前的研究过的Service知识，这个AppBindRecord就是记录App之间Service通信的
        AppBindRecord b = s.retrieveAppBindingLocked(service, callerApp);
        ConnectionRecord c = new ConnectionRecord(b, activity,
                connection, flags, clientLabel, clientIntent,
                callerApp.uid, callerApp.processName, callingPackage);
        // 注意这里的connection.asBinder调用的就是IServiceConnection.Stub.Proxy.asBinder
        // 返回的就是mRemote
        IBinder binder = connection.asBinder();
        // ......
        if (s.app != null && b.intent.received) {
          // Service is already running, so we can immediately
          // publish the connection.
          try {
              // c.conn就是Client端传入的IServiceConnection
              // 所以这里又调回去Client进程了，注意传入的b.intent.binder对象
              // 这个传入的b.intent.binder对象就是服务端App发布Service时传入的（publishServiceLocked）
              // 其实可以猜得到是这个就是对应服务端App的IDemoInterface对象
              // 2.3 转到Client进程
              c.conn.connected(s.name, b.intent.binder, false);
          } catch (Exception e) {
              Slog.w(TAG, "Failure sending service " + s.shortInstanceName
                      + " to connection " + c.conn.asBinder()
                      + " (in " + c.binding.client.processName + ")", e);
          }
}

2.3 Client=>LoadedApk.ServiceDispatcher.InnerConnection.connected

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

2.3.1 LoadedApk.ServiceDispatcher.connected

public void connected(ComponentName name, IBinder service, boolean dead) {
    if (mActivityExecutor != null) {
        mActivityExecutor.execute(new RunConnection(name, service, 0, dead));
    } else if (mActivityThread != null) {
        // 2.3.2 这里其实最后还是调用到了doConnected
        mActivityThread.post(new RunConnection(name, service, 0, dead));
    } else {
        doConnected(name, service, dead);
    }
}

2.3.2 LoadedApk.ServiceDispatcher.doConnected

public void doConnected(ComponentName name, IBinder service, boolean dead) {
    // ......

    // 这个service就是服务端App中的DemoBinder中的mRemote了
    if (service != null) {
        // mDemoServiceConnection通知已经建立连接
        mConnection.onServiceConnected(name, service);
    } else {
        // The binding machinery worked, but the remote returned null from onBind().
        mConnection.onNullBinding(name);
    }
}

2.3.3 客户端的ServiceConnection

override fun onServiceConnected(p0: ComponentName?, p1: IBinder?) {
    Log.d("Client", "DemoService connected")
    // 远程服务连接成功，打个招呼
    val mProxyBinder = IDemoInterface.Stub.asInterface(p1)
    try {
        mProxyBinder.sayHello(5000, "Hello?")
    } catch (e:RemoteException) {

    }
}

到这里，Android系统中两个进程通过四大组件之一的Service进行跨进程通信的连接已经建立了。

简单来说这个过程借助了SystemServer的帮助：Client app <–> SystemServer <–> Server app

Server App将Service的IBinder保存在SystemServer中，在Client App通过bindService的时候，传入。这样Client App就有了和Server App通信的基础。

搞清楚是怎么建立连接的过程，接下来深入探究下mProxyBinder.sayHello调用到不同进程对应的方法的细节。

SwallowJoe
关注
专栏目录
Android Binder——APP中的Binder通信（十八）
小旭的专栏
04-22 160
在 APP 开发中，四大组件中的 Activity 和 Service 是其中最常见的，在 Activity 启动 Service 的时候经常用到 bindService() 方法，而这就是建立 Binder 通信的过程。这一篇内容我们就来分析一下这里的 Binder 通信。
Binder(3)--sayHello之ioctl.md
SwallowJoe的博客
12-19 283
参考资料 简介 一. IBinder.transact 1.1 BinderProxy.transact 1.2 android_util_Binder#android_os_BinderProxy_transact 1.3 BpBinder#transact 1.4 IPCThreadState#transact 1.4.1 IPCThreadState#writeTransactionData 1.5 IPCThreadState#waitForResponse 1.6 IPCThreadS..
AIDL实现Binder通信简单实例（Android Studio开发）
04-19
写好aidl 文件以后，利用Android Studio自动生成代码，并通过两个app实现简单的binder通信
【安卓开发】使用binder进行进程间通信
Image
09-02 2009
通常我们会有这样的需求，在安卓系统中，两个独立的进程之间需要通信，如进程A需要进程B的发过来的信号；或者进程A与进程B共享一个内存块；或者进程A是32位进程而进程B是64位进程，为了加速处理过程，需要把进程A处理后的数据传递给进程B进行处理。这个时候就涉及到了安卓系统中的进程间通信，而安卓系统中的进程间通信往往离不开binder。binder是安卓系统中独有的进程间通信方式，关于其实现机制跟原理，可
千里马Android Framework实战课程-应用程序app的Binder启动篇
learnframework的博客
08-04 1695
上一个学习专题zygote启动app进程时候，有简单讲过一下binder启动，但没有详细进行分析。这一节进行重点详细分析。 ProcessState的启动 sp<ProcessState> ProcessState::self() { Mutex::Autolock _l(gProcessMutex); if (gProcess != nullptr) { return gProcess; } gProcess = new ProcessState
笔记 - 安卓中的Binder之使用①（二）
Papa1998
07-18 534
引言 上一篇中我们aidl和其对应的java代码都生成了，我们也分析了，那具体的使用还没有讲，接下来就来见一下针对我们的IBookManager，该怎么写对应的客户端和服务端。 梗概 《Android开发艺术》是直接在一个app中开启两个进程，并且各个阶段不可控，我这里进行了稍稍的改造，创建了两个app，并且各个阶段都用Button来控制，可以更好的理解。 服务端 服务端我们新建了一个项目，叫做AIDLService，并创建一个Service来监听客户端的请求，然后要创建上一篇讲的aidl文件，把暴露给客
Android UI架构(十一)--App请求切换帧率(2)之DisplayModeId.md
SwallowJoe的博客
09-20 4229
文章目录参考资料一. preferredDisplayModeId改变1.1 RootWindowContainer.applySurfaceChangesTransaction1.2 DisplayContent.applySurfaceChangesTransaction()1.3 DisplayContent.mApplySurfaceChangesTransaction1.4 DisplayManagerService.setDisplayProperties二. DisplayModeDirect
AppWidget源码分析（2）---updateAppWidget过程分析.md
破磬
08-13 5285
前面一篇文章，分析了AppWidgetProvider和RemoteView的源码，从中我们可以知道它们的实现原理，AppWidgetProvider是一个BroadcastReceiver，所以它是通过广播接收通知的，收到更新通知后，AppWidgetProvider需要去提供View供远程进程显示。这篇文章分析这个传输过程，分析updateAppWidget方法。
Android Binder进程间通信机制
鸿蒙开发知识记录
05-11 1462
1 Binder机制简介 为了系统的安全与稳定，Linux系统是存在进程隔离的：两个不同的进程，如应用App进程和ActivityManagerService服务所在的system_server系统进程，是无法直接通过内存地址访问到对方内部的函数或者变量的。所以两个进程如果需要相互访问就涉及到一个跨进程通信的概念即IPC(Inter-process communication，进程间通讯)。本质上是借助于不同进程的内核空间都是共享的原理，两个不同的进程都去访问内核空间，从而达到“间接”访问对方的目的。Bin
Android 进程通讯机制之Binder（信使）架构以及内存映射详解
m0_66264169的博客
02-04 2661
同一个应用由系统分配一个独立的账户， 该应用的产生的所有进程，都会是这同一个账户，每个进程都是相互独立的。 _那提起多进程，往往想到的是进程间的怎么交流信息的？那就有了今天这篇文章:Binder详解 一.Binder是什么？ Binder我也称之为信使（鸽子） Binder是安卓中实现IPC（进程间通信的）常用手段，四大组件之间的跨进程通信也是利用Binder实现的，Binder是学习四大组件工作原理的的一个重要基础，是Android提供的一套进程间相互通信框架。用来多进程间发送消息，同步和共.
App的启动和跳转与binder的关系
liyang_nash的专栏
03-29 466
点击桌面图标. Launcher和要启动的app是两个不同的App, 他们之间的通讯是通过ActivityServiceManager完成的. 整体流程: (1)点击相应图标之后, Launcher通知AMS要启动哪个app. 而且指定要启动MyApp的哪个界面. action = “android.intent.action.MAIN” category = “android.inten
Android之Binder原理剖析
最新发布
zhuhai0613的博客
12-08 1808
binder
Binder机制全解（一）Binder通信模型
appdsn的博客
02-11 788
      Binder是Android系统提供的一种IPC（进程间通信）机制，它的英文翻译是“粘合剂”，正如其名，它可以将系统各个进程粘合在一起，这样我们就可以使用其他进程提供的各种服务，整个系统仿佛运行于同一个程序之中。Android系统的四大组件，ActivityManagerService，PackageManagerService等系统服务无一不与Binder挂钩，它是系统间各个组件通信...
Android利用Binder进行通信
不忘初心
09-03 652
Android利用Binder进行通信Binder作为Android使用最广泛的IPC通信机制之一，其重要性不言而喻。Binder的实现思想与原理各路大神已经分析的十分透彻了，个人觉得最好以及最详细的是老罗的Android之旅系列里面关于Binder的讲解： [ Android进程间通信（IPC）机制Binder简要介绍和学习计划]Binder作为一种高效的IPC通信手段，其使用也十分的简单，本文参
Android Binder的原理与使用
QG
08-25 1989
Android Binder的原理与使用
帮你快速拿Offer！2021年Android工作或许更难找，搞懂这些直接来阿里入职
fanzhang_vip0723的博客
12-11 289
前言 Flutter 作为Google出品的一个新兴的跨平台移动客户端UI开发框架，正在被越来越多的开发者和组织使用，包括阿里的咸鱼、腾讯的微信等。 今天，我主要讲解Flutter中文本组件方面的Widget，包括Text、RichText、TextField，希望你们会喜欢。 什么是 HTTPS? HTTPS (基于安全套接字层的超文本传输协议 或者是 HTTP over SSL) 是一个 Netscape 开发的 Web 协议。 你也可以说：HTTPS = HTTP + SSL HTTPS
Context类bindService(Intent service, ServiceConnection conn, int flags)参数
到达的专栏
09-13 3502
public abstract boolean bindService(Intent service, ServiceConnection conn, int flags);  参数 flags的值有如下情况： public static final int BIND_AUTO_CREATE       表明只要绑定存在，就自动建立 Service；同时也告知Android系统，
AIDL用法 实现两个APP间的通信
godoge的博客
04-04 2490
AIDL是跨进程通信的一种方法，下面我来讲讲它的用法：服务项目中的配置使用：第一步：在服务项目中建一个自定义MyService类并继承Android的Service类，实现onBind()方法。第二步：在AndroidManifest文件处声明Service，并指定一个Action用于客户项目绑定这个Service。例如：第三步：新建AIDL文件(AIDL目录与java、res目录同级，文件在包名...
Service的绑定过程
zhaonhui的博客
09-09 2049
Service的绑定过程 ContextWrapper类： //Context类型，具体实现类是ContextImpl Context mBase; @Override public boolean bindService(Intent service, ServiceConnection conn, int flags) { return mBase.bindSer...
Android Binder深度解析：进程通信的关键
AIDL（Android Interface Definition Language）是使用Binder进行跨进程通信的一种工具，它允许开发者定义接口，使得客户端和服务端可以透明地进行数据交换。 理解Binder的原理对于深入掌握Android系统，特别是涉及...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值