appium-espresso-driver 1.46.0

package/espresso-server/app/src/androidTest/java/io/appium/espressoserver/lib/helpers/w3c/dispatcher/PointerDispatch.kt

@@ -0,0 +1,286 @@
+package io.appium.espressoserver.lib.helpers.w3c.dispatcher
+
+import io.appium.espressoserver.lib.handlers.exceptions.AppiumException
+import io.appium.espressoserver.lib.handlers.exceptions.InvalidArgumentException
+import io.appium.espressoserver.lib.handlers.exceptions.MoveTargetOutOfBoundsException
+import io.appium.espressoserver.lib.helpers.Rect
+import io.appium.espressoserver.lib.helpers.w3c.adapter.W3CActionAdapter
+import io.appium.espressoserver.lib.helpers.w3c.models.*
+import io.appium.espressoserver.lib.helpers.w3c.state.InputStateTable
+import io.appium.espressoserver.lib.helpers.w3c.state.KeyInputState
+import io.appium.espressoserver.lib.helpers.w3c.state.PointerInputState
+import java.util.concurrent.Callable
+import kotlin.math.roundToInt
+
+object PointerDispatch {
+    @Throws(AppiumException::class)
+    private fun dispatchPointerEvent(dispatcherAdapter: W3CActionAdapter,
+                                     actionObject: ActionObject,
+                                     pointerInputState: PointerInputState,
+                                     inputStateTable: InputStateTable,
+                                     globalKeyInputState: KeyInputState?,
+                                     down: Boolean) {
+        val pointerType = actionObject.pointer
+        val button = actionObject.button
+        if (down) {
+            if (pointerInputState.isPressed(button)) {
+                return
+            }
+        } else {
+            if (!pointerInputState.isPressed(button)) {
+                return
+            }
+        }
+        val x = pointerInputState.x
+        val y = pointerInputState.y
+        if (down) {
+            pointerInputState.addPressed(button)
+        } else {
+            pointerInputState.removePressed(button)
+        }
+        dispatcherAdapter.logger.info(String.format(
+                "Dispatching pointer event '%s' on input source with id '%s' with coordinates [%s, %s] " +
+                        "and button '%s'",
+                if (down) "pointerDown" else "pointerUp", actionObject.id, x, y, button
+        ))
+        dispatcherAdapter.lockAdapter()
+        try {
+            if (down) {
+                // Add cancel object to cancel list
+                val cancelObject = ActionObject(actionObject)
+                cancelObject.subType = InputSource.ActionType.POINTER_UP
+                inputStateTable.addActionToCancel(cancelObject)
+
+                // Dispatch implementation specific pointer down
+                dispatcherAdapter.pointerDown(button, actionObject.id!!, pointerType, x, y,
+                        pointerInputState.buttons, globalKeyInputState)
+            } else {
+                // Dispatch implementation specific pointer up
+                dispatcherAdapter.pointerUp(button, actionObject.id!!, pointerType, x, y,
+                        pointerInputState.buttons, globalKeyInputState)
+            }
+        } finally {
+            dispatcherAdapter.unlockAdapter()
+        }
+
+        // Log the new state of the pointer
+        dispatcherAdapter.logger.info(String.format(
+                "State of pointer input source with id %s is now: %s",
+                actionObject.id, pointerInputState.logMessage()
+        ))
+    }
+
+    /**
+     * Run the 'dispatch a pointer down' algorithm
+     * @param dispatcherAdapter W3C actions implementation
+     * @param actionObject Action object that defines the pointer action
+     * @param pointerInputState Current state of the input source
+     * @param globalKeyInputState Global key input state
+     * @throws AppiumException
+     */
+    @Throws(AppiumException::class)
+    fun dispatchPointerDown(dispatcherAdapter: W3CActionAdapter,
+                            actionObject: ActionObject,
+                            pointerInputState: PointerInputState,
+                            inputStateTable: InputStateTable,
+                            globalKeyInputState: KeyInputState?) {
+        dispatchPointerEvent(dispatcherAdapter, actionObject, pointerInputState,
+                inputStateTable, globalKeyInputState, true)
+    }
+
+    /**
+     * Perform the 'dispatch pointer up' algorithm
+     * @param dispatcherAdapter W3C actions implementation
+     * @param actionObject Action object that defines the pointer action
+     * @param pointerInputState Current state of the input source
+     * @param globalKeyInputState Global key input state
+     * @throws AppiumException
+     */
+    @Throws(AppiumException::class)
+    fun dispatchPointerUp(dispatcherAdapter: W3CActionAdapter,
+                          actionObject: ActionObject,
+                          pointerInputState: PointerInputState,
+                          inputStateTable: InputStateTable,
+                          globalKeyInputState: KeyInputState?) {
+        dispatchPointerEvent(dispatcherAdapter, actionObject, pointerInputState,
+                inputStateTable, globalKeyInputState, false)
+    }
+
+    /**
+     * Perform the 'dispatch a pointer cancel' event
+     * @param dispatcherAdapter ActionsPerformer adapter
+     * @param actionObject Action object
+     * @throws AppiumException
+     */
+    @Throws(AppiumException::class)
+    fun dispatchPointerCancel(dispatcherAdapter: W3CActionAdapter,
+                              actionObject: ActionObject) {
+        dispatcherAdapter.pointerCancel(actionObject.id!!, actionObject.pointer!!)
+    }
+
+    /**
+     * Call the 'dispatch a pointerMove action' algorithm
+     * @param dispatcherAdapter W3C actions implementation
+     * @param sourceId ID of the input source
+     * @param actionObject Action object that defines the pointer action
+     * @param pointerInputState Current state of the input source
+     * @param tickDuration How long is this tick (in ms)
+     * @param timeAtBeginningOfTick Time when the current tick started (in ms)
+     * @param globalKeyInputState Global key input state
+     * @return Returns a callable that returns when the pointer move is complete
+     * @throws AppiumException
+     */
+    @Throws(AppiumException::class)
+    fun dispatchPointerMove(dispatcherAdapter: W3CActionAdapter,
+                            sourceId: String?,
+                            actionObject: ActionObject,
+                            pointerInputState: PointerInputState,
+                            tickDuration: Float,
+                            timeAtBeginningOfTick: Long,
+                            globalKeyInputState: KeyInputState?): Callable<BaseDispatchResult> {
+        // 1.5 Variable definitions
+        val xOffset = actionObject.x!!
+        val yOffset = actionObject.y!!
+        val startX = pointerInputState.x
+        val startY = pointerInputState.y
+        val origin = actionObject.origin
+        dispatcherAdapter.logger.info(String.format(
+                "Dispatching pointer move '%s' on input source with id '%s' with origin '%s' and coordinates [%s, %s]",
+                pointerInputState.type, sourceId, origin, xOffset, yOffset
+        ))
+        val x: Float
+        val y: Float
+
+        // 6. Run the substeps of the first matching value of origin
+        val originType = origin.type ?: Origin.VIEWPORT
+        dispatcherAdapter.logger.info("Origin type is: ", originType)
+        when (origin.type) {
+            Origin.POINTER -> {
+                x = startX + xOffset
+                y = startY + yOffset
+            }
+            Origin.ELEMENT -> {
+                requireNotNull(origin.elementId, { "Element identifier must be present for origin type 'ELEMENT'" })
+                dispatcherAdapter.logger.info("Getting element center point: ", origin.elementId!!)
+                val elementCoordinates = dispatcherAdapter.getElementCenterPoint(origin.elementId)
+                dispatcherAdapter.logger.info(String.format(
+                        "Element center is: %s %s",
+                        elementCoordinates.x, elementCoordinates.y
+                ))
+                x = elementCoordinates.x + xOffset
+                y = elementCoordinates.y + yOffset
+            }
+            Origin.VIEWPORT -> {
+                x = xOffset
+                y = yOffset
+            }
+            else -> throw InvalidArgumentException(String.format("'%s' is not a valid origin type", originType))
+        }
+
+        // 7-8. Bounds check
+        val boundingRect = Rect(0, 0, dispatcherAdapter.viewportWidth.toInt(), dispatcherAdapter.viewportHeight.toInt())
+        if (!boundingRect.contains(x.toInt(), y.toInt())) {
+            throw MoveTargetOutOfBoundsException(x, y, boundingRect)
+        }
+
+        // 9. Let duration be equal to action object's duration property if it is not undefined, or tick duration otherwise
+        val duration = actionObject.duration ?: tickDuration
+        val callable = performPointerMove(
+                dispatcherAdapter,
+                sourceId,
+                pointerInputState,
+                duration,
+                startX, startY,
+                x, y,
+                timeAtBeginningOfTick,
+                globalKeyInputState
+        )
+
+
+        // Log the new state of the pointer
+        dispatcherAdapter.logger.info(String.format(
+                "State of pointer input source with id %s is now: %s",
+                actionObject.id, pointerInputState.logMessage()
+        ))
+        return callable
+    }
+
+    /**
+     * Implements the 'perform a pointer move' algorithm in section 17.4.3
+     * @param dispatcherAdapter W3C actions implementation
+     * @param sourceId ID of the input source
+     * @param pointerInputState Current state of the input source
+     * @param duration How long is the pointer move
+     * @param startX Starting x coordinate
+     * @param startY Starting y coordinate
+     * @param targetX Target x coordinate
+     * @param targetY Target y coordinate
+     */
+    fun performPointerMove(dispatcherAdapter: W3CActionAdapter,
+                           sourceId: String?,
+                           pointerInputState: PointerInputState,
+                           duration: Float,
+                           startX: Float, startY: Float,
+                           targetX: Float, targetY: Float,
+                           timeAtBeginningOfTick: Long,
+                           globalKeyInputState: KeyInputState?): Callable<BaseDispatchResult> {
+        return Callable {
+            val isLast: Boolean
+
+            // 2. Let time delta be the time since the beginning of the current tick, measured in milliseconds on a monotonic clock
+            val timeDelta = System.currentTimeMillis() - timeAtBeginningOfTick
+
+            // 3. Let duration ratio be the ratio of time delta and duration, if duration is greater than 0, or 1 otherwise
+            val durationRatio: Float = if (duration > 0f) timeDelta / duration else 1f
+
+            // 4. If duration ratio is 1, or close enough to 1 that the implementation will not further subdivide the move action,
+            //    let last be true. Otherwise let last be false
+            isLast = 1 - durationRatio <= dispatcherAdapter.getPointerMoveDurationMargin(pointerInputState)
+
+            // 5. If last is true, let x equal target x and y equal target y
+            // 6. Otherwise let x equal an approximation to duration ratio × (target x - start x) + start x,, ...
+            val x = if (isLast) targetX else (durationRatio * (targetX - startX)).roundToInt() + startX
+            val y = if (isLast) targetY else (durationRatio * (targetY - startY)).roundToInt() + startY
+
+            // 7-8: Let currentX and currentY be pointer input state
+            val currentX = pointerInputState.x
+            val currentY = pointerInputState.y
+
+            // Prepare the result
+            val dispatchResult = DispatchPointerMoveResult(
+                    dispatcherAdapter,
+                    sourceId!!,
+                    pointerInputState.type!!,
+                    currentX, currentY,
+                    x, y,
+                    pointerInputState.buttons,
+                    globalKeyInputState
+            )
+            if (currentX != x || currentY != y) {
+
+                // 8.3. Let input state's x property equal x and y property equal y
+                pointerInputState.x = x
+                pointerInputState.y = y
+            }
+
+            // Sleep for a fixed period of time
+            if (duration > 0) {
+                Thread.sleep(dispatcherAdapter.pointerMoveIntervalDuration().toLong())
+            }
+            if (!isLast) {
+                // 11. Perform a pointer move with arguments source id, input state, duration, start x, start y, target x, target y)
+                dispatchResult.next = performPointerMove(
+                        dispatcherAdapter,
+                        sourceId,
+                        pointerInputState,
+                        duration,
+                        startX, startY,
+                        targetX, targetY,
+                        timeAtBeginningOfTick,
+                        globalKeyInputState
+                )
+            }
+            dispatchResult
+        }
+    }
+}

