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
19namespace OHOS {
20namespace DisplayPowerMgr {
21BrightnessManagerExt::BrightnessManagerExt()
22{
23}
24
25BrightnessManagerExt::~BrightnessManagerExt()
26{
27    CloseBrightnessExtLibrary();
28}
29
30void 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
39void BrightnessManagerExt::DeInit()
40{
41    auto deInit = reinterpret_cast<void (*)()>(mBrightnessManagerDeInitFunc);
42    if (deInit) {
43        deInit();
44    }
45    CloseBrightnessExtLibrary();
46}
47
48bool 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
66bool 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
104bool 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
154bool 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
199void 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
232void 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
242DisplayState BrightnessManagerExt::GetState()
243{
244    if (!mBrightnessManagerExtEnable) {
245        return DisplayState::DISPLAY_UNKNOWN;
246    }
247    auto getDisplayStateFunc = reinterpret_cast<DisplayState (*)()>(mGetDisplayStateFunc);
248    return getDisplayStateFunc();
249}
250
251bool 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
260bool 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
269bool 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
278double BrightnessManagerExt::GetDiscount() const
279{
280    if (!mBrightnessManagerExtEnable) {
281        return 1.0;
282    }
283    auto getDiscountFunc = reinterpret_cast<double (*)()>(mGetDiscountFunc);
284    return getDiscountFunc();
285}
286
287void BrightnessManagerExt::SetScreenOnBrightness()
288{
289    if (!mBrightnessManagerExtEnable) {
290        return;
291    }
292    auto setScreenOnBrightnessFunc = reinterpret_cast<void (*)()>(mSetScreenOnBrightnessFunc);
293    setScreenOnBrightnessFunc();
294}
295
296uint32_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
305void BrightnessManagerExt::ClearOffset()
306{
307    if (!mBrightnessManagerExtEnable) {
308        return;
309    }
310    auto clearOffsetFunc = reinterpret_cast<void (*)()>(mClearOffsetFunc);
311    clearOffsetFunc();
312}
313
314bool 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
323bool 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
332bool 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
341bool 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
350uint32_t BrightnessManagerExt::GetBrightness()
351{
352    if (!mBrightnessManagerExtEnable) {
353        return 0;
354    }
355    auto getBrightnessFunc = reinterpret_cast<uint32_t (*)()>(mGetBrightnessFunc);
356    return getBrightnessFunc();
357}
358
359uint32_t BrightnessManagerExt::GetDeviceBrightness()
360{
361    if (!mBrightnessManagerExtEnable) {
362        return 0;
363    }
364    auto getDeviceBrightnessFunc = reinterpret_cast<uint32_t (*)()>(mGetDeviceBrightnessFunc);
365    return getDeviceBrightnessFunc();
366}
367
368bool BrightnessManagerExt::IsBrightnessOverridden() const
369{
370    if (!mBrightnessManagerExtEnable) {
371        return false;
372    }
373    auto isBrightnessOverriddenFunc = reinterpret_cast<bool (*)()>(mIsBrightnessOverriddenFunc);
374    return isBrightnessOverriddenFunc();
375}
376
377bool BrightnessManagerExt::IsBrightnessBoosted() const
378{
379    if (!mBrightnessManagerExtEnable) {
380        return false;
381    }
382    auto isBrightnessBoostedFunc = reinterpret_cast<bool (*)()>(mIsBrightnessBoostedFunc);
383    return isBrightnessBoostedFunc();
384}
385
386uint32_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
395void 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
404uint32_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
420bool 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
429bool 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