安卓Service完全解析(中)

摘要: 版权声明：本文出自汪磊的博客，转载请务必注明出处。

 

在上一篇中我们学习了Android Service相关的许多基础但是重要的内容，基本涵盖大部分平日里的开发工作。今天我们继续学习一下稍微高级一点的用法，即：远程Service用法，使用远程Service可以实现安卓跨进程通信的功能。下面我们就开始学习一下吧。

什么是远程Service?

所谓的远程Service就是与调用者不在同一进程的Service即可叫做远程Service。那是不是也有近程Service？其实不叫近程Service，专业叫法叫做本地Service，就是调用者与Service在同一进程。

 

调用远程Service的桥梁-AIDL接口定义语言

由于远程服务与调用者不在同一进程，我们不能再像调用本地服务一样的方式去调用远程服务，

那么如何才能让Activity与一个远程Service建立关联呢？这就要使用AIDL来进行跨进程通信了（IPC）。

AIDL（Android Interface Definition Language）是Android接口定义语言的意思，它可以用于让某个Service与多个应用程序组件之间进行跨进程通信，从而可以实现多个应用程序共享同一个Service的功能。（本篇着重讲解与远程服务通信的过程，不涉及AIDL接口定义语言的细节讲解）

 

废话少说，下面我们通过一个简单的Demo来讲解一下与远程Service通信的过程。

首先我们新建一个远程服务Demo的工程，新建RemoteService.aidl文件，代码如下：

package com.wl.remoteservice;
interface RemoteService{
    int call(int a,int b);
}

 

我们点击完保存之后，在gen目录下会生成一个与之对应的java文件，如下：

关于文件中内容我们暂时不细究，会在下篇的时候在研究一下。

然后编写Service类，新建WLService继承Service，如下：

public class WLService extends Service {

    private static final String TAG = "HEART";
    @Override
    public IBinder onBind(Intent intent) {
        Log.i(TAG, "onBind");
        return new MyBinder();
    }

    private int methodInRemoteService(int a,int b){

        return a+b;
    }
    
    private class MyBinder extends RemoteService.Stub{
        
        @Override
        public int call(int a,int b) {
            
            return methodInRemoteService(a,b);
        }        
    }
    
    @Override
    public void onCreate() {
        Log.i(TAG, "onCreate");
        super.onCreate();
    }
    
    @Override
    public boolean onUnbind(Intent intent) {
        Log.i(TAG, "onUnbind");
        return super.onUnbind(intent);

    }
    @Override
    public void onDestroy() {
        Log.i(TAG, "onDestroy");
        super.onDestroy();
    }
    
}

 

这里我们定义了一个内部类MyBinder继承自RemoteService.Stub，那这个stub是什么玩意呢？点进去看一下，如下

 public static abstract class Stub extends android.os.Binder implements com.wl.remoteservice.RemoteService 

看定义我们就明白了，原来MyBinder就是Binder子类并且实现了RemoteService接口，所以在onBind的时候返回其实例也就容易理解了。

接下来，在清单文件注册Service。这里我们需要在另一个应用程序启动WLService，但是在另一个应用程序中去绑定Service的时候并没有WLService这个类，这时就必须使用到隐式Intent了。现在修改AndroidManifest.xml中的代码，给WLService加上一个action，如下所示：

 

        <service android:name="com.wl.remoteservice.WLService">
            <intent-filter >
                <action android:name="com.wanglei.remoteservice"/>
            </intent-filter>
        </service>

然后我们新建一个项目用以调用上面项目中的远程服务，新项目就叫做：调用远程服务。

首先需要将RemoteService.aidl拷贝过来，记住需要连同原包路径一同拷贝过来，如下：

 

接下来，修改布局文件：

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical"
    tools:context=".MainActivity" >

    <Button
        android:layout_width="fill_parent"
        android:layout_height="wrap_content"
        android:onClick="bind"
        android:text="绑定服务" />

    <Button
        android:layout_width="fill_parent"
        android:layout_height="wrap_content"
        android:onClick="unbind"
        android:text="解除绑定服务" />

    <Button
        android:layout_width="fill_parent"
        android:layout_height="wrap_content"
        android:onClick="click"
        android:text="调用远程服务方法" />

