AIDL进程间通信

最新推荐文章于 2024-04-17 21:45:27 发布

原创最新推荐文章于 2024-04-17 21:45:27 发布 · 265 阅读

CC 4.0 BY-SA版权

该博客详细介绍了如何使用AIDL（Android Interface Definition Language）进行进程间通信（IPC）。首先，在服务端创建aidl文件和对应的Book类，声明Parcelable数据类型。接着，创建Service并指定Action以供客户端绑定。在客户端，复制服务端的aidl文件和Book类，设置布局和MainActivity。最后，讨论了startService与bindService的区别和使用场景。

一.创建一个Service端工程：
1.新建一个aidl文件，创建完成后系统会默认创建一个aidl文件夹，aidl文件中有一个默认方法，可以删掉。改为声明Parcelable数据类型的aidl文件。
在这里插入图片描述
2.创建一个类，Book.java,只包含Name属性，并实现Parcelable接口。

public class Book implements Parcelable {
private String name;
public Book(){
}
public Book(String name){
    this.name = name;
}

public String getName() {
    return name;
}

public void setName(String name) {
    this.name = name;
}

@Override
public String toString() {
    return "book name: " + name;
}

@Override
public int describeContents() {
    return 0;
}

@Override
public void writeToParcel(Parcel parcel, int i) {
    parcel.writeString(this.name);
}

public void readFromParcel(Parcel parcel){
    parcel.readString();
}

protected Book(Parcel parcel){
    this.name = parcel.readString();
}
public static final Creator<Book> CREATOR = new Creator<Book>() {
    @Override
    public Book createFromParcel(Parcel parcel) {
        return new Book(parcel);
    }

    @Override
    public Book[] newArray(int i) {
        return new Book[i];
    }
};
}

3.服务端需要暴露给客户端一个获取书籍列表以及添加的方法，方法需要定义在AIDl文件中，新建一个aidl文件，BookController.aidl文件。List需要明确导包。

// BookController.aidl
package com.text.aidlservice;
import com.text.aidlservice.Book;
interface BookController {
 List<Book> getBookList();
void addBookInOut(inout Book book);
void addBookIn(in Book book);
void addBookOut(out Book book);
}

在进程间通信中真正器作用的不是aidl文件，而是系统据此而生成的文件，之后需要使用到当中的内部静态抽象类Stub。
在这里插入图片描述
4.创建一个Service供给客户端远程绑定，

public class AIDLService extends Service {
private String TAG = "Service";
private List<Book> bookList;
public AIDLService(){

}

@Override
public void onCreate() {
    super.onCreate();
    bookList = new ArrayList<>();
    initData();
}

private void initData() {
    Book book1 = new Book("墨菲定律");
    Book book2 = new Book("羊皮卷");
    Book book3 = new Book("面向对象");
    Book book4 = new Book("java");
    Book book5 = new Book("android");
    bookList.add(book1);
    bookList.add(book2);
    bookList.add(book3);
    bookList.add(book4);
    bookList.add(book5);
}
private final BookController.Stub stub = new BookController.Stub() {
    @Override
    public List<Book> getBookList() throws RemoteException {
        return bookList;
    }

    @Override
    public void addBookInOut(Book book) throws RemoteException {
        if (book != null){
            book.setName("Service改了新书名字 InOut");
            bookList.add(book);
        }else{
            Log.e(TAG,"接收到空对象 InOut");
        }
    }

    @Override
    public void addBookIn(Book book) throws RemoteException {
        if (book != null) {
            book.setName("服务器改了新书的名字 IN");
            bookList.add(book);
        }else{
            Log.e(TAG,"接收到空对象 In");
        }
    }

    @Override
    public void addBookOut(Book book) throws RemoteException {
        if (book != null) {
            Log.e(TAG,"客户端传来的书的名字：" + book.getName());
            book.setName("服务器传来的新书的名字 Out");
            bookList.add(book);
        }else{
            Log.e(TAG,"接收到空对象 out");
        }
    }
};

@Override
public int onStartCommand(Intent intent, int flags, int startId) {
    Log.e(TAG,"onStartCommand");
    return super.onStartCommand(intent, flags, startId);
}

@Nullable
@Override
public IBinder onBind(Intent intent) {
    return stub;
}
}

