Detailed explanation of the Android IPC mechanism Messenger instance

Detailed explanation of the Android IPC mechanism Messenger instance

Preface:

Messenger can be translated into a messenger, through which it can pass Message objects between different processes. With it, it can easily realize data transfer between processes.

The method used by Messenger is relatively simple than AIDL. It has a layer of encapsulation for AIDL. We don’t need to implement process communication as we use AIDL. You can see that its source code shows signs of AIDL.

public final class Messenger implements Parcelable {
  private final IMessenger mTarget;

  public Messenger(Handler target) {
    mTarget = ();
  }

  public void send(Message message) throws RemoteException {
    (message);
  }

  public IBinder getBinder() {
    return ();
  }

  public boolean equals(Object otherObj) {
    if (otherObj == null) {
      return false;
    }
    try {
      return ().equals(((Messenger)otherObj)
          .());
    } catch (ClassCastException e) {
    }
    return false;
  }

  public int hashCode() {
    return ().hashCode();
  }

  public int describeContents() {
    return 0;
  }

  public void writeToParcel(Parcel out, int flags) {
    (());
  }

  public static final <Messenger> CREATOR
      = new <Messenger>() {
    public Messenger createFromParcel(Parcel in) {
      IBinder target = ();
      return target != null ? new Messenger(target) : null;
    }

    public Messenger[] newArray(int size) {
      return new Messenger[size];
    }
  };

  public static void writeMessengerOrNullToParcel(Messenger messenger,
      Parcel out) {
    (messenger != null ? ()
        : null);
  }

  public static Messenger readMessengerOrNullFromParcel(Parcel in) {
    IBinder b = ();
    return b != null ? new Messenger(b) : null;
  }

  public Messenger(IBinder target) {
    mTarget = (target);
  }
}

First, we need to create a new service to handle the client's request, and declare a Handler as a parameter to create a Messenger, and then return the Binder through the getBinder() method.

public class MessageService extends Service {

  private Messenger mMessenger = new Messenger(new Handler() {
    @Override
    public void handleMessage(Message msgFromClient) {
      (msgFromClient);
      Message msgToTarget = (msgFromClient);
       = 0;
      try {
        (2000);
        msgToTarget.arg1 = msgFromClient.arg1 + msgFromClient.arg2;
        (msgToTarget);
      } catch (InterruptedException e) {
        ();
      } catch (RemoteException e) {
        ();
      }
    }
  });

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

The logic inside is to simply add the values of arg1 and arg2 in the Message sent by the client and return the result to the replyTo Messenger corresponding to the Message, and return the Message on the server to the client through send.

Then process it on the client side: first, bindService is needed to bind this service, and then generate a Messenger object through IBinder. This Messenger object can encapsulate the data that needs to be processed into a Message and then send to the Service.

 Messenger mMessenger = new Messenger(new Handler() {
    @Override
    public void handleMessage(Message msg) {
      (msg);
      ("Jayuchou", "--- Read data from an asynchronous thread --- " + msg.arg1);
    }
  });

  Messenger mService;

  ServiceConnection connection = new ServiceConnection() {
    @Override
    public void onServiceConnected(ComponentName name, IBinder service) {
      mService = new Messenger(service);
      ("Jayuchou", "-- Connected success --");
    }

    @Override
    public void onServiceDisconnected(ComponentName name) {
      ("Jayuchou", "-- Connected dismiss --");
      mService = null;
    }
  };

Then the call is:

     Message msgFromClient = (null, 0, 1, 2);
         = mMessenger;
        try {
          (msgFromClient);
        } catch (RemoteException e) {
          ();
        }

Encapsulate the data in the Message, and replyTo in the Message specifies the Messenger object in the server to call back the result.

(msgToTarget);

We can see a code in the Service, where replyTo is the Messenger we pass in on the client. At this time, call the send method to pass the data of another process on the server to the process you want to use and use Messenger for receiving. We can use it similar to the usage of Handler. Messenger is a lightweight AIDL that processes requests one at a time.

The above is a detailed explanation of the message processing of Android messenger. There are many articles on this website about Android development. Please search and refer to it. Thank you for reading. I hope it can help you. Thank you for your support for this website!