bunnypad/android_device_samsung_a20
Watch
1
0
Fork
You've already forked android_device_samsung_a20
 0
mirror of https://github.com/chararomandroid/android_device_samsung_a20 synced 2026-08-23 04:25:33 -04:00
Code Issues Projects Releases Packages Wiki Activity Actions

universal7885: run clang-format based on system-clang-format

Browse source 
* On every *.cpp *.h files

Signed-off-by: roynatech2544 <whiteshell2544@naver.com>
This commit is contained in:
roynatech2544 2021-12-12 20:37:53 +09:00
commit 098179eabb
No known key found for this signature in database
GPG key ID: 9675C32163D88D30
47 changed files with 1545 additions and 1709 deletions
Download patch file Download diff file Expand all files Collapse all files

24
universal7885-common/aidl/light/Lights.cpp
View file

@ -41,10 +41,12 @@ Lights::Lights() {
mLights.emplace(LightType::BACKLIGHT, mLights.emplace(LightType::BACKLIGHT,
std::bind(&Lights::handleBacklight, this, std::placeholders::_1)); std::bind(&Lights::handleBacklight, this, std::placeholders::_1));
#ifdef BUTTON_BRIGHTNESS_NODE #ifdef BUTTON_BRIGHTNESS_NODE
mLights.emplace(LightType::BUTTONS, std::bind(&Lights::handleButtons, this, std::placeholders::_1)); mLights.emplace(LightType::BUTTONS,
std::bind(&Lights::handleButtons, this, std::placeholders::_1));
#endif /* BUTTON_BRIGHTNESS_NODE */ #endif /* BUTTON_BRIGHTNESS_NODE */
#ifdef LED_BLINK_NODE #ifdef LED_BLINK_NODE
mLights.emplace(LightType::BATTERY, std::bind(&Lights::handleBattery, this, std::placeholders::_1)); mLights.emplace(LightType::BATTERY,
std::bind(&Lights::handleBattery, this, std::placeholders::_1));
mLights.emplace(LightType::NOTIFICATIONS, mLights.emplace(LightType::NOTIFICATIONS,
std::bind(&Lights::handleNotifications, this, std::placeholders::_1)); std::bind(&Lights::handleNotifications, this, std::placeholders::_1));
mLights.emplace(LightType::ATTENTION, mLights.emplace(LightType::ATTENTION,
@ -147,7 +149,7 @@ void Lights::setNotificationLED() {
state.color = calibrateColor(state.color & COLOR_MASK, adjusted_brightness); state.color = calibrateColor(state.color & COLOR_MASK, adjusted_brightness);
set(LED_BLINK_NODE, ::android::base::StringPrintf("0x%08x %d %d", state.color, state.flashOnMs, set(LED_BLINK_NODE, ::android::base::StringPrintf("0x%08x %d %d", state.color, state.flashOnMs,
state.flashOffMs)); state.flashOffMs));
#ifdef LED_BLN_NODE #ifdef LED_BLN_NODE
if (bln) { if (bln) {
@ -166,9 +168,10 @@ uint32_t Lights::calibrateColor(uint32_t color, int32_t brightness) {
} }
#endif /* LED_BLINK_NODE */ #endif /* LED_BLINK_NODE */
#define AutoHwLight(light) {.id = (int32_t)light, .type = light, .ordinal = 0} #define AutoHwLight(light) \
{ .id = (int32_t)light, .type = light, .ordinal = 0 }
ndk::ScopedAStatus Lights::getLights(std::vector<HwLight> *_aidl_return) { ndk::ScopedAStatus Lights::getLights(std::vector<HwLight>* _aidl_return) {
for (auto const& light : mLights) { for (auto const& light : mLights) {
_aidl_return->push_back(AutoHwLight(light.first)); _aidl_return->push_back(AutoHwLight(light.first));
} }
@ -179,11 +182,12 @@ ndk::ScopedAStatus Lights::getLights(std::vector<HwLight> *_aidl_return) {
uint32_t Lights::rgbToBrightness(const HwLightState& state) { uint32_t Lights::rgbToBrightness(const HwLightState& state) {
uint32_t color = state.color & COLOR_MASK; uint32_t color = state.color & COLOR_MASK;
return ((77 * ((color >> 16) & 0xff)) + (150 * ((color >> 8) & 0xff)) + (29 * (color & 0xff))) >> return ((77 * ((color >> 16) & 0xff)) + (150 * ((color >> 8) & 0xff)) +
(29 * (color & 0xff))) >>
8; 8;
} }
} // namespace light } // namespace light
} // namespace hardware } // namespace hardware
} // namespace android } // namespace android
} // namespace aidl } // namespace aidl

16
universal7885-common/aidl/light/Lights.h
View file

@ -10,8 +10,8 @@
#include <unordered_map> #include <unordered_map>
#include "samsung_lights.h" #include "samsung_lights.h"
using ::aidl::android::hardware::light::HwLightState;
using ::aidl::android::hardware::light::HwLight; using ::aidl::android::hardware::light::HwLight;
using ::aidl::android::hardware::light::HwLightState;
namespace aidl { namespace aidl {
namespace android { namespace android {
@ -19,13 +19,13 @@ namespace hardware {
namespace light { namespace light {
class Lights : public BnLights { class Lights : public BnLights {
public: public:
Lights(); Lights();
ndk::ScopedAStatus setLightState(int32_t id, const HwLightState& state) override; ndk::ScopedAStatus setLightState(int32_t id, const HwLightState& state) override;
ndk::ScopedAStatus getLights(std::vector<HwLight> *_aidl_return) override; ndk::ScopedAStatus getLights(std::vector<HwLight>* _aidl_return) override;
private: private:
void handleBacklight(const HwLightState& state); void handleBacklight(const HwLightState& state);
#ifdef BUTTON_BRIGHTNESS_NODE #ifdef BUTTON_BRIGHTNESS_NODE
void handleButtons(const HwLightState& state); void handleButtons(const HwLightState& state);
@ -48,7 +48,7 @@ private:
std::unordered_map<LightType, std::function<void(const HwLightState&)>> mLights; std::unordered_map<LightType, std::function<void(const HwLightState&)>> mLights;
}; };
} // namespace light } // namespace light
} // namespace hardware } // namespace hardware
} // namespace android } // namespace android
} // namespace aidl } // namespace aidl

4
universal7885-common/aidl/light/service.cpp
View file

@ -8,9 +8,9 @@
#include "Lights.h" #include "Lights.h"
#include <android-base/logging.h>
#include <android/binder_manager.h> #include <android/binder_manager.h>
#include <android/binder_process.h> #include <android/binder_process.h>
#include <android-base/logging.h>
using ::aidl::android::hardware::light::Lights; using ::aidl::android::hardware::light::Lights;
@ -23,5 +23,5 @@ int main() {
CHECK(status == STATUS_OK); CHECK(status == STATUS_OK);
ABinderProcess_joinThreadPool(); ABinderProcess_joinThreadPool();
return EXIT_FAILURE; // should not reach return EXIT_FAILURE; // should not reach
} }

19
universal7885-common/aidl/power-libperfmgr/InteractionHandler.cpp
View file

@ -36,7 +36,7 @@
static const std::vector<std::string> fb_idle_patch = {"/sys/class/drm/card0/device/idle_state", static const std::vector<std::string> fb_idle_patch = {"/sys/class/drm/card0/device/idle_state",
"/sys/class/graphics/fb0/idle_state"}; "/sys/class/graphics/fb0/idle_state"};
InteractionHandler::InteractionHandler(std::shared_ptr<HintManager> const &hint_manager) InteractionHandler::InteractionHandler(std::shared_ptr<HintManager> const& hint_manager)
: mState(INTERACTION_STATE_UNINITIALIZED), : mState(INTERACTION_STATE_UNINITIALIZED),
mWaitMs(100), mWaitMs(100),
mMinDurationMs(1400), mMinDurationMs(1400),
@ -50,10 +50,9 @@ InteractionHandler::~InteractionHandler() {
static int fb_idle_open(void) { static int fb_idle_open(void) {
int fd; int fd;
for (auto &path : fb_idle_patch) { for (auto& path : fb_idle_patch) {
fd = open(path.c_str(), O_RDONLY); fd = open(path.c_str(), O_RDONLY);
if (fd >= 0) if (fd >= 0) return fd;
return fd;
} }
ALOGE("Unable to open fb idle state path (%d)", errno); ALOGE("Unable to open fb idle state path (%d)", errno);
return -1; return -1;
@ -62,8 +61,7 @@ static int fb_idle_open(void) {
bool InteractionHandler::Init() { bool InteractionHandler::Init() {
std::lock_guard<std::mutex> lk(mLock); std::lock_guard<std::mutex> lk(mLock);
if (mState != INTERACTION_STATE_UNINITIALIZED) if (mState != INTERACTION_STATE_UNINITIALIZED) return true;
return true;
mIdleFd = fb_idle_open(); mIdleFd = fb_idle_open();
@ -84,8 +82,7 @@ bool InteractionHandler::Init() {
void InteractionHandler::Exit() { void InteractionHandler::Exit() {
std::unique_lock<std::mutex> lk(mLock); std::unique_lock<std::mutex> lk(mLock);
if (mState == INTERACTION_STATE_UNINITIALIZED) if (mState == INTERACTION_STATE_UNINITIALIZED) return;
return;
AbortWaitLocked(); AbortWaitLocked();
mState = INTERACTION_STATE_UNINITIALIZED; mState = INTERACTION_STATE_UNINITIALIZED;
@ -186,8 +183,7 @@ void InteractionHandler::Release() {
void InteractionHandler::AbortWaitLocked() { void InteractionHandler::AbortWaitLocked() {
uint64_t val = 1; uint64_t val = 1;
ssize_t ret = write(mEventFd, &val, sizeof(val)); ssize_t ret = write(mEventFd, &val, sizeof(val));
if (ret != sizeof(val)) if (ret != sizeof(val)) ALOGW("Unable to write to event fd (%zd)", ret);
ALOGW("Unable to write to event fd (%zd)", ret);
} }
void InteractionHandler::WaitForIdle(int32_t wait_ms, int32_t timeout_ms) { void InteractionHandler::WaitForIdle(int32_t wait_ms, int32_t timeout_ms) {
@ -253,8 +249,7 @@ void InteractionHandler::Routine() {
while (true) { while (true) {
lk.lock(); lk.lock();
mCond.wait(lk, [&] { return mState != INTERACTION_STATE_IDLE; }); mCond.wait(lk, [&] { return mState != INTERACTION_STATE_IDLE; });
if (mState == INTERACTION_STATE_UNINITIALIZED) if (mState == INTERACTION_STATE_UNINITIALIZED) return;
return;
mState = INTERACTION_STATE_WAITING; mState = INTERACTION_STATE_WAITING;
lk.unlock(); lk.unlock();

2
universal7885-common/aidl/power-libperfmgr/InteractionHandler.h
View file

@ -36,7 +36,7 @@ enum interaction_state {
class InteractionHandler { class InteractionHandler {
public: public:
InteractionHandler(std::shared_ptr<HintManager> const &hint_manager); InteractionHandler(std::shared_ptr<HintManager> const& hint_manager);
~InteractionHandler(); ~InteractionHandler();
bool Init(); bool Init();
void Exit(); void Exit();

10
universal7885-common/aidl/power-libperfmgr/Power.cpp
View file

@ -169,10 +169,10 @@ ndk::ScopedAStatus Power::setMode(Mode type, bool enabled) {
return ndk::ScopedAStatus::ok(); return ndk::ScopedAStatus::ok();
} }
ndk::ScopedAStatus Power::isModeSupported(Mode type, bool *_aidl_return) { ndk::ScopedAStatus Power::isModeSupported(Mode type, bool* _aidl_return) {
bool supported = mHintManager->IsHintSupported(toString(type)); bool supported = mHintManager->IsHintSupported(toString(type));
switch (type) { switch (type) {
case Mode::LOW_POWER: // LOW_POWER handled insides PowerHAL specifically case Mode::LOW_POWER: // LOW_POWER handled insides PowerHAL specifically
supported = true; supported = true;
break; break;
case Mode::DOUBLE_TAP_TO_WAKE: case Mode::DOUBLE_TAP_TO_WAKE:
@ -227,18 +227,18 @@ ndk::ScopedAStatus Power::setBoost(Boost type, int32_t durationMs) {
return ndk::ScopedAStatus::ok(); return ndk::ScopedAStatus::ok();
} }
ndk::ScopedAStatus Power::isBoostSupported(Boost type, bool *_aidl_return) { ndk::ScopedAStatus Power::isBoostSupported(Boost type, bool* _aidl_return) {
bool supported = mHintManager->IsHintSupported(toString(type)); bool supported = mHintManager->IsHintSupported(toString(type));
LOG(INFO) << "Power boost " << toString(type) << " isBoostSupported: " << supported; LOG(INFO) << "Power boost " << toString(type) << " isBoostSupported: " << supported;
*_aidl_return = supported; *_aidl_return = supported;
return ndk::ScopedAStatus::ok(); return ndk::ScopedAStatus::ok();
} }
constexpr const char *boolToString(bool b) { constexpr const char* boolToString(bool b) {
return b ? "true" : "false"; return b ? "true" : "false";
} }
binder_status_t Power::dump(int fd, const char **, uint32_t) { binder_status_t Power::dump(int fd, const char**, uint32_t) {
std::string buf(::android::base::StringPrintf( std::string buf(::android::base::StringPrintf(
"HintManager Running: %s\n" "HintManager Running: %s\n"
"VRMode: %s\n" "VRMode: %s\n"

6
universal7885-common/aidl/power-libperfmgr/Power.h
View file

@ -41,10 +41,10 @@ class Power : public ::aidl::android::hardware::power::BnPower {
public: public:
Power(std::shared_ptr<HintManager> hm); Power(std::shared_ptr<HintManager> hm);
ndk::ScopedAStatus setMode(Mode type, bool enabled) override; ndk::ScopedAStatus setMode(Mode type, bool enabled) override;
ndk::ScopedAStatus isModeSupported(Mode type, bool *_aidl_return) override; ndk::ScopedAStatus isModeSupported(Mode type, bool* _aidl_return) override;
ndk::ScopedAStatus setBoost(Boost type, int32_t durationMs) override; ndk::ScopedAStatus setBoost(Boost type, int32_t durationMs) override;
ndk::ScopedAStatus isBoostSupported(Boost type, bool *_aidl_return) override; ndk::ScopedAStatus isBoostSupported(Boost type, bool* _aidl_return) override;
binder_status_t dump(int fd, const char **args, uint32_t numArgs) override; binder_status_t dump(int fd, const char** args, uint32_t numArgs) override;
private: private:
std::shared_ptr<HintManager> mHintManager; std::shared_ptr<HintManager> mHintManager;

8
universal7885-common/aidl/power-libperfmgr/PowerExt.cpp
View file

@ -37,7 +37,7 @@ namespace power {
namespace impl { namespace impl {
namespace pixel { namespace pixel {
ndk::ScopedAStatus PowerExt::setMode(const std::string &mode, bool enabled) { ndk::ScopedAStatus PowerExt::setMode(const std::string& mode, bool enabled) {
LOG(DEBUG) << "PowerExt setMode: " << mode << " to: " << enabled; LOG(DEBUG) << "PowerExt setMode: " << mode << " to: " << enabled;
ATRACE_INT(mode.c_str(), enabled); ATRACE_INT(mode.c_str(), enabled);
@ -50,14 +50,14 @@ ndk::ScopedAStatus PowerExt::setMode(const std::string &mode, bool enabled) {
return ndk::ScopedAStatus::ok(); return ndk::ScopedAStatus::ok();
} }
ndk::ScopedAStatus PowerExt::isModeSupported(const std::string &mode, bool *_aidl_return) { ndk::ScopedAStatus PowerExt::isModeSupported(const std::string& mode, bool* _aidl_return) {
bool supported = mHintManager->IsHintSupported(mode); bool supported = mHintManager->IsHintSupported(mode);
LOG(INFO) << "PowerExt mode " << mode << " isModeSupported: " << supported; LOG(INFO) << "PowerExt mode " << mode << " isModeSupported: " << supported;
*_aidl_return = supported; *_aidl_return = supported;
return ndk::ScopedAStatus::ok(); return ndk::ScopedAStatus::ok();
} }
ndk::ScopedAStatus PowerExt::setBoost(const std::string &boost, int32_t durationMs) { ndk::ScopedAStatus PowerExt::setBoost(const std::string& boost, int32_t durationMs) {
LOG(DEBUG) << "PowerExt setBoost: " << boost << " duration: " << durationMs; LOG(DEBUG) << "PowerExt setBoost: " << boost << " duration: " << durationMs;
ATRACE_INT(boost.c_str(), durationMs); ATRACE_INT(boost.c_str(), durationMs);
@ -72,7 +72,7 @@ ndk::ScopedAStatus PowerExt::setBoost(const std::string &boost, int32_t duration
return ndk::ScopedAStatus::ok(); return ndk::ScopedAStatus::ok();
} }
ndk::ScopedAStatus PowerExt::isBoostSupported(const std::string &boost, bool *_aidl_return) { ndk::ScopedAStatus PowerExt::isBoostSupported(const std::string& boost, bool* _aidl_return) {
bool supported = mHintManager->IsHintSupported(boost); bool supported = mHintManager->IsHintSupported(boost);
LOG(INFO) << "PowerExt boost " << boost << " isBoostSupported: " << supported; LOG(INFO) << "PowerExt boost " << boost << " isBoostSupported: " << supported;
*_aidl_return = supported; *_aidl_return = supported;

11
universal7885-common/aidl/power-libperfmgr/PowerExt.h
View file

@ -34,12 +34,11 @@ using ::android::perfmgr::HintManager;
class PowerExt : public ::aidl::google::hardware::power::extension::pixel::BnPowerExt { class PowerExt : public ::aidl::google::hardware::power::extension::pixel::BnPowerExt {
public: public:
PowerExt(std::shared_ptr<HintManager> hm) PowerExt(std::shared_ptr<HintManager> hm) : mHintManager(hm) {}
: mHintManager(hm) {} ndk::ScopedAStatus setMode(const std::string& mode, bool enabled) override;
ndk::ScopedAStatus setMode(const std::string &mode, bool enabled) override; ndk::ScopedAStatus isModeSupported(const std::string& mode, bool* _aidl_return) override;
ndk::ScopedAStatus isModeSupported(const std::string &mode, bool *_aidl_return) override; ndk::ScopedAStatus setBoost(const std::string& boost, int32_t durationMs) override;
ndk::ScopedAStatus setBoost(const std::string &boost, int32_t durationMs) override; ndk::ScopedAStatus isBoostSupported(const std::string& boost, bool* _aidl_return) override;
ndk::ScopedAStatus isBoostSupported(const std::string &boost, bool *_aidl_return) override;
private: private:
std::shared_ptr<HintManager> mHintManager; std::shared_ptr<HintManager> mHintManager;

48
universal7885-common/aidl/vibrator/Vibrator.cpp
View file

@ -53,7 +53,8 @@ Vibrator::Vibrator() {
ndk::ScopedAStatus Vibrator::getCapabilities(int32_t* _aidl_return) { ndk::ScopedAStatus Vibrator::getCapabilities(int32_t* _aidl_return) {
*_aidl_return = IVibrator::CAP_ON_CALLBACK | IVibrator::CAP_PERFORM_CALLBACK | *_aidl_return = IVibrator::CAP_ON_CALLBACK | IVibrator::CAP_PERFORM_CALLBACK |
IVibrator::CAP_EXTERNAL_CONTROL /*| IVibrator::CAP_COMPOSE_EFFECTS | IVibrator::CAP_EXTERNAL_CONTROL /*| IVibrator::CAP_COMPOSE_EFFECTS |
IVibrator::CAP_ALWAYS_ON_CONTROL*/; IVibrator::CAP_ALWAYS_ON_CONTROL*/
;
if (mHasTimedOutIntensity) { if (mHasTimedOutIntensity) {
*_aidl_return = *_aidl_return | IVibrator::CAP_AMPLITUDE_CONTROL | *_aidl_return = *_aidl_return | IVibrator::CAP_AMPLITUDE_CONTROL |
@ -67,7 +68,8 @@ ndk::ScopedAStatus Vibrator::off() {
return activate(0); return activate(0);
} }
ndk::ScopedAStatus Vibrator::on(int32_t timeoutMs, const std::shared_ptr<IVibratorCallback>& callback) { ndk::ScopedAStatus Vibrator::on(int32_t timeoutMs,
const std::shared_ptr<IVibratorCallback>& callback) {
ndk::ScopedAStatus status = activate(timeoutMs); ndk::ScopedAStatus status = activate(timeoutMs);
if (callback != nullptr) { if (callback != nullptr) {
@ -84,7 +86,9 @@ ndk::ScopedAStatus Vibrator::on(int32_t timeoutMs, const std::shared_ptr<IVibrat
return status; return status;
} }
ndk::ScopedAStatus Vibrator::perform(Effect effect, EffectStrength strength, const std::shared_ptr<IVibratorCallback>& callback, int32_t* _aidl_return) { ndk::ScopedAStatus Vibrator::perform(Effect effect, EffectStrength strength,
const std::shared_ptr<IVibratorCallback>& callback,
int32_t* _aidl_return) {
ndk::ScopedAStatus status; ndk::ScopedAStatus status;
uint8_t amplitude; uint8_t amplitude;
uint32_t ms; uint32_t ms;
@ -115,14 +119,13 @@ ndk::ScopedAStatus Vibrator::perform(Effect effect, EffectStrength strength, con
} }
ndk::ScopedAStatus Vibrator::getSupportedEffects(std::vector<Effect>* _aidl_return) { ndk::ScopedAStatus Vibrator::getSupportedEffects(std::vector<Effect>* _aidl_return) {
*_aidl_return = {Effect::CLICK, Effect::DOUBLE_CLICK, Effect::HEAVY_CLICK, *_aidl_return = {
Effect::TICK, Effect::TEXTURE_TICK, Effect::THUD, Effect::POP, Effect::CLICK, Effect::DOUBLE_CLICK, Effect::HEAVY_CLICK, Effect::TICK,
Effect::RINGTONE_1, Effect::RINGTONE_2, Effect::RINGTONE_3, Effect::TEXTURE_TICK, Effect::THUD, Effect::POP, Effect::RINGTONE_1,
Effect::RINGTONE_4, Effect::RINGTONE_5, Effect::RINGTONE_6, Effect::RINGTONE_2, Effect::RINGTONE_3, Effect::RINGTONE_4, Effect::RINGTONE_5,
Effect::RINGTONE_7, Effect::RINGTONE_7, Effect::RINGTONE_8, Effect::RINGTONE_6, Effect::RINGTONE_7, Effect::RINGTONE_7, Effect::RINGTONE_8,
Effect::RINGTONE_9, Effect::RINGTONE_10, Effect::RINGTONE_11, Effect::RINGTONE_9, Effect::RINGTONE_10, Effect::RINGTONE_11, Effect::RINGTONE_12,
Effect::RINGTONE_12, Effect::RINGTONE_13, Effect::RINGTONE_14, Effect::RINGTONE_13, Effect::RINGTONE_14, Effect::RINGTONE_15};
Effect::RINGTONE_15};
return ndk::ScopedAStatus::ok(); return ndk::ScopedAStatus::ok();
} }
@ -168,15 +171,18 @@ ndk::ScopedAStatus Vibrator::getCompositionSizeMax(int32_t* /*_aidl_return*/) {
return ndk::ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION); return ndk::ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION);
} }
ndk::ScopedAStatus Vibrator::getSupportedPrimitives(std::vector<CompositePrimitive>* /*_aidl_return*/) { ndk::ScopedAStatus Vibrator::getSupportedPrimitives(
std::vector<CompositePrimitive>* /*_aidl_return*/) {
return ndk::ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION); return ndk::ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION);
} }
ndk::ScopedAStatus Vibrator::getPrimitiveDuration(CompositePrimitive /*primitive*/, int32_t* /*_aidl_return*/) { ndk::ScopedAStatus Vibrator::getPrimitiveDuration(CompositePrimitive /*primitive*/,
int32_t* /*_aidl_return*/) {
return ndk::ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION); return ndk::ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION);
} }
ndk::ScopedAStatus Vibrator::compose(const std::vector<CompositeEffect>& /*composite*/, const std::shared_ptr<IVibratorCallback>& /*callback*/) { ndk::ScopedAStatus Vibrator::compose(const std::vector<CompositeEffect>& /*composite*/,
const std::shared_ptr<IVibratorCallback>& /*callback*/) {
return ndk::ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION); return ndk::ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION);
} }
@ -184,7 +190,8 @@ ndk::ScopedAStatus Vibrator::getSupportedAlwaysOnEffects(std::vector<Effect>* /*
return ndk::ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION); return ndk::ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION);
} }
ndk::ScopedAStatus Vibrator::alwaysOnEnable(int32_t /*id*/, Effect /*effect*/, EffectStrength /*strength*/) { ndk::ScopedAStatus Vibrator::alwaysOnEnable(int32_t /*id*/, Effect /*effect*/,
EffectStrength /*strength*/) {
return ndk::ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION); return ndk::ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION);
} }
@ -224,7 +231,8 @@ ndk::ScopedAStatus Vibrator::getSupportedBraking(std::vector<Braking>* /*_aidl_r
return ndk::ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION); return ndk::ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION);
} }
ndk::ScopedAStatus Vibrator::composePwle(const std::vector<PrimitivePwle>& /*composite*/, const std::shared_ptr<IVibratorCallback>& /*callback*/) { ndk::ScopedAStatus Vibrator::composePwle(const std::vector<PrimitivePwle>& /*composite*/,
const std::shared_ptr<IVibratorCallback>& /*callback*/) {
return ndk::ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION); return ndk::ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION);
} }
@ -290,7 +298,7 @@ uint32_t Vibrator::effectToMs(Effect effect, ndk::ScopedAStatus* status) {
return 0; return 0;
} }
} // namespace vibrator } // namespace vibrator
} // namespace hardware } // namespace hardware
} // namespace android } // namespace android
} // namespace aidl } // namespace aidl

37
universal7885-common/aidl/vibrator/Vibrator.h
View file

@ -15,12 +15,12 @@
#define VIBRATOR_TIMEOUT_PATH "/sys/class/timed_output/vibrator/enable" #define VIBRATOR_TIMEOUT_PATH "/sys/class/timed_output/vibrator/enable"
#define VIBRATOR_INTENSITY_PATH "/sys/class/timed_output/vibrator/intensity" #define VIBRATOR_INTENSITY_PATH "/sys/class/timed_output/vibrator/intensity"
using ::aidl::android::hardware::vibrator::IVibratorCallback;
using ::aidl::android::hardware::vibrator::Braking; using ::aidl::android::hardware::vibrator::Braking;
using ::aidl::android::hardware::vibrator::Effect;
using ::aidl::android::hardware::vibrator::EffectStrength;
using ::aidl::android::hardware::vibrator::CompositeEffect; using ::aidl::android::hardware::vibrator::CompositeEffect;
using ::aidl::android::hardware::vibrator::CompositePrimitive; using ::aidl::android::hardware::vibrator::CompositePrimitive;
using ::aidl::android::hardware::vibrator::Effect;
using ::aidl::android::hardware::vibrator::EffectStrength;
using ::aidl::android::hardware::vibrator::IVibratorCallback;
using ::aidl::android::hardware::vibrator::PrimitivePwle; using ::aidl::android::hardware::vibrator::PrimitivePwle;
namespace aidl { namespace aidl {
@ -29,20 +29,26 @@ namespace hardware {
namespace vibrator { namespace vibrator {
class Vibrator : public BnVibrator { class Vibrator : public BnVibrator {
public: public:
Vibrator(); Vibrator();
ndk::ScopedAStatus getCapabilities(int32_t* _aidl_return) override; ndk::ScopedAStatus getCapabilities(int32_t* _aidl_return) override;
ndk::ScopedAStatus off() override; ndk::ScopedAStatus off() override;
ndk::ScopedAStatus on(int32_t timeoutMs, const std::shared_ptr<IVibratorCallback>& callback) override; ndk::ScopedAStatus on(int32_t timeoutMs,
ndk::ScopedAStatus perform(Effect effect, EffectStrength strength, const std::shared_ptr<IVibratorCallback>& callback, int32_t* _aidl_return) override; const std::shared_ptr<IVibratorCallback>& callback) override;
ndk::ScopedAStatus perform(Effect effect, EffectStrength strength,
const std::shared_ptr<IVibratorCallback>& callback,
int32_t* _aidl_return) override;
ndk::ScopedAStatus getSupportedEffects(std::vector<Effect>* _aidl_return) override; ndk::ScopedAStatus getSupportedEffects(std::vector<Effect>* _aidl_return) override;
ndk::ScopedAStatus setAmplitude(float amplitude) override; ndk::ScopedAStatus setAmplitude(float amplitude) override;
ndk::ScopedAStatus setExternalControl(bool enabled) override; ndk::ScopedAStatus setExternalControl(bool enabled) override;
ndk::ScopedAStatus getCompositionDelayMax(int32_t* _aidl_return) override; ndk::ScopedAStatus getCompositionDelayMax(int32_t* _aidl_return) override;
ndk::ScopedAStatus getCompositionSizeMax(int32_t* _aidl_return) override; ndk::ScopedAStatus getCompositionSizeMax(int32_t* _aidl_return) override;
ndk::ScopedAStatus getSupportedPrimitives(std::vector<CompositePrimitive>* _aidl_return) override; ndk::ScopedAStatus getSupportedPrimitives(
ndk::ScopedAStatus getPrimitiveDuration(CompositePrimitive primitive, int32_t* _aidl_return) override; std::vector<CompositePrimitive>* _aidl_return) override;
ndk::ScopedAStatus compose(const std::vector<CompositeEffect>& composite, const std::shared_ptr<IVibratorCallback>& callback) override; ndk::ScopedAStatus getPrimitiveDuration(CompositePrimitive primitive,
int32_t* _aidl_return) override;
ndk::ScopedAStatus compose(const std::vector<CompositeEffect>& composite,
const std::shared_ptr<IVibratorCallback>& callback) override;
ndk::ScopedAStatus getSupportedAlwaysOnEffects(std::vector<Effect>* _aidl_return) override; ndk::ScopedAStatus getSupportedAlwaysOnEffects(std::vector<Effect>* _aidl_return) override;
ndk::ScopedAStatus alwaysOnEnable(int32_t id, Effect effect, EffectStrength strength) override; ndk::ScopedAStatus alwaysOnEnable(int32_t id, Effect effect, EffectStrength strength) override;
ndk::ScopedAStatus alwaysOnDisable(int32_t id) override; ndk::ScopedAStatus alwaysOnDisable(int32_t id) override;
@ -54,9 +60,10 @@ public:
ndk::ScopedAStatus getPwlePrimitiveDurationMax(int32_t* _aidl_return) override; ndk::ScopedAStatus getPwlePrimitiveDurationMax(int32_t* _aidl_return) override;
ndk::ScopedAStatus getPwleCompositionSizeMax(int32_t* _aidl_return) override; ndk::ScopedAStatus getPwleCompositionSizeMax(int32_t* _aidl_return) override;
ndk::ScopedAStatus getSupportedBraking(std::vector<Braking>* _aidl_return) override; ndk::ScopedAStatus getSupportedBraking(std::vector<Braking>* _aidl_return) override;
ndk::ScopedAStatus composePwle(const std::vector<PrimitivePwle>& composite, const std::shared_ptr<IVibratorCallback>& callback) override; ndk::ScopedAStatus composePwle(const std::vector<PrimitivePwle>& composite,
const std::shared_ptr<IVibratorCallback>& callback) override;
private: private:
ndk::ScopedAStatus activate(uint32_t ms); ndk::ScopedAStatus activate(uint32_t ms);
static uint32_t effectToMs(Effect effect, ndk::ScopedAStatus* status); static uint32_t effectToMs(Effect effect, ndk::ScopedAStatus* status);
static uint8_t strengthToAmplitude(EffectStrength strength, ndk::ScopedAStatus* status); static uint8_t strengthToAmplitude(EffectStrength strength, ndk::ScopedAStatus* status);
@ -69,7 +76,7 @@ private:
bool mHasTimedOutIntensity; bool mHasTimedOutIntensity;
}; };
} // namespace vibrator } // namespace vibrator
} // namespace hardware } // namespace hardware
} // namespace android } // namespace android
} // namespace aidl } // namespace aidl

7
universal7885-common/aidl/vibrator/service.cpp
View file

@ -6,9 +6,9 @@
#include "Vibrator.h" #include "Vibrator.h"
#include <android-base/logging.h>
#include <android/binder_manager.h> #include <android/binder_manager.h>
#include <android/binder_process.h> #include <android/binder_process.h>
#include <android-base/logging.h>
using ::aidl::android::hardware::vibrator::Vibrator; using ::aidl::android::hardware::vibrator::Vibrator;
@ -17,9 +17,10 @@ int main() {
std::shared_ptr<Vibrator> vibrator = ndk::SharedRefBase::make<Vibrator>(); std::shared_ptr<Vibrator> vibrator = ndk::SharedRefBase::make<Vibrator>();
const std::string instance = std::string() + Vibrator::descriptor + "/default"; const std::string instance = std::string() + Vibrator::descriptor + "/default";
binder_status_t status = AServiceManager_addService(vibrator->asBinder().get(), instance.c_str()); binder_status_t status =
AServiceManager_addService(vibrator->asBinder().get(), instance.c_str());
CHECK(status == STATUS_OK); CHECK(status == STATUS_OK);
ABinderProcess_joinThreadPool(); ABinderProcess_joinThreadPool();
return EXIT_FAILURE; // should not reach return EXIT_FAILURE; // should not reach
} }

167
universal7885-common/apps/SamsungParts/jni/BatteryBridge.cpp
View file

@ -1,98 +1,95 @@
#include <vendor/eureka/hardware/battery/1.0/IBattery.h>
#include <hidl/Status.h>
#include <hidl/LegacySupport.h>
#include <hardware/hardware.h> #include <hardware/hardware.h>
#include <hidl/HidlSupport.h> #include <hidl/HidlSupport.h>
#include <hidl/LegacySupport.h>
#include <hidl/Status.h>
#include <vendor/eureka/hardware/battery/1.0/IBattery.h>
#include "jni.h" #include "jni.h"
using vendor::eureka::hardware::battery::V1_0::IBattery;
using vendor::eureka::hardware::battery::V1_0::SysfsType;
using vendor::eureka::hardware::battery::V1_0::Number;
using android::sp; using android::sp;
using vendor::eureka::hardware::battery::V1_0::IBattery;
extern "C" JNIEXPORT void using vendor::eureka::hardware::battery::V1_0::Number;
JNICALL using vendor::eureka::hardware::battery::V1_0::SysfsType;
Java_com_eurekateam_samsungextras_interfaces_Battery_setChargeSysfs
(JNIEnv *env , __unused jclass obj, jint enable) { extern "C" JNIEXPORT void JNICALL
android::sp<IBattery> service = IBattery::getService(); Java_com_eurekateam_samsungextras_interfaces_Battery_setChargeSysfs(JNIEnv* env,
if (enable == 1){ __unused jclass obj,
service->setBatteryWritable(SysfsType::CHARGE, Number::ENABLE); jint enable) {
}else{ android::sp<IBattery> service = IBattery::getService();
service->setBatteryWritable(SysfsType::CHARGE, Number::DISABLE); if (enable == 1) {
} service->setBatteryWritable(SysfsType::CHARGE, Number::ENABLE);
} else {
service->setBatteryWritable(SysfsType::CHARGE, Number::DISABLE);
}
} }
extern "C" JNIEXPORT jint extern "C" JNIEXPORT jint JNICALL
JNICALL Java_com_eurekateam_samsungextras_interfaces_Battery_getChargeSysfs(JNIEnv* env,
Java_com_eurekateam_samsungextras_interfaces_Battery_getChargeSysfs __unused jclass obj) {
(JNIEnv *env , __unused jclass obj) { android::sp<IBattery> service = IBattery::getService();
android::sp<IBattery> service = IBattery::getService(); int ret = service->getBatteryStats(SysfsType::CHARGE);
int ret = service->getBatteryStats(SysfsType::CHARGE); return ret;
return ret;
} }
extern "C" extern "C" JNIEXPORT void JNICALL
JNIEXPORT void JNICALL Java_com_eurekateam_samsungextras_interfaces_Battery_setFastCharge(JNIEnv* env,
Java_com_eurekateam_samsungextras_interfaces_Battery_setFastCharge(JNIEnv *env, __unused jobject obj, __unused jobject obj,
jint enable) { jint enable) {
android::sp<IBattery> service = IBattery::getService(); android::sp<IBattery> service = IBattery::getService();
if (enable == 1){ if (enable == 1) {
service->setBatteryWritable(SysfsType::FASTCHARGE, Number::ENABLE); service->setBatteryWritable(SysfsType::FASTCHARGE, Number::ENABLE);
}else{ } else {
service->setBatteryWritable(SysfsType::FASTCHARGE, Number::DISABLE); service->setBatteryWritable(SysfsType::FASTCHARGE, Number::DISABLE);
} }
} }
extern "C" extern "C" JNIEXPORT jint JNICALL
JNIEXPORT jint JNICALL Java_com_eurekateam_samsungextras_interfaces_Battery_getFastChargeSysfs(JNIEnv* env,
Java_com_eurekateam_samsungextras_interfaces_Battery_getFastChargeSysfs(JNIEnv *env, __unused __unused jclass obj) {
jclass obj) { android::sp<IBattery> service = IBattery::getService();
android::sp<IBattery> service = IBattery::getService(); int ret = service->getBatteryStats(SysfsType::FASTCHARGE);
int ret = service->getBatteryStats(SysfsType::FASTCHARGE); return ret;
return ret;
} }
extern "C" extern "C" JNIEXPORT jint JNICALL
JNIEXPORT jint JNICALL Java_com_eurekateam_samsungextras_interfaces_Battery_getGeneralBatteryStats(JNIEnv* env,
Java_com_eurekateam_samsungextras_interfaces_Battery_getGeneralBatteryStats(JNIEnv *env,__unused jobject obj, jint id) { __unused jobject obj,
/** jint id) {
* id: /**
* 1 = BATTERY_CAPACITY_MAX * id:
* 2 = BATTERY_CAPACITY_CURRENT (%) * 1 = BATTERY_CAPACITY_MAX
* 3 = BATTERY_CAPACITY_CURRENT (mAh) * 2 = BATTERY_CAPACITY_CURRENT (%)
* 4 = CHARGING_STATE * 3 = BATTERY_CAPACITY_CURRENT (mAh)
* 5 = BATTERY_TEMP * 4 = CHARGING_STATE
* 6 = BATTERY_CURRENT * 5 = BATTERY_TEMP
*/ * 6 = BATTERY_CURRENT
android::sp<IBattery> service = IBattery::getService(); */
int ret; android::sp<IBattery> service = IBattery::getService();
switch (id) { int ret;
case 1: switch (id) {
ret = service->getBatteryStats(SysfsType::CAPACITY_MAX) / 1000; case 1:
break; ret = service->getBatteryStats(SysfsType::CAPACITY_MAX) / 1000;
case 2: break;
ret = service->getBatteryStats(SysfsType::CAPACITY_CURRENT); case 2:
break; ret = service->getBatteryStats(SysfsType::CAPACITY_CURRENT);
case 3: break;
ret = (float) service->getBatteryStats(SysfsType::CAPACITY_CURRENT) * case 3:
(float) service->getBatteryStats(SysfsType::CAPACITY_MAX) / 100000; ret = (float)service->getBatteryStats(SysfsType::CAPACITY_CURRENT) *
break; (float)service->getBatteryStats(SysfsType::CAPACITY_MAX) / 100000;
case 4: break;
if (service->getBatteryStats(SysfsType::CURRENT) > 0){ case 4:
ret = 1; if (service->getBatteryStats(SysfsType::CURRENT) > 0) {
}else{ ret = 1;
ret = 0; } else {
} ret = 0;
break; }
case 5: break;
ret = service->getBatteryStats(SysfsType::TEMP) / 10; case 5:
break; ret = service->getBatteryStats(SysfsType::TEMP) / 10;
case 6: break;
ret = service->getBatteryStats(SysfsType::CURRENT); case 6:
break; ret = service->getBatteryStats(SysfsType::CURRENT);
default: break;
ret = -1; default:
break; ret = -1;
} break;
return ret; }
return ret;
} }

107
universal7885-common/apps/SamsungParts/jni/FlashlightBridge.cpp
View file

@ -1,68 +1,63 @@
#include <vendor/eureka/hardware/flashlight/1.0/IFlashlight.h>
#include <hidl/Status.h>
#include <hidl/LegacySupport.h>
#include <hardware/hardware.h> #include <hardware/hardware.h>
#include <hidl/HidlSupport.h> #include <hidl/HidlSupport.h>
#include <hidl/LegacySupport.h>
#include <hidl/Status.h>
#include <vendor/eureka/hardware/flashlight/1.0/IFlashlight.h>
#include "jni.h" #include "jni.h"
using vendor::eureka::hardware::flashlight::V1_0::IFlashlight; using android::sp;
using vendor::eureka::hardware::flashlight::V1_0::Device; using vendor::eureka::hardware::flashlight::V1_0::Device;
using vendor::eureka::hardware::flashlight::V1_0::Enable; using vendor::eureka::hardware::flashlight::V1_0::Enable;
using vendor::eureka::hardware::flashlight::V1_0::IFlashlight;
using vendor::eureka::hardware::flashlight::V1_0::Number; using vendor::eureka::hardware::flashlight::V1_0::Number;
using android::sp;
extern "C" extern "C" JNIEXPORT void JNICALL Java_com_eurekateam_samsungextras_interfaces_Flashlight_setFlash(
JNIEXPORT void JNICALL JNIEnv* env, __unused jobject obj, jint value) {
Java_com_eurekateam_samsungextras_interfaces_Flashlight_setFlash(JNIEnv *env, __unused jobject obj, android::sp<IFlashlight> service = IFlashlight::getService();
jint value) { service->setFlashlightEnable(Enable::ENABLE);
android::sp<IFlashlight> service = IFlashlight::getService(); switch (value) {
service->setFlashlightEnable(Enable::ENABLE); case 1:
switch (value) { service->setFlashlightWritable(Number::ONEUI);
case 1: break;
service->setFlashlightWritable(Number::ONEUI); case 2:
break; service->setFlashlightWritable(Number::TWOUI);
case 2: break;
service->setFlashlightWritable(Number::TWOUI); case 3:
break; service->setFlashlightWritable(Number::THREEUI);
case 3: break;
service->setFlashlightWritable(Number::THREEUI); case 4:
break; service->setFlashlightWritable(Number::FOURUI);
case 4: break;
service->setFlashlightWritable(Number::FOURUI); case 5:
break; service->setFlashlightWritable(Number::FIVEUI);
case 5: break;
service->setFlashlightWritable(Number::FIVEUI); case 6:
break; service->setFlashlightWritable(Number::SIXUI);
case 6: break;
service->setFlashlightWritable(Number::SIXUI); case 7:
break; service->setFlashlightWritable(Number::SEVENUI);
case 7: break;
service->setFlashlightWritable(Number::SEVENUI); case 8:
break; service->setFlashlightWritable(Number::EIGHTUI);
case 8: break;
service->setFlashlightWritable(Number::EIGHTUI); case 9:
break; service->setFlashlightWritable(Number::NINEUI);
case 9: break;
service->setFlashlightWritable(Number::NINEUI); case 10:
break; service->setFlashlightWritable(Number::TENUI);
case 10: break;
service->setFlashlightWritable(Number::TENUI); default:
break; break;
default: }
break;
}
} }
extern "C" extern "C" JNIEXPORT jint JNICALL Java_com_eurekateam_samsungextras_interfaces_Flashlight_getFlash(
JNIEXPORT jint JNICALL JNIEnv* env, jobject clazz, jint isA10) {
Java_com_eurekateam_samsungextras_interfaces_Flashlight_getFlash(JNIEnv *env, jobject clazz, android::sp<IFlashlight> service = IFlashlight::getService();
jint isA10) { int ret;
android::sp<IFlashlight> service = IFlashlight::getService(); if (isA10 == 1) {
int ret;
if (isA10 == 1){
ret = service->readFlashlightstats(Device::A10); ret = service->readFlashlightstats(Device::A10);
}else{ } else {
ret = service->readFlashlightstats(Device::NOTA10); ret = service->readFlashlightstats(Device::NOTA10);
} }
return ret; return ret;
} }

40
universal7885-common/apps/SamsungParts/jni/GPUBridge.cpp
View file

@ -1,28 +1,26 @@
#include <vendor/eureka/hardware/gpu/1.0/IGpu.h>
#include <hidl/Status.h>
#include <hidl/LegacySupport.h>
#include <hardware/hardware.h> #include <hardware/hardware.h>
#include <hidl/HidlSupport.h> #include <hidl/HidlSupport.h>
#include <hidl/LegacySupport.h>
#include <hidl/Status.h>
#include <vendor/eureka/hardware/gpu/1.0/IGpu.h>
#include "jni.h" #include "jni.h"
using vendor::eureka::hardware::gpu::V1_0::IGpu;
using vendor::eureka::hardware::gpu::V1_0::Enable;
using android::sp; using android::sp;
using vendor::eureka::hardware::gpu::V1_0::Enable;
extern "C" using vendor::eureka::hardware::gpu::V1_0::IGpu;
JNIEXPORT void JNICALL
Java_com_eurekateam_samsungextras_interfaces_GPU_setGPU(JNIEnv *env, jclass clazz, jint enable) { extern "C" JNIEXPORT void JNICALL
android::sp<IGpu> service = IGpu::getService(); Java_com_eurekateam_samsungextras_interfaces_GPU_setGPU(JNIEnv* env, jclass clazz, jint enable) {
if (enable == 1){ android::sp<IGpu> service = IGpu::getService();
service->setGpuWritable(Enable::ENABLE); if (enable == 1) {
}else{ service->setGpuWritable(Enable::ENABLE);
service->setGpuWritable(Enable::DISABLE); } else {
} service->setGpuWritable(Enable::DISABLE);
}
} }
extern "C" extern "C" JNIEXPORT jint JNICALL
JNIEXPORT jint JNICALL Java_com_eurekateam_samsungextras_interfaces_GPU_getGPU(JNIEnv* env, jclass clazz) {
Java_com_eurekateam_samsungextras_interfaces_GPU_getGPU(JNIEnv *env, jclass clazz) { android::sp<IGpu> service = IGpu::getService();
android::sp<IGpu> service = IGpu::getService(); int ret = service->readGpustats();
int ret = service->readGpustats(); return ret;
return ret;
} }

21
universal7885-common/apps/SamsungParts/jni/SELinuxBridge.cpp
View file

@ -1,18 +1,17 @@
#include <vendor/eureka/security/selinux/1.0/ISELinux.h>
#include <hidl/Status.h>
#include <hidl/LegacySupport.h>
#include <hardware/hardware.h> #include <hardware/hardware.h>
#include <hidl/HidlSupport.h> #include <hidl/HidlSupport.h>
#include <hidl/LegacySupport.h>
#include <hidl/Status.h>
#include <vendor/eureka/security/selinux/1.0/ISELinux.h>
#include "jni.h" #include "jni.h"
using vendor::eureka::security::selinux::V1_0::ISELinux;
using vendor::eureka::security::selinux::V1_0::Enable;
using android::sp; using android::sp;
using vendor::eureka::security::selinux::V1_0::Enable;
using vendor::eureka::security::selinux::V1_0::ISELinux;
extern "C" extern "C" JNIEXPORT jint JNICALL
JNIEXPORT jint JNICALL Java_com_eurekateam_samsungextras_interfaces_SELinux_getSELinux(JNIEnv* env, jclass clazz) {
Java_com_eurekateam_samsungextras_interfaces_SELinux_getSELinux(JNIEnv *env, jclass clazz) { android::sp<ISELinux> service = ISELinux::getService();
android::sp<ISELinux> service = ISELinux::getService(); int ret = service->readSELinuxstats();
int ret = service->readSELinuxstats(); return ret;
return ret;
} }

20
universal7885-common/bluetooth/bdroid_buildcfg.h
View file

@ -6,21 +6,15 @@
#include <cutils/properties.h> #include <cutils/properties.h>
#include <string.h> #include <string.h>
static inline const char* BtmGetDefaultName() static inline const char* BtmGetDefaultName() {
{
char product_device[PROPERTY_VALUE_MAX]; char product_device[PROPERTY_VALUE_MAX];
property_get("ro.product.device", product_device, ""); property_get("ro.product.device", product_device, "");
if (strstr(product_device, "a10")) if (strstr(product_device, "a10")) return "Galaxy A10";
return "Galaxy A10"; if (strstr(product_device, "a20e")) return "Galaxy A20e";
if (strstr(product_device, "a20e")) if (strstr(product_device, "a20")) return "Galaxy A20";
return "Galaxy A20e"; if (strstr(product_device, "a30")) return "Galaxy A30";
if (strstr(product_device, "a20")) if (strstr(product_device, "a40")) return "Galaxy A40";
return "Galaxy A20";
if (strstr(product_device, "a30"))
return "Galaxy A30";
if (strstr(product_device, "a40"))
return "Galaxy A40";
// Fallback to Generic // Fallback to Generic
return "Samsung Galaxy"; return "Samsung Galaxy";
} }

105
universal7885-common/hidl/fingerprint/BiometricsFingerprint.cpp
View file

@ -24,9 +24,9 @@
#include "BiometricsFingerprint.h" #include "BiometricsFingerprint.h"
#include <dlfcn.h> #include <dlfcn.h>
#include <fstream>
#include <inttypes.h> #include <inttypes.h>
#include <unistd.h> #include <unistd.h>
#include <fstream>
#ifdef HAS_FINGERPRINT_GESTURES #ifdef HAS_FINGERPRINT_GESTURES
#include <fcntl.h> #include <fcntl.h>
@ -58,9 +58,8 @@ BiometricsFingerprint::BiometricsFingerprint() : mClientCallback(nullptr) {
return; return;
} }
int err = ioctl(uinputFd, UI_SET_EVBIT, EV_KEY) | int err = ioctl(uinputFd, UI_SET_EVBIT, EV_KEY) | ioctl(uinputFd, UI_SET_KEYBIT, KEY_UP) |
ioctl(uinputFd, UI_SET_KEYBIT, KEY_UP) | ioctl(uinputFd, UI_SET_KEYBIT, KEY_DOWN);
ioctl(uinputFd, UI_SET_KEYBIT, KEY_DOWN);
if (err != 0) { if (err != 0) {
LOG(ERROR) << "Unable to enable key events"; LOG(ERROR) << "Unable to enable key events";
return; return;
@ -71,14 +70,14 @@ BiometricsFingerprint::BiometricsFingerprint() : mClientCallback(nullptr) {
err = write(uinputFd, &uidev, sizeof(uidev)); err = write(uinputFd, &uidev, sizeof(uidev));
if (err < 0) { if (err < 0) {
LOG(ERROR) << "Write user device to uinput node failed"; LOG(ERROR) << "Write user device to uinput node failed";
return; return;
} }
err = ioctl(uinputFd, UI_DEV_CREATE); err = ioctl(uinputFd, UI_DEV_CREATE);
if (err < 0) { if (err < 0) {
LOG(ERROR) << "Unable to create uinput device"; LOG(ERROR) << "Unable to create uinput device";
return; return;
} }
LOG(INFO) << "Successfully registered uinput-sec-fp for fingerprint gestures"; LOG(INFO) << "Successfully registered uinput-sec-fp for fingerprint gestures";
@ -200,7 +199,7 @@ FingerprintAcquiredInfo BiometricsFingerprint::VendorAcquiredFilter(int32_t info
} }
Return<uint64_t> BiometricsFingerprint::setNotify( Return<uint64_t> BiometricsFingerprint::setNotify(
const sp<IBiometricsFingerprintClientCallback>& clientCallback) { const sp<IBiometricsFingerprintClientCallback>& clientCallback) {
std::lock_guard<std::mutex> lock(mClientCallbackMutex); std::lock_guard<std::mutex> lock(mClientCallbackMutex);
mClientCallback = clientCallback; mClientCallback = clientCallback;
// This is here because HAL 2.3 doesn't have a way to propagate a // This is here because HAL 2.3 doesn't have a way to propagate a
@ -286,33 +285,33 @@ bool BiometricsFingerprint::openHal() {
if (handle) { if (handle) {
int err; int err;
ss_fingerprint_close = ss_fingerprint_close = reinterpret_cast<typeof(ss_fingerprint_close)>(
reinterpret_cast<typeof(ss_fingerprint_close)>(dlsym(handle, "ss_fingerprint_close")); dlsym(handle, "ss_fingerprint_close"));
ss_fingerprint_open = ss_fingerprint_open =
reinterpret_cast<typeof(ss_fingerprint_open)>(dlsym(handle, "ss_fingerprint_open")); reinterpret_cast<typeof(ss_fingerprint_open)>(dlsym(handle, "ss_fingerprint_open"));
ss_set_notify_callback = reinterpret_cast<typeof(ss_set_notify_callback)>( ss_set_notify_callback = reinterpret_cast<typeof(ss_set_notify_callback)>(
dlsym(handle, "ss_set_notify_callback")); dlsym(handle, "ss_set_notify_callback"));
ss_fingerprint_pre_enroll = reinterpret_cast<typeof(ss_fingerprint_pre_enroll)>( ss_fingerprint_pre_enroll = reinterpret_cast<typeof(ss_fingerprint_pre_enroll)>(
dlsym(handle, "ss_fingerprint_pre_enroll")); dlsym(handle, "ss_fingerprint_pre_enroll"));
ss_fingerprint_enroll = ss_fingerprint_enroll = reinterpret_cast<typeof(ss_fingerprint_enroll)>(
reinterpret_cast<typeof(ss_fingerprint_enroll)>(dlsym(handle, "ss_fingerprint_enroll")); dlsym(handle, "ss_fingerprint_enroll"));
ss_fingerprint_post_enroll = reinterpret_cast<typeof(ss_fingerprint_post_enroll)>( ss_fingerprint_post_enroll = reinterpret_cast<typeof(ss_fingerprint_post_enroll)>(
dlsym(handle, "ss_fingerprint_post_enroll")); dlsym(handle, "ss_fingerprint_post_enroll"));
ss_fingerprint_get_auth_id = reinterpret_cast<typeof(ss_fingerprint_get_auth_id)>( ss_fingerprint_get_auth_id = reinterpret_cast<typeof(ss_fingerprint_get_auth_id)>(
dlsym(handle, "ss_fingerprint_get_auth_id")); dlsym(handle, "ss_fingerprint_get_auth_id"));
ss_fingerprint_cancel = ss_fingerprint_cancel = reinterpret_cast<typeof(ss_fingerprint_cancel)>(
reinterpret_cast<typeof(ss_fingerprint_cancel)>(dlsym(handle, "ss_fingerprint_cancel")); dlsym(handle, "ss_fingerprint_cancel"));
ss_fingerprint_enumerate = reinterpret_cast<typeof(ss_fingerprint_enumerate)>( ss_fingerprint_enumerate = reinterpret_cast<typeof(ss_fingerprint_enumerate)>(
dlsym(handle, "ss_fingerprint_enumerate")); dlsym(handle, "ss_fingerprint_enumerate"));
ss_fingerprint_remove = ss_fingerprint_remove = reinterpret_cast<typeof(ss_fingerprint_remove)>(
reinterpret_cast<typeof(ss_fingerprint_remove)>(dlsym(handle, "ss_fingerprint_remove")); dlsym(handle, "ss_fingerprint_remove"));
ss_fingerprint_set_active_group = reinterpret_cast<typeof(ss_fingerprint_set_active_group)>( ss_fingerprint_set_active_group = reinterpret_cast<typeof(ss_fingerprint_set_active_group)>(
dlsym(handle, "ss_fingerprint_set_active_group")); dlsym(handle, "ss_fingerprint_set_active_group"));
ss_fingerprint_authenticate = reinterpret_cast<typeof(ss_fingerprint_authenticate)>( ss_fingerprint_authenticate = reinterpret_cast<typeof(ss_fingerprint_authenticate)>(
dlsym(handle, "ss_fingerprint_authenticate")); dlsym(handle, "ss_fingerprint_authenticate"));
ss_fingerprint_request = reinterpret_cast<typeof(ss_fingerprint_request)>( ss_fingerprint_request = reinterpret_cast<typeof(ss_fingerprint_request)>(
dlsym(handle, "ss_fingerprint_request")); dlsym(handle, "ss_fingerprint_request"));
if ((err = ss_fingerprint_open(nullptr)) != 0) { if ((err = ss_fingerprint_open(nullptr)) != 0) {
LOG(ERROR) << "Can't open fingerprint, error: " << err; LOG(ERROR) << "Can't open fingerprint, error: " << err;
@ -332,7 +331,7 @@ bool BiometricsFingerprint::openHal() {
void BiometricsFingerprint::notify(const fingerprint_msg_t* msg) { void BiometricsFingerprint::notify(const fingerprint_msg_t* msg) {
BiometricsFingerprint* thisPtr = BiometricsFingerprint* thisPtr =
static_cast<BiometricsFingerprint*>(BiometricsFingerprint::getInstance()); static_cast<BiometricsFingerprint*>(BiometricsFingerprint::getInstance());
std::lock_guard<std::mutex> lock(thisPtr->mClientCallbackMutex); std::lock_guard<std::mutex> lock(thisPtr->mClientCallbackMutex);
if (thisPtr == nullptr || thisPtr->mClientCallback == nullptr) { if (thisPtr == nullptr || thisPtr->mClientCallback == nullptr) {
LOG(ERROR) << "Receiving callbacks before the client callback is registered."; LOG(ERROR) << "Receiving callbacks before the client callback is registered.";
@ -355,7 +354,7 @@ void BiometricsFingerprint::notify(const fingerprint_msg_t* msg) {
} }
int32_t vendorCode = 0; int32_t vendorCode = 0;
FingerprintAcquiredInfo result = FingerprintAcquiredInfo result =
VendorAcquiredFilter(msg->data.acquired.acquired_info, &vendorCode); VendorAcquiredFilter(msg->data.acquired.acquired_info, &vendorCode);
LOG(DEBUG) << "onAcquired(" << static_cast<int>(result) << ")"; LOG(DEBUG) << "onAcquired(" << static_cast<int>(result) << ")";
if (!thisPtr->mClientCallback->onAcquired(devId, result, vendorCode).isOk()) { if (!thisPtr->mClientCallback->onAcquired(devId, result, vendorCode).isOk()) {
LOG(ERROR) << "failed to invoke fingerprint onAcquired callback"; LOG(ERROR) << "failed to invoke fingerprint onAcquired callback";
@ -364,10 +363,10 @@ void BiometricsFingerprint::notify(const fingerprint_msg_t* msg) {
case FINGERPRINT_TEMPLATE_ENROLLING: case FINGERPRINT_TEMPLATE_ENROLLING:
#ifdef USES_PERCENTAGE_SAMPLES #ifdef USES_PERCENTAGE_SAMPLES
const_cast<fingerprint_msg_t*>(msg)->data.enroll.samples_remaining = const_cast<fingerprint_msg_t*>(msg)->data.enroll.samples_remaining =
100 - msg->data.enroll.samples_remaining; 100 - msg->data.enroll.samples_remaining;
#endif #endif
#ifdef CALL_CANCEL_ON_ENROLL_COMPLETION #ifdef CALL_CANCEL_ON_ENROLL_COMPLETION
if(msg->data.enroll.samples_remaining == 0) { if (msg->data.enroll.samples_remaining == 0) {
thisPtr->ss_fingerprint_cancel(); thisPtr->ss_fingerprint_cancel();
} }
#endif #endif
@ -375,9 +374,10 @@ void BiometricsFingerprint::notify(const fingerprint_msg_t* msg) {
<< ", gid=" << msg->data.enroll.finger.gid << ", gid=" << msg->data.enroll.finger.gid
<< ", rem=" << msg->data.enroll.samples_remaining << ")"; << ", rem=" << msg->data.enroll.samples_remaining << ")";
if (!thisPtr->mClientCallback if (!thisPtr->mClientCallback
->onEnrollResult(devId, msg->data.enroll.finger.fid, ->onEnrollResult(devId, msg->data.enroll.finger.fid,
msg->data.enroll.finger.gid, msg->data.enroll.samples_remaining) msg->data.enroll.finger.gid,
.isOk()) { msg->data.enroll.samples_remaining)
.isOk()) {
LOG(ERROR) << "failed to invoke fingerprint onEnrollResult callback"; LOG(ERROR) << "failed to invoke fingerprint onEnrollResult callback";
} }
break; break;
@ -386,9 +386,10 @@ void BiometricsFingerprint::notify(const fingerprint_msg_t* msg) {
<< ", gid=" << msg->data.removed.finger.gid << ", gid=" << msg->data.removed.finger.gid
<< ", rem=" << msg->data.removed.remaining_templates << ")"; << ", rem=" << msg->data.removed.remaining_templates << ")";
if (!thisPtr->mClientCallback if (!thisPtr->mClientCallback
->onRemoved(devId, msg->data.removed.finger.fid, msg->data.removed.finger.gid, ->onRemoved(devId, msg->data.removed.finger.fid,
msg->data.removed.remaining_templates) msg->data.removed.finger.gid,
.isOk()) { msg->data.removed.remaining_templates)
.isOk()) {
LOG(ERROR) << "failed to invoke fingerprint onRemoved callback"; LOG(ERROR) << "failed to invoke fingerprint onRemoved callback";
} }
break; break;
@ -398,19 +399,20 @@ void BiometricsFingerprint::notify(const fingerprint_msg_t* msg) {
if (msg->data.authenticated.finger.fid != 0) { if (msg->data.authenticated.finger.fid != 0) {
const uint8_t* hat = reinterpret_cast<const uint8_t*>(&msg->data.authenticated.hat); const uint8_t* hat = reinterpret_cast<const uint8_t*>(&msg->data.authenticated.hat);
const hidl_vec<uint8_t> token( const hidl_vec<uint8_t> token(
std::vector<uint8_t>(hat, hat + sizeof(msg->data.authenticated.hat))); std::vector<uint8_t>(hat, hat + sizeof(msg->data.authenticated.hat)));
if (!thisPtr->mClientCallback if (!thisPtr->mClientCallback
->onAuthenticated(devId, msg->data.authenticated.finger.fid, ->onAuthenticated(devId, msg->data.authenticated.finger.fid,
msg->data.authenticated.finger.gid, token) msg->data.authenticated.finger.gid, token)
.isOk()) { .isOk()) {
LOG(ERROR) << "failed to invoke fingerprint onAuthenticated callback"; LOG(ERROR) << "failed to invoke fingerprint onAuthenticated callback";
} }
} else { } else {
// Not a recognized fingerprint // Not a recognized fingerprint
if (!thisPtr->mClientCallback if (!thisPtr->mClientCallback
->onAuthenticated(devId, msg->data.authenticated.finger.fid, ->onAuthenticated(devId, msg->data.authenticated.finger.fid,
msg->data.authenticated.finger.gid, hidl_vec<uint8_t>()) msg->data.authenticated.finger.gid,
.isOk()) { hidl_vec<uint8_t>())
.isOk()) {
LOG(ERROR) << "failed to invoke fingerprint onAuthenticated callback"; LOG(ERROR) << "failed to invoke fingerprint onAuthenticated callback";
} }
} }
@ -420,10 +422,10 @@ void BiometricsFingerprint::notify(const fingerprint_msg_t* msg) {
<< ", gid=" << msg->data.enumerated.finger.gid << ", gid=" << msg->data.enumerated.finger.gid
<< ", rem=" << msg->data.enumerated.remaining_templates << ")"; << ", rem=" << msg->data.enumerated.remaining_templates << ")";
if (!thisPtr->mClientCallback if (!thisPtr->mClientCallback
->onEnumerate(devId, msg->data.enumerated.finger.fid, ->onEnumerate(devId, msg->data.enumerated.finger.fid,
msg->data.enumerated.finger.gid, msg->data.enumerated.finger.gid,
msg->data.enumerated.remaining_templates) msg->data.enumerated.remaining_templates)
.isOk()) { .isOk()) {
LOG(ERROR) << "failed to invoke fingerprint onEnumerate callback"; LOG(ERROR) << "failed to invoke fingerprint onEnumerate callback";
} }
break; break;
@ -436,8 +438,7 @@ void BiometricsFingerprint::handleEvent(int eventCode) {
case SEM_FINGERPRINT_EVENT_GESTURE_SWIPE_DOWN: case SEM_FINGERPRINT_EVENT_GESTURE_SWIPE_DOWN:
case SEM_FINGERPRINT_EVENT_GESTURE_SWIPE_UP: case SEM_FINGERPRINT_EVENT_GESTURE_SWIPE_UP:
struct input_event event {}; struct input_event event {};
int keycode = eventCode == SEM_FINGERPRINT_EVENT_GESTURE_SWIPE_UP ? int keycode = eventCode == SEM_FINGERPRINT_EVENT_GESTURE_SWIPE_UP ? KEY_UP : KEY_DOWN;
KEY_UP : KEY_DOWN;
int err; int err;
// Report the key // Report the key
@ -479,7 +480,7 @@ void BiometricsFingerprint::handleEvent(int eventCode) {
LOG(ERROR) << "Write EV_SYN to uinput node failed"; LOG(ERROR) << "Write EV_SYN to uinput node failed";
return; return;
} }
break; break;
#endif #endif
} }
} }
@ -496,8 +497,8 @@ int BiometricsFingerprint::waitForSensor(std::chrono::milliseconds pollWait,
int sensorStatus = SEM_SENSOR_STATUS_WORKING; int sensorStatus = SEM_SENSOR_STATUS_WORKING;
std::chrono::milliseconds timeWaited = 0ms; std::chrono::milliseconds timeWaited = 0ms;
while (sensorStatus != SEM_SENSOR_STATUS_OK) { while (sensorStatus != SEM_SENSOR_STATUS_OK) {
if (sensorStatus == SEM_SENSOR_STATUS_CALIBRATION_ERROR if (sensorStatus == SEM_SENSOR_STATUS_CALIBRATION_ERROR ||
|| sensorStatus == SEM_SENSOR_STATUS_ERROR){ sensorStatus == SEM_SENSOR_STATUS_ERROR) {
return -1; return -1;
} }
if (timeWaited >= timeOut) { if (timeWaited >= timeOut) {

22
universal7885-common/hidl/fingerprint/BiometricsFingerprint.h
View file

@ -24,12 +24,12 @@
#include <linux/uinput.h> #include <linux/uinput.h>
#endif #endif
#include <android/hardware/biometrics/fingerprint/2.1/types.h>
#include <android/hardware/biometrics/fingerprint/2.3/IBiometricsFingerprint.h>
#include <hardware/fingerprint.h> #include <hardware/fingerprint.h>
#include <hardware/hardware.h> #include <hardware/hardware.h>
#include <hidl/MQDescriptor.h> #include <hidl/MQDescriptor.h>
#include <hidl/Status.h> #include <hidl/Status.h>
#include <android/hardware/biometrics/fingerprint/2.3/IBiometricsFingerprint.h>
#include <android/hardware/biometrics/fingerprint/2.1/types.h>
#include "VendorConstants.h" #include "VendorConstants.h"
@ -47,11 +47,11 @@ using ::android::hardware::hidl_string;
using ::android::hardware::hidl_vec; using ::android::hardware::hidl_vec;
using ::android::hardware::Return; using ::android::hardware::Return;
using ::android::hardware::Void; using ::android::hardware::Void;
using ::android::hardware::biometrics::fingerprint::V2_3::IBiometricsFingerprint;
using ::android::hardware::biometrics::fingerprint::V2_1::IBiometricsFingerprintClientCallback;
using ::android::hardware::biometrics::fingerprint::V2_1::FingerprintAcquiredInfo; using ::android::hardware::biometrics::fingerprint::V2_1::FingerprintAcquiredInfo;
using ::android::hardware::biometrics::fingerprint::V2_1::FingerprintError; using ::android::hardware::biometrics::fingerprint::V2_1::FingerprintError;
using ::android::hardware::biometrics::fingerprint::V2_1::IBiometricsFingerprintClientCallback;
using ::android::hardware::biometrics::fingerprint::V2_1::RequestStatus; using ::android::hardware::biometrics::fingerprint::V2_1::RequestStatus;
using ::android::hardware::biometrics::fingerprint::V2_3::IBiometricsFingerprint;
struct BiometricsFingerprint : public IBiometricsFingerprint { struct BiometricsFingerprint : public IBiometricsFingerprint {
BiometricsFingerprint(); BiometricsFingerprint();
@ -60,9 +60,10 @@ struct BiometricsFingerprint : public IBiometricsFingerprint {
// Method to wrap legacy HAL with BiometricsFingerprint class // Method to wrap legacy HAL with BiometricsFingerprint class
static IBiometricsFingerprint* getInstance(); static IBiometricsFingerprint* getInstance();
// Methods from ::android::hardware::biometrics::fingerprint::V2_3::IBiometricsFingerprint follow. // Methods from ::android::hardware::biometrics::fingerprint::V2_3::IBiometricsFingerprint
// follow.
Return<uint64_t> setNotify( Return<uint64_t> setNotify(
const sp<IBiometricsFingerprintClientCallback>& clientCallback) override; const sp<IBiometricsFingerprintClientCallback>& clientCallback) override;
Return<uint64_t> preEnroll() override; Return<uint64_t> preEnroll() override;
Return<RequestStatus> enroll(const hidl_array<uint8_t, 69>& hat, uint32_t gid, Return<RequestStatus> enroll(const hidl_array<uint8_t, 69>& hat, uint32_t gid,
uint32_t timeoutSec) override; uint32_t timeoutSec) override;
@ -76,15 +77,15 @@ struct BiometricsFingerprint : public IBiometricsFingerprint {
Return<bool> isUdfps(uint32_t sensorID) override; Return<bool> isUdfps(uint32_t sensorID) override;
Return<void> onFingerDown(uint32_t x, uint32_t y, float minor, float major) override; Return<void> onFingerDown(uint32_t x, uint32_t y, float minor, float major) override;
Return<void> onFingerUp() override; Return<void> onFingerUp() override;
Return<void> onShowUdfpsOverlay(){ return Void();} Return<void> onShowUdfpsOverlay() { return Void(); }
Return<void> onHideUdfpsOverlay(){ return Void();} Return<void> onHideUdfpsOverlay() { return Void(); }
private: private:
bool openHal(); bool openHal();
int request(int cmd, int param); int request(int cmd, int param);
int waitForSensor(std::chrono::milliseconds pollWait, std::chrono::milliseconds timeOut); int waitForSensor(std::chrono::milliseconds pollWait, std::chrono::milliseconds timeOut);
static void notify( static void notify(
const fingerprint_msg_t* msg); /* Static callback for legacy HAL implementation */ const fingerprint_msg_t* msg); /* Static callback for legacy HAL implementation */
void handleEvent(int eventCode); void handleEvent(int eventCode);
static Return<RequestStatus> ErrorFilter(int32_t error); static Return<RequestStatus> ErrorFilter(int32_t error);
static FingerprintError VendorErrorFilter(int32_t error, int32_t* vendorCode); static FingerprintError VendorErrorFilter(int32_t error, int32_t* vendorCode);
@ -111,7 +112,8 @@ struct BiometricsFingerprint : public IBiometricsFingerprint {
int (*ss_fingerprint_remove)(uint32_t gid, uint32_t fid); int (*ss_fingerprint_remove)(uint32_t gid, uint32_t fid);
int (*ss_fingerprint_set_active_group)(uint32_t gid, const char* store_path); int (*ss_fingerprint_set_active_group)(uint32_t gid, const char* store_path);
int (*ss_fingerprint_authenticate)(uint64_t operation_id, uint32_t gid); int (*ss_fingerprint_authenticate)(uint64_t operation_id, uint32_t gid);
int (*ss_fingerprint_request)(uint32_t cmd, char *inBuf, uint32_t inBuf_length, char *outBuf, uint32_t outBuf_length, uint32_t param); int (*ss_fingerprint_request)(uint32_t cmd, char* inBuf, uint32_t inBuf_length, char* outBuf,
uint32_t outBuf_length, uint32_t param);
}; };
} // namespace implementation } // namespace implementation

2
universal7885-common/hidl/fingerprint/VendorConstants.h
View file

@ -101,4 +101,4 @@
#define SEM_SENSOR_STATUS_OK 100040 #define SEM_SENSOR_STATUS_OK 100040
#define SEM_SENSOR_STATUS_WORKING 100041 #define SEM_SENSOR_STATUS_WORKING 100041
#endif // SAMSUNG_FINGERPRINT_CONSTANTS_H #endif // SAMSUNG_FINGERPRINT_CONSTANTS_H

2
universal7885-common/hidl/keymaster/service.cpp
View file

@ -37,7 +37,7 @@ IKeymasterDevice* CreateSKeymasterDevice(SecurityLevel securityLevel);
int main() { int main() {
IKeymasterDevice* keymaster = IKeymasterDevice* keymaster =
skeymaster::CreateSKeymasterDevice(SecurityLevel::TRUSTED_ENVIRONMENT); skeymaster::CreateSKeymasterDevice(SecurityLevel::TRUSTED_ENVIRONMENT);
configureRpcThreadpool(1, true); configureRpcThreadpool(1, true);

129
universal7885-common/hidl/sensors/Sensors.cpp
View file

@ -37,7 +37,7 @@ namespace implementation {
static bool UseMultiHal() { static bool UseMultiHal() {
const std::string& name = MULTI_HAL_CONFIG_FILE_PATH; const std::string& name = MULTI_HAL_CONFIG_FILE_PATH;
struct stat buffer; struct stat buffer;
return (stat (name.c_str(), &buffer) == 0); return (stat(name.c_str(), &buffer) == 0);
} }
static Result ResultFromStatus(status_t err) { static Result ResultFromStatus(status_t err) {
@ -55,28 +55,20 @@ static Result ResultFromStatus(status_t err) {
} }
} }
Sensors::Sensors() Sensors::Sensors() : mInitCheck(NO_INIT), mSensorModule(nullptr), mSensorDevice(nullptr) {
: mInitCheck(NO_INIT),
mSensorModule(nullptr),
mSensorDevice(nullptr) {
status_t err = OK; status_t err = OK;
if (UseMultiHal()) { if (UseMultiHal()) {
mSensorModule = ::get_multi_hal_module_info(); mSensorModule = ::get_multi_hal_module_info();
} else { } else {
err = hw_get_module( err = hw_get_module(SENSORS_HARDWARE_MODULE_ID, (hw_module_t const**)&mSensorModule);
SENSORS_HARDWARE_MODULE_ID,
(hw_module_t const **)&mSensorModule);
} }
if (mSensorModule == NULL) { if (mSensorModule == NULL) {
err = UNKNOWN_ERROR; err = UNKNOWN_ERROR;
} }
if (err != OK) { if (err != OK) {
LOG(ERROR) << "Couldn't load " LOG(ERROR) << "Couldn't load " << SENSORS_HARDWARE_MODULE_ID << " module ("
<< SENSORS_HARDWARE_MODULE_ID << strerror(-err) << ")";
<< " module ("
<< strerror(-err)
<< ")";
mInitCheck = err; mInitCheck = err;
return; return;
@ -85,11 +77,8 @@ Sensors::Sensors()
err = sensors_open_1(&mSensorModule->common, &mSensorDevice); err = sensors_open_1(&mSensorModule->common, &mSensorDevice);
if (err != OK) { if (err != OK) {
LOG(ERROR) << "Couldn't open device for module " LOG(ERROR) << "Couldn't open device for module " << SENSORS_HARDWARE_MODULE_ID << " ("
<< SENSORS_HARDWARE_MODULE_ID << strerror(-err) << ")";
<< " ("
<< strerror(-err)
<< ")";
mInitCheck = err; mInitCheck = err;
return; return;
@ -119,15 +108,15 @@ status_t Sensors::initCheck() const {
} }
Return<void> Sensors::getSensorsList(getSensorsList_cb _hidl_cb) { Return<void> Sensors::getSensorsList(getSensorsList_cb _hidl_cb) {
sensor_t const *list; sensor_t const* list;
size_t count = mSensorModule->get_sensors_list(mSensorModule, &list); size_t count = mSensorModule->get_sensors_list(mSensorModule, &list);
hidl_vec<SensorInfo> out; hidl_vec<SensorInfo> out;
out.resize(count); out.resize(count);
for (size_t i = 0; i < count; ++i) { for (size_t i = 0; i < count; ++i) {
const sensor_t *src = &list[i]; const sensor_t* src = &list[i];
SensorInfo *dst = &out[i]; SensorInfo* dst = &out[i];
convertFromSensor(*src, dst); convertFromSensor(*src, dst);
@ -166,31 +155,26 @@ int Sensors::getHalDeviceVersion() const {
} }
Return<Result> Sensors::setOperationMode(OperationMode mode) { Return<Result> Sensors::setOperationMode(OperationMode mode) {
if (getHalDeviceVersion() < SENSORS_DEVICE_API_VERSION_1_4 if (getHalDeviceVersion() < SENSORS_DEVICE_API_VERSION_1_4 ||
|| mSensorModule->set_operation_mode == nullptr) { mSensorModule->set_operation_mode == nullptr) {
return Result::INVALID_OPERATION; return Result::INVALID_OPERATION;
} }
return ResultFromStatus(mSensorModule->set_operation_mode((uint32_t)mode)); return ResultFromStatus(mSensorModule->set_operation_mode((uint32_t)mode));
} }
Return<Result> Sensors::activate( Return<Result> Sensors::activate(int32_t sensor_handle, bool enabled) {
int32_t sensor_handle, bool enabled) { return ResultFromStatus(mSensorDevice->activate(
return ResultFromStatus( reinterpret_cast<sensors_poll_device_t*>(mSensorDevice), sensor_handle, enabled));
mSensorDevice->activate(
reinterpret_cast<sensors_poll_device_t *>(mSensorDevice),
sensor_handle,
enabled));
} }
Return<void> Sensors::poll(int32_t maxCount, poll_cb _hidl_cb) { Return<void> Sensors::poll(int32_t maxCount, poll_cb _hidl_cb) {
hidl_vec<Event> out; hidl_vec<Event> out;
hidl_vec<SensorInfo> dynamicSensorsAdded; hidl_vec<SensorInfo> dynamicSensorsAdded;
std::unique_ptr<sensors_event_t[]> data; std::unique_ptr<sensors_event_t[]> data;
int err = android::NO_ERROR; int err = android::NO_ERROR;
{ // scope of reentry lock { // scope of reentry lock
// This enforces a single client, meaning that a maximum of one client can call poll(). // This enforces a single client, meaning that a maximum of one client can call poll().
// If this function is re-entred, it means that we are stuck in a state that may prevent // If this function is re-entred, it means that we are stuck in a state that may prevent
@ -200,11 +184,11 @@ Return<void> Sensors::poll(int32_t maxCount, poll_cb _hidl_cb) {
// //
// This function must not call _hidl_cb(...) or return until there is no risk of blocking. // This function must not call _hidl_cb(...) or return until there is no risk of blocking.
std::unique_lock<std::mutex> lock(mPollLock, std::try_to_lock); std::unique_lock<std::mutex> lock(mPollLock, std::try_to_lock);
if(!lock.owns_lock()){ if (!lock.owns_lock()) {
// cannot get the lock, hidl service will go into deadlock if it is not restarted. // cannot get the lock, hidl service will go into deadlock if it is not restarted.
// This is guaranteed to not trigger in passthrough mode. // This is guaranteed to not trigger in passthrough mode.
LOG(ERROR) << LOG(ERROR)
"ISensors::poll() re-entry. I do not know what to do except killing myself."; << "ISensors::poll() re-entry. I do not know what to do except killing myself.";
::exit(-1); ::exit(-1);
} }
@ -213,9 +197,8 @@ Return<void> Sensors::poll(int32_t maxCount, poll_cb _hidl_cb) {
} else { } else {
int bufferSize = maxCount <= kPollMaxBufferSize ? maxCount : kPollMaxBufferSize; int bufferSize = maxCount <= kPollMaxBufferSize ? maxCount : kPollMaxBufferSize;
data.reset(new sensors_event_t[bufferSize]); data.reset(new sensors_event_t[bufferSize]);
err = mSensorDevice->poll( err = mSensorDevice->poll(reinterpret_cast<sensors_poll_device_t*>(mSensorDevice),
reinterpret_cast<sensors_poll_device_t *>(mSensorDevice), data.get(), bufferSize);
data.get(), bufferSize);
} }
} }
@ -231,7 +214,7 @@ Return<void> Sensors::poll(int32_t maxCount, poll_cb _hidl_cb) {
continue; continue;
} }
const dynamic_sensor_meta_event_t *dyn = &data[i].dynamic_sensor_meta; const dynamic_sensor_meta_event_t* dyn = &data[i].dynamic_sensor_meta;
if (!dyn->connected) { if (!dyn->connected) {
continue; continue;
@ -256,17 +239,10 @@ Return<void> Sensors::poll(int32_t maxCount, poll_cb _hidl_cb) {
return Void(); return Void();
} }
Return<Result> Sensors::batch( Return<Result> Sensors::batch(int32_t sensor_handle, int64_t sampling_period_ns,
int32_t sensor_handle, int64_t max_report_latency_ns) {
int64_t sampling_period_ns, return ResultFromStatus(mSensorDevice->batch(mSensorDevice, sensor_handle, 0, /*flags*/
int64_t max_report_latency_ns) { sampling_period_ns, max_report_latency_ns));
return ResultFromStatus(
mSensorDevice->batch(
mSensorDevice,
sensor_handle,
0, /*flags*/
sampling_period_ns,
max_report_latency_ns));
} }
Return<Result> Sensors::flush(int32_t sensor_handle) { Return<Result> Sensors::flush(int32_t sensor_handle) {
@ -274,22 +250,21 @@ Return<Result> Sensors::flush(int32_t sensor_handle) {
} }
Return<Result> Sensors::injectSensorData(const Event& event) { Return<Result> Sensors::injectSensorData(const Event& event) {
if (getHalDeviceVersion() < SENSORS_DEVICE_API_VERSION_1_4 if (getHalDeviceVersion() < SENSORS_DEVICE_API_VERSION_1_4 ||
|| mSensorDevice->inject_sensor_data == nullptr) { mSensorDevice->inject_sensor_data == nullptr) {
return Result::INVALID_OPERATION; return Result::INVALID_OPERATION;
} }
sensors_event_t out; sensors_event_t out;
convertToSensorEvent(event, &out); convertToSensorEvent(event, &out);
return ResultFromStatus( return ResultFromStatus(mSensorDevice->inject_sensor_data(mSensorDevice, &out));
mSensorDevice->inject_sensor_data(mSensorDevice, &out));
} }
Return<void> Sensors::registerDirectChannel( Return<void> Sensors::registerDirectChannel(const SharedMemInfo& mem,
const SharedMemInfo& mem, registerDirectChannel_cb _hidl_cb) { registerDirectChannel_cb _hidl_cb) {
if (mSensorDevice->register_direct_channel == nullptr if (mSensorDevice->register_direct_channel == nullptr ||
|| mSensorDevice->config_direct_report == nullptr) { mSensorDevice->config_direct_report == nullptr) {
// HAL does not support // HAL does not support
_hidl_cb(Result::INVALID_OPERATION, -1); _hidl_cb(Result::INVALID_OPERATION, -1);
return Void(); return Void();
@ -297,8 +272,8 @@ Return<void> Sensors::registerDirectChannel(
sensors_direct_mem_t m; sensors_direct_mem_t m;
if (!convertFromSharedMemInfo(mem, &m)) { if (!convertFromSharedMemInfo(mem, &m)) {
_hidl_cb(Result::BAD_VALUE, -1); _hidl_cb(Result::BAD_VALUE, -1);
return Void(); return Void();
} }
int err = mSensorDevice->register_direct_channel(mSensorDevice, &m, -1); int err = mSensorDevice->register_direct_channel(mSensorDevice, &m, -1);
@ -313,8 +288,8 @@ Return<void> Sensors::registerDirectChannel(
} }
Return<Result> Sensors::unregisterDirectChannel(int32_t channelHandle) { Return<Result> Sensors::unregisterDirectChannel(int32_t channelHandle) {
if (mSensorDevice->register_direct_channel == nullptr if (mSensorDevice->register_direct_channel == nullptr ||
|| mSensorDevice->config_direct_report == nullptr) { mSensorDevice->config_direct_report == nullptr) {
// HAL does not support // HAL does not support
return Result::INVALID_OPERATION; return Result::INVALID_OPERATION;
} }
@ -324,26 +299,22 @@ Return<Result> Sensors::unregisterDirectChannel(int32_t channelHandle) {
return Result::OK; return Result::OK;
} }
Return<void> Sensors::configDirectReport( Return<void> Sensors::configDirectReport(int32_t sensorHandle, int32_t channelHandle,
int32_t sensorHandle, int32_t channelHandle, RateLevel rate, RateLevel rate, configDirectReport_cb _hidl_cb) {
configDirectReport_cb _hidl_cb) { if (mSensorDevice->register_direct_channel == nullptr ||
if (mSensorDevice->register_direct_channel == nullptr mSensorDevice->config_direct_report == nullptr) {
|| mSensorDevice->config_direct_report == nullptr) {
// HAL does not support // HAL does not support
_hidl_cb(Result::INVALID_OPERATION, -1); _hidl_cb(Result::INVALID_OPERATION, -1);
return Void(); return Void();
} }
sensors_direct_cfg_t cfg = { sensors_direct_cfg_t cfg = {.rate_level = convertFromRateLevel(rate)};
.rate_level = convertFromRateLevel(rate)
};
if (cfg.rate_level < 0) { if (cfg.rate_level < 0) {
_hidl_cb(Result::BAD_VALUE, -1); _hidl_cb(Result::BAD_VALUE, -1);
return Void(); return Void();
} }
int err = mSensorDevice->config_direct_report(mSensorDevice, int err = mSensorDevice->config_direct_report(mSensorDevice, sensorHandle, channelHandle, &cfg);
sensorHandle, channelHandle, &cfg);
if (rate == RateLevel::STOP) { if (rate == RateLevel::STOP) {
_hidl_cb(ResultFromStatus(err), -1); _hidl_cb(ResultFromStatus(err), -1);
@ -354,20 +325,18 @@ Return<void> Sensors::configDirectReport(
} }
// static // static
void Sensors::convertFromSensorEvents( void Sensors::convertFromSensorEvents(size_t count, const sensors_event_t* srcArray,
size_t count, hidl_vec<Event>* dstVec) {
const sensors_event_t *srcArray,
hidl_vec<Event> *dstVec) {
for (size_t i = 0; i < count; ++i) { for (size_t i = 0; i < count; ++i) {
const sensors_event_t &src = srcArray[i]; const sensors_event_t& src = srcArray[i];
Event *dst = &(*dstVec)[i]; Event* dst = &(*dstVec)[i];
convertFromSensorEvent(src, dst); convertFromSensorEvent(src, dst);
} }
} }
ISensors *HIDL_FETCH_ISensors(const char * /* hal */) { ISensors* HIDL_FETCH_ISensors(const char* /* hal */) {
Sensors *sensors = new Sensors; Sensors* sensors = new Sensors;
if (sensors->initCheck() != OK) { if (sensors->initCheck() != OK) {
delete sensors; delete sensors;
sensors = nullptr; sensors = nullptr;

31
universal7885-common/hidl/sensors/Sensors.h
View file

@ -29,7 +29,6 @@ namespace sensors {
namespace V1_0 { namespace V1_0 {
namespace implementation { namespace implementation {
struct Sensors : public ::android::hardware::sensors::V1_0::ISensors { struct Sensors : public ::android::hardware::sensors::V1_0::ISensors {
Sensors(); Sensors();
@ -39,45 +38,41 @@ struct Sensors : public ::android::hardware::sensors::V1_0::ISensors {
Return<Result> setOperationMode(OperationMode mode) override; Return<Result> setOperationMode(OperationMode mode) override;
Return<Result> activate( Return<Result> activate(int32_t sensor_handle, bool enabled) override;
int32_t sensor_handle, bool enabled) override;
Return<void> poll(int32_t maxCount, poll_cb _hidl_cb) override; Return<void> poll(int32_t maxCount, poll_cb _hidl_cb) override;
Return<Result> batch( Return<Result> batch(int32_t sensor_handle, int64_t sampling_period_ns,
int32_t sensor_handle, int64_t max_report_latency_ns) override;
int64_t sampling_period_ns,
int64_t max_report_latency_ns) override;
Return<Result> flush(int32_t sensor_handle) override; Return<Result> flush(int32_t sensor_handle) override;
Return<Result> injectSensorData(const Event& event) override; Return<Result> injectSensorData(const Event& event) override;
Return<void> registerDirectChannel( Return<void> registerDirectChannel(const SharedMemInfo& mem,
const SharedMemInfo& mem, registerDirectChannel_cb _hidl_cb) override; registerDirectChannel_cb _hidl_cb) override;
Return<Result> unregisterDirectChannel(int32_t channelHandle) override; Return<Result> unregisterDirectChannel(int32_t channelHandle) override;
Return<void> configDirectReport( Return<void> configDirectReport(int32_t sensorHandle, int32_t channelHandle, RateLevel rate,
int32_t sensorHandle, int32_t channelHandle, RateLevel rate, configDirectReport_cb _hidl_cb) override;
configDirectReport_cb _hidl_cb) override;
private: private:
static constexpr int32_t kPollMaxBufferSize = 128; static constexpr int32_t kPollMaxBufferSize = 128;
status_t mInitCheck; status_t mInitCheck;
sensors_module_t *mSensorModule; sensors_module_t* mSensorModule;
sensors_poll_device_1_t *mSensorDevice; sensors_poll_device_1_t* mSensorDevice;
std::mutex mPollLock; std::mutex mPollLock;
int getHalDeviceVersion() const; int getHalDeviceVersion() const;
static void convertFromSensorEvents( static void convertFromSensorEvents(size_t count, const sensors_event_t* src,
size_t count, const sensors_event_t *src, hidl_vec<Event> *dst); hidl_vec<Event>* dst);
DISALLOW_COPY_AND_ASSIGN(Sensors); DISALLOW_COPY_AND_ASSIGN(Sensors);
}; };
extern "C" ISensors *HIDL_FETCH_ISensors(const char *name); extern "C" ISensors* HIDL_FETCH_ISensors(const char* name);
} // namespace implementation } // namespace implementation
} // namespace V1_0 } // namespace V1_0

31
universal7885-common/init/init_universal7885.cpp
View file

@ -30,8 +30,8 @@
#define _REALLY_INCLUDE_SYS__SYSTEM_PROPERTIES_H_ #define _REALLY_INCLUDE_SYS__SYSTEM_PROPERTIES_H_
#include <sys/_system_properties.h> #include <sys/_system_properties.h>
#include <android-base/properties.h>
#include <android-base/logging.h> #include <android-base/logging.h>
#include <android-base/properties.h>
#include "property_service.h" #include "property_service.h"
#include "vendor_init.h" #include "vendor_init.h"
@ -40,28 +40,23 @@ using android::base::GetProperty;
using std::string; using std::string;
std::vector<std::string> ro_props_default_source_order = { std::vector<std::string> ro_props_default_source_order = {
"", "", "odm.", "product.", "system.", "system_ext.", "vendor.",
"odm.",
"product.",
"system.",
"system_ext.",
"vendor.",
}; };
void property_override(char const prop[], char const value[], bool add = true) { void property_override(char const prop[], char const value[], bool add = true) {
prop_info *pi; prop_info* pi;
pi = (prop_info*) __system_property_find(prop); pi = (prop_info*)__system_property_find(prop);
if (pi) if (pi)
__system_property_update(pi, value, strlen(value)); __system_property_update(pi, value, strlen(value));
else if (add) else if (add)
__system_property_add(prop, strlen(prop), value, strlen(value)); __system_property_add(prop, strlen(prop), value, strlen(value));
} }
void set_ro_build_prop(const std::string &prop, const std::string &value, bool product = true) { void set_ro_build_prop(const std::string& prop, const std::string& value, bool product = true) {
string prop_name; string prop_name;
for (const auto &source : ro_props_default_source_order) { for (const auto& source : ro_props_default_source_order) {
if (product) if (product)
prop_name = "ro.product." + source + prop; prop_name = "ro.product." + source + prop;
else else
@ -71,10 +66,11 @@ void set_ro_build_prop(const std::string &prop, const std::string &value, bool p
} }
} }
bool hasEnding (std::string const &fullString, std::string const &ending) { bool hasEnding(std::string const& fullString, std::string const& ending) {
if (fullString.length() >= ending.length()) { if (fullString.length() >= ending.length()) {
return (0 == fullString.compare (fullString.length() - ending.length(), ending.length(), ending)); return (0 ==
} else { fullString.compare(fullString.length() - ending.length(), ending.length(), ending));
} else {
return false; return false;
} }
} }
@ -83,12 +79,13 @@ void vendor_load_properties() {
string model; string model;
model = GetProperty("ro.boot.product.model", ""); model = GetProperty("ro.boot.product.model", "");
if(model.empty()){ if (model.empty()) {
model = GetProperty("ro.boot.em.model", ""); model = GetProperty("ro.boot.em.model", "");
} }
if (hasEnding(model, "N") || hasEnding(model, "S") || hasEnding(model, "K") || model == "SM-A202F") { if (hasEnding(model, "N") || hasEnding(model, "S") || hasEnding(model, "K") ||
property_override("ro.boot.product.hardware.sku", "NFC"); model == "SM-A202F") {
property_override("ro.boot.product.hardware.sku", "NFC");
} }
set_ro_build_prop("model", model); set_ro_build_prop("model", model);

167
universal7885-common/interfaces/hardware/battery/1.0/default/Battery.cpp
View file

@ -13,96 +13,97 @@
// limitations under the License. // limitations under the License.
#include "Battery.h" #include "Battery.h"
#include <iostream>
#include <fstream>
#include <sstream>
#include <unistd.h> #include <unistd.h>
#include <fstream>
#include <iostream>
#include <sstream>
namespace vendor::eureka::hardware::battery::V1_0 { namespace vendor::eureka::hardware::battery::V1_0 {
// Methods from ::android::hardware::battery::V1_0::IBattery follow. // Methods from ::android::hardware::battery::V1_0::IBattery follow.
Return<int32_t> Battery::getBatteryStats(battery::V1_0::SysfsType stats) { Return<int32_t> Battery::getBatteryStats(battery::V1_0::SysfsType stats) {
std::ifstream file; std::ifstream file;
std::string filename; std::string filename;
switch (stats){ switch (stats) {
case SysfsType::CAPACITY_MAX: case SysfsType::CAPACITY_MAX:
filename = "/sys/devices/platform/battery/power_supply/battery/charge_full"; filename = "/sys/devices/platform/battery/power_supply/battery/charge_full";
break; break;
case SysfsType::TEMP: case SysfsType::TEMP:
filename = "/sys/devices/platform/battery/power_supply/battery/batt_temp"; filename = "/sys/devices/platform/battery/power_supply/battery/batt_temp";
break; break;
case SysfsType::CAPACITY_CURRENT: case SysfsType::CAPACITY_CURRENT:
filename = "/sys/devices/platform/battery/power_supply/battery/capacity"; filename = "/sys/devices/platform/battery/power_supply/battery/capacity";
break; break;
case SysfsType::CURRENT: case SysfsType::CURRENT:
filename = "/sys/devices/platform/battery/power_supply/battery/current_now"; filename = "/sys/devices/platform/battery/power_supply/battery/current_now";
break; break;
case SysfsType::FASTCHARGE: case SysfsType::FASTCHARGE:
filename = "/sys/class/sec/switch/afc_disable"; filename = "/sys/class/sec/switch/afc_disable";
break; break;
case SysfsType::CHARGE: case SysfsType::CHARGE:
filename = "/sys/devices/platform/battery/power_supply/battery/batt_slate_mode"; filename = "/sys/devices/platform/battery/power_supply/battery/batt_slate_mode";
break; break;
default: default:
filename = ""; filename = "";
break; break;
} }
std::string value; std::string value;
int32_t intvalue; int32_t intvalue;
file.open(filename); file.open(filename);
if (file.is_open()) { if (file.is_open()) {
getline(file, value); getline(file, value);
file.close();
std::stringstream val(value);
val >> intvalue;
return intvalue;
}
return -1;
}
Return<int32_t> Battery::setBatteryWritable(battery::V1_0::SysfsType stats, battery::V1_0::Number value) {
std::ofstream file;
std::string filename;
bool FastCharge = false;
switch (stats){
case SysfsType::CAPACITY_MAX:
filename = "/sys/devices/platform/battery/power_supply/battery/charge_full";
break;
case SysfsType::TEMP:
filename = "/sys/devices/platform/battery/power_supply/battery/batt_temp";
break;
case SysfsType::CAPACITY_CURRENT:
filename = "/sys/devices/platform/battery/power_supply/battery/capacity";
break;
case SysfsType::CURRENT:
filename = "/sys/devices/platform/battery/power_supply/battery/current_now";
break;
case SysfsType::FASTCHARGE:
filename = "/sys/class/sec/switch/afc_disable";
FastCharge = true;
break;
case SysfsType::CHARGE:
filename = "/sys/devices/platform/battery/power_supply/battery/batt_slate_mode";
break;
default:
filename = "";
break;
}
if(FastCharge) seteuid(ANDROID_SYSTEM_UID);
file.open(filename);
int write;
if (value == Number::ENABLE){
write = 1;
}else{
write = 0;
}
file << write;
file.close(); file.close();
if(FastCharge) seteuid(ANDROID_ROOT_UID); std::stringstream val(value);
return 0; val >> intvalue;
return intvalue;
}
return -1;
} }
IBattery *Battery::getInstance(void){ Return<int32_t> Battery::setBatteryWritable(battery::V1_0::SysfsType stats,
return new Battery(); battery::V1_0::Number value) {
std::ofstream file;
std::string filename;
bool FastCharge = false;
switch (stats) {
case SysfsType::CAPACITY_MAX:
filename = "/sys/devices/platform/battery/power_supply/battery/charge_full";
break;
case SysfsType::TEMP:
filename = "/sys/devices/platform/battery/power_supply/battery/batt_temp";
break;
case SysfsType::CAPACITY_CURRENT:
filename = "/sys/devices/platform/battery/power_supply/battery/capacity";
break;
case SysfsType::CURRENT:
filename = "/sys/devices/platform/battery/power_supply/battery/current_now";
break;
case SysfsType::FASTCHARGE:
filename = "/sys/class/sec/switch/afc_disable";
FastCharge = true;
break;
case SysfsType::CHARGE:
filename = "/sys/devices/platform/battery/power_supply/battery/batt_slate_mode";
break;
default:
filename = "";
break;
}
if (FastCharge) seteuid(ANDROID_SYSTEM_UID);
file.open(filename);
int write;
if (value == Number::ENABLE) {
write = 1;
} else {
write = 0;
}
file << write;
file.close();
if (FastCharge) seteuid(ANDROID_ROOT_UID);
return 0;
} }
} // namespace android::hardware::battery::implementation
IBattery* Battery::getInstance(void) {
return new Battery();
}
} // namespace vendor::eureka::hardware::battery::V1_0

7
universal7885-common/interfaces/hardware/battery/1.0/default/Battery.h
View file

@ -14,22 +14,22 @@
#pragma once #pragma once
#include <vendor/eureka/hardware/battery/1.0/IBattery.h>
#include <hidl/MQDescriptor.h> #include <hidl/MQDescriptor.h>
#include <hidl/Status.h> #include <hidl/Status.h>
#include <vendor/eureka/hardware/battery/1.0/IBattery.h>
#define ANDROID_SYSTEM_UID 1000 #define ANDROID_SYSTEM_UID 1000
#define ANDROID_ROOT_UID 0 #define ANDROID_ROOT_UID 0
namespace vendor::eureka::hardware::battery::V1_0 { namespace vendor::eureka::hardware::battery::V1_0 {
using ::android::sp;
using ::android::hardware::hidl_array; using ::android::hardware::hidl_array;
using ::android::hardware::hidl_memory; using ::android::hardware::hidl_memory;
using ::android::hardware::hidl_string; using ::android::hardware::hidl_string;
using ::android::hardware::hidl_vec; using ::android::hardware::hidl_vec;
using ::android::hardware::Return; using ::android::hardware::Return;
using ::android::hardware::Void; using ::android::hardware::Void;
using ::android::sp;
struct Battery : public IBattery { struct Battery : public IBattery {
// Methods from ::vendor::eureka::hardware::battery::V1_0::IBattery follow. // Methods from ::vendor::eureka::hardware::battery::V1_0::IBattery follow.
@ -38,6 +38,5 @@ struct Battery : public IBattery {
// Methods from ::android::hidl::base::V1_0::IBase follow. // Methods from ::android::hidl::base::V1_0::IBase follow.
static IBattery* getInstance(void); static IBattery* getInstance(void);
}; };
} // namespace android::hardware::battery::implementation } // namespace vendor::eureka::hardware::battery::V1_0

53
universal7885-common/interfaces/hardware/battery/1.0/default/service.cpp
View file

@ -12,38 +12,37 @@
// 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 "vendor.eureka.hardware.battery@1.0-service" #define LOG_TAG "vendor.eureka.hardware.battery@1.0-service"
#include <vendor/eureka/hardware/battery/1.0/IBattery.h> #include <vendor/eureka/hardware/battery/1.0/IBattery.h>
#include <hidl/LegacySupport.h> #include <hidl/LegacySupport.h>
#include "Battery.h" #include "Battery.h"
using vendor::eureka::hardware::battery::V1_0::IBattery; using android::sp;
using vendor::eureka::hardware::battery::V1_0::Battery;
using android::hardware::configureRpcThreadpool; using android::hardware::configureRpcThreadpool;
using android::hardware::joinRpcThreadpool; using android::hardware::joinRpcThreadpool;
using android::sp; using vendor::eureka::hardware::battery::V1_0::Battery;
using vendor::eureka::hardware::battery::V1_0::IBattery;
int main() { int main() {
int ret; int ret;
android::sp<IBattery> service = Battery::getInstance(); android::sp<IBattery> service = Battery::getInstance();
configureRpcThreadpool(1, true /*callerWillJoin*/); configureRpcThreadpool(1, true /*callerWillJoin*/);
if (service != nullptr) { if (service != nullptr) {
ret = service->registerAsService(); ret = service->registerAsService();
if(ret != 0) { if (ret != 0) {
ALOGE("Can't register instance of Battery HAL, nullptr"); ALOGE("Can't register instance of Battery HAL, nullptr");
}else{ } else {
ALOGI("registered Battery HAL"); ALOGI("registered Battery HAL");
} }
} else { } else {
ALOGE("Can't create instance of Battery HAL, nullptr"); ALOGE("Can't create instance of Battery HAL, nullptr");
} }
joinRpcThreadpool(); joinRpcThreadpool();
return -1; // should never get here return -1; // should never get here
} }

160
universal7885-common/interfaces/hardware/flashlight/1.0/default/Flashlight.cpp
View file

@ -13,98 +13,98 @@
// limitations under the License. // limitations under the License.
#include "Flashlight.h" #include "Flashlight.h"
#include <iostream>
#include <fstream> #include <fstream>
#include <iostream>
#include <sstream> #include <sstream>
namespace vendor::eureka::hardware::flashlight::V1_0 { namespace vendor::eureka::hardware::flashlight::V1_0 {
// Methods from ::android::hardware::flashlight::V1_0::IFlashlight follow. // Methods from ::android::hardware::flashlight::V1_0::IFlashlight follow.
Return<int32_t> Flashlight::setFlashlightEnable(flashlight::V1_0::Enable enable) { Return<int32_t> Flashlight::setFlashlightEnable(flashlight::V1_0::Enable enable) {
std::ofstream file; std::ofstream file;
std::string writevalue; std::string writevalue;
switch (enable){ switch (enable) {
case Enable::ENABLE: case Enable::ENABLE:
writevalue = "1"; writevalue = "1";
break; break;
case Enable::DISABLE: case Enable::DISABLE:
writevalue = "0"; writevalue = "0";
break; break;
default: default:
writevalue = ""; writevalue = "";
break; break;
} }
file.open("/sys/class/camera/flash/torch_brightness_lvl_enable"); file.open("/sys/class/camera/flash/torch_brightness_lvl_enable");
file << writevalue; file << writevalue;
file.close(); file.close();
return 0; return 0;
} }
Return<int32_t> Flashlight::setFlashlightWritable(flashlight::V1_0::Number value) { Return<int32_t> Flashlight::setFlashlightWritable(flashlight::V1_0::Number value) {
std::ofstream file; std::ofstream file;
std::string writevalue; std::string writevalue;
switch (value){ switch (value) {
case Number::ONEUI: case Number::ONEUI:
writevalue = "1"; writevalue = "1";
break; break;
case Number::TWOUI: case Number::TWOUI:
writevalue = "2"; writevalue = "2";
break; break;
case Number::THREEUI: case Number::THREEUI:
writevalue = "3"; writevalue = "3";
break; break;
case Number::FOURUI: case Number::FOURUI:
writevalue = "4"; writevalue = "4";
break; break;
case Number::FIVEUI: case Number::FIVEUI:
writevalue = "5"; writevalue = "5";
break; break;
case Number::SIXUI: case Number::SIXUI:
writevalue = "6"; writevalue = "6";
break; break;
case Number::SEVENUI: case Number::SEVENUI:
writevalue = "7"; writevalue = "7";
break; break;
case Number::EIGHTUI: case Number::EIGHTUI:
writevalue = "8"; writevalue = "8";
break; break;
case Number::NINEUI: case Number::NINEUI:
writevalue = "9"; writevalue = "9";
break; break;
case Number::TENUI: case Number::TENUI:
writevalue = "10"; writevalue = "10";
break; break;
default: default:
writevalue = ""; writevalue = "";
break; break;
} }
file.open("/sys/class/camera/flash/torch_brightness_lvl"); file.open("/sys/class/camera/flash/torch_brightness_lvl");
file << writevalue; file << writevalue;
file.close(); file.close();
return 0; return 0;
} }
Return<int32_t> Flashlight::readFlashlightstats(flashlight::V1_0::Device device) { Return<int32_t> Flashlight::readFlashlightstats(flashlight::V1_0::Device device) {
std::ifstream file; std::ifstream file;
std::string value; std::string value;
int32_t intvalue; int32_t intvalue;
file.open("/sys/class/camera/flash/torch_brightness_lvl"); file.open("/sys/class/camera/flash/torch_brightness_lvl");
if (file.is_open()) { if (file.is_open()) {
getline(file, value); getline(file, value);
file.close(); file.close();
std::stringstream val(value); std::stringstream val(value);
val >> intvalue; val >> intvalue;
if (device == Device::A10){ if (device == Device::A10) {
return intvalue; return intvalue;
}else if (device == Device::NOTA10){ } else if (device == Device::NOTA10) {
return intvalue / 21; return intvalue / 21;
} }
// Never Here // Never Here
return -1; return -1;
} }
return -1; return -1;
} }
IFlashlight *Flashlight::getInstance(void){ IFlashlight* Flashlight::getInstance(void) {
return new Flashlight(); return new Flashlight();
} }
} // namespace android::hardware::flashlight::implementation } // namespace vendor::eureka::hardware::flashlight::V1_0

7
universal7885-common/interfaces/hardware/flashlight/1.0/default/Flashlight.h
View file

@ -14,19 +14,19 @@
#pragma once #pragma once
#include <vendor/eureka/hardware/flashlight/1.0/IFlashlight.h>
#include <hidl/MQDescriptor.h> #include <hidl/MQDescriptor.h>
#include <hidl/Status.h> #include <hidl/Status.h>
#include <vendor/eureka/hardware/flashlight/1.0/IFlashlight.h>
namespace vendor::eureka::hardware::flashlight::V1_0 { namespace vendor::eureka::hardware::flashlight::V1_0 {
using ::android::sp;
using ::android::hardware::hidl_array; using ::android::hardware::hidl_array;
using ::android::hardware::hidl_memory; using ::android::hardware::hidl_memory;
using ::android::hardware::hidl_string; using ::android::hardware::hidl_string;
using ::android::hardware::hidl_vec; using ::android::hardware::hidl_vec;
using ::android::hardware::Return; using ::android::hardware::Return;
using ::android::hardware::Void; using ::android::hardware::Void;
using ::android::sp;
struct Flashlight : public IFlashlight { struct Flashlight : public IFlashlight {
// Methods from ::vendor::eureka::hardware::flashlight::V1_0::IFlashlight follow. // Methods from ::vendor::eureka::hardware::flashlight::V1_0::IFlashlight follow.
@ -35,6 +35,5 @@ struct Flashlight : public IFlashlight {
Return<int32_t> readFlashlightstats(Device device); Return<int32_t> readFlashlightstats(Device device);
// Methods from ::android::hidl::base::V1_0::IBase follow. // Methods from ::android::hidl::base::V1_0::IBase follow.
static IFlashlight* getInstance(void); static IFlashlight* getInstance(void);
}; };
} // namespace android::hardware::flashlight::implementation } // namespace vendor::eureka::hardware::flashlight::V1_0

53
universal7885-common/interfaces/hardware/flashlight/1.0/default/service.cpp
View file

@ -12,38 +12,37 @@
// 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 "vendor.eureka.hardware.flashlight@1.0-service" #define LOG_TAG "vendor.eureka.hardware.flashlight@1.0-service"
#include <vendor/eureka/hardware/flashlight/1.0/IFlashlight.h> #include <vendor/eureka/hardware/flashlight/1.0/IFlashlight.h>
#include <hidl/LegacySupport.h> #include <hidl/LegacySupport.h>
#include "Flashlight.h" #include "Flashlight.h"
using vendor::eureka::hardware::flashlight::V1_0::IFlashlight; using android::sp;
using vendor::eureka::hardware::flashlight::V1_0::Flashlight;
using android::hardware::configureRpcThreadpool; using android::hardware::configureRpcThreadpool;
using android::hardware::joinRpcThreadpool; using android::hardware::joinRpcThreadpool;
using android::sp; using vendor::eureka::hardware::flashlight::V1_0::Flashlight;
using vendor::eureka::hardware::flashlight::V1_0::IFlashlight;
int main() { int main() {
int ret; int ret;
android::sp<IFlashlight> service = Flashlight::getInstance(); android::sp<IFlashlight> service = Flashlight::getInstance();
configureRpcThreadpool(1, true /*callerWillJoin*/); configureRpcThreadpool(1, true /*callerWillJoin*/);
if (service != nullptr) { if (service != nullptr) {
ret = service->registerAsService(); ret = service->registerAsService();
if(ret != 0) { if (ret != 0) {
ALOGE("Can't register instance of Flashlight HAL, nullptr"); ALOGE("Can't register instance of Flashlight HAL, nullptr");
}else{ } else {
ALOGI("registered Flashlight HAL"); ALOGI("registered Flashlight HAL");
} }
} else { } else {
ALOGE("Can't create instance of Flashlight HAL, nullptr"); ALOGE("Can't create instance of Flashlight HAL, nullptr");
} }
joinRpcThreadpool(); joinRpcThreadpool();
return -1; // should never get here return -1; // should never get here
} }

50
universal7885-common/interfaces/hardware/gpu/1.0/default/Gpu.cpp
View file

@ -13,41 +13,41 @@
// limitations under the License. // limitations under the License.
#include "Gpu.h" #include "Gpu.h"
#include <iostream>
#include <fstream> #include <fstream>
#include <iostream>
#include <sstream> #include <sstream>
namespace vendor::eureka::hardware::gpu::V1_0 { namespace vendor::eureka::hardware::gpu::V1_0 {
Return<int32_t> Gpu::setGpuWritable(gpu::V1_0::Enable enable) { Return<int32_t> Gpu::setGpuWritable(gpu::V1_0::Enable enable) {
std::ofstream file; std::ofstream file;
std::string writevalue; std::string writevalue;
if (enable == Enable::ENABLE){ if (enable == Enable::ENABLE) {
writevalue = "1"; writevalue = "1";
}else{ } else {
writevalue = "0"; writevalue = "0";
} }
file.open("/sys/devices/platform/11500000.mali/tmu"); file.open("/sys/devices/platform/11500000.mali/tmu");
file << writevalue; file << writevalue;
file.close(); file.close();
return 0; return 0;
} }
Return<int32_t> Gpu::readGpustats(void) { Return<int32_t> Gpu::readGpustats(void) {
std::ifstream file; std::ifstream file;
std::string value; std::string value;
int32_t intvalue; int32_t intvalue;
file.open("/sys/devices/platform/11500000.mali/tmu"); file.open("/sys/devices/platform/11500000.mali/tmu");
if (file.is_open()) { if (file.is_open()) {
getline(file, value); getline(file, value);
file.close(); file.close();
std::stringstream val(value); std::stringstream val(value);
val >> intvalue; val >> intvalue;
return intvalue; return intvalue;
} }
return -1; return -1;
} }
IGpu *Gpu::getInstance(void){ IGpu* Gpu::getInstance(void) {
return new Gpu(); return new Gpu();
} }
} // namespace android::hardware::gpu::implementation } // namespace vendor::eureka::hardware::gpu::V1_0

7
universal7885-common/interfaces/hardware/gpu/1.0/default/Gpu.h
View file

@ -14,19 +14,19 @@
#pragma once #pragma once
#include <vendor/eureka/hardware/gpu/1.0/IGpu.h>
#include <hidl/MQDescriptor.h> #include <hidl/MQDescriptor.h>
#include <hidl/Status.h> #include <hidl/Status.h>
#include <vendor/eureka/hardware/gpu/1.0/IGpu.h>
namespace vendor::eureka::hardware::gpu::V1_0 { namespace vendor::eureka::hardware::gpu::V1_0 {
using ::android::sp;
using ::android::hardware::hidl_array; using ::android::hardware::hidl_array;
using ::android::hardware::hidl_memory; using ::android::hardware::hidl_memory;
using ::android::hardware::hidl_string; using ::android::hardware::hidl_string;
using ::android::hardware::hidl_vec; using ::android::hardware::hidl_vec;
using ::android::hardware::Return; using ::android::hardware::Return;
using ::android::hardware::Void; using ::android::hardware::Void;
using ::android::sp;
struct Gpu : public IGpu { struct Gpu : public IGpu {
// Methods from ::vendor::eureka::hardware::gpu::V1_0::IGpu follow. // Methods from ::vendor::eureka::hardware::gpu::V1_0::IGpu follow.
@ -34,6 +34,5 @@ struct Gpu : public IGpu {
Return<int32_t> readGpustats(void); Return<int32_t> readGpustats(void);
// Methods from ::android::hidl::base::V1_0::IBase follow. // Methods from ::android::hidl::base::V1_0::IBase follow.
static IGpu* getInstance(void); static IGpu* getInstance(void);
}; };
} // namespace android::hardware::gpu::implementation } // namespace vendor::eureka::hardware::gpu::V1_0

53
universal7885-common/interfaces/hardware/gpu/1.0/default/service.cpp
View file

@ -12,38 +12,37 @@
// 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 "vendor.eureka.hardware.gpu@1.0-service" #define LOG_TAG "vendor.eureka.hardware.gpu@1.0-service"
#include <vendor/eureka/hardware/gpu/1.0/IGpu.h> #include <vendor/eureka/hardware/gpu/1.0/IGpu.h>
#include <hidl/LegacySupport.h> #include <hidl/LegacySupport.h>
#include "Gpu.h" #include "Gpu.h"
using vendor::eureka::hardware::gpu::V1_0::IGpu; using android::sp;
using vendor::eureka::hardware::gpu::V1_0::Gpu;
using android::hardware::configureRpcThreadpool; using android::hardware::configureRpcThreadpool;
using android::hardware::joinRpcThreadpool; using android::hardware::joinRpcThreadpool;
using android::sp; using vendor::eureka::hardware::gpu::V1_0::Gpu;
using vendor::eureka::hardware::gpu::V1_0::IGpu;
int main() { int main() {
int ret; int ret;
android::sp<IGpu> service = Gpu::getInstance(); android::sp<IGpu> service = Gpu::getInstance();
configureRpcThreadpool(1, true /*callerWillJoin*/); configureRpcThreadpool(1, true /*callerWillJoin*/);
if (service != nullptr) { if (service != nullptr) {
ret = service->registerAsService(); ret = service->registerAsService();
if(ret != 0) { if (ret != 0) {
ALOGE("Can't register instance of Gpu HAL, nullptr"); ALOGE("Can't register instance of Gpu HAL, nullptr");
}else{ } else {
ALOGI("registered Gpu HAL"); ALOGI("registered Gpu HAL");
} }
} else { } else {
ALOGE("Can't create instance of Gpu HAL, nullptr"); ALOGE("Can't create instance of Gpu HAL, nullptr");
} }
joinRpcThreadpool(); joinRpcThreadpool();
return -1; // should never get here return -1; // should never get here
} }

50
universal7885-common/interfaces/security/selinux/1.0/default/SELinux.cpp
View file

@ -13,41 +13,41 @@
// limitations under the License. // limitations under the License.
#include "SELinux.h" #include "SELinux.h"
#include <iostream>
#include <fstream> #include <fstream>
#include <iostream>
#include <sstream> #include <sstream>
namespace vendor::eureka::security::selinux::V1_0 { namespace vendor::eureka::security::selinux::V1_0 {
Return<int32_t> SELinux::setSELinuxWritable(selinux::V1_0::Enable enable) { Return<int32_t> SELinux::setSELinuxWritable(selinux::V1_0::Enable enable) {
std::ofstream file; std::ofstream file;
std::string writevalue; std::string writevalue;
if (enable == Enable::ENABLE){ if (enable == Enable::ENABLE) {
writevalue = "1"; writevalue = "1";
}else{ } else {
writevalue = "0"; writevalue = "0";
} }
file.open("/sys/fs/selinux/enforce"); file.open("/sys/fs/selinux/enforce");
file << writevalue; file << writevalue;
file.close(); file.close();
return 0; return 0;
} }
Return<int32_t> SELinux::readSELinuxstats(void) { Return<int32_t> SELinux::readSELinuxstats(void) {
std::ifstream file; std::ifstream file;
std::string value; std::string value;
int32_t intvalue; int32_t intvalue;
file.open("/sys/fs/selinux/enforce"); file.open("/sys/fs/selinux/enforce");
if (file.is_open()) { if (file.is_open()) {
getline(file, value); getline(file, value);
file.close(); file.close();
std::stringstream val(value); std::stringstream val(value);
val >> intvalue; val >> intvalue;
return intvalue; return intvalue;
} }
return -1; return -1;
} }
ISELinux *SELinux::getInstance(void){ ISELinux* SELinux::getInstance(void) {
return new SELinux(); return new SELinux();
} }
} // namespace android::security::selinux::implementation } // namespace vendor::eureka::security::selinux::V1_0

7
universal7885-common/interfaces/security/selinux/1.0/default/SELinux.h
View file

@ -14,19 +14,19 @@
#pragma once #pragma once
#include <vendor/eureka/security/selinux/1.0/ISELinux.h>
#include <hidl/MQDescriptor.h> #include <hidl/MQDescriptor.h>
#include <hidl/Status.h> #include <hidl/Status.h>
#include <vendor/eureka/security/selinux/1.0/ISELinux.h>
namespace vendor::eureka::security::selinux::V1_0 { namespace vendor::eureka::security::selinux::V1_0 {
using ::android::sp;
using ::android::hardware::hidl_array; using ::android::hardware::hidl_array;
using ::android::hardware::hidl_memory; using ::android::hardware::hidl_memory;
using ::android::hardware::hidl_string; using ::android::hardware::hidl_string;
using ::android::hardware::hidl_vec; using ::android::hardware::hidl_vec;
using ::android::hardware::Return; using ::android::hardware::Return;
using ::android::hardware::Void; using ::android::hardware::Void;
using ::android::sp;
struct SELinux : public ISELinux { struct SELinux : public ISELinux {
// Methods from ::vendor::eureka::security::selinux::V1_0::ISELinux follow. // Methods from ::vendor::eureka::security::selinux::V1_0::ISELinux follow.
@ -34,6 +34,5 @@ struct SELinux : public ISELinux {
Return<int32_t> readSELinuxstats(void); Return<int32_t> readSELinuxstats(void);
// Methods from ::android::hidl::base::V1_0::IBase follow. // Methods from ::android::hidl::base::V1_0::IBase follow.
static ISELinux* getInstance(void); static ISELinux* getInstance(void);
}; };
} // namespace android::security::selinux::implementation } // namespace vendor::eureka::security::selinux::V1_0

53
universal7885-common/interfaces/security/selinux/1.0/default/service.cpp
View file

@ -12,38 +12,37 @@
// 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 "vendor.eureka.security.selinux@1.0-service" #define LOG_TAG "vendor.eureka.security.selinux@1.0-service"
#include <vendor/eureka/security/selinux/1.0/ISELinux.h> #include <vendor/eureka/security/selinux/1.0/ISELinux.h>
#include <hidl/LegacySupport.h> #include <hidl/LegacySupport.h>
#include "SELinux.h" #include "SELinux.h"
using vendor::eureka::security::selinux::V1_0::ISELinux; using android::sp;
using vendor::eureka::security::selinux::V1_0::SELinux;
using android::hardware::configureRpcThreadpool; using android::hardware::configureRpcThreadpool;
using android::hardware::joinRpcThreadpool; using android::hardware::joinRpcThreadpool;
using android::sp; using vendor::eureka::security::selinux::V1_0::ISELinux;
using vendor::eureka::security::selinux::V1_0::SELinux;
int main() { int main() {
int ret; int ret;
android::sp<ISELinux> service = SELinux::getInstance(); android::sp<ISELinux> service = SELinux::getInstance();
configureRpcThreadpool(1, true /*callerWillJoin*/); configureRpcThreadpool(1, true /*callerWillJoin*/);
if (service != nullptr) { if (service != nullptr) {
ret = service->registerAsService(); ret = service->registerAsService();
if(ret != 0) { if (ret != 0) {
ALOGE("Can't register instance of SELinux HAL, nullptr"); ALOGE("Can't register instance of SELinux HAL, nullptr");
}else{ } else {
ALOGI("registered SELinux HAL"); ALOGI("registered SELinux HAL");
} }
} else { } else {
ALOGE("Can't create instance of SELinux HAL, nullptr"); ALOGE("Can't create instance of SELinux HAL, nullptr");
} }
joinRpcThreadpool(); joinRpcThreadpool();
return -1; // should never get here return -1; // should never get here
} }

167
universal7885-common/libshims/camera/CameraMetadata.cpp
View file

@ -24,41 +24,34 @@
namespace android { namespace android {
#define ALIGN_TO(val, alignment) \ #define ALIGN_TO(val, alignment) (((uintptr_t)(val) + ((alignment)-1)) & ~((alignment)-1))
(((uintptr_t)(val) + ((alignment) - 1)) & ~((alignment) - 1))
CameraMetadata::CameraMetadata() : CameraMetadata::CameraMetadata() : mBuffer(NULL), mLocked(false) {}
mBuffer(NULL), mLocked(false) {
}
CameraMetadata::CameraMetadata(size_t entryCapacity, size_t dataCapacity) : CameraMetadata::CameraMetadata(size_t entryCapacity, size_t dataCapacity) : mLocked(false) {
mLocked(false)
{
mBuffer = allocate_camera_metadata(entryCapacity, dataCapacity); mBuffer = allocate_camera_metadata(entryCapacity, dataCapacity);
} }
CameraMetadata::CameraMetadata(const CameraMetadata &other) : CameraMetadata::CameraMetadata(const CameraMetadata& other) : mLocked(false) {
mLocked(false) {
mBuffer = clone_camera_metadata(other.mBuffer); mBuffer = clone_camera_metadata(other.mBuffer);
} }
CameraMetadata::CameraMetadata(camera_metadata_t *buffer) : CameraMetadata::CameraMetadata(camera_metadata_t* buffer) : mBuffer(NULL), mLocked(false) {
mBuffer(NULL), mLocked(false) {
acquire(buffer); acquire(buffer);
} }
CameraMetadata &CameraMetadata::operator=(const CameraMetadata &other) { CameraMetadata& CameraMetadata::operator=(const CameraMetadata& other) {
return operator=(other.mBuffer); return operator=(other.mBuffer);
} }
CameraMetadata &CameraMetadata::operator=(const camera_metadata_t *buffer) { CameraMetadata& CameraMetadata::operator=(const camera_metadata_t* buffer) {
if (mLocked) { if (mLocked) {
ALOGE("%s: Assignment to a locked CameraMetadata!", __FUNCTION__); ALOGE("%s: Assignment to a locked CameraMetadata!", __FUNCTION__);
return *this; return *this;
} }
if (CC_LIKELY(buffer != mBuffer)) { if (CC_LIKELY(buffer != mBuffer)) {
camera_metadata_t *newBuffer = clone_camera_metadata(buffer); camera_metadata_t* newBuffer = clone_camera_metadata(buffer);
clear(); clear();
mBuffer = newBuffer; mBuffer = newBuffer;
} }
@ -75,14 +68,13 @@ const camera_metadata_t* CameraMetadata::getAndLock() const {
return mBuffer; return mBuffer;
} }
status_t CameraMetadata::unlock(const camera_metadata_t *buffer) const { status_t CameraMetadata::unlock(const camera_metadata_t* buffer) const {
if (!mLocked) { if (!mLocked) {
ALOGE("%s: Can't unlock a non-locked CameraMetadata!", __FUNCTION__); ALOGE("%s: Can't unlock a non-locked CameraMetadata!", __FUNCTION__);
return INVALID_OPERATION; return INVALID_OPERATION;
} }
if (buffer != mBuffer) { if (buffer != mBuffer) {
ALOGE("%s: Can't unlock CameraMetadata with wrong pointer!", ALOGE("%s: Can't unlock CameraMetadata with wrong pointer!", __FUNCTION__);
__FUNCTION__);
return BAD_VALUE; return BAD_VALUE;
} }
mLocked = false; mLocked = false;
@ -94,7 +86,7 @@ camera_metadata_t* CameraMetadata::release() {
ALOGE("%s: CameraMetadata is locked", __FUNCTION__); ALOGE("%s: CameraMetadata is locked", __FUNCTION__);
return NULL; return NULL;
} }
camera_metadata_t *released = mBuffer; camera_metadata_t* released = mBuffer;
mBuffer = NULL; mBuffer = NULL;
return released; return released;
} }
@ -110,7 +102,7 @@ void CameraMetadata::clear() {
} }
} }
void CameraMetadata::acquire(camera_metadata_t *buffer) { void CameraMetadata::acquire(camera_metadata_t* buffer) {
if (mLocked) { if (mLocked) {
ALOGE("%s: CameraMetadata is locked", __FUNCTION__); ALOGE("%s: CameraMetadata is locked", __FUNCTION__);
return; return;
@ -118,12 +110,11 @@ void CameraMetadata::acquire(camera_metadata_t *buffer) {
clear(); clear();
mBuffer = buffer; mBuffer = buffer;
ALOGE_IF(validate_camera_metadata_structure(mBuffer, /*size*/NULL) != OK, ALOGE_IF(validate_camera_metadata_structure(mBuffer, /*size*/ NULL) != OK,
"%s: Failed to validate metadata structure %p", "%s: Failed to validate metadata structure %p", __FUNCTION__, buffer);
__FUNCTION__, buffer);
} }
void CameraMetadata::acquire(CameraMetadata &other) { void CameraMetadata::acquire(CameraMetadata& other) {
if (mLocked) { if (mLocked) {
ALOGE("%s: CameraMetadata is locked", __FUNCTION__); ALOGE("%s: CameraMetadata is locked", __FUNCTION__);
return; return;
@ -131,7 +122,7 @@ void CameraMetadata::acquire(CameraMetadata &other) {
acquire(other.release()); acquire(other.release());
} }
status_t CameraMetadata::append(const CameraMetadata &other) { status_t CameraMetadata::append(const CameraMetadata& other) {
return append(other.mBuffer); return append(other.mBuffer);
} }
@ -148,8 +139,7 @@ status_t CameraMetadata::append(const camera_metadata_t* other) {
} }
size_t CameraMetadata::entryCount() const { size_t CameraMetadata::entryCount() const {
return (mBuffer == NULL) ? 0 : return (mBuffer == NULL) ? 0 : get_camera_metadata_entry_count(mBuffer);
get_camera_metadata_entry_count(mBuffer);
} }
bool CameraMetadata::isEmpty() const { bool CameraMetadata::isEmpty() const {
@ -166,127 +156,119 @@ status_t CameraMetadata::sort() {
status_t CameraMetadata::checkType(uint32_t tag, uint8_t expectedType) { status_t CameraMetadata::checkType(uint32_t tag, uint8_t expectedType) {
int tagType = get_local_camera_metadata_tag_type(tag, mBuffer); int tagType = get_local_camera_metadata_tag_type(tag, mBuffer);
if ( CC_UNLIKELY(tagType == -1)) { if (CC_UNLIKELY(tagType == -1)) {
ALOGE("Update metadata entry: Unknown tag %d", tag); ALOGE("Update metadata entry: Unknown tag %d", tag);
return INVALID_OPERATION; return INVALID_OPERATION;
} }
if ( CC_UNLIKELY(tagType != expectedType) ) { if (CC_UNLIKELY(tagType != expectedType)) {
ALOGE("Mismatched tag type when updating entry %s (%d) of type %s; " ALOGE("Mismatched tag type when updating entry %s (%d) of type %s; "
"got type %s data instead ", "got type %s data instead ",
get_local_camera_metadata_tag_name(tag, mBuffer), tag, get_local_camera_metadata_tag_name(tag, mBuffer), tag,
camera_metadata_type_names[tagType], camera_metadata_type_names[tagType], camera_metadata_type_names[expectedType]);
camera_metadata_type_names[expectedType]);
return INVALID_OPERATION; return INVALID_OPERATION;
} }
return OK; return OK;
} }
status_t CameraMetadata::update(uint32_t tag, status_t CameraMetadata::update(uint32_t tag, const int32_t* data, size_t data_count) {
const int32_t *data, size_t data_count) {
status_t res; status_t res;
if (mLocked) { if (mLocked) {
ALOGE("%s: CameraMetadata is locked", __FUNCTION__); ALOGE("%s: CameraMetadata is locked", __FUNCTION__);
return INVALID_OPERATION; return INVALID_OPERATION;
} }
if ( (res = checkType(tag, TYPE_INT32)) != OK) { if ((res = checkType(tag, TYPE_INT32)) != OK) {
return res; return res;
} }
return updateImpl(tag, (const void*)data, data_count); return updateImpl(tag, (const void*)data, data_count);
} }
status_t CameraMetadata::update(uint32_t tag, status_t CameraMetadata::update(uint32_t tag, const uint8_t* data, size_t data_count) {
const uint8_t *data, size_t data_count) {
status_t res; status_t res;
if (mLocked) { if (mLocked) {
ALOGE("%s: CameraMetadata is locked", __FUNCTION__); ALOGE("%s: CameraMetadata is locked", __FUNCTION__);
return INVALID_OPERATION; return INVALID_OPERATION;
} }
if ( (res = checkType(tag, TYPE_BYTE)) != OK) { if ((res = checkType(tag, TYPE_BYTE)) != OK) {
return res; return res;
} }
return updateImpl(tag, (const void*)data, data_count); return updateImpl(tag, (const void*)data, data_count);
} }
status_t CameraMetadata::update(uint32_t tag, status_t CameraMetadata::update(uint32_t tag, const float* data, size_t data_count) {
const float *data, size_t data_count) {
status_t res; status_t res;
if (mLocked) { if (mLocked) {
ALOGE("%s: CameraMetadata is locked", __FUNCTION__); ALOGE("%s: CameraMetadata is locked", __FUNCTION__);
return INVALID_OPERATION; return INVALID_OPERATION;
} }
if ( (res = checkType(tag, TYPE_FLOAT)) != OK) { if ((res = checkType(tag, TYPE_FLOAT)) != OK) {
return res; return res;
} }
return updateImpl(tag, (const void*)data, data_count); return updateImpl(tag, (const void*)data, data_count);
} }
status_t CameraMetadata::update(uint32_t tag, status_t CameraMetadata::update(uint32_t tag, const int64_t* data, size_t data_count) {
const int64_t *data, size_t data_count) {
status_t res; status_t res;
if (mLocked) { if (mLocked) {
ALOGE("%s: CameraMetadata is locked", __FUNCTION__); ALOGE("%s: CameraMetadata is locked", __FUNCTION__);
return INVALID_OPERATION; return INVALID_OPERATION;
} }
if ( (res = checkType(tag, TYPE_INT64)) != OK) { if ((res = checkType(tag, TYPE_INT64)) != OK) {
return res; return res;
} }
return updateImpl(tag, (const void*)data, data_count); return updateImpl(tag, (const void*)data, data_count);
} }
status_t CameraMetadata::update(uint32_t tag, status_t CameraMetadata::update(uint32_t tag, const double* data, size_t data_count) {
const double *data, size_t data_count) {
status_t res; status_t res;
if (mLocked) { if (mLocked) {
ALOGE("%s: CameraMetadata is locked", __FUNCTION__); ALOGE("%s: CameraMetadata is locked", __FUNCTION__);
return INVALID_OPERATION; return INVALID_OPERATION;
} }
if ( (res = checkType(tag, TYPE_DOUBLE)) != OK) { if ((res = checkType(tag, TYPE_DOUBLE)) != OK) {
return res; return res;
} }
return updateImpl(tag, (const void*)data, data_count); return updateImpl(tag, (const void*)data, data_count);
} }
status_t CameraMetadata::update(uint32_t tag, status_t CameraMetadata::update(uint32_t tag, const camera_metadata_rational_t* data,
const camera_metadata_rational_t *data, size_t data_count) { size_t data_count) {
status_t res; status_t res;
if (mLocked) { if (mLocked) {
ALOGE("%s: CameraMetadata is locked", __FUNCTION__); ALOGE("%s: CameraMetadata is locked", __FUNCTION__);
return INVALID_OPERATION; return INVALID_OPERATION;
} }
if ( (res = checkType(tag, TYPE_RATIONAL)) != OK) { if ((res = checkType(tag, TYPE_RATIONAL)) != OK) {
return res; return res;
} }
return updateImpl(tag, (const void*)data, data_count); return updateImpl(tag, (const void*)data, data_count);
} }
status_t CameraMetadata::update(uint32_t tag, status_t CameraMetadata::update(uint32_t tag, const String8& string) {
const String8 &string) {
status_t res; status_t res;
if (mLocked) { if (mLocked) {
ALOGE("%s: CameraMetadata is locked", __FUNCTION__); ALOGE("%s: CameraMetadata is locked", __FUNCTION__);
return INVALID_OPERATION; return INVALID_OPERATION;
} }
if ( (res = checkType(tag, TYPE_BYTE)) != OK) { if ((res = checkType(tag, TYPE_BYTE)) != OK) {
return res; return res;
} }
// string.size() doesn't count the null termination character. // string.size() doesn't count the null termination character.
return updateImpl(tag, (const void*)string.string(), string.size() + 1); return updateImpl(tag, (const void*)string.string(), string.size() + 1);
} }
status_t CameraMetadata::update(const camera_metadata_ro_entry &entry) { status_t CameraMetadata::update(const camera_metadata_ro_entry& entry) {
status_t res; status_t res;
if (mLocked) { if (mLocked) {
ALOGE("%s: CameraMetadata is locked", __FUNCTION__); ALOGE("%s: CameraMetadata is locked", __FUNCTION__);
return INVALID_OPERATION; return INVALID_OPERATION;
} }
if ( (res = checkType(entry.tag, entry.type)) != OK) { if ((res = checkType(entry.tag, entry.type)) != OK) {
return res; return res;
} }
return updateImpl(entry.tag, (const void*)entry.data.u8, entry.count); return updateImpl(entry.tag, (const void*)entry.data.u8, entry.count);
} }
status_t CameraMetadata::updateImpl(uint32_t tag, const void *data, status_t CameraMetadata::updateImpl(uint32_t tag, const void* data, size_t data_count) {
size_t data_count) {
status_t res; status_t res;
if (mLocked) { if (mLocked) {
ALOGE("%s: CameraMetadata is locked", __FUNCTION__); ALOGE("%s: CameraMetadata is locked", __FUNCTION__);
@ -303,13 +285,11 @@ status_t CameraMetadata::updateImpl(uint32_t tag, const void *data,
uintptr_t bufAddr = reinterpret_cast<uintptr_t>(mBuffer); uintptr_t bufAddr = reinterpret_cast<uintptr_t>(mBuffer);
uintptr_t dataAddr = reinterpret_cast<uintptr_t>(data); uintptr_t dataAddr = reinterpret_cast<uintptr_t>(data);
if (dataAddr > bufAddr && dataAddr < (bufAddr + bufferSize)) { if (dataAddr > bufAddr && dataAddr < (bufAddr + bufferSize)) {
ALOGE("%s: Update attempted with data from the same metadata buffer!", ALOGE("%s: Update attempted with data from the same metadata buffer!", __FUNCTION__);
__FUNCTION__);
return INVALID_OPERATION; return INVALID_OPERATION;
} }
size_t data_size = calculate_camera_metadata_entry_data_size(type, size_t data_size = calculate_camera_metadata_entry_data_size(type, data_count);
data_count);
res = resizeIfNeeded(1, data_size); res = resizeIfNeeded(1, data_size);
@ -317,27 +297,23 @@ status_t CameraMetadata::updateImpl(uint32_t tag, const void *data,
camera_metadata_entry_t entry; camera_metadata_entry_t entry;
res = find_camera_metadata_entry(mBuffer, tag, &entry); res = find_camera_metadata_entry(mBuffer, tag, &entry);
if (res == NAME_NOT_FOUND) { if (res == NAME_NOT_FOUND) {
res = add_camera_metadata_entry(mBuffer, res = add_camera_metadata_entry(mBuffer, tag, data, data_count);
tag, data, data_count);
} else if (res == OK) { } else if (res == OK) {
res = update_camera_metadata_entry(mBuffer, res = update_camera_metadata_entry(mBuffer, entry.index, data, data_count, NULL);
entry.index, data, data_count, NULL);
} }
} }
if (res != OK) { if (res != OK) {
ALOGE("%s: Unable to update metadata entry %s.%s (%x): %s (%d)", ALOGE("%s: Unable to update metadata entry %s.%s (%x): %s (%d)", __FUNCTION__,
__FUNCTION__, get_local_camera_metadata_section_name(tag, mBuffer), get_local_camera_metadata_section_name(tag, mBuffer),
get_local_camera_metadata_tag_name(tag, mBuffer), tag, get_local_camera_metadata_tag_name(tag, mBuffer), tag, strerror(-res), res);
strerror(-res), res);
} }
IF_ALOGV() { IF_ALOGV() {
ALOGE_IF(validate_camera_metadata_structure(mBuffer, /*size*/NULL) != ALOGE_IF(validate_camera_metadata_structure(mBuffer, /*size*/ NULL) != OK,
OK,
"%s: Failed to validate metadata structure after update %p", "%s: Failed to validate metadata structure after update %p", __FUNCTION__,
__FUNCTION__, mBuffer); mBuffer);
} }
return res; return res;
@ -357,7 +333,7 @@ camera_metadata_entry_t CameraMetadata::find(uint32_t tag) {
return entry; return entry;
} }
res = find_camera_metadata_entry(mBuffer, tag, &entry); res = find_camera_metadata_entry(mBuffer, tag, &entry);
if (CC_UNLIKELY( res != OK )) { if (CC_UNLIKELY(res != OK)) {
entry.count = 0; entry.count = 0;
entry.data.u8 = NULL; entry.data.u8 = NULL;
} }
@ -368,7 +344,7 @@ camera_metadata_ro_entry_t CameraMetadata::find(uint32_t tag) const {
status_t res; status_t res;
camera_metadata_ro_entry entry; camera_metadata_ro_entry entry;
res = find_camera_metadata_ro_entry(mBuffer, tag, &entry); res = find_camera_metadata_ro_entry(mBuffer, tag, &entry);
if (CC_UNLIKELY( res != OK )) { if (CC_UNLIKELY(res != OK)) {
entry.count = 0; entry.count = 0;
entry.data.u8 = NULL; entry.data.u8 = NULL;
} }
@ -386,20 +362,16 @@ status_t CameraMetadata::erase(uint32_t tag) {
if (res == NAME_NOT_FOUND) { if (res == NAME_NOT_FOUND) {
return OK; return OK;
} else if (res != OK) { } else if (res != OK) {
ALOGE("%s: Error looking for entry %s.%s (%x): %s %d", ALOGE("%s: Error looking for entry %s.%s (%x): %s %d", __FUNCTION__,
__FUNCTION__, get_local_camera_metadata_section_name(tag, mBuffer),
get_local_camera_metadata_section_name(tag, mBuffer), get_local_camera_metadata_tag_name(tag, mBuffer), tag, strerror(-res), res);
get_local_camera_metadata_tag_name(tag, mBuffer),
tag, strerror(-res), res);
return res; return res;
} }
res = delete_camera_metadata_entry(mBuffer, entry.index); res = delete_camera_metadata_entry(mBuffer, entry.index);
if (res != OK) { if (res != OK) {
ALOGE("%s: Error deleting entry %s.%s (%x): %s %d", ALOGE("%s: Error deleting entry %s.%s (%x): %s %d", __FUNCTION__,
__FUNCTION__, get_local_camera_metadata_section_name(tag, mBuffer),
get_local_camera_metadata_section_name(tag, mBuffer), get_local_camera_metadata_tag_name(tag, mBuffer), tag, strerror(-res), res);
get_local_camera_metadata_tag_name(tag, mBuffer),
tag, strerror(-res), res);
} }
return res; return res;
} }
@ -418,23 +390,17 @@ status_t CameraMetadata::resizeIfNeeded(size_t extraEntries, size_t extraData) {
} else { } else {
size_t currentEntryCount = get_camera_metadata_entry_count(mBuffer); size_t currentEntryCount = get_camera_metadata_entry_count(mBuffer);
size_t currentEntryCap = get_camera_metadata_entry_capacity(mBuffer); size_t currentEntryCap = get_camera_metadata_entry_capacity(mBuffer);
size_t newEntryCount = currentEntryCount + size_t newEntryCount = currentEntryCount + extraEntries;
extraEntries; newEntryCount = (newEntryCount > currentEntryCap) ? newEntryCount * 2 : currentEntryCap;
newEntryCount = (newEntryCount > currentEntryCap) ?
newEntryCount * 2 : currentEntryCap;
size_t currentDataCount = get_camera_metadata_data_count(mBuffer); size_t currentDataCount = get_camera_metadata_data_count(mBuffer);
size_t currentDataCap = get_camera_metadata_data_capacity(mBuffer); size_t currentDataCap = get_camera_metadata_data_capacity(mBuffer);
size_t newDataCount = currentDataCount + size_t newDataCount = currentDataCount + extraData;
extraData; newDataCount = (newDataCount > currentDataCap) ? newDataCount * 2 : currentDataCap;
newDataCount = (newDataCount > currentDataCap) ?
newDataCount * 2 : currentDataCap;
if (newEntryCount > currentEntryCap || if (newEntryCount > currentEntryCap || newDataCount > currentDataCap) {
newDataCount > currentDataCap) { camera_metadata_t* oldBuffer = mBuffer;
camera_metadata_t *oldBuffer = mBuffer; mBuffer = allocate_camera_metadata(newEntryCount, newDataCount);
mBuffer = allocate_camera_metadata(newEntryCount,
newDataCount);
if (mBuffer == NULL) { if (mBuffer == NULL) {
ALOGE("%s: Can't allocate larger metadata buffer", __FUNCTION__); ALOGE("%s: Can't allocate larger metadata buffer", __FUNCTION__);
return NO_MEMORY; return NO_MEMORY;
@ -462,5 +428,4 @@ void CameraMetadata::swap(CameraMetadata& other) {
mBuffer = otherBuf; mBuffer = otherBuf;
} }
}; // namespace android
}; // namespace android

53
universal7885-common/libshims/camera/CameraMetadata.h
View file

@ -39,15 +39,15 @@ class CameraMetadata {
~CameraMetadata(); ~CameraMetadata();
/** Takes ownership of passed-in buffer */ /** Takes ownership of passed-in buffer */
CameraMetadata(camera_metadata_t *buffer); CameraMetadata(camera_metadata_t* buffer);
/** Clones the metadata */ /** Clones the metadata */
CameraMetadata(const CameraMetadata &other); CameraMetadata(const CameraMetadata& other);
/** /**
* Assignment clones metadata buffer. * Assignment clones metadata buffer.
*/ */
CameraMetadata &operator=(const CameraMetadata &other); CameraMetadata& operator=(const CameraMetadata& other);
CameraMetadata &operator=(const camera_metadata_t *buffer); CameraMetadata& operator=(const camera_metadata_t* buffer);
/** /**
* Get reference to the underlying metadata buffer. Ownership remains with * Get reference to the underlying metadata buffer. Ownership remains with
@ -64,7 +64,7 @@ class CameraMetadata {
* from getAndLock must be provided to guarantee that the right object is * from getAndLock must be provided to guarantee that the right object is
* being unlocked. * being unlocked.
*/ */
status_t unlock(const camera_metadata_t *buffer) const; status_t unlock(const camera_metadata_t* buffer) const;
/** /**
* Release a raw metadata buffer to the caller. After this call, * Release a raw metadata buffer to the caller. After this call,
@ -91,12 +91,12 @@ class CameraMetadata {
* Acquires raw buffer from other CameraMetadata object. After the call, the argument * Acquires raw buffer from other CameraMetadata object. After the call, the argument
* object no longer has any metadata. * object no longer has any metadata.
*/ */
void acquire(CameraMetadata &other); void acquire(CameraMetadata& other);
/** /**
* Append metadata from another CameraMetadata object. * Append metadata from another CameraMetadata object.
*/ */
status_t append(const CameraMetadata &other); status_t append(const CameraMetadata& other);
/** /**
* Append metadata from a raw camera_metadata buffer * Append metadata from a raw camera_metadata buffer
@ -123,24 +123,16 @@ class CameraMetadata {
* will reallocate the buffer if insufficient space exists. Overloaded for * will reallocate the buffer if insufficient space exists. Overloaded for
* the various types of valid data. * the various types of valid data.
*/ */
status_t update(uint32_t tag, status_t update(uint32_t tag, const uint8_t* data, size_t data_count);
const uint8_t *data, size_t data_count); status_t update(uint32_t tag, const int32_t* data, size_t data_count);
status_t update(uint32_t tag, status_t update(uint32_t tag, const float* data, size_t data_count);
const int32_t *data, size_t data_count); status_t update(uint32_t tag, const int64_t* data, size_t data_count);
status_t update(uint32_t tag, status_t update(uint32_t tag, const double* data, size_t data_count);
const float *data, size_t data_count); status_t update(uint32_t tag, const camera_metadata_rational_t* data, size_t data_count);
status_t update(uint32_t tag, status_t update(uint32_t tag, const String8& string);
const int64_t *data, size_t data_count); status_t update(const camera_metadata_ro_entry& entry);
status_t update(uint32_t tag,
const double *data, size_t data_count);
status_t update(uint32_t tag,
const camera_metadata_rational_t *data, size_t data_count);
status_t update(uint32_t tag,
const String8 &string);
status_t update(const camera_metadata_ro_entry &entry);
template <typename T>
template<typename T>
status_t update(uint32_t tag, Vector<T> data) { status_t update(uint32_t tag, Vector<T> data) {
return update(tag, data.array(), data.size()); return update(tag, data.array(), data.size());
} }
@ -170,7 +162,7 @@ class CameraMetadata {
* Swap the underlying camera metadata between this and the other * Swap the underlying camera metadata between this and the other
* metadata object. * metadata object.
*/ */
void swap(CameraMetadata &other); void swap(CameraMetadata& other);
/** /**
* Dump contents into FD for debugging. The verbosity levels are * Dump contents into FD for debugging. The verbosity levels are
@ -184,9 +176,9 @@ class CameraMetadata {
void dump(int fd, int verbosity = 1, int indentation = 0) const; void dump(int fd, int verbosity = 1, int indentation = 0) const;
private: private:
camera_metadata_t *mBuffer; camera_metadata_t* mBuffer;
volatile char mReserved[3] __attribute__ ((unused)); volatile char mReserved[3] __attribute__((unused));
mutable bool mLocked; mutable bool mLocked;
/** /**
* Check if tag has a given type * Check if tag has a given type
@ -196,15 +188,14 @@ class CameraMetadata {
/** /**
* Base update entry method * Base update entry method
*/ */
status_t updateImpl(uint32_t tag, const void *data, size_t data_count); status_t updateImpl(uint32_t tag, const void* data, size_t data_count);
/** /**
* Resize metadata buffer if needed by reallocating it and copying it over. * Resize metadata buffer if needed by reallocating it and copying it over.
*/ */
status_t resizeIfNeeded(size_t extraEntries, size_t extraData); status_t resizeIfNeeded(size_t extraEntries, size_t extraData);
}; };
} // namespace android } // namespace android
#endif #endif

210
universal7885-common/libshims/camera/CameraParameters.cpp
View file

@ -18,11 +18,11 @@
#define LOG_TAG "CameraParams" #define LOG_TAG "CameraParams"
#include <log/log.h> #include <log/log.h>
#include <string.h>
#include <stdlib.h> #include <stdlib.h>
#include <string.h>
#include <system/graphics.h>
#include <unistd.h> #include <unistd.h>
#include "CameraParameters.h" #include "CameraParameters.h"
#include <system/graphics.h>
namespace android { namespace android {
@ -74,7 +74,8 @@ const char CameraParameters::KEY_EXPOSURE_COMPENSATION_STEP[] = "exposure-compen
const char CameraParameters::KEY_AUTO_EXPOSURE_LOCK[] = "auto-exposure-lock"; const char CameraParameters::KEY_AUTO_EXPOSURE_LOCK[] = "auto-exposure-lock";
const char CameraParameters::KEY_AUTO_EXPOSURE_LOCK_SUPPORTED[] = "auto-exposure-lock-supported"; const char CameraParameters::KEY_AUTO_EXPOSURE_LOCK_SUPPORTED[] = "auto-exposure-lock-supported";
const char CameraParameters::KEY_AUTO_WHITEBALANCE_LOCK[] = "auto-whitebalance-lock"; const char CameraParameters::KEY_AUTO_WHITEBALANCE_LOCK[] = "auto-whitebalance-lock";
const char CameraParameters::KEY_AUTO_WHITEBALANCE_LOCK_SUPPORTED[] = "auto-whitebalance-lock-supported"; const char CameraParameters::KEY_AUTO_WHITEBALANCE_LOCK_SUPPORTED[] =
"auto-whitebalance-lock-supported";
const char CameraParameters::KEY_MAX_NUM_METERING_AREAS[] = "max-num-metering-areas"; const char CameraParameters::KEY_MAX_NUM_METERING_AREAS[] = "max-num-metering-areas";
const char CameraParameters::KEY_METERING_AREAS[] = "metering-areas"; const char CameraParameters::KEY_METERING_AREAS[] = "metering-areas";
const char CameraParameters::KEY_ZOOM[] = "zoom"; const char CameraParameters::KEY_ZOOM[] = "zoom";
@ -86,7 +87,8 @@ const char CameraParameters::KEY_FOCUS_DISTANCES[] = "focus-distances";
const char CameraParameters::KEY_VIDEO_FRAME_FORMAT[] = "video-frame-format"; const char CameraParameters::KEY_VIDEO_FRAME_FORMAT[] = "video-frame-format";
const char CameraParameters::KEY_VIDEO_SIZE[] = "video-size"; const char CameraParameters::KEY_VIDEO_SIZE[] = "video-size";
const char CameraParameters::KEY_SUPPORTED_VIDEO_SIZES[] = "video-size-values"; const char CameraParameters::KEY_SUPPORTED_VIDEO_SIZES[] = "video-size-values";
const char CameraParameters::KEY_PREFERRED_PREVIEW_SIZE_FOR_VIDEO[] = "preferred-preview-size-for-video"; const char CameraParameters::KEY_PREFERRED_PREVIEW_SIZE_FOR_VIDEO[] =
"preferred-preview-size-for-video";
const char CameraParameters::KEY_MAX_NUM_DETECTED_FACES_HW[] = "max-num-detected-faces-hw"; const char CameraParameters::KEY_MAX_NUM_DETECTED_FACES_HW[] = "max-num-detected-faces-hw";
const char CameraParameters::KEY_MAX_NUM_DETECTED_FACES_SW[] = "max-num-detected-faces-sw"; const char CameraParameters::KEY_MAX_NUM_DETECTED_FACES_SW[] = "max-num-detected-faces-sw";
const char CameraParameters::KEY_RECORDING_HINT[] = "recording-hint"; const char CameraParameters::KEY_RECORDING_HINT[] = "recording-hint";
@ -155,7 +157,7 @@ const char CameraParameters::SCENE_MODE_HDR[] = "hdr";
const char CameraParameters::PIXEL_FORMAT_YUV422SP[] = "yuv422sp"; const char CameraParameters::PIXEL_FORMAT_YUV422SP[] = "yuv422sp";
const char CameraParameters::PIXEL_FORMAT_YUV420SP[] = "yuv420sp"; const char CameraParameters::PIXEL_FORMAT_YUV420SP[] = "yuv420sp";
const char CameraParameters::PIXEL_FORMAT_YUV422I[] = "yuv422i-yuyv"; const char CameraParameters::PIXEL_FORMAT_YUV422I[] = "yuv422i-yuyv";
const char CameraParameters::PIXEL_FORMAT_YUV420P[] = "yuv420p"; const char CameraParameters::PIXEL_FORMAT_YUV420P[] = "yuv420p";
const char CameraParameters::PIXEL_FORMAT_RGB565[] = "rgb565"; const char CameraParameters::PIXEL_FORMAT_RGB565[] = "rgb565";
const char CameraParameters::PIXEL_FORMAT_RGBA8888[] = "rgba8888"; const char CameraParameters::PIXEL_FORMAT_RGBA8888[] = "rgba8888";
const char CameraParameters::PIXEL_FORMAT_JPEG[] = "jpeg"; const char CameraParameters::PIXEL_FORMAT_JPEG[] = "jpeg";
@ -175,17 +177,11 @@ const char CameraParameters::FOCUS_MODE_CONTINUOUS_PICTURE[] = "continuous-pictu
const char CameraParameters::LIGHTFX_LOWLIGHT[] = "low-light"; const char CameraParameters::LIGHTFX_LOWLIGHT[] = "low-light";
const char CameraParameters::LIGHTFX_HDR[] = "high-dynamic-range"; const char CameraParameters::LIGHTFX_HDR[] = "high-dynamic-range";
CameraParameters::CameraParameters() CameraParameters::CameraParameters() : mMap() {}
: mMap()
{
}
CameraParameters::~CameraParameters() CameraParameters::~CameraParameters() {}
{
}
String8 CameraParameters::flatten() const String8 CameraParameters::flatten() const {
{
String8 flattened(""); String8 flattened("");
size_t size = mMap.size(); size_t size = mMap.size();
@ -197,31 +193,28 @@ String8 CameraParameters::flatten() const
flattened += k; flattened += k;
flattened += "="; flattened += "=";
flattened += v; flattened += v;
if (i != size-1) if (i != size - 1) flattened += ";";
flattened += ";";
} }
return flattened; return flattened;
} }
void CameraParameters::unflatten(const String8 &params) void CameraParameters::unflatten(const String8& params) {
{ const char* a = params.string();
const char *a = params.string(); const char* b;
const char *b;
mMap.clear(); mMap.clear();
for (;;) { for (;;) {
// Find the bounds of the key name. // Find the bounds of the key name.
b = strchr(a, '='); b = strchr(a, '=');
if (b == 0) if (b == 0) break;
break;
// Create the key string. // Create the key string.
String8 k(a, (size_t)(b-a)); String8 k(a, (size_t)(b - a));
// Find the value. // Find the value.
a = b+1; a = b + 1;
b = strchr(a, ';'); b = strchr(a, ';');
if (b == 0) { if (b == 0) {
// If there's no semicolon, this is the last item. // If there's no semicolon, this is the last item.
@ -230,15 +223,13 @@ void CameraParameters::unflatten(const String8 &params)
break; break;
} }
String8 v(a, (size_t)(b-a)); String8 v(a, (size_t)(b - a));
mMap.add(k, v); mMap.add(k, v);
a = b+1; a = b + 1;
} }
} }
void CameraParameters::set(const char* key, const char* value) {
void CameraParameters::set(const char *key, const char *value)
{
// i think i can do this with strspn() // i think i can do this with strspn()
if (strchr(key, '=') || strchr(key, ';')) { if (strchr(key, '=') || strchr(key, ';')) {
// ALOGE("Key \"%s\"contains invalid character (= or ;)", key); // ALOGE("Key \"%s\"contains invalid character (= or ;)", key);
@ -253,54 +244,44 @@ void CameraParameters::set(const char *key, const char *value)
mMap.replaceValueFor(String8(key), String8(value)); mMap.replaceValueFor(String8(key), String8(value));
} }
void CameraParameters::set(const char *key, int value) void CameraParameters::set(const char* key, int value) {
{
char str[16]; char str[16];
sprintf(str, "%d", value); sprintf(str, "%d", value);
set(key, str); set(key, str);
} }
void CameraParameters::setFloat(const char *key, float value) void CameraParameters::setFloat(const char* key, float value) {
{
char str[16]; // 14 should be enough. We overestimate to be safe. char str[16]; // 14 should be enough. We overestimate to be safe.
snprintf(str, sizeof(str), "%g", value); snprintf(str, sizeof(str), "%g", value);
set(key, str); set(key, str);
} }
const char *CameraParameters::get(const char *key) const const char* CameraParameters::get(const char* key) const {
{
String8 v = mMap.valueFor(String8(key)); String8 v = mMap.valueFor(String8(key));
if (v.length() == 0) if (v.length() == 0) return 0;
return 0;
return v.string(); return v.string();
} }
int CameraParameters::getInt(const char *key) const int CameraParameters::getInt(const char* key) const {
{ const char* v = get(key);
const char *v = get(key); if (v == 0) return -1;
if (v == 0)
return -1;
return strtol(v, 0, 0); return strtol(v, 0, 0);
} }
float CameraParameters::getFloat(const char *key) const float CameraParameters::getFloat(const char* key) const {
{ const char* v = get(key);
const char *v = get(key);
if (v == 0) return -1; if (v == 0) return -1;
return strtof(v, 0); return strtof(v, 0);
} }
void CameraParameters::remove(const char *key) void CameraParameters::remove(const char* key) {
{
mMap.removeItem(String8(key)); mMap.removeItem(String8(key));
} }
// Parse string like "640x480" or "10000,20000" // Parse string like "640x480" or "10000,20000"
static int parse_pair(const char *str, int *first, int *second, char delim, static int parse_pair(const char* str, int* first, int* second, char delim, char** endptr = NULL) {
char **endptr = NULL)
{
// Find the first integer. // Find the first integer.
char *end; char* end;
int w = (int)strtol(str, &end, 10); int w = (int)strtol(str, &end, 10);
// If a delimeter does not immediately follow, give up. // If a delimeter does not immediately follow, give up.
if (*end != delim) { if (*end != delim) {
@ -309,7 +290,7 @@ static int parse_pair(const char *str, int *first, int *second, char delim,
} }
// Find the second integer, immediately after the delimeter. // Find the second integer, immediately after the delimeter.
int h = (int)strtol(end+1, &end, 10); int h = (int)strtol(end + 1, &end, 10);
*first = w; *first = w;
*second = h; *second = h;
@ -321,18 +302,16 @@ static int parse_pair(const char *str, int *first, int *second, char delim,
return 0; return 0;
} }
static void parseSizesList(const char *sizesStr, Vector<Size> &sizes) static void parseSizesList(const char* sizesStr, Vector<Size>& sizes) {
{
if (sizesStr == 0) { if (sizesStr == 0) {
return; return;
} }
char *sizeStartPtr = (char *)sizesStr; char* sizeStartPtr = (char*)sizesStr;
while (true) { while (true) {
int width, height; int width, height;
int success = parse_pair(sizeStartPtr, &width, &height, 'x', int success = parse_pair(sizeStartPtr, &width, &height, 'x', &sizeStartPtr);
&sizeStartPtr);
if (success == -1 || (*sizeStartPtr != ',' && *sizeStartPtr != '\0')) { if (success == -1 || (*sizeStartPtr != ',' && *sizeStartPtr != '\0')) {
ALOGE("Picture sizes string \"%s\" contains invalid character.", sizesStr); ALOGE("Picture sizes string \"%s\" contains invalid character.", sizesStr);
return; return;
@ -346,119 +325,101 @@ static void parseSizesList(const char *sizesStr, Vector<Size> &sizes)
} }
} }
void CameraParameters::setPreviewSize(int width, int height) void CameraParameters::setPreviewSize(int width, int height) {
{
char str[32]; char str[32];
sprintf(str, "%dx%d", width, height); sprintf(str, "%dx%d", width, height);
set(KEY_PREVIEW_SIZE, str); set(KEY_PREVIEW_SIZE, str);
} }
void CameraParameters::getPreviewSize(int *width, int *height) const void CameraParameters::getPreviewSize(int* width, int* height) const {
{
*width = *height = -1; *width = *height = -1;
// Get the current string, if it doesn't exist, leave the -1x-1 // Get the current string, if it doesn't exist, leave the -1x-1
const char *p = get(KEY_PREVIEW_SIZE); const char* p = get(KEY_PREVIEW_SIZE);
if (p == 0) return; if (p == 0) return;
parse_pair(p, width, height, 'x'); parse_pair(p, width, height, 'x');
} }
void CameraParameters::getPreferredPreviewSizeForVideo(int *width, int *height) const void CameraParameters::getPreferredPreviewSizeForVideo(int* width, int* height) const {
{
*width = *height = -1; *width = *height = -1;
const char *p = get(KEY_PREFERRED_PREVIEW_SIZE_FOR_VIDEO); const char* p = get(KEY_PREFERRED_PREVIEW_SIZE_FOR_VIDEO);
if (p == 0) return; if (p == 0) return;
parse_pair(p, width, height, 'x'); parse_pair(p, width, height, 'x');
} }
void CameraParameters::getSupportedPreviewSizes(Vector<Size> &sizes) const void CameraParameters::getSupportedPreviewSizes(Vector<Size>& sizes) const {
{ const char* previewSizesStr = get(KEY_SUPPORTED_PREVIEW_SIZES);
const char *previewSizesStr = get(KEY_SUPPORTED_PREVIEW_SIZES);
parseSizesList(previewSizesStr, sizes); parseSizesList(previewSizesStr, sizes);
} }
void CameraParameters::setVideoSize(int width, int height) void CameraParameters::setVideoSize(int width, int height) {
{
char str[32]; char str[32];
sprintf(str, "%dx%d", width, height); sprintf(str, "%dx%d", width, height);
set(KEY_VIDEO_SIZE, str); set(KEY_VIDEO_SIZE, str);
} }
void CameraParameters::getVideoSize(int *width, int *height) const void CameraParameters::getVideoSize(int* width, int* height) const {
{
*width = *height = -1; *width = *height = -1;
const char *p = get(KEY_VIDEO_SIZE); const char* p = get(KEY_VIDEO_SIZE);
if (p == 0) return; if (p == 0) return;
parse_pair(p, width, height, 'x'); parse_pair(p, width, height, 'x');
} }
void CameraParameters::getSupportedVideoSizes(Vector<Size> &sizes) const void CameraParameters::getSupportedVideoSizes(Vector<Size>& sizes) const {
{ const char* videoSizesStr = get(KEY_SUPPORTED_VIDEO_SIZES);
const char *videoSizesStr = get(KEY_SUPPORTED_VIDEO_SIZES);
parseSizesList(videoSizesStr, sizes); parseSizesList(videoSizesStr, sizes);
} }
void CameraParameters::setPreviewFrameRate(int fps) void CameraParameters::setPreviewFrameRate(int fps) {
{
set(KEY_PREVIEW_FRAME_RATE, fps); set(KEY_PREVIEW_FRAME_RATE, fps);
} }
int CameraParameters::getPreviewFrameRate() const int CameraParameters::getPreviewFrameRate() const {
{
return getInt(KEY_PREVIEW_FRAME_RATE); return getInt(KEY_PREVIEW_FRAME_RATE);
} }
void CameraParameters::getPreviewFpsRange(int *min_fps, int *max_fps) const void CameraParameters::getPreviewFpsRange(int* min_fps, int* max_fps) const {
{
*min_fps = *max_fps = -1; *min_fps = *max_fps = -1;
const char *p = get(KEY_PREVIEW_FPS_RANGE); const char* p = get(KEY_PREVIEW_FPS_RANGE);
if (p == 0) return; if (p == 0) return;
parse_pair(p, min_fps, max_fps, ','); parse_pair(p, min_fps, max_fps, ',');
} }
void CameraParameters::setPreviewFormat(const char *format) void CameraParameters::setPreviewFormat(const char* format) {
{
set(KEY_PREVIEW_FORMAT, format); set(KEY_PREVIEW_FORMAT, format);
} }
const char *CameraParameters::getPreviewFormat() const const char* CameraParameters::getPreviewFormat() const {
{
return get(KEY_PREVIEW_FORMAT); return get(KEY_PREVIEW_FORMAT);
} }
void CameraParameters::setPictureSize(int width, int height) void CameraParameters::setPictureSize(int width, int height) {
{
char str[32]; char str[32];
sprintf(str, "%dx%d", width, height); sprintf(str, "%dx%d", width, height);
set(KEY_PICTURE_SIZE, str); set(KEY_PICTURE_SIZE, str);
} }
void CameraParameters::getPictureSize(int *width, int *height) const void CameraParameters::getPictureSize(int* width, int* height) const {
{
*width = *height = -1; *width = *height = -1;
// Get the current string, if it doesn't exist, leave the -1x-1 // Get the current string, if it doesn't exist, leave the -1x-1
const char *p = get(KEY_PICTURE_SIZE); const char* p = get(KEY_PICTURE_SIZE);
if (p == 0) return; if (p == 0) return;
parse_pair(p, width, height, 'x'); parse_pair(p, width, height, 'x');
} }
void CameraParameters::getSupportedPictureSizes(Vector<Size> &sizes) const void CameraParameters::getSupportedPictureSizes(Vector<Size>& sizes) const {
{ const char* pictureSizesStr = get(KEY_SUPPORTED_PICTURE_SIZES);
const char *pictureSizesStr = get(KEY_SUPPORTED_PICTURE_SIZES);
parseSizesList(pictureSizesStr, sizes); parseSizesList(pictureSizesStr, sizes);
} }
void CameraParameters::setPictureFormat(const char *format) void CameraParameters::setPictureFormat(const char* format) {
{
set(KEY_PICTURE_FORMAT, format); set(KEY_PICTURE_FORMAT, format);
} }
const char *CameraParameters::getPictureFormat() const const char* CameraParameters::getPictureFormat() const {
{
return get(KEY_PICTURE_FORMAT); return get(KEY_PICTURE_FORMAT);
} }
void CameraParameters::dump() const void CameraParameters::dump() const {
{
ALOGD("dump: mMap.size = %zu", mMap.size()); ALOGD("dump: mMap.size = %zu", mMap.size());
for (size_t i = 0; i < mMap.size(); i++) { for (size_t i = 0; i < mMap.size(); i++) {
String8 k, v; String8 k, v;
@ -468,8 +429,7 @@ void CameraParameters::dump() const
} }
} }
status_t CameraParameters::dump(int fd, const Vector<String16>& /*args*/) const status_t CameraParameters::dump(int fd, const Vector<String16>& /*args*/) const {
{
const size_t SIZE = 256; const size_t SIZE = 256;
char buffer[SIZE]; char buffer[SIZE];
String8 result; String8 result;
@ -487,8 +447,7 @@ status_t CameraParameters::dump(int fd, const Vector<String16>& /*args*/) const
} }
void CameraParameters::getSupportedPreviewFormats(Vector<int>& formats) const { void CameraParameters::getSupportedPreviewFormats(Vector<int>& formats) const {
const char* supportedPreviewFormats = const char* supportedPreviewFormats = get(CameraParameters::KEY_SUPPORTED_PREVIEW_FORMATS);
get(CameraParameters::KEY_SUPPORTED_PREVIEW_FORMATS);
if (supportedPreviewFormats == NULL) { if (supportedPreviewFormats == NULL) {
ALOGW("%s: No supported preview formats.", __FUNCTION__); ALOGW("%s: No supported preview formats.", __FUNCTION__);
@ -510,30 +469,27 @@ void CameraParameters::getSupportedPreviewFormats(Vector<int>& formats) const {
fmtStr.unlockBuffer(fmtStr.size()); fmtStr.unlockBuffer(fmtStr.size());
} }
int CameraParameters::previewFormatToEnum(const char* format) { int CameraParameters::previewFormatToEnum(const char* format) {
return return !format ? HAL_PIXEL_FORMAT_YCrCb_420_SP
!format ? : !strcmp(format, PIXEL_FORMAT_YUV422SP) ? HAL_PIXEL_FORMAT_YCbCr_422_SP
HAL_PIXEL_FORMAT_YCrCb_420_SP : : // NV16
!strcmp(format, PIXEL_FORMAT_YUV422SP) ? !strcmp(format, PIXEL_FORMAT_YUV420SP) ? HAL_PIXEL_FORMAT_YCrCb_420_SP
HAL_PIXEL_FORMAT_YCbCr_422_SP : // NV16 : // NV21
!strcmp(format, PIXEL_FORMAT_YUV420SP) ? !strcmp(format, PIXEL_FORMAT_YUV422I) ? HAL_PIXEL_FORMAT_YCbCr_422_I
HAL_PIXEL_FORMAT_YCrCb_420_SP : // NV21 : // YUY2
!strcmp(format, PIXEL_FORMAT_YUV422I) ? !strcmp(format, PIXEL_FORMAT_YUV420P) ? HAL_PIXEL_FORMAT_YV12
HAL_PIXEL_FORMAT_YCbCr_422_I : // YUY2 : // YV12
!strcmp(format, PIXEL_FORMAT_YUV420P) ? !strcmp(format, PIXEL_FORMAT_RGB565) ? HAL_PIXEL_FORMAT_RGB_565
HAL_PIXEL_FORMAT_YV12 : // YV12 : // RGB565
!strcmp(format, PIXEL_FORMAT_RGB565) ? !strcmp(format, PIXEL_FORMAT_RGBA8888) ? HAL_PIXEL_FORMAT_RGBA_8888
HAL_PIXEL_FORMAT_RGB_565 : // RGB565 : // RGB8888
!strcmp(format, PIXEL_FORMAT_RGBA8888) ? !strcmp(format, PIXEL_FORMAT_BAYER_RGGB) ? HAL_PIXEL_FORMAT_RAW16
HAL_PIXEL_FORMAT_RGBA_8888 : // RGB8888 : // Raw sensor data
!strcmp(format, PIXEL_FORMAT_BAYER_RGGB) ? -1;
HAL_PIXEL_FORMAT_RAW16 : // Raw sensor data
-1;
} }
bool CameraParameters::isEmpty() const { bool CameraParameters::isEmpty() const {
return mMap.isEmpty(); return mMap.isEmpty();
} }
}; // namespace android }; // namespace android

59
universal7885-common/libshims/camera/CameraParameters.h
View file

@ -37,28 +37,27 @@ struct Size {
} }
}; };
class CameraParameters class CameraParameters {
{ public:
public:
CameraParameters(); CameraParameters();
CameraParameters(const String8 &params) { unflatten(params); } CameraParameters(const String8& params) { unflatten(params); }
~CameraParameters(); ~CameraParameters();
String8 flatten() const; String8 flatten() const;
void unflatten(const String8 &params); void unflatten(const String8& params);
void set(const char *key, const char *value); void set(const char* key, const char* value);
void set(const char *key, int value); void set(const char* key, int value);
void setFloat(const char *key, float value); void setFloat(const char* key, float value);
const char *get(const char *key) const; const char* get(const char* key) const;
int getInt(const char *key) const; int getInt(const char* key) const;
float getFloat(const char *key) const; float getFloat(const char* key) const;
void remove(const char *key); void remove(const char* key);
void setPreviewSize(int width, int height); void setPreviewSize(int width, int height);
void getPreviewSize(int *width, int *height) const; void getPreviewSize(int* width, int* height) const;
void getSupportedPreviewSizes(Vector<Size> &sizes) const; void getSupportedPreviewSizes(Vector<Size>& sizes) const;
// Set the dimensions in pixels to the given width and height // Set the dimensions in pixels to the given width and height
// for video frames. The given width and height must be one // for video frames. The given width and height must be one
@ -71,14 +70,14 @@ public:
// supported dimensions returned from getSupportedVideoSizes(). // supported dimensions returned from getSupportedVideoSizes().
// Must not be called if getSupportedVideoSizes() returns an // Must not be called if getSupportedVideoSizes() returns an
// empty Vector of Size. // empty Vector of Size.
void getVideoSize(int *width, int *height) const; void getVideoSize(int* width, int* height) const;
// Retrieve a Vector of supported dimensions (width and height) // Retrieve a Vector of supported dimensions (width and height)
// in pixels for video frames. If sizes returned from the method // in pixels for video frames. If sizes returned from the method
// is empty, the camera does not support calls to setVideoSize() // is empty, the camera does not support calls to setVideoSize()
// or getVideoSize(). In adddition, it also indicates that // or getVideoSize(). In adddition, it also indicates that
// the camera only has a single output, and does not have // the camera only has a single output, and does not have
// separate output for video frames and preview frame. // separate output for video frames and preview frame.
void getSupportedVideoSizes(Vector<Size> &sizes) const; void getSupportedVideoSizes(Vector<Size>& sizes) const;
// Retrieve the preferred preview size (width and height) in pixels // Retrieve the preferred preview size (width and height) in pixels
// for video recording. The given width and height must be one of // for video recording. The given width and height must be one of
// supported preview sizes returned from getSupportedPreviewSizes(). // supported preview sizes returned from getSupportedPreviewSizes().
@ -86,18 +85,18 @@ public:
// Vector of Size. If getSupportedVideoSizes() returns an empty // Vector of Size. If getSupportedVideoSizes() returns an empty
// Vector of Size, the width and height returned from this method // Vector of Size, the width and height returned from this method
// is invalid, and is "-1x-1". // is invalid, and is "-1x-1".
void getPreferredPreviewSizeForVideo(int *width, int *height) const; void getPreferredPreviewSizeForVideo(int* width, int* height) const;
void setPreviewFrameRate(int fps); void setPreviewFrameRate(int fps);
int getPreviewFrameRate() const; int getPreviewFrameRate() const;
void getPreviewFpsRange(int *min_fps, int *max_fps) const; void getPreviewFpsRange(int* min_fps, int* max_fps) const;
void setPreviewFormat(const char *format); void setPreviewFormat(const char* format);
const char *getPreviewFormat() const; const char* getPreviewFormat() const;
void setPictureSize(int width, int height); void setPictureSize(int width, int height);
void getPictureSize(int *width, int *height) const; void getPictureSize(int* width, int* height) const;
void getSupportedPictureSizes(Vector<Size> &sizes) const; void getSupportedPictureSizes(Vector<Size>& sizes) const;
void setPictureFormat(const char *format); void setPictureFormat(const char* format);
const char *getPictureFormat() const; const char* getPictureFormat() const;
void dump() const; void dump() const;
status_t dump(int fd, const Vector<String16>& args) const; status_t dump(int fd, const Vector<String16>& args) const;
@ -614,9 +613,9 @@ public:
// Pixel color formats for KEY_PREVIEW_FORMAT, KEY_PICTURE_FORMAT, // Pixel color formats for KEY_PREVIEW_FORMAT, KEY_PICTURE_FORMAT,
// and KEY_VIDEO_FRAME_FORMAT // and KEY_VIDEO_FRAME_FORMAT
static const char PIXEL_FORMAT_YUV422SP[]; static const char PIXEL_FORMAT_YUV422SP[];
static const char PIXEL_FORMAT_YUV420SP[]; // NV21 static const char PIXEL_FORMAT_YUV420SP[]; // NV21
static const char PIXEL_FORMAT_YUV422I[]; // YUY2 static const char PIXEL_FORMAT_YUV422I[]; // YUY2
static const char PIXEL_FORMAT_YUV420P[]; // YV12 static const char PIXEL_FORMAT_YUV420P[]; // YV12
static const char PIXEL_FORMAT_RGB565[]; static const char PIXEL_FORMAT_RGB565[];
static const char PIXEL_FORMAT_RGBA8888[]; static const char PIXEL_FORMAT_RGBA8888[];
static const char PIXEL_FORMAT_JPEG[]; static const char PIXEL_FORMAT_JPEG[];
@ -690,10 +689,10 @@ public:
*/ */
static int previewFormatToEnum(const char* format); static int previewFormatToEnum(const char* format);
private: private:
DefaultKeyedVector<String8,String8> mMap; DefaultKeyedVector<String8, String8> mMap;
}; };
}; // namespace }; // namespace android
#endif #endif

13
universal7885-common/libshims/sensor/ASensorManager.cpp
View file

@ -23,9 +23,9 @@ using android::Mutex;
static Mutex gLock; static Mutex gLock;
extern "C" ALooper *ALooper_forCamera() { extern "C" ALooper* ALooper_forCamera() {
LOG(VERBOSE) << "ALooper_forCamera"; LOG(VERBOSE) << "ALooper_forCamera";
ALooper *sLooper = NULL; ALooper* sLooper = NULL;
Mutex::Autolock autoLock(gLock); Mutex::Autolock autoLock(gLock);
sLooper = new ALooper; sLooper = new ALooper;
@ -33,7 +33,7 @@ extern "C" ALooper *ALooper_forCamera() {
return sLooper; return sLooper;
} }
extern "C" int ALooper_release_forCamera(ALooper *sLooper) { extern "C" int ALooper_release_forCamera(ALooper* sLooper) {
if (sLooper != nullptr) { if (sLooper != nullptr) {
Mutex::Autolock autoLock(gLock); Mutex::Autolock autoLock(gLock);
delete sLooper; delete sLooper;
@ -42,11 +42,8 @@ extern "C" int ALooper_release_forCamera(ALooper *sLooper) {
return 0; return 0;
} }
extern "C" int ALooper_pollOnce_camera(ALooper *sLooper, extern "C" int ALooper_pollOnce_camera(ALooper* sLooper, int timeoutMillis, int* outFd,
int timeoutMillis, int* outEvents, void** outData) {
int* outFd,
int* outEvents,
void** outData) {
int res = sLooper->pollOnce(timeoutMillis, outFd, outEvents, outData); int res = sLooper->pollOnce(timeoutMillis, outFd, outEvents, outData);
LOG(VERBOSE) << "ALooper_pollOnce_camera => " << res; LOG(VERBOSE) << "ALooper_pollOnce_camera => " << res;
return res; return res;

5
universal7885-common/secril_config_svc/secril_config_svc.cpp
View file

@ -42,11 +42,10 @@ void LoadProperties(std::string data) {
} }
} }
int main(int argc, char *argv[]) { int main(int argc, char* argv[]) {
std::string prop = FACTORY_PROP; std::string prop = FACTORY_PROP;
if (argc > 1 && std::string(argv[1]) == "NetworkConfig") if (argc > 1 && std::string(argv[1]) == "NetworkConfig") prop = TELEPHONY_PROP;
prop = TELEPHONY_PROP;
std::ifstream in(EFS_NEW + prop); std::ifstream in(EFS_NEW + prop);
if (in.good()) { if (in.good()) {

9
universal7885-common/usb/typeb/Usb.cpp Executable file → Normal file
View file

@ -30,8 +30,8 @@ namespace usb {
namespace V1_0 { namespace V1_0 {
namespace implementation { namespace implementation {
Return<void> Usb::switchRole(const hidl_string &portName __unused, Return<void> Usb::switchRole(const hidl_string& portName __unused,
const PortRole &newRole __unused) { const PortRole& newRole __unused) {
LOG(ERROR) << __func__ << ": Not supported"; LOG(ERROR) << __func__ << ": Not supported";
return Void(); return Void();
} }
@ -51,8 +51,7 @@ Return<void> Usb::queryPortStatus() {
pthread_mutex_lock(&mLock); pthread_mutex_lock(&mLock);
if (mCallback != NULL) { if (mCallback != NULL) {
Return<void> ret = Return<void> ret = mCallback->notifyPortStatusChange(currentPortStatus, Status::SUCCESS);
mCallback->notifyPortStatusChange(currentPortStatus, Status::SUCCESS);
if (!ret.isOk()) { if (!ret.isOk()) {
LOG(ERROR) << "queryPortStatus error " << ret.description(); LOG(ERROR) << "queryPortStatus error " << ret.description();
} }
@ -64,7 +63,7 @@ Return<void> Usb::queryPortStatus() {
return Void(); return Void();
} }
Return<void> Usb::setCallback(const sp<IUsbCallback> &callback) { Return<void> Usb::setCallback(const sp<IUsbCallback>& callback) {
pthread_mutex_lock(&mLock); pthread_mutex_lock(&mLock);
mCallback = callback; mCallback = callback;

10
universal7885-common/usb/typeb/Usb.h Executable file → Normal file
View file

@ -35,17 +35,17 @@ namespace usb {
namespace V1_0 { namespace V1_0 {
namespace implementation { namespace implementation {
using ::android::hardware::usb::V1_0::IUsb; using ::android::sp;
using ::android::hardware::usb::V1_0::IUsbCallback;
using ::android::hardware::usb::V1_0::PortRole;
using ::android::hidl::base::V1_0::IBase;
using ::android::hardware::hidl_array; using ::android::hardware::hidl_array;
using ::android::hardware::hidl_memory; using ::android::hardware::hidl_memory;
using ::android::hardware::hidl_string; using ::android::hardware::hidl_string;
using ::android::hardware::hidl_vec; using ::android::hardware::hidl_vec;
using ::android::hardware::Return; using ::android::hardware::Return;
using ::android::hardware::Void; using ::android::hardware::Void;
using ::android::sp; using ::android::hardware::usb::V1_0::IUsb;
using ::android::hardware::usb::V1_0::IUsbCallback;
using ::android::hardware::usb::V1_0::PortRole;
using ::android::hidl::base::V1_0::IBase;
struct Usb : public IUsb { struct Usb : public IUsb {
Return<void> switchRole(const hidl_string& portName, const PortRole& role) override; Return<void> switchRole(const hidl_string& portName, const PortRole& role) override;

1176
universal7885-common/usb/typec/Usb.cpp
View file

File diff suppressed because it is too large Load diff

27
universal7885-common/usb/typec/Usb.h
View file

@ -2,8 +2,8 @@
#define ANDROID_HARDWARE_USB_V1_1_USB_H #define ANDROID_HARDWARE_USB_V1_1_USB_H
#include <android/hardware/usb/1.1/IUsb.h> #include <android/hardware/usb/1.1/IUsb.h>
#include <android/hardware/usb/1.1/types.h>
#include <android/hardware/usb/1.1/IUsbCallback.h> #include <android/hardware/usb/1.1/IUsbCallback.h>
#include <android/hardware/usb/1.1/types.h>
#include <hidl/Status.h> #include <hidl/Status.h>
#include <utils/Log.h> #include <utils/Log.h>
@ -20,10 +20,17 @@ namespace usb {
namespace V1_1 { namespace V1_1 {
namespace implementation { namespace implementation {
using ::android::hardware::usb::V1_0::PortRole; using ::android::sp;
using ::android::hardware::usb::V1_0::PortRoleType; 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::hardware::usb::V1_0::PortDataRole; using ::android::hardware::usb::V1_0::PortDataRole;
using ::android::hardware::usb::V1_0::PortPowerRole; using ::android::hardware::usb::V1_0::PortPowerRole;
using ::android::hardware::usb::V1_0::PortRole;
using ::android::hardware::usb::V1_0::PortRoleType;
using ::android::hardware::usb::V1_0::Status; using ::android::hardware::usb::V1_0::Status;
using ::android::hardware::usb::V1_1::IUsb; using ::android::hardware::usb::V1_1::IUsb;
using ::android::hardware::usb::V1_1::IUsbCallback; using ::android::hardware::usb::V1_1::IUsbCallback;
@ -31,13 +38,6 @@ using ::android::hardware::usb::V1_1::PortMode_1_1;
using ::android::hardware::usb::V1_1::PortStatus_1_1; using ::android::hardware::usb::V1_1::PortStatus_1_1;
using ::android::hidl::base::V1_0::DebugInfo; using ::android::hidl::base::V1_0::DebugInfo;
using ::android::hidl::base::V1_0::IBase; using ::android::hidl::base::V1_0::IBase;
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 Usb : public IUsb { struct Usb : public IUsb {
Usb(); Usb();
@ -46,7 +46,6 @@ struct Usb : public IUsb {
Return<void> setCallback(const sp<V1_0::IUsbCallback>& callback) override; Return<void> setCallback(const sp<V1_0::IUsbCallback>& callback) override;
Return<void> queryPortStatus() override; Return<void> queryPortStatus() override;
sp<V1_0::IUsbCallback> mCallback_1_0; sp<V1_0::IUsbCallback> mCallback_1_0;
// Protects mCallback variable // Protects mCallback variable
pthread_mutex_t mLock; pthread_mutex_t mLock;
@ -59,12 +58,12 @@ struct Usb : public IUsb {
// Variable to signal partner coming back online after type switch // Variable to signal partner coming back online after type switch
bool mPartnerUp; bool mPartnerUp;
private: private:
pthread_t mPoll; pthread_t mPoll;
}; };
} // namespace implementation } // namespace implementation
} // namespace V1_0 } // namespace V1_1
} // namespace usb } // namespace usb
} // namespace hardware } // namespace hardware
} // namespace android } // namespace android

3
universal7885-common/usb/typec/service.cpp
View file

@ -29,8 +29,8 @@ using android::hardware::joinRpcThreadpool;
using android::hardware::usb::V1_1::IUsb; using android::hardware::usb::V1_1::IUsb;
using android::hardware::usb::V1_1::implementation::Usb; using android::hardware::usb::V1_1::implementation::Usb;
using android::status_t;
using android::OK; using android::OK;
using android::status_t;
int main() { int main() {
android::sp<IUsb> service = new Usb(); android::sp<IUsb> service = new Usb();
@ -48,5 +48,4 @@ int main() {
// Under noraml cases, execution will not reach this line. // Under noraml cases, execution will not reach this line.
ALOGI("USB HAL failed to join thread pool."); ALOGI("USB HAL failed to join thread pool.");
return 1; return 1;
} }