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 #include "brightness_service.h"
17 
18 #include <file_ex.h>
19 #include <hisysevent.h>
20 #include <ipc_skeleton.h>
21 #include <securec.h>
22 
23 #include "brightness_action.h"
24 #include "brightness_setting_helper.h"
25 #include "config_parser.h"
26 #include "delayed_sp_singleton.h"
27 #include "display_common.h"
28 #include "display_log.h"
29 #include "display_manager_lite.h"
30 #include "dm_common.h"
31 #include "errors.h"
32 #include "ffrt_utils.h"
33 #include "light_lux_manager.h"
34 #include "new"
35 #include "permission.h"
36 #include "refbase.h"
37 #include "screen_manager_lite.h"
38 #include "setting_provider.h"
39 #include "system_ability_definition.h"
40 
41 #ifdef ENABLE_SENSOR_PART
42 #include "sensor_agent.h"
43 #endif
44 
45 namespace OHOS {
46 namespace DisplayPowerMgr {
47 namespace {
48 constexpr uint32_t MAX_DEFAULT_BRGIHTNESS_LEVEL = 255;
49 constexpr uint32_t MIN_DEFAULT_BRGIHTNESS_LEVEL = 1;
50 constexpr uint32_t MAX_MAPPING_BRGIHTNESS_LEVEL = 223;
51 constexpr uint32_t MIN_MAPPING_BRGIHTNESS_LEVEL = 1;
52 constexpr uint32_t MAX_HBM_BRGIHTNESS_NIT = 1000;
53 constexpr uint32_t MAX_DEFAULT_BRGIHTNESS_NIT = 600;
54 constexpr uint32_t MIN_DEFAULT_BRGIHTNESS_NIT = 2;
55 constexpr uint32_t MAX_DEFAULT_HIGH_BRGIHTNESS_LEVEL = 10000;
56 constexpr uint32_t MIN_DEFAULT_HIGH_BRGIHTNESS_LEVEL = 156;
57 constexpr uint32_t DEFAULT_ANIMATING_DURATION = 500;
58 constexpr uint32_t DEFAULT_BRIGHTEN_DURATION = 2000;
59 constexpr uint32_t DEFAULT_DARKEN_DURATION = 5000;
60 constexpr uint32_t DEFAULT_MAX_BRIGHTNESS_DURATION = 3000;
61 constexpr uint32_t BRIGHTNESS_TYPE = 0;
62 constexpr uint32_t AMBIENT_LIGHT_TYPE = 1;
63 constexpr uint32_t APS_LISTEN_PARAMS_LENGHT = 3;
64 constexpr time_t CALL_APS_INTERVAL = 2;
65 
66 FFRTHandle g_cancelBoostTaskHandle{};
67 FFRTHandle g_waitForFirstLuxTaskHandle{};
68 }
69 
70 const uint32_t BrightnessService::AMBIENT_LUX_LEVELS[BrightnessService::LUX_LEVEL_LENGTH] = { 1, 3, 5, 10, 20, 50, 200,
71     500, 1000, 2000, 3000, 5000, 10000, 20000, 40000, 50000, 60000, 70000, 80000, 90000, 100000, INT_MAX };
72 
73 using namespace OHOS::PowerMgr;
74 
75 uint32_t BrightnessService::brightnessValueMax = MAX_DEFAULT_BRGIHTNESS_LEVEL;
76 uint32_t BrightnessService::brightnessValueMin = MIN_DEFAULT_BRGIHTNESS_LEVEL;
77 
BrightnessService()78 BrightnessService::BrightnessService()
79 {
80     DISPLAY_HILOGI(FEAT_BRIGHTNESS, "BrightnessService created for displayId=%{public}d", mDisplayId);
81     mAction = std::make_shared<BrightnessAction>(mDisplayId);
82     if (mAction == nullptr) {
83         DISPLAY_HILOGE(FEAT_BRIGHTNESS, "mAction is null");
84         return;
85     }
86     mState = mAction->GetDisplayState();
87     mDimmingCallback = std::make_shared<DimmingCallbackImpl>(mAction, [this](uint32_t brightness) {
88         SetSettingBrightness(brightness);
89     });
90     if (mDimmingCallback == nullptr) {
91         DISPLAY_HILOGE(FEAT_BRIGHTNESS, "mDimmingCallback is null");
92     }
93     std::string name = "BrightnessService" + std::to_string(mDisplayId);
94     mDimming = std::make_shared<BrightnessDimming>(name, mDimmingCallback);
95 }
96 
Get()97 BrightnessService& BrightnessService::Get()
98 {
99     static BrightnessService brightnessManager;
100     return brightnessManager;
101 }
102 
Init(uint32_t defaultMax,uint32_t defaultMin)103 void BrightnessService::Init(uint32_t defaultMax, uint32_t defaultMin)
104 {
105     queue_ = std::make_shared<FFRTQueue> ("brightness_manager");
106     if (queue_ == nullptr) {
107         return;
108     }
109     if (!mDimming->Init()) {
110         return;
111     }
112 #ifdef ENABLE_SENSOR_PART
113     InitSensors();
114     mIsFoldDevice = Rosen::DisplayManagerLite::GetInstance().IsFoldable();
115     DISPLAY_HILOGI(FEAT_BRIGHTNESS, "Init mIsFoldDevice=%{public}d", mIsFoldDevice);
116 #endif
117     ConfigParse::Get().Initialize();
118     mLightLuxManager.InitParameters();
119     mBrightnessCalculationManager.InitParameters();
120 
121     bool isFoldable = Rosen::DisplayManagerLite::GetInstance().IsFoldable();
122     brightnessValueMax = defaultMax;
123     brightnessValueMin = defaultMin;
124     DISPLAY_HILOGI(FEAT_BRIGHTNESS, "BrightnessService::init isFoldable=%{public}d, max=%{public}u, min=%{public}u",
125         isFoldable, brightnessValueMax, brightnessValueMin);
126     if (isFoldable) {
127         RegisterFoldStatusListener();
128     }
129 }
130 
DeInit()131 void BrightnessService::DeInit()
132 {
133     bool isFoldable = Rosen::DisplayManagerLite::GetInstance().IsFoldable();
134     DISPLAY_HILOGI(FEAT_BRIGHTNESS, "BrightnessService::init isFoldable=%{public}d", isFoldable);
135     if (isFoldable) {
136         UnRegisterFoldStatusListener();
137     }
138     if (queue_) {
139         queue_.reset();
140         g_cancelBoostTaskHandle = nullptr;
141         g_waitForFirstLuxTaskHandle = nullptr;
142         DISPLAY_HILOGI(FEAT_BRIGHTNESS, "destruct brightness ffrt queue");
143     }
144 
145     mDimming->Reset();
146 }
147 
OnFoldStatusChanged(Rosen::FoldStatus foldStatus)148 void BrightnessService::FoldStatusLisener::OnFoldStatusChanged(Rosen::FoldStatus foldStatus)
149 {
150     DISPLAY_HILOGI(FEAT_BRIGHTNESS, "OnFoldStatusChanged currenFoldStatus=%{public}d", foldStatus);
151     if (mLastFoldStatus == foldStatus) {
152         DISPLAY_HILOGE(FEAT_BRIGHTNESS, "no need set foldStatus");
153         return;
154     }
155     bool isSensorEnable = BrightnessService::Get().GetIsSupportLightSensor();
156     bool isAutoEnable = BrightnessService::Get().GetSettingAutoBrightness();
157     bool isScreenOn = BrightnessService::Get().IsScreenOn();
158     int displayId = BrightnessService::Get().GetDisplayIdWithFoldstatus(foldStatus);
159     DISPLAY_HILOGI(FEAT_BRIGHTNESS, "OnFoldStatusChanged isSensorEnable=%{public}d, isAutoEnable=%{public}d"\
160         ", isScreenOn=%{public}d, displayid=%{public}d", isSensorEnable, isAutoEnable, isScreenOn, displayId);
161     uint32_t currentBrightness = BrightnessService::Get().GetBrightness();
162     BrightnessService::Get().SetDisplayId(displayId);
163 
164     if (Rosen::FoldStatus::FOLDED == foldStatus || Rosen::FoldStatus::EXPAND == foldStatus) {
165         int sensorId = BrightnessService::Get().GetSensorIdWithFoldstatus(foldStatus);
166         BrightnessService::Get().SetCurrentSensorId(static_cast<uint32_t>(sensorId));
167         DISPLAY_HILOGI(FEAT_BRIGHTNESS, "OnFoldStatusChanged sensorid=%{public}d", sensorId);
168         if (isSensorEnable && isAutoEnable && isScreenOn) {
169             if (sensorId == SENSOR_TYPE_ID_AMBIENT_LIGHT) {
170                 BrightnessService::Get().ActivateAmbientSensor();
171             } else if (sensorId == SENSOR_TYPE_ID_AMBIENT_LIGHT1) {
172                 BrightnessService::Get().ActivateAmbientSensor1();
173             }
174         }
175     } else if (Rosen::FoldStatus::HALF_FOLD == foldStatus) {
176         uint32_t currentEffectSensorId = BrightnessService::Get().GetCurrentSensorId();
177         if (isSensorEnable && isAutoEnable && isScreenOn) {
178             if (currentEffectSensorId == SENSOR_TYPE_ID_AMBIENT_LIGHT) {
179                 BrightnessService::Get().DeactivateAmbientSensor();
180             } else if (currentEffectSensorId == SENSOR_TYPE_ID_AMBIENT_LIGHT1) {
181                 BrightnessService::Get().DeactivateAmbientSensor1();
182             }
183         }
184     }
185 
186     if (BrightnessService::Get().CanSetBrightness()) {
187         BrightnessService::Get().UpdateBrightness(currentBrightness, 0, true);
188     }
189     mLastFoldStatus = foldStatus;
190 }
191 
RegisterFoldStatusListener()192 void BrightnessService::RegisterFoldStatusListener()
193 {
194     mFoldStatusistener = new FoldStatusLisener();
195     if (mFoldStatusistener == nullptr) {
196         DISPLAY_HILOGI(FEAT_BRIGHTNESS, "BrightnessService::RegisterDisplayModeListener newListener failed");
197         return;
198     }
199     auto ret = Rosen::DisplayManagerLite::GetInstance().RegisterFoldStatusListener(mFoldStatusistener);
200     if (ret != Rosen::DMError::DM_OK) {
201         DISPLAY_HILOGI(FEAT_BRIGHTNESS, "Rosen::DisplayManagerLite::RegisterDisplayModeListener failed");
202         mFoldStatusistener = nullptr;
203     } else {
204         DISPLAY_HILOGI(FEAT_BRIGHTNESS, "BrightnessService::RegisterDisplayModeListener success");
205     }
206 }
207 
UnRegisterFoldStatusListener()208 void BrightnessService::UnRegisterFoldStatusListener()
209 {
210     if (mFoldStatusistener == nullptr) {
211         DISPLAY_HILOGI(FEAT_BRIGHTNESS, "BrightnessService::UnRegistermFoldStatusistener listener is null");
212         return;
213     }
214     auto ret = Rosen::DisplayManagerLite::GetInstance().UnregisterFoldStatusListener(mFoldStatusistener);
215     if (ret != Rosen::DMError::DM_OK) {
216         DISPLAY_HILOGI(FEAT_BRIGHTNESS, "BrightnessService::UnRegisterDisplayModeListener  failed");
217     }
218 }
219 
GetDisplayId()220 uint32_t BrightnessService::GetDisplayId()
221 {
222     return mDisplayId;
223 }
224 
NotifyLightChangeToAps(uint32_t type,float value)225 void BrightnessService::NotifyLightChangeToAps(uint32_t type, float value)
226 {
227     // Check whether APS callback interface exists
228     if (!mApsListenLightChangeCallback) {
229         DISPLAY_HILOGD(FEAT_BRIGHTNESS, "BrightnessService::NotifyLightChangeToAps function is null");
230         return;
231     }
232 
233     // Check Whether APS is initialized
234     if (mLightBrightnessThreshold.size() != APS_LISTEN_PARAMS_LENGHT) {
235         DISPLAY_HILOGD(FEAT_BRIGHTNESS, "BrightnessService::NotifyLightChangeToAps not init yet");
236         return;
237     }
238 
239     // brightness
240     if (type == BRIGHTNESS_TYPE) {
241         int32_t nitValue = static_cast<int32_t>(GetMappingBrightnessNit(static_cast<uint32_t>(value)));
242         int32_t brightness = mLightBrightnessThreshold[0];
243         if (!mIsBrightnessValidate && nitValue >= brightness) {
244             mIsBrightnessValidate = true;
245             mApsListenLightChangeCallback->OnNotifyApsLightBrightnessChange(type, mIsBrightnessValidate);
246         } else if (mIsBrightnessValidate && nitValue < brightness) {
247             mIsBrightnessValidate = false;
248             mApsListenLightChangeCallback->OnNotifyApsLightBrightnessChange(type, mIsBrightnessValidate);
249         }
250         return;
251     }
252 
253     // amlient light
254     if (type == AMBIENT_LIGHT_TYPE) {
255         // Check the interval for invoking the APS interface
256         time_t currentTime = time(0);
257         if (currentTime - mLastCallApsTime < CALL_APS_INTERVAL) {
258             DISPLAY_HILOGD(
259                 FEAT_BRIGHTNESS, "BrightnessService::NotifyLightChangeToAps interface is invoked frequently");
260             return;
261         }
262         mLastCallApsTime = currentTime;
263 
264         int32_t light = mLightBrightnessThreshold[1];
265         int32_t range = mLightBrightnessThreshold[2];
266         if (!mIsLightValidate && value >= light) {
267             mIsLightValidate = true;
268             mApsListenLightChangeCallback->OnNotifyApsLightBrightnessChange(type, mIsLightValidate);
269         } else if (mIsLightValidate && value < (light - range)) {
270             mIsLightValidate = false;
271             mApsListenLightChangeCallback->OnNotifyApsLightBrightnessChange(type, mIsLightValidate);
272         }
273     }
274 }
275 
GetCurrentDisplayId(uint32_t defaultId)276 uint32_t BrightnessService::GetCurrentDisplayId(uint32_t defaultId)
277 {
278     uint32_t currentId = defaultId;
279     bool isFoldable = Rosen::DisplayManagerLite::GetInstance().IsFoldable();
280     if (!isFoldable) {
281         DISPLAY_HILOGI(FEAT_STATE, "GetCurrentDisplayId not fold phone return default id=%{public}d", defaultId);
282         return currentId;
283     }
284     std::string identity = IPCSkeleton::ResetCallingIdentity();
285     auto foldMode = Rosen::DisplayManagerLite::GetInstance().GetFoldDisplayMode();
286     currentId = static_cast<uint32_t>(GetDisplayIdWithDisplayMode(foldMode));
287     DISPLAY_HILOGI(FEAT_STATE, "GetCurrentDisplayId foldMode=%{public}u", foldMode);
288     IPCSkeleton::SetCallingIdentity(identity);
289     return static_cast<uint32_t>(currentId);
290 }
291 
SetDisplayId(uint32_t displayId)292 void BrightnessService::SetDisplayId(uint32_t displayId)
293 {
294     mDisplayId = displayId;
295     if (mAction == nullptr) {
296         DISPLAY_HILOGI(FEAT_BRIGHTNESS, "BrightnessService::SetDisplayId mAction == nullptr");
297         return;
298     }
299     mAction->SetDisplayId(displayId);
300 }
301 
GetCurrentSensorId()302 uint32_t BrightnessService::GetCurrentSensorId()
303 {
304     return mCurrentSensorId;
305 }
306 
SetCurrentSensorId(uint32_t sensorId)307 void BrightnessService::SetCurrentSensorId(uint32_t sensorId)
308 {
309     mCurrentSensorId = sensorId;
310 }
311 
DimmingCallbackImpl(const std::shared_ptr<BrightnessAction> & action,std::function<void (uint32_t)> callback)312 BrightnessService::DimmingCallbackImpl::DimmingCallbackImpl(
313     const std::shared_ptr<BrightnessAction>& action, std::function<void(uint32_t)> callback)
314     : mAction(action), mCallback(callback)
315 {
316 }
317 
OnStart()318 void BrightnessService::DimmingCallbackImpl::OnStart()
319 {
320     DISPLAY_HILOGD(FEAT_BRIGHTNESS, "BrightnessDimmingCallback onStart");
321 }
322 
OnChanged(uint32_t currentValue)323 void BrightnessService::DimmingCallbackImpl::OnChanged(uint32_t currentValue)
324 {
325     if (!BrightnessService::Get().IsDimming()) {
326         DISPLAY_HILOGI(FEAT_BRIGHTNESS, "OnChanged currentValue=%{public}d already stopDimming, return", currentValue);
327         return;
328     }
329     DISPLAY_HILOGI(FEAT_BRIGHTNESS, "OnChanged brightness,mapBrightness=%{public}d", currentValue);
330     bool isSuccess = mAction->SetBrightness(currentValue);
331     if (isSuccess) {
332         BrightnessService::Get().ReportBrightnessBigData(currentValue);
333     }
334     if (isSuccess && !BrightnessService::Get().IsSleepStatus()) {
335         if (!BrightnessService::Get().IsDimming()) {
336             DISPLAY_HILOGI(FEAT_BRIGHTNESS, "OnChanged already stopDimming , not update setting brightness");
337             return;
338         }
339         FFRTTask task = [this, currentValue] {
340             auto tmpVal = BrightnessService::Get().GetOrigBrightnessLevel(currentValue);
341             this->mCallback(tmpVal);
342         };
343         FFRTUtils::SubmitTask(task);
344         DISPLAY_HILOGI(FEAT_BRIGHTNESS, "Update OnChanged,Setting brightness=%{public}d", currentValue);
345     } else {
346         DISPLAY_HILOGI(FEAT_BRIGHTNESS, "Update OnChanged failed, brightness=%{public}d", currentValue);
347     }
348 }
349 
OnEnd()350 void BrightnessService::DimmingCallbackImpl::OnEnd()
351 {
352     DISPLAY_HILOGD(FEAT_BRIGHTNESS, "ScreenAnimatorCallback OnEnd");
353 }
354 
DiscountBrightness(double discount)355 void BrightnessService::DimmingCallbackImpl::DiscountBrightness(double discount)
356 {
357     mDiscount = discount;
358 }
359 
SetDisplayState(uint32_t id,DisplayState state)360 void BrightnessService::SetDisplayState(uint32_t id, DisplayState state)
361 {
362     mState = state;
363     bool isAutoMode = false;
364     bool isScreenOn = IsScreenOnState(state); // depend on state on
365     bool isSettingOn = false;
366     if (isScreenOn) {
367         isSettingOn = IsAutoAdjustBrightness();
368     }
369     isAutoMode = isScreenOn && isSettingOn;
370     DISPLAY_HILOGI(FEAT_BRIGHTNESS, "SetDisplayState id=%{public}d, isAutoMode=%{public}d, isScreenOn=%{public}d, "\
371         "isSettingOn=%{public}d, state=%{public}d", id, isAutoMode, isScreenOn, isSettingOn, state);
372 #ifdef ENABLE_SENSOR_PART
373     bool isModeChange = StateChangedSetAutoBrightness(isAutoMode);
374     DISPLAY_HILOGI(FEAT_BRIGHTNESS, "SetDisplayState id=%{public}d, isAutoMode=%{public}d, isModeChange=%{public}d",
375         id, isAutoMode, isModeChange);
376 #endif
377     if (state == DisplayState::DISPLAY_OFF) {
378         if (mIsSleepStatus) {
379             mIsBrightnessOverridden = false;
380             mIsSleepStatus = false;
381         }
382         mBrightnessTarget.store(0);
383         if (mDimming->IsDimming()) {
384             DISPLAY_HILOGI(FEAT_BRIGHTNESS, "DISPLAY_OFF StopDimming");
385             mDimming->StopDimming();
386         }
387     } else if (state == DisplayState::DISPLAY_DIM) {
388         SetSleepBrightness();
389     } else if (state == DisplayState::DISPLAY_ON) {
390         mIsDisplayOnWhenFirstLuxReport.store(true);
391         if (mIsSleepStatus) {
392             RestoreBrightness(0);
393             mIsSleepStatus = false;
394         }
395     }
396 }
397 
GetDisplayState()398 DisplayState BrightnessService::GetDisplayState()
399 {
400     return mState;
401 }
402 
IsScreenOnState(DisplayState state)403 bool BrightnessService::IsScreenOnState(DisplayState state)
404 {
405     return state == DisplayState::DISPLAY_ON || state == DisplayState::DISPLAY_DIM;
406 }
407 
GetSettingAutoBrightness(const std::string & key)408 bool BrightnessService::GetSettingAutoBrightness(const std::string& key)
409 {
410     return BrightnessSettingHelper::GetSettingAutoBrightness(key);
411 }
412 
SetSettingAutoBrightness(bool enable)413 void BrightnessService::SetSettingAutoBrightness(bool enable)
414 {
415     BrightnessSettingHelper::SetSettingAutoBrightness(enable);
416 }
417 
SetLightBrightnessThreshold(std::vector<int32_t> threshold,sptr<IDisplayBrightnessCallback> callback)418 uint32_t BrightnessService::SetLightBrightnessThreshold(
419     std::vector<int32_t> threshold, sptr<IDisplayBrightnessCallback> callback)
420 {
421     uint32_t result = 0;
422     if (threshold.size() != APS_LISTEN_PARAMS_LENGHT || !callback) {
423         DISPLAY_HILOGW(FEAT_BRIGHTNESS, "BrightnessService::SetLightBrightnessThreshold params verify faild.");
424         return result;
425     }
426     result = 1;
427     mLightBrightnessThreshold = threshold;
428     mApsListenLightChangeCallback = callback;
429     DISPLAY_HILOGI(FEAT_BRIGHTNESS, "BrightnessService::SetLightBrightnessThreshold set listener success");
430     return result;
431 }
432 
433 #ifdef ENABLE_SENSOR_PART
AutoAdjustBrightness(bool enable)434 bool BrightnessService::AutoAdjustBrightness(bool enable)
435 {
436     DISPLAY_HILOGI(FEAT_BRIGHTNESS, "SetAutoBrightnessEnable start, enable=%{public}d, isEnabled=%{public}d, "\
437         "isSupport=%{public}d", enable, mIsAutoBrightnessEnabled, mIsSupportLightSensor);
438     if (!mIsSupportLightSensor) {
439         DISPLAY_HILOGI(FEAT_BRIGHTNESS, "SetAutoBrightnessEnable not support");
440         SetSettingAutoBrightness(false);
441         return false;
442     }
443     if (enable) {
444         if (mIsAutoBrightnessEnabled) {
445             DISPLAY_HILOGI(FEAT_BRIGHTNESS, "SetAutoBrightnessEnable is already enabled");
446             return true;
447         }
448         mIsAutoBrightnessEnabled = true;
449         ActivateValidAmbientSensor();
450         DISPLAY_HILOGI(FEAT_BRIGHTNESS, "SetAutoBrightnessEnable enable");
451     } else {
452         if (!mIsAutoBrightnessEnabled) {
453             DISPLAY_HILOGI(FEAT_BRIGHTNESS, "SetAutoBrightnessEnable is already disabled");
454             return true;
455         }
456         DeactivateAllAmbientSensor();
457         mIsAutoBrightnessEnabled = false;
458         DISPLAY_HILOGI(FEAT_BRIGHTNESS, "SetAutoBrightnessEnable disable");
459     }
460     return true;
461 }
462 
StateChangedSetAutoBrightness(bool enable)463 bool BrightnessService::StateChangedSetAutoBrightness(bool enable)
464 {
465     DISPLAY_HILOGI(FEAT_BRIGHTNESS, "StateChangedSetAutoBrightness start, enable=%{public}d, "\
466         "isSensorEnabled=%{public}d, isSupport=%{public}d", enable, mIsLightSensorEnabled, mIsSupportLightSensor);
467     if (!mIsSupportLightSensor) {
468         DISPLAY_HILOGI(FEAT_BRIGHTNESS, "StateChangedSetAutoBrightness not support");
469         SetSettingAutoBrightness(false);
470         return false;
471     }
472     if (enable) {
473         if (IsCurrentSensorEnable()) {
474             DISPLAY_HILOGI(FEAT_BRIGHTNESS, "StateChangedSetAutoBrightness is already enabled");
475             return true;
476         }
477         ActivateValidAmbientSensor();
478         DISPLAY_HILOGI(FEAT_BRIGHTNESS, "StateChangedSetAutoBrightness enable");
479     } else {
480         if (!IsCurrentSensorEnable()) {
481             DISPLAY_HILOGI(FEAT_BRIGHTNESS, "StateChangedSetAutoBrightness is already disabled");
482             return true;
483         }
484         DeactivateAllAmbientSensor();
485         DISPLAY_HILOGI(FEAT_BRIGHTNESS, "StateChangedSetAutoBrightness disable");
486     }
487     return true;
488 }
489 
InitSensors()490 void BrightnessService::InitSensors()
491 {
492     DISPLAY_HILOGI(FEAT_BRIGHTNESS, "InitSensors start");
493     SensorInfo* sensorInfo = nullptr;
494     int32_t count;
495     int ret = GetAllSensors(&sensorInfo, &count);
496     if (ret != 0 || sensorInfo == nullptr || count < 0) {
497         DISPLAY_HILOGI(FEAT_BRIGHTNESS, "Can't get sensors");
498         return;
499     }
500     mIsSupportLightSensor = false;
501     for (int i = 0; i < count; i++) {
502         if (sensorInfo[i].sensorId == SENSOR_TYPE_ID_AMBIENT_LIGHT ||
503             sensorInfo[i].sensorId == SENSOR_TYPE_ID_AMBIENT_LIGHT1) {
504             DISPLAY_HILOGI(FEAT_BRIGHTNESS, "AMBIENT_LIGHT Support");
505             mIsSupportLightSensor = true;
506             break;
507         }
508     }
509     if (!mIsSupportLightSensor) {
510         DISPLAY_HILOGI(FEAT_BRIGHTNESS, "AMBIENT_LIGHT not support");
511     }
512 }
513 
AmbientLightCallback(SensorEvent * event)514 void BrightnessService::AmbientLightCallback(SensorEvent* event)
515 {
516     if (event == nullptr) {
517         DISPLAY_HILOGI(FEAT_BRIGHTNESS, "Sensor event is nullptr");
518         return;
519     }
520     if (event->sensorTypeId != SENSOR_TYPE_ID_AMBIENT_LIGHT && event->sensorTypeId != SENSOR_TYPE_ID_AMBIENT_LIGHT1) {
521         DISPLAY_HILOGI(FEAT_BRIGHTNESS, "Sensor Callback is not AMBIENT_LIGHT id=%{public}d", event->sensorTypeId);
522         return;
523     }
524     AmbientLightData* data = reinterpret_cast<AmbientLightData*>(event->data);
525     if (data == nullptr) {
526         DISPLAY_HILOGE(FEAT_BRIGHTNESS, "AmbientLightData is null");
527         return;
528     }
529     BrightnessService::Get().ProcessLightLux(data->intensity);
530 }
531 
ActivateAmbientSensor()532 void BrightnessService::ActivateAmbientSensor()
533 {
534     if (!mIsAutoBrightnessEnabled) {
535         DISPLAY_HILOGI(FEAT_BRIGHTNESS, "auto brightness is not enabled");
536         return;
537     }
538     if (mIsLightSensorEnabled) {
539         DISPLAY_HILOGI(FEAT_BRIGHTNESS, "Ambient Sensor is already on");
540         return;
541     }
542     (void)strcpy_s(mSensorUser.name, sizeof(mSensorUser.name), "BrightnessService");
543     mSensorUser.userData = nullptr;
544     mSensorUser.callback = &AmbientLightCallback;
545     SubscribeSensor(SENSOR_TYPE_ID_AMBIENT_LIGHT, &mSensorUser);
546     SetBatch(SENSOR_TYPE_ID_AMBIENT_LIGHT, &mSensorUser, SAMPLING_RATE, SAMPLING_RATE);
547     ActivateSensor(SENSOR_TYPE_ID_AMBIENT_LIGHT, &mSensorUser);
548     SetMode(SENSOR_TYPE_ID_AMBIENT_LIGHT, &mSensorUser, SENSOR_ON_CHANGE);
549     mIsLightSensorEnabled = true;
550     DISPLAY_HILOGI(FEAT_BRIGHTNESS, "ActivateAmbientSensor");
551 }
552 
DeactivateAmbientSensor()553 void BrightnessService::DeactivateAmbientSensor()
554 {
555     if (!mIsAutoBrightnessEnabled) {
556         DISPLAY_HILOGI(FEAT_BRIGHTNESS, "auto brightness is not enabled");
557         return;
558     }
559     if (!mIsLightSensorEnabled) {
560         DISPLAY_HILOGI(FEAT_BRIGHTNESS, "Ambient Sensor is already off");
561         return;
562     }
563     DeactivateSensor(SENSOR_TYPE_ID_AMBIENT_LIGHT, &mSensorUser);
564     UnsubscribeSensor(SENSOR_TYPE_ID_AMBIENT_LIGHT, &mSensorUser);
565     mIsLightSensorEnabled = false;
566     mLightLuxManager.ClearLuxData();
567     DISPLAY_HILOGI(FEAT_BRIGHTNESS, "DeactivateAmbientSensor");
568 }
569 
ActivateAmbientSensor1()570 void BrightnessService::ActivateAmbientSensor1()
571 {
572     if (!mIsAutoBrightnessEnabled) {
573         DISPLAY_HILOGI(FEAT_BRIGHTNESS, "auto brightness1 is not enabled");
574         return;
575     }
576     if (mIsLightSensor1Enabled) {
577         DISPLAY_HILOGI(FEAT_BRIGHTNESS, "Ambient Sensor1 is already on");
578         return;
579     }
580     (void)strcpy_s(mSensorUser1.name, sizeof(mSensorUser1.name), "BrightnessService");
581     mSensorUser1.userData = nullptr;
582     mSensorUser1.callback = &AmbientLightCallback;
583     SubscribeSensor(SENSOR_TYPE_ID_AMBIENT_LIGHT1, &mSensorUser1);
584     SetBatch(SENSOR_TYPE_ID_AMBIENT_LIGHT1, &mSensorUser1, SAMPLING_RATE, SAMPLING_RATE);
585     ActivateSensor(SENSOR_TYPE_ID_AMBIENT_LIGHT1, &mSensorUser1);
586     SetMode(SENSOR_TYPE_ID_AMBIENT_LIGHT1, &mSensorUser1, SENSOR_ON_CHANGE);
587     mIsLightSensor1Enabled = true;
588     DISPLAY_HILOGI(FEAT_BRIGHTNESS, "ActivateAmbientSensor1");
589 }
590 
DeactivateAmbientSensor1()591 void BrightnessService::DeactivateAmbientSensor1()
592 {
593     if (!mIsAutoBrightnessEnabled) {
594         DISPLAY_HILOGI(FEAT_BRIGHTNESS, "auto brightness1 is not enabled");
595         return;
596     }
597     if (!mIsLightSensor1Enabled) {
598         DISPLAY_HILOGI(FEAT_BRIGHTNESS, "Ambient Sensor1 is already off");
599         return;
600     }
601     DeactivateSensor(SENSOR_TYPE_ID_AMBIENT_LIGHT1, &mSensorUser1);
602     UnsubscribeSensor(SENSOR_TYPE_ID_AMBIENT_LIGHT1, &mSensorUser1);
603     mIsLightSensor1Enabled = false;
604     mLightLuxManager.ClearLuxData();
605     DISPLAY_HILOGI(FEAT_BRIGHTNESS, "DeactivateAmbientSensor1");
606 }
607 
ActivateValidAmbientSensor()608 void BrightnessService::ActivateValidAmbientSensor()
609 {
610     DISPLAY_HILOGI(FEAT_BRIGHTNESS, "ActivateValidAmbientSensor");
611     bool isFoldable = Rosen::DisplayManagerLite::GetInstance().IsFoldable();
612     if (!isFoldable) {
613         ActivateAmbientSensor();
614         return;
615     }
616     std::string identity = IPCSkeleton::ResetCallingIdentity();
617     auto foldMode = Rosen::DisplayManagerLite::GetInstance().GetFoldDisplayMode();
618     int sensorId = GetSensorIdWithDisplayMode(foldMode);
619     DISPLAY_HILOGI(FEAT_BRIGHTNESS, "ActivateValidAmbientSensor sensorId=%{public}d, mode=%{public}d",
620         sensorId, foldMode);
621     if (sensorId == SENSOR_TYPE_ID_AMBIENT_LIGHT) {
622         ActivateAmbientSensor();
623     } else if (sensorId == SENSOR_TYPE_ID_AMBIENT_LIGHT1) {
624         ActivateAmbientSensor1();
625     }
626     IPCSkeleton::SetCallingIdentity(identity);
627 }
628 
DeactivateValidAmbientSensor()629 void BrightnessService::DeactivateValidAmbientSensor()
630 {
631     DISPLAY_HILOGI(FEAT_BRIGHTNESS, "DeactivateValidAmbientSensor");
632     bool isFoldable = Rosen::DisplayManagerLite::GetInstance().IsFoldable();
633     if (!isFoldable) {
634         DeactivateAmbientSensor();
635         return;
636     }
637     std::string identity = IPCSkeleton::ResetCallingIdentity();
638     auto foldMode = Rosen::DisplayManagerLite::GetInstance().GetFoldDisplayMode();
639     int sensorId = GetSensorIdWithDisplayMode(foldMode);
640     DISPLAY_HILOGI(FEAT_BRIGHTNESS, "DeactivateValidAmbientSensor sensorId=%{public}d, mode=%{public}d",
641         sensorId, foldMode);
642     if (sensorId == SENSOR_TYPE_ID_AMBIENT_LIGHT) {
643         DeactivateAmbientSensor();
644     } else if (sensorId == SENSOR_TYPE_ID_AMBIENT_LIGHT1) {
645         DeactivateAmbientSensor1();
646     }
647     IPCSkeleton::SetCallingIdentity(identity);
648 }
649 
DeactivateAllAmbientSensor()650 void BrightnessService::DeactivateAllAmbientSensor()
651 {
652     DISPLAY_HILOGI(FEAT_BRIGHTNESS, "DeactivateAllAmbientSensor");
653     bool isFoldable = Rosen::DisplayManagerLite::GetInstance().IsFoldable();
654     if (!isFoldable) {
655         DeactivateAmbientSensor();
656         return;
657     }
658     DeactivateAmbientSensor();
659     DeactivateAmbientSensor1();
660 }
661 #endif
662 
IsAutoAdjustBrightness()663 bool BrightnessService::IsAutoAdjustBrightness()
664 {
665     return mIsAutoBrightnessEnabled;
666 }
667 
ProcessLightLux(float lux)668 void BrightnessService::ProcessLightLux(float lux)
669 {
670     DISPLAY_HILOGD(FEAT_BRIGHTNESS, "ProcessLightLux, lux=%{public}f, mLightLux=%{public}f",
671         lux, mLightLuxManager.GetSmoothedLux());
672     if (!CanSetBrightness()) {
673         if (mIsLuxActiveWithLog) {
674             mIsLuxActiveWithLog = false;
675             DISPLAY_HILOGI(FEAT_BRIGHTNESS, "ProcessLightLux:mIsLuxActiveWithLog=false");
676         }
677         return;
678     }
679     if (!mIsLuxActiveWithLog) {
680         mIsLuxActiveWithLog = true;
681         DISPLAY_HILOGI(FEAT_BRIGHTNESS, "ProcessLightLux:mIsLuxActiveWithLog=true");
682     }
683     NotifyLightChangeToAps(AMBIENT_LIGHT_TYPE, lux);
684     if (mLightLuxManager.IsNeedUpdateBrightness(lux)) {
685         DISPLAY_HILOGI(FEAT_BRIGHTNESS, "UpdateLightLux, lux=%{public}f, mLightLux=%{public}f, isFirst=%{public}d",
686             lux, mLightLuxManager.GetSmoothedLux(), mLightLuxManager.GetIsFirstLux());
687         UpdateCurrentBrightnessLevel(lux, mLightLuxManager.GetIsFirstLux());
688     }
689 
690     for (int index = 0; index < LUX_LEVEL_LENGTH; index++) {
691         if (static_cast<uint32_t>(lux) < AMBIENT_LUX_LEVELS[index]) {
692             if (index != mLuxLevel || mLightLuxManager.GetIsFirstLux()) {
693                 mLuxLevel = index;
694                 // Notify ambient lux change event to battery statistics
695                 // type:0 auto brightness, 1 manual brightness, 2 window brightness, 3 others
696                 HiSysEventWrite(HiviewDFX::HiSysEvent::Domain::DISPLAY, "AMBIENT_LIGHT",
697                     HiviewDFX::HiSysEvent::EventType::STATISTIC, "LEVEL", mLuxLevel, "TYPE", 0);
698             }
699             break;
700         }
701     }
702 }
703 
UpdateCurrentBrightnessLevel(float lux,bool isFastDuration)704 void BrightnessService::UpdateCurrentBrightnessLevel(float lux, bool isFastDuration)
705 {
706     uint32_t brightnessLevel = GetBrightnessLevel(lux);
707     if (mBrightnessLevel != brightnessLevel || isFastDuration) {
708         uint32_t duration = DEFAULT_BRIGHTEN_DURATION;
709         if (brightnessLevel < mBrightnessLevel) {
710             duration = DEFAULT_DARKEN_DURATION;
711         }
712         if (isFastDuration) {
713             duration = DEFAULT_ANIMATING_DURATION;
714         }
715         if (isFastDuration && mIsDisplayOnWhenFirstLuxReport) {
716             duration = 0;
717             mIsDisplayOnWhenFirstLuxReport.store(false);
718         }
719         DISPLAY_HILOGI(FEAT_BRIGHTNESS, "UpdateCurrentBrightnessLevel lux=%{public}f, mBrightnessLevel=%{public}d, "\
720             "brightnessLevel=%{public}d, duration=%{public}d", lux, mBrightnessLevel, brightnessLevel, duration);
721         mBrightnessLevel = brightnessLevel;
722         mCurrentBrightness.store(brightnessLevel);
723         if (mWaitForFirstLux) {
724             FFRTUtils::CancelTask(g_waitForFirstLuxTaskHandle, queue_);
725             mWaitForFirstLux = false;
726             DISPLAY_HILOGI(FEAT_BRIGHTNESS, "UpdateCurrentBrightnessLevel CancelScreenOn waitforFisrtLux Task");
727         }
728         mBrightnessTarget.store(brightnessLevel);
729         SetBrightnessLevel(brightnessLevel, duration);
730     }
731 }
732 
SetBrightnessLevel(uint32_t value,uint32_t duration)733 void BrightnessService::SetBrightnessLevel(uint32_t value, uint32_t duration)
734 {
735     DISPLAY_HILOGI(FEAT_BRIGHTNESS, "SetBrightnessLevel value=%{public}d, duration=%{public}d",
736         value, duration);
737     UpdateBrightness(value, duration, true);
738 }
739 
GetBrightnessLevel(float lux)740 uint32_t BrightnessService::GetBrightnessLevel(float lux)
741 {
742     uint32_t brightnessLevel = static_cast<uint32_t>(mBrightnessCalculationManager.GetInterpolatedValue(lux) *
743         MAX_DEFAULT_BRGIHTNESS_LEVEL);
744 
745     DISPLAY_HILOGI(FEAT_BRIGHTNESS, "GetBrightnessLevel lux=%{public}f, brightnessLevel=%{public}d",
746         lux, brightnessLevel);
747     return brightnessLevel;
748 }
749 
GetBrightnessHighLevel(uint32_t level)750 uint32_t BrightnessService::GetBrightnessHighLevel(uint32_t level)
751 {
752     uint32_t brightnessHighLevel = level;
753     return level;
754 }
755 
SetBrightness(uint32_t value,uint32_t gradualDuration,bool continuous)756 bool BrightnessService::SetBrightness(uint32_t value, uint32_t gradualDuration, bool continuous)
757 {
758     DISPLAY_HILOGD(FEAT_BRIGHTNESS, "SetBrightness val=%{public}d, duration=%{public}d", value, gradualDuration);
759     if (!CanSetBrightness()) {
760         DISPLAY_HILOGW(FEAT_BRIGHTNESS, "Cannot set brightness, ignore the change");
761         mCachedSettingBrightness = value;
762         return false;
763     }
764     if (gradualDuration == 0) {
765         bool isSettingOn = IsAutoAdjustBrightness();
766         if (isSettingOn && IsCurrentSensorEnable()) {
767             mIsUserMode = true;
768             mBrightnessCalculationManager.UpdateBrightnessOffset(value, mLightLuxManager.GetSmoothedLux());
769             DISPLAY_HILOGI(FEAT_BRIGHTNESS, "UpdateBrightnessOffset level=%{public}d, mLightLux=%{public}f",
770                 value, mLightLuxManager.GetSmoothedLux());
771         }
772     }
773     mBrightnessTarget.store(value);
774     mCurrentBrightness.store(value);
775     NotifyLightChangeToAps(BRIGHTNESS_TYPE, static_cast<float>(value));
776     bool isSuccess = UpdateBrightness(value, gradualDuration, !continuous);
777     DISPLAY_HILOGD(FEAT_BRIGHTNESS, "SetBrightness val=%{public}d, isSuccess=%{public}d", value, isSuccess);
778     mIsUserMode = false;
779     return isSuccess;
780 }
781 
SetScreenOnBrightness()782 void BrightnessService::SetScreenOnBrightness()
783 {
784     uint32_t screenOnBrightness = GetScreenOnBrightness(true);
785     if (mWaitForFirstLux) {
786         DISPLAY_HILOGI(FEAT_BRIGHTNESS, "SetScreenOnBrightness waitForFirstLux");
787         FFRTUtils::CancelTask(g_waitForFirstLuxTaskHandle, queue_);
788         screenOnBrightness = mCachedSettingBrightness;
789         DISPLAY_HILOGI(FEAT_BRIGHTNESS, "SetScreenOnBrightness waitForFirstLux,GetSettingBrightness=%{public}d",
790             screenOnBrightness);
791         FFRTTask setBrightnessTask = [this, screenOnBrightness] {
792             this->UpdateBrightness(screenOnBrightness, 0, true);
793         };
794         g_waitForFirstLuxTaskHandle = FFRTUtils::SubmitDelayTask(setBrightnessTask, WAIT_FOR_FIRST_LUX_MAX_TIME,
795             queue_);
796         return;
797     }
798     bool needUpdateBrightness = true;
799     if (IsBrightnessBoosted() || IsBrightnessOverridden()) {
800         needUpdateBrightness = false;
801     }
802     DISPLAY_HILOGI(FEAT_BRIGHTNESS, "SetScreenOnBrightness screenOnBrightness=%{public}d, needUpdate=%{public}d",
803         screenOnBrightness, needUpdateBrightness);
804     UpdateBrightness(screenOnBrightness, 0, needUpdateBrightness);
805 }
806 
ClearOffset()807 void BrightnessService::ClearOffset()
808 {
809     if (mDimming->IsDimming()) {
810         DISPLAY_HILOGI(FEAT_BRIGHTNESS, "mode off StopDimming");
811         mDimming->StopDimming();
812     }
813     DISPLAY_HILOGI(FEAT_BRIGHTNESS, "ClearOffset mLightLux=%{public}f", mLightLuxManager.GetSmoothedLux());
814     mBrightnessTarget.store(0);
815     mBrightnessCalculationManager.UpdateBrightnessOffset(0, mLightLuxManager.GetSmoothedLux());
816 }
817 
GetBrightness()818 uint32_t BrightnessService::GetBrightness()
819 {
820     return GetSettingBrightness();
821 }
822 
GetDeviceBrightness()823 uint32_t BrightnessService::GetDeviceBrightness()
824 {
825     uint32_t brightness = DEFAULT_BRIGHTNESS;
826     if (mAction != nullptr) {
827         brightness = mAction->GetBrightness();
828     }
829     return GetOrigBrightnessLevel(brightness);
830 }
831 
GetCachedSettingBrightness()832 uint32_t BrightnessService::GetCachedSettingBrightness()
833 {
834     return mCachedSettingBrightness;
835 }
836 
DiscountBrightness(double discount,uint32_t gradualDuration)837 bool BrightnessService::DiscountBrightness(double discount, uint32_t gradualDuration)
838 {
839     if (!CanDiscountBrightness()) {
840         DISPLAY_HILOGW(FEAT_BRIGHTNESS, "Cannot discount brightness, ignore the change");
841         return false;
842     }
843     auto safeDiscount = discount;
844     if (safeDiscount > DISCOUNT_MAX) {
845         DISPLAY_HILOGD(FEAT_BRIGHTNESS, "discount value is greater than max, discount=%{public}lf", discount);
846         safeDiscount = DISCOUNT_MAX;
847     }
848     if (safeDiscount < DISCOUNT_MIN) {
849         DISPLAY_HILOGD(FEAT_BRIGHTNESS, "discount value is less than min, discount=%{public}lf", discount);
850         safeDiscount = DISCOUNT_MIN;
851     }
852     DISPLAY_HILOGI(FEAT_BRIGHTNESS, "Discount brightness, safeDiscount=%{public}lf", safeDiscount);
853     mDiscount = safeDiscount;
854     if (mDimmingCallback) {
855         mDimmingCallback->DiscountBrightness(safeDiscount);
856     }
857     uint32_t screenOnBrightness = GetScreenOnBrightness(false);
858     return UpdateBrightness(screenOnBrightness, gradualDuration);
859 }
860 
SetSleepBrightness()861 void BrightnessService::SetSleepBrightness()
862 {
863     uint32_t value = GetSettingBrightness();
864     if (value <= MIN_DEFAULT_BRGIHTNESS_LEVEL) {
865         return;
866     }
867     uint32_t sleepBrightness = BrightnessParamHelper::GetSleepBrightness();
868     uint32_t sleepMinumumReductionBrightness = BrightnessParamHelper::GetSleepMinumumReductionBrightness();
869     if (value < sleepMinumumReductionBrightness) {
870         value = sleepMinumumReductionBrightness;
871     }
872     uint32_t enterSleepBrightness = std::max(std::min(value - sleepMinumumReductionBrightness, sleepBrightness),
873         MIN_DEFAULT_BRGIHTNESS_LEVEL);
874     uint32_t sleepDarkenTime = BrightnessParamHelper::GetSleepDarkenTime();
875     mIsSleepStatus = true;
876     DISPLAY_HILOGI(FEAT_BRIGHTNESS, "SetSleepBrightness enterSleepBrightness=%{pulblic}d, sleepDarkenTime=%{public}d",
877         enterSleepBrightness, sleepDarkenTime);
878     OverrideBrightness(enterSleepBrightness, sleepDarkenTime);
879 }
880 
OverrideBrightness(uint32_t value,uint32_t gradualDuration)881 bool BrightnessService::OverrideBrightness(uint32_t value, uint32_t gradualDuration)
882 {
883     if (!CanOverrideBrightness()) {
884         DISPLAY_HILOGW(FEAT_BRIGHTNESS, "Cannot override brightness, ignore the change");
885         return false;
886     }
887     if (!mIsBrightnessOverridden) {
888         mIsBrightnessOverridden = true;
889     }
890     mOverriddenBrightness = value;
891     mBeforeOverriddenBrightness = GetSettingBrightness();
892     DISPLAY_HILOGI(FEAT_BRIGHTNESS, "Override brightness, value=%{public}u, mBeforeOverriddenBrightness=%{public}d",
893         value, mBeforeOverriddenBrightness);
894     return UpdateBrightness(value, gradualDuration);
895 }
896 
RestoreBrightness(uint32_t gradualDuration)897 bool BrightnessService::RestoreBrightness(uint32_t gradualDuration)
898 {
899     if (!IsBrightnessOverridden()) {
900         DISPLAY_HILOGD(FEAT_BRIGHTNESS, "Brightness is not override, no need to restore");
901         return false;
902     }
903     DISPLAY_HILOGI(FEAT_BRIGHTNESS, "restore brightness=%{public}d", mBeforeOverriddenBrightness);
904     mIsBrightnessOverridden = false;
905     return UpdateBrightness(mBeforeOverriddenBrightness, gradualDuration, true);
906 }
907 
IsBrightnessOverridden()908 bool BrightnessService::IsBrightnessOverridden()
909 {
910     return mIsBrightnessOverridden;
911 }
912 
BoostBrightness(uint32_t timeoutMs,uint32_t gradualDuration)913 bool BrightnessService::BoostBrightness(uint32_t timeoutMs, uint32_t gradualDuration)
914 {
915     if (!CanBoostBrightness()) {
916         DISPLAY_HILOGW(FEAT_BRIGHTNESS, "Cannot boost brightness, ignore the change");
917         return false;
918     }
919     bool isSuccess = true;
920     if (!mIsBrightnessBoosted) {
921         uint32_t maxBrightness = BrightnessParamHelper::GetMaxBrightness();
922         DISPLAY_HILOGI(FEAT_BRIGHTNESS, "Boost brightness, maxBrightness: %{public}d", maxBrightness);
923         mIsBrightnessBoosted = true;
924         isSuccess = UpdateBrightness(maxBrightness, gradualDuration);
925     }
926 
927     // If boost multi-times, we will resend the cancel boost event.
928     FFRTUtils::CancelTask(g_cancelBoostTaskHandle, queue_);
929     FFRTTask task = [this, gradualDuration] { this->CancelBoostBrightness(gradualDuration); };
930     g_cancelBoostTaskHandle = FFRTUtils::SubmitDelayTask(task, timeoutMs, queue_);
931     DISPLAY_HILOGI(FEAT_BRIGHTNESS, "BoostBrightness update timeout=%{public}u, isSuccess=%{public}d", timeoutMs,
932         isSuccess);
933     return isSuccess;
934 }
935 
CancelBoostBrightness(uint32_t gradualDuration)936 bool BrightnessService::CancelBoostBrightness(uint32_t gradualDuration)
937 {
938     DISPLAY_HILOGD(FEAT_BRIGHTNESS, "Cancel boost brightness");
939     if (!IsBrightnessBoosted()) {
940         DISPLAY_HILOGD(FEAT_BRIGHTNESS, "Brightness is not boost, no need to restore");
941         return false;
942     }
943     FFRTUtils::CancelTask(g_cancelBoostTaskHandle, queue_);
944     mIsBrightnessBoosted = false;
945     return UpdateBrightness(mCachedSettingBrightness, gradualDuration, true);
946 }
947 
IsBrightnessBoosted()948 bool BrightnessService::IsBrightnessBoosted()
949 {
950     return mIsBrightnessBoosted;
951 }
952 
IsScreenOn()953 bool BrightnessService::IsScreenOn()
954 {
955     return (mState == DisplayState::DISPLAY_ON || mState == DisplayState::DISPLAY_DIM);
956 }
957 
CanSetBrightness()958 bool BrightnessService::CanSetBrightness()
959 {
960     bool isScreenOn = IsScreenOn();
961     bool isOverridden = IsBrightnessOverridden();
962     bool isBoosted = IsBrightnessBoosted();
963     DISPLAY_HILOGD(FEAT_BRIGHTNESS, "isScreenOn: %{public}d, isOverridden: %{public}d, isBoosted: %{public}d",
964         isScreenOn, isOverridden, isBoosted);
965     return isScreenOn && !isOverridden && !isBoosted;
966 }
967 
CanDiscountBrightness()968 bool BrightnessService::CanDiscountBrightness()
969 {
970     return IsScreenOn();
971 }
972 
CanOverrideBrightness()973 bool BrightnessService::CanOverrideBrightness()
974 {
975     return IsScreenOn() && !IsBrightnessBoosted();
976 }
977 
CanBoostBrightness()978 bool BrightnessService::CanBoostBrightness()
979 {
980     return IsScreenOn() && !IsBrightnessOverridden();
981 }
982 
UpdateBrightness(uint32_t value,uint32_t gradualDuration,bool updateSetting)983 bool BrightnessService::UpdateBrightness(uint32_t value, uint32_t gradualDuration, bool updateSetting)
984 {
985     DISPLAY_HILOGD(FEAT_BRIGHTNESS, "UpdateBrightness, value=%{public}u, discount=%{public}f,"\
986         "duration=%{public}u, updateSetting=%{public}d", value, mDiscount, gradualDuration, updateSetting);
987     mWaitForFirstLux = false;
988     auto safeBrightness = GetSafeBrightness(value);
989     if (mDimming->IsDimming()) {
990         DISPLAY_HILOGI(FEAT_BRIGHTNESS, "UpdateBrightness StopDimming");
991         mDimming->StopDimming();
992     }
993     auto brightness = static_cast<uint32_t>(safeBrightness * mDiscount);
994     brightness = GetMappingBrightnessLevel(brightness);
995     if (gradualDuration > 0) {
996         mDimming->StartDimming(GetSettingBrightness(), brightness, gradualDuration);
997         return true;
998     }
999     bool isSuccess = mAction->SetBrightness(brightness);
1000     DISPLAY_HILOGD(FEAT_BRIGHTNESS, "UpdateBrightness is %{public}s, brightness: %{public}u",
1001         isSuccess ? "succ" : "failed", brightness);
1002     if (isSuccess && updateSetting) {
1003         DISPLAY_HILOGI(FEAT_BRIGHTNESS, "UpdateBrightness, settings, value=%{public}u", safeBrightness);
1004         FFRTUtils::SubmitTask([this, safeBrightness] { this->SetSettingBrightness(safeBrightness); });
1005     }
1006     if (isSuccess) {
1007         ReportBrightnessBigData(brightness);
1008     }
1009     return isSuccess;
1010 }
1011 
GetSettingBrightness(const std::string & key)1012 uint32_t BrightnessService::GetSettingBrightness(const std::string& key)
1013 {
1014     uint32_t settingBrightness = DEFAULT_BRIGHTNESS;
1015     auto isSuccess = BrightnessSettingHelper::GetSettingBrightness(settingBrightness, key);
1016     if (isSuccess != ERR_OK) {
1017         DISPLAY_HILOGW(FEAT_BRIGHTNESS,
1018             "get setting brightness failed, return default=%{public}d, key=%{public}s, ret=%{public}d",
1019             settingBrightness, key.c_str(), isSuccess);
1020     }
1021     DISPLAY_HILOGI(FEAT_BRIGHTNESS, "GetSettingBrightness=%{public}d", settingBrightness);
1022     return settingBrightness;
1023 }
1024 
SetSettingBrightness(uint32_t value)1025 void BrightnessService::SetSettingBrightness(uint32_t value)
1026 {
1027     BrightnessSettingHelper::SetSettingBrightness(value);
1028     mBrightnessLevel = value;
1029     mCachedSettingBrightness = value;
1030     DISPLAY_HILOGI(FEAT_BRIGHTNESS, "SetSettingBrightness brightness=%{public}u", value);
1031 }
1032 
GetScreenOnBrightness(bool isUpdateTarget)1033 uint32_t BrightnessService::GetScreenOnBrightness(bool isUpdateTarget)
1034 {
1035     uint32_t screenOnbrightness;
1036     if (IsBrightnessBoosted()) {
1037         DISPLAY_HILOGD(FEAT_BRIGHTNESS, "Brightness is boosted, return max brightness");
1038         screenOnbrightness = BrightnessParamHelper::GetMaxBrightness();
1039     } else if (IsBrightnessOverridden()) {
1040         DISPLAY_HILOGD(FEAT_BRIGHTNESS, "Brightness is overridden, return overridden brightness=%{public}u",
1041             mOverriddenBrightness);
1042         screenOnbrightness = mOverriddenBrightness;
1043     } else if (isUpdateTarget && mIsAutoBrightnessEnabled) {
1044         if (mBrightnessTarget.load() > 0) {
1045             DISPLAY_HILOGI(FEAT_BRIGHTNESS, "update, return mBrightnessTarget=%{public}d", mBrightnessTarget.load());
1046             screenOnbrightness = mBrightnessTarget.load();
1047         } else {
1048             screenOnbrightness = 0;
1049             mWaitForFirstLux = true;
1050         }
1051     } else {
1052         screenOnbrightness = GetSettingBrightness();
1053     }
1054     return screenOnbrightness;
1055 }
1056 
RegisterSettingBrightnessObserver()1057 void BrightnessService::RegisterSettingBrightnessObserver()
1058 {
1059 }
1060 
UpdateBrightnessSettingFunc(const std::string & key)1061 void BrightnessService::UpdateBrightnessSettingFunc(const std::string& key)
1062 {
1063 }
1064 
UnregisterSettingBrightnessObserver()1065 void BrightnessService::UnregisterSettingBrightnessObserver()
1066 {
1067     BrightnessSettingHelper::UnregisterSettingBrightnessObserver();
1068 }
1069 
GetDiscount() const1070 double BrightnessService::GetDiscount() const
1071 {
1072     return mDiscount;
1073 }
1074 
GetDimmingUpdateTime() const1075 uint32_t BrightnessService::GetDimmingUpdateTime() const
1076 {
1077     return mDimming->GetDimmingUpdateTime();
1078 }
1079 
GetMappingBrightnessLevel(uint32_t level)1080 uint32_t BrightnessService::GetMappingBrightnessLevel(uint32_t level)
1081 {
1082     if (level < MIN_DEFAULT_BRGIHTNESS_LEVEL) {
1083         level = MIN_DEFAULT_BRGIHTNESS_LEVEL;
1084     }
1085     if (level > MAX_DEFAULT_BRGIHTNESS_LEVEL) {
1086         level = MAX_DEFAULT_BRGIHTNESS_LEVEL;
1087     }
1088     float levelOut = static_cast<float>(1.0f * (level - MIN_DEFAULT_BRGIHTNESS_LEVEL)
1089          * (MAX_MAPPING_BRGIHTNESS_LEVEL - MIN_MAPPING_BRGIHTNESS_LEVEL)
1090          / (MAX_DEFAULT_BRGIHTNESS_LEVEL - MIN_DEFAULT_BRGIHTNESS_LEVEL)) + MIN_MAPPING_BRGIHTNESS_LEVEL + 0.5f;
1091     if (static_cast<uint32_t>(levelOut) < BrightnessParamHelper::GetMinBrightness()) {
1092         return BrightnessParamHelper::GetMinBrightness();
1093     }
1094     return static_cast<uint32_t>(levelOut);
1095 }
1096 
GetOrigBrightnessLevel(uint32_t level)1097 uint32_t BrightnessService::GetOrigBrightnessLevel(uint32_t level)
1098 {
1099     if (level < MIN_MAPPING_BRGIHTNESS_LEVEL) {
1100         level = MIN_MAPPING_BRGIHTNESS_LEVEL;
1101     }
1102     if (level > MAX_MAPPING_BRGIHTNESS_LEVEL) {
1103         level = MAX_MAPPING_BRGIHTNESS_LEVEL;
1104     }
1105     float levelOut = static_cast<float>(1.0f * (level - MIN_MAPPING_BRGIHTNESS_LEVEL)
1106         * (MAX_DEFAULT_BRGIHTNESS_LEVEL - MIN_DEFAULT_BRGIHTNESS_LEVEL)
1107          / (MAX_MAPPING_BRGIHTNESS_LEVEL - MIN_MAPPING_BRGIHTNESS_LEVEL) + MIN_MAPPING_BRGIHTNESS_LEVEL + 0.5f);
1108     return static_cast<int>(levelOut);
1109 }
1110 
GetMappingBrightnessNit(uint32_t level)1111 uint32_t BrightnessService::GetMappingBrightnessNit(uint32_t level)
1112 {
1113     uint32_t levelIn = level;
1114     if (levelIn < MIN_MAPPING_BRGIHTNESS_LEVEL) {
1115         levelIn = MIN_MAPPING_BRGIHTNESS_LEVEL;
1116     }
1117     if (levelIn > MAX_MAPPING_BRGIHTNESS_LEVEL) {
1118         levelIn = MAX_MAPPING_BRGIHTNESS_LEVEL;
1119     }
1120     double nitOut = (double)(levelIn - MIN_MAPPING_BRGIHTNESS_LEVEL)
1121         * (MAX_DEFAULT_BRGIHTNESS_NIT - MIN_DEFAULT_BRGIHTNESS_NIT)
1122          / (MAX_MAPPING_BRGIHTNESS_LEVEL - MIN_MAPPING_BRGIHTNESS_LEVEL) + MIN_DEFAULT_BRGIHTNESS_NIT;
1123     return round(nitOut);
1124 }
1125 
GetBrightnessLevelFromNit(uint32_t nit)1126 uint32_t BrightnessService::GetBrightnessLevelFromNit(uint32_t nit)
1127 {
1128     uint32_t nitIn = nit;
1129     if (nitIn < MIN_DEFAULT_BRGIHTNESS_NIT) {
1130         nitIn = MIN_DEFAULT_BRGIHTNESS_NIT;
1131     }
1132     if (nitIn > MAX_DEFAULT_BRGIHTNESS_NIT) {
1133         nitIn = MAX_DEFAULT_BRGIHTNESS_NIT;
1134     }
1135     double levelOut = (double)(nitIn - MIN_DEFAULT_BRGIHTNESS_NIT)
1136         * (MAX_DEFAULT_BRGIHTNESS_LEVEL - MIN_DEFAULT_BRGIHTNESS_LEVEL)
1137          / (MAX_DEFAULT_BRGIHTNESS_NIT - MIN_DEFAULT_BRGIHTNESS_NIT) + MIN_DEFAULT_BRGIHTNESS_LEVEL;
1138     return round(levelOut);
1139 }
1140 
GetMappingHighBrightnessLevel(uint32_t level)1141 uint32_t BrightnessService::GetMappingHighBrightnessLevel(uint32_t level)
1142 {
1143     uint32_t levelIn = level;
1144     if (levelIn < MIN_DEFAULT_BRGIHTNESS_LEVEL) {
1145         levelIn = MIN_DEFAULT_BRGIHTNESS_LEVEL;
1146     }
1147     if (levelIn > MAX_DEFAULT_BRGIHTNESS_LEVEL) {
1148         levelIn = MAX_DEFAULT_BRGIHTNESS_LEVEL;
1149     }
1150     uint32_t levelOut = (levelIn - MIN_DEFAULT_BRGIHTNESS_LEVEL)
1151          * (MAX_DEFAULT_HIGH_BRGIHTNESS_LEVEL - MIN_DEFAULT_HIGH_BRGIHTNESS_LEVEL)
1152          / (MAX_DEFAULT_BRGIHTNESS_LEVEL - MIN_DEFAULT_BRGIHTNESS_LEVEL) + MIN_DEFAULT_HIGH_BRGIHTNESS_LEVEL;
1153     return levelOut;
1154 }
1155 
UpdateBrightnessSceneMode(BrightnessSceneMode mode)1156 void BrightnessService::UpdateBrightnessSceneMode(BrightnessSceneMode mode)
1157 {
1158 }
1159 
IsDimming()1160 bool BrightnessService::IsDimming()
1161 {
1162     if (mDimming == nullptr) {
1163         return false;
1164     }
1165     return mDimming->IsDimming();
1166 }
1167 
GetReason()1168 std::string BrightnessService::GetReason()
1169 {
1170     if (mIsBrightnessOverridden) {
1171         return "APP";
1172     }
1173     if (mIsUserMode) {
1174         return "USER";
1175     }
1176     if (mIsAutoBrightnessEnabled) {
1177         return "AUTO";
1178     }
1179     return "MANUAL";
1180 }
1181 
ReportBrightnessBigData(uint32_t brightness)1182 void BrightnessService::ReportBrightnessBigData(uint32_t brightness)
1183 {
1184     std::string reason = GetReason();
1185     uint32_t nit = GetMappingBrightnessNit(brightness);
1186     // Notify screen brightness change event to battery statistics
1187     HiSysEventWrite(HiviewDFX::HiSysEvent::Domain::DISPLAY, "BRIGHTNESS_NIT",
1188         HiviewDFX::HiSysEvent::EventType::STATISTIC, "BRIGHTNESS", brightness, "REASON", reason, "NIT", nit);
1189     DISPLAY_HILOGD(FEAT_BRIGHTNESS, "BigData brightness=%{public}d,reason=%{public}s,nit=%{public}d",
1190         brightness, reason.c_str(), nit);
1191 }
1192 
IsSleepStatus()1193 bool BrightnessService::IsSleepStatus()
1194 {
1195     return mIsSleepStatus;
1196 }
1197 
GetIsSupportLightSensor()1198 bool BrightnessService::GetIsSupportLightSensor()
1199 {
1200     return mIsSupportLightSensor;
1201 }
1202 
IsCurrentSensorEnable()1203 bool BrightnessService::IsCurrentSensorEnable()
1204 {
1205     bool isFoldable = Rosen::DisplayManagerLite::GetInstance().IsFoldable();
1206     if (!isFoldable) {
1207         return mIsLightSensorEnabled;
1208     }
1209     bool result = false;
1210     std::string identity = IPCSkeleton::ResetCallingIdentity();
1211     auto foldMode = Rosen::DisplayManagerLite::GetInstance().GetFoldDisplayMode();
1212     int sensorId = GetSensorIdWithDisplayMode(foldMode);
1213     if (sensorId == SENSOR_TYPE_ID_AMBIENT_LIGHT) {
1214         result = mIsLightSensorEnabled;
1215     } else if (sensorId == SENSOR_TYPE_ID_AMBIENT_LIGHT1) {
1216         result = mIsLightSensor1Enabled;
1217     }
1218     IPCSkeleton::SetCallingIdentity(identity);
1219     return result;
1220 }
1221 
GetDisplayIdWithFoldstatus(Rosen::FoldStatus foldStatus)1222 int BrightnessService::GetDisplayIdWithFoldstatus(Rosen::FoldStatus foldStatus)
1223 {
1224     return mBrightnessCalculationManager.GetDisplayIdWithFoldstatus(static_cast<int>(foldStatus));
1225 }
1226 
GetSensorIdWithFoldstatus(Rosen::FoldStatus foldStatus)1227 int BrightnessService::GetSensorIdWithFoldstatus(Rosen::FoldStatus foldStatus)
1228 {
1229     return mBrightnessCalculationManager.GetSensorIdWithFoldstatus(static_cast<int>(foldStatus));
1230 }
1231 
GetDisplayIdWithDisplayMode(Rosen::FoldDisplayMode mode)1232 int BrightnessService::GetDisplayIdWithDisplayMode(Rosen::FoldDisplayMode mode)
1233 {
1234     return mBrightnessCalculationManager.GetDisplayIdWithDisplayMode(static_cast<int>(mode));
1235 }
1236 
GetSensorIdWithDisplayMode(Rosen::FoldDisplayMode mode)1237 int BrightnessService::GetSensorIdWithDisplayMode(Rosen::FoldDisplayMode mode)
1238 {
1239     return mBrightnessCalculationManager.GetSensorIdWithDisplayMode(static_cast<int>(mode));
1240 }
1241 
SetMaxBrightness(double value)1242 bool BrightnessService::SetMaxBrightness(double value)
1243 {
1244     int32_t intMaxValue = round(value * MAX_DEFAULT_BRGIHTNESS_LEVEL);
1245     if (intMaxValue <= 0) {
1246         intMaxValue = brightnessValueMin;
1247     }
1248     if (intMaxValue == brightnessValueMax) {
1249         DISPLAY_HILOGI(FEAT_BRIGHTNESS, "SetMaxBrightness value=oldMax");
1250         return true;
1251     }
1252     DISPLAY_HILOGI(FEAT_BRIGHTNESS, "SetMaxBrightness value=%{public}u, oldMax=%{public}u",
1253         intMaxValue, brightnessValueMax);
1254     brightnessValueMax =
1255         (intMaxValue > MAX_DEFAULT_BRGIHTNESS_LEVEL ? MAX_DEFAULT_BRGIHTNESS_LEVEL : intMaxValue);
1256     uint32_t currentBrightness = GetSettingBrightness();
1257     if (brightnessValueMax < currentBrightness) {
1258         DISPLAY_HILOGI(FEAT_BRIGHTNESS, "SetMaxBrightness currentBrightness=%{public}u", currentBrightness);
1259         return UpdateBrightness(brightnessValueMax, DEFAULT_MAX_BRIGHTNESS_DURATION, true);
1260     }
1261     if (mCurrentBrightness.load() == 0) {
1262         DISPLAY_HILOGI(FEAT_BRIGHTNESS, "No need to update brightne during init");
1263         return true;
1264     }
1265     return UpdateBrightness(mCurrentBrightness.load(), DEFAULT_MAX_BRIGHTNESS_DURATION, true);
1266 }
1267 
SetMaxBrightnessNit(uint32_t maxNit)1268 bool BrightnessService::SetMaxBrightnessNit(uint32_t maxNit)
1269 {
1270     uint32_t max_value = GetBrightnessLevelFromNit(maxNit);
1271     DISPLAY_HILOGI(FEAT_BRIGHTNESS, "SetMaxBrightnessNit nitIn=%{public}u, levelOut=%{public}u",
1272         maxNit, max_value);
1273     if (max_value == brightnessValueMax) {
1274         DISPLAY_HILOGI(FEAT_BRIGHTNESS, "SetMaxBrightness value=oldMax");
1275         return true;
1276     }
1277     brightnessValueMax =
1278         (max_value > MAX_DEFAULT_BRGIHTNESS_LEVEL ? MAX_DEFAULT_BRGIHTNESS_LEVEL : max_value);
1279     uint32_t currentBrightness = GetSettingBrightness();
1280     if (brightnessValueMax < currentBrightness) {
1281         DISPLAY_HILOGI(FEAT_BRIGHTNESS, "SetMaxBrightnessNit currentBrightness=%{public}u", currentBrightness);
1282         return UpdateBrightness(brightnessValueMax, DEFAULT_MAX_BRIGHTNESS_DURATION, true);
1283     }
1284     if (mCurrentBrightness.load() == 0) {
1285         DISPLAY_HILOGI(FEAT_BRIGHTNESS, "No need to update brightne during init");
1286         return true;
1287     }
1288     return UpdateBrightness(mCurrentBrightness.load(), DEFAULT_MAX_BRIGHTNESS_DURATION, true);
1289 }
1290 
GetSafeBrightness(uint32_t value)1291 uint32_t BrightnessService::GetSafeBrightness(uint32_t value)
1292 {
1293     auto brightnessValue = value;
1294     if (brightnessValue > brightnessValueMax) {
1295         DISPLAY_HILOGI(FEAT_BRIGHTNESS, "value is bigger than max=%{public}u, value=%{public}u",
1296             brightnessValueMax, value);
1297         brightnessValue = brightnessValueMax;
1298     }
1299     if (brightnessValue < brightnessValueMin) {
1300         DISPLAY_HILOGI(FEAT_BRIGHTNESS, "brightness value is less than min, value=%{public}u", value);
1301         brightnessValue = brightnessValueMin;
1302     }
1303     return brightnessValue;
1304 }
1305 } // namespace DisplayPowerMgr
1306 } // namespace OHOS
1307