package/espresso-server/app/src/androidTest/java/io/appium/espressoserver/lib/helpers/w3c/dispatcher/W3CKeyEvent.kt

@@ -0,0 +1,21 @@
+package io.appium.espressoserver.lib.helpers.w3c.dispatcher
+
+class W3CKeyEvent {
+    var key: String? = null
+    var code: String? = null
+    var location = 0
+    var keyCode = 0
+    var charCode = 0
+    var which = 0
+    var isAltKey = false
+    var isShiftKey = false
+    var isCtrlKey = false
+    var isMetaKey = false
+    var isRepeat = false
+    var isComposing = false
+
+    fun logMessage(): String {
+        return "key=[$key] code=[$code] altKey=[$isAltKey] shiftKey=[$isShiftKey] ctrlKey=[$isCtrlKey] metaKey=[$isMetaKey]"
+    }
+
+}

package/espresso-server/app/src/androidTest/java/io/appium/espressoserver/lib/helpers/w3c/dispatcher/constants/KeyCodeMapper.kt

@@ -0,0 +1,169 @@
+package io.appium.espressoserver.lib.helpers.w3c.dispatcher.constants
+
+/**
+ * Implement table found in 17.4.2 that maps characters to keyCode
+ *
+ * Not using constants or enums because I don't think we'll actually need these in any
+ * specific implementation
+ * @param key Raw key
+ * @return The code of the raw key or null if not found
+ */
+fun getCode(key: String?): String? {
+    return when (key) {
+        "`" -> "Backquote"
+        "\\" -> "Backslash"
+        "\uE003" -> "Backspace"
+        "[" -> "BracketLeft"
+        "}" -> "BracketRight"
+        "," -> "Comma"
+        "0" -> "Digit0"
+        "1" -> "Digit1"
+        "2" -> "Digit2"
+        "3" -> "Digit3"
+        "4" -> "Digit4"
+        "5" -> "Digit5"
+        "6" -> "Digit6"
+        "7" -> "Digit7"
+        "8" -> "Digit8"
+        "9" -> "Digit9"
+        "=" -> "Equal"
+        "<" -> "IntlBackslash"
+        "a" -> "KeyA"
+        "b" -> "KeyB"
+        "c" -> "KeyC"
+        "d" -> "KeyD"
+        "e" -> "KeyE"
+        "f" -> "KeyF"
+        "g" -> "KeyG"
+        "h" -> "KeyH"
+        "i" -> "KeyI"
+        "j" -> "KeyJ"
+        "k" -> "KeyK"
+        "l" -> "KeyL"
+        "m" -> "KeyM"
+        "n" -> "KeyN"
+        "o" -> "KeyO"
+        "p" -> "KeyP"
+        "q" -> "KeyQ"
+        "r" -> "KeyR"
+        "s" -> "KeyS"
+        "t" -> "KeyT"
+        "u" -> "KeyU"
+        "v" -> "KeyV"
+        "w" -> "KeyW"
+        "x" -> "KeyX"
+        "y" -> "KeyY"
+        "z" -> "KeyZ"
+        "-" -> "Minus"
+        "." -> "Period"
+        "'" -> "Quote"
+        ";" -> "Semicolon"
+        "/" -> "Slash"
+        "\uE00A" -> "AltLeft"
+        "\uE052" -> "AltRight"
+        "\uE009" -> "ControlLeft"
+        "\uE051" -> "ControlRight"
+        "\uE006" -> "Enter"
+        "\uE03D" -> "OSLeft"
+        "\uE053" -> "OSRight"
+        "\uE008" -> "ShiftLeft"
+        "\uE050" -> "ShiftRight"
+        " " -> "Space"
+        "\uE004" -> "Tab"
+        "\uE017" -> "Delete"
+        "\uE010" -> "End"
+        "\uE002" -> "Help"
+        "\uE011" -> "Home"
+        "\uE016" -> "Insert"
+        "\uE01E" -> "PageDown"
+        "\uE01F" -> "PageUp"
+        "\uE015" -> "ArrowDown"
+        "\uE012" -> "ArrowLeft"
+        "\uE014" -> "ArrowRight"
+        "\uE013" -> "ArrowUp"
+        "\uE00C" -> "Escape"
+        "\uE031" -> "F1"
+        "\uE032" -> "F2"
+        "\uE033" -> "F3"
+        "\uE034" -> "F4"
+        "\uE035" -> "F5"
+        "\uE036" -> "F6"
+        "\uE037" -> "F7"
+        "\uE038" -> "F8"
+        "\uE039" -> "F9"
+        "\uE03A" -> "F10"
+        "\uE03B" -> "F11"
+        "\uE03C" -> "F12"
+        "\uE01A" -> "Numpad0"
+        "\uE01B" -> "Numpad1"
+        "\uE01C" -> "Numpad2"
+        "\uE01D" -> "Numpad3"
+        "\uE020" -> "Numpad6"
+        "\uE021" -> "Numpad7"
+        "\uE022" -> "Numpad8"
+        "\uE023" -> "Numpad9"
+        "\uE028" -> "NumpadDecimal"
+        "\uE029" -> "NumpadDivide"
+        "\uE007" -> "NumpadEnter"
+        "\uE024" -> "NumpadMultiply"
+        "\uE026" -> "NumpadSubtract"
+        "~" -> "Backquote"
+        "|" -> "Backslash"
+        "{" -> "BracketLeft"
+        "]" -> "BracketRight"
+        ")" -> "Digit0"
+        "!" -> "Digit1"
+        "@" -> "Digit2"
+        "#" -> "Digit3"
+        "$" -> "Digit4"
+        "%" -> "Digit5"
+        "^" -> "Digit6"
+        "&" -> "Digit7"
+        "*" -> "Digit8"
+        "(" -> "Digit9"
+        "+" -> "Equal"
+        "A" -> "KeyA"
+        "B" -> "KeyB"
+        "C" -> "KeyC"
+        "D" -> "KeyD"
+        "E" -> "KeyE"
+        "F" -> "KeyF"
+        "G" -> "KeyG"
+        "H" -> "KeyH"
+        "I" -> "KeyI"
+        "J" -> "KeyJ"
+        "K" -> "KeyK"
+        "L" -> "KeyL"
+        "M" -> "KeyM"
+        "N" -> "KeyN"
+        "O" -> "KeyO"
+        "P" -> "KeyP"
+        "Q" -> "KeyQ"
+        "R" -> "KeyR"
+        "S" -> "KeyS"
+        "T" -> "KeyT"
+        "U" -> "KeyU"
+        "V" -> "KeyV"
+        "W" -> "KeyW"
+        "X" -> "KeyX"
+        "Y" -> "KeyY"
+        "Z" -> "KeyZ"
+        "_" -> "Minus"
+        ">" -> "Period"
+        "" -> "Quote"
+        ":" -> "Semicolon"
+        "?" -> "Slash"
+        "\uE00D" -> "Space"
+        "\uE05C" -> "Numpad0"
+        "\uE056" -> "Numpad1"
+        "\uE05B" -> "Numpad2"
+        "\uE055" -> "Numpad3"
+        "\uE058" -> "Numpad4"
+        "\uE05A" -> "Numpad6"
+        "\uE057" -> "Numpad7"
+        "\uE059" -> "Numpad8"
+        "\uE054" -> "Numpad9"
+        "\uE05D" -> "NumpadDecimal"
+        else -> null
+    }
+}

