Merge "Post-O. Move VMS property to hal 2.1."
diff --git a/audio/2.0/default/StreamOut.cpp b/audio/2.0/default/StreamOut.cpp
index 6ccdbcd..cdc8ded 100644
--- a/audio/2.0/default/StreamOut.cpp
+++ b/audio/2.0/default/StreamOut.cpp
@@ -79,6 +79,10 @@
ssize_t writeResult = mStream->write(mStream, &mBuffer[0], availToRead);
if (writeResult >= 0) {
mStatus.reply.written = writeResult;
+ // Diagnostics of the cause of b/35813113.
+ ALOGE_IF(writeResult > availToRead,
+ "legacy hal reports more bytes written than asked for: %lld > %lld",
+ (long long)writeResult, (long long)availToRead);
} else {
mStatus.retval = Stream::analyzeStatus("write", writeResult);
}
diff --git a/audio/effect/2.0/vts/functional/Android.bp b/audio/effect/2.0/vts/functional/Android.bp
index df80dba..a162534 100644
--- a/audio/effect/2.0/vts/functional/Android.bp
+++ b/audio/effect/2.0/vts/functional/Android.bp
@@ -16,7 +16,6 @@
cc_test {
name: "VtsHalAudioEffectV2_0TargetTest",
- gtest: true,
srcs: ["VtsHalAudioEffectV2_0TargetTest.cpp"],
shared_libs: [
"libbase",
@@ -28,7 +27,7 @@
"libutils",
"android.hardware.audio.effect@2.0",
],
- static_libs: ["libgtest"],
+ static_libs: ["VtsHalHidlTargetBaseTest"],
cflags: [
"-O0",
"-g",
diff --git a/audio/effect/2.0/vts/functional/VtsHalAudioEffectV2_0TargetTest.cpp b/audio/effect/2.0/vts/functional/VtsHalAudioEffectV2_0TargetTest.cpp
index 6e050c6..6c5b980 100644
--- a/audio/effect/2.0/vts/functional/VtsHalAudioEffectV2_0TargetTest.cpp
+++ b/audio/effect/2.0/vts/functional/VtsHalAudioEffectV2_0TargetTest.cpp
@@ -21,7 +21,7 @@
#include <android/hardware/audio/effect/2.0/IEffectsFactory.h>
#include <android/hardware/audio/effect/2.0/types.h>
-#include <gtest/gtest.h>
+#include <VtsHalHidlTargetBaseTest.h>
using ::android::hardware::audio::common::V2_0::Uuid;
using ::android::hardware::audio::effect::V2_0::EffectDescriptor;
@@ -35,10 +35,10 @@
using ::android::sp;
// The main test class for Audio Effect HIDL HAL.
-class AudioEffectHidlTest : public ::testing::Test {
+class AudioEffectHidlTest : public ::testing::VtsHalHidlTargetBaseTest {
public:
virtual void SetUp() override {
- effectsFactory = IEffectsFactory::getService();
+ effectsFactory = ::testing::VtsHalHidlTargetBaseTest::getService<IEffectsFactory>();
ASSERT_NE(effectsFactory, nullptr);
}
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 02f8438..9591689 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
@@ -28,6 +28,11 @@
namespace impl {
+const VehicleProperty kHvacPowerProperties[] = {
+ VehicleProperty::HVAC_FAN_SPEED,
+ VehicleProperty::HVAC_FAN_DIRECTION,
+};
+
const VehiclePropConfig kVehicleProperties[] = {
{
.prop = toInt(VehicleProperty::INFO_MAKE),
@@ -36,10 +41,37 @@
},
{
+ .prop = toInt(VehicleProperty::PERF_VEHICLE_SPEED),
+ .access = VehiclePropertyAccess::READ,
+ .changeMode = VehiclePropertyChangeMode::ON_CHANGE,
+ },
+
+ {
+ .prop = toInt(VehicleProperty::CURRENT_GEAR),
+ .access = VehiclePropertyAccess::READ,
+ .changeMode = VehiclePropertyChangeMode::ON_CHANGE,
+ },
+
+ {
+ .prop = toInt(VehicleProperty::PARKING_BRAKE_ON),
+ .access = VehiclePropertyAccess::READ,
+ .changeMode = VehiclePropertyChangeMode::ON_CHANGE,
+ },
+
+ {
+ .prop = toInt(VehicleProperty::FUEL_LEVEL_LOW),
+ .access = VehiclePropertyAccess::READ,
+ .changeMode = VehiclePropertyChangeMode::ON_CHANGE,
+ },
+
+ {
.prop = toInt(VehicleProperty::HVAC_POWER_ON),
.access = VehiclePropertyAccess::READ_WRITE,
.changeMode = VehiclePropertyChangeMode::ON_CHANGE,
- .supportedAreas = toInt(VehicleAreaZone::ROW_1)
+ .supportedAreas = toInt(VehicleAreaZone::ROW_1),
+ // TODO(bryaneyler): Ideally, this is generated dynamically from
+ // kHvacPowerProperties.
+ .configString = "0x12400500,0x12400501" // HVAC_FAN_SPEED,HVAC_FAN_DIRECTION
},
{
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
index f020ba7..7a66c04 100644
--- a/automotive/vehicle/2.0/default/impl/vhal_v2_0/DefaultVehicleHal.cpp
+++ b/automotive/vehicle/2.0/default/impl/vhal_v2_0/DefaultVehicleHal.cpp
@@ -102,9 +102,9 @@
{
std::lock_guard<std::mutex> lock(mPropsMutex);
- for (auto& propVal : mProps) {
+ for (auto& prop : mProps) {
emulator::VehiclePropValue* protoVal = respMsg.add_value();
- populateProtoVehiclePropValue(protoVal, propVal.get());
+ populateProtoVehiclePropValue(protoVal, prop.second.get());
}
}
}
@@ -172,10 +172,9 @@
areaId = 0;
}
- for (auto& prop : mProps) {
- if ((prop->prop == propId) && (prop->areaId == areaId)) {
- return prop.get();
- }
+ 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", __FUNCTION__, propId, areaId);
return nullptr;
@@ -361,6 +360,18 @@
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;
@@ -485,6 +496,18 @@
StatusCode status;
switch (propId) {
default:
+ if (mHvacPowerProps.find(VehicleProperty(propId)) !=
+ mHvacPowerProps.end()) {
+ auto prop = mProps.find(
+ std::make_pair(toInt(VehicleProperty::HVAC_POWER_ON), 0));
+ if (prop != mProps.end()) {
+ if (prop->second->value.int32Values.size() == 1 &&
+ prop->second->value.int32Values[0] == 0) {
+ status = StatusCode::NOT_AVAILABLE;
+ break;
+ }
+ }
+ }
status = updateProperty(propValue);
if (status == StatusCode::OK) {
// Send property update to emulator
@@ -506,6 +529,10 @@
// 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();
@@ -567,7 +594,7 @@
prop->areaId = curArea;
prop->prop = cfg.prop;
setDefaultValue(prop.get());
- mProps.push_back(std::move(prop));
+ mProps[std::make_pair(prop->prop, prop->areaId)] = std::move(prop);
} while (supportedAreas != 0);
}
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
index b4ba8ba..1ad8702 100644
--- a/automotive/vehicle/2.0/default/impl/vhal_v2_0/DefaultVehicleHal.h
+++ b/automotive/vehicle/2.0/default/impl/vhal_v2_0/DefaultVehicleHal.h
@@ -17,9 +17,11 @@
#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>
@@ -93,9 +95,11 @@
void txMsg(emulator::EmulatorMessage& txMsg);
StatusCode updateProperty(const VehiclePropValue& propValue);
private:
- // TODO: Use a hashtable to support indexing props
- std::vector<std::unique_ptr<VehiclePropValue>> mProps;
+ std::map<
+ std::pair<int32_t /*VehicleProperty*/, int32_t /*areaId*/>,
+ std::unique_ptr<VehiclePropValue>> mProps;
std::atomic<int> mExit;
+ std::unordered_set<VehicleProperty> mHvacPowerProps;
std::mutex mPropsMutex;
std::thread mThread;
std::unique_ptr<CommBase> mComm{nullptr};
diff --git a/biometrics/fingerprint/2.1/vts/functional/Android.bp b/biometrics/fingerprint/2.1/vts/functional/Android.bp
index ee1a9fe..63115c1 100644
--- a/biometrics/fingerprint/2.1/vts/functional/Android.bp
+++ b/biometrics/fingerprint/2.1/vts/functional/Android.bp
@@ -16,7 +16,6 @@
cc_test {
name: "VtsHalBiometricsFingerprintV2_1TargetTest",
- gtest: true,
srcs: ["VtsHalBiometricsFingerprintV2_1TargetTest.cpp"],
shared_libs: [
"libbase",
@@ -27,7 +26,7 @@
"libutils",
"android.hardware.biometrics.fingerprint@2.1",
],
- static_libs: ["libgtest"],
+ static_libs: ["VtsHalHidlTargetBaseTest"],
cflags: [
"-O0",
"-g",
diff --git a/biometrics/fingerprint/2.1/vts/functional/VtsHalBiometricsFingerprintV2_1TargetTest.cpp b/biometrics/fingerprint/2.1/vts/functional/VtsHalBiometricsFingerprintV2_1TargetTest.cpp
index 9138000..87d70bb 100644
--- a/biometrics/fingerprint/2.1/vts/functional/VtsHalBiometricsFingerprintV2_1TargetTest.cpp
+++ b/biometrics/fingerprint/2.1/vts/functional/VtsHalBiometricsFingerprintV2_1TargetTest.cpp
@@ -20,7 +20,7 @@
#include <android/hardware/biometrics/fingerprint/2.1/IBiometricsFingerprint.h>
#include <android/hardware/biometrics/fingerprint/2.1/IBiometricsFingerprintClientCallback.h>
#include <chrono>
-#include <gtest/gtest.h>
+#include <VtsHalHidlTargetBaseTest.h>
#include <hidl/HidlSupport.h>
#include <hidl/HidlTransportSupport.h>
@@ -34,7 +34,7 @@
#define SERVICE_NAME "fingerprint_hal"
-class FingerprintHidlTest : public ::testing::Test,
+class FingerprintHidlTest : public ::testing::VtsHalHidlTargetBaseTest,
public IBiometricsFingerprintClientCallback {
protected:
@@ -49,7 +49,7 @@
err(FingerprintError::ERROR_NO_ERROR), threshold(1) {}
virtual void SetUp() override {
- service = IBiometricsFingerprint::getService(SERVICE_NAME);
+ service = ::testing::VtsHalHidlTargetBaseTest::getService<IBiometricsFingerprint>(SERVICE_NAME);
ASSERT_NE(service, nullptr);
clearErr();
diff --git a/bluetooth/1.0/vts/functional/VtsHalBluetoothV1_0TargetTest.cpp b/bluetooth/1.0/vts/functional/VtsHalBluetoothV1_0TargetTest.cpp
index ce15875..c8c7cb5 100644
--- a/bluetooth/1.0/vts/functional/VtsHalBluetoothV1_0TargetTest.cpp
+++ b/bluetooth/1.0/vts/functional/VtsHalBluetoothV1_0TargetTest.cpp
@@ -121,7 +121,7 @@
public:
virtual void SetUp() override {
// currently test passthrough mode only
- bluetooth = testing::VtsHalHidlTargetBaseTest::getService<IBluetoothHci>();
+ bluetooth = ::testing::VtsHalHidlTargetBaseTest::getService<IBluetoothHci>();
ASSERT_NE(bluetooth, nullptr);
ALOGI("%s: getService() for bluetooth is %s", __func__,
bluetooth->isRemote() ? "remote" : "local");
diff --git a/boot/1.0/vts/functional/Android.bp b/boot/1.0/vts/functional/Android.bp
index 5081162..7643e1d 100644
--- a/boot/1.0/vts/functional/Android.bp
+++ b/boot/1.0/vts/functional/Android.bp
@@ -16,7 +16,6 @@
cc_test {
name: "VtsHalBootV1_0TargetTest",
- gtest: true,
srcs: ["VtsHalBootV1_0TargetTest.cpp"],
shared_libs: [
"libbase",
@@ -27,7 +26,7 @@
"libutils",
"android.hardware.boot@1.0",
],
- static_libs: ["libgtest"],
+ static_libs: ["VtsHalHidlTargetBaseTest"],
cflags: [
"-O0",
"-g",
diff --git a/boot/1.0/vts/functional/VtsHalBootV1_0TargetTest.cpp b/boot/1.0/vts/functional/VtsHalBootV1_0TargetTest.cpp
index 36142df..49eefb1 100644
--- a/boot/1.0/vts/functional/VtsHalBootV1_0TargetTest.cpp
+++ b/boot/1.0/vts/functional/VtsHalBootV1_0TargetTest.cpp
@@ -21,7 +21,7 @@
#include <android/hardware/boot/1.0/IBootControl.h>
-#include <gtest/gtest.h>
+#include <VtsHalHidlTargetBaseTest.h>
using ::android::hardware::boot::V1_0::IBootControl;
using ::android::hardware::boot::V1_0::CommandResult;
@@ -32,10 +32,10 @@
using ::android::sp;
// The main test class for the Boot HIDL HAL.
-class BootHidlTest : public ::testing::Test {
+class BootHidlTest : public ::testing::VtsHalHidlTargetBaseTest {
public:
virtual void SetUp() override {
- boot = IBootControl::getService();
+ boot = ::testing::VtsHalHidlTargetBaseTest::getService<IBootControl>();
ASSERT_NE(boot, nullptr);
}
diff --git a/broadcastradio/1.0/vts/functional/Android.bp b/broadcastradio/1.0/vts/functional/Android.bp
index d608877..25a6e22 100644
--- a/broadcastradio/1.0/vts/functional/Android.bp
+++ b/broadcastradio/1.0/vts/functional/Android.bp
@@ -16,7 +16,6 @@
cc_test {
name: "VtsHalBroadcastradioV1_0TargetTest",
- gtest: true,
srcs: ["VtsHalBroadcastradioV1_0TargetTest.cpp"],
shared_libs: [
"libbase",
@@ -28,7 +27,7 @@
"libutils",
"android.hardware.broadcastradio@1.0",
],
- static_libs: ["libgtest"],
+ static_libs: ["VtsHalHidlTargetBaseTest"],
cflags: [
"-O0",
"-g",
diff --git a/broadcastradio/1.0/vts/functional/VtsHalBroadcastradioV1_0TargetTest.cpp b/broadcastradio/1.0/vts/functional/VtsHalBroadcastradioV1_0TargetTest.cpp
index 28a913c..4212729 100644
--- a/broadcastradio/1.0/vts/functional/VtsHalBroadcastradioV1_0TargetTest.cpp
+++ b/broadcastradio/1.0/vts/functional/VtsHalBroadcastradioV1_0TargetTest.cpp
@@ -15,7 +15,7 @@
*/
#define LOG_TAG "BroadcastRadioHidlHalTest"
-#include <gtest/gtest.h>
+#include <VtsHalHidlTargetBaseTest.h>
#include <android-base/logging.h>
#include <cutils/native_handle.h>
#include <cutils/properties.h>
@@ -50,20 +50,11 @@
// The main test class for Broadcast Radio HIDL HAL.
-class BroadcastRadioHidlTest : public ::testing::Test {
+class BroadcastRadioHidlTest : public ::testing::VtsHalHidlTargetBaseTest {
protected:
virtual void SetUp() override {
- bool getStub = false;
- char getsubProperty[PROPERTY_VALUE_MAX];
- if (property_get("vts.hidl.get_stub", getsubProperty, "") > 0) {
- if (!strcmp(getsubProperty, "true") ||
- !strcmp(getsubProperty, "True") ||
- !strcmp(getsubProperty, "1")) {
- getStub = true;
- }
- }
sp<IBroadcastRadioFactory> factory =
- IBroadcastRadioFactory::getService(getStub);
+ ::testing::VtsHalHidlTargetBaseTest::getService<IBroadcastRadioFactory>();
if (factory != 0) {
factory->connectModule(Class::AM_FM,
[&](Result retval, const ::android::sp<IBroadcastRadio>& result) {
@@ -74,7 +65,6 @@
}
mTunerCallback = new MyCallback(this);
ASSERT_NE(nullptr, mRadio.get());
- ASSERT_EQ(!getStub, mRadio->isRemote());
ASSERT_NE(nullptr, mTunerCallback.get());
}
diff --git a/broadcastradio/1.1/vts/functional/Android.bp b/broadcastradio/1.1/vts/functional/Android.bp
index e10ddab..6d66f14 100644
--- a/broadcastradio/1.1/vts/functional/Android.bp
+++ b/broadcastradio/1.1/vts/functional/Android.bp
@@ -16,7 +16,6 @@
cc_test {
name: "VtsHalBroadcastradioV1_1TargetTest",
- gtest: true,
srcs: ["VtsHalBroadcastradioV1_1TargetTest.cpp"],
shared_libs: [
"libbase",
@@ -29,7 +28,7 @@
"android.hardware.broadcastradio@1.0",
"android.hardware.broadcastradio@1.1",
],
- static_libs: ["libgtest"],
+ static_libs: ["VtsHalHidlTargetBaseTest"],
cflags: [
"-O0",
"-g",
diff --git a/broadcastradio/1.1/vts/functional/VtsHalBroadcastradioV1_1TargetTest.cpp b/broadcastradio/1.1/vts/functional/VtsHalBroadcastradioV1_1TargetTest.cpp
index 873a10b..b980d31 100644
--- a/broadcastradio/1.1/vts/functional/VtsHalBroadcastradioV1_1TargetTest.cpp
+++ b/broadcastradio/1.1/vts/functional/VtsHalBroadcastradioV1_1TargetTest.cpp
@@ -15,7 +15,7 @@
*/
#define LOG_TAG "BroadcastRadioHidlHalTest"
-#include <gtest/gtest.h>
+#include <VtsHalHidlTargetBaseTest.h>
#include <android-base/logging.h>
#include <cutils/native_handle.h>
#include <cutils/properties.h>
@@ -52,19 +52,10 @@
// The main test class for Broadcast Radio HIDL HAL.
-class BroadcastRadioHidlTest : public ::testing::Test {
+class BroadcastRadioHidlTest : public ::testing::VtsHalHidlTargetBaseTest {
protected:
virtual void SetUp() override {
- bool getStub = false;
- char getsubProperty[PROPERTY_VALUE_MAX];
- if (property_get("vts.hidl.get_stub", getsubProperty, "") > 0) {
- if (!strcmp(getsubProperty, "true") ||
- !strcmp(getsubProperty, "True") ||
- !strcmp(getsubProperty, "1")) {
- getStub = true;
- }
- }
- auto factory = IBroadcastRadioFactory::getService(getStub);
+ auto factory = ::testing::VtsHalHidlTargetBaseTest::getService<IBroadcastRadioFactory>();
if (factory != 0) {
factory->connectModule(Class::AM_FM,
[&](Result retval, const ::android::sp<IBroadcastRadio>& result) {
@@ -75,7 +66,6 @@
}
mTunerCallback = new MyCallback(this);
ASSERT_NE(nullptr, mRadio.get());
- ASSERT_EQ(!getStub, mRadio->isRemote());
ASSERT_NE(nullptr, mTunerCallback.get());
}
diff --git a/camera/Android.bp b/camera/Android.bp
index e379e49..3869766 100644
--- a/camera/Android.bp
+++ b/camera/Android.bp
@@ -3,6 +3,7 @@
"common/1.0",
"common/1.0/default",
"device/1.0",
+ "device/1.0/default",
"device/3.2",
"device/3.2/default",
"metadata/3.2",
diff --git a/camera/common/1.0/default/Android.bp b/camera/common/1.0/default/Android.bp
index af0ff6e..9ec266c 100644
--- a/camera/common/1.0/default/Android.bp
+++ b/camera/common/1.0/default/Android.bp
@@ -1,6 +1,10 @@
cc_library_static {
name: "android.hardware.camera.common@1.0-helper",
- srcs: ["CameraModule.cpp", "CameraMetadata.cpp", "VendorTagDescriptor.cpp"],
+ srcs: [
+ "CameraModule.cpp",
+ "CameraMetadata.cpp",
+ "VendorTagDescriptor.cpp",
+ "HandleImporter.cpp"],
cflags: [
"-Werror",
"-Wextra",
@@ -13,3 +17,4 @@
include_dirs: ["system/media/private/camera/include"],
export_include_dirs : ["include"]
}
+
diff --git a/camera/common/1.0/default/HandleImporter.cpp b/camera/common/1.0/default/HandleImporter.cpp
new file mode 100644
index 0000000..dee2973
--- /dev/null
+++ b/camera/common/1.0/default/HandleImporter.cpp
@@ -0,0 +1,190 @@
+/*
+ * 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 "HandleImporter"
+#include <utils/Log.h>
+#include "HandleImporter.h"
+
+namespace android {
+namespace hardware {
+namespace camera {
+namespace common {
+namespace V1_0 {
+namespace helper {
+
+HandleImporter HandleImporter::sHandleImporter;
+
+HandleImporter& HandleImporter::getInstance() {
+ sHandleImporter.initialize();
+ return sHandleImporter;
+}
+
+bool HandleImporter::initialize() {
+ // allow only one client
+ if (mInitialized) {
+ return false;
+ }
+
+ if (!openGralloc()) {
+ return false;
+ }
+
+ mInitialized = true;
+ return true;
+}
+
+void HandleImporter::cleanup() {
+ if (!mInitialized) {
+ return;
+ }
+
+ closeGralloc();
+ mInitialized = false;
+}
+
+// In IComposer, any buffer_handle_t is owned by the caller and we need to
+// make a clone for hwcomposer2. We also need to translate empty handle
+// to nullptr. This function does that, in-place.
+bool HandleImporter::importBuffer(buffer_handle_t& handle) {
+ if (!handle->numFds && !handle->numInts) {
+ handle = nullptr;
+ return true;
+ }
+
+ buffer_handle_t clone = cloneBuffer(handle);
+ if (!clone) {
+ return false;
+ }
+
+ handle = clone;
+ return true;
+}
+
+void HandleImporter::freeBuffer(buffer_handle_t handle) {
+ if (!handle) {
+ return;
+ }
+
+ releaseBuffer(handle);
+}
+
+bool HandleImporter::importFence(const native_handle_t* handle, int& fd) {
+ if (handle == nullptr || handle->numFds == 0) {
+ fd = -1;
+ } else if (handle->numFds == 1) {
+ fd = dup(handle->data[0]);
+ if (fd < 0) {
+ ALOGE("failed to dup fence fd %d", handle->data[0]);
+ return false;
+ }
+ } else {
+ ALOGE("invalid fence handle with %d file descriptors",
+ handle->numFds);
+ return false;
+ }
+
+ return true;
+}
+
+void HandleImporter::closeFence(int fd) {
+ if (fd >= 0) {
+ close(fd);
+ }
+}
+
+bool HandleImporter::openGralloc() {
+ const hw_module_t* module;
+ int err = hw_get_module(GRALLOC_HARDWARE_MODULE_ID, &module);
+ if (err) {
+ ALOGE("failed to get gralloc module");
+ return false;
+ }
+
+ uint8_t major = (module->module_api_version >> 8) & 0xff;
+ if (major > 1) {
+ ALOGE("unknown gralloc module major version %d", major);
+ return false;
+ }
+
+ if (major == 1) {
+ err = gralloc1_open(module, &mDevice);
+ if (err) {
+ ALOGE("failed to open gralloc1 device");
+ return false;
+ }
+
+ mRetain = reinterpret_cast<GRALLOC1_PFN_RETAIN>(
+ mDevice->getFunction(mDevice, GRALLOC1_FUNCTION_RETAIN));
+ mRelease = reinterpret_cast<GRALLOC1_PFN_RELEASE>(
+ mDevice->getFunction(mDevice, GRALLOC1_FUNCTION_RELEASE));
+ if (!mRetain || !mRelease) {
+ ALOGE("invalid gralloc1 device");
+ gralloc1_close(mDevice);
+ return false;
+ }
+ } else {
+ mModule = reinterpret_cast<const gralloc_module_t*>(module);
+ }
+
+ return true;
+}
+
+void HandleImporter::closeGralloc() {
+ if (mDevice) {
+ gralloc1_close(mDevice);
+ }
+}
+
+buffer_handle_t HandleImporter::cloneBuffer(buffer_handle_t handle) {
+ native_handle_t* clone = native_handle_clone(handle);
+ if (!clone) {
+ ALOGE("failed to clone buffer %p", handle);
+ return nullptr;
+ }
+
+ bool err;
+ if (mDevice) {
+ err = (mRetain(mDevice, clone) != GRALLOC1_ERROR_NONE);
+ } else {
+ err = (mModule->registerBuffer(mModule, clone) != 0);
+ }
+
+ if (err) {
+ ALOGE("failed to retain/register buffer %p", clone);
+ native_handle_close(clone);
+ native_handle_delete(clone);
+ return nullptr;
+ }
+
+ return clone;
+}
+
+void HandleImporter::releaseBuffer(buffer_handle_t handle) {
+ if (mDevice) {
+ mRelease(mDevice, handle);
+ } else {
+ mModule->unregisterBuffer(mModule, handle);
+ }
+ native_handle_close(handle);
+ native_handle_delete(const_cast<native_handle_t*>(handle));
+}
+
+} // namespace helper
+} // namespace V1_0
+} // namespace common
+} // namespace camera
+} // namespace hardware
+} // namespace android
diff --git a/camera/common/1.0/default/include/CameraModule.h b/camera/common/1.0/default/include/CameraModule.h
index 68d4f90..9fbfbd5 100644
--- a/camera/common/1.0/default/include/CameraModule.h
+++ b/camera/common/1.0/default/include/CameraModule.h
@@ -20,6 +20,7 @@
#include <hardware/camera.h>
#include <utils/Mutex.h>
#include <utils/KeyedVector.h>
+#include <utils/RefBase.h>
#include "CameraMetadata.h"
diff --git a/camera/common/1.0/default/include/HandleImporter.h b/camera/common/1.0/default/include/HandleImporter.h
new file mode 100644
index 0000000..def8982
--- /dev/null
+++ b/camera/common/1.0/default/include/HandleImporter.h
@@ -0,0 +1,73 @@
+/*
+ * 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 CAMERA_COMMON_1_0_HANDLEIMPORTED_H
+#define CAMERA_COMMON_1_0_HANDLEIMPORTED_H
+
+#include <hardware/gralloc.h>
+#include <hardware/gralloc1.h>
+#include <system/window.h>
+
+namespace android {
+namespace hardware {
+namespace camera {
+namespace common {
+namespace V1_0 {
+namespace helper {
+
+// Borrowed from graphics HAL. Use this until gralloc mapper HAL is working
+class HandleImporter {
+public:
+ static HandleImporter& getInstance();
+
+ // In IComposer, any buffer_handle_t is owned by the caller and we need to
+ // make a clone for hwcomposer2. We also need to translate empty handle
+ // to nullptr. This function does that, in-place.
+ bool importBuffer(buffer_handle_t& handle);
+ void freeBuffer(buffer_handle_t handle);
+ bool importFence(const native_handle_t* handle, int& fd);
+ void closeFence(int fd);
+
+private:
+
+ HandleImporter() : mInitialized(false) {}
+ bool initialize();
+ void cleanup();
+ bool openGralloc();
+ void closeGralloc();
+ buffer_handle_t cloneBuffer(buffer_handle_t handle);
+ void releaseBuffer(buffer_handle_t handle);
+
+ static HandleImporter sHandleImporter;
+ bool mInitialized;
+
+ // gralloc1
+ gralloc1_device_t* mDevice;
+ GRALLOC1_PFN_RETAIN mRetain;
+ GRALLOC1_PFN_RELEASE mRelease;
+
+ // gralloc0
+ const gralloc_module_t* mModule;
+};
+
+} // namespace helper
+} // namespace V1_0
+} // namespace common
+} // namespace camera
+} // namespace hardware
+} // namespace android
+
+#endif // CAMERA_COMMON_1_0_HANDLEIMPORTED_H
\ No newline at end of file
diff --git a/camera/device/1.0/ICameraDevice.hal b/camera/device/1.0/ICameraDevice.hal
index d232a67..4a3a406 100644
--- a/camera/device/1.0/ICameraDevice.hal
+++ b/camera/device/1.0/ICameraDevice.hal
@@ -298,7 +298,8 @@
recordingEnabled() generates (bool enabled);
/**
- * Release a record frame previously returned by CAMERA_MSG_VIDEO_FRAME.
+ * Release a record frame previously returned by CAMERA_MSG_VIDEO_FRAME in
+ * dataCallbackTimestamp.
*
* 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
@@ -306,10 +307,26 @@
* disableMsgType(CAMERA_MSG_VIDEO_FRAME), it is the camera HAL's
* responsibility to manage the life-cycle of the video recording frames.
*
- * @param data The memory buffer to release a recording frame from.
+ * @param memId The memory buffer to release a recording frame from.
* @param bufferIndex The specific buffer index to return to the HAL.
*/
- releaseRecordingFrame(MemoryId data, uint32_t bufferIndex);
+ releaseRecordingFrame(MemoryId memId, uint32_t bufferIndex);
+
+ /**
+ * Release a record frame previously returned by CAMERA_MSG_VIDEO_FRAME in
+ * handleCallbackTimestamp.
+ *
+ * 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 memId The memory buffer to release a recording frame from.
+ * @param bufferIndex The specific buffer index to return to the HAL.
+ * @param frame The handle for a released video frame
+ */
+ releaseRecordingFrameHandle(MemoryId memId, uint32_t bufferIndex, handle frame);
/**
* Start auto focus.
@@ -352,14 +369,14 @@
/**
* Set the camera parameters.
*
- * @param parms The parameter string, consisting of
+ * @param params The parameter string, consisting of
* '<key1>=<value1>; ...;<keyN>=<valueN>'.
* @return status The status code for this operation:
* OK: Parameter update was successful
* ILLEGAL_ARGUMENT: At least one parameter was invalid or not supported
*
*/
- setParameters(string parms) generates (Status status);
+ setParameters(string params) generates (Status status);
/**
* Retrieve the camera parameters.
diff --git a/camera/device/1.0/ICameraDeviceCallback.hal b/camera/device/1.0/ICameraDeviceCallback.hal
index 97014ee..1b0db24 100644
--- a/camera/device/1.0/ICameraDeviceCallback.hal
+++ b/camera/device/1.0/ICameraDeviceCallback.hal
@@ -42,8 +42,10 @@
* @param bufferCount The number of contiguous buffers that the descriptor
* contains.
*
- * @return memId A integer identifier for this memory buffer, for use with
- * data callbacks and unregistering memory.
+ * @return memId A positive integer identifier for this memory buffer, for
+ * use with data callbacks and unregistering memory. 0 must be returned
+ * in case of error, such as if the descriptor does not contain exactly
+ * one FD.
*/
registerMemory(handle descriptor, uint32_t bufferSize, uint32_t bufferCount)
generates (MemoryId memId);
@@ -62,7 +64,8 @@
* starts.
*
*/
- dataCallback(DataCallbackMsg msgType, MemoryId data, uint32_t bufferIndex);
+ dataCallback(DataCallbackMsg msgType, MemoryId data, uint32_t bufferIndex,
+ CameraFrameMetadata metadata);
/**
* Send a buffer of image data to the camera service, with a timestamp
@@ -78,4 +81,21 @@
dataCallbackTimestamp(DataCallbackMsg msgType, MemoryId data, uint32_t bufferIndex,
int64_t timestamp);
+ /**
+ * Send a buffer of image data to the camera service, with a timestamp
+ *
+ * @param msgType The kind of image buffer data this call represents.
+ * @param handle The handle of image buffer data this call represents.
+ * @param data A memory handle to the buffer containing the data.
+ * @param bufferIndex The offset into the memory handle where the buffer
+ * starts.
+ * @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);
+
};
diff --git a/camera/device/1.0/ICameraDevicePreviewCallback.hal b/camera/device/1.0/ICameraDevicePreviewCallback.hal
index ebc7460..4c9b517 100644
--- a/camera/device/1.0/ICameraDevicePreviewCallback.hal
+++ b/camera/device/1.0/ICameraDevicePreviewCallback.hal
@@ -30,28 +30,31 @@
*
* @return status The status code for this operation. If not OK, then
* buffer and stride must not be used.
- * @return buffer A handle to the buffer to write into.
+ * @return bufferId A unique ID for the returned buffer.
+ * @return buffer A handle to the buffer to write into. Must be non-null if the bufferId has not
+ * been seen by HAL before. Must be null if the bufferId is seen before. HAL must keep track
+ * of the bufferId to actual buffer handle mapping.
* @return stride The stride between two rows of pixels in this buffer.
*/
- dequeueBuffer() generates (Status status, handle buffer, uint32_t stride);
+ dequeueBuffer() generates (Status status, uint64_t bufferId, handle buffer, uint32_t stride);
/**
* Send a filled preview buffer to its consumer.
*
- * @param buffer The handle to the preview buffer that's been filled.
+ * @param bufferId The bufferId of the preview buffer
* @return status The status code for this operation.
*/
- enqueueBuffer(handle buffer) generates (Status status);
+ enqueueBuffer(uint64_t bufferId) generates (Status status);
/**
* Return a preview buffer unfilled. This buffer must not be sent on to the
* preview consumer as a valid buffer, but may be reused as if it were
* empty.
*
- * @param buffer The handle to the preview buffer to return.
+ * @param bufferId The bufferId of the preview buffer
* @return status The status code for this operation.
*/
- cancelBuffer(handle buffer) generates (Status status);
+ cancelBuffer(uint64_t bufferId) generates (Status status);
/**
* Set the number of preview buffers needed by the HAL.
diff --git a/camera/device/1.0/default/Android.bp b/camera/device/1.0/default/Android.bp
new file mode 100644
index 0000000..1663787
--- /dev/null
+++ b/camera/device/1.0/default/Android.bp
@@ -0,0 +1,27 @@
+cc_library_shared {
+ name: "camera.device@1.0-impl",
+ srcs: [
+ "CameraDevice.cpp",
+ ],
+ shared_libs: [
+ "libhidlbase",
+ "libhidltransport",
+ "libhwbinder",
+ "libutils",
+ "android.hardware.camera.device@1.0",
+ "android.hardware.camera.common@1.0",
+ "android.hardware.graphics.allocator@2.0",
+ "android.hardware.graphics.common@1.0",
+ "android.hidl.base@1.0",
+ "libcutils",
+ "liblog",
+ "libhardware",
+ "libcamera_metadata",
+ "libbinder",
+ ],
+ static_libs: [
+ "android.hardware.camera.common@1.0-helper"
+ ],
+ export_include_dirs: ["."]
+}
+
diff --git a/camera/device/1.0/default/CameraDevice.cpp b/camera/device/1.0/default/CameraDevice.cpp
new file mode 100644
index 0000000..819525b
--- /dev/null
+++ b/camera/device/1.0/default/CameraDevice.cpp
@@ -0,0 +1,948 @@
+/*
+ * 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 "CamDev@1.0-impl"
+#include <utils/Log.h>
+#include <hardware/camera.h>
+#include <hardware/gralloc1.h>
+#include <utils/Trace.h>
+
+#include "CameraDevice_1_0.h"
+
+namespace android {
+namespace hardware {
+namespace camera {
+namespace device {
+namespace V1_0 {
+namespace implementation {
+
+using ::android::hardware::graphics::allocator::V2_0::ProducerUsage;
+using ::android::hardware::graphics::common::V1_0::PixelFormat;
+
+HandleImporter& CameraDevice::sHandleImporter = HandleImporter::getInstance();
+
+Status CameraDevice::getHidlStatus(const int& status) {
+ switch (status) {
+ case 0: return Status::OK;
+ case -ENOSYS: return Status::OPERATION_NOT_SUPPORTED;
+ case -EBUSY : return Status::CAMERA_IN_USE;
+ case -EUSERS: return Status::MAX_CAMERAS_IN_USE;
+ case -ENODEV: return Status::INTERNAL_ERROR;
+ case -EINVAL: return Status::ILLEGAL_ARGUMENT;
+ default:
+ ALOGE("%s: unknown HAL status code %d", __FUNCTION__, status);
+ return Status::INTERNAL_ERROR;
+ }
+}
+
+status_t CameraDevice::getStatusT(const Status& s) {
+ switch(s) {
+ case Status::OK:
+ return OK;
+ case Status::ILLEGAL_ARGUMENT:
+ return BAD_VALUE;
+ case Status::CAMERA_IN_USE:
+ return -EBUSY;
+ case Status::MAX_CAMERAS_IN_USE:
+ return -EUSERS;
+ case Status::METHOD_NOT_SUPPORTED:
+ return UNKNOWN_TRANSACTION;
+ case Status::OPERATION_NOT_SUPPORTED:
+ return INVALID_OPERATION;
+ case Status::CAMERA_DISCONNECTED:
+ return DEAD_OBJECT;
+ case Status::INTERNAL_ERROR:
+ return INVALID_OPERATION;
+ }
+ ALOGW("Unexpected HAL status code %d", s);
+ return INVALID_OPERATION;
+}
+
+Status CameraDevice::initStatus() const {
+ Mutex::Autolock _l(mLock);
+ Status status = Status::OK;
+ if (mInitFail) {
+ status = Status::INTERNAL_ERROR;
+ } else if (mDisconnected) {
+ status = Status::CAMERA_DISCONNECTED;
+ }
+ return status;
+}
+
+CameraDevice::CameraDevice(
+ sp<CameraModule> module, const std::string& cameraId,
+ const SortedVector<std::pair<std::string, std::string>>& cameraDeviceNames) :
+ mModule(module),
+ mCameraId(cameraId),
+ mDisconnected(false),
+ mCameraDeviceNames(cameraDeviceNames) {
+ mCameraIdInt = atoi(mCameraId.c_str());
+ // Should not reach here as provider also validate ID
+ if (mCameraIdInt < 0 || mCameraIdInt >= module->getNumberOfCameras()) {
+ ALOGE("%s: Invalid camera id: %s", __FUNCTION__, mCameraId.c_str());
+ mInitFail = true;
+ }
+
+ mDeviceVersion = mModule->getDeviceVersion(mCameraIdInt);
+ if (mDeviceVersion != CAMERA_DEVICE_API_VERSION_1_0 && !mModule->isOpenLegacyDefined()) {
+ ALOGI("%s: Camera id %s does not support HAL1.0",
+ __FUNCTION__, mCameraId.c_str());
+ mInitFail = true;
+ }
+}
+
+CameraDevice::~CameraDevice() {
+ Mutex::Autolock _l(mLock);
+ if (mDevice != nullptr) {
+ ALOGW("%s: camera %s is deleted while open", __FUNCTION__, mCameraId.c_str());
+ close();
+ }
+ mHalPreviewWindow.cleanUpCirculatingBuffers();
+}
+
+
+void CameraDevice::setConnectionStatus(bool connected) {
+ Mutex::Autolock _l(mLock);
+ mDisconnected = !connected;
+ if (mDevice == nullptr) {
+ return;
+ }
+ if (!connected) {
+ ALOGW("%s: camera %s is disconneted. Closing", __FUNCTION__, mCameraId.c_str());
+ close();
+ }
+ return;
+}
+
+void CameraDevice::CameraPreviewWindow::cleanUpCirculatingBuffers() {
+ Mutex::Autolock _l(mLock);
+ for (auto pair : mCirculatingBuffers) {
+ sHandleImporter.freeBuffer(pair.second);
+ }
+ mCirculatingBuffers.clear();
+ mBufferIdMap.clear();
+}
+
+int CameraDevice::sDequeueBuffer(struct preview_stream_ops* w,
+ buffer_handle_t** buffer, int *stride) {
+ CameraPreviewWindow* object = static_cast<CameraPreviewWindow*>(w);
+ if (object->mPreviewCallback == nullptr) {
+ ALOGE("%s: camera HAL calling preview ops while there is no preview window!", __FUNCTION__);
+ return INVALID_OPERATION;
+ }
+
+ if (buffer == nullptr || stride == nullptr) {
+ ALOGE("%s: buffer (%p) and stride (%p) must not be null!", __FUNCTION__, buffer, stride);
+ return BAD_VALUE;
+ }
+
+ Status s;
+ object->mPreviewCallback->dequeueBuffer(
+ [&](auto status, uint64_t bufferId, const auto& buf, uint32_t strd) {
+ s = status;
+ if (s == Status::OK) {
+ Mutex::Autolock _l(object->mLock);
+ if (object->mCirculatingBuffers.count(bufferId) == 0) {
+ buffer_handle_t importedBuf = buf.getNativeHandle();
+ sHandleImporter.importBuffer(importedBuf);
+ if (importedBuf == nullptr) {
+ ALOGE("%s: preview buffer import failed!", __FUNCTION__);
+ s = Status::INTERNAL_ERROR;
+ return;
+ } else {
+ object->mCirculatingBuffers[bufferId] = importedBuf;
+ object->mBufferIdMap[&(object->mCirculatingBuffers[bufferId])] = bufferId;
+ }
+ }
+ *buffer = &(object->mCirculatingBuffers[bufferId]);
+ *stride = strd;
+ }
+ });
+ return getStatusT(s);
+}
+
+int CameraDevice::sLockBuffer(struct preview_stream_ops*, buffer_handle_t*) {
+ // TODO: make sure lock_buffer is indeed a no-op (and will always be)
+ return 0;
+}
+
+int CameraDevice::sEnqueueBuffer(struct preview_stream_ops* w, buffer_handle_t* buffer) {
+ CameraPreviewWindow* object = static_cast<CameraPreviewWindow*>(w);
+ if (object->mPreviewCallback == nullptr) {
+ ALOGE("%s: camera HAL calling preview ops while there is no preview window!", __FUNCTION__);
+ return INVALID_OPERATION;
+ }
+ uint64_t bufferId = object->mBufferIdMap.at(buffer);
+ return getStatusT(object->mPreviewCallback->enqueueBuffer(bufferId));
+}
+
+int CameraDevice::sCancelBuffer(struct preview_stream_ops* w, buffer_handle_t* buffer) {
+ CameraPreviewWindow* object = static_cast<CameraPreviewWindow*>(w);
+ if (object->mPreviewCallback == nullptr) {
+ ALOGE("%s: camera HAL calling preview ops while there is no preview window!", __FUNCTION__);
+ return INVALID_OPERATION;
+ }
+ uint64_t bufferId = object->mBufferIdMap.at(buffer);
+ return getStatusT(object->mPreviewCallback->cancelBuffer(bufferId));
+}
+
+int CameraDevice::sSetBufferCount(struct preview_stream_ops* w, int count) {
+ CameraPreviewWindow* object = static_cast<CameraPreviewWindow*>(w);
+ if (object->mPreviewCallback == nullptr) {
+ ALOGE("%s: camera HAL calling preview ops while there is no preview window!", __FUNCTION__);
+ return INVALID_OPERATION;
+ }
+
+ object->cleanUpCirculatingBuffers();
+ return getStatusT(object->mPreviewCallback->setBufferCount(count));
+}
+
+int CameraDevice::sSetBuffersGeometry(struct preview_stream_ops* w,
+ int width, int height, int format) {
+ CameraPreviewWindow* object = static_cast<CameraPreviewWindow*>(w);
+ if (object->mPreviewCallback == nullptr) {
+ ALOGE("%s: camera HAL calling preview ops while there is no preview window!", __FUNCTION__);
+ return INVALID_OPERATION;
+ }
+
+ object->cleanUpCirculatingBuffers();
+ return getStatusT(
+ object->mPreviewCallback->setBuffersGeometry(width, height, (PixelFormat) format));
+}
+
+int CameraDevice::sSetCrop(struct preview_stream_ops *w,
+ int left, int top, int right, int bottom) {
+ CameraPreviewWindow* object = static_cast<CameraPreviewWindow*>(w);
+ if (object->mPreviewCallback == nullptr) {
+ ALOGE("%s: camera HAL calling preview ops while there is no preview window!", __FUNCTION__);
+ return INVALID_OPERATION;
+ }
+
+ return getStatusT(object->mPreviewCallback->setCrop(left, top, right, bottom));
+}
+
+int CameraDevice::sSetTimestamp(struct preview_stream_ops *w, int64_t timestamp) {
+ CameraPreviewWindow* object = static_cast<CameraPreviewWindow*>(w);
+ if (object->mPreviewCallback == nullptr) {
+ ALOGE("%s: camera HAL calling preview ops while there is no preview window!", __FUNCTION__);
+ return INVALID_OPERATION;
+ }
+
+ return getStatusT(object->mPreviewCallback->setTimestamp(timestamp));
+}
+
+int CameraDevice::sSetUsage(struct preview_stream_ops* w, int usage) {
+ CameraPreviewWindow* object = static_cast<CameraPreviewWindow*>(w);
+ if (object->mPreviewCallback == nullptr) {
+ ALOGE("%s: camera HAL calling preview ops while there is no preview window!", __FUNCTION__);
+ return INVALID_OPERATION;
+ }
+
+ object->cleanUpCirculatingBuffers();
+ return getStatusT(object->mPreviewCallback->setUsage((ProducerUsage) usage));
+}
+
+int CameraDevice::sSetSwapInterval(struct preview_stream_ops *w, int interval) {
+ CameraPreviewWindow* object = static_cast<CameraPreviewWindow*>(w);
+ if (object->mPreviewCallback == nullptr) {
+ ALOGE("%s: camera HAL calling preview ops while there is no preview window!", __FUNCTION__);
+ return INVALID_OPERATION;
+ }
+
+ return getStatusT(object->mPreviewCallback->setSwapInterval(interval));
+}
+
+int CameraDevice::sGetMinUndequeuedBufferCount(
+ const struct preview_stream_ops *w,
+ int *count) {
+ const CameraPreviewWindow* object = static_cast<const CameraPreviewWindow*>(w);
+ if (object->mPreviewCallback == nullptr) {
+ ALOGE("%s: camera HAL calling preview ops while there is no preview window!", __FUNCTION__);
+ return INVALID_OPERATION;
+ }
+ if (count == nullptr) {
+ ALOGE("%s: count is null!", __FUNCTION__);
+ return BAD_VALUE;
+ }
+
+ Status s;
+ object->mPreviewCallback->getMinUndequeuedBufferCount(
+ [&](auto status, uint32_t cnt) {
+ s = status;
+ if (s == Status::OK) {
+ *count = cnt;
+ }
+ });
+ return getStatusT(s);
+}
+
+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);
+ commonInitialization();
+}
+
+CameraDevice::CameraHeapMemory::CameraHeapMemory(size_t buf_size, uint_t num_buffers) :
+ mBufSize(buf_size),
+ mNumBufs(num_buffers) {
+ mHeap = new MemoryHeapBase(buf_size * num_buffers);
+ commonInitialization();
+}
+
+void CameraDevice::CameraHeapMemory::commonInitialization() {
+ handle.data = mHeap->base();
+ 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;
+}
+
+// shared memory methods
+camera_memory_t* CameraDevice::sGetMemory(int fd, size_t buf_size, uint_t num_bufs, void *user) {
+ ALOGV("%s", __FUNCTION__);
+ CameraDevice* object = static_cast<CameraDevice*>(user);
+ if (object->mDeviceCallback == nullptr) {
+ ALOGE("%s: camera HAL request memory while camera is not opened!", __FUNCTION__);
+ return nullptr;
+ }
+
+ 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);
+ } else {
+ mem = new CameraHeapMemory(fd, buf_size, num_bufs);
+ }
+ handle->data[0] = mem->mHeap->getHeapID();
+ mem->incStrong(mem);
+
+ hidl_handle hidlHandle = handle;
+ MemoryId id = object->mDeviceCallback->registerMemory(hidlHandle, buf_size, num_bufs);
+ mem->handle.mId = id;
+ if (object->mMemoryMap.count(id) != 0) {
+ ALOGE("%s: duplicate MemoryId %d returned by client!", __FUNCTION__, id);
+ }
+ object->mMemoryMap[id] = mem;
+ mem->handle.mDevice = object;
+ native_handle_delete(handle);
+ return &mem->handle;
+}
+
+void CameraDevice::sPutMemory(camera_memory_t *data) {
+ if (!data)
+ return;
+
+ CameraHeapMemory* mem = static_cast<CameraHeapMemory *>(data->handle);
+ CameraDevice* device = mem->handle.mDevice;
+ if (device == nullptr) {
+ ALOGE("%s: camera HAL return memory for a null device!", __FUNCTION__);
+ }
+ if (device->mDeviceCallback == nullptr) {
+ ALOGE("%s: camera HAL return memory while camera is not opened!", __FUNCTION__);
+ }
+ device->mDeviceCallback->unregisterMemory(mem->handle.mId);
+ device->mMemoryMap.erase(mem->handle.mId);
+ mem->decStrong(mem);
+}
+
+// Callback forwarding methods
+void CameraDevice::sNotifyCb(int32_t msg_type, int32_t ext1, int32_t ext2, void *user) {
+ ALOGV("%s", __FUNCTION__);
+ CameraDevice* object = static_cast<CameraDevice*>(user);
+ if (object->mDeviceCallback != nullptr) {
+ object->mDeviceCallback->notifyCallback((NotifyCallbackMsg) msg_type, ext1, ext2);
+ }
+}
+
+void CameraDevice::sDataCb(int32_t msg_type, const camera_memory_t *data, unsigned int index,
+ camera_frame_metadata_t *metadata, void *user) {
+ ALOGV("%s", __FUNCTION__);
+ CameraDevice* object = static_cast<CameraDevice*>(user);
+ sp<CameraHeapMemory> mem(static_cast<CameraHeapMemory*>(data->handle));
+ if (index >= mem->mNumBufs) {
+ ALOGE("%s: invalid buffer index %d, max allowed is %d", __FUNCTION__,
+ index, mem->mNumBufs);
+ return;
+ }
+ if (object->mDeviceCallback != nullptr) {
+ CameraFrameMetadata hidlMetadata;
+ if (metadata) {
+ hidlMetadata.faces.resize(metadata->number_of_faces);
+ for (size_t i = 0; i < hidlMetadata.faces.size(); i++) {
+ hidlMetadata.faces[i].score = metadata->faces[i].score;
+ hidlMetadata.faces[i].id = metadata->faces[i].id;
+ for (int k = 0; k < 4; k++) {
+ hidlMetadata.faces[i].rect[k] = metadata->faces[i].rect[k];
+ }
+ for (int k = 0; k < 2; k++) {
+ hidlMetadata.faces[i].leftEye[k] = metadata->faces[i].left_eye[k];
+ }
+ for (int k = 0; k < 2; k++) {
+ hidlMetadata.faces[i].rightEye[k] = metadata->faces[i].right_eye[k];
+ }
+ for (int k = 0; k < 2; k++) {
+ hidlMetadata.faces[i].mouth[k] = metadata->faces[i].mouth[k];
+ }
+ }
+ }
+ CameraHeapMemory* mem = static_cast<CameraHeapMemory *>(data->handle);
+ object->mDeviceCallback->dataCallback(
+ (DataCallbackMsg) msg_type, mem->handle.mId, index, hidlMetadata);
+ }
+}
+
+void CameraDevice::sDataCbTimestamp(nsecs_t timestamp, int32_t msg_type,
+ const camera_memory_t *data, unsigned index, void *user) {
+ ALOGV("%s", __FUNCTION__);
+ CameraDevice* object = static_cast<CameraDevice*>(user);
+ // Start refcounting the heap object from here on. When the clients
+ // drop all references, it will be destroyed (as well as the enclosed
+ // MemoryHeapBase.
+ sp<CameraHeapMemory> mem(static_cast<CameraHeapMemory*>(data->handle));
+ if (index >= mem->mNumBufs) {
+ ALOGE("%s: invalid buffer index %d, max allowed is %d", __FUNCTION__,
+ index, mem->mNumBufs);
+ return;
+ }
+
+ native_handle_t* handle = nullptr;
+ if (object->mMetadataMode) {
+ if (mem->mBufSize == sizeof(VideoNativeHandleMetadata)) {
+ VideoNativeHandleMetadata* md = (VideoNativeHandleMetadata*)
+ mem->mBuffers[index]->pointer();
+ if (md->eType == VideoNativeHandleMetadata::kMetadataBufferTypeNativeHandleSource) {
+ handle = md->pHandle;
+ }
+ }
+ }
+
+ if (object->mDeviceCallback != nullptr) {
+ if (handle == nullptr) {
+ object->mDeviceCallback->dataCallbackTimestamp(
+ (DataCallbackMsg) msg_type, mem->handle.mId, index, timestamp);
+ } else {
+ object->mDeviceCallback->handleCallbackTimestamp(
+ (DataCallbackMsg) msg_type, handle, mem->handle.mId, index, timestamp);
+ }
+ }
+}
+
+void CameraDevice::initHalPreviewWindow()
+{
+ mHalPreviewWindow.cancel_buffer = sCancelBuffer;
+ mHalPreviewWindow.lock_buffer = sLockBuffer;
+ mHalPreviewWindow.dequeue_buffer = sDequeueBuffer;
+ mHalPreviewWindow.enqueue_buffer = sEnqueueBuffer;
+ mHalPreviewWindow.set_buffer_count = sSetBufferCount;
+ mHalPreviewWindow.set_buffers_geometry = sSetBuffersGeometry;
+ mHalPreviewWindow.set_crop = sSetCrop;
+ mHalPreviewWindow.set_timestamp = sSetTimestamp;
+ mHalPreviewWindow.set_usage = sSetUsage;
+ mHalPreviewWindow.set_swap_interval = sSetSwapInterval;
+
+ mHalPreviewWindow.get_min_undequeued_buffer_count =
+ sGetMinUndequeuedBufferCount;
+}
+
+// Methods from ::android::hardware::camera::device::V1_0::ICameraDevice follow.
+Return<void> CameraDevice::getResourceCost(getResourceCost_cb _hidl_cb) {
+ Status status = initStatus();
+ CameraResourceCost resCost;
+ if (status == Status::OK) {
+ int cost = 100;
+ std::vector<std::string> conflicting_devices;
+ struct camera_info info;
+
+ // If using post-2.4 module version, query the cost + conflicting devices from the HAL
+ if (mModule->getModuleApiVersion() >= CAMERA_MODULE_API_VERSION_2_4) {
+ int ret = mModule->getCameraInfo(mCameraIdInt, &info);
+ if (ret == OK) {
+ cost = info.resource_cost;
+ for (size_t i = 0; i < info.conflicting_devices_length; i++) {
+ std::string cameraId(info.conflicting_devices[i]);
+ for (const auto& pair : mCameraDeviceNames) {
+ if (cameraId == pair.first) {
+ conflicting_devices.push_back(pair.second);
+ }
+ }
+ }
+ } else {
+ status = Status::INTERNAL_ERROR;
+ }
+ }
+
+ if (status == Status::OK) {
+ resCost.resourceCost = cost;
+ resCost.conflictingDevices.resize(conflicting_devices.size());
+ for (size_t i = 0; i < conflicting_devices.size(); i++) {
+ resCost.conflictingDevices[i] = conflicting_devices[i];
+ ALOGV("CamDevice %s is conflicting with camDevice %s",
+ mCameraId.c_str(), resCost.conflictingDevices[i].c_str());
+ }
+ }
+ }
+ _hidl_cb(status, resCost);
+ return Void();
+}
+
+Return<void> CameraDevice::getCameraInfo(getCameraInfo_cb _hidl_cb) {
+ Status status = initStatus();
+ CameraInfo cameraInfo;
+ if (status == Status::OK) {
+ struct camera_info info;
+ int ret = mModule->getCameraInfo(mCameraIdInt, &info);
+ if (ret == OK) {
+ cameraInfo.facing = (CameraFacing) info.facing;
+ // Device 1.0 does not support external camera facing.
+ // The closest approximation would be front camera.
+ // TODO: figure out should we override here or let
+ // camera service handle it.
+ if (cameraInfo.facing == CameraFacing::EXTERNAL) {
+ cameraInfo.facing = CameraFacing::FRONT;
+ }
+ cameraInfo.orientation = info.orientation;
+ } else {
+ ALOGE("%s: get camera info failed!", __FUNCTION__);
+ status = Status::INTERNAL_ERROR;
+ }
+ }
+ _hidl_cb(status, cameraInfo);
+ return Void();
+}
+
+Return<Status> CameraDevice::setTorchMode(TorchMode mode) {
+ if (!mModule->isSetTorchModeSupported()) {
+ return Status::METHOD_NOT_SUPPORTED;
+ }
+
+ Status status = initStatus();
+ if (status == Status::OK) {
+ bool enable = (mode == TorchMode::ON) ? true : false;
+ status = getHidlStatus(mModule->setTorchMode(mCameraId.c_str(), enable));
+ }
+ return status;
+}
+
+Return<Status> CameraDevice::dumpState(const hidl_handle& handle) {
+ Mutex::Autolock _l(mLock);
+ if (handle.getNativeHandle() == nullptr) {
+ ALOGE("%s: handle must not be null", __FUNCTION__);
+ return Status::ILLEGAL_ARGUMENT;
+ }
+ if (handle->numFds != 1 || handle->numInts != 0) {
+ ALOGE("%s: handle must contain 1 FD and 0 integers! Got %d FDs and %d ints",
+ __FUNCTION__, handle->numFds, handle->numInts);
+ return Status::ILLEGAL_ARGUMENT;
+ }
+ int fd = handle->data[0];
+
+ if (mDevice != nullptr) {
+ if (mDevice->ops->dump) { // It's fine if the HAL doesn't implement dump()
+ return getHidlStatus(mDevice->ops->dump(mDevice, fd));
+ }
+ }
+ return Status::OK;
+}
+
+Return<Status> CameraDevice::open(const sp<ICameraDeviceCallback>& callback) {
+ ALOGI("Opening camera %s", mCameraId.c_str());
+ Mutex::Autolock _l(mLock);
+
+ camera_info info;
+ status_t res = mModule->getCameraInfo(mCameraIdInt, &info);
+ if (res != OK) {
+ ALOGE("Could not get camera info: %s: %d", mCameraId.c_str(), res);
+ return getHidlStatus(res);
+ }
+
+ int rc = OK;
+ if (mModule->getModuleApiVersion() >= CAMERA_MODULE_API_VERSION_2_3 &&
+ info.device_version > CAMERA_DEVICE_API_VERSION_1_0) {
+ // Open higher version camera device as HAL1.0 device.
+ rc = mModule->openLegacy(mCameraId.c_str(),
+ CAMERA_DEVICE_API_VERSION_1_0,
+ (hw_device_t **)&mDevice);
+ } else {
+ rc = mModule->open(mCameraId.c_str(), (hw_device_t **)&mDevice);
+ }
+ if (rc != OK) {
+ mDevice = nullptr;
+ ALOGE("Could not open camera %s: %d", mCameraId.c_str(), rc);
+ return getHidlStatus(rc);
+ }
+
+ initHalPreviewWindow();
+ mDeviceCallback = callback;
+
+ if (mDevice->ops->set_callbacks) {
+ mDevice->ops->set_callbacks(mDevice,
+ sNotifyCb, sDataCb, sDataCbTimestamp, sGetMemory, this);
+ }
+
+ return getHidlStatus(rc);
+}
+
+Return<Status> CameraDevice::setPreviewWindow(const sp<ICameraDevicePreviewCallback>& window) {
+ ALOGV("%s(%s)", __FUNCTION__, mCameraId.c_str());
+ Mutex::Autolock _l(mLock);
+ if (!mDevice) {
+ ALOGE("%s called while camera is not opened", __FUNCTION__);
+ return Status::OPERATION_NOT_SUPPORTED;
+ }
+
+ mHalPreviewWindow.mPreviewCallback = window;
+ if (mDevice->ops->set_preview_window) {
+ return getHidlStatus(mDevice->ops->set_preview_window(mDevice,
+ (window == nullptr) ? nullptr : &mHalPreviewWindow));
+ }
+ return Status::INTERNAL_ERROR; // HAL should provide set_preview_window
+}
+
+Return<void> CameraDevice::enableMsgType(uint32_t msgType) {
+ ALOGV("%s(%s)", __FUNCTION__, mCameraId.c_str());
+ Mutex::Autolock _l(mLock);
+ if (!mDevice) {
+ ALOGE("%s called while camera is not opened", __FUNCTION__);
+ return Void();
+ }
+ if (mDevice->ops->enable_msg_type) {
+ mDevice->ops->enable_msg_type(mDevice, msgType);
+ }
+ return Void();
+}
+
+Return<void> CameraDevice::disableMsgType(uint32_t msgType) {
+ ALOGV("%s(%s)", __FUNCTION__, mCameraId.c_str());
+ Mutex::Autolock _l(mLock);
+ if (!mDevice) {
+ ALOGE("%s called while camera is not opened", __FUNCTION__);
+ return Void();
+ }
+ if (mDevice->ops->disable_msg_type) {
+ mDevice->ops->disable_msg_type(mDevice, msgType);
+ }
+ return Void();
+}
+
+Return<bool> CameraDevice::msgTypeEnabled(uint32_t msgType) {
+ ALOGV("%s(%s)", __FUNCTION__, mCameraId.c_str());
+ Mutex::Autolock _l(mLock);
+ if (!mDevice) {
+ ALOGE("%s called while camera is not opened", __FUNCTION__);
+ return false;
+ }
+ if (mDevice->ops->msg_type_enabled) {
+ return mDevice->ops->msg_type_enabled(mDevice, msgType);
+ }
+ return false;
+}
+
+Return<Status> CameraDevice::startPreview() {
+ ALOGV("%s(%s)", __FUNCTION__, mCameraId.c_str());
+ Mutex::Autolock _l(mLock);
+ if (!mDevice) {
+ ALOGE("%s called while camera is not opened", __FUNCTION__);
+ return Status::OPERATION_NOT_SUPPORTED;
+ }
+ if (mDevice->ops->start_preview) {
+ return getHidlStatus(mDevice->ops->start_preview(mDevice));
+ }
+ return Status::INTERNAL_ERROR; // HAL should provide start_preview
+}
+
+Return<void> CameraDevice::stopPreview() {
+ ALOGV("%s(%s)", __FUNCTION__, mCameraId.c_str());
+ Mutex::Autolock _l(mLock);
+ if (!mDevice) {
+ ALOGE("%s called while camera is not opened", __FUNCTION__);
+ return Void();
+ }
+ if (mDevice->ops->stop_preview) {
+ mDevice->ops->stop_preview(mDevice);
+ }
+ return Void();
+}
+
+Return<bool> CameraDevice::previewEnabled() {
+ ALOGV("%s(%s)", __FUNCTION__, mCameraId.c_str());
+ Mutex::Autolock _l(mLock);
+ if (!mDevice) {
+ ALOGE("%s called while camera is not opened", __FUNCTION__);
+ return false;
+ }
+ if (mDevice->ops->preview_enabled) {
+ return mDevice->ops->preview_enabled(mDevice);
+ }
+ return false;
+}
+
+Return<Status> CameraDevice::storeMetaDataInBuffers(bool enable) {
+ ALOGV("%s(%s)", __FUNCTION__, mCameraId.c_str());
+ Mutex::Autolock _l(mLock);
+ if (!mDevice) {
+ ALOGE("%s called while camera is not opened", __FUNCTION__);
+ return Status::OPERATION_NOT_SUPPORTED;
+ }
+ if (mDevice->ops->store_meta_data_in_buffers) {
+ status_t s = mDevice->ops->store_meta_data_in_buffers(mDevice, enable);
+ if (s == OK && enable) {
+ mMetadataMode = true;
+ }
+ return getHidlStatus(s);
+ }
+ return enable ? Status::ILLEGAL_ARGUMENT : Status::OK;
+}
+
+Return<Status> CameraDevice::startRecording() {
+ ALOGV("%s(%s)", __FUNCTION__, mCameraId.c_str());
+ Mutex::Autolock _l(mLock);
+ if (!mDevice) {
+ ALOGE("%s called while camera is not opened", __FUNCTION__);
+ return Status::OPERATION_NOT_SUPPORTED;
+ }
+ if (mDevice->ops->start_recording) {
+ return getHidlStatus(mDevice->ops->start_recording(mDevice));
+ }
+ return Status::ILLEGAL_ARGUMENT;
+}
+
+Return<void> CameraDevice::stopRecording() {
+ ALOGV("%s(%s)", __FUNCTION__, mCameraId.c_str());
+ Mutex::Autolock _l(mLock);
+ if (!mDevice) {
+ ALOGE("%s called while camera is not opened", __FUNCTION__);
+ return Void();
+ }
+ if (mDevice->ops->stop_recording) {
+ mDevice->ops->stop_recording(mDevice);
+ }
+ return Void();
+}
+
+Return<bool> CameraDevice::recordingEnabled() {
+ ALOGV("%s(%s)", __FUNCTION__, mCameraId.c_str());
+ Mutex::Autolock _l(mLock);
+ if (!mDevice) {
+ ALOGE("%s called while camera is not opened", __FUNCTION__);
+ return false;
+ }
+ if (mDevice->ops->recording_enabled) {
+ return mDevice->ops->recording_enabled(mDevice);
+ }
+ return false;
+}
+
+void CameraDevice::releaseRecordingFrameLocked(
+ uint32_t memId, uint32_t bufferIndex, const native_handle_t* handle) {
+ if (!mDevice) {
+ ALOGE("%s called while camera is not opened", __FUNCTION__);
+ return;
+ }
+ 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;
+ if (handle) {
+ VideoNativeHandleMetadata* md = (VideoNativeHandleMetadata*) data;
+ if (md->eType == VideoNativeHandleMetadata::kMetadataBufferTypeNativeHandleSource) {
+ // Input handle will be closed by HIDL transport later, so clone it
+ // HAL implementation is responsible to close/delete the clone
+ native_handle_t* clone = native_handle_clone(handle);
+ if (!clone) {
+ ALOGE("%s: failed to clone buffer %p", __FUNCTION__, handle);
+ return;
+ }
+ md->pHandle = clone;
+ } else {
+ ALOGE("%s:Malform VideoNativeHandleMetadata at memId %d, bufferId %d",
+ __FUNCTION__, memId, bufferIndex);
+ return;
+ }
+ }
+ mDevice->ops->release_recording_frame(mDevice, data);
+ }
+}
+
+Return<void> CameraDevice::releaseRecordingFrame(uint32_t memId, uint32_t bufferIndex) {
+ ALOGV("%s(%s)", __FUNCTION__, mCameraId.c_str());
+ Mutex::Autolock _l(mLock);
+ releaseRecordingFrameLocked(memId, bufferIndex, nullptr);
+ return Void();
+}
+
+Return<void> CameraDevice::releaseRecordingFrameHandle(
+ uint32_t memId, uint32_t bufferIndex, const hidl_handle& frame) {
+ ALOGV("%s(%s)", __FUNCTION__, mCameraId.c_str());
+ Mutex::Autolock _l(mLock);
+ releaseRecordingFrameLocked(
+ memId, bufferIndex, frame.getNativeHandle());
+ return Void();
+}
+
+Return<Status> CameraDevice::autoFocus() {
+ ALOGV("%s(%s)", __FUNCTION__, mCameraId.c_str());
+ Mutex::Autolock _l(mLock);
+ if (!mDevice) {
+ ALOGE("%s called while camera is not opened", __FUNCTION__);
+ return Status::OPERATION_NOT_SUPPORTED;
+ }
+ if (mDevice->ops->auto_focus) {
+ return getHidlStatus(mDevice->ops->auto_focus(mDevice));
+ }
+ return Status::ILLEGAL_ARGUMENT;
+}
+
+Return<Status> CameraDevice::cancelAutoFocus() {
+ ALOGV("%s(%s)", __FUNCTION__, mCameraId.c_str());
+ Mutex::Autolock _l(mLock);
+ if (!mDevice) {
+ ALOGE("%s called while camera is not opened", __FUNCTION__);
+ return Status::OPERATION_NOT_SUPPORTED;
+ }
+ if (mDevice->ops->cancel_auto_focus) {
+ return getHidlStatus(mDevice->ops->cancel_auto_focus(mDevice));
+ }
+ return Status::ILLEGAL_ARGUMENT;
+}
+
+Return<Status> CameraDevice::takePicture() {
+ ALOGV("%s(%s)", __FUNCTION__, mCameraId.c_str());
+ Mutex::Autolock _l(mLock);
+ if (!mDevice) {
+ ALOGE("%s called while camera is not opened", __FUNCTION__);
+ return Status::OPERATION_NOT_SUPPORTED;
+ }
+ if (mDevice->ops->take_picture) {
+ return getHidlStatus(mDevice->ops->take_picture(mDevice));
+ }
+ return Status::ILLEGAL_ARGUMENT;
+}
+
+Return<Status> CameraDevice::cancelPicture() {
+ ALOGV("%s(%s)", __FUNCTION__, mCameraId.c_str());
+ Mutex::Autolock _l(mLock);
+ if (!mDevice) {
+ ALOGE("%s called while camera is not opened", __FUNCTION__);
+ return Status::OPERATION_NOT_SUPPORTED;
+ }
+ if (mDevice->ops->cancel_picture) {
+ return getHidlStatus(mDevice->ops->cancel_picture(mDevice));
+ }
+ return Status::ILLEGAL_ARGUMENT;
+}
+
+Return<Status> CameraDevice::setParameters(const hidl_string& params) {
+ ALOGV("%s(%s)", __FUNCTION__, mCameraId.c_str());
+ Mutex::Autolock _l(mLock);
+ if (!mDevice) {
+ ALOGE("%s called while camera is not opened", __FUNCTION__);
+ return Status::OPERATION_NOT_SUPPORTED;
+ }
+ if (mDevice->ops->set_parameters) {
+ return getHidlStatus(mDevice->ops->set_parameters(mDevice, params.c_str()));
+ }
+ return Status::ILLEGAL_ARGUMENT;
+}
+
+Return<void> CameraDevice::getParameters(getParameters_cb _hidl_cb) {
+ ALOGV("%s(%s)", __FUNCTION__, mCameraId.c_str());
+ Mutex::Autolock _l(mLock);
+ hidl_string outStr;
+ if (!mDevice) {
+ ALOGE("%s called while camera is not opened", __FUNCTION__);
+ _hidl_cb(outStr);
+ return Void();
+ }
+ if (mDevice->ops->get_parameters) {
+ char *temp = mDevice->ops->get_parameters(mDevice);
+ outStr = temp;
+ if (mDevice->ops->put_parameters) {
+ mDevice->ops->put_parameters(mDevice, temp);
+ } else {
+ free(temp);
+ }
+ }
+ _hidl_cb(outStr);
+ return Void();
+}
+
+Return<Status> CameraDevice::sendCommand(CommandType cmd, int32_t arg1, int32_t arg2) {
+ ALOGV("%s(%s)", __FUNCTION__, mCameraId.c_str());
+ Mutex::Autolock _l(mLock);
+ if (!mDevice) {
+ ALOGE("%s called while camera is not opened", __FUNCTION__);
+ return Status::OPERATION_NOT_SUPPORTED;
+ }
+ if (mDevice->ops->send_command) {
+ return getHidlStatus(mDevice->ops->send_command(mDevice, (int32_t) cmd, arg1, arg2));
+ }
+ return Status::ILLEGAL_ARGUMENT;
+}
+
+Return<void> CameraDevice::close() {
+ ALOGI("Closing camera %s", mCameraId.c_str());
+ Mutex::Autolock _l(mLock);
+ if(mDevice) {
+ int rc = mDevice->common.close(&mDevice->common);
+ if (rc != OK) {
+ ALOGE("Could not close camera %s: %d", mCameraId.c_str(), rc);
+ }
+ mDevice = nullptr;
+ }
+ return Void();
+}
+
+} // namespace implementation
+} // namespace V1_0
+} // namespace device
+} // namespace camera
+} // namespace hardware
+} // namespace android
diff --git a/camera/device/1.0/default/CameraDevice_1_0.h b/camera/device/1.0/default/CameraDevice_1_0.h
new file mode 100644
index 0000000..2568f86
--- /dev/null
+++ b/camera/device/1.0/default/CameraDevice_1_0.h
@@ -0,0 +1,224 @@
+/*
+ * 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_CAMERA_DEVICE_V1_0_CAMERADEVICE_H
+#define ANDROID_HARDWARE_CAMERA_DEVICE_V1_0_CAMERADEVICE_H
+
+#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 <hidl/MQDescriptor.h>
+#include <hidl/Status.h>
+
+namespace android {
+namespace hardware {
+namespace camera {
+namespace device {
+namespace V1_0 {
+namespace implementation {
+
+using ::android::hardware::camera::common::V1_0::CameraResourceCost;
+using ::android::hardware::camera::common::V1_0::Status;
+using ::android::hardware::camera::common::V1_0::TorchMode;
+using ::android::hardware::camera::common::V1_0::helper::CameraModule;
+using ::android::hardware::camera::common::V1_0::helper::HandleImporter;
+using ::android::hardware::camera::device::V1_0::CameraInfo;
+using ::android::hardware::camera::device::V1_0::CommandType;
+using ::android::hardware::camera::device::V1_0::ICameraDevice;
+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::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 CameraDevice : public ICameraDevice {
+
+ // Called by provider HAL. Provider HAL must ensure the uniqueness of
+ // CameraDevice object per cameraId, or there could be multiple CameraDevice
+ // trying to access the same physical camera.
+ // Also, provider will have to keep track of all CameraDevice objects in
+ // order to notify CameraDevice when the underlying camera is detached
+ CameraDevice(sp<CameraModule> module,
+ const std::string& cameraId,
+ const SortedVector<std::pair<std::string, std::string>>& cameraDeviceNames);
+ ~CameraDevice();
+
+ // Caller must use this method to check if CameraDevice ctor failed
+ bool isInitFailed() { return mInitFail; }
+ // Used by provider HAL to signal external camera disconnected
+ void setConnectionStatus(bool connected);
+
+ // Methods from ::android::hardware::camera::device::V1_0::ICameraDevice follow.
+ Return<void> getResourceCost(getResourceCost_cb _hidl_cb) override;
+ Return<void> getCameraInfo(getCameraInfo_cb _hidl_cb) override;
+ Return<Status> setTorchMode(TorchMode mode) override;
+ Return<Status> dumpState(const hidl_handle& fd) override;
+ Return<Status> open(const sp<ICameraDeviceCallback>& callback) override;
+ Return<Status> setPreviewWindow(const sp<ICameraDevicePreviewCallback>& window) override;
+ Return<void> enableMsgType(uint32_t msgType) override;
+ Return<void> disableMsgType(uint32_t msgType) override;
+ Return<bool> msgTypeEnabled(uint32_t msgType) override;
+ Return<Status> startPreview() override;
+ Return<void> stopPreview() override;
+ Return<bool> previewEnabled() override;
+ Return<Status> storeMetaDataInBuffers(bool enable) override;
+ Return<Status> startRecording() override;
+ Return<void> stopRecording() override;
+ Return<bool> recordingEnabled() override;
+ 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<Status> autoFocus() override;
+ Return<Status> cancelAutoFocus() override;
+ Return<Status> takePicture() override;
+ Return<Status> cancelPicture() override;
+ Return<Status> setParameters(const hidl_string& params) override;
+ Return<void> getParameters(getParameters_cb _hidl_cb) override;
+ Return<Status> sendCommand(CommandType cmd, int32_t arg1, int32_t arg2) override;
+ Return<void> close() override;
+
+private:
+ struct CameraMemory : public camera_memory_t {
+ MemoryId mId;
+ CameraDevice* mDevice;
+ };
+
+ 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);
+ 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;
+ CameraMemory handle;
+ };
+
+ // TODO: b/35625849
+ // Meta data buffer layout for passing a native_handle to codec
+ // matching frameworks/native/include/media/hardware/MetadataBufferType.h and
+ // frameworks/native/include/media/hardware/HardwareAPI.h
+ struct VideoNativeHandleMetadata {
+ static const uint32_t kMetadataBufferTypeNativeHandleSource = 3;
+ uint32_t eType; // must be kMetadataBufferTypeNativeHandleSource
+ native_handle_t* pHandle;
+ };
+
+ const sp<CameraModule> mModule;
+ const std::string mCameraId;
+ // const after ctor
+ int mCameraIdInt;
+ int mDeviceVersion;
+
+ camera_device_t* mDevice = nullptr;
+
+ void initHalPreviewWindow();
+ struct CameraPreviewWindow : public preview_stream_ops {
+ // Called when we expect buffer will be re-allocated
+ void cleanUpCirculatingBuffers();
+
+ Mutex mLock;
+ sp<ICameraDevicePreviewCallback> mPreviewCallback = nullptr;
+ std::unordered_map<uint64_t, buffer_handle_t> mCirculatingBuffers;
+ std::unordered_map<buffer_handle_t*, uint64_t> mBufferIdMap;
+ } mHalPreviewWindow;
+
+ // gating access to mDevice, mInitFail, mDisconnected
+ mutable Mutex mLock;
+
+ bool mInitFail = false;
+ // Set by provider (when external camera is connected/disconnected)
+ bool mDisconnected;
+
+ static HandleImporter& sHandleImporter;
+
+ const SortedVector<std::pair<std::string, std::string>>& mCameraDeviceNames;
+
+ sp<ICameraDeviceCallback> mDeviceCallback = nullptr;
+
+ std::unordered_map<MemoryId, CameraHeapMemory*> mMemoryMap;
+
+ bool mMetadataMode = false;
+
+ void releaseRecordingFrameLocked(uint32_t memId, uint32_t bufferIndex, const native_handle_t*);
+
+ // shared memory methods
+ static camera_memory_t* sGetMemory(int fd, size_t buf_size, uint_t num_bufs, void *user);
+ static void sPutMemory(camera_memory_t *data);
+
+ // 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);
+ 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);
+
+ static int sLockBuffer(struct preview_stream_ops* w, buffer_handle_t* buffer);
+
+ static int sEnqueueBuffer(struct preview_stream_ops* w, buffer_handle_t* buffer);
+
+ static int sCancelBuffer(struct preview_stream_ops* w, buffer_handle_t* buffer);
+
+ static int sSetBufferCount(struct preview_stream_ops* w, int count);
+
+ static int sSetBuffersGeometry(struct preview_stream_ops* w,
+ int width, int height, int format);
+
+ static int sSetCrop(struct preview_stream_ops *w, int left, int top, int right, int bottom);
+
+ static int sSetTimestamp(struct preview_stream_ops *w, int64_t timestamp);
+
+ static int sSetUsage(struct preview_stream_ops* w, int usage);
+
+ static int sSetSwapInterval(struct preview_stream_ops *w, int interval);
+
+ static int sGetMinUndequeuedBufferCount(const struct preview_stream_ops *w, int *count);
+
+ // convert conventional HAL status to HIDL Status
+ static Status getHidlStatus(const int&);
+ static status_t getStatusT(const Status& s);
+
+ Status initStatus() const;
+};
+
+} // namespace implementation
+} // namespace V1_0
+} // namespace device
+} // namespace camera
+} // namespace hardware
+} // namespace android
+
+#endif // ANDROID_HARDWARE_CAMERA_DEVICE_V1_0_CAMERADEVICE_H
diff --git a/camera/device/1.0/types.hal b/camera/device/1.0/types.hal
index 83c0be4..b32c938 100644
--- a/camera/device/1.0/types.hal
+++ b/camera/device/1.0/types.hal
@@ -189,6 +189,66 @@
PREVIEW_METADATA = 0x0400
};
+/**
+ * Information for a single detected face.
+ */
+ struct CameraFace {
+ /**
+ * Bounds of the face [left, top, right, bottom]. (-1000, -1000) represents
+ * the top-left of the camera field of view, and (1000, 1000) represents the
+ * bottom-right of the field of view. The width and height cannot be 0 or
+ * negative. This is supported by both hardware and software face detection.
+ *
+ * The direction is relative to the sensor orientation, that is, what the
+ * sensor sees. The direction is not affected by the rotation or mirroring
+ * of CAMERA_CMD_SET_DISPLAY_ORIENTATION.
+ */
+ int32_t[4] rect;
+
+ /**
+ * The confidence level of the face. The range is 1 to 100. 100 is the
+ * highest confidence. This is supported by both hardware and software
+ * face detection.
+ */
+ int32_t score;
+
+ /**
+ * An unique id per face while the face is visible to the tracker. If
+ * the face leaves the field-of-view and comes back, it will get a new
+ * id. If the value is 0, id is not supported.
+ */
+ int32_t id;
+
+ /**
+ * The coordinates of the center of the left eye. The range is -1000 to
+ * 1000. -2000, -2000 if this is not supported.
+ */
+ int32_t[2] leftEye;
+
+ /**
+ * The coordinates of the center of the right eye. The range is -1000 to
+ * 1000. -2000, -2000 if this is not supported.
+ */
+ int32_t[2] rightEye;
+
+ /**
+ * The coordinates of the center of the mouth. The range is -1000 to 1000.
+ * -2000, -2000 if this is not supported.
+ */
+ int32_t[2] mouth;
+
+};
+
+/**
+ * The metadata of the frame data, such as face detection result.
+ */
+struct CameraFrameMetadata {
+ /**
+ * A vector of the detected faces.
+ */
+ vec<CameraFace> faces;
+};
+
/*
* A simple integer handle to use to reference a particular memory buffer
* between the HAL and the framework.
diff --git a/camera/device/3.2/default/CameraDevice.cpp b/camera/device/3.2/default/CameraDevice.cpp
index 18e0e7b..0a457ad 100644
--- a/camera/device/3.2/default/CameraDevice.cpp
+++ b/camera/device/3.2/default/CameraDevice.cpp
@@ -15,11 +15,11 @@
*/
#define LOG_TAG "CamDev@3.2-impl"
-#include <android/log.h>
+#include <utils/Log.h>
#include <utils/Vector.h>
#include <utils/Trace.h>
-#include "CameraDevice.h"
+#include "CameraDevice_3_2.h"
#include <include/convert.h>
namespace android {
diff --git a/camera/device/3.2/default/CameraDeviceSession.cpp b/camera/device/3.2/default/CameraDeviceSession.cpp
index 0f3d97b..3c3c078 100644
--- a/camera/device/3.2/default/CameraDeviceSession.cpp
+++ b/camera/device/3.2/default/CameraDeviceSession.cpp
@@ -29,198 +29,13 @@
namespace V3_2 {
namespace implementation {
-namespace {
-
-// Copy pasted from Hwc.cpp. Use this until gralloc mapper HAL is working
-class HandleImporter {
-public:
- HandleImporter() : mInitialized(false) {}
-
- bool initialize()
- {
- // allow only one client
- if (mInitialized) {
- return false;
- }
-
- if (!openGralloc()) {
- return false;
- }
-
- mInitialized = true;
- return true;
- }
-
- void cleanup()
- {
- if (!mInitialized) {
- return;
- }
-
- closeGralloc();
- mInitialized = false;
- }
-
- // In IComposer, any buffer_handle_t is owned by the caller and we need to
- // make a clone for hwcomposer2. We also need to translate empty handle
- // to nullptr. This function does that, in-place.
- bool importBuffer(buffer_handle_t& handle)
- {
- if (!handle->numFds && !handle->numInts) {
- handle = nullptr;
- return true;
- }
-
- buffer_handle_t clone = cloneBuffer(handle);
- if (!clone) {
- return false;
- }
-
- handle = clone;
- return true;
- }
-
- void freeBuffer(buffer_handle_t handle)
- {
- if (!handle) {
- return;
- }
-
- releaseBuffer(handle);
- }
-
- bool importFence(const native_handle_t* handle, int& fd)
- {
- if (handle == nullptr || handle->numFds == 0) {
- fd = -1;
- } else if (handle->numFds == 1) {
- fd = dup(handle->data[0]);
- if (fd < 0) {
- ALOGE("failed to dup fence fd %d", handle->data[0]);
- return false;
- }
- } else {
- ALOGE("invalid fence handle with %d file descriptors",
- handle->numFds);
- return false;
- }
-
- return true;
- }
-
- void closeFence(int fd)
- {
- if (fd >= 0) {
- close(fd);
- }
- }
-
-private:
- bool mInitialized;
-
- bool openGralloc()
- {
- const hw_module_t* module;
- int err = hw_get_module(GRALLOC_HARDWARE_MODULE_ID, &module);
- if (err) {
- ALOGE("failed to get gralloc module");
- return false;
- }
-
- uint8_t major = (module->module_api_version >> 8) & 0xff;
- if (major > 1) {
- ALOGE("unknown gralloc module major version %d", major);
- return false;
- }
-
- if (major == 1) {
- err = gralloc1_open(module, &mDevice);
- if (err) {
- ALOGE("failed to open gralloc1 device");
- return false;
- }
-
- mRetain = reinterpret_cast<GRALLOC1_PFN_RETAIN>(
- mDevice->getFunction(mDevice, GRALLOC1_FUNCTION_RETAIN));
- mRelease = reinterpret_cast<GRALLOC1_PFN_RELEASE>(
- mDevice->getFunction(mDevice, GRALLOC1_FUNCTION_RELEASE));
- if (!mRetain || !mRelease) {
- ALOGE("invalid gralloc1 device");
- gralloc1_close(mDevice);
- return false;
- }
- } else {
- mModule = reinterpret_cast<const gralloc_module_t*>(module);
- }
-
- return true;
- }
-
- void closeGralloc()
- {
- if (mDevice) {
- gralloc1_close(mDevice);
- }
- }
-
- buffer_handle_t cloneBuffer(buffer_handle_t handle)
- {
- native_handle_t* clone = native_handle_clone(handle);
- if (!clone) {
- ALOGE("failed to clone buffer %p", handle);
- return nullptr;
- }
-
- bool err;
- if (mDevice) {
- err = (mRetain(mDevice, clone) != GRALLOC1_ERROR_NONE);
- } else {
- err = (mModule->registerBuffer(mModule, clone) != 0);
- }
-
- if (err) {
- ALOGE("failed to retain/register buffer %p", clone);
- native_handle_close(clone);
- native_handle_delete(clone);
- return nullptr;
- }
-
- return clone;
- }
-
- void releaseBuffer(buffer_handle_t handle)
- {
- if (mDevice) {
- mRelease(mDevice, handle);
- } else {
- mModule->unregisterBuffer(mModule, handle);
- }
- native_handle_close(handle);
- native_handle_delete(const_cast<native_handle_t*>(handle));
- }
-
- // gralloc1
- gralloc1_device_t* mDevice;
- GRALLOC1_PFN_RETAIN mRetain;
- GRALLOC1_PFN_RELEASE mRelease;
-
- // gralloc0
- const gralloc_module_t* mModule;
-};
-
-HandleImporter sHandleImporter;
-
-} // Anonymous namespace
+HandleImporter& CameraDeviceSession::sHandleImporter = HandleImporter::getInstance();
CameraDeviceSession::CameraDeviceSession(
camera3_device_t* device, const sp<ICameraDeviceCallback>& callback) :
camera3_callback_ops({&sProcessCaptureResult, &sNotify}),
mDevice(device),
mCallback(callback) {
- // For now, we init sHandleImporter but do not cleanup (keep it alive until
- // HAL process ends)
- sHandleImporter.initialize();
-
mInitFail = initialize();
}
diff --git a/camera/device/3.2/default/CameraDeviceSession.h b/camera/device/3.2/default/CameraDeviceSession.h
index f8689d3..3786e4b 100644
--- a/camera/device/3.2/default/CameraDeviceSession.h
+++ b/camera/device/3.2/default/CameraDeviceSession.h
@@ -26,6 +26,7 @@
#include <hidl/Status.h>
#include <hidl/MQDescriptor.h>
#include <include/convert.h>
+#include "HandleImporter.h"
namespace android {
namespace hardware {
@@ -39,6 +40,7 @@
using ::android::hardware::camera::device::V3_2::StreamConfiguration;
using ::android::hardware::camera::device::V3_2::ICameraDeviceSession;
using ::android::hardware::camera::common::V1_0::Status;
+using ::android::hardware::camera::common::V1_0::helper::HandleImporter;
using ::android::hardware::Return;
using ::android::hardware::Void;
using ::android::hardware::hidl_vec;
@@ -109,6 +111,8 @@
// Stream ID -> circulating buffers map
std::map<int, CirculatingBuffers> mCirculatingBuffers;
+ static HandleImporter& sHandleImporter;
+
bool mInitFail;
bool initialize();
diff --git a/camera/device/3.2/default/CameraDevice.h b/camera/device/3.2/default/CameraDevice_3_2.h
similarity index 97%
rename from camera/device/3.2/default/CameraDevice.h
rename to camera/device/3.2/default/CameraDevice_3_2.h
index 317eea5..4e86067 100644
--- a/camera/device/3.2/default/CameraDevice.h
+++ b/camera/device/3.2/default/CameraDevice_3_2.h
@@ -55,7 +55,7 @@
// Called by provider HAL. Provider HAL must ensure the uniqueness of
// CameraDevice object per cameraId, or there could be multiple CameraDevice
// trying to access the same physical camera.
- // Also, provider will have to keep track of all CameraDevice object in
+ // Also, provider will have to keep track of all CameraDevice objects in
// order to notify CameraDevice when the underlying camera is detached
CameraDevice(sp<CameraModule> module,
const std::string& cameraId,
@@ -81,8 +81,7 @@
/* End of Methods from ::android::hardware::camera::device::V3_2::ICameraDevice */
private:
- // Passed from provider HAL. Should not change.
- sp<CameraModule> mModule;
+ const sp<CameraModule> mModule;
const std::string mCameraId;
// const after ctor
int mCameraIdInt;
diff --git a/camera/provider/2.4/default/Android.bp b/camera/provider/2.4/default/Android.bp
index 7315292..a6febec 100644
--- a/camera/provider/2.4/default/Android.bp
+++ b/camera/provider/2.4/default/Android.bp
@@ -10,6 +10,7 @@
"libcutils",
"android.hardware.camera.device@1.0",
"android.hardware.camera.device@3.2",
+ "camera.device@1.0-impl",
"camera.device@3.2-impl",
"android.hardware.camera.provider@2.4",
"android.hardware.camera.common@1.0",
@@ -34,15 +35,9 @@
"libhidltransport",
"liblog",
"libutils",
- "libhardware",
"android.hardware.camera.device@1.0",
"android.hardware.camera.device@3.2",
"android.hardware.camera.provider@2.4",
"android.hardware.camera.common@1.0",
- "libcutils",
- "libcamera_metadata"
],
- static_libs: [
- "android.hardware.camera.common@1.0-helper"
- ]
}
diff --git a/camera/provider/2.4/default/CameraProvider.cpp b/camera/provider/2.4/default/CameraProvider.cpp
index 5714f83..ad9f0b8 100644
--- a/camera/provider/2.4/default/CameraProvider.cpp
+++ b/camera/provider/2.4/default/CameraProvider.cpp
@@ -18,7 +18,8 @@
#include <android/log.h>
#include "CameraProvider.h"
-#include "CameraDevice.h"
+#include "CameraDevice_1_0.h"
+#include "CameraDevice_3_2.h"
#include <string.h>
#include <utils/Trace.h>
@@ -59,8 +60,6 @@
return;
}
- ALOGI("%s resolved provider %p", __FUNCTION__, cp);
-
Mutex::Autolock _l(cp->mCbLock);
char cameraId[kMaxCameraIdLen];
snprintf(cameraId, sizeof(cameraId), "%d", camera_id);
@@ -89,8 +88,6 @@
return;
}
- ALOGI("%s resolved provider %p", __FUNCTION__, cp);
-
Mutex::Autolock _l(cp->mCbLock);
if (cp->mCallbacks != nullptr) {
std::string cameraIdStr(camera_id);
@@ -323,9 +320,57 @@
}
Return<void> CameraProvider::getCameraDeviceInterface_V1_x(
- const hidl_string& /*cameraDeviceName*/, getCameraDeviceInterface_V1_x_cb _hidl_cb) {
- // TODO implement after device 1.0 is implemented
- _hidl_cb(Status::INTERNAL_ERROR, nullptr);
+ const hidl_string& cameraDeviceName, getCameraDeviceInterface_V1_x_cb _hidl_cb) {
+ std::smatch sm;
+ bool match = matchDeviceName(cameraDeviceName, sm);
+ 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
+ Status status = Status::OK;
+ ssize_t idx = mCameraIds.indexOf(cameraId);
+ if (idx == NAME_NOT_FOUND) {
+ ALOGE("%s: cannot find camera %s!", __FUNCTION__, cameraId.c_str());
+ status = Status::ILLEGAL_ARGUMENT;
+ } else { // invalid version
+ ALOGE("%s: camera device %s does not support version %s!",
+ __FUNCTION__, cameraId.c_str(), deviceVersion.c_str());
+ status = Status::OPERATION_NOT_SUPPORTED;
+ }
+ _hidl_cb(status, nullptr);
+ return Void();
+ }
+
+ if (mCameraStatusMap.count(cameraId) == 0 ||
+ mCameraStatusMap[cameraId] != CAMERA_DEVICE_STATUS_PRESENT) {
+ _hidl_cb(Status::ILLEGAL_ARGUMENT, nullptr);
+ return Void();
+ }
+
+ sp<android::hardware::camera::device::V1_0::implementation::CameraDevice> device =
+ new android::hardware::camera::device::V1_0::implementation::CameraDevice(
+ mModule, cameraId, mCameraDeviceNames);
+
+ if (device == nullptr) {
+ ALOGE("%s: cannot allocate camera device for id %s", __FUNCTION__, cameraId.c_str());
+ _hidl_cb(Status::INTERNAL_ERROR, nullptr);
+ return Void();
+ }
+
+ if (device->isInitFailed()) {
+ ALOGE("%s: camera device %s init failed!", __FUNCTION__, cameraId.c_str());
+ device = nullptr;
+ _hidl_cb(Status::INTERNAL_ERROR, nullptr);
+ return Void();
+ }
+
+ _hidl_cb (Status::OK, device);
return Void();
}
diff --git a/camera/provider/2.4/vts/functional/Android.bp b/camera/provider/2.4/vts/functional/Android.bp
index defe3dc..f478152 100644
--- a/camera/provider/2.4/vts/functional/Android.bp
+++ b/camera/provider/2.4/vts/functional/Android.bp
@@ -16,7 +16,6 @@
cc_test {
name: "VtsHalCameraProviderV2_4TargetTest",
- gtest: true,
srcs: ["VtsHalCameraProviderV2_4TargetTest.cpp"],
shared_libs: [
"liblog",
@@ -29,7 +28,7 @@
"libcamera_metadata",
"libui"
],
- static_libs: ["libgtest"],
+ static_libs: ["VtsHalHidlTargetBaseTest"],
cflags: [
"-O0",
"-g",
diff --git a/camera/provider/2.4/vts/functional/VtsHalCameraProviderV2_4TargetTest.cpp b/camera/provider/2.4/vts/functional/VtsHalCameraProviderV2_4TargetTest.cpp
index 038e1dd..19bc899 100644
--- a/camera/provider/2.4/vts/functional/VtsHalCameraProviderV2_4TargetTest.cpp
+++ b/camera/provider/2.4/vts/functional/VtsHalCameraProviderV2_4TargetTest.cpp
@@ -19,7 +19,7 @@
#include <android/hardware/camera/device/3.2/ICameraDevice.h>
#include <android/log.h>
#include <ui/GraphicBuffer.h>
-#include <gtest/gtest.h>
+#include <VtsHalHidlTargetBaseTest.h>
#include <regex>
#include "system/camera_metadata.h"
#include <hardware/gralloc.h>
@@ -131,7 +131,7 @@
void CameraHidlEnvironment::SetUp() {
// TODO: test the binderized mode
- mProvider = ICameraProvider::getService(CAMERA_PASSTHROUGH_SERVICE_NAME);
+ mProvider = ::testing::VtsHalHidlTargetBaseTest::getService<ICameraProvider>(CAMERA_PASSTHROUGH_SERVICE_NAME);
// TODO: handle the device doesn't have any camera case
ALOGI_IF(mProvider, "provider is not nullptr, %p", mProvider.get());
ASSERT_NE(mProvider, nullptr);
@@ -142,7 +142,7 @@
}
// The main test class for camera HIDL HAL.
-class CameraHidlTest : public ::testing::Test {
+class CameraHidlTest : public ::testing::VtsHalHidlTargetBaseTest {
public:
virtual void SetUp() override {}
virtual void TearDown() override {}
diff --git a/contexthub/1.0/vts/functional/Android.bp b/contexthub/1.0/vts/functional/Android.bp
index c3c121c..8ef5f62 100644
--- a/contexthub/1.0/vts/functional/Android.bp
+++ b/contexthub/1.0/vts/functional/Android.bp
@@ -16,7 +16,6 @@
cc_test {
name: "VtsHalContexthubV1_0TargetTest",
- gtest: true,
srcs: ["VtsHalContexthubV1_0TargetTest.cpp"],
shared_libs: [
"liblog",
@@ -25,7 +24,7 @@
"libutils",
"android.hardware.contexthub@1.0",
],
- static_libs: ["libgtest"],
+ static_libs: ["VtsHalHidlTargetBaseTest"],
cflags: [
"-O0",
"-g",
diff --git a/contexthub/1.0/vts/functional/VtsHalContexthubV1_0TargetTest.cpp b/contexthub/1.0/vts/functional/VtsHalContexthubV1_0TargetTest.cpp
index e4dea4f..c5eea89 100644
--- a/contexthub/1.0/vts/functional/VtsHalContexthubV1_0TargetTest.cpp
+++ b/contexthub/1.0/vts/functional/VtsHalContexthubV1_0TargetTest.cpp
@@ -21,7 +21,7 @@
#include <android/hardware/contexthub/1.0/IContexthubCallback.h>
#include <android/hardware/contexthub/1.0/types.h>
#include <android/log.h>
-#include <gtest/gtest.h>
+#include <VtsHalHidlTargetBaseTest.h>
#include <cinttypes>
#include <future>
@@ -80,7 +80,7 @@
static std::vector<uint32_t> hubIds;
if (hubIds.size() == 0) {
- sp<IContexthub> hubApi = IContexthub::getService(CONTEXTHUB_SERVICE_NAME);
+ sp<IContexthub> hubApi = ::testing::VtsHalHidlTargetBaseTest::getService<IContexthub>(CONTEXTHUB_SERVICE_NAME);
if (hubApi != nullptr) {
for (ContextHub hub : getHubsSync(hubApi)) {
@@ -95,10 +95,10 @@
// Base test fixture that initializes the HAL and makes the context hub API
// handle available
-class ContexthubHidlTestBase : public ::testing::Test {
+class ContexthubHidlTestBase : public ::testing::VtsHalHidlTargetBaseTest {
public:
virtual void SetUp() override {
- hubApi = IContexthub::getService(CONTEXTHUB_SERVICE_NAME);
+ hubApi = ::testing::VtsHalHidlTargetBaseTest::getService<IContexthub>(CONTEXTHUB_SERVICE_NAME);
ASSERT_NE(hubApi, nullptr);
// getHubs() must be called at least once for proper initialization of the
diff --git a/drm/1.0/default/CryptoPlugin.cpp b/drm/1.0/default/CryptoPlugin.cpp
index 4a4171b..9c51b15 100644
--- a/drm/1.0/default/CryptoPlugin.cpp
+++ b/drm/1.0/default/CryptoPlugin.cpp
@@ -144,7 +144,7 @@
status = android::OK;
bytesWritten = result;
} else {
- status = -result;
+ status = result;
bytesWritten = 0;
}
diff --git a/gatekeeper/1.0/vts/functional/Android.bp b/gatekeeper/1.0/vts/functional/Android.bp
index 080152d..c2c32a6 100644
--- a/gatekeeper/1.0/vts/functional/Android.bp
+++ b/gatekeeper/1.0/vts/functional/Android.bp
@@ -16,7 +16,6 @@
cc_test {
name: "VtsHalGatekeeperV1_0TargetTest",
- gtest: true,
srcs: ["VtsHalGatekeeperV1_0TargetTest.cpp"],
shared_libs: [
"libbase",
@@ -28,7 +27,7 @@
"libutils",
"android.hardware.gatekeeper@1.0",
],
- static_libs: ["libgtest"],
+ static_libs: ["VtsHalHidlTargetBaseTest"],
cflags: [
"-O0",
"-g",
diff --git a/gatekeeper/1.0/vts/functional/VtsHalGatekeeperV1_0TargetTest.cpp b/gatekeeper/1.0/vts/functional/VtsHalGatekeeperV1_0TargetTest.cpp
index bdc3956..8d6f726 100644
--- a/gatekeeper/1.0/vts/functional/VtsHalGatekeeperV1_0TargetTest.cpp
+++ b/gatekeeper/1.0/vts/functional/VtsHalGatekeeperV1_0TargetTest.cpp
@@ -30,7 +30,7 @@
#include <android/hardware/gatekeeper/1.0/IGatekeeper.h>
#include <android/hardware/gatekeeper/1.0/types.h>
-#include <gtest/gtest.h>
+#include <VtsHalHidlTargetBaseTest.h>
using ::android::hardware::hidl_string;
using ::android::hardware::hidl_vec;
@@ -76,7 +76,7 @@
}
// The main test class for Gatekeeper HIDL HAL.
-class GatekeeperHidlTest : public ::testing::Test {
+class GatekeeperHidlTest : public ::testing::VtsHalHidlTargetBaseTest {
protected:
void setUid(uint32_t uid) { uid_ = uid; }
@@ -187,7 +187,7 @@
GatekeeperHidlTest() : uid_(0) {}
virtual void SetUp() override {
GatekeeperResponse rsp;
- gatekeeper_ = IGatekeeper::getService();
+ gatekeeper_ = ::testing::VtsHalHidlTargetBaseTest::getService<IGatekeeper>();
ASSERT_NE(nullptr, gatekeeper_.get());
doDeleteAllUsers(rsp);
}
diff --git a/gnss/1.0/vts/functional/Android.bp b/gnss/1.0/vts/functional/Android.bp
index 5e27b67..2c8a6aa 100644
--- a/gnss/1.0/vts/functional/Android.bp
+++ b/gnss/1.0/vts/functional/Android.bp
@@ -16,7 +16,6 @@
cc_test {
name: "VtsHalGnssV1_0TargetTest",
- gtest: true,
srcs: ["VtsHalGnssV1_0TargetTest.cpp"],
shared_libs: [
"android.hardware.gnss@1.0",
@@ -28,7 +27,7 @@
"libnativehelper",
"libutils",
],
- static_libs: ["libgtest"],
+ static_libs: ["VtsHalHidlTargetBaseTest"],
cflags: [
"-O0",
"-g",
diff --git a/gnss/1.0/vts/functional/VtsHalGnssV1_0TargetTest.cpp b/gnss/1.0/vts/functional/VtsHalGnssV1_0TargetTest.cpp
index 3a9de9a..38c2715 100644
--- a/gnss/1.0/vts/functional/VtsHalGnssV1_0TargetTest.cpp
+++ b/gnss/1.0/vts/functional/VtsHalGnssV1_0TargetTest.cpp
@@ -18,7 +18,7 @@
#include <android/hardware/gnss/1.0/IGnss.h>
#include <android/log.h>
-#include <gtest/gtest.h>
+#include <VtsHalHidlTargetBaseTest.h>
#include <chrono>
#include <condition_variable>
@@ -36,7 +36,7 @@
#define TIMEOUT_SECONDS 5 // for basic commands/responses
// The main test class for GNSS HAL.
-class GnssHalTest : public ::testing::Test {
+class GnssHalTest : public ::testing::VtsHalHidlTargetBaseTest {
public:
virtual void SetUp() override {
/* TODO(b/35678469): Setup the init.rc for VTS such that there's a
@@ -45,7 +45,7 @@
* callbacks trigger.
*/
- gnss_hal_ = IGnss::getService();
+ gnss_hal_ = ::testing::VtsHalHidlTargetBaseTest::getService<IGnss>();
ASSERT_NE(gnss_hal_, nullptr);
gnss_cb_ = new GnssCallback(*this);
diff --git a/graphics/allocator/2.0/vts/functional/Android.bp b/graphics/allocator/2.0/vts/functional/Android.bp
index 8c0480b..fdc91ae 100644
--- a/graphics/allocator/2.0/vts/functional/Android.bp
+++ b/graphics/allocator/2.0/vts/functional/Android.bp
@@ -16,7 +16,6 @@
cc_test {
name: "VtsHalGraphicsAllocatorV2_0TargetTest",
- gtest: true,
srcs: ["VtsHalGraphicsAllocatorV2_0TargetTest.cpp"],
shared_libs: [
"libbase",
@@ -28,7 +27,7 @@
"libutils",
"android.hardware.graphics.allocator@2.0",
],
- static_libs: ["libgtest"],
+ static_libs: ["VtsHalHidlTargetBaseTest"],
cflags: [
"-O0",
"-g",
diff --git a/graphics/allocator/2.0/vts/functional/VtsHalGraphicsAllocatorV2_0TargetTest.cpp b/graphics/allocator/2.0/vts/functional/VtsHalGraphicsAllocatorV2_0TargetTest.cpp
index d45463e..a8ced8c 100644
--- a/graphics/allocator/2.0/vts/functional/VtsHalGraphicsAllocatorV2_0TargetTest.cpp
+++ b/graphics/allocator/2.0/vts/functional/VtsHalGraphicsAllocatorV2_0TargetTest.cpp
@@ -20,7 +20,7 @@
#include <android-base/logging.h>
#include <android/hardware/graphics/allocator/2.0/IAllocator.h>
-#include <gtest/gtest.h>
+#include <VtsHalHidlTargetBaseTest.h>
namespace android {
namespace hardware {
@@ -69,10 +69,10 @@
BufferDescriptor mDescriptor;
};
-class GraphicsAllocatorHidlTest : public ::testing::Test {
+class GraphicsAllocatorHidlTest : public ::testing::VtsHalHidlTargetBaseTest {
protected:
void SetUp() override {
- mAllocator = IAllocator::getService();
+ mAllocator = ::testing::VtsHalHidlTargetBaseTest::getService<IAllocator>();
ASSERT_NE(mAllocator, nullptr);
mAllocator->createClient([this](const auto& error, const auto& client) {
diff --git a/graphics/common/1.0/types.hal b/graphics/common/1.0/types.hal
index 7663701..1ddd892 100644
--- a/graphics/common/1.0/types.hal
+++ b/graphics/common/1.0/types.hal
@@ -792,7 +792,7 @@
TRANSFER_GAMMA2_8 = 6 << TRANSFER_SHIFT,
/*
- * SMPTE ST 2084
+ * SMPTE ST 2084 (Dolby Perceptual Quantizer)
*
* Transfer characteristic curve:
* E = ((c1 + c2 * L^n) / (1 + c3 * L^n)) ^ m
@@ -1068,6 +1068,15 @@
*/
BT2020 = STANDARD_BT2020 | TRANSFER_SMPTE_170M | RANGE_FULL,
+ /*
+ * ITU-R Recommendation 2020 (BT.2020)
+ *
+ * Ultra High-definition television
+ *
+ * Use full range, SMPTE 2084 (PQ) transfer and BT2020 standard
+ */
+ BT2020_PQ = STANDARD_BT2020 | TRANSFER_ST2084 | RANGE_FULL,
+
/*
* Data spaces for non-color formats
diff --git a/graphics/composer/2.1/vts/functional/Android.bp b/graphics/composer/2.1/vts/functional/Android.bp
index 1b8f351..9be04d1 100644
--- a/graphics/composer/2.1/vts/functional/Android.bp
+++ b/graphics/composer/2.1/vts/functional/Android.bp
@@ -16,7 +16,6 @@
cc_test {
name: "VtsHalGraphicsComposerV2_1TargetTest",
- gtest: true,
srcs: ["VtsHalGraphicsComposerV2_1TargetTest.cpp"],
shared_libs: [
"android.hardware.graphics.allocator@2.0",
@@ -32,7 +31,7 @@
"libsync",
"libutils",
],
- static_libs: ["libgtest", "libhwcomposer-command-buffer"],
+ static_libs: ["VtsHalHidlTargetBaseTest", "libhwcomposer-command-buffer"],
cflags: [
"-O0",
"-g",
diff --git a/graphics/composer/2.1/vts/functional/VtsHalGraphicsComposerV2_1TargetTest.cpp b/graphics/composer/2.1/vts/functional/VtsHalGraphicsComposerV2_1TargetTest.cpp
index d9352e7..a565845 100644
--- a/graphics/composer/2.1/vts/functional/VtsHalGraphicsComposerV2_1TargetTest.cpp
+++ b/graphics/composer/2.1/vts/functional/VtsHalGraphicsComposerV2_1TargetTest.cpp
@@ -22,7 +22,7 @@
#include <android/hardware/graphics/composer/2.1/IComposer.h>
#include <android/hardware/graphics/mapper/2.0/IMapper.h>
-#include <gtest/gtest.h>
+#include <VtsHalHidlTargetBaseTest.h>
#include <unistd.h>
#include <algorithm>
@@ -131,10 +131,10 @@
int mInvalidVsyncCount = 0;
};
-class GraphicsComposerHidlTest : public ::testing::Test {
+class GraphicsComposerHidlTest : public ::testing::VtsHalHidlTargetBaseTest {
protected:
void SetUp() override {
- mComposer = IComposer::getService();
+ mComposer = ::testing::VtsHalHidlTargetBaseTest::getService<IComposer>();
ASSERT_NE(nullptr, mComposer.get());
mComposerClient = createClient();
@@ -749,7 +749,7 @@
private:
void SetUpGralloc() {
- mAllocator = IAllocator::getService();
+ mAllocator = ::testing::VtsHalHidlTargetBaseTest::getService<IAllocator>();
ASSERT_NE(nullptr, mAllocator.get());
mAllocator->createClient([this](const auto& error, const auto& client) {
@@ -759,7 +759,7 @@
});
ASSERT_NE(nullptr, mAllocatorClient.get());
- mMapper = IMapper::getService();
+ mMapper = ::testing::VtsHalHidlTargetBaseTest::getService<IMapper>();
ASSERT_NE(nullptr, mMapper.get());
ASSERT_FALSE(mMapper->isRemote());
}
diff --git a/graphics/mapper/2.0/vts/functional/Android.bp b/graphics/mapper/2.0/vts/functional/Android.bp
index 79e1a44..24cd1be 100644
--- a/graphics/mapper/2.0/vts/functional/Android.bp
+++ b/graphics/mapper/2.0/vts/functional/Android.bp
@@ -16,7 +16,6 @@
cc_test {
name: "VtsHalGraphicsMapperV2_0TargetTest",
- gtest: true,
srcs: ["VtsHalGraphicsMapperV2_0TargetTest.cpp"],
shared_libs: [
"libbase",
@@ -31,7 +30,7 @@
"android.hardware.graphics.mapper@2.0",
"android.hardware.graphics.common@1.0",
],
- static_libs: ["libgtest"],
+ static_libs: ["VtsHalHidlTargetBaseTest"],
cflags: [
"-O0",
"-g",
diff --git a/graphics/mapper/2.0/vts/functional/VtsHalGraphicsMapperV2_0TargetTest.cpp b/graphics/mapper/2.0/vts/functional/VtsHalGraphicsMapperV2_0TargetTest.cpp
index 65ad63a..b2a37dd 100644
--- a/graphics/mapper/2.0/vts/functional/VtsHalGraphicsMapperV2_0TargetTest.cpp
+++ b/graphics/mapper/2.0/vts/functional/VtsHalGraphicsMapperV2_0TargetTest.cpp
@@ -19,7 +19,7 @@
#include <android-base/logging.h>
#include <android/hardware/graphics/allocator/2.0/IAllocator.h>
#include <android/hardware/graphics/mapper/2.0/IMapper.h>
-#include <gtest/gtest.h>
+#include <VtsHalHidlTargetBaseTest.h>
#include <sync/sync.h>
namespace android {
@@ -33,10 +33,10 @@
using namespace android::hardware::graphics::allocator::V2_0;
using namespace android::hardware::graphics::common::V1_0;
-class GraphicsMapperHidlTest : public ::testing::Test {
+class GraphicsMapperHidlTest : public ::testing::VtsHalHidlTargetBaseTest {
protected:
void SetUp() override {
- mAllocator = IAllocator::getService();
+ mAllocator = ::testing::VtsHalHidlTargetBaseTest::getService<IAllocator>();
ASSERT_NE(mAllocator, nullptr);
mAllocator->createClient([this](const auto& error, const auto& client) {
@@ -46,7 +46,7 @@
});
ASSERT_NE(mAllocatorClient, nullptr);
- mMapper = IMapper::getService();
+ mMapper = ::testing::VtsHalHidlTargetBaseTest::getService<IMapper>();
ASSERT_NE(nullptr, mMapper.get());
ASSERT_FALSE(mMapper->isRemote());
diff --git a/ir/1.0/vts/functional/VtsHalIrV1_0TargetTest.cpp b/ir/1.0/vts/functional/VtsHalIrV1_0TargetTest.cpp
index 1dd0405..605eabb 100644
--- a/ir/1.0/vts/functional/VtsHalIrV1_0TargetTest.cpp
+++ b/ir/1.0/vts/functional/VtsHalIrV1_0TargetTest.cpp
@@ -34,7 +34,7 @@
class ConsumerIrHidlTest : public ::testing::VtsHalHidlTargetBaseTest {
public:
virtual void SetUp() override {
- ir = testing::VtsHalHidlTargetBaseTest::getService<IConsumerIr>();
+ ir = ::testing::VtsHalHidlTargetBaseTest::getService<IConsumerIr>();
ASSERT_NE(ir, nullptr);
}
diff --git a/light/2.0/vts/functional/Android.bp b/light/2.0/vts/functional/Android.bp
index 9c9ff9d..c21aa6b 100644
--- a/light/2.0/vts/functional/Android.bp
+++ b/light/2.0/vts/functional/Android.bp
@@ -16,7 +16,6 @@
cc_test {
name: "VtsHalLightV2_0TargetTest",
- gtest: true,
srcs: ["VtsHalLightV2_0TargetTest.cpp"],
shared_libs: [
"libbase",
@@ -25,7 +24,7 @@
"libutils",
"android.hardware.light@2.0",
],
- static_libs: ["libgtest"],
+ static_libs: ["VtsHalHidlTargetBaseTest"],
cflags: [
"-O0",
"-g",
diff --git a/light/2.0/vts/functional/VtsHalLightV2_0TargetTest.cpp b/light/2.0/vts/functional/VtsHalLightV2_0TargetTest.cpp
index 7abb6e7..50b6d5f 100644
--- a/light/2.0/vts/functional/VtsHalLightV2_0TargetTest.cpp
+++ b/light/2.0/vts/functional/VtsHalLightV2_0TargetTest.cpp
@@ -19,7 +19,7 @@
#include <android-base/logging.h>
#include <android/hardware/light/2.0/ILight.h>
#include <android/hardware/light/2.0/types.h>
-#include <gtest/gtest.h>
+#include <VtsHalHidlTargetBaseTest.h>
#include <set>
#include <unistd.h>
@@ -72,10 +72,10 @@
Type::WIFI
};
-class LightHidlTest : public ::testing::Test {
+class LightHidlTest : public ::testing::VtsHalHidlTargetBaseTest {
public:
virtual void SetUp() override {
- light = ILight::getService();
+ light = ::testing::VtsHalHidlTargetBaseTest::getService<ILight>();
ASSERT_NE(light, nullptr);
LOG(INFO) << "Test is remote " << light->isRemote();
diff --git a/memtrack/1.0/vts/functional/Android.bp b/memtrack/1.0/vts/functional/Android.bp
index b9d89be..27781af 100644
--- a/memtrack/1.0/vts/functional/Android.bp
+++ b/memtrack/1.0/vts/functional/Android.bp
@@ -16,7 +16,6 @@
cc_test {
name: "VtsHalMemtrackV1_0TargetTest",
- gtest: true,
srcs: ["VtsHalMemtrackV1_0TargetTest.cpp"],
shared_libs: [
"libbase",
@@ -27,7 +26,7 @@
"libutils",
"android.hardware.memtrack@1.0",
],
- static_libs: ["libgtest"],
+ static_libs: ["VtsHalHidlTargetBaseTest"],
cflags: [
"-O0",
"-g",
diff --git a/memtrack/1.0/vts/functional/VtsHalMemtrackV1_0TargetTest.cpp b/memtrack/1.0/vts/functional/VtsHalMemtrackV1_0TargetTest.cpp
index a4b4fa9..1113f42 100644
--- a/memtrack/1.0/vts/functional/VtsHalMemtrackV1_0TargetTest.cpp
+++ b/memtrack/1.0/vts/functional/VtsHalMemtrackV1_0TargetTest.cpp
@@ -18,7 +18,7 @@
#include <android-base/logging.h>
#include <android/hardware/memtrack/1.0/IMemtrack.h>
-#include <gtest/gtest.h>
+#include <VtsHalHidlTargetBaseTest.h>
#include <algorithm>
#include <vector>
@@ -34,10 +34,10 @@
using std::vector;
using std::count_if;
-class MemtrackHidlTest : public ::testing::Test {
+class MemtrackHidlTest : public ::testing::VtsHalHidlTargetBaseTest {
public:
virtual void SetUp() override {
- memtrack = IMemtrack::getService();
+ memtrack = ::testing::VtsHalHidlTargetBaseTest::getService<IMemtrack>();
ASSERT_NE(memtrack, nullptr);
}
diff --git a/nfc/1.0/vts/functional/VtsHalNfcV1_0TargetTest.cpp b/nfc/1.0/vts/functional/VtsHalNfcV1_0TargetTest.cpp
index ae21f9a..5b6089d 100644
--- a/nfc/1.0/vts/functional/VtsHalNfcV1_0TargetTest.cpp
+++ b/nfc/1.0/vts/functional/VtsHalNfcV1_0TargetTest.cpp
@@ -59,7 +59,7 @@
class NfcHidlTest : public ::testing::VtsHalHidlTargetBaseTest {
public:
virtual void SetUp() override {
- nfc_ = testing::VtsHalHidlTargetBaseTest::getService<INfc>();
+ nfc_ = ::testing::VtsHalHidlTargetBaseTest::getService<INfc>();
ASSERT_NE(nfc_, nullptr);
nfc_cb_ = new NfcClientCallback(*this);
diff --git a/power/1.0/vts/functional/Android.bp b/power/1.0/vts/functional/Android.bp
index 9d1118e..984f9e3 100644
--- a/power/1.0/vts/functional/Android.bp
+++ b/power/1.0/vts/functional/Android.bp
@@ -16,7 +16,6 @@
cc_test {
name: "VtsHalPowerV1_0TargetTest",
- gtest: true,
srcs: ["VtsHalPowerV1_0TargetTest.cpp"],
shared_libs: [
"libbase",
@@ -28,7 +27,7 @@
"libutils",
"android.hardware.power@1.0",
],
- static_libs: ["libgtest"],
+ static_libs: ["VtsHalHidlTargetBaseTest"],
cflags: [
"-O0",
"-g",
diff --git a/power/1.0/vts/functional/VtsHalPowerV1_0TargetTest.cpp b/power/1.0/vts/functional/VtsHalPowerV1_0TargetTest.cpp
index 7a34f00..757367b 100644
--- a/power/1.0/vts/functional/VtsHalPowerV1_0TargetTest.cpp
+++ b/power/1.0/vts/functional/VtsHalPowerV1_0TargetTest.cpp
@@ -22,7 +22,7 @@
#include <android-base/unique_fd.h>
#include <android/hardware/power/1.0/IPower.h>
-#include <gtest/gtest.h>
+#include <VtsHalHidlTargetBaseTest.h>
#include <algorithm>
@@ -43,10 +43,10 @@
#define AVAILABLE_GOVERNORS_PATH \
"/sys/devices/system/cpu/cpu0/cpufreq/scaling_available_governors"
-class PowerHidlTest : public ::testing::Test {
+class PowerHidlTest : public ::testing::VtsHalHidlTargetBaseTest {
public:
virtual void SetUp() override {
- power = IPower::getService();
+ power = ::testing::VtsHalHidlTargetBaseTest::getService<IPower>();
ASSERT_NE(power, nullptr);
}
diff --git a/radio/1.0/Android.mk b/radio/1.0/Android.mk
index 7f4c7d4..94072fb 100644
--- a/radio/1.0/Android.mk
+++ b/radio/1.0/Android.mk
@@ -929,6 +929,25 @@
LOCAL_GENERATED_SOURCES += $(GEN)
#
+# Build types.hal (CellIdentity)
+#
+GEN := $(intermediates)/android/hardware/radio/V1_0/CellIdentity.java
+$(GEN): $(HIDL)
+$(GEN): PRIVATE_HIDL := $(HIDL)
+$(GEN): PRIVATE_DEPS := $(LOCAL_PATH)/types.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.radio@1.0::types.CellIdentity
+
+$(GEN): $(LOCAL_PATH)/types.hal
+ $(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
# Build types.hal (CellIdentityCdma)
#
GEN := $(intermediates)/android/hardware/radio/V1_0/CellIdentityCdma.java
@@ -3944,6 +3963,25 @@
LOCAL_GENERATED_SOURCES += $(GEN)
#
+# Build types.hal (CellIdentity)
+#
+GEN := $(intermediates)/android/hardware/radio/V1_0/CellIdentity.java
+$(GEN): $(HIDL)
+$(GEN): PRIVATE_HIDL := $(HIDL)
+$(GEN): PRIVATE_DEPS := $(LOCAL_PATH)/types.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.radio@1.0::types.CellIdentity
+
+$(GEN): $(LOCAL_PATH)/types.hal
+ $(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN)
+
+#
# Build types.hal (CellIdentityCdma)
#
GEN := $(intermediates)/android/hardware/radio/V1_0/CellIdentityCdma.java
diff --git a/radio/1.0/IRadio.hal b/radio/1.0/IRadio.hal
index baa4df6..a8c9d93 100644
--- a/radio/1.0/IRadio.hal
+++ b/radio/1.0/IRadio.hal
@@ -378,13 +378,18 @@
* @param radioTechnology Radio technology to use.
* @param dataProfileInfo data profile info.
* @param modemCognitive Indicating this profile was sent to the modem through setDataProfile
- * earlier.
+ * earlier.
* @param roamingAllowed Indicating data roaming is allowed or not by the user.
+ * @param isRoaming Indicating the device is roaming or not. The 'protocol' parameter in the old
+ * RIL API must be filled accordingly based on the roaming condition.
+ * Note this is for backward compatibility with the old radio modem. The modem
+ * must not use this param for any other reason.
*
* Response function is IRadioResponse.setupDataCallResponse()
*/
oneway setupDataCall(int32_t serial, RadioTechnology radioTechnology,
- DataProfileInfo dataProfileInfo, bool modemCognitive, bool roamingAllowed);
+ DataProfileInfo dataProfileInfo, bool modemCognitive, bool roamingAllowed,
+ bool isRoaming);
/*
* Request ICC I/O operation.
@@ -1139,7 +1144,7 @@
oneway reportSmsMemoryStatus(int32_t serial, bool available);
/*
- * Indicates that the StkSerivce is running and is
+ * Indicates that the StkService is running and is
* ready to receive unsolicited stkXXXXX commands.
*
* @param serial Serial number of request.
@@ -1241,13 +1246,17 @@
*
* @param serial Serial number of request.
* @param dataProfileInfo data profile containing APN settings
- * @param modemCognitive is indicating the data profile was sent to the modem through
- * setDataProfile earlier.
+ * @param modemCognitive indicating the data profile was sent to the modem through
+ * setDataProfile earlier.
+ * @param isRoaming Indicating the device is roaming or not. The 'protocol' parameter in the old
+ * RIL_InitialAttachApn must be filled accordingly based on the roaming
+ * condition. Note this is for backward compatibility with the old radio modem.
+ * The modem must not use this param for any other reason.
*
* Response callback is IRadioResponse.setInitialAttachApnResponse()
*/
oneway setInitialAttachApn(int32_t serial, DataProfileInfo dataProfileInfo,
- bool modemCognitive);
+ bool modemCognitive, bool isRoaming);
/*
* Request current IMS registration state
@@ -1413,10 +1422,14 @@
*
* @param serial Serial number of request.
* @param profiles Array of DataProfiles to set.
+ * @param isRoaming Indicating the device is roaming or not. The 'protocol' parameter in the old
+ * RIL API RIL_DataProfileInfo must be filled accordingly based on the
+ * roaming condition. Note this is for backward compatibility with the old
+ * radio modem. The modem must not use this param for any other reason.
*
* Response callback is IRadioResponse.setDataProfileResponse()
*/
- oneway setDataProfile(int32_t serial, vec<DataProfileInfo> profiles);
+ oneway setDataProfile(int32_t serial, vec<DataProfileInfo> profiles, bool isRoaming);
/*
* Device is shutting down. All further commands are ignored
@@ -1429,7 +1442,7 @@
oneway requestShutdown(int32_t serial);
/*
- * Used to get phone radio capablility.
+ * Used to get phone radio capability.
*
* @param serial Serial number of request.
*
diff --git a/radio/1.0/types.hal b/radio/1.0/types.hal
index 91030ef..7c1d143 100644
--- a/radio/1.0/types.hal
+++ b/radio/1.0/types.hal
@@ -499,21 +499,21 @@
* "managed roaming"
*/
enum RegState : int32_t {
- NOT_REG_MT_NOT_SEARCHING_OP, // Not registered, MT is not currently searching
+ NOT_REG_MT_NOT_SEARCHING_OP = 0, // Not registered, MT is not currently searching
// a new operator to register
- REG_HOME, // Registered, home network
- NOT_REG_MT_SEARCHING_OP, // Not registered, but MT is currently searching
+ REG_HOME = 1, // Registered, home network
+ NOT_REG_MT_SEARCHING_OP = 2, // Not registered, but MT is currently searching
// a new operator to register
- REG_DENIED, // Registration denied
- UNKNOWN, // Unknown
- REG_ROAMING, // Registered, roaming
- NOT_REG_MT_NOT_SEARCHING_OP_EM, // Same as NOT_REG_MT_NOT_SEARCHING_OP but indicates that
+ REG_DENIED = 3, // Registration denied
+ UNKNOWN = 4, // Unknown
+ REG_ROAMING = 5, // Registered, roaming
+ NOT_REG_MT_NOT_SEARCHING_OP_EM = 10, // Same as NOT_REG_MT_NOT_SEARCHING_OP but indicates that
// emergency calls are enabled.
- NOT_REG_MT_SEARCHING_OP_EM, // Same as NOT_REG_MT_SEARCHING_OP but indicates that
+ NOT_REG_MT_SEARCHING_OP_EM = 12, // Same as NOT_REG_MT_SEARCHING_OP but indicates that
// emergency calls are enabled.
- REG_DENIED_EM, // Same as REG_DENIED but indicates that
+ REG_DENIED_EM = 13, // Same as REG_DENIED but indicates that
// emergency calls are enabled.
- UNKNOWN_EM, // Same as UNKNOWN but indicates that
+ UNKNOWN_EM = 14, // Same as UNKNOWN but indicates that
// emergency calls are enabled.
};
@@ -815,6 +815,7 @@
};
enum CellInfoType : int32_t {
+ NONE = 0,
GSM = 1,
CDMA = 2,
LTE = 3,
@@ -1281,11 +1282,11 @@
};
struct SetupDataCallResult {
- int32_t status; // A RadioDataCallFailCause, 0 which is
- // RadioDataCallFailCause:NONE if no error
- int32_t suggestedRetryTime; // If status != 0, this fields indicates the suggested
- // retry back-off timer value RIL wants to override the
- // one pre-configured in FW.
+ DataCallFailCause status; // Data call fail cause. DataCallFailCause.NONE if no
+ // error.
+ int32_t suggestedRetryTime; // If status != DataCallFailCause.NONE, this field
+ // indicates the suggested retry back-off timer value RIL
+ // wants to override the one pre-configured in FW.
// The unit is milliseconds.
// The value < 0 means no value is suggested.
// The value 0 means retry must be done ASAP.
@@ -1296,8 +1297,8 @@
string type; // One of the PDP_type values in TS 27.007 section 10.1.1.
// For example, "IP", "IPV6", "IPV4V6", or "PPP". If
// status is
- // RadioDataCallFailCause:ONLY_SINGLE_BEARER_ALLOWED this
- // is the type supported such as "IP" or "IPV6"
+ // DataCallFailCause.ONLY_SINGLE_BEARER_ALLOWED, this
+ // is the type supported such as "IP" or "IPV6".
string ifname; // The network interface name
string addresses; // A space-delimited list of addresses with optional "/"
// prefix length, e.g., "192.0.1.3" or
@@ -1343,125 +1344,6 @@
// Base64 format, see 3GPP TS 31.102 7.1.2
};
-struct VoiceRegStateResult {
- RegState regState;
- int32_t lac; // LAC if registered on a GSM/WCDMA system or
- // -1 if not.Valid LAC are 0x0000 - 0xffff
- int32_t cid; // CID. if registered on a * GSM/WCDMA or -1 if not
- // Valid CID are 0x00000000 - 0xffffffff
- // In GSM, CID is Cell ID (see TS 27.007) in 16 bits
- // In UMTS, CID is UMTS Cell Identity (see TS 25.331)
- // in 28 bits
- int32_t rat; // indicates the available voice radio technology,
- // valid values as defined by RadioTechnology.
- int32_t baseStationId; // Base Station ID. if registered on a CDMA
- // system or -1 if not. Base Station ID in decimal format
- int32_t baseStationLatitude; // Base Station latitude. if registered on a
- // CDMA system or -1 if not. Base Station latitude is a
- // decimal number as specified in 3GPP2 C.S0005-A v6.0.
- // It is represented in units of 0.25 seconds and ranges
- // from -1296000 to 1296000, both values inclusive
- // (corresponding to a range of -90 to +90 degrees).
- int32_t baseStationLongitude; // Base Station longitude. if registered on a
- // CDMA system or -1 if not. Base Station
- // longitude is a decimal number as specified in
- // 3GPP2 C.S0005-A v6.0. It is represented in
- // units of 0.25 seconds and ranges from -2592000
- // to 2592000, both values inclusive (corresponding
- // to a range of -180 to +180 degrees).
- bool cssSupported; // concurrent services support indicator. if
- // registered on a CDMA system.
- // false - Concurrent services not supported,
- // true - Concurrent services supported
- int32_t systemId; // System ID. if registered on a CDMA system or
- // -1 if not. Valid System ID are 0 - 32767
- int32_t networkId; // Network ID. if registered on a CDMA system or
- // -1 if not. Valid System ID are 0 - 65535
- int32_t roamingIndicator; // TSB-58 Roaming Indicator if registered
- // on a CDMA or EVDO system or -1 if not.
- // Valid values are 0-255.
- int32_t systemIsInPrl; // indicates whether the current system is in the
- // PRL if registered on a CDMA or EVDO system or -1 if
- // not. 0=not in the PRL, 1=in the PRL
- int32_t defaultRoamingIndicator; // default Roaming Indicator from the PRL,
- // if registered on a CDMA or EVDO system or -1 if not.
- // Valid values are 0-255.
- int32_t reasonForDenial; // reasonForDenial if registration state is 3
- // (Registration denied) this is an enumerated reason why
- // registration was denied. See 3GPP TS 24.008,
- // 10.5.3.6 and Annex G.
- // 0 - General
- // 1 - Authentication Failure
- // 2 - IMSI unknown in HLR
- // 3 - Illegal MS
- // 4 - Illegal ME
- // 5 - PLMN not allowed
- // 6 - Location area not allowed
- // 7 - Roaming not allowed
- // 8 - No Suitable Cells in this Location Area
- // 9 - Network failure
- // 10 - Persistent location update reject
- // 11 - PLMN not allowed
- // 12 - Location area not allowed
- // 13 - Roaming not allowed in this Location Area
- // 15 - No Suitable Cells in this Location Area
- // 17 - Network Failure
- // 20 - MAC Failure
- // 21 - Sync Failure
- // 22 - Congestion
- // 23 - GSM Authentication unacceptable
- // 25 - Not Authorized for this CSG
- // 32 - Service option not supported
- // 33 - Requested service option not subscribed
- // 34 - Service option temporarily out of order
- // 38 - Call cannot be identified
- // 48-63 - Retry upon entry into a new cell
- // 95 - Semantically incorrect message
- // 96 - Invalid mandatory information
- // 97 - Message type non-existent or not implemented
- // 98 - Message type not compatible with protocol state
- // 99 - Information element non-existent or not implemented
- // 100 - Conditional IE error
- // 101 - Message not compatible with protocol state
- // 111 - Protocol error, unspecified
- int32_t psc; // Primary Scrambling Code of the current
- // cell as described in TS 25.331, in hexadecimal
- // format, or -1 if unknown or not registered
- // to a UMTS network.
-};
-
-struct DataRegStateResult {
- RegState regState; // Valid reg states are NOT_REG_MT_NOT_SEARCHING_OP,
- // REG_HOME, NOT_REG_MT_SEARCHING_OP, REG_DENIED,
- // UNKNOWN, REG_ROAMING defined in RegState
- int32_t lac; // LAC if registered or -1 if not
- // valid LAC are 0x0000 - 0xffff
- int32_t cid; // CID if registered or -1 if not
- // valid CID are 0x00000000 - 0x0fffffff
- int32_t rat; // indicates the available data radio technology,
- // valid values as defined by RadioTechnology.
- int32_t reasonDataDenied; // if registration state is 3 (Registration
- // denied) this is an enumerated reason why
- // registration was denied. See 3GPP TS 24.008,
- // Annex G.6 "Additional cause codes for GMM".
- // 7 == GPRS services not allowed
- // 8 == GPRS services and non-GPRS services not allowed
- // 9 == MS identity cannot be derived by the network
- // 10 == Implicitly detached
- // 14 == GPRS services not allowed in this PLMN
- // 16 == MSC temporarily not reachable
- // 40 == No PDP context activated
- int32_t maxDataCalls; // The maximum number of simultaneous Data Calls that
- // must be established using setupDataCall().
- // The values below are optional LTE location information in decimal.
- // If a value is unknown that value must be -1.
- int32_t tac; // a 16-bit Tracking Area Code.
- int32_t phyCid; // a 0-503 Physical Cell Identifier.
- int32_t eci; // a 28-bit E-UTRAN Cell Identifier.
- int32_t csgid; // a 27-bit Closed Subscriber Group Identity.
- int32_t tadv; // a 6-bit timing advance value.
-};
-
// See also com.android.internal.telephony.gsm.CallForwardInfo
struct CallForwardInfo {
CallForwardInfoStatus status; // For queryCallForwardStatus()
@@ -1687,6 +1569,100 @@
// empty
};
+struct CellIdentity {
+ CellInfoType cellInfoType; // cell type for selecting from union CellInfo
+ // Only one of the below vectors must be of size 1, based on a valid CellInfoType and
+ // others must be of size 0. If cell info type is NONE, then all the vectors
+ // must be of size 0.
+ vec<CellIdentityGsm> cellIdentityGsm;
+ vec<CellIdentityWcdma> cellIdentityWcdma;
+ vec<CellIdentityCdma> cellIdentityCdma;
+ vec<CellIdentityLte> cellIdentityLte;
+ vec<CellIdentityTdscdma> cellIdentityTdscdma;
+};
+
+struct VoiceRegStateResult {
+ RegState regState; // Valid reg states are NOT_REG_MT_NOT_SEARCHING_OP,
+ // REG_HOME, NOT_REG_MT_SEARCHING_OP, REG_DENIED,
+ // UNKNOWN, REG_ROAMING defined in RegState
+ int32_t rat; // indicates the available voice radio technology,
+ // valid values as defined by RadioTechnology.
+ bool cssSupported; // concurrent services support indicator. if
+ // registered on a CDMA system.
+ // false - Concurrent services not supported,
+ // true - Concurrent services supported
+ int32_t roamingIndicator; // TSB-58 Roaming Indicator if registered
+ // on a CDMA or EVDO system or -1 if not.
+ // Valid values are 0-255.
+ int32_t systemIsInPrl; // indicates whether the current system is in the
+ // PRL if registered on a CDMA or EVDO system or -1 if
+ // not. 0=not in the PRL, 1=in the PRL
+ int32_t defaultRoamingIndicator; // default Roaming Indicator from the PRL,
+ // if registered on a CDMA or EVDO system or -1 if not.
+ // Valid values are 0-255.
+ int32_t reasonForDenial; // reasonForDenial if registration state is 3
+ // (Registration denied) this is an enumerated reason why
+ // registration was denied. See 3GPP TS 24.008,
+ // 10.5.3.6 and Annex G.
+ // 0 - General
+ // 1 - Authentication Failure
+ // 2 - IMSI unknown in HLR
+ // 3 - Illegal MS
+ // 4 - Illegal ME
+ // 5 - PLMN not allowed
+ // 6 - Location area not allowed
+ // 7 - Roaming not allowed
+ // 8 - No Suitable Cells in this Location Area
+ // 9 - Network failure
+ // 10 - Persistent location update reject
+ // 11 - PLMN not allowed
+ // 12 - Location area not allowed
+ // 13 - Roaming not allowed in this Location Area
+ // 15 - No Suitable Cells in this Location Area
+ // 17 - Network Failure
+ // 20 - MAC Failure
+ // 21 - Sync Failure
+ // 22 - Congestion
+ // 23 - GSM Authentication unacceptable
+ // 25 - Not Authorized for this CSG
+ // 32 - Service option not supported
+ // 33 - Requested service option not subscribed
+ // 34 - Service option temporarily out of order
+ // 38 - Call cannot be identified
+ // 48-63 - Retry upon entry into a new cell
+ // 95 - Semantically incorrect message
+ // 96 - Invalid mandatory information
+ // 97 - Message type non-existent or not implemented
+ // 98 - Message type not compatible with protocol state
+ // 99 - Information element non-existent or not implemented
+ // 100 - Conditional IE error
+ // 101 - Message not compatible with protocol state
+ // 111 - Protocol error, unspecified
+ CellIdentity cellIdentity;
+};
+
+struct DataRegStateResult {
+ RegState regState; // Valid reg states are NOT_REG_MT_NOT_SEARCHING_OP,
+ // REG_HOME, NOT_REG_MT_SEARCHING_OP, REG_DENIED,
+ // UNKNOWN, REG_ROAMING defined in RegState
+ int32_t rat; // indicates the available data radio technology,
+ // valid values as defined by RadioTechnology.
+ int32_t reasonDataDenied; // if registration state is 3 (Registration
+ // denied) this is an enumerated reason why
+ // registration was denied. See 3GPP TS 24.008,
+ // Annex G.6 "Additional cause codes for GMM".
+ // 7 == GPRS services not allowed
+ // 8 == GPRS services and non-GPRS services not allowed
+ // 9 == MS identity cannot be derived by the network
+ // 10 == Implicitly detached
+ // 14 == GPRS services not allowed in this PLMN
+ // 16 == MSC temporarily not reachable
+ // 40 == No PDP context activated
+ int32_t maxDataCalls; // The maximum number of simultaneous Data Calls that
+ // must be established using setupDataCall().
+ CellIdentity cellIdentity;
+};
+
struct GsmSmsMessage {
string smscPdu; // SMSC address in GSM BCD format prefixed by a length
// byte (as expected by TS 27.005) or empty string for
@@ -2005,4 +1981,4 @@
// to send all of them.
vec<uint8_t> contents; // Carrier-defined content. It is binary, opaque and
// loosely defined in LTE Layer 3 spec 24.008
-};
\ No newline at end of file
+};
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 9b540e8..bd979b0 100644
--- a/radio/1.0/vts/functional/radio_hidl_hal_icc.cpp
+++ b/radio/1.0/vts/functional/radio_hidl_hal_icc.cpp
@@ -20,86 +20,271 @@
* Test IRadio.getIccCardStatus() for the response returned.
*/
TEST_F(RadioHidlTest, getIccCardStatus) {
- 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(radioRsp->rspInfo.error, RadioError::NONE);
-
- EXPECT_LE(radioRsp->cardStatus.applications.size(), (unsigned int) RadioConst::CARD_MAX_APPS);
- EXPECT_LT(radioRsp->cardStatus.gsmUmtsSubscriptionAppIndex, (int) RadioConst::CARD_MAX_APPS);
- EXPECT_LT(radioRsp->cardStatus.cdmaSubscriptionAppIndex, (int) RadioConst::CARD_MAX_APPS);
- EXPECT_LT(radioRsp->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 IRadio.supplyIccPinForApp() for the response returned
*/
TEST_F(RadioHidlTest, supplyIccPinForApp) {
- radio->supplyIccPinForApp(2, hidl_string("test1"), hidl_string());
- EXPECT_EQ(std::cv_status::no_timeout, wait());
- EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
- EXPECT_EQ(2, radioRsp->rspInfo.serial);
+ int serial = 1;
- EXPECT_EQ(radioRsp->rspInfo.error, RadioError::PASSWORD_INCORRECT);
+ // 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) {
- radio->supplyIccPukForApp(3, hidl_string("test1"), hidl_string("test2"), hidl_string());
- EXPECT_EQ(std::cv_status::no_timeout, wait());
- EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
- EXPECT_EQ(3, radioRsp->rspInfo.serial);
+ int serial = 1;
- EXPECT_EQ(radioRsp->rspInfo.error, RadioError::PASSWORD_INCORRECT);
+ // 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) {
- radio->supplyIccPin2ForApp(4, hidl_string("test1"), hidl_string());
- EXPECT_EQ(std::cv_status::no_timeout, wait());
- EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
- EXPECT_EQ(4, radioRsp->rspInfo.serial);
+ int serial = 1;
- EXPECT_EQ(radioRsp->rspInfo.error, RadioError::PASSWORD_INCORRECT);
+ // 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) {
- radio->supplyIccPuk2ForApp(5, hidl_string("test1"), hidl_string("test2"), hidl_string());
- EXPECT_EQ(std::cv_status::no_timeout, wait());
- EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
- EXPECT_EQ(5, radioRsp->rspInfo.serial);
+ int serial = 1;
- EXPECT_EQ(radioRsp->rspInfo.error, RadioError::PASSWORD_INCORRECT);
+ // 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) {
- radio->changeIccPinForApp(6, hidl_string("test1"), hidl_string("test2"), hidl_string());
- EXPECT_EQ(std::cv_status::no_timeout, wait());
- EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
- EXPECT_EQ(6, radioRsp->rspInfo.serial);
+ int serial = 1;
- EXPECT_EQ(radioRsp->rspInfo.error, RadioError::PASSWORD_INCORRECT);
+ // 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) {
- radio->changeIccPin2ForApp(7, hidl_string("test1"), hidl_string("test2"), hidl_string());
+ 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);
+ }
+ }
+}
+
+/*
+ * Test IRadio.getImsiForApp() for the response returned.
+ */
+TEST_F(RadioHidlTest, getImsiForApp) {
+ 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);
+
+ // 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;
+
+ 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);
+ }
+}
+
+/*
+ * 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();
+
+ radio->iccTransmitApduBasicChannel(serial, msg);
EXPECT_EQ(std::cv_status::no_timeout, wait());
EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
- EXPECT_EQ(7, radioRsp->rspInfo.serial);
+ EXPECT_EQ(serial, radioRsp->rspInfo.serial);
- EXPECT_EQ(radioRsp->rspInfo.error, RadioError::PASSWORD_INCORRECT);
+ // TODO(sanketpadawe): Add test for error code
}
+
+/*
+ * Test IRadio.iccOpenLogicalChannel() for the response returned.
+ */
+TEST_F(RadioHidlTest, iccOpenLogicalChannel) {
+ 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);
+ }
+}
+
+/*
+ * 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);
+
+ 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();
+
+ 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
+}
+
+/*
+ * Test IRadio.requestIccSimAuthentication() for the response returned.
+ */
+TEST_F(RadioHidlTest, requestIccSimAuthentication) {
+ 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);
+ }
+}
\ No newline at end of file
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 d1ab06a..50b27e9 100644
--- a/radio/1.0/vts/functional/radio_hidl_hal_test.cpp
+++ b/radio/1.0/vts/functional/radio_hidl_hal_test.cpp
@@ -17,7 +17,7 @@
#include<radio_hidl_hal_utils.h>
void RadioHidlTest::SetUp() {
- radio = testing::VtsHalHidlTargetBaseTest::getService<IRadio>(hidl_string("rild"));
+ radio = ::testing::VtsHalHidlTargetBaseTest::getService<IRadio>(hidl_string("rild"));
ASSERT_NE(radio, nullptr);
radioRsp = new RadioResponse(*this);
@@ -27,6 +27,12 @@
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);
}
void RadioHidlTest::TearDown() {
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 732d88e..0429226 100644
--- a/radio/1.0/vts/functional/radio_hidl_hal_utils.h
+++ b/radio/1.0/vts/functional/radio_hidl_hal_utils.h
@@ -27,6 +27,7 @@
#include <android/hardware/radio/1.0/types.h>
using ::android::hardware::radio::V1_0::ActivityStatsInfo;
+using ::android::hardware::radio::V1_0::AppType;
using ::android::hardware::radio::V1_0::CardStatus;
using ::android::hardware::radio::V1_0::Call;
using ::android::hardware::radio::V1_0::CallForwardInfo;
@@ -39,6 +40,7 @@
using ::android::hardware::radio::V1_0::DataRegStateResult;
using ::android::hardware::radio::V1_0::GsmBroadcastSmsConfigInfo;
using ::android::hardware::radio::V1_0::HardwareConfig;
+using ::android::hardware::radio::V1_0::IccIo;
using ::android::hardware::radio::V1_0::IccIoResult;
using ::android::hardware::radio::V1_0::IRadio;
using ::android::hardware::radio::V1_0::IRadioResponse;
@@ -60,6 +62,7 @@
using ::android::hardware::radio::V1_0::SendSmsResult;
using ::android::hardware::radio::V1_0::SetupDataCallResult;
using ::android::hardware::radio::V1_0::SignalStrength;
+using ::android::hardware::radio::V1_0::SimApdu;
using ::android::hardware::radio::V1_0::TtyMode;
using ::android::hardware::radio::V1_0::VoiceRegStateResult;
@@ -71,6 +74,7 @@
#define TIMEOUT_PERIOD 20
class RadioHidlTest;
+extern CardStatus cardStatus;
/* Callback class for radio response */
class RadioResponse : public IRadioResponse {
@@ -79,7 +83,9 @@
public:
RadioResponseInfo rspInfo;
- CardStatus cardStatus;
+ hidl_string imsi;
+ IccIoResult iccIoResult;
+ int channelId;
RadioResponse(RadioHidlTest& parent);
@@ -443,6 +449,7 @@
sp<IRadio> radio;
sp<RadioResponse> radioRsp;
sp<IRadioIndication> radioInd;
+
};
// A class for test environment setup
diff --git a/radio/1.0/vts/functional/radio_response.cpp b/radio/1.0/vts/functional/radio_response.cpp
index b2a74f4..2b4f10f 100644
--- a/radio/1.0/vts/functional/radio_response.cpp
+++ b/radio/1.0/vts/functional/radio_response.cpp
@@ -16,6 +16,8 @@
#include<radio_hidl_hal_utils.h>
+CardStatus cardStatus;
+
RadioResponse::RadioResponse(RadioHidlTest& parent) : parent(parent) {
}
@@ -28,638 +30,667 @@
}
Return<void> RadioResponse::supplyIccPinForAppResponse(
- const RadioResponseInfo& info, int32_t remainingRetries) {
+ const RadioResponseInfo& info, int32_t /*remainingRetries*/) {
rspInfo = info;
parent.notify();
return Void();
}
Return<void> RadioResponse::supplyIccPukForAppResponse(
- const RadioResponseInfo& info, int32_t remainingRetries) {
+ 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) {
+ const RadioResponseInfo& info, int32_t /*remainingRetries*/) {
rspInfo = info;
parent.notify();
return Void();
}
Return<void> RadioResponse::changeIccPinForAppResponse(
- const RadioResponseInfo& info, int32_t remainingRetries) {
+ const RadioResponseInfo& info, int32_t /*remainingRetries*/) {
rspInfo = info;
parent.notify();
return Void();
}
Return<void> RadioResponse::changeIccPin2ForAppResponse(
- const RadioResponseInfo& info, int32_t remaining_retries) {
+ const RadioResponseInfo& info, int32_t /*remainingRetries*/) {
rspInfo = info;
parent.notify();
return Void();
}
Return<void> RadioResponse::supplyNetworkDepersonalizationResponse(
- const RadioResponseInfo& info, int32_t remainingRetries) {
+ const RadioResponseInfo& /*info*/, int32_t /*remainingRetries*/) {
return Void();
}
Return<void> RadioResponse::getCurrentCallsResponse(
- const RadioResponseInfo& info, const ::android::hardware::hidl_vec<Call>& calls) {
+ const RadioResponseInfo& /*info*/, const ::android::hardware::hidl_vec<Call>& /*calls*/) {
return Void();
}
-Return<void> RadioResponse::dialResponse(const RadioResponseInfo& info) {
+Return<void> RadioResponse::dialResponse(const RadioResponseInfo& /*info*/) {
return Void();
}
Return<void> RadioResponse::getIMSIForAppResponse(
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) {
+ const RadioResponseInfo& /*info*/) {
return Void();
}
Return<void> RadioResponse::hangupWaitingOrBackgroundResponse(
- const RadioResponseInfo& info) {
+ const RadioResponseInfo& /*info*/) {
return Void();
}
Return<void> RadioResponse::hangupForegroundResumeBackgroundResponse(
- const RadioResponseInfo& info) {
+ const RadioResponseInfo& /*info*/) {
return Void();
}
Return<void> RadioResponse::switchWaitingOrHoldingAndActiveResponse(
- const RadioResponseInfo& info) {
+ const RadioResponseInfo& /*info*/) {
return Void();
}
Return<void> RadioResponse::conferenceResponse(
- const RadioResponseInfo& info) {
+ const RadioResponseInfo& /*info*/) {
return Void();
}
Return<void> RadioResponse::rejectCallResponse(
- const RadioResponseInfo& info) {
+ const RadioResponseInfo& /*info*/) {
return Void();
}
Return<void> RadioResponse::getLastCallFailCauseResponse(
- const RadioResponseInfo& info, const LastCallFailCauseInfo& failCauseInfo) {
+ const RadioResponseInfo& /*info*/, const LastCallFailCauseInfo& /*failCauseInfo*/) {
return Void();
}
Return<void> RadioResponse::getSignalStrengthResponse(
- const RadioResponseInfo& info, const SignalStrength& sig_strength) {
+ const RadioResponseInfo& /*info*/, const SignalStrength& /*sig_strength*/) {
return Void();
}
Return<void> RadioResponse::getVoiceRegistrationStateResponse(
- const RadioResponseInfo& info, const VoiceRegStateResult& voiceRegResponse) {
+ const RadioResponseInfo& /*info*/, const VoiceRegStateResult& /*voiceRegResponse*/) {
return Void();
}
Return<void> RadioResponse::getDataRegistrationStateResponse(
- const RadioResponseInfo& info, const DataRegStateResult& dataRegResponse) {
+ const RadioResponseInfo& /*info*/, const DataRegStateResult& /*dataRegResponse*/) {
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) {
+ const RadioResponseInfo& /*info*/, const ::android::hardware::hidl_string& /*longName*/,
+ const ::android::hardware::hidl_string& /*shortName*/,
+ const ::android::hardware::hidl_string& /*numeric*/) {
return Void();
}
-Return<void> RadioResponse::setRadioPowerResponse(const RadioResponseInfo& info) {
+Return<void> RadioResponse::setRadioPowerResponse(const RadioResponseInfo& /*info*/) {
return Void();
}
-Return<void> RadioResponse::sendDtmfResponse(const RadioResponseInfo& info) {
+Return<void> RadioResponse::sendDtmfResponse(const RadioResponseInfo& /*info*/) {
return Void();
}
-Return<void> RadioResponse::sendSmsResponse(const RadioResponseInfo& info,
- const SendSmsResult& sms) {
+Return<void> RadioResponse::sendSmsResponse(const RadioResponseInfo& /*info*/,
+ const SendSmsResult& /*sms*/) {
return Void();
}
Return<void> RadioResponse::sendSMSExpectMoreResponse(
- const RadioResponseInfo& info, const SendSmsResult& sms) {
+ const RadioResponseInfo& /*info*/, const SendSmsResult& /*sms*/) {
return Void();
}
Return<void> RadioResponse::setupDataCallResponse(
- const RadioResponseInfo& info, const SetupDataCallResult& dcResponse) {
+ const RadioResponseInfo& /*info*/, const SetupDataCallResult& /*dcResponse*/) {
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) {
+Return<void> RadioResponse::sendUssdResponse(const RadioResponseInfo& /*info*/) {
return Void();
}
-Return<void> RadioResponse::cancelPendingUssdResponse(const RadioResponseInfo& info) {
+Return<void> RadioResponse::cancelPendingUssdResponse(const RadioResponseInfo& /*info*/) {
return Void();
}
-Return<void> RadioResponse::getClirResponse(const RadioResponseInfo& info, int32_t n, int32_t m) {
+Return<void> RadioResponse::getClirResponse(const RadioResponseInfo& /*info*/, int32_t /*n*/,
+ int32_t /*m*/) {
return Void();
}
-Return<void> RadioResponse::setClirResponse(const RadioResponseInfo& info) {
+Return<void> RadioResponse::setClirResponse(const RadioResponseInfo& /*info*/) {
return Void();
}
Return<void> RadioResponse::getCallForwardStatusResponse(
- const RadioResponseInfo& info, const ::android::hardware::hidl_vec<CallForwardInfo>&
- callForwardInfos) {
+ const RadioResponseInfo& /*info*/, const ::android::hardware::hidl_vec<CallForwardInfo>&
+ /*callForwardInfos*/) {
return Void();
}
-Return<void> RadioResponse::setCallForwardResponse(const RadioResponseInfo& info) {
+Return<void> RadioResponse::setCallForwardResponse(const RadioResponseInfo& /*info*/) {
return Void();
}
Return<void> RadioResponse::getCallWaitingResponse(
- const RadioResponseInfo& info, bool enable, int32_t serviceClass) {
+ const RadioResponseInfo& /*info*/, bool /*enable*/, int32_t /*serviceClass*/) {
return Void();
}
-Return<void> RadioResponse::setCallWaitingResponse(const RadioResponseInfo& info) {
+Return<void> RadioResponse::setCallWaitingResponse(const RadioResponseInfo& /*info*/) {
return Void();
}
-Return<void> RadioResponse::acknowledgeLastIncomingGsmSmsResponse(const RadioResponseInfo& info) {
+Return<void> RadioResponse::acknowledgeLastIncomingGsmSmsResponse(const RadioResponseInfo& /*info*/) {
return Void();
}
-Return<void> RadioResponse::acceptCallResponse(const RadioResponseInfo& info) {
+Return<void> RadioResponse::acceptCallResponse(const RadioResponseInfo& /*info*/) {
return Void();
}
-Return<void> RadioResponse::deactivateDataCallResponse(const RadioResponseInfo& info) {
+Return<void> RadioResponse::deactivateDataCallResponse(const RadioResponseInfo& /*info*/) {
return Void();
}
-Return<void> RadioResponse::getFacilityLockForAppResponse(const RadioResponseInfo& info,
- int32_t response) {
+Return<void> RadioResponse::getFacilityLockForAppResponse(const RadioResponseInfo& /*info*/,
+ int32_t /*response*/) {
return Void();
}
-Return<void> RadioResponse::setFacilityLockForAppResponse(const RadioResponseInfo& info,
- int32_t retry) {
+Return<void> RadioResponse::setFacilityLockForAppResponse(const RadioResponseInfo& /*info*/,
+ int32_t /*retry*/) {
return Void();
}
-Return<void> RadioResponse::setBarringPasswordResponse(const RadioResponseInfo& info) {
+Return<void> RadioResponse::setBarringPasswordResponse(const RadioResponseInfo& /*info*/) {
return Void();
}
Return<void> RadioResponse::getNetworkSelectionModeResponse(
- const RadioResponseInfo& info, bool manual) {
+ const RadioResponseInfo& /*info*/, bool /*manual*/) {
return Void();
}
Return<void> RadioResponse::setNetworkSelectionModeAutomaticResponse(
- const RadioResponseInfo& info) {
+ const RadioResponseInfo& /*info*/) {
return Void();
}
-Return<void> RadioResponse::setNetworkSelectionModeManualResponse(const RadioResponseInfo& info) {
+Return<void> RadioResponse::setNetworkSelectionModeManualResponse(
+ const RadioResponseInfo& /*info*/) {
return Void();
}
Return<void> RadioResponse::getAvailableNetworksResponse(
- const RadioResponseInfo& info,
- const ::android::hardware::hidl_vec<OperatorInfo>& networkInfos) {
+ const RadioResponseInfo& /*info*/,
+ const ::android::hardware::hidl_vec<OperatorInfo>& /*networkInfos*/) {
return Void();
}
Return<void> RadioResponse::startDtmfResponse(
- const RadioResponseInfo& info) {
+ const RadioResponseInfo& /*info*/) {
return Void();
}
Return<void> RadioResponse::stopDtmfResponse(
- const RadioResponseInfo& info) {
+ const RadioResponseInfo& /*info*/) {
return Void();
}
Return<void> RadioResponse::getBasebandVersionResponse(
- const RadioResponseInfo& info, const ::android::hardware::hidl_string& version) {
+ const RadioResponseInfo& /*info*/, const ::android::hardware::hidl_string& /*version*/) {
return Void();
}
-Return<void> RadioResponse::separateConnectionResponse(const RadioResponseInfo& info) {
+Return<void> RadioResponse::separateConnectionResponse(const RadioResponseInfo& /*info*/) {
return Void();
}
-Return<void> RadioResponse::setMuteResponse(const RadioResponseInfo& info) {
+Return<void> RadioResponse::setMuteResponse(const RadioResponseInfo& /*info*/) {
return Void();
}
-Return<void> RadioResponse::getMuteResponse(const RadioResponseInfo& info, bool enable) {
+Return<void> RadioResponse::getMuteResponse(const RadioResponseInfo& /*info*/, bool /*enable*/) {
return Void();
}
-Return<void> RadioResponse::getClipResponse(const RadioResponseInfo& info, ClipStatus status) {
+Return<void> RadioResponse::getClipResponse(const RadioResponseInfo& /*info*/,
+ ClipStatus /*status*/) {
return Void();
}
Return<void> RadioResponse::getDataCallListResponse(
- const RadioResponseInfo& info,
- const ::android::hardware::hidl_vec<SetupDataCallResult>& dcResponse) {
+ const RadioResponseInfo& /*info*/,
+ const ::android::hardware::hidl_vec<SetupDataCallResult>& /*dcResponse*/) {
return Void();
}
Return<void> RadioResponse::sendOemRilRequestRawResponse(
- const RadioResponseInfo& info,
- const ::android::hardware::hidl_vec<uint8_t>& data) {
+ 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) {
+ const RadioResponseInfo& /*info*/,
+ const ::android::hardware::hidl_vec<::android::hardware::hidl_string>& /*data*/) {
return Void();
}
Return<void> RadioResponse::sendScreenStateResponse(
- const RadioResponseInfo& info) {
+ const RadioResponseInfo& /*info*/) {
return Void();
}
Return<void> RadioResponse::setSuppServiceNotificationsResponse(
- const RadioResponseInfo& info) {
+ const RadioResponseInfo& /*info*/) {
return Void();
}
Return<void> RadioResponse::writeSmsToSimResponse(
- const RadioResponseInfo& info, int32_t index) {
+ const RadioResponseInfo& /*info*/, int32_t /*index*/) {
return Void();
}
Return<void> RadioResponse::deleteSmsOnSimResponse(
- const RadioResponseInfo& info) {
+ const RadioResponseInfo& /*info*/) {
return Void();
}
-Return<void> RadioResponse::setBandModeResponse(const RadioResponseInfo& info) {
+Return<void> RadioResponse::setBandModeResponse(const RadioResponseInfo& /*info*/) {
return Void();
}
Return<void> RadioResponse::getAvailableBandModesResponse(
- const RadioResponseInfo& info,
- const ::android::hardware::hidl_vec<RadioBandMode>& bandModes) {
+ const RadioResponseInfo& /*info*/,
+ const ::android::hardware::hidl_vec<RadioBandMode>& /*bandModes*/) {
return Void();
}
-Return<void> RadioResponse::sendEnvelopeResponse(const RadioResponseInfo& info,
- const ::android::hardware::hidl_string& commandResponse) {
+Return<void> RadioResponse::sendEnvelopeResponse(const RadioResponseInfo& /*info*/,
+ const ::android::hardware::hidl_string& /*commandResponse*/) {
return Void();
}
-Return<void> RadioResponse::sendTerminalResponseToSimResponse(const RadioResponseInfo& info) {
+Return<void> RadioResponse::sendTerminalResponseToSimResponse(const RadioResponseInfo& /*info*/) {
return Void();
}
Return<void> RadioResponse::handleStkCallSetupRequestFromSimResponse(
- const RadioResponseInfo& info) {
+ const RadioResponseInfo& /*info*/) {
return Void();
}
-Return<void> RadioResponse::explicitCallTransferResponse(const RadioResponseInfo& info) {
+Return<void> RadioResponse::explicitCallTransferResponse(const RadioResponseInfo& /*info*/) {
return Void();
}
-Return<void> RadioResponse::setPreferredNetworkTypeResponse(const RadioResponseInfo& info) {
+Return<void> RadioResponse::setPreferredNetworkTypeResponse(const RadioResponseInfo& /*info*/) {
return Void();
}
Return<void> RadioResponse::getPreferredNetworkTypeResponse(
- const RadioResponseInfo& info, PreferredNetworkType nw_type) {
+ const RadioResponseInfo& /*info*/, PreferredNetworkType /*nw_type*/) {
return Void();
}
Return<void> RadioResponse::getNeighboringCidsResponse(
- const RadioResponseInfo& info,
- const ::android::hardware::hidl_vec<NeighboringCell>& cells) {
+ const RadioResponseInfo& /*info*/,
+ const ::android::hardware::hidl_vec<NeighboringCell>& /*cells*/) {
return Void();
}
Return<void> RadioResponse::setLocationUpdatesResponse(
- const RadioResponseInfo& info) {
+ const RadioResponseInfo& /*info*/) {
return Void();
}
-Return<void> RadioResponse::setCdmaSubscriptionSourceResponse(const RadioResponseInfo& info) {
+Return<void> RadioResponse::setCdmaSubscriptionSourceResponse(const RadioResponseInfo& /*info*/) {
return Void();
}
-Return<void> RadioResponse::setCdmaRoamingPreferenceResponse(const RadioResponseInfo& info) {
+Return<void> RadioResponse::setCdmaRoamingPreferenceResponse(const RadioResponseInfo& /*info*/) {
return Void();
}
Return<void> RadioResponse::getCdmaRoamingPreferenceResponse(
- const RadioResponseInfo& info, CdmaRoamingType type) {
+ const RadioResponseInfo& /*info*/, CdmaRoamingType /*type*/) {
return Void();
}
-Return<void> RadioResponse::setTTYModeResponse(const RadioResponseInfo& info) {
+Return<void> RadioResponse::setTTYModeResponse(const RadioResponseInfo& /*info*/) {
return Void();
}
-Return<void> RadioResponse::getTTYModeResponse(const RadioResponseInfo& info, TtyMode mode) {
+Return<void> RadioResponse::getTTYModeResponse(const RadioResponseInfo& /*info*/,
+ TtyMode /*mode*/) {
return Void();
}
-Return<void> RadioResponse::setPreferredVoicePrivacyResponse(const RadioResponseInfo& info) {
+Return<void> RadioResponse::setPreferredVoicePrivacyResponse(const RadioResponseInfo& /*info*/) {
return Void();
}
Return<void> RadioResponse::getPreferredVoicePrivacyResponse(
- const RadioResponseInfo& info, bool enable) {
+ const RadioResponseInfo& /*info*/, bool /*enable*/) {
return Void();
}
-Return<void> RadioResponse::sendCDMAFeatureCodeResponse(const RadioResponseInfo& info) {
+Return<void> RadioResponse::sendCDMAFeatureCodeResponse(const RadioResponseInfo& /*info*/) {
return Void();
}
-Return<void> RadioResponse::sendBurstDtmfResponse(const RadioResponseInfo& info) {
+Return<void> RadioResponse::sendBurstDtmfResponse(const RadioResponseInfo& /*info*/) {
return Void();
}
Return<void> RadioResponse::sendCdmaSmsResponse(
- const RadioResponseInfo& info, const SendSmsResult& sms) {
+ const RadioResponseInfo& /*info*/, const SendSmsResult& /*sms*/) {
return Void();
}
Return<void> RadioResponse::acknowledgeLastIncomingCdmaSmsResponse(
- const RadioResponseInfo& info) {
+ const RadioResponseInfo& /*info*/) {
return Void();
}
Return<void> RadioResponse::getGsmBroadcastConfigResponse(
- const RadioResponseInfo& info,
- const ::android::hardware::hidl_vec<GsmBroadcastSmsConfigInfo>& configs) {
+ const RadioResponseInfo& /*info*/,
+ const ::android::hardware::hidl_vec<GsmBroadcastSmsConfigInfo>& /*configs*/) {
return Void();
}
-Return<void> RadioResponse::setGsmBroadcastConfigResponse(const RadioResponseInfo& info) {
+Return<void> RadioResponse::setGsmBroadcastConfigResponse(const RadioResponseInfo& /*info*/) {
return Void();
}
-Return<void> RadioResponse::setGsmBroadcastActivationResponse(const RadioResponseInfo& info) {
+Return<void> RadioResponse::setGsmBroadcastActivationResponse(const RadioResponseInfo& /*info*/) {
return Void();
}
Return<void> RadioResponse::getCdmaBroadcastConfigResponse(
- const RadioResponseInfo& info,
- const ::android::hardware::hidl_vec<CdmaBroadcastSmsConfigInfo>& configs) {
+ const RadioResponseInfo& /*info*/,
+ const ::android::hardware::hidl_vec<CdmaBroadcastSmsConfigInfo>& /*configs*/) {
return Void();
}
-Return<void> RadioResponse::setCdmaBroadcastConfigResponse(const RadioResponseInfo& info) {
+Return<void> RadioResponse::setCdmaBroadcastConfigResponse(const RadioResponseInfo& /*info*/) {
return Void();
}
-Return<void> RadioResponse::setCdmaBroadcastActivationResponse(const RadioResponseInfo& info) {
+Return<void> RadioResponse::setCdmaBroadcastActivationResponse(const RadioResponseInfo& /*info*/) {
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) {
+ 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();
}
Return<void> RadioResponse::writeSmsToRuimResponse(
- const RadioResponseInfo& info, uint32_t index) {
+ const RadioResponseInfo& /*info*/, uint32_t /*index*/) {
return Void();
}
Return<void> RadioResponse::deleteSmsOnRuimResponse(
- const RadioResponseInfo& info) {
+ const RadioResponseInfo& /*info*/) {
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) {
+ 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();
}
-Return<void> RadioResponse::exitEmergencyCallbackModeResponse(const RadioResponseInfo& info) {
+Return<void> RadioResponse::exitEmergencyCallbackModeResponse(const RadioResponseInfo& /*info*/) {
return Void();
}
Return<void> RadioResponse::getSmscAddressResponse(
- const RadioResponseInfo& info, const ::android::hardware::hidl_string& smsc) {
+ const RadioResponseInfo& /*info*/, const ::android::hardware::hidl_string& /*smsc*/) {
return Void();
}
-Return<void> RadioResponse::setSmscAddressResponse(const RadioResponseInfo& info) {
+Return<void> RadioResponse::setSmscAddressResponse(const RadioResponseInfo& /*info*/) {
return Void();
}
-Return<void> RadioResponse::reportSmsMemoryStatusResponse(const RadioResponseInfo& info) {
+Return<void> RadioResponse::reportSmsMemoryStatusResponse(const RadioResponseInfo& /*info*/) {
return Void();
}
-Return<void> RadioResponse::reportStkServiceIsRunningResponse(const RadioResponseInfo& info) {
+Return<void> RadioResponse::reportStkServiceIsRunningResponse(const RadioResponseInfo& /*info*/) {
return Void();
}
Return<void> RadioResponse::getCdmaSubscriptionSourceResponse(
- const RadioResponseInfo& info, CdmaSubscriptionSource source) {
+ const RadioResponseInfo& /*info*/, CdmaSubscriptionSource /*source*/) {
return Void();
}
Return<void> RadioResponse::requestIsimAuthenticationResponse(
- const RadioResponseInfo& info, const ::android::hardware::hidl_string& response) {
+ const RadioResponseInfo& /*info*/, const ::android::hardware::hidl_string& /*response*/) {
return Void();
}
Return<void> RadioResponse::acknowledgeIncomingGsmSmsWithPduResponse(
- const RadioResponseInfo& info) {
+ const RadioResponseInfo& /*info*/) {
return Void();
}
Return<void> RadioResponse::sendEnvelopeWithStatusResponse(
- const RadioResponseInfo& info, const IccIoResult& iccIo) {
+ const RadioResponseInfo& /*info*/, const IccIoResult& /*iccIo*/) {
return Void();
}
Return<void> RadioResponse::getVoiceRadioTechnologyResponse(
- const RadioResponseInfo& info, RadioTechnology rat) {
+ const RadioResponseInfo& /*info*/, RadioTechnology /*rat*/) {
return Void();
}
Return<void> RadioResponse::getCellInfoListResponse(
- const RadioResponseInfo& info, const ::android::hardware::hidl_vec<CellInfo>& cellInfo) {
+ const RadioResponseInfo& /*info*/,
+ const ::android::hardware::hidl_vec<CellInfo>& /*cellInfo*/) {
return Void();
}
-Return<void> RadioResponse::setCellInfoListRateResponse(const RadioResponseInfo& info) {
+Return<void> RadioResponse::setCellInfoListRateResponse(const RadioResponseInfo& /*info*/) {
return Void();
}
-Return<void> RadioResponse::setInitialAttachApnResponse(const RadioResponseInfo& info) {
+Return<void> RadioResponse::setInitialAttachApnResponse(const RadioResponseInfo& /*info*/) {
return Void();
}
Return<void> RadioResponse::getImsRegistrationStateResponse(
- const RadioResponseInfo& info, bool isRegistered, RadioTechnologyFamily ratFamily) {
+ const RadioResponseInfo& /*info*/, bool /*isRegistered*/,
+ RadioTechnologyFamily /*ratFamily*/) {
return Void();
}
Return<void> RadioResponse::sendImsSmsResponse(
- const RadioResponseInfo& info, const SendSmsResult& sms) {
+ const RadioResponseInfo& /*info*/, const SendSmsResult& /*sms*/) {
return Void();
}
Return<void> RadioResponse::iccTransmitApduBasicChannelResponse(
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) {
+ 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::iccTransmitApduLogicalChannelResponse(
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) {
+ const RadioResponseInfo& /*info*/, const ::android::hardware::hidl_string& /*result*/) {
return Void();
}
-Return<void> RadioResponse::nvWriteItemResponse(const RadioResponseInfo& info) {
+Return<void> RadioResponse::nvWriteItemResponse(const RadioResponseInfo& /*info*/) {
return Void();
}
-Return<void> RadioResponse::nvWriteCdmaPrlResponse(const RadioResponseInfo& info) {
+Return<void> RadioResponse::nvWriteCdmaPrlResponse(const RadioResponseInfo& /*info*/) {
return Void();
}
-Return<void> RadioResponse::nvResetConfigResponse(const RadioResponseInfo& info) {
+Return<void> RadioResponse::nvResetConfigResponse(const RadioResponseInfo& /*info*/) {
return Void();
}
-Return<void> RadioResponse::setUiccSubscriptionResponse(const RadioResponseInfo& info) {
+Return<void> RadioResponse::setUiccSubscriptionResponse(const RadioResponseInfo& /*info*/) {
return Void();
}
-Return<void> RadioResponse::setDataAllowedResponse(const RadioResponseInfo& info) {
+Return<void> RadioResponse::setDataAllowedResponse(const RadioResponseInfo& /*info*/) {
return Void();
}
Return<void> RadioResponse::getHardwareConfigResponse(
- const RadioResponseInfo& info,
- const ::android::hardware::hidl_vec<HardwareConfig>& config) {
+ const RadioResponseInfo& /*info*/,
+ const ::android::hardware::hidl_vec<HardwareConfig>& /*config*/) {
return Void();
}
Return<void> RadioResponse::requestIccSimAuthenticationResponse(
const RadioResponseInfo& info, const IccIoResult& result) {
+ rspInfo = info;
+ this->iccIoResult = result;
+ parent.notify();
return Void();
}
-Return<void> RadioResponse::setDataProfileResponse(const RadioResponseInfo& info) {
+Return<void> RadioResponse::setDataProfileResponse(const RadioResponseInfo& /*info*/) {
return Void();
}
-Return<void> RadioResponse::requestShutdownResponse(const RadioResponseInfo& info) {
+Return<void> RadioResponse::requestShutdownResponse(const RadioResponseInfo& /*info*/) {
return Void();
}
Return<void> RadioResponse::getRadioCapabilityResponse(
- const RadioResponseInfo& info, const RadioCapability& rc) {
+ const RadioResponseInfo& /*info*/, const RadioCapability& /*rc*/) {
return Void();
}
Return<void> RadioResponse::setRadioCapabilityResponse(
- const RadioResponseInfo& info, const RadioCapability& rc) {
+ const RadioResponseInfo& /*info*/, const RadioCapability& /*rc*/) {
return Void();
}
Return<void> RadioResponse::startLceServiceResponse(
- const RadioResponseInfo& info, const LceStatusInfo& statusInfo) {
+ const RadioResponseInfo& /*info*/, const LceStatusInfo& /*statusInfo*/) {
return Void();
}
Return<void> RadioResponse::stopLceServiceResponse(
- const RadioResponseInfo& info, const LceStatusInfo& statusInfo) {
+ const RadioResponseInfo& /*info*/, const LceStatusInfo& /*statusInfo*/) {
return Void();
}
Return<void> RadioResponse::pullLceDataResponse(
- const RadioResponseInfo& info, const LceDataInfo& lceInfo) {
+ const RadioResponseInfo& /*info*/, const LceDataInfo& /*lceInfo*/) {
return Void();
}
Return<void> RadioResponse::getModemActivityInfoResponse(
- const RadioResponseInfo& info, const ActivityStatsInfo& activityInfo) {
+ const RadioResponseInfo& /*info*/, const ActivityStatsInfo& /*activityInfo*/) {
return Void();
}
Return<void> RadioResponse::setAllowedCarriersResponse(
- const RadioResponseInfo& info, int32_t numAllowed) {
+ const RadioResponseInfo& /*info*/, int32_t /*numAllowed*/) {
return Void();
}
Return<void> RadioResponse::getAllowedCarriersResponse(
- const RadioResponseInfo& info, bool allAllowed, const CarrierRestrictions& carriers) {
+ const RadioResponseInfo& /*info*/, bool /*allAllowed*/,
+ const CarrierRestrictions& /*carriers*/) {
return Void();
}
Return<void> RadioResponse::sendDeviceStateResponse(
- const RadioResponseInfo& info) {
+ const RadioResponseInfo& /*info*/) {
return Void();
}
Return<void> RadioResponse::setIndicationFilterResponse(
- const RadioResponseInfo& info) {
+ const RadioResponseInfo& /*info*/) {
return Void();
}
Return<void> RadioResponse::setSimCardPowerResponse(
- const RadioResponseInfo& info) {
+ const RadioResponseInfo& /*info*/) {
return Void();
}
-Return<void> RadioResponse::acknowledgeRequest(int32_t serial) {
+Return<void> RadioResponse::acknowledgeRequest(int32_t /*serial*/) {
return Void();
}
diff --git a/sensors/1.0/default/Sensors.cpp b/sensors/1.0/default/Sensors.cpp
index 41eb945..37e2b81 100644
--- a/sensors/1.0/default/Sensors.cpp
+++ b/sensors/1.0/default/Sensors.cpp
@@ -145,22 +145,41 @@
}
Return<void> Sensors::poll(int32_t maxCount, poll_cb _hidl_cb) {
+
hidl_vec<Event> out;
hidl_vec<SensorInfo> dynamicSensorsAdded;
- if (maxCount <= 0) {
- _hidl_cb(Result::BAD_VALUE, out, dynamicSensorsAdded);
- return Void();
+ std::unique_ptr<sensors_event_t[]> data;
+ int err = android::NO_ERROR;
+
+ { // scope of reentry lock
+
+ // This enforces a single client, meaning that a maximum of one client can call poll().
+ // If this function is re-entred, it means that we are stuck in a state that may prevent
+ // the system from proceeding normally.
+ //
+ // Exit and let the system restart the sensor-hal-implementation hidl service.
+ //
+ // This function must not call _hidl_cb(...) or return until there is no risk of blocking.
+ std::unique_lock<std::mutex> lock(mPollLock, std::try_to_lock);
+ if(!lock.owns_lock()){
+ // cannot get the lock, hidl service will go into deadlock if it is not restarted.
+ // This is guaranteed to not trigger in passthrough mode.
+ LOG(FATAL) <<
+ "ISensors::poll() re-entry. I do not know what to do except killing myself.";
+ }
+
+ if (maxCount <= 0) {
+ err = android::BAD_VALUE;
+ } else {
+ int bufferSize = maxCount <= kPollMaxBufferSize ? maxCount : kPollMaxBufferSize;
+ data.reset(new sensors_event_t[bufferSize]);
+ err = mSensorDevice->poll(
+ reinterpret_cast<sensors_poll_device_t *>(mSensorDevice),
+ data.get(), bufferSize);
+ }
}
- int bufferSize = maxCount <= kPollMaxBufferSize ? maxCount : kPollMaxBufferSize;
-
- std::unique_ptr<sensors_event_t[]> data(new sensors_event_t[bufferSize]);
-
- int err = mSensorDevice->poll(
- reinterpret_cast<sensors_poll_device_t *>(mSensorDevice),
- data.get(), bufferSize);
-
if (err < 0) {
_hidl_cb(ResultFromStatus(err), out, dynamicSensorsAdded);
return Void();
diff --git a/sensors/1.0/default/Sensors.h b/sensors/1.0/default/Sensors.h
index 09729d3..7d715e0 100644
--- a/sensors/1.0/default/Sensors.h
+++ b/sensors/1.0/default/Sensors.h
@@ -20,6 +20,7 @@
#include <android/hardware/sensors/1.0/ISensors.h>
#include <hardware/sensors.h>
+#include <mutex>
namespace android {
namespace hardware {
@@ -65,6 +66,7 @@
status_t mInitCheck;
sensors_module_t *mSensorModule;
sensors_poll_device_1_t *mSensorDevice;
+ std::mutex mPollLock;
int getHalDeviceVersion() const;
diff --git a/sensors/1.0/default/convert.cpp b/sensors/1.0/default/convert.cpp
index 748a963..306d3a3 100644
--- a/sensors/1.0/default/convert.cpp
+++ b/sensors/1.0/default/convert.cpp
@@ -25,8 +25,8 @@
namespace implementation {
void convertFromSensor(const sensor_t &src, SensorInfo *dst) {
- dst->name = src.name == nullptr ? "" : src.name;
- dst->vendor = src.vendor == nullptr ? "" : src.vendor;
+ dst->name = src.name;
+ dst->vendor = src.vendor;
dst->version = src.version;
dst->sensorHandle = src.handle;
dst->type = (SensorType)src.type;
@@ -36,8 +36,8 @@
dst->minDelay = src.minDelay;
dst->fifoReservedEventCount = src.fifoReservedEventCount;
dst->fifoMaxEventCount = src.fifoMaxEventCount;
- dst->typeAsString = src.stringType == nullptr ? "" : src.stringType;
- dst->requiredPermission = src.requiredPermission == nullptr ? "" : src.requiredPermission;
+ dst->typeAsString = src.stringType;
+ dst->requiredPermission = src.requiredPermission;
dst->maxDelay = src.maxDelay;
dst->flags = src.flags;
}
diff --git a/sensors/1.0/vts/functional/Android.bp b/sensors/1.0/vts/functional/Android.bp
index c2889c5..4be4f64 100644
--- a/sensors/1.0/vts/functional/Android.bp
+++ b/sensors/1.0/vts/functional/Android.bp
@@ -16,7 +16,6 @@
cc_test {
name: "VtsHalSensorsV1_0TargetTest",
- gtest: true,
srcs: ["VtsHalSensorsV1_0TargetTest.cpp"],
shared_libs: [
"android.hardware.sensors@1.0",
@@ -25,7 +24,7 @@
"liblog",
"libutils",
],
- static_libs: ["libgtest"],
+ static_libs: ["VtsHalHidlTargetBaseTest"],
cflags: [
"-O0",
"-g",
diff --git a/sensors/1.0/vts/functional/VtsHalSensorsV1_0TargetTest.cpp b/sensors/1.0/vts/functional/VtsHalSensorsV1_0TargetTest.cpp
index 9a71745..b1483e3 100644
--- a/sensors/1.0/vts/functional/VtsHalSensorsV1_0TargetTest.cpp
+++ b/sensors/1.0/vts/functional/VtsHalSensorsV1_0TargetTest.cpp
@@ -20,7 +20,7 @@
#include <android/hardware/sensors/1.0/types.h>
#include <android/log.h>
#include <cutils/ashmem.h>
-#include <gtest/gtest.h>
+#include <VtsHalHidlTargetBaseTest.h>
#include <hardware/sensors.h> // for sensor type strings
#include <algorithm>
@@ -80,7 +80,7 @@
};
void SensorsHidlEnvironment::SetUp() {
- sensors = ISensors::getService();
+ sensors = ::testing::VtsHalHidlTargetBaseTest::getService<ISensors>();
ALOGI_IF(sensors, "sensors is not nullptr, %p", sensors.get());
ASSERT_NE(sensors, nullptr);
@@ -309,7 +309,7 @@
}
// The main test class for SENSORS HIDL HAL.
-class SensorsHidlTest : public ::testing::Test {
+class SensorsHidlTest : public ::testing::VtsHalHidlTargetBaseTest {
public:
virtual void SetUp() override {
}
diff --git a/soundtrigger/2.0/vts/functional/Android.bp b/soundtrigger/2.0/vts/functional/Android.bp
index 700b213..269e4b6 100644
--- a/soundtrigger/2.0/vts/functional/Android.bp
+++ b/soundtrigger/2.0/vts/functional/Android.bp
@@ -16,7 +16,6 @@
cc_test {
name: "VtsHalSoundtriggerV2_0TargetTest",
- gtest: true,
srcs: ["VtsHalSoundtriggerV2_0TargetTest.cpp"],
shared_libs: [
"libbase",
@@ -28,7 +27,7 @@
"libutils",
"android.hardware.soundtrigger@2.0",
],
- static_libs: ["libgtest"],
+ static_libs: ["VtsHalHidlTargetBaseTest"],
cflags: [
"-O0",
"-g",
diff --git a/soundtrigger/2.0/vts/functional/VtsHalSoundtriggerV2_0TargetTest.cpp b/soundtrigger/2.0/vts/functional/VtsHalSoundtriggerV2_0TargetTest.cpp
index cb00ad5..41e7e69 100644
--- a/soundtrigger/2.0/vts/functional/VtsHalSoundtriggerV2_0TargetTest.cpp
+++ b/soundtrigger/2.0/vts/functional/VtsHalSoundtriggerV2_0TargetTest.cpp
@@ -22,7 +22,7 @@
#include <android/hardware/soundtrigger/2.0/ISoundTriggerHw.h>
#include <android/hardware/soundtrigger/2.0/types.h>
-#include <gtest/gtest.h>
+#include <VtsHalHidlTargetBaseTest.h>
using ::android::hardware::audio::common::V2_0::AudioDevice;
using ::android::hardware::soundtrigger::V2_0::SoundModelHandle;
@@ -37,10 +37,10 @@
using ::android::sp;
// The main test class for Sound Trigger HIDL HAL.
-class SoundTriggerHidlTest : public ::testing::Test {
+class SoundTriggerHidlTest : public ::testing::VtsHalHidlTargetBaseTest {
public:
virtual void SetUp() override {
- mSoundTriggerHal = ISoundTriggerHw::getService("sound_trigger.primary");
+ mSoundTriggerHal = ::testing::VtsHalHidlTargetBaseTest::getService<ISoundTriggerHw>("sound_trigger.primary");
ASSERT_NE(nullptr, mSoundTriggerHal.get());
mCallback = new MyCallback();
ASSERT_NE(nullptr, mCallback.get());
diff --git a/tests/Android.bp b/tests/Android.bp
index 040a6fb..997ba79 100644
--- a/tests/Android.bp
+++ b/tests/Android.bp
@@ -3,6 +3,7 @@
"bar/1.0",
"bar/1.0/default",
"baz/1.0",
+ "baz/1.0/default",
"expression/1.0",
"extension/light/2.0",
"foo/1.0",
diff --git a/tests/baz/1.0/default/Android.bp b/tests/baz/1.0/default/Android.bp
new file mode 100644
index 0000000..e160d8a
--- /dev/null
+++ b/tests/baz/1.0/default/Android.bp
@@ -0,0 +1,16 @@
+cc_library_shared {
+ name: "android.hardware.tests.baz@1.0-impl",
+ relative_install_path: "hw",
+ proprietary: true,
+ srcs: [
+ "Baz.cpp",
+ ],
+ shared_libs: [
+ "libbase",
+ "libhidlbase",
+ "libhidltransport",
+ "libutils",
+ "android.hardware.tests.baz@1.0",
+ "android.hidl.base@1.0",
+ ],
+}
diff --git a/tests/baz/1.0/default/Baz.cpp b/tests/baz/1.0/default/Baz.cpp
new file mode 100644
index 0000000..8e57fa0
--- /dev/null
+++ b/tests/baz/1.0/default/Baz.cpp
@@ -0,0 +1,519 @@
+#include "Baz.h"
+#include <android-base/logging.h>
+
+namespace android {
+namespace hardware {
+namespace tests {
+namespace baz {
+namespace V1_0 {
+namespace implementation {
+
+struct BazCallback : public IBazCallback {
+ Return<void> heyItsMe(const sp<IBazCallback> &cb) override;
+ Return<void> hey() override;
+};
+
+Return<void> BazCallback::heyItsMe(
+ const sp<IBazCallback> &cb) {
+ LOG(INFO) << "SERVER: heyItsMe cb = " << cb.get();
+
+ return Void();
+}
+
+Return<void> BazCallback::hey() {
+ LOG(INFO) << "SERVER: hey";
+
+ return Void();
+}
+
+// TODO(b/35703683) : replace usage of below methods with toString()
+
+static std::string to_string(const IBaz::Foo::Bar &bar);
+static std::string to_string(const IBaz::Foo &foo);
+static std::string to_string(const hidl_string &s);
+static std::string to_string(bool x);
+static std::string to_string(const IBaz::StringMatrix5x3 &M);
+static std::string to_string(const IBaz::StringMatrix3x5 &M);
+
+template<typename T, size_t SIZE>
+static std::string to_string(const hidl_array<T, SIZE> &array);
+
+template<size_t SIZE>
+static std::string to_string(const hidl_array<uint8_t, SIZE> &array);
+
+template<typename T>
+static std::string to_string(const hidl_vec<T> &vec) {
+ std::string out;
+ out = "[";
+ for (size_t i = 0; i < vec.size(); ++i) {
+ if (i > 0) {
+ out += ", ";
+ }
+ out += to_string(vec[i]);
+ }
+ out += "]";
+
+ return out;
+}
+
+template<typename T, size_t SIZE>
+static std::string to_string(const hidl_array<T, SIZE> &array) {
+ std::string out;
+ out = "[";
+ for (size_t i = 0; i < SIZE; ++i) {
+ if (i > 0) {
+ out += ", ";
+ }
+ out += to_string(array[i]);
+ }
+ out += "]";
+
+ return out;
+}
+
+template<size_t SIZE>
+static std::string to_string(const hidl_array<uint8_t, SIZE> &array) {
+ std::string out;
+ for (size_t i = 0; i < SIZE; ++i) {
+ if (i > 0) {
+ out += ":";
+ }
+
+ char tmp[3];
+ sprintf(tmp, "%02x", array[i]);
+
+ out += tmp;
+ }
+
+ return out;
+}
+
+template<typename T, size_t SIZE1, size_t SIZE2>
+static std::string to_string(const hidl_array<T, SIZE1, SIZE2> &array) {
+ std::string out;
+ out = "[";
+ for (size_t i = 0; i < SIZE1; ++i) {
+ if (i > 0) {
+ out += ", ";
+ }
+
+ out += "[";
+ for (size_t j = 0; j < SIZE2; ++j) {
+ if (j > 0) {
+ out += ", ";
+ }
+
+ out += to_string(array[i][j]);
+ }
+ out += "]";
+ }
+ out += "]";
+
+ return out;
+}
+
+static std::string to_string(bool x) {
+ return x ? "true" : "false";
+}
+
+static std::string to_string(const hidl_string &s) {
+ return std::string("'") + s.c_str() + "'";
+}
+
+static std::string to_string(const IBaz::Foo::Bar &bar) {
+ std::string out;
+ out = "Bar(";
+ out += "z = " + to_string(bar.z) + ", ";
+ out += "s = '" + std::string(bar.s.c_str()) + "'";
+ out += ")";
+
+ return out;
+}
+
+static std::string to_string(const IBaz::Foo &foo) {
+ std::string out;
+ out = "Foo(";
+ out += "x = " + to_string(foo.x) + ", ";
+ out += "y = " + to_string(foo.y) + ", ";
+ out += "aaa = " + to_string(foo.aaa);
+ out += ")";
+
+ return out;
+}
+
+static std::string to_string(const IBaz::StringMatrix5x3 &M) {
+ return to_string(M.s);
+}
+
+static std::string to_string(const IBaz::StringMatrix3x5 &M) {
+ return to_string(M.s);
+}
+
+static std::string VectorOfArray_to_string(const IBaz::VectorOfArray &in) {
+ std::string out;
+ out += "VectorOfArray(";
+
+ for (size_t i = 0; i < in.addresses.size(); ++i) {
+ if (i > 0) {
+ out += ", ";
+ }
+
+ for (size_t j = 0; j < 6; ++j) {
+ if (j > 0) {
+ out += ":";
+ }
+
+ char tmp[3];
+ sprintf(tmp, "%02x", in.addresses[i][j]);
+
+ out += tmp;
+ }
+ }
+
+ out += ")";
+
+ return out;
+}
+
+// Methods from ::android::hardware::tests::baz::V1_0::IBase follow.
+Return<void> Baz::someBaseMethod() {
+ LOG(INFO) << "Baz::someBaseMethod";
+
+ return Void();
+}
+
+Return<bool> Baz::someBoolMethod(bool x) {
+ LOG(INFO) << "Baz::someBoolMethod(" << to_string(x) << ")";
+
+ return !x;
+}
+
+Return<void> Baz::someBoolArrayMethod(const hidl_array<bool, 3>& x,
+ someBoolArrayMethod_cb _hidl_cb) {
+ LOG(INFO) << "Baz::someBoolArrayMethod("
+ << to_string(x[0])
+ << ", "
+ << to_string(x[1])
+ << ", "
+ << to_string(x[2])
+ << ")";
+
+ hidl_array<bool, 4> out;
+ out[0] = !x[0];
+ out[1] = !x[1];
+ out[2] = !x[2];
+ out[3] = true;
+
+ _hidl_cb(out);
+
+ return Void();
+}
+
+Return<void> Baz::someBoolVectorMethod(const hidl_vec<bool>& x, someBoolVectorMethod_cb _hidl_cb) {
+ LOG(INFO) << "Baz::someBoolVectorMethod(" << to_string(x) << ")";
+
+ hidl_vec<bool> out;
+ out.resize(x.size());
+ for (size_t i = 0; i < x.size(); ++i) {
+ out[i] = !x[i];
+ }
+
+ _hidl_cb(out);
+
+ return Void();
+}
+
+Return<void> Baz::someOtherBaseMethod(const IBase::Foo& foo, someOtherBaseMethod_cb _hidl_cb) {
+ LOG(INFO) << "Baz::someOtherBaseMethod "
+ << to_string(foo);
+
+ _hidl_cb(foo);
+
+ return Void();
+}
+
+Return<void> Baz::someMethodWithFooArrays(const hidl_array<IBase::Foo, 2>& fooInput,
+ someMethodWithFooArrays_cb _hidl_cb) {
+ LOG(INFO) << "Baz::someMethodWithFooArrays "
+ << to_string(fooInput);
+
+ hidl_array<IBaz::Foo, 2> fooOutput;
+ fooOutput[0] = fooInput[1];
+ fooOutput[1] = fooInput[0];
+
+ _hidl_cb(fooOutput);
+
+ return Void();
+}
+
+Return<void> Baz::someMethodWithFooVectors(const hidl_vec<IBase::Foo>& fooInput,
+ someMethodWithFooVectors_cb _hidl_cb) {
+ LOG(INFO) << "Baz::someMethodWithFooVectors "
+ << to_string(fooInput);
+
+ hidl_vec<IBaz::Foo> fooOutput;
+ fooOutput.resize(2);
+ fooOutput[0] = fooInput[1];
+ fooOutput[1] = fooInput[0];
+
+ _hidl_cb(fooOutput);
+
+ return Void();
+}
+
+Return<void> Baz::someMethodWithVectorOfArray(const IBase::VectorOfArray& in,
+ someMethodWithVectorOfArray_cb _hidl_cb) {
+ LOG(INFO) << "Baz::someMethodWithVectorOfArray "
+ << VectorOfArray_to_string(in);
+
+ IBase::VectorOfArray out;
+
+ const size_t n = in.addresses.size();
+ out.addresses.resize(n);
+
+ for (size_t i = 0; i < n; ++i) {
+ out.addresses[i] = in.addresses[n - 1 - i];
+ }
+
+ _hidl_cb(out);
+
+ return Void();
+}
+
+Return<void> Baz::someMethodTakingAVectorOfArray(const hidl_vec<hidl_array<uint8_t, 6>>& in,
+ someMethodTakingAVectorOfArray_cb _hidl_cb) {
+ LOG(INFO) << "Baz::someMethodTakingAVectorOfArray "
+ << to_string(in);
+
+ const size_t n = in.size();
+
+ hidl_vec<hidl_array<uint8_t, 6> > out;
+ out.resize(n);
+
+ for (size_t i = 0; i < n; ++i) {
+ out[i] = in[n - 1 - i];
+ }
+
+ _hidl_cb(out);
+
+ return Void();
+}
+
+Return<void> Baz::transpose(const IBase::StringMatrix5x3& in, transpose_cb _hidl_cb) {
+ LOG(INFO) << "Baz::transpose " << to_string(in);
+
+ IBase::StringMatrix3x5 out;
+ for (size_t i = 0; i < 3; ++i) {
+ for (size_t j = 0; j < 5; ++j) {
+ out.s[i][j] = in.s[j][i];
+ }
+ }
+
+ _hidl_cb(out);
+
+ return Void();
+}
+
+Return<void> Baz::transpose2(const hidl_array<hidl_string, 5, 3>& in, transpose2_cb _hidl_cb) {
+ LOG(INFO) << "Baz::transpose2 " << to_string(in);
+
+ hidl_array<hidl_string, 3, 5> out;
+ for (size_t i = 0; i < 3; ++i) {
+ for (size_t j = 0; j < 5; ++j) {
+ out[i][j] = in[j][i];
+ }
+ }
+
+ _hidl_cb(out);
+
+ return Void();
+}
+
+Return<void> Baz::takeAMask(IBase::BitField bf,
+ uint8_t first,
+ const IBase::MyMask& second,
+ uint8_t third,
+ takeAMask_cb _hidl_cb) {
+ _hidl_cb(bf, bf | first, second.value & bf, (bf | bf) & third);
+ return Void();
+}
+
+// Methods from ::android::hardware::tests::baz::V1_0::IBaz follow.
+
+Return<void> Baz::doThis(float param) {
+ LOG(INFO) << "Baz::doThis(" << param << ")";
+
+ return Void();
+}
+
+Return<int32_t> Baz::doThatAndReturnSomething(int64_t param) {
+ LOG(INFO) << "Baz::doThatAndReturnSomething(" << param << ")";
+
+ return 666;
+}
+
+Return<double> Baz::doQuiteABit(int32_t a, int64_t b, float c, double d) {
+ LOG(INFO) << "Baz::doQuiteABit("
+ << a
+ << ", "
+ << b
+ << ", "
+ << c
+ << ", "
+ << d
+ << ")";
+
+ return 666.5;
+}
+
+Return<void> Baz::doSomethingElse(const hidl_array<int32_t, 15>& param,
+ doSomethingElse_cb _hidl_cb) {
+ LOG(INFO) << "Baz::doSomethingElse(...)";
+
+ hidl_array<int32_t, 32> result;
+ for (size_t i = 0; i < 15; ++i) {
+ result[i] = 2 * param[i];
+ result[15 + i] = param[i];
+ }
+ result[30] = 1;
+ result[31] = 2;
+
+ _hidl_cb(result);
+
+ return Void();
+}
+
+Return<void> Baz::doStuffAndReturnAString(doStuffAndReturnAString_cb _hidl_cb) {
+ LOG(INFO) << "doStuffAndReturnAString";
+
+ hidl_string s;
+ s = "Hello, world!";
+
+ _hidl_cb(s);
+
+ return Void();
+}
+
+Return<void> Baz::mapThisVector(const hidl_vec<int32_t>& param, mapThisVector_cb _hidl_cb) {
+ LOG(INFO) << "mapThisVector";
+
+ hidl_vec<int32_t> out;
+ out.resize(param.size());
+ for (size_t i = 0; i < param.size(); ++i) {
+ out[i] = param[i] * 2;
+ }
+
+ _hidl_cb(out);
+
+ return Void();
+}
+
+Return<void> Baz::callMe(const sp<IBazCallback>& cb) {
+ LOG(INFO) << "callMe " << cb.get();
+
+ if (cb != NULL) {
+ sp<IBazCallback> my_cb = new BazCallback;
+ cb->heyItsMe(my_cb);
+ }
+
+ return Void();
+}
+
+Return<void> Baz::callMeLater(const sp<IBazCallback>& cb) {
+ LOG(INFO) << "callMeLater " << cb.get();
+
+ mStoredCallback = cb;
+
+ return Void();
+}
+
+Return<void> Baz::iAmFreeNow() {
+ if (mStoredCallback != nullptr) {
+ mStoredCallback->hey();
+ }
+ return Void();
+}
+
+Return<void> Baz::dieNow() {
+ exit(1);
+ return Void();
+}
+
+Return<IBaz::SomeEnum> Baz::useAnEnum(IBaz::SomeEnum zzz) {
+ LOG(INFO) << "useAnEnum " << (int)zzz;
+
+ return SomeEnum::goober;
+}
+
+Return<void> Baz::haveSomeStrings(const hidl_array<hidl_string, 3>& array,
+ haveSomeStrings_cb _hidl_cb) {
+ LOG(INFO) << "haveSomeStrings("
+ << to_string(array)
+ << ")";
+
+ hidl_array<hidl_string, 2> result;
+ result[0] = "Hello";
+ result[1] = "World";
+
+ _hidl_cb(result);
+
+ return Void();
+}
+
+Return<void> Baz::haveAStringVec(const hidl_vec<hidl_string>& vector,
+ haveAStringVec_cb _hidl_cb) {
+ LOG(INFO) << "haveAStringVec(" << to_string(vector) << ")";
+
+ hidl_vec<hidl_string> result;
+ result.resize(2);
+
+ result[0] = "Hello";
+ result[1] = "World";
+
+ _hidl_cb(result);
+
+ return Void();
+}
+
+Return<void> Baz::returnABunchOfStrings(returnABunchOfStrings_cb _hidl_cb) {
+ hidl_string eins; eins = "Eins";
+ hidl_string zwei; zwei = "Zwei";
+ hidl_string drei; drei = "Drei";
+ _hidl_cb(eins, zwei, drei);
+
+ return Void();
+}
+
+Return<uint8_t> Baz::returnABitField() {
+ return 0;
+}
+
+Return<uint32_t> Baz::size(uint32_t size) {
+ return size;
+}
+
+Return<void> Baz::getNestedStructs(getNestedStructs_cb _hidl_cb) {
+ int size = 5;
+ hidl_vec<IBaz::NestedStruct> result;
+ result.resize(size);
+ for (int i = 0; i < size; i++) {
+ result[i].a = i;
+ if (i == 1) {
+ result[i].matrices.resize(6);
+ }
+ }
+ _hidl_cb(result);
+ return Void();
+}
+// Methods from ::android::hidl::base::V1_0::IBase follow.
+
+IBaz* HIDL_FETCH_IBaz(const char* /* name */) {
+ return new Baz();
+}
+
+} // namespace implementation
+} // namespace V1_0
+} // namespace baz
+} // namespace tests
+} // namespace hardware
+} // namespace android
diff --git a/tests/baz/1.0/default/Baz.h b/tests/baz/1.0/default/Baz.h
new file mode 100644
index 0000000..ceb3035
--- /dev/null
+++ b/tests/baz/1.0/default/Baz.h
@@ -0,0 +1,92 @@
+#ifndef ANDROID_HARDWARE_TESTS_BAZ_V1_0_BAZ_H
+#define ANDROID_HARDWARE_TESTS_BAZ_V1_0_BAZ_H
+
+#include <android/hardware/tests/baz/1.0/IBaz.h>
+#include <hidl/MQDescriptor.h>
+#include <hidl/Status.h>
+
+namespace android {
+namespace hardware {
+namespace tests {
+namespace baz {
+namespace V1_0 {
+namespace implementation {
+
+// using ::android::hardware::tests::baz::V1_0::IBase;
+using ::android::hardware::tests::baz::V1_0::IBaz;
+using ::android::hardware::tests::baz::V1_0::IBazCallback;
+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 Baz : public IBaz {
+ // Methods from ::android::hardware::tests::baz::V1_0::IBase follow.
+ Return<void> someBaseMethod() override;
+ Return<bool> someBoolMethod(bool x) override;
+ Return<void> someBoolArrayMethod(const hidl_array<bool, 3>& x,
+ someBoolArrayMethod_cb _hidl_cb) override;
+ Return<void> someBoolVectorMethod(const hidl_vec<bool>& x,
+ someBoolVectorMethod_cb _hidl_cb) override;
+ Return<void> someOtherBaseMethod(const IBase::Foo& foo,
+ someOtherBaseMethod_cb _hidl_cb) override;
+ Return<void> someMethodWithFooArrays(const hidl_array<IBase::Foo, 2>& fooInput,
+ someMethodWithFooArrays_cb _hidl_cb) override;
+ Return<void> someMethodWithFooVectors(const hidl_vec<IBase::Foo>& fooInput,
+ someMethodWithFooVectors_cb _hidl_cb) override;
+ Return<void> someMethodWithVectorOfArray(const IBase::VectorOfArray& in,
+ someMethodWithVectorOfArray_cb _hidl_cb) override;
+ Return<void> someMethodTakingAVectorOfArray(const hidl_vec<hidl_array<uint8_t, 6>>& in,
+ someMethodTakingAVectorOfArray_cb _hidl_cb) override;
+ Return<void> transpose(const IBase::StringMatrix5x3& in,
+ transpose_cb _hidl_cb) override;
+ Return<void> transpose2(const hidl_array<hidl_string, 5, 3>& in,
+ transpose2_cb _hidl_cb) override;
+ Return<void> takeAMask(IBase::BitField bf,
+ uint8_t first,
+ const IBase::MyMask& second,
+ uint8_t third,
+ takeAMask_cb _hidl_cb) override;
+
+ // Methods from ::android::hardware::tests::baz::V1_0::IBaz follow.
+ Return<void> doThis(float param) override;
+ Return<int32_t> doThatAndReturnSomething(int64_t param) override;
+ Return<double> doQuiteABit(int32_t a, int64_t b, float c, double d) override;
+ Return<void> doSomethingElse(const hidl_array<int32_t, 15>& param,
+ doSomethingElse_cb _hidl_cb) override;
+ Return<void> doStuffAndReturnAString(doStuffAndReturnAString_cb _hidl_cb) override;
+ Return<void> mapThisVector(const hidl_vec<int32_t>& param, mapThisVector_cb _hidl_cb) override;
+ Return<void> callMe(const sp<IBazCallback>& cb) override;
+ Return<void> callMeLater(const sp<IBazCallback>& cb) override;
+ Return<void> iAmFreeNow() override;
+ Return<void> dieNow() override;
+ Return<IBaz::SomeEnum> useAnEnum(IBaz::SomeEnum zzz) override;
+ Return<void> haveSomeStrings(const hidl_array<hidl_string, 3>& array,
+ haveSomeStrings_cb _hidl_cb) override;
+ Return<void> haveAStringVec(const hidl_vec<hidl_string>& vector,
+ haveAStringVec_cb _hidl_cb) override;
+ Return<void> returnABunchOfStrings(returnABunchOfStrings_cb _hidl_cb) override;
+ Return<uint8_t> returnABitField() override;
+ Return<uint32_t> size(uint32_t size) override;
+ Return<void> getNestedStructs(getNestedStructs_cb _hidl_cb) override;
+
+ // Methods from ::android::hidl::base::V1_0::IBase follow.
+ private:
+ sp<IBazCallback> mStoredCallback;
+};
+
+extern "C" IBaz* HIDL_FETCH_IBaz(const char* name);
+
+} // namespace implementation
+} // namespace V1_0
+} // namespace baz
+} // namespace tests
+} // namespace hardware
+} // namespace android
+
+#endif // ANDROID_HARDWARE_TESTS_BAZ_V1_0_BAZ_H
diff --git a/thermal/1.0/vts/functional/Android.bp b/thermal/1.0/vts/functional/Android.bp
index 63f0ba9..456b75b 100644
--- a/thermal/1.0/vts/functional/Android.bp
+++ b/thermal/1.0/vts/functional/Android.bp
@@ -16,7 +16,6 @@
cc_test {
name: "VtsHalThermalV1_0TargetTest",
- gtest: true,
srcs: ["VtsHalThermalV1_0TargetTest.cpp"],
shared_libs: [
"libbase",
@@ -28,7 +27,7 @@
"libutils",
"android.hardware.thermal@1.0",
],
- static_libs: ["libgtest"],
+ static_libs: ["VtsHalHidlTargetBaseTest"],
cflags: [
"-O0",
"-g",
diff --git a/thermal/1.0/vts/functional/VtsHalThermalV1_0TargetTest.cpp b/thermal/1.0/vts/functional/VtsHalThermalV1_0TargetTest.cpp
index 5bdd2c2..6feec73 100644
--- a/thermal/1.0/vts/functional/VtsHalThermalV1_0TargetTest.cpp
+++ b/thermal/1.0/vts/functional/VtsHalThermalV1_0TargetTest.cpp
@@ -24,7 +24,7 @@
#include <android-base/logging.h>
#include <android/hardware/thermal/1.0/IThermal.h>
#include <android/hardware/thermal/1.0/types.h>
-#include <gtest/gtest.h>
+#include <VtsHalHidlTargetBaseTest.h>
#include <unistd.h>
using ::android::hardware::hidl_string;
@@ -46,10 +46,10 @@
#define MAX_FAN_SPEED 20000
// The main test class for THERMAL HIDL HAL.
-class ThermalHidlTest : public ::testing::Test {
+class ThermalHidlTest : public ::testing::VtsHalHidlTargetBaseTest {
public:
virtual void SetUp() override {
- thermal_ = IThermal::getService();
+ thermal_ = ::testing::VtsHalHidlTargetBaseTest::getService<IThermal>();
ASSERT_NE(thermal_, nullptr);
baseSize_ = 0;
names_.clear();
diff --git a/tv/input/1.0/vts/functional/Android.bp b/tv/input/1.0/vts/functional/Android.bp
index e3785ab..bcff457 100644
--- a/tv/input/1.0/vts/functional/Android.bp
+++ b/tv/input/1.0/vts/functional/Android.bp
@@ -16,7 +16,6 @@
cc_test {
name: "VtsHalTvInputV1_0TargetTest",
- gtest: true,
srcs: ["VtsHalTvInputV1_0TargetTest.cpp"],
shared_libs: [
"libbase",
@@ -28,7 +27,7 @@
"libutils",
"android.hardware.tv.input@1.0",
],
- static_libs: ["libgtest"],
+ static_libs: ["VtsHalHidlTargetBaseTest"],
cflags: [
"-O0",
"-g",
diff --git a/tv/input/1.0/vts/functional/VtsHalTvInputV1_0TargetTest.cpp b/tv/input/1.0/vts/functional/VtsHalTvInputV1_0TargetTest.cpp
index 3747dc5..6757df1 100644
--- a/tv/input/1.0/vts/functional/VtsHalTvInputV1_0TargetTest.cpp
+++ b/tv/input/1.0/vts/functional/VtsHalTvInputV1_0TargetTest.cpp
@@ -21,7 +21,7 @@
#include <android/hardware/tv/input/1.0/ITvInput.h>
#include <android/hardware/tv/input/1.0/ITvInputCallback.h>
-#include <gtest/gtest.h>
+#include <VtsHalHidlTargetBaseTest.h>
#include <utils/KeyedVector.h>
#include <mutex>
#include <vector>
@@ -43,10 +43,10 @@
#define DEFAULT_ID INT32_MIN
/* The main test class for TV Input HIDL HAL. */
-class TvInputHidlTest : public ::testing::Test {
+class TvInputHidlTest : public ::testing::VtsHalHidlTargetBaseTest {
public:
virtual void SetUp() override {
- tv_input_ = ITvInput::getService();
+ tv_input_ = ::testing::VtsHalHidlTargetBaseTest::getService<ITvInput>();
ASSERT_NE(tv_input_, nullptr);
tv_input_callback_ = new TvInputCallback(*this);
ASSERT_NE(tv_input_callback_, nullptr);
diff --git a/usb/1.0/vts/functional/Android.bp b/usb/1.0/vts/functional/Android.bp
index 6f3d1be..ef47f25 100644
--- a/usb/1.0/vts/functional/Android.bp
+++ b/usb/1.0/vts/functional/Android.bp
@@ -16,7 +16,6 @@
cc_test {
name: "VtsHalUsbV1_0TargetTest",
- gtest: true,
srcs: ["VtsHalUsbV1_0TargetTest.cpp"],
shared_libs: [
"libbase",
@@ -28,7 +27,7 @@
"libutils",
"android.hardware.usb@1.0",
],
- static_libs: ["libgtest"],
+ static_libs: ["VtsHalHidlTargetBaseTest"],
cflags: [
"-O0",
"-g",
diff --git a/usb/1.0/vts/functional/VtsHalUsbV1_0TargetTest.cpp b/usb/1.0/vts/functional/VtsHalUsbV1_0TargetTest.cpp
index 658e6b1..9d59fe2 100644
--- a/usb/1.0/vts/functional/VtsHalUsbV1_0TargetTest.cpp
+++ b/usb/1.0/vts/functional/VtsHalUsbV1_0TargetTest.cpp
@@ -21,7 +21,7 @@
#include <android/hardware/usb/1.0/IUsbCallback.h>
#include <android/hardware/usb/1.0/types.h>
-#include <gtest/gtest.h>
+#include <VtsHalHidlTargetBaseTest.h>
#include <stdlib.h>
#include <chrono>
#include <condition_variable>
@@ -50,7 +50,7 @@
#define USB_SERVICE_NAME "usb_hal"
// The main test class for the USB hidl HAL
-class UsbHidlTest : public ::testing::Test {
+class UsbHidlTest : public ::testing::VtsHalHidlTargetBaseTest {
public:
// Callback class for the USB HIDL hal.
// Usb Hal will call this object upon role switch or port query.
@@ -97,7 +97,7 @@
virtual void SetUp() override {
ALOGI("Setup");
- usb = IUsb::getService(USB_SERVICE_NAME);
+ usb = ::testing::VtsHalHidlTargetBaseTest::getService<IUsb>(USB_SERVICE_NAME);
ASSERT_NE(usb, nullptr);
usb_cb_2 = new UsbCallback(*this, 2);
diff --git a/vibrator/1.0/vts/functional/Android.bp b/vibrator/1.0/vts/functional/Android.bp
index 640de01..ff9dca8 100644
--- a/vibrator/1.0/vts/functional/Android.bp
+++ b/vibrator/1.0/vts/functional/Android.bp
@@ -16,7 +16,6 @@
cc_test {
name: "VtsHalVibratorV1_0TargetTest",
- gtest: true,
srcs: ["VtsHalVibratorV1_0TargetTest.cpp"],
shared_libs: [
"libbase",
@@ -25,7 +24,7 @@
"libutils",
"android.hardware.vibrator@1.0",
],
- static_libs: ["libgtest"],
+ static_libs: ["VtsHalHidlTargetBaseTest"],
cflags: [
"-O0",
"-g",
diff --git a/vibrator/1.0/vts/functional/VtsHalVibratorV1_0TargetTest.cpp b/vibrator/1.0/vts/functional/VtsHalVibratorV1_0TargetTest.cpp
index 435b002..c9541fe 100644
--- a/vibrator/1.0/vts/functional/VtsHalVibratorV1_0TargetTest.cpp
+++ b/vibrator/1.0/vts/functional/VtsHalVibratorV1_0TargetTest.cpp
@@ -19,7 +19,7 @@
#include <android-base/logging.h>
#include <android/hardware/vibrator/1.0/IVibrator.h>
#include <android/hardware/vibrator/1.0/types.h>
-#include <gtest/gtest.h>
+#include <VtsHalHidlTargetBaseTest.h>
#include <unistd.h>
using ::android::hardware::vibrator::V1_0::IVibrator;
@@ -29,10 +29,10 @@
using ::android::sp;
// The main test class for VIBRATOR HIDL HAL.
-class VibratorHidlTest : public ::testing::Test {
+class VibratorHidlTest : public ::testing::VtsHalHidlTargetBaseTest {
public:
virtual void SetUp() override {
- vibrator = IVibrator::getService();
+ vibrator = ::testing::VtsHalHidlTargetBaseTest::getService<IVibrator>();
ASSERT_NE(vibrator, nullptr);
}
diff --git a/vr/1.0/vts/functional/Android.bp b/vr/1.0/vts/functional/Android.bp
index 36bc527..b2e50ad 100644
--- a/vr/1.0/vts/functional/Android.bp
+++ b/vr/1.0/vts/functional/Android.bp
@@ -16,7 +16,6 @@
cc_test {
name: "VtsHalVrV1_0TargetTest",
- gtest: true,
srcs: ["VtsHalVrV1_0TargetTest.cpp"],
shared_libs: [
"liblog",
@@ -24,7 +23,7 @@
"libutils",
"android.hardware.vr@1.0",
],
- static_libs: ["libgtest"],
+ static_libs: ["VtsHalHidlTargetBaseTest"],
cflags: [
"-O0",
"-g",
diff --git a/vr/1.0/vts/functional/VtsHalVrV1_0TargetTest.cpp b/vr/1.0/vts/functional/VtsHalVrV1_0TargetTest.cpp
index c7ec076..6a7b078 100644
--- a/vr/1.0/vts/functional/VtsHalVrV1_0TargetTest.cpp
+++ b/vr/1.0/vts/functional/VtsHalVrV1_0TargetTest.cpp
@@ -18,7 +18,7 @@
#include <android-base/logging.h>
#include <android/hardware/vr/1.0/IVr.h>
#include <android/log.h>
-#include <gtest/gtest.h>
+#include <VtsHalHidlTargetBaseTest.h>
#include <hardware/vr.h>
using ::android::hardware::vr::V1_0::IVr;
@@ -27,10 +27,10 @@
using ::android::sp;
// The main test class for VR HIDL HAL.
-class VrHidlTest : public ::testing::Test {
+class VrHidlTest : public ::testing::VtsHalHidlTargetBaseTest {
public:
void SetUp() override {
- vr = IVr::getService();
+ vr = ::testing::VtsHalHidlTargetBaseTest::getService<IVr>();
ASSERT_NE(vr, nullptr);
}
diff --git a/wifi/1.0/IWifiChip.hal b/wifi/1.0/IWifiChip.hal
index b0598a4..611c449 100644
--- a/wifi/1.0/IWifiChip.hal
+++ b/wifi/1.0/IWifiChip.hal
@@ -629,6 +629,19 @@
forceDumpToDebugRingBuffer(string ringName) generates (WifiStatus status);
/**
+ * API to stop the debug data collection for all ring buffers.
+ *
+ * @return status WifiStatus of the operation.
+ * Possible status codes:
+ * |WifiStatusCode.SUCCESS|,
+ * |WifiStatusCode.ERROR_WIFI_CHIP_INVALID|,
+ * |WifiStatusCode.ERROR_NOT_SUPPORTED|,
+ * |WifiStatusCode.NOT_AVAILABLE|,
+ * |WifiStatusCode.UNKNOWN|
+ */
+ stopLoggingToDebugRingBuffer() generates (WifiStatus status);
+
+ /**
* API to retrieve the wifi wake up reason stats for debugging.
* The driver is expected to start maintaining these stats once the chip
* is configured using |configureChip|. These stats must be reset whenever
diff --git a/wifi/1.0/IWifiStaIfaceEventCallback.hal b/wifi/1.0/IWifiStaIfaceEventCallback.hal
index e8df4c2..e51ea6d 100644
--- a/wifi/1.0/IWifiStaIfaceEventCallback.hal
+++ b/wifi/1.0/IWifiStaIfaceEventCallback.hal
@@ -31,9 +31,12 @@
* |StaBackgroundScanBucketParameters.eventReportScheme|.
*
* @param cmdId command ID corresponding to the request.
+ * @param bucketsScanned Bitset where each bit indicates if the bucket with
+ * that index (starting at 0) was scanned.
* @parm result Full scan result for an AP.
*/
- oneway onBackgroundFullScanResult(CommandId cmdId, StaScanResult result);
+ oneway onBackgroundFullScanResult(
+ CommandId cmdId, uint32_t bucketsScanned, StaScanResult result);
/**
* Called when the |StaBackgroundScanBucketParameters.eventReportScheme| flags
diff --git a/wifi/1.0/default/hidl_struct_util.cpp b/wifi/1.0/default/hidl_struct_util.cpp
index c498206..82364cb 100644
--- a/wifi/1.0/default/hidl_struct_util.cpp
+++ b/wifi/1.0/default/hidl_struct_util.cpp
@@ -338,7 +338,6 @@
hidl_scan_params.reportThresholdPercent;
legacy_scan_params->report_threshold_num_scans =
hidl_scan_params.reportThresholdNumScans;
- // TODO(b/33194311): Expose these max limits in the HIDL interface.
if (hidl_scan_params.buckets.size() > MAX_BUCKETS) {
return false;
}
@@ -366,7 +365,6 @@
convertHidlGscanReportEventFlagToLegacy(flag);
}
}
- // TODO(b/33194311): Expose these max limits in the HIDL interface.
if (hidl_bucket_spec.frequencies.size() > MAX_CHANNELS) {
return false;
}
@@ -973,6 +971,8 @@
legacy_request->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->service_responder_policy = hidl_request.autoAcceptDataPathRequests ?
+ legacy_hal::NAN_SERVICE_ACCEPT_POLICY_ALL : legacy_hal::NAN_SERVICE_ACCEPT_POLICY_NONE;
return true;
}
diff --git a/wifi/1.0/default/wifi_chip.cpp b/wifi/1.0/default/wifi_chip.cpp
index 6aeedf8..6f980c0 100644
--- a/wifi/1.0/default/wifi_chip.cpp
+++ b/wifi/1.0/default/wifi_chip.cpp
@@ -317,6 +317,14 @@
ring_name);
}
+Return<void> WifiChip::stopLoggingToDebugRingBuffer(
+ stopLoggingToDebugRingBuffer_cb hidl_status_cb) {
+ return validateAndCall(this,
+ WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
+ &WifiChip::stopLoggingToDebugRingBufferInternal,
+ hidl_status_cb);
+}
+
Return<void> WifiChip::getDebugHostWakeReasonStats(
getDebugHostWakeReasonStats_cb hidl_status_cb) {
return validateAndCall(this,
@@ -735,6 +743,12 @@
return createWifiStatusFromLegacyError(legacy_status);
}
+WifiStatus WifiChip::stopLoggingToDebugRingBufferInternal() {
+ legacy_hal::wifi_error legacy_status =
+ legacy_hal_.lock()->deregisterRingBufferCallbackHandler();
+ return createWifiStatusFromLegacyError(legacy_status);
+}
+
std::pair<WifiStatus, WifiDebugHostWakeReasonStats>
WifiChip::getDebugHostWakeReasonStatsInternal() {
legacy_hal::wifi_error legacy_status;
diff --git a/wifi/1.0/default/wifi_chip.h b/wifi/1.0/default/wifi_chip.h
index e1c2344..406938c 100644
--- a/wifi/1.0/default/wifi_chip.h
+++ b/wifi/1.0/default/wifi_chip.h
@@ -119,6 +119,8 @@
Return<void> forceDumpToDebugRingBuffer(
const hidl_string& ring_name,
forceDumpToDebugRingBuffer_cb hidl_status_cb) override;
+ Return<void> stopLoggingToDebugRingBuffer(
+ stopLoggingToDebugRingBuffer_cb hidl_status_cb) override;
Return<void> getDebugHostWakeReasonStats(
getDebugHostWakeReasonStats_cb hidl_status_cb) override;
Return<void> enableDebugErrorAlerts(
@@ -170,6 +172,7 @@
uint32_t max_interval_in_sec,
uint32_t min_data_size_in_bytes);
WifiStatus forceDumpToDebugRingBufferInternal(const hidl_string& ring_name);
+ WifiStatus stopLoggingToDebugRingBufferInternal();
std::pair<WifiStatus, WifiDebugHostWakeReasonStats>
getDebugHostWakeReasonStatsInternal();
WifiStatus enableDebugErrorAlertsInternal(bool enable);
diff --git a/wifi/1.0/default/wifi_nan_iface.cpp b/wifi/1.0/default/wifi_nan_iface.cpp
index 68be2a7..6977fc0 100644
--- a/wifi/1.0/default/wifi_nan_iface.cpp
+++ b/wifi/1.0/default/wifi_nan_iface.cpp
@@ -166,6 +166,7 @@
LOG(ERROR) << "Failed to invoke the callback";
}
}
+ break;
}
case legacy_hal::NAN_DP_END: {
for (const auto& callback : shared_ptr_this->getEventCallbacks()) {
diff --git a/wifi/1.0/default/wifi_sta_iface.cpp b/wifi/1.0/default/wifi_sta_iface.cpp
index 0c84102..626b195 100644
--- a/wifi/1.0/default/wifi_sta_iface.cpp
+++ b/wifi/1.0/default/wifi_sta_iface.cpp
@@ -415,7 +415,7 @@
const auto& on_full_result_callback = [weak_ptr_this](
legacy_hal::wifi_request_id id,
const legacy_hal::wifi_scan_result* result,
- uint32_t /* buckets_scanned */) {
+ uint32_t buckets_scanned) {
const auto shared_ptr_this = weak_ptr_this.promote();
if (!shared_ptr_this.get() || !shared_ptr_this->isValid()) {
LOG(ERROR) << "Callback invoked on an invalid object";
@@ -428,7 +428,8 @@
return;
}
for (const auto& callback : shared_ptr_this->getEventCallbacks()) {
- if (!callback->onBackgroundFullScanResult(id, hidl_scan_result).isOk()) {
+ if (!callback->onBackgroundFullScanResult(
+ id, buckets_scanned, hidl_scan_result).isOk()) {
LOG(ERROR) << "Failed to invoke onBackgroundFullScanResult callback";
}
}
diff --git a/wifi/1.0/types.hal b/wifi/1.0/types.hal
index 5ffb55c..83e6660 100644
--- a/wifi/1.0/types.hal
+++ b/wifi/1.0/types.hal
@@ -306,6 +306,15 @@
};
/**
+ * Max limits for background scan.
+ */
+enum StaScanLimits : uint32_t {
+ MAX_CHANNELS = 16,
+ MAX_BUCKETS = 16,
+ MAX_AP_CACHE_PER_SCAN = 32
+};
+
+/**
* Background Scan parameters per bucket that can be specified in background
* scan requests.
*/
@@ -318,6 +327,7 @@
/**
* Channel frequencies (in Mhz) to scan if |band| is set to
* |BAND_UNSPECIFIED|.
+ * Max length: |StaScanLimits.MAX_CHANNELS|.
*/
vec<WifiChannelInMhz> frequencies;
/**
@@ -361,6 +371,7 @@
/**
* Maximum number of APs that must be stored for each scan. If the maximum
* is reached the highest RSSI results must be returned.
+ * Max length: |StaScanLimits.MAX_AP_CACHE_PER_SCAN|.
*/
uint32_t maxApPerScan;
/**
@@ -374,6 +385,7 @@
uint32_t reportThresholdNumScans;
/**
* List of buckets to be scheduled.
+ * Max length: |StaScanLimits.MAX_BUCKETS|.
*/
vec<StaBackgroundScanBucketParameters> buckets;
};
@@ -506,8 +518,8 @@
*/
bitfield<StaScanDataFlagMask> flags;
/**
- * Bitset where each bit indicates if the bucket with that index was
- * scanned.
+ * Bitset where each bit indicates if the bucket with that index (starting at
+ * 0) was scanned.
*/
uint32_t bucketsScanned;
/**
@@ -1062,6 +1074,13 @@
* peer.
*/
NanTxType txType;
+ /**
+ * Specifies whether data-path requests |IWifiNanIfaceEventCallback.eventDataPathRequest| (in
+ * the context of this discovery session) are automatically accepted (if true) - in which case
+ * the Responder must not call the |IWifiNanIface.respondToDataPathIndicationRequest| method and
+ * the device must automatically accept the data-path request and complete the negotiation.
+ */
+ bool autoAcceptDataPathRequests;
};
/**
diff --git a/wifi/1.0/vts/functional/wifi_hidl_test_utils.cpp b/wifi/1.0/vts/functional/wifi_hidl_test_utils.cpp
index 820a75d..9042075 100644
--- a/wifi/1.0/vts/functional/wifi_hidl_test_utils.cpp
+++ b/wifi/1.0/vts/functional/wifi_hidl_test_utils.cpp
@@ -43,7 +43,7 @@
void startFramework() { ASSERT_EQ(std::system("svc wifi enable"), 0); }
sp<IWifi> getWifi() {
- sp<IWifi> wifi = testing::VtsHalHidlTargetBaseTest::getService<IWifi>();
+ sp<IWifi> wifi = ::testing::VtsHalHidlTargetBaseTest::getService<IWifi>();
return wifi;
}