按键事件转换

src/dialog.cpp

@@ -1,5 +1,6 @@
 #include <QFile>
 #include <QTime>
+#include <QKeyEvent>
 
 #include "dialog.h"
 #include "ui_dialog.h"
@@ -44,3 +45,9 @@ void Dialog::on_stopServerBtn_clicked()
         m_videoForm->close();
     }
 }
+
+void Dialog::keyPressEvent(QKeyEvent *event)
+{
+    qDebug() << event->key();
+    return QDialog::keyPressEvent(event);
+}

src/dialog.h

@@ -26,6 +26,9 @@ private slots:
 
     void on_stopServerBtn_clicked();
 
+protected:
+    void keyPressEvent(QKeyEvent *event);
+
 private:
     Ui::Dialog *ui;
 

src/inputcontrol/inputconvert.cpp

@@ -46,7 +46,7 @@ ControlEvent *InputConvert::wheelEvent(const QWheelEvent *from, const QSize& fra
 {
     if (!from) {
         return Q_NULLPTR;
-    }    
+    }
 
     // delta
     qint32 hScroll = 0;
@@ -75,6 +75,40 @@ ControlEvent *InputConvert::wheelEvent(const QWheelEvent *from, const QSize& fra
     return controlEvent;
 }
 
+ControlEvent *InputConvert::keyEvent(const QKeyEvent *from)
+{
+    if (!from) {
+        return Q_NULLPTR;
+    }
+
+    // action
+    AndroidKeyeventAction action;
+    switch (from->type()) {
+    case QEvent::KeyPress:
+        action = AKEY_EVENT_ACTION_DOWN;
+        break;
+    case QEvent::KeyRelease:
+        action = AKEY_EVENT_ACTION_UP;
+        break;
+    default:
+        return Q_NULLPTR;
+    }
+
+    // key code
+    AndroidKeycode keyCode = convertKeyCode(from->key(), from->modifiers());
+    if (AKEYCODE_UNKNOWN == keyCode) {
+        return Q_NULLPTR;
+    }
+
+    // set data
+    ControlEvent* controlEvent = new ControlEvent(ControlEvent::CET_KEYCODE);
+    if (!controlEvent) {
+        return Q_NULLPTR;
+    }
+    controlEvent->setKeycodeEventData(action, keyCode, convertMetastate(from->modifiers()));
+    return controlEvent;
+}
+
 AndroidMotioneventButtons InputConvert::convertMouseButtons(Qt::MouseButtons buttonState)
 {
     quint32 buttons = 0;
@@ -95,3 +129,207 @@ AndroidMotioneventButtons InputConvert::convertMouseButtons(Qt::MouseButtons but
     }
     return (AndroidMotioneventButtons)buttons;
 }
+
+AndroidKeycode InputConvert::convertKeyCode(int key, Qt::KeyboardModifiers modifiers)
+{
+    AndroidKeycode keyCode = AKEYCODE_UNKNOWN;
+    // functional keys
+    switch (key) {
+    case Qt::Key_Return:
+        keyCode = AKEYCODE_ENTER;
+        break;
+    case Qt::Key_Enter:
+        keyCode = AKEYCODE_NUMPAD_ENTER;
+        break;
+    case Qt::Key_Escape:
+        keyCode = AKEYCODE_ESCAPE;
+        break;
+    case Qt::Key_Backspace:
+        keyCode = AKEYCODE_DEL;
+        break;
+    case Qt::Key_Delete:
+        keyCode = AKEYCODE_FORWARD_DEL;
+        break;
+    case Qt::Key_Tab:
+        keyCode = AKEYCODE_TAB;
+        break;
+    case Qt::Key_Home:
+        keyCode = AKEYCODE_MOVE_HOME;
+        break;
+    case Qt::Key_End:
+        keyCode = AKEYCODE_MOVE_END;
+        break;
+    case Qt::Key_PageUp:
+        keyCode = AKEYCODE_PAGE_UP;
+        break;
+    case Qt::Key_PageDown:
+        keyCode = AKEYCODE_PAGE_DOWN;
+        break;
+    case Qt::Key_Left:
+        keyCode = AKEYCODE_DPAD_LEFT;
+        break;
+    case Qt::Key_Right:
+        keyCode = AKEYCODE_DPAD_RIGHT;
+        break;
+    case Qt::Key_Up:
+        keyCode = AKEYCODE_DPAD_UP;
+        break;
+    case Qt::Key_Down:
+        keyCode = AKEYCODE_DPAD_DOWN;
+        break;
+    }
+    if (AKEYCODE_UNKNOWN != keyCode) {
+        return keyCode;
+    }
+
+    // if ALT and META are pressed, dont handle letters and space
+    if (modifiers & (Qt::AltModifier | Qt::MetaModifier)) {
+        return keyCode;
+    }
+
+    // character keys
+    switch (key) {
+    case Qt::Key_A:
+        keyCode = AKEYCODE_A;
+        break;
+    case Qt::Key_B:
+        keyCode = AKEYCODE_B;
+        break;
+    case Qt::Key_C:
+        keyCode = AKEYCODE_C;
+        break;
+    case Qt::Key_D:
+        keyCode = AKEYCODE_D;
+        break;
+    case Qt::Key_E:
+        keyCode = AKEYCODE_E;
+        break;
+    case Qt::Key_F:
+        keyCode = AKEYCODE_F;
+        break;
+    case Qt::Key_G:
+        keyCode = AKEYCODE_G;
+        break;
+    case Qt::Key_H:
+        keyCode = AKEYCODE_H;
+        break;
+    case Qt::Key_I:
+        keyCode = AKEYCODE_I;
+        break;
+    case Qt::Key_J:
+        keyCode = AKEYCODE_J;
+        break;
+    case Qt::Key_K:
+        keyCode = AKEYCODE_K;
+        break;
+    case Qt::Key_L:
+        keyCode = AKEYCODE_L;
+        break;
+    case Qt::Key_M:
+        keyCode = AKEYCODE_M;
+        break;
+    case Qt::Key_N:
+        keyCode = AKEYCODE_N;
+        break;
+    case Qt::Key_O:
+        keyCode = AKEYCODE_O;
+        break;
+    case Qt::Key_P:
+        keyCode = AKEYCODE_P;
+        break;
+    case Qt::Key_Q:
+        keyCode = AKEYCODE_Q;
+        break;
+    case Qt::Key_R:
+        keyCode = AKEYCODE_R;
+        break;
+    case Qt::Key_S:
+        keyCode = AKEYCODE_S;
+        break;
+    case Qt::Key_T:
+        keyCode = AKEYCODE_T;
+        break;
+    case Qt::Key_U:
+        keyCode = AKEYCODE_U;
+        break;
+    case Qt::Key_V:
+        keyCode = AKEYCODE_V;
+        break;
+    case Qt::Key_W:
+        keyCode = AKEYCODE_W;
+        break;
+    case Qt::Key_X:
+        keyCode = AKEYCODE_X;
+        break;
+    case Qt::Key_Y:
+        keyCode = AKEYCODE_Y;
+        break;
+    case Qt::Key_Z:
+        keyCode = AKEYCODE_Z;
+        break;
+    case Qt::Key_0:
+        keyCode = AKEYCODE_0;
+        break;
+    case Qt::Key_1:
+        keyCode = AKEYCODE_1;
+        break;
+    case Qt::Key_2:
+        keyCode = AKEYCODE_2;
+        break;
+    case Qt::Key_3:
+        keyCode = AKEYCODE_3;
+        break;
+    case Qt::Key_4:
+        keyCode = AKEYCODE_4;
+        break;
+    case Qt::Key_5:
+        keyCode = AKEYCODE_5;
+        break;
+    case Qt::Key_6:
+        keyCode = AKEYCODE_6;
+        break;
+    case Qt::Key_7:
+        keyCode = AKEYCODE_7;
+        break;
+    case Qt::Key_8:
+        keyCode = AKEYCODE_8;
+        break;
+    case Qt::Key_9:
+        keyCode = AKEYCODE_9;
+        break;
+    case Qt::Key_Space:
+        keyCode = AKEYCODE_SPACE;
+        break;
+    }
+    return keyCode;
+}
+
+AndroidMetastate InputConvert::convertMetastate(Qt::KeyboardModifiers modifiers)
+{
+    int metastate = AMETA_NONE;
+
+    if (modifiers & Qt::ShiftModifier) {
+        metastate |= AMETA_SHIFT_ON;
+    }
+    if (modifiers & Qt::ControlModifier) {
+        metastate |= AMETA_CTRL_ON;
+    }
+    if (modifiers & Qt::AltModifier) {
+        metastate |= AMETA_ALT_ON;
+    }
+    if (modifiers & Qt::MetaModifier) {
+        metastate |= AMETA_META_ON;
+    }
+    /*
+    if (mod & KMOD_NUM) {
+        metastate |= AMETA_NUM_LOCK_ON;
+    }
+    if (mod & KMOD_CAPS) {
+        metastate |= AMETA_CAPS_LOCK_ON;
+    }
+    if (mod & KMOD_MODE) { // Alt Gr
+        // no mapping?
+    }
+    */
+    return (AndroidMetastate)metastate;
+}

src/inputcontrol/inputconvert.h

@@ -3,6 +3,7 @@
 
 #include <QMouseEvent>
 #include <QWheelEvent>
+#include <QKeyEvent>
 
 #include "controlevent.h"
 
@@ -15,9 +16,12 @@ public:
     // to which the absolute position apply, to scale it accordingly
     static ControlEvent* mouseEvent(const QMouseEvent* from, const QSize& frameSize, const QSize& showSize);
     static ControlEvent* wheelEvent(const QWheelEvent* from, const QSize& frameSize, const QSize& showSize);
+    static ControlEvent* keyEvent(const QKeyEvent* from);
 
 private:
     static AndroidMotioneventButtons convertMouseButtons(Qt::MouseButtons buttonState);
+    static AndroidKeycode convertKeyCode(int key, Qt::KeyboardModifiers modifiers);
+    static AndroidMetastate convertMetastate(Qt::KeyboardModifiers modifiers);
 };
 
 #endif // INPUTCONVERT_H

src/videoform.cpp

@@ -121,3 +121,19 @@ void VideoForm::wheelEvent(QWheelEvent *event)
         m_controller.postControlEvent(controlEvent);
     }
 }
+
+void VideoForm::keyPressEvent(QKeyEvent *event)
+{
+    ControlEvent* controlEvent = InputConvert::keyEvent(event);
+    if (controlEvent) {
+        m_controller.postControlEvent(controlEvent);
+    }
+}
+
+void VideoForm::keyReleaseEvent(QKeyEvent *event)
+{
+    ControlEvent* controlEvent = InputConvert::keyEvent(event);
+    if (controlEvent) {
+        m_controller.postControlEvent(controlEvent);
+    }
+}

src/videoform.h

@@ -28,6 +28,8 @@ protected:
     void mouseReleaseEvent(QMouseEvent *event);
     void mouseMoveEvent(QMouseEvent *event);
     void wheelEvent(QWheelEvent *event);
+    void keyPressEvent(QKeyEvent *event);
+    void keyReleaseEvent(QKeyEvent *event);
 
 private:
     Ui::videoForm *ui;