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();
        }
    }

     // ......
}

如下图所示：

ANR.jpg

原因就是：

前边说过 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，它是一个接口

图片.png

第二：在MyAIDLService.aidl接口中，定义两个方法，分别是两个int类型数据相加，把传递的字符串全部转为大写；

第三：然后点击 Build - Clean Project

图片.png

第四：如果成功，就会生成MyAIDLService.java类，如下图

图片.png

第五：然后在 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：

      <service android:name=".test_service.MyService"
            android:process=":remote"
            >
                <intent-filter >
                    <action android:name="com.novate.usual.test_service.aidl.MyAIDLService"/>
                </intent-filter>

            </service>

然后重新运行这第一个app项目，此时就把 远程Service 端的工作全部完成；

然后新建一个项目 ClientTest项目，需要做以下几步：

第一：把第一个项目中的 MyAIDLService.aidl文件连同包名所在路径全部拷贝到 ClientTest项目的包名下，然后重新 clean项目，和上边第一个项目处理方式一样，clean完成后就会生成MyAIDLService的java类，如下图所示：

图片.png

第二：然后在 ClientTest项目中的 activity_main.xml 中添加一个 button 按钮，如下，用于绑定服务：

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical"
    >

    <Button
        android:id="@+id/bind_service"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:text="Bind Service"
        />
</LinearLayout>

第三：然后在 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> 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