nativescript 9.1.0-alpha.16 → 9.1.0-alpha.17

package/lib/common/file-system.d.ts

@@ -0,0 +1,77 @@
+import * as fs from "fs";
+import { IFileSystem, IReadFileOptions, IFsStats } from "./declarations";
+import { IInjector } from "./definitions/yok";
+export declare class FileSystem implements IFileSystem {
+    private $injector;
+    private static DEFAULT_INDENTATION_CHARACTER;
+    private static JSON_OBJECT_REGEXP;
+    constructor($injector: IInjector);
+    zipFiles(zipFile: string, files: string[], zipPathCallback: (path: string) => string): Promise<void>;
+    utimes(path: string, atime: Date, mtime: Date): void;
+    unzip(zipFile: string, destinationDir: string, options?: {
+        overwriteExisitingFiles?: boolean;
+        caseSensitive?: boolean;
+    }, fileFilters?: string[]): Promise<void>;
+    private findFileCaseInsensitive;
+    exists(path: string): boolean;
+    deleteFile(path: string): void;
+    deleteDirectory(directory: string): void;
+    deleteDirectorySafe(directory: string): void;
+    getFileSize(path: string): number;
+    getSize(path: string): number;
+    futureFromEvent(eventEmitter: any, event: string): Promise<any>;
+    createDirectory(path: string): void;
+    readDirectory(path: string): string[];
+    readFile(filename: string, options?: IReadFileOptions): string | Buffer;
+    readText(filename: string, options?: IReadFileOptions | string): string;
+    readJson(filename: string, encoding?: string): any;
+    writeFile(filename: string, data: string | Buffer, encoding?: string): void;
+    appendFile(filename: string, data: any, encoding?: string): void;
+    writeJson(filename: string, data: any, space?: string, encoding?: string): void;
+    copyFile(sourceFileName: string, destinationFileName: string): void;
+    createReadStream(path: string, options?: {
+        flags?: string;
+        encoding?: BufferEncoding;
+        fd?: number;
+        mode?: number;
+        autoClose?: boolean;
+        emitClose?: boolean;
+        start?: number;
+        end?: number;
+        highWaterMark?: number;
+    }): NodeJS.ReadableStream;
+    createWriteStream(path: string, options?: {
+        flags?: string;
+        encoding?: BufferEncoding;
+        fd?: number;
+        mode?: number;
+        autoClose?: boolean;
+        emitClose?: boolean;
+        start?: number;
+        highWaterMark?: number;
+    }): any;
+    chmod(path: string, mode: any): void;
+    getFsStats(path: string): fs.Stats;
+    getLsStats(path: string): fs.Stats;
+    getUniqueFileName(baseName: string): string;
+    isEmptyDir(directoryPath: string): boolean;
+    isRelativePath(p: string): boolean;
+    ensureDirectoryExists(directoryPath: string): void;
+    rename(oldPath: string, newPath: string): void;
+    renameIfExists(oldPath: string, newPath: string): boolean;
+    symlink(sourcePath: string, destinationPath: string, type?: fs.symlink.Type): void;
+    setCurrentUserAsOwner(path: string, owner: string): Promise<void>;
+    enumerateFilesInDirectorySync(directoryPath: string, filterCallback?: (_file: string, _stat: IFsStats) => boolean, opts?: {
+        enumerateDirectories?: boolean;
+        includeEmptyDirectories?: boolean;
+    }, foundFiles?: string[]): string[];
+    getFileShasum(fileName: string, options?: {
+        algorithm?: string;
+        encoding?: "hex" | "base64";
+    }): Promise<string>;
+    readStdin(): Promise<string>;
+    rm(options?: string, ...files: string[]): void;
+    deleteEmptyParents(directory: string): void;
+    realpath(filePath: string): string;
+    private getIndentationCharacter;
+}

package/lib/common/header.d.ts

@@ -0,0 +1 @@
+export declare function printHeader(): void;

package/lib/common/helpers.d.ts

