appium-espresso-driver 1.46.0

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

@@ -0,0 +1,71 @@
+package io.appium.espressoserver.lib.helpers.w3c.adapter
+
+import android.graphics.Point
+
+import io.appium.espressoserver.lib.handlers.exceptions.AppiumException
+import io.appium.espressoserver.lib.helpers.Logger
+import io.appium.espressoserver.lib.helpers.w3c.dispatcher.W3CKeyEvent
+import io.appium.espressoserver.lib.helpers.w3c.models.InputSource.PointerType
+import io.appium.espressoserver.lib.helpers.w3c.state.KeyInputState
+import io.appium.espressoserver.lib.helpers.w3c.state.PointerInputState
+
+interface W3CActionAdapter {
+
+    val viewportWidth: Long
+
+    val viewportHeight: Long
+
+    val logger: Logger
+
+    @Throws(AppiumException::class)
+    fun keyDown(keyDownEvent: W3CKeyEvent)
+
+    @Throws(AppiumException::class)
+    fun keyUp(keyUpEvent: W3CKeyEvent)
+
+    @Throws(AppiumException::class)
+    fun pointerDown(button: Int, sourceId: String, pointerType: PointerType?,
+                    x: Float, y: Float, depressedButtons: Set<Int>,
+                    globalKeyInputState: KeyInputState?)
+
+    @Throws(AppiumException::class)
+    fun pointerUp(button: Int, sourceId: String, pointerType: PointerType?,
+                  x: Float, y: Float, depressedButtons: Set<Int>,
+                  globalKeyInputState: KeyInputState?)
+
+    @Throws(AppiumException::class)
+    fun pointerMove(sourceId: String, pointerType: PointerType?,
+                    currentX: Float, currentY: Float, x: Float, y: Float,
+                    buttons: Set<Int>?, globalKeyInputState: KeyInputState?)
+
+    @Throws(AppiumException::class)
+    fun pointerCancel(sourceId: String, pointerType: PointerType)
+
+    fun lockAdapter()
+
+    fun unlockAdapter()
+
+    @Throws(AppiumException::class)
+    fun getKeyCode(keyValue: String?, location: Int): Int
+
+    @Throws(AppiumException::class)
+    fun getCharCode(keyValue: String?, location: Int): Int
+
+    @Throws(AppiumException::class)
+    fun getWhich(keyValue: String?, location: Int): Int
+
+    fun getPointerMoveDurationMargin(pointerInputState: PointerInputState): Double
+
+    fun pointerMoveIntervalDuration(): Int
+
+    @Throws(AppiumException::class)
+    fun sleep(duration: Float)
+
+    fun waitForUiThread()
+
+    @Throws(AppiumException::class)
+    fun getElementCenterPoint(elementId: String?): Point
+
+    @Throws(AppiumException::class)
+    fun sychronousTickActionsComplete()
+}

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

