LenovoZ5s/device_lenovo_sdm710-common
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

kunlun2: Import light hal from davinci, adopt for rgb

Browse source 
Signed-off-by: SamarV-121 <samarvispute121@gmail.com>
This commit is contained in:
Vitaliy Tomin 2020-04-12 01:59:02 +05:30 committed by SamarV-121
parent e3f6e9613a
commit a9bb0d616f
5 changed files with 406 additions and 231 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

332
light/Light.cpp
View file

@ -1,109 +1,223 @@
/* /*
* Copyright (C) 2018 The LineageOS Project * Copyright (C) 2018-2019 The LineageOS Project
* *
* Licensed under the Apache License, Version 2.0 (the "License"); * Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License. * you may not use this file except in compliance with the License.
* You may obtain a copy of the License at * You may obtain a copy of the License at
* *
* http://www.apache.org/licenses/LICENSE-2.0 * http://www.apache.org/licenses/LICENSE-2.0
* *
* Unless required by applicable law or agreed to in writing, software * Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, * distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and * See the License for the specific language governing permissions and
* limitations under the License. * limitations under the License.
*/ */
#define LOG_TAG "LightsService" #define LOG_TAG "LightService"
#include "Light.h" #include <log/log.h>
#include <android-base/logging.h> #include "Light.h"
#include <android-base/stringprintf.h>
#include <fstream> #include <fstream>
namespace android { #define LCD_LED "/sys/class/backlight/panel0-backlight/"
namespace hardware { #define RED_LED "/sys/class/leds/red/"
namespace light { #define BLUE_LED "/sys/class/leds/blue/"
namespace V2_0 { #define GREEN_LED "/sys/class/leds/green/"
namespace implementation {
#define BREATH "breath"
/* #define BRIGHTNESS "brightness"
* Write value to path and close file. #define MAX_BRIGHTNESS "max_brightness"
*/ #define DELAY_OFF "delay_off"
template <typename T> #define DELAY_ON "delay_on"
static void set(const std::string& path, const T& value) {
std::ofstream file(path); namespace {
file << value; /*
} * Write value to path and close file.
*/
/* static void set(std::string path, std::string value) {
* Read from path and close file. std::ofstream file(path);
* Return def in case of any failure.
*/ if (!file.is_open()) {
template <typename T> ALOGW("failed to write %s to %s", value.c_str(), path.c_str());
static T get(const std::string& path, const T& def) { return;
std::ifstream file(path); }
T result;
file << value;
file >> result; }
return file.fail() ? def : result;
} static void set(std::string path, int value) {
set(path, std::to_string(value));
static constexpr int kDefaultMaxBrightness = 255; }
static uint32_t rgbToBrightness(const LightState& state) { static int get(std::string path) {
uint32_t color = state.color & 0x00ffffff; std::ifstream file(path);
return ((77 * ((color >> 16) & 0xff)) int value;
+ (150 * ((color >> 8) & 0xff))
+ (29 * (color & 0xff))) >> 8; if (!file.is_open()) {
} ALOGW("failed to read from %s", path.c_str());
return 0;
Light::Light() { }
mLights.emplace(Type::BACKLIGHT, std::bind(&Light::handleBacklight, this, std::placeholders::_1));
} file >> value;
return value;
void Light::handleBacklight(const LightState& state) { }
int maxBrightness = get("/sys/class/backlight/panel0-backlight/max_brightness", -1);
if (maxBrightness < 0) { static int getMaxBrightness(std::string path) {
maxBrightness = kDefaultMaxBrightness; int value = get(path);
} ALOGW("Got max brightness %d", value);
uint32_t sentBrightness = rgbToBrightness(state); return value;
uint32_t brightness = sentBrightness * maxBrightness / kDefaultMaxBrightness; }
LOG(DEBUG) << "Writing backlight brightness " << brightness
<< " (orig " << sentBrightness << ")"; static uint32_t getBrightness(const LightState& state) {
set("/sys/class/backlight/panel0-backlight/brightness", brightness); uint32_t alpha, red, green, blue;
}
/*
Return<Status> Light::setLight(Type type, const LightState& state) { * Extract brightness from AARRGGBB.
auto it = mLights.find(type); */
alpha = (state.color >> 24) & 0xFF;
if (it == mLights.end()) { red = (state.color >> 16) & 0xFF;
return Status::LIGHT_NOT_SUPPORTED; green = (state.color >> 8) & 0xFF;
} blue = state.color & 0xFF;
// Lock global mutex until light state is updated. /*
std::lock_guard<std::mutex> lock(mLock); * Scale RGB brightness if Alpha brightness is not 0xFF.
*/
it->second(state); if (alpha != 0xFF) {
red = red * alpha / 0xFF;
return Status::SUCCESS; green = green * alpha / 0xFF;
} blue = blue * alpha / 0xFF;
}
Return<void> Light::getSupportedTypes(getSupportedTypes_cb _hidl_cb) {
std::vector<Type> types; return (77 * red + 150 * green + 29 * blue) >> 8;
}
for (auto const& light : mLights) {
types.push_back(light.first); static inline uint32_t scaleBrightness(uint32_t brightness, uint32_t maxBrightness) {
} return brightness * maxBrightness / 0xFF;
}
_hidl_cb(types);
static inline uint32_t getScaledBrightness(const LightState& state, uint32_t maxBrightness) {
return Void(); return scaleBrightness(getBrightness(state), maxBrightness);
} }
} // namespace implementation static void handleBacklight(const LightState& state) {
} // namespace V2_0 uint32_t brightness = getScaledBrightness(state, getMaxBrightness(LCD_LED MAX_BRIGHTNESS));
} // namespace light set(LCD_LED BRIGHTNESS, brightness);
} // namespace hardware }
} // namespace android
static void handleNotification(const LightState& state) {
uint32_t redBrightness = scaleBrightness( (state.color >> 16) & 0xFF, getMaxBrightness(RED_LED MAX_BRIGHTNESS));
uint32_t blueBrightness = scaleBrightness( state.color & 0xFF, getMaxBrightness(BLUE_LED MAX_BRIGHTNESS));
uint32_t greenBrightness = scaleBrightness((state.color >> 8) & 0xFF, getMaxBrightness(GREEN_LED MAX_BRIGHTNESS));
/* Disable breathing or blinking */
set(RED_LED BREATH, 0);
set(RED_LED DELAY_OFF, 0);
set(RED_LED DELAY_ON, 0);
set(BLUE_LED BREATH, 0);
set(BLUE_LED DELAY_OFF, 0);
set(BLUE_LED DELAY_ON, 0);
set(GREEN_LED BREATH, 0);
set(GREEN_LED DELAY_OFF, 0);
set(GREEN_LED DELAY_ON, 0);
switch (state.flashMode) {
case Flash::HARDWARE:
/* Breathing */
set(RED_LED BREATH, 1);
set(BLUE_LED BREATH, 1);
set(GREEN_LED BREATH, 1);
break;
case Flash::TIMED:
/* Blinking */
set(RED_LED DELAY_OFF, state.flashOnMs);
set(RED_LED DELAY_ON, state.flashOffMs);
set(BLUE_LED DELAY_OFF, state.flashOnMs);
set(BLUE_LED DELAY_ON, state.flashOffMs);
set(GREEN_LED DELAY_OFF, state.flashOnMs);
set(GREEN_LED DELAY_ON, state.flashOffMs);
break;
case Flash::NONE:
default:
break;
}
set(RED_LED BRIGHTNESS, redBrightness);
set(BLUE_LED BRIGHTNESS, blueBrightness);
set(GREEN_LED BRIGHTNESS, greenBrightness);
}
static inline bool isLit(const LightState& state) {
return state.color & 0x00ffffff;
}
/* Keep sorted in the order of importance. */
static std::vector<LightBackend> backends = {
{ Type::ATTENTION, handleNotification },
{ Type::NOTIFICATIONS, handleNotification },
{ Type::BATTERY, handleNotification },
{ Type::BACKLIGHT, handleBacklight },
};
} // anonymous namespace
namespace android {
namespace hardware {
namespace light {
namespace V2_0 {
namespace implementation {
Return<Status> Light::setLight(Type type, const LightState& state) {
LightStateHandler handler = nullptr;
/* Lock global mutex until light state is updated. */
std::lock_guard<std::mutex> lock(globalLock);
/* Update the cached state value for the current type. */
for (LightBackend& backend : backends) {
if (backend.type == type) {
backend.state = state;
handler = backend.handler;
}
}
/* If no handler has been found, then the type is not supported. */
if (!handler) {
return Status::LIGHT_NOT_SUPPORTED;
}
/* Light up the type with the highest priority that matches the current handler. */
for (LightBackend& backend : backends) {
if (handler == backend.handler && isLit(backend.state)) {
handler(backend.state);
return Status::SUCCESS;
}
}
/* If no type has been lit up, then turn off the hardware. */
handler(state);
return Status::SUCCESS;
}
Return<void> Light::getSupportedTypes(getSupportedTypes_cb _hidl_cb) {
std::vector<Type> types;
for (const LightBackend& backend : backends) {
types.push_back(backend.type);
}
_hidl_cb(types);
return Void();
}
} // namespace implementation
} // namespace V2_0
} // namespace light
} // namespace hardware
} // namespace android

