appium-espresso-driver 1.46.0

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

@@ -0,0 +1,153 @@
+package io.appium.espressoserver.lib.helpers.w3c.adapter.espresso
+
+import android.os.SystemClock
+import android.view.MotionEvent
+import android.view.MotionEvent.PointerProperties
+import androidx.test.espresso.InjectEventSecurityException
+import androidx.test.espresso.UiController
+import io.appium.espressoserver.lib.handlers.exceptions.AppiumException
+import io.appium.espressoserver.lib.handlers.exceptions.MoveTargetOutOfBoundsException
+import io.appium.espressoserver.lib.helpers.AndroidLogger
+import io.appium.espressoserver.lib.helpers.w3c.models.InputSource
+
+class MotionEventBuilder {
+    private val motionEventParams: MotionEventParams
+    fun withX(x: List<Long>?): MotionEventBuilder = apply { motionEventParams.x = x }
+    fun withY(y: List<Long>?): MotionEventBuilder = apply { motionEventParams.y = y }
+    fun withX(x: Long): MotionEventBuilder = apply { motionEventParams.x = listOf(x) }
+    fun withY(y: Long): MotionEventBuilder = apply { motionEventParams.y = listOf(y) }
+    fun withDownTime(downTime: Long): MotionEventBuilder = apply { motionEventParams.downTime = downTime }
+    fun withEventTime(eventTime: Long): MotionEventBuilder = apply { motionEventParams.eventTime = eventTime }
+    fun withAction(action: Int): MotionEventBuilder = apply { motionEventParams.action = action }
+    fun withMetaState(metaState: Int): MotionEventBuilder = apply { motionEventParams.metaState = metaState }
+    fun withButtonState(buttonState: Int): MotionEventBuilder = apply { motionEventParams.buttonState = buttonState }
+    fun withXPrecision(xPrecision: Float): MotionEventBuilder = apply { motionEventParams.xPrecision = xPrecision }
+    fun withYPrecision(yPrecision: Float): MotionEventBuilder = apply { motionEventParams.yPrecision = yPrecision }
+    fun withDeviceId(deviceId: Int): MotionEventBuilder = apply { motionEventParams.deviceId = deviceId }
+    fun withSource(source: Int): MotionEventBuilder = apply { motionEventParams.source = source }
+    fun withEdgeFlags(edgeFlags: Int): MotionEventBuilder = apply { motionEventParams.edgeFlags = edgeFlags }
+    fun withPointerType(pointerType: InputSource.PointerType?): MotionEventBuilder = apply { motionEventParams.pointerType = pointerType }
+
+    fun build(): MotionEventRunner {
+        return MotionEventRunner(motionEventParams)
+    }
+
+    class MotionEventParams {
+        var downTime: Long = 0
+        var action = 0
+        var x: List<Long>? = null
+        var y: List<Long>? = null
+        var metaState = 0
+        var xPrecision = 0f
+        var yPrecision = 0f
+        var deviceId = 0
+        var edgeFlags = 0
+        var buttonState = 0
+        var source = 0
+        var pointerType: InputSource.PointerType? = null
+        var eventTime: Long = 0
+    }
+
+    class MotionEventRunner(private val motionEventParams: MotionEventParams) {
+        @Throws(AppiumException::class)
+        fun run(uiController: UiController): MotionEvent? {
+            var pointerCount = if (motionEventParams.x == null) 0 else motionEventParams.x!!.size
+
+            // Don't do anything if no pointers were provided
+            if (pointerCount == 0 && motionEventParams.action != MotionEvent.ACTION_CANCEL) {
+                return null
+            }
+            val pointerCoords = arrayOfNulls<MotionEvent.PointerCoords>(pointerCount)
+            val pointerProperties = arrayOfNulls<PointerProperties>(pointerCount)
+            for (pointerIndex in 0 until pointerCount) {
+                // Set pointer coordinates
+                pointerCoords[pointerIndex] = MotionEvent.PointerCoords()
+                pointerCoords[pointerIndex]!!.let {
+                    it.clear()
+                    it.pressure = 1f
+                    it.size = 1f
+                    it.x = motionEventParams.x!![pointerIndex].toFloat()
+                    it.y = motionEventParams.y!![pointerIndex].toFloat()
+                }
+
+                // Set pointer properties
+                pointerProperties[pointerIndex] = PointerProperties()
+                pointerProperties[pointerIndex]!!.let {
+                    it.toolType = getToolType(motionEventParams.pointerType)
+                    it.id = pointerIndex
+                }
+            }
+
+            // ACTION_POINTER_DOWN and ACTION_POINTER_UP need a bit mask
+            var action = motionEventParams.action
+            if (pointerCount > 1 && (action == MotionEvent.ACTION_POINTER_DOWN || action == MotionEvent.ACTION_POINTER_UP)) {
+                action += pointerProperties[1]!!.id shl MotionEvent.ACTION_POINTER_INDEX_SHIFT
+            }
+
+            // ACTION_DOWN and ACTION_UP and ACTION_CANCEL has a pointer count of 1
+            if (action == MotionEvent.ACTION_DOWN || action == MotionEvent.ACTION_UP || action == MotionEvent.ACTION_CANCEL) {
+                pointerCount = if (motionEventParams.x != null && motionEventParams.y != null) {
+                    1
+                } else {
+                    0
+                }
+            }
+            val eventTime = if (motionEventParams.eventTime > 0) motionEventParams.eventTime else SystemClock.uptimeMillis()
+            AndroidLogger.info(String.format(
+                    "Running Android MotionEvent.obtain with parameters: " +
+                            "downTime=[%s], eventTime=[%s], action=[%s], pointerCount=[%s], " + "" +
+                            "pointerProperties=[%s], pointerCoords=[%s], metaState=[%s], buttonState=[%s], " +
+                            "xPrecision=[%s], yPrecision=[%s], deviceId=[%s], edgeFlags=[%s], source=[%s], " +
+                            "flags=[%s]",
+                    "For more information, see https://developer.android.com/reference/android/view/MotionEvent#obtain(long,%20long,%20int,%20int,%20android.view.MotionEvent.PointerProperties[],%20android.view.MotionEvent.PointerCoords[],%20int,%20int,%20float,%20float,%20int,%20int,%20int,%20int)",
+                    motionEventParams.downTime,
+                    eventTime,
+                    action,
+                    pointerCount,
+                    pointerProperties.contentToString(),
+                    pointerCoords.contentToString(),
+                    motionEventParams.metaState,
+                    motionEventParams.buttonState,
+                    motionEventParams.xPrecision,
+                    motionEventParams.yPrecision,
+                    motionEventParams.deviceId,
+                    motionEventParams.edgeFlags,
+                    motionEventParams.source,
+                    0
+            ))
+            val evt = MotionEvent.obtain(
+                    motionEventParams.downTime,
+                    eventTime,
+                    action,
+                    pointerCount,
+                    pointerProperties,
+                    pointerCoords,
+                    motionEventParams.metaState,
+                    motionEventParams.buttonState,
+                    motionEventParams.xPrecision,
+                    motionEventParams.yPrecision,
+                    motionEventParams.deviceId,
+                    motionEventParams.edgeFlags,
+                    motionEventParams.source,
+                    0 // MotionEvent flags. Don't think we need to set these.
+            )
+            try {
+                val success = uiController.injectMotionEvent(evt)
+                if (!success) {
+                    throw AppiumException("Could not complete pointer operation")
+                }
+            } catch (e: InjectEventSecurityException) {
+                throw MoveTargetOutOfBoundsException(String.format(
+                        "Could not complete pointer operation. Pointer operation is within the viewport but is not within bounds of the app-under-test. Cause: %s",
+                        e.cause
+                ))
+            }
+            return evt
+        }
+
+    }
+
+    init {
+        motionEventParams = MotionEventParams()
+    }
+}

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

