这一次,binder真正理解了(一) -----跨进程通信以及AIDL的使用

最新推荐文章于 2023-03-20 18:47:19 发布
最新推荐文章于 2023-03-20 18:47:19 发布
阅读量668 收藏 3
点赞数 1
分类专栏： binder 文章标签： binder android 面试 理解
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_38366777/article/details/108033102
版权

前言

网上有很多有关于binder文章的讲述，读了很多文章，有些直接讲源码，对初学的来说比较抽象，这系列文章先从使用背景，从运用上逐步深入去介绍知识点，希望能有一个更好的理解。这系列文章先从ipc通信讲起，通过AIDL的使用去探binder原理，这一次和我一起理清binder吧，有哪里讲的不好的点，欢迎指正补充，希望这一系列能让大家在以后的面试中能稳稳的回答出binder的相关问题。

概述

在日常的app开发当中,大家有没有跨进程的使用呢。还是一个进程走到底呢 。

在android里,一个应用启动对应着一个进程，那一个应用多创建进程又有什么好处呢，又有什么应用场景呢。

  • 分担主进程的内存压力

当应用越做越大，内存越来越多，将一些独立的组件放到不同的进程，它就不占用主进程的内存空间了。手机分配给每个进程的内存都是有限的，在一些webiview的优化文章里，让webview独自使用一个进程。

  • 使应用常驻后台，防止主进程被杀守护进程，守护进程和主进程之间相互监视，有一方被杀就重新启动它。

Android后台进程里有很多应用是多个进程的，因为它们要常驻后台，特别是即时通讯或者社交应用，不过现在多进程已经被用烂了。典型用法是在启动一个不可见的轻量级私有进程，在后台收发消息，或者做一些耗时的事情，或者开机启动这个进程，然后做监听等。坏处：消耗用户的电量，多占用了系统的空间，若所有应用都这样占用，系统内存很容易占满而导致卡顿，应用程序架构会变得复杂，因为要处理多进程之间的通信。

看来一个应用多进程还是有一些好处的，在创建多进程的同时，想必需要了解一些进程间通信，就比如上文提到的webview优化，那我们应用让webview打开指定文章，肯定需要传递url吧。还有一种进程通信的业务场景，大家应该经常遇到，就比如第三方登录，我们使用微信登陆和qq登陆，两个应用都是不同的进程，他们也需要使用进程间通信吧。看来，进程间通信所应用的业务场景比较多的。当然Android底层的实现用到进程间通信更多。

进程间通信方式（IPC通信方式）

每个进程都有自己的一部分独立的系统资源，彼此是隔离的。为了能使不同的进程互相访问资源并进行协调工作，才有了进程间通信。
每个Android的进程，只能运行在自己进程所拥有的虚拟地址空间。对应一个4GB的虚拟地址空间，其中3GB是用户空间，1GB是内核空间，当然内核空间的大小是可以通过参数配置调整的。对于用户空间，不同进程之间彼此是不能共享的，而内核空间却是可共享的。（换句话说,你A进程要和B进程通信，在用户空间两者无法通信，可以将两者转向内核通信）那么进程间通信都有哪几种方式呢，android是基于linux系统的，这边继承了linux系统的ipc通信方式，也有自己独有的通信方式。

  • 一 使用Bundle

    我们直到，四大组件中的三大组件（Activity、Service、Receiver）都是支持在Intent中传递Bundle数据的，由于Bundle实现了Parcelable接口，由于Bundle实现了Parcelable接口，所以它可以方便地在不同的进程间传输。

传输的数据必须能够序列化，比如基本类型、实现Parcelable接口的对象，实现了Serializable接口的对象以及一些Android支持的特殊对象。

除了直接传递数据这种典型的使用场景，它还有一种特殊的使用场景。这种方式的核心思想在于将原本需要在A进程的计算任务转移到B进程的后台Service中去执行，避免了A进程在计算，不能把计算结果传递给要启动的B进程里。

  • 二 使用文件共享

