Merge "Use HIDL's memory for shared memory and add wrapper interfaces for IGraphicBufferProducer."
diff --git a/audio/effect/2.0/vts/functional/audio_effect_hidl_hal_test.cpp b/audio/effect/2.0/vts/functional/audio_effect_hidl_hal_test.cpp
index 9b7d0cf..145d4c3 100644
--- a/audio/effect/2.0/vts/functional/audio_effect_hidl_hal_test.cpp
+++ b/audio/effect/2.0/vts/functional/audio_effect_hidl_hal_test.cpp
@@ -38,8 +38,7 @@
class AudioEffectHidlTest : public ::testing::Test {
public:
virtual void SetUp() override {
- // currently test passthrough mode only
- effectsFactory = IEffectsFactory::getService("audio_effects_factory", true);
+ effectsFactory = IEffectsFactory::getService("audio_effects_factory");
ASSERT_NE(effectsFactory, nullptr);
}
diff --git a/biometrics/fingerprint/2.1/Android.bp b/biometrics/fingerprint/2.1/Android.bp
index 02b7328..2a252dc 100644
--- a/biometrics/fingerprint/2.1/Android.bp
+++ b/biometrics/fingerprint/2.1/Android.bp
@@ -62,3 +62,155 @@
"android.hidl.base@1.0",
],
}
+
+genrule {
+ name: "android.hardware.biometrics.fingerprint.vts.driver@2.1_genc++",
+ tools: ["hidl-gen", "vtsc"],
+ cmd: "$(location hidl-gen) -o $(genDir) -Lvts -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.biometrics.fingerprint@2.1 && $(location vtsc) -mDRIVER -tSOURCE -b$(genDir) android/hardware/biometrics/fingerprint/2.1/ $(genDir)/android/hardware/biometrics/fingerprint/2.1/",
+ srcs: [
+ "types.hal",
+ "IBiometricsFingerprint.hal",
+ "IBiometricsFingerprintClientCallback.hal",
+ ],
+ out: [
+ "android/hardware/biometrics/fingerprint/2.1/types.vts.cpp",
+ "android/hardware/biometrics/fingerprint/2.1/BiometricsFingerprint.vts.cpp",
+ "android/hardware/biometrics/fingerprint/2.1/BiometricsFingerprintClientCallback.vts.cpp",
+ ],
+}
+
+genrule {
+ name: "android.hardware.biometrics.fingerprint.vts.driver@2.1_genc++_headers",
+ tools: ["hidl-gen", "vtsc"],
+ cmd: "$(location hidl-gen) -o $(genDir) -Lvts -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.biometrics.fingerprint@2.1 && $(location vtsc) -mDRIVER -tHEADER -b$(genDir) android/hardware/biometrics/fingerprint/2.1/ $(genDir)/android/hardware/biometrics/fingerprint/2.1/",
+ srcs: [
+ "types.hal",
+ "IBiometricsFingerprint.hal",
+ "IBiometricsFingerprintClientCallback.hal",
+ ],
+ out: [
+ "android/hardware/biometrics/fingerprint/2.1/types.vts.h",
+ "android/hardware/biometrics/fingerprint/2.1/BiometricsFingerprint.vts.h",
+ "android/hardware/biometrics/fingerprint/2.1/BiometricsFingerprintClientCallback.vts.h",
+ ],
+}
+
+cc_library_shared {
+ name: "android.hardware.biometrics.fingerprint.vts.driver@2.1",
+ generated_sources: ["android.hardware.biometrics.fingerprint.vts.driver@2.1_genc++"],
+ generated_headers: ["android.hardware.biometrics.fingerprint.vts.driver@2.1_genc++_headers"],
+ export_generated_headers: ["android.hardware.biometrics.fingerprint.vts.driver@2.1_genc++_headers"],
+ shared_libs: [
+ "libhidlbase",
+ "libhidltransport",
+ "libhwbinder",
+ "liblog",
+ "libutils",
+ "libcutils",
+ "libvts_common",
+ "libvts_datatype",
+ "libvts_measurement",
+ "libvts_multidevice_proto",
+ "libcamera_metadata",
+ "libprotobuf-cpp-full",
+ "android.hidl.base@1.0",
+ "android.hardware.biometrics.fingerprint@2.1",
+ ],
+ export_shared_lib_headers: [
+ "libhidlbase",
+ "libhidltransport",
+ "libhwbinder",
+ "libutils",
+ "android.hidl.base@1.0",
+ ],
+}
+
+genrule {
+ name: "android.hardware.biometrics.fingerprint@2.1-IBiometricsFingerprint-vts.profiler_genc++",
+ tools: ["hidl-gen", "vtsc"],
+ cmd: "$(location hidl-gen) -o $(genDir) -Lvts -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.biometrics.fingerprint@2.1 && $(location vtsc) -mPROFILER -tSOURCE -b$(genDir) android/hardware/biometrics/fingerprint/2.1/ $(genDir)/android/hardware/biometrics/fingerprint/2.1/",
+ srcs: [
+ "IBiometricsFingerprint.hal",
+ "types.hal",
+ ],
+ out: [
+ "android/hardware/biometrics/fingerprint/2.1/BiometricsFingerprint.vts.cpp",
+ "android/hardware/biometrics/fingerprint/2.1/types.vts.cpp",
+ ],
+}
+
+genrule {
+ name: "android.hardware.biometrics.fingerprint@2.1-IBiometricsFingerprint-vts.profiler_genc++_headers",
+ tools: ["hidl-gen", "vtsc"],
+ cmd: "$(location hidl-gen) -o $(genDir) -Lvts -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.biometrics.fingerprint@2.1 && $(location vtsc) -mPROFILER -tHEADER -b$(genDir) android/hardware/biometrics/fingerprint/2.1/ $(genDir)/android/hardware/biometrics/fingerprint/2.1/",
+ srcs: [
+ "IBiometricsFingerprint.hal",
+ "types.hal",
+ ],
+ out: [
+ "android/hardware/biometrics/fingerprint/2.1/BiometricsFingerprint.vts.h",
+ "android/hardware/biometrics/fingerprint/2.1/types.vts.h",
+ ],
+}
+
+cc_library_shared {
+ name: "android.hardware.biometrics.fingerprint@2.1-IBiometricsFingerprint-vts.profiler",
+ generated_sources: ["android.hardware.biometrics.fingerprint@2.1-IBiometricsFingerprint-vts.profiler_genc++"],
+ generated_headers: ["android.hardware.biometrics.fingerprint@2.1-IBiometricsFingerprint-vts.profiler_genc++_headers"],
+ export_generated_headers: ["android.hardware.biometrics.fingerprint@2.1-IBiometricsFingerprint-vts.profiler_genc++_headers"],
+ shared_libs: [
+ "libbase",
+ "libhidlbase",
+ "libhidltransport",
+ "libvts_profiling",
+ "libvts_multidevice_proto",
+ "libprotobuf-cpp-full",
+ "android.hidl.base@1.0",
+ "android.hardware.biometrics.fingerprint@2.1",
+ ],
+}
+
+genrule {
+ name: "android.hardware.biometrics.fingerprint@2.1-IBiometricsFingerprintClientCallback-vts.profiler_genc++",
+ tools: ["hidl-gen", "vtsc"],
+ cmd: "$(location hidl-gen) -o $(genDir) -Lvts -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.biometrics.fingerprint@2.1 && $(location vtsc) -mPROFILER -tSOURCE -b$(genDir) android/hardware/biometrics/fingerprint/2.1/ $(genDir)/android/hardware/biometrics/fingerprint/2.1/",
+ srcs: [
+ "IBiometricsFingerprintClientCallback.hal",
+ "types.hal",
+ ],
+ out: [
+ "android/hardware/biometrics/fingerprint/2.1/BiometricsFingerprintClientCallback.vts.cpp",
+ "android/hardware/biometrics/fingerprint/2.1/types.vts.cpp",
+ ],
+}
+
+genrule {
+ name: "android.hardware.biometrics.fingerprint@2.1-IBiometricsFingerprintClientCallback-vts.profiler_genc++_headers",
+ tools: ["hidl-gen", "vtsc"],
+ cmd: "$(location hidl-gen) -o $(genDir) -Lvts -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.biometrics.fingerprint@2.1 && $(location vtsc) -mPROFILER -tHEADER -b$(genDir) android/hardware/biometrics/fingerprint/2.1/ $(genDir)/android/hardware/biometrics/fingerprint/2.1/",
+ srcs: [
+ "IBiometricsFingerprintClientCallback.hal",
+ "types.hal",
+ ],
+ out: [
+ "android/hardware/biometrics/fingerprint/2.1/BiometricsFingerprintClientCallback.vts.h",
+ "android/hardware/biometrics/fingerprint/2.1/types.vts.h",
+ ],
+}
+
+cc_library_shared {
+ name: "android.hardware.biometrics.fingerprint@2.1-IBiometricsFingerprintClientCallback-vts.profiler",
+ generated_sources: ["android.hardware.biometrics.fingerprint@2.1-IBiometricsFingerprintClientCallback-vts.profiler_genc++"],
+ generated_headers: ["android.hardware.biometrics.fingerprint@2.1-IBiometricsFingerprintClientCallback-vts.profiler_genc++_headers"],
+ export_generated_headers: ["android.hardware.biometrics.fingerprint@2.1-IBiometricsFingerprintClientCallback-vts.profiler_genc++_headers"],
+ shared_libs: [
+ "libbase",
+ "libhidlbase",
+ "libhidltransport",
+ "libvts_profiling",
+ "libvts_multidevice_proto",
+ "libprotobuf-cpp-full",
+ "android.hidl.base@1.0",
+ "android.hardware.biometrics.fingerprint@2.1",
+ ],
+}
diff --git a/biometrics/fingerprint/2.1/IBiometricsFingerprintClientCallback.hal b/biometrics/fingerprint/2.1/IBiometricsFingerprintClientCallback.hal
index 63435d1..d913cf1 100644
--- a/biometrics/fingerprint/2.1/IBiometricsFingerprintClientCallback.hal
+++ b/biometrics/fingerprint/2.1/IBiometricsFingerprintClientCallback.hal
@@ -43,8 +43,9 @@
* @param deviceId the instance of this fingerprint device
* @param fingerId the fingerprint templetate that was authenticated
* @param groupId the groupid for the template that was authenticated
+ * @param token the hardware authentication token to pass to Keystore.addAuthToken()
*/
- oneway onAuthenticated(uint64_t deviceId, uint32_t fingerId, uint32_t groupId);
+ oneway onAuthenticated(uint64_t deviceId, uint32_t fingerId, uint32_t groupId, vec<uint8_t> token);
/**
* Sent when a fingerprint error occurs
diff --git a/biometrics/fingerprint/2.1/default/BiometricsFingerprint.cpp b/biometrics/fingerprint/2.1/default/BiometricsFingerprint.cpp
index 516cd00..154b7a6 100644
--- a/biometrics/fingerprint/2.1/default/BiometricsFingerprint.cpp
+++ b/biometrics/fingerprint/2.1/default/BiometricsFingerprint.cpp
@@ -14,10 +14,9 @@
* limitations under the License.
*/
#define LOG_TAG "android.hardware.biometrics.fingerprint@2.1-service"
+#define LOG_VERBOSE "android.hardware.biometrics.fingerprint@2.1-service"
// For communication with Keystore binder interface
-#include <binder/IServiceManager.h>
-#include <keystore/IKeystoreService.h>
#include <keystore/keystore.h> // for error codes
#include <hardware/hw_auth_token.h>
@@ -40,23 +39,19 @@
using RequestStatus =
android::hardware::biometrics::fingerprint::V2_1::RequestStatus;
-sp<IBiometricsFingerprintClientCallback>
- BiometricsFingerprint::mClientCallback = nullptr;
+BiometricsFingerprint *BiometricsFingerprint::sInstance = nullptr;
-// TODO: This is here because HAL 2.1 doesn't have a way to propagate a
-// unique token for its driver. Subsequent versions should send a unique
-// token for each call to notify(). This is fine as long as there's only
-// one fingerprint device on the platform.
-fingerprint_device_t *BiometricsFingerprint::sDevice = nullptr;
-
-BiometricsFingerprint::BiometricsFingerprint(fingerprint_device_t *device)
- : mDevice(device) {
- sDevice = mDevice; // keep track of the most recent instance
+BiometricsFingerprint::BiometricsFingerprint() : mClientCallback(nullptr), mDevice(nullptr) {
+ sInstance = this; // keep track of the most recent instance
+ mDevice = openHal();
+ if (!mDevice) {
+ ALOGE("Can't open HAL module");
+ }
}
BiometricsFingerprint::~BiometricsFingerprint() {
- ALOG(LOG_VERBOSE, LOG_TAG, "nativeCloseHal()\n");
- if (mDevice == NULL) {
+ ALOGV(LOG_VERBOSE, LOG_TAG, "~BiometricsFingerprint()\n");
+ if (mDevice == nullptr) {
ALOGE("No valid device");
return;
}
@@ -66,7 +61,7 @@
ALOGE("Can't close fingerprint module, error: %d", err);
return;
}
- mDevice = NULL;
+ mDevice = nullptr;
}
Return<RequestStatus> BiometricsFingerprint::ErrorFilter(int32_t error) {
@@ -107,6 +102,8 @@
return FingerprintError::ERROR_CANCELED;
case FINGERPRINT_ERROR_UNABLE_TO_REMOVE:
return FingerprintError::ERROR_UNABLE_TO_REMOVE;
+ case FINGERPRINT_ERROR_LOCKOUT:
+ return FingerprintError::ERROR_LOCKOUT;
default:
if (error >= FINGERPRINT_ERROR_VENDOR_BASE) {
// vendor specific code.
@@ -114,7 +111,7 @@
return FingerprintError::ERROR_VENDOR;
}
}
- ALOGE("Unknown error from fingerprint vendor library");
+ ALOGE("Unknown error from fingerprint vendor library: %d", error);
return FingerprintError::ERROR_UNABLE_TO_PROCESS;
}
@@ -143,13 +140,17 @@
return FingerprintAcquiredInfo::ACQUIRED_VENDOR;
}
}
- ALOGE("Unknown acquiredmsg from fingerprint vendor library");
+ ALOGE("Unknown acquiredmsg from fingerprint vendor library: %d", info);
return FingerprintAcquiredInfo::ACQUIRED_INSUFFICIENT;
}
Return<uint64_t> BiometricsFingerprint::setNotify(
const sp<IBiometricsFingerprintClientCallback>& clientCallback) {
mClientCallback = clientCallback;
+ // This is here because HAL 2.1 doesn't have a way to propagate a
+ // unique token for its driver. Subsequent versions should send a unique
+ // token for each call to setNotify(). This is fine as long as there's only
+ // one fingerprint device on the platform.
return reinterpret_cast<uint64_t>(mDevice);
}
@@ -199,36 +200,44 @@
}
IBiometricsFingerprint* BiometricsFingerprint::getInstance() {
+ if (!sInstance) {
+ sInstance = new BiometricsFingerprint();
+ }
+ return sInstance;
+}
+
+fingerprint_device_t* BiometricsFingerprint::openHal() {
int err;
- const hw_module_t *hw_mdl = NULL;
- ALOGE("Opening fingerprint hal library...");
+ const hw_module_t *hw_mdl = nullptr;
+ ALOGD("Opening fingerprint hal library...");
if (0 != (err = hw_get_module(FINGERPRINT_HARDWARE_MODULE_ID, &hw_mdl))) {
ALOGE("Can't open fingerprint HW Module, error: %d", err);
return nullptr;
}
- if (hw_mdl == NULL) {
+ if (hw_mdl == nullptr) {
ALOGE("No valid fingerprint module");
return nullptr;
}
fingerprint_module_t const *module =
reinterpret_cast<const fingerprint_module_t*>(hw_mdl);
- if (module->common.methods->open == NULL) {
+ if (module->common.methods->open == nullptr) {
ALOGE("No valid open method");
return nullptr;
}
- hw_device_t *device = NULL;
+ hw_device_t *device = nullptr;
- if (0 != (err = module->common.methods->open(hw_mdl, NULL, &device))) {
+ if (0 != (err = module->common.methods->open(hw_mdl, nullptr, &device))) {
ALOGE("Can't open fingerprint methods, error: %d", err);
return nullptr;
}
if (kVersion != device->version) {
+ // enforce version on new devices because of HIDL@2.1 translation layer
ALOGE("Wrong fp version. Expected %d, got %d", kVersion, device->version);
- return 0; // enforce this on new devices because of HIDL translation layer
+ return nullptr;
}
fingerprint_device_t* fp_device =
@@ -240,23 +249,67 @@
return nullptr;
}
- return new BiometricsFingerprint(fp_device);
+ return fp_device;
}
-void BiometricsFingerprint::notifyKeystore(const uint8_t *auth_token, const size_t auth_token_length) {
- if (auth_token != nullptr && auth_token_length > 0) {
- // TODO: cache service?
- sp<IServiceManager> sm = android::defaultServiceManager();
- sp<::android::IBinder> binder = sm->getService(String16("android.security.keystore"));
- sp<IKeystoreService> service = interface_cast<IKeystoreService>(binder);
- if (service != nullptr) {
- auto ret = service->addAuthToken(auth_token, auth_token_length);
- if (!ret.isOk()) {
- ALOGE("Failure sending auth token to KeyStore: %" PRId32, int32_t(ret));
+void BiometricsFingerprint::notify(const fingerprint_msg_t *msg) {
+ BiometricsFingerprint* thisPtr = static_cast<BiometricsFingerprint*>(
+ BiometricsFingerprint::getInstance());
+ if (thisPtr == nullptr || thisPtr->mClientCallback == nullptr) {
+ ALOGE("Receiving callbacks before the client callback is registered.");
+ return;
+ }
+ const uint64_t devId = reinterpret_cast<uint64_t>(thisPtr->mDevice);
+ switch (msg->type) {
+ case FINGERPRINT_ERROR: {
+ int32_t vendorCode = 0;
+ FingerprintError result = VendorErrorFilter(msg->data.error, &vendorCode);
+ thisPtr->mClientCallback->onError(devId, result, vendorCode);
}
- } else {
- ALOGE("Unable to communicate with KeyStore");
- }
+ break;
+ case FINGERPRINT_ACQUIRED: {
+ int32_t vendorCode = 0;
+ FingerprintAcquiredInfo result =
+ VendorAcquiredFilter(msg->data.acquired.acquired_info, &vendorCode);
+ thisPtr->mClientCallback->onAcquired(devId, result, vendorCode);
+ }
+ break;
+ case FINGERPRINT_TEMPLATE_ENROLLING:
+ thisPtr->mClientCallback->onEnrollResult(devId,
+ msg->data.enroll.finger.fid,
+ msg->data.enroll.finger.gid,
+ msg->data.enroll.samples_remaining);
+ break;
+ case FINGERPRINT_TEMPLATE_REMOVED:
+ thisPtr->mClientCallback->onRemoved(devId,
+ msg->data.removed.finger.fid,
+ msg->data.removed.finger.gid,
+ msg->data.removed.remaining_templates);
+ break;
+ case FINGERPRINT_AUTHENTICATED:
+ if (msg->data.authenticated.finger.fid != 0) {
+ const uint8_t* hat =
+ reinterpret_cast<const uint8_t *>(&msg->data.authenticated.hat);
+ const hidl_vec<uint8_t> token(
+ std::vector<uint8_t>(hat, hat + sizeof(msg->data.authenticated.hat)));
+ thisPtr->mClientCallback->onAuthenticated(devId,
+ msg->data.authenticated.finger.fid,
+ msg->data.authenticated.finger.gid,
+ token);
+ } else {
+ // Not a recognized fingerprint
+ thisPtr->mClientCallback->onAuthenticated(devId,
+ msg->data.authenticated.finger.fid,
+ msg->data.authenticated.finger.gid,
+ hidl_vec<uint8_t>());
+ }
+ break;
+ case FINGERPRINT_TEMPLATE_ENUMERATING:
+ thisPtr->mClientCallback->onEnumerate(devId,
+ msg->data.enumerated.finger.fid,
+ msg->data.enumerated.finger.gid,
+ msg->data.enumerated.remaining_templates);
+ break;
}
}
diff --git a/biometrics/fingerprint/2.1/default/BiometricsFingerprint.h b/biometrics/fingerprint/2.1/default/BiometricsFingerprint.h
index 1f44a1c..652a3e0 100644
--- a/biometrics/fingerprint/2.1/default/BiometricsFingerprint.h
+++ b/biometrics/fingerprint/2.1/default/BiometricsFingerprint.h
@@ -43,7 +43,7 @@
struct BiometricsFingerprint : public IBiometricsFingerprint {
public:
- BiometricsFingerprint(fingerprint_device_t *device);
+ BiometricsFingerprint();
~BiometricsFingerprint();
// Method to wrap legacy HAL with BiometricsFingerprint class
@@ -60,68 +60,17 @@
Return<RequestStatus> remove(uint32_t gid, uint32_t fid) override;
Return<RequestStatus> setActiveGroup(uint32_t gid, const hidl_string& storePath) override;
Return<RequestStatus> authenticate(uint64_t operationId, uint32_t gid) override;
- static void notify(const fingerprint_msg_t *msg) {
- if (mClientCallback == nullptr) {
- ALOGE("Receiving callbacks before the client callback is registered.");
- return;
- }
- const uint64_t devId = reinterpret_cast<uint64_t>(sDevice);
- switch (msg->type) {
- case FINGERPRINT_ERROR: {
- int32_t vendorCode = 0;
- FingerprintError result =
- VendorErrorFilter(msg->data.error, &vendorCode);
- mClientCallback->onError(devId, result, vendorCode);
- }
- break;
- case FINGERPRINT_ACQUIRED: {
- int32_t vendorCode = 0;
- FingerprintAcquiredInfo result =
- VendorAcquiredFilter(msg->data.acquired.acquired_info,
- &vendorCode);
- mClientCallback->onAcquired(devId, result, vendorCode);
- }
- break;
- case FINGERPRINT_TEMPLATE_ENROLLING:
- mClientCallback->onEnrollResult(devId,
- msg->data.enroll.finger.fid,
- msg->data.enroll.finger.gid,
- msg->data.enroll.samples_remaining);
- break;
- case FINGERPRINT_TEMPLATE_REMOVED:
- mClientCallback->onRemoved(devId,
- msg->data.removed.finger.fid,
- msg->data.removed.finger.gid,
- msg->data.removed.remaining_templates);
- break;
- case FINGERPRINT_AUTHENTICATED:
- if (msg->data.authenticated.finger.fid != 0) {
- const uint8_t* hat =
- reinterpret_cast<const uint8_t *>(&msg->data.authenticated.hat);
- notifyKeystore(hat, sizeof(msg->data.authenticated.hat));
- }
- mClientCallback->onAuthenticated(devId,
- msg->data.authenticated.finger.fid,
- msg->data.authenticated.finger.gid);
- break;
- case FINGERPRINT_TEMPLATE_ENUMERATING:
- mClientCallback->onEnumerate(devId,
- msg->data.enumerated.finger.fid,
- msg->data.enumerated.finger.gid,
- msg->data.enumerated.remaining_templates);
- break;
- }
- }
+
private:
- Return<RequestStatus> ErrorFilter(int32_t error);
- static void notifyKeystore(const uint8_t *auth_token, const size_t auth_token_length);
- static FingerprintError VendorErrorFilter(int32_t error,
- int32_t* vendorCode);
- static FingerprintAcquiredInfo VendorAcquiredFilter(int32_t error,
- int32_t* vendorCode);
- static sp<IBiometricsFingerprintClientCallback> mClientCallback;
+ static fingerprint_device_t* openHal();
+ static void notify(const fingerprint_msg_t *msg); /* Static callback for legacy HAL implementation */
+ static Return<RequestStatus> ErrorFilter(int32_t error);
+ static FingerprintError VendorErrorFilter(int32_t error, int32_t* vendorCode);
+ static FingerprintAcquiredInfo VendorAcquiredFilter(int32_t error, int32_t* vendorCode);
+ static BiometricsFingerprint* sInstance;
+
+ sp<IBiometricsFingerprintClientCallback> mClientCallback;
fingerprint_device_t *mDevice;
- static fingerprint_device_t *sDevice; // TODO: allow multiple drivers
};
} // namespace implementation
diff --git a/camera/provider/2.4/vts/functional/camera_hidl_hal_test.cpp b/camera/provider/2.4/vts/functional/camera_hidl_hal_test.cpp
index 0eb291c..0186371 100644
--- a/camera/provider/2.4/vts/functional/camera_hidl_hal_test.cpp
+++ b/camera/provider/2.4/vts/functional/camera_hidl_hal_test.cpp
@@ -95,7 +95,7 @@
void CameraHidlEnvironment::SetUp() {
// TODO: test the binderized mode
- mProvider = ICameraProvider::getService(CAMERA_PASSTHROUGH_SERVICE_NAME, true);
+ mProvider = ICameraProvider::getService(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);
diff --git a/drm/1.0/default/CryptoPlugin.cpp b/drm/1.0/default/CryptoPlugin.cpp
index 1a32706..fb61ede 100644
--- a/drm/1.0/default/CryptoPlugin.cpp
+++ b/drm/1.0/default/CryptoPlugin.cpp
@@ -62,6 +62,11 @@
const DestinationBuffer& destination,
decrypt_cb _hidl_cb) {
+ if (mSharedBufferBase == NULL) {
+ _hidl_cb(Status::BAD_VALUE, 0, "decrypt buffer base not set");
+ return Void();
+ }
+
android::CryptoPlugin::Mode legacyMode;
switch(mode) {
case Mode::UNENCRYPTED:
diff --git a/evs/1.0/IEvsCamera.hal b/evs/1.0/IEvsCamera.hal
index a2fc565..d0559d7 100644
--- a/evs/1.0/IEvsCamera.hal
+++ b/evs/1.0/IEvsCamera.hal
@@ -65,7 +65,7 @@
* as one), and if the supply is exhausted, no further frames may be
* delivered until a buffer is returned.
*/
- doneWithFrame(uint32_t frameId, handle bufferHandle) generates (EvsResult result);
+ oneway doneWithFrame(BufferDesc buffer);
/**
* Stop the delivery of EVS camera frames.
diff --git a/evs/1.0/IEvsCameraStream.hal b/evs/1.0/IEvsCameraStream.hal
index ef5460f..fcd5717 100644
--- a/evs/1.0/IEvsCameraStream.hal
+++ b/evs/1.0/IEvsCameraStream.hal
@@ -32,5 +32,5 @@
* must be delivered, signifying the end of the stream. No further frame
* deliveries may happen thereafter.
*/
- oneway deliverFrame(uint32_t frameId, handle bufferHandle);
+ oneway deliverFrame(BufferDesc buffer);
};
diff --git a/evs/1.0/IEvsDisplay.hal b/evs/1.0/IEvsDisplay.hal
index a473872..8352221 100644
--- a/evs/1.0/IEvsDisplay.hal
+++ b/evs/1.0/IEvsDisplay.hal
@@ -65,7 +65,7 @@
* must be returned via a call to returnTargetBufferForDisplay() even if the
* display is no longer visible.
*/
- getTargetBuffer() generates (handle bufferHandle);
+ getTargetBuffer() generates (BufferDesc buffer);
/**
@@ -76,5 +76,5 @@
* call. The buffer may be returned at any time and in any DisplayState, but all
* buffers are expected to be returned before the IEvsDisplay interface is destroyed.
*/
- returnTargetBufferForDisplay(handle bufferHandle) generates (EvsResult result);
+ returnTargetBufferForDisplay(BufferDesc buffer) generates (EvsResult result);
};
diff --git a/evs/1.0/IEvsEnumerator.hal b/evs/1.0/IEvsEnumerator.hal
index e3a1382..3779866 100644
--- a/evs/1.0/IEvsEnumerator.hal
+++ b/evs/1.0/IEvsEnumerator.hal
@@ -67,5 +67,15 @@
* NOTE: All buffer must have been returned to the display before making this call.
*/
closeDisplay(IEvsDisplay display);
+
+ /**
+ * This call requests the current state of the display
+ *
+ * If there is no open display, this returns DisplayState::NOT_OPEN. otherwise, it returns
+ * the actual state of the active display. This call is replicated on the IEvsEnumerator
+ * interface in order to allow secondary clients to monitor the state of the EVS display
+ * without acquiring exclusive ownership of the display.
+ */
+ getDisplayState() generates (DisplayState state);
};
diff --git a/evs/1.0/default/Android.bp b/evs/1.0/default/Android.bp
index 3bda250..e3bff25 100644
--- a/evs/1.0/default/Android.bp
+++ b/evs/1.0/default/Android.bp
@@ -11,7 +11,6 @@
shared_libs: [
"android.hardware.evs@1.0",
- "android.hardware.graphics.allocator@2.0",
"libui",
"libbase",
"libbinder",
diff --git a/evs/1.0/default/EvsCamera.cpp b/evs/1.0/default/EvsCamera.cpp
index 6715a2e..c62f7b6 100644
--- a/evs/1.0/default/EvsCamera.cpp
+++ b/evs/1.0/default/EvsCamera.cpp
@@ -33,18 +33,22 @@
const char EvsCamera::kCameraName_Backup[] = "backup";
const char EvsCamera::kCameraName_RightTurn[] = "Right Turn";
+// Arbitrary limit on number of graphics buffers allowed to be allocated
+// Safeguards against unreasonable resource consumption and provides a testable limit
+const unsigned MAX_BUFFERS_IN_FLIGHT = 100;
+
// TODO(b/31632518): Need to get notification when our client dies so we can close the camera.
-// As it stands, if the client dies suddently, the buffer may be stranded.
-// As possible work around would be to give the client a HIDL object to exclusively hold
-// and use it's destructor to perform some work in the server side.
+// As it stands, if the client dies suddenly, the buffer may be stranded.
-EvsCamera::EvsCamera(const char *id) {
+EvsCamera::EvsCamera(const char *id) :
+ mFramesAllowed(0),
+ mFramesInUse(0),
+ mStreamState(STOPPED) {
+
ALOGD("EvsCamera instantiated");
mDescription.cameraId = id;
- mFrameBusy = false;
- mStreamState = STOPPED;
// Set up dummy data for testing
if (mDescription.cameraId == kCameraName_Backup) {
@@ -52,16 +56,23 @@
mDescription.vendorFlags = 0xFFFFFFFF; // Arbitrary value
mDescription.defaultHorResolution = 320; // 1/2 NTSC/VGA
mDescription.defaultVerResolution = 240; // 1/2 NTSC/VGA
- }
- else if (mDescription.cameraId == kCameraName_RightTurn) {
+ } else if (mDescription.cameraId == kCameraName_RightTurn) {
// Nothing but the name and the usage hint
mDescription.hints = static_cast<uint32_t>(UsageHint::USAGE_HINT_RIGHT_TURN);
- }
- else {
+ } else {
// Leave empty for a minimalist camera description without even a hint
}
+
+
+ // Set our buffer properties
+ mWidth = (mDescription.defaultHorResolution) ? mDescription.defaultHorResolution : 640;
+ mHeight = (mDescription.defaultVerResolution) ? mDescription.defaultVerResolution : 480;
+
+ mFormat = HAL_PIXEL_FORMAT_RGBA_8888;
+ mUsage = GRALLOC_USAGE_HW_TEXTURE | GRALLOC_USAGE_HW_CAMERA_WRITE;
}
+
EvsCamera::~EvsCamera() {
ALOGD("EvsCamera being destroyed");
std::lock_guard<std::mutex> lock(mAccessLock);
@@ -70,11 +81,14 @@
// (It really should be already)
stopVideoStream();
- // Drop the graphics buffer we've been using
- if (mBuffer) {
- // Drop the graphics buffer we've been using
- GraphicBufferAllocator& alloc(GraphicBufferAllocator::get());
- alloc.free(mBuffer);
+ // Drop all the graphics buffers we've been using
+ GraphicBufferAllocator& alloc(GraphicBufferAllocator::get());
+ for (auto&& rec : mBuffers) {
+ if (rec.inUse) {
+ ALOGE("Error - releasing buffer despite remote ownership");
+ }
+ alloc.free(rec.handle);
+ rec.handle = nullptr;
}
ALOGD("EvsCamera destroyed");
@@ -95,113 +109,109 @@
ALOGD("setMaxFramesInFlight");
std::lock_guard<std::mutex> lock(mAccessLock);
- // TODO: Update our stored value
-
- // TODO: Adjust our buffer count right now if we can. Otherwise, it'll adjust in doneWithFrame
-
- // For now we support only one!
- if (bufferCount != 1) {
- return EvsResult::BUFFER_NOT_AVAILABLE;
+ // We cannot function without at least one video buffer to send data
+ if (bufferCount < 1) {
+ ALOGE("Ignoring setMaxFramesInFlight with less than one buffer requested");
+ return EvsResult::INVALID_ARG;
}
- return EvsResult::OK;
+ // Update our internal state
+ if (setAvailableFrames_Locked(bufferCount)) {
+ return EvsResult::OK;
+ } else {
+ return EvsResult::BUFFER_NOT_AVAILABLE;
+ }
}
+
Return<EvsResult> EvsCamera::startVideoStream(const ::android::sp<IEvsCameraStream>& stream) {
ALOGD("startVideoStream");
std::lock_guard<std::mutex> lock(mAccessLock);
- // We only support a single stream at a time
if (mStreamState != STOPPED) {
ALOGE("ignoring startVideoStream call when a stream is already running.");
return EvsResult::STREAM_ALREADY_RUNNING;
}
+ // If the client never indicated otherwise, configure ourselves for a single streaming buffer
+ if (mFramesAllowed < 1) {
+ if (!setAvailableFrames_Locked(1)) {
+ ALOGE("Failed to start stream because we couldn't get a graphics buffer");
+ return EvsResult::BUFFER_NOT_AVAILABLE;
+ }
+ }
+
// Record the user's callback for use when we have a frame ready
mStream = stream;
- // Allocate a graphics buffer into which we'll put our test images
- if (!mBuffer) {
- mWidth = (mDescription.defaultHorResolution) ? mDescription.defaultHorResolution : 640;
- mHeight = (mDescription.defaultVerResolution) ? mDescription.defaultVerResolution : 480;
- // TODO: What about stride? Assume no padding for now...
- mStride = 4* mWidth; // Special cased to assume 4 byte pixels with no padding for now
-
- ALOGD("Allocating buffer for camera frame");
- GraphicBufferAllocator &alloc(GraphicBufferAllocator::get());
- status_t result = alloc.allocate(mWidth, mHeight,
- HAL_PIXEL_FORMAT_RGBA_8888, 1, GRALLOC_USAGE_HW_TEXTURE,
- &mBuffer, &mStride, 0, "EvsCamera");
- if (result != NO_ERROR) {
- ALOGE("Error %d allocating %d x %d graphics buffer", result, mWidth, mHeight);
- return EvsResult::BUFFER_NOT_AVAILABLE;
- }
- if (!mBuffer) {
- ALOGE("We didn't get a buffer handle back from the allocator");
- return EvsResult::BUFFER_NOT_AVAILABLE;
- }
- }
-
// Start the frame generation thread
mStreamState = RUNNING;
- mCaptureThread = std::thread([this](){GenerateFrames();});
+ mCaptureThread = std::thread([this](){ generateFrames(); });
return EvsResult::OK;
}
-Return<EvsResult> EvsCamera::doneWithFrame(uint32_t /* frameId */, const hidl_handle& bufferHandle) {
+
+Return<void> EvsCamera::doneWithFrame(const BufferDesc& buffer) {
ALOGD("doneWithFrame");
- std::lock_guard<std::mutex> lock(mAccessLock);
-
- if (!bufferHandle)
- {
- ALOGE("ignoring doneWithFrame called with invalid handle");
- return EvsResult::INVALID_ARG;
- }
-
- // TODO: Track which frames we've delivered and validate this is one of them
-
- // Mark the frame buffer as available for a new frame
- mFrameBusy = false;
-
- // TODO: If we currently have too many buffers, drop this one
-
- return EvsResult::OK;
-}
-
-Return<void> EvsCamera::stopVideoStream() {
- ALOGD("stopVideoStream");
-
- bool waitForJoin = false;
- // Lock scope
- {
+ { // lock context
std::lock_guard <std::mutex> lock(mAccessLock);
- if (mStreamState == RUNNING) {
- // Tell the GenerateFrames loop we want it to stop
- mStreamState = STOPPING;
+ if (buffer.memHandle == nullptr) {
+ ALOGE("ignoring doneWithFrame called with null handle");
+ } else if (buffer.bufferId >= mBuffers.size()) {
+ ALOGE("ignoring doneWithFrame called with invalid bufferId %d (max is %lu)",
+ buffer.bufferId, mBuffers.size()-1);
+ } else if (!mBuffers[buffer.bufferId].inUse) {
+ ALOGE("ignoring doneWithFrame called on frame %d which is already free",
+ buffer.bufferId);
+ } else {
+ // Mark the frame as available
+ mBuffers[buffer.bufferId].inUse = false;
+ mFramesInUse--;
- // Note that we asked the thread to stop and should wait for it do so
- waitForJoin = true;
- }
- }
-
- if (waitForJoin) {
- // Block outside the mutex until the "stop" flag has been acknowledged
- // NOTE: We won't send any more frames, but the client might still get one already in flight
- ALOGD("Waiting for stream thread to end...");
- mCaptureThread.join();
-
- // Lock scope
- {
- std::lock_guard <std::mutex> lock(mAccessLock);
- mStreamState = STOPPED;
+ // If this frame's index is high in the array, try to move it down
+ // to improve locality after mFramesAllowed has been reduced.
+ if (buffer.bufferId >= mFramesAllowed) {
+ // Find an empty slot lower in the array (which should always exist in this case)
+ for (auto&& rec : mBuffers) {
+ if (rec.handle == nullptr) {
+ rec.handle = mBuffers[buffer.bufferId].handle;
+ mBuffers[buffer.bufferId].handle = nullptr;
+ break;
+ }
+ }
+ }
}
}
return Void();
}
+
+Return<void> EvsCamera::stopVideoStream() {
+ ALOGD("stopVideoStream");
+ std::unique_lock <std::mutex> lock(mAccessLock);
+
+ if (mStreamState == RUNNING) {
+ // Tell the GenerateFrames loop we want it to stop
+ mStreamState = STOPPING;
+
+ // Block outside the mutex until the "stop" flag has been acknowledged
+ // We won't send any more frames, but the client might still get some already in flight
+ ALOGD("Waiting for stream thread to end...");
+ lock.unlock();
+ mCaptureThread.join();
+ lock.lock();
+
+ mStreamState = STOPPED;
+ ALOGD("Stream marked STOPPED.");
+ }
+
+ return Void();
+}
+
+
Return<int32_t> EvsCamera::getExtendedInfo(uint32_t opaqueIdentifier) {
ALOGD("getExtendedInfo");
std::lock_guard<std::mutex> lock(mAccessLock);
@@ -215,6 +225,7 @@
return 0;
}
+
Return<EvsResult> EvsCamera::setExtendedInfo(uint32_t /*opaqueIdentifier*/, int32_t /*opaqueValue*/) {
ALOGD("setExtendedInfo");
std::lock_guard<std::mutex> lock(mAccessLock);
@@ -224,10 +235,124 @@
}
-void EvsCamera::GenerateFrames() {
- ALOGD("Frame generate loop started");
+bool EvsCamera::setAvailableFrames_Locked(unsigned bufferCount) {
+ if (bufferCount < 1) {
+ ALOGE("Ignoring request to set buffer count to zero");
+ return false;
+ }
+ if (bufferCount > MAX_BUFFERS_IN_FLIGHT) {
+ ALOGE("Rejecting buffer request in excess of internal limit");
+ return false;
+ }
- uint32_t frameNumber;
+ // Is an increase required?
+ if (mFramesAllowed < bufferCount) {
+ // An increase is required
+ unsigned needed = bufferCount - mFramesAllowed;
+ ALOGI("Allocating %d buffers for camera frames", needed);
+
+ unsigned added = increaseAvailableFrames_Locked(needed);
+ if (added != needed) {
+ // If we didn't add all the frames we needed, then roll back to the previous state
+ ALOGE("Rolling back to previous frame queue size");
+ decreaseAvailableFrames_Locked(added);
+ return false;
+ }
+ } else if (mFramesAllowed > bufferCount) {
+ // A decrease is required
+ unsigned framesToRelease = mFramesAllowed - bufferCount;
+ ALOGI("Returning %d camera frame buffers", framesToRelease);
+
+ unsigned released = decreaseAvailableFrames_Locked(framesToRelease);
+ if (released != framesToRelease) {
+ // This shouldn't happen with a properly behaving client because the client
+ // should only make this call after returning sufficient outstanding buffers
+ // to allow a clean resize.
+ ALOGE("Buffer queue shrink failed -- too many buffers currently in use?");
+ }
+ }
+
+ return true;
+}
+
+
+unsigned EvsCamera::increaseAvailableFrames_Locked(unsigned numToAdd) {
+ // Acquire the graphics buffer allocator
+ GraphicBufferAllocator &alloc(GraphicBufferAllocator::get());
+
+ unsigned added = 0;
+
+ while (added < numToAdd) {
+ buffer_handle_t memHandle = nullptr;
+ status_t result = alloc.allocate(mWidth, mHeight,
+ mFormat, 1,
+ mUsage,
+ &memHandle, &mStride, 0, "EvsCamera");
+ if (result != NO_ERROR) {
+ ALOGE("Error %d allocating %d x %d graphics buffer", result, mWidth, mHeight);
+ break;
+ }
+ if (!memHandle) {
+ ALOGE("We didn't get a buffer handle back from the allocator");
+ break;
+ }
+
+ // Find a place to store the new buffer
+ bool stored = false;
+ for (auto&& rec : mBuffers) {
+ if (rec.handle == nullptr) {
+ // Use this existing entry
+ rec.handle = memHandle;
+ rec.inUse = false;
+ stored = true;
+ break;
+ }
+ }
+ if (!stored) {
+ // Add a BufferRecord wrapping this handle to our set of available buffers
+ mBuffers.emplace_back(memHandle);
+ }
+
+ mFramesAllowed++;
+ added++;
+ }
+
+ return added;
+}
+
+
+unsigned EvsCamera::decreaseAvailableFrames_Locked(unsigned numToRemove) {
+ // Acquire the graphics buffer allocator
+ GraphicBufferAllocator &alloc(GraphicBufferAllocator::get());
+
+ unsigned removed = 0;
+
+ for (auto&& rec : mBuffers) {
+ // Is this record not in use, but holding a buffer that we can free?
+ if ((rec.inUse == false) && (rec.handle != nullptr)) {
+ // Release buffer and update the record so we can recognize it as "empty"
+ alloc.free(rec.handle);
+ rec.handle = nullptr;
+
+ mFramesAllowed--;
+ removed++;
+
+ if (removed == numToRemove) {
+ break;
+ }
+ }
+ }
+
+ return removed;
+}
+
+
+// This is the asynchronous frame generation thread that runs in parallel with the
+// main serving thread. There is one for each active camera instance.
+void EvsCamera::generateFrames() {
+ ALOGD("Frame generation loop started");
+
+ unsigned idx;
while (true) {
bool timeForFrame = false;
@@ -235,57 +360,69 @@
{
std::lock_guard<std::mutex> lock(mAccessLock);
- // Tick the frame counter -- rollover is tolerated
- frameNumber = mFrameId++;
-
if (mStreamState != RUNNING) {
// Break out of our main thread loop
break;
}
- if (mFrameBusy) {
+ // Are we allowed to issue another buffer?
+ if (mFramesInUse >= mFramesAllowed) {
// Can't do anything right now -- skip this frame
- ALOGW("Skipped a frame because client hasn't returned a buffer\n");
- }
- else {
- // We're going to make the frame busy
- mFrameBusy = true;
- timeForFrame = true;
+ ALOGW("Skipped a frame because too many are in flight\n");
+ } else {
+ // Identify an available buffer to fill
+ for (idx = 0; idx < mBuffers.size(); idx++) {
+ if (!mBuffers[idx].inUse) {
+ if (mBuffers[idx].handle != nullptr) {
+ // Found an available record, so stop looking
+ break;
+ }
+ }
+ }
+ if (idx >= mBuffers.size()) {
+ // This shouldn't happen since we already checked mFramesInUse vs mFramesAllowed
+ ALOGE("Failed to find an available buffer slot\n");
+ } else {
+ // We're going to make the frame busy
+ mBuffers[idx].inUse = true;
+ mFramesInUse++;
+ timeForFrame = true;
+ }
}
}
if (timeForFrame) {
- // Lock our output buffer for writing
- uint32_t *pixels = nullptr;
- GraphicBufferMapper &mapper = GraphicBufferMapper::get();
- mapper.lock(mBuffer,
- GRALLOC_USAGE_SW_WRITE_OFTEN,
- android::Rect(mWidth, mHeight),
- (void **) &pixels);
+ // Assemble the buffer description we'll transmit below
+ BufferDesc buff = {};
+ buff.width = mWidth;
+ buff.height = mHeight;
+ buff.stride = mStride;
+ buff.format = mFormat;
+ buff.usage = mUsage;
+ buff.bufferId = idx;
+ buff.memHandle = mBuffers[idx].handle;
- // If we failed to lock the pixel buffer, we're about to crash, but log it first
- if (!pixels) {
- ALOGE("Camera failed to gain access to image buffer for writing");
+ // Write test data into the image buffer
+ fillTestFrame(buff);
+
+ // Issue the (asynchronous) callback to the client -- can't be holding the lock
+ auto result = mStream->deliverFrame(buff);
+ if (result.isOk()) {
+ ALOGD("Delivered %p as id %d", buff.memHandle.getNativeHandle(), buff.bufferId);
+ } else {
+ // This can happen if the client dies and is likely unrecoverable.
+ // To avoid consuming resources generating failing calls, we stop sending
+ // frames. Note, however, that the stream remains in the "STREAMING" state
+ // until cleaned up on the main thread.
+ ALOGE("Frame delivery call failed in the transport layer.");
+
+ // Since we didn't actually deliver it, mark the frame as available
+ std::lock_guard<std::mutex> lock(mAccessLock);
+ mBuffers[idx].inUse = false;
+ mFramesInUse--;
+
+ break;
}
-
- // Fill in the test pixels
- for (unsigned row = 0; row < mHeight; row++) {
- for (unsigned col = 0; col < mWidth; col++) {
- // Index into the row to set the pixel at this column
- // (We're making vertical gradient in the green channel, and
- // horitzontal gradient in the blue channel)
- pixels[col] = 0xFF0000FF | ((row & 0xFF) << 16) | ((col & 0xFF) << 8);
- }
- // Point to the next row
- pixels = pixels + (mStride / sizeof(*pixels));
- }
-
- // Release our output buffer
- mapper.unlock(mBuffer);
-
- // Issue the (asynchronous) callback to the client
- mStream->deliverFrame(frameNumber, mBuffer);
- ALOGD("Delivered %p as frame %d", mBuffer, frameNumber);
}
// We arbitrarily choose to generate frames at 10 fps (1/10 * uSecPerSec)
@@ -293,11 +430,58 @@
}
// If we've been asked to stop, send one last NULL frame to signal the actual end of stream
- mStream->deliverFrame(frameNumber, nullptr);
+ BufferDesc nullBuff = {};
+ auto result = mStream->deliverFrame(nullBuff);
+ if (!result.isOk()) {
+ ALOGE("Error delivering end of stream marker");
+ }
return;
}
+
+void EvsCamera::fillTestFrame(BufferDesc buff) {
+ // Lock our output buffer for writing
+ uint32_t *pixels = nullptr;
+ GraphicBufferMapper &mapper = GraphicBufferMapper::get();
+ mapper.lock(buff.memHandle,
+ GRALLOC_USAGE_SW_WRITE_OFTEN | GRALLOC_USAGE_SW_READ_NEVER,
+ android::Rect(buff.width, buff.height),
+ (void **) &pixels);
+
+ // If we failed to lock the pixel buffer, we're about to crash, but log it first
+ if (!pixels) {
+ ALOGE("Camera failed to gain access to image buffer for writing");
+ }
+
+ // Fill in the test pixels
+ for (unsigned row = 0; row < buff.height; row++) {
+ for (unsigned col = 0; col < buff.width; col++) {
+ // Index into the row to check the pixel at this column.
+ // We expect 0xFF in the LSB channel, a vertical gradient in the
+ // second channel, a horitzontal gradient in the third channel, and
+ // 0xFF in the MSB.
+ // The exception is the very first 32 bits which is used for the
+ // time varying frame signature to avoid getting fooled by a static image.
+ uint32_t expectedPixel = 0xFF0000FF | // MSB and LSB
+ ((row & 0xFF) << 8) | // vertical gradient
+ ((col & 0xFF) << 16); // horizontal gradient
+ if ((row | col) == 0) {
+ static uint32_t sFrameTicker = 0;
+ expectedPixel = (sFrameTicker) & 0xFF;
+ sFrameTicker++;
+ }
+ pixels[col] = expectedPixel;
+ }
+ // Point to the next row
+ pixels = pixels + (buff.stride / sizeof(*pixels));
+ }
+
+ // Release our output buffer
+ mapper.unlock(buff.memHandle);
+}
+
+
} // namespace implementation
} // namespace V1_0
} // namespace evs
diff --git a/evs/1.0/default/EvsCamera.h b/evs/1.0/default/EvsCamera.h
index 5d29125..8d644a0 100644
--- a/evs/1.0/default/EvsCamera.h
+++ b/evs/1.0/default/EvsCamera.h
@@ -23,19 +23,21 @@
#include <thread>
+
namespace android {
namespace hardware {
namespace evs {
namespace V1_0 {
namespace implementation {
+
class EvsCamera : public IEvsCamera {
public:
// Methods from ::android::hardware::evs::V1_0::IEvsCamera follow.
Return<void> getId(getId_cb id_cb) override;
Return<EvsResult> setMaxFramesInFlight(uint32_t bufferCount) override;
Return<EvsResult> startVideoStream(const ::android::sp<IEvsCameraStream>& stream) override;
- Return<EvsResult> doneWithFrame(uint32_t frameId, const hidl_handle& bufferHandle) override;
+ Return<void> doneWithFrame(const BufferDesc& buffer) override;
Return<void> stopVideoStream() override;
Return<int32_t> getExtendedInfo(uint32_t opaqueIdentifier) override;
Return<EvsResult> setExtendedInfo(uint32_t opaqueIdentifier, int32_t opaqueValue) override;
@@ -45,34 +47,49 @@
virtual ~EvsCamera() override;
const CameraDesc& getDesc() { return mDescription; };
- void GenerateFrames();
static const char kCameraName_Backup[];
static const char kCameraName_RightTurn[];
private:
- CameraDesc mDescription = {}; // The properties of this camera
+ // These three functions are expected to be called while mAccessLock is held
+ bool setAvailableFrames_Locked(unsigned bufferCount);
+ unsigned increaseAvailableFrames_Locked(unsigned numToAdd);
+ unsigned decreaseAvailableFrames_Locked(unsigned numToRemove);
- buffer_handle_t mBuffer = nullptr; // A graphics buffer into which we'll store images
- uint32_t mWidth = 0; // number of pixels across the buffer
- uint32_t mHeight = 0; // number of pixels vertically in the buffer
- uint32_t mStride = 0; // Bytes per line in the buffer
+ void generateFrames();
+ void fillTestFrame(BufferDesc buff);
- sp<IEvsCameraStream> mStream = nullptr; // The callback the user expects when a frame is ready
+ CameraDesc mDescription = {}; // The properties of this camera
- std::thread mCaptureThread; // The thread we'll use to synthesize frames
+ std::thread mCaptureThread; // The thread we'll use to synthesize frames
- uint32_t mFrameId; // A frame counter used to identify specific frames
+ uint32_t mWidth = 0; // Horizontal pixel count in the buffers
+ uint32_t mHeight = 0; // Vertical pixel count in the buffers
+ uint32_t mFormat = 0; // Values from android_pixel_format_t [TODO: YUV? Leave opaque?]
+ uint32_t mUsage = 0; // Values from from Gralloc.h
+ uint32_t mStride = 0; // Bytes per line in the buffers
+
+ sp<IEvsCameraStream> mStream = nullptr; // The callback used to deliver each frame
+
+ struct BufferRecord {
+ buffer_handle_t handle;
+ bool inUse;
+ explicit BufferRecord(buffer_handle_t h) : handle(h), inUse(false) {};
+ };
+ std::vector<BufferRecord> mBuffers; // Graphics buffers to transfer images
+ unsigned mFramesAllowed; // How many buffers are we currently using
+ unsigned mFramesInUse; // How many buffers are currently outstanding
enum StreamStateValues {
STOPPED,
RUNNING,
STOPPING,
};
- StreamStateValues mStreamState;
- bool mFrameBusy; // A flag telling us our one buffer is in use
+ StreamStateValues mStreamState;
- std::mutex mAccessLock;
+ // Syncrhonization necessary to deconflict mCaptureThread from the main service thread
+ std::mutex mAccessLock;
};
} // namespace implementation
diff --git a/evs/1.0/default/EvsDisplay.cpp b/evs/1.0/default/EvsDisplay.cpp
index 9dba6fc..dff4c49 100644
--- a/evs/1.0/default/EvsDisplay.cpp
+++ b/evs/1.0/default/EvsDisplay.cpp
@@ -39,6 +39,7 @@
ALOGD("EvsDisplay instantiated");
// Set up our self description
+ // NOTE: These are arbitrary values chosen for testing
mInfo.displayId = "Mock Display";
mInfo.vendorFlags = 3870;
mInfo.defaultHorResolution = 320;
@@ -50,16 +51,17 @@
ALOGD("EvsDisplay being destroyed");
std::lock_guard<std::mutex> lock(mAccessLock);
- // Report if we're going away while a buffer is outstanding. This could be bad.
+ // Report if we're going away while a buffer is outstanding
if (mFrameBusy) {
- ALOGE("EvsDisplay going down while client is holding a buffer\n");
+ ALOGE("EvsDisplay going down while client is holding a buffer");
}
// Make sure we release our frame buffer
- if (mBuffer) {
+ if (mBuffer.memHandle) {
// Drop the graphics buffer we've been using
GraphicBufferAllocator& alloc(GraphicBufferAllocator::get());
- alloc.free(mBuffer);
+ alloc.free(mBuffer.memHandle);
+ mBuffer.memHandle = nullptr;
}
ALOGD("EvsDisplay destroyed");
}
@@ -135,36 +137,60 @@
std::lock_guard<std::mutex> lock(mAccessLock);
// If we don't already have a buffer, allocate one now
- if (!mBuffer) {
+ if (!mBuffer.memHandle) {
+ // Assemble the buffer description we'll use for our render target
+ mBuffer.width = mInfo.defaultHorResolution;
+ mBuffer.height = mInfo.defaultVerResolution;
+ mBuffer.format = HAL_PIXEL_FORMAT_RGBA_8888;
+ mBuffer.usage = GRALLOC_USAGE_HW_RENDER | GRALLOC_USAGE_HW_COMPOSER;
+ mBuffer.bufferId = 0x3870; // Arbitrary magic number for self recognition
+
+ buffer_handle_t handle = nullptr;
GraphicBufferAllocator& alloc(GraphicBufferAllocator::get());
- status_t result = alloc.allocate(mInfo.defaultHorResolution, mInfo.defaultVerResolution,
- HAL_PIXEL_FORMAT_RGBA_8888, 1,
- GRALLOC_USAGE_HW_FB | GRALLOC_USAGE_HW_COMPOSER,
- &mBuffer, &mStride, 0, "EvsDisplay");
+ status_t result = alloc.allocate(mBuffer.width, mBuffer.height,
+ mBuffer.format, 1, mBuffer.usage,
+ &handle, &mBuffer.stride,
+ 0, "EvsDisplay");
+ if (result != NO_ERROR) {
+ ALOGE("Error %d allocating %d x %d graphics buffer",
+ result, mBuffer.width, mBuffer.height);
+ BufferDesc nullBuff = {};
+ _hidl_cb(nullBuff);
+ return Void();
+ }
+ if (!handle) {
+ ALOGE("We didn't get a buffer handle back from the allocator");
+ BufferDesc nullBuff = {};
+ _hidl_cb(nullBuff);
+ return Void();
+ }
+
+ mBuffer.memHandle = handle;
mFrameBusy = false;
- ALOGD("Allocated new buffer %p with stride %u", mBuffer, mStride);
+ ALOGD("Allocated new buffer %p with stride %u",
+ mBuffer.memHandle.getNativeHandle(), mStride);
}
// Do we have a frame available?
if (mFrameBusy) {
// This means either we have a 2nd client trying to compete for buffers
// (an unsupported mode of operation) or else the client hasn't returned
- // a previously issues buffer yet (they're behaving badly).
- // NOTE: We have to make callback even if we have nothing to provide
+ // a previously issued buffer yet (they're behaving badly).
+ // NOTE: We have to make the callback even if we have nothing to provide
ALOGE("getTargetBuffer called while no buffers available.");
- _hidl_cb(nullptr);
- }
- else {
+ BufferDesc nullBuff = {};
+ _hidl_cb(nullBuff);
+ return Void();
+ } else {
// Mark our buffer as busy
mFrameBusy = true;
// Send the buffer to the client
- ALOGD("Providing display buffer %p", mBuffer);
+ ALOGD("Providing display buffer handle %p as id %d",
+ mBuffer.memHandle.getNativeHandle(), mBuffer.bufferId);
_hidl_cb(mBuffer);
+ return Void();
}
-
- // All done
- return Void();
}
@@ -172,22 +198,19 @@
* This call tells the display that the buffer is ready for display.
* The buffer is no longer valid for use by the client after this call.
*/
-Return<EvsResult> EvsDisplay::returnTargetBufferForDisplay(const hidl_handle& bufferHandle) {
- ALOGD("returnTargetBufferForDisplay %p", bufferHandle.getNativeHandle());
+Return<EvsResult> EvsDisplay::returnTargetBufferForDisplay(const BufferDesc& buffer) {
+ ALOGD("returnTargetBufferForDisplay %p", buffer.memHandle.getNativeHandle());
std::lock_guard<std::mutex> lock(mAccessLock);
- // This shouldn't happen if we haven't issued the buffer!
- if (!bufferHandle) {
+ // Nobody should call us with a null handle
+ if (!buffer.memHandle.getNativeHandle()) {
ALOGE ("returnTargetBufferForDisplay called without a valid buffer handle.\n");
return EvsResult::INVALID_ARG;
}
- /* TODO(b/33492405): It would be nice to validate we got back the buffer we expect,
- * but HIDL doesn't support that (yet?)
- if (bufferHandle != mBuffer) {
+ if (buffer.bufferId != mBuffer.bufferId) {
ALOGE ("Got an unrecognized frame returned.\n");
return EvsResult::INVALID_ARG;
}
- */
if (!mFrameBusy) {
ALOGE ("A frame was returned with no outstanding frames.\n");
return EvsResult::BUFFER_NOT_AVAILABLE;
@@ -204,10 +227,71 @@
if (mRequestedState != DisplayState::VISIBLE) {
// We shouldn't get frames back when we're not visible.
ALOGE ("Got an unexpected frame returned while not visible - ignoring.\n");
- }
- else {
- // Make this buffer visible
- // TODO: Add code to put this image on the screen (or validate it somehow?)
+ } else {
+ // This is where the buffer would be made visible.
+ // For now we simply validate it has the data we expect in it by reading it back
+
+ // Lock our display buffer for reading
+ uint32_t* pixels = nullptr;
+ GraphicBufferMapper &mapper = GraphicBufferMapper::get();
+ mapper.lock(mBuffer.memHandle,
+ GRALLOC_USAGE_SW_READ_OFTEN | GRALLOC_USAGE_SW_WRITE_NEVER,
+ android::Rect(mBuffer.width, mBuffer.height),
+ (void **)&pixels);
+
+ // If we failed to lock the pixel buffer, we're about to crash, but log it first
+ if (!pixels) {
+ ALOGE("Camera failed to gain access to image buffer for reading");
+ }
+
+ // Check the test pixels
+ bool frameLooksGood = true;
+ for (unsigned row = 0; row < mInfo.defaultVerResolution; row++) {
+ for (unsigned col = 0; col < mInfo.defaultHorResolution; col++) {
+ // Index into the row to check the pixel at this column.
+ // We expect 0xFF in the LSB channel, a vertical gradient in the
+ // second channel, a horitzontal gradient in the third channel, and
+ // 0xFF in the MSB.
+ // The exception is the very first 32 bits which is used for the
+ // time varying frame signature to avoid getting fooled by a static image.
+ uint32_t expectedPixel = 0xFF0000FF | // MSB and LSB
+ ((row & 0xFF) << 8) | // vertical gradient
+ ((col & 0xFF) << 16); // horizontal gradient
+ if ((row | col) == 0) {
+ // we'll check the "uniqueness" of the frame signature below
+ continue;
+ }
+ // Walk across this row (we'll step rows below)
+ if (pixels[col] != expectedPixel) {
+ ALOGE("Pixel check mismatch in frame buffer");
+ frameLooksGood = false;
+ break;
+ }
+ }
+
+ if (!frameLooksGood) {
+ break;
+ }
+
+ // Point to the next row
+ pixels = pixels + (mStride / sizeof(*pixels));
+ }
+
+ // Ensure we don't see the same buffer twice without it being rewritten
+ static uint32_t prevSignature = ~0;
+ uint32_t signature = pixels[0] & 0xFF;
+ if (prevSignature == signature) {
+ frameLooksGood = false;
+ ALOGE("Duplicate, likely stale frame buffer detected");
+ }
+
+
+ // Release our output buffer
+ mapper.unlock(mBuffer.memHandle);
+
+ if (!frameLooksGood) {
+ return EvsResult::UNDERLYING_SERVICE_ERROR;
+ }
}
return EvsResult::OK;
diff --git a/evs/1.0/default/EvsDisplay.h b/evs/1.0/default/EvsDisplay.h
index a2d5d3e..6e0111e 100644
--- a/evs/1.0/default/EvsDisplay.h
+++ b/evs/1.0/default/EvsDisplay.h
@@ -33,7 +33,7 @@
Return<EvsResult> setDisplayState(DisplayState state) override;
Return<DisplayState> getDisplayState() override;
Return<void> getTargetBuffer(getTargetBuffer_cb _hidl_cb) override;
- Return<EvsResult> returnTargetBufferForDisplay(const hidl_handle& bufferHandle) override;
+ Return<EvsResult> returnTargetBufferForDisplay(const BufferDesc& buffer) override;
// Implementation details
EvsDisplay();
@@ -41,10 +41,10 @@
private:
DisplayDesc mInfo = {};
- buffer_handle_t mBuffer = nullptr; // A graphics buffer into which we'll store images
- uint32_t mStride = 0; // Bytes per line in the buffer
+ BufferDesc mBuffer = {}; // A graphics buffer into which we'll store images
+ uint32_t mStride = 0; // Bytes per line in the buffer
- bool mFrameBusy = false; // A flag telling us our buffer is in use
+ bool mFrameBusy = false; // A flag telling us our buffer is in use
DisplayState mRequestedState = DisplayState::NOT_VISIBLE;
std::mutex mAccessLock;
diff --git a/evs/1.0/default/EvsEnumerator.cpp b/evs/1.0/default/EvsEnumerator.cpp
index ba8da00..4bf77f3 100644
--- a/evs/1.0/default/EvsEnumerator.cpp
+++ b/evs/1.0/default/EvsEnumerator.cpp
@@ -27,6 +27,11 @@
namespace implementation {
+// TODO(b/31632518): Need to get notification when our client dies so we can close the camera.
+// As it stands, if the client dies suddenly, the camera will be stuck "open".
+// NOTE: Display should already be safe by virtue of holding only a weak pointer.
+
+
EvsEnumerator::EvsEnumerator() {
ALOGD("EvsEnumerator created");
@@ -78,15 +83,11 @@
if (!pRecord) {
ALOGE("Requested camera %s not found", cameraId.c_str());
return nullptr;
- }
- else if (pRecord->inUse) {
+ } else if (pRecord->inUse) {
ALOGE("Cannot open camera %s which is already in use", cameraId.c_str());
return nullptr;
- }
- else {
- /* TODO(b/33492405): Do this, When HIDL can give us back a recognizable pointer
+ } else {
pRecord->inUse = true;
- */
return(pRecord->pCamera);
}
}
@@ -96,14 +97,21 @@
if (camera == nullptr) {
ALOGE("Ignoring call to closeCamera with null camera pointer");
- }
- else {
- // Make sure the camera has stopped streaming
- camera->stopVideoStream();
+ } else {
+ // Find this camera in our list
+ auto it = std::find_if(mCameraList.begin(),
+ mCameraList.end(),
+ [camera](const CameraRecord& rec) {
+ return (rec.pCamera == camera);
+ });
+ if (it == mCameraList.end()) {
+ ALOGE("Ignoring close on unrecognized camera");
+ } else {
+ // Make sure the camera has stopped streaming
+ camera->stopVideoStream();
- /* TODO(b/33492405): Do this, When HIDL can give us back a recognizable pointer
- pRecord->inUse = false;
- */
+ it->inUse = false;
+ }
}
return Void();
@@ -113,41 +121,49 @@
ALOGD("openDisplay");
// If we already have a display active, then this request must be denied
- if (mActiveDisplay != nullptr) {
+ sp<IEvsDisplay> pActiveDisplay = mActiveDisplay.promote();
+ if (pActiveDisplay != nullptr) {
ALOGW("Rejecting openDisplay request the display is already in use.");
return nullptr;
- }
- else {
+ } else {
// Create a new display interface and return it
- mActiveDisplay = new EvsDisplay();
- ALOGD("Returning new EvsDisplay object %p", mActiveDisplay.get());
- return mActiveDisplay;
+ pActiveDisplay = new EvsDisplay();
+ mActiveDisplay = pActiveDisplay;
+ ALOGD("Returning new EvsDisplay object %p", pActiveDisplay.get());
+ return pActiveDisplay;
}
}
Return<void> EvsEnumerator::closeDisplay(const ::android::sp<IEvsDisplay>& display) {
ALOGD("closeDisplay");
- if (mActiveDisplay == nullptr) {
- ALOGE("Ignoring closeDisplay when display is not active");
- }
- else if (display == nullptr) {
- ALOGE("Ignoring closeDisplay with null display pointer");
- }
- else {
+ // Do we still have a display object we think should be active?
+ sp<IEvsDisplay> pActiveDisplay = mActiveDisplay.promote();
+
+ if (pActiveDisplay == nullptr) {
+ ALOGE("Ignoring closeDisplay when there is no active display.");
+ } else if (display != pActiveDisplay) {
+ ALOGE("Ignoring closeDisplay on a display we didn't issue");
+ ALOGI("Got %p while active display is %p.", display.get(), pActiveDisplay.get());
+ } else {
// Drop the active display
- // TODO(b/33492405): When HIDL provides recognizable pointers, add validation here.
mActiveDisplay = nullptr;
}
return Void();
}
+Return<DisplayState> EvsEnumerator::getDisplayState() {
+ ALOGD("getDisplayState");
-// TODO(b/31632518): Need to get notification when our client dies so we can close the camera.
-// As possible work around would be to give the client a HIDL object to exclusively hold
-// and use it's destructor to perform some work in the server side.
-
+ // Do we still have a display object we think should be active?
+ sp<IEvsDisplay> pActiveDisplay = mActiveDisplay.promote();
+ if (pActiveDisplay != nullptr) {
+ return pActiveDisplay->getDisplayState();
+ } else {
+ return DisplayState::NOT_OPEN;
+ }
+}
} // namespace implementation
} // namespace V1_0
diff --git a/evs/1.0/default/EvsEnumerator.h b/evs/1.0/default/EvsEnumerator.h
index 90df837..0e719bd 100644
--- a/evs/1.0/default/EvsEnumerator.h
+++ b/evs/1.0/default/EvsEnumerator.h
@@ -38,6 +38,7 @@
Return<void> closeCamera(const ::android::sp<IEvsCamera>& carCamera) override;
Return<sp<IEvsDisplay>> openDisplay() override;
Return<void> closeDisplay(const ::android::sp<IEvsDisplay>& display) override;
+ Return<DisplayState> getDisplayState() override;
// Implementation details
EvsEnumerator();
@@ -50,7 +51,7 @@
};
std::list<CameraRecord> mCameraList;
- sp<IEvsDisplay> mActiveDisplay;
+ wp<IEvsDisplay> mActiveDisplay; // Weak pointer -> object destructs if client dies
};
} // namespace implementation
diff --git a/evs/1.0/types.hal b/evs/1.0/types.hal
index fd9dcdc..6b580cf 100644
--- a/evs/1.0/types.hal
+++ b/evs/1.0/types.hal
@@ -72,6 +72,29 @@
/*
+ * Structure representing an image buffer through our APIs
+ *
+ * In addition to the handle to the graphics memory, we need to retain
+ * the properties of the buffer for easy reference and reconstruction of
+ * an ANativeWindowBuffer object on the remote side of API calls.
+ * (Not least because OpenGL expect an ANativeWindowBuffer* for us as a
+ * texture via eglCreateImageKHR().
+ * See also related types from android.hardware.graphics.common
+ * TODO: b/34722508 Review details of interaction of this structure with gralloc and OpenGL.
+ * Specifically consider if format and/or usage should become enumerated types.
+ */
+struct BufferDesc {
+ uint32_t width; // Units of pixels
+ uint32_t height; // Units of pixels
+ uint32_t stride; // Units of bytes
+ uint32_t format; // May contain values from android_pixel_format_t
+ uint32_t usage; // May contain values from from Gralloc.h
+ uint32_t bufferId; // Opaque value from driver
+ handle memHandle; // gralloc memory buffer handle
+};
+
+
+/*
* States for control of the EVS display
*
* The DisplayInfo structure describes the basic properties of an EVS display. Any EVS
@@ -81,7 +104,8 @@
* presentation device.
*/
enum DisplayState : uint32_t {
- NOT_VISIBLE = 0, // Display is inhibited
+ NOT_OPEN = 0, // Display has not been requested by any application
+ NOT_VISIBLE, // Display is inhibited
VISIBLE_ON_NEXT_FRAME, // Will become visible with next frame
VISIBLE, // Display is currently active
NUM_STATES // Must be last
@@ -94,4 +118,5 @@
INVALID_ARG,
STREAM_ALREADY_RUNNING,
BUFFER_NOT_AVAILABLE,
+ UNDERLYING_SERVICE_ERROR,
};
\ No newline at end of file
diff --git a/gatekeeper/1.0/vts/Android.mk b/gatekeeper/1.0/vts/Android.mk
new file mode 100644
index 0000000..58c2dca
--- /dev/null
+++ b/gatekeeper/1.0/vts/Android.mk
@@ -0,0 +1,19 @@
+#
+# Copyright (C) 2016 The Android Open Source Project
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+LOCAL_PATH := $(call my-dir)
+
+include $(LOCAL_PATH)/functional/vts/testcases/hal/gatekeeper/hidl/Android.mk
diff --git a/gatekeeper/1.0/vts/functional/gatekeeper_hidl_hal_test.cpp b/gatekeeper/1.0/vts/functional/gatekeeper_hidl_hal_test.cpp
index 09690f8..67b4482 100644
--- a/gatekeeper/1.0/vts/functional/gatekeeper_hidl_hal_test.cpp
+++ b/gatekeeper/1.0/vts/functional/gatekeeper_hidl_hal_test.cpp
@@ -187,7 +187,7 @@
GatekeeperHidlTest() : uid_(0) {}
virtual void SetUp() override {
GatekeeperResponse rsp;
- gatekeeper_ = IGatekeeper::getService("gatekeeper", false);
+ gatekeeper_ = IGatekeeper::getService("gatekeeper");
ASSERT_NE(nullptr, gatekeeper_.get());
doDeleteAllUsers(rsp);
}
diff --git a/gatekeeper/1.0/vts/functional/vts/testcases/hal/gatekeeper/hidl/Android.mk b/gatekeeper/1.0/vts/functional/vts/testcases/hal/gatekeeper/hidl/Android.mk
new file mode 100644
index 0000000..f9e3276
--- /dev/null
+++ b/gatekeeper/1.0/vts/functional/vts/testcases/hal/gatekeeper/hidl/Android.mk
@@ -0,0 +1,19 @@
+#
+# Copyright (C) 2016 The Android Open Source Project
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+LOCAL_PATH := $(call my-dir)
+
+include $(call all-subdir-makefiles)
diff --git a/graphics/composer/2.1/default/Android.bp b/graphics/composer/2.1/default/Android.bp
index 0d63c3c..a366fa2 100644
--- a/graphics/composer/2.1/default/Android.bp
+++ b/graphics/composer/2.1/default/Android.bp
@@ -1,7 +1,28 @@
+cc_library_static {
+ name: "libhwcomposer-client",
+ export_include_dirs: ["."],
+ srcs: ["ComposerClient.cpp"],
+ cppflags: ["-DBINDERIZED"],
+ shared_libs: [
+ "android.hardware.graphics.allocator@2.0",
+ "android.hardware.graphics.composer@2.1",
+ "libbase",
+ "libcutils",
+ "libfmq",
+ "libhardware",
+ "libhidlbase",
+ "libhidltransport",
+ "libhwbinder",
+ "liblog",
+ "libsync",
+ "libutils",
+ ],
+}
+
cc_library_shared {
name: "android.hardware.graphics.composer@2.1-impl",
relative_install_path: "hw",
- srcs: ["Hwc.cpp", "HwcClient.cpp"],
+ srcs: ["Hwc.cpp", "ComposerClient.cpp"],
shared_libs: [
"android.hardware.graphics.allocator@2.0",
"android.hardware.graphics.composer@2.1",
@@ -21,10 +42,13 @@
cc_binary {
name: "android.hardware.graphics.composer@2.1-service",
relative_install_path: "hw",
- srcs: ["service.cpp", "Hwc.cpp", "HwcClient.cpp"],
+ srcs: ["service.cpp", "Hwc.cpp"],
cppflags: ["-DBINDERIZED"],
init_rc: ["android.hardware.graphics.composer@2.1-service.rc"],
+ static_libs: [
+ "libhwcomposer-client",
+ ],
shared_libs: [
"android.hardware.graphics.allocator@2.0",
"android.hardware.graphics.composer@2.1",
diff --git a/graphics/composer/2.1/default/ComposerBase.h b/graphics/composer/2.1/default/ComposerBase.h
new file mode 100644
index 0000000..85b1a4d
--- /dev/null
+++ b/graphics/composer/2.1/default/ComposerBase.h
@@ -0,0 +1,130 @@
+/*
+ * Copyright 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_GRAPHICS_COMPOSER_V2_1_COMPOSER_BASE_H
+#define ANDROID_HARDWARE_GRAPHICS_COMPOSER_V2_1_COMPOSER_BASE_H
+
+#include <android/hardware/graphics/composer/2.1/IComposer.h>
+#include <hardware/hwcomposer2.h>
+
+namespace android {
+namespace hardware {
+namespace graphics {
+namespace composer {
+namespace V2_1 {
+namespace implementation {
+
+using android::hardware::graphics::common::V1_0::PixelFormat;
+using android::hardware::graphics::common::V1_0::Transform;
+using android::hardware::graphics::common::V1_0::Dataspace;
+using android::hardware::graphics::common::V1_0::ColorMode;
+using android::hardware::graphics::common::V1_0::ColorTransform;
+using android::hardware::graphics::common::V1_0::Hdr;
+
+class ComposerBase {
+public:
+ virtual ~ComposerBase() {};
+
+ virtual void removeClient() = 0;
+ virtual void enableCallback(bool enable) = 0;
+ virtual uint32_t getMaxVirtualDisplayCount() = 0;
+ virtual Error createVirtualDisplay(uint32_t width, uint32_t height,
+ PixelFormat* format, Display* outDisplay) = 0;
+ virtual Error destroyVirtualDisplay(Display display) = 0;
+ virtual Error createLayer(Display display, Layer* outLayer) = 0;
+ virtual Error destroyLayer(Display display, Layer layer) = 0;
+
+ virtual Error getActiveConfig(Display display, Config* outConfig) = 0;
+ virtual Error getClientTargetSupport(Display display,
+ uint32_t width, uint32_t height,
+ PixelFormat format, Dataspace dataspace) = 0;
+ virtual Error getColorModes(Display display,
+ hidl_vec<ColorMode>* outModes) = 0;
+ virtual Error getDisplayAttribute(Display display, Config config,
+ IComposerClient::Attribute attribute, int32_t* outValue) = 0;
+ virtual Error getDisplayConfigs(Display display,
+ hidl_vec<Config>* outConfigs) = 0;
+ virtual Error getDisplayName(Display display, hidl_string* outName) = 0;
+ virtual Error getDisplayType(Display display,
+ IComposerClient::DisplayType* outType) = 0;
+ virtual Error getDozeSupport(Display display, bool* outSupport) = 0;
+ virtual Error getHdrCapabilities(Display display, hidl_vec<Hdr>* outTypes,
+ float* outMaxLuminance, float* outMaxAverageLuminance,
+ float* outMinLuminance) = 0;
+
+ virtual Error setActiveConfig(Display display, Config config) = 0;
+ virtual Error setColorMode(Display display, ColorMode mode) = 0;
+ virtual Error setPowerMode(Display display,
+ IComposerClient::PowerMode mode) = 0;
+ virtual Error setVsyncEnabled(Display display,
+ IComposerClient::Vsync enabled) = 0;
+
+ virtual Error setColorTransform(Display display, const float* matrix,
+ int32_t hint) = 0;
+ virtual Error setClientTarget(Display display, buffer_handle_t target,
+ int32_t acquireFence, int32_t dataspace,
+ const std::vector<hwc_rect_t>& damage) = 0;
+ virtual Error setOutputBuffer(Display display, buffer_handle_t buffer,
+ int32_t releaseFence) = 0;
+ virtual Error validateDisplay(Display display,
+ std::vector<Layer>* outChangedLayers,
+ std::vector<IComposerClient::Composition>* outCompositionTypes,
+ uint32_t* outDisplayRequestMask,
+ std::vector<Layer>* outRequestedLayers,
+ std::vector<uint32_t>* outRequestMasks) = 0;
+ virtual Error acceptDisplayChanges(Display display) = 0;
+ virtual Error presentDisplay(Display display, int32_t* outPresentFence,
+ std::vector<Layer>* outLayers,
+ std::vector<int32_t>* outReleaseFences) = 0;
+
+ virtual Error setLayerCursorPosition(Display display, Layer layer,
+ int32_t x, int32_t y) = 0;
+ virtual Error setLayerBuffer(Display display, Layer layer,
+ buffer_handle_t buffer, int32_t acquireFence) = 0;
+ virtual Error setLayerSurfaceDamage(Display display, Layer layer,
+ const std::vector<hwc_rect_t>& damage) = 0;
+ virtual Error setLayerBlendMode(Display display, Layer layer,
+ int32_t mode) = 0;
+ virtual Error setLayerColor(Display display, Layer layer,
+ IComposerClient::Color color) = 0;
+ virtual Error setLayerCompositionType(Display display, Layer layer,
+ int32_t type) = 0;
+ virtual Error setLayerDataspace(Display display, Layer layer,
+ int32_t dataspace) = 0;
+ virtual Error setLayerDisplayFrame(Display display, Layer layer,
+ const hwc_rect_t& frame) = 0;
+ virtual Error setLayerPlaneAlpha(Display display, Layer layer,
+ float alpha) = 0;
+ virtual Error setLayerSidebandStream(Display display, Layer layer,
+ buffer_handle_t stream) = 0;
+ virtual Error setLayerSourceCrop(Display display, Layer layer,
+ const hwc_frect_t& crop) = 0;
+ virtual Error setLayerTransform(Display display, Layer layer,
+ int32_t transform) = 0;
+ virtual Error setLayerVisibleRegion(Display display, Layer layer,
+ const std::vector<hwc_rect_t>& visible) = 0;
+ virtual Error setLayerZOrder(Display display, Layer layer,
+ uint32_t z) = 0;
+};
+
+} // namespace implementation
+} // namespace V2_1
+} // namespace composer
+} // namespace graphics
+} // namespace hardware
+} // namespace android
+
+#endif // ANDROID_HARDWARE_GRAPHICS_COMPOSER_V2_1_COMPOSER_BASE_H
diff --git a/graphics/composer/2.1/default/HwcClient.cpp b/graphics/composer/2.1/default/ComposerClient.cpp
similarity index 76%
rename from graphics/composer/2.1/default/HwcClient.cpp
rename to graphics/composer/2.1/default/ComposerClient.cpp
index edd161a..49415ee 100644
--- a/graphics/composer/2.1/default/HwcClient.cpp
+++ b/graphics/composer/2.1/default/ComposerClient.cpp
@@ -20,8 +20,8 @@
#include <hardware/gralloc1.h>
#include <log/log.h>
+#include "ComposerClient.h"
#include "Hwc.h"
-#include "HwcClient.h"
#include "IComposerCommandBuffer.h"
namespace android {
@@ -230,15 +230,12 @@
}
}
-HwcClient::HwcClient(HwcHal& hal)
- : mHal(hal), mReader(*this), mWriter(kWriterInitialSize)
+ComposerClient::ComposerClient(ComposerBase& hal)
+ : mHal(hal), mWriter(kWriterInitialSize)
{
- if (!sHandleImporter.initialize()) {
- LOG_ALWAYS_FATAL("failed to initialize handle importer");
- }
}
-HwcClient::~HwcClient()
+ComposerClient::~ComposerClient()
{
mHal.enableCallback(false);
mHal.removeClient();
@@ -264,7 +261,15 @@
sHandleImporter.cleanup();
}
-void HwcClient::onHotplug(Display display,
+void ComposerClient::initialize()
+{
+ mReader = createCommandReader();
+ if (!sHandleImporter.initialize()) {
+ LOG_ALWAYS_FATAL("failed to initialize handle importer");
+ }
+}
+
+void ComposerClient::onHotplug(Display display,
IComposerCallback::Connection connected)
{
{
@@ -280,17 +285,18 @@
mCallback->onHotplug(display, connected);
}
-void HwcClient::onRefresh(Display display)
+void ComposerClient::onRefresh(Display display)
{
mCallback->onRefresh(display);
}
-void HwcClient::onVsync(Display display, int64_t timestamp)
+void ComposerClient::onVsync(Display display, int64_t timestamp)
{
mCallback->onVsync(display, timestamp);
}
-Return<void> HwcClient::registerCallback(const sp<IComposerCallback>& callback)
+Return<void> ComposerClient::registerCallback(
+ const sp<IComposerCallback>& callback)
{
// no locking as we require this function to be called only once
mCallback = callback;
@@ -299,13 +305,13 @@
return Void();
}
-Return<uint32_t> HwcClient::getMaxVirtualDisplayCount()
+Return<uint32_t> ComposerClient::getMaxVirtualDisplayCount()
{
return mHal.getMaxVirtualDisplayCount();
}
-Return<void> HwcClient::createVirtualDisplay(uint32_t width, uint32_t height,
- PixelFormat formatHint, uint32_t outputBufferSlotCount,
+Return<void> ComposerClient::createVirtualDisplay(uint32_t width,
+ uint32_t height, PixelFormat formatHint, uint32_t outputBufferSlotCount,
createVirtualDisplay_cb hidl_cb)
{
Display display = 0;
@@ -322,7 +328,7 @@
return Void();
}
-Return<Error> HwcClient::destroyVirtualDisplay(Display display)
+Return<Error> ComposerClient::destroyVirtualDisplay(Display display)
{
Error err = mHal.destroyVirtualDisplay(display);
if (err == Error::NONE) {
@@ -334,8 +340,8 @@
return err;
}
-Return<void> HwcClient::createLayer(Display display, uint32_t bufferSlotCount,
- createLayer_cb hidl_cb)
+Return<void> ComposerClient::createLayer(Display display,
+ uint32_t bufferSlotCount, createLayer_cb hidl_cb)
{
Layer layer = 0;
Error err = mHal.createLayer(display, &layer);
@@ -351,7 +357,7 @@
return Void();
}
-Return<Error> HwcClient::destroyLayer(Display display, Layer layer)
+Return<Error> ComposerClient::destroyLayer(Display display, Layer layer)
{
Error err = mHal.destroyLayer(display, layer);
if (err == Error::NONE) {
@@ -364,7 +370,7 @@
return err;
}
-Return<void> HwcClient::getActiveConfig(Display display,
+Return<void> ComposerClient::getActiveConfig(Display display,
getActiveConfig_cb hidl_cb)
{
Config config = 0;
@@ -374,7 +380,7 @@
return Void();
}
-Return<Error> HwcClient::getClientTargetSupport(Display display,
+Return<Error> ComposerClient::getClientTargetSupport(Display display,
uint32_t width, uint32_t height,
PixelFormat format, Dataspace dataspace)
{
@@ -383,7 +389,8 @@
return err;
}
-Return<void> HwcClient::getColorModes(Display display, getColorModes_cb hidl_cb)
+Return<void> ComposerClient::getColorModes(Display display,
+ getColorModes_cb hidl_cb)
{
hidl_vec<ColorMode> modes;
Error err = mHal.getColorModes(display, &modes);
@@ -392,7 +399,7 @@
return Void();
}
-Return<void> HwcClient::getDisplayAttribute(Display display,
+Return<void> ComposerClient::getDisplayAttribute(Display display,
Config config, Attribute attribute,
getDisplayAttribute_cb hidl_cb)
{
@@ -403,7 +410,7 @@
return Void();
}
-Return<void> HwcClient::getDisplayConfigs(Display display,
+Return<void> ComposerClient::getDisplayConfigs(Display display,
getDisplayConfigs_cb hidl_cb)
{
hidl_vec<Config> configs;
@@ -413,7 +420,7 @@
return Void();
}
-Return<void> HwcClient::getDisplayName(Display display,
+Return<void> ComposerClient::getDisplayName(Display display,
getDisplayName_cb hidl_cb)
{
hidl_string name;
@@ -423,7 +430,7 @@
return Void();
}
-Return<void> HwcClient::getDisplayType(Display display,
+Return<void> ComposerClient::getDisplayType(Display display,
getDisplayType_cb hidl_cb)
{
DisplayType type = DisplayType::INVALID;
@@ -433,7 +440,7 @@
return Void();
}
-Return<void> HwcClient::getDozeSupport(Display display,
+Return<void> ComposerClient::getDozeSupport(Display display,
getDozeSupport_cb hidl_cb)
{
bool support = false;
@@ -443,7 +450,7 @@
return Void();
}
-Return<void> HwcClient::getHdrCapabilities(Display display,
+Return<void> ComposerClient::getHdrCapabilities(Display display,
getHdrCapabilities_cb hidl_cb)
{
hidl_vec<Hdr> types;
@@ -457,7 +464,7 @@
return Void();
}
-Return<Error> HwcClient::setClientTargetSlotCount(Display display,
+Return<Error> ComposerClient::setClientTargetSlotCount(Display display,
uint32_t clientTargetSlotCount)
{
std::lock_guard<std::mutex> lock(mDisplayDataMutex);
@@ -472,39 +479,39 @@
return Error::NONE;
}
-Return<Error> HwcClient::setActiveConfig(Display display, Config config)
+Return<Error> ComposerClient::setActiveConfig(Display display, Config config)
{
Error err = mHal.setActiveConfig(display, config);
return err;
}
-Return<Error> HwcClient::setColorMode(Display display, ColorMode mode)
+Return<Error> ComposerClient::setColorMode(Display display, ColorMode mode)
{
Error err = mHal.setColorMode(display, mode);
return err;
}
-Return<Error> HwcClient::setPowerMode(Display display, PowerMode mode)
+Return<Error> ComposerClient::setPowerMode(Display display, PowerMode mode)
{
Error err = mHal.setPowerMode(display, mode);
return err;
}
-Return<Error> HwcClient::setVsyncEnabled(Display display, Vsync enabled)
+Return<Error> ComposerClient::setVsyncEnabled(Display display, Vsync enabled)
{
Error err = mHal.setVsyncEnabled(display, enabled);
return err;
}
-Return<Error> HwcClient::setInputCommandQueue(
+Return<Error> ComposerClient::setInputCommandQueue(
const MQDescriptorSync<uint32_t>& descriptor)
{
std::lock_guard<std::mutex> lock(mCommandMutex);
- return mReader.setMQDescriptor(descriptor) ?
+ return mReader->setMQDescriptor(descriptor) ?
Error::NONE : Error::NO_RESOURCES;
}
-Return<void> HwcClient::getOutputCommandQueue(
+Return<void> ComposerClient::getOutputCommandQueue(
getOutputCommandQueue_cb hidl_cb)
{
// no locking as we require this function to be called inside
@@ -520,7 +527,7 @@
return Void();
}
-Return<void> HwcClient::executeCommands(uint32_t inLength,
+Return<void> ComposerClient::executeCommands(uint32_t inLength,
const hidl_vec<hidl_handle>& inHandles,
executeCommands_cb hidl_cb)
{
@@ -530,12 +537,12 @@
uint32_t outLength = 0;
hidl_vec<hidl_handle> outHandles;
- if (!mReader.readQueue(inLength, inHandles)) {
+ if (!mReader->readQueue(inLength, inHandles)) {
hidl_cb(Error::BAD_PARAMETER, outChanged, outLength, outHandles);
return Void();
}
- Error err = mReader.parse();
+ Error err = mReader->parse();
if (err == Error::NONE &&
!mWriter.writeQueue(&outChanged, &outLength, &outHandles)) {
err = Error::NO_RESOURCES;
@@ -543,18 +550,29 @@
hidl_cb(err, outChanged, outLength, outHandles);
- mReader.reset();
+ mReader->reset();
mWriter.reset();
return Void();
}
-HwcClient::CommandReader::CommandReader(HwcClient& client)
+std::unique_ptr<ComposerClient::CommandReader>
+ComposerClient::createCommandReader()
+{
+ return std::unique_ptr<ComposerClient::CommandReader>(
+ new CommandReader(*this));
+}
+
+ComposerClient::CommandReader::CommandReader(ComposerClient& client)
: mClient(client), mHal(client.mHal), mWriter(client.mWriter)
{
}
-Error HwcClient::CommandReader::parse()
+ComposerClient::CommandReader::~CommandReader()
+{
+}
+
+Error ComposerClient::CommandReader::parse()
{
IComposerClient::Command command;
uint16_t length = 0;
@@ -564,79 +582,7 @@
break;
}
- bool parsed = false;
- switch (command) {
- case IComposerClient::Command::SELECT_DISPLAY:
- parsed = parseSelectDisplay(length);
- break;
- case IComposerClient::Command::SELECT_LAYER:
- parsed = parseSelectLayer(length);
- break;
- case IComposerClient::Command::SET_COLOR_TRANSFORM:
- parsed = parseSetColorTransform(length);
- break;
- case IComposerClient::Command::SET_CLIENT_TARGET:
- parsed = parseSetClientTarget(length);
- break;
- case IComposerClient::Command::SET_OUTPUT_BUFFER:
- parsed = parseSetOutputBuffer(length);
- break;
- case IComposerClient::Command::VALIDATE_DISPLAY:
- parsed = parseValidateDisplay(length);
- break;
- case IComposerClient::Command::ACCEPT_DISPLAY_CHANGES:
- parsed = parseAcceptDisplayChanges(length);
- break;
- case IComposerClient::Command::PRESENT_DISPLAY:
- parsed = parsePresentDisplay(length);
- break;
- case IComposerClient::Command::SET_LAYER_CURSOR_POSITION:
- parsed = parseSetLayerCursorPosition(length);
- break;
- case IComposerClient::Command::SET_LAYER_BUFFER:
- parsed = parseSetLayerBuffer(length);
- break;
- case IComposerClient::Command::SET_LAYER_SURFACE_DAMAGE:
- parsed = parseSetLayerSurfaceDamage(length);
- break;
- case IComposerClient::Command::SET_LAYER_BLEND_MODE:
- parsed = parseSetLayerBlendMode(length);
- break;
- case IComposerClient::Command::SET_LAYER_COLOR:
- parsed = parseSetLayerColor(length);
- break;
- case IComposerClient::Command::SET_LAYER_COMPOSITION_TYPE:
- parsed = parseSetLayerCompositionType(length);
- break;
- case IComposerClient::Command::SET_LAYER_DATASPACE:
- parsed = parseSetLayerDataspace(length);
- break;
- case IComposerClient::Command::SET_LAYER_DISPLAY_FRAME:
- parsed = parseSetLayerDisplayFrame(length);
- break;
- case IComposerClient::Command::SET_LAYER_PLANE_ALPHA:
- parsed = parseSetLayerPlaneAlpha(length);
- break;
- case IComposerClient::Command::SET_LAYER_SIDEBAND_STREAM:
- parsed = parseSetLayerSidebandStream(length);
- break;
- case IComposerClient::Command::SET_LAYER_SOURCE_CROP:
- parsed = parseSetLayerSourceCrop(length);
- break;
- case IComposerClient::Command::SET_LAYER_TRANSFORM:
- parsed = parseSetLayerTransform(length);
- break;
- case IComposerClient::Command::SET_LAYER_VISIBLE_REGION:
- parsed = parseSetLayerVisibleRegion(length);
- break;
- case IComposerClient::Command::SET_LAYER_Z_ORDER:
- parsed = parseSetLayerZOrder(length);
- break;
- default:
- parsed = false;
- break;
- }
-
+ bool parsed = parseCommand(command, length);
endCommand();
if (!parsed) {
@@ -649,7 +595,59 @@
return (isEmpty()) ? Error::NONE : Error::BAD_PARAMETER;
}
-bool HwcClient::CommandReader::parseSelectDisplay(uint16_t length)
+bool ComposerClient::CommandReader::parseCommand(
+ IComposerClient::Command command, uint16_t length) {
+ switch (command) {
+ case IComposerClient::Command::SELECT_DISPLAY:
+ return parseSelectDisplay(length);
+ case IComposerClient::Command::SELECT_LAYER:
+ return parseSelectLayer(length);
+ case IComposerClient::Command::SET_COLOR_TRANSFORM:
+ return parseSetColorTransform(length);
+ case IComposerClient::Command::SET_CLIENT_TARGET:
+ return parseSetClientTarget(length);
+ case IComposerClient::Command::SET_OUTPUT_BUFFER:
+ return parseSetOutputBuffer(length);
+ case IComposerClient::Command::VALIDATE_DISPLAY:
+ return parseValidateDisplay(length);
+ case IComposerClient::Command::ACCEPT_DISPLAY_CHANGES:
+ return parseAcceptDisplayChanges(length);
+ case IComposerClient::Command::PRESENT_DISPLAY:
+ return parsePresentDisplay(length);
+ case IComposerClient::Command::SET_LAYER_CURSOR_POSITION:
+ return parseSetLayerCursorPosition(length);
+ case IComposerClient::Command::SET_LAYER_BUFFER:
+ return parseSetLayerBuffer(length);
+ case IComposerClient::Command::SET_LAYER_SURFACE_DAMAGE:
+ return parseSetLayerSurfaceDamage(length);
+ case IComposerClient::Command::SET_LAYER_BLEND_MODE:
+ return parseSetLayerBlendMode(length);
+ case IComposerClient::Command::SET_LAYER_COLOR:
+ return parseSetLayerColor(length);
+ case IComposerClient::Command::SET_LAYER_COMPOSITION_TYPE:
+ return parseSetLayerCompositionType(length);
+ case IComposerClient::Command::SET_LAYER_DATASPACE:
+ return parseSetLayerDataspace(length);
+ case IComposerClient::Command::SET_LAYER_DISPLAY_FRAME:
+ return parseSetLayerDisplayFrame(length);
+ case IComposerClient::Command::SET_LAYER_PLANE_ALPHA:
+ return parseSetLayerPlaneAlpha(length);
+ case IComposerClient::Command::SET_LAYER_SIDEBAND_STREAM:
+ return parseSetLayerSidebandStream(length);
+ case IComposerClient::Command::SET_LAYER_SOURCE_CROP:
+ return parseSetLayerSourceCrop(length);
+ case IComposerClient::Command::SET_LAYER_TRANSFORM:
+ return parseSetLayerTransform(length);
+ case IComposerClient::Command::SET_LAYER_VISIBLE_REGION:
+ return parseSetLayerVisibleRegion(length);
+ case IComposerClient::Command::SET_LAYER_Z_ORDER:
+ return parseSetLayerZOrder(length);
+ default:
+ return false;
+ }
+}
+
+bool ComposerClient::CommandReader::parseSelectDisplay(uint16_t length)
{
if (length != CommandWriterBase::kSelectDisplayLength) {
return false;
@@ -661,7 +659,7 @@
return true;
}
-bool HwcClient::CommandReader::parseSelectLayer(uint16_t length)
+bool ComposerClient::CommandReader::parseSelectLayer(uint16_t length)
{
if (length != CommandWriterBase::kSelectLayerLength) {
return false;
@@ -672,7 +670,7 @@
return true;
}
-bool HwcClient::CommandReader::parseSetColorTransform(uint16_t length)
+bool ComposerClient::CommandReader::parseSetColorTransform(uint16_t length)
{
if (length != CommandWriterBase::kSetColorTransformLength) {
return false;
@@ -692,7 +690,7 @@
return true;
}
-bool HwcClient::CommandReader::parseSetClientTarget(uint16_t length)
+bool ComposerClient::CommandReader::parseSetClientTarget(uint16_t length)
{
// 4 parameters followed by N rectangles
if ((length - 4) % 4 != 0) {
@@ -720,7 +718,7 @@
return true;
}
-bool HwcClient::CommandReader::parseSetOutputBuffer(uint16_t length)
+bool ComposerClient::CommandReader::parseSetOutputBuffer(uint16_t length)
{
if (length != CommandWriterBase::kSetOutputBufferLength) {
return false;
@@ -744,7 +742,7 @@
return true;
}
-bool HwcClient::CommandReader::parseValidateDisplay(uint16_t length)
+bool ComposerClient::CommandReader::parseValidateDisplay(uint16_t length)
{
if (length != CommandWriterBase::kValidateDisplayLength) {
return false;
@@ -771,7 +769,7 @@
return true;
}
-bool HwcClient::CommandReader::parseAcceptDisplayChanges(uint16_t length)
+bool ComposerClient::CommandReader::parseAcceptDisplayChanges(uint16_t length)
{
if (length != CommandWriterBase::kAcceptDisplayChangesLength) {
return false;
@@ -785,7 +783,7 @@
return true;
}
-bool HwcClient::CommandReader::parsePresentDisplay(uint16_t length)
+bool ComposerClient::CommandReader::parsePresentDisplay(uint16_t length)
{
if (length != CommandWriterBase::kPresentDisplayLength) {
return false;
@@ -805,7 +803,7 @@
return true;
}
-bool HwcClient::CommandReader::parseSetLayerCursorPosition(uint16_t length)
+bool ComposerClient::CommandReader::parseSetLayerCursorPosition(uint16_t length)
{
if (length != CommandWriterBase::kSetLayerCursorPositionLength) {
return false;
@@ -820,7 +818,7 @@
return true;
}
-bool HwcClient::CommandReader::parseSetLayerBuffer(uint16_t length)
+bool ComposerClient::CommandReader::parseSetLayerBuffer(uint16_t length)
{
if (length != CommandWriterBase::kSetLayerBufferLength) {
return false;
@@ -844,7 +842,7 @@
return true;
}
-bool HwcClient::CommandReader::parseSetLayerSurfaceDamage(uint16_t length)
+bool ComposerClient::CommandReader::parseSetLayerSurfaceDamage(uint16_t length)
{
// N rectangles
if (length % 4 != 0) {
@@ -860,7 +858,7 @@
return true;
}
-bool HwcClient::CommandReader::parseSetLayerBlendMode(uint16_t length)
+bool ComposerClient::CommandReader::parseSetLayerBlendMode(uint16_t length)
{
if (length != CommandWriterBase::kSetLayerBlendModeLength) {
return false;
@@ -874,7 +872,7 @@
return true;
}
-bool HwcClient::CommandReader::parseSetLayerColor(uint16_t length)
+bool ComposerClient::CommandReader::parseSetLayerColor(uint16_t length)
{
if (length != CommandWriterBase::kSetLayerColorLength) {
return false;
@@ -888,7 +886,8 @@
return true;
}
-bool HwcClient::CommandReader::parseSetLayerCompositionType(uint16_t length)
+bool ComposerClient::CommandReader::parseSetLayerCompositionType(
+ uint16_t length)
{
if (length != CommandWriterBase::kSetLayerCompositionTypeLength) {
return false;
@@ -902,7 +901,7 @@
return true;
}
-bool HwcClient::CommandReader::parseSetLayerDataspace(uint16_t length)
+bool ComposerClient::CommandReader::parseSetLayerDataspace(uint16_t length)
{
if (length != CommandWriterBase::kSetLayerDataspaceLength) {
return false;
@@ -916,7 +915,7 @@
return true;
}
-bool HwcClient::CommandReader::parseSetLayerDisplayFrame(uint16_t length)
+bool ComposerClient::CommandReader::parseSetLayerDisplayFrame(uint16_t length)
{
if (length != CommandWriterBase::kSetLayerDisplayFrameLength) {
return false;
@@ -930,7 +929,7 @@
return true;
}
-bool HwcClient::CommandReader::parseSetLayerPlaneAlpha(uint16_t length)
+bool ComposerClient::CommandReader::parseSetLayerPlaneAlpha(uint16_t length)
{
if (length != CommandWriterBase::kSetLayerPlaneAlphaLength) {
return false;
@@ -944,7 +943,7 @@
return true;
}
-bool HwcClient::CommandReader::parseSetLayerSidebandStream(uint16_t length)
+bool ComposerClient::CommandReader::parseSetLayerSidebandStream(uint16_t length)
{
if (length != CommandWriterBase::kSetLayerSidebandStreamLength) {
return false;
@@ -963,7 +962,7 @@
return true;
}
-bool HwcClient::CommandReader::parseSetLayerSourceCrop(uint16_t length)
+bool ComposerClient::CommandReader::parseSetLayerSourceCrop(uint16_t length)
{
if (length != CommandWriterBase::kSetLayerSourceCropLength) {
return false;
@@ -977,7 +976,7 @@
return true;
}
-bool HwcClient::CommandReader::parseSetLayerTransform(uint16_t length)
+bool ComposerClient::CommandReader::parseSetLayerTransform(uint16_t length)
{
if (length != CommandWriterBase::kSetLayerTransformLength) {
return false;
@@ -991,7 +990,7 @@
return true;
}
-bool HwcClient::CommandReader::parseSetLayerVisibleRegion(uint16_t length)
+bool ComposerClient::CommandReader::parseSetLayerVisibleRegion(uint16_t length)
{
// N rectangles
if (length % 4 != 0) {
@@ -1007,7 +1006,7 @@
return true;
}
-bool HwcClient::CommandReader::parseSetLayerZOrder(uint16_t length)
+bool ComposerClient::CommandReader::parseSetLayerZOrder(uint16_t length)
{
if (length != CommandWriterBase::kSetLayerZOrderLength) {
return false;
@@ -1021,7 +1020,7 @@
return true;
}
-hwc_rect_t HwcClient::CommandReader::readRect()
+hwc_rect_t ComposerClient::CommandReader::readRect()
{
return hwc_rect_t{
readSigned(),
@@ -1031,7 +1030,7 @@
};
}
-std::vector<hwc_rect_t> HwcClient::CommandReader::readRegion(size_t count)
+std::vector<hwc_rect_t> ComposerClient::CommandReader::readRegion(size_t count)
{
std::vector<hwc_rect_t> region;
region.reserve(count);
@@ -1043,7 +1042,7 @@
return region;
}
-hwc_frect_t HwcClient::CommandReader::readFRect()
+hwc_frect_t ComposerClient::CommandReader::readFRect()
{
return hwc_frect_t{
readFloat(),
@@ -1053,8 +1052,8 @@
};
}
-Error HwcClient::CommandReader::lookupBuffer(BufferCache cache, uint32_t slot,
- bool useCache, buffer_handle_t& handle)
+Error ComposerClient::CommandReader::lookupBuffer(BufferCache cache,
+ uint32_t slot, bool useCache, buffer_handle_t& handle)
{
std::lock_guard<std::mutex> lock(mClient.mDisplayDataMutex);
diff --git a/graphics/composer/2.1/default/HwcClient.h b/graphics/composer/2.1/default/ComposerClient.h
similarity index 89%
rename from graphics/composer/2.1/default/HwcClient.h
rename to graphics/composer/2.1/default/ComposerClient.h
index 35a0450..d351cfb 100644
--- a/graphics/composer/2.1/default/HwcClient.h
+++ b/graphics/composer/2.1/default/ComposerClient.h
@@ -14,8 +14,8 @@
* limitations under the License.
*/
-#ifndef ANDROID_HARDWARE_GRAPHICS_COMPOSER_V2_1_HWC_CLIENT_H
-#define ANDROID_HARDWARE_GRAPHICS_COMPOSER_V2_1_HWC_CLIENT_H
+#ifndef ANDROID_HARDWARE_GRAPHICS_COMPOSER_V2_1_COMPOSER_CLIENT_H
+#define ANDROID_HARDWARE_GRAPHICS_COMPOSER_V2_1_COMPOSER_CLIENT_H
#include <mutex>
#include <unordered_map>
@@ -50,10 +50,12 @@
buffer_handle_t mHandle;
};
-class HwcClient : public IComposerClient {
+class ComposerClient : public IComposerClient {
public:
- HwcClient(HwcHal& hal);
- virtual ~HwcClient();
+ ComposerClient(ComposerBase& hal);
+ virtual ~ComposerClient();
+
+ void initialize();
void onHotplug(Display display, IComposerCallback::Connection connected);
void onRefresh(Display display);
@@ -104,7 +106,7 @@
const hidl_vec<hidl_handle>& inHandles,
executeCommands_cb hidl_cb) override;
-private:
+protected:
struct LayerBuffers {
std::vector<BufferClone> Buffers;
BufferClone SidebandStream;
@@ -123,10 +125,15 @@
class CommandReader : public CommandReaderBase {
public:
- CommandReader(HwcClient& client);
+ CommandReader(ComposerClient& client);
+ virtual ~CommandReader();
+
Error parse();
- private:
+ protected:
+ virtual bool parseCommand(IComposerClient::Command command,
+ uint16_t length);
+
bool parseSelectDisplay(uint16_t length);
bool parseSelectLayer(uint16_t length);
bool parseSetColorTransform(uint16_t length);
@@ -169,21 +176,23 @@
0, false, handle);
}
- HwcClient& mClient;
- HwcHal& mHal;
+ ComposerClient& mClient;
+ ComposerBase& mHal;
CommandWriterBase& mWriter;
Display mDisplay;
Layer mLayer;
};
- HwcHal& mHal;
+ virtual std::unique_ptr<CommandReader> createCommandReader();
+
+ ComposerBase& mHal;
// 64KiB minus a small space for metadata such as read/write pointers
static constexpr size_t kWriterInitialSize =
64 * 1024 / sizeof(uint32_t) - 16;
std::mutex mCommandMutex;
- CommandReader mReader;
+ std::unique_ptr<CommandReader> mReader;
CommandWriterBase mWriter;
sp<IComposerCallback> mCallback;
@@ -199,4 +208,4 @@
} // namespace hardware
} // namespace android
-#endif // ANDROID_HARDWARE_GRAPHICS_COMPOSER_V2_1_HWC_CLIENT_H
+#endif // ANDROID_HARDWARE_GRAPHICS_COMPOSER_V2_1_COMPOSER_CLIENT_H
diff --git a/graphics/composer/2.1/default/Hwc.cpp b/graphics/composer/2.1/default/Hwc.cpp
index 4efb12b..cf82967 100644
--- a/graphics/composer/2.1/default/Hwc.cpp
+++ b/graphics/composer/2.1/default/Hwc.cpp
@@ -20,8 +20,8 @@
#include <log/log.h>
+#include "ComposerClient.h"
#include "Hwc.h"
-#include "HwcClient.h"
namespace android {
namespace hardware {
@@ -184,14 +184,15 @@
Return<void> HwcHal::createClient(createClient_cb hidl_cb)
{
Error err = Error::NONE;
- sp<HwcClient> client;
+ sp<ComposerClient> client;
{
std::lock_guard<std::mutex> lock(mClientMutex);
// only one client is allowed
if (mClient == nullptr) {
- client = new HwcClient(*this);
+ client = new ComposerClient(*this);
+ client->initialize();
mClient = client;
} else {
err = Error::NO_RESOURCES;
@@ -203,7 +204,7 @@
return Void();
}
-sp<HwcClient> HwcHal::getClient()
+sp<ComposerClient> HwcHal::getClient()
{
std::lock_guard<std::mutex> lock(mClientMutex);
return (mClient != nullptr) ? mClient.promote() : nullptr;
diff --git a/graphics/composer/2.1/default/Hwc.h b/graphics/composer/2.1/default/Hwc.h
index 6420b31..ca08cf0 100644
--- a/graphics/composer/2.1/default/Hwc.h
+++ b/graphics/composer/2.1/default/Hwc.h
@@ -24,6 +24,8 @@
#include <android/hardware/graphics/composer/2.1/IComposer.h>
#include <hardware/hwcomposer2.h>
+#include "ComposerBase.h"
+
namespace android {
namespace hardware {
namespace graphics {
@@ -38,96 +40,101 @@
using android::hardware::graphics::common::V1_0::ColorTransform;
using android::hardware::graphics::common::V1_0::Hdr;
-class HwcClient;
+class ComposerClient;
-class HwcHal : public IComposer {
+class HwcHal : public IComposer, public ComposerBase {
public:
HwcHal(const hw_module_t* module);
virtual ~HwcHal();
+ bool hasCapability(Capability capability) const;
+
// IComposer interface
Return<void> getCapabilities(getCapabilities_cb hidl_cb) override;
Return<void> dumpDebugInfo(dumpDebugInfo_cb hidl_cb) override;
Return<void> createClient(createClient_cb hidl_cb) override;
- bool hasCapability(Capability capability) const;
-
- void removeClient();
-
- void enableCallback(bool enable);
-
- uint32_t getMaxVirtualDisplayCount();
+ // ComposerBase interface
+ void removeClient() override;
+ void enableCallback(bool enable) override;
+ uint32_t getMaxVirtualDisplayCount() override;
Error createVirtualDisplay(uint32_t width, uint32_t height,
- PixelFormat* format, Display* outDisplay);
- Error destroyVirtualDisplay(Display display);
+ PixelFormat* format, Display* outDisplay) override;
+ Error destroyVirtualDisplay(Display display) override;
- Error createLayer(Display display, Layer* outLayer);
- Error destroyLayer(Display display, Layer layer);
+ Error createLayer(Display display, Layer* outLayer) override;
+ Error destroyLayer(Display display, Layer layer) override;
- Error getActiveConfig(Display display, Config* outConfig);
+ Error getActiveConfig(Display display, Config* outConfig) override;
Error getClientTargetSupport(Display display,
uint32_t width, uint32_t height,
- PixelFormat format, Dataspace dataspace);
- Error getColorModes(Display display, hidl_vec<ColorMode>* outModes);
+ PixelFormat format, Dataspace dataspace) override;
+ Error getColorModes(Display display,
+ hidl_vec<ColorMode>* outModes) override;
Error getDisplayAttribute(Display display, Config config,
- IComposerClient::Attribute attribute, int32_t* outValue);
- Error getDisplayConfigs(Display display, hidl_vec<Config>* outConfigs);
- Error getDisplayName(Display display, hidl_string* outName);
+ IComposerClient::Attribute attribute, int32_t* outValue) override;
+ Error getDisplayConfigs(Display display,
+ hidl_vec<Config>* outConfigs) override;
+ Error getDisplayName(Display display, hidl_string* outName) override;
Error getDisplayType(Display display,
- IComposerClient::DisplayType* outType);
- Error getDozeSupport(Display display, bool* outSupport);
+ IComposerClient::DisplayType* outType) override;
+ Error getDozeSupport(Display display, bool* outSupport) override;
Error getHdrCapabilities(Display display, hidl_vec<Hdr>* outTypes,
float* outMaxLuminance, float* outMaxAverageLuminance,
- float* outMinLuminance);
+ float* outMinLuminance) override;
- Error setActiveConfig(Display display, Config config);
- Error setColorMode(Display display, ColorMode mode);
- Error setPowerMode(Display display, IComposerClient::PowerMode mode);
- Error setVsyncEnabled(Display display, IComposerClient::Vsync enabled);
+ Error setActiveConfig(Display display, Config config) override;
+ Error setColorMode(Display display, ColorMode mode) override;
+ Error setPowerMode(Display display,
+ IComposerClient::PowerMode mode) override;
+ Error setVsyncEnabled(Display display,
+ IComposerClient::Vsync enabled) override;
Error setColorTransform(Display display, const float* matrix,
- int32_t hint);
+ int32_t hint) override;
Error setClientTarget(Display display, buffer_handle_t target,
int32_t acquireFence, int32_t dataspace,
- const std::vector<hwc_rect_t>& damage);
+ const std::vector<hwc_rect_t>& damage) override;
Error setOutputBuffer(Display display, buffer_handle_t buffer,
- int32_t releaseFence);
+ int32_t releaseFence) override;
Error validateDisplay(Display display,
std::vector<Layer>* outChangedLayers,
std::vector<IComposerClient::Composition>* outCompositionTypes,
uint32_t* outDisplayRequestMask,
std::vector<Layer>* outRequestedLayers,
- std::vector<uint32_t>* outRequestMasks);
- Error acceptDisplayChanges(Display display);
+ std::vector<uint32_t>* outRequestMasks) override;
+ Error acceptDisplayChanges(Display display) override;
Error presentDisplay(Display display, int32_t* outPresentFence,
std::vector<Layer>* outLayers,
- std::vector<int32_t>* outReleaseFences);
+ std::vector<int32_t>* outReleaseFences) override;
Error setLayerCursorPosition(Display display, Layer layer,
- int32_t x, int32_t y);
+ int32_t x, int32_t y) override;
Error setLayerBuffer(Display display, Layer layer,
- buffer_handle_t buffer, int32_t acquireFence);
+ buffer_handle_t buffer, int32_t acquireFence) override;
Error setLayerSurfaceDamage(Display display, Layer layer,
- const std::vector<hwc_rect_t>& damage);
- Error setLayerBlendMode(Display display, Layer layer, int32_t mode);
+ const std::vector<hwc_rect_t>& damage) override;
+ Error setLayerBlendMode(Display display, Layer layer,
+ int32_t mode) override;
Error setLayerColor(Display display, Layer layer,
- IComposerClient::Color color);
+ IComposerClient::Color color) override;
Error setLayerCompositionType(Display display, Layer layer,
- int32_t type);
+ int32_t type) override;
Error setLayerDataspace(Display display, Layer layer,
- int32_t dataspace);
+ int32_t dataspace) override;
Error setLayerDisplayFrame(Display display, Layer layer,
- const hwc_rect_t& frame);
- Error setLayerPlaneAlpha(Display display, Layer layer, float alpha);
+ const hwc_rect_t& frame) override;
+ Error setLayerPlaneAlpha(Display display, Layer layer,
+ float alpha) override;
Error setLayerSidebandStream(Display display, Layer layer,
- buffer_handle_t stream);
+ buffer_handle_t stream) override;
Error setLayerSourceCrop(Display display, Layer layer,
- const hwc_frect_t& crop);
+ const hwc_frect_t& crop) override;
Error setLayerTransform(Display display, Layer layer,
- int32_t transform);
+ int32_t transform) override;
Error setLayerVisibleRegion(Display display, Layer layer,
- const std::vector<hwc_rect_t>& visible);
- Error setLayerZOrder(Display display, Layer layer, uint32_t z);
+ const std::vector<hwc_rect_t>& visible) override;
+ Error setLayerZOrder(Display display, Layer layer, uint32_t z) override;
private:
void initCapabilities();
@@ -136,7 +143,7 @@
void initDispatch(hwc2_function_descriptor_t desc, T* outPfn);
void initDispatch();
- sp<HwcClient> getClient();
+ sp<ComposerClient> getClient();
static void hotplugHook(hwc2_callback_data_t callbackData,
hwc2_display_t display, int32_t connected);
@@ -196,7 +203,7 @@
} mDispatch;
std::mutex mClientMutex;
- wp<HwcClient> mClient;
+ wp<ComposerClient> mClient;
};
extern "C" IComposer* HIDL_FETCH_IComposer(const char* name);
diff --git a/memtrack/1.0/vts/Android.mk b/memtrack/1.0/vts/Android.mk
index 397f946..fbb5951 100644
--- a/memtrack/1.0/vts/Android.mk
+++ b/memtrack/1.0/vts/Android.mk
@@ -16,6 +16,4 @@
LOCAL_PATH := $(call my-dir)
-include $(call all-subdir-makefiles)
-
-include $(LOCAL_PATH)/functional/vts/testcases/hal/memtrack/hidl/target/Android.mk
+include $(LOCAL_PATH)/functional/vts/testcases/hal/memtrack/hidl/Android.mk
diff --git a/memtrack/1.0/vts/functional/vts/testcases/hal/memtrack/hidl/Android.mk b/memtrack/1.0/vts/functional/vts/testcases/hal/memtrack/hidl/Android.mk
new file mode 100644
index 0000000..f9e3276
--- /dev/null
+++ b/memtrack/1.0/vts/functional/vts/testcases/hal/memtrack/hidl/Android.mk
@@ -0,0 +1,19 @@
+#
+# Copyright (C) 2016 The Android Open Source Project
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+LOCAL_PATH := $(call my-dir)
+
+include $(call all-subdir-makefiles)
diff --git a/nfc/1.0/vts/functional/vts/testcases/hal/nfc/hidl/target_profiling/AndroidTest.xml b/nfc/1.0/vts/functional/vts/testcases/hal/nfc/hidl/target_profiling/AndroidTest.xml
index 42c7e22..3b570f9 100644
--- a/nfc/1.0/vts/functional/vts/testcases/hal/nfc/hidl/target_profiling/AndroidTest.xml
+++ b/nfc/1.0/vts/functional/vts/testcases/hal/nfc/hidl/target_profiling/AndroidTest.xml
@@ -25,7 +25,7 @@
_64bit::DATA/nativetest64/nfc_hidl_hal_test/nfc_hidl_hal_test,
"/>
<option name="binary-test-type" value="gtest" />
- <option name="test-timeout" value="20m" />
+ <option name="test-timeout" value="25m" />
<option name="enable-profiling" value="true" />
</test>
</configuration>
diff --git a/soundtrigger/2.0/vts/functional/vts/testcases/hal/soundtrigger/hidl/target_profiling/AndroidTest.xml b/soundtrigger/2.0/vts/functional/vts/testcases/hal/soundtrigger/hidl/target_profiling/AndroidTest.xml
index e95a406..cd95b5f 100644
--- a/soundtrigger/2.0/vts/functional/vts/testcases/hal/soundtrigger/hidl/target_profiling/AndroidTest.xml
+++ b/soundtrigger/2.0/vts/functional/vts/testcases/hal/soundtrigger/hidl/target_profiling/AndroidTest.xml
@@ -19,12 +19,13 @@
</target_preparer>
<target_preparer class="com.android.tradefed.targetprep.VtsPythonVirtualenvPreparer" />
<test class="com.android.tradefed.testtype.VtsMultiDeviceTest">
- <option name="test-module-name" value="HalSoundTriggerHidlTargetBasicTest" />
+ <option name="test-module-name" value="HalSoundTriggerHidlTargetBasicProfilingTest" />
<option name="binary-test-sources" value="
_32bit::DATA/nativetest/soundtrigger_hidl_hal_test/soundtrigger_hidl_hal_test,
_64bit::DATA/nativetest64/soundtrigger_hidl_hal_test/soundtrigger_hidl_hal_test,
"/>
- <option name="binary-test-type" value="gtest" />
+ <option name="binary-test-type" value="hal_hidl_gtest" />
+ <option name="precondition-file-path-prefix" value="*/lib/hw/sound_trigger.primary." />
<option name="test-timeout" value="1m" />
<option name="enable-profiling" value="true" />
</test>
diff --git a/thermal/1.0/vts/functional/thermal_hidl_hal_test.cpp b/thermal/1.0/vts/functional/thermal_hidl_hal_test.cpp
index d922169..3c887c8 100644
--- a/thermal/1.0/vts/functional/thermal_hidl_hal_test.cpp
+++ b/thermal/1.0/vts/functional/thermal_hidl_hal_test.cpp
@@ -50,7 +50,7 @@
class ThermalHidlTest : public ::testing::Test {
public:
virtual void SetUp() override {
- thermal_ = IThermal::getService(THERMAL_SERVICE_NAME, false);
+ thermal_ = IThermal::getService(THERMAL_SERVICE_NAME);
ASSERT_NE(thermal_, nullptr);
baseSize_ = 0;
names_.clear();
diff --git a/vehicle/2.0/default/tests/VehicleHalManager_test.cpp b/vehicle/2.0/default/tests/VehicleHalManager_test.cpp
index 4a20ea5..dc32252 100644
--- a/vehicle/2.0/default/tests/VehicleHalManager_test.cpp
+++ b/vehicle/2.0/default/tests/VehicleHalManager_test.cpp
@@ -67,7 +67,7 @@
pValue = getValuePool()->obtainFloat(42.42);
}
break;
- case VehicleProperty::VEHICLE_MAPS_DATA_SERVICE:
+ case VehicleProperty::VEHICLE_MAP_SERVICE:
pValue = getValuePool()->obtainComplex();
pValue->value.int32Values = hidl_vec<int32_t> { 10, 20 };
pValue->value.int64Values = hidl_vec<int64_t> { 30, 40 };
@@ -317,10 +317,10 @@
}
TEST_F(VehicleHalManagerTest, get_Complex) {
- invokeGet(VehicleProperty::VEHICLE_MAPS_DATA_SERVICE, 0);
+ invokeGet(VehicleProperty::VEHICLE_MAP_SERVICE, 0);
ASSERT_EQ(StatusCode::OK, actualStatusCode);
- ASSERT_EQ(VehicleProperty::VEHICLE_MAPS_DATA_SERVICE, actualValue.prop);
+ ASSERT_EQ(VehicleProperty::VEHICLE_MAP_SERVICE, actualValue.prop);
ASSERT_EQ(3, actualValue.value.bytes.size());
ASSERT_EQ(1, actualValue.value.bytes[0]);
diff --git a/vehicle/2.0/default/tests/VehicleHalTestUtils.h b/vehicle/2.0/default/tests/VehicleHalTestUtils.h
index b6a5c31..538c022 100644
--- a/vehicle/2.0/default/tests/VehicleHalTestUtils.h
+++ b/vehicle/2.0/default/tests/VehicleHalTestUtils.h
@@ -107,7 +107,7 @@
// Complex data type.
{
- .prop = VehicleProperty::VEHICLE_MAPS_DATA_SERVICE,
+ .prop = VehicleProperty::VEHICLE_MAP_SERVICE,
.access = VehiclePropertyAccess::READ_WRITE,
.changeMode = VehiclePropertyChangeMode::ON_CHANGE
}
diff --git a/vehicle/2.0/types.hal b/vehicle/2.0/types.hal
index a9b706d..fb59a5a 100644
--- a/vehicle/2.0/types.hal
+++ b/vehicle/2.0/types.hal
@@ -964,6 +964,7 @@
*
* @change_mode VehiclePropertyChangeMode:ON_CHANGE
* @access VehiclePropertyAccess:READ_WRITE
+ */
AUDIO_PARAMETERS = (
0x907
| VehiclePropertyGroup:SYSTEM
@@ -1718,7 +1719,7 @@
* @change_mode VehiclePropertyChangeMode:ON_CHANGE
* @access VehiclePropertyAccess:READ_WRITE
*/
- VEHICLE_MAPS_DATA_SERVICE = (
+ VEHICLE_MAP_SERVICE = (
0x0C00
| VehiclePropertyGroup:SYSTEM
| VehiclePropertyType:COMPLEX
diff --git a/vehicle/2.0/vts/functional/vts/testcases/hal/vehicle/hidl/host/VehicleHidlTest.py b/vehicle/2.0/vts/functional/vts/testcases/hal/vehicle/hidl/host/VehicleHidlTest.py
index 8024be2..7854c7b 100644
--- a/vehicle/2.0/vts/functional/vts/testcases/hal/vehicle/hidl/host/VehicleHidlTest.py
+++ b/vehicle/2.0/vts/functional/vts/testcases/hal/vehicle/hidl/host/VehicleHidlTest.py
@@ -108,19 +108,89 @@
break
return isLiveSupported, isFreezeSupported
+ def readVhalProperty(self, propertyId, areaId=0):
+ """Reads a specified property from Vehicle HAL.
+
+ Args:
+ propertyId: the numeric identifier of the property to be read.
+ areaId: the numeric identifier of the vehicle area to retrieve the
+ property for. 0, or omitted, for global.
+
+ Returns:
+ the value of the property as read from Vehicle HAL, or None
+ if it could not read successfully.
+ """
+ vp_dict = {
+ 'prop' : propertyId,
+ 'timestamp' : 0,
+ 'areaId' : areaId,
+ 'value' : {
+ 'int32Values' : [],
+ 'floatValues' : [],
+ 'int64Values' : [],
+ 'bytes' : [],
+ 'stringValue' : ""
+ }
+ }
+ vp = self.vtypes.Py2Pb("VehiclePropValue", vp_dict)
+ status, value = self.vehicle.get(vp)
+ if self.vtypes.OK == status:
+ return value
+ else:
+ logging.warning("attempt to read property %s returned error %d",
+ propertyId, status)
+
def testObd2SensorProperties(self):
"""Test reading the live and freeze OBD2 frame properties.
OBD2 (On-Board Diagnostics 2) is the industry standard protocol
for retrieving diagnostic sensor information from vehicles.
"""
+ class CheckRead(object):
+ """This class wraps the logic of an actual property read.
+
+ Attributes:
+ testobject: the test case this object is used on behalf of.
+ propertyId: the identifier of the Vehiche HAL property to read.
+ name: the engineer-readable name of this test operation.
+ """
+
+ def __init__(self, testobject, propertyId, name):
+ self.testobject = testobject
+ self.propertyId = propertyId
+ self.name = name
+
+ def onReadSuccess(self, propValue):
+ """Override this to perform any post-read validation.
+
+ Args:
+ propValue: the property value obtained from Vehicle HAL.
+ """
+ pass
+
+ def __call__(self):
+ """Reads the specified property and validates the result."""
+ propValue = self.testobject.readVhalProperty(self.propertyId)
+ asserts.assertNotEqual(propValue, None,
+ msg="reading %s should not return None" %
+ self.name)
+ logging.info("%s = %s", self.name, propValue)
+ self.onReadSuccess(propValue)
+ logging.info("%s pass" % self.name)
+
def checkLiveFrameRead():
"""Validates reading the OBD2_LIVE_FRAME (if available)."""
- logging.info("checkLiveFrameRead no-op pass")
+ checker = CheckRead(self,
+ self.vtypes.OBD2_LIVE_FRAME,
+ "OBD2_LIVE_FRAME")
+ checker()
def checkFreezeFrameRead():
"""Validates reading the OBD2_FREEZE_FRAME (if available)."""
- logging.info("checkLiveFrameRead no-op pass")
+ checker = CheckRead(self,
+ self.vtypes.OBD2_FREEZE_FRAME,
+ "OBD2_FREEZE_FRAME")
+ checker()
isLiveSupported, isFreezeSupported = self.getSupportInfo()
logging.info("isLiveSupported = %s, isFreezeSupported = %s",
@@ -158,11 +228,11 @@
assertEqual(1, len(propValue.value.int32Values))
drivingStatus = propValue.value.int32Values[0]
- allStatuses = self.vtypes.UNRESTRICTED or self.vtypes.NO_VIDEO or
- self.vtypes.NO_KEYBOARD_INPUT or self.vtypes.NO_VOICE_INPUT or
- self.vtypes.NO_CONFIG or self.vtypes.LIMIT_MESSAGE_LEN
+ allStatuses = (self.vtypes.UNRESTRICTED | self.vtypes.NO_VIDEO
+ | self.vtypes.NO_KEYBOARD_INPUT | self.vtypes.NO_VOICE_INPUT
+ | self.vtypes.NO_CONFIG | self.vtypes.LIMIT_MESSAGE_LEN)
- assertEqual(allStatuses, allStatuses or drivingStatus)
+ assertEqual(allStatuses, allStatuses | drivingStatus)
if __name__ == "__main__":
test_runner.main()
diff --git a/vehicle/2.0/vts/types.vts b/vehicle/2.0/vts/types.vts
index fa7d892..067a7d6 100644
--- a/vehicle/2.0/vts/types.vts
+++ b/vehicle/2.0/vts/types.vts
@@ -494,7 +494,7 @@
scalar_value: {
int32_t: 287312836
}
- enumerator: "VEHICLE_MAPS_DATA_SERVICE"
+ enumerator: "VEHICLE_MAP_SERVICE"
scalar_value: {
int32_t: 299895808
}
diff --git a/vibrator/1.0/vts/functional/vibrator_hidl_hal_test.cpp b/vibrator/1.0/vts/functional/vibrator_hidl_hal_test.cpp
index 782a763..435b002 100644
--- a/vibrator/1.0/vts/functional/vibrator_hidl_hal_test.cpp
+++ b/vibrator/1.0/vts/functional/vibrator_hidl_hal_test.cpp
@@ -32,7 +32,7 @@
class VibratorHidlTest : public ::testing::Test {
public:
virtual void SetUp() override {
- vibrator = IVibrator::getService(false);
+ vibrator = IVibrator::getService();
ASSERT_NE(vibrator, nullptr);
}
diff --git a/vr/1.0/vts/functional/vr_hidl_hal_test.cpp b/vr/1.0/vts/functional/vr_hidl_hal_test.cpp
index 85ecbdc..7e85337 100644
--- a/vr/1.0/vts/functional/vr_hidl_hal_test.cpp
+++ b/vr/1.0/vts/functional/vr_hidl_hal_test.cpp
@@ -32,8 +32,7 @@
class VrHidlTest : public ::testing::Test {
public:
void SetUp() override {
- // currently test passthrough mode only
- vr = IVr::getService(VR_SERVICE_NAME, true);
+ vr = IVr::getService(VR_SERVICE_NAME);
ASSERT_NE(vr, nullptr);
ASSERT_TRUE(!vr->isRemote());
}