登录
当前位置： 首页 > 编程笔记 >

Android  AIDL——进程通信机制详解

牟稳
2023-03-14
本文向大家介绍Android  AIDL——进程通信机制详解，包括了Android  AIDL——进程通信机制详解的使用技巧和注意事项，需要的朋友参考一下

Android  AIDL， Android进程机制通信机制，这里就整理下AIDL 的知识，帮助大家学习理解此部分知识！

什么是 AIDL

AIDL 全称 Android Interface Definition Language，即 安卓接口描述语言。听起来很深奥，其实它的本质就是生成进程间通信接口的辅助工具。它的存在形式是一种 .aidl 文件，开发者需要做的就是在该文件中定义进程间通信的接口，编译的时候 IDE 就会根据我们的 .aidl 接口文件生成可供项目使用的 .java 文件，这和我们说的“语法糖”有些类似。

AIDL 的语法就是 java 的语法，就是导包上有点细微差别。java 中如果两个类在相同的包中，是不需要进行导包操作的，但是在 AIDL 中，则必须进行导包声明。

 AIDL 详解

构想一个场景：我们有一个图书管理系统，这个系统的通过 CS 模式来实现。具体的管理功能由服务端进程来实现，客户端只需要调用相应的接口就可以。

那么首先定义这个管理系统的 ADIL 接口。

我们在 /rc 新建 aidl 包，包中有三个文件 Book.java 、Book.aidl、IBookManager.aidl 三个文件。

package com.example.aidl book

public class Book implements Parcelable {
 int bookId;
 String bookName;

 public Book(int bookId, String bookName) {
   this.bookId = bookId;
   this.bookName = bookName;
 }

 ...
}

package com.example.aidl;

Parcelable Book;

package com.example.aidl;

import com.example.aidl.Book;

inteface IBookManager {
  List<Book> getBookList();
  void addBook(in Book book);
}

下面对这三个文件分别进行说明：

Book.java 是我们定义的实体类，它实现了 Parcelable 接口，这样 Book 类才能在进程间传输。
Book.aidl 是这个实体类在 AIDL 中的声明。
IBookManager 是服务端和客户端通信的接口。（注意，在 AIDL 接口中除基本类型外，参数前须加方向，in 表示输入型参数，out 表示输出型参数，inout 表示输入输出型参数）

编译器编译后，android studio 为我们的项目自动生成了一个 .java 文件，这个文件包含三个类，这三个类分别是 IBookManager, Stub 和 Proxy，这三个类都是静态类型，我们完全可以把他们分开来，三个类定义如下：

IBookManager



public interface IBookManager extends android.os.IInterface {

  public void addBook(net.bingyan.library.Book book) throws android.os.RemoteException;

  public java.util.List<net.bingyan.library.Book> getBookList() throws android.os.RemoteException;
}

Stub



public static abstract class Stub extends android.os.Binder implements net.bingyan.library.IBookManager {
    private static final java.lang.String DESCRIPTOR = "net.bingyan.library.IBookManager";

    static final int TRANSACTION_addBook = (android.os.IBinder.FIRST_CALL_TRANSACTION + 0);
    static final int TRANSACTION_getBookList = (android.os.IBinder.FIRST_CALL_TRANSACTION + 1);
    /**
     * Construct the stub at attach it to the interface.
     */
    public Stub() {
      this.attachInterface(this, DESCRIPTOR);
    }

    /**
     * Cast an IBinder object into an net.bingyan.library.IBookManager interface,
     * generating a proxy if needed. http://www.manongjc.com/article/1501.html
     */
    public static net.bingyan.library.IBookManager asInterface(android.os.IBinder obj) {
      if ((obj == null)) {
        return null;
      }
      android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR);
      if (((iin != null) && (iin instanceof net.bingyan.library.IBookManager))) {
        return ((net.bingyan.library.IBookManager) iin);
      }
      return new net.bingyan.library.IBookManager.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 {
      switch (code) {
        case INTERFACE_TRANSACTION: {
          reply.writeString(DESCRIPTOR);
          return true;
        }
        case TRANSACTION_addBook: {
          data.enforceInterface(DESCRIPTOR);
          net.bingyan.library.Book _arg0;
          if ((0 != data.readInt())) {
            _arg0 = net.bingyan.library.Book.CREATOR.createFromParcel(data);
          } else {
            _arg0 = null;
          }
          this.addBook(_arg0);
          reply.writeNoException();
          return true;
        }
        case TRANSACTION_getBookList: {
          data.enforceInterface(DESCRIPTOR);
          java.util.List<net.bingyan.library.Book> _result = this.getBookList();
          reply.writeNoException();
          reply.writeTypedList(_result);
          return true;
        }
      }
      return super.onTransact(code, data, reply, flags);
    }
}

