1. 概述
前边几篇文章记录了Service的基础知识点：Service基本用法、Service与Activity通信（本地通信）、Service销毁方式、Service与Thread关系、及如何创建前台进程等， 这篇文章记录下远程Service。
2. 现象
1>：通过Service演示：
下边先看一种现象：直接在MyService的 onCreate() 中添加 Thread.sleep(60000)，让线程睡眠60秒，然后点击MainActivity中的 startService或者bindService，过一会会ANR，
代码如下：
public class MyService extends Service {
// ......
@Override
public void onCreate() {
super.onCreate();
Log.e("TAG" , "onCreate__executed") ;
try {
Thread.sleep(60000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
// ......
}
如下图所示：
原因就是：
前边说过 Service与Activity一样，四大组件都一样，都是运行到主线程中的，如果在它们初始化比如 onCreate 方法中执行 Thread.sleep(60000)等耗时操作就会ANR；
2>：通过远程Service演示：
把普通Service变成 远程Service很简单，直接在 清单文件中添加 android:process=":remote"即可；
然后直接运行项目，不会ANR，onCreate__executed直接打印，1分钟后 onStartCommand__executed打印（我的没有打印）
原因就是：
远程Service，即就是MyService已经在另一个进程中运行，ANR只会阻塞它自己进程中的主线程，如果不是同一个进程，那么就不能阻塞另一个进程中的主线程；
在MainActivity的onCreate和MyService的onCreate中打印所在进程id，可以看到，远程MyService的包名也变了，如下：
com.novate.usual Activity process id is__18044
com.novate.usual:remote Service process id is__18276
如果把 MyService中的 Thread.sleep(60000)注释，点击 startService可以，点击 bindService，程序崩溃，原因是bindService用于 绑定 Service和Activity，但是仅限于同一个进程中，由于远程MyService已经在另一个进程中了，此时的Activity与MyService 就是两个不同的进程中，所以就不能用这种方式绑定了。
怎样让 Activity与远程MyService 建立关联呢，就是用 AIDL进行跨进程通信；
3. AIDL
AIDL：Android Interface Definition Language，安卓接口定义语言，用于跨进程通信，简单说，就是多个进程通信，不管是同一个项目下的多个进程，还是多个不同app项目中的多个进程；
可以实现 多个应用程序（多个app项目）共享一个Service 的功能；
1>：案例一：同一个app项目下的，当前进程和远程MyService进行通信
步骤如下：
第一：首先在之前项目包下创建 aidl 包，然后在aidl包下， New - Folder - AIDL Folder，创建 MyAIDLService.aidl，它是一个接口
第二：在MyAIDLService.aidl接口中，定义两个方法，分别是两个int类型数据相加，把传递的字符串全部转为大写；
第三：然后点击 Build - Clean Project
第四：如果成功，就会生成MyAIDLService.java类，如下图
第五：然后在 MyService中：首先实现MyAIDLService.Stub，实例对象为mBinder，然后重写 MyAIDLService接口中的两个方法，然后在 onBind方法中返回 mBinder对象，代码如下：
public class MyService extends Service {
@Override
public void onCreate() {
super.onCreate();
}
/**
* Binder是父类，Stub是子类
*
* 第一：这里首先对MyAIDLService.Stub进行实现，重写sum()和toUppercase()方法
*/
MyAIDLService.Stub mBinder = new MyAIDLService.Stub() {
/**
* 两个整数相加
*/
@Override
public int sum(int a, int b) throws RemoteException {
return a+b;
}
/**
* 将传入的字符串全部转为大写
*/
@Override
public String toUppercase(String str) throws RemoteException {
if (str != null){
return str.toUpperCase() ;
}
return null;
}
} ;
/**
* 第二：在 onBinde方法中直接返回 Stub的对象mBinder
*/
@Nullable
@Override
public IBinder onBind(Intent intent) {
return mBinder;
}
@Override
public int onStartCommand(Intent intent, int flags, int startId) {
Log.e("TAG" , "onStartCommand__executed") ;
return super.onStartCommand(intent, flags, startId);
}
@Override
public void onDestroy() {
super.onDestroy();
}
}
第六：然后在 ServiceActivity中修改 ServiceConnection中的代码，把 IBinder对象转为 MyAIDLService对象，就可以调用 MyAIDLService.aidl接口中所有的方法了，代码如下：
public class ServiceActivity extends AppCompatActivity implements View.OnClickListener {
private Button startService;
private Button stopService;
private Intent intent;
private Button bindService;
private Button unbindService;
private MyAIDLService myAIDLService ;
/**
* 创建匿名内部类，重写 onServiceConnected 和 onServiceDisconnected方法
* AIDL方式对应的 ServiceConnection
*
*/
private ServiceConnection connection = new ServiceConnection() {
@Override
public void onServiceConnected(ComponentName name, IBinder service) {
// 这里把 IBinder对象转为 MyAIDLService对象，就可以调用MyAIDLService.aidl文件中所有接口了
myAIDLService = MyAIDLService.Stub.asInterface(service) ;
try {
int result = myAIDLService.sum(5,5) ;
String upperStr = myAIDLService.toUppercase("yintao") ;
Log.e("TAG" , "result: "+result + ", upperStr: "+upperStr) ;
} catch (RemoteException e) {
e.printStackTrace();
}
}
@Override
public void onServiceDisconnected(ComponentName name) {
}
} ;
@Override
public void onCreate(@Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_service);
startService = (Button) findViewById(R.id.start_service);
stopService = (Button) findViewById(R.id.stop_service);
startService.setOnClickListener(this);
stopService.setOnClickListener(this);
bindService = (Button) findViewById(R.id.bind_service);
unbindService = (Button) findViewById(R.id.unbind_service);
bindService.setOnClickListener(this);
unbindService.setOnClickListener(this);
Log.e("TAG" , "Activity process id is__"+ Process.myPid()) ;
}
@Override
public void onClick(View v) {
switch (v.getId()){
// 启动服务
case R.id.start_service:
intent = new Intent(ServiceActivity.this , MyService.class);
startService(intent) ;
break;
// 停止服务
case R.id.stop_service:
intent = new Intent(ServiceActivity.this , MyService.class);
stopService(intent) ;
break;
// 绑定服务：将 Activity与Service绑定，接收3个参数：
// param_1: intent对象
// param_2: 上边的 ServiceConnection实例对象
// param_3: 一个标志位，BIND_AUTO_CREATE表示Activity与Service建立关联后，会自动创建Service
case R.id.bind_service:
Intent intent = new Intent(ServiceActivity.this , MyService.class) ;
bindService(intent , connection , BIND_AUTO_CREATE) ;
break;
// 解绑服务：解除 Activity与Service的关联
case R.id.unbind_service:
unbindService(connection);
break;
}
}
}
运行项目，先点击 startService开启服务，然后 点击bindService绑定服务，点击bindService就表示把当前进程 和 远程 MyService进行绑定，这个就是 跨进程通信了，绑定服务后 打印结果如下 ：
result: 10, upperStr: YINTAO
由上边可知：已经实现了跨进程通信，实现了一个进程中访问另一个进程的方法
2>：案例二：两个不同app下进程通信
我们知道，要让 Activity与Service通信，需要绑定二者，如果是同一个项目的Activity和Service，可以用如下方式：
Intent bindIntent = new Intent(this, MyService.class);
bindService(bindIntent, connection, BIND_AUTO_CREATE);
但是如果是两个app下的，第二个app肯定没有 MyService这个类，此时可以用 隐式intent，直接在第一个app的 清单文件中 给 MyService添加 action：
然后重新运行这第一个app项目，此时就把 远程Service 端的工作全部完成；
然后新建一个项目 ClientTest项目，需要做以下几步：
第一：把第一个项目中的 MyAIDLService.aidl文件连同包名所在路径全部拷贝到 ClientTest项目的包名下，然后重新 clean项目，和上边第一个项目处理方式一样，clean完成后就会生成MyAIDLService的java类，如下图所示：
第二：然后在 ClientTest项目中的 activity_main.xml 中添加一个 button 按钮，如下，用于绑定服务：
第三：然后在 MainActivity中，首先点击 bindService用于绑定第二个项目和 第一个项目的MyService服务，通过 隐式 intent，然后创建匿名内部类 ServiceConnection，重新两个方法 onServiceConnected 和 onServiceDisconnected ，在 前者中：把 IBinder对象转为 MyAIDLService，然后就可以调用 该接口下的所有方法了：
public class MainActivity extends AppCompatActivity {
private MyAIDLService myAIDLService ;
private ServiceConnection connection = new ServiceConnection() {
@Override
public void onServiceConnected(ComponentName name, IBinder service) {
// 这里把 IBinder 对象转为 MyAIDLService对象，就可以调用MyAIDLService.aidl接口中所有方法了
myAIDLService = MyAIDLService.Stub.asInterface(service) ;
try {
int result = myAIDLService.sum(50 , 50) ;
String upperStr = myAIDLService.toUppercase("come from ClientTest") ;
Log.e("TAG" , "跨进程通信的：result: "+result + ", upperStr: "+upperStr) ;
} catch (RemoteException e) {
e.printStackTrace();
}
}
@Override
public void onServiceDisconnected(ComponentName name) {
}
} ;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
Button bind_service = (Button) findViewById(R.id.bind_service);
bind_service.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
Intent intent = new Intent("com.novate.usual.test_service.aidl.MyAIDLService") ;
final Intent eintent = new Intent(createExplicitFromImplicitIntent(MainActivity.this,intent));
bindService(eintent , connection , BIND_AUTO_CREATE) ;
}
});
}
/***
* 隐式调用intent，5.0以上手机会报错：Service Intent must be explicit，
* 重写下边这个方法就可以
*/
public static Intent createExplicitFromImplicitIntent(Context context, Intent implicitIntent) {
// Retrieve all services that can match the given intent
PackageManager pm = context.getPackageManager();
List resolveInfo = pm.queryIntentServices(implicitIntent, 0);
// Make sure only one match was found
if (resolveInfo == null || resolveInfo.size() != 1) {
return null;
}
// Get component info and create ComponentName
ResolveInfo serviceInfo = resolveInfo.get(0);
String packageName = serviceInfo.serviceInfo.packageName;
String className = serviceInfo.serviceInfo.name;
ComponentName component = new ComponentName(packageName, className);
// Create a new intent. Use the old one for extras and such reuse
Intent explicitIntent = new Intent(implicitIntent);
// Set the component to be explicit
explicitIntent.setComponent(component);
return explicitIntent;
}
}
此时第二个项目 ClientTest所有代码就写完了，然后直接运行这个项目，点击bindService，此时这第二个项目就会和第一个项目的MyService进行绑定，打印结果如下：
跨进程通信的：result: 100, upperStr: COME FROM CLIENTTEST
到这里就实现了 2个app项目下的 跨进程通信
4. 2个app跨进程通信步骤总结
其实就是第二个app项目 和 第一个app的 MyService进行通信，实现步骤如下：
对于第一个app项目：
1>：首先创建 MyService，然后创建aidl包，在aidl包下创建 MyAIDLService.aidl接口文件，然后clean，生成MyAIDLService.java类；
2>：然后在清单文件中：把 MyService声明成远程的，同时添加intent-filter和action，说明是隐式的；
对于第二个app项目：ClientTest
1>：首先把第一个项目的MyAIDLService.aidl接口文件包括所在的包名全部拷贝到 ClientTest项目的包名下，然后clean；
2>：然后创建 activity_main.xml文件，里边写一个 bindService的按钮，用于绑定第二个项目和第一个项目的MyService远程服务；
3>：然后在MainActivity中，创建匿名内部类ServiceConnection，重写两个方法，在服务连接成功方法中：把 IBinder 对象转为 MyAIDLService，然后就可以调用 该接口中所有的方法了；
以上就是2个app项目进行跨进程通信的具体步骤了；
可以延伸，如果是多个app进行跨进程通信，都可以按照第二个app项目的操作方式，这样就可以实现：让一个Service和多个app进行跨进程通信，
5. 注意
2个进程或者多个进程通信，是需要传递数据的，Android对于跨进程通信传递数据类型支持：8种基本数据类型、String字符串、List或者Map， 如果想要传递自定义的对象或者服务器返回的对象，这个时候就必须让其实现 Parcelable或者Serializable ，并且给这个对象也定义一个同名的AIDL文件，如果项目中有这方面需要，百度下就可以
代码已上传至github：
https://github.com/shuai999/ServiceTest.git
https://github.com/shuai999/ClinetTest.git