@@ -0,0 +1,271 @@
+package io.appium.espressoserver.lib.helpers.w3c.adapter.espresso
+
+import android.os.SystemClock
+import android.view.KeyCharacterMap
+import android.view.KeyEvent
+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.InvalidArgumentException
+import io.appium.espressoserver.lib.helpers.AndroidLogger
+import io.appium.espressoserver.lib.helpers.w3c.dispatcher.W3CKeyEvent
+import io.appium.espressoserver.lib.helpers.w3c.dispatcher.constants.NormalizedKeys.ALT
+import io.appium.espressoserver.lib.helpers.w3c.dispatcher.constants.NormalizedKeys.ARROW_DOWN
+import io.appium.espressoserver.lib.helpers.w3c.dispatcher.constants.NormalizedKeys.ARROW_LEFT
+import io.appium.espressoserver.lib.helpers.w3c.dispatcher.constants.NormalizedKeys.ARROW_RIGHT
+import io.appium.espressoserver.lib.helpers.w3c.dispatcher.constants.NormalizedKeys.ARROW_UP
+import io.appium.espressoserver.lib.helpers.w3c.dispatcher.constants.NormalizedKeys.ASTERISK
+import io.appium.espressoserver.lib.helpers.w3c.dispatcher.constants.NormalizedKeys.BACKSPACE
+import io.appium.espressoserver.lib.helpers.w3c.dispatcher.constants.NormalizedKeys.CLEAR
+import io.appium.espressoserver.lib.helpers.w3c.dispatcher.constants.NormalizedKeys.COMMA
+import io.appium.espressoserver.lib.helpers.w3c.dispatcher.constants.NormalizedKeys.CONTROL
+import io.appium.espressoserver.lib.helpers.w3c.dispatcher.constants.NormalizedKeys.DELETE
+import io.appium.espressoserver.lib.helpers.w3c.dispatcher.constants.NormalizedKeys.EIGHT
+import io.appium.espressoserver.lib.helpers.w3c.dispatcher.constants.NormalizedKeys.END
+import io.appium.espressoserver.lib.helpers.w3c.dispatcher.constants.NormalizedKeys.EQUALS
+import io.appium.espressoserver.lib.helpers.w3c.dispatcher.constants.NormalizedKeys.ESCAPE
+import io.appium.espressoserver.lib.helpers.w3c.dispatcher.constants.NormalizedKeys.F1
+import io.appium.espressoserver.lib.helpers.w3c.dispatcher.constants.NormalizedKeys.F10
+import io.appium.espressoserver.lib.helpers.w3c.dispatcher.constants.NormalizedKeys.F11
+import io.appium.espressoserver.lib.helpers.w3c.dispatcher.constants.NormalizedKeys.F12
+import io.appium.espressoserver.lib.helpers.w3c.dispatcher.constants.NormalizedKeys.F2
+import io.appium.espressoserver.lib.helpers.w3c.dispatcher.constants.NormalizedKeys.F3
+import io.appium.espressoserver.lib.helpers.w3c.dispatcher.constants.NormalizedKeys.F4
+import io.appium.espressoserver.lib.helpers.w3c.dispatcher.constants.NormalizedKeys.F5
+import io.appium.espressoserver.lib.helpers.w3c.dispatcher.constants.NormalizedKeys.F6
+import io.appium.espressoserver.lib.helpers.w3c.dispatcher.constants.NormalizedKeys.F7
+import io.appium.espressoserver.lib.helpers.w3c.dispatcher.constants.NormalizedKeys.F8
+import io.appium.espressoserver.lib.helpers.w3c.dispatcher.constants.NormalizedKeys.F9
+import io.appium.espressoserver.lib.helpers.w3c.dispatcher.constants.NormalizedKeys.FIVE
+import io.appium.espressoserver.lib.helpers.w3c.dispatcher.constants.NormalizedKeys.FORWARD_SLASH
+import io.appium.espressoserver.lib.helpers.w3c.dispatcher.constants.NormalizedKeys.FOUR
+import io.appium.espressoserver.lib.helpers.w3c.dispatcher.constants.NormalizedKeys.HELP
+import io.appium.espressoserver.lib.helpers.w3c.dispatcher.constants.NormalizedKeys.HOME
+import io.appium.espressoserver.lib.helpers.w3c.dispatcher.constants.NormalizedKeys.HYPHEN
+import io.appium.espressoserver.lib.helpers.w3c.dispatcher.constants.NormalizedKeys.INSERT
+import io.appium.espressoserver.lib.helpers.w3c.dispatcher.constants.NormalizedKeys.META
+import io.appium.espressoserver.lib.helpers.w3c.dispatcher.constants.NormalizedKeys.NINE
+import io.appium.espressoserver.lib.helpers.w3c.dispatcher.constants.NormalizedKeys.ONE
+import io.appium.espressoserver.lib.helpers.w3c.dispatcher.constants.NormalizedKeys.PAGEDOWN
+import io.appium.espressoserver.lib.helpers.w3c.dispatcher.constants.NormalizedKeys.PAGEUP
+import io.appium.espressoserver.lib.helpers.w3c.dispatcher.constants.NormalizedKeys.PAUSE
+import io.appium.espressoserver.lib.helpers.w3c.dispatcher.constants.NormalizedKeys.PERIOD
+import io.appium.espressoserver.lib.helpers.w3c.dispatcher.constants.NormalizedKeys.PLUS
+import io.appium.espressoserver.lib.helpers.w3c.dispatcher.constants.NormalizedKeys.RETURN
+import io.appium.espressoserver.lib.helpers.w3c.dispatcher.constants.NormalizedKeys.SEMICOLON
+import io.appium.espressoserver.lib.helpers.w3c.dispatcher.constants.NormalizedKeys.SEVEN
+import io.appium.espressoserver.lib.helpers.w3c.dispatcher.constants.NormalizedKeys.SHIFT
+import io.appium.espressoserver.lib.helpers.w3c.dispatcher.constants.NormalizedKeys.SIX
+import io.appium.espressoserver.lib.helpers.w3c.dispatcher.constants.NormalizedKeys.TAB
+import io.appium.espressoserver.lib.helpers.w3c.dispatcher.constants.NormalizedKeys.THREE
+import io.appium.espressoserver.lib.helpers.w3c.dispatcher.constants.NormalizedKeys.TWO
+import io.appium.espressoserver.lib.helpers.w3c.dispatcher.constants.NormalizedKeys.UNIDENTIFIED
+import io.appium.espressoserver.lib.helpers.w3c.dispatcher.constants.NormalizedKeys.WHITESPACE
+import io.appium.espressoserver.lib.helpers.w3c.dispatcher.constants.NormalizedKeys.ZENKAKU_HANKAKU
+import io.appium.espressoserver.lib.helpers.w3c.dispatcher.constants.NormalizedKeys.ZERO
+import java.util.*
+
+
+/**
+ * Translate a W3C Key into an Android Key Event (if possible
+ * @param keyValue The W3C normalized key value (https://www.w3.org/TR/webdriver1/#keyboard-actions)
+ * @param location The W3C "key location"
+ * @return
+ */
+fun keyCodeToEvent(keyValue: String?, @Suppress("UNUSED_PARAMETER") location: Int): Int {
+    return when (keyValue) {
+        UNIDENTIFIED -> KeyEvent.KEYCODE_UNKNOWN
+        HELP -> KeyEvent.KEYCODE_HELP
+        BACKSPACE -> KeyEvent.KEYCODE_DEL
+        TAB -> KeyEvent.KEYCODE_TAB
+        CLEAR -> KeyEvent.KEYCODE_CLEAR
+        RETURN -> KeyEvent.KEYCODE_ENTER
+        PAUSE -> KeyEvent.KEYCODE_BREAK
+        ESCAPE -> KeyEvent.KEYCODE_ESCAPE
+        WHITESPACE -> KeyEvent.KEYCODE_SPACE
+        SEMICOLON -> KeyEvent.KEYCODE_SEMICOLON
+        EQUALS -> KeyEvent.KEYCODE_EQUALS
+        ZERO -> KeyEvent.KEYCODE_0
+        ONE -> KeyEvent.KEYCODE_1
+        TWO -> KeyEvent.KEYCODE_2
+        THREE -> KeyEvent.KEYCODE_3
+        FOUR -> KeyEvent.KEYCODE_4
+        FIVE -> KeyEvent.KEYCODE_5
+        SIX -> KeyEvent.KEYCODE_6
+        SEVEN -> KeyEvent.KEYCODE_7
+        EIGHT -> KeyEvent.KEYCODE_8
+        NINE -> KeyEvent.KEYCODE_9
+        ASTERISK -> KeyEvent.KEYCODE_STAR
+        PLUS -> KeyEvent.KEYCODE_NUMPAD_ADD
+        COMMA -> KeyEvent.KEYCODE_COMMA
+        HYPHEN -> KeyEvent.KEYCODE_MINUS
+        PERIOD -> KeyEvent.KEYCODE_PERIOD
+        FORWARD_SLASH -> KeyEvent.KEYCODE_SLASH
+        F1 -> KeyEvent.KEYCODE_F1
+        F2 -> KeyEvent.KEYCODE_F2
+        F3 -> KeyEvent.KEYCODE_F3
+        F4 -> KeyEvent.KEYCODE_F4
+        F5 -> KeyEvent.KEYCODE_F5
+        F6 -> KeyEvent.KEYCODE_F6
+        F7 -> KeyEvent.KEYCODE_F7
+        F8 -> KeyEvent.KEYCODE_F8
+        F9 -> KeyEvent.KEYCODE_F9
+        F10 -> KeyEvent.KEYCODE_F10
+        F11 -> KeyEvent.KEYCODE_F11
+        F12 -> KeyEvent.KEYCODE_F12
+        ZENKAKU_HANKAKU -> KeyEvent.KEYCODE_ZENKAKU_HANKAKU
+        SHIFT -> KeyEvent.KEYCODE_SHIFT_LEFT
+        CONTROL -> KeyEvent.KEYCODE_CTRL_LEFT
+        ALT -> KeyEvent.KEYCODE_ALT_LEFT
+        META -> KeyEvent.KEYCODE_META_LEFT
+        PAGEUP -> KeyEvent.KEYCODE_PAGE_UP
+        PAGEDOWN -> KeyEvent.KEYCODE_PAGE_DOWN
+        END -> KeyEvent.KEYCODE_MOVE_END
+        HOME -> KeyEvent.KEYCODE_HOME
+        ARROW_LEFT -> KeyEvent.KEYCODE_DPAD_LEFT
+        ARROW_UP -> KeyEvent.KEYCODE_DPAD_DOWN
+        ARROW_RIGHT -> KeyEvent.KEYCODE_DPAD_RIGHT
+        ARROW_DOWN -> KeyEvent.KEYCODE_DPAD_DOWN
+        INSERT -> KeyEvent.KEYCODE_INSERT
+        DELETE -> KeyEvent.KEYCODE_FORWARD_DEL
+        else -> -1
+    }
+}
+
+class AndroidKeyEvent(private val uiController: UiController) {
+    private val keyCharacterMap = KeyCharacterMap.load(KeyCharacterMap.VIRTUAL_KEYBOARD)
+    private val keyDownTimes: MutableMap<String?, List<KeyEvent>> = HashMap()
+
+    @Throws(AppiumException::class)
+    fun keyDown(w3cKeyEvent: W3CKeyEvent) {
+        keyUpOrDown(w3cKeyEvent, true)
+    }
+
+    @Throws(AppiumException::class)
+    fun keyUp(w3cKeyEvent: W3CKeyEvent) {
+        keyUpOrDown(w3cKeyEvent, false)
+    }
+
+    /**
+     * Translate a string into a sequence of Android Key Events
+     * @param key A key in String form
+     * @param isDown Returns true if this is a key down events
+     * @param isRepeat Returns true if this is a repeat key down
+     * @param metaState The current global meta state of Android key events
+     * @return
+     * @throws InvalidArgumentException
+     */
+    @Throws(InvalidArgumentException::class)
+    private fun convertStringToAndroidKeyEvents(key: String?, isDown: Boolean,
+                                                isRepeat: Boolean, metaState: Int): List<KeyEvent> {
+        val keyEventsFromChar = keyCharacterMap.getEvents(key!!.toCharArray())
+                ?: throw InvalidArgumentException(String.format("Could not find matching keycode for character %s", key))
+        val now = SystemClock.uptimeMillis()
+        val keyEvents: MutableList<KeyEvent> = ArrayList()
+        var keyEventIndex = 0
+        while (keyEventIndex * 2 < keyEventsFromChar.size) {
+            // getEvents produces UP and DOWN events, so we need to skip over every other event
+            val keyEvent = keyEventsFromChar[keyEventIndex * 2]
+            val downTime = if (isDown) SystemClock.uptimeMillis() else keyDownTimes[key]!![keyEventIndex].downTime
+            keyEvents.add(KeyEvent(
+                    downTime,
+                    if (isDown) downTime else now,
+                    if (isDown) KeyEvent.ACTION_DOWN else KeyEvent.ACTION_UP,
+                    keyEvent.keyCode,
+                    if (isRepeat) 1 else 0,
+                    metaState or keyEvent.metaState,
+                    KeyCharacterMap.VIRTUAL_KEYBOARD, 0, 0
+            ))
+            keyEventIndex++
+        }
+        return keyEvents
+    }
+
+    /**
+     * Dispatch an Android key event
+     * @param w3cKeyEvent Key Event in W3C form (https://www.w3.org/TR/webdriver1/#keyboard-actions)
+     * @param isDown Returns true if it's keyDown, otherwise it's keyUp
+     * @throws AppiumException
+     */
+    @Throws(AppiumException::class)
+    private fun keyUpOrDown(w3cKeyEvent: W3CKeyEvent, isDown: Boolean) {
+        val action = if (isDown) KeyEvent.ACTION_DOWN else KeyEvent.ACTION_UP
+        val key = w3cKeyEvent.key
+        val keyCode = w3cKeyEvent.keyCode
+
+        // No-op if releasing a key that isn't down
+        if (action == KeyEvent.ACTION_UP && !keyDownTimes.containsKey(key)) {
+            return
+        }
+        val keyEvents: List<KeyEvent>
+        keyEvents = if (keyCode >= 0) {
+
+            // If the keyCode is known, send it now
+            val downTime = if (isDown) SystemClock.uptimeMillis() else keyDownTimes[key]!![0].downTime
+            listOf(KeyEvent(
+                    downTime,
+                    if (isDown) downTime else SystemClock.uptimeMillis(),
+                    action,
+                    keyCode,
+                    if (w3cKeyEvent.isRepeat) 1 else 0,
+                    getMetaState(w3cKeyEvent),
+                    KeyCharacterMap.VIRTUAL_KEYBOARD, 0, 0
+            ))
+        } else {
+            // If there's no keyCode, map the characters to Android keys
+            convertStringToAndroidKeyEvents(key, isDown, w3cKeyEvent.isRepeat, getMetaState(w3cKeyEvent))
+        }
+        injectKeyEvents(isDown, keyEvents, key)
+    }
+
+    /**
+     * Get the Android key meta state from a W3C key event
+     * @param keyEvent W3C key event
+     * @return
+     */
+    private fun getMetaState(keyEvent: W3CKeyEvent): Int {
+        var metaState = 0
+        if (keyEvent.isAltKey) {
+            metaState = metaState or KeyEvent.META_ALT_MASK
+        }
+        if (keyEvent.isCtrlKey) {
+            metaState = metaState or KeyEvent.META_CTRL_MASK
+        }
+        if (keyEvent.isShiftKey) {
+            metaState = metaState or KeyEvent.META_SHIFT_MASK
+        }
+        return metaState
+    }
+
+    /**
+     * Inject a key event into UiController
+     * @param isDown Is it a key down event?
+     * @param keyEvents A list of the Android Key Events to inject
+     * @param key The key to inject in string form (for logging purposes)
+     * @throws AppiumException
+     */
+    @Throws(AppiumException::class)
+    private fun injectKeyEvents(isDown: Boolean, keyEvents: List<KeyEvent>, key: String?) {
+        // If it's a keydown event, record that this key went down. If it's keyup, remove pre-existing
+        // record of this key going down
+        if (isDown) {
+            keyDownTimes[key] = keyEvents
+        } else {
+            keyDownTimes.remove(key)
+        }
+
+        // Inject all of the key events, in order
+        for (androidKeyEvent in keyEvents) {
+            AndroidLogger.info(String.format("Calling key event: %s", androidKeyEvent))
+            var isSuccess: Boolean
+            isSuccess = try {
+                uiController.injectKeyEvent(androidKeyEvent)
+            } catch (e: InjectEventSecurityException) {
+                throw AppiumException(e.cause.toString())
+            }
+            if (!isSuccess) {
+                throw AppiumException(String.format("Could not inject key event %s", key))
+            }
+        }
+    }
+}

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

