appium-espresso-driver 1.46.0

package/espresso-server/app/src/androidTest/java/io/appium/espressoserver/lib/handlers/exceptions/NoSuchDriverException.kt

@@ -0,0 +1,31 @@
+/*
+ * 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.handlers.exceptions
+
+import fi.iki.elonen.NanoHTTPD
+
+class NoSuchDriverException : AppiumException {
+    constructor(message: String) : super(message)
+
+    override fun error(): String {
+        return "invalid session id"
+    }
+
+    override fun status(): NanoHTTPD.Response.Status {
+        return NanoHTTPD.Response.Status.NOT_FOUND
+    }
+}

package/espresso-server/app/src/androidTest/java/io/appium/espressoserver/lib/handlers/exceptions/NoSuchElementException.kt

@@ -0,0 +1,34 @@
+/*
+ * 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.handlers.exceptions
+
+import fi.iki.elonen.NanoHTTPD
+
+class NoSuchElementException : AppiumException {
+
+    constructor(reason: String): super(reason)
+
+    constructor(reason: String, e: Throwable): super(reason, e)
+
+    override fun error(): String {
+        return "no such element"
+    }
+
+    override fun status(): NanoHTTPD.Response.Status {
+        return NanoHTTPD.Response.Status.NOT_FOUND
+    }
+}

package/espresso-server/app/src/androidTest/java/io/appium/espressoserver/lib/handlers/exceptions/NotYetImplementedException.kt

@@ -0,0 +1,33 @@
+/*
+ * 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.handlers.exceptions
+
+import fi.iki.elonen.NanoHTTPD
+
+class NotYetImplementedException : AppiumException {
+    constructor() : super("The operation requested is not yet implemented by Espresso driver") {}
+
+    constructor(message: String) : super(message) {}
+
+    override fun error(): String {
+        return "unknown method"
+    }
+
+    override fun status(): NanoHTTPD.Response.Status {
+        return NanoHTTPD.Response.Status.NOT_FOUND
+    }
+}

package/espresso-server/app/src/androidTest/java/io/appium/espressoserver/lib/handlers/exceptions/ScreenCaptureException.kt

@@ -0,0 +1,30 @@
+/*
+ * 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.handlers.exceptions
+
+import fi.iki.elonen.NanoHTTPD
+
+
+class ScreenCaptureException(reason: String) : AppiumException(reason) {
+    override fun error(): String {
+        return "unable to capture screen"
+    }
+
+    override fun status(): NanoHTTPD.Response.Status {
+        return NanoHTTPD.Response.Status.INTERNAL_ERROR
+    }
+}

package/espresso-server/app/src/androidTest/java/io/appium/espressoserver/lib/handlers/exceptions/SessionNotCreatedException.kt

@@ -0,0 +1,34 @@
+/*
+ * 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.handlers.exceptions
+
+import fi.iki.elonen.NanoHTTPD
+
+class SessionNotCreatedException: AppiumException {
+
+    constructor(reason: String) : super(reason) {}
+
+    constructor(cause: Throwable) : super(cause) {}
+
+    override fun error(): String {
+        return "session not created"
+    }
+
+    override fun status(): NanoHTTPD.Response.Status {
+        return NanoHTTPD.Response.Status.INTERNAL_ERROR
+    }
+}

package/espresso-server/app/src/androidTest/java/io/appium/espressoserver/lib/handlers/exceptions/StaleElementException.kt

@@ -0,0 +1,30 @@
+/*
+ * 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.handlers.exceptions
+
+import fi.iki.elonen.NanoHTTPD
+
+class StaleElementException(elementId: String) :
+        AppiumException(String.format("The cached element %s no longer exists in the Android View hierarchy. Try to find it using a locator.", elementId)) {
+    override fun error(): String {
+        return "stale element reference"
+    }
+
+    override fun status(): NanoHTTPD.Response.Status {
+        return NanoHTTPD.Response.Status.NOT_FOUND
+    }
+}

package/espresso-server/app/src/androidTest/java/io/appium/espressoserver/lib/handlers/exceptions/XPathLookupException.kt

@@ -0,0 +1,31 @@
+/*
+ * 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.handlers.exceptions
+
+import fi.iki.elonen.NanoHTTPD
+
+
+class XPathLookupException(xpath: String, reason: String) :
+        AppiumException(String.format("Could not parse XPath %s: %s", xpath, reason)) {
+    override fun error(): String {
+        return "invalid selector"
+    }
+
+    override fun status(): NanoHTTPD.Response.Status {
+        return NanoHTTPD.Response.Status.BAD_REQUEST
+    }
+}

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

@@ -0,0 +1,15 @@
+package io.appium.espressoserver.lib.helpers
+
+import android.app.UiAutomation
+import android.os.Build
+import androidx.test.platform.app.InstrumentationRegistry
+import androidx.test.uiautomator.Configurator
+
+fun setAccessibilityServiceState() {
+    InstrumentationRegistry.getArguments().getString("DISABLE_SUPPRESS_ACCESSIBILITY_SERVICES")?.let { flag ->
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
+            Configurator.getInstance().uiAutomationFlags =
+                    if (flag.toBoolean()) UiAutomation.FLAG_DONT_SUPPRESS_ACCESSIBILITY_SERVICES else 0
+        }
+    }
+}

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

@@ -0,0 +1,125 @@
+/*
+ * 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
+
+import android.app.Activity
+import android.content.Context
+import android.os.Build
+import android.util.ArrayMap
+import androidx.test.platform.app.InstrumentationRegistry
+import androidx.test.runner.lifecycle.ActivityLifecycleMonitorRegistry
+import androidx.test.runner.lifecycle.Stage
+import io.appium.espressoserver.lib.helpers.ReflectionUtils.extractField
+import io.appium.espressoserver.lib.model.StartActivityParams
+import io.appium.espressoserver.lib.model.mapToLocaleParams
+
+object ActivityHelpers {
+    val currentActivity: Activity
+        get() {
+            val method1 = fun(): Activity? {
+                // https://stackoverflow.com/questions/38737127/espresso-how-to-get-current-activity-to-test-fragments/58684943#58684943
+                var result: Activity? = null
+                InstrumentationRegistry.getInstrumentation()
+                        .runOnMainSync {
+                            run {
+                                result = ActivityLifecycleMonitorRegistry.getInstance()
+                                        .getActivitiesInStage(Stage.RESUMED)
+                                        .elementAtOrNull(0)
+                            }
+                        }
+                return result
+            }
+            val method2 = fun(): Activity? {
+                //    https://androidreclib.wordpress.com/2014/11/22/getting-the-current-activity/
+                try {
+                    val activityThreadClass = Class.forName("android.app.ActivityThread")
+                    val activityThread = activityThreadClass.getMethod("currentActivityThread").invoke(null)
+                    val activities = extractField(activityThreadClass, "mActivities", activityThread) as ArrayMap<*, *>
+                    return activities.values
+                            .map { Pair(extractField(it.javaClass, "paused", it) as Boolean, it) }
+                            .filter { !it.first }
+                            .map { extractField(it.second.javaClass, "activity", it.second) as Activity }
+                            .firstOrNull()
+                } catch (e: Exception) {
+                    // ignore
+                }
+                return null
+            }
+            for (method in listOf(method1, method2)) {
+                val result = method()
+                if (result != null) {
+                    return result
+                }
+            }
+
+            throw IllegalStateException("Cannot retrieve the current activity")
+        }
+
+    /**
+     * https://android.googlesource.com/platform/frameworks/base/+/master/tools/aapt/Resource.cpp#755
+     *
+     * @param context Target context instance
+     * @param pkg app package name
+     * @param activity activity name shortcut to be qualified
+     * @return The qualified activity name
+     */
+    private fun getFullyQualifiedActivityName(context: Context, pkg: String?, activity: String): String {
+        val appPackage = pkg ?: context.packageName
+        val dotPos = activity.indexOf(".")
+        return (if (dotPos > 0) activity else "$appPackage${(if (dotPos == 0) "" else ".")}$activity")
+    }
+
+    fun startActivity(params: StartActivityParams) {
+        if (params.appActivity == null && params.optionalIntentArguments == null) {
+            throw IllegalArgumentException("Either activity name or intent options must be set")
+        }
+
+        val instrumentation = InstrumentationRegistry.getInstrumentation()
+        params.locale?.let {
+            changeLocale(instrumentation.targetContext.applicationContext, mapToLocaleParams(it).toLocale())
+        }
+
+        val intent = if (params.optionalIntentArguments == null) {
+            val fullyQualifiedAppActivity = getFullyQualifiedActivityName(instrumentation.targetContext,
+                    params.appPackage, params.appActivity!!)
+            val defaultOptions = mapOf<String, Any>(
+                    "action" to "ACTION_MAIN",
+                    "flags" to "ACTIVITY_NEW_TASK",
+                    "className" to fullyQualifiedAppActivity
+            )
+            AndroidLogger.info("Starting activity '$fullyQualifiedAppActivity' " +
+                    "with default options: $defaultOptions")
+            makeIntent(instrumentation.targetContext, defaultOptions)
+        } else {
+            AndroidLogger.info("Staring activity with custom options: ${params.optionalIntentArguments}")
+            makeIntent(instrumentation.targetContext, params.optionalIntentArguments)
+        }
+
+        if (params.optionalActivityArguments == null) {
+            instrumentation.startActivitySync(intent)
+        } else {
+            makeActivityOptions(params.optionalActivityArguments).let {
+                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P) {
+                    instrumentation.startActivitySync(intent, it.toBundle())
+                } else {
+                    instrumentation.targetContext.startActivity(intent, it.toBundle())
+                }
+            }
+        }
+    }
+
+}

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

