• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (c) 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 "screen_session_dumper.h"
17 
18 #include <csignal>
19 #include <fstream>
20 #include <transaction/rs_interfaces.h>
21 
22 #include "unique_fd.h"
23 #include "screen_session_manager.h"
24 #include "session_permission.h"
25 #include "screen_rotation_property.h"
26 #include "screen_sensor_connector.h"
27 #include "parameters.h"
28 #include "fold_screen_controller/super_fold_state_manager.h"
29 #include "fold_screen_controller/super_fold_sensor_manager.h"
30 #include "fold_screen_controller/fold_screen_sensor_manager.h"
31 #include "fold_screen_state_internel.h"
32 #include "window_helper.h"
33 #include "fold_screen_controller/secondary_fold_sensor_manager.h"
34 
35 namespace OHOS {
36 namespace Rosen {
37 namespace {
38 constexpr int LINE_WIDTH = 30;
39 constexpr int DUMPER_PARAM_INDEX_ONE = 1;
40 constexpr int DUMPER_PARAM_INDEX_TWO = 2;
41 constexpr int DUMPER_PARAM_INDEX_THREE = 3;
42 const std::string ARG_DUMP_HELP = "-h";
43 const std::string ARG_DUMP_ALL = "-a";
44 const std::string ARG_DUMP_FOLD_STATUS = "-f";
45 
46 constexpr int MOTION_SENSOR_PARAM_SIZE = 2;
47 const std::string STATUS_FOLD_HALF = "-z";
48 const std::string STATUS_EXPAND = "-y";
49 const std::string STATUS_FOLD = "-p";
50 const std::string ARG_SET_ROTATION_SENSOR = "-motion"; // rotation event inject
51 const std::string ARG_SET_ROTATION_LOCK = "-rotationlock";
52 const std::string ARG_PUBLISH_CAST_EVENT = "-publishcastevent";
53 const std::string ARG_FOLD_DISPLAY_FULL = "-f";
54 const std::string ARG_FOLD_DISPLAY_MAIN = "-m";
55 const std::string ARG_FOLD_DISPLAY_GLOBALL_FULL = "-g";
56 const std::string ARG_FOLD_DISPLAY_SUB = "-sub";
57 const std::string ARG_FOLD_DISPLAY_COOR = "-coor";
58 const std::vector<std::string> displayModeCommands = {"-f", "-m", "-sub", "-coor", "-g"};
59 const std::string ARG_LOCK_FOLD_DISPLAY_STATUS = "-l";
60 const std::string ARG_UNLOCK_FOLD_DISPLAY_STATUS = "-u";
61 const std::string ARG_SET_ON_TENT_MODE = "-ontent";
62 const std::string ARG_SET_OFF_TENT_MODE = "-offtent";
63 const std::string ARG_SET_HOVER_STATUS = "-hoverstatus";
64 const std::string ARG_SET_SUPER_FOLD_STATUS = "-supertrans";
65 const std::string ARG_SET_POSTURE_HALL = "-posture";
66 const std::string ARG_SET_POSTURE_HALL_STATUS = "-registerhall"; // 关闭开合sensor报值
67 const std::string ARG_SET_SECONDARY_FOLD_STATUS = "-secondary";
68 const std::string ARG_CHANGE_OUTER_CMD = "outer";
69 const std::string ANGLE_STR = "angle";
70 const std::string HALL_STR = "hall";
71 #ifdef FOLD_ABILITY_ENABLE
72 constexpr int SUPER_FOLD_STATUS_MAX = 2;
73 const char SECONDARY_DUMPER_VALUE_BOUNDARY[] = "mfg";
74 constexpr size_t SECONDARY_FOLD_STATUS_INDEX_M = 0;
75 constexpr size_t SECONDARY_FOLD_STATUS_INDEX_F = 1;
76 constexpr size_t SECONDARY_FOLD_STATUS_INDEX_G = 2;
77 constexpr size_t SECONDARY_FOLD_STATUS_COMMAND_NUM = 2;
78 constexpr uint16_t HALL_EXT_DATA_FLAG = 26;
79 #endif
80 }
81 
GetProcessNameByPid(int32_t pid)82 static std::string GetProcessNameByPid(int32_t pid)
83 {
84     std::string filePath = "/proc/" + std::to_string(pid) + "/comm";
85     char tmpPath[PATH_MAX]  = { 0 };
86     if (!realpath(filePath.c_str(), tmpPath)) {
87         return "UNKNOWN";
88     }
89     std::ifstream infile(filePath);
90     if (!infile.is_open()) {
91         return "UNKNOWN";
92     }
93     std::string processName = "UNKNOWN";
94     std::getline(infile, processName);
95     infile.close();
96     return processName;
97 }
98 
ScreenSessionDumper(int fd,const std::vector<std::u16string> & args)99 ScreenSessionDumper::ScreenSessionDumper(int fd, const std::vector<std::u16string>& args)
100     : fd_(fd)
101 {
102     std::wstring_convert<std::codecvt_utf8_utf16<char16_t>, char16_t> cv;
103     std::string info;
104     for (auto& u16str : args) {
105         std::string arg = cv.to_bytes(u16str);
106         params_.emplace_back(arg);
107         info += arg;
108     }
109     TLOGI(WmsLogTag::DMS, "input args: [%{public}s]", info.c_str());
110 }
111 
IsNumber(std::string str)112 bool ScreenSessionDumper::IsNumber(std::string str)
113 {
114     if (str.size() == 0) {
115         return false;
116     }
117     for (int32_t i = 0; i < static_cast<int32_t>(str.size()); i++) {
118         if (str.at(i) < '0' || str.at(i) > '9') {
119             return false;
120         }
121     }
122     return true;
123 }
124 
OutputDumpInfo()125 void ScreenSessionDumper::OutputDumpInfo()
126 {
127     if (fd_ < 0) {
128         TLOGE(WmsLogTag::DMS, "invalid fd: %{public}d", fd_);
129         return;
130     }
131 
132     static_cast<void>(signal(SIGPIPE, SIG_IGN));  // ignore SIGPIPE crash
133     int ret = dprintf(fd_, "%s\n", dumpInfo_.c_str());
134     if (ret < 0) {
135         TLOGE(WmsLogTag::DMS, "dprintf error. ret: %{public}d", ret);
136         return;
137     }
138     dumpInfo_.clear();
139 }
140 
141 
ExecuteDumpCmd()142 void ScreenSessionDumper::ExecuteDumpCmd()
143 {
144     if (!(SessionPermission::IsSACalling() || SessionPermission::IsStartByHdcd())) {
145         TLOGE(WmsLogTag::DMS, "dump permission denied!");
146         return;
147     }
148     if (params_.empty()) {
149         TLOGE(WmsLogTag::DMS, "params is null");
150         return;
151     }
152     if (params_[0] == ARG_DUMP_HELP) {
153         ShowHelpInfo();
154     } else if (params_[0] == ARG_DUMP_ALL) {
155         ShowAllScreenInfo();
156         ShowVisibleAreaDisplayInfo();
157     } else if (params_[0] == ARG_DUMP_FOLD_STATUS) {
158         DumpFoldStatus();
159     }
160     ExecuteInjectCmd();
161     OutputDumpInfo();
162 }
163 
ExecuteInjectCmd()164 void ScreenSessionDumper::ExecuteInjectCmd()
165 {
166     bool isDeveloperMode = system::GetBoolParameter("const.security.developermode.state", false);
167     if (isDeveloperMode) {
168         if (params_.size() == 1 && IsValidDisplayModeCommand(params_[0])) {
169             int errCode = SetFoldDisplayMode();
170             if (errCode != 0) {
171                 ShowIllegalArgsInfo();
172             }
173             return;
174         }
175     }
176     bool isDebugMode = system::GetBoolParameter("dms.hidumper.supportdebug", false);
177     if (!isDebugMode) {
178         TLOGI(WmsLogTag::DMS, "Can't use DMS hidumper inject methods.");
179         dumpInfo_.append("dms.hidumper.supportdebug false\n");
180         return;
181     }
182     if (params_[0] == ARG_CHANGE_OUTER_CMD && params_.size() == DUMPER_PARAM_INDEX_TWO) {
183         ScreenSessionManager::GetInstance().MultiScreenChangeOuter(params_[1]);
184         return;
185     }
186     if (params_.size() == DUMPER_PARAM_INDEX_THREE) {
187         TLOGI(WmsLogTag::DMS, "dump params[0] = %{public}s ,params[1] = %{public}s ,para,s[2] = %{public}s",
188             params_[0].c_str(), params_[DUMPER_PARAM_INDEX_ONE].c_str(), params_[DUMPER_PARAM_INDEX_TWO].c_str());
189         ScreenSessionManager::GetInstance().MultiScreenModeChange(params_[0], params_[DUMPER_PARAM_INDEX_ONE],
190             params_[DUMPER_PARAM_INDEX_TWO]);
191         return;
192     }
193     if (params_[0] == STATUS_FOLD_HALF || params_[0] == STATUS_EXPAND || params_[0] == STATUS_FOLD) {
194         ShowNotifyFoldStatusChangedInfo();
195         return;
196     } else if (params_[0].find(ARG_SET_ROTATION_SENSOR) != std::string::npos) {
197         SetMotionSensorValue(params_[0]);
198         return;
199     } else if (params_[0].find(ARG_SET_ROTATION_LOCK) != std::string::npos) {
200         SetRotationLockedValue(params_[0]);
201         return;
202     } else if (params_[0].find(ARG_PUBLISH_CAST_EVENT) != std::string::npos) {
203         MockSendCastPublishEvent(params_[0]);
204         return;
205     } else if (params_.size() == 1 && (params_[0] == ARG_LOCK_FOLD_DISPLAY_STATUS
206                 || params_[0] == ARG_UNLOCK_FOLD_DISPLAY_STATUS)) {
207         int errCode = SetFoldStatusLocked();
208         if (errCode != 0) {
209             ShowIllegalArgsInfo();
210         }
211         return;
212     }
213     ExecuteInjectCmd2();
214 }
215 
ExecuteInjectCmd2()216 void ScreenSessionDumper::ExecuteInjectCmd2()
217 {
218     if (params_[0].find(ARG_SET_ON_TENT_MODE) != std::string::npos ||
219         params_[0].find(ARG_SET_OFF_TENT_MODE) != std::string::npos) {
220         SetEnterOrExitTentMode(params_[0]);
221     } else if (params_[0].find(ARG_SET_HOVER_STATUS) != std::string::npos) {
222         SetHoverStatusChange(params_[0]);
223     } else if (params_[0].find(ARG_SET_SUPER_FOLD_STATUS) != std::string::npos) {
224         SetSuperFoldStatusChange(params_[0]);
225     } else if (params_[0].find(ARG_SET_POSTURE_HALL) != std::string::npos) {
226         SetHallAndPostureValue(params_[0]);
227     } else if (params_[0].find(ARG_SET_POSTURE_HALL_STATUS) != std::string::npos) {
228         SetHallAndPostureStatus(params_[0]);
229     } else if (params_[0].find(ARG_SET_SECONDARY_FOLD_STATUS) != std::string::npos) {
230         SetSecondaryStatusChange(params_[0]);
231     }
232 }
233 
DumpEventTracker(EventTracker & tracker)234 void ScreenSessionDumper::DumpEventTracker(EventTracker& tracker)
235 {
236     std::ostringstream oss;
237     auto recordInfos = tracker.GetRecordInfos();
238     oss << "-------------- DMS KEY EVENTS LIST  --------------" << std::endl;
239     for (const auto& info : recordInfos) {
240         oss << std::left << "[" << tracker.formatTimestamp(info.timestamp).c_str()
241             << "]: " << info.info.c_str() << std::endl;
242     }
243     dumpInfo_.append(oss.str());
244 }
245 
DumpMultiUserInfo(std::vector<int32_t> oldScbPids,int32_t userId,int32_t ScbPid)246 void ScreenSessionDumper::DumpMultiUserInfo(std::vector<int32_t> oldScbPids, int32_t userId, int32_t ScbPid)
247 {
248     std::ostringstream oss;
249     oss << "-------------- DMS Multi User Info --------------" << std::endl;
250     oss << std::left << "[oldScbPid:] ";
251     for (auto oldScbPid : oldScbPids) {
252         oss << oldScbPid  << " ";
253     }
254     oss << std::endl;
255     oss << std::left << "[userId:] " << userId << std::endl;
256     oss << std::left << "[ScbPid:] " << ScbPid << std::endl;
257     dumpInfo_.append(oss.str());
258 }
259 
DumpFreezedPidList(std::set<int32_t> pidList)260 void ScreenSessionDumper::DumpFreezedPidList(std::set<int32_t> pidList)
261 {
262     std::ostringstream oss;
263     oss << "-------------- DMS FREEZED PID LIST  --------------" << std::endl;
264     for (auto pid : pidList) {
265         oss << std::left << "[PID: " << pid  << "]: "
266             << " [" << GetProcessNameByPid(pid) << "]"<< std::endl;
267     }
268     dumpInfo_.append(oss.str());
269 }
270 
ShowHelpInfo()271 void ScreenSessionDumper::ShowHelpInfo()
272 {
273     dumpInfo_.append("Usage:\n")
274         .append(" -h                             ")
275         .append("|help text for the tool\n")
276         .append(" -a                             ")
277         .append("|dump all screen information in the system\n")
278         .append(" -z                             ")
279         .append("|switch to fold half status\n")
280         .append(" -y                             ")
281         .append("|switch to expand status\n")
282         .append(" -p                             ")
283         .append("|switch to fold status\n")
284         .append(" -f                             ")
285         .append("|get to fold status\n");
286 }
287 
ShowAllScreenInfo()288 void ScreenSessionDumper::ShowAllScreenInfo()
289 {
290     std::vector<ScreenId> screenIds = ScreenSessionManager::GetInstance().GetAllScreenIds();
291     for (auto screenId : screenIds) {
292         std::ostringstream oss;
293         oss << "---------------- Screen ID: " << screenId << " ----------------" << std::endl;
294         dumpInfo_.append(oss.str());
295         DumpFoldStatus();
296         DumpTentMode();
297         DumpScreenSessionById(screenId);
298         DumpRsInfoById(screenId);
299         DumpCutoutInfoById(screenId);
300         DumpScreenInfoById(screenId);
301         DumpScreenPropertyById(screenId);
302         DumpFoldCreaseRegion();
303     }
304 }
305 
ShowVisibleAreaDisplayInfo()306 void ScreenSessionDumper::ShowVisibleAreaDisplayInfo()
307 {
308     std::vector<DisplayId> displayIds = ScreenSessionManager::GetInstance().GetAllDisplayIds();
309     for (auto displayId : displayIds) {
310         std::ostringstream oss;
311         oss << "-------------- Display ID: " << displayId << " --------------" << std::endl;
312         dumpInfo_.append(oss.str());
313         DumpVisibleAreaDisplayInfoById(displayId);
314     }
315 }
316 
DumpFoldStatus()317 void ScreenSessionDumper::DumpFoldStatus()
318 {
319     std::ostringstream oss;
320     auto foldStatus = ScreenSessionManager::GetInstance().GetFoldStatus();
321     std::string status = "";
322     switch (foldStatus) {
323         case FoldStatus::EXPAND: {
324             status = "EXPAND";
325             break;
326         }
327         case FoldStatus::FOLDED: {
328             status = "FOLDED";
329             break;
330         }
331         case FoldStatus::HALF_FOLD: {
332             status = "HALF_FOLD";
333             break;
334         }
335         case FoldStatus::FOLD_STATE_EXPAND_WITH_SECOND_EXPAND: {
336             status = "FOLD_STATUS_EXPANDED_WITH_SECOND_EXPANDED";
337             break;
338         }
339         case FoldStatus::FOLD_STATE_EXPAND_WITH_SECOND_HALF_FOLDED: {
340             status = "FOLD_STATUS_EXPANDED_WITH_SECOND_HALF_FOLDED";
341             break;
342         }
343         case FoldStatus::FOLD_STATE_FOLDED_WITH_SECOND_EXPAND: {
344             status = "FOLD_STATUS_FOLDED_WITH_SECOND_EXPANDED";
345             break;
346         }
347         case FoldStatus::FOLD_STATE_FOLDED_WITH_SECOND_HALF_FOLDED: {
348             status = "FOLD_STATUS_FOLDED_WITH_SECOND_HALF_FOLDED";
349             break;
350         }
351         case FoldStatus::FOLD_STATE_HALF_FOLDED_WITH_SECOND_EXPAND: {
352             status = "FOLD_STATUS_HALF_FOLDED_WITH_SECOND_EXPANDED";
353             break;
354         }
355         case FoldStatus::FOLD_STATE_HALF_FOLDED_WITH_SECOND_HALF_FOLDED: {
356             status = "FOLD_STATUS_HALF_FOLDED_WITH_SECOND_HALF_FOLDED";
357             break;
358         }
359         default: {
360             status = "UNKNOWN";
361             break;
362         }
363     }
364     oss << std::left << std::setw(LINE_WIDTH) << "FoldStatus: "
365         << status << std::endl;
366     dumpInfo_.append(oss.str());
367 }
368 
DumpTentMode()369 void ScreenSessionDumper::DumpTentMode()
370 {
371     std::ostringstream oss;
372     bool isTentMode = ScreenSessionManager::GetInstance().GetTentMode();
373     std::string status = "";
374     if (isTentMode) {
375         status = "TRUE";
376     } else {
377         status = "FALSE";
378     }
379     oss << std::left << std::setw(LINE_WIDTH) << "TentMode: "
380         << status << std::endl;
381     dumpInfo_.append(oss.str());
382 }
383 
DumpFoldCreaseRegion()384 void ScreenSessionDumper::DumpFoldCreaseRegion()
385 {
386     std::ostringstream oss;
387     auto creaseRegion = ScreenSessionManager::GetInstance().GetCurrentFoldCreaseRegion();
388     if (creaseRegion == nullptr) {
389         TLOGE(WmsLogTag::DMS, "creaseRegion is nullptr.");
390         return;
391     }
392     auto creaseRects = creaseRegion->GetCreaseRects();
393     if (creaseRects.empty()) {
394         TLOGE(WmsLogTag::DMS, "current crease region is null");
395         return;
396     }
397     oss << std::left << std::setw(LINE_WIDTH) << "CurrentCreaseRects<X, Y, W, H>: "
398         << creaseRects[0].posX_ << ", " << creaseRects[0].posY_ << ", "
399         << creaseRects[0].width_ << ", " << creaseRects[0].height_ << std::endl;
400     dumpInfo_.append(oss.str());
401 }
402 
DumpScreenSessionById(ScreenId id)403 void ScreenSessionDumper::DumpScreenSessionById(ScreenId id)
404 {
405     std::ostringstream oss;
406     oss << "[SCREEN SESSION]" << std::endl;
407     auto screenSession = ScreenSessionManager::GetInstance().GetScreenSession(id);
408     if (screenSession == nullptr) {
409         TLOGE(WmsLogTag::DMS, "screenSession nullptr. screen id: %{public}" PRIu64"", id);
410         return;
411     }
412     oss << std::left << std::setw(LINE_WIDTH) << "Name: "
413         << screenSession->GetName() << std::endl;
414     oss << std::left << std::setw(LINE_WIDTH) << "RSScreenId: "
415         << screenSession->GetRSScreenId() << std::endl;
416     sptr<SupportedScreenModes> activeModes = screenSession->GetActiveScreenMode();
417     if (activeModes != nullptr) {
418         oss << std::left << std::setw(LINE_WIDTH) << "activeModes<id, W, H, RS>: "
419             << activeModes->id_ << ", " << activeModes->width_ << ", "
420             << activeModes->height_ << ", " << activeModes->refreshRate_ << std::endl;
421     }
422     oss << std::left << std::setw(LINE_WIDTH) << "SourceMode: "
423         << static_cast<int32_t>(screenSession->GetSourceMode()) << std::endl;
424     oss << std::left << std::setw(LINE_WIDTH) << "ScreenCombination: "
425         << static_cast<int32_t>(screenSession->GetScreenCombination()) << std::endl;
426     oss << std::left << std::setw(LINE_WIDTH) << "Orientation: "
427         << static_cast<int32_t>(screenSession->GetOrientation()) << std::endl;
428     oss << std::left << std::setw(LINE_WIDTH) << "Rotation: "
429         << static_cast<int32_t>(screenSession->GetRotation()) << std::endl;
430     oss << std::left << std::setw(LINE_WIDTH) << "ScreenRequestedOrientation: "
431         << static_cast<int32_t>(screenSession->GetScreenRequestedOrientation()) << std::endl;
432     oss << std::left << std::setw(LINE_WIDTH) << "isExtend: "
433         << static_cast<int32_t>(screenSession->GetIsExtend()) << std::endl;
434     dumpInfo_.append(oss.str());
435 }
436 
DumpRsInfoById(ScreenId id)437 void ScreenSessionDumper::DumpRsInfoById(ScreenId id)
438 {
439     std::ostringstream oss;
440     oss << "[RS INFO]" << std::endl;
441     auto screenSession = ScreenSessionManager::GetInstance().GetScreenSession(id);
442     if (screenSession == nullptr) {
443         TLOGE(WmsLogTag::DMS, "screenSession nullptr. screen id: %{public}" PRIu64"", id);
444         return;
445     }
446     auto state = static_cast<ScreenPowerState>(RSInterfaces::GetInstance().GetScreenPowerStatus(id));
447     oss << std::left << std::setw(LINE_WIDTH) << "ScreenPowerState: "
448         << static_cast<int32_t>(state) << std::endl;
449     std::vector<ScreenColorGamut> colorGamuts;
450     DMError ret = screenSession->GetScreenSupportedColorGamuts(colorGamuts);
451     if (ret == DMError::DM_OK && colorGamuts.size() > 0) {
452         oss << std::left << std::setw(LINE_WIDTH) << "SupportedColorGamuts: ";
453         for (uint32_t i = 0; i < colorGamuts.size() - 1; i++) {
454             oss << static_cast<int32_t>(colorGamuts[i]) << ", ";
455         }
456         oss << static_cast<int32_t>(colorGamuts[colorGamuts.size() - 1]) << std::endl;
457     }
458     ScreenColorGamut colorGamut;
459     ret = screenSession->GetScreenColorGamut(colorGamut);
460     if (ret == DMError::DM_OK) {
461         oss << std::left << std::setw(LINE_WIDTH) << "ScreenColorGamut: "
462             << static_cast<int32_t>(colorGamut) << std::endl;
463     }
464     ScreenGamutMap gamutMap;
465     ret = screenSession->GetScreenGamutMap(gamutMap);
466     if (ret == DMError::DM_OK) {
467         oss << std::left << std::setw(LINE_WIDTH) << "ScreenGamutMap: "
468             << static_cast<int32_t>(gamutMap) << std::endl;
469     }
470     GraphicPixelFormat pixelFormat;
471     ret = screenSession->GetPixelFormat(pixelFormat);
472     if (ret == DMError::DM_OK) {
473         oss << std::left << std::setw(LINE_WIDTH) << "GraphicPixelFormat: "
474             << static_cast<int32_t>(pixelFormat) << std::endl;
475     }
476     dumpInfo_.append(oss.str());
477     DumpRsInfoById01(screenSession); // 拆分函数，避免函数过长
478 }
479 
DumpRsInfoById01(sptr<ScreenSession> screenSession)480 void ScreenSessionDumper::DumpRsInfoById01(sptr<ScreenSession> screenSession)
481 {
482     std::ostringstream oss;
483     std::vector<ScreenHDRFormat> hdrFormats;
484     DMError ret = screenSession->GetSupportedHDRFormats(hdrFormats);
485     if (ret == DMError::DM_OK && hdrFormats.size() > 0) {
486         oss << std::left << std::setw(LINE_WIDTH) << "SupportedScreenHDRFormat: ";
487         for (uint32_t i = 0; i < hdrFormats.size() - 1; i++) {
488             oss << static_cast<int32_t>(hdrFormats[i]) << ", ";
489         }
490         oss << static_cast<int32_t>(hdrFormats[hdrFormats.size() - 1]) << std::endl;
491     }
492     ScreenHDRFormat hdrFormat;
493     ret = screenSession->GetScreenHDRFormat(hdrFormat);
494     if (ret == DMError::DM_OK) {
495         oss << std::left << std::setw(LINE_WIDTH) << "ScreenHDRFormat: "
496             << static_cast<int32_t>(hdrFormat) << std::endl;
497     }
498     std::vector<GraphicCM_ColorSpaceType> colorSpaces;
499     ret = screenSession->GetSupportedColorSpaces(colorSpaces);
500     if (ret == DMError::DM_OK && colorSpaces.size() > 0) {
501         oss << std::left << std::setw(LINE_WIDTH) << "SupportedColorSpaces: ";
502         for (uint32_t i = 0; i < colorSpaces.size() - 1; i++) {
503             oss << static_cast<int32_t>(colorSpaces[i]) << ", ";
504         }
505         oss << static_cast<int32_t>(colorSpaces[colorSpaces.size() - 1]) << std::endl;
506     }
507     GraphicCM_ColorSpaceType colorSpace;
508     ret = screenSession->GetScreenColorSpace(colorSpace);
509     if (ret == DMError::DM_OK) {
510         oss << std::left << std::setw(LINE_WIDTH) << "ScreenColorSpace: "
511             << static_cast<int32_t>(colorSpace) << std::endl;
512     }
513     dumpInfo_.append(oss.str());
514 }
515 
DumpCutoutInfoPrint(std::ostringstream & oss,const DMRect & areaRect,const std::string & label)516 void ScreenSessionDumper::DumpCutoutInfoPrint(std::ostringstream& oss,
517     const DMRect& areaRect, const std::string& label)
518 {
519     oss << std::left << std::setw(LINE_WIDTH) << label
520         << areaRect.posX_ << ", "
521         << areaRect.posY_ << ", "
522         << areaRect.width_ << ", "
523         << areaRect.height_ << std::endl;
524 }
525 
DumpCutoutInfoById(ScreenId id)526 void ScreenSessionDumper::DumpCutoutInfoById(ScreenId id)
527 {
528     std::ostringstream oss;
529     oss << "[CUTOUT INFO]" << std::endl;
530     sptr<CutoutInfo> cutoutInfo = ScreenSessionManager::GetInstance().GetCutoutInfo(id);
531     if (cutoutInfo == nullptr) {
532         TLOGE(WmsLogTag::DMS, "cutoutInfo nullptr. screen id: %{public}" PRIu64"", id);
533         return;
534     }
535     DumpCutoutInfoPrint(oss, cutoutInfo->GetWaterfallDisplayAreaRects().left, "WaterFall_L<X,Y,W,H>: ");
536     DumpCutoutInfoPrint(oss, cutoutInfo->GetWaterfallDisplayAreaRects().top, "WaterFall_T<X,Y,W,H>: ");
537     DumpCutoutInfoPrint(oss, cutoutInfo->GetWaterfallDisplayAreaRects().right, "WaterFall_R<X,Y,W,H>: ");
538     DumpCutoutInfoPrint(oss, cutoutInfo->GetWaterfallDisplayAreaRects().bottom, "WaterFall_B<X,Y,W,H>: ");
539 
540     std::vector<DMRect> boundingRects = cutoutInfo->GetBoundingRects();
541     oss << std::left << std::setw(LINE_WIDTH) << "BoundingRects<X,Y,W,H>: ";
542     for (auto rect : boundingRects) {
543         oss << "[" << rect.posX_ << ", " << rect.posY_ << ", " << rect.width_ << ", " << rect.height_ << "] ";
544     }
545     oss << std::endl;
546     dumpInfo_.append(oss.str());
547 }
548 
DumpScreenInfoById(ScreenId id)549 void ScreenSessionDumper::DumpScreenInfoById(ScreenId id)
550 {
551     std::ostringstream oss;
552     oss << "[SCREEN INFO]" << std::endl;
553     auto screenInfo = ScreenSessionManager::GetInstance().GetScreenInfoById(id);
554     if (screenInfo == nullptr) {
555         TLOGE(WmsLogTag::DMS, "screenInfo nullptr. screen id: %{public}" PRIu64"", id);
556         return;
557     }
558     oss << std::left << std::setw(LINE_WIDTH) << "VirtualWidth: "
559         << screenInfo->GetVirtualWidth() << std::endl;
560     oss << std::left << std::setw(LINE_WIDTH) << "VirtualHeight: "
561         << screenInfo->GetVirtualHeight() << std::endl;
562     oss << std::left << std::setw(LINE_WIDTH) << "LastParentId: "
563         << screenInfo->GetLastParentId() << std::endl;
564     oss << std::left << std::setw(LINE_WIDTH) << "ParentId: "
565         << screenInfo->GetParentId() << std::endl;
566     oss << std::left << std::setw(LINE_WIDTH) << "IsScreenGroup: "
567         << screenInfo->GetIsScreenGroup() << std::endl;
568     oss << std::left << std::setw(LINE_WIDTH) << "VirtualPixelRatio: "
569         << screenInfo->GetVirtualPixelRatio() << std::endl;
570     oss << std::left << std::setw(LINE_WIDTH) << "Rotation: "
571         << static_cast<int32_t>(screenInfo->GetRotation()) << std::endl;
572     oss << std::left << std::setw(LINE_WIDTH) << "Orientation: "
573         << static_cast<int32_t>(screenInfo->GetOrientation()) << std::endl;
574     oss << std::left << std::setw(LINE_WIDTH) << "SourceMode: "
575         << static_cast<int32_t>(screenInfo->GetSourceMode()) << std::endl;
576     oss << std::left << std::setw(LINE_WIDTH) << "ScreenType: "
577         << static_cast<int32_t>(screenInfo->GetType()) << std::endl;
578     dumpInfo_.append(oss.str());
579 }
580 
DumpVisibleAreaDisplayInfoById(DisplayId id)581 void ScreenSessionDumper::DumpVisibleAreaDisplayInfoById(DisplayId id)
582 {
583     std::ostringstream oss;
584     oss << "[DISPLAY INFO]" << std::endl;
585     auto displayInfo = ScreenSessionManager::GetInstance().GetVisibleAreaDisplayInfoById(id);
586     if (displayInfo == nullptr) {
587         TLOGE(WmsLogTag::DMS, "displayInfo nullptr. display id: %{public}" PRIu64"", id);
588         return;
589     }
590     oss << std::left << std::setw(LINE_WIDTH) << "visibleAreaWidth: "
591         << displayInfo->GetWidth() << std::endl;
592     oss << std::left << std::setw(LINE_WIDTH) << "visibleAreaHeight: "
593         << displayInfo->GetHeight() << std::endl;
594     dumpInfo_.append(oss.str());
595 }
596 
DumpScreenPropertyById(ScreenId id)597 void ScreenSessionDumper::DumpScreenPropertyById(ScreenId id)
598 {
599     std::ostringstream oss;
600     oss << "[SCREEN PROPERTY]" << std::endl;
601     ScreenProperty screenProperty = ScreenSessionManager::GetInstance().GetScreenProperty(id);
602 
603     oss << std::left << std::setw(LINE_WIDTH) << "Rotation: " << screenProperty.GetRotation() << std::endl;
604     oss << std::left << std::setw(LINE_WIDTH) << "Density: " << screenProperty.GetDensity() << std::endl;
605     oss << std::left << std::setw(LINE_WIDTH) << "DensityInCurResolution: "
606         << screenProperty.GetDensityInCurResolution() << std::endl;
607     oss << std::left << std::setw(LINE_WIDTH) << "PhyWidth: " << screenProperty.GetPhyWidth() << std::endl;
608     oss << std::left << std::setw(LINE_WIDTH) << "PhyHeight: " << screenProperty.GetPhyHeight() << std::endl;
609     oss << std::left << std::setw(LINE_WIDTH) << "RefreshRate: " << screenProperty.GetRefreshRate() << std::endl;
610     oss << std::left << std::setw(LINE_WIDTH) << "VirtualPixelRatio: "
611         << screenProperty.GetVirtualPixelRatio() << std::endl;
612     oss << std::left << std::setw(LINE_WIDTH) << "ScreenRotation: "
613         << static_cast<int32_t>(screenProperty.GetRotation()) << std::endl;
614     oss << std::left << std::setw(LINE_WIDTH) << "Orientation: "
615         <<  static_cast<int32_t>(screenProperty.GetOrientation()) << std::endl;
616     oss << std::left << std::setw(LINE_WIDTH) << "DisplayOrientation: "
617         << static_cast<int32_t>(screenProperty.GetDisplayOrientation()) << std::endl;
618     oss << std::left << std::setw(LINE_WIDTH) << "GetScreenType: "
619         << static_cast<int32_t>(screenProperty.GetScreenType()) << std::endl;
620     oss << std::left << std::setw(LINE_WIDTH) << "ReqOrientation: "
621         << static_cast<int32_t>(screenProperty.GetScreenRequestedOrientation()) << std::endl;
622     oss << std::left << std::setw(LINE_WIDTH) << "DPI<X, Y>: " << screenProperty.GetXDpi()
623         << ", " << screenProperty.GetYDpi() << std::endl;
624     oss << std::left << std::setw(LINE_WIDTH) << "Offset<X, Y>: " << screenProperty.GetOffsetX()
625         << ", " << screenProperty.GetOffsetY() << std::endl;
626     oss << std::left << std::setw(LINE_WIDTH) << "StartPosition<X, Y>: " << screenProperty.GetStartX()
627         << ", " << screenProperty.GetStartY() << std::endl;
628     oss << std::left << std::setw(LINE_WIDTH) << "Bounds<L,T,W,H>: "
629         << screenProperty.GetBounds().rect_.GetLeft() << ", "
630         << screenProperty.GetBounds().rect_.GetTop() << ", "
631         << screenProperty.GetBounds().rect_.GetWidth() << ", "
632         << screenProperty.GetBounds().rect_.GetHeight() << ", " << std::endl;
633     oss << std::left << std::setw(LINE_WIDTH) << "PhyBounds<L,T,W,H>: "
634         << screenProperty.GetPhyBounds().rect_.GetLeft() << ", "
635         << screenProperty.GetPhyBounds().rect_.GetTop() << ", "
636         << screenProperty.GetPhyBounds().rect_.GetWidth() << ", "
637         << screenProperty.GetPhyBounds().rect_.GetHeight() << ", " << std::endl;
638     oss << std::left << std::setw(LINE_WIDTH) << "AvailableArea<X,Y,W,H> "
639         << screenProperty.GetAvailableArea().posX_ << ", "
640         << screenProperty.GetAvailableArea().posY_ << ", "
641         << screenProperty.GetAvailableArea().width_ << ", "
642         << screenProperty.GetAvailableArea().height_ << ", " << std::endl;
643     oss << std::left << std::setw(LINE_WIDTH) << "DefaultDeviceRotationOffset "
644         << screenProperty.GetDefaultDeviceRotationOffset() << std::endl;
645     dumpInfo_.append(oss.str());
646 }
647 
648 /**
649  * hidumper inject methods
650  */
ShowNotifyFoldStatusChangedInfo()651 void ScreenSessionDumper::ShowNotifyFoldStatusChangedInfo()
652 {
653     TLOGI(WmsLogTag::DMS, "params_: [%{public}s]", params_[0].c_str());
654     int errCode = ScreenSessionManager::GetInstance().NotifyFoldStatusChanged(params_[0]);
655     if (errCode != 0) {
656         ShowIllegalArgsInfo();
657     } else {
658         std::ostringstream oss;
659         oss << "currentFoldStatus is: "
660             << static_cast<uint32_t>(ScreenSessionManager::GetInstance().GetFoldStatus())
661             << std::endl;
662         dumpInfo_.append(oss.str());
663     }
664 }
665 
ShowIllegalArgsInfo()666 void ScreenSessionDumper::ShowIllegalArgsInfo()
667 {
668     dumpInfo_.append("The arguments are illegal and you can enter '-h' for help.");
669 }
670 
SetMotionSensorValue(std::string input)671 void ScreenSessionDumper::SetMotionSensorValue(std::string input)
672 {
673     size_t commaPos = input.find_last_of(',');
674     if ((commaPos != std::string::npos) && (input.substr(0, commaPos) == ARG_SET_ROTATION_SENSOR)) {
675         std::string valueStr = input.substr(commaPos + 1, MOTION_SENSOR_PARAM_SIZE);
676         if (valueStr.size() == 1 && !std::isdigit(valueStr[0])) {
677             return;
678         }
679         if (valueStr.size() == MOTION_SENSOR_PARAM_SIZE && valueStr != "-1") {
680             return;
681         }
682         int32_t value = std::stoi(valueStr);
683         if (value <  static_cast<int32_t>(DeviceRotation::INVALID) ||
684             value > static_cast<int32_t>(DeviceRotation::ROTATION_LANDSCAPE_INVERTED)) {
685             TLOGE(WmsLogTag::DMS, "params is invalid: %{public}d", value);
686             return;
687         }
688         ScreenRotationProperty::HandleSensorEventInput(static_cast<DeviceRotation>(value));
689         TLOGI(WmsLogTag::DMS, "mock motion sensor: %{public}d", value);
690     }
691 }
692 
SetRotationLockedValue(std::string input)693 void ScreenSessionDumper::SetRotationLockedValue(std::string input)
694 {
695     size_t commaPos = input.find_last_of(',');
696     if ((commaPos != std::string::npos) && (input.substr(0, commaPos) == ARG_SET_ROTATION_LOCK)) {
697         std::string valueStr = input.substr(commaPos + 1);
698         if (valueStr.size() != 1) {
699             return;
700         }
701         if (!std::isdigit(valueStr[0])) {
702             return;
703         }
704         int32_t value = std::stoi(valueStr);
705         ScreenSessionManager::GetInstance().SetScreenRotationLocked(static_cast<bool>(value));
706         TLOGI(WmsLogTag::DMS, "mock rotation locked: %{public}d", value);
707     }
708 }
709 
MockSendCastPublishEvent(std::string input)710 void ScreenSessionDumper::MockSendCastPublishEvent(std::string input)
711 {
712     std::ostringstream oss;
713     oss << "-------------- DMS SEND CAST PUBLISH EVENT --------------" << std::endl;
714     size_t commaPos = input.find_last_of(',');
715     if ((commaPos != std::string::npos) && (input.substr(0, commaPos) == ARG_PUBLISH_CAST_EVENT)) {
716         std::string valueStr = input.substr(commaPos + 1);
717         if (valueStr.size() != 1) {
718             oss << std::left << "[error]: " << "the value is too long" << std::endl;
719             dumpInfo_.append(oss.str());
720             return;
721         }
722         if (!std::isdigit(valueStr[0])) {
723             oss << std::left << "[error]: " << "value is not a number" << std::endl;
724             dumpInfo_.append(oss.str());
725             return;
726         }
727         int32_t value = std::stoi(valueStr);
728         ScreenSessionManager::GetInstance().NotifyCastWhenScreenConnectChange(static_cast<bool>(value));
729         oss << std::left << "[success]: " << "send cast publish event success" << std::endl;
730     } else {
731         oss << std::left << "[error]: " << "the command is invalid" << std::endl;
732     }
733     dumpInfo_.append(oss.str());
734 }
735 
IsValidDisplayModeCommand(std::string command)736 bool ScreenSessionDumper::IsValidDisplayModeCommand(std::string command)
737 {
738     if (std::find(displayModeCommands.begin(), displayModeCommands.end(), command) != displayModeCommands.end()) {
739         return true;
740     }
741     return false;
742 }
743 
SetFoldDisplayMode()744 int ScreenSessionDumper::SetFoldDisplayMode()
745 {
746     std::string modeParam = params_[0];
747     if (modeParam.empty()) {
748         return -1;
749     }
750     FoldDisplayMode displayMode = FoldDisplayMode::UNKNOWN;
751     if (modeParam == ARG_FOLD_DISPLAY_FULL) {
752         displayMode = FoldDisplayMode::FULL;
753     } else if (modeParam == ARG_FOLD_DISPLAY_MAIN) {
754         displayMode = FoldDisplayMode::MAIN;
755     } else if (modeParam == ARG_FOLD_DISPLAY_SUB) {
756         displayMode = FoldDisplayMode::SUB;
757     } else if (modeParam == ARG_FOLD_DISPLAY_COOR) {
758         displayMode = FoldDisplayMode::COORDINATION;
759     } else {
760         TLOGW(WmsLogTag::DMS, "SetFoldDisplayMode mode not support");
761         return -1;
762     }
763     ScreenSessionManager::GetInstance().SetFoldDisplayMode(displayMode);
764     return 0;
765 }
766 
SetFoldStatusLocked()767 int ScreenSessionDumper::SetFoldStatusLocked()
768 {
769     std::string lockParam = params_[0];
770     if (lockParam.empty()) {
771         return -1;
772     }
773     bool lockDisplayStatus = false;
774     if (lockParam == ARG_LOCK_FOLD_DISPLAY_STATUS) {
775         lockDisplayStatus = true;
776     } else if (lockParam == ARG_UNLOCK_FOLD_DISPLAY_STATUS) {
777         lockDisplayStatus = false;
778     } else {
779         TLOGW(WmsLogTag::DMS, "SetFoldStatusLocked status not support");
780         return -1;
781     }
782     ScreenSessionManager::GetInstance().SetFoldStatusLocked(lockDisplayStatus);
783     return 0;
784 }
785 
SetEnterOrExitTentMode(std::string input)786 void ScreenSessionDumper::SetEnterOrExitTentMode(std::string input)
787 {
788 #ifdef FOLD_ABILITY_ENABLE
789     if (input == ARG_SET_ON_TENT_MODE) {
790         ScreenSessionManager::GetInstance().OnTentModeChanged(true);
791     } else if (input == ARG_SET_OFF_TENT_MODE) {
792         ScreenSessionManager::GetInstance().OnTentModeChanged(false);
793     }
794 #endif
795 }
796 
SetHoverStatusChange(std::string input)797 void ScreenSessionDumper::SetHoverStatusChange(std::string input)
798 {
799     size_t commaPos = input.find_last_of(',');
800     auto screenSession = ScreenSessionManager::GetInstance().GetDefaultScreenSession();
801     if (screenSession == nullptr) {
802         TLOGE(WmsLogTag::DMS, "screenSession is nullptr");
803         return;
804     }
805     if ((commaPos != std::string::npos) && (input.substr(0, commaPos) == ARG_SET_HOVER_STATUS)) {
806         std::string valueStr = input.substr(commaPos + 1);
807         if (valueStr.size() != 1) {
808             dumpInfo_.append("[error]: the value is too long");
809             return;
810         }
811         if (!std::isdigit(valueStr[0])) {
812             dumpInfo_.append("[error]: value is not a number");
813             return;
814         }
815         int32_t value = std::stoi(valueStr);
816         if ((value < static_cast<int32_t>(DeviceHoverStatus::INVALID)) ||
817             (value > static_cast<int32_t>(DeviceHoverStatus::CAMERA_STATUS_CANCEL))) {
818             TLOGE(WmsLogTag::DMS, "params is invalid: %{public}d", value);
819             return;
820         }
821         screenSession->HoverStatusChange(value);
822         TLOGI(WmsLogTag::DMS, "SetHoverStatusChange: %{public}d", value);
823     }
824 }
825 
SetHallAndPostureValue(std::string input)826 void ScreenSessionDumper::SetHallAndPostureValue(std::string input)
827 {
828 #ifdef FOLD_ABILITY_ENABLE
829     std::string token;
830     std::istringstream ss(input);
831     std::vector<std::string> tokens;
832     while (std::getline(ss, token, ',')) {
833         tokens.push_back(token);
834     }
835     if (tokens.size() != DUMPER_PARAM_INDEX_THREE && tokens[0] != ARG_SET_POSTURE_HALL) {
836         TLOGE(WmsLogTag::DMS, "param error: %{public}s", input.c_str());
837         return;
838     }
839     if (!IsNumber(tokens[DUMPER_PARAM_INDEX_ONE]) || !IsNumber(tokens[DUMPER_PARAM_INDEX_TWO])) {
840         TLOGE(WmsLogTag::DMS, "param error: %{public}s", input.c_str());
841         return;
842     }
843     int hallVal = stoi(tokens[DUMPER_PARAM_INDEX_ONE]);
844     int postureVal = stoi(tokens[DUMPER_PARAM_INDEX_TWO]);
845     FoldScreenSensorManager::ExtHallData hallData = {
846         .flag = (1 << 1),
847         .hall = hallVal,
848     };
849     PostureData postureData = {
850         .angle = postureVal,
851     };
852     SensorEvent hallEvent = {
853         .data = reinterpret_cast<uint8_t *>(&hallData),
854         .dataLen = sizeof(FoldScreenSensorManager::ExtHallData),
855     };
856     SensorEvent postureEvent = {
857         .data = reinterpret_cast<uint8_t *>(&postureData),
858         .dataLen = sizeof(PostureData),
859     };
860     FoldScreenSensorManager::GetInstance().HandleHallData(&hallEvent);
861     FoldScreenSensorManager::GetInstance().HandlePostureData(&postureEvent);
862     TLOGI(WmsLogTag::DMS, "mock posture: %{public}d, hall: %{public}d ", postureVal, hallVal);
863 #endif
864 }
865 
SetHallAndPostureStatus(std::string input)866 void ScreenSessionDumper::SetHallAndPostureStatus(std::string input)
867 {
868 #ifdef FOLD_ABILITY_ENABLE
869     size_t commaPos = input.find_last_of(',');
870     if ((commaPos != std::string::npos) && (input.substr(0, commaPos) == ARG_SET_POSTURE_HALL_STATUS)) {
871         std::string valueStr = input.substr(commaPos + 1, DUMPER_PARAM_INDEX_ONE);
872         if (valueStr.size() != DUMPER_PARAM_INDEX_ONE && !std::isdigit(valueStr[0])) {
873             return;
874         }
875         int32_t value = std::stoi(valueStr);
876         if (value) {
877             if (FoldScreenStateInternel::IsSuperFoldDisplayDevice()) {
878                 SuperFoldSensorManager::GetInstance().RegisterPostureCallback();
879                 SuperFoldSensorManager::GetInstance().RegisterHallCallback();
880             } else {
881                 FoldScreenSensorManager::GetInstance().RegisterHallCallback();
882                 FoldScreenSensorManager::GetInstance().RegisterPostureCallback();
883                 ScreenSensorConnector::SubscribeRotationSensor();
884             }
885         } else {
886             if (FoldScreenStateInternel::IsSuperFoldDisplayDevice()) {
887                 SuperFoldSensorManager::GetInstance().UnregisterPostureCallback();
888                 SuperFoldSensorManager::GetInstance().UnregisterHallCallback();
889             } else {
890                 FoldScreenSensorManager::GetInstance().UnRegisterHallCallback();
891                 FoldScreenSensorManager::GetInstance().UnRegisterPostureCallback();
892                 ScreenSensorConnector::UnsubscribeRotationSensor();
893             }
894         }
895         TLOGI(WmsLogTag::DMS, "hall and posture register status: %{public}d", value);
896     }
897 #endif
898 }
899 
SetSuperFoldStatusChange(std::string input)900 void ScreenSessionDumper::SetSuperFoldStatusChange(std::string input)
901 {
902 #ifdef FOLD_ABILITY_ENABLE
903     size_t commaPos = input.find_last_of(',');
904     if ((commaPos != std::string::npos) && (input.substr(0, commaPos) == ARG_SET_SUPER_FOLD_STATUS)) {
905         std::string valueStr = input.substr(commaPos + 1, SUPER_FOLD_STATUS_MAX);
906         if (valueStr.empty()) {
907             return;
908         }
909         if (valueStr.size() == 1 && !std::isdigit(valueStr[0])) {
910             return;
911         }
912         if (valueStr.size() == SUPER_FOLD_STATUS_MAX && !std::isdigit(valueStr[0])
913             && !std::isdigit(valueStr[1])) {
914             return;
915         }
916         int32_t value = std::stoi(valueStr);
917         if (value <=  static_cast<int32_t>(SuperFoldStatusChangeEvents::UNDEFINED) ||
918             value >= static_cast<int32_t>(SuperFoldStatusChangeEvents::INVALID)) {
919             TLOGE(WmsLogTag::DMS, "params is invalid: %{public}d", value);
920             return;
921         }
922         SuperFoldStateManager::GetInstance().
923             HandleSuperFoldStatusChange(static_cast<SuperFoldStatusChangeEvents>(value));
924         TLOGI(WmsLogTag::DMS, "state: %{public}d, event: %{public}d",
925             SuperFoldStateManager::GetInstance().GetCurrentStatus(), value);
926     }
927 #endif
928 }
929 
SetSecondaryStatusChange(const std::string & input)930 void ScreenSessionDumper::SetSecondaryStatusChange(const std::string &input)
931 {
932 #ifdef FOLD_ABILITY_ENABLE
933     if (!FoldScreenStateInternel::IsSecondaryDisplayFoldDevice()) {
934         TLOGD(WmsLogTag::DMS, "not secondary device");
935         return;
936     }
937     TLOGI(WmsLogTag::DMS, "secondary input: %{public}s", input.c_str());
938     size_t commaPos = input.find(',');
939     if (!((commaPos != std::string::npos) && (input.substr(0, commaPos) == ARG_SET_SECONDARY_FOLD_STATUS))) {
940         return;
941     }
942     std::string valueStr = input.substr(commaPos + 1, 1);
943     if (valueStr.empty()) {
944         return;
945     }
946     char ch = valueStr[0];
947     TLOGI(WmsLogTag::DMS, "value: %{public}c", ch);
948     const char *end = SECONDARY_DUMPER_VALUE_BOUNDARY + sizeof(SECONDARY_DUMPER_VALUE_BOUNDARY); // mfg
949     const char *result = std::find(SECONDARY_DUMPER_VALUE_BOUNDARY, end, ch);
950     if (result == end) {
951         if (ch == 'p') { // sensor
952             TriggerSecondarySensor(input.substr(commaPos + 1, input.size() - commaPos - 1));
953         } else if (ch == 'z') { // foldstatus
954             TriggerSecondaryFoldStatus(input.substr(commaPos + 1, input.size() - commaPos - 1));
955         } else {
956             TLOGE(WmsLogTag::DMS, "command not supported.");
957         }
958         return;
959     }
960 
961     FoldDisplayMode displayMode = FoldDisplayMode::UNKNOWN;
962     if (ch == SECONDARY_DUMPER_VALUE_BOUNDARY[SECONDARY_FOLD_STATUS_INDEX_M]) {
963         displayMode = FoldDisplayMode::FULL;
964     } else if (ch == SECONDARY_DUMPER_VALUE_BOUNDARY[SECONDARY_FOLD_STATUS_INDEX_F]) {
965         displayMode = FoldDisplayMode::MAIN;
966     } else if (ch == SECONDARY_DUMPER_VALUE_BOUNDARY[SECONDARY_FOLD_STATUS_INDEX_G]) {
967         displayMode = FoldDisplayMode::GLOBAL_FULL;
968     } else {
969         TLOGW(WmsLogTag::DMS, "SetFoldDisplayMode mode is not supported.");
970         return;
971     }
972     ScreenSessionManager::GetInstance().SetFoldDisplayMode(displayMode);
973 #endif
974 }
975 #ifdef FOLD_ABILITY_ENABLE
IsAllCharDigit(const std::string & firstPostureStr)976 bool ScreenSessionDumper::IsAllCharDigit(const std::string &firstPostureStr)
977 {
978     for (size_t i = 0; i < firstPostureStr.size(); i++) {
979         if (!std::isdigit(firstPostureStr[i])) {
980             TLOGW(WmsLogTag::DMS, "%{public}s is not number", firstPostureStr.c_str());
981             return false;
982         }
983     }
984     return true;
985 }
986 
GetPostureAndHall(std::vector<std::string> strVec,std::vector<float> & postures,std::vector<uint16_t> & halls)987 bool ScreenSessionDumper::GetPostureAndHall(std::vector<std::string> strVec,
988     std::vector<float> &postures, std::vector<uint16_t> &halls)
989 {
990     for (std::string str : strVec) {
991         size_t index = str.find(":");
992         if (index == std::string::npos) {
993             return false;
994         }
995         std::string key = str.substr(0, index);
996         std::string value = str.substr(index + 1, str.size() - index - 1);
997         index = value.find(",");
998         if (index == std::string::npos) {
999             return false;
1000         }
1001         std::vector<std::string> posturesStrList = WindowHelper::Split(value, ",");
1002         std::string firstPostureStr;
1003         std::string secondPostureStr;
1004         std::string thirdPostureStr;
1005         if (posturesStrList.size() == DUMPER_PARAM_INDEX_THREE) {
1006             firstPostureStr = posturesStrList[0];
1007             secondPostureStr = posturesStrList[1];
1008             thirdPostureStr = posturesStrList[DUMPER_PARAM_INDEX_TWO];
1009             if (!WindowHelper::IsFloatingNumber(firstPostureStr) ||
1010                 !WindowHelper::IsFloatingNumber(secondPostureStr)) {
1011                 TLOGW(WmsLogTag::DMS, "posture should be a float number");
1012                 return false;
1013             }
1014             if (thirdPostureStr != "0" && thirdPostureStr != "1") {
1015                 TLOGW(WmsLogTag::DMS, "third posture is not 0 or 1");
1016                 return false;
1017             }
1018             postures.emplace_back(std::stof(firstPostureStr));
1019             postures.emplace_back(std::stof(secondPostureStr));
1020             postures.emplace_back(std::stof(thirdPostureStr));
1021         } else if (posturesStrList.size() == DUMPER_PARAM_INDEX_TWO) {
1022             firstPostureStr = posturesStrList[0];
1023             secondPostureStr = posturesStrList[1];
1024             if (!IsAllCharDigit(firstPostureStr) || !IsAllCharDigit(secondPostureStr)) {
1025                 return false;
1026             }
1027             halls.emplace_back(static_cast<uint16_t>(std::stoi(firstPostureStr)));
1028             halls.emplace_back(static_cast<uint16_t>(std::stoi(secondPostureStr)));
1029         } else {
1030             TLOGW(WmsLogTag::DMS, "sensor command error");
1031             return false;
1032         }
1033     }
1034     return true;
1035 }
1036 
TriggerSecondarySensor(const std::string & valueStr)1037 void ScreenSessionDumper::TriggerSecondarySensor(const std::string &valueStr)
1038 {
1039     TLOGI(WmsLogTag::DMS, "%{public}s", valueStr.c_str());
1040     std::vector<std::string> strVec = WindowHelper::Split(valueStr, "/");
1041     std::vector<float> postures;
1042     std::vector<uint16_t> halls;
1043     if (!GetPostureAndHall(strVec, postures, halls)) {
1044         TLOGW(WmsLogTag::DMS, "GetPostureAndHall failed");
1045         return;
1046     }
1047     FoldScreenSensorManager::ExtHallData hallData = {
1048         .flag = HALL_EXT_DATA_FLAG,
1049         .hall = halls[0],
1050         .hallAb = halls[1],
1051     };
1052     FoldScreenSensorManager::PostureDataSecondary postureData = {
1053         .postureBc = postures[0],
1054         .postureAb = postures[1],
1055         .postureAbAnti = postures[DUMPER_PARAM_INDEX_TWO],
1056     };
1057     SensorEvent hallEvent = {
1058         .data = reinterpret_cast<uint8_t *>(&hallData),
1059         .dataLen = sizeof(FoldScreenSensorManager::ExtHallData),
1060     };
1061     SensorEvent postureEvent = {
1062         .data = reinterpret_cast<uint8_t *>(&postureData),
1063         .dataLen = sizeof(FoldScreenSensorManager::PostureDataSecondary),
1064     };
1065     TLOGI(WmsLogTag::DMS, "mock secondary sensor: %{public}s, %{public}s",
1066         FoldScreenStateInternel::TransVec2Str(postures, ANGLE_STR).c_str(),
1067         FoldScreenStateInternel::TransVec2Str(halls, HALL_STR).c_str());
1068     SecondaryFoldSensorManager::GetInstance().HandleHallDataExt(&hallEvent);
1069     SecondaryFoldSensorManager::GetInstance().HandlePostureData(&postureEvent);
1070 }
1071 
TriggerSecondaryFoldStatus(const std::string & valueStr)1072 void ScreenSessionDumper::TriggerSecondaryFoldStatus(const std::string &valueStr)
1073 {
1074     std::vector<std::string> strVec = WindowHelper::Split(valueStr, "=");
1075     if (strVec.size() != SECONDARY_FOLD_STATUS_COMMAND_NUM) {
1076         TLOGW(WmsLogTag::DMS, "secondary foldstatus command miss '=' or has extra '='.");
1077         return;
1078     }
1079     const std::string &foldStatusStr = strVec[1];
1080     for (size_t i = 0; i < foldStatusStr.size(); i++) {
1081         if (!std::isdigit(foldStatusStr[i])) {
1082             TLOGW(WmsLogTag::DMS, "secondary foldstatus command contains characters that are not numbers.");
1083             return;
1084         }
1085     }
1086     uint32_t foldStatus = static_cast<uint32_t>(std::stoi(foldStatusStr));
1087     switch (foldStatus) {
1088         case static_cast<uint32_t>(FoldStatus::EXPAND) :
1089         case static_cast<uint32_t>(FoldStatus::FOLDED) :
1090         case static_cast<uint32_t>(FoldStatus::HALF_FOLD) :
1091         case static_cast<uint32_t>(FoldStatus::FOLD_STATE_EXPAND_WITH_SECOND_EXPAND) :
1092         case static_cast<uint32_t>(FoldStatus::FOLD_STATE_EXPAND_WITH_SECOND_HALF_FOLDED) :
1093         case static_cast<uint32_t>(FoldStatus::FOLD_STATE_FOLDED_WITH_SECOND_EXPAND) :
1094         case static_cast<uint32_t>(FoldStatus::FOLD_STATE_FOLDED_WITH_SECOND_HALF_FOLDED) :
1095         case static_cast<uint32_t>(FoldStatus::FOLD_STATE_HALF_FOLDED_WITH_SECOND_EXPAND) :
1096         case static_cast<uint32_t>(FoldStatus::FOLD_STATE_HALF_FOLDED_WITH_SECOND_HALF_FOLDED) : {
1097             break;
1098         }
1099         default: {
1100             TLOGW(WmsLogTag::DMS, "secondary foldstatus is out of range.");
1101             return;
1102         }
1103     }
1104     TLOGI(WmsLogTag::DMS, "change fold status, %{public}s", foldStatusStr.c_str());
1105     ScreenSessionManager::GetInstance().TriggerFoldStatusChange(static_cast<FoldStatus>(foldStatus));
1106 }
1107 #endif
1108 } // Rosen
1109 } // OHOS