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
47namespace OHOS {
48namespace DisplayPowerMgr {
49namespace {
50constexpr uint32_t MAX_DEFAULT_BRGIHTNESS_LEVEL = 255;
51constexpr uint32_t MIN_DEFAULT_BRGIHTNESS_LEVEL = 1;
52constexpr uint32_t MAX_MAPPING_BRGIHTNESS_LEVEL = 223;
53constexpr uint32_t MIN_MAPPING_BRGIHTNESS_LEVEL = 1;
54constexpr uint32_t MAX_DEFAULT_BRGIHTNESS_NIT = 600;
55constexpr uint32_t MIN_DEFAULT_BRGIHTNESS_NIT = 2;
56constexpr uint32_t MAX_DEFAULT_HIGH_BRGIHTNESS_LEVEL = 10000;
57constexpr uint32_t MIN_DEFAULT_HIGH_BRGIHTNESS_LEVEL = 156;
58constexpr uint32_t DEFAULT_ANIMATING_DURATION = 500;
59constexpr uint32_t DEFAULT_BRIGHTEN_DURATION = 2000;
60constexpr uint32_t DEFAULT_DARKEN_DURATION = 5000;
61constexpr uint32_t DEFAULT_MAX_BRIGHTNESS_DURATION = 3000;
62constexpr uint32_t BRIGHTNESS_TYPE = 0;
63constexpr uint32_t AMBIENT_LIGHT_TYPE = 1;
64constexpr uint32_t APS_LISTEN_PARAMS_LENGHT = 3;
65constexpr time_t CALL_APS_INTERVAL = 2;
66
67FFRTHandle g_cancelBoostTaskHandle{};
68FFRTHandle g_waitForFirstLuxTaskHandle{};
69}
70
71const 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
74using namespace OHOS::PowerMgr;
75
76uint32_t BrightnessService::brightnessValueMax = MAX_DEFAULT_BRGIHTNESS_LEVEL;
77uint32_t BrightnessService::brightnessValueMin = MIN_DEFAULT_BRGIHTNESS_LEVEL;
78
79BrightnessService::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
98BrightnessService& BrightnessService::Get()
99{
100    static BrightnessService brightnessManager;
101    return brightnessManager;
102}
103
104void 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
132void 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
149void 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
193void 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
209void 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
221uint32_t BrightnessService::GetDisplayId()
222{
223    return mDisplayId;
224}
225
226void 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
277uint32_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
293void 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
303uint32_t BrightnessService::GetCurrentSensorId()
304{
305    return mCurrentSensorId;
306}
307
308void BrightnessService::SetCurrentSensorId(uint32_t sensorId)
309{
310    mCurrentSensorId = sensorId;
311}
312
313BrightnessService::DimmingCallbackImpl::DimmingCallbackImpl(
314    const std::shared_ptr<BrightnessAction>& action, std::function<void(uint32_t)> callback)
315    : mAction(action), mCallback(callback)
316{
317}
318
319void BrightnessService::DimmingCallbackImpl::OnStart()
320{
321    DISPLAY_HILOGD(FEAT_BRIGHTNESS, "BrightnessDimmingCallback onStart");
322}
323
324void 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
351void BrightnessService::DimmingCallbackImpl::OnEnd()
352{
353    DISPLAY_HILOGD(FEAT_BRIGHTNESS, "ScreenAnimatorCallback OnEnd");
354}
355
356void BrightnessService::DimmingCallbackImpl::DiscountBrightness(double discount)
357{
358    mDiscount = discount;
359}
360
361void 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
399DisplayState BrightnessService::GetDisplayState()
400{
401    return mState;
402}
403
404bool BrightnessService::IsScreenOnState(DisplayState state)
405{
406    return state == DisplayState::DISPLAY_ON || state == DisplayState::DISPLAY_DIM;
407}
408
409bool BrightnessService::GetSettingAutoBrightness(const std::string& key)
410{
411    return BrightnessSettingHelper::GetSettingAutoBrightness(key);
412}
413
414void BrightnessService::SetSettingAutoBrightness(bool enable)
415{
416    BrightnessSettingHelper::SetSettingAutoBrightness(enable);
417}
418
419uint32_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
435bool 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
464bool 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
491void 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
515void 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
533void 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
554void 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
571void 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
592void 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
609void 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
630void 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
651void 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
664bool BrightnessService::IsAutoAdjustBrightness()
665{
666    return mIsAutoBrightnessEnabled;
667}
668
669void 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
707void 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
736void 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
743uint32_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
753uint32_t BrightnessService::GetBrightnessHighLevel(uint32_t level)
754{
755    return level;
756}
757
758bool 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
784void 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
809void 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
820uint32_t BrightnessService::GetBrightness()
821{
822    return GetSettingBrightness();
823}
824
825uint32_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
834uint32_t BrightnessService::GetCachedSettingBrightness()
835{
836    return mCachedSettingBrightness;
837}
838
839bool 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
863void 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
883bool 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
899bool 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
910bool BrightnessService::IsBrightnessOverridden()
911{
912    return mIsBrightnessOverridden;
913}
914
915bool 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
938bool 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
950bool BrightnessService::IsBrightnessBoosted()
951{
952    return mIsBrightnessBoosted;
953}
954
955bool BrightnessService::IsScreenOn()
956{
957    return (mState == DisplayState::DISPLAY_ON || mState == DisplayState::DISPLAY_DIM);
958}
959
960bool 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
970bool BrightnessService::CanDiscountBrightness()
971{
972    return IsScreenOn();
973}
974
975bool BrightnessService::CanOverrideBrightness()
976{
977    return IsScreenOn() && !IsBrightnessBoosted();
978}
979
980bool BrightnessService::CanBoostBrightness()
981{
982    return IsScreenOn() && !IsBrightnessOverridden();
983}
984
985bool 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
1014uint32_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
1027void 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
1035uint32_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
1059void BrightnessService::RegisterSettingBrightnessObserver()
1060{
1061}
1062
1063void BrightnessService::UpdateBrightnessSettingFunc(const std::string& key)
1064{
1065}
1066
1067void BrightnessService::UnregisterSettingBrightnessObserver()
1068{
1069    BrightnessSettingHelper::UnregisterSettingBrightnessObserver();
1070}
1071
1072double BrightnessService::GetDiscount() const
1073{
1074    return mDiscount;
1075}
1076
1077uint32_t BrightnessService::GetDimmingUpdateTime() const
1078{
1079    return mDimming->GetDimmingUpdateTime();
1080}
1081
1082uint32_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
1099uint32_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
1113uint32_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
1128uint32_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
1143uint32_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
1158void BrightnessService::UpdateBrightnessSceneMode(BrightnessSceneMode mode)
1159{
1160}
1161
1162bool BrightnessService::IsDimming()
1163{
1164    if (mDimming == nullptr) {
1165        return false;
1166    }
1167    return mDimming->IsDimming();
1168}
1169
1170std::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
1184void 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
1197bool BrightnessService::IsSleepStatus()
1198{
1199    return mIsSleepStatus;
1200}
1201
1202bool BrightnessService::GetIsSupportLightSensor()
1203{
1204    return mIsSupportLightSensor;
1205}
1206
1207bool 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
1226int BrightnessService::GetDisplayIdWithFoldstatus(Rosen::FoldStatus foldStatus)
1227{
1228    return mBrightnessCalculationManager.GetDisplayIdWithFoldstatus(static_cast<int>(foldStatus));
1229}
1230
1231int BrightnessService::GetSensorIdWithFoldstatus(Rosen::FoldStatus foldStatus)
1232{
1233    return mBrightnessCalculationManager.GetSensorIdWithFoldstatus(static_cast<int>(foldStatus));
1234}
1235
1236int BrightnessService::GetDisplayIdWithDisplayMode(Rosen::FoldDisplayMode mode)
1237{
1238    return mBrightnessCalculationManager.GetDisplayIdWithDisplayMode(static_cast<int>(mode));
1239}
1240
1241int BrightnessService::GetSensorIdWithDisplayMode(Rosen::FoldDisplayMode mode)
1242{
1243    return mBrightnessCalculationManager.GetSensorIdWithDisplayMode(static_cast<int>(mode));
1244}
1245
1246bool 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
1272bool 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
1295uint32_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