Light 2.0 hal default implementation. (81f5da98) · Commits · e / os / android_hardware_interfaces

light/2.0/default/Android.mk

0 → 100644

+20 −0

Original line number	Diff line number	Diff line
		LOCAL_PATH := $(call my-dir)

		include $(CLEAR_VARS)
		LOCAL_MODULE := android.hardware.light@2.0-impl
		LOCAL_MODULE_RELATIVE_PATH := hw
		LOCAL_SRC_FILES := \
		Light.cpp \

		LOCAL_SHARED_LIBRARIES := \
		libhidl \
		libhwbinder \
		libutils \
		liblog \
		libcutils \
		libhardware \
		libbase \
		libcutils \
		android.hardware.light@2.0 \

		include $(BUILD_SHARED_LIBRARY)

light/2.0/default/Light.cpp

0 → 100644

+140 −0

Original line number	Diff line number	Diff line
		#include "Light.h"

		namespace android {
		namespace hardware {
		namespace light {
		namespace V2_0 {
		namespace implementation {

		static_assert(LIGHT_FLASH_NONE == static_cast<int>(Flash::NONE),
		"Flash::NONE must match legacy value.");
		static_assert(LIGHT_FLASH_TIMED == static_cast<int>(Flash::TIMED),
		"Flash::TIMED must match legacy value.");
		static_assert(LIGHT_FLASH_HARDWARE == static_cast<int>(Flash::HARDWARE),
		"Flash::HARDWARE must match legacy value.");

		static_assert(BRIGHTNESS_MODE_USER == static_cast<int>(Brightness::USER),
		"Brightness::USER must match legacy value.");
		static_assert(BRIGHTNESS_MODE_SENSOR == static_cast<int>(Brightness::SENSOR),
		"Brightness::SENSOR must match legacy value.");
		static_assert(BRIGHTNESS_MODE_LOW_PERSISTENCE ==
		static_cast<int>(Brightness::LOW_PERSISTENCE),
		"Brightness::LOW_PERSISTENCE must match legacy value.");

		Light::Light(std::map<Type, light_device_t*> &&lights)
		: mLights(std::move(lights)) {}

		// Methods from ::android::hardware::light::V2_0::ILight follow.
		Return<Status> Light::setLight(Type type, const LightState& state) {
		auto it = mLights.find(type);

		if (it == mLights.end()) {
		return Status::LIGHT_NOT_SUPPORTED;
		}

		light_device_t* hwLight = it->second;

		light_state_t legacyState {
		.color = state.color,
		.flashMode = static_cast<int>(state.flashMode),
		.flashOnMS = state.flashOnMs,
		.flashOffMS = state.flashOffMs,
		.brightnessMode = static_cast<int>(state.brightnessMode),
		};

		int ret = hwLight->set_light(hwLight, &legacyState);

		switch (ret) {
		case -ENOSYS:
		return Status::BRIGHTNESS_NOT_SUPPORTED;
		case 0:
		return Status::SUCCESS;
		default:
		return Status::UNKNOWN;
		}
		}

		Return<void> Light::getSupportedTypes(getSupportedTypes_cb _hidl_cb) {
		Type *types = new Type[mLights.size()];

		int idx = 0;
		for(auto const &pair : mLights) {
		Type type = pair.first;

		types[idx++] = type;
		}

		{
		hidl_vec<Type> hidl_types{};
		hidl_types.setToExternal(types, mLights.size());

		_hidl_cb(hidl_types);
		}

		delete[] types;

		return Void();
		}

		const static std::map<Type, const char*> kLogicalLights = {
		{Type::BACKLIGHT, LIGHT_ID_BACKLIGHT},
		{Type::KEYBOARD, LIGHT_ID_KEYBOARD},
		{Type::BUTTONS, LIGHT_ID_BUTTONS},
		{Type::BATTERY, LIGHT_ID_BATTERY},
		{Type::NOTIFICATIONS, LIGHT_ID_NOTIFICATIONS},
		{Type::ATTENTION, LIGHT_ID_ATTENTION},
		{Type::BLUETOOTH, LIGHT_ID_BLUETOOTH},
		{Type::WIFI, LIGHT_ID_WIFI}
		};

		light_device_t* getLightDevice(const char* name) {
		light_device_t* lightDevice;
		const hw_module_t* hwModule = NULL;

		int ret = hw_get_module (LIGHTS_HARDWARE_MODULE_ID, &hwModule);
		if (ret == 0) {
		ret = hwModule->methods->open(hwModule, name,
		reinterpret_cast<hw_device_t**>(&lightDevice));
		if (ret != 0) {
		ALOGE("light_open %s %s failed: %d", LIGHTS_HARDWARE_MODULE_ID, name, ret);
		}
		} else {
		ALOGE("hw_get_module %s %s failed: %d", LIGHTS_HARDWARE_MODULE_ID, name, ret);
		}

		if (ret == 0) {
		return lightDevice;
		} else {
		ALOGE("Light passthrough failed to load legacy HAL.");
		return nullptr;
		}
		}

		ILight* HIDL_FETCH_ILight(const char* /* name */) {
		std::map<Type, light_device_t*> lights;

		for(auto const &pair : kLogicalLights) {
		Type type = pair.first;
		const char* name = pair.second;

		light_device_t* light = getLightDevice(name);

		if (light != nullptr) {
		lights[type] = light;
		}
		}

		if (lights.size() == 0) {
		// Log information, but still return new Light.
		// Some devices may not have any lights.
		ALOGI("Could not open any lights.");
		}

		return new Light(std::move(lights));
		}

		} // namespace implementation
		} // namespace V2_0
		} // namespace light
		} // namespace hardware
		} // namespace android

light/2.0/default/Light.h

0 → 100644

+46 −0

Original line number	Diff line number	Diff line
		#ifndef HIDL_GENERATED_android_hardware_light_V2_0_Light_H_
		#define HIDL_GENERATED_android_hardware_light_V2_0_Light_H_

		#include <android/hardware/light/2.0/ILight.h>
		#include <hardware/hardware.h>
		#include <hardware/lights.h>
		#include <hidl/Status.h>
		#include <hidl/MQDescriptor.h>
		#include <map>

		namespace android {
		namespace hardware {
		namespace light {
		namespace V2_0 {
		namespace implementation {

		using ::android::hardware::light::V2_0::ILight;
		using ::android::hardware::light::V2_0::LightState;
		using ::android::hardware::light::V2_0::Status;
		using ::android::hardware::light::V2_0::Type;
		using ::android::hardware::Return;
		using ::android::hardware::Void;
		using ::android::hardware::hidl_vec;
		using ::android::hardware::hidl_string;
		using ::android::sp;

		struct Light : public ILight {
		Light(std::map<Type, light_device_t*> &&lights);

		// Methods from ::android::hardware::light::V2_0::ILight follow.
		Return<Status> setLight(Type type, const LightState& state) override;
		Return<void> getSupportedTypes(getSupportedTypes_cb _hidl_cb) override;

		private:
		std::map<Type, light_device_t*> mLights;
		};

		extern "C" ILight* HIDL_FETCH_ILight(const char* name);

		} // namespace implementation
		} // namespace V2_0
		} // namespace light
		} // namespace hardware
		} // namespace android

		#endif // HIDL_GENERATED_android_hardware_light_V2_0_Light_H_