!100 添加鼠标事件

Merge pull request !100 from fupengfei/master

cli/CommandLine.cpp

@@ -17,6 +17,7 @@
 
 #include <algorithm>
 #include <regex>
+#include <sstream>
 
 #include "CommandLineInterface.h"
 #include "CommandParser.h"
@@ -51,11 +52,11 @@ CommandLine::~CommandLine()
 void CommandLine::CheckAndRun()
 {
     if (!IsArgValid()) {
+        ELOG("CheckAndRun: invalid command params");
         SetCommandResult("result", false);
         SendResult();
         return;
     }
-
     Run();
     SendResult();
 }
@@ -159,6 +160,31 @@ bool CommandLine::IsOneDigitFloatType(string arg) const
     return regex_match(arg, isFloat);
 }
 
+void TouchAndMouseCommand::SetEventParams(EventParams& params)
+{
+    if (CommandParser::GetInstance().GetScreenMode() == CommandParser::ScreenMode::STATIC) {
+        return;
+    }
+    MouseInputImpl::GetInstance().SetMousePosition(params.x, params.y);
+    MouseInputImpl::GetInstance().SetMouseStatus(params.type);
+    MouseInputImpl::GetInstance().SetMouseButton(params.button);
+    MouseInputImpl::GetInstance().SetMouseAction(params.action);
+    MouseInputImpl::GetInstance().SetSourceType(params.sourceType);
+    MouseInputImpl::GetInstance().SetSourceTool(params.sourceTool);
+    MouseInputImpl::GetInstance().SetPressedBtns(params.pressedBtnsVec);
+    MouseInputImpl::GetInstance().SetAxisValues(params.axisVec);
+    MouseInputImpl::GetInstance().DispatchOsTouchEvent();
+    std::stringstream ss;
+    ss << "[";
+    for (double val : params.axisVec) {
+        ss << " " << val << " ";
+    }
+    ss << "]" << std::endl;
+    ILOG("%s(%f,%f,%d,%d,%d,%d,%d,%d,%d,%s)", params.name.c_str(), params.x, params.y, params.type, params.button,
+        params.action, params.sourceType, params.sourceTool, params.pressedBtnsVec.size(), params.axisVec.size(),
+        ss.str().c_str());
+}
+
 bool TouchPressCommand::IsActionArgValid() const
 {
     if (args.isNull() || !args.isMember("x") || !args.isMember("y") ||
@@ -185,15 +211,18 @@ TouchPressCommand::TouchPressCommand(CommandType commandType, const Json::Value&
 
 void TouchPressCommand::RunAction()
 {
-    if (CommandParser::GetInstance().GetScreenMode() == CommandParser::ScreenMode::STATIC) {
-        return;
-    }
-    MouseInputImpl::GetInstance().SetMousePosition(atof(args["x"].asString().data()),
-                                                   atof(args["y"].asString().data()));
-    MouseInputImpl::GetInstance().SetMouseStatus(MouseInputImpl::INDEV_STATE_PRESS);
-    MouseInputImpl::GetInstance().DispatchOsTouchEvent();
+    int type = 0;
+    EventParams param;
+    param.x = atof(args["x"].asString().data());
+    param.y = atof(args["y"].asString().data());
+    param.type = type;
+    param.name = "TouchPress";
+    param.button = MouseInputImpl::GetInstance().DEFAULT_BUTTON;
+    param.action = MouseInputImpl::GetInstance().DEFAULT_ACTION;
+    param.sourceType = MouseInputImpl::GetInstance().DEFAULT_SOURCETYPE;
+    param.sourceTool = MouseInputImpl::GetInstance().DEFAULT_SOURCETOOL;
+    SetEventParams(param);
     SetCommandResult("result", true);
-    ILOG("MousePress(%s,%s)", args["x"].asString().c_str(), args["y"].asString().c_str());
 }
 
 bool MouseWheelCommand::IsActionArgValid() const
@@ -226,13 +255,18 @@ TouchReleaseCommand::TouchReleaseCommand(CommandType commandType, const Json::Va
 
 void TouchReleaseCommand::RunAction()
 {
-    if (CommandParser::GetInstance().GetScreenMode() == CommandParser::ScreenMode::STATIC) {
-        return;
-    }
-    MouseInputImpl::GetInstance().SetMouseStatus(MouseInputImpl::INDEV_STATE_RELEASE);
-    MouseInputImpl::GetInstance().DispatchOsTouchEvent();
+    int type = 1;
+    EventParams param;
+    param.x = atof(args["x"].asString().data());
+    param.y = atof(args["y"].asString().data());
+    param.type = type;
+    param.name = "TouchRelease";
+    param.button = MouseInputImpl::GetInstance().DEFAULT_BUTTON;
+    param.action = MouseInputImpl::GetInstance().DEFAULT_ACTION;
+    param.sourceType = MouseInputImpl::GetInstance().DEFAULT_SOURCETYPE;
+    param.sourceTool = MouseInputImpl::GetInstance().DEFAULT_SOURCETOOL;
+    SetEventParams(param);
     SetCommandResult("result", true);
-    ILOG("MouseRelease run finished");
 }
 
 bool TouchMoveCommand::IsActionArgValid() const
@@ -261,16 +295,18 @@ TouchMoveCommand::TouchMoveCommand(CommandType commandType, const Json::Value& a
 
 void TouchMoveCommand::RunAction()
 {
-    if (CommandParser::GetInstance().GetScreenMode() == CommandParser::ScreenMode::STATIC) {
-        return;
-    }
-    MouseInputImpl::GetInstance().SetMouseStatus(MouseInput::INDEV_STATE_MOVE);
-    MouseInputImpl::GetInstance().SetMousePosition(atof(args["x"].asString().data()),
-                                                   atof(args["y"].asString().data()));
-    MouseInputImpl::GetInstance().DispatchOsTouchEvent();
-    Json::Value res = true;
-    SetCommandResult("result", res);
-    ILOG("MouseMove run finished");
+    int type = 2;
+    EventParams param;
+    param.x = atof(args["x"].asString().data());
+    param.y = atof(args["y"].asString().data());
+    param.type = type;
+    param.name = "TouchMove";
+    param.button = MouseInputImpl::GetInstance().DEFAULT_BUTTON;
+    param.action = MouseInputImpl::GetInstance().DEFAULT_ACTION;
+    param.sourceType = MouseInputImpl::GetInstance().DEFAULT_SOURCETYPE;
+    param.sourceTool = MouseInputImpl::GetInstance().DEFAULT_SOURCETOOL;
+    SetEventParams(param);
+    SetCommandResult("result", true);
 }
 
 PowerCommand::PowerCommand(CommandType commandType, const Json::Value& arg, const LocalSocket& socket)
@@ -1334,4 +1370,94 @@ void KeyPressCommand::RunAction()
     }
     SetCommandResult("result", true);
     ILOG("KeyPressCommand run finished.");
+}
+
+bool PointEventCommand::IsActionArgValid() const
+{
+    return IsArgsExist() && IsArgsValid();
+}
+
+bool PointEventCommand::IsArgsExist() const
+{
+    if (args.isNull() || !args.isMember("x") || !args.isMember("y") ||
+        !args["x"].isInt() || !args["y"].isInt()) {
+        return false;
+    }
+    if (!args.isMember("button") || !args.isMember("action") ||
+        !args["button"].isInt() || !args["action"].isInt()) {
+        return false;
+    }
+    if (!args.isMember("sourceType") || !args.isMember("sourceTool") ||
+        !args["sourceType"].isInt() || !args["sourceTool"].isInt()) {
+        return false;
+    }
+    if (!args.isMember("axisValues") || !args["axisValues"].isArray()) {
+        return false;
+    }
+    return true;
+}
+
+bool PointEventCommand::IsArgsValid() const
+{
+    int32_t pointX = args["x"].asInt();
+    int32_t pointY = args["y"].asInt();
+    int32_t button = args["button"].asInt();
+    int32_t action = args["action"].asInt();
+    int32_t sourceType = args["sourceType"].asInt();
+    int32_t sourcceTool = args["sourcceTool"].asInt();
+    if (pointX < 0 || pointX > VirtualScreenImpl::GetInstance().GetOrignalWidth()) {
+        ELOG("X coordinate range %d ~ %d", 0, VirtualScreenImpl::GetInstance().GetOrignalWidth());
+        return false;
+    }
+    if (pointY < 0 || pointY > VirtualScreenImpl::GetInstance().GetOrignalHeight()) {
+        ELOG("Y coordinate range %d ~ %d", 0, VirtualScreenImpl::GetInstance().GetOrignalHeight());
+        return false;
+    }
+    if (button < -1 || action < 0 || sourceType < 0 || sourcceTool < 0) {
+        ELOG("action,sourceType,sourcceTool must >= 0, button must >= -1");
+        return false;
+    }
+    Json::Value axisArrayNum = args["axisValues"];
+    for (unsigned int i = 0; i < axisArrayNum.size(); i++) {
+        if (!axisArrayNum[i].isDouble()) {
+            ELOG("Param axisValues's value is invalid.");
+            return false;
+        }
+    }
+    return true;
+}
+
+PointEventCommand::PointEventCommand(CommandType commandType, const Json::Value& arg, const LocalSocket& socket)
+    : CommandLine(commandType, arg, socket)
+{
+}
+
+void PointEventCommand::RunAction()
+{
+    int type = 9;
+    EventParams param;
+    if (args.isMember("pressedButtons") && args["pressedButtons"].isArray()) {
+        Json::Value pressedCodes = args["pressedCodes"];
+        for (unsigned int i = 0; i < pressedCodes.size(); i++) {
+            if (!pressedCodes[i].isInt() || pressedCodes[i].asInt() < -1) {
+                continue;
+            }
+            param.pressedBtnsVec.insert(pressedCodes[i].asInt());
+        }
+    }
+    vector<double> axisVec; // 13 is array size
+    Json::Value axisCodes = args["axisValues"];
+    for (unsigned int i = 0; i < axisCodes.size(); i++) {
+        param.axisVec.push_back(axisCodes[i].asDouble());
+    }
+    param.x = atof(args["x"].asString().data());
+    param.y = atof(args["y"].asString().data());
+    param.type = type;
+    param.button = args["button"].asInt();
+    param.action = args["action"].asInt();
+    param.sourceType = args["sourceType"].asInt();
+    param.sourceTool = args["sourceTool"].asInt();
+    param.name = "PointEvent";
+    SetEventParams(param);
+    SetCommandResult("result", true);
 }

cli/CommandLine.h

@@ -17,6 +17,8 @@
 #define COMMANDLINE_H
 
 #include <json.h>
+#include <set>
+#include <vector>
 
 #include "LocalSocket.h"
 
@@ -86,7 +88,24 @@ private:
     void Run();
 };
 
-class TouchPressCommand : public CommandLine {
+class TouchAndMouseCommand {
+protected:
+    struct EventParams {
+        double x;
+        double y;
+        int type;
+        int button;
+        int action;
+        int sourceType;
+        int sourceTool;
+        std::set<int> pressedBtnsVec;
+        std::vector<double> axisVec; // 13 is array size
+        std::string name;
+    };
+    void SetEventParams(EventParams& params);
+};
+
+class TouchPressCommand : public CommandLine, public TouchAndMouseCommand {
 public:
     TouchPressCommand(CommandType commandType, const Json::Value& arg, const LocalSocket& socket);
     ~TouchPressCommand() override {}
@@ -96,7 +115,7 @@ protected:
     bool IsActionArgValid() const override;
 };
 
-class TouchMoveCommand : public CommandLine {
+class TouchMoveCommand : public CommandLine, public TouchAndMouseCommand {
 public:
     TouchMoveCommand(CommandType commandType, const Json::Value& arg, const LocalSocket& socket);
     ~TouchMoveCommand() override {}
@@ -106,7 +125,7 @@ protected:
     bool IsActionArgValid() const override;
 };
 
-class TouchReleaseCommand : public CommandLine {
+class TouchReleaseCommand : public CommandLine, public TouchAndMouseCommand {
 public:
     TouchReleaseCommand(CommandType commandType, const Json::Value& arg, const LocalSocket& socket);
     ~TouchReleaseCommand() override {}
@@ -461,4 +480,16 @@ protected:
     bool IsImeArgsValid() const;
     bool IsKeyArgsValid() const;
 };
+
+class PointEventCommand : public CommandLine, public TouchAndMouseCommand {
+public:
+    PointEventCommand(CommandType commandType, const Json::Value& arg, const LocalSocket& socket);
+    ~PointEventCommand() override {}
+
+protected:
+    void RunAction() override;
+    bool IsActionArgValid() const override;
+    bool IsArgsExist() const;
+    bool IsArgsValid() const;
+};
 #endif // COMMANDLINE_H

cli/CommandLineFactory.cpp

@@ -70,6 +70,7 @@ void CommandLineFactory::InitCommandMap()
     typeMap["exit"] = &CommandLineFactory::CreateObject<ExitCommand>;
     typeMap["Resolution"] = &CommandLineFactory::CreateObject<ResolutionCommand>;
     typeMap["DeviceType"] = &CommandLineFactory::CreateObject<DeviceTypeCommand>;
+    typeMap["PointEvent"] = &CommandLineFactory::CreateObject<PointEventCommand>;
 }
 
 unique_ptr<CommandLine> CommandLineFactory::CreateCommandLine(string command,

mock/MouseInput.cpp

@@ -15,11 +15,12 @@
 
 #include "MouseInput.h"
 
-MouseInput::MouseInput() : mouseStatus(INDEV_STATE_RELEASE), mouseXPosition(0), mouseYPosition(0) {}
+MouseInput::MouseInput() : touchAction(0), mouseXPosition(0), mouseYPosition(0),
+    pointButton(0), pointAction(0), sourceType(0), sourceTool(0) {}
 
-void MouseInput::SetMouseStatus(MouseStatus status)
+void MouseInput::SetMouseStatus(int status)
 {
-    mouseStatus = status;
+    touchAction = status;
 }
 
 void MouseInput::SetMousePosition(double xPosition, double yPosition)
@@ -37,3 +38,33 @@ double MouseInput::GetMouseYPosition() const
 {
     return mouseYPosition;
 }
+
+void MouseInput::SetMouseButton(int buttonVal)
+{
+    pointButton = buttonVal;
+}
+
+void MouseInput::SetMouseAction(int actionVal)
+{
+    pointAction = actionVal;
+}
+
+void MouseInput::SetSourceType(int sourceTypeVal)
+{
+    sourceType = sourceTypeVal;
+}
+
+void MouseInput::SetSourceTool(int sourceToolVal)
+{
+    sourceTool = sourceToolVal;
+}
+
+void MouseInput::SetPressedBtns(std::set<int>& pressedBtns)
+{
+    pressedBtnsVec = pressedBtns;
+}
+
+void MouseInput::SetAxisValues(std::vector<double>& axisValues) // 13 is array size
+{
+    axisValuesArr = axisValues;
+}

mock/MouseInput.h

@@ -16,23 +16,40 @@
 #ifndef MOUSEINPUT_H
 #define MOUSEINPUT_H
 
+#include <set>
+#include <vector>
+
 class MouseInput {
 public:
-    enum MouseStatus { INDEV_STATE_RELEASE = 0, INDEV_STATE_PRESS, INDEV_STATE_MOVE };
-
     double GetMouseXPosition() const;
     double GetMouseYPosition() const;
-    virtual void SetMouseStatus(MouseStatus status);
+    virtual void SetMouseStatus(int status);
     virtual void SetMousePosition(double xPosition, double yPosition);
     virtual void DispatchOsTouchEvent() const {};
     virtual void DispatchOsBackEvent() const {};
+    virtual void SetMouseButton(int buttonVal);
+    virtual void SetMouseAction(int actionVal);
+    virtual void SetSourceType(int sourceTypeVal);
+    virtual void SetSourceTool(int sourceToolVal);
+    virtual void SetPressedBtns(std::set<int>& pressedBtns);
+    virtual void SetAxisValues(std::vector<double>& axisValues); // 13 is array size
+    const int DEFAULT_BUTTON = -1; // default unknown
+    const int DEFAULT_ACTION = 0;  // default unknown
+    const int DEFAULT_SOURCETYPE = 2; // default touch
+    const int DEFAULT_SOURCETOOL = 1; // default finger
 
 protected:
     MouseInput();
     virtual ~MouseInput() {}
-    MouseStatus mouseStatus;
+    int touchAction;
     double mouseXPosition;
     double mouseYPosition;
+    int pointButton;
+    int pointAction;
+    int sourceType;
+    int sourceTool;
+    std::set<int> pressedBtnsVec;
+    std::vector<double> axisValuesArr; // 13 is array size
 };
 
 #endif // MOUSEINPUT_H

mock/lite/MouseInputImpl.cpp

@@ -29,15 +29,16 @@ bool MouseInputImpl::Read(OHOS::DeviceData& data)
 {
     data.point.x = static_cast<short>(mouseXPosition);
     data.point.y = static_cast<short>(mouseYPosition);
-    data.state = mouseStatus;
+    data.state = touchAction;
     return false;
 }
 
-void MouseInputImpl::SetMouseStatus(MouseStatus status)
+void MouseInputImpl::SetMouseStatus(int status)
 {
-    if (status == INDEV_STATE_MOVE) {
+    int moveType = 2;
+    if (status == moveType) {
         return;
     }
-    mouseStatus = status;
+    touchAction = status;
 }
 

mock/lite/MouseInputImpl.h

@@ -24,7 +24,7 @@ class MouseInputImpl : public MouseInput, public OHOS::PointerInputDevice {
 public:
     static MouseInputImpl& GetInstance();
     virtual bool Read(OHOS::DeviceData& data) override;
-    virtual void SetMouseStatus(MouseStatus status) override;
+    virtual void SetMouseStatus(int status) override;
 
 private:
     MouseInputImpl();

mock/rich/MouseInputImpl.cpp

@@ -18,6 +18,7 @@
 #include <thread>
 #include <vector>
 #include <chrono>
+#include <sstream>
 
 #include "PreviewerEngineLog.h"
 
@@ -25,28 +26,26 @@ using namespace std;
 
 using namespace OHOS::MMI;
 
-MouseInputImpl::MouseInputImpl()
+MouseInputImpl::MouseInputImpl() noexcept
 {
 }
 
-TouchType MouseInputImpl::ConvertToOsType(MouseInput::MouseStatus status) const
+TouchType MouseInputImpl::ConvertToOsType(int status) const
 {
-    TouchType type;
-    switch (status) {
-        case INDEV_STATE_RELEASE:
-            type = TouchType::UP;
-            break;
-        case INDEV_STATE_PRESS:
-            type = TouchType::DOWN;
-            break;
-        case INDEV_STATE_MOVE:
-            type = TouchType::MOVE;
-            break;
-        default:
-            break;
+    if (status < static_cast<int>(TouchType::DOWN) || status > static_cast<int>(TouchType::UNKNOWN)) {
+        return TouchType::UNKNOWN;
     }
-    return type;
+    return static_cast<TouchType>(status);
 }
+
+SourceTool MouseInputImpl::ConvertToOsTool(int tools) const
+{
+    if (tools < static_cast<int>(SourceTool::UNKNOWN) || tools > static_cast<int>(SourceTool::LENS)) {
+        return SourceTool::UNKNOWN;
+    }
+    return static_cast<SourceTool>(tools);
+}
+
 void MouseInputImpl::DispatchOsTouchEvent() const
 {
     auto pointerEvent = std::make_shared<PointerEvent>();
@@ -54,9 +53,24 @@ void MouseInputImpl::DispatchOsTouchEvent() const
     pointerEvent->id = 1;
     pointerEvent->x = mouseXPosition;
     pointerEvent->y = mouseYPosition;
-    pointerEvent->type = ConvertToOsType(mouseStatus);
+    pointerEvent->type = ConvertToOsType(touchAction);
+    pointerEvent->buttonId_ = pointButton;
+    pointerEvent->pointerAction_ = pointAction;
+    pointerEvent->sourceType = sourceType;
+    pointerEvent->sourceTool = ConvertToOsTool(sourceTool);
+    pointerEvent->pressedButtons_ = pressedBtnsVec;
+    std::copy(axisValuesArr.begin(), axisValuesArr.end(), pointerEvent->axisValues_.begin());
     pointerEvent->size = sizeof (PointerEvent);
-    ILOG("MouseInputImpl::DispatchEvent x: %f y:%f", mouseXPosition, mouseYPosition);
+    std::stringstream ss;
+    ss << "[";
+    for (double val : axisValuesArr) {
+        ss << " " << val << " ";
+    }
+    ss << "]" << std::endl;
+    ILOG("MouseInputImpl::DispatchEvent x: %f y:%f type:%d buttonId_:%d pointerAction_:%d sourceType:%d \
+        sourceTool:%d pressedButtonsSize:%d axisValuesArr:%s", pointerEvent->x, pointerEvent->y,
+        pointerEvent->type, pointerEvent->buttonId_, pointerEvent->pointerAction_, pointerEvent->sourceType,
+        pointerEvent->sourceTool, pointerEvent->pressedButtons_.size(), ss.str().c_str());
     ILOG("current thread: %d", this_thread::get_id());
     JsAppImpl::GetInstance().DispatchPointerEvent(pointerEvent);
 }
@@ -74,9 +88,9 @@ MouseInputImpl& MouseInputImpl::GetInstance()
     return instance;
 }
 
-void MouseInputImpl::SetMouseStatus(MouseStatus status)
+void MouseInputImpl::SetMouseStatus(int status)
 {
-    mouseStatus = status;
+    touchAction = status;
 }
 
 void MouseInputImpl::SetMousePosition(double xPosition, double yPosition)

mock/rich/MouseInputImpl.h

@@ -22,14 +22,15 @@
 class MouseInputImpl : public MouseInput {
 public:
     static MouseInputImpl& GetInstance();
-    void SetMouseStatus(MouseStatus status) override;
+    void SetMouseStatus(int status) override;
     void SetMousePosition(double xPosition, double yPosition) override;
     void DispatchOsTouchEvent() const override;
     void DispatchOsBackEvent() const override;
 private:
-    MouseInputImpl();
+    MouseInputImpl() noexcept;
     virtual ~MouseInputImpl() {}
-    OHOS::MMI::TouchType ConvertToOsType(MouseStatus status) const;
+    OHOS::MMI::TouchType ConvertToOsType(int status) const;
+    OHOS::MMI::SourceTool ConvertToOsTool(int tools) const;
 };
 
 #endif // MOUSEINPUTIMPL_H