@@ -0,0 +1,90 @@
+package io.appium.espressoserver.lib.helpers.w3c.adapter.espresso
+
+import android.view.MotionEvent
+import androidx.test.espresso.UiController
+import io.appium.espressoserver.lib.handlers.exceptions.AppiumException
+import io.appium.espressoserver.lib.helpers.w3c.models.InputSource
+import io.appium.espressoserver.lib.helpers.w3c.state.KeyInputState
+import java.util.concurrent.ConcurrentHashMap
+
+class AndroidMotionEvent private constructor(private val uiController: UiController) {
+    private var downTime: Long = 0
+
+    @Throws(AppiumException::class)
+    fun pointerEvent(x: List<Long>?, y: List<Long>?,
+                     action: Int,
+                     button: Int?,
+                     pointerType: InputSource.PointerType?,
+                     globalKeyInputState: KeyInputState?,
+                     downEvent: MotionEvent?,
+                     eventTime: Long): MotionEvent {
+        val metaState = globalKeyInputState?.toMetaState() ?: 0
+        downTime = downEvent?.downTime ?: eventTime
+        return MotionEventBuilder()
+                .withAction(action)
+                .withButtonState(extractButton(button, pointerType))
+                .withPointerType(pointerType)
+                .withDownTime(downTime)
+                .withEventTime(eventTime)
+                .withX(x)
+                .withY(y)
+                .withMetaState(metaState)
+                .withSource(downEvent?.source ?: 0)
+                .build()
+                .run(uiController)!!
+    }
+
+    @Throws(AppiumException::class)
+    fun pointerMove(x: List<Long>?, y: List<Long>?,
+                    pointerType: InputSource.PointerType?,
+                    globalKeyInputState: KeyInputState?,
+                    downEvent: MotionEvent?) {
+        val metaState = globalKeyInputState?.toMetaState() ?: 0
+        MotionEventBuilder()
+                .withAction(MotionEvent.ACTION_MOVE)
+                .withDownTime(downTime)
+                .withPointerType(pointerType)
+                .withX(x)
+                .withY(y)
+                .withMetaState(metaState)
+                .withSource(downEvent?.source ?: 0)
+                .build()
+                .run(uiController)
+    }
+
+    @JvmOverloads
+    @Throws(AppiumException::class)
+    fun pointerCancel(x: List<Long>? = null, y: List<Long>? = null) {
+        MotionEventBuilder()
+                .withAction(MotionEvent.ACTION_CANCEL)
+                .withDownTime(downTime)
+                .withX(x)
+                .withY(y)
+                .withPointerType(InputSource.PointerType.TOUCH)
+                .build()
+                .run(uiController)
+    }
+
+    companion object {
+        private var touchMotionEvent: AndroidMotionEvent? = null
+        private val motionEvents: MutableMap<String, AndroidMotionEvent> = ConcurrentHashMap()
+
+        @Synchronized
+        fun getMotionEvent(
+                sourceId: String, uiController: UiController): AndroidMotionEvent {
+            if (!motionEvents.containsKey(sourceId)) {
+                motionEvents[sourceId] = AndroidMotionEvent(uiController)
+            }
+            return motionEvents[sourceId]!!
+        }
+
+        @Synchronized
+        fun getTouchMotionEvent(uiController: UiController): AndroidMotionEvent {
+            if (touchMotionEvent == null) {
+                touchMotionEvent = AndroidMotionEvent(uiController)
+            }
+            return touchMotionEvent!!
+        }
+    }
+
+}

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