共享文件也是一种不错的进程间通信方式，两个进程通过读/写同一个文件来交换数据，比如A进程把数据写入文件，B进程通过读取这个文件来获取数据。由于Android系统基于Linux，使得其并发读/写文件可以没有限制地进行，甚至两个线程同时对同一个文件进行写操作都是允许的。

通过文件共享这种方式来共享数据对文件格式是没有具体要求的，比如可以是文本文件，也可以是XML文件，只要读/写双方约定数据格式即可。通过文件共享的方式也是有局限性的，比如并发读/写的问题。

  • 三 使用Socket

Socket也称为“套接字”，是网络通信的概念，它分为流失套接字和用户数据包套接字两种，分别对应于网络的传输控制层的TCP和UDP协议。

一般用于设计我们的聊天室程序，首先在远程Service建立一个TCP服务，然后在主界面中连接TCP服务，连接上了以后，就可以给服务端发消息了。使用Socket的工作机制。

  • 四 使用Messenger

通过Messenger可以在不同进程中传递Messenger对象，在Messenger中放入我们需要传递的数据，就可以轻松地实现数据的进程间传递了。Messenger是一种轻量级的IPC方案，它的底层实现是AIDL。

  • 五 使用AIDL

AIDL也是Messenger的底层实现，可以用来跨进称调用服务端，底层实现是binder。

  • 六 ContentProvider

ContentProvider的底层实现同样也是Binder。系统已封装好使用起来十分简单，(毕竟ContentProvider是用于和其他应用进行交互的)

系统预置了许多ContentProvider，比如通讯录信息、日程表信息等，要跨进程访问这些消息，只需要通过ContentResolver的query、update、insert和delet方法即可。

我们可以看到Messenger，AIDL，ContentProvider底层实际都是用Binder。

走错片场了，binder牛逼。

那Binder是什么？ Binder作为Android系统提供的一种IPC机制。确实这句话就是他的定义，他就是Android系统来解决跨进程通信的一个机制，之后的系列文章会讲解他是如何运作的，从java层逐步往native层深入下去。

AIDL 实现进程间通信

github代码直通车

首先我们先从基于binder机制的AIDL讲起，如何实现进程间通信 ，现在我想实现这样一个功能，进程A的Activity传递数据给进程B的Service,进程B处理完数据再将数据返回给A （整个过程可以类比第三方登录）。可以参考下方流程图，首先进程A的clientActivity将MyData对象传给进程B的Service操作一通，等进程B的Service操作完在将处理后的MyData对象返回给进程A，大家可以试着想想该如何实现这种场景，再继续阅读下面的代码。

在这里插入图片描述

RemoteService

注册Service
   <service
            android:name=".binder.RemoteService"
            android:enabled="true"
            android:exported="true"
            android:process=":remote">
        </service>
编写AIDL文件
  • 要操作的MyData对象

MyData.aidl


package com.hugh.byteadvance.binder;

parcelable MyData;
  • IRemoteService.aidl 实际操作的函数,之后的Activity进程要调用这边的opration函数

IRemoteService.aidl

package com.hugh.byteadvance.binder;
import com.hugh.byteadvance.binder.MyData;
import com.hugh.byteadvance.binder.ICompletedListener;
interface IRemoteService {
      int getPid();
      MyData getMyData();
      void operation(in MyData parameter1 );
      void registerListener(in ICompletedListener listener);

      void unregisterListener(in ICompletedListener listener);
}
  • ICompletedListener 模仿耗时操作通过回调来通知

ICompletedListener.aidl

package com.hugh.byteadvance.binder;

import com.hugh.byteadvance.binder.MyData;

interface ICompletedListener {
   void onOperationCompleted(in MyData result);
}

Service部分代码编写

