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

* On every *.cpp *.h files

Signed-off-by: roynatech2544 <whiteshell2544@naver.com>

universal7885-common/aidl/light/Lights.cpp

@@ -41,10 +41,12 @@ Lights::Lights() {
     mLights.emplace(LightType::BACKLIGHT,
                     std::bind(&Lights::handleBacklight, this, std::placeholders::_1));
 #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 */
 #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,
                     std::bind(&Lights::handleNotifications, this, std::placeholders::_1));
     mLights.emplace(LightType::ATTENTION,
@@ -166,7 +168,8 @@ uint32_t Lights::calibrateColor(uint32_t color, int32_t brightness) {
 }
 #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) {
     for (auto const& light : mLights) {
@@ -179,7 +182,8 @@ ndk::ScopedAStatus Lights::getLights(std::vector<HwLight> *_aidl_return) {
 uint32_t Lights::rgbToBrightness(const HwLightState& state) {
     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;
 }
 

universal7885-common/aidl/light/Lights.h

@@ -10,8 +10,8 @@
 #include <unordered_map>
 #include "samsung_lights.h"
 
-using ::aidl::android::hardware::light::HwLightState;
 using ::aidl::android::hardware::light::HwLight;
+using ::aidl::android::hardware::light::HwLightState;
 
 namespace aidl {
 namespace android {

universal7885-common/aidl/light/service.cpp

@@ -8,9 +8,9 @@
 
 #include "Lights.h"
 
+#include <android-base/logging.h>
 #include <android/binder_manager.h>
 #include <android/binder_process.h>
-#include <android-base/logging.h>
 
 using ::aidl::android::hardware::light::Lights;
 

universal7885-common/aidl/power-libperfmgr/InteractionHandler.cpp

@@ -52,8 +52,7 @@ static int fb_idle_open(void) {
     int fd;
     for (auto& path : fb_idle_patch) {
         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);
     return -1;
@@ -62,8 +61,7 @@ static int fb_idle_open(void) {
 bool InteractionHandler::Init() {
     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();
 
@@ -84,8 +82,7 @@ bool InteractionHandler::Init() {
 
 void InteractionHandler::Exit() {
     std::unique_lock<std::mutex> lk(mLock);
-    if (mState == INTERACTION_STATE_UNINITIALIZED)
+    if (mState == INTERACTION_STATE_UNINITIALIZED) return;
-        return;
 
     AbortWaitLocked();
     mState = INTERACTION_STATE_UNINITIALIZED;
@@ -186,8 +183,7 @@ void InteractionHandler::Release() {
 void InteractionHandler::AbortWaitLocked() {
     uint64_t val = 1;
     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) {
@@ -253,8 +249,7 @@ void InteractionHandler::Routine() {
     while (true) {
         lk.lock();
         mCond.wait(lk, [&] { return mState != INTERACTION_STATE_IDLE; });
-        if (mState == INTERACTION_STATE_UNINITIALIZED)
+        if (mState == INTERACTION_STATE_UNINITIALIZED) return;
-            return;
         mState = INTERACTION_STATE_WAITING;
         lk.unlock();
 

universal7885-common/aidl/power-libperfmgr/PowerExt.h

@@ -34,8 +34,7 @@ using ::android::perfmgr::HintManager;
 
 class PowerExt : public ::aidl::google::hardware::power::extension::pixel::BnPowerExt {
   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 isModeSupported(const std::string& mode, bool* _aidl_return) override;
     ndk::ScopedAStatus setBoost(const std::string& boost, int32_t durationMs) override;

universal7885-common/aidl/vibrator/Vibrator.cpp

@@ -53,7 +53,8 @@ Vibrator::Vibrator() {
 ndk::ScopedAStatus Vibrator::getCapabilities(int32_t* _aidl_return) {
     *_aidl_return = IVibrator::CAP_ON_CALLBACK | IVibrator::CAP_PERFORM_CALLBACK |
                     IVibrator::CAP_EXTERNAL_CONTROL /*| IVibrator::CAP_COMPOSE_EFFECTS |
-                    IVibrator::CAP_ALWAYS_ON_CONTROL*/;
+                    IVibrator::CAP_ALWAYS_ON_CONTROL*/
+            ;
 
     if (mHasTimedOutIntensity) {
         *_aidl_return = *_aidl_return | IVibrator::CAP_AMPLITUDE_CONTROL |
@@ -67,7 +68,8 @@ ndk::ScopedAStatus Vibrator::off() {
     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);
 
     if (callback != nullptr) {
@@ -84,7 +86,9 @@ ndk::ScopedAStatus Vibrator::on(int32_t timeoutMs, const std::shared_ptr<IVibrat
     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;
     uint8_t amplitude;
     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) {
-    *_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();
 }
 
@@ -168,15 +171,18 @@ ndk::ScopedAStatus Vibrator::getCompositionSizeMax(int32_t* /*_aidl_return*/) {
     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);
 }
 
-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);
 }
 
-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);
 }
 
@@ -184,7 +190,8 @@ ndk::ScopedAStatus Vibrator::getSupportedAlwaysOnEffects(std::vector<Effect>* /*
     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);
 }
 
@@ -224,7 +231,8 @@ ndk::ScopedAStatus Vibrator::getSupportedBraking(std::vector<Braking>* /*_aidl_r
     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);
 }
 

universal7885-common/aidl/vibrator/Vibrator.h

@@ -15,12 +15,12 @@
 #define VIBRATOR_TIMEOUT_PATH "/sys/class/timed_output/vibrator/enable"
 #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::Effect;
-using ::aidl::android::hardware::vibrator::EffectStrength;
 using ::aidl::android::hardware::vibrator::CompositeEffect;
 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;
 
 namespace aidl {
@@ -33,16 +33,22 @@ public:
     Vibrator();
     ndk::ScopedAStatus getCapabilities(int32_t* _aidl_return) 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 setAmplitude(float amplitude) override;
     ndk::ScopedAStatus setExternalControl(bool enabled) override;
     ndk::ScopedAStatus getCompositionDelayMax(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 alwaysOnEnable(int32_t id, Effect effect, EffectStrength strength) override;
     ndk::ScopedAStatus alwaysOnDisable(int32_t id) override;
@@ -54,7 +60,8 @@ public:
     ndk::ScopedAStatus getPwlePrimitiveDurationMax(int32_t* _aidl_return) override;
     ndk::ScopedAStatus getPwleCompositionSizeMax(int32_t* _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:
     ndk::ScopedAStatus activate(uint32_t ms);

universal7885-common/aidl/vibrator/service.cpp

@@ -6,9 +6,9 @@
 
 #include "Vibrator.h"
 
+#include <android-base/logging.h>
 #include <android/binder_manager.h>
 #include <android/binder_process.h>
-#include <android-base/logging.h>
 
 using ::aidl::android::hardware::vibrator::Vibrator;
 
@@ -17,7 +17,8 @@ int main() {
     std::shared_ptr<Vibrator> vibrator = ndk::SharedRefBase::make<Vibrator>();
 
     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);
 
     ABinderProcess_joinThreadPool();

universal7885-common/apps/SamsungParts/jni/BatteryBridge.cpp

@@ -1,19 +1,19 @@
-#include <vendor/eureka/hardware/battery/1.0/IBattery.h>
-#include <hidl/Status.h>
-#include <hidl/LegacySupport.h>
 #include <hardware/hardware.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"
 
-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 vendor::eureka::hardware::battery::V1_0::IBattery;
+using vendor::eureka::hardware::battery::V1_0::Number;
+using vendor::eureka::hardware::battery::V1_0::SysfsType;
 
-extern "C" JNIEXPORT void
+extern "C" JNIEXPORT void JNICALL
-JNICALL
+Java_com_eurekateam_samsungextras_interfaces_Battery_setChargeSysfs(JNIEnv* env,
-Java_com_eurekateam_samsungextras_interfaces_Battery_setChargeSysfs
+                                                                    __unused jclass obj,
-(JNIEnv *env , __unused jclass obj, jint enable) {
+                                                                    jint enable) {
     android::sp<IBattery> service = IBattery::getService();
     if (enable == 1) {
         service->setBatteryWritable(SysfsType::CHARGE, Number::ENABLE);
@@ -22,18 +22,17 @@ Java_com_eurekateam_samsungextras_interfaces_Battery_setChargeSysfs
     }
 }
 
-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();
     int ret = service->getBatteryStats(SysfsType::CHARGE);
     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) {
     android::sp<IBattery> service = IBattery::getService();
     if (enable == 1) {
@@ -42,17 +41,17 @@ Java_com_eurekateam_samsungextras_interfaces_Battery_setFastCharge(JNIEnv *env,
         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();
     int ret = service->getBatteryStats(SysfsType::FASTCHARGE);
     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
@@ -93,6 +92,4 @@ Java_com_eurekateam_samsungextras_interfaces_Battery_getGeneralBatteryStats(JNIE
             break;
     }
     return ret;
-
-
 }

universal7885-common/apps/SamsungParts/jni/FlashlightBridge.cpp

@@ -1,20 +1,18 @@
-#include <vendor/eureka/hardware/flashlight/1.0/IFlashlight.h>
-#include <hidl/Status.h>
-#include <hidl/LegacySupport.h>
 #include <hardware/hardware.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"
 
-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::Enable;
+using vendor::eureka::hardware::flashlight::V1_0::IFlashlight;
 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,
-                                                                 jint value) {
     android::sp<IFlashlight> service = IFlashlight::getService();
     service->setFlashlightEnable(Enable::ENABLE);
     switch (value) {
@@ -50,13 +48,10 @@ Java_com_eurekateam_samsungextras_interfaces_Flashlight_setFlash(JNIEnv *env, __
             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,
-                                                                 jint isA10) {
     android::sp<IFlashlight> service = IFlashlight::getService();
     int ret;
     if (isA10 == 1) {

universal7885-common/apps/SamsungParts/jni/GPUBridge.cpp

@@ -1,16 +1,15 @@
-#include <vendor/eureka/hardware/gpu/1.0/IGpu.h>
-#include <hidl/Status.h>
-#include <hidl/LegacySupport.h>
 #include <hardware/hardware.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"
 
-using vendor::eureka::hardware::gpu::V1_0::IGpu;
-using vendor::eureka::hardware::gpu::V1_0::Enable;
 using android::sp;
+using vendor::eureka::hardware::gpu::V1_0::Enable;
+using vendor::eureka::hardware::gpu::V1_0::IGpu;
 
-extern "C"
+extern "C" JNIEXPORT void JNICALL
-JNIEXPORT void JNICALL
 Java_com_eurekateam_samsungextras_interfaces_GPU_setGPU(JNIEnv* env, jclass clazz, jint enable) {
     android::sp<IGpu> service = IGpu::getService();
     if (enable == 1) {
@@ -19,8 +18,7 @@ Java_com_eurekateam_samsungextras_interfaces_GPU_setGPU(JNIEnv *env, jclass claz
         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) {
     android::sp<IGpu> service = IGpu::getService();
     int ret = service->readGpustats();

universal7885-common/apps/SamsungParts/jni/SELinuxBridge.cpp

@@ -1,16 +1,15 @@
-#include <vendor/eureka/security/selinux/1.0/ISELinux.h>
-#include <hidl/Status.h>
-#include <hidl/LegacySupport.h>
 #include <hardware/hardware.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"
 
-using vendor::eureka::security::selinux::V1_0::ISELinux;
-using vendor::eureka::security::selinux::V1_0::Enable;
 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) {
     android::sp<ISELinux> service = ISELinux::getService();
     int ret = service->readSELinuxstats();

universal7885-common/bluetooth/bdroid_buildcfg.h

@@ -6,21 +6,15 @@
 #include <cutils/properties.h>
 #include <string.h>
 
-static inline const char* BtmGetDefaultName()
+static inline const char* BtmGetDefaultName() {
-{
     char product_device[PROPERTY_VALUE_MAX];
     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
     return "Samsung Galaxy";
 }

universal7885-common/hidl/fingerprint/BiometricsFingerprint.cpp

@@ -24,9 +24,9 @@
 #include "BiometricsFingerprint.h"
 
 #include <dlfcn.h>
-#include <fstream>
 #include <inttypes.h>
 #include <unistd.h>
+#include <fstream>
 
 #ifdef HAS_FINGERPRINT_GESTURES
 #include <fcntl.h>
@@ -58,8 +58,7 @@ BiometricsFingerprint::BiometricsFingerprint() : mClientCallback(nullptr) {
         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);
     if (err != 0) {
         LOG(ERROR) << "Unable to enable key events";
@@ -286,8 +285,8 @@ bool BiometricsFingerprint::openHal() {
     if (handle) {
         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 =
                 reinterpret_cast<typeof(ss_fingerprint_open)>(dlsym(handle, "ss_fingerprint_open"));
 
@@ -295,18 +294,18 @@ bool BiometricsFingerprint::openHal() {
                 dlsym(handle, "ss_set_notify_callback"));
         ss_fingerprint_pre_enroll = reinterpret_cast<typeof(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)>(
                 dlsym(handle, "ss_fingerprint_post_enroll"));
         ss_fingerprint_get_auth_id = reinterpret_cast<typeof(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)>(
                 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)>(
                 dlsym(handle, "ss_fingerprint_set_active_group"));
         ss_fingerprint_authenticate = reinterpret_cast<typeof(ss_fingerprint_authenticate)>(
@@ -376,7 +375,8 @@ void BiometricsFingerprint::notify(const fingerprint_msg_t* msg) {
                        << ", rem=" << msg->data.enroll.samples_remaining << ")";
             if (!thisPtr->mClientCallback
                          ->onEnrollResult(devId, msg->data.enroll.finger.fid,
-                                     msg->data.enroll.finger.gid, msg->data.enroll.samples_remaining)
+                                          msg->data.enroll.finger.gid,
+                                          msg->data.enroll.samples_remaining)
                          .isOk()) {
                 LOG(ERROR) << "failed to invoke fingerprint onEnrollResult callback";
             }
@@ -386,7 +386,8 @@ void BiometricsFingerprint::notify(const fingerprint_msg_t* msg) {
                        << ", gid=" << msg->data.removed.finger.gid
                        << ", rem=" << msg->data.removed.remaining_templates << ")";
             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.finger.gid,
                                      msg->data.removed.remaining_templates)
                          .isOk()) {
                 LOG(ERROR) << "failed to invoke fingerprint onRemoved callback";
@@ -409,7 +410,8 @@ void BiometricsFingerprint::notify(const fingerprint_msg_t* msg) {
                 // Not a recognized fingerprint
                 if (!thisPtr->mClientCallback
                              ->onAuthenticated(devId, msg->data.authenticated.finger.fid,
-                                           msg->data.authenticated.finger.gid, hidl_vec<uint8_t>())
+                                               msg->data.authenticated.finger.gid,
+                                               hidl_vec<uint8_t>())
                              .isOk()) {
                     LOG(ERROR) << "failed to invoke fingerprint onAuthenticated callback";
                 }
@@ -436,8 +438,7 @@ void BiometricsFingerprint::handleEvent(int eventCode) {
         case SEM_FINGERPRINT_EVENT_GESTURE_SWIPE_DOWN:
         case SEM_FINGERPRINT_EVENT_GESTURE_SWIPE_UP:
             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;
 
             // Report the key
@@ -496,8 +497,8 @@ int BiometricsFingerprint::waitForSensor(std::chrono::milliseconds pollWait,
     int sensorStatus = SEM_SENSOR_STATUS_WORKING;
     std::chrono::milliseconds timeWaited = 0ms;
     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;
         }
         if (timeWaited >= timeOut) {

universal7885-common/hidl/fingerprint/BiometricsFingerprint.h

@@ -24,12 +24,12 @@
 #include <linux/uinput.h>
 #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/hardware.h>
 #include <hidl/MQDescriptor.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"
 
@@ -47,11 +47,11 @@ using ::android::hardware::hidl_string;
 using ::android::hardware::hidl_vec;
 using ::android::hardware::Return;
 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::FingerprintError;
+using ::android::hardware::biometrics::fingerprint::V2_1::IBiometricsFingerprintClientCallback;
 using ::android::hardware::biometrics::fingerprint::V2_1::RequestStatus;
+using ::android::hardware::biometrics::fingerprint::V2_3::IBiometricsFingerprint;
 
 struct BiometricsFingerprint : public IBiometricsFingerprint {
     BiometricsFingerprint();
@@ -60,7 +60,8 @@ struct BiometricsFingerprint : public IBiometricsFingerprint {
     // Method to wrap legacy HAL with BiometricsFingerprint class
     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(
             const sp<IBiometricsFingerprintClientCallback>& clientCallback) override;
     Return<uint64_t> preEnroll() override;
@@ -111,7 +112,8 @@ struct BiometricsFingerprint : public IBiometricsFingerprint {
     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_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

universal7885-common/hidl/sensors/Sensors.cpp

@@ -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;
     if (UseMultiHal()) {
         mSensorModule = ::get_multi_hal_module_info();
     } 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) {
         err = UNKNOWN_ERROR;
     }
 
     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;
         return;
@@ -85,11 +77,8 @@ Sensors::Sensors()
     err = sensors_open_1(&mSensorModule->common, &mSensorDevice);
 
     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;
         return;
@@ -166,24 +155,19 @@ int Sensors::getHalDeviceVersion() const {
 }
 
 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 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) {
-
     hidl_vec<Event> out;
     hidl_vec<SensorInfo> dynamicSensorsAdded;
 
@@ -203,8 +187,8 @@ Return<void> Sensors::poll(int32_t maxCount, poll_cb _hidl_cb) {
         if (!lock.owns_lock()) {
             // cannot get the lock, hidl service will go into deadlock if it is not restarted.
             // 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);
         }
 
@@ -213,8 +197,7 @@ Return<void> Sensors::poll(int32_t maxCount, poll_cb _hidl_cb) {
         } else {
             int bufferSize = maxCount <= kPollMaxBufferSize ? maxCount : kPollMaxBufferSize;
             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);
         }
     }
@@ -256,17 +239,10 @@ Return<void> Sensors::poll(int32_t maxCount, poll_cb _hidl_cb) {
     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 sampling_period_ns,
                               int64_t max_report_latency_ns) {
-    return ResultFromStatus(
+    return ResultFromStatus(mSensorDevice->batch(mSensorDevice, sensor_handle, 0, /*flags*/
-            mSensorDevice->batch(
+                                                 sampling_period_ns, max_report_latency_ns));
-                mSensorDevice,
-                sensor_handle,
-                0, /*flags*/
-                sampling_period_ns,
-                max_report_latency_ns));
 }
 
 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) {
-    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;
     }
 
     sensors_event_t 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
         _hidl_cb(Result::INVALID_OPERATION, -1);
         return Void();
@@ -313,8 +288,8 @@ Return<void> Sensors::registerDirectChannel(
 }
 
 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
         return Result::INVALID_OPERATION;
     }
@@ -324,26 +299,22 @@ Return<Result> Sensors::unregisterDirectChannel(int32_t channelHandle) {
     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
         _hidl_cb(Result::INVALID_OPERATION, -1);
         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) {
         _hidl_cb(Result::BAD_VALUE, -1);
         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) {
         _hidl_cb(ResultFromStatus(err), -1);
@@ -354,9 +325,7 @@ Return<void> Sensors::configDirectReport(
 }
 
 // static
-void Sensors::convertFromSensorEvents(
+void Sensors::convertFromSensorEvents(size_t count, const sensors_event_t* srcArray,
-        size_t count,
-        const sensors_event_t *srcArray,
                                       hidl_vec<Event>* dstVec) {
     for (size_t i = 0; i < count; ++i) {
         const sensors_event_t& src = srcArray[i];

universal7885-common/hidl/sensors/Sensors.h

@@ -29,7 +29,6 @@ namespace sensors {
 namespace V1_0 {
 namespace implementation {
 
-
 struct Sensors : public ::android::hardware::sensors::V1_0::ISensors {
     Sensors();
 
@@ -39,27 +38,23 @@ struct Sensors : public ::android::hardware::sensors::V1_0::ISensors {
 
     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<Result> batch(
+    Return<Result> batch(int32_t sensor_handle, int64_t sampling_period_ns,
-            int32_t sensor_handle,
-            int64_t sampling_period_ns,
                          int64_t max_report_latency_ns) override;
 
     Return<Result> flush(int32_t sensor_handle) 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<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;
 
   private:
@@ -71,8 +66,8 @@ private:
 
     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);
 };

universal7885-common/init/init_universal7885.cpp

@@ -30,8 +30,8 @@
 #define _REALLY_INCLUDE_SYS__SYSTEM_PROPERTIES_H_
 #include <sys/_system_properties.h>
 
-#include <android-base/properties.h>
 #include <android-base/logging.h>
+#include <android-base/properties.h>
 
 #include "property_service.h"
 #include "vendor_init.h"
@@ -40,12 +40,7 @@ using android::base::GetProperty;
 using std::string;
 
 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) {
@@ -73,7 +68,8 @@ 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) {
     if (fullString.length() >= ending.length()) {
-        return (0 == fullString.compare (fullString.length() - ending.length(), ending.length(), ending));
+        return (0 ==
+                fullString.compare(fullString.length() - ending.length(), ending.length(), ending));
     } else {
         return false;
     }
@@ -87,7 +83,8 @@ void vendor_load_properties() {
         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") ||
+        model == "SM-A202F") {
         property_override("ro.boot.product.hardware.sku", "NFC");
     }
 

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

@@ -13,10 +13,10 @@
 // limitations under the License.
 
 #include "Battery.h"
-#include <iostream>
-#include <fstream>
-#include <sstream>
 #include <unistd.h>
+#include <fstream>
+#include <iostream>
+#include <sstream>
 
 namespace vendor::eureka::hardware::battery::V1_0 {
 
@@ -60,7 +60,8 @@ Return<int32_t> Battery::getBatteryStats(battery::V1_0::SysfsType stats) {
     return -1;
 }
 
-Return<int32_t> Battery::setBatteryWritable(battery::V1_0::SysfsType stats, battery::V1_0::Number value) {
+Return<int32_t> Battery::setBatteryWritable(battery::V1_0::SysfsType stats,
+                                            battery::V1_0::Number value) {
     std::ofstream file;
     std::string filename;
     bool FastCharge = false;
@@ -105,4 +106,4 @@ Return<int32_t> Battery::setBatteryWritable(battery::V1_0::SysfsType stats, batt
 IBattery* Battery::getInstance(void) {
     return new Battery();
 }
-}  // namespace android::hardware::battery::implementation
+}  // namespace vendor::eureka::hardware::battery::V1_0

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

@@ -14,22 +14,22 @@
 
 #pragma once
 
-#include <vendor/eureka/hardware/battery/1.0/IBattery.h>
 #include <hidl/MQDescriptor.h>
 #include <hidl/Status.h>
+#include <vendor/eureka/hardware/battery/1.0/IBattery.h>
 
 #define ANDROID_SYSTEM_UID 1000
 #define ANDROID_ROOT_UID 0
 
 namespace vendor::eureka::hardware::battery::V1_0 {
 
+using ::android::sp;
 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 Battery : public IBattery {
     // 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.
     static IBattery* getInstance(void);
-
 };
-}  // namespace android::hardware::battery::implementation
+}  // namespace vendor::eureka::hardware::battery::V1_0

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

@@ -12,7 +12,6 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-
 #define LOG_TAG "vendor.eureka.hardware.battery@1.0-service"
 
 #include <vendor/eureka/hardware/battery/1.0/IBattery.h>
@@ -21,11 +20,11 @@
 
 #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::joinRpcThreadpool;
-using android::sp;
+using vendor::eureka::hardware::battery::V1_0::Battery;
+using vendor::eureka::hardware::battery::V1_0::IBattery;
 
 int main() {
     int ret;

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

@@ -13,8 +13,8 @@
 // limitations under the License.
 
 #include "Flashlight.h"
-#include <iostream>
 #include <fstream>
+#include <iostream>
 #include <sstream>
 namespace vendor::eureka::hardware::flashlight::V1_0 {
 
@@ -107,4 +107,4 @@ Return<int32_t> Flashlight::readFlashlightstats(flashlight::V1_0::Device device)
 IFlashlight* Flashlight::getInstance(void) {
     return new Flashlight();
 }
-}  // namespace android::hardware::flashlight::implementation
+}  // namespace vendor::eureka::hardware::flashlight::V1_0

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

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

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

@@ -12,7 +12,6 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-
 #define LOG_TAG "vendor.eureka.hardware.flashlight@1.0-service"
 
 #include <vendor/eureka/hardware/flashlight/1.0/IFlashlight.h>
@@ -21,11 +20,11 @@
 
 #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::joinRpcThreadpool;
-using android::sp;
+using vendor::eureka::hardware::flashlight::V1_0::Flashlight;
+using vendor::eureka::hardware::flashlight::V1_0::IFlashlight;
 
 int main() {
     int ret;

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

@@ -13,8 +13,8 @@
 // limitations under the License.
 
 #include "Gpu.h"
-#include <iostream>
 #include <fstream>
+#include <iostream>
 #include <sstream>
 namespace vendor::eureka::hardware::gpu::V1_0 {
 
@@ -50,4 +50,4 @@ Return<int32_t> Gpu::readGpustats(void) {
 IGpu* Gpu::getInstance(void) {
     return new Gpu();
 }
-}  // namespace android::hardware::gpu::implementation
+}  // namespace vendor::eureka::hardware::gpu::V1_0

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

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

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

@@ -12,7 +12,6 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-
 #define LOG_TAG "vendor.eureka.hardware.gpu@1.0-service"
 
 #include <vendor/eureka/hardware/gpu/1.0/IGpu.h>
@@ -21,11 +20,11 @@
 
 #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::joinRpcThreadpool;
-using android::sp;
+using vendor::eureka::hardware::gpu::V1_0::Gpu;
+using vendor::eureka::hardware::gpu::V1_0::IGpu;
 
 int main() {
     int ret;

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

@@ -13,8 +13,8 @@
 // limitations under the License.
 
 #include "SELinux.h"
-#include <iostream>
 #include <fstream>
+#include <iostream>
 #include <sstream>
 namespace vendor::eureka::security::selinux::V1_0 {
 
@@ -50,4 +50,4 @@ Return<int32_t> SELinux::readSELinuxstats(void) {
 ISELinux* SELinux::getInstance(void) {
     return new SELinux();
 }
-}  // namespace android::security::selinux::implementation
+}  // namespace vendor::eureka::security::selinux::V1_0

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

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

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

@@ -12,7 +12,6 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-
 #define LOG_TAG "vendor.eureka.security.selinux@1.0-service"
 
 #include <vendor/eureka/security/selinux/1.0/ISELinux.h>
@@ -21,11 +20,11 @@
 
 #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::joinRpcThreadpool;
-using android::sp;
+using vendor::eureka::security::selinux::V1_0::ISELinux;
+using vendor::eureka::security::selinux::V1_0::SELinux;
 
 int main() {
     int ret;

universal7885-common/libshims/camera/CameraMetadata.cpp

@@ -24,26 +24,19 @@
 
 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);
 }
 
-CameraMetadata::CameraMetadata(const CameraMetadata &other) :
+CameraMetadata::CameraMetadata(const CameraMetadata& other) : mLocked(false) {
-        mLocked(false) {
     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);
 }
 
@@ -81,8 +74,7 @@ status_t CameraMetadata::unlock(const camera_metadata_t *buffer) const {
         return INVALID_OPERATION;
     }
     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;
     }
     mLocked = false;
@@ -119,8 +111,7 @@ void CameraMetadata::acquire(camera_metadata_t *buffer) {
     mBuffer = buffer;
 
     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) {
@@ -148,8 +139,7 @@ status_t CameraMetadata::append(const camera_metadata_t* other) {
 }
 
 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 {
@@ -174,15 +164,13 @@ status_t CameraMetadata::checkType(uint32_t tag, uint8_t expectedType) {
         ALOGE("Mismatched tag type when updating entry %s (%d) of type %s; "
               "got type %s data instead ",
               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 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;
     if (mLocked) {
         ALOGE("%s: CameraMetadata is locked", __FUNCTION__);
@@ -194,8 +182,7 @@ status_t CameraMetadata::update(uint32_t tag,
     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;
     if (mLocked) {
         ALOGE("%s: CameraMetadata is locked", __FUNCTION__);
@@ -207,8 +194,7 @@ status_t CameraMetadata::update(uint32_t tag,
     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;
     if (mLocked) {
         ALOGE("%s: CameraMetadata is locked", __FUNCTION__);
@@ -220,8 +206,7 @@ status_t CameraMetadata::update(uint32_t tag,
     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;
     if (mLocked) {
         ALOGE("%s: CameraMetadata is locked", __FUNCTION__);
@@ -233,8 +218,7 @@ status_t CameraMetadata::update(uint32_t tag,
     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;
     if (mLocked) {
         ALOGE("%s: CameraMetadata is locked", __FUNCTION__);
@@ -246,8 +230,8 @@ status_t CameraMetadata::update(uint32_t tag,
     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;
     if (mLocked) {
         ALOGE("%s: CameraMetadata is locked", __FUNCTION__);
@@ -259,8 +243,7 @@ status_t CameraMetadata::update(uint32_t tag,
     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;
     if (mLocked) {
         ALOGE("%s: CameraMetadata is locked", __FUNCTION__);
@@ -285,8 +268,7 @@ status_t CameraMetadata::update(const camera_metadata_ro_entry &entry) {
     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;
     if (mLocked) {
         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 dataAddr = reinterpret_cast<uintptr_t>(data);
     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;
     }
 
-    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);
 
@@ -317,27 +297,23 @@ status_t CameraMetadata::updateImpl(uint32_t tag, const void *data,
         camera_metadata_entry_t entry;
         res = find_camera_metadata_entry(mBuffer, tag, &entry);
         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) {
-            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) {
-        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() {
-        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;
@@ -386,20 +362,16 @@ status_t CameraMetadata::erase(uint32_t tag) {
     if (res == NAME_NOT_FOUND) {
         return 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_tag_name(tag, mBuffer),
+              get_local_camera_metadata_tag_name(tag, mBuffer), tag, strerror(-res), res);
-                tag, strerror(-res), res);
         return res;
     }
     res = delete_camera_metadata_entry(mBuffer, entry.index);
     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_tag_name(tag, mBuffer),
+              get_local_camera_metadata_tag_name(tag, mBuffer), tag, strerror(-res), res);
-                tag, strerror(-res), res);
     }
     return res;
 }
@@ -418,23 +390,17 @@ status_t CameraMetadata::resizeIfNeeded(size_t extraEntries, size_t extraData) {
     } else {
         size_t currentEntryCount = get_camera_metadata_entry_count(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 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;
-            mBuffer = allocate_camera_metadata(newEntryCount,
+            mBuffer = allocate_camera_metadata(newEntryCount, newDataCount);
-                    newDataCount);
             if (mBuffer == NULL) {
                 ALOGE("%s: Can't allocate larger metadata buffer", __FUNCTION__);
                 return NO_MEMORY;
@@ -462,5 +428,4 @@ void CameraMetadata::swap(CameraMetadata& other) {
     mBuffer = otherBuf;
 }
 
-
 };  // namespace android

universal7885-common/libshims/camera/CameraMetadata.h

@@ -123,23 +123,15 @@ class CameraMetadata {
      * will reallocate the buffer if insufficient space exists. Overloaded for
      * 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(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>
     status_t update(uint32_t tag, Vector<T> data) {
         return update(tag, data.array(), data.size());
@@ -202,7 +194,6 @@ class CameraMetadata {
      * Resize metadata buffer if needed by reallocating it and copying it over.
      */
     status_t resizeIfNeeded(size_t extraEntries, size_t extraData);
-
 };
 
 }  // namespace android

universal7885-common/libshims/camera/CameraParameters.cpp

@@ -18,11 +18,11 @@
 #define LOG_TAG "CameraParams"
 #include <log/log.h>
 
-#include <string.h>
 #include <stdlib.h>
+#include <string.h>
+#include <system/graphics.h>
 #include <unistd.h>
 #include "CameraParameters.h"
-#include <system/graphics.h>
 
 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_SUPPORTED[] = "auto-exposure-lock-supported";
 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_METERING_AREAS[] = "metering-areas";
 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_SIZE[] = "video-size";
 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_SW[] = "max-num-detected-faces-sw";
 const char CameraParameters::KEY_RECORDING_HINT[] = "recording-hint";
@@ -175,17 +177,11 @@ const char CameraParameters::FOCUS_MODE_CONTINUOUS_PICTURE[] = "continuous-pictu
 const char CameraParameters::LIGHTFX_LOWLIGHT[] = "low-light";
 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("");
     size_t size = mMap.size();
 
@@ -197,15 +193,13 @@ String8 CameraParameters::flatten() const
         flattened += k;
         flattened += "=";
         flattened += v;
-        if (i != size-1)
+        if (i != size - 1) flattened += ";";
-            flattened += ";";
     }
 
     return flattened;
 }
 
-void CameraParameters::unflatten(const String8 &params)
+void CameraParameters::unflatten(const String8& params) {
-{
     const char* a = params.string();
     const char* b;
 
@@ -214,8 +208,7 @@ void CameraParameters::unflatten(const String8 &params)
     for (;;) {
         // Find the bounds of the key name.
         b = strchr(a, '=');
-        if (b == 0)
+        if (b == 0) break;
-            break;
 
         // Create the key string.
         String8 k(a, (size_t)(b - a));
@@ -236,9 +229,7 @@ void CameraParameters::unflatten(const String8 &params)
     }
 }
 
-
+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()
     if (strchr(key, '=') || strchr(key, ';')) {
         // ALOGE("Key \"%s\"contains invalid character (= or ;)", key);
@@ -253,52 +244,42 @@ void CameraParameters::set(const char *key, const char *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];
     sprintf(str, "%d", value);
     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.
     snprintf(str, sizeof(str), "%g", value);
     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));
-    if (v.length() == 0)
+    if (v.length() == 0) return 0;
-        return 0;
     return v.string();
 }
 
-int CameraParameters::getInt(const char *key) const
+int CameraParameters::getInt(const char* key) const {
-{
     const char* v = get(key);
-    if (v == 0)
+    if (v == 0) return -1;
-        return -1;
     return strtol(v, 0, 0);
 }
 
-float CameraParameters::getFloat(const char *key) const
+float CameraParameters::getFloat(const char* key) const {
-{
     const char* v = get(key);
     if (v == 0) return -1;
     return strtof(v, 0);
 }
 
-void CameraParameters::remove(const char *key)
+void CameraParameters::remove(const char* key) {
-{
     mMap.removeItem(String8(key));
 }
 
 // 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.
     char* end;
     int w = (int)strtol(str, &end, 10);
@@ -321,8 +302,7 @@ static int parse_pair(const char *str, int *first, int *second, char delim,
     return 0;
 }
 
-static void parseSizesList(const char *sizesStr, Vector<Size> &sizes)
+static void parseSizesList(const char* sizesStr, Vector<Size>& sizes) {
-{
     if (sizesStr == 0) {
         return;
     }
@@ -331,8 +311,7 @@ static void parseSizesList(const char *sizesStr, Vector<Size> &sizes)
 
     while (true) {
         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')) {
             ALOGE("Picture sizes string \"%s\" contains invalid character.", sizesStr);
             return;
@@ -346,15 +325,13 @@ 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];
     sprintf(str, "%dx%d", width, height);
     set(KEY_PREVIEW_SIZE, str);
 }
 
-void CameraParameters::getPreviewSize(int *width, int *height) const
+void CameraParameters::getPreviewSize(int* width, int* height) const {
-{
     *width = *height = -1;
     // Get the current string, if it doesn't exist, leave the -1x-1
     const char* p = get(KEY_PREVIEW_SIZE);
@@ -362,78 +339,66 @@ void CameraParameters::getPreviewSize(int *width, int *height) const
     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;
     const char* p = get(KEY_PREFERRED_PREVIEW_SIZE_FOR_VIDEO);
     if (p == 0) return;
     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);
     parseSizesList(previewSizesStr, sizes);
 }
 
-void CameraParameters::setVideoSize(int width, int height)
+void CameraParameters::setVideoSize(int width, int height) {
-{
     char str[32];
     sprintf(str, "%dx%d", width, height);
     set(KEY_VIDEO_SIZE, str);
 }
 
-void CameraParameters::getVideoSize(int *width, int *height) const
+void CameraParameters::getVideoSize(int* width, int* height) const {
-{
     *width = *height = -1;
     const char* p = get(KEY_VIDEO_SIZE);
     if (p == 0) return;
     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);
     parseSizesList(videoSizesStr, sizes);
 }
 
-void CameraParameters::setPreviewFrameRate(int fps)
+void CameraParameters::setPreviewFrameRate(int fps) {
-{
     set(KEY_PREVIEW_FRAME_RATE, fps);
 }
 
-int CameraParameters::getPreviewFrameRate() const
+int CameraParameters::getPreviewFrameRate() const {
-{
     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;
     const char* p = get(KEY_PREVIEW_FPS_RANGE);
     if (p == 0) return;
     parse_pair(p, min_fps, max_fps, ',');
 }
 
-void CameraParameters::setPreviewFormat(const char *format)
+void CameraParameters::setPreviewFormat(const char* format) {
-{
     set(KEY_PREVIEW_FORMAT, format);
 }
 
-const char *CameraParameters::getPreviewFormat() const
+const char* CameraParameters::getPreviewFormat() const {
-{
     return get(KEY_PREVIEW_FORMAT);
 }
 
-void CameraParameters::setPictureSize(int width, int height)
+void CameraParameters::setPictureSize(int width, int height) {
-{
     char str[32];
     sprintf(str, "%dx%d", width, height);
     set(KEY_PICTURE_SIZE, str);
 }
 
-void CameraParameters::getPictureSize(int *width, int *height) const
+void CameraParameters::getPictureSize(int* width, int* height) const {
-{
     *width = *height = -1;
     // Get the current string, if it doesn't exist, leave the -1x-1
     const char* p = get(KEY_PICTURE_SIZE);
@@ -441,24 +406,20 @@ void CameraParameters::getPictureSize(int *width, int *height) const
     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);
     parseSizesList(pictureSizesStr, sizes);
 }
 
-void CameraParameters::setPictureFormat(const char *format)
+void CameraParameters::setPictureFormat(const char* format) {
-{
     set(KEY_PICTURE_FORMAT, format);
 }
 
-const char *CameraParameters::getPictureFormat() const
+const char* CameraParameters::getPictureFormat() const {
-{
     return get(KEY_PICTURE_FORMAT);
 }
 
-void CameraParameters::dump() const
+void CameraParameters::dump() const {
-{
     ALOGD("dump: mMap.size = %zu", mMap.size());
     for (size_t i = 0; i < mMap.size(); i++) {
         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;
     char buffer[SIZE];
     String8 result;
@@ -487,8 +447,7 @@ status_t CameraParameters::dump(int fd, const Vector<String16>& /*args*/) 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) {
         ALOGW("%s: No supported preview formats.", __FUNCTION__);
@@ -510,25 +469,22 @@ void CameraParameters::getSupportedPreviewFormats(Vector<int>& formats) const {
     fmtStr.unlockBuffer(fmtStr.size());
 }
 
-
 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) ?
-            HAL_PIXEL_FORMAT_RAW16 :   // Raw sensor data
                    -1;
 }
 

universal7885-common/libshims/camera/CameraParameters.h

@@ -37,8 +37,7 @@ struct Size {
     }
 };
 
-class CameraParameters
+class CameraParameters {
-{
   public:
     CameraParameters();
     CameraParameters(const String8& params) { unflatten(params); }
@@ -694,6 +693,6 @@ private:
     DefaultKeyedVector<String8, String8> mMap;
 };
 
-}; // namespace
+};  // namespace android
 
 #endif

universal7885-common/libshims/sensor/ASensorManager.cpp

@@ -42,11 +42,8 @@ extern "C" int ALooper_release_forCamera(ALooper *sLooper) {
     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);
     LOG(VERBOSE) << "ALooper_pollOnce_camera => " << res;
     return res;

universal7885-common/secril_config_svc/secril_config_svc.cpp

@@ -45,8 +45,7 @@ void LoadProperties(std::string data) {
 int main(int argc, char* argv[]) {
     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);
     if (in.good()) {

universal7885-common/usb/typeb/Usb.cpp

@@ -51,8 +51,7 @@ Return<void> Usb::queryPortStatus() {
 
     pthread_mutex_lock(&mLock);
     if (mCallback != NULL) {
-        Return<void> ret =
+        Return<void> ret = mCallback->notifyPortStatusChange(currentPortStatus, Status::SUCCESS);
-                mCallback->notifyPortStatusChange(currentPortStatus, Status::SUCCESS);
         if (!ret.isOk()) {
             LOG(ERROR) << "queryPortStatus error " << ret.description();
         }

universal7885-common/usb/typeb/Usb.h

@@ -35,17 +35,17 @@ namespace usb {
 namespace V1_0 {
 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_memory;
 using ::android::hardware::hidl_string;
 using ::android::hardware::hidl_vec;
 using ::android::hardware::Return;
 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 {
     Return<void> switchRole(const hidl_string& portName, const PortRole& role) override;

universal7885-common/usb/typec/Usb.cpp

@@ -18,14 +18,14 @@
 
 #include <android-base/logging.h>
 #include <assert.h>
-#include <chrono>
 #include <dirent.h>
 #include <pthread.h>
-#include <regex>
 #include <stdio.h>
 #include <sys/types.h>
-#include <thread>
 #include <unistd.h>
+#include <chrono>
+#include <regex>
+#include <thread>
 #include <unordered_map>
 
 #include <cutils/uevent.h>
@@ -72,8 +72,7 @@ static int32_t readFile(const std::string &filename, std::string *contents) {
     return -1;
 }
 
-static int32_t writeFile(const std::string &filename,
+static int32_t writeFile(const std::string& filename, const std::string& contents) {
-                         const std::string &contents) {
     FILE* fp;
     int ret;
 
@@ -93,8 +92,7 @@ static int32_t writeFile(const std::string &filename,
     return -1;
 }
 
-std::string appendRoleNodeHelper(const std::string &portName,
+std::string appendRoleNodeHelper(const std::string& portName, PortRoleType type) {
-                                 PortRoleType type) {
     std::string node("/sys/class/typec/" + portName);
 
     switch (type) {
@@ -117,8 +115,7 @@ std::string convertRoletoString(PortRole role) {
             return "sink";
     } else if (role.type == PortRoleType::DATA_ROLE) {
         if (role.role == static_cast<uint32_t>(PortDataRole::HOST)) return "host";
-    if (role.role == static_cast<uint32_t>(PortDataRole::DEVICE))
+        if (role.role == static_cast<uint32_t>(PortDataRole::DEVICE)) return "device";
-      return "device";
     } else if (role.type == PortRoleType::MODE) {
         if (role.role == static_cast<uint32_t>(PortMode_1_1::UFP)) return "sink";
         if (role.role == static_cast<uint32_t>(PortMode_1_1::DFP)) return "source";
@@ -138,8 +135,7 @@ void extractRole(std::string *roleName) {
 }
 
 void switchToDrp(const std::string& portName) {
-  std::string filename =
+    std::string filename = appendRoleNodeHelper(std::string(portName.c_str()), PortRoleType::MODE);
-      appendRoleNodeHelper(std::string(portName.c_str()), PortRoleType::MODE);
     FILE* fp;
 
     if (filename != "") {
@@ -147,8 +143,7 @@ void switchToDrp(const std::string &portName) {
         if (fp != NULL) {
             int ret = fputs("dual", fp);
             fclose(fp);
-      if (ret == EOF)
+            if (ret == EOF) ALOGE("Fatal: Error while switching back to drp");
-        ALOGE("Fatal: Error while switching back to drp");
         } else {
             ALOGE("Fatal: Cannot open file to switch back to drp");
         }
@@ -157,10 +152,8 @@ void switchToDrp(const std::string &portName) {
     }
 }
 
-bool switchMode(const hidl_string &portName,
+bool switchMode(const hidl_string& portName, const PortRole& newRole, struct Usb* usb) {
-                             const PortRole &newRole, struct Usb *usb) {
+    std::string filename = appendRoleNodeHelper(std::string(portName.c_str()), newRole.type);
-  std::string filename =
-       appendRoleNodeHelper(std::string(portName.c_str()), newRole.type);
     std::string written;
     FILE* fp;
     bool roleSwitch = false;
@@ -206,8 +199,7 @@ wait_again:
         pthread_mutex_unlock(&usb->mPartnerLock);
     }
 
-  if (!roleSwitch)
+    if (!roleSwitch) switchToDrp(std::string(portName.c_str()));
-    switchToDrp(std::string(portName.c_str()));
 
     return roleSwitch;
 }
@@ -236,11 +228,8 @@ Usb::Usb()
     }
 }
 
-
+Return<void> Usb::switchRole(const hidl_string& portName, const PortRole& newRole) {
-Return<void> Usb::switchRole(const hidl_string &portName,
+    std::string filename = appendRoleNodeHelper(std::string(portName.c_str()), newRole.type);
-                             const PortRole &newRole) {
-  std::string filename =
-      appendRoleNodeHelper(std::string(portName.c_str()), newRole.type);
     std::string written;
     FILE* fp;
     bool roleSwitch = false;
@@ -252,8 +241,7 @@ Return<void> Usb::switchRole(const hidl_string &portName,
 
     pthread_mutex_lock(&mRoleSwitchLock);
 
-  ALOGI("filename write: %s role:%s", filename.c_str(),
+    ALOGI("filename write: %s role:%s", filename.c_str(), convertRoletoString(newRole).c_str());
-        convertRoletoString(newRole).c_str());
 
     if (newRole.type == PortRoleType::MODE) {
         roleSwitch = switchMode(portName, newRole, this);
@@ -280,11 +268,9 @@ Return<void> Usb::switchRole(const hidl_string &portName,
 
     pthread_mutex_lock(&mLock);
     if (mCallback_1_0 != NULL) {
-    Return<void> ret =
+        Return<void> ret = mCallback_1_0->notifyRoleSwitchStatus(
-        mCallback_1_0->notifyRoleSwitchStatus(portName, newRole,
+                portName, newRole, roleSwitch ? Status::SUCCESS : Status::ERROR);
-        roleSwitch ? Status::SUCCESS : Status::ERROR);
+        if (!ret.isOk()) ALOGE("RoleSwitchStatus error %s", ret.description().c_str());
-    if (!ret.isOk())
-      ALOGE("RoleSwitchStatus error %s", ret.description().c_str());
     } else {
         ALOGE("Not notifying the userspace. Callback is not set");
     }
@@ -295,20 +281,18 @@ Return<void> Usb::switchRole(const hidl_string &portName,
 }
 
 Status getAccessoryConnected(const std::string& portName, std::string* accessory) {
-  std::string filename =
+    std::string filename = "/sys/class/typec/" + portName + "-partner/accessory_mode";
-    "/sys/class/typec/" + portName + "-partner/accessory_mode";
 
     if (readFile(filename, accessory)) {
-    ALOGE("getAccessoryConnected: Failed to open filesystem node: %s",
+        ALOGE("getAccessoryConnected: Failed to open filesystem node: %s", filename.c_str());
-          filename.c_str());
         return Status::ERROR;
     }
 
     return Status::SUCCESS;
 }
 
-Status getCurrentRoleHelper(const std::string &portName, bool connected,
+Status getCurrentRoleHelper(const std::string& portName, bool connected, PortRoleType type,
-                            PortRoleType type, uint32_t *currentRole) {
+                            uint32_t* currentRole) {
     std::string filename;
     std::string roleName;
     std::string accessory;
@@ -344,8 +328,7 @@ Status getCurrentRoleHelper(const std::string &portName, bool connected,
     }
 
     if (readFile(filename, &roleName)) {
-    ALOGE("getCurrentRole: Failed to open filesystem node: %s",
+        ALOGE("getCurrentRole: Failed to open filesystem node: %s", filename.c_str());
-          filename.c_str());
         return Status::ERROR;
     }
 
@@ -404,8 +387,7 @@ Status getTypeCPortNamesHelper(std::unordered_map<std::string, bool> *names) {
 }
 
 bool canSwitchRoleHelper(const std::string& portName, PortRoleType /*type*/) {
-  std::string filename =
+    std::string filename = "/sys/class/typec/" + portName + "-partner/supports_usb_power_delivery";
-      "/sys/class/typec/" + portName + "-partner/supports_usb_power_delivery";
     std::string supportsPD;
 
     if (!readFile(filename, &supportsPD)) {
@@ -422,8 +404,7 @@ bool canSwitchRoleHelper(const std::string &portName, PortRoleType /*type*/) {
  * The caller of this method would reconstruct the V1_0::PortStatus
  * object if required.
  */
-Status getPortStatusHelper(hidl_vec<PortStatus_1_1> *currentPortStatus_1_1,
+Status getPortStatusHelper(hidl_vec<PortStatus_1_1>* currentPortStatus_1_1, bool V1_0) {
-    bool V1_0) {
     std::unordered_map<std::string, bool> names;
     Status result = getTypeCPortNamesHelper(&names);
     int i = -1;
@@ -436,8 +417,7 @@ Status getPortStatusHelper(hidl_vec<PortStatus_1_1> *currentPortStatus_1_1,
             (*currentPortStatus_1_1)[i].status.portName = port.first;
 
             uint32_t currentRole;
-      if (getCurrentRoleHelper(port.first, port.second,
+            if (getCurrentRoleHelper(port.first, port.second, PortRoleType::POWER_ROLE,
-                               PortRoleType::POWER_ROLE,
                                      &currentRole) == Status::SUCCESS) {
                 (*currentPortStatus_1_1)[i].status.currentPowerRole =
                         static_cast<PortPowerRole>(currentRole);
@@ -455,10 +435,9 @@ Status getPortStatusHelper(hidl_vec<PortStatus_1_1> *currentPortStatus_1_1,
                 goto done;
             }
 
-      if (getCurrentRoleHelper(port.first, port.second, PortRoleType::MODE,
+            if (getCurrentRoleHelper(port.first, port.second, PortRoleType::MODE, &currentRole) ==
-                               &currentRole) == Status::SUCCESS) {
+                Status::SUCCESS) {
-        (*currentPortStatus_1_1)[i].currentMode =
+                (*currentPortStatus_1_1)[i].currentMode = static_cast<PortMode_1_1>(currentRole);
-            static_cast<PortMode_1_1>(currentRole);
                 (*currentPortStatus_1_1)[i].status.currentMode =
                         static_cast<V1_0::PortMode>(currentRole);
             } else {
@@ -468,15 +447,12 @@ Status getPortStatusHelper(hidl_vec<PortStatus_1_1> *currentPortStatus_1_1,
 
             (*currentPortStatus_1_1)[i].status.canChangeMode = true;
             (*currentPortStatus_1_1)[i].status.canChangeDataRole =
-          port.second ? canSwitchRoleHelper(port.first, PortRoleType::DATA_ROLE)
+                    port.second ? canSwitchRoleHelper(port.first, PortRoleType::DATA_ROLE) : false;
-                      : false;
             (*currentPortStatus_1_1)[i].status.canChangePowerRole =
-          port.second
+                    port.second ? canSwitchRoleHelper(port.first, PortRoleType::POWER_ROLE) : false;
-              ? canSwitchRoleHelper(port.first, PortRoleType::POWER_ROLE)
-              : false;
 
-      ALOGI("connected:%d canChangeMode:%d canChagedata:%d canChangePower:%d",
+            ALOGI("connected:%d canChangeMode:%d canChagedata:%d canChangePower:%d", port.second,
-            port.second, (*currentPortStatus_1_1)[i].status.canChangeMode,
+                  (*currentPortStatus_1_1)[i].status.canChangeMode,
                   (*currentPortStatus_1_1)[i].status.canChangeDataRole,
                   (*currentPortStatus_1_1)[i].status.canChangePowerRole);
 
@@ -518,8 +494,7 @@ Return<void> Usb::queryPortStatus() {
         else
             ret = mCallback_1_0->notifyPortStatusChange(currentPortStatus, status);
 
-    if (!ret.isOk())
+        if (!ret.isOk()) ALOGE("queryPortStatus_1_1 error %s", ret.description().c_str());
-      ALOGE("queryPortStatus_1_1 error %s", ret.description().c_str());
     } else {
         ALOGI("Notifying userspace skipped. Callback is NULL");
     }
@@ -560,14 +535,14 @@ static void uevent_event(uint32_t /*epevents*/, struct data *payload) {
             ALOGI("uevent received %s", cp);
             pthread_mutex_lock(&payload->usb->mLock);
             if (payload->usb->mCallback_1_0 != NULL) {
-        sp<IUsbCallback> callback_V1_1 = IUsbCallback::castFrom(payload->usb->mCallback_1_0);
+                sp<IUsbCallback> callback_V1_1 =
+                        IUsbCallback::castFrom(payload->usb->mCallback_1_0);
                 Return<void> ret;
 
                 // V1_1 callback
                 if (callback_V1_1 != NULL) {
                     Status status = getPortStatusHelper(&currentPortStatus_1_1, false);
-          ret = callback_V1_1->notifyPortStatusChange_1_1(
+                    ret = callback_V1_1->notifyPortStatusChange_1_1(currentPortStatus_1_1, status);
-              currentPortStatus_1_1, status);
                 } else {  // V1_0 callback
                     Status status = getPortStatusHelper(&currentPortStatus_1_1, true);
 
@@ -581,8 +556,8 @@ static void uevent_event(uint32_t /*epevents*/, struct data *payload) {
                     for (unsigned long i = 0; i < currentPortStatus_1_1.size(); i++)
                         currentPortStatus[i] = currentPortStatus_1_1[i].status;
 
-          ret = payload->usb->mCallback_1_0->notifyPortStatusChange(
+                    ret = payload->usb->mCallback_1_0->notifyPortStatusChange(currentPortStatus,
-              currentPortStatus, status);
+                                                                              status);
                 }
                 if (!ret.isOk()) ALOGE("error %s", ret.description().c_str());
             } else {
@@ -593,9 +568,12 @@ static void uevent_event(uint32_t /*epevents*/, struct data *payload) {
             // Role switch is not in progress and port is in disconnected state
             if (!pthread_mutex_trylock(&payload->usb->mRoleSwitchLock)) {
                 for (unsigned long i = 0; i < currentPortStatus_1_1.size(); i++) {
-          DIR *dp = opendir(std::string("/sys/class/typec/"
+                    DIR* dp = opendir(
-              + std::string(currentPortStatus_1_1[i].status.portName.c_str())
+                            std::string(
-              + "-partner").c_str());
+                                    "/sys/class/typec/" +
+                                    std::string(currentPortStatus_1_1[i].status.portName.c_str()) +
+                                    "-partner")
+                                    .c_str());
                     if (dp == NULL) {
                         // PortRole role = {.role = static_cast<uint32_t>(PortMode::UFP)};
                         switchToDrp(currentPortStatus_1_1[i].status.portName);
@@ -607,7 +585,8 @@ static void uevent_event(uint32_t /*epevents*/, struct data *payload) {
             }
             break;
         } else if (std::regex_match(cp, match,
-          std::regex("add@(/devices/soc/a800000\\.ssusb/a800000\\.dwc3/xhci-hcd\\.0\\.auto/"
+                                    std::regex("add@(/devices/soc/a800000\\.ssusb/a800000\\.dwc3/"
+                                               "xhci-hcd\\.0\\.auto/"
                                                "usb\\d/\\d-\\d)/.*"))) {
             if (match.size() == 2) {
                 std::csub_match submatch = match[1];
@@ -616,7 +595,8 @@ static void uevent_event(uint32_t /*epevents*/, struct data *payload) {
         }
 
         /* advance to after the next \0 */
-    while (*cp++) {}
+        while (*cp++) {
+        }
     }
 }
 
@@ -666,8 +646,8 @@ void *work(void *param) {
 
         for (int n = 0; n < nevents; ++n) {
             if (events[n].data.ptr)
-        (*(void (*)(int, struct data *payload))events[n].data.ptr)(
+                (*(void (*)(int, struct data* payload))events[n].data.ptr)(events[n].events,
-            events[n].events, &payload);
+                                                                           &payload);
         }
     }
 
@@ -690,12 +670,10 @@ void sighandler(int sig) {
 }
 
 Return<void> Usb::setCallback(const sp<V1_0::IUsbCallback>& callback) {
-
     sp<IUsbCallback> callback_V1_1 = IUsbCallback::castFrom(callback);
 
     if (callback != NULL)
-      if (callback_V1_1 == NULL)
+        if (callback_V1_1 == NULL) ALOGI("Registering 1.0 callback");
-          ALOGI("Registering 1.0 callback");
 
     pthread_mutex_lock(&mLock);
     /*
@@ -784,7 +762,7 @@ void checkUsbDeviceAutoSuspend(const std::string& devicePath) {
 }
 
 }  // namespace implementation
-}  // namespace V1_0
+}  // namespace V1_1
 }  // namespace usb
 }  // namespace hardware
 }  // namespace android

universal7885-common/usb/typec/Usb.h

@@ -2,8 +2,8 @@
 #define ANDROID_HARDWARE_USB_V1_1_USB_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/types.h>
 #include <hidl/Status.h>
 #include <utils/Log.h>
 
@@ -20,10 +20,17 @@ namespace usb {
 namespace V1_1 {
 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::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_1::IUsb;
 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::hidl::base::V1_0::DebugInfo;
 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 {
     Usb();
@@ -46,7 +46,6 @@ struct Usb : public IUsb {
     Return<void> setCallback(const sp<V1_0::IUsbCallback>& callback) override;
     Return<void> queryPortStatus() override;
 
-
     sp<V1_0::IUsbCallback> mCallback_1_0;
     // Protects mCallback variable
     pthread_mutex_t mLock;
@@ -64,7 +63,7 @@ struct Usb : public IUsb {
 };
 
 }  // namespace implementation
-}  // namespace V1_0
+}  // namespace V1_1
 }  // namespace usb
 }  // namespace hardware
 }  // namespace android

universal7885-common/usb/typec/service.cpp

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