128
light/Light.h
View file

@ -1,60 +1,68 @@
/* /*
* Copyright (C) 2018 The LineageOS Project * Copyright (C) 2018 The LineageOS Project
* *
* Licensed under the Apache License, Version 2.0 (the "License"); * Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License. * you may not use this file except in compliance with the License.
* You may obtain a copy of the License at * You may obtain a copy of the License at
* *
* http://www.apache.org/licenses/LICENSE-2.0 * http://www.apache.org/licenses/LICENSE-2.0
* *
* Unless required by applicable law or agreed to in writing, software * Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, * distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and * See the License for the specific language governing permissions and
* limitations under the License. * limitations under the License.
*/ */
#ifndef ANDROID_HARDWARE_LIGHT_V2_0_LIGHT_H #ifndef ANDROID_HARDWARE_LIGHT_V2_0_LIGHT_H
#define ANDROID_HARDWARE_LIGHT_V2_0_LIGHT_H #define ANDROID_HARDWARE_LIGHT_V2_0_LIGHT_H
#include <android/hardware/light/2.0/ILight.h> #include <android/hardware/light/2.0/ILight.h>
#include <hardware/lights.h> #include <hardware/lights.h>
#include <hidl/Status.h> #include <hidl/Status.h>
#include <unordered_map> #include <map>
#include <mutex> #include <mutex>
#include <vector>
namespace android {
namespace hardware { using ::android::hardware::Return;
namespace light { using ::android::hardware::Void;
namespace V2_0 { using ::android::hardware::light::V2_0::Flash;
namespace implementation { using ::android::hardware::light::V2_0::ILight;
using ::android::hardware::light::V2_0::LightState;
using ::android::hardware::Return; using ::android::hardware::light::V2_0::Status;
using ::android::hardware::Void; using ::android::hardware::light::V2_0::Type;
using ::android::hardware::hidl_vec;
using ::android::hardware::light::V2_0::ILight; typedef void (*LightStateHandler)(const LightState&);
using ::android::hardware::light::V2_0::LightState;
using ::android::hardware::light::V2_0::Status; struct LightBackend {
using ::android::hardware::light::V2_0::Type; Type type;
LightState state;
class Light : public ILight { LightStateHandler handler;
public:
Light(); LightBackend(Type type, LightStateHandler handler) : type(type), handler(handler) {
this->state.color = 0xff000000;
Return<Status> setLight(Type type, const LightState& state) override; }
Return<void> getSupportedTypes(getSupportedTypes_cb _hidl_cb) override; };
private: namespace android {
void handleBacklight(const LightState& state); namespace hardware {
namespace light {
std::mutex mLock; namespace V2_0 {
std::unordered_map<Type, std::function<void(const LightState&)>> mLights; namespace implementation {
};
class Light : public ILight {
} // namespace implementation public:
} // namespace V2_0 Return<Status> setLight(Type type, const LightState& state) override;
} // namespace light Return<void> getSupportedTypes(getSupportedTypes_cb _hidl_cb) override;
} // namespace hardware
} // namespace android private:
std::mutex globalLock;
#endif // ANDROID_HARDWARE_LIGHT_V2_0_LIGHT_H };
} // namespace implementation
} // namespace V2_0
} // namespace light
} // namespace hardware
} // namespace android
#endif // ANDROID_HARDWARE_LIGHT_V2_0_LIGHT_H

31
light/android.hardware.light@2.0-service.lenovo_kunlun2.rc
View file

@ -1,3 +1,34 @@
on boot
chown system system /sys/class/backlight/panel0-backlight/brightness
chown system system /sys/class/backlight/panel0-backlight/max_brightness
chown system system /sys/class/leds/red/breath
chown system system /sys/class/leds/red/brightness
chown system system /sys/class/leds/red/delay_on
chown system system /sys/class/leds/red/delay_off
chown system system /sys/class/leds/green/breath
chown system system /sys/class/leds/green/brightness
chown system system /sys/class/leds/green/delay_on
chown system system /sys/class/leds/green/delay_off
chown system system /sys/class/leds/blue/breath
chown system system /sys/class/leds/blue/brightness
chown system system /sys/class/leds/blue/delay_on
chown system system /sys/class/leds/blue/delay_off
chmod 0644 /sys/class/backlight/panel0-backlight/brightness
chmod 0644 /sys/class/backlight/panel0-backlight/max_brightness
chmod 0644 /sys/class/leds/red/breath
chmod 0644 /sys/class/leds/red/brightness
chmod 0644 /sys/class/leds/red/delay_on
chmod 0644 /sys/class/leds/red/delay_off
chmod 0644 /sys/class/leds/green/breath
chmod 0644 /sys/class/leds/green/brightness
chmod 0644 /sys/class/leds/green/delay_on
chmod 0644 /sys/class/leds/green/delay_off
chmod 0644 /sys/class/leds/blue/breath
chmod 0644 /sys/class/leds/blue/brightness
chmod 0644 /sys/class/leds/blue/delay_on
chmod 0644 /sys/class/leds/blue/delay_off
service vendor.light-hal-2-0 /vendor/bin/hw/android.hardware.light@2.0-service service vendor.light-hal-2-0 /vendor/bin/hw/android.hardware.light@2.0-service
interface android.hardware.light@2.0::ILight default interface android.hardware.light@2.0::ILight default
class hal class hal

112
light/service.cpp
View file

@ -1,62 +1,50 @@
/* /*
* Copyright (C) 2018 The LineageOS Project * Copyright (C) 2018 The LineageOS Project
* *
* Licensed under the Apache License, Version 2.0 (the "License"); * Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License. * you may not use this file except in compliance with the License.
* You may obtain a copy of the License at * You may obtain a copy of the License at
* *
* http://www.apache.org/licenses/LICENSE-2.0 * http://www.apache.org/licenses/LICENSE-2.0
* *
* Unless required by applicable law or agreed to in writing, software * Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, * distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and * See the License for the specific language governing permissions and
* limitations under the License. * limitations under the License.
*/ */
#define LOG_TAG "android.hardware.light@2.0-service.lenovo_kunlun2" #define LOG_TAG "android.hardware.light@2.0-service.lenovo_kunlun2"
#include <android-base/logging.h> #include <hidl/HidlTransportSupport.h>
#include <hidl/HidlTransportSupport.h>
#include "Light.h"
#include "Light.h"
using android::hardware::configureRpcThreadpool;
using android::hardware::configureRpcThreadpool; using android::hardware::joinRpcThreadpool;
using android::hardware::joinRpcThreadpool;
using android::hardware::light::V2_0::ILight;
using android::hardware::light::V2_0::ILight; using android::hardware::light::V2_0::implementation::Light;
using android::hardware::light::V2_0::implementation::Light;
using android::OK;
using android::OK; using android::sp;
using android::sp; using android::status_t;
using android::status_t;
int main() {
int main() { sp<ILight> service = new Light();
status_t status;
sp<ILight> service = nullptr; configureRpcThreadpool(1, true);
LOG(INFO) << "Light HAL service 2.0 is starting."; status_t status = service->registerAsService();
if (status != OK) {
service = new Light(); ALOGE("Cannot register Light HAL service.");
if (service == nullptr) { return 1;
LOG(ERROR) << "Can not create an instance of Light HAL Iface, exiting."; }
goto shutdown;
} ALOGI("Light HAL service ready.");
configureRpcThreadpool(1, true /*callerWillJoin*/); joinRpcThreadpool();
status = service->registerAsService(); ALOGI("Light HAL service failed to join thread pool.");
if (status != OK) { return 1;
LOG(ERROR) << "Could not register service for Light HAL Iface (" << status << ")"; }
goto shutdown;
}
LOG(INFO) << "Light HAL service is ready.";
joinRpcThreadpool();
// Should not pass this line
shutdown:
// In normal operation, we don't expect the thread pool to exit
LOG(ERROR) << "Light HAL service is shutting down.";
return 1;
}

34
overlay-pe/frameworks/base/core/res/res/values/custom_config.xml
View file

@ -15,6 +15,40 @@
for different hardware and product builds. Do not translate. --> for different hardware and product builds. Do not translate. -->
<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2"> <resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
<!-- All the capabilities of the LEDs on this device, stored as a bit field.
This integer should equal the sum of the corresponding value for each
of the following capabilities present:
// Device has a color adjustable battery light.
LIGHTS_RGB_NOTIFICATION_LED = 1
// Device has a color adjustable notification light.
LIGHTS_RGB_BATTERY_LED = 2
LIGHTS_MULTIPLE_NOTIFICATION_LED = 4 (deprecated)
// The notification light has adjustable pulsing capability.
LIGHTS_PULSATING_LED = 8
// Device has a multi-segment battery light that is able to
// use the light brightness value to determine how many
// segments to show (in order to represent battery level).
LIGHTS_SEGMENTED_BATTERY_LED = 16
// The notification light supports HAL adjustable brightness
// via the alpha channel.
// Note: if a device notification light supports LIGHTS_RGB_NOTIFICATION_LED
// then HAL support is not necessary for brightness control. In this case,
// brightness support will be provided by mokee-sdk through the scaling of
// RGB color values.
LIGHTS_ADJUSTABLE_NOTIFICATION_LED_BRIGHTNESS = 32
// Device has a battery light.
LIGHTS_BATTERY_LED = 64
// The battery light supports HAL adjustable brightness via
// the alpha channel.
// Note: if a device battery light supports LIGHTS_RGB_BATTERY_LED then HAL
// support is not necessary for brightness control. In this case,
// brightness support will be provided by mokee-sdk through the scaling of
// RGB color values.
LIGHTS_ADJUSTABLE_BATTERY_LED_BRIGHTNESS = 128
For example, a device with notification and battery lights that supports
pulsating and RGB control would set this config to 75. -->
<integer name="config_deviceLightCapabilities">75</integer>
<!-- Whether notify fingerprint client of successful cancelled authentication --> <!-- Whether notify fingerprint client of successful cancelled authentication -->
<bool name="config_notifyClientOnFingerprintCancelSuccess">true</bool> <bool name="config_notifyClientOnFingerprintCancelSuccess">true</bool>