diff --git a/common/aidl/aidl_api/android.hardware.common/current/android/hardware/common/SynchronizedReadWrite.aidl b/common/aidl/aidl_api/android.hardware.common/current/android/hardware/common/SynchronizedReadWrite.aidl new file mode 100644 index 0000000000..aec3d6dfd3 --- /dev/null +++ b/common/aidl/aidl_api/android.hardware.common/current/android/hardware/common/SynchronizedReadWrite.aidl @@ -0,0 +1,22 @@ +/////////////////////////////////////////////////////////////////////////////// +// THIS FILE IS IMMUTABLE. DO NOT EDIT IN ANY CASE. // +/////////////////////////////////////////////////////////////////////////////// + +// This file is a snapshot of an AIDL interface (or parcelable). Do not try to +// edit this file. It looks like you are doing that because you have modified +// an AIDL interface in a backward-incompatible way, e.g., deleting a function +// from an interface or a field from a parcelable and it broke the build. That +// breakage is intended. +// +// You must not make a backward incompatible changes to the AIDL files built +// with the aidl_interface module type with versions property set. The module +// type is used to build AIDL files in a way that they can be used across +// independently updatable components of the system. If a device is shipped +// with such a backward incompatible change, it has a high risk of breaking +// later when a module using the interface is updated, e.g., Mainline modules. + +package android.hardware.common; +@VintfStability +enum SynchronizedReadWrite { + EMPTY = 0, +} diff --git a/common/aidl/aidl_api/android.hardware.common/current/android/hardware/common/UnsynchronizedWrite.aidl b/common/aidl/aidl_api/android.hardware.common/current/android/hardware/common/UnsynchronizedWrite.aidl new file mode 100644 index 0000000000..e390d20bce --- /dev/null +++ b/common/aidl/aidl_api/android.hardware.common/current/android/hardware/common/UnsynchronizedWrite.aidl @@ -0,0 +1,22 @@ +/////////////////////////////////////////////////////////////////////////////// +// THIS FILE IS IMMUTABLE. DO NOT EDIT IN ANY CASE. // +/////////////////////////////////////////////////////////////////////////////// + +// This file is a snapshot of an AIDL interface (or parcelable). Do not try to +// edit this file. It looks like you are doing that because you have modified +// an AIDL interface in a backward-incompatible way, e.g., deleting a function +// from an interface or a field from a parcelable and it broke the build. That +// breakage is intended. +// +// You must not make a backward incompatible changes to the AIDL files built +// with the aidl_interface module type with versions property set. The module +// type is used to build AIDL files in a way that they can be used across +// independently updatable components of the system. If a device is shipped +// with such a backward incompatible change, it has a high risk of breaking +// later when a module using the interface is updated, e.g., Mainline modules. + +package android.hardware.common; +@VintfStability +enum UnsynchronizedWrite { + EMPTY = 0, +} diff --git a/common/aidl/android/hardware/common/MQDescriptor.aidl b/common/aidl/android/hardware/common/MQDescriptor.aidl index 899768890e..7e89b15f56 100644 --- a/common/aidl/android/hardware/common/MQDescriptor.aidl +++ b/common/aidl/android/hardware/common/MQDescriptor.aidl @@ -22,9 +22,12 @@ import android.hardware.common.GrantorDescriptor; * For use with libfmq. This is created from an instance of AidlMessageQueue, * and is used to pass information required to create another instance of that * queue for fast communication. + * T - is used to specify the type of the payload + * Flavor - is used to specify the type of the queue using + * android.hardware.common.SynchronizedReadWrite or UnsynchronizedWrite */ @VintfStability -parcelable MQDescriptor { +parcelable MQDescriptor { /* * Describes each of the grantors for the message queue. They are used to * get the readptr, writeptr, dataptr, and the optional EventFlag word diff --git a/common/aidl/android/hardware/common/SynchronizedReadWrite.aidl b/common/aidl/android/hardware/common/SynchronizedReadWrite.aidl new file mode 100644 index 0000000000..ef93bf2aba --- /dev/null +++ b/common/aidl/android/hardware/common/SynchronizedReadWrite.aidl @@ -0,0 +1,27 @@ +/* + * Copyright 2020 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package android.hardware.common; + +/* + * For use with android.hardware.common.MQDescriptor to specify which type of + * queue to use. SynchronizedReadWrite is single reader, single writer, with no + * overflow. All messages written need to be read. + */ +@VintfStability +enum SynchronizedReadWrite { + EMPTY, +} diff --git a/common/aidl/android/hardware/common/UnsynchronizedWrite.aidl b/common/aidl/android/hardware/common/UnsynchronizedWrite.aidl new file mode 100644 index 0000000000..aa27c8d029 --- /dev/null +++ b/common/aidl/android/hardware/common/UnsynchronizedWrite.aidl @@ -0,0 +1,27 @@ +/* + * Copyright 2020 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package android.hardware.common; + +/* + * For use with android.hardware.common.MQDescriptor to specify which type of + * queue to use. UnsynchronizedWrite is single writer, multiple reader, with + * overflow. If messages are not read fast enough, they can be overwritten. + */ +@VintfStability +enum UnsynchronizedWrite { + EMPTY, +} diff --git a/tests/msgq/1.0/ITestMsgQ.hal b/tests/msgq/1.0/ITestMsgQ.hal index 112270a9e8..bd10237c90 100644 --- a/tests/msgq/1.0/ITestMsgQ.hal +++ b/tests/msgq/1.0/ITestMsgQ.hal @@ -31,7 +31,7 @@ interface ITestMsgQ { * * @return ret True if the setup is successful. */ - configureFmqSyncReadWrite(fmq_sync mqDesc) generates(bool ret); + configureFmqSyncReadWrite(fmq_sync mqDesc) generates(bool ret); /** * This method requests the service to return an MQDescriptor to @@ -46,7 +46,7 @@ interface ITestMsgQ { * @return mqDesc This structure describes the unsynchronized FMQ that was * set up by the service. Client can use it to set up the FMQ at its end. */ - getFmqUnsyncWrite(bool configureFmq) generates(bool ret, fmq_unsync mqDesc); + getFmqUnsyncWrite(bool configureFmq) generates(bool ret, fmq_unsync mqDesc); /** * This method request the service to write into the synchronized read/write diff --git a/tests/msgq/1.0/default/TestMsgQ.cpp b/tests/msgq/1.0/default/TestMsgQ.cpp index ba665c9204..44737378b3 100644 --- a/tests/msgq/1.0/default/TestMsgQ.cpp +++ b/tests/msgq/1.0/default/TestMsgQ.cpp @@ -25,7 +25,7 @@ namespace implementation { // Methods from ::android::hardware::tests::msgq::V1_0::ITestMsgQ follow. Return TestMsgQ::configureFmqSyncReadWrite( - const android::hardware::MQDescriptorSync& mqDesc) { + const android::hardware::MQDescriptorSync& mqDesc) { mFmqSynchronized.reset(new (std::nothrow) MessageQueueSync(mqDesc)); if ((mFmqSynchronized == nullptr) || (mFmqSynchronized->isValid() == false)) { return false; @@ -56,7 +56,7 @@ Return TestMsgQ::getFmqUnsyncWrite(bool configureFmq, getFmqUnsyncWrite_cb } Return TestMsgQ::requestWriteFmqSync(int32_t count) { - std::vector data(count); + std::vector data(count); for (int i = 0; i < count; i++) { data[i] = i; } @@ -65,14 +65,14 @@ Return TestMsgQ::requestWriteFmqSync(int32_t count) { } Return TestMsgQ::requestReadFmqSync(int32_t count) { - std::vector data(count); + std::vector data(count); bool result = mFmqSynchronized->read(&data[0], count) && verifyData(&data[0], count); return result; } Return TestMsgQ::requestWriteFmqUnsync(int32_t count) { - std::vector data(count); + std::vector data(count); for (int i = 0; i < count; i++) { data[i] = i; } @@ -81,14 +81,14 @@ Return TestMsgQ::requestWriteFmqUnsync(int32_t count) { } Return TestMsgQ::requestReadFmqUnsync(int32_t count) { - std::vector data(count); + std::vector data(count); bool result = mFmqUnsynchronized->read(&data[0], count) && verifyData(&data[0], count); return result; } Return TestMsgQ::requestBlockingRead(int32_t count) { - std::vector data(count); + std::vector data(count); bool result = mFmqSynchronized->readBlocking( &data[0], count, @@ -103,7 +103,7 @@ Return TestMsgQ::requestBlockingRead(int32_t count) { } Return TestMsgQ::requestBlockingReadDefaultEventFlagBits(int32_t count) { - std::vector data(count); + std::vector data(count); bool result = mFmqSynchronized->readBlocking( &data[0], count); @@ -116,7 +116,7 @@ Return TestMsgQ::requestBlockingReadDefaultEventFlagBits(int32_t count) { } Return TestMsgQ::requestBlockingReadRepeat(int32_t count, int32_t numIter) { - std::vector data(count); + std::vector data(count); for (int i = 0; i < numIter; i++) { bool result = mFmqSynchronized->readBlocking( &data[0], diff --git a/tests/msgq/1.0/default/TestMsgQ.h b/tests/msgq/1.0/default/TestMsgQ.h index f9fcddd4bc..8a204b725d 100644 --- a/tests/msgq/1.0/default/TestMsgQ.h +++ b/tests/msgq/1.0/default/TestMsgQ.h @@ -49,13 +49,13 @@ using android::hardware::MQDescriptorUnsync; using android::hardware::MessageQueue; struct TestMsgQ : public ITestMsgQ { - typedef MessageQueue MessageQueueSync; - typedef MessageQueue MessageQueueUnsync; + typedef MessageQueue MessageQueueSync; + typedef MessageQueue MessageQueueUnsync; TestMsgQ() : mFmqSynchronized(nullptr), mFmqUnsynchronized(nullptr) {} // Methods from ::android::hardware::tests::msgq::V1_0::ITestMsgQ follow. - Return configureFmqSyncReadWrite(const MQDescriptorSync& mqDesc) override; + Return configureFmqSyncReadWrite(const MQDescriptorSync& mqDesc) override; Return getFmqUnsyncWrite(bool configureFmq, getFmqUnsyncWrite_cb _hidl_cb) override; Return requestWriteFmqSync(int32_t count) override; Return requestReadFmqSync(int32_t count) override; @@ -73,7 +73,7 @@ private: /* * Utility function to verify data read from the fast message queue. */ - bool verifyData(uint16_t* data, int count) { + bool verifyData(int32_t* data, int count) { for (int i = 0; i < count; i++) { if (data[i] != i) return false; }