codeceptjs 4.0.0-beta.2 → 4.0.0-beta.21

package/lib/helper/Appium.js

@@ -1,25 +1,27 @@
-import fs from 'fs';
-import { default as axios } from 'axios';
-import { v4 as uuidv4 } from 'uuid';
-import Webdriver from './WebDriver';
-import AssertionFailedError from '../assert/error.js';
-import { truth } from '../assert/truth';
-import recorder from '../recorder.js';
-import Locator from '../locator.js';
-import ConnectionRefused from './errors/ConnectionRefused.js';
-
-let webdriverio;
-
-const mobileRoot = '//*';
-const webRoot = 'body';
+import * as webdriverio from 'webdriverio'
+import fs from 'fs'
+import axios from 'axios'
+import { v4 as uuidv4 } from 'uuid'
+
+import Webdriver from './WebDriver.js'
+import AssertionFailedError from '../assert/error.js'
+import { truth } from '../assert/truth.js'
+import recorder from '../recorder.js'
+import Locator from '../locator.js'
+import ConnectionRefused from './errors/ConnectionRefused.js'
+import ElementNotFound from './errors/ElementNotFound.js'
+import { dontSeeElementError } from './errors/ElementAssertion.js'
+
+const mobileRoot = '//*'
+const webRoot = 'body'
 const supportedPlatform = {
   android: 'Android',
   iOS: 'iOS',
-};
+}
 
 const vendorPrefix = {
   appium: 'appium',
-};
+}
 
 /**
  *  Appium helper extends [Webdriver](http://codecept.io/helpers/WebDriver/) helper.
@@ -43,7 +45,7 @@ const vendorPrefix = {
  *
  * This helper should be configured in codecept.conf.ts or codecept.conf.js
  *
- * * `appiumV2`: set this to true if you want to run tests with AppiumV2. See more how to setup [here](https://codecept.io/mobile/#setting-up)
+ * * `appiumV2`: by default is true, set this to false if you want to run tests with AppiumV1. See more how to setup [here](https://codecept.io/mobile/#setting-up)
  * * `app`: Application path. Local path or remote URL to an .ipa or .apk file, or a .zip containing one of these. Alias to desiredCapabilities.appPackage
  * * `host`: (default: 'localhost') Appium host
  * * `port`: (default: '4723') Appium port
@@ -123,7 +125,7 @@ const vendorPrefix = {
  * {
  * helpers: {
  *   Appium: {
- *         appiumV2: true,
+ *         appiumV2: true, // By default is true, set to false if you want to run against Appium v1
  *         host: "hub-cloud.browserstack.com",
  *         port: 4444,
  *         user: process.env.BROWSERSTACK_USER,
@@ -174,19 +176,16 @@ class Appium extends Webdriver {
 
   // @ts-ignore
   constructor(config) {
-    super(config);
+    super(config)
 
-    this.isRunning = false;
-    if (config.appiumV2 === true) {
-      this.appiumV2 = true;
-    }
-    this.axios = axios.create();
+    this.isRunning = false
+    this.appiumV2 = config.appiumV2 || true
+    this.axios = axios.create()
 
-    webdriverio = require('webdriverio');
     if (!config.appiumV2) {
-      console.log('The Appium core team does not maintain Appium 1.x anymore since the 1st of January 2022. Please migrating to Appium 2.x by adding appiumV2: true to your config.');
-      console.log('More info: https://bit.ly/appium-v2-migration');
-      console.log('This Appium 1.x support will be removed in next major release.');
+      console.log('The Appium core team does not maintain Appium 1.x anymore since the 1st of January 2022. Appium 2.x is used by default.')
+      console.log('More info: https://bit.ly/appium-v2-migration')
+      console.log('This Appium 1.x support will be removed in next major release.')
     }
   }
 
@@ -203,7 +202,7 @@ class Appium extends Webdriver {
               }
             }
           }
-      `);
+      `)
     }
 
     // set defaults
@@ -224,166 +223,195 @@ class Appium extends Webdriver {
       timeouts: {
         script: 0, // ms
       },
-    };
+    }
 
     // override defaults with config
-    config = Object.assign(defaults, config);
+    config = Object.assign(defaults, config)
 
-    config.baseUrl = config.url || config.baseUrl;
+    config.baseUrl = config.url || config.baseUrl
     if (config.desiredCapabilities && Object.keys(config.desiredCapabilities).length) {
-      config.capabilities = this.appiumV2 === true ? this._convertAppiumV2Caps(config.desiredCapabilities) : config.desiredCapabilities;
+      config.capabilities = this.appiumV2 === true ? this._convertAppiumV2Caps(config.desiredCapabilities) : config.desiredCapabilities
     }
 
     if (this.appiumV2) {
-      config.capabilities[`${vendorPrefix.appium}:deviceName`] = config[`${vendorPrefix.appium}:device`] || config.capabilities[`${vendorPrefix.appium}:deviceName`];
-      config.capabilities[`${vendorPrefix.appium}:browserName`] = config[`${vendorPrefix.appium}:browser`] || config.capabilities[`${vendorPrefix.appium}:browserName`];
-      config.capabilities[`${vendorPrefix.appium}:app`] = config[`${vendorPrefix.appium}:app`] || config.capabilities[`${vendorPrefix.appium}:app`];
-      config.capabilities[`${vendorPrefix.appium}:tunnelIdentifier`] = config[`${vendorPrefix.appium}:tunnelIdentifier`] || config.capabilities[`${vendorPrefix.appium}:tunnelIdentifier`]; // Adding the code to connect to sauce labs via sauce tunnel
+      config.capabilities[`${vendorPrefix.appium}:deviceName`] = config[`${vendorPrefix.appium}:device`] || config.capabilities[`${vendorPrefix.appium}:deviceName`]
+      config.capabilities[`${vendorPrefix.appium}:browserName`] = config[`${vendorPrefix.appium}:browser`] || config.capabilities[`${vendorPrefix.appium}:browserName`]
+      config.capabilities[`${vendorPrefix.appium}:app`] = config[`${vendorPrefix.appium}:app`] || config.capabilities[`${vendorPrefix.appium}:app`]
+      config.capabilities[`${vendorPrefix.appium}:tunnelIdentifier`] = config[`${vendorPrefix.appium}:tunnelIdentifier`] || config.capabilities[`${vendorPrefix.appium}:tunnelIdentifier`] // Adding the code to connect to sauce labs via sauce tunnel
     } else {
-      config.capabilities.deviceName = config.device || config.capabilities.deviceName;
-      config.capabilities.browserName = config.browser || config.capabilities.browserName;
-      config.capabilities.app = config.app || config.capabilities.app;
-      config.capabilities.tunnelIdentifier = config.tunnelIdentifier || config.capabilities.tunnelIdentifier; // Adding the code to connect to sauce labs via sauce tunnel
+      config.capabilities.deviceName = config.device || config.capabilities.deviceName
+      config.capabilities.browserName = config.browser || config.capabilities.browserName
+      config.capabilities.app = config.app || config.capabilities.app
+      config.capabilities.tunnelIdentifier = config.tunnelIdentifier || config.capabilities.tunnelIdentifier // Adding the code to connect to sauce labs via sauce tunnel
     }
 
-    config.capabilities.platformName = config.platform || config.capabilities.platformName;
-    config.waitForTimeoutInSeconds = config.waitForTimeout / 1000; // convert to seconds
+    config.capabilities.platformName = config.platform || config.capabilities.platformName
+    config.waitForTimeoutInSeconds = config.waitForTimeout / 1000 // convert to seconds
 
     // [CodeceptJS compatible] transform host to hostname
-    config.hostname = config.host || config.hostname;
+    config.hostname = config.host || config.hostname
 
     if (!config.app && config.capabilities.browserName) {
-      this.isWeb = true;
-      this.root = webRoot;
+      this.isWeb = true
+      this.root = webRoot
     } else {
-      this.isWeb = false;
-      this.root = mobileRoot;
+      this.isWeb = false
+      this.root = mobileRoot
     }
 
-    this.platform = null;
+    this.platform = null
     if (config.capabilities[`${vendorPrefix.appium}:platformName`]) {
-      this.platform = config.capabilities[`${vendorPrefix.appium}:platformName`].toLowerCase();
+      config.capabilities[`${vendorPrefix.appium}:platformName`] = config.capabilities[`${vendorPrefix.appium}:platformName`].toLowerCase()
+      this.platform = config.capabilities[`${vendorPrefix.appium}:platformName`]
     }
 
     if (config.capabilities.platformName) {
-      this.platform = config.capabilities.platformName.toLowerCase();
+      config.capabilities.platformName = config.capabilities.platformName.toLowerCase()
+      this.platform = config.capabilities.platformName
     }
 
-    return config;
+    return config
   }
 
   _convertAppiumV2Caps(capabilities) {
-    const _convertedCaps = {};
+    const _convertedCaps = {}
     for (const [key, value] of Object.entries(capabilities)) {
       if (!key.startsWith(vendorPrefix.appium)) {
-        if (key !== 'platformName' && key !== 'bstack:options') {
-          _convertedCaps[`${vendorPrefix.appium}:${key}`] = value;
+        if (key !== 'platformName' && key !== 'bstack:options' && key !== 'sauce:options') {
+          _convertedCaps[`${vendorPrefix.appium}:${key}`] = value
         } else {
-          _convertedCaps[`${key}`] = value;
+          _convertedCaps[`${key}`] = value
         }
       } else {
-        _convertedCaps[`${key}`] = value;
+        _convertedCaps[`${key}`] = value
       }
     }
-    return _convertedCaps;
+    return _convertedCaps
   }
 
   static _config() {
-    return [{
-      name: 'app',
-      message: 'Application package. Path to file or url',
-      default: 'http://localhost',
-    }, {
-      name: 'platform',
-      message: 'Mobile Platform',
-      type: 'list',
-      choices: ['iOS', supportedPlatform.android],
-      default: supportedPlatform.android,
-    }, {
-      name: 'device',
-      message: 'Device to run tests on',
-      default: 'emulator',
-    }];
+    return [
+      {
+        name: 'app',
+        message: 'Application package. Path to file or url',
+        default: 'http://localhost',
+      },
+      {
+        name: 'platform',
+        message: 'Mobile Platform',
+        type: 'list',
+        choices: ['iOS', supportedPlatform.android],
+        default: supportedPlatform.android,
+      },
+      {
+        name: 'device',
+        message: 'Device to run tests on',
+        default: 'emulator',
+      },
+    ]
   }
 
   async _startBrowser() {
     if (this.appiumV2 === true) {
-      this.options.capabilities = this._convertAppiumV2Caps(this.options.capabilities);
-      this.options.desiredCapabilities = this._convertAppiumV2Caps(this.options.desiredCapabilities);
+      this.options.capabilities = this._convertAppiumV2Caps(this.options.capabilities)
+      this.options.desiredCapabilities = this._convertAppiumV2Caps(this.options.desiredCapabilities)
     }
 
     try {
       if (this.options.multiremote) {
-        this.browser = await webdriverio.multiremote(this.options.multiremote);
+        this.browser = await webdriverio.multiremote(this.options.multiremote)
       } else {
-        this.browser = await webdriverio.remote(this.options);
+        this.browser = await webdriverio.remote(this.options)
       }
     } catch (err) {
       if (err.toString().indexOf('ECONNREFUSED')) {
-        throw new ConnectionRefused(err);
+        throw new ConnectionRefused(err)
       }
-      throw err;
+      throw err
     }
-    this.$$ = this.browser.$$.bind(this.browser);
+    this.$$ = this.browser.$$.bind(this.browser)
 
-    this.isRunning = true;
+    this.isRunning = true
     if (this.options.timeouts && this.isWeb) {
-      await this.defineTimeout(this.options.timeouts);
+      await this.defineTimeout(this.options.timeouts)
     }
     if (this.options.windowSize === 'maximize' && !this.platform) {
-      const res = await this.browser.execute('return [screen.width, screen.height]');
+      const res = await this.browser.execute('return [screen.width, screen.height]')
       return this.browser.windowHandleSize({
         width: res.value[0],
         height: res.value[1],
-      });
+      })
     }
     if (this.options.windowSize && this.options.windowSize.indexOf('x') > 0 && !this.platform) {
-      const dimensions = this.options.windowSize.split('x');
+      const dimensions = this.options.windowSize.split('x')
       await this.browser.windowHandleSize({
         width: dimensions[0],
         height: dimensions[1],
-      });
+      })
     }
   }
 
   async _after() {
-    if (!this.isRunning) return;
+    if (!this.isRunning) return
     if (this.options.restart) {
-      this.isRunning = false;
-      return this.browser.deleteSession();
+      this.isRunning = false
+      return this.browser.deleteSession()
     }
     if (this.isWeb && !this.platform) {
-      return super._after();
+      return super._after()
     }
   }
 
   async _withinBegin(context) {
     if (this.isWeb) {
-      return super._withinBegin(context);
+      return super._withinBegin(context)
     }
     if (context === 'webview') {
-      return this.switchToWeb();
+      return this.switchToWeb()
     }
     if (typeof context === 'object') {
-      if (context.web) return this.switchToWeb(context.web);
-      if (context.webview) return this.switchToWeb(context.webview);
+      if (context.web) return this.switchToWeb(context.web)
+      if (context.webview) return this.switchToWeb(context.webview)
     }
-    return this.switchToContext(context);
+    return this.switchToContext(context)
   }
 
   _withinEnd() {
     if (this.isWeb) {
-      return super._withinEnd();
+      return super._withinEnd()
     }
-    return this.switchToNative();
+    return this.switchToNative()
   }
 
   _buildAppiumEndpoint() {
-    const {
-      protocol, port, hostname, path,
-    } = this.browser.options;
+    const { protocol, port, hostname, path } = this.browser.options
+    // Ensure path does NOT end with a slash to prevent double slashes
+    const normalizedPath = path.replace(/\/$/, '')
     // Build path to Appium REST API endpoint
-    return `${protocol}://${hostname}:${port}${path}`;
+    return `${protocol}://${hostname}:${port}${normalizedPath}/session/${this.browser.sessionId}`
+  }
+
+  /**
+   * Helper method to safely call isDisplayed() on mobile elements.
+   * Handles the case where webdriverio tries to use execute/sync which isn't supported in Appium.
+   * @private
+   */
+  async _isDisplayedSafe(element) {
+    if (this.isWeb) {
+      // For web contexts, use the normal isDisplayed
+      return element.isDisplayed()
+    }
+
+    try {
+      return await element.isDisplayed()
+    } catch (err) {
+      // If isDisplayed fails due to execute/sync not being supported in native mobile contexts,
+      // fall back to assuming the element is displayed (since we found it)
+      if (err.message && err.message.includes('Method is not implemented')) {
+        return true
+      }
+      throw err
+    }
   }
 
   /**
@@ -421,11 +449,11 @@ class Appium extends Webdriver {
    * @param {*} fn
    */
   async runOnIOS(caps, fn) {
-    if (this.platform !== 'ios') return;
-    recorder.session.start('iOS-only actions');
-    await this._runWithCaps(caps, fn);
-    await recorder.add('restore from iOS session', () => recorder.session.restore());
-    return recorder.promise();
+    if (this.platform !== 'ios') return
+    recorder.session.start('iOS-only actions')
+    this._runWithCaps(caps, fn)
+    recorder.add('restore from iOS session', () => recorder.session.restore())
+    return recorder.promise()
   }
 
   /**
@@ -463,11 +491,11 @@ class Appium extends Webdriver {
    * @param {*} fn
    */
   async runOnAndroid(caps, fn) {
-    if (this.platform !== 'android') return;
-    recorder.session.start('Android-only actions');
-    await this._runWithCaps(caps, fn);
-    await recorder.add('restore from Android session', () => recorder.session.restore());
-    return recorder.promise();
+    if (this.platform !== 'android') return
+    recorder.session.start('Android-only actions')
+    this._runWithCaps(caps, fn)
+    recorder.add('restore from Android session', () => recorder.session.restore())
+    return recorder.promise()
   }
 
   /**
@@ -480,38 +508,36 @@ class Appium extends Webdriver {
    * });
    * ```
    *
-   * @param {*} fn
    */
