appium-espresso-driver 1.46.0

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

@@ -0,0 +1,93 @@
+/*
+ * 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.processor
+
+import io.appium.espressoserver.lib.handlers.exceptions.InvalidArgumentException
+import io.appium.espressoserver.lib.handlers.exceptions.NotYetImplementedException
+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.models.InputSource.InputSourceType
+import io.appium.espressoserver.lib.helpers.w3c.state.ActiveInputSources
+import io.appium.espressoserver.lib.helpers.w3c.state.InputStateTable
+
+import io.appium.espressoserver.lib.helpers.w3c.processor.KeyProcessor.processKeyAction
+import io.appium.espressoserver.lib.helpers.w3c.processor.PauseProcessor.processNullAction
+import io.appium.espressoserver.lib.helpers.w3c.processor.PointerProcessor.processPointerAction
+
+object ActionsProcessor {
+
+    /**
+     * Follows algorithm "for process an input source action sequence" in section 17.3
+     */
+    @Throws(InvalidArgumentException::class, NotYetImplementedException::class)
+    fun processSourceActionSequence(inputSource: InputSource, activeInputSources: ActiveInputSources, inputStateTable: InputStateTable): List<ActionObject> {
+        // 1: Get the type
+        // 2: If type is not "key", "pointer", or "none", return an error
+        inputSource.type
+                ?: throw InvalidArgumentException("'type' is required in input source and must be one of: pointer, key, none")
+
+
+        // 3: Get the ID from the input source
+        // 4: If id is undefined or is not a String, return error
+        val id = inputSource.id
+                ?: throw InvalidArgumentException("'id' in action cannot be null")
+
+
+        // 6: Let source be the input source in the list of active input sources where that input source’s input id matches id,
+        val activeSource = activeInputSources.getInputSource(inputSource)
+
+        // 7:  source is undefined:
+        if (activeSource == null) {
+            activeInputSources.addInputSource(inputSource)
+            inputStateTable.addInputState(inputSource.id!!, inputSource.defaultState!!)
+        } else {
+
+            // 8: If source's type does not match type return an error
+            if (activeSource.type != inputSource.type) {
+                throw InvalidArgumentException("Input type ${inputSource.type} does not match pre-existing input type '${activeSource.type}' in actions input source with id '${id}'")
+            }
+
+            // 9: If it's a pointer type, check that they match parameter types
+            if (activeSource.type == InputSourceType.POINTER && activeSource.pointerType != inputSource.pointerType) {
+                throw InvalidArgumentException("Pointer type ${inputSource.pointerType} does not match pre-existing pointer type '${activeSource.pointerType}' in actions input " +
+                        "source with id '${id}'")
+            }
+        }
+
+        // 10: Let action items be the result of getting a property named actions from action sequence
+        // 11: If action items is not an Array, return error
+        val actionItems = inputSource.actions
+                ?: throw InvalidArgumentException("'actions' array not provided in actions input source with id '${id}'")
+
+        // 12: Let actions be a new list
+        val actionObjects = arrayListOf<ActionObject>()
+
+        // 13: For each item in action items
+        var index = 0
+        for (action in actionItems) {
+            index++
+            when (inputSource.type) {
+                InputSourceType.NONE -> actionObjects.add(processNullAction(action, inputSource.type, id, index))
+                InputSourceType.POINTER -> actionObjects.add(processPointerAction(action, inputSource, id, index))
+                InputSourceType.KEY -> actionObjects.add(processKeyAction(action, inputSource.type, id, index))
+                else -> throw InvalidArgumentException("'actions[${index}]' of input source with id '${id}' did not provide a valid type")
+            }
+        }
+
+        return actionObjects
+    }
+}

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