Proxy



private static class Proxy implements net.bingyan.library.IBookManager {
      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.  http://www.manongjc.com/article/1500.html
       */
      @Override
      public void addBook(net.bingyan.library.Book book) throws android.os.RemoteException {
        android.os.Parcel _data = android.os.Parcel.obtain();
        android.os.Parcel _reply = android.os.Parcel.obtain();
        try {
          _data.writeInterfaceToken(DESCRIPTOR);
          if ((book != null)) {
            _data.writeInt(1);
            book.writeToParcel(_data, 0);
          } else {
            _data.writeInt(0);
          }
          mRemote.transact(Stub.TRANSACTION_addBook, _data, _reply, 0);
          _reply.readException();
        } finally {
          _reply.recycle();
          _data.recycle();
        }
      }

      @Override
      public java.util.List<net.bingyan.library.Book> getBookList() throws android.os.RemoteException {
        android.os.Parcel _data = android.os.Parcel.obtain();
        android.os.Parcel _reply = android.os.Parcel.obtain();
        java.util.List<net.bingyan.library.Book> _result;
        try {
          _data.writeInterfaceToken(DESCRIPTOR);
          mRemote.transact(Stub.TRANSACTION_getBookList, _data, _reply, 0);
          _reply.readException();
          _result = _reply.createTypedArrayList(net.bingyan.library.Book.CREATOR);
        } finally {
          _reply.recycle();
          _data.recycle();
        }
        return _result;
      }
    }

对生成的这三个类的说明如下：

  1. IBookManager 这个类是我们定义的接口，android studio 给它添加了一个父类，让它继承自 android.os.interface 这个接口，这个接口只有一个方法 IBinder asBinder()，这样 IBookManager 中就有三个带实现的方法了，它是服务端进程和客户端进程通信的窗口。
  2. Stub 是个抽象类，这个类继承自 android.os.Binder 类，并且实现的了 IBookManager 这个接口。在 Stub 中，已经实现了 asBinder() 这个接口方法，还有两个是我们定义的 AIDL 接口方法留给继承它的子类去实现。它用在服务端，因此服务端需要实现这两个方法。
  3. Proxy 顾名思义是一个代理类，它是服务端在客户端的一个代理，它也实现了 IBookManager接口，并且实现了 IBookManager 中的所有方法。它用在客户端，是服务端在客户端的代理。现在我们对这三个类逐个分析：
  4. IBookManager 这个类没什么好说的，它只是简单继承了 asInterface 这个接口，作用就是将 IBookManager 转换成 IBinder。
  5. Proxy 这个类上面已经提到过了，它就是进程间通信机制的一个封装类，他的内部实现机制就是 Binder，通过构造方法我们也容易看出来。它的构造方法接受一个 IBinder 类型的参数，参数名为 remote，显然，它代表着服务端。我们看看这个类中的方法 addBook() 和 getBookList()：
@Override
public void addBook(net.bingyan.library.Book book) throws android.os.RemoteException {
   android.os.Parcel _data = android.os.Parcel.obtain();
   android.os.Parcel _reply = android.os.Parcel.obtain();
   try {
      _data.writeInterfaceToken(DESCRIPTOR)
      if ((book != null)) {
        _data.writeInt(1);
        book.writeToParcel(_data, 0);
      } else {
        _data.writeInt(0);
      }
      mRemote.transact(Stub.TRANSACTION_addBook, _data, _reply, 0);
      _reply.readException();
    } finally {
      _reply.recycle();
      _data.recycle();
    }
}
@Override /* http://www.manongjc.com/article/1547.html */
public java.util.List<net.bingyan.library.Book> getBookList() throws android.os.RemoteException {
    android.os.Parcel _data = android.os.Parcel.obtain();
    android.os.Parcel _reply = android.os.Parcel.obtain();
    java.util.List<net.bingyan.library.Book> _result;
    try {
       _data.writeInterfaceToken(DESCRIPTOR);
       mRemote.transact(Stub.TRANSACTION_getBookList, _data, _reply, 0);
       _reply.readException();
       _result = _reply.createTypedArrayList(net.bingyan.library.Book.CREATOR);
    } finally {
      _reply.recycle();
      _data.recycle();
    }
    return _result;
}

