1 /*
2  * Copyright (c) 2021-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 DISPLAYMGR_DISPLAY_MGR_SERVICE_H
17 #define DISPLAYMGR_DISPLAY_MGR_SERVICE_H
18 
19 #include <atomic>
20 #include <cstdint>
21 #include <string>
22 #include <vector>
23 #include <map>
24 #include <memory>
25 #include <functional>
26 #include <sys/types.h>
27 #include "delayed_sp_singleton.h"
28 #include "refbase.h"
29 #include "event_runner.h"
30 #include "iremote_object.h"
31 #ifdef ENABLE_SENSOR_PART
32 #include "sensor_agent_type.h"
33 #endif
34 #include "idisplay_power_callback.h"
35 #include "display_power_info.h"
36 #include "display_common.h"
37 #include "display_power_mgr_stub.h"
38 #include "screen_controller.h"
39 #include "brightness_manager.h"
40 #include "ffrt_utils.h"
41 
42 namespace OHOS {
43 namespace DisplayPowerMgr {
44 class DisplayPowerMgrService : public DisplayPowerMgrStub {
45 public:
46     virtual ~DisplayPowerMgrService() = default;
47     virtual bool SetDisplayState(uint32_t id, DisplayState state, uint32_t reason) override;
48     virtual DisplayState GetDisplayState(uint32_t id) override;
49     virtual std::vector<uint32_t> GetDisplayIds() override;
50     virtual uint32_t GetMainDisplayId() override;
51     virtual bool SetBrightness(uint32_t value, uint32_t displayId, bool continuous = false) override;
52     virtual bool SetMaxBrightness(double value, uint32_t mode) override;
53     virtual bool SetMaxBrightnessNit(uint32_t maxNit, uint32_t mode) override;
54     virtual bool DiscountBrightness(double discount, uint32_t displayId) override;
55     virtual bool OverrideBrightness(uint32_t value, uint32_t displayId, uint32_t duration = 500) override;
56     virtual bool OverrideDisplayOffDelay(uint32_t delayMs) override;
57     virtual bool RestoreBrightness(uint32_t displayId, uint32_t duration = 500) override;
58     virtual uint32_t GetBrightness(uint32_t displayId) override;
59     virtual uint32_t GetDefaultBrightness() override;
60     virtual uint32_t GetMaxBrightness() override;
61     virtual uint32_t GetMinBrightness() override;
62     virtual bool AdjustBrightness(uint32_t id, int32_t value, uint32_t duration) override;
63     virtual bool AutoAdjustBrightness(bool enable) override;
64     virtual bool IsAutoAdjustBrightness() override;
65     virtual bool RegisterCallback(sptr<IDisplayPowerCallback> callback) override;
66     virtual bool BoostBrightness(int32_t timeoutMs, uint32_t displayId) override;
67     virtual bool CancelBoostBrightness(uint32_t displayId) override;
68     virtual uint32_t GetDeviceBrightness(uint32_t displayId) override;
69     virtual bool SetCoordinated(bool coordinated, uint32_t displayId) override;
70     virtual uint32_t SetLightBrightnessThreshold(
71         std::vector<int32_t> threshold, sptr<IDisplayBrightnessCallback> callback) override;
72     virtual int32_t Dump(int32_t fd, const std::vector<std::u16string>& args) override;
73     virtual DisplayErrors GetError() override;
74     void NotifyStateChangeCallback(uint32_t displayId, DisplayState state, uint32_t reason);
75     void Init();
76     void Deinit();
77     void Reset();
78     void ClearOffset();
79     void SetScreenOnBrightness();
80     static uint32_t GetSafeBrightness(uint32_t value);
81     static double GetSafeDiscount(double discount, uint32_t brightness);
82 
83 private:
84     class CallbackDeathRecipient : public IRemoteObject::DeathRecipient {
85     public:
86         CallbackDeathRecipient() = default;
87         virtual ~CallbackDeathRecipient() = default;
88         virtual void OnRemoteDied(const wptr<IRemoteObject>& remote);
89     private:
90         std::mutex callbackMutex_;
91     };
92 
93 #ifdef ENABLE_SENSOR_PART
94     static void AmbientLightCallback(SensorEvent* event);
95     void InitSensors();
96     void ActivateAmbientSensor();
97     void DeactivateAmbientSensor();
98     bool ambientSensorEnabled_ {false};
99     SensorUser sensorUser_ {};
100 #endif
101     bool supportLightSensor_ {false};
102 
103     static const uint32_t AUTO_ADJUST_BRIGHTNESS_STRIDE = 1;
104     static const uint32_t SAMPLING_RATE = 100000000;
105     static const int32_t BRIGHTNESS_CHANGE_MIN = 2;
106     static const int32_t LUX_TO_NIT_SQRT_RADIO = 5;
107     static const time_t LUX_STABLE_TIME = 1;
108     static constexpr float LUX_CHANGE_RATE_THRESHOLD = 2;
109     static constexpr float LUX_CHANGE_STABLE_MIN = 10.0;
110     static const int32_t NIT_MIN = 2;
111     static const int32_t NIT_MAX = 450;
112     static const uint32_t BRIGHTNESS_OFF = 0;
113     static const uint32_t BRIGHTNESS_MIN;
114     static const uint32_t BRIGHTNESS_DEFAULT;
115     static const uint32_t BRIGHTNESS_MAX;
116     static const uint32_t DELAY_TIME_UNSET = 0;
117     static constexpr const double DISCOUNT_MIN = 0.01;
118     static constexpr const double DISCOUNT_MAX = 1.00;
119 
120     friend DelayedSpSingleton<DisplayPowerMgrService>;
121 
122     DisplayPowerMgrService();
123     bool IsChangedLux(float scalar);
124     bool CalculateBrightness(float scalar, int32_t& brightness, int32_t& change);
125     int32_t GetBrightnessFromLightScalar(float scalar);
126     void DumpDisplayInfo(std::string& result);
127     static void RegisterBootCompletedCallback();
128     static void SetBootCompletedBrightness();
129     static void SetBootCompletedAutoBrightness();
130     static void RegisterSettingObservers();
131     static void UnregisterSettingObservers();
132     static void RegisterSettingAutoBrightnessObserver();
133     static void UnregisterSettingAutoBrightnessObserver();
134     static void AutoBrightnessSettingUpdateFunc(const std::string& key);
135     static void SetSettingAutoBrightness(bool enable);
136     static bool GetSettingAutoBrightness(const std::string& key = SETTING_AUTO_ADJUST_BRIGHTNESS_KEY);
137     void ScreenOffDelay(uint32_t id, DisplayState state, uint32_t reason);
138 
139     static constexpr const char* SETTING_AUTO_ADJUST_BRIGHTNESS_KEY {"settings.display.auto_screen_brightness"};
140     std::map<uint64_t, std::shared_ptr<ScreenController>> controllerMap_;
141     bool autoBrightness_ {false};
142     sptr<IDisplayPowerCallback> callback_;
143     sptr<CallbackDeathRecipient> cbDeathRecipient_;
144 
145     DisplayErrors lastError_ {DisplayErrors::ERR_OK};
146     time_t lastLuxTime_ {0};
147     float lastLux_ {0};
148     bool luxChanged_ {false};
149     std::mutex mutex_;
150     static std::atomic_bool isBootCompleted_;
151     uint32_t displayOffDelayMs_ {0};
152     bool isDisplayDelayOff_ = false;
153     bool setDisplayStateRet_ = true;
154     uint32_t displayId_ {0};
155     DisplayState displayState_ {DisplayState::DISPLAY_UNKNOWN};
156     DisplayState tempState_ {DisplayState::DISPLAY_UNKNOWN};
157     uint32_t displayReason_ {0};
158     std::shared_ptr<PowerMgr::FFRTQueue> queue_;
159     bool isInTestMode_ {false};
160 };
161 } // namespace DisplayPowerMgr
162 } // namespace OHOS
163 #endif // DISPLAYMGR_DISPLAY_MGR_SERVICE_H
164