appium-espresso-driver 1.46.0

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

@@ -0,0 +1,138 @@
+package io.appium.espressoserver.lib.helpers.w3c.models
+
+import io.appium.espressoserver.lib.handlers.exceptions.AppiumException
+import io.appium.espressoserver.lib.handlers.exceptions.InvalidArgumentException
+import io.appium.espressoserver.lib.helpers.w3c.adapter.W3CActionAdapter
+import io.appium.espressoserver.lib.helpers.w3c.dispatcher.BaseDispatchResult
+import io.appium.espressoserver.lib.helpers.w3c.dispatcher.PointerDispatch
+import io.appium.espressoserver.lib.helpers.w3c.dispatcher.dispatchKeyDown
+import io.appium.espressoserver.lib.helpers.w3c.dispatcher.dispatchKeyUp
+import io.appium.espressoserver.lib.helpers.w3c.models.InputSource.InputSourceType
+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
+
+class ActionObject {
+    private var index = 0
+    var type: InputSourceType? = null
+    var subType: InputSource.ActionType? = null
+    var id: String? = null
+    var duration: Float? = null
+    var x: Float? = null
+        get() { return field ?: 0f }
+    var y: Float? = null
+        get() { return field ?: 0f }
+    var button = 0
+    var value: String? = null
+    var pointer: InputSource.PointerType? = null
+    var origin = Origin()
+
+    constructor() {}
+
+    // Copy constructor
+    constructor(actionObject: ActionObject) {
+        index = actionObject.index
+        type = actionObject.type
+        subType = actionObject.subType
+        id = actionObject.id
+        duration = actionObject.duration
+        origin = actionObject.origin
+        x = actionObject.x
+        y = actionObject.y
+        button = actionObject.button
+        value = actionObject.value
+        pointer = actionObject.pointer
+    }
+
+    constructor(id: String?, type: InputSourceType?, subType: InputSource.ActionType?, index: Int) {
+        this.type = type
+        this.subType = subType
+        this.id = id
+        this.index = index // Store the index of the action for possible future logging issues
+    }
+
+    /**
+     * Call `dispatch tick actions` algorithm in section 17.4
+     * @param adapter Adapter for actions
+     * @param inputStateTable State of all inputs
+     * @param tickDuration How long the tick is
+     * @param timeAtBeginningOfTick When the tick began
+     * @return
+     * @throws AppiumException
+     */
+    @Throws(AppiumException::class)
+    fun dispatch(adapter: W3CActionAdapter,
+                 inputStateTable: InputStateTable,
+                 tickDuration: Float, timeAtBeginningOfTick: Long): Callable<BaseDispatchResult>? {
+        val inputSourceType = type
+        val actionType = subType
+        adapter.logger.info(String.format(
+                "Dispatching action #%s of input source %s",
+                index, id
+        ))
+        // 1.3 If the current session's input state table doesn't have a property corresponding to
+        //      source id, then let the property corresponding to source id be a new object of the
+        //      corresponding input source state type for source type.
+        // 1.4 Let device state be the input source state corresponding to source id in the current session’s input state table
+        val deviceState = inputStateTable.getOrCreateInputState(id!!, this)
+        try {
+            if (inputSourceType == InputSourceType.KEY) {
+                when (actionType) {
+                    InputSource.ActionType.KEY_DOWN -> dispatchKeyDown(adapter, this, (deviceState as KeyInputState), inputStateTable, tickDuration)
+                    InputSource.ActionType.KEY_UP -> dispatchKeyUp(adapter, this, (deviceState as KeyInputState), inputStateTable, tickDuration)
+                    else -> {}
+                }
+            } else if (inputSourceType == InputSourceType.POINTER) {
+                when (actionType) {
+                    InputSource.ActionType.POINTER_MOVE -> return PointerDispatch.dispatchPointerMove(
+                            adapter,
+                            id,
+                            this,
+                            deviceState as PointerInputState,
+                            tickDuration,
+                            timeAtBeginningOfTick,
+                            inputStateTable.globalKeyInputState
+                    )
+                    InputSource.ActionType.POINTER_DOWN -> {
+                        PointerDispatch.dispatchPointerDown(
+                                adapter,
+                                this,
+                                deviceState as PointerInputState,
+                                inputStateTable,
+                                inputStateTable.globalKeyInputState
+                        )
+                        return null
+                    }
+                    InputSource.ActionType.POINTER_UP -> {
+                        PointerDispatch.dispatchPointerUp(
+                                adapter,
+                                this,
+                                deviceState as PointerInputState,
+                                inputStateTable,
+                                inputStateTable.globalKeyInputState
+                        )
+                        return null
+                    }
+                    InputSource.ActionType.POINTER_CANCEL -> {
+                        PointerDispatch.dispatchPointerCancel(
+                                adapter,
+                                this
+                        )
+                        return null
+                    }
+                    else -> adapter.logger.info(String.format(
+                            "Dispatching pause event for %s milliseconds",
+                            duration
+                    ))
+                }
+            }
+        } catch (cce: ClassCastException) {
+            throw InvalidArgumentException(String.format(
+                    "Attempted to apply action of type '%s' to a source with type '%s': %s",
+                    inputSourceType, deviceState!!.javaClass.simpleName, cce.message
+            ))
+        }
+        return null
+    }
+}

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