@@ -0,0 +1,62 @@
+import * as net from "net";
+import { EventEmitter } from "events";
+import * as crypto from "crypto";
+import { IDictionary, IDeferPromise, Server, IProjectFilesConfig } from "./declarations";
+import { IAndroidSigningData } from "../definitions/build";
+export declare function stripComments(content: string): string;
+export declare function doesCurrentNpmCommandMatch(patterns?: RegExp[]): boolean;
+export declare function someWithRegExps(array: string[], patterns: RegExp[]): boolean;
+export declare function getCurrentNpmCommandArgv(): string[];
+export declare function isInstallingNativeScriptGlobally(): boolean;
+export declare function createRegExp(input: string, opts?: string): RegExp;
+export declare function regExpEscape(input: string): string;
+export declare function getShortPluginName(pluginName: string): string;
+export declare function executeActionByChunks<T>(initialData: T[] | IDictionary<T>, chunkSize: number, elementAction: (element: T, key?: string | number) => Promise<any>): Promise<void>;
+export declare function deferPromise<T>(): IDeferPromise<T>;
+export declare function settlePromises<T>(promises: Promise<T>[]): Promise<T[]>;
+export declare function getPropertyName(func: Function): string;
+export declare function quoteString(s: string): string;
+export declare function createGUID(useBraces?: boolean): string;
+export declare function stringReplaceAll(inputString: string, find: any, replace: string): string;
+export declare function isRequestSuccessful(request: Server.IRequestResponseData): boolean;
+export declare function isResponseRedirect(response: Server.IRequestResponseData): boolean;
+export declare function formatListOfNames(names: string[], conjunction?: string): string;
+export declare function getRelativeToRootPath(rootPath: string, filePath: string): string;
+export declare function setIsInteractive(override?: () => boolean): void;
+export declare function isInteractive(): boolean;
+export declare function toBoolean(str: any): boolean;
+export declare function block(operation: () => void): void;
+export declare function isNumberWithoutExponent(n: any): boolean;
+export declare function fromWindowsRelativePathToUnix(windowsRelativePath: string): string;
+export declare function isNullOrWhitespace(input: any): boolean;
+export declare function getCurrentEpochTime(): number;
+export declare function sleep(ms: number): Promise<void>;
+export declare function createTable(headers: string[], data: string[][]): any;
+export declare function getMessageWithBorders(message: string, spanLength?: number): string;
+export declare function remove<T>(array: T[], predicate: (element: T) => boolean, numberOfElements?: number): T[];
+export declare function trimSymbol(str: string, symbol: string): string;
+export declare function parseJson(data: string): any;
+export declare function getFuturesResults<T>(promises: Promise<T | T[] | T[][]>[], predicate: (element: any) => boolean): Promise<T[] | T[][]>;
+export declare function appendZeroesToVersion(version: string, requiredVersionLength: number): string;
+export declare function decorateMethod(before: (method1: any, self1: any, args1: any[]) => Promise<any>, after: (method2: any, self2: any, result2: any, args2: any[]) => Promise<any>): (target: Object, propertyKey: string, descriptor: TypedPropertyDescriptor<Function>) => void;
+export declare function hook(commandName: string): (target: Object, propertyKey: string, descriptor: TypedPropertyDescriptor<Function>) => void;
+export declare function isPromise(candidateFuture: any): boolean;
+export declare function attachAwaitDetach(eventName: string, eventEmitter: EventEmitter, eventHandler: (...args: any[]) => void, operation: Promise<any>): Promise<void>;
+export declare function connectEventually(factory: () => Promise<net.Socket>, handler: (_socket: net.Socket) => void): Promise<void>;
+export declare function getHash(str: string, options?: {
+    algorithm?: string;
+    encoding?: crypto.BinaryToTextEncoding;
+}): string;
+export declare function connectEventuallyUntilTimeout(factory: () => Promise<net.Socket>, timeout: number): Promise<net.Socket>;
+export declare function getProjectFilesConfig(opts: {
+    isReleaseBuild: boolean;
+}): IProjectFilesConfig;
+export declare function getPidFromiOSSimulatorLogs(applicationIdentifier: string, logLine: string): string;
+export declare function getValueFromNestedObject(obj: any, key: string): any;
+export declare function getWinRegPropertyValue(key: string, propertyName: string): Promise<string>;
+export declare function stringify(value: any, replacer?: (key: string, value: any) => any, space?: string | number): string;
+export declare function getFixedLengthDateString(): string;
+export declare function getFormattedDateComponent(component: number): string;
+export declare function getFormattedMilliseconds(date: Date): string;
+export declare function annotate(fn: any): any;
+export declare function hasValidAndroidSigning(signingData: Partial<IAndroidSigningData>): boolean;

package/lib/common/helpers.js

@@ -400,7 +400,7 @@ function decorateMethod(before, after) {
                 const replacementMethods = _.filter(newMethods, (f) => _.isFunction(f));
                 if (replacementMethods.length > 0) {
                     hasBeenReplaced = true;
-                    const chainedReplacementMethod = _.reduce(replacementMethods, (prev, next) => next.bind(next, args, prev), sink.bind(this));
+                    const chainedReplacementMethod = _.reduce(replacementMethods, (prev, next) => (...forwardedArgs) => next.call(next, forwardedArgs.length ? forwardedArgs : args, prev), sink.bind(this));
                     result = chainedReplacementMethod();
                 }
             }
