1 /*
2 * Copyright (c) 2021-2022 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 "display_power_mgr_service.h"
17
18 #include <hisysevent.h>
19 #include <file_ex.h>
20 #include <securec.h>
21 #include <system_ability_definition.h>
22 #include "errors.h"
23 #include "new"
24 #include "screen_action.h"
25 #include "sensor_agent.h"
26 #include "watchdog.h"
27 #include "display_log.h"
28 #include "display_auto_brightness.h"
29 #include "display_param_helper.h"
30 #include "permission.h"
31 #include "setting_provider.h"
32
33 namespace OHOS {
34 namespace DisplayPowerMgr {
35 using namespace OHOS::PowerMgr;
36 namespace {
37 constexpr const char* DISPLAY_SERVICE_NAME = "DisplayPowerManagerService";
38 constexpr int32_t AUTO_BRIGHTNESS_DISABLE = 0;
39 constexpr int32_t AUTO_BRIGHTNESS_ENABLE = 1;
40 sptr<SettingObserver> g_autoBrightnessObserver;
41 DisplayParamHelper::BootCompletedCallback g_bootCompletedCallback;
42 }
43 const uint32_t DisplayPowerMgrService::BRIGHTNESS_MIN = DisplayParamHelper::GetMinBrightness();
44 const uint32_t DisplayPowerMgrService::BRIGHTNESS_DEFAULT = DisplayParamHelper::GetDefaultBrightness();
45 const uint32_t DisplayPowerMgrService::BRIGHTNESS_MAX = DisplayParamHelper::GetMaxBrightness();
46 DisplayPowerMgrService::DisplayPowerMgrService() = default;
47
Init()48 void DisplayPowerMgrService::Init()
49 {
50 DISPLAY_HILOGI(COMP_SVC, "DisplayPowerMgrService Create");
51 if (!eventRunner_) {
52 eventRunner_ = AppExecFwk::EventRunner::Create(DISPLAY_SERVICE_NAME);
53 if (eventRunner_ == nullptr) {
54 DISPLAY_HILOGE(COMP_SVC, "Init failed due to create EventRunner");
55 return;
56 }
57 }
58
59 if (!handler_) {
60 handler_ = std::make_shared<DisplayEventHandler>(eventRunner_,
61 DelayedSpSingleton<DisplayPowerMgrService>::GetInstance());
62 std::string handlerName("DisplayPowerEventHandler");
63 HiviewDFX::Watchdog::GetInstance().AddThread(handlerName, handler_);
64 }
65
66 std::vector<uint32_t> displayIds = ScreenAction::GetAllDisplayId();
67 for (const auto& id: displayIds) {
68 DISPLAY_HILOGI(COMP_SVC, "find display, id=%{public}u", id);
69 controllerMap_.emplace(id, std::make_shared<ScreenController>(id, handler_));
70 }
71
72 callback_ = nullptr;
73 cbDeathRecipient_ = nullptr;
74
75 InitSensors();
76 RegisterBootCompletedCallback();
77 }
RegisterBootCompletedCallback()78 void DisplayPowerMgrService::RegisterBootCompletedCallback()
79 {
80 g_bootCompletedCallback = []() {
81 SetBootCompletedBrightness();
82 SetBootCompletedAutoBrightness();
83 RegisterSettingObservers();
84 };
85 DisplayParamHelper::RegisterBootCompletedCallback(g_bootCompletedCallback);
86 }
87
Deinit()88 void DisplayPowerMgrService::Deinit()
89 {
90 UnregisterSettingObservers();
91 }
92
SetBootCompletedBrightness()93 void DisplayPowerMgrService::SetBootCompletedBrightness()
94 {
95 uint32_t mainDisplayId = DelayedSpSingleton<DisplayPowerMgrService>::GetInstance()->GetMainDisplayId();
96 uint32_t brightness = DelayedSpSingleton<DisplayPowerMgrService>::GetInstance()->GetBrightness(mainDisplayId);
97 DelayedSpSingleton<DisplayPowerMgrService>::GetInstance()->SetBrightness(brightness, mainDisplayId);
98 }
99
SetBootCompletedAutoBrightness()100 void DisplayPowerMgrService::SetBootCompletedAutoBrightness()
101 {
102 bool enable = GetSettingAutoBrightness();
103 DelayedSpSingleton<DisplayPowerMgrService>::GetInstance()->AutoAdjustBrightness(enable);
104 }
105
RegisterSettingObservers()106 void DisplayPowerMgrService::RegisterSettingObservers()
107 {
108 uint32_t mainDisplayId = DelayedSpSingleton<DisplayPowerMgrService>::GetInstance()->GetMainDisplayId();
109 auto controllerMap = DelayedSpSingleton<DisplayPowerMgrService>::GetInstance()->controllerMap_;
110 auto iter = controllerMap.find(mainDisplayId);
111 if (iter != controllerMap.end()) {
112 iter->second->RegisterSettingBrightnessObserver();
113 }
114 RegisterSettingAutoBrightnessObserver();
115 }
116
UnregisterSettingObservers()117 void DisplayPowerMgrService::UnregisterSettingObservers()
118 {
119 uint32_t mainDisplayId = DelayedSpSingleton<DisplayPowerMgrService>::GetInstance()->GetMainDisplayId();
120 auto controllerMap = DelayedSpSingleton<DisplayPowerMgrService>::GetInstance()->controllerMap_;
121 auto iter = controllerMap.find(mainDisplayId);
122 if (iter != controllerMap.end()) {
123 iter->second->UnregisterSettingBrightnessObserver();
124 }
125 UnregisterSettingAutoBrightnessObserver();
126 }
127
RegisterSettingAutoBrightnessObserver()128 void DisplayPowerMgrService::RegisterSettingAutoBrightnessObserver()
129 {
130 if (g_autoBrightnessObserver) {
131 DISPLAY_HILOGD(FEAT_BRIGHTNESS, "setting auto brightness observer is already registered");
132 return;
133 }
134 SettingProvider& provider = SettingProvider::GetInstance(DISPLAY_MANAGER_SERVICE_ID);
135 SettingObserver::UpdateFunc updateFunc = [&](const std::string& key) { AutoBrightnessSettingUpdateFunc(key); };
136 g_autoBrightnessObserver = provider.CreateObserver(SETTING_AUTO_ADJUST_BRIGHTNESS_KEY, updateFunc);
137 ErrCode ret = provider.RegisterObserver(g_autoBrightnessObserver);
138 if (ret != ERR_OK) {
139 DISPLAY_HILOGW(FEAT_BRIGHTNESS, "register setting auto brightness observer failed, ret=%{public}d", ret);
140 g_autoBrightnessObserver = nullptr;
141 }
142 }
143
AutoBrightnessSettingUpdateFunc(const std::string & key)144 void DisplayPowerMgrService::AutoBrightnessSettingUpdateFunc(const std::string& key)
145 {
146 bool isSettingEnable = GetSettingAutoBrightness(key);
147 bool isSystemEnable = DelayedSpSingleton<DisplayPowerMgrService>::GetInstance()->IsAutoAdjustBrightness();
148 if (isSettingEnable == isSystemEnable) {
149 return;
150 }
151 DelayedSpSingleton<DisplayPowerMgrService>::GetInstance()->AutoAdjustBrightness(isSettingEnable);
152 }
153
SetSettingAutoBrightness(bool enable)154 void DisplayPowerMgrService::SetSettingAutoBrightness(bool enable)
155 {
156 SettingProvider& provider = SettingProvider::GetInstance(DISPLAY_MANAGER_SERVICE_ID);
157 int32_t value = enable ? AUTO_BRIGHTNESS_ENABLE : AUTO_BRIGHTNESS_DISABLE;
158 ErrCode ret = provider.PutIntValue(SETTING_AUTO_ADJUST_BRIGHTNESS_KEY, value);
159 if (ret != ERR_OK) {
160 DISPLAY_HILOGW(FEAT_BRIGHTNESS, "set setting auto brightness failed, ret=%{public}d", ret);
161 }
162 }
163
GetSettingAutoBrightness(const std::string & key)164 bool DisplayPowerMgrService::GetSettingAutoBrightness(const std::string& key)
165 {
166 SettingProvider& provider = SettingProvider::GetInstance(DISPLAY_MANAGER_SERVICE_ID);
167 int32_t value;
168 ErrCode ret = provider.GetIntValue(key, value);
169 if (ret != ERR_OK) {
170 DISPLAY_HILOGW(
171 FEAT_BRIGHTNESS, "get setting auto brightness failed key=%{public}s, ret=%{public}d", key.c_str(), ret);
172 }
173 return (value == AUTO_BRIGHTNESS_ENABLE);
174 }
175
UnregisterSettingAutoBrightnessObserver()176 void DisplayPowerMgrService::UnregisterSettingAutoBrightnessObserver()
177 {
178 if (g_autoBrightnessObserver == nullptr) {
179 DISPLAY_HILOGD(FEAT_BRIGHTNESS, "g_autoBrightnessObserver is nullptr, no need to unregister");
180 return;
181 }
182 SettingProvider& provider = SettingProvider::GetInstance(DISPLAY_MANAGER_SERVICE_ID);
183 ErrCode ret = provider.UnregisterObserver(g_autoBrightnessObserver);
184 if (ret != ERR_OK) {
185 DISPLAY_HILOGW(FEAT_BRIGHTNESS, "unregister setting auto brightness observer failed, ret=%{public}d", ret);
186 }
187 g_autoBrightnessObserver = nullptr;
188 }
189
SetDisplayState(uint32_t id,DisplayState state,uint32_t reason)190 bool DisplayPowerMgrService::SetDisplayState(uint32_t id, DisplayState state, uint32_t reason)
191 {
192 DISPLAY_HILOGI(COMP_SVC, "SetDisplayState %{public}d, %{public}d", id, state);
193 auto iterator = controllerMap_.find(id);
194 if (iterator == controllerMap_.end()) {
195 return false;
196 }
197 if (id == GetMainDisplayId()) {
198 DISPLAY_HILOGI(COMP_SVC, "change ambient sensor status");
199 if (state == DisplayState::DISPLAY_ON) {
200 ActivateAmbientSensor();
201 } else if (state == DisplayState::DISPLAY_OFF) {
202 DeactivateAmbientSensor();
203 }
204 }
205 return iterator->second->UpdateState(state, reason);
206 }
207
GetDisplayState(uint32_t id)208 DisplayState DisplayPowerMgrService::GetDisplayState(uint32_t id)
209 {
210 DISPLAY_HILOGD(COMP_SVC, "GetDisplayState %{public}d", id);
211 auto iterator = controllerMap_.find(id);
212 if (iterator == controllerMap_.end()) {
213 return DisplayState::DISPLAY_UNKNOWN;
214 }
215 return iterator->second->GetState();
216 }
217
GetDisplayIds()218 std::vector<uint32_t> DisplayPowerMgrService::GetDisplayIds()
219 {
220 std::vector<uint32_t> ids;
221 for (auto& iter: controllerMap_) {
222 ids.push_back(iter.first);
223 }
224 return ids;
225 }
226
GetMainDisplayId()227 uint32_t DisplayPowerMgrService::GetMainDisplayId()
228 {
229 uint32_t id = ScreenAction::GetDefaultDisplayId();
230 DISPLAY_HILOGI(COMP_SVC, "GetMainDisplayId %{public}d", id);
231 return id;
232 }
233
SetBrightness(uint32_t value,uint32_t displayId)234 bool DisplayPowerMgrService::SetBrightness(uint32_t value, uint32_t displayId)
235 {
236 if (!Permission::IsSystem()) {
237 lastError_ = DisplayErrors::ERR_PERMISSION_DENIED;
238 return false;
239 }
240 auto brightness = GetSafeBrightness(value);
241 DISPLAY_HILOGI(FEAT_BRIGHTNESS, "SetBrightness displayId=%{public}u, value=%{public}u", displayId, brightness);
242 auto iter = controllerMap_.find(displayId);
243 if (iter == controllerMap_.end()) {
244 return false;
245 }
246 return iter->second->SetBrightness(brightness);
247 }
248
DiscountBrightness(double discount,uint32_t displayId)249 bool DisplayPowerMgrService::DiscountBrightness(double discount, uint32_t displayId)
250 {
251 auto iter = controllerMap_.find(displayId);
252 if (iter == controllerMap_.end()) {
253 return false;
254 }
255 auto brightness = iter->second->GetBrightness();
256 auto safeDiscount = GetSafeDiscount(discount, brightness);
257 DISPLAY_HILOGI(FEAT_BRIGHTNESS, "DiscountBrightness displayId=%{public}u, discount-%{public}lf",
258 displayId, safeDiscount);
259 HiviewDFX::HiSysEvent::Write("DISPLAY", "BACKLIGHT_DISCOUNT",
260 HiviewDFX::HiSysEvent::EventType::STATISTIC, "RATIO", safeDiscount);
261 return iter->second->DiscountBrightness(safeDiscount);
262 }
263
OverrideBrightness(uint32_t value,uint32_t displayId)264 bool DisplayPowerMgrService::OverrideBrightness(uint32_t value, uint32_t displayId)
265 {
266 auto brightness = GetSafeBrightness(value);
267 DISPLAY_HILOGI(COMP_SVC, "OverrideBrightness displayId=%{public}u, value=%{public}u", displayId, brightness);
268 auto iter = controllerMap_.find(displayId);
269 if (iter == controllerMap_.end()) {
270 return false;
271 }
272 return iter->second->OverrideBrightness(brightness);
273 }
274
RestoreBrightness(uint32_t displayId)275 bool DisplayPowerMgrService::RestoreBrightness(uint32_t displayId)
276 {
277 DISPLAY_HILOGI(COMP_SVC, "RestoreBrightness displayId=%{public}u", displayId);
278 auto iter = controllerMap_.find(displayId);
279 if (iter == controllerMap_.end()) {
280 return false;
281 }
282 return iter->second->RestoreBrightness();
283 }
284
GetBrightness(uint32_t displayId)285 uint32_t DisplayPowerMgrService::GetBrightness(uint32_t displayId)
286 {
287 DISPLAY_HILOGD(FEAT_BRIGHTNESS, "GetBrightness displayId=%{public}u", displayId);
288 auto iter = controllerMap_.find(displayId);
289 if (iter == controllerMap_.end()) {
290 return BRIGHTNESS_OFF;
291 }
292 return iter->second->GetBrightness();
293 }
294
GetDefaultBrightness()295 uint32_t DisplayPowerMgrService::GetDefaultBrightness()
296 {
297 return BRIGHTNESS_DEFAULT;
298 }
299
GetMaxBrightness()300 uint32_t DisplayPowerMgrService::GetMaxBrightness()
301 {
302 return BRIGHTNESS_MAX;
303 }
304
GetMinBrightness()305 uint32_t DisplayPowerMgrService::GetMinBrightness()
306 {
307 return BRIGHTNESS_MIN;
308 }
309
AdjustBrightness(uint32_t id,int32_t value,uint32_t duration)310 bool DisplayPowerMgrService::AdjustBrightness(uint32_t id, int32_t value, uint32_t duration)
311 {
312 DISPLAY_HILOGD(FEAT_BRIGHTNESS, "SetDisplayState %{public}d, %{public}d, %{public}d",
313 id, value, duration);
314 auto iterator = controllerMap_.find(id);
315 if (iterator == controllerMap_.end()) {
316 return false;
317 }
318 return iterator->second->SetBrightness(value, duration);
319 }
320
AutoAdjustBrightness(bool enable)321 bool DisplayPowerMgrService::AutoAdjustBrightness(bool enable)
322 {
323 DISPLAY_HILOGD(FEAT_BRIGHTNESS, "AutoAdjustBrightness start");
324 if (!supportLightSensor_) {
325 DISPLAY_HILOGD(FEAT_BRIGHTNESS, "AutoAdjustBrightness not support");
326 SetSettingAutoBrightness(false);
327 return false;
328 }
329 if (enable) {
330 DISPLAY_HILOGD(FEAT_BRIGHTNESS, "AutoAdjustBrightness enable");
331 if (autoBrightness_) {
332 DISPLAY_HILOGD(FEAT_BRIGHTNESS, "AutoAdjustBrightness is already enabled");
333 return true;
334 }
335 autoBrightness_ = true;
336 if (GetDisplayState(GetMainDisplayId()) == DisplayState::DISPLAY_ON) {
337 ActivateAmbientSensor();
338 }
339 } else {
340 DISPLAY_HILOGD(FEAT_BRIGHTNESS, "AutoAdjustBrightness disable");
341 if (!autoBrightness_) {
342 DISPLAY_HILOGD(FEAT_BRIGHTNESS, "AutoAdjustBrightness is already disabled");
343 return true;
344 }
345 DeactivateAmbientSensor();
346 autoBrightness_ = false;
347 }
348 SetSettingAutoBrightness(enable);
349 return true;
350 }
351
IsAutoAdjustBrightness()352 bool DisplayPowerMgrService::IsAutoAdjustBrightness()
353 {
354 return autoBrightness_;
355 }
356
ActivateAmbientSensor()357 void DisplayPowerMgrService::ActivateAmbientSensor()
358 {
359 if (!autoBrightness_) {
360 DISPLAY_HILOGD(FEAT_BRIGHTNESS, "auto brightness is not enabled");
361 return;
362 }
363 if (ambientSensorEnabled_) {
364 DISPLAY_HILOGD(FEAT_BRIGHTNESS, "Ambient Sensor is already on");
365 return;
366 }
367 (void) strcpy_s(sensorUser_.name, sizeof(sensorUser_.name), "DisplayPowerMgrService");
368 sensorUser_.userData = nullptr;
369 sensorUser_.callback = &AmbientLightCallback;
370 SubscribeSensor(SENSOR_TYPE_ID_AMBIENT_LIGHT, &sensorUser_);
371 SetBatch(SENSOR_TYPE_ID_AMBIENT_LIGHT, &sensorUser_, SAMPLING_RATE, SAMPLING_RATE);
372 ActivateSensor(SENSOR_TYPE_ID_AMBIENT_LIGHT, &sensorUser_);
373 SetMode(SENSOR_TYPE_ID_AMBIENT_LIGHT, &sensorUser_, SENSOR_ON_CHANGE);
374 ambientSensorEnabled_ = true;
375 }
376
DeactivateAmbientSensor()377 void DisplayPowerMgrService::DeactivateAmbientSensor()
378 {
379 if (!autoBrightness_) {
380 DISPLAY_HILOGD(FEAT_BRIGHTNESS, "auto brightness is not enabled");
381 return;
382 }
383 if (!ambientSensorEnabled_) {
384 DISPLAY_HILOGD(FEAT_BRIGHTNESS, "Ambient Sensor is already off");
385 return;
386 }
387 DeactivateSensor(SENSOR_TYPE_ID_AMBIENT_LIGHT, &sensorUser_);
388 UnsubscribeSensor(SENSOR_TYPE_ID_AMBIENT_LIGHT, &sensorUser_);
389 ambientSensorEnabled_ = false;
390 }
391
RegisterCallback(sptr<IDisplayPowerCallback> callback)392 bool DisplayPowerMgrService::RegisterCallback(sptr<IDisplayPowerCallback> callback)
393 {
394 DISPLAY_HILOGI(COMP_SVC, "RegisterCallback");
395 if (callback_ != nullptr) {
396 DISPLAY_HILOGI(COMP_SVC, "Callback function exist");
397 return false;
398 }
399 callback_ = callback;
400 sptr<IRemoteObject> remote = callback_->AsObject();
401 if (!remote->IsProxyObject()) {
402 DISPLAY_HILOGE(COMP_FWK, "Callback is not proxy");
403 return false;
404 }
405 if (cbDeathRecipient_ == nullptr) {
406 cbDeathRecipient_ = new CallbackDeathRecipient();
407 }
408 remote->AddDeathRecipient(cbDeathRecipient_);
409 return true;
410 }
411
BoostBrightness(int32_t timeoutMs,uint32_t displayId)412 bool DisplayPowerMgrService::BoostBrightness(int32_t timeoutMs, uint32_t displayId)
413 {
414 DISPLAY_HILOGD(FEAT_BRIGHTNESS, "Timing boost brightness: %{public}d, id: %{public}d", timeoutMs, displayId);
415 RETURN_IF_WITH_RET(timeoutMs <= 0, false);
416 auto iter = controllerMap_.find(displayId);
417 RETURN_IF_WITH_RET(iter == controllerMap_.end(), false);
418 return iter->second->BoostBrightness(timeoutMs);
419 }
420
CancelBoostBrightness(uint32_t displayId)421 bool DisplayPowerMgrService::CancelBoostBrightness(uint32_t displayId)
422 {
423 DISPLAY_HILOGD(FEAT_BRIGHTNESS, "Cancel boost brightness, id: %{public}d", displayId);
424 auto iter = controllerMap_.find(displayId);
425 RETURN_IF_WITH_RET(iter == controllerMap_.end(), false);
426 return iter->second->CancelBoostBrightness();
427 }
428
GetDeviceBrightness(uint32_t displayId)429 uint32_t DisplayPowerMgrService::GetDeviceBrightness(uint32_t displayId)
430 {
431 DISPLAY_HILOGD(FEAT_BRIGHTNESS, "GetDeviceBrightness displayId=%{public}u", displayId);
432 auto iter = controllerMap_.find(displayId);
433 if (iter == controllerMap_.end()) {
434 return BRIGHTNESS_OFF;
435 }
436 return iter->second->GetDeviceBrightness();
437 }
438
NotifyStateChangeCallback(uint32_t displayId,DisplayState state)439 void DisplayPowerMgrService::NotifyStateChangeCallback(uint32_t displayId, DisplayState state)
440 {
441 if (callback_ != nullptr) {
442 callback_->OnDisplayStateChanged(displayId, state);
443 }
444 }
445
Dump(int32_t fd,const std::vector<std::u16string> & args)446 int32_t DisplayPowerMgrService::Dump(int32_t fd, const std::vector<std::u16string>& args)
447 {
448 std::string result("DISPLAY POWER MANAGER DUMP:\n");
449 for (auto& iter: controllerMap_) {
450 auto control = iter.second;
451 result.append("Display Id=");
452 result.append(std::to_string(iter.first));
453 result.append(" State=");
454 result.append(std::to_string(static_cast<uint32_t>(control->GetState())));
455 result.append(" Discount=");
456 result.append(std::to_string(control->GetDiscount()));
457 result.append(" Brightness=");
458 result.append(std::to_string(control->GetBrightness()));
459 if (control->IsBrightnessOverridden()) {
460 result.append(" OverrideBrightness=");
461 result.append(std::to_string(control->GetScreenOnBrightness()));
462 }
463 if (control->IsBrightnessBoosted()) {
464 result.append(" BoostBrightness=");
465 result.append(std::to_string(control->GetScreenOnBrightness()));
466 }
467 result.append("\n");
468 result.append("DeviceBrightness=");
469 result.append(std::to_string(control->GetDeviceBrightness()));
470 result.append("\n");
471 }
472
473 result.append("Support Ambient Light: ");
474 if (supportLightSensor_) {
475 result.append("TRUE");
476 } else {
477 result.append("FALSE");
478 }
479 result.append("\n");
480
481 result.append("Auto Adjust Brightness: ");
482 if (autoBrightness_) {
483 result.append("ON");
484 } else {
485 result.append("OFF");
486 }
487 result.append("\n");
488
489 result.append("Brightness Limits: ");
490 result.append("Max=" + std::to_string(GetMaxBrightness()) + " ");
491 result.append("Min=" + std::to_string(GetMinBrightness()) + " ");
492 result.append("Default=" + std::to_string(GetDefaultBrightness()));
493 result.append("\n");
494
495 if (!SaveStringToFd(fd, result)) {
496 DISPLAY_HILOGE(COMP_SVC, "Failed to save dump info to fd");
497 }
498 return ERR_OK;
499 }
500
InitSensors()501 void DisplayPowerMgrService::InitSensors()
502 {
503 DISPLAY_HILOGI(FEAT_BRIGHTNESS, "InitSensors start");
504 SensorInfo* sensorInfo = nullptr;
505 int32_t count;
506 int ret = GetAllSensors(&sensorInfo, &count);
507 if (ret != 0 || sensorInfo == nullptr) {
508 DISPLAY_HILOGI(FEAT_BRIGHTNESS, "Can't get sensors");
509 return;
510 }
511 supportLightSensor_ = false;
512 for (int i = 0; i < count; i++) {
513 if (sensorInfo[i].sensorId == SENSOR_TYPE_ID_AMBIENT_LIGHT) {
514 DISPLAY_HILOGI(FEAT_BRIGHTNESS, "AMBIENT_LIGHT Support");
515 supportLightSensor_ = true;
516 break;
517 }
518 }
519
520 if (!supportLightSensor_) {
521 DISPLAY_HILOGI(FEAT_BRIGHTNESS, "AMBIENT_LIGHT not support");
522 }
523 }
524
AmbientLightCallback(SensorEvent * event)525 void DisplayPowerMgrService::AmbientLightCallback(SensorEvent* event)
526 {
527 if (event->sensorTypeId != SENSOR_TYPE_ID_AMBIENT_LIGHT) {
528 DISPLAY_HILOGI(FEAT_BRIGHTNESS, "Sensor Callback is not AMBIENT_LIGHT");
529 return;
530 }
531 auto pms = DelayedSpSingleton<DisplayPowerMgrService>::GetInstance();
532 if (pms == nullptr) {
533 DISPLAY_HILOGI(FEAT_BRIGHTNESS, "Sensor Callback no service");
534 return;
535 }
536 uint32_t mainDispId = pms->GetMainDisplayId();
537 auto mainDisp = pms->controllerMap_.find(mainDispId);
538 if (mainDisp == pms->controllerMap_.end()) {
539 return;
540 }
541 if (mainDisp->second->IsBrightnessOverridden() || mainDisp->second->IsBrightnessBoosted()) {
542 DISPLAY_HILOGD(FEAT_BRIGHTNESS, "Overwrite or boost brightness scene, auto brightness is invalid");
543 return;
544 }
545 AmbientLightData* data = (AmbientLightData*) event->data;
546 int32_t brightness = static_cast<int32_t>(mainDisp->second->GetBrightness());
547 uint32_t animationUpdateTime = mainDisp->second->GetAnimationUpdateTime();
548 int32_t changeBrightness = 0;
549 if (pms->CalculateBrightness(data->intensity, brightness, changeBrightness)) {
550 double discountStride = static_cast<double>(AUTO_ADJUST_BRIGHTNESS_STRIDE / mainDisp->second->GetDiscount());
551 uint32_t gradualDuration = floor(changeBrightness / discountStride) * animationUpdateTime;
552 pms->AdjustBrightness(mainDispId, brightness, gradualDuration);
553 }
554 // Notify ambient brightness change event to battery statistics
555 HiviewDFX::HiSysEvent::Write("DISPLAY", "AMBIENT_LIGHT",
556 HiviewDFX::HiSysEvent::EventType::STATISTIC, "LEVEL", brightness);
557 }
558
IsChangedLux(float scalar)559 bool DisplayPowerMgrService::IsChangedLux(float scalar)
560 {
561 DISPLAY_HILOGD(FEAT_BRIGHTNESS, "changed: %{public}d, %{public}f vs %{public}f",
562 luxChanged_, lastLux_, scalar);
563 if (lastLuxTime_ <= 0) {
564 DISPLAY_HILOGD(FEAT_BRIGHTNESS, "receive lux at first time");
565 lastLuxTime_ = time(0);
566 lastLux_ = scalar;
567 luxChanged_ = true;
568 return false;
569 }
570
571 if (!luxChanged_) {
572 float luxChangeMin = (lastLux_ / LUX_CHANGE_RATE_THRESHOLD) + 1;
573 if (abs(scalar - lastLux_) < luxChangeMin) {
574 DISPLAY_HILOGD(FEAT_BRIGHTNESS, "Too little change");
575 return false;
576 } else {
577 DISPLAY_HILOGI(FEAT_BRIGHTNESS, "First time to change, wait for stable");
578 luxChanged_ = true;
579 return false;
580 }
581 } else {
582 float luxChangeMin = (lastLux_ / LUX_CHANGE_RATE_THRESHOLD) + 1;
583 if (luxChangeMin < LUX_CHANGE_STABLE_MIN) {
584 luxChangeMin = LUX_CHANGE_STABLE_MIN;
585 }
586 if (abs(scalar - lastLux_) >= luxChangeMin) {
587 time_t currentTime = time(0);
588 time_t sub = currentTime - lastLuxTime_;
589 DISPLAY_HILOGD(FEAT_BRIGHTNESS, "stable lux");
590 if (sub >= LUX_STABLE_TIME) {
591 DISPLAY_HILOGI(FEAT_BRIGHTNESS, "stable enought to change");
592 lastLuxTime_ = time(0);
593 lastLux_ = scalar;
594 luxChanged_ = false;
595 return true;
596 }
597 } else {
598 DISPLAY_HILOGD(FEAT_BRIGHTNESS, "unstable lux, wait for stable");
599 luxChanged_ = true;
600 return false;
601 }
602 }
603 return false;
604 }
605
GetSafeBrightness(uint32_t value)606 uint32_t DisplayPowerMgrService::GetSafeBrightness(uint32_t value)
607 {
608 auto brightnessValue = value;
609 if (brightnessValue > BRIGHTNESS_MAX) {
610 DISPLAY_HILOGD(FEAT_BRIGHTNESS, "brightness value is greater than max, value=%{public}u", value);
611 brightnessValue = BRIGHTNESS_MAX;
612 }
613 if (brightnessValue < BRIGHTNESS_MIN) {
614 DISPLAY_HILOGD(FEAT_BRIGHTNESS, "brightness value is less than min, value=%{public}u", value);
615 brightnessValue = BRIGHTNESS_MIN;
616 }
617 return brightnessValue;
618 }
619
GetSafeDiscount(double discount,uint32_t brightness)620 double DisplayPowerMgrService::GetSafeDiscount(double discount, uint32_t brightness)
621 {
622 auto safeDiscount = discount;
623 if (safeDiscount > DISCOUNT_MAX) {
624 DISPLAY_HILOGD(COMP_SVC, "discount value is greater than max, discount=%{public}lf", discount);
625 safeDiscount = DISCOUNT_MAX;
626 }
627 if (safeDiscount < DISCOUNT_MIN) {
628 DISPLAY_HILOGD(COMP_SVC, "discount value is less than min, discount=%{public}lf", discount);
629 safeDiscount = DISCOUNT_MIN;
630 }
631 if (static_cast<uint32_t>(BRIGHTNESS_MIN / safeDiscount) > BRIGHTNESS_MAX) {
632 DISPLAY_HILOGD(COMP_SVC, "brightness than max, brightness=%{public}u, discount=%{public}lf",
633 static_cast<uint32_t>(BRIGHTNESS_MIN / safeDiscount), discount);
634 safeDiscount = static_cast<double>(BRIGHTNESS_MIN / static_cast<double>(brightness));
635 }
636
637 return safeDiscount;
638 }
639
CalculateBrightness(float scalar,int32_t & brightness,int32_t & change)640 bool DisplayPowerMgrService::CalculateBrightness(float scalar, int32_t& brightness, int32_t& change)
641 {
642 const float lastLux = lastLux_;
643 if (!IsChangedLux(scalar)) {
644 return false;
645 }
646 int32_t calcBrightness = GetBrightnessFromLightScalar(scalar);
647 int32_t difference = abs(calcBrightness - brightness);
648 DISPLAY_HILOGD(FEAT_BRIGHTNESS, "lux: %{public}f -> %{public}f, screen: %{public}d -> %{public}d",
649 lastLux, scalar, brightness, calcBrightness);
650 if (difference < BRIGHTNESS_CHANGE_MIN
651 || (scalar > lastLux && calcBrightness < brightness)
652 || (scalar < lastLux && calcBrightness > brightness)) {
653 DISPLAY_HILOGI(FEAT_BRIGHTNESS, "screen is too light/dark when calculated change");
654 return false;
655 }
656 brightness = calcBrightness;
657 change = difference;
658 return true;
659 }
660
GetBrightnessFromLightScalar(float scalar)661 int32_t DisplayPowerMgrService::GetBrightnessFromLightScalar(float scalar)
662 {
663 int32_t brightness = static_cast<int32_t>(DisplayAutoBrightness::CalculateAutoBrightness(scalar));
664 DISPLAY_HILOGD(FEAT_BRIGHTNESS, "scalar: %{public}f, brightness: %{public}d", scalar, brightness);
665 if (brightness > BRIGHTNESS_MAX) {
666 brightness = BRIGHTNESS_MAX;
667 } else if (brightness < BRIGHTNESS_MIN) {
668 brightness = BRIGHTNESS_MIN;
669 }
670 return brightness;
671 }
672
GetError()673 DisplayErrors DisplayPowerMgrService::GetError()
674 {
675 DisplayErrors tmpError = lastError_;
676 lastError_ = DisplayErrors::ERR_OK;
677 return tmpError;
678 }
679
OnRemoteDied(const wptr<IRemoteObject> & remote)680 void DisplayPowerMgrService::CallbackDeathRecipient::OnRemoteDied(const wptr<IRemoteObject>& remote)
681 {
682 DISPLAY_HILOGI(COMP_SVC, "CallbackDeathRecipient OnRemoteDied");
683 auto pms = DelayedSpSingleton<DisplayPowerMgrService>::GetInstance();
684 if (pms == nullptr) {
685 DISPLAY_HILOGI(COMP_SVC, "OnRemoteDied no service");
686 return;
687 }
688
689 pms->callback_ = nullptr;
690 }
691 } // namespace DisplayPowerMgr
692 } // namespace OHOS
693