@@ -0,0 +1,112 @@
+package io.appium.espressoserver.lib.helpers.w3c.models
+
+import java.util.concurrent.ExecutionException
+import java.util.concurrent.ExecutorCompletionService
+import java.util.concurrent.Executors
+
+import io.appium.espressoserver.lib.handlers.exceptions.AppiumException
+import io.appium.espressoserver.lib.handlers.exceptions.InvalidArgumentException
+import io.appium.espressoserver.lib.handlers.exceptions.NotYetImplementedException
+import io.appium.espressoserver.lib.helpers.w3c.adapter.W3CActionAdapter
+import io.appium.espressoserver.lib.helpers.w3c.dispatcher.BaseDispatchResult
+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.ActionsProcessor.processSourceActionSequence
+
+/**
+ * The algorithm for extracting an action sequence from a request takes the JSON Object representing
+ * an action sequence, validates the input, and returns a data structure that is the transpose of
+ * the input JSON, such that the actions to be performed in a single tick are grouped together
+ *
+ * (Defined in 17.3 of spec 'extract an action sequence')
+ */
+class ActionSequence @Throws(InvalidArgumentException::class, NotYetImplementedException::class)
+constructor(actions: Actions, activeInputSources: ActiveInputSources,
+            inputStateTable: InputStateTable) : Iterator<Tick> {
+
+    private val ticks = arrayListOf<Tick>()
+    private var tickCounter = 0
+
+    init {
+        // Check if null to keep Codacy happy. It will never make it this far if it's null though.
+        actions.actions?.let {
+            for (inputSource in it) {
+                val actionObjects = processSourceActionSequence(inputSource, activeInputSources, inputStateTable)
+                for ((tickIndex, action) in actionObjects.withIndex()) {
+                    if (ticks.size == tickIndex) {
+                        ticks.add(Tick())
+                    }
+                    val tick = ticks[tickIndex]
+                    tick.addAction(action)
+                }
+            }
+        }
+    }
+
+    override fun hasNext(): Boolean {
+        return tickCounter < ticks.size
+    }
+
+    override fun next(): Tick {
+        return ticks[tickCounter++]
+    }
+
+    /**
+     * Call the dispatchAll algorithm defined in 17.4
+     * @param adapter W3C ActionsPerformer adapter
+     * @param inputStateTable Input states for this session
+     * @throws AppiumException
+     * @throws InterruptedException
+     * @throws ExecutionException
+     */
+    @Throws(AppiumException::class, InterruptedException::class, ExecutionException::class)
+    fun dispatch(adapter: W3CActionAdapter, inputStateTable: InputStateTable) {
+        for ((tickIndex, tick) in ticks.withIndex()) {
+            val timeAtBeginningOfTick = System.currentTimeMillis()
+            val tickDuration = tick.calculateTickDuration()
+
+            // 1. Dispatch all of the events
+            adapter.logger.info("Dispatching tick #${tickIndex + 1} of ${ticks.size}")
+            val callables = tick.dispatchAll(adapter, inputStateTable, tickDuration)
+            var callableCount = callables.size
+
+            adapter.sychronousTickActionsComplete()
+
+            // 2. Wait until the following conditions are all met:
+
+            //  2.1 Wait for any pending async operations
+            if (callables.isNotEmpty()) {
+                val executor = Executors.newCachedThreadPool()
+                val completionService = ExecutorCompletionService<BaseDispatchResult>(executor)
+                for (callable in callables) {
+                    completionService.submit(callable)
+                }
+
+                var received = 0
+                while (received < callableCount) {
+                    val resultFuture = completionService.take() //blocks if none available
+                    val dispatchResult = resultFuture.get()
+                    dispatchResult.perform()
+                    if (dispatchResult.hasNext()) {
+                        callableCount++
+                        completionService.submit(dispatchResult.next)
+                    }
+                    received++
+                }
+            }
+
+            //  2.2 At least tick duration milliseconds have passed
+            val timeSinceBeginningOfTick = (System.currentTimeMillis() - timeAtBeginningOfTick).toFloat()
+            if (timeSinceBeginningOfTick < tickDuration) {
+                val timeToSleep = tickDuration - timeSinceBeginningOfTick
+                adapter.logger.info("Wait for tick to finish for $timeToSleep ms")
+                adapter.sleep(timeToSleep)
+            }
+
+            // 2.3 The UI thread is complete
+            adapter.waitForUiThread()
+
+        }
+    }
+}

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

