Depuis Android 12, Fast Message Queue peut être utilisé avec les interfaces AIDL à l’aide du backend NDK. Cela permet aux processus de communiquer sans la surcharge et les restrictions des transactions de classeur après une courte configuration. L'utilisation de Stable AIDL permet la communication entre les processus du système et du fournisseur.
Types de charges utiles pris en charge
- Types
parcelable
@FixedSize AIDL - Types
enum
AIDL - Types intégraux AIDL
Les messages envoyés entre les processus dans la file d'attente des messages de mémoire partagée doivent avoir la même disposition de mémoire au-delà des limites des processus et ne peuvent pas contenir de pointeurs. Tenter de créer un AidlMessageQueue
avec un type qui n'est pas pris en charge entraînera une erreur de compilation.
Types de files d'attente pris en charge
Les mêmes types de files d'attente de HIDL, souvent appelés versions, sont pris en charge avec AIDL. Ceux-ci sont utilisés comme arguments de modèle pour les files d'attente et les descripteurs.
Types HIDL | Types AIDL |
---|---|
android::hardware::kSynchronizedReadWrite | android.hardware.common.fmq.SynchronizedReadWrite |
android::hardware::kUnsynchronizedWrite | android.hardware.common.fmq.UnsynchronizedWrite |
Comment utiliser
Définissez l'interface AIDL qui transmettra le MQDescriptor
à l'autre processus. MQDescriptor
peut être utilisé partout où un colisable peut se trouver.
Les arguments de modèle requis pour MQDescriptor
sont le type de charge utile et le type de 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 des messages est presque identique au processus utilisant HIDL , en utilisant uniquement 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éera 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 l’installation est la même que celle de HIDL MessageQueue
. Toutes les API décrites dans Utilisation de MessageQueue sont entièrement prises en charge avec AidlMessageQueue
à une exception près :
const MQDescriptor<T, flavor>* getDesc()
est remplacé par MQDescriptor<T, U> dupeDesc()
qui renvoie l'AIDL MQDescriptor
.