1 /*
2 * Copyright (c) 2023-2023 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 "calculation_manager.h"
17
18 #include <algorithm>
19 #include <cmath>
20 #include <iostream>
21 #include <sstream>
22 #include <string>
23
24 #include "display_log.h"
25
26 namespace OHOS {
27 namespace DisplayPowerMgr {
28
29 namespace {
30 constexpr float DEFAULT_NO_OFFSET_LUX = -1.0f;
31 constexpr float DEFAULT_OFFSET_BRIGHTNESS = 0.0f;
32 constexpr float DEFAULT_OFFSET_DELTA = 0.0f;
33 constexpr float SMALL_VALUE = 1e-6f;
34 constexpr float DEFAULT_OFFSET_RATIO = 1.0f;
35 constexpr float MIN_OFFSET_RATIO = 0.0f;
36 constexpr float MIN_DEFAULT_BRIGHTNESS = 4.0f;
37 constexpr float MAX_DEFAULT_BRIGHTNESS = 255.0f;
38
39 constexpr float AMBIENT_VALID_MAX_LUX = 40000;
40 constexpr float AMBIENT_VALID_MIN_LUX = 0.0f;
41 } // namespace
42
InitParameters()43 void BrightnessCalculationManager::InitParameters()
44 {
45 mBrightnessCalculationCurve.InitParameters();
46 }
47
GetInterpolatedValue(float lux)48 float BrightnessCalculationManager::GetInterpolatedValue(float lux)
49 {
50 float valueInterp = GetInterpolatedBrightenssLevel(mPosBrightness, lux) / MAX_DEFAULT_BRIGHTNESS;
51 DISPLAY_HILOGI(FEAT_BRIGHTNESS, "GetInterpolatedValue lux=%{public}f, valueInterp=%{public}f, "\
52 " mPosBrightness=%{public}f", lux, valueInterp, mPosBrightness);
53 return valueInterp;
54 }
55
GetInterpolatedBrightenssLevel(float positionBrightness,float lux)56 float BrightnessCalculationManager::GetInterpolatedBrightenssLevel(float positionBrightness, float lux)
57 {
58 float posBrightness = positionBrightness;
59 UpdateCurveAmbientLux(lux);
60 UpdateDefaultBrightness(lux);
61
62 if (mLastLuxDefaultBrightness <= DEFAULT_OFFSET_BRIGHTNESS && mPosBrightness != DEFAULT_OFFSET_BRIGHTNESS) {
63 posBrightness = DEFAULT_OFFSET_BRIGHTNESS;
64 ResetDefaultBrightnessOffset();
65 }
66
67 float offsetBrightness = mDefaultBrightnessFromLux;
68 if (IsDefaultBrightnessMode(posBrightness)) {
69 offsetBrightness = mDefaultBrightnessFromLux;
70 } else {
71 offsetBrightness = GetOffsetLevel(mStartLuxDefaultBrightness,
72 mDefaultBrightnessFromLux, posBrightness, mDelta);
73 }
74
75 mLastLuxDefaultBrightness = mDefaultBrightnessFromLux;
76 mOffsetBrightnessLast = offsetBrightness;
77 DISPLAY_HILOGI(FEAT_BRIGHTNESS, "GetLevel lux=%{public}f, offsetBrightness=%{public}f, default=%{public}f",
78 lux, offsetBrightness, mDefaultBrightnessFromLux);
79 return offsetBrightness;
80 }
81
UpdateDefaultBrightness(float lux)82 void BrightnessCalculationManager::UpdateDefaultBrightness(float lux)
83 {
84 float defaultBrightness = GetCurrentBrightness(lux);
85 mDefaultBrightnessFromLux = defaultBrightness;
86 }
87
GetCurrentBrightness(float lux)88 float BrightnessCalculationManager::GetCurrentBrightness(float lux)
89 {
90 return mBrightnessCalculationCurve.GetCurrentBrightness(lux);
91 }
92
UpdateParaFromReboot()93 void BrightnessCalculationManager::UpdateParaFromReboot()
94 {
95 mLastLuxDefaultBrightness = mDefaultBrightnessFromLux;
96 mStartLuxDefaultBrightness = mDefaultBrightnessFromLux;
97 mOffsetBrightnessLast = mDefaultBrightnessFromLux;
98 mIsReboot = false;
99 }
100
IsDefaultBrightnessMode(float positionBrightness)101 bool BrightnessCalculationManager::IsDefaultBrightnessMode(float positionBrightness)
102 {
103 if (positionBrightness == DEFAULT_OFFSET_DELTA) {
104 return true;
105 }
106 return false;
107 }
108
GetOffsetLevel(float brightnessStartOrig,float brightnessEndOrig,float brightnessStartNew,float delta)109 float BrightnessCalculationManager::GetOffsetLevel(float brightnessStartOrig, float brightnessEndOrig,
110 float brightnessStartNew, float delta)
111 {
112 float brightenRatio = 1.0f;
113 float darkenRatio = 1.0f;
114 float deltaStart = delta;
115 if (brightnessStartOrig < brightnessEndOrig) {
116 if (deltaStart > DEFAULT_OFFSET_DELTA) {
117 darkenRatio = GetDefaultBrightenOffsetBrightenRaio(brightnessStartOrig, brightnessEndOrig,
118 brightnessStartNew, deltaStart);
119 }
120 if (deltaStart < DEFAULT_OFFSET_DELTA) {
121 brightenRatio = GetDefaultDarkenOffsetBrightenRatio(brightnessStartOrig, brightnessEndOrig,
122 brightnessStartNew, deltaStart);
123 }
124 }
125 if (brightnessStartOrig > brightnessEndOrig) {
126 if (deltaStart < DEFAULT_OFFSET_DELTA) {
127 darkenRatio = GetDefaultDarkenOffsetDarkenRatio(brightnessStartOrig, brightnessEndOrig,
128 brightnessStartNew, deltaStart);
129 }
130 if (deltaStart > DEFAULT_OFFSET_DELTA) {
131 brightenRatio = GetDefaultBrightenOffsetDarkenRatio(brightnessStartOrig, brightnessEndOrig,
132 brightnessStartNew);
133 }
134 }
135 float tempDeltaNew = deltaStart * brightenRatio * darkenRatio;
136
137 float brightnessAndDelta = brightnessEndOrig + tempDeltaNew;
138 float offsetBrightnessTemp = (brightnessAndDelta > MIN_DEFAULT_BRIGHTNESS
139 ? brightnessAndDelta : MIN_DEFAULT_BRIGHTNESS);
140 float offsetBrightness = (offsetBrightnessTemp < MAX_DEFAULT_BRIGHTNESS
141 ? offsetBrightnessTemp : MAX_DEFAULT_BRIGHTNESS);
142 DISPLAY_HILOGI(FEAT_BRIGHTNESS, "GetOffsetLevel tempDeltaNew=%{public}f, deltaStart=%{public}f, "\
143 " brightenRatio=%{public}f, darkenRatio=%{public}f", tempDeltaNew, deltaStart, brightenRatio, darkenRatio);
144 return offsetBrightness;
145 }
146
GetDefaultBrightenOffsetBrightenRaio(float brightnessStartOrig,float brightnessEndOrig,float brightnessStartNew,float deltaStart)147 float BrightnessCalculationManager::GetDefaultBrightenOffsetBrightenRaio(float brightnessStartOrig,
148 float brightnessEndOrig, float brightnessStartNew, float deltaStart)
149 {
150 float brightenRatio;
151 if (std::abs(MAX_DEFAULT_BRIGHTNESS - brightnessStartOrig) < SMALL_VALUE) {
152 brightenRatio = DEFAULT_OFFSET_RATIO;
153 } else {
154 brightenRatio = (MAX_DEFAULT_BRIGHTNESS - brightnessEndOrig)
155 / (MAX_DEFAULT_BRIGHTNESS - brightnessStartOrig);
156 }
157
158 float offsetBrightnessTmp = ((1 - offsetBrightenAlphaRight)
159 * std::max(brightnessEndOrig, brightnessStartNew))
160 + (offsetBrightenAlphaRight * ((deltaStart * brightenRatio) + brightnessEndOrig));
161 if (std::abs(deltaStart) < SMALL_VALUE) {
162 brightenRatio = DEFAULT_OFFSET_RATIO;
163 } else {
164 brightenRatio = (offsetBrightnessTmp - brightnessEndOrig) / deltaStart;
165 }
166 if (brightenRatio < MIN_OFFSET_RATIO) {
167 brightenRatio = MIN_OFFSET_RATIO;
168 }
169 return brightenRatio;
170 }
171
172
GetAmbientOffsetLux()173 float BrightnessCalculationManager::GetAmbientOffsetLux()
174 {
175 float lux = static_cast<int>(mOffsetLux);
176 return lux;
177 }
178
GetBrightenOffsetNoValidBrightenLux(float lux)179 float BrightnessCalculationManager::GetBrightenOffsetNoValidBrightenLux(float lux)
180 {
181 float noValidBrightenLuxTh = AMBIENT_VALID_MAX_LUX;
182 return noValidBrightenLuxTh;
183 }
184
GetDefaultDarkenOffsetBrightenRatio(float brightnessStartOrig,float brightnessEndOrig,float brightnessStartNew,float deltaStart)185 float BrightnessCalculationManager::GetDefaultDarkenOffsetBrightenRatio(float brightnessStartOrig,
186 float brightnessEndOrig, float brightnessStartNew, float deltaStart)
187 {
188 float brightenRatio;
189 if (std::abs(MAX_DEFAULT_BRIGHTNESS - brightnessStartOrig) < SMALL_VALUE) {
190 brightenRatio = DEFAULT_OFFSET_RATIO;
191 } else {
192 brightenRatio = (MAX_DEFAULT_BRIGHTNESS - brightnessEndOrig)
193 / (MAX_DEFAULT_BRIGHTNESS - brightnessStartOrig);
194 }
195
196 if (brightenRatio < MIN_OFFSET_RATIO) {
197 brightenRatio = MIN_OFFSET_RATIO;
198 }
199 return brightenRatio;
200 }
201
GetDefaultDarkenOffsetDarkenRatio(float brightnessStartOrig,float brightnessEndOrig,float brightnessStartNew,float deltaStart)202 float BrightnessCalculationManager::GetDefaultDarkenOffsetDarkenRatio(float brightnessStartOrig,
203 float brightnessEndOrig, float brightnessStartNew, float deltaStart)
204 {
205 float darkenRatio;
206 if (std::abs(brightnessStartOrig - MIN_DEFAULT_BRIGHTNESS) < SMALL_VALUE) {
207 darkenRatio = DEFAULT_OFFSET_RATIO;
208 } else {
209 darkenRatio = (brightnessEndOrig - MIN_DEFAULT_BRIGHTNESS)
210 / (brightnessStartOrig - MIN_DEFAULT_BRIGHTNESS);
211 }
212 float offsetBrightnessTmp = ((1 - offsetDarkenAlphaLeft) * std::min(brightnessEndOrig,
213 brightnessStartNew)) + (offsetDarkenAlphaLeft * ((deltaStart * darkenRatio) + brightnessEndOrig));
214 if (std::abs(deltaStart) < SMALL_VALUE) {
215 darkenRatio = DEFAULT_OFFSET_RATIO;
216 } else {
217 darkenRatio = (offsetBrightnessTmp - brightnessEndOrig) / deltaStart;
218 }
219 if (darkenRatio < MIN_OFFSET_RATIO) {
220 darkenRatio = MIN_OFFSET_RATIO;
221 }
222 return darkenRatio;
223 }
224
GetDefaultBrightenOffsetDarkenRatio(float brightnessStartOrig,float brightnessEndOrig,float brightnessStartNew)225 float BrightnessCalculationManager::GetDefaultBrightenOffsetDarkenRatio(float brightnessStartOrig,
226 float brightnessEndOrig, float brightnessStartNew)
227 {
228 float darkenRatio;
229 if (std::abs(brightnessStartOrig) < SMALL_VALUE) {
230 darkenRatio = DEFAULT_OFFSET_RATIO;
231 } else {
232 float darkenRatioTmp = static_cast<float>(pow(brightnessEndOrig / brightnessStartOrig,
233 offsetBrightenRatioLeft));
234 darkenRatio = (offsetBrightenAlphaLeft * brightnessEndOrig / brightnessStartOrig)
235 + ((1 - offsetBrightenAlphaLeft) * darkenRatioTmp);
236 }
237 return darkenRatio;
238 }
239
UpdateBrightnessOffset(float posBrightness,float lux)240 void BrightnessCalculationManager::UpdateBrightnessOffset(float posBrightness, float lux)
241 {
242 if (lux < AMBIENT_VALID_MIN_LUX || lux > AMBIENT_VALID_MAX_LUX) {
243 return;
244 }
245 if (std::abs(posBrightness) < SMALL_VALUE) {
246 ResetDefaultBrightnessOffset();
247 return;
248 }
249 mOffsetLux = lux;
250 mStartLuxDefaultBrightness = GetCurrentBrightness(lux);
251 mPosBrightness = posBrightness;
252 mDelta = mPosBrightness - mStartLuxDefaultBrightness;
253 DISPLAY_HILOGI(FEAT_BRIGHTNESS, "UpdateBrightnessOffset lux=%{public}f, mDelta=%{public}f, "\
254 "mPosBrightness=%{public}f", lux, mDelta, mPosBrightness);
255 }
256
ResetDefaultBrightnessOffset()257 void BrightnessCalculationManager::ResetDefaultBrightnessOffset()
258 {
259 mOffsetLux = DEFAULT_NO_OFFSET_LUX;
260 mDelta = DEFAULT_OFFSET_DELTA;
261
262 mOffsetBrightnessLast = DEFAULT_OFFSET_BRIGHTNESS;
263 mLastLuxDefaultBrightness = DEFAULT_OFFSET_BRIGHTNESS;
264 mStartLuxDefaultBrightness = DEFAULT_OFFSET_BRIGHTNESS;
265 mPosBrightness = DEFAULT_OFFSET_BRIGHTNESS;
266 DISPLAY_HILOGI(FEAT_BRIGHTNESS, "ResetDefaultBrightnessOffset");
267 }
268
UpdateCurveAmbientLux(float lux)269 void BrightnessCalculationManager::UpdateCurveAmbientLux(float lux)
270 {
271 if (mCurveLux != lux) {
272 mBrightnessCalculationCurve.UpdateCurveAmbientLux(lux);
273 mCurveLux = lux;
274 }
275 }
276
SetGameModeEnable(bool isGameCurveEnable)277 void BrightnessCalculationManager::SetGameModeEnable(bool isGameCurveEnable)
278 {
279 mIsGameCurveEnable = isGameCurveEnable;
280 }
281
SetCameraModeEnable(bool isCameraCurveEnable)282 void BrightnessCalculationManager::SetCameraModeEnable(bool isCameraCurveEnable)
283 {
284 mIsCameraCurveEnable = isCameraCurveEnable;
285 }
286
UpdateCurrentUserId(int userId)287 void BrightnessCalculationManager::UpdateCurrentUserId(int userId)
288 {
289 mCurrentUserId = userId;
290 mBrightnessCalculationCurve.UpdateCurrentUserId(userId);
291 }
292
ResetOffsetFromHumanFactor(bool isOffsetResetEnable,int minOffsetBrightness,int maxOffsetBrightness)293 void BrightnessCalculationManager::ResetOffsetFromHumanFactor(bool isOffsetResetEnable, int minOffsetBrightness,
294 int maxOffsetBrightness)
295 {
296 if (isOffsetResetEnable && std::abs(mPosBrightness) > SMALL_VALUE) {
297 if (mPosBrightness < minOffsetBrightness) {
298 mPosBrightness = minOffsetBrightness;
299 mOffsetBrightnessLast = minOffsetBrightness;
300 mDelta = mPosBrightness - mStartLuxDefaultBrightness;
301 }
302 if (mPosBrightness > maxOffsetBrightness) {
303 mPosBrightness = maxOffsetBrightness;
304 mOffsetBrightnessLast = maxOffsetBrightness;
305 mDelta = mPosBrightness - mStartLuxDefaultBrightness;
306 }
307 }
308 }
309
GetDisplayIdWithDisplayMode(int displayMode)310 int BrightnessCalculationManager::GetDisplayIdWithDisplayMode(int displayMode)
311 {
312 return mBrightnessCalculationCurve.GetDisplayIdWithDisplayMode(displayMode);
313 }
314
GetSensorIdWithDisplayMode(int displayMode)315 int BrightnessCalculationManager::GetSensorIdWithDisplayMode(int displayMode)
316 {
317 return mBrightnessCalculationCurve.GetSensorIdWithDisplayMode(displayMode);
318 }
319
GetDisplayIdWithFoldstatus(int foldStatus)320 int BrightnessCalculationManager::GetDisplayIdWithFoldstatus(int foldStatus)
321 {
322 return mBrightnessCalculationCurve.GetDisplayIdWithFoldstatus(foldStatus);
323 }
324
GetSensorIdWithFoldstatus(int foldStatus)325 int BrightnessCalculationManager::GetSensorIdWithFoldstatus(int foldStatus)
326 {
327 return mBrightnessCalculationCurve.GetSensorIdWithFoldstatus(foldStatus);
328 }
329 } // namespace DisplayPowerMgr
330 } // namespace OHOS