@@ -418,7 +418,7 @@ function hook(commandName) {
     function getHooksService(self) {
         let hooksService = self.$hooksService;
         if (!hooksService) {
-            const injector = self.$injector;
+            const injector = self.$injector || require("./yok").getInjector();
             if (!injector) {
                 throw Error("Type with hooks needs to have either $hooksService or $injector injected.");
             }
@@ -439,7 +439,7 @@ function hook(commandName) {
     }
     return decorateMethod(async (method, self, args) => {
         const hooksService = getHooksService(self);
-        return hooksService.executeBeforeHooks(commandName, prepareArguments(method, args, hooksService));
+        return hooksService.executeBeforeHooks(commandName, prepareArguments(method, args, hooksService), { consumesMiddlewares: true });
     }, async (method, self, resultPromise, args) => {
         const result = await resultPromise;
         const hooksService = getHooksService(self);

package/lib/common/host-info.d.ts

@@ -0,0 +1,24 @@
+import { IHostInfo, IErrors } from "./declarations";
+import { IInjector } from "./definitions/yok";
+export declare class HostInfo implements IHostInfo {
+    private $errors;
+    private $injector;
+    private static WIN32_NAME;
+    private static PROCESSOR_ARCHITEW6432;
+    private static DARWIN_OS_NAME;
+    private static LINUX_OS_NAME;
+    private static DOT_NET_REGISTRY_PATH;
+    private get $childProcess();
+    private get $osInfo();
+    private get $logger();
+    constructor($errors: IErrors, $injector: IInjector);
+    get isWindows(): boolean;
+    get isWindows64(): boolean;
+    get isWindows32(): boolean;
+    get isDarwin(): boolean;
+    get isLinux(): boolean;
+    get isLinux64(): boolean;
+    getMacOSVersion(): Promise<string>;
+    dotNetVersion(): Promise<string>;
+    isDotNet40Installed(message?: string): Promise<boolean>;
+}

package/lib/common/http-client.d.ts

@@ -0,0 +1,14 @@
+import { Server, IProxySettings, IProxyService } from "./declarations";
+export declare class HttpClient implements Server.IHttpClient {
+    private $logger;
+    private $proxyService;
+    private $staticConfig;
+    private static STUCK_REQUEST_ERROR_MESSAGE;
+    private static STUCK_RESPONSE_ERROR_MESSAGE;
+    private defaultUserAgent;
+    constructor($logger: ILogger, $proxyService: IProxyService, $staticConfig: Config.IStaticConfig);
+    httpRequest(options: any, proxySettings?: IProxySettings): Promise<Server.IResponse>;
+    private httpRequestCore;
+    private getErrorMessage;
+    private useProxySettings;
+}

package/lib/common/http-client.js

@@ -4,6 +4,7 @@ exports.HttpClient = void 0;
 const _ = require("lodash");
 const os_1 = require("os");
 const util = require("util");
+const promises_1 = require("stream/promises");
 const yok_1 = require("./yok");
 const axios_1 = require("axios");
 const constants_1 = require("./constants");
@@ -75,7 +76,10 @@ class HttpClient {
             method: options.method,
             proxy: false,
             httpAgent: agent,
+            httpsAgent: agent,
             data: options.body,
+            responseType: options.pipeTo ? "stream" : undefined,
+            onDownloadProgress: options.onDownloadProgress,
         }).catch((err) => {
             this.$logger.trace("An error occurred while sending the request:", err);
             if (err.response) {
@@ -92,6 +96,13 @@ class HttpClient {
         });
         if (result) {
             this.$logger.trace("httpRequest: Done. code = %d", result.status.toString());
+            if (options.pipeTo) {
+                await (0, promises_1.pipeline)(result.data, options.pipeTo);
+                return {
+                    response: result,
+                    headers: result.headers,
+                };
+            }
             return {
                 response: result,
                 body: JSON.stringify(result.data),

package/lib/common/logger/appenders/cli-appender.d.ts

@@ -0,0 +1,2 @@
+import { LoggingEvent } from "log4js";
+export declare function configure(config: Log4JSAppenderConfiguration, layouts: any): (loggingEvent: LoggingEvent) => void;

package/lib/common/logger/appenders/emit-appender.d.ts

@@ -0,0 +1,5 @@
+import { LoggingEvent } from "log4js";
+export declare function configure(config: Log4JSEmitAppenderConfiguration, layouts: any): {
+    (loggingEvent: LoggingEvent): void;
+    shutdown(): void;
+};

package/lib/common/logger/layouts/cli-layout.d.ts

@@ -0,0 +1,2 @@
+import { LoggingEvent } from "log4js";
+export declare function layout(config: any): (logEvent: LoggingEvent) => string;

package/lib/common/logger/logger.d.ts

@@ -0,0 +1,24 @@
+export declare class Logger implements ILogger {
+    private $config;
+    private log4jsLogger;
+    private passwordRegex;
+    private passwordReplacement;
+    private defaultLogLevel;
+    constructor($config: Config.IConfig);
+    initialize(opts?: ILoggerOptions): void;
+    initializeCliLogger(opts?: ILoggerOptions): void;
+    getLevel(): string;
+    fatal(...args: any[]): void;
+    error(...args: any[]): void;
+    warn(...args: any[]): void;
+    info(...args: any[]): void;
+    debug(...args: any[]): void;
+    trace(...args: any[]): void;
+    prepare(item: any): string;
+    printMarkdown(...args: string[]): void;
+    isVerbose(): boolean;
+    clearScreen(): void;
+    private logMessage;
+    private getLogOptionsForMessage;
+    private getPasswordEncodedArguments;
+}

package/lib/common/messages/messages.d.ts

@@ -0,0 +1,7 @@
+export declare class Messages implements IMessages {
+    Devices: {
+        NotFoundDeviceByIdentifierErrorMessage: string;
+        NotFoundDeviceByIdentifierErrorMessageWithIdentifier: string;
+        NotFoundDeviceByIndexErrorMessage: string;
+    };
+}

package/lib/common/mobile/android/android-application-manager.d.ts

@@ -0,0 +1,31 @@
+import { ApplicationManagerBase } from "../application-manager-base";
+import { IOptions } from "../../../declarations";
+import { IAndroidBuildData } from "../../../definitions/build";
+import { IAndroidBundleToolService } from "../../../definitions/android-bundle-tool-service";
+import { IFileSystem, Server, IErrors, IHooksService, IDictionary } from "../../declarations";
+export declare class AndroidApplicationManager extends ApplicationManagerBase {
+    private adb;
+    private identifier;
+    private $androidBundleToolService;
+    private $fs;
+    private $options;
+    private $logcatHelper;
+    private $androidProcessService;
+    private $httpClient;
+    protected $deviceLogProvider: Mobile.IDeviceLogProvider;
+    private $errors;
+    PID_CHECK_INTERVAL: number;
+    PID_CHECK_TIMEOUT: number;
+    constructor(adb: Mobile.IDeviceAndroidDebugBridge, identifier: string, $androidBundleToolService: IAndroidBundleToolService, $fs: IFileSystem, $options: IOptions, $logcatHelper: Mobile.ILogcatHelper, $androidProcessService: Mobile.IAndroidProcessService, $httpClient: Server.IHttpClient, $deviceLogProvider: Mobile.IDeviceLogProvider, $errors: IErrors, $logger: ILogger, $hooksService: IHooksService);
+    getInstalledApplications(): Promise<string[]>;
+    installApplication(packageFilePath: string, appIdentifier?: string, buildData?: IAndroidBuildData): Promise<void>;
+    uninstallApplication(appIdentifier: string): Promise<void>;
+    startApplication(appData: Mobile.IStartApplicationData): Promise<void>;
+    private onAppLaunch;
+    private getAppProcessId;
+    stopApplication(appData: Mobile.IApplicationData): Promise<void>;
+    getDebuggableApps(): Promise<Mobile.IDeviceApplicationInformation[]>;
+    getDebuggableAppViews(appIdentifiers: string[]): Promise<IDictionary<Mobile.IDebugWebViewInfo[]>>;
+    private getFullyQualifiedActivityRegex;
+    private hasValidApksFile;
+}

package/lib/common/mobile/android/android-debug-bridge-result-handler.d.ts

@@ -0,0 +1,9 @@
+import { IErrors } from "../../declarations";
+export declare class AndroidDebugBridgeResultHandler implements Mobile.IAndroidDebugBridgeResultHandler {
+    private $logger;
+    private $errors;
+    private static ANDROID_DEBUG_BRIDGE_ERRORS;
+    constructor($logger: ILogger, $errors: IErrors);
+    checkForErrors(adbResult: any): Mobile.IAndroidDebugBridgeError[];
+    handleErrors(errors: Mobile.IAndroidDebugBridgeError[], treatErrorsAsWarnings?: boolean): void;
+}

package/lib/common/mobile/android/android-debug-bridge.d.ts

@@ -0,0 +1,24 @@
+import { IChildProcess, IErrors } from "../../declarations";
+interface IComposeCommandResult {
+    command: string;
+    args: string[];
+}
+export declare class AndroidDebugBridge implements Mobile.IAndroidDebugBridge {
+    protected $childProcess: IChildProcess;
+    protected $errors: IErrors;
+    protected $logger: ILogger;
+    protected $staticConfig: Config.IStaticConfig;
+    protected $androidDebugBridgeResultHandler: Mobile.IAndroidDebugBridgeResultHandler;
+    private adbFilePath;
+    constructor($childProcess: IChildProcess, $errors: IErrors, $logger: ILogger, $staticConfig: Config.IStaticConfig, $androidDebugBridgeResultHandler: Mobile.IAndroidDebugBridgeResultHandler);
+    protected init(): Promise<void>;
+    executeCommand(args: string[], options?: Mobile.IAndroidDebugBridgeCommandOptions): Promise<any>;
+    getPropertyValue(deviceId: string, propertyName: string): Promise<string>;
+    getDevices(): Promise<string[]>;
+    getDevicesSafe(): Promise<string[]>;
+    protected composeCommand(params: string[], identifier?: string): Promise<IComposeCommandResult>;
+    executeShellCommand(args: string[], options?: Mobile.IAndroidDebugBridgeCommandOptions): Promise<any>;
+    pushFile(localFilePath: string, deviceFilePath: string): Promise<void>;
+    removeFile(deviceFilePath: string): Promise<void>;
+}
+export {};

package/lib/common/mobile/android/android-device-file-system.d.ts

@@ -0,0 +1,26 @@
+import { IFileSystem, IStringDictionary } from "../../declarations";
+import { IInjector } from "../../definitions/yok";
+import { ITempService } from "../../../definitions/temp-service";
+export declare class AndroidDeviceFileSystem implements Mobile.IDeviceFileSystem {
+    private adb;
+    private $fs;
+    private $logger;
+    private $mobileHelper;
+    private $tempService;
+    private $injector;
+    private _deviceHashServices;
+    constructor(adb: Mobile.IDeviceAndroidDebugBridge, $fs: IFileSystem, $logger: ILogger, $mobileHelper: Mobile.IMobileHelper, $tempService: ITempService, $injector: IInjector);
+    listFiles(devicePath: string, appIdentifier?: string): Promise<any>;
+    getFile(deviceFilePath: string, appIdentifier: string, outputPath?: string): Promise<void>;
+    getFileContent(deviceFilePath: string, appIdentifier: string): Promise<string>;
+    putFile(localFilePath: string, deviceFilePath: string, appIdentifier: string): Promise<void>;
+    transferFiles(deviceAppData: Mobile.IDeviceAppData, localToDevicePaths: Mobile.ILocalToDevicePathData[]): Promise<Mobile.ILocalToDevicePathData[]>;
+    transferDirectory(deviceAppData: Mobile.IDeviceAppData, localToDevicePaths: Mobile.ILocalToDevicePathData[], projectFilesPath: string): Promise<Mobile.ILocalToDevicePathData[]>;
+    private chmodFiles;
+    private pushFiles;
+    transferFile(localPath: string, devicePath: string): Promise<void>;
+    createFileOnDevice(deviceFilePath: string, fileContent: string): Promise<void>;
+    deleteFile(deviceFilePath: string, appIdentifier: string): Promise<void>;
+    updateHashesOnDevice(hashes: IStringDictionary, appIdentifier: string): Promise<void>;
+    getDeviceHashService(appIdentifier: string): Mobile.IAndroidDeviceHashService;
+}

package/lib/common/mobile/android/android-device-hash-service.d.ts

@@ -0,0 +1,23 @@
+import { IFileSystem, IStringDictionary } from "../../declarations";
+import { ITempService } from "../../../definitions/temp-service";
+export declare class AndroidDeviceHashService implements Mobile.IAndroidDeviceHashService {
+    private adb;
+    private appIdentifier;
+    private $fs;
+    private $mobileHelper;
+    private $tempService;
+    private static HASH_FILE_NAME;
+    constructor(adb: Mobile.IDeviceAndroidDebugBridge, appIdentifier: string, $fs: IFileSystem, $mobileHelper: Mobile.IMobileHelper, $tempService: ITempService);
+    get hashFileDevicePath(): string;
+    doesShasumFileExistsOnDevice(): Promise<boolean>;
+    getShasumsFromDevice(): Promise<IStringDictionary>;
+    uploadHashFileToDevice(data: IStringDictionary): Promise<void>;
+    updateHashes(localToDevicePaths: Mobile.ILocalToDevicePathData[]): Promise<void>;
+    generateHashesFromLocalToDevicePaths(localToDevicePaths: Mobile.ILocalToDevicePathData[], initialShasums?: IStringDictionary): Promise<IStringDictionary>;
+    getDevicePaths(localToDevicePaths: Mobile.ILocalToDevicePathData[]): string[];
+    getChangedShasums(oldShasums: IStringDictionary, currentShasums: IStringDictionary): IStringDictionary;
+    removeHashes(localToDevicePaths: Mobile.ILocalToDevicePathData[]): Promise<boolean>;
+    private getHashFileLocalPath;
+    private getTempDir;
+    private downloadHashFileFromDevice;
+}

package/lib/common/mobile/android/android-device.d.ts

@@ -0,0 +1,24 @@
+import { IInjector } from "../../definitions/yok";
+export declare class AndroidDevice implements Mobile.IAndroidDevice {
+    private identifier;
+    private status;
+    private $androidEmulatorServices;
+    private $logger;
+    private $devicePlatformsConstants;
+    private $logcatHelper;
+    private $injector;
+    adb: Mobile.IDeviceAndroidDebugBridge;
+    applicationManager: Mobile.IDeviceApplicationManager;
+    fileSystem: Mobile.IAndroidDeviceFileSystem;
+    deviceInfo: Mobile.IDeviceInfo;
+    private static ADB_DEVICE_STATUS_INFO;
+    constructor(identifier: string, status: string, $androidEmulatorServices: Mobile.IEmulatorPlatformService, $logger: ILogger, $devicePlatformsConstants: Mobile.IDevicePlatformsConstants, $logcatHelper: Mobile.ILogcatHelper, $injector: IInjector);
+    init(): Promise<void>;
+    get isEmulator(): boolean;
+    get isOnlyWiFiConnected(): boolean;
+    openDeviceLogStream(): Promise<void>;
+    detach(): void;
+    private getDeviceDetails;
+    private getIsTablet;
+    private getType;
+}

package/lib/common/mobile/android/android-emulator-services.d.ts

@@ -0,0 +1,23 @@
+import { IChildProcess, IUserSettingsService, IUtils } from "../../declarations";
+export declare class AndroidEmulatorServices implements Mobile.IEmulatorPlatformService {
+    private $androidGenymotionService;
+    private $androidVirtualDeviceService;
+    private $adb;
+    private $childProcess;
+    private $emulatorHelper;
+    private $logger;
+    private $utils;
+    private $userSettingsService;
+    constructor($androidGenymotionService: Mobile.IAndroidVirtualDeviceService, $androidVirtualDeviceService: Mobile.IAndroidVirtualDeviceService, $adb: Mobile.IAndroidDebugBridge, $childProcess: IChildProcess, $emulatorHelper: Mobile.IEmulatorHelper, $logger: ILogger, $utils: IUtils, $userSettingsService: IUserSettingsService);
+    getEmulatorImages(): Promise<Mobile.IEmulatorImagesOutput>;
+    getRunningEmulatorIds(): Promise<string[]>;
+    getRunningEmulatorName(emulatorId: string): Promise<string>;
+    getRunningEmulatorImageIdentifier(emulatorId: string): Promise<string>;
+    startEmulator(options: Mobile.IAndroidStartEmulatorOptions): Promise<Mobile.IStartEmulatorOutput>;
+    detach(deviceInfo: Mobile.IDeviceInfo): void;
+    private startEmulatorCore;
+    private spawnEmulator;
+    private getBestFit;
+    private waitForEmulatorBootToComplete;
+    private isEmulatorBootCompleted;
+}

package/lib/common/mobile/android/android-ini-file-parser.d.ts

@@ -0,0 +1,8 @@
+import { IFileSystem } from "../../declarations";
+export declare class AndroidIniFileParser implements Mobile.IAndroidIniFileParser {
+    private $fs;
+    constructor($fs: IFileSystem);
+    parseIniFile(iniFilePath: string): Mobile.IAvdInfo;
+    private getAvdEncoding;
+    private readTargetNum;
+}

package/lib/common/mobile/android/android-log-filter.d.ts

@@ -0,0 +1,11 @@
+export declare class AndroidLogFilter implements Mobile.IPlatformLogFilter {
+    private $loggingLevels;
+    private static LINE_REGEX;
+    private static API_LEVEL_23_LINE_REGEX;
+    constructor($loggingLevels: Mobile.ILoggingLevels);
+    filterData(data: string, loggingOptions?: Mobile.IDeviceLogOptions): string;
+    getConsoleLogFromLine(lineText: string, pid: string): {
+        tag: string;
+        message: string;
+    };
+}

package/lib/common/mobile/android/android-virtual-device-service.d.ts

@@ -0,0 +1,37 @@
+import { IChildProcess, IFileSystem, IHostInfo, ISysInfo } from "../../declarations";
+export declare class AndroidVirtualDeviceService implements Mobile.IAndroidVirtualDeviceService {
+    private $androidIniFileParser;
+    private $childProcess;
+    private $devicePlatformsConstants;
+    private $emulatorHelper;
+    private $fs;
+    private $hostInfo;
+    private $sysInfo;
+    private $logger;
+    private androidHome;
+    private mapEmulatorIdToImageIdentifier;
+    constructor($androidIniFileParser: Mobile.IAndroidIniFileParser, $childProcess: IChildProcess, $devicePlatformsConstants: Mobile.IDevicePlatformsConstants, $emulatorHelper: Mobile.IEmulatorHelper, $fs: IFileSystem, $hostInfo: IHostInfo, $sysInfo: ISysInfo, $logger: ILogger);
+    getEmulatorImages(adbDevicesOutput: string[]): Promise<Mobile.IEmulatorImagesOutput>;
+    getRunningEmulatorIds(adbDevicesOutput: string[]): Promise<string[]>;
+    getRunningEmulatorName(emulatorId: string): Promise<string>;
+    startEmulatorArgs(imageIdentifier: string): string[];
+    get pathToEmulatorExecutable(): string;
+    getRunningEmulatorImageIdentifier(emulatorId: string): Promise<string>;
+    detach(deviceInfo: Mobile.IDeviceInfo): void;
+    private getEmulatorImagesCore;
+    private canExecuteAvdManagerCommand;
+    private getRunningEmulatorData;
+    private get pathToAvdManagerExecutable();
+    private get pathToAndroidExecutable();
+    private get pathToAvdHomeDir();
+    private getConfigurationError;
+    private getExecutableName;
+    private listAvdsFromDirectory;
+    private parseListAvdsOutput;
+    private getAvdManagerDeviceInfo;
+    private getInfoFromAvd;
+    private convertAvdToDeviceInfo;
+    private getImageIdentifierFromClientOutput;
+    private getIniFilePath;
+    private clearNetConnection;
+}

package/lib/common/mobile/android/device-android-debug-bridge.d.ts

@@ -0,0 +1,18 @@
+import { AndroidDebugBridge } from "./android-debug-bridge";
+import { IChildProcess, IErrors, IStringDictionary } from "../../declarations";
+interface IComposeCommandResult {
+    command: string;
+    args: string[];
+}
+export declare class DeviceAndroidDebugBridge extends AndroidDebugBridge implements Mobile.IDeviceAndroidDebugBridge {
+    private identifier;
+    protected $childProcess: IChildProcess;
+    protected $errors: IErrors;
+    protected $logger: ILogger;
+    protected $staticConfig: Config.IStaticConfig;
+    protected $androidDebugBridgeResultHandler: Mobile.IAndroidDebugBridgeResultHandler;
+    constructor(identifier: string, $childProcess: IChildProcess, $errors: IErrors, $logger: ILogger, $staticConfig: Config.IStaticConfig, $androidDebugBridgeResultHandler: Mobile.IAndroidDebugBridgeResultHandler);
+    sendBroadcastToDevice(action: string, extras?: IStringDictionary): Promise<number>;
+    protected composeCommand(params: string[]): Promise<IComposeCommandResult>;
+}
+export {};

package/lib/common/mobile/android/genymotion/genymotion-service.d.ts

@@ -0,0 +1,26 @@
+import { IChildProcess, IFileSystem } from "../../../declarations";
+export declare class AndroidGenymotionService implements Mobile.IAndroidVirtualDeviceService {
+    private $adb;
+    private $childProcess;
+    private $devicePlatformsConstants;
+    private $emulatorHelper;
+    private $fs;
+    private $logger;
+    private $virtualBoxService;
+    constructor($adb: Mobile.IAndroidDebugBridge, $childProcess: IChildProcess, $devicePlatformsConstants: Mobile.IDevicePlatformsConstants, $emulatorHelper: Mobile.IEmulatorHelper, $fs: IFileSystem, $logger: ILogger, $virtualBoxService: Mobile.IVirtualBoxService);
+    getEmulatorImages(adbDevicesOutput: string[]): Promise<Mobile.IEmulatorImagesOutput>;
+    getRunningEmulatorIds(adbDevicesOutput: string[]): Promise<string[]>;
+    get pathToEmulatorExecutable(): string;
+    startEmulatorArgs(imageIdentifier: string): string[];
+    private getEmulatorImagesCore;
+    getRunningEmulatorName(emulatorId: string): Promise<string>;
+    getRunningEmulatorImageIdentifier(emulatorId: string): Promise<string>;
+    private getRunningEmulatorData;
+    private get playerSearchPaths();
+    private parseListVmsOutput;
+    private convertToDeviceInfo;
+    private getSdkVersion;
+    private isGenymotionEmulator;
+    private getConfigurationPlatformSpecficErrorMessage;
+    private getConfigurationError;
+}

package/lib/common/mobile/android/genymotion/virtualbox-service.d.ts

@@ -0,0 +1,13 @@
+import { IChildProcess, IFileSystem, IHostInfo } from "../../../declarations";
+export declare class VirtualBoxService implements Mobile.IVirtualBoxService {
+    private $childProcess;
+    private $fs;
+    private $hostInfo;
+    private $logger;
+    constructor($childProcess: IChildProcess, $fs: IFileSystem, $hostInfo: IHostInfo, $logger: ILogger);
+    listVms(): Promise<Mobile.IVirtualBoxListVmsOutput>;
+    enumerateGuestProperties(id: string): Promise<Mobile.IVirtualBoxEnumerateGuestPropertiesOutput>;
+    private getvBoxManageSearchPaths;
+    private get vBoxManageExecutableNames();
+    private getvBoxManagePath;
+}

package/lib/common/mobile/android/logcat-helper.d.ts

@@ -0,0 +1,17 @@
+import { IInjector } from "../../definitions/yok";
+export declare class LogcatHelper implements Mobile.ILogcatHelper {
+    private $deviceLogProvider;
+    private $devicePlatformsConstants;
+    private $logger;
+    private $injector;
+    private $devicesService;
+    private mapDevicesLoggingData;
+    constructor($deviceLogProvider: Mobile.IDeviceLogProvider, $devicePlatformsConstants: Mobile.IDevicePlatformsConstants, $logger: ILogger, $injector: IInjector, $devicesService: Mobile.IDevicesService);
+    start(options: Mobile.ILogcatStartOptions): Promise<void>;
+    dump(deviceIdentifier: string): Promise<void>;
+    stop(deviceIdentifier: string): void;
+    private forceStop;
+    private isLogcatPidSupported;
+    private getLogcatStream;
+    private getAppStartTrackingLogcatStream;
+}

package/lib/common/mobile/application-manager-base.d.ts

@@ -0,0 +1,27 @@
+import { EventEmitter } from "events";
+import { IBuildData } from "../../definitions/build";
+import { IDictionary, IHooksService } from "../declarations";
+export declare abstract class ApplicationManagerBase extends EventEmitter implements Mobile.IDeviceApplicationManager {
+    protected $logger: ILogger;
+    protected $hooksService: IHooksService;
+    protected $deviceLogProvider: Mobile.IDeviceLogProvider;
+    private lastInstalledAppIdentifiers;
+    private lastAvailableDebuggableApps;
+    private lastAvailableDebuggableAppViews;
+    constructor($logger: ILogger, $hooksService: IHooksService, $deviceLogProvider: Mobile.IDeviceLogProvider);
+    setTransferredAppFiles(files: string[]): Promise<void>;
+    reinstallApplication(appIdentifier: string, packageFilePath: string, buildData?: IBuildData): Promise<void>;
+    restartApplication(appData: Mobile.IApplicationData): Promise<void>;
+    isApplicationInstalled(appIdentifier: string): Promise<boolean>;
+    private checkForApplicationUpdatesPromise;
+    checkForApplicationUpdates(): Promise<void>;
+    tryStartApplication(appData: Mobile.IApplicationData): Promise<void>;
+    abstract installApplication(packageFilePath: string, appIdentifier?: string, buildData?: IBuildData): Promise<void>;
+    abstract uninstallApplication(appIdentifier: string): Promise<void>;
+    abstract startApplication(appData: Mobile.IApplicationData): Promise<void>;
+    abstract stopApplication(appData: Mobile.IApplicationData): Promise<void>;
+    abstract getInstalledApplications(): Promise<string[]>;
+    abstract getDebuggableApps(): Promise<Mobile.IDeviceApplicationInformation[]>;
+    abstract getDebuggableAppViews(appIdentifiers: string[]): Promise<IDictionary<Mobile.IDebugWebViewInfo[]>>;
+    private checkForAvailableDebuggableAppsChanges;
+}

package/lib/common/mobile/device-emitter.d.ts

@@ -0,0 +1,8 @@
+import { EventEmitter } from "events";
+export declare class DeviceEmitter extends EventEmitter {
+    private $deviceLogProvider;
+    private $devicesService;
+    constructor($deviceLogProvider: EventEmitter, $devicesService: Mobile.IDevicesService);
+    initialize(): void;
+    private attachApplicationChangedHandlers;
+}