operation实现了具体操作，将数据相加，相乘最后通过回调返回给进程A Activity。
这里实现了同步和异步的操作，同步可以参考getPid()，getMyData()。
异步这边可以参考下operation(),注意这边的回调使用到了RemoteCallbackList。

public class RemoteService extends Service {

    private static final String TAG = "aaa";

    MyData mMyData;
    //声明
    private RemoteCallbackList<ICompletedListener> callbackList;

    @Override
    public void onCreate() {
        super.onCreate();
        initMyData();
        callbackList = new RemoteCallbackList<>();
    }


    /**
     * 初始化MyData数据
     **/
    private void initMyData() {
        mMyData = new MyData();
        mMyData.setData1(10);
        mMyData.setData2(20);
    }

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

    private final IRemoteService.Stub mBinder = new IRemoteService.Stub() {
        @Override
        public int getPid() throws RemoteException {
            Log.e(TAG, "android.os.Process.myPid()" + android.os.Process.myPid());
            return android.os.Process.myPid();
        }

        @Override
        public MyData getMyData() throws RemoteException {
            Log.i(TAG, "[RemoteService] getMyData()  " + mMyData.toString());
            return mMyData;
        }

        @Override
        public void operation(MyData parameter1 ) throws RemoteException {
            try {
                Log.e(TAG, "operation 被调用，延时3秒，模拟耗时计算");
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            int param1 = parameter1.getData1();
            int param2 = parameter1.getData2();
            MyData result = new MyData(param1 + param2,param1 *param2);
            //在操作 RemoteCallbackList 前，必须先调用其 beginBroadcast 方法
            //此外，beginBroadcast 必须和 finishBroadcast配套使用
            int count = callbackList.beginBroadcast();
            for (int i = 0; i < count; i++) {
                ICompletedListener listener = callbackList.getBroadcastItem(i);
                if (listener != null) {
                    listener.onOperationCompleted(result);
                }
            }
        }

        @Override
        public void registerListener(ICompletedListener listener) throws RemoteException {
            callbackList.register(listener);
            Log.e(TAG, "registerListener 注册回调成功");
        }

        @Override
        public void unregisterListener(ICompletedListener listener) throws RemoteException {
            callbackList.unregister(listener);
            Log.e(TAG, "unregisterListener 解除注册回调成功");
        }

        //此处可以用于权限拦截
        @Override
        public boolean onTransact(int code, Parcel data, Parcel reply, int flags) throws RemoteException {
            return super.onTransact(code, data, reply, flags);
        }
    };

    @Override
    public boolean onUnbind(Intent intent) {
        Log.i(TAG, "[RemoteService] onUnbind");
        return super.onUnbind(intent);
    }


    @Override
    public void onDestroy() {
        Log.i(TAG, "[RemoteService] onDestroy");
        super.onDestroy();
    }

}

Activity代码编写

讲一下Activity的流程

  1. 首先新建ServiceConnection对象，在ServiceConnected和onServiceDisconnected写下相关的操作

  2. 启动Service,并绑定Service，在onServiceConnected的回调中，获取IRemoteService的代理对象

  3. mRemoteService.registerListener(completedListener); 注册监听后 ， mRemoteService.operation(myData); 通过代理对象执行相应的方法。

  4. 最后 onOperationCompleted 再回调中获取相关结果。

重点：我们的操作都需要获取到IRemoteService的代理对象，就能进行进程间的通信。


public class ClientActivity extends AppCompatActivity implements View.OnClickListener {
    private static final String TAG = "aaa";
    private IRemoteService mRemoteService;
    private boolean mIsBound;
    private TextView mCallBackTv;
    private Button mBtnRegister;
    private Button mBtnOperate;
    private TextView mTvResult;
    private TextView mBtnUnRegister;