@@ -0,0 +1,89 @@
+/*
+ * 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.models
+
+import io.appium.espressoserver.lib.handlers.exceptions.AppiumException
+import io.appium.espressoserver.lib.helpers.w3c.adapter.W3CActionAdapter
+import io.appium.espressoserver.lib.helpers.w3c.state.ActiveInputSources
+import io.appium.espressoserver.lib.helpers.w3c.state.InputStateTable
+import io.appium.espressoserver.lib.model.AppiumParams
+import java.util.concurrent.ExecutionException
+
+class Actions : AppiumParams() {
+    var actions: List<InputSource>? = null
+    var adapter: W3CActionAdapter? = null
+
+    /**
+     * Perform actions (17.5)
+     * @param sessionId ID of the session to perform actions on
+     * @throws AppiumException
+     */
+    @Throws(AppiumException::class)
+    fun perform(sessionId: String) {
+        if (adapter == null) {
+            throw AppiumException("An internal server error has occurred: Failed to initialize /actions adapter")
+        }
+
+        // Get state of session
+        val activeInputSources = ActiveInputSources.getActiveInputSourcesForSession(sessionId)
+        val inputStateTable = InputStateTable.getInputStateTableOfSession(sessionId)
+
+        // Let `actions by tick` be the result of trying to extract an action sequence with argument parameters
+        adapter!!.logger.info("Performing actions")
+        val actionsByTick = ActionSequence(this, activeInputSources, inputStateTable)
+        try {
+            // Dispatch the actions
+            actionsByTick.dispatch(adapter!!, inputStateTable)
+        } catch (e: InterruptedException) {
+            throw AppiumException(e.cause.toString())
+        } catch (e: ExecutionException) {
+            throw AppiumException(e.cause.toString())
+        }
+    }
+
+    /**
+     * Release actions (17.6)
+     * @param sessionId ID of the session to release actions on
+     */
+    @Throws(AppiumException::class)
+    fun release(sessionId: String) {
+        if (adapter == null) {
+            throw AppiumException("An internal server error has occurred: Failed to initialize /actions adapter")
+        }
+
+        // Get state of session
+        val inputStateTable = InputStateTable.getInputStateTableOfSession(sessionId)
+
+        // Undo all actions
+        adapter!!.logger.info(String.format("Releasing actions performed during session %s", sessionId))
+        inputStateTable.undoAll(adapter!!, System.currentTimeMillis())
+    }
+
+    class ActionsBuilder {
+        private var actions: List<InputSource>? = null
+        private var adapter: W3CActionAdapter? = null
+        fun withActions(actions: List<InputSource>?): ActionsBuilder = apply { this.actions = actions }
+
+        fun withAdapter(adapter: W3CActionAdapter?): ActionsBuilder = apply { this.adapter = adapter }
+
+        fun build(): Actions {
+            val actions = Actions()
+            actions.adapter = adapter
+            actions.actions = this.actions
+            return actions
+        }
+    }
+}

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

