1. 全栈程序员必看首页

android IPC 通信（上）－sharedUserId&&Messenger「建议收藏」

全栈程序员-用户IM • • 未分类

android IPC 通信（上）－sharedUserId&&Messenger

大家好，又见面了，我是全栈君。

　　看了一本书，上面有一章讲解了IPC(Inter-Process Communication，进程间通信)通信，决定结合以前的一篇博客android 两个应用之间的通信与调用和自己的理解来好好整理总结一下这块的知识，由于内容较多，这部分会分上中下三篇博客来仔细分析讲解，第一篇上篇要讲解的是sharedUserId和Messenger的使用方式。
　　android IPC通信（中）－ContentProvider&&Socket
　　android IPC通信（下）－AIDL

sharedUserId

　　sharedUserId的作用是让两个应用程序共享一个user id，我们都知道linux进程给每一个应用程序分配了一个独立的user id，所以如果两个或多个应用程序的签名相同并且设置了一样的sharedUserId，他们将会共享一个user id，相同user id的应用程序可以访问对方的数据（也就是说如果应用程序中的一个文件的权限是600，相同uid可以直接访问，反之则无法访问），并且设置成一个android:process就能够运行在一个进程中了。
　　sharedUserId方式主要就是使用createPackageContext (String packageName, int flags)函数，该函数用来返回指定包名应用的上下文，注意是application的context。
　　这个方法有两个参数：

  1. packageName：包名，要得到Context的应用程序的完整包名
  2. flags：标志位，有CONTEXT_INCLUDE_CODE和CONTEXT_IGNORE_SECURITY两个选项，CONTEXT_INCLUDE_CODE选项的作用就是可以在调用者的进程执行该application的代码，也就是说可以使用getClassLoader()函数来初始化该application的相关类，使用该标识将会在你可以使用的application context上施加安全约束，如果需要加载的application不能被安全的加载进进程的话，将会抛出一个SecurityException，如果这个标示没有被设置，那么将不会在被加载的类上面施加任何约束，getClassLoader()将会返回默认的系统类加载器；CONTEXT_IGNORE_SECURITY的意思是忽略任何安全警告，和CONTEXT_INCLUDE_CODE标识一起使用可能会将不安全的代码加载进进程，所以谨慎使用。

　　在我博客
android permission权限与安全机制解析（上）中已经简单介绍了一下SharedUserId，这次就要详细讲解一下他的具体用法，用来A应用和B应用之间的交互。先来看看两个应用的manifest文件：

　　A应用：

<manifest package="com.android.shareduserid_a"
xmlns:android="schemas.android.com/apk/res/and…"
android:sharedUserId="com.android.test"
android:sharedUserLabel="@string/share_label">

<application
 android:allowBackup="true"
android:icon="@mipmap/ic_launcher"
android:label="@string/app_name"
android:theme="@style/AppTheme">
<activity android:name="com.android.shareuserid_a.Server">
<intent-filter>
<action android:name="android.intent.action.MAIN"/>
<category android:name="android.intent.category.LAUNCHER"/>
</intent-filter>
</activity>

</application>

</manifest>
复制代码

B应用：

<manifest package="com.android.shareduserid_b"
xmlns:android="schemas.android.com/apk/res/and…"
android:sharedUserId="com.android.test"
android:sharedUserLabel="@string/share_label">
<application
 android:allowBackup="true"
android:icon="@mipmap/ic_launcher"
android:label="@string/app_name"
android:theme="@style/AppTheme">
<activity android:name="com.android.shareuserid_b.Client"
android:exported="true">
</activity>
</application>
</manifest>
复制代码

　　B应用的Client Activity加上了android:exported=”true”用来与A应用交互，这个在 android permission权限与安全机制解析（上）已经有详细的介绍，在这就略过了。
　　A应用有一个Server的Activity，B应用有一个Client的Activity，先来看看交互的效果，左侧为A应用，右侧为B应用：
　　
　　A应用中的Server activity通过下面代码获取到B应用的application context：

context = createPackageContext("com.android.shareduserid_b", CONTEXT_INCLUDE_CODE|CONTEXT_IGNORE_SECURITY);复制代码

　　获取到该application的上下文之后，我们能做的事情就很多了，下面介绍几种：

获取Ｂ应用drawable

　　获取B应用的drawable，使用getIdentifier函数即可获取B应用该资源的id：

//获取B应用图片
int id = context.getResources().getIdentifier("share", "mipmap", "com.android.shareduserid_b");
iv_pic.setImageDrawable(ContextCompat.getDrawable(context, id));复制代码

获取Ｂ应用string

　　获取B应用字符串，统一使用getIdentifier函数获取id：

