Star34
765
代码
代码
Issues258
Pull Requests192
项目讨论
Wiki
分析
Star34
765
已合并
兼容模式开关 #17703
松本松创建于 1月23日
兼容模式开关 #17703
已合并
松本松创建于 1月23日
从weixin_66524478/window_window_manager_4316master合入到openharmony/window_window_managermaster
共 6 个文件变更+440-5
Mwindow_scene/screen_session_manager/include/screen_session_manager.h+10-1
@@ -369,6 +369,13 @@ public:
369 void NotifyScreenMagneticStateChanged(bool isMagneticState);369 void NotifyScreenMagneticStateChanged(bool isMagneticState);
370 void OnTentModeChanged(int tentType, int32_t hall = -1);370 void OnTentModeChanged(int tentType, int32_t hall = -1);
371 void RegisterSettingDpiObserver();371 void RegisterSettingDpiObserver();
372+ void RegisterOffScreenRenderingSettingSwitchObserver();
373+ void SetExtendScreenDpiFromSettingData();
374+ float CalDefaultExtendScreenDensity(ScreenProperty& property);
375+ float GetOptionalDpi(const float dpi);
376+ void GetOrCalExtendScreenDefaultDensity(const sptr<ScreenSession> session,
377+ ScreenProperty& property, float& extendDensity);
378+ void InitExtendScreenDpiOptions();
372 void RegisterSettingRotationObserver();379 void RegisterSettingRotationObserver();
373 void NotifyBrightnessInfoChanged(ScreenId screenId, const BrightnessInfo& info);380 void NotifyBrightnessInfoChanged(ScreenId screenId, const BrightnessInfo& info);
374 381 
@@ -959,7 +966,7 @@ private:
959 float pcModeDpi_ { 1.0f };966 float pcModeDpi_ { 1.0f };
960 967 
961 uint32_t defaultDpi {0};968 uint32_t defaultDpi {0};
962- uint32_t extendDefaultDpi_ {0};969+ float extendDefaultDensity_ {1.0f};
hejunfei1991
hejunfei1991hejunfei19911月23日

默认值为什么是1.0

