1 /*
2 * Copyright (c) 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 "screen_setting_helper.h"
17
18 #include <cerrno>
19 #include <parameters.h>
20
21 #include "screen_session_manager/include/screen_session_manager.h"
22 #include "setting_provider.h"
23 #include "system_ability_definition.h"
24 #include "window_manager_hilog.h"
25 #include "fold_screen_state_internel.h"
26 #include "fold_screen_controller/super_fold_state_manager.h"
27
28 namespace OHOS {
29 namespace Rosen {
30 sptr<SettingObserver> ScreenSettingHelper::dpiObserver_;
31 sptr<SettingObserver> ScreenSettingHelper::castObserver_;
32 sptr<SettingObserver> ScreenSettingHelper::rotationObserver_;
33 sptr<SettingObserver> ScreenSettingHelper::wireCastObserver_;
34 sptr<SettingObserver> ScreenSettingHelper::extendScreenDpiObserver_;
35 sptr<SettingObserver> ScreenSettingHelper::duringCallStateObserver_;
36 constexpr int32_t PARAM_NUM_TEN = 10;
37 constexpr uint32_t EXPECT_SCREEN_MODE_SIZE = 2;
38 constexpr uint32_t EXPECT_RELATIVE_POSITION_SIZE = 3;
39 constexpr uint32_t VALID_MULTI_SCREEN_INFO_SIZE = 4;
40 constexpr uint32_t INDEX_SCREEN_INFO = 0;
41 constexpr uint32_t INDEX_SCREEN_MODE = 1;
42 constexpr uint32_t INDEX_FIRST_RELATIVE_POSITION = 2;
43 constexpr uint32_t INDEX_SECOND_RELATIVE_POSITION = 3;
44 constexpr uint32_t DATA_INDEX_ZERO = 0;
45 constexpr uint32_t DATA_INDEX_ONE = 1;
46 constexpr uint32_t DATA_INDEX_TWO = 2;
47 constexpr uint32_t SCREEN_MAIN_IN_DATA = 0;
48 constexpr uint32_t SCREEN_MIRROR_IN_DATA = 1;
49 constexpr uint32_t SCREEN_EXTEND_IN_DATA = 2;
50 constexpr ScreenId RS_ID_INTERNAL = 0;
51 constexpr uint32_t EXTEND_SCREEN_DPI_LEVEL_NEG_ONE = -1;
52 constexpr uint32_t EXTEND_SCREEN_DPI_LEVEL_ZERO = 0;
53 constexpr uint32_t EXTEND_SCREEN_DPI_LEVEL_ONE = 1;
54 constexpr float EXTEND_SCREEN_DPI_NEG_ONE_PARAMETER = 0.7f;
55 constexpr float EXTEND_SCREEN_DPI_ZERO_PARAMETER = 0.85f;
56 constexpr float EXTEND_SCREEN_DPI_ONE_PARAMETER = 1.00f;
57 const std::string SCREEN_SHAPE = system::GetParameter("const.window.screen_shape", "0:0");
58 constexpr int32_t INDEX_EXTEND_SCREEN_DPI_POSITION = -1;
59
RegisterSettingDpiObserver(SettingObserver::UpdateFunc func)60 void ScreenSettingHelper::RegisterSettingDpiObserver(SettingObserver::UpdateFunc func)
61 {
62 if (dpiObserver_) {
63 TLOGD(WmsLogTag::DMS, "setting dpi observer is registered");
64 return;
65 }
66 SettingProvider& provider = SettingProvider::GetInstance(DISPLAY_MANAGER_SERVICE_SA_ID);
67 dpiObserver_ = provider.CreateObserver(SETTING_DPI_KEY, func);
68 if (dpiObserver_ == nullptr) {
69 TLOGE(WmsLogTag::DMS, "create observer failed");
70 }
71 ErrCode ret = provider.RegisterObserver(dpiObserver_);
72 if (ret != ERR_OK) {
73 TLOGW(WmsLogTag::DMS, "failed, ret=%{public}d", ret);
74 dpiObserver_ = nullptr;
75 }
76 }
77
UnregisterSettingDpiObserver()78 void ScreenSettingHelper::UnregisterSettingDpiObserver()
79 {
80 if (dpiObserver_ == nullptr) {
81 TLOGD(WmsLogTag::DMS, "dpiObserver_ is nullptr");
82 return;
83 }
84 SettingProvider& provider = SettingProvider::GetInstance(DISPLAY_MANAGER_SERVICE_SA_ID);
85 ErrCode ret = provider.UnregisterObserver(dpiObserver_);
86 if (ret != ERR_OK) {
87 TLOGW(WmsLogTag::DMS, "failed, ret=%{public}d", ret);
88 }
89 dpiObserver_ = nullptr;
90 }
91
GetSettingDpi(uint32_t & dpi,const std::string & key)92 bool ScreenSettingHelper::GetSettingDpi(uint32_t& dpi, const std::string& key)
93 {
94 return GetSettingValue(dpi, key);
95 }
96
GetSettingValue(uint32_t & value,const std::string & key)97 bool ScreenSettingHelper::GetSettingValue(uint32_t& value, const std::string& key)
98 {
99 SettingProvider& settingData = SettingProvider::GetInstance(DISPLAY_MANAGER_SERVICE_SA_ID);
100 int32_t getValue;
101 ErrCode ret = settingData.GetIntValue(key, getValue);
102 if (ret != ERR_OK) {
103 TLOGW(WmsLogTag::DMS, "failed, ret=%{public}d", ret);
104 return false;
105 }
106 value = static_cast<uint32_t>(getValue);
107 return true;
108 }
109
GetSettingValue(const std::string & key,std::string & value)110 bool ScreenSettingHelper::GetSettingValue(const std::string& key, std::string& value)
111 {
112 SettingProvider& provider = SettingProvider::GetInstance(DISPLAY_MANAGER_SERVICE_SA_ID);
113 std::string getValue = "";
114 ErrCode ret = provider.GetStringValue(key, getValue);
115 if (ret != ERR_OK) {
116 TLOGE(WmsLogTag::DMS, "failed, ret=%{public}d", ret);
117 return false;
118 }
119 value = getValue;
120 return true;
121 }
122
SetSettingValue(const std::string & key,uint32_t value)123 bool ScreenSettingHelper::SetSettingValue(const std::string& key, uint32_t value)
124 {
125 SettingProvider& provider = SettingProvider::GetInstance(DISPLAY_MANAGER_SERVICE_SA_ID);
126 ErrCode ret = provider.PutIntValue(key, value, false);
127 if (ret != ERR_OK) {
128 TLOGE(WmsLogTag::DMS, "failed, ret:%{public}d", ret);
129 return false;
130 }
131 return true;
132 }
133
SetSettingValue(const std::string & key,const std::string & value)134 bool ScreenSettingHelper::SetSettingValue(const std::string& key, const std::string& value)
135 {
136 SettingProvider& provider = SettingProvider::GetInstance(DISPLAY_MANAGER_SERVICE_SA_ID);
137 ErrCode ret = provider.PutStringValue(key, value, false);
138 if (ret != ERR_OK) {
139 TLOGE(WmsLogTag::DMS, "failed, ret:%{public}d", ret);
140 return false;
141 }
142 return true;
143 }
144
SetSettingDefaultDpi(uint32_t & dpi,const std::string & key)145 bool ScreenSettingHelper::SetSettingDefaultDpi(uint32_t& dpi, const std::string& key)
146 {
147 SettingProvider& provider = SettingProvider::GetInstance(DISPLAY_MANAGER_SERVICE_SA_ID);
148 ErrCode ret = provider.PutIntValue(key, dpi, false);
149 if (ret != ERR_OK) {
150 TLOGW(WmsLogTag::DMS, "put int value failed, ret=%{public}d", ret);
151 return false;
152 }
153 return true;
154 }
155
RegisterSettingCastObserver(SettingObserver::UpdateFunc func)156 void ScreenSettingHelper::RegisterSettingCastObserver(SettingObserver::UpdateFunc func)
157 {
158 if (castObserver_) {
159 TLOGD(WmsLogTag::DMS, "setting cast observer is registered");
160 return;
161 }
162 SettingProvider& castProvider = SettingProvider::GetInstance(DISPLAY_MANAGER_SERVICE_SA_ID);
163 castObserver_ = castProvider.CreateObserver(SETTING_CAST_KEY, func);
164 if (castObserver_ == nullptr) {
165 TLOGE(WmsLogTag::DMS, "create observer failed");
166 }
167 ErrCode ret = castProvider.RegisterObserver(castObserver_);
168 if (ret != ERR_OK) {
169 TLOGW(WmsLogTag::DMS, "failed, ret=%{public}d", ret);
170 castObserver_ = nullptr;
171 }
172 }
173
UnregisterSettingCastObserver()174 void ScreenSettingHelper::UnregisterSettingCastObserver()
175 {
176 if (castObserver_ == nullptr) {
177 TLOGD(WmsLogTag::DMS, "castObserver_ is nullptr");
178 return;
179 }
180 SettingProvider& castProvider = SettingProvider::GetInstance(DISPLAY_MANAGER_SERVICE_SA_ID);
181 ErrCode ret = castProvider.UnregisterObserver(castObserver_);
182 if (ret != ERR_OK) {
183 TLOGW(WmsLogTag::DMS, "failed, ret=%{public}d", ret);
184 }
185 castObserver_ = nullptr;
186 }
187
GetSettingCast(bool & enable,const std::string & key)188 bool ScreenSettingHelper::GetSettingCast(bool& enable, const std::string& key)
189 {
190 SettingProvider& castProvider = SettingProvider::GetInstance(DISPLAY_MANAGER_SERVICE_SA_ID);
191 ErrCode ret = castProvider.GetBoolValue(key, enable);
192 if (ret != ERR_OK) {
193 TLOGW(WmsLogTag::DMS, "failed, ret=%{public}d", ret);
194 return false;
195 }
196 return true;
197 }
198
RegisterSettingRotationObserver(SettingObserver::UpdateFunc func)199 void ScreenSettingHelper::RegisterSettingRotationObserver(SettingObserver::UpdateFunc func)
200 {
201 if (rotationObserver_ != nullptr) {
202 TLOGI(WmsLogTag::DMS, "setting rotation observer is registered");
203 return;
204 }
205 SettingProvider& settingProvider = SettingProvider::GetInstance(DISPLAY_MANAGER_SERVICE_SA_ID);
206 rotationObserver_ = settingProvider.CreateObserver(SETTING_ROTATION_KEY, func);
207 if (rotationObserver_ == nullptr) {
208 TLOGE(WmsLogTag::DMS, "create observer failed");
209 }
210 ErrCode ret = settingProvider.RegisterObserver(rotationObserver_);
211 if (ret != ERR_OK) {
212 TLOGE(WmsLogTag::DMS, "failed, ret:%{public}d", ret);
213 rotationObserver_ = nullptr;
214 }
215 }
216
UnregisterSettingRotationObserver()217 void ScreenSettingHelper::UnregisterSettingRotationObserver()
218 {
219 if (rotationObserver_ == nullptr) {
220 TLOGI(WmsLogTag::DMS, "rotationObserver_ is nullptr");
221 return;
222 }
223 SettingProvider& settingProvider = SettingProvider::GetInstance(DISPLAY_MANAGER_SERVICE_SA_ID);
224 ErrCode ret = settingProvider.UnregisterObserver(rotationObserver_);
225 if (ret != ERR_OK) {
226 TLOGE(WmsLogTag::DMS, "failed, ret:%{public}d", ret);
227 }
228 rotationObserver_ = nullptr;
229 }
230
SetSettingRotation(int32_t rotation)231 void ScreenSettingHelper::SetSettingRotation(int32_t rotation)
232 {
233 SettingProvider& settingProvider = SettingProvider::GetInstance(DISPLAY_MANAGER_SERVICE_SA_ID);
234 ErrCode ret = settingProvider.PutIntValue(SETTING_ROTATION_KEY, rotation, true);
235 if (ret != ERR_OK) {
236 TLOGE(WmsLogTag::DMS, "failed, ret:%{public}d", ret);
237 return;
238 }
239 TLOGE(WmsLogTag::DMS, "succeed, ret:%{public}d", ret);
240 }
241
GetSettingRotation(int32_t & rotation,const std::string & key)242 bool ScreenSettingHelper::GetSettingRotation(int32_t& rotation, const std::string& key)
243 {
244 SettingProvider& settingProvider = SettingProvider::GetInstance(DISPLAY_MANAGER_SERVICE_SA_ID);
245 ErrCode ret = settingProvider.GetIntValue(key, rotation);
246 if (ret != ERR_OK) {
247 TLOGE(WmsLogTag::DMS, "failed, ret:%{public}d", ret);
248 return false;
249 }
250 TLOGE(WmsLogTag::DMS, "current rotation:%{public}d", rotation);
251 return true;
252 }
253
SetSettingRotationScreenId(int32_t screenId)254 void ScreenSettingHelper::SetSettingRotationScreenId(int32_t screenId)
255 {
256 SettingProvider& settingProvider = SettingProvider::GetInstance(DISPLAY_MANAGER_SERVICE_SA_ID);
257 ErrCode ret = settingProvider.PutIntValue(SETTING_ROTATION_SCREEN_ID_KEY, screenId, false);
258 if (ret != ERR_OK) {
259 TLOGE(WmsLogTag::DMS, "failed, ret:%{public}d", ret);
260 return;
261 }
262 TLOGE(WmsLogTag::DMS, "succeed, ret:%{public}d", ret);
263 }
264
GetSettingRotationScreenID(int32_t & screenId,const std::string & key)265 bool ScreenSettingHelper::GetSettingRotationScreenID(int32_t& screenId, const std::string& key)
266 {
267 SettingProvider& settingProvider = SettingProvider::GetInstance(DISPLAY_MANAGER_SERVICE_SA_ID);
268 ErrCode ret = settingProvider.GetIntValue(key, screenId);
269 if (ret != ERR_OK) {
270 TLOGE(WmsLogTag::DMS, "failed, ret:%{public}d", ret);
271 return false;
272 }
273 TLOGE(WmsLogTag::DMS, "current rotation screen id:%{public}d", screenId);
274 return true;
275 }
276
RemoveInvalidChar(const std::string & input)277 std::string ScreenSettingHelper::RemoveInvalidChar(const std::string& input)
278 {
279 TLOGW(WmsLogTag::DMS, "input string: %{public}s", input.c_str());
280 std::string resultString = "";
281 for (char character : input) {
282 if (std::isdigit(character) || character == ' ' || character == ',' ||
283 character == '.' || character == ';' || character == '_') {
284 resultString += character;
285 }
286 }
287 return resultString;
288 }
289
SplitString(std::vector<std::string> & splitValues,const std::string & input,char delimiter)290 bool ScreenSettingHelper::SplitString(std::vector<std::string>& splitValues, const std::string& input,
291 char delimiter)
292 {
293 TLOGI(WmsLogTag::DMS, "input string: %{public}s", input.c_str());
294 if (input.size() == 0) {
295 TLOGE(WmsLogTag::DMS, "noting in input string");
296 return false;
297 }
298 std::stringstream stream(input);
299 std::string token = "";
300 while (std::getline(stream, token, delimiter)) {
301 splitValues.push_back(token);
302 }
303 if (splitValues.size() == 0) {
304 TLOGE(WmsLogTag::DMS, "failed, noting split");
305 return false;
306 }
307 return true;
308 }
309
IsNumber(const std::string & str)310 bool ScreenSettingHelper::IsNumber(const std::string& str)
311 {
312 int32_t length = static_cast<int32_t>(str.size());
313 int32_t start = 0;
314 while (start < length && isspace(str[start])) {
315 start++;
316 }
317 bool hasDot = false;
318 bool hasDigit = false;
319 if (start < length && str[start] == '-') {
320 start++;
321 }
322 for (int32_t i = start; i < length; ++i) {
323 if (str[i] == '.') {
324 if (hasDot) {
325 return false;
326 }
327 hasDot = true;
328 } else if (isdigit(str[i])) {
329 hasDigit = true;
330 } else {
331 return false;
332 }
333 }
334 return hasDigit;
335 }
336
ConvertStrToUint64(const std::string & str,uint64_t & num)337 bool ScreenSettingHelper::ConvertStrToUint64(const std::string& str, uint64_t& num)
338 {
339 char *endFlag;
340 errno = 0;
341 uint64_t tmp = static_cast<uint64_t>(std::strtoull(str.c_str(), &endFlag, BASE_TEN));
342 if (errno == ERANGE) {
343 return false;
344 } else if (endFlag == nullptr || *endFlag != '\0') {
345 return false;
346 }
347 num = tmp;
348 return true;
349 }
350
GetMultiScreenInfo(const std::string & key)351 std::map<std::string, MultiScreenInfo> ScreenSettingHelper::GetMultiScreenInfo(const std::string& key)
352 {
353 std::map<std::string, MultiScreenInfo> multiScreenInfoMap = {};
354 std::string value = "";
355 SettingProvider& settingProvider = SettingProvider::GetInstance(DISPLAY_MANAGER_SERVICE_SA_ID);
356 ErrCode ret = settingProvider.GetStringValueMultiUser(key, value);
357 if (ret != ERR_OK) {
358 TLOGE(WmsLogTag::DMS, "failed, ret=%{public}d", ret);
359 return multiScreenInfoMap;
360 }
361 std::string validString = RemoveInvalidChar(value);
362 std::vector<std::string> restoredScreen = {};
363 bool split = SplitString(restoredScreen, validString, ',');
364 if (!split) {
365 TLOGE(WmsLogTag::DMS, "split screen failed");
366 return multiScreenInfoMap;
367 }
368 for (auto infoString : restoredScreen) {
369 std::vector<std::string> infoVector = {};
370 split = SplitString(infoVector, infoString, ';');
371 if (!split || infoVector.size() != VALID_MULTI_SCREEN_INFO_SIZE) {
372 TLOGE(WmsLogTag::DMS, "split info failed");
373 continue;
374 }
375 MultiScreenInfo info = {};
376 if (!GetScreenMode(info, infoVector[INDEX_SCREEN_MODE])) {
377 continue;
378 }
379 if (!GetScreenRelativePosition(info, infoVector[INDEX_FIRST_RELATIVE_POSITION])) {
380 continue;
381 }
382 if (!GetScreenRelativePosition(info, infoVector[INDEX_SECOND_RELATIVE_POSITION])) {
383 continue;
384 }
385 if (info.mainScreenOption.screenId_ == info.secondaryScreenOption.screenId_) {
386 TLOGE(WmsLogTag::DMS, "invalid screen of relative position!");
387 continue;
388 }
389 multiScreenInfoMap[infoVector[INDEX_SCREEN_INFO]] = info;
390 }
391 return multiScreenInfoMap;
392 }
393
GetScreenMode(MultiScreenInfo & info,const std::string & inputString)394 bool ScreenSettingHelper::GetScreenMode(MultiScreenInfo& info, const std::string& inputString)
395 {
396 std::vector<std::string> screenMode = {};
397 bool split = SplitString(screenMode, inputString, ' ');
398 uint32_t dataSize = screenMode.size();
399 if (!split || dataSize != EXPECT_SCREEN_MODE_SIZE) {
400 TLOGE(WmsLogTag::DMS, "split failed, data size: %{public}d", dataSize);
401 return false;
402 }
403
404 uint32_t mode = 0;
405 if (!IsNumber(screenMode[DATA_INDEX_ZERO])) {
406 TLOGE(WmsLogTag::DMS, "not number");
407 return false;
408 } else {
409 mode = static_cast<uint32_t>(strtoll(screenMode[DATA_INDEX_ZERO].c_str(), nullptr, PARAM_NUM_TEN));
410 TLOGW(WmsLogTag::DMS, "internal screen mode: %{public}d", mode);
411 if (!UpdateScreenMode(info, mode, false)) {
412 return false;
413 }
414 }
415 if (!IsNumber(screenMode[DATA_INDEX_ONE])) {
416 TLOGE(WmsLogTag::DMS, "not number");
417 return false;
418 } else {
419 mode = static_cast<uint32_t>(strtoll(screenMode[DATA_INDEX_ONE].c_str(), nullptr, PARAM_NUM_TEN));
420 #ifdef FOLD_ABILITY_ENABLE
421 if (FoldScreenStateInternel::IsSuperFoldDisplayDevice() &&
422 SuperFoldStateManager::GetInstance().GetCurrentStatus() != SuperFoldStatus::EXPANDED) {
423 mode = SCREEN_MIRROR_IN_DATA;
424 }
425 #endif
426 TLOGW(WmsLogTag::DMS, "external screen mode: %{public}d", mode);
427 if (!UpdateScreenMode(info, mode, true)) {
428 return false;
429 }
430 }
431 return true;
432 }
433
UpdateScreenMode(MultiScreenInfo & info,uint32_t mode,bool isExternal)434 bool ScreenSettingHelper::UpdateScreenMode(MultiScreenInfo& info, uint32_t mode, bool isExternal)
435 {
436 if (mode == SCREEN_MAIN_IN_DATA) {
437 info.isExtendMain = isExternal;
438 } else if (mode == SCREEN_MIRROR_IN_DATA) {
439 info.multiScreenMode = MultiScreenMode::SCREEN_MIRROR;
440 } else if (mode == SCREEN_EXTEND_IN_DATA) {
441 info.multiScreenMode = MultiScreenMode::SCREEN_EXTEND;
442 } else {
443 TLOGE(WmsLogTag::DMS, "invalid mode!");
444 return false;
445 }
446 return true;
447 }
448
GetScreenRelativePosition(MultiScreenInfo & info,const std::string & inputString)449 bool ScreenSettingHelper::GetScreenRelativePosition(MultiScreenInfo& info, const std::string& inputString)
450 {
451 std::vector<std::string> relativePosition = {};
452 bool split = SplitString(relativePosition, inputString, ' ');
453 uint32_t dataSize = relativePosition.size();
454 if (!split || dataSize != EXPECT_RELATIVE_POSITION_SIZE) {
455 TLOGE(WmsLogTag::DMS, "split failed, data size: %{public}d", dataSize);
456 return false;
457 }
458
459 ScreenId screenId = SCREEN_ID_INVALID;
460 uint32_t startX = 0;
461 uint32_t startY = 0;
462 if (!IsNumber(relativePosition[DATA_INDEX_ZERO])) {
463 TLOGE(WmsLogTag::DMS, "not number");
464 return false;
465 } else {
466 screenId = static_cast<ScreenId>(strtoll(relativePosition[DATA_INDEX_ZERO].c_str(), nullptr, PARAM_NUM_TEN));
467 }
468 if (!IsNumber(relativePosition[DATA_INDEX_ONE])) {
469 TLOGE(WmsLogTag::DMS, "not number");
470 return false;
471 } else {
472 startX = static_cast<uint32_t>(strtoll(relativePosition[DATA_INDEX_ONE].c_str(), nullptr, PARAM_NUM_TEN));
473 }
474 if (!IsNumber(relativePosition[DATA_INDEX_TWO])) {
475 TLOGE(WmsLogTag::DMS, "not number");
476 return false;
477 } else {
478 startY = static_cast<uint32_t>(strtoll(relativePosition[DATA_INDEX_TWO].c_str(), nullptr, PARAM_NUM_TEN));
479 }
480 TLOGW(WmsLogTag::DMS, "screenId: %{public}" PRIu64 ", startX: %{public}d, startY: %{public}d",
481 screenId, startX, startY);
482
483 if ((RS_ID_INTERNAL == screenId && !info.isExtendMain) || (RS_ID_INTERNAL != screenId && info.isExtendMain)) {
484 TLOGI(WmsLogTag::DMS, "find main screen option");
485 info.mainScreenOption.screenId_ = screenId;
486 info.mainScreenOption.startX_ = startX;
487 info.mainScreenOption.startY_ = startY;
488 } else {
489 TLOGI(WmsLogTag::DMS, "find secondary screen option");
490 info.secondaryScreenOption.screenId_ = screenId;
491 info.secondaryScreenOption.startX_ = startX;
492 info.secondaryScreenOption.startY_ = startY;
493 }
494 return true;
495 }
496
GetScreenShape(ScreenId screenId)497 ScreenShape ScreenSettingHelper::GetScreenShape(ScreenId screenId)
498 {
499 std::istringstream iss(SCREEN_SHAPE);
500 std::string id;
501 std::string shape;
502 while (std::getline(iss, id, ':')) {
503 std::getline(iss, shape, ';');
504 if (!IsNumber(id)) {
505 TLOGI(WmsLogTag::DMS, "id is invalid");
506 continue;
507 }
508 if (screenId == static_cast<ScreenId>(std::stoi(id))) {
509 if (!IsNumber(shape)) {
510 TLOGE(WmsLogTag::DMS, "shape is invalid");
511 return ScreenShape::RECTANGLE;
512 }
513 return static_cast<ScreenShape>(std::stoi(shape));
514 }
515 }
516 TLOGI(WmsLogTag::DMS, "Can not find screen shape info. ccm:%{public}s", SCREEN_SHAPE.c_str());
517 return ScreenShape::RECTANGLE;
518 }
519
RegisterSettingWireCastObserver(SettingObserver::UpdateFunc func)520 void ScreenSettingHelper::RegisterSettingWireCastObserver(SettingObserver::UpdateFunc func)
521 {
522 if (wireCastObserver_) {
523 TLOGD(WmsLogTag::DMS, "setting wire cast observer is registered");
524 return;
525 }
526 SettingProvider& wireCastProvider = SettingProvider::GetInstance(DISPLAY_MANAGER_SERVICE_SA_ID);
527 wireCastObserver_ = wireCastProvider.CreateObserver(SETTING_CAST_KEY, func);
528 if (wireCastObserver_ == nullptr) {
529 TLOGE(WmsLogTag::DMS, "create observer failed");
530 return;
531 }
532 ErrCode ret = wireCastProvider.RegisterObserver(wireCastObserver_);
533 if (ret != ERR_OK) {
534 TLOGW(WmsLogTag::DMS, "failed, ret=%{public}d", ret);
535 wireCastObserver_ = nullptr;
536 }
537 }
538
UnregisterSettingWireCastObserver()539 void ScreenSettingHelper::UnregisterSettingWireCastObserver()
540 {
541 if (wireCastObserver_ == nullptr) {
542 TLOGD(WmsLogTag::DMS, "wireCastObserver_ is nullptr");
543 return;
544 }
545 SettingProvider& wireCastProvider = SettingProvider::GetInstance(DISPLAY_MANAGER_SERVICE_SA_ID);
546 ErrCode ret = wireCastProvider.UnregisterObserver(wireCastObserver_);
547 if (ret != ERR_OK) {
548 TLOGW(WmsLogTag::DMS, "failed, ret=%{public}d", ret);
549 }
550 wireCastObserver_ = nullptr;
551 }
552
RegisterSettingExtendScreenDpiObserver(SettingObserver::UpdateFunc func)553 void ScreenSettingHelper::RegisterSettingExtendScreenDpiObserver(SettingObserver::UpdateFunc func)
554 {
555 if (extendScreenDpiObserver_ != nullptr) {
556 TLOGD(WmsLogTag::DMS, "setting extend dpi observer is registered");
557 return;
558 }
559 SettingProvider& extendScreenProvider = SettingProvider::GetInstance(DISPLAY_MANAGER_SERVICE_SA_ID);
560 extendScreenDpiObserver_ = extendScreenProvider.CreateObserver(SETTING_EXTEND_DPI_KEY, func);
561 if (extendScreenDpiObserver_ == nullptr) {
562 TLOGE(WmsLogTag::DMS, "create observer failed");
563 return;
564 }
565 ErrCode ret = extendScreenProvider.RegisterObserver(extendScreenDpiObserver_);
566 if (ret != ERR_OK) {
567 TLOGW(WmsLogTag::DMS, "failed, ret=%{public}d", ret);
568 extendScreenDpiObserver_ = nullptr;
569 }
570 }
571
UnRegisterSettingExtendScreenDpiObserver()572 void ScreenSettingHelper::UnRegisterSettingExtendScreenDpiObserver()
573 {
574 if (extendScreenDpiObserver_ == nullptr) {
575 TLOGD(WmsLogTag::DMS, "extendScreenDpiObserver_ is nullptr");
576 return;
577 }
578 SettingProvider& extendScreenProvider = SettingProvider::GetInstance(DISPLAY_MANAGER_SERVICE_SA_ID);
579 ErrCode ret = extendScreenProvider.UnregisterObserver(extendScreenDpiObserver_);
580 if (ret != ERR_OK) {
581 TLOGW(WmsLogTag::DMS, "failed, ret=%{public}d", ret);
582 }
583 extendScreenDpiObserver_ = nullptr;
584 }
585
GetSettingExtendScreenDpi(float & coef,const std::string & key)586 bool ScreenSettingHelper::GetSettingExtendScreenDpi(float& coef, const std::string& key)
587 {
588 SettingProvider& extendScreenProvider = SettingProvider::GetInstance(DISPLAY_MANAGER_SERVICE_SA_ID);
589 int32_t value = INDEX_EXTEND_SCREEN_DPI_POSITION;
590 ErrCode ret = extendScreenProvider.GetIntValue(key, value);
591 if (ret != ERR_OK) {
592 TLOGE(WmsLogTag::DMS, "failed, ret=%{public}d", ret);
593 return false;
594 }
595 TLOGI(WmsLogTag::DMS, "get setting extend dpi is %{public}d", value);
596 switch (value) {
597 case EXTEND_SCREEN_DPI_LEVEL_NEG_ONE:
598 coef = EXTEND_SCREEN_DPI_NEG_ONE_PARAMETER;
599 break;
600 case EXTEND_SCREEN_DPI_LEVEL_ZERO:
601 coef = EXTEND_SCREEN_DPI_ZERO_PARAMETER;
602 break;
603 case EXTEND_SCREEN_DPI_LEVEL_ONE:
604 coef = EXTEND_SCREEN_DPI_ONE_PARAMETER;
605 break;
606 default:
607 coef = EXTEND_SCREEN_DPI_ONE_PARAMETER;
608 break;
609 }
610 return true;
611 }
612
ConvertStrToInt32(const std::string & str,int32_t & num)613 bool ScreenSettingHelper::ConvertStrToInt32(const std::string& str, int32_t& num)
614 {
615 auto res = std::from_chars(str.data(), str.data() + str.size(), num);
616 if (res.ec != std::errc()) {
617 return false;
618 }
619 return true;
620 }
621
RegisterSettingDuringCallStateObserver(SettingObserver::UpdateFunc func)622 void ScreenSettingHelper::RegisterSettingDuringCallStateObserver(SettingObserver::UpdateFunc func)
623 {
624 if (duringCallStateObserver_ != nullptr) {
625 TLOGW(WmsLogTag::DMS, "during call state observer is registered");
626 return;
627 }
628 SettingProvider& settingProvider = SettingProvider::GetInstance(DISPLAY_MANAGER_SERVICE_SA_ID);
629 duringCallStateObserver_ = settingProvider.CreateObserver(SETTING_DURING_CALL_KEY, func);
630 if (duringCallStateObserver_ == nullptr) {
631 TLOGE(WmsLogTag::DMS, "create observer failed");
632 return;
633 }
634 ErrCode ret = settingProvider.RegisterObserver(duringCallStateObserver_);
635 if (ret != ERR_OK) {
636 TLOGW(WmsLogTag::DMS, "failed, ret=%{public}d", ret);
637 duringCallStateObserver_ = nullptr;
638 }
639 }
640
UnregisterSettingDuringCallStateObserver()641 void ScreenSettingHelper::UnregisterSettingDuringCallStateObserver()
642 {
643 if (duringCallStateObserver_ == nullptr) {
644 TLOGW(WmsLogTag::DMS, "duringCallStateObserver_ is nullptr");
645 return;
646 }
647 SettingProvider& settingProvider = SettingProvider::GetInstance(DISPLAY_MANAGER_SERVICE_SA_ID);
648 ErrCode ret = settingProvider.UnregisterObserver(duringCallStateObserver_);
649 if (ret != ERR_OK) {
650 TLOGW(WmsLogTag::DMS, "failed, ret=%{public}d", ret);
651 }
652 duringCallStateObserver_ = nullptr;
653 }
654
GetSettingDuringCallState(bool & enable,const std::string & key)655 bool ScreenSettingHelper::GetSettingDuringCallState(bool& enable, const std::string& key)
656 {
657 SettingProvider& settingProvider = SettingProvider::GetInstance(DISPLAY_MANAGER_SERVICE_SA_ID);
658 bool value = 0;
659 ErrCode ret = settingProvider.GetBoolValue(key, value);
660 if (ret != ERR_OK) {
661 TLOGE(WmsLogTag::DMS, "failed, ret=%{public}d", ret);
662 return false;
663 }
664 TLOGI(WmsLogTag::DMS, "get during call state is %{public}d", value);
665 enable = value;
666 return true;
667 }
668
SetSettingDuringCallState(const std::string & key,bool value)669 bool ScreenSettingHelper::SetSettingDuringCallState(const std::string& key, bool value)
670 {
671 SettingProvider& settingProvider = SettingProvider::GetInstance(DISPLAY_MANAGER_SERVICE_SA_ID);
672 ErrCode ret = settingProvider.PutBoolValue(key, value);
673 if (ret != ERR_OK) {
674 TLOGE(WmsLogTag::DMS, "failed, ret=%{public}d", ret);
675 return false;
676 }
677 TLOGI(WmsLogTag::DMS, "put during call state is %{public}d", value);
678 return true;
679 }
680 } // namespace Rosen
681 } // namespace OHOS
682