@@ -0,0 +1,57 @@
+/*
+ * 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.processor
+
+import io.appium.espressoserver.lib.handlers.exceptions.InvalidArgumentException
+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.models.InputSource.InputSourceType
+
+object KeyProcessor {
+    /**
+     * Follows the 'process a key action' algorithm in 17.2
+     * @param action Action being processed
+     * @param inputSourceType Source type
+     * @param id ID of input source that it's part of
+     * @param index Index within the 'actions' array
+     * @return Processed action object
+     * @throws InvalidArgumentException If failed to process, throw this. Means that args are bad.
+     */
+    @Throws(InvalidArgumentException::class)
+    fun processKeyAction(action: InputSource.Action, inputSourceType: InputSourceType?, id: String?, index: Int): ActionObject {
+
+        // 1-3 get and validate the action type
+        val subType = action.type
+        val validKeyTypes = listOf(InputSource.ActionType.KEY_UP, InputSource.ActionType.KEY_DOWN, InputSource.ActionType.PAUSE)
+        if (!validKeyTypes.contains(subType)) {
+            throwArgException(index, id, "has an invalid type. 'type' for 'key' actions must be one of: keyUp, keyDown or pause")
+        }
+
+        // 4 if pause return PAUSE action
+        if (subType == InputSource.ActionType.PAUSE) {
+            return PauseProcessor.processPauseAction(action, inputSourceType, id, index)
+        }
+
+        // 5-7 get the Unicode value of the keystroke (verify that it's a single character)
+        val key = action.value
+        if (key?.length != 1) {
+            throwArgException(index, id, String.format("has invalid 'value' %s. Must be a unicode point", key))
+        }
+        val actionObject = ActionObject(id, inputSourceType, subType, index)
+        actionObject.value = key
+        return actionObject
+    }
+}

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

@@ -0,0 +1,59 @@
+/*
+ * 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.processor
+
+import io.appium.espressoserver.lib.handlers.exceptions.InvalidArgumentException
+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.models.InputSource.InputSourceType
+
+object PauseProcessor {
+    /**
+     * Implement the 'process a null action' in 17.3
+     * @param action Action being processed
+     * @param inputSourceType Source type
+     * @param id ID of input source that it's part of
+     * @param index Index within the 'actions' array
+     * @return Processed action object
+     * @throws InvalidArgumentException If failed to process, throw this. Means that args are bad.
+     */
+    @Throws(InvalidArgumentException::class)
+    fun processNullAction(action: InputSource.Action, inputSourceType: InputSourceType?, id: String?, index: Int): ActionObject {
+        if (action.type != InputSource.ActionType.PAUSE) {
+            throwArgException(index, id, "must be type 'pause' if input source type is null")
+        }
+        return processPauseAction(action, inputSourceType, id, index)
+    }
+
+    /**
+     * Follows the 'process a pause action' algorithm in 17.3
+     * @param action Action being processed
+     * @param inputSourceType Source type
+     * @param id ID of input source that it's part of
+     * @param index Index within the 'actions' array
+     * @return Processed action object
+     * @throws InvalidArgumentException If failed to process, throw this. Means that args are bad.
+     */
+    @JvmStatic
+    @Throws(InvalidArgumentException::class)
+    fun processPauseAction(action: InputSource.Action, inputSourceType: InputSourceType?, id: String?, index: Int): ActionObject {
+        val duration = action.duration
+        assertNullOrPositive(index, id, "duration", duration)
+        val actionObject = ActionObject(id, inputSourceType, InputSource.ActionType.PAUSE, index)
+        actionObject.duration = duration
+        return actionObject
+    }
+}

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