id = context.getResources().getIdentifier("share_string", "string", "com.android.shareduserid_b");
tv_string.setText(context.getString(id));复制代码

打开Ｂ应用页面

　　打开B应用activity，使用ComponentName设置B应用的activity名称和包名就能成功跳转过去了，类名需要带上完整的包名，当然使用intent.setClassName()函数也是能够成功的，记得在B应用一定要加上android:exported=”true”：

Intent intent = new Intent();
ComponentName componentName = new ComponentName("com.android.shareduserid_b",
"com.android.shareuserid_b.Client");
intent.setComponent(componentName);
//intent.setClassName(context, "com.android.shareuserid_b.Client");
//intent.setClassName("com.android.shareduserid_b",
//        "com.android.shareuserid_b.Client");
startActivity(intent);复制代码

执行Ｂ应用指定类函数

　　执行B应用函数，当然是利用反射，要执行B应用的代码，调用createPackageContext函数时flag中一定要有CONTEXT_INCLUDE_CODE。如果被反射的函数参数是可变类型，类似于int… integers，那么getMethod函数第二个参数传入一个int[]数组就可以了。注意在B应用中要有相关的类和函数：

try {
   
   
    Class clazz = context.getClassLoader().loadClass("com.android.shareuserid_b.Method");
    Object object = clazz.newInstance();
int[] ints = new int[]{
   
   1,2,3};
int sum = (int) clazz.getMethod("add", int[].class).invoke(object, ints);
    tv_sum.setText("sum is :"+sum);
} catch (Exception e) {
   
   
    L.e(e);
    e.printStackTrace();
}复制代码

获取Ｂ应用SharedPreferences

　　获取B应用SharedPreferences，这个需要特殊说明一下，由于SharedPreferences是有缓存机制的，所以如果在B应用中修改了该SharedPreferences文件，接着A应用去读取该文件中修改的那个值，这时你会发现还是修改前的值，这就是缓存机制导致的问题，不过有一个flag可以解决这个问题：MODE_MULTI_PROCESS，但是非常不幸的是api23已经将该标识deprecated了，原因是在一些版本上不可靠，有兴趣的可以去了解一下，看代码：

//注意Context.MODE_MULTI_PROCESS不可靠
SharedPreferences sharedPreferences = context.getSharedPreferences("permanent", MODE_MULTI_PROCESS);
String time = sharedPreferences.getString("time", "get time error");
tv_shared_preference.setText(time);复制代码

获取Ｂ应用数据库

　　获取B应用的数据库，注意数据库名字和表名一定要对应上，要不然会抛出Exception：

String DBPath = context.getDatabasePath("permanentCache.db").getAbsolutePath();
SQLiteDatabase sqLiteDatabase = SQLiteDatabase.openDatabase(DBPath, null, SQLiteDatabase.OPEN_READONLY);
Cursor cursor = sqLiteDatabase.query("cache_1", null, "key=?", new String[]{
   
   "time"}, null, null, null, null);
cursor.moveToNext();
tv_DB.setText(cursor.getString(1));
cursor.close();
sqLiteDatabase.close();复制代码

用途：这种方式可以用来进行轻量级的补丁操作，例如皮肤，第一步从服务器获取所有皮肤的包名，第二步看用户选择的皮肤包是否已经安装到手机上，如果没有从服务器下载安装，如果有直接第三步；第三步当然就是从该皮肤包中获取资源等等等了。

下载地址

源码地址：github.com/zhaozepeng/…

Messenger

　　Messenger可以用来在不同进程中传递对象，在Messenger中放入我们需要传递的对象，就能轻松地实现数据的进程间传递了。Messenger是一种轻量级的IPC方案，它对AIDL进行封装，所以使用起来非常的方便，当然AIDL通信的底层实现也是对Binder的封装，需要特别注意的是这个Binder类并不会影响系统对进程生命周期的管理（你需要使用一些更高等级的组件来告诉系统你的进程需要继续执行而不被系统回收内存），如果由于某些原因被系统杀死回收，连接就会断开。

　　因为是进程之间的通信，所以可以在一个应用中开两个进程通信，也可以在两个应用中实现通信，我就以两个应用之间的通信为例。两个应用之间的通信可以使用两种方式：

  1. 客户端使用bindService函数绑定服务端Service，并且利用handler进行两个应用之间message的处理。
  2. 客户端使用bindService绑定服务端Service，然后直接使用反射机制，让客户端反射service端的函数来进行操作，注意，这种方式一定要让两个应用运行在同一个进程中（使用sharedUserId+android:process），要不然无法反射出相关函数，具体代码中会指出。

Handler处理方式

　　handler方式最主要是通过Messenger+message进行两个应用的通信，先来看看服务端Service代码：

Messenger messenger = null;
private static class MessengerHandler extends Handler{ 
    
