File d'attente des messages rapide avec AIDL

Restez organisé à l'aide des collections Enregistrez et classez les contenus selon vos préférences.

À partir d'Android 12, la file d'attente de messages rapide peut être utilisée avec les interfaces AIDL à l'aide du backend du NDK. Cela permet aux processus de sans les frais généraux et les restrictions liés aux transactions de liaison quelques étapes de configuration rapides. L'utilisation de Stable AIDL permet la communication entre le système et processus des fournisseurs.

Types de charges utiles compatibles

• Types AIDL parcelable @FixedSize
• Types enum AIDL
• Types entiers AIDL

Les messages envoyés entre les processus dans la file d'attente de messages de mémoire partagée doivent avoir la même mise en page de mémoire au-delà des limites de processus et ne peuvent pas contenir de pointeurs. Tentative de création d'un AidlMessageQueue avec un type non compatible entraînera une erreur de compilation.

Types de files d'attente compatibles

Les mêmes types de files d'attente de HIDL, souvent appelés "saveurs", sont compatibles avec AIDL. Ils sont utilisés comme arguments de modèle pour les files d'attente et les descripteurs.

Fonctionnement

Définissez l'interface AIDL qui transmettra le MQDescriptor à l'autre processus. MQDescriptor peut être utilisé partout où il peut être morcelé.

Les arguments de modèle requis pour MQDescriptor sont le type de charge utile et la saveur de la file d'attente.

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

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

Le processus de configuration de chaque côté de la file d'attente de messages est presque identique à le processus à l'aide de HIDL, simplement en utilisant les types 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);

Le processus de réception crée l'autre côté de la file d'attente avec le descripteur reçu de l'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()) {
   ...
}

L'utilisation de AidlMessageQueue après la configuration est la même que pour l'MessageQueue HIDL. Toutes les API décrites dans la section Utiliser MessageQueue sont entièrement compatibles avec AidlMessageQueue, à une exception près :

const MQDescriptor<T, flavor>* getDesc() est remplacé par MQDescriptor<T, U> dupeDesc() qui renvoie le MQDescriptor AIDL.