@@ -0,0 +1,115 @@
+/*
+ * 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.processor
+
+import io.appium.espressoserver.lib.handlers.exceptions.InvalidArgumentException
+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.models.InputSource.InputSourceType
+import io.appium.espressoserver.lib.helpers.w3c.processor.PauseProcessor.processPauseAction
+
+object PointerProcessor {
+    /**
+     * Follows the 'process a pointer action' algorithm in 17.2
+     * @param action Action being processed
+     * @param inputSource Input source
+     * @param id ID of input source that it's part of
+     * @param index Index within the 'actions' array
+     * @return Processed action object
+     * @throws InvalidArgumentException If failed to process, throw this. Means that args are bad.
+     */
+    @Throws(InvalidArgumentException::class)
+    fun processPointerAction(action: InputSource.Action, inputSource: InputSource, id: String?, index: Int): ActionObject {
+
+        // 1 -2 get and validate the type
+        val subType = action.type
+        val validKeyTypes = listOf(InputSource.ActionType.POINTER_MOVE, InputSource.ActionType.POINTER_DOWN,
+                InputSource.ActionType.POINTER_UP, InputSource.ActionType.POINTER_CANCEL, InputSource.ActionType.PAUSE)
+        if (!validKeyTypes.contains(subType)) {
+            throwArgException(index, id, "has an invalid type. 'type' for 'key' actions must be one of:" +
+                    "pointerMove, pointerDown, pointerUp, pointerCancel, pause")
+        }
+        val actionObject: ActionObject
+
+        // 4 if pause return PAUSE action
+        if (subType == InputSource.ActionType.PAUSE) {
+            return processPauseAction(action, inputSource.type, id, index)
+        }
+        actionObject = when (subType) {
+            InputSource.ActionType.POINTER_DOWN, InputSource.ActionType.POINTER_UP -> processPointerUpOrDownAction(action, inputSource.type, id, index)
+            InputSource.ActionType.POINTER_MOVE -> processPointerMoveAction(action, inputSource.type, id, index)
+            InputSource.ActionType.POINTER_CANCEL -> processPointerCancelAction(action, inputSource.type, id, index)
+            else -> throw InvalidArgumentException(String.format("Invalid pointer type %s", subType))
+        }
+        actionObject.pointer = inputSource.pointerType
+        return actionObject
+    }
+
+    /**
+     * Follows the 'process a pointer up or pointer down action' algorithm in 17.2
+     * @param action Action being processed
+     * @param inputSourceType Source type
+     * @param id ID of input source that it's part of
+     * @param index Index within the 'actions' array
+     * @return Processed action object
+     * @throws InvalidArgumentException If failed to process, throw this. Means that args are bad.
+     */
+    @Throws(InvalidArgumentException::class)
+    fun processPointerUpOrDownAction(action: InputSource.Action, inputSourceType: InputSourceType?, id: String?, index: Int): ActionObject {
+        val actionObject = ActionObject(id, inputSourceType, action.type, index)
+        val button = action.button
+        if (button!! < 0) {
+            throwArgException(index, id, String.format("property 'button' must be greater than or equal to 0. Found %s", button))
+        }
+        actionObject.button = button
+        return actionObject
+    }
+
+    fun processPointerCancelAction(action: InputSource.Action, inputSourceType: InputSourceType?, id: String?, index: Int): ActionObject {
+        return ActionObject(id, inputSourceType, action.type, index)
+    }
+
+    /**
+     * Follows the 'process pointer move action' algorithm in 17.3
+     * @param action Action being processed
+     * @param inputSourceType Source type
+     * @param id ID of input source that it's part of
+     * @param index Index within the 'actions' array
+     * @return Processed action object
+     * @throws InvalidArgumentException If failed to process, throw this. Means that args are bad.
+     */
+    @Throws(InvalidArgumentException::class)
+    fun processPointerMoveAction(action: InputSource.Action, inputSourceType: InputSourceType?, id: String?, index: Int): ActionObject {
+        val actionObject = ActionObject(id, inputSourceType, action.type, index)
+
+        // 1-3 Add the duration
+        val duration = action.duration
+        assertNullOrPositive(index, id, "duration", duration)
+        actionObject.duration = duration
+
+        // 4-7 Add the origin
+        actionObject.origin = action.origin
+
+        // 8-10 Add the X coordinate
+        val x = action.x
+        actionObject.x = x
+
+        // 11-14 Add the Y coordinate
+        val y = action.y
+        actionObject.y = y
+        return actionObject
+    }
+}

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

