AIDL (1)

preface

This article focuses on the functions of AIDL and how to get started with AIDL project quickly

Introduction to the

Quick learning

This article is intended to quickly implement the AIDL project, but more details will be covered in the next article.

• Create an AIDL file on the server side to declare the Java beans and the interface to transport the call. [Declaration document]
• Create the Service on the server side and implement the interface. [Create service]
• The client binds the Service. [Binding service]
• The client invokes the server interface. [Cross-process call]

The service side

To create the server project, start by creating the AIDL folder in app/ SRC /main.

Create a carrierMessageBean

First we create a Java Bean object for transport in this AIDL folder (the package name doesn’t matter) and implement the Parcelable interface (the Parcelable plugin is recommended), since interprocess communication requires converting this object into a sequence of bytes for transport or storage. (Carrier of delivery)

public class MessageBean implements Parcelable {
    private String content;// Request content
    private int level;// Important level`````` Get set method ``````@Override
    public int describeContents() {
        return 0;
    }

    @Override
    public void writeToParcel(Parcel dest, int flags) {
        dest.writeString(this.content);
        dest.writeInt(this.level);
    }

    // If you want to support directional tag out,inout, override this method
    public void readFromParcel(Parcel dest) {
        // Note that the order of values read here should be the same as in the writeToParcel() method
        this.content = dest.readString();
        this.level = dest.readInt();
    }
    protected MessageBean(Parcel in) {
        this.content = in.readString();
        this.level = in.readInt();
    }
    public MessageBean() {

    public static final Creator<MessageBean> CREATOR = new Creator<MessageBean>() {
        @Override
        public MessageBean createFromParcel(Parcel source) {
            return new MessageBean(source);
        }

        @Override
        public MessageBean[] newArray(int size) {
            return newMessageBean[size]; }}; }Copy the code

Create an AIDL fileMessageBean.AIDL

package qdx.aidlserver;// Manually guide packets
parcelable MessageBean;/ / parcelable is lowercaseCopy the code

Create an AIDL fileIDemandManager.AIDL

We created the IDemandManager interface to implement the passing method. In addition, if there is a transport carrier in the method, we must specify the orientation tag(in,out,inout).

• In: The client data object flows to the server, and the modification of the data object by the server does not affect the client.
• Out: The data object flows from the server to the client. (At this time, the data object received by the server is empty. The server can modify the data object and send it to the client.)
• Inout: A combination of these two data streams. (However, this tag is not recommended because it will increase overhead)

package qdx.aidlserver;

import qdx.aidlserver.MessageBean;
import qdx.aidlserver.IDemandListener;

interface IDemandManager {
     MessageBean getDemand();

     void setDemandIn(in MessageBean msg);// Client -> server

     // Both out and inout need to override the readFromParcel method of MessageBean
     void setDemandOut(out MessageBean msg);// Server -> client

     void setDemandInOut(inout MessageBean msg);// Client <-> server
}Copy the code

Pit and perfect

sourceSets {
    main {
        java.srcDirs = ['src/main/java'.'src/main/aidl']}}Copy the code

Create a Service

Finally, we need to create a service that can handle requests from clients or push messages to clients on a regular basis.

public class AIDLService extends Service {

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

    //Stub inherits Binder internally with cross-process transport capabilities
    IDemandManager.Stub demandManager = new IDemandManager.Stub() {
        @Override
        public MessageBean getDemand(a)throws RemoteException {
            MessageBean demand = new MessageBean("First, salute when you see me.".1);
            return demand;
        }

        @Override
        public void setDemandIn(MessageBean msg) throws RemoteException {// The client data flows to the server
            Log.i(TAG, "Programmer :" + msg.toString());
        }

        @Override
        public void setDemandOut(MessageBean msg) throws RemoteException {// The server data flows to the client
            Log.i(TAG, "Programmer :" + msg.toString());// the MSG content must be empty

            msg.setContent("I don't want explanations. Get all your work done before you leave work!");
            msg.setLevel(5);
        }

        @Override
        public void setDemandInOut(MessageBean msg) throws RemoteException {// Data interchange
            Log.i(TAG, "Programmer :" + msg.toString());

            msg.setContent("Change the user interaction color to pink.");
            msg.setLevel(3); }}; }Copy the code

Finally, we register the service Action as the service name in the manifest file, from which the client can implicitly start the service (com.tengxun.aidl). On Meizu’s mobile phone, the system prohibits the permission to start the service implicitly, so be sure to enable the permission to start the project automatically in the mobile phone Manager/Permission Management /.

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

