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 "iremote_object.h"
38#include "idisplay_brightness_callback.h"
39#include "light_lux_manager.h"
40#include "refbase.h"
41#include "ffrt_utils.h"
42#ifdef ENABLE_SENSOR_PART
43#include "sensor_agent_type.h"
44#endif
45
46#include <sys/types.h>
47
48namespace OHOS {
49namespace DisplayPowerMgr {
50class BrightnessService {
51public:
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 AutoAdjustBrightness(bool enable);
112    bool StateChangedSetAutoBrightness(bool enable);
113    bool IsAutoAdjustBrightness();
114    void ProcessLightLux(float lux);
115    void RegisterSettingBrightnessObserver();
116    void UnregisterSettingBrightnessObserver();
117    uint32_t GetBrightness();
118    uint32_t GetDeviceBrightness();
119    uint32_t GetCachedSettingBrightness();
120    uint32_t GetScreenOnBrightness(bool isUpdateTarget);
121    uint32_t GetBrightnessLevel(float lux);
122    uint32_t GetBrightnessHighLevel(uint32_t level);
123    uint32_t GetMappingBrightnessNit(uint32_t level);
124    uint32_t GetBrightnessLevelFromNit(uint32_t nit);
125    uint32_t GetMappingHighBrightnessLevel(uint32_t level);
126    bool SetBrightness(uint32_t value, uint32_t gradualDuration = 0, bool continuous = false);
127    void SetScreenOnBrightness();
128    bool OverrideBrightness(uint32_t value, uint32_t gradualDuration = 0);
129    bool RestoreBrightness(uint32_t gradualDuration = 0);
130    bool IsBrightnessOverridden();
131    bool BoostBrightness(uint32_t timeoutMs, uint32_t gradualDuration = 0);
132    bool CancelBoostBrightness(uint32_t gradualDuration = 0);
133    bool IsBrightnessBoosted();
134    bool DiscountBrightness(double discount, uint32_t gradualDuration = 0);
135    double GetDiscount() const;
136    uint32_t GetDimmingUpdateTime() const;
137    void ClearOffset();
138    void UpdateBrightnessSceneMode(BrightnessSceneMode mode);
139    uint32_t GetDisplayId();
140    void SetDisplayId(uint32_t displayId);
141    uint32_t SetLightBrightnessThreshold(std::vector<int32_t> threshold, sptr<IDisplayBrightnessCallback> callback);
142    uint32_t GetCurrentDisplayId(uint32_t defaultId);
143    bool IsDimming();
144    void ReportBrightnessBigData(uint32_t brightness);
145    bool IsSleepStatus();
146    void SetSleepBrightness();
147    int GetDisplayIdWithFoldstatus(Rosen::FoldStatus foldStatus);
148    int GetSensorIdWithFoldstatus(Rosen::FoldStatus foldStatus);
149    int GetDisplayIdWithDisplayMode(Rosen::FoldDisplayMode mode);
150    int GetSensorIdWithDisplayMode(Rosen::FoldDisplayMode mode);
151    uint32_t GetCurrentSensorId();
152    void SetCurrentSensorId(uint32_t sensorId);
153
154    static uint32_t GetSafeBrightness(uint32_t value);
155    bool SetMaxBrightness(double value);
156    bool SetMaxBrightnessNit(uint32_t maxNit);
157private:
158    static const constexpr char* SETTING_BRIGHTNESS_KEY{"settings.display.screen_brightness_status"};
159    static const uint32_t SAMPLING_RATE = 100000000;
160    static constexpr uint32_t DEFAULT_DISPLAY_ID = 0;
161    static constexpr uint32_t SECOND_DISPLAY_ID = 1;
162    static constexpr uint32_t DEFAULT_BRIGHTNESS = 50;
163    static constexpr const double DISCOUNT_MIN = 0.01;
164    static constexpr const double DISCOUNT_MAX = 1.00;
165    static const uint32_t AMBIENT_LUX_LEVELS[LUX_LEVEL_LENGTH];
166    static const uint32_t WAIT_FOR_FIRST_LUX_MAX_TIME = 200;
167    static const uint32_t WAIT_FOR_FIRST_LUX_STEP = 10;
168    static uint32_t brightnessValueMin;
169    static uint32_t brightnessValueMax;
170
171    BrightnessService();
172    virtual ~BrightnessService() = default;
173
174    static uint32_t GetSettingBrightness(const std::string& key = SETTING_BRIGHTNESS_KEY);
175    bool mIsLuxActiveWithLog{true};
176#ifdef ENABLE_SENSOR_PART
177    static void AmbientLightCallback(SensorEvent* event);
178    void InitSensors();
179    void ActivateAmbientSensor();
180    void DeactivateAmbientSensor();
181    void ActivateAmbientSensor1();
182    void DeactivateAmbientSensor1();
183    void ActivateValidAmbientSensor();
184    void DeactivateValidAmbientSensor();
185    void DeactivateAllAmbientSensor();
186    bool mIsSupportLightSensor{false};
187    SensorUser mSensorUser{};
188    SensorUser mSensorUser1{};
189#endif
190    bool mIsLightSensorEnabled{false};
191    bool mIsLightSensor1Enabled{false};
192
193    void UpdateCurrentBrightnessLevel(float lux, bool isFastDuration);
194    void SetBrightnessLevel(uint32_t value, uint32_t duration);
195    bool IsScreenOn();
196    bool CanSetBrightness();
197    bool CanDiscountBrightness();
198    bool CanOverrideBrightness();
199    bool CanBoostBrightness();
200    bool UpdateBrightness(uint32_t value, uint32_t gradualDuration = 0, bool updateSetting = false);
201    void SetSettingBrightness(uint32_t value);
202    void UpdateBrightnessSettingFunc(const std::string& key);
203    void RegisterFoldStatusListener();
204    void UnRegisterFoldStatusListener();
205    std::string GetReason();
206    void NotifyLightChangeToAps(uint32_t type, float value);
207    bool GetIsSupportLightSensor();
208    bool IsCurrentSensorEnable();
209
210    bool mIsFoldDevice{false};
211    bool mIsAutoBrightnessEnabled{false};
212    DisplayState mState{DisplayState::DISPLAY_UNKNOWN};
213    uint32_t mBrightnessLevel{0};
214    std::atomic<uint32_t> mBrightnessTarget{0};
215    uint32_t mDisplayId{0};
216    uint32_t mCurrentSensorId{5};
217    int mLuxLevel{-1};
218    double mDiscount{1.0f};
219    std::atomic<bool> mIsBrightnessOverridden{false};
220    std::atomic<bool> mIsBrightnessBoosted{false};
221    uint32_t mCachedSettingBrightness{DEFAULT_BRIGHTNESS};
222    uint32_t mOverriddenBrightness{DEFAULT_BRIGHTNESS};
223    uint32_t mBeforeOverriddenBrightness{DEFAULT_BRIGHTNESS};
224    std::shared_ptr<BrightnessAction> mAction{nullptr};
225    std::shared_ptr<BrightnessDimmingCallback> mDimmingCallback{nullptr};
226    std::shared_ptr<BrightnessDimming> mDimming;
227    LightLuxManager mLightLuxManager{};
228    BrightnessCalculationManager mBrightnessCalculationManager{};
229    sptr<Rosen::DisplayManagerLite::IFoldStatusListener> mFoldStatusistener;
230    std::shared_ptr<PowerMgr::FFRTQueue> queue_;
231    bool mIsUserMode{false};
232    std::atomic<bool> mIsSleepStatus{false};
233    std::vector<int32_t> mLightBrightnessThreshold;
234    sptr<IDisplayBrightnessCallback> mApsListenLightChangeCallback = nullptr;
235    bool mIsBrightnessValidate = false;
236    bool mIsLightValidate = false;
237    time_t mLastCallApsTime {0};
238    std::atomic<bool> mIsDisplayOnWhenFirstLuxReport{false};
239    std::atomic<bool> mWaitForFirstLux{false};
240    std::atomic<uint32_t> mCurrentBrightness{DEFAULT_BRIGHTNESS};
241};
242} // namespace DisplayPowerMgr
243} // namespace OHOS
244#endif // BRIGHTNESS_CONTROLLER_H