@@ -0,0 +1,35 @@
+/*
+ * 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.processor
+
+import io.appium.espressoserver.lib.handlers.exceptions.InvalidArgumentException
+
+fun isNullOrPositive(num: Float?): Boolean {
+    return num == null || num >= 0
+}
+
+@Throws(InvalidArgumentException::class)
+fun throwArgException(index: Int, id: String?, message: String?) {
+    throw InvalidArgumentException("action in actions[$index] of action input source with id '$id' $message")
+}
+
+@Throws(InvalidArgumentException::class)
+fun assertNullOrPositive(index: Int, id: String?, propertyName: String?, propertyValue: Float?) {
+    if (!isNullOrPositive(propertyValue)) {
+        throwArgException(index, id,
+                "must have property '$propertyName' be greater than or equal to 0 or undefined. Found $propertyValue")
+    }
+}

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

@@ -0,0 +1,62 @@
+package io.appium.espressoserver.lib.helpers.w3c.state
+
+import io.appium.espressoserver.lib.handlers.exceptions.InvalidArgumentException
+import io.appium.espressoserver.lib.helpers.w3c.models.InputSource
+import java.util.*
+
+/**
+ * Active Input Source defined in W3C spec
+ *
+ * (see https://www.w3.org/TR/webdriver/#terminology-0)
+ */
+class ActiveInputSources {
+    private val inputSources: MutableMap<String?, InputSource> = WeakHashMap()
+
+    @Throws(InvalidArgumentException::class)
+    fun addInputSource(inputSource: InputSource) {
+        inputSources[inputSource.id] = inputSource
+    }
+
+    /**
+     * Remove an input source and also remove it from InputStateTable
+     * @param inputSource Source to remove
+     */
+    fun removeInputSource(inputSource: InputSource) {
+        removeInputSource(inputSource.id)
+    }
+
+    fun removeInputSource(id: String?) {
+        inputSources.remove(id)
+    }
+
+    fun getInputSource(inputSource: InputSource): InputSource? {
+        return inputSources[inputSource.id]
+    }
+
+    fun getInputSource(id: String?): InputSource? {
+        return inputSources[id]
+    }
+
+    fun hasInputSource(id: String?): Boolean {
+        return inputSources.containsKey(id)
+    }
+
+    companion object {
+        private val activeInputSources: MutableMap<String, ActiveInputSources> = WeakHashMap()
+
+        /**
+         * Get the `active input sources` table for a session
+         *
+         * @return Global instance of ActiveInputSources
+         */
+        @Synchronized
+        fun getActiveInputSourcesForSession(sessionId: String): ActiveInputSources {
+            var globalInputStateTable = activeInputSources[sessionId]
+            if (globalInputStateTable == null) {
+                activeInputSources[sessionId] = ActiveInputSources()
+                globalInputStateTable = activeInputSources[sessionId]
+            }
+            return globalInputStateTable!!
+        }
+    }
+}

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

@@ -0,0 +1,6 @@
+package io.appium.espressoserver.lib.helpers.w3c.state
+
+/**
+ * Blank interface used to group together inputstates
+ */
+interface InputState

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

@@ -0,0 +1,95 @@
+package io.appium.espressoserver.lib.helpers.w3c.state
+
+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.ActionObject
+import io.appium.espressoserver.lib.helpers.w3c.models.InputSource.InputSourceType
+import java.util.*
+
+/**
+ * Keep the state of all active input sources
+ *
+ * (defined in 17.1 of spec)
+ */
+class InputStateTable {
+    private val stateTable: MutableMap<String, InputState> = HashMap()
+    val cancelList: MutableList<ActionObject> = ArrayList()
+    fun addInputState(id: String, inputState: InputState) {
+        stateTable[id] = inputState
+    }
+
+    fun getInputState(id: String): InputState? {
+        return stateTable[id]
+    }
+
+    fun getOrCreateInputState(sourceId: String, actionObject: ActionObject): InputState? {
+        if (!hasInputState(sourceId)) {
+            val newInputState: InputState? = when (actionObject.type) {
+                InputSourceType.KEY -> KeyInputState()
+                InputSourceType.POINTER -> PointerInputState(actionObject.pointer)
+                else -> null
+            }
+            newInputState?.let {
+                addInputState(sourceId, it)
+            }
+        }
+        return stateTable[sourceId]
+    }
+
+    fun hasInputState(id: String): Boolean {
+        return stateTable.containsKey(id)
+    }
+
+    fun addActionToCancel(actionObject: ActionObject) {
+        cancelList.add(actionObject)
+    }
+
+    val globalKeyInputState: KeyInputState
+        get() {
+            val keyInputStates: MutableList<KeyInputState> = ArrayList()
+            for ((_, inputState) in stateTable) {
+                if (inputState is KeyInputState) {
+                    keyInputStates.add(inputState)
+                }
+            }
+            return getGlobalKeyState(keyInputStates)
+        }
+
+    /**
+     * Do the release actions to undo everything
+     * @param adapter W3C Action adapter
+     * @param timeAtBeginningOfTick When did the tick begin
+     * @throws AppiumException
+     */
+    @Throws(AppiumException::class)
+    fun undoAll(adapter: W3CActionAdapter, timeAtBeginningOfTick: Long) {
+        // 2-3: Dispatch tick actions with arguments undo actions and duration 0 in reverse order
+        cancelList.reverse()
+        for (actionObject in cancelList) {
+            actionObject.dispatch(adapter, this, 0f, timeAtBeginningOfTick)
+        }
+        adapter.sychronousTickActionsComplete()
+
+        // Clear the cancel list now that the Undo operations are all fulfilled
+        cancelList.clear()
+    }
+
+    companion object {
+        private val inputStateTables: MutableMap<String, InputStateTable> = HashMap()
+
+        /**
+         * Get the global input states for a given session
+         * @param sessionId ID of the session
+         * @return
+         */
+        @Synchronized
+        fun getInputStateTableOfSession(sessionId: String): InputStateTable {
+            var globalInputStateTable = inputStateTables[sessionId]
+            if (globalInputStateTable == null) {
+                inputStateTables[sessionId] = InputStateTable()
+                globalInputStateTable = inputStateTables[sessionId]
+            }
+            return globalInputStateTable!!
+        }
+    }
+}

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