-  /* eslint-disable */
-  async runInWeb(fn) {
-    if (!this.isWeb) return;
-    recorder.session.start('Web-only actions');
 
-    recorder.add('restore from Web session', () => recorder.session.restore(), true);
-    return recorder.promise();
+  async runInWeb() {
+    if (!this.isWeb) return
+    recorder.session.start('Web-only actions')
+
+    recorder.add('restore from Web session', () => recorder.session.restore(), true)
+    return recorder.promise()
   }
-  /* eslint-enable */
 
-  async _runWithCaps(caps, fn) {
+  _runWithCaps(caps, fn) {
     if (typeof caps === 'object') {
       for (const key in caps) {
         // skip if capabilities do not match
         if (this.config.desiredCapabilities[key] !== caps[key]) {
-          return;
+          return
         }
       }
     }
     if (typeof caps === 'function') {
       if (!fn) {
-        fn = caps;
+        fn = caps
       } else {
         // skip if capabilities are checked inside a function
-        const enabled = caps(this.config.desiredCapabilities);
-        if (!enabled) return;
+        const enabled = caps(this.config.desiredCapabilities)
+        if (!enabled) return
       }
     }
 
-    fn();
+    fn()
   }
 
   /**
@@ -527,9 +553,9 @@ class Appium extends Webdriver {
    * Appium: support only Android
    */
   async checkIfAppIsInstalled(bundleId) {
-    onlyForApps.call(this, supportedPlatform.android);
+    onlyForApps.call(this, supportedPlatform.android)
 
-    return this.browser.isAppInstalled(bundleId);
+    return this.browser.isAppInstalled(bundleId)
   }
 
   /**
@@ -545,9 +571,9 @@ class Appium extends Webdriver {
    * Appium: support only Android
    */
   async seeAppIsInstalled(bundleId) {
-    onlyForApps.call(this, supportedPlatform.android);
-    const res = await this.browser.isAppInstalled(bundleId);
-    return truth(`app ${bundleId}`, 'to be installed').assert(res);
+    onlyForApps.call(this, supportedPlatform.android)
+    const res = await this.browser.isAppInstalled(bundleId)
+    return truth(`app ${bundleId}`, 'to be installed').assert(res)
   }
 
   /**
@@ -563,9 +589,9 @@ class Appium extends Webdriver {
    * Appium: support only Android
    */
   async seeAppIsNotInstalled(bundleId) {
-    onlyForApps.call(this, supportedPlatform.android);
-    const res = await this.browser.isAppInstalled(bundleId);
-    return truth(`app ${bundleId}`, 'not to be installed').negate(res);
+    onlyForApps.call(this, supportedPlatform.android)
+    const res = await this.browser.isAppInstalled(bundleId)
+    return truth(`app ${bundleId}`, 'not to be installed').negate(res)
   }
 
   /**
@@ -580,8 +606,8 @@ class Appium extends Webdriver {
    * Appium: support only Android
    */
   async installApp(path) {
-    onlyForApps.call(this, supportedPlatform.android);
-    return this.browser.installApp(path);
+    onlyForApps.call(this, supportedPlatform.android)
+    return this.browser.installApp(path)
   }
 
   /**
@@ -597,13 +623,13 @@ class Appium extends Webdriver {
    * @param {string} [bundleId] ID of bundle
    */
   async removeApp(appId, bundleId) {
-    onlyForApps.call(this, supportedPlatform.android);
+    onlyForApps.call(this, supportedPlatform.android)
 
     return this.axios({
       method: 'post',
-      url: `${this._buildAppiumEndpoint()}/session/${this.browser.sessionId}/appium/device/remove_app`,
+      url: `${this._buildAppiumEndpoint()}/appium/device/remove_app`,
       data: { appId, bundleId },
-    });
+    })
   }
 
   /**
@@ -615,11 +641,12 @@ class Appium extends Webdriver {
    *
    */
   async resetApp() {
-    onlyForApps.call(this);
+    onlyForApps.call(this)
+    this.isWeb = false // Reset to native context after app reset
     return this.axios({
       method: 'post',
-      url: `${this._buildAppiumEndpoint()}/session/${this.browser.sessionId}/appium/app/reset`,
-    });
+      url: `${this._buildAppiumEndpoint()}/appium/app/reset`,
+    })
   }
 
   /**
@@ -634,9 +661,9 @@ class Appium extends Webdriver {
    * Appium: support only Android
    */
   async seeCurrentActivityIs(currentActivity) {
-    onlyForApps.call(this, supportedPlatform.android);
-    const res = await this.browser.getCurrentActivity();
-    return truth('current activity', `to be ${currentActivity}`).assert(res === currentActivity);
+    onlyForApps.call(this, supportedPlatform.android)
+    const res = await this.browser.getCurrentActivity()
+    return truth('current activity', `to be ${currentActivity}`).assert(res === currentActivity)
   }
 
   /**
@@ -651,9 +678,9 @@ class Appium extends Webdriver {
    * Appium: support only Android
    */
   async seeDeviceIsLocked() {
-    onlyForApps.call(this, supportedPlatform.android);
-    const res = await this.browser.isLocked();
-    return truth('device', 'to be locked').assert(res);
+    onlyForApps.call(this, supportedPlatform.android)
+    const res = await this.browser.isLocked()
+    return truth('device', 'to be locked').assert(res)
   }
 
   /**
@@ -668,9 +695,9 @@ class Appium extends Webdriver {
    * Appium: support only Android
    */
   async seeDeviceIsUnlocked() {
-    onlyForApps.call(this, supportedPlatform.android);
-    const res = await this.browser.isLocked();
-    return truth('device', 'to be locked').negate(res);
+    onlyForApps.call(this, supportedPlatform.android)
+    const res = await this.browser.isLocked()
+    return truth('device', 'to be locked').negate(res)
   }
 
   /**
@@ -688,15 +715,15 @@ class Appium extends Webdriver {
    * Appium: support Android and iOS
    */
   async seeOrientationIs(orientation) {
-    onlyForApps.call(this);
+    onlyForApps.call(this)
 
     const res = await this.axios({
       method: 'get',
-      url: `${this._buildAppiumEndpoint()}/session/${this.browser.sessionId}/orientation`,
-    });
+      url: `${this._buildAppiumEndpoint()}/orientation`,
+    })
 