    @Override
    public void handleMessage(Message msg) {
        switch (msg.what){
            case 1:
                L.i("i receive '" + msg.getData().getString("message")+"'");
                Messenger client = msg.replyTo;

                //回应客户端
                if (client != null){
                    Message reply = Message.obtain();
                    Bundle message = new Bundle();
                    message.putString("message", "i have received your message");
                    L.i("i have received your message");
                    reply.setData(message);
                    try {
                        client.send(reply);
                    } catch (RemoteException e) {
                        e.printStackTrace();
                    }
                }
                break;
            case 2:
                L.i("i receive '" + msg.getData().getString("message")+"'");
                L.i("client has disconnect this connection, bye~");
                break;
            default:
                break;
        }
    }
}

@Override
public IBinder onBind(Intent intent) {
    return messenger.getBinder();
}

@Override
public void onCreate() {
    super.onCreate();
    messenger = new Messenger(new MessengerHandler());
}复制代码

　　客户端代码：

private Button connect_handler;
private TextView tv_handler;
private Button connect_binder;
private TextView tv_binder;

private ServiceConnection serviceConnection;
private Messenger serverMessenger;
private Messenger messenger;

private boolean hasBindService = false;

@Override
public void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.client_handler);
    connect_handler = (Button) findViewById(R.id.connect_handler);
    connect_handler.setOnClickListener(this);
    tv_handler = (TextView) findViewById(R.id.tv_handler);
    connect_binder = (Button) findViewById(R.id.connect_binder);
    connect_binder.setOnClickListener(this);
    tv_binder = (TextView) findViewById(R.id.tv_binder);

    serviceConnection = new ServiceConnection() {
        @Override
        public void onServiceConnected(ComponentName name, IBinder service) {
            serverMessenger = new Messenger(service);
            communicate();
        }

        @Override
        public void onServiceDisconnected(ComponentName name) {
            serverMessenger = null;
        }
    };

    messenger = new Messenger(new Handler(){
        @Override
        public void handleMessage(Message msg) {
            L.i("i have received '" + msg.getData().getString("message") + "'");
            Message message = Message.obtain();
            Bundle bundle = new Bundle();
            bundle.putString("message", "OK, bye bye~");
            message.setData(bundle);
            L.i("i have send '" + message.getData().getString("message") + "'");
            message.what = 2;
            if (serverMessenger != null){
                try {
                    serverMessenger.send(message);
                } catch (RemoteException e) {
                    e.printStackTrace();
                }
            }
        }
    });
}

private void communicate(){
    SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd-HH:mm:ss");
    Message message = Message.obtain();
    Bundle msg = new Bundle();
    msg.putString("message", "i have send handler a message at " + simpleDateFormat.format(System.currentTimeMillis()));
    message.setData(msg);
    L.i("i have send '" + message.getData().getString("message") + "'");
    message.what = 1;
    message.replyTo = messenger;
    if (serverMessenger != null){
        try {
            serverMessenger.send(message);
        } catch (RemoteException e) {
            e.printStackTrace();
        }
    }
}

@Override
public void onClick(View v) {
    switch (v.getId()){
        case R.id.connect_handler:
            if (!hasBindService) {
                Intent intent = new Intent();
                intent.setClassName("com.android.messenger_a", "com.android.messenger_a.ServerWithHandler");
                bindService(intent, serviceConnection, BIND_AUTO_CREATE);
                hasBindService = true;
            }else{
                if (serverMessenger == null){
                    return;
                }
                communicate();
            }
            break;
        case R.id.connect_binder:
            startActivity(new Intent(this, ClientForBinder.class));
            break;
    }
}

@Override
protected void onDestroy() {
    super.onDestroy();
    if (serverMessenger != null)
        unbindService(serviceConnection);
}复制代码

　　运行结果如下图：

　　

　　服务器端Service先需要自定义一个Handler类用来处理客户端发过来的消息，接着用一个Handler对象新建一个Messenger对象，这样就相当于把发送给Messenger的message处理交给了该Handler，最后就在onBind函数中返回该Messenger的IBinder即可。

　　客户端用bindService绑定该服务端service，并且在onServiceConnected回调中用IBinder参数构造一个Messenger，这个Messenger就是客户端用来和服务端通信的中介了，还有一点需要注意的是，为了服务端接收到客户端的消息之后能够回复客户端，在客户端也需要新建一个Messenger，并且将其通过message.replyTo变量传递给服务端，服务端就能够通过该replyTo变量传递消息给客户端了。

反射方式

　　该模式需要使用sharedUserId+android:permission的方式将两个应用置于一个进程才能使用（这样想一想好像就不是跨进程通信了呢-, -），要不然是无法反射到相关函数的。

