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, uint32_t reason)232 void BrightnessManagerExt::SetDisplayState(uint32_t id, DisplayState state, uint32_t reason)
233 {
234     if (!mBrightnessManagerExtEnable) {
235         return;
236     }
237     auto setDisplayStateFunc = reinterpret_cast<void (*)(uint32_t, DisplayState state, uint32_t reason)>
238         (mSetDisplayStateFunc);
239     setDisplayStateFunc(id, state, reason);
240 }
241 
GetState()242 DisplayState BrightnessManagerExt::GetState()
243 {
244     if (!mBrightnessManagerExtEnable) {
245         return DisplayState::DISPLAY_UNKNOWN;
246     }
247     auto getDisplayStateFunc = reinterpret_cast<DisplayState (*)()>(mGetDisplayStateFunc);
248     return getDisplayStateFunc();
249 }
250 
AutoAdjustBrightness(bool enable)251 bool BrightnessManagerExt::AutoAdjustBrightness(bool enable)
252 {
253     if (!mBrightnessManagerExtEnable) {
254         return false;
255     }
256     auto autoAdjustBrightnessFunc = reinterpret_cast<bool (*)(bool)>(mAutoAdjustBrightnessFunc);
257     return autoAdjustBrightnessFunc(enable);
258 }
259 
SetBrightness(uint32_t value, uint32_t gradualDuration, bool continuous)260 bool BrightnessManagerExt::SetBrightness(uint32_t value, uint32_t gradualDuration, bool continuous)
261 {
262     if (!mBrightnessManagerExtEnable) {
263         return false;
264     }
265     auto setBrightnessFunc = reinterpret_cast<bool (*)(uint32_t, uint32_t, bool)>(mSetBrightnessFunc);
266     return setBrightnessFunc(value, gradualDuration, continuous);
267 }
268 
DiscountBrightness(double discount)269 bool BrightnessManagerExt::DiscountBrightness(double discount)
270 {
271     if (!mBrightnessManagerExtEnable) {
272         return false;
273     }
274     auto discountBrightnessFunc = reinterpret_cast<bool (*)(double)>(mDiscountBrightnessFunc);
275     return discountBrightnessFunc(discount);
276 }
277 
GetDiscount() const278 double BrightnessManagerExt::GetDiscount() const
279 {
280     if (!mBrightnessManagerExtEnable) {
281         return 1.0;
282     }
283     auto getDiscountFunc = reinterpret_cast<double (*)()>(mGetDiscountFunc);
284     return getDiscountFunc();
285 }
286 
SetScreenOnBrightness()287 void BrightnessManagerExt::SetScreenOnBrightness()
288 {
289     if (!mBrightnessManagerExtEnable) {
290         return;
291     }
292     auto setScreenOnBrightnessFunc = reinterpret_cast<void (*)()>(mSetScreenOnBrightnessFunc);
293     setScreenOnBrightnessFunc();
294 }
295 
GetScreenOnBrightness() const296 uint32_t BrightnessManagerExt::GetScreenOnBrightness() const
297 {
298     if (!mBrightnessManagerExtEnable) {
299         return 0;
300     }
301     auto getScreenOnBrightnessFunc = reinterpret_cast<uint32_t (*)(bool)>(mGetScreenOnBrightnessFunc);
302     return getScreenOnBrightnessFunc(false);
303 }
304 
ClearOffset()305 void BrightnessManagerExt::ClearOffset()
306 {
307     if (!mBrightnessManagerExtEnable) {
308         return;
309     }
310     auto clearOffsetFunc = reinterpret_cast<void (*)()>(mClearOffsetFunc);
311     clearOffsetFunc();
312 }
313 
OverrideBrightness(uint32_t value, uint32_t gradualDuration)314 bool BrightnessManagerExt::OverrideBrightness(uint32_t value, uint32_t gradualDuration)
315 {
316     if (!mBrightnessManagerExtEnable) {
317         return false;
318     }
319     auto overrideBrightnessFunc = reinterpret_cast<bool (*)(uint32_t, uint32_t)>(mOverrideBrightnessFunc);
320     return overrideBrightnessFunc(value, gradualDuration);
321 }
322 
RestoreBrightness(uint32_t gradualDuration)323 bool BrightnessManagerExt::RestoreBrightness(uint32_t gradualDuration)
324 {
325     if (!mBrightnessManagerExtEnable) {
326         return false;
327     }
328     auto restoreBrightnessFunc = reinterpret_cast<bool (*)(uint32_t)>(mRestoreBrightnessFunc);
329     return restoreBrightnessFunc(gradualDuration);
330 }
331 
BoostBrightness(uint32_t timeoutMs, uint32_t gradualDuration)332 bool BrightnessManagerExt::BoostBrightness(uint32_t timeoutMs, uint32_t gradualDuration)
333 {
334     if (!mBrightnessManagerExtEnable) {
335         return false;
336     }
337     auto boostBrightnessFunc = reinterpret_cast<bool (*)(uint32_t, uint32_t)>(mBoostBrightnessFunc);
338     return boostBrightnessFunc(timeoutMs, gradualDuration);
339 }
340 
CancelBoostBrightness(uint32_t gradualDuration)341 bool BrightnessManagerExt::CancelBoostBrightness(uint32_t gradualDuration)
342 {
343     if (!mBrightnessManagerExtEnable) {
344         return false;
345     }
346     auto cancelBoostBrightnessFunc = reinterpret_cast<bool (*)(uint32_t)>(mCancelBoostBrightnessFunc);
347     return cancelBoostBrightnessFunc(gradualDuration);
348 }
349 
GetBrightness()350 uint32_t BrightnessManagerExt::GetBrightness()
351 {
352     if (!mBrightnessManagerExtEnable) {
353         return 0;
354     }
355     auto getBrightnessFunc = reinterpret_cast<uint32_t (*)()>(mGetBrightnessFunc);
356     return getBrightnessFunc();
357 }
358 
GetDeviceBrightness()359 uint32_t BrightnessManagerExt::GetDeviceBrightness()
360 {
361     if (!mBrightnessManagerExtEnable) {
362         return 0;
363     }
364     auto getDeviceBrightnessFunc = reinterpret_cast<uint32_t (*)()>(mGetDeviceBrightnessFunc);
365     return getDeviceBrightnessFunc();
366 }
367 
IsBrightnessOverridden() const368 bool BrightnessManagerExt::IsBrightnessOverridden() const
369 {
370     if (!mBrightnessManagerExtEnable) {
371         return false;
372     }
373     auto isBrightnessOverriddenFunc = reinterpret_cast<bool (*)()>(mIsBrightnessOverriddenFunc);
374     return isBrightnessOverriddenFunc();
375 }
376 
IsBrightnessBoosted() const377 bool BrightnessManagerExt::IsBrightnessBoosted() const
378 {
379     if (!mBrightnessManagerExtEnable) {
380         return false;
381     }
382     auto isBrightnessBoostedFunc = reinterpret_cast<bool (*)()>(mIsBrightnessBoostedFunc);
383     return isBrightnessBoostedFunc();
384 }
385 
GetCurrentDisplayId(uint32_t defaultId) const386 uint32_t BrightnessManagerExt::GetCurrentDisplayId(uint32_t defaultId) const
387 {
388     if (!mBrightnessManagerExtEnable) {
389         return defaultId;
390     }
391     auto getCurrentDisplayIdFunc = reinterpret_cast<uint32_t (*)(uint32_t)>(mGetCurrentDisplayIdFunc);
392     return getCurrentDisplayIdFunc(defaultId);
393 }
394 
SetDisplayId(uint32_t id)395 void BrightnessManagerExt::SetDisplayId(uint32_t id)
396 {
397     if (!mBrightnessManagerExtEnable) {
398         return;
399     }
400     auto setDisplayIdFunc = reinterpret_cast<void (*)(uint32_t)>(mSetDisplayIdFunc);
401     setDisplayIdFunc(id);
402 }
403 
SetLightBrightnessThreshold( std::vector<int32_t> threshold, sptr<IDisplayBrightnessCallback> callback)404 uint32_t BrightnessManagerExt::SetLightBrightnessThreshold(
405     std::vector<int32_t> threshold, sptr<IDisplayBrightnessCallback> callback)
406 {
407     uint32_t result = 0;
408     if (!mBrightnessManagerExtEnable) {
409         return result;
410     }
411     auto setLightBrightnessThresholdFunc =
412         reinterpret_cast<uint32_t (*)(std::vector<int32_t>, sptr<IDisplayBrightnessCallback>)>(
413         mSetLightBrightnessThresholdFunc);
414     if (!setLightBrightnessThresholdFunc) {
415         return result;
416     }
417     return setLightBrightnessThresholdFunc(threshold, callback);
418 }
419 
SetMaxBrightness(double value)420 bool BrightnessManagerExt::SetMaxBrightness(double value)
421 {
422     if (!mBrightnessManagerExtEnable) {
423         return false;
424     }
425     auto setMaxBrightnessFunc = reinterpret_cast<bool (*)(double)>(mSetMaxBrightnessFunc);
426     return setMaxBrightnessFunc(value);
427 }
428 
SetMaxBrightnessNit(uint32_t nit)429 bool BrightnessManagerExt::SetMaxBrightnessNit(uint32_t nit)
430 {
431     if (!mBrightnessManagerExtEnable) {
432         return false;
433     }
434     auto setMaxBrightnessNitFunc = reinterpret_cast<bool (*)(uint32_t)>(mSetMaxBrightnessNitFunc);
435     return setMaxBrightnessNitFunc(nit);
436 }
437 } // namespace DisplayPowerMgr
438 } // namespace OHOS