        </service>Copy the code

The client

Copy the AIDL folder

Copy the aiDL folder created on the server to the app/ SRC /main directory on the client and associate the AIDL path with gradle.build.

    sourceSets {
        main {
            java.srcDirs = ['src/main/java'.'src/main/aidl']}}Copy the code

Open the service

        Intent intent = new Intent();
        intent.setAction("com.tengxun.aidl");/ / service action
        intent.setPackage("qdx.aidlserver");// the package name of the aiDL file in the aidl folder
        bindService(intent, connection, Context.BIND_AUTO_CREATE);Copy the code

Associate the object and call the method

After the service binding is successful, we convert the idemandManager.stub object on the server side into the AIDL interface type object required by our client side through asInterface, and this transformation process is process-specific (detailed in the next chapter).

    private IDemandManager demandManager;

    private ServiceConnection connection = new ServiceConnection() {
        @Override
        public void onServiceConnected(ComponentName name, IBinder service) {
            demandManager = IDemandManager.Stub.asInterface(service);// Once we have this object, we can use it for inter-process method calls and transfers.
        }

        @Override
        public void onServiceDisconnected(ComponentName name) {
        }
    };Copy the code

At this point we can communicate across processes through AIDL.

Additional skills (timed push messages)

The above steps have already achieved normal cross-process communication. If we want to push messages to the client project periodically, how do we do this in the cross-process? —————— uses the observer pattern (a collection of multiple callback methods)——————

Server project (push message)

package qdx.aidlserver;

import qdx.aidlserver.MessageBean;

interface IDemandListener {

     void onDemandReceiver(in MessageBean msg);// Client -> server

}Copy the code

     void registerListener(IDemandListener listener);

     void unregisterListener(IDemandListener listener);Copy the code

    IDemandManager.Stub demandManager = new IDemandManager.Stub() {
        ` `` `` `
        setDemandIn/outMethods such as` `` `` `

        @Override
        public void registerListener(IDemandListener listener) throws RemoteException {
        }

        @Override
        public void unregisterListener(IDemandListener listener) throws RemoteException {

        }
    };
Copy the code

        private RemoteCallbackList<IDemandListener> demandList = new RemoteCallbackList<>();

        @Override
        public void registerListener(IDemandListener listener) throws RemoteException {
            demandList.register(listener);//
        }

        @Override
        public void unregisterListener(IDemandListener listener) throws RemoteException {
            demandList.unregister(listener);
        }Copy the code

    private Handler mHandler = new Handler() {
        @Override
        public void handleMessage(Message msg) {
            super.handleMessage(msg);

            if(demandList ! =null) {
                int nums = demandList.beginBroadcast();
                for (int i = 0; i < nums; i++) {
                    MessageBean messageBean = new MessageBean("I threw the", count);
                    count++;
                    try {
                        demandList.getBroadcastItem(i).onDemandReceiver(messageBean);
                    } catch (RemoteException e) {
                        e.printStackTrace();
                    }
                }
                demandList.finishBroadcast();
            }

            mHandler.sendEmptyMessageDelayed(WHAT_MSG, 3000);// Push the message every 3s}};Copy the code

Client project (receiving timing push)

The idemandListener.stub is created (our client project is “Server” in terms of the push process) and added to demandManager.

    IDemandListener.Stub listener = new IDemandListener.Stub() {
        @Override
        public void onDemandReceiver(final MessageBean msg) throws RemoteException {
            // This method runs in a Binder thread pool, non-UI threads}}; demandManager.registerListener(listener);Copy the code

conclusion

The project download

Download.csdn.net/download/qi…