关于AIDL

转载自 https://blog.csdn.net/singwhatiwanna/article/details/17041691

1. 创建一个包名用来存放aidl文件

创建一个包名用来存放aidl文件,比如com.ryg.sayhi.aidl，在里面新建IMyService.aidl文件，如果需要访问自定义对象，还需要建立对象的aidl文件，这里我们由于使用了自定义对象Student，所以，还需要创建Student.aidl和Student.java。注意，这三个文件，需要都放在com.ryg.sayhi.aidl包里。下面描述如何写这三个文件。
 

package com.ryg.sayhi.aidl;
 
import com.ryg.sayhi.aidl.Student;
 
interface IMyService {
 
    List<Student> getStudent();
    void addStudent(in Student student);
}

AS会自动生成public static abstract class Stub extends android.os.Binder implements com.ryg.sayhi.aidl.IMyService
可见这个Stub类就是一个普通的Binder，只不过它实现了我们定义的aidl接口。它还有一个静态方法
public static com.ryg.sayhi.aidl.IMyService asInterface(android.os.IBinder obj)
这个方法很有用，通过它，我们就可以在客户端中得到IMyService的实例，进而通过实例来调用其方法。

2.创建服务端service

创建一个service，比如名为MyService.java，代码如下：

/**
 * @author scott
 */
public class MyService extends Service
{
    private final static String TAG = "MyService";
    private static final String PACKAGE_SAYHI = "com.example.test";
 
    private NotificationManager mNotificationManager;
    private boolean mCanRun = true;
    private List<Student> mStudents = new ArrayList<Student>();
    
    //这里实现了aidl中的抽象函数
    private final IMyService.Stub mBinder = new IMyService.Stub() {
 
        @Override
        public List<Student> getStudent() throws RemoteException {
            synchronized (mStudents) {
                return mStudents;
            }
        }
 
        @Override
        public void addStudent(Student student) throws RemoteException {
            synchronized (mStudents) {
                if (!mStudents.contains(student)) {
                    mStudents.add(student);
                }
            }
        }
 
        //在这里可以做权限认证，return false意味着客户端的调用就会失败，比如下面，只允许包名为com.example.test的客户端通过，
        //其他apk将无法完成调用过程
        public boolean onTransact(int code, Parcel data, Parcel reply, int flags)
                throws RemoteException {
            String packageName = null;
            String[] packages = MyService.this.getPackageManager().
                    getPackagesForUid(getCallingUid());
            if (packages != null && packages.length > 0) {
                packageName = packages[0];
            }
            Log.d(TAG, "onTransact: " + packageName);
            if (!PACKAGE_SAYHI.equals(packageName)) {
                return false;
            }
 
            return super.onTransact(code, data, reply, flags);
        }
 
    };
 
    @Override
    public void onCreate()
    {
        Thread thr = new Thread(null, new ServiceWorker(), "BackgroundService");
        thr.start();
 
        synchronized (mStudents) {
            for (int i = 1; i < 6; i++) {
                Student student = new Student();
                student.name = "student#" + i;
                student.age = i * 5;
                mStudents.add(student);
            }
        }
 
        mNotificationManager = (NotificationManager) getSystemService(NOTIFICATION_SERVICE);
        super.onCreate();
    }
 
    @Override
    public IBinder onBind(Intent intent)
    {
        Log.d(TAG, String.format("on bind,intent = %s", intent.toString()));
        displayNotificationMessage("服务已启动");
        return mBinder;
    }
 
    @Override
    public int onStartCommand(Intent intent, int flags, int startId)
    {
        return super.onStartCommand(intent, flags, startId);
    }
 
    @Override
    public void onDestroy()
    {
        mCanRun = false;
        super.onDestroy();
    }
 
    private void displayNotificationMessage(String message)
    {
        //dosomething
    }
 
    class ServiceWorker implements Runnable
    {
        long counter = 0;
 
        @Override
        public void run()
        {
            // do background processing here.....
            while (mCanRun)
            {
                Log.d("scott", "" + counter);
                counter++;
                try
                {
                    Thread.sleep(2000);
                } catch (InterruptedException e)
                {
                    e.printStackTrace();
                }
            }
        }
    }
 
}

上述代码的关键在于onBind函数，当客户端bind上来的时候，将IMyService.Stub mBinder返回给客户端，这个mBinder是aidl的存根，其实现了之前定义的aidl接口中的抽象函数。

问题：问题来了，有可能你的service只想让某个特定的apk使用，而不是所有apk都能使用，这个时候，你需要重写Stub中的onTransact方法，根据调用者的uid来获得其信息，然后做权限认证，如果返回true，则调用成功，否则调用会失败。对于其他apk，你只要在onTransact中返回false就可以让其无法调用IMyService中的方法，这样就可以解决这个问题了。
   

3. 在AndroidMenifest中声明service

        <service
            android:name="com.ryg.sayhi.MyService"
            android:process=":remote"
            android:exported="true" >
            <intent-filter>
                <category android:name="android.intent.category.DEFAULT" />
                <action android:name="com.ryg.sayhi.MyService" />
            </intent-filter>
        </service>

说明：上述的 <action android:name="com.ryg.sayhi.MyService" />是为了能让其他apk隐式bindService，通过隐式调用的方式来起activity或者service，需要把category设为default，这是因为，隐式调用的时候，intent中的category默认会被设置为default。
 

4.新建一个工程，充当客户端

新建一个客户端工程，将服务端工程中的com.ryg.sayhi.aidl包整个拷贝到客户端工程的src下，这个时候，客户端com.ryg.sayhi.aidl包是和服务端工程完全一样的。如果客户端工程中不采用服务端的包名，客户端将无法正常工作，比如你把客户端中com.ryg.sayhi.aidl改一下名字，你运行程序的时候将会crash，也就是说，客户端存放aidl文件的包必须和服务端一样。客户端bindService的代码就比较简单了，如下：
 

import com.ryg.sayhi.aidl.IMyService;
import com.ryg.sayhi.aidl.Student;
 
public class MainActivity extends Activity implements OnClickListener {
 
    private static final String ACTION_BIND_SERVICE = "com.ryg.sayhi.MyService";
    private IMyService mIMyService;
 
    private ServiceConnection mServiceConnection = new ServiceConnection()
    {
        @Override
        public void onServiceDisconnected(ComponentName name)
        {
            mIMyService = null;
        }
 
        @Override
        public void onServiceConnected(ComponentName name, IBinder service)
        {
            //通过服务端onBind方法返回的binder对象得到IMyService的实例，得到实例就可以调用它的方法了
            mIMyService = IMyService.Stub.asInterface(service);
            try {
                Student student = mIMyService.getStudent().get(0);
                showDialog(student.toString());
            } catch (RemoteException e) {
                e.printStackTrace();
            }
 
        }
    };
 
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        Button button1 = (Button) findViewById(R.id.button1);
        button1.setOnClickListener(new OnClickListener() {
 
    @Override
    public void onClick(View view) {
        if (view.getId() == R.id.button1) {
            Intent intentService = new Intent(ACTION_BIND_SERVICE);
            intentService.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
            MainActivity.this.bindService(intentService, mServiceConnection, BIND_AUTO_CREATE);
        }
 
    }
 
    public void showDialog(String message)
    {
        new AlertDialog.Builder(MainActivity.this)
                .setTitle("scott")
                .setMessage(message)
                .setPositiveButton("确定", null)
                .show();
    }
    
    @Override
    protected void onDestroy() {
        if (mIMyService != null) {
            unbindService(mServiceConnection);
        }
        super.onDestroy();
    }
}