精华内容
下载资源
问答
  • Android跨进程通信Binder、Messenger、AIDL汇总,代码包含服务端和客户端。一站式解决。
  • Android 跨进程通信大总结

    千次阅读 2020-12-22 16:04:55
    文章目录1、Android进程2、修改Android默认进程3、指定activity、Service进程 1、Android进程 android { compileSdkVersion 29 buildToolsVersion "29.0.3" defaultConfig { applicationId "com.zhaoyanjun" ...

    转载请标明出处:http://blog.csdn.net/zhaoyanjun6/article/details/111553746
    本文出自【赵彦军的博客】

    1、Android进程

    android {
        compileSdkVersion 29
        buildToolsVersion "29.0.3"
    
        defaultConfig {
            applicationId "com.zhaoyanjun"
            minSdkVersion 16
            targetSdkVersion 29
            versionCode 1
            versionName "1.0"
        }
    }    
    

    applicationId 为:com.zhaoyanjun,那项目运行起来,所有的 activityservice 默认运行在 com.zhaoyanjun 进程.

    工具类:

    package com.zhaoyanjun;
    
    import java.io.FileInputStream;
    import java.io.IOException;
    
    /**
     * @author yanjun.zhao
     * @time 2020/12/16 11:01 AM
     * @desc
     */
    public class Process {
    
        /**
         * 获取当前进程名
         * @return
         */
        public static String getCurrentProcessName() {
            FileInputStream in = null;
            try {
                String fn = "/proc/self/cmdline";
                in = new FileInputStream(fn);
                byte[] buffer = new byte[256];
                int len = 0;
                int b;
                while ((b = in.read()) > 0 && len < buffer.length) {
                    buffer[len++] = (byte) b;
                }
                if (len > 0) {
                    String s = new String(buffer, 0, len, "UTF-8");
                    return s;
                }
            } catch (Throwable e) {
                e.printStackTrace();
            } finally {
                if (in != null) {
                    try {
                        in.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
            return null;
        }
    }
    

    2、修改Android默认进程

    <?xml version="1.0" encoding="utf-8"?>
    <manifest xmlns:android="http://schemas.android.com/apk/res/android"
        package="com.zhaoyanjun">
    
        <application
            android:process=":appProcess"
            android:allowBackup="true"
            android:icon="@mipmap/ic_launcher"
            android:label="@string/app_name"
            android:roundIcon="@mipmap/ic_launcher_round"
            android:supportsRtl="true"
            android:theme="@style/Theme.RecyclerViewDemo">
            <activity android:name=".MainActivity">
                <intent-filter>
                    <action android:name="android.intent.action.MAIN" />
    
                    <category android:name="android.intent.category.LAUNCHER" />
                </intent-filter>
            </activity>
            
        </application>
    </manifest>
    

    在 application 标签下添加 android:process 属性可以修改Android默认的进程名字。进程的名字为:com.zhaoyanjun:appProcess , 这个修改是全局的,所有 activity 都默认运行在这个进程中。

    3、指定activity、Service进程

    activity 指定进程

    <activity
        android:process=":remote"
        android:name=".MainActivity2">
    </activity>
    

    在这里插入图片描述
    service 指定进程

    <service
        android:process=":remote_service"
        android:name=".LibraryService">
    </service>
    

    在这里插入图片描述

    4、activity进程间通信

    MainActivity有一个 button 按钮,点击跳转到 MainActivity2

    //MainActivity代码
    findViewById<Button>(R.id.bt1).setOnClickListener {
          var intent = Intent(this, MainActivity2::class.java)
          intent.putExtra("key", "value1")
          startActivity(intent)
    }
    

    MainActivity2 指定进程

    <activity
        android:process=":remote"
        android:name=".MainActivity2">
    </activity>
    

    MainActivity2 逻辑

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main2)
    
        var value = intent.getStringExtra("key")
        Log.d("zhaoyanjun", "MainActivity2 进程: ${Process.getCurrentProcessName()} 获取值: $value")
    }
    

    日志:

    D/zhaoyanjun: MainActivity2 进程: com.zhaoyanjun:remote 获取值: value1
    

    5、AIDL 简介

    AIDL的语法十分简单,与Java语言基本保持一致,需要记住的规则有以下几点:

    1、AIDL文件以 .aidl 为后缀名

    2、 AIDL支持的数据类型分为如下几种:

    • 八种基本数据类型:bytecharshortintlongfloatdoubleboolean
      StringCharSequence
    • 实现了Parcelable接口的数据类型
    • List 类型。List承载的数据必须是AIDL支持的类型,或者是其它声明的AIDL对象
    • Map类型。Map承载的数据必须是AIDL支持的类型,或者是其它声明的AIDL对象

    3、AIDL文件可以分为两类。一类用来声明实现了Parcelable接口的数据类型,以供其他AIDL文件使用那些非默认支持的数据类型。还有一类是用来定义接口方法,声明要暴露哪些接口给客户端调用,定向Tag就是用来标注这些方法的参数值。

    3、定向Tag。定向Tag表示在跨进程通信中数据的流向,用于标注方法的参数值,分为 in、out、inout 三种。

    • 其中 in 表示数据只能由客户端流向服务端,
    • out 表示数据只能由服务端流向客户端,而 inout 则表示数据可在服务端与客户端之间双向流通。此外,如果AIDL方法接口的参数值类型是:基本数据类型、String、CharSequence或者其他AIDL文件定义的方法接口,那么这些参数值的定向 Tag 默认是且只能是 in,所以除了这些类型外,其他参数值都需要明确标注使用哪种定向Tag。定向Tag具体的使用差别后边会有介绍

    4、明确导包。在AIDL文件中需要明确标明引用到的数据类型所在的包名,即使两个文件处在同个包名下

    6、activity、service 进程间通信 AIDL

    创建 IBookAidlInterface.aidl文件 在这里插入图片描述
    创建 IBookAidlInterface 完成后,会在 main 目录下,创建 aidl 文件夹,并且会创建同名的包名,如下:
    在这里插入图片描述
    我们把默认的 basicTypes 方法删除,修改如下

    interface IBookAidlInterface {
        String getTitle();
        void setTitle(String title);
    }
    

    下面创建 Service , 并指定进程名字:

     <service
         android:name=".MyService"
         android:enabled="true"
         android:exported="true"
         android:process=":remote" />
    

    MyService 如下:

    class MyService : Service() {
    
        private var binder: Binder = object : IBookAidlInterface.Stub() {
    
            override fun getTitle(): String {
                return "aidl->title"
            }
    
            override fun setTitle(title: String?) {
                Log.d("aidl", "service-setTitle:$title")
            }
        }
    
        override fun onBind(intent: Intent): IBinder {
            return binder
        }
    
        override fun onCreate() {
            super.onCreate()
        }
    }
    

    MainActivity 绑定Service

    class MainActivity : AppCompatActivity() {
    
        private var iBookAidlInterface: IBookAidlInterface? = null
    
        private var serviceConnection: ServiceConnection = object : ServiceConnection {
            override fun onServiceDisconnected(name: ComponentName?) {
    
            }
    
            override fun onServiceConnected(name: ComponentName?, service: IBinder?) {
                iBookAidlInterface = IBookAidlInterface.Stub.asInterface(service)
                var name = iBookAidlInterface?.title
                Log.d("aidl", "getTitle: $name")
                iBookAidlInterface?.title = "我是一个title"
            }
        }
    
        override fun onCreate(savedInstanceState: Bundle?) {
            super.onCreate(savedInstanceState)
            setContentView(R.layout.activity_main)
            bindService()
        }
    
        /**
         * 绑定服务
         */
        private fun bindService() {
            var intent = Intent(this, MyService::class.java)
            bindService(intent, serviceConnection, Context.BIND_AUTO_CREATE)
        }
    
        override fun onDestroy() {
            super.onDestroy()
            unbindService(serviceConnection)
        }
    }
    

    运行项目,日志如下:
    在这里插入图片描述
    在这里插入图片描述
    可以看到,子进程 Service 和 主进程的 Activity 已经可以通信了。
    github 地址:https://github.com/zyj1609wz/AndroidMultiProgress

    7、AIDL 传递复杂对象

    首先创建 Book 类,并且实现 Parcelable 接口。这里要注意,一定要实现 Parcelable 接口,因为只有实现 Parcelable 的复杂对象才能在 AIDL 中传递。

    public class Book implements Parcelable {
    
        public String title;
    
        Book() {
    
        }
    
        protected Book(Parcel in) {
            title = in.readString();
        }
    
        @Override
        public void writeToParcel(Parcel dest, int flags) {
            dest.writeString(title);
        }
    
        @Override
        public int describeContents() {
            return 0;
        }
    
        public static final Creator<Book> CREATOR = new Creator<Book>() {
            @Override
            public Book createFromParcel(Parcel in) {
                return new Book(in);
            }
    
            @Override
            public Book[] newArray(int size) {
                return new Book[size];
            }
        };
    }
    
    

    同时在 aidl 目录中定义 Book.aidl 文件,并且声明 parcelable 属性。Book.aidl文件如下:

    package com.yanjun.progress;
    
    parcelable Book;
    

    下面我们修改 IBookAidlInterface.aidl 的方法,如下:

    interface IBookAidlInterface {
         String getTitle();
         void setTitle(String title);
         Book getBook();
         void setBook(in Book book);
    }
    

    需要注意的是 setBook方法,一定要声明 Book 对象是 in属性,表明是 book 对象是从客户端流向服务端。

    最后在 Service 里面实现接口就行了,如下:

    class MyService : Service() {
    
        private var binder: Binder = object : IBookAidlInterface.Stub() {
    
            override fun getTitle(): String {
                return "aidl->title"
            }
    
            override fun setTitle(title: String?) {
                Log.d("aidl", "service-setTitle:$title")
            }
    
            override fun getBook(): Book {
                var book = Book()
                book.title = "书的名字"
                return book
            }
    
            override fun setBook(book: Book?) {
    
            }
        }
    
        override fun onBind(intent: Intent): IBinder ?{
            return binder
        }
    
        override fun onCreate() {
            super.onCreate()
        }
    }
    

    demo github 地址:https://github.com/zyj1609wz/AndroidMultiProgress

    8、SharedPreferences 跨进程

    SharedPreferences要实现跨进程通信,要遵循文件名字相同的规则。而且是同一个应用,两个进程间。
    SharedPreferences之所以能实现跨进程,是因为SharedPreferences 数据存在SD卡的磁盘中,两个进程共用一个文件。

    注意事项:

    • 虽然 SharedPreferences 可以实现跨进程,但是 Google 官方不建议使用,因为 Google 认为多个进程读同一个文件都是不安全的,Android 不保证该模式总是能正确的工作,建议使用 ContentProvider 替代多进程之间文件的共享。

    额外话题 SharedPreferences 优化:

    • commit 是把内容同步提交到硬盘的,返回 boolean 表明修改是否提交成功
    • apply先立即把修改提交到内存,然后开启一个异步的线程提交到硬盘,并且如果提交失败,你不会收到任何通知,apply没有返回值 。
    • 使用了apply方式异步写sp的时候,每次apply()调用都会新增一个finisher。在有些系统生命周期事件发生的时候都会去检查已经提交的apply写操作是否完成,如果没有完成则阻塞主线程,造成 ANR
    • 当一个文件较大时,首次读取可能会较慢,每次写入也会较慢
    • 在不同模块使用多个文件存储的情况下,那么未被使用到的模块,不会被读取进内存
    • 当存储的valuejson或者html形式时,由于特殊符号较多,会占用更多的字符

    如何解决 ANR :

    • 如果处理 SP的时候,使用commit方法替代apply,在保证调用时线程正确处理,并保证同一文件不使用多个线程写入的情况下,不会出现该ANR
    • 自查是否有一下子修改多个key-valueapply多次的情况,如有,可合并为put多次但apply一次

    9、广播跨进程

    Context.sendBroadcast()
    发送的是普通广播,所有订阅者都有机会获得并进行处理

    10、ContentProvider跨进程

    什么是ContentProvider ?

    即 内容提供者,是 Android 四大组件之一

    ContentProvider什么作用?

    进程间 进行数据交互 & 共享,即跨进程通信

    在这里插入图片描述

    ContentProvider原理

    ContentProvider的底层原理 = Android中的Binder机制

    ContentProvider优秀文章链接

    本来是想总结一下的,但是我发现了一篇写的很好的文章:
    建议把文章和评论都看看,很有收获。

    Android:关于ContentProvider的知识都在这里了!
    Android中使用Contentprovider导致进程被杀死

    11、Socket跨进程通信

    优点:

    • 功能强大,可通过网络传输字节流,支持一对多实时并发通信

    缺点:

    • 实现细节步骤稍繁琐,不支持直接的RPC

    适用场景:

    • 网络间的数据交换

    12、文件共享跨进程

    优点

    • 简单易用

    缺点:

    • 不适用高并发场景,并且无法做到进程间即时通信

    适用场景:

    • 适用于无关发的情况下,交换简单的数据,对实时性要求不高的场景。

    13、Bundle跨进程

    优点

    • 简单易用

    缺点:

    • 只能传输Bundle支持的数据类型

    适用场景:

    • 四大组件间的进程间通信

    14、MMKV

    MMKV是国内微信团队开源的高性能 key-value组件,良好的支持Android跨进程通信,具体使用方法就自己看文档吧,这里不赘述了。

    github: https://github.com/Tencent/MMKV/
    中文文档:MMKV中文文档

    展开全文
  • Android跨进程通信:图文详解 Binder机制 原理

    万次阅读 多人点赞 2017-06-22 10:31:24
    如果你接触过 跨进程通信 (IPC),那么你对Binder一定不陌生 虽然 网上有很多介绍 Binder的文章,可是存在一些问题:浅显的讨论Binder机制 或 一味讲解 Binder源码、逻辑不清楚,最终导致的是读者们还是无法形成一...

    前言

    • 如果你接触过 跨进程通信 (IPC),那么你对Binder一定不陌生
    • 虽然 网上有很多介绍 Binder的文章,可是存在一些问题:浅显的讨论Binder机制 或 一味讲解 Binder源码、逻辑不清楚,最终导致的是读者们还是无法形成一个完整的Binder概念
    • 本文采用 清晰的图文讲解方式,按照 大角度 -> 小角度 去分析Binder,即:
      1. 先从 机制、模型的角度 去分析 整个Binder跨进程通信机制的模型
      2. 再 从源码实现角度,分析 BinderAndroid中的具体实现

    从而全方位地介绍 Binder,希望你们会喜欢。

    请尽量在PC端而不要在移动端看,否则图片可能看不清。


    目录

    目录


    1. Binder到底是什么?

    • 中文即 粘合剂,意思为粘合了两个不同的进程

    • 网上有很多对Binder的定义,但都说不清楚:Binder是跨进程通信方式、它实现了IBinder接口,是连接 ServiceManager的桥梁blabla,估计大家都看晕了,没法很好的理解

    • 我认为:对于Binder的定义,在不同场景下其定义不同

    定义

    在本文的讲解中,按照 大角度 -> 小角度 去分析Binder,即:

    • 先从 机制、模型的角度 去分析 整个Binder跨进程通信机制的模型

    其中,会详细分析模型组成中的 Binder驱动

    • 再 从源码实现角度,分析 BinderAndroid中的具体实现

    从而全方位地介绍 Binder,希望你们会喜欢。


    2. 知识储备

    在讲解Binder前,我们先了解一些Linux的基础知识

    2.1 进程空间划分

    • 一个进程空间分为 用户空间 & 内核空间(Kernel),即把进程内 用户 & 内核 隔离开来
    • 二者区别:
      1. 进程间,用户空间的数据不可共享,所以用户空间 = 不可共享空间
      2. 进程间,内核空间的数据可共享,所以内核空间 = 可共享空间

    所有进程共用1个内核空间

    • 进程内 用户空间 & 内核空间 进行交互 需通过 系统调用,主要通过函数:
    1. copy_from_user():将用户空间的数据拷贝到内核空间
    2. copy_to_user():将内核空间的数据拷贝到用户空间

    示意图

    2.2 进程隔离 & 跨进程通信( IPC )

    • 进程隔离
      为了保证 安全性 & 独立性,一个进程 不能直接操作或者访问另一个进程,即Android的进程是相互独立、隔离的

    • 跨进程通信( IPC
      即进程间需进行数据交互、通信

    • 跨进程通信的基本原理

    示意图

    a. 而Binder的作用则是:连接 两个进程,实现了mmap()系统调用,主要负责 创建数据接收的缓存空间 & 管理数据接收缓存
    b. 注:传统的跨进程通信需拷贝数据2次,但Binder机制只需1次,主要是使用到了内存映射,具体下面会详细说明

    2.5 内存映射

    具体请看文章:操作系统:图文详解 内存映射


    3. Binder 跨进程通信机制 模型

    3.1 模型原理图

    Binder 跨进程通信机制 模型 基于 Client - Server 模式
    示意图

    3.2 模型组成角色说明

    示意图

    此处重点讲解 Binder驱动的作用 & 原理:

    • 简介

    示意图

    • 跨进程通信的核心原理

    关于其核心原理:内存映射,具体请看文章:操作系统:图文详解 内存映射

    示意图

    3.3 模型原理步骤说明

    示意图

    3.4 额外说明

    说明1:Client进程、Server进程 & Service Manager 进程之间的交互 都必须通过Binder驱动(使用 openioctl文件操作函数),而非直接交互

    原因:

    1. Client进程、Server进程 & Service Manager进程属于进程空间的用户空间,不可进行进程间交互
    2. Binder驱动 属于 进程空间的 内核空间,可进行进程间 & 进程内交互

    所以,原理图可表示为以下:

    虚线表示并非直接交互

    示意图

    说明2: Binder驱动 & Service Manager进程 属于 Android基础架构(即系统已经实现好了);而Client 进程 和 Server 进程 属于Android应用层(需要开发者自己实现)

    所以,在进行跨进程通信时,开发者只需自定义Client & Server 进程 并 显式使用上述3个步骤,最终借助 Android的基本架构功能就可完成进程间通信

    示意图

    说明3:Binder请求的线程管理
    • Server进程会创建很多线程来处理Binder请求
    • Binder模型的线程管理 采用Binder驱动的线程池,并由Binder驱动自身进行管理

    而不是由Server进程来管理的

    • 一个进程的Binder线程数默认最大是16,超过的请求会被阻塞等待空闲的Binder线程。

    所以,在进程间通信时处理并发问题时,如使用ContentProvider时,它的CRUD(创建、检索、更新和删除)方法只能同时有16个线程同时工作


    • 至此,我相信大家对Binder 跨进程通信机制 模型 已经有了一个非常清晰的定性认识
    • 下面,我将通过一个实例,分析Binder跨进程通信机制 模型在 Android中的具体代码实现方式

    即分析 上述步骤在Android中具体是用代码如何实现的


    4. Binder机制 在Android中的具体实现原理

    • Binder机制在 Android中的实现主要依靠 Binder类,其实现了IBinder 接口

    下面会详细说明

    • 实例说明:Client进程 需要调用 Server进程的加法函数(将整数a和b相加)

    即:

    1. Client进程 需要传两个整数给 Server进程
    2. Server进程 需要把相加后的结果 返回给Client进程
    • 具体步骤
      下面,我会根据Binder 跨进程通信机制 模型的步骤进行分析

    步骤1:注册服务

    • 过程描述
      Server进程 通过Binder驱动 向 Service Manager进程 注册服务
    • 代码实现
      Server进程 创建 一个 Binder 对象
    1. Binder 实体是 Server进程 在 Binder 驱动中的存在形式
    2. 该对象保存 ServerServiceManager 的信息(保存在内核空间中)
    3. Binder 驱动通过 内核空间的Binder 实体 找到用户空间的Server对象
    • 代码分析
        
        Binder binder = new Stub();
        // 步骤1:创建Binder对象 ->>分析1
    
        // 步骤2:创建 IInterface 接口类 的匿名类
        // 创建前,需要预先定义 继承了IInterface 接口的接口 -->分析3
        IInterface plus = new IPlus(){
    
              // 确定Client进程需要调用的方法
              public int add(int a,int b) {
                   return a+b;
             }
    
              // 实现IInterface接口中唯一的方法
              public IBinder asBinder(){ 
                    return null ;
               }
    };
              // 步骤3
              binder.attachInterface(plus,"add two int");
             // 1. 将(add two int,plus)作为(key,value)对存入到Binder对象中的一个Map<String,IInterface>对象中
             // 2. 之后,Binder对象 可根据add two int通过queryLocalIInterface()获得对应IInterface对象(即plus)的引用,可依靠该引用完成对请求方法的调用
            // 分析完毕,跳出
    
    
    <-- 分析1:Stub类 -->
        public class Stub extends Binder {
        // 继承自Binder类 ->>分析2
    
              // 复写onTransact()
              @Override
              boolean onTransact(int code, Parcel data, Parcel reply, int flags){
              // 具体逻辑等到步骤3再具体讲解,此处先跳过
              switch (code) { 
                    case Stub.add: { 
    
                           data.enforceInterface("add two int"); 
    
                           int  arg0  = data.readInt();
                           int  arg1  = data.readInt();
    
                           int  result = this.queryLocalIInterface("add two int") .add( arg0,  arg1); 
    
                            reply.writeInt(result); 
    
                            return true; 
                      }
               } 
          return super.onTransact(code, data, reply, flags); 
    
    }
    // 回到上面的步骤1,继续看步骤2
    
    <-- 分析2:Binder 类 -->
     public class Binder implement IBinder{
        // Binder机制在Android中的实现主要依靠的是Binder类,其实现了IBinder接口
        // IBinder接口:定义了远程操作对象的基本接口,代表了一种跨进程传输的能力
        // 系统会为每个实现了IBinder接口的对象提供跨进程传输能力
        // 即Binder类对象具备了跨进程传输的能力
    
            void attachInterface(IInterface plus, String descriptor);
            // 作用:
              // 1. 将(descriptor,plus)作为(key,value)对存入到Binder对象中的一个Map<String,IInterface>对象中
              // 2. 之后,Binder对象 可根据descriptor通过queryLocalIInterface()获得对应IInterface对象(即plus)的引用,可依靠该引用完成对请求方法的调用
    
            IInterface queryLocalInterface(Stringdescriptor) ;
            // 作用:根据 参数 descriptor 查找相应的IInterface对象(即plus引用)
    
            boolean onTransact(int code, Parcel data, Parcel reply, int flags);
            // 定义:继承自IBinder接口的
            // 作用:执行Client进程所请求的目标方法(子类需要复写)
            // 参数说明:
            // code:Client进程请求方法标识符。即Server进程根据该标识确定所请求的目标方法
            // data:目标方法的参数。(Client进程传进来的,此处就是整数a和b)
            // reply:目标方法执行后的结果(返回给Client进程)
             // 注:运行在Server进程的Binder线程池中;当Client进程发起远程请求时,远程请求会要求系统底层执行回调该方法
    
            final class BinderProxy implements IBinder {
             // 即Server进程创建的Binder对象的代理对象类
             // 该类属于Binder的内部类
            }
            // 回到分析1原处
    }
    
    <-- 分析3:IInterface接口实现类 -->
    
     public interface IPlus extends IInterface {
              // 继承自IInterface接口->>分析4
              // 定义需要实现的接口方法,即Client进程需要调用的方法
             public int add(int a,int b);
    // 返回步骤2
    }
    
    <-- 分析4:IInterface接口类 -->
    // 进程间通信定义的通用接口
    // 通过定义接口,然后再服务端实现接口、客户端调用接口,就可实现跨进程通信。
    public interface IInterface
    {
        // 只有一个方法:返回当前接口关联的 Binder 对象。
        public IBinder asBinder();
    }
      // 回到分析3原处
    

    注册服务后,Binder驱动持有 Server进程创建的Binder实体

    步骤2:获取服务

    • Client进程 使用 某个 service前(此处是 相加函数),须 通过Binder驱动 向 ServiceManager进程 获取相应的Service信息
    • 具体代码实现过程如下:

    示意图

    此时,Client进程与 Server进程已经建立了连接

    步骤3:使用服务

    Client进程 根据获取到的 Service信息(Binder代理对象),通过Binder驱动 建立与 该Service所在Server进程通信的链路,并开始使用服务

    • 过程描述

      1. Client进程 将参数(整数a和b)发送到Server进程
      2. Server进程 根据Client进程要求调用 目标方法(即加法函数)
      3. Server进程 将目标方法的结果(即加法后的结果)返回给Client进程
    • 代码实现过程

    步骤1: Client进程 将参数(整数a和b)发送到Server进程

    // 1. Client进程 将需要传送的数据写入到Parcel对象中
    // data = 数据 = 目标方法的参数(Client进程传进来的,此处就是整数a和b) + IInterface接口对象的标识符descriptor
      android.os.Parcel data = android.os.Parcel.obtain();
      data.writeInt(a); 
      data.writeInt(b); 
    
      data.writeInterfaceToken("add two int");;
      // 方法对象标识符让Server进程在Binder对象中根据"add two int"通过queryLocalIInterface()查找相应的IInterface对象(即Server创建的plus),Client进程需要调用的相加方法就在该对象中
    
      android.os.Parcel reply = android.os.Parcel.obtain();
      // reply:目标方法执行后的结果(此处是相加后的结果)
    
    // 2. 通过 调用代理对象的transact() 将 上述数据发送到Binder驱动
      binderproxy.transact(Stub.add, data, reply, 0)
      // 参数说明:
        // 1. Stub.add:目标方法的标识符(Client进程 和 Server进程 自身约定,可为任意)
        // 2. data :上述的Parcel对象
        // 3. reply:返回结果
        // 0:可不管
    
    // 注:在发送数据后,Client进程的该线程会暂时被挂起
    // 所以,若Server进程执行的耗时操作,请不要使用主线程,以防止ANR
    
    
    // 3. Binder驱动根据 代理对象 找到对应的真身Binder对象所在的Server 进程(系统自动执行)
    // 4. Binder驱动把 数据 发送到Server 进程中,并通知Server 进程执行解包(系统自动执行)
    
    

    步骤2:Server进程根据Client进要求 调用 目标方法(即加法函数)

    // 1. 收到Binder驱动通知后,Server 进程通过回调Binder对象onTransact()进行数据解包 & 调用目标方法
      public class Stub extends Binder {
    
              // 复写onTransact()
              @Override
              boolean onTransact(int code, Parcel data, Parcel reply, int flags){
              // code即在transact()中约定的目标方法的标识符
    
              switch (code) { 
                    case Stub.add: { 
                      // a. 解包Parcel中的数据
                           data.enforceInterface("add two int"); 
                            // a1. 解析目标方法对象的标识符
    
                           int  arg0  = data.readInt();
                           int  arg1  = data.readInt();
                           // a2. 获得目标方法的参数
                          
                           // b. 根据"add two int"通过queryLocalIInterface()获取相应的IInterface对象(即Server创建的plus)的引用,通过该对象引用调用方法
                           int  result = this.queryLocalIInterface("add two int") .add( arg0,  arg1); 
                          
                            // c. 将计算结果写入到reply
                            reply.writeInt(result); 
                            
                            return true; 
                      }
               } 
          return super.onTransact(code, data, reply, flags); 
          // 2. 将结算结果返回 到Binder驱动
    
    
    

    步骤3:Server进程 将目标方法的结果(即加法后的结果)返回给Client进程

      // 1. Binder驱动根据 代理对象 沿原路 将结果返回 并通知Client进程获取返回结果
      // 2. 通过代理对象 接收结果(之前被挂起的线程被唤醒)
    
        binderproxy.transact(Stub.ADD, data, reply, 0);
        reply.readException();;
        result = reply.readInt();
              }
    }
    
    • 总结
      下面,我用一个原理图 & 流程图来总结步骤3的内容

    原理图

    流程图


    5. 优点

    对比 LinuxAndroid基于Linux)上的其他进程通信方式(管道、消息队列、共享内存、
    信号量、Socket),Binder 机制的优点有:
    示意图


    6. 总结

    • 本文主要详细讲解 跨进程通信模型 Binder机制 ,总结如下:

    定义

    特别地,对于从模型结构组成的Binder驱动来说:

    示意图

    • 整个Binder模型的原理步骤 & 源码分析

    示意图

    Carson带你学Android 文章系列:
    Carson带你学Android:页面活动-Activity
    Carson带你学Android:广播-BroadcastReceiver
    Carson带你学Android:服务-Service
    Carson带你学Android:内存承载器-ContentProvider


    欢迎关注Carson_Ho的CSDN博客 与 公众号!

    博客链接:https://carsonho.blog.csdn.net/


    请帮顶 / 评论点赞!因为你的鼓励是我写作的最大动力!

    展开全文
  • 本框架实现了安卓跨进程跨app通信的方便调用和封装
  • Android跨进程通信传输大数据

    千次阅读 2020-05-14 10:56:04
    Android跨进程通信的方式大概有如下几种: 1.Activity方式: Intent callIntent = new Intent(Intent.ACTION_CALL, Uri.parse("tel:12345678" ); startActivity(callIntent); 2.Content Provider 方式: Android...

    Android跨进程通信的方式大概有如下几种:

    1.Activity方式:

    Intent callIntent = new Intent(Intent.ACTION_CALL, Uri.parse("tel:12345678" ); 
    startActivity(callIntent);
    

    2.Content Provider 方式:

    Android应用程序可以使用文件或SqlLite数据库来存储数据。
    Content Provider提供了一种在多个应用程序之间数据共享的方式(跨进程共享数据),
    应用程序可以利用Content Provider完成下面的工作
    1. 查询数据
    2. 修改数据
    3. 添加数据
    4. 删除数据
    

    3.广播方式:

    Intent intent = new Intent(“com.android.ACTION_TEST);
    intent.putExtra("value","content");
    mContext.sendBroadcast(intent);
    

    4.LocalSocket方式

    客户端LocalSocket代码
    //创建对象
    LocalSocket localSocket = new LocalSocket();
    //连接socketServerSocket
    localSocket.connect(new LocalSocketAddress(String addrStr));
    获取localSocket的输入输出流:
    outputStream = localSocket.getOutputStream();
    inputStream = localSocket.getInputStream();
    写入数据:
    outputStream.write("数据".getBytes());
    循环接收数据:
    try {    
          int readed = inputStream.read();
          int size = 0;
          byte[] bytes = new byte[0];
          while (readed != -1) {
              byte[] copy = new byte[500000]; 
              System.arraycopy(bytes, 0, copy, 0, bytes.length);
              bytes = copy;
              bytes[size++] = (byte) readed; 
              //以换行符标识成结束
              if ('\n' == (byte) readed) {
                  String resultStr = new String(bytes, 0, size); 
                  break;                                                         				     
            } 
           readed = inputStream.read();
        }
    } catch (IOException e) {
            return false;
    }
    
    
    服务端LocalServerSocket代码
    
    //初始化
    try {
        //socketAddress需跟localSocket地址一致,否则无法连接上
        serverSocket = new LocalServerSocket(socketAddress);
    } catch (IOException e) {
        LoggerHelper.e("Server to establish connection exception:" + e.toString());
        e.printStackTrace();
        return false;
    }
    try {
        //获取接收的LocalSocket
        localSocket = serverSocket.accept();
        //设置缓冲大小
        localSocket.setReceiveBufferSize(ConstantConfig.BUFFER_SIZE);
        localSocket.setSendBufferSize(ConstantConfig.BUFFER_SIZE);
    } catch (IOException e) {
        e.printStackTrace();
        LoggerHelper.d("Waiting to be linked to a bug,error:" + e.toString());
        return false;
    }
    获取输入输出流一致:
    
    if (localSocket != null) {
        try {
            inputStream = localSocket.getInputStream();
            outputStream = localSocket.getOutputStream();
            /** 允许一直接收数据,一直到连接被断开,则认为应用端退出,自己也退出 */
            while (isLock && receiveData()) ;
        } catch (IOException e) {
            LoggerHelper.e("Get stream exception:" + e.toString());        e.printStackTrace();
            return false;
        }
    }
    

    5.AIDL Service方式

    这也是本文采取的主要方式,通过AIDL读取共享内存的方式去实现大数据的传输
    5.1首先定义两个AIDL文件,注意服务端和客户端的两个文件要一样,并且放在同一个文件夹下。

    服务端使用
    package com.example.administrator.testgsensor;
    
    import com.example.administrator.testgsensor.ITestCallbackAidlInterface;
    
    // Declare any non-default types here with import statements
    
    interface ITestAidlInterface {
        void registerCallback(ITestCallbackAidlInterface cb);
        void unregisterCallback(ITestCallbackAidlInterface cb);
        ParcelFileDescriptor getMemoryFileDescriptor();
        void serverSendData(String data);
    }
    
    客户端使用
    // ITestCallbackAidlInterface.aidl
    package com.example.administrator.testgsensor;
    
    // Declare any non-default types here with import statements
    
    interface ITestCallbackAidlInterface {
         void clintSenddata(String data);
    }
    
    服务端实现代码
    package com.example.administrator.testgsensor;
    
    import android.app.Service;
    import android.content.Intent;
    import android.os.IBinder;
    import android.os.MemoryFile;
    import android.os.ParcelFileDescriptor;
    import android.os.RemoteCallbackList;
    import android.os.RemoteException;
    import android.util.Log;
    
    import java.io.FileDescriptor;
    import java.io.IOException;
    import java.lang.reflect.Method;
    
    public class TestService extends Service{
    
        private String TAG = "TestService";
        private TestInterface mTestInterface = new TestInterface();
        final RemoteCallbackList<ITestCallbackAidlInterface> mCallbackList = new RemoteCallbackList<ITestCallbackAidlInterface>();
        private MemoryFile mMemoryFile = null;
        private ParcelFileDescriptor pfd = null;
        private boolean isRunFlag = false;
        private FileDescriptor fd;
    
        @Override
        public void onCreate(){
            super.onCreate();
        }
    
        @Override
        public void onDestroy(){
            super.onDestroy();
        }
    
        @Override
        public IBinder onBind(Intent intent) {
            isRunFlag = true;
            return mTestInterface;
        }
    
        @Override
        public void onStart(Intent intent, int startId){
            super.onStart(intent, startId);
        }
    
    
        @Override
        public boolean onUnbind(Intent intent){
            isRunFlag = false;
            if (mMemoryFile != null){
                mMemoryFile.close();
                mMemoryFile = null;
            }
            return super.onUnbind(intent);
        }
    
    	//实现接口ITestAidlInterface
        public class TestInterface extends ITestAidlInterface.Stub {
    
            @Override
            public void registerCallback(ITestCallbackAidlInterface cb) throws RemoteException {
                if(cb != null) mCallbackList.register(cb);
            }
    
            @Override
            public void unregisterCallback(ITestCallbackAidlInterface cb) throws RemoteException {
                if(cb != null) mCallbackList.unregister(cb);
            }
    
            @Override
            public ParcelFileDescriptor getMemoryFileDescriptor() throws RemoteException {
                if (pfd == null){
                    createMemoryFile();
                }
                if (pfd != null && !pfd.getFileDescriptor().valid()){
                    if (mMemoryFile != null){
                        mMemoryFile.close();
                        mMemoryFile = null;
                    }
                    try {
                        pfd.close();
                        pfd = null;
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                    createMemoryFile();
                }
                return  pfd;
            }
    
            @Override
            public void serverSendData(String data) throws RemoteException {
                //客户端返回数据
            }
    
        }
    	
    	//创建共享内存块
        private void createMemoryFile(){
            if (mMemoryFile == null){
                try {
                    mMemoryFile = new MemoryFile("memfile", 1000);
                    Method method = MemoryFile.class.getDeclaredMethod("getFileDescriptor");
                    fd = (FileDescriptor) method.invoke(mMemoryFile);
                    if (fd.valid()){
                        Log.d(TAG, "createMemoryFile: fd valid");
                        pfd = ParcelFileDescriptor.dup(fd);
                        new Thread(testRunnable ).start();
                    }else {
                        Log.e(TAG, "createMemoryFile: fd = -1");
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                    if (mMemoryFile != null){
                        mMemoryFile.close();
                        mMemoryFile = null;
                    }
                    pfd = null;
                }
            }
        }
    
        Runnable testRunnable = new Runnable() {
            @Override
            public void run() {
                try {
    
                    while (isRunFlag){
                        byte[] testData = {0x01,0x02,0x03};
                        if (fd.valid()) {
                        	//往内存块里面写数据
                            mMemoryFile.writeBytes(testData, 0, 0, testData.length);
                        } else {
                            writeStop();
                        }
                        Thread.sleep(10);
                    }
                    isRunFlag = false;
                } catch (Exception e) {
                    e.printStackTrace();
                } finally {
                    isRunFlag = false;
                }
            }
        };
    
    	//发送数据给客户端
        private void writeStop() {
            final int n = mCallbackList.beginBroadcast();
            for (int i=0; i < n; i++) {
                try {
                    mCallbackList.getBroadcastItem(i).clintSenddata("stop");
                } catch (RemoteException e) {
                    e.printStackTrace();
                }
            }
            mCallbackList.finishBroadcast();
        }
    }
    
    
    记得在AndroidManifest.xml中注册service
    <service
    	   android:name="com.example.administrator.testgsensor.TestService"
    	   android:enabled="true"
    	   android:exported="true">
    	   <intent-filter >
    	       <action android:name="com.example.administrator.testgsensor.TestService" />
    	   </intent-filter>
    </service>
    

    接下来看客户端的代码

    客户端代码
    package com.example.administrator.testgsensor;
    
    import android.app.Activity;
    import android.content.ComponentName;
    import android.content.Context;
    import android.content.Intent;
    import android.content.ServiceConnection;
    import android.os.Bundle;
    import android.os.IBinder;
    import android.os.MemoryFile;
    import android.os.ParcelFileDescriptor;
    import android.os.RemoteException;
    import android.util.Log;
    
    import java.io.IOException;
    
    public class MainActivity extends Activity {
    
        private static final String TAG = "MainActivity";
        private boolean isBind = false;
        private ITestAidlInterface mTestAidlInterface;
        private MemoryFile mMemoryFile;
        private boolean bRead = false;
    
        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_main);
            binderService();
            bRead = true;
            new Thread(new Runnable() {
                @Override
                public void run() {
                    byte[] data = new byte[3];
                    while (bRead){
                        if (mTestAidlInterface != null && mMemoryFile != null) {
                            try {
                                //读取共享内存块的数据
                                mMemoryFile.readBytes(data, 0, 0, data.length);
                            } catch (IOException e) {
                                e.printStackTrace();
                            } 
                        }
                    }
                }
            }).start();
            
        }
    
        @Override
        protected void onDestroy() {
    	    if (mTestAidlInterface != null) {
    	         try {
    	             mTestAidlInterface.unregisterCallback(testCallbackAidlInterface);
    	         } catch (RemoteException e) {
    	             e.printStackTrace();
    	         }
    	    }
    	    unBinderService();
            super.onDestroy();
        }
    
        private ServiceConnection conn = new ServiceConnection() {
            @Override
            public void onServiceConnected(ComponentName name, IBinder service) {
    
                if (mTestAidlInterface == null) {
                    mTestAidlInterface = ITestAidlInterface.Stub.asInterface(service);
                    Log.d(TAG, "onServiceConnected: ");
    
                    if (mTestAidlInterface != null) {
                        try {
                            mTestAidlInterface.registerCallback(testCallbackAidlInterface);
    
                            //获取共享内存文件描述符
                            ParcelFileDescriptor pfd = mTestAidlInterface.getMemoryFileDescriptor();
    
                            if (pfd != null) {
                                Log.d(TAG, "pfd != null "+pfd.toString());
                                mMemoryFile = MemoryFileHelper.openMemoryFile(pfd, 1000, MemoryFileHelper.PROT_READ);
                            }
                        } catch (RemoteException e) {
                            e.printStackTrace();
                        }
                    }
                }
            }
    
            @Override
            public void onServiceDisconnected(ComponentName name) {
                Log.d(TAG, "onServiceDisconnected: ");//正常情况下是不会被调用的,只有远程服务意外停止才会
                unBinderService();
            }
        };
    
        ITestCallbackAidlInterface testCallbackAidlInterface = new ITestCallbackAidlInterface.Stub() {
            @Override
            public void clintSenddata(String data) throws RemoteException {
                //服务端发送数据
            }
        };
    
        private void binderService() {
            Intent intent = new Intent();
            intent.setAction("com.example.administrator.testgsensor.TestService");
            intent.setPackage("com.example.administrator.testgsensor");
            intent.setClassName("com.example.administrator.testgsensor",
                    "com.example.administrator.testgsensor.TestService");
            this.bindService(intent, conn, Context.BIND_AUTO_CREATE);
            isBind = true;
        }
    
        private void unBinderService() {
            if (isBind) {
                this.unbindService(conn);
                isBind = false;
            }else {
                return;
            }
    
            testCallbackAidlInterface = null;
            if (mMemoryFile != null) {
                mMemoryFile.close();
                mMemoryFile = null;
            }
        }
    
    }
    

    到此服务端和客户端的代码已经完成,两个进程间就可以通过读写共享内存块的方式共享大数据啦。
    最后附上两个工具类的代码。

    package com.example.administrator.testgsensor;
    
    import android.os.MemoryFile;
    import android.os.ParcelFileDescriptor;
    import android.util.Log;
    
    import java.io.FileDescriptor;
    import java.io.IOException;
    import java.lang.reflect.Method;
    
    
    public class MemoryFileHelper {
    
        public static final int PROT_READ = 0x01;//只读方式打开,
        public static final int PROT_WRITE = 0x02;//可写方式打开,PROT_WRITE|PROT_READ可读可写方式打开
        private static final String TAG = "MemoryFileHelper";
    
        /**
         * 创建共享内存对象
         *
         * @param name   描述共享内存文件名称
         * @param length 用于指定创建多大的共享内存对象
         * @return MemoryFile 描述共享内存对象
         */
        public static MemoryFile createMemoryFile(String name, int length) {
            try {
                return new MemoryFile(name, length);
            } catch (IOException e) {
                e.printStackTrace();
            }
            return null;
        }
    
        public static MemoryFile openMemoryFile(ParcelFileDescriptor pfd, int length, int mode) {
            if (pfd == null) {
                throw new IllegalArgumentException("ParcelFileDescriptor 不能为空");
            }
            FileDescriptor fd = pfd.getFileDescriptor();
            Log.d(TAG, "openMemoryFile: pfd="+pfd.toString());
            Log.d(TAG, "openMemoryFile: fd="+fd.toString());
            return openMemoryFile(fd, length, mode);
        }
    
        /**
         * 打开共享内存,一般是一个地方创建了一块共享内存
         * 另一个地方持有描述这块共享内存的文件描述符,调用
         * 此方法即可获得一个描述那块共享内存的MemoryFile
         * 对象
         *
         * @param fd     文件描述
         * @param length 共享内存的大小
         * @param mode   PROT_READ = 0x1只读方式打开,
         *               PROT_WRITE = 0x2可写方式打开,
         *               PROT_WRITE|PROT_READ可读可写方式打开
         * @return MemoryFile
         */
        public static MemoryFile openMemoryFile(FileDescriptor fd, int length, int mode) {
            MemoryFile memoryFile = null;
            try {
                memoryFile = new MemoryFile("tem", length);
                memoryFile.close();
                Class<?> c = MemoryFile.class;
                Method native_mmap = null;
                Method[] ms = c.getDeclaredMethods();
                for (int i = 0; ms != null && i < ms.length; i++) {
                    if (ms[i].getName().equals("native_mmap")) {
                        native_mmap = ms[i];
                    }
                }
    
                ReflectUtil.setField("android.os.MemoryFile", memoryFile, "mFD", fd);
                ReflectUtil.setField("android.os.MemoryFile", memoryFile, "mLength", length);
                //address 在4.4中是int类型,在6.0中是long类型。
                long address = (Integer) ReflectUtil.invokeMethod(null, native_mmap, fd, length, mode);
                ReflectUtil.setField("android.os.MemoryFile", memoryFile, "mAddress", address);
    
                Log.d(TAG, "openMemoryFile: mFD"+fd.toString());
                Log.d(TAG, "openMemoryFile: mLength"+length);
                Log.d(TAG, "openMemoryFile: mAddress"+address);
    
            } catch (Exception e) {
                e.printStackTrace();
            }
            return memoryFile;
        }
    
        /**
         * 获取memoryFile的ParcelFileDescriptor
         *
         * @param memoryFile 描述一块共享内存
         * @return ParcelFileDescriptor
         */
        public static ParcelFileDescriptor getParcelFileDescriptor(MemoryFile memoryFile) {
            if (memoryFile == null) {
                throw new IllegalArgumentException("memoryFile 不能为空");
            }
            ParcelFileDescriptor pfd;
            FileDescriptor fd = getFileDescriptor(memoryFile);
            pfd = (ParcelFileDescriptor) ReflectUtil.getInstance("android.os.ParcelFileDescriptor", fd);
            return pfd;
        }
    
        /**
         * 获取memoryFile的FileDescriptor
         *
         * @param memoryFile 描述一块共享内存
         * @return 这块共享内存对应的文件描述符
         */
        public static FileDescriptor getFileDescriptor(MemoryFile memoryFile) {
            if (memoryFile == null) {
                throw new IllegalArgumentException("memoryFile 不能为空");
            }
            FileDescriptor fd;
            fd = (FileDescriptor) ReflectUtil.invoke("android.os.MemoryFile", memoryFile, "getFileDescriptor");
            return fd;
        }
    
    }
    
    
    package com.example.administrator.testgsensor;
    
    
    import java.lang.reflect.Constructor;
    import java.lang.reflect.Field;
    import java.lang.reflect.Method;
    
    public class ReflectUtil {
        /**
         * 根据类名,参数实例化对象
         *
         * @param className 类的路径全名
         * @param params    构造函数需要的参数
         * @return 返回T类型的一个对象
         */
        public static Object getInstance(String className, Object... params) {
            if (className == null || className.equals("")) {
                throw new IllegalArgumentException("className 不能为空");
            }
            try {
                Class<?> c = Class.forName(className);
                if (params != null) {
                    int plength = params.length;
                    Class[] paramsTypes = new Class[plength];
                    for (int i = 0; i < plength; i++) {
                        paramsTypes[i] = params[i].getClass();
                    }
                    Constructor constructor = c.getDeclaredConstructor(paramsTypes);
                    constructor.setAccessible(true);
                    return constructor.newInstance(params);
                }
                Constructor constructor = c.getDeclaredConstructor();
                constructor.setAccessible(true);
                return constructor.newInstance();
            } catch (Exception e) {
                e.printStackTrace();
            }
            return null;
        }
    
        /**
         * 执行instance的方法
         *
         * @param className  类的全名
         * @param instance   对应的对象,为null时执行类的静态方法
         * @param methodName 方法名称
         * @param params     参数
         */
        public static Object invoke(String className, Object instance, String methodName, Object... params) {
            if (className == null || className.equals("")) {
                throw new IllegalArgumentException("className 不能为空");
            }
            if (methodName == null || methodName.equals("")) {
                throw new IllegalArgumentException("methodName不能为空");
            }
            try {
                Class<?> c = Class.forName(className);
                if (params != null) {
                    int plength = params.length;
                    Class[] paramsTypes = new Class[plength];
                    for (int i = 0; i < plength; i++) {
                        paramsTypes[i] = params[i].getClass();
                    }
                    Method method = c.getDeclaredMethod(methodName, paramsTypes);
                    method.setAccessible(true);
                    return method.invoke(instance, params);
                }
                Method method = c.getDeclaredMethod(methodName);
                method.setAccessible(true);
                return method.invoke(instance);
            } catch (Exception e) {
                e.printStackTrace();
            }
            return null;
        }
    
        /**
         * 执行指定的对方法
         *
         * @param instance 需要执行该方法的对象,为空时,执行静态方法
         * @param m        需要执行的方法对象
         * @param params   方法对应的参数
         * @return 方法m执行的返回值
         */
        public static Object invokeMethod(Object instance, Method m, Object... params) {
            if (m == null) {
                throw new IllegalArgumentException("method 不能为空");
            }
            m.setAccessible(true);
            try {
                return m.invoke(instance, params);
            } catch (Exception e) {
                e.printStackTrace();
            }
            return null;
        }
    
        /**
         * 取得属性值
         *
         * @param className 类的全名
         * @param fieldName 属性名
         * @param instance  对应的对象,为null时取静态变量
         * @return 属性对应的值
         */
        public static Object getField(String className, Object instance, String fieldName) {
            if (className == null || className.equals("")) {
                throw new IllegalArgumentException("className 不能为空");
            }
            if (fieldName == null || fieldName.equals("")) {
                throw new IllegalArgumentException("fieldName 不能为空");
            }
            try {
                Class c = Class.forName(className);
                Field field = c.getDeclaredField(fieldName);
                field.setAccessible(true);
                return field.get(instance);
            } catch (Exception e) {
                e.printStackTrace();
            }
            return null;
        }
    
        /**
         * 设置属性
         *
         * @param className 类的全名
         * @param fieldName 属性名
         * @param instance  对应的对象,为null时改变的是静态变量
         * @param value     值
         */
        public static void setField(String className, Object instance, String fieldName, Object value) {
            if (className == null || className.equals("")) {
                throw new IllegalArgumentException("className 不能为空");
            }
            if (fieldName == null || fieldName.equals("")) {
                throw new IllegalArgumentException("fieldName 不能为空");
            }
            try {
                Class<?> c = Class.forName(className);
                Field field = c.getDeclaredField(fieldName);
                field.setAccessible(true);
                field.set(instance, value);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    
        /**
         * 根据方法名,类名,参数获取方法
         *
         * @param className  类名,全名称
         * @param methodName 方法名
         * @param paramsType 参数类型列表
         * @return 方法对象
         */
        public static Method getMethod(String className, String methodName, Class... paramsType) {
            if (className == null || className.equals("")) {
                throw new IllegalArgumentException("className 不能为空");
            }
            if (methodName == null || methodName.equals("")) {
                throw new IllegalArgumentException("methodName不能为空");
            }
            try {
                Class<?> c = Class.forName(className);
                return c.getDeclaredMethod(methodName, paramsType);
            } catch (Exception e) {
                e.printStackTrace();
            }
            return null;
        }
    
    
    }
    
    
    展开全文
  • AIDL:Android Interface Definition Language,即Android接口定义语言. android studio中使用aidl实现跨进程通讯,具体步骤如下
  • Android SDK中提供了4种用于跨进程通讯的方式。这篇文章主要介绍了详解Android 进程通信的几种实现方式,有兴趣的可以了解一下。
  • Android跨进程通信之ContentProvider

    千次阅读 2016-06-29 16:42:38
    需求一:进程一操作或者得到进程二的数据 可以看到,可以通过这个几个方法远程调用另一个进程中ContentProvider的方法。这里需要说一个call这个函数,它相当于就是远程调用。 具体用法如下: 1、实现...

    需求一:进程一操作或者得到进程二的数据

    这里写图片描述

    可以看到,可以通过这个几个方法远程调用另一个进程中ContentProvider的方法。这里需要说一个call这个函数,它相当于就是远程调用。

    具体用法如下:

    1、实现ContentProvider

    public class MyContentProvider extends ContentProvider {
        private static final String TAG = "MyContentProvider";
    
        @Override
        public boolean onCreate() {
            return false;
        }
    
        @Nullable
        @Override
        public Cursor query(Uri uri, String[] projection, String selection, String[] selectionArgs, String sortOrder) {
            Log.d(TAG, "MyContentProvider query");
            return null;
        }
    
        @Nullable
        @Override
        public String getType(Uri uri) {
            Log.d(TAG, "MyContentProvider getType");
            return null;
        }
    
        @Nullable
        @Override
        public Uri insert(Uri uri, ContentValues values) {
            Log.d(TAG, "MyContentProvider insert");
            return null;
        }
    
        @Override
        public int delete(Uri uri, String selection, String[] selectionArgs) {
            Log.d(TAG, "MyContentProvider delete");
            return 0;
        }
    
        @Override
        public int update(Uri uri, ContentValues values, String selection, String[] selectionArgs) {
            Log.d(TAG, "MyContentProvider update");
            return 0;
        }
    
        @Nullable
        @Override
        public Bundle call(String method, String arg, Bundle extras) {
            Log.d(TAG, "MyContentProvider call");
            return super.call(method, arg, extras);
        }
    }

    2、远程调用

    public class MainActivity extends AppCompatActivity {
    
        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_main);
            ContentResolver resolver =  getContentResolver();
            if (resolver != null) {
                resolver.insert(Uri.parse("content://com.mirhunana.mycontentprovider/test"), new ContentValues());
                resolver.query(Uri.parse("content://com.mirhunana.mycontentprovider/test"), null, null, null, null);
                resolver.delete(Uri.parse("content://com.mirhunana.mycontentprovider/test"), null, null);
                resolver.update(Uri.parse("content://com.mirhunana.mycontentprovider/test"), new ContentValues(), null, null);
                resolver.call(Uri.parse("content://com.mirhunana.mycontentprovider/test"), "getService", null, null);
            }
    
        }
    }

    输入结果:

    06-29 16:27:46.340 :remote D/MyContentProvider: MyContentProvider insert
    06-29 16:27:46.345 :remote D/MyContentProvider: MyContentProvider query
    06-29 16:27:46.350 :remote D/MyContentProvider: MyContentProvider delete
    06-29 16:27:46.350 :remote D/MyContentProvider: MyContentProvider update
    06-29 16:27:46.355 :remote D/MyContentProvider: MyContentProvider call

    需求二:进程一观察进程二的某些数据的变化

    这里写图片描述

    使用观察者模式,在一个进程中观察另一个进程的数据情况,当另一个进程数据发生变化的时候,可以远程的通知该进程。

    具体用法如下:

    1、自定义ContentObserver

    public class MyContentObsever extends ContentObserver {
        private static final String TAG = "MyContentObsever";
        public MyContentObsever(Handler handler) {
            super(handler);
        }
    
        @Override
        public void onChange(boolean selfChange) {
            // 客户端可以得到数据源发生改变的通知
            Log.d(TAG, "数据源发生了变化!");
            super.onChange(selfChange);
        }
    
        @Override
        public void onChange(boolean selfChange, Uri uri) {
            super.onChange(selfChange, uri);
        }
    }

    2、写一个客户端,注册监听,监听指定的URI

    public class MainActivity extends Activity {
    
        private MyContentObsever myContentObsever;
        private Handler mHander = new Handler();
    
        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_main);
    
            myContentObsever = new MyContentObsever(mHander);
            getContentResolver().registerContentObserver(MyService.URI, false, myContentObsever);
    
            startService(new Intent(this, MyService.class));
        }
    }

    3、启动一个Service,Serivce运行在另外一个进程

    public class MyService extends Service {
        public static final String AUTHORITY = "mirhunana";
        public static final Uri URI = Uri.parse("content://" + AUTHORITY + "/cache");
        public MyService() {
        }
    
        @Override
        public IBinder onBind(Intent intent) {
            // TODO: Return the communication channel to the service.
            throw new UnsupportedOperationException("Not yet implemented");
        }
    
        @Override
        public void onCreate() {
            super.onCreate();
            // 假设我们的数据源在这个服务中发生了改变,我们来通知客户端
            ContentResolver resolver = getContentResolver();
            resolver.notifyChange(URI, null);
        }
    }

    具体可以参考文章:

    ContentProvider和Uri详解

    Android中ContentObserver的使用

    欢迎关注微信公众号:DroidMind
    精品内容独家发布平台


    呈现与博客不一样的技术干货

    展开全文
  • QQ的网路通信使用的就是跨进程通讯。创建Aidl接口文件创建一个File,命名为:xxx.aidl;此处命名为:IIncrementUpdateServer.aidl,具体请看下图aidl文件所在位置: 创建完成后,如下所示: IIncrementUp
  • Android跨进程通信的四种方式

    千次阅读 2017-09-05 16:36:32
    Android系统中应用程序之间不能共享内存,在android SDK中提供了4种用于跨进程通讯的方式。这4种方式正好对应于android系统中4种应用程序组件:Activity、Content Provider、Broadcast和Service。1、其中Activity...
  • android跨进程通信方式有哪些?

    千次阅读 2018-03-22 18:19:09
    定义多进程Android应用中使用多进程只有一个办法(用NDK的fork来做除外),就是在AndroidManifest.xml中声明组件时,用android:process属性来指定。不知定process属性,则默认运行在主进程中,主进程名字为包名。...
  • NULL 博文链接:https://trylovecatch.iteye.com/blog/1167682
  • NULL 博文链接:https://trylovecatch.iteye.com/blog/1167806
  • android跨进程通信

    2011-09-28 16:45:34
    android程序中调用外部程序 并同时实现进程之间的通信
  • 跨进程通信方式 文件共享 Bundle AIDL (1)创建AIDL接口 (2)根据AIDL创建远程Service服务 (3)绑定远程Service服务 Messenger (1)创建服务端Messenger (2)创建客户端Messenger (3)绑定远程服务端 ...
  • android跨进程通信(IPC):使用AIDL

    万次阅读 多人点赞 2013-11-30 23:20:52
     AIDL (Android Interface Definition Language) 是一种IDL 语言,用于生成可以在Android设备上两个进程之间进行进程通信(interprocess communication, IPC)的代码。如果在一个进程中(例如Activity)要调用另一...
  • Android跨进程通信demo

    2016-07-20 17:58:21
    压缩包共包含8个工程,涉及ipc通信,java设计模式,service通信。有需要的朋友可以下载学习。
  • 关于使用aidl进行跨进程通信的简单demo
  • 本文为大家分享了Android AIDL实现两个APP间的跨进程通信实例,供大家参考,具体内容如下 1 Service端创建 首先需要创建一个Android工程然后创建AIDL文件,创建AIDL文件主要为了生成继承了Binder的Stub类,以便应用...
  • Android 使用AIDL跨进程通信--传递自定义对象 服务端进程-SystemApp(包含IRemoteBinder.aidl,Book.aidl) 客户端进程-ClientApp
  • Android AIDL跨进程通信

    2017-09-30 15:04:21
    Android AIDL跨进程通信 的demo,包括两部分,两个项目
  • 本篇文章主要介绍了Android AIDL实现跨进程通信的示例代码,具有一定的参考价值,有兴趣的可以了解一下
  • Android跨进程通信-Binder连接池的使用

    千次阅读 2016-10-09 09:16:37
    产生原因:因为当有多个不同的业务块都要使用AIDL来进行通信,则需要创建多个Service,每创建一个Service就需要消耗系统资源。 解决思路:将所有的AIDL放在一个Service中处理 2.Binder连接池的使用方法? 实现...
  • android之AIDL跨进程通信详解

    千次阅读 2017-02-23 18:18:53
    背景一直以来都只是听说AIDL是跨进程的,但都由于项目中也没涉及到,所以也从来都没彻底去了解过,最近空闲下来去了解插件化开发原理,看着看着正好涉及到Ibinder以及android用到的AIDL,于是乎按图索骥一条条来探索...
  • Android跨进程通信——Activity

    千次阅读 2012-10-11 11:26:46
    会用到跨进程通信的方式,什么是跨进程通信,例如,在第三方应用中调用拨号、短信、邮件等,在这个过程中发生数据的传递,当前应用(一个进程)调用另一个应用(第二个进程),这就是Android中的跨进程通信。...
  • Android 跨进程通信 代码~~~~~~~~~~~~~~~~~~~~

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 79,692
精华内容 31,876
关键字:

android跨进程通信