@@ -0,0 +1,60 @@
+/*
+ * 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
+
+import android.app.ActivityOptions
+import kotlin.reflect.full.cast
+
+/**
+ * Creates an options using the given activityOptions
+ *
+ * @param activityOptions mapping. The mapping can have the following keys:
+ * - `launchDisplayId`: display id which you want to launch, such as {"launchDisplayId":"1"}
+ * @return The created options
+ * @throws IllegalArgumentException if required options are missing or
+ * there is an issue with mapping value format
+ */
+
+fun makeActivityOptions(activityOptions: Map<String, Any?>?): ActivityOptions {
+    val options = ActivityOptions.makeBasic()
+    val handlersMapping = mapOf<String, (key: String, value: Any?) -> Unit>(
+            "launchDisplayId" to fun(_, value) {
+                try {
+                    if (String::class.isInstance(value)) {
+                        options.launchDisplayId = String::class.cast(value).toInt()
+                    } else if (Number::class.isInstance(value)) {
+                        options.launchDisplayId = Number::class.cast(value).toInt()
+                    } else {
+                        throw IllegalArgumentException(
+                                "The value of 'launchDisplayId' must be of type 'String' or 'Number'. '$value' is given instead")
+                    }
+                } catch (e: NumberFormatException) {
+                    throw IllegalArgumentException(
+                            "Can't covert '$value' to Int", e)
+                }
+            }
+    )
+    activityOptions?.let {
+        for ((optName: String, optValue: Any?) in it.entries) {
+            val handler = handlersMapping[optName]
+                    ?: throw IllegalArgumentException("The option named '$optName' is not known. " +
+                            "Only the following options are supported: ${handlersMapping.keys}")
+            handler(optName, optValue)
+        }
+    }
+    return options
+}

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