服务端需要被客户端远程绑定，可以通过先指定包名，之后在配置Action值或者直接指定Service类名的方式来绑定Service。采用配置Action方案。

<service android:name=".AIDLService"
        android:enabled="true"
        android:exported="true">
        <intent-filter>
            <action android:name="com.text.aidlservice.action" />
            <category android:name="android.intent.category.DEFAULT" />
        </intent-filter>
    </service>

二.创建一个Client工程：
1，先把服务端的aidl文件复制到java文件夹同个层级下，不需要改任何代码。
2.需要创建和服务端Book类所在的相同包名来存放Book类。Service端Book.java复制到Client
3.修改布局文件，添加两个Button。
4.修改mainActivity文件。

class MainActivity extends AppCompatActivity {
private final String TAG = "Client";
private BookController bookController;
private boolean connected;
private List<Book> bookList;
private ServiceConnection serviceConnection = new ServiceConnection() {
    @Override
    public void onServiceConnected(ComponentName componentName, IBinder iBinder) {
        Log.d(TAG,"onServiceConnected");
        bookController = BookController.Stub.asInterface(iBinder);
        connected = true;
    }

    @Override
    public void onServiceDisconnected(ComponentName componentName) {
        connected = false;
    }
};

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);
    bindService();
    Log.d(TAG,"onCreate");
    findViewById(R.id.btn1).setOnClickListener(clickListener);
    findViewById(R.id.btn2).setOnClickListener(clickListener);
    findViewById(R.id.btn3).setOnClickListener(clickListener);
    findViewById(R.id.btn4).setOnClickListener(clickListener);

}

private void bindService() {
    Intent intent = new Intent();
    intent.setPackage("com.text.aidlservice");
    intent.setAction("com.text.aidlservice.action");
    startService(intent);
    bindService(intent, serviceConnection, Context.BIND_AUTO_CREATE);
    Log.d(TAG,"bindService");
}

private View.OnClickListener clickListener = new View.OnClickListener() {
    @Override
    public void onClick(View view) {
        switch (view.getId()){
            case R.id.btn1:
                Log.d(TAG, "connected = " + connected);
                if (connected){
                    try {
                        bookList = bookController.getBookList();
                    } catch (RemoteException e) {
                        e.printStackTrace();
                    }
                    Log.d(TAG, "log");
                    log();
                }
                break;
            case R.id.btn2:
                if (connected){
                    Book book = new Book("In Out");
                    try {
                        bookController.addBookInOut(book);
                        Log.e(TAG,"向服务器以InOut方式添加一本新书,name:" + book.getName());

                    } catch (RemoteException e) {
                        e.printStackTrace();
                    }
                }
                break;
            case R.id.btn3:
                if (connected){
                    Book book = new Book("In");
                    try {
                        bookController.addBookIn(book);
                        Log.e(TAG,"向服务器以In方式添加一本新书,name:" + book.getName());

                    } catch (RemoteException e) {
                        e.printStackTrace();
                    }
                }
                break;
            case R.id.btn4:
                if (connected){
                    Book book = new Book("Out");
                    try {
                        bookController.addBookOut(book);
                        Log.e(TAG,"向服务器以Out方式添加一本新书,name:" + book.getName());

                    } catch (RemoteException e) {
                        e.printStackTrace();
                    }
                }
                break;
        }
    }
};

@Override
protected void onDestroy() {
    super.onDestroy();
    if (connected){
        unbindService(serviceConnection);
    }
}

private void log(){
    for (Book book: bookList){
        Log.d(TAG, book.toString());
    }
}
}

三.服务的两种启动方式
1.startService:通过调用startservice()启动服务，以无限期运行。onCreate->onStartCommand()->onDestory().
一旦启动，服务即可在后台无限期运行，即使启动服务的组件已被销毁也不受影像。
以启动的服务通常是执行单一操作，而且不会将结果返回给调用方。
startService(intent);
2.绑定：bindService()绑定到服务。onCreate->onBind()->onDestory
提供一个客户端-服务器接口，允许组件与服务进行交互，发送请求，获取结果，甚至是利用进程间通信（IPC）跨进程执行这些操作。
bindService（intent，ServiceConnection，BIND_AUTO_CREATE）；