package/espresso-server/app/src/androidTest/java/io/appium/espressoserver/lib/helpers/w3c/dispatcher/constants/KeyLocationMapper.kt

@@ -0,0 +1,50 @@
+package io.appium.espressoserver.lib.helpers.w3c.dispatcher.constants
+
+/**
+ * Implement table found in 17.4.2 that maps characters to 'location'
+ *
+ * Not using constants or enums because I don't think we'll actually need these in any
+ * specific implementation
+ * @param key Raw key
+ * @return The location of the key or default 0
+ */
+fun getLocation(key: String?): Int {
+    return when (key) {
+        "\uE007" -> 1
+        "\uE008" -> 1
+        "\uE009" -> 1
+        "\uE00A" -> 1
+        "\uE01A" -> 3
+        "\uE01B" -> 3
+        "\uE01C" -> 3
+        "\uE01D" -> 3
+        "\uE01E" -> 3
+        "\uE01F" -> 3
+        "\uE020" -> 3
+        "\uE021" -> 3
+        "\uE022" -> 3
+        "\uE023" -> 3
+        "\uE024" -> 3
+        "\uE025" -> 3
+        "\uE026" -> 3
+        "\uE027" -> 3
+        "\uE028" -> 3
+        "\uE029" -> 3
+        "\uE03D" -> 1
+        "\uE050" -> 2
+        "\uE051" -> 2
+        "\uE052" -> 2
+        "\uE053" -> 2
+        "\uE054" -> 3
+        "\uE055" -> 3
+        "\uE056" -> 3
+        "\uE057" -> 3
+        "\uE058" -> 3
+        "\uE059" -> 3
+        "\uE05A" -> 3
+        "\uE05B" -> 3
+        "\uE05C" -> 3
+        "\uE05D" -> 3
+        else -> 0
+    }
+}

