hidl: livedisplay: Add binderized service implementation

* Change default ::implementation namespace to ::samsung
* Fill in required methods for used impls
* Cleanup passthrough code for used impls
* Remove unused impls
* Add and setup binderized service

Change-Id: I545a7c0ac8bf4fce04da73a0d39d4ac1938496f2
tirimbino
Jan Altensen 6 years ago committed by Kevin Haggerty
parent 1a8433638a
commit 4e47a0bc91
  1. 40
      lineagehw/hidl/livedisplay/AdaptiveBacklight.cpp
  2. 12
      lineagehw/hidl/livedisplay/AdaptiveBacklight.h
  3. 74
      lineagehw/hidl/livedisplay/Android.bp
  4. 47
      lineagehw/hidl/livedisplay/AutoContrast.cpp
  5. 52
      lineagehw/hidl/livedisplay/ColorBalance.cpp
  6. 57
      lineagehw/hidl/livedisplay/ColorBalance.h
  7. 47
      lineagehw/hidl/livedisplay/ColorEnhancement.cpp
  8. 52
      lineagehw/hidl/livedisplay/DisplayColorCalibration.cpp
  9. 23
      lineagehw/hidl/livedisplay/DisplayColorCalibration.h
  10. 77
      lineagehw/hidl/livedisplay/DisplayColorCalibrationExynos.cpp
  11. 28
      lineagehw/hidl/livedisplay/DisplayColorCalibrationExynos.h
  12. 106
      lineagehw/hidl/livedisplay/DisplayModes.cpp
  13. 23
      lineagehw/hidl/livedisplay/DisplayModes.h
  14. 77
      lineagehw/hidl/livedisplay/PictureAdjustment.cpp
  15. 62
      lineagehw/hidl/livedisplay/PictureAdjustment.h
  16. 37
      lineagehw/hidl/livedisplay/ReadingEnhancement.cpp
  17. 14
      lineagehw/hidl/livedisplay/ReadingEnhancement.h
  18. 57
      lineagehw/hidl/livedisplay/SunlightEnhancement.cpp
  19. 15
      lineagehw/hidl/livedisplay/SunlightEnhancement.h
  20. 64
      lineagehw/hidl/livedisplay/SunlightEnhancementExynos.cpp
  21. 22
      lineagehw/hidl/livedisplay/SunlightEnhancementExynos.h
  22. 4
      lineagehw/hidl/livedisplay/lineage.livedisplay@2.0-service.samsung-exynos.rc
  23. 4
      lineagehw/hidl/livedisplay/lineage.livedisplay@2.0-service.samsung-qcom.rc
  24. 145
      lineagehw/hidl/livedisplay/service.cpp
  25. 145
      lineagehw/hidl/livedisplay/serviceExynos.cpp
  26. 4
      lineagehw/hidl/livedisplay/vendor.lineage.livedisplay@2.0-service.samsung-exynos.rc
  27. 4
      lineagehw/hidl/livedisplay/vendor.lineage.livedisplay@2.0-service.samsung-qcom.rc

