1 /*
2  * Copyright (c) 2023-2023 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 "event_runner.h"
38 #include "iremote_object.h"
39 #include "idisplay_brightness_callback.h"
40 #include "light_lux_manager.h"
41 #include "refbase.h"
42 #include "ffrt_utils.h"
43 #ifdef ENABLE_SENSOR_PART
44 #include "sensor_agent_type.h"
45 #endif
46 
47 #include <sys/types.h>
48 
49 namespace OHOS {
50 namespace DisplayPowerMgr {
51 class BrightnessService {
52 public:
53     class DimmingCallbackImpl : public BrightnessDimmingCallback {
54     public:
55         DimmingCallbackImpl(const std::shared_ptr<BrightnessAction>& action,
56             std::function<void(uint32_t)> callback);
57         ~DimmingCallbackImpl() override = default;
58         DimmingCallbackImpl(const DimmingCallbackImpl&) = delete;
59         DimmingCallbackImpl& operator=(const DimmingCallbackImpl&) = delete;
60         DimmingCallbackImpl(DimmingCallbackImpl&&) = delete;
61         DimmingCallbackImpl& operator=(DimmingCallbackImpl&&) = delete;
62 
63         void OnStart() override;
64         void OnChanged(uint32_t currentValue) override;
65         void OnEnd() override;
66         void DiscountBrightness(double discount) override;
67 
68     private:
69         const std::shared_ptr<BrightnessAction> mAction{};
70         std::function<void(uint32_t)> mCallback{};
71         double mDiscount{1.0};
72     };
73 
74     class FoldStatusLisener : public Rosen::DisplayManagerLite::IFoldStatusListener {
75     public:
76         FoldStatusLisener() = default;
77         virtual ~FoldStatusLisener() = default;
78 
79         FoldStatusLisener(const FoldStatusLisener&) = delete;
80         FoldStatusLisener& operator=(const FoldStatusLisener&) = delete;
81         FoldStatusLisener(FoldStatusLisener&&) = delete;
82         FoldStatusLisener& operator=(FoldStatusLisener&&) = delete;
83 
84         /**
85         * @param FoldStatus uint32_t; UNKNOWN = 0, EXPAND = 1,  FOLDED = 2,  HALF_FOLD = 3;
86         */
87         void OnFoldStatusChanged(Rosen::FoldStatus foldStatus) override;
88 
89     private:
90         Rosen::FoldStatus mLastFoldStatus = Rosen::FoldStatus::UNKNOWN;
91     };
92 
93     static constexpr const char* SETTING_AUTO_ADJUST_BRIGHTNESS_KEY {"settings.display.auto_screen_brightness"};
94     static const int LUX_LEVEL_LENGTH = 23;
95 
96     BrightnessService(const BrightnessService&) = delete;
97     BrightnessService& operator=(const BrightnessService&) = delete;
98     BrightnessService(BrightnessService&&) = delete;
99     BrightnessService& operator=(BrightnessService&&) = delete;
100 
101     static BrightnessService& Get();
102     static uint32_t GetMappingBrightnessLevel(uint32_t level);
103     static uint32_t GetOrigBrightnessLevel(uint32_t level);
104     static void SetSettingAutoBrightness(bool enable);
105     static bool GetSettingAutoBrightness(const std::string& key = SETTING_AUTO_ADJUST_BRIGHTNESS_KEY);
106 
107     void Init(uint32_t defaultMax, uint32_t defaultMin);
108     void DeInit();
109     void SetDisplayState(uint32_t id, DisplayState state);
110     DisplayState GetDisplayState();
111     bool IsScreenOnState(DisplayState state);
112     bool AutoAdjustBrightness(bool enable);
113     bool StateChangedSetAutoBrightness(bool enable);
114     bool IsAutoAdjustBrightness();
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 
155     static uint32_t GetSafeBrightness(uint32_t value);
156     bool SetMaxBrightness(double value);
157     bool SetMaxBrightnessNit(uint32_t maxNit);
158 private:
159     static const constexpr char* SETTING_BRIGHTNESS_KEY{"settings.display.screen_brightness_status"};
160     static const uint32_t SAMPLING_RATE = 100000000;
161     static constexpr uint32_t DEFAULT_DISPLAY_ID = 0;
162     static constexpr uint32_t SECOND_DISPLAY_ID = 1;
163     static constexpr uint32_t DEFAULT_BRIGHTNESS = 50;
164     static constexpr const double DISCOUNT_MIN = 0.01;
165     static constexpr const double DISCOUNT_MAX = 1.00;
166     static const uint32_t AMBIENT_LUX_LEVELS[LUX_LEVEL_LENGTH];
167     static const uint32_t WAIT_FOR_FIRST_LUX_MAX_TIME = 200;
168     static const uint32_t WAIT_FOR_FIRST_LUX_STEP = 10;
169     static uint32_t brightnessValueMin;
170     static uint32_t brightnessValueMax;
171 
172     BrightnessService();
173     virtual ~BrightnessService() = default;
174 
175     static uint32_t GetSettingBrightness(const std::string& key = SETTING_BRIGHTNESS_KEY);
176     bool mIsLuxActiveWithLog{true};
177 #ifdef ENABLE_SENSOR_PART
178     static void AmbientLightCallback(SensorEvent* event);
179     void InitSensors();
180     void ActivateAmbientSensor();
181     void DeactivateAmbientSensor();
182     void ActivateAmbientSensor1();
183     void DeactivateAmbientSensor1();
184     void ActivateValidAmbientSensor();
185     void DeactivateValidAmbientSensor();
186     void DeactivateAllAmbientSensor();
187     bool mIsSupportLightSensor{false};
188     SensorUser mSensorUser{};
189     SensorUser mSensorUser1{};
190 #endif
191     bool mIsLightSensorEnabled{false};
192     bool mIsLightSensor1Enabled{false};
193 
194     void UpdateCurrentBrightnessLevel(float lux, bool isFastDuration);
195     void SetBrightnessLevel(uint32_t value, uint32_t duration);
196     bool IsScreenOn();
197     bool CanSetBrightness();
198     bool CanDiscountBrightness();
199     bool CanOverrideBrightness();
200     bool CanBoostBrightness();
201     bool UpdateBrightness(uint32_t value, uint32_t gradualDuration = 0, bool updateSetting = false);
202     void SetSettingBrightness(uint32_t value);
203     void UpdateBrightnessSettingFunc(const std::string& key);
204     void RegisterFoldStatusListener();
205     void UnRegisterFoldStatusListener();
206     std::string GetReason();
207     void NotifyLightChangeToAps(uint32_t type, float value);
208     bool GetIsSupportLightSensor();
209     bool IsCurrentSensorEnable();
210 
211     bool mIsFoldDevice{false};
212     bool mIsAutoBrightnessEnabled{false};
213     DisplayState mState{DisplayState::DISPLAY_UNKNOWN};
214     uint32_t mStateChangeReason{0};
215     uint32_t mBrightnessLevel{0};
216     std::atomic<uint32_t> mBrightnessTarget{0};
217     uint32_t mDisplayId{0};
218     uint32_t mCurrentSensorId{5};
219     int mLuxLevel{-1};
220     double mDiscount{1.0f};
221     std::atomic<bool> mIsBrightnessOverridden{false};
222     std::atomic<bool> mIsBrightnessBoosted{false};
223     uint32_t mCachedSettingBrightness{DEFAULT_BRIGHTNESS};
224     uint32_t mOverriddenBrightness{DEFAULT_BRIGHTNESS};
225     uint32_t mBeforeOverriddenBrightness{DEFAULT_BRIGHTNESS};
226     std::shared_ptr<BrightnessAction> mAction{nullptr};
227     std::shared_ptr<BrightnessDimmingCallback> mDimmingCallback{nullptr};
228     std::shared_ptr<BrightnessDimming> mDimming;
229     LightLuxManager mLightLuxManager{};
230     BrightnessCalculationManager mBrightnessCalculationManager{};
231     sptr<Rosen::DisplayManagerLite::IFoldStatusListener> mFoldStatusistener;
232     std::shared_ptr<PowerMgr::FFRTQueue> queue_;
233     bool mIsUserMode{false};
234     std::atomic<bool> mIsSleepStatus{false};
235     std::vector<int32_t> mLightBrightnessThreshold;
236     sptr<IDisplayBrightnessCallback> mApsListenLightChangeCallback = nullptr;
237     bool mIsBrightnessValidate = false;
238     bool mIsLightValidate = false;
239     time_t mLastCallApsTime {0};
240     std::atomic<bool> mIsDisplayOnWhenFirstLuxReport{false};
241     std::atomic<bool> mWaitForFirstLux{false};
242     std::atomic<uint32_t> mCurrentBrightness{DEFAULT_BRIGHTNESS};
243 };
244 } // namespace DisplayPowerMgr
245 } // namespace OHOS
246 #endif // BRIGHTNESS_CONTROLLER_H