</LinearLayout>

然后编写MainActivity中代码，如下：

public class MainActivity extends Activity {
    private static final String TAG = "HEART";
    private RemoteService mRemoteService;
    private MyConn conn;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
    }
    
    public void bind(View view){
        Intent intent = new Intent();
        intent.setAction("com.wanglei.remoteservice");
        conn = new MyConn();
        bindService(intent, conn, BIND_AUTO_CREATE);//异步的操作
    }
    
    public void unbind(View view){
        unbindService(conn);
    }    
    
    public void click(View view){

        if(null != mRemoteService){
            try {
                int result = mRemoteService.call(10,20);
                Log.i(TAG, "result = "+result);
            } catch (RemoteException e) {
                e.printStackTrace();
            }
        }
    }
    
    private class MyConn implements ServiceConnection{
        @Override
        public void onServiceConnected(ComponentName name, IBinder service) {
            
            mRemoteService = RemoteService.Stub.asInterface(service);
        }

        @Override
        public void onServiceDisconnected(ComponentName name) {
            
        }
    }
}

会发现和上篇讲的bind服务差别不大，这里我们需要在另一程序里面绑定服务所以需要用隐式意图开启。

这里我们需要注意一下，在安卓5.0出来以后，服务意图必须用显式调用，调用bind服务的时候会报如下警告

我们找一下源码，看看哪里报的这个警告，终于在 sdk/sources/android-21/android/app/ContextImpl.Java目录下找到报警告的代码：

    private void validateServiceIntent(Intent service) {
        if (service.getComponent() == null && service.getPackage() == null) {
            if (getApplicationInfo().targetSdkVersion >= Build.VERSION_CODES.LOLLIPOP) {
                IllegalArgumentException ex = new IllegalArgumentException(
                        "Service Intent must be explicit: " + service);
                throw ex;
            } else {
                Log.w(TAG, "Implicit intents with startService are not safe: " + service
                        + " " + Debug.getCallers(2, 3));
            }
        }
    }

好了找到报错的原因了，那怎么解决呢？观察源码发现最外层if判断的时候有个service.getPackage() == null，我们只需要使其不为null不就可以了，这也是谷歌推荐的解决方法

我们将绑定服务的方法改为如下：

public void bind(View view){
        Intent intent = new Intent();
        intent.setAction("com.wanglei.remoteservice");
        intent.setPackage("com.wl.remoteservice");//设置为Service所在包名
        conn = new MyConn();
        bindService(intent, conn, BIND_AUTO_CREATE);//异步的操作
}

这样修改就好了，当然还有另外一种解决方法，将隐式意图变为显示意图，方法如下：

public static Intent getExplicitIntent(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;  
    } 

好了，通过以上两种方式就可以解决了，到此我们两个项目都已经编写完毕，先运行远程服务demo项目，在运行调用远程服务项目，点击绑定远程服务按钮，然后点击调用远程服务按钮，打印如下：

到此为止，我们成功调用了远程服务中的方法，跨进程通信成功实现，不过有些刚接触的同学可能还有些混乱，怎么觉得那么混乱，比平时用的组建多那么多步骤，那我们总结一下调用远程服务的步骤：

1.编写aidl文件

2.创建远程服务类，在服务的内部创建一个内部类提供一个方法，可以间接调用服务的方法

3.实现服务的onbind方法，返回服务内部类实例

4.拷贝aidl文件到另一工程联同包名

5.在activity 绑定服务。bindService();

6.在服务成功绑定的时候 会执行一个方法 onServiceConnected 传递过来一个 IBinder对象进行类型转换

7.调用远程服务里面的方法。

 

好了，到这里关于服务的所有最重要的部分都已经讲解完了，通过(上)(中)两篇相信你对服务有了一个全面的认识。