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 if (!Permission::IsSystem()) {
193 return false;
194 }
195 DISPLAY_HILOGI(COMP_SVC, "SetDisplayState %{public}d, %{public}d", id, state);
196 auto iterator = controllerMap_.find(id);
197 if (iterator == controllerMap_.end()) {
198 return false;
199 }
200 if (id == GetMainDisplayId()) {
201 DISPLAY_HILOGI(COMP_SVC, "change ambient sensor status");
202 if (state == DisplayState::DISPLAY_ON) {
203 ActivateAmbientSensor();
204 } else if (state == DisplayState::DISPLAY_OFF) {
205 DeactivateAmbientSensor();
206 }
207 }
208 return iterator->second->UpdateState(state, reason);
209 }
210
GetDisplayState(uint32_t id)211 DisplayState DisplayPowerMgrService::GetDisplayState(uint32_t id)
212 {
213 DISPLAY_HILOGD(COMP_SVC, "GetDisplayState %{public}d", id);
214 auto iterator = controllerMap_.find(id);
215 if (iterator == controllerMap_.end()) {
216 return DisplayState::DISPLAY_UNKNOWN;
217 }
218 return iterator->second->GetState();
219 }
220
GetDisplayIds()221 std::vector<uint32_t> DisplayPowerMgrService::GetDisplayIds()
222 {
223 std::vector<uint32_t> ids;
224 for (auto& iter: controllerMap_) {
225 ids.push_back(iter.first);
226 }
227 return ids;
228 }
229
GetMainDisplayId()230 uint32_t DisplayPowerMgrService::GetMainDisplayId()
231 {
232 uint32_t id = ScreenAction::GetDefaultDisplayId();
233 DISPLAY_HILOGI(COMP_SVC, "GetMainDisplayId %{public}d", id);
234 return id;
235 }
236
SetBrightness(uint32_t value,uint32_t displayId)237 bool DisplayPowerMgrService::SetBrightness(uint32_t value, uint32_t displayId)
238 {
239 if (!Permission::IsSystem()) {
240 lastError_ = DisplayErrors::ERR_PERMISSION_DENIED;
241 return false;
242 }
243 auto brightness = GetSafeBrightness(value);
244 DISPLAY_HILOGI(FEAT_BRIGHTNESS, "SetBrightness displayId=%{public}u, value=%{public}u", displayId, brightness);
245 auto iter = controllerMap_.find(displayId);
246 if (iter == controllerMap_.end()) {
247 return false;
248 }
249 return iter->second->SetBrightness(brightness);
250 }
251
DiscountBrightness(double discount,uint32_t displayId)252 bool DisplayPowerMgrService::DiscountBrightness(double discount, uint32_t displayId)
253 {
254 if (!Permission::IsSystem()) {
255 return false;
256 }
257 auto iter = controllerMap_.find(displayId);
258 if (iter == controllerMap_.end()) {
259 return false;
260 }
261 auto brightness = iter->second->GetBrightness();
262 auto safeDiscount = GetSafeDiscount(discount, brightness);
263 DISPLAY_HILOGI(FEAT_BRIGHTNESS, "DiscountBrightness displayId=%{public}u, discount-%{public}lf",
264 displayId, safeDiscount);
265 HiviewDFX::HiSysEvent::Write("DISPLAY", "BACKLIGHT_DISCOUNT",
266 HiviewDFX::HiSysEvent::EventType::STATISTIC, "RATIO", safeDiscount);
267 return iter->second->DiscountBrightness(safeDiscount);
268 }
269
OverrideBrightness(uint32_t value,uint32_t displayId)270 bool DisplayPowerMgrService::OverrideBrightness(uint32_t value, uint32_t displayId)
271 {
272 if (!Permission::IsSystem()) {
273 return false;
274 }
275 auto brightness = GetSafeBrightness(value);
276 DISPLAY_HILOGI(COMP_SVC, "OverrideBrightness displayId=%{public}u, value=%{public}u", displayId, brightness);
277 auto iter = controllerMap_.find(displayId);
278 if (iter == controllerMap_.end()) {
279 return false;
280 }
281 return iter->second->OverrideBrightness(brightness);
282 }
283
RestoreBrightness(uint32_t displayId)284 bool DisplayPowerMgrService::RestoreBrightness(uint32_t displayId)
285 {
286 if (!Permission::IsSystem()) {
287 return false;
288 }
289 DISPLAY_HILOGI(COMP_SVC, "RestoreBrightness displayId=%{public}u", displayId);
290 auto iter = controllerMap_.find(displayId);
291 if (iter == controllerMap_.end()) {
292 return false;
293 }
294 return iter->second->RestoreBrightness();
295 }
296
GetBrightness(uint32_t displayId)297 uint32_t DisplayPowerMgrService::GetBrightness(uint32_t displayId)
298 {
299 DISPLAY_HILOGD(FEAT_BRIGHTNESS, "GetBrightness displayId=%{public}u", displayId);
300 auto iter = controllerMap_.find(displayId);
301 if (iter == controllerMap_.end()) {
302 return BRIGHTNESS_OFF;
303 }
304 return iter->second->GetBrightness();
305 }
306
GetDefaultBrightness()307 uint32_t DisplayPowerMgrService::GetDefaultBrightness()
308 {
309 return BRIGHTNESS_DEFAULT;
310 }
311
GetMaxBrightness()312 uint32_t DisplayPowerMgrService::GetMaxBrightness()
313 {
314 return BRIGHTNESS_MAX;
315 }
316
GetMinBrightness()317 uint32_t DisplayPowerMgrService::GetMinBrightness()
318 {
319 return BRIGHTNESS_MIN;
320 }
321
AdjustBrightness(uint32_t id,int32_t value,uint32_t duration)322 bool DisplayPowerMgrService::AdjustBrightness(uint32_t id, int32_t value, uint32_t duration)
323 {
324 if (!Permission::IsSystem()) {
325 return false;
326 }
327 DISPLAY_HILOGD(FEAT_BRIGHTNESS, "SetDisplayState %{public}d, %{public}d, %{public}d",
328 id, value, duration);
329 auto iterator = controllerMap_.find(id);
330 if (iterator == controllerMap_.end()) {
331 return false;
332 }
333 return iterator->second->SetBrightness(value, duration);
334 }
335
AutoAdjustBrightness(bool enable)336 bool DisplayPowerMgrService::AutoAdjustBrightness(bool enable)
337 {
338 DISPLAY_HILOGD(FEAT_BRIGHTNESS, "AutoAdjustBrightness start");
339 if (!supportLightSensor_) {
340 DISPLAY_HILOGD(FEAT_BRIGHTNESS, "AutoAdjustBrightness not support");
341 SetSettingAutoBrightness(false);
342 return false;
343 }
344 if (enable) {
345 DISPLAY_HILOGD(FEAT_BRIGHTNESS, "AutoAdjustBrightness enable");
346 if (autoBrightness_) {
347 DISPLAY_HILOGD(FEAT_BRIGHTNESS, "AutoAdjustBrightness is already enabled");
348 return true;
349 }
350 autoBrightness_ = true;
351 if (GetDisplayState(GetMainDisplayId()) == DisplayState::DISPLAY_ON) {
352 ActivateAmbientSensor();
353 }
354 } else {
355 DISPLAY_HILOGD(FEAT_BRIGHTNESS, "AutoAdjustBrightness disable");
356 if (!autoBrightness_) {
357 DISPLAY_HILOGD(FEAT_BRIGHTNESS, "AutoAdjustBrightness is already disabled");
358 return true;
359 }
360 DeactivateAmbientSensor();
361 autoBrightness_ = false;
362 }
363 SetSettingAutoBrightness(enable);
364 return true;
365 }
366
IsAutoAdjustBrightness()367 bool DisplayPowerMgrService::IsAutoAdjustBrightness()
368 {
369 return autoBrightness_;
370 }
371
ActivateAmbientSensor()372 void DisplayPowerMgrService::ActivateAmbientSensor()
373 {
374 if (!autoBrightness_) {
375 DISPLAY_HILOGD(FEAT_BRIGHTNESS, "auto brightness is not enabled");
376 return;
377 }
378 if (ambientSensorEnabled_) {
379 DISPLAY_HILOGD(FEAT_BRIGHTNESS, "Ambient Sensor is already on");
380 return;
381 }
382 (void) strcpy_s(sensorUser_.name, sizeof(sensorUser_.name), "DisplayPowerMgrService");
383 sensorUser_.userData = nullptr;
384 sensorUser_.callback = &AmbientLightCallback;
385 SubscribeSensor(SENSOR_TYPE_ID_AMBIENT_LIGHT, &sensorUser_);
386 SetBatch(SENSOR_TYPE_ID_AMBIENT_LIGHT, &sensorUser_, SAMPLING_RATE, SAMPLING_RATE);
387 ActivateSensor(SENSOR_TYPE_ID_AMBIENT_LIGHT, &sensorUser_);
388 SetMode(SENSOR_TYPE_ID_AMBIENT_LIGHT, &sensorUser_, SENSOR_ON_CHANGE);
389 ambientSensorEnabled_ = true;
390 }
391
DeactivateAmbientSensor()392 void DisplayPowerMgrService::DeactivateAmbientSensor()
393 {
394 if (!autoBrightness_) {
395 DISPLAY_HILOGD(FEAT_BRIGHTNESS, "auto brightness is not enabled");
396 return;
397 }
398 if (!ambientSensorEnabled_) {
399 DISPLAY_HILOGD(FEAT_BRIGHTNESS, "Ambient Sensor is already off");
400 return;
401 }
402 DeactivateSensor(SENSOR_TYPE_ID_AMBIENT_LIGHT, &sensorUser_);
403 UnsubscribeSensor(SENSOR_TYPE_ID_AMBIENT_LIGHT, &sensorUser_);
404 ambientSensorEnabled_ = false;
405 }
406
RegisterCallback(sptr<IDisplayPowerCallback> callback)407 bool DisplayPowerMgrService::RegisterCallback(sptr<IDisplayPowerCallback> callback)
408 {
409 if (!Permission::IsSystem()) {
410 return false;
411 }
412 DISPLAY_HILOGI(COMP_SVC, "RegisterCallback");
413 if (callback_ != nullptr) {
414 DISPLAY_HILOGI(COMP_SVC, "Callback function exist");
415 return false;
416 }
417 callback_ = callback;
418 sptr<IRemoteObject> remote = callback_->AsObject();
419 if (!remote->IsProxyObject()) {
420 DISPLAY_HILOGE(COMP_FWK, "Callback is not proxy");
421 return false;
422 }
423 if (cbDeathRecipient_ == nullptr) {
424 cbDeathRecipient_ = new CallbackDeathRecipient();
425 }
426 remote->AddDeathRecipient(cbDeathRecipient_);
427 return true;
428 }
429
BoostBrightness(int32_t timeoutMs,uint32_t displayId)430 bool DisplayPowerMgrService::BoostBrightness(int32_t timeoutMs, uint32_t displayId)
431 {
432 if (!Permission::IsSystem()) {
433 return false;
434 }
435 DISPLAY_HILOGD(FEAT_BRIGHTNESS, "Timing boost brightness: %{public}d, id: %{public}d", timeoutMs, displayId);
436 RETURN_IF_WITH_RET(timeoutMs <= 0, false);
437 auto iter = controllerMap_.find(displayId);
438 RETURN_IF_WITH_RET(iter == controllerMap_.end(), false);
439 return iter->second->BoostBrightness(timeoutMs);
440 }
441
CancelBoostBrightness(uint32_t displayId)442 bool DisplayPowerMgrService::CancelBoostBrightness(uint32_t displayId)
443 {
444 if (!Permission::IsSystem()) {
445 return false;
446 }
447 DISPLAY_HILOGD(FEAT_BRIGHTNESS, "Cancel boost brightness, id: %{public}d", displayId);
448 auto iter = controllerMap_.find(displayId);
449 RETURN_IF_WITH_RET(iter == controllerMap_.end(), false);
450 return iter->second->CancelBoostBrightness();
451 }
452
GetDeviceBrightness(uint32_t displayId)453 uint32_t DisplayPowerMgrService::GetDeviceBrightness(uint32_t displayId)
454 {
455 DISPLAY_HILOGD(FEAT_BRIGHTNESS, "GetDeviceBrightness displayId=%{public}u", displayId);
456 auto iter = controllerMap_.find(displayId);
457 if (iter == controllerMap_.end()) {
458 return BRIGHTNESS_OFF;
459 }
460 return iter->second->GetDeviceBrightness();
461 }
462
NotifyStateChangeCallback(uint32_t displayId,DisplayState state)463 void DisplayPowerMgrService::NotifyStateChangeCallback(uint32_t displayId, DisplayState state)
464 {
465 if (callback_ != nullptr) {
466 callback_->OnDisplayStateChanged(displayId, state);
467 }
468 }
469
Dump(int32_t fd,const std::vector<std::u16string> & args)470 int32_t DisplayPowerMgrService::Dump(int32_t fd, const std::vector<std::u16string>& args)
471 {
472 if (!Permission::IsSystem()) {
473 return false;
474 }
475 std::string result("DISPLAY POWER MANAGER DUMP:\n");
476 for (auto& iter: controllerMap_) {
477 auto control = iter.second;
478 result.append("Display Id=");
479 result.append(std::to_string(iter.first));
480 result.append(" State=");
481 result.append(std::to_string(static_cast<uint32_t>(control->GetState())));
482 result.append(" Discount=");
483 result.append(std::to_string(control->GetDiscount()));
484 result.append(" Brightness=");
485 result.append(std::to_string(control->GetBrightness()));
486 if (control->IsBrightnessOverridden()) {
487 result.append(" OverrideBrightness=");
488 result.append(std::to_string(control->GetScreenOnBrightness()));
489 }
490 if (control->IsBrightnessBoosted()) {
491 result.append(" BoostBrightness=");
492 result.append(std::to_string(control->GetScreenOnBrightness()));
493 }
494 result.append("\n");
495 result.append("DeviceBrightness=");
496 result.append(std::to_string(control->GetDeviceBrightness()));
497 result.append("\n");
498 }
499
500 result.append("Support Ambient Light: ");
501 if (supportLightSensor_) {
502 result.append("TRUE");
503 } else {
504 result.append("FALSE");
505 }
506 result.append("\n");
507
508 result.append("Auto Adjust Brightness: ");
509 if (autoBrightness_) {
510 result.append("ON");
511 } else {
512 result.append("OFF");
513 }
514 result.append("\n");
515
516 result.append("Brightness Limits: ");
517 result.append("Max=" + std::to_string(GetMaxBrightness()) + " ");
518 result.append("Min=" + std::to_string(GetMinBrightness()) + " ");
519 result.append("Default=" + std::to_string(GetDefaultBrightness()));
520 result.append("\n");
521
522 if (!SaveStringToFd(fd, result)) {
523 DISPLAY_HILOGE(COMP_SVC, "Failed to save dump info to fd");
524 }
525 return ERR_OK;
526 }
527
InitSensors()528 void DisplayPowerMgrService::InitSensors()
529 {
530 DISPLAY_HILOGI(FEAT_BRIGHTNESS, "InitSensors start");
531 SensorInfo* sensorInfo = nullptr;
532 int32_t count;
533 int ret = GetAllSensors(&sensorInfo, &count);
534 if (ret != 0 || sensorInfo == nullptr) {
535 DISPLAY_HILOGI(FEAT_BRIGHTNESS, "Can't get sensors");
536 return;
537 }
538 supportLightSensor_ = false;
539 for (int i = 0; i < count; i++) {
540 if (sensorInfo[i].sensorId == SENSOR_TYPE_ID_AMBIENT_LIGHT) {
541 DISPLAY_HILOGI(FEAT_BRIGHTNESS, "AMBIENT_LIGHT Support");
542 supportLightSensor_ = true;
543 break;
544 }
545 }
546
547 if (!supportLightSensor_) {
548 DISPLAY_HILOGI(FEAT_BRIGHTNESS, "AMBIENT_LIGHT not support");
549 }
550 }
551
AmbientLightCallback(SensorEvent * event)552 void DisplayPowerMgrService::AmbientLightCallback(SensorEvent* event)
553 {
554 if (event->sensorTypeId != SENSOR_TYPE_ID_AMBIENT_LIGHT) {
555 DISPLAY_HILOGI(FEAT_BRIGHTNESS, "Sensor Callback is not AMBIENT_LIGHT");
556 return;
557 }
558 auto pms = DelayedSpSingleton<DisplayPowerMgrService>::GetInstance();
559 if (pms == nullptr) {
560 DISPLAY_HILOGI(FEAT_BRIGHTNESS, "Sensor Callback no service");
561 return;
562 }
563 uint32_t mainDispId = pms->GetMainDisplayId();
564 auto mainDisp = pms->controllerMap_.find(mainDispId);
565 if (mainDisp == pms->controllerMap_.end()) {
566 return;
567 }
568 if (mainDisp->second->IsBrightnessOverridden() || mainDisp->second->IsBrightnessBoosted()) {
569 DISPLAY_HILOGD(FEAT_BRIGHTNESS, "Overwrite or boost brightness scene, auto brightness is invalid");
570 return;
571 }
572 AmbientLightData* data = (AmbientLightData*) event->data;
573 int32_t brightness = static_cast<int32_t>(mainDisp->second->GetBrightness());
574 uint32_t animationUpdateTime = mainDisp->second->GetAnimationUpdateTime();
575 int32_t changeBrightness = 0;
576 if (pms->CalculateBrightness(data->intensity, brightness, changeBrightness)) {
577 double discountStride = static_cast<double>(AUTO_ADJUST_BRIGHTNESS_STRIDE / mainDisp->second->GetDiscount());
578 uint32_t gradualDuration = floor(changeBrightness / discountStride) * animationUpdateTime;
579 pms->AdjustBrightness(mainDispId, brightness, gradualDuration);
580 }
581 // Notify ambient brightness change event to battery statistics
582 HiviewDFX::HiSysEvent::Write("DISPLAY", "AMBIENT_LIGHT",
583 HiviewDFX::HiSysEvent::EventType::STATISTIC, "LEVEL", brightness);
584 }
585
IsChangedLux(float scalar)586 bool DisplayPowerMgrService::IsChangedLux(float scalar)
587 {
588 DISPLAY_HILOGD(FEAT_BRIGHTNESS, "changed: %{public}d, %{public}f vs %{public}f",
589 luxChanged_, lastLux_, scalar);
590 if (lastLuxTime_ <= 0) {
591 DISPLAY_HILOGD(FEAT_BRIGHTNESS, "receive lux at first time");
592 lastLuxTime_ = time(0);
593 lastLux_ = scalar;
594 luxChanged_ = true;
595 return false;
596 }
597
598 if (!luxChanged_) {
599 float luxChangeMin = (lastLux_ / LUX_CHANGE_RATE_THRESHOLD) + 1;
600 if (abs(scalar - lastLux_) < luxChangeMin) {
601 DISPLAY_HILOGD(FEAT_BRIGHTNESS, "Too little change");
602 return false;
603 } else {
604 DISPLAY_HILOGI(FEAT_BRIGHTNESS, "First time to change, wait for stable");
605 luxChanged_ = true;
606 return false;
607 }
608 } else {
609 float luxChangeMin = (lastLux_ / LUX_CHANGE_RATE_THRESHOLD) + 1;
610 if (luxChangeMin < LUX_CHANGE_STABLE_MIN) {
611 luxChangeMin = LUX_CHANGE_STABLE_MIN;
612 }
613 if (abs(scalar - lastLux_) >= luxChangeMin) {
614 time_t currentTime = time(0);
615 time_t sub = currentTime - lastLuxTime_;
616 DISPLAY_HILOGD(FEAT_BRIGHTNESS, "stable lux");
617 if (sub >= LUX_STABLE_TIME) {
618 DISPLAY_HILOGI(FEAT_BRIGHTNESS, "stable enought to change");
619 lastLuxTime_ = time(0);
620 lastLux_ = scalar;
621 luxChanged_ = false;
622 return true;
623 }
624 } else {
625 DISPLAY_HILOGD(FEAT_BRIGHTNESS, "unstable lux, wait for stable");
626 luxChanged_ = true;
627 return false;
628 }
629 }
630 return false;
631 }
632
GetSafeBrightness(uint32_t value)633 uint32_t DisplayPowerMgrService::GetSafeBrightness(uint32_t value)
634 {
635 auto brightnessValue = value;
636 if (brightnessValue > BRIGHTNESS_MAX) {
637 DISPLAY_HILOGD(FEAT_BRIGHTNESS, "brightness value is greater than max, value=%{public}u", value);
638 brightnessValue = BRIGHTNESS_MAX;
639 }
640 if (brightnessValue < BRIGHTNESS_MIN) {
641 DISPLAY_HILOGD(FEAT_BRIGHTNESS, "brightness value is less than min, value=%{public}u", value);
642 brightnessValue = BRIGHTNESS_MIN;
643 }
644 return brightnessValue;
645 }
646
GetSafeDiscount(double discount,uint32_t brightness)647 double DisplayPowerMgrService::GetSafeDiscount(double discount, uint32_t brightness)
648 {
649 auto safeDiscount = discount;
650 if (safeDiscount > DISCOUNT_MAX) {
651 DISPLAY_HILOGD(COMP_SVC, "discount value is greater than max, discount=%{public}lf", discount);
652 safeDiscount = DISCOUNT_MAX;
653 }
654 if (safeDiscount < DISCOUNT_MIN) {
655 DISPLAY_HILOGD(COMP_SVC, "discount value is less than min, discount=%{public}lf", discount);
656 safeDiscount = DISCOUNT_MIN;
657 }
658 if (static_cast<uint32_t>(BRIGHTNESS_MIN / safeDiscount) > BRIGHTNESS_MAX) {
659 DISPLAY_HILOGD(COMP_SVC, "brightness than max, brightness=%{public}u, discount=%{public}lf",
660 static_cast<uint32_t>(BRIGHTNESS_MIN / safeDiscount), discount);
661 safeDiscount = static_cast<double>(BRIGHTNESS_MIN / static_cast<double>(brightness));
662 }
663
664 return safeDiscount;
665 }
666
CalculateBrightness(float scalar,int32_t & brightness,int32_t & change)667 bool DisplayPowerMgrService::CalculateBrightness(float scalar, int32_t& brightness, int32_t& change)
668 {
669 const float lastLux = lastLux_;
670 if (!IsChangedLux(scalar)) {
671 return false;
672 }
673 int32_t calcBrightness = GetBrightnessFromLightScalar(scalar);
674 int32_t difference = abs(calcBrightness - brightness);
675 DISPLAY_HILOGD(FEAT_BRIGHTNESS, "lux: %{public}f -> %{public}f, screen: %{public}d -> %{public}d",
676 lastLux, scalar, brightness, calcBrightness);
677 if (difference < BRIGHTNESS_CHANGE_MIN
678 || (scalar > lastLux && calcBrightness < brightness)
679 || (scalar < lastLux && calcBrightness > brightness)) {
680 DISPLAY_HILOGI(FEAT_BRIGHTNESS, "screen is too light/dark when calculated change");
681 return false;
682 }
683 brightness = calcBrightness;
684 change = difference;
685 return true;
686 }
687
GetBrightnessFromLightScalar(float scalar)688 int32_t DisplayPowerMgrService::GetBrightnessFromLightScalar(float scalar)
689 {
690 int32_t brightness = static_cast<int32_t>(DisplayAutoBrightness::CalculateAutoBrightness(scalar));
691 DISPLAY_HILOGD(FEAT_BRIGHTNESS, "scalar: %{public}f, brightness: %{public}d", scalar, brightness);
692 if (brightness > BRIGHTNESS_MAX) {
693 brightness = BRIGHTNESS_MAX;
694 } else if (brightness < BRIGHTNESS_MIN) {
695 brightness = BRIGHTNESS_MIN;
696 }
697 return brightness;
698 }
699
GetError()700 DisplayErrors DisplayPowerMgrService::GetError()
701 {
702 DisplayErrors tmpError = lastError_;
703 lastError_ = DisplayErrors::ERR_OK;
704 return tmpError;
705 }
706
OnRemoteDied(const wptr<IRemoteObject> & remote)707 void DisplayPowerMgrService::CallbackDeathRecipient::OnRemoteDied(const wptr<IRemoteObject>& remote)
708 {
709 DISPLAY_HILOGI(COMP_SVC, "CallbackDeathRecipient OnRemoteDied");
710 auto pms = DelayedSpSingleton<DisplayPowerMgrService>::GetInstance();
711 if (pms == nullptr) {
712 DISPLAY_HILOGI(COMP_SVC, "OnRemoteDied no service");
713 return;
714 }
715
716 pms->callback_ = nullptr;
717 }
718 } // namespace DisplayPowerMgr
719 } // namespace OHOS
720