    private ICompletedListener completedListener = new ICompletedListener.Stub() {
        @Override
        public void onOperationCompleted(final MyData result) throws RemoteException {
            runOnUiThread(new Runnable() {
                @Override
                public void run() {
                    mTvResult.setText("运算结果： 加法：" + result.getData1() + "------运算结果: 乘法：" + result.getData2());
                }
            });
        }
    };

    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_binder);
        mCallBackTv = (TextView) findViewById(R.id.tv_callback);
        mTvResult = findViewById(R.id.tv_operate_result);
        mBtnOperate = findViewById(R.id.btn_operate);
        mBtnRegister = findViewById(R.id.btn_register);
        mBtnUnRegister = findViewById(R.id.btn_un_register);
        mBtnRegister.setOnClickListener(this);
        mBtnOperate.setOnClickListener(this);
        mBtnUnRegister.setOnClickListener(this);
        mCallBackTv.setText("unattached");
    }


    private ServiceConnection mConnection = new ServiceConnection() {
        @Override
        public void onServiceConnected(ComponentName name, IBinder service) {
            mRemoteService = IRemoteService.Stub.asInterface(service);
            String pidInfo = null;
            MyData myData = null;
            try {
                myData = mRemoteService.getMyData();
                pidInfo = "pid=" + mRemoteService.getPid() +
                        ", data1 = " + myData.getData1() +
                        ", data2=" + myData.getData2();
            } catch (RemoteException e) {
                e.printStackTrace();
            }
            Log.i(TAG, "[ClientActivity] onServiceConnected  " + pidInfo);
            mCallBackTv.setText(pidInfo);
            Toast.makeText(ClientActivity.this, "connected", Toast.LENGTH_SHORT).show();
        }

        @Override
        public void onServiceDisconnected(ComponentName name) {
            Log.i(TAG, "[ClientActivity] onServiceDisconnected");
            mCallBackTv.setText("disconnected");
            mRemoteService = null;
            Toast.makeText(ClientActivity.this, "disconnected", Toast.LENGTH_SHORT).show();
        }
    };

    @Override
    public void onClick(View v) {
        switch (v.getId()) {
            case R.id.btn_register:
                /**
                 * 注册监听
                 */
                if (mRemoteService == null) {
                    Toast.makeText(ClientActivity.this, "请先点击bind,建立链接", Toast.LENGTH_SHORT).show();
                } else {
                    try {
                        Toast.makeText(ClientActivity.this, "注册监听成功", Toast.LENGTH_SHORT).show();
                        mRemoteService.registerListener(completedListener);
                    } catch (RemoteException e) {
                        e.printStackTrace();
                    }
                }
                break;
            case R.id.btn_operate:
                /**
                 * 调用Service异步方法
                 */
                if (mRemoteService == null) {
                    Toast.makeText(ClientActivity.this, "请先点击bind,建立链接", Toast.LENGTH_SHORT).show();
                } else {
                    try {
                        Log.e("aaa", "送入数据");
                        MyData myData = new MyData(2, 88);
                        mRemoteService.operation(myData);
                    } catch (RemoteException e) {
                        e.printStackTrace();
                    }
                }
                break;
            case R.id.btn_un_register:
                /**
                 * 取消监听
                 */
                if (mRemoteService == null) {
                    Toast.makeText(ClientActivity.this, "请先点击bind,建立链接", Toast.LENGTH_SHORT).show();
                } else {
                    try {
                        mRemoteService.unregisterListener(completedListener);
                    } catch (RemoteException e) {
                        e.printStackTrace();
                    }
                }
                break;
        }
    }


    public void clickHandler(View view) {
        switch (view.getId()) {
            case R.id.btn_bind:
                bindRemoteService();
                break;

            case R.id.btn_unbind:
                unbindRemoteService();
                break;

            case R.id.btn_kill:
                killRemoteService();
                break;
        }
    }

    /**
     * 绑定远程服务
     */
    private void bindRemoteService() {
        Log.i(TAG, "[ClientActivity] bindRemoteService");
        Intent intent = new Intent(ClientActivity.this, RemoteService.class);
        intent.setAction(IRemoteService.class.getName());
        bindService(intent, mConnection, Context.BIND_AUTO_CREATE);

        mIsBound = true;
        mCallBackTv.setText("binding中");
    }

    /**
     * 解除绑定远程服务
     */
    private void unbindRemoteService() {
        if (!mIsBound) {
            return;
        }
        Log.i(TAG, "[ClientActivity] unbindRemoteService ==>");
        unbindService(mConnection);
        mIsBound = false;
        mCallBackTv.setText("unbinding...");
    }


    /**
     * 杀死远程服务
     */
    private void killRemoteService() {
        Log.i(TAG, "[ClientActivity] killRemoteService");
        try {
            android.os.Process.killProcess(mRemoteService.getPid());
            mCallBackTv.setText("kill success");
        } catch (RemoteException e) {
            e.printStackTrace();
            Toast.makeText(ClientActivity.this, "kill failure", Toast.LENGTH_SHORT).show();
        }
    }

}