@@ -0,0 +1,173 @@
+package io.appium.espressoserver.lib.helpers.w3c.models
+
+import com.google.gson.annotations.SerializedName
+import io.appium.espressoserver.lib.helpers.w3c.state.InputState
+import io.appium.espressoserver.lib.helpers.w3c.state.KeyInputState
+import io.appium.espressoserver.lib.helpers.w3c.state.PointerInputState
+
+/**
+ * InputSource
+ *
+ * (refer to https://www.w3.org/TR/webdriver/#terminology-0 of W3C spec)
+ *
+ * Represents a Virtual Device providing input events
+ */
+@Suppress("unused")
+class InputSource {
+    var type: InputSourceType? = null
+    var id: String? = null
+    var parameters: Parameters? = null
+    var actions: List<Action>? = null
+    private val state: InputState? = null
+
+    constructor() {}
+    constructor(type: InputSourceType?, id: String?, parameters: Parameters?, actions: List<Action>?) {
+        this.type = type
+        this.id = id
+        this.parameters = parameters
+        this.actions = actions
+    }
+
+    /**
+     * Get the initial state of an Input Source
+     * @return Get the initial input state (see 17.3 for info on Input State)
+     */
+    val defaultState: InputState?
+        get() = when (type) {
+            InputSourceType.POINTER -> PointerInputState(pointerType)
+            InputSourceType.KEY -> KeyInputState()
+            else -> null
+        }
+
+    // NOTE: The spec specifies that the default should be MOUSE. This is an exception
+    // because the vast majority of use cases on a mobile device will use TOUCH.
+    val pointerType: PointerType?
+        get() {
+            if (parameters != null) {
+                return parameters!!.pointerType
+            } else if (type == InputSourceType.POINTER) {
+                // NOTE: The spec specifies that the default should be MOUSE. This is an exception
+                // because the vast majority of use cases on a mobile device will use TOUCH.
+                return PointerType.TOUCH
+            }
+            return null
+        }
+
+    enum class InputSourceType {
+        @SerializedName("pointer")
+        POINTER,
+        @SerializedName("key")
+        KEY,
+        @SerializedName("none")
+        NONE
+    }
+
+    class Action {
+        var type // type of action
+                : ActionType? = null
+        var duration // time in milliseconds
+                : Float? = null
+        var button // Button that is being pressed. Defaults to 0.
+                : Int? = null
+            get() { return field ?: 0 }
+        var x // x coordinate of pointer
+                : Float? = null
+        var y // y coordinate of pointer
+                : Float? = null
+        var value // a string containing a single Unicode code point or a number
+                : String? = null
+        var origin = Origin() // origin; could be viewport, pointer or <{element-6066-11e4-a52e-4f735466cecf: <element-uuid>}>
+
+        val isOriginViewport: Boolean
+            get() = origin.type != null && origin.type.equals(Origin.VIEWPORT, ignoreCase = true)
+
+        val isOriginPointer: Boolean
+            get() = origin.type != null && origin.type.equals(Origin.POINTER, ignoreCase = true)
+
+        val isOriginElement: Boolean
+            get() = origin.type != null && origin.type.equals(Origin.ELEMENT, ignoreCase = true)
+    }
+
+    enum class ActionType {
+        @SerializedName("pause")
+        PAUSE,
+        @SerializedName("pointerDown")
+        POINTER_DOWN,
+        @SerializedName("pointerUp")
+        POINTER_UP,
+        @SerializedName("pointerMove")
+        POINTER_MOVE,
+        @SerializedName("pointerCancel")
+        POINTER_CANCEL,
+        @SerializedName("keyUp")
+        KEY_UP,
+        @SerializedName("keyDown")
+        KEY_DOWN
+    }
+
+    class Parameters {
+        var pointerType: PointerType? = null
+    }
+
+    enum class PointerType {
+        @SerializedName("mouse")
+        MOUSE,
+        @SerializedName("pen")
+        PEN,
+        @SerializedName("touch")
+        TOUCH
+    }
+
+    class InputSourceBuilder {
+        private var type: InputSourceType? = null
+        private var id: String? = null
+        private var parameters: Parameters? = null
+        private var actions: List<Action>? = null
+        fun withType(type: InputSourceType?): InputSourceBuilder = apply { this.type = type }
+        fun withId(id: String?): InputSourceBuilder = apply { this.id = id }
+        fun withParameters(parameters: Parameters?): InputSourceBuilder = apply { this.parameters = parameters }
+        fun withActions(actions: List<Action>?): InputSourceBuilder = apply { this.actions = actions }
+        fun build(): InputSource {
+            val inputSource = InputSource()
+            inputSource.actions = actions
+            inputSource.type = type
+            inputSource.id = id
+            inputSource.parameters = parameters
+            return inputSource
+        }
+    }
+
+    class ActionBuilder {
+        private var type: ActionType? = null
+        private var duration: Long? = null
+        private var button: Int? = null
+        private var x: Long? = null
+        private var y: Long? = null
+        private var value: String? = null
+        private var origin = Origin()
+        fun withType(type: ActionType?): ActionBuilder = apply { this.type = type }
+        fun withDuration(duration: Long?): ActionBuilder = apply { this.duration = duration }
+        fun withButton(button: Int?): ActionBuilder = apply { this.button = button }
+        fun withX(x: Long?): ActionBuilder = apply { this.x = x }
+        fun withY(y: Long?): ActionBuilder = apply { this.y = y }
+        fun withValue(value: String?): ActionBuilder = apply { this.value = value }
+        fun withOrigin(origin: Origin): ActionBuilder = apply { this.origin = origin }
+        fun withOriginType(originType: String?): ActionBuilder = apply { this.origin.type = originType }
+        fun withOriginElementId(elementId: String?): ActionBuilder = apply {
+            this.origin.type = Origin.ELEMENT
+            this.origin.elementId = elementId
+        }
+
+        fun build(): Action {
+            val action = Action()
+            duration?.let { action.duration = it.toFloat() }
+            action.type = type
+            button?.let { action.button = it }
+            action.value = value
+            x?.let { action.x = it.toFloat() }
+            y?.let { action.y = it.toFloat() }
+            action.origin = origin
+            return action
+        }
+    }
+}

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