@@ -0,0 +1,147 @@
+package io.appium.espressoserver.lib.helpers.w3c.adapter.espresso
+
+import android.content.Context
+import android.graphics.Point
+
+import androidx.test.espresso.UiController
+import androidx.test.espresso.action.GeneralLocation
+import io.appium.espressoserver.lib.handlers.exceptions.AppiumException
+import io.appium.espressoserver.lib.helpers.AndroidLogger
+import io.appium.espressoserver.lib.helpers.Logger
+import io.appium.espressoserver.lib.helpers.w3c.adapter.BaseW3CActionAdapter
+import io.appium.espressoserver.lib.helpers.w3c.dispatcher.W3CKeyEvent
+import io.appium.espressoserver.lib.helpers.w3c.models.InputSource.PointerType
+import io.appium.espressoserver.lib.helpers.w3c.state.KeyInputState
+import io.appium.espressoserver.lib.model.EspressoElement
+
+import android.view.KeyEvent.ACTION_DOWN
+import android.view.KeyEvent.ACTION_UP
+import android.view.MotionEvent.ACTION_MOVE
+import android.view.MotionEvent.ACTION_POINTER_DOWN
+import android.view.MotionEvent.ACTION_POINTER_UP
+import androidx.test.core.app.ApplicationProvider.getApplicationContext
+import kotlin.math.roundToInt
+import kotlin.math.roundToLong
+
+class EspressoW3CActionAdapter(private val uiController: UiController) : BaseW3CActionAdapter() {
+
+    private val androidKeyEvent: AndroidKeyEvent = AndroidKeyEvent(uiController)
+    private val multiTouchState = MultiTouchState()
+    private val displayMetrics = getApplicationContext<Context>().resources.displayMetrics
+
+    override val viewportHeight: Long
+        get() = displayMetrics.heightPixels.toLong()
+
+    override val viewportWidth: Long
+        get() = displayMetrics.widthPixels.toLong()
+
+    override val logger: Logger
+        get() = AndroidLogger
+
+    @Throws(AppiumException::class)
+    override fun keyDown(keyDownEvent: W3CKeyEvent) {
+        androidKeyEvent.keyDown(keyDownEvent)
+    }
+
+    @Throws(AppiumException::class)
+    override fun keyUp(keyUpEvent: W3CKeyEvent) {
+        androidKeyEvent.keyUp(keyUpEvent)
+    }
+
+    @Throws(AppiumException::class)
+    override fun pointerDown(button: Int, sourceId: String, pointerType: PointerType?,
+                    x: Float, y: Float, depressedButtons: Set<Int>,
+                    globalKeyInputState: KeyInputState?) {
+        this.logger.info("Running pointer down at coordinates: ${x}, ${y}, $pointerType")
+        val roundedCoords = toCoordinates(x, y)
+
+        if (isTouch(pointerType)) {
+            // touch down actions need to be grouped together
+            multiTouchState.updateTouchState(ACTION_DOWN, sourceId, roundedCoords.x.toLong(), roundedCoords.y.toLong(), globalKeyInputState, button)
+        } else {
+            val androidMotionEvent = AndroidMotionEvent.getMotionEvent(sourceId, uiController)
+            val xList = listOf(roundedCoords.x.toLong())
+            val yList = listOf(roundedCoords.y.toLong())
+            androidMotionEvent.pointerEvent(
+                    xList, yList,
+                    ACTION_DOWN, button, pointerType, globalKeyInputState, null, 0)
+
+            androidMotionEvent.pointerEvent(
+                    xList, yList,
+                    ACTION_POINTER_DOWN, button, pointerType, globalKeyInputState, null, 0)
+        }
+    }
+
+    @Throws(AppiumException::class)
+    override fun pointerUp(button: Int, sourceId: String, pointerType: PointerType?,
+                  x: Float, y: Float, depressedButtons: Set<Int>,
+                  globalKeyInputState: KeyInputState?) {
+        this.logger.info("Running pointer up at coordinates: $x $y $pointerType")
+        val roundedCoords = toCoordinates(x, y)
+        if (isTouch(pointerType)) {
+            // touch up actions need to be grouped together
+            multiTouchState.updateTouchState(ACTION_UP, sourceId, roundedCoords.x.toLong(), roundedCoords.y.toLong(), globalKeyInputState, button)
+        } else {
+            val xList = listOf(roundedCoords.x.toLong())
+            val yList = listOf(roundedCoords.y.toLong())
+            val androidMotionEvent = AndroidMotionEvent.getMotionEvent(sourceId, uiController)
+            androidMotionEvent.pointerEvent(xList, yList,
+                    ACTION_POINTER_UP, button, pointerType, globalKeyInputState, null, 0)
+            androidMotionEvent.pointerEvent(xList, yList,
+                    ACTION_UP, button, pointerType, globalKeyInputState, null, 0)
+        }
+    }
+
+    @Throws(AppiumException::class)
+    override fun pointerMove(sourceId: String, pointerType: PointerType?,
+                             currentX: Float, currentY: Float, x: Float, y: Float,
+                             buttons: Set<Int>?, globalKeyInputState: KeyInputState?) {
+        this.logger.info("Running pointer move at coordinates: $x $y $pointerType")
+        val roundedCoords = toCoordinates(x, y)
+        if (isTouch(pointerType)) {
+            multiTouchState.updateTouchState(ACTION_MOVE, sourceId, roundedCoords.x.toLong(), roundedCoords.y.toLong(), globalKeyInputState, null)
+            multiTouchState.pointerMove(uiController)
+        } else {
+            AndroidMotionEvent.getMotionEvent(sourceId, uiController)
+                    .pointerMove(listOf(roundedCoords.x.toLong()), listOf(roundedCoords.y.toLong()), pointerType, globalKeyInputState, null)
+        }
+    }
+
+    @Throws(AppiumException::class)
+    override fun pointerCancel(sourceId: String, pointerType: PointerType) {
+        if (isTouch(pointerType)) {
+            multiTouchState.pointerCancel(uiController)
+        } else {
+            AndroidMotionEvent.getMotionEvent(sourceId, uiController).pointerCancel()
+        }
+    }
+
+    @Throws(AppiumException::class)
+    override fun sychronousTickActionsComplete() {
+        multiTouchState.perform(uiController)
+        AndroidLogger.info("Pointer event: Tick complete")
+    }
+
+    override fun getKeyCode(keyValue: String?, location: Int): Int {
+        return keyCodeToEvent(keyValue, location)
+    }
+
+    @Throws(AppiumException::class)
+    override fun getElementCenterPoint(elementId: String?): Point {
+        val view = EspressoElement.getViewById(elementId)
+        val coords = GeneralLocation.CENTER.calculateCoordinates(view)
+        val point = Point()
+        point.x = coords[0].roundToInt()
+        point.y = coords[1].roundToInt()
+        return point
+    }
+
+    override fun waitForUiThread() {
+        uiController.loopMainThreadUntilIdle()
+    }
+
+    override fun sleep(duration: Float) {
+        val roundedDuration = duration.roundToLong()
+        uiController.loopMainThreadForAtLeast(roundedDuration)
+    }
+}

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

