diff --git a/.gitignore b/.gitignore
index b7e2314ee..a9c4cf5c4 100644
--- a/.gitignore
+++ b/.gitignore
@@ -9,4 +9,6 @@ test/data/output
 test/acceptance/output
 examples/output
 test/data/app/db
-test/data/sandbox/steps.d.ts
\ No newline at end of file
+test/data/sandbox/steps.d.ts
+testpullfilecache*
+.DS_Store
diff --git a/.travis.yml b/.travis.yml
index 15821580a..cbc1b32b0 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -1,38 +1,34 @@
 language: node_js
 node_js:
-  - '4.3'
-  - '6.9.5'
-  - '7'
-
-
+- 6.9.5
+- '7'
 sudo: required
 dist: trusty
-
 env:
+  global:
+  - secure: vLPyF/U+KhmWAXMkcrYFben6Qo5Tsk9nExbb/YTxCCqtpu5FlCcKZ0h/7OXJT9sXR7t8dmz564VbAtbhazPU+2FdpxIoR/D6OUeZa1WhyB5GGfpfHmfIe1hQTsZg0B0zGrrpcLBeaTA1E7+0lBhIKj9S1FoApa6xfP21bju+IddpD881m0bdF/2gEiBrabWHoQieWLNgS4EzUI5IcOknz4bk3nx6ztldJOokwTqUy2RgtVbMkJf0v6LbBOxT5uCwlLYxllDwY6fIatPP7Gol5V2fxMYhp4k/QSeULy81EJBpVhW0Bw5FfGBBVnqk495fhCjRNbjwzcs2zz2dD1i99KeIFhfKYQsfto7odHbt0kasYgaQQUZEZsbY6ScYMDXnzprTCotolmPXJmqu0rHnUfa2ZZxl9/jNis1IoCdwsvJ+cemL13fw9llFvnMGtmqDc9ltjzKoRfi8rpUH5x6EbnUE6vdr0RDA+D3mUbFr2kxlMwQPTpujnxOghpuDnDc/2CGe17uklssw2g2vMxdIuiqxXvKkeN0xBddtlbUx2PwRrecjCmv7RE13j+ERsIysDQUkTMnXTWBumtVGmdxZpFhxD7wwmVFi3qjq4FGyO3f8alnfYOBspPhLgC2PTJGS/X23C9LC08tFl6MpeHD97HUaW6bx+ObI2/0jBsDXB3k=
+  - secure: OlLkzBUwlRFIa5xDWEs/It6ofSfC+pXRVt17kTyox8beH5qu5Ks3/Zwa48YMqHKnbNHI7hiRBO2YfsJgjYJoQ5/ovKPa3rvffNXdKeDZpt+lQqlhjJYpgp0pNgck45RKnFj1pKpQCVG6dWWcT59Gi8NoI8AsAVCVgFtO8McfV8qbks6G2UP0GdFR5s6tRyZTjfCVmMNtJX9veYuibwoiwRyFhh1FY+sw5BvAONSBdOWmcK7RdDm7IE+Oitzn3bRZnC6sgLNpy6qhncED/pbn4GFD5MRlu0UkDGDfXldsOyjOtqdaN5WbOGdhevaYgr/5VvSeMbO7fITlDXbhz9pViogl6fnxj0zELZvG6b6H7nAVV29uzHP4jofocP41h33rvYnQUTfNHN8HIRN4LVfekN2I27GDO+J1QFiWNN/36nhsRH9tWPwSNC2f9QLIf6OrD60FVUIMlQrFHqyrO4KZBZkRsGMgYzsa5XmGOGUATUBrmQVTynNQc+yhniJd4Q8LwwmXMDWNeoeg5eh0TFgERVDlkQ8tPaWOXmpHi6BL4JZlGz275SDWgZH4bnH2B1RzO1qcGN905vIo5snX8LwZbxSfXrt+4WP3jOi+1i8ZrFwACk7jlovJiJquQuZQ5dL7C9rBwpAWB8YjgOKNikDWvUrVnYGS/gLwrdN7+pRiims=
+  matrix:
   - HELPER=Protractor
   - HELPER=Nightmare
   - HELPER=SeleniumWebdriver
   - HELPER=WebDriverIO
-
+  - HELPER=Appium
 addons:
   apt:
     packages:
-      - php5-cli
-
+    - php5-cli
 services:
-  - docker
-
+- docker
 before_install:
-  - docker pull selenium/standalone-chrome:2.53.0
-
+- docker pull selenium/standalone-chrome:2.53.0
 before_script:
-  - docker run -d --net=host selenium/standalone-chrome:2.53.0
-  - export DISPLAY=:99.0
-  - sh -e /etc/init.d/xvfb start
-  - chmod -R 777 test/data
-  - "php -S 127.0.0.1:8000 -t test/data/app >/dev/null 2>&1 &"
-  - sleep 10
-
+- docker run -d --net=host selenium/standalone-chrome:2.53.0
+- export DISPLAY=:99.0
+- sh -e /etc/init.d/xvfb start
+- chmod -R 777 test/data
+- php -S 127.0.0.1:8000 -t test/data/app >/dev/null 2>&1 &
+- sleep 10
 script:
-  - gulp test
-  - '[[ "$TRAVIS_NODE_VERSION" == "4.3" ]] || ./node_modules/.bin/mocha test/helper/${HELPER}_test.js'
\ No newline at end of file
+- gulp test
+- './node_modules/.bin/mocha test/helper/${HELPER}_test.js'
diff --git a/docs/helpers/Appium.md b/docs/helpers/Appium.md
new file mode 100644
index 000000000..63dd4bb15
--- /dev/null
+++ b/docs/helpers/Appium.md
@@ -0,0 +1,1611 @@
+Appium helper is extends from WebriverIO. It's support all browser methods and also includes special methods for mobile apps testing. You can use this helper to test Web on desktop and mobile devices and mobile apps.
+
+#### Appium Installation
+
+Appium is an open source test automation framework for use with native, hybrid and mobile web apps that implements the WebDriver protocol.
+It allows you to run Selenium tests on mobile devices and also test native, hybrid and mobile web apps.
+
+1.  Download and install [Appium](http://appium.io/)
+
+    ```
+    npm i -g appium
+    ```
+2. Download and install Android SDK or Android Studio to manage emulators from [Android Studio site](https://developer.android.com/studio/index.html#downloads)
+3. Set the $ANDROID_HOME env variable to your Android SDK path
+
+    Example:
+    ```
+     export ANDROID_HOME=/Users/bestUser/Library/Android/sdk
+    ```
+4. Add Android SDK tools to $PATH
+
+    Example:
+    ```
+    export PATH="${ANDROID_HOME}/tools:$PATH"
+    export PATH="${ANDROID_HOME}/tools/bin:$PATH"
+    ```
+5. Add Java Home bin directory to $PATH
+
+    Example:
+    ```
+    export PATH="${JAVA_HOME}/bin:$PATH"
+    ```
+6. Create and launch emulator:
+    
+    From Android Studio:
+    * Create any empty android application
+    * Create emulator using this [documentation](https://developer.android.com/studio/run/managing-avds.html)
+   * Note that x86 emulators works much faster as ARM emulators, but you can use them only on Mac and Linux.
+   * Launch emulator from interface
+   
+    From Command line:
+   * Create emulator using [avdmanager commandline tool](https://developer.android.com/studio/command-line/avdmanager.html)
+   * Launch emulator using [emulator commandline tool](https://developer.android.com/studio/run/emulator-commandline.html)
+7. Test that Appium is installed correctly using `appium-doctor`
+
+    ```
+    npm i -g appium-doctor
+    appium-doctor
+    ```
+    If there are any issues, you have to fix them before Appium launch
+
+8.  Launch the daemon: `appium`
+9. Also on Mac you can launch tests for iOS devices. For this, install xcode from App store. You can get detailed information [here](http://appium.io/slate/en/master/?ruby#running-appium-on-mac-os-x)
+
+
+
+### Configuration
+
+This helper should be configured in codecept.conf.js
+
+#### Appium configuration
+
+-   `port`: Appium server port
+-   `restart`: restart browser or app between tests (default: true), if set to false cookies will be cleaned but browser window will be kept and for apps nothing will be changed.
+-   `desiredCapabilities`: Appium capabilities
+--   `platformName` - Which mobile OS platform to use
+--   `appPackage` - Java package of the Android app you want to run
+--   `appActivity` - Activity name for the Android activity you want to launch from your package.
+--   `deviceName`: The kind of mobile device or emulator to use
+--   `platformVersion`: Mobile OS version
+--   `app` - The absolute local path or remote http URL to an .ipa or .apk file, or a .zip containing one of these. Appium will attempt to install this app binary on the appropriate device first.
+--   `browserName`: Name of mobile web browser to automate. Should be an empty string if automating an app instead.
+
+Example:
+
+```js
+ {
+   helpers: {
+       Appium: {
+           desiredCapabilities: {
+               platformName: "Android",
+               appPackage: "com.example.android.myApp",
+               appActivity: "MainActivity",
+               deviceName: "OnePlus3",
+               platformVersion: "6.0.1"
+           },
+           port: 4723,
+           restart: false
+       }
+    }
+ }
+```
+Additional configuration params can be used from <https://github.com/appium/appium/blob/master/docs/en/writing-running-appium/caps.md>
+
+
+## Access From Helpers
+
+Receive a Appium client from a custom helper by accessing `browser` property:
+
+```js
+this.helpers['Appium'].browser
+```
+
+**Parameters**
+
+-   `config`
+
+## _locate
+
+Get elements by different locator types, including strict locator
+Should be used in custom helpers:
+
+```js
+this.helpers['Appium']._locate({name: 'password'}).then //...
+```
+
+**Parameters**
+
+-   `locator`  
+
+## _locateCheckable
+
+Find a checkbox by providing human readable text:
+
+```js
+this.helpers['Appium']._locateCheckable('I agree with terms and conditions').then // ...
+```
+
+**Parameters**
+
+-   `locator`  
+
+## _locateClickable
+
+Find a clickable element by providing human readable text:
+
+```js
+this.helpers['Appium']._locateClickable('Next page').then // ...
+```
+
+**Parameters**
+
+-   `locator`  
+
+## _locateFields
+
+Find field elements by providing human readable text:
+
+```js
+this.helpers['Appium']._locateFields('Your email').then // ...
+```
+
+**Parameters**
+
+-   `locator`  
+
+## acceptPopup
+
+Accepts the active JavaScript native popup window, as created by window.alert|window.confirm|window.prompt.
+Don't confuse popups with modal windows, as created by [various libraries](http://jster.net/category/windows-modals-popups).
+
+Appium: support only web testing
+
+## amOnPage
+
+Opens a web page in a browser. Requires relative or absolute url.
+If url starts with `/`, opens a web page of a site defined in `url` config parameter.
+
+Appium: support only web testing
+
+```js
+I.amOnPage('/'); // opens main page of website
+I.amOnPage('https://github.com'); // opens github
+I.amOnPage('/login'); // opens a login page
+```
+
+**Parameters**
+
+-   `url`  url path or global url
+
+## appendField
+
+Appends text to a input field or textarea.
+Field is located by name, label, CSS or XPath
+
+Appium: support, but it's clear a field before insert in apps
+
+```js
+I.appendField('#myTextField', 'appended');
+```
+
+**Parameters**
+
+-   `field`  located by label|name|CSS|XPath|strict locator
+-   `value`  text value
+
+## attachFile
+
+Attaches a file to element located by label, name, CSS or XPath
+Path to file is relative current codecept directory (where codecept.json is located).
+File will be uploaded to remote system (if tests are running remotely).
+
+Appium: not tested
+
+```js
+I.attachFile('Avatar', 'data/avatar.jpg');
+I.attachFile('form input[name=avatar]', 'data/avatar.jpg');
+```
+
+**Parameters**
+
+-   `locator`  field located by label|name|CSS|XPath|strict locator
+-   `pathToFile`  local file path relative to codecept.json config file
+
+## cancelPopup
+
+Dismisses the active JavaScript popup, as created by window.alert|window.confirm|window.prompt.
+
+Appium: support only web testing
+
+## checkOption
+
+Selects a checkbox or radio button.
+Element is located by label or name or CSS or XPath.
+
+Appium: support only web testing
+
+The second parameter is a context (CSS or XPath locator) to narrow the search.
+
+```js
+I.checkOption('#agree');
+I.checkOption('I Agree to Terms and Conditions');
+I.checkOption('agree', '//form');
+```
+
+**Parameters**
+
+-   `field`  checkbox located by label | name | CSS | XPath | strict locator
+-   `context`  (optional) element located by CSS | XPath | strict locator
+
+## clearCookie
+
+Clears a cookie by name,
+if none provided clears all cookies
+
+Appium: support only web testing
+
+```js
+I.clearCookie();
+I.clearCookie('test');
+```
+
+**Parameters**
+
+-   `cookie`  (optional)
+
+## clearField
+
+Clears a `<textarea>` or text `<input>` element's value.
+
+Appium: support
+
+```js
+I.clearField('#email');
+```
+
+**Parameters**
+
+-   `locator`  field located by label|name|CSS|XPath|strict locator
+
+## click
+
+Perform a click on a link or a button, given by a locator.
+If a fuzzy locator is given, the page will be searched for a button, link, or image matching the locator string.
+For buttons, the "value" attribute, "name" attribute, and inner text are searched. For links, the link text is searched.
+For images, the "alt" attribute and inner text of any parent links are searched.
+
+Appium: support
+
+The second parameter is a context (CSS or XPath locator) to narrow the search.
+
+```js
+// simple link
+I.click('Logout');
+// button of form
+I.click('Submit');
+// CSS button
+I.click('#form input[type=submit]');
+// XPath
+I.click('//form/*[@type=submit]');
+// link in context
+I.click('Logout', '#nav');
+// using strict locator
+I.click({css: 'nav a.login'});
+```
+
+**Parameters**
+
+-   `locator`  clickable link or button located by text, or any element located by CSS|XPath|strict locator
+-   `context`  (optional) element to search in CSS|XPath|Strict locator
+
+## defineTimeout
+
+Set [WebDriverIO timeouts](http://webdriver.io/guide/testrunner/timeouts.html) in realtime.
+
+Appium: support only web testing
+
+Timeouts are expected to be passed as object:
+
+```js
+I.defineTimeout({ script: 5000 });
+I.defineTimeout({ implicit: 10000, "page load": 10000, script: 5000 });
+```
+
+**Parameters**
+
+-   `timeouts`  
+
+## dontSee
+
+Opposite to `see`. Checks that a text is not present on a page.
+Use context parameter to narrow down the search.
+
+Appium: support with context in apps
+
+```js
+I.dontSee('Login'); // assume we are already logged in
+```
+
+**Parameters**
+
+-   `text`  is not present
+-   `context`  (optional) element located by CSS|XPath|strict locator in which to perfrom search
+
+## dontSeeCheckboxIsChecked
+
+Verifies that the specified checkbox is not checked.
+
+Appium: support only web testing
+
+**Parameters**
+
+-   `field`  located by label|name|CSS|XPath|strict locator
+
+## dontSeeCookie
+
+Checks that cookie with given name does not exist.
+
+Appium: support only web testing
+
+**Parameters**
+
+-   `name`  
+
+## dontSeeCurrentUrlEquals
+
+Checks that current url is not equal to provided one.
+If a relative url provided, a configured url will be prepended to it.
+
+Appium: support only web testing
+
+**Parameters**
+
+-   `url`  
+
+## dontSeeElement
+
+Opposite to `seeElement`. Checks that element is not visible
+
+Appium: support
+
+**Parameters**
+
+-   `locator`  located by CSS|XPath|Strict locator
+
+## dontSeeElementInDOM
+
+Opposite to `seeElementInDOM`. Checks that element is not on page.
+
+Appium: support only web testing
+
+**Parameters**
+
+-   `locator`  located by CSS|XPath|Strict locator
+
+## dontSeeInCurrentUrl
+
+Checks that current url does not contain a provided fragment.
+
+Appium: support only web testing
+
+**Parameters**
+
+-   `url`  
+
+## dontSeeInField
+
+Checks that value of input field or textare doesn't equal to given value
+Opposite to `seeInField`.
+
+Appium: support only web testing
+
+**Parameters**
+
+-   `field`  located by label|name|CSS|XPath|strict locator
+-   `value`  is not expected to be a field value
+
+## dontSeeInSource
+
+Checks that the current page contains the given string in its raw source code
+
+Appium: support
+
+**Parameters**
+
+-   `text`  
+
+## dontSeeInTitle
+
+Checks that title does not contain text.
+
+Appium: support only web testing
+
+**Parameters**
+
+-   `text`  
+
+## doubleClick
+
+Performs a double-click on an element matched by link|button|label|CSS or XPath.
+Context can be specified as second parameter to narrow search.
+
+Appium: support only web testing
+
+```js
+I.doubleClick('Edit');
+I.doubleClick('Edit', '.actions');
+I.doubleClick({css: 'button.accept'});
+I.doubleClick('.btn.edit');
+```
+
+**Parameters**
+
+-   `locator`  
+-   `context`  
+
+## dragAndDrop
+
+Drag an item to a destination element.
+
+Appium: not tested
+
+```js
+I.dragAndDrop('#dragHandle', '#container');
+```
+
+**Parameters**
+
+-   `srcElement`  
+-   `destElement`  
+
+## executeAsyncScript
+
+Executes async script on page.
+Provided function should execute a passed callback (as first argument) to signal it is finished.
+
+Appium: support only web testing
+
+**Parameters**
+
+-   `fn`  
+-   `args`  Examples for Vue.js.
+    In order to make components completely rendered we are waiting for [nextTick](https://vuejs.org/v2/api/#Vue-nextTick).```js
+    I.executeAsyncScript(function(done) {
+    Vue.nextTick(done); // waiting for next tick
+    })
+    ```By passing value to `done()` function you can return values.
+    Additional arguments can be passed as well, while `done` function is always last parameter in arguments list.```js
+    let val = yield I.executeAsyncScript(function(url, done) {
+    // in browser context
+    $.ajax(url, { success: (data) => done(data); }
+    }, 'http://ajax.callback.url/');
+    ```
+
+## executeScript
+
+Executes sync script on a page.
+Pass arguments to function as additional parameters.
+Will return execution result to a test.
+In this case you should use generator and yield to receive results.
+
+Appium: support only web testing
+
+Example with jQuery DatePicker:
+
+```js
+// change date of jQuery DatePicker
+I.executeScript(function() {
+// now we are inside browser context
+$('date')).datetimepicker('setDate', new Date());
+});
+```
+
+Can return values. Don't forget to use `yield` to get them.
+
+```js
+let date = yield I.executeScript(function(el) {
+// only basic types can be returned
+return $(el)).datetimepicker('getDate').toString();
+}, '#date'); // passing selector
+```
+
+**Parameters**
+
+-   `fn`  
+
+## fillField
+
+Fills a text field or textarea, after clearing its value, with the given string.
+Field is located by name, label, CSS, or XPath.
+
+Appium: support
+
+```js
+// by label
+I.fillField('Email', 'hello@world.com');
+// by name
+I.fillField('password', '123456');
+// by CSS
+I.fillField('form#login input[name=username]', 'John');
+// or by strict locator
+I.fillField({css: 'form#login input[name=username]'}, 'John');
+```
+
+**Parameters**
+
+-   `field`  located by label|name|CSS|XPath|strict locator
+-   `value`  
+
+## grabAttributeFrom
+
+Retrieves an attribute from an element located by CSS or XPath and returns it to test.
+Resumes test execution, so **should be used inside a generator with `yield`** operator.
+
+Appium: can be used for apps only with several values ("contentDescription", "text", "className", "resourceId")
+
+```js
+let hint = yield I.grabAttributeFrom('#tooltip', 'title');
+```
+
+**Parameters**
+
+-   `locator`  element located by CSS|XPath|strict locator
+-   `attr`  
+
+## grabCookie
+
+Gets a cookie object by name
+Resumes test execution, so **should be used inside a generator with `yield`** operator.
+
+Appium: support only web testing
+
+```js
+let cookie = I.grabCookie('auth');
+assert(cookie.value, '123456');
+```
+
+**Parameters**
+
+-   `name`  
+
+## grabHTMLFrom
+
+Retrieves the innerHTML from an element located by CSS or XPath and returns it to test.
+Resumes test execution, so **should be used inside a generator with `yield`** operator.
+
+Appium: support only web testing
+
+```js
+let postHTML = yield I.grabHTMLFrom('#post');
+```
+
+**Parameters**
+
+-   `locator`  
+
+## grabTextFrom
+
+Retrieves a text from an element located by CSS or XPath and returns it to test.
+Resumes test execution, so **should be used inside a generator with `yield`** operator.
+
+Appium: support
+
+```js
+let pin = yield I.grabTextFrom('#pin');
+```
+
+**Parameters**
+
+-   `locator`  element located by CSS|XPath|strict locator
+
+## grabTitle
+
+Retrieves a page title and returns it to test.
+Resumes test execution, so **should be used inside a generator with `yield`** operator.
+
+Appium: support only web testing
+
+```js
+let title = yield I.grabTitle();
+```
+
+## grabValueFrom
+
+Retrieves a value from a form element located by CSS or XPath and returns it to test.
+Resumes test execution, so **should be used inside a generator with `yield`** operator.
+
+Appium: support only web testing
+
+```js
+let email = yield I.grabValueFrom('input[name=email]');
+```
+
+**Parameters**
+
+-   `locator`  field located by label|name|CSS|XPath|strict locator
+
+## moveCursorTo
+
+Moves cursor to element matched by locator.
+Extra shift can be set with offsetX and offsetY options
+
+Appium: support only web testing
+
+```js
+I.moveCursorTo('.tooltip');
+I.moveCursorTo('#submit', 5,5);
+```
+
+**Parameters**
+
+-   `locator`  
+-   `offsetX`  
+-   `offsetY`  
+
+## pressKey
+
+Presses a key on a focused element.
+Speical keys like 'Enter', 'Control', [etc](https://code.google.com/p/selenium/wiki/JsonWireProtocol#/session/:sessionId/element/:id/value)
+will be replaced with corresponding unicode.
+If modifier key is used (Control, Command, Alt, Shift) in array, it will be released afterwards.
+
+Appium: support, but clear field before pressing in apps
+
+```js
+I.pressKey('Enter');
+I.pressKey(['Control','a']);
+```
+
+**Parameters**
+
+-   `key`  To make combinations with modifier and mouse clicks (like Ctrl+Click) press a modifier, click, then release it.```js
+    I.pressKey('Control');
+    I.click('#someelement');
+    I.pressKey('Control');
+    ```
+
+## resizeWindow
+
+Resize the current window to provided width and height.
+First parameter can be set to `maximize`
+
+Appium: not tested in web, in apps doesn't work
+
+**Parameters**
+
+-   `width`  or `maximize`
+-   `height`  
+
+## rightClick
+
+Performs right click on an element matched by CSS or XPath.
+
+Appium: support, but in apps works as usual click
+
+**Parameters**
+
+-   `locator`  
+
+## saveScreenshot
+
+Saves a screenshot to ouput folder (set in codecept.json).
+Filename is relative to output folder.
+
+Appium: support
+
+```js
+I.saveScreenshot('debug.png');
+```
+
+**Parameters**
+
+-   `fileName`  
+
+## scrollTo
+
+Scrolls to element matched by locator.
+Extra shift can be set with offsetX and offsetY options
+
+Appium: support only web testing
+
+```js
+I.scrollTo('footer');
+I.scrollTo('#submit', 5,5);
+```
+
+**Parameters**
+
+-   `locator`  
+-   `offsetX`  
+-   `offsetY`  
+
+## see
+
+Checks that a page contains a visible text.
+Use context parameter to narrow down the search.
+
+Appium: support with context in apps
+
+```js
+I.see('Welcome'); // text welcome on a page
+I.see('Welcome', '.content'); // text inside .content div
+I.see('Register', {css: 'form.register'}); // use strict locator
+```
+
+**Parameters**
+
+-   `text`  expected on page
+-   `context`  (optional) element located by CSS|Xpath|strict locator in which to search for text
+
+## seeCheckboxIsChecked
+
+Verifies that the specified checkbox is checked.
+
+Appium: support only web testing
+
+```js
+I.seeCheckboxIsChecked('Agree');
+I.seeCheckboxIsChecked('#agree'); // I suppose user agreed to terms
+I.seeCheckboxIsChecked({css: '#signup_form input[type=checkbox]'});
+```
+
+**Parameters**
+
+-   `field`  located by label|name|CSS|XPath|strict locator
+
+## seeCookie
+
+Checks that cookie with given name exists.
+
+Appium: support only web testing
+
+```js
+I.seeCookie('Auth');
+```
+
+**Parameters**
+
+-   `name`  
+
+## seeCurrentUrlEquals
+
+Checks that current url is equal to provided one.
+
+Appium: support only web testing
+
+If a relative url provided, a configured url will be prepended to it.
+So both examples will work:
+
+```js
+I.seeCurrentUrlEquals('/register');
+I.seeCurrentUrlEquals('http://my.site.com/register');
+```
+
+**Parameters**
+
+-   `url`  
+
+## seeElement
+
+Checks that a given Element is visible
+Element is located by CSS or XPath.
+
+Appium: support
+
+```js
+I.seeElement('#modal');
+```
+
+**Parameters**
+
+-   `locator`  located by CSS|XPath|strict locator
+
+## seeElementInDOM
+
+Checks that a given Element is present in the DOM
+Element is located by CSS or XPath.
+
+Appium: support only web testing
+
+```js
+I.seeElementInDOM('#modal');
+```
+
+**Parameters**
+
+-   `locator`  located by CSS|XPath|strict locator
+
+## seeInCurrentUrl
+
+Checks that current url contains a provided fragment.
+
+Appium: support only web testing
+
+```js
+I.seeInCurrentUrl('/register'); // we are on registration page
+```
+
+**Parameters**
+
+-   `url`  
+
+## seeInField
+
+Checks that the given input field or textarea equals to given value.
+For fuzzy locators, fields are matched by label text, the "name" attribute, CSS, and XPath.
+
+Appium: support only web testing
+
+```js
+I.seeInField('Username', 'davert');
+I.seeInField({css: 'form textarea'},'Type your comment here');
+I.seeInField('form input[type=hidden]','hidden_value');
+I.seeInField('#searchform input','Search');
+```
+
+**Parameters**
+
+-   `field`  located by label|name|CSS|XPath|strict locator
+-   `value`  
+
+## seeInPopup
+
+Checks that the active JavaScript popup, as created by `window.alert|window.confirm|window.prompt`, contains the given string.
+
+Appium: support only web testing
+
+**Parameters**
+
+-   `text`  
+
+## seeInSource
+
+Checks that the current page contains the given string in its raw source code.
+
+Appium: support
+
+```js
+I.seeInSource('<h1>Green eggs &amp; ham</h1>');
+```
+
+**Parameters**
+
+-   `text`  
+
+## seeInTitle
+
+Checks that title contains text.
+
+Appium: support only web testing
+
+**Parameters**
+
+-   `text`  
+
+## seeNumberOfElements
+
+asserts that an element appears a given number of times in the DOM
+Element is located by label or name or CSS or XPath.
+
+Appium: support
+
+```js
+I.seeNumberOfElements('#submitBtn', 1);
+```
+
+**Parameters**
+
+-   `selector`  
+-   `num`  
+
+## selectOption
+
+Selects an option in a drop-down select.
+Field is searched by label | name | CSS | XPath.
+Option is selected by visible text or by value.
+
+Appium: support only web testing
+
+```js
+I.selectOption('Choose Plan', 'Monthly'); // select by label
+I.selectOption('subscription', 'Monthly'); // match option by text
+I.selectOption('subscription', '0'); // or by value
+I.selectOption('//form/select[@name=account]','Premium');
+I.selectOption('form select[name=account]', 'Premium');
+I.selectOption({css: 'form select[name=account]'}, 'Premium');
+```
+
+Provide an array for the second argument to select multiple options.
+
+```js
+I.selectOption('Which OS do you use?', ['Android', 'iOS']);
+```
+
+**Parameters**
+
+-   `select`  field located by label|name|CSS|XPath|strict locator
+-   `option`  
+
+## setCookie
+
+Sets a cookie
+
+Appium: support only web testing
+
+```js
+I.setCookie({name: 'auth', value: true});
+```
+
+**Parameters**
+
+-   `cookie`  Uses Selenium's JSON [cookie format](https://code.google.com/p/selenium/wiki/JsonWireProtocol#Cookie_JSON_Object).
+
+## switchTo
+
+Switches frame or in case of null locator reverts to parent.
+
+Appium: support only web testing
+
+**Parameters**
+
+-   `locator`  
+
+## wait
+
+Pauses execution for a number of seconds.
+
+Appium: support
+
+```js
+I.wait(2); // wait 2 secs
+```
+
+**Parameters**
+
+-   `sec`  
+
+## waitForElement
+
+Waits for element to be present on page (by default waits for 1sec).
+Element can be located by CSS or XPath.
+
+Appium: support
+
+```js
+I.waitForElement('.btn.continue');
+I.waitForElement('.btn.continue', 5); // wait for 5 secs
+```
+
+**Parameters**
+
+-   `locator`  element located by CSS|XPath|strict locator
+-   `sec`  time seconds to wait, 1 by default
+
+## waitForEnabled
+
+Waits for element to become enabled (by default waits for 1sec).
+Element can be located by CSS or XPath.
+
+Appium: support only web testing
+
+**Parameters**
+
+-   `locator`  element located by CSS|XPath|strict locator
+-   `sec`  time seconds to wait, 1 by default
+
+## waitForInvisible
+
+Waits for an element to become invisible on a page (by default waits for 1sec).
+Element can be located by CSS or XPath.
+
+Appium: support
+
+    I.waitForInvisible('#popup');
+
+**Parameters**
+
+-   `locator`  element located by CSS|XPath|strict locator
+-   `sec`  time seconds to wait, 1 by default
+
+## waitForStalenessOf
+
+Waits for an element to become not attached to the DOM on a page (by default waits for 1sec).
+Element can be located by CSS or XPath.
+
+Appium: support only web testing
+
+    I.waitForStalenessOf('#popup');
+
+**Parameters**
+
+-   `locator`  element located by CSS|XPath|strict locator
+-   `sec`  time seconds to wait, 1 by default
+
+## waitForText
+
+Waits for a text to appear (by default waits for 1sec).
+Element can be located by CSS or XPath.
+Narrow down search results by providing context.
+
+Appium: support
+
+```js
+I.waitForText('Thank you, form has been submitted');
+I.waitForText('Thank you, form has been submitted', 5, '#modal');
+```
+
+**Parameters**
+
+-   `text`  to wait for
+-   `sec`  seconds to wait
+-   `context`  element located by CSS|XPath|strict locator
+
+## waitForVisible
+
+Waits for an element to become visible on a page (by default waits for 1sec).
+Element can be located by CSS or XPath.
+
+Appium: support
+
+    I.waitForVisible('#popup');
+
+**Parameters**
+
+-   `locator`  element located by CSS|XPath|strict locator
+-   `sec`  time seconds to wait, 1 by default
+
+## waitToHide
+
+Waits for an element to become invisible on a page (by default waits for 1sec).
+Element can be located by CSS or XPath.
+
+Appium: support
+
+**Parameters**
+
+-   `locator`  
+-   `sec`  
+
+## waitUntil
+
+Waits for a function to return true (waits for 1sec by default).
+
+Appium: support
+
+**Parameters**
+
+-   `fn`  
+-   `sec`  
+
+
+# Appium extra methods
+
+## seeAppIsInstalled
+
+Check if an app is installed.
+
+Appium: support only Android
+
+```js
+I.seeAppIsInstalled("com.MainApp");
+```
+
+**Parameters**
+
+-   `bundleId` -	ID of bundled app
+
+## seeAppIsNotInstalled
+
+Check if an app is not installed.
+
+Appium: support only Android
+
+```js
+I.seeAppIsNotInstalled("com.MainApp");
+```
+
+**Parameters**
+
+-   `bundleId` -	ID of bundled app
+
+## seeCurrentActivityIs
+
+check current activity on an Android device.
+
+Appium: support only Android
+
+```js
+I.seeCurrentActivityIs(".MainActivity");
+```
+
+**Parameters**
+
+-   `currentActivity` -	expected current activity
+
+## seeDeviceIsLocked
+
+Check whether the device is locked.
+
+Appium: support only Android
+
+```js
+I.seeDeviceIsLocked()
+```
+
+## dontSeeDeviceIsLocked
+
+Check whether the device is not locked.
+
+Appium: support only Android
+
+```js
+I.dontSeeDeviceIsLocked()
+```
+
+## seeOrientationIs
+
+Check the device orientation
+
+Appium: support Android and iOS
+
+```js
+I.seeOrientationIs("landscape");
+```
+
+**Parameters**
+
+-   `orientation` -	expected orientation ("landscape" or "portrait")
+
+## closeApp
+
+Close the given application.
+
+Appium: support only iOS
+
+```js
+I.closeApp();
+```
+
+## grabAllContexts
+
+Get list of all available contexts
+
+Appium: support Android and iOS
+
+```js
+let contexts = yield I.grabAllContexts()
+/*
+['NATIVE_APP', 'WEBVIEW_io.selendroid.testapp']
+*/
+```
+
+## grabContext
+
+Retrieve current context
+
+Appium: support Android and iOS
+
+```js
+let context = yield I.grabContext()
+/*
+'NATIVE_APP'
+*/
+```
+
+## grabCurrentActivity
+
+Get current device activity.
+
+Appium: support only Android
+
+```js
+let currentActivity = yield I.grabCurrentActivity()
+/*
+.ui.WalkthroughActivity
+*/
+```
+
+## grabNetworkConnection
+
+Get informations about the current network connection (Data/WIFI/Airplane). The actual server value will be a number. However WebdriverIO additional properties to the response object to allow easier assertions.
+
+Appium: support only Android
+
+```js
+let networkConnection = yield I.grabNetworkConnection()
+/*
+{ status: 0,
+value: 6,
+sessionId: '24781a27-4d0e-45ee-b964-6b3934d63fb7',
+inAirplaneMode: false,
+hasWifi: true,
+hasData: true }
+*/
+```
+
+## grabOrientation
+
+Get current orientation.
+
+Appium: support Android and iOS
+
+```js
+let orientation = yield I.grabOrientation()
+/*
+portrait
+*/
+```
+
+## grabSettings
+
+Get all the currently specified settings
+
+Appium: support only Android
+
+```js
+let settings = yield I.grabSettings()
+/*
+{ ignoreUnimportantViews: false }
+*/
+```
+
+## hideDeviceKeyboard
+
+Hide the keyboard. (taps outside to hide keyboard per default)
+
+Appium: support Android and iOS
+
+```js
+I.hideDeviceKeyboard('tapOutside');
+I.hideDeviceKeyboard('pressKey', 'Done');
+```
+
+**Parameters**
+
+-   `strategy` - desired strategy to close keyboard (‘tapOutside’ or ‘pressKey’)
+-   `key` - key to close keyboard
+
+## installApp
+
+Install an app on device.
+
+Appium: support only Android
+
+```js
+I.installApp('/path/to/my/App.apk');
+```
+
+**Parameters**
+
+-   `path` - path to Android application
+
+## makeTouchAction
+
+The Touch Action API provides the basis of all gestures that can be automated in Appium. At its core is the ability to chain together ad hoc individual actions, which will then be applied to an element in the application on the device.
+Full documentation http://webdriver.io/api/mobile/touchAction.html
+
+Appium: support Android and iOS
+
+```js
+I.makeTouchAction('//UITextbox', 'tap');
+```
+
+**Parameters**
+
+-   `locator` - selector to execute the touchAction on
+-   `action` - action to execute
+
+## makeShake
+
+Perform a shake action on the device.
+
+Appium: support only iOS
+
+```js
+I.makeShake();
+```
+
+## openNotifications
+
+Open the notifications panel on the device.
+
+Appium: support only Android
+
+```js
+I.openNotifications()
+```
+
+## pullFile
+
+Pulls a file from the device.
+
+Appium: support Android and iOS
+
+```js
+I.pullFile('/sdcard/myfile.txt', 'c:/tmp/myfile.txt');
+```
+
+**Parameters**
+
+-   `path` - device path to file
+-   `dest` - destination path to file
+
+## removeApp
+
+Remove an app from the device.
+
+Appium: support only Android
+
+```js
+I.removeApp('com.Myapp');
+```
+
+**Parameters**
+
+-   `bundleId` -  bundle ID of application
+
+## rotate
+
+Perform a rotation gesture centered on the specified element.
+
+Appium: support only iOS
+
+not tested
+
+```js
+I.rotate(114, 198);
+```
+
+**Parameters**
+
+-   `x` -  x offset to use for the center of the rotate gesture (default 0)
+-   `y` -  y offset to use for the center of the rotate gesture (default 0)
+-   `duration` -  The length of hold time for the specified gesture, in seconds. (default 1)
+-   `radius` -  The distance in points from the center to the edge of the circular path.
+-   `rotation` -  The length of rotation in radians. (default pi (π))
+-   `touchCount` -  The number of touches to use in the specified gesture. (Effectively, the number of fingers a user would use to make the specified gesture.) Valid values are 1 to 5. (default 2)
+
+**Parameters**
+
+-   `seconds` -  number of seconds after the app will open again
+
+## sendDeviceKeyEvent
+
+Send a key event to the device
+list of keys: https://developer.android.com/reference/android/view/KeyEvent.html
+
+Appium: support only Android
+
+```js
+I.sendDeviceKeyEvent(3)
+```
+
+**Parameters**
+
+-   `keyValue` - device specific key value.
+
+## setImmediateValue
+
+Set immediate value in app.
+
+Appium: support only iOs
+not tested
+
+```js
+I.setImmediateValue(el, 'foo')
+```
+
+**Parameters**
+
+-   `id` - ID of a WebElement JSON object to route the command to.
+-   `value` - The sequence of keys to type. An array must be provided. The server should flatten the array items to a single string to be typed.
+
+## setOrientation
+
+Set a device orientation. Will fail, if app will not change orientation
+
+Appium: support Android and iOS
+
+```js
+I.setOrientation('landscape')
+```
+
+**Parameters**
+
+-   `orientation` - orientation (landscape/portrait)
+
+## setNetworkConnection
+
+Set network connection.
+
+Appium: support only Android
+
+```js
+I.setNetworkConnection(1)
+```
+
+**Parameters**
+
+-   `value` - bitmasks of network connection. See http://webdriver.io/api/mobile/setNetworkConnection.html
+
+## setSettings
+
+Update the current setting on the device
+
+Appium: support Android and iOS
+
+```js
+I.setSettings({ cyberdelia: 'open' })
+```
+
+**Parameters**
+
+-   `settings` - key/value pairs defining settings on the device
+
+## simulateTouchId
+
+ Simulate Touch ID with either valid (match == true) or invalid (match == false) fingerprint.
+
+Appium: support only iOS
+not tested
+
+```js
+I.simulateTouchId(true)
+```
+
+**Parameters**
+
+-   `match` - if true the command simulates a valid fingerprint
+
+## startActivity
+
+Start an arbitrary Android activity during a session.
+
+Appium: support only Android
+
+```js
+I.startActivity('io.appium.android.apis','.view.DragAndDropDemo')
+```
+
+**Parameters**
+
+-   `appPackage` - name of app
+-   `appActivity` - name of activity
+
+
+## swipe
+
+Perform a swipe on the screen or an element.
+
+Appium: support Android and iOS
+
+```js
+I.swipe('//elem', 300, 200, 150);
+```
+
+**Parameters**
+
+-   `locator` - element to swipe on
+-   `xoffset` - x offset of swipe gesture (in pixels or relative units)
+-   `yoffset` - y offset of swipe gesture (in pixels or relative units)
+-   `speed` - time (in seconds) to spend performing the swipe
+
+## swipeDown
+
+Perform a swipe down on an element.
+
+Appium: support Android and iOS
+
+```js
+I.swipeDown('//elem', 300, 200);
+```
+
+**Parameters**
+
+-   `locator` - element to swipe on
+-   `yoffset` - y offset of swipe gesture (in pixels or relative units)
+-   `speed` - time (in seconds) to spend performing the swipe
+
+## swipeLeft
+
+Perform a swipe left on an element.
+
+Appium: support Android and iOS
+
+```js
+I.swipeDown('//elem', 300, 200);
+```
+
+**Parameters**
+
+-   `locator` - element to swipe on
+-   `xoffset` - x offset of swipe gesture (in pixels or relative units)
+-   `speed` - time (in seconds) to spend performing the swipe
+
+## swipeRight
+
+Perform a swipe right on an element.
+
+Appium: support Android and iOS
+
+```js
+I.swipeRight('//elem', 300, 200);
+```
+
+**Parameters**
+
+-   `locator` - element to swipe on
+-   `xoffset` - x offset of swipe gesture (in pixels or relative units)
+-   `speed` - time (in seconds) to spend performing the swipe
+
+## swipeTo
+
+Perform a swipe in selected direction on an element to seachable element.
+
+Appium: support Android and iOS
+
+```js
+I.swipeTo("//searchelem", "//elem", 'left', 30, 400, 100);
+```
+
+**Parameters**
+
+-   `seachableLocator` - element to search
+-   `scrollLocator` - element to swipe on
+-   `direction` - direction to swipe ('down', 'up', 'left', 'right')
+-   `timeout` - seconds to wait
+-   `offset` - offset of swipe gesture (in pixels or relative units)
+-   `speed` - time (in seconds) to spend performing the swipe
+
+## swipeUp
+
+Perform a swipe right on an element.
+
+Appium: support Android and iOS
+
+```js
+I.swipeUp('//elem', 300, 200);
+```
+
+**Parameters**
+
+-   `locator` - element to swipe on
+-   `yoffset` - y offset of swipe gesture (in pixels or relative units)
+-   `speed` - time (in seconds) to spend performing the swipe
+
+
+## switchToContext
+
+Switch to the specified context
+
+Appium: support only Android
+
+```js
+I.switchToContext('NATIVE_APP')
+```
+
+**Parameters**
+
+-   `value` - name of context
+
+
+## touchPerform
+
+Performs a specific touch action. The action object need to contain the action name, x/y coordinates
+
+Appium: support Android and iOS
+
+```js
+I.touchPerform([{
+    action: 'press',
+    options: {
+        x: 100,
+        y: 250
+    }
+}]);
+```
+
+**Parameters**
+
+-   `actions` - touch action as object or object[] with attributes like touchCount, x, y, duration
diff --git a/docs/helpers/WebDriverIO.md b/docs/helpers/WebDriverIO.md
index 073061e25..ee9b56e05 100644
--- a/docs/helpers/WebDriverIO.md
+++ b/docs/helpers/WebDriverIO.md
@@ -1,7 +1,7 @@
 # WebDriverIO
 
 WebDriverIO helper which wraps [webdriverio](http://webdriver.io/) library to
-manipulate browser using Selenium WebDriver or PhantomJS.
+manipulate browser using Selenium WebDriver, PhantomJS.
 
 #### Selenium Installation
 
@@ -19,7 +19,9 @@ It allows you to run Selenium tests on a server without a GUI installed.
 
 ### Configuration
 
-This helper should be configured in codecept.json
+This helper should be configured in codecept.conf.js
+
+#### Desktop configuration
 
 -   `url` - base url of website to be tested
 -   `browser` - browser in which perform testing
@@ -33,18 +35,17 @@ This helper should be configured in codecept.json
 
 Example:
 
-```json
+```js
 {
-   "helpers": {
-     "WebDriverIO" : {
-       "browser": "chrome",
-       "restart": false,
-       "windowSize": "maximize",
-       "timeouts": {
-         "script": 60000,
-         "page load": 10000,
-         "implicit" : 5000
-       }
+   helpers: {
+     WebDriverIO : {
+       browser: "chrome",
+       restart: false,
+       windowSize: "maximize",
+       timeouts: {
+         script: 60000,
+         page load: 10000,
+         implicit : 5000       }
      }
    }
 }
@@ -59,19 +60,19 @@ need to update the `helpers.WebDriverIO.desiredCapabilities.proxy` key.
 
 ```js
 {
-    "helpers": {
-        "WebDriverIO": {
-            "desiredCapabilities": {
-                "proxy": {
-                    "proxyType": "manual|pac",
-                    "proxyAutoconfigUrl": "URL TO PAC FILE",
-                    "httpProxy": "PROXY SERVER",
-                    "sslProxy": "PROXY SERVER",
-                    "ftpProxy": "PROXY SERVER",
-                    "socksProxy": "PROXY SERVER",
-                    "socksUsername": "USERNAME",
-                    "socksPassword": "PASSWORD",
-                    "noProxy": "BYPASS ADDRESSES"
+    helpers: {
+        WebDriverIO: {
+            desiredCapabilities: {
+                proxy: {
+                    proxyType: "manual|pac",
+                    proxyAutoconfigUrl: "URL TO PAC FILE",
+                    httpProxy: "PROXY SERVER",
+                    sslProxy: "PROXY SERVER",
+                    ftpProxy: "PROXY SERVER",
+                    socksProxy: "PROXY SERVER",
+                    socksUsername: "USERNAME",
+                    socksPassword: "PASSWORD",
+                    noProxy: "BYPASS ADDRESSES"
                 }
             }
         }
@@ -83,15 +84,15 @@ For example,
 
 ```js
 {
-    "helpers": {
-        "WebDriverIO": {
-            "desiredCapabilities": {
-                "proxy": {
-                    "proxyType": "manual",
-                    "httpProxy": "http://corporate.proxy:8080",
-                    "socksUsername": "codeceptjs",
-                    "socksPassword": "secret",
-                    "noProxy": "127.0.0.1,localhost"
+    helpers: {
+        WebDriverIO: {
+            desiredCapabilities: {
+                proxy: {
+                    proxyType: "manual",
+                    httpProxy: "http://corporate.proxy:8080",
+                    socksUsername: "codeceptjs",
+                    socksPassword: "secret",
+                    noProxy: "127.0.0.1,localhost"
                 }
             }
         }
@@ -112,13 +113,13 @@ service provider to connect to.
 
 ```js
 {
-    "helpers":{
-        "WebDriverIO": {
-            "url": "YOUR_DESIERED_HOST",
-            "user": "YOUR_BROWSERSTACK_USER",
-            "key": "YOUR_BROWSERSTACK_KEY",
-            "desiredCapabilities": {
-                "browserName": "chrome",
+    helpers:{
+        WebDriverIO: {
+            url: "YOUR_DESIERED_HOST",
+            user: "YOUR_BROWSERSTACK_USER",
+            key: "YOUR_BROWSERSTACK_KEY",
+            desiredCapabilities: {
+                browserName: "chrome",
 
                 // only set this if you're using BrowserStackLocal to test a local domain
                 // "browserstack.local": true,
@@ -140,17 +141,17 @@ Here is the [webdriverio docs](http://webdriver.io/guide/usage/multiremote.html)
 
 ```js
 {
-    "helpers": {
-        "WebDriverIO": {
-            "multiremote": {
-                "MyChrome": {
-                    "desiredCapabilities": {
-                        "browserName": "chrome"
+    helpers: {
+        WebDriverIO: {
+            multiremote: {
+                MyChrome: {
+                    desiredCapabilities: {
+                        browserName: "chrome"
                      }
                 },
-                "MyFirefox": {
-                   "desiredCapabilities": {
-                       "browserName": "firefox"
+                MyFirefox: {
+                   desiredCapabilities: {
+                       browserName: "firefox"
                    }
                 }
             }
@@ -169,7 +170,7 @@ this.helpers['WebDriverIO'].browser
 
 **Parameters**
 
--   `config`  
+-   `config`
 
 ## _locate
 
@@ -273,7 +274,6 @@ I.attachFile('form input[name=avatar]', 'data/avatar.jpg');
 ## cancelPopup
 
 Dismisses the active JavaScript popup, as created by window.alert|window.confirm|window.prompt.
-
 ## checkOption
 
 Selects a checkbox or radio button.
@@ -352,6 +352,7 @@ I.click({css: 'nav a.login'});
 ## defineTimeout
 
 Set [WebDriverIO timeouts](http://webdriver.io/guide/testrunner/timeouts.html) in realtime.
+
 Timeouts are expected to be passed as object:
 
 ```js
@@ -767,6 +768,7 @@ I.seeCookie('Auth');
 ## seeCurrentUrlEquals
 
 Checks that current url is equal to provided one.
+
 If a relative url provided, a configured url will be prepended to it.
 So both examples will work:
 
@@ -1043,4 +1045,4 @@ Waits for a function to return true (waits for 1sec by default).
 **Parameters**
 
 -   `fn`  
--   `sec`  
+-   `sec`
diff --git a/lib/helper/Appium.js b/lib/helper/Appium.js
new file mode 100644
index 000000000..99e474bec
--- /dev/null
+++ b/lib/helper/Appium.js
@@ -0,0 +1,613 @@
+'use strict';
+let webdriverio;
+const WebdriverIO = require('./WebDriverIO');
+const AssertionFailedError = require('../assert/error');
+const empty = require('../assert/empty').empty;
+const truth = require('../assert/truth').truth;
+const assert = require('assert');
+const path = require('path');
+const requireg = require('requireg');
+const fs = require('fs');
+
+let browserCap;
+
+/**
+ Appium helper is extends from WebriverIO. It's support all browser methods and also includes special methods for mobile apps testing. You can use this helper to test Web on desktop and mobile devices and mobile apps.
+ #### Appium Installation
+ Appium is an open source test automation framework for use with native, hybrid and mobile web apps that implements the WebDriver protocol.
+ It allows you to run Selenium tests on mobile devices and also test native, hybrid and mobile web apps.
+ 1.  Download and install [Appium](http://appium.io/)
+ 2.  Launch the daemon: `appium`
+ ### Configuration
+ This helper should be configured in codecept.conf.js
+ #### Appium configuration
+ -   `port`: Appium serverport
+ -   `restart`: restart browser or app between tests (default: true), if set to false cookies will be cleaned but browser window will be kept and for apps nothing will be changed.
+ -   `desiredCapabilities`: Appium capabilities
+ --   `platformName` - Which mobile OS platform to use
+ --   `appPackage` - Java package of the Android app you want to run
+ --   `appActivity` - Activity name for the Android activity you want to launch from your package.
+ --   `deviceName`: The kind of mobile device or emulator to use
+ --   `platformVersion`: Mobile OS version
+ --   `app` - The absolute local path or remote http URL to an .ipa or .apk file, or a .zip containing one of these. Appium will attempt to install this app binary on the appropriate device first.
+ --   `browserName`: Name of mobile web browser to automate. Should be an empty string if automating an app instead.
+ Example:
+ ```js
+ {
+   helpers: {
+       WebDriverIO: {
+           desiredCapabilities: {
+               platformName: "Android",
+               appPackage: "com.example.android.myApp",
+               appActivity: "MainActivity",
+               deviceName: "OnePlus3",
+               platformVersion: "6.0.1"
+           },
+           port: 4723,
+           restart: false
+       }
+    }
+ }
+ ```
+ Additional configuration params can be used from <https://github.com/appium/appium/blob/master/docs/en/writing-running-appium/caps.md>
+ ## Access From Helpers
+ Receive a Appium client from a custom helper by accessing `browser` property:
+ ```js
+ this.helpers['Appium'].browser
+ ```
+ */
+class Appium extends WebdriverIO {
+
+  /**
+   * Appium Special Methods for Mobile only
+   */
+
+  constructor(config) {
+    super(config);
+    webdriverio = requireg('webdriverio');
+
+    // set defaults
+    this.options = {
+      waitForTimeout: 1000, // ms
+      desiredCapabilities: {},
+      restart: true,
+      manualStart: false,
+      timeouts: {
+        script: 1000 // ms
+      }
+    };
+
+    // override defaults with config
+    Object.assign(this.options, config);
+
+    this.options.baseUrl = this.options.url || this.options.baseUrl;
+    this.options.desiredCapabilities.browserName = this.options.browser || this.options.desiredCapabilities.browserName;
+    browserCap = this.options.desiredCapabilities.browserName;
+    this.options.waitForTimeout /= 1000; // convert to seconds
+
+
+  }
+
+
+  _startBrowser() {
+    if (this.options.multiremote) {
+      this.browser = webdriverio.multiremote(this.options.multiremote).init();
+    } else {
+      this.browser = webdriverio.remote(this.options).init();
+    }
+
+    if (this.options.timeouts && browserCap) {
+      this.defineTimeout(this.options.timeouts);
+    }
+
+    if (this.options.windowSize === 'maximize') {
+      this.browser.windowHandleMaximize(false);
+    }
+    if (this.options.windowSize && this.options.windowSize.indexOf('x') > 0) {
+      let dimensions = this.options.windowSize.split('x');
+      this.browser.windowHandleSize({
+        width: dimensions[0],
+        height: dimensions[1]
+      });
+    }
+    return this.browser;
+  }
+
+  _after() {
+    if (this.options.restart) return this.browser.end();
+    if (this.options.desiredCapabilities.browserName) {
+      this.debugSection('Session', 'cleaning cookies and localStorage');
+      return this.browser.execute('localStorage.clear();').then(() => {
+        return this.browser.deleteCookie();
+      });
+    }
+  }
+
+  /**
+   * Check if an app is installed.
+   * Appium: support only Android
+   */
+  seeAppIsInstalled(bundleId) {
+    onlyForApps.call(this, "Android");
+    return this.browser.isAppInstalled(bundleId).then(function (res) {
+      return truth(`app ${bundleId}`, 'to be installed').assert(res.value);
+    });
+  }
+
+  /**
+   * Check if an app is not installed.
+   * Appium: support only Android
+   */
+  seeAppIsNotInstalled(bundleId) {
+    onlyForApps.call(this, "Android");
+    return this.browser.isAppInstalled(bundleId).then(function (res) {
+      return truth(`app ${bundleId}`, 'to be installed').negate(res.value);
+    });
+  }
+
+  /**
+   * Install an app on device.
+   * Appium: support only Android
+   */
+  installApp(path) {
+    onlyForApps.call(this, "Android");
+    return this.browser.installApp(path);
+  }
+
+  /**
+   * Remove an app from the device.
+   * Appium: support only Android
+   */
+  removeApp(bundleId) {
+    onlyForApps.call(this, "Android");
+    return this.browser.removeApp(bundleId);
+  }
+
+  /**
+   * check current activity on an Android device.
+   * Appium: support only Android
+   */
+  seeCurrentActivityIs(currentActivity) {
+    onlyForApps.call(this, "Android");
+    return this.browser.currentActivity().then(function (res) {
+      return truth('current activity', `to be ${currentActivity}`).assert(res.value == currentActivity);
+    });
+  }
+
+  /**
+   * Check whether the device is locked.
+   * Appium: support only Android
+   */
+  seeDeviceIsLocked() {
+    onlyForApps.call(this, "Android");
+    return this.browser.isLocked().then(function (res) {
+      return truth('device', 'to be locked').assert(res.value);
+    });
+  }
+
+  /**
+   * Check whether the device is not locked.
+   * Appium: support only Android
+   */
+  dontSeeDeviceIsLocked() {
+    onlyForApps.call(this, "Android");
+    return this.browser.isLocked().then(function (res) {
+      return truth('device', 'to be locked').negate(res.value);
+    });
+  }
+
+  /**
+   * Check the device orientation
+   * Appium: support Android and iOS
+   */
+  seeOrientationIs(orientation) {
+    onlyForApps.call(this);
+    return this.browser.orientation().then(function (res) {
+      return truth('orientation', `to be ${orientation}`).assert(res.value == orientation);
+    });
+  }
+
+  /**
+   * Set a device orientation. Will fail, if app will not set orientation
+   * Appium: support Android and iOS
+   */
+  setOrientation(orientation) {
+    onlyForApps.call(this);
+    return this.browser.setOrientation(orientation);
+  }
+
+  /**
+   * Get list of all available contexts
+   * Appium: support Android and iOS
+   */
+  grabAllContexts() {
+    onlyForApps.call(this);
+    return this.browser.contexts().then(function (res) {
+      return res.value;
+    });
+  }
+
+  /**
+   * Retrieve current context
+   * Appium: support Android and iOS
+   */
+  grabContext() {
+    onlyForApps.call(this);
+    return this.browser.context().then(function (res) {
+      return res.value;
+    });
+  }
+
+  /**
+   * Get current device activity.
+   * Appium: support only Android
+   */
+  grabCurrentActivity() {
+    onlyForApps.call(this, "Android");
+    return this.browser.getCurrentDeviceActivity();
+  }
+
+  /**
+   * Get informations about the current network connection (Data/WIFI/Airplane).
+   * The actual server value will be a number. However WebdriverIO additional
+   * properties to the response object to allow easier assertions.
+   * Appium: support only Android
+   */
+  grabNetworkConnection() {
+    onlyForApps.call(this, "Android");
+    return this.browser.getNetworkConnection().then(function (res) {
+      return {
+        value: res.value,
+        inAirplaneMode: res.inAirplaneMode,
+        hasWifi: res.hasWifi,
+        hasData: res.hasData
+      };
+    });
+  }
+
+  /**
+   * Get current orientation.
+   * Appium: support Android and iOS
+   */
+  grabOrientation() {
+    onlyForApps.call(this);
+    return this.browser.orientation().then(function (res) {
+      return res.value;
+    });
+  }
+
+  /**
+   * Get all the currently specified settings
+   * Appium: support Android and iOS
+   */
+  grabSettings() {
+    onlyForApps.call(this);
+    return this.browser.settings().then(function (res) {
+      return res.value;
+    });
+  }
+
+  /**
+   * Switch to the specified context
+   * Appium: support only Android
+   */
+  switchToContext(value) {
+    onlyForApps.call(this, "Android");
+    return this.browser.context(value);
+  }
+
+  /**
+   * Start an arbitrary Android activity during a session.
+   * Appium: support only Android
+   */
+  startActivity(appPackage, appActivity) {
+    onlyForApps.call(this, "Android");
+    return this.browser.startActivity(appPackage, appActivity);
+  }
+
+  /**
+   * Set network connection.
+   * Appium: support only Android
+   */
+  setNetworkConnection(value) {
+    onlyForApps.call(this, "Android");
+    return this.browser.setNetworkConnection(value);
+  }
+
+  /**
+   * Update the current setting on the device
+   * Appium: support Android and iOS
+   */
+  setSettings(settings) {
+    onlyForApps.call(this);
+    return this.browser.settings(settings);
+  }
+
+  /**
+   * Hide the keyboard.
+   * Appium: support Android and iOS
+   */
+  hideDeviceKeyboard(strategy, key) {
+    onlyForApps.call(this);
+    strategy = strategy || 'tapOutside';
+    return this.browser.hideDeviceKeyboard(strategy, key);
+  }
+
+  /**
+   * send a key event to the device
+   * Appium: support only Android
+   * list of keys: https://developer.android.com/reference/android/view/KeyEvent.html
+   */
+  sendDeviceKeyEvent(keyValue) {
+    onlyForApps.call(this, "Android");
+    return this.browser.deviceKeyEvent(keyValue);
+  }
+
+  /**
+   * Open the notifications panel on the device.
+   * Appium: support only Android
+   */
+  openNotifications() {
+    onlyForApps.call(this, "Android");
+    return this.browser.openNotifications();
+  }
+
+  /**
+   * The Touch Action API provides the basis of all gestures that can be
+   * automated in Appium. At its core is the ability to chain together ad hoc
+   * individual actions, which will then be applied to an element in the
+   * application on the device.
+   * Full documentation http://webdriver.io/api/mobile/touchAction.html
+   * Appium: support Android and iOS
+   */
+  makeTouchAction(locator, action) {
+    onlyForApps.call(this);
+    return this.browser.touchAction(withStrictLocator(locator), action);
+  }
+
+  /**
+   * Perform a swipe on the screen or an element.
+   * Appium: support Android and iOS
+   */
+  swipe(locator, xoffset, yoffset, speed) {
+    onlyForApps.call(this);
+    return this.browser.swipe(withStrictLocator(locator), xoffset, yoffset, speed);
+  }
+
+  /**
+   * Perform a swipe down on an element.
+   * Appium: support Android and iOS
+   */
+  swipeDown(locator, yOffset, speed) {
+    onlyForApps.call(this);
+    return this.browser.swipeDown(withStrictLocator(locator), yOffset, speed);
+  }
+
+  /**
+   * Perform a swipe left on an element.
+   * Appium: support Android and iOS
+   */
+  swipeLeft(locator, xoffset, speed) {
+    onlyForApps.call(this);
+    return this.browser.swipeLeft(withStrictLocator(locator), xoffset, speed);
+  }
+
+  /**
+   * Perform a swipe right on an element.
+   * Appium: support Android and iOS
+   */
+  swipeRight(locator, xoffset, speed) {
+    onlyForApps.call(this);
+    return this.browser.swipeRight(withStrictLocator(locator), xoffset, speed);
+  }
+
+  /**
+   * Perform a swipe up on an element.
+   * Appium: support Android and iOS
+   */
+  swipeUp(locator, yOffset, speed) {
+    onlyForApps.call(this);
+    return this.browser.swipeUp(withStrictLocator(locator), yOffset, speed);
+  }
+
+  /**
+   * Perform a swipe in selected direction on an element to seachable element.
+   * Appium: support Android and iOS
+   */
+  swipeTo(seachableLocator, scrollLocator, direction, timeout, offset, speed) {
+    onlyForApps.call(this);
+    direction = direction || 'down';
+    switch (direction) {
+    case 'down':
+      direction = 'swipeDown';
+      break;
+    case 'up':
+      direction = 'swipeUp';
+      break;
+    case 'left':
+      direction = 'swipeLeft';
+      break;
+    case 'right':
+      direction = 'swipeRight';
+      break;
+    }
+    timeout = timeout || this.options.waitForTimeout;
+
+    var errorMsg = 'element ("' + seachableLocator + '") still not visible after ' + timeout + 'seconds';
+    let browser = this.browser;
+    let err = false;
+    let currentSource;
+    return browser.waitUntil(function () {
+      if (err) {
+        return new Error('Scroll to the end and element ' + seachableLocator + ' was not found');
+      } else {
+        return browser.isVisible(withStrictLocator(seachableLocator))
+          .then(function (res) {
+            if (res) {
+              return true;
+            } else {
+              return browser[direction](scrollLocator, offset, speed).getSource().then((source) => {
+                if (source === currentSource) {
+                  err = true;
+                } else {
+                  currentSource = source;
+                  return false;
+                }
+              });
+            }
+          });
+      }
+    }, timeout * 1000, errorMsg)
+      .catch((e) => {
+        if (e.type === 'WaitUntilTimeoutError' && e.message != 'timeout' && e.type != 'NoSuchElement') {
+          throw new AssertionFailedError({customMessage: 'Scroll to the end and element ' + seachableLocator + ' was not found'}, '');
+        } else {
+          throw e;
+        }
+      });
+
+  }
+
+  /**
+   * Performs a specific touch action. The action object need to contain the action name, x/y coordinates
+   * Appium: support Android and iOS
+   */
+  touchPerform(actions) {
+    onlyForApps.call(this);
+    return this.browser.touchPerform(actions);
+  }
+
+  /**
+   * Pulls a file from the device.
+   * Appium: support Android and iOS
+   */
+  pullFile(path, dest) {
+    onlyForApps.call(this);
+    return this.browser.pullFile(path).then(function (res) {
+      return fs.writeFile(dest, Buffer.from(res.value, 'base64'), function (err) {
+        if (err) {
+          return false;
+        }
+        return true;
+      });
+    });
+  }
+
+  /**
+   * Perform a shake action on the device.
+   * Appium: support only iOS
+   */
+  makeShake() {
+    onlyForApps.call(this, "iOS");
+    return this.browser.shake();
+  }
+
+  /**
+   * Perform a rotation gesture centered on the specified element.
+   * Appium: support only iOS
+   TODO: not tested
+   */
+  rotate(x, y, duration, radius, rotation, touchCount) {
+    onlyForApps.call(this, "iOS");
+    return this.browser.rotate(x, y, duration, radius, rotation, touchCount);
+  }
+
+  /**
+   * Set immediate value in app.
+   * Appium: support only iOS
+   TODO: not tested
+   */
+  setImmediateValue(id, value) {
+    onlyForApps.call(this, "iOS");
+    return this.browser.setImmediateValue(id, value);
+  }
+
+  /**
+   * Simulate Touch ID with either valid (match == true) or invalid (match == false) fingerprint.
+   * Appium: support only iOS
+   * TODO: not tested
+   */
+  simulateTouchId(match) {
+    onlyForApps.call(this, "iOS");
+    match = match || true;
+    return this.browser.touch(match);
+  }
+
+  /**
+   * Close the given application.
+   * Appium: support only iOS
+   */
+  closeApp() {
+    onlyForApps.call(this, "iOS");
+    return this.browser.closeApp();
+  }
+
+  /*
+   * End Appium Methods
+   */
+
+}
+
+function isCSSorXPathLocator(locator) {
+  if (locator[0] === '#' || locator[0] === '.') {
+    if (browserCap) {
+      return true;
+    } else {
+      throw new Error(
+        `Unable to use css locators in apps. Locator strategies for this request: xpath, id, class name`);
+    }
+  }
+  if (locator.substr(0, 2) === '//') {
+    return true;
+  }
+  return false;
+}
+
+function withStrictLocator(locator) {
+  if (!locator) return null;
+  if (isCSSorXPathLocator(locator)) return locator;
+  if (typeof locator !== 'object') return locator;
+  let key = Object.keys(locator)[0];
+  let value = locator[key];
+
+  locator.toString = () => `{${key}: '${value}'}`;
+
+  switch (key) {
+  case 'by':
+  case 'xpath':
+    return value;
+  case 'css':
+    if (browserCap) {
+      return value;
+    } else {
+      throw new Error(
+          `Unable to use css locators in apps. Locator strategies for this request: xpath, id, class name or accessibility id`);
+    }
+  case 'id':
+    return '#' + value;
+  case 'name':
+    return `[name="${value}"]`;
+  }
+}
+
+// in the end of a file
+function onlyForApps(platformName) {
+  var callerName;
+  var stack = new Error().stack,
+    re = /Appium.(\w+)/g,
+    caller = stack.split('\n')[2].trim(),
+    m = re.exec(caller);
+  callerName = m[1] || m[2];
+  if (!platformName) {
+    if (!this.options.desiredCapabilities.platformName) {
+      throw new Error(`${callerName} method can be used only with apps`);
+    }
+  } else {
+    if (this.options.desiredCapabilities.platformName != platformName) {
+      throw new Error(`${callerName} method can be used only with ${platformName} apps`);
+    }
+  }
+}
+
+
+module.exports = Appium;
diff --git a/lib/helper/WebDriverIO.js b/lib/helper/WebDriverIO.js
index 87580f624..9aa0d92a1 100644
--- a/lib/helper/WebDriverIO.js
+++ b/lib/helper/WebDriverIO.js
@@ -22,8 +22,10 @@ let withinStore = {};
  * #### Selenium Installation
  *
  * 1. Download [Selenium Server](http://docs.seleniumhq.org/download/)
- * 2. For Chrome browser install [ChromeDriver](https://sites.google.com/a/chromium.org/chromedriver/getting-started), for Firefox browser install [GeckoDriver](https://github.com/mozilla/geckodriver).
- * 3. Launch the server: `java -jar selenium-server-standalone-3.xx.xxx.jar`. To locate Chromedriver binary use `-Dwebdriver.chrome.driver=./chromedriver` option. For Geckodriver use `-Dwebdriver.gecko.driver=`.
+ * 2. For Chrome browser install [ChromeDriver](https://sites.google.com/a/chromium.org/chromedriver/getting-started),
+ * for Firefox browser install [GeckoDriver](https://github.com/mozilla/geckodriver).
+ * 3. Launch the server: `java -jar selenium-server-standalone-3.xx.xxx.jar`. To locate Chromedriver binary use
+ * `-Dwebdriver.chrome.driver=./chromedriver` option. For Geckodriver use `-Dwebdriver.gecko.driver=`.
  *
  * #### PhantomJS Installation
  *
@@ -43,8 +45,10 @@ let withinStore = {};
  * * `keepCookies` (optional, default: false)  - keep cookies between tests when `restart` set to false.
  * * `windowSize`: (optional) default window size. Set to `maximize` or a dimension in the format `640x480`.
  * * `waitForTimeout`: (option) sets default wait time in *ms* for all `wait*` functions. 1000 by default;
- * * `desiredCapabilities`: Selenium's [desired capabilities](https://github.com/SeleniumHQ/selenium/wiki/DesiredCapabilities)
- * * `manualStart` (optional, default: false) - do not start browser before a test, start it manually inside a helper with `this.helpers["WebDriverIO"]._startBrowser()`
+ * * `desiredCapabilities`: Selenium's [desired
+ * capabilities](https://github.com/SeleniumHQ/selenium/wiki/DesiredCapabilities)
+ * * `manualStart` (optional, default: false) - do not start browser before a test, start it manually inside a helper
+ * with `this.helpers["WebDriverIO"]._startBrowser()`
  * * `timeouts`: [WebDriverIO timeouts](http://webdriver.io/guide/testrunner/timeouts.html) defined as hash.
  *
  * Example:
@@ -67,7 +71,8 @@ let withinStore = {};
  *
  * ```
  *
- * Additional configuration params can be used from [webdriverio website](http://webdriver.io/guide/getstarted/configuration.html).
+ * Additional configuration params can be used from [webdriverio
+ * website](http://webdriver.io/guide/getstarted/configuration.html).
  *
  * ### Connect through proxy
  *
@@ -115,7 +120,8 @@ let withinStore = {};
  * }
  * ```
  *
- * Please refer to [Selenium - Proxy Object](https://github.com/SeleniumHQ/selenium/wiki/DesiredCapabilities) for more information.
+ * Please refer to [Selenium - Proxy Object](https://github.com/SeleniumHQ/selenium/wiki/DesiredCapabilities) for more
+ * information.
  *
  * ### Cloud Providers
  *
@@ -196,6 +202,7 @@ class WebDriverIO extends Helper {
       desiredCapabilities: {},
       restart: true,
       uniqueScreenshotNames: false,
+      fullPageScreenshots: true,
       manualStart: false,
       keepCookies: false,
       timeouts: {
@@ -210,7 +217,7 @@ class WebDriverIO extends Helper {
     this.options.desiredCapabilities.browserName = this.options.browser || this.options.desiredCapabilities.browserName;
     this.options.waitForTimeout /= 1000; // convert to seconds
 
-    if (!this.options.url || !this.options.browser) {
+    if (!this.options.desiredCapabilities.platformName && (!this.options.url || !this.options.browser)) {
       throw new Error(`
         WebDriverIO requires ares.valuet least these parameters
         Check your codeceptjs config file to ensure these are set properly
@@ -224,6 +231,8 @@ class WebDriverIO extends Helper {
           }
       `);
     }
+
+
   }
 
   static _checkRequirements() {
@@ -298,11 +307,13 @@ class WebDriverIO extends Helper {
   _failed(test) {
     let fileName = '';
     if (this.options.uniqueScreenshotNames) {
-      fileName = test.title.substring(0, 10).replace(/ /g, '_') + '-' + hashCode(test.title) + '-' + hashCode(test.file) + '.failed.png';
+      fileName =
+        test.title.substring(0, 10).replace(/ /g, '_') + '-' + hashCode(test.title) + '-' + hashCode(test.file) +
+        '.failed.png';
     } else {
       fileName = test.title.replace(/ /g, '_') + '.failed.png';
     }
-    return this.saveScreenshot(fileName, true);
+    return this.saveScreenshot(fileName, this.options.fullPageScreenshots);
   }
 
   _withinBegin(locator) {
@@ -388,6 +399,7 @@ class WebDriverIO extends Helper {
 
   /**
    * Set [WebDriverIO timeouts](http://webdriver.io/guide/testrunner/timeouts.html) in realtime.
+   * Appium: support only web testing
    * Timeouts are expected to be passed as object:
    *
    * ```js
@@ -409,6 +421,7 @@ class WebDriverIO extends Helper {
 
   /**
    * {{> ../webapi/amOnPage }}
+   * Appium: support only web testing
    */
   amOnPage(url) {
     return this.browser.url(url).url((err, res) => {
@@ -419,6 +432,7 @@ class WebDriverIO extends Helper {
 
   /**
    * {{> ../webapi/click }}
+   * Appium: support
    */
   click(locator, context) {
     let client = this.browser;
@@ -438,6 +452,7 @@ class WebDriverIO extends Helper {
 
   /**
    * {{> ../webapi/doubleClick }}
+   * Appium: support only web testing
    */
   doubleClick(locator, context) {
     let client = this.browser;
@@ -456,6 +471,7 @@ class WebDriverIO extends Helper {
 
   /**
    * Performs right click on an element matched by CSS or XPath.
+   * Appium: support, but in apps works as usual click
    */
   rightClick(locator) {
     return this.browser.rightClick(withStrictLocator(locator));
@@ -463,6 +479,7 @@ class WebDriverIO extends Helper {
 
   /**
    * {{> ../webapi/fillField }}
+   * Appium: support
    */
   fillField(field, value) {
     return findFields(this.browser, field).then(function (res) {
@@ -476,6 +493,7 @@ class WebDriverIO extends Helper {
 
   /**
    * {{> ../webapi/appendField }}
+   * Appium: support, but it's clear a field before insert in apps
    */
   appendField(field, value) {
     return findFields(this.browser, field).then(function (res) {
@@ -489,7 +507,7 @@ class WebDriverIO extends Helper {
 
   /**
    * {{> ../webapi/selectOption}}
-   *
+   * Appium: support only web testing
    */
   selectOption(select, option) {
     return findFields(this.browser, select).then(function (res) {
@@ -547,6 +565,7 @@ class WebDriverIO extends Helper {
 
   /**
    * {{> ../webapi/attachFile }}
+   * Appium: not tested
    */
   attachFile(locator, pathToFile) {
     let file = path.join(global.codecept_dir, pathToFile);
@@ -566,6 +585,7 @@ class WebDriverIO extends Helper {
 
   /**
    * {{> ../webapi/checkOption }}
+   * Appium: not tested
    */
   checkOption(field, context) {
     let client = this.browser;
@@ -587,6 +607,7 @@ class WebDriverIO extends Helper {
 
   /**
    * {{> ../webapi/grabTextFrom }}
+   * Appium: support
    */
   grabTextFrom(locator) {
     return this.browser.getText(withStrictLocator(locator)).then(function (text) {
@@ -597,6 +618,7 @@ class WebDriverIO extends Helper {
   /**
    * Retrieves the innerHTML from an element located by CSS or XPath and returns it to test.
    * Resumes test execution, so **should be used inside a generator with `yield`** operator.
+   * Appium: support only web testing
    *
    * ```js
    * let postHTML = yield I.grabHTMLFrom('#post');
@@ -610,6 +632,7 @@ class WebDriverIO extends Helper {
 
   /**
    * {{> ../webapi/grabValueFrom }}
+   * Appium: support only web testing
    */
   grabValueFrom(locator) {
     return this.browser.getValue(withStrictLocator(locator)).then(function (text) {
@@ -619,6 +642,7 @@ class WebDriverIO extends Helper {
 
   /**
    * {{> ../webapi/grabAttributeFrom }}
+   * Appium: can be used for apps only with several values ("contentDescription", "text", "className", "resourceId")
    */
   grabAttributeFrom(locator, attr) {
     return this.browser.getAttribute(withStrictLocator(locator), attr).then(function (text) {
@@ -628,6 +652,7 @@ class WebDriverIO extends Helper {
 
   /**
    * {{> ../webapi/seeInTitle }}
+   * Appium: support only web testing
    */
   seeInTitle(text) {
     return this.browser.getTitle().then((title) => {
@@ -637,6 +662,7 @@ class WebDriverIO extends Helper {
 
   /**
    * {{> ../webapi/dontSeeInTitle }}
+   * Appium: support only web testing
    */
   dontSeeInTitle(text) {
     return this.browser.getTitle().then((title) => {
@@ -646,6 +672,7 @@ class WebDriverIO extends Helper {
 
   /**
    * {{> ../webapi/grabTitle }}
+   * Appium: support only web testing
    */
   grabTitle() {
     return this.browser.getTitle().then((title) => {
@@ -656,6 +683,7 @@ class WebDriverIO extends Helper {
 
   /**
    * {{> ../webapi/see }}
+   * Appium: support with context in apps
    */
   see(text, context) {
     return proceedSee.call(this, 'assert', text, context);
@@ -663,6 +691,7 @@ class WebDriverIO extends Helper {
 
   /**
    * {{> ../webapi/dontSee }}
+   * Appium: support with context in apps
    */
   dontSee(text, context) {
     return proceedSee.call(this, 'negate', text, context);
@@ -670,6 +699,7 @@ class WebDriverIO extends Helper {
 
   /**
    * {{> ../webapi/seeInField }}
+   * Appium: support only web testing
    */
   seeInField(field, value) {
     return proceedSeeField.call(this, 'assert', field, value);
@@ -677,6 +707,7 @@ class WebDriverIO extends Helper {
 
   /**
    * {{> ../webapi/dontSeeInField }}
+   * Appium: support only web testing
    */
   dontSeeInField(field, value) {
     return proceedSeeField.call(this, 'negate', field, value);
@@ -684,6 +715,7 @@ class WebDriverIO extends Helper {
 
   /**
    * {{> ../webapi/seeCheckboxIsChecked }}
+   * Appium: not tested
    */
   seeCheckboxIsChecked(field) {
     return proceedSeeCheckbox.call(this, 'assert', field);
@@ -691,6 +723,7 @@ class WebDriverIO extends Helper {
 
   /**
    * {{> ../webapi/dontSeeCheckboxIsChecked }}
+   * Appium: not tested
    */
   dontSeeCheckboxIsChecked(field) {
     return proceedSeeCheckbox.call(this, 'negate', field);
@@ -698,6 +731,7 @@ class WebDriverIO extends Helper {
 
   /**
    * {{> ../webapi/seeElement }}
+   * Appium: support
    */
   seeElement(locator) {
     return this.browser.isVisible(withStrictLocator(locator)).then(function (res) {
@@ -707,6 +741,7 @@ class WebDriverIO extends Helper {
 
   /**
    * {{> ../webapi/dontSeeElement}}
+   * Appium: support
    */
   dontSeeElement(locator) {
     return this.browser.isVisible(withStrictLocator(locator)).then(function (res) {
@@ -716,6 +751,7 @@ class WebDriverIO extends Helper {
 
   /**
    * {{> ../webapi/seeElementInDOM }}
+   * Appium: support
    */
   seeElementInDOM(locator) {
     return this.browser.elements(withStrictLocator(locator)).then(function (res) {
@@ -725,6 +761,7 @@ class WebDriverIO extends Helper {
 
   /**
    * {{> ../webapi/dontSeeElementInDOM }}
+   * Appium: support
    */
   dontSeeElementInDOM(locator) {
     return this.browser.elements(withStrictLocator(locator)).then(function (res) {
@@ -734,6 +771,7 @@ class WebDriverIO extends Helper {
 
   /**
    * {{> ../webapi/seeInSource }}
+   * Appium: support
    */
   seeInSource(text) {
     return this.browser.getSource().then((source) => {
@@ -741,8 +779,17 @@ class WebDriverIO extends Helper {
     });
   }
 
+  /**
+   * {{> ../webapi/seeInSource }}
+   * Appium: support
+   */
+  grabSource() {
+    return this.browser.getSource();
+  }
+
   /**
    * {{> ../webapi/dontSeeInSource }}
+   * Appium: support
    */
   dontSeeInSource(text) {
     return this.browser.getSource().then((source) => {
@@ -753,6 +800,7 @@ class WebDriverIO extends Helper {
   /**
    * asserts that an element appears a given number of times in the DOM
    * Element is located by label or name or CSS or XPath.
+   * Appium: support
    *
    * ```js
    * I.seeNumberOfElements('#submitBtn', 1);
@@ -784,6 +832,7 @@ class WebDriverIO extends Helper {
 
   /**
    * {{> ../webapi/seeInCurrentUrl }}
+   * Appium: support only web testing
    */
   seeInCurrentUrl(url) {
     return this.browser.url().then(function (res) {
@@ -793,6 +842,7 @@ class WebDriverIO extends Helper {
 
   /**
    * {{> ../webapi/dontSeeInCurrentUrl }}
+   * Appium: support only web testing
    */
   dontSeeInCurrentUrl(url) {
     return this.browser.url().then(function (res) {
@@ -802,6 +852,7 @@ class WebDriverIO extends Helper {
 
   /**
    * {{> ../webapi/seeCurrentUrlEquals }}
+   * Appium: support only web testing
    */
   seeCurrentUrlEquals(url) {
     return this.browser.url().then((res) => {
@@ -811,6 +862,7 @@ class WebDriverIO extends Helper {
 
   /**
    * {{> ../webapi/dontSeeCurrentUrlEquals }}
+   * Appium: support only web testing
    */
   dontSeeCurrentUrlEquals(url) {
     return this.browser.url().then((res) => {
@@ -820,6 +872,7 @@ class WebDriverIO extends Helper {
 
   /**
    * {{> ../webapi/executeScript }}
+   * Appium: support only web testing
    *
    * Wraps [execute](http://webdriver.io/api/protocol/execute.html) command.
    */
@@ -829,6 +882,7 @@ class WebDriverIO extends Helper {
 
   /**
    * {{> ../webapi/executeAsyncScript }}
+   * Appium: support only web testing
    */
   executeAsyncScript(fn) {
     return this.browser.executeAsync.apply(this.browser, arguments).then((res) => res.value);
@@ -837,6 +891,7 @@ class WebDriverIO extends Helper {
   /**
    * Scrolls to element matched by locator.
    * Extra shift can be set with offsetX and offsetY options
+   * Appium: support only web testing
    *
    * ```js
    * I.scrollTo('footer');
@@ -849,6 +904,7 @@ class WebDriverIO extends Helper {
 
   /**
    * {{> ../webapi/moveCursorTo}}
+   * Appium: support only web testing
    */
   moveCursorTo(locator, offsetX, offsetY) {
     return this.browser.moveToObject(withStrictLocator(locator), offsetX, offsetY);
@@ -856,6 +912,7 @@ class WebDriverIO extends Helper {
 
   /**
    * {{> ../webapi/saveScreenshot}}
+   * Appium: support
    */
   saveScreenshot(fileName, fullPage = false) {
     let outputFile = path.join(global.output_dir, fileName);
@@ -868,9 +925,9 @@ class WebDriverIO extends Helper {
       height: document.body.scrollHeight,
       width: document.body.scrollWidth
     })).then(({
-      width,
-      height
-    }) => {
+                width,
+                height
+              }) => {
       this.browser.windowHandleSize(width, height);
       this.debug('Screenshot has been saved to ' + outputFile);
       return this.browser.saveScreenshot(outputFile);
@@ -880,6 +937,7 @@ class WebDriverIO extends Helper {
 
   /**
    * {{> ../webapi/setCookie}}
+   * Appium: support only web testing
    *
    * Uses Selenium's JSON [cookie format](https://code.google.com/p/selenium/wiki/JsonWireProtocol#Cookie_JSON_Object).
    */
@@ -889,6 +947,7 @@ class WebDriverIO extends Helper {
 
   /**
    * {{> ../webapi/clearCookie}}
+   * Appium: support only web testing
    */
   clearCookie(cookie) {
     return this.browser.deleteCookie(cookie);
@@ -896,6 +955,7 @@ class WebDriverIO extends Helper {
 
   /**
    * {{> ../webapi/clearField}}
+   * Appium: support
    */
   clearField(field) {
     return findFields(this.browser, field).then(function (res) {
@@ -910,6 +970,7 @@ class WebDriverIO extends Helper {
 
   /**
    * {{> ../webapi/seeCookie}}
+   * Appium: support only web testing
    */
   seeCookie(name) {
     return this.browser.getCookie(name).then(function (res) {
@@ -919,6 +980,7 @@ class WebDriverIO extends Helper {
 
   /**
    * {{> ../webapi/dontSeeCookie}}
+   * Appium: support only web testing
    */
   dontSeeCookie(name) {
     return this.browser.getCookie(name).then(function (res) {
@@ -928,6 +990,7 @@ class WebDriverIO extends Helper {
 
   /**
    * {{> ../webapi/grabCookie}}
+   * Appium: support only web testing
    */
   grabCookie(name) {
     return this.browser.getCookie(name);
@@ -935,7 +998,8 @@ class WebDriverIO extends Helper {
 
   /**
    * Accepts the active JavaScript native popup window, as created by window.alert|window.confirm|window.prompt.
-   * Don't confuse popups with modal windows, as created by [various libraries](http://jster.net/category/windows-modals-popups).
+   * Don't confuse popups with modal windows, as created by [various
+   * libraries](http://jster.net/category/windows-modals-popups). Appium: support only web testing
    */
   acceptPopup() {
     return this.browser.alertText().then(function (res) {
@@ -947,6 +1011,7 @@ class WebDriverIO extends Helper {
 
   /**
    * Dismisses the active JavaScript popup, as created by window.alert|window.confirm|window.prompt.
+   * Appium: support only web testing
    */
   cancelPopup() {
     return this.browser.alertText().then(function (res) {
@@ -957,7 +1022,8 @@ class WebDriverIO extends Helper {
   }
 
   /**
-   * Checks that the active JavaScript popup, as created by `window.alert|window.confirm|window.prompt`, contains the given string.
+   * Checks that the active JavaScript popup, as created by `window.alert|window.confirm|window.prompt`, contains the
+   * given string. Appium: support only web testing
    */
   seeInPopup(text) {
     return this.browser.alertText().then(function (res) {
@@ -972,6 +1038,7 @@ class WebDriverIO extends Helper {
    * {{> ../webapi/pressKey }}
    *
    * To make combinations with modifier and mouse clicks (like Ctrl+Click) press a modifier, click, then release it.
+   * Appium: support, but clear field before pressing in apps
    *
    * ```js
    * I.pressKey('Control');
@@ -992,6 +1059,7 @@ class WebDriverIO extends Helper {
 
   /**
    * {{> ../webapi/resizeWindow }}
+   * Appium: not tested in web, in apps doesn't work
    */
   resizeWindow(width, height) {
     if (width === 'maximize') {
@@ -1005,6 +1073,7 @@ class WebDriverIO extends Helper {
 
   /**
    * Drag an item to a destination element.
+   * Appium: not tested
    *
    * ```js
    * I.dragAndDrop('#dragHandle', '#container');
@@ -1019,6 +1088,7 @@ class WebDriverIO extends Helper {
 
   /**
    * {{> ../webapi/wait }}
+   * Appium: support
    */
   wait(sec) {
     return this.browser.pause(sec * 1000);
@@ -1026,6 +1096,7 @@ class WebDriverIO extends Helper {
 
   /**
    * {{> ../webapi/waitForEnabled }}
+   * Appium: support
    */
   waitForEnabled(locator, sec) {
     sec = sec || this.options.waitForTimeout;
@@ -1034,6 +1105,7 @@ class WebDriverIO extends Helper {
 
   /**
    * {{> ../webapi/waitForElement }}
+   * Appium: support
    */
   waitForElement(locator, sec) {
     sec = sec || this.options.waitForTimeout;
@@ -1042,12 +1114,13 @@ class WebDriverIO extends Helper {
 
   /**
    * {{> ../webapi/waitForText }}
+   * Appium: support
    */
   waitForText(text, sec, context) {
     sec = sec || this.options.waitForTimeout;
     context = context || 'body';
     return this.browser.waitUntil(function () {
-      return this.getText(context).then(function (source) {
+      return this.getText(withStrictLocator(context)).then(function (source) {
         if (Array.isArray(source)) {
           return source.filter(part => part.indexOf(text) >= 0).length > 0;
         }
@@ -1056,7 +1129,7 @@ class WebDriverIO extends Helper {
     }, sec * 1000)
       .catch((e) => {
         if (e.type === 'WaitUntilTimeoutError') {
-          return proceedSee.call(this, 'assert', text, context);
+          return proceedSee.call(this, 'assert', text, withStrictLocator(context));
         } else {
           throw e;
         }
@@ -1065,6 +1138,7 @@ class WebDriverIO extends Helper {
 
   /**
    * {{> ../webapi/waitForVisible }}
+   * Appium: support
    */
   waitForVisible(locator, sec) {
     sec = sec || this.options.waitForTimeout;
@@ -1073,6 +1147,7 @@ class WebDriverIO extends Helper {
 
   /**
    * {{> ../webapi/waitForInvisible }}
+   * Appium: support
    */
   waitForInvisible(locator, sec) {
     sec = sec || this.options.waitForTimeout;
@@ -1082,6 +1157,7 @@ class WebDriverIO extends Helper {
   /**
    * Waits for an element to become invisible on a page (by default waits for 1sec).
    * Element can be located by CSS or XPath.
+   * Appium: support
    */
   waitToHide(locator, sec) {
     return this.waitForInvisible(locator, sec);
@@ -1089,6 +1165,7 @@ class WebDriverIO extends Helper {
 
   /**
    * {{> ../webapi/waitForStalenessOf }}
+   * Appium: support
    */
   waitForStalenessOf(locator, sec) {
     sec = sec || this.options.waitForTimeout;
@@ -1097,6 +1174,7 @@ class WebDriverIO extends Helper {
 
   /**
    * Waits for a function to return true (waits for 1sec by default).
+   * Appium: support
    */
   waitUntil(fn, sec) {
     sec = sec || this.options.waitForTimeout;
@@ -1105,11 +1183,13 @@ class WebDriverIO extends Helper {
 
   /**
    * Switches frame or in case of null locator reverts to parent.
+   * Appium: support only web testing
    */
   switchTo(locator) {
     locator = locator || null;
     return this.browser.frame(locator);
   }
+
 }
 
 function proceedSee(assertType, text, context) {
@@ -1283,6 +1363,7 @@ function withStrictLocator(locator) {
   switch (key) {
   case 'by':
   case 'xpath':
+    return value;
   case 'css':
     return value;
   case 'id':
diff --git a/package.json b/package.json
index a12c8d3e4..a258c4949 100644
--- a/package.json
+++ b/package.json
@@ -61,7 +61,7 @@
     "protractor": ">4.0.9 <6.0",
     "selenium-webdriver": "^2.53.1",
     "sinon": "^1.17.2",
-    "webdriverio": ">3.4.0 <5.0.0"
+    "webdriverio": ">3.4.0 <4.7.1"
   },
   "scripts": {
     "prepublish": "gulp prepublish",
diff --git a/test/data/mobile/selendroid-test-app-0.17.0.apk b/test/data/mobile/selendroid-test-app-0.17.0.apk
new file mode 100644
index 000000000..9ccb53a05
Binary files /dev/null and b/test/data/mobile/selendroid-test-app-0.17.0.apk differ
diff --git a/test/helper/Appium_test.js b/test/helper/Appium_test.js
new file mode 100644
index 000000000..63f7efbff
--- /dev/null
+++ b/test/helper/Appium_test.js
@@ -0,0 +1,504 @@
+'use strict';
+
+let Appium = require('../../lib/helper/Appium');
+let should = require('chai').should();
+let app;
+let assert = require('assert');
+let path = require('path');
+let fs = require('fs');
+let fileExists = require('../../lib/utils').fileExists;
+let AssertionFailedError = require('../../lib/assert/error');
+let expectError = require('../../lib/utils').test.expectError;
+let apk_path =  'https://github.com/Codeception/CodeceptJS/raw/Appium/test/data/mobile/selendroid-test-app-0.17.0.apk'
+
+
+describe('Appium', function () {
+  this.retries(1);
+  this.timeout(120000);
+
+  before(() => {
+    global.codecept_dir = path.join(__dirname, '/../data');
+    try {
+      fs.unlinkSync(dataFile);
+    } catch (err) {
+    }
+
+    app = new Appium({
+      desiredCapabilities: {
+        app: apk_path,
+        appiumVersion: "1.6.4",
+        browserName: "",
+        recordVideo: "false",
+        recordScreenshots: "false",
+        platformName: "Android",
+        platformVersion: "6.0",
+        deviceName: "Android Emulator"
+      },
+      host: 'ondemand.saucelabs.com',
+      port: 80,
+      user: process.env.SAUCE_USERNAME,
+      key: process.env.SAUCE_ACCESS_KEY,
+    });
+  });
+
+  beforeEach(() => {
+    return app._before();
+  });
+
+  afterEach(() => {
+    return app._after();
+  });
+
+
+  describe('app installation : #seeAppIsInstalled, #installApp, #removeApp, #seeAppIsNotInstalled', () => {
+
+    describe(
+      '#grabAllContexts, #grabContext, #grabCurrentActivity, #grabNetworkConnection, #grabOrientation, #grabSettings',
+      () => {
+
+        it('should grab all available contexts for screen', function*() {
+          yield app.click('~buttonStartWebviewCD')
+          let val = yield app.grabAllContexts();
+          assert.deepEqual(val, ['NATIVE_APP', 'WEBVIEW_io.selendroid.testapp']);
+        });
+
+        it('should grab current context', function*() {
+          let val = yield app.grabContext();
+          assert.equal(val, 'NATIVE_APP');
+        });
+
+        it('should grab current activity of app', function*() {
+          let val = yield app.grabCurrentActivity();
+          assert.equal(val, '.HomeScreenActivity');
+        });
+
+        it('should grab network connection settings', function*() {
+          yield app.setNetworkConnection(4)
+          let val = yield app.grabNetworkConnection();
+          assert.equal(val.value, 4);
+          assert.equal(val.inAirplaneMode, false);
+          assert.equal(val.hasWifi, false);
+          assert.equal(val.hasData, true);
+        });
+
+        it('should grab orientation', function*() {
+          let val = yield app.grabOrientation();
+          assert.equal(val, 'PORTRAIT');
+        });
+
+        it('should grab custom settings', function*() {
+          let val = yield app.grabSettings();
+          assert.deepEqual(val, {ignoreUnimportantViews: false});
+        });
+
+      });
+
+    it('should remove App and install it again', () => {
+      return app.seeAppIsInstalled("io.selendroid.testapp")
+        .then(() => app.removeApp("io.selendroid.testapp"))
+        .then(() => app.seeAppIsNotInstalled("io.selendroid.testapp"))
+        .then(() => app.installApp(apk_path))
+        .then(() => app.seeAppIsInstalled("io.selendroid.testapp"))
+    });
+
+    it('should assert when app is/is not installed', () => {
+      return app.seeAppIsInstalled("io.super.app")
+        .then(expectError)
+        .catch((e) => {
+          e.should.be.instanceOf(AssertionFailedError);
+          e.inspect().should.include('expected app io.super.app to be installed');
+        })
+        .then(() => app.seeAppIsNotInstalled("io.selendroid.testapp"))
+        .then(expectError)
+        .catch((e) => {
+          e.should.be.instanceOf(AssertionFailedError);
+          e.inspect().should.include('expected app io.selendroid.testapp not to be installed');
+        })
+    });
+  });
+
+  describe('see seeCurrentActivity: #seeCurrentActivityIs', () => {
+
+    it('should return .HomeScreenActivity for default screen', () => {
+      return app.seeCurrentActivityIs(".HomeScreenActivity")
+    });
+
+    it('should assert for wrong screen', () => {
+      return app.seeCurrentActivityIs(".SuperScreen")
+        .then(expectError)
+        .catch((e) => {
+          e.should.be.instanceOf(AssertionFailedError);
+          e.inspect().should.include('expected current activity to be .SuperScreen');
+        })
+    });
+  });
+
+  describe('device lock : #seeDeviceIsLocked, #dontSeeDeviceIsLocked', () => {
+
+    it('should return correct status about lock', () => {
+      return app.dontSeeDeviceIsLocked()
+        .then(() => app.seeDeviceIsLocked())
+        .then(expectError)
+        .catch((e) => {
+          e.should.be.instanceOf(AssertionFailedError);
+          e.inspect().should.include('expected device to be locked');
+        })
+    });
+  });
+
+  describe('device orientation : #seeOrientationIs #setOrientation', () => {
+
+    it('should return correct status about lock', () => {
+      return app.seeOrientationIs('PORTRAIT')
+        .then(() => app.seeOrientationIs('LANDSCAPE'))
+        .then(expectError)
+        .catch((e) => {
+          e.should.be.instanceOf(AssertionFailedError);
+          e.inspect().should.include('expected orientation to be LANDSCAPE');
+        })
+    });
+
+    it('should set device orientation', () => {
+      return app.click('~buttonStartWebviewCD')
+        .then(() => app.setOrientation('LANDSCAPE'))
+        .then(() => app.seeOrientationIs('LANDSCAPE'))
+    });
+
+  });
+
+  describe('app context and activity: #switchToContext', () => {
+
+    it('should switch context', function*() {
+      yield app.click('~buttonStartWebviewCD')
+      yield app.switchToContext('WEBVIEW_io.selendroid.testapp')
+      let val = yield app.grabContext();
+      return assert.equal(val, 'WEBVIEW_io.selendroid.testapp');
+    });
+
+    it('should switch activity', function*() {
+      yield app.startActivity('io.selendroid.testapp', '.RegisterUserActivity')
+      let val = yield app.grabCurrentActivity();
+      assert.equal(val, '.RegisterUserActivity');
+    });
+
+  });
+
+  describe('#setNetworkConnection, #setSettings', () => {
+
+    it('should set Network Connection (airplane mode on)', function*() {
+      yield app.setNetworkConnection(1)
+      let val = yield app.grabNetworkConnection();
+      return assert.equal(val.value, 1);
+    });
+
+    it('should set custom settings', function*() {
+      yield app.setSettings({cyberdelia: 'open'})
+      let val = yield app.grabSettings();
+      assert.deepEqual(val, {ignoreUnimportantViews: false, cyberdelia: 'open'});
+    });
+
+  });
+
+  describe('#hideDeviceKeyboard', () => {
+
+    it('should hide device Keyboard', () => {
+      return app.click('~startUserRegistrationCD')
+        .then(() => app.click('android.widget.CheckBox'))
+        .then(expectError)
+        .catch((e) => {
+          e.message.should.include('Clickable element android.widget.CheckBox was not found by text|CSS|XPath');
+        })
+        .then(() => app.hideDeviceKeyboard('pressKey', 'Done'))
+        .then(() => app.click('android.widget.CheckBox'))
+    });
+
+    it('should assert if no keyboard', () => {
+      return app.hideDeviceKeyboard('pressKey', 'Done').then(expectError)
+        .catch((e) => {
+          e.message.should.include(
+            'An unknown server-side error occurred while processing the command. Original error: Soft keyboard not present, cannot hide keyboard');
+        })
+    });
+
+  });
+
+  describe('#sendDeviceKeyEvent', () => {
+
+    it('should react on pressing keycode', function*() {
+      return app.sendDeviceKeyEvent(3)
+        .then(() => app.waitForVisible('~Apps'))
+    });
+
+  });
+
+  describe('#openNotifications', () => {
+
+    it('should react on notification opening', () => {
+      return app.seeElement('//android.widget.FrameLayout[@resource-id="com.android.systemui:id/quick_settings_container"]')
+        .then(expectError)
+        .catch((e) => {
+          e.should.be.instanceOf(AssertionFailedError);
+          e.inspect().should.include('expected elements of //android.widget.FrameLayout[@resource-id="com.android.systemui:id/quick_settings_container"] to be seen');
+        })
+        .then(() => app.openNotifications())
+        .then(() => app.waitForVisible('//android.widget.FrameLayout[@resource-id="com.android.systemui:id/quick_settings_container"]', 10))
+    });
+
+  });
+
+  describe('#makeTouchAction', () => {
+
+    it('should react on touch actions', function*() {
+      yield app.makeTouchAction("~buttonStartWebviewCD", 'tap')
+      let val = yield app.grabCurrentActivity();
+      assert.equal(val, '.WebViewActivity');
+    });
+
+    it('should react on swipe action', function*() {
+      yield app.click("//android.widget.Button[@resource-id = 'io.selendroid.testapp:id/touchTest']")
+      yield app.waitForText("Gesture Type", 10,
+        "//android.widget.TextView[@resource-id = 'io.selendroid.testapp:id/gesture_type_text_view']")
+      yield app.swipe("//android.widget.LinearLayout[@resource-id = 'io.selendroid.testapp:id/LinearLayout1']", 800,
+        1200, 1000);
+      let type = yield app.grabTextFrom(
+        "//android.widget.TextView[@resource-id = 'io.selendroid.testapp:id/gesture_type_text_view']")
+      let vx = yield app.grabTextFrom("//android.widget.TextView[@resource-id = 'io.selendroid.testapp:id/text_view3']")
+      let vy = yield app.grabTextFrom("//android.widget.TextView[@resource-id = 'io.selendroid.testapp:id/text_view4']")
+      assert.equal(type, 'FLICK');
+      assert.equal(vx, 'vx: 12000.0 pps');
+      assert.equal(vy, 'vy: 12000.0 pps');
+    });
+
+    it('should react on swipeDown action', function*() {
+      yield app.click("//android.widget.Button[@resource-id = 'io.selendroid.testapp:id/touchTest']")
+      yield app.waitForText("Gesture Type", 10,
+        "//android.widget.TextView[@resource-id = 'io.selendroid.testapp:id/gesture_type_text_view']")
+      yield app.swipeDown("//android.widget.LinearLayout[@resource-id = 'io.selendroid.testapp:id/LinearLayout1']",
+        1200, 1000);
+      let type = yield app.grabTextFrom(
+        "//android.widget.TextView[@resource-id = 'io.selendroid.testapp:id/gesture_type_text_view']")
+      let vy = yield app.grabTextFrom("//android.widget.TextView[@resource-id = 'io.selendroid.testapp:id/text_view4']")
+      assert.equal(type, 'FLICK');
+      assert.equal(vy, 'vy: 12000.0 pps');
+    });
+
+    it('should react on swipeUp action', function*() {
+      yield app.click("//android.widget.Button[@resource-id = 'io.selendroid.testapp:id/touchTest']")
+      yield app.waitForText("Gesture Type", 10,
+        "//android.widget.TextView[@resource-id = 'io.selendroid.testapp:id/gesture_type_text_view']")
+      yield app.swipeUp("//android.widget.LinearLayout[@resource-id = 'io.selendroid.testapp:id/LinearLayout1']", -1200,
+        1000);
+      let type = yield app.grabTextFrom(
+        "//android.widget.TextView[@resource-id = 'io.selendroid.testapp:id/gesture_type_text_view']")
+      let vy = yield app.grabTextFrom("//android.widget.TextView[@resource-id = 'io.selendroid.testapp:id/text_view4']")
+      assert.equal(type, 'FLICK');
+      assert.equal(vy, 'vy: -12000.0 pps');
+    });
+
+    it('should react on swipeRight action', function*() {
+      yield app.click("//android.widget.Button[@resource-id = 'io.selendroid.testapp:id/touchTest']")
+      yield app.waitForText("Gesture Type", 10,
+        "//android.widget.TextView[@resource-id = 'io.selendroid.testapp:id/gesture_type_text_view']")
+      yield app.swipeRight("//android.widget.LinearLayout[@resource-id = 'io.selendroid.testapp:id/LinearLayout1']",
+        800, 1000);
+      let type = yield app.grabTextFrom(
+        "//android.widget.TextView[@resource-id = 'io.selendroid.testapp:id/gesture_type_text_view']")
+      let vy = yield app.grabTextFrom("//android.widget.TextView[@resource-id = 'io.selendroid.testapp:id/text_view3']")
+      assert.equal(type, 'FLICK');
+      assert.equal(vy, 'vx: 12000.0 pps');
+    });
+
+    it('should react on swipeLeft action', function*() {
+      yield app.click("//android.widget.Button[@resource-id = 'io.selendroid.testapp:id/touchTest']")
+      yield app.waitForText("Gesture Type", 10,
+        "//android.widget.TextView[@resource-id = 'io.selendroid.testapp:id/gesture_type_text_view']")
+      yield app.swipeLeft("//android.widget.LinearLayout[@resource-id = 'io.selendroid.testapp:id/LinearLayout1']",
+        -800, 1000);
+      let type = yield app.grabTextFrom(
+        "//android.widget.TextView[@resource-id = 'io.selendroid.testapp:id/gesture_type_text_view']")
+      let vy = yield app.grabTextFrom("//android.widget.TextView[@resource-id = 'io.selendroid.testapp:id/text_view3']")
+      assert.equal(type, 'FLICK');
+      assert.equal(vy, 'vx: -12000.0 pps');
+    });
+
+    it('should react on touchPerform action', function*() {
+      //yield app.seeInSource('blabla')
+      yield app.touchPerform([{
+        action: 'press',
+        options: {
+          x: 100,
+          y: 200
+        }
+      }, {action: 'release'}])
+      let val = yield app.grabCurrentActivity();
+      assert.equal(val, '.WebViewActivity');
+    });
+
+    it('should assert when you dont scroll the document anymore', () => {
+      return app.click('~startUserRegistrationCD')
+        .then(
+          () => app.swipeTo("android.widget.CheckBox", "//android.widget.ScrollView/android.widget.LinearLayout", "up",
+            30, 100, 500))
+        .catch((e) => {
+          e.inspect().should.include('Scroll to the end and element android.widget.CheckBox was not found');
+        })
+    });
+
+    it('should react on swipeTo action', function*() {
+      yield app.click("~startUserRegistrationCD")
+      yield app.swipeTo("android.widget.CheckBox", "//android.widget.ScrollView/android.widget.LinearLayout", "up", 30,
+        100, 700);
+    });
+
+  });
+
+  describe('#pullFile', () => {
+
+    it('should pull file to local machine', function*() {
+      let savepath = path.join(__dirname, '/../data/output/testpullfile' + new Date().getTime() + '.png')
+      return app.pullFile('/storage/emulated/0/DCIM/sauce_logo.png', savepath)
+        .then(() => assert.ok(fileExists(savepath), null, 'file does not exists'));
+    });
+  });
+
+
+  describe('see text : #see', () => {
+    it('should fail when text is not on site', () => {
+      return app.see('EN Button', '~buttonTestCD')
+        .then(() => app.dontSee('Welcome', '~buttonTestCD'));
+    });
+  });
+
+  describe('#pressKey', () => {
+    it('should be able to send special keys to element', function*() {
+      yield app.click('~startUserRegistrationCD')
+      yield app.click('~email of the customer')
+      yield app.pressKey('1');
+      yield app.hideDeviceKeyboard('pressKey', 'Done')
+      yield app.swipeTo("android.widget.Button", "//android.widget.ScrollView/android.widget.LinearLayout", "up", 30,
+        100, 700);
+      yield app.click('android.widget.Button');
+      return app.see('1',
+        '//android.widget.TextView[@resource-id="io.selendroid.testapp:id/label_email_data"]');
+    });
+  });
+
+  describe('#seeInSource', () => {
+    it('should check for text to be in HTML source', () => {
+      return app.seeInSource(
+        'class="android.widget.Button" package="io.selendroid.testapp" content-desc="buttonTestCD"')
+        .then(() => app.dontSeeInSource('<meta'));
+    });
+  });
+
+  describe('#waitForText', () => {
+    it('should return error if not present', () => {
+      return app.waitForText('Nothing here', 1, '~buttonTestCD')
+        .then(expectError)
+        .catch((e) => {
+          e.should.be.instanceOf(AssertionFailedError);
+          e.inspect().should.be.equal('expected element ~buttonTestCD to include "Nothing here"');
+        });
+    });
+  });
+
+  describe('#seeNumberOfElements', () => {
+    it('should return 1 as count', () => {
+      return app.seeNumberOfElements('~buttonTestCD', 1);
+    });
+  });
+
+  describe('see element : #seeElement, #dontSeeElement', () => {
+    it('should check visible elements on page', function*() {
+      yield app.seeElement('~buttonTestCD');
+      yield app.seeElement('//android.widget.Button[@content-desc = "buttonTestCD"]');
+      yield app.dontSeeElement('#something-beyond');
+      return app.dontSeeElement('//input[@id="something-beyond"]');
+    });
+  });
+
+  describe('#click', () => {
+    it('should click by accessibility id', function*() {
+      return app.click('~startUserRegistrationCD')
+        .then(() => app.seeElement('~label_usernameCD'))
+    });
+
+    it('should click by xpath', function*() {
+      return app.click('//android.widget.ImageButton[@content-desc = "startUserRegistrationCD"]')
+        .then(() => app.seeElement('~label_usernameCD'))
+    });
+  });
+
+  describe('#fillField, #appendField', () => {
+    it('should fill field by accessibility id', function*() {
+      return app.click('~startUserRegistrationCD')
+        .then(() => app.fillField('~email of the customer', 'Nothing special'))
+        .then(() => app.hideDeviceKeyboard('pressKey', 'Done'))
+        .then(() => app.swipeTo("android.widget.Button", "//android.widget.ScrollView/android.widget.LinearLayout", "up", 30,
+        100, 700))
+        .then(() => app.click('android.widget.Button'))
+        .then(() => app.see('Nothing special',
+          '//android.widget.TextView[@resource-id="io.selendroid.testapp:id/label_email_data"]'))
+    });
+
+    it('should fill field by xpath', function*() {
+      yield app.click('~startUserRegistrationCD')
+      yield app.fillField('//android.widget.EditText[@content-desc="email of the customer"]', 'Nothing special');
+      yield app.hideDeviceKeyboard('pressKey', 'Done')
+      yield app.swipeTo("android.widget.Button", "//android.widget.ScrollView/android.widget.LinearLayout", "up", 30,
+        100, 700);
+      yield app.click('android.widget.Button');
+      yield app.see('Nothing special',
+        '//android.widget.TextView[@resource-id="io.selendroid.testapp:id/label_email_data"]');
+    });
+
+    it('should append field value', function*() {
+      yield app.click('~startUserRegistrationCD')
+      yield app.fillField('~email of the customer', 'Nothing special');
+      yield app.appendField('~email of the customer', 'blabla');
+      yield app.hideDeviceKeyboard('pressKey', 'Done')
+      yield app.swipeTo("android.widget.Button", "//android.widget.ScrollView/android.widget.LinearLayout", "up", 30,
+        100, 700);
+      yield app.click('android.widget.Button');
+      yield app.see('Nothing specialblabla',
+        '//android.widget.TextView[@resource-id="io.selendroid.testapp:id/label_email_data"]');
+    });
+
+  });
+
+  describe('#clearField', () => {
+    it('should clear a given element', () => {
+      return app.click('~startUserRegistrationCD')
+        .then(() => app.fillField('~email of the customer', 'Nothing special'))
+        .then(() => app.see('Nothing special', '~email of the customer'))
+        .then(() => app.clearField('~email of the customer'))
+        .then(() => app.dontSee('Nothing special', '~email of the customer'));
+    });
+  });
+
+  describe('#grabTextFrom, #grabValueFrom, #grabAttributeFrom', () => {
+    it('should grab text from page', function*() {
+      let val = yield app.grabTextFrom('~buttonTestCD');
+      assert.equal(val, "EN Button");
+    });
+
+    it('should grab attribute from element', function*() {
+      let val = yield app.grabAttributeFrom('~buttonTestCD', 'resourceId');
+      return assert.equal(val, "io.selendroid.testapp:id/buttonTest");
+    });
+
+  });
+
+  describe('#saveScreenshot', () => {
+    beforeEach(() => {
+      global.output_dir = path.join(global.codecept_dir, 'output');
+    });
+
+    it('should create a screenshot file in output dir', () => {
+      let sec = (new Date()).getUTCMilliseconds();
+      return app.saveScreenshot('screenshot_' + sec)
+        .then(() => assert.ok(fileExists(path.join(output_dir, 'screenshot_' + sec)), null, 'file does not exists'));
+    });
+  });
+
+});