likedislike
松本松
松本松
1月23日 评论：
963 uint32_t defaultDeviceRotationOffset_ { 0 };970 uint32_t defaultDeviceRotationOffset_ { 0 };
964 std::atomic<ExtendScreenConnectStatus> extendScreenConnectStatus_ = ExtendScreenConnectStatus::UNKNOWN;971 std::atomic<ExtendScreenConnectStatus> extendScreenConnectStatus_ = ExtendScreenConnectStatus::UNKNOWN;
965 bool isExtendScreenConnected_ = false;972 bool isExtendScreenConnected_ = false;
@@ -1068,7 +1075,9 @@ private:
1068 bool isCallingByThirdParty);1075 bool isCallingByThirdParty);
1069 bool IsSupportCoordination();1076 bool IsSupportCoordination();
1070 void RegisterSettingExtendScreenDpiObserver();1077 void RegisterSettingExtendScreenDpiObserver();
1078+ void RegisterSettingExtendScreenIndepDpiObserver();
1071 void SetExtendScreenDpi();1079 void SetExtendScreenDpi();
1080+ void SetExtendScreenIndepDpi();
1072 void RegisterSettingBorderingAreaPercentObserver();1081 void RegisterSettingBorderingAreaPercentObserver();
1073 void SetBorderingAreaPercent();1082 void SetBorderingAreaPercent();
1074 bool HandleSwitchPcMode();1083 bool HandleSwitchPcMode();
Mwindow_scene/screen_session_manager/include/screen_setting_helper.h+9-0
@@ -34,6 +34,8 @@ class ScreenSettingHelper {
34public:34public:
35 static void RegisterSettingDpiObserver(SettingObserver::UpdateFunc func);35 static void RegisterSettingDpiObserver(SettingObserver::UpdateFunc func);
36 static void UnregisterSettingDpiObserver();36 static void UnregisterSettingDpiObserver();
37+ static void RegisterSettingOffScreenRenderObserver(SettingObserver::UpdateFunc func);
38+ static bool GetSettingOffScreenRenderValue(bool& offerRenderValue_, const std::string& key);
37 static bool GetSettingDpi(uint32_t& dpi, const std::string& key = SETTING_DPI_KEY);39 static bool GetSettingDpi(uint32_t& dpi, const std::string& key = SETTING_DPI_KEY);
38 static bool SetSettingDefaultDpi(uint32_t& dpi, const std::string& key);40 static bool SetSettingDefaultDpi(uint32_t& dpi, const std::string& key);
39 static bool GetSettingValue(uint32_t& value, const std::string& key);41 static bool GetSettingValue(uint32_t& value, const std::string& key);
@@ -56,6 +58,8 @@ public:
56 static std::map<std::string, MultiScreenInfo> GetMultiScreenInfo(const std::string& key = SETTING_SCREEN_MODE_KEY);58 static std::map<std::string, MultiScreenInfo> GetMultiScreenInfo(const std::string& key = SETTING_SCREEN_MODE_KEY);
57 static std::map<std::string, SupportedScreenModes> GetResolutionMode(const std::string& key =59 static std::map<std::string, SupportedScreenModes> GetResolutionMode(const std::string& key =
58 SETTING_SCREEN_RESOLUTION_MODE_KEY);60 SETTING_SCREEN_RESOLUTION_MODE_KEY);
61+ static std::map<std::string, std::string> GetDpiMode(const std::string& key =
62+ SETTING_EXTEND_INDEP_DPI_KEY);
59 static std::map<std::string, uint32_t> GetBorderingAreaPercent(const std::string& key =63 static std::map<std::string, uint32_t> GetBorderingAreaPercent(const std::string& key =
60 SETTING_SCREEN_BORDERING_AREA_PERCENT_KEY);64 SETTING_SCREEN_BORDERING_AREA_PERCENT_KEY);
61 static bool GetScreenMode(MultiScreenInfo& info, const std::string& inputString);65 static bool GetScreenMode(MultiScreenInfo& info, const std::string& inputString);
@@ -70,6 +74,8 @@ public:
70 static void UnregisterSettingBorderingAreaPercentObserver();74 static void UnregisterSettingBorderingAreaPercentObserver();
71 static void RegisterSettingExtendScreenDpiObserver(SettingObserver::UpdateFunc func);75 static void RegisterSettingExtendScreenDpiObserver(SettingObserver::UpdateFunc func);
72 static void UnRegisterSettingExtendScreenDpiObserver();76 static void UnRegisterSettingExtendScreenDpiObserver();
77+ static void RegisterSettingExtendScreenIndepDpiObserver(SettingObserver::UpdateFunc func);
78+ static void UnRegisterSettingExtendScreenIndepDpiObserver();
73 static void RegisterSettingDuringCallStateObserver(SettingObserver::UpdateFunc func);79 static void RegisterSettingDuringCallStateObserver(SettingObserver::UpdateFunc func);
74 static void UnregisterSettingDuringCallStateObserver();80 static void UnregisterSettingDuringCallStateObserver();
75 static bool GetSettingDuringCallState(bool& enable, const std::string& key = SETTING_DURING_CALL_KEY);81 static bool GetSettingDuringCallState(bool& enable, const std::string& key = SETTING_DURING_CALL_KEY);
@@ -134,6 +140,7 @@ private:
134 static const constexpr char* SETTING_ROTATION_SCREEN_ID_KEY {"screen_rotation_screen_id_value"};140 static const constexpr char* SETTING_ROTATION_SCREEN_ID_KEY {"screen_rotation_screen_id_value"};
135 static const constexpr char* SETTING_SCREEN_MODE_KEY {"user_set_screen_mode_edid"};141 static const constexpr char* SETTING_SCREEN_MODE_KEY {"user_set_screen_mode_edid"};
136 static const constexpr char* SETTING_EXTEND_DPI_KEY {"user_set_dpi_extend"};142 static const constexpr char* SETTING_EXTEND_DPI_KEY {"user_set_dpi_extend"};
143+ static const constexpr char* SETTING_EXTEND_INDEP_DPI_KEY {"user_set_indep_dpi_extend"};
137 static const constexpr char* SETTING_DURING_CALL_KEY {"during_call_state"};144 static const constexpr char* SETTING_DURING_CALL_KEY {"during_call_state"};
138 static const constexpr char* SETTING_RESOLUTION_EFFECT_KEY {"user_set_resolution_effect_select"};145 static const constexpr char* SETTING_RESOLUTION_EFFECT_KEY {"user_set_resolution_effect_select"};
139 static const constexpr char* SETTING_COMPATIBLE_APP_STRATEGY_KEY {"COMPATIBLE_APP_STRATEGY"};146 static const constexpr char* SETTING_COMPATIBLE_APP_STRATEGY_KEY {"COMPATIBLE_APP_STRATEGY"};
@@ -143,10 +150,12 @@ private:
143 static const constexpr char* SETTING_DUAL_DISPLAY_READY_KEY {"settings.display.dual_display_ready"};150 static const constexpr char* SETTING_DUAL_DISPLAY_READY_KEY {"settings.display.dual_display_ready"};
144 static const constexpr uint32_t BASE_TEN = 10;151 static const constexpr uint32_t BASE_TEN = 10;
145 static sptr<SettingObserver> dpiObserver_;152 static sptr<SettingObserver> dpiObserver_;
153+ static sptr<SettingObserver> offScreenRenderObserver_;
146 static sptr<SettingObserver> castObserver_;154 static sptr<SettingObserver> castObserver_;
147 static sptr<SettingObserver> rotationObserver_;155 static sptr<SettingObserver> rotationObserver_;
148 static sptr<SettingObserver> wireCastObserver_;156 static sptr<SettingObserver> wireCastObserver_;
149 static sptr<SettingObserver> extendScreenDpiObserver_;157 static sptr<SettingObserver> extendScreenDpiObserver_;
158+ static sptr<SettingObserver> extendScreenIndepDpiObserver_;
150 static sptr<SettingObserver> duringCallStateObserver_;159 static sptr<SettingObserver> duringCallStateObserver_;
151 static sptr<SettingObserver> resolutionEffectObserver_;160 static sptr<SettingObserver> resolutionEffectObserver_;
152 static sptr<SettingObserver> correctionExemptionListObserver_;161 static sptr<SettingObserver> correctionExemptionListObserver_;
Mwindow_scene/screen_session_manager/src/screen_session_manager.cpp+169-4
@@ -166,6 +166,16 @@ constexpr float DEFAULT_SCALE = 1.0f;
166constexpr float SECONDARY_ROTATION_90 = 90.0F;166constexpr float SECONDARY_ROTATION_90 = 90.0F;
167constexpr float SECONDARY_ROTATION_270 = 270.0F;167constexpr float SECONDARY_ROTATION_270 = 270.0F;
168static const constexpr char* SET_SETTING_DPI_KEY {"default_display_dpi"};168static const constexpr char* SET_SETTING_DPI_KEY {"default_display_dpi"};
169+static bool g_offScreenRenderValue = true;
170+std::vector<float> extendScreenDpiOptions {};
171+constexpr int32_t EXTEND_SCREEN_DPI_OPTIONS_COUNT { 16 };
172+constexpr float EXTEND_SCREEN_DPI_MIN_VALUE { 136.0f };
173+constexpr float EXTEND_SCREEN_DPI_INCREASE_STEP { 24.0f };
174+constexpr float EXTEND_SCREEN_DPI_BASELINE { 160.0f };
hejunfei1991
hejunfei1991hejunfei19911月23日

貌似已经有160的base_line

likedislike
松本松
松本松
1月23日 评论：
175+const bool SUPPORT_COMPATIBLE_MODE =
176+ (system::GetIntParameter<int32_t>("const.settings.extend_display_function_list", 0) & 0x4) == 4;
177+const std::string SETTING_OFF_SCREEN_RENDERING_SWITCH_KEY = "off_screen_rendering_switch";
178+constexpr float PHYSICAL_MASS = 1.6f;
169const std::vector<std::string> ROTATION_DEFAULT = {"0", "1", "2", "3"};179const std::vector<std::string> ROTATION_DEFAULT = {"0", "1", "2", "3"};
170const std::vector<std::string> ORIENTATION_DEFAULT = {"0", "1", "2", "3"};180const std::vector<std::string> ORIENTATION_DEFAULT = {"0", "1", "2", "3"};
171const uint32_t MAX_INTERVAL_US = 1800000000; // 30分钟181const uint32_t MAX_INTERVAL_US = 1800000000; // 30分钟
@@ -273,6 +283,13 @@ inline int32_t GetUserIdByCallingUid()
273 283 
274WM_IMPLEMENT_SINGLE_INSTANCE(ScreenSessionManager)284WM_IMPLEMENT_SINGLE_INSTANCE(ScreenSessionManager)
275 285 
286+void ScreenSessionManager::InitExtendScreenDpiOptions()
287+{
288+ for (int i = 0; i < EXTEND_SCREEN_DPI_OPTIONS_COUNT; ++i) {
289+ extendScreenDpiOptions.push_back(EXTEND_SCREEN_DPI_MIN_VALUE + EXTEND_SCREEN_DPI_INCREASE_STEP * i);
290+ }
291+}
292+ 
276static void* g_dmsExtHandler = nullptr;293static void* g_dmsExtHandler = nullptr;
277void ScreenSessionManager::LoadDmsExtension()294void ScreenSessionManager::LoadDmsExtension()
278{295{
@@ -334,6 +351,9 @@ ScreenSessionManager::ScreenSessionManager()
334 SetFirstSCBConnect(true);351 SetFirstSCBConnect(true);
335 WatchParameter(BOOTEVENT_BOOT_COMPLETED.c_str(), BootFinishedCallback, this);352 WatchParameter(BOOTEVENT_BOOT_COMPLETED.c_str(), BootFinishedCallback, this);
336 isSupportCapture_ = IsSupportCapture();353 isSupportCapture_ = IsSupportCapture();
354+ if (SUPPORT_COMPATIBLE_MODE) {
355+ InitExtendScreenDpiOptions();
356+ }
337}357}
338 358 
339bool SortByScreenId(const ScreenId& screenIdA, const ScreenId& screenIdB)359bool SortByScreenId(const ScreenId& screenIdA, const ScreenId& screenIdB)
@@ -4112,8 +4132,8 @@ void ScreenSessionManager::InitExtendScreenProperty(ScreenId screenId, sptr<Scre
4112 return;4132 return;
4113 }4133 }
4114 bool isSupportOffScreenRendering = ScreenSceneConfig::IsSupportOffScreenRendering();4134 bool isSupportOffScreenRendering = ScreenSceneConfig::IsSupportOffScreenRendering();
4115- if (!isSupportOffScreenRendering) {4135+ if (!isSupportOffScreenRendering || !g_offScreenRenderValue) {
4116- TLOGNFW(WmsLogTag::DMS, "xml isSupportOffScreenRendering is fasle");4136+ TLOGNFW(WmsLogTag::DMS, "current is not OffScreenRendering");
4117 return;4137 return;
4118 }4138 }
4119 GetInternalWidth();4139 GetInternalWidth();
@@ -4240,6 +4260,55 @@ void ScreenSessionManager::SetInnerScreenFallbackPlan(sptr<ScreenSession> screen
4240 screenId, screenAdjustWidth, screenAdjustHeight);4260 screenId, screenAdjustWidth, screenAdjustHeight);
4241}4261}
4242 4262 
4263+float ScreenSessionManager::CalDefaultExtendScreenDensity(ScreenProperty& property)
4264+{
4265+ float PPI = property.GetScreenRealPPI();
4266+ if (PPI > EPSILON) {
4267+ float defaultExtendScreenDPI = std::ceil(PPI * PHYSICAL_MASS);
4268+ return defaultExtendScreenDPI / BASELINE_DENSITY;
4269+ } else {
4270+ return densityDpi_;
4271+ }
4272+}
4273+
4274+float ScreenSessionManager::GetOptionalDpi(const float dpi) {
4275+ if (dpi <= EXTEND_SCREEN_DPI_BASELINE + EPSILON) {
4276+ return EXTEND_SCREEN_DPI_BASELINE;
4277+ }
4278+ auto it = std::lower_bound(extendScreenDpiOptions.begin(), extendScreenDpiOptions.end(), dpi);
4279+ if (it == extendScreenDpiOptions.end()) {
4280+ return extendScreenDpiOptions.back();
4281+ } else {
4282+ float optionDpi_ = *it;
4283+ if (optionDpi_ - dpi > EXTEND_SCREEN_DPI_INCREASE_STEP / 2) {
4284+ optionDpi_ -= EXTEND_SCREEN_DPI_INCREASE_STEP;
4285+ }
4286+ return optionDpi_;
4287+ }
4288+}
4289+
4290+void ScreenSessionManager::GetOrCalExtendScreenDefaultDensity(const sptr<ScreenSession> session,
4291+ ScreenProperty& property, float& extendDensity)
4292+{
4293+ if (g_offScreenRenderValue) {
4294+ return;
4295+ }
4296+ std::map<std::string, std::string> dpiMap = ScreenSettingHelper::GetDpiMode();
4297+ std::string serialNumber = session->GetSerialNumber();
4298+ auto it = dpiMap.find(serialNumber);
4299+ if (it == dpiMap.end()) {
4300+ float density_ = CalDefaultExtendScreenDensity(property);
4301+ float dpi = GetOptionalDpi(density_ * BASELINE_DENSITY);
4302+ extendDefaultDensity_ = dpi / BASELINE_DENSITY;
4303+ extendDensity = extendDefaultDensity_;
4304+ g_extendScreenDpiCoef = EXTEND_SCREEN_DPI_DEFAULT_PARAMETER;
4305+ TLOGNFW(WmsLogTag::DMS, "get setting dpi fail, use extend screen default dpi");
4306+ } else {
4307+ g_extendScreenDpiCoef = std::stof(dpiMap[serialNumber]) / BASELINE_DENSITY;
4308+ extendDensity = EXTEND_SCREEN_DPI_DEFAULT_PARAMETER;
4309+ }
4310+}
4311+ 
4243void ScreenSessionManager::InitExtendScreenDensity(sptr<ScreenSession> session, ScreenProperty property)4312void ScreenSessionManager::InitExtendScreenDensity(sptr<ScreenSession> session, ScreenProperty property)
4244{4313{
4245 if (session->GetScreenProperty().GetScreenType() != ScreenType::REAL || session->isInternal_) {4314 if (session->GetScreenProperty().GetScreenType() != ScreenType::REAL || session->isInternal_) {
@@ -4254,6 +4323,7 @@ void ScreenSessionManager::InitExtendScreenDensity(sptr<ScreenSession> session,
4254 return;4323 return;
4255 }4324 }
4256 float extendDensity = screenSession->GetScreenProperty().GetDensity();4325 float extendDensity = screenSession->GetScreenProperty().GetDensity();
4326+ GetOrCalExtendScreenDefaultDensity(session, property, extendDensity);
4257 float curResolution = screenSession->GetScreenProperty().GetDensityInCurResolution();4327 float curResolution = screenSession->GetScreenProperty().GetDensityInCurResolution();
4258 float defaultDensity = screenSession->GetScreenProperty().GetDefaultDensity();4328 float defaultDensity = screenSession->GetScreenProperty().GetDefaultDensity();
4259 TLOGNFW(WmsLogTag::DMS, "extendDensity = %{public}f", extendDensity);4329 TLOGNFW(WmsLogTag::DMS, "extendDensity = %{public}f", extendDensity);
@@ -5588,7 +5658,17 @@ void ScreenSessionManager::BootFinishedCallback(const char *key, const char *val
5588 auto &that = *reinterpret_cast<ScreenSessionManager *>(context);5658 auto &that = *reinterpret_cast<ScreenSessionManager *>(context);
5589 that.SetRotateLockedFromSettingData();5659 that.SetRotateLockedFromSettingData();
5590 that.SetDpiFromSettingData();5660 that.SetDpiFromSettingData();
5591- that.SetExtendScreenDpi();5661+ if (SUPPORT_COMPATIBLE_MODE) {
5662+ ScreenSettingHelper::GetSettingOffScreenRenderValue(g_offScreenRenderValue,
5663+ SETTING_OFF_SCREEN_RENDERING_SWITCH_KEY);
5664+ that.RegisterOffScreenRenderingSettingSwitchObserver();
5665+ that.RegisterSettingExtendScreenIndepDpiObserver();
5666+ }
5667+ if (g_offScreenRenderValue) {
5668+ that.SetExtendScreenDpi();
5669+ } else {
5670+ that.SetExtendScreenIndepDpi();
5671+ }
5592 that.SetBorderingAreaPercent();5672 that.SetBorderingAreaPercent();
5593 that.UpdateDisplayState(that.GetAllScreenIds(), DisplayState::ON);5673 that.UpdateDisplayState(that.GetAllScreenIds(), DisplayState::ON);
5594 that.RegisterSettingDpiObserver();5674 that.RegisterSettingDpiObserver();
@@ -5734,6 +5814,60 @@ void ScreenSessionManager::RegisterSettingDpiObserver()
5734 ScreenSettingHelper::RegisterSettingDpiObserver(DmUtils::wrap_callback(updateFunc));5814 ScreenSettingHelper::RegisterSettingDpiObserver(DmUtils::wrap_callback(updateFunc));
5735}5815}
5736 5816 
5817+void ScreenSessionManager::RegisterOffScreenRenderingSettingSwitchObserver()
5818+{
5819+ TLOGNFI(WmsLogTag::DMS, "Register off screen rendering Setting Switch Observer");
5820+ SettingObserver::UpdateFunc updateFunc = [&](const std::string& key) { SetExtendScreenDpiFromSettingData(); };
5821+ ScreenSettingHelper::RegisterSettingOffScreenRenderObserver(DmUtils::wrap_callback(updateFunc));
5822+}
5823+
5824+void ScreenSessionManager::SetExtendScreenDpiFromSettingData()
5825+{
5826+#ifdef WM_MULTI_SCREEN_ENABLE
5827+ OnScreenModeChange(ScreenModeChangeEvent::BEGIN);
5828+ {
5829+ std::unique_lock<std::mutex> lock(screenMaskMutex_);
5830+ if (DmUtils::safe_wait_for(screenMaskCV_, lock,
5831+ std::chrono::milliseconds(CV_WAIT_SCREEN_MASK_MS)) == std::cv_status::timeout) {
5832+ TLOGNFI(WmsLogTag::DMS, "wait screenMaskMutex_ timeout");
5833+ }
5834+ }
5835+ ScreenSettingHelper::GetSettingOffScreenRenderValue(g_offScreenRenderValue,
5836+ SETTING_OFF_SCREEN_RENDERING_SWITCH_KEY);
5837+ sptr<ScreenSession> innerSession = nullptr;
5838+ sptr<ScreenSession> externalSession = nullptr;
5839+ GetInternalAndExternalSession(innerSession, externalSession);
5840+ if (!innerSession || !externalSession) {
5841+ TLOGNFE(WmsLogTag::DMS, "screen session is null.");
5842+ return;
5843+ }
5844+ RRect previousScreenBounds = externalSession->GetScreenProperty().GetBounds();
5845+ sptr<ScreenSession> phyScreenSession = GetPhysicalScreenSession(externalSession->GetRSScreenId());
5846+ auto externalScreenProperty = externalSession->GetScreenProperty();
5847+ if (g_offScreenRenderValue) {
5848+ SetExtendScreenDpi();
5849+ InitExtendScreenProperty(phyScreenSession->GetScreenId(), phyScreenSession,
5850+ phyScreenSession->GetScreenProperty());
5851+ InitExtendScreenProperty(externalSession->GetScreenId(), externalSession, externalScreenProperty);
5852+ } else {
5853+ auto externalphyBounds = externalScreenProperty.GetPhyBounds();
5854+ externalSession->SetExtendProperty(externalphyBounds, g_offScreenRenderValue);
5855+ phyScreenSession->SetExtendProperty(externalphyBounds, g_offScreenRenderValue);
5856+ uint32_t offWidth = externalphyBounds.rect_.GetWidth();
5857+ uint32_t offHeight = externalphyBounds.rect_.GetHeight();
5858+ int32_t res = RSInterfaces::GetInstance().SetPhysicalScreenResolution(
5859+ externalSession->GetRSScreenId(), offWidth, offHeight);
5860+ std::string offScreenResult = (res == StatusCode::SUCCESS) ? "success" : "failed";
5861+ TLOGNFW(WmsLogTag::DMS, "rsId=%{public}" PRIu64" offScreen width=%{public}u height=%{public}u %{public}s",
5862+ externalSession->GetRSScreenId(), offWidth, offHeight, offScreenResult.c_str());
5863+ SetExtendScreenIndepDpi();
5864+ }
5865+ externalSession->SetScreenOffScreenRendering();
5866+ CheckAndNotifyChangeMode(previousScreenBounds, externalSession);
5867+ OnScreenModeChange(ScreenModeChangeEvent::END);
5868+#endif
5869+}
5870+ 
5737void ScreenSessionManager::SetDpiFromSettingData()5871void ScreenSessionManager::SetDpiFromSettingData()
5738{5872{
5739 uint32_t settingDpi;5873 uint32_t settingDpi;
@@ -5757,7 +5891,7 @@ void ScreenSessionManager::SetDpiFromSettingData()
5757 }5891 }
5758 }5892 }
5759 SetVirtualPixelRatio(defaultScreenId, dpi);5893 SetVirtualPixelRatio(defaultScreenId, dpi);
5760- if (g_isPcDevice) {5894+ if (g_isPcDevice && g_offScreenRenderValue) {
5761 SetExtendPixelRatio(dpi * g_extendScreenDpiCoef);5895 SetExtendPixelRatio(dpi * g_extendScreenDpiCoef);
5762 }5896 }
5763 } else {5897 } else {
@@ -13183,6 +13317,13 @@ void ScreenSessionManager::RegisterSettingExtendScreenDpiObserver()
13183 ScreenSettingHelper::RegisterSettingExtendScreenDpiObserver(DmUtils::wrap_callback(updateFunc));13317 ScreenSettingHelper::RegisterSettingExtendScreenDpiObserver(DmUtils::wrap_callback(updateFunc));
13184}13318}
13185 13319 
13320+void ScreenSessionManager::RegisterSettingExtendScreenIndepDpiObserver()
13321+{
13322+ TLOGNFI(WmsLogTag::DMS, "Register Setting Extend independent Dpi Observer");
13323+ SettingObserver::UpdateFunc updateFunc = [&](const std::string& key) { SetExtendScreenIndepDpi(); };
13324+ ScreenSettingHelper::RegisterSettingExtendScreenIndepDpiObserver(DmUtils::wrap_callback(updateFunc));
13325+}
13326+ 
13186void ScreenSessionManager::SetExtendScreenDpi()13327void ScreenSessionManager::SetExtendScreenDpi()
13187{13328{
13188 float extendScreenDpiCoef = EXTEND_SCREEN_DPI_DEFAULT_PARAMETER;13329 float extendScreenDpiCoef = EXTEND_SCREEN_DPI_DEFAULT_PARAMETER;
@@ -13198,6 +13339,30 @@ void ScreenSessionManager::SetExtendScreenDpi()
13198 TLOGNFI(WmsLogTag::DMS, "get setting extend screen dpi is : %{public}f", g_extendScreenDpiCoef);13339 TLOGNFI(WmsLogTag::DMS, "get setting extend screen dpi is : %{public}f", g_extendScreenDpiCoef);
13199}13340}
13200 13341 
13342+void ScreenSessionManager::SetExtendScreenIndepDpi()
13343+{
13344+ sptr<ScreenSession> innerSession = nullptr;
13345+ sptr<ScreenSession> externalSession = nullptr;
13346+ GetInternalAndExternalSession(innerSession, externalSession);
13347+ if (!innerSession || !externalSession) {
13348+ TLOGNFE(WmsLogTag::DMS, "screen session is null.");
13349+ return;
13350+ }
13351+ std::map<std::string, std::string> dpiMap = ScreenSettingHelper::GetDpiMode();
13352+ std::string serialNumber = externalSession->GetSerialNumber();
13353+ ScreenId screenId = externalSession->GetScreenId();
13354+ auto it = dpiMap.find(serialNumber);
13355+ if (it == dpiMap.end()) {
13356+ TLOGNFW(WmsLogTag::DMS, "get setting extend screen density fail,"
13357+ "use default density: %{public}f", extendDefaultDensity_);
13358+ SetVirtualPixelRatio(screenId, extendDefaultDensity_);
13359+ } else {
13360+ float density_ = std::stof(dpiMap[serialNumber]) / BASELINE_DENSITY;
13361+ SetVirtualPixelRatio(screenId, density_);
13362+ TLOGNFI(WmsLogTag::DMS, "get setting extend screen density: %{public}f", density_);
13363+ }
13364+}
13365+ 
13201sptr<ScreenSession> ScreenSessionManager::GetFakePhysicalScreenSession(ScreenId screenId, ScreenId defScreenId,13366sptr<ScreenSession> ScreenSessionManager::GetFakePhysicalScreenSession(ScreenId screenId, ScreenId defScreenId,
13202 ScreenProperty property)13367 ScreenProperty property)
13203{13368{
Mwindow_scene/screen_session_manager/src/screen_setting_helper.cpp+101-0
@@ -28,10 +28,12 @@
28namespace OHOS {28namespace OHOS {
29namespace Rosen {29namespace Rosen {
30sptr<SettingObserver> ScreenSettingHelper::dpiObserver_;30sptr<SettingObserver> ScreenSettingHelper::dpiObserver_;
31+sptr<SettingObserver> ScreenSettingHelper::offScreenRenderObserver_;
31sptr<SettingObserver> ScreenSettingHelper::castObserver_;32sptr<SettingObserver> ScreenSettingHelper::castObserver_;
32sptr<SettingObserver> ScreenSettingHelper::rotationObserver_;33sptr<SettingObserver> ScreenSettingHelper::rotationObserver_;
33sptr<SettingObserver> ScreenSettingHelper::wireCastObserver_;34sptr<SettingObserver> ScreenSettingHelper::wireCastObserver_;
34sptr<SettingObserver> ScreenSettingHelper::extendScreenDpiObserver_;35sptr<SettingObserver> ScreenSettingHelper::extendScreenDpiObserver_;
36+sptr<SettingObserver> ScreenSettingHelper::extendScreenIndepDpiObserver_;
35sptr<SettingObserver> ScreenSettingHelper::duringCallStateObserver_;37sptr<SettingObserver> ScreenSettingHelper::duringCallStateObserver_;
36sptr<SettingObserver> ScreenSettingHelper::resolutionEffectObserver_;38sptr<SettingObserver> ScreenSettingHelper::resolutionEffectObserver_;
37sptr<SettingObserver> ScreenSettingHelper::correctionExemptionListObserver_;39sptr<SettingObserver> ScreenSettingHelper::correctionExemptionListObserver_;
@@ -44,6 +46,8 @@ constexpr uint32_t EXPECT_SCREEN_MODE_SIZE = 2;
44constexpr uint32_t EXPECT_PERCENT_SIZE = 1;46constexpr uint32_t EXPECT_PERCENT_SIZE = 1;
45constexpr uint32_t EXPECT_RELATIVE_POSITION_SIZE = 3;47constexpr uint32_t EXPECT_RELATIVE_POSITION_SIZE = 3;
46constexpr uint32_t VALID_MULTI_SCREEN_INFO_SIZE = 5;48constexpr uint32_t VALID_MULTI_SCREEN_INFO_SIZE = 5;
49+constexpr uint32_t VALID_DPI_MODE_SIZE = 2;
50+constexpr uint32_t INDEX_DPI_MODE = 1;
47constexpr uint32_t VALID_PERCENT_SIZE = 2;51constexpr uint32_t VALID_PERCENT_SIZE = 2;
48constexpr uint32_t INDEX_SCREEN_INFO = 0;52constexpr uint32_t INDEX_SCREEN_INFO = 0;
49constexpr uint32_t INDEX_SCREEN_MODE = 1;53constexpr uint32_t INDEX_SCREEN_MODE = 1;
@@ -70,6 +74,7 @@ const std::string ENABLE_RESOLUTION_EFFECT = "1";
70constexpr int32_t EXPECT_SCREEN_RESOLUTION_EFFECT_SIZE = 2;74constexpr int32_t EXPECT_SCREEN_RESOLUTION_EFFECT_SIZE = 2;
71constexpr int32_t INDEX_SCREEN_RESOLUTION_EFFECT_SN = 0;75constexpr int32_t INDEX_SCREEN_RESOLUTION_EFFECT_SN = 0;
72constexpr int32_t INDEX_SCREEN_RESOLUTION_EFFECT_EN = 1;76constexpr int32_t INDEX_SCREEN_RESOLUTION_EFFECT_EN = 1;
77+const std::string SETTING_OFF_SCREEN_RENDERING_SWITCH_KEY = "off_screen_rendering_switch";
73const std::string USE_LOGIC_CAMERA_STRING = "useLogicCamera";78const std::string USE_LOGIC_CAMERA_STRING = "useLogicCamera";
74const std::string CUSTOM_LOGIC_DIRECTION_STRING = "customLogicDirection";79const std::string CUSTOM_LOGIC_DIRECTION_STRING = "customLogicDirection";
75 80 
@@ -105,6 +110,38 @@ void ScreenSettingHelper::UnregisterSettingDpiObserver()
105 dpiObserver_ = nullptr;110 dpiObserver_ = nullptr;
106}111}
107 112 
113+void ScreenSettingHelper::RegisterSettingOffScreenRenderObserver(SettingObserver::UpdateFunc func)
114+{
115+ if (offScreenRenderObserver_) {
116+ TLOGD(WmsLogTag::DMS, "setting off screen rendering observer is registered");
117+ return;
118+ }
119+ SettingProvider& provider = SettingProvider::GetInstance(DISPLAY_MANAGER_SERVICE_SA_ID);
120+ offScreenRenderObserver_ = provider.CreateObserver(SETTING_OFF_SCREEN_RENDERING_SWITCH_KEY, func);
121+ if (offScreenRenderObserver_ == nullptr) {
122+ TLOGE(WmsLogTag::DMS, "create off screen rendering observer failed");
123+ return;
124+ }
125+ ErrCode ret = provider.RegisterObserver(offScreenRenderObserver_);
126+ if (ret != ERR_OK) {
127+ TLOGW(WmsLogTag::DMS, "failed, ret=%{public}d", ret);
128+ offScreenRenderObserver_ = nullptr;
129+ }
130+}
131+
132+bool ScreenSettingHelper::GetSettingOffScreenRenderValue(bool& offScreenRenderValue_, const std::string& key)
133+{
134+ SettingProvider& provider = SettingProvider::GetInstance(DISPLAY_MANAGER_SERVICE_SA_ID);
135+ int32_t value;
136+ ErrCode ret = provider.GetIntValue(key, value);
137+ if (ret != ERR_OK) {
138+ TLOGW(WmsLogTag::DMS, "failed, ret=%{public}d", ret);
139+ return false;
140+ }
141+ offScreenRenderValue_ = (value == 1);
142+ return true;
143+}
144+ 
108bool ScreenSettingHelper::GetSettingDpi(uint32_t& dpi, const std::string& key)145bool ScreenSettingHelper::GetSettingDpi(uint32_t& dpi, const std::string& key)
109{146{
110 return GetSettingValue(dpi, key);147 return GetSettingValue(dpi, key);
@@ -554,6 +591,36 @@ std::map<std::string, SupportedScreenModes> ScreenSettingHelper::GetResolutionMo
554 return resolutionMap;591 return resolutionMap;
555}592}
556 593 
594+std::map<std::string, std::string> ScreenSettingHelper::GetDpiMode(const std::string& key)
595+{
596+ std::map<std::string, std::string> dpiMap = {};
597+ std::string value = "";
598+ SettingProvider& settingProvider = SettingProvider::GetInstance(DISPLAY_MANAGER_SERVICE_SA_ID);
599+ ErrCode ret = settingProvider.GetStringValue(key, value);
600+ TLOGI(WmsLogTag::DMS, "value=%{public}s", value.c_str());
601+ if (ret != ERR_OK) {
602+ TLOGE(WmsLogTag::DMS, "failed, ret=%{public}d", ret);
603+ return dpiMap;
604+ }
605+ std::string validString = RemoveInvalidChar(value);
606+ std::vector<std::string> restoredScreen = {};
607+ bool split = SplitString(restoredScreen, validString, ',');
608+ if (!split) {
609+ TLOGE(WmsLogTag::DMS, "split screen failed");
610+ return dpiMap;
611+ }
612+ for (auto infoString : restoredScreen) {
613+ std::vector<std::string> infoVector = {};
614+ split = SplitString(infoVector, infoString, ';');
615+ if (!split || infoVector.size() != VALID_DPI_MODE_SIZE) {
616+ TLOGE(WmsLogTag::DMS, "split info failed");
617+ continue;
618+ }
619+ dpiMap[infoVector[INDEX_SCREEN_INFO]] = infoVector[INDEX_DPI_MODE];
620+ }
621+ return dpiMap;
622+}
623+ 
557bool ScreenSettingHelper::GetScreenMode(MultiScreenInfo& info, const std::string& inputString)624bool ScreenSettingHelper::GetScreenMode(MultiScreenInfo& info, const std::string& inputString)
558{625{
559 std::vector<std::string> screenMode = {};626 std::vector<std::string> screenMode = {};
@@ -821,6 +888,40 @@ void ScreenSettingHelper::UnRegisterSettingExtendScreenDpiObserver()
821 extendScreenDpiObserver_ = nullptr;888 extendScreenDpiObserver_ = nullptr;
822}889}
823 890 
891+void ScreenSettingHelper::RegisterSettingExtendScreenIndepDpiObserver(SettingObserver::UpdateFunc func)
892+{
893+ if (extendScreenIndepDpiObserver_ != nullptr) {
894+ TLOGD(WmsLogTag::DMS, "setting extend independent dpi observer is registered");
895+ return;
896+ }
897+ SettingProvider& extendScreenProvider = SettingProvider::GetInstance(DISPLAY_MANAGER_SERVICE_SA_ID);
898+ extendScreenIndepDpiObserver_ = extendScreenProvider.CreateObserver(SETTING_EXTEND_INDEP_DPI_KEY, func);
899+ if (extendScreenIndepDpiObserver_ == nullptr) {
900+ TLOGE(WmsLogTag::DMS, "create observer failed");
901+ return;
902+ }
903+ ErrCode ret = extendScreenProvider.RegisterObserver(extendScreenIndepDpiObserver_);
904+ if (ret != ERR_OK) {
905+ TLOGW(WmsLogTag::DMS, "failed, ret=%{public}d", ret);
906+ extendScreenIndepDpiObserver_ = nullptr;
907+ }
908+}
909+
910+void ScreenSettingHelper::UnRegisterSettingExtendScreenIndepDpiObserver()
911+{
912+ if (extendScreenIndepDpiObserver_ == nullptr) {
913+ TLOGD(WmsLogTag::DMS, "extendScreenIndepDpiObserver_ is nullptr");
914+ return;
915+ }
916+ SettingProvider& extendScreenProvider = SettingProvider::GetInstance(DISPLAY_MANAGER_SERVICE_SA_ID);
917+ ErrCode ret = extendScreenProvider.UnregisterObserver(extendScreenIndepDpiObserver_);
918+ if (ret != ERR_OK) {
919+ TLOGW(WmsLogTag::DMS, "failed, ret=%{public}d", ret);
920+ } else {
921+ extendScreenIndepDpiObserver_ = nullptr;
922+ }
923+}
924+ 
824bool ScreenSettingHelper::GetSettingExtendScreenDpi(float& coef, const std::string& key)925bool ScreenSettingHelper::GetSettingExtendScreenDpi(float& coef, const std::string& key)
825{926{
826 SettingProvider& extendScreenProvider = SettingProvider::GetInstance(DISPLAY_MANAGER_SERVICE_SA_ID);927 SettingProvider& extendScreenProvider = SettingProvider::GetInstance(DISPLAY_MANAGER_SERVICE_SA_ID);
Mwindow_scene/test/dms_unittest/screen_session_manager_test_two.cpp+71-0
@@ -93,6 +93,77 @@ void ScreenSessionManagerTest::TearDown()
93 93 
94namespace {94namespace {
95 95 
96+/**
97+ * @tc.name: CalDefaultExtendScreenDensity
98+ * @tc.desc: CalDefaultExtendScreenDensity test
99+ * @tc.type: FUNC
100+ */
101+HWTEST_F(ScreenSessionManagerTest, CalDefaultExtendScreenDensity, TestSize.Level1)
102+{
103+ auto ssm = new ScreenSessionManager();
104+ ASSERT_NE(ssm, nullptr);
105+ ssm->InitExtendScreenDpiOptions();
106+ ScreenProperty property = ScreenProperty();
107+ property.screenRealPPI_ = 160.0f;
108+ EXPECT_EQ(ssm->CalDefaultExtendScreenDensity(property), 160.0f);
109+}
110+
111+/**
112+ * @tc.name: GetOptionalDpi
113+ * @tc.desc: GetOptionalDpi test
114+ * @tc.type: FUNC
115+ */
116+HWTEST_F(ScreenSessionManagerTest, GetOptionalDpi, TestSize.Level1)
117+{
118+ ASSERT_NE(ssm_, nullptr);
119+ float dpi = 160.0f;
120+ EXPECT_EQ(ssm_->GetOptionalDpi(dpi), 160.0f);
121+ dpi = 184.0f;
122+ EXPECT_EQ(ssm_->GetOptionalDpi(dpi), 184.0f);
123+}
124+
125+/**
126+ * @tc.name: GetOrCalExtendScreenDefaultDensity
127+ * @tc.desc: GetOrCalExtendScreenDefaultDensity test
128+ * @tc.type: FUNC
129+ */
130+HWTEST_F(ScreenSessionManagerTest, GetOrCalExtendScreenDefaultDensity, TestSize.Level1)
131+{
132+ ASSERT_NE(ssm_, nullptr);
133+ sptr<ScreenSession> screenSession = new (std::nothrow) ScreenSession(0, ScreenProperty(), 0);
134+ auto property = screenSession->GetScreenProperty();
135+ float density = 1.0f;
136+ ssm_->GetOrCalExtendScreenDefaultDensity(screenSession, property, density);
137+}
138+
139+/**
140+ * @tc.name: SetExtendScreenDpiFromSettingData
141+ * @tc.desc: SetExtendScreenDpiFromSettingData test
142+ * @tc.type: FUNC
143+ */
144+HWTEST_F(ScreenSessionManagerTest, SetExtendScreenDpiFromSettingData, TestSize.Level1)
145+{
146+ g_errLog.clear();
147+ LOG_SetCallback(MyLogCallback);
148+ ASSERT_NE(ssm_, nullptr);
149+ ssm_->SetExtendScreenDpiFromSettingData();
150+ EXPECT_TRUE(g_errLog.find("screen session is null") != std::string::npos);
Z
Zzhaoliang1月23日

这个log不是这样用的，模仿其他的需要设置callStack，然后最后置为空

likedislike
151+}
152+
153+/**
154+ * @tc.name: SetExtendScreenIndepDpi
155+ * @tc.desc: SetExtendScreenIndepDpi test
156+ * @tc.type: FUNC
157+ */
158+HWTEST_F(ScreenSessionManagerTest, SetExtendScreenIndepDpi, TestSize.Level1)
159+{
160+ g_errLog.clear();
161+ LOG_SetCallback(MyLogCallback);
162+ ASSERT_NE(ssm_, nullptr);
163+ ssm_->SetExtendScreenIndepDpi();
164+ EXPECT_TRUE(g_errLog.find("screen session is null") != std::string::npos);
165+}
166+ 
96/**167/**
97 * @tc.name: SetScreenPowerForFold01168 * @tc.name: SetScreenPowerForFold01
98 * @tc.desc: SetScreenPowerForFold test169 * @tc.desc: SetScreenPowerForFold test
Mwindow_scene/test/dms_unittest/screen_setting_helper_test.cpp+80-0
@@ -103,6 +103,86 @@ namespace {
103 ASSERT_EQ(ScreenSettingHelper::dpiObserver_, nullptr);103 ASSERT_EQ(ScreenSettingHelper::dpiObserver_, nullptr);
104 }104 }
105 105 
106+ /**
107+ * @tc.name: RegisterSettingOffScreenRenderObserver
108+ * @tc.desc: RegisterSettingOffScreenRenderObserver
109+ * @tc.type: FUNC
110+ */
111+ HWTEST_F(ScreenSettingHelperTest, RegisterSettingOffScreenRenderObserver, TestSize.Level1)
112+ {
113+ auto func = [] (const std::string&) {
114+ TLOGI(WmsLogTag::DMS, "UT test");
115+ };
116+ ScreenSettingHelper::offScreenRenderObserver_ = new SettingObserver();
117+ ScreenSettingHelper::RegisterSettingOffScreenRenderObserver(func);
118+ ScreenSettingHelper::offScreenRenderObserver_ = nullptr;
119+ ScreenSettingHelper::RegisterSettingOffScreenRenderObserver(func);
120+ ASSERT_EQ(ScreenSettingHelper::offScreenRenderObserver_, nullptr);
Z
Zzhaoliang1月23日

虚假断言

likedislike
121+ }
122+
123+ /**
124+ * @tc.name: RegisterSettingExtendScreenIndepDpiObserver
125+ * @tc.desc: RegisterSettingExtendScreenIndepDpiObserver
126+ * @tc.type: FUNC
127+ */
128+ HWTEST_F(ScreenSettingHelperTest, RegisterSettingExtendScreenIndepDpiObserver, TestSize.Level1)
129+ {
130+ auto func = [] (const std::string&) {
131+ TLOGI(WmsLogTag::DMS, "UT test");
132+ };
133+ ScreenSettingHelper::extendScreenIndepDpiObserver_ = new SettingObserver();
134+ ScreenSettingHelper::RegisterSettingExtendScreenIndepDpiObserver(func);
135+ ScreenSettingHelper::extendScreenIndepDpiObserver_ = nullptr;
136+ ScreenSettingHelper::RegisterSettingExtendScreenIndepDpiObserver(func);
137+ ASSERT_EQ(ScreenSettingHelper::extendScreenIndepDpiObserver_, nullptr);
138+ }
139+
140+ /**
141+ * @tc.name: UnRegisterSettingExtendScreenIndepDpiObserver
142+ * @tc.desc: UnRegisterSettingExtendScreenIndepDpiObserver
143+ * @tc.type: FUNC
144+ */
145+ HWTEST_F(ScreenSettingHelperTest, UnRegisterSettingExtendScreenIndepDpiObserver, TestSize.Level1)
146+ {
147+ ScreenSettingHelper::UnRegisterSettingExtendScreenIndepDpiObserver();
148+ ScreenSettingHelper::extendScreenIndepDpiObserver_ = new SettingObserver();
149+ ScreenSettingHelper::UnRegisterSettingExtendScreenIndepDpiObserver();
150+ ASSERT_EQ(ScreenSettingHelper::extendScreenIndepDpiObserver_, nullptr);
151+ ScreenSettingHelper::extendScreenIndepDpiObserver_ = nullptr;
152+ }
153+ 
154+ /**
155+ * @tc.name: GetSettingOffScreenRenderValue
156+ * @tc.desc: GetSettingOffScreenRenderValue
157+ * @tc.type: FUNC
158+ */
159+ HWTEST_F(ScreenSettingHelperTest, GetSettingOffScreenRenderValue, TestSize.Level1)
160+ {
161+ bool offerRenderValue = false;
162+ std::string key = "test";
163+ bool ret = ScreenSettingHelper::GetSettingOffScreenRenderValue(offerRenderValue, key);
164+ ASSERT_FALSE(ret);
165+ key = "off_screen_rendering_switch";
166+ ret = ScreenSettingHelper::GetSettingOffScreenRenderValue(offerRenderValue, key);
167+ }
168+ 
169+ /**
170+ * @tc.name: GetDpiMode
171+ * @tc.desc: Test GetDpiMode
172+ * @tc.type: FUNC
173+ */
174+ HWTEST_F(ScreenSettingHelperTest, GetDpiModeTest, Function | SmallTest | Level3)
175+ {
176+ ScreenSettingHelper screenSettingHelper = ScreenSettingHelper();
177+ std::string value = "";
178+ std::string key = "user_set_indep_dpi_extend";
179+ bool ret = screenSettingHelper.SetSettingValue(key, value);
180+ ASSERT_FALSE(ret);
181+
182+ std::map<std::string, std::string> dpiMap = screenSettingHelper.GetDpiMode(key);
183+ ASSERT_TRUE(dpiMap.empty());
184+ }
185+ 
106 /**186 /**
107 * @tc.name: GetSettingDpi01187 * @tc.name: GetSettingDpi01
108 * @tc.desc: GetSettingDpi01188 * @tc.desc: GetSettingDpi01