@@ -0,0 +1,71 @@
+package io.appium.espressoserver.lib.helpers.w3c.adapter.espresso
+
+import android.graphics.Point
+import android.os.Build
+import android.view.MotionEvent
+import io.appium.espressoserver.lib.handlers.exceptions.AppiumException
+import io.appium.espressoserver.lib.helpers.w3c.models.InputSource
+import kotlin.math.roundToInt
+
+private const val MOUSE_BUTTON_LEFT = 0
+private const val MOUSE_BUTTON_MIDDLE = 1
+private const val MOUSE_BUTTON_RIGHT = 2
+
+@Throws(AppiumException::class)
+fun extractButton(w3cButton: Int?, pointerType: InputSource.PointerType?): Int {
+    // Get the Android tool type constant associated with the W3C provided pointer type
+    val toolType = getToolType(pointerType)
+    if (toolType == MotionEvent.TOOL_TYPE_FINGER) {
+        // Ignore button code conversion for the unsupported tool type
+        return w3cButton ?: 0
+    }
+    var androidButton = MOUSE_BUTTON_LEFT
+    if (w3cButton != null) {
+        androidButton = w3cButton
+    }
+    return when (androidButton) {
+        MOUSE_BUTTON_LEFT -> if (toolType == MotionEvent.TOOL_TYPE_STYLUS && Build.VERSION.SDK_INT >= 23) MotionEvent.BUTTON_STYLUS_PRIMARY else MotionEvent.BUTTON_PRIMARY
+        MOUSE_BUTTON_MIDDLE -> MotionEvent.BUTTON_TERTIARY
+        MOUSE_BUTTON_RIGHT -> if (toolType == MotionEvent.TOOL_TYPE_STYLUS && Build.VERSION.SDK_INT >= 23) MotionEvent.BUTTON_STYLUS_SECONDARY else MotionEvent.BUTTON_SECONDARY
+        else -> androidButton
+    }
+}
+
+/**
+ * Return Android tool type based on W3C pointer type
+ * @param pointerType W3C pointer types (TOUCH, PEN, MOUSE)
+ * @return Android Motion Event type (FINGER, STYLUS, MOUSE)
+ */
+@Throws(AppiumException::class)
+fun getToolType(pointerType: InputSource.PointerType?): Int {
+    @Suppress("REDUNDANT_ELSE_IN_WHEN")
+    return if (pointerType == null) {
+        MotionEvent.TOOL_TYPE_FINGER
+    } else when (pointerType) {
+        InputSource.PointerType.TOUCH -> MotionEvent.TOOL_TYPE_FINGER
+        InputSource.PointerType.PEN -> MotionEvent.TOOL_TYPE_STYLUS
+        InputSource.PointerType.MOUSE -> MotionEvent.TOOL_TYPE_MOUSE
+        else -> throw AppiumException(String.format("Invalid tool type: %s", pointerType))
+    }
+}
+
+// If a 'mouse' event was provided, convert it to 'touch'
+// This is because some clients only send 'mouse' events and the assumption is that if they
+// send 'mouse' events to a device that has a touch screen, it needs to be converted
+fun isTouch(type: InputSource.PointerType?): Boolean {
+    // return type == TOUCH || (type == MOUSE && isTouchScreen); // TODO Revisit this if we wish to support MOUSE on Android
+    return type === InputSource.PointerType.TOUCH || type === InputSource.PointerType.MOUSE
+}
+
+/**
+ * Convert [x,y] coordinates from float to long.
+ *
+ * Gives warning if the long values are different from the float values
+ *
+ * @param x X coordinate
+ * @param y Y coordinate
+ * @return Rounded x and y coordinates
+ */
+fun toCoordinates(x: Float, y: Float): Point {
+    return Point(x.roundToInt(), y.roundToInt())
+}