@ -14,33 +14,47 @@
* limitations under the License.
*/
#include <android-base/file.h>
#include <android-base/strings.h>
#include <fstream>
#include "AdaptiveBacklight.h"
using android::base::ReadFileToString;
using android::base::Trim;
using android::base::WriteStringToFile;
namespace vendor {
namespace lineage {
namespace livedisplay {
namespace V2_0 {
namespace implementation {
namespace samsung {
static constexpr const char *kBacklightPath = "/sys/class/lcd/panel/power_reduce";
bool AdaptiveBacklight::isSupported() {
std::fstream backlight(kBacklightPath, backlight.in | backlight.out);
return backlight.good();
}
// Methods from ::vendor::lineage::livedisplay::V2_0::IAdaptiveBacklight follow.
Return<bool> AdaptiveBacklight::isEnabled() {
// TODO implement
return bool {};
std::string tmp;
int32_t contents = 0;
if (ReadFileToString(kBacklightPath, &tmp)) {
contents = std::stoi(Trim(tmp));
}
return contents > 0;
}
Return<bool> AdaptiveBacklight::setEnabled(bool enabled) {
// TODO implement
return bool {};
return WriteStringToFile(enabled ? "1" : "0", kBacklightPath, true);
}
// Methods from ::android::hidl::base::V1_0::IBase follow.
//IAdaptiveBacklight* HIDL_FETCH_IAdaptiveBacklight(const char* /* name */) {
//return new AdaptiveBacklight();
//}
//
} // namespace implementation
} // namespace samsung
} // namespace V2_0
} // namespace livedisplay
} // namespace lineage

@ -25,7 +25,7 @@ namespace vendor {
namespace lineage {
namespace livedisplay {
namespace V2_0 {
namespace implementation {
namespace samsung {
using ::android::hardware::hidl_array;
using ::android::hardware::hidl_memory;
@ -35,7 +35,10 @@ using ::android::hardware::Return;
using ::android::hardware::Void;
using ::android::sp;
struct AdaptiveBacklight : public IAdaptiveBacklight {
class AdaptiveBacklight : public IAdaptiveBacklight {
public:
bool isSupported();
// Methods from ::vendor::lineage::livedisplay::V2_0::IAdaptiveBacklight follow.
Return<bool> isEnabled() override;
Return<bool> setEnabled(bool enabled) override;
@ -44,10 +47,7 @@ struct AdaptiveBacklight : public IAdaptiveBacklight {
};
// FIXME: most likely delete, this is only for passthrough implementations
// extern "C" IAdaptiveBacklight* HIDL_FETCH_IAdaptiveBacklight(const char* name);
} // namespace implementation
} // namespace samsung
} // namespace V2_0
} // namespace livedisplay
} // namespace lineage

@ -12,36 +12,74 @@
// See the License for the specific language governing permissions and
// limitations under the License.
cc_library_shared {
// FIXME: this should only be -impl for a passthrough hal.
// In most cases, to convert this to a binderized implementation, you should:
// - change '-impl' to '-service' here and make it a cc_binary instead of a
// cc_library_shared.
// - add a *.rc file for this module.
// - delete HIDL_FETCH_I* functions.
// - call configureRpcThreadpool and registerAsService on the instance.
// You may also want to append '-impl/-service' with a specific identifier like
// '-vendor' or '-<hardware identifier>' etc to distinguish it.
name: "vendor.lineage.livedisplay@2.0-impl",
cc_defaults {
name: "livedisplay_samsung_exynos_defaults",
defaults: ["hidl_defaults"],
relative_install_path: "hw",
srcs: [
"AdaptiveBacklight.cpp",
"DisplayColorCalibrationExynos.cpp",
"DisplayModes.cpp",
"ReadingEnhancement.cpp",
"SunlightEnhancementExynos.cpp",
"serviceExynos.cpp",
],
shared_libs: [
"libbase",
"libbinder",
"libhidlbase",
"libhidltransport",
"libutils",
"vendor.lineage.livedisplay@2.0",
],
}
cc_defaults {
name: "livedisplay_samsung_qcom_defaults",
defaults: ["hidl_defaults"],
relative_install_path: "hw",
// FIXME: this should be 'vendor: true' for modules that will eventually be
// on AOSP.
proprietary: true,
srcs: [
"AdaptiveBacklight.cpp",
"AutoContrast.cpp",
"ColorBalance.cpp",
"ColorEnhancement.cpp",
"DisplayColorCalibration.cpp",
"DisplayModes.cpp",
"PictureAdjustment.cpp",
"ReadingEnhancement.cpp",
"SunlightEnhancement.cpp",
"service.cpp",
],
shared_libs: [
"libbase",
"libbinder",
"libhidlbase",
"libhidltransport",
"libutils",
"vendor.lineage.livedisplay@2.0",
],
}
cc_binary {
name: "lineage.livedisplay@2.0-service.samsung-exynos",
init_rc: ["lineage.livedisplay@2.0-service.samsung-exynos.rc"],
defaults: ["livedisplay_samsung_exynos_defaults"],
cflags: ["-DLIVES_IN_SYSTEM"],
}
cc_binary {
name: "vendor.lineage.livedisplay@2.0-service.samsung-exynos",
init_rc: ["vendor.lineage.livedisplay@2.0-service.samsung-exynos.rc"],
defaults: ["livedisplay_samsung_exynos_defaults"],
vendor: true,
}
cc_binary {
name: "lineage.livedisplay@2.0-service.samsung-qcom",
init_rc: ["lineage.livedisplay@2.0-service.samsung-qcom.rc"],
defaults: ["livedisplay_samsung_qcom_defaults"],
cflags: ["-DLIVES_IN_SYSTEM"],
}
cc_binary {
name: "vendor.lineage.livedisplay@2.0-service.samsung-qcom",
init_rc: ["vendor.lineage.livedisplay@2.0-service.samsung-qcom.rc"],
defaults: ["livedisplay_samsung_qcom_defaults"],
vendor: true,
}

@ -1,47 +0,0 @@
/*
* Copyright (C) 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.
* 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.
*/
#include "AutoContrast.h"
namespace vendor {
namespace lineage {
namespace livedisplay {
namespace V2_0 {
namespace implementation {
// Methods from ::vendor::lineage::livedisplay::V2_0::IAutoContrast follow.
Return<bool> AutoContrast::isEnabled() {
// TODO implement
return bool {};
}
Return<bool> AutoContrast::setEnabled(bool enabled) {
// TODO implement
return bool {};
}
// Methods from ::android::hidl::base::V1_0::IBase follow.
//IAutoContrast* HIDL_FETCH_IAutoContrast(const char* /* name */) {
//return new AutoContrast();
//}
//
} // namespace implementation
} // namespace V2_0
} // namespace livedisplay
} // namespace lineage
} // namespace vendor

@ -1,52 +0,0 @@
/*
* Copyright (C) 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.
* 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.
*/
#include "ColorBalance.h"
namespace vendor {
namespace lineage {
namespace livedisplay {
namespace V2_0 {
namespace implementation {
// Methods from ::vendor::lineage::livedisplay::V2_0::IColorBalance follow.
Return<void> ColorBalance::getColorBalanceRange(getColorBalanceRange_cb _hidl_cb) {
// TODO implement
return Void();
}
Return<int32_t> ColorBalance::getColorBalance() {
// TODO implement
return int32_t {};
}
Return<bool> ColorBalance::setColorBalance(int32_t value) {
// TODO implement
return bool {};
}
// Methods from ::android::hidl::base::V1_0::IBase follow.
//IColorBalance* HIDL_FETCH_IColorBalance(const char* /* name */) {
//return new ColorBalance();
//}
//
} // namespace implementation
} // namespace V2_0
} // namespace livedisplay
} // namespace lineage
} // namespace vendor

@ -1,57 +0,0 @@
/*
* Copyright (C) 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.
* 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 VENDOR_LINEAGE_LIVEDISPLAY_V2_0_COLORBALANCE_H
#define VENDOR_LINEAGE_LIVEDISPLAY_V2_0_COLORBALANCE_H
#include <vendor/lineage/livedisplay/2.0/IColorBalance.h>
#include <hidl/MQDescriptor.h>
#include <hidl/Status.h>
namespace vendor {
namespace lineage {
namespace livedisplay {
namespace V2_0 {
namespace implementation {
using ::android::hardware::hidl_array;
using ::android::hardware::hidl_memory;
using ::android::hardware::hidl_string;
using ::android::hardware::hidl_vec;
using ::android::hardware::Return;
using ::android::hardware::Void;
using ::android::sp;
struct ColorBalance : public IColorBalance {
// Methods from ::vendor::lineage::livedisplay::V2_0::IColorBalance follow.
Return<void> getColorBalanceRange(getColorBalanceRange_cb _hidl_cb) override;
Return<int32_t> getColorBalance() override;
Return<bool> setColorBalance(int32_t value) override;
// Methods from ::android::hidl::base::V1_0::IBase follow.
};
// FIXME: most likely delete, this is only for passthrough implementations
// extern "C" IColorBalance* HIDL_FETCH_IColorBalance(const char* name);
} // namespace implementation
} // namespace V2_0
} // namespace livedisplay
} // namespace lineage
} // namespace vendor
#endif // VENDOR_LINEAGE_LIVEDISPLAY_V2_0_COLORBALANCE_H

@ -1,47 +0,0 @@
/*
* Copyright (C) 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.
* 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.
*/
#include "ColorEnhancement.h"
namespace vendor {
namespace lineage {
namespace livedisplay {
namespace V2_0 {
namespace implementation {
// Methods from ::vendor::lineage::livedisplay::V2_0::IColorEnhancement follow.
Return<bool> ColorEnhancement::isEnabled() {
// TODO implement
return bool {};
}
Return<bool> ColorEnhancement::setEnabled(bool enabled) {
// TODO implement
return bool {};
}
// Methods from ::android::hidl::base::V1_0::IBase follow.
//IColorEnhancement* HIDL_FETCH_IColorEnhancement(const char* /* name */) {
//return new ColorEnhancement();
//}
//
} // namespace implementation
} // namespace V2_0
} // namespace livedisplay
} // namespace lineage
} // namespace vendor

@ -14,43 +14,65 @@
* limitations under the License.
*/
#include <android-base/file.h>
#include <android-base/strings.h>
#include <fstream>
#include "DisplayColorCalibration.h"
using android::base::ReadFileToString;
using android::base::Split;
using android::base::Trim;
using android::base::WriteStringToFile;
namespace vendor {
namespace lineage {
namespace livedisplay {
namespace V2_0 {
namespace implementation {
namespace samsung {
bool DisplayColorCalibration::isSupported() {
std::fstream rgb(FILE_RGB, rgb.in | rgb.out);
return rgb.good();
}
// Methods from ::vendor::lineage::livedisplay::V2_0::IDisplayColorCalibration follow.
Return<int32_t> DisplayColorCalibration::getMaxValue() {
// TODO implement
return int32_t {};
return 32768;
}
Return<int32_t> DisplayColorCalibration::getMinValue() {
// TODO implement
return int32_t {};
return 255;
}
Return<void> DisplayColorCalibration::getCalibration(getCalibration_cb _hidl_cb) {
// TODO implement
std::vector<int32_t> rgb;
std::string tmp;
if (ReadFileToString(FILE_RGB, &tmp)) {
std::vector<std::string> colors = Split(Trim(tmp), " ");
for (const std::string& color : colors) {
rgb.push_back(std::stoi(color));
}
}
_hidl_cb(rgb);
return Void();
}
Return<bool> DisplayColorCalibration::setCalibration(const hidl_vec<int32_t>& rgb) {
// TODO implement
return bool {};
}
std::string contents;
for (const int32_t& color : rgb) {
contents += std::to_string(color) + " ";
}
// Methods from ::android::hidl::base::V1_0::IBase follow.
return WriteStringToFile(Trim(contents), FILE_RGB, true);
}
//IDisplayColorCalibration* HIDL_FETCH_IDisplayColorCalibration(const char* /* name */) {
//return new DisplayColorCalibration();
//}
//
} // namespace implementation
} // namespace samsung
} // namespace V2_0
} // namespace livedisplay
} // namespace lineage

@ -18,38 +18,31 @@
#define VENDOR_LINEAGE_LIVEDISPLAY_V2_0_DISPLAYCOLORCALIBRATION_H
#include <vendor/lineage/livedisplay/2.0/IDisplayColorCalibration.h>
#include <hidl/MQDescriptor.h>
#include <hidl/Status.h>
namespace vendor {
namespace lineage {
namespace livedisplay {
namespace V2_0 {
namespace implementation {
namespace samsung {
using ::android::hardware::hidl_array;
using ::android::hardware::hidl_memory;
using ::android::hardware::hidl_string;
using ::android::hardware::hidl_vec;
using ::android::hardware::Return;
using ::android::hardware::Void;
using ::android::sp;
struct DisplayColorCalibration : public IDisplayColorCalibration {
#define FILE_RGB "/sys/class/graphics/fb0/rgb"
class DisplayColorCalibration : public IDisplayColorCalibration {
public:
bool isSupported();
// Methods from ::vendor::lineage::livedisplay::V2_0::IDisplayColorCalibration follow.
Return<int32_t> getMaxValue() override;
Return<int32_t> getMinValue() override;
Return<void> getCalibration(getCalibration_cb _hidl_cb) override;
Return<bool> setCalibration(const hidl_vec<int32_t>& rgb) override;
// Methods from ::android::hidl::base::V1_0::IBase follow.
};
// FIXME: most likely delete, this is only for passthrough implementations
// extern "C" IDisplayColorCalibration* HIDL_FETCH_IDisplayColorCalibration(const char* name);
} // namespace implementation
} // namespace samsung
} // namespace V2_0
} // namespace livedisplay
} // namespace lineage

@ -0,0 +1,77 @@
/*
* Copyright (C) 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.
* 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.
*/
#include <android-base/file.h>
#include <android-base/strings.h>
#include <fstream>
#include "DisplayColorCalibrationExynos.h"
using android::base::ReadFileToString;
using android::base::Split;
using android::base::Trim;
using android::base::WriteStringToFile;
namespace vendor {
namespace lineage {
namespace livedisplay {
namespace V2_0 {
namespace samsung {
static constexpr const char *kColorPath = "/sys/class/mdnie/mdnie/sensorRGB";
bool DisplayColorCalibrationExynos::isSupported() {
std::fstream rgb(kColorPath, rgb.in | rgb.out);
return rgb.good();
}
Return<int32_t> DisplayColorCalibrationExynos::getMaxValue() {
return 255;
}
Return<int32_t> DisplayColorCalibrationExynos::getMinValue() {
return 1;
}
Return<void> DisplayColorCalibrationExynos::getCalibration(getCalibration_cb resultCb) {
std::vector<int32_t> rgb;
std::string tmp;
if (ReadFileToString(kColorPath, &tmp)) {
std::vector<std::string> colors = Split(Trim(tmp), " ");
for (const std::string& color : colors) {
rgb.push_back(std::stoi(color));
}
}
resultCb(rgb);
return Void();
}
Return<bool> DisplayColorCalibrationExynos::setCalibration(const hidl_vec<int32_t>& rgb) {
std::string contents;
for (const int32_t& color : rgb) {
contents += std::to_string(color) + " ";
}
return WriteStringToFile(Trim(contents), kColorPath, true);
}
} // namespace samsung
} // namespace V2_0
} // namespace livedisplay
} // namespace lineage
} // namespace vendor

@ -14,10 +14,10 @@
* limitations under the License.
*/
#ifndef VENDOR_LINEAGE_LIVEDISPLAY_V2_0_COLORENHANCEMENT_H
#define VENDOR_LINEAGE_LIVEDISPLAY_V2_0_COLORENHANCEMENT_H
#ifndef VENDOR_LINEAGE_LIVEDISPLAY_V2_0_DISPLAYCOLORCALIBRATIONEXYNOS_H
#define VENDOR_LINEAGE_LIVEDISPLAY_V2_0_DISPLAYCOLORCALIBRATIONEXYNOS_H
#include <vendor/lineage/livedisplay/2.0/IColorEnhancement.h>
#include <vendor/lineage/livedisplay/2.0/IDisplayColorCalibration.h>
#include <hidl/MQDescriptor.h>
#include <hidl/Status.h>
@ -25,7 +25,7 @@ namespace vendor {
namespace lineage {
namespace livedisplay {
namespace V2_0 {
namespace implementation {
namespace samsung {
using ::android::hardware::hidl_array;
using ::android::hardware::hidl_memory;
@ -35,22 +35,24 @@ using ::android::hardware::Return;
using ::android::hardware::Void;
using ::android::sp;
struct ColorEnhancement : public IColorEnhancement {
// Methods from ::vendor::lineage::livedisplay::V2_0::IColorEnhancement follow.
Return<bool> isEnabled() override;
Return<bool> setEnabled(bool enabled) override;
class DisplayColorCalibrationExynos : public IDisplayColorCalibration {
public:
bool isSupported();
// Methods from ::vendor::lineage::livedisplay::V2_0::IDisplayColorCalibration follow.
Return<int32_t> getMaxValue() override;
Return<int32_t> getMinValue() override;
Return<void> getCalibration(getCalibration_cb resultCb) override;
Return<bool> setCalibration(const hidl_vec<int32_t>& rgb) override;
// Methods from ::android::hidl::base::V1_0::IBase follow.
};
// FIXME: most likely delete, this is only for passthrough implementations
// extern "C" IColorEnhancement* HIDL_FETCH_IColorEnhancement(const char* name);
} // namespace implementation
} // namespace samsung
} // namespace V2_0
} // namespace livedisplay
} // namespace lineage
} // namespace vendor
#endif // VENDOR_LINEAGE_LIVEDISPLAY_V2_0_COLORENHANCEMENT_H
#endif // VENDOR_LINEAGE_LIVEDISPLAY_V2_0_DISPLAYCOLORCALIBRATIONEXYNOS_H

@ -14,43 +14,121 @@
* limitations under the License.
*/
#define LOG_TAG "DisplayModesService"
#include "DisplayModes.h"
#include <android-base/logging.h>
#include <fstream>
namespace vendor {
namespace lineage {
namespace livedisplay {
namespace V2_0 {
namespace implementation {
namespace samsung {
static constexpr const char* kModePath = "/sys/class/mdnie/mdnie/mode";
static constexpr const char* kModeMaxPath = "/sys/class/mdnie/mdnie/mode_max";
static constexpr const char* kDefaultPath = "/data/misc/.displaymodedefault";
const std::map<int32_t, std::string> DisplayModes::kModeMap = {
{0, "Dynamic"},
{1, "Standard"},
{2, "Natural"},
{3, "Cinema"},
{4, "Adaptive"},
{5, "Reading"},
};
DisplayModes::DisplayModes() : mDefaultModeId(0) {
std::ifstream defaultFile(kDefaultPath);
int value;
defaultFile >> value;
LOG(DEBUG) << "Default file read result " << value << " fail " << defaultFile.fail();
if (defaultFile.fail()) {
return;
}
for (const auto& entry : kModeMap) {
if (value == entry.first) {
mDefaultModeId = entry.first;
break;
}
}
}
bool DisplayModes::isSupported() {
std::ofstream modeFile(kModePath);
return modeFile.good();
}
// Methods from ::vendor::lineage::livedisplay::V2_0::IDisplayModes follow.
Return<void> DisplayModes::getDisplayModes(getDisplayModes_cb _hidl_cb) {
// TODO implement
Return<void> DisplayModes::getDisplayModes(getDisplayModes_cb resultCb) {
std::ifstream maxModeFile(kModeMaxPath);
int value;
std::vector<DisplayMode> modes;
if (!maxModeFile.fail()) {
maxModeFile >> value;
} else {
value = kModeMap.size();
}
for (const auto& entry : kModeMap) {
if (entry.first < value)
modes.push_back({entry.first, entry.second});
}
resultCb(modes);
return Void();
}
Return<void> DisplayModes::getCurrentDisplayMode(getCurrentDisplayMode_cb _hidl_cb) {
// TODO implement
Return<void> DisplayModes::getCurrentDisplayMode(getCurrentDisplayMode_cb resultCb) {
int32_t currentModeId = mDefaultModeId;
std::ifstream modeFile(kModePath);
int value;
modeFile >> value;
if (!modeFile.fail()) {
for (const auto& entry : kModeMap) {
if (value == entry.first) {
currentModeId = entry.first;
break;
}
}
}
resultCb({currentModeId, kModeMap.at(currentModeId)});
return Void();
}
Return<void> DisplayModes::getDefaultDisplayMode(getDefaultDisplayMode_cb _hidl_cb) {
// TODO implement
Return<void> DisplayModes::getDefaultDisplayMode(getDefaultDisplayMode_cb resultCb) {
resultCb({mDefaultModeId, kModeMap.at(mDefaultModeId)});
return Void();
}
Return<bool> DisplayModes::setDisplayMode(int32_t modeID, bool makeDefault) {
// TODO implement
return bool {};
const auto iter = kModeMap.find(modeID);
if (iter == kModeMap.end()) {
return false;
}
std::ofstream modeFile(kModePath);
modeFile << iter->first;
if (modeFile.fail()) {
return false;
}
if (makeDefault) {
std::ofstream defaultFile(kDefaultPath);
defaultFile << iter->first;
if (defaultFile.fail()) {
return false;
}
mDefaultModeId = iter->first;
}
return true;
}
// Methods from ::android::hidl::base::V1_0::IBase follow.
//IDisplayModes* HIDL_FETCH_IDisplayModes(const char* /* name */) {
//return new DisplayModes();
//}
//
} // namespace implementation
} // namespace samsung
} // namespace V2_0
} // namespace livedisplay
} // namespace lineage

@ -25,7 +25,7 @@ namespace vendor {
namespace lineage {
namespace livedisplay {
namespace V2_0 {
namespace implementation {
namespace samsung {
using ::android::hardware::hidl_array;
using ::android::hardware::hidl_memory;
@ -35,21 +35,24 @@ using ::android::hardware::Return;
using ::android::hardware::Void;
using ::android::sp;
struct DisplayModes : public IDisplayModes {
class DisplayModes : public IDisplayModes {
public:
DisplayModes();
bool isSupported();
// Methods from ::vendor::lineage::livedisplay::V2_0::IDisplayModes follow.
Return<void> getDisplayModes(getDisplayModes_cb _hidl_cb) override;
Return<void> getCurrentDisplayMode(getCurrentDisplayMode_cb _hidl_cb) override;
Return<void> getDefaultDisplayMode(getDefaultDisplayMode_cb _hidl_cb) override;
Return<void> getDisplayModes(getDisplayModes_cb resultCb) override;
Return<void> getCurrentDisplayMode(getCurrentDisplayMode_cb resultCb) override;
Return<void> getDefaultDisplayMode(getDefaultDisplayMode_cb resultCb) override;
Return<bool> setDisplayMode(int32_t modeID, bool makeDefault) override;
// Methods from ::android::hidl::base::V1_0::IBase follow.
private:
static const std::map<int32_t, std::string> kModeMap;
int32_t mDefaultModeId;
};
// FIXME: most likely delete, this is only for passthrough implementations
// extern "C" IDisplayModes* HIDL_FETCH_IDisplayModes(const char* name);
} // namespace implementation
} // namespace samsung
} // namespace V2_0
} // namespace livedisplay
} // namespace lineage

@ -1,77 +0,0 @@
/*
* Copyright (C) 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.
* 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.
*/
#include "PictureAdjustment.h"
namespace vendor {
namespace lineage {
namespace livedisplay {
namespace V2_0 {
namespace implementation {
// Methods from ::vendor::lineage::livedisplay::V2_0::IPictureAdjustment follow.
Return<void> PictureAdjustment::getHueRange(getHueRange_cb _hidl_cb) {
// TODO implement
return Void();
}
Return<void> PictureAdjustment::getSaturationRange(getSaturationRange_cb _hidl_cb) {
// TODO implement
return Void();
}
Return<void> PictureAdjustment::getIntensityRange(getIntensityRange_cb _hidl_cb) {
// TODO implement
return Void();
}
Return<void> PictureAdjustment::getContrastRange(getContrastRange_cb _hidl_cb) {
// TODO implement
return Void();
}
Return<void> PictureAdjustment::getSaturationThresholdRange(getSaturationThresholdRange_cb _hidl_cb) {
// TODO implement
return Void();
}
Return<void> PictureAdjustment::getPictureAdjustment(getPictureAdjustment_cb _hidl_cb) {
// TODO implement
return Void();
}
Return<void> PictureAdjustment::getDefaultPictureAdjustment(getDefaultPictureAdjustment_cb _hidl_cb) {
// TODO implement
return Void();
}
Return<bool> PictureAdjustment::setPictureAdjustment(const ::vendor::lineage::livedisplay::V2_0::HSIC& hsic) {
// TODO implement
return bool {};
}
// Methods from ::android::hidl::base::V1_0::IBase follow.
//IPictureAdjustment* HIDL_FETCH_IPictureAdjustment(const char* /* name */) {
//return new PictureAdjustment();
//}
//
} // namespace implementation
} // namespace V2_0
} // namespace livedisplay
} // namespace lineage
} // namespace vendor

@ -1,62 +0,0 @@
/*
* Copyright (C) 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.
* 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 VENDOR_LINEAGE_LIVEDISPLAY_V2_0_PICTUREADJUSTMENT_H
#define VENDOR_LINEAGE_LIVEDISPLAY_V2_0_PICTUREADJUSTMENT_H
#include <vendor/lineage/livedisplay/2.0/IPictureAdjustment.h>
#include <hidl/MQDescriptor.h>
#include <hidl/Status.h>
namespace vendor {
namespace lineage {
namespace livedisplay {
namespace V2_0 {
namespace implementation {
using ::android::hardware::hidl_array;
using ::android::hardware::hidl_memory;
using ::android::hardware::hidl_string;
using ::android::hardware::hidl_vec;
using ::android::hardware::Return;
using ::android::hardware::Void;
using ::android::sp;
struct PictureAdjustment : public IPictureAdjustment {
// Methods from ::vendor::lineage::livedisplay::V2_0::IPictureAdjustment follow.
Return<void> getHueRange(getHueRange_cb _hidl_cb) override;
Return<void> getSaturationRange(getSaturationRange_cb _hidl_cb) override;
Return<void> getIntensityRange(getIntensityRange_cb _hidl_cb) override;
Return<void> getContrastRange(getContrastRange_cb _hidl_cb) override;
Return<void> getSaturationThresholdRange(getSaturationThresholdRange_cb _hidl_cb) override;
Return<void> getPictureAdjustment(getPictureAdjustment_cb _hidl_cb) override;
Return<void> getDefaultPictureAdjustment(getDefaultPictureAdjustment_cb _hidl_cb) override;
Return<bool> setPictureAdjustment(const ::vendor::lineage::livedisplay::V2_0::HSIC& hsic) override;
// Methods from ::android::hidl::base::V1_0::IBase follow.
};
// FIXME: most likely delete, this is only for passthrough implementations
// extern "C" IPictureAdjustment* HIDL_FETCH_IPictureAdjustment(const char* name);
} // namespace implementation
} // namespace V2_0
} // namespace livedisplay
} // namespace lineage
} // namespace vendor
#endif // VENDOR_LINEAGE_LIVEDISPLAY_V2_0_PICTUREADJUSTMENT_H

@ -14,33 +14,50 @@
* limitations under the License.
*/
#include <android-base/file.h>
#include <android-base/strings.h>
#include <fstream>
#include "ReadingEnhancement.h"
using android::base::ReadFileToString;
using android::base::Trim;
using android::base::WriteStringToFile;
namespace vendor {
namespace lineage {
namespace livedisplay {
namespace V2_0 {
namespace implementation {
namespace samsung {
static constexpr const char *kREPath = "/sys/class/mdnie/mdnie/accessibility";
// Methods from ::vendor::lineage::livedisplay::V2_0::ISunlightEnhancement follow.
bool ReadingEnhancement::isSupported() {
std::fstream re(kREPath, re.in | re.out);
return re.good();
}
// Methods from ::vendor::lineage::livedisplay::V2_0::IReadingEnhancement follow.
Return<bool> ReadingEnhancement::isEnabled() {
// TODO implement
return bool {};
std::string contents;
if (ReadFileToString(kREPath, &contents)) {
contents = Trim(contents);
}
return !contents.compare("Current accessibility : DSI0 : GRAYSCALE ") || !contents.compare("4");
}
Return<bool> ReadingEnhancement::setEnabled(bool enabled) {
// TODO implement
return bool {};
return WriteStringToFile(enabled ? "4" : "0", kREPath, true);
}
// Methods from ::android::hidl::base::V1_0::IBase follow.
//IReadingEnhancement* HIDL_FETCH_IReadingEnhancement(const char* /* name */) {
//return new ReadingEnhancement();
//}
//
} // namespace implementation
} // namespace samsung
} // namespace V2_0
} // namespace livedisplay
} // namespace lineage

@ -25,7 +25,7 @@ namespace vendor {
namespace lineage {
namespace livedisplay {
namespace V2_0 {
namespace implementation {
namespace samsung {
using ::android::hardware::hidl_array;
using ::android::hardware::hidl_memory;
@ -35,19 +35,19 @@ using ::android::hardware::Return;
using ::android::hardware::Void;
using ::android::sp;
struct ReadingEnhancement : public IReadingEnhancement {
class ReadingEnhancement : public IReadingEnhancement {
public:
bool isSupported();
// Methods from ::vendor::lineage::livedisplay::V2_0::IReadingEnhancement follow.
Return<bool> isEnabled() override;
Return<bool> setEnabled(bool enabled) override;
Return<bool> setEnabled(bool) override;
// Methods from ::android::hidl::base::V1_0::IBase follow.
};
// FIXME: most likely delete, this is only for passthrough implementations
// extern "C" IReadingEnhancement* HIDL_FETCH_IReadingEnhancement(const char* name);
} // namespace implementation
} // namespace samsung
} // namespace V2_0
} // namespace livedisplay
} // namespace lineage

@ -14,33 +14,64 @@
* limitations under the License.
*/
#include <android-base/file.h>
#include <android-base/strings.h>
#include <fstream>
#include "SunlightEnhancement.h"
using android::base::ReadFileToString;
using android::base::Trim;
using android::base::WriteStringToFile;
namespace vendor {
namespace lineage {
namespace livedisplay {
namespace V2_0 {
namespace implementation {
namespace samsung {
static constexpr const char *kHBMPath = "/sys/class/lcd/panel/panel/auto_brightness";
static constexpr const char *kSREPath = "/sys/class/mdnie/mdnie/outdoor";
// Methods from ::vendor::lineage::livedisplay::V2_0::ISunlightEnhancement follow.
Return<bool> SunlightEnhancement::isEnabled() {
// TODO implement
return bool {};
bool SunlightEnhancement::isSupported() {
std::fstream sre(kSREPath, sre.in | sre.out);
std::fstream hbm(kHBMPath, hbm.in | hbm.out);
if (hbm.good()) {
mHasHBM = true;
}
return sre.good();
}
Return<bool> SunlightEnhancement::setEnabled(bool enabled) {
// TODO implement
return bool {};
// Methods from ::vendor::lineage::livedisplay::V2_0::IAdaptiveBacklight follow.
Return<bool> SunlightEnhancement::isEnabled() {
std::string tmp;
int32_t statusSRE = 0;
int32_t statusHBM = 0;
if (ReadFileToString(kSREPath, &tmp)) {
statusSRE = std::stoi(Trim(tmp));
}
if (mHasHBM && ReadFileToString(kHBMPath, &tmp)) {
statusHBM = std::stoi(Trim(tmp));
}
return ((statusSRE == 1 && statusHBM == 6) || statusSRE == 1);
}
Return<bool> SunlightEnhancement::setEnabled(bool enabled) {
if (mHasHBM) {
WriteStringToFile(enabled ? "6" : "0", kHBMPath, true);
}
// Methods from ::android::hidl::base::V1_0::IBase follow.
return WriteStringToFile(enabled ? "1" : "0", kSREPath, true);
}
//ISunlightEnhancement* HIDL_FETCH_ISunlightEnhancement(const char* /* name */) {
//return new SunlightEnhancement();
//}
//
} // namespace implementation
} // namespace samsung
} // namespace V2_0
} // namespace livedisplay
} // namespace lineage

@ -25,7 +25,7 @@ namespace vendor {
namespace lineage {
namespace livedisplay {
namespace V2_0 {
namespace implementation {
namespace samsung {
using ::android::hardware::hidl_array;
using ::android::hardware::hidl_memory;
@ -35,19 +35,20 @@ using ::android::hardware::Return;
using ::android::hardware::Void;
using ::android::sp;
struct SunlightEnhancement : public ISunlightEnhancement {
class SunlightEnhancement : public ISunlightEnhancement {
public:
bool isSupported();
// Methods from ::vendor::lineage::livedisplay::V2_0::ISunlightEnhancement follow.
Return<bool> isEnabled() override;
Return<bool> setEnabled(bool enabled) override;
// Methods from ::android::hidl::base::V1_0::IBase follow.
private:
bool mHasHBM = false;
};
// FIXME: most likely delete, this is only for passthrough implementations
// extern "C" ISunlightEnhancement* HIDL_FETCH_ISunlightEnhancement(const char* name);
} // namespace implementation
} // namespace samsung
} // namespace V2_0
} // namespace livedisplay
} // namespace lineage

@ -0,0 +1,64 @@
/*
* Copyright (C) 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.
* 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.
*/
#include <android-base/file.h>
#include <android-base/strings.h>
#include <fstream>
#include "SunlightEnhancementExynos.h"
using android::base::ReadFileToString;
using android::base::Trim;
using android::base::WriteStringToFile;
namespace vendor {
namespace lineage {
namespace livedisplay {
namespace V2_0 {
namespace samsung {
static constexpr const char *kLUXPath = "/sys/class/mdnie/mdnie/lux";
// Methods from ::vendor::lineage::livedisplay::V2_0::ISunlightEnhancement follow.
bool SunlightEnhancementExynos::isSupported() {
std::fstream file(kLUXPath, file.in | file.out);
return file.good();
}
// Methods from ::vendor::lineage::livedisplay::V2_0::IAdaptiveBacklight follow.
Return<bool> SunlightEnhancementExynos::isEnabled() {
std::string tmp;
int32_t contents = 0;
if (ReadFileToString(kLUXPath, &tmp)) {
contents = std::stoi(Trim(tmp));
}
return contents > 0;
}
Return<bool> SunlightEnhancementExynos::setEnabled(bool enabled) {
/* see drivers/video/fbdev/exynos/decon_7880/panels/mdnie_lite_table*, get_hbm_index */
return WriteStringToFile(enabled ? "40000" : "0", kLUXPath, true);
}
} // namespace samsung
} // namespace V2_0
} // namespace livedisplay
} // namespace lineage
} // namespace vendor

@ -14,10 +14,10 @@
* limitations under the License.
*/
#ifndef VENDOR_LINEAGE_LIVEDISPLAY_V2_0_AUTOCONTRAST_H
#define VENDOR_LINEAGE_LIVEDISPLAY_V2_0_AUTOCONTRAST_H
#ifndef VENDOR_LINEAGE_LIVEDISPLAY_V2_0_SUNLIGHTENHANCEMENTEXYNOS_H
#define VENDOR_LINEAGE_LIVEDISPLAY_V2_0_SUNLIGHTENHANCEMENTEXYNOS_H
#include <vendor/lineage/livedisplay/2.0/IAutoContrast.h>
#include <vendor/lineage/livedisplay/2.0/ISunlightEnhancement.h>
#include <hidl/MQDescriptor.h>
#include <hidl/Status.h>
@ -25,7 +25,7 @@ namespace vendor {
namespace lineage {
namespace livedisplay {
namespace V2_0 {
namespace implementation {
namespace samsung {
using ::android::hardware::hidl_array;
using ::android::hardware::hidl_memory;
@ -35,8 +35,11 @@ using ::android::hardware::Return;
using ::android::hardware::Void;
using ::android::sp;
struct AutoContrast : public IAutoContrast {
// Methods from ::vendor::lineage::livedisplay::V2_0::IAutoContrast follow.
class SunlightEnhancementExynos : public ISunlightEnhancement {
public:
bool isSupported();
// Methods from ::vendor::lineage::livedisplay::V2_0::ISunlightEnhancement follow.
Return<bool> isEnabled() override;
Return<bool> setEnabled(bool enabled) override;
@ -44,13 +47,10 @@ struct AutoContrast : public IAutoContrast {
};
// FIXME: most likely delete, this is only for passthrough implementations
// extern "C" IAutoContrast* HIDL_FETCH_IAutoContrast(const char* name);
} // namespace implementation
} // namespace samsung
} // namespace V2_0
} // namespace livedisplay
} // namespace lineage
} // namespace vendor
#endif // VENDOR_LINEAGE_LIVEDISPLAY_V2_0_AUTOCONTRAST_H
#endif // VENDOR_LINEAGE_LIVEDISPLAY_V2_0_SUNLIGHTENHANCEMENTEXYNOS_H

@ -0,0 +1,4 @@
service livedisplay-hal-2-0-samsung-exynos /system/bin/hw/lineage.livedisplay@2.0-service.samsung-exynos
class hal
user system
group system

@ -0,0 +1,4 @@
service livedisplay-hal-2-0-samsung-qcom /system/bin/hw/lineage.livedisplay@2.0-service.samsung-qcom
class late_start
user system
group system

@ -0,0 +1,145 @@
/*
* Copyright (C) 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.
* 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.
*/
#ifdef LIVES_IN_SYSTEM
#define LOG_TAG "lineage.livedisplay@2.0-service.samsung-qcom"
#else
#define LOG_TAG "vendor.lineage.livedisplay@2.0-service.samsung-qcom"
#endif
#include <android-base/logging.h>
#include <binder/ProcessState.h>
#include <hidl/HidlTransportSupport.h>
#include "AdaptiveBacklight.h"
#include "DisplayColorCalibration.h"
#include "DisplayModes.h"
#include "ReadingEnhancement.h"
#include "SunlightEnhancement.h"
using android::hardware::configureRpcThreadpool;
using android::hardware::joinRpcThreadpool;
using android::sp;
using android::status_t;
using android::OK;
using vendor::lineage::livedisplay::V2_0::samsung::AdaptiveBacklight;
using vendor::lineage::livedisplay::V2_0::samsung::DisplayColorCalibration;
using vendor::lineage::livedisplay::V2_0::samsung::DisplayModes;
using vendor::lineage::livedisplay::V2_0::samsung::ReadingEnhancement;
using vendor::lineage::livedisplay::V2_0::samsung::SunlightEnhancement;
int main() {
sp<AdaptiveBacklight> adaptiveBacklight;
sp<DisplayColorCalibration> displayColorCalibration;
sp<DisplayModes> displayModes;
sp<ReadingEnhancement> readingEnhancement;
sp<SunlightEnhancement> sunlightEnhancement;
status_t status;
LOG(INFO) << "LiveDisplay HAL service is starting.";
adaptiveBacklight = new AdaptiveBacklight();
if (adaptiveBacklight == nullptr) {
LOG(ERROR) << "Can not create an instance of LiveDisplay HAL AdaptiveBacklight Iface, exiting.";
goto shutdown;
}
displayColorCalibration = new DisplayColorCalibration();
if (displayColorCalibration == nullptr) {
LOG(ERROR) << "Can not create an instance of LiveDisplay HAL DisplayColorCalibration Iface, exiting.";
goto shutdown;
}
displayModes = new DisplayModes();
if (displayModes == nullptr) {
LOG(ERROR) << "Can not create an instance of LiveDisplay HAL DisplayModes Iface, exiting.";
goto shutdown;
}
readingEnhancement = new ReadingEnhancement();
if (readingEnhancement == nullptr) {
LOG(ERROR) << "Can not create an instance of LiveDisplay HAL ReadingEnhancement Iface, exiting.";
goto shutdown;
}
sunlightEnhancement = new SunlightEnhancement();
if (sunlightEnhancement == nullptr) {
LOG(ERROR) << "Can not create an instance of LiveDisplay HAL SunlightEnhancement Iface, exiting.";
goto shutdown;
}
configureRpcThreadpool(1, true /*callerWillJoin*/);
if (adaptiveBacklight->isSupported()) {
status = adaptiveBacklight->registerAsService();
if (status != OK) {
LOG(ERROR)
<< "Could not register service for LiveDisplay HAL AdaptiveBacklight Iface ("
<< status << ")";
goto shutdown;
}
}
if (displayColorCalibration->isSupported()) {
status = displayColorCalibration->registerAsService();
if (status != OK) {
LOG(ERROR)
<< "Could not register service for LiveDisplay HAL DisplayColorCalibration Iface ("
<< status << ")";
goto shutdown;
}
}
if (displayModes->isSupported()) {
status = displayModes->registerAsService();
if (status != OK) {
LOG(ERROR)
<< "Could not register service for LiveDisplay HAL DisplayModes Iface ("
<< status << ")";
goto shutdown;
}
}
if (readingEnhancement->isSupported()) {
status = readingEnhancement->registerAsService();
if (status != OK) {
LOG(ERROR)
<< "Could not register service for LiveDisplay HAL ReadingEnhancement Iface ("
<< status << ")";
goto shutdown;
}
}
if (sunlightEnhancement->isSupported()) {
status = sunlightEnhancement->registerAsService();
if (status != OK) {
LOG(ERROR)
<< "Could not register service for LiveDisplay HAL SunlightEnhancement Iface ("
<< status << ")";
goto shutdown;
}
}
LOG(INFO) << "LiveDisplay HAL service is ready.";
joinRpcThreadpool();
// Should not pass this line
shutdown:
// In normal operation, we don't expect the thread pool to shutdown
LOG(ERROR) << "LiveDisplay HAL service is shutting down.";
return 1;
}

@ -0,0 +1,145 @@
/*
* Copyright (C) 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.
* 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.
*/
#ifdef LIVES_IN_SYSTEM
#define LOG_TAG "lineage.livedisplay@2.0-service.samsung-exynos"
#else
#define LOG_TAG "vendor.lineage.livedisplay@2.0-service.samsung-exynos"
#endif
#include <android-base/logging.h>
#include <binder/ProcessState.h>
#include <hidl/HidlTransportSupport.h>
#include "AdaptiveBacklight.h"
#include "DisplayColorCalibrationExynos.h"
#include "DisplayModes.h"
#include "ReadingEnhancement.h"
#include "SunlightEnhancementExynos.h"
using android::hardware::configureRpcThreadpool;
using android::hardware::joinRpcThreadpool;
using android::sp;
using android::status_t;
using android::OK;
using vendor::lineage::livedisplay::V2_0::samsung::AdaptiveBacklight;
using vendor::lineage::livedisplay::V2_0::samsung::DisplayColorCalibrationExynos;
using vendor::lineage::livedisplay::V2_0::samsung::DisplayModes;
using vendor::lineage::livedisplay::V2_0::samsung::ReadingEnhancement;
using vendor::lineage::livedisplay::V2_0::samsung::SunlightEnhancementExynos;
int main() {
sp<AdaptiveBacklight> adaptiveBacklight;
sp<DisplayColorCalibrationExynos> displayColorCalibrationExynos;
sp<DisplayModes> displayModes;
sp<ReadingEnhancement> readingEnhancement;
sp<SunlightEnhancementExynos> sunlightEnhancementExynos;
status_t status;
LOG(INFO) << "LiveDisplay HAL service is starting.";
adaptiveBacklight = new AdaptiveBacklight();
if (adaptiveBacklight == nullptr) {
LOG(ERROR) << "Can not create an instance of LiveDisplay HAL AdaptiveBacklight Iface, exiting.";
goto shutdown;
}
displayColorCalibrationExynos = new DisplayColorCalibrationExynos();
if (displayColorCalibrationExynos == nullptr) {
LOG(ERROR) << "Can not create an instance of LiveDisplay HAL DisplayColorCalibration Iface, exiting.";
goto shutdown;
}
displayModes = new DisplayModes();
if (displayModes == nullptr) {
LOG(ERROR) << "Can not create an instance of LiveDisplay HAL DisplayModes Iface, exiting.";
goto shutdown;
}
readingEnhancement = new ReadingEnhancement();
if (readingEnhancement == nullptr) {
LOG(ERROR) << "Can not create an instance of LiveDisplay HAL ReadingEnhancement Iface, exiting.";
goto shutdown;
}
sunlightEnhancementExynos = new SunlightEnhancementExynos();
if (sunlightEnhancementExynos == nullptr) {
LOG(ERROR) << "Can not create an instance of LiveDisplay HAL SunlightEnhancement Iface, exiting.";
goto shutdown;
}
configureRpcThreadpool(1, true /*callerWillJoin*/);
if (adaptiveBacklight->isSupported()) {
status = adaptiveBacklight->registerAsService();
if (status != OK) {
LOG(ERROR)
<< "Could not register service for LiveDisplay HAL AdaptiveBacklight Iface ("
<< status << ")";
goto shutdown;
}
}
if (displayColorCalibrationExynos->isSupported()) {
status = displayColorCalibrationExynos->registerAsService();
if (status != OK) {
LOG(ERROR)
<< "Could not register service for LiveDisplay HAL DisplayColorCalibration Iface ("
<< status << ")";
goto shutdown;
}
}
if (displayModes->isSupported()) {
status = displayModes->registerAsService();
if (status != OK) {
LOG(ERROR)
<< "Could not register service for LiveDisplay HAL DisplayModes Iface ("
<< status << ")";
goto shutdown;
}
}
if (readingEnhancement->isSupported()) {
status = readingEnhancement->registerAsService();
if (status != OK) {
LOG(ERROR)
<< "Could not register service for LiveDisplay HAL ReadingEnhancement Iface ("
<< status << ")";
goto shutdown;
}
}
if (sunlightEnhancementExynos->isSupported()) {
status = sunlightEnhancementExynos->registerAsService();
if (status != OK) {
LOG(ERROR)
<< "Could not register service for LiveDisplay HAL SunlightEnhancement Iface ("
<< status << ")";
goto shutdown;
}
}
LOG(INFO) << "LiveDisplay HAL service is ready.";
joinRpcThreadpool();
// Should not pass this line
shutdown:
// In normal operation, we don't expect the thread pool to shutdown
LOG(ERROR) << "LiveDisplay HAL service is shutting down.";
return 1;
}

@ -0,0 +1,4 @@
service vendor.livedisplay-hal-2-0-samsung-exynos /vendor/bin/hw/vendor.lineage.livedisplay@2.0-service.samsung-exynos
class hal
user system
group system

@ -0,0 +1,4 @@
service vendor.livedisplay-hal-2-0-samsung-qcom /vendor/bin/hw/vendor.lineage.livedisplay@2.0-service.samsung-qcom
class late_start
user system
group system
Loading…
Cancel
Save