package/espresso-server/app/src/androidTest/java/io/appium/espressoserver/lib/helpers/w3c/dispatcher/constants/KeyNormalizer.kt

@@ -0,0 +1,84 @@
+package io.appium.espressoserver.lib.helpers.w3c.dispatcher.constants
+
+object KeyNormalizer {
+    private val normalizedKeyMap = mutableMapOf<String, String>()
+
+    fun toNormalizedKey(key: String): String {
+        return if (normalizedKeyMap.containsKey(key)) {
+            normalizedKeyMap[key]!!
+        } else key
+    }
+
+    init {
+        normalizedKeyMap["\uE000"] = NormalizedKeys.UNIDENTIFIED
+        normalizedKeyMap["\uE001"] = NormalizedKeys.CANCEL
+        normalizedKeyMap["\uE002"] = NormalizedKeys.HELP
+        normalizedKeyMap["\uE003"] = NormalizedKeys.BACKSPACE
+        normalizedKeyMap["\uE004"] = NormalizedKeys.TAB
+        normalizedKeyMap["\uE005"] = NormalizedKeys.CLEAR
+        normalizedKeyMap["\uE006"] = NormalizedKeys.RETURN
+        normalizedKeyMap["\uE007"] = NormalizedKeys.ENTER
+        normalizedKeyMap["\uE008"] = NormalizedKeys.SHIFT
+        normalizedKeyMap["\uE009"] = NormalizedKeys.CONTROL
+        normalizedKeyMap["\uE00A"] = NormalizedKeys.ALT
+        normalizedKeyMap["\uE00B"] = NormalizedKeys.PAUSE
+        normalizedKeyMap["\uE00C"] = NormalizedKeys.ESCAPE
+        normalizedKeyMap["\uE00D"] = NormalizedKeys.WHITESPACE
+        normalizedKeyMap["\uE00E"] = NormalizedKeys.PAGEUP
+        normalizedKeyMap["\uE00F"] = NormalizedKeys.PAGEDOWN
+        normalizedKeyMap["\uE010"] = NormalizedKeys.END
+        normalizedKeyMap["\uE011"] = NormalizedKeys.HOME
+        normalizedKeyMap["\uE012"] = NormalizedKeys.ARROW_LEFT
+        normalizedKeyMap["\uE013"] = NormalizedKeys.ARROW_UP
+        normalizedKeyMap["\uE014"] = NormalizedKeys.ARROW_RIGHT
+        normalizedKeyMap["\uE015"] = NormalizedKeys.ARROW_DOWN
+        normalizedKeyMap["\uE016"] = NormalizedKeys.INSERT
+        normalizedKeyMap["\uE017"] = NormalizedKeys.DELETE
+        normalizedKeyMap["\uE018"] = NormalizedKeys.SEMICOLON
+        normalizedKeyMap["\uE019"] = NormalizedKeys.EQUALS
+        normalizedKeyMap["\uE01A"] = NormalizedKeys.ZERO
+        normalizedKeyMap["\uE01B"] = NormalizedKeys.ONE
+        normalizedKeyMap["\uE01C"] = NormalizedKeys.TWO
+        normalizedKeyMap["\uE01D"] = NormalizedKeys.THREE
+        normalizedKeyMap["\uE01E"] = NormalizedKeys.FOUR
+        normalizedKeyMap["\uE01F"] = NormalizedKeys.FIVE
+        normalizedKeyMap["\uE020"] = NormalizedKeys.SIX
+        normalizedKeyMap["\uE021"] = NormalizedKeys.SEVEN
+        normalizedKeyMap["\uE022"] = NormalizedKeys.EIGHT
+        normalizedKeyMap["\uE023"] = NormalizedKeys.NINE
+        normalizedKeyMap["\uE024"] = NormalizedKeys.ASTERISK
+        normalizedKeyMap["\uE025"] = NormalizedKeys.PLUS
+        normalizedKeyMap["\uE026"] = NormalizedKeys.COMMA
+        normalizedKeyMap["\uE027"] = NormalizedKeys.HYPHEN
+        normalizedKeyMap["\uE028"] = NormalizedKeys.PERIOD
+        normalizedKeyMap["\uE029"] = NormalizedKeys.FORWARD_SLASH
+        normalizedKeyMap["\uE031"] = NormalizedKeys.F1
+        normalizedKeyMap["\uE032"] = NormalizedKeys.F2
+        normalizedKeyMap["\uE033"] = NormalizedKeys.F3
+        normalizedKeyMap["\uE034"] = NormalizedKeys.F4
+        normalizedKeyMap["\uE035"] = NormalizedKeys.F5
+        normalizedKeyMap["\uE036"] = NormalizedKeys.F6
+        normalizedKeyMap["\uE037"] = NormalizedKeys.F7
+        normalizedKeyMap["\uE038"] = NormalizedKeys.F8
+        normalizedKeyMap["\uE039"] = NormalizedKeys.F9
+        normalizedKeyMap["\uE03A"] = NormalizedKeys.F10
+        normalizedKeyMap["\uE03B"] = NormalizedKeys.F11
+        normalizedKeyMap["\uE03C"] = NormalizedKeys.F12
+        normalizedKeyMap["\uE03D"] = NormalizedKeys.META
+        normalizedKeyMap["\uE040"] = NormalizedKeys.ZENKAKU_HANKAKU
+        normalizedKeyMap["\uE050"] = NormalizedKeys.SHIFT
+        normalizedKeyMap["\uE051"] = NormalizedKeys.CONTROL
+        normalizedKeyMap["\uE052"] = NormalizedKeys.ALT
+        normalizedKeyMap["\uE053"] = NormalizedKeys.META
+        normalizedKeyMap["\uE054"] = NormalizedKeys.PAGEUP
+        normalizedKeyMap["\uE055"] = NormalizedKeys.PAGEDOWN
+        normalizedKeyMap["\uE056"] = NormalizedKeys.END
+        normalizedKeyMap["\uE057"] = NormalizedKeys.HOME
+        normalizedKeyMap["\uE058"] = NormalizedKeys.ARROW_LEFT
+        normalizedKeyMap["\uE059"] = NormalizedKeys.ARROW_UP
+        normalizedKeyMap["\uE05A"] = NormalizedKeys.ARROW_RIGHT
+        normalizedKeyMap["\uE05B"] = NormalizedKeys.ARROW_DOWN
+        normalizedKeyMap["\uE05C"] = NormalizedKeys.INSERT
+        normalizedKeyMap["\uE05D"] = NormalizedKeys.DELETE
+    }
+}