小结

大家可以参考demo和上面的流程图来理清下两进程间通信的流程。这样有助于后面的源码理解,这边为了方便阅读，只贴出了部分功能代码。在下一章为大家带来binder原理相关的解析。

工欲善其事，必先利其器。既然要读源码，那我们必须要先准备好相应的源码吧。

首先看下Android系统的架构图

我们可以看到binder驱动在kernel层,接下来的系列文章里，会讲解binder如何从应用层到framework层再到kernel层的整个链路。话不多说。给大家推荐下源码下载的地址。

注：Binder系列文章 framework 源码使用 android10 release 分支，kernel 部分使用 common 的 android-4.9-q-release 分支。

源码涉及目录

/framework/base/core/java/               (Java)
/framework/base/core/jni/                (JNI)
/framework/native/libs/binder            (Native)
/framework/native/cmds/servicemanager/   (Native)
/kernel/drivers/staging/android          (Driver)

Java framework

/framework/base/core/java/android/os/  
    - IInterface.java
    - IBinder.java
    - Parcel.java
    - IServiceManager.java
    - ServiceManager.java
    - ServiceManagerNative.java
    - Binder.java  


/framework/base/core/jni/    
    - android_os_Parcel.cpp
    - AndroidRuntime.cpp
    - android_util_Binder.cpp (核心类)

Native framework

/framework/native/libs/binder         
    - IServiceManager.cpp
    - BpBinder.cpp
    - Binder.cpp
    - IPCThreadState.cpp (核心类)
    - ProcessState.cpp  (核心类)

/framework/native/include/binder/
    - IServiceManager.h
    - IInterface.h

/framework/native/cmds/servicemanager/
    - service_manager.c
    - binder.c

Kernel

kernel/drivers/android
    - binder.c

源码下载

https://github.com/hughcoder/ByteAdvance

持续更新 敬请期待

参考

gityuan 的binder代码分析

