3.Android中的IPC方式---使用AIDL（2）

最新推荐文章于 2024-06-21 17:23:06 发布

金栗

最新推荐文章于 2024-06-21 17:23:06 发布

阅读量115

点赞数

分类专栏： Android开发文章标签： java android

本文链接：https://blog.csdn.net/m0_38088392/article/details/106638919

版权

Android开发专栏收录该内容

28 篇文章 0 订阅

订阅专栏

我们接着再调用一下另外一个接口addBook，我们在客户端给服务器添加一本书，然后再获取一次，看程序是否能够正常工作。还是上次的代码，客户端在服务连接后，在onServiceConnected中做如下改动

public void onServiceConnected(ComponentName name, IBinder service) {
            IBookManager bookManager = IBookManager.Stub.asInterface(service);
            try {
                List<Book> list = bookManager.getBookList();
                Log.i(TAG,"query book list:" + list.toString());
                Book newBook = new Book(3,"Android开发艺术探索");
                bookManager.addBook(newBook);
                Log.i(TAG,"add book:"+ newBook);
                List<Book> newList = bookManager.getBookList();
                Log.i(TAG,"query book list:"+ newList.toString());
            }catch (RemoteException e){
                e.printStackTrace();
            }
        }

运行后我们再看一下log，很显然，我们成功地向服务器添加了一本书“Android开发艺术探索”。
在这里插入图片描述
假设有一种需求：用户不想时不时去查询图书列表了，太累了，于是，他想“当有新书时能不能把书的信息告诉我呢？”。这就是一种典型的观察者模式，每个感兴趣的用户都观察新书，当新书到的时候，图书馆就通知每一个对这本书感兴趣的用户，这种模式在实际开发中用的很多。为了模拟这种情形，首先我们需要提供一个AIDL接口，每个用户都需要实现这个接口并且向图书馆申请新书的提醒功能，当然用户也可以随时取消这种提醒。之所以选择AIDL接口而不是普通接口，是因为AIDL中无分发使用普通接口。
这里我们创建一个IOnNewBookArrivedListener.aidl文件，从程序上说就是调用所有的IOnNewBookArrivedListener中的onNewBookArrived方法，并把新书的对象通过参数传递给客户端，内容如下所示

// IOnNewBookArrivedListener.aidl
package com.example.aidl;

// Declare any non-default types here with import statements
import com.example.aidl.Book;
interface IOnNewBookArrivedListener {
    void onNewBookArrived(in Book newBook);
}

除了要新加一个AIDL接口，还要在原有的接口中添加两个新方法，代码如下

// IBookManager.aidl
package com.example.aidl
// Declare any non-default types here with import statements
import com.example.aidl.Book;
interface IBookManager {
    List<Book> getBookList();
    void  addBook(in Book book);
    void registerListener(IOnNewBookArrivedListener listener);
    void unregisterListener(IOnNewBookArrivedListener listener);
}

接着，服务端中的Service的实现也要稍微修改，主要是Service中的IBookManager.Stub的实现，因为我们在IBookManager新加了两个方法，所以在IBookManager.Stub中也要实现这两个方法。同时，在BookManagerService中还开启了一个线程，每隔5s就向书库中增加一本新书并通知所有感兴趣的用户，代码如下:

package com.example.aidl;

import android.app.Service;
import android.content.Intent;
import android.os.Binder;
import android.os.IBinder;
import android.os.RemoteException;
import android.util.Log;

import java.util.List;
import java.util.concurrent.CopyOnWriteArrayList;
import java.util.concurrent.atomic.AtomicBoolean;

public class BookManagerService extends Service {
    private static final String TAG = "BMS";
    private AtomicBoolean mIsServiceDestroyed = new AtomicBoolean(false);
    private CopyOnWriteArrayList<Book> mBookList = new CopyOnWriteArrayList<Book>();
    private CopyOnWriteArrayList<IOnNewBookArrivedListener> mListenerList = new CopyOnWriteArrayList<IOnNewBookArrivedListener>();
    private Binder mBinder = new IBookManager.Stub() {
        @Override
        public List<Book> getBookList() throws RemoteException {
            return mBookList;
        }

        @Override
        public void addBook(Book book) throws RemoteException {
             mBookList.add(book);
        }
        @Override
        public void registerListener(IOnNewBookArrivedListener listener){
            throw RemoteException{
                if(!mListenerList.contains(listener)){
                    mListenerList.add(listener);
                }else {
                    Log.d(TAG,"already exists");
                }
                Log.d(TAG,"registerListener,size:" + mListenerList.size());
            }
        }
        @Override
        public void unregisterListener(IOnNewBookArrivedListener listener)
            throws RemoteException{
            if(mListenerList.contains(listener)){
                mListenerList.remove(listener);
                Log.d(TAG,"unregister listener succeed");
            }else{
                Log.d(TAG,"not found,can not unregister.");
            }
            Log.d(TAG,"unregister,current size:"+mListenerList.size());
        };

    };


    @Override
    public void onCreate() {
        super.onCreate();
        mBookList.add(new Book(1,"Android"));
        mBookList.add(new Book(2,"IOS"));
        new Thread(new ServiceWorker()).start();
    }

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