@@ -0,0 +1,24 @@
+package io.appium.espressoserver.lib.helpers.w3c.models
+
+import com.google.gson.annotations.JsonAdapter
+
+@JsonAdapter(OriginDeserializer::class)
+class Origin {
+    var type: String? = VIEWPORT
+    var elementId: String? = null
+
+    constructor()
+    constructor(type: String) {
+        this.type = type
+    }
+    constructor(type: String, elementId: String) {
+        this.type = type
+        this.elementId = elementId
+    }
+
+    companion object {
+        const val VIEWPORT = "viewport"
+        const val POINTER = "pointer"
+        const val ELEMENT = "element-6066-11e4-a52e-4f735466cecf"
+    }
+}

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

@@ -0,0 +1,25 @@
+package io.appium.espressoserver.lib.helpers.w3c.models
+
+import com.google.gson.JsonDeserializationContext
+import com.google.gson.JsonDeserializer
+import com.google.gson.JsonElement
+import com.google.gson.JsonParseException
+import java.lang.reflect.Type
+
+class OriginDeserializer : JsonDeserializer<Origin> {
+    @Throws(JsonParseException::class)
+    override fun deserialize(json: JsonElement, paramType: Type,
+                             paramJsonDeserializationContext: JsonDeserializationContext): Origin {
+        val origin = Origin()
+        if (json.isJsonPrimitive) {
+            origin.type = json.asString
+        } else if (json.isJsonObject && json.asJsonObject[Origin.ELEMENT].isJsonPrimitive) {
+            val elementId = json.asJsonObject[Origin.ELEMENT].asString
+            origin.elementId = elementId
+            origin.type = Origin.ELEMENT
+        } else if (json.isJsonNull) {
+            origin.type = Origin.VIEWPORT
+        }
+        return origin
+    }
+}

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

@@ -0,0 +1,62 @@
+package io.appium.espressoserver.lib.helpers.w3c.models
+
+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.BaseDispatchResult
+import io.appium.espressoserver.lib.helpers.w3c.models.InputSource.InputSourceType
+import io.appium.espressoserver.lib.helpers.w3c.state.InputStateTable
+import java.util.*
+import java.util.concurrent.Callable
+
+class Tick : Iterator<ActionObject> {
+    private val tickActions: MutableList<ActionObject> = ArrayList()
+    private var actionCounter = 0
+    fun addAction(action: ActionObject) {
+        tickActions.add(action)
+    }
+
+    override fun hasNext(): Boolean {
+        return actionCounter < tickActions.size
+    }
+
+    override fun next(): ActionObject {
+        return tickActions[actionCounter++]
+    }
+
+    /**
+     * Get max tick duration for a tick
+     * @return Max tick duration
+     */
+    fun calculateTickDuration(): Float {
+        var maxDuration = 0f
+        for (actionObject in tickActions) {
+            var currDuration = 0.0f
+            val type = actionObject.type
+            val duration = actionObject.duration
+            val subType = actionObject.subType
+            if (duration != null && (subType === InputSource.ActionType.PAUSE
+                            || type === InputSourceType.POINTER && subType === InputSource.ActionType.POINTER_MOVE)) {
+                currDuration = duration
+            }
+            if (currDuration > maxDuration) {
+                maxDuration = currDuration
+            }
+        }
+        return maxDuration
+    }
+
+    @Throws(AppiumException::class)
+    fun dispatchAll(adapter: W3CActionAdapter, inputStateTable: InputStateTable, tickDuration: Float): List<Callable<BaseDispatchResult>> {
+        val timeAtBeginningOfTick = System.currentTimeMillis()
+        val asyncOperations: MutableList<Callable<BaseDispatchResult>> = ArrayList()
+        for (actionObject in tickActions) {
+            // 2. Run algorithm with arguments source id, action object, device state and tick duration
+            val dispatchResult = actionObject.dispatch(adapter,
+                    inputStateTable, tickDuration, timeAtBeginningOfTick)
+
+            // If it's an async operation, add it to the list
+            dispatchResult?.let { asyncOperations.add(it) }
+        }
+        return asyncOperations
+    }
+}