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() && 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 
LoadBrightnessStatus()104 bool BrightnessManagerExt::LoadBrightnessStatus()
105 {
106     mSetDisplayStateFunc = dlsym(mBrightnessManagerExtHandle, "SetDisplayState");
107     if (!mSetDisplayStateFunc) {
108         DISPLAY_HILOGE(FEAT_BRIGHTNESS, "dlsym SetDisplayState func failed!");
109         return false;
110     }
111     mGetDisplayStateFunc = dlsym(mBrightnessManagerExtHandle, "GetDisplayState");
112     if (!mGetDisplayStateFunc) {
113         DISPLAY_HILOGE(FEAT_BRIGHTNESS, "dlsym GetDisplayState func failed!");
114         return false;
115     }
116     mGetDiscountFunc = dlsym(mBrightnessManagerExtHandle, "GetDiscount");
117     if (!mGetDiscountFunc) {
118         DISPLAY_HILOGE(FEAT_BRIGHTNESS, "dlsym GetDiscount func failed!");
119         return false;
120     }
121     mGetScreenOnBrightnessFunc = dlsym(mBrightnessManagerExtHandle, "GetScreenOnBrightness");
122     if (!mGetScreenOnBrightnessFunc) {
123         DISPLAY_HILOGE(FEAT_BRIGHTNESS, "dlsym GetScreenOnBrightness func failed!");
124         return false;
125     }
126     mCancelBoostBrightnessFunc = dlsym(mBrightnessManagerExtHandle, "CancelBoostBrightness");
127     if (!mCancelBoostBrightnessFunc) {
128         DISPLAY_HILOGE(FEAT_BRIGHTNESS, "dlsym CancelBoostBrightness func failed!");
129         return false;
130     }
131     mIsBrightnessOverriddenFunc = dlsym(mBrightnessManagerExtHandle, "IsBrightnessOverridden");
132     if (!mIsBrightnessOverriddenFunc) {
133         DISPLAY_HILOGE(FEAT_BRIGHTNESS, "dlsym IsBrightnessOverridden func failed!");
134         return false;
135     }
136     mIsBrightnessBoostedFunc = dlsym(mBrightnessManagerExtHandle, "IsBrightnessBoosted");
137     if (!mIsBrightnessBoostedFunc) {
138         DISPLAY_HILOGE(FEAT_BRIGHTNESS, "dlsym IsBrightnessBoosted func failed!");
139         return false;
140     }
141     mGetBrightnessFunc = dlsym(mBrightnessManagerExtHandle, "GetBrightness");
142     if (!mGetBrightnessFunc) {
143         DISPLAY_HILOGE(FEAT_BRIGHTNESS, "dlsym GetBrightness func failed!");
144         return false;
145     }
146     mGetDeviceBrightnessFunc = dlsym(mBrightnessManagerExtHandle, "GetDeviceBrightness");
147     if (!mGetDeviceBrightnessFunc) {
148         DISPLAY_HILOGE(FEAT_BRIGHTNESS, "dlsym GetDeviceBrightness func failed!");
149         return false;
150     }
151     return true;
152 }
153 
LoadBrightnessControl()154 bool BrightnessManagerExt::LoadBrightnessControl()
155 {
156     mAutoAdjustBrightnessFunc = dlsym(mBrightnessManagerExtHandle, "AutoAdjustBrightness");
157     if (!mAutoAdjustBrightnessFunc) {
158         DISPLAY_HILOGE(FEAT_BRIGHTNESS, "dlsym AutoAdjustBrightness func failed!");
159         return false;
160     }
161     mSetBrightnessFunc = dlsym(mBrightnessManagerExtHandle, "SetBrightness");
162     if (!mSetBrightnessFunc) {
163         DISPLAY_HILOGE(FEAT_BRIGHTNESS, "dlsym SetBrightness func failed!");
164         return false;
165     }
166     mDiscountBrightnessFunc = dlsym(mBrightnessManagerExtHandle, "DiscountBrightness");
167     if (!mDiscountBrightnessFunc) {
168         DISPLAY_HILOGE(FEAT_BRIGHTNESS, "dlsym DiscountBrightness func failed!");
169         return false;
170     }
171     mSetScreenOnBrightnessFunc = dlsym(mBrightnessManagerExtHandle, "SetScreenOnBrightness");
172     if (!mSetScreenOnBrightnessFunc) {
173         DISPLAY_HILOGE(FEAT_BRIGHTNESS, "dlsym SetScreenOnBrightness func failed!");
174         return false;
175     }
176     mOverrideBrightnessFunc = dlsym(mBrightnessManagerExtHandle, "OverrideBrightness");
177     if (!mOverrideBrightnessFunc) {
178         DISPLAY_HILOGE(FEAT_BRIGHTNESS, "dlsym OverrideBrightness func failed!");
179         return false;
180     }
181     mRestoreBrightnessFunc = dlsym(mBrightnessManagerExtHandle, "RestoreBrightness");
182     if (!mRestoreBrightnessFunc) {
183         DISPLAY_HILOGE(FEAT_BRIGHTNESS, "dlsym RestoreBrightness func failed!");
184         return false;
185     }
186     mBoostBrightnessFunc = dlsym(mBrightnessManagerExtHandle, "BoostBrightness");
187     if (!mBoostBrightnessFunc) {
188         DISPLAY_HILOGE(FEAT_BRIGHTNESS, "dlsym BoostBrightness func failed!");
189         return false;
190     }
191     mClearOffsetFunc = dlsym(mBrightnessManagerExtHandle, "ClearOffset");
192     if (!mClearOffsetFunc) {
193         DISPLAY_HILOGE(FEAT_BRIGHTNESS, "dlsym ClearOffset func failed!");
194         return false;
195     }
196     return true;
197 }
198 
CloseBrightnessExtLibrary()199 void BrightnessManagerExt::CloseBrightnessExtLibrary()
200 {
201     if (mBrightnessManagerExtHandle) {
202 #ifndef FUZZ_TEST
203         dlclose(mBrightnessManagerExtHandle);
204 #endif
205         mBrightnessManagerExtHandle = nullptr;
206     }
207     mBrightnessManagerInitFunc = nullptr;
208     mBrightnessManagerDeInitFunc = nullptr;
209     mSetDisplayStateFunc = nullptr;
210     mGetDisplayStateFunc = nullptr;
211     mAutoAdjustBrightnessFunc = nullptr;
212     mSetBrightnessFunc = nullptr;
213     mDiscountBrightnessFunc = nullptr;
214     mGetDiscountFunc = nullptr;
215     mSetScreenOnBrightnessFunc = nullptr;
216     mGetScreenOnBrightnessFunc = nullptr;
217     mOverrideBrightnessFunc = nullptr;
218     mRestoreBrightnessFunc = nullptr;
219     mBoostBrightnessFunc = nullptr;
220     mCancelBoostBrightnessFunc = nullptr;
221     mIsBrightnessOverriddenFunc = nullptr;
222     mIsBrightnessBoostedFunc = nullptr;
223     mGetBrightnessFunc = nullptr;
224     mGetDeviceBrightnessFunc = nullptr;
225     mClearOffsetFunc = nullptr;
226     mGetCurrentDisplayIdFunc = nullptr;
227     mSetDisplayIdFunc = nullptr;
228     mSetMaxBrightnessFunc = nullptr;
229     mSetMaxBrightnessNitFunc = nullptr;
230 }
231 
SetDisplayState(uint32_t id,DisplayState state)232 void BrightnessManagerExt::SetDisplayState(uint32_t id, DisplayState state)
233 {
234     if (!mBrightnessManagerExtEnable) {
235         return;
236     }
237     auto setDisplayStateFunc = reinterpret_cast<void (*)(uint32_t, DisplayState state)>(mSetDisplayStateFunc);
238     setDisplayStateFunc(id, state);
239 }
240 
GetState()241 DisplayState BrightnessManagerExt::GetState()
242 {
243     if (!mBrightnessManagerExtEnable) {
244         return DisplayState::DISPLAY_UNKNOWN;
245     }
246     auto getDisplayStateFunc = reinterpret_cast<DisplayState (*)()>(mGetDisplayStateFunc);
247     return getDisplayStateFunc();
248 }
249 
AutoAdjustBrightness(bool enable)250 bool BrightnessManagerExt::AutoAdjustBrightness(bool enable)
251 {
252     if (!mBrightnessManagerExtEnable) {
253         return false;
254     }
255     auto autoAdjustBrightnessFunc = reinterpret_cast<bool (*)(bool)>(mAutoAdjustBrightnessFunc);
256     return autoAdjustBrightnessFunc(enable);
257 }
258 
SetBrightness(uint32_t value,uint32_t gradualDuration,bool continuous)259 bool BrightnessManagerExt::SetBrightness(uint32_t value, uint32_t gradualDuration, bool continuous)
260 {
261     if (!mBrightnessManagerExtEnable) {
262         return false;
263     }
264     auto setBrightnessFunc = reinterpret_cast<bool (*)(uint32_t, uint32_t, bool)>(mSetBrightnessFunc);
265     return setBrightnessFunc(value, gradualDuration, continuous);
266 }
267 
DiscountBrightness(double discount)268 bool BrightnessManagerExt::DiscountBrightness(double discount)
269 {
270     if (!mBrightnessManagerExtEnable) {
271         return false;
272     }
273     auto discountBrightnessFunc = reinterpret_cast<bool (*)(double)>(mDiscountBrightnessFunc);
274     return discountBrightnessFunc(discount);
275 }
276 
GetDiscount() const277 double BrightnessManagerExt::GetDiscount() const
278 {
279     if (!mBrightnessManagerExtEnable) {
280         return 1.0;
281     }
282     auto getDiscountFunc = reinterpret_cast<double (*)()>(mGetDiscountFunc);
283     return getDiscountFunc();
284 }
285 
SetScreenOnBrightness()286 void BrightnessManagerExt::SetScreenOnBrightness()
287 {
288     if (!mBrightnessManagerExtEnable) {
289         return;
290     }
291     auto setScreenOnBrightnessFunc = reinterpret_cast<void (*)()>(mSetScreenOnBrightnessFunc);
292     setScreenOnBrightnessFunc();
293 }
294 
GetScreenOnBrightness() const295 uint32_t BrightnessManagerExt::GetScreenOnBrightness() const
296 {
297     if (!mBrightnessManagerExtEnable) {
298         return 0;
299     }
300     auto getScreenOnBrightnessFunc = reinterpret_cast<uint32_t (*)(bool)>(mGetScreenOnBrightnessFunc);
301     return getScreenOnBrightnessFunc(false);
302 }
303 
ClearOffset()304 void BrightnessManagerExt::ClearOffset()
305 {
306     if (!mBrightnessManagerExtEnable) {
307         return;
308     }
309     auto clearOffsetFunc = reinterpret_cast<void (*)()>(mClearOffsetFunc);
310     clearOffsetFunc();
311 }
312 
OverrideBrightness(uint32_t value,uint32_t gradualDuration)313 bool BrightnessManagerExt::OverrideBrightness(uint32_t value, uint32_t gradualDuration)
314 {
315     if (!mBrightnessManagerExtEnable) {
316         return false;
317     }
318     auto overrideBrightnessFunc = reinterpret_cast<bool (*)(uint32_t, uint32_t)>(mOverrideBrightnessFunc);
319     return overrideBrightnessFunc(value, gradualDuration);
320 }
321 
RestoreBrightness(uint32_t gradualDuration)322 bool BrightnessManagerExt::RestoreBrightness(uint32_t gradualDuration)
323 {
324     if (!mBrightnessManagerExtEnable) {
325         return false;
326     }
327     auto restoreBrightnessFunc = reinterpret_cast<bool (*)(uint32_t)>(mRestoreBrightnessFunc);
328     return restoreBrightnessFunc(gradualDuration);
329 }
330 
BoostBrightness(uint32_t timeoutMs,uint32_t gradualDuration)331 bool BrightnessManagerExt::BoostBrightness(uint32_t timeoutMs, uint32_t gradualDuration)
332 {
333     if (!mBrightnessManagerExtEnable) {
334         return false;
335     }
336     auto boostBrightnessFunc = reinterpret_cast<bool (*)(uint32_t, uint32_t)>(mBoostBrightnessFunc);
337     return boostBrightnessFunc(timeoutMs, gradualDuration);
338 }
339 
CancelBoostBrightness(uint32_t gradualDuration)340 bool BrightnessManagerExt::CancelBoostBrightness(uint32_t gradualDuration)
341 {
342     if (!mBrightnessManagerExtEnable) {
343         return false;
344     }
345     auto cancelBoostBrightnessFunc = reinterpret_cast<bool (*)(uint32_t)>(mCancelBoostBrightnessFunc);
346     return cancelBoostBrightnessFunc(gradualDuration);
347 }
348 
GetBrightness()349 uint32_t BrightnessManagerExt::GetBrightness()
350 {
351     if (!mBrightnessManagerExtEnable) {
352         return 0;
353     }
354     auto getBrightnessFunc = reinterpret_cast<uint32_t (*)()>(mGetBrightnessFunc);
355     return getBrightnessFunc();
356 }
357 
GetDeviceBrightness()358 uint32_t BrightnessManagerExt::GetDeviceBrightness()
359 {
360     if (!mBrightnessManagerExtEnable) {
361         return 0;
362     }
363     auto getDeviceBrightnessFunc = reinterpret_cast<uint32_t (*)()>(mGetDeviceBrightnessFunc);
364     return getDeviceBrightnessFunc();
365 }
366 
IsBrightnessOverridden() const367 bool BrightnessManagerExt::IsBrightnessOverridden() const
368 {
369     if (!mBrightnessManagerExtEnable) {
370         return false;
371     }
372     auto isBrightnessOverriddenFunc = reinterpret_cast<bool (*)()>(mIsBrightnessOverriddenFunc);
373     return isBrightnessOverriddenFunc();
374 }
375 
IsBrightnessBoosted() const376 bool BrightnessManagerExt::IsBrightnessBoosted() const
377 {
378     if (!mBrightnessManagerExtEnable) {
379         return false;
380     }
381     auto isBrightnessBoostedFunc = reinterpret_cast<bool (*)()>(mIsBrightnessBoostedFunc);
382     return isBrightnessBoostedFunc();
383 }
384 
GetCurrentDisplayId(uint32_t defaultId) const385 uint32_t BrightnessManagerExt::GetCurrentDisplayId(uint32_t defaultId) const
386 {
387     if (!mBrightnessManagerExtEnable) {
388         return defaultId;
389     }
390     auto getCurrentDisplayIdFunc = reinterpret_cast<uint32_t (*)(uint32_t)>(mGetCurrentDisplayIdFunc);
391     return getCurrentDisplayIdFunc(defaultId);
392 }
393 
SetDisplayId(uint32_t id)394 void BrightnessManagerExt::SetDisplayId(uint32_t id)
395 {
396     if (!mBrightnessManagerExtEnable) {
397         return;
398     }
399     auto setDisplayIdFunc = reinterpret_cast<void (*)(uint32_t)>(mSetDisplayIdFunc);
400     setDisplayIdFunc(id);
401 }
402 
SetLightBrightnessThreshold(std::vector<int32_t> threshold,sptr<IDisplayBrightnessCallback> callback)403 uint32_t BrightnessManagerExt::SetLightBrightnessThreshold(
404     std::vector<int32_t> threshold, sptr<IDisplayBrightnessCallback> callback)
405 {
406     uint32_t result = 0;
407     if (!mBrightnessManagerExtEnable) {
408         return result;
409     }
410     auto setLightBrightnessThresholdFunc =
411         reinterpret_cast<uint32_t (*)(std::vector<int32_t>, sptr<IDisplayBrightnessCallback>)>(
412         mSetLightBrightnessThresholdFunc);
413     if (!setLightBrightnessThresholdFunc) {
414         return result;
415     }
416     return setLightBrightnessThresholdFunc(threshold, callback);
417 }
418 
SetMaxBrightness(double value)419 bool BrightnessManagerExt::SetMaxBrightness(double value)
420 {
421     if (!mBrightnessManagerExtEnable) {
422         return false;
423     }
424     auto setMaxBrightnessFunc = reinterpret_cast<bool (*)(double)>(mSetMaxBrightnessFunc);
425     return setMaxBrightnessFunc(value);
426 }
427 
SetMaxBrightnessNit(uint32_t nit)428 bool BrightnessManagerExt::SetMaxBrightnessNit(uint32_t nit)
429 {
430     if (!mBrightnessManagerExtEnable) {
431         return false;
432     }
433     auto setMaxBrightnessNitFunc = reinterpret_cast<bool (*)(uint32_t)>(mSetMaxBrightnessNitFunc);
434     return setMaxBrightnessNitFunc(nit);
435 }
436 } // namespace DisplayPowerMgr
437 } // namespace OHOS