它们是编译器自动实现的，这两个方法有很多类似之处，可以现在这里透露下：这两个方法就是客户端进程调用服务端进程的窗口。在这两个方法的开始，它们都定义了两个 Parcel（中文译名：包裹）对象。Parcel 这个类我们看上去很眼熟，是的，Book 类中的 writeToParcel() 和 CREATOR中的 createFromParcel() 的参数就是 Parcel 类型的，关于这个类文档中解释如下：

Container for a message (data and object references) that can be sent through an IBinder. A Parcel can contain both flattened data that will be unflattened on the other side of the IPC (using the various methods here for writing specific types, or the general {@link Parcelable} interface), and references to live {@link IBinder} objects that will result in the other side receiving a proxy IBinder connected with the original IBinder in the Parcel.

翻译一下：Proxy 是一个可以通过 IBinder 进行消息传递的一个容器。一个 Parcel 可以包含可序列化的数据，这些数据会在 IPC 的另一端被反序列化；它也可以包含指向 IBinder 对象的引用，这会使得另一端接收到一个 IBinder 类型的代理对象，这个代理对象连接着 Parcel 中的原始 IBinder 对象。

下面用图来直观的说明：

Android 进程通信机制之 AIDL

如图，我们可以很直观的看到服务端以 Parcel 作为数据包裹依靠 Binder 和客户端进行通信。数据包裹就是序列化之后的对象。

如上所述，这两个方法都定义了两个 Parcel 对象，分别叫做 _data 和 _reply，形象的来说，从客户端的角度来看，_data 就是客户端发送给服务端的数据包裹，_reply 服务端发送给客户端的数据包裹。

之后便开始用这两个对象来和服务端进行通信了，我们能够观察到，两个方法中都有这么个方法调用 mRemote.transact()，它有四个参数，第一个参数的意义我们后面再讲，第二个参数 _data 负责向服务端发送数据包裹比如接口方法的参数，第三个参数 _reply 负责从服务端接收数据包裹比如接口方法的返回值。这行代码只有一句简单的方法调用，但是却是 AIDL 通信的最核心部分，它其实进行了一次远程方法调用（客户端通过本地代理 Proxy 暴露的接口方法调用服务端 Stub 同名方法），所以能想到它是一个耗时操作。

在我们的例子中：

1.void addBook(Book book) 需要借助 _data 向服务端发送参数 Book:book，发送的方式就是把 Book 通过其实现的 writeToParcel(Parcel out) 方法打包至 _data 中，正如你能想到的，_data 其实就是参数 out，还记得 Book 中的这个方法的实现吗？ 我们是将 Book 的字段一个个打包至 Parcel 中的。

2.List<Book> getBookList() 需要借助 _reply 从服务端接收返回值 List<Book>:books，方法中的做法是将 Book 中的 CREATOR 这个静态字段作为参数传入 _reply 的 createTypedArrayList() 方法中，还记得 Book 中的 CREATOR 吗？当时你是不是好奇这个静态字段应该怎么用呢？现在一切明了了，我们需要靠这个对象（便于理解我们可以叫它”反序列化器“）来对服务端的数据反序列化从而重新生成可序列化的对象或者对象数组。很明显 CREATOR 借助 _reply 生成了 List<Book>:books。

当然这两个方法中的 _data 和 _reply 不仅传递了对象，还传递了一些校验信息，这个我们可以不必深究，但应注意的是，Parcel 打包顺序和解包顺序要严格对应。例如，第一个打包的是 int:i，那么第一解包的也应该是这个整型值。也即打包时第一次调用的如果是 Parcel.writeInt(int)，解包时第一次调用的应该是 Parcel.readInt()。

到此，客户端的 Proxy 讲解完了，下面我们看看服务端的 Stub。

Stub 中实现了 IBookManager 的其中一个方法，这个很简单，就是简单的将自身返回，因为 Stub 本身就继承自 Binder，而 Binder 继承自 IBinder，所以没有任何问题。你会问：还有两个方法没实现呢？这两个方法就是我们定义的接口方法，它们留给服务端进程去实现，也就是说，到时候我们在服务端进程中需要定义一个 Stub 的实现者。下面对 Stub 中的两个重要方法进行分析：

