• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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 "CommandLine.h"
17 
18 #include <algorithm>
19 #include <regex>
20 #include <sstream>
21 
22 #include "CommandLineInterface.h"
23 #include "CommandParser.h"
24 #include "Interrupter.h"
25 #include "JsApp.h"
26 #include "JsAppImpl.h"
27 #include "JsonReader.h"
28 #include "LanguageManagerImpl.h"
29 #include "ModelConfig.h"
30 #include "ModelManager.h"
31 #include "MouseInputImpl.h"
32 #include "MouseWheelImpl.h"
33 #include "KeyInputImpl.h"
34 #include "PreviewerEngineLog.h"
35 #include "SharedData.h"
36 #include "VirtualMessageImpl.h"
37 #include "VirtualScreenImpl.h"
38 
39 using namespace std;
40 
CommandLine(CommandType commandType,const Json2::Value & arg,const LocalSocket & socket)41 CommandLine::CommandLine(CommandType commandType, const Json2::Value& arg, const LocalSocket& socket)
42     : args(arg), cliSocket(socket), type(commandType), commandName("")
43 {
44 }
45 
~CommandLine()46 CommandLine::~CommandLine()
47 {
48 }
49 
CheckAndRun()50 void CommandLine::CheckAndRun()
51 {
52     if (!IsArgValid()) {
53         ELOG("CheckAndRun: invalid command params");
54         SetCommandResult("result", JsonReader::CreateBool(false));
55         SendResult();
56         return;
57     }
58     Run();
59     SendResult();
60 }
61 
SendResult()62 void CommandLine::SendResult()
63 {
64     if (commandResult.IsNull() || !commandResult.IsValid()) {
65         return;
66     }
67     cliSocket << commandResult.ToStyledString();
68     ELOG("SendResult commandResult: %s", commandResult.ToStyledString().c_str());
69     commandResult.Clear();
70 }
71 
RunAndSendResultToManager()72 void CommandLine::RunAndSendResultToManager()
73 {
74     Run();
75     SendResultToManager();
76 }
77 
SendResultToManager()78 void CommandLine::SendResultToManager()
79 {
80     if (commandResultToManager.IsNull() || !commandResultToManager.IsValid()) {
81         return;
82     }
83     cliSocket << commandResultToManager.ToStyledString();
84     commandResultToManager.Clear();
85 }
86 
IsArgValid() const87 bool CommandLine::IsArgValid() const
88 {
89     if (type == CommandType::GET) {
90         return IsGetArgValid();
91     }
92     if (type == CommandType::SET) {
93         return IsSetArgValid();
94     }
95     if (type == CommandType::ACTION) {
96         return IsActionArgValid();
97     }
98     return true;
99 }
100 
ToUint8(std::string str) const101 uint8_t CommandLine::ToUint8(std::string str) const
102 {
103     int value = atoi(str.data());
104     if (value > UINT8_MAX) {
105         ELOG("CommandLine::ToUint8 value is overflow, value: %d", value);
106     }
107     return static_cast<uint8_t>(value);
108 }
109 
SetCommandName(std::string command)110 void CommandLine::SetCommandName(std::string command)
111 {
112     this->commandName = command;
113 }
114 
SetCommandResult(const std::string & resultType,const Json2::Value & resultContent)115 void CommandLine::SetCommandResult(const std::string& resultType, const Json2::Value& resultContent)
116 {
117     this->commandResult.Add("version", CommandLineInterface::COMMAND_VERSION.c_str());
118     this->commandResult.Add("command", this->commandName.c_str());
119     this->commandResult.Add(resultType.c_str(), resultContent);
120 }
121 
SetResultToManager(const std::string & resultType,const Json2::Value & resultContent,const std::string & messageType)122 void CommandLine::SetResultToManager(const std::string& resultType,
123                                      const Json2::Value& resultContent,
124                                      const std::string& messageType)
125 {
126     this->commandResultToManager.Add("MessageType", messageType.c_str());
127     this->commandResultToManager.Add(resultType.c_str(), resultContent);
128 }
129 
Run()130 void CommandLine::Run()
131 {
132     if (type == CommandType::GET) {
133         RunGet();
134     } else if (type == CommandType::SET) {
135         RunSet();
136     } else if (type == CommandType::ACTION) {
137         RunAction();
138     }
139 }
140 
IsBoolType(std::string arg) const141 bool CommandLine::IsBoolType(std::string arg) const
142 {
143     regex tofrx("^(true)|(false)$");
144     if (regex_match(arg, tofrx)) {
145         return true;
146     }
147     return false;
148 }
149 
IsIntType(string arg) const150 bool CommandLine::IsIntType(string arg) const
151 {
152     regex isInt("^\\d+$");
153     return regex_match(arg, isInt);
154 }
155 
IsOneDigitFloatType(string arg,bool allowNegativeNumber) const156 bool CommandLine::IsOneDigitFloatType(string arg, bool allowNegativeNumber) const
157 {
158     if (allowNegativeNumber) {
159         regex isFloat("^-?\\d+(\\.\\d+)?$");
160         return regex_match(arg, isFloat);
161     } else {
162         regex isFloat("^\\d(\\.\\d+)?$");
163         return regex_match(arg, isFloat);
164     }
165 }
166 
SetEventParams(EventParams & params)167 void TouchAndMouseCommand::SetEventParams(EventParams& params)
168 {
169     if (CommandParser::GetInstance().GetScreenMode() == CommandParser::ScreenMode::STATIC) {
170         return;
171     }
172     MouseInputImpl::GetInstance().SetMousePosition(params.x, params.y);
173     MouseInputImpl::GetInstance().SetMouseStatus(params.type);
174     MouseInputImpl::GetInstance().SetMouseButton(params.button);
175     MouseInputImpl::GetInstance().SetMouseAction(params.action);
176     MouseInputImpl::GetInstance().SetSourceType(params.sourceType);
177     MouseInputImpl::GetInstance().SetSourceTool(params.sourceTool);
178     MouseInputImpl::GetInstance().SetPressedBtns(params.pressedBtnsVec);
179     MouseInputImpl::GetInstance().SetAxisValues(params.axisVec);
180     MouseInputImpl::GetInstance().DispatchOsTouchEvent();
181     std::stringstream ss;
182     ss << "[";
183     for (double val : params.axisVec) {
184         ss << " " << val << " ";
185     }
186     ss << "]" << std::endl;
187     ILOG("%s(%f,%f,%d,%d,%d,%d,%d,%d,%d,%s)", params.name.c_str(), params.x, params.y, params.type, params.button,
188         params.action, params.sourceType, params.sourceTool, params.pressedBtnsVec.size(), params.axisVec.size(),
189         ss.str().c_str());
190 }
191 
IsActionArgValid() const192 bool TouchPressCommand::IsActionArgValid() const
193 {
194     if (args.IsNull() || !args.IsMember("x") || !args.IsMember("y") ||
195         !args["x"].IsInt() || !args["y"].IsInt()) {
196         return false;
197     }
198     int32_t pointX = args["x"].AsInt();
199     int32_t pointY = args["y"].AsInt();
200     if (pointX < 0 || pointX > VirtualScreenImpl::GetInstance().GetCurrentWidth()) {
201         ELOG("X coordinate range %d ~ %d", 0, VirtualScreenImpl::GetInstance().GetCurrentWidth());
202         return false;
203     }
204     if (pointY < 0 || pointY > VirtualScreenImpl::GetInstance().GetCurrentHeight()) {
205         ELOG("Y coordinate range %d ~ %d", 0, VirtualScreenImpl::GetInstance().GetCurrentHeight());
206         return false;
207     }
208     return true;
209 }
210 
TouchPressCommand(CommandType commandType,const Json2::Value & arg,const LocalSocket & socket)211 TouchPressCommand::TouchPressCommand(CommandType commandType, const Json2::Value& arg, const LocalSocket& socket)
212     : CommandLine(commandType, arg, socket)
213 {
214 }
215 
RunAction()216 void TouchPressCommand::RunAction()
217 {
218     int type = 0;
219     EventParams param;
220     param.x = args["x"].AsDouble();
221     param.y = args["y"].AsDouble();
222     param.type = type;
223     param.name = "TouchPress";
224     param.button = MouseInputImpl::GetInstance().defaultButton;
225     param.action = MouseInputImpl::GetInstance().defaultAction;
226     param.sourceType = MouseInputImpl::GetInstance().defaultSourceType;
227     param.sourceTool = MouseInputImpl::GetInstance().defaultSourceTool;
228     SetEventParams(param);
229     SetCommandResult("result", JsonReader::CreateBool(true));
230 }
231 
IsActionArgValid() const232 bool MouseWheelCommand::IsActionArgValid() const
233 {
234     if (args.IsNull() || !args.IsMember("rotate") || !args["rotate"].IsDouble()) {
235         return false;
236     }
237     return true;
238 }
239 
MouseWheelCommand(CommandType commandType,const Json2::Value & arg,const LocalSocket & socket)240 MouseWheelCommand::MouseWheelCommand(CommandType commandType, const Json2::Value& arg, const LocalSocket& socket)
241     : CommandLine(commandType, arg, socket)
242 {
243 }
244 
RunAction()245 void MouseWheelCommand::RunAction()
246 {
247     if (CommandParser::GetInstance().GetScreenMode() == CommandParser::ScreenMode::STATIC) {
248         return;
249     }
250     MouseWheelImpl::GetInstance().SetRotate(args["rotate"].AsDouble());
251     SetCommandResult("result", JsonReader::CreateBool(true));
252     ILOG("CrownRotate (%f)", args["rotate"].AsDouble());
253 }
254 
IsActionArgValid() const255 bool TouchReleaseCommand::IsActionArgValid() const
256 {
257     if (args.IsNull() || !args.IsMember("x") || !args.IsMember("y") ||
258         !args["x"].IsInt() || !args["y"].IsInt()) {
259         return false;
260     }
261     int32_t pX = args["x"].AsInt();
262     int32_t pY = args["y"].AsInt();
263     if (pY < 0 || pY > VirtualScreenImpl::GetInstance().GetCurrentHeight()) {
264         ELOG("Y coordinate range %d ~ %d", 0, VirtualScreenImpl::GetInstance().GetCurrentHeight());
265         return false;
266     }
267     if (pX < 0 || pX > VirtualScreenImpl::GetInstance().GetCurrentWidth()) {
268         ELOG("X coordinate range %d ~ %d", 0, VirtualScreenImpl::GetInstance().GetCurrentWidth());
269         return false;
270     }
271     return true;
272 }
273 
TouchReleaseCommand(CommandType commandType,const Json2::Value & arg,const LocalSocket & socket)274 TouchReleaseCommand::TouchReleaseCommand(CommandType commandType, const Json2::Value& arg, const LocalSocket& socket)
275     : CommandLine(commandType, arg, socket)
276 {
277 }
278 
RunAction()279 void TouchReleaseCommand::RunAction()
280 {
281     int type = 1;
282     EventParams param;
283     param.x = args["x"].AsDouble();
284     param.y = args["y"].AsDouble();
285     param.type = type;
286     param.name = "TouchRelease";
287     param.button = MouseInputImpl::GetInstance().defaultButton;
288     param.action = MouseInputImpl::GetInstance().defaultAction;
289     param.sourceType = MouseInputImpl::GetInstance().defaultSourceType;
290     param.sourceTool = MouseInputImpl::GetInstance().defaultSourceTool;
291     SetEventParams(param);
292     SetCommandResult("result", JsonReader::CreateBool(true));
293 }
294 
IsActionArgValid() const295 bool TouchMoveCommand::IsActionArgValid() const
296 {
297     if (args.IsNull() || !args.IsMember("x") || !args.IsMember("y") ||
298         !args["x"].IsInt() || !args["y"].IsInt()) {
299         return false;
300     }
301     int32_t pX = args["x"].AsInt();
302     int32_t pY = args["y"].AsInt();
303     if (pX < 0 || pX > VirtualScreenImpl::GetInstance().GetCurrentWidth()) {
304         ELOG("X coordinate range %d ~ %d", 0, VirtualScreenImpl::GetInstance().GetCurrentWidth());
305         return false;
306     }
307     if (pY < 0 || pY > VirtualScreenImpl::GetInstance().GetCurrentHeight()) {
308         ELOG("Y coordinate range %d ~ %d", 0, VirtualScreenImpl::GetInstance().GetCurrentHeight());
309         return false;
310     }
311     return true;
312 }
313 
TouchMoveCommand(CommandType commandType,const Json2::Value & arg,const LocalSocket & socket)314 TouchMoveCommand::TouchMoveCommand(CommandType commandType, const Json2::Value& arg, const LocalSocket& socket)
315     : CommandLine(commandType, arg, socket)
316 {
317 }
318 
RunAction()319 void TouchMoveCommand::RunAction()
320 {
321     int type = 2;
322     EventParams param;
323     param.x = args["x"].AsDouble();
324     param.y = args["y"].AsDouble();
325     param.type = type;
326     param.name = "TouchMove";
327     param.button = MouseInputImpl::GetInstance().defaultButton;
328     param.action = MouseInputImpl::GetInstance().defaultAction;
329     param.sourceType = MouseInputImpl::GetInstance().defaultSourceType;
330     param.sourceTool = MouseInputImpl::GetInstance().defaultSourceTool;
331     SetEventParams(param);
332     SetCommandResult("result", JsonReader::CreateBool(true));
333 }
334 
PowerCommand(CommandType commandType,const Json2::Value & arg,const LocalSocket & socket)335 PowerCommand::PowerCommand(CommandType commandType, const Json2::Value& arg, const LocalSocket& socket)
336     : CommandLine(commandType, arg, socket)
337 {
338 }
339 
IsSetArgValid() const340 bool PowerCommand::IsSetArgValid() const
341 {
342     if (args.IsNull() || !args.IsMember("Power") || !args["Power"].IsDouble()) {
343         ELOG("Invalid number of arguments!");
344         return false;
345     }
346     double val = args["Power"].AsDouble();
347     if (!SharedData<double>::IsValid(SharedDataType::BATTERY_LEVEL, val)) {
348         ELOG("PowerCommand invalid value: %f", val);
349         return false;
350     }
351     return true;
352 }
353 
RunGet()354 void PowerCommand::RunGet()
355 {
356     double power = SharedData<double>::GetData(SharedDataType::BATTERY_LEVEL);
357     Json2::Value resultContent = JsonReader::CreateObject();
358     resultContent.Add("Power", power);
359     SetCommandResult("result", resultContent);
360     ILOG("Get power run finished");
361 }
362 
RunSet()363 void PowerCommand::RunSet()
364 {
365     double val = args["Power"].AsDouble();
366     SharedData<double>::SetData(SharedDataType::BATTERY_LEVEL, val);
367     SetCommandResult("result", JsonReader::CreateBool(true));
368     ILOG("Set power run finished, the value is: %f", val);
369 }
370 
VolumeCommand(CommandType commandType,const Json2::Value & arg,const LocalSocket & socket)371 VolumeCommand::VolumeCommand(CommandType commandType, const Json2::Value& arg, const LocalSocket& socket)
372     : CommandLine(commandType, arg, socket)
373 {
374 }
375 
IsSetArgValid() const376 bool VolumeCommand::IsSetArgValid() const
377 {
378     return true;
379 }
380 
RunGet()381 void VolumeCommand::RunGet()
382 {
383     SetCommandResult("result", JsonReader::CreateString("Command offline"));
384     ILOG("Command offline");
385 }
386 
RunSet()387 void VolumeCommand::RunSet()
388 {
389     SetCommandResult("result", JsonReader::CreateString("Command offline"));
390     ILOG("Command offline");
391 }
392 
BarometerCommand(CommandType commandType,const Json2::Value & arg,const LocalSocket & socket)393 BarometerCommand::BarometerCommand(CommandType commandType, const Json2::Value& arg, const LocalSocket& socket)
394     : CommandLine(commandType, arg, socket)
395 {
396 }
397 
IsSetArgValid() const398 bool BarometerCommand::IsSetArgValid() const
399 {
400     if (args.IsNull() || !args.IsMember("Barometer") || !args["Barometer"].IsUInt()) {
401         ELOG("Invalid number of arguments!");
402         return false;
403     }
404     uint32_t val = args["Barometer"].AsUInt();
405     if (!SharedData<uint32_t>::IsValid(SharedDataType::PRESSURE_VALUE, val)) {
406         ELOG("Barometer invalid value: %d", val);
407         return false;
408     }
409     return true;
410 }
411 
RunGet()412 void BarometerCommand::RunGet()
413 {
414     int barometer = static_cast<int>(SharedData<uint32_t>::GetData(SharedDataType::PRESSURE_VALUE));
415     Json2::Value resultContent = JsonReader::CreateObject();
416     resultContent.Add("Barometer", barometer);
417     SetCommandResult("result", resultContent);
418     ILOG("Get barometer run finished");
419 }
420 
RunSet()421 void BarometerCommand::RunSet()
422 {
423     uint32_t val = args["Barometer"].AsUInt();
424     SharedData<uint32_t>::SetData(SharedDataType::PRESSURE_VALUE, val);
425     SetCommandResult("result", JsonReader::CreateBool(true));
426     ILOG("Set barometer run finished, the value is: %d", val);
427 }
428 
ResolutionSwitchCommand(CommandType commandType,const Json2::Value & arg,const LocalSocket & socket)429 ResolutionSwitchCommand::ResolutionSwitchCommand(CommandType commandType,
430                                                  const Json2::Value& arg,
431                                                  const LocalSocket& socket)
432     : CommandLine(commandType, arg, socket)
433 {
434 }
435 
IsSetArgValid() const436 bool ResolutionSwitchCommand::IsSetArgValid() const
437 {
438     if (args.IsNull() || !args.IsMember("originWidth") || !args.IsMember("originHeight") || !args.IsMember("width") ||
439         !args.IsMember("height") || !args.IsMember("screenDensity")) {
440         ELOG("Invalid param of arguments!");
441         return false;
442     }
443     if (!args["originWidth"].IsInt() || !args["originHeight"].IsInt() ||
444         !args["screenDensity"].IsInt() || !args["width"].IsInt() || !args["height"].IsInt()) {
445         ELOG("Invalid number of arguments!");
446         return false;
447     }
448     if (!IsIntValValid()) {
449         return false;
450     }
451     if (args.IsMember("reason")) {
452         if (!args["reason"].IsString()) {
453             return false;
454         }
455         string reason = args["reason"].AsString();
456         if (reason != "rotation" && reason != "resize" && reason != "undefined") {
457             ELOG("Invalid value of reason!");
458             return false;
459         }
460     }
461     return true;
462 }
463 
IsIntValValid() const464 bool ResolutionSwitchCommand::IsIntValValid() const
465 {
466     if (args["originWidth"].AsInt() < minWidth || args["originWidth"].AsInt() > maxWidth ||
467         args["originHeight"].AsInt() < minWidth || args["originHeight"].AsInt() > maxWidth ||
468         args["width"].AsInt() < minWidth || args["width"].AsInt() > maxWidth ||
469         args["height"].AsInt() < minWidth || args["height"].AsInt() > maxWidth) {
470         ELOG("width or height is out of range %d-%d", minWidth, maxWidth);
471         return false;
472     }
473     if (args["screenDensity"].AsInt() < minDpi || args["screenDensity"].AsInt() > maxDpi) {
474         ELOG("screenDensity is out of range %d-%d", minDpi, maxDpi);
475         return false;
476     }
477     return true;
478 }
479 
RunSet()480 void ResolutionSwitchCommand::RunSet()
481 {
482     int32_t originWidth = args["originWidth"].AsInt();
483     int32_t originHeight = args["originHeight"].AsInt();
484     int32_t width = args["width"].AsInt();
485     int32_t height = args["height"].AsInt();
486     int32_t screenDensity = args["screenDensity"].AsInt();
487     string reason = "undefined";
488     if (args.IsMember("reason")) {
489         reason = args["reason"].AsString();
490     }
491     ResolutionParam param(originWidth, originHeight, width, height);
492     JsAppImpl::GetInstance().ResolutionChanged(param, screenDensity, reason);
493     SetCommandResult("result", JsonReader::CreateBool(true));
494     ILOG("ResolutionSwitch run finished.");
495 }
496 
OrientationCommand(CommandType commandType,const Json2::Value & arg,const LocalSocket & socket)497 OrientationCommand::OrientationCommand(CommandType commandType, const Json2::Value& arg, const LocalSocket& socket)
498     : CommandLine(commandType, arg, socket)
499 {
500 }
501 
IsSetArgValid() const502 bool OrientationCommand::IsSetArgValid() const
503 {
504     if (args.IsNull() || !args.IsMember("Orientation") || !args["Orientation"].IsString()) {
505         ELOG("Invalid number of arguments!");
506         return false;
507     }
508     if (args["Orientation"].AsString() != "portrait" && args["Orientation"].AsString() != "landscape") {
509         ELOG("Orientation just support [portrait,landscape].");
510         return false;
511     }
512     return true;
513 }
514 
RunSet()515 void OrientationCommand::RunSet()
516 {
517     std::string commandOrientation = args["Orientation"].AsString();
518     std::string currentOrientation = JsAppImpl::GetInstance().GetOrientation();
519     if (commandOrientation != currentOrientation) {
520         JsAppImpl::GetInstance().OrientationChanged(commandOrientation);
521     }
522     SetCommandResult("result", JsonReader::CreateBool(true));
523     ILOG("Set Orientation run finished, Orientation is: %s", args["Orientation"].AsString().c_str());
524 }
525 
ColorModeCommand(CommandType commandType,const Json2::Value & arg,const LocalSocket & socket)526 ColorModeCommand::ColorModeCommand(CommandType commandType, const Json2::Value& arg, const LocalSocket& socket)
527     : CommandLine(commandType, arg, socket)
528 {
529 }
530 
IsSetArgValid() const531 bool ColorModeCommand::IsSetArgValid() const
532 {
533     if (args.IsNull() || !args.IsMember("ColorMode") || !args["ColorMode"].IsString()) {
534         ELOG("Invalid number of arguments!");
535         return false;
536     }
537 
538     if (args["ColorMode"].AsString() != "light" && args["ColorMode"].AsString() != "dark") {
539         ELOG("ColorMode just support [light,dark]");
540         return false;
541     }
542     return true;
543 }
544 
RunSet()545 void ColorModeCommand::RunSet()
546 {
547     std::string commandColorMode = args["ColorMode"].AsString();
548     std::string currentColorMode = JsAppImpl::GetInstance().GetColorMode();
549     if (commandColorMode != currentColorMode) {
550         JsAppImpl::GetInstance().SetArgsColorMode(args["ColorMode"].AsString());
551         JsAppImpl::GetInstance().ColorModeChanged(commandColorMode);
552     }
553     SetCommandResult("result", JsonReader::CreateBool(true));
554     ILOG("Set ColorMode run finished, ColorMode is: %s", args["ColorMode"].AsString().c_str());
555 }
556 
FontSelectCommand(CommandType commandType,const Json2::Value & arg,const LocalSocket & socket)557 FontSelectCommand::FontSelectCommand(CommandType commandType, const Json2::Value& arg, const LocalSocket& socket)
558     : CommandLine(commandType, arg, socket)
559 {
560 }
561 
IsSetArgValid() const562 bool FontSelectCommand::IsSetArgValid() const
563 {
564     if (args.IsNull() || !args.IsMember("FontSelect") || !args["FontSelect"].IsBool()) {
565         ELOG("Invalid number of arguments!");
566         return false;
567     }
568     return true;
569 }
570 
RunSet()571 void FontSelectCommand::RunSet()
572 {
573     SetCommandResult("result", JsonReader::CreateBool(true));
574     ILOG("FontSelect finished, currentSelect is: %s", args["FontSelect"].AsBool() ? "true" : "false");
575 }
576 
MemoryRefreshCommand(CommandType commandType,const Json2::Value & arg,const LocalSocket & socket)577 MemoryRefreshCommand::MemoryRefreshCommand(CommandType commandType, const Json2::Value& arg, const LocalSocket& socket)
578     : CommandLine(commandType, arg, socket)
579 {
580 }
581 
IsSetArgValid() const582 bool MemoryRefreshCommand::IsSetArgValid() const
583 {
584     if (args.IsNull()) {
585         ELOG("Invalid MemoryRefresh of arguments!");
586         return false;
587     }
588     return true;
589 }
590 
RunSet()591 void MemoryRefreshCommand::RunSet()
592 {
593     ILOG("MemoryRefreshCommand begin.");
594     bool ret = JsAppImpl::GetInstance().MemoryRefresh(args.ToStyledString());
595     SetCommandResult("result", JsonReader::CreateBool(ret));
596     ILOG("MemoryRefresh finished.");
597 }
598 
LoadDocumentCommand(CommandType commandType,const Json2::Value & arg,const LocalSocket & socket)599 LoadDocumentCommand::LoadDocumentCommand(CommandType commandType, const Json2::Value& arg, const LocalSocket& socket)
600     : CommandLine(commandType, arg, socket)
601 {
602 }
603 
IsSetArgValid() const604 bool LoadDocumentCommand::IsSetArgValid() const
605 {
606     if (args.IsNull() || !args.IsMember("url") || !args.IsMember("className") || !args.IsMember("previewParam") ||
607         !args["url"].IsString() || !args["className"].IsString() || !args["previewParam"].IsObject()) {
608         return false;
609     }
610     Json2::Value previewParam = args["previewParam"];
611     if (!previewParam["width"].IsInt() || !previewParam["height"].IsInt() || !previewParam["dpi"].IsInt() ||
612         !previewParam["locale"].IsString() || !previewParam["colorMode"].IsString() ||
613         !previewParam["orientation"].IsString() || !previewParam["deviceType"].IsString()) {
614         return false;
615     }
616     if (!IsIntValValid(previewParam) || !IsStrValVailid(previewParam)) {
617         return false;
618     }
619     return true;
620 }
621 
IsIntValValid(const Json2::Value & previewParam) const622 bool LoadDocumentCommand::IsIntValValid(const Json2::Value& previewParam) const
623 {
624     int width = previewParam["width"].AsInt();
625     int height = previewParam["height"].AsInt();
626     int dpi = previewParam["dpi"].AsInt();
627     if (width < minLoadDocWidth || width > maxLoadDocWidth || height < minLoadDocWidth ||
628         height > maxLoadDocWidth || dpi < minDpi || dpi > maxDpi) {
629         return false;
630     }
631     return true;
632 }
633 
IsStrValVailid(const Json2::Value & previewParam) const634 bool LoadDocumentCommand::IsStrValVailid(const Json2::Value& previewParam) const
635 {
636     string locale = previewParam["locale"].AsString();
637     bool isLiteDevice = JsApp::IsLiteDevice(CommandParser::GetInstance().GetDeviceType());
638     if (isLiteDevice) {
639         if (std::find(liteSupportedLanguages.begin(), liteSupportedLanguages.end(), locale) ==
640             liteSupportedLanguages.end()) {
641             return false;
642         }
643     } else {
644         if (std::find(richSupportedLanguages.begin(), richSupportedLanguages.end(), locale) ==
645             richSupportedLanguages.end()) {
646             return false;
647         }
648     }
649     if (previewParam["colorMode"].AsString() != "light" && previewParam["colorMode"].AsString() != "dark") {
650         return false;
651     }
652     if (previewParam["orientation"].AsString() != "portrait" &&
653         previewParam["orientation"].AsString() != "landscape") {
654         return false;
655     }
656     if (std::find(LoadDocDevs.begin(), LoadDocDevs.end(), previewParam["deviceType"].AsString()) ==
657         LoadDocDevs.end()) {
658         return false;
659     }
660     return true;
661 }
662 
RunSet()663 void LoadDocumentCommand::RunSet()
664 {
665     VirtualScreenImpl::GetInstance().SetLoadDocFlag(VirtualScreen::LoadDocType::START);
666     ILOG("LoadDocumentCommand begin.");
667     std::string pageUrl = args["url"].AsString();
668     std::string className = args["className"].AsString();
669     VirtualScreenImpl::GetInstance().InitFlushEmptyTime();
670     JsAppImpl::GetInstance().LoadDocument(pageUrl, className, args["previewParam"]);
671     VirtualScreenImpl::GetInstance().SetLoadDocFlag(VirtualScreen::LoadDocType::FINISHED);
672     SetCommandResult("result", JsonReader::CreateBool(true));
673     ILOG("LoadDocumentCommand finished.");
674 }
675 
ReloadRuntimePageCommand(CommandType commandType,const Json2::Value & arg,const LocalSocket & socket)676 ReloadRuntimePageCommand::ReloadRuntimePageCommand(CommandType commandType,
677                                                    const Json2::Value& arg,
678                                                    const LocalSocket& socket)
679     : CommandLine(commandType, arg, socket)
680 {
681 }
682 
IsSetArgValid() const683 bool ReloadRuntimePageCommand::IsSetArgValid() const
684 {
685     if (args.IsNull() || !args.IsMember("ReloadRuntimePage") || !args["ReloadRuntimePage"].IsString()) {
686         ELOG("Invalid number of arguments!");
687         return false;
688     }
689     return true;
690 }
691 
RunSet()692 void ReloadRuntimePageCommand::RunSet()
693 {
694     std::string currentPage = args["ReloadRuntimePage"].AsString();
695     JsAppImpl::GetInstance().ReloadRuntimePage(currentPage);
696     SetCommandResult("result", JsonReader::CreateBool(true));
697     ILOG("ReloadRuntimePage finished, currentPage is: %s", args["ReloadRuntimePage"].AsString().c_str());
698 }
699 
CurrentRouterCommand(CommandType commandType,const Json2::Value & arg,const LocalSocket & socket)700 CurrentRouterCommand::CurrentRouterCommand(CommandType commandType, const Json2::Value& arg, const LocalSocket& socket)
701     : CommandLine(commandType, arg, socket)
702 {
703 }
704 
RunGet()705 void CurrentRouterCommand::RunGet()
706 {
707     Json2::Value resultContent = JsonReader::CreateObject();
708     std::string currentRouter = VirtualScreenImpl::GetInstance().GetCurrentRouter();
709     resultContent.Add("CurrentRouter", currentRouter.c_str());
710     SetResultToManager("args", resultContent, "CurrentJsRouter");
711     ILOG("Get CurrentRouter run finished.");
712 }
713 
LoadContentCommand(CommandType commandType,const Json2::Value & arg,const LocalSocket & socket)714 LoadContentCommand::LoadContentCommand(CommandType commandType, const Json2::Value& arg, const LocalSocket& socket)
715     : CommandLine(commandType, arg, socket)
716 {
717 }
718 
RunGet()719 void LoadContentCommand::RunGet()
720 {
721     Json2::Value resultContent = JsonReader::CreateObject();
722     std::string currentRouter = VirtualScreenImpl::GetInstance().GetAbilityCurrentRouter();
723     resultContent.Add("AbilityCurrentRouter", currentRouter.c_str());
724     SetResultToManager("args", resultContent, "AbilityCurrentJsRouter");
725     ILOG("Get AbilityCurrentRouter run finished.");
726 }
727 
LanguageCommand(CommandType commandType,const Json2::Value & arg,const LocalSocket & socket)728 LanguageCommand::LanguageCommand(CommandType commandType, const Json2::Value& arg, const LocalSocket& socket)
729     : CommandLine(commandType, arg, socket)
730 {
731 }
732 
IsSetArgValid() const733 bool LanguageCommand::IsSetArgValid() const
734 {
735     if (args.IsNull() || !args.IsMember("Language") || !args["Language"].IsString()) {
736         ELOG("Invalid number of arguments!");
737         return false;
738     }
739 
740     CommandParser& cmdParser = CommandParser::GetInstance();
741     string deviceType = cmdParser.GetDeviceType();
742     bool isLiteDevice = JsApp::IsLiteDevice(deviceType);
743     if (isLiteDevice) {
744         if (std::find(liteSupportedLanguages.begin(), liteSupportedLanguages.end(), args["Language"].AsString()) ==
745             liteSupportedLanguages.end()) {
746             ELOG("Language not support liteDevice : %s", args["Language"].AsString().c_str());
747             return false;
748         }
749     } else {
750         if (std::find(richSupportedLanguages.begin(), richSupportedLanguages.end(), args["Language"].AsString()) ==
751             richSupportedLanguages.end()) {
752             ELOG("Language not support richDevice : %s", args["Language"].AsString().c_str());
753             return false;
754         }
755     }
756     return true;
757 }
758 
RunGet()759 void LanguageCommand::RunGet()
760 {
761     std::string language = SharedData<string>::GetData(SharedDataType::LANGUAGE);
762     Json2::Value resultContent = JsonReader::CreateObject();
763     resultContent.Add("Language", language.c_str());
764     SetCommandResult("result", resultContent);
765     ILOG("Get language run finished.");
766 }
767 
RunSet()768 void LanguageCommand::RunSet()
769 {
770     string language(args["Language"].AsString());
771     SharedData<string>::SetData(SharedDataType::LANGUAGE, language);
772     SetCommandResult("result", JsonReader::CreateBool(true));
773     ILOG("Set language run finished, language is: %s", language.c_str());
774 }
775 
SupportedLanguagesCommand(CommandType commandType,const Json2::Value & arg,const LocalSocket & socket)776 SupportedLanguagesCommand::SupportedLanguagesCommand(CommandType commandType,
777                                                      const Json2::Value& arg,
778                                                      const LocalSocket& socket)
779     : CommandLine(commandType, arg, socket)
780 {
781 }
782 
RunGet()783 void SupportedLanguagesCommand::RunGet()
784 {
785     Json2::Value resultContent = JsonReader::CreateObject();
786     Json2::Value languageList = JsonReader::CreateArray();
787     string deviceType = CommandParser::GetInstance().GetDeviceType();
788     bool isLiteDevice = JsApp::IsLiteDevice(deviceType);
789     if (!deviceType.empty() && !isLiteDevice) {
790         for (auto iter = richSupportedLanguages.begin(); iter != richSupportedLanguages.end(); iter++) {
791             languageList.Add((*iter).c_str());
792         }
793     } else {
794         for (auto iter = liteSupportedLanguages.begin(); iter != liteSupportedLanguages.end(); iter++) {
795             languageList.Add((*iter).c_str());
796         }
797     }
798     resultContent.Add("SupportedLanguages", languageList);
799     SetCommandResult("result", resultContent);
800     ILOG("Get supportedLanguages run finished.");
801 }
802 
LocationCommand(CommandType commandType,const Json2::Value & arg,const LocalSocket & socket)803 LocationCommand::LocationCommand(CommandType commandType, const Json2::Value& arg, const LocalSocket& socket)
804     : CommandLine(commandType, arg, socket)
805 {
806 }
807 
IsSetArgValid() const808 bool LocationCommand::IsSetArgValid() const
809 {
810     if (args.IsNull() || !args.IsMember("latitude") || !args.IsMember("longitude")) {
811         ELOG("Invalid number of arguments!");
812         return false;
813     }
814     string latitude(args["latitude"].AsString());
815     string longitude(args["longitude"].AsString());
816     regex isDob("^([\\-]*[0-9]{1,}[\\.][0-9]*)$");
817     if (!regex_match(latitude, isDob) || !regex_match(longitude, isDob)) {
818         ELOG("Invalid arguments!");
819         return false;
820     }
821 
822     if (!SharedData<double>::IsValid(SharedDataType::LATITUDE, atof(latitude.data()))) {
823         ELOG("LocationCommand invalid latitude value: %f", atof(latitude.data()));
824         return false;
825     }
826 
827     if (!SharedData<double>::IsValid(SharedDataType::LONGITUDE, atof(longitude.data()))) {
828         ELOG("LocationCommand invalid longitude value: %f", atof(longitude.data()));
829         return false;
830     }
831     return true;
832 }
833 
RunGet()834 void LocationCommand::RunGet()
835 {
836     double longitude = SharedData<double>::GetData(SharedDataType::LONGITUDE);
837     double latitude = SharedData<double>::GetData(SharedDataType::LATITUDE);
838     Json2::Value resultContent = JsonReader::CreateObject();
839     resultContent.Add("latitude", latitude);
840     resultContent.Add("longitude", longitude);
841     SetCommandResult("result", resultContent);
842     ILOG("Get location run finished");
843 }
844 
RunSet()845 void LocationCommand::RunSet()
846 {
847     string latitude(args["latitude"].AsString());
848     string longitude(args["longitude"].AsString());
849     SharedData<double>::SetData(SharedDataType::LONGITUDE, atof(longitude.data()));
850     SharedData<double>::SetData(SharedDataType::LATITUDE, atof(latitude.data()));
851     Json2::Value resultContent = JsonReader::CreateBool(true);
852     SetCommandResult("result", resultContent);
853     ILOG("Set location run finished, latitude: %s,longitude: %s", latitude.c_str(), longitude.c_str());
854 }
855 
DistributedCommunicationsCommand(CommandType commandType,const Json2::Value & arg,const LocalSocket & socket)856 DistributedCommunicationsCommand::DistributedCommunicationsCommand(CommandType commandType,
857                                                                    const Json2::Value& arg,
858                                                                    const LocalSocket& socket)
859     : CommandLine(commandType, arg, socket)
860 {
861 }
862 
RunAction()863 void DistributedCommunicationsCommand::RunAction()
864 {
865     MessageInfo info;
866     info.deviceID = args["DeviceId"].AsString();
867     info.bundleName = args["bundleName"].AsString();
868     info.abilityName = args["abilityName"].AsString();
869     info.message = args["message"].AsString();
870     VirtualMessageImpl::GetInstance().SendVirtualMessage(info);
871     Json2::Value resultContent = JsonReader::CreateBool(true);
872     SetCommandResult("result", resultContent);
873     ILOG("Send distributedCommunications run finished");
874 }
875 
IsActionArgValid() const876 bool DistributedCommunicationsCommand::IsActionArgValid() const
877 {
878     if (args.IsNull() || !args.IsMember("DeviceId") || !args.IsMember("bundleName") || !args.IsMember("abilityName") ||
879         !args.IsMember("message")) {
880         ELOG("Invalid number of arguments!");
881         return false;
882     }
883     if (args["DeviceId"].AsString().empty() || args["bundleName"].AsString().empty() ||
884         args["abilityName"].AsString().empty() || args["message"].AsString().empty()) {
885         ELOG("Invalid arguments!");
886         return false;
887     }
888     return true;
889 }
890 
StringToCharVector(string str) const891 std::vector<char> DistributedCommunicationsCommand::StringToCharVector(string str) const
892 {
893     vector<char> vec(str.begin(), str.end());
894     vec.push_back('\0');
895     return vec;
896 }
897 
KeepScreenOnStateCommand(CommandType commandType,const Json2::Value & arg,const LocalSocket & socket)898 KeepScreenOnStateCommand::KeepScreenOnStateCommand(CommandType commandType,
899                                                    const Json2::Value& arg,
900                                                    const LocalSocket& socket)
901     : CommandLine(commandType, arg, socket)
902 {
903 }
904 
RunGet()905 void KeepScreenOnStateCommand::RunGet()
906 {
907     Json2::Value result = JsonReader::CreateObject();
908     result.Add("KeepScreenOnState", SharedData<bool>::GetData(SharedDataType::KEEP_SCREEN_ON));
909     SetCommandResult("result", result);
910     ILOG("Get keepScreenOnState run finished");
911 }
912 
RunSet()913 void KeepScreenOnStateCommand::RunSet()
914 {
915     SharedData<bool>::SetData(SharedDataType::KEEP_SCREEN_ON, args["KeepScreenOnState"].AsBool());
916     SetCommandResult("result", JsonReader::CreateBool(true));
917     ILOG("Set keepScreenOnState run finished, the value is: %s",
918         args["KeepScreenOnState"].AsBool() ? "true" : "false");
919 }
920 
IsSetArgValid() const921 bool KeepScreenOnStateCommand::IsSetArgValid() const
922 {
923     if (args.IsNull() || !args.IsMember("KeepScreenOnState")) {
924         ELOG("Invalid number of arguments!");
925         return false;
926     }
927     if (!args["KeepScreenOnState"].IsBool()) {
928         ELOG("arg KeepScreenOnState id not bool");
929         return false;
930     }
931     return true;
932 }
933 
WearingStateCommand(CommandType commandType,const Json2::Value & arg,const LocalSocket & socket)934 WearingStateCommand::WearingStateCommand(CommandType commandType, const Json2::Value& arg, const LocalSocket& socket)
935     : CommandLine(commandType, arg, socket)
936 {
937 }
938 
RunGet()939 void WearingStateCommand::RunGet()
940 {
941     Json2::Value result = JsonReader::CreateObject();
942     result.Add("WearingState", SharedData<bool>::GetData(SharedDataType::WEARING_STATE));
943     SetCommandResult("result", result);
944     ILOG("Get wearingState run finished");
945 }
946 
RunSet()947 void WearingStateCommand::RunSet()
948 {
949     SharedData<bool>::SetData(SharedDataType::WEARING_STATE, args["WearingState"].AsBool());
950     SetCommandResult("result", JsonReader::CreateBool(true));
951     ILOG("Set wearingState run finished, the value is: %s", args["WearingState"].AsBool() ? "true" : "false");
952 }
953 
IsSetArgValid() const954 bool WearingStateCommand::IsSetArgValid() const
955 {
956     if (args.IsNull() || !args.IsMember("WearingState")) {
957         ELOG("Invalid number of arguments!");
958         return false;
959     }
960     if (!args["WearingState"].IsBool()) {
961         ILOG("arg WearingState is not bool");
962         return false;
963     }
964     return true;
965 }
966 
BrightnessModeCommand(CommandType commandType,const Json2::Value & arg,const LocalSocket & socket)967 BrightnessModeCommand::BrightnessModeCommand(CommandType commandType, const Json2::Value& arg,
968     const LocalSocket& socket) : CommandLine(commandType, arg, socket)
969 {
970 }
971 
RunGet()972 void BrightnessModeCommand::RunGet()
973 {
974     Json2::Value result = JsonReader::CreateObject();
975     result.Add("BrightnessMode", SharedData<uint8_t>::GetData(SharedDataType::BRIGHTNESS_MODE));
976     SetCommandResult("result", result);
977     ILOG("Get brightnessMode run finished");
978 }
979 
RunSet()980 void BrightnessModeCommand::RunSet()
981 {
982     SharedData<uint8_t>::SetData(SharedDataType::BRIGHTNESS_MODE,
983                                  static_cast<uint8_t>(args["BrightnessMode"].AsInt()));
984     SetCommandResult("result", JsonReader::CreateBool(true));
985     ILOG("Set brightnessMode run finished, the value is: %d", args["BrightnessMode"].AsInt());
986 }
987 
IsSetArgValid() const988 bool BrightnessModeCommand::IsSetArgValid() const
989 {
990     if (args.IsNull() || !args.IsMember("BrightnessMode")) {
991         ELOG("Invalid number of arguments!");
992         return false;
993     }
994     if (!args["BrightnessMode"].IsInt()) {
995         ELOG("BrightnessMode is not int");
996         return false;
997     }
998     uint8_t temp = static_cast<uint8_t>(args["BrightnessMode"].AsInt());
999     if (!SharedData<uint8_t>::IsValid(SharedDataType::BRIGHTNESS_MODE, temp)) {
1000         ELOG("BrightnessModeCommand invalid value: %d", temp);
1001         return false;
1002     }
1003     return true;
1004 }
1005 
ChargeModeCommand(CommandType commandType,const Json2::Value & arg,const LocalSocket & socket)1006 ChargeModeCommand::ChargeModeCommand(CommandType commandType, const Json2::Value& arg, const LocalSocket& socket)
1007     : CommandLine(commandType, arg, socket)
1008 {
1009 }
1010 
RunGet()1011 void ChargeModeCommand::RunGet()
1012 {
1013     Json2::Value result = JsonReader::CreateObject();
1014     result.Add("ChargeMode", SharedData<uint8_t>::GetData(SharedDataType::BATTERY_STATUS));
1015     SetCommandResult("result", result);
1016     ILOG("Get chargeMode run finished");
1017 }
1018 
RunSet()1019 void ChargeModeCommand::RunSet()
1020 {
1021     SharedData<uint8_t>::SetData(SharedDataType::BATTERY_STATUS,
1022                                  static_cast<uint8_t>(args["ChargeMode"].AsInt()));
1023     SetCommandResult("result", JsonReader::CreateBool(true));
1024     ILOG("Set chargeMode run finished, the value is: %d", args["ChargeMode"].AsInt());
1025 }
1026 
IsSetArgValid() const1027 bool ChargeModeCommand::IsSetArgValid() const
1028 {
1029     if (args.IsNull() || !args.IsMember("ChargeMode")) {
1030         ELOG("Invalid number of arguments!");
1031         return false;
1032     }
1033     if (!args["ChargeMode"].IsInt()) {
1034         ELOG("ChargeMode is not int");
1035         return false;
1036     }
1037     uint8_t temp = static_cast<uint8_t>(args["ChargeMode"].AsInt());
1038     if (!SharedData<uint8_t>::IsValid(SharedDataType::BATTERY_STATUS, temp)) {
1039         ELOG("ChargeModeCommand invalid value: %d", temp);
1040         return false;
1041     }
1042     return true;
1043 }
1044 
BrightnessCommand(CommandType commandType,const Json2::Value & arg,const LocalSocket & socket)1045 BrightnessCommand::BrightnessCommand(CommandType commandType, const Json2::Value& arg, const LocalSocket& socket)
1046     : CommandLine(commandType, arg, socket)
1047 {
1048 }
1049 
RunGet()1050 void BrightnessCommand::RunGet()
1051 {
1052     Json2::Value result = JsonReader::CreateObject();
1053     result.Add("Brightness", SharedData<uint8_t>::GetData(SharedDataType::BRIGHTNESS_VALUE));
1054     SetCommandResult("result", result);
1055     ILOG("Get brightness run finished");
1056 }
1057 
RunSet()1058 void BrightnessCommand::RunSet()
1059 {
1060     SharedData<uint8_t>::SetData(SharedDataType::BRIGHTNESS_VALUE,
1061                                  static_cast<uint8_t>(args["Brightness"].AsInt()));
1062     Json2::Value result = JsonReader::CreateBool(true);
1063     SetCommandResult("result", result);
1064     ILOG("Set brightness run finished, the value is: %d", args["Brightness"].AsInt());
1065 }
1066 
IsSetArgValid() const1067 bool BrightnessCommand::IsSetArgValid() const
1068 {
1069     if (args.IsNull() || !args.IsMember("Brightness")) {
1070         ELOG("Invalid number of arguments!");
1071         return false;
1072     }
1073     if (!args["Brightness"].IsInt()) {
1074         ELOG("Brightness is not int");
1075         return false;
1076     }
1077     uint8_t temp = static_cast<uint8_t>(args["Brightness"].AsInt());
1078     if (!SharedData<uint8_t>::IsValid(SharedDataType::BRIGHTNESS_VALUE, temp)) {
1079         ELOG("BrightnessCommand invalid value: ", temp);
1080         return false;
1081     }
1082     return true;
1083 }
1084 
HeartRateCommand(CommandType commandType,const Json2::Value & arg,const LocalSocket & socket)1085 HeartRateCommand::HeartRateCommand(CommandType commandType, const Json2::Value& arg, const LocalSocket& socket)
1086     : CommandLine(commandType, arg, socket)
1087 {
1088 }
1089 
RunGet()1090 void HeartRateCommand::RunGet()
1091 {
1092     Json2::Value result = JsonReader::CreateObject();
1093     result.Add("HeartRate", SharedData<uint8_t>::GetData(SharedDataType::HEARTBEAT_VALUE));
1094     SetCommandResult("result", result);
1095     ILOG("Get heartRate run finished");
1096 }
1097 
RunSet()1098 void HeartRateCommand::RunSet()
1099 {
1100     SharedData<uint8_t>::SetData(SharedDataType::HEARTBEAT_VALUE,
1101                                  static_cast<uint8_t>(args["HeartRate"].AsInt()));
1102     SetCommandResult("result", JsonReader::CreateBool(true));
1103     ILOG("Set heartRate run finished, the value is: %d", args["HeartRate"].AsInt());
1104 }
1105 
IsSetArgValid() const1106 bool HeartRateCommand::IsSetArgValid() const
1107 {
1108     if (args.IsNull() || !args.IsMember("HeartRate")) {
1109         ELOG("Invalid number of arguments!");
1110         return false;
1111     }
1112     if (!args["HeartRate"].IsInt()) {
1113         ELOG("HeartRate is not int");
1114         return false;
1115     }
1116     if (args["HeartRate"].AsInt() > UINT8_MAX) {
1117         ELOG("Invalid arguments!");
1118         return false;
1119     }
1120     uint8_t temp = static_cast<uint8_t>(args["HeartRate"].AsInt());
1121     if (!SharedData<uint8_t>::IsValid(SharedDataType::HEARTBEAT_VALUE, temp)) {
1122         ELOG("HeartRateCommand invalid value: %d", temp);
1123         return false;
1124     }
1125     return true;
1126 }
1127 
StepCountCommand(CommandType commandType,const Json2::Value & arg,const LocalSocket & socket)1128 StepCountCommand::StepCountCommand(CommandType commandType, const Json2::Value& arg, const LocalSocket& socket)
1129     : CommandLine(commandType, arg, socket)
1130 {
1131 }
1132 
RunGet()1133 void StepCountCommand::RunGet()
1134 {
1135     Json2::Value result = JsonReader::CreateObject();
1136     result.Add("StepCount", SharedData<uint32_t>::GetData(SharedDataType::SUMSTEP_VALUE));
1137     SetCommandResult("result", result);
1138     ILOG("Get stepCount run finished");
1139 }
1140 
RunSet()1141 void StepCountCommand::RunSet()
1142 {
1143     SharedData<uint32_t>::SetData(SharedDataType::SUMSTEP_VALUE,
1144                                   static_cast<uint32_t>(args["StepCount"].AsInt()));
1145     SetCommandResult("result", JsonReader::CreateBool(true));
1146     ILOG("Set stepCount run finished, the value is: %d", args["StepCount"].AsInt());
1147 }
1148 
IsSetArgValid() const1149 bool StepCountCommand::IsSetArgValid() const
1150 {
1151     if (args.IsNull() || !args.IsMember("StepCount")) {
1152         ELOG("Invalid number of arguments!");
1153         return false;
1154     }
1155     if (!args["StepCount"].IsInt()) {
1156         ELOG("StepCount is not int");
1157         return false;
1158     }
1159 
1160     uint32_t temp = args["StepCount"].AsUInt();
1161     if (!SharedData<uint32_t>::IsValid(SharedDataType::SUMSTEP_VALUE, temp)) {
1162         ELOG("StepCountCommand invalid value: %d", temp);
1163         return false;
1164     }
1165     return true;
1166 }
1167 
InspectorJSONTree(CommandType commandType,const Json2::Value & arg,const LocalSocket & socket)1168 InspectorJSONTree::InspectorJSONTree(CommandType commandType, const Json2::Value& arg, const LocalSocket& socket)
1169     : CommandLine(commandType, arg, socket)
1170 {
1171 }
1172 
RunAction()1173 void InspectorJSONTree::RunAction()
1174 {
1175     ILOG("GetJsonTree run!");
1176     std::string str = JsAppImpl::GetInstance().GetJSONTree();
1177     if (str == "null") {
1178         str = "{\"children\":\"empty json tree\"}";
1179     }
1180     SetCommandResult("result", JsonReader::CreateString(str));
1181     ILOG("SendJsonTree end!");
1182 }
1183 
InspectorDefault(CommandType commandType,const Json2::Value & arg,const LocalSocket & socket)1184 InspectorDefault::InspectorDefault(CommandType commandType, const Json2::Value& arg, const LocalSocket& socket)
1185     : CommandLine(commandType, arg, socket)
1186 {
1187 }
1188 
RunAction()1189 void InspectorDefault::RunAction()
1190 {
1191     ILOG("GetDefaultJsonTree run!");
1192     std::string str = JsAppImpl::GetInstance().GetDefaultJSONTree();
1193     SetCommandResult("result", JsonReader::CreateString(str));
1194     ILOG("SendDefaultJsonTree end!");
1195 }
1196 
ExitCommand(CommandType commandType,const Json2::Value & arg,const LocalSocket & socket)1197 ExitCommand::ExitCommand(CommandType commandType, const Json2::Value& arg, const LocalSocket& socket)
1198     : CommandLine(commandType, arg, socket)
1199 {
1200 }
1201 
RunAction()1202 void ExitCommand::RunAction()
1203 {
1204     ILOG("ExitCommand run.");
1205     SetCommandResult("result", JsonReader::CreateBool(true));
1206     SendResult();
1207     Interrupter::Interrupt();
1208     ILOG("Ready to exit");
1209 }
1210 
DeviceTypeCommand(CommandLine::CommandType commandType,const Json2::Value & arg,const LocalSocket & socket)1211 DeviceTypeCommand::DeviceTypeCommand(CommandLine::CommandType commandType,
1212                                      const Json2::Value& arg,
1213                                      const LocalSocket& socket)
1214     : CommandLine(commandType, arg, socket)
1215 {
1216 }
1217 
RunSet()1218 void DeviceTypeCommand::RunSet() {}
1219 
ResolutionCommand(CommandLine::CommandType commandType,const Json2::Value & arg,const LocalSocket & socket)1220 ResolutionCommand::ResolutionCommand(CommandLine::CommandType commandType,
1221                                      const Json2::Value& arg,
1222                                      const LocalSocket& socket)
1223     : CommandLine(commandType, arg, socket)
1224 {
1225 }
1226 
RunSet()1227 void ResolutionCommand::RunSet() {}
1228 
BackClickedCommand(CommandLine::CommandType commandType,const Json2::Value & arg,const LocalSocket & socket)1229 BackClickedCommand::BackClickedCommand(CommandLine::CommandType commandType,
1230                                        const Json2::Value& arg,
1231                                        const LocalSocket& socket)
1232     : CommandLine(commandType, arg, socket)
1233 {
1234 }
1235 
RunAction()1236 void BackClickedCommand::RunAction()
1237 {
1238     MouseInputImpl::GetInstance().DispatchOsBackEvent();
1239     ILOG("BackClickCommand run");
1240     SetCommandResult("result", JsonReader::CreateBool(true));
1241     ILOG("BackClickCommand end");
1242 }
1243 
RestartCommand(CommandLine::CommandType commandType,const Json2::Value & arg,const LocalSocket & socket)1244 RestartCommand::RestartCommand(CommandLine::CommandType commandType, const Json2::Value& arg, const LocalSocket& socket)
1245     : CommandLine(commandType, arg, socket)
1246 {
1247 }
1248 
RunAction()1249 void RestartCommand::RunAction()
1250 {
1251     ILOG("RestartCommand start");
1252     JsAppImpl::GetInstance().Restart();
1253     SetCommandResult("result", JsonReader::CreateBool(true));
1254     ILOG("RestartCommand end");
1255 }
1256 
FastPreviewMsgCommand(CommandType commandType,const Json2::Value & arg,const LocalSocket & socket)1257 FastPreviewMsgCommand::FastPreviewMsgCommand(CommandType commandType, const Json2::Value& arg,
1258     const LocalSocket& socket) : CommandLine(commandType, arg, socket)
1259 {
1260 }
1261 
RunGet()1262 void FastPreviewMsgCommand::RunGet()
1263 {
1264     Json2::Value resultContent = JsonReader::CreateObject();
1265     std::string fastPreviewMsg = VirtualScreenImpl::GetInstance().GetFastPreviewMsg();
1266     resultContent.Add("FastPreviewMsg", fastPreviewMsg.c_str());
1267     SetResultToManager("args", resultContent, "MemoryRefresh");
1268     ILOG("Get FastPreviewMsgCommand run finished.");
1269 }
1270 
DropFrameCommand(CommandType commandType,const Json2::Value & arg,const LocalSocket & socket)1271 DropFrameCommand::DropFrameCommand(CommandType commandType, const Json2::Value& arg, const LocalSocket& socket)
1272     : CommandLine(commandType, arg, socket)
1273 {
1274 }
1275 
IsSetArgValid() const1276 bool DropFrameCommand::IsSetArgValid() const
1277 {
1278     if (args.IsNull() || !args.IsMember("frequency") || !args["frequency"].IsInt()) {
1279         ELOG("Invalid DropFrame of arguments!");
1280         return false;
1281     }
1282     if (args["frequency"].AsInt() < 0) {
1283         ELOG("DropFrame param frequency must greater than or equal to 0");
1284         return false;
1285     }
1286     return true;
1287 }
1288 
RunSet()1289 void DropFrameCommand::RunSet()
1290 {
1291     ILOG("Set DropFrame frequency start.");
1292     int frequency = args["frequency"].AsInt();
1293     VirtualScreenImpl::GetInstance().SetDropFrameFrequency(frequency);
1294     SetCommandResult("result", JsonReader::CreateBool(true));
1295     ILOG("Set DropFrame frequency: %dms.", frequency);
1296 }
1297 
IsActionArgValid() const1298 bool KeyPressCommand::IsActionArgValid() const
1299 {
1300     if (args.IsNull() || !args.IsMember("isInputMethod") || !args["isInputMethod"].IsBool()) {
1301         ELOG("Param isInputMethod's value is invalid.");
1302         return false;
1303     }
1304     bool isInputMethod = args["isInputMethod"].AsBool();
1305     if (isInputMethod) {
1306         return IsImeArgsValid();
1307     } else {
1308         return IsKeyArgsValid();
1309     }
1310 }
1311 
IsImeArgsValid() const1312 bool KeyPressCommand::IsImeArgsValid() const
1313 {
1314     if (!args.IsMember("codePoint") || !args["codePoint"].IsInt()) {
1315         ELOG("Param codePoint's value is invalid.");
1316         return false;
1317     }
1318     return true;
1319 }
1320 
IsKeyArgsValid() const1321 bool KeyPressCommand::IsKeyArgsValid() const
1322 {
1323     if (!args.IsMember("keyCode") || !args["keyCode"].IsInt() || !args["keyAction"].IsInt() ||
1324         !args.IsMember("keyAction") || !args["keyAction"].IsInt() ||
1325         !args.IsMember("pressedCodes") || !args["pressedCodes"].IsArray() ||
1326         args["pressedCodes"].GetArraySize() < 1 || (args.IsMember("keyString") && !args["keyString"].IsString())) {
1327         ELOG("Param keyEvent's value is invalid.");
1328         return false;
1329     }
1330     if (!args.IsMember("keyString")) {
1331         ILOG("Param keyString is lost, it will be empty string.");
1332     }
1333     if (args["keyAction"].AsInt() < minActionVal || args["keyAction"].AsInt() > maxActionVal) {
1334         ELOG("Param keyAction's value is invalid,value range %d-%d.", minActionVal, maxActionVal);
1335         return false;
1336     }
1337     int keyCode = args["keyCode"].AsInt();
1338     if (keyCode > maxKeyVal || keyCode < minKeyVal) {
1339         ELOG("Param pressedCode value is invalid,value range %d-%d.", minKeyVal, maxKeyVal);
1340         return false;
1341     }
1342     Json2::Value arrayNum = args["pressedCodes"];
1343     for (unsigned int i = 0; i < arrayNum.GetArraySize(); i++) {
1344         if (!arrayNum.GetArrayItem(i).IsInt()) {
1345             ELOG("Param pressedCodes's value is invalid.");
1346             return false;
1347         }
1348         int pressedCode = arrayNum.GetArrayItem(i).AsInt();
1349         if (pressedCode > maxKeyVal || pressedCode < minKeyVal) {
1350             ELOG("Param pressedCode value is invalid,value range %d-%d.", minKeyVal, maxKeyVal);
1351             return false;
1352         }
1353     }
1354     return true;
1355 }
1356 
KeyPressCommand(CommandType commandType,const Json2::Value & arg,const LocalSocket & socket)1357 KeyPressCommand::KeyPressCommand(CommandType commandType, const Json2::Value& arg,
1358                                  const LocalSocket& socket)
1359     : CommandLine(commandType, arg, socket)
1360 {
1361 }
1362 
RunAction()1363 void KeyPressCommand::RunAction()
1364 {
1365     if (CommandParser::GetInstance().GetScreenMode() == CommandParser::ScreenMode::STATIC) {
1366         return;
1367     }
1368     bool isInputMethod = args["isInputMethod"].AsBool();
1369     if (isInputMethod) {
1370         VirtualScreen::inputMethodCountPerMinute++;
1371         unsigned int codePoint = args["codePoint"].AsInt();
1372         KeyInputImpl::GetInstance().SetCodePoint(codePoint);
1373         KeyInputImpl::GetInstance().DispatchOsInputMethodEvent();
1374     } else {
1375         VirtualScreen::inputKeyCountPerMinute++;
1376         int32_t keyCode = args["keyCode"].AsInt();
1377         int32_t keyAction = args["keyAction"].AsInt();
1378         Json2::Value pressedCodes = args["pressedCodes"];
1379         vector<int32_t> pressedCodesVec;
1380         for (unsigned int i = 0; i < pressedCodes.GetArraySize(); i++) {
1381             pressedCodesVec.push_back(pressedCodes.GetArrayItem(i).AsInt());
1382         }
1383         string keyString = "";
1384         if (args.IsMember("keyString") && args["keyString"].IsString()) {
1385             keyString = args["keyString"].AsString();
1386         }
1387         KeyInputImpl::GetInstance().SetKeyEvent(keyCode, keyAction, pressedCodesVec, keyString);
1388         KeyInputImpl::GetInstance().DispatchOsKeyEvent();
1389     }
1390     SetCommandResult("result", JsonReader::CreateBool(true));
1391     ILOG("KeyPressCommand run finished.");
1392 }
1393 
IsActionArgValid() const1394 bool PointEventCommand::IsActionArgValid() const
1395 {
1396     return IsArgsExist() && IsArgsValid();
1397 }
1398 
IsArgsExist() const1399 bool PointEventCommand::IsArgsExist() const
1400 {
1401     if (args.IsNull() || !args.IsMember("x") || !args.IsMember("y") ||
1402         !args["x"].IsInt() || !args["y"].IsInt()) {
1403         return false;
1404     }
1405     if (!args.IsMember("button") || !args.IsMember("action") ||
1406         !args["button"].IsInt() || !args["action"].IsInt()) {
1407         return false;
1408     }
1409     if (!args.IsMember("sourceType") || !args.IsMember("sourceTool") ||
1410         !args["sourceType"].IsInt() || !args["sourceTool"].IsInt()) {
1411         return false;
1412     }
1413     if (!args.IsMember("axisValues") || !args["axisValues"].IsArray()) {
1414         return false;
1415     }
1416     return true;
1417 }
1418 
IsArgsValid() const1419 bool PointEventCommand::IsArgsValid() const
1420 {
1421     int32_t pointX = args["x"].AsInt();
1422     int32_t pointY = args["y"].AsInt();
1423     int32_t button = args["button"].AsInt();
1424     int32_t action = args["action"].AsInt();
1425     int32_t sourceType = args["sourceType"].AsInt();
1426     int32_t sourceTool = args["sourceTool"].AsInt();
1427     if (pointX < 0 || pointX > VirtualScreenImpl::GetInstance().GetCurrentWidth()) {
1428         ELOG("X coordinate range %d ~ %d", 0, VirtualScreenImpl::GetInstance().GetCurrentWidth());
1429         return false;
1430     }
1431     if (pointY < 0 || pointY > VirtualScreenImpl::GetInstance().GetCurrentHeight()) {
1432         ELOG("Y coordinate range %d ~ %d", 0, VirtualScreenImpl::GetInstance().GetCurrentHeight());
1433         return false;
1434     }
1435     if (button < -1 || action < 0 || sourceType < 0 || sourceTool < 0) {
1436         ELOG("action,sourceType,sourceTool must >= 0, button must >= -1");
1437         return false;
1438     }
1439     Json2::Value axisArrayNum = args["axisValues"];
1440     for (unsigned int i = 0; i < axisArrayNum.GetArraySize(); i++) {
1441         if (!axisArrayNum.GetArrayItem(i).IsDouble()) {
1442             ELOG("Param axisValues's value is invalid.");
1443             return false;
1444         }
1445     }
1446     return true;
1447 }
1448 
PointEventCommand(CommandType commandType,const Json2::Value & arg,const LocalSocket & socket)1449 PointEventCommand::PointEventCommand(CommandType commandType, const Json2::Value& arg, const LocalSocket& socket)
1450     : CommandLine(commandType, arg, socket)
1451 {
1452 }
1453 
RunAction()1454 void PointEventCommand::RunAction()
1455 {
1456     int type = 9;
1457     EventParams param;
1458     if (args.IsMember("pressedButtons") && args["pressedButtons"].IsArray()) {
1459         Json2::Value pressedCodes = args["pressedButtons"];
1460         for (unsigned int i = 0; i < pressedCodes.GetArraySize(); i++) {
1461             Json2::Value val = pressedCodes.GetArrayItem(i);
1462             if (!val.IsInt() || val.AsInt() < -1) {
1463                 continue;
1464             }
1465             param.pressedBtnsVec.insert(val.AsInt());
1466         }
1467     }
1468     vector<double> axisVec; // 13 is array size
1469     Json2::Value axisCodes = args["axisValues"];
1470     for (unsigned int i = 0; i < axisCodes.GetArraySize(); i++) {
1471         param.axisVec.push_back(axisCodes.GetArrayItem(i).AsDouble());
1472     }
1473     param.x = args["x"].AsDouble();
1474     param.y = args["y"].AsDouble();
1475     param.type = type;
1476     param.button = args["button"].AsInt();
1477     param.action = args["action"].AsInt();
1478     param.sourceType = args["sourceType"].AsInt();
1479     param.sourceTool = args["sourceTool"].AsInt();
1480     param.name = "PointEvent";
1481     SetEventParams(param);
1482     SetCommandResult("result", JsonReader::CreateBool(true));
1483 }
1484 
FoldStatusCommand(CommandType commandType,const Json2::Value & arg,const LocalSocket & socket)1485 FoldStatusCommand::FoldStatusCommand(CommandType commandType, const Json2::Value& arg, const LocalSocket& socket)
1486     : CommandLine(commandType, arg, socket)
1487 {
1488 }
1489 
IsSetArgValid() const1490 bool FoldStatusCommand::IsSetArgValid() const
1491 {
1492     if (args.IsNull() || !args.IsMember("FoldStatus") || !args["FoldStatus"].IsString()) {
1493         ELOG("Invalid FoldStatus of arguments!");
1494         return false;
1495     }
1496     if (!args.IsMember("width") || !args["width"].IsInt() ||
1497         !args.IsMember("height") || !args["height"].IsInt()) {
1498         ELOG("Invalid width and height of arguments!");
1499         return false;
1500     }
1501     if (args["width"].AsInt() < minWidth || args["width"].AsInt() > maxWidth ||
1502         args["height"].AsInt() < minWidth || args["height"].AsInt() > maxWidth) {
1503         ELOG("width or height is out of range %d-%d", minWidth, maxWidth);
1504         return false;
1505     }
1506     if (args["FoldStatus"].AsString() == "fold" || args["FoldStatus"].AsString() == "unfold" ||
1507         args["FoldStatus"].AsString() == "unknown" || args["FoldStatus"].AsString() == "half_fold") {
1508         return true;
1509     }
1510     ELOG("FoldStatus param must be \"fold\" or \"unfold\" or \"unknown\" or \"half_fold\"");
1511     return false;
1512 }
1513 
RunSet()1514 void FoldStatusCommand::RunSet()
1515 {
1516     std::string commandStatus = args["FoldStatus"].AsString();
1517     int32_t width = args["width"].AsInt();
1518     int32_t height = args["height"].AsInt();
1519     std::string currentStatus = VirtualScreenImpl::GetInstance().GetFoldStatus();
1520     if (commandStatus != currentStatus) {
1521         JsAppImpl::GetInstance().FoldStatusChanged(commandStatus, width, height);
1522     }
1523     SetCommandResult("result", JsonReader::CreateBool(true));
1524     ILOG("Set FoldStatus run finished, FoldStatus is: %s", args["FoldStatus"].AsString().c_str());
1525 }
1526 
AvoidAreaCommand(CommandType commandType,const Json2::Value & arg,const LocalSocket & socket)1527 AvoidAreaCommand::AvoidAreaCommand(CommandType commandType, const Json2::Value& arg,
1528     const LocalSocket& socket) : CommandLine(commandType, arg, socket)
1529 {
1530 }
1531 
IsSetArgValid() const1532 bool AvoidAreaCommand::IsSetArgValid() const
1533 {
1534     if (args.IsNull() || !args.IsMember("topRect") || !args.IsMember("bottomRect") ||
1535         !args.IsMember("leftRect") || !args.IsMember("rightRect")) {
1536         ELOG("AvoidAreaCommand missing arguments!");
1537         return false;
1538     }
1539     if (!args["topRect"].IsObject() || !args["bottomRect"].IsObject() || !args["leftRect"].IsObject()
1540         || !args["rightRect"].IsObject()) {
1541         ELOG("Invalid values of arguments!");
1542         return false;
1543     }
1544     Json2::Value topRect = args.GetValue("topRect");
1545     Json2::Value bottomRect = args.GetValue("bottomRect");
1546     Json2::Value leftRect = args.GetValue("leftRect");
1547     Json2::Value rightRect = args.GetValue("rightRect");
1548     if (!IsObjectValid(topRect) || !IsObjectValid(bottomRect) ||
1549         !IsObjectValid(leftRect) || !IsObjectValid(rightRect)) {
1550         ELOG("Invalid values of arguments!");
1551         return false;
1552     }
1553     return true;
1554 }
1555 
IsObjectValid(const Json2::Value & val) const1556 bool AvoidAreaCommand::IsObjectValid(const Json2::Value& val) const
1557 {
1558     if (val.IsNull() || !val.IsMember("posX") || !val["posY"].IsInt() ||
1559         !val.IsMember("width") || !val.IsMember("height")) {
1560         ELOG("AvoidAreaCommand missing arguments!");
1561         return false;
1562     }
1563     if (!val["posX"].IsInt() || !val["posY"].IsInt() || !val["width"].IsUInt()
1564         || !val["height"].IsUInt()) {
1565         ELOG("Invalid values of arguments!");
1566         return false;
1567     }
1568     if (val["posX"].AsInt() < 0 || val["posY"].AsInt() < 0 ||
1569         val["width"].AsUInt() < 0 || val["height"].AsUInt() < 0) {
1570         ELOG("Invalid values of arguments!");
1571         return false;
1572     }
1573     return true;
1574 }
1575 
RunSet()1576 void AvoidAreaCommand::RunSet()
1577 {
1578     Json2::Value topRectObj = args.GetValue("topRect");
1579     AvoidRect topRect = AvoidRect(topRectObj["posX"].AsInt(), topRectObj["posY"].AsInt(),
1580         topRectObj["width"].AsUInt(), topRectObj["height"].AsUInt());
1581     Json2::Value bottomRectObj = args.GetValue("bottomRect");
1582     AvoidRect bottomRect = AvoidRect(bottomRectObj["posX"].AsInt(), bottomRectObj["posY"].AsInt(),
1583         bottomRectObj["width"].AsUInt(), bottomRectObj["height"].AsUInt());
1584     Json2::Value leftRectObj = args.GetValue("leftRect");
1585     AvoidRect leftRect = AvoidRect(leftRectObj["posX"].AsInt(), leftRectObj["posY"].AsInt(),
1586         leftRectObj["width"].AsUInt(), leftRectObj["height"].AsUInt());
1587     Json2::Value rightRectObj = args.GetValue("rightRect");
1588     AvoidRect rightRect = AvoidRect(rightRectObj["posX"].AsInt(), rightRectObj["posY"].AsInt(),
1589         rightRectObj["width"].AsUInt(), rightRectObj["height"].AsUInt());
1590     JsAppImpl::GetInstance().SetAvoidArea(AvoidAreas(topRect, leftRect, rightRect, bottomRect));
1591     SetCommandResult("result", JsonReader::CreateBool(true));
1592     ILOG("Set AvoidArea run finished");
1593 }
1594 
AvoidAreaChangedCommand(CommandType commandType,const Json2::Value & arg,const LocalSocket & socket)1595 AvoidAreaChangedCommand::AvoidAreaChangedCommand(CommandType commandType, const Json2::Value& arg,
1596     const LocalSocket& socket) : CommandLine(commandType, arg, socket)
1597 {
1598 }
1599 
RunGet()1600 void AvoidAreaChangedCommand::RunGet()
1601 {
1602     SetResultToManager("args", args, "AvoidAreaChanged");
1603     ILOG("Get AvoidAreaChangedCommand run finished.");
1604 }