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 "fold_screen_controller/fold_screen_controller.h"
17 #include "fold_screen_controller/single_display_fold_policy.h"
18 #include "fold_screen_controller/secondary_display_fold_policy.h"
19 #include "fold_screen_controller/single_display_pocket_fold_policy.h"
20 #include "fold_screen_controller/dual_display_fold_policy.h"
21 #include "fold_screen_controller/fold_screen_sensor_manager.h"
22 #include "fold_screen_controller/sensor_fold_state_manager/dual_display_sensor_fold_state_manager.h"
23 #include "fold_screen_controller/sensor_fold_state_manager/single_display_sensor_fold_state_manager.h"
24 #include "fold_screen_controller/sensor_fold_state_manager/single_display_sensor_pocket_fold_state_manager.h"
25 #include "fold_screen_controller/sensor_fold_state_manager/dual_display_sensor_fold_state_manager.h"
26 #include "fold_screen_controller/sensor_fold_state_manager/secondary_display_sensor_fold_state_manager.h"
27 #include "fold_screen_controller/secondary_fold_sensor_manager.h"
28 #include "fold_screen_state_internel.h"
29
30 #include "window_manager_hilog.h"
31
32 namespace OHOS::Rosen {
FoldScreenController(std::recursive_mutex & displayInfoMutex,std::shared_ptr<TaskScheduler> screenPowerTaskScheduler)33 FoldScreenController::FoldScreenController(std::recursive_mutex& displayInfoMutex,
34 std::shared_ptr<TaskScheduler> screenPowerTaskScheduler)
35 : displayInfoMutex_(displayInfoMutex), screenPowerTaskScheduler_(screenPowerTaskScheduler)
36 {
37 if (FoldScreenStateInternel::IsDualDisplayFoldDevice()) {
38 foldScreenPolicy_ = GetFoldScreenPolicy(DisplayDeviceType::DOUBLE_DISPLAY_DEVICE);
39 sensorFoldStateManager_ = new DualDisplaySensorFoldStateManager();
40 TLOGI(WmsLogTag::DMS, "fold polocy: DOUBLE_DISPLAY_DEVICE");
41 } else if (FoldScreenStateInternel::IsSingleDisplayFoldDevice()) {
42 foldScreenPolicy_ = GetFoldScreenPolicy(DisplayDeviceType::SINGLE_DISPLAY_DEVICE);
43 sensorFoldStateManager_ = new SingleDisplaySensorFoldStateManager();
44 TLOGI(WmsLogTag::DMS, "fold polocy: SINGLE_DISPLAY_DEVICE");
45 } else if (FoldScreenStateInternel::IsSingleDisplayPocketFoldDevice()) {
46 foldScreenPolicy_ = GetFoldScreenPolicy(DisplayDeviceType::SINGLE_DISPLAY_POCKET_DEVICE);
47 sensorFoldStateManager_ = new SingleDisplaySensorPocketFoldStateManager();
48 TLOGI(WmsLogTag::DMS, "fold polocy: SINGLE_DISPLAY_POCKET_DEVICE");
49 } else if (FoldScreenStateInternel::IsSecondaryDisplayFoldDevice()) {
50 foldScreenPolicy_ = GetFoldScreenPolicy(DisplayDeviceType::SECONDARY_DISPLAY_DEVICE);
51 sensorFoldStateManager_ = new SecondaryDisplaySensorFoldStateManager();
52 TLOGI(WmsLogTag::DMS, "fold polocy: SECONDARY_DISPLAY_DEVICE");
53 }
54 if (foldScreenPolicy_ == nullptr) {
55 TLOGE(WmsLogTag::DMS, "FoldScreenPolicy is null");
56 return;
57 }
58 if (sensorFoldStateManager_ == nullptr) {
59 TLOGE(WmsLogTag::DMS, "SensorFoldStateManager is null");
60 return;
61 }
62 #ifdef SENSOR_ENABLE
63 if (FoldScreenStateInternel::IsSecondaryDisplayFoldDevice()) {
64 SecondaryFoldSensorManager::GetInstance().SetFoldScreenPolicy(foldScreenPolicy_);
65 SecondaryFoldSensorManager::GetInstance().SetSensorFoldStateManager(sensorFoldStateManager_);
66 } else {
67 FoldScreenSensorManager::GetInstance().SetFoldScreenPolicy(foldScreenPolicy_);
68 FoldScreenSensorManager::GetInstance().SetSensorFoldStateManager(sensorFoldStateManager_);
69 }
70 #endif
71 }
72
~FoldScreenController()73 FoldScreenController::~FoldScreenController()
74 {
75 TLOGI(WmsLogTag::DMS, "FoldScreenController is destructed");
76 }
77
GetFoldScreenPolicy(DisplayDeviceType productType)78 sptr<FoldScreenPolicy> FoldScreenController::GetFoldScreenPolicy(DisplayDeviceType productType)
79 {
80 sptr<FoldScreenPolicy> tempPolicy = nullptr;
81 switch (productType) {
82 case DisplayDeviceType::SINGLE_DISPLAY_DEVICE: {
83 tempPolicy = new SingleDisplayFoldPolicy(displayInfoMutex_, screenPowerTaskScheduler_);
84 break;
85 }
86 case DisplayDeviceType::DOUBLE_DISPLAY_DEVICE: {
87 tempPolicy = new DualDisplayFoldPolicy(displayInfoMutex_, screenPowerTaskScheduler_);
88 break;
89 }
90 case DisplayDeviceType::SINGLE_DISPLAY_POCKET_DEVICE:{
91 tempPolicy = new SingleDisplayPocketFoldPolicy(displayInfoMutex_, screenPowerTaskScheduler_);
92 break;
93 }
94 case DisplayDeviceType::SECONDARY_DISPLAY_DEVICE:{
95 tempPolicy = new SecondaryDisplayFoldPolicy(displayInfoMutex_, screenPowerTaskScheduler_);
96 break;
97 }
98 default: {
99 TLOGE(WmsLogTag::DMS, "GetFoldScreenPolicy DisplayDeviceType is invalid");
100 break;
101 }
102 }
103
104 return tempPolicy;
105 }
106
SetDisplayMode(const FoldDisplayMode displayMode)107 void FoldScreenController::SetDisplayMode(const FoldDisplayMode displayMode)
108 {
109 if (foldScreenPolicy_ == nullptr) {
110 TLOGW(WmsLogTag::DMS, "SetDisplayMode: foldScreenPolicy_ is null");
111 return;
112 }
113 foldScreenPolicy_->ChangeScreenDisplayMode(displayMode);
114 }
115
RecoverDisplayMode()116 void FoldScreenController::RecoverDisplayMode()
117 {
118 if (foldScreenPolicy_ == nullptr) {
119 TLOGW(WmsLogTag::DMS, "foldScreenPolicy_ is null");
120 return;
121 }
122 FoldDisplayMode displayMode = foldScreenPolicy_->GetModeMatchStatus();
123 FoldDisplayMode currentDisplayMode = foldScreenPolicy_->GetScreenDisplayMode();
124 if (displayMode == currentDisplayMode) {
125 TLOGI(WmsLogTag::DMS, "current displayMode is correct, skip");
126 return;
127 }
128 if (!FoldScreenStateInternel::IsSingleDisplayFoldDevice() &&
129 !FoldScreenStateInternel::IsSingleDisplayPocketFoldDevice()) {
130 TLOGI(WmsLogTag::DMS, "not single display fold (pocket) device, skip");
131 return;
132 }
133 TLOGI(WmsLogTag::DMS, "%{public}d -> %{public}d", currentDisplayMode, displayMode);
134 foldScreenPolicy_->ChangeScreenDisplayMode(displayMode, DisplayModeChangeReason::RECOVER);
135 }
136
LockDisplayStatus(bool locked)137 void FoldScreenController::LockDisplayStatus(bool locked)
138 {
139 if (foldScreenPolicy_ == nullptr) {
140 TLOGW(WmsLogTag::DMS, "LockDisplayStatus: foldScreenPolicy_ is null");
141 return;
142 }
143 foldScreenPolicy_->LockDisplayStatus(locked);
144 }
145
GetDisplayMode()146 FoldDisplayMode FoldScreenController::GetDisplayMode()
147 {
148 if (foldScreenPolicy_ == nullptr) {
149 TLOGW(WmsLogTag::DMS, "GetDisplayMode: foldScreenPolicy_ is null");
150 return FoldDisplayMode::UNKNOWN;
151 }
152 return foldScreenPolicy_->GetScreenDisplayMode();
153 }
154
IsFoldable()155 bool FoldScreenController::IsFoldable()
156 {
157 return true;
158 }
159
GetFoldStatus()160 FoldStatus FoldScreenController::GetFoldStatus()
161 {
162 if (foldScreenPolicy_ == nullptr) {
163 TLOGW(WmsLogTag::DMS, "GetFoldStatus: foldScreenPolicy_ is null");
164 return FoldStatus::UNKNOWN;
165 }
166 return foldScreenPolicy_->GetFoldStatus();
167 }
168
SetFoldStatus(FoldStatus foldStatus)169 void FoldScreenController::SetFoldStatus(FoldStatus foldStatus)
170 {
171 if (foldScreenPolicy_ == nullptr) {
172 TLOGW(WmsLogTag::DMS, "SetFoldStatus: foldScreenPolicy_ is null");
173 return;
174 }
175 foldScreenPolicy_->SetFoldStatus(foldStatus);
176 }
177
GetModeMatchStatus()178 FoldDisplayMode FoldScreenController::GetModeMatchStatus()
179 {
180 if (foldScreenPolicy_ == nullptr) {
181 TLOGW(WmsLogTag::DMS, "foldScreenPolicy is null");
182 return FoldDisplayMode::UNKNOWN;
183 }
184 return foldScreenPolicy_->GetModeMatchStatus();
185 }
186
GetTentMode()187 bool FoldScreenController::GetTentMode()
188 {
189 if (sensorFoldStateManager_ == nullptr) {
190 TLOGW(WmsLogTag::DMS, "GetTentMode: sensorFoldStateManager_ is null");
191 return false;
192 }
193 return sensorFoldStateManager_->IsTentMode();
194 }
195
OnTentModeChanged(bool isTentMode,int32_t hall)196 void FoldScreenController::OnTentModeChanged(bool isTentMode, int32_t hall)
197 {
198 if (sensorFoldStateManager_ == nullptr) {
199 TLOGW(WmsLogTag::DMS, "OnTentModeChanged: sensorFoldStateManager_ is null");
200 return;
201 }
202 return sensorFoldStateManager_->HandleTentChange(isTentMode, foldScreenPolicy_, hall);
203 }
204
GetCurrentFoldCreaseRegion()205 sptr<FoldCreaseRegion> FoldScreenController::GetCurrentFoldCreaseRegion()
206 {
207 if (foldScreenPolicy_ == nullptr) {
208 TLOGW(WmsLogTag::DMS, "GetFoldStatus: foldScreenPolicy_ is null");
209 return nullptr;
210 }
211 return foldScreenPolicy_->GetCurrentFoldCreaseRegion();
212 }
213
GetCurrentScreenId()214 ScreenId FoldScreenController::GetCurrentScreenId()
215 {
216 if (foldScreenPolicy_ == nullptr) {
217 TLOGW(WmsLogTag::DMS, "GetCurrentScreenId: foldScreenPolicy_ is null");
218 return 0;
219 }
220 return foldScreenPolicy_->GetCurrentScreenId();
221 }
222
BootAnimationFinishPowerInit()223 void FoldScreenController::BootAnimationFinishPowerInit()
224 {
225 if (foldScreenPolicy_ == nullptr) {
226 TLOGW(WmsLogTag::DMS, "foldScreenPolicy_ is null");
227 return;
228 }
229 foldScreenPolicy_->BootAnimationFinishPowerInit();
230 foldScreenPolicy_->currentDisplayMode_ = FoldDisplayMode::UNKNOWN;
231 }
232
SetOnBootAnimation(bool onBootAnimation)233 void FoldScreenController::SetOnBootAnimation(bool onBootAnimation)
234 {
235 if (foldScreenPolicy_ == nullptr) {
236 TLOGW(WmsLogTag::DMS, "SetOnBootAnimation: foldScreenPolicy_ is null");
237 return;
238 }
239 foldScreenPolicy_->SetOnBootAnimation(onBootAnimation);
240 }
241
UpdateForPhyScreenPropertyChange()242 void FoldScreenController::UpdateForPhyScreenPropertyChange()
243 {
244 if (foldScreenPolicy_ == nullptr) {
245 TLOGW(WmsLogTag::DMS, "UpdateForPhyScreenPropertyChange: foldScreenPolicy_ is null");
246 return;
247 }
248 foldScreenPolicy_->UpdateForPhyScreenPropertyChange();
249 }
250
ExitCoordination()251 void FoldScreenController::ExitCoordination()
252 {
253 if (foldScreenPolicy_ == nullptr) {
254 TLOGW(WmsLogTag::DMS, "foldScreenPolicy_ is null");
255 return;
256 }
257 foldScreenPolicy_->ExitCoordination();
258 }
259
GetModeChangeRunningStatus()260 bool FoldScreenController::GetModeChangeRunningStatus()
261 {
262 return foldScreenPolicy_->GetModeChangeRunningStatus();
263 }
264
SetdisplayModeChangeStatus(bool status)265 void FoldScreenController::SetdisplayModeChangeStatus(bool status)
266 {
267 if (FoldScreenStateInternel::IsSecondaryDisplayFoldDevice()) {
268 foldScreenPolicy_->SetSecondaryDisplayModeChangeStatus(status);
269 } else {
270 foldScreenPolicy_->SetdisplayModeChangeStatus(status);
271 }
272 }
273
GetdisplayModeRunningStatus()274 bool FoldScreenController::GetdisplayModeRunningStatus()
275 {
276 return foldScreenPolicy_->GetdisplayModeRunningStatus();
277 }
278
GetLastCacheDisplayMode()279 FoldDisplayMode FoldScreenController::GetLastCacheDisplayMode()
280 {
281 return foldScreenPolicy_->GetLastCacheDisplayMode();
282 }
283
AddOrRemoveDisplayNodeToTree(ScreenId screenId,int32_t command)284 void FoldScreenController::AddOrRemoveDisplayNodeToTree(ScreenId screenId, int32_t command)
285 {
286 if (foldScreenPolicy_ == nullptr) {
287 TLOGW(WmsLogTag::DMS, "foldScreenPolicy_ is null");
288 return;
289 }
290 foldScreenPolicy_->AddOrRemoveDisplayNodeToTree(screenId, command);
291 }
292
SetScreenSnapshotRect(RSSurfaceCaptureConfig & config)293 void FoldScreenController::SetScreenSnapshotRect(RSSurfaceCaptureConfig& config)
294 {
295 if (foldScreenPolicy_ == nullptr) {
296 TLOGW(WmsLogTag::DMS, "foldScreenPolicy_ is null");
297 return;
298 }
299 foldScreenPolicy_->SetScreenSnapshotRect(config);
300 }
301
SetMainScreenRegion(DMRect & mainScreenRegion)302 void FoldScreenController::SetMainScreenRegion(DMRect& mainScreenRegion)
303 {
304 if (foldScreenPolicy_ == nullptr) {
305 TLOGW(WmsLogTag::DMS, "foldScreenPolicy_ is null");
306 return;
307 }
308 foldScreenPolicy_->SetMainScreenRegion(mainScreenRegion);
309 }
310 } // namespace OHOS::Rosen