soso密斯密斯
关注
专栏目录
【实践篇】Android中AIDL使用
terase梅
12-06 950
Binder的前身是OpenBinder，它是一种通过提供远程过程调用（RPC）功能进程间通信的机制，是Android系统中的重要组成部分。在Android系统的Binder机制中，由一系统组件组成，分别是：Client、Server、ServiceManager和binder驱动。其中Client、Server和ServiceManager运行在用户空间，binder驱动运行在内核空间，binder驱动程序是核心组件，ServiceManager提供管理功能，Client和Server在binder驱动和
Android进程间通信-AIDL的使用
weixin_39520007的博客
11-17 519
Android常用的进程通讯方式 进程：一般指一个执行单元，在PC和移动设备上指一个程序或一个应用，一个进程可以包含多个线程。Android系统底层是基于Linux的，每个进程都有自己的虚拟内存空间，因此无法直接操作其他进程的内存空间，但进程间通信（Inter-Process Communication IPC）又是不可避免的，而Android系统为我们提供了这么几种常用方式： Bundle：通过...
Android~AIDL完成跨进程通信（AIDL文件解析）
~~~的博客
06-10 757
一、如何使用AIDL文件来完成跨进程通信?        AIDL的作用，就是让两个不同的应用间通过Service进行通信（进程通讯IPC），并且远程的Service可以处理多线程。简单来讲就是，两个应用，一个应用对外提供一个远程Service，其他的应用可以并发地访问这个Service，即：C/S模式。 二、AIDL 的编写主要为以下三部分：        创建一个A
进程间通讯：Binder：AIDL
C++ JAVA的专栏
11-29 510
AIDL是Android Interface Description Languaged 简写。用于描写客户端/服务端通信接口的一种描述语言。其实说人话就是通过定义aidl接口来生成第二章中的代理类。即AIDL的原理其实跟上一章的代理模式优化Binder的使用是一样的。目的就是为了省去我们自己编写代理的代码。 1.定义AIDL接口 package com.zhpan.sample.binder.aidl; // Declare any non-default types here with impo
android 中 aidl和binder 跨进程通讯
Deaht_Huimie的博客
05-24 213
以前写过一个service的远程快进程调用，https://blog.csdn.net/Deaht_Huimie/article/details/52693191， 这一篇文章介绍的比较粗浅。 如果是两个app之间通讯，则两个app中的aidl需要一样，包括包名，通过绑定service和 ServiceConnection 来实现通讯，用法和一个app内跨进程通讯一样，这方面网上也有许多介绍。我...
Binder之AIDL进程间通信的使用（附源码）
热门推荐
魔法少女厄加特的博客
05-07 2万+
废话不多说，先看代码，再讲原理。 首先我们先搞两个进程出来，一个作为客户端（client）一个作为服务端（service）。 在客户端和服务的分别创建一个AIDL接口，可以用如下方式进行创建，需要注意的是，两端创建的接口必须保证完全一致，包括他们的包名，这里的包名可能需要手动去修改一下，不一致的话运行时会抛出如下异常 “Binder invocation to an incorrect inter...
Android+ 进程间通信+ Binder驱动原理+ AIDL
09-28
传统的IPC通信需要在用户空间和内核空间之间进行两次数据拷贝，而Binder通过内核支持的直接通信通道，只需要一次拷贝，提高了效率。例如，在服务端，当客户端发起查询请求时，服务端的Binder对象通过onTransact()...
Android平台必备技能（一）---进程间通信AIDL的应用详解
格物致知的专栏
12-20 936
一些必备的背景知识，理解以下知识将有助于编写AIDL通信流程。 1. AIDL是什么？ AIDL:Android Interface Definition Language,即Android接口定义语言。即Android平台上使用的IDL交互式数据语言，定义了Android平台IPC的模板。 2. AIDL的语法？ 2.1) AIDL文件以 .aidl 为后缀名； ...
Android平台必备技能（一）---进程间通信AIDL接口回调
格物致知的专栏
06-21 584
先回顾一下aidl的使用方法，可以参考上篇介绍的AIDL怎么用，链接如下： Server端： 创建aidl接口文件以及数据（Parcelable）文件； 创建service文件，在AndroidManifest中声明action； 3、在service文件中添加IxxxInterface.Stub, 以及对应aidl接口实现，例如： private IMediaShareInterface.Stub mIMediaShareMgr = new IMediaShareInterface....
Android IPC进程间通信，Binder机制原理及AIDL实例
csdn_aiyang的博客
08-12 3586
我们知道，Android的底层是使用Linux内核运行的，而Linux为了保证系统的稳定性，使用的是进程隔离的机制，也就是让不同的进程运行在不同的虚拟空间，使得不同进程之间无法共享数据，防止数据的篡改。关于多进程的基础使用及优缺点的介绍链接中已经讲的很清楚了。但是，有时候我们也会遇到不同进程间需要通信的情况，那么，这时候就需要使用Android系统进程间通信IPC（Inter-Process Communication)。
（原创）使用aidl进程间通讯并开启独立进程的服务仿下载监听回调等场景
10-21
（原创）使用aidl进程间通讯并开启独立进程的服务仿下载监听回调等场景，博客链接：http://blog.csdn.net/lnn368/article/details/52882841
AIDL最全Demo
05-09
目前我使用过的AIDL，主要可以分为三大场景：普通AIDL、带有远程回调接口的AIDL和需要引用自定义Parcelable的AIDL，针对三类场景我分别写了个例子。
使用binder-AIDL进行跨进程通信
weixin_34234823的博客
06-13 115
为什么80%的码农都做不了架构师？>>> ...
【Android】使用Binder实现进程间通讯简单案例
little_fat_sheep
09-18 2418
1 前言 使用AIDL实现进程间通讯简单案例和使用AIDL实现进程间传递对象案例中介绍了使用 AIDL 进行进程间通讯，文中提到在编写完 aidl 文件（如：IMessageManager.aidl）并 Make Buidl 后，会生成一个接口（如：IMessageManager.java），接口中包含一个静态抽象内部类 Stub，Stub 中又包含一个静态内部类 Proxy，Stub 和 Proxy 都实现了此接口，同时 Stub 继承了 Binder 类。本文将从 IMessageManager...
aidl的应用场景
weixin_30647065的博客
10-25 649
支付宝 package com.tesy.alipay; import com.test.alipay.Iservice.Stub; import android.app.Service; import android.content.Intent; import android.os.Binder; import android.os.IBinder; public...
AIDL使用方法总结
安卓开发-顺 的博客
06-07 1433
一、AIDL使用步骤（Android studio环境）场景：应用B要调用应用A中的方法。应用A中要做的事情：（1）src下 右键创建一个aidl文件，提供一个打印日志的方法，编码方式类似java，如图：刷新或重新编译一下会生成对应的java文件如图：（2）新建AIDLService.java类，该类继承Service类，类名可自定义。 package com.example.zhangsh
android AIDL的使用
weixin_36965072的博客
11-07 268
在Android中，一个进程通常无法访问另一个进程的内存。为了进程间的通信，进程需要将其对象分解成可供操作系统理解的语言，将其编组为可更操作的对象，编写执行该编组操作的代码较为繁琐，因此Android会使用AIDL为我们处理此问题。
IPC、Binder及AIDL原理机制
duncan891101的专栏
08-04 362
一、IPC介绍 IPC是Inter-Process Communication的缩写，含义是进程间通信或者跨进程通信，是指两个进程之间进行数据交换的过程。那么为什么需要开启多进程呢？原因有二，其一是一个应用因为某些原因需要独立运行在某个进程中。其二可能是加大一个应用可使用的内存空间，早期的一些版本，一个进程最大的内存空间是16MB。 1、Android中开启多进程 Android中开启多进程的方法只有一个，那就是给四大组件在Manifest中指定android:process属性，除此之外没有其他办法，也就
AIDL 详细介绍及使用
最新发布
u013773608的博客
03-20 6517
从某种意义上说AIDL其实是一个模板，因为在使用过程中，实际起作用的并不是AIDL文件，而是据此而生成的一个IInterface的实例代码，AIDL其实是为了避免我们重复编写代码而出现的一个模板。方法入手，在上面的代码中可以看到，主要的作用就是根据传入的Binder对象转换成客户端需要的 IMyAidlInterface 接口。服务端的代码差不多就这些，下面我们来看看客户端的，客户端也是需要 AIDL 文件的，可以从服务端中复制过来。看完上面方法的介绍，我们回过头来看看 AIDL 例子中实现的流程。
Android Binder深度解析：进程通信的关键
AIDL（Android Interface Definition Language）是使用Binder进行跨进程通信的一种工具，它允许开发者定义接口，使得客户端和服务端可以透明地进行数据交换。 理解Binder的原理对于深入掌握Android系统，特别是涉及...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值