    @Override
    public void onDestroy() {
        mIsServiceDestroyed.set(true);
        super.onDestroy();
    }
    private void onNewBookArrived(Book book) throws RemoteException{
        mBookList.add(book);
        Log.d(TAG,"onNewBookArrived,notify listeners:"+mListenerList.size());
        for (int i=0;i<mListenerList.size();i++){
            IOnNewBookArrivedListener listener = mListenerList.get(i);
            Log.d(TAG,"onNewBookArrived,notify listener:"+listener);
            listener.onNewBookArrived(book);
        }
    }
    private class ServiceWorker implements Runnable{
        @Override
        public void run() {
            while (!mIsServiceDestroyed.get()){
                try{
                    Thread.sleep(5000);
                }catch (InterruptedException e){
                    e.printStackTrace();
                }
                int bookId = mBookList.size()+1;
                Book newBook = new Book(bookId,"new book#"+bookId);
                try{
                    onNewBookArrived(newBook);
                }catch (RemoteException e){
                    e.printStackTrace();
                }
            }
        }
    }
}

最后，我们还需要修改一下客户端的代码，首先客户端要注册IOnNewBookArrivedListener到远程服务端，这样当有新书时服务端才能通知当前客户端，同时在Activity退出时解除这个注册；另一方面，当有新书时，服务端会回调客户端的IOnNewBookArrivedListener对象中的onNewBookArrived方法，但是这个方法是在客户端的Binder线程池中执行的，为了方便进行UI操作，需要有一个Handler可以将其切换到客户端的主线程中去执行。客户端代码修改如下：

package com.example.aidl;

import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
import androidx.appcompat.app.AppCompatActivity;

import android.content.ComponentName;
import android.content.Context;
import android.content.Intent;
import android.content.ServiceConnection;
import android.os.Bundle;
import android.os.Handler;
import android.os.IBinder;
import android.os.Message;
import android.os.RemoteException;
import android.util.Log;

import java.util.List;

public class BookManagerActivity extends AppCompatActivity {
    public static final String TAG = "BookManagerActivity";
    private static final int MESSAGE_NEW_BOOK_ARRIVED = 1;
    private IBookManager mRemoteBookManager;
    private Handler mHandler = new Handler(){
        @Override
        public void handleMessage(@NonNull Message msg) {
            switch (msg.what){
                case MESSAGE_NEW_BOOK_ARRIVED:
                    Log.d(TAG,"receive new book:"+msg.obj);
                    break;
                    default:
                        super.handleMessage(msg);
            }
        }
    }
    private ServiceConnection mConnection = new ServiceConnection() {
        @Override
        public void onServiceConnected(ComponentName name, IBinder service) {
            IBookManager bookManager = IBookManager.Stub.asInterface(service);
            try {
                mRemoteBookManager = bookManager;
                List<Book> list = bookManager.getBookList();
                Log.i(TAG,"query book list,list type:" + list.getClass().getCanonicalName());
                Log.i(TAG,"query book list:"+list.toString());
                Book newBook = new Book(3,"Android进阶");
                bookManager.addBook(newBook);
                Log.i(TAG,"add book:"+ newBook);
                List<Book> newList = bookManager.getBookList();
                Log.i(TAG,"query book list:"+ newList.toString());
                bookManager.regiterListener(mOnNewBookArrivedListener);
            }catch (RemoteException e){
                e.printStackTrace();
            }
        }

        @Override
        public void onServiceDisconnected(ComponentName name) {
              mRemoteBookManager = null;
              Log.e(TAG,"binder died");
        }
    };
    private IOnNewBookArrivedListener mOnNewBookArrivedListener = new IOnNewBookArrivedListener.Stub(){
        @Override
        public void onNewBookArrived(Book newBook) throws RemoteException{
            mHandler.obtainMessage(MESSAGE_NEW_BOOK_ARRIVED,newBook).sendToTarget();
        }
    };

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_book_manager);
        Intent intent = new Intent(this,BookManagerService.class);
        bindService(intent,mConnection, Context.BIND_AUTO_CREATE);
    }

    @Override
    protected void onDestroy() {
        if (mRemoteBookManager != null && mRemoteBookManager.asBinder().isBinderAlive()){
            try{
                Log.i(TAG,"unregister listener:"+mOnNewBookArrivedListener);
                mRemoteBookManager.unregisterListener(mOnNewBookArrivedListener);
            }catch (RemoteException e){
                e.printStackTrace();
            }
        }
        unbindService(mConnection);
        super.onDestroy();
    }
}

金栗

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
3.Android中的IPC方式---使用AIDL（2）

我们接着再调用一下另外一个接口addBook，我们在客户端给服务器添加一本书，然后再获取一次，看程序是否能够正常工作。还是上次的代码，客户端在服务连接后，在onServiceConnected中做如下改动public void onServiceConnected(ComponentName name, IBinder service) { IBookManager bookManager = IBookManager.Stub.asInterface(service);
复制链接

扫一扫

专栏目录