-    const currentOrientation = res.data.value;
-    return truth('orientation', `to be ${orientation}`).assert(currentOrientation === orientation);
+    const currentOrientation = res.data.value
+    return truth('orientation', `to be ${orientation}`).assert(currentOrientation === orientation)
   }
 
   /**
@@ -712,13 +739,13 @@ class Appium extends Webdriver {
    * Appium: support Android and iOS
    */
   async setOrientation(orientation) {
-    onlyForApps.call(this);
+    onlyForApps.call(this)
 
     return this.axios({
       method: 'post',
-      url: `${this._buildAppiumEndpoint()}/session/${this.browser.sessionId}/orientation`,
+      url: `${this._buildAppiumEndpoint()}/orientation`,
       data: { orientation },
-    });
+    })
   }
 
   /**
@@ -733,8 +760,8 @@ class Appium extends Webdriver {
    * Appium: support Android and iOS
    */
   async grabAllContexts() {
-    onlyForApps.call(this);
-    return this.browser.getContexts();
+    onlyForApps.call(this)
+    return this.browser.getContexts()
   }
 
   /**
@@ -749,8 +776,8 @@ class Appium extends Webdriver {
    * Appium: support Android and iOS
    */
   async grabContext() {
-    onlyForApps.call(this);
-    return this.browser.getContext();
+    onlyForApps.call(this)
+    return this.browser.getContext()
   }
 
   /**
@@ -765,8 +792,8 @@ class Appium extends Webdriver {
    * Appium: support only Android
    */
   async grabCurrentActivity() {
-    onlyForApps.call(this, supportedPlatform.android);
-    return this.browser.getCurrentActivity();
+    onlyForApps.call(this, supportedPlatform.android)
+    return this.browser.getCurrentActivity()
   }
 
   /**
@@ -783,14 +810,14 @@ class Appium extends Webdriver {
    * Appium: support only Android
    */
   async grabNetworkConnection() {
-    onlyForApps.call(this, supportedPlatform.android);
-    const res = await this.browser.getNetworkConnection();
+    onlyForApps.call(this, supportedPlatform.android)
+    const res = await this.browser.getNetworkConnection()
     return {
       value: res,
       inAirplaneMode: res.inAirplaneMode,
       hasWifi: res.hasWifi,
       hasData: res.hasData,
-    };
+    }
   }
 
   /**
@@ -805,10 +832,10 @@ class Appium extends Webdriver {
    * Appium: support Android and iOS
    */
   async grabOrientation() {
-    onlyForApps.call(this);
-    const res = await this.browser.orientation();
-    this.debugSection('Orientation', res);
-    return res;
+    onlyForApps.call(this)
+    const res = await this.browser.orientation()
+    this.debugSection('Orientation', res)
+    return res
   }
 
   /**
@@ -823,10 +850,10 @@ class Appium extends Webdriver {
    * Appium: support Android and iOS
    */
   async grabSettings() {
-    onlyForApps.call(this);
-    const res = await this.browser.getSettings();
-    this.debugSection('Settings', JSON.stringify(res));
-    return res;
+    onlyForApps.call(this)
+    const res = await this.browser.getSettings()
+    this.debugSection('Settings', JSON.stringify(res))
+    return res
   }
 
   /**
@@ -835,7 +862,7 @@ class Appium extends Webdriver {
    * @param {*} context the context to switch to
    */
   async switchToContext(context) {
-    return this.browser.switchContext(context);
+    return this.browser.switchContext(context)
   }
 
   /**
@@ -855,17 +882,17 @@ class Appium extends Webdriver {
    * @param {string} [context]
    */
   async switchToWeb(context) {
-    this.isWeb = true;
-    this.defaultContext = 'body';
+    this.isWeb = true
+    this.defaultContext = 'body'
 
-    if (context) return this.switchToContext(context);
-    const contexts = await this.grabAllContexts();
-    this.debugSection('Contexts', contexts.toString());
+    if (context) return this.switchToContext(context)
+    const contexts = await this.grabAllContexts()
+    this.debugSection('Contexts', contexts.toString())
     for (const idx in contexts) {
-      if (contexts[idx].match(/^WEBVIEW/)) return this.switchToContext(contexts[idx]);
+      if (contexts[idx].match(/^WEBVIEW/)) return this.switchToContext(contexts[idx])
     }
 
-    throw new Error('No WEBVIEW could be guessed, please specify one in params');
+    throw new Error('No WEBVIEW could be guessed, please specify one in params')
   }
 
   /**
@@ -882,11 +909,11 @@ class Appium extends Webdriver {
    * @return {Promise<void>}
    */
   async switchToNative(context = null) {
-    this.isWeb = false;
-    this.defaultContext = '//*';
+    this.isWeb = false
+    this.defaultContext = '//*'
 
-    if (context) return this.switchToContext(context);
-    return this.switchToContext('NATIVE_APP');
+    if (context) return this.switchToContext(context)
+    return this.switchToContext('NATIVE_APP')
   }
 
   /**
@@ -903,8 +930,8 @@ class Appium extends Webdriver {
    * @return {Promise<void>}
    */
   async startActivity(appPackage, appActivity) {
-    onlyForApps.call(this, supportedPlatform.android);
-    return this.browser.startActivity(appPackage, appActivity);
+    onlyForApps.call(this, supportedPlatform.android)
+    return this.browser.startActivity(appPackage, appActivity)
   }
 
   /**
@@ -929,8 +956,8 @@ class Appium extends Webdriver {
    * @return {Promise<number>}
    */
   async setNetworkConnection(value) {
-    onlyForApps.call(this, supportedPlatform.android);
-    return this.browser.setNetworkConnection(value);
+    onlyForApps.call(this, supportedPlatform.android)
+    return this.browser.setNetworkConnection(value)
   }
 
   /**
@@ -945,8 +972,8 @@ class Appium extends Webdriver {
    * Appium: support Android and iOS
    */
   async setSettings(settings) {
-    onlyForApps.call(this);
-    return this.browser.settings(settings);
+    onlyForApps.call(this)
+    return this.browser.settings(settings)
   }
 
   /**
@@ -955,21 +982,19 @@ class Appium extends Webdriver {
    * ```js
    * // taps outside to hide keyboard per default
    * I.hideDeviceKeyboard();
-   * I.hideDeviceKeyboard('tapOutside');
-   *
-   * // or by pressing key
-   * I.hideDeviceKeyboard('pressKey', 'Done');
    * ```
    *
    * Appium: support Android and iOS
    *
-   * @param {'tapOutside' | 'pressKey'} [strategy] Desired strategy to close keyboard (‘tapOutside’ or ‘pressKey’)
-   * @param {string} [key] Optional key
    */
