appium-espresso-driver 1.46.0

package/build/lib/server-builder.js

@@ -0,0 +1,213 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.buildServerSigningConfig = buildServerSigningConfig;
+exports.default = exports.GRADLE_URL_TEMPLATE = exports.VERSION_KEYS = exports.ServerBuilder = void 0;
+
+require("source-map-support/register");
+
+var _teen_process = require("teen_process");
+
+var _appiumSupport = require("appium-support");
+
+var _lodash = _interopRequireDefault(require("lodash"));
+
+var _logger = _interopRequireDefault(require("./logger"));
+
+var _path = _interopRequireDefault(require("path"));
+
+var _os = require("os");
+
+var _utils = require("./utils");
+
+const GRADLE_VERSION_KEY = 'gradle';
+const GRADLE_URL_PREFIX = 'distributionUrl=';
+const GRADLE_URL_TEMPLATE = 'https\\://services.gradle.org/distributions/gradle-VERSION-all.zip';
+exports.GRADLE_URL_TEMPLATE = GRADLE_URL_TEMPLATE;
+const GRADLE_MAX_ERROR_LOG_LINES = 15;
+const DEPENDENCY_PROP_NAMES = ['additionalAppDependencies', 'additionalAndroidTestDependencies'];
+const VERSION_KEYS = [GRADLE_VERSION_KEY, 'androidGradlePlugin', 'compileSdk', 'buildTools', 'minSdk', 'targetSdk', 'kotlin'];
+exports.VERSION_KEYS = VERSION_KEYS;
+
+const gradleLog = _appiumSupport.logger.getLogger('Gradle');
+
+function buildServerSigningConfig(args) {
+  return {
+    zipAlign: true,
+    keystoreFile: args.keystoreFile,
+    keystorePassword: args.keystorePassword,
+    keyAlias: args.keyAlias,
+    keyPassword: args.keyPassword
+  };
+}
+
+class ServerBuilder {
+  constructor(args = {}) {
+    this.serverPath = args.serverPath;
+    this.showGradleLog = args.showGradleLog;
+    const buildConfiguration = args.buildConfiguration || {};
+    const versionConfiguration = buildConfiguration.toolsVersions || {};
+    this.serverVersions = _lodash.default.reduce(versionConfiguration, (acc, value, key) => {
+      if (VERSION_KEYS.includes(key)) {
+        acc[key] = value;
+      } else {
+        _logger.default.warn(`Got unexpected '${key}' in toolsVersion block of the build configuration`);
+      }
+
+      return acc;
+    }, {});
+    this.testAppPackage = args.testAppPackage;
+    this.signingConfig = args.signingConfig;
+
+    for (const propName of DEPENDENCY_PROP_NAMES) {
+      this[propName] = buildConfiguration[propName] || [];
+    }
+  }
+
+  async build() {
+    if (this.serverVersions[GRADLE_VERSION_KEY]) {
+      await this.setGradleWrapperVersion(this.serverVersions[GRADLE_VERSION_KEY]);
+    }
+
+    await this.insertAdditionalDependencies();
+    await this.runBuildProcess();
+  }
+
+  getCommand() {
+    const cmd = _appiumSupport.system.isWindows() ? 'gradlew.bat' : './gradlew';
+
+    const buildProperty = (key, value) => value ? `-P${key}=${value}` : null;
+
+    let args = VERSION_KEYS.filter(key => key !== GRADLE_VERSION_KEY).map(key => {
+      const serverVersion = this.serverVersions[key];
+      const gradleProperty = `appium${key.charAt(0).toUpperCase()}${key.slice(1)}`;
+      return buildProperty(gradleProperty, serverVersion);
+    }).filter(Boolean);
+
+    if (this.signingConfig) {
+      args.push(..._lodash.default.keys(this.signingConfig).map(key => [`appium${_lodash.default.upperFirst(key)}`, this.signingConfig[key]]).map(([k, v]) => buildProperty(k, v)).filter(Boolean));
+    }
+
+    if (this.testAppPackage) {
+      args.push(buildProperty('appiumTargetPackage', this.testAppPackage));
+    }
+
+    args.push('app:assembleAndroidTest');
+    return {
+      cmd,
+      args
+    };
+  }
+
+  async setGradleWrapperVersion(version) {
+    const propertiesPath = _path.default.resolve(this.serverPath, 'gradle', 'wrapper', 'gradle-wrapper.properties');
+
+    const originalProperties = await _appiumSupport.fs.readFile(propertiesPath, 'utf8');
+    const newProperties = this.updateGradleDistUrl(originalProperties, version);
+    await _appiumSupport.fs.writeFile(propertiesPath, newProperties, 'utf8');
+  }
+
+  updateGradleDistUrl(propertiesContent, version) {
+    return propertiesContent.replace(new RegExp(`^(${_lodash.default.escapeRegExp(GRADLE_URL_PREFIX)}).+$`, 'gm'), `$1${GRADLE_URL_TEMPLATE.replace('VERSION', version)}`);
+  }
+
+  async insertAdditionalDependencies() {
+    let hasAdditionalDeps = false;
+
+    for (const propName of DEPENDENCY_PROP_NAMES) {
+      if (!_lodash.default.isArray(this[propName])) {
+        throw new Error(`'${propName}' must be an array`);
+      }
+
+      if (_lodash.default.isEmpty(this[propName].filter(line => _lodash.default.trim(line)))) {
+        continue;
+      }
+
+      for (const dep of this[propName]) {
+        if (/[\s'\\$]/.test(dep)) {
+          throw new Error('Single quotes, dollar characters and whitespace characters' + ` are disallowed in additional dependencies: ${dep}`);
+        }
+      }
+
+      hasAdditionalDeps = true;
+    }
+
+    if (!hasAdditionalDeps) {
+      return;
+    }
+
+    const buildPath = _path.default.resolve(this.serverPath, 'app', 'build.gradle.kts');
+
+    let configuration = await _appiumSupport.fs.readFile(buildPath, 'utf8');
+
+    for (const propName of DEPENDENCY_PROP_NAMES) {
+      const prefix = propName === DEPENDENCY_PROP_NAMES[0] ? 'implementation' : 'androidTestImplementation';
+      const deps = this[propName].filter(line => _lodash.default.trim(line)).map(line => `${prefix}("${line}")`);
+
+      if (_lodash.default.isEmpty(deps)) {
+        continue;
+      }
+
+      _logger.default.info(`Adding the following ${propName} to build.gradle.kts: ${deps}`);
+
+      configuration = (0, _utils.updateDependencyLines)(configuration, propName, deps);
+    }
+
+    await _appiumSupport.fs.writeFile(buildPath, configuration, 'utf8');
+  }
+
+  async runBuildProcess() {
+    const {
+      cmd,
+      args
+    } = this.getCommand();
+
+    _logger.default.debug(`Beginning build with command '${cmd} ${args.join(' ')}' ` + `in directory '${this.serverPath}'`);
+
+    const gradlebuild = new _teen_process.SubProcess(cmd, args, {
+      cwd: this.serverPath,
+      stdio: ['ignore', 'pipe', 'pipe']
+    });
+    let buildLastLines = [];
+    const logMsg = `Output from Gradle ${this.showGradleLog ? 'will' : 'will not'} be logged`;
+
+    _logger.default.debug(`${logMsg}. To change this, use 'showGradleLog' desired capability`);
+
+    gradlebuild.on('stream-line', line => {
+      if (this.showGradleLog) {
+        if (line.startsWith('[STDERR]')) {
+          gradleLog.warn(line);
+        } else {
+          gradleLog.info(line);
+        }
+      }
+
+      buildLastLines.push(`${_os.EOL}${line}`);
+
+      if (buildLastLines.length > GRADLE_MAX_ERROR_LOG_LINES) {
+        buildLastLines = buildLastLines.slice(-GRADLE_MAX_ERROR_LOG_LINES);
+      }
+    });
+
+    try {
+      await gradlebuild.start();
+      await gradlebuild.join();
+    } catch (err) {
+      let msg = `Unable to build Espresso server - ${err.message}\n` + `Gradle error message:${_os.EOL}${buildLastLines}`;
+
+      _logger.default.errorAndThrow(msg);
+    }
+  }
+
+}
+
+exports.ServerBuilder = ServerBuilder;
+var _default = ServerBuilder;
+exports.default = _default;require('source-map-support').install();
+
+
+//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["lib/server-builder.js"],"names":["GRADLE_VERSION_KEY","GRADLE_URL_PREFIX","GRADLE_URL_TEMPLATE","GRADLE_MAX_ERROR_LOG_LINES","DEPENDENCY_PROP_NAMES","VERSION_KEYS","gradleLog","logger","getLogger","buildServerSigningConfig","args","zipAlign","keystoreFile","keystorePassword","keyAlias","keyPassword","ServerBuilder","constructor","serverPath","showGradleLog","buildConfiguration","versionConfiguration","toolsVersions","serverVersions","_","reduce","acc","value","key","includes","log","warn","testAppPackage","signingConfig","propName","build","setGradleWrapperVersion","insertAdditionalDependencies","runBuildProcess","getCommand","cmd","system","isWindows","buildProperty","filter","map","serverVersion","gradleProperty","charAt","toUpperCase","slice","Boolean","push","keys","upperFirst","k","v","version","propertiesPath","path","resolve","originalProperties","fs","readFile","newProperties","updateGradleDistUrl","writeFile","propertiesContent","replace","RegExp","escapeRegExp","hasAdditionalDeps","isArray","Error","isEmpty","line","trim","dep","test","buildPath","configuration","prefix","deps","info","debug","join","gradlebuild","SubProcess","cwd","stdio","buildLastLines","logMsg","on","startsWith","EOL","length","start","err","msg","message","errorAndThrow"],"mappings":";;;;;;;;;;;;AAAA;;AACA;;AACA;;AACA;;AACA;;AACA;;AACA;;AAEA,MAAMA,kBAAkB,GAAG,QAA3B;AACA,MAAMC,iBAAiB,GAAG,kBAA1B;AACA,MAAMC,mBAAmB,GAAG,oEAA5B;;AACA,MAAMC,0BAA0B,GAAG,EAAnC;AACA,MAAMC,qBAAqB,GAAG,CAAC,2BAAD,EAA8B,mCAA9B,CAA9B;AAEA,MAAMC,YAAY,GAAG,CACnBL,kBADmB,EAEnB,qBAFmB,EAGnB,YAHmB,EAInB,YAJmB,EAKnB,QALmB,EAMnB,WANmB,EAOnB,QAPmB,CAArB;;;AAUA,MAAMM,SAAS,GAAGC,sBAAOC,SAAP,CAAiB,QAAjB,CAAlB;;AAEA,SAASC,wBAAT,CAAmCC,IAAnC,EAAyC;AACvC,SAAO;AACLC,IAAAA,QAAQ,EAAE,IADL;AAELC,IAAAA,YAAY,EAAEF,IAAI,CAACE,YAFd;AAGLC,IAAAA,gBAAgB,EAAEH,IAAI,CAACG,gBAHlB;AAILC,IAAAA,QAAQ,EAAEJ,IAAI,CAACI,QAJV;AAKLC,IAAAA,WAAW,EAAEL,IAAI,CAACK;AALb,GAAP;AAOD;;AAED,MAAMC,aAAN,CAAoB;AAClBC,EAAAA,WAAW,CAAEP,IAAI,GAAG,EAAT,EAAa;AACtB,SAAKQ,UAAL,GAAkBR,IAAI,CAACQ,UAAvB;AACA,SAAKC,aAAL,GAAqBT,IAAI,CAACS,aAA1B;AAEA,UAAMC,kBAAkB,GAAGV,IAAI,CAACU,kBAAL,IAA2B,EAAtD;AAEA,UAAMC,oBAAoB,GAAGD,kBAAkB,CAACE,aAAnB,IAAoC,EAAjE;AACA,SAAKC,cAAL,GAAsBC,gBAAEC,MAAF,CAASJ,oBAAT,EAA+B,CAACK,GAAD,EAAMC,KAAN,EAAaC,GAAb,KAAqB;AACxE,UAAIvB,YAAY,CAACwB,QAAb,CAAsBD,GAAtB,CAAJ,EAAgC;AAC9BF,QAAAA,GAAG,CAACE,GAAD,CAAH,GAAWD,KAAX;AACD,OAFD,MAEO;AACLG,wBAAIC,IAAJ,CAAU,mBAAkBH,GAAI,oDAAhC;AACD;;AACD,aAAOF,GAAP;AACD,KAPqB,EAOnB,EAPmB,CAAtB;AASA,SAAKM,cAAL,GAAsBtB,IAAI,CAACsB,cAA3B;AACA,SAAKC,aAAL,GAAqBvB,IAAI,CAACuB,aAA1B;;AAEA,SAAK,MAAMC,QAAX,IAAuB9B,qBAAvB,EAA8C;AAC5C,WAAK8B,QAAL,IAAiBd,kBAAkB,CAACc,QAAD,CAAlB,IAAgC,EAAjD;AACD;AACF;;AAEU,QAALC,KAAK,GAAI;AACb,QAAI,KAAKZ,cAAL,CAAoBvB,kBAApB,CAAJ,EAA6C;AAC3C,YAAM,KAAKoC,uBAAL,CAA6B,KAAKb,cAAL,CAAoBvB,kBAApB,CAA7B,CAAN;AACD;;AAED,UAAM,KAAKqC,4BAAL,EAAN;AAEA,UAAM,KAAKC,eAAL,EAAN;AACD;;AAEDC,EAAAA,UAAU,GAAI;AACZ,UAAMC,GAAG,GAAGC,sBAAOC,SAAP,KAAqB,aAArB,GAAqC,WAAjD;;AACA,UAAMC,aAAa,GAAG,CAACf,GAAD,EAAMD,KAAN,KAAgBA,KAAK,GAAI,KAAIC,GAAI,IAAGD,KAAM,EAArB,GAAyB,IAApE;;AACA,QAAIjB,IAAI,GAAGL,YAAY,CACpBuC,MADQ,CACAhB,GAAD,IAASA,GAAG,KAAK5B,kBADhB,EAER6C,GAFQ,CAEHjB,GAAD,IAAS;AACZ,YAAMkB,aAAa,GAAG,KAAKvB,cAAL,CAAoBK,GAApB,CAAtB;AACA,YAAMmB,cAAc,GAAI,SAAQnB,GAAG,CAACoB,MAAJ,CAAW,CAAX,EAAcC,WAAd,EAA4B,GAAErB,GAAG,CAACsB,KAAJ,CAAU,CAAV,CAAa,EAA3E;AACA,aAAOP,aAAa,CAACI,cAAD,EAAiBD,aAAjB,CAApB;AACD,KANQ,EAORF,MAPQ,CAODO,OAPC,CAAX;;AASA,QAAI,KAAKlB,aAAT,EAAwB;AACtBvB,MAAAA,IAAI,CAAC0C,IAAL,CAAU,GACR5B,gBAAE6B,IAAF,CAAO,KAAKpB,aAAZ,EACCY,GADD,CACMjB,GAAD,IAAS,CAAE,SAAQJ,gBAAE8B,UAAF,CAAa1B,GAAb,CAAkB,EAA5B,EAA+B,KAAKK,aAAL,CAAmBL,GAAnB,CAA/B,CADd,EAECiB,GAFD,CAEK,CAAC,CAACU,CAAD,EAAIC,CAAJ,CAAD,KAAYb,aAAa,CAACY,CAAD,EAAIC,CAAJ,CAF9B,EAGCZ,MAHD,CAGQO,OAHR,CADF;AAMD;;AAED,QAAI,KAAKnB,cAAT,EAAyB;AACvBtB,MAAAA,IAAI,CAAC0C,IAAL,CAAUT,aAAa,CAAC,qBAAD,EAAwB,KAAKX,cAA7B,CAAvB;AACD;;AACDtB,IAAAA,IAAI,CAAC0C,IAAL,CAAU,yBAAV;AAEA,WAAO;AAACZ,MAAAA,GAAD;AAAM9B,MAAAA;AAAN,KAAP;AACD;;AAE4B,QAAvB0B,uBAAuB,CAAEqB,OAAF,EAAW;AACtC,UAAMC,cAAc,GAAGC,cAAKC,OAAL,CAAa,KAAK1C,UAAlB,EAA8B,QAA9B,EAAwC,SAAxC,EAAmD,2BAAnD,CAAvB;;AACA,UAAM2C,kBAAkB,GAAG,MAAMC,kBAAGC,QAAH,CAAYL,cAAZ,EAA4B,MAA5B,CAAjC;AACA,UAAMM,aAAa,GAAG,KAAKC,mBAAL,CAAyBJ,kBAAzB,EAA6CJ,OAA7C,CAAtB;AACA,UAAMK,kBAAGI,SAAH,CAAaR,cAAb,EAA6BM,aAA7B,EAA4C,MAA5C,CAAN;AACD;;AAEDC,EAAAA,mBAAmB,CAAEE,iBAAF,EAAqBV,OAArB,EAA8B;AAC/C,WAAOU,iBAAiB,CAACC,OAAlB,CACL,IAAIC,MAAJ,CAAY,KAAI7C,gBAAE8C,YAAF,CAAerE,iBAAf,CAAkC,MAAlD,EAAyD,IAAzD,CADK,EAEJ,KAAIC,mBAAmB,CAACkE,OAApB,CAA4B,SAA5B,EAAuCX,OAAvC,CAAgD,EAFhD,CAAP;AAID;;AAEiC,QAA5BpB,4BAA4B,GAAI;AACpC,QAAIkC,iBAAiB,GAAG,KAAxB;;AACA,SAAK,MAAMrC,QAAX,IAAuB9B,qBAAvB,EAA8C;AAC5C,UAAI,CAACoB,gBAAEgD,OAAF,CAAU,KAAKtC,QAAL,CAAV,CAAL,EAAgC;AAC9B,cAAM,IAAIuC,KAAJ,CAAW,IAAGvC,QAAS,oBAAvB,CAAN;AACD;;AACD,UAAIV,gBAAEkD,OAAF,CAAU,KAAKxC,QAAL,EAAeU,MAAf,CAAuB+B,IAAD,IAAUnD,gBAAEoD,IAAF,CAAOD,IAAP,CAAhC,CAAV,CAAJ,EAA8D;AAC5D;AACD;;AAED,WAAK,MAAME,GAAX,IAAkB,KAAK3C,QAAL,CAAlB,EAAkC;AAChC,YAAI,WAAW4C,IAAX,CAAgBD,GAAhB,CAAJ,EAA0B;AACxB,gBAAM,IAAIJ,KAAJ,CAAU,+DACb,+CAA8CI,GAAI,EAD/C,CAAN;AAED;AACF;;AACDN,MAAAA,iBAAiB,GAAG,IAApB;AACD;;AACD,QAAI,CAACA,iBAAL,EAAwB;AACtB;AACD;;AAED,UAAMQ,SAAS,GAAGpB,cAAKC,OAAL,CAAa,KAAK1C,UAAlB,EAA8B,KAA9B,EAAqC,kBAArC,CAAlB;;AACA,QAAI8D,aAAa,GAAG,MAAMlB,kBAAGC,QAAH,CAAYgB,SAAZ,EAAuB,MAAvB,CAA1B;;AACA,SAAK,MAAM7C,QAAX,IAAuB9B,qBAAvB,EAA8C;AAC5C,YAAM6E,MAAM,GAAG/C,QAAQ,KAAK9B,qBAAqB,CAAC,CAAD,CAAlC,GACX,gBADW,GAEX,2BAFJ;AAGA,YAAM8E,IAAI,GAAG,KAAKhD,QAAL,EACVU,MADU,CACF+B,IAAD,IAAUnD,gBAAEoD,IAAF,CAAOD,IAAP,CADP,EAEV9B,GAFU,CAEL8B,IAAD,IAAW,GAAEM,MAAO,KAAIN,IAAK,IAFvB,CAAb;;AAGA,UAAInD,gBAAEkD,OAAF,CAAUQ,IAAV,CAAJ,EAAqB;AACnB;AACD;;AAEDpD,sBAAIqD,IAAJ,CAAU,wBAAuBjD,QAAS,yBAAwBgD,IAAK,EAAvE;;AACAF,MAAAA,aAAa,GAAG,kCAAsBA,aAAtB,EAAqC9C,QAArC,EAA+CgD,IAA/C,CAAhB;AACD;;AACD,UAAMpB,kBAAGI,SAAH,CAAaa,SAAb,EAAwBC,aAAxB,EAAuC,MAAvC,CAAN;AACD;;AAEoB,QAAf1C,eAAe,GAAI;AACvB,UAAM;AAACE,MAAAA,GAAD;AAAM9B,MAAAA;AAAN,QAAc,KAAK6B,UAAL,EAApB;;AACAT,oBAAIsD,KAAJ,CAAW,iCAAgC5C,GAAI,IAAG9B,IAAI,CAAC2E,IAAL,CAAU,GAAV,CAAe,IAAvD,GACP,iBAAgB,KAAKnE,UAAW,GADnC;;AAEA,UAAMoE,WAAW,GAAG,IAAIC,wBAAJ,CAAe/C,GAAf,EAAoB9B,IAApB,EAA0B;AAC5C8E,MAAAA,GAAG,EAAE,KAAKtE,UADkC;AAE5CuE,MAAAA,KAAK,EAAE,CAAC,QAAD,EAAW,MAAX,EAAmB,MAAnB;AAFqC,KAA1B,CAApB;AAIA,QAAIC,cAAc,GAAG,EAArB;AAEA,UAAMC,MAAM,GAAI,sBAAqB,KAAKxE,aAAL,GAAqB,MAArB,GAA8B,UAAW,YAA9E;;AACAW,oBAAIsD,KAAJ,CAAW,GAAEO,MAAO,0DAApB;;AACAL,IAAAA,WAAW,CAACM,EAAZ,CAAe,aAAf,EAA+BjB,IAAD,IAAU;AACtC,UAAI,KAAKxD,aAAT,EAAwB;AACtB,YAAIwD,IAAI,CAACkB,UAAL,CAAgB,UAAhB,CAAJ,EAAiC;AAC/BvF,UAAAA,SAAS,CAACyB,IAAV,CAAe4C,IAAf;AACD,SAFD,MAEO;AACLrE,UAAAA,SAAS,CAAC6E,IAAV,CAAeR,IAAf;AACD;AACF;;AACDe,MAAAA,cAAc,CAACtC,IAAf,CAAqB,GAAE0C,OAAI,GAAEnB,IAAK,EAAlC;;AACA,UAAIe,cAAc,CAACK,MAAf,GAAwB5F,0BAA5B,EAAwD;AACtDuF,QAAAA,cAAc,GAAGA,cAAc,CAACxC,KAAf,CAAqB,CAAC/C,0BAAtB,CAAjB;AACD;AACF,KAZD;;AAcA,QAAI;AACF,YAAMmF,WAAW,CAACU,KAAZ,EAAN;AACA,YAAMV,WAAW,CAACD,IAAZ,EAAN;AACD,KAHD,CAGE,OAAOY,GAAP,EAAY;AACZ,UAAIC,GAAG,GAAI,qCAAoCD,GAAG,CAACE,OAAQ,IAAjD,GACP,wBAAuBL,OAAI,GAAEJ,cAAe,EAD/C;;AAEA5D,sBAAIsE,aAAJ,CAAkBF,GAAlB;AACD;AACF;;AAzJiB;;;eA6JLlF,a","sourcesContent":["import { SubProcess } from 'teen_process';\nimport { fs, logger, system } from 'appium-support';\nimport _ from 'lodash';\nimport log from './logger';\nimport path from 'path';\nimport { EOL } from 'os';\nimport { updateDependencyLines } from './utils';\n\nconst GRADLE_VERSION_KEY = 'gradle';\nconst GRADLE_URL_PREFIX = 'distributionUrl=';\nconst GRADLE_URL_TEMPLATE = 'https\\\\://services.gradle.org/distributions/gradle-VERSION-all.zip';\nconst GRADLE_MAX_ERROR_LOG_LINES = 15;\nconst DEPENDENCY_PROP_NAMES = ['additionalAppDependencies', 'additionalAndroidTestDependencies'];\n\nconst VERSION_KEYS = [\n  GRADLE_VERSION_KEY,\n  'androidGradlePlugin',\n  'compileSdk',\n  'buildTools',\n  'minSdk',\n  'targetSdk',\n  'kotlin'\n];\n\nconst gradleLog = logger.getLogger('Gradle');\n\nfunction buildServerSigningConfig (args) {\n  return {\n    zipAlign: true,\n    keystoreFile: args.keystoreFile,\n    keystorePassword: args.keystorePassword,\n    keyAlias: args.keyAlias,\n    keyPassword: args.keyPassword\n  };\n}\n\nclass ServerBuilder {\n  constructor (args = {}) {\n    this.serverPath = args.serverPath;\n    this.showGradleLog = args.showGradleLog;\n\n    const buildConfiguration = args.buildConfiguration || {};\n\n    const versionConfiguration = buildConfiguration.toolsVersions || {};\n    this.serverVersions = _.reduce(versionConfiguration, (acc, value, key) => {\n      if (VERSION_KEYS.includes(key)) {\n        acc[key] = value;\n      } else {\n        log.warn(`Got unexpected '${key}' in toolsVersion block of the build configuration`);\n      }\n      return acc;\n    }, {});\n\n    this.testAppPackage = args.testAppPackage;\n    this.signingConfig = args.signingConfig;\n\n    for (const propName of DEPENDENCY_PROP_NAMES) {\n      this[propName] = buildConfiguration[propName] || [];\n    }\n  }\n\n  async build () {\n    if (this.serverVersions[GRADLE_VERSION_KEY]) {\n      await this.setGradleWrapperVersion(this.serverVersions[GRADLE_VERSION_KEY]);\n    }\n\n    await this.insertAdditionalDependencies();\n\n    await this.runBuildProcess();\n  }\n\n  getCommand () {\n    const cmd = system.isWindows() ? 'gradlew.bat' : './gradlew';\n    const buildProperty = (key, value) => value ? `-P${key}=${value}` : null;\n    let args = VERSION_KEYS\n      .filter((key) => key !== GRADLE_VERSION_KEY)\n      .map((key) => {\n        const serverVersion = this.serverVersions[key];\n        const gradleProperty = `appium${key.charAt(0).toUpperCase()}${key.slice(1)}`;\n        return buildProperty(gradleProperty, serverVersion);\n      })\n      .filter(Boolean);\n\n    if (this.signingConfig) {\n      args.push(...(\n        _.keys(this.signingConfig)\n        .map((key) => [`appium${_.upperFirst(key)}`, this.signingConfig[key]])\n        .map(([k, v]) => buildProperty(k, v))\n        .filter(Boolean)\n      ));\n    }\n\n    if (this.testAppPackage) {\n      args.push(buildProperty('appiumTargetPackage', this.testAppPackage));\n    }\n    args.push('app:assembleAndroidTest');\n\n    return {cmd, args};\n  }\n\n  async setGradleWrapperVersion (version) {\n    const propertiesPath = path.resolve(this.serverPath, 'gradle', 'wrapper', 'gradle-wrapper.properties');\n    const originalProperties = await fs.readFile(propertiesPath, 'utf8');\n    const newProperties = this.updateGradleDistUrl(originalProperties, version);\n    await fs.writeFile(propertiesPath, newProperties, 'utf8');\n  }\n\n  updateGradleDistUrl (propertiesContent, version) {\n    return propertiesContent.replace(\n      new RegExp(`^(${_.escapeRegExp(GRADLE_URL_PREFIX)}).+$`, 'gm'),\n      `$1${GRADLE_URL_TEMPLATE.replace('VERSION', version)}`\n    );\n  }\n\n  async insertAdditionalDependencies () {\n    let hasAdditionalDeps = false;\n    for (const propName of DEPENDENCY_PROP_NAMES) {\n      if (!_.isArray(this[propName])) {\n        throw new Error(`'${propName}' must be an array`);\n      }\n      if (_.isEmpty(this[propName].filter((line) => _.trim(line)))) {\n        continue;\n      }\n\n      for (const dep of this[propName]) {\n        if (/[\\s'\\\\$]/.test(dep)) {\n          throw new Error('Single quotes, dollar characters and whitespace characters' +\n            ` are disallowed in additional dependencies: ${dep}`);\n        }\n      }\n      hasAdditionalDeps = true;\n    }\n    if (!hasAdditionalDeps) {\n      return;\n    }\n\n    const buildPath = path.resolve(this.serverPath, 'app', 'build.gradle.kts');\n    let configuration = await fs.readFile(buildPath, 'utf8');\n    for (const propName of DEPENDENCY_PROP_NAMES) {\n      const prefix = propName === DEPENDENCY_PROP_NAMES[0]\n        ? 'implementation'\n        : 'androidTestImplementation';\n      const deps = this[propName]\n        .filter((line) => _.trim(line))\n        .map((line) => `${prefix}(\"${line}\")`);\n      if (_.isEmpty(deps)) {\n        continue;\n      }\n\n      log.info(`Adding the following ${propName} to build.gradle.kts: ${deps}`);\n      configuration = updateDependencyLines(configuration, propName, deps);\n    }\n    await fs.writeFile(buildPath, configuration, 'utf8');\n  }\n\n  async runBuildProcess () {\n    const {cmd, args} = this.getCommand();\n    log.debug(`Beginning build with command '${cmd} ${args.join(' ')}' ` +\n      `in directory '${this.serverPath}'`);\n    const gradlebuild = new SubProcess(cmd, args, {\n      cwd: this.serverPath,\n      stdio: ['ignore', 'pipe', 'pipe'],\n    });\n    let buildLastLines = [];\n\n    const logMsg = `Output from Gradle ${this.showGradleLog ? 'will' : 'will not'} be logged`;\n    log.debug(`${logMsg}. To change this, use 'showGradleLog' desired capability`);\n    gradlebuild.on('stream-line', (line) => {\n      if (this.showGradleLog) {\n        if (line.startsWith('[STDERR]')) {\n          gradleLog.warn(line);\n        } else {\n          gradleLog.info(line);\n        }\n      }\n      buildLastLines.push(`${EOL}${line}`);\n      if (buildLastLines.length > GRADLE_MAX_ERROR_LOG_LINES) {\n        buildLastLines = buildLastLines.slice(-GRADLE_MAX_ERROR_LOG_LINES);\n      }\n    });\n\n    try {\n      await gradlebuild.start();\n      await gradlebuild.join();\n    } catch (err) {\n      let msg = `Unable to build Espresso server - ${err.message}\\n` +\n        `Gradle error message:${EOL}${buildLastLines}`;\n      log.errorAndThrow(msg);\n    }\n  }\n}\n\nexport { ServerBuilder, VERSION_KEYS, GRADLE_URL_TEMPLATE, buildServerSigningConfig };\nexport default ServerBuilder;\n"],"file":"lib/server-builder.js","sourceRoot":"../.."}

package/build/lib/server.js

@@ -0,0 +1,39 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.startServer = startServer;
+exports.default = void 0;
+
+require("source-map-support/register");
+
+var _logger = _interopRequireDefault(require("./logger"));
+
+var _appiumBaseDriver = require("appium-base-driver");
+
+var _driver = _interopRequireDefault(require("./driver"));
+
+async function startServer(port, host) {
+  const d = new _driver.default({
+    port,
+    host
+  });
+  const server = (0, _appiumBaseDriver.server)({
+    routeConfiguringFunction: (0, _appiumBaseDriver.routeConfiguringFunction)(d),
+    port,
+    hostname: host
+  });
+
+  _logger.default.info(`Android Espresso Driver listening on http://${host}:${port}`);
+
+  return await server;
+}
+
+var _default = startServer;
+exports.default = _default;require('source-map-support').install();
+
+
+//# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImxpYi9zZXJ2ZXIuanMiXSwibmFtZXMiOlsic3RhcnRTZXJ2ZXIiLCJwb3J0IiwiaG9zdCIsImQiLCJFc3ByZXNzb0RyaXZlciIsInNlcnZlciIsInJvdXRlQ29uZmlndXJpbmdGdW5jdGlvbiIsImhvc3RuYW1lIiwibG9nIiwiaW5mbyJdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7O0FBQUE7O0FBQ0E7O0FBQ0E7O0FBR0EsZUFBZUEsV0FBZixDQUE0QkMsSUFBNUIsRUFBa0NDLElBQWxDLEVBQXdDO0FBQ3RDLFFBQU1DLENBQUMsR0FBRyxJQUFJQyxlQUFKLENBQW1CO0FBQUNILElBQUFBLElBQUQ7QUFBT0MsSUFBQUE7QUFBUCxHQUFuQixDQUFWO0FBQ0EsUUFBTUcsTUFBTSxHQUFHLDhCQUFXO0FBQ3hCQyxJQUFBQSx3QkFBd0IsRUFBRSxnREFBeUJILENBQXpCLENBREY7QUFFeEJGLElBQUFBLElBRndCO0FBR3hCTSxJQUFBQSxRQUFRLEVBQUVMO0FBSGMsR0FBWCxDQUFmOztBQUtBTSxrQkFBSUMsSUFBSixDQUFVLCtDQUE4Q1AsSUFBSyxJQUFHRCxJQUFLLEVBQXJFOztBQUNBLFNBQU8sTUFBTUksTUFBYjtBQUNEOztlQUdjTCxXIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IGxvZyBmcm9tICcuL2xvZ2dlcic7XG5pbXBvcnQgeyBzZXJ2ZXIgYXMgYmFzZVNlcnZlciwgcm91dGVDb25maWd1cmluZ0Z1bmN0aW9uIH0gZnJvbSAnYXBwaXVtLWJhc2UtZHJpdmVyJztcbmltcG9ydCBFc3ByZXNzb0RyaXZlciBmcm9tICcuL2RyaXZlcic7XG5cblxuYXN5bmMgZnVuY3Rpb24gc3RhcnRTZXJ2ZXIgKHBvcnQsIGhvc3QpIHtcbiAgY29uc3QgZCA9IG5ldyBFc3ByZXNzb0RyaXZlcih7cG9ydCwgaG9zdH0pO1xuICBjb25zdCBzZXJ2ZXIgPSBiYXNlU2VydmVyKHtcbiAgICByb3V0ZUNvbmZpZ3VyaW5nRnVuY3Rpb246IHJvdXRlQ29uZmlndXJpbmdGdW5jdGlvbihkKSxcbiAgICBwb3J0LFxuICAgIGhvc3RuYW1lOiBob3N0LFxuICB9KTtcbiAgbG9nLmluZm8oYEFuZHJvaWQgRXNwcmVzc28gRHJpdmVyIGxpc3RlbmluZyBvbiBodHRwOi8vJHtob3N0fToke3BvcnR9YCk7XG4gIHJldHVybiBhd2FpdCBzZXJ2ZXI7XG59XG5cbmV4cG9ydCB7IHN0YXJ0U2VydmVyIH07XG5leHBvcnQgZGVmYXVsdCBzdGFydFNlcnZlcjtcbiJdLCJmaWxlIjoibGliL3NlcnZlci5qcyIsInNvdXJjZVJvb3QiOiIuLi8uLiJ9

package/build/lib/utils.js

@@ -0,0 +1,85 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.qualifyActivityName = qualifyActivityName;
+exports.copyGradleProjectRecursively = copyGradleProjectRecursively;
+exports.requireOptions = requireOptions;
+exports.updateDependencyLines = updateDependencyLines;
+
+require("source-map-support/register");
+
+var _appiumSupport = require("appium-support");
+
+var _lodash = _interopRequireDefault(require("lodash"));
+
+var _path = _interopRequireDefault(require("path"));
+
+function qualifyActivityName(activityName, packageName) {
+  if ([activityName, packageName].some(name => !name || _lodash.default.includes(name, '*'))) {
+    return activityName;
+  }
+
+  const dotPos = activityName.indexOf('.');
+
+  if (dotPos > 0) {
+    return activityName;
+  }
+
+  return `${packageName}${dotPos === 0 ? '' : '.'}${activityName}`;
+}
+
+async function copyGradleProjectRecursively(sourceBaseDir, targetBaseDir) {
+  await _appiumSupport.fs.walkDir(sourceBaseDir, true, async (itemPath, isDirectory) => {
+    const relativePath = _path.default.relative(sourceBaseDir, itemPath);
+
+    const targetPath = _path.default.resolve(targetBaseDir, relativePath);
+
+    const isInGradleBuildDir = `${_path.default.sep}${itemPath}`.includes(`${_path.default.sep}build${_path.default.sep}`);
+
+    if (isInGradleBuildDir) {
+      return false;
+    }
+
+    if (isDirectory) {
+      await (0, _appiumSupport.mkdirp)(targetPath);
+    } else {
+      await _appiumSupport.fs.copyFile(itemPath, targetPath);
+    }
+
+    return false;
+  });
+}
+
+function requireOptions(opts, requiredKeys = []) {
+  const missingKeys = _lodash.default.difference(requiredKeys, _lodash.default.keys(opts));
+
+  if (!_lodash.default.isEmpty(missingKeys)) {
+    throw new Error(`The following options are required: ${missingKeys}`);
+  }
+
+  return opts;
+}
+
+function updateDependencyLines(originalContent, dependencyPlaceholder, dependencyLines) {
+  const configurationLines = originalContent.split('\n');
+  const searchRe = new RegExp(`^\\s*//\\s*\\b${_lodash.default.escapeRegExp(dependencyPlaceholder)}\\b`, 'm');
+  const placeholderIndex = configurationLines.findIndex(line => searchRe.test(line));
+
+  if (placeholderIndex < 0) {
+    return originalContent;
+  }
+
+  const placeholderLine = configurationLines[placeholderIndex];
+
+  const indentLen = placeholderLine.length - _lodash.default.trimStart(placeholderLine).length;
+
+  configurationLines.splice(placeholderIndex + 1, 0, ...dependencyLines.map(line => `${' '.repeat(indentLen)}${line}`));
+  return configurationLines.join('\n');
+}require('source-map-support').install();
+
+
+//# sourceMappingURL=data:application/json;charset=utf8;base64,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

package/espresso-server/app/build/outputs/apk/androidTest/debug/output-metadata.json

@@ -0,0 +1,18 @@
+{
+  "version": 2,
+  "artifactType": {
+    "type": "APK",
+    "kind": "Directory"
+  },
+  "applicationId": "io.appium.espressoserver.test",
+  "variantName": "processDebugAndroidTestResources",
+  "elements": [
+    {
+      "type": "SINGLE",
+      "filters": [],
+      "versionCode": 0,
+      "versionName": "",
+      "outputFile": "app-debug-androidTest.apk"
+    }
+  ]
+}

package/espresso-server/app/build.gradle.kts

@@ -0,0 +1,153 @@
+plugins {
+    id("com.android.application")
+    kotlin("android")
+}
+
+android {
+    compileSdkVersion(getIntProperty("appiumCompileSdk", 30))
+    buildToolsVersion(getStringProperty("appiumBuildTools", "30.0.3"))
+    defaultConfig {
+        // <instrumentation android:targetPackage=""/>
+        applicationId = getStringProperty("appiumTargetPackage", "io.appium.espressoserver")
+        // <manifest package=""/>
+        testApplicationId = "io.appium.espressoserver.test"
+        testHandleProfiling = false
+        testFunctionalTest = false
+        minSdkVersion(getIntProperty("appiumMinSdk", 21))
+        targetSdkVersion(getIntProperty("appiumTargetSdk", 28))
+        versionCode = 1
+        versionName = "1.0"
+        testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
+    }
+
+    buildTypes {
+        getByName("debug") {
+            zipAlignEnabled(getBooleanProperty("appiumZipAlign", true))
+        }
+        getByName("release") {
+            isMinifyEnabled = false
+            proguardFiles(getDefaultProguardFile("proguard-android.txt"), "proguard-rules.pro")
+        }
+    }
+
+    sourceSets {
+        getByName("test") {
+            java.srcDirs("src/androidTest/java")
+        }
+    }
+
+    testOptions {
+        unitTests.isReturnDefaultValues = true
+    }
+
+    signingConfigs {
+        getByName("debug") {
+            findProperty("appiumKeystoreFile")?.also {
+                storeFile(File(it.toString()))
+            }
+
+            findProperty("appiumKeystorePassword")?.also {
+                storePassword(it.toString())
+            }
+
+            findProperty("appiumKeyAlias")?.also {
+                keyAlias(it.toString())
+            }
+
+            findProperty("appiumKeyPassword")?.also {
+                keyPassword(it.toString())
+            }
+        }
+    }
+
+    compileOptions {
+        sourceCompatibility = JavaVersion.VERSION_1_8
+        targetCompatibility = JavaVersion.VERSION_1_8
+    }
+
+    kotlinOptions {
+        jvmTarget = JavaVersion.VERSION_1_8.toString()
+    }
+
+    packagingOptions {
+        exclude("META-INF/**")
+    }
+}
+
+dependencies {
+    implementation(fileTree(mapOf("dir" to "libs", "include" to listOf("*.jar"))))
+    // additionalAppDependencies placeholder (don't change or delete this line)
+
+    testImplementation("org.powermock:powermock-api-mockito2:${Version.mocklib}")
+    testImplementation("org.powermock:powermock-classloading-xstream:${Version.mocklib}")
+    testImplementation("org.powermock:powermock-module-junit4-rule:${Version.mocklib}")
+    testImplementation("org.powermock:powermock-module-junit4:${Version.mocklib}")
+    testImplementation("androidx.annotation:annotation:${Version.annotation}")
+    testImplementation("androidx.test.espresso:espresso-contrib:${Version.espresso}")
+    testImplementation("androidx.test.espresso:espresso-core:${Version.espresso}")
+    testImplementation("androidx.test.espresso:espresso-web:${Version.espresso}")
+    testImplementation("androidx.test.uiautomator:uiautomator:${Version.uia}")
+    testImplementation("androidx.test:core:${Version.testlib}")
+    testImplementation("androidx.test:runner:${Version.testlib}")
+    testImplementation("androidx.test:rules:${Version.testlib}")
+    testImplementation("com.google.code.gson:gson:${Version.gson}")
+    testImplementation("junit:junit:${Version.junit}")
+    testImplementation("org.mockito:mockito-core:${Version.mockito}")
+    testImplementation("org.nanohttpd:nanohttpd-webserver:${Version.nanohttpd}")
+    testImplementation("org.robolectric:robolectric:${Version.robolectric}")
+    testImplementation("org.jetbrains.kotlin:kotlin-test:${Version.kotlin}")
+    testImplementation("org.jetbrains.kotlin:kotlin-test-junit:${Version.kotlin}")
+    testImplementation("org.jetbrains.kotlin:kotlin-reflect:${Version.kotlin}")
+    testImplementation("androidx.compose.ui:ui-test:${Version.compose}")
+    testImplementation("androidx.compose.ui:ui-test-junit4:${Version.compose}")
+
+    androidTestImplementation("androidx.annotation:annotation:${Version.annotation}")
+    androidTestImplementation("androidx.test.espresso:espresso-contrib:${Version.espresso}") {
+        // Exclude transitive dependencies to limit conflicts with AndroidX libraries from AUT.
+        // Link to PR with fix and discussion https://github.com/appium/appium-espresso-driver/pull/596
+        isTransitive = false
+    }
+    androidTestImplementation("androidx.test.espresso:espresso-web:${Version.espresso}")
+    androidTestImplementation("androidx.test.uiautomator:uiautomator:${Version.uia}")
+    androidTestImplementation("androidx.test:core:${Version.testlib}")
+    androidTestImplementation("androidx.test:runner:${Version.testlib}")
+    androidTestImplementation("androidx.test:rules:${Version.testlib}")
+    androidTestImplementation("com.google.code.gson:gson:${Version.gson}")
+    androidTestImplementation("org.nanohttpd:nanohttpd-webserver:${Version.nanohttpd}")
+    androidTestImplementation("org.jetbrains.kotlin:kotlin-stdlib-jdk8:${Version.kotlin}")
+    androidTestImplementation("org.jetbrains.kotlin:kotlin-reflect:${Version.kotlin}")
+    androidTestImplementation("androidx.compose.ui:ui-test:${Version.compose}")
+    androidTestImplementation("androidx.compose.ui:ui-test-junit4:${Version.compose}"){
+        isTransitive = false
+    }
+
+    // additionalAndroidTestDependencies placeholder (don't change or delete this line)
+}
+
+tasks.withType<Test> {
+    systemProperty("skipespressoserver", "true")
+}
+
+object Version {
+    const val kotlin = "1.4.32"
+    const val espresso = "3.3.0"
+    const val testlib = "1.3.0"
+    const val mocklib = "1.7.4"
+    const val gson = "2.8.6"
+    const val uia = "2.2.0"
+    const val nanohttpd = "2.3.1"
+    const val annotation = "1.1.0"
+    const val mockito = "2.8.9"
+    const val robolectric = "4.5.1"
+    const val junit = "4.13"
+    const val compose = "1.0.0"
+}
+
+fun Project.getStringProperty(name: String, default: String): String =
+    properties.getOrDefault(name, default).toString()
+
+fun Project.getIntProperty(name: String, default: Int): Int =
+    this.getStringProperty(name, default.toString()).toInt()
+
+fun Project.getBooleanProperty(name: String, default: Boolean): Boolean =
+    this.getStringProperty(name, default.toString()).toBoolean()

package/espresso-server/app/proguard-rules.pro

@@ -0,0 +1,25 @@
+# Add project specific ProGuard rules here.
+# By default, the flags in this file are appended to flags specified
+# in ~/Library/Android/sdk/tools/proguard/proguard-android.txt
+# You can edit the include path and order by changing the proguardFiles
+# directive in build.gradle.kts.
+#
+# For more details, see
+#   http://developer.android.com/guide/developing/tools/proguard.html
+
+# Add any project specific keep options here:
+
+# If your project uses WebView with JS, uncomment the following
+# and specify the fully qualified class name to the JavaScript interface
+# class:
+#-keepclassmembers class fqcn.of.javascript.interface.for.webview {
+#   public *;
+#}
+
+# Uncomment this to preserve the line number information for
+# debugging stack traces.
+#-keepattributes SourceFile,LineNumberTable
+
+# If you keep the line number information, uncomment this to
+# hide the original source file name.
+#-renamesourcefileattribute SourceFile