@@ -0,0 +1,170 @@
+/*
+ * 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
+
+import java.util.ArrayList
+import java.util.Collections
+import java.util.HashMap
+import java.util.regex.Pattern
+import androidx.test.uiautomator.By
+import androidx.test.uiautomator.UiObject2
+import io.appium.espressoserver.lib.handlers.exceptions.InvalidElementStateException
+import io.appium.espressoserver.lib.handlers.exceptions.NoAlertOpenException
+
+import io.appium.espressoserver.lib.helpers.InteractionHelper.getUiDevice
+
+object AlertHelpers {
+    private const val regularAlertButtonResIdPrefix = "android:id/button"
+    private val regularAlertButtonResIdPattern = Pattern.compile("^$regularAlertButtonResIdPrefix\\d+$")
+    private const val alertContentResId = "android:id/content"
+    private val regularAlertTitleResIdPattern = Pattern.compile(".+:id/(alertTitle|custom)$")
+    private val permissionAlertTitleResIdPattern = Pattern.compile(".+:id/permission_message$")
+    private val permissionAlertButtonResIdPattern = Pattern.compile(".+:id/permission_\\w+_button$")
+    private val alertElementsResIdPattern = Pattern.compile(".+:id/.+")
+
+    private val alertType: AlertType
+        @Throws(NoAlertOpenException::class)
+        get() {
+            getUiDevice().waitForIdle()
+
+            if (getUiDevice().findObjects(By.res(regularAlertTitleResIdPattern)).isNotEmpty()) {
+                AndroidLogger.debug("Regular alert has been detected")
+                return AlertType.REGULAR
+            }
+            if (getUiDevice().findObjects(By.res(permissionAlertTitleResIdPattern)).isNotEmpty()) {
+                AndroidLogger.debug("Permission alert has been detected")
+                return AlertType.PERMISSION
+            }
+
+            throw NoAlertOpenException()
+        }
+
+    /**
+     * @return The actual text of the on-screen dialog. An empty
+     * string is going to be returned if the dialog contains no text.
+     * @throws NoAlertOpenException if no dialog is present on the screen
+     */
+    val text: String
+        @Throws(NoAlertOpenException::class)
+        get() {
+            val alertType = alertType
+
+            val alertRoots = getUiDevice().findObjects(By.res(alertContentResId))
+            if (alertRoots.isEmpty()) {
+                AndroidLogger.warn("Alert content container is missing")
+                throw NoAlertOpenException()
+            }
+
+            val alertElements = alertRoots[0].findObjects(By.res(alertElementsResIdPattern))
+            AndroidLogger.debug("Detected ${alertElements.size} alert elements")
+            val alertButtonsResIdPattern = if (alertType == AlertType.REGULAR)
+                regularAlertButtonResIdPattern.toString()
+            else
+                permissionAlertButtonResIdPattern.toString()
+            return alertElements.toTypedArray()
+                    .filter { it.resourceName != null && !it.resourceName.matches(alertButtonsResIdPattern.toRegex()) }
+                    .filter { (it.text ?: "").isNotEmpty() }
+                    .joinToString(separator = "\n")
+        }
+
+    private fun buttonResIdByIdx(index: Int): String {
+        return "$regularAlertButtonResIdPrefix$index"
+    }
+
+    private fun filterButtonByLabel(buttons: Collection<UiObject2>, label: String?): UiObject2? {
+        return buttons.toTypedArray().firstOrNull { it.text == label }
+    }
+
+    private fun getRegularAlertButton(action: AlertAction, buttonLabel: String?): UiObject2? {
+        val alertButtonsMapping = HashMap<String, UiObject2>()
+        val buttonIndexes = ArrayList<Int>()
+        for (button in getUiDevice().findObjects(By.res(regularAlertButtonResIdPattern))) {
+            val resId = button.resourceName
+            alertButtonsMapping[resId] = button
+            buttonIndexes.add(Integer.parseInt(resId.substring(regularAlertButtonResIdPrefix.length)))
+        }
+        if (alertButtonsMapping.isEmpty()) {
+            return null
+        }
+        AndroidLogger.debug("Found ${alertButtonsMapping.size} buttons on the alert")
+
+        if (buttonLabel == null) {
+            val minIdx = Collections.min(buttonIndexes)
+            return if (action == AlertAction.ACCEPT)
+                alertButtonsMapping[buttonResIdByIdx(minIdx)]
+            else
+                alertButtonsMapping[buttonResIdByIdx(if (alertButtonsMapping.size > 1) minIdx + 1 else minIdx)]
+        }
+        return filterButtonByLabel(alertButtonsMapping.values, buttonLabel)
+    }
+
+    private fun getPermissionAlertButton(action: AlertAction, buttonLabel: String?): UiObject2? {
+        val buttons = getUiDevice().findObjects(By.res(permissionAlertButtonResIdPattern))
+        if (buttons.isEmpty()) {
+            return null
+        }
+        AndroidLogger.debug("Found ${buttons.size} buttons on the alert")
+
+        if (buttonLabel == null) {
+            if (action == AlertAction.ACCEPT) {
+                return if (buttons.size > 1) buttons[1] else buttons[0]
+            }
+            if (action == AlertAction.DISMISS) {
+                return buttons[0]
+            }
+        } else {
+            return filterButtonByLabel(buttons, buttonLabel)
+        }
+        return null
+    }
+
+    /**
+     * Accept or dismiss on-screen alert.
+     *
+     * @param action      either ACCEPT or DISMISS
+     * @param buttonLabel if this parameter is set then the method
+     * will look for the dialog button with this particular
+     * text instead of the default one (usually it is the first button
+     * for ACCEPT and the last one for DISMISS action)
+     * @return the actual label of the clicked button
+     * @throws NoAlertOpenException         if no dialog is present on the screen
+     * @throws InvalidElementStateException if no matching button can be found
+     */
+    @Throws(InvalidElementStateException::class, NoAlertOpenException::class)
+    fun handle(action: AlertAction, buttonLabel: String?): String {
+        val alertType = alertType
+
+        val dstButton = (if (alertType == AlertType.REGULAR)
+            getRegularAlertButton(action, buttonLabel)
+        else
+            getPermissionAlertButton(action, buttonLabel))
+                ?: throw InvalidElementStateException("The expected button cannot be detected on the alert")
+
+        val actualLabel = dstButton.text
+        AndroidLogger.info("Clicking alert button '$actualLabel' in order to ${action.name.toLowerCase()} it")
+        dstButton.click()
+        return actualLabel
+    }
+
+    enum class AlertAction {
+        ACCEPT, DISMISS
+    }
+
+    enum class AlertType {
+        REGULAR, PERMISSION
+    }
+}

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

