appium-android-driver 7.8.2 → 8.0.0

package/lib/commands/network.js

@@ -1,4 +1,3 @@
-import {mixin} from './mixins';
 import _ from 'lodash';
 import {errors} from 'appium/driver';
 import {util} from 'appium/support';
@@ -7,12 +6,6 @@ import B from 'bluebird';
 const AIRPLANE_MODE_MASK = 0b001;
 const WIFI_MASK = 0b010;
 const DATA_MASK = 0b100;
-// The value close to zero, but not zero, is needed
-// to trick JSON generation and send a float value instead of an integer,
-// This allows strictly-typed clients, like Java, to properly
-// parse it. Otherwise float 0.0 is always represented as integer 0 in JS.
-// The value must not be greater than DBL_EPSILON (https://opensource.apple.com/source/Libc/Libc-498/include/float.h)
-const GEO_EPSILON = Number.MIN_VALUE;
 const WIFI_KEY_NAME = 'wifi';
 const DATA_KEY_NAME = 'data';
 const AIRPLANE_MODE_KEY_NAME = 'airplaneMode';
@@ -23,239 +16,232 @@ const SUPPORTED_SERVICE_NAMES = /** @type {const} */ ([
 ]);
 
 /**
- * @type {import('./mixins').NetworkMixin & ThisType<import('../driver').AndroidDriver>}
- * @satisfies {import('@appium/types').ExternalDriver}
+ * @this {import('../driver').AndroidDriver}
+ * @returns {Promise<number>}
  */
