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