Merge "Add command line strictness to VTS" into oc-dev
diff --git a/.clang-format b/.clang-format
new file mode 100644
index 0000000..787d47a
--- /dev/null
+++ b/.clang-format
@@ -0,0 +1,28 @@
+#
+# Copyright (C) 2017 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.
+#
+
+#
+# Below are some minor deviations from the default Google style to
+# accommodate for handling of the large legacy code base.
+#
+
+BasedOnStyle: Google
+CommentPragmas: NOLINT:.*
+DerivePointerAlignment: false
+AllowShortFunctionsOnASingleLine: Inline
+TabWidth: 4
+UseTab: Never
+IndentWidth: 4
diff --git a/PREUPLOAD.cfg b/PREUPLOAD.cfg
new file mode 100644
index 0000000..213c93a
--- /dev/null
+++ b/PREUPLOAD.cfg
@@ -0,0 +1,5 @@
+[Options]
+ignore_merged_commits = true
+
+[Builtin Hooks]
+clang_format = true
diff --git a/automotive/Android.bp b/automotive/Android.bp
index 9b24ded..aec8865 100644
--- a/automotive/Android.bp
+++ b/automotive/Android.bp
@@ -2,6 +2,7 @@
subdirs = [
"evs/1.0",
"evs/1.0/default",
+ "evs/1.0/vts/functional",
"vehicle/2.0",
"vehicle/2.1",
]
diff --git a/automotive/evs/1.0/default/EvsEnumerator.cpp b/automotive/evs/1.0/default/EvsEnumerator.cpp
index 731e21b..b25d418 100644
--- a/automotive/evs/1.0/default/EvsEnumerator.cpp
+++ b/automotive/evs/1.0/default/EvsEnumerator.cpp
@@ -99,7 +99,7 @@
}
// Construct a camera instance for the caller
- pActiveCamera = new EvsCamera(cameraId);
+ pActiveCamera = new EvsCamera(cameraId.c_str());
pRecord->activeInstance = pActiveCamera;
if (pActiveCamera == nullptr) {
ALOGE("Failed to allocate new EvsCamera object for %s\n", cameraId.c_str());
diff --git a/automotive/evs/1.0/default/service.cpp b/automotive/evs/1.0/default/service.cpp
index 1b64e44..d4181b9 100644
--- a/automotive/evs/1.0/default/service.cpp
+++ b/automotive/evs/1.0/default/service.cpp
@@ -19,9 +19,9 @@
#include <unistd.h>
#include <hidl/HidlTransportSupport.h>
+#include <log/log.h>
#include <utils/Errors.h>
#include <utils/StrongPointer.h>
-#include <utils/Log.h>
#include "ServiceNames.h"
#include "EvsEnumerator.h"
diff --git a/automotive/evs/1.0/vts/functional/Android.bp b/automotive/evs/1.0/vts/functional/Android.bp
new file mode 100644
index 0000000..22ceff3
--- /dev/null
+++ b/automotive/evs/1.0/vts/functional/Android.bp
@@ -0,0 +1,45 @@
+//
+// Copyright (C) 2016 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.
+//
+
+cc_test {
+ name: "VtsEvsV1_0Target",
+
+ srcs: [
+ "VtsEvsV1_0TargetTest.cpp",
+ "FrameHandler.cpp"
+ ],
+
+ defaults: [
+ "hidl_defaults",
+ ],
+
+ shared_libs: [
+ "android.hardware.automotive.evs@1.0",
+ "liblog",
+ "libutils",
+ "libui",
+ "libhidlbase",
+ "libhidltransport",
+ ],
+
+ static_libs: ["VtsHalHidlTargetTestBase"],
+
+ cflags: [
+ "-O0",
+ "-g",
+ ],
+}
+
diff --git a/automotive/evs/1.0/vts/functional/FrameHandler.cpp b/automotive/evs/1.0/vts/functional/FrameHandler.cpp
new file mode 100644
index 0000000..01d9a0e
--- /dev/null
+++ b/automotive/evs/1.0/vts/functional/FrameHandler.cpp
@@ -0,0 +1,311 @@
+/*
+ * Copyright (C) 2017 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.
+ */
+
+#define LOG_TAG "VtsHalEvsTest"
+
+#include "FrameHandler.h"
+
+#include <stdio.h>
+#include <string.h>
+
+#include <android/log.h>
+#include <cutils/native_handle.h>
+#include <ui/GraphicBufferMapper.h>
+#include <ui/GraphicBuffer.h>
+
+#include <algorithm> // std::min
+
+
+// For the moment, we're assuming that the underlying EVS driver we're working with
+// is providing 4 byte RGBx data. This is fine for loopback testing, although
+// real hardware is expected to provide YUV data -- most likly formatted as YV12
+static const unsigned kBytesPerPixel = 4; // assuming 4 byte RGBx pixels
+
+
+FrameHandler::FrameHandler(android::sp <IEvsCamera> pCamera, CameraDesc cameraInfo,
+ android::sp <IEvsDisplay> pDisplay,
+ BufferControlFlag mode) :
+ mCamera(pCamera),
+ mCameraInfo(cameraInfo),
+ mDisplay(pDisplay),
+ mReturnMode(mode) {
+ // Nothing but member initialization here...
+}
+
+
+void FrameHandler::shutdown()
+{
+ // Make sure we're not still streaming
+ blockingStopStream();
+
+ // At this point, the receiver thread is no longer running, so we can safely drop
+ // our remote object references so they can be freed
+ mCamera = nullptr;
+ mDisplay = nullptr;
+}
+
+
+bool FrameHandler::startStream() {
+ // Mark ourselves as running
+ mLock.lock();
+ mRunning = true;
+ mLock.unlock();
+
+ // Tell the camera to start streaming
+ Return<EvsResult> result = mCamera->startVideoStream(this);
+ return (result == EvsResult::OK);
+}
+
+
+void FrameHandler::asyncStopStream() {
+ // Tell the camera to stop streaming.
+ // This will result in a null frame being delivered when the stream actually stops.
+ mCamera->stopVideoStream();
+}
+
+
+void FrameHandler::blockingStopStream() {
+ // Tell the stream to stop
+ asyncStopStream();
+
+ // Wait until the stream has actually stopped
+ std::unique_lock<std::mutex> lock(mLock);
+ mSignal.wait(lock, [this](){ return !mRunning; });
+}
+
+
+bool FrameHandler::returnHeldBuffer() {
+ std::unique_lock<std::mutex> lock(mLock);
+
+ // Return the oldest buffer we're holding
+ if (mHeldBuffers.empty()) {
+ // No buffers are currently held
+ return false;
+ }
+
+ BufferDesc buffer = mHeldBuffers.front();
+ mHeldBuffers.pop();
+ mCamera->doneWithFrame(buffer);
+
+ return true;
+}
+
+
+bool FrameHandler::isRunning() {
+ std::unique_lock<std::mutex> lock(mLock);
+ return mRunning;
+}
+
+
+void FrameHandler::waitForFrameCount(unsigned frameCount) {
+ // Wait until we've seen at least the requested number of frames (could be more)
+ std::unique_lock<std::mutex> lock(mLock);
+ mSignal.wait(lock, [this, frameCount](){ return mFramesReceived >= frameCount; });
+}
+
+
+void FrameHandler::getFramesCounters(unsigned* received, unsigned* displayed) {
+ std::unique_lock<std::mutex> lock(mLock);
+
+ if (received) {
+ *received = mFramesReceived;
+ }
+ if (displayed) {
+ *displayed = mFramesDisplayed;
+ }
+}
+
+
+Return<void> FrameHandler::deliverFrame(const BufferDesc& bufferArg) {
+ ALOGD("Received a frame from the camera (%p)", bufferArg.memHandle.getNativeHandle());
+
+ // Local flag we use to keep track of when the stream is stopping
+ bool timeToStop = false;
+
+ // TODO: Why do we get a gralloc crash if we don't clone the buffer here?
+ BufferDesc buffer(bufferArg);
+ ALOGD("Clone the received frame as %p", buffer.memHandle.getNativeHandle());
+
+ if (buffer.memHandle.getNativeHandle() == nullptr) {
+ // Signal that the last frame has been received and the stream is stopped
+ timeToStop = true;
+ } else {
+ // If we were given an opened display at construction time, then send the received
+ // image back down the camera.
+ if (mDisplay.get()) {
+ // Get the output buffer we'll use to display the imagery
+ BufferDesc tgtBuffer = {};
+ mDisplay->getTargetBuffer([&tgtBuffer](const BufferDesc& buff) {
+ tgtBuffer = buff;
+ }
+ );
+
+ if (tgtBuffer.memHandle == nullptr) {
+ printf("Didn't get target buffer - frame lost\n");
+ ALOGE("Didn't get requested output buffer -- skipping this frame.");
+ } else {
+ // In order for the handles passed through HIDL and stored in the BufferDesc to
+ // be lockable, we must register them with GraphicBufferMapper
+ registerBufferHelper(tgtBuffer);
+ registerBufferHelper(buffer);
+
+ // Copy the contents of the of buffer.memHandle into tgtBuffer
+ copyBufferContents(tgtBuffer, buffer);
+
+ // Send the target buffer back for display
+ Return <EvsResult> result = mDisplay->returnTargetBufferForDisplay(tgtBuffer);
+ if (!result.isOk()) {
+ printf("HIDL error on display buffer (%s)- frame lost\n",
+ result.description().c_str());
+ ALOGE("Error making the remote function call. HIDL said %s",
+ result.description().c_str());
+ } else if (result != EvsResult::OK) {
+ printf("Display reported error - frame lost\n");
+ ALOGE("We encountered error %d when returning a buffer to the display!",
+ (EvsResult) result);
+ } else {
+ // Everything looks good!
+ // Keep track so tests or watch dogs can monitor progress
+ mLock.lock();
+ mFramesDisplayed++;
+ mLock.unlock();
+ }
+
+ // Now tell GraphicBufferMapper we won't be using these handles anymore
+ unregisterBufferHelper(tgtBuffer);
+ unregisterBufferHelper(buffer);
+ }
+ }
+
+
+ switch (mReturnMode) {
+ case eAutoReturn:
+ // Send the camera buffer back now that we're done with it
+ ALOGD("Calling doneWithFrame");
+ // TODO: Why is it that we get a HIDL crash if we pass back the cloned buffer?
+ mCamera->doneWithFrame(bufferArg);
+ break;
+ case eNoAutoReturn:
+ // Hang onto the buffer handle for now -- we'll return it explicitly later
+ mHeldBuffers.push(bufferArg);
+ }
+
+
+ ALOGD("Frame handling complete");
+ }
+
+
+ // Update our received frame count and notify anybody who cares that things have changed
+ mLock.lock();
+ if (timeToStop) {
+ mRunning = false;
+ } else {
+ mFramesReceived++;
+ }
+ mLock.unlock();
+ mSignal.notify_all();
+
+
+ return Void();
+}
+
+
+bool FrameHandler::copyBufferContents(const BufferDesc& tgtBuffer,
+ const BufferDesc& srcBuffer) {
+ bool success = true;
+
+ // Make sure we don't run off the end of either buffer
+ const unsigned width = std::min(tgtBuffer.width,
+ srcBuffer.width);
+ const unsigned height = std::min(tgtBuffer.height,
+ srcBuffer.height);
+
+ android::GraphicBufferMapper &mapper = android::GraphicBufferMapper::get();
+
+
+ // Lock our source buffer for reading
+ unsigned char* srcPixels = nullptr;
+ mapper.registerBuffer(srcBuffer.memHandle);
+ mapper.lock(srcBuffer.memHandle,
+ GRALLOC_USAGE_SW_READ_OFTEN,
+ android::Rect(width, height),
+ (void **) &srcPixels);
+
+ // Lock our target buffer for writing
+ unsigned char* tgtPixels = nullptr;
+ mapper.registerBuffer(tgtBuffer.memHandle);
+ mapper.lock(tgtBuffer.memHandle,
+ GRALLOC_USAGE_SW_WRITE_OFTEN,
+ android::Rect(width, height),
+ (void **) &tgtPixels);
+
+ if (srcPixels && tgtPixels) {
+ for (unsigned row = 0; row < height; row++) {
+ // Copy the entire row of pixel data
+ memcpy(tgtPixels, srcPixels, width * kBytesPerPixel);
+
+ // Advance to the next row (keeping in mind that stride here is in units of pixels)
+ tgtPixels += tgtBuffer.stride * kBytesPerPixel;
+ srcPixels += srcBuffer.stride * kBytesPerPixel;
+ }
+ } else {
+ ALOGE("Failed to copy buffer contents");
+ success = false;
+ }
+
+ if (srcPixels) {
+ mapper.unlock(srcBuffer.memHandle);
+ }
+ if (tgtPixels) {
+ mapper.unlock(tgtBuffer.memHandle);
+ }
+ mapper.unregisterBuffer(srcBuffer.memHandle);
+ mapper.unregisterBuffer(tgtBuffer.memHandle);
+
+ return success;
+}
+
+
+void FrameHandler::registerBufferHelper(const BufferDesc& buffer)
+{
+ // In order for the handles passed through HIDL and stored in the BufferDesc to
+ // be lockable, we must register them with GraphicBufferMapper.
+ // If the device upon which we're running supports gralloc1, we could just call
+ // registerBuffer directly with the handle. But that call is broken for gralloc0 devices
+ // (which we care about, at least for now). As a result, we have to synthesize a GraphicBuffer
+ // object around the buffer handle in order to make a call to the overloaded alternate
+ // version of the registerBuffer call that does happen to work on gralloc0 devices.
+#if REGISTER_BUFFER_ALWAYS_WORKS
+ android::GraphicBufferMapper::get().registerBuffer(buffer.memHandle);
+#else
+ android::sp<android::GraphicBuffer> pGfxBuff = new android::GraphicBuffer(
+ buffer.width, buffer.height, buffer.format,
+ 1, /* we always use exactly one layer */
+ buffer.usage, buffer.stride,
+ const_cast<native_handle_t*>(buffer.memHandle.getNativeHandle()),
+ false /* GraphicBuffer should not try to free the handle */
+ );
+
+ android::GraphicBufferMapper::get().registerBuffer(pGfxBuff.get());
+#endif
+}
+
+
+void FrameHandler::unregisterBufferHelper(const BufferDesc& buffer)
+{
+ // Now tell GraphicBufferMapper we won't be using these handles anymore
+ android::GraphicBufferMapper::get().unregisterBuffer(buffer.memHandle);
+}
diff --git a/automotive/evs/1.0/vts/functional/FrameHandler.h b/automotive/evs/1.0/vts/functional/FrameHandler.h
new file mode 100644
index 0000000..d5c3f6b
--- /dev/null
+++ b/automotive/evs/1.0/vts/functional/FrameHandler.h
@@ -0,0 +1,93 @@
+/*
+ * Copyright (C) 2017 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.
+ */
+
+#ifndef EVS_VTS_FRAMEHANDLER_H
+#define EVS_VTS_FRAMEHANDLER_H
+
+#include <queue>
+
+#include <android/hardware/automotive/evs/1.0/IEvsCameraStream.h>
+#include <android/hardware/automotive/evs/1.0/IEvsCamera.h>
+#include <android/hardware/automotive/evs/1.0/IEvsDisplay.h>
+
+using namespace ::android::hardware::automotive::evs::V1_0;
+using ::android::hardware::Return;
+using ::android::hardware::Void;
+using ::android::hardware::hidl_vec;
+using ::android::hardware::hidl_handle;
+using ::android::sp;
+
+
+/*
+ * FrameHandler:
+ * This class can be used to receive camera imagery from an IEvsCamera implementation. Given an
+ * IEvsDisplay instance at startup, it will forward the received imagery to the display,
+ * providing a trivial implementation of a rear vew camera type application.
+ * Note that the video frames are delivered on a background thread, while the control interface
+ * is actuated from the applications foreground thread.
+ */
+class FrameHandler : public IEvsCameraStream {
+public:
+ enum BufferControlFlag {
+ eAutoReturn,
+ eNoAutoReturn,
+ };
+
+ FrameHandler(android::sp <IEvsCamera> pCamera, CameraDesc cameraInfo,
+ android::sp <IEvsDisplay> pDisplay = nullptr,
+ BufferControlFlag mode = eAutoReturn);
+ void shutdown();
+
+ bool startStream();
+ void asyncStopStream();
+ void blockingStopStream();
+
+ bool returnHeldBuffer();
+
+ bool isRunning();
+
+ void waitForFrameCount(unsigned frameCount);
+ void getFramesCounters(unsigned* received, unsigned* displayed);
+
+private:
+ // Implementation for ::android::hardware::automotive::evs::V1_0::ICarCameraStream
+ Return<void> deliverFrame(const BufferDesc& buffer) override;
+
+ // Local implementation details
+ bool copyBufferContents(const BufferDesc& tgtBuffer, const BufferDesc& srcBuffer);
+ void registerBufferHelper(const BufferDesc& buffer);
+ void unregisterBufferHelper(const BufferDesc& buffer);
+
+ // Values initialized as startup
+ android::sp <IEvsCamera> mCamera;
+ CameraDesc mCameraInfo;
+ android::sp <IEvsDisplay> mDisplay;
+ BufferControlFlag mReturnMode;
+
+ // Since we get frames delivered to us asnchronously via the ICarCameraStream interface,
+ // we need to protect all member variables that may be modified while we're streaming
+ // (ie: those below)
+ std::mutex mLock;
+ std::condition_variable mSignal;
+
+ std::queue<BufferDesc> mHeldBuffers;
+ bool mRunning = false;
+ unsigned mFramesReceived = 0; // Simple counter -- rolls over eventually!
+ unsigned mFramesDisplayed = 0; // Simple counter -- rolls over eventually!
+};
+
+
+#endif //EVS_VTS_FRAMEHANDLER_H
diff --git a/automotive/evs/1.0/vts/functional/VtsEvsV1_0TargetTest.cpp b/automotive/evs/1.0/vts/functional/VtsEvsV1_0TargetTest.cpp
new file mode 100644
index 0000000..50b6581
--- /dev/null
+++ b/automotive/evs/1.0/vts/functional/VtsEvsV1_0TargetTest.cpp
@@ -0,0 +1,464 @@
+/*
+ * Copyright (C) 2017 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.
+ */
+
+#define LOG_TAG "VtsHalEvsTest"
+
+
+// TODO: How should we configure these values to target appropriate hardware?
+const static char kEnumeratorName[] = "EvsEnumeratorHw-Mock";
+
+
+// These values are called out in the EVS design doc (as of Mar 8, 2017)
+static const int kMaxStreamStartMilliseconds = 500;
+static const int kMinimumFramesPerSecond = 10;
+
+static const int kSecondsToMilliseconds = 1000;
+static const int kMillisecondsToMicroseconds = 1000;
+static const float kNanoToMilliseconds = 0.000001f;
+static const float kNanoToSeconds = 0.000000001f;
+
+
+#include "FrameHandler.h"
+
+#include <stdio.h>
+#include <string.h>
+
+#include <hidl/HidlTransportSupport.h>
+#include <hwbinder/ProcessState.h>
+#include <log/log.h>
+#include <utils/Errors.h>
+#include <utils/StrongPointer.h>
+
+#include <android/log.h>
+#include <android/hardware/automotive/evs/1.0/IEvsCamera.h>
+#include <android/hardware/automotive/evs/1.0/IEvsEnumerator.h>
+#include <android/hardware/automotive/evs/1.0/IEvsCameraStream.h>
+#include <android/hardware/automotive/evs/1.0/IEvsDisplay.h>
+
+#include <VtsHalHidlTargetTestBase.h>
+
+
+using namespace ::android::hardware::automotive::evs::V1_0;
+using ::android::hardware::Return;
+using ::android::hardware::Void;
+using ::android::hardware::hidl_vec;
+using ::android::hardware::hidl_handle;
+using ::android::hardware::hidl_string;
+using ::android::sp;
+
+
+// The main test class for EVS
+class EvsHidlTest : public ::testing::VtsHalHidlTargetTestBase {
+public:
+ virtual void SetUp() override {
+ // Make sure we can connect to the enumerator
+ pEnumerator = IEvsEnumerator::getService(kEnumeratorName);
+ ASSERT_NE(pEnumerator.get(), nullptr);
+ }
+
+ virtual void TearDown() override {}
+
+protected:
+ void loadCameraList() {
+ // SetUp() must run first!
+ assert(pEnumerator != nullptr);
+
+ // Get the camera list
+ pEnumerator->getCameraList([this](hidl_vec <CameraDesc> cameraList) {
+ ALOGI("Camera list callback received %zu cameras",
+ cameraList.size());
+ cameraInfo.reserve(cameraList.size());
+ for (auto&& cam: cameraList) {
+ ALOGI("Found camera %s", cam.cameraId.c_str());
+ cameraInfo.push_back(cam);
+ }
+ }
+ );
+
+ // We insist on at least one camera for EVS to pass any camera tests
+ ASSERT_GE(cameraInfo.size(), 1u);
+ }
+
+ sp<IEvsEnumerator> pEnumerator; // Every test needs access to the service
+ std::vector <CameraDesc> cameraInfo; // Empty unless/until loadCameraList() is called
+};
+
+
+//
+// Tests start here...
+//
+
+/*
+ * CameraOpenClean:
+ * Opens each camera reported by the enumerator and then explicitly closes it via a
+ * call to closeCamera. Then repeats the test to ensure all cameras can be reopened.
+ */
+TEST_F(EvsHidlTest, CameraOpenClean) {
+ // Get the camera list
+ loadCameraList();
+
+ // Open and close each camera twice
+ for (auto&& cam: cameraInfo) {
+ for (int pass = 0; pass < 2; pass++) {
+ sp<IEvsCamera> pCam = pEnumerator->openCamera(cam.cameraId);
+ ASSERT_NE(pCam, nullptr);
+
+ // Verify that this camera self-identifies correctly
+ pCam->getCameraInfo([&cam](CameraDesc desc) {
+ ALOGD("Found camera %s", desc.cameraId.c_str());
+ EXPECT_EQ(cam.cameraId, desc.cameraId);
+ }
+ );
+
+ // Explicitly close the camera so resources are released right away
+ pEnumerator->closeCamera(pCam);
+ }
+ }
+}
+
+
+/*
+ * CameraOpenAggressive:
+ * Opens each camera reported by the enumerator twice in a row without an intervening closeCamera
+ * call. This ensures that the intended "aggressive open" behavior works. This is necessary for
+ * the system to be tolerant of shutdown/restart race conditions.
+ */
+TEST_F(EvsHidlTest, CameraOpenAggressive) {
+ // Get the camera list
+ loadCameraList();
+
+ // Open and close each camera twice
+ for (auto&& cam: cameraInfo) {
+ sp<IEvsCamera> pCam = pEnumerator->openCamera(cam.cameraId);
+ ASSERT_NE(pCam, nullptr);
+
+ // Verify that this camera self-identifies correctly
+ pCam->getCameraInfo([&cam](CameraDesc desc) {
+ ALOGD("Found camera %s", desc.cameraId.c_str());
+ EXPECT_EQ(cam.cameraId, desc.cameraId);
+ }
+ );
+
+ sp<IEvsCamera> pCam2 = pEnumerator->openCamera(cam.cameraId);
+ ASSERT_NE(pCam, pCam2);
+ ASSERT_NE(pCam2, nullptr);
+
+ // Verify that the old camera rejects calls
+ Return<EvsResult> badResult = pCam->setMaxFramesInFlight(2);
+ EXPECT_EQ(EvsResult::OWNERSHIP_LOST, EvsResult(badResult));
+
+ // Close the superceded camera
+ pEnumerator->closeCamera(pCam);
+
+ // Verify that the second camera instance self-identifies correctly
+ pCam2->getCameraInfo([&cam](CameraDesc desc) {
+ ALOGD("Found camera %s", desc.cameraId.c_str());
+ EXPECT_EQ(cam.cameraId, desc.cameraId);
+ }
+ );
+
+ // Leave the second camera dangling so it gets cleaned up by the destructor path
+ }
+
+ // Sleep here to ensure the destructor cleanup has time to run so we don't break follow on tests
+ sleep(1); // I hate that this is an arbitrary time to wait. :( b/36122635
+}
+
+
+/*
+ * DisplayOpen:
+ * Test both clean shut down and "aggressive open" device stealing behavior.
+ */
+TEST_F(EvsHidlTest, DisplayOpen) {
+ // Request exclusive access to the EVS display, then let it go
+ {
+ sp<IEvsDisplay> pDisplay = pEnumerator->openDisplay();
+ ASSERT_NE(pDisplay, nullptr);
+
+ // Ask the display what it's name is
+ pDisplay->getDisplayInfo([](DisplayDesc desc) {
+ ALOGD("Found display %s", desc.displayId.c_str());
+ }
+ );
+
+ pEnumerator->closeDisplay(pDisplay);
+ }
+
+ // Ensure we can reopen the display after it has been closed
+ {
+ // Reopen the display
+ sp<IEvsDisplay> pDisplay = pEnumerator->openDisplay();
+ ASSERT_NE(pDisplay, nullptr);
+
+ // Open the display while its already open -- ownership should be transferred
+ sp<IEvsDisplay> pDisplay2 = pEnumerator->openDisplay();
+ ASSERT_NE(pDisplay2, nullptr);
+
+ // Ensure the old display properly reports its assassination
+ Return<DisplayState> badResult = pDisplay->getDisplayState();
+ EXPECT_EQ(badResult, DisplayState::DEAD);
+
+ // Close only the newest display instance -- the other should already be a zombie
+ pEnumerator->closeDisplay(pDisplay2);
+ }
+
+ // Finally, validate that we can open the display after the provoked failure above
+ sp<IEvsDisplay> pDisplay = pEnumerator->openDisplay();
+ ASSERT_NE(pDisplay, nullptr);
+
+ pEnumerator->closeDisplay(pDisplay);
+}
+
+
+/*
+ * DisplayStates:
+ * Validate that display states transition as expected and can be queried from either the display
+ * object itself or the owning enumerator.
+ */
+TEST_F(EvsHidlTest, DisplayStates) {
+ // Ensure the display starts in the expected state
+ EXPECT_EQ((DisplayState)pEnumerator->getDisplayState(), DisplayState::NOT_OPEN);
+
+ // Scope to limit the lifetime of the pDisplay pointer, and thus the IEvsDisplay object
+ {
+ // Request exclusive access to the EVS display
+ sp<IEvsDisplay> pDisplay = pEnumerator->openDisplay();
+ ASSERT_NE(pDisplay, nullptr);
+ EXPECT_EQ((DisplayState)pEnumerator->getDisplayState(), DisplayState::NOT_VISIBLE);
+
+ // Activate the display
+ pDisplay->setDisplayState(DisplayState::VISIBLE_ON_NEXT_FRAME);
+ EXPECT_EQ((DisplayState)pEnumerator->getDisplayState(), DisplayState::VISIBLE_ON_NEXT_FRAME);
+ EXPECT_EQ((DisplayState)pDisplay->getDisplayState(), DisplayState::VISIBLE_ON_NEXT_FRAME);
+
+ // Get the output buffer we'd use to display the imagery
+ BufferDesc tgtBuffer = {};
+ pDisplay->getTargetBuffer([&tgtBuffer](const BufferDesc& buff) {
+ tgtBuffer = buff;
+ }
+ );
+ EXPECT_NE(tgtBuffer.memHandle, nullptr);
+
+ // Send the target buffer back for display (we didn't actually fill anything)
+ pDisplay->returnTargetBufferForDisplay(tgtBuffer);
+
+ // Sleep for a tenth of a second to ensure the driver has time to get the image displayed
+ usleep(100 * kMillisecondsToMicroseconds);
+ EXPECT_EQ((DisplayState)pEnumerator->getDisplayState(), DisplayState::VISIBLE);
+ EXPECT_EQ((DisplayState)pDisplay->getDisplayState(), DisplayState::VISIBLE);
+
+ // Turn off the display
+ pDisplay->setDisplayState(DisplayState::NOT_VISIBLE);
+ usleep(100 * kMillisecondsToMicroseconds);
+ EXPECT_EQ((DisplayState)pEnumerator->getDisplayState(), DisplayState::NOT_VISIBLE);
+
+ // Close the display
+ pEnumerator->closeDisplay(pDisplay);
+ }
+
+ // TODO: This hack shouldn't be necessary. b/36122635
+// NOTE: Calling flushCommand here did not avoid the race. Going back to sleep... :(
+// android::hardware::IPCThreadState::self()->flushCommands();
+ sleep(1);
+
+ // Now that the display pointer has gone out of scope, causing the IEvsDisplay interface
+ // object to be destroyed, we should be back to the "not open" state.
+ // NOTE: If we want this to pass without the sleep above, we'd have to add the
+ // (now recommended) closeDisplay() call instead of relying on the smarter pointer
+ // going out of scope.
+ EXPECT_EQ((DisplayState)pEnumerator->getDisplayState(), DisplayState::NOT_OPEN);
+}
+
+
+/*
+ * CameraStreamPerformance:
+ * Measure and qualify the stream start up time and streaming frame rate of each reported camera
+ */
+TEST_F(EvsHidlTest, CameraStreamPerformance) {
+ // Get the camera list
+ loadCameraList();
+
+ // Test each reported camera
+ for (auto&& cam: cameraInfo) {
+ sp <IEvsCamera> pCam = pEnumerator->openCamera(cam.cameraId);
+ ASSERT_NE(pCam, nullptr);
+
+ // Set up a frame receiver object which will fire up its own thread
+ sp<FrameHandler> frameHandler = new FrameHandler(pCam, cam,
+ nullptr,
+ FrameHandler::eAutoReturn);
+
+ // Start the camera's video stream
+ nsecs_t start = systemTime(SYSTEM_TIME_MONOTONIC);
+ bool startResult = frameHandler->startStream();
+ EXPECT_EQ(startResult, true);
+
+ // Ensure the first frame arrived within the expected time
+ frameHandler->waitForFrameCount(1);
+ nsecs_t firstFrame = systemTime(SYSTEM_TIME_MONOTONIC);
+ nsecs_t timeToFirstFrame = systemTime(SYSTEM_TIME_MONOTONIC) - start;
+ EXPECT_LE(nanoseconds_to_milliseconds(timeToFirstFrame), kMaxStreamStartMilliseconds);
+ printf("Measured time to first frame %0.2f ms\n", timeToFirstFrame * kNanoToMilliseconds);
+ ALOGI("Measured time to first frame %0.2f ms", timeToFirstFrame * kNanoToMilliseconds);
+
+ // Wait a bit, then ensure we get at least the required minimum number of frames
+ sleep(5);
+ nsecs_t end = systemTime(SYSTEM_TIME_MONOTONIC);
+ unsigned framesReceived = 0;
+ frameHandler->getFramesCounters(&framesReceived, nullptr);
+ framesReceived = framesReceived - 1; // Back out the first frame we already waited for
+ nsecs_t runTime = end - firstFrame;
+ float framesPerSecond = framesReceived / (runTime * kNanoToSeconds);
+ printf("Measured camera rate %3.2f fps\n", framesPerSecond);
+ ALOGI("Measured camera rate %3.2f fps", framesPerSecond);
+ EXPECT_GE(framesPerSecond, kMinimumFramesPerSecond);
+
+ // Even when the camera pointer goes out of scope, the FrameHandler object will
+ // keep the stream alive unless we tell it to shutdown.
+ // Also note that the FrameHandle and the Camera have a mutual circular reference, so
+ // we have to break that cycle in order for either of them to get cleaned up.
+ frameHandler->shutdown();
+
+ // Explicitly release the camera
+ pEnumerator->closeCamera(pCam);
+ }
+}
+
+
+/*
+ * CameraStreamBuffering:
+ * Ensure the camera implementation behaves properly when the client holds onto buffers for more
+ * than one frame time. The camera must cleanly skip frames until the client is ready again.
+ */
+TEST_F(EvsHidlTest, CameraStreamBuffering) {
+ // Arbitrary constant (should be > 1 and less than crazy)
+ static const unsigned int kBuffersToHold = 6;
+
+ // Get the camera list
+ loadCameraList();
+
+ // Test each reported camera
+ for (auto&& cam: cameraInfo) {
+
+ sp<IEvsCamera> pCam = pEnumerator->openCamera(cam.cameraId);
+ ASSERT_NE(pCam, nullptr);
+
+ // Ask for a crazy number of buffers in flight to ensure it errors correctly
+ Return<EvsResult> badResult = pCam->setMaxFramesInFlight(0xFFFFFFFF);
+ EXPECT_EQ(EvsResult::BUFFER_NOT_AVAILABLE, badResult);
+
+ // Now ask for exactly two buffers in flight as we'll test behavior in that case
+ Return<EvsResult> goodResult = pCam->setMaxFramesInFlight(kBuffersToHold);
+ EXPECT_EQ(EvsResult::OK, goodResult);
+
+
+ // Set up a frame receiver object which will fire up its own thread.
+ sp<FrameHandler> frameHandler = new FrameHandler(pCam, cam,
+ nullptr,
+ FrameHandler::eNoAutoReturn);
+
+ // Start the camera's video stream
+ bool startResult = frameHandler->startStream();
+ EXPECT_TRUE(startResult);
+
+ // Check that the video stream stalls once we've gotten exactly the number of buffers
+ // we requested since we told the frameHandler not to return them.
+ sleep(1); // 1 second would be enough for at least 5 frames to be delivered worst case
+ unsigned framesReceived = 0;
+ frameHandler->getFramesCounters(&framesReceived, nullptr);
+ EXPECT_EQ(kBuffersToHold, framesReceived);
+
+
+ // Give back one buffer
+ bool didReturnBuffer = frameHandler->returnHeldBuffer();
+ EXPECT_TRUE(didReturnBuffer);
+
+ // Once we return a buffer, it shouldn't take more than 1/10 second to get a new one
+ // filled since we require 10fps minimum -- but give a 10% allowance just in case.
+ usleep(110 * kMillisecondsToMicroseconds);
+ frameHandler->getFramesCounters(&framesReceived, nullptr);
+ EXPECT_EQ(kBuffersToHold+1, framesReceived);
+
+ // Even when the camera pointer goes out of scope, the FrameHandler object will
+ // keep the stream alive unless we tell it to shutdown.
+ // Also note that the FrameHandle and the Camera have a mutual circular reference, so
+ // we have to break that cycle in order for either of them to get cleaned up.
+ frameHandler->shutdown();
+
+ // Explicitly release the camera
+ pEnumerator->closeCamera(pCam);
+ }
+}
+
+
+/*
+ * CameraToDisplayRoundTrip:
+ * End to end test of data flowing from the camera to the display. Each delivered frame of camera
+ * imagery is simply copied to the display buffer and presented on screen. This is the one test
+ * which a human could observe to see the operation of the system on the physical display.
+ */
+TEST_F(EvsHidlTest, CameraToDisplayRoundTrip) {
+ // Get the camera list
+ loadCameraList();
+
+ // Request exclusive access to the EVS display
+ sp<IEvsDisplay> pDisplay = pEnumerator->openDisplay();
+ ASSERT_NE(pDisplay, nullptr);
+
+ // Test each reported camera
+ for (auto&& cam: cameraInfo) {
+ sp <IEvsCamera> pCam = pEnumerator->openCamera(cam.cameraId);
+ ASSERT_NE(pCam, nullptr);
+
+ // Set up a frame receiver object which will fire up its own thread.
+ sp<FrameHandler> frameHandler = new FrameHandler(pCam, cam,
+ pDisplay,
+ FrameHandler::eAutoReturn);
+
+
+ // Activate the display
+ pDisplay->setDisplayState(DisplayState::VISIBLE_ON_NEXT_FRAME);
+
+ // Start the camera's video stream
+ bool startResult = frameHandler->startStream();
+ EXPECT_EQ(startResult, true);
+
+ // Wait a while to let the data flow
+ static const int kSecondsToWait = 5;
+ const int streamTimeMs = kSecondsToWait * kSecondsToMilliseconds -
+ kMaxStreamStartMilliseconds;
+ const unsigned minimumFramesExpected = streamTimeMs * kMinimumFramesPerSecond /
+ kSecondsToMilliseconds;
+ sleep(kSecondsToWait);
+ unsigned framesReceived = 0;
+ unsigned framesDisplayed = 0;
+ frameHandler->getFramesCounters(&framesReceived, &framesDisplayed);
+ EXPECT_EQ(framesReceived, framesDisplayed);
+ EXPECT_GE(framesDisplayed, minimumFramesExpected);
+
+ // Turn off the display (yes, before the stream stops -- it should be handled)
+ pDisplay->setDisplayState(DisplayState::NOT_VISIBLE);
+
+ // Shut down the streamer
+ frameHandler->shutdown();
+
+ // Explicitly release the camera
+ pEnumerator->closeCamera(pCam);
+ }
+
+ // Explicitly release the display
+ pEnumerator->closeDisplay(pDisplay);
+}
\ No newline at end of file
diff --git a/automotive/vehicle/2.0/default/Android.mk b/automotive/vehicle/2.0/default/Android.mk
index 4a010e9..3c56159 100644
--- a/automotive/vehicle/2.0/default/Android.mk
+++ b/automotive/vehicle/2.0/default/Android.mk
@@ -22,10 +22,10 @@
include $(CLEAR_VARS)
LOCAL_MODULE := $(vhal_v2_0)-manager-lib
LOCAL_SRC_FILES := \
- common/src/AccessControlConfigParser.cpp \
common/src/SubscriptionManager.cpp \
common/src/VehicleHalManager.cpp \
common/src/VehicleObjectPool.cpp \
+ common/src/VehiclePropertyStore.cpp \
common/src/VehicleUtils.cpp \
LOCAL_C_INCLUDES := \
@@ -35,7 +35,6 @@
$(LOCAL_PATH)/common/include
LOCAL_SHARED_LIBRARIES := \
- libbinder \
libhidlbase \
libhidltransport \
libhwbinder \
@@ -74,9 +73,10 @@
LOCAL_MODULE:= $(vhal_v2_0)-default-impl-lib
LOCAL_SRC_FILES:= \
- impl/vhal_v2_0/DefaultVehicleHal.cpp \
+ impl/vhal_v2_0/EmulatedVehicleHal.cpp \
+ impl/vhal_v2_0/VehicleEmulator.cpp \
impl/vhal_v2_0/PipeComm.cpp \
- impl/vhal_v2_0/SocketComm.cpp
+ impl/vhal_v2_0/SocketComm.cpp \
LOCAL_C_INCLUDES := \
$(LOCAL_PATH)/impl/vhal_v2_0
@@ -89,7 +89,6 @@
LOCAL_SHARED_LIBRARIES := \
libbase \
- libbinder \
libhidlbase \
libhidltransport \
libhwbinder \
@@ -117,7 +116,6 @@
$(vhal_v2_0)-manager-lib \
LOCAL_SRC_FILES:= \
- tests/AccessControlConfigParser_test.cpp \
tests/RecurrentTimer_test.cpp \
tests/SubscriptionManager_test.cpp \
tests/VehicleHalManager_test.cpp \
@@ -125,7 +123,6 @@
tests/VehiclePropConfigIndex_test.cpp \
LOCAL_SHARED_LIBRARIES := \
- libbinder \
libhidlbase \
libhidltransport \
libhwbinder \
@@ -153,7 +150,6 @@
LOCAL_SHARED_LIBRARIES := \
libbase \
- libbinder \
libhidlbase \
libhidltransport \
libhwbinder \
diff --git a/automotive/vehicle/2.0/default/VehicleService.cpp b/automotive/vehicle/2.0/default/VehicleService.cpp
index 95057cc..e6d292e 100644
--- a/automotive/vehicle/2.0/default/VehicleService.cpp
+++ b/automotive/vehicle/2.0/default/VehicleService.cpp
@@ -21,14 +21,16 @@
#include <iostream>
#include <vhal_v2_0/VehicleHalManager.h>
-#include <vhal_v2_0/DefaultVehicleHal.h>
+#include <vhal_v2_0/EmulatedVehicleHal.h>
using namespace android;
using namespace android::hardware;
using namespace android::hardware::automotive::vehicle::V2_0;
int main(int /* argc */, char* /* argv */ []) {
- auto hal = std::make_unique<impl::DefaultVehicleHal>();
+ auto store = std::make_unique<VehiclePropertyStore>();
+ auto hal = std::make_unique<impl::EmulatedVehicleHal>(store.get());
+ auto emulator = std::make_unique<impl::VehicleEmulator>(hal.get());
auto service = std::make_unique<VehicleHalManager>(hal.get());
configureRpcThreadpool(1, true /* callerWillJoin */);
diff --git a/automotive/vehicle/2.0/default/common/include/vhal_v2_0/AccessControlConfigParser.h b/automotive/vehicle/2.0/default/common/include/vhal_v2_0/AccessControlConfigParser.h
deleted file mode 100644
index 8ef6f5a..0000000
--- a/automotive/vehicle/2.0/default/common/include/vhal_v2_0/AccessControlConfigParser.h
+++ /dev/null
@@ -1,113 +0,0 @@
-/*
- * Copyright (C) 2016 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.
- */
-
-#ifndef android_hardware_automotive_vehicle_V2_0_AccessControlConfigParser_H_
-#define android_hardware_automotive_vehicle_V2_0_AccessControlConfigParser_H_
-
-#include <string>
-#include <vector>
-#include <unordered_map>
-#include <list>
-
-#include <android/hardware/automotive/vehicle/2.0/types.h>
-
-namespace android {
-namespace hardware {
-namespace automotive {
-namespace vehicle {
-namespace V2_0 {
-
-struct PropertyAcl {
- int32_t propId;
- unsigned uid;
- VehiclePropertyAccess access;
-};
-
-using PropertyAclMap = std::unordered_multimap<int32_t, PropertyAcl>;
-
-/**
- * Parser for per-property access control in vehicle HAL.
- *
- * It supports the following format:
- * Set ALIAS_NAME UID
- * {S,V}:0x0305 {ALIAS_NAME,UID} {R,W,RW}
- *
- * ALIAS_NAME is just an alias for UID
- * S - for system properties (VehiclePropertyGroup::SYSTEM)
- * V - for vendor properties (VehiclePropertyGroup::VENDOR)
- *
- * Example:
- *
- * Set AID_AUDIO 1004
- * Set AID_MY_APP 10022
- *
- * S:0x0305 AID_AUDIO RW
- * S:0x0305 10021 R
- * V:0x0101 AID_MY_APP R
- */
-class AccessControlConfigParser {
-public:
- /**
- * Creates an instance of AccessControlConfigParser
- *
- * @param properties - properties supported by HAL implementation
- */
- AccessControlConfigParser(const std::vector<int32_t>& properties);
-
- /**
- * Parses config content from given stream and writes results to
- * propertyAclMap.
- */
- bool parseFromStream(std::istream* stream, PropertyAclMap* propertyAclMap);
-
-private:
- bool processTokens(std::list<std::string>* tokens,
- PropertyAclMap* propertyAclMap);
-
- bool parsePropertyGroup(char group,
- VehiclePropertyGroup* outPropertyGroup) const;
-
- bool parsePropertyId(const std::string& strPropId,
- VehiclePropertyGroup propertyGroup,
- int32_t* outVehicleProperty) const;
-
- bool parseUid(const std::string& strUid, unsigned* outUid) const;
-
- bool parseAccess(const std::string& strAccess,
- VehiclePropertyAccess* outAccess) const;
-
-
- std::string readNextToken(std::list<std::string>* tokens) const;
-
- static bool parseInt(const char* strValue, int* outIntValue);
- static void split(const std::string& line,
- std::list<std::string>* outTokens);
-
-private:
- std::unordered_map<std::string, unsigned> mUidMap {}; // Contains UID
- // aliases.
-
- // Map property ids w/o TYPE and AREA to VehicleProperty.
- std::unordered_map<int32_t, int32_t> mStrippedToVehiclePropertyMap;
-};
-
-} // namespace V2_0
-} // namespace vehicle
-} // namespace automotive
-} // namespace hardware
-} // namespace android
-
-#endif // android_hardware_automotive_vehicle_V2_0_AccessControlConfigParser_H_
diff --git a/automotive/vehicle/2.0/default/common/include/vhal_v2_0/SubscriptionManager.h b/automotive/vehicle/2.0/default/common/include/vhal_v2_0/SubscriptionManager.h
index a808c66..fd59802 100644
--- a/automotive/vehicle/2.0/default/common/include/vhal_v2_0/SubscriptionManager.h
+++ b/automotive/vehicle/2.0/default/common/include/vhal_v2_0/SubscriptionManager.h
@@ -24,7 +24,7 @@
#include <android/log.h>
#include <hidl/HidlSupport.h>
-#include <hwbinder/IPCThreadState.h>
+#include <utils/SortedVector.h>
#include <android/hardware/automotive/vehicle/2.0/IVehicle.h>
@@ -39,10 +39,8 @@
class HalClient : public android::RefBase {
public:
- HalClient(const sp<IVehicleCallback> &callback,
- int32_t pid,
- int32_t uid)
- : mCallback(callback), mPid(pid), mUid(uid) {}
+ HalClient(const sp<IVehicleCallback> &callback)
+ : mCallback(callback) {}
virtual ~HalClient() {}
public:
@@ -56,8 +54,6 @@
private:
const sp<IVehicleCallback> mCallback;
- const int32_t mPid;
- const int32_t mUid;
std::map<int32_t, SubscribeOptions> mSubscriptions;
};
diff --git a/automotive/vehicle/2.0/default/common/include/vhal_v2_0/VehicleHalManager.h b/automotive/vehicle/2.0/default/common/include/vhal_v2_0/VehicleHalManager.h
index b8ab309..1d45f4b 100644
--- a/automotive/vehicle/2.0/default/common/include/vhal_v2_0/VehicleHalManager.h
+++ b/automotive/vehicle/2.0/default/common/include/vhal_v2_0/VehicleHalManager.h
@@ -27,9 +27,7 @@
#include <set>
#include <android/hardware/automotive/vehicle/2.0/IVehicle.h>
-#include <hwbinder/IPCThreadState.h>
-#include "AccessControlConfigParser.h"
#include "ConcurrentQueue.h"
#include "SubscriptionManager.h"
#include "VehicleHal.h"
@@ -42,11 +40,6 @@
namespace vehicle {
namespace V2_0 {
-struct Caller {
- pid_t pid;
- uid_t uid;
-};
-
/**
* This class is a thick proxy between IVehicle HIDL interface and vendor's implementation.
*
@@ -99,14 +92,8 @@
const VehiclePropConfig* getPropConfigOrNull(int32_t prop) const;
- bool checkWritePermission(const VehiclePropConfig &config,
- const Caller& callee) const;
- bool checkReadPermission(const VehiclePropConfig &config,
- const Caller& caller) const;
- bool checkAcl(uid_t callerUid,
- int32_t propertyId,
- VehiclePropertyAccess requiredAccess) const;
-
+ bool checkWritePermission(const VehiclePropConfig &config) const;
+ bool checkReadPermission(const VehiclePropConfig &config) const;
void onAllClientsUnsubscribed(int32_t propertyId);
static bool isSubscribable(const VehiclePropConfig& config,
@@ -114,12 +101,6 @@
static bool isSampleRateFixed(VehiclePropertyChangeMode mode);
static float checkSampleRate(const VehiclePropConfig& config,
float sampleRate);
- static void readAndParseAclConfig(const char* filename,
- AccessControlConfigParser* parser,
- PropertyAclMap* outAclMap);
-
- static Caller getCaller();
-
private:
VehicleHal* mHal;
std::unique_ptr<VehiclePropConfigIndex> mConfigIndex;
@@ -130,7 +111,6 @@
ConcurrentQueue<VehiclePropValuePtr> mEventQueue;
BatchingConsumer<VehiclePropValuePtr> mBatchingConsumer;
VehiclePropValuePool mValueObjectPool;
- PropertyAclMap mPropertyAclMap;
};
} // namespace V2_0
diff --git a/automotive/vehicle/2.0/default/common/include/vhal_v2_0/VehiclePropertyStore.h b/automotive/vehicle/2.0/default/common/include/vhal_v2_0/VehiclePropertyStore.h
new file mode 100644
index 0000000..eda94b7
--- /dev/null
+++ b/automotive/vehicle/2.0/default/common/include/vhal_v2_0/VehiclePropertyStore.h
@@ -0,0 +1,104 @@
+/*
+ * Copyright (C) 2017 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.
+ */
+
+#ifndef android_hardware_automotive_vehicle_V2_0_impl_PropertyDb_H_
+#define android_hardware_automotive_vehicle_V2_0_impl_PropertyDb_H_
+
+#include <cstdint>
+#include <unordered_map>
+#include <memory>
+#include <mutex>
+
+#include <android/hardware/automotive/vehicle/2.0/IVehicle.h>
+
+namespace android {
+namespace hardware {
+namespace automotive {
+namespace vehicle {
+namespace V2_0 {
+
+/**
+ * Encapsulates work related to storing and accessing configuration, storing and modifying
+ * vehicle property values.
+ *
+ * VehiclePropertyValues stored in a sorted map thus it makes easier to get range of values, e.g.
+ * to get value for all areas for particular property.
+ *
+ * This class is thread-safe, however it uses blocking synchronization across all methods.
+ */
+class VehiclePropertyStore {
+public:
+ /* Function that used to calculate unique token for given VehiclePropValue */
+ using TokenFunction = std::function<int64_t(const VehiclePropValue& value)>;
+
+private:
+ struct RecordConfig {
+ VehiclePropConfig propConfig;
+ TokenFunction tokenFunction;
+ };
+
+ struct RecordId {
+ int32_t prop;
+ int32_t area;
+ int64_t token;
+
+ bool operator==(const RecordId& other) const;
+ bool operator<(const RecordId& other) const;
+ };
+
+ using PropertyMap = std::map<RecordId, VehiclePropValue>;
+ using PropertyMapRange = std::pair<PropertyMap::const_iterator, PropertyMap::const_iterator>;
+
+public:
+ void registerProperty(const VehiclePropConfig& config, TokenFunction tokenFunc = nullptr);
+
+ /* Stores provided value. Returns true if value was written returns false if config for
+ * example wasn't registered. */
+ bool writeValue(const VehiclePropValue& propValue);
+
+ void removeValue(const VehiclePropValue& propValue);
+ void removeValuesForProperty(int32_t propId);
+
+ std::vector<VehiclePropValue> readAllValues() const;
+ std::vector<VehiclePropValue> readValuesForProperty(int32_t propId) const;
+ std::unique_ptr<VehiclePropValue> readValueOrNull(const VehiclePropValue& request) const;
+ std::unique_ptr<VehiclePropValue> readValueOrNull(int32_t prop, int32_t area = 0,
+ int64_t token = 0) const;
+
+ std::vector<VehiclePropConfig> getAllConfigs() const;
+ const VehiclePropConfig* getConfigOrNull(int32_t propId) const;
+ const VehiclePropConfig* getConfigOrDie(int32_t propId) const;
+
+private:
+ RecordId getRecordIdLocked(const VehiclePropValue& valuePrototype) const;
+ const VehiclePropValue* getValueOrNullLocked(const RecordId& recId) const;
+ PropertyMapRange findRangeLocked(int32_t propId) const;
+
+private:
+ using MuxGuard = std::lock_guard<std::mutex>;
+ mutable std::mutex mLock;
+ std::unordered_map<int32_t /* VehicleProperty */, RecordConfig> mConfigs;
+
+ PropertyMap mPropertyValues; // Sorted map of RecordId : VehiclePropValue.
+};
+
+} // namespace V2_0
+} // namespace vehicle
+} // namespace automotive
+} // namespace hardware
+} // namespace android
+
+#endif //android_hardware_automotive_vehicle_V2_0_impl_PropertyDb_H_
diff --git a/automotive/vehicle/2.0/default/common/src/AccessControlConfigParser.cpp b/automotive/vehicle/2.0/default/common/src/AccessControlConfigParser.cpp
deleted file mode 100644
index 6a3f8e5..0000000
--- a/automotive/vehicle/2.0/default/common/src/AccessControlConfigParser.cpp
+++ /dev/null
@@ -1,228 +0,0 @@
-/*
- * Copyright (C) 2016 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.
- */
-
-#define LOG_TAG "automotive.vehicle@2.0-impl"
-
-#include "AccessControlConfigParser.h"
-#include "VehicleUtils.h"
-
-#include <fstream>
-#include <iostream>
-#include <sstream>
-
-#include <log/log.h>
-
-namespace android {
-namespace hardware {
-namespace automotive {
-namespace vehicle {
-namespace V2_0 {
-
-AccessControlConfigParser::AccessControlConfigParser(
- const std::vector<int32_t>& properties) {
- // Property Id in the config file doesn't include information about
- // type and area. So we want to create a map from these kind of
- // *stripped* properties to the whole VehicleProperty.
- // We also want to filter out ACL to the properties that supported
- // by concrete Vehicle HAL implementation.
- for (auto prop : properties) {
- auto strippedProp = prop
- & ~toInt(VehiclePropertyType::MASK)
- & ~toInt(VehicleArea::MASK);
- mStrippedToVehiclePropertyMap.emplace(strippedProp, prop);
- }
-}
-
-bool AccessControlConfigParser::parseFromStream(
- std::istream* stream, PropertyAclMap* propertyAclMap) {
- std::list<std::string> tokens;
- std::string line;
- int lineNo = 0;
- bool warnings = false;
- for (;std::getline(*stream, line); lineNo++) {
- split(line, &tokens);
- if (!processTokens(&tokens, propertyAclMap)) {
- warnings = true;
- ALOGW("Failed to parse line %d : %s", lineNo, line.c_str());
- }
- }
- return !warnings;
-}
-
-
-bool AccessControlConfigParser::processTokens(std::list<std::string>* tokens,
- PropertyAclMap* propertyAclMap) {
- std::string token = readNextToken(tokens);
- if (token.empty() || token[0] == '#') { // Ignore comment.
- return true;
- }
-
- if (token == "Set") {
- std::string alias = readNextToken(tokens);
- std::string strUid = readNextToken(tokens);
- if (alias.empty() || strUid.empty()) {
- ALOGW("Expected alias and UID must be specified");
- return false;
- }
- int uid;
- if (!parseInt(strUid.c_str(), &uid)) {
- ALOGW("Invalid UID: %d", uid);
- }
- mUidMap.emplace(std::move(alias), uid);
- } else if (token.size() > 2 && token[1] == ':') {
- VehiclePropertyGroup propGroup;
- if (!parsePropertyGroup(token[0], &propGroup)) {
- return false;
- }
- std::string strUid = readNextToken(tokens);
- std::string strAccess = readNextToken(tokens);
- if (strUid.empty() || strAccess.empty()) {
- ALOGW("Expected UID and access for property: %s",
- token.c_str());
- }
-
-
- PropertyAcl acl;
- if (parsePropertyId(token.substr(2), propGroup, &acl.propId)
- && parseUid(strUid, &acl.uid)
- && parseAccess(strAccess, &acl.access)) {
- propertyAclMap->emplace(acl.propId, std::move(acl));
- } else {
- return false;
- }
- } else {
- ALOGW("Unexpected token: %s", token.c_str());
- return false;
- }
-
- return true;
-}
-
-bool AccessControlConfigParser::parsePropertyGroup(
- char group, VehiclePropertyGroup* outPropertyGroup) const {
- switch (group) {
- case 'S': // Fall through.
- case 's':
- *outPropertyGroup = VehiclePropertyGroup::SYSTEM;
- break;
- case 'V': // Fall through.
- case 'v':
- *outPropertyGroup = VehiclePropertyGroup::VENDOR;
- break;
- default:
- ALOGW("Unexpected group: %c", group);
- return false;
- }
- return true;
-}
-
-bool AccessControlConfigParser::parsePropertyId(
- const std::string& strPropId,
- VehiclePropertyGroup propertyGroup,
- int32_t* outVehicleProperty) const {
- int32_t propId;
- if (!parseInt(strPropId.c_str(), &propId)) {
- ALOGW("Failed to convert property id to integer: %s",
- strPropId.c_str());
- return false;
- }
- propId |= static_cast<int>(propertyGroup);
- auto it = mStrippedToVehiclePropertyMap.find(propId);
- if (it == mStrippedToVehiclePropertyMap.end()) {
- ALOGW("Property Id not found or not supported: 0x%x", propId);
- return false;
- }
- *outVehicleProperty = it->second;
- return true;
-}
-
-bool AccessControlConfigParser::parseInt(const char* strValue,
- int* outIntValue) {
- char* end;
- long num = std::strtol(strValue, &end, 0 /* auto detect base */);
- bool success = *end == 0 && errno != ERANGE;
- if (success) {
- *outIntValue = static_cast<int>(num);
- }
-
- return success;
-}
-
-bool AccessControlConfigParser::parseUid(const std::string& strUid,
- unsigned* outUid) const {
- auto element = mUidMap.find(strUid);
- if (element != mUidMap.end()) {
- *outUid = element->second;
- } else {
- int val;
- if (!parseInt(strUid.c_str(), &val)) {
- ALOGW("Failed to convert UID '%s' to integer", strUid.c_str());
- return false;
- }
- *outUid = static_cast<unsigned>(val);
- }
- return true;
-}
-
-bool AccessControlConfigParser::parseAccess(
- const std::string& strAccess, VehiclePropertyAccess* outAccess) const {
- if (strAccess.size() == 0 || strAccess.size() > 2) {
- ALOGW("Unknown access mode '%s'", strAccess.c_str());
- return false;
- }
- int32_t access = static_cast<int32_t>(VehiclePropertyAccess::NONE);
- for (char c : strAccess) {
- if (c == 'R' || c == 'r') {
- access |= VehiclePropertyAccess::READ;
- } else if (c == 'W' || c == 'w') {
- access |= VehiclePropertyAccess::WRITE;
- } else {
- ALOGW("Unknown access mode: %c", c);
- return false;
- }
- }
- *outAccess = static_cast<VehiclePropertyAccess>(access);
- return true;
-}
-
-void AccessControlConfigParser::split(const std::string& line,
- std::list<std::string>* outTokens) {
- outTokens->clear();
- std::istringstream iss(line);
-
- while (!iss.eof()) {
- std::string token;
- iss >> token;
- outTokens->push_back(std::move(token));
- }
-}
-
-std::string AccessControlConfigParser::readNextToken(
- std::list<std::string>* tokens) const {
- if (tokens->empty()) {
- return "";
- }
-
- std::string token = tokens->front();
- tokens->pop_front();
- return token;
-}
-
-} // namespace V2_0
-} // namespace vehicle
-} // namespace automotive
-} // namespace hardware
-} // namespace android
diff --git a/automotive/vehicle/2.0/default/common/src/SubscriptionManager.cpp b/automotive/vehicle/2.0/default/common/src/SubscriptionManager.cpp
index 4493a41..e0f3f31 100644
--- a/automotive/vehicle/2.0/default/common/src/SubscriptionManager.cpp
+++ b/automotive/vehicle/2.0/default/common/src/SubscriptionManager.cpp
@@ -232,10 +232,8 @@
__func__, callback.get(), res.description().c_str());
return nullptr;
}
- IPCThreadState* self = IPCThreadState::self();
- pid_t pid = self->getCallingPid();
- uid_t uid = self->getCallingUid();
- sp<HalClient> client = new HalClient(callback, pid, uid);
+
+ sp<HalClient> client = new HalClient(callback);
mClients.emplace(callback, client);
return client;
} else {
diff --git a/automotive/vehicle/2.0/default/common/src/VehicleHalManager.cpp b/automotive/vehicle/2.0/default/common/src/VehicleHalManager.cpp
index 8906f6e..f452be8 100644
--- a/automotive/vehicle/2.0/default/common/src/VehicleHalManager.cpp
+++ b/automotive/vehicle/2.0/default/common/src/VehicleHalManager.cpp
@@ -18,10 +18,10 @@
#include "VehicleHalManager.h"
+#include <cmath>
#include <fstream>
#include <android/log.h>
-#include <private/android_filesystem_config.h>
#include "VehicleUtils.h"
@@ -84,7 +84,7 @@
return Void();
}
- if (!checkReadPermission(*config, getCaller())) {
+ if (!checkReadPermission(*config)) {
_hidl_cb(StatusCode::ACCESS_DENIED, kEmptyValue);
return Void();
}
@@ -105,7 +105,7 @@
return StatusCode::INVALID_ARG;
}
- if (!checkWritePermission(*config, getCaller())) {
+ if (!checkWritePermission(*config)) {
return StatusCode::ACCESS_DENIED;
}
@@ -119,7 +119,6 @@
Return<StatusCode> VehicleHalManager::subscribe(const sp<IVehicleCallback> &callback,
const hidl_vec<SubscribeOptions> &options) {
hidl_vec<SubscribeOptions> verifiedOptions(options);
- auto caller = getCaller();
for (size_t i = 0; i < verifiedOptions.size(); i++) {
SubscribeOptions& ops = verifiedOptions[i];
auto prop = ops.propId;
@@ -136,10 +135,6 @@
return StatusCode::INVALID_ARG;
}
- if (!checkAcl(caller.uid, config->prop, VehiclePropertyAccess::READ)) {
- return StatusCode::ACCESS_DENIED;
- }
-
if (!isSubscribable(*config, ops.flags)) {
ALOGE("Failed to subscribe: property 0x%x is not subscribable",
prop);
@@ -209,13 +204,6 @@
for (const auto& config : supportedPropConfigs) {
supportedProperties.push_back(config.prop);
}
-
- AccessControlConfigParser aclParser(supportedProperties);
- const char* configs[] = { "/system/etc/vehicle_access.conf",
- "/vendor/etc/vehicle_access.conf" };
- for (const char* filename : configs) {
- readAndParseAclConfig(filename, &aclParser, &mPropertyAclMap);
- }
}
VehicleHalManager::~VehicleHalManager() {
@@ -317,39 +305,22 @@
return true;
}
-bool VehicleHalManager::checkAcl(uid_t callerUid, int32_t propertyId,
- VehiclePropertyAccess requiredAccess) const {
- if (callerUid == AID_SYSTEM && isSystemProperty(propertyId)) {
- return true;
- }
-
- auto range = mPropertyAclMap.equal_range(propertyId);
- for (auto it = range.first; it != range.second; ++it) {
- auto& acl = it->second;
- if (acl.uid == callerUid && (acl.access & requiredAccess)) {
- return true;
- }
- }
- return false;
-}
-
-bool VehicleHalManager::checkWritePermission(const VehiclePropConfig &config,
- const Caller& caller) const {
+bool VehicleHalManager::checkWritePermission(const VehiclePropConfig &config) const {
if (!(config.access & VehiclePropertyAccess::WRITE)) {
ALOGW("Property 0%x has no write access", config.prop);
return false;
+ } else {
+ return true;
}
- return checkAcl(caller.uid, config.prop, VehiclePropertyAccess::WRITE);
}
-bool VehicleHalManager::checkReadPermission(const VehiclePropConfig &config,
- const Caller& caller) const {
+bool VehicleHalManager::checkReadPermission(const VehiclePropConfig &config) const {
if (!(config.access & VehiclePropertyAccess::READ)) {
ALOGW("Property 0%x has no read access", config.prop);
return false;
+ } else {
+ return true;
}
-
- return checkAcl(caller.uid, config.prop, VehiclePropertyAccess::READ);
}
void VehicleHalManager::handlePropertySetEvent(const VehiclePropValue& value) {
@@ -366,26 +337,6 @@
? &mConfigIndex->getConfig(prop) : nullptr;
}
-Caller VehicleHalManager::getCaller() {
- Caller caller;
- IPCThreadState* self = IPCThreadState::self();
- caller.pid = self->getCallingPid();
- caller.uid = self->getCallingUid();
-
- return caller;
-}
-
-void VehicleHalManager::readAndParseAclConfig(const char* filename,
- AccessControlConfigParser* parser,
- PropertyAclMap* outAclMap) {
- std::ifstream file(filename);
- if (file.is_open()) {
- ALOGI("Parsing file: %s", filename);
- parser->parseFromStream(&file, outAclMap);
- file.close();
- }
-}
-
void VehicleHalManager::onAllClientsUnsubscribed(int32_t propertyId) {
mHal->unsubscribe(propertyId);
}
diff --git a/automotive/vehicle/2.0/default/common/src/VehiclePropertyStore.cpp b/automotive/vehicle/2.0/default/common/src/VehiclePropertyStore.cpp
new file mode 100644
index 0000000..2c3ebfc
--- /dev/null
+++ b/automotive/vehicle/2.0/default/common/src/VehiclePropertyStore.cpp
@@ -0,0 +1,172 @@
+/*
+ * Copyright (C) 2017 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.
+ */
+#define LOG_TAG "VehiclePropertyStore"
+#include <log/log.h>
+
+#include <common/include/vhal_v2_0/VehicleUtils.h>
+#include "VehiclePropertyStore.h"
+
+namespace android {
+namespace hardware {
+namespace automotive {
+namespace vehicle {
+namespace V2_0 {
+
+bool VehiclePropertyStore::RecordId::operator==(const VehiclePropertyStore::RecordId& other) const {
+ return prop == other.prop && area == other.area && token == other.token;
+}
+
+bool VehiclePropertyStore::RecordId::operator<(const VehiclePropertyStore::RecordId& other) const {
+ return prop < other.prop
+ || (prop == other.prop && area < other.area)
+ || (prop == other.prop && area == other.area && token < other.token);
+}
+
+void VehiclePropertyStore::registerProperty(const VehiclePropConfig& config,
+ VehiclePropertyStore::TokenFunction tokenFunc) {
+ MuxGuard g(mLock);
+ mConfigs.insert({ config.prop, RecordConfig { config, tokenFunc } });
+}
+
+bool VehiclePropertyStore::writeValue(const VehiclePropValue& propValue) {
+ MuxGuard g(mLock);
+ if (!mConfigs.count(propValue.prop)) return false;
+
+ RecordId recId = getRecordIdLocked(propValue);
+ VehiclePropValue* valueToUpdate = const_cast<VehiclePropValue*>(getValueOrNullLocked(recId));
+ if (valueToUpdate == nullptr) {
+ mPropertyValues.insert({ recId, propValue });
+ } else {
+ valueToUpdate->timestamp = propValue.timestamp;
+ valueToUpdate->value = propValue.value;
+ }
+ return true;
+}
+
+void VehiclePropertyStore::removeValue(const VehiclePropValue& propValue) {
+ MuxGuard g(mLock);
+ RecordId recId = getRecordIdLocked(propValue);
+ auto it = mPropertyValues.find(recId);
+ if (it != mPropertyValues.end()) {
+ mPropertyValues.erase(it);
+ }
+}
+
+void VehiclePropertyStore::removeValuesForProperty(int32_t propId) {
+ MuxGuard g(mLock);
+ auto range = findRangeLocked(propId);
+ mPropertyValues.erase(range.first, range.second);
+}
+
+std::vector<VehiclePropValue> VehiclePropertyStore::readAllValues() const {
+ MuxGuard g(mLock);
+ std::vector<VehiclePropValue> allValues;
+ allValues.reserve(mPropertyValues.size());
+ for (auto&& it : mPropertyValues) {
+ allValues.push_back(it.second);
+ }
+ return allValues;
+}
+
+std::vector<VehiclePropValue> VehiclePropertyStore::readValuesForProperty(int32_t propId) const {
+ std::vector<VehiclePropValue> values;
+ MuxGuard g(mLock);
+ auto range = findRangeLocked(propId);
+ for (auto it = range.first; it != range.second; ++it) {
+ values.push_back(it->second);
+ }
+
+ return values;
+}
+
+std::unique_ptr<VehiclePropValue> VehiclePropertyStore::readValueOrNull(
+ const VehiclePropValue& request) const {
+ MuxGuard g(mLock);
+ RecordId recId = getRecordIdLocked(request);
+ const VehiclePropValue* internalValue = getValueOrNullLocked(recId);
+ return internalValue ? std::make_unique<VehiclePropValue>(*internalValue) : nullptr;
+}
+
+std::unique_ptr<VehiclePropValue> VehiclePropertyStore::readValueOrNull(
+ int32_t prop, int32_t area, int64_t token) const {
+ RecordId recId = {prop, isGlobalProp(prop) ? 0 : area, token };
+ MuxGuard g(mLock);
+ const VehiclePropValue* internalValue = getValueOrNullLocked(recId);
+ return internalValue ? std::make_unique<VehiclePropValue>(*internalValue) : nullptr;
+}
+
+
+std::vector<VehiclePropConfig> VehiclePropertyStore::getAllConfigs() const {
+ MuxGuard g(mLock);
+ std::vector<VehiclePropConfig> configs;
+ configs.reserve(mConfigs.size());
+ for (auto&& recordConfigIt: mConfigs) {
+ configs.push_back(recordConfigIt.second.propConfig);
+ }
+ return configs;
+}
+
+const VehiclePropConfig* VehiclePropertyStore::getConfigOrNull(int32_t propId) const {
+ MuxGuard g(mLock);
+ auto recordConfigIt = mConfigs.find(propId);
+ return recordConfigIt != mConfigs.end() ? &recordConfigIt->second.propConfig : nullptr;
+}
+
+const VehiclePropConfig* VehiclePropertyStore::getConfigOrDie(int32_t propId) const {
+ auto cfg = getConfigOrNull(propId);
+ if (!cfg) {
+ ALOGW("%s: config not found for property: 0x%x", __func__, propId);
+ abort();
+ }
+ return cfg;
+}
+
+VehiclePropertyStore::RecordId VehiclePropertyStore::getRecordIdLocked(
+ const VehiclePropValue& valuePrototype) const {
+ RecordId recId = {
+ .prop = valuePrototype.prop,
+ .area = isGlobalProp(valuePrototype.prop) ? 0 : valuePrototype.areaId,
+ .token = 0
+ };
+
+ auto it = mConfigs.find(recId.prop);
+ if (it == mConfigs.end()) return {};
+
+ if (it->second.tokenFunction != nullptr) {
+ recId.token = it->second.tokenFunction(valuePrototype);
+ }
+ return recId;
+}
+
+const VehiclePropValue* VehiclePropertyStore::getValueOrNullLocked(
+ const VehiclePropertyStore::RecordId& recId) const {
+ auto it = mPropertyValues.find(recId);
+ return it == mPropertyValues.end() ? nullptr : &it->second;
+}
+
+VehiclePropertyStore::PropertyMapRange VehiclePropertyStore::findRangeLocked(int32_t propId) const {
+ // Based on the fact that mPropertyValues is a sorted map by RecordId.
+ auto beginIt = mPropertyValues.lower_bound( RecordId { propId, INT32_MIN, 0 });
+ auto endIt = mPropertyValues.lower_bound( RecordId { propId + 1, INT32_MIN, 0 });
+
+ return PropertyMapRange { beginIt, endIt };
+}
+
+} // namespace V2_0
+} // namespace vehicle
+} // namespace automotive
+} // namespace hardware
+} // namespace android
diff --git a/automotive/vehicle/2.0/default/impl/vhal_v2_0/DefaultConfig.h b/automotive/vehicle/2.0/default/impl/vhal_v2_0/DefaultConfig.h
index 545de39..bf16a9b 100644
--- a/automotive/vehicle/2.0/default/impl/vhal_v2_0/DefaultConfig.h
+++ b/automotive/vehicle/2.0/default/impl/vhal_v2_0/DefaultConfig.h
@@ -33,176 +33,257 @@
toInt(VehicleProperty::HVAC_FAN_DIRECTION),
};
-const VehiclePropConfig kVehicleProperties[] = {
+struct ConfigDeclaration {
+ VehiclePropConfig config;
+
+ /* This value will be used as an initial value for the property. If this field is specified for
+ * property that supports multiple areas then it will be used for all areas unless particular
+ * area is overridden in initialAreaValue field. */
+ VehiclePropValue::RawValue initialValue;
+ /* Use initialAreaValues if it is necessary to specify different values per each area. */
+ std::map<int32_t, VehiclePropValue::RawValue> initialAreaValues;
+};
+
+const ConfigDeclaration kVehicleProperties[] {
{
- .prop = toInt(VehicleProperty::INFO_MAKE),
- .access = VehiclePropertyAccess::READ,
- .changeMode = VehiclePropertyChangeMode::STATIC,
+ .config = {
+ .prop = toInt(VehicleProperty::INFO_MAKE),
+ .access = VehiclePropertyAccess::READ,
+ .changeMode = VehiclePropertyChangeMode::STATIC,
+ },
+ .initialValue = { .stringValue = "Toy Vehicle" }
+ },
+ {
+ .config = {
+ .prop = toInt(VehicleProperty::PERF_VEHICLE_SPEED),
+ .access = VehiclePropertyAccess::READ,
+ .changeMode = VehiclePropertyChangeMode::ON_CHANGE,
+ },
+ .initialValue = { .floatValues = {0.0f} }
},
{
- .prop = toInt(VehicleProperty::PERF_VEHICLE_SPEED),
- .access = VehiclePropertyAccess::READ,
- .changeMode = VehiclePropertyChangeMode::ON_CHANGE,
+ .config = {
+ .prop = toInt(VehicleProperty::CURRENT_GEAR),
+ .access = VehiclePropertyAccess::READ,
+ .changeMode = VehiclePropertyChangeMode::ON_CHANGE,
+ },
+ .initialValue = { .int32Values = { toInt(VehicleGear::GEAR_PARK) } }
},
{
- .prop = toInt(VehicleProperty::CURRENT_GEAR),
- .access = VehiclePropertyAccess::READ,
- .changeMode = VehiclePropertyChangeMode::ON_CHANGE,
+ .config = {
+ .prop = toInt(VehicleProperty::PARKING_BRAKE_ON),
+ .access = VehiclePropertyAccess::READ,
+ .changeMode = VehiclePropertyChangeMode::ON_CHANGE,
+ },
+ .initialValue = { .int32Values = {1} }
},
{
- .prop = toInt(VehicleProperty::PARKING_BRAKE_ON),
- .access = VehiclePropertyAccess::READ,
- .changeMode = VehiclePropertyChangeMode::ON_CHANGE,
+ .config = {
+ .prop = toInt(VehicleProperty::FUEL_LEVEL_LOW),
+ .access = VehiclePropertyAccess::READ,
+ .changeMode = VehiclePropertyChangeMode::ON_CHANGE,
+ },
+ .initialValue = { .int32Values = {0} }
},
{
- .prop = toInt(VehicleProperty::FUEL_LEVEL_LOW),
- .access = VehiclePropertyAccess::READ,
- .changeMode = VehiclePropertyChangeMode::ON_CHANGE,
+ .config = {
+ .prop = toInt(VehicleProperty::HVAC_POWER_ON),
+ .access = VehiclePropertyAccess::READ_WRITE,
+ .changeMode = VehiclePropertyChangeMode::ON_CHANGE,
+ .supportedAreas = toInt(VehicleAreaZone::ROW_1),
+ // TODO(bryaneyler): Ideally, this is generated dynamically from
+ // kHvacPowerProperties.
+ .configString = "0x12400500,0x12400501" // HVAC_FAN_SPEED,HVAC_FAN_DIRECTION
+ },
+ .initialValue = { .int32Values = {1} }
},
{
- .prop = toInt(VehicleProperty::HVAC_POWER_ON),
- .access = VehiclePropertyAccess::READ_WRITE,
- .changeMode = VehiclePropertyChangeMode::ON_CHANGE,
- .supportedAreas = toInt(VehicleAreaZone::ROW_1),
- // TODO(bryaneyler): Ideally, this is generated dynamically from
- // kHvacPowerProperties.
- .configString = "0x12400500,0x12400501" // HVAC_FAN_SPEED,HVAC_FAN_DIRECTION
+ .config = {
+ .prop = toInt(VehicleProperty::HVAC_DEFROSTER),
+ .access = VehiclePropertyAccess::READ_WRITE,
+ .changeMode = VehiclePropertyChangeMode::ON_CHANGE,
+ .supportedAreas =
+ VehicleAreaWindow::FRONT_WINDSHIELD
+ | VehicleAreaWindow::REAR_WINDSHIELD
+ },
+ .initialValue = { .int32Values = {0} } // Will be used for all areas.
},
{
- .prop = toInt(VehicleProperty::HVAC_DEFROSTER),
- .access = VehiclePropertyAccess::READ_WRITE,
- .changeMode = VehiclePropertyChangeMode::ON_CHANGE,
- .supportedAreas =
- VehicleAreaWindow::FRONT_WINDSHIELD
- | VehicleAreaWindow::REAR_WINDSHIELD
+ .config = {
+ .prop = toInt(VehicleProperty::HVAC_RECIRC_ON),
+ .access = VehiclePropertyAccess::READ_WRITE,
+ .changeMode = VehiclePropertyChangeMode::ON_CHANGE,
+ .supportedAreas = toInt(VehicleAreaZone::ROW_1)
+ },
+ .initialValue = { .int32Values = {1} }
},
{
- .prop = toInt(VehicleProperty::HVAC_RECIRC_ON),
- .access = VehiclePropertyAccess::READ_WRITE,
- .changeMode = VehiclePropertyChangeMode::ON_CHANGE,
- .supportedAreas = toInt(VehicleAreaZone::ROW_1)
+ .config = {
+ .prop = toInt(VehicleProperty::HVAC_AC_ON),
+ .access = VehiclePropertyAccess::READ_WRITE,
+ .changeMode = VehiclePropertyChangeMode::ON_CHANGE,
+ .supportedAreas = toInt(VehicleAreaZone::ROW_1)
+ },
+ .initialValue = { .int32Values = {1} }
},
{
- .prop = toInt(VehicleProperty::HVAC_AC_ON),
- .access = VehiclePropertyAccess::READ_WRITE,
- .changeMode = VehiclePropertyChangeMode::ON_CHANGE,
- .supportedAreas = toInt(VehicleAreaZone::ROW_1)
+ .config = {
+ .prop = toInt(VehicleProperty::HVAC_AUTO_ON),
+ .access = VehiclePropertyAccess::READ_WRITE,
+ .changeMode = VehiclePropertyChangeMode::ON_CHANGE,
+ .supportedAreas = toInt(VehicleAreaZone::ROW_1)
+ },
+ .initialValue = { .int32Values = {1} }
},
{
- .prop = toInt(VehicleProperty::HVAC_AUTO_ON),
- .access = VehiclePropertyAccess::READ_WRITE,
- .changeMode = VehiclePropertyChangeMode::ON_CHANGE,
- .supportedAreas = toInt(VehicleAreaZone::ROW_1)
+ .config = {
+ .prop = toInt(VehicleProperty::HVAC_FAN_SPEED),
+ .access = VehiclePropertyAccess::READ_WRITE,
+ .changeMode = VehiclePropertyChangeMode::ON_CHANGE,
+ .supportedAreas = toInt(VehicleAreaZone::ROW_1),
+ .areaConfigs = {
+ VehicleAreaConfig {
+ .areaId = toInt(VehicleAreaZone::ROW_1),
+ .minInt32Value = 1,
+ .maxInt32Value = 7
+ }
+ }
+ },
+ .initialValue = { .int32Values = {3} }
},
{
- .prop = toInt(VehicleProperty::HVAC_FAN_SPEED),
- .access = VehiclePropertyAccess::READ_WRITE,
- .changeMode = VehiclePropertyChangeMode::ON_CHANGE,
- .supportedAreas = toInt(VehicleAreaZone::ROW_1),
- .areaConfigs = {
- VehicleAreaConfig {
- .areaId = toInt(VehicleAreaZone::ROW_1),
- .minInt32Value = 1,
- .maxInt32Value = 7
+ .config = {
+ .prop = toInt(VehicleProperty::HVAC_FAN_DIRECTION),
+ .access = VehiclePropertyAccess::READ_WRITE,
+ .changeMode = VehiclePropertyChangeMode::ON_CHANGE,
+ .supportedAreas = toInt(VehicleAreaZone::ROW_1),
+ },
+ .initialValue = { .int32Values = { toInt(VehicleHvacFanDirection::FACE) } }
+ },
+
+ {
+ .config = {
+ .prop = toInt(VehicleProperty::HVAC_TEMPERATURE_SET),
+ .access = VehiclePropertyAccess::READ_WRITE,
+ .changeMode = VehiclePropertyChangeMode::ON_CHANGE,
+ .supportedAreas =
+ VehicleAreaZone::ROW_1_LEFT
+ | VehicleAreaZone::ROW_1_RIGHT,
+ .areaConfigs = {
+ VehicleAreaConfig {
+ .areaId = toInt(VehicleAreaZone::ROW_1_LEFT),
+ .minFloatValue = 16,
+ .maxFloatValue = 32,
+ },
+ VehicleAreaConfig {
+ .areaId = toInt(VehicleAreaZone::ROW_1_RIGHT),
+ .minFloatValue = 16,
+ .maxFloatValue = 32,
+ }
+ }
+ },
+ .initialAreaValues = {
+ {
+ toInt(VehicleAreaZone::ROW_1_LEFT),
+ { .floatValues = {16} }
+ }, {
+ toInt(VehicleAreaZone::ROW_1_RIGHT),
+ { .floatValues = {20} }
}
}
},
{
- .prop = toInt(VehicleProperty::HVAC_FAN_DIRECTION),
- .access = VehiclePropertyAccess::READ_WRITE,
- .changeMode = VehiclePropertyChangeMode::ON_CHANGE,
- .supportedAreas = toInt(VehicleAreaZone::ROW_1),
+ .config = {
+ .prop = toInt(VehicleProperty::ENV_OUTSIDE_TEMPERATURE),
+ .access = VehiclePropertyAccess::READ,
+ // TODO(bryaneyler): Support ON_CHANGE as well.
+ .changeMode = VehiclePropertyChangeMode::CONTINUOUS,
+ .minSampleRate = 1.0f,
+ .maxSampleRate = 2.0f,
+ },
+ .initialValue = { .floatValues = {25.0f} }
},
{
- .prop = toInt(VehicleProperty::HVAC_TEMPERATURE_SET),
- .access = VehiclePropertyAccess::READ_WRITE,
- .changeMode = VehiclePropertyChangeMode::ON_CHANGE,
- .supportedAreas =
- VehicleAreaZone::ROW_1_LEFT
- | VehicleAreaZone::ROW_1_RIGHT,
- .areaConfigs = {
- VehicleAreaConfig {
- .areaId = toInt(VehicleAreaZone::ROW_1_LEFT),
- .minFloatValue = 16,
- .maxFloatValue = 32,
- },
- VehicleAreaConfig {
- .areaId = toInt(VehicleAreaZone::ROW_1_RIGHT),
- .minFloatValue = 16,
- .maxFloatValue = 32,
+ .config = {
+ .prop = toInt(VehicleProperty::NIGHT_MODE),
+ .access = VehiclePropertyAccess::READ,
+ .changeMode = VehiclePropertyChangeMode::ON_CHANGE,
+ },
+ .initialValue = { .int32Values = {0} }
+ },
+
+ {
+ .config = {
+ .prop = toInt(VehicleProperty::DRIVING_STATUS),
+ .access = VehiclePropertyAccess::READ,
+ .changeMode = VehiclePropertyChangeMode::ON_CHANGE,
+ },
+ .initialValue = { .int32Values = { toInt(VehicleDrivingStatus::UNRESTRICTED) } }
+ },
+
+ {
+ .config = {
+ .prop = toInt(VehicleProperty::GEAR_SELECTION),
+ .access = VehiclePropertyAccess::READ,
+ .changeMode = VehiclePropertyChangeMode::ON_CHANGE,
+ },
+ .initialValue = { .int32Values = { toInt(VehicleGear::GEAR_PARK) } }
+ },
+
+ {
+ .config = {
+ .prop = toInt(VehicleProperty::INFO_FUEL_CAPACITY),
+ .access = VehiclePropertyAccess::READ,
+ .changeMode = VehiclePropertyChangeMode::STATIC,
+ },
+ .initialValue = { .floatValues = { 123000.0f } } // In Milliliters
+ },
+
+ {
+ .config = {
+ .prop = toInt(VehicleProperty::DISPLAY_BRIGHTNESS),
+ .access = VehiclePropertyAccess::READ_WRITE,
+ .changeMode = VehiclePropertyChangeMode::ON_CHANGE,
+ .areaConfigs = {
+ VehicleAreaConfig {
+ .minInt32Value = 0,
+ .maxInt32Value = 10
+ }
}
- }
+ },
+ .initialValue = { .int32Values = {7} }
},
{
- .prop = toInt(VehicleProperty::ENV_OUTSIDE_TEMPERATURE),
- .access = VehiclePropertyAccess::READ,
- // TODO(bryaneyler): Support ON_CHANGE as well.
- .changeMode = VehiclePropertyChangeMode::CONTINUOUS,
- .minSampleRate = 1.0f,
- .maxSampleRate = 2.0f,
+ .config = {
+ .prop = toInt(VehicleProperty::IGNITION_STATE),
+ .access = VehiclePropertyAccess::READ,
+ .changeMode = VehiclePropertyChangeMode::ON_CHANGE,
+ },
+ .initialValue = { .int32Values = { toInt(VehicleIgnitionState::ON) } }
},
{
- .prop = toInt(VehicleProperty::NIGHT_MODE),
- .access = VehiclePropertyAccess::READ,
- .changeMode = VehiclePropertyChangeMode::ON_CHANGE,
- },
-
- {
- .prop = toInt(VehicleProperty::DRIVING_STATUS),
- .access = VehiclePropertyAccess::READ,
- .changeMode = VehiclePropertyChangeMode::ON_CHANGE,
- },
-
- {
- .prop = toInt(VehicleProperty::GEAR_SELECTION),
- .access = VehiclePropertyAccess::READ,
- .changeMode = VehiclePropertyChangeMode::ON_CHANGE,
- },
-
- {
- .prop = toInt(VehicleProperty::INFO_FUEL_CAPACITY),
- .access = VehiclePropertyAccess::READ,
- .changeMode = VehiclePropertyChangeMode::STATIC,
- },
-
- {
- .prop = toInt(VehicleProperty::DISPLAY_BRIGHTNESS),
- .access = VehiclePropertyAccess::READ_WRITE,
- .changeMode = VehiclePropertyChangeMode::ON_CHANGE,
- .areaConfigs = {
- VehicleAreaConfig {
- .minInt32Value = 0,
- .maxInt32Value = 10
- }
- }
- },
-
- {
- .prop = toInt(VehicleProperty::IGNITION_STATE),
- .access = VehiclePropertyAccess::READ,
- .changeMode = VehiclePropertyChangeMode::ON_CHANGE,
- },
-
- {
- .prop = toInt(VehicleProperty::ENGINE_OIL_TEMP),
- .access = VehiclePropertyAccess::READ,
- .changeMode = VehiclePropertyChangeMode::CONTINUOUS,
- .minSampleRate = 0.1, // 0.1 Hz, every 10 seconds
- .maxSampleRate = 10, // 10 Hz, every 100 ms
+ .config = {
+ .prop = toInt(VehicleProperty::ENGINE_OIL_TEMP),
+ .access = VehiclePropertyAccess::READ,
+ .changeMode = VehiclePropertyChangeMode::CONTINUOUS,
+ .minSampleRate = 0.1, // 0.1 Hz, every 10 seconds
+ .maxSampleRate = 10, // 10 Hz, every 100 ms
+ },
+ .initialValue = { .floatValues = {101.0f} }
}
};
diff --git a/automotive/vehicle/2.0/default/impl/vhal_v2_0/DefaultVehicleHal.cpp b/automotive/vehicle/2.0/default/impl/vhal_v2_0/DefaultVehicleHal.cpp
deleted file mode 100644
index 03a65f3..0000000
--- a/automotive/vehicle/2.0/default/impl/vhal_v2_0/DefaultVehicleHal.cpp
+++ /dev/null
@@ -1,689 +0,0 @@
-/*
- * Copyright (C) 2016 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.
- */
-
-#define LOG_TAG "DefaultVehicleHal_v2_0"
-#include <android/log.h>
-
-#include <algorithm>
-#include <android-base/properties.h>
-#include <cstdio>
-
-#include "DefaultVehicleHal.h"
-#include "PipeComm.h"
-#include "SocketComm.h"
-#include "VehicleHalProto.pb.h"
-
-namespace android {
-namespace hardware {
-namespace automotive {
-namespace vehicle {
-namespace V2_0 {
-
-namespace impl {
-
-void DefaultVehicleHal::doGetConfig(emulator::EmulatorMessage& rxMsg,
- emulator::EmulatorMessage& respMsg) {
- std::vector<VehiclePropConfig> configs = listProperties();
- emulator::VehiclePropGet getProp = rxMsg.prop(0);
-
- respMsg.set_msg_type(emulator::GET_CONFIG_RESP);
- respMsg.set_status(emulator::ERROR_INVALID_PROPERTY);
-
- for (auto& config : configs) {
- // Find the config we are looking for
- if (config.prop == getProp.prop()) {
- emulator::VehiclePropConfig* protoCfg = respMsg.add_config();
- populateProtoVehicleConfig(protoCfg, config);
- respMsg.set_status(emulator::RESULT_OK);
- break;
- }
- }
-}
-
-void DefaultVehicleHal::doGetConfigAll(emulator::EmulatorMessage& /* rxMsg */,
- emulator::EmulatorMessage& respMsg) {
- std::vector<VehiclePropConfig> configs = listProperties();
-
- respMsg.set_msg_type(emulator::GET_CONFIG_ALL_RESP);
- respMsg.set_status(emulator::RESULT_OK);
-
- for (auto& config : configs) {
- emulator::VehiclePropConfig* protoCfg = respMsg.add_config();
- populateProtoVehicleConfig(protoCfg, config);
- }
-}
-
-void DefaultVehicleHal::doGetProperty(emulator::EmulatorMessage& rxMsg,
- emulator::EmulatorMessage& respMsg) {
- int32_t areaId = 0;
- emulator::VehiclePropGet getProp = rxMsg.prop(0);
- int32_t propId = getProp.prop();
- emulator::Status status = emulator::ERROR_INVALID_PROPERTY;
- VehiclePropValue* val;
-
- respMsg.set_msg_type(emulator::GET_PROPERTY_RESP);
-
- if (getProp.has_area_id()) {
- areaId = getProp.area_id();
- }
-
- {
- std::lock_guard<std::mutex> lock(mPropsMutex);
-
- val = getVehiclePropValueLocked(propId, areaId);
- if (val != nullptr) {
- emulator::VehiclePropValue* protoVal = respMsg.add_value();
- populateProtoVehiclePropValue(protoVal, val);
- status = emulator::RESULT_OK;
- }
- }
-
- respMsg.set_status(status);
-}
-
-void DefaultVehicleHal::doGetPropertyAll(emulator::EmulatorMessage& /* rxMsg */,
- emulator::EmulatorMessage& respMsg) {
- respMsg.set_msg_type(emulator::GET_PROPERTY_ALL_RESP);
- respMsg.set_status(emulator::RESULT_OK);
-
- {
- std::lock_guard<std::mutex> lock(mPropsMutex);
-
- for (auto& prop : mProps) {
- emulator::VehiclePropValue* protoVal = respMsg.add_value();
- populateProtoVehiclePropValue(protoVal, prop.second->get());
- }
- }
-}
-
-void DefaultVehicleHal::doSetProperty(emulator::EmulatorMessage& rxMsg,
- emulator::EmulatorMessage& respMsg) {
- emulator::VehiclePropValue protoVal = rxMsg.value(0);
- VehiclePropValue val;
-
- respMsg.set_msg_type(emulator::SET_PROPERTY_RESP);
-
- val.prop = protoVal.prop();
- val.areaId = protoVal.area_id();
- val.timestamp = elapsedRealtimeNano();
-
- // Copy value data if it is set. This automatically handles complex data types if needed.
- if (protoVal.has_string_value()) {
- val.value.stringValue = protoVal.string_value().c_str();
- }
-
- if (protoVal.has_bytes_value()) {
- std::vector<uint8_t> tmp(protoVal.bytes_value().begin(), protoVal.bytes_value().end());
- val.value.bytes = tmp;
- }
-
- if (protoVal.int32_values_size() > 0) {
- std::vector<int32_t> int32Values = std::vector<int32_t>(protoVal.int32_values_size());
- for (int i=0; i<protoVal.int32_values_size(); i++) {
- int32Values[i] = protoVal.int32_values(i);
- }
- val.value.int32Values = int32Values;
- }
-
- if (protoVal.int64_values_size() > 0) {
- std::vector<int64_t> int64Values = std::vector<int64_t>(protoVal.int64_values_size());
- for (int i=0; i<protoVal.int64_values_size(); i++) {
- int64Values[i] = protoVal.int64_values(i);
- }
- val.value.int64Values = int64Values;
- }
-
- if (protoVal.float_values_size() > 0) {
- std::vector<float> floatValues = std::vector<float>(protoVal.float_values_size());
- for (int i=0; i<protoVal.float_values_size(); i++) {
- floatValues[i] = protoVal.float_values(i);
- }
- val.value.floatValues = floatValues;
- }
-
- if (updateProperty(val) == StatusCode::OK) {
- // Send property up to VehicleHalManager via callback
- auto& pool = *getValuePool();
- VehiclePropValuePtr v = pool.obtain(val);
-
- doHalEvent(std::move(v));
- respMsg.set_status(emulator::RESULT_OK);
- } else {
- respMsg.set_status(emulator::ERROR_INVALID_PROPERTY);
- }
-}
-
-// This function should only be called while mPropsMutex is locked.
-VehiclePropValue* DefaultVehicleHal::getVehiclePropValueLocked(int32_t propId, int32_t areaId) {
- if (getPropArea(propId) == VehicleArea::GLOBAL) {
- // In VehicleHal, global properties have areaId = -1. We use 0.
- areaId = 0;
- }
-
- auto prop = mProps.find(std::make_pair(propId, areaId));
- if (prop != mProps.end()) {
- return prop->second->get();
- }
- ALOGW("%s: Property not found: propId = 0x%x, areaId = 0x%x", __func__, propId, areaId);
- return nullptr;
-}
-
-void DefaultVehicleHal::parseRxProtoBuf(std::vector<uint8_t>& msg) {
- emulator::EmulatorMessage rxMsg;
- emulator::EmulatorMessage respMsg;
-
- if (rxMsg.ParseFromArray(msg.data(), msg.size())) {
- switch (rxMsg.msg_type()) {
- case emulator::GET_CONFIG_CMD:
- doGetConfig(rxMsg, respMsg);
- break;
- case emulator::GET_CONFIG_ALL_CMD:
- doGetConfigAll(rxMsg, respMsg);
- break;
- case emulator::GET_PROPERTY_CMD:
- doGetProperty(rxMsg, respMsg);
- break;
- case emulator::GET_PROPERTY_ALL_CMD:
- doGetPropertyAll(rxMsg, respMsg);
- break;
- case emulator::SET_PROPERTY_CMD:
- doSetProperty(rxMsg, respMsg);
- break;
- default:
- ALOGW("%s: Unknown message received, type = %d", __func__, rxMsg.msg_type());
- respMsg.set_status(emulator::ERROR_UNIMPLEMENTED_CMD);
- break;
- }
-
- // Send the reply
- txMsg(respMsg);
- } else {
- ALOGE("%s: ParseFromString() failed. msgSize=%d", __func__, static_cast<int>(msg.size()));
- }
-}
-
-// Copies internal VehiclePropConfig data structure to protobuf VehiclePropConfig
-void DefaultVehicleHal::populateProtoVehicleConfig(emulator::VehiclePropConfig* protoCfg,
- const VehiclePropConfig& cfg) {
- protoCfg->set_prop(cfg.prop);
- protoCfg->set_access(toInt(cfg.access));
- protoCfg->set_change_mode(toInt(cfg.changeMode));
- protoCfg->set_value_type(toInt(getPropType(cfg.prop)));
-
- if (!isGlobalProp(cfg.prop)) {
- protoCfg->set_supported_areas(cfg.supportedAreas);
- }
-
- for (auto& configElement : cfg.configArray) {
- protoCfg->add_config_array(configElement);
- }
-
- if (cfg.configString.size() > 0) {
- protoCfg->set_config_string(cfg.configString.c_str(), cfg.configString.size());
- }
-
- // Populate the min/max values based on property type
- switch (getPropType(cfg.prop)) {
- case VehiclePropertyType::STRING:
- case VehiclePropertyType::BOOLEAN:
- case VehiclePropertyType::INT32_VEC:
- case VehiclePropertyType::FLOAT_VEC:
- case VehiclePropertyType::BYTES:
- case VehiclePropertyType::COMPLEX:
- // Do nothing. These types don't have min/max values
- break;
- case VehiclePropertyType::INT64:
- if (cfg.areaConfigs.size() > 0) {
- emulator::VehicleAreaConfig* aCfg = protoCfg->add_area_configs();
- aCfg->set_min_int64_value(cfg.areaConfigs[0].minInt64Value);
- aCfg->set_max_int64_value(cfg.areaConfigs[0].maxInt64Value);
- }
- break;
- case VehiclePropertyType::FLOAT:
- if (cfg.areaConfigs.size() > 0) {
- emulator::VehicleAreaConfig* aCfg = protoCfg->add_area_configs();
- aCfg->set_min_float_value(cfg.areaConfigs[0].minFloatValue);
- aCfg->set_max_float_value(cfg.areaConfigs[0].maxFloatValue);
- }
- break;
- case VehiclePropertyType::INT32:
- if (cfg.areaConfigs.size() > 0) {
- emulator::VehicleAreaConfig* aCfg = protoCfg->add_area_configs();
- aCfg->set_min_int32_value(cfg.areaConfigs[0].minInt32Value);
- aCfg->set_max_int32_value(cfg.areaConfigs[0].maxInt32Value);
- }
- break;
- default:
- ALOGW("%s: Unknown property type: 0x%x", __func__, toInt(getPropType(cfg.prop)));
- break;
- }
-
- protoCfg->set_min_sample_rate(cfg.minSampleRate);
- protoCfg->set_max_sample_rate(cfg.maxSampleRate);
-}
-
-// Copies internal VehiclePropValue data structure to protobuf VehiclePropValue
-void DefaultVehicleHal::populateProtoVehiclePropValue(emulator::VehiclePropValue* protoVal,
- const VehiclePropValue* val) {
- protoVal->set_prop(val->prop);
- protoVal->set_value_type(toInt(getPropType(val->prop)));
- protoVal->set_timestamp(val->timestamp);
- protoVal->set_area_id(val->areaId);
-
- // Copy value data if it is set.
- // - for bytes and strings, this is indicated by size > 0
- // - for int32, int64, and float, copy the values if vectors have data
- if (val->value.stringValue.size() > 0) {
- protoVal->set_string_value(val->value.stringValue.c_str(), val->value.stringValue.size());
- }
-
- if (val->value.bytes.size() > 0) {
- protoVal->set_bytes_value(val->value.bytes.data(), val->value.bytes.size());
- }
-
- for (auto& int32Value : val->value.int32Values) {
- protoVal->add_int32_values(int32Value);
- }
-
- for (auto& int64Value : val->value.int64Values) {
- protoVal->add_int64_values(int64Value);
- }
-
- for (auto& floatValue : val->value.floatValues) {
- protoVal->add_float_values(floatValue);
- }
-}
-
-void DefaultVehicleHal::rxMsg() {
- int numBytes = 0;
-
- while (mExit == 0) {
- std::vector<uint8_t> msg = mComm->read();
-
- if (msg.size() > 0) {
- // Received a message.
- parseRxProtoBuf(msg);
- } else {
- // This happens when connection is closed
- ALOGD("%s: numBytes=%d, msgSize=%d", __func__, numBytes,
- static_cast<int32_t>(msg.size()));
- break;
- }
- }
-}
-
-void DefaultVehicleHal::rxThread() {
- bool isEmulator = android::base::GetBoolProperty("ro.kernel.qemu", false);
-
- if (isEmulator) {
- // Initialize pipe to Emulator
- mComm.reset(new PipeComm);
- } else {
- // Initialize socket over ADB
- mComm.reset(new SocketComm);
- }
-
- int retVal = mComm->open();
-
- if (retVal == 0) {
- // Comms are properly opened
- while (mExit == 0) {
- retVal = mComm->connect();
-
- if (retVal >= 0) {
- rxMsg();
- }
-
- // Check every 100ms for a new connection
- std::this_thread::sleep_for(std::chrono::milliseconds(100));
- }
- }
-}
-
-// This function sets the default value of a property if we are interested in setting it.
-// TODO: Co-locate the default values with the configuration structure, to make it easier to
-// add new properties and their defaults.
-void DefaultVehicleHal::setDefaultValue(VehiclePropValue* prop) {
- switch (prop->prop) {
- case toInt(VehicleProperty::INFO_MAKE):
- prop->value.stringValue = "Default Car";
- break;
- case toInt(VehicleProperty::PERF_VEHICLE_SPEED):
- prop->value.floatValues[0] = 0;
- break;
- case toInt(VehicleProperty::CURRENT_GEAR):
- prop->value.int32Values[0] = toInt(VehicleGear::GEAR_PARK);
- break;
- case toInt(VehicleProperty::PARKING_BRAKE_ON):
- prop->value.int32Values[0] = 1;
- break;
- case toInt(VehicleProperty::FUEL_LEVEL_LOW):
- prop->value.int32Values[0] = 0;
- break;
- case toInt(VehicleProperty::HVAC_POWER_ON):
- prop->value.int32Values[0] = 1;
- break;
- case toInt(VehicleProperty::HVAC_DEFROSTER):
- prop->value.int32Values[0] = 0;
- break;
- case toInt(VehicleProperty::HVAC_RECIRC_ON):
- prop->value.int32Values[0] = 1;
- break;
- case toInt(VehicleProperty::HVAC_AC_ON):
- prop->value.int32Values[0] = 1;
- break;
- case toInt(VehicleProperty::HVAC_AUTO_ON):
- prop->value.int32Values[0] = 1;
- break;
- case toInt(VehicleProperty::HVAC_FAN_SPEED):
- prop->value.int32Values[0] = 3;
- break;
- case toInt(VehicleProperty::HVAC_FAN_DIRECTION):
- prop->value.int32Values[0] = toInt(VehicleHvacFanDirection::FACE);
- break;
- case toInt(VehicleProperty::HVAC_TEMPERATURE_SET):
- prop->value.floatValues[0] = 16;
- break;
- case toInt(VehicleProperty::ENV_OUTSIDE_TEMPERATURE):
- prop->value.floatValues[0] = 25;
- break;
- case toInt(VehicleProperty::NIGHT_MODE):
- prop->value.int32Values[0] = 0;
- break;
- case toInt(VehicleProperty::DRIVING_STATUS):
- prop->value.int32Values[0] = toInt(VehicleDrivingStatus::UNRESTRICTED);
- break;
- case toInt(VehicleProperty::GEAR_SELECTION):
- prop->value.int32Values[0] = toInt(VehicleGear::GEAR_PARK);
- break;
- case toInt(VehicleProperty::INFO_FUEL_CAPACITY):
- prop->value.floatValues[0] = 123000.0f; // In milliliters
- break;
- case toInt(VehicleProperty::ENGINE_OIL_TEMP):
- prop->value.floatValues[0] = 101;
- break;
- case toInt(VehicleProperty::DISPLAY_BRIGHTNESS):
- prop->value.int32Values[0] = 7;
- break;
- case toInt(VehicleProperty::IGNITION_STATE):
- prop->value.int32Values[0] = toInt(VehicleIgnitionState::ON);
- break;
- default:
- ALOGW("%s: propId=0x%x not found", __func__, prop->prop);
- break;
- }
-}
-
-// Transmit a reply back to the emulator
-void DefaultVehicleHal::txMsg(emulator::EmulatorMessage& txMsg) {
- int numBytes = txMsg.ByteSize();
- std::vector<uint8_t> msg(numBytes);
-
- if (txMsg.SerializeToArray(msg.data(), msg.size())) {
- int retVal = 0;
-
- // Send the message
- if (mExit == 0) {
- mComm->write(msg);
- }
-
- if (retVal < 0) {
- ALOGE("%s: Failed to tx message: retval=%d, errno=%d", __func__, retVal, errno);
- }
- } else {
- ALOGE("%s: SerializeToString failed!", __func__);
- }
-}
-
-// Updates the property value held in the HAL
-StatusCode DefaultVehicleHal::updateProperty(const VehiclePropValue& propValue) {
- auto propId = propValue.prop;
- auto areaId = propValue.areaId;
- StatusCode status = StatusCode::INVALID_ARG;
-
- {
- std::lock_guard<std::mutex> lock(mPropsMutex);
-
- VehiclePropValue* internalPropValue = getVehiclePropValueLocked(propId, areaId);
- if (internalPropValue != nullptr) {
- internalPropValue->value = propValue.value;
- internalPropValue->timestamp = propValue.timestamp;
- status = StatusCode::OK;
- }
- }
- return status;
-}
-
-VehicleHal::VehiclePropValuePtr DefaultVehicleHal::get(
- const VehiclePropValue& requestedPropValue, StatusCode* outStatus) {
- auto areaId = requestedPropValue.areaId;
- auto& pool = *getValuePool();
- auto propId = requestedPropValue.prop;
- StatusCode status;
- VehiclePropValuePtr v = nullptr;
-
- switch (propId) {
- default:
- {
- std::lock_guard<std::mutex> lock(mPropsMutex);
-
- VehiclePropValue *internalPropValue = getVehiclePropValueLocked(propId, areaId);
- if (internalPropValue != nullptr) {
- v = pool.obtain(*internalPropValue);
- }
- }
-
- if (v != nullptr) {
- status = StatusCode::OK;
- } else {
- status = StatusCode::INVALID_ARG;
- }
- break;
- }
-
- *outStatus = status;
- return v;
-}
-
-StatusCode DefaultVehicleHal::set(const VehiclePropValue& propValue) {
- auto propId = propValue.prop;
- StatusCode status;
- switch (propId) {
- default:
- if (mHvacPowerProps.count(propId)) {
- std::lock_guard<std::mutex> lock(mPropsMutex);
- auto hvacPowerOn = getVehiclePropValueLocked(toInt(VehicleProperty::HVAC_POWER_ON),
- toInt(VehicleAreaZone::ROW_1));
-
- if (hvacPowerOn && hvacPowerOn->value.int32Values.size() == 1
- && hvacPowerOn->value.int32Values[0] == 0) {
- status = StatusCode::NOT_AVAILABLE;
- break;
- }
- }
- status = updateProperty(propValue);
- if (status == StatusCode::OK) {
- // Send property update to emulator
- emulator::EmulatorMessage msg;
- emulator::VehiclePropValue *val = msg.add_value();
- populateProtoVehiclePropValue(val, &propValue);
- msg.set_status(emulator::RESULT_OK);
- msg.set_msg_type(emulator::SET_PROPERTY_ASYNC);
- txMsg(msg);
- }
- break;
- }
-
- return status;
-}
-
-V2_0::StatusCode DefaultVehicleHal::addCustomProperty(int32_t property,
- std::unique_ptr<CustomVehiclePropertyHandler>&& handler) {
- mProps[std::make_pair(property, 0)] = std::move(handler);
- ALOGW("%s: Added custom property: propId = 0x%x", __func__, property);
- return StatusCode::OK;
-}
-
-// Parse supported properties list and generate vector of property values to hold current values.
-void DefaultVehicleHal::onCreate() {
- // Initialize member variables
- mExit = 0;
-
- for (auto& prop : kHvacPowerProperties) {
- mHvacPowerProps.insert(prop);
- }
-
- // Get the list of configurations supported by this HAL
- std::vector<VehiclePropConfig> configs = listProperties();
-
- for (auto& cfg : configs) {
- VehiclePropertyType propType = getPropType(cfg.prop);
- int32_t supportedAreas = cfg.supportedAreas;
- int32_t vecSize;
-
- // Set the vector size based on property type
- switch (propType) {
- case VehiclePropertyType::BOOLEAN:
- case VehiclePropertyType::INT32:
- case VehiclePropertyType::INT64:
- case VehiclePropertyType::FLOAT:
- vecSize = 1;
- break;
- case VehiclePropertyType::INT32_VEC:
- case VehiclePropertyType::FLOAT_VEC:
- case VehiclePropertyType::BYTES:
- // TODO: Add proper support for these types
- vecSize = 1;
- break;
- case VehiclePropertyType::STRING:
- // Require individual handling
- vecSize = 0;
- break;
- case VehiclePropertyType::COMPLEX:
- switch (cfg.prop) {
- default:
- // Need to handle each complex property separately
- break;
- }
- continue;
- default:
- ALOGE("%s: propType=0x%x not found", __func__, propType);
- vecSize = 0;
- break;
- }
-
- // A global property will have supportedAreas = 0
- if (getPropArea(cfg.prop) == VehicleArea::GLOBAL) {
- supportedAreas = 0;
- }
-
- // This loop is a do-while so it executes at least once to handle global properties
- do {
- int32_t curArea = supportedAreas;
-
- // Clear the right-most bit of supportedAreas
- supportedAreas &= supportedAreas - 1;
-
- // Set curArea to the previously cleared bit
- curArea ^= supportedAreas;
-
- // Create a separate instance for each individual zone
- std::unique_ptr<VehiclePropValue> prop = createVehiclePropValue(propType, vecSize);
- prop->areaId = curArea;
- prop->prop = cfg.prop;
- setDefaultValue(prop.get());
- std::unique_ptr<CustomVehiclePropertyHandler> handler;
- handler.reset(new StoredValueCustomVehiclePropertyHandler());
- handler->set(*prop);
- mProps[std::make_pair(prop->prop, prop->areaId)] =
- std::move(handler);
- } while (supportedAreas != 0);
- }
-
- // Start rx thread
- mThread = std::thread(&DefaultVehicleHal::rxThread, this);
-}
-
-void DefaultVehicleHal::onContinuousPropertyTimer(const std::vector<int32_t>& properties) {
- VehiclePropValuePtr v;
-
- auto& pool = *getValuePool();
-
- for (int32_t property : properties) {
- if (isContinuousProperty(property)) {
- // In real implementation this value should be read from sensor, random
- // value used for testing purpose only.
- std::lock_guard<std::mutex> lock(mPropsMutex);
-
- VehiclePropValue *internalPropValue = getVehiclePropValueLocked(property);
- if (internalPropValue != nullptr) {
- v = pool.obtain(*internalPropValue);
- }
- if (VehiclePropertyType::FLOAT == getPropType(property)) {
- // Just get some randomness to continuous properties to see slightly differnt values
- // on the other end.
- v->value.floatValues[0] = v->value.floatValues[0] + std::rand() % 5;
- }
- } else {
- ALOGE("Unexpected onContinuousPropertyTimer for property: 0x%x", property);
- }
-
- if (v.get()) {
- v->timestamp = elapsedRealtimeNano();
- doHalEvent(std::move(v));
- }
- }
-}
-
-StatusCode DefaultVehicleHal::subscribe(int32_t property, int32_t,
- float sampleRate) {
- ALOGI("subscribe called for property: 0x%x, sampleRate: %f", property, sampleRate);
-
- if (isContinuousProperty(property)) {
- mRecurrentTimer.registerRecurrentEvent(hertzToNanoseconds(sampleRate), property);
- }
- return StatusCode::OK;
-}
-
-StatusCode DefaultVehicleHal::unsubscribe(int32_t property) {
- ALOGI("%s propId: 0x%x", __func__, property);
- if (isContinuousProperty(property)) {
- mRecurrentTimer.unregisterRecurrentEvent(property);
- }
- return StatusCode::OK;
-}
-
-const VehiclePropConfig* DefaultVehicleHal::getPropConfig(int32_t propId) const {
- auto it = mPropConfigMap.find(propId);
- return it == mPropConfigMap.end() ? nullptr : it->second;
-}
-
-bool DefaultVehicleHal::isContinuousProperty(int32_t propId) const {
- const VehiclePropConfig* config = getPropConfig(propId);
- if (config == nullptr) {
- ALOGW("Config not found for property: 0x%x", propId);
- return false;
- }
- return config->changeMode == VehiclePropertyChangeMode::CONTINUOUS;
-}
-
-} // impl
-
-} // namespace V2_0
-} // namespace vehicle
-} // namespace automotive
-} // namespace hardware
-} // namespace android
diff --git a/automotive/vehicle/2.0/default/impl/vhal_v2_0/DefaultVehicleHal.h b/automotive/vehicle/2.0/default/impl/vhal_v2_0/DefaultVehicleHal.h
deleted file mode 100644
index c8310b3..0000000
--- a/automotive/vehicle/2.0/default/impl/vhal_v2_0/DefaultVehicleHal.h
+++ /dev/null
@@ -1,189 +0,0 @@
-/*
- * Copyright (C) 2016 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.
- */
-
-#ifndef android_hardware_automotive_vehicle_V2_0_impl_DefaultVehicleHal_H_
-#define android_hardware_automotive_vehicle_V2_0_impl_DefaultVehicleHal_H_
-
-#include <map>
-#include <memory>
-#include <sys/socket.h>
-#include <thread>
-#include <unordered_set>
-
-#include <utils/SystemClock.h>
-
-#include "CommBase.h"
-#include "VehicleHalProto.pb.h"
-
-#include <vhal_v2_0/RecurrentTimer.h>
-#include <vhal_v2_0/VehicleHal.h>
-
-#include "DefaultConfig.h"
-#include "VehicleHalProto.pb.h"
-
-namespace android {
-namespace hardware {
-namespace automotive {
-namespace vehicle {
-namespace V2_0 {
-
-namespace impl {
-
-class DefaultVehicleHal : public VehicleHal {
-public:
- class CustomVehiclePropertyHandler {
- public:
- virtual VehiclePropValue* get() = 0;
- virtual StatusCode set(const VehiclePropValue& propValue) = 0;
- virtual ~CustomVehiclePropertyHandler() = default;
- };
-
-protected:
- class StoredValueCustomVehiclePropertyHandler :
- public CustomVehiclePropertyHandler {
- public:
- VehiclePropValue* get() override {
- return mPropValue.get();
- }
-
- StatusCode set(const VehiclePropValue& propValue) {
- *mPropValue = propValue;
- return StatusCode::OK;
- }
-private:
- std::unique_ptr<VehiclePropValue> mPropValue{new VehiclePropValue()};
-};
-
-public:
- DefaultVehicleHal() : mRecurrentTimer(
- std::bind(&DefaultVehicleHal::onContinuousPropertyTimer, this, std::placeholders::_1)) {
- for (size_t i = 0; i < arraysize(kVehicleProperties); i++) {
- mPropConfigMap[kVehicleProperties[i].prop] = &kVehicleProperties[i];
- }
- }
-
- ~DefaultVehicleHal() override {
- // Notify thread to finish and wait for it to terminate
- mExit = 1;
-
- // Close emulator socket if it is open
- mComm->stop();
-
- mThread.join();
- }
-
- std::vector<VehiclePropConfig> listProperties() override {
- return std::vector<VehiclePropConfig>(std::begin(kVehicleProperties),
- std::end(kVehicleProperties));
- }
-
- VehiclePropValuePtr get(const VehiclePropValue& requestedPropValue,
- StatusCode* outStatus) override;
-
- void onCreate() override;
-
- StatusCode set(const VehiclePropValue& propValue) override;
-
- StatusCode subscribe(int32_t property, int32_t areas, float sampleRate) override;
-
- StatusCode unsubscribe(int32_t property) override;
-
- /**
- * Add custom property information to this HAL instance.
- *
- * This is useful for allowing later versions of Vehicle HAL to coalesce
- * the list of properties they support with a previous version of the HAL.
- *
- * @param property The identifier of the new property
- * @param handler The object that will handle get/set requests
- * @return OK on success, an error code on failure
- */
- virtual StatusCode addCustomProperty(int32_t,
- std::unique_ptr<CustomVehiclePropertyHandler>&&);
-
- /**
- * Add custom property information to this HAL instance.
- *
- * This is useful for allowing later versions of Vehicle HAL to coalesce
- * the list of properties they support with a previous version of the HAL.
- *
- * @param initialValue The initial value for the new property. This is not
- * constant data, as later set() operations can change
- * this value at will
- * @return OK on success, an error code on failure
- */
- virtual StatusCode addCustomProperty(
- const VehiclePropValue& initialValue) {
- std::unique_ptr<CustomVehiclePropertyHandler> handler;
- handler.reset(new StoredValueCustomVehiclePropertyHandler());
- StatusCode setResponse = handler->set(initialValue);
- if (StatusCode::OK == setResponse) {
- return addCustomProperty(initialValue.prop,
- std::move(handler));
- } else {
- return setResponse;
- }
- }
-
-private:
- void doGetConfig(emulator::EmulatorMessage& rxMsg, emulator::EmulatorMessage& respMsg);
- void doGetConfigAll(emulator::EmulatorMessage& rxMsg, emulator::EmulatorMessage& respMsg);
- void doGetProperty(emulator::EmulatorMessage& rxMsg, emulator::EmulatorMessage& respMsg);
- void doGetPropertyAll(emulator::EmulatorMessage& rxMsg, emulator::EmulatorMessage& respMsg);
- void doSetProperty(emulator::EmulatorMessage& rxMsg, emulator::EmulatorMessage& respMsg);
- VehiclePropValue* getVehiclePropValueLocked(int32_t propId, int32_t areaId = 0);
- const VehiclePropConfig* getPropConfig(int32_t propId) const;
- bool isContinuousProperty(int32_t propId) const;
- void parseRxProtoBuf(std::vector<uint8_t>& msg);
- void populateProtoVehicleConfig(emulator::VehiclePropConfig* protoCfg,
- const VehiclePropConfig& cfg);
- void populateProtoVehiclePropValue(emulator::VehiclePropValue* protoVal,
- const VehiclePropValue* val);
- void setDefaultValue(VehiclePropValue* prop);
- void rxMsg();
- void rxThread();
- void txMsg(emulator::EmulatorMessage& txMsg);
- StatusCode updateProperty(const VehiclePropValue& propValue);
-
- constexpr std::chrono::nanoseconds hertzToNanoseconds(float hz) const {
- return std::chrono::nanoseconds(static_cast<int64_t>(1000000000L / hz));
- }
-
- void onContinuousPropertyTimer(const std::vector<int32_t>& properties);
-
-private:
- std::map<
- std::pair<int32_t /*VehicleProperty*/, int32_t /*areaId*/>,
- std::unique_ptr<CustomVehiclePropertyHandler>> mProps;
- std::atomic<int> mExit;
- std::unordered_set<int32_t> mHvacPowerProps;
- std::mutex mPropsMutex;
- std::thread mThread;
- std::unique_ptr<CommBase> mComm{nullptr};
- RecurrentTimer mRecurrentTimer;
- std::unordered_map<int32_t, const VehiclePropConfig*> mPropConfigMap;
-};
-
-} // impl
-
-} // namespace V2_0
-} // namespace vehicle
-} // namespace automotive
-} // namespace hardware
-} // namespace android
-
-
-#endif // android_hardware_automotive_vehicle_V2_0_impl_DefaultVehicleHal_H_
diff --git a/automotive/vehicle/2.0/default/impl/vhal_v2_0/EmulatedVehicleHal.cpp b/automotive/vehicle/2.0/default/impl/vhal_v2_0/EmulatedVehicleHal.cpp
new file mode 100644
index 0000000..0ac6ada
--- /dev/null
+++ b/automotive/vehicle/2.0/default/impl/vhal_v2_0/EmulatedVehicleHal.cpp
@@ -0,0 +1,185 @@
+/*
+ * Copyright (C) 2016 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.
+ */
+
+#define LOG_TAG "DefaultVehicleHal_v2_0"
+#include <android/log.h>
+
+#include "EmulatedVehicleHal.h"
+
+namespace android {
+namespace hardware {
+namespace automotive {
+namespace vehicle {
+namespace V2_0 {
+
+namespace impl {
+
+EmulatedVehicleHal::EmulatedVehicleHal(VehiclePropertyStore* propStore)
+ : mPropStore(propStore),
+ mHvacPowerProps(std::begin(kHvacPowerProperties), std::end(kHvacPowerProperties)),
+ mRecurrentTimer(std::bind(&EmulatedVehicleHal::onContinuousPropertyTimer,
+ this, std::placeholders::_1)) {
+
+ for (size_t i = 0; i < arraysize(kVehicleProperties); i++) {
+ mPropStore->registerProperty(kVehicleProperties[i].config);
+ }
+}
+
+VehicleHal::VehiclePropValuePtr EmulatedVehicleHal::get(
+ const VehiclePropValue& requestedPropValue, StatusCode* outStatus) {
+ VehiclePropValuePtr v = nullptr;
+
+ auto internalPropValue = mPropStore->readValueOrNull(requestedPropValue);
+ if (internalPropValue != nullptr) {
+ v = getValuePool()->obtain(*internalPropValue);
+ }
+
+ *outStatus = v != nullptr ? StatusCode::OK : StatusCode::INVALID_ARG;
+ return v;
+}
+
+StatusCode EmulatedVehicleHal::set(const VehiclePropValue& propValue) {
+ if (mHvacPowerProps.count(propValue.prop)) {
+ auto hvacPowerOn = mPropStore->readValueOrNull(toInt(VehicleProperty::HVAC_POWER_ON),
+ toInt(VehicleAreaZone::ROW_1));
+
+ if (hvacPowerOn && hvacPowerOn->value.int32Values.size() == 1
+ && hvacPowerOn->value.int32Values[0] == 0) {
+ return StatusCode::NOT_AVAILABLE;
+ }
+ }
+
+ if (!mPropStore->writeValue(propValue)) {
+ return StatusCode::INVALID_ARG;
+ }
+
+ getEmulatorOrDie()->doSetValueFromClient(propValue);
+
+ return StatusCode::OK;
+}
+
+// Parse supported properties list and generate vector of property values to hold current values.
+void EmulatedVehicleHal::onCreate() {
+ for (auto& it : kVehicleProperties) {
+ VehiclePropConfig cfg = it.config;
+ int32_t supportedAreas = cfg.supportedAreas;
+
+ // A global property will have supportedAreas = 0
+ if (isGlobalProp(cfg.prop)) {
+ supportedAreas = 0;
+ }
+
+ // This loop is a do-while so it executes at least once to handle global properties
+ do {
+ int32_t curArea = supportedAreas;
+ supportedAreas &= supportedAreas - 1; // Clear the right-most bit of supportedAreas.
+ curArea ^= supportedAreas; // Set curArea to the previously cleared bit.
+
+ // Create a separate instance for each individual zone
+ VehiclePropValue prop = {
+ .prop = cfg.prop,
+ .areaId = curArea,
+ };
+ if (it.initialAreaValues.size() > 0) {
+ auto valueForAreaIt = it.initialAreaValues.find(curArea);
+ if (valueForAreaIt != it.initialAreaValues.end()) {
+ prop.value = valueForAreaIt->second;
+ } else {
+ ALOGW("%s failed to get default value for prop 0x%x area 0x%x",
+ __func__, cfg.prop, curArea);
+ }
+ } else {
+ prop.value = it.initialValue;
+ }
+ mPropStore->writeValue(prop);
+
+ } while (supportedAreas != 0);
+ }
+}
+
+std::vector<VehiclePropConfig> EmulatedVehicleHal::listProperties() {
+ return mPropStore->getAllConfigs();
+}
+
+void EmulatedVehicleHal::onContinuousPropertyTimer(const std::vector<int32_t>& properties) {
+ VehiclePropValuePtr v;
+
+ auto& pool = *getValuePool();
+
+ for (int32_t property : properties) {
+ if (isContinuousProperty(property)) {
+ auto internalPropValue = mPropStore->readValueOrNull(property);
+ if (internalPropValue != nullptr) {
+ v = pool.obtain(*internalPropValue);
+ }
+ } else {
+ ALOGE("Unexpected onContinuousPropertyTimer for property: 0x%x", property);
+ }
+
+ if (v.get()) {
+ v->timestamp = elapsedRealtimeNano();
+ doHalEvent(std::move(v));
+ }
+ }
+}
+
+StatusCode EmulatedVehicleHal::subscribe(int32_t property, int32_t,
+ float sampleRate) {
+ ALOGI("%s propId: 0x%x, sampleRate: %f", __func__, property, sampleRate);
+
+ if (isContinuousProperty(property)) {
+ mRecurrentTimer.registerRecurrentEvent(hertzToNanoseconds(sampleRate), property);
+ }
+ return StatusCode::OK;
+}
+
+StatusCode EmulatedVehicleHal::unsubscribe(int32_t property) {
+ ALOGI("%s propId: 0x%x", __func__, property);
+ if (isContinuousProperty(property)) {
+ mRecurrentTimer.unregisterRecurrentEvent(property);
+ }
+ return StatusCode::OK;
+}
+
+bool EmulatedVehicleHal::isContinuousProperty(int32_t propId) const {
+ const VehiclePropConfig* config = mPropStore->getConfigOrNull(propId);
+ if (config == nullptr) {
+ ALOGW("Config not found for property: 0x%x", propId);
+ return false;
+ }
+ return config->changeMode == VehiclePropertyChangeMode::CONTINUOUS;
+}
+
+bool EmulatedVehicleHal::setPropertyFromVehicle(const VehiclePropValue& propValue) {
+ if (mPropStore->writeValue(propValue)) {
+ doHalEvent(getValuePool()->obtain(propValue));
+ return true;
+ } else {
+ return false;
+ }
+}
+
+std::vector<VehiclePropValue> EmulatedVehicleHal::getAllProperties() const {
+ return mPropStore->readAllValues();
+}
+
+} // impl
+
+} // namespace V2_0
+} // namespace vehicle
+} // namespace automotive
+} // namespace hardware
+} // namespace android
diff --git a/automotive/vehicle/2.0/default/impl/vhal_v2_0/EmulatedVehicleHal.h b/automotive/vehicle/2.0/default/impl/vhal_v2_0/EmulatedVehicleHal.h
new file mode 100644
index 0000000..e0874e2
--- /dev/null
+++ b/automotive/vehicle/2.0/default/impl/vhal_v2_0/EmulatedVehicleHal.h
@@ -0,0 +1,88 @@
+/*
+ * Copyright (C) 2016 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.
+ */
+
+#ifndef android_hardware_automotive_vehicle_V2_0_impl_EmulatedVehicleHal_H_
+#define android_hardware_automotive_vehicle_V2_0_impl_EmulatedVehicleHal_H_
+
+#include <map>
+#include <memory>
+#include <sys/socket.h>
+#include <thread>
+#include <unordered_set>
+
+#include <utils/SystemClock.h>
+
+#include "VehicleHalProto.pb.h"
+
+#include <vhal_v2_0/RecurrentTimer.h>
+#include <vhal_v2_0/VehicleHal.h>
+#include "vhal_v2_0/VehiclePropertyStore.h"
+
+#include "DefaultConfig.h"
+#include "VehicleHalProto.pb.h"
+#include "VehicleEmulator.h"
+
+namespace android {
+namespace hardware {
+namespace automotive {
+namespace vehicle {
+namespace V2_0 {
+
+namespace impl {
+
+/** Implementation of VehicleHal that connected to emulator instead of real vehicle network. */
+class EmulatedVehicleHal : public EmulatedVehicleHalIface {
+public:
+ EmulatedVehicleHal(VehiclePropertyStore* propStore);
+ ~EmulatedVehicleHal() = default;
+
+ // Methods from VehicleHal
+ void onCreate() override;
+ std::vector<VehiclePropConfig> listProperties() override;
+ VehiclePropValuePtr get(const VehiclePropValue& requestedPropValue,
+ StatusCode* outStatus) override;
+ StatusCode set(const VehiclePropValue& propValue) override;
+ StatusCode subscribe(int32_t property, int32_t areas, float sampleRate) override;
+ StatusCode unsubscribe(int32_t property) override;
+
+ // Methods from EmulatedVehicleHalIface
+ bool setPropertyFromVehicle(const VehiclePropValue& propValue) override;
+ std::vector<VehiclePropValue> getAllProperties() const override;
+
+private:
+ constexpr std::chrono::nanoseconds hertzToNanoseconds(float hz) const {
+ return std::chrono::nanoseconds(static_cast<int64_t>(1000000000L / hz));
+ }
+
+ void onContinuousPropertyTimer(const std::vector<int32_t>& properties);
+ bool isContinuousProperty(int32_t propId) const;
+
+private:
+ VehiclePropertyStore* mPropStore;
+ std::unordered_set<int32_t> mHvacPowerProps;
+ RecurrentTimer mRecurrentTimer;
+};
+
+} // impl
+
+} // namespace V2_0
+} // namespace vehicle
+} // namespace automotive
+} // namespace hardware
+} // namespace android
+
+
+#endif // android_hardware_automotive_vehicle_V2_0_impl_EmulatedVehicleHal_H_
diff --git a/automotive/vehicle/2.0/default/impl/vhal_v2_0/PipeComm.cpp b/automotive/vehicle/2.0/default/impl/vhal_v2_0/PipeComm.cpp
index 6f219fa..2b15aa3 100644
--- a/automotive/vehicle/2.0/default/impl/vhal_v2_0/PipeComm.cpp
+++ b/automotive/vehicle/2.0/default/impl/vhal_v2_0/PipeComm.cpp
@@ -18,6 +18,7 @@
#include <android/hardware/automotive/vehicle/2.0/IVehicle.h>
#include <android/log.h>
+#include <log/log.h>
#include <system/qemu_pipe.h>
#include "PipeComm.h"
diff --git a/automotive/vehicle/2.0/default/impl/vhal_v2_0/SocketComm.cpp b/automotive/vehicle/2.0/default/impl/vhal_v2_0/SocketComm.cpp
index a3ef4b1..42c1c78 100644
--- a/automotive/vehicle/2.0/default/impl/vhal_v2_0/SocketComm.cpp
+++ b/automotive/vehicle/2.0/default/impl/vhal_v2_0/SocketComm.cpp
@@ -18,6 +18,7 @@
#include <android/hardware/automotive/vehicle/2.0/IVehicle.h>
#include <android/log.h>
+#include <log/log.h>
#include <netinet/in.h>
#include <sys/socket.h>
diff --git a/automotive/vehicle/2.0/default/impl/vhal_v2_0/VehicleEmulator.cpp b/automotive/vehicle/2.0/default/impl/vhal_v2_0/VehicleEmulator.cpp
new file mode 100644
index 0000000..38cb743
--- /dev/null
+++ b/automotive/vehicle/2.0/default/impl/vhal_v2_0/VehicleEmulator.cpp
@@ -0,0 +1,360 @@
+/*
+ * Copyright (C) 2017 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.
+ */
+#define LOG_TAG "VehicleEmulator_v2_0"
+#include <android/log.h>
+
+#include <algorithm>
+#include <android-base/properties.h>
+#include <utils/SystemClock.h>
+
+#include <vhal_v2_0/VehicleUtils.h>
+
+#include "PipeComm.h"
+#include "SocketComm.h"
+
+#include "VehicleEmulator.h"
+
+namespace android {
+namespace hardware {
+namespace automotive {
+namespace vehicle {
+namespace V2_0 {
+
+namespace impl {
+
+std::unique_ptr<CommBase> CommFactory::create() {
+ bool isEmulator = android::base::GetBoolProperty("ro.kernel.qemu", false);
+
+ if (isEmulator) {
+ return std::make_unique<PipeComm>();
+ } else {
+ return std::make_unique<SocketComm>();
+ }
+}
+
+VehicleEmulator::~VehicleEmulator() {
+ mExit = true; // Notify thread to finish and wait for it to terminate.
+ mComm->stop(); // Close emulator socket if it is open.
+ if (mThread.joinable()) mThread.join();
+}
+
+void VehicleEmulator::doSetValueFromClient(const VehiclePropValue& propValue) {
+ emulator::EmulatorMessage msg;
+ emulator::VehiclePropValue *val = msg.add_value();
+ populateProtoVehiclePropValue(val, &propValue);
+ msg.set_status(emulator::RESULT_OK);
+ msg.set_msg_type(emulator::SET_PROPERTY_ASYNC);
+ txMsg(msg);
+}
+
+void VehicleEmulator::doGetConfig(VehicleEmulator::EmulatorMessage& rxMsg,
+ VehicleEmulator::EmulatorMessage& respMsg) {
+ std::vector<VehiclePropConfig> configs = mHal->listProperties();
+ emulator::VehiclePropGet getProp = rxMsg.prop(0);
+
+ respMsg.set_msg_type(emulator::GET_CONFIG_RESP);
+ respMsg.set_status(emulator::ERROR_INVALID_PROPERTY);
+
+ for (auto& config : configs) {
+ // Find the config we are looking for
+ if (config.prop == getProp.prop()) {
+ emulator::VehiclePropConfig* protoCfg = respMsg.add_config();
+ populateProtoVehicleConfig(protoCfg, config);
+ respMsg.set_status(emulator::RESULT_OK);
+ break;
+ }
+ }
+}
+
+void VehicleEmulator::doGetConfigAll(VehicleEmulator::EmulatorMessage& /* rxMsg */,
+ VehicleEmulator::EmulatorMessage& respMsg) {
+ std::vector<VehiclePropConfig> configs = mHal->listProperties();
+
+ respMsg.set_msg_type(emulator::GET_CONFIG_ALL_RESP);
+ respMsg.set_status(emulator::RESULT_OK);
+
+ for (auto& config : configs) {
+ emulator::VehiclePropConfig* protoCfg = respMsg.add_config();
+ populateProtoVehicleConfig(protoCfg, config);
+ }
+}
+
+void VehicleEmulator::doGetProperty(VehicleEmulator::EmulatorMessage& rxMsg,
+ VehicleEmulator::EmulatorMessage& respMsg) {
+ int32_t areaId = 0;
+ emulator::VehiclePropGet getProp = rxMsg.prop(0);
+ int32_t propId = getProp.prop();
+ emulator::Status status = emulator::ERROR_INVALID_PROPERTY;
+
+ respMsg.set_msg_type(emulator::GET_PROPERTY_RESP);
+
+ if (getProp.has_area_id()) {
+ areaId = getProp.area_id();
+ }
+
+ {
+ VehiclePropValue request = { .prop = propId, .areaId = areaId };
+ StatusCode halStatus;
+ auto val = mHal->get(request, &halStatus);
+ if (val != nullptr) {
+ emulator::VehiclePropValue* protoVal = respMsg.add_value();
+ populateProtoVehiclePropValue(protoVal, val.get());
+ status = emulator::RESULT_OK;
+ }
+ }
+
+ respMsg.set_status(status);
+}
+
+void VehicleEmulator::doGetPropertyAll(VehicleEmulator::EmulatorMessage& /* rxMsg */,
+ VehicleEmulator::EmulatorMessage& respMsg) {
+ respMsg.set_msg_type(emulator::GET_PROPERTY_ALL_RESP);
+ respMsg.set_status(emulator::RESULT_OK);
+
+ {
+ for (const auto& prop : mHal->getAllProperties()) {
+ emulator::VehiclePropValue* protoVal = respMsg.add_value();
+ populateProtoVehiclePropValue(protoVal, &prop);
+ }
+ }
+}
+
+void VehicleEmulator::doSetProperty(VehicleEmulator::EmulatorMessage& rxMsg,
+ VehicleEmulator::EmulatorMessage& respMsg) {
+ emulator::VehiclePropValue protoVal = rxMsg.value(0);
+ VehiclePropValue val = {
+ .prop = protoVal.prop(),
+ .areaId = protoVal.area_id(),
+ .timestamp = elapsedRealtimeNano(),
+ };
+
+ respMsg.set_msg_type(emulator::SET_PROPERTY_RESP);
+
+ // Copy value data if it is set. This automatically handles complex data types if needed.
+ if (protoVal.has_string_value()) {
+ val.value.stringValue = protoVal.string_value().c_str();
+ }
+
+ if (protoVal.has_bytes_value()) {
+ val.value.bytes = std::vector<uint8_t> { protoVal.bytes_value().begin(),
+ protoVal.bytes_value().end() };
+ }
+
+ if (protoVal.int32_values_size() > 0) {
+ val.value.int32Values = std::vector<int32_t> { protoVal.int32_values().begin(),
+ protoVal.int32_values().end() };
+ }
+
+ if (protoVal.int64_values_size() > 0) {
+ val.value.int64Values = std::vector<int64_t> { protoVal.int64_values().begin(),
+ protoVal.int64_values().end() };
+ }
+
+ if (protoVal.float_values_size() > 0) {
+ val.value.floatValues = std::vector<float> { protoVal.float_values().begin(),
+ protoVal.float_values().end() };
+ }
+
+ bool halRes = mHal->setPropertyFromVehicle(val);
+ respMsg.set_status(halRes ? emulator::RESULT_OK : emulator::ERROR_INVALID_PROPERTY);
+}
+
+void VehicleEmulator::txMsg(emulator::EmulatorMessage& txMsg) {
+ int numBytes = txMsg.ByteSize();
+ std::vector<uint8_t> msg(static_cast<size_t>(numBytes));
+
+ if (!txMsg.SerializeToArray(msg.data(), static_cast<int32_t>(msg.size()))) {
+ ALOGE("%s: SerializeToString failed!", __func__);
+ return;
+ }
+
+ if (mExit) {
+ ALOGW("%s: unable to transmit a message, connection closed", __func__);
+ return;
+ }
+
+ // Send the message
+ int retVal = mComm->write(msg);
+ if (retVal < 0) {
+ ALOGE("%s: Failed to tx message: retval=%d, errno=%d", __func__, retVal, errno);
+ }
+}
+
+void VehicleEmulator::parseRxProtoBuf(std::vector<uint8_t>& msg) {
+ emulator::EmulatorMessage rxMsg;
+ emulator::EmulatorMessage respMsg;
+
+ if (rxMsg.ParseFromArray(msg.data(), static_cast<int32_t>(msg.size()))) {
+ switch (rxMsg.msg_type()) {
+ case emulator::GET_CONFIG_CMD:
+ doGetConfig(rxMsg, respMsg);
+ break;
+ case emulator::GET_CONFIG_ALL_CMD:
+ doGetConfigAll(rxMsg, respMsg);
+ break;
+ case emulator::GET_PROPERTY_CMD:
+ doGetProperty(rxMsg, respMsg);
+ break;
+ case emulator::GET_PROPERTY_ALL_CMD:
+ doGetPropertyAll(rxMsg, respMsg);
+ break;
+ case emulator::SET_PROPERTY_CMD:
+ doSetProperty(rxMsg, respMsg);
+ break;
+ default:
+ ALOGW("%s: Unknown message received, type = %d", __func__, rxMsg.msg_type());
+ respMsg.set_status(emulator::ERROR_UNIMPLEMENTED_CMD);
+ break;
+ }
+
+ // Send the reply
+ txMsg(respMsg);
+ } else {
+ ALOGE("%s: ParseFromString() failed. msgSize=%d", __func__, static_cast<int>(msg.size()));
+ }
+}
+
+void VehicleEmulator::populateProtoVehicleConfig(emulator::VehiclePropConfig* protoCfg,
+ const VehiclePropConfig& cfg) {
+ protoCfg->set_prop(cfg.prop);
+ protoCfg->set_access(toInt(cfg.access));
+ protoCfg->set_change_mode(toInt(cfg.changeMode));
+ protoCfg->set_value_type(toInt(getPropType(cfg.prop)));
+
+ if (!isGlobalProp(cfg.prop)) {
+ protoCfg->set_supported_areas(cfg.supportedAreas);
+ }
+
+ for (auto& configElement : cfg.configArray) {
+ protoCfg->add_config_array(configElement);
+ }
+
+ if (cfg.configString.size() > 0) {
+ protoCfg->set_config_string(cfg.configString.c_str(), cfg.configString.size());
+ }
+
+ // Populate the min/max values based on property type
+ switch (getPropType(cfg.prop)) {
+ case VehiclePropertyType::STRING:
+ case VehiclePropertyType::BOOLEAN:
+ case VehiclePropertyType::INT32_VEC:
+ case VehiclePropertyType::FLOAT_VEC:
+ case VehiclePropertyType::BYTES:
+ case VehiclePropertyType::COMPLEX:
+ // Do nothing. These types don't have min/max values
+ break;
+ case VehiclePropertyType::INT64:
+ if (cfg.areaConfigs.size() > 0) {
+ emulator::VehicleAreaConfig* aCfg = protoCfg->add_area_configs();
+ aCfg->set_min_int64_value(cfg.areaConfigs[0].minInt64Value);
+ aCfg->set_max_int64_value(cfg.areaConfigs[0].maxInt64Value);
+ }
+ break;
+ case VehiclePropertyType::FLOAT:
+ if (cfg.areaConfigs.size() > 0) {
+ emulator::VehicleAreaConfig* aCfg = protoCfg->add_area_configs();
+ aCfg->set_min_float_value(cfg.areaConfigs[0].minFloatValue);
+ aCfg->set_max_float_value(cfg.areaConfigs[0].maxFloatValue);
+ }
+ break;
+ case VehiclePropertyType::INT32:
+ if (cfg.areaConfigs.size() > 0) {
+ emulator::VehicleAreaConfig* aCfg = protoCfg->add_area_configs();
+ aCfg->set_min_int32_value(cfg.areaConfigs[0].minInt32Value);
+ aCfg->set_max_int32_value(cfg.areaConfigs[0].maxInt32Value);
+ }
+ break;
+ default:
+ ALOGW("%s: Unknown property type: 0x%x", __func__, toInt(getPropType(cfg.prop)));
+ break;
+ }
+
+ protoCfg->set_min_sample_rate(cfg.minSampleRate);
+ protoCfg->set_max_sample_rate(cfg.maxSampleRate);
+}
+
+void VehicleEmulator::populateProtoVehiclePropValue(emulator::VehiclePropValue* protoVal,
+ const VehiclePropValue* val) {
+ protoVal->set_prop(val->prop);
+ protoVal->set_value_type(toInt(getPropType(val->prop)));
+ protoVal->set_timestamp(val->timestamp);
+ protoVal->set_area_id(val->areaId);
+
+ // Copy value data if it is set.
+ // - for bytes and strings, this is indicated by size > 0
+ // - for int32, int64, and float, copy the values if vectors have data
+ if (val->value.stringValue.size() > 0) {
+ protoVal->set_string_value(val->value.stringValue.c_str(), val->value.stringValue.size());
+ }
+
+ if (val->value.bytes.size() > 0) {
+ protoVal->set_bytes_value(val->value.bytes.data(), val->value.bytes.size());
+ }
+
+ for (auto& int32Value : val->value.int32Values) {
+ protoVal->add_int32_values(int32Value);
+ }
+
+ for (auto& int64Value : val->value.int64Values) {
+ protoVal->add_int64_values(int64Value);
+ }
+
+ for (auto& floatValue : val->value.floatValues) {
+ protoVal->add_float_values(floatValue);
+ }
+}
+
+void VehicleEmulator::rxMsg() {
+ while (!mExit) {
+ std::vector<uint8_t> msg = mComm->read();
+
+ if (msg.size() > 0) {
+ // Received a message.
+ parseRxProtoBuf(msg);
+ } else {
+ // This happens when connection is closed
+ ALOGD("%s: msgSize=%zu", __func__, msg.size());
+ break;
+ }
+ }
+}
+
+void VehicleEmulator::rxThread() {
+ if (mExit) return;
+
+ int retVal = mComm->open();
+ if (retVal != 0) mExit = true;
+
+ // Comms are properly opened
+ while (!mExit) {
+ retVal = mComm->connect();
+
+ if (retVal >= 0) {
+ rxMsg();
+ }
+
+ // Check every 100ms for a new connection
+ std::this_thread::sleep_for(std::chrono::milliseconds(100));
+ }
+}
+
+} // impl
+
+} // namespace V2_0
+} // namespace vehicle
+} // namespace automotive
+} // namespace hardware
+} // namespace android
diff --git a/automotive/vehicle/2.0/default/impl/vhal_v2_0/VehicleEmulator.h b/automotive/vehicle/2.0/default/impl/vhal_v2_0/VehicleEmulator.h
new file mode 100644
index 0000000..c8bcd60
--- /dev/null
+++ b/automotive/vehicle/2.0/default/impl/vhal_v2_0/VehicleEmulator.h
@@ -0,0 +1,117 @@
+/*
+ * Copyright (C) 2017 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.
+ */
+
+#ifndef android_hardware_automotive_vehicle_V2_0_impl_VehicleHalEmulator_H_
+#define android_hardware_automotive_vehicle_V2_0_impl_VehicleHalEmulator_H_
+
+#include <log/log.h>
+#include <memory>
+#include <thread>
+#include <vector>
+
+#include "vhal_v2_0/VehicleHal.h"
+
+#include "CommBase.h"
+#include "VehicleHalProto.pb.h"
+
+namespace android {
+namespace hardware {
+namespace automotive {
+namespace vehicle {
+namespace V2_0 {
+
+namespace impl {
+
+class VehicleEmulator; // Forward declaration.
+
+/** Extension of VehicleHal that used by VehicleEmulator. */
+class EmulatedVehicleHalIface : public VehicleHal {
+public:
+ virtual bool setPropertyFromVehicle(const VehiclePropValue& propValue) = 0;
+ virtual std::vector<VehiclePropValue> getAllProperties() const = 0;
+
+ void registerEmulator(VehicleEmulator* emulator) {
+ ALOGI("%s, emulator: %p", __func__, emulator);
+ std::lock_guard<std::mutex> g(mEmulatorLock);
+ mEmulator = emulator;
+ }
+
+protected:
+ VehicleEmulator* getEmulatorOrDie() {
+ std::lock_guard<std::mutex> g(mEmulatorLock);
+ ALOGI("%s, emulator: %p", __func__, mEmulator);
+ assert(mEmulator != nullptr);
+ return mEmulator;
+ }
+
+private:
+ mutable std::mutex mEmulatorLock;
+ VehicleEmulator* mEmulator;
+};
+
+struct CommFactory {
+ static std::unique_ptr<CommBase> create();
+};
+
+/**
+ * Emulates vehicle by providing controlling interface from host side either through ADB or Pipe.
+ */
+class VehicleEmulator {
+public:
+ VehicleEmulator(EmulatedVehicleHalIface* hal,
+ std::unique_ptr<CommBase> comm = CommFactory::create())
+ : mHal { hal },
+ mComm(comm.release()),
+ mThread { &VehicleEmulator::rxThread, this} {
+ mHal->registerEmulator(this);
+ }
+ virtual ~VehicleEmulator();
+
+ void doSetValueFromClient(const VehiclePropValue& propValue);
+
+private:
+ using EmulatorMessage = emulator::EmulatorMessage;
+
+ void doGetConfig(EmulatorMessage& rxMsg, EmulatorMessage& respMsg);
+ void doGetConfigAll(EmulatorMessage& rxMsg, EmulatorMessage& respMsg);
+ void doGetProperty(EmulatorMessage& rxMsg, EmulatorMessage& respMsg);
+ void doGetPropertyAll(EmulatorMessage& rxMsg, EmulatorMessage& respMsg);
+ void doSetProperty(EmulatorMessage& rxMsg, EmulatorMessage& respMsg);
+ void txMsg(emulator::EmulatorMessage& txMsg);
+ void parseRxProtoBuf(std::vector<uint8_t>& msg);
+ void populateProtoVehicleConfig(emulator::VehiclePropConfig* protoCfg,
+ const VehiclePropConfig& cfg);
+ void populateProtoVehiclePropValue(emulator::VehiclePropValue* protoVal,
+ const VehiclePropValue* val);
+ void rxMsg();
+ void rxThread();
+
+private:
+ std::atomic<bool> mExit { false };
+ EmulatedVehicleHalIface* mHal;
+ std::unique_ptr<CommBase> mComm;
+ std::thread mThread;
+};
+
+} // impl
+
+} // namespace V2_0
+} // namespace vehicle
+} // namespace automotive
+} // namespace hardware
+} // namespace android
+
+#endif // android_hardware_automotive_vehicle_V2_0_impl_VehicleHalEmulator_H_
diff --git a/automotive/vehicle/2.0/default/tests/AccessControlConfigParser_test.cpp b/automotive/vehicle/2.0/default/tests/AccessControlConfigParser_test.cpp
deleted file mode 100644
index d9611c0..0000000
--- a/automotive/vehicle/2.0/default/tests/AccessControlConfigParser_test.cpp
+++ /dev/null
@@ -1,152 +0,0 @@
-/*
- * Copyright (C) 2016 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.
- */
-
-#include <gtest/gtest.h>
-#include <memory>
-#include <fstream>
-#include <unordered_set>
-
-#include "vhal_v2_0/AccessControlConfigParser.h"
-#include "vhal_v2_0/VehicleUtils.h"
-
-namespace android {
-namespace hardware {
-namespace automotive {
-namespace vehicle {
-namespace V2_0 {
-
-namespace {
-
-class AccessControlConfigParserTest : public ::testing::Test {
-protected:
- void SetUp() override {
- std::vector<int32_t> supportedProperties {
- toInt(VehicleProperty::HVAC_FAN_SPEED),
- toInt(VehicleProperty::HVAC_FAN_DIRECTION),
- };
- parser.reset(new AccessControlConfigParser(supportedProperties));
- }
-public:
- PropertyAclMap aclMap;
- std::unique_ptr<AccessControlConfigParser> parser;
-};
-
-TEST_F(AccessControlConfigParserTest, basicParsing) {
- std::stringstream file;
- file << "S:0x0500 1000 RW" << std::endl;
-
- ASSERT_TRUE(parser->parseFromStream(&file, &aclMap));
-
- ASSERT_EQ(1u, aclMap.size());
- auto it = aclMap.find(toInt(VehicleProperty::HVAC_FAN_SPEED));
- ASSERT_NE(aclMap.end(), it);
- ASSERT_EQ(VehiclePropertyAccess::READ_WRITE, it->second.access);
- ASSERT_EQ(toInt(VehicleProperty::HVAC_FAN_SPEED), it->second.propId);
- ASSERT_EQ(1000u, it->second.uid);
-}
-
-TEST_F(AccessControlConfigParserTest, multipleUids) {
- std::stringstream file;
- file << "Set AID_AUDIO 1004" << std::endl
- << "Set AID_SYSTEM 1000" << std::endl
- << "S:0x0500 AID_SYSTEM RW" << std::endl
- << "S:0x0500 AID_AUDIO RW" << std::endl
- << "S:0x0500 0xbeef R" << std::endl; // Read-only.
-
- std::unordered_set<unsigned> expectedUids {1000, 1004, 0xbeef};
-
- ASSERT_TRUE(parser->parseFromStream(&file, &aclMap));
-
- auto range = aclMap.equal_range(toInt(VehicleProperty::HVAC_FAN_SPEED));
- for (auto it = range.first; it != range.second; ++it) {
- auto& acl = it->second;
-
- ASSERT_EQ(1u, expectedUids.count(acl.uid))
- << " uid: " << std::hex << acl.uid;
-
- if (acl.uid == 0xbeef) {
- ASSERT_EQ(VehiclePropertyAccess::READ, acl.access);
- } else {
- ASSERT_EQ(VehiclePropertyAccess::READ_WRITE, acl.access);
- }
- }
-}
-
-TEST_F(AccessControlConfigParserTest, fileContainsJunk) {
- std::stringstream file;
- file << "This string will be ignored with warning in the log" << std::endl
- << "# However comments are quit legitimate" << std::endl
- << "S:0x0500 0xbeef R # YAY" << std::endl;
-
- ASSERT_FALSE(parser->parseFromStream(&file, &aclMap));
-
- ASSERT_EQ(1u, aclMap.size());
- auto it = aclMap.find(toInt(VehicleProperty::HVAC_FAN_SPEED));
- ASSERT_NE(aclMap.end(), it);
- ASSERT_EQ(VehiclePropertyAccess::READ, it->second.access);
- ASSERT_EQ(toInt(VehicleProperty::HVAC_FAN_SPEED), it->second.propId);
- ASSERT_EQ(0xBEEFu, it->second.uid);
-}
-
-TEST_F(AccessControlConfigParserTest, badIntegerFormat) {
- std::stringstream file;
- file << "S:0x0500 A12 RW " << std::endl;
-
- ASSERT_FALSE(parser->parseFromStream(&file, &aclMap));
- ASSERT_EQ(0u, aclMap.size());
-}
-
-TEST_F(AccessControlConfigParserTest, ignoreNotSupportedProperties) {
- std::stringstream file;
- file << "S:0x0666 1000 RW " << std::endl;
-
- ASSERT_FALSE(parser->parseFromStream(&file, &aclMap));
- ASSERT_EQ(0u, aclMap.size());
-}
-
-TEST_F(AccessControlConfigParserTest, multipleCalls) {
- std::stringstream configFile;
- configFile << "S:0x0500 1000 RW" << std::endl;
-
- ASSERT_TRUE(parser->parseFromStream(&configFile, &aclMap));
- ASSERT_EQ(1u, aclMap.size());
-
- std::stringstream configFile2;
- configFile2 << "S:0x0501 1004 RW" << std::endl;
- ASSERT_TRUE(parser->parseFromStream(&configFile2, &aclMap));
- ASSERT_EQ(2u, aclMap.size());
-
- auto it = aclMap.find(toInt(VehicleProperty::HVAC_FAN_SPEED));
- ASSERT_NE(aclMap.end(), it);
- ASSERT_EQ(VehiclePropertyAccess::READ_WRITE, it->second.access);
- ASSERT_EQ(toInt(VehicleProperty::HVAC_FAN_SPEED), it->second.propId);
- ASSERT_EQ(1000u, it->second.uid);
-
- it = aclMap.find(toInt(VehicleProperty::HVAC_FAN_DIRECTION));
- ASSERT_NE(aclMap.end(), it);
- ASSERT_EQ(VehiclePropertyAccess::READ_WRITE, it->second.access);
- ASSERT_EQ(toInt(VehicleProperty::HVAC_FAN_DIRECTION), it->second.propId);
- ASSERT_EQ(1004u, it->second.uid);
-}
-
-
-} // namespace anonymous
-
-} // namespace V2_0
-} // namespace vehicle
-} // namespace automotive
-} // namespace hardware
-} // namespace android
diff --git a/automotive/vehicle/2.0/default/tests/VehicleHalManager_test.cpp b/automotive/vehicle/2.0/default/tests/VehicleHalManager_test.cpp
index b5cdf5c..04335b5 100644
--- a/automotive/vehicle/2.0/default/tests/VehicleHalManager_test.cpp
+++ b/automotive/vehicle/2.0/default/tests/VehicleHalManager_test.cpp
@@ -452,8 +452,8 @@
HalClientVector clients;
sp<IVehicleCallback> callback1 = new MockedVehicleCallback();
- sp<HalClient> c1 = new HalClient(callback1, 10, 20);
- sp<HalClient> c2 = new HalClient(callback1, 10, 20);
+ sp<HalClient> c1 = new HalClient(callback1);
+ sp<HalClient> c2 = new HalClient(callback1);
clients.addOrUpdate(c1);
clients.addOrUpdate(c1);
diff --git a/automotive/vehicle/2.1/default/Android.mk b/automotive/vehicle/2.1/default/Android.mk
index 3075956..32ec456 100644
--- a/automotive/vehicle/2.1/default/Android.mk
+++ b/automotive/vehicle/2.1/default/Android.mk
@@ -33,7 +33,6 @@
$(LOCAL_PATH)/common/include
LOCAL_SHARED_LIBRARIES := \
- libbinder \
libhidlbase \
libhidltransport \
libhwbinder \
@@ -50,7 +49,7 @@
LOCAL_MODULE:= $(vhal_v2_1)-default-impl-lib
LOCAL_SRC_FILES:= \
- impl/vhal_v2_1/DefaultVehicleHal.cpp \
+ impl/vhal_v2_1/EmulatedVehicleHal.cpp \
LOCAL_C_INCLUDES := \
$(LOCAL_PATH)/impl/vhal_v2_1 \
@@ -71,7 +70,6 @@
LOCAL_SHARED_LIBRARIES := \
libbase \
- libbinder \
libhidlbase \
libhidltransport \
libhwbinder \
@@ -107,7 +105,6 @@
LOCAL_SHARED_LIBRARIES := \
libbase \
- libbinder \
libhidlbase \
libhidltransport \
libhwbinder \
diff --git a/automotive/vehicle/2.1/default/common/include/vhal_v2_1/Obd2SensorStore.h b/automotive/vehicle/2.1/default/common/include/vhal_v2_1/Obd2SensorStore.h
index 945e3e0..6c44626 100644
--- a/automotive/vehicle/2.1/default/common/include/vhal_v2_1/Obd2SensorStore.h
+++ b/automotive/vehicle/2.1/default/common/include/vhal_v2_1/Obd2SensorStore.h
@@ -55,8 +55,7 @@
const std::vector<uint8_t>& getSensorsBitmask() const;
// Given a stringValue, fill in a VehiclePropValue
- void fillPropValue(V2_0::VehiclePropValue *propValue,
- std::string dtc) const;
+ void fillPropValue(const std::string& dtc, V2_0::VehiclePropValue *propValue) const;
private:
class BitmaskInVector {
diff --git a/automotive/vehicle/2.1/default/common/src/Obd2SensorStore.cpp b/automotive/vehicle/2.1/default/common/src/Obd2SensorStore.cpp
index b07717b..f4c63a9 100644
--- a/automotive/vehicle/2.1/default/common/src/Obd2SensorStore.cpp
+++ b/automotive/vehicle/2.1/default/common/src/Obd2SensorStore.cpp
@@ -99,8 +99,8 @@
return mSensorsBitmask.getBitmask();
}
-void Obd2SensorStore::fillPropValue(V2_0::VehiclePropValue *propValue,
- std::string dtc) const {
+void Obd2SensorStore::fillPropValue(const std::string& dtc,
+ V2_0::VehiclePropValue *propValue) const {
propValue->timestamp = elapsedRealtimeNano();
propValue->value.int32Values = getIntegerSensors();
propValue->value.floatValues = getFloatSensors();
diff --git a/automotive/vehicle/2.1/default/impl/vhal_v2_1/DefaultConfig.h b/automotive/vehicle/2.1/default/impl/vhal_v2_1/DefaultConfig.h
index 6bdec59..aa9aa3c 100644
--- a/automotive/vehicle/2.1/default/impl/vhal_v2_1/DefaultConfig.h
+++ b/automotive/vehicle/2.1/default/impl/vhal_v2_1/DefaultConfig.h
@@ -28,41 +28,50 @@
namespace impl {
+// Some handy constants to avoid conversions from enum to int.
+constexpr int OBD2_LIVE_FRAME = (int) V2_1::VehicleProperty::OBD2_LIVE_FRAME;
+constexpr int OBD2_FREEZE_FRAME = (int) V2_1::VehicleProperty::OBD2_FREEZE_FRAME;
+constexpr int OBD2_FREEZE_FRAME_INFO = (int) V2_1::VehicleProperty::OBD2_FREEZE_FRAME_INFO;
+constexpr int OBD2_FREEZE_FRAME_CLEAR = (int) V2_1::VehicleProperty::OBD2_FREEZE_FRAME_CLEAR;
+constexpr int VEHICLE_MAP_SERVICE = (int) V2_1::VehicleProperty::VEHICLE_MAP_SERVICE;
+constexpr int WHEEL_TICK = (int) V2_1::VehicleProperty::WHEEL_TICK;
+
+
const V2_0::VehiclePropConfig kVehicleProperties[] = {
{
- .prop = V2_0::toInt(V2_1::VehicleProperty::WHEEL_TICK),
+ .prop = WHEEL_TICK,
.access = V2_0::VehiclePropertyAccess::READ,
.changeMode = V2_0::VehiclePropertyChangeMode::CONTINUOUS,
},
{
- .prop = V2_0::toInt(V2_1::VehicleProperty::OBD2_LIVE_FRAME),
+ .prop = OBD2_LIVE_FRAME,
.access = V2_0::VehiclePropertyAccess::READ,
.changeMode = V2_0::VehiclePropertyChangeMode::ON_CHANGE,
.configArray = {0,0}
},
{
- .prop = V2_0::toInt(V2_1::VehicleProperty::OBD2_FREEZE_FRAME),
+ .prop = OBD2_FREEZE_FRAME,
.access = V2_0::VehiclePropertyAccess::READ,
.changeMode = V2_0::VehiclePropertyChangeMode::ON_CHANGE,
.configArray = {0,0}
},
{
- .prop = V2_0::toInt(V2_1::VehicleProperty::OBD2_FREEZE_FRAME_INFO),
+ .prop = OBD2_FREEZE_FRAME_INFO,
.access = V2_0::VehiclePropertyAccess::READ,
.changeMode = V2_0::VehiclePropertyChangeMode::ON_CHANGE
},
{
- .prop = V2_0::toInt(V2_1::VehicleProperty::OBD2_FREEZE_FRAME_CLEAR),
+ .prop = OBD2_FREEZE_FRAME_CLEAR,
.access = V2_0::VehiclePropertyAccess::WRITE,
.changeMode = V2_0::VehiclePropertyChangeMode::ON_CHANGE
},
{
- .prop = V2_0::toInt(VehicleProperty::VEHICLE_MAP_SERVICE),
+ .prop = VEHICLE_MAP_SERVICE,
.access = V2_0::VehiclePropertyAccess::READ_WRITE,
.changeMode = V2_0::VehiclePropertyChangeMode::ON_CHANGE
}
diff --git a/automotive/vehicle/2.1/default/impl/vhal_v2_1/DefaultVehicleHal.h b/automotive/vehicle/2.1/default/impl/vhal_v2_1/DefaultVehicleHal.h
deleted file mode 100644
index af21138..0000000
--- a/automotive/vehicle/2.1/default/impl/vhal_v2_1/DefaultVehicleHal.h
+++ /dev/null
@@ -1,96 +0,0 @@
-/*
- * Copyright (C) 2016 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.
- */
-
-#ifndef android_hardware_automotive_vehicle_V2_1_impl_DefaultVehicleHal_H_
-#define android_hardware_automotive_vehicle_V2_1_impl_DefaultVehicleHal_H_
-
-#include <memory>
-
-#include <utils/SystemClock.h>
-
-#include <vhal_v2_0/VehicleHal.h>
-#include <vhal_v2_0/DefaultVehicleHal.h>
-#include <vhal_v2_1/Obd2SensorStore.h>
-
-#include "DefaultConfig.h"
-
-namespace android {
-namespace hardware {
-namespace automotive {
-namespace vehicle {
-namespace V2_1 {
-
-namespace impl {
-
-using namespace std::placeholders;
-
-class DefaultVehicleHal : public V2_0::VehicleHal {
-public:
- DefaultVehicleHal(V2_0::impl::DefaultVehicleHal* vhal20) :
- mVehicleHal20(vhal20) {}
-
- std::vector<V2_0::VehiclePropConfig> listProperties() override {
- std::vector<V2_0::VehiclePropConfig> propConfigs(mVehicleHal20->listProperties());
-
- // Join Vehicle Hal 2.0 and 2.1 configs.
- propConfigs.insert(propConfigs.end(),
- std::begin(kVehicleProperties),
- std::end(kVehicleProperties));
-
- return propConfigs;
- }
-
- VehiclePropValuePtr get(const V2_0::VehiclePropValue& requestedPropValue,
- V2_0::StatusCode* outStatus) override;
-
- V2_0::StatusCode set(const V2_0::VehiclePropValue& propValue) override;
-
- V2_0::StatusCode subscribe(int32_t property,
- int32_t areas,
- float sampleRate) override {
- return mVehicleHal20->subscribe(property, areas, sampleRate);
- }
-
- V2_0::StatusCode unsubscribe(int32_t property) override {
- return mVehicleHal20->unsubscribe(property);
- }
-
- void onCreate() override;
-
-private:
- void initObd2LiveFrame(V2_0::VehiclePropConfig& propConfig,
- V2_0::VehiclePropValue* liveObd2Frame);
- void initObd2FreezeFrame(V2_0::VehiclePropConfig& propConfig);
- V2_0::StatusCode fillObd2FreezeFrame(const V2_0::VehiclePropValue& requestedPropValue,
- V2_0::VehiclePropValue* v);
- V2_0::StatusCode fillObd2DtcInfo(V2_0::VehiclePropValue *v);
- V2_0::StatusCode clearObd2FreezeFrames(const V2_0::VehiclePropValue& propValue);
-
-private:
- V2_0::impl::DefaultVehicleHal* mVehicleHal20;
- std::vector<std::unique_ptr<V2_0::VehiclePropValue>> mFreezeObd2Frames;
-};
-
-} // impl
-
-} // namespace V2_1
-} // namespace vehicle
-} // namespace automotive
-} // namespace hardware
-} // namespace android
-
-
-#endif // android_hardware_automotive_vehicle_V2_0_impl_DefaultVehicleHal_H_
diff --git a/automotive/vehicle/2.1/default/impl/vhal_v2_1/DefaultVehicleHal.cpp b/automotive/vehicle/2.1/default/impl/vhal_v2_1/EmulatedVehicleHal.cpp
similarity index 63%
rename from automotive/vehicle/2.1/default/impl/vhal_v2_1/DefaultVehicleHal.cpp
rename to automotive/vehicle/2.1/default/impl/vhal_v2_1/EmulatedVehicleHal.cpp
index b147ce7..4dceae0 100644
--- a/automotive/vehicle/2.1/default/impl/vhal_v2_1/DefaultVehicleHal.cpp
+++ b/automotive/vehicle/2.1/default/impl/vhal_v2_1/EmulatedVehicleHal.cpp
@@ -17,11 +17,12 @@
#define LOG_TAG "DefaultVehicleHal_v2_1"
#include <android/log.h>
-#include <algorithm>
+#include <log/log.h>
#include <netinet/in.h>
#include <sys/socket.h>
+#include <algorithm>
-#include "DefaultVehicleHal.h"
+#include "EmulatedVehicleHal.h"
#include "VehicleHalProto.pb.h"
#define DEBUG_SOCKET (33452)
@@ -120,118 +121,103 @@
return sensorStore;
}
-void DefaultVehicleHal::initObd2LiveFrame(V2_0::VehiclePropConfig& propConfig,
- V2_0::VehiclePropValue* liveObd2Frame) {
- auto sensorStore = fillDefaultObd2Frame(propConfig.configArray[0],
- propConfig.configArray[1]);
- sensorStore->fillPropValue(liveObd2Frame, "");
- liveObd2Frame->prop = V2_0::toInt(VehicleProperty::OBD2_LIVE_FRAME);
+void EmulatedVehicleHal::initObd2LiveFrame(const V2_0::VehiclePropConfig& propConfig) {
+ auto liveObd2Frame = createVehiclePropValue(V2_0::VehiclePropertyType::COMPLEX, 0);
+ auto sensorStore = fillDefaultObd2Frame(static_cast<size_t>(propConfig.configArray[0]),
+ static_cast<size_t>(propConfig.configArray[1]));
+ sensorStore->fillPropValue("", liveObd2Frame.get());
+ liveObd2Frame->prop = OBD2_LIVE_FRAME;
+
+ mPropStore->writeValue(*liveObd2Frame);
}
-void DefaultVehicleHal::initObd2FreezeFrame(V2_0::VehiclePropConfig& propConfig) {
- auto sensorStore = fillDefaultObd2Frame(propConfig.configArray[0],
- propConfig.configArray[1]);
+void EmulatedVehicleHal::initObd2FreezeFrame(const V2_0::VehiclePropConfig& propConfig) {
+ auto sensorStore = fillDefaultObd2Frame(static_cast<size_t>(propConfig.configArray[0]),
+ static_cast<size_t>(propConfig.configArray[1]));
- mFreezeObd2Frames.push_back(
- createVehiclePropValue(V2_0::VehiclePropertyType::COMPLEX,0));
- mFreezeObd2Frames.push_back(
- createVehiclePropValue(V2_0::VehiclePropertyType::COMPLEX,0));
- mFreezeObd2Frames.push_back(
- createVehiclePropValue(V2_0::VehiclePropertyType::COMPLEX,0));
-
- sensorStore->fillPropValue(mFreezeObd2Frames[0].get(), "P0070");
- sensorStore->fillPropValue(mFreezeObd2Frames[1].get(), "P0102");
- sensorStore->fillPropValue(mFreezeObd2Frames[2].get(), "P0123");
+ static std::vector<std::string> sampleDtcs = { "P0070", "P0102" "P0123" };
+ for (auto&& dtc : sampleDtcs) {
+ auto freezeFrame = createVehiclePropValue(V2_0::VehiclePropertyType::COMPLEX, 0);
+ sensorStore->fillPropValue(dtc, freezeFrame.get());
+ mPropStore->writeValue(*freezeFrame);
+ }
}
-template<typename Iterable>
-typename Iterable::const_iterator findPropValueAtTimestamp(
- const Iterable& frames,
- int64_t timestamp) {
- return std::find_if(frames.begin(),
- frames.end(),
- [timestamp] (const std::unique_ptr<V2_0::VehiclePropValue>&
- propValue) -> bool {
- return propValue->timestamp == timestamp;
- });
-}
-
-V2_0::StatusCode DefaultVehicleHal::fillObd2FreezeFrame(
+V2_0::StatusCode EmulatedVehicleHal::fillObd2FreezeFrame(
const V2_0::VehiclePropValue& requestedPropValue,
- V2_0::VehiclePropValue* v) {
+ V2_0::VehiclePropValue* outValue) {
if (requestedPropValue.value.int64Values.size() != 1) {
ALOGE("asked for OBD2_FREEZE_FRAME without valid timestamp");
return V2_0::StatusCode::INVALID_ARG;
}
auto timestamp = requestedPropValue.value.int64Values[0];
- auto freezeFrameIter = findPropValueAtTimestamp(mFreezeObd2Frames,
- timestamp);
- if(mFreezeObd2Frames.end() == freezeFrameIter) {
+ auto freezeFrame = mPropStore->readValueOrNull(OBD2_FREEZE_FRAME, 0, timestamp);
+ if(freezeFrame == nullptr) {
ALOGE("asked for OBD2_FREEZE_FRAME at invalid timestamp");
return V2_0::StatusCode::INVALID_ARG;
}
- const auto& freezeFrame = *freezeFrameIter;
- v->prop = V2_0::toInt(VehicleProperty::OBD2_FREEZE_FRAME);
- v->value.int32Values = freezeFrame->value.int32Values;
- v->value.floatValues = freezeFrame->value.floatValues;
- v->value.bytes = freezeFrame->value.bytes;
- v->value.stringValue = freezeFrame->value.stringValue;
- v->timestamp = freezeFrame->timestamp;
+ outValue->prop = OBD2_FREEZE_FRAME;
+ outValue->value.int32Values = freezeFrame->value.int32Values;
+ outValue->value.floatValues = freezeFrame->value.floatValues;
+ outValue->value.bytes = freezeFrame->value.bytes;
+ outValue->value.stringValue = freezeFrame->value.stringValue;
+ outValue->timestamp = freezeFrame->timestamp;
return V2_0::StatusCode::OK;
}
-V2_0::StatusCode DefaultVehicleHal::clearObd2FreezeFrames(
- const V2_0::VehiclePropValue& propValue) {
+V2_0::StatusCode EmulatedVehicleHal::clearObd2FreezeFrames(const V2_0::VehiclePropValue& propValue) {
if (propValue.value.int64Values.size() == 0) {
- mFreezeObd2Frames.clear();
+ mPropStore->removeValuesForProperty(OBD2_FREEZE_FRAME);
return V2_0::StatusCode::OK;
} else {
for(int64_t timestamp: propValue.value.int64Values) {
- auto freezeFrameIter = findPropValueAtTimestamp(mFreezeObd2Frames,
- timestamp);
- if(mFreezeObd2Frames.end() == freezeFrameIter) {
+ auto freezeFrame = mPropStore->readValueOrNull(OBD2_FREEZE_FRAME, 0, timestamp);
+ if(freezeFrame == nullptr) {
ALOGE("asked for OBD2_FREEZE_FRAME at invalid timestamp");
return V2_0::StatusCode::INVALID_ARG;
}
- mFreezeObd2Frames.erase(freezeFrameIter);
+ mPropStore->removeValue(*freezeFrame);
}
}
return V2_0::StatusCode::OK;
}
-V2_0::StatusCode DefaultVehicleHal::fillObd2DtcInfo(V2_0::VehiclePropValue* v) {
+V2_0::StatusCode EmulatedVehicleHal::fillObd2DtcInfo(V2_0::VehiclePropValue* outValue) {
std::vector<int64_t> timestamps;
- for(const auto& freezeFrame: mFreezeObd2Frames) {
- timestamps.push_back(freezeFrame->timestamp);
+ for(const auto& freezeFrame: mPropStore->readValuesForProperty(OBD2_FREEZE_FRAME)) {
+ timestamps.push_back(freezeFrame.timestamp);
}
- v->value.int64Values = timestamps;
+ outValue->value.int64Values = timestamps;
return V2_0::StatusCode::OK;
}
-void DefaultVehicleHal::onCreate() {
- mVehicleHal20->init(getValuePool(),
- std::bind(&DefaultVehicleHal::doHalEvent, this, _1),
- std::bind(&DefaultVehicleHal::doHalPropertySetError, this, _1, _2, _3));
+void EmulatedVehicleHal::onCreate() {
+ V2_0::impl::EmulatedVehicleHal::onCreate();
- std::vector<V2_0::VehiclePropConfig> configs = listProperties();
- for (auto& cfg : configs) {
- switch(cfg.prop) {
- case V2_0::toInt(V2_1::VehicleProperty::OBD2_LIVE_FRAME): {
- auto liveObd2Frame = createVehiclePropValue(V2_0::VehiclePropertyType::COMPLEX, 0);
- initObd2LiveFrame(cfg, liveObd2Frame.get());
- mVehicleHal20->addCustomProperty(*liveObd2Frame);
+ initObd2LiveFrame(*mPropStore->getConfigOrDie(OBD2_LIVE_FRAME));
+ initObd2FreezeFrame(*mPropStore->getConfigOrDie(OBD2_FREEZE_FRAME));
+}
+
+void EmulatedVehicleHal::initStaticConfig() {
+ for (auto&& cfg = std::begin(kVehicleProperties); cfg != std::end(kVehicleProperties); ++cfg) {
+ V2_0::VehiclePropertyStore::TokenFunction tokenFunction = nullptr;
+
+ switch (cfg->prop) {
+ case OBD2_FREEZE_FRAME: {
+ tokenFunction = [] (const V2_0::VehiclePropValue& propValue) {
+ return propValue.timestamp;
+ };
+ break;
}
- break;
- case V2_0::toInt(V2_1::VehicleProperty::OBD2_FREEZE_FRAME):
- initObd2FreezeFrame(cfg);
- break;
default:
break;
}
+
+ mPropStore->registerProperty(*cfg, tokenFunction);
}
}
-DefaultVehicleHal::VehiclePropValuePtr DefaultVehicleHal::get(
+EmulatedVehicleHal::VehiclePropValuePtr EmulatedVehicleHal::get(
const V2_0::VehiclePropValue& requestedPropValue,
V2_0::StatusCode* outStatus) {
@@ -240,34 +226,30 @@
auto& pool = *getValuePool();
switch (propId) {
- case V2_0::toInt(V2_1::VehicleProperty::OBD2_FREEZE_FRAME):
+ case OBD2_FREEZE_FRAME:
v = pool.obtainComplex();
*outStatus = fillObd2FreezeFrame(requestedPropValue, v.get());
return v;
- case V2_0::toInt(V2_1::VehicleProperty::OBD2_FREEZE_FRAME_INFO):
+ case OBD2_FREEZE_FRAME_INFO:
v = pool.obtainComplex();
*outStatus = fillObd2DtcInfo(v.get());
return v;
default:
- return mVehicleHal20->get(requestedPropValue, outStatus);
+ return V2_0::impl::EmulatedVehicleHal::get(requestedPropValue, outStatus);
}
}
-V2_0::StatusCode DefaultVehicleHal::set(
- const V2_0::VehiclePropValue& propValue) {
-
+V2_0::StatusCode EmulatedVehicleHal::set(const V2_0::VehiclePropValue& propValue) {
auto propId = propValue.prop;
switch (propId) {
- case V2_0::toInt(V2_1::VehicleProperty::OBD2_FREEZE_FRAME_CLEAR):
+ case OBD2_FREEZE_FRAME_CLEAR:
return clearObd2FreezeFrames(propValue);
- break;
- case V2_0::toInt(V2_1::VehicleProperty::VEHICLE_MAP_SERVICE):
+ case VEHICLE_MAP_SERVICE:
// Placeholder for future implementation of VMS property in the default hal. For now, just
// returns OK; otherwise, hal clients crash with property not supported.
return V2_0::StatusCode::OK;
- break;
default:
- return mVehicleHal20->set(propValue);
+ return V2_0::impl::EmulatedVehicleHal::set(propValue);
}
}
diff --git a/automotive/vehicle/2.1/default/impl/vhal_v2_1/EmulatedVehicleHal.h b/automotive/vehicle/2.1/default/impl/vhal_v2_1/EmulatedVehicleHal.h
new file mode 100644
index 0000000..7cc3b79
--- /dev/null
+++ b/automotive/vehicle/2.1/default/impl/vhal_v2_1/EmulatedVehicleHal.h
@@ -0,0 +1,77 @@
+/*
+ * Copyright (C) 2016 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.
+ */
+
+#ifndef android_hardware_automotive_vehicle_V2_1_impl_EmulatedVehicleHal_H_
+#define android_hardware_automotive_vehicle_V2_1_impl_EmulatedVehicleHal_H_
+
+#include <memory>
+
+#include <utils/SystemClock.h>
+
+#include <vhal_v2_0/EmulatedVehicleHal.h>
+#include <vhal_v2_0/VehicleHal.h>
+#include <vhal_v2_0/VehiclePropertyStore.h>
+#include <vhal_v2_1/Obd2SensorStore.h>
+
+#include "DefaultConfig.h"
+
+namespace android {
+namespace hardware {
+namespace automotive {
+namespace vehicle {
+namespace V2_1 {
+
+namespace impl {
+
+using namespace std::placeholders;
+
+class EmulatedVehicleHal : public V2_0::impl::EmulatedVehicleHal {
+public:
+ EmulatedVehicleHal(V2_0::VehiclePropertyStore* propStore)
+ : V2_0::impl::EmulatedVehicleHal(propStore), mPropStore(propStore) {
+ initStaticConfig();
+ }
+
+ VehiclePropValuePtr get(const V2_0::VehiclePropValue& requestedPropValue,
+ V2_0::StatusCode* outStatus) override;
+
+ V2_0::StatusCode set(const V2_0::VehiclePropValue& propValue) override;
+
+ void onCreate() override;
+
+private:
+ void initStaticConfig();
+ void initObd2LiveFrame(const V2_0::VehiclePropConfig& propConfig);
+ void initObd2FreezeFrame(const V2_0::VehiclePropConfig& propConfig);
+ V2_0::StatusCode fillObd2FreezeFrame(const V2_0::VehiclePropValue& requestedPropValue,
+ V2_0::VehiclePropValue* outValue);
+ V2_0::StatusCode fillObd2DtcInfo(V2_0::VehiclePropValue *outValue);
+ V2_0::StatusCode clearObd2FreezeFrames(const V2_0::VehiclePropValue& propValue);
+
+private:
+ V2_0::VehiclePropertyStore* mPropStore;
+};
+
+} // impl
+
+} // namespace V2_1
+} // namespace vehicle
+} // namespace automotive
+} // namespace hardware
+} // namespace android
+
+
+#endif // android_hardware_automotive_vehicle_V2_0_impl_EmulatedVehicleHal_H_
diff --git a/automotive/vehicle/2.1/default/service.cpp b/automotive/vehicle/2.1/default/service.cpp
index 0844622..4873279 100644
--- a/automotive/vehicle/2.1/default/service.cpp
+++ b/automotive/vehicle/2.1/default/service.cpp
@@ -23,9 +23,10 @@
#include <android/hardware/automotive/vehicle/2.1/IVehicle.h>
#include <vhal_v2_0/VehicleHalManager.h>
-#include <vhal_v2_0/DefaultVehicleHal.h>
+#include <vhal_v2_0/VehiclePropertyStore.h>
+#include <vhal_v2_0/EmulatedVehicleHal.h>
-#include <vhal_v2_1/DefaultVehicleHal.h>
+#include <vhal_v2_1/EmulatedVehicleHal.h>
using namespace android;
using namespace android::hardware;
@@ -80,10 +81,10 @@
};
int main(int /* argc */, char* /* argv */ []) {
- auto halImpl20 = std::make_unique<V2_0::impl::DefaultVehicleHal>();
- auto halImpl21 = std::make_unique<V2_1::impl::DefaultVehicleHal>(halImpl20.get());
-
- auto vehicleManager = std::make_unique<V2_0::VehicleHalManager>(halImpl21.get());
+ auto store = std::make_unique<V2_0::VehiclePropertyStore>();
+ auto hal = std::make_unique<V2_1::impl::EmulatedVehicleHal>(store.get());
+ auto emulator = std::make_unique<V2_0::impl::VehicleEmulator>(hal.get());
+ auto vehicleManager = std::make_unique<V2_0::VehicleHalManager>(hal.get());
Vehicle_V2_1 vehicle21(vehicleManager.get());
diff --git a/bluetooth/1.0/default/android.hardware.bluetooth@1.0-service.rc b/bluetooth/1.0/default/android.hardware.bluetooth@1.0-service.rc
index 8545d2f..0f76c39 100644
--- a/bluetooth/1.0/default/android.hardware.bluetooth@1.0-service.rc
+++ b/bluetooth/1.0/default/android.hardware.bluetooth@1.0-service.rc
@@ -2,3 +2,4 @@
class hal
user bluetooth
group bluetooth
+ writepid /dev/stune/foreground/tasks
diff --git a/bluetooth/1.0/vts/functional/VtsHalBluetoothV1_0TargetTest.cpp b/bluetooth/1.0/vts/functional/VtsHalBluetoothV1_0TargetTest.cpp
index 9a4efae..d699f21 100644
--- a/bluetooth/1.0/vts/functional/VtsHalBluetoothV1_0TargetTest.cpp
+++ b/bluetooth/1.0/vts/functional/VtsHalBluetoothV1_0TargetTest.cpp
@@ -23,9 +23,8 @@
#include <hardware/bluetooth.h>
#include <utils/Log.h>
+#include <VtsHalHidlTargetCallbackBase.h>
#include <VtsHalHidlTargetTestBase.h>
-#include <condition_variable>
-#include <mutex>
#include <queue>
using ::android::hardware::bluetooth::V1_0::IBluetoothHci;
@@ -92,6 +91,11 @@
#define ACL_BROADCAST_ACTIVE_SLAVE (0x1 << 4)
#define ACL_PACKET_BOUNDARY_COMPLETE (0x3 << 6)
+constexpr char kCallbackNameAclEventReceived[] = "aclDataReceived";
+constexpr char kCallbackNameHciEventReceived[] = "hciEventReceived";
+constexpr char kCallbackNameInitializationComplete[] = "initializationComplete";
+constexpr char kCallbackNameScoEventReceived[] = "scoDataReceived";
+
class ThroughputLogger {
public:
ThroughputLogger(std::string task)
@@ -121,7 +125,8 @@
public:
virtual void SetUp() override {
// currently test passthrough mode only
- bluetooth = ::testing::VtsHalHidlTargetTestBase::getService<IBluetoothHci>();
+ bluetooth =
+ ::testing::VtsHalHidlTargetTestBase::getService<IBluetoothHci>();
ASSERT_NE(bluetooth, nullptr);
ALOGI("%s: getService() for bluetooth is %s", __func__,
bluetooth->isRemote() ? "remote" : "local");
@@ -135,10 +140,6 @@
max_sco_data_packets = 0;
initialized = false;
- initialized_count = 0;
- event_count = 0;
- acl_count = 0;
- sco_count = 0;
event_cb_count = 0;
acl_cb_count = 0;
sco_cb_count = 0;
@@ -146,7 +147,18 @@
ASSERT_EQ(initialized, false);
bluetooth->initialize(bluetooth_cb);
- wait_for_init_callback();
+ bluetooth_cb->SetWaitTimeout(kCallbackNameInitializationComplete,
+ WAIT_FOR_INIT_TIMEOUT);
+ bluetooth_cb->SetWaitTimeout(kCallbackNameHciEventReceived,
+ WAIT_FOR_HCI_EVENT_TIMEOUT);
+ bluetooth_cb->SetWaitTimeout(kCallbackNameAclEventReceived,
+ WAIT_FOR_ACL_DATA_TIMEOUT);
+ bluetooth_cb->SetWaitTimeout(kCallbackNameScoEventReceived,
+ WAIT_FOR_SCO_DATA_TIMEOUT);
+
+ EXPECT_TRUE(
+ bluetooth_cb->WaitForCallback(kCallbackNameInitializationComplete)
+ .no_timeout);
ASSERT_EQ(initialized, true);
}
@@ -171,82 +183,10 @@
void wait_for_command_complete_event(hidl_vec<uint8_t> cmd);
int wait_for_completed_packets_event(uint16_t handle);
- // Inform the test about the initialization callback
- inline void notify_initialized() {
- std::unique_lock<std::mutex> lock(initialized_mutex);
- initialized_count++;
- initialized_condition.notify_one();
- }
-
- // Test code calls this function to wait for the init callback
- inline void wait_for_init_callback() {
- std::unique_lock<std::mutex> lock(initialized_mutex);
-
- auto start_time = std::chrono::steady_clock::now();
- while (initialized_count == 0)
- if (initialized_condition.wait_until(lock,
- start_time + WAIT_FOR_INIT_TIMEOUT) ==
- std::cv_status::timeout)
- return;
- initialized_count--;
- }
-
- // Inform the test about an event callback
- inline void notify_event_received() {
- std::unique_lock<std::mutex> lock(event_mutex);
- event_count++;
- event_condition.notify_one();
- }
-
- // Test code calls this function to wait for an event callback
- inline void wait_for_event() {
- std::unique_lock<std::mutex> lock(event_mutex);
-
- auto start_time = std::chrono::steady_clock::now();
- while (event_count == 0)
- if (event_condition.wait_until(lock,
- start_time + WAIT_FOR_HCI_EVENT_TIMEOUT) ==
- std::cv_status::timeout)
- return;
- event_count--;
- }
-
- // Inform the test about an acl data callback
- inline void notify_acl_data_received() {
- std::unique_lock<std::mutex> lock(acl_mutex);
- acl_count++;
- acl_condition.notify_one();
- }
-
- // Test code calls this function to wait for an acl data callback
- inline void wait_for_acl() {
- std::unique_lock<std::mutex> lock(acl_mutex);
-
- while (acl_count == 0)
- acl_condition.wait_until(
- lock, std::chrono::steady_clock::now() + WAIT_FOR_ACL_DATA_TIMEOUT);
- acl_count--;
- }
-
- // Inform the test about a sco data callback
- inline void notify_sco_data_received() {
- std::unique_lock<std::mutex> lock(sco_mutex);
- sco_count++;
- sco_condition.notify_one();
- }
-
- // Test code calls this function to wait for a sco data callback
- inline void wait_for_sco() {
- std::unique_lock<std::mutex> lock(sco_mutex);
-
- while (sco_count == 0)
- sco_condition.wait_until(
- lock, std::chrono::steady_clock::now() + WAIT_FOR_SCO_DATA_TIMEOUT);
- sco_count--;
- }
-
// A simple test implementation of BluetoothHciCallbacks.
- class BluetoothHciCallbacks : public IBluetoothHciCallbacks {
+ class BluetoothHciCallbacks
+ : public ::testing::VtsHalHidlTargetCallbackBase<BluetoothHidlTest>,
+ public IBluetoothHciCallbacks {
BluetoothHidlTest& parent_;
public:
@@ -256,7 +196,7 @@
Return<void> initializationComplete(Status status) override {
parent_.initialized = (status == Status::SUCCESS);
- parent_.notify_initialized();
+ NotifyFromCallback(kCallbackNameInitializationComplete);
ALOGV("%s (status = %d)", __func__, static_cast<int>(status));
return Void();
};
@@ -265,7 +205,7 @@
const ::android::hardware::hidl_vec<uint8_t>& event) override {
parent_.event_cb_count++;
parent_.event_queue.push(event);
- parent_.notify_event_received();
+ NotifyFromCallback(kCallbackNameHciEventReceived);
ALOGV("Event received (length = %d)", static_cast<int>(event.size()));
return Void();
};
@@ -274,7 +214,7 @@
const ::android::hardware::hidl_vec<uint8_t>& data) override {
parent_.acl_cb_count++;
parent_.acl_queue.push(data);
- parent_.notify_acl_data_received();
+ NotifyFromCallback(kCallbackNameAclEventReceived);
return Void();
};
@@ -282,13 +222,13 @@
const ::android::hardware::hidl_vec<uint8_t>& data) override {
parent_.sco_cb_count++;
parent_.sco_queue.push(data);
- parent_.notify_sco_data_received();
+ NotifyFromCallback(kCallbackNameScoEventReceived);
return Void();
};
};
sp<IBluetoothHci> bluetooth;
- sp<IBluetoothHciCallbacks> bluetooth_cb;
+ sp<BluetoothHciCallbacks> bluetooth_cb;
std::queue<hidl_vec<uint8_t>> event_queue;
std::queue<hidl_vec<uint8_t>> acl_queue;
std::queue<hidl_vec<uint8_t>> sco_queue;
@@ -303,20 +243,6 @@
int max_sco_data_packet_length;
int max_acl_data_packets;
int max_sco_data_packets;
-
- private:
- std::mutex initialized_mutex;
- std::mutex event_mutex;
- std::mutex sco_mutex;
- std::mutex acl_mutex;
- std::condition_variable initialized_condition;
- std::condition_variable event_condition;
- std::condition_variable sco_condition;
- std::condition_variable acl_condition;
- int initialized_count;
- int event_count;
- int sco_count;
- int acl_count;
};
// A class for test environment setup (kept since this file is a template).
@@ -334,11 +260,12 @@
int status_event_count = 0;
hidl_vec<uint8_t> event;
do {
- wait_for_event();
- EXPECT_LT(static_cast<size_t>(0), event_queue.size());
- if (event_queue.size() == 0) {
- event.resize(0);
- break;
+ EXPECT_TRUE(bluetooth_cb->WaitForCallback(kCallbackNameHciEventReceived)
+ .no_timeout);
+ EXPECT_LT(static_cast<size_t>(0), event_queue.size());
+ if (event_queue.size() == 0) {
+ event.resize(0);
+ break;
}
event = event_queue.front();
event_queue.pop();
@@ -366,7 +293,8 @@
hidl_vec<uint8_t> cmd = COMMAND_HCI_READ_BUFFER_SIZE;
bluetooth->sendHciCommand(cmd);
- wait_for_event();
+ EXPECT_TRUE(
+ bluetooth_cb->WaitForCallback(kCallbackNameHciEventReceived).no_timeout);
EXPECT_LT(static_cast<size_t>(0), event_queue.size());
if (event_queue.size() == 0) return;
@@ -420,7 +348,8 @@
bluetooth->sendHciCommand(cmd);
// Check the loopback of the HCI packet
- wait_for_event();
+ EXPECT_TRUE(bluetooth_cb->WaitForCallback(kCallbackNameHciEventReceived)
+ .no_timeout);
hidl_vec<uint8_t> event = event_queue.front();
event_queue.pop();
size_t compare_length =
@@ -456,7 +385,8 @@
bluetooth->sendScoData(sco_vector);
// Check the loopback of the SCO packet
- wait_for_sco();
+ EXPECT_TRUE(bluetooth_cb->WaitForCallback(kCallbackNameScoEventReceived)
+ .no_timeout);
hidl_vec<uint8_t> sco_loopback = sco_queue.front();
sco_queue.pop();
@@ -501,7 +431,8 @@
bluetooth->sendAclData(acl_vector);
// Check the loopback of the ACL packet
- wait_for_acl();
+ EXPECT_TRUE(bluetooth_cb->WaitForCallback(kCallbackNameAclEventReceived)
+ .no_timeout);
hidl_vec<uint8_t> acl_loopback = acl_queue.front();
acl_queue.pop();
@@ -527,19 +458,20 @@
// Return the number of completed packets reported by the controller.
int BluetoothHidlTest::wait_for_completed_packets_event(uint16_t handle) {
- wait_for_event();
- int packets_processed = 0;
- while (event_queue.size() > 0) {
- hidl_vec<uint8_t> event = event_queue.front();
- event_queue.pop();
+ EXPECT_TRUE(bluetooth_cb->WaitForCallback(kCallbackNameHciEventReceived)
+ .no_timeout);
+ int packets_processed = 0;
+ while (event_queue.size() > 0) {
+ hidl_vec<uint8_t> event = event_queue.front();
+ event_queue.pop();
- EXPECT_EQ(EVENT_NUMBER_OF_COMPLETED_PACKETS, event[EVENT_CODE_BYTE]);
- EXPECT_EQ(1, event[EVENT_NUMBER_OF_COMPLETED_PACKETS_NUM_HANDLES]);
+ EXPECT_EQ(EVENT_NUMBER_OF_COMPLETED_PACKETS, event[EVENT_CODE_BYTE]);
+ EXPECT_EQ(1, event[EVENT_NUMBER_OF_COMPLETED_PACKETS_NUM_HANDLES]);
- uint16_t event_handle = event[3] + (event[4] << 8);
- EXPECT_EQ(handle, event_handle);
+ uint16_t event_handle = event[3] + (event[4] << 8);
+ EXPECT_EQ(handle, event_handle);
- packets_processed += event[5] + (event[6] << 8);
+ packets_processed += event[5] + (event[6] << 8);
}
return packets_processed;
}
@@ -554,32 +486,34 @@
int connection_event_count = 0;
hidl_vec<uint8_t> event;
do {
- wait_for_event();
- event = event_queue.front();
- event_queue.pop();
- EXPECT_GT(event.size(),
- static_cast<size_t>(EVENT_COMMAND_COMPLETE_STATUS_BYTE));
- if (event[EVENT_CODE_BYTE] == EVENT_CONNECTION_COMPLETE) {
+ EXPECT_TRUE(bluetooth_cb->WaitForCallback(kCallbackNameHciEventReceived)
+ .no_timeout);
+ event = event_queue.front();
+ event_queue.pop();
EXPECT_GT(event.size(),
- static_cast<size_t>(EVENT_CONNECTION_COMPLETE_TYPE));
- EXPECT_EQ(event[EVENT_LENGTH_BYTE],
- EVENT_CONNECTION_COMPLETE_PARAM_LENGTH);
- uint8_t connection_type = event[EVENT_CONNECTION_COMPLETE_TYPE];
+ static_cast<size_t>(EVENT_COMMAND_COMPLETE_STATUS_BYTE));
+ if (event[EVENT_CODE_BYTE] == EVENT_CONNECTION_COMPLETE) {
+ EXPECT_GT(event.size(),
+ static_cast<size_t>(EVENT_CONNECTION_COMPLETE_TYPE));
+ EXPECT_EQ(event[EVENT_LENGTH_BYTE],
+ EVENT_CONNECTION_COMPLETE_PARAM_LENGTH);
+ uint8_t connection_type = event[EVENT_CONNECTION_COMPLETE_TYPE];
- EXPECT_TRUE(connection_type == EVENT_CONNECTION_COMPLETE_TYPE_SCO ||
- connection_type == EVENT_CONNECTION_COMPLETE_TYPE_ACL);
+ EXPECT_TRUE(connection_type == EVENT_CONNECTION_COMPLETE_TYPE_SCO ||
+ connection_type == EVENT_CONNECTION_COMPLETE_TYPE_ACL);
- // Save handles
- uint16_t handle = event[EVENT_CONNECTION_COMPLETE_HANDLE_LSBYTE] |
- event[EVENT_CONNECTION_COMPLETE_HANDLE_LSBYTE + 1] << 8;
- if (connection_type == EVENT_CONNECTION_COMPLETE_TYPE_SCO)
- sco_handles.push_back(handle);
- else
- acl_handles.push_back(handle);
+ // Save handles
+ uint16_t handle = event[EVENT_CONNECTION_COMPLETE_HANDLE_LSBYTE] |
+ event[EVENT_CONNECTION_COMPLETE_HANDLE_LSBYTE + 1]
+ << 8;
+ if (connection_type == EVENT_CONNECTION_COMPLETE_TYPE_SCO)
+ sco_handles.push_back(handle);
+ else
+ acl_handles.push_back(handle);
- ALOGD("Connect complete type = %d handle = %d",
- event[EVENT_CONNECTION_COMPLETE_TYPE], handle);
- connection_event_count++;
+ ALOGD("Connect complete type = %d handle = %d",
+ event[EVENT_CONNECTION_COMPLETE_TYPE], handle);
+ connection_event_count++;
}
} while (event[EVENT_CODE_BYTE] == EVENT_CONNECTION_COMPLETE);
@@ -592,7 +526,7 @@
}
// Empty test: Initialize()/Close() are called in SetUp()/TearDown().
-TEST_F(BluetoothHidlTest, InitializeAndClose) { }
+TEST_F(BluetoothHidlTest, InitializeAndClose) {}
// Send an HCI Reset with sendHciCommand and wait for a command complete event.
TEST_F(BluetoothHidlTest, HciReset) {
@@ -607,7 +541,8 @@
hidl_vec<uint8_t> cmd = COMMAND_HCI_READ_LOCAL_VERSION_INFORMATION;
bluetooth->sendHciCommand(cmd);
- wait_for_event();
+ EXPECT_TRUE(
+ bluetooth_cb->WaitForCallback(kCallbackNameHciEventReceived).no_timeout);
hidl_vec<uint8_t> event = event_queue.front();
event_queue.pop();
@@ -627,7 +562,8 @@
hidl_vec<uint8_t> cmd = COMMAND_HCI_SHOULD_BE_UNKNOWN;
bluetooth->sendHciCommand(cmd);
- wait_for_event();
+ EXPECT_TRUE(
+ bluetooth_cb->WaitForCallback(kCallbackNameHciEventReceived).no_timeout);
hidl_vec<uint8_t> event = event_queue.front();
event_queue.pop();
diff --git a/boot/1.0/vts/functional/VtsHalBootV1_0TargetTest.cpp b/boot/1.0/vts/functional/VtsHalBootV1_0TargetTest.cpp
index 9789ee6..f48a95d 100644
--- a/boot/1.0/vts/functional/VtsHalBootV1_0TargetTest.cpp
+++ b/boot/1.0/vts/functional/VtsHalBootV1_0TargetTest.cpp
@@ -30,6 +30,8 @@
using ::android::hardware::hidl_string;
using ::android::hardware::Return;
using ::android::sp;
+using std::string;
+using std::vector;
// The main test class for the Boot HIDL HAL.
class BootHidlTest : public ::testing::VtsHalHidlTargetTestBase {
@@ -83,7 +85,7 @@
{
// Restore original flags to avoid problems on reboot
CommandResult cr;
- Return <void> result = boot->markBootSuccessful(generate_callback(&cr));
+ Return<void> result = boot->markBootSuccessful(generate_callback(&cr));
EXPECT_TRUE(result.isOk());
EXPECT_TRUE(cr.success);
}
@@ -151,22 +153,21 @@
// Sanity check Boot::getSuffix() on good and bad inputs.
TEST_F(BootHidlTest, GetSuffix) {
- const char *suffixPtr;
- auto cb = [&](hidl_string suffix) { suffixPtr = suffix.c_str(); };
- for (Slot i = 0; i < 2; i++) {
- CommandResult cr;
- Return<void> result = boot->getSuffix(i, cb);
- EXPECT_TRUE(result.isOk());
- char correctSuffix[3];
- snprintf(correctSuffix, sizeof(correctSuffix), "_%c", 'a' + i);
- ASSERT_EQ(0, strcmp(suffixPtr, correctSuffix));
- }
- {
- char emptySuffix[] = "";
- Return<void> result = boot->getSuffix(boot->getNumberSlots(), cb);
- EXPECT_TRUE(result.isOk());
- ASSERT_EQ(0, strcmp(emptySuffix, suffixPtr));
- }
+ string suffixStr;
+ vector<string> correctSuffixes = {"_a", "_b"};
+ auto cb = [&](hidl_string suffix) { suffixStr = suffix.c_str(); };
+ for (Slot i = 0; i < 2; i++) {
+ CommandResult cr;
+ Return<void> result = boot->getSuffix(i, cb);
+ EXPECT_TRUE(result.isOk());
+ ASSERT_EQ(0, suffixStr.compare(correctSuffixes[i]));
+ }
+ {
+ string emptySuffix = "";
+ Return<void> result = boot->getSuffix(boot->getNumberSlots(), cb);
+ EXPECT_TRUE(result.isOk());
+ ASSERT_EQ(0, suffixStr.compare(emptySuffix));
+ }
}
int main(int argc, char **argv) {
diff --git a/camera/common/1.0/default/CameraMetadata.cpp b/camera/common/1.0/default/CameraMetadata.cpp
index 44c2040..0e7ef6e 100644
--- a/camera/common/1.0/default/CameraMetadata.cpp
+++ b/camera/common/1.0/default/CameraMetadata.cpp
@@ -17,7 +17,7 @@
// #define LOG_NDEBUG 0
#define LOG_TAG "CamComm1.0-MD"
-#include <utils/Log.h>
+#include <log/log.h>
#include <utils/Errors.h>
#include "CameraMetadata.h"
diff --git a/camera/common/1.0/default/HandleImporter.cpp b/camera/common/1.0/default/HandleImporter.cpp
index dee2973..e22f26f 100644
--- a/camera/common/1.0/default/HandleImporter.cpp
+++ b/camera/common/1.0/default/HandleImporter.cpp
@@ -15,8 +15,8 @@
*/
#define LOG_TAG "HandleImporter"
-#include <utils/Log.h>
#include "HandleImporter.h"
+#include <log/log.h>
namespace android {
namespace hardware {
diff --git a/camera/common/1.0/default/VendorTagDescriptor.cpp b/camera/common/1.0/default/VendorTagDescriptor.cpp
index db884a8..bc18270 100644
--- a/camera/common/1.0/default/VendorTagDescriptor.cpp
+++ b/camera/common/1.0/default/VendorTagDescriptor.cpp
@@ -16,13 +16,13 @@
#define LOG_TAG "CamComm1.0-VTDesc"
-#include <utils/Errors.h>
-#include <utils/Log.h>
-#include <utils/Mutex.h>
-#include <utils/Vector.h>
-#include <utils/SortedVector.h>
+#include <log/log.h>
#include <system/camera_metadata.h>
#include <camera_metadata_hidden.h>
+#include <utils/Errors.h>
+#include <utils/Mutex.h>
+#include <utils/SortedVector.h>
+#include <utils/Vector.h>
#include "VendorTagDescriptor.h"
diff --git a/camera/device/1.0/ICameraDevice.hal b/camera/device/1.0/ICameraDevice.hal
index 52d6cf0..d4aa8cc 100644
--- a/camera/device/1.0/ICameraDevice.hal
+++ b/camera/device/1.0/ICameraDevice.hal
@@ -328,6 +328,20 @@
releaseRecordingFrameHandle(MemoryId memId, uint32_t bufferIndex, handle frame);
/**
+ * Release a batch of record frames previously returned by CAMERA_MSG_VIDEO_FRAME
+ * in handleCallbackTimestampBatch.
+ *
+ * It is camera HAL client's responsibility to release video recording
+ * frames sent out by the camera HAL before the camera HAL receives a call
+ * to disableMsgType(CAMERA_MSG_VIDEO_FRAME). After it receives the call to
+ * disableMsgType(CAMERA_MSG_VIDEO_FRAME), it is the camera HAL's
+ * responsibility to manage the life-cycle of the video recording frames.
+ *
+ * @param batch A batch of recording frames to be released by camera HAL.
+ */
+ releaseRecordingFrameHandleBatch(vec<VideoFrameMessage> batch);
+
+ /**
* Start auto focus.
*
* The notification callback routine is called with
diff --git a/camera/device/1.0/ICameraDeviceCallback.hal b/camera/device/1.0/ICameraDeviceCallback.hal
index 1b0db24..1dfcd80 100644
--- a/camera/device/1.0/ICameraDeviceCallback.hal
+++ b/camera/device/1.0/ICameraDeviceCallback.hal
@@ -92,10 +92,24 @@
* @param timestamp The time this buffer was captured by the camera, in
* nanoseconds.
*
- * @return frameId a frame ID to be used with releaseRecordingFrameId later
- *
*/
handleCallbackTimestamp(DataCallbackMsg msgType, handle frameData, MemoryId data,
uint32_t bufferIndex, int64_t timestamp);
+ /**
+ * Send a batch of image data buffer to the camera service, with timestamps
+ *
+ * This callback can be used to send multiple frames to camera framework in one callback, which
+ * reduce number of callbacks in performance intensive use cases, such as high speed video
+ * recording. The HAL must not mix use of this method with handleCallbackTimestamp in one
+ * recording session (between startRecording and stopRecording)
+ *
+ * @param msgType The kind of image buffer data this call represents.
+ * @param batch a vector messages. Each message contains a image buffer and a timestamp. The
+ * messages must be ordered in time from lower index to higher index, so that timestamp of
+ * i-th message is always smaller than i+1-th message.
+ *
+ */
+ handleCallbackTimestampBatch(DataCallbackMsg msgType, vec<HandleTimestampMessage> batch);
+
};
diff --git a/camera/device/1.0/default/Android.bp b/camera/device/1.0/default/Android.bp
index 5688fc1..af94b0f 100644
--- a/camera/device/1.0/default/Android.bp
+++ b/camera/device/1.0/default/Android.bp
@@ -7,6 +7,7 @@
],
shared_libs: [
"libhidlbase",
+ "libhidlmemory",
"libhidltransport",
"libhwbinder",
"libutils",
@@ -14,12 +15,13 @@
"android.hardware.camera.common@1.0",
"android.hardware.graphics.allocator@2.0",
"android.hardware.graphics.common@1.0",
+ "android.hidl.allocator@1.0",
"android.hidl.base@1.0",
+ "android.hidl.memory@1.0",
"libcutils",
"liblog",
"libhardware",
"libcamera_metadata",
- "libbinder",
],
static_libs: [
"android.hardware.camera.common@1.0-helper"
diff --git a/camera/device/1.0/default/CameraDevice.cpp b/camera/device/1.0/default/CameraDevice.cpp
index 819525b..6495f30 100644
--- a/camera/device/1.0/default/CameraDevice.cpp
+++ b/camera/device/1.0/default/CameraDevice.cpp
@@ -15,9 +15,10 @@
*/
#define LOG_TAG "CamDev@1.0-impl"
-#include <utils/Log.h>
#include <hardware/camera.h>
#include <hardware/gralloc1.h>
+#include <hidlmemory/mapping.h>
+#include <log/log.h>
#include <utils/Trace.h>
#include "CameraDevice_1_0.h"
@@ -102,6 +103,12 @@
__FUNCTION__, mCameraId.c_str());
mInitFail = true;
}
+
+ mAshmemAllocator = IAllocator::getService("ashmem");
+ if (mAshmemAllocator == nullptr) {
+ ALOGI("%s: cannot get ashmemAllocator", __FUNCTION__);
+ mInitFail = true;
+ }
}
CameraDevice::~CameraDevice() {
@@ -289,35 +296,66 @@
return getStatusT(s);
}
-CameraDevice::CameraHeapMemory::CameraHeapMemory(int fd, size_t buf_size, uint_t num_buffers) :
+CameraDevice::CameraHeapMemory::CameraHeapMemory(
+ int fd, size_t buf_size, uint_t num_buffers) :
mBufSize(buf_size),
mNumBufs(num_buffers) {
- mHeap = new MemoryHeapBase(fd, buf_size * num_buffers);
+ mHidlHandle = native_handle_create(1,0);
+ mHidlHandle->data[0] = fcntl(fd, F_DUPFD_CLOEXEC, 0);
+ const size_t pagesize = getpagesize();
+ size_t size = ((buf_size * num_buffers + pagesize-1) & ~(pagesize-1));
+ mHidlHeap = hidl_memory("ashmem", mHidlHandle, size);
commonInitialization();
}
-CameraDevice::CameraHeapMemory::CameraHeapMemory(size_t buf_size, uint_t num_buffers) :
+CameraDevice::CameraHeapMemory::CameraHeapMemory(
+ sp<IAllocator> ashmemAllocator,
+ size_t buf_size, uint_t num_buffers) :
mBufSize(buf_size),
mNumBufs(num_buffers) {
- mHeap = new MemoryHeapBase(buf_size * num_buffers);
+ const size_t pagesize = getpagesize();
+ size_t size = ((buf_size * num_buffers + pagesize-1) & ~(pagesize-1));
+ ashmemAllocator->allocate(size,
+ [&](bool success, const hidl_memory& mem) {
+ if (!success) {
+ ALOGE("%s: allocating ashmem of %zu bytes failed!",
+ __FUNCTION__, buf_size * num_buffers);
+ return;
+ }
+ mHidlHandle = native_handle_clone(mem.handle());
+ mHidlHeap = hidl_memory("ashmem", mHidlHandle, size);
+ });
+
commonInitialization();
}
void CameraDevice::CameraHeapMemory::commonInitialization() {
- handle.data = mHeap->base();
+ mHidlHeapMemory = mapMemory(mHidlHeap);
+ if (mHidlHeapMemory == nullptr) {
+ ALOGE("%s: memory map failed!", __FUNCTION__);
+ native_handle_close(mHidlHandle); // close FD for the shared memory
+ native_handle_delete(mHidlHandle);
+ mHidlHeap = hidl_memory();
+ mHidlHandle = nullptr;
+ return;
+ }
+ mHidlHeapMemData = mHidlHeapMemory->getPointer();
+ handle.data = mHidlHeapMemData;
handle.size = mBufSize * mNumBufs;
handle.handle = this;
-
- mBuffers = new sp<MemoryBase>[mNumBufs];
- for (uint_t i = 0; i < mNumBufs; i++) {
- mBuffers[i] = new MemoryBase(mHeap, i * mBufSize, mBufSize);
- }
-
handle.release = sPutMemory;
}
CameraDevice::CameraHeapMemory::~CameraHeapMemory() {
- delete [] mBuffers;
+ if (mHidlHeapMemory != nullptr) {
+ mHidlHeapMemData = nullptr;
+ mHidlHeapMemory.clear(); // The destructor will trigger munmap
+ }
+
+ if (mHidlHandle) {
+ native_handle_close(mHidlHandle); // close FD for the shared memory
+ native_handle_delete(mHidlHandle);
+ }
}
// shared memory methods
@@ -330,22 +368,13 @@
}
CameraHeapMemory* mem;
- native_handle_t* handle = native_handle_create(1,0);
-
- if (handle == nullptr) {
- ALOGE("%s: native_handle_create failed!", __FUNCTION__);
- return nullptr;
- }
-
if (fd < 0) {
- mem = new CameraHeapMemory(buf_size, num_bufs);
+ mem = new CameraHeapMemory(object->mAshmemAllocator, buf_size, num_bufs);
} else {
mem = new CameraHeapMemory(fd, buf_size, num_bufs);
}
- handle->data[0] = mem->mHeap->getHeapID();
mem->incStrong(mem);
-
- hidl_handle hidlHandle = handle;
+ hidl_handle hidlHandle = mem->mHidlHandle;
MemoryId id = object->mDeviceCallback->registerMemory(hidlHandle, buf_size, num_bufs);
mem->handle.mId = id;
if (object->mMemoryMap.count(id) != 0) {
@@ -353,7 +382,6 @@
}
object->mMemoryMap[id] = mem;
mem->handle.mDevice = object;
- native_handle_delete(handle);
return &mem->handle;
}
@@ -420,6 +448,39 @@
}
}
+void CameraDevice::handleCallbackTimestamp(
+ nsecs_t timestamp, int32_t msg_type,
+ MemoryId memId , unsigned index, native_handle_t* handle) {
+ uint32_t batchSize = 0;
+ {
+ Mutex::Autolock _l(mBatchLock);
+ batchSize = mBatchSize;
+ }
+
+ if (batchSize == 0) { // non-batch mode
+ mDeviceCallback->handleCallbackTimestamp(
+ (DataCallbackMsg) msg_type, handle, memId, index, timestamp);
+ } else { // batch mode
+ Mutex::Autolock _l(mBatchLock);
+ size_t inflightSize = mInflightBatch.size();
+ if (inflightSize == 0) {
+ mBatchMsgType = msg_type;
+ } else if (mBatchMsgType != msg_type) {
+ ALOGE("%s: msg_type change (from %d to %d) is not supported!",
+ __FUNCTION__, mBatchMsgType, msg_type);
+ return;
+ }
+ mInflightBatch.push_back({handle, memId, index, timestamp});
+
+ // Send batched frames to camera framework
+ if (mInflightBatch.size() >= batchSize) {
+ mDeviceCallback->handleCallbackTimestampBatch(
+ (DataCallbackMsg) mBatchMsgType, mInflightBatch);
+ mInflightBatch.clear();
+ }
+ }
+}
+
void CameraDevice::sDataCbTimestamp(nsecs_t timestamp, int32_t msg_type,
const camera_memory_t *data, unsigned index, void *user) {
ALOGV("%s", __FUNCTION__);
@@ -438,7 +499,7 @@
if (object->mMetadataMode) {
if (mem->mBufSize == sizeof(VideoNativeHandleMetadata)) {
VideoNativeHandleMetadata* md = (VideoNativeHandleMetadata*)
- mem->mBuffers[index]->pointer();
+ ((uint8_t*) mem->mHidlHeapMemData + index * mem->mBufSize);
if (md->eType == VideoNativeHandleMetadata::kMetadataBufferTypeNativeHandleSource) {
handle = md->pHandle;
}
@@ -450,8 +511,7 @@
object->mDeviceCallback->dataCallbackTimestamp(
(DataCallbackMsg) msg_type, mem->handle.mId, index, timestamp);
} else {
- object->mDeviceCallback->handleCallbackTimestamp(
- (DataCallbackMsg) msg_type, handle, mem->handle.mId, index, timestamp);
+ object->handleCallbackTimestamp(timestamp, msg_type, mem->handle.mId, index, handle);
}
}
}
@@ -769,27 +829,12 @@
}
if (mDevice->ops->release_recording_frame) {
CameraHeapMemory* camMemory = mMemoryMap.at(memId);
- sp<MemoryHeapBase> heap = camMemory->mHeap;
if (bufferIndex >= camMemory->mNumBufs) {
ALOGE("%s: bufferIndex %d exceeds number of buffers %d",
__FUNCTION__, bufferIndex, camMemory->mNumBufs);
return;
}
- sp<IMemory> mem = camMemory->mBuffers[bufferIndex];
- // TODO: simplify below logic once we verify offset is indeed idx * mBufSize
- // and heap == heap2
- ssize_t offset;
- size_t size;
- sp<IMemoryHeap> heap2 = mem->getMemory(&offset, &size);
- if ((size_t)offset != bufferIndex * camMemory->mBufSize) {
- ALOGI("%s: unexpected offset %zd (was expecting %zu)",
- __FUNCTION__, offset, bufferIndex * camMemory->mBufSize);
- }
- if (heap != heap2) {
- ALOGE("%s: heap mismatch!", __FUNCTION__);
- return;
- }
- void *data = ((uint8_t *)heap->base()) + offset;
+ void *data = ((uint8_t *) camMemory->mHidlHeapMemData) + bufferIndex * camMemory->mBufSize;
if (handle) {
VideoNativeHandleMetadata* md = (VideoNativeHandleMetadata*) data;
if (md->eType == VideoNativeHandleMetadata::kMetadataBufferTypeNativeHandleSource) {
@@ -827,6 +872,17 @@
return Void();
}
+Return<void> CameraDevice::releaseRecordingFrameHandleBatch(
+ const hidl_vec<VideoFrameMessage>& msgs) {
+ ALOGV("%s(%s)", __FUNCTION__, mCameraId.c_str());
+ Mutex::Autolock _l(mLock);
+ for (auto& msg : msgs) {
+ releaseRecordingFrameLocked(
+ msg.data, msg.bufferIndex, msg.frameData.getNativeHandle());
+ }
+ return Void();
+}
+
Return<Status> CameraDevice::autoFocus() {
ALOGV("%s(%s)", __FUNCTION__, mCameraId.c_str());
Mutex::Autolock _l(mLock);
diff --git a/camera/device/1.0/default/CameraDevice_1_0.h b/camera/device/1.0/default/CameraDevice_1_0.h
index 2568f86..a9f55c2 100644
--- a/camera/device/1.0/default/CameraDevice_1_0.h
+++ b/camera/device/1.0/default/CameraDevice_1_0.h
@@ -20,12 +20,12 @@
#include <unordered_map>
#include "utils/Mutex.h"
#include "utils/SortedVector.h"
-#include <binder/MemoryBase.h>
-#include <binder/MemoryHeapBase.h>
#include "CameraModule.h"
#include "HandleImporter.h"
#include <android/hardware/camera/device/1.0/ICameraDevice.h>
+#include <android/hidl/allocator/1.0/IAllocator.h>
+#include <android/hidl/memory/1.0/IMemory.h>
#include <hidl/MQDescriptor.h>
#include <hidl/Status.h>
@@ -47,7 +47,9 @@
using ::android::hardware::camera::device::V1_0::ICameraDeviceCallback;
using ::android::hardware::camera::device::V1_0::ICameraDevicePreviewCallback;
using ::android::hardware::camera::device::V1_0::MemoryId;
+using ::android::hidl::allocator::V1_0::IAllocator;
using ::android::hidl::base::V1_0::IBase;
+using ::android::hidl::memory::V1_0::IMemory;
using ::android::hardware::hidl_array;
using ::android::hardware::hidl_memory;
using ::android::hardware::hidl_string;
@@ -93,6 +95,8 @@
Return<void> releaseRecordingFrame(uint32_t memId, uint32_t bufferIndex) override;
Return<void> releaseRecordingFrameHandle(
uint32_t memId, uint32_t bufferIndex, const hidl_handle& frame) override;
+ Return<void> releaseRecordingFrameHandleBatch(
+ const hidl_vec<VideoFrameMessage>&) override;
Return<Status> autoFocus() override;
Return<Status> cancelAutoFocus() override;
Return<Status> takePicture() override;
@@ -111,17 +115,24 @@
class CameraHeapMemory : public RefBase {
public:
CameraHeapMemory(int fd, size_t buf_size, uint_t num_buffers = 1);
- explicit CameraHeapMemory(size_t buf_size, uint_t num_buffers = 1);
+ explicit CameraHeapMemory(
+ sp<IAllocator> ashmemAllocator, size_t buf_size, uint_t num_buffers = 1);
void commonInitialization();
virtual ~CameraHeapMemory();
size_t mBufSize;
uint_t mNumBufs;
- // TODO: b/35887419: use hidl_memory instead and get rid of libbinder
- sp<MemoryHeapBase> mHeap;
- sp<MemoryBase>* mBuffers;
+
+ // Shared memory related members
+ hidl_memory mHidlHeap;
+ native_handle_t* mHidlHandle; // contains one shared memory FD
+ void* mHidlHeapMemData;
+ sp<IMemory> mHidlHeapMemory; // munmap happens in ~IMemory()
+
CameraMemory handle;
};
+ sp<IAllocator> mAshmemAllocator;
+
// TODO: b/35625849
// Meta data buffer layout for passing a native_handle to codec
@@ -169,6 +180,16 @@
bool mMetadataMode = false;
+ mutable Mutex mBatchLock;
+ // Start of protection scope for mBatchLock
+ uint32_t mBatchSize = 0; // 0 for non-batch mode, set to other value to start batching
+ int32_t mBatchMsgType; // Maybe only allow DataCallbackMsg::VIDEO_FRAME?
+ std::vector<HandleTimestampMessage> mInflightBatch;
+ // End of protection scope for mBatchLock
+
+ void handleCallbackTimestamp(
+ nsecs_t timestamp, int32_t msg_type,
+ MemoryId memId , unsigned index, native_handle_t* handle);
void releaseRecordingFrameLocked(uint32_t memId, uint32_t bufferIndex, const native_handle_t*);
// shared memory methods
@@ -178,13 +199,13 @@
// Device callback forwarding methods
static void sNotifyCb(int32_t msg_type, int32_t ext1, int32_t ext2, void *user);
static void sDataCb(int32_t msg_type, const camera_memory_t *data, unsigned int index,
- camera_frame_metadata_t *metadata, void *user);
+ camera_frame_metadata_t *metadata, void *user);
static void sDataCbTimestamp(nsecs_t timestamp, int32_t msg_type,
const camera_memory_t *data, unsigned index, void *user);
// Preview window callback forwarding methods
static int sDequeueBuffer(struct preview_stream_ops* w,
- buffer_handle_t** buffer, int *stride);
+ buffer_handle_t** buffer, int *stride);
static int sLockBuffer(struct preview_stream_ops* w, buffer_handle_t* buffer);
@@ -195,7 +216,7 @@
static int sSetBufferCount(struct preview_stream_ops* w, int count);
static int sSetBuffersGeometry(struct preview_stream_ops* w,
- int width, int height, int format);
+ int width, int height, int format);
static int sSetCrop(struct preview_stream_ops *w, int left, int top, int right, int bottom);
diff --git a/camera/device/1.0/types.hal b/camera/device/1.0/types.hal
index bf632d1..ce5205e 100644
--- a/camera/device/1.0/types.hal
+++ b/camera/device/1.0/types.hal
@@ -254,3 +254,36 @@
* between the HAL and the framework.
*/
typedef uint32_t MemoryId;
+
+/*
+ * Struct containing arguments of ICameraDeviceCallback::handleCallbackTimestamp.
+ * Used to send a batch of messages in ICameraDeviceCallback::handleCallbackTimestampBatch.
+ */
+struct HandleTimestampMessage {
+ // The handle of image buffer data.
+ handle frameData;
+
+ // A memory handle to the buffer containing the data
+ MemoryId data;
+
+ // The offset into the memory handle where the buffer starts.
+ uint32_t bufferIndex;
+
+ // The time this buffer was captured by the camera, in nanoseconds
+ int64_t timestamp;
+};
+
+/*
+ * Struct containing arguments of ICameraDevice::releaseRecordingFrameHandle.
+ * Used by camera framework to send a batch of recording frames back to camera HAL.
+ */
+struct VideoFrameMessage {
+ // The handle of image buffer data.
+ handle frameData;
+
+ // A memory handle to the buffer containing the data
+ MemoryId data;
+
+ // The offset into the memory handle where the buffer starts.
+ uint32_t bufferIndex;
+};
diff --git a/camera/device/3.2/ICameraDeviceSession.hal b/camera/device/3.2/ICameraDeviceSession.hal
index e186c8d..731fc76 100644
--- a/camera/device/3.2/ICameraDeviceSession.hal
+++ b/camera/device/3.2/ICameraDeviceSession.hal
@@ -183,6 +183,11 @@
* client, the HAL must process the requests in order of lowest index to
* highest index.
*
+ * The cachesToRemove argument contains a list of buffer caches (see
+ * StreamBuffer document for more information on buffer cache) to be removed
+ * by camera HAL. Camera HAL must remove these cache entries whether or not
+ * this method returns OK.
+ *
* The actual request processing is asynchronous, with the results of
* capture being returned by the HAL through the processCaptureResult()
* call. This call requires the result metadata to be available, but output
@@ -238,7 +243,8 @@
* that HAL processed successfully before HAL runs into an error.
*
*/
- processCaptureRequest(vec<CaptureRequest> requests)
+ processCaptureRequest(vec<CaptureRequest> requests,
+ vec<BufferCache> cachesToRemove)
generates (Status status, uint32_t numRequestProcessed);
/**
diff --git a/camera/device/3.2/default/CameraDevice.cpp b/camera/device/3.2/default/CameraDevice.cpp
index a742335..637a1e6 100644
--- a/camera/device/3.2/default/CameraDevice.cpp
+++ b/camera/device/3.2/default/CameraDevice.cpp
@@ -15,7 +15,7 @@
*/
#define LOG_TAG "CamDev@3.2-impl"
-#include <utils/Log.h>
+#include <log/log.h>
#include <utils/Vector.h>
#include <utils/Trace.h>
diff --git a/camera/device/3.2/default/CameraDeviceSession.cpp b/camera/device/3.2/default/CameraDeviceSession.cpp
index fb1d1ff..5b3024b 100644
--- a/camera/device/3.2/default/CameraDeviceSession.cpp
+++ b/camera/device/3.2/default/CameraDeviceSession.cpp
@@ -678,8 +678,32 @@
mCirculatingBuffers.erase(id);
}
+void CameraDeviceSession::updateBufferCaches(const hidl_vec<BufferCache>& cachesToRemove) {
+ Mutex::Autolock _l(mInflightLock);
+ for (auto& cache : cachesToRemove) {
+ auto cbsIt = mCirculatingBuffers.find(cache.streamId);
+ if (cbsIt == mCirculatingBuffers.end()) {
+ // The stream could have been removed
+ continue;
+ }
+ CirculatingBuffers& cbs = cbsIt->second;
+ auto it = cbs.find(cache.bufferId);
+ if (it != cbs.end()) {
+ sHandleImporter.freeBuffer(it->second);
+ cbs.erase(it);
+ } else {
+ ALOGE("%s: stream %d buffer %" PRIu64 " is not cached",
+ __FUNCTION__, cache.streamId, cache.bufferId);
+ }
+ }
+}
+
Return<void> CameraDeviceSession::processCaptureRequest(
- const hidl_vec<CaptureRequest>& requests, processCaptureRequest_cb _hidl_cb) {
+ const hidl_vec<CaptureRequest>& requests,
+ const hidl_vec<BufferCache>& cachesToRemove,
+ processCaptureRequest_cb _hidl_cb) {
+ updateBufferCaches(cachesToRemove);
+
uint32_t numRequestProcessed = 0;
Status s = Status::OK;
for (size_t i = 0; i < requests.size(); i++, numRequestProcessed++) {
diff --git a/camera/device/3.2/default/CameraDeviceSession.h b/camera/device/3.2/default/CameraDeviceSession.h
index 8923c05..781056e 100644
--- a/camera/device/3.2/default/CameraDeviceSession.h
+++ b/camera/device/3.2/default/CameraDeviceSession.h
@@ -85,7 +85,9 @@
Return<void> configureStreams(
const StreamConfiguration& requestedConfiguration, configureStreams_cb _hidl_cb) override;
Return<void> processCaptureRequest(
- const hidl_vec<CaptureRequest>& requests, processCaptureRequest_cb _hidl_cb) override;
+ const hidl_vec<CaptureRequest>& requests,
+ const hidl_vec<BufferCache>& cachesToRemove,
+ processCaptureRequest_cb _hidl_cb) override;
Return<Status> flush() override;
Return<void> close() override;
@@ -234,6 +236,8 @@
void cleanupBuffersLocked(int id);
+ void updateBufferCaches(const hidl_vec<BufferCache>& cachesToRemove);
+
Status processOneCaptureRequest(const CaptureRequest& request);
/**
* Static callback forwarding methods from HAL to instance
diff --git a/camera/device/3.2/default/convert.cpp b/camera/device/3.2/default/convert.cpp
index 35676df..c7cc75a 100644
--- a/camera/device/3.2/default/convert.cpp
+++ b/camera/device/3.2/default/convert.cpp
@@ -15,7 +15,7 @@
*/
#define LOG_TAG "android.hardware.camera.device@3.2-convert-impl"
-#include <android/log.h>
+#include <log/log.h>
#include "include/convert.h"
diff --git a/camera/device/3.2/types.hal b/camera/device/3.2/types.hal
index fd75528..5ae7a18 100644
--- a/camera/device/3.2/types.hal
+++ b/camera/device/3.2/types.hal
@@ -958,3 +958,25 @@
uint32_t partialResult;
};
+
+/**
+ * BufferCache:
+ *
+ * A list of cached bufferIds associated with a certain stream.
+ * Buffers are passed between camera service and camera HAL via bufferId except
+ * the first time a new buffer is being passed to HAL in CaptureRequest. Camera
+ * service and camera HAL therefore need to maintain a cached map of bufferId
+ * and corresponing native handle.
+ *
+ */
+struct BufferCache {
+ /**
+ * The ID of the stream this list is associated with.
+ */
+ int32_t streamId;
+
+ /**
+ * A cached buffer ID associated with streamId.
+ */
+ uint64_t bufferId;
+};
diff --git a/camera/provider/2.4/default/Android.bp b/camera/provider/2.4/default/Android.bp
index 42dec4d..9506827 100644
--- a/camera/provider/2.4/default/Android.bp
+++ b/camera/provider/2.4/default/Android.bp
@@ -15,6 +15,8 @@
"camera.device@3.2-impl",
"android.hardware.camera.provider@2.4",
"android.hardware.camera.common@1.0",
+ "android.hidl.allocator@1.0",
+ "android.hidl.memory@1.0",
"liblog",
"libhardware",
"libcamera_metadata"
diff --git a/camera/provider/2.4/default/CameraProvider.cpp b/camera/provider/2.4/default/CameraProvider.cpp
index 8701ec1..9f4d188 100644
--- a/camera/provider/2.4/default/CameraProvider.cpp
+++ b/camera/provider/2.4/default/CameraProvider.cpp
@@ -40,6 +40,22 @@
const int kMaxCameraDeviceNameLen = 128;
const int kMaxCameraIdLen = 16;
+bool matchDeviceName(const hidl_string& deviceName, std::string* deviceVersion,
+ std::string* cameraId) {
+ std::string deviceNameStd(deviceName.c_str());
+ std::smatch sm;
+ if (std::regex_match(deviceNameStd, sm, kDeviceNameRE)) {
+ if (deviceVersion != nullptr) {
+ *deviceVersion = sm[1];
+ }
+ if (cameraId != nullptr) {
+ *cameraId = sm[2];
+ }
+ return true;
+ }
+ return false;
+}
+
} // anonymous namespace
using ::android::hardware::camera::common::V1_0::CameraMetadataType;
@@ -112,30 +128,22 @@
}
}
-bool CameraProvider::matchDeviceName(const hidl_string& deviceName, std::smatch& sm) {
- std::string deviceNameStd(deviceName.c_str());
- return std::regex_match(deviceNameStd, sm, kDeviceNameRE);
-}
-
std::string CameraProvider::getLegacyCameraId(const hidl_string& deviceName) {
- std::smatch sm;
- bool match = matchDeviceName(deviceName, sm);
- if (!match) {
- return std::string("");
- }
- return sm[2];
+ std::string cameraId;
+ matchDeviceName(deviceName, nullptr, &cameraId);
+ return cameraId;
}
int CameraProvider::getCameraDeviceVersion(const hidl_string& deviceName) {
- std::smatch sm;
- bool match = matchDeviceName(deviceName, sm);
+ std::string deviceVersion;
+ bool match = matchDeviceName(deviceName, &deviceVersion, nullptr);
if (!match) {
return -1;
}
- if (sm[1].compare(kHAL3_2) == 0) {
+ if (deviceVersion == kHAL3_2) {
// maybe switched to 3.4 or define the hidl version enum later
return CAMERA_DEVICE_API_VERSION_3_2;
- } else if (sm[1].compare(kHAL1_0) == 0) {
+ } else if (deviceVersion == kHAL1_0) {
return CAMERA_DEVICE_API_VERSION_1_0;
}
return 0;
@@ -322,15 +330,13 @@
Return<void> CameraProvider::getCameraDeviceInterface_V1_x(
const hidl_string& cameraDeviceName, getCameraDeviceInterface_V1_x_cb _hidl_cb) {
- std::smatch sm;
- bool match = matchDeviceName(cameraDeviceName, sm);
+ std::string cameraId, deviceVersion;
+ bool match = matchDeviceName(cameraDeviceName, &deviceVersion, &cameraId);
if (!match) {
_hidl_cb(Status::ILLEGAL_ARGUMENT, nullptr);
return Void();
}
- std::string cameraId = sm[2];
- std::string deviceVersion = sm[1];
std::string deviceName(cameraDeviceName.c_str());
ssize_t index = mCameraDeviceNames.indexOf(std::make_pair(cameraId, deviceName));
if (index == NAME_NOT_FOUND) { // Either an illegal name or a device version mismatch
@@ -377,15 +383,13 @@
Return<void> CameraProvider::getCameraDeviceInterface_V3_x(
const hidl_string& cameraDeviceName, getCameraDeviceInterface_V3_x_cb _hidl_cb) {
- std::smatch sm;
- bool match = matchDeviceName(cameraDeviceName, sm);
+ std::string cameraId, deviceVersion;
+ bool match = matchDeviceName(cameraDeviceName, &deviceVersion, &cameraId);
if (!match) {
_hidl_cb(Status::ILLEGAL_ARGUMENT, nullptr);
return Void();
}
- std::string cameraId = sm[2];
- std::string deviceVersion = sm[1];
std::string deviceName(cameraDeviceName.c_str());
ssize_t index = mCameraDeviceNames.indexOf(std::make_pair(cameraId, deviceName));
if (index == NAME_NOT_FOUND) { // Either an illegal name or a device version mismatch
diff --git a/camera/provider/2.4/default/CameraProvider.h b/camera/provider/2.4/default/CameraProvider.h
index 2a43e2f..d7b0ea6 100644
--- a/camera/provider/2.4/default/CameraProvider.h
+++ b/camera/provider/2.4/default/CameraProvider.h
@@ -91,7 +91,6 @@
bool setUpVendorTags();
// extract legacy camera ID/device version from a HIDL device name
- static bool matchDeviceName(const hidl_string& deviceName, std::smatch& sm);
static std::string getLegacyCameraId(const hidl_string& deviceName);
static int getCameraDeviceVersion(const hidl_string& deviceName);
diff --git a/camera/provider/2.4/vts/functional/CameraParameters.cpp b/camera/provider/2.4/vts/functional/CameraParameters.cpp
index 0285154..97b263b 100644
--- a/camera/provider/2.4/vts/functional/CameraParameters.cpp
+++ b/camera/provider/2.4/vts/functional/CameraParameters.cpp
@@ -16,7 +16,7 @@
*/
#define LOG_TAG "CameraParams"
-#include <utils/Log.h>
+#include <log/log.h>
#include <string.h>
#include <stdlib.h>
diff --git a/camera/provider/2.4/vts/functional/VtsHalCameraProviderV2_4TargetTest.cpp b/camera/provider/2.4/vts/functional/VtsHalCameraProviderV2_4TargetTest.cpp
index a79c9fa..74e6efe 100644
--- a/camera/provider/2.4/vts/functional/VtsHalCameraProviderV2_4TargetTest.cpp
+++ b/camera/provider/2.4/vts/functional/VtsHalCameraProviderV2_4TargetTest.cpp
@@ -61,6 +61,7 @@
using ::android::hardware::camera::provider::V2_4::ICameraProvider;
using ::android::hardware::camera::provider::V2_4::ICameraProviderCallback;
using ::android::hardware::camera::device::V3_2::ICameraDevice;
+using ::android::hardware::camera::device::V3_2::BufferCache;
using ::android::hardware::camera::device::V3_2::CaptureRequest;
using ::android::hardware::camera::device::V3_2::CaptureResult;
using ::android::hardware::camera::device::V3_2::ICameraDeviceCallback;
@@ -86,6 +87,7 @@
using ::android::hardware::camera::device::V1_0::CameraFrameMetadata;
using ::android::hardware::camera::device::V1_0::ICameraDevicePreviewCallback;
using ::android::hardware::camera::device::V1_0::FrameCallbackFlag;
+using ::android::hardware::camera::device::V1_0::HandleTimestampMessage;
const char kCameraPassthroughServiceName[] = "legacy/0";
const uint32_t kMaxPreviewWidth = 1920;
@@ -510,6 +512,10 @@
const hidl_handle& frameData,uint32_t data,
uint32_t bufferIndex, int64_t timestamp) override;
+ Return<void> handleCallbackTimestampBatch(DataCallbackMsg msgType,
+ const ::android::hardware::hidl_vec<HandleTimestampMessage>& batch) override;
+
+
private:
CameraHidlTest *mParent; // Parent object
};
@@ -666,6 +672,23 @@
return Void();
}
+Return<void> CameraHidlTest::Camera1DeviceCb::handleCallbackTimestampBatch(
+ DataCallbackMsg msgType,
+ const hidl_vec<HandleTimestampMessage>& batch) {
+ std::unique_lock<std::mutex> l(mParent->mLock);
+ for (auto& msg : batch) {
+ mParent->mDataMessageTypeReceived = msgType;
+ mParent->mVideoBufferIndex = msg.bufferIndex;
+ if (mParent->mMemoryPool.count(msg.data) == 0) {
+ ADD_FAILURE() << "memory pool ID " << msg.data << " not found";
+ }
+ mParent->mVideoData = msg.data;
+ mParent->mVideoNativeHandle = msg.frameData;
+ mParent->mResultCondition.notify_one();
+ }
+ return Void();
+}
+
Return<void> CameraHidlTest::DeviceCb::processCaptureResult(
const hidl_vec<CaptureResult>& results) {
if (nullptr == mParent) {
@@ -2481,8 +2504,10 @@
Status status = Status::INTERNAL_ERROR;
uint32_t numRequestProcessed = 0;
+ hidl_vec<BufferCache> cachesToRemove;
Return<void> returnStatus = session->processCaptureRequest(
{request},
+ cachesToRemove,
[&status, &numRequestProcessed] (auto s, uint32_t n) {
status = s;
numRequestProcessed = n;
@@ -2513,6 +2538,7 @@
returnStatus = session->processCaptureRequest(
{request},
+ cachesToRemove,
[&status, &numRequestProcessed] (auto s, uint32_t n) {
status = s;
numRequestProcessed = n;
@@ -2579,8 +2605,10 @@
//Settings were not correctly initialized, we should fail here
Status status = Status::OK;
uint32_t numRequestProcessed = 0;
+ hidl_vec<BufferCache> cachesToRemove;
Return<void> ret = session->processCaptureRequest(
{request},
+ cachesToRemove,
[&status, &numRequestProcessed] (auto s, uint32_t n) {
status = s;
numRequestProcessed = n;
@@ -2632,8 +2660,10 @@
//Output buffers are missing, we should fail here
Status status = Status::OK;
uint32_t numRequestProcessed = 0;
+ hidl_vec<BufferCache> cachesToRemove;
ret = session->processCaptureRequest(
{request},
+ cachesToRemove,
[&status, &numRequestProcessed] (auto s, uint32_t n) {
status = s;
numRequestProcessed = n;
@@ -2701,8 +2731,10 @@
Status status = Status::INTERNAL_ERROR;
uint32_t numRequestProcessed = 0;
+ hidl_vec<BufferCache> cachesToRemove;
ret = session->processCaptureRequest(
{request},
+ cachesToRemove,
[&status, &numRequestProcessed] (auto s, uint32_t n) {
status = s;
numRequestProcessed = n;
diff --git a/configstore/1.0/default/SurfaceFlingerConfigs.cpp b/configstore/1.0/default/SurfaceFlingerConfigs.cpp
index 9469ab4..70bd803 100644
--- a/configstore/1.0/default/SurfaceFlingerConfigs.cpp
+++ b/configstore/1.0/default/SurfaceFlingerConfigs.cpp
@@ -12,7 +12,6 @@
Return<void> SurfaceFlingerConfigs::vsyncEventPhaseOffsetNs(vsyncEventPhaseOffsetNs_cb _hidl_cb) {
#ifdef VSYNC_EVENT_PHASE_OFFSET_NS
_hidl_cb({true, VSYNC_EVENT_PHASE_OFFSET_NS});
- LOG(INFO) << "vsync event phase offset ns = " << VSYNC_EVENT_PHASE_OFFSET_NS;
#else
_hidl_cb({false, 0});
#endif
@@ -22,7 +21,6 @@
Return<void> SurfaceFlingerConfigs::vsyncSfEventPhaseOffsetNs(vsyncEventPhaseOffsetNs_cb _hidl_cb) {
#ifdef SF_VSYNC_EVENT_PHASE_OFFSET_NS
_hidl_cb({true, SF_VSYNC_EVENT_PHASE_OFFSET_NS});
- LOG(INFO) << "sfvsync event phase offset ns = " << SF_VSYNC_EVENT_PHASE_OFFSET_NS;
#else
_hidl_cb({false, 0});
#endif
@@ -32,7 +30,6 @@
Return<void> SurfaceFlingerConfigs::useContextPriority(useContextPriority_cb _hidl_cb) {
#ifdef USE_CONTEXT_PRIORITY
_hidl_cb({true, USE_CONTEXT_PRIORITY});
- LOG(INFO) << "SurfaceFlinger useContextPriority=" << USE_CONTEXT_PRIORITY;
#else
_hidl_cb({false, false});
#endif
@@ -42,7 +39,6 @@
Return<void> SurfaceFlingerConfigs::maxFrameBufferAcquiredBuffers(maxFrameBufferAcquiredBuffers_cb _hidl_cb) {
#ifdef NUM_FRAMEBUFFER_SURFACE_BUFFERS
_hidl_cb({true, NUM_FRAMEBUFFER_SURFACE_BUFFERS});
- LOG(INFO) << "SurfaceFlinger FrameBuffer max acquired buffers : " << NUM_FRAMEBUFFER_SURFACE_BUFFERS;
#else
_hidl_cb({false, 0});
#endif
@@ -55,7 +51,6 @@
value = true;
#endif
_hidl_cb({true, value});
- LOG(INFO) << "SurfaceFlinger Display: " << (value ? "Wide Color" : "Standard Color");
return Void();
}
@@ -65,7 +60,6 @@
value = false;
#endif
_hidl_cb({true, value});
- LOG(INFO) << "SurfaceFlinger hasSyncFramework: " << value;
return Void();
}
@@ -75,14 +69,12 @@
value = true;
#endif
_hidl_cb({true, value});
- LOG(INFO) << "SurfaceFlinger Display: " << (value ? "HDR" : "SDR");
return Void();
}
Return<void> SurfaceFlingerConfigs::presentTimeOffsetFromVSyncNs(presentTimeOffsetFromVSyncNs_cb _hidl_cb) {
#ifdef PRESENT_TIME_OFFSET_FROM_VSYNC_NS
_hidl_cb({true, PRESENT_TIME_OFFSET_FROM_VSYNC_NS});
- LOG(INFO) << "SurfaceFlinger presentTimeStampOffsetNs = " << PRESENT_TIME_OFFSET_FROM_VSYNC_NS;
#else
_hidl_cb({false, 0});
#endif
@@ -95,7 +87,6 @@
value = true;
#endif
_hidl_cb({true, value});
- LOG(INFO) << "SurfaceFlinger forceHwcForRGBtoYUV: " << value;
return Void();
}
@@ -104,7 +95,6 @@
#ifdef MAX_VIRTUAL_DISPLAY_DIMENSION
maxSize = MAX_VIRTUAL_DISPLAY_DIMENSION;
_hidl_cb({true, maxSize});
- LOG(INFO) << "SurfaceFlinger MaxVirtualDisplaySize: " << maxSize;
#else
_hidl_cb({false, maxSize});
#endif
@@ -119,7 +109,6 @@
specified = true;
#endif
_hidl_cb({specified, value});
- LOG(INFO) << "SurfaceFlinger UseVrFlinger: " << (value ? "true" : "false");
return Void();
}
diff --git a/configstore/1.0/default/android.hardware.configstore@1.0-service.rc b/configstore/1.0/default/android.hardware.configstore@1.0-service.rc
index 8741bdd..563d854 100644
--- a/configstore/1.0/default/android.hardware.configstore@1.0-service.rc
+++ b/configstore/1.0/default/android.hardware.configstore@1.0-service.rc
@@ -1,4 +1,4 @@
service configstore-hal-1-0 /vendor/bin/hw/android.hardware.configstore@1.0-service
- class hal
+ class hal animation
user system
group system
diff --git a/configstore/utils/Android.bp b/configstore/utils/Android.bp
index aa420d1..2c8aad6 100644
--- a/configstore/utils/Android.bp
+++ b/configstore/utils/Android.bp
@@ -14,14 +14,22 @@
// limitations under the License.
//
-cc_library_headers {
+cc_library_shared {
name: "android.hardware.configstore-utils",
defaults: ["hidl_defaults"],
+
+ srcs: [ "ConfigStoreUtils.cpp" ],
+
export_include_dirs: ["include"],
+
shared_libs: [
+ "android.hardware.configstore@1.0",
+ "libbase",
"libhidlbase"
],
export_shared_lib_headers: [
+ "android.hardware.configstore@1.0",
+ "libbase",
"libhidlbase"
],
}
diff --git a/configstore/utils/ConfigStoreUtils.cpp b/configstore/utils/ConfigStoreUtils.cpp
new file mode 100644
index 0000000..5a1fb42
--- /dev/null
+++ b/configstore/utils/ConfigStoreUtils.cpp
@@ -0,0 +1,40 @@
+//
+// Copyright (C) 2017 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.
+//
+
+#define LOG_TAG "ConfigStore"
+
+#include <android-base/logging.h>
+#include <configstore/Utils.h>
+
+namespace android {
+namespace hardware {
+namespace details {
+
+bool wouldLogInfo() {
+ return WOULD_LOG(INFO);
+}
+
+void logAlwaysInfo(const std::string& message) {
+ LOG(INFO) << message;
+}
+
+void logAlwaysError(const std::string& message) {
+ LOG(ERROR) << message;
+}
+
+} // namespace details
+} // namespace hardware
+} // namespace android
diff --git a/configstore/utils/include/configstore/Utils.h b/configstore/utils/include/configstore/Utils.h
index 46cc9b0..a54ce85 100644
--- a/configstore/utils/include/configstore/Utils.h
+++ b/configstore/utils/include/configstore/Utils.h
@@ -17,24 +17,31 @@
#ifndef ANDROID_HARDWARE_CONFIGSTORE_UTILS_H
#define ANDROID_HARDWARE_CONFIGSTORE_UTILS_H
+#include <android/hardware/configstore/1.0/ISurfaceFlingerConfigs.h>
#include <hidl/Status.h>
-#include <stdatomic.h>
-#pragma push_macro("LOG_TAG")
-#undef LOG_TAG
-#define LOG_TAG "ConfigStoreUtil"
+#include <sstream>
namespace android {
namespace hardware {
+
+namespace details {
+// Templated classes can use the below method
+// to avoid creating dependencies on liblog.
+bool wouldLogInfo();
+void logAlwaysInfo(const std::string& message);
+void logAlwaysError(const std::string& message);
+} // namespace details
+
namespace configstore {
+using namespace android::hardware::configstore::V1_0;
// arguments V: type for the value (i.e., OptionalXXX)
// I: interface class name
// func: member function pointer
-using namespace V1_0;
-
template<typename V, typename I, android::hardware::Return<void> (I::* func)
(std::function<void(const V&)>)>
decltype(V::value) get(const decltype(V::value) &defValue) {
+ using namespace android::hardware::details;
auto getHelper = []()->V {
V ret;
sp<I> configs = I::getService();
@@ -47,7 +54,11 @@
ret = v;
});
if (!status.isOk()) {
- ALOGE("HIDL call failed. %s", status.description().c_str());
+ std::ostringstream oss;
+ oss << "HIDL call failed for retrieving a config item from "
+ "configstore : "
+ << status.description().c_str();
+ logAlwaysError(oss.str());
ret.specified = false;
}
}
@@ -56,6 +67,24 @@
};
static V cachedValue = getHelper();
+ if (wouldLogInfo()) {
+ std::string iname = __PRETTY_FUNCTION__;
+ // func name starts with "func = " in __PRETTY_FUNCTION__
+ auto pos = iname.find("func = ");
+ if (pos != std::string::npos) {
+ iname = iname.substr(pos + sizeof("func = "));
+ iname.pop_back(); // remove trailing ']'
+ } else {
+ iname += " (unknown)";
+ }
+
+ std::ostringstream oss;
+ oss << iname << " retrieved: "
+ << (cachedValue.specified ? cachedValue.value : defValue)
+ << (cachedValue.specified ? "" : " (default)");
+ logAlwaysInfo(oss.str());
+ }
+
return cachedValue.specified ? cachedValue.value : defValue;
}
@@ -99,6 +128,4 @@
} // namespace hardware
} // namespace android
-#pragma pop_macro("LOG_TAG")
-
#endif // ANDROID_HARDWARE_CONFIGSTORE_UTILS_H
diff --git a/contexthub/1.0/vts/functional/VtsHalContexthubV1_0TargetTest.cpp b/contexthub/1.0/vts/functional/VtsHalContexthubV1_0TargetTest.cpp
index 765857f..5672824 100644
--- a/contexthub/1.0/vts/functional/VtsHalContexthubV1_0TargetTest.cpp
+++ b/contexthub/1.0/vts/functional/VtsHalContexthubV1_0TargetTest.cpp
@@ -16,12 +16,13 @@
#define LOG_TAG "contexthub_hidl_hal_test"
+#include <VtsHalHidlTargetTestBase.h>
#include <android-base/logging.h>
#include <android/hardware/contexthub/1.0/IContexthub.h>
#include <android/hardware/contexthub/1.0/IContexthubCallback.h>
#include <android/hardware/contexthub/1.0/types.h>
#include <android/log.h>
-#include <VtsHalHidlTargetTestBase.h>
+#include <log/log.h>
#include <cinttypes>
#include <future>
diff --git a/drm/1.0/IDrmPlugin.hal b/drm/1.0/IDrmPlugin.hal
index 083b311..07b0832 100644
--- a/drm/1.0/IDrmPlugin.hal
+++ b/drm/1.0/IDrmPlugin.hal
@@ -179,10 +179,9 @@
* certificate authority (CA) is an entity which issues digital certificates
* for use by other parties. It is an example of a trusted third party.
* @return status the status of the call. The status must be OK or one of
- * the following errors: BAD_VALUE if the sessionId is invalid,
- * ERROR_DRM_CANNOT_HANDLE if the drm scheme does not require provisioning
- * or ERROR_DRM_INVALID_STATE if the HAL is in a state where the provision
- * request cannot be generated.
+ * the following errors: ERROR_DRM_CANNOT_HANDLE if the drm scheme does not
+ * require provisioning or ERROR_DRM_INVALID_STATE if the HAL is in a state
+ * where the provision request cannot be generated.
* @return request if successful the opaque certificate request blob
* is returned
* @return defaultUrl URL that the provisioning request should be
diff --git a/drm/1.0/default/Android.mk b/drm/1.0/default/Android.mk
index f2334a0..23a4506 100644
--- a/drm/1.0/default/Android.mk
+++ b/drm/1.0/default/Android.mk
@@ -38,9 +38,12 @@
LOCAL_C_INCLUDES := \
hardware/interfaces/drm
-# TODO: The legacy DRM plugins only support 32-bit. They need
-# to be migrated to 64-bit (b/18948909)
+# TODO(b/18948909) Some legacy DRM plugins only support 32-bit. They need to be
+# migrated to 64-bit. Once all of a device's legacy DRM plugins support 64-bit,
+# that device can turn on ENABLE_MEDIADRM_64 to build this service as 64-bit.
+ifneq ($(ENABLE_MEDIADRM_64), true)
LOCAL_32_BIT_ONLY := true
+endif
include $(BUILD_EXECUTABLE)
@@ -55,11 +58,13 @@
DrmPlugin.cpp \
CryptoFactory.cpp \
CryptoPlugin.cpp \
+ LegacyPluginPath.cpp \
TypeConvert.cpp \
LOCAL_SHARED_LIBRARIES := \
android.hardware.drm@1.0 \
android.hidl.memory@1.0 \
+ libcutils \
libhidlbase \
libhidlmemory \
libhidltransport \
@@ -72,8 +77,11 @@
frameworks/native/include \
frameworks/av/include
-# TODO: The legacy DRM plugins only support 32-bit. They need
-# to be migrated to 64-bit (b/18948909)
+# TODO: Some legacy DRM plugins only support 32-bit. They need to be migrated to
+# 64-bit. (b/18948909) Once all of a device's legacy DRM plugins support 64-bit,
+# that device can turn on ENABLE_MEDIADRM_64 to build this impl as 64-bit.
+ifneq ($(ENABLE_MEDIADRM_64), true)
LOCAL_32_BIT_ONLY := true
+endif
include $(BUILD_SHARED_LIBRARY)
diff --git a/drm/1.0/default/CryptoFactory.cpp b/drm/1.0/default/CryptoFactory.cpp
index e46233d..caab83b 100644
--- a/drm/1.0/default/CryptoFactory.cpp
+++ b/drm/1.0/default/CryptoFactory.cpp
@@ -16,9 +16,10 @@
#define LOG_TAG "android.hardware.drm@1.0-impl"
#include "CryptoFactory.h"
+#include <log/log.h>
#include "CryptoPlugin.h"
+#include "LegacyPluginPath.h"
#include "TypeConvert.h"
-#include <utils/Log.h>
namespace android {
namespace hardware {
@@ -27,7 +28,7 @@
namespace implementation {
CryptoFactory::CryptoFactory() :
- loader("/vendor/lib/mediadrm", "createCryptoFactory") {
+ loader(getDrmPluginPath(), "createCryptoFactory") {
}
// Methods from ::android::hardware::drm::V1_0::ICryptoFactory follow.
diff --git a/drm/1.0/default/CryptoPlugin.cpp b/drm/1.0/default/CryptoPlugin.cpp
index 9c51b15..591861a 100644
--- a/drm/1.0/default/CryptoPlugin.cpp
+++ b/drm/1.0/default/CryptoPlugin.cpp
@@ -20,8 +20,8 @@
#include <android/hidl/memory/1.0/IMemory.h>
#include <hidlmemory/mapping.h>
+#include <log/log.h>
#include <media/stagefright/foundation/AString.h>
-#include <utils/Log.h>
using android::hardware::hidl_memory;
using android::hidl::memory::V1_0::IMemory;
@@ -35,7 +35,7 @@
// Methods from ::android::hardware::drm::V1_0::ICryptoPlugin follow
Return<bool> CryptoPlugin::requiresSecureDecoderComponent(
const hidl_string& mime) {
- return mLegacyPlugin->requiresSecureDecoderComponent(mime);
+ return mLegacyPlugin->requiresSecureDecoderComponent(mime.c_str());
}
Return<void> CryptoPlugin::notifyResolution(uint32_t width,
diff --git a/drm/1.0/default/DrmFactory.cpp b/drm/1.0/default/DrmFactory.cpp
index 9ec0ab7..7e5d998 100644
--- a/drm/1.0/default/DrmFactory.cpp
+++ b/drm/1.0/default/DrmFactory.cpp
@@ -1,6 +1,6 @@
/*
* Copyright (C) 2016 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
@@ -16,9 +16,10 @@
#define LOG_TAG "android.hardware.drm@1.0-impl"
#include "DrmFactory.h"
+#include <log/log.h>
#include "DrmPlugin.h"
+#include "LegacyPluginPath.h"
#include "TypeConvert.h"
-#include <utils/Log.h>
namespace android {
namespace hardware {
@@ -27,7 +28,7 @@
namespace implementation {
DrmFactory::DrmFactory() :
- loader("/vendor/lib/mediadrm", "createDrmFactory") {
+ loader(getDrmPluginPath(), "createDrmFactory") {
}
// Methods from ::android::hardware::drm::V1_0::IDrmFactory follow.
diff --git a/drm/1.0/default/DrmPlugin.cpp b/drm/1.0/default/DrmPlugin.cpp
index c7428a5..1695ef7 100644
--- a/drm/1.0/default/DrmPlugin.cpp
+++ b/drm/1.0/default/DrmPlugin.cpp
@@ -70,15 +70,15 @@
if (status == android::OK) {
android::KeyedVector<String8, String8> legacyOptionalParameters;
for (size_t i = 0; i < optionalParameters.size(); i++) {
- legacyOptionalParameters.add(String8(optionalParameters[i].key),
- String8(optionalParameters[i].value));
+ legacyOptionalParameters.add(String8(optionalParameters[i].key.c_str()),
+ String8(optionalParameters[i].value.c_str()));
}
android::DrmPlugin::KeyRequestType legacyRequestType =
android::DrmPlugin::kKeyRequestType_Unknown;
status = mLegacyPlugin->getKeyRequest(toVector(scope),
- toVector(initData), String8(mimeType), legacyKeyType,
+ toVector(initData), String8(mimeType.c_str()), legacyKeyType,
legacyOptionalParameters, legacyRequest, defaultUrl,
&legacyRequestType);
@@ -149,7 +149,7 @@
Vector<uint8_t> legacyRequest;
String8 legacyDefaultUrl;
status_t status = mLegacyPlugin->getProvisionRequest(
- String8(certificateType), String8(certificateAuthority),
+ String8(certificateType.c_str()), String8(certificateAuthority.c_str()),
legacyRequest, legacyDefaultUrl);
_hidl_cb(toStatus(status), toHidlVec(legacyRequest),
@@ -217,7 +217,7 @@
getPropertyString_cb _hidl_cb) {
String8 legacyValue;
status_t status = mLegacyPlugin->getPropertyString(
- String8(propertyName), legacyValue);
+ String8(propertyName.c_str()), legacyValue);
_hidl_cb(toStatus(status), legacyValue.string());
return Void();
}
@@ -226,7 +226,7 @@
getPropertyByteArray_cb _hidl_cb) {
Vector<uint8_t> legacyValue;
status_t status = mLegacyPlugin->getPropertyByteArray(
- String8(propertyName), legacyValue);
+ String8(propertyName.c_str()), legacyValue);
_hidl_cb(toStatus(status), toHidlVec(legacyValue));
return Void();
}
@@ -234,15 +234,15 @@
Return<Status> DrmPlugin::setPropertyString(const hidl_string& propertyName,
const hidl_string& value) {
status_t legacyStatus =
- mLegacyPlugin->setPropertyString(String8(propertyName),
- String8(value));
+ mLegacyPlugin->setPropertyString(String8(propertyName.c_str()),
+ String8(value.c_str()));
return toStatus(legacyStatus);
}
Return<Status> DrmPlugin::setPropertyByteArray(
const hidl_string& propertyName, const hidl_vec<uint8_t>& value) {
status_t legacyStatus =
- mLegacyPlugin->setPropertyByteArray(String8(propertyName),
+ mLegacyPlugin->setPropertyByteArray(String8(propertyName.c_str()),
toVector(value));
return toStatus(legacyStatus);
}
@@ -251,7 +251,7 @@
const hidl_vec<uint8_t>& sessionId, const hidl_string& algorithm) {
status_t legacyStatus =
mLegacyPlugin->setCipherAlgorithm(toVector(sessionId),
- String8(algorithm));
+ String8(algorithm.c_str()));
return toStatus(legacyStatus);
}
@@ -259,7 +259,7 @@
const hidl_vec<uint8_t>& sessionId, const hidl_string& algorithm) {
status_t legacyStatus =
mLegacyPlugin->setMacAlgorithm(toVector(sessionId),
- String8(algorithm));
+ String8(algorithm.c_str()));
return toStatus(legacyStatus);
}
@@ -313,7 +313,7 @@
Vector<uint8_t> legacySignature;
status_t status = mLegacyPlugin->signRSA(toVector(sessionId),
- String8(algorithm), toVector(message), toVector(wrappedKey),
+ String8(algorithm.c_str()), toVector(message), toVector(wrappedKey),
legacySignature);
_hidl_cb(toStatus(status), toHidlVec(legacySignature));
return Void();
@@ -327,19 +327,25 @@
Return<void> DrmPlugin::sendEvent(EventType eventType,
const hidl_vec<uint8_t>& sessionId, const hidl_vec<uint8_t>& data) {
- mListener->sendEvent(eventType, sessionId, data);
+ if (mListener != nullptr) {
+ mListener->sendEvent(eventType, sessionId, data);
+ }
return Void();
}
Return<void> DrmPlugin::sendExpirationUpdate(
const hidl_vec<uint8_t>& sessionId, int64_t expiryTimeInMS) {
- mListener->sendExpirationUpdate(sessionId, expiryTimeInMS);
+ if (mListener != nullptr) {
+ mListener->sendExpirationUpdate(sessionId, expiryTimeInMS);
+ }
return Void();
}
Return<void> DrmPlugin::sendKeysChange(const hidl_vec<uint8_t>& sessionId,
const hidl_vec<KeyStatus>& keyStatusList, bool hasNewUsableKey) {
- mListener->sendKeysChange(sessionId, keyStatusList, hasNewUsableKey);
+ if (mListener != nullptr) {
+ mListener->sendKeysChange(sessionId, keyStatusList, hasNewUsableKey);
+ }
return Void();
}
diff --git a/drm/1.0/default/LegacyPluginPath.cpp b/drm/1.0/default/LegacyPluginPath.cpp
new file mode 100644
index 0000000..369059d
--- /dev/null
+++ b/drm/1.0/default/LegacyPluginPath.cpp
@@ -0,0 +1,39 @@
+/*
+ * Copyright (C) 2017 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.
+ */
+
+#include "LegacyPluginPath.h"
+
+#include <cutils/properties.h>
+
+namespace android {
+namespace hardware {
+namespace drm {
+namespace V1_0 {
+namespace implementation {
+
+const char* getDrmPluginPath() {
+ if (property_get_bool("drm.64bit.enabled", false)) {
+ return "/vendor/lib64/mediadrm";
+ } else {
+ return "/vendor/lib/mediadrm";
+ }
+}
+
+} // namespace implementation
+} // namespace V1_0
+} // namespace drm
+} // namespace hardware
+} // namespace android
diff --git a/drm/1.0/default/LegacyPluginPath.h b/drm/1.0/default/LegacyPluginPath.h
new file mode 100644
index 0000000..7145f2e
--- /dev/null
+++ b/drm/1.0/default/LegacyPluginPath.h
@@ -0,0 +1,35 @@
+/*
+ * Copyright (C) 2017 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.
+ */
+
+#ifndef LEGACY_PLUGIN_PATH_H_
+
+#define LEGACY_PLUGIN_PATH_H_
+
+namespace android {
+namespace hardware {
+namespace drm {
+namespace V1_0 {
+namespace implementation {
+
+const char* getDrmPluginPath();
+
+} // namespace implementation
+} // namespace V1_0
+} // namespace drm
+} // namespace hardware
+} // namespace android
+
+#endif // LEGACY_PLUGIN_PATH_H_
diff --git a/drm/1.0/vts/functional/Android.bp b/drm/1.0/vts/functional/Android.bp
index 546aa12..43ea372 100644
--- a/drm/1.0/vts/functional/Android.bp
+++ b/drm/1.0/vts/functional/Android.bp
@@ -15,7 +15,7 @@
//
cc_test {
- name: "drm_hidl_test",
+ name: "VtsHalDrmV1_0TargetTest",
srcs: [
"drm_hal_clearkey_test.cpp",
"drm_hal_vendor_test.cpp",
@@ -34,6 +34,8 @@
"libhwbinder",
"liblog",
"libnativehelper",
+ "libssl",
+ "libcrypto",
"libutils",
],
static_libs: [
diff --git a/drm/1.0/vts/functional/drm_hal_clearkey_test.cpp b/drm/1.0/vts/functional/drm_hal_clearkey_test.cpp
index 2296d2d..e97ac10 100644
--- a/drm/1.0/vts/functional/drm_hal_clearkey_test.cpp
+++ b/drm/1.0/vts/functional/drm_hal_clearkey_test.cpp
@@ -26,6 +26,8 @@
#include <gtest/gtest.h>
#include <hidl/HidlSupport.h>
#include <hidlmemory/mapping.h>
+#include <log/log.h>
+#include <openssl/aes.h>
#include <memory>
#include <random>
@@ -125,6 +127,39 @@
}
/**
+ * Ensure the factory doesn't support an empty UUID
+ */
+TEST_F(DrmHalClearkeyFactoryTest, EmptyPluginUUIDNotSupported) {
+ hidl_array<uint8_t, 16> emptyUUID;
+ EXPECT_FALSE(drmFactory->isCryptoSchemeSupported(emptyUUID));
+ EXPECT_FALSE(cryptoFactory->isCryptoSchemeSupported(emptyUUID));
+}
+
+/**
+ * Ensure empty content type is not supported
+ */
+TEST_F(DrmHalClearkeyFactoryTest, EmptyContentTypeNotSupported) {
+ hidl_string empty;
+ EXPECT_FALSE(drmFactory->isContentTypeSupported(empty));
+}
+
+/**
+ * Ensure invalid content type is not supported
+ */
+TEST_F(DrmHalClearkeyFactoryTest, InvalidContentTypeNotSupported) {
+ hidl_string invalid("abcdabcd");
+ EXPECT_FALSE(drmFactory->isContentTypeSupported(invalid));
+}
+
+/**
+ * Ensure valid content type is supported
+ */
+TEST_F(DrmHalClearkeyFactoryTest, ValidContentTypeSupported) {
+ hidl_string cencType("cenc");
+ EXPECT_TRUE(drmFactory->isContentTypeSupported(cencType));
+}
+
+/**
* Ensure clearkey drm plugin can be created
*/
TEST_F(DrmHalClearkeyFactoryTest, CreateClearKeyDrmPlugin) {
@@ -418,6 +453,26 @@
}
/**
+ * Test that a removeKeys on an empty sessionID returns BAD_VALUE
+ */
+TEST_F(DrmHalClearkeyPluginTest, RemoveKeysEmptySessionId) {
+ SessionId sessionId;
+ Status status = drmPlugin->removeKeys(sessionId);
+ EXPECT_TRUE(status == Status::BAD_VALUE);
+}
+
+/**
+ * Remove keys is not supported for clearkey.
+ */
+TEST_F(DrmHalClearkeyPluginTest, RemoveKeysNewSession) {
+ SessionId sessionId = openSession();
+ Status status = drmPlugin->removeKeys(sessionId);
+ // Clearkey plugin doesn't support remove keys
+ EXPECT_EQ(Status::ERROR_DRM_CANNOT_HANDLE, status);
+ closeSession(sessionId);
+}
+
+/**
* Test that the clearkey plugin doesn't support getting
* secure stops.
*/
@@ -617,7 +672,7 @@
;
hidl_vec<uint8_t> keyId = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1};
hidl_vec<uint8_t> input = {1, 2, 3, 4, 5};
- hidl_vec<uint8_t> iv = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+ hidl_vec<uint8_t> iv = std::vector<uint8_t>(AES_BLOCK_SIZE, 0);
auto res = drmPlugin->encrypt(session, keyId, input, iv,
[&](Status status, const hidl_vec<uint8_t>&) {
EXPECT_EQ(Status::ERROR_DRM_CANNOT_HANDLE,
@@ -629,10 +684,9 @@
TEST_F(DrmHalClearkeyPluginTest, GenericDecryptNotSupported) {
SessionId session = openSession();
- ;
hidl_vec<uint8_t> keyId = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1};
hidl_vec<uint8_t> input = {1, 2, 3, 4, 5};
- hidl_vec<uint8_t> iv = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+ hidl_vec<uint8_t> iv = std::vector<uint8_t>(AES_BLOCK_SIZE, 0);
auto res = drmPlugin->decrypt(session, keyId, input, iv,
[&](Status status, const hidl_vec<uint8_t>&) {
EXPECT_EQ(Status::ERROR_DRM_CANNOT_HANDLE,
@@ -763,6 +817,17 @@
}
/**
+ * setMediaDrmSession with an empty session id: BAD_VALUE. An
+ * empty session clears the previously set session and should
+ * return OK.
+ */
+TEST_F(DrmHalClearkeyPluginTest, SetMediaDrmSessionEmptySession) {
+ SessionId sessionId;
+ Status status = cryptoPlugin->setMediaDrmSession(sessionId);
+ EXPECT_EQ(Status::OK, status);
+}
+
+/**
* Decrypt tests
*/
@@ -771,9 +836,15 @@
void loadKeys(const SessionId& sessionId);
void fillRandom(const sp<IMemory>& memory);
hidl_array<uint8_t, 16> toHidlArray(const vector<uint8_t>& vec) {
- EXPECT_EQ(vec.size(), 16u);
+ EXPECT_EQ(16u, vec.size());
return hidl_array<uint8_t, 16>(&vec[0]);
}
+ uint32_t decrypt(Mode mode, uint8_t* iv, const hidl_vec<SubSample>& subSamples,
+ const Pattern& pattern, Status status);
+ void aes_ctr_decrypt(uint8_t* dest, uint8_t* src, uint8_t* iv,
+ const hidl_vec<SubSample>& subSamples, const vector<uint8_t>& key);
+ void aes_cbc_decrypt(uint8_t* dest, uint8_t* src, uint8_t* iv,
+ const hidl_vec<SubSample>& subSamples, const vector<uint8_t>& key);
};
/**
@@ -847,36 +918,162 @@
}
}
-/**
- * Positive decrypt test. "Decrypt" a single clear
- * segment. Verify data matches.
- */
-TEST_F(DrmHalClearkeyDecryptTest, ClearSegmentTest) {
- const size_t kSegmentSize = 1024;
+uint32_t DrmHalClearkeyDecryptTest::decrypt(Mode mode,
+ uint8_t* iv, const hidl_vec<SubSample>& subSamples,
+ const Pattern& pattern, Status expectedStatus) {
const size_t kSegmentIndex = 0;
const vector<uint8_t> keyId = {0x60, 0x06, 0x1e, 0x01, 0x7e, 0x47,
0x7e, 0x87, 0x7e, 0x57, 0xd0, 0x0d,
0x1e, 0xd0, 0x0d, 0x1e};
- uint8_t iv[16] = {0};
+ const vector<uint8_t> contentKey = {0x1a, 0x8a, 0x20, 0x95, 0xe4,
+ 0xde, 0xb2, 0xd2, 0x9e, 0xc8,
+ 0x16, 0xac, 0x7b, 0xae, 0x20, 0x82};
+ uint8_t localIv[AES_BLOCK_SIZE];
+ memcpy(localIv, iv, AES_BLOCK_SIZE);
+ size_t totalSize = 0;
+ for (size_t i = 0; i < subSamples.size(); i++) {
+ totalSize += subSamples[i].numBytesOfClearData;
+ totalSize += subSamples[i].numBytesOfEncryptedData;
+ }
+
+ // The first totalSize bytes of shared memory is the encrypted
+ // input, the second totalSize bytes is the decrypted output.
sp<IMemory> sharedMemory =
- getDecryptMemory(kSegmentSize * 2, kSegmentIndex);
+ getDecryptMemory(totalSize * 2, kSegmentIndex);
- SharedBuffer sourceBuffer = {
- .bufferId = kSegmentIndex, .offset = 0, .size = kSegmentSize};
+ const SharedBuffer sourceBuffer = {
+ .bufferId = kSegmentIndex, .offset = 0, .size = totalSize};
fillRandom(sharedMemory);
- DestinationBuffer destBuffer = {.type = BufferType::SHARED_MEMORY,
- {.bufferId = kSegmentIndex,
- .offset = kSegmentSize,
- .size = kSegmentSize},
- .secureMemory = nullptr};
+ const DestinationBuffer destBuffer = {.type = BufferType::SHARED_MEMORY,
+ {.bufferId = kSegmentIndex,
+ .offset = totalSize,
+ .size = totalSize},
+ .secureMemory = nullptr};
+ const uint64_t offset = 0;
+ const bool kNotSecure = false;
+ uint32_t bytesWritten = 0;
+ auto res = cryptoPlugin->decrypt(kNotSecure, toHidlArray(keyId), localIv, mode,
+ pattern, subSamples, sourceBuffer, offset, destBuffer,
+ [&](Status status, uint32_t count, string detailedError) {
+ EXPECT_EQ(expectedStatus, status) << "Unexpected decrypt status " <<
+ detailedError;
+ bytesWritten = count;
+ });
+ EXPECT_OK(res);
- Pattern noPattern = {0, 0};
- vector<SubSample> subSamples = {{.numBytesOfClearData = kSegmentSize,
- .numBytesOfEncryptedData = 0}};
- uint64_t offset = 0;
+ if (bytesWritten != totalSize) {
+ return bytesWritten;
+ }
+ uint8_t* base = static_cast<uint8_t*>(
+ static_cast<void*>(sharedMemory->getPointer()));
+ // generate reference vector
+ vector<uint8_t> reference(totalSize);
+
+ memcpy(localIv, iv, AES_BLOCK_SIZE);
+ switch (mode) {
+ case Mode::UNENCRYPTED:
+ memcpy(&reference[0], base, totalSize);
+ break;
+ case Mode::AES_CTR:
+ aes_ctr_decrypt(&reference[0], base, localIv, subSamples, contentKey);
+ break;
+ case Mode::AES_CBC:
+ aes_cbc_decrypt(&reference[0], base, localIv, subSamples, contentKey);
+ break;
+ case Mode::AES_CBC_CTS:
+ EXPECT_TRUE(false) << "AES_CBC_CTS mode not supported";
+ break;
+ }
+
+ // compare reference to decrypted data which is at base + total size
+ EXPECT_EQ(0, memcmp(static_cast<void *>(&reference[0]),
+ static_cast<void*>(base + totalSize), totalSize))
+ << "decrypt data mismatch";
+ return totalSize;
+}
+
+/**
+ * Decrypt a list of clear+encrypted subsamples using the specified key
+ * in AES-CTR mode
+ */
+void DrmHalClearkeyDecryptTest::aes_ctr_decrypt(uint8_t* dest, uint8_t* src,
+ uint8_t* iv, const hidl_vec<SubSample>& subSamples,
+ const vector<uint8_t>& key) {
+ AES_KEY decryptionKey;
+ AES_set_encrypt_key(&key[0], 128, &decryptionKey);
+
+ size_t offset = 0;
+ unsigned int blockOffset = 0;
+ uint8_t previousEncryptedCounter[AES_BLOCK_SIZE];
+ memset(previousEncryptedCounter, 0, AES_BLOCK_SIZE);
+
+ for (size_t i = 0; i < subSamples.size(); i++) {
+ const SubSample& subSample = subSamples[i];
+
+ if (subSample.numBytesOfClearData > 0) {
+ memcpy(dest + offset, src + offset, subSample.numBytesOfClearData);
+ offset += subSample.numBytesOfClearData;
+ }
+
+ if (subSample.numBytesOfEncryptedData > 0) {
+ AES_ctr128_encrypt(src + offset, dest + offset,
+ subSample.numBytesOfEncryptedData, &decryptionKey,
+ iv, previousEncryptedCounter, &blockOffset);
+ offset += subSample.numBytesOfEncryptedData;
+ }
+ }
+}
+
+/**
+ * Decrypt a list of clear+encrypted subsamples using the specified key
+ * in AES-CBC mode
+ */
+void DrmHalClearkeyDecryptTest::aes_cbc_decrypt(uint8_t* dest, uint8_t* src,
+ uint8_t* iv, const hidl_vec<SubSample>& subSamples,
+ const vector<uint8_t>& key) {
+ AES_KEY decryptionKey;
+ AES_set_encrypt_key(&key[0], 128, &decryptionKey);
+
+ size_t offset = 0;
+ size_t num = 0;
+ size_t ecount_buf = 0;
+ for (size_t i = 0; i < subSamples.size(); i++) {
+ memcpy(dest + offset, src + offset, subSamples[i].numBytesOfClearData);
+ offset += subSamples[i].numBytesOfClearData;
+
+ AES_cbc_encrypt(src + offset, dest + offset, subSamples[i].numBytesOfEncryptedData,
+ &decryptionKey, iv, 0 /* decrypt */);
+ offset += subSamples[i].numBytesOfEncryptedData;
+ }
+}
+
+/**
+ * Test query key status
+ */
+TEST_F(DrmHalClearkeyDecryptTest, TestQueryKeyStatus) {
+ auto sessionId = openSession();
+ auto res = drmPlugin->queryKeyStatus(sessionId,
+ [&](Status status, KeyedVector /* info */) {
+ // clearkey doesn't support this method
+ EXPECT_EQ(Status::ERROR_DRM_CANNOT_HANDLE, status);
+ });
+ EXPECT_OK(res);
+}
+
+
+/**
+ * Positive decrypt test. "Decrypt" a single clear segment
+ */
+TEST_F(DrmHalClearkeyDecryptTest, ClearSegmentTest) {
+ vector<uint8_t> iv(AES_BLOCK_SIZE, 0);
+ const Pattern noPattern = {0, 0};
+ const uint32_t kByteCount = 256;
+ const vector<SubSample> subSamples = {
+ {.numBytesOfClearData = kByteCount,
+ .numBytesOfEncryptedData = 0}};
auto sessionId = openSession();
loadKeys(sessionId);
@@ -884,21 +1081,57 @@
EXPECT_EQ(Status::OK, status);
const bool kNotSecure = false;
- auto res = cryptoPlugin->decrypt(
- kNotSecure, toHidlArray(keyId), iv, Mode::UNENCRYPTED, noPattern,
- subSamples, sourceBuffer, offset, destBuffer,
- [&](Status status, uint32_t bytesWritten, string detailedError) {
- EXPECT_EQ(Status::OK, status) << "Failure in decryption:"
- << detailedError;
- EXPECT_EQ(bytesWritten, kSegmentSize);
- });
- EXPECT_OK(res);
+ uint32_t byteCount = decrypt(Mode::UNENCRYPTED, &iv[0], subSamples,
+ noPattern, Status::OK);
+ EXPECT_EQ(kByteCount, byteCount);
- uint8_t* base = static_cast<uint8_t*>(
- static_cast<void*>(sharedMemory->getPointer()));
+ closeSession(sessionId);
+}
- EXPECT_EQ(0, memcmp(static_cast<void*>(base),
- static_cast<void*>(base + kSegmentSize), kSegmentSize))
- << "decrypt data mismatch";
+/**
+ * Positive decrypt test. Decrypt a single segment using AES_CTR.
+ * Verify data matches.
+ */
+TEST_F(DrmHalClearkeyDecryptTest, EncryptedAesCtrSegmentTest) {
+ vector<uint8_t> iv(AES_BLOCK_SIZE, 0);
+ const Pattern noPattern = {0, 0};
+ const uint32_t kClearBytes = 512;
+ const uint32_t kEncryptedBytes = 512;
+ const vector<SubSample> subSamples = {
+ {.numBytesOfClearData = kClearBytes,
+ .numBytesOfEncryptedData = kEncryptedBytes
+ }};
+ auto sessionId = openSession();
+ loadKeys(sessionId);
+
+ Status status = cryptoPlugin->setMediaDrmSession(sessionId);
+ EXPECT_EQ(Status::OK, status);
+
+ const bool kNotSecure = false;
+ uint32_t byteCount = decrypt(Mode::AES_CTR, &iv[0], subSamples,
+ noPattern, Status::OK);
+ EXPECT_EQ(kClearBytes + kEncryptedBytes, byteCount);
+
+ closeSession(sessionId);
+}
+/**
+ * Negative decrypt test. Decrypt without loading keys.
+ */
+TEST_F(DrmHalClearkeyDecryptTest, EncryptedAesCtrSegmentTestNoKeys) {
+ vector<uint8_t> iv(AES_BLOCK_SIZE, 0);
+ const Pattern noPattern = {0, 0};
+ const vector<SubSample> subSamples = {
+ {.numBytesOfClearData = 256,
+ .numBytesOfEncryptedData = 256}};
+ auto sessionId = openSession();
+
+ Status status = cryptoPlugin->setMediaDrmSession(sessionId);
+ EXPECT_EQ(Status::OK, status);
+
+ const bool kNotSecure = false;
+ uint32_t byteCount = decrypt(Mode::AES_CTR, &iv[0], subSamples,
+ noPattern, Status::ERROR_DRM_NO_LICENSE);
+ EXPECT_EQ(0u, byteCount);
+
closeSession(sessionId);
}
diff --git a/drm/1.0/vts/functional/drm_hal_vendor_module_api.h b/drm/1.0/vts/functional/drm_hal_vendor_module_api.h
index db19719..73e0cfe 100644
--- a/drm/1.0/vts/functional/drm_hal_vendor_module_api.h
+++ b/drm/1.0/vts/functional/drm_hal_vendor_module_api.h
@@ -73,21 +73,21 @@
* value with initial version 1. The API version indicates which subclass
* version DrmHalVTSVendorModule this instance is.
*/
- virtual uint32_t getAPIVersion() = 0;
+ virtual uint32_t getAPIVersion() const = 0;
/**
* Return the UUID for the DRM HAL implementation. Protection System
* Specific
* UUID (see http://dashif.org/identifiers/protection/)
*/
- virtual std::vector<uint8_t> getUUID() = 0;
+ virtual std::vector<uint8_t> getUUID() const = 0;
/**
* Return the service name for the DRM HAL implementation. If the hal is a
* legacy
* drm plugin, i.e. not running as a HIDL service, return the empty string.
*/
- virtual std::string getServiceName() = 0;
+ virtual std::string getServiceName() const = 0;
private:
DrmHalVTSVendorModule(const DrmHalVTSVendorModule&) = delete;
@@ -103,7 +103,7 @@
DrmHalVTSVendorModule_V1() {}
virtual ~DrmHalVTSVendorModule_V1() {}
- virtual uint32_t getAPIVersion() { return 1; }
+ virtual uint32_t getAPIVersion() const { return 1; }
/**
* Handle a provisioning request. This function will be called if the HAL
@@ -178,11 +178,10 @@
const std::vector<uint8_t> keyId;
/**
- * The key value is provided to generate expected values for
- * validating
- * decryption. If isSecure is false, no key value is required.
+ * The clear content key is provided to generate expected values for
+ * validating decryption.
*/
- const std::vector<uint8_t> keyValue;
+ const std::vector<uint8_t> clearContentKey;
};
std::vector<Key> keys;
};
@@ -191,7 +190,8 @@
* Return a list of content configurations that can be exercised by the
* VTS test.
*/
- virtual std::vector<ContentConfiguration> getContentConfigurations() = 0;
+ virtual std::vector<ContentConfiguration>
+ getContentConfigurations() const = 0;
/**
* Handle a key request. This function will be called if the HAL
diff --git a/drm/1.0/vts/functional/drm_hal_vendor_test.cpp b/drm/1.0/vts/functional/drm_hal_vendor_test.cpp
index dcfee4e..44675dc 100644
--- a/drm/1.0/vts/functional/drm_hal_vendor_test.cpp
+++ b/drm/1.0/vts/functional/drm_hal_vendor_test.cpp
@@ -21,27 +21,34 @@
#include <android/hardware/drm/1.0/ICryptoPlugin.h>
#include <android/hardware/drm/1.0/IDrmFactory.h>
#include <android/hardware/drm/1.0/IDrmPlugin.h>
+#include <android/hardware/drm/1.0/IDrmPluginListener.h>
#include <android/hardware/drm/1.0/types.h>
#include <android/hidl/allocator/1.0/IAllocator.h>
#include <gtest/gtest.h>
#include <hidlmemory/mapping.h>
+#include <log/log.h>
+#include <openssl/aes.h>
#include <memory>
#include <random>
-#include "VtsHalHidlTargetTestBase.h"
#include "drm_hal_vendor_module_api.h"
#include "vendor_modules.h"
+#include "VtsHalHidlTargetTestBase.h"
using ::android::hardware::drm::V1_0::BufferType;
using ::android::hardware::drm::V1_0::DestinationBuffer;
+using ::android::hardware::drm::V1_0::EventType;
using ::android::hardware::drm::V1_0::ICryptoFactory;
using ::android::hardware::drm::V1_0::ICryptoPlugin;
using ::android::hardware::drm::V1_0::IDrmFactory;
using ::android::hardware::drm::V1_0::IDrmPlugin;
+using ::android::hardware::drm::V1_0::IDrmPluginListener;
using ::android::hardware::drm::V1_0::KeyedVector;
-using ::android::hardware::drm::V1_0::KeyValue;
using ::android::hardware::drm::V1_0::KeyRequestType;
+using ::android::hardware::drm::V1_0::KeyStatus;
+using ::android::hardware::drm::V1_0::KeyStatusType;
using ::android::hardware::drm::V1_0::KeyType;
+using ::android::hardware::drm::V1_0::KeyValue;
using ::android::hardware::drm::V1_0::Mode;
using ::android::hardware::drm::V1_0::Pattern;
using ::android::hardware::drm::V1_0::SecureStop;
@@ -56,6 +63,7 @@
using ::android::hardware::hidl_string;
using ::android::hardware::hidl_vec;
using ::android::hardware::Return;
+using ::android::hardware::Void;
using ::android::hidl::allocator::V1_0::IAllocator;
using ::android::hidl::memory::V1_0::IMemory;
using ::android::sp;
@@ -67,6 +75,9 @@
using std::mt19937;
using std::vector;
+using ContentConfiguration = ::DrmHalVTSVendorModule_V1::ContentConfiguration;
+using Key = ::DrmHalVTSVendorModule_V1::ContentConfiguration::Key;
+
#define ASSERT_OK(ret) ASSERT_TRUE(ret.isOk())
#define EXPECT_OK(ret) EXPECT_TRUE(ret.isOk())
@@ -80,10 +91,9 @@
class DrmHalVendorFactoryTest : public testing::TestWithParam<std::string> {
public:
DrmHalVendorFactoryTest()
- : vendorModule(gVendorModules ? static_cast<DrmHalVTSVendorModule_V1*>(
- gVendorModules->getVendorModule(
- GetParam()))
- : nullptr) {}
+ : vendorModule(static_cast<DrmHalVTSVendorModule_V1*>(
+ gVendorModules->getModule(GetParam()))),
+ contentConfigurations(vendorModule->getContentConfigurations()) {}
virtual ~DrmHalVendorFactoryTest() {}
@@ -117,14 +127,27 @@
sp<IDrmFactory> drmFactory;
sp<ICryptoFactory> cryptoFactory;
unique_ptr<DrmHalVTSVendorModule_V1> vendorModule;
+ const vector<ContentConfiguration> contentConfigurations;
};
-/**
- * Ensure the factory supports its scheme UUID
- */
-TEST_P(DrmHalVendorFactoryTest, VendorPluginSupported) {
- EXPECT_TRUE(drmFactory->isCryptoSchemeSupported(getVendorUUID()));
- EXPECT_TRUE(cryptoFactory->isCryptoSchemeSupported(getVendorUUID()));
+TEST_P(DrmHalVendorFactoryTest, ValidateConfigurations) {
+ const char* kVendorStr = "Vendor module ";
+ for (auto config : contentConfigurations) {
+ ASSERT_TRUE(config.name.size() > 0) << kVendorStr << "has no name";
+ ASSERT_TRUE(config.serverUrl.size() > 0) << kVendorStr
+ << "has no serverUrl";
+ ASSERT_TRUE(config.initData.size() > 0) << kVendorStr
+ << "has no init data";
+ ASSERT_TRUE(config.mimeType.size() > 0) << kVendorStr
+ << "has no mime type";
+ ASSERT_TRUE(config.keys.size() >= 1) << kVendorStr << "has no keys";
+ for (auto key : config.keys) {
+ ASSERT_TRUE(key.keyId.size() > 0) << kVendorStr
+ << " has zero length keyId";
+ ASSERT_TRUE(key.keyId.size() > 0) << kVendorStr
+ << " has zero length key value";
+ }
+ }
}
/**
@@ -136,6 +159,48 @@
}
/**
+ * Ensure the factory doesn't support an empty UUID
+ */
+TEST_P(DrmHalVendorFactoryTest, EmptyPluginUUIDNotSupported) {
+ hidl_array<uint8_t, 16> emptyUUID;
+ EXPECT_FALSE(drmFactory->isCryptoSchemeSupported(emptyUUID));
+ EXPECT_FALSE(cryptoFactory->isCryptoSchemeSupported(emptyUUID));
+}
+
+/**
+ * Ensure the factory supports the scheme uuid in the config
+ */
+TEST_P(DrmHalVendorFactoryTest, EmptyPluginConfigUUIDSupported) {
+ EXPECT_TRUE(drmFactory->isCryptoSchemeSupported(getVendorUUID()));
+ EXPECT_TRUE(cryptoFactory->isCryptoSchemeSupported(getVendorUUID()));
+}
+
+/**
+ * Ensure empty content type is not supported
+ */
+TEST_P(DrmHalVendorFactoryTest, EmptyContentTypeNotSupported) {
+ hidl_string empty;
+ EXPECT_FALSE(drmFactory->isContentTypeSupported(empty));
+}
+
+/**
+ * Ensure invalid content type is not supported
+ */
+TEST_P(DrmHalVendorFactoryTest, InvalidContentTypeNotSupported) {
+ hidl_string invalid("abcdabcd");
+ EXPECT_FALSE(drmFactory->isContentTypeSupported(invalid));
+}
+
+/**
+ * Ensure valid content types in the configs are supported
+ */
+TEST_P(DrmHalVendorFactoryTest, ValidContentTypeSupported) {
+ for (auto config : contentConfigurations) {
+ EXPECT_TRUE(drmFactory->isContentTypeSupported(config.mimeType));
+ }
+}
+
+/**
* Ensure vendor drm plugin can be created
*/
TEST_P(DrmHalVendorFactoryTest, CreateVendorDrmPlugin) {
@@ -393,6 +458,26 @@
}
/**
+ * Test that a removeKeys on an empty sessionID returns BAD_VALUE
+ */
+TEST_P(DrmHalVendorPluginTest, RemoveKeysEmptySessionId) {
+ SessionId sessionId;
+ Status status = drmPlugin->removeKeys(sessionId);
+ EXPECT_TRUE(status == Status::BAD_VALUE);
+}
+
+/**
+ * Test that remove keys returns okay on an initialized session
+ * that has no keys.
+ */
+TEST_P(DrmHalVendorPluginTest, RemoveKeysNewSession) {
+ SessionId sessionId = openSession();
+ Status status = drmPlugin->removeKeys(sessionId);
+ EXPECT_TRUE(status == Status::OK);
+ closeSession(sessionId);
+}
+
+/**
* Test that the plugin either doesn't support getting
* secure stops, or has no secure stops available after
* clearing them.
@@ -722,6 +807,175 @@
}
/**
+ * Verify that requiresSecureDecoderComponent returns true for secure
+ * configurations
+ */
+TEST_P(DrmHalVendorPluginTest, RequiresSecureDecoderConfig) {
+ const char* kVendorStr = "Vendor module ";
+ for (auto config : contentConfigurations) {
+ for (auto key : config.keys) {
+ if (key.isSecure) {
+ EXPECT_TRUE(cryptoPlugin->requiresSecureDecoderComponent(config.mimeType));
+ break;
+ }
+ }
+ }
+}
+
+/**
+ * Event Handling tests
+ */
+
+class TestDrmPluginListener : public IDrmPluginListener {
+public:
+ TestDrmPluginListener() {reset();}
+ virtual ~TestDrmPluginListener() {}
+
+ virtual Return<void> sendEvent(EventType eventType, const hidl_vec<uint8_t>& sessionId,
+ const hidl_vec<uint8_t>& data) override {
+ eventType_ = eventType;
+ sessionId_ = sessionId;
+ data_ = data;
+ gotEvent_ = true;
+ return Void();
+ }
+
+ virtual Return<void> sendExpirationUpdate(const hidl_vec<uint8_t>& sessionId,
+ int64_t expiryTimeInMS) override {
+ sessionId_ = sessionId;
+ expiryTimeInMS_ = expiryTimeInMS;
+ gotExpirationUpdate_ = true;
+ return Void();
+ }
+
+ virtual Return<void> sendKeysChange(const hidl_vec<uint8_t>& sessionId,
+ const hidl_vec<KeyStatus>& keyStatusList, bool hasNewUsableKey) override {
+ sessionId_ = sessionId;
+ keyStatusList_ = keyStatusList;
+ hasNewUsableKey_ = hasNewUsableKey;
+ gotKeysChange_ = true;
+ return Void();
+ }
+
+ EventType getEventType() const {return eventType_;}
+ SessionId getSessionId() const {return sessionId_;}
+ vector<uint8_t> getData() const {return data_;}
+ int64_t getExpiryTimeInMS() const {return expiryTimeInMS_;}
+ hidl_vec<KeyStatus> getKeyStatusList() const {return keyStatusList_;}
+ bool hasNewUsableKey() {return hasNewUsableKey_;}
+ bool gotEvent() {return gotEvent_;}
+ bool gotExpirationUpdate() {return gotExpirationUpdate_;}
+ bool gotKeysChange() {return gotKeysChange_;}
+
+ void reset() {
+ gotEvent_ = gotExpirationUpdate_ = gotKeysChange_ = false;
+ eventType_ = EventType::PROVISION_REQUIRED;
+ sessionId_ = SessionId();
+ data_ = hidl_vec<uint8_t>();
+ expiryTimeInMS_ = 0;
+ keyStatusList_ = hidl_vec<KeyStatus>();
+ hasNewUsableKey_ = false;
+ }
+
+private:
+ bool gotEvent_;
+ bool gotExpirationUpdate_;
+ bool gotKeysChange_;
+
+ EventType eventType_;
+ SessionId sessionId_;
+ hidl_vec<uint8_t> data_;
+ int64_t expiryTimeInMS_;
+ hidl_vec<KeyStatus> keyStatusList_;
+ bool hasNewUsableKey_;
+};
+
+/**
+ * Simulate the plugin sending events. Make sure the listener
+ * gets them.
+ */
+TEST_P(DrmHalVendorPluginTest, ListenerEvents) {
+ sp<TestDrmPluginListener> listener = new TestDrmPluginListener();
+ drmPlugin->setListener(listener);
+ auto sessionId = openSession();
+ vector<uint8_t> data = {0, 1, 2};
+ EventType eventTypes[] = {EventType::PROVISION_REQUIRED,
+ EventType::KEY_NEEDED,
+ EventType::KEY_EXPIRED,
+ EventType::VENDOR_DEFINED,
+ EventType::SESSION_RECLAIMED};
+ for (auto eventType : eventTypes) {
+ listener->reset();
+ drmPlugin->sendEvent(eventType, sessionId, data);
+ while (!listener->gotEvent()) {usleep(100);}
+ EXPECT_EQ(eventType, listener->getEventType());
+ EXPECT_EQ(sessionId, listener->getSessionId());
+ EXPECT_EQ(data, listener->getData());
+ }
+ closeSession(sessionId);
+}
+
+/**
+ * Simulate the plugin sending expiration updates and make sure
+ * the listener gets them.
+ */
+TEST_P(DrmHalVendorPluginTest, ListenerExpirationUpdate) {
+ sp<TestDrmPluginListener> listener = new TestDrmPluginListener();
+ drmPlugin->setListener(listener);
+ auto sessionId = openSession();
+ drmPlugin->sendExpirationUpdate(sessionId, 100);
+ while (!listener->gotExpirationUpdate()) {usleep(100);}
+ EXPECT_EQ(sessionId, listener->getSessionId());
+ EXPECT_EQ(100, listener->getExpiryTimeInMS());
+ closeSession(sessionId);
+}
+
+/**
+ * Simulate the plugin sending keys change and make sure
+ * the listener gets them.
+ */
+TEST_P(DrmHalVendorPluginTest, ListenerKeysChange) {
+ sp<TestDrmPluginListener> listener = new TestDrmPluginListener();
+ drmPlugin->setListener(listener);
+ auto sessionId = openSession();
+ const hidl_vec<KeyStatus> keyStatusList = {
+ {{1}, KeyStatusType::USABLE},
+ {{2}, KeyStatusType::EXPIRED},
+ {{3}, KeyStatusType::OUTPUTNOTALLOWED},
+ {{4}, KeyStatusType::STATUSPENDING},
+ {{5}, KeyStatusType::INTERNALERROR},
+ };
+
+ drmPlugin->sendKeysChange(sessionId, keyStatusList, true);
+ while (!listener->gotKeysChange()) {usleep(100);}
+ EXPECT_EQ(sessionId, listener->getSessionId());
+ EXPECT_EQ(keyStatusList, listener->getKeyStatusList());
+ EXPECT_EQ(true, listener->hasNewUsableKey());
+}
+
+/**
+ * Negative listener tests. Call send methods with no
+ * listener set.
+ */
+TEST_P(DrmHalVendorPluginTest, NotListening) {
+ sp<TestDrmPluginListener> listener = new TestDrmPluginListener();
+ drmPlugin->setListener(listener);
+ drmPlugin->setListener(nullptr);
+
+ SessionId sessionId;
+ vector<uint8_t> data;
+ hidl_vec<KeyStatus> keyStatusList;
+ drmPlugin->sendEvent(EventType::PROVISION_REQUIRED, sessionId, data);
+ drmPlugin->sendExpirationUpdate(sessionId, 100);
+ drmPlugin->sendKeysChange(sessionId, keyStatusList, true);
+ usleep(1000); // can't wait for the event to be recieved, just wait a long time
+ EXPECT_EQ(false, listener->gotEvent());
+ EXPECT_EQ(false, listener->gotExpirationUpdate());
+ EXPECT_EQ(false, listener->gotKeysChange());
+}
+
+
+/**
* CryptoPlugin tests
*/
@@ -786,6 +1040,15 @@
}
/**
+ * setMediaDrmSession with a empty session id: BAD_VALUE
+ */
+TEST_P(DrmHalVendorPluginTest, SetMediaDrmSessionEmptySession) {
+ SessionId sessionId;
+ Status status = cryptoPlugin->setMediaDrmSession(sessionId);
+ EXPECT_EQ(Status::BAD_VALUE, status);
+}
+
+/**
* Decrypt tests
*/
@@ -796,14 +1059,23 @@
protected:
void loadKeys(const SessionId& sessionId,
- const DrmHalVTSVendorModule_V1::ContentConfiguration&
- configuration);
+ const ContentConfiguration& configuration);
void fillRandom(const sp<IMemory>& memory);
KeyedVector toHidlKeyedVector(const map<string, string>& params);
hidl_array<uint8_t, 16> toHidlArray(const vector<uint8_t>& vec) {
EXPECT_EQ(vec.size(), 16u);
return hidl_array<uint8_t, 16>(&vec[0]);
}
+ hidl_vec<KeyValue> queryKeyStatus(SessionId sessionId);
+ void removeKeys(SessionId sessionId);
+ uint32_t decrypt(Mode mode, bool isSecure,
+ const hidl_array<uint8_t, 16>& keyId, uint8_t* iv,
+ const hidl_vec<SubSample>& subSamples, const Pattern& pattern,
+ const vector<uint8_t>& key, Status expectedStatus);
+ void aes_ctr_decrypt(uint8_t* dest, uint8_t* src, uint8_t* iv,
+ const hidl_vec<SubSample>& subSamples, const vector<uint8_t>& key);
+ void aes_cbc_decrypt(uint8_t* dest, uint8_t* src, uint8_t* iv,
+ const hidl_vec<SubSample>& subSamples, const vector<uint8_t>& key);
};
KeyedVector DrmHalVendorDecryptTest::toHidlKeyedVector(
@@ -823,9 +1095,8 @@
* These tests use predetermined key request/response to
* avoid requiring a round trip to a license server.
*/
-void DrmHalVendorDecryptTest::loadKeys(
- const SessionId& sessionId,
- const DrmHalVTSVendorModule_V1::ContentConfiguration& configuration) {
+void DrmHalVendorDecryptTest::loadKeys(const SessionId& sessionId,
+ const ContentConfiguration& configuration) {
hidl_vec<uint8_t> keyRequest;
auto res = drmPlugin->getKeyRequest(
sessionId, configuration.initData, configuration.mimeType,
@@ -874,107 +1145,326 @@
}
}
-TEST_P(DrmHalVendorDecryptTest, ValidateConfigurations) {
- vector<DrmHalVTSVendorModule_V1::ContentConfiguration> configurations =
- vendorModule->getContentConfigurations();
- const char* kVendorStr = "Vendor module ";
- for (auto config : configurations) {
- ASSERT_TRUE(config.name.size() > 0) << kVendorStr << "has no name";
- ASSERT_TRUE(config.serverUrl.size() > 0) << kVendorStr
- << "has no serverUrl";
- ASSERT_TRUE(config.initData.size() > 0) << kVendorStr
- << "has no init data";
- ASSERT_TRUE(config.mimeType.size() > 0) << kVendorStr
- << "has no mime type";
- ASSERT_TRUE(config.keys.size() >= 1) << kVendorStr << "has no keys";
- for (auto key : config.keys) {
- ASSERT_TRUE(key.keyId.size() > 0) << kVendorStr
- << " has zero length keyId";
- ASSERT_TRUE(key.keyId.size() > 0) << kVendorStr
- << " has zero length key value";
+hidl_vec<KeyValue> DrmHalVendorDecryptTest::queryKeyStatus(SessionId sessionId) {
+ hidl_vec<KeyValue> keyStatus;
+ auto res = drmPlugin->queryKeyStatus(sessionId,
+ [&](Status status, KeyedVector info) {
+ EXPECT_EQ(Status::OK, status);
+ keyStatus = info;
+ });
+ EXPECT_OK(res);
+ return keyStatus;
+}
+
+void DrmHalVendorDecryptTest::removeKeys(SessionId sessionId) {
+ auto res = drmPlugin->removeKeys(sessionId);
+ EXPECT_OK(res);
+}
+
+uint32_t DrmHalVendorDecryptTest::decrypt(Mode mode, bool isSecure,
+ const hidl_array<uint8_t, 16>& keyId, uint8_t* iv,
+ const hidl_vec<SubSample>& subSamples, const Pattern& pattern,
+ const vector<uint8_t>& key, Status expectedStatus) {
+ const size_t kSegmentIndex = 0;
+
+ uint8_t localIv[AES_BLOCK_SIZE];
+ memcpy(localIv, iv, AES_BLOCK_SIZE);
+
+ size_t totalSize = 0;
+ for (size_t i = 0; i < subSamples.size(); i++) {
+ totalSize += subSamples[i].numBytesOfClearData;
+ totalSize += subSamples[i].numBytesOfEncryptedData;
+ }
+
+ // The first totalSize bytes of shared memory is the encrypted
+ // input, the second totalSize bytes is the decrypted output.
+ sp<IMemory> sharedMemory =
+ getDecryptMemory(totalSize * 2, kSegmentIndex);
+
+ SharedBuffer sourceBuffer = {
+ .bufferId = kSegmentIndex, .offset = 0, .size = totalSize};
+ fillRandom(sharedMemory);
+
+ DestinationBuffer destBuffer = {.type = BufferType::SHARED_MEMORY,
+ {.bufferId = kSegmentIndex,
+ .offset = totalSize,
+ .size = totalSize},
+ .secureMemory = nullptr};
+ uint64_t offset = 0;
+ uint32_t bytesWritten = 0;
+ auto res = cryptoPlugin->decrypt(isSecure, keyId, localIv, mode, pattern,
+ subSamples, sourceBuffer, offset, destBuffer,
+ [&](Status status, uint32_t count, string detailedError) {
+ EXPECT_EQ(expectedStatus, status) << "Unexpected decrypt status " <<
+ detailedError;
+ bytesWritten = count;
+ });
+ EXPECT_OK(res);
+
+ if (bytesWritten != totalSize) {
+ return bytesWritten;
+ }
+ uint8_t* base = static_cast<uint8_t*>(
+ static_cast<void*>(sharedMemory->getPointer()));
+
+ // generate reference vector
+ vector<uint8_t> reference(totalSize);
+
+ memcpy(localIv, iv, AES_BLOCK_SIZE);
+ switch (mode) {
+ case Mode::UNENCRYPTED:
+ memcpy(&reference[0], base, totalSize);
+ break;
+ case Mode::AES_CTR:
+ aes_ctr_decrypt(&reference[0], base, localIv, subSamples, key);
+ break;
+ case Mode::AES_CBC:
+ aes_cbc_decrypt(&reference[0], base, localIv, subSamples, key);
+ break;
+ case Mode::AES_CBC_CTS:
+ EXPECT_TRUE(false) << "AES_CBC_CTS mode not supported";
+ break;
+ }
+
+ // compare reference to decrypted data which is at base + total size
+ EXPECT_EQ(0, memcmp(static_cast<void*>(&reference[0]),
+ static_cast<void*>(base + totalSize), totalSize))
+ << "decrypt data mismatch";
+ return totalSize;
+}
+
+/**
+ * Decrypt a list of clear+encrypted subsamples using the specified key
+ * in AES-CTR mode
+ */
+void DrmHalVendorDecryptTest::aes_ctr_decrypt(uint8_t* dest, uint8_t* src,
+ uint8_t* iv, const hidl_vec<SubSample>& subSamples,
+ const vector<uint8_t>& key) {
+
+ AES_KEY decryptionKey;
+ AES_set_encrypt_key(&key[0], 128, &decryptionKey);
+
+ size_t offset = 0;
+ unsigned blockOffset = 0;
+ uint8_t previousEncryptedCounter[AES_BLOCK_SIZE];
+ memset(previousEncryptedCounter, 0, AES_BLOCK_SIZE);
+
+ for (size_t i = 0; i < subSamples.size(); i++) {
+ const SubSample& subSample = subSamples[i];
+
+ if (subSample.numBytesOfClearData > 0) {
+ memcpy(dest + offset, src + offset, subSample.numBytesOfClearData);
+ offset += subSample.numBytesOfClearData;
+ }
+
+ if (subSample.numBytesOfEncryptedData > 0) {
+ AES_ctr128_encrypt(src + offset, dest + offset,
+ subSample.numBytesOfEncryptedData, &decryptionKey,
+ iv, previousEncryptedCounter, &blockOffset);
+ offset += subSample.numBytesOfEncryptedData;
}
}
}
/**
- * Positive decrypt test. "Decrypt" a single clear
- * segment. Verify data matches.
+ * Decrypt a list of clear+encrypted subsamples using the specified key
+ * in AES-CBC mode
*/
-TEST_P(DrmHalVendorDecryptTest, ClearSegmentTest) {
- vector<DrmHalVTSVendorModule_V1::ContentConfiguration> configurations =
- vendorModule->getContentConfigurations();
- for (auto config : configurations) {
- const size_t kSegmentSize = 1024;
- const size_t kSegmentIndex = 0;
- uint8_t iv[16] = {0};
+void DrmHalVendorDecryptTest::aes_cbc_decrypt(uint8_t* dest, uint8_t* src,
+ uint8_t* iv, const hidl_vec<SubSample>& subSamples,
+ const vector<uint8_t>& key) {
+ AES_KEY decryptionKey;
+ AES_set_encrypt_key(&key[0], 128, &decryptionKey);
- sp<IMemory> sharedMemory =
- getDecryptMemory(kSegmentSize * 2, kSegmentIndex);
+ size_t offset = 0;
+ size_t num = 0;
+ size_t ecount_buf = 0;
+ for (size_t i = 0; i < subSamples.size(); i++) {
+ const SubSample& subSample = subSamples[i];
- SharedBuffer sourceBuffer = {
- .bufferId = kSegmentIndex, .offset = 0, .size = kSegmentSize};
- fillRandom(sharedMemory);
+ memcpy(dest + offset, src + offset, subSample.numBytesOfClearData);
+ offset += subSample.numBytesOfClearData;
- DestinationBuffer destBuffer = {.type = BufferType::SHARED_MEMORY,
- {.bufferId = kSegmentIndex,
- .offset = kSegmentSize,
- .size = kSegmentSize},
- .secureMemory = nullptr};
+ AES_cbc_encrypt(src + offset, dest + offset, subSample.numBytesOfEncryptedData,
+ &decryptionKey, iv, 0 /* decrypt */);
+ offset += subSample.numBytesOfEncryptedData;
+ }
+}
- Pattern noPattern = {0, 0};
- vector<SubSample> subSamples = {{.numBytesOfClearData = kSegmentSize,
- .numBytesOfEncryptedData = 0}};
- uint64_t offset = 0;
+/**
+ * Test key status with empty session id, should return BAD_VALUE
+ */
+TEST_P(DrmHalVendorDecryptTest, QueryKeyStatusInvalidSession) {
+ SessionId sessionId;
+ auto res = drmPlugin->queryKeyStatus(sessionId,
+ [&](Status status, KeyedVector /* info */) {
+ EXPECT_EQ(Status::BAD_VALUE, status);
+ });
+ EXPECT_OK(res);
+}
+
+
+/**
+ * Test key status. There should be no key status prior to loading keys
+ */
+TEST_P(DrmHalVendorDecryptTest, QueryKeyStatusWithNoKeys) {
+ auto sessionId = openSession();
+ auto keyStatus = queryKeyStatus(sessionId);
+ EXPECT_EQ(0u, keyStatus.size());
+ closeSession(sessionId);
+}
+
+
+/**
+ * Test key status. There should be key status after loading keys.
+ */
+TEST_P(DrmHalVendorDecryptTest, QueryKeyStatus) {
+ for (auto config : contentConfigurations) {
auto sessionId = openSession();
loadKeys(sessionId, config);
-
- Status status = cryptoPlugin->setMediaDrmSession(sessionId);
- EXPECT_EQ(Status::OK, status);
-
- const bool kNotSecure = false;
- auto res = cryptoPlugin->decrypt(
- kNotSecure, toHidlArray(config.keys[0].keyId), iv,
- Mode::UNENCRYPTED, noPattern, subSamples, sourceBuffer, offset,
- destBuffer, [&](Status status, uint32_t bytesWritten,
- string detailedError) {
- EXPECT_EQ(Status::OK, status) << "Failure in decryption "
- "for configuration "
- << config.name << ": "
- << detailedError;
- EXPECT_EQ(bytesWritten, kSegmentSize);
- });
- EXPECT_OK(res);
- uint8_t* base = static_cast<uint8_t*>(
- static_cast<void*>(sharedMemory->getPointer()));
-
- EXPECT_EQ(0,
- memcmp(static_cast<void*>(base),
- static_cast<void*>(base + kSegmentSize), kSegmentSize))
- << "decrypt data mismatch";
+ auto keyStatus = queryKeyStatus(sessionId);
+ EXPECT_NE(0u, keyStatus.size());
closeSession(sessionId);
}
}
/**
+ * Positive decrypt test. "Decrypt" a single clear segment and verify.
+ */
+TEST_P(DrmHalVendorDecryptTest, ClearSegmentTest) {
+ for (auto config : contentConfigurations) {
+ for (auto key : config.keys) {
+ const size_t kSegmentSize = 1024;
+ vector<uint8_t> iv(AES_BLOCK_SIZE, 0);
+ const Pattern noPattern = {0, 0};
+ const vector<SubSample> subSamples = {{.numBytesOfClearData = kSegmentSize,
+ .numBytesOfEncryptedData = 0}};
+ auto sessionId = openSession();
+ loadKeys(sessionId, config);
+
+ Status status = cryptoPlugin->setMediaDrmSession(sessionId);
+ EXPECT_EQ(Status::OK, status);
+
+ uint32_t byteCount = decrypt(Mode::UNENCRYPTED, key.isSecure, toHidlArray(key.keyId),
+ &iv[0], subSamples, noPattern, key.clearContentKey, Status::OK);
+ EXPECT_EQ(kSegmentSize, byteCount);
+
+ closeSession(sessionId);
+ }
+ }
+}
+
+/**
+ * Positive decrypt test. Decrypt a single segment using aes_ctr.
+ * Verify data matches.
+ */
+TEST_P(DrmHalVendorDecryptTest, EncryptedAesCtrSegmentTest) {
+ for (auto config : contentConfigurations) {
+ for (auto key : config.keys) {
+ const size_t kSegmentSize = 1024;
+ vector<uint8_t> iv(AES_BLOCK_SIZE, 0);
+ const Pattern noPattern = {0, 0};
+ const vector<SubSample> subSamples = {{.numBytesOfClearData = kSegmentSize,
+ .numBytesOfEncryptedData = 0}};
+ auto sessionId = openSession();
+ loadKeys(sessionId, config);
+
+ Status status = cryptoPlugin->setMediaDrmSession(sessionId);
+ EXPECT_EQ(Status::OK, status);
+
+ uint32_t byteCount = decrypt(Mode::AES_CTR, key.isSecure, toHidlArray(key.keyId),
+ &iv[0], subSamples, noPattern, key.clearContentKey, Status::OK);
+ EXPECT_EQ(kSegmentSize, byteCount);
+
+ closeSession(sessionId);
+ }
+ }
+}
+
+/**
+ * Negative decrypt test. Decrypt without loading keys.
+ */
+TEST_P(DrmHalVendorDecryptTest, EncryptedAesCtrSegmentTestNoKeys) {
+ for (auto config : contentConfigurations) {
+ for (auto key : config.keys) {
+ vector<uint8_t> iv(AES_BLOCK_SIZE, 0);
+ const Pattern noPattern = {0, 0};
+ const vector<SubSample> subSamples = {{.numBytesOfClearData = 256,
+ .numBytesOfEncryptedData = 256}};
+ auto sessionId = openSession();
+
+ Status status = cryptoPlugin->setMediaDrmSession(sessionId);
+ EXPECT_EQ(Status::OK, status);
+
+ uint32_t byteCount = decrypt(Mode::AES_CTR, key.isSecure,
+ toHidlArray(key.keyId), &iv[0], subSamples, noPattern,
+ key.clearContentKey, Status::ERROR_DRM_NO_LICENSE);
+ EXPECT_EQ(0u, byteCount);
+
+ closeSession(sessionId);
+ }
+ }
+}
+
+/**
+ * Test key removal. Load keys then remove them and verify that
+ * decryption can't be performed.
+ */
+TEST_P(DrmHalVendorDecryptTest, AttemptDecryptWithKeysRemoved) {
+ for (auto config : contentConfigurations) {
+ for (auto key : config.keys) {
+ vector<uint8_t> iv(AES_BLOCK_SIZE, 0);
+ const Pattern noPattern = {0, 0};
+ const vector<SubSample> subSamples = {{.numBytesOfClearData = 256,
+ .numBytesOfEncryptedData = 256}};
+ auto sessionId = openSession();
+
+ Status status = cryptoPlugin->setMediaDrmSession(sessionId);
+ EXPECT_EQ(Status::OK, status);
+
+ loadKeys(sessionId, config);
+ removeKeys(sessionId);
+
+ uint32_t byteCount = decrypt(Mode::AES_CTR, key.isSecure,
+ toHidlArray(key.keyId), &iv[0], subSamples, noPattern,
+ key.clearContentKey, Status::ERROR_DRM_DECRYPT);
+ EXPECT_EQ(0u, byteCount);
+
+ closeSession(sessionId);
+ }
+ }
+}
+
+
+/**
* Instantiate the set of test cases for each vendor module
*/
INSTANTIATE_TEST_CASE_P(
DrmHalVendorFactoryTestCases, DrmHalVendorFactoryTest,
- testing::ValuesIn(gVendorModules->getVendorModulePaths()));
+ testing::ValuesIn(gVendorModules->getPathList()));
INSTANTIATE_TEST_CASE_P(
DrmHalVendorPluginTestCases, DrmHalVendorPluginTest,
- testing::ValuesIn(gVendorModules->getVendorModulePaths()));
+ testing::ValuesIn(gVendorModules->getPathList()));
INSTANTIATE_TEST_CASE_P(
DrmHalVendorDecryptTestCases, DrmHalVendorDecryptTest,
- testing::ValuesIn(gVendorModules->getVendorModulePaths()));
+ testing::ValuesIn(gVendorModules->getPathList()));
int main(int argc, char** argv) {
- gVendorModules =
- new drm_vts::VendorModules("/data/nativetest/drm_hidl_test/vendor");
+#if defined(__LP64__)
+ const char* kModulePath = "/data/local/tmp/64/lib";
+#else
+ const char* kModulePath = "/data/local/tmp/32/lib";
+#endif
+ gVendorModules = new drm_vts::VendorModules(kModulePath);
+ if (gVendorModules->getPathList().size() == 0) {
+ std::cerr << "No vendor modules found in " << kModulePath <<
+ ", exiting" << std::endl;
+ exit(-1);
+ }
::testing::InitGoogleTest(&argc, argv);
return RUN_ALL_TESTS();
}
diff --git a/drm/1.0/vts/functional/vendor/lib/libvtswidevine.so b/drm/1.0/vts/functional/vendor/lib/libvtswidevine.so
deleted file mode 100755
index d365b34..0000000
--- a/drm/1.0/vts/functional/vendor/lib/libvtswidevine.so
+++ /dev/null
Binary files differ
diff --git a/drm/1.0/vts/functional/vendor_modules.cpp b/drm/1.0/vts/functional/vendor_modules.cpp
index 34af6f8..2bf0b28 100644
--- a/drm/1.0/vts/functional/vendor_modules.cpp
+++ b/drm/1.0/vts/functional/vendor_modules.cpp
@@ -18,7 +18,7 @@
#include <dirent.h>
#include <dlfcn.h>
-#include <utils/Log.h>
+#include <log/log.h>
#include <memory>
#include "shared_library.h"
@@ -29,44 +29,37 @@
using std::unique_ptr;
namespace drm_vts {
-vector<string> VendorModules::getVendorModulePaths() {
- if (mModuleList.size() > 0) {
- return mModuleList;
- }
-
- DIR* dir = opendir(mModulesPath.c_str());
+void VendorModules::scanModules(const std::string &directory) {
+ DIR* dir = opendir(directory.c_str());
if (dir == NULL) {
- ALOGE("Unable to open drm VTS vendor directory %s",
- mModulesPath.c_str());
- return mModuleList;
- }
-
- struct dirent* entry;
- while ((entry = readdir(dir))) {
- string fullpath = mModulesPath + "/" + entry->d_name;
- if (endsWith(fullpath, ".so")) {
- mModuleList.push_back(fullpath);
+ ALOGE("Unable to open drm VTS vendor directory %s", directory.c_str());
+ } else {
+ struct dirent* entry;
+ while ((entry = readdir(dir))) {
+ ALOGD("checking file %s", entry->d_name);
+ string fullpath = directory + "/" + entry->d_name;
+ if (endsWith(fullpath, ".so")) {
+ mPathList.push_back(fullpath);
+ }
}
+ closedir(dir);
}
-
- closedir(dir);
- return mModuleList;
}
-DrmHalVTSVendorModule* VendorModules::getVendorModule(const string& path) {
- unique_ptr<SharedLibrary>& library = mOpenLibraries[path];
- if (!library) {
- library = unique_ptr<SharedLibrary>(new SharedLibrary(path));
+DrmHalVTSVendorModule* VendorModules::getModule(const string& path) {
+ if (mOpenLibraries.find(path) == mOpenLibraries.end()) {
+ auto library = std::make_unique<SharedLibrary>(path);
if (!library) {
ALOGE("failed to map shared library %s", path.c_str());
return NULL;
}
+ mOpenLibraries[path] = std::move(library);
}
+ const unique_ptr<SharedLibrary>& library = mOpenLibraries[path];
void* symbol = library->lookup("vendorModuleFactory");
if (symbol == NULL) {
ALOGE("getVendorModule failed to lookup 'vendorModuleFactory' in %s: "
- "%s",
- path.c_str(), library->lastError());
+ "%s", path.c_str(), library->lastError());
return NULL;
}
typedef DrmHalVTSVendorModule* (*ModuleFactory)();
diff --git a/drm/1.0/vts/functional/vendor_modules.h b/drm/1.0/vts/functional/vendor_modules.h
index 5371a0d..ca538f6 100644
--- a/drm/1.0/vts/functional/vendor_modules.h
+++ b/drm/1.0/vts/functional/vendor_modules.h
@@ -30,27 +30,33 @@
* Initialize with a file system path where the shared libraries
* are to be found.
*/
- explicit VendorModules(const std::string& path) : mModulesPath(path) {}
+ explicit VendorModules(const std::string& dir) {
+ scanModules(dir);
+ }
~VendorModules() {}
/**
- * Return a list of paths to available vendor modules.
- */
- std::vector<std::string> getVendorModulePaths();
-
- /**
* Retrieve a DrmHalVTSVendorModule given its full path. The
* getAPIVersion method can be used to determine the versioned
* subclass type.
*/
- DrmHalVTSVendorModule* getVendorModule(const std::string& path);
+ DrmHalVTSVendorModule* getModule(const std::string& path);
+
+ /**
+ * Return the list of paths to available vendor modules.
+ */
+ std::vector<std::string> getPathList() const {return mPathList;}
private:
- std::string mModulesPath;
- std::vector<std::string> mModuleList;
+ std::vector<std::string> mPathList;
std::map<std::string, std::unique_ptr<SharedLibrary>> mOpenLibraries;
- inline bool endsWith(const std::string& str, const std::string& suffix) {
+ /**
+ * Scan the list of paths to available vendor modules.
+ */
+ void scanModules(const std::string& dir);
+
+ inline bool endsWith(const std::string& str, const std::string& suffix) const {
if (suffix.size() > str.size()) return false;
return std::equal(suffix.rbegin(), suffix.rend(), str.rbegin());
}
diff --git a/gatekeeper/1.0/vts/functional/VtsHalGatekeeperV1_0TargetTest.cpp b/gatekeeper/1.0/vts/functional/VtsHalGatekeeperV1_0TargetTest.cpp
index 391dea0..e9a44eb 100644
--- a/gatekeeper/1.0/vts/functional/VtsHalGatekeeperV1_0TargetTest.cpp
+++ b/gatekeeper/1.0/vts/functional/VtsHalGatekeeperV1_0TargetTest.cpp
@@ -30,6 +30,8 @@
#include <android/hardware/gatekeeper/1.0/IGatekeeper.h>
#include <android/hardware/gatekeeper/1.0/types.h>
+#include <log/log.h>
+
#include <VtsHalHidlTargetTestBase.h>
using ::android::hardware::hidl_string;
diff --git a/gnss/1.0/IGnssDebug.hal b/gnss/1.0/IGnssDebug.hal
index 716ba88..4c4cfb8 100644
--- a/gnss/1.0/IGnssDebug.hal
+++ b/gnss/1.0/IGnssDebug.hal
@@ -71,8 +71,8 @@
/** Represents heading in degrees. */
float bearingDegrees;
/**
- * Estimated horizontal accuracy of position expressed in meters, radial,
- * 68% confidence.
+ * Estimated horizontal accuracy of position expressed in meters,
+ * radial, 68% confidence.
*/
double horizontalAccuracyMeters;
/**
@@ -126,7 +126,11 @@
/** Defines the constellation type of the given SV. */
GnssConstellationType constellation;
- /** Defines the ephemeris type of the satellite. */
+ /**
+ * Defines the standard broadcast ephemeris or almanac availability for
+ * the satellite. To report status of predicted orbit and clock
+ * information, see the serverPrediction fields below.
+ */
SatelliteEphemerisType ephemerisType;
/** Defines the ephemeris source of the satellite. */
SatelliteEphemerisSource ephemerisSource;
@@ -143,7 +147,7 @@
float ephemerisAgeSeconds;
/**
- * True if a server has provided a predicted orbit (& clock) for
+ * True if a server has provided a predicted orbit and clock model for
* this satellite.
*/
bool serverPredictionIsAvailable;
diff --git a/gnss/1.0/vts/functional/VtsHalGnssV1_0TargetTest.cpp b/gnss/1.0/vts/functional/VtsHalGnssV1_0TargetTest.cpp
index 2de4d5f..fde3171 100644
--- a/gnss/1.0/vts/functional/VtsHalGnssV1_0TargetTest.cpp
+++ b/gnss/1.0/vts/functional/VtsHalGnssV1_0TargetTest.cpp
@@ -16,7 +16,7 @@
#define LOG_TAG "VtsHalGnssV1_0TargetTest"
#include <android/hardware/gnss/1.0/IGnss.h>
-#include <android/log.h>
+#include <log/log.h>
#include <VtsHalHidlTargetTestBase.h>
diff --git a/graphics/allocator/2.0/default/Gralloc1On0Adapter.cpp b/graphics/allocator/2.0/default/Gralloc1On0Adapter.cpp
index f722429..be055ec 100644
--- a/graphics/allocator/2.0/default/Gralloc1On0Adapter.cpp
+++ b/graphics/allocator/2.0/default/Gralloc1On0Adapter.cpp
@@ -25,7 +25,7 @@
#include <hardware/gralloc.h>
-#include <utils/Log.h>
+#include <log/log.h>
#include <sync/sync.h>
#include <inttypes.h>
diff --git a/graphics/allocator/2.0/default/android.hardware.graphics.allocator@2.0-service.rc b/graphics/allocator/2.0/default/android.hardware.graphics.allocator@2.0-service.rc
index 3e2edda..9a08f66 100644
--- a/graphics/allocator/2.0/default/android.hardware.graphics.allocator@2.0-service.rc
+++ b/graphics/allocator/2.0/default/android.hardware.graphics.allocator@2.0-service.rc
@@ -1,5 +1,5 @@
service gralloc-2-0 /vendor/bin/hw/android.hardware.graphics.allocator@2.0-service
- class hal
+ class hal animation
user system
group graphics drmrpc
onrestart restart surfaceflinger
diff --git a/graphics/composer/2.1/default/android.hardware.graphics.composer@2.1-service.rc b/graphics/composer/2.1/default/android.hardware.graphics.composer@2.1-service.rc
index b6060db..51b0e3b 100644
--- a/graphics/composer/2.1/default/android.hardware.graphics.composer@2.1-service.rc
+++ b/graphics/composer/2.1/default/android.hardware.graphics.composer@2.1-service.rc
@@ -1,5 +1,5 @@
service hwcomposer-2-1 /vendor/bin/hw/android.hardware.graphics.composer@2.1-service
- class hal
+ class hal animation
user system
group graphics drmrpc
capabilities SYS_NICE
diff --git a/keymaster/3.0/default/android.hardware.keymaster@3.0-service.rc b/keymaster/3.0/default/android.hardware.keymaster@3.0-service.rc
index fd43178..849d270 100644
--- a/keymaster/3.0/default/android.hardware.keymaster@3.0-service.rc
+++ b/keymaster/3.0/default/android.hardware.keymaster@3.0-service.rc
@@ -1,4 +1,4 @@
service keymaster-3-0 /vendor/bin/hw/android.hardware.keymaster@3.0-service
- class hal
+ class early_hal
user system
group system drmrpc
diff --git a/keymaster/3.0/vts/functional/Android.mk b/keymaster/3.0/vts/functional/Android.mk
index 4265b9f..4098664 100644
--- a/keymaster/3.0/vts/functional/Android.mk
+++ b/keymaster/3.0/vts/functional/Android.mk
@@ -15,7 +15,7 @@
LOCAL_PATH := $(call my-dir)
include $(CLEAR_VARS)
-LOCAL_MODULE := keymaster_hidl_hal_test
+LOCAL_MODULE := VtsHalKeymasterV3_0TargetTest
LOCAL_SRC_FILES := \
authorization_set.cpp \
attestation_record.cpp \
diff --git a/keymaster/3.0/vts/functional/keymaster_hidl_hal_test.cpp b/keymaster/3.0/vts/functional/keymaster_hidl_hal_test.cpp
index 2382f0b..edb1cd1 100644
--- a/keymaster/3.0/vts/functional/keymaster_hidl_hal_test.cpp
+++ b/keymaster/3.0/vts/functional/keymaster_hidl_hal_test.cpp
@@ -46,6 +46,8 @@
// non-gtest argument will be used as the service name.
string service_name = "default";
+static bool arm_deleteAllKeys = false;
+
namespace android {
namespace hardware {
@@ -488,13 +490,20 @@
return ExportKey(format, key_blob_, client_id, app_data, key_material);
}
- ErrorCode DeleteKey(HidlBuf* key_blob) {
+ ErrorCode DeleteKey(HidlBuf* key_blob, bool keep_key_blob = false) {
ErrorCode error = keymaster_->deleteKey(*key_blob);
- *key_blob = HidlBuf();
+ if (!keep_key_blob) *key_blob = HidlBuf();
return error;
}
- ErrorCode DeleteKey() { return DeleteKey(&key_blob_); }
+ ErrorCode DeleteKey(bool keep_key_blob = false) {
+ return DeleteKey(&key_blob_, keep_key_blob);
+ }
+
+ ErrorCode DeleteAllKeys() {
+ ErrorCode error = keymaster_->deleteAllKeys();
+ return error;
+ }
ErrorCode GetCharacteristics(const HidlBuf& key_blob, const HidlBuf& client_id,
const HidlBuf& app_data, KeyCharacteristics* key_characteristics) {
@@ -3893,6 +3902,124 @@
&cert_chain));
}
+typedef KeymasterHidlTest KeyDeletionTest;
+
+/**
+ * KeyDeletionTest.DeleteKey
+ *
+ * This test checks that if rollback protection is implemented, DeleteKey invalidates a formerly
+ * valid key blob.
+ */
+TEST_F(KeyDeletionTest, DeleteKey) {
+ ASSERT_EQ(ErrorCode::OK, GenerateKey(AuthorizationSetBuilder()
+ .RsaSigningKey(1024, 3)
+ .Digest(Digest::NONE)
+ .Padding(PaddingMode::NONE)
+ .Authorization(TAG_NO_AUTH_REQUIRED)));
+
+ // Delete must work if rollback protection is implemented
+ AuthorizationSet teeEnforced(key_characteristics_.teeEnforced);
+ bool rollback_protected = teeEnforced.Contains(TAG_ROLLBACK_RESISTANT);
+
+ if (rollback_protected) {
+ ASSERT_EQ(ErrorCode::OK, DeleteKey(true /* keep key blob */));
+ } else {
+ auto delete_result = DeleteKey(true /* keep key blob */);
+ ASSERT_TRUE(delete_result == ErrorCode::OK | delete_result == ErrorCode::UNIMPLEMENTED);
+ }
+
+ string message = "12345678901234567890123456789012";
+ AuthorizationSet begin_out_params;
+
+ if (rollback_protected) {
+ EXPECT_EQ(ErrorCode::INVALID_KEY_BLOB,
+ Begin(KeyPurpose::SIGN, key_blob_,
+ AuthorizationSetBuilder().Digest(Digest::NONE).Padding(PaddingMode::NONE),
+ &begin_out_params, &op_handle_));
+ } else {
+ EXPECT_EQ(ErrorCode::OK,
+ Begin(KeyPurpose::SIGN, key_blob_,
+ AuthorizationSetBuilder().Digest(Digest::NONE).Padding(PaddingMode::NONE),
+ &begin_out_params, &op_handle_));
+ }
+ AbortIfNeeded();
+ key_blob_ = HidlBuf();
+}
+
+/**
+ * KeyDeletionTest.DeleteInvalidKey
+ *
+ * This test checks that the HAL excepts invalid key blobs.
+ */
+TEST_F(KeyDeletionTest, DeleteInvalidKey) {
+ // Generate key just to check if rollback protection is implemented
+ ASSERT_EQ(ErrorCode::OK, GenerateKey(AuthorizationSetBuilder()
+ .RsaSigningKey(1024, 3)
+ .Digest(Digest::NONE)
+ .Padding(PaddingMode::NONE)
+ .Authorization(TAG_NO_AUTH_REQUIRED)));
+
+ // Delete must work if rollback protection is implemented
+ AuthorizationSet teeEnforced(key_characteristics_.teeEnforced);
+ bool rollback_protected = teeEnforced.Contains(TAG_ROLLBACK_RESISTANT);
+
+ // Delete the key we don't care about the result at this point.
+ DeleteKey();
+
+ // Now create an invalid key blob and delete it.
+ key_blob_ = HidlBuf("just some garbage data which is not a valid key blob");
+
+ if (rollback_protected) {
+ ASSERT_EQ(ErrorCode::OK, DeleteKey());
+ } else {
+ auto delete_result = DeleteKey();
+ ASSERT_TRUE(delete_result == ErrorCode::OK | delete_result == ErrorCode::UNIMPLEMENTED);
+ }
+}
+
+/**
+ * KeyDeletionTest.DeleteAllKeys
+ *
+ * This test is disarmed by default. To arm it use --arm_deleteAllKeys.
+ *
+ * BEWARE: This test has serious side effects. All user keys will be lost! This includes
+ * FBE/FDE encryption keys, which means that the device will not even boot until after the
+ * device has been wiped manually (e.g., fastboot flashall -w), and new FBE/FDE keys have
+ * been provisioned. Use this test only on dedicated testing devices that have no valuable
+ * credentials stored in Keystore/Keymaster.
+ */
+TEST_F(KeyDeletionTest, DeleteAllKeys) {
+ if (!arm_deleteAllKeys) return;
+ ASSERT_EQ(ErrorCode::OK, GenerateKey(AuthorizationSetBuilder()
+ .RsaSigningKey(1024, 3)
+ .Digest(Digest::NONE)
+ .Padding(PaddingMode::NONE)
+ .Authorization(TAG_NO_AUTH_REQUIRED)));
+
+ // Delete must work if rollback protection is implemented
+ AuthorizationSet teeEnforced(key_characteristics_.teeEnforced);
+ bool rollback_protected = teeEnforced.Contains(TAG_ROLLBACK_RESISTANT);
+
+ ASSERT_EQ(ErrorCode::OK, DeleteAllKeys());
+
+ string message = "12345678901234567890123456789012";
+ AuthorizationSet begin_out_params;
+
+ if (rollback_protected) {
+ EXPECT_EQ(ErrorCode::INVALID_KEY_BLOB,
+ Begin(KeyPurpose::SIGN, key_blob_,
+ AuthorizationSetBuilder().Digest(Digest::NONE).Padding(PaddingMode::NONE),
+ &begin_out_params, &op_handle_));
+ } else {
+ EXPECT_EQ(ErrorCode::OK,
+ Begin(KeyPurpose::SIGN, key_blob_,
+ AuthorizationSetBuilder().Digest(Digest::NONE).Padding(PaddingMode::NONE),
+ &begin_out_params, &op_handle_));
+ }
+ AbortIfNeeded();
+ key_blob_ = HidlBuf();
+}
+
} // namespace test
} // namespace V3_0
} // namespace keymaster
@@ -3901,9 +4028,19 @@
int main(int argc, char** argv) {
::testing::InitGoogleTest(&argc, argv);
- if (argc == 2) {
- ALOGI("Running keymaster VTS against service \"%s\"", argv[1]);
- service_name = argv[1];
+ std::vector<std::string> positional_args;
+ for (int i = 1; i < argc; ++i) {
+ if (argv[i][0] == '-') {
+ if (std::string(argv[i]) == "--arm_deleteAllKeys") {
+ arm_deleteAllKeys = true;
+ }
+ } else {
+ positional_args.push_back(argv[i]);
+ }
+ }
+ if (positional_args.size()) {
+ ALOGI("Running keymaster VTS against service \"%s\"", positional_args[0].c_str());
+ service_name = positional_args[0];
}
int status = RUN_ALL_TESTS();
ALOGI("Test result = %d", status);
diff --git a/memtrack/1.0/vts/functional/VtsHalMemtrackV1_0TargetTest.cpp b/memtrack/1.0/vts/functional/VtsHalMemtrackV1_0TargetTest.cpp
index a8d8aea..6ff566e 100644
--- a/memtrack/1.0/vts/functional/VtsHalMemtrackV1_0TargetTest.cpp
+++ b/memtrack/1.0/vts/functional/VtsHalMemtrackV1_0TargetTest.cpp
@@ -22,6 +22,7 @@
#include <VtsHalHidlTargetTestBase.h>
+#include <fcntl.h>
#include <algorithm>
#include <vector>
diff --git a/nfc/1.0/vts/functional/VtsHalNfcV1_0TargetTest.cpp b/nfc/1.0/vts/functional/VtsHalNfcV1_0TargetTest.cpp
index aa3bc9c..cf9f66e 100644
--- a/nfc/1.0/vts/functional/VtsHalNfcV1_0TargetTest.cpp
+++ b/nfc/1.0/vts/functional/VtsHalNfcV1_0TargetTest.cpp
@@ -22,10 +22,8 @@
#include <android/hardware/nfc/1.0/types.h>
#include <hardware/nfc.h>
+#include <VtsHalHidlTargetCallbackBase.h>
#include <VtsHalHidlTargetTestBase.h>
-#include <chrono>
-#include <condition_variable>
-#include <mutex>
using ::android::hardware::nfc::V1_0::INfc;
using ::android::hardware::nfc::V1_0::INfcClientCallback;
@@ -55,6 +53,43 @@
#define VERSION 0x11
#define TIMEOUT_PERIOD 5
+constexpr char kCallbackNameSendEvent[] = "sendEvent";
+constexpr char kCallbackNameSendData[] = "sendData";
+
+class NfcClientCallbackArgs {
+ public:
+ NfcEvent last_event_;
+ NfcStatus last_status_;
+ NfcData last_data_;
+};
+
+/* Callback class for data & Event. */
+class NfcClientCallback
+ : public ::testing::VtsHalHidlTargetCallbackBase<NfcClientCallbackArgs>,
+ public INfcClientCallback {
+ public:
+ virtual ~NfcClientCallback() = default;
+
+ /* sendEvent callback function - Records the Event & Status
+ * and notifies the TEST
+ **/
+ Return<void> sendEvent(NfcEvent event, NfcStatus event_status) override {
+ NfcClientCallbackArgs args;
+ args.last_event_ = event;
+ args.last_status_ = event_status;
+ NotifyFromCallback(kCallbackNameSendEvent, args);
+ return Void();
+ };
+
+ /* sendData callback function. Records the data and notifies the TEST*/
+ Return<void> sendData(const NfcData& data) override {
+ NfcClientCallbackArgs args;
+ args.last_data_ = data;
+ NotifyFromCallback(kCallbackNameSendData, args);
+ return Void();
+ };
+};
+
// The main test class for NFC HIDL HAL.
class NfcHidlTest : public ::testing::VtsHalHidlTargetTestBase {
public:
@@ -62,88 +97,28 @@
nfc_ = ::testing::VtsHalHidlTargetTestBase::getService<INfc>();
ASSERT_NE(nfc_, nullptr);
- nfc_cb_ = new NfcClientCallback(*this);
+ nfc_cb_ = new NfcClientCallback();
ASSERT_NE(nfc_cb_, nullptr);
- count = 0;
- last_event_ = NfcEvent::ERROR;
- last_status_ = NfcStatus::FAILED;
-
EXPECT_EQ(NfcStatus::OK, nfc_->open(nfc_cb_));
// Wait for OPEN_CPLT event
- EXPECT_EQ(std::cv_status::no_timeout, wait());
- EXPECT_EQ(NfcEvent::OPEN_CPLT, last_event_);
- EXPECT_EQ(NfcStatus::OK, last_status_);
+ auto res = nfc_cb_->WaitForCallback(kCallbackNameSendEvent);
+ EXPECT_TRUE(res.no_timeout);
+ EXPECT_EQ(NfcEvent::OPEN_CPLT, res.args->last_event_);
+ EXPECT_EQ(NfcStatus::OK, res.args->last_status_);
}
virtual void TearDown() override {
EXPECT_EQ(NfcStatus::OK, nfc_->close());
// Wait for CLOSE_CPLT event
- EXPECT_EQ(std::cv_status::no_timeout, wait());
- EXPECT_EQ(NfcEvent::CLOSE_CPLT, last_event_);
- EXPECT_EQ(NfcStatus::OK, last_status_);
+ auto res = nfc_cb_->WaitForCallback(kCallbackNameSendEvent);
+ EXPECT_TRUE(res.no_timeout);
+ EXPECT_EQ(NfcEvent::CLOSE_CPLT, res.args->last_event_);
+ EXPECT_EQ(NfcStatus::OK, res.args->last_status_);
}
- /* Used as a mechanism to inform the test about data/event callback */
- inline void notify() {
- std::unique_lock<std::mutex> lock(mtx);
- count++;
- cv.notify_one();
- }
-
- /* Test code calls this function to wait for data/event callback */
- inline std::cv_status wait() {
- std::unique_lock<std::mutex> lock(mtx);
-
- std::cv_status status = std::cv_status::no_timeout;
- auto now = std::chrono::system_clock::now();
- while (count == 0) {
- status = cv.wait_until(lock, now + std::chrono::seconds(TIMEOUT_PERIOD));
- if (status == std::cv_status::timeout) return status;
- }
- count--;
- return status;
- }
-
- /* Callback class for data & Event. */
- class NfcClientCallback : public INfcClientCallback {
- NfcHidlTest& parent_;
-
- public:
- NfcClientCallback(NfcHidlTest& parent) : parent_(parent){};
-
- virtual ~NfcClientCallback() = default;
-
- /* sendEvent callback function - Records the Event & Status
- * and notifies the TEST
- **/
- Return<void> sendEvent(NfcEvent event, NfcStatus event_status) override {
- parent_.last_event_ = event;
- parent_.last_status_ = event_status;
- parent_.notify();
- return Void();
- };
-
- /* sendData callback function. Records the data and notifies the TEST*/
- Return<void> sendData(const NfcData& data) override {
- size_t size = parent_.last_data_.size();
- parent_.last_data_.resize(size + 1);
- parent_.last_data_[size] = data;
- parent_.notify();
- return Void();
- };
- };
-
sp<INfc> nfc_;
- sp<INfcClientCallback> nfc_cb_;
- NfcEvent last_event_;
- NfcStatus last_status_;
- hidl_vec<NfcData> last_data_;
-
- private:
- std::mutex mtx;
- std::condition_variable cv;
- int count;
+ sp<NfcClientCallback> nfc_cb_;
};
// A class for test environment setup (kept since this file is a template).
@@ -175,12 +150,12 @@
NfcData data = cmd;
EXPECT_EQ(data.size(), nfc_->write(data));
// Wait for CORE_RESET_RSP
- EXPECT_EQ(std::cv_status::no_timeout, wait());
- EXPECT_EQ(1ul, last_data_.size());
- EXPECT_EQ(6ul, last_data_[0].size());
- EXPECT_EQ((int)NfcStatus::OK, last_data_[0][3]);
- EXPECT_GE(VERSION, last_data_[0][4]);
- EXPECT_EQ(0ul, last_data_[0][5]);
+ auto res = nfc_cb_->WaitForCallback(kCallbackNameSendData);
+ EXPECT_TRUE(res.no_timeout);
+ EXPECT_EQ(6ul, res.args->last_data_.size());
+ EXPECT_EQ((int)NfcStatus::OK, res.args->last_data_[3]);
+ EXPECT_GE(VERSION, res.args->last_data_[4]);
+ EXPECT_EQ(0ul, res.args->last_data_[5]);
}
/*
@@ -194,12 +169,12 @@
NfcData data = cmd;
EXPECT_EQ(data.size(), nfc_->write(data));
// Wait for CORE_RESET_RSP
- EXPECT_EQ(std::cv_status::no_timeout, wait());
- EXPECT_EQ(1ul, last_data_.size());
- EXPECT_EQ(6ul, last_data_[0].size());
- EXPECT_EQ((int)NfcStatus::OK, last_data_[0][3]);
- EXPECT_GE(VERSION, last_data_[0][4]);
- EXPECT_EQ(1ul, last_data_[0][5]);
+ auto res = nfc_cb_->WaitForCallback(kCallbackNameSendData);
+ EXPECT_TRUE(res.no_timeout);
+ EXPECT_EQ(6ul, res.args->last_data_.size());
+ EXPECT_EQ((int)NfcStatus::OK, res.args->last_data_[3]);
+ EXPECT_GE(VERSION, res.args->last_data_[4]);
+ EXPECT_EQ(1ul, res.args->last_data_[5]);
}
/*
@@ -214,10 +189,10 @@
NfcData data = cmd;
EXPECT_EQ(data.size(), nfc_->write(data));
// Wait for RSP
- EXPECT_EQ(std::cv_status::no_timeout, wait());
- EXPECT_EQ(1ul, last_data_.size());
- EXPECT_EQ(4ul, last_data_[0].size());
- EXPECT_EQ(SYNTAX_ERROR, last_data_[0][3]);
+ auto res = nfc_cb_->WaitForCallback(kCallbackNameSendData);
+ EXPECT_TRUE(res.no_timeout);
+ EXPECT_EQ(4ul, res.args->last_data_.size());
+ EXPECT_EQ(SYNTAX_ERROR, res.args->last_data_[3]);
}
/*
@@ -236,29 +211,27 @@
size_t size = data.size();
for (int i = 0; i < 100; i++) {
- last_data_.resize(0);
data.resize(++size);
data[size - 1] = 0xFF;
EXPECT_EQ(data.size(), nfc_->write(data));
// Wait for CORE_INTERFACE_ERROR_NTF
- EXPECT_EQ(std::cv_status::no_timeout, wait());
- EXPECT_EQ(1ul, last_data_.size());
- EXPECT_EQ(5ul, last_data_[0].size());
- EXPECT_EQ(0x60, last_data_[0][0]);
- EXPECT_EQ(0x08, last_data_[0][1]);
- EXPECT_EQ(0x02, last_data_[0][2]);
- EXPECT_EQ(SYNTAX_ERROR, last_data_[0][3]);
+ auto res = nfc_cb_->WaitForCallback(kCallbackNameSendData);
+ EXPECT_TRUE(res.no_timeout);
+ EXPECT_EQ(5ul, res.args->last_data_.size());
+ EXPECT_EQ(0x60, res.args->last_data_[0]);
+ EXPECT_EQ(0x08, res.args->last_data_[1]);
+ EXPECT_EQ(0x02, res.args->last_data_[2]);
+ EXPECT_EQ(SYNTAX_ERROR, res.args->last_data_[3]);
}
cmd = CORE_CONN_CREATE_CMD;
data = cmd;
- last_data_.resize(0);
EXPECT_EQ(data.size(), nfc_->write(data));
// Wait for CORE_CONN_CREATE_RSP
- EXPECT_EQ(std::cv_status::no_timeout, wait());
- EXPECT_EQ(1ul, last_data_.size());
- EXPECT_EQ(7ul, last_data_[0].size());
- EXPECT_EQ((int)NfcStatus::OK, last_data_[0][3]);
+ auto res = nfc_cb_->WaitForCallback(kCallbackNameSendData);
+ EXPECT_TRUE(res.no_timeout);
+ EXPECT_EQ(7ul, res.args->last_data_.size());
+ EXPECT_EQ((int)NfcStatus::OK, res.args->last_data_[3]);
}
/*
* Bandwidth:
@@ -273,40 +246,48 @@
NfcData data = cmd;
EXPECT_EQ(data.size(), nfc_->write(data));
// Wait for CORE_CONN_CREATE_RSP
- EXPECT_EQ(std::cv_status::no_timeout, wait());
- EXPECT_EQ(1ul, last_data_.size());
- EXPECT_EQ(7ul, last_data_[0].size());
- EXPECT_EQ((int)NfcStatus::OK, last_data_[0][3]);
- uint8_t conn_id = last_data_[0][6];
- uint32_t max_payload_size = last_data_[0][4];
+ auto res = nfc_cb_->WaitForCallback(kCallbackNameSendData);
+ EXPECT_TRUE(res.no_timeout);
+ EXPECT_EQ(7ul, res.args->last_data_.size());
+ EXPECT_EQ((int)NfcStatus::OK, res.args->last_data_[3]);
+ uint8_t conn_id = res.args->last_data_[6];
+ uint32_t max_payload_size = res.args->last_data_[4];
for (int loops = 0; loops < NUMBER_LOOPS; loops++) {
- last_data_.resize(0);
- data.resize(max_payload_size + LOOP_BACK_HEADER_SIZE);
- data[0] = conn_id;
- data[1] = 0x00;
- data[2] = max_payload_size;
- for (uint32_t i = 0; i < max_payload_size; i++) {
- data[i + LOOP_BACK_HEADER_SIZE] = i;
+ res.args->last_data_.resize(0);
+ data.resize(max_payload_size + LOOP_BACK_HEADER_SIZE);
+ data[0] = conn_id;
+ data[1] = 0x00;
+ data[2] = max_payload_size;
+ for (uint32_t i = 0; i < max_payload_size; i++) {
+ data[i + LOOP_BACK_HEADER_SIZE] = i;
}
EXPECT_EQ(max_payload_size + LOOP_BACK_HEADER_SIZE, nfc_->write(data));
// Wait for data and CORE_CONN_CREDITS_NTF
- EXPECT_EQ(std::cv_status::no_timeout, wait());
- EXPECT_EQ(std::cv_status::no_timeout, wait());
- // Check if the same data was recieved back
- EXPECT_EQ(2ul, last_data_.size());
+ auto res1 = nfc_cb_->WaitForCallback(kCallbackNameSendData);
+ EXPECT_TRUE(res1.no_timeout);
+ auto res2 = nfc_cb_->WaitForCallback(kCallbackNameSendData);
+ EXPECT_TRUE(res2.no_timeout);
+ // Check if the same data was received back
+ EXPECT_TRUE(res1.args);
+ EXPECT_TRUE(res2.args);
+ NfcData credits_ntf = res1.args->last_data_;
+ NfcData received_data = res2.args->last_data_;
/* It is possible that CORE_CONN_CREDITS_NTF is received before data,
* Find the order and do further checks depending on that */
- uint8_t data_index = last_data_[0].size() == data.size() ? 0 : 1;
- EXPECT_EQ(data.size(), last_data_[data_index].size());
+ if (received_data.size() != data.size()) {
+ credits_ntf = res2.args->last_data_;
+ received_data = res1.args->last_data_;
+ }
+ EXPECT_EQ(data.size(), received_data.size());
for (size_t i = 0; i < data.size(); i++) {
- EXPECT_EQ(data[i], last_data_[data_index][i]);
+ EXPECT_EQ(data[i], received_data[i]);
}
- EXPECT_EQ(6ul, last_data_[!data_index].size());
+ EXPECT_EQ(6ul, credits_ntf.size());
// Check if the credit is refilled to 1
- EXPECT_EQ(1, last_data_[!data_index][5]);
+ EXPECT_EQ(1, credits_ntf[5]);
}
}
@@ -319,9 +300,10 @@
TEST_F(NfcHidlTest, PowerCycle) {
EXPECT_EQ(NfcStatus::OK, nfc_->powerCycle());
// Wait for NfcEvent.OPEN_CPLT
- EXPECT_EQ(std::cv_status::no_timeout, wait());
- EXPECT_EQ(NfcEvent::OPEN_CPLT, last_event_);
- EXPECT_EQ(NfcStatus::OK, last_status_);
+ auto res = nfc_cb_->WaitForCallback(kCallbackNameSendEvent);
+ EXPECT_TRUE(res.no_timeout);
+ EXPECT_EQ(NfcEvent::OPEN_CPLT, res.args->last_event_);
+ EXPECT_EQ(NfcStatus::OK, res.args->last_status_);
}
/*
@@ -332,17 +314,19 @@
TEST_F(NfcHidlTest, PowerCycleAfterClose) {
EXPECT_EQ(NfcStatus::OK, nfc_->close());
// Wait for CLOSE_CPLT event
- EXPECT_EQ(std::cv_status::no_timeout, wait());
- EXPECT_EQ(NfcEvent::CLOSE_CPLT, last_event_);
- EXPECT_EQ(NfcStatus::OK, last_status_);
+ auto res = nfc_cb_->WaitForCallback(kCallbackNameSendEvent);
+ EXPECT_TRUE(res.no_timeout);
+ EXPECT_EQ(NfcEvent::CLOSE_CPLT, res.args->last_event_);
+ EXPECT_EQ(NfcStatus::OK, res.args->last_status_);
EXPECT_EQ(NfcStatus::FAILED, nfc_->powerCycle());
EXPECT_EQ(NfcStatus::OK, nfc_->open(nfc_cb_));
// Wait for OPEN_CPLT event
- EXPECT_EQ(std::cv_status::no_timeout, wait());
- EXPECT_EQ(NfcEvent::OPEN_CPLT, last_event_);
- EXPECT_EQ(NfcStatus::OK, last_status_);
+ res = nfc_cb_->WaitForCallback(kCallbackNameSendEvent);
+ EXPECT_TRUE(res.no_timeout);
+ EXPECT_EQ(NfcEvent::OPEN_CPLT, res.args->last_event_);
+ EXPECT_EQ(NfcStatus::OK, res.args->last_status_);
}
/*
@@ -353,13 +337,16 @@
TEST_F(NfcHidlTest, CoreInitialized) {
NfcData data;
data.resize(1);
- for (int i = 0; i <= 6; i++)
- {
- data[0] = i;
- EXPECT_EQ(NfcStatus::OK, nfc_->coreInitialized(data));
- // Wait for NfcEvent.POST_INIT_CPLT
- EXPECT_EQ(std::cv_status::no_timeout, wait());
- EXPECT_EQ(NfcEvent::POST_INIT_CPLT, last_event_);
+ // These parameters might lead to device specific proprietary behavior
+ // Using > 10 values should result in predictable and common results for
+ // most devices.
+ for (int i = 10; i <= 16; i++) {
+ data[0] = i;
+ EXPECT_EQ(NfcStatus::OK, nfc_->coreInitialized(data));
+ // Wait for NfcEvent.POST_INIT_CPLT
+ auto res = nfc_cb_->WaitForCallback(kCallbackNameSendEvent);
+ EXPECT_TRUE(res.no_timeout);
+ EXPECT_EQ(NfcEvent::POST_INIT_CPLT, res.args->last_event_);
}
}
@@ -380,17 +367,19 @@
TEST_F(NfcHidlTest, ControlGrantedAfterClose) {
EXPECT_EQ(NfcStatus::OK, nfc_->close());
// Wait for CLOSE_CPLT event
- EXPECT_EQ(std::cv_status::no_timeout, wait());
- EXPECT_EQ(NfcEvent::CLOSE_CPLT, last_event_);
- EXPECT_EQ(NfcStatus::OK, last_status_);
+ auto res = nfc_cb_->WaitForCallback(kCallbackNameSendEvent);
+ EXPECT_TRUE(res.no_timeout);
+ EXPECT_EQ(NfcEvent::CLOSE_CPLT, res.args->last_event_);
+ EXPECT_EQ(NfcStatus::OK, res.args->last_status_);
EXPECT_EQ(NfcStatus::OK, nfc_->controlGranted());
EXPECT_EQ(NfcStatus::OK, nfc_->open(nfc_cb_));
// Wait for OPEN_CPLT event
- EXPECT_EQ(std::cv_status::no_timeout, wait());
- EXPECT_EQ(NfcEvent::OPEN_CPLT, last_event_);
- EXPECT_EQ(NfcStatus::OK, last_status_);
+ res = nfc_cb_->WaitForCallback(kCallbackNameSendEvent);
+ EXPECT_TRUE(res.no_timeout);
+ EXPECT_EQ(NfcEvent::OPEN_CPLT, res.args->last_event_);
+ EXPECT_EQ(NfcStatus::OK, res.args->last_status_);
}
/* PreDiscover:
@@ -409,17 +398,19 @@
TEST_F(NfcHidlTest, PreDiscoverAfterClose) {
EXPECT_EQ(NfcStatus::OK, nfc_->close());
// Wait for CLOSE_CPLT event
- EXPECT_EQ(std::cv_status::no_timeout, wait());
- EXPECT_EQ(NfcEvent::CLOSE_CPLT, last_event_);
- EXPECT_EQ(NfcStatus::OK, last_status_);
+ auto res = nfc_cb_->WaitForCallback(kCallbackNameSendEvent);
+ EXPECT_TRUE(res.no_timeout);
+ EXPECT_EQ(NfcEvent::CLOSE_CPLT, res.args->last_event_);
+ EXPECT_EQ(NfcStatus::OK, res.args->last_status_);
EXPECT_EQ(NfcStatus::OK, nfc_->prediscover());
EXPECT_EQ(NfcStatus::OK, nfc_->open(nfc_cb_));
// Wait for OPEN_CPLT event
- EXPECT_EQ(std::cv_status::no_timeout, wait());
- EXPECT_EQ(NfcEvent::OPEN_CPLT, last_event_);
- EXPECT_EQ(NfcStatus::OK, last_status_);
+ res = nfc_cb_->WaitForCallback(kCallbackNameSendEvent);
+ EXPECT_TRUE(res.no_timeout);
+ EXPECT_EQ(NfcEvent::OPEN_CPLT, res.args->last_event_);
+ EXPECT_EQ(NfcStatus::OK, res.args->last_status_);
}
/*
@@ -430,20 +421,21 @@
TEST_F(NfcHidlTest, CloseAfterClose) {
EXPECT_EQ(NfcStatus::OK, nfc_->close());
// Wait for CLOSE_CPLT event
- EXPECT_EQ(std::cv_status::no_timeout, wait());
- EXPECT_EQ(NfcEvent::CLOSE_CPLT, last_event_);
- EXPECT_EQ(NfcStatus::OK, last_status_);
+ auto res = nfc_cb_->WaitForCallback(kCallbackNameSendEvent);
+ EXPECT_TRUE(res.no_timeout);
+ EXPECT_EQ(NfcEvent::CLOSE_CPLT, res.args->last_event_);
+ EXPECT_EQ(NfcStatus::OK, res.args->last_status_);
EXPECT_EQ(NfcStatus::FAILED, nfc_->close());
EXPECT_EQ(NfcStatus::OK, nfc_->open(nfc_cb_));
// Wait for OPEN_CPLT event
- EXPECT_EQ(std::cv_status::no_timeout, wait());
- EXPECT_EQ(NfcEvent::OPEN_CPLT, last_event_);
- EXPECT_EQ(NfcStatus::OK, last_status_);
+ res = nfc_cb_->WaitForCallback(kCallbackNameSendEvent);
+ EXPECT_TRUE(res.no_timeout);
+ EXPECT_EQ(NfcEvent::OPEN_CPLT, res.args->last_event_);
+ EXPECT_EQ(NfcStatus::OK, res.args->last_status_);
}
-
/*
* OpenAfterOpen:
* Calls open() multiple times
diff --git a/power/1.0/vts/functional/VtsHalPowerV1_0TargetTest.cpp b/power/1.0/vts/functional/VtsHalPowerV1_0TargetTest.cpp
index cd1a261..c94fa4f 100644
--- a/power/1.0/vts/functional/VtsHalPowerV1_0TargetTest.cpp
+++ b/power/1.0/vts/functional/VtsHalPowerV1_0TargetTest.cpp
@@ -24,6 +24,7 @@
#include <VtsHalHidlTargetTestBase.h>
+#include <fcntl.h>
#include <algorithm>
using ::android::hardware::power::V1_0::IPower;
diff --git a/radio/1.0/vts/functional/VtsHalRadioV1_0TargetTest.cpp b/radio/1.0/vts/functional/VtsHalRadioV1_0TargetTest.cpp
index d01adf2..e7c89d5 100644
--- a/radio/1.0/vts/functional/VtsHalRadioV1_0TargetTest.cpp
+++ b/radio/1.0/vts/functional/VtsHalRadioV1_0TargetTest.cpp
@@ -14,14 +14,14 @@
* limitations under the License.
*/
-#include<radio_hidl_hal_utils.h>
+#include <radio_hidl_hal_utils.h>
int main(int argc, char** argv) {
- ::testing::AddGlobalTestEnvironment(new RadioHidlEnvironment);
- ::testing::InitGoogleTest(&argc, argv);
+ ::testing::AddGlobalTestEnvironment(new RadioHidlEnvironment);
+ ::testing::InitGoogleTest(&argc, argv);
- int status = RUN_ALL_TESTS();
- LOG(INFO) << "Test result = " << status;
+ int status = RUN_ALL_TESTS();
+ LOG(INFO) << "Test result = " << status;
- return status;
+ return status;
}
\ No newline at end of file
diff --git a/radio/1.0/vts/functional/VtsHalSapV1_0TargetTest.cpp b/radio/1.0/vts/functional/VtsHalSapV1_0TargetTest.cpp
index f902588..5306076 100644
--- a/radio/1.0/vts/functional/VtsHalSapV1_0TargetTest.cpp
+++ b/radio/1.0/vts/functional/VtsHalSapV1_0TargetTest.cpp
@@ -14,15 +14,15 @@
* limitations under the License.
*/
-#include<sap_hidl_hal_utils.h>
+#include <sap_hidl_hal_utils.h>
int main(int argc, char** argv) {
- // Add Sim-access Profile Hidl Environment
- ::testing::AddGlobalTestEnvironment(new SapHidlEnvironment);
- ::testing::InitGoogleTest(&argc, argv);
+ // Add Sim-access Profile Hidl Environment
+ ::testing::AddGlobalTestEnvironment(new SapHidlEnvironment);
+ ::testing::InitGoogleTest(&argc, argv);
- int status = RUN_ALL_TESTS();
- LOG(INFO) << "Test result = " << status;
+ int status = RUN_ALL_TESTS();
+ LOG(INFO) << "Test result = " << status;
- return status;
+ return status;
}
diff --git a/radio/1.0/vts/functional/radio_hidl_hal_cell_broadcast.cpp b/radio/1.0/vts/functional/radio_hidl_hal_cell_broadcast.cpp
index d87ce5f..53d1b90 100644
--- a/radio/1.0/vts/functional/radio_hidl_hal_cell_broadcast.cpp
+++ b/radio/1.0/vts/functional/radio_hidl_hal_cell_broadcast.cpp
@@ -14,7 +14,7 @@
* limitations under the License.
*/
-#include<radio_hidl_hal_utils.h>
+#include <radio_hidl_hal_utils.h>
using namespace ::android::hardware::radio::V1_0;
@@ -22,153 +22,154 @@
* Test IRadio.setGsmBroadcastConfig() for the response returned.
*/
TEST_F(RadioHidlTest, setGsmBroadcastConfig) {
- int serial = 0;
+ int serial = 0;
- // Create GsmBroadcastSmsConfigInfo #1
- GsmBroadcastSmsConfigInfo gbSmsConfig1;
- gbSmsConfig1.fromServiceId = 4352;
- gbSmsConfig1.toServiceId = 4354;
- gbSmsConfig1.fromCodeScheme = 0;
- gbSmsConfig1.toCodeScheme = 255;
- gbSmsConfig1.selected = true;
+ // Create GsmBroadcastSmsConfigInfo #1
+ GsmBroadcastSmsConfigInfo gbSmsConfig1;
+ gbSmsConfig1.fromServiceId = 4352;
+ gbSmsConfig1.toServiceId = 4354;
+ gbSmsConfig1.fromCodeScheme = 0;
+ gbSmsConfig1.toCodeScheme = 255;
+ gbSmsConfig1.selected = true;
- // Create GsmBroadcastSmsConfigInfo #2
- GsmBroadcastSmsConfigInfo gbSmsConfig2;
- gbSmsConfig2.fromServiceId = 4356;
- gbSmsConfig2.toServiceId = 4356;
- gbSmsConfig2.fromCodeScheme = 0;
- gbSmsConfig2.toCodeScheme = 255;
- gbSmsConfig2.selected = true;
+ // Create GsmBroadcastSmsConfigInfo #2
+ GsmBroadcastSmsConfigInfo gbSmsConfig2;
+ gbSmsConfig2.fromServiceId = 4356;
+ gbSmsConfig2.toServiceId = 4356;
+ gbSmsConfig2.fromCodeScheme = 0;
+ gbSmsConfig2.toCodeScheme = 255;
+ gbSmsConfig2.selected = true;
- // Create GsmBroadcastSmsConfigInfo #3
- GsmBroadcastSmsConfigInfo gbSmsConfig3;
- gbSmsConfig3.fromServiceId = 4370;
- gbSmsConfig3.toServiceId = 4379;
- gbSmsConfig3.fromCodeScheme = 0;
- gbSmsConfig3.toCodeScheme = 255;
- gbSmsConfig3.selected = true;
+ // Create GsmBroadcastSmsConfigInfo #3
+ GsmBroadcastSmsConfigInfo gbSmsConfig3;
+ gbSmsConfig3.fromServiceId = 4370;
+ gbSmsConfig3.toServiceId = 4379;
+ gbSmsConfig3.fromCodeScheme = 0;
+ gbSmsConfig3.toCodeScheme = 255;
+ gbSmsConfig3.selected = true;
- // Create GsmBroadcastSmsConfigInfo #4
- GsmBroadcastSmsConfigInfo gbSmsConfig4;
- gbSmsConfig4.fromServiceId = 4383;
- gbSmsConfig4.toServiceId = 4391;
- gbSmsConfig4.fromCodeScheme = 0;
- gbSmsConfig4.toCodeScheme = 255;
- gbSmsConfig4.selected = true;
+ // Create GsmBroadcastSmsConfigInfo #4
+ GsmBroadcastSmsConfigInfo gbSmsConfig4;
+ gbSmsConfig4.fromServiceId = 4383;
+ gbSmsConfig4.toServiceId = 4391;
+ gbSmsConfig4.fromCodeScheme = 0;
+ gbSmsConfig4.toCodeScheme = 255;
+ gbSmsConfig4.selected = true;
- // Create GsmBroadcastSmsConfigInfo #5
- GsmBroadcastSmsConfigInfo gbSmsConfig5;
- gbSmsConfig5.fromServiceId = 4392;
- gbSmsConfig5.toServiceId = 4392;
- gbSmsConfig5.fromCodeScheme = 0;
- gbSmsConfig5.toCodeScheme = 255;
- gbSmsConfig5.selected = true;
+ // Create GsmBroadcastSmsConfigInfo #5
+ GsmBroadcastSmsConfigInfo gbSmsConfig5;
+ gbSmsConfig5.fromServiceId = 4392;
+ gbSmsConfig5.toServiceId = 4392;
+ gbSmsConfig5.fromCodeScheme = 0;
+ gbSmsConfig5.toCodeScheme = 255;
+ gbSmsConfig5.selected = true;
- android::hardware::hidl_vec<GsmBroadcastSmsConfigInfo> gsmBroadcastSmsConfigsInfoList
- = {gbSmsConfig1, gbSmsConfig2, gbSmsConfig3, gbSmsConfig4, gbSmsConfig5};
+ android::hardware::hidl_vec<GsmBroadcastSmsConfigInfo>
+ gsmBroadcastSmsConfigsInfoList = {
+ gbSmsConfig1, gbSmsConfig2, gbSmsConfig3, gbSmsConfig4, gbSmsConfig5};
- radio->setGsmBroadcastConfig(++serial, gsmBroadcastSmsConfigsInfoList);
+ radio->setGsmBroadcastConfig(++serial, gsmBroadcastSmsConfigsInfoList);
- EXPECT_EQ(std::cv_status::no_timeout, wait());
- EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
- EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+ EXPECT_EQ(std::cv_status::no_timeout, wait());
+ EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+ EXPECT_EQ(serial, radioRsp->rspInfo.serial);
- if (cardStatus.cardState == CardState::ABSENT) {
- EXPECT_EQ(RadioError::NONE, radioRsp->rspInfo.error);
- }
+ if (cardStatus.cardState == CardState::ABSENT) {
+ EXPECT_EQ(RadioError::NONE, radioRsp->rspInfo.error);
+ }
}
/*
* Test IRadio.getGsmBroadcastConfig() for the response returned.
*/
TEST_F(RadioHidlTest, getGsmBroadcastConfig) {
- int serial = 0;
+ int serial = 0;
- radio->getGsmBroadcastConfig(++serial);
+ radio->getGsmBroadcastConfig(++serial);
- EXPECT_EQ(std::cv_status::no_timeout, wait());
- EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
- EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+ EXPECT_EQ(std::cv_status::no_timeout, wait());
+ EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+ EXPECT_EQ(serial, radioRsp->rspInfo.serial);
- if (cardStatus.cardState == CardState::ABSENT) {
- EXPECT_EQ(RadioError::NONE, radioRsp->rspInfo.error);
- }
+ if (cardStatus.cardState == CardState::ABSENT) {
+ EXPECT_EQ(RadioError::NONE, radioRsp->rspInfo.error);
+ }
}
/*
* Test IRadio.setCdmaBroadcastConfig() for the response returned.
*/
TEST_F(RadioHidlTest, setCdmaBroadcastConfig) {
- int serial = 0;
+ int serial = 0;
- CdmaBroadcastSmsConfigInfo cbSmsConfig;
- cbSmsConfig.serviceCategory = 4096;
- cbSmsConfig.language = 1;
- cbSmsConfig.selected = true;
+ CdmaBroadcastSmsConfigInfo cbSmsConfig;
+ cbSmsConfig.serviceCategory = 4096;
+ cbSmsConfig.language = 1;
+ cbSmsConfig.selected = true;
- android::hardware::hidl_vec<CdmaBroadcastSmsConfigInfo> cdmaBroadcastSmsConfigInfoList
- = {cbSmsConfig};
+ android::hardware::hidl_vec<CdmaBroadcastSmsConfigInfo>
+ cdmaBroadcastSmsConfigInfoList = {cbSmsConfig};
- radio->setCdmaBroadcastConfig(++serial, cdmaBroadcastSmsConfigInfoList);
+ radio->setCdmaBroadcastConfig(++serial, cdmaBroadcastSmsConfigInfoList);
- EXPECT_EQ(std::cv_status::no_timeout, wait());
- EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
- EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+ EXPECT_EQ(std::cv_status::no_timeout, wait());
+ EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+ EXPECT_EQ(serial, radioRsp->rspInfo.serial);
- if (cardStatus.cardState == CardState::ABSENT) {
- EXPECT_EQ(RadioError::NONE, radioRsp->rspInfo.error);
- }
+ if (cardStatus.cardState == CardState::ABSENT) {
+ EXPECT_EQ(RadioError::NONE, radioRsp->rspInfo.error);
+ }
}
/*
* Test IRadio.getCdmaBroadcastConfig() for the response returned.
*/
TEST_F(RadioHidlTest, getCdmaBroadcastConfig) {
- int serial = 0;
+ int serial = 0;
- radio->getCdmaBroadcastConfig(++serial);
+ radio->getCdmaBroadcastConfig(++serial);
- EXPECT_EQ(std::cv_status::no_timeout, wait());
- EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
- EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+ EXPECT_EQ(std::cv_status::no_timeout, wait());
+ EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+ EXPECT_EQ(serial, radioRsp->rspInfo.serial);
- if (cardStatus.cardState == CardState::ABSENT) {
- EXPECT_EQ(RadioError::NONE, radioRsp->rspInfo.error);
- }
+ if (cardStatus.cardState == CardState::ABSENT) {
+ EXPECT_EQ(RadioError::NONE, radioRsp->rspInfo.error);
+ }
}
/*
* Test IRadio.setCdmaBroadcastActivation() for the response returned.
*/
TEST_F(RadioHidlTest, setCdmaBroadcastActivation) {
- int serial = 0;
- bool activate = false;
+ int serial = 0;
+ bool activate = false;
- radio->setCdmaBroadcastActivation(++serial, activate);
+ radio->setCdmaBroadcastActivation(++serial, activate);
- EXPECT_EQ(std::cv_status::no_timeout, wait());
- EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
- EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+ EXPECT_EQ(std::cv_status::no_timeout, wait());
+ EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+ EXPECT_EQ(serial, radioRsp->rspInfo.serial);
- if (cardStatus.cardState == CardState::ABSENT) {
- EXPECT_EQ(RadioError::NONE, radioRsp->rspInfo.error);
- }
+ if (cardStatus.cardState == CardState::ABSENT) {
+ EXPECT_EQ(RadioError::NONE, radioRsp->rspInfo.error);
+ }
}
/*
* Test IRadio.setGsmBroadcastActivation() for the response returned.
*/
TEST_F(RadioHidlTest, setGsmBroadcastActivation) {
- int serial = 0;
- bool activate = false;
+ int serial = 0;
+ bool activate = false;
- radio->setGsmBroadcastActivation(++serial, activate);
+ radio->setGsmBroadcastActivation(++serial, activate);
- EXPECT_EQ(std::cv_status::no_timeout, wait());
- EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
- EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+ EXPECT_EQ(std::cv_status::no_timeout, wait());
+ EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+ EXPECT_EQ(serial, radioRsp->rspInfo.serial);
- if (cardStatus.cardState == CardState::ABSENT) {
- EXPECT_EQ(RadioError::NONE, radioRsp->rspInfo.error);
- }
+ if (cardStatus.cardState == CardState::ABSENT) {
+ EXPECT_EQ(RadioError::NONE, radioRsp->rspInfo.error);
+ }
}
diff --git a/radio/1.0/vts/functional/radio_hidl_hal_data.cpp b/radio/1.0/vts/functional/radio_hidl_hal_data.cpp
index 06cab6a..526cb04 100644
--- a/radio/1.0/vts/functional/radio_hidl_hal_data.cpp
+++ b/radio/1.0/vts/functional/radio_hidl_hal_data.cpp
@@ -14,7 +14,7 @@
* limitations under the License.
*/
-#include<radio_hidl_hal_utils.h>
+#include <radio_hidl_hal_utils.h>
using namespace ::android::hardware::radio::V1_0;
@@ -22,198 +22,198 @@
* Test IRadio.getDataRegistrationState() for the response returned.
*/
TEST_F(RadioHidlTest, getDataRegistrationState) {
- int serial = 0;
+ int serial = 0;
- radio->getDataRegistrationState(++serial);
+ radio->getDataRegistrationState(++serial);
- EXPECT_EQ(std::cv_status::no_timeout, wait());
- EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
- EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+ EXPECT_EQ(std::cv_status::no_timeout, wait());
+ EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+ EXPECT_EQ(serial, radioRsp->rspInfo.serial);
- if (cardStatus.cardState == CardState::ABSENT) {
- EXPECT_EQ(RadioError::NONE, radioRsp->rspInfo.error);
- }
+ if (cardStatus.cardState == CardState::ABSENT) {
+ EXPECT_EQ(RadioError::NONE, radioRsp->rspInfo.error);
+ }
}
/*
* Test IRadio.setupDataCall() for the response returned.
*/
TEST_F(RadioHidlTest, setupDataCall) {
- int serial = 0;
+ int serial = 0;
- RadioTechnology radioTechnology = RadioTechnology::LTE;
+ RadioTechnology radioTechnology = RadioTechnology::LTE;
- DataProfileInfo dataProfileInfo;
- memset(&dataProfileInfo, 0, sizeof(dataProfileInfo));
- dataProfileInfo.profileId = DataProfileId::IMS;
- dataProfileInfo.apn = hidl_string("VZWIMS");
- dataProfileInfo.protocol = hidl_string("IPV4V6");
- dataProfileInfo.roamingProtocol = hidl_string("IPV6");
- dataProfileInfo.authType = ApnAuthType::NO_PAP_NO_CHAP;
- dataProfileInfo.user = "";
- dataProfileInfo.password = "";
- dataProfileInfo.type = DataProfileInfoType::THREE_GPP2;
- dataProfileInfo.maxConnsTime = 300;
- dataProfileInfo.maxConns = 20;
- dataProfileInfo.waitTime = 0;
- dataProfileInfo.enabled = true;
- dataProfileInfo.supportedApnTypesBitmap = 320;
- dataProfileInfo.bearerBitmap = 161543;
- dataProfileInfo.mtu = 0;
- dataProfileInfo.mvnoType = MvnoType::NONE;
- dataProfileInfo.mvnoMatchData = hidl_string();
+ DataProfileInfo dataProfileInfo;
+ memset(&dataProfileInfo, 0, sizeof(dataProfileInfo));
+ dataProfileInfo.profileId = DataProfileId::IMS;
+ dataProfileInfo.apn = hidl_string("VZWIMS");
+ dataProfileInfo.protocol = hidl_string("IPV4V6");
+ dataProfileInfo.roamingProtocol = hidl_string("IPV6");
+ dataProfileInfo.authType = ApnAuthType::NO_PAP_NO_CHAP;
+ dataProfileInfo.user = "";
+ dataProfileInfo.password = "";
+ dataProfileInfo.type = DataProfileInfoType::THREE_GPP2;
+ dataProfileInfo.maxConnsTime = 300;
+ dataProfileInfo.maxConns = 20;
+ dataProfileInfo.waitTime = 0;
+ dataProfileInfo.enabled = true;
+ dataProfileInfo.supportedApnTypesBitmap = 320;
+ dataProfileInfo.bearerBitmap = 161543;
+ dataProfileInfo.mtu = 0;
+ dataProfileInfo.mvnoType = MvnoType::NONE;
+ dataProfileInfo.mvnoMatchData = hidl_string();
- bool modemCognitive = false;
- bool roamingAllowed = false;
- bool isRoaming = false;
+ bool modemCognitive = false;
+ bool roamingAllowed = false;
+ bool isRoaming = false;
- radio->setupDataCall(++serial, radioTechnology, dataProfileInfo, modemCognitive,
- roamingAllowed, isRoaming);
+ radio->setupDataCall(++serial, radioTechnology, dataProfileInfo,
+ modemCognitive, roamingAllowed, isRoaming);
- EXPECT_EQ(std::cv_status::no_timeout, wait());
- EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
- EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+ EXPECT_EQ(std::cv_status::no_timeout, wait());
+ EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+ EXPECT_EQ(serial, radioRsp->rspInfo.serial);
- if (cardStatus.cardState == CardState::ABSENT) {
- ASSERT_FALSE(RadioError::NONE == radioRsp->rspInfo.error);
- }
+ if (cardStatus.cardState == CardState::ABSENT) {
+ ASSERT_FALSE(RadioError::NONE == radioRsp->rspInfo.error);
+ }
}
/*
* Test IRadio.deactivateDataCall() for the response returned.
*/
TEST_F(RadioHidlTest, deactivateDataCall) {
- int serial = 0;
- int cid = 1;
- bool reasonRadioShutDown = false;
+ int serial = 0;
+ int cid = 1;
+ bool reasonRadioShutDown = false;
- radio->deactivateDataCall(++serial, cid, reasonRadioShutDown);
+ radio->deactivateDataCall(++serial, cid, reasonRadioShutDown);
- EXPECT_EQ(std::cv_status::no_timeout, wait());
- EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
- EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+ EXPECT_EQ(std::cv_status::no_timeout, wait());
+ EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+ EXPECT_EQ(serial, radioRsp->rspInfo.serial);
- if (cardStatus.cardState == CardState::ABSENT) {
- EXPECT_EQ(RadioError::INVALID_ARGUMENTS, radioRsp->rspInfo.error);
- }
+ if (cardStatus.cardState == CardState::ABSENT) {
+ EXPECT_EQ(RadioError::INVALID_ARGUMENTS, radioRsp->rspInfo.error);
+ }
}
/*
* Test IRadio.getDataCallList() for the response returned.
*/
TEST_F(RadioHidlTest, getDataCallList) {
- int serial = 0;
+ int serial = 0;
- radio->getDataCallList(++serial);
+ radio->getDataCallList(++serial);
- EXPECT_EQ(std::cv_status::no_timeout, wait());
- EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
- EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+ EXPECT_EQ(std::cv_status::no_timeout, wait());
+ EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+ EXPECT_EQ(serial, radioRsp->rspInfo.serial);
- if (cardStatus.cardState == CardState::ABSENT) {
- EXPECT_EQ(RadioError::NONE, radioRsp->rspInfo.error);
- }
+ if (cardStatus.cardState == CardState::ABSENT) {
+ EXPECT_EQ(RadioError::NONE, radioRsp->rspInfo.error);
+ }
}
/*
* Test IRadio.setInitialAttachApn() for the response returned.
*/
TEST_F(RadioHidlTest, setInitialAttachApn) {
- int serial = 0;
+ int serial = 0;
- DataProfileInfo dataProfileInfo;
- memset(&dataProfileInfo, 0, sizeof(dataProfileInfo));
- dataProfileInfo.profileId = DataProfileId::IMS;
- dataProfileInfo.apn = hidl_string("VZWIMS");
- dataProfileInfo.protocol = hidl_string("IPV4V6");
- dataProfileInfo.roamingProtocol = hidl_string("IPV6");
- dataProfileInfo.authType = ApnAuthType::NO_PAP_NO_CHAP;
- dataProfileInfo.user = "";
- dataProfileInfo.password = "";
- dataProfileInfo.type = DataProfileInfoType::THREE_GPP2;
- dataProfileInfo.maxConnsTime = 300;
- dataProfileInfo.maxConns = 20;
- dataProfileInfo.waitTime = 0;
- dataProfileInfo.enabled = true;
- dataProfileInfo.supportedApnTypesBitmap = 320;
- dataProfileInfo.bearerBitmap = 161543;
- dataProfileInfo.mtu = 0;
- dataProfileInfo.mvnoType = MvnoType::NONE;
- dataProfileInfo.mvnoMatchData = hidl_string();
+ DataProfileInfo dataProfileInfo;
+ memset(&dataProfileInfo, 0, sizeof(dataProfileInfo));
+ dataProfileInfo.profileId = DataProfileId::IMS;
+ dataProfileInfo.apn = hidl_string("VZWIMS");
+ dataProfileInfo.protocol = hidl_string("IPV4V6");
+ dataProfileInfo.roamingProtocol = hidl_string("IPV6");
+ dataProfileInfo.authType = ApnAuthType::NO_PAP_NO_CHAP;
+ dataProfileInfo.user = "";
+ dataProfileInfo.password = "";
+ dataProfileInfo.type = DataProfileInfoType::THREE_GPP2;
+ dataProfileInfo.maxConnsTime = 300;
+ dataProfileInfo.maxConns = 20;
+ dataProfileInfo.waitTime = 0;
+ dataProfileInfo.enabled = true;
+ dataProfileInfo.supportedApnTypesBitmap = 320;
+ dataProfileInfo.bearerBitmap = 161543;
+ dataProfileInfo.mtu = 0;
+ dataProfileInfo.mvnoType = MvnoType::NONE;
+ dataProfileInfo.mvnoMatchData = hidl_string();
- bool modemCognitive = true;
- bool isRoaming = false;
+ bool modemCognitive = true;
+ bool isRoaming = false;
- radio->setInitialAttachApn(++serial, dataProfileInfo,
- modemCognitive, isRoaming);
+ radio->setInitialAttachApn(++serial, dataProfileInfo, modemCognitive,
+ isRoaming);
- EXPECT_EQ(std::cv_status::no_timeout, wait());
- EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
- EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+ EXPECT_EQ(std::cv_status::no_timeout, wait());
+ EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+ EXPECT_EQ(serial, radioRsp->rspInfo.serial);
- if (cardStatus.cardState == CardState::ABSENT) {
- ASSERT_FALSE(RadioError::NONE == radioRsp->rspInfo.error);
- }
+ if (cardStatus.cardState == CardState::ABSENT) {
+ ASSERT_FALSE(RadioError::NONE == radioRsp->rspInfo.error);
+ }
}
/*
* Test IRadio.setDataAllowed() for the response returned.
*/
TEST_F(RadioHidlTest, setDataAllowed) {
- int serial = 0;
- bool allow = true;
+ int serial = 0;
+ bool allow = true;
- radio->setDataAllowed(++serial, allow);
+ radio->setDataAllowed(++serial, allow);
- EXPECT_EQ(std::cv_status::no_timeout, wait());
- EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
- EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+ EXPECT_EQ(std::cv_status::no_timeout, wait());
+ EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+ EXPECT_EQ(serial, radioRsp->rspInfo.serial);
- if (cardStatus.cardState == CardState::ABSENT) {
- EXPECT_EQ(RadioError::NONE, radioRsp->rspInfo.error);
- }
+ if (cardStatus.cardState == CardState::ABSENT) {
+ EXPECT_EQ(RadioError::NONE, radioRsp->rspInfo.error);
+ }
}
/*
* Test IRadio.setDataProfile() for the response returned.
*/
TEST_F(RadioHidlTest, setDataProfile) {
- int serial = 0;
+ int serial = 0;
- // Create a dataProfileInfo
- DataProfileInfo dataProfileInfo;
- memset(&dataProfileInfo, 0, sizeof(dataProfileInfo));
- dataProfileInfo.profileId = DataProfileId::IMS;
- dataProfileInfo.apn = hidl_string("VZWIMS");
- dataProfileInfo.protocol = hidl_string("IPV4V6");
- dataProfileInfo.roamingProtocol = hidl_string("IPV6");
- dataProfileInfo.authType = ApnAuthType::NO_PAP_NO_CHAP;
- dataProfileInfo.user = "";
- dataProfileInfo.password = "";
- dataProfileInfo.type = DataProfileInfoType::THREE_GPP2;
- dataProfileInfo.maxConnsTime = 300;
- dataProfileInfo.maxConns = 20;
- dataProfileInfo.waitTime = 0;
- dataProfileInfo.enabled = true;
- dataProfileInfo.supportedApnTypesBitmap = 320;
- dataProfileInfo.bearerBitmap = 161543;
- dataProfileInfo.mtu = 0;
- dataProfileInfo.mvnoType = MvnoType::NONE;
- dataProfileInfo.mvnoMatchData = hidl_string();
+ // Create a dataProfileInfo
+ DataProfileInfo dataProfileInfo;
+ memset(&dataProfileInfo, 0, sizeof(dataProfileInfo));
+ dataProfileInfo.profileId = DataProfileId::IMS;
+ dataProfileInfo.apn = hidl_string("VZWIMS");
+ dataProfileInfo.protocol = hidl_string("IPV4V6");
+ dataProfileInfo.roamingProtocol = hidl_string("IPV6");
+ dataProfileInfo.authType = ApnAuthType::NO_PAP_NO_CHAP;
+ dataProfileInfo.user = "";
+ dataProfileInfo.password = "";
+ dataProfileInfo.type = DataProfileInfoType::THREE_GPP2;
+ dataProfileInfo.maxConnsTime = 300;
+ dataProfileInfo.maxConns = 20;
+ dataProfileInfo.waitTime = 0;
+ dataProfileInfo.enabled = true;
+ dataProfileInfo.supportedApnTypesBitmap = 320;
+ dataProfileInfo.bearerBitmap = 161543;
+ dataProfileInfo.mtu = 0;
+ dataProfileInfo.mvnoType = MvnoType::NONE;
+ dataProfileInfo.mvnoMatchData = hidl_string();
- // Create a dataProfileInfoList
- android::hardware::hidl_vec<DataProfileInfo> dataProfileInfoList = {dataProfileInfo};
+ // Create a dataProfileInfoList
+ android::hardware::hidl_vec<DataProfileInfo> dataProfileInfoList = {
+ dataProfileInfo};
- bool isRoadming = false;
+ bool isRoadming = false;
- radio->setDataProfile(++serial, dataProfileInfoList, isRoadming);
+ radio->setDataProfile(++serial, dataProfileInfoList, isRoadming);
- EXPECT_EQ(std::cv_status::no_timeout, wait());
- EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
- EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+ EXPECT_EQ(std::cv_status::no_timeout, wait());
+ EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+ EXPECT_EQ(serial, radioRsp->rspInfo.serial);
- if (cardStatus.cardState == CardState::ABSENT) {
- // TODO(shuoq): Will add error check when we know the expected error from QC
- }
+ if (cardStatus.cardState == CardState::ABSENT) {
+ // TODO(shuoq): Will add error check when we know the expected error from QC
+ }
}
-
diff --git a/radio/1.0/vts/functional/radio_hidl_hal_icc.cpp b/radio/1.0/vts/functional/radio_hidl_hal_icc.cpp
index 9cae9c2..19738d5 100644
--- a/radio/1.0/vts/functional/radio_hidl_hal_icc.cpp
+++ b/radio/1.0/vts/functional/radio_hidl_hal_icc.cpp
@@ -14,293 +14,307 @@
* limitations under the License.
*/
- #include<radio_hidl_hal_utils.h>
+#include <radio_hidl_hal_utils.h>
/*
* Test IRadio.getIccCardStatus() for the response returned.
*/
TEST_F(RadioHidlTest, getIccCardStatus) {
- EXPECT_LE(cardStatus.applications.size(), (unsigned int) RadioConst::CARD_MAX_APPS);
- EXPECT_LT(cardStatus.gsmUmtsSubscriptionAppIndex, (int) RadioConst::CARD_MAX_APPS);
- EXPECT_LT(cardStatus.cdmaSubscriptionAppIndex, (int) RadioConst::CARD_MAX_APPS);
- EXPECT_LT(cardStatus.imsSubscriptionAppIndex, (int) RadioConst::CARD_MAX_APPS);
+ EXPECT_LE(cardStatus.applications.size(),
+ (unsigned int)RadioConst::CARD_MAX_APPS);
+ EXPECT_LT(cardStatus.gsmUmtsSubscriptionAppIndex,
+ (int)RadioConst::CARD_MAX_APPS);
+ EXPECT_LT(cardStatus.cdmaSubscriptionAppIndex,
+ (int)RadioConst::CARD_MAX_APPS);
+ EXPECT_LT(cardStatus.imsSubscriptionAppIndex, (int)RadioConst::CARD_MAX_APPS);
}
/*
* Test IRadio.supplyIccPinForApp() for the response returned
*/
TEST_F(RadioHidlTest, supplyIccPinForApp) {
- int serial = 1;
+ int serial = 1;
- // Pass wrong password and check PASSWORD_INCORRECT returned for 3GPP and 3GPP2 apps only
- for (int i = 0; i < (int) cardStatus.applications.size(); i++) {
- if (cardStatus.applications[i].appType == AppType::SIM
- || cardStatus.applications[i].appType == AppType::USIM
- || cardStatus.applications[i].appType == AppType::RUIM
- || cardStatus.applications[i].appType == AppType::CSIM) {
- radio->supplyIccPinForApp(++serial, hidl_string("test1"),
- cardStatus.applications[i].aidPtr);
- EXPECT_EQ(std::cv_status::no_timeout, wait());
- EXPECT_EQ(serial, radioRsp->rspInfo.serial);
- EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
- EXPECT_EQ(RadioError::PASSWORD_INCORRECT, radioRsp->rspInfo.error);
- }
+ // Pass wrong password and check PASSWORD_INCORRECT returned for 3GPP and
+ // 3GPP2 apps only
+ for (int i = 0; i < (int)cardStatus.applications.size(); i++) {
+ if (cardStatus.applications[i].appType == AppType::SIM ||
+ cardStatus.applications[i].appType == AppType::USIM ||
+ cardStatus.applications[i].appType == AppType::RUIM ||
+ cardStatus.applications[i].appType == AppType::CSIM) {
+ radio->supplyIccPinForApp(++serial, hidl_string("test1"),
+ cardStatus.applications[i].aidPtr);
+ EXPECT_EQ(std::cv_status::no_timeout, wait());
+ EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+ EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+ EXPECT_EQ(RadioError::PASSWORD_INCORRECT, radioRsp->rspInfo.error);
}
+ }
}
/*
* Test IRadio.supplyIccPukForApp() for the response returned.
*/
TEST_F(RadioHidlTest, supplyIccPukForApp) {
- int serial = 1;
+ int serial = 1;
- // Pass wrong password and check PASSWORD_INCORRECT returned for 3GPP and 3GPP2 apps only
- for (int i = 0; i < (int) cardStatus.applications.size(); i++) {
- if (cardStatus.applications[i].appType == AppType::SIM
- || cardStatus.applications[i].appType == AppType::USIM
- || cardStatus.applications[i].appType == AppType::RUIM
- || cardStatus.applications[i].appType == AppType::CSIM) {
- radio->supplyIccPukForApp(++serial, hidl_string("test1"), hidl_string("test2"),
- cardStatus.applications[i].aidPtr);
- EXPECT_EQ(std::cv_status::no_timeout, wait());
- EXPECT_EQ(serial, radioRsp->rspInfo.serial);
- EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
- EXPECT_EQ(RadioError::PASSWORD_INCORRECT, radioRsp->rspInfo.error);
- }
+ // Pass wrong password and check PASSWORD_INCORRECT returned for 3GPP and
+ // 3GPP2 apps only
+ for (int i = 0; i < (int)cardStatus.applications.size(); i++) {
+ if (cardStatus.applications[i].appType == AppType::SIM ||
+ cardStatus.applications[i].appType == AppType::USIM ||
+ cardStatus.applications[i].appType == AppType::RUIM ||
+ cardStatus.applications[i].appType == AppType::CSIM) {
+ radio->supplyIccPukForApp(++serial, hidl_string("test1"),
+ hidl_string("test2"),
+ cardStatus.applications[i].aidPtr);
+ EXPECT_EQ(std::cv_status::no_timeout, wait());
+ EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+ EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+ EXPECT_EQ(RadioError::PASSWORD_INCORRECT, radioRsp->rspInfo.error);
}
+ }
}
/*
* Test IRadio.supplyIccPin2ForApp() for the response returned.
*/
TEST_F(RadioHidlTest, supplyIccPin2ForApp) {
- int serial = 1;
+ int serial = 1;
- // Pass wrong password and check PASSWORD_INCORRECT returned for 3GPP and 3GPP2 apps only
- for (int i = 0; i < (int) cardStatus.applications.size(); i++) {
- if (cardStatus.applications[i].appType == AppType::SIM
- || cardStatus.applications[i].appType == AppType::USIM
- || cardStatus.applications[i].appType == AppType::RUIM
- || cardStatus.applications[i].appType == AppType::CSIM) {
- radio->supplyIccPin2ForApp(++serial, hidl_string("test1"),
- cardStatus.applications[i].aidPtr);
- EXPECT_EQ(std::cv_status::no_timeout, wait());
- EXPECT_EQ(serial, radioRsp->rspInfo.serial);
- EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
- EXPECT_EQ(RadioError::PASSWORD_INCORRECT, radioRsp->rspInfo.error);
- }
+ // Pass wrong password and check PASSWORD_INCORRECT returned for 3GPP and
+ // 3GPP2 apps only
+ for (int i = 0; i < (int)cardStatus.applications.size(); i++) {
+ if (cardStatus.applications[i].appType == AppType::SIM ||
+ cardStatus.applications[i].appType == AppType::USIM ||
+ cardStatus.applications[i].appType == AppType::RUIM ||
+ cardStatus.applications[i].appType == AppType::CSIM) {
+ radio->supplyIccPin2ForApp(++serial, hidl_string("test1"),
+ cardStatus.applications[i].aidPtr);
+ EXPECT_EQ(std::cv_status::no_timeout, wait());
+ EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+ EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+ EXPECT_EQ(RadioError::PASSWORD_INCORRECT, radioRsp->rspInfo.error);
}
+ }
}
/*
* Test IRadio.supplyIccPuk2ForApp() for the response returned.
*/
TEST_F(RadioHidlTest, supplyIccPuk2ForApp) {
- int serial = 1;
+ int serial = 1;
- // Pass wrong password and check PASSWORD_INCORRECT returned for 3GPP and 3GPP2 apps only
- for (int i = 0; i < (int) cardStatus.applications.size(); i++) {
- if (cardStatus.applications[i].appType == AppType::SIM
- || cardStatus.applications[i].appType == AppType::USIM
- || cardStatus.applications[i].appType == AppType::RUIM
- || cardStatus.applications[i].appType == AppType::CSIM) {
- radio->supplyIccPuk2ForApp(++serial, hidl_string("test1"), hidl_string("test2"),
- cardStatus.applications[i].aidPtr);
- EXPECT_EQ(std::cv_status::no_timeout, wait());
- EXPECT_EQ(serial, radioRsp->rspInfo.serial);
- EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
- EXPECT_EQ(RadioError::PASSWORD_INCORRECT, radioRsp->rspInfo.error);
- }
+ // Pass wrong password and check PASSWORD_INCORRECT returned for 3GPP and
+ // 3GPP2 apps only
+ for (int i = 0; i < (int)cardStatus.applications.size(); i++) {
+ if (cardStatus.applications[i].appType == AppType::SIM ||
+ cardStatus.applications[i].appType == AppType::USIM ||
+ cardStatus.applications[i].appType == AppType::RUIM ||
+ cardStatus.applications[i].appType == AppType::CSIM) {
+ radio->supplyIccPuk2ForApp(++serial, hidl_string("test1"),
+ hidl_string("test2"),
+ cardStatus.applications[i].aidPtr);
+ EXPECT_EQ(std::cv_status::no_timeout, wait());
+ EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+ EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+ EXPECT_EQ(RadioError::PASSWORD_INCORRECT, radioRsp->rspInfo.error);
}
+ }
}
/*
* Test IRadio.changeIccPinForApp() for the response returned.
*/
TEST_F(RadioHidlTest, changeIccPinForApp) {
- int serial = 1;
+ int serial = 1;
- // Pass wrong password and check PASSWORD_INCORRECT returned for 3GPP and 3GPP2 apps only
- for (int i = 0; i < (int) cardStatus.applications.size(); i++) {
- if (cardStatus.applications[i].appType == AppType::SIM
- || cardStatus.applications[i].appType == AppType::USIM
- || cardStatus.applications[i].appType == AppType::RUIM
- || cardStatus.applications[i].appType == AppType::CSIM) {
- radio->changeIccPinForApp(++serial, hidl_string("test1"), hidl_string("test2"),
- cardStatus.applications[i].aidPtr);
- EXPECT_EQ(std::cv_status::no_timeout, wait());
- EXPECT_EQ(serial, radioRsp->rspInfo.serial);
- EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
- EXPECT_EQ(RadioError::PASSWORD_INCORRECT, radioRsp->rspInfo.error);
- }
+ // Pass wrong password and check PASSWORD_INCORRECT returned for 3GPP and
+ // 3GPP2 apps only
+ for (int i = 0; i < (int)cardStatus.applications.size(); i++) {
+ if (cardStatus.applications[i].appType == AppType::SIM ||
+ cardStatus.applications[i].appType == AppType::USIM ||
+ cardStatus.applications[i].appType == AppType::RUIM ||
+ cardStatus.applications[i].appType == AppType::CSIM) {
+ radio->changeIccPinForApp(++serial, hidl_string("test1"),
+ hidl_string("test2"),
+ cardStatus.applications[i].aidPtr);
+ EXPECT_EQ(std::cv_status::no_timeout, wait());
+ EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+ EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+ EXPECT_EQ(RadioError::PASSWORD_INCORRECT, radioRsp->rspInfo.error);
}
+ }
}
/*
* Test IRadio.changeIccPin2ForApp() for the response returned.
*/
TEST_F(RadioHidlTest, changeIccPin2ForApp) {
- int serial = 1;
+ int serial = 1;
- // Pass wrong password and check PASSWORD_INCORRECT returned for 3GPP and 3GPP2 apps only
- for (int i = 0; i < (int) cardStatus.applications.size(); i++) {
- if (cardStatus.applications[i].appType == AppType::SIM
- || cardStatus.applications[i].appType == AppType::USIM
- || cardStatus.applications[i].appType == AppType::RUIM
- || cardStatus.applications[i].appType == AppType::CSIM) {
- radio->changeIccPin2ForApp(++serial, hidl_string("test1"), hidl_string("test2"),
- cardStatus.applications[i].aidPtr);
- EXPECT_EQ(std::cv_status::no_timeout, wait());
- EXPECT_EQ(serial, radioRsp->rspInfo.serial);
- EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
- EXPECT_EQ(RadioError::PASSWORD_INCORRECT, radioRsp->rspInfo.error);
- }
+ // Pass wrong password and check PASSWORD_INCORRECT returned for 3GPP and
+ // 3GPP2 apps only
+ for (int i = 0; i < (int)cardStatus.applications.size(); i++) {
+ if (cardStatus.applications[i].appType == AppType::SIM ||
+ cardStatus.applications[i].appType == AppType::USIM ||
+ cardStatus.applications[i].appType == AppType::RUIM ||
+ cardStatus.applications[i].appType == AppType::CSIM) {
+ radio->changeIccPin2ForApp(++serial, hidl_string("test1"),
+ hidl_string("test2"),
+ cardStatus.applications[i].aidPtr);
+ EXPECT_EQ(std::cv_status::no_timeout, wait());
+ EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+ EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+ EXPECT_EQ(RadioError::PASSWORD_INCORRECT, radioRsp->rspInfo.error);
}
+ }
}
/*
* Test IRadio.getImsiForApp() for the response returned.
*/
TEST_F(RadioHidlTest, getImsiForApp) {
- int serial = 1;
+ int serial = 1;
- // Check success returned while getting imsi for 3GPP and 3GPP2 apps only
- for (int i = 0; i < (int) cardStatus.applications.size(); i++) {
- if (cardStatus.applications[i].appType == AppType::SIM
- || cardStatus.applications[i].appType == AppType::USIM
- || cardStatus.applications[i].appType == AppType::RUIM
- || cardStatus.applications[i].appType == AppType::CSIM) {
- radio->getImsiForApp(++serial, cardStatus.applications[i].aidPtr);
- EXPECT_EQ(std::cv_status::no_timeout, wait());
- EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
- EXPECT_EQ(serial, radioRsp->rspInfo.serial);
- EXPECT_EQ(RadioError::NONE, radioRsp->rspInfo.error);
+ // Check success returned while getting imsi for 3GPP and 3GPP2 apps only
+ for (int i = 0; i < (int)cardStatus.applications.size(); i++) {
+ if (cardStatus.applications[i].appType == AppType::SIM ||
+ cardStatus.applications[i].appType == AppType::USIM ||
+ cardStatus.applications[i].appType == AppType::RUIM ||
+ cardStatus.applications[i].appType == AppType::CSIM) {
+ radio->getImsiForApp(++serial, cardStatus.applications[i].aidPtr);
+ EXPECT_EQ(std::cv_status::no_timeout, wait());
+ EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+ EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+ EXPECT_EQ(RadioError::NONE, radioRsp->rspInfo.error);
- // IMSI (MCC+MNC+MSIN) is at least 6 digits, but not more than 15
- if (radioRsp->rspInfo.error == RadioError::NONE) {
- EXPECT_NE(radioRsp->imsi, hidl_string());
- EXPECT_GE((int) (radioRsp->imsi).size(), 6);
- EXPECT_LE((int) (radioRsp->imsi).size(), 15);
- }
- }
+ // IMSI (MCC+MNC+MSIN) is at least 6 digits, but not more than 15
+ if (radioRsp->rspInfo.error == RadioError::NONE) {
+ EXPECT_NE(radioRsp->imsi, hidl_string());
+ EXPECT_GE((int)(radioRsp->imsi).size(), 6);
+ EXPECT_LE((int)(radioRsp->imsi).size(), 15);
+ }
}
+ }
}
/*
* Test IRadio.iccIOForApp() for the response returned.
*/
TEST_F(RadioHidlTest, iccIOForApp) {
- int serial = 1;
+ int serial = 1;
- for (int i = 0; i < (int) cardStatus.applications.size(); i++) {
- IccIo iccIo;
- iccIo.command = 0xc0;
- iccIo.fileId = 0x6f11;
- iccIo.path = hidl_string("3F007FFF");
- iccIo.p1 = 0;
- iccIo.p2 = 0;
- iccIo.p3 = 0;
- iccIo.data = hidl_string();
- iccIo.pin2 = hidl_string();
- iccIo.aid = cardStatus.applications[i].aidPtr;
+ for (int i = 0; i < (int)cardStatus.applications.size(); i++) {
+ IccIo iccIo;
+ iccIo.command = 0xc0;
+ iccIo.fileId = 0x6f11;
+ iccIo.path = hidl_string("3F007FFF");
+ iccIo.p1 = 0;
+ iccIo.p2 = 0;
+ iccIo.p3 = 0;
+ iccIo.data = hidl_string();
+ iccIo.pin2 = hidl_string();
+ iccIo.aid = cardStatus.applications[i].aidPtr;
- radio->iccIOForApp(++serial, iccIo);
- EXPECT_EQ(std::cv_status::no_timeout, wait());
- EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
- EXPECT_EQ(serial, radioRsp->rspInfo.serial);
- }
+ radio->iccIOForApp(++serial, iccIo);
+ EXPECT_EQ(std::cv_status::no_timeout, wait());
+ EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+ EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+ }
}
/*
* Test IRadio.iccTransmitApduBasicChannel() for the response returned.
*/
TEST_F(RadioHidlTest, iccTransmitApduBasicChannel) {
- int serial = 1;
- SimApdu msg;
- memset(&msg, 0, sizeof(msg));
- msg.data = hidl_string();
+ int serial = 1;
+ SimApdu msg;
+ memset(&msg, 0, sizeof(msg));
+ msg.data = hidl_string();
- radio->iccTransmitApduBasicChannel(serial, msg);
- EXPECT_EQ(std::cv_status::no_timeout, wait());
- EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
- EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+ radio->iccTransmitApduBasicChannel(serial, msg);
+ EXPECT_EQ(std::cv_status::no_timeout, wait());
+ EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+ EXPECT_EQ(serial, radioRsp->rspInfo.serial);
- // TODO(sanketpadawe): Add test for error code
+ // TODO(sanketpadawe): Add test for error code
}
/*
* Test IRadio.iccOpenLogicalChannel() for the response returned.
*/
TEST_F(RadioHidlTest, iccOpenLogicalChannel) {
- int serial = 1;
+ int serial = 1;
- for (int i = 0; i < (int) cardStatus.applications.size(); i++) {
- radio->iccOpenLogicalChannel(++serial, cardStatus.applications[i].aidPtr);
- EXPECT_EQ(std::cv_status::no_timeout, wait());
- EXPECT_EQ(serial, radioRsp->rspInfo.serial);
- EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
- }
+ for (int i = 0; i < (int)cardStatus.applications.size(); i++) {
+ radio->iccOpenLogicalChannel(++serial, cardStatus.applications[i].aidPtr);
+ EXPECT_EQ(std::cv_status::no_timeout, wait());
+ EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+ EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+ }
}
/*
* Test IRadio.iccCloseLogicalChannel() for the response returned.
*/
TEST_F(RadioHidlTest, iccCloseLogicalChannel) {
- int serial = 1;
- // Try closing invalid channel and check INVALID_ARGUMENTS returned as error
- radio->iccCloseLogicalChannel(serial, 0);
- EXPECT_EQ(std::cv_status::no_timeout, wait());
- EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
- EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+ int serial = 1;
+ // Try closing invalid channel and check INVALID_ARGUMENTS returned as error
+ radio->iccCloseLogicalChannel(serial, 0);
+ EXPECT_EQ(std::cv_status::no_timeout, wait());
+ EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+ EXPECT_EQ(serial, radioRsp->rspInfo.serial);
- EXPECT_EQ(RadioError::INVALID_ARGUMENTS, radioRsp->rspInfo.error);
+ EXPECT_EQ(RadioError::INVALID_ARGUMENTS, radioRsp->rspInfo.error);
}
/*
* Test IRadio.iccTransmitApduLogicalChannel() for the response returned.
*/
TEST_F(RadioHidlTest, iccTransmitApduLogicalChannel) {
- SimApdu msg;
- memset(&msg, 0, sizeof(msg));
- msg.data = hidl_string();
+ SimApdu msg;
+ memset(&msg, 0, sizeof(msg));
+ msg.data = hidl_string();
- radio->iccTransmitApduLogicalChannel(1, msg);
- EXPECT_EQ(std::cv_status::no_timeout, wait());
- EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
- EXPECT_EQ(1, radioRsp->rspInfo.serial);
+ radio->iccTransmitApduLogicalChannel(1, msg);
+ EXPECT_EQ(std::cv_status::no_timeout, wait());
+ EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+ EXPECT_EQ(1, radioRsp->rspInfo.serial);
- // TODO(sanketpadawe): Add test for error code
+ // TODO(sanketpadawe): Add test for error code
}
/*
* Test IRadio.requestIccSimAuthentication() for the response returned.
*/
TEST_F(RadioHidlTest, requestIccSimAuthentication) {
- int serial = 1;
+ int serial = 1;
- // Pass wrong challenge string and check RadioError::INVALID_ARGUMENTS returned as error.
- for (int i = 0; i < (int) cardStatus.applications.size(); i++) {
- radio->requestIccSimAuthentication(++serial, 0, hidl_string("test"),
- cardStatus.applications[i].aidPtr);
- EXPECT_EQ(std::cv_status::no_timeout, wait());
- EXPECT_EQ(serial, radioRsp->rspInfo.serial);
- EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
- EXPECT_EQ(RadioError::INVALID_ARGUMENTS, radioRsp->rspInfo.error);
- }
+ // Pass wrong challenge string and check RadioError::INVALID_ARGUMENTS
+ // returned as error.
+ for (int i = 0; i < (int)cardStatus.applications.size(); i++) {
+ radio->requestIccSimAuthentication(++serial, 0, hidl_string("test"),
+ cardStatus.applications[i].aidPtr);
+ EXPECT_EQ(std::cv_status::no_timeout, wait());
+ EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+ EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+ EXPECT_EQ(RadioError::INVALID_ARGUMENTS, radioRsp->rspInfo.error);
+ }
}
/*
* Test IRadio.supplyNetworkDepersonalization() for the response returned.
*/
TEST_F(RadioHidlTest, supplyNetworkDepersonalization) {
- int serial = 1;
+ int serial = 1;
- radio->supplyNetworkDepersonalization(serial, hidl_string("test"));
- EXPECT_EQ(std::cv_status::no_timeout, wait());
- EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
- EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+ radio->supplyNetworkDepersonalization(serial, hidl_string("test"));
+ EXPECT_EQ(std::cv_status::no_timeout, wait());
+ EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+ EXPECT_EQ(serial, radioRsp->rspInfo.serial);
- if (cardStatus.cardState == CardState::ABSENT) {
- ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::PASSWORD_INCORRECT);
- }
+ if (cardStatus.cardState == CardState::ABSENT) {
+ ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::PASSWORD_INCORRECT);
+ }
}
\ No newline at end of file
diff --git a/radio/1.0/vts/functional/radio_hidl_hal_ims.cpp b/radio/1.0/vts/functional/radio_hidl_hal_ims.cpp
index fdc39d8..0ec2e5c 100644
--- a/radio/1.0/vts/functional/radio_hidl_hal_ims.cpp
+++ b/radio/1.0/vts/functional/radio_hidl_hal_ims.cpp
@@ -14,7 +14,7 @@
* limitations under the License.
*/
-#include<radio_hidl_hal_utils.h>
+#include <radio_hidl_hal_utils.h>
using namespace ::android::hardware::radio::V1_0;
@@ -22,179 +22,181 @@
* Test IRadio.getClir() for the response returned.
*/
TEST_F(RadioHidlTest, getClir) {
- int serial = 0;
+ int serial = 0;
- radio->getClir(++serial);
+ radio->getClir(++serial);
- EXPECT_EQ(std::cv_status::no_timeout, wait());
- EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
- EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+ EXPECT_EQ(std::cv_status::no_timeout, wait());
+ EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+ EXPECT_EQ(serial, radioRsp->rspInfo.serial);
- if (cardStatus.cardState == CardState::ABSENT) {
- ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::MODEM_ERR
- || radioRsp->rspInfo.error == RadioError::SYSTEM_ERR
- || radioRsp->rspInfo.error == RadioError::INTERNAL_ERR);
- }
+ if (cardStatus.cardState == CardState::ABSENT) {
+ ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::MODEM_ERR ||
+ radioRsp->rspInfo.error == RadioError::SYSTEM_ERR ||
+ radioRsp->rspInfo.error == RadioError::INTERNAL_ERR);
+ }
}
/*
* Test IRadio.setClir() for the response returned.
*/
TEST_F(RadioHidlTest, setClir) {
- int serial = 0;
- int32_t status = 1;
+ int serial = 0;
+ int32_t status = 1;
- radio->setClir(++serial, status);
+ radio->setClir(++serial, status);
- EXPECT_EQ(std::cv_status::no_timeout, wait());
- EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
- EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+ EXPECT_EQ(std::cv_status::no_timeout, wait());
+ EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+ EXPECT_EQ(serial, radioRsp->rspInfo.serial);
- if (cardStatus.cardState == CardState::ABSENT) {
- EXPECT_EQ(RadioError::NONE, radioRsp->rspInfo.error);
- }
+ if (cardStatus.cardState == CardState::ABSENT) {
+ EXPECT_EQ(RadioError::NONE, radioRsp->rspInfo.error);
+ }
}
/*
* Test IRadio.getFacilityLockForApp() for the response returned.
*/
TEST_F(RadioHidlTest, getFacilityLockForApp) {
- int serial = 0;
- std::string facility = "";
- std::string password = "";
- int32_t serviceClass = 1;
- std::string appId = "";
+ int serial = 0;
+ std::string facility = "";
+ std::string password = "";
+ int32_t serviceClass = 1;
+ std::string appId = "";
- radio->getFacilityLockForApp(++serial, facility, password, serviceClass, appId);
+ radio->getFacilityLockForApp(++serial, facility, password, serviceClass,
+ appId);
- EXPECT_EQ(std::cv_status::no_timeout, wait());
- EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
- EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+ EXPECT_EQ(std::cv_status::no_timeout, wait());
+ EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+ EXPECT_EQ(serial, radioRsp->rspInfo.serial);
- if (cardStatus.cardState == CardState::ABSENT) {
- ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS
- || radioRsp->rspInfo.error == RadioError::MODEM_ERR
- || radioRsp->rspInfo.error == RadioError::SYSTEM_ERR
- || radioRsp->rspInfo.error == RadioError::INTERNAL_ERR);
- }
+ if (cardStatus.cardState == CardState::ABSENT) {
+ ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS ||
+ radioRsp->rspInfo.error == RadioError::MODEM_ERR ||
+ radioRsp->rspInfo.error == RadioError::SYSTEM_ERR ||
+ radioRsp->rspInfo.error == RadioError::INTERNAL_ERR);
+ }
}
/*
* Test IRadio.setFacilityLockForApp() for the response returned.
*/
TEST_F(RadioHidlTest, setFacilityLockForApp) {
- int serial = 0;
- std::string facility = "";
- bool lockState = false;
- std::string password = "";
- int32_t serviceClass = 1;
- std::string appId = "";
+ int serial = 0;
+ std::string facility = "";
+ bool lockState = false;
+ std::string password = "";
+ int32_t serviceClass = 1;
+ std::string appId = "";
- radio->setFacilityLockForApp(++serial, facility, lockState, password, serviceClass, appId);
+ radio->setFacilityLockForApp(++serial, facility, lockState, password,
+ serviceClass, appId);
- EXPECT_EQ(std::cv_status::no_timeout, wait());
- EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
- EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+ EXPECT_EQ(std::cv_status::no_timeout, wait());
+ EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+ EXPECT_EQ(serial, radioRsp->rspInfo.serial);
- if (cardStatus.cardState == CardState::ABSENT) {
- ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS
- || radioRsp->rspInfo.error == RadioError::MODEM_ERR
- || radioRsp->rspInfo.error == RadioError::SYSTEM_ERR
- || radioRsp->rspInfo.error == RadioError::INTERNAL_ERR);
- }
+ if (cardStatus.cardState == CardState::ABSENT) {
+ ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS ||
+ radioRsp->rspInfo.error == RadioError::MODEM_ERR ||
+ radioRsp->rspInfo.error == RadioError::SYSTEM_ERR ||
+ radioRsp->rspInfo.error == RadioError::INTERNAL_ERR);
+ }
}
/*
* Test IRadio.setBarringPassword() for the response returned.
*/
TEST_F(RadioHidlTest, setBarringPassword) {
- int serial = 0;
- std::string facility = "";
- std::string oldPassword = "";
- std::string newPassword = "";
+ int serial = 0;
+ std::string facility = "";
+ std::string oldPassword = "";
+ std::string newPassword = "";
- radio->setBarringPassword(++serial, facility, oldPassword, newPassword);
+ radio->setBarringPassword(++serial, facility, oldPassword, newPassword);
- EXPECT_EQ(std::cv_status::no_timeout, wait());
- EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
- EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+ EXPECT_EQ(std::cv_status::no_timeout, wait());
+ EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+ EXPECT_EQ(serial, radioRsp->rspInfo.serial);
- if (cardStatus.cardState == CardState::ABSENT) {
- ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS
- || radioRsp->rspInfo.error == RadioError::MODEM_ERR
- || radioRsp->rspInfo.error == RadioError::SYSTEM_ERR
- || radioRsp->rspInfo.error == RadioError::INTERNAL_ERR);
- }
+ if (cardStatus.cardState == CardState::ABSENT) {
+ ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS ||
+ radioRsp->rspInfo.error == RadioError::MODEM_ERR ||
+ radioRsp->rspInfo.error == RadioError::SYSTEM_ERR ||
+ radioRsp->rspInfo.error == RadioError::INTERNAL_ERR);
+ }
}
/*
* Test IRadio.getClip() for the response returned.
*/
TEST_F(RadioHidlTest, getClip) {
- int serial = 0;
+ int serial = 0;
- radio->getClip(++serial);
+ radio->getClip(++serial);
- EXPECT_EQ(std::cv_status::no_timeout, wait());
- EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
- EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+ EXPECT_EQ(std::cv_status::no_timeout, wait());
+ EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+ EXPECT_EQ(serial, radioRsp->rspInfo.serial);
- if (cardStatus.cardState == CardState::ABSENT) {
- ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::MODEM_ERR
- || radioRsp->rspInfo.error == RadioError::SYSTEM_ERR
- || radioRsp->rspInfo.error == RadioError::INTERNAL_ERR);
- }
+ if (cardStatus.cardState == CardState::ABSENT) {
+ ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::MODEM_ERR ||
+ radioRsp->rspInfo.error == RadioError::SYSTEM_ERR ||
+ radioRsp->rspInfo.error == RadioError::INTERNAL_ERR);
+ }
}
/*
* Test IRadio.setSuppServiceNotifications() for the response returned.
*/
TEST_F(RadioHidlTest, setSuppServiceNotifications) {
- int serial = 0;
- bool enable = false;
+ int serial = 0;
+ bool enable = false;
- radio->setSuppServiceNotifications(++serial, enable);
+ radio->setSuppServiceNotifications(++serial, enable);
- EXPECT_EQ(std::cv_status::no_timeout, wait());
- EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
- EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+ EXPECT_EQ(std::cv_status::no_timeout, wait());
+ EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+ EXPECT_EQ(serial, radioRsp->rspInfo.serial);
- if (cardStatus.cardState == CardState::ABSENT) {
- EXPECT_EQ(RadioError::NONE, radioRsp->rspInfo.error);
- }
+ if (cardStatus.cardState == CardState::ABSENT) {
+ EXPECT_EQ(RadioError::NONE, radioRsp->rspInfo.error);
+ }
}
/*
* Test IRadio.requestIsimAuthentication() for the response returned.
*/
TEST_F(RadioHidlTest, requestIsimAuthentication) {
- int serial = 0;
- std::string challenge = "";
+ int serial = 0;
+ std::string challenge = "";
- radio->requestIsimAuthentication(++serial, challenge);
+ radio->requestIsimAuthentication(++serial, challenge);
- EXPECT_EQ(std::cv_status::no_timeout, wait());
- EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
- EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+ EXPECT_EQ(std::cv_status::no_timeout, wait());
+ EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+ EXPECT_EQ(serial, radioRsp->rspInfo.serial);
- if (cardStatus.cardState == CardState::ABSENT) {
- EXPECT_EQ(RadioError::NONE, radioRsp->rspInfo.error);
- }
+ if (cardStatus.cardState == CardState::ABSENT) {
+ EXPECT_EQ(RadioError::NONE, radioRsp->rspInfo.error);
+ }
}
/*
* Test IRadio.getImsRegistrationState() for the response returned.
*/
TEST_F(RadioHidlTest, getImsRegistrationState) {
- int serial = 0;
+ int serial = 0;
- radio->getImsRegistrationState(++serial);
+ radio->getImsRegistrationState(++serial);
- EXPECT_EQ(std::cv_status::no_timeout, wait());
- EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
- EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+ EXPECT_EQ(std::cv_status::no_timeout, wait());
+ EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+ EXPECT_EQ(serial, radioRsp->rspInfo.serial);
- if (cardStatus.cardState == CardState::ABSENT) {
- EXPECT_EQ(RadioError::NONE, radioRsp->rspInfo.error);
- }
+ if (cardStatus.cardState == CardState::ABSENT) {
+ EXPECT_EQ(RadioError::NONE, radioRsp->rspInfo.error);
+ }
}
diff --git a/radio/1.0/vts/functional/radio_hidl_hal_misc.cpp b/radio/1.0/vts/functional/radio_hidl_hal_misc.cpp
index f704520..2e0a10f 100644
--- a/radio/1.0/vts/functional/radio_hidl_hal_misc.cpp
+++ b/radio/1.0/vts/functional/radio_hidl_hal_misc.cpp
@@ -14,778 +14,779 @@
* limitations under the License.
*/
-#include<radio_hidl_hal_utils.h>
+#include <radio_hidl_hal_utils.h>
/*
* Test IRadio.getSignalStrength() for the response returned.
*/
TEST_F(RadioHidlTest, getSignalStrength) {
- int serial = 1;
+ int serial = 1;
- radio->getSignalStrength(++serial);
- EXPECT_EQ(std::cv_status::no_timeout, wait());
- EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
- EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+ radio->getSignalStrength(++serial);
+ EXPECT_EQ(std::cv_status::no_timeout, wait());
+ EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+ EXPECT_EQ(serial, radioRsp->rspInfo.serial);
- if (cardStatus.cardState == CardState::ABSENT) {
- ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE);
- }
+ if (cardStatus.cardState == CardState::ABSENT) {
+ ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE);
+ }
}
/*
* Test IRadio.getVoiceRegistrationState() for the response returned.
*/
TEST_F(RadioHidlTest, getVoiceRegistrationState) {
- int serial = 1;
+ int serial = 1;
- radio->getVoiceRegistrationState(++serial);
- EXPECT_EQ(std::cv_status::no_timeout, wait());
- EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
- EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+ radio->getVoiceRegistrationState(++serial);
+ EXPECT_EQ(std::cv_status::no_timeout, wait());
+ EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+ EXPECT_EQ(serial, radioRsp->rspInfo.serial);
- if (cardStatus.cardState == CardState::ABSENT) {
- ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE);
- }
+ if (cardStatus.cardState == CardState::ABSENT) {
+ ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE);
+ }
}
/*
* Test IRadio.getOperator() for the response returned.
*/
TEST_F(RadioHidlTest, getOperator) {
- int serial = 1;
+ int serial = 1;
- radio->getOperator(++serial);
- EXPECT_EQ(std::cv_status::no_timeout, wait());
- EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
- EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+ radio->getOperator(++serial);
+ EXPECT_EQ(std::cv_status::no_timeout, wait());
+ EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+ EXPECT_EQ(serial, radioRsp->rspInfo.serial);
- if (cardStatus.cardState == CardState::ABSENT) {
- ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE);
- }
+ if (cardStatus.cardState == CardState::ABSENT) {
+ ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE);
+ }
}
/*
* Test IRadio.setRadioPower() for the response returned.
*/
TEST_F(RadioHidlTest, setRadioPower) {
- int serial = 1;
+ int serial = 1;
- radio->setRadioPower(++serial, 0);
- EXPECT_EQ(std::cv_status::no_timeout, wait());
- EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
- EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+ radio->setRadioPower(++serial, 0);
+ EXPECT_EQ(std::cv_status::no_timeout, wait());
+ EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+ EXPECT_EQ(serial, radioRsp->rspInfo.serial);
- if (cardStatus.cardState == CardState::ABSENT) {
- ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE);
- }
+ if (cardStatus.cardState == CardState::ABSENT) {
+ ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE);
+ }
}
/*
* Test IRadio.getNetworkSelectionMode() for the response returned.
*/
TEST_F(RadioHidlTest, getNetworkSelectionMode) {
- int serial = 1;
+ int serial = 1;
- radio->getNetworkSelectionMode(++serial);
- EXPECT_EQ(std::cv_status::no_timeout, wait());
- EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
- EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+ radio->getNetworkSelectionMode(++serial);
+ EXPECT_EQ(std::cv_status::no_timeout, wait());
+ EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+ EXPECT_EQ(serial, radioRsp->rspInfo.serial);
- if (cardStatus.cardState == CardState::ABSENT) {
- ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE);
- }
+ if (cardStatus.cardState == CardState::ABSENT) {
+ ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE);
+ }
}
/*
* Test IRadio.setNetworkSelectionModeAutomatic() for the response returned.
*/
TEST_F(RadioHidlTest, setNetworkSelectionModeAutomatic) {
- int serial = 1;
+ int serial = 1;
- radio->setNetworkSelectionModeAutomatic(++serial);
- EXPECT_EQ(std::cv_status::no_timeout, wait());
- EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
- EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+ radio->setNetworkSelectionModeAutomatic(++serial);
+ EXPECT_EQ(std::cv_status::no_timeout, wait());
+ EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+ EXPECT_EQ(serial, radioRsp->rspInfo.serial);
- if (cardStatus.cardState == CardState::ABSENT) {
- ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::ILLEGAL_SIM_OR_ME);
- }
+ if (cardStatus.cardState == CardState::ABSENT) {
+ ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::ILLEGAL_SIM_OR_ME);
+ }
}
/*
* Test IRadio.setNetworkSelectionModeManual() for the response returned.
*/
TEST_F(RadioHidlTest, setNetworkSelectionModeManual) {
- int serial = 1;
+ int serial = 1;
- radio->setNetworkSelectionModeManual(++serial, "123456");
- EXPECT_EQ(std::cv_status::no_timeout, wait());
- EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
- EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+ radio->setNetworkSelectionModeManual(++serial, "123456");
+ EXPECT_EQ(std::cv_status::no_timeout, wait());
+ EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+ EXPECT_EQ(serial, radioRsp->rspInfo.serial);
- if (cardStatus.cardState == CardState::ABSENT) {
- ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::ILLEGAL_SIM_OR_ME);
- }
+ if (cardStatus.cardState == CardState::ABSENT) {
+ ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::ILLEGAL_SIM_OR_ME);
+ }
}
/*
* Test IRadio.getAvailableNetworks() for the response returned.
*/
TEST_F(RadioHidlTest, getAvailableNetworks) {
- int serial = 1;
+ int serial = 1;
- radio->getAvailableNetworks(++serial);
- EXPECT_EQ(std::cv_status::no_timeout, wait());
- EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
- EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+ radio->getAvailableNetworks(++serial);
+ EXPECT_EQ(std::cv_status::no_timeout, wait());
+ EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+ EXPECT_EQ(serial, radioRsp->rspInfo.serial);
- if (cardStatus.cardState == CardState::ABSENT) {
- ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE);
- }
+ if (cardStatus.cardState == CardState::ABSENT) {
+ ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE);
+ }
}
/*
* Test IRadio.getBasebandVersion() for the response returned.
*/
TEST_F(RadioHidlTest, getBasebandVersion) {
- int serial = 1;
+ int serial = 1;
- radio->getBasebandVersion(++serial);
- EXPECT_EQ(std::cv_status::no_timeout, wait());
- EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
- EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+ radio->getBasebandVersion(++serial);
+ EXPECT_EQ(std::cv_status::no_timeout, wait());
+ EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+ EXPECT_EQ(serial, radioRsp->rspInfo.serial);
- if (cardStatus.cardState == CardState::ABSENT) {
- ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE);
- }
+ if (cardStatus.cardState == CardState::ABSENT) {
+ ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE);
+ }
}
/*
* Test IRadio.setBandMode() for the response returned.
*/
TEST_F(RadioHidlTest, setBandMode) {
- int serial = 1;
+ int serial = 1;
- radio->setBandMode(++serial, RadioBandMode::BAND_MODE_USA);
- EXPECT_EQ(std::cv_status::no_timeout, wait());
- EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
- EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+ radio->setBandMode(++serial, RadioBandMode::BAND_MODE_USA);
+ EXPECT_EQ(std::cv_status::no_timeout, wait());
+ EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+ EXPECT_EQ(serial, radioRsp->rspInfo.serial);
- if (cardStatus.cardState == CardState::ABSENT) {
- ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE);
- }
+ if (cardStatus.cardState == CardState::ABSENT) {
+ ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE);
+ }
}
/*
* Test IRadio.getAvailableBandModes() for the response returned.
*/
TEST_F(RadioHidlTest, getAvailableBandModes) {
- int serial = 1;
+ int serial = 1;
- radio->getAvailableBandModes(++serial);
- EXPECT_EQ(std::cv_status::no_timeout, wait());
- EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
- EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+ radio->getAvailableBandModes(++serial);
+ EXPECT_EQ(std::cv_status::no_timeout, wait());
+ EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+ EXPECT_EQ(serial, radioRsp->rspInfo.serial);
- if (cardStatus.cardState == CardState::ABSENT) {
- ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE);
- }
+ if (cardStatus.cardState == CardState::ABSENT) {
+ ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE);
+ }
}
/*
* Test IRadio.setPreferredNetworkType() for the response returned.
*/
TEST_F(RadioHidlTest, setPreferredNetworkType) {
- int serial = 1;
+ int serial = 1;
- radio->setPreferredNetworkType(++serial, PreferredNetworkType::GSM_ONLY);
- EXPECT_EQ(std::cv_status::no_timeout, wait());
- EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
- EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+ radio->setPreferredNetworkType(++serial, PreferredNetworkType::GSM_ONLY);
+ EXPECT_EQ(std::cv_status::no_timeout, wait());
+ EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+ EXPECT_EQ(serial, radioRsp->rspInfo.serial);
- if (cardStatus.cardState == CardState::ABSENT) {
- ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE);
- }
+ if (cardStatus.cardState == CardState::ABSENT) {
+ ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE);
+ }
}
/*
* Test IRadio.getPreferredNetworkType() for the response returned.
*/
TEST_F(RadioHidlTest, getPreferredNetworkType) {
- int serial = 1;
+ int serial = 1;
- radio->getPreferredNetworkType(++serial);
- EXPECT_EQ(std::cv_status::no_timeout, wait());
- EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
- EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+ radio->getPreferredNetworkType(++serial);
+ EXPECT_EQ(std::cv_status::no_timeout, wait());
+ EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+ EXPECT_EQ(serial, radioRsp->rspInfo.serial);
- if (cardStatus.cardState == CardState::ABSENT) {
- ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE);
- }
+ if (cardStatus.cardState == CardState::ABSENT) {
+ ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE);
+ }
}
/*
* Test IRadio.getNeighboringCids() for the response returned.
*/
TEST_F(RadioHidlTest, getNeighboringCids) {
- int serial = 1;
+ int serial = 1;
- radio->getNeighboringCids(++serial);
- EXPECT_EQ(std::cv_status::no_timeout, wait());
- EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
- EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+ radio->getNeighboringCids(++serial);
+ EXPECT_EQ(std::cv_status::no_timeout, wait());
+ EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+ EXPECT_EQ(serial, radioRsp->rspInfo.serial);
- if (cardStatus.cardState == CardState::ABSENT) {
- ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE);
- }
+ if (cardStatus.cardState == CardState::ABSENT) {
+ ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE);
+ }
}
/*
* Test IRadio.setLocationUpdates() for the response returned.
*/
TEST_F(RadioHidlTest, setLocationUpdates) {
- int serial = 1;
+ int serial = 1;
- radio->setLocationUpdates(++serial, true);
- EXPECT_EQ(std::cv_status::no_timeout, wait());
- EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
- EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+ radio->setLocationUpdates(++serial, true);
+ EXPECT_EQ(std::cv_status::no_timeout, wait());
+ EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+ EXPECT_EQ(serial, radioRsp->rspInfo.serial);
- if (cardStatus.cardState == CardState::ABSENT) {
- ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE);
- }
+ if (cardStatus.cardState == CardState::ABSENT) {
+ ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE);
+ }
}
/*
* Test IRadio.setCdmaRoamingPreference() for the response returned.
*/
TEST_F(RadioHidlTest, setCdmaRoamingPreference) {
- int serial = 1;
+ int serial = 1;
- radio->setCdmaRoamingPreference(++serial, CdmaRoamingType::HOME_NETWORK);
- EXPECT_EQ(std::cv_status::no_timeout, wait());
- EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
- EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+ radio->setCdmaRoamingPreference(++serial, CdmaRoamingType::HOME_NETWORK);
+ EXPECT_EQ(std::cv_status::no_timeout, wait());
+ EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+ EXPECT_EQ(serial, radioRsp->rspInfo.serial);
- if (cardStatus.cardState == CardState::ABSENT) {
- ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE);
- }
+ if (cardStatus.cardState == CardState::ABSENT) {
+ ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE);
+ }
}
/*
* Test IRadio.getCdmaRoamingPreference() for the response returned.
*/
TEST_F(RadioHidlTest, getCdmaRoamingPreference) {
- int serial = 1;
+ int serial = 1;
- radio->getCdmaRoamingPreference(++serial);
- EXPECT_EQ(std::cv_status::no_timeout, wait());
- EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
- EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+ radio->getCdmaRoamingPreference(++serial);
+ EXPECT_EQ(std::cv_status::no_timeout, wait());
+ EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+ EXPECT_EQ(serial, radioRsp->rspInfo.serial);
- if (cardStatus.cardState == CardState::ABSENT) {
- ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE);
- }
+ if (cardStatus.cardState == CardState::ABSENT) {
+ ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE);
+ }
}
/*
* Test IRadio.getTTYMode() for the response returned.
*/
TEST_F(RadioHidlTest, getTTYMode) {
- int serial = 1;
+ int serial = 1;
- radio->getTTYMode(++serial);
- EXPECT_EQ(std::cv_status::no_timeout, wait());
- EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
- EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+ radio->getTTYMode(++serial);
+ EXPECT_EQ(std::cv_status::no_timeout, wait());
+ EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+ EXPECT_EQ(serial, radioRsp->rspInfo.serial);
- if (cardStatus.cardState == CardState::ABSENT) {
- ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE);
- }
+ if (cardStatus.cardState == CardState::ABSENT) {
+ ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE);
+ }
}
/*
* Test IRadio.setTTYMode() for the response returned.
*/
TEST_F(RadioHidlTest, setTTYMode) {
- int serial = 1;
+ int serial = 1;
- radio->setTTYMode(++serial, TtyMode::OFF);
- EXPECT_EQ(std::cv_status::no_timeout, wait());
- EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
- EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+ radio->setTTYMode(++serial, TtyMode::OFF);
+ EXPECT_EQ(std::cv_status::no_timeout, wait());
+ EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+ EXPECT_EQ(serial, radioRsp->rspInfo.serial);
- if (cardStatus.cardState == CardState::ABSENT) {
- ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE);
- }
+ if (cardStatus.cardState == CardState::ABSENT) {
+ ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE);
+ }
}
/*
* Test IRadio.setPreferredVoicePrivacy() for the response returned.
*/
TEST_F(RadioHidlTest, setPreferredVoicePrivacy) {
- int serial = 1;
+ int serial = 1;
- radio->setPreferredVoicePrivacy(++serial, true);
- EXPECT_EQ(std::cv_status::no_timeout, wait());
- EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
- EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+ radio->setPreferredVoicePrivacy(++serial, true);
+ EXPECT_EQ(std::cv_status::no_timeout, wait());
+ EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+ EXPECT_EQ(serial, radioRsp->rspInfo.serial);
- if (cardStatus.cardState == CardState::ABSENT) {
- ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE);
- }
+ if (cardStatus.cardState == CardState::ABSENT) {
+ ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE);
+ }
}
/*
* Test IRadio.getPreferredVoicePrivacy() for the response returned.
*/
TEST_F(RadioHidlTest, getPreferredVoicePrivacy) {
- int serial = 1;
+ int serial = 1;
- radio->getPreferredVoicePrivacy(++serial);
- EXPECT_EQ(std::cv_status::no_timeout, wait());
- EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
- EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+ radio->getPreferredVoicePrivacy(++serial);
+ EXPECT_EQ(std::cv_status::no_timeout, wait());
+ EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+ EXPECT_EQ(serial, radioRsp->rspInfo.serial);
- if (cardStatus.cardState == CardState::ABSENT) {
- ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE);
- }
+ if (cardStatus.cardState == CardState::ABSENT) {
+ ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE);
+ }
}
/*
* Test IRadio.getCDMASubscription() for the response returned.
*/
TEST_F(RadioHidlTest, getCDMASubscription) {
- int serial = 1;
+ int serial = 1;
- radio->getCDMASubscription(++serial);
- EXPECT_EQ(std::cv_status::no_timeout, wait());
- EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
- EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+ radio->getCDMASubscription(++serial);
+ EXPECT_EQ(std::cv_status::no_timeout, wait());
+ EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+ EXPECT_EQ(serial, radioRsp->rspInfo.serial);
- if (cardStatus.cardState == CardState::ABSENT) {
- ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE);
- }
+ if (cardStatus.cardState == CardState::ABSENT) {
+ ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE);
+ }
}
/*
* Test IRadio.getDeviceIdentity() for the response returned.
*/
TEST_F(RadioHidlTest, getDeviceIdentity) {
- int serial = 1;
+ int serial = 1;
- radio->getDeviceIdentity(++serial);
- EXPECT_EQ(std::cv_status::no_timeout, wait());
- EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
- EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+ radio->getDeviceIdentity(++serial);
+ EXPECT_EQ(std::cv_status::no_timeout, wait());
+ EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+ EXPECT_EQ(serial, radioRsp->rspInfo.serial);
- if (cardStatus.cardState == CardState::ABSENT) {
- ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE);
- }
+ if (cardStatus.cardState == CardState::ABSENT) {
+ ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE);
+ }
}
/*
* Test IRadio.exitEmergencyCallbackMode() for the response returned.
*/
TEST_F(RadioHidlTest, exitEmergencyCallbackMode) {
- int serial = 1;
+ int serial = 1;
- radio->exitEmergencyCallbackMode(++serial);
- EXPECT_EQ(std::cv_status::no_timeout, wait());
- EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
- EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+ radio->exitEmergencyCallbackMode(++serial);
+ EXPECT_EQ(std::cv_status::no_timeout, wait());
+ EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+ EXPECT_EQ(serial, radioRsp->rspInfo.serial);
- if (cardStatus.cardState == CardState::ABSENT) {
- ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE);
- }
+ if (cardStatus.cardState == CardState::ABSENT) {
+ ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE);
+ }
}
/*
* Test IRadio.getCdmaSubscriptionSource() for the response returned.
*/
TEST_F(RadioHidlTest, getCdmaSubscriptionSource) {
- int serial = 1;
+ int serial = 1;
- radio->getCdmaSubscriptionSource(++serial);
- EXPECT_EQ(std::cv_status::no_timeout, wait());
- EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
- EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+ radio->getCdmaSubscriptionSource(++serial);
+ EXPECT_EQ(std::cv_status::no_timeout, wait());
+ EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+ EXPECT_EQ(serial, radioRsp->rspInfo.serial);
- if (cardStatus.cardState == CardState::ABSENT) {
- ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE);
- }
+ if (cardStatus.cardState == CardState::ABSENT) {
+ ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE);
+ }
}
/*
* Test IRadio.setCdmaSubscriptionSource() for the response returned.
*/
TEST_F(RadioHidlTest, setCdmaSubscriptionSource) {
- int serial = 1;
+ int serial = 1;
- radio->setCdmaSubscriptionSource(++serial, CdmaSubscriptionSource::RUIM_SIM);
- EXPECT_EQ(std::cv_status::no_timeout, wait());
- EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
- EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+ radio->setCdmaSubscriptionSource(++serial, CdmaSubscriptionSource::RUIM_SIM);
+ EXPECT_EQ(std::cv_status::no_timeout, wait());
+ EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+ EXPECT_EQ(serial, radioRsp->rspInfo.serial);
- if (cardStatus.cardState == CardState::ABSENT) {
- ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::SIM_ABSENT
- || radioRsp->rspInfo.error == RadioError::SUBSCRIPTION_NOT_AVAILABLE);
- }
+ if (cardStatus.cardState == CardState::ABSENT) {
+ ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::SIM_ABSENT ||
+ radioRsp->rspInfo.error ==
+ RadioError::SUBSCRIPTION_NOT_AVAILABLE);
+ }
}
/*
* Test IRadio.getVoiceRadioTechnology() for the response returned.
*/
TEST_F(RadioHidlTest, getVoiceRadioTechnology) {
- int serial = 1;
+ int serial = 1;
- radio->getVoiceRadioTechnology(++serial);
- EXPECT_EQ(std::cv_status::no_timeout, wait());
- EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
- EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+ radio->getVoiceRadioTechnology(++serial);
+ EXPECT_EQ(std::cv_status::no_timeout, wait());
+ EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+ EXPECT_EQ(serial, radioRsp->rspInfo.serial);
- if (cardStatus.cardState == CardState::ABSENT) {
- ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE);
- }
+ if (cardStatus.cardState == CardState::ABSENT) {
+ ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE);
+ }
}
/*
* Test IRadio.getCellInfoList() for the response returned.
*/
TEST_F(RadioHidlTest, getCellInfoList) {
- int serial = 1;
+ int serial = 1;
- radio->getCellInfoList(++serial);
- EXPECT_EQ(std::cv_status::no_timeout, wait());
- EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
- EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+ radio->getCellInfoList(++serial);
+ EXPECT_EQ(std::cv_status::no_timeout, wait());
+ EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+ EXPECT_EQ(serial, radioRsp->rspInfo.serial);
- if (cardStatus.cardState == CardState::ABSENT) {
- ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE);
- }
+ if (cardStatus.cardState == CardState::ABSENT) {
+ ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE);
+ }
}
/*
* Test IRadio.setCellInfoListRate() for the response returned.
*/
TEST_F(RadioHidlTest, setCellInfoListRate) {
- int serial = 1;
+ int serial = 1;
- // TODO(sanketpadawe): RIL crashes with value of rate = 10
- radio->setCellInfoListRate(++serial, 10);
- EXPECT_EQ(std::cv_status::no_timeout, wait());
- EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
- EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+ // TODO(sanketpadawe): RIL crashes with value of rate = 10
+ radio->setCellInfoListRate(++serial, 10);
+ EXPECT_EQ(std::cv_status::no_timeout, wait());
+ EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+ EXPECT_EQ(serial, radioRsp->rspInfo.serial);
- if (cardStatus.cardState == CardState::ABSENT) {
- ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE);
- }
+ if (cardStatus.cardState == CardState::ABSENT) {
+ ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE);
+ }
}
/*
* Test IRadio.nvReadItem() for the response returned.
*/
TEST_F(RadioHidlTest, nvReadItem) {
- int serial = 1;
+ int serial = 1;
- radio->nvReadItem(++serial, NvItem::LTE_BAND_ENABLE_25);
- EXPECT_EQ(std::cv_status::no_timeout, wait());
- EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
- EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+ radio->nvReadItem(++serial, NvItem::LTE_BAND_ENABLE_25);
+ EXPECT_EQ(std::cv_status::no_timeout, wait());
+ EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+ EXPECT_EQ(serial, radioRsp->rspInfo.serial);
- if (cardStatus.cardState == CardState::ABSENT) {
- ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE);
- }
+ if (cardStatus.cardState == CardState::ABSENT) {
+ ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE);
+ }
}
/*
* Test IRadio.nvWriteItem() for the response returned.
*/
TEST_F(RadioHidlTest, nvWriteItem) {
- int serial = 1;
- NvWriteItem item;
- memset(&item, 0, sizeof(item));
- item.value = hidl_string();
+ int serial = 1;
+ NvWriteItem item;
+ memset(&item, 0, sizeof(item));
+ item.value = hidl_string();
- radio->nvWriteItem(++serial, item);
- EXPECT_EQ(std::cv_status::no_timeout, wait());
- EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
- EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+ radio->nvWriteItem(++serial, item);
+ EXPECT_EQ(std::cv_status::no_timeout, wait());
+ EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+ EXPECT_EQ(serial, radioRsp->rspInfo.serial);
- if (cardStatus.cardState == CardState::ABSENT) {
- ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE);
- }
+ if (cardStatus.cardState == CardState::ABSENT) {
+ ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE);
+ }
}
/*
* Test IRadio.nvWriteCdmaPrl() for the response returned.
*/
TEST_F(RadioHidlTest, nvWriteCdmaPrl) {
- int serial = 1;
- std::vector<uint8_t> prl = {1, 2, 3, 4, 5};
+ int serial = 1;
+ std::vector<uint8_t> prl = {1, 2, 3, 4, 5};
- radio->nvWriteCdmaPrl(++serial, hidl_vec<uint8_t>(prl));
- EXPECT_EQ(std::cv_status::no_timeout, wait());
- EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
- EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+ radio->nvWriteCdmaPrl(++serial, hidl_vec<uint8_t>(prl));
+ EXPECT_EQ(std::cv_status::no_timeout, wait());
+ EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+ EXPECT_EQ(serial, radioRsp->rspInfo.serial);
- if (cardStatus.cardState == CardState::ABSENT) {
- ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE);
- }
+ if (cardStatus.cardState == CardState::ABSENT) {
+ ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE);
+ }
}
/*
* Test IRadio.nvResetConfig() for the response returned.
*/
TEST_F(RadioHidlTest, nvResetConfig) {
- int serial = 1;
+ int serial = 1;
- radio->nvResetConfig(++serial, ResetNvType::RELOAD);
- EXPECT_EQ(std::cv_status::no_timeout, wait());
- EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
- EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+ radio->nvResetConfig(++serial, ResetNvType::RELOAD);
+ EXPECT_EQ(std::cv_status::no_timeout, wait());
+ EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+ EXPECT_EQ(serial, radioRsp->rspInfo.serial);
- if (cardStatus.cardState == CardState::ABSENT) {
- ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE);
- }
+ if (cardStatus.cardState == CardState::ABSENT) {
+ ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE);
+ }
}
/*
* Test IRadio.setUiccSubscription() for the response returned.
*/
TEST_F(RadioHidlTest, setUiccSubscription) {
- int serial = 1;
- SelectUiccSub item;
- memset(&item, 0, sizeof(item));
+ int serial = 1;
+ SelectUiccSub item;
+ memset(&item, 0, sizeof(item));
- radio->setUiccSubscription(++serial, item);
- EXPECT_EQ(std::cv_status::no_timeout, wait());
- EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
- EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+ radio->setUiccSubscription(++serial, item);
+ EXPECT_EQ(std::cv_status::no_timeout, wait());
+ EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+ EXPECT_EQ(serial, radioRsp->rspInfo.serial);
- if (cardStatus.cardState == CardState::ABSENT) {
- ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE);
- }
+ if (cardStatus.cardState == CardState::ABSENT) {
+ ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE);
+ }
}
/*
* Test IRadio.getHardwareConfig() for the response returned.
*/
TEST_F(RadioHidlTest, getHardwareConfig) {
- int serial = 1;
+ int serial = 1;
- radio->getHardwareConfig(++serial);
- EXPECT_EQ(std::cv_status::no_timeout, wait());
- EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
- EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+ radio->getHardwareConfig(++serial);
+ EXPECT_EQ(std::cv_status::no_timeout, wait());
+ EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+ EXPECT_EQ(serial, radioRsp->rspInfo.serial);
- if (cardStatus.cardState == CardState::ABSENT) {
- ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE);
- }
+ if (cardStatus.cardState == CardState::ABSENT) {
+ ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE);
+ }
}
/*
* Test IRadio.requestShutdown() for the response returned.
*/
TEST_F(RadioHidlTest, requestShutdown) {
- int serial = 1;
+ int serial = 1;
- radio->requestShutdown(++serial);
- EXPECT_EQ(std::cv_status::no_timeout, wait());
- EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
- EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+ radio->requestShutdown(++serial);
+ EXPECT_EQ(std::cv_status::no_timeout, wait());
+ EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+ EXPECT_EQ(serial, radioRsp->rspInfo.serial);
- if (cardStatus.cardState == CardState::ABSENT) {
- ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE);
- }
+ if (cardStatus.cardState == CardState::ABSENT) {
+ ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE);
+ }
}
/*
* Test IRadio.getRadioCapability() for the response returned.
*/
TEST_F(RadioHidlTest, getRadioCapability) {
- int serial = 1;
+ int serial = 1;
- radio->getRadioCapability(++serial);
- EXPECT_EQ(std::cv_status::no_timeout, wait());
- EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
- EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+ radio->getRadioCapability(++serial);
+ EXPECT_EQ(std::cv_status::no_timeout, wait());
+ EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+ EXPECT_EQ(serial, radioRsp->rspInfo.serial);
- if (cardStatus.cardState == CardState::ABSENT) {
- ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE);
- }
+ if (cardStatus.cardState == CardState::ABSENT) {
+ ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE);
+ }
}
/*
* Test IRadio.setRadioCapability() for the response returned.
*/
TEST_F(RadioHidlTest, setRadioCapability) {
- int serial = 1;
- RadioCapability rc;
- memset(&rc, 0, sizeof(rc));
- rc.logicalModemUuid = hidl_string();
+ int serial = 1;
+ RadioCapability rc;
+ memset(&rc, 0, sizeof(rc));
+ rc.logicalModemUuid = hidl_string();
- radio->setRadioCapability(++serial, rc);
- EXPECT_EQ(std::cv_status::no_timeout, wait());
- EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
- EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+ radio->setRadioCapability(++serial, rc);
+ EXPECT_EQ(std::cv_status::no_timeout, wait());
+ EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+ EXPECT_EQ(serial, radioRsp->rspInfo.serial);
- if (cardStatus.cardState == CardState::ABSENT) {
- ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE);
- }
+ if (cardStatus.cardState == CardState::ABSENT) {
+ ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE);
+ }
}
/*
* Test IRadio.startLceService() for the response returned.
*/
TEST_F(RadioHidlTest, startLceService) {
- int serial = 1;
+ int serial = 1;
- radio->startLceService(++serial, 5, true);
- EXPECT_EQ(std::cv_status::no_timeout, wait());
- EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
- EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+ radio->startLceService(++serial, 5, true);
+ EXPECT_EQ(std::cv_status::no_timeout, wait());
+ EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+ EXPECT_EQ(serial, radioRsp->rspInfo.serial);
- if (cardStatus.cardState == CardState::ABSENT) {
- ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE
- || radioRsp->rspInfo.error == RadioError::LCE_NOT_SUPPORTED);
- }
+ if (cardStatus.cardState == CardState::ABSENT) {
+ ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE ||
+ radioRsp->rspInfo.error == RadioError::LCE_NOT_SUPPORTED);
+ }
}
/*
* Test IRadio.stopLceService() for the response returned.
*/
TEST_F(RadioHidlTest, stopLceService) {
- int serial = 1;
+ int serial = 1;
- radio->stopLceService(++serial);
- EXPECT_EQ(std::cv_status::no_timeout, wait());
- EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
- EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+ radio->stopLceService(++serial);
+ EXPECT_EQ(std::cv_status::no_timeout, wait());
+ EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+ EXPECT_EQ(serial, radioRsp->rspInfo.serial);
- if (cardStatus.cardState == CardState::ABSENT) {
- ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE
- || radioRsp->rspInfo.error == RadioError::LCE_NOT_SUPPORTED);
- }
+ if (cardStatus.cardState == CardState::ABSENT) {
+ ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE ||
+ radioRsp->rspInfo.error == RadioError::LCE_NOT_SUPPORTED);
+ }
}
/*
* Test IRadio.pullLceData() for the response returned.
*/
TEST_F(RadioHidlTest, pullLceData) {
- int serial = 1;
+ int serial = 1;
- radio->pullLceData(++serial);
- EXPECT_EQ(std::cv_status::no_timeout, wait());
- EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
- EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+ radio->pullLceData(++serial);
+ EXPECT_EQ(std::cv_status::no_timeout, wait());
+ EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+ EXPECT_EQ(serial, radioRsp->rspInfo.serial);
- if (cardStatus.cardState == CardState::ABSENT) {
- ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE
- || radioRsp->rspInfo.error == RadioError::LCE_NOT_SUPPORTED);
- }
+ if (cardStatus.cardState == CardState::ABSENT) {
+ ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE ||
+ radioRsp->rspInfo.error == RadioError::LCE_NOT_SUPPORTED);
+ }
}
/*
* Test IRadio.getModemActivityInfo() for the response returned.
*/
TEST_F(RadioHidlTest, getModemActivityInfo) {
- int serial = 1;
+ int serial = 1;
- radio->getModemActivityInfo(++serial);
- EXPECT_EQ(std::cv_status::no_timeout, wait());
- EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
- EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+ radio->getModemActivityInfo(++serial);
+ EXPECT_EQ(std::cv_status::no_timeout, wait());
+ EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+ EXPECT_EQ(serial, radioRsp->rspInfo.serial);
- if (cardStatus.cardState == CardState::ABSENT) {
- ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE);
- }
+ if (cardStatus.cardState == CardState::ABSENT) {
+ ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE);
+ }
}
/*
* Test IRadio.setAllowedCarriers() for the response returned.
*/
TEST_F(RadioHidlTest, setAllowedCarriers) {
- int serial = 1;
- CarrierRestrictions carriers;
- memset(&carriers, 0, sizeof(carriers));
- carriers.allowedCarriers.resize(1);
- carriers.excludedCarriers.resize(0);
- carriers.allowedCarriers[0].mcc = hidl_string();
- carriers.allowedCarriers[0].mnc = hidl_string();
- carriers.allowedCarriers[0].matchType = CarrierMatchType::ALL;
- carriers.allowedCarriers[0].matchData = hidl_string();
+ int serial = 1;
+ CarrierRestrictions carriers;
+ memset(&carriers, 0, sizeof(carriers));
+ carriers.allowedCarriers.resize(1);
+ carriers.excludedCarriers.resize(0);
+ carriers.allowedCarriers[0].mcc = hidl_string();
+ carriers.allowedCarriers[0].mnc = hidl_string();
+ carriers.allowedCarriers[0].matchType = CarrierMatchType::ALL;
+ carriers.allowedCarriers[0].matchData = hidl_string();
- radio->setAllowedCarriers(++serial, false, carriers);
- EXPECT_EQ(std::cv_status::no_timeout, wait());
- EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
- EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+ radio->setAllowedCarriers(++serial, false, carriers);
+ EXPECT_EQ(std::cv_status::no_timeout, wait());
+ EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+ EXPECT_EQ(serial, radioRsp->rspInfo.serial);
- if (cardStatus.cardState == CardState::ABSENT) {
- ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE);
- }
+ if (cardStatus.cardState == CardState::ABSENT) {
+ ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE);
+ }
}
/*
* Test IRadio.getAllowedCarriers() for the response returned.
*/
TEST_F(RadioHidlTest, getAllowedCarriers) {
- int serial = 1;
+ int serial = 1;
- radio->getAllowedCarriers(++serial);
- EXPECT_EQ(std::cv_status::no_timeout, wait());
- EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
- EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+ radio->getAllowedCarriers(++serial);
+ EXPECT_EQ(std::cv_status::no_timeout, wait());
+ EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+ EXPECT_EQ(serial, radioRsp->rspInfo.serial);
- if (cardStatus.cardState == CardState::ABSENT) {
- ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE);
- }
+ if (cardStatus.cardState == CardState::ABSENT) {
+ ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE);
+ }
}
/*
* Test IRadio.sendDeviceState() for the response returned.
*/
TEST_F(RadioHidlTest, sendDeviceState) {
- int serial = 1;
+ int serial = 1;
- radio->sendDeviceState(++serial, DeviceStateType::POWER_SAVE_MODE, true);
- EXPECT_EQ(std::cv_status::no_timeout, wait());
- EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
- EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+ radio->sendDeviceState(++serial, DeviceStateType::POWER_SAVE_MODE, true);
+ EXPECT_EQ(std::cv_status::no_timeout, wait());
+ EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+ EXPECT_EQ(serial, radioRsp->rspInfo.serial);
- if (cardStatus.cardState == CardState::ABSENT) {
- ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE);
- }
+ if (cardStatus.cardState == CardState::ABSENT) {
+ ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE);
+ }
}
/*
* Test IRadio.setIndicationFilter() for the response returned.
*/
TEST_F(RadioHidlTest, setIndicationFilter) {
- int serial = 1;
+ int serial = 1;
- radio->setIndicationFilter(++serial, 1);
- EXPECT_EQ(std::cv_status::no_timeout, wait());
- EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
- EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+ radio->setIndicationFilter(++serial, 1);
+ EXPECT_EQ(std::cv_status::no_timeout, wait());
+ EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+ EXPECT_EQ(serial, radioRsp->rspInfo.serial);
- if (cardStatus.cardState == CardState::ABSENT) {
- ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE);
- }
+ if (cardStatus.cardState == CardState::ABSENT) {
+ ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE);
+ }
}
/*
* Test IRadio.setSimCardPower() for the response returned.
*/
TEST_F(RadioHidlTest, setSimCardPower) {
- int serial = 1;
+ int serial = 1;
- radio->setSimCardPower(++serial, true);
- EXPECT_EQ(std::cv_status::no_timeout, wait());
- EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
- EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+ radio->setSimCardPower(++serial, true);
+ EXPECT_EQ(std::cv_status::no_timeout, wait());
+ EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+ EXPECT_EQ(serial, radioRsp->rspInfo.serial);
- if (cardStatus.cardState == CardState::ABSENT) {
- ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::SIM_ABSENT);
- }
+ if (cardStatus.cardState == CardState::ABSENT) {
+ ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::SIM_ABSENT);
+ }
}
\ No newline at end of file
diff --git a/radio/1.0/vts/functional/radio_hidl_hal_sms.cpp b/radio/1.0/vts/functional/radio_hidl_hal_sms.cpp
index 54ae7c0..7caf471 100644
--- a/radio/1.0/vts/functional/radio_hidl_hal_sms.cpp
+++ b/radio/1.0/vts/functional/radio_hidl_hal_sms.cpp
@@ -14,7 +14,7 @@
* limitations under the License.
*/
-#include<radio_hidl_hal_utils.h>
+#include <radio_hidl_hal_utils.h>
using namespace ::android::hardware::radio::V1_0;
@@ -22,403 +22,408 @@
* Test IRadio.sendSms() for the response returned.
*/
TEST_F(RadioHidlTest, sendSms) {
- int serial = 0;
- GsmSmsMessage msg;
- msg.smscPdu = "";
- msg.pdu = "01000b916105770203f3000006d4f29c3e9b01";
+ int serial = 0;
+ GsmSmsMessage msg;
+ msg.smscPdu = "";
+ msg.pdu = "01000b916105770203f3000006d4f29c3e9b01";
- radio->sendSms(++serial, msg);
+ radio->sendSms(++serial, msg);
- EXPECT_EQ(std::cv_status::no_timeout, wait());
- EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
- EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+ EXPECT_EQ(std::cv_status::no_timeout, wait());
+ EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+ EXPECT_EQ(serial, radioRsp->rspInfo.serial);
- if (cardStatus.cardState == CardState::ABSENT) {
- ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS
- || radioRsp->rspInfo.error == RadioError::MODEM_ERR
- || radioRsp->rspInfo.error == RadioError::SYSTEM_ERR
- || radioRsp->rspInfo.error == RadioError::INVALID_STATE);
- EXPECT_EQ(0, radioRsp->sendSmsResult.errorCode);
- }
+ if (cardStatus.cardState == CardState::ABSENT) {
+ ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS ||
+ radioRsp->rspInfo.error == RadioError::MODEM_ERR ||
+ radioRsp->rspInfo.error == RadioError::SYSTEM_ERR ||
+ radioRsp->rspInfo.error == RadioError::INVALID_STATE);
+ EXPECT_EQ(0, radioRsp->sendSmsResult.errorCode);
+ }
}
/*
* Test IRadio.sendSMSExpectMore() for the response returned.
*/
TEST_F(RadioHidlTest, sendSMSExpectMore) {
- int serial = 0;
- GsmSmsMessage msg;
- msg.smscPdu = "";
- msg.pdu = "01000b916105770203f3000006d4f29c3e9b01";
+ int serial = 0;
+ GsmSmsMessage msg;
+ msg.smscPdu = "";
+ msg.pdu = "01000b916105770203f3000006d4f29c3e9b01";
- radio->sendSMSExpectMore(++serial, msg);
+ radio->sendSMSExpectMore(++serial, msg);
- // TODO(shuoq): add more test for this API when inserted sim card is considered
+ // TODO(shuoq): add more test for this API when inserted sim card is
+ // considered
- EXPECT_EQ(std::cv_status::no_timeout, wait());
- EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
- EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+ EXPECT_EQ(std::cv_status::no_timeout, wait());
+ EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+ EXPECT_EQ(serial, radioRsp->rspInfo.serial);
- if (cardStatus.cardState == CardState::ABSENT) {
- ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS
- || radioRsp->rspInfo.error == RadioError::MODEM_ERR
- || radioRsp->rspInfo.error == RadioError::SYSTEM_ERR
- || radioRsp->rspInfo.error == RadioError::INVALID_STATE);
- }
+ if (cardStatus.cardState == CardState::ABSENT) {
+ ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS ||
+ radioRsp->rspInfo.error == RadioError::MODEM_ERR ||
+ radioRsp->rspInfo.error == RadioError::SYSTEM_ERR ||
+ radioRsp->rspInfo.error == RadioError::INVALID_STATE);
+ }
}
/*
* Test IRadio.acknowledgeLastIncomingGsmSms() for the response returned.
*/
TEST_F(RadioHidlTest, acknowledgeLastIncomingGsmSms) {
- int serial = 0;
- bool success = true;
+ int serial = 0;
+ bool success = true;
- radio->acknowledgeLastIncomingGsmSms(++serial, success,
- SmsAcknowledgeFailCause::MEMORY_CAPACITY_EXCEEDED);
+ radio->acknowledgeLastIncomingGsmSms(
+ ++serial, success, SmsAcknowledgeFailCause::MEMORY_CAPACITY_EXCEEDED);
- EXPECT_EQ(std::cv_status::no_timeout, wait());
- EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
- EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+ EXPECT_EQ(std::cv_status::no_timeout, wait());
+ EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+ EXPECT_EQ(serial, radioRsp->rspInfo.serial);
- if (cardStatus.cardState == CardState::ABSENT) {
- EXPECT_EQ(RadioError::INVALID_ARGUMENTS, radioRsp->rspInfo.error);
- }
+ if (cardStatus.cardState == CardState::ABSENT) {
+ EXPECT_EQ(RadioError::INVALID_ARGUMENTS, radioRsp->rspInfo.error);
+ }
}
/*
* Test IRadio.acknowledgeIncomingGsmSmsWithPdu() for the response returned.
*/
TEST_F(RadioHidlTest, acknowledgeIncomingGsmSmsWithPdu) {
- int serial = 0;
- bool success = true;
- std::string ackPdu = "";
+ int serial = 0;
+ bool success = true;
+ std::string ackPdu = "";
- radio->acknowledgeIncomingGsmSmsWithPdu(++serial, success, ackPdu);
+ radio->acknowledgeIncomingGsmSmsWithPdu(++serial, success, ackPdu);
- EXPECT_EQ(std::cv_status::no_timeout, wait());
- EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
- EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+ EXPECT_EQ(std::cv_status::no_timeout, wait());
+ EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+ EXPECT_EQ(serial, radioRsp->rspInfo.serial);
- if (cardStatus.cardState == CardState::ABSENT) {
- // TODO(shuoq): Will add error check when we know the expected error from QC
- }
+ if (cardStatus.cardState == CardState::ABSENT) {
+ // TODO(shuoq): Will add error check when we know the expected error from QC
+ }
}
/*
* Test IRadio.sendCdmaSms() for the response returned.
*/
TEST_F(RadioHidlTest, sendCdmaSms) {
- int serial = 0;
+ int serial = 0;
- // Create a CdmaSmsAddress
- CdmaSmsAddress cdmaSmsAddress;
- cdmaSmsAddress.digitMode = CdmaSmsDigitMode::FOUR_BIT;
- cdmaSmsAddress.numberMode = CdmaSmsNumberMode::NOT_DATA_NETWORK;
- cdmaSmsAddress.numberType = CdmaSmsNumberType::UNKNOWN;
- cdmaSmsAddress.numberPlan = CdmaSmsNumberPlan::UNKNOWN;
- cdmaSmsAddress.digits = (std::vector<uint8_t>) {11, 1, 6, 5, 10, 7, 7, 2, 10, 3, 10, 3};
+ // Create a CdmaSmsAddress
+ CdmaSmsAddress cdmaSmsAddress;
+ cdmaSmsAddress.digitMode = CdmaSmsDigitMode::FOUR_BIT;
+ cdmaSmsAddress.numberMode = CdmaSmsNumberMode::NOT_DATA_NETWORK;
+ cdmaSmsAddress.numberType = CdmaSmsNumberType::UNKNOWN;
+ cdmaSmsAddress.numberPlan = CdmaSmsNumberPlan::UNKNOWN;
+ cdmaSmsAddress.digits =
+ (std::vector<uint8_t>){11, 1, 6, 5, 10, 7, 7, 2, 10, 3, 10, 3};
- // Create a CdmaSmsSubAddress
- CdmaSmsSubaddress cdmaSmsSubaddress;
- cdmaSmsSubaddress.subaddressType = CdmaSmsSubaddressType::NSAP;
- cdmaSmsSubaddress.odd = false;
- cdmaSmsSubaddress.digits = (std::vector<uint8_t>) {};
+ // Create a CdmaSmsSubAddress
+ CdmaSmsSubaddress cdmaSmsSubaddress;
+ cdmaSmsSubaddress.subaddressType = CdmaSmsSubaddressType::NSAP;
+ cdmaSmsSubaddress.odd = false;
+ cdmaSmsSubaddress.digits = (std::vector<uint8_t>){};
- // Create a CdmaSmsMessage
- android::hardware::radio::V1_0::CdmaSmsMessage cdmaSmsMessage;
- cdmaSmsMessage.teleserviceId = 4098;
- cdmaSmsMessage.isServicePresent = false;
- cdmaSmsMessage.serviceCategory = 0;
- cdmaSmsMessage.address = cdmaSmsAddress;
- cdmaSmsMessage.subAddress = cdmaSmsSubaddress;
- cdmaSmsMessage.bearerData = (std::vector<uint8_t>)
- {15, 0, 3, 32, 3, 16, 1, 8, 16, 53, 76, 68, 6, 51, 106, 0};
+ // Create a CdmaSmsMessage
+ android::hardware::radio::V1_0::CdmaSmsMessage cdmaSmsMessage;
+ cdmaSmsMessage.teleserviceId = 4098;
+ cdmaSmsMessage.isServicePresent = false;
+ cdmaSmsMessage.serviceCategory = 0;
+ cdmaSmsMessage.address = cdmaSmsAddress;
+ cdmaSmsMessage.subAddress = cdmaSmsSubaddress;
+ cdmaSmsMessage.bearerData = (std::vector<uint8_t>){
+ 15, 0, 3, 32, 3, 16, 1, 8, 16, 53, 76, 68, 6, 51, 106, 0};
- radio->sendCdmaSms(++serial, cdmaSmsMessage);
+ radio->sendCdmaSms(++serial, cdmaSmsMessage);
- EXPECT_EQ(std::cv_status::no_timeout, wait());
- EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
- EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+ EXPECT_EQ(std::cv_status::no_timeout, wait());
+ EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+ EXPECT_EQ(serial, radioRsp->rspInfo.serial);
- if (cardStatus.cardState == CardState::ABSENT) {
- ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS
- || radioRsp->rspInfo.error == RadioError::MODEM_ERR
- || radioRsp->rspInfo.error == RadioError::SYSTEM_ERR
- || radioRsp->rspInfo.error == RadioError::INVALID_STATE);
- }
+ if (cardStatus.cardState == CardState::ABSENT) {
+ ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS ||
+ radioRsp->rspInfo.error == RadioError::MODEM_ERR ||
+ radioRsp->rspInfo.error == RadioError::SYSTEM_ERR ||
+ radioRsp->rspInfo.error == RadioError::INVALID_STATE);
+ }
}
/*
* Test IRadio.acknowledgeLastIncomingCdmaSms() for the response returned.
*/
TEST_F(RadioHidlTest, acknowledgeLastIncomingCdmaSms) {
- int serial = 0;
+ int serial = 0;
- // Create a CdmaSmsAck
- CdmaSmsAck cdmaSmsAck;
- cdmaSmsAck.errorClass = CdmaSmsErrorClass::NO_ERROR;
- cdmaSmsAck.smsCauseCode = 1;
+ // Create a CdmaSmsAck
+ CdmaSmsAck cdmaSmsAck;
+ cdmaSmsAck.errorClass = CdmaSmsErrorClass::NO_ERROR;
+ cdmaSmsAck.smsCauseCode = 1;
- radio->acknowledgeLastIncomingCdmaSms(++serial, cdmaSmsAck);
+ radio->acknowledgeLastIncomingCdmaSms(++serial, cdmaSmsAck);
- EXPECT_EQ(std::cv_status::no_timeout, wait());
- EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
- EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+ EXPECT_EQ(std::cv_status::no_timeout, wait());
+ EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+ EXPECT_EQ(serial, radioRsp->rspInfo.serial);
- if (cardStatus.cardState == CardState::ABSENT) {
- EXPECT_EQ(RadioError::NO_SMS_TO_ACK, radioRsp->rspInfo.error);
- }
+ if (cardStatus.cardState == CardState::ABSENT) {
+ EXPECT_EQ(RadioError::NO_SMS_TO_ACK, radioRsp->rspInfo.error);
+ }
}
/*
* Test IRadio.sendImsSms() for the response returned.
*/
TEST_F(RadioHidlTest, sendImsSms) {
- int serial = 1;
+ int serial = 1;
- // Create a CdmaSmsAddress
- CdmaSmsAddress cdmaSmsAddress;
- cdmaSmsAddress.digitMode = CdmaSmsDigitMode::FOUR_BIT;
- cdmaSmsAddress.numberMode = CdmaSmsNumberMode::NOT_DATA_NETWORK;
- cdmaSmsAddress.numberType = CdmaSmsNumberType::UNKNOWN;
- cdmaSmsAddress.numberPlan = CdmaSmsNumberPlan::UNKNOWN;
- cdmaSmsAddress.digits = (std::vector<uint8_t>) {11, 1, 6, 5, 10, 7, 7, 2, 10, 3, 10, 3};
+ // Create a CdmaSmsAddress
+ CdmaSmsAddress cdmaSmsAddress;
+ cdmaSmsAddress.digitMode = CdmaSmsDigitMode::FOUR_BIT;
+ cdmaSmsAddress.numberMode = CdmaSmsNumberMode::NOT_DATA_NETWORK;
+ cdmaSmsAddress.numberType = CdmaSmsNumberType::UNKNOWN;
+ cdmaSmsAddress.numberPlan = CdmaSmsNumberPlan::UNKNOWN;
+ cdmaSmsAddress.digits =
+ (std::vector<uint8_t>){11, 1, 6, 5, 10, 7, 7, 2, 10, 3, 10, 3};
- // Create a CdmaSmsSubAddress
- CdmaSmsSubaddress cdmaSmsSubaddress;
- cdmaSmsSubaddress.subaddressType = CdmaSmsSubaddressType::NSAP;
- cdmaSmsSubaddress.odd = false;
- cdmaSmsSubaddress.digits = (std::vector<uint8_t>) {};
+ // Create a CdmaSmsSubAddress
+ CdmaSmsSubaddress cdmaSmsSubaddress;
+ cdmaSmsSubaddress.subaddressType = CdmaSmsSubaddressType::NSAP;
+ cdmaSmsSubaddress.odd = false;
+ cdmaSmsSubaddress.digits = (std::vector<uint8_t>){};
- // Create a CdmaSmsMessage
- CdmaSmsMessage cdmaSmsMessage;
- cdmaSmsMessage.teleserviceId = 4098;
- cdmaSmsMessage.isServicePresent = false;
- cdmaSmsMessage.serviceCategory = 0;
- cdmaSmsMessage.address = cdmaSmsAddress;
- cdmaSmsMessage.subAddress = cdmaSmsSubaddress;
- cdmaSmsMessage.bearerData = (std::vector<uint8_t>)
- {15, 0, 3, 32, 3, 16, 1, 8, 16, 53, 76, 68, 6, 51, 106, 0};
+ // Create a CdmaSmsMessage
+ CdmaSmsMessage cdmaSmsMessage;
+ cdmaSmsMessage.teleserviceId = 4098;
+ cdmaSmsMessage.isServicePresent = false;
+ cdmaSmsMessage.serviceCategory = 0;
+ cdmaSmsMessage.address = cdmaSmsAddress;
+ cdmaSmsMessage.subAddress = cdmaSmsSubaddress;
+ cdmaSmsMessage.bearerData = (std::vector<uint8_t>){
+ 15, 0, 3, 32, 3, 16, 1, 8, 16, 53, 76, 68, 6, 51, 106, 0};
- // Creata an ImsSmsMessage
- ImsSmsMessage msg;
- msg.tech = RadioTechnologyFamily::THREE_GPP2;
- msg.retry = false;
- msg.messageRef = 0;
- msg.cdmaMessage = (std::vector<CdmaSmsMessage>) {cdmaSmsMessage};
- msg.gsmMessage = (std::vector<GsmSmsMessage>) {};
+ // Creata an ImsSmsMessage
+ ImsSmsMessage msg;
+ msg.tech = RadioTechnologyFamily::THREE_GPP2;
+ msg.retry = false;
+ msg.messageRef = 0;
+ msg.cdmaMessage = (std::vector<CdmaSmsMessage>){cdmaSmsMessage};
+ msg.gsmMessage = (std::vector<GsmSmsMessage>){};
- radio->sendImsSms(serial, msg);
+ radio->sendImsSms(serial, msg);
- EXPECT_EQ(std::cv_status::no_timeout, wait());
- EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
- EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+ EXPECT_EQ(std::cv_status::no_timeout, wait());
+ EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+ EXPECT_EQ(serial, radioRsp->rspInfo.serial);
- if (cardStatus.cardState == CardState::ABSENT) {
- EXPECT_EQ(RadioError::INVALID_ARGUMENTS, radioRsp->rspInfo.error);
- }
+ if (cardStatus.cardState == CardState::ABSENT) {
+ EXPECT_EQ(RadioError::INVALID_ARGUMENTS, radioRsp->rspInfo.error);
+ }
}
/*
* Test IRadio.getSmscAddress() for the response returned.
*/
TEST_F(RadioHidlTest, getSmscAddress) {
- int serial = 0;
+ int serial = 0;
- radio->getSmscAddress(++serial);
+ radio->getSmscAddress(++serial);
- EXPECT_EQ(std::cv_status::no_timeout, wait());
- EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
- EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+ EXPECT_EQ(std::cv_status::no_timeout, wait());
+ EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+ EXPECT_EQ(serial, radioRsp->rspInfo.serial);
- if (cardStatus.cardState == CardState::ABSENT) {
- ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS
- || radioRsp->rspInfo.error == RadioError::MODEM_ERR
- || radioRsp->rspInfo.error == RadioError::SYSTEM_ERR
- || radioRsp->rspInfo.error == RadioError::INVALID_STATE
- || radioRsp->rspInfo.error == RadioError::INVALID_MODEM_STATE);
- }
+ if (cardStatus.cardState == CardState::ABSENT) {
+ ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS ||
+ radioRsp->rspInfo.error == RadioError::MODEM_ERR ||
+ radioRsp->rspInfo.error == RadioError::SYSTEM_ERR ||
+ radioRsp->rspInfo.error == RadioError::INVALID_STATE ||
+ radioRsp->rspInfo.error == RadioError::INVALID_MODEM_STATE);
+ }
}
/*
* Test IRadio.setSmscAddress() for the response returned.
*/
TEST_F(RadioHidlTest, setSmscAddress) {
- int serial = 0;
- hidl_string address = hidl_string("smscAddress");
+ int serial = 0;
+ hidl_string address = hidl_string("smscAddress");
- radio->setSmscAddress(++serial, address);
+ radio->setSmscAddress(++serial, address);
- EXPECT_EQ(std::cv_status::no_timeout, wait());
- EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
- EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+ EXPECT_EQ(std::cv_status::no_timeout, wait());
+ EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+ EXPECT_EQ(serial, radioRsp->rspInfo.serial);
- if (cardStatus.cardState == CardState::ABSENT) {
- EXPECT_EQ(RadioError::INVALID_SMS_FORMAT, radioRsp->rspInfo.error);
- }
+ if (cardStatus.cardState == CardState::ABSENT) {
+ EXPECT_EQ(RadioError::INVALID_SMS_FORMAT, radioRsp->rspInfo.error);
+ }
}
/*
* Test IRadio.writeSmsToSim() for the response returned.
*/
TEST_F(RadioHidlTest, writeSmsToSim) {
- int serial = 0;
- SmsWriteArgs smsWriteArgs;
- smsWriteArgs.status = SmsWriteArgsStatus::REC_UNREAD;
- smsWriteArgs.smsc = "";
- smsWriteArgs.pdu = "01000b916105770203f3000006d4f29c3e9b01";
+ int serial = 0;
+ SmsWriteArgs smsWriteArgs;
+ smsWriteArgs.status = SmsWriteArgsStatus::REC_UNREAD;
+ smsWriteArgs.smsc = "";
+ smsWriteArgs.pdu = "01000b916105770203f3000006d4f29c3e9b01";
- radio->writeSmsToSim(++serial, smsWriteArgs);
+ radio->writeSmsToSim(++serial, smsWriteArgs);
- EXPECT_EQ(std::cv_status::no_timeout, wait());
- EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
- EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+ EXPECT_EQ(std::cv_status::no_timeout, wait());
+ EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+ EXPECT_EQ(serial, radioRsp->rspInfo.serial);
- if (cardStatus.cardState == CardState::ABSENT) {
- ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS
- || radioRsp->rspInfo.error == RadioError::MODEM_ERR
- || radioRsp->rspInfo.error == RadioError::INVALID_MODEM_STATE
- || radioRsp->rspInfo.error == RadioError::INTERNAL_ERR);
- }
+ if (cardStatus.cardState == CardState::ABSENT) {
+ ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS ||
+ radioRsp->rspInfo.error == RadioError::MODEM_ERR ||
+ radioRsp->rspInfo.error == RadioError::INVALID_MODEM_STATE ||
+ radioRsp->rspInfo.error == RadioError::INTERNAL_ERR);
+ }
}
/*
* Test IRadio.deleteSmsOnSim() for the response returned.
*/
TEST_F(RadioHidlTest, deleteSmsOnSim) {
- int serial = 0;
- int index = 1;
+ int serial = 0;
+ int index = 1;
- radio->deleteSmsOnSim(++serial, index);
+ radio->deleteSmsOnSim(++serial, index);
- EXPECT_EQ(std::cv_status::no_timeout, wait());
- EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
- EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+ EXPECT_EQ(std::cv_status::no_timeout, wait());
+ EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+ EXPECT_EQ(serial, radioRsp->rspInfo.serial);
- if (cardStatus.cardState == CardState::ABSENT) {
- EXPECT_EQ(RadioError::INVALID_SMS_FORMAT, radioRsp->rspInfo.error);
- ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS
- || radioRsp->rspInfo.error == RadioError::MODEM_ERR
- || radioRsp->rspInfo.error == RadioError::SYSTEM_ERR);
- }
+ if (cardStatus.cardState == CardState::ABSENT) {
+ EXPECT_EQ(RadioError::INVALID_SMS_FORMAT, radioRsp->rspInfo.error);
+ ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS ||
+ radioRsp->rspInfo.error == RadioError::MODEM_ERR ||
+ radioRsp->rspInfo.error == RadioError::SYSTEM_ERR);
+ }
}
/*
* Test IRadio.writeSmsToRuim() for the response returned.
*/
TEST_F(RadioHidlTest, writeSmsToRuim) {
- int serial = 0;
+ int serial = 0;
- // Create a CdmaSmsAddress
- CdmaSmsAddress cdmaSmsAddress;
- cdmaSmsAddress.digitMode = CdmaSmsDigitMode::FOUR_BIT;
- cdmaSmsAddress.numberMode = CdmaSmsNumberMode::NOT_DATA_NETWORK;
- cdmaSmsAddress.numberType = CdmaSmsNumberType::UNKNOWN;
- cdmaSmsAddress.numberPlan = CdmaSmsNumberPlan::UNKNOWN;
- cdmaSmsAddress.digits = (std::vector<uint8_t>) {11, 1, 6, 5, 10, 7, 7, 2, 10, 3, 10, 3};
+ // Create a CdmaSmsAddress
+ CdmaSmsAddress cdmaSmsAddress;
+ cdmaSmsAddress.digitMode = CdmaSmsDigitMode::FOUR_BIT;
+ cdmaSmsAddress.numberMode = CdmaSmsNumberMode::NOT_DATA_NETWORK;
+ cdmaSmsAddress.numberType = CdmaSmsNumberType::UNKNOWN;
+ cdmaSmsAddress.numberPlan = CdmaSmsNumberPlan::UNKNOWN;
+ cdmaSmsAddress.digits =
+ (std::vector<uint8_t>){11, 1, 6, 5, 10, 7, 7, 2, 10, 3, 10, 3};
- // Create a CdmaSmsSubAddress
- CdmaSmsSubaddress cdmaSmsSubaddress;
- cdmaSmsSubaddress.subaddressType = CdmaSmsSubaddressType::NSAP;
- cdmaSmsSubaddress.odd = false;
- cdmaSmsSubaddress.digits = (std::vector<uint8_t>) {};
+ // Create a CdmaSmsSubAddress
+ CdmaSmsSubaddress cdmaSmsSubaddress;
+ cdmaSmsSubaddress.subaddressType = CdmaSmsSubaddressType::NSAP;
+ cdmaSmsSubaddress.odd = false;
+ cdmaSmsSubaddress.digits = (std::vector<uint8_t>){};
- // Create a CdmaSmsMessage
- CdmaSmsMessage cdmaSmsMessage;
- cdmaSmsMessage.teleserviceId = 4098;
- cdmaSmsMessage.isServicePresent = false;
- cdmaSmsMessage.serviceCategory = 0;
- cdmaSmsMessage.address = cdmaSmsAddress;
- cdmaSmsMessage.subAddress = cdmaSmsSubaddress;
- cdmaSmsMessage.bearerData = (std::vector<uint8_t>)
- {15, 0, 3, 32, 3, 16, 1, 8, 16, 53, 76, 68, 6, 51, 106, 0};
+ // Create a CdmaSmsMessage
+ CdmaSmsMessage cdmaSmsMessage;
+ cdmaSmsMessage.teleserviceId = 4098;
+ cdmaSmsMessage.isServicePresent = false;
+ cdmaSmsMessage.serviceCategory = 0;
+ cdmaSmsMessage.address = cdmaSmsAddress;
+ cdmaSmsMessage.subAddress = cdmaSmsSubaddress;
+ cdmaSmsMessage.bearerData = (std::vector<uint8_t>){
+ 15, 0, 3, 32, 3, 16, 1, 8, 16, 53, 76, 68, 6, 51, 106, 0};
- // Create a CdmaSmsWriteArgs
- CdmaSmsWriteArgs cdmaSmsWriteArgs;
- cdmaSmsWriteArgs.status = CdmaSmsWriteArgsStatus::REC_UNREAD;
- cdmaSmsWriteArgs.message = cdmaSmsMessage;
+ // Create a CdmaSmsWriteArgs
+ CdmaSmsWriteArgs cdmaSmsWriteArgs;
+ cdmaSmsWriteArgs.status = CdmaSmsWriteArgsStatus::REC_UNREAD;
+ cdmaSmsWriteArgs.message = cdmaSmsMessage;
- radio->writeSmsToRuim(++serial, cdmaSmsWriteArgs);
+ radio->writeSmsToRuim(++serial, cdmaSmsWriteArgs);
- EXPECT_EQ(std::cv_status::no_timeout, wait());
- EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
- EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+ EXPECT_EQ(std::cv_status::no_timeout, wait());
+ EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+ EXPECT_EQ(serial, radioRsp->rspInfo.serial);
- if (cardStatus.cardState == CardState::ABSENT) {
- ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS
- || radioRsp->rspInfo.error == RadioError::MODEM_ERR
- || radioRsp->rspInfo.error == RadioError::INVALID_MODEM_STATE
- || radioRsp->rspInfo.error == RadioError::INTERNAL_ERR);
- }
+ if (cardStatus.cardState == CardState::ABSENT) {
+ ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS ||
+ radioRsp->rspInfo.error == RadioError::MODEM_ERR ||
+ radioRsp->rspInfo.error == RadioError::INVALID_MODEM_STATE ||
+ radioRsp->rspInfo.error == RadioError::INTERNAL_ERR);
+ }
}
/*
* Test IRadio.deleteSmsOnRuim() for the response returned.
*/
TEST_F(RadioHidlTest, deleteSmsOnRuim) {
- int serial = 0;
- int index = 1;
+ int serial = 0;
+ int index = 1;
- // Create a CdmaSmsAddress
- CdmaSmsAddress cdmaSmsAddress;
- cdmaSmsAddress.digitMode = CdmaSmsDigitMode::FOUR_BIT;
- cdmaSmsAddress.numberMode = CdmaSmsNumberMode::NOT_DATA_NETWORK;
- cdmaSmsAddress.numberType = CdmaSmsNumberType::UNKNOWN;
- cdmaSmsAddress.numberPlan = CdmaSmsNumberPlan::UNKNOWN;
- cdmaSmsAddress.digits = (std::vector<uint8_t>) {11, 1, 6, 5, 10, 7, 7, 2, 10, 3, 10, 3};
+ // Create a CdmaSmsAddress
+ CdmaSmsAddress cdmaSmsAddress;
+ cdmaSmsAddress.digitMode = CdmaSmsDigitMode::FOUR_BIT;
+ cdmaSmsAddress.numberMode = CdmaSmsNumberMode::NOT_DATA_NETWORK;
+ cdmaSmsAddress.numberType = CdmaSmsNumberType::UNKNOWN;
+ cdmaSmsAddress.numberPlan = CdmaSmsNumberPlan::UNKNOWN;
+ cdmaSmsAddress.digits =
+ (std::vector<uint8_t>){11, 1, 6, 5, 10, 7, 7, 2, 10, 3, 10, 3};
- // Create a CdmaSmsSubAddress
- CdmaSmsSubaddress cdmaSmsSubaddress;
- cdmaSmsSubaddress.subaddressType = CdmaSmsSubaddressType::NSAP;
- cdmaSmsSubaddress.odd = false;
- cdmaSmsSubaddress.digits = (std::vector<uint8_t>) {};
+ // Create a CdmaSmsSubAddress
+ CdmaSmsSubaddress cdmaSmsSubaddress;
+ cdmaSmsSubaddress.subaddressType = CdmaSmsSubaddressType::NSAP;
+ cdmaSmsSubaddress.odd = false;
+ cdmaSmsSubaddress.digits = (std::vector<uint8_t>){};
- // Create a CdmaSmsMessage
- CdmaSmsMessage cdmaSmsMessage;
- cdmaSmsMessage.teleserviceId = 4098;
- cdmaSmsMessage.isServicePresent = false;
- cdmaSmsMessage.serviceCategory = 0;
- cdmaSmsMessage.address = cdmaSmsAddress;
- cdmaSmsMessage.subAddress = cdmaSmsSubaddress;
- cdmaSmsMessage.bearerData = (std::vector<uint8_t>)
- {15, 0, 3, 32, 3, 16, 1, 8, 16, 53, 76, 68, 6, 51, 106, 0};
+ // Create a CdmaSmsMessage
+ CdmaSmsMessage cdmaSmsMessage;
+ cdmaSmsMessage.teleserviceId = 4098;
+ cdmaSmsMessage.isServicePresent = false;
+ cdmaSmsMessage.serviceCategory = 0;
+ cdmaSmsMessage.address = cdmaSmsAddress;
+ cdmaSmsMessage.subAddress = cdmaSmsSubaddress;
+ cdmaSmsMessage.bearerData = (std::vector<uint8_t>){
+ 15, 0, 3, 32, 3, 16, 1, 8, 16, 53, 76, 68, 6, 51, 106, 0};
- // Create a CdmaSmsWriteArgs
- CdmaSmsWriteArgs cdmaSmsWriteArgs;
- cdmaSmsWriteArgs.status = CdmaSmsWriteArgsStatus::REC_UNREAD;
- cdmaSmsWriteArgs.message = cdmaSmsMessage;
+ // Create a CdmaSmsWriteArgs
+ CdmaSmsWriteArgs cdmaSmsWriteArgs;
+ cdmaSmsWriteArgs.status = CdmaSmsWriteArgsStatus::REC_UNREAD;
+ cdmaSmsWriteArgs.message = cdmaSmsMessage;
- radio->deleteSmsOnRuim(++serial, index);
+ radio->deleteSmsOnRuim(++serial, index);
- EXPECT_EQ(std::cv_status::no_timeout, wait());
- EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
- EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+ EXPECT_EQ(std::cv_status::no_timeout, wait());
+ EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+ EXPECT_EQ(serial, radioRsp->rspInfo.serial);
- if (cardStatus.cardState == CardState::ABSENT) {
- ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS
- || radioRsp->rspInfo.error == RadioError::MODEM_ERR
- || radioRsp->rspInfo.error == RadioError::SYSTEM_ERR);
- }
+ if (cardStatus.cardState == CardState::ABSENT) {
+ ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS ||
+ radioRsp->rspInfo.error == RadioError::MODEM_ERR ||
+ radioRsp->rspInfo.error == RadioError::SYSTEM_ERR);
+ }
}
/*
* Test IRadio.reportSmsMemoryStatus() for the response returned.
*/
TEST_F(RadioHidlTest, reportSmsMemoryStatus) {
- int serial = 0;
- bool available = true;
+ int serial = 0;
+ bool available = true;
- radio->reportSmsMemoryStatus(++serial, available);
+ radio->reportSmsMemoryStatus(++serial, available);
- EXPECT_EQ(std::cv_status::no_timeout, wait());
- EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
- EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+ EXPECT_EQ(std::cv_status::no_timeout, wait());
+ EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+ EXPECT_EQ(serial, radioRsp->rspInfo.serial);
- if (cardStatus.cardState == CardState::ABSENT) {
- ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS
- || radioRsp->rspInfo.error == RadioError::MODEM_ERR
- || radioRsp->rspInfo.error == RadioError::SYSTEM_ERR
- || radioRsp->rspInfo.error == RadioError::INVALID_STATE);
- }
+ if (cardStatus.cardState == CardState::ABSENT) {
+ ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS ||
+ radioRsp->rspInfo.error == RadioError::MODEM_ERR ||
+ radioRsp->rspInfo.error == RadioError::SYSTEM_ERR ||
+ radioRsp->rspInfo.error == RadioError::INVALID_STATE);
+ }
}
diff --git a/radio/1.0/vts/functional/radio_hidl_hal_stk.cpp b/radio/1.0/vts/functional/radio_hidl_hal_stk.cpp
index f6d576d..b02a740 100644
--- a/radio/1.0/vts/functional/radio_hidl_hal_stk.cpp
+++ b/radio/1.0/vts/functional/radio_hidl_hal_stk.cpp
@@ -14,7 +14,7 @@
* limitations under the License.
*/
-#include<radio_hidl_hal_utils.h>
+#include <radio_hidl_hal_utils.h>
using namespace ::android::hardware::radio::V1_0;
@@ -22,132 +22,133 @@
* Test IRadio.sendEnvelope() for the response returned.
*/
TEST_F(RadioHidlTest, sendEnvelope) {
- int serial = 0;
+ int serial = 0;
- // Test with sending empty string
- std::string content = "";
+ // Test with sending empty string
+ std::string content = "";
- radio->sendEnvelope(++serial, content);
+ radio->sendEnvelope(++serial, content);
- EXPECT_EQ(std::cv_status::no_timeout, wait());
- EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
- EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+ EXPECT_EQ(std::cv_status::no_timeout, wait());
+ EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+ EXPECT_EQ(serial, radioRsp->rspInfo.serial);
- if (cardStatus.cardState == CardState::ABSENT) {
- EXPECT_EQ(RadioError::NONE, radioRsp->rspInfo.error);
- }
+ if (cardStatus.cardState == CardState::ABSENT) {
+ EXPECT_EQ(RadioError::NONE, radioRsp->rspInfo.error);
+ }
- // Test with sending random string
- content = "0";
+ // Test with sending random string
+ content = "0";
- radio->sendEnvelope(++serial, content);
+ radio->sendEnvelope(++serial, content);
- EXPECT_EQ(std::cv_status::no_timeout, wait());
- EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
- EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+ EXPECT_EQ(std::cv_status::no_timeout, wait());
+ EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+ EXPECT_EQ(serial, radioRsp->rspInfo.serial);
- if (cardStatus.cardState == CardState::ABSENT) {
- EXPECT_EQ(RadioError::NONE, radioRsp->rspInfo.error);
- }
+ if (cardStatus.cardState == CardState::ABSENT) {
+ EXPECT_EQ(RadioError::NONE, radioRsp->rspInfo.error);
+ }
}
/*
* Test IRadio.sendTerminalResponseToSim() for the response returned.
*/
TEST_F(RadioHidlTest, sendTerminalResponseToSim) {
- int serial = 0;
+ int serial = 0;
- // Test with sending empty string
- std::string commandResponse = "";
+ // Test with sending empty string
+ std::string commandResponse = "";
- radio->sendTerminalResponseToSim(++serial, commandResponse);
+ radio->sendTerminalResponseToSim(++serial, commandResponse);
- EXPECT_EQ(std::cv_status::no_timeout, wait());
- EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
- EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+ EXPECT_EQ(std::cv_status::no_timeout, wait());
+ EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+ EXPECT_EQ(serial, radioRsp->rspInfo.serial);
- if (cardStatus.cardState == CardState::ABSENT) {
- EXPECT_EQ(RadioError::NONE, radioRsp->rspInfo.error);
- }
+ if (cardStatus.cardState == CardState::ABSENT) {
+ EXPECT_EQ(RadioError::NONE, radioRsp->rspInfo.error);
+ }
- // Test with sending random string
- commandResponse = "0";
+ // Test with sending random string
+ commandResponse = "0";
- radio->sendTerminalResponseToSim(++serial, commandResponse);
+ radio->sendTerminalResponseToSim(++serial, commandResponse);
- EXPECT_EQ(std::cv_status::no_timeout, wait());
- EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
- EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+ EXPECT_EQ(std::cv_status::no_timeout, wait());
+ EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+ EXPECT_EQ(serial, radioRsp->rspInfo.serial);
- if (cardStatus.cardState == CardState::ABSENT) {
- EXPECT_EQ(RadioError::NONE, radioRsp->rspInfo.error);
- }
+ if (cardStatus.cardState == CardState::ABSENT) {
+ EXPECT_EQ(RadioError::NONE, radioRsp->rspInfo.error);
+ }
}
/*
* Test IRadio.handleStkCallSetupRequestFromSim() for the response returned.
*/
TEST_F(RadioHidlTest, handleStkCallSetupRequestFromSim) {
- int serial = 0;
- bool accept = false;
+ int serial = 0;
+ bool accept = false;
- radio->handleStkCallSetupRequestFromSim(++serial, accept);
+ radio->handleStkCallSetupRequestFromSim(++serial, accept);
- EXPECT_EQ(std::cv_status::no_timeout, wait());
- EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
- EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+ EXPECT_EQ(std::cv_status::no_timeout, wait());
+ EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+ EXPECT_EQ(serial, radioRsp->rspInfo.serial);
- if (cardStatus.cardState == CardState::ABSENT) {
- EXPECT_EQ(RadioError::NONE, radioRsp->rspInfo.error);
- }
+ if (cardStatus.cardState == CardState::ABSENT) {
+ EXPECT_EQ(RadioError::NONE, radioRsp->rspInfo.error);
+ }
}
/*
* Test IRadio.reportStkServiceIsRunning() for the response returned.
*/
TEST_F(RadioHidlTest, reportStkServiceIsRunning) {
- int serial = 0;
+ int serial = 0;
- radio->reportStkServiceIsRunning(++serial);
+ radio->reportStkServiceIsRunning(++serial);
- EXPECT_EQ(std::cv_status::no_timeout, wait());
- EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
- EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+ EXPECT_EQ(std::cv_status::no_timeout, wait());
+ EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+ EXPECT_EQ(serial, radioRsp->rspInfo.serial);
- if (cardStatus.cardState == CardState::ABSENT) {
- EXPECT_EQ(RadioError::NONE, radioRsp->rspInfo.error);
- }
+ if (cardStatus.cardState == CardState::ABSENT) {
+ EXPECT_EQ(RadioError::NONE, radioRsp->rspInfo.error);
+ }
}
/*
- * Test IRadio.sendEnvelopeWithStatus() for the response returned with empty string.
+ * Test IRadio.sendEnvelopeWithStatus() for the response returned with empty
+ * string.
*/
TEST_F(RadioHidlTest, sendEnvelopeWithStatus) {
- int serial = 0;
+ int serial = 0;
- // Test with sending empty string
- std::string contents = "";
+ // Test with sending empty string
+ std::string contents = "";
- radio->sendEnvelopeWithStatus(++serial, contents);
+ radio->sendEnvelopeWithStatus(++serial, contents);
- EXPECT_EQ(std::cv_status::no_timeout, wait());
- EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
- EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+ EXPECT_EQ(std::cv_status::no_timeout, wait());
+ EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+ EXPECT_EQ(serial, radioRsp->rspInfo.serial);
- if (cardStatus.cardState == CardState::ABSENT) {
- EXPECT_EQ(RadioError::NONE, radioRsp->rspInfo.error);
- }
+ if (cardStatus.cardState == CardState::ABSENT) {
+ EXPECT_EQ(RadioError::NONE, radioRsp->rspInfo.error);
+ }
- // Test with sending random string
- contents = "0";
+ // Test with sending random string
+ contents = "0";
- radio->sendEnvelopeWithStatus(++serial, contents);
+ radio->sendEnvelopeWithStatus(++serial, contents);
- EXPECT_EQ(std::cv_status::no_timeout, wait());
- EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
- EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+ EXPECT_EQ(std::cv_status::no_timeout, wait());
+ EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+ EXPECT_EQ(serial, radioRsp->rspInfo.serial);
- if (cardStatus.cardState == CardState::ABSENT) {
- ASSERT_FALSE(RadioError::NONE == radioRsp->rspInfo.error);
- }
+ if (cardStatus.cardState == CardState::ABSENT) {
+ ASSERT_FALSE(RadioError::NONE == radioRsp->rspInfo.error);
+ }
}
diff --git a/radio/1.0/vts/functional/radio_hidl_hal_test.cpp b/radio/1.0/vts/functional/radio_hidl_hal_test.cpp
index db7356f..9094f39 100644
--- a/radio/1.0/vts/functional/radio_hidl_hal_test.cpp
+++ b/radio/1.0/vts/functional/radio_hidl_hal_test.cpp
@@ -14,48 +14,47 @@
* limitations under the License.
*/
-#include<radio_hidl_hal_utils.h>
+#include <radio_hidl_hal_utils.h>
void RadioHidlTest::SetUp() {
- radio = ::testing::VtsHalHidlTargetTestBase::getService<IRadio>(hidl_string("rild"));
- ASSERT_NE(radio, nullptr);
+ radio = ::testing::VtsHalHidlTargetTestBase::getService<IRadio>(
+ hidl_string("rild"));
+ ASSERT_NE(radio, nullptr);
- radioRsp = new RadioResponse(*this);
- ASSERT_NE(radioRsp, nullptr);
+ radioRsp = new RadioResponse(*this);
+ ASSERT_NE(radioRsp, nullptr);
- count = 0;
+ count = 0;
- radioInd = NULL;
- radio->setResponseFunctions(radioRsp, radioInd);
+ radioInd = NULL;
+ radio->setResponseFunctions(radioRsp, radioInd);
- radio->getIccCardStatus(1);
- EXPECT_EQ(std::cv_status::no_timeout, wait());
- EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
- EXPECT_EQ(1, radioRsp->rspInfo.serial);
- EXPECT_EQ(RadioError::NONE, radioRsp->rspInfo.error);
+ radio->getIccCardStatus(1);
+ EXPECT_EQ(std::cv_status::no_timeout, wait());
+ EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+ EXPECT_EQ(1, radioRsp->rspInfo.serial);
+ EXPECT_EQ(RadioError::NONE, radioRsp->rspInfo.error);
}
-void RadioHidlTest::TearDown() {
-}
+void RadioHidlTest::TearDown() {}
void RadioHidlTest::notify() {
- std::unique_lock<std::mutex> lock(mtx);
- count++;
- cv.notify_one();
+ std::unique_lock<std::mutex> lock(mtx);
+ count++;
+ cv.notify_one();
}
std::cv_status RadioHidlTest::wait() {
- std::unique_lock<std::mutex> lock(mtx);
+ std::unique_lock<std::mutex> lock(mtx);
- std::cv_status status = std::cv_status::no_timeout;
- auto now = std::chrono::system_clock::now();
- while (count == 0) {
- status = cv.wait_until(lock, now + std::chrono::seconds(TIMEOUT_PERIOD));
- if (status == std::cv_status::timeout) {
- return status;
- }
+ std::cv_status status = std::cv_status::no_timeout;
+ auto now = std::chrono::system_clock::now();
+ while (count == 0) {
+ status = cv.wait_until(lock, now + std::chrono::seconds(TIMEOUT_PERIOD));
+ if (status == std::cv_status::timeout) {
+ return status;
}
- count--;
- return status;
+ }
+ count--;
+ return status;
}
-
diff --git a/radio/1.0/vts/functional/radio_hidl_hal_utils.h b/radio/1.0/vts/functional/radio_hidl_hal_utils.h
index 126ad0d..6826238 100644
--- a/radio/1.0/vts/functional/radio_hidl_hal_utils.h
+++ b/radio/1.0/vts/functional/radio_hidl_hal_utils.h
@@ -22,8 +22,8 @@
#include <mutex>
#include <android/hardware/radio/1.0/IRadio.h>
-#include <android/hardware/radio/1.0/IRadioResponse.h>
#include <android/hardware/radio/1.0/IRadioIndication.h>
+#include <android/hardware/radio/1.0/IRadioResponse.h>
#include <android/hardware/radio/1.0/types.h>
using ::android::hardware::radio::V1_0::ActivityStatsInfo;
@@ -87,387 +87,426 @@
/* Callback class for radio response */
class RadioResponse : public IRadioResponse {
-private:
- RadioHidlTest& parent;
+ private:
+ RadioHidlTest& parent;
-public:
- RadioResponseInfo rspInfo;
- hidl_string imsi;
- IccIoResult iccIoResult;
- int channelId;
+ public:
+ RadioResponseInfo rspInfo;
+ hidl_string imsi;
+ IccIoResult iccIoResult;
+ int channelId;
- // Sms
- SendSmsResult sendSmsResult;
- hidl_string smscAddress;
- uint32_t writeSmsToSimIndex;
- uint32_t writeSmsToRuimIndex;
+ // Sms
+ SendSmsResult sendSmsResult;
+ hidl_string smscAddress;
+ uint32_t writeSmsToSimIndex;
+ uint32_t writeSmsToRuimIndex;
- RadioResponse(RadioHidlTest& parent);
+ RadioResponse(RadioHidlTest& parent);
- virtual ~RadioResponse() = default;
+ virtual ~RadioResponse() = default;
- Return<void> getIccCardStatusResponse(const RadioResponseInfo& info,
- const CardStatus& cardStatus);
+ Return<void> getIccCardStatusResponse(const RadioResponseInfo& info,
+ const CardStatus& cardStatus);
- Return<void> supplyIccPinForAppResponse(const RadioResponseInfo& info,
- int32_t remainingRetries);
+ Return<void> supplyIccPinForAppResponse(const RadioResponseInfo& info,
+ int32_t remainingRetries);
- Return<void> supplyIccPukForAppResponse(const RadioResponseInfo& info,
- int32_t remainingRetries);
+ Return<void> supplyIccPukForAppResponse(const RadioResponseInfo& info,
+ int32_t remainingRetries);
- Return<void> supplyIccPin2ForAppResponse(const RadioResponseInfo& info,
- int32_t remainingRetries);
+ Return<void> supplyIccPin2ForAppResponse(const RadioResponseInfo& info,
+ int32_t remainingRetries);
- Return<void> supplyIccPuk2ForAppResponse(const RadioResponseInfo& info,
- int32_t remainingRetries);
+ Return<void> supplyIccPuk2ForAppResponse(const RadioResponseInfo& info,
+ int32_t remainingRetries);
- Return<void> changeIccPinForAppResponse(const RadioResponseInfo& info,
- int32_t remainingRetries);
+ Return<void> changeIccPinForAppResponse(const RadioResponseInfo& info,
+ int32_t remainingRetries);
- Return<void> changeIccPin2ForAppResponse(const RadioResponseInfo& info,
- int32_t remainingRetries);
+ Return<void> changeIccPin2ForAppResponse(const RadioResponseInfo& info,
+ int32_t remainingRetries);
- Return<void> supplyNetworkDepersonalizationResponse(
- const RadioResponseInfo& info, int32_t remainingRetries);
+ Return<void> supplyNetworkDepersonalizationResponse(
+ const RadioResponseInfo& info, int32_t remainingRetries);
- Return<void> getCurrentCallsResponse(const RadioResponseInfo& info,
- const ::android::hardware::hidl_vec<Call>& calls);
+ Return<void> getCurrentCallsResponse(
+ const RadioResponseInfo& info,
+ const ::android::hardware::hidl_vec<Call>& calls);
- Return<void> dialResponse(const RadioResponseInfo& info);
+ Return<void> dialResponse(const RadioResponseInfo& info);
- Return<void> getIMSIForAppResponse(const RadioResponseInfo& info,
- const ::android::hardware::hidl_string& imsi);
+ Return<void> getIMSIForAppResponse(
+ const RadioResponseInfo& info,
+ const ::android::hardware::hidl_string& imsi);
- Return<void> hangupConnectionResponse(const RadioResponseInfo& info);
+ Return<void> hangupConnectionResponse(const RadioResponseInfo& info);
- Return<void> hangupWaitingOrBackgroundResponse(
- const RadioResponseInfo& info);
+ Return<void> hangupWaitingOrBackgroundResponse(const RadioResponseInfo& info);
- Return<void> hangupForegroundResumeBackgroundResponse(
- const RadioResponseInfo& info);
+ Return<void> hangupForegroundResumeBackgroundResponse(
+ const RadioResponseInfo& info);
- Return<void> switchWaitingOrHoldingAndActiveResponse(
- const RadioResponseInfo& info);
+ Return<void> switchWaitingOrHoldingAndActiveResponse(
+ const RadioResponseInfo& info);
- Return<void> conferenceResponse(const RadioResponseInfo& info);
+ Return<void> conferenceResponse(const RadioResponseInfo& info);
- Return<void> rejectCallResponse(const RadioResponseInfo& info);
+ Return<void> rejectCallResponse(const RadioResponseInfo& info);
- Return<void> getLastCallFailCauseResponse(const RadioResponseInfo& info,
- const LastCallFailCauseInfo& failCauseInfo);
+ Return<void> getLastCallFailCauseResponse(
+ const RadioResponseInfo& info,
+ const LastCallFailCauseInfo& failCauseInfo);
- Return<void> getSignalStrengthResponse(const RadioResponseInfo& info,
- const SignalStrength& sigStrength);
+ Return<void> getSignalStrengthResponse(const RadioResponseInfo& info,
+ const SignalStrength& sigStrength);
- Return<void> getVoiceRegistrationStateResponse(const RadioResponseInfo& info,
- const VoiceRegStateResult& voiceRegResponse);
+ Return<void> getVoiceRegistrationStateResponse(
+ const RadioResponseInfo& info,
+ const VoiceRegStateResult& voiceRegResponse);
- Return<void> getDataRegistrationStateResponse(const RadioResponseInfo& info,
- const DataRegStateResult& dataRegResponse);
+ Return<void> getDataRegistrationStateResponse(
+ const RadioResponseInfo& info, const DataRegStateResult& dataRegResponse);
- Return<void> getOperatorResponse(const RadioResponseInfo& info,
- const ::android::hardware::hidl_string& longName,
- const ::android::hardware::hidl_string& shortName,
- const ::android::hardware::hidl_string& numeric);
+ Return<void> getOperatorResponse(
+ const RadioResponseInfo& info,
+ const ::android::hardware::hidl_string& longName,
+ const ::android::hardware::hidl_string& shortName,
+ const ::android::hardware::hidl_string& numeric);
- Return<void> setRadioPowerResponse(const RadioResponseInfo& info);
+ Return<void> setRadioPowerResponse(const RadioResponseInfo& info);
- Return<void> sendDtmfResponse(const RadioResponseInfo& info);
+ Return<void> sendDtmfResponse(const RadioResponseInfo& info);
- Return<void> sendSmsResponse(const RadioResponseInfo& info,
- const SendSmsResult& sms);
+ Return<void> sendSmsResponse(const RadioResponseInfo& info,
+ const SendSmsResult& sms);
- Return<void> sendSMSExpectMoreResponse(const RadioResponseInfo& info,
- const SendSmsResult& sms);
+ Return<void> sendSMSExpectMoreResponse(const RadioResponseInfo& info,
+ const SendSmsResult& sms);
- Return<void> setupDataCallResponse(const RadioResponseInfo& info,
- const SetupDataCallResult& dcResponse);
+ Return<void> setupDataCallResponse(const RadioResponseInfo& info,
+ const SetupDataCallResult& dcResponse);
- Return<void> iccIOForAppResponse(const RadioResponseInfo& info,
- const IccIoResult& iccIo);
+ Return<void> iccIOForAppResponse(const RadioResponseInfo& info,
+ const IccIoResult& iccIo);
- Return<void> sendUssdResponse(const RadioResponseInfo& info);
+ Return<void> sendUssdResponse(const RadioResponseInfo& info);
- Return<void> cancelPendingUssdResponse(const RadioResponseInfo& info);
+ Return<void> cancelPendingUssdResponse(const RadioResponseInfo& info);
- Return<void> getClirResponse(const RadioResponseInfo& info, int32_t n, int32_t m);
+ Return<void> getClirResponse(const RadioResponseInfo& info, int32_t n,
+ int32_t m);
- Return<void> setClirResponse(const RadioResponseInfo& info);
+ Return<void> setClirResponse(const RadioResponseInfo& info);
- Return<void> getCallForwardStatusResponse(const RadioResponseInfo& info,
- const ::android::hardware::hidl_vec<CallForwardInfo>& call_forwardInfos);
+ Return<void> getCallForwardStatusResponse(
+ const RadioResponseInfo& info,
+ const ::android::hardware::hidl_vec<CallForwardInfo>& call_forwardInfos);
- Return<void> setCallForwardResponse(const RadioResponseInfo& info);
+ Return<void> setCallForwardResponse(const RadioResponseInfo& info);
- Return<void> getCallWaitingResponse(const RadioResponseInfo& info,
- bool enable, int32_t serviceClass);
+ Return<void> getCallWaitingResponse(const RadioResponseInfo& info,
+ bool enable, int32_t serviceClass);
- Return<void> setCallWaitingResponse(const RadioResponseInfo& info);
+ Return<void> setCallWaitingResponse(const RadioResponseInfo& info);
- Return<void> acknowledgeLastIncomingGsmSmsResponse(const RadioResponseInfo& info);
+ Return<void> acknowledgeLastIncomingGsmSmsResponse(
+ const RadioResponseInfo& info);
- Return<void> acceptCallResponse(const RadioResponseInfo& info);
+ Return<void> acceptCallResponse(const RadioResponseInfo& info);
- Return<void> deactivateDataCallResponse(const RadioResponseInfo& info);
+ Return<void> deactivateDataCallResponse(const RadioResponseInfo& info);
- Return<void> getFacilityLockForAppResponse(const RadioResponseInfo& info,int32_t response);
+ Return<void> getFacilityLockForAppResponse(const RadioResponseInfo& info,
+ int32_t response);
- Return<void> setFacilityLockForAppResponse(const RadioResponseInfo& info,int32_t retry);
+ Return<void> setFacilityLockForAppResponse(const RadioResponseInfo& info,
+ int32_t retry);
- Return<void> setBarringPasswordResponse(const RadioResponseInfo& info);
+ Return<void> setBarringPasswordResponse(const RadioResponseInfo& info);
- Return<void> getNetworkSelectionModeResponse(const RadioResponseInfo& info,bool manual);
+ Return<void> getNetworkSelectionModeResponse(const RadioResponseInfo& info,
+ bool manual);
- Return<void> setNetworkSelectionModeAutomaticResponse(const RadioResponseInfo& info);
+ Return<void> setNetworkSelectionModeAutomaticResponse(
+ const RadioResponseInfo& info);
- Return<void> setNetworkSelectionModeManualResponse(const RadioResponseInfo& info);
+ Return<void> setNetworkSelectionModeManualResponse(
+ const RadioResponseInfo& info);
- Return<void> getAvailableNetworksResponse(const RadioResponseInfo& info,
- const ::android::hardware::hidl_vec<OperatorInfo>& networkInfos);
+ Return<void> getAvailableNetworksResponse(
+ const RadioResponseInfo& info,
+ const ::android::hardware::hidl_vec<OperatorInfo>& networkInfos);
- Return<void> startDtmfResponse(const RadioResponseInfo& info);
+ Return<void> startDtmfResponse(const RadioResponseInfo& info);
- Return<void> stopDtmfResponse(const RadioResponseInfo& info);
+ Return<void> stopDtmfResponse(const RadioResponseInfo& info);
- Return<void> getBasebandVersionResponse(const RadioResponseInfo& info,
- const ::android::hardware::hidl_string& version);
+ Return<void> getBasebandVersionResponse(
+ const RadioResponseInfo& info,
+ const ::android::hardware::hidl_string& version);
- Return<void> separateConnectionResponse(const RadioResponseInfo& info);
+ Return<void> separateConnectionResponse(const RadioResponseInfo& info);
- Return<void> setMuteResponse(const RadioResponseInfo& info);
+ Return<void> setMuteResponse(const RadioResponseInfo& info);
- Return<void> getMuteResponse(const RadioResponseInfo& info, bool enable);
+ Return<void> getMuteResponse(const RadioResponseInfo& info, bool enable);
- Return<void> getClipResponse(const RadioResponseInfo& info,ClipStatus status);
+ Return<void> getClipResponse(const RadioResponseInfo& info,
+ ClipStatus status);
- Return<void> getDataCallListResponse(const RadioResponseInfo& info,
- const ::android::hardware::hidl_vec<SetupDataCallResult>& dcResponse);
+ Return<void> getDataCallListResponse(
+ const RadioResponseInfo& info,
+ const ::android::hardware::hidl_vec<SetupDataCallResult>& dcResponse);
- Return<void> sendOemRilRequestRawResponse(const RadioResponseInfo& info,
- const ::android::hardware::hidl_vec<uint8_t>& data);
+ Return<void> sendOemRilRequestRawResponse(
+ const RadioResponseInfo& info,
+ const ::android::hardware::hidl_vec<uint8_t>& data);
- Return<void> sendOemRilRequestStringsResponse(const RadioResponseInfo& info,
- const ::android::hardware::hidl_vec<::android::hardware::hidl_string>& data);
+ Return<void> sendOemRilRequestStringsResponse(
+ const RadioResponseInfo& info,
+ const ::android::hardware::hidl_vec<::android::hardware::hidl_string>&
+ data);
- Return<void> setSuppServiceNotificationsResponse(
- const RadioResponseInfo& info);
+ Return<void> setSuppServiceNotificationsResponse(
+ const RadioResponseInfo& info);
- Return<void> writeSmsToSimResponse(const RadioResponseInfo& info,int32_t index);
+ Return<void> writeSmsToSimResponse(const RadioResponseInfo& info,
+ int32_t index);
- Return<void> deleteSmsOnSimResponse(const RadioResponseInfo& info);
+ Return<void> deleteSmsOnSimResponse(const RadioResponseInfo& info);
- Return<void> setBandModeResponse(const RadioResponseInfo& info);
+ Return<void> setBandModeResponse(const RadioResponseInfo& info);
- Return<void> getAvailableBandModesResponse(const RadioResponseInfo& info,
- const ::android::hardware::hidl_vec<RadioBandMode>& bandModes);
+ Return<void> getAvailableBandModesResponse(
+ const RadioResponseInfo& info,
+ const ::android::hardware::hidl_vec<RadioBandMode>& bandModes);
- Return<void> sendEnvelopeResponse(const RadioResponseInfo& info,
- const ::android::hardware::hidl_string& commandResponse);
+ Return<void> sendEnvelopeResponse(
+ const RadioResponseInfo& info,
+ const ::android::hardware::hidl_string& commandResponse);
- Return<void> sendTerminalResponseToSimResponse(const RadioResponseInfo& info);
+ Return<void> sendTerminalResponseToSimResponse(const RadioResponseInfo& info);
- Return<void> handleStkCallSetupRequestFromSimResponse(
- const RadioResponseInfo& info);
+ Return<void> handleStkCallSetupRequestFromSimResponse(
+ const RadioResponseInfo& info);
- Return<void> explicitCallTransferResponse(const RadioResponseInfo& info);
+ Return<void> explicitCallTransferResponse(const RadioResponseInfo& info);
- Return<void> setPreferredNetworkTypeResponse(const RadioResponseInfo& info);
+ Return<void> setPreferredNetworkTypeResponse(const RadioResponseInfo& info);
- Return<void> getPreferredNetworkTypeResponse(const RadioResponseInfo& info,
- PreferredNetworkType nwType);
+ Return<void> getPreferredNetworkTypeResponse(const RadioResponseInfo& info,
+ PreferredNetworkType nwType);
- Return<void> getNeighboringCidsResponse(const RadioResponseInfo& info,
- const ::android::hardware::hidl_vec<NeighboringCell>& cells);
+ Return<void> getNeighboringCidsResponse(
+ const RadioResponseInfo& info,
+ const ::android::hardware::hidl_vec<NeighboringCell>& cells);
- Return<void> setLocationUpdatesResponse(const RadioResponseInfo& info);
+ Return<void> setLocationUpdatesResponse(const RadioResponseInfo& info);
- Return<void> setCdmaSubscriptionSourceResponse(const RadioResponseInfo& info);
+ Return<void> setCdmaSubscriptionSourceResponse(const RadioResponseInfo& info);
- Return<void> setCdmaRoamingPreferenceResponse(const RadioResponseInfo& info);
+ Return<void> setCdmaRoamingPreferenceResponse(const RadioResponseInfo& info);
- Return<void> getCdmaRoamingPreferenceResponse(const RadioResponseInfo& info,
- CdmaRoamingType type);
+ Return<void> getCdmaRoamingPreferenceResponse(const RadioResponseInfo& info,
+ CdmaRoamingType type);
- Return<void> setTTYModeResponse(const RadioResponseInfo& info);
+ Return<void> setTTYModeResponse(const RadioResponseInfo& info);
- Return<void> getTTYModeResponse(const RadioResponseInfo& info, TtyMode mode);
+ Return<void> getTTYModeResponse(const RadioResponseInfo& info, TtyMode mode);
- Return<void> setPreferredVoicePrivacyResponse(const RadioResponseInfo& info);
+ Return<void> setPreferredVoicePrivacyResponse(const RadioResponseInfo& info);
- Return<void> getPreferredVoicePrivacyResponse(const RadioResponseInfo& info, bool enable);
+ Return<void> getPreferredVoicePrivacyResponse(const RadioResponseInfo& info,
+ bool enable);
- Return<void> sendCDMAFeatureCodeResponse(const RadioResponseInfo& info);
+ Return<void> sendCDMAFeatureCodeResponse(const RadioResponseInfo& info);
- Return<void> sendBurstDtmfResponse(const RadioResponseInfo& info);
+ Return<void> sendBurstDtmfResponse(const RadioResponseInfo& info);
- Return<void> sendCdmaSmsResponse(const RadioResponseInfo& info, const SendSmsResult& sms);
+ Return<void> sendCdmaSmsResponse(const RadioResponseInfo& info,
+ const SendSmsResult& sms);
- Return<void> acknowledgeLastIncomingCdmaSmsResponse(const RadioResponseInfo& info);
+ Return<void> acknowledgeLastIncomingCdmaSmsResponse(
+ const RadioResponseInfo& info);
- Return<void> getGsmBroadcastConfigResponse(const RadioResponseInfo& info,
- const ::android::hardware::hidl_vec<GsmBroadcastSmsConfigInfo>& configs);
+ Return<void> getGsmBroadcastConfigResponse(
+ const RadioResponseInfo& info,
+ const ::android::hardware::hidl_vec<GsmBroadcastSmsConfigInfo>& configs);
- Return<void> setGsmBroadcastConfigResponse(const RadioResponseInfo& info);
+ Return<void> setGsmBroadcastConfigResponse(const RadioResponseInfo& info);
- Return<void> setGsmBroadcastActivationResponse(const RadioResponseInfo& info);
+ Return<void> setGsmBroadcastActivationResponse(const RadioResponseInfo& info);
- Return<void> getCdmaBroadcastConfigResponse(const RadioResponseInfo& info,
- const ::android::hardware::hidl_vec<CdmaBroadcastSmsConfigInfo>& configs);
+ Return<void> getCdmaBroadcastConfigResponse(
+ const RadioResponseInfo& info,
+ const ::android::hardware::hidl_vec<CdmaBroadcastSmsConfigInfo>& configs);
- Return<void> setCdmaBroadcastConfigResponse(const RadioResponseInfo& info);
+ Return<void> setCdmaBroadcastConfigResponse(const RadioResponseInfo& info);
- Return<void> setCdmaBroadcastActivationResponse(const RadioResponseInfo& info);
+ Return<void> setCdmaBroadcastActivationResponse(
+ const RadioResponseInfo& info);
- Return<void> getCDMASubscriptionResponse(const RadioResponseInfo& info,
- const ::android::hardware::hidl_string& mdn,
- const ::android::hardware::hidl_string& hSid,
- const ::android::hardware::hidl_string& hNid,
- const ::android::hardware::hidl_string& min,
- const ::android::hardware::hidl_string& prl);
+ Return<void> getCDMASubscriptionResponse(
+ const RadioResponseInfo& info,
+ const ::android::hardware::hidl_string& mdn,
+ const ::android::hardware::hidl_string& hSid,
+ const ::android::hardware::hidl_string& hNid,
+ const ::android::hardware::hidl_string& min,
+ const ::android::hardware::hidl_string& prl);
- Return<void> writeSmsToRuimResponse(const RadioResponseInfo& info, uint32_t index);
+ Return<void> writeSmsToRuimResponse(const RadioResponseInfo& info,
+ uint32_t index);
- Return<void> deleteSmsOnRuimResponse(const RadioResponseInfo& info);
+ Return<void> deleteSmsOnRuimResponse(const RadioResponseInfo& info);
- Return<void> getDeviceIdentityResponse(const RadioResponseInfo& info,
- const ::android::hardware::hidl_string& imei,
- const ::android::hardware::hidl_string& imeisv,
- const ::android::hardware::hidl_string& esn,
- const ::android::hardware::hidl_string& meid);
+ Return<void> getDeviceIdentityResponse(
+ const RadioResponseInfo& info,
+ const ::android::hardware::hidl_string& imei,
+ const ::android::hardware::hidl_string& imeisv,
+ const ::android::hardware::hidl_string& esn,
+ const ::android::hardware::hidl_string& meid);
- Return<void> exitEmergencyCallbackModeResponse(const RadioResponseInfo& info);
+ Return<void> exitEmergencyCallbackModeResponse(const RadioResponseInfo& info);
- Return<void> getSmscAddressResponse(const RadioResponseInfo& info,
- const ::android::hardware::hidl_string& smsc);
+ Return<void> getSmscAddressResponse(
+ const RadioResponseInfo& info,
+ const ::android::hardware::hidl_string& smsc);
- Return<void> setSmscAddressResponse(const RadioResponseInfo& info);
+ Return<void> setSmscAddressResponse(const RadioResponseInfo& info);
- Return<void> reportSmsMemoryStatusResponse(const RadioResponseInfo& info);
+ Return<void> reportSmsMemoryStatusResponse(const RadioResponseInfo& info);
- Return<void> reportStkServiceIsRunningResponse(const RadioResponseInfo& info);
+ Return<void> reportStkServiceIsRunningResponse(const RadioResponseInfo& info);
- Return<void> getCdmaSubscriptionSourceResponse(const RadioResponseInfo& info,
- CdmaSubscriptionSource source);
+ Return<void> getCdmaSubscriptionSourceResponse(const RadioResponseInfo& info,
+ CdmaSubscriptionSource source);
- Return<void> requestIsimAuthenticationResponse(const RadioResponseInfo& info,
- const ::android::hardware::hidl_string& response);
+ Return<void> requestIsimAuthenticationResponse(
+ const RadioResponseInfo& info,
+ const ::android::hardware::hidl_string& response);
- Return<void> acknowledgeIncomingGsmSmsWithPduResponse(
- const RadioResponseInfo& info);
+ Return<void> acknowledgeIncomingGsmSmsWithPduResponse(
+ const RadioResponseInfo& info);
- Return<void> sendEnvelopeWithStatusResponse(const RadioResponseInfo& info,
- const IccIoResult& iccIo);
+ Return<void> sendEnvelopeWithStatusResponse(const RadioResponseInfo& info,
+ const IccIoResult& iccIo);
- Return<void> getVoiceRadioTechnologyResponse(const RadioResponseInfo& info,
- RadioTechnology rat);
+ Return<void> getVoiceRadioTechnologyResponse(const RadioResponseInfo& info,
+ RadioTechnology rat);
- Return<void> getCellInfoListResponse(const RadioResponseInfo& info,
- const ::android::hardware::hidl_vec<CellInfo>& cellInfo);
+ Return<void> getCellInfoListResponse(
+ const RadioResponseInfo& info,
+ const ::android::hardware::hidl_vec<CellInfo>& cellInfo);
- Return<void> setCellInfoListRateResponse(const RadioResponseInfo& info);
+ Return<void> setCellInfoListRateResponse(const RadioResponseInfo& info);
- Return<void> setInitialAttachApnResponse(const RadioResponseInfo& info);
+ Return<void> setInitialAttachApnResponse(const RadioResponseInfo& info);
- Return<void> getImsRegistrationStateResponse(const RadioResponseInfo& info,
- bool isRegistered, RadioTechnologyFamily ratFamily);
+ Return<void> getImsRegistrationStateResponse(const RadioResponseInfo& info,
+ bool isRegistered,
+ RadioTechnologyFamily ratFamily);
- Return<void> sendImsSmsResponse(const RadioResponseInfo& info,
- const SendSmsResult& sms);
+ Return<void> sendImsSmsResponse(const RadioResponseInfo& info,
+ const SendSmsResult& sms);
- Return<void> iccTransmitApduBasicChannelResponse(
- const RadioResponseInfo& info, const IccIoResult& result);
+ Return<void> iccTransmitApduBasicChannelResponse(
+ const RadioResponseInfo& info, const IccIoResult& result);
- Return<void> iccOpenLogicalChannelResponse(const RadioResponseInfo& info,
- int32_t channelId, const ::android::hardware::hidl_vec<int8_t>& selectResponse);
+ Return<void> iccOpenLogicalChannelResponse(
+ const RadioResponseInfo& info, int32_t channelId,
+ const ::android::hardware::hidl_vec<int8_t>& selectResponse);
- Return<void> iccCloseLogicalChannelResponse(const RadioResponseInfo& info);
+ Return<void> iccCloseLogicalChannelResponse(const RadioResponseInfo& info);
- Return<void> iccTransmitApduLogicalChannelResponse(
- const RadioResponseInfo& info, const IccIoResult& result);
+ Return<void> iccTransmitApduLogicalChannelResponse(
+ const RadioResponseInfo& info, const IccIoResult& result);
- Return<void> nvReadItemResponse(const RadioResponseInfo& info,
- const ::android::hardware::hidl_string& result);
+ Return<void> nvReadItemResponse(
+ const RadioResponseInfo& info,
+ const ::android::hardware::hidl_string& result);
- Return<void> nvWriteItemResponse(const RadioResponseInfo& info);
+ Return<void> nvWriteItemResponse(const RadioResponseInfo& info);
- Return<void> nvWriteCdmaPrlResponse(const RadioResponseInfo& info);
+ Return<void> nvWriteCdmaPrlResponse(const RadioResponseInfo& info);
- Return<void> nvResetConfigResponse(const RadioResponseInfo& info);
+ Return<void> nvResetConfigResponse(const RadioResponseInfo& info);
- Return<void> setUiccSubscriptionResponse(const RadioResponseInfo& info);
+ Return<void> setUiccSubscriptionResponse(const RadioResponseInfo& info);
- Return<void> setDataAllowedResponse(const RadioResponseInfo& info);
+ Return<void> setDataAllowedResponse(const RadioResponseInfo& info);
- Return<void> getHardwareConfigResponse(const RadioResponseInfo& info,
- const ::android::hardware::hidl_vec<HardwareConfig>& config);
+ Return<void> getHardwareConfigResponse(
+ const RadioResponseInfo& info,
+ const ::android::hardware::hidl_vec<HardwareConfig>& config);
- Return<void> requestIccSimAuthenticationResponse(
- const RadioResponseInfo& info, const IccIoResult& result);
+ Return<void> requestIccSimAuthenticationResponse(
+ const RadioResponseInfo& info, const IccIoResult& result);
- Return<void> setDataProfileResponse(const RadioResponseInfo& info);
+ Return<void> setDataProfileResponse(const RadioResponseInfo& info);
- Return<void> requestShutdownResponse(const RadioResponseInfo& info);
+ Return<void> requestShutdownResponse(const RadioResponseInfo& info);
- Return<void> getRadioCapabilityResponse(const RadioResponseInfo& info,
- const RadioCapability& rc);
+ Return<void> getRadioCapabilityResponse(const RadioResponseInfo& info,
+ const RadioCapability& rc);
- Return<void> setRadioCapabilityResponse(const RadioResponseInfo& info,
- const RadioCapability& rc);
+ Return<void> setRadioCapabilityResponse(const RadioResponseInfo& info,
+ const RadioCapability& rc);
- Return<void> startLceServiceResponse(const RadioResponseInfo& info,
- const LceStatusInfo& statusInfo);
+ Return<void> startLceServiceResponse(const RadioResponseInfo& info,
+ const LceStatusInfo& statusInfo);
- Return<void> stopLceServiceResponse(const RadioResponseInfo& info,
- const LceStatusInfo& statusInfo);
+ Return<void> stopLceServiceResponse(const RadioResponseInfo& info,
+ const LceStatusInfo& statusInfo);
- Return<void> pullLceDataResponse(const RadioResponseInfo& info,
- const LceDataInfo& lceInfo);
+ Return<void> pullLceDataResponse(const RadioResponseInfo& info,
+ const LceDataInfo& lceInfo);
- Return<void> getModemActivityInfoResponse(const RadioResponseInfo& info,
- const ActivityStatsInfo& activityInfo);
+ Return<void> getModemActivityInfoResponse(
+ const RadioResponseInfo& info, const ActivityStatsInfo& activityInfo);
- Return<void> setAllowedCarriersResponse(const RadioResponseInfo& info,
- int32_t numAllowed);
+ Return<void> setAllowedCarriersResponse(const RadioResponseInfo& info,
+ int32_t numAllowed);
- Return<void> getAllowedCarriersResponse(const RadioResponseInfo& info,
- bool allAllowed, const CarrierRestrictions& carriers);
+ Return<void> getAllowedCarriersResponse(const RadioResponseInfo& info,
+ bool allAllowed,
+ const CarrierRestrictions& carriers);
- Return<void> sendDeviceStateResponse(const RadioResponseInfo& info);
+ Return<void> sendDeviceStateResponse(const RadioResponseInfo& info);
- Return<void> setIndicationFilterResponse(const RadioResponseInfo& info);
+ Return<void> setIndicationFilterResponse(const RadioResponseInfo& info);
- Return<void> setSimCardPowerResponse(const RadioResponseInfo& info);
+ Return<void> setSimCardPowerResponse(const RadioResponseInfo& info);
- Return<void> acknowledgeRequest(int32_t serial);
+ Return<void> acknowledgeRequest(int32_t serial);
};
// The main test class for Radio HIDL.
class RadioHidlTest : public ::testing::VtsHalHidlTargetTestBase {
-private:
- std::mutex mtx;
- std::condition_variable cv;
- int count;
+ private:
+ std::mutex mtx;
+ std::condition_variable cv;
+ int count;
-public:
- virtual void SetUp() override;
+ public:
+ virtual void SetUp() override;
- virtual void TearDown() override;
+ virtual void TearDown() override;
- /* Used as a mechanism to inform the test about data/event callback */
- void notify();
+ /* Used as a mechanism to inform the test about data/event callback */
+ void notify();
- /* Test code calls this function to wait for response */
- std::cv_status wait();
+ /* Test code calls this function to wait for response */
+ std::cv_status wait();
- sp<IRadio> radio;
- sp<RadioResponse> radioRsp;
- sp<IRadioIndication> radioInd;
-
+ sp<IRadio> radio;
+ sp<RadioResponse> radioRsp;
+ sp<IRadioIndication> radioInd;
};
// A class for test environment setup
class RadioHidlEnvironment : public ::testing::Environment {
-public:
- virtual void SetUp() {}
- virtual void TearDown() {}
+ public:
+ virtual void SetUp() {}
+ virtual void TearDown() {}
};
diff --git a/radio/1.0/vts/functional/radio_hidl_hal_voice.cpp b/radio/1.0/vts/functional/radio_hidl_hal_voice.cpp
index fa2871d..ef10d10 100644
--- a/radio/1.0/vts/functional/radio_hidl_hal_voice.cpp
+++ b/radio/1.0/vts/functional/radio_hidl_hal_voice.cpp
@@ -14,471 +14,471 @@
* limitations under the License.
*/
-#include<radio_hidl_hal_utils.h>
+#include <radio_hidl_hal_utils.h>
/*
* Test IRadio.getCurrentCalls() for the response returned.
*/
TEST_F(RadioHidlTest, getCurrentCalls) {
- int serial = 1;
+ int serial = 1;
- radio->getCurrentCalls(serial);
- EXPECT_EQ(std::cv_status::no_timeout, wait());
- EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
- EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+ radio->getCurrentCalls(serial);
+ EXPECT_EQ(std::cv_status::no_timeout, wait());
+ EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+ EXPECT_EQ(serial, radioRsp->rspInfo.serial);
- if (cardStatus.cardState == CardState::ABSENT) {
- ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE);
- }
+ if (cardStatus.cardState == CardState::ABSENT) {
+ ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE);
+ }
}
/*
* Test IRadio.dial() for the response returned.
*/
TEST_F(RadioHidlTest, dial) {
- int serial = 1;
+ int serial = 1;
- Dial dialInfo;
- memset(&dialInfo, 0, sizeof(dialInfo));
- dialInfo.address = hidl_string("123456789");
+ Dial dialInfo;
+ memset(&dialInfo, 0, sizeof(dialInfo));
+ dialInfo.address = hidl_string("123456789");
- radio->dial(serial, dialInfo);
- EXPECT_EQ(std::cv_status::no_timeout, wait());
- EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
- EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+ radio->dial(serial, dialInfo);
+ EXPECT_EQ(std::cv_status::no_timeout, wait());
+ EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+ EXPECT_EQ(serial, radioRsp->rspInfo.serial);
- if (cardStatus.cardState == CardState::ABSENT) {
- ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS
- || radioRsp->rspInfo.error == RadioError::INVALID_STATE
- || radioRsp->rspInfo.error == RadioError::MODEM_ERR
- || radioRsp->rspInfo.error == RadioError::INTERNAL_ERR);
- }
+ if (cardStatus.cardState == CardState::ABSENT) {
+ ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS ||
+ radioRsp->rspInfo.error == RadioError::INVALID_STATE ||
+ radioRsp->rspInfo.error == RadioError::MODEM_ERR ||
+ radioRsp->rspInfo.error == RadioError::INTERNAL_ERR);
+ }
}
/*
* Test IRadio.hangup() for the response returned.
*/
TEST_F(RadioHidlTest, hangup) {
- int serial = 1;
+ int serial = 1;
- radio->hangup(serial, 1);
- EXPECT_EQ(std::cv_status::no_timeout, wait());
- EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
- EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+ radio->hangup(serial, 1);
+ EXPECT_EQ(std::cv_status::no_timeout, wait());
+ EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+ EXPECT_EQ(serial, radioRsp->rspInfo.serial);
- if (cardStatus.cardState == CardState::ABSENT) {
- ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS
- || radioRsp->rspInfo.error == RadioError::INVALID_STATE
- || radioRsp->rspInfo.error == RadioError::MODEM_ERR
- || radioRsp->rspInfo.error == RadioError::INTERNAL_ERR);
- }
+ if (cardStatus.cardState == CardState::ABSENT) {
+ ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS ||
+ radioRsp->rspInfo.error == RadioError::INVALID_STATE ||
+ radioRsp->rspInfo.error == RadioError::MODEM_ERR ||
+ radioRsp->rspInfo.error == RadioError::INTERNAL_ERR);
+ }
}
/*
* Test IRadio.hangupWaitingOrBackground() for the response returned.
*/
TEST_F(RadioHidlTest, hangupWaitingOrBackground) {
- int serial = 1;
+ int serial = 1;
- radio->hangupWaitingOrBackground(serial);
- EXPECT_EQ(std::cv_status::no_timeout, wait());
- EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
- EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+ radio->hangupWaitingOrBackground(serial);
+ EXPECT_EQ(std::cv_status::no_timeout, wait());
+ EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+ EXPECT_EQ(serial, radioRsp->rspInfo.serial);
- if (cardStatus.cardState == CardState::ABSENT) {
- ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::INVALID_STATE
- || radioRsp->rspInfo.error == RadioError::MODEM_ERR
- || radioRsp->rspInfo.error == RadioError::INTERNAL_ERR);
- }
+ if (cardStatus.cardState == CardState::ABSENT) {
+ ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::INVALID_STATE ||
+ radioRsp->rspInfo.error == RadioError::MODEM_ERR ||
+ radioRsp->rspInfo.error == RadioError::INTERNAL_ERR);
+ }
}
/*
* Test IRadio.hangupForegroundResumeBackground() for the response returned.
*/
TEST_F(RadioHidlTest, hangupForegroundResumeBackground) {
- int serial = 1;
+ int serial = 1;
- radio->hangupForegroundResumeBackground(serial);
- EXPECT_EQ(std::cv_status::no_timeout, wait());
- EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
- EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+ radio->hangupForegroundResumeBackground(serial);
+ EXPECT_EQ(std::cv_status::no_timeout, wait());
+ EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+ EXPECT_EQ(serial, radioRsp->rspInfo.serial);
- if (cardStatus.cardState == CardState::ABSENT) {
- ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::INVALID_STATE
- || radioRsp->rspInfo.error == RadioError::MODEM_ERR
- || radioRsp->rspInfo.error == RadioError::INTERNAL_ERR);
- }
+ if (cardStatus.cardState == CardState::ABSENT) {
+ ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::INVALID_STATE ||
+ radioRsp->rspInfo.error == RadioError::MODEM_ERR ||
+ radioRsp->rspInfo.error == RadioError::INTERNAL_ERR);
+ }
}
/*
* Test IRadio.switchWaitingOrHoldingAndActive() for the response returned.
*/
TEST_F(RadioHidlTest, switchWaitingOrHoldingAndActive) {
- int serial = 1;
+ int serial = 1;
- radio->switchWaitingOrHoldingAndActive(serial);
- EXPECT_EQ(std::cv_status::no_timeout, wait());
- EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
- EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+ radio->switchWaitingOrHoldingAndActive(serial);
+ EXPECT_EQ(std::cv_status::no_timeout, wait());
+ EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+ EXPECT_EQ(serial, radioRsp->rspInfo.serial);
- if (cardStatus.cardState == CardState::ABSENT) {
- ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::INVALID_STATE
- || radioRsp->rspInfo.error == RadioError::MODEM_ERR
- || radioRsp->rspInfo.error == RadioError::INTERNAL_ERR);
- }
+ if (cardStatus.cardState == CardState::ABSENT) {
+ ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::INVALID_STATE ||
+ radioRsp->rspInfo.error == RadioError::MODEM_ERR ||
+ radioRsp->rspInfo.error == RadioError::INTERNAL_ERR);
+ }
}
/*
* Test IRadio.conference() for the response returned.
*/
TEST_F(RadioHidlTest, conference) {
- int serial = 1;
+ int serial = 1;
- radio->conference(serial);
- EXPECT_EQ(std::cv_status::no_timeout, wait());
- EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
- EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+ radio->conference(serial);
+ EXPECT_EQ(std::cv_status::no_timeout, wait());
+ EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+ EXPECT_EQ(serial, radioRsp->rspInfo.serial);
- if (cardStatus.cardState == CardState::ABSENT) {
- ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::INVALID_STATE
- || radioRsp->rspInfo.error == RadioError::MODEM_ERR
- || radioRsp->rspInfo.error == RadioError::INTERNAL_ERR);
- }
+ if (cardStatus.cardState == CardState::ABSENT) {
+ ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::INVALID_STATE ||
+ radioRsp->rspInfo.error == RadioError::MODEM_ERR ||
+ radioRsp->rspInfo.error == RadioError::INTERNAL_ERR);
+ }
}
/*
* Test IRadio.rejectCall() for the response returned.
*/
TEST_F(RadioHidlTest, rejectCall) {
- int serial = 1;
+ int serial = 1;
- radio->rejectCall(serial);
- EXPECT_EQ(std::cv_status::no_timeout, wait());
- EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
- EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+ radio->rejectCall(serial);
+ EXPECT_EQ(std::cv_status::no_timeout, wait());
+ EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+ EXPECT_EQ(serial, radioRsp->rspInfo.serial);
- if (cardStatus.cardState == CardState::ABSENT) {
- ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::INVALID_STATE
- || radioRsp->rspInfo.error == RadioError::MODEM_ERR
- || radioRsp->rspInfo.error == RadioError::INTERNAL_ERR);
- }
+ if (cardStatus.cardState == CardState::ABSENT) {
+ ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::INVALID_STATE ||
+ radioRsp->rspInfo.error == RadioError::MODEM_ERR ||
+ radioRsp->rspInfo.error == RadioError::INTERNAL_ERR);
+ }
}
/*
* Test IRadio.getLastCallFailCause() for the response returned.
*/
TEST_F(RadioHidlTest, getLastCallFailCause) {
- int serial = 1;
+ int serial = 1;
- radio->getLastCallFailCause(serial);
- EXPECT_EQ(std::cv_status::no_timeout, wait());
- EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
- EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+ radio->getLastCallFailCause(serial);
+ EXPECT_EQ(std::cv_status::no_timeout, wait());
+ EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+ EXPECT_EQ(serial, radioRsp->rspInfo.serial);
- if (cardStatus.cardState == CardState::ABSENT) {
- ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE);
- }
+ if (cardStatus.cardState == CardState::ABSENT) {
+ ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE);
+ }
}
/*
* Test IRadio.sendUssd() for the response returned.
*/
TEST_F(RadioHidlTest, sendUssd) {
- int serial = 1;
- radio->sendUssd(serial, hidl_string("test"));
- EXPECT_EQ(std::cv_status::no_timeout, wait());
- EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
- EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+ int serial = 1;
+ radio->sendUssd(serial, hidl_string("test"));
+ EXPECT_EQ(std::cv_status::no_timeout, wait());
+ EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+ EXPECT_EQ(serial, radioRsp->rspInfo.serial);
- if (cardStatus.cardState == CardState::ABSENT) {
- ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS
- || radioRsp->rspInfo.error == RadioError::INVALID_STATE
- || radioRsp->rspInfo.error == RadioError::MODEM_ERR
- || radioRsp->rspInfo.error == RadioError::SYSTEM_ERR
- || radioRsp->rspInfo.error == RadioError::INTERNAL_ERR);
- }
+ if (cardStatus.cardState == CardState::ABSENT) {
+ ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS ||
+ radioRsp->rspInfo.error == RadioError::INVALID_STATE ||
+ radioRsp->rspInfo.error == RadioError::MODEM_ERR ||
+ radioRsp->rspInfo.error == RadioError::SYSTEM_ERR ||
+ radioRsp->rspInfo.error == RadioError::INTERNAL_ERR);
+ }
}
/*
* Test IRadio.cancelPendingUssd() for the response returned.
*/
TEST_F(RadioHidlTest, cancelPendingUssd) {
- int serial = 1;
+ int serial = 1;
- radio->cancelPendingUssd(serial);
- EXPECT_EQ(std::cv_status::no_timeout, wait());
- EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
- EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+ radio->cancelPendingUssd(serial);
+ EXPECT_EQ(std::cv_status::no_timeout, wait());
+ EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+ EXPECT_EQ(serial, radioRsp->rspInfo.serial);
- if (cardStatus.cardState == CardState::ABSENT) {
- ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::INVALID_STATE
- || radioRsp->rspInfo.error == RadioError::MODEM_ERR
- || radioRsp->rspInfo.error == RadioError::INTERNAL_ERR);
- }
+ if (cardStatus.cardState == CardState::ABSENT) {
+ ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::INVALID_STATE ||
+ radioRsp->rspInfo.error == RadioError::MODEM_ERR ||
+ radioRsp->rspInfo.error == RadioError::INTERNAL_ERR);
+ }
}
/*
* Test IRadio.getCallForwardStatus() for the response returned.
*/
TEST_F(RadioHidlTest, getCallForwardStatus) {
- int serial = 1;
- CallForwardInfo callInfo;
- memset(&callInfo, 0, sizeof(callInfo));
- callInfo.number = hidl_string();
+ int serial = 1;
+ CallForwardInfo callInfo;
+ memset(&callInfo, 0, sizeof(callInfo));
+ callInfo.number = hidl_string();
- radio->getCallForwardStatus(serial, callInfo);
- EXPECT_EQ(std::cv_status::no_timeout, wait());
- EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
- EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+ radio->getCallForwardStatus(serial, callInfo);
+ EXPECT_EQ(std::cv_status::no_timeout, wait());
+ EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+ EXPECT_EQ(serial, radioRsp->rspInfo.serial);
- if (cardStatus.cardState == CardState::ABSENT) {
- ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS
- || radioRsp->rspInfo.error == RadioError::INVALID_STATE
- || radioRsp->rspInfo.error == RadioError::MODEM_ERR
- || radioRsp->rspInfo.error == RadioError::INTERNAL_ERR);
- }
+ if (cardStatus.cardState == CardState::ABSENT) {
+ ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS ||
+ radioRsp->rspInfo.error == RadioError::INVALID_STATE ||
+ radioRsp->rspInfo.error == RadioError::MODEM_ERR ||
+ radioRsp->rspInfo.error == RadioError::INTERNAL_ERR);
+ }
}
/*
* Test IRadio.setCallForward() for the response returned.
*/
TEST_F(RadioHidlTest, setCallForward) {
- int serial = 1;
- CallForwardInfo callInfo;
- memset(&callInfo, 0, sizeof(callInfo));
- callInfo.number = hidl_string();
+ int serial = 1;
+ CallForwardInfo callInfo;
+ memset(&callInfo, 0, sizeof(callInfo));
+ callInfo.number = hidl_string();
- radio->setCallForward(serial, callInfo);
- EXPECT_EQ(std::cv_status::no_timeout, wait());
- EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
- EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+ radio->setCallForward(serial, callInfo);
+ EXPECT_EQ(std::cv_status::no_timeout, wait());
+ EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+ EXPECT_EQ(serial, radioRsp->rspInfo.serial);
- if (cardStatus.cardState == CardState::ABSENT) {
- ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS
- || radioRsp->rspInfo.error == RadioError::INVALID_STATE
- || radioRsp->rspInfo.error == RadioError::MODEM_ERR
- || radioRsp->rspInfo.error == RadioError::INTERNAL_ERR);
- }
+ if (cardStatus.cardState == CardState::ABSENT) {
+ ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS ||
+ radioRsp->rspInfo.error == RadioError::INVALID_STATE ||
+ radioRsp->rspInfo.error == RadioError::MODEM_ERR ||
+ radioRsp->rspInfo.error == RadioError::INTERNAL_ERR);
+ }
}
/*
* Test IRadio.getCallWaiting() for the response returned.
*/
TEST_F(RadioHidlTest, getCallWaiting) {
- int serial = 1;
+ int serial = 1;
- radio->getCallWaiting(serial, 1);
- EXPECT_EQ(std::cv_status::no_timeout, wait());
- EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
- EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+ radio->getCallWaiting(serial, 1);
+ EXPECT_EQ(std::cv_status::no_timeout, wait());
+ EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+ EXPECT_EQ(serial, radioRsp->rspInfo.serial);
- if (cardStatus.cardState == CardState::ABSENT) {
- ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS
- || radioRsp->rspInfo.error == RadioError::NONE
- || radioRsp->rspInfo.error == RadioError::MODEM_ERR
- || radioRsp->rspInfo.error == RadioError::INTERNAL_ERR);
- }
+ if (cardStatus.cardState == CardState::ABSENT) {
+ ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS ||
+ radioRsp->rspInfo.error == RadioError::NONE ||
+ radioRsp->rspInfo.error == RadioError::MODEM_ERR ||
+ radioRsp->rspInfo.error == RadioError::INTERNAL_ERR);
+ }
}
/*
* Test IRadio.setCallWaiting() for the response returned.
*/
TEST_F(RadioHidlTest, setCallWaiting) {
- int serial = 1;
+ int serial = 1;
- radio->setCallWaiting(serial, true, 1);
- EXPECT_EQ(std::cv_status::no_timeout, wait());
- EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
- EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+ radio->setCallWaiting(serial, true, 1);
+ EXPECT_EQ(std::cv_status::no_timeout, wait());
+ EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+ EXPECT_EQ(serial, radioRsp->rspInfo.serial);
- if (cardStatus.cardState == CardState::ABSENT) {
- ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS
- || radioRsp->rspInfo.error == RadioError::INVALID_STATE
- || radioRsp->rspInfo.error == RadioError::MODEM_ERR
- || radioRsp->rspInfo.error == RadioError::INTERNAL_ERR);
- }
+ if (cardStatus.cardState == CardState::ABSENT) {
+ ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS ||
+ radioRsp->rspInfo.error == RadioError::INVALID_STATE ||
+ radioRsp->rspInfo.error == RadioError::MODEM_ERR ||
+ radioRsp->rspInfo.error == RadioError::INTERNAL_ERR);
+ }
}
/*
* Test IRadio.acceptCall() for the response returned.
*/
TEST_F(RadioHidlTest, acceptCall) {
- int serial = 1;
+ int serial = 1;
- radio->acceptCall(serial);
- EXPECT_EQ(std::cv_status::no_timeout, wait());
- EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
- EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+ radio->acceptCall(serial);
+ EXPECT_EQ(std::cv_status::no_timeout, wait());
+ EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+ EXPECT_EQ(serial, radioRsp->rspInfo.serial);
- if (cardStatus.cardState == CardState::ABSENT) {
- ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::INVALID_STATE
- || radioRsp->rspInfo.error == RadioError::MODEM_ERR
- || radioRsp->rspInfo.error == RadioError::INTERNAL_ERR);
- }
+ if (cardStatus.cardState == CardState::ABSENT) {
+ ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::INVALID_STATE ||
+ radioRsp->rspInfo.error == RadioError::MODEM_ERR ||
+ radioRsp->rspInfo.error == RadioError::INTERNAL_ERR);
+ }
}
/*
* Test IRadio.separateConnection() for the response returned.
*/
TEST_F(RadioHidlTest, separateConnection) {
- int serial = 1;
+ int serial = 1;
- radio->separateConnection(serial, 1);
- EXPECT_EQ(std::cv_status::no_timeout, wait());
- EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
- EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+ radio->separateConnection(serial, 1);
+ EXPECT_EQ(std::cv_status::no_timeout, wait());
+ EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+ EXPECT_EQ(serial, radioRsp->rspInfo.serial);
- if (cardStatus.cardState == CardState::ABSENT) {
- ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS
- || radioRsp->rspInfo.error == RadioError::INVALID_STATE
- || radioRsp->rspInfo.error == RadioError::SYSTEM_ERR
- || radioRsp->rspInfo.error == RadioError::MODEM_ERR
- || radioRsp->rspInfo.error == RadioError::INTERNAL_ERR);
- }
+ if (cardStatus.cardState == CardState::ABSENT) {
+ ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS ||
+ radioRsp->rspInfo.error == RadioError::INVALID_STATE ||
+ radioRsp->rspInfo.error == RadioError::SYSTEM_ERR ||
+ radioRsp->rspInfo.error == RadioError::MODEM_ERR ||
+ radioRsp->rspInfo.error == RadioError::INTERNAL_ERR);
+ }
}
/*
* Test IRadio.explicitCallTransfer() for the response returned.
*/
TEST_F(RadioHidlTest, explicitCallTransfer) {
- int serial = 1;
+ int serial = 1;
- radio->explicitCallTransfer(serial);
- EXPECT_EQ(std::cv_status::no_timeout, wait());
- EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
- EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+ radio->explicitCallTransfer(serial);
+ EXPECT_EQ(std::cv_status::no_timeout, wait());
+ EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+ EXPECT_EQ(serial, radioRsp->rspInfo.serial);
- if (cardStatus.cardState == CardState::ABSENT) {
- ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::INVALID_STATE
- || radioRsp->rspInfo.error == RadioError::MODEM_ERR
- || radioRsp->rspInfo.error == RadioError::INTERNAL_ERR);
- }
+ if (cardStatus.cardState == CardState::ABSENT) {
+ ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::INVALID_STATE ||
+ radioRsp->rspInfo.error == RadioError::MODEM_ERR ||
+ radioRsp->rspInfo.error == RadioError::INTERNAL_ERR);
+ }
}
/*
* Test IRadio.sendCDMAFeatureCode() for the response returned.
*/
TEST_F(RadioHidlTest, sendCDMAFeatureCode) {
- int serial = 1;
+ int serial = 1;
- radio->sendCDMAFeatureCode(serial, hidl_string());
- EXPECT_EQ(std::cv_status::no_timeout, wait());
- EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
- EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+ radio->sendCDMAFeatureCode(serial, hidl_string());
+ EXPECT_EQ(std::cv_status::no_timeout, wait());
+ EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+ EXPECT_EQ(serial, radioRsp->rspInfo.serial);
- if (cardStatus.cardState == CardState::ABSENT) {
- ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS
- || radioRsp->rspInfo.error == RadioError::INVALID_STATE
- || radioRsp->rspInfo.error == RadioError::MODEM_ERR
- || radioRsp->rspInfo.error == RadioError::INTERNAL_ERR
- || radioRsp->rspInfo.error == RadioError::SYSTEM_ERR);
- }
+ if (cardStatus.cardState == CardState::ABSENT) {
+ ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS ||
+ radioRsp->rspInfo.error == RadioError::INVALID_STATE ||
+ radioRsp->rspInfo.error == RadioError::MODEM_ERR ||
+ radioRsp->rspInfo.error == RadioError::INTERNAL_ERR ||
+ radioRsp->rspInfo.error == RadioError::SYSTEM_ERR);
+ }
}
/*
* Test IRadio.sendDtmf() for the response returned.
*/
TEST_F(RadioHidlTest, sendDtmf) {
- int serial = 1;
+ int serial = 1;
- radio->sendDtmf(serial, "1");
- EXPECT_EQ(std::cv_status::no_timeout, wait());
- EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
- EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+ radio->sendDtmf(serial, "1");
+ EXPECT_EQ(std::cv_status::no_timeout, wait());
+ EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+ EXPECT_EQ(serial, radioRsp->rspInfo.serial);
- if (cardStatus.cardState == CardState::ABSENT) {
- ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS
- || radioRsp->rspInfo.error == RadioError::NO_RESOURCES
- || radioRsp->rspInfo.error == RadioError::MODEM_ERR);
- }
+ if (cardStatus.cardState == CardState::ABSENT) {
+ ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS ||
+ radioRsp->rspInfo.error == RadioError::NO_RESOURCES ||
+ radioRsp->rspInfo.error == RadioError::MODEM_ERR);
+ }
}
/*
* Test IRadio.startDtmf() for the response returned.
*/
TEST_F(RadioHidlTest, startDtmf) {
- int serial = 1;
+ int serial = 1;
- radio->startDtmf(serial, "1");
- EXPECT_EQ(std::cv_status::no_timeout, wait());
- EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
- EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+ radio->startDtmf(serial, "1");
+ EXPECT_EQ(std::cv_status::no_timeout, wait());
+ EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+ EXPECT_EQ(serial, radioRsp->rspInfo.serial);
- if (cardStatus.cardState == CardState::ABSENT) {
- ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS
- || radioRsp->rspInfo.error == RadioError::SYSTEM_ERR
- || radioRsp->rspInfo.error == RadioError::MODEM_ERR
- || radioRsp->rspInfo.error == RadioError::INTERNAL_ERR);
- }
+ if (cardStatus.cardState == CardState::ABSENT) {
+ ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS ||
+ radioRsp->rspInfo.error == RadioError::SYSTEM_ERR ||
+ radioRsp->rspInfo.error == RadioError::MODEM_ERR ||
+ radioRsp->rspInfo.error == RadioError::INTERNAL_ERR);
+ }
}
/*
* Test IRadio.stopDtmf() for the response returned.
*/
TEST_F(RadioHidlTest, stopDtmf) {
- int serial = 1;
+ int serial = 1;
- radio->stopDtmf(serial);
- EXPECT_EQ(std::cv_status::no_timeout, wait());
- EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
- EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+ radio->stopDtmf(serial);
+ EXPECT_EQ(std::cv_status::no_timeout, wait());
+ EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+ EXPECT_EQ(serial, radioRsp->rspInfo.serial);
- if (cardStatus.cardState == CardState::ABSENT) {
- ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::SYSTEM_ERR
- || radioRsp->rspInfo.error == RadioError::MODEM_ERR
- || radioRsp->rspInfo.error == RadioError::INTERNAL_ERR);
- }
+ if (cardStatus.cardState == CardState::ABSENT) {
+ ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::SYSTEM_ERR ||
+ radioRsp->rspInfo.error == RadioError::MODEM_ERR ||
+ radioRsp->rspInfo.error == RadioError::INTERNAL_ERR);
+ }
}
/*
* Test IRadio.setMute() for the response returned.
*/
TEST_F(RadioHidlTest, setMute) {
- int serial = 1;
+ int serial = 1;
- radio->setMute(serial, true);
- EXPECT_EQ(std::cv_status::no_timeout, wait());
- EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
- EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+ radio->setMute(serial, true);
+ EXPECT_EQ(std::cv_status::no_timeout, wait());
+ EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+ EXPECT_EQ(serial, radioRsp->rspInfo.serial);
- if (cardStatus.cardState == CardState::ABSENT) {
- ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS
- || radioRsp->rspInfo.error == RadioError::NONE);
- }
+ if (cardStatus.cardState == CardState::ABSENT) {
+ ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS ||
+ radioRsp->rspInfo.error == RadioError::NONE);
+ }
}
/*
* Test IRadio.getMute() for the response returned.
*/
TEST_F(RadioHidlTest, getMute) {
- int serial = 1;
+ int serial = 1;
- radio->getMute(serial);
- EXPECT_EQ(std::cv_status::no_timeout, wait());
- EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
- EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+ radio->getMute(serial);
+ EXPECT_EQ(std::cv_status::no_timeout, wait());
+ EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+ EXPECT_EQ(serial, radioRsp->rspInfo.serial);
- if (cardStatus.cardState == CardState::ABSENT) {
- ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE);
- }
+ if (cardStatus.cardState == CardState::ABSENT) {
+ ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE);
+ }
}
/*
* Test IRadio.sendBurstDtmf() for the response returned.
*/
TEST_F(RadioHidlTest, sendBurstDtmf) {
- int serial = 1;
+ int serial = 1;
- radio->sendBurstDtmf(serial, "1", 0, 0);
- EXPECT_EQ(std::cv_status::no_timeout, wait());
- EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
- EXPECT_EQ(serial, radioRsp->rspInfo.serial);
+ radio->sendBurstDtmf(serial, "1", 0, 0);
+ EXPECT_EQ(std::cv_status::no_timeout, wait());
+ EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
+ EXPECT_EQ(serial, radioRsp->rspInfo.serial);
- if (cardStatus.cardState == CardState::ABSENT) {
- ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS
- || radioRsp->rspInfo.error == RadioError::SYSTEM_ERR
- || radioRsp->rspInfo.error == RadioError::MODEM_ERR
- || radioRsp->rspInfo.error == RadioError::INTERNAL_ERR
- || radioRsp->rspInfo.error == RadioError::INVALID_STATE);
- }
+ if (cardStatus.cardState == CardState::ABSENT) {
+ ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS ||
+ radioRsp->rspInfo.error == RadioError::SYSTEM_ERR ||
+ radioRsp->rspInfo.error == RadioError::MODEM_ERR ||
+ radioRsp->rspInfo.error == RadioError::INTERNAL_ERR ||
+ radioRsp->rspInfo.error == RadioError::INVALID_STATE);
+ }
}
\ No newline at end of file
diff --git a/radio/1.0/vts/functional/radio_response.cpp b/radio/1.0/vts/functional/radio_response.cpp
index c889a18..22c20a5 100644
--- a/radio/1.0/vts/functional/radio_response.cpp
+++ b/radio/1.0/vts/functional/radio_response.cpp
@@ -14,913 +14,959 @@
* limitations under the License.
*/
-#include<radio_hidl_hal_utils.h>
+#include <radio_hidl_hal_utils.h>
CardStatus cardStatus;
-RadioResponse::RadioResponse(RadioHidlTest& parent) : parent(parent) {
-}
+RadioResponse::RadioResponse(RadioHidlTest& parent) : parent(parent) {}
Return<void> RadioResponse::getIccCardStatusResponse(
- const RadioResponseInfo& info, const CardStatus& card_status) {
- rspInfo = info;
- cardStatus = card_status;
- parent.notify();
- return Void();
+ const RadioResponseInfo& info, const CardStatus& card_status) {
+ rspInfo = info;
+ cardStatus = card_status;
+ parent.notify();
+ return Void();
}
Return<void> RadioResponse::supplyIccPinForAppResponse(
- const RadioResponseInfo& info, int32_t /*remainingRetries*/) {
- rspInfo = info;
- parent.notify();
- return Void();
+ const RadioResponseInfo& info, int32_t /*remainingRetries*/) {
+ rspInfo = info;
+ parent.notify();
+ return Void();
}
Return<void> RadioResponse::supplyIccPukForAppResponse(
- const RadioResponseInfo& info, int32_t /*remainingRetries*/) {
- rspInfo = info;
- parent.notify();
- return Void();
+ const RadioResponseInfo& info, int32_t /*remainingRetries*/) {
+ rspInfo = info;
+ parent.notify();
+ return Void();
}
Return<void> RadioResponse::supplyIccPin2ForAppResponse(
- const RadioResponseInfo& info, int32_t /*remainingRetries*/) {
+ const RadioResponseInfo& info, int32_t /*remainingRetries*/) {
rspInfo = info;
parent.notify();
return Void();
}
Return<void> RadioResponse::supplyIccPuk2ForAppResponse(
- const RadioResponseInfo& info, int32_t /*remainingRetries*/) {
- rspInfo = info;
- parent.notify();
- return Void();
+ const RadioResponseInfo& info, int32_t /*remainingRetries*/) {
+ rspInfo = info;
+ parent.notify();
+ return Void();
}
Return<void> RadioResponse::changeIccPinForAppResponse(
- const RadioResponseInfo& info, int32_t /*remainingRetries*/) {
- rspInfo = info;
- parent.notify();
- return Void();
+ const RadioResponseInfo& info, int32_t /*remainingRetries*/) {
+ rspInfo = info;
+ parent.notify();
+ return Void();
}
Return<void> RadioResponse::changeIccPin2ForAppResponse(
- const RadioResponseInfo& info, int32_t /*remainingRetries*/) {
- rspInfo = info;
- parent.notify();
- return Void();
+ const RadioResponseInfo& info, int32_t /*remainingRetries*/) {
+ rspInfo = info;
+ parent.notify();
+ return Void();
}
Return<void> RadioResponse::supplyNetworkDepersonalizationResponse(
- const RadioResponseInfo& info, int32_t /*remainingRetries*/) {
- rspInfo = info;
- parent.notify();
- return Void();
+ const RadioResponseInfo& info, int32_t /*remainingRetries*/) {
+ rspInfo = info;
+ parent.notify();
+ return Void();
}
Return<void> RadioResponse::getCurrentCallsResponse(
- const RadioResponseInfo& info, const ::android::hardware::hidl_vec<Call>& /*calls*/) {
- rspInfo = info;
- parent.notify();
- return Void();
+ const RadioResponseInfo& info,
+ const ::android::hardware::hidl_vec<Call>& /*calls*/) {
+ rspInfo = info;
+ parent.notify();
+ return Void();
}
Return<void> RadioResponse::dialResponse(const RadioResponseInfo& info) {
- rspInfo = info;
- parent.notify();
- return Void();
+ rspInfo = info;
+ parent.notify();
+ return Void();
}
Return<void> RadioResponse::getIMSIForAppResponse(
- const RadioResponseInfo& info, const ::android::hardware::hidl_string& imsi) {
- rspInfo = info;
- this->imsi = imsi;
- parent.notify();
- return Void();
+ const RadioResponseInfo& info,
+ const ::android::hardware::hidl_string& imsi) {
+ rspInfo = info;
+ this->imsi = imsi;
+ parent.notify();
+ return Void();
}
Return<void> RadioResponse::hangupConnectionResponse(
- const RadioResponseInfo& info) {
- rspInfo = info;
- parent.notify();
- return Void();
+ const RadioResponseInfo& info) {
+ rspInfo = info;
+ parent.notify();
+ return Void();
}
Return<void> RadioResponse::hangupWaitingOrBackgroundResponse(
- const RadioResponseInfo& info) {
- rspInfo = info;
- parent.notify();
- return Void();
+ const RadioResponseInfo& info) {
+ rspInfo = info;
+ parent.notify();
+ return Void();
}
Return<void> RadioResponse::hangupForegroundResumeBackgroundResponse(
- const RadioResponseInfo& info) {
- rspInfo = info;
- parent.notify();
- return Void();
+ const RadioResponseInfo& info) {
+ rspInfo = info;
+ parent.notify();
+ return Void();
}
Return<void> RadioResponse::switchWaitingOrHoldingAndActiveResponse(
- const RadioResponseInfo& info) {
- rspInfo = info;
- parent.notify();
- return Void();
+ const RadioResponseInfo& info) {
+ rspInfo = info;
+ parent.notify();
+ return Void();
}
-Return<void> RadioResponse::conferenceResponse(
- const RadioResponseInfo& info) {
- rspInfo = info;
- parent.notify();
- return Void();
+Return<void> RadioResponse::conferenceResponse(const RadioResponseInfo& info) {
+ rspInfo = info;
+ parent.notify();
+ return Void();
}
-Return<void> RadioResponse::rejectCallResponse(
- const RadioResponseInfo& info) {
- rspInfo = info;
- parent.notify();
- return Void();
+Return<void> RadioResponse::rejectCallResponse(const RadioResponseInfo& info) {
+ rspInfo = info;
+ parent.notify();
+ return Void();
}
Return<void> RadioResponse::getLastCallFailCauseResponse(
- const RadioResponseInfo& info, const LastCallFailCauseInfo& /*failCauseInfo*/) {
- rspInfo = info;
- parent.notify();
- return Void();
+ const RadioResponseInfo& info,
+ const LastCallFailCauseInfo& /*failCauseInfo*/) {
+ rspInfo = info;
+ parent.notify();
+ return Void();
}
Return<void> RadioResponse::getSignalStrengthResponse(
- const RadioResponseInfo& info, const SignalStrength& /*sig_strength*/) {
- rspInfo = info;
- parent.notify();
- return Void();
+ const RadioResponseInfo& info, const SignalStrength& /*sig_strength*/) {
+ rspInfo = info;
+ parent.notify();
+ return Void();
}
Return<void> RadioResponse::getVoiceRegistrationStateResponse(
- const RadioResponseInfo& info, const VoiceRegStateResult& /*voiceRegResponse*/) {
- rspInfo = info;
- parent.notify();
- return Void();
+ const RadioResponseInfo& info,
+ const VoiceRegStateResult& /*voiceRegResponse*/) {
+ rspInfo = info;
+ parent.notify();
+ return Void();
}
Return<void> RadioResponse::getDataRegistrationStateResponse(
- const RadioResponseInfo& info, const DataRegStateResult& /*dataRegResponse*/) {
- rspInfo = info;
- parent.notify();
- return Void();
+ const RadioResponseInfo& info,
+ const DataRegStateResult& /*dataRegResponse*/) {
+ rspInfo = info;
+ parent.notify();
+ return Void();
}
Return<void> RadioResponse::getOperatorResponse(
- const RadioResponseInfo& info, const ::android::hardware::hidl_string& /*longName*/,
- const ::android::hardware::hidl_string& /*shortName*/,
- const ::android::hardware::hidl_string& /*numeric*/) {
- rspInfo = info;
- parent.notify();
- return Void();
+ const RadioResponseInfo& info,
+ const ::android::hardware::hidl_string& /*longName*/,
+ const ::android::hardware::hidl_string& /*shortName*/,
+ const ::android::hardware::hidl_string& /*numeric*/) {
+ rspInfo = info;
+ parent.notify();
+ return Void();
}
-Return<void> RadioResponse::setRadioPowerResponse(const RadioResponseInfo& info) {
- rspInfo = info;
- parent.notify();
- return Void();
+Return<void> RadioResponse::setRadioPowerResponse(
+ const RadioResponseInfo& info) {
+ rspInfo = info;
+ parent.notify();
+ return Void();
}
Return<void> RadioResponse::sendDtmfResponse(const RadioResponseInfo& info) {
- rspInfo = info;
- parent.notify();
- return Void();
+ rspInfo = info;
+ parent.notify();
+ return Void();
}
Return<void> RadioResponse::sendSmsResponse(const RadioResponseInfo& info,
- const SendSmsResult& sms) {
- rspInfo = info;
- sendSmsResult = sms;
- parent.notify();
- return Void();
+ const SendSmsResult& sms) {
+ rspInfo = info;
+ sendSmsResult = sms;
+ parent.notify();
+ return Void();
}
Return<void> RadioResponse::sendSMSExpectMoreResponse(
- const RadioResponseInfo& info, const SendSmsResult& sms) {
- rspInfo = info;
- sendSmsResult = sms;
- parent.notify();
- return Void();
+ const RadioResponseInfo& info, const SendSmsResult& sms) {
+ rspInfo = info;
+ sendSmsResult = sms;
+ parent.notify();
+ return Void();
}
Return<void> RadioResponse::setupDataCallResponse(
- const RadioResponseInfo& info, const SetupDataCallResult& /*dcResponse*/) {
- rspInfo = info;
- parent.notify();
- return Void();
+ const RadioResponseInfo& info, const SetupDataCallResult& /*dcResponse*/) {
+ rspInfo = info;
+ parent.notify();
+ return Void();
}
-Return<void> RadioResponse::iccIOForAppResponse(
- const RadioResponseInfo& info, const IccIoResult& iccIo) {
- rspInfo = info;
- this->iccIoResult = iccIo;
- parent.notify();
- return Void();
+Return<void> RadioResponse::iccIOForAppResponse(const RadioResponseInfo& info,
+ const IccIoResult& iccIo) {
+ rspInfo = info;
+ this->iccIoResult = iccIo;
+ parent.notify();
+ return Void();
}
Return<void> RadioResponse::sendUssdResponse(const RadioResponseInfo& info) {
- rspInfo = info;
- parent.notify();
- return Void();
+ rspInfo = info;
+ parent.notify();
+ return Void();
}
-Return<void> RadioResponse::cancelPendingUssdResponse(const RadioResponseInfo& info) {
- rspInfo = info;
- parent.notify();
- return Void();
+Return<void> RadioResponse::cancelPendingUssdResponse(
+ const RadioResponseInfo& info) {
+ rspInfo = info;
+ parent.notify();
+ return Void();
}
-Return<void> RadioResponse::getClirResponse(const RadioResponseInfo& info, int32_t /*n*/,
- int32_t /*m*/) {
- rspInfo = info;
- parent.notify();
- return Void();
+Return<void> RadioResponse::getClirResponse(const RadioResponseInfo& info,
+ int32_t /*n*/, int32_t /*m*/) {
+ rspInfo = info;
+ parent.notify();
+ return Void();
}
Return<void> RadioResponse::setClirResponse(const RadioResponseInfo& info) {
- rspInfo = info;
- parent.notify();
- return Void();
+ rspInfo = info;
+ parent.notify();
+ return Void();
}
Return<void> RadioResponse::getCallForwardStatusResponse(
- const RadioResponseInfo& info, const ::android::hardware::hidl_vec<CallForwardInfo>&
- /*callForwardInfos*/) {
- rspInfo = info;
- parent.notify();
- return Void();
+ const RadioResponseInfo& info,
+ const ::android::hardware::hidl_vec<CallForwardInfo>&
+ /*callForwardInfos*/) {
+ rspInfo = info;
+ parent.notify();
+ return Void();
}
-Return<void> RadioResponse::setCallForwardResponse(const RadioResponseInfo& info) {
- rspInfo = info;
- parent.notify();
- return Void();
+Return<void> RadioResponse::setCallForwardResponse(
+ const RadioResponseInfo& info) {
+ rspInfo = info;
+ parent.notify();
+ return Void();
}
Return<void> RadioResponse::getCallWaitingResponse(
- const RadioResponseInfo& info, bool /*enable*/, int32_t /*serviceClass*/) {
- rspInfo = info;
- parent.notify();
- return Void();
+ const RadioResponseInfo& info, bool /*enable*/, int32_t /*serviceClass*/) {
+ rspInfo = info;
+ parent.notify();
+ return Void();
}
-Return<void> RadioResponse::setCallWaitingResponse(const RadioResponseInfo& info) {
- rspInfo = info;
- parent.notify();
- return Void();
+Return<void> RadioResponse::setCallWaitingResponse(
+ const RadioResponseInfo& info) {
+ rspInfo = info;
+ parent.notify();
+ return Void();
}
-Return<void> RadioResponse::acknowledgeLastIncomingGsmSmsResponse(const RadioResponseInfo& info) {
- rspInfo = info;
- parent.notify();
- return Void();
+Return<void> RadioResponse::acknowledgeLastIncomingGsmSmsResponse(
+ const RadioResponseInfo& info) {
+ rspInfo = info;
+ parent.notify();
+ return Void();
}
Return<void> RadioResponse::acceptCallResponse(const RadioResponseInfo& info) {
- rspInfo = info;
- parent.notify();
- return Void();
+ rspInfo = info;
+ parent.notify();
+ return Void();
}
-Return<void> RadioResponse::deactivateDataCallResponse(const RadioResponseInfo& info) {
- rspInfo = info;
- parent.notify();
- return Void();
+Return<void> RadioResponse::deactivateDataCallResponse(
+ const RadioResponseInfo& info) {
+ rspInfo = info;
+ parent.notify();
+ return Void();
}
-Return<void> RadioResponse::getFacilityLockForAppResponse(const RadioResponseInfo& info,
- int32_t /*response*/) {
- rspInfo = info;
- parent.notify();
- return Void();
+Return<void> RadioResponse::getFacilityLockForAppResponse(
+ const RadioResponseInfo& info, int32_t /*response*/) {
+ rspInfo = info;
+ parent.notify();
+ return Void();
}
-Return<void> RadioResponse::setFacilityLockForAppResponse(const RadioResponseInfo& info,
- int32_t /*retry*/) {
- rspInfo = info;
- parent.notify();
- return Void();
+Return<void> RadioResponse::setFacilityLockForAppResponse(
+ const RadioResponseInfo& info, int32_t /*retry*/) {
+ rspInfo = info;
+ parent.notify();
+ return Void();
}
-Return<void> RadioResponse::setBarringPasswordResponse(const RadioResponseInfo& info) {
- rspInfo = info;
- parent.notify();
- return Void();
+Return<void> RadioResponse::setBarringPasswordResponse(
+ const RadioResponseInfo& info) {
+ rspInfo = info;
+ parent.notify();
+ return Void();
}
Return<void> RadioResponse::getNetworkSelectionModeResponse(
- const RadioResponseInfo& info, bool /*manual*/) {
- rspInfo = info;
- parent.notify();
- return Void();
+ const RadioResponseInfo& info, bool /*manual*/) {
+ rspInfo = info;
+ parent.notify();
+ return Void();
}
Return<void> RadioResponse::setNetworkSelectionModeAutomaticResponse(
- const RadioResponseInfo& info) {
- rspInfo = info;
- parent.notify();
- return Void();
+ const RadioResponseInfo& info) {
+ rspInfo = info;
+ parent.notify();
+ return Void();
}
Return<void> RadioResponse::setNetworkSelectionModeManualResponse(
- const RadioResponseInfo& info) {
- rspInfo = info;
- parent.notify();
- return Void();
+ const RadioResponseInfo& info) {
+ rspInfo = info;
+ parent.notify();
+ return Void();
}
Return<void> RadioResponse::getAvailableNetworksResponse(
- const RadioResponseInfo& info,
- const ::android::hardware::hidl_vec<OperatorInfo>& /*networkInfos*/) {
- rspInfo = info;
- parent.notify();
- return Void();
+ const RadioResponseInfo& info,
+ const ::android::hardware::hidl_vec<OperatorInfo>& /*networkInfos*/) {
+ rspInfo = info;
+ parent.notify();
+ return Void();
}
-Return<void> RadioResponse::startDtmfResponse(
- const RadioResponseInfo& info) {
- rspInfo = info;
- parent.notify();
- return Void();
+Return<void> RadioResponse::startDtmfResponse(const RadioResponseInfo& info) {
+ rspInfo = info;
+ parent.notify();
+ return Void();
}
-Return<void> RadioResponse::stopDtmfResponse(
- const RadioResponseInfo& info) {
- rspInfo = info;
- parent.notify();
- return Void();
+Return<void> RadioResponse::stopDtmfResponse(const RadioResponseInfo& info) {
+ rspInfo = info;
+ parent.notify();
+ return Void();
}
Return<void> RadioResponse::getBasebandVersionResponse(
- const RadioResponseInfo& info, const ::android::hardware::hidl_string& /*version*/) {
- rspInfo = info;
- parent.notify();
- return Void();
+ const RadioResponseInfo& info,
+ const ::android::hardware::hidl_string& /*version*/) {
+ rspInfo = info;
+ parent.notify();
+ return Void();
}
-Return<void> RadioResponse::separateConnectionResponse(const RadioResponseInfo& info) {
- rspInfo = info;
- parent.notify();
- return Void();
+Return<void> RadioResponse::separateConnectionResponse(
+ const RadioResponseInfo& info) {
+ rspInfo = info;
+ parent.notify();
+ return Void();
}
Return<void> RadioResponse::setMuteResponse(const RadioResponseInfo& info) {
- rspInfo = info;
- parent.notify();
- return Void();
+ rspInfo = info;
+ parent.notify();
+ return Void();
}
-Return<void> RadioResponse::getMuteResponse(const RadioResponseInfo& info, bool /*enable*/) {
- rspInfo = info;
- parent.notify();
- return Void();
+Return<void> RadioResponse::getMuteResponse(const RadioResponseInfo& info,
+ bool /*enable*/) {
+ rspInfo = info;
+ parent.notify();
+ return Void();
}
Return<void> RadioResponse::getClipResponse(const RadioResponseInfo& info,
- ClipStatus /*status*/) {
- rspInfo = info;
- parent.notify();
- return Void();
+ ClipStatus /*status*/) {
+ rspInfo = info;
+ parent.notify();
+ return Void();
}
Return<void> RadioResponse::getDataCallListResponse(
- const RadioResponseInfo& info,
- const ::android::hardware::hidl_vec<SetupDataCallResult>& /*dcResponse*/) {
- rspInfo = info;
- parent.notify();
- return Void();
+ const RadioResponseInfo& info,
+ const ::android::hardware::hidl_vec<SetupDataCallResult>& /*dcResponse*/) {
+ rspInfo = info;
+ parent.notify();
+ return Void();
}
Return<void> RadioResponse::sendOemRilRequestRawResponse(
- const RadioResponseInfo& /*info*/,
- const ::android::hardware::hidl_vec<uint8_t>& /*data*/) {
- return Void();
+ const RadioResponseInfo& /*info*/,
+ const ::android::hardware::hidl_vec<uint8_t>& /*data*/) {
+ return Void();
}
Return<void> RadioResponse::sendOemRilRequestStringsResponse(
- const RadioResponseInfo& /*info*/,
- const ::android::hardware::hidl_vec<::android::hardware::hidl_string>& /*data*/) {
- return Void();
+ const RadioResponseInfo& /*info*/,
+ const ::android::hardware::hidl_vec<
+ ::android::hardware::hidl_string>& /*data*/) {
+ return Void();
}
Return<void> RadioResponse::setSuppServiceNotificationsResponse(
- const RadioResponseInfo& info) {
- rspInfo = info;
- parent.notify();
- return Void();
+ const RadioResponseInfo& info) {
+ rspInfo = info;
+ parent.notify();
+ return Void();
}
-Return<void> RadioResponse::writeSmsToSimResponse(
- const RadioResponseInfo& info, int32_t index) {
- rspInfo = info;
- writeSmsToSimIndex = index;
- parent.notify();
- return Void();
+Return<void> RadioResponse::writeSmsToSimResponse(const RadioResponseInfo& info,
+ int32_t index) {
+ rspInfo = info;
+ writeSmsToSimIndex = index;
+ parent.notify();
+ return Void();
}
Return<void> RadioResponse::deleteSmsOnSimResponse(
- const RadioResponseInfo& info) {
- rspInfo = info;
- parent.notify();
- return Void();
+ const RadioResponseInfo& info) {
+ rspInfo = info;
+ parent.notify();
+ return Void();
}
Return<void> RadioResponse::setBandModeResponse(const RadioResponseInfo& info) {
- rspInfo = info;
- parent.notify();
- return Void();
+ rspInfo = info;
+ parent.notify();
+ return Void();
}
Return<void> RadioResponse::getAvailableBandModesResponse(
- const RadioResponseInfo& info,
- const ::android::hardware::hidl_vec<RadioBandMode>& /*bandModes*/) {
- rspInfo = info;
- parent.notify();
- return Void();
+ const RadioResponseInfo& info,
+ const ::android::hardware::hidl_vec<RadioBandMode>& /*bandModes*/) {
+ rspInfo = info;
+ parent.notify();
+ return Void();
}
-Return<void> RadioResponse::sendEnvelopeResponse(const RadioResponseInfo& info,
- const ::android::hardware::hidl_string& /*commandResponse*/) {
- rspInfo = info;
- parent.notify();
- return Void();
+Return<void> RadioResponse::sendEnvelopeResponse(
+ const RadioResponseInfo& info,
+ const ::android::hardware::hidl_string& /*commandResponse*/) {
+ rspInfo = info;
+ parent.notify();
+ return Void();
}
-Return<void> RadioResponse::sendTerminalResponseToSimResponse(const RadioResponseInfo& info) {
- rspInfo = info;
- parent.notify();
- return Void();
+Return<void> RadioResponse::sendTerminalResponseToSimResponse(
+ const RadioResponseInfo& info) {
+ rspInfo = info;
+ parent.notify();
+ return Void();
}
Return<void> RadioResponse::handleStkCallSetupRequestFromSimResponse(
- const RadioResponseInfo& info) {
- rspInfo = info;
- parent.notify();
- return Void();
+ const RadioResponseInfo& info) {
+ rspInfo = info;
+ parent.notify();
+ return Void();
}
-Return<void> RadioResponse::explicitCallTransferResponse(const RadioResponseInfo& info) {
- rspInfo = info;
- parent.notify();
- return Void();
+Return<void> RadioResponse::explicitCallTransferResponse(
+ const RadioResponseInfo& info) {
+ rspInfo = info;
+ parent.notify();
+ return Void();
}
-Return<void> RadioResponse::setPreferredNetworkTypeResponse(const RadioResponseInfo& info) {
- rspInfo = info;
- parent.notify();
- return Void();
+Return<void> RadioResponse::setPreferredNetworkTypeResponse(
+ const RadioResponseInfo& info) {
+ rspInfo = info;
+ parent.notify();
+ return Void();
}
Return<void> RadioResponse::getPreferredNetworkTypeResponse(
- const RadioResponseInfo& info, PreferredNetworkType /*nw_type*/) {
- rspInfo = info;
- parent.notify();
- return Void();
+ const RadioResponseInfo& info, PreferredNetworkType /*nw_type*/) {
+ rspInfo = info;
+ parent.notify();
+ return Void();
}
Return<void> RadioResponse::getNeighboringCidsResponse(
- const RadioResponseInfo& info,
- const ::android::hardware::hidl_vec<NeighboringCell>& /*cells*/) {
- rspInfo = info;
- parent.notify();
- return Void();
+ const RadioResponseInfo& info,
+ const ::android::hardware::hidl_vec<NeighboringCell>& /*cells*/) {
+ rspInfo = info;
+ parent.notify();
+ return Void();
}
Return<void> RadioResponse::setLocationUpdatesResponse(
- const RadioResponseInfo& info) {
- rspInfo = info;
- parent.notify();
- return Void();
+ const RadioResponseInfo& info) {
+ rspInfo = info;
+ parent.notify();
+ return Void();
}
-Return<void> RadioResponse::setCdmaSubscriptionSourceResponse(const RadioResponseInfo& info) {
- rspInfo = info;
- parent.notify();
- return Void();
+Return<void> RadioResponse::setCdmaSubscriptionSourceResponse(
+ const RadioResponseInfo& info) {
+ rspInfo = info;
+ parent.notify();
+ return Void();
}
-Return<void> RadioResponse::setCdmaRoamingPreferenceResponse(const RadioResponseInfo& info) {
- rspInfo = info;
- parent.notify();
- return Void();
+Return<void> RadioResponse::setCdmaRoamingPreferenceResponse(
+ const RadioResponseInfo& info) {
+ rspInfo = info;
+ parent.notify();
+ return Void();
}
Return<void> RadioResponse::getCdmaRoamingPreferenceResponse(
- const RadioResponseInfo& info, CdmaRoamingType /*type*/) {
- rspInfo = info;
- parent.notify();
- return Void();
+ const RadioResponseInfo& info, CdmaRoamingType /*type*/) {
+ rspInfo = info;
+ parent.notify();
+ return Void();
}
Return<void> RadioResponse::setTTYModeResponse(const RadioResponseInfo& info) {
- rspInfo = info;
- parent.notify();
- return Void();
+ rspInfo = info;
+ parent.notify();
+ return Void();
}
Return<void> RadioResponse::getTTYModeResponse(const RadioResponseInfo& info,
- TtyMode /*mode*/) {
- rspInfo = info;
- parent.notify();
- return Void();
+ TtyMode /*mode*/) {
+ rspInfo = info;
+ parent.notify();
+ return Void();
}
-Return<void> RadioResponse::setPreferredVoicePrivacyResponse(const RadioResponseInfo& info) {
- rspInfo = info;
- parent.notify();
- return Void();
+Return<void> RadioResponse::setPreferredVoicePrivacyResponse(
+ const RadioResponseInfo& info) {
+ rspInfo = info;
+ parent.notify();
+ return Void();
}
Return<void> RadioResponse::getPreferredVoicePrivacyResponse(
- const RadioResponseInfo& info, bool /*enable*/) {
- rspInfo = info;
- parent.notify();
- return Void();
+ const RadioResponseInfo& info, bool /*enable*/) {
+ rspInfo = info;
+ parent.notify();
+ return Void();
}
-Return<void> RadioResponse::sendCDMAFeatureCodeResponse(const RadioResponseInfo& info) {
- rspInfo = info;
- parent.notify();
- return Void();
+Return<void> RadioResponse::sendCDMAFeatureCodeResponse(
+ const RadioResponseInfo& info) {
+ rspInfo = info;
+ parent.notify();
+ return Void();
}
-Return<void> RadioResponse::sendBurstDtmfResponse(const RadioResponseInfo& info) {
- rspInfo = info;
- parent.notify();
- return Void();
+Return<void> RadioResponse::sendBurstDtmfResponse(
+ const RadioResponseInfo& info) {
+ rspInfo = info;
+ parent.notify();
+ return Void();
}
-Return<void> RadioResponse::sendCdmaSmsResponse(
- const RadioResponseInfo& info, const SendSmsResult& sms) {
- rspInfo = info;
- sendSmsResult = sms;
- parent.notify();
- return Void();
+Return<void> RadioResponse::sendCdmaSmsResponse(const RadioResponseInfo& info,
+ const SendSmsResult& sms) {
+ rspInfo = info;
+ sendSmsResult = sms;
+ parent.notify();
+ return Void();
}
Return<void> RadioResponse::acknowledgeLastIncomingCdmaSmsResponse(
- const RadioResponseInfo& info) {
- rspInfo = info;
- parent.notify();
- return Void();
+ const RadioResponseInfo& info) {
+ rspInfo = info;
+ parent.notify();
+ return Void();
}
Return<void> RadioResponse::getGsmBroadcastConfigResponse(
- const RadioResponseInfo& info,
- const ::android::hardware::hidl_vec<GsmBroadcastSmsConfigInfo>& /*configs*/) {
- rspInfo = info;
- parent.notify();
- return Void();
+ const RadioResponseInfo& info,
+ const ::android::hardware::hidl_vec<
+ GsmBroadcastSmsConfigInfo>& /*configs*/) {
+ rspInfo = info;
+ parent.notify();
+ return Void();
}
-Return<void> RadioResponse::setGsmBroadcastConfigResponse(const RadioResponseInfo& info) {
- rspInfo = info;
- parent.notify();
- return Void();
+Return<void> RadioResponse::setGsmBroadcastConfigResponse(
+ const RadioResponseInfo& info) {
+ rspInfo = info;
+ parent.notify();
+ return Void();
}
-Return<void> RadioResponse::setGsmBroadcastActivationResponse(const RadioResponseInfo& info) {
- rspInfo = info;
- parent.notify();
- return Void();
+Return<void> RadioResponse::setGsmBroadcastActivationResponse(
+ const RadioResponseInfo& info) {
+ rspInfo = info;
+ parent.notify();
+ return Void();
}
Return<void> RadioResponse::getCdmaBroadcastConfigResponse(
- const RadioResponseInfo& info,
- const ::android::hardware::hidl_vec<CdmaBroadcastSmsConfigInfo>& /*configs*/) {
- rspInfo = info;
- parent.notify();
- return Void();
+ const RadioResponseInfo& info,
+ const ::android::hardware::hidl_vec<
+ CdmaBroadcastSmsConfigInfo>& /*configs*/) {
+ rspInfo = info;
+ parent.notify();
+ return Void();
}
-Return<void> RadioResponse::setCdmaBroadcastConfigResponse(const RadioResponseInfo& info) {
- rspInfo = info;
- parent.notify();
- return Void();
+Return<void> RadioResponse::setCdmaBroadcastConfigResponse(
+ const RadioResponseInfo& info) {
+ rspInfo = info;
+ parent.notify();
+ return Void();
}
-Return<void> RadioResponse::setCdmaBroadcastActivationResponse(const RadioResponseInfo& info) {
- rspInfo = info;
- parent.notify();
- return Void();
+Return<void> RadioResponse::setCdmaBroadcastActivationResponse(
+ const RadioResponseInfo& info) {
+ rspInfo = info;
+ parent.notify();
+ return Void();
}
Return<void> RadioResponse::getCDMASubscriptionResponse(
- const RadioResponseInfo& info, const ::android::hardware::hidl_string& /*mdn*/,
- const ::android::hardware::hidl_string& /*hSid*/,
- const ::android::hardware::hidl_string& /*hNid*/,
- const ::android::hardware::hidl_string& /*min*/,
- const ::android::hardware::hidl_string& /*prl*/) {
- rspInfo = info;
- parent.notify();
- return Void();
+ const RadioResponseInfo& info,
+ const ::android::hardware::hidl_string& /*mdn*/,
+ const ::android::hardware::hidl_string& /*hSid*/,
+ const ::android::hardware::hidl_string& /*hNid*/,
+ const ::android::hardware::hidl_string& /*min*/,
+ const ::android::hardware::hidl_string& /*prl*/) {
+ rspInfo = info;
+ parent.notify();
+ return Void();
}
Return<void> RadioResponse::writeSmsToRuimResponse(
- const RadioResponseInfo& info, uint32_t index) {
- rspInfo = info;
- writeSmsToRuimIndex = index;
- parent.notify();
- return Void();
+ const RadioResponseInfo& info, uint32_t index) {
+ rspInfo = info;
+ writeSmsToRuimIndex = index;
+ parent.notify();
+ return Void();
}
Return<void> RadioResponse::deleteSmsOnRuimResponse(
- const RadioResponseInfo& info) {
- rspInfo = info;
- parent.notify();
- return Void();
+ const RadioResponseInfo& info) {
+ rspInfo = info;
+ parent.notify();
+ return Void();
}
Return<void> RadioResponse::getDeviceIdentityResponse(
- const RadioResponseInfo& info, const ::android::hardware::hidl_string& /*imei*/,
- const ::android::hardware::hidl_string& /*imeisv*/,
- const ::android::hardware::hidl_string& /*esn*/,
- const ::android::hardware::hidl_string& /*meid*/) {
- rspInfo = info;
- parent.notify();
- return Void();
+ const RadioResponseInfo& info,
+ const ::android::hardware::hidl_string& /*imei*/,
+ const ::android::hardware::hidl_string& /*imeisv*/,
+ const ::android::hardware::hidl_string& /*esn*/,
+ const ::android::hardware::hidl_string& /*meid*/) {
+ rspInfo = info;
+ parent.notify();
+ return Void();
}
-Return<void> RadioResponse::exitEmergencyCallbackModeResponse(const RadioResponseInfo& info) {
- rspInfo = info;
- parent.notify();
- return Void();
+Return<void> RadioResponse::exitEmergencyCallbackModeResponse(
+ const RadioResponseInfo& info) {
+ rspInfo = info;
+ parent.notify();
+ return Void();
}
Return<void> RadioResponse::getSmscAddressResponse(
- const RadioResponseInfo& info, const ::android::hardware::hidl_string& smsc) {
- rspInfo = info;
- smscAddress = smsc;
- parent.notify();
- return Void();
+ const RadioResponseInfo& info,
+ const ::android::hardware::hidl_string& smsc) {
+ rspInfo = info;
+ smscAddress = smsc;
+ parent.notify();
+ return Void();
}
-Return<void> RadioResponse::setSmscAddressResponse(const RadioResponseInfo& info) {
- rspInfo = info;
- parent.notify();
- return Void();
+Return<void> RadioResponse::setSmscAddressResponse(
+ const RadioResponseInfo& info) {
+ rspInfo = info;
+ parent.notify();
+ return Void();
}
-Return<void> RadioResponse::reportSmsMemoryStatusResponse(const RadioResponseInfo& info) {
- rspInfo = info;
- parent.notify();
- return Void();
+Return<void> RadioResponse::reportSmsMemoryStatusResponse(
+ const RadioResponseInfo& info) {
+ rspInfo = info;
+ parent.notify();
+ return Void();
}
-Return<void> RadioResponse::reportStkServiceIsRunningResponse(const RadioResponseInfo& info) {
- rspInfo = info;
- parent.notify();
- return Void();
+Return<void> RadioResponse::reportStkServiceIsRunningResponse(
+ const RadioResponseInfo& info) {
+ rspInfo = info;
+ parent.notify();
+ return Void();
}
Return<void> RadioResponse::getCdmaSubscriptionSourceResponse(
- const RadioResponseInfo& info, CdmaSubscriptionSource /*source*/) {
- rspInfo = info;
- parent.notify();
- return Void();
+ const RadioResponseInfo& info, CdmaSubscriptionSource /*source*/) {
+ rspInfo = info;
+ parent.notify();
+ return Void();
}
Return<void> RadioResponse::requestIsimAuthenticationResponse(
- const RadioResponseInfo& info, const ::android::hardware::hidl_string& /*response*/) {
- rspInfo = info;
- parent.notify();
- return Void();
+ const RadioResponseInfo& info,
+ const ::android::hardware::hidl_string& /*response*/) {
+ rspInfo = info;
+ parent.notify();
+ return Void();
}
Return<void> RadioResponse::acknowledgeIncomingGsmSmsWithPduResponse(
- const RadioResponseInfo& info) {
- rspInfo = info;
- parent.notify();
- return Void();
+ const RadioResponseInfo& info) {
+ rspInfo = info;
+ parent.notify();
+ return Void();
}
Return<void> RadioResponse::sendEnvelopeWithStatusResponse(
- const RadioResponseInfo& info, const IccIoResult& /*iccIo*/) {
- rspInfo = info;
- parent.notify();
- return Void();
+ const RadioResponseInfo& info, const IccIoResult& /*iccIo*/) {
+ rspInfo = info;
+ parent.notify();
+ return Void();
}
Return<void> RadioResponse::getVoiceRadioTechnologyResponse(
- const RadioResponseInfo& info, RadioTechnology /*rat*/) {
- rspInfo = info;
- parent.notify();
- return Void();
+ const RadioResponseInfo& info, RadioTechnology /*rat*/) {
+ rspInfo = info;
+ parent.notify();
+ return Void();
}
Return<void> RadioResponse::getCellInfoListResponse(
- const RadioResponseInfo& info,
- const ::android::hardware::hidl_vec<CellInfo>& /*cellInfo*/) {
- rspInfo = info;
- parent.notify();
- return Void();
+ const RadioResponseInfo& info,
+ const ::android::hardware::hidl_vec<CellInfo>& /*cellInfo*/) {
+ rspInfo = info;
+ parent.notify();
+ return Void();
}
-Return<void> RadioResponse::setCellInfoListRateResponse(const RadioResponseInfo& info) {
- rspInfo = info;
- parent.notify();
- return Void();
+Return<void> RadioResponse::setCellInfoListRateResponse(
+ const RadioResponseInfo& info) {
+ rspInfo = info;
+ parent.notify();
+ return Void();
}
-Return<void> RadioResponse::setInitialAttachApnResponse(const RadioResponseInfo& info) {
- rspInfo = info;
- parent.notify();
- return Void();
+Return<void> RadioResponse::setInitialAttachApnResponse(
+ const RadioResponseInfo& info) {
+ rspInfo = info;
+ parent.notify();
+ return Void();
}
Return<void> RadioResponse::getImsRegistrationStateResponse(
- const RadioResponseInfo& info, bool /*isRegistered*/,
- RadioTechnologyFamily /*ratFamily*/) {
- rspInfo = info;
- parent.notify();
- return Void();
+ const RadioResponseInfo& info, bool /*isRegistered*/,
+ RadioTechnologyFamily /*ratFamily*/) {
+ rspInfo = info;
+ parent.notify();
+ return Void();
}
-Return<void> RadioResponse::sendImsSmsResponse(
- const RadioResponseInfo& info, const SendSmsResult& sms) {
- rspInfo = info;
- sendSmsResult = sms;
- parent.notify();
- return Void();
+Return<void> RadioResponse::sendImsSmsResponse(const RadioResponseInfo& info,
+ const SendSmsResult& sms) {
+ rspInfo = info;
+ sendSmsResult = sms;
+ parent.notify();
+ return Void();
}
Return<void> RadioResponse::iccTransmitApduBasicChannelResponse(
- const RadioResponseInfo& info, const IccIoResult& result) {
- rspInfo = info;
- this->iccIoResult = result;
- parent.notify();
- return Void();
+ const RadioResponseInfo& info, const IccIoResult& result) {
+ rspInfo = info;
+ this->iccIoResult = result;
+ parent.notify();
+ return Void();
}
Return<void> RadioResponse::iccOpenLogicalChannelResponse(
- const RadioResponseInfo& info, int32_t channelId,
- const ::android::hardware::hidl_vec<int8_t>& /*selectResponse*/) {
- rspInfo = info;
- this->channelId = channelId;
- parent.notify();
- return Void();
+ const RadioResponseInfo& info, int32_t channelId,
+ const ::android::hardware::hidl_vec<int8_t>& /*selectResponse*/) {
+ rspInfo = info;
+ this->channelId = channelId;
+ parent.notify();
+ return Void();
}
-Return<void> RadioResponse::iccCloseLogicalChannelResponse(const RadioResponseInfo& info) {
- rspInfo = info;
- parent.notify();
- return Void();
+Return<void> RadioResponse::iccCloseLogicalChannelResponse(
+ const RadioResponseInfo& info) {
+ rspInfo = info;
+ parent.notify();
+ return Void();
}
Return<void> RadioResponse::iccTransmitApduLogicalChannelResponse(
- const RadioResponseInfo& info, const IccIoResult& result) {
- rspInfo = info;
- this->iccIoResult = result;
- parent.notify();
- return Void();
+ const RadioResponseInfo& info, const IccIoResult& result) {
+ rspInfo = info;
+ this->iccIoResult = result;
+ parent.notify();
+ return Void();
}
Return<void> RadioResponse::nvReadItemResponse(
- const RadioResponseInfo& info, const ::android::hardware::hidl_string& /*result*/) {
- rspInfo = info;
- parent.notify();
- return Void();
+ const RadioResponseInfo& info,
+ const ::android::hardware::hidl_string& /*result*/) {
+ rspInfo = info;
+ parent.notify();
+ return Void();
}
Return<void> RadioResponse::nvWriteItemResponse(const RadioResponseInfo& info) {
- rspInfo = info;
- parent.notify();
- return Void();
+ rspInfo = info;
+ parent.notify();
+ return Void();
}
-Return<void> RadioResponse::nvWriteCdmaPrlResponse(const RadioResponseInfo& info) {
- rspInfo = info;
- parent.notify();
- return Void();
+Return<void> RadioResponse::nvWriteCdmaPrlResponse(
+ const RadioResponseInfo& info) {
+ rspInfo = info;
+ parent.notify();
+ return Void();
}
-Return<void> RadioResponse::nvResetConfigResponse(const RadioResponseInfo& info) {
- rspInfo = info;
- parent.notify();
- return Void();
+Return<void> RadioResponse::nvResetConfigResponse(
+ const RadioResponseInfo& info) {
+ rspInfo = info;
+ parent.notify();
+ return Void();
}
-Return<void> RadioResponse::setUiccSubscriptionResponse(const RadioResponseInfo& info) {
- rspInfo = info;
- parent.notify();
- return Void();
+Return<void> RadioResponse::setUiccSubscriptionResponse(
+ const RadioResponseInfo& info) {
+ rspInfo = info;
+ parent.notify();
+ return Void();
}
-Return<void> RadioResponse::setDataAllowedResponse(const RadioResponseInfo& info) {
- rspInfo = info;
- parent.notify();
- return Void();
+Return<void> RadioResponse::setDataAllowedResponse(
+ const RadioResponseInfo& info) {
+ rspInfo = info;
+ parent.notify();
+ return Void();
}
Return<void> RadioResponse::getHardwareConfigResponse(
- const RadioResponseInfo& info,
- const ::android::hardware::hidl_vec<HardwareConfig>& /*config*/) {
- rspInfo = info;
- parent.notify();
- return Void();
+ const RadioResponseInfo& info,
+ const ::android::hardware::hidl_vec<HardwareConfig>& /*config*/) {
+ rspInfo = info;
+ parent.notify();
+ return Void();
}
Return<void> RadioResponse::requestIccSimAuthenticationResponse(
- const RadioResponseInfo& info, const IccIoResult& result) {
- rspInfo = info;
- this->iccIoResult = result;
- parent.notify();
- return Void();
+ const RadioResponseInfo& info, const IccIoResult& result) {
+ rspInfo = info;
+ this->iccIoResult = result;
+ parent.notify();
+ return Void();
}
-Return<void> RadioResponse::setDataProfileResponse(const RadioResponseInfo& info) {
- rspInfo = info;
- parent.notify();
- return Void();
+Return<void> RadioResponse::setDataProfileResponse(
+ const RadioResponseInfo& info) {
+ rspInfo = info;
+ parent.notify();
+ return Void();
}
-Return<void> RadioResponse::requestShutdownResponse(const RadioResponseInfo& info) {
- rspInfo = info;
- parent.notify();
- return Void();
+Return<void> RadioResponse::requestShutdownResponse(
+ const RadioResponseInfo& info) {
+ rspInfo = info;
+ parent.notify();
+ return Void();
}
Return<void> RadioResponse::getRadioCapabilityResponse(
- const RadioResponseInfo& info, const RadioCapability& /*rc*/) {
- rspInfo = info;
- parent.notify();
- return Void();
+ const RadioResponseInfo& info, const RadioCapability& /*rc*/) {
+ rspInfo = info;
+ parent.notify();
+ return Void();
}
Return<void> RadioResponse::setRadioCapabilityResponse(
- const RadioResponseInfo& info, const RadioCapability& /*rc*/) {
- rspInfo = info;
- parent.notify();
- return Void();
+ const RadioResponseInfo& info, const RadioCapability& /*rc*/) {
+ rspInfo = info;
+ parent.notify();
+ return Void();
}
Return<void> RadioResponse::startLceServiceResponse(
- const RadioResponseInfo& info, const LceStatusInfo& /*statusInfo*/) {
- rspInfo = info;
- parent.notify();
- return Void();
+ const RadioResponseInfo& info, const LceStatusInfo& /*statusInfo*/) {
+ rspInfo = info;
+ parent.notify();
+ return Void();
}
Return<void> RadioResponse::stopLceServiceResponse(
- const RadioResponseInfo& info, const LceStatusInfo& /*statusInfo*/) {
- rspInfo = info;
- parent.notify();
- return Void();
+ const RadioResponseInfo& info, const LceStatusInfo& /*statusInfo*/) {
+ rspInfo = info;
+ parent.notify();
+ return Void();
}
Return<void> RadioResponse::pullLceDataResponse(
- const RadioResponseInfo& info, const LceDataInfo& /*lceInfo*/) {
- rspInfo = info;
- parent.notify();
- return Void();
+ const RadioResponseInfo& info, const LceDataInfo& /*lceInfo*/) {
+ rspInfo = info;
+ parent.notify();
+ return Void();
}
Return<void> RadioResponse::getModemActivityInfoResponse(
- const RadioResponseInfo& info, const ActivityStatsInfo& /*activityInfo*/) {
- rspInfo = info;
- parent.notify();
- return Void();
+ const RadioResponseInfo& info, const ActivityStatsInfo& /*activityInfo*/) {
+ rspInfo = info;
+ parent.notify();
+ return Void();
}
Return<void> RadioResponse::setAllowedCarriersResponse(
- const RadioResponseInfo& info, int32_t /*numAllowed*/) {
- rspInfo = info;
- parent.notify();
- return Void();
+ const RadioResponseInfo& info, int32_t /*numAllowed*/) {
+ rspInfo = info;
+ parent.notify();
+ return Void();
}
Return<void> RadioResponse::getAllowedCarriersResponse(
- const RadioResponseInfo& info, bool /*allAllowed*/,
- const CarrierRestrictions& /*carriers*/) {
- rspInfo = info;
- parent.notify();
- return Void();
+ const RadioResponseInfo& info, bool /*allAllowed*/,
+ const CarrierRestrictions& /*carriers*/) {
+ rspInfo = info;
+ parent.notify();
+ return Void();
}
Return<void> RadioResponse::sendDeviceStateResponse(
- const RadioResponseInfo& info) {
- rspInfo = info;
- parent.notify();
- return Void();
+ const RadioResponseInfo& info) {
+ rspInfo = info;
+ parent.notify();
+ return Void();
}
Return<void> RadioResponse::setIndicationFilterResponse(
- const RadioResponseInfo& info) {
- rspInfo = info;
- parent.notify();
- return Void();
+ const RadioResponseInfo& info) {
+ rspInfo = info;
+ parent.notify();
+ return Void();
}
Return<void> RadioResponse::setSimCardPowerResponse(
- const RadioResponseInfo& info) {
- rspInfo = info;
- parent.notify();
- return Void();
+ const RadioResponseInfo& info) {
+ rspInfo = info;
+ parent.notify();
+ return Void();
}
Return<void> RadioResponse::acknowledgeRequest(int32_t /*serial*/) {
- return Void();
+ return Void();
}
diff --git a/radio/1.0/vts/functional/sap_callback.cpp b/radio/1.0/vts/functional/sap_callback.cpp
index 563d066..3a06ecd 100644
--- a/radio/1.0/vts/functional/sap_callback.cpp
+++ b/radio/1.0/vts/functional/sap_callback.cpp
@@ -14,79 +14,82 @@
* limitations under the License.
*/
-#include<sap_hidl_hal_utils.h>
+#include <sap_hidl_hal_utils.h>
-SapCallback::SapCallback(SapHidlTest& parent) : parent(parent) {
-}
+SapCallback::SapCallback(SapHidlTest& parent) : parent(parent) {}
-Return<void> SapCallback::connectResponse(int32_t token, SapConnectRsp /*sapConnectRsp*/,
- int32_t /*maxMsgSize*/) {
- sapResponseToken = token;
- parent.notify();
- return Void();
+Return<void> SapCallback::connectResponse(int32_t token,
+ SapConnectRsp /*sapConnectRsp*/,
+ int32_t /*maxMsgSize*/) {
+ sapResponseToken = token;
+ parent.notify();
+ return Void();
}
Return<void> SapCallback::disconnectResponse(int32_t token) {
- sapResponseToken = token;
- parent.notify();
- return Void();
+ sapResponseToken = token;
+ parent.notify();
+ return Void();
}
-Return<void> SapCallback::disconnectIndication(int32_t /*token*/,
- SapDisconnectType /*disconnectType*/) {
- return Void();
+Return<void> SapCallback::disconnectIndication(
+ int32_t /*token*/, SapDisconnectType /*disconnectType*/) {
+ return Void();
}
-Return<void> SapCallback::apduResponse(int32_t token, SapResultCode resultCode,
- const ::android::hardware::hidl_vec<uint8_t>& /*apduRsp*/) {
- sapResponseToken = token;
- sapResultCode = resultCode;
- parent.notify();
- return Void();
+Return<void> SapCallback::apduResponse(
+ int32_t token, SapResultCode resultCode,
+ const ::android::hardware::hidl_vec<uint8_t>& /*apduRsp*/) {
+ sapResponseToken = token;
+ sapResultCode = resultCode;
+ parent.notify();
+ return Void();
}
-Return<void> SapCallback::transferAtrResponse(int32_t token, SapResultCode resultCode,
- const ::android::hardware::hidl_vec<uint8_t>& /*atr*/) {
- sapResponseToken = token;
- sapResultCode = resultCode;
- parent.notify();
- return Void();
+Return<void> SapCallback::transferAtrResponse(
+ int32_t token, SapResultCode resultCode,
+ const ::android::hardware::hidl_vec<uint8_t>& /*atr*/) {
+ sapResponseToken = token;
+ sapResultCode = resultCode;
+ parent.notify();
+ return Void();
}
-Return<void> SapCallback::powerResponse(int32_t token, SapResultCode resultCode) {
- sapResponseToken = token;
- sapResultCode = resultCode;
- parent.notify();
- return Void();
+Return<void> SapCallback::powerResponse(int32_t token,
+ SapResultCode resultCode) {
+ sapResponseToken = token;
+ sapResultCode = resultCode;
+ parent.notify();
+ return Void();
}
-Return<void> SapCallback::resetSimResponse(int32_t token, SapResultCode resultCode) {
- sapResponseToken = token;
- sapResultCode = resultCode;
- parent.notify();
- return Void();
+Return<void> SapCallback::resetSimResponse(int32_t token,
+ SapResultCode resultCode) {
+ sapResponseToken = token;
+ sapResultCode = resultCode;
+ parent.notify();
+ return Void();
}
-Return<void> SapCallback::statusIndication(int32_t /*token*/, SapStatus /*status*/) {
- return Void();
+Return<void> SapCallback::statusIndication(int32_t /*token*/,
+ SapStatus /*status*/) {
+ return Void();
}
-Return<void> SapCallback::transferCardReaderStatusResponse(int32_t token,
- SapResultCode resultCode, int32_t /*cardReaderStatus*/) {
- sapResponseToken = token;
- sapResultCode = resultCode;
- parent.notify();
- return Void();
+Return<void> SapCallback::transferCardReaderStatusResponse(
+ int32_t token, SapResultCode resultCode, int32_t /*cardReaderStatus*/) {
+ sapResponseToken = token;
+ sapResultCode = resultCode;
+ parent.notify();
+ return Void();
}
-Return<void> SapCallback::errorResponse(int32_t /*token*/) {
- return Void();
-}
+Return<void> SapCallback::errorResponse(int32_t /*token*/) { return Void(); }
Return<void> SapCallback::transferProtocolResponse(int32_t token,
- SapResultCode resultCode) {
- sapResponseToken = token;
- sapResultCode = resultCode;
- parent.notify();
- return Void();
+ SapResultCode resultCode) {
+ sapResponseToken = token;
+ sapResultCode = resultCode;
+ parent.notify();
+ return Void();
}
diff --git a/radio/1.0/vts/functional/sap_hidl_hal_api.cpp b/radio/1.0/vts/functional/sap_hidl_hal_api.cpp
index e806bd7..682230c 100644
--- a/radio/1.0/vts/functional/sap_hidl_hal_api.cpp
+++ b/radio/1.0/vts/functional/sap_hidl_hal_api.cpp
@@ -14,44 +14,44 @@
* limitations under the License.
*/
-#include<sap_hidl_hal_utils.h>
+#include <sap_hidl_hal_utils.h>
/*
* Test ISap.connectReq() for the response returned.
*/
TEST_F(SapHidlTest, connectReq) {
- int32_t token = 0;
- int32_t maxMsgSize = 100;
+ int32_t token = 0;
+ int32_t maxMsgSize = 100;
- sap->connectReq(++token, maxMsgSize);
- EXPECT_EQ(std::cv_status::no_timeout, wait());
- EXPECT_EQ(sapCb->sapResponseToken, token);
+ sap->connectReq(++token, maxMsgSize);
+ EXPECT_EQ(std::cv_status::no_timeout, wait());
+ EXPECT_EQ(sapCb->sapResponseToken, token);
}
/*
* Test IRadio.disconnectReq() for the response returned
*/
TEST_F(SapHidlTest, disconnectReq) {
- int32_t token = 0;
+ int32_t token = 0;
- sap->disconnectReq(++token);
- EXPECT_EQ(std::cv_status::no_timeout, wait());
- EXPECT_EQ(sapCb->sapResponseToken, token);
+ sap->disconnectReq(++token);
+ EXPECT_EQ(std::cv_status::no_timeout, wait());
+ EXPECT_EQ(sapCb->sapResponseToken, token);
}
/*
* Test IRadio.apduReq() for the response returned.
*/
TEST_F(SapHidlTest, apduReq) {
- int32_t token = 0;
- SapApduType sapApduType = SapApduType::APDU;
- android::hardware::hidl_vec<uint8_t> command = {};
+ int32_t token = 0;
+ SapApduType sapApduType = SapApduType::APDU;
+ android::hardware::hidl_vec<uint8_t> command = {};
- sap->apduReq(++token, sapApduType, command);
- EXPECT_EQ(std::cv_status::no_timeout, wait());
- EXPECT_EQ(sapCb->sapResponseToken, token);
+ sap->apduReq(++token, sapApduType, command);
+ EXPECT_EQ(std::cv_status::no_timeout, wait());
+ EXPECT_EQ(sapCb->sapResponseToken, token);
- ASSERT_TRUE(SapResultCode::CARD_NOT_ACCESSSIBLE == sapCb->sapResultCode ||
+ ASSERT_TRUE(SapResultCode::CARD_NOT_ACCESSSIBLE == sapCb->sapResultCode ||
SapResultCode::CARD_ALREADY_POWERED_OFF == sapCb->sapResultCode ||
SapResultCode::CARD_REMOVED == sapCb->sapResultCode);
}
@@ -60,13 +60,13 @@
* Test IRadio.transferAtrReq() for the response returned.
*/
TEST_F(SapHidlTest, transferAtrReq) {
- int32_t token = 0;
+ int32_t token = 0;
- sap->transferAtrReq(++token);
- EXPECT_EQ(std::cv_status::no_timeout, wait());
- EXPECT_EQ(sapCb->sapResponseToken, token);
+ sap->transferAtrReq(++token);
+ EXPECT_EQ(std::cv_status::no_timeout, wait());
+ EXPECT_EQ(sapCb->sapResponseToken, token);
- ASSERT_TRUE(SapResultCode::DATA_NOT_AVAILABLE == sapCb->sapResultCode ||
+ ASSERT_TRUE(SapResultCode::DATA_NOT_AVAILABLE == sapCb->sapResultCode ||
SapResultCode::CARD_ALREADY_POWERED_OFF == sapCb->sapResultCode ||
SapResultCode::CARD_REMOVED == sapCb->sapResultCode);
}
@@ -75,14 +75,14 @@
* Test IRadio.powerReq() for the response returned.
*/
TEST_F(SapHidlTest, powerReq) {
- int32_t token = 0;
- bool state = true;
+ int32_t token = 0;
+ bool state = true;
- sap->powerReq(++token, state);
- EXPECT_EQ(std::cv_status::no_timeout, wait());
- EXPECT_EQ(sapCb->sapResponseToken, token);
+ sap->powerReq(++token, state);
+ EXPECT_EQ(std::cv_status::no_timeout, wait());
+ EXPECT_EQ(sapCb->sapResponseToken, token);
- ASSERT_TRUE(SapResultCode::CARD_NOT_ACCESSSIBLE == sapCb->sapResultCode ||
+ ASSERT_TRUE(SapResultCode::CARD_NOT_ACCESSSIBLE == sapCb->sapResultCode ||
SapResultCode::CARD_ALREADY_POWERED_OFF == sapCb->sapResultCode ||
SapResultCode::CARD_REMOVED == sapCb->sapResultCode ||
SapResultCode::CARD_ALREADY_POWERED_ON == sapCb->sapResultCode);
@@ -92,13 +92,13 @@
* Test IRadio.resetSimReq() for the response returned.
*/
TEST_F(SapHidlTest, resetSimReq) {
- int32_t token = 0;
+ int32_t token = 0;
- sap->resetSimReq(++token);
- EXPECT_EQ(std::cv_status::no_timeout, wait());
- EXPECT_EQ(sapCb->sapResponseToken, token);
+ sap->resetSimReq(++token);
+ EXPECT_EQ(std::cv_status::no_timeout, wait());
+ EXPECT_EQ(sapCb->sapResponseToken, token);
- ASSERT_TRUE(SapResultCode::CARD_NOT_ACCESSSIBLE == sapCb->sapResultCode ||
+ ASSERT_TRUE(SapResultCode::CARD_NOT_ACCESSSIBLE == sapCb->sapResultCode ||
SapResultCode::CARD_ALREADY_POWERED_OFF == sapCb->sapResultCode ||
SapResultCode::CARD_REMOVED == sapCb->sapResultCode);
}
@@ -107,25 +107,25 @@
* Test IRadio.transferCardReaderStatusReq() for the response returned.
*/
TEST_F(SapHidlTest, transferCardReaderStatusReq) {
- int32_t token = 0;
+ int32_t token = 0;
- sap->transferCardReaderStatusReq(++token);
- EXPECT_EQ(std::cv_status::no_timeout, wait());
- EXPECT_EQ(sapCb->sapResponseToken, token);
+ sap->transferCardReaderStatusReq(++token);
+ EXPECT_EQ(std::cv_status::no_timeout, wait());
+ EXPECT_EQ(sapCb->sapResponseToken, token);
- EXPECT_EQ(SapResultCode::DATA_NOT_AVAILABLE, sapCb->sapResultCode);
+ EXPECT_EQ(SapResultCode::DATA_NOT_AVAILABLE, sapCb->sapResultCode);
}
/*
* Test IRadio.setTransferProtocolReq() for the response returned.
*/
TEST_F(SapHidlTest, setTransferProtocolReq) {
- int32_t token = 0;
- SapTransferProtocol sapTransferProtocol = SapTransferProtocol::T0;
+ int32_t token = 0;
+ SapTransferProtocol sapTransferProtocol = SapTransferProtocol::T0;
- sap->setTransferProtocolReq(++token, sapTransferProtocol);
- EXPECT_EQ(std::cv_status::no_timeout, wait());
- EXPECT_EQ(sapCb->sapResponseToken, token);
+ sap->setTransferProtocolReq(++token, sapTransferProtocol);
+ EXPECT_EQ(std::cv_status::no_timeout, wait());
+ EXPECT_EQ(sapCb->sapResponseToken, token);
- EXPECT_EQ(SapResultCode::NOT_SUPPORTED, sapCb->sapResultCode);
+ EXPECT_EQ(SapResultCode::NOT_SUPPORTED, sapCb->sapResultCode);
}
diff --git a/radio/1.0/vts/functional/sap_hidl_hal_test.cpp b/radio/1.0/vts/functional/sap_hidl_hal_test.cpp
index a67c5b6..88274cd 100644
--- a/radio/1.0/vts/functional/sap_hidl_hal_test.cpp
+++ b/radio/1.0/vts/functional/sap_hidl_hal_test.cpp
@@ -14,41 +14,40 @@
* limitations under the License.
*/
-#include<sap_hidl_hal_utils.h>
+#include <sap_hidl_hal_utils.h>
void SapHidlTest::SetUp() {
- sap = ::testing::VtsHalHidlTargetTestBase::getService<ISap>(hidl_string("sap_uim_socket1"));
- ASSERT_NE(sap, nullptr);
+ sap = ::testing::VtsHalHidlTargetTestBase::getService<ISap>(
+ hidl_string("sap_uim_socket1"));
+ ASSERT_NE(sap, nullptr);
- sapCb = new SapCallback(*this);
- ASSERT_NE(sapCb, nullptr);
+ sapCb = new SapCallback(*this);
+ ASSERT_NE(sapCb, nullptr);
- count = 0;
+ count = 0;
- sap->setCallback(sapCb);
+ sap->setCallback(sapCb);
}
-void SapHidlTest::TearDown() {
-}
+void SapHidlTest::TearDown() {}
void SapHidlTest::notify() {
- std::unique_lock<std::mutex> lock(mtx);
- count++;
- cv.notify_one();
+ std::unique_lock<std::mutex> lock(mtx);
+ count++;
+ cv.notify_one();
}
std::cv_status SapHidlTest::wait() {
- std::unique_lock<std::mutex> lock(mtx);
+ std::unique_lock<std::mutex> lock(mtx);
- std::cv_status status = std::cv_status::no_timeout;
- auto now = std::chrono::system_clock::now();
- while (count == 0) {
- status = cv.wait_until(lock, now + std::chrono::seconds(TIMEOUT_PERIOD));
- if (status == std::cv_status::timeout) {
- return status;
- }
+ std::cv_status status = std::cv_status::no_timeout;
+ auto now = std::chrono::system_clock::now();
+ while (count == 0) {
+ status = cv.wait_until(lock, now + std::chrono::seconds(TIMEOUT_PERIOD));
+ if (status == std::cv_status::timeout) {
+ return status;
}
- count--;
- return status;
+ }
+ count--;
+ return status;
}
-
diff --git a/radio/1.0/vts/functional/sap_hidl_hal_utils.h b/radio/1.0/vts/functional/sap_hidl_hal_utils.h
index e3efa50..2ee3c96 100644
--- a/radio/1.0/vts/functional/sap_hidl_hal_utils.h
+++ b/radio/1.0/vts/functional/sap_hidl_hal_utils.h
@@ -39,71 +39,77 @@
/* Callback class for sap response */
class SapCallback : public ISapCallback {
-private:
- SapHidlTest& parent;
+ private:
+ SapHidlTest& parent;
-public:
- SapResultCode sapResultCode;
- int32_t sapResponseToken;
+ public:
+ SapResultCode sapResultCode;
+ int32_t sapResponseToken;
- SapCallback(SapHidlTest& parent);
+ SapCallback(SapHidlTest& parent);
- virtual ~SapCallback() = default;
+ virtual ~SapCallback() = default;
- Return<void> connectResponse(int32_t token, SapConnectRsp sapConnectRsp, int32_t maxMsgSize);
+ Return<void> connectResponse(int32_t token, SapConnectRsp sapConnectRsp,
+ int32_t maxMsgSize);
- Return<void> disconnectResponse(int32_t token);
+ Return<void> disconnectResponse(int32_t token);
- Return<void> disconnectIndication(int32_t token, SapDisconnectType disconnectType);
+ Return<void> disconnectIndication(int32_t token,
+ SapDisconnectType disconnectType);
- Return<void> apduResponse(int32_t token, SapResultCode resultCode,
- const ::android::hardware::hidl_vec<uint8_t>& apduRsp);
+ Return<void> apduResponse(
+ int32_t token, SapResultCode resultCode,
+ const ::android::hardware::hidl_vec<uint8_t>& apduRsp);
- Return<void> transferAtrResponse(int32_t token, SapResultCode resultCode,
- const ::android::hardware::hidl_vec<uint8_t>& atr);
+ Return<void> transferAtrResponse(
+ int32_t token, SapResultCode resultCode,
+ const ::android::hardware::hidl_vec<uint8_t>& atr);
- Return<void> powerResponse(int32_t token, SapResultCode resultCode);
+ Return<void> powerResponse(int32_t token, SapResultCode resultCode);
- Return<void> resetSimResponse(int32_t token, SapResultCode resultCode);
+ Return<void> resetSimResponse(int32_t token, SapResultCode resultCode);
- Return<void> statusIndication(int32_t token, SapStatus status);
+ Return<void> statusIndication(int32_t token, SapStatus status);
- Return<void> transferCardReaderStatusResponse(int32_t token, SapResultCode resultCode,
- int32_t cardReaderStatus);
+ Return<void> transferCardReaderStatusResponse(int32_t token,
+ SapResultCode resultCode,
+ int32_t cardReaderStatus);
- Return<void> errorResponse(int32_t token);
+ Return<void> errorResponse(int32_t token);
- Return<void> transferProtocolResponse(int32_t token, SapResultCode resultCode);
+ Return<void> transferProtocolResponse(int32_t token,
+ SapResultCode resultCode);
};
// The main test class for Sap HIDL.
class SapHidlTest : public ::testing::VtsHalHidlTargetTestBase {
-private:
- std::mutex mtx;
- std::condition_variable cv;
- int count;
+ private:
+ std::mutex mtx;
+ std::condition_variable cv;
+ int count;
-public:
- virtual void SetUp() override;
+ public:
+ virtual void SetUp() override;
- virtual void TearDown() override;
+ virtual void TearDown() override;
- /* Used as a mechanism to inform the test about data/event callback */
- void notify();
+ /* Used as a mechanism to inform the test about data/event callback */
+ void notify();
- /* Test code calls this function to wait for response */
- std::cv_status wait();
+ /* Test code calls this function to wait for response */
+ std::cv_status wait();
- /* Sap service */
- sp<ISap> sap;
+ /* Sap service */
+ sp<ISap> sap;
- /* Sap Callback object */
- sp<SapCallback> sapCb;
+ /* Sap Callback object */
+ sp<SapCallback> sapCb;
};
// A class for test environment setup
class SapHidlEnvironment : public ::testing::Environment {
-public:
- virtual void SetUp() {}
- virtual void TearDown() {}
+ public:
+ virtual void SetUp() {}
+ virtual void TearDown() {}
};
diff --git a/sensors/1.0/vts/functional/VtsHalSensorsV1_0TargetTest.cpp b/sensors/1.0/vts/functional/VtsHalSensorsV1_0TargetTest.cpp
index a65c7b8..f757a64 100644
--- a/sensors/1.0/vts/functional/VtsHalSensorsV1_0TargetTest.cpp
+++ b/sensors/1.0/vts/functional/VtsHalSensorsV1_0TargetTest.cpp
@@ -15,14 +15,14 @@
*/
#define LOG_TAG "sensors_hidl_hal_test"
+#include <VtsHalHidlTargetTestBase.h>
#include <android-base/logging.h>
#include <android/hardware/sensors/1.0/ISensors.h>
#include <android/hardware/sensors/1.0/types.h>
-#include <android/log.h>
#include <cutils/ashmem.h>
+#include <hardware/sensors.h> // for sensor type strings
+#include <log/log.h>
#include <utils/SystemClock.h>
-#include <VtsHalHidlTargetTestBase.h>
-#include <hardware/sensors.h> // for sensor type strings
#include <algorithm>
#include <cinttypes>
@@ -616,7 +616,7 @@
switch (type) {
#define CHECK_TYPE_STRING_FOR_SENSOR_TYPE(type) \
- case SensorType::type: ASSERT_STREQ(SENSOR_STRING_TYPE_ ## type, stringType); break;
+ case SensorType::type: ASSERT_STREQ(SENSOR_STRING_TYPE_ ## type, stringType.c_str()); break;
CHECK_TYPE_STRING_FOR_SENSOR_TYPE(ACCELEROMETER);
CHECK_TYPE_STRING_FOR_SENSOR_TYPE(ACCELEROMETER_UNCALIBRATED);
CHECK_TYPE_STRING_FOR_SENSOR_TYPE(ADDITIONAL_INFO);
diff --git a/soundtrigger/2.0/vts/functional/VtsHalSoundtriggerV2_0TargetTest.cpp b/soundtrigger/2.0/vts/functional/VtsHalSoundtriggerV2_0TargetTest.cpp
index 3fbef18..2eca8f4 100644
--- a/soundtrigger/2.0/vts/functional/VtsHalSoundtriggerV2_0TargetTest.cpp
+++ b/soundtrigger/2.0/vts/functional/VtsHalSoundtriggerV2_0TargetTest.cpp
@@ -23,6 +23,7 @@
#include <android/log.h>
#include <cutils/native_handle.h>
+#include <log/log.h>
#include <android/hardware/audio/common/2.0/types.h>
#include <android/hardware/soundtrigger/2.0/ISoundTriggerHw.h>
diff --git a/tests/Android.bp b/tests/Android.bp
index 31dc75e..6f99a36 100644
--- a/tests/Android.bp
+++ b/tests/Android.bp
@@ -9,6 +9,8 @@
"foo/1.0",
"foo/1.0/default",
"foo/1.0/default/lib",
+ "hash/1.0",
+ "hash/1.0/default",
"inheritance/1.0",
"inheritance/1.0/default",
"libhwbinder/1.0",
diff --git a/tests/baz/1.0/Android.bp b/tests/baz/1.0/Android.bp
index 8f327e3..1d5013b 100644
--- a/tests/baz/1.0/Android.bp
+++ b/tests/baz/1.0/Android.bp
@@ -7,6 +7,7 @@
"IBase.hal",
"IBaz.hal",
"IBazCallback.hal",
+ "IQuux.hal",
],
}
@@ -22,6 +23,7 @@
"android/hardware/tests/baz/1.0/BaseAll.cpp",
"android/hardware/tests/baz/1.0/BazAll.cpp",
"android/hardware/tests/baz/1.0/BazCallbackAll.cpp",
+ "android/hardware/tests/baz/1.0/QuuxAll.cpp",
],
}
@@ -50,6 +52,11 @@
"android/hardware/tests/baz/1.0/BnHwBazCallback.h",
"android/hardware/tests/baz/1.0/BpHwBazCallback.h",
"android/hardware/tests/baz/1.0/BsBazCallback.h",
+ "android/hardware/tests/baz/1.0/IQuux.h",
+ "android/hardware/tests/baz/1.0/IHwQuux.h",
+ "android/hardware/tests/baz/1.0/BnHwQuux.h",
+ "android/hardware/tests/baz/1.0/BpHwQuux.h",
+ "android/hardware/tests/baz/1.0/BsQuux.h",
],
}
diff --git a/tests/baz/1.0/Android.mk b/tests/baz/1.0/Android.mk
index 40026ec..9d4d6b6 100644
--- a/tests/baz/1.0/Android.mk
+++ b/tests/baz/1.0/Android.mk
@@ -76,6 +76,25 @@
$(GEN): $(LOCAL_PATH)/IBazCallback.hal
$(transform-generated-source)
LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build IQuux.hal
+#
+GEN := $(intermediates)/android/hardware/tests/baz/V1_0/IQuux.java
+$(GEN): $(HIDL)
+$(GEN): PRIVATE_HIDL := $(HIDL)
+$(GEN): PRIVATE_DEPS := $(LOCAL_PATH)/IQuux.hal
+$(GEN): PRIVATE_OUTPUT_DIR := $(intermediates)
+$(GEN): PRIVATE_CUSTOM_TOOL = \
+ $(PRIVATE_HIDL) -o $(PRIVATE_OUTPUT_DIR) \
+ -Ljava \
+ -randroid.hardware:hardware/interfaces \
+ -randroid.hidl:system/libhidl/transport \
+ android.hardware.tests.baz@1.0::IQuux
+
+$(GEN): $(LOCAL_PATH)/IQuux.hal
+ $(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
include $(BUILD_JAVA_LIBRARY)
@@ -153,6 +172,25 @@
$(GEN): $(LOCAL_PATH)/IBazCallback.hal
$(transform-generated-source)
LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
+# Build IQuux.hal
+#
+GEN := $(intermediates)/android/hardware/tests/baz/V1_0/IQuux.java
+$(GEN): $(HIDL)
+$(GEN): PRIVATE_HIDL := $(HIDL)
+$(GEN): PRIVATE_DEPS := $(LOCAL_PATH)/IQuux.hal
+$(GEN): PRIVATE_OUTPUT_DIR := $(intermediates)
+$(GEN): PRIVATE_CUSTOM_TOOL = \
+ $(PRIVATE_HIDL) -o $(PRIVATE_OUTPUT_DIR) \
+ -Ljava \
+ -randroid.hardware:hardware/interfaces \
+ -randroid.hidl:system/libhidl/transport \
+ android.hardware.tests.baz@1.0::IQuux
+
+$(GEN): $(LOCAL_PATH)/IQuux.hal
+ $(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
include $(BUILD_STATIC_JAVA_LIBRARY)
diff --git a/tests/baz/1.0/IQuux.hal b/tests/baz/1.0/IQuux.hal
new file mode 100644
index 0000000..ccf3212
--- /dev/null
+++ b/tests/baz/1.0/IQuux.hal
@@ -0,0 +1,20 @@
+/*
+ * Copyright (C) 2017 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.tests.baz@1.0;
+
+interface IQuux {
+};
diff --git a/tests/hash/1.0/Android.bp b/tests/hash/1.0/Android.bp
new file mode 100644
index 0000000..c217e5c
--- /dev/null
+++ b/tests/hash/1.0/Android.bp
@@ -0,0 +1,59 @@
+// This file is autogenerated by hidl-gen. Do not edit manually.
+
+filegroup {
+ name: "android.hardware.tests.hash@1.0_hal",
+ srcs: [
+ "IHash.hal",
+ ],
+}
+
+genrule {
+ name: "android.hardware.tests.hash@1.0_genc++",
+ tools: ["hidl-gen"],
+ cmd: "$(location hidl-gen) -o $(genDir) -Lc++ -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.tests.hash@1.0",
+ srcs: [
+ ":android.hardware.tests.hash@1.0_hal",
+ ],
+ out: [
+ "android/hardware/tests/hash/1.0/HashAll.cpp",
+ ],
+}
+
+genrule {
+ name: "android.hardware.tests.hash@1.0_genc++_headers",
+ tools: ["hidl-gen"],
+ cmd: "$(location hidl-gen) -o $(genDir) -Lc++ -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.tests.hash@1.0",
+ srcs: [
+ ":android.hardware.tests.hash@1.0_hal",
+ ],
+ out: [
+ "android/hardware/tests/hash/1.0/IHash.h",
+ "android/hardware/tests/hash/1.0/IHwHash.h",
+ "android/hardware/tests/hash/1.0/BnHwHash.h",
+ "android/hardware/tests/hash/1.0/BpHwHash.h",
+ "android/hardware/tests/hash/1.0/BsHash.h",
+ ],
+}
+
+cc_library_shared {
+ name: "android.hardware.tests.hash@1.0",
+ generated_sources: ["android.hardware.tests.hash@1.0_genc++"],
+ generated_headers: ["android.hardware.tests.hash@1.0_genc++_headers"],
+ export_generated_headers: ["android.hardware.tests.hash@1.0_genc++_headers"],
+ shared_libs: [
+ "libhidlbase",
+ "libhidltransport",
+ "libhwbinder",
+ "liblog",
+ "libutils",
+ "libcutils",
+ "android.hidl.base@1.0",
+ ],
+ export_shared_lib_headers: [
+ "libhidlbase",
+ "libhidltransport",
+ "libhwbinder",
+ "libutils",
+ "android.hidl.base@1.0",
+ ],
+}
diff --git a/tests/hash/1.0/Android.mk b/tests/hash/1.0/Android.mk
new file mode 100644
index 0000000..15428b4
--- /dev/null
+++ b/tests/hash/1.0/Android.mk
@@ -0,0 +1,76 @@
+# This file is autogenerated by hidl-gen. Do not edit manually.
+
+LOCAL_PATH := $(call my-dir)
+
+################################################################################
+
+include $(CLEAR_VARS)
+LOCAL_MODULE := android.hardware.tests.hash@1.0-java
+LOCAL_MODULE_CLASS := JAVA_LIBRARIES
+
+intermediates := $(call local-generated-sources-dir, COMMON)
+
+HIDL := $(HOST_OUT_EXECUTABLES)/hidl-gen$(HOST_EXECUTABLE_SUFFIX)
+
+LOCAL_JAVA_LIBRARIES := \
+ android.hidl.base@1.0-java \
+
+
+#
+# Build IHash.hal
+#
+GEN := $(intermediates)/android/hardware/tests/hash/V1_0/IHash.java
+$(GEN): $(HIDL)
+$(GEN): PRIVATE_HIDL := $(HIDL)
+$(GEN): PRIVATE_DEPS := $(LOCAL_PATH)/IHash.hal
+$(GEN): PRIVATE_OUTPUT_DIR := $(intermediates)
+$(GEN): PRIVATE_CUSTOM_TOOL = \
+ $(PRIVATE_HIDL) -o $(PRIVATE_OUTPUT_DIR) \
+ -Ljava \
+ -randroid.hardware:hardware/interfaces \
+ -randroid.hidl:system/libhidl/transport \
+ android.hardware.tests.hash@1.0::IHash
+
+$(GEN): $(LOCAL_PATH)/IHash.hal
+ $(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+include $(BUILD_JAVA_LIBRARY)
+
+
+################################################################################
+
+include $(CLEAR_VARS)
+LOCAL_MODULE := android.hardware.tests.hash@1.0-java-static
+LOCAL_MODULE_CLASS := JAVA_LIBRARIES
+
+intermediates := $(call local-generated-sources-dir, COMMON)
+
+HIDL := $(HOST_OUT_EXECUTABLES)/hidl-gen$(HOST_EXECUTABLE_SUFFIX)
+
+LOCAL_STATIC_JAVA_LIBRARIES := \
+ android.hidl.base@1.0-java-static \
+
+
+#
+# Build IHash.hal
+#
+GEN := $(intermediates)/android/hardware/tests/hash/V1_0/IHash.java
+$(GEN): $(HIDL)
+$(GEN): PRIVATE_HIDL := $(HIDL)
+$(GEN): PRIVATE_DEPS := $(LOCAL_PATH)/IHash.hal
+$(GEN): PRIVATE_OUTPUT_DIR := $(intermediates)
+$(GEN): PRIVATE_CUSTOM_TOOL = \
+ $(PRIVATE_HIDL) -o $(PRIVATE_OUTPUT_DIR) \
+ -Ljava \
+ -randroid.hardware:hardware/interfaces \
+ -randroid.hidl:system/libhidl/transport \
+ android.hardware.tests.hash@1.0::IHash
+
+$(GEN): $(LOCAL_PATH)/IHash.hal
+ $(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+include $(BUILD_STATIC_JAVA_LIBRARY)
+
+
+
+include $(call all-makefiles-under,$(LOCAL_PATH))
diff --git a/tests/hash/1.0/IHash.hal b/tests/hash/1.0/IHash.hal
new file mode 100644
index 0000000..ba48384
--- /dev/null
+++ b/tests/hash/1.0/IHash.hal
@@ -0,0 +1,32 @@
+/*
+ * Copyright (C) 2017 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.tests.hash@1.0;
+
+/**
+ * Test interface for hashing HAL files.
+ * This file is FREEZED to ensure its hash doesn't change.
+ */
+interface IHash {
+ /**
+ * Dummy.
+ */
+ dummy();
+ /**
+ * Dummy.
+ */
+ functions();
+};
diff --git a/tests/hash/1.0/default/Android.bp b/tests/hash/1.0/default/Android.bp
new file mode 100644
index 0000000..e798a66
--- /dev/null
+++ b/tests/hash/1.0/default/Android.bp
@@ -0,0 +1,15 @@
+cc_library_shared {
+ name: "android.hardware.tests.hash@1.0-impl",
+ relative_install_path: "hw",
+ proprietary: true,
+ srcs: [
+ "Hash.cpp",
+ ],
+ shared_libs: [
+ "libhidlbase",
+ "libhidltransport",
+ "libutils",
+ "android.hardware.tests.hash@1.0",
+ "android.hidl.base@1.0",
+ ],
+}
diff --git a/tests/hash/1.0/default/Hash.cpp b/tests/hash/1.0/default/Hash.cpp
new file mode 100644
index 0000000..caed721
--- /dev/null
+++ b/tests/hash/1.0/default/Hash.cpp
@@ -0,0 +1,30 @@
+#include "Hash.h"
+
+namespace android {
+namespace hardware {
+namespace tests {
+namespace hash {
+namespace V1_0 {
+namespace implementation {
+
+// Methods from ::android::hardware::tests::hash::V1_0::IHash follow.
+Return<void> Hash::dummy() {
+ return Void();
+}
+
+Return<void> Hash::functions() {
+ return Void();
+}
+
+// Methods from ::android::hidl::base::V1_0::IBase follow.
+
+IHash* HIDL_FETCH_IHash(const char* /* name */) {
+ return new Hash();
+}
+
+} // namespace implementation
+} // namespace V1_0
+} // namespace hash
+} // namespace tests
+} // namespace hardware
+} // namespace android
diff --git a/tests/hash/1.0/default/Hash.h b/tests/hash/1.0/default/Hash.h
new file mode 100644
index 0000000..dd1678f
--- /dev/null
+++ b/tests/hash/1.0/default/Hash.h
@@ -0,0 +1,43 @@
+#ifndef ANDROID_HARDWARE_TESTS_HASH_V1_0_HASH_H
+#define ANDROID_HARDWARE_TESTS_HASH_V1_0_HASH_H
+
+#include <android/hardware/tests/hash/1.0/IHash.h>
+#include <hidl/MQDescriptor.h>
+#include <hidl/Status.h>
+
+namespace android {
+namespace hardware {
+namespace tests {
+namespace hash {
+namespace V1_0 {
+namespace implementation {
+
+using ::android::hardware::tests::hash::V1_0::IHash;
+using ::android::hidl::base::V1_0::DebugInfo;
+using ::android::hidl::base::V1_0::IBase;
+using ::android::hardware::hidl_array;
+using ::android::hardware::hidl_memory;
+using ::android::hardware::hidl_string;
+using ::android::hardware::hidl_vec;
+using ::android::hardware::Return;
+using ::android::hardware::Void;
+using ::android::sp;
+
+struct Hash : public IHash {
+ // Methods from ::android::hardware::tests::hash::V1_0::IHash follow.
+ Return<void> dummy() override;
+ Return<void> functions() override;
+
+ // Methods from ::android::hidl::base::V1_0::IBase follow.
+};
+
+extern "C" IHash* HIDL_FETCH_IHash(const char* name);
+
+} // namespace implementation
+} // namespace V1_0
+} // namespace hash
+} // namespace tests
+} // namespace hardware
+} // namespace android
+
+#endif // ANDROID_HARDWARE_TESTS_HASH_V1_0_HASH_H
diff --git a/usb/1.0/default/Usb.h b/usb/1.0/default/Usb.h
index c34d080..ddfcac6 100644
--- a/usb/1.0/default/Usb.h
+++ b/usb/1.0/default/Usb.h
@@ -4,7 +4,7 @@
#include <android/hardware/usb/1.0/IUsb.h>
#include <hidl/MQDescriptor.h>
#include <hidl/Status.h>
-#include <utils/Log.h>
+#include <log/log.h>
#ifdef LOG_TAG
#undef LOG_TAG
diff --git a/usb/1.0/default/service.cpp b/usb/1.0/default/service.cpp
index 4605a4c..43ab6f0 100644
--- a/usb/1.0/default/service.cpp
+++ b/usb/1.0/default/service.cpp
@@ -27,13 +27,21 @@
using android::hardware::usb::V1_0::IUsb;
using android::hardware::usb::V1_0::implementation::Usb;
+using android::status_t;
+using android::OK;
+
int main() {
android::sp<IUsb> service = new Usb();
configureRpcThreadpool(1, true /*callerWillJoin*/);
- service->registerAsService();
+ status_t status = service->registerAsService();
- ALOGI("USB HAL Ready.");
- joinRpcThreadpool();
+ if (status == OK) {
+ ALOGI("USB HAL Ready.");
+ joinRpcThreadpool();
+ }
+
+ ALOGE("Cannot register USB HAL service");
+ return 1;
}
diff --git a/usb/1.0/vts/functional/VtsHalUsbV1_0TargetTest.cpp b/usb/1.0/vts/functional/VtsHalUsbV1_0TargetTest.cpp
index ea6d4a9..b77398f 100644
--- a/usb/1.0/vts/functional/VtsHalUsbV1_0TargetTest.cpp
+++ b/usb/1.0/vts/functional/VtsHalUsbV1_0TargetTest.cpp
@@ -22,6 +22,7 @@
#include <android/hardware/usb/1.0/types.h>
#include <VtsHalHidlTargetTestBase.h>
+#include <log/log.h>
#include <stdlib.h>
#include <chrono>
#include <condition_variable>
diff --git a/vr/1.0/vts/functional/VtsHalVrV1_0TargetTest.cpp b/vr/1.0/vts/functional/VtsHalVrV1_0TargetTest.cpp
index a983731..23f4c71 100644
--- a/vr/1.0/vts/functional/VtsHalVrV1_0TargetTest.cpp
+++ b/vr/1.0/vts/functional/VtsHalVrV1_0TargetTest.cpp
@@ -15,11 +15,11 @@
*/
#define LOG_TAG "vr_hidl_hal_test"
+#include <VtsHalHidlTargetTestBase.h>
#include <android-base/logging.h>
#include <android/hardware/vr/1.0/IVr.h>
-#include <android/log.h>
-#include <VtsHalHidlTargetTestBase.h>
#include <hardware/vr.h>
+#include <log/log.h>
using ::android::hardware::vr::V1_0::IVr;
using ::android::hardware::Return;
diff --git a/wifi/1.0/default/hidl_callback_util.h b/wifi/1.0/default/hidl_callback_util.h
index 7136279..b7100c8 100644
--- a/wifi/1.0/default/hidl_callback_util.h
+++ b/wifi/1.0/default/hidl_callback_util.h
@@ -82,7 +82,7 @@
return true;
}
- const std::set<android::sp<CallbackType>> getCallbacks() { return cb_set_; }
+ const std::set<android::sp<CallbackType>>& getCallbacks() { return cb_set_; }
// Death notification for callbacks.
void onObjectDeath(uint64_t cookie) {
diff --git a/wifi/1.0/default/hidl_struct_util.cpp b/wifi/1.0/default/hidl_struct_util.cpp
index c005213..83b2e53 100644
--- a/wifi/1.0/default/hidl_struct_util.cpp
+++ b/wifi/1.0/default/hidl_struct_util.cpp
@@ -417,17 +417,25 @@
const wifi_ie& legacy_ie = (*reinterpret_cast<const wifi_ie*>(next_ie));
uint32_t curr_ie_len = kIeHeaderLen + legacy_ie.len;
if (next_ie + curr_ie_len > ies_end) {
- return false;
+ LOG(ERROR) << "Error parsing IE blob. Next IE: " << (void *)next_ie
+ << ", Curr IE len: " << curr_ie_len << ", IEs End: " << (void *)ies_end;
+ break;
}
WifiInformationElement hidl_ie;
if (!convertLegacyIeToHidl(legacy_ie, &hidl_ie)) {
- return false;
+ LOG(ERROR) << "Error converting IE. Id: " << legacy_ie.id
+ << ", len: " << legacy_ie.len;
+ break;
}
hidl_ies->push_back(std::move(hidl_ie));
next_ie += curr_ie_len;
}
- // Ensure that the blob has been fully consumed.
- return (next_ie == ies_end);
+ // Check if the blob has been fully consumed.
+ if (next_ie != ies_end) {
+ LOG(ERROR) << "Failed to fully parse IE blob. Next IE: " << (void *)next_ie
+ << ", IEs End: " << (void *)ies_end;
+ }
+ return true;
}
bool convertLegacyGscanResultToHidl(
@@ -774,10 +782,104 @@
CHECK(false);
}
+legacy_hal::NanMatchAlg convertHidlNanMatchAlgToLegacy(NanMatchAlg type) {
+ switch (type) {
+ case NanMatchAlg::MATCH_ONCE:
+ return legacy_hal::NAN_MATCH_ALG_MATCH_ONCE;
+ case NanMatchAlg::MATCH_CONTINUOUS:
+ return legacy_hal::NAN_MATCH_ALG_MATCH_CONTINUOUS;
+ case NanMatchAlg::MATCH_NEVER:
+ return legacy_hal::NAN_MATCH_ALG_MATCH_NEVER;
+ }
+ CHECK(false);
+}
+
+legacy_hal::NanPublishType convertHidlNanPublishTypeToLegacy(NanPublishType type) {
+ switch (type) {
+ case NanPublishType::UNSOLICITED:
+ return legacy_hal::NAN_PUBLISH_TYPE_UNSOLICITED;
+ case NanPublishType::SOLICITED:
+ return legacy_hal::NAN_PUBLISH_TYPE_SOLICITED;
+ case NanPublishType::UNSOLICITED_SOLICITED:
+ return legacy_hal::NAN_PUBLISH_TYPE_UNSOLICITED_SOLICITED;
+ }
+ CHECK(false);
+}
+
+legacy_hal::NanTxType convertHidlNanTxTypeToLegacy(NanTxType type) {
+ switch (type) {
+ case NanTxType::BROADCAST:
+ return legacy_hal::NAN_TX_TYPE_BROADCAST;
+ case NanTxType::UNICAST:
+ return legacy_hal::NAN_TX_TYPE_UNICAST;
+ }
+ CHECK(false);
+}
+
+legacy_hal::NanSubscribeType convertHidlNanSubscribeTypeToLegacy(NanSubscribeType type) {
+ switch (type) {
+ case NanSubscribeType::PASSIVE:
+ return legacy_hal::NAN_SUBSCRIBE_TYPE_PASSIVE;
+ case NanSubscribeType::ACTIVE:
+ return legacy_hal::NAN_SUBSCRIBE_TYPE_ACTIVE;
+ }
+ CHECK(false);
+}
+
+legacy_hal::NanSRFType convertHidlNanSrfTypeToLegacy(NanSrfType type) {
+ switch (type) {
+ case NanSrfType::BLOOM_FILTER:
+ return legacy_hal::NAN_SRF_ATTR_BLOOM_FILTER;
+ case NanSrfType::PARTIAL_MAC_ADDR:
+ return legacy_hal::NAN_SRF_ATTR_PARTIAL_MAC_ADDR;
+ }
+ CHECK(false);
+}
+
+legacy_hal::NanDataPathChannelCfg convertHidlNanDataPathChannelCfgToLegacy(
+ NanDataPathChannelCfg type) {
+ switch (type) {
+ case NanDataPathChannelCfg::CHANNEL_NOT_REQUESTED:
+ return legacy_hal::NAN_DP_CHANNEL_NOT_REQUESTED;
+ case NanDataPathChannelCfg::REQUEST_CHANNEL_SETUP:
+ return legacy_hal::NAN_DP_REQUEST_CHANNEL_SETUP;
+ case NanDataPathChannelCfg::FORCE_CHANNEL_SETUP:
+ return legacy_hal::NAN_DP_FORCE_CHANNEL_SETUP;
+ }
+ CHECK(false);
+}
+
NanStatusType convertLegacyNanStatusTypeToHidl(
legacy_hal::NanStatusType type) {
- // values are identical - may need to do a mapping if they diverge in the future
- return (NanStatusType) type;
+ switch (type) {
+ case legacy_hal::NAN_STATUS_SUCCESS:
+ return NanStatusType::SUCCESS;
+ case legacy_hal::NAN_STATUS_INTERNAL_FAILURE:
+ return NanStatusType::INTERNAL_FAILURE;
+ case legacy_hal::NAN_STATUS_PROTOCOL_FAILURE:
+ return NanStatusType::PROTOCOL_FAILURE;
+ case legacy_hal::NAN_STATUS_INVALID_PUBLISH_SUBSCRIBE_ID:
+ return NanStatusType::INVALID_SESSION_ID;
+ case legacy_hal::NAN_STATUS_NO_RESOURCE_AVAILABLE:
+ return NanStatusType::NO_RESOURCES_AVAILABLE;
+ case legacy_hal::NAN_STATUS_INVALID_PARAM:
+ return NanStatusType::INVALID_ARGS;
+ case legacy_hal::NAN_STATUS_INVALID_REQUESTOR_INSTANCE_ID:
+ return NanStatusType::INVALID_PEER_ID;
+ case legacy_hal::NAN_STATUS_INVALID_NDP_ID:
+ return NanStatusType::INVALID_NDP_ID;
+ case legacy_hal::NAN_STATUS_NAN_NOT_ALLOWED:
+ return NanStatusType::NAN_NOT_ALLOWED;
+ case legacy_hal::NAN_STATUS_NO_OTA_ACK:
+ return NanStatusType::NO_OTA_ACK;
+ case legacy_hal::NAN_STATUS_ALREADY_ENABLED:
+ return NanStatusType::ALREADY_ENABLED;
+ case legacy_hal::NAN_STATUS_FOLLOWUP_QUEUE_FULL:
+ return NanStatusType::FOLLOWUP_TX_QUEUE_FULL;
+ case legacy_hal::NAN_STATUS_UNSUPPORTED_CONCURRENCY_NAN_DISABLED:
+ return NanStatusType::UNSUPPORTED_CONCURRENCY_NAN_DISABLED;
+ }
+ CHECK(false);
}
bool convertHidlNanEnableRequestToLegacy(
@@ -931,7 +1033,7 @@
memcpy(legacy_request->service_name, hidl_request.baseConfigs.serviceName.data(),
legacy_request->service_name_len);
legacy_request->publish_match_indicator =
- (legacy_hal::NanMatchAlg) hidl_request.baseConfigs.discoveryMatchIndicator;
+ convertHidlNanMatchAlgToLegacy(hidl_request.baseConfigs.discoveryMatchIndicator);
legacy_request->service_specific_info_len = hidl_request.baseConfigs.serviceSpecificInfo.size();
if (legacy_request->service_specific_info_len > NAN_MAX_SERVICE_SPECIFIC_INFO_LEN) {
LOG(ERROR) << "convertHidlNanPublishRequestToLegacy: service_specific_info_len too large";
@@ -1018,8 +1120,8 @@
legacy_request->ranging_auto_response = hidl_request.baseConfigs.rangingRequired ?
legacy_hal::NAN_RANGING_AUTO_RESPONSE_ENABLE : legacy_hal::NAN_RANGING_AUTO_RESPONSE_DISABLE;
legacy_request->sdea_params.range_report = legacy_hal::NAN_DISABLE_RANGE_REPORT;
- legacy_request->publish_type = (legacy_hal::NanPublishType) hidl_request.publishType;
- legacy_request->tx_type = (legacy_hal::NanTxType) hidl_request.txType;
+ legacy_request->publish_type = convertHidlNanPublishTypeToLegacy(hidl_request.publishType);
+ legacy_request->tx_type = convertHidlNanTxTypeToLegacy(hidl_request.txType);
legacy_request->service_responder_policy = hidl_request.autoAcceptDataPathRequests ?
legacy_hal::NAN_SERVICE_ACCEPT_POLICY_ALL : legacy_hal::NAN_SERVICE_ACCEPT_POLICY_NONE;
@@ -1047,7 +1149,7 @@
memcpy(legacy_request->service_name, hidl_request.baseConfigs.serviceName.data(),
legacy_request->service_name_len);
legacy_request->subscribe_match_indicator =
- (legacy_hal::NanMatchAlg) hidl_request.baseConfigs.discoveryMatchIndicator;
+ convertHidlNanMatchAlgToLegacy(hidl_request.baseConfigs.discoveryMatchIndicator);
legacy_request->service_specific_info_len = hidl_request.baseConfigs.serviceSpecificInfo.size();
if (legacy_request->service_specific_info_len > NAN_MAX_SERVICE_SPECIFIC_INFO_LEN) {
LOG(ERROR) << "convertHidlNanSubscribeRequestToLegacy: service_specific_info_len too large";
@@ -1134,8 +1236,8 @@
legacy_request->ranging_auto_response = hidl_request.baseConfigs.rangingRequired ?
legacy_hal::NAN_RANGING_AUTO_RESPONSE_ENABLE : legacy_hal::NAN_RANGING_AUTO_RESPONSE_DISABLE;
legacy_request->sdea_params.range_report = legacy_hal::NAN_DISABLE_RANGE_REPORT;
- legacy_request->subscribe_type = (legacy_hal::NanSubscribeType) hidl_request.subscribeType;
- legacy_request->serviceResponseFilter = (legacy_hal::NanSRFType) hidl_request.srfType;
+ legacy_request->subscribe_type = convertHidlNanSubscribeTypeToLegacy(hidl_request.subscribeType);
+ legacy_request->serviceResponseFilter = convertHidlNanSrfTypeToLegacy(hidl_request.srfType);
legacy_request->serviceResponseInclude = hidl_request.srfRespondIfInAddressSet ?
legacy_hal::NAN_SRF_INCLUDE_RESPOND : legacy_hal::NAN_SRF_INCLUDE_DO_NOT_RESPOND;
legacy_request->useServiceResponseFilter = hidl_request.shouldUseSrf ?
@@ -1295,7 +1397,7 @@
legacy_request->requestor_instance_id = hidl_request.peerId;
memcpy(legacy_request->peer_disc_mac_addr, hidl_request.peerDiscMacAddr.data(), 6);
legacy_request->channel_request_type =
- (legacy_hal::NanDataPathChannelCfg) hidl_request.channelRequestType;
+ convertHidlNanDataPathChannelCfgToLegacy(hidl_request.channelRequestType);
legacy_request->channel = hidl_request.channel;
strcpy(legacy_request->ndp_iface, hidl_request.ifaceName.c_str());
legacy_request->ndp_cfg.security_cfg = (hidl_request.securityConfig.securityType
diff --git a/wifi/1.0/default/wifi_chip.cpp b/wifi/1.0/default/wifi_chip.cpp
index 9c41a40..319e126 100644
--- a/wifi/1.0/default/wifi_chip.cpp
+++ b/wifi/1.0/default/wifi_chip.cpp
@@ -855,7 +855,8 @@
for (const auto& callback : shared_ptr_this->getEventCallbacks()) {
if (!callback->onDebugRingBufferDataAvailable(hidl_status, data).isOk()) {
LOG(ERROR) << "Failed to invoke onDebugRingBufferDataAvailable"
- << " callback";
+ << " callback on: " << toString(callback);
+
}
}
};
diff --git a/wifi/supplicant/1.0/vts/Android.mk b/wifi/supplicant/1.0/vts/Android.mk
new file mode 100644
index 0000000..6361f9b
--- /dev/null
+++ b/wifi/supplicant/1.0/vts/Android.mk
@@ -0,0 +1,2 @@
+LOCAL_PATH := $(call my-dir)
+include $(call all-makefiles-under,$(LOCAL_PATH))
diff --git a/wifi/supplicant/1.0/vts/functional/supplicant_hidl_test_utils.cpp b/wifi/supplicant/1.0/vts/functional/supplicant_hidl_test_utils.cpp
index 1fcfc8c..df4bfa9 100644
--- a/wifi/supplicant/1.0/vts/functional/supplicant_hidl_test_utils.cpp
+++ b/wifi/supplicant/1.0/vts/functional/supplicant_hidl_test_utils.cpp
@@ -136,14 +136,14 @@
};
void stopWifiFramework() {
- ASSERT_EQ(std::system("svc wifi disable"), 0);
+ ASSERT_EQ(std::system("stop"), 0);
// TODO: Use some other mechanism to wait for the framework to
// finish disabling.
sleep(5);
}
void startWifiFramework() {
- ASSERT_EQ(std::system("svc wifi enable"), 0);
+ ASSERT_EQ(std::system("start"), 0);
// These tests don't care whether the framework
// finished enabling or not.
}
diff --git a/wifi/supplicant/1.0/vts/functional/supplicant_sta_iface_hidl_test.cpp b/wifi/supplicant/1.0/vts/functional/supplicant_sta_iface_hidl_test.cpp
index c2a58b6..5abf4e0 100644
--- a/wifi/supplicant/1.0/vts/functional/supplicant_sta_iface_hidl_test.cpp
+++ b/wifi/supplicant/1.0/vts/functional/supplicant_sta_iface_hidl_test.cpp
@@ -104,11 +104,13 @@
}
Return<void> onDisconnected(const hidl_array<uint8_t, 6>& /* bssid */,
bool /* locallyGenerated */,
- uint32_t /* reasonCode */) override {
+ ISupplicantStaIfaceCallback::ReasonCode
+ /* reasonCode */) override {
return Void();
}
Return<void> onAssociationRejected(
- const hidl_array<uint8_t, 6>& /* bssid */, uint32_t /* statusCode */,
+ const hidl_array<uint8_t, 6>& /* bssid */,
+ ISupplicantStaIfaceCallback::StatusCode /* statusCode */,
bool /*timedOut */) override {
return Void();
}
@@ -116,6 +118,11 @@
const hidl_array<uint8_t, 6>& /* bssid */) override {
return Void();
}
+ Return<void> onBssidChanged(
+ ISupplicantStaIfaceCallback::BssidChangeReason /* reason */,
+ const hidl_array<uint8_t, 6>& /* bssid */) override {
+ return Void();
+ }
Return<void> onEapFailure() override { return Void(); }
Return<void> onWpsEventSuccess() override { return Void(); }
Return<void> onWpsEventFail(