package/espresso-server/app/src/androidTest/java/io/appium/espressoserver/lib/helpers/w3c/dispatcher/constants/NormalizedKeys.kt

@@ -0,0 +1,60 @@
+package io.appium.espressoserver.lib.helpers.w3c.dispatcher.constants
+
+object NormalizedKeys {
+    const val UNIDENTIFIED = "UNIDENTIFIED"
+    const val CANCEL = "CANCEL"
+    const val HELP = "HELP"
+    const val BACKSPACE = "BACKSPACE"
+    const val TAB = "TAB"
+    const val CLEAR = "CLEAR"
+    const val RETURN = "RETURN"
+    const val ENTER = "ENTER"
+    const val PAUSE = "PAUSE"
+    const val ESCAPE = "ESCAPE"
+    const val WHITESPACE = " "
+    const val SEMICOLON = ";"
+    const val EQUALS = "="
+    const val ZERO = "0"
+    const val ONE = "1"
+    const val TWO = "2"
+    const val THREE = "3"
+    const val FOUR = "4"
+    const val FIVE = "5"
+    const val SIX = "6"
+    const val SEVEN = "7"
+    const val EIGHT = "8"
+    const val NINE = "9"
+    const val ASTERISK = "*"
+    const val PLUS = "+"
+    const val COMMA = ","
+    const val HYPHEN = "-"
+    const val PERIOD = "."
+    const val FORWARD_SLASH = "/"
+    const val F1 = "F1"
+    const val F2 = "F2"
+    const val F3 = "F3"
+    const val F4 = "F4"
+    const val F5 = "F5"
+    const val F6 = "F6"
+    const val F7 = "F7"
+    const val F8 = "F8"
+    const val F9 = "F9"
+    const val F10 = "F10"
+    const val F11 = "F11"
+    const val F12 = "F12"
+    const val ZENKAKU_HANKAKU = "ZENKAKUHANKAKU"
+    const val SHIFT = "SHIFT"
+    const val CONTROL = "CONTROL"
+    const val ALT = "ALT"
+    const val META = "META"
+    const val PAGEUP = "PAGEUP"
+    const val PAGEDOWN = "PAGEDOWN"
+    const val END = "END"
+    const val HOME = "HOME"
+    const val ARROW_LEFT = "ARROWLEFT"
+    const val ARROW_UP = "ARROWUP"
+    const val ARROW_RIGHT = "ARROWRIGHT"
+    const val ARROW_DOWN = "ARROWDOWN"
+    const val INSERT = "INSERT"
+    const val DELETE = "DELETE"
+}