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