@@ -0,0 +1,82 @@
+package io.appium.espressoserver.lib.helpers.w3c.state
+
+import android.view.KeyEvent
+import java.util.*
+
+/**
+ * Implement 'calculated global key state' in spec 17.2
+ */
+fun getGlobalKeyState(keyInputStates: List<KeyInputState>): KeyInputState {
+    var isAlt = false
+    var isShift = false
+    var isCtrl = false
+    var isMeta = false
+    val outputState = KeyInputState()
+    for (keyInputState in keyInputStates) {
+        if (keyInputState.isAlt) {
+            isAlt = true
+        }
+        if (keyInputState.isShift) {
+            isShift = true
+        }
+        if (keyInputState.isCtrl) {
+            isCtrl = true
+        }
+        if (keyInputState.isMeta) {
+            isMeta = true
+        }
+        for (key in keyInputState.pressed) {
+            outputState.addPressed(key)
+        }
+    }
+    outputState.isAlt = isAlt
+    outputState.isShift = isShift
+    outputState.isCtrl = isCtrl
+    outputState.isMeta = isMeta
+    return outputState
+}
+
+/**
+ * Key input state specified in 17.2 of spec
+ *
+ * https://www.w3.org/TR/webdriver/#input-source-state
+ */
+class KeyInputState : InputState {
+    val pressed: MutableSet<String> = HashSet()
+    var isAlt = false
+    var isShift = false
+    var isCtrl = false
+    var isMeta = false
+    fun isPressed(key: String): Boolean {
+        return pressed.contains(key)
+    }
+
+    fun addPressed(key: String) {
+        pressed.add(key)
+    }
+
+    fun removePressed(key: String) {
+        pressed.remove(key)
+    }
+
+    fun logMessage(): String {
+        return "alt=[$isAlt] shift=[$isShift] ctrl=[$isCtrl] meta=[$isMeta] pressed=[$pressed]"
+    }
+
+    fun toMetaState(): Int {
+        var metaState = 0
+        if (isAlt) {
+            metaState = metaState or KeyEvent.META_ALT_MASK
+        }
+        if (isCtrl) {
+            metaState = metaState or KeyEvent.META_CTRL_MASK
+        }
+        if (isShift) {
+            metaState = metaState or KeyEvent.META_SHIFT_MASK
+        }
+        if (isMeta) {
+            metaState = metaState or KeyEvent.META_META_MASK
+        }
+        return metaState
+    }
+}

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

@@ -0,0 +1,45 @@
+package io.appium.espressoserver.lib.helpers.w3c.state
+
+import io.appium.espressoserver.lib.helpers.w3c.models.InputSource
+import java.util.*
+
+/**
+ * Pointer input state specified in 17.2 of spec
+ *
+ * https://www.w3.org/TR/webdriver/#input-source-state
+ */
+class PointerInputState : InputState {
+    private val pressed: MutableSet<Int> = HashSet()
+    var x = 0f
+    var y = 0f
+    var type: InputSource.PointerType? = null
+        get() { return field ?: InputSource.PointerType.TOUCH }
+
+    @Suppress("ConvertSecondaryConstructorToPrimary")
+    constructor(type: InputSource.PointerType?) {
+        this.type = type
+    }
+
+    fun isPressed(num: Int): Boolean {
+        return pressed.contains(num)
+    }
+
+    fun addPressed(num: Int) {
+        pressed.add(num)
+    }
+
+    fun removePressed(num: Int) {
+        pressed.remove(num)
+    }
+
+    val buttons: Set<Int>
+        get() = pressed
+
+    fun hasPressedButtons(): Boolean {
+        return pressed.isNotEmpty()
+    }
+
+    fun logMessage(): String {
+        return "pointer-type=[$type] x=[$x] y=[$y] pressed=[$pressed]"
+    }
+}