1 /*
2 * Copyright (c) 2024-2024 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 <dlfcn.h>
17 #include "brightness_manager_ext.h"
18
19 namespace OHOS {
20 namespace DisplayPowerMgr {
BrightnessManagerExt()21 BrightnessManagerExt::BrightnessManagerExt()
22 {
23 }
24
~BrightnessManagerExt()25 BrightnessManagerExt::~BrightnessManagerExt()
26 {
27 CloseBrightnessExtLibrary();
28 }
29
Init(uint32_t defaultMax,uint32_t defaultMin)30 void BrightnessManagerExt::Init(uint32_t defaultMax, uint32_t defaultMin)
31 {
32 if (!LoadBrightnessExtLibrary()) {
33 return;
34 }
35 auto init = reinterpret_cast<void (*)(uint32_t, uint32_t)>(mBrightnessManagerInitFunc);
36 init(defaultMax, defaultMin);
37 }
38
DeInit()39 void BrightnessManagerExt::DeInit()
40 {
41 auto deInit = reinterpret_cast<void (*)()>(mBrightnessManagerDeInitFunc);
42 if (deInit) {
43 deInit();
44 }
45 CloseBrightnessExtLibrary();
46 }
47
LoadBrightnessExtLibrary()48 bool BrightnessManagerExt::LoadBrightnessExtLibrary()
49 {
50 #ifndef FUZZ_TEST
51 mBrightnessManagerExtHandle = dlopen("libbrightness_wrapper.z.so", RTLD_NOW);
52 #endif
53 if (!mBrightnessManagerExtHandle) {
54 DISPLAY_HILOGE(FEAT_BRIGHTNESS, "dlopen libbrightness_wrapper.z.so failed!");
55 return false;
56 }
57 if (LoadBrightnessOps() && LoadBrightnessOpsEx1() && LoadBrightnessStatus() && LoadBrightnessControl()) {
58 mBrightnessManagerExtEnable = true;
59 } else {
60 mBrightnessManagerExtEnable = false;
61 CloseBrightnessExtLibrary();
62 }
63 return mBrightnessManagerExtEnable;
64 }
65
LoadBrightnessOps()66 bool BrightnessManagerExt::LoadBrightnessOps()
67 {
68 mBrightnessManagerInitFunc = dlsym(mBrightnessManagerExtHandle, "Init");
69 if (!mBrightnessManagerInitFunc) {
70 return false;
71 }
72 mBrightnessManagerDeInitFunc = dlsym(mBrightnessManagerExtHandle, "DeInit");
73 if (!mBrightnessManagerDeInitFunc) {
74 return false;
75 }
76 mGetCurrentDisplayIdFunc = dlsym(mBrightnessManagerExtHandle, "GetCurrentDisplayId");
77 if (!mGetCurrentDisplayIdFunc) {
78 DISPLAY_HILOGE(FEAT_BRIGHTNESS, "dlsym GetCurrentDisplayId func failed!");
79 return false;
80 }
81 mSetDisplayIdFunc = dlsym(mBrightnessManagerExtHandle, "SetDisplayId");
82 if (!mSetDisplayIdFunc) {
83 DISPLAY_HILOGE(FEAT_BRIGHTNESS, "dlsym SetDisplayId func failed!");
84 return false;
85 }
86 mSetLightBrightnessThresholdFunc = dlsym(mBrightnessManagerExtHandle, "SetLightBrightnessThreshold");
87 if (!mSetLightBrightnessThresholdFunc) {
88 DISPLAY_HILOGE(FEAT_BRIGHTNESS, "dlsym SetLightBrightnessThreshold func failed!");
89 return false;
90 }
91 mSetMaxBrightnessFunc = dlsym(mBrightnessManagerExtHandle, "SetMaxBrightness");
92 if (!mSetMaxBrightnessFunc) {
93 DISPLAY_HILOGE(FEAT_BRIGHTNESS, "dlsym SetMaxBrightness func failed!");
94 return false;
95 }
96 mSetMaxBrightnessNitFunc = dlsym(mBrightnessManagerExtHandle, "SetMaxBrightnessNit");
97 if (!mSetMaxBrightnessNitFunc) {
98 DISPLAY_HILOGE(FEAT_BRIGHTNESS, "dlsym SetMaxBrightnessNit func failed!");
99 return false;
100 }
101 return true;
102 }
103
LoadBrightnessOpsEx1()104 bool BrightnessManagerExt::LoadBrightnessOpsEx1()
105 {
106 mIsSupportLightSensorFunc = dlsym(mBrightnessManagerExtHandle, "IsSupportLightSensor");
107 if (!mIsSupportLightSensorFunc) {
108 DISPLAY_HILOGE(FEAT_BRIGHTNESS, "dlsym IsSupportLightSensor func failed!");
109 return false;
110 }
111 mIsAutoAdjustBrightnessFunc = dlsym(mBrightnessManagerExtHandle, "IsAutoAdjustBrightness");
112 if (!mIsAutoAdjustBrightnessFunc) {
113 DISPLAY_HILOGE(FEAT_BRIGHTNESS, "dlsym IsAutoAdjustBrightness func failed!");
114 return false;
115 }
116 return true;
117 }
118
LoadBrightnessStatus()119 bool BrightnessManagerExt::LoadBrightnessStatus()
120 {
121 mSetDisplayStateFunc = dlsym(mBrightnessManagerExtHandle, "SetDisplayState");
122 if (!mSetDisplayStateFunc) {
123 DISPLAY_HILOGE(FEAT_BRIGHTNESS, "dlsym SetDisplayState func failed!");
124 return false;
125 }
126 mGetDisplayStateFunc = dlsym(mBrightnessManagerExtHandle, "GetDisplayState");
127 if (!mGetDisplayStateFunc) {
128 DISPLAY_HILOGE(FEAT_BRIGHTNESS, "dlsym GetDisplayState func failed!");
129 return false;
130 }
131 mGetDiscountFunc = dlsym(mBrightnessManagerExtHandle, "GetDiscount");
132 if (!mGetDiscountFunc) {
133 DISPLAY_HILOGE(FEAT_BRIGHTNESS, "dlsym GetDiscount func failed!");
134 return false;
135 }
136 mGetScreenOnBrightnessFunc = dlsym(mBrightnessManagerExtHandle, "GetScreenOnBrightness");
137 if (!mGetScreenOnBrightnessFunc) {
138 DISPLAY_HILOGE(FEAT_BRIGHTNESS, "dlsym GetScreenOnBrightness func failed!");
139 return false;
140 }
141 mCancelBoostBrightnessFunc = dlsym(mBrightnessManagerExtHandle, "CancelBoostBrightness");
142 if (!mCancelBoostBrightnessFunc) {
143 DISPLAY_HILOGE(FEAT_BRIGHTNESS, "dlsym CancelBoostBrightness func failed!");
144 return false;
145 }
146 mIsBrightnessOverriddenFunc = dlsym(mBrightnessManagerExtHandle, "IsBrightnessOverridden");
147 if (!mIsBrightnessOverriddenFunc) {
148 DISPLAY_HILOGE(FEAT_BRIGHTNESS, "dlsym IsBrightnessOverridden func failed!");
149 return false;
150 }
151 mIsBrightnessBoostedFunc = dlsym(mBrightnessManagerExtHandle, "IsBrightnessBoosted");
152 if (!mIsBrightnessBoostedFunc) {
153 DISPLAY_HILOGE(FEAT_BRIGHTNESS, "dlsym IsBrightnessBoosted func failed!");
154 return false;
155 }
156 mGetBrightnessFunc = dlsym(mBrightnessManagerExtHandle, "GetBrightness");
157 if (!mGetBrightnessFunc) {
158 DISPLAY_HILOGE(FEAT_BRIGHTNESS, "dlsym GetBrightness func failed!");
159 return false;
160 }
161 mGetDeviceBrightnessFunc = dlsym(mBrightnessManagerExtHandle, "GetDeviceBrightness");
162 if (!mGetDeviceBrightnessFunc) {
163 DISPLAY_HILOGE(FEAT_BRIGHTNESS, "dlsym GetDeviceBrightness func failed!");
164 return false;
165 }
166 return true;
167 }
168
LoadBrightnessControl()169 bool BrightnessManagerExt::LoadBrightnessControl()
170 {
171 mAutoAdjustBrightnessFunc = dlsym(mBrightnessManagerExtHandle, "AutoAdjustBrightness");
172 if (!mAutoAdjustBrightnessFunc) {
173 DISPLAY_HILOGE(FEAT_BRIGHTNESS, "dlsym AutoAdjustBrightness func failed!");
174 return false;
175 }
176 mSetBrightnessFunc = dlsym(mBrightnessManagerExtHandle, "SetBrightness");
177 if (!mSetBrightnessFunc) {
178 DISPLAY_HILOGE(FEAT_BRIGHTNESS, "dlsym SetBrightness func failed!");
179 return false;
180 }
181 mDiscountBrightnessFunc = dlsym(mBrightnessManagerExtHandle, "DiscountBrightness");
182 if (!mDiscountBrightnessFunc) {
183 DISPLAY_HILOGE(FEAT_BRIGHTNESS, "dlsym DiscountBrightness func failed!");
184 return false;
185 }
186 mSetScreenOnBrightnessFunc = dlsym(mBrightnessManagerExtHandle, "SetScreenOnBrightness");
187 if (!mSetScreenOnBrightnessFunc) {
188 DISPLAY_HILOGE(FEAT_BRIGHTNESS, "dlsym SetScreenOnBrightness func failed!");
189 return false;
190 }
191 mOverrideBrightnessFunc = dlsym(mBrightnessManagerExtHandle, "OverrideBrightness");
192 if (!mOverrideBrightnessFunc) {
193 DISPLAY_HILOGE(FEAT_BRIGHTNESS, "dlsym OverrideBrightness func failed!");
194 return false;
195 }
196 mRestoreBrightnessFunc = dlsym(mBrightnessManagerExtHandle, "RestoreBrightness");
197 if (!mRestoreBrightnessFunc) {
198 DISPLAY_HILOGE(FEAT_BRIGHTNESS, "dlsym RestoreBrightness func failed!");
199 return false;
200 }
201 mBoostBrightnessFunc = dlsym(mBrightnessManagerExtHandle, "BoostBrightness");
202 if (!mBoostBrightnessFunc) {
203 DISPLAY_HILOGE(FEAT_BRIGHTNESS, "dlsym BoostBrightness func failed!");
204 return false;
205 }
206 mClearOffsetFunc = dlsym(mBrightnessManagerExtHandle, "ClearOffset");
207 if (!mClearOffsetFunc) {
208 DISPLAY_HILOGE(FEAT_BRIGHTNESS, "dlsym ClearOffset func failed!");
209 return false;
210 }
211 mNotifyScreenPowerStatusFunc = dlsym(mBrightnessManagerExtHandle, "NotifyScreenPowerStatus");
212 if (!mNotifyScreenPowerStatusFunc) {
213 DISPLAY_HILOGE(FEAT_BRIGHTNESS, "dlsym mNotifyScreenPowerStatusFunc func failed!");
214 return false;
215 }
216 return true;
217 }
218
CloseBrightnessExtLibrary()219 void BrightnessManagerExt::CloseBrightnessExtLibrary()
220 {
221 if (mBrightnessManagerExtHandle) {
222 #ifndef FUZZ_TEST
223 dlclose(mBrightnessManagerExtHandle);
224 #endif
225 mBrightnessManagerExtHandle = nullptr;
226 }
227 mBrightnessManagerInitFunc = nullptr;
228 mBrightnessManagerDeInitFunc = nullptr;
229 mSetDisplayStateFunc = nullptr;
230 mGetDisplayStateFunc = nullptr;
231 mIsSupportLightSensorFunc = nullptr;
232 mIsAutoAdjustBrightnessFunc = nullptr;
233 mAutoAdjustBrightnessFunc = nullptr;
234 mSetBrightnessFunc = nullptr;
235 mDiscountBrightnessFunc = nullptr;
236 mGetDiscountFunc = nullptr;
237 mSetScreenOnBrightnessFunc = nullptr;
238 mGetScreenOnBrightnessFunc = nullptr;
239 mOverrideBrightnessFunc = nullptr;
240 mRestoreBrightnessFunc = nullptr;
241 mBoostBrightnessFunc = nullptr;
242 mCancelBoostBrightnessFunc = nullptr;
243 mIsBrightnessOverriddenFunc = nullptr;
244 mIsBrightnessBoostedFunc = nullptr;
245 mGetBrightnessFunc = nullptr;
246 mGetDeviceBrightnessFunc = nullptr;
247 mClearOffsetFunc = nullptr;
248 mGetCurrentDisplayIdFunc = nullptr;
249 mSetDisplayIdFunc = nullptr;
250 mSetMaxBrightnessFunc = nullptr;
251 mSetMaxBrightnessNitFunc = nullptr;
252 mNotifyScreenPowerStatusFunc = nullptr;
253 }
254
SetDisplayState(uint32_t id,DisplayState state,uint32_t reason)255 void BrightnessManagerExt::SetDisplayState(uint32_t id, DisplayState state, uint32_t reason)
256 {
257 if (!mBrightnessManagerExtEnable) {
258 return;
259 }
260 auto setDisplayStateFunc = reinterpret_cast<void (*)(uint32_t, DisplayState state, uint32_t reason)>
261 (mSetDisplayStateFunc);
262 setDisplayStateFunc(id, state, reason);
263 }
264
GetState()265 DisplayState BrightnessManagerExt::GetState()
266 {
267 if (!mBrightnessManagerExtEnable) {
268 return DisplayState::DISPLAY_UNKNOWN;
269 }
270 auto getDisplayStateFunc = reinterpret_cast<DisplayState (*)()>(mGetDisplayStateFunc);
271 return getDisplayStateFunc();
272 }
273
IsSupportLightSensor(void)274 bool BrightnessManagerExt::IsSupportLightSensor(void)
275 {
276 if (!mBrightnessManagerExtEnable) {
277 return false;
278 }
279 auto isSupportLightSensorFunc = reinterpret_cast<bool (*)()>(mIsSupportLightSensorFunc);
280 return isSupportLightSensorFunc();
281 }
282
IsAutoAdjustBrightness(void)283 bool BrightnessManagerExt::IsAutoAdjustBrightness(void)
284 {
285 if (!mBrightnessManagerExtEnable) {
286 return false;
287 }
288 auto isAutoAdjustBrightnessFunc = reinterpret_cast<bool (*)()>(mIsAutoAdjustBrightnessFunc);
289 return isAutoAdjustBrightnessFunc();
290 }
291
AutoAdjustBrightness(bool enable)292 bool BrightnessManagerExt::AutoAdjustBrightness(bool enable)
293 {
294 if (!mBrightnessManagerExtEnable) {
295 return false;
296 }
297 auto autoAdjustBrightnessFunc = reinterpret_cast<bool (*)(bool)>(mAutoAdjustBrightnessFunc);
298 return autoAdjustBrightnessFunc(enable);
299 }
300
SetBrightness(uint32_t value,uint32_t gradualDuration,bool continuous)301 bool BrightnessManagerExt::SetBrightness(uint32_t value, uint32_t gradualDuration, bool continuous)
302 {
303 if (!mBrightnessManagerExtEnable) {
304 return false;
305 }
306 auto setBrightnessFunc = reinterpret_cast<bool (*)(uint32_t, uint32_t, bool)>(mSetBrightnessFunc);
307 return setBrightnessFunc(value, gradualDuration, continuous);
308 }
309
DiscountBrightness(double discount)310 bool BrightnessManagerExt::DiscountBrightness(double discount)
311 {
312 if (!mBrightnessManagerExtEnable) {
313 return false;
314 }
315 auto discountBrightnessFunc = reinterpret_cast<bool (*)(double)>(mDiscountBrightnessFunc);
316 return discountBrightnessFunc(discount);
317 }
318
GetDiscount() const319 double BrightnessManagerExt::GetDiscount() const
320 {
321 if (!mBrightnessManagerExtEnable) {
322 return 1.0;
323 }
324 auto getDiscountFunc = reinterpret_cast<double (*)()>(mGetDiscountFunc);
325 return getDiscountFunc();
326 }
327
SetScreenOnBrightness()328 void BrightnessManagerExt::SetScreenOnBrightness()
329 {
330 if (!mBrightnessManagerExtEnable) {
331 return;
332 }
333 auto setScreenOnBrightnessFunc = reinterpret_cast<void (*)()>(mSetScreenOnBrightnessFunc);
334 setScreenOnBrightnessFunc();
335 }
336
GetScreenOnBrightness() const337 uint32_t BrightnessManagerExt::GetScreenOnBrightness() const
338 {
339 if (!mBrightnessManagerExtEnable) {
340 return 0;
341 }
342 auto getScreenOnBrightnessFunc = reinterpret_cast<uint32_t (*)(bool)>(mGetScreenOnBrightnessFunc);
343 return getScreenOnBrightnessFunc(false);
344 }
345
ClearOffset()346 void BrightnessManagerExt::ClearOffset()
347 {
348 if (!mBrightnessManagerExtEnable) {
349 return;
350 }
351 auto clearOffsetFunc = reinterpret_cast<void (*)()>(mClearOffsetFunc);
352 clearOffsetFunc();
353 }
354
OverrideBrightness(uint32_t value,uint32_t gradualDuration)355 bool BrightnessManagerExt::OverrideBrightness(uint32_t value, uint32_t gradualDuration)
356 {
357 if (!mBrightnessManagerExtEnable) {
358 return false;
359 }
360 auto overrideBrightnessFunc = reinterpret_cast<bool (*)(uint32_t, uint32_t)>(mOverrideBrightnessFunc);
361 return overrideBrightnessFunc(value, gradualDuration);
362 }
363
RestoreBrightness(uint32_t gradualDuration)364 bool BrightnessManagerExt::RestoreBrightness(uint32_t gradualDuration)
365 {
366 if (!mBrightnessManagerExtEnable) {
367 return false;
368 }
369 auto restoreBrightnessFunc = reinterpret_cast<bool (*)(uint32_t)>(mRestoreBrightnessFunc);
370 return restoreBrightnessFunc(gradualDuration);
371 }
372
BoostBrightness(uint32_t timeoutMs,uint32_t gradualDuration)373 bool BrightnessManagerExt::BoostBrightness(uint32_t timeoutMs, uint32_t gradualDuration)
374 {
375 if (!mBrightnessManagerExtEnable) {
376 return false;
377 }
378 auto boostBrightnessFunc = reinterpret_cast<bool (*)(uint32_t, uint32_t)>(mBoostBrightnessFunc);
379 return boostBrightnessFunc(timeoutMs, gradualDuration);
380 }
381
CancelBoostBrightness(uint32_t gradualDuration)382 bool BrightnessManagerExt::CancelBoostBrightness(uint32_t gradualDuration)
383 {
384 if (!mBrightnessManagerExtEnable) {
385 return false;
386 }
387 auto cancelBoostBrightnessFunc = reinterpret_cast<bool (*)(uint32_t)>(mCancelBoostBrightnessFunc);
388 return cancelBoostBrightnessFunc(gradualDuration);
389 }
390
GetBrightness()391 uint32_t BrightnessManagerExt::GetBrightness()
392 {
393 if (!mBrightnessManagerExtEnable) {
394 return 0;
395 }
396 auto getBrightnessFunc = reinterpret_cast<uint32_t (*)()>(mGetBrightnessFunc);
397 return getBrightnessFunc();
398 }
399
GetDeviceBrightness()400 uint32_t BrightnessManagerExt::GetDeviceBrightness()
401 {
402 if (!mBrightnessManagerExtEnable) {
403 return 0;
404 }
405 auto getDeviceBrightnessFunc = reinterpret_cast<uint32_t (*)()>(mGetDeviceBrightnessFunc);
406 return getDeviceBrightnessFunc();
407 }
408
IsBrightnessOverridden() const409 bool BrightnessManagerExt::IsBrightnessOverridden() const
410 {
411 if (!mBrightnessManagerExtEnable) {
412 return false;
413 }
414 auto isBrightnessOverriddenFunc = reinterpret_cast<bool (*)()>(mIsBrightnessOverriddenFunc);
415 return isBrightnessOverriddenFunc();
416 }
417
IsBrightnessBoosted() const418 bool BrightnessManagerExt::IsBrightnessBoosted() const
419 {
420 if (!mBrightnessManagerExtEnable) {
421 return false;
422 }
423 auto isBrightnessBoostedFunc = reinterpret_cast<bool (*)()>(mIsBrightnessBoostedFunc);
424 return isBrightnessBoostedFunc();
425 }
426
GetCurrentDisplayId(uint32_t defaultId) const427 uint32_t BrightnessManagerExt::GetCurrentDisplayId(uint32_t defaultId) const
428 {
429 if (!mBrightnessManagerExtEnable) {
430 return defaultId;
431 }
432 auto getCurrentDisplayIdFunc = reinterpret_cast<uint32_t (*)(uint32_t)>(mGetCurrentDisplayIdFunc);
433 return getCurrentDisplayIdFunc(defaultId);
434 }
435
SetDisplayId(uint32_t id)436 void BrightnessManagerExt::SetDisplayId(uint32_t id)
437 {
438 if (!mBrightnessManagerExtEnable) {
439 return;
440 }
441 auto setDisplayIdFunc = reinterpret_cast<void (*)(uint32_t)>(mSetDisplayIdFunc);
442 setDisplayIdFunc(id);
443 }
444
SetLightBrightnessThreshold(std::vector<int32_t> threshold,sptr<IDisplayBrightnessCallback> callback)445 uint32_t BrightnessManagerExt::SetLightBrightnessThreshold(
446 std::vector<int32_t> threshold, sptr<IDisplayBrightnessCallback> callback)
447 {
448 uint32_t result = 0;
449 if (!mBrightnessManagerExtEnable) {
450 return result;
451 }
452 auto setLightBrightnessThresholdFunc =
453 reinterpret_cast<uint32_t (*)(std::vector<int32_t>, sptr<IDisplayBrightnessCallback>)>(
454 mSetLightBrightnessThresholdFunc);
455 if (!setLightBrightnessThresholdFunc) {
456 return result;
457 }
458 return setLightBrightnessThresholdFunc(threshold, callback);
459 }
460
SetMaxBrightness(double value)461 bool BrightnessManagerExt::SetMaxBrightness(double value)
462 {
463 if (!mBrightnessManagerExtEnable) {
464 return false;
465 }
466 auto setMaxBrightnessFunc = reinterpret_cast<bool (*)(double)>(mSetMaxBrightnessFunc);
467 return setMaxBrightnessFunc(value);
468 }
469
SetMaxBrightnessNit(uint32_t nit)470 bool BrightnessManagerExt::SetMaxBrightnessNit(uint32_t nit)
471 {
472 if (!mBrightnessManagerExtEnable) {
473 return false;
474 }
475 auto setMaxBrightnessNitFunc = reinterpret_cast<bool (*)(uint32_t)>(mSetMaxBrightnessNitFunc);
476 return setMaxBrightnessNitFunc(nit);
477 }
478
NotifyScreenPowerStatus(uint32_t displayId,uint32_t status)479 int BrightnessManagerExt::NotifyScreenPowerStatus(uint32_t displayId, uint32_t status)
480 {
481 if (!mBrightnessManagerExtEnable) {
482 return -1; // -1 means return failed
483 }
484 auto NotifyScreenPowerStatusFunc =
485 reinterpret_cast<int (*)(uint32_t, uint32_t)>(mNotifyScreenPowerStatusFunc);
486 return NotifyScreenPowerStatusFunc(displayId, status);
487 }
488 } // namespace DisplayPowerMgr
489 } // namespace OHOS