@@ -0,0 +1,45 @@
+/*
+ * 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
+
+const val TAG = "appium"
+
+object AndroidLogger : Logger {
+
+    override fun error(vararg messages: Any) {
+        android.util.Log.e(TAG, toString(*messages))
+    }
+
+    override fun error(message: String, throwable: Throwable) {
+        android.util.Log.e(TAG, toString(message), throwable)
+    }
+
+    override fun info(vararg messages: Any) {
+        android.util.Log.i(TAG, toString(*messages))
+    }
+
+    override fun debug(vararg messages: Any) {
+        android.util.Log.d(TAG, toString(*messages))
+    }
+
+    override fun warn(vararg messages: Any) {
+        android.util.Log.w(TAG, toString(*messages))
+    }
+
+    private fun toString(vararg args: Any): String =
+            args.toList().joinToString(separator = "") { "$it" }
+}

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

@@ -0,0 +1,17 @@
+package io.appium.espressoserver.lib.helpers
+
+import com.google.gson.JsonObject
+import com.google.gson.JsonParseException
+
+object AssertHelpers {
+
+    fun assertIsPrimitive(obj: JsonObject, propName: String) {
+        obj.get(propName)?.let { if (it.isJsonPrimitive) return; }
+        throw JsonParseException("'${propName}' property is required and must be a JSON primitive")
+    }
+
+    fun assertIsPresent(obj: JsonObject, propName: String) {
+        obj.get(propName) ?: throw JsonParseException("'${propName}' is a required field");
+    }
+
+}