Messenger es un mecanismo ligero para la comunicación entre procesos (IPC) en Android, que utiliza un enfoque basado en mensajes. A diferencia de AIDL, que requiere definir interfaces complejas, Messenger simplifica el intercambio de datos entre aplicaciones mediante el uso de objetos Message y un flujo similar al envío de mensajes entre hilos. En esencia, encapsula AIDL para proporcionar una interfaz más accesible, ideal para escenarios donde no se necesita procesamiento concurrente en el servicio.

Ejemplo de código para implementar Messenger

A continuación, se muestra un ejemplo práctico donde una aplicación cliente envía un mensaje al servicio, y este responde con otro mensaje.

Implementación del servicio

El servicio define un Handler para manejar mensajes entrantes y un Messenger asociado que expone el enlace a través del método onBind.

public class MsgServicio extends Service {
    private static final String LOG_TAG = "MessengerEjemplo";
    private static final int TIPO_MENSAJE_CLIENTE = 0x001;
    private static final int TIPO_MENSAJE_SERVIDOR = 0x002;
    private static final String CLAVE_CLIENTE = "clave_cliente";
    private static final String CLAVE_SERVIDOR = "clave_servidor";

    private final Messenger messengerLocal = new Messenger(new ManejadorMensajes());

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

    private static class ManejadorMensajes extends Handler {
        @Override
        public void handleMessage(Message mensaje) {
            switch (mensaje.what) {
                case TIPO_MENSAJE_CLIENTE:
                    String textoCliente = mensaje.getData().getString(CLAVE_CLIENTE);
                    Log.d(LOG_TAG, "Mensaje recibido del cliente: " + textoCliente);
                    Messenger respuestaCliente = mensaje.replyTo;
                    Message mensajeRespuesta = Message.obtain();
                    mensajeRespuesta.what = TIPO_MENSAJE_SERVIDOR;
                    Bundle datosRespuesta = new Bundle();
                    datosRespuesta.putString(CLAVE_SERVIDOR, "Hola cliente, estoy operativo");
                    mensajeRespuesta.setData(datosRespuesta);
                    try {
                        respuestaCliente.send(mensajeRespuesta);
                    } catch (RemoteException ex) {
                        Log.e(LOG_TAG, "Error al enviar respuesta", ex);
                    }
                    break;
                default:
                    super.handleMessage(mensaje);
            }
        }
    }
}

En el archivo de manifiesto, el servicio debe declararse con la propiedad android:exported="true" para permitir el acceso desde otras aplicaciones.

Implementación del cliente

El cliente se conecta al servicio, crea un Messenger local para recibir respuestas y envía un mensaje inicial al servicio.

public class ClienteMsgActivity extends AppCompatActivity {
    private static final String LOG_TAG = "MessengerEjemplo";
    private static final int TIPO_MENSAJE_CLIENTE = 0x001;
    private static final int TIPO_MENSAJE_SERVIDOR = 0x002;
    private static final String CLAVE_CLIENTE = "clave_cliente";
    private static final String CLAVE_SERVIDOR = "clave_servidor";
    private static final String PAQUETE_SERVIDOR = "com.ejemplo.servidor";
    private static final String RUTA_SERVICIO = "com.ejemplo.servidor.MsgServicio";

    private Messenger messengerRemoto;
    private Messenger messengerLocal = new Messenger(new ManejadorCliente());

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_cliente);
        conectarServicio();
    }

    private void conectarServicio() {
        Intent intencion = new Intent();
        ComponentName componente = new ComponentName(PAQUETE_SERVIDOR, RUTA_SERVICIO);
        intencion.setComponent(componente);
        bindService(intencion, conexionServicio, Context.BIND_AUTO_CREATE);
    }

    private static class ManejadorCliente extends Handler {
        @Override
        public void handleMessage(Message mensaje) {
            switch (mensaje.what) {
                case TIPO_MENSAJE_SERVIDOR:
                    String textoServidor = mensaje.getData().getString(CLAVE_SERVIDOR);
                    Log.d(LOG_TAG, "Respuesta del servidor: " + textoServidor);
                    break;
                default:
                    break;
            }
            super.handleMessage(mensaje);
        }
    }

    private ServiceConnection conexionServicio = new ServiceConnection() {
        @Override
        public void onServiceConnected(ComponentName nombre, IBinder enlace) {
            messengerRemoto = new Messenger(enlace);
            Message mensajeInicial = Message.obtain();
            mensajeInicial.what = TIPO_MENSAJE_CLIENTE;
            Bundle datosIniciales = new Bundle();
            datosIniciales.putString(CLAVE_CLIENTE, "Hola servidor, ¿cómo estás?");
            mensajeInicial.setData(datosIniciales);
            mensajeInicial.replyTo = messengerLocal;
            try {
                messengerRemoto.send(mensajeInicial);
            } catch (RemoteException ex) {
                Log.e(LOG_TAG, "Error al enviar mensaje", ex);
            }
        }

        @Override
        public void onServiceDisconnected(ComponentName nombre) {
            messengerRemoto = null;
        }
    };

    @Override
    protected void onDestroy() {
        super.onDestroy();
        unbindService(conexionServicio);
    }
}

