首先，我们可以想一些通信的方式，
- 第一种方式就是需要有一个消息的发送方（client，指发送消息），消息的接收方（server-接收并处理消息）
- 第二种方式就是发送方和接收方都向同一个消息中心发送消息，消息中心负责将消息转发给对应的接收方
- 第三种方式就是通过访问共享对象，达到通信
大部分通信基于以上俩种方式来实现的，接下来我们看下Android
为我们提供的进程通信方式有哪些
一，广播
通过系统AMS的机制实现多进程通信
二，ContentProvider
通过共享内容的方式
三，共享文件
并发不多或者无并发的情况可以使用
四，Socket
服务端建立severSocket，客户端建立连接，实现相互通信。socket常用于网络通信
五，使用Bundle的方式
-
传输的数据必须基本数据类型或者能够被序列化
- 基本数据类型（int, long, char, boolean, double等）
- String和CharSequence
- List：只支持ArrayList，并且里面的元素都能被AIDL支持
- Map：只支持HashMap，里面的每个元素能被AIDL支持
- Parcelable：所有实现Parcelable接口的对象
-
利用Bundle进行进程间通信
Intent intent = new Intent(MainActivity.this, MyActivity.class); Bundle bundle = new Bundle(); bundle.putString("data", "data"); intent.putExtras(bundle); startActivity(intent);
利用Bundle进行进程间通信是很容易的，大家应该注意到，这种方式进行进程间通信只能是单方向的简单数据传输，它使用时有一定的局限性。
六，Messenger（信息员）
消息是单向的，使用的是handler来实现，因此并发的效率不高，适合消息较少的情况下使用
1，消息的发送方：
public class ClientActivity extends AppCompatActivity {
private Messenger mPutMessage;
private final WeakHandler mClientHandler = new WeakHandler(msg -> {
try {
// msg.replyTo = new Messenger()
if(mPutMessage != null)mPutMessage.send(msg);
} catch (RemoteException e) {
e.printStackTrace();
}
});
@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
Intent i = new Intent(this, MessagerService.class);
bindService(i, conn, Service.BIND_AUTO_CREATE);
Button btn = new Button(this);
setContentView(btn);
btn.setText("send");
btn.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View view) {
Message pool = Message.obtain();
pool.what = 1;
Bundle bundle = new Bundle();
bundle.putString("key", "test messager");
pool.obj = bundle;
mClientHandler.sendMessage(pool);
}
});
}
private final ServiceConnection conn = new ServiceConnection() {
@Override
public void onServiceConnected(ComponentName componentName, IBinder iBinder) {
mPutMessage = new Messenger(iBinder);
}
@Override
public void onServiceDisconnected(ComponentName componentName) {
mPutMessage = null;
}
};
@Override
protected void onDestroy() {
super.onDestroy();
unbindService(conn);
}
}
2，消息的接收方
public class MessagerService extends Service {
private final WeakHandler mServiceHandler = new WeakHandler(msg -> {
switch (msg.what) {
case 1:
Log.e("MessagerService", "服务端收到客户端的消息=" + msg.obj);
Bundle b = (Bundle) msg.obj;
Toast.makeText(getApplicationContext(), "服务端收到客户端的消息=" + b.getString("key"), Toast.LENGTH_LONG).show();
break;
default:
break;
}
});
private Messenger messenger;
@Override
public void onCreate() {
super.onCreate();
messenger = new Messenger(mServiceHandler);
}
@Override
public IBinder onBind(Intent intent) {
return messenger.getBinder();
}
}
注意:这种方式的消息不仅是单向的，而且发送的所有消息类型必须是实现Parcelable序列化的，否则会 Can't marshal non-Parcelable objects across processes.异常
七，AIDL
Android系统内的大部分进程通信都是基于AIDL来实现的
1，创建进程通信桥梁-AIDl文件
MediaInfo.aidl
package com.aidl.data;
// Declare any non-default types here with import statements
parcelable MediaInfo;
IMeidia.aidl
package com.aidl;
import com.aidl.data.MediaInfo;
// Declare any non-default types here with import statements
interface IMeidia {
MediaInfo getMeidiaInfo();
void playMedia(String url);
void stopMedia();
}
2，声明进程通信访问对象
public class MediaInfo implements Parcelable {
public int mediaId;
public String mediaName;
public String url;
public MediaInfo(int mediaId, String mediaName, String url) {
this.mediaId = mediaId;
this.mediaName = mediaName;
this.url = url;
}
protected MediaInfo(Parcel in) {
mediaId = in.readInt();
mediaName = in.readString();
}
@Override
public void writeToParcel(Parcel dest, int flags) {
dest.writeInt(mediaId);
dest.writeString(mediaName);
}
@Override
public int describeContents() {
return 0;
}
public static final Creator<MediaInfo> CREATOR = new Creator<MediaInfo>() {
@Override
public MediaInfo createFromParcel(Parcel in) {
return new MediaInfo(in);
}
@Override
public MediaInfo[] newArray(int size) {
return new MediaInfo[size];
}
};
@Override
public String toString() {
return "MediaInfo{" +
"mediaId=" + mediaId +
", mediaName='" + mediaName + '\'' +
'}';
}
}
2,建立服务端
/**
* 进程通信服务端
*/
public class MediaService extends Service {
public static final String ACTION = "service.com.aidl.MediaService";
private final com.aidl.IMeidia.Stub mBinder = new com.aidl.IMeidia.Stub() {
@Override
public MediaInfo getMeidiaInfo() throws RemoteException {
return new MediaInfo(10001, MediaService.class.getSimpleName(), "");
}
@Override
public void playMedia(String url) throws RemoteException {
startPlayer(url);
}
@Override
public void stopMedia() throws RemoteException {
stopMPlayer();
}
};
@Override
public IBinder onBind(Intent intent) {
return mBinder;
}
}
2，客户端绑定server，获取消息或者发送消息
public class AidlClientActivity extends Activity {
private com.aidl.IMeidia mMedia;
private final ServiceConnection mConn = new ServiceConnection() {
@Override
public void onServiceConnected(ComponentName name, IBinder service) {
mMedia = com.aidl.IMeidia.Stub.asInterface(service);
try {
//获取消息
mMedia.getMeidiaInfo();
//发送消息
mMedia.playMedia("url");
} catch (RemoteException e) {
e.printStackTrace();
}
}
@Override
public void onServiceDisconnected(ComponentName name) {
try {
mMedia.stopMedia();
mMedia = null;
} catch (RemoteException e) {
e.printStackTrace();
}
}
};
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
Intent i = new Intent(this, MediaService.class);
bindService(i, mConn, Context.BIND_AUTO_CREATE);
}
@Override
protected void onDestroy() {
super.onDestroy();
unbindService(mConn);
}
}
网友评论