IBookManager asInterface(IBinder obj)

public static net.bingyan.library.IBookManager asInterface(android.os.IBinder obj) {
      if ((obj == null)) {
        return null;
      }
      android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR);
      if (((iin != null) && (iin instanceof net.bingyan.library.IBookManager))) {
        return ((net.bingyan.library.IBookManager) iin);
      }
      return new net.bingyan.library.IBookManager.Stub.Proxy(obj);
    }

这个方法的作用是将 Stub 类转换成 IBookManager 这个接口，方法中有个判断：如果我们的服务端进程和客户端进程是同一进程，那么就直接将 Stub 类通过类型转换转成 IBookManager；如果不是同一进程，那么就通过代理类 Proxy 将 Stub 转换成 IBookManager。为什么这么做，我们知道如果服务端进程和客户端进程不是同一进程，那么它们的内存就不能共享，就不能通过一般的方式进行通信，但是我们如果自己去实现进程间通信方式，对于普通开发者来说成本太大，因此编译器帮我们生成了一个封装了了进程间通信的工具，也就是这个 Proxy，这个类对底层的进程通信机制进行了封装只同时暴露出接口方法，客户端只需要调用这两个方法实现进程间通信（其实就是方法的远程调用）而不需要了解其中的细节。

有了这个方法，我们在客户端可以借助其将一个 IBinder 类型的变量转换成我们定义的接口 IBookManager，它的使用场景我们会在后面的实例中进行讲解。

onTransact(int code, Parcel data, Parcel reply, int flags)

@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_addBook: {
          data.enforceInterface(DESCRIPTOR);
          net.bingyan.library.Book _arg0;
          if ((0 != data.readInt())) {
            _arg0 = net.bingyan.library.Book.CREATOR.createFromParcel(data);
          } else {
            _arg0 = null;
          }
          this.addBook(_arg0);
          reply.writeNoException();
          return true; /* http://www.manongjc.com/article/1499.html */
        }
        case TRANSACTION_getBookList: {
          data.enforceInterface(DESCRIPTOR);
          java.util.List<net.bingyan.library.Book> _result = this.getBookList();
          reply.writeNoException();
          reply.writeTypedList(_result);
          return true;
        }
      }
      return super.onTransact(code, data, reply, flags);
}

这个方法我们是不是也很熟悉呢？我们在 Proxy 中也看到一个类似得方法 transact(int, Parcel, Parcel, int)，它们的参数一样，而且它们都是 Binder 中的方法，那么它们有什么联系呢？

前面说了，transact() 执行了一个远程调用，如果说 transact() 是远程调用的发起，那么 onTransact() 就是远程调用的响应。真实过程是客户端发器远程方法调用，android 系统通过底层代码对这个调用进行响应和处理，之后回调服务端的 onTransact() 方法，从数据包裹中取出方法参数，交给服务端实现的同名方法调用，最后将返回值打包返回给客户端。

需要注意的是 onTransact() 是在服务端进程的 Binder 线程池中进行的，这就意味着如果我们的要在 onTransact() 方法的中更新 UI，就必须借助 Handler。

这两个方法的第一个参数的含义是 AIDL 接口方法的标识码，在 Stub 中，定义了两个常量作为这两个方法的标示：

static final int TRANSACTION_addBook = (android.os.IBinder.FIRST_CALL_TRANSACTION + 0);
   static final int TRANSACTION_getBookList = (android.os.IBinder.FIRST_CALL_TRANSACTION + 1);

如果 code == TRANSACTION_addBook，那么说明客户端调用的是 addBook()；如果 code == TRANSACTION_getBookList，那么客户端调用的是 getBookList()，然后交由相应的服务端方法处理。 用一张图来表示整个通信过程：

Android 进程通信机制之 AIDL

了解了 AIDL 的整个过程，接下来就是 AIDL 在安卓程序中的应用了。

 AIDL 的使用

相信大家应该都和清楚 Service 的使用了吧，Service 虽然称作“服务”，并且运行于后台，但是它们默认还是运行在默认进程的主线程中。其实让 Service 运行在默认进程中，有点大材小用了。android 的很多系统服务都运行于单独的进程中，供其他应用调用，比如窗口管理服务。这样做的好处是可以多个应用共享同一个服务，节约了资源，也便于集中管理各个客户端，要注意问题的就是线程安全问题。

