donjohanliebert/device_xiaomi_sm6150-common
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

sm6150-common: Move to common Xiaomi light AIDL

Browse Source 
Change-Id: I00494cd392d19abd97cd65aeb4ec4bd9c9b11352
This commit is contained in:
Sebastiano Barezzi 2021-09-23 16:49:09 +02:00 committed by basamaryan
parent 7dc92aba67
commit ed6986e80f
No known key found for this signature in database
GPG Key ID: 707BA6C82329E8F9
7 changed files with 1 additions and 422 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

35
light/Android.bp
View File

@ -1,35 +0,0 @@
//
// Copyright (C) 2019-2020 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.
// 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.
cc_binary {
name: "android.hardware.light@2.0-service.xiaomi_sm6150",
defaults: ["hidl_defaults"],
vintf_fragments: ["android.hardware.light@2.0-service.xiaomi_sm6150.xml"],
init_rc: ["android.hardware.light@2.0-service.xiaomi_sm6150.rc"],
relative_install_path: "hw",
srcs: [
"service.cpp",
"Light.cpp",
],
vendor: true,
shared_libs: [
"android.hardware.light@2.0",
"libbase",
"libhardware",
"libhidlbase",
"liblog",
"libutils",
],
}

239
light/Light.cpp
View File

@ -1,239 +0,0 @@
/*
* Copyright (C) 2018-2020 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.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#define LOG_TAG "LightService"
#include <log/log.h>
#include "Light.h"
#include <fstream>
#define NOTIFICATION_LED_LEFT(x) "/sys/class/leds/left/" + x
#define NOTIFICATION_LED_WHITE(x) "/sys/class/leds/white/" + x
#define BREATH "breath"
#define BRIGHTNESS "brightness"
#define MAX_BRIGHTNESS "max_brightness"
namespace {
/*
* Get the full path to the led node.
*/
static std::string getLedPath(std::string path) {
std::ifstream left_path(NOTIFICATION_LED_LEFT(path));
return left_path.good() ? NOTIFICATION_LED_LEFT(path) : NOTIFICATION_LED_WHITE(path);
}
/*
* Write value to path and close file.
*/
static void set(std::string path, std::string value) {
std::ofstream file(getLedPath(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));
}
/*
* Read max brightness from path and close file.
*/
static int getMaxBrightness(std::string path) {
std::ifstream file(getLedPath(path));
int value;
if (!file.is_open()) {
ALOGW("failed to read from %s", path.c_str());
return 0;
}
file >> 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 using Alpha brightness.
*/
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) {
if (brightness == 0) {
return 0;
}
return (brightness - 1) * (maxBrightness - 1) / (0xFF - 1) + 1;
}
static inline uint32_t getScaledBrightness(const LightState& state, uint32_t maxBrightness) {
return scaleBrightness(getBrightness(state), maxBrightness);
}
static void handleNotification(const LightState& state) {
uint32_t notificationBrightness = getScaledBrightness(state, getMaxBrightness(MAX_BRIGHTNESS));
/* Disable breathing or blinking */
set(BREATH, 0);
set(BRIGHTNESS, 0);
if (!notificationBrightness) {
return;
}
switch (state.flashMode) {
case Flash::HARDWARE:
case Flash::TIMED:
/* Breathing */
set(BREATH, 1);
break;
case Flash::NONE:
default:
set(BRIGHTNESS, notificationBrightness);
}
}
static inline bool isStateLit(const LightState& state) {
return state.color & 0x00ffffff;
}
static inline bool isStateEqual(const LightState& first, const LightState& second) {
if (first.color == second.color && first.flashMode == second.flashMode &&
first.flashOnMs == second.flashOnMs &&
first.flashOffMs == second.flashOffMs &&
first.brightnessMode == second.brightnessMode) {
return true;
}
return false;
}
/* Keep sorted in the order of importance. */
static std::vector<LightBackend> backends = {
{ Type::ATTENTION, handleNotification },
{ Type::NOTIFICATIONS, handleNotification },
{ Type::BATTERY, handleNotification },
};
static LightStateHandler findHandler(Type type) {
for (const LightBackend& backend : backends) {
if (backend.type == type) {
return backend.handler;
}
}
return nullptr;
}
static LightState findLitState(LightStateHandler handler) {
LightState emptyState;
for (const LightBackend& backend : backends) {
if (backend.handler == handler) {
if (isStateLit(backend.state)) {
return backend.state;
}
emptyState = backend.state;
}
}
return emptyState;
}
static void updateState(Type type, const LightState& state) {
for (LightBackend& backend : backends) {
if (backend.type == type) {
backend.state = state;
}
}
}
} // anonymous namespace
namespace android {
namespace hardware {
namespace light {
namespace V2_0 {
namespace implementation {
Return<Status> Light::setLight(Type type, const LightState& state) {
/* Lock global mutex until light state is updated. */
std::lock_guard<std::mutex> lock(globalLock);
LightStateHandler handler = findHandler(type);
if (!handler) {
/* If no handler has been found, then the type is not supported. */
return Status::LIGHT_NOT_SUPPORTED;
}
/* Find the old state of the current handler. */
LightState oldState = findLitState(handler);
/* Update the cached state value for the current type. */
updateState(type, state);
/* Find the new state of the current handler. */
LightState newState = findLitState(handler);
if (isStateEqual(oldState, newState)) {
return Status::SUCCESS;
}
handler(newState);
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

68
light/Light.h
View File

@ -1,68 +0,0 @@
/*
* Copyright (C) 2018 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.
* 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_LIGHT_V2_0_LIGHT_H
#define ANDROID_HARDWARE_LIGHT_V2_0_LIGHT_H
#include <android/hardware/light/2.0/ILight.h>
#include <hardware/lights.h>
#include <hidl/Status.h>
#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 {
namespace light {
namespace V2_0 {
namespace implementation {
class Light : public ILight {
public:
Return<Status> setLight(Type type, const LightState& state) override;
Return<void> getSupportedTypes(getSupportedTypes_cb _hidl_cb) override;
private:
std::mutex globalLock;
};
} // namespace implementation
} // namespace V2_0
} // namespace light
} // namespace hardware
} // namespace android
#endif // ANDROID_HARDWARE_LIGHT_V2_0_LIGHT_H

18
light/android.hardware.light@2.0-service.xiaomi_sm6150.rc
View File

@ -1,18 +0,0 @@
on boot
chown system system /sys/class/leds/left/brightness
chown system system /sys/class/leds/left/breath
chown system system /sys/class/leds/white/brightness
chown system system /sys/class/leds/white/breath
chmod 0644 /sys/class/leds/left/brightness
chmod 0644 /sys/class/leds/left/breath
chmod 0644 /sys/class/leds/white/brightness
chmod 0644 /sys/class/leds/white/breath
service vendor.light-hal-2-0 /vendor/bin/hw/android.hardware.light@2.0-service.xiaomi_sm6150
interface android.hardware.light@2.0::ILight default
class hal
user system
group system
# shutting off lights while powering-off
shutdown critical

11
light/android.hardware.light@2.0-service.xiaomi_sm6150.xml
View File

@ -1,11 +0,0 @@
<manifest version="1.0" type="device">
<hal format="hidl">
<name>android.hardware.light</name>
<transport>hwbinder</transport>
<version>2.0</version>
<interface>
<name>ILight</name>
<instance>default</instance>
</interface>
</hal>
</manifest>

50
light/service.cpp
View File

@ -1,50 +0,0 @@
/*
* Copyright (C) 2018 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.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#define LOG_TAG "android.hardware.light@2.0-service.xiaomi_sm6150"
#include <hidl/HidlTransportSupport.h>
#include "Light.h"
using android::hardware::configureRpcThreadpool;
using android::hardware::joinRpcThreadpool;
using android::hardware::light::V2_0::ILight;
using android::hardware::light::V2_0::implementation::Light;
using android::OK;
using android::sp;
using android::status_t;
int main() {
sp<ILight> service = new Light();
configureRpcThreadpool(1, true);
status_t status = service->registerAsService();
if (status != OK) {
ALOGE("Cannot register Light HAL service.");
return 1;
}
ALOGI("Light HAL service ready.");
joinRpcThreadpool();
ALOGI("Light HAL service failed to join thread pool.");
return 1;
}

2
sepolicy/vendor/file_contexts vendored
View File

@ -33,7 +33,7 @@
# HALs
/(vendor|system/vendor)/bin/hw/android\.hardware\.biometrics\.fingerprint@2\.3-service\.xiaomi u:object_r:hal_fingerprint_default_exec:s0
/vendor/bin/hw/android\.hardware\.light@2\.0-service\.xiaomi_sm6150 u:object_r:hal_light_default_exec:s0
/vendor/bin/hw/android\.hardware\.light-service\.xiaomi u:object_r:hal_light_default_exec:s0
/vendor/bin/hw/vendor\.lineage\.livedisplay@2\.1-service\.xiaomi_sm6150 u:object_r:hal_lineage_livedisplay_qti_exec:s0
# IR