-const NetworkMixin = {
-  async getNetworkConnection() {
-    this.log.info('Getting network connection');
-    let airplaneModeOn = await this.adb.isAirplaneModeOn();
-    let connection = airplaneModeOn ? AIRPLANE_MODE_MASK : 0;
+export async function getNetworkConnection() {
+  this.log.info('Getting network connection');
+  let airplaneModeOn = await this.adb.isAirplaneModeOn();
+  let connection = airplaneModeOn ? AIRPLANE_MODE_MASK : 0;
+
+  // no need to check anything else if we are in airplane mode
+  if (!airplaneModeOn) {
+    let wifiOn = await this.isWifiOn();
+    connection |= wifiOn ? WIFI_MASK : 0;
+    let dataOn = await this.adb.isDataOn();
+    connection |= dataOn ? DATA_MASK : 0;
+  }
+
+  return connection;
+}
 
-    // no need to check anything else if we are in airplane mode
-    if (!airplaneModeOn) {
-      let wifiOn = await this.isWifiOn();
-      connection |= wifiOn ? WIFI_MASK : 0;
-      let dataOn = await this.adb.isDataOn();
-      connection |= dataOn ? DATA_MASK : 0;
-    }
-
-    return connection;
-  },
-
-  async isWifiOn() {
-    return await this.adb.isWifiOn();
-  },
-
-  async mobileSetConnectivity(opts = {}) {
-    const {wifi, data, airplaneMode} = opts;
-    if (_.every([wifi, data, airplaneMode], _.isUndefined)) {
-      throw new errors.InvalidArgumentError(
-        `Either one of ${JSON.stringify(SUPPORTED_SERVICE_NAMES)} options must be provided`
-      );
-    }
-
-    const currentState = await this.mobileGetConnectivity({
-      services: /** @type {import('./types').ServiceType[]} */ ([
-        ...(_.isUndefined(wifi) ? [] : [WIFI_KEY_NAME]),
-        ...(_.isUndefined(data) ? [] : [DATA_KEY_NAME]),
-        ...(_.isUndefined(airplaneMode) ? [] : [AIRPLANE_MODE_KEY_NAME]),
-      ]),
-    });
-    /** @type {(Promise<any>|(() => Promise<any>))[]} */
-    const setters = [];
-    if (!_.isUndefined(wifi) && currentState.wifi !== Boolean(wifi)) {
-      setters.push(this.setWifiState(wifi));
-    }
-    if (!_.isUndefined(data) && currentState.data !== Boolean(data)) {
-      setters.push(this.setDataState(data));
-    }
-    if (!_.isUndefined(airplaneMode) && currentState.airplaneMode !== Boolean(airplaneMode)) {
-      setters.push(async () => {
-        await this.adb.setAirplaneMode(airplaneMode);
-        if ((await this.adb.getApiLevel()) < 30) {
-          await this.adb.broadcastAirplaneMode(airplaneMode);
-        }
-      });
-    }
-    if (!_.isEmpty(setters)) {
-      await B.all(setters);
-    }
-  },
-
-  async mobileGetConnectivity(opts = {}) {
-    let {services = SUPPORTED_SERVICE_NAMES} = opts;
-    const svcs = _.castArray(services);
-    const unsupportedServices = _.difference(services, SUPPORTED_SERVICE_NAMES);
-    if (!_.isEmpty(unsupportedServices)) {
-      throw new errors.InvalidArgumentError(
-        `${util.pluralize(
-          'Service name',
-          unsupportedServices.length,
-          false
-        )} ${unsupportedServices} ` +
-          `${
-            unsupportedServices.length === 1 ? 'is' : 'are'
-          } not known. Only the following services are ` +
-          `suported: ${SUPPORTED_SERVICE_NAMES}`
-      );
-    }
-
-    const statePromises = {
-      wifi: B.resolve(svcs.includes(WIFI_KEY_NAME) ? this.adb.isWifiOn() : undefined),
-      data: B.resolve(svcs.includes(DATA_KEY_NAME) ? this.adb.isDataOn() : undefined),
-      airplaneMode: B.resolve(
-        svcs.includes(AIRPLANE_MODE_KEY_NAME) ? this.adb.isAirplaneModeOn() : undefined
-      ),
-    };
-    await B.all(_.values(statePromises));
-    return {
-      wifi: Boolean(statePromises.wifi.value()),
-      data: Boolean(statePromises.data.value()),
-      airplaneMode: Boolean(statePromises.airplaneMode.value()),
-    };
-  },
-
-  async setNetworkConnection(type) {
-    this.log.info('Setting network connection');
-    // decode the input
-    const shouldEnableAirplaneMode = (type & AIRPLANE_MODE_MASK) !== 0;
-    const shouldEnableWifi = (type & WIFI_MASK) !== 0;
-    const shouldEnableDataConnection = (type & DATA_MASK) !== 0;
-
-    const currentState = await this.getNetworkConnection();
-    const isAirplaneModeEnabled = (currentState & AIRPLANE_MODE_MASK) !== 0;
-    const isWiFiEnabled = (currentState & WIFI_MASK) !== 0;
-    const isDataEnabled = (currentState & DATA_MASK) !== 0;
+/**
+ * @this {import('../driver').AndroidDriver}
+ * @returns {Promise<boolean>}
+ */
+export async function isWifiOn() {
+  return await this.adb.isWifiOn();
+}
 
-    if (shouldEnableAirplaneMode !== isAirplaneModeEnabled) {
-      await this.adb.setAirplaneMode(shouldEnableAirplaneMode);
+/**
+ * @since Android 12 (only real devices, emulators work in all APIs)
+ * @this {import('../driver').AndroidDriver}
+ * @param {import('./types').SetConnectivityOpts} [opts={}]
+ * @returns {Promise<void>}
+ */
+export async function mobileSetConnectivity(opts = {}) {
+  const {wifi, data, airplaneMode} = opts;
+  if (_.every([wifi, data, airplaneMode], _.isUndefined)) {
+    throw new errors.InvalidArgumentError(
+      `Either one of ${JSON.stringify(SUPPORTED_SERVICE_NAMES)} options must be provided`,
+    );
+  }
+
+  const currentState = await this.mobileGetConnectivity({
+    services: /** @type {import('./types').ServiceType[]} */ ([
+      ...(_.isUndefined(wifi) ? [] : [WIFI_KEY_NAME]),
+      ...(_.isUndefined(data) ? [] : [DATA_KEY_NAME]),
+      ...(_.isUndefined(airplaneMode) ? [] : [AIRPLANE_MODE_KEY_NAME]),
+    ]),
+  });
+  /** @type {(Promise<any>|(() => Promise<any>))[]} */
+  const setters = [];
+  if (!_.isUndefined(wifi) && currentState.wifi !== Boolean(wifi)) {
+    setters.push(this.setWifiState(wifi));
+  }
+  if (!_.isUndefined(data) && currentState.data !== Boolean(data)) {
+    setters.push(this.setDataState(data));
+  }
+  if (!_.isUndefined(airplaneMode) && currentState.airplaneMode !== Boolean(airplaneMode)) {
+    setters.push(async () => {
+      await this.adb.setAirplaneMode(airplaneMode);
       if ((await this.adb.getApiLevel()) < 30) {
-        await this.adb.broadcastAirplaneMode(shouldEnableAirplaneMode);
+        await this.adb.broadcastAirplaneMode(airplaneMode);
       }
-    } else {
-      this.log.info(
-        `Not changing airplane mode, since it is already ${
-          shouldEnableAirplaneMode ? 'enabled' : 'disabled'
-        }`
-      );
-    }
-
-    if (shouldEnableWifi === isWiFiEnabled && shouldEnableDataConnection === isDataEnabled) {
-      this.log.info(
-        'Not changing data connection/Wi-Fi states, since they are already set to expected values'
-      );
-      if (await this.adb.isAirplaneModeOn()) {
-        return AIRPLANE_MODE_MASK | currentState;
-      }
-      return ~AIRPLANE_MODE_MASK & currentState;
-    }
-
-    if (shouldEnableWifi !== isWiFiEnabled) {
-      await this.setWifiState(shouldEnableWifi);
-    } else {
-      this.log.info(
-        `Not changing Wi-Fi state, since it is already ` +
-          `${shouldEnableWifi ? 'enabled' : 'disabled'}`
-      );
-    }
-
-    if (shouldEnableAirplaneMode) {
-      this.log.info('Not changing data connection state, because airplane mode is enabled');
-    } else if (shouldEnableDataConnection === isDataEnabled) {
-      this.log.info(
-        `Not changing data connection state, since it is already ` +
-          `${shouldEnableDataConnection ? 'enabled' : 'disabled'}`
-      );
-    } else {
-      await this.setDataState(shouldEnableDataConnection);
-    }
-
-    return await this.getNetworkConnection();
-  },
-
-  async setWifiState(isOn) {
-    await this.settingsApp.setWifiState(isOn, this.isEmulator());
-  },
-
-  async setDataState(isOn) {
-    await this.settingsApp.setDataState(isOn, this.isEmulator());
-  },
-
-  async toggleData() {
-    const isOn = await this.adb.isDataOn();
-    this.log.info(`Turning network data ${!isOn ? 'on' : 'off'}`);
-    await this.setDataState(!isOn);
-  },
+    });
+  }
+  if (!_.isEmpty(setters)) {
+    await B.all(setters);
+  }
+}
 
-  async toggleWiFi() {
-    const isOn = await this.adb.isWifiOn();
-    this.log.info(`Turning WiFi ${!isOn ? 'on' : 'off'}`);
-    await this.setWifiState(!isOn);
-  },
+/**
+ * @this {import('../driver').AndroidDriver}
+ * @param {import('./types').GetConnectivityOpts} [opts={}]
+ * @returns {Promise<import('./types').GetConnectivityResult>}
+ */
+export async function mobileGetConnectivity(opts = {}) {
+  let {services = SUPPORTED_SERVICE_NAMES} = opts;
+  const svcs = _.castArray(services);
+  const unsupportedServices = _.difference(services, SUPPORTED_SERVICE_NAMES);
+  if (!_.isEmpty(unsupportedServices)) {
+    throw new errors.InvalidArgumentError(
+      `${util.pluralize(
+        'Service name',
+        unsupportedServices.length,
+        false,
+      )} ${unsupportedServices} ` +
+        `${
+          unsupportedServices.length === 1 ? 'is' : 'are'
+        } not known. Only the following services are ` +
+        `suported: ${SUPPORTED_SERVICE_NAMES}`,
+    );
+  }
+
+  const statePromises = {
+    wifi: B.resolve(svcs.includes(WIFI_KEY_NAME) ? this.adb.isWifiOn() : undefined),
+    data: B.resolve(svcs.includes(DATA_KEY_NAME) ? this.adb.isDataOn() : undefined),
+    airplaneMode: B.resolve(
+      svcs.includes(AIRPLANE_MODE_KEY_NAME) ? this.adb.isAirplaneModeOn() : undefined,
+    ),
+  };
+  await B.all(_.values(statePromises));
+  return {
+    wifi: Boolean(statePromises.wifi.value()),
+    data: Boolean(statePromises.data.value()),
+    airplaneMode: Boolean(statePromises.airplaneMode.value()),
+  };
+}
 
-  async toggleFlightMode() {
-    /*
-     * TODO: Implement isRealDevice(). This method fails on
-     * real devices, it should throw a NotYetImplementedError
-     */
-    let flightMode = !(await this.adb.isAirplaneModeOn());
-    this.log.info(`Turning flight mode ${flightMode ? 'on' : 'off'}`);
-    await this.adb.setAirplaneMode(flightMode);
+/**
+ * @since Android 12 (only real devices, emulators work in all APIs)
+ * @this {import('../driver').AndroidDriver}
+ * @param {number} type
+ * @returns {Promise<number>}
+ */
+export async function setNetworkConnection(type) {
+  this.log.info('Setting network connection');
+  // decode the input
+  const shouldEnableAirplaneMode = (type & AIRPLANE_MODE_MASK) !== 0;
+  const shouldEnableWifi = (type & WIFI_MASK) !== 0;
+  const shouldEnableDataConnection = (type & DATA_MASK) !== 0;
+
+  const currentState = await this.getNetworkConnection();
+  const isAirplaneModeEnabled = (currentState & AIRPLANE_MODE_MASK) !== 0;
+  const isWiFiEnabled = (currentState & WIFI_MASK) !== 0;
+  const isDataEnabled = (currentState & DATA_MASK) !== 0;
+
+  if (shouldEnableAirplaneMode !== isAirplaneModeEnabled) {
+    await this.adb.setAirplaneMode(shouldEnableAirplaneMode);
     if ((await this.adb.getApiLevel()) < 30) {
-      await this.adb.broadcastAirplaneMode(flightMode);
+      await this.adb.broadcastAirplaneMode(shouldEnableAirplaneMode);
     }
-  },
+  } else {
+    this.log.info(
+      `Not changing airplane mode, since it is already ${
+        shouldEnableAirplaneMode ? 'enabled' : 'disabled'
+      }`,
+    );
+  }
 
-  async setGeoLocation(location) {
-    await this.settingsApp.setGeoLocation(location, this.isEmulator());
-    try {
-      return await this.getGeoLocation();
-    } catch (e) {
-      this.log.warn(
-        `Could not get the current geolocation info: ${/** @type {Error} */ (e).message}`
-      );
-      this.log.warn(`Returning the default zero'ed values`);
-      return {
-        latitude: GEO_EPSILON,
-        longitude: GEO_EPSILON,
-        altitude: GEO_EPSILON,
-      };
+  if (shouldEnableWifi === isWiFiEnabled && shouldEnableDataConnection === isDataEnabled) {
+    this.log.info(
+      'Not changing data connection/Wi-Fi states, since they are already set to expected values',
+    );
+    if (await this.adb.isAirplaneModeOn()) {
+      return AIRPLANE_MODE_MASK | currentState;
     }
-  },
+    return ~AIRPLANE_MODE_MASK & currentState;
+  }
+
+  if (shouldEnableWifi !== isWiFiEnabled) {
+    await this.setWifiState(shouldEnableWifi);
+  } else {
+    this.log.info(
+      `Not changing Wi-Fi state, since it is already ` +
+        `${shouldEnableWifi ? 'enabled' : 'disabled'}`,
+    );
+  }
+
+  if (shouldEnableAirplaneMode) {
+    this.log.info('Not changing data connection state, because airplane mode is enabled');
+  } else if (shouldEnableDataConnection === isDataEnabled) {
+    this.log.info(
+      `Not changing data connection state, since it is already ` +
+        `${shouldEnableDataConnection ? 'enabled' : 'disabled'}`,
+    );
+  } else {
+    await this.setDataState(shouldEnableDataConnection);
+  }
 
-  async mobileRefreshGpsCache(opts = {}) {
-    const {timeoutMs} = opts;
-    await this.settingsApp.refreshGeoLocationCache(timeoutMs);
-  },
+  return await this.getNetworkConnection();
+}
 
-  async getGeoLocation() {
-    const {latitude, longitude, altitude} = await this.settingsApp.getGeoLocation();
-    return {
-      latitude: parseFloat(String(latitude)) || GEO_EPSILON,
-      longitude: parseFloat(String(longitude)) || GEO_EPSILON,
-      altitude: parseFloat(String(altitude)) || GEO_EPSILON,
-    };
-  },
+/**
+ * @since Android 12 (only real devices, emulators work in all APIs)
+ * @this {import('../driver').AndroidDriver}
+ * @param {boolean} isOn
+ * @returns {Promise<void>}
+ */
+export async function setWifiState(isOn) {
+  await this.settingsApp.setWifiState(isOn, this.isEmulator());
+}
 
-  async isLocationServicesEnabled() {
-    return (await this.adb.getLocationProviders()).includes('gps');
-  },
+/**
+ * @since Android 12 (only real devices, emulators work in all APIs)
+ * @this {import('../driver').AndroidDriver}
+ * @param {boolean} isOn
+ * @returns {Promise<void>}
+ */
+export async function setDataState(isOn) {
+  await this.settingsApp.setDataState(isOn, this.isEmulator());
+}
 
-  async toggleLocationServices() {
-    this.log.info('Toggling location services');
-    const isGpsEnabled = await this.isLocationServicesEnabled();
-    this.log.debug(
-      `Current GPS state: ${isGpsEnabled}. ` +
-        `The service is going to be ${isGpsEnabled ? 'disabled' : 'enabled'}`
-    );
-    await this.adb.toggleGPSLocationProvider(!isGpsEnabled);
-  },
-};
+/**
+ * @since Android 12 (only real devices, emulators work in all APIs)
+ * @this {import('../driver').AndroidDriver}
+ * @returns {Promise<void>}
+ */
+export async function toggleData() {
+  const isOn = await this.adb.isDataOn();
+  this.log.info(`Turning network data ${!isOn ? 'on' : 'off'}`);
+  await this.setDataState(!isOn);
+}
 
-mixin(NetworkMixin);
+/**
+ * @since Android 12 (only real devices, emulators work in all APIs)
+ * @this {import('../driver').AndroidDriver}
+ * @returns {Promise<void>}
+ */
+export async function toggleWiFi() {
+  const isOn = await this.adb.isWifiOn();
+  this.log.info(`Turning WiFi ${!isOn ? 'on' : 'off'}`);
+  await this.setWifiState(!isOn);
+}
 
-export default NetworkMixin;
+/**
+ * @since Android 12 (only real devices, emulators work in all APIs)
+ * @this {import('../driver').AndroidDriver}
+ * @returns {Promise<void>}
+ */
+export async function toggleFlightMode() {
+  let flightMode = !(await this.adb.isAirplaneModeOn());
+  this.log.info(`Turning flight mode ${flightMode ? 'on' : 'off'}`);
+  await this.adb.setAirplaneMode(flightMode);
+  if ((await this.adb.getApiLevel()) < 30) {
+    await this.adb.broadcastAirplaneMode(flightMode);
+  }
+}
 
 /**
  * @typedef {import('appium-adb').ADB} ADB