-  async hideDeviceKeyboard(strategy, key) {
-    onlyForApps.call(this);
-    strategy = strategy || 'tapOutside';
-    return this.browser.hideKeyboard(strategy, key);
+  async hideDeviceKeyboard() {
+    onlyForApps.call(this)
+
+    return this.axios({
+      method: 'post',
+      url: `${this._buildAppiumEndpoint()}/appium/device/hide_keyboard`,
+      data: {},
+    })
   }
 
   /**
@@ -986,8 +1011,8 @@ class Appium extends Webdriver {
    * Appium: support only Android
    */
   async sendDeviceKeyEvent(keyValue) {
-    onlyForApps.call(this, supportedPlatform.android);
-    return this.browser.pressKeyCode(keyValue);
+    onlyForApps.call(this, supportedPlatform.android)
+    return this.browser.pressKeyCode(keyValue)
   }
 
   /**
@@ -1002,8 +1027,8 @@ class Appium extends Webdriver {
    * Appium: support only Android
    */
   async openNotifications() {
-    onlyForApps.call(this, supportedPlatform.android);
-    return this.browser.openNotifications();
+    onlyForApps.call(this, supportedPlatform.android)
+    return this.browser.openNotifications()
   }
 
   /**
@@ -1022,13 +1047,13 @@ class Appium extends Webdriver {
    * Appium: support Android and iOS
    */
   async makeTouchAction(locator, action) {
-    onlyForApps.call(this);
-    const element = await this.browser.$(parseLocator.call(this, locator));
+    onlyForApps.call(this)
+    const element = await this.browser.$(parseLocator.call(this, locator))
 
     return this.browser.touchAction({
       action,
       element,
-    });
+    })
   }
 
   /**
@@ -1045,7 +1070,13 @@ class Appium extends Webdriver {
    * @param {*} locator
    */
   async tap(locator) {
-    return this.makeTouchAction(locator, 'tap');
+    const { elementId } = await this.browser.$(parseLocator.call(this, locator))
+
+    return this.axios({
+      method: 'post',
+      url: `${this._buildAppiumEndpoint()}/element/${elementId}/click`,
+      data: {},
+    })
   }
 
   /**
@@ -1066,14 +1097,16 @@ class Appium extends Webdriver {
    *
    * Appium: support Android and iOS
    */