Al ejecutar la aplicación, los logs mostrarán el intercambio de mensajes entre cliente y servidor, demostrando la comunicación bidireccional.

Flujo de interacción de Messenger

El proceso se divide en pasos clave: el cliente se vincula al servicio mediante bindService, el servicio devuelve un IBinder a través de onBind, el cliente crea un Messenger remoto a partir de ese IBinder, envía un mensaje incluyendo su Messenger local en el campo replyTo, el servicio recibe el mensaje y utiliza el Messenger del cliente para enviar una respuesta. Este flujo garantiza que ambos procesos puedan comunicarse de manera asíncrona.

Diferencias entre Messenger y AIDL

Aunque Messenger se basa internamente en AIDL, existen distincioens importantes. Messenger ofrece una API más sencilla y no requiere la definición de archivos AIDL explícitos. En términos de concurrencia, AIDL permite múltiples solicitudes simultáneas al servicio, mientras que Messenger serializa las solicitudes mediante una cola de mensajes, evitando la necesidad de manejo de hilos en el servicio. Para aplicaciones que no requieren procesamiento paralelo, Messenger es preferible por su simplicidad; en cambio, AIDL es adecuado para escenarios complejos con operaciones concurrentes.

Análisis del código fuente de Messenger

Para comprender el funcionamiento interno, se analiza el flujo de creación y comunicación.

Creación del Messenger en el servicio

En el servicio, el objeto Messenger se inicializa con un Handler personalizado. El constructor de Messenger delega en el método getIMessenger del Handler, que devuelve una implementación interna MessengerImpl. Esta clase extiende IMessenger.Stub, un componente generado por AIDL que hereda de Binder, lo que confirma que Messenger es una capa sobre AIDL.

// Fragmento relevante de Messenger.java
public Messenger(Handler objetivo) {
    mTarget = objetivo.getIMessenger();
}

// Fragmento de Handler.java
final IMessenger getIMessenger() {
    synchronized (mQueue) {
        if (mMessengerInterno == null) {
            mMessengerInterno = new MessengerImpl();
        }
        return mMessengerInterno;
    }
}

private final class MessengerImpl extends IMessenger.Stub {
    public void send(Message msg) {
        msg.sendingUid = Binder.getCallingUid();
        Handler.this.sendMessage(msg);
    }
}

El método getBinder del Messenger devuelve el IBinder asociado, que en realidad es el objeto MessengerImpl (un Binder), similar al retorno de un Binder en servicios AIDL.

Creación del Messenger remoto en el cliente

Cuando el cliente se conecta al servicio, recibe un IBinder y crea un Messenger remoto. El constructor utiliza IMessenger.Stub.asInterface para obtener un proxy al servicio, aálogo a los proxies generados en AIDL.

// Constructor del Messenger para cliente
public Messenger(IBinder objetivo) {
    mTarget = IMessenger.Stub.asInterface(objetivo);
}

Envío de mensajes

El envío de mensajes a través del Messenger remoto invoca el método send del proxy, que finalmente llama al send del MessengerImpl en el servicio, transmitiendo el mensaje al Handler correspondiente. Para la comunicación inversa, el cliente incluye su Messenger local en el campo replyTo del mensaje, permitiendo que el servicio lo utilice para enviar respuestas.