那么接下来我们就用 AIDL 实现一个简单的 CS 架构的图书管理系统。

首先我们定义服务端：

BookManagerService



public class BookManagerService extends Service {

  private final List<Book> mLibrary = new ArrayList<>();

  private IBookManager mBookManager = new IBookManager.Stub() {
    @Override
    public void addBook(Book book) throws RemoteException {
      synchronized (mLibrary) {
        mLibrary.add(book);
        Log.d("BookManagerService", "now our library has " + mLibrary.size() + " books");
      }

    }

    @Override
    public List<Book> getBookList() throws RemoteException {
      return mLibrary;
    }
  };
 
  @Override /* http://www.manongjc.com/article/1496.html */
  public IBinder onBind(Intent intent) {
    return mBookManager.asBinder();
  }

}



<service
   android:process=":remote"
   android:name=".BookManagerService"/>

服务端我们定义了 BookManagerService 这个类，在它里面我们创建了服务端的 Stub 对象，并且实现了需要实现的两个 AIDL 接口方法来定义服务端的图书管理策略。在 onBind() 方法中我们将 IBookManager 对象作为 IBinder 返回。我们知道，当我们绑定一个服务时，系统会调用 onBinder() 方法得到服务端的 IBinder 对象，并将其转换成客户端的 IBinder 对象传给客户端，虽然服务端的 IBinder 和 客户端的 IBinder 是两个 IBinder 对象，但他们在底层都是同一个对象。我们在 xml 中注册 Service 时给它指定了进程名，这样 Service 就能运行在单独的进程中了。

接下来看看客户端的实现：

Client



public class Client extends AppCompatActivity {

  private TextView textView;

  private IBookManager bookManager;

  @Override
  protected void onCreate(@Nullable Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.library_book_manager_system_client);

    Intent i = new Intent(Client.this, BookManagerService.class);
    bindService(i, conn, BIND_AUTO_CREATE);

    Button addABook = (Button) findViewById(R.id.button);
    addABook.setOnClickListener(v -> {
      if (bookManager == null) return;
      try {
        bookManager.addBook(new Book(0, "book"));
        textView.setText(getString(R.string.book_management_system_book_count, String.valueOf(bookManager.getBookList().size())));
      } catch (RemoteException e) {
        e.printStackTrace();
      }

    });

    textView = (TextView) findViewById(R.id.textView);
  }

  private ServiceConnection conn = new ServiceConnection() {
    @Override
    public void onServiceConnected(ComponentName name, IBinder service) {
      Log.d("Client -->", service.toString());

      bookManager = IBookManager.Stub.asInterface(service);
    }

    @Override
    public void onServiceDisconnected(ComponentName name) {
      Log.d("Client", name.toString());
    }
  };

}




<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
  android:orientation="vertical" android:layout_width="match_parent"
  android:layout_height="match_parent"
  android:weightSum="1"
  android:gravity="center">

  <Button
    android:text="http://www.manongjc.com/article/1495.html"
    android:layout_width="111dp"
    android:layout_height="wrap_content"
    android:id="@+id/button" />

  <TextView
    android:layout_marginTop="10dp"
    android:text="@string/book_management_system_book_count"
    android:layout_width="231dp"
    android:gravity="center"
    android:layout_height="wrap_content"
    android:id="@+id/textView" />
</LinearLayout>

我们的客户端就是一个 Activity，onCreate() 中进行了服务的绑定，bindService() 方法中有一参数 ServiceConnection:conn，因为绑定服务是异步进行的，这个参数的作用就是绑定服务成功后回调的接口，它有两个回调方法：一个是连接服务成功后回调，另一个在与服务端断开连接后回调。我们现在关心的主要是 onServiceConnected() 方法，在这里我们只做了一件事：将服务端转换过来的 IBinder 对象转换成 AIDL 接口，我们定义 IBookManager:bookManager 字段来保持对其的引用。这样的话，我们就可以通过这个 bookManager 来进行方法的远程调用。我们给客户端的 Button 注册事件：每一次点击都会向服务端增加一本书，并且将图书馆现有的图书数量显示出来。

现在我们看看程序的运行效果：

每当我们点击按钮，我们就成功的向服务端添加了一本书，说明我们通过 AIDL 跨进程通信成功了。

