kunlun2: Import light hal from davinci, adopt for rgb

Signed-off-by: SamarV-121 <samarvispute121@gmail.com>

light/Light.cpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2018 The LineageOS Project
+ * Copyright (C) 2018-2019 The LineageOS Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -14,78 +14,192 @@
  * limitations under the License.
  */
 
-#define LOG_TAG "LightsService"
+#define LOG_TAG "LightService"
+
+#include <log/log.h>
 
 #include "Light.h"
 
-#include <android-base/logging.h>
-#include <android-base/stringprintf.h>
 #include <fstream>
 
+#define LCD_LED         "/sys/class/backlight/panel0-backlight/"
+#define RED_LED         "/sys/class/leds/red/"
+#define BLUE_LED        "/sys/class/leds/blue/"
+#define GREEN_LED       "/sys/class/leds/green/"
+
+#define BREATH          "breath"
+#define BRIGHTNESS      "brightness"
+#define MAX_BRIGHTNESS  "max_brightness"
+#define DELAY_OFF       "delay_off"
+#define DELAY_ON        "delay_on"
+
+namespace {
+/*
+ * Write value to path and close file.
+ */
+static void set(std::string path, std::string value) {
+    std::ofstream file(path);
+
+    if (!file.is_open()) {
+        ALOGW("failed to write %s to %s", value.c_str(), path.c_str());
+        return;
+    }
+
+    file << value;
+}
+
+static void set(std::string path, int value) {
+    set(path, std::to_string(value));
+}
+
+static int get(std::string path) {
+    std::ifstream file(path);
+    int value;
+
+    if (!file.is_open()) {
+    ALOGW("failed to read from %s", path.c_str());
+    return 0;
+    }
+
+    file >> value;
+    return value;
+}
+
+static int getMaxBrightness(std::string path) {
+    int value = get(path);
+    ALOGW("Got max brightness %d", value);
+    return value;
+}
+
+static uint32_t getBrightness(const LightState& state) {
+    uint32_t alpha, red, green, blue;
+
+    /*
+     * Extract brightness from AARRGGBB.
+     */
+    alpha = (state.color >> 24) & 0xFF;
+    red = (state.color >> 16) & 0xFF;
+    green = (state.color >> 8) & 0xFF;
+    blue = state.color & 0xFF;
+
+    /*
+     * Scale RGB brightness if Alpha brightness is not 0xFF.
+     */
+    if (alpha != 0xFF) {
+        red = red * alpha / 0xFF;
+        green = green * alpha / 0xFF;
+        blue = blue * alpha / 0xFF;
+    }
+
+    return (77 * red + 150 * green + 29 * blue) >> 8;
+}
+
+static inline uint32_t scaleBrightness(uint32_t brightness, uint32_t maxBrightness) {
+    return brightness * maxBrightness / 0xFF;
+}
+
+static inline uint32_t getScaledBrightness(const LightState& state, uint32_t maxBrightness) {
+    return scaleBrightness(getBrightness(state), maxBrightness);
+}
+
+static void handleBacklight(const LightState& state) {
+    uint32_t brightness = getScaledBrightness(state, getMaxBrightness(LCD_LED MAX_BRIGHTNESS));
+    set(LCD_LED BRIGHTNESS, brightness);
+}
+
+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 {
 
-/*
- * Write value to path and close file.
- */
-template <typename T>
-static void set(const std::string& path, const T& value) {
-    std::ofstream file(path);
-    file << value;
-}
-
-/*
- * Read from path and close file.
- * Return def in case of any failure.
- */
-template <typename T>
-static T get(const std::string& path, const T& def) {
-    std::ifstream file(path);
-    T result;
-
-    file >> result;
-    return file.fail() ? def : result;
-}
-
-static constexpr int kDefaultMaxBrightness = 255;
-
-static uint32_t rgbToBrightness(const LightState& state) {
-    uint32_t color = state.color & 0x00ffffff;
-    return ((77 * ((color >> 16) & 0xff))
-            + (150 * ((color >> 8) & 0xff))
-            + (29 * (color & 0xff))) >> 8;
-}
-
-Light::Light() {
-    mLights.emplace(Type::BACKLIGHT, std::bind(&Light::handleBacklight, this, std::placeholders::_1));
-}
-
-void Light::handleBacklight(const LightState& state) {
-    int maxBrightness = get("/sys/class/backlight/panel0-backlight/max_brightness", -1);
-    if (maxBrightness < 0) {
-        maxBrightness = kDefaultMaxBrightness;
-    }
-    uint32_t sentBrightness = rgbToBrightness(state);
-    uint32_t brightness = sentBrightness * maxBrightness / kDefaultMaxBrightness;
-    LOG(DEBUG) << "Writing backlight brightness " << brightness
-               << " (orig " << sentBrightness << ")";
-    set("/sys/class/backlight/panel0-backlight/brightness", brightness);
-}
-
 Return<Status> Light::setLight(Type type, const LightState& state) {
-    auto it = mLights.find(type);
+    LightStateHandler handler = nullptr;
 
-    if (it == mLights.end()) {
+    /* 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;
     }
 
-    // Lock global mutex until light state is updated.
+    /* Light up the type with the highest priority that matches the current handler. */
-    std::lock_guard<std::mutex> lock(mLock);
+    for (LightBackend& backend : backends) {
+        if (handler == backend.handler && isLit(backend.state)) {
+            handler(backend.state);
+            return Status::SUCCESS;
+        }
+    }
 
-    it->second(state);
+    /* If no type has been lit up, then turn off the hardware. */
+    handler(state);
 
     return Status::SUCCESS;
 }
@@ -93,8 +207,8 @@ Return<Status> Light::setLight(Type type, const LightState& state) {
 Return<void> Light::getSupportedTypes(getSupportedTypes_cb _hidl_cb) {
     std::vector<Type> types;
 
-    for (auto const& light : mLights) {
+    for (const LightBackend& backend : backends) {
-        types.push_back(light.first);
+        types.push_back(backend.type);
     }
 
     _hidl_cb(types);

light/Light.h

@@ -20,8 +20,29 @@
 #include <android/hardware/light/2.0/ILight.h>
 #include <hardware/lights.h>
 #include <hidl/Status.h>
-#include <unordered_map>
+#include <map>
 #include <mutex>
+#include <vector>
+
+using ::android::hardware::Return;
+using ::android::hardware::Void;
+using ::android::hardware::light::V2_0::Flash;
+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;
+
+typedef void (*LightStateHandler)(const LightState&);
+
+struct LightBackend {
+    Type type;
+    LightState state;
+    LightStateHandler handler;
+
+    LightBackend(Type type, LightStateHandler handler) : type(type), handler(handler) {
+        this->state.color = 0xff000000;
+    }
+};
 
 namespace android {
 namespace hardware {
@@ -29,26 +50,13 @@ namespace light {
 namespace V2_0 {
 namespace implementation {
 
-using ::android::hardware::Return;
-using ::android::hardware::Void;
-using ::android::hardware::hidl_vec;
-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;
-
 class Light : public ILight {
   public:
-    Light();
-
     Return<Status> setLight(Type type, const LightState& state) override;
     Return<void> getSupportedTypes(getSupportedTypes_cb _hidl_cb) override;
 
   private:
-    void handleBacklight(const LightState& state);
+    std::mutex globalLock;
-
-    std::mutex mLock;
-    std::unordered_map<Type, std::function<void(const LightState&)>> mLights;
 };
 
 }  // namespace implementation

light/android.hardware.light@2.0-service.lenovo_kunlun2.rc

@@ -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
     interface android.hardware.light@2.0::ILight default
     class hal

light/service.cpp

@@ -16,7 +16,6 @@
 
 #define LOG_TAG "android.hardware.light@2.0-service.lenovo_kunlun2"
 
-#include <android-base/logging.h>
 #include <hidl/HidlTransportSupport.h>
 
 #include "Light.h"
@@ -32,31 +31,20 @@ using android::sp;
 using android::status_t;
 
 int main() {
-    status_t status;
+    sp<ILight> service = new Light();
-    sp<ILight> service = nullptr;
 
-    LOG(INFO) << "Light HAL service 2.0 is starting.";
+    configureRpcThreadpool(1, true);
 
-    service = new Light();
+    status_t status = service->registerAsService();
-    if (service == nullptr) {
-        LOG(ERROR) << "Can not create an instance of Light HAL Iface, exiting.";
-        goto shutdown;
-    }
-
-    configureRpcThreadpool(1, true /*callerWillJoin*/);
-
-    status = service->registerAsService();
     if (status != OK) {
-        LOG(ERROR) << "Could not register service for Light HAL Iface (" << status << ")";
+        ALOGE("Cannot register Light HAL service.");
-        goto shutdown;
+        return 1;
     }
 
-    LOG(INFO) << "Light HAL service is ready.";
+    ALOGI("Light HAL service ready.");
-    joinRpcThreadpool();
-    // Should not pass this line
 
-shutdown:
+    joinRpcThreadpool();
-    // In normal operation, we don't expect the thread pool to exit
+
-    LOG(ERROR) << "Light HAL service is shutting down.";
+    ALOGI("Light HAL service failed to join thread pool.");
     return 1;
 }

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

@@ -15,6 +15,40 @@
      for different hardware and product builds.  Do not translate. -->
 <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 -->
     <bool name="config_notifyClientOnFingerprintCancelSuccess">true</bool>