Fila rápida de mensagens com AIDL

A partir do Android 12, a Fila rápida de mensagens pode ser usada com interfaces AIDL usando o back-end do NDK. Isso permite que os processos se comuniquem sem o overhead e as restrições das transações de binder após uma configuração curta. Usar a AIDL estável permite a comunicação entre o sistema e processos do fornecedor.

Tipos de payload com suporte

• Tipos de parcelable da AIDL @FixedSize
• Tipos de AIDL enum
• Tipos integrais AIDL

As mensagens enviadas entre processos na fila de mensagens de memória compartilhada devem ter o mesmo layout de memória entre limites de processo e não pode conter ponteiros. A tentativa de criar um AidlMessageQueue com um tipo não compatível causará um erro de compilação.

Tipos de fila compatíveis

Os mesmos tipos de fila do HIDL, geralmente chamados de variações, são compatíveis com a AIDL. Eles são usados como argumentos de modelo para as filas e os descritores.

Como usar

Defina a interface AIDL que transmitirá o MQDescriptor para o outro processo. O MQDescriptor pode ser usado em qualquer lugar em que parcelable.

Os argumentos de modelo obrigatórios para MQDescriptor são tipo de payload e variação de fila.

import android.hardware.common.fmq.MQDescriptor
import android.hardware.common.fmq.SynchronizedReadWrite

void getQueue(out MQDescriptor<int, SynchronizedReadWrite> mqDesc);

O processo de configuração de cada lado da fila de mensagens é quase idêntico ao o processo usando HIDL, apenas usando os tipos AIDL.

#include <fmq/AidlMessageQueue.h>
...
using ::android::AidlMessageQueue;
using ::aidl::android::hardware::common::fmq::MQDescriptor;
using ::aidl::android::hardware::common::fmq::SynchronizedReadWrite;
...
ndk::ScopedAStatus MyInterface::getQueue(MQDescriptor<int32_t, SynchronizedReadWrite>* mqDesc) {
    *mqDesc = mFmqSynchronized->dupeDesc();
    return ndk::ScopedAStatus::ok();
}
...
// Create the first side of the queue before servicing getQueue() in this example
mFmqSynchronized =
  new AidlMessageQueue<int32_t, SynchronizedReadWrite>(kNumElementsInQueue);

O processo de recebimento criará o outro lado da fila com o descritor recebido da interface AIDL.

MQDescriptor<int32_t, SynchronizedReadWrite> desc;
auto ret = service->getQueue(true, &desc);
if (!ret.isOk()) {
   ...
}
// By default the constructor will reset the read and write pointers of the queue.
// Add a second `false` argument to avoid resetting the pointers.
mQueue = new (std::nothrow) AidlMessageQueue<int32_t, SynchronizedReadWrite>(desc);
if (!mQueue->isValid()) {
   ...
}

O uso do AidlMessageQueue após a configuração é o mesmo que o HIDL MessageQueue. Todas as APIs descritas em Uso da MessageQueue são totalmente compatíveis com AidlMessageQueue, com uma exceção:

O campo const MQDescriptor<T, flavor>* getDesc() foi substituído por MQDescriptor<T, U> dupeDesc() que retorna o MQDescriptor da AIDL.