感谢阅读，希望能帮助到大家，谢谢大家对本站的支持！

 类似资料：
  • Android 进程间通信AIDL使用详解

    本文向大家介绍Android 进程间通信AIDL使用详解，包括了Android 进程间通信AIDL使用详解的使用技巧和注意事项，需要的朋友参考一下 一、概述 AIDL 意思即 Android Interface Definition Language，翻译过来就是Android接口定义语言，是用于定义服务器和客户端通信接口的一种描述语言，可以拿来生成用于IPC的代码。从某种意义上说AIDL其实是一

  • Android IPC进程间通信详解最新AndroidStudio的AIDL操作)

    本文向大家介绍Android IPC进程间通信详解最新AndroidStudio的AIDL操作)，包括了Android IPC进程间通信详解最新AndroidStudio的AIDL操作)的使用技巧和注意事项，需要的朋友参考一下 前言 前面梳理了Android的线程间的通信《Thread、Handler和HandlerThread关系何在？》 ，这些都是在同一个进程中，那进程间的通信，或者说不同的应

  • 浅谈Android Aidl 通讯机制

    本文向大家介绍浅谈Android Aidl 通讯机制，包括了浅谈Android Aidl 通讯机制的使用技巧和注意事项，需要的朋友参考一下 服务端： 首先是编写一个aidl文件，注意AIDL只支持方法，不能定义静态成员，并且方法也不能有类似public等的修饰符；AIDL运行方法有任何类型的参数和返回值，在java的类型中，以下的类型使用时不需要导入包（import），基本数据类型、String、

  • Android多进程间采用AIDL方式进行通信

    本文向大家介绍Android多进程间采用AIDL方式进行通信，包括了Android多进程间采用AIDL方式进行通信的使用技巧和注意事项，需要的朋友参考一下 在上一节中，我介绍了Android中Service的生命周期以及一些有关知识。在这一节中，我采用代码编写的方式来介绍一下不同程序之间也就是不同进程之间通信采用AIDL方式。 首先我需要解释一下，不同程序进程间采用AIDL方式启动服务，我们可以看

  • Android IPC机制利用Messenger实现跨进程通信

    本文向大家介绍Android IPC机制利用Messenger实现跨进程通信，包括了Android IPC机制利用Messenger实现跨进程通信的使用技巧和注意事项，需要的朋友参考一下 写作原因：跨进程通信的实现和理解是Android进阶中重要的一环。下面博主分享IPC一些相关知识、操作及自己在学习IPC过程中的一些理解。这一章使用Messenger实现跨进程通信，其中bindService基础

  • 3.2.4 Android Binder机制及AIDL使用

    Binder原理 1、概述 Android系统中，涉及到多进程间的通信底层都是依赖于Binder IPC机制。例如当进程A中的Activity要向进程B中的Service通信，这便需要依赖于Binder IPC。不仅于此，整个Android系统架构中，大量采用了Binder机制作为IPC（进程间通信，Interprocess Communication）方案。 当然也存在部分其他的IPC方式，如管

相关阅读

Android IPC机制利用Messenger实现跨进程通信Android程序设计之AIDL实例详解Android通过AIDL在两个APP之间Service通信php中socket通信机制实例详解Android中如何利用AIDL机制调用远程服务

相关文章

Redis的事务机制详解MySQL中的锁机制详解Go语言CSP：通信顺序进程简述Java 线程通信详解Hadoop中的契约监控机制

相关问答

父进程在子进程之前执行，如何通过信号量强制相反？java单机版，用于与android设备通信请参阅Tomcat子进程的详细信息通过WiFi与Android/iOS进行通信的跨平台服务器应用程序PyObc作为通过管道与主进程通信的子进程不起作用

相关工具

信任的进化AsyncUdpSocket即时通信计算机进化高仿微信打飞机通用信息系统框架

相关文档

IPC 进程间通信 中文文档Java 反射机制教程Android Animation 动画详解Android 研发工程师高级进阶通信的数学理论
快捷导航： 新手教程 算法原理 架构设计 Java进阶 数据库进阶 大厂专栏 面试经验 编程笔记 编程问答 所有专题 文档资料 工具软件 电子书籍 小牛导航
在线工具： 房贷计算器 个税计算器 Linux命令查询 Json格式化 正则表达式 颜色转换 AES加解密 SHA1加密 MD5加密 毒鸡汤 字数统计 随机密码生成 进制转换 Base64编解码 励志句子
Copyright © 2019-2024 小牛知识库@xnip.cn. All Rights Reserved.