-  /* eslint-disable */
+
   async swipe(locator, xoffset, yoffset, speed = 1000) {
-    onlyForApps.call(this);
-    const res = await this.browser.$(parseLocator.call(this, locator));
+    onlyForApps.call(this)
+    const res = await this.browser.$(parseLocator.call(this, locator))
     // if (!res.length) throw new ElementNotFound(locator, 'was not found in UI');
-    return this.performSwipe(await res.getLocation(), { x: (await res.getLocation()).x + xoffset, y: (await res.getLocation()).y + yoffset });
+    return this.performSwipe(await res.getLocation(), {
+      x: (await res.getLocation()).x + xoffset,
+      y: (await res.getLocation()).y + yoffset,
+    })
   }
-  /* eslint-enable */
 
   /**
    * Perform a swipe on the screen.
@@ -1088,42 +1121,44 @@ class Appium extends Webdriver {
    * Appium: support Android and iOS
    */
   async performSwipe(from, to) {
-    await this.browser.performActions([{
-      id: uuidv4(),
-      type: 'pointer',
-      parameters: {
-        pointerType: 'touch',
-      },
-      actions: [
-        {
-          duration: 0,
-          x: from.x,
-          y: from.y,
-          type: 'pointerMove',
-          origin: 'viewport',
-        },
-        {
-          button: 1,
-          type: 'pointerDown',
-        },
-        {
-          duration: 200,
-          type: 'pause',
-        },
-        {
-          duration: 600,
-          x: to.x,
-          y: to.y,
-          type: 'pointerMove',
-          origin: 'viewport',
+    await this.browser.performActions([
+      {
+        id: uuidv4(),
+        type: 'pointer',
+        parameters: {
+          pointerType: 'touch',
         },
-        {
-          button: 1,
-          type: 'pointerUp',
-        },
-      ],
-    }]);
-    await this.browser.pause(1000);
+        actions: [
+          {
+            duration: 0,
+            x: from.x,
+            y: from.y,
+            type: 'pointerMove',
+            origin: 'viewport',
+          },
+          {
+            button: 1,
+            type: 'pointerDown',
+          },
+          {
+            duration: 200,
+            type: 'pause',
+          },
+          {
+            duration: 600,
+            x: to.x,
+            y: to.y,
+            type: 'pointerMove',
+            origin: 'viewport',
+          },
+          {
+            button: 1,
+            type: 'pointerUp',
+          },
+        ],
+      },
+    ])
+    await this.browser.pause(2000)
   }
 
   /**
@@ -1144,14 +1179,14 @@ class Appium extends Webdriver {
    * Appium: support Android and iOS
    */
   async swipeDown(locator, yoffset = 1000, speed) {
-    onlyForApps.call(this);
+    onlyForApps.call(this)
 
     if (!speed) {
-      speed = yoffset;
-      yoffset = 100;
+      speed = yoffset
+      yoffset = 100
     }
 
-    return this.swipe(parseLocator.call(this, locator), 0, yoffset, speed);
+    return this.swipe(parseLocator.call(this, locator), 0, yoffset, speed)
   }
 
   /**
@@ -1173,13 +1208,13 @@ class Appium extends Webdriver {
    * Appium: support Android and iOS
    */
   async swipeLeft(locator, xoffset = 1000, speed) {
-    onlyForApps.call(this);
+    onlyForApps.call(this)
     if (!speed) {
-      speed = xoffset;
-      xoffset = 100;
+      speed = xoffset
+      xoffset = 100
     }
 
-    return this.swipe(parseLocator.call(this, locator), -xoffset, 0, speed);
+    return this.swipe(parseLocator.call(this, locator), -xoffset, 0, speed)
   }
 
   /**
@@ -1200,13 +1235,13 @@ class Appium extends Webdriver {
    * Appium: support Android and iOS
    */
   async swipeRight(locator, xoffset = 1000, speed) {
-    onlyForApps.call(this);
+    onlyForApps.call(this)
     if (!speed) {
-      speed = xoffset;
-      xoffset = 100;
+      speed = xoffset
+      xoffset = 100
     }
 
-    return this.swipe(parseLocator.call(this, locator), xoffset, 0, speed);
+    return this.swipe(parseLocator.call(this, locator), xoffset, 0, speed)
   }
 
   /**
@@ -1227,14 +1262,14 @@ class Appium extends Webdriver {
    * Appium: support Android and iOS
    */
   async swipeUp(locator, yoffset = 1000, speed) {
-    onlyForApps.call(this);
+    onlyForApps.call(this)
 
     if (!speed) {
-      speed = yoffset;
-      yoffset = 100;
+      speed = yoffset
+      yoffset = 100
     }
 
-    return this.swipe(parseLocator.call(this, locator), 0, -yoffset, speed);
+    return this.swipe(parseLocator.call(this, locator), 0, -yoffset, speed)
   }
 
   /**
@@ -1261,55 +1296,61 @@ class Appium extends Webdriver {
    * Appium: support Android and iOS
    */
   async swipeTo(searchableLocator, scrollLocator, direction, timeout, offset, speed) {
-    onlyForApps.call(this);
-    direction = direction || 'down';
+    onlyForApps.call(this)
+    direction = direction || 'down'
     switch (direction) {
       case 'down':
-        direction = 'swipeDown';
-        break;
+        direction = 'swipeDown'
+        break
       case 'up':
-        direction = 'swipeUp';
-        break;
+        direction = 'swipeUp'
+        break
       case 'left':
-        direction = 'swipeLeft';
-        break;
+        direction = 'swipeLeft'
+        break
       case 'right':
-        direction = 'swipeRight';
-        break;
+        direction = 'swipeRight'
+        break
     }
-    timeout = timeout || this.options.waitForTimeoutInSeconds;
-
-    const errorMsg = `element ("${searchableLocator}") still not visible after ${timeout}seconds`;
-    const browser = this.browser;
-    let err = false;
-    let currentSource;
-    return browser.waitUntil(() => {
-      if (err) {
-        return new Error(`Scroll to the end and element ${searchableLocator} was not found`);
-      }
-      return browser.$$(parseLocator.call(this, searchableLocator))
-        .then(els => els.length && els[0].isDisplayed())
-        .then((res) => {
-          if (res) {
-            return true;
+    timeout = timeout || this.options.waitForTimeoutInSeconds
+
+    const errorMsg = `element ("${searchableLocator}") still not visible after ${timeout}seconds`
+    const browser = this.browser
+    let err = false
+    let currentSource
+    return browser
+      .waitUntil(
+        async () => {
+          if (err) {
+            return new Error(`Scroll to the end and element ${searchableLocator} was not found`)
           }
-          return this[direction](scrollLocator, offset, speed).getSource().then((source) => {
-            if (source === currentSource) {
-              err = true;
-            } else {
-              currentSource = source;
-              return false;
+          const els = await browser.$$(parseLocator.call(this, searchableLocator))
+          if (els.length) {
+            const displayed = await this._isDisplayedSafe(els[0])
+            if (displayed) {
+              return true
             }
-          });
-        });
-    }, timeout * 1000, errorMsg)
-      .catch((e) => {
+          }
+
+          await this[direction](scrollLocator, offset, speed)
+          const source = await this.browser.getPageSource()
+          if (source === currentSource) {
+            err = true
+          } else {
+            currentSource = source
+            return false
+          }
+        },
+        timeout * 1000,
+        errorMsg,
+      )
+      .catch(e => {
         if (e.message.indexOf('timeout') && e.type !== 'NoSuchElement') {
-          throw new AssertionFailedError({ customMessage: `Scroll to the end and element ${searchableLocator} was not found` }, '');
+          throw new AssertionFailedError({ customMessage: `Scroll to the end and element ${searchableLocator} was not found` }, '')
         } else {
-          throw e;
+          throw e
         }
-      });
+      })
   }
 
   /**
@@ -1341,8 +1382,8 @@ class Appium extends Webdriver {
    * @param {Array} actions Array of touch actions
    */
   async touchPerform(actions) {
-    onlyForApps.call(this);
-    return this.browser.touchPerform(actions);
+    onlyForApps.call(this)
+    return this.browser.touchPerform(actions)
   }
 
   /**
@@ -1361,13 +1402,15 @@ class Appium extends Webdriver {
    * Appium: support Android and iOS
    */
   async pullFile(path, dest) {
-    onlyForApps.call(this);
-    return this.browser.pullFile(path).then(res => fs.writeFile(dest, Buffer.from(res, 'base64'), (err) => {
-      if (err) {
-        return false;
-      }
-      return true;
-    }));
+    onlyForApps.call(this)
+    return this.browser.pullFile(path).then(res =>
+      fs.writeFile(dest, Buffer.from(res, 'base64'), err => {
+        if (err) {
+          return false
+        }
+        return true
+      }),
+    )
   }
 
   /**
@@ -1382,8 +1425,8 @@ class Appium extends Webdriver {
    * Appium: support only iOS
    */
   async shakeDevice() {
-    onlyForApps.call(this, 'iOS');
-    return this.browser.shake();
+    onlyForApps.call(this, 'iOS')
+    return this.browser.shake()
   }
 
   /**
@@ -1400,8 +1443,8 @@ class Appium extends Webdriver {
    * Appium: support only iOS
    */
   async rotate(x, y, duration, radius, rotation, touchCount) {
-    onlyForApps.call(this, 'iOS');
-    return this.browser.rotate(x, y, duration, radius, rotation, touchCount);
+    onlyForApps.call(this, 'iOS')
+    return this.browser.rotate(x, y, duration, radius, rotation, touchCount)
   }
 
   /**
@@ -1414,8 +1457,8 @@ class Appium extends Webdriver {
    * Appium: support only iOS
    */
   async setImmediateValue(id, value) {
-    onlyForApps.call(this, 'iOS');
-    return this.browser.setImmediateValue(id, value);
+    onlyForApps.call(this, 'iOS')
+    return this.browser.setImmediateValue(id, value)
   }
 
   /**
@@ -1433,9 +1476,9 @@ class Appium extends Webdriver {
    * TODO: not tested
    */
   async simulateTouchId(match) {
-    onlyForApps.call(this, 'iOS');
-    match = match || true;
-    return this.browser.touchId(match);
+    onlyForApps.call(this, 'iOS')
+    match = match || true
+    return this.browser.touchId(match)
   }
 
   /**
@@ -1450,8 +1493,8 @@ class Appium extends Webdriver {
    * Appium: support both Android and iOS
    */
   async closeApp() {
-    onlyForApps.call(this);
-    return this.browser.closeApp();
+    onlyForApps.call(this)
+    return this.browser.closeApp()
   }
 
   /**
@@ -1459,8 +1502,8 @@ class Appium extends Webdriver {
    *
    */
   async appendField(field, value) {
-    if (this.isWeb) return super.appendField(field, value);
-    return super.appendField(parseLocator.call(this, field), value);
+    if (this.isWeb) return super.appendField(field, value)
+    return super.appendField(parseLocator.call(this, field), value)
   }
 
   /**
@@ -1468,8 +1511,8 @@ class Appium extends Webdriver {
    *
    */
   async checkOption(field) {
-    if (this.isWeb) return super.checkOption(field);
-    return super.checkOption(parseLocator.call(this, field));
+    if (this.isWeb) return super.checkOption(field)
+    return super.checkOption(parseLocator.call(this, field))
   }
 
   /**
@@ -1477,8 +1520,15 @@ class Appium extends Webdriver {
    *
    */
   async click(locator, context) {
-    if (this.isWeb) return super.click(locator, context);
-    return super.click(parseLocator.call(this, locator), parseLocator.call(this, context));
+    if (this.isWeb) return super.click(locator, context)
+
+    const { elementId } = await this.browser.$(parseLocator.call(this, locator), parseLocator.call(this, context))
+
+    return this.axios({
+      method: 'post',
+      url: `${this._buildAppiumEndpoint()}/element/${elementId}/click`,
+      data: {},
+    })
   }
 
   /**
@@ -1486,16 +1536,35 @@ class Appium extends Webdriver {
    *
    */
   async dontSeeCheckboxIsChecked(field) {
-    if (this.isWeb) return super.dontSeeCheckboxIsChecked(field);
-    return super.dontSeeCheckboxIsChecked(parseLocator.call(this, field));
+    if (this.isWeb) return super.dontSeeCheckboxIsChecked(field)
+    return super.dontSeeCheckboxIsChecked(parseLocator.call(this, field))
   }
 
   /**
    * {{> dontSeeElement }}
    */
   async dontSeeElement(locator) {
-    if (this.isWeb) return super.dontSeeElement(locator);
-    return super.dontSeeElement(parseLocator.call(this, locator));
+    if (this.isWeb) return super.dontSeeElement(locator)
+
+    // For mobile native apps, use safe isDisplayed wrapper
+    const parsedLocator = parseLocator.call(this, locator)
+    const res = await this._locate(parsedLocator, false)
+
+    if (!res || res.length === 0) {
+      return truth(`elements of ${Locator.build(parsedLocator)}`, 'to be seen').negate(false)
+    }
+
+    const selected = []
+    for (const el of res) {
+      const displayed = await this._isDisplayedSafe(el)
+      if (displayed) selected.push(true)
+    }
+
+    try {
+      return truth(`elements of ${Locator.build(parsedLocator)}`, 'to be seen').negate(selected)
+    } catch (err) {
+      throw err
+    }
   }
 
   /**
@@ -1503,17 +1572,17 @@ class Appium extends Webdriver {
    *
    */
   async dontSeeInField(field, value) {
-    const _value = (typeof value === 'boolean') ? value : value.toString();
-    if (this.isWeb) return super.dontSeeInField(field, _value);
-    return super.dontSeeInField(parseLocator.call(this, field), _value);
+    const _value = typeof value === 'boolean' ? value : value.toString()
+    if (this.isWeb) return super.dontSeeInField(field, _value)
+    return super.dontSeeInField(parseLocator.call(this, field), _value)
   }
 
   /**
    * {{> dontSee }}
    */
   async dontSee(text, context = null) {
-    if (this.isWeb) return super.dontSee(text, context);
-    return super.dontSee(text, parseLocator.call(this, context));
+    if (this.isWeb) return super.dontSee(text, context)
+    return super.dontSee(text, parseLocator.call(this, context))
   }
 
   /**
@@ -1521,9 +1590,9 @@ class Appium extends Webdriver {
    *
    */
   async fillField(field, value) {
-    value = value.toString();
-    if (this.isWeb) return super.fillField(field, value);
-    return super.fillField(parseLocator.call(this, field), value);
+    value = value.toString()
+    if (this.isWeb) return super.fillField(field, value)
+    return super.fillField(parseLocator.call(this, field), value)
   }
 
   /**
@@ -1531,8 +1600,8 @@ class Appium extends Webdriver {
    *
    */
   async grabTextFromAll(locator) {
-    if (this.isWeb) return super.grabTextFromAll(locator);
-    return super.grabTextFromAll(parseLocator.call(this, locator));
+    if (this.isWeb) return super.grabTextFromAll(locator)
+    return super.grabTextFromAll(parseLocator.call(this, locator))
   }
 
   /**
@@ -1540,16 +1609,27 @@ class Appium extends Webdriver {
    *
    */
   async grabTextFrom(locator) {
-    if (this.isWeb) return super.grabTextFrom(locator);
-    return super.grabTextFrom(parseLocator.call(this, locator));
+    if (this.isWeb) return super.grabTextFrom(locator)
+    return super.grabTextFrom(parseLocator.call(this, locator))
   }
 
   /**
    * {{> grabNumberOfVisibleElements }}
    */
   async grabNumberOfVisibleElements(locator) {
-    if (this.isWeb) return super.grabNumberOfVisibleElements(locator);
-    return super.grabNumberOfVisibleElements(parseLocator.call(this, locator));
+    if (this.isWeb) return super.grabNumberOfVisibleElements(locator)
+
+    // For mobile native apps, use safe isDisplayed wrapper
+    const parsedLocator = parseLocator.call(this, locator)
+    const res = await this._locate(parsedLocator)
+
+    const selected = []
+    for (const el of res) {
+      const displayed = await this._isDisplayedSafe(el)
+      if (displayed) selected.push(true)
+    }
+
+    return selected.length
   }
 
   /**
@@ -1558,8 +1638,8 @@ class Appium extends Webdriver {
    * {{> grabAttributeFrom }}
    */
   async grabAttributeFrom(locator, attr) {
-    if (this.isWeb) return super.grabAttributeFrom(locator, attr);
-    return super.grabAttributeFrom(parseLocator.call(this, locator), attr);
+    if (this.isWeb) return super.grabAttributeFrom(locator, attr)
+    return super.grabAttributeFrom(parseLocator.call(this, locator), attr)
   }
 
   /**
@@ -1567,8 +1647,8 @@ class Appium extends Webdriver {
    * {{> grabAttributeFromAll }}
    */
   async grabAttributeFromAll(locator, attr) {
-    if (this.isWeb) return super.grabAttributeFromAll(locator, attr);
-    return super.grabAttributeFromAll(parseLocator.call(this, locator), attr);
+    if (this.isWeb) return super.grabAttributeFromAll(locator, attr)
+    return super.grabAttributeFromAll(parseLocator.call(this, locator), attr)
   }
 
   /**
@@ -1576,8 +1656,8 @@ class Appium extends Webdriver {
    *
    */
   async grabValueFromAll(locator) {
-    if (this.isWeb) return super.grabValueFromAll(locator);
-    return super.grabValueFromAll(parseLocator.call(this, locator));
+    if (this.isWeb) return super.grabValueFromAll(locator)
+    return super.grabValueFromAll(parseLocator.call(this, locator))
   }
 
   /**
@@ -1585,8 +1665,8 @@ class Appium extends Webdriver {
    *
    */
   async grabValueFrom(locator) {
-    if (this.isWeb) return super.grabValueFrom(locator);
-    return super.grabValueFrom(parseLocator.call(this, locator));
+    if (this.isWeb) return super.grabValueFrom(locator)
+    return super.grabValueFrom(parseLocator.call(this, locator))
   }
 
   /**
@@ -1601,7 +1681,7 @@ class Appium extends Webdriver {
    * @return {Promise<void>}
    */
   async saveScreenshot(fileName) {
-    return super.saveScreenshot(fileName, false);
+    return super.saveScreenshot(fileName, false)
   }
 
   /**
@@ -1610,7 +1690,7 @@ class Appium extends Webdriver {
    * Supported only for web testing
    */
   async scrollIntoView(locator, scrollIntoViewOptions) {
-    if (this.isWeb) return super.scrollIntoView(locator, scrollIntoViewOptions);
+    if (this.isWeb) return super.scrollIntoView(locator, scrollIntoViewOptions)
   }
 
   /**
@@ -1618,8 +1698,8 @@ class Appium extends Webdriver {
    *
    */
   async seeCheckboxIsChecked(field) {
-    if (this.isWeb) return super.seeCheckboxIsChecked(field);
-    return super.seeCheckboxIsChecked(parseLocator.call(this, field));
+    if (this.isWeb) return super.seeCheckboxIsChecked(field)
+    return super.seeCheckboxIsChecked(parseLocator.call(this, field))
   }
 
   /**
@@ -1627,8 +1707,27 @@ class Appium extends Webdriver {
    *
    */
   async seeElement(locator) {
-    if (this.isWeb) return super.seeElement(locator);
-    return super.seeElement(parseLocator.call(this, locator));
+    if (this.isWeb) return super.seeElement(locator)
+
+    // For mobile native apps, use safe isDisplayed wrapper
+    const parsedLocator = parseLocator.call(this, locator)
+    const res = await this._locate(parsedLocator, true)
+
+    if (!res || res.length === 0) {
+      throw new ElementNotFound(parsedLocator)
+    }
+
+    const selected = []
+    for (const el of res) {
+      const displayed = await this._isDisplayedSafe(el)
+      if (displayed) selected.push(true)
+    }
+
+    try {
+      return truth(`elements of ${Locator.build(parsedLocator)}`, 'to be seen').assert(selected)
+    } catch (e) {
+      dontSeeElementError(parsedLocator)
+    }
   }
 
   /**
@@ -1636,9 +1735,9 @@ class Appium extends Webdriver {
    *
    */
   async seeInField(field, value) {
-    const _value = (typeof value === 'boolean') ? value : value.toString();
-    if (this.isWeb) return super.seeInField(field, _value);
-    return super.seeInField(parseLocator.call(this, field), _value);
+    const _value = typeof value === 'boolean' ? value : value.toString()
+    if (this.isWeb) return super.seeInField(field, _value)
+    return super.seeInField(parseLocator.call(this, field), _value)
   }
 
   /**
@@ -1646,8 +1745,8 @@ class Appium extends Webdriver {
    *
    */
   async see(text, context) {
-    if (this.isWeb) return super.see(text, context);
-    return super.see(text, parseLocator.call(this, context));
+    if (this.isWeb) return super.see(text, context)
+    return super.see(text, parseLocator.call(this, context))
   }
 
   /**
@@ -1656,8 +1755,8 @@ class Appium extends Webdriver {
    * Supported only for web testing
    */
   async selectOption(select, option) {
-    if (this.isWeb) return super.selectOption(select, option);
-    throw new Error('Should be used only in Web context. In native context use \'click\' method instead');
+    if (this.isWeb) return super.selectOption(select, option)
+    throw new Error("Should be used only in Web context. In native context use 'click' method instead")
   }
 
   /**
@@ -1665,8 +1764,8 @@ class Appium extends Webdriver {
    *
    */
   async waitForElement(locator, sec = null) {
-    if (this.isWeb) return super.waitForElement(locator, sec);
-    return super.waitForElement(parseLocator.call(this, locator), sec);
+    if (this.isWeb) return super.waitForElement(locator, sec)
+    return super.waitForElement(parseLocator.call(this, locator), sec)
   }
 
   /**
@@ -1674,8 +1773,30 @@ class Appium extends Webdriver {
    *
    */
   async waitForVisible(locator, sec = null) {
-    if (this.isWeb) return super.waitForVisible(locator, sec);
-    return super.waitForVisible(parseLocator.call(this, locator), sec);
+    if (this.isWeb) return super.waitForVisible(locator, sec)
+
+    // For mobile native apps, use safe isDisplayed wrapper
+    const parsedLocator = parseLocator.call(this, locator)
+    const aSec = sec || this.options.waitForTimeoutInSeconds
+
+    return this.browser.waitUntil(
+      async () => {
+        const res = await this._res(parsedLocator)
+        if (!res || res.length === 0) return false
+
+        const selected = []
+        for (const el of res) {
+          const displayed = await this._isDisplayedSafe(el)
+          if (displayed) selected.push(true)
+        }
+
+        return selected.length > 0
+      },
+      {
+        timeout: aSec * 1000,
+        timeoutMsg: `element (${Locator.build(parsedLocator)}) still not visible after ${aSec} sec`,
+      },
+    )
   }
 
   /**
@@ -1683,8 +1804,27 @@ class Appium extends Webdriver {
    *
    */
   async waitForInvisible(locator, sec = null) {
-    if (this.isWeb) return super.waitForInvisible(locator, sec);
-    return super.waitForInvisible(parseLocator.call(this, locator), sec);
+    if (this.isWeb) return super.waitForInvisible(locator, sec)
+
+    // For mobile native apps, use safe isDisplayed wrapper
+    const parsedLocator = parseLocator.call(this, locator)
+    const aSec = sec || this.options.waitForTimeoutInSeconds
+
+    return this.browser.waitUntil(
+      async () => {
+        const res = await this._res(parsedLocator)
+        if (!res || res.length === 0) return true
+
+        const selected = []
+        for (const el of res) {
+          const displayed = await this._isDisplayedSafe(el)
+          if (displayed) selected.push(true)
+        }
+
+        return selected.length === 0
+      },
+      { timeout: aSec * 1000, timeoutMsg: `element (${Locator.build(parsedLocator)}) still visible after ${aSec} sec` },
+    )
   }
 
   /**
@@ -1692,74 +1832,72 @@ class Appium extends Webdriver {
    *
    */
   async waitForText(text, sec = null, context = null) {
-    if (this.isWeb) return super.waitForText(text, sec, context);
-    return super.waitForText(text, sec, parseLocator.call(this, context));
+    if (this.isWeb) return super.waitForText(text, sec, context)
+    return super.waitForText(text, sec, parseLocator.call(this, context))
   }
 }
 
 function parseLocator(locator) {
-  if (!locator) return null;
+  if (!locator) return null
 
   if (typeof locator === 'object') {
     if (locator.web && this.isWeb) {
-      return parseLocator.call(this, locator.web);
+      return parseLocator.call(this, locator.web)
     }
 
     if (locator.android && this.platform === 'android') {
       if (typeof locator.android === 'string') {
-        return parseLocator.call(this, locator.android);
+        return parseLocator.call(this, locator.android)
       }
       // The locator is an Android DataMatcher or ViewMatcher locator so return as is
-      return locator.android;
+      return locator.android
     }
 
     if (locator.ios && this.platform === 'ios') {
-      return parseLocator.call(this, locator.ios);
+      return parseLocator.call(this, locator.ios)
     }
   }
 
   if (typeof locator === 'string') {
-    if (locator[0] === '~') return locator;
-    if (locator.substr(0, 2) === '//') return locator;
+    if (locator[0] === '~') return locator
+    if (locator.substr(0, 2) === '//') return locator
     if (locator[0] === '#' && !this.isWeb) {
       // hook before webdriverio supports native # locators
-      return parseLocator.call(this, { id: locator.slice(1) });
+      return parseLocator.call(this, { id: locator.slice(1) })
     }
 
     if (this.platform === 'android' && !this.isWeb) {
-      const isNativeLocator = /^\-?android=?/.exec(locator);
-      return isNativeLocator
-        ? locator
-        : `android=new UiSelector().text("${locator}")`;
+      const isNativeLocator = /^\-?android=?/.exec(locator)
+      return isNativeLocator ? locator : `android=new UiSelector().text("${locator}")`
     }
   }
 
-  locator = new Locator(locator, 'xpath');
-  if (locator.type === 'css' && !this.isWeb) throw new Error('Unable to use css locators in apps. Locator strategies for this request: xpath, id, class name or accessibility id');
-  if (locator.type === 'name' && !this.isWeb) throw new Error("Can't locate element by name in Native context. Use either ID, class name or accessibility id");
-  if (locator.type === 'id' && !this.isWeb && this.platform === 'android') return `//*[@resource-id='${locator.value}']`;
-  return locator.simplify();
+  locator = new Locator(locator, 'xpath')
+  if (locator.type === 'css' && !this.isWeb) throw new Error('Unable to use css locators in apps. Locator strategies for this request: xpath, id, class name or accessibility id')
+  if (locator.type === 'name' && !this.isWeb) throw new Error("Can't locate element by name in Native context. Use either ID, class name or accessibility id")
+  if (locator.type === 'id' && !this.isWeb && this.platform === 'android') return `//*[@resource-id='${locator.value}']`
+  return locator.simplify()
 }
 
 // in the end of a file
 function onlyForApps(expectedPlatform) {
-  const stack = new Error().stack || '';
-  const re = /Appium.(\w+)/g;
-  const caller = stack.split('\n')[2].trim();
-  const m = re.exec(caller);
+  const stack = new Error().stack || ''
+  const re = /Appium.(\w+)/g
+  const caller = stack.split('\n')[2].trim()
+  const m = re.exec(caller)
 
   if (!m) {
-    throw new Error(`Invalid caller ${caller}`);
+    throw new Error(`Invalid caller ${caller}`)
   }
 
-  const callerName = m[1] || m[2];
+  const callerName = m[1] || m[2]
   if (!expectedPlatform) {
     if (!this.platform) {
-      throw new Error(`${callerName} method can be used only with apps`);
+      throw new Error(`${callerName} method can be used only with apps`)
     }
   } else if (this.platform !== expectedPlatform.toLowerCase()) {
-    throw new Error(`${callerName} method can be used only with ${expectedPlatform} apps`);
+    throw new Error(`${callerName} method can be used only with ${expectedPlatform} apps`)
   }
 }
 
-export default Appium;
+export default Appium