1 /* 2 * Copyright (c) 2023-2025 Huawei Device Co., Ltd. 3 * Licensed under the Apache License, Version 2.0 (the "License"); 4 * you may not use this file except in compliance with the License. 5 * You may obtain a copy of the License at 6 * 7 * http://www.apache.org/licenses/LICENSE-2.0 8 * 9 * Unless required by applicable law or agreed to in writing, software 10 * distributed under the License is distributed on an "AS IS" BASIS, 11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 * See the License for the specific language governing permissions and 13 * limitations under the License. 14 */ 15 16 #ifndef BRIGHTNESS_CONTROLLER_H 17 #define BRIGHTNESS_CONTROLLER_H 18 19 #include <atomic> 20 #include <cstdint> 21 #include <functional> 22 #include <map> 23 #include <memory> 24 #include <mutex> 25 #include <string> 26 #include <vector> 27 28 #include "brightness_action.h" 29 #include "brightness_dimming.h" 30 #include "brightness_base.h" 31 #include "brightness_param_helper.h" 32 #include "calculation_manager.h" 33 #include "display_common.h" 34 #include "display_power_info.h" 35 #include "display_manager_lite.h" 36 #include "dm_common.h" 37 #include "iremote_object.h" 38 #include "idisplay_brightness_callback.h" 39 #include "light_lux_manager.h" 40 #include "refbase.h" 41 #include "brightness_ffrt.h" 42 #ifdef ENABLE_SENSOR_PART 43 #include "sensor_agent_type.h" 44 #endif 45 46 #include <sys/types.h> 47 48 namespace OHOS { 49 namespace DisplayPowerMgr { 50 class BrightnessService { 51 public: 52 class DimmingCallbackImpl : public BrightnessDimmingCallback { 53 public: 54 DimmingCallbackImpl(const std::shared_ptr<BrightnessAction>& action, 55 std::function<void(uint32_t)> callback); 56 ~DimmingCallbackImpl() override = default; 57 DimmingCallbackImpl(const DimmingCallbackImpl&) = delete; 58 DimmingCallbackImpl& operator=(const DimmingCallbackImpl&) = delete; 59 DimmingCallbackImpl(DimmingCallbackImpl&&) = delete; 60 DimmingCallbackImpl& operator=(DimmingCallbackImpl&&) = delete; 61 62 void OnStart() override; 63 void OnChanged(uint32_t currentValue) override; 64 void OnEnd() override; 65 void DiscountBrightness(double discount) override; 66 67 private: 68 const std::shared_ptr<BrightnessAction> mAction{}; 69 std::function<void(uint32_t)> mCallback{}; 70 double mDiscount{1.0}; 71 }; 72 73 class FoldStatusLisener : public Rosen::DisplayManagerLite::IFoldStatusListener { 74 public: 75 FoldStatusLisener() = default; 76 virtual ~FoldStatusLisener() = default; 77 78 FoldStatusLisener(const FoldStatusLisener&) = delete; 79 FoldStatusLisener& operator=(const FoldStatusLisener&) = delete; 80 FoldStatusLisener(FoldStatusLisener&&) = delete; 81 FoldStatusLisener& operator=(FoldStatusLisener&&) = delete; 82 83 /** 84 * @param FoldStatus uint32_t; UNKNOWN = 0, EXPAND = 1, FOLDED = 2, HALF_FOLD = 3; 85 */ 86 void OnFoldStatusChanged(Rosen::FoldStatus foldStatus) override; 87 88 private: 89 Rosen::FoldStatus mLastFoldStatus = Rosen::FoldStatus::UNKNOWN; 90 }; 91 92 static constexpr const char* SETTING_AUTO_ADJUST_BRIGHTNESS_KEY {"settings.display.auto_screen_brightness"}; 93 static const int LUX_LEVEL_LENGTH = 23; 94 95 BrightnessService(const BrightnessService&) = delete; 96 BrightnessService& operator=(const BrightnessService&) = delete; 97 BrightnessService(BrightnessService&&) = delete; 98 BrightnessService& operator=(BrightnessService&&) = delete; 99 100 static BrightnessService& Get(); 101 static uint32_t GetMappingBrightnessLevel(uint32_t level); 102 static uint32_t GetOrigBrightnessLevel(uint32_t level); 103 static void SetSettingAutoBrightness(bool enable); 104 static bool GetSettingAutoBrightness(const std::string& key = SETTING_AUTO_ADJUST_BRIGHTNESS_KEY); 105 106 void Init(uint32_t defaultMax, uint32_t defaultMin); 107 void DeInit(); 108 void SetDisplayState(uint32_t id, DisplayState state); 109 DisplayState GetDisplayState(); 110 bool IsScreenOnState(DisplayState state); 111 bool IsSupportLightSensor(void); 112 bool IsAutoAdjustBrightness(void); 113 bool AutoAdjustBrightness(bool enable); 114 bool StateChangedSetAutoBrightness(bool enable); 115 void ProcessLightLux(float lux); 116 void RegisterSettingBrightnessObserver(); 117 void UnregisterSettingBrightnessObserver(); 118 uint32_t GetBrightness(); 119 uint32_t GetDeviceBrightness(); 120 uint32_t GetCachedSettingBrightness(); 121 uint32_t GetScreenOnBrightness(bool isUpdateTarget); 122 uint32_t GetBrightnessLevel(float lux); 123 uint32_t GetBrightnessHighLevel(uint32_t level); 124 uint32_t GetMappingBrightnessNit(uint32_t level); 125 uint32_t GetBrightnessLevelFromNit(uint32_t nit); 126 uint32_t GetMappingHighBrightnessLevel(uint32_t level); 127 bool SetBrightness(uint32_t value, uint32_t gradualDuration = 0, bool continuous = false); 128 void SetScreenOnBrightness(); 129 bool OverrideBrightness(uint32_t value, uint32_t gradualDuration = 0); 130 bool RestoreBrightness(uint32_t gradualDuration = 0); 131 bool IsBrightnessOverridden(); 132 bool BoostBrightness(uint32_t timeoutMs, uint32_t gradualDuration = 0); 133 bool CancelBoostBrightness(uint32_t gradualDuration = 0); 134 bool IsBrightnessBoosted(); 135 bool DiscountBrightness(double discount, uint32_t gradualDuration = 0); 136 double GetDiscount() const; 137 uint32_t GetDimmingUpdateTime() const; 138 void ClearOffset(); 139 void UpdateBrightnessSceneMode(BrightnessSceneMode mode); 140 uint32_t GetDisplayId(); 141 void SetDisplayId(uint32_t displayId); 142 uint32_t SetLightBrightnessThreshold(std::vector<int32_t> threshold, sptr<IDisplayBrightnessCallback> callback); 143 uint32_t GetCurrentDisplayId(uint32_t defaultId); 144 bool IsDimming(); 145 void ReportBrightnessBigData(uint32_t brightness); 146 bool IsSleepStatus(); 147 void SetSleepBrightness(); 148 int GetDisplayIdWithFoldstatus(Rosen::FoldStatus foldStatus); 149 int GetSensorIdWithFoldstatus(Rosen::FoldStatus foldStatus); 150 int GetDisplayIdWithDisplayMode(Rosen::FoldDisplayMode mode); 151 int GetSensorIdWithDisplayMode(Rosen::FoldDisplayMode mode); 152 uint32_t GetCurrentSensorId(); 153 void SetCurrentSensorId(uint32_t sensorId); 154 int NotifyScreenPowerStatus(uint32_t displayId, uint32_t status); 155 156 static uint32_t GetSafeBrightness(uint32_t value); 157 bool SetMaxBrightness(double value); 158 bool SetMaxBrightnessNit(uint32_t maxNit); 159 private: 160 static const constexpr char* SETTING_BRIGHTNESS_KEY{"settings.display.screen_brightness_status"}; 161 static const uint32_t SAMPLING_RATE = 100000000; 162 static constexpr uint32_t DEFAULT_DISPLAY_ID = 0; 163 static constexpr uint32_t SECOND_DISPLAY_ID = 1; 164 static constexpr uint32_t DEFAULT_BRIGHTNESS = 50; 165 static constexpr const double DISCOUNT_MIN = 0.01; 166 static constexpr const double DISCOUNT_MAX = 1.00; 167 static const uint32_t AMBIENT_LUX_LEVELS[LUX_LEVEL_LENGTH]; 168 static const uint32_t WAIT_FOR_FIRST_LUX_MAX_TIME = 200; 169 static const uint32_t WAIT_FOR_FIRST_LUX_STEP = 10; 170 static uint32_t brightnessValueMin; 171 static uint32_t brightnessValueMax; 172 173 BrightnessService(); 174 virtual ~BrightnessService() = default; 175 176 static uint32_t GetSettingBrightness(const std::string& key = SETTING_BRIGHTNESS_KEY); 177 bool mIsLuxActiveWithLog{true}; 178 #ifdef ENABLE_SENSOR_PART 179 static void AmbientLightCallback(SensorEvent* event); 180 void InitSensors(); 181 void ActivateAmbientSensor(); 182 void DeactivateAmbientSensor(); 183 void ActivateAmbientSensor1(); 184 void DeactivateAmbientSensor1(); 185 void ActivateValidAmbientSensor(); 186 void DeactivateValidAmbientSensor(); 187 void DeactivateAllAmbientSensor(); 188 bool mIsSupportLightSensor{false}; 189 SensorUser mSensorUser{}; 190 SensorUser mSensorUser1{}; 191 #endif 192 bool mIsLightSensorEnabled{false}; 193 bool mIsLightSensor1Enabled{false}; 194 195 void UpdateCurrentBrightnessLevel(float lux, bool isFastDuration); 196 void SetBrightnessLevel(uint32_t value, uint32_t duration); 197 bool IsScreenOn(); 198 bool CanSetBrightness(); 199 bool CanDiscountBrightness(); 200 bool CanOverrideBrightness(); 201 bool CanBoostBrightness(); 202 bool UpdateBrightness(uint32_t value, uint32_t gradualDuration = 0, bool updateSetting = false); 203 void SetSettingBrightness(uint32_t value); 204 void UpdateBrightnessSettingFunc(const std::string& key); 205 void RegisterFoldStatusListener(); 206 void UnRegisterFoldStatusListener(); 207 std::string GetReason(); 208 bool GetIsSupportLightSensor(); 209 bool IsCurrentSensorEnable(); 210 211 bool mIsFoldDevice{false}; 212 bool mIsAutoBrightnessEnabled{false}; 213 DisplayState mState{DisplayState::DISPLAY_UNKNOWN}; 214 uint32_t mBrightnessLevel{0}; 215 std::atomic<uint32_t> mBrightnessTarget{0}; 216 uint32_t mDisplayId{0}; 217 uint32_t mCurrentSensorId{5}; 218 int mLuxLevel{-1}; 219 double mDiscount{1.0f}; 220 std::atomic<bool> mIsBrightnessOverridden{false}; 221 std::atomic<bool> mIsBrightnessBoosted{false}; 222 uint32_t mCachedSettingBrightness{DEFAULT_BRIGHTNESS}; 223 uint32_t mOverriddenBrightness{DEFAULT_BRIGHTNESS}; 224 uint32_t mBeforeOverriddenBrightness{DEFAULT_BRIGHTNESS}; 225 std::shared_ptr<BrightnessAction> mAction{nullptr}; 226 std::shared_ptr<BrightnessDimmingCallback> mDimmingCallback{nullptr}; 227 std::shared_ptr<BrightnessDimming> mDimming; 228 LightLuxManager mLightLuxManager{}; 229 BrightnessCalculationManager mBrightnessCalculationManager{}; 230 sptr<Rosen::DisplayManagerLite::IFoldStatusListener> mFoldStatusistener; 231 std::shared_ptr<PowerMgr::FFRTQueue> queue_; 232 bool mIsUserMode{false}; 233 std::atomic<bool> mIsSleepStatus{false}; 234 std::atomic<bool> mIsDisplayOnWhenFirstLuxReport{false}; 235 std::atomic<bool> mWaitForFirstLux{false}; 236 std::atomic<uint32_t> mCurrentBrightness{DEFAULT_BRIGHTNESS}; 237 std::once_flag mInitCallFlag; 238 std::mutex mBoostHandleLock{}; 239 std::mutex mFirstLuxHandleLock{}; 240 }; 241 } // namespace DisplayPowerMgr 242 } // namespace OHOS 243 #endif // BRIGHTNESS_CONTROLLER_H