　　服务端代码：

private final InnerBinder binder = new InnerBinder();

public class InnerBinder extends Binder { 
    
    public ServerWithBinder getServer(){
        return ServerWithBinder.this;
    }
}

public int add(int... ints){
    int sum = 0;
    for (int temp : ints){
        sum += temp;
    }
    return sum;
}

@Override
public IBinder onBind(Intent intent) {
    return binder;
}复制代码

　　客户端代码：

private ServiceConnection serviceConnection;
private Messenger serverMessenger;
private IBinder mBoundService;
@Override
public void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.client_binder);
    findViewById(R.id.connect_binder).setOnClickListener(this);

    serviceConnection = new ServiceConnection() {
        @Override
        public void onServiceConnected(ComponentName name, IBinder service) {
            try {
                mBoundService = service;
                Class clazz = mBoundService.getClass();
                //如果两个应用程序没有运行在同一个进程中，则无法反射到该函数
                Method method = clazz.getDeclaredMethod("getServer");
                Object object = method.invoke(mBoundService);
                Class messenger = object.getClass();
                Method add = messenger.getDeclaredMethod("add", int[].class);
                L.e("1+2+3=" + add.invoke(object, new int[]{
   
   1,2,3}));
            } catch (NoSuchMethodException e) {
                e.printStackTrace();
            } catch (InvocationTargetException e) {
                e.printStackTrace();
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            }
        }

        @Override
        public void onServiceDisconnected(ComponentName name) {
            serverMessenger = null;
        }
    };
}

@Override
public void onClick(View v) {
    Intent intent = new Intent();
    intent.setClassName("com.android.messenger_a", "com.android.messenger_a.ServerWithBinder");
    bindService(intent, serviceConnection, BIND_AUTO_CREATE);
}

@Override
protected void onDestroy() {
    if (serverMessenger != null)
        unbindService(serviceConnection);
    super.onDestroy();
}复制代码

　　运行结果如下图所示：

　　

　　客户端通过onServiceConnected函数回调获取到该Binder对象，通过该Binder对象反射服务端Binder类的相关方法，在服务端的该相关方法getServer()中，直接返回该Service对象，获取到该Service对象之后就能够成功反射该类的所有方法，也就能够成功进行两个应用之间（虽然说不是两个进程）的通信了。

下载地址

源码地址：github.com/zhaozepeng/…

Service相关flag介绍

　　关于Service的详细介绍可以看我以前的一篇博客：

　　blog.csdn.net/self_study/…

　　这里简单介绍Service的相关flag标识，每次通过startService(Intent)函数启动Service都会调用到onStartCommand (Intent intent, int flags, int startId)函数，该函数第二个参数可以为 0，START_FLAG_REDELIVERY或者START_FLAG_RETRY：

  1. START_FLAG_REDELIVERY让系统重新发送一个intent，这样如果你的服务在处理它的时候被Kill掉，Intent不会丢失。
  2. START_FLAG_RETRY表示服务之前被设为START_STICKY，则会被传入这个标记。

　　onStartCommand (Intent intent, int flags, int startId)函数返回值有四个
START_STICKY、
START_NOT_STICKY、
START_REDELIVER_INTENT、
START_STICKY_COMPATIBILITY

  1. START_STICKY如果service进程被kill掉，保留service的状态为开始状态，但不保留递送的intent对象。随后系统会尝试重新创建service，由于服务状态为开始状态，所以创建服务后一定会调用onStartCommand(Intent,int,int)方法。如果在此期间没有任何启动命令被传递到service，那么参数Intent将为null。
  2. START_NOT_STICKY“非粘性的”，使用这个返回值时，如果在执行完onStartCommand后，服务被异常kill掉，系统不会自动重启该服务
  3. START_REDELIVER_INTENT重传Intent。使用这个返回值时，如果在执行完onStartCommand后，服务被异常kill掉，系统会自动重启该服务，并将Intent的值传入。
  4. START_STICKY_COMPATIBILITYSTART_STICKY的兼容版本，但不保证服务被kill后一定能重启。
版权声明：本文内容由互联网用户自发贡献，该文观点仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 举报，一经查实，本站将立刻删除。

发布者：全栈程序员-用户IM，转载请注明出处：https://javaforall.cn/108737.html原文链接：https://javaforall.cn

【正版授权，激活自己账号】： Jetbrains全家桶Ide使用，1年售后保障，每天仅需1毛

【官方授权 正版激活】： 官方授权 正版激活 支持Jetbrains家族下所有IDE 使用个人JB账号...

赞 (0)
全栈程序员-用户IM全栈程序员-用户IM
0 0


相关推荐

发表回复

您的电子邮箱地址不会被公开。

关注全栈程序员社区公众号