@@ -0,0 +1,132 @@
+package io.appium.espressoserver.lib.helpers.w3c.adapter.espresso
+
+import android.os.SystemClock
+import android.view.MotionEvent
+import androidx.test.espresso.UiController
+import io.appium.espressoserver.lib.handlers.exceptions.AppiumException
+import io.appium.espressoserver.lib.helpers.w3c.adapter.espresso.AndroidMotionEvent.Companion.getTouchMotionEvent
+import io.appium.espressoserver.lib.helpers.w3c.models.InputSource
+import io.appium.espressoserver.lib.helpers.w3c.state.KeyInputState
+import java.util.*
+
+class MultiTouchState {
+    private val touchStateSet: MutableMap<String, TouchState> = LinkedHashMap()
+    private var globalKeyInputState: KeyInputState? = null
+    private var button = 0
+    private var downEvent: MotionEvent? = null
+    private var touchPhase: TouchPhase? = null
+    fun updateTouchState(actionType: Int,
+                         sourceId: String,
+                         x: Long?, y: Long?,
+                         globalKeyInputState: KeyInputState?,
+                         button: Int?) {
+
+        // Lazily get the touch state of the input with given sourceId
+        if (!touchStateSet.containsKey(sourceId)) {
+            val touchState = TouchState()
+            touchStateSet[sourceId] = touchState
+        }
+
+        // Update x and y coordinates
+        val touchState = touchStateSet[sourceId]!!
+        touchState.x = x!!
+        touchState.y = y!!
+
+        // Update to global key input state
+        this.globalKeyInputState = globalKeyInputState
+        if (button != null) {
+            this.button = button
+        }
+
+        // Record if we're in the TOUCH_DOWN or TOUCH_UP phase
+        if (actionType == MotionEvent.ACTION_DOWN) {
+            touchPhase = TouchPhase.DOWN
+        } else if (actionType == MotionEvent.ACTION_UP) {
+            touchPhase = TouchPhase.UP
+        }
+    }
+
+    /**
+     * Get the x coordinates for all inputs in the same order they were entered
+     * @return X coordinates as a list
+     */
+    private val xCoords: List<Long>
+        get() { return touchStateSet.values.map { it.x } }
+
+    /**
+     * Get the y coordinates for all inputs in the same order they were entered
+     * @return Y coordinates as a list
+     */
+    private val yCoords: List<Long>
+        get() { return touchStateSet.values.map { it.y } }
+
+    @Throws(AppiumException::class)
+    fun pointerDown(uiController: UiController) {
+        val androidMotionEvent = getTouchMotionEvent(uiController)
+        val eventTime = SystemClock.uptimeMillis()
+        val xCoords = xCoords
+        val yCoords = yCoords
+        downEvent = androidMotionEvent.pointerEvent(
+                xCoords, yCoords,
+                MotionEvent.ACTION_DOWN, button, InputSource.PointerType.TOUCH, globalKeyInputState!!, null, eventTime)
+        if (xCoords.size > 1) {
+            androidMotionEvent.pointerEvent(xCoords, yCoords,
+                    MotionEvent.ACTION_POINTER_DOWN, button, InputSource.PointerType.TOUCH, globalKeyInputState!!, downEvent, eventTime)
+        }
+    }
+
+    @Throws(AppiumException::class)
+    fun pointerUp(uiController: UiController) {
+        val androidMotionEvent = getTouchMotionEvent(uiController)
+        val eventTime = SystemClock.uptimeMillis()
+        val xCoords = xCoords
+        val yCoords = yCoords
+        if (xCoords.size > 1) {
+            androidMotionEvent.pointerEvent(
+                    xCoords, yCoords,
+                    MotionEvent.ACTION_POINTER_UP, button, InputSource.PointerType.TOUCH, globalKeyInputState!!, downEvent, eventTime)
+        }
+        androidMotionEvent.pointerEvent(
+                xCoords, yCoords,
+                MotionEvent.ACTION_UP, button, InputSource.PointerType.TOUCH, globalKeyInputState!!, downEvent, eventTime)
+        downEvent = null
+    }
+
+    @Throws(AppiumException::class)
+    fun pointerCancel(uiController: UiController) {
+        val xCoords = xCoords
+        val yCoords = yCoords
+        getTouchMotionEvent(uiController).pointerEvent(
+                xCoords, yCoords,
+                MotionEvent.ACTION_CANCEL, button, InputSource.PointerType.TOUCH, globalKeyInputState!!, downEvent, SystemClock.uptimeMillis()
+        )
+        downEvent = null
+        touchPhase = TouchPhase.NONE
+    }
+
+    @Throws(AppiumException::class)
+    fun pointerMove(uiController: UiController) {
+        if (isDown) {
+            val androidMotionEvent = getTouchMotionEvent(uiController)
+            androidMotionEvent.pointerMove(
+                    xCoords, yCoords, InputSource.PointerType.TOUCH, globalKeyInputState!!, downEvent)
+        }
+    }
+
+    val isDown: Boolean
+        get() = downEvent != null
+
+    @Throws(AppiumException::class)
+    fun perform(uiController: UiController) {
+        if (touchPhase == TouchPhase.DOWN) {
+            pointerDown(uiController)
+        } else if (touchPhase == TouchPhase.UP) {
+            pointerUp(uiController)
+        }
+        touchPhase = TouchPhase.NONE
+    }
+
+    enum class TouchPhase {
+        DOWN, UP, NONE
+    }
+}

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

@@ -0,0 +1,7 @@
+package io.appium.espressoserver.lib.helpers.w3c.adapter.espresso
+
+class TouchState {
+    var x: Long = 0
+    var y: Long = 0
+    var sourceId: String? = null
+}

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

@@ -0,0 +1,96 @@
+/*
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * See the NOTICE file distributed with this work for additional
+ * information regarding copyright ownership.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.appium.espressoserver.lib.helpers.w3c.caps
+
+import io.appium.espressoserver.lib.helpers.AndroidLogger
+import io.appium.espressoserver.lib.handlers.exceptions.InvalidArgumentException
+
+
+val STANDARD_CAPS = listOf(
+        "browserName",
+        "browserVersion",
+        "platformName",
+        "acceptInsecureCerts",
+        "pageLoadStrategy",
+        "proxy",
+        "setWindowRect",
+        "timeouts",
+        "unhandledPromptBehavior"
+)
+const val APPIUM_PREFIX = "appium"
+
+
+fun isStandardCap(capName: String): Boolean = STANDARD_CAPS.any { it.toLowerCase() == capName.toLowerCase() }
+
+
+fun mergeCaps(primary: Map<String, Any?>, secondary: Map<String, Any?>): Map<String, Any?> {
+    val result = primary.toMutableMap()
+    secondary.mapValues {
+        if (result[it.key] != null) {
+            throw InvalidArgumentException(
+                    "Property '${it.key}' should not exist on both primary ($primary) and secondary ($secondary) objects")
+        }
+        result[it.key] = it.value
+    }
+    return result
+}
+
+
+fun stripPrefixes(caps: Map<String, Any?>): Map<String, Any?> {
+    val prefix = "$APPIUM_PREFIX:"
+    val badPrefixedCaps = caps.keys
+            .filter { it.startsWith(prefix) }
+            .fold(mutableListOf<String>(), { acc, capName ->
+                val strippedName = capName.substring(prefix.length)
+                if (isStandardCap(strippedName)) {
+                    acc.add(strippedName)
+                }
+                acc
+            })
+    if (badPrefixedCaps.isNotEmpty()) {
+        throw InvalidArgumentException(
+                "The capabilities $badPrefixedCaps are standard capabilities and should not have the '$prefix' prefix")
+    }
+
+    return caps.map {
+        if (it.key.startsWith(prefix) && it.key.length > prefix.length)
+            it.key.substring(prefix.length) to it.value
+        else
+            it.key to it.value
+    }.toMap()
+}
+
+
+fun parseCapabilities(firstMatchValue: List<Map<String, Any?>>?,
+                      alwaysMatchValue: Map<String, Any?>?): Map<String, Any?> {
+    val alwaysMatch = alwaysMatchValue ?: mapOf()
+    val firstMatch = firstMatchValue ?: listOf()
+
+    val allFirstMatchCaps = if (firstMatch.isNotEmpty()) firstMatch else listOf<Map<*, *>>(mapOf<String, Any?>())
+    val requiredCaps = stripPrefixes(alwaysMatch)
+    @Suppress("UNCHECKED_CAST")
+    (allFirstMatchCaps as List<Map<String, Any?>>)
+            .map { stripPrefixes(it) }
+            .forEach {
+                try {
+                    return mergeCaps(requiredCaps, it)
+                } catch (e: Exception) {
+                    AndroidLogger.warn(e)
+                }
+            }
+    throw InvalidArgumentException("Could not find matching capabilities from {$firstMatch, $alwaysMatch}")
+}

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

@@ -0,0 +1,14 @@
+package io.appium.espressoserver.lib.helpers.w3c.dispatcher
+
+import io.appium.espressoserver.lib.handlers.exceptions.AppiumException
+import java.util.concurrent.Callable
+
+abstract class BaseDispatchResult {
+    var next: Callable<BaseDispatchResult>? = null
+    operator fun hasNext(): Boolean {
+        return next != null
+    }
+
+    @Throws(AppiumException::class)
+    abstract fun perform()
+}

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

@@ -0,0 +1,22 @@
+package io.appium.espressoserver.lib.helpers.w3c.dispatcher
+
+import io.appium.espressoserver.lib.handlers.exceptions.AppiumException
+import io.appium.espressoserver.lib.helpers.w3c.adapter.W3CActionAdapter
+import io.appium.espressoserver.lib.helpers.w3c.models.InputSource
+import io.appium.espressoserver.lib.helpers.w3c.state.KeyInputState
+
+class DispatchPointerMoveResult(private val dispatcherAdapter: W3CActionAdapter,
+                                private val sourceId: String,
+                                private val pointerType: InputSource.PointerType,
+                                private val currentX: Float, private val currentY: Float,
+                                private val x: Float, private val y: Float,
+                                private val buttons: Set<Int>,
+                                private val globalKeyInputState: KeyInputState?) : BaseDispatchResult() {
+    @Throws(AppiumException::class)
+    override fun perform() {
+        if (currentX != x || currentY != y) {
+            dispatcherAdapter.pointerMove(sourceId, pointerType, currentX, currentY, x, y, buttons, globalKeyInputState)
+        }
+    }
+
+}

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

@@ -0,0 +1,151 @@
+package io.appium.espressoserver.lib.helpers.w3c.dispatcher
+
+import io.appium.espressoserver.lib.handlers.exceptions.AppiumException
+import io.appium.espressoserver.lib.helpers.w3c.adapter.W3CActionAdapter
+import io.appium.espressoserver.lib.helpers.w3c.dispatcher.constants.KeyNormalizer
+import io.appium.espressoserver.lib.helpers.w3c.dispatcher.constants.NormalizedKeys
+import io.appium.espressoserver.lib.helpers.w3c.dispatcher.constants.getCode
+import io.appium.espressoserver.lib.helpers.w3c.dispatcher.constants.getLocation
+import io.appium.espressoserver.lib.helpers.w3c.models.ActionObject
+import io.appium.espressoserver.lib.helpers.w3c.models.InputSource
+import io.appium.espressoserver.lib.helpers.w3c.state.InputStateTable
+import io.appium.espressoserver.lib.helpers.w3c.state.KeyInputState
+
+/**
+ * Implement key dispatch events (https://www.w3.org/TR/webdriver/#keyboard-actions)
+ */
+@Throws(AppiumException::class)
+private fun dispatchKeyEvent(dispatcherAdapter: W3CActionAdapter,
+                             actionObject: ActionObject,
+                             inputState: KeyInputState,
+                             inputStateTable: InputStateTable,
+                             @Suppress("UNUSED_PARAMETER") tickDuration: Float,
+                             down: Boolean): W3CKeyEvent {
+    // Get the base Key Event
+    val keyEvent = getKeyEvent(dispatcherAdapter, actionObject.value!!)
+    val key = keyEvent.key!!
+
+    // 3. If the input state's pressed property contains key, let repeat be true, otherwise let repeat be false.
+    if (inputState.isPressed(key)) {
+        keyEvent.isRepeat = true
+    }
+
+    // 6. Let charCode, keyCode and which be the implementation-specific values of the charCode,
+    // keyCode and which properties.
+    // Omiting this for now until there's an implementation that needs it.
+
+    // 7-10: Set the alt, shift, ctrl meta key state
+    dispatcherAdapter.logger.info(String.format(
+            "Dispatching '%s' event on input source with id %s with properties '%s'",
+            if (down) "keyDown" else "keyUp", actionObject.id, keyEvent.logMessage()
+    ))
+    if (down) {
+        inputState.isAlt = inputState.isAlt || key == NormalizedKeys.ALT
+        inputState.isShift = inputState.isShift || key == NormalizedKeys.SHIFT
+        inputState.isCtrl = inputState.isCtrl || key == NormalizedKeys.CONTROL
+        inputState.isMeta = inputState.isMeta || key == NormalizedKeys.META
+    } else {
+        inputState.isAlt = inputState.isAlt && key != NormalizedKeys.ALT
+        inputState.isShift = inputState.isShift && key != NormalizedKeys.SHIFT
+        inputState.isCtrl = inputState.isCtrl && key != NormalizedKeys.CONTROL
+        inputState.isMeta = inputState.isMeta && key != NormalizedKeys.META
+    }
+
+    // Set the alt, shift, ctrl and meta states on the Key Event
+    keyEvent.isAltKey = inputState.isAlt
+    keyEvent.isCtrlKey = inputState.isCtrl
+    keyEvent.isShiftKey = inputState.isShift
+    keyEvent.isMetaKey = inputState.isMeta
+
+    // 11: Add key to the set corresponding to input state's pressed property
+    if (down) {
+        inputState.addPressed(key)
+    } else {
+        inputState.removePressed(key)
+    }
+
+    // Must lock the dispatcherAdapter in-case other threads are also using it
+    dispatcherAdapter.lockAdapter()
+    try {
+        if (down) {
+
+            // 12: Append action object with subtype property changed to 'keyUp' to cancel list
+            val cancelActionObject = ActionObject(actionObject)
+            cancelActionObject.subType = InputSource.ActionType.KEY_UP
+            inputStateTable.addActionToCancel(cancelActionObject)
+
+            // 13: Call implementation specific key-down event
+            dispatcherAdapter.keyDown(keyEvent)
+        } else {
+            // 13: Call implementation specific key-up event
+            dispatcherAdapter.keyUp(keyEvent)
+        }
+    } finally {
+        dispatcherAdapter.unlockAdapter()
+    }
+
+    // Log the updated keyboard state
+    dispatcherAdapter.logger.info(String.format(
+            "Current state of key input source with id: %s",
+            inputState.logMessage()
+    ))
+    return keyEvent
+}
+
+/**
+ * Dispatch a key down event (in accordance with https://www.w3.org/TR/webdriver/#keyboard-actions)
+ *
+ * @param dispatcherAdapter Adapter that has implementation specific keyDown event
+ * @param actionObject W3C Action Object
+ * @param inputState State of the input source
+ * @param inputStateTable All of the input states for this session
+ * @param tickDuration How long the 'tick' is. This is unused currently but may be used in the future
+ * @return W3CKeyEvent (for testing purposes). 'null' if the dispatch failed.
+ */
+@Throws(AppiumException::class)
+fun dispatchKeyDown(dispatcherAdapter: W3CActionAdapter,
+                    actionObject: ActionObject, inputState: KeyInputState,
+                    inputStateTable: InputStateTable, tickDuration: Float = 0f): W3CKeyEvent? =
+     dispatchKeyEvent(dispatcherAdapter, actionObject, inputState, inputStateTable, tickDuration, true)
+
+/**
+ * Dispatch a key up event (in accordance with https://www.w3.org/TR/webdriver/#keyboard-actions)
+ *
+ * @param dispatcherAdapter Adapter that has implementation specific keyDown event
+ * @param actionObject W3C Action Object
+ * @param inputState State of the input source
+ * @param inputStateTable All of the input states for this session
+ * @param tickDuration How long the 'tick' is. This is unused currently but may be used in the future
+ * @return W3CKeyEvent (for testing purposes). 'null' if the dispatch failed.
+ */
+@Throws(AppiumException::class)
+fun dispatchKeyUp(dispatcherAdapter: W3CActionAdapter,
+                  actionObject: ActionObject, inputState: KeyInputState,
+                  inputStateTable: InputStateTable, tickDuration: Float = 0f): W3CKeyEvent? =
+        dispatchKeyEvent(dispatcherAdapter, actionObject, inputState, inputStateTable, tickDuration, false)
+
+/**
+ * Helper method to get a Key Event that has common attributes between KeyUp and KeyDispatch
+ * @param rawKey The value of the key stroke
+ * @return W3CKeyEvent Key event info used by adapter
+ */
+@Throws(AppiumException::class)
+fun getKeyEvent(dispatcherAdapter: W3CActionAdapter, rawKey: String): W3CKeyEvent = W3CKeyEvent().apply {
+    // 1. Let raw key be action's value property
+
+    // 2. Let key be equal to the normalised key value for raw key
+    this.key = KeyNormalizer.toNormalizedKey(rawKey)
+
+    // 4. Let code be 'code' for raw keypress
+    this.code = getCode(rawKey)
+
+    // 5. Let location be the key location for raw key
+    this.location = getLocation(rawKey)
+
+    // 6. Let charCode, keyCode and which be the implementation-specific values of the charCode,
+    // keyCode and which properties appropriate for a key with key key and location location on
+    // a 102 key US keyboard
+    this.keyCode = dispatcherAdapter.getKeyCode(this.key, this.location)
+    this.charCode = dispatcherAdapter.getCharCode(this.code, this.location)
+    this.which = dispatcherAdapter.getWhich(this.key, this.location)
+}