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

package/lib/services/ios/xcodebuild-command-service.d.ts

@@ -0,0 +1,17 @@
+import { ISpawnResult, IErrors, IChildProcess } from "../../common/declarations";
+export declare class XcodebuildCommandService implements IXcodebuildCommandService {
+    private $childProcess;
+    private $errors;
+    private $logger;
+    constructor($childProcess: IChildProcess, $errors: IErrors, $logger: ILogger);
+    executeCommand(args: string[], options: {
+        cwd: string;
+        stdio?: string;
+        message?: string;
+        spawnOptions?: any;
+        onProgress?: (chunk: {
+            data: string;
+            pipe: string;
+        }) => void;
+    }): Promise<ISpawnResult>;
+}

package/lib/services/ios/xcodebuild-service.d.ts

@@ -0,0 +1,13 @@
+import { IPlatformData } from "../../definitions/platform";
+import { IProjectData, IBuildConfig } from "../../definitions/project";
+export declare class XcodebuildService implements IXcodebuildService {
+    private $exportOptionsPlistService;
+    private $xcodebuildArgsService;
+    private $xcodebuildCommandService;
+    constructor($exportOptionsPlistService: IExportOptionsPlistService, $xcodebuildArgsService: IXcodebuildArgsService, $xcodebuildCommandService: IXcodebuildCommandService);
+    buildForDevice(platformData: IPlatformData, projectData: IProjectData, buildConfig: IBuildConfig): Promise<string>;
+    buildForSimulator(platformData: IPlatformData, projectData: IProjectData, buildConfig: IBuildConfig): Promise<void>;
+    buildForAppStore(platformData: IPlatformData, projectData: IProjectData, buildConfig: IBuildConfig): Promise<string>;
+    private createDevelopmentArchive;
+    private createDistributionArchive;
+}

package/lib/services/ios-debugger-port-service.d.ts

@@ -0,0 +1,20 @@
+import { IiOSNotification } from "../declarations";
+export declare class IOSDebuggerPortService implements IIOSDebuggerPortService {
+    private $logParserService;
+    private $iOSNotification;
+    private $devicePlatformsConstants;
+    private $logger;
+    static DEBUG_PORT_LOG_REGEX: RegExp;
+    private mapDebuggerPortData;
+    private currentAppId;
+    constructor($logParserService: ILogParserService, $iOSNotification: IiOSNotification, $devicePlatformsConstants: Mobile.IDevicePlatformsConstants, $logger: ILogger);
+    getPort(data: IIOSDebuggerPortInputData): Promise<number>;
+    attachToDebuggerPortFoundEvent(appId: string): Promise<void>;
+    private attachToDebuggerPortFoundEventCore;
+    private handleAppCrash;
+    private handlePortFound;
+    private attachToAttachRequestEvent;
+    private getPortByKey;
+    private setData;
+    private clearTimeout;
+}

package/lib/services/ios-device-debug-service.d.ts

@@ -0,0 +1,29 @@
+import { DebugServiceBase } from "./debug-service-base";
+import { IDeviceDebugService, IDebugOptions, IDebugResultInfo, IDebugData } from "../definitions/debug";
+import { IPackageInstallationManager, IAppDebugSocketProxyFactory } from "../declarations";
+import { IProjectDataService } from "../definitions/project";
+import { IChildProcess, IHostInfo, IErrors } from "../common/declarations";
+export declare class IOSDeviceDebugService extends DebugServiceBase implements IDeviceDebugService {
+    protected device: Mobile.IiOSDevice;
+    protected $devicesService: Mobile.IDevicesService;
+    private $childProcess;
+    private $hostInfo;
+    private $logger;
+    private $errors;
+    private $packageInstallationManager;
+    private $appDebugSocketProxyFactory;
+    private $projectDataService;
+    private deviceIdentifier;
+    constructor(device: Mobile.IiOSDevice, $devicesService: Mobile.IDevicesService, $childProcess: IChildProcess, $hostInfo: IHostInfo, $logger: ILogger, $errors: IErrors, $packageInstallationManager: IPackageInstallationManager, $appDebugSocketProxyFactory: IAppDebugSocketProxyFactory, $projectDataService: IProjectDataService);
+    get platform(): string;
+    debug(debugData: IDebugData, debugOptions: IDebugOptions): Promise<IDebugResultInfo>;
+    debugStop(): Promise<void>;
+    private validateOptions;
+    private validateUSBConnectedDevice;
+    private getProjectName;
+    private killProcess;
+    private wireDebuggerClient;
+    private setupWebAppDebugProxy;
+    private setupTcpAppDebugProxy;
+    private openAppInspector;
+}

package/lib/services/ios-entitlements-service.d.ts

@@ -0,0 +1,19 @@
+import { IPluginsService } from "../definitions/plugins";
+import { IProjectData } from "../definitions/project";
+import { IFileSystem } from "../common/declarations";
+import { IOptions } from "../declarations";
+export declare class IOSEntitlementsService {
+    private $options;
+    private $fs;
+    private $logger;
+    private $devicePlatformsConstants;
+    private $mobileHelper;
+    private $pluginsService;
+    constructor($options: IOptions, $fs: IFileSystem, $logger: ILogger, $devicePlatformsConstants: Mobile.IDevicePlatformsConstants, $mobileHelper: Mobile.IMobileHelper, $pluginsService: IPluginsService);
+    static readonly DefaultEntitlementsName: string;
+    private getDefaultAppEntitlementsPath;
+    getPlatformsEntitlementsPath(projectData: IProjectData): string;
+    getPlatformsEntitlementsRelativePath(projectData: IProjectData): string;
+    merge(projectData: IProjectData): Promise<void>;
+    private getAllInstalledPlugins;
+}

package/lib/services/ios-entitlements-service.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.IOSEntitlementsService = void 0;
 const path = require("path");
-const plist_merge_patch_1 = require("plist-merge-patch");
+const plist_session_1 = require("../tools/plist-merge/plist-session");
 const yok_1 = require("../common/yok");
 class IOSEntitlementsService {
     constructor($options, $fs, $logger, $devicePlatformsConstants, $mobileHelper, $pluginsService) {
@@ -29,7 +29,7 @@ class IOSEntitlementsService {
         return path.join(projectData.projectName, projectData.projectName + ".entitlements");
     }
     async merge(projectData) {
-        const session = new plist_merge_patch_1.PlistSession({
+        const session = new plist_session_1.PlistSession({
             log: (txt) => this.$logger.trace("App.entitlements: " + txt),
         });
         const projectDir = projectData.projectDir;
@@ -53,7 +53,7 @@ class IOSEntitlementsService {
         if (this.$fs.exists(appEntitlementsPath)) {
             makePatch(appEntitlementsPath);
         }
-        if (session.patches && session.patches.length > 0) {
+        if (session.hasPatches) {
             const plistContent = session.build();
             this.$logger.trace("App.entitlements: Write to: " +
                 this.getPlatformsEntitlementsPath(projectData));

package/lib/services/ios-extensions-service.d.ts

@@ -0,0 +1,12 @@
+import { IIOSNativeTargetService, IIOSExtensionsService, IAddExtensionsFromPathOptions, IRemoveExtensionsOptions } from "../definitions/project";
+import { IFileSystem } from "../common/declarations";
+export declare class IOSExtensionsService implements IIOSExtensionsService {
+    protected $fs: IFileSystem;
+    protected $pbxprojDomXcode: IPbxprojDomXcode;
+    protected $xcode: IXcode;
+    private $iOSNativeTargetService;
+    constructor($fs: IFileSystem, $pbxprojDomXcode: IPbxprojDomXcode, $xcode: IXcode, $iOSNativeTargetService: IIOSNativeTargetService);
+    addExtensionsFromPath({ extensionsFolderPath, projectData, platformData, pbxProjPath, }: IAddExtensionsFromPathOptions): Promise<boolean>;
+    private configureTarget;
+    removeExtensions({ pbxProjPath }: IRemoveExtensionsOptions): void;
+}

package/lib/services/ios-log-filter.d.ts

@@ -0,0 +1,11 @@
+export declare class IOSLogFilter implements Mobile.IPlatformLogFilter {
+    private $loggingLevels;
+    private appOutputRegex;
+    protected infoFilterRegex: RegExp;
+    protected postFilterRegex: RegExp;
+    private filterActive;
+    private partialLine;
+    constructor($loggingLevels: Mobile.ILoggingLevels);
+    filterData(data: string, loggingOptions?: Mobile.IDeviceLogOptions): string;
+    private preFilter;
+}

package/lib/services/ios-native-target-service.d.ts

@@ -0,0 +1,14 @@
+import { IIOSNativeTargetService, IProjectData, IXcodeTargetBuildConfigurationProperty } from "../definitions/project";
+import { IPlatformData } from "../definitions/platform";
+import { IFileSystem } from "../common/declarations";
+export declare class IOSNativeTargetService implements IIOSNativeTargetService {
+    protected $fs: IFileSystem;
+    protected $pbxprojDomXcode: IPbxprojDomXcode;
+    protected $logger: ILogger;
+    constructor($fs: IFileSystem, $pbxprojDomXcode: IPbxprojDomXcode, $logger: ILogger);
+    addTargetToProject(targetRootPath: string, targetFolder: string, targetType: string, project: IXcode.project, platformData: IPlatformData, parentTarget?: string): IXcode.target;
+    prepareSigning(targetUuids: string[], projectData: IProjectData, projectPath: string): void;
+    getTargetDirectories(folderPath: string): string[];
+    setXcodeTargetBuildConfigurationProperties(properties: IXcodeTargetBuildConfigurationProperty[], targetName: string, project: IXcode.project): void;
+    setConfigurationsFromJsonFile(jsonPath: string, targetUuid: string, targetName: string, project: IXcode.project): void;
+}

package/lib/services/ios-project-service.d.ts

@@ -0,0 +1,108 @@
+import * as projectServiceBaseLib from "./platform-project-service-base";
+import { IOSProvisionService } from "./ios-provision-service";
+import { IOSEntitlementsService } from "./ios-entitlements-service";
+import { IOSBuildData } from "../data/build-data";
+import { IOSPrepareData } from "../data/prepare-data";
+import { IPlatformData, IPlatformEnvironmentRequirements } from "../definitions/platform";
+import { IProjectData, ICocoaPodsService, IProjectDataService, IIOSExtensionsService, IIOSWatchAppService, IIOSNativeTargetService, IValidatePlatformOutput, IProjectConfigService } from "../definitions/project";
+import { IXcprojService, IXcconfigService, IDependencyData, IOptions } from "../declarations";
+import { IPluginData } from "../definitions/plugins";
+import { IFileSystem, IChildProcess, IErrors, IHostInfo, IPlistParser, ISysInfo, IRelease } from "../common/declarations";
+import { IInjector } from "../common/definitions/yok";
+import { INotConfiguredEnvOptions } from "../common/definitions/commands";
+import { IProjectChangesInfo } from "../definitions/project-changes";
+import { ITempService } from "../definitions/temp-service";
+export declare const DevicePlatformSdkName = "iphoneos";
+export declare const SimulatorPlatformSdkName = "iphonesimulator";
+export declare const VisionDevicePlatformSdkName = "xros";
+export declare const VisionSimulatorPlatformSdkName = "xrsimulator";
+export declare class IOSProjectService extends projectServiceBaseLib.PlatformProjectServiceBase {
+    private $options;
+    private $childProcess;
+    private $cocoapodsService;
+    private $errors;
+    private $logger;
+    private $injector;
+    private $devicePlatformsConstants;
+    private $hostInfo;
+    private $xcprojService;
+    private $iOSProvisionService;
+    private $iOSSigningService;
+    private $pbxprojDomXcode;
+    private $xcode;
+    private $iOSEntitlementsService;
+    private $platformEnvironmentRequirements;
+    private $plistParser;
+    private $xcconfigService;
+    private $xcodebuildService;
+    private $iOSExtensionsService;
+    private $iOSWatchAppService;
+    private $iOSNativeTargetService;
+    private $sysInfo;
+    private $tempService;
+    private $spmService;
+    private $mobileHelper;
+    private $projectConfigService;
+    private static IOS_PROJECT_NAME_PLACEHOLDER;
+    private static IOS_PLATFORM_NAME;
+    private static GENERATED_PLUGINS_DIR_NAME;
+    constructor($fs: IFileSystem, $options: IOptions, $childProcess: IChildProcess, $cocoapodsService: ICocoaPodsService, $errors: IErrors, $logger: ILogger, $injector: IInjector, $projectDataService: IProjectDataService, $devicePlatformsConstants: Mobile.IDevicePlatformsConstants, $hostInfo: IHostInfo, $xcprojService: IXcprojService, $iOSProvisionService: IOSProvisionService, $iOSSigningService: IiOSSigningService, $pbxprojDomXcode: IPbxprojDomXcode, $xcode: IXcode, $iOSEntitlementsService: IOSEntitlementsService, $platformEnvironmentRequirements: IPlatformEnvironmentRequirements, $plistParser: IPlistParser, $xcconfigService: IXcconfigService, $xcodebuildService: IXcodebuildService, $iOSExtensionsService: IIOSExtensionsService, $iOSWatchAppService: IIOSWatchAppService, $iOSNativeTargetService: IIOSNativeTargetService, $sysInfo: ISysInfo, $tempService: ITempService, $spmService: ISPMService, $mobileHelper: Mobile.IMobileHelper, $projectConfigService: IProjectConfigService);
+    private _platformsDirCache;
+    private _platformOverrideCache;
+    private _platformData;
+    getPlatformData(projectData: IProjectData): IPlatformData;
+    validateOptions(projectId: string, provision: true | string, teamId: true | string): Promise<boolean>;
+    getAppResourcesDestinationDirectoryPath(projectData: IProjectData): string;
+    validate(projectData: IProjectData, options: IOptions, notConfiguredEnvOptions?: INotConfiguredEnvOptions): Promise<IValidatePlatformOutput>;
+    createProject(frameworkDir: string, frameworkVersion: string, projectData: IProjectData): Promise<void>;
+    interpolateData(projectData: IProjectData): Promise<void>;
+    interpolateConfigurationFile(projectData: IProjectData): void;
+    cleanProject(projectRoot: string, projectData: IProjectData): Promise<void>;
+    afterCreateProject(projectRoot: string, projectData: IProjectData): void;
+    buildProject(projectRoot: string, projectData: IProjectData, buildData: IOSBuildData): Promise<void>;
+    isPlatformPrepared(projectRoot: string, projectData: IProjectData): boolean;
+    cleanDeviceTempFolder(deviceIdentifier: string): Promise<void>;
+    private isDynamicFramework;
+    private _addedFrameworks;
+    clearFrameworksCache(): void;
+    private addFramework;
+    private _addedStaticLibs;
+    private addStaticLibrary;
+    prepareProject(projectData: IProjectData, prepareData: IOSPrepareData): Promise<void>;
+    prepareAppResources(projectData: IProjectData): void;
+    processConfigurationFilesFromAppResources(projectData: IProjectData, opts: IRelease): Promise<void>;
+    ensureConfigurationFileInAppResources(): void;
+    private mergeInfoPlists;
+    private getAllProductionPlugins;
+    private replace;
+    private getLibSubpathRelativeToProjectPath;
+    private getPbxProjPath;
+    private createPbxProj;
+    private savePbxProj;
+    preparePluginNativeCode(pluginData: IPluginData, projectData: IProjectData, opts?: any): Promise<void>;
+    shouldRepreparePlugin(pluginData: IPluginData, projectData: IProjectData): boolean;
+    removePluginNativeCode(pluginData: IPluginData, projectData: IProjectData): Promise<void>;
+    handleNativeDependenciesChange(projectData: IProjectData, opts: IRelease): Promise<void>;
+    beforePrepareAllPlugins(projectData: IProjectData, dependencies?: IDependencyData[]): Promise<IDependencyData[]>;
+    checkForChanges(changesInfo: IProjectChangesInfo, prepareData: IOSPrepareData, projectData: IProjectData): Promise<void>;
+    getDeploymentTarget(projectData: IProjectData): string;
+    private setProductBundleIdentifier;
+    private getAllLibsForPluginWithFileExtension;
+    private validateFramework;
+    private replaceFileContent;
+    private replaceFileName;
+    private prepareNativeSourceCode;
+    private addExtensions;
+    private getRootGroup;
+    private prepareResources;
+    private prepareFrameworks;
+    private prepareStaticLibs;
+    private removeNativeSourceCode;
+    private removeFrameworks;
+    private removeStaticLibs;
+    private generateModulemap;
+    private mergeProjectXcconfigFiles;
+    private getBuildXCConfigFilePath;
+    private validateApplicationIdentifier;
+    private applyPluginsCocoaPods;
+}

package/lib/services/ios-project-service.js

@@ -15,7 +15,7 @@ const constants_1 = require("../common/constants");
 const helpers = require("../common/helpers");
 const helpers_1 = require("../common/helpers");
 const projectServiceBaseLib = require("./platform-project-service-base");
-const plist_merge_patch_1 = require("plist-merge-patch");
+const plist_session_1 = require("../tools/plist-merge/plist-session");
 const os_1 = require("os");
 const plist = require("plist");
 const fastGlob = require("fast-glob");
@@ -450,7 +450,7 @@ class IOSProjectService extends projectServiceBaseLib.PlatformProjectServiceBase
             log: (txt) => this.$logger.trace(`${reporterTraceMessage} ${txt}`),
             warn: (txt) => this.$logger.warn(`${reporterTraceMessage} ${txt}`),
         };
-        const session = new plist_merge_patch_1.PlistSession(reporter);
+        const session = new plist_session_1.PlistSession(reporter);
         const makePatch = (plistPath) => {
             if (!this.$fs.exists(plistPath)) {
                 this.$logger.trace("No plist found at: " + plistPath);

package/lib/services/ios-provision-service.d.ts

@@ -0,0 +1,18 @@
+import * as mobileprovision from "ios-mobileprovision-finder";
+import { IOptions } from "../declarations";
+export declare class IOSProvisionService {
+    private $logger;
+    private $options;
+    private $devicesService;
+    private $mobileHelper;
+    constructor($logger: ILogger, $options: IOptions, $devicesService: Mobile.IDevicesService, $mobileHelper: Mobile.IMobileHelper);
+    pick(uuidOrName: string, projectId: string): Promise<mobileprovision.provision.MobileProvision>;
+    listProvisions(projectId: string): Promise<void>;
+    listTeams(): Promise<void>;
+    private queryProvisioningProfilesAndDevices;
+    getDevelopmentTeams(): Promise<{
+        id: string;
+        name: string;
+    }[]>;
+    getTeamIdsWithName(teamName: string): Promise<string[]>;
+}

package/lib/services/ios-watch-app-service.d.ts

@@ -0,0 +1,39 @@
+import { IIOSWatchAppService, IIOSNativeTargetService, IAddWatchAppFromPathOptions, IRemoveWatchAppOptions, IProjectData } from "../definitions/project";
+import { IPlatformData } from "../definitions/platform";
+import { IFileSystem } from "../common/declarations";
+export declare class IOSWatchAppService implements IIOSWatchAppService {
+    protected $fs: IFileSystem;
+    protected $pbxprojDomXcode: IPbxprojDomXcode;
+    protected $xcode: IXcode;
+    private $iOSNativeTargetService;
+    private $logger;
+    private $spmPbxprojService;
+    constructor($fs: IFileSystem, $pbxprojDomXcode: IPbxprojDomXcode, $xcode: IXcode, $iOSNativeTargetService: IIOSNativeTargetService, $logger: ILogger, $spmPbxprojService: ISPMPbxprojService);
+    private addResourceFile;
+    private addSourceFile;
+    addWatchAppFromPath({ watchAppFolderPath, projectData, platformData, pbxProjPath, disableStubBinary, }: IAddWatchAppFromPathOptions): Promise<boolean>;
+    private addTarget;
+    private addSourceFilesFromDirectory;
+    private addTargetResources;
+    private addResourcesFromDirectory;
+    removeWatchApp({ pbxProjPath }: IRemoveWatchAppOptions): void;
+    hasWatchApp(platformData: IPlatformData, projectData: IProjectData): boolean;
+    private configureTarget;
+    private applyWatchAppStubBinaryOverrides;
+    private processWatchAppConfiguration;
+    private addCustomResource;
+    private addCustomSourceFile;
+    private resolvePathWithBasedir;
+    private addAllSourceFilesFromDirectory;
+    private addAllResourcesRecursively;
+    private addModuleDependency;
+    private addCompiledFramework;
+    private getFolderFiles;
+    addBuildPhaseIfNotExisting(project: IXcode.project, buildPhaseType: string, comment: string, target: string): void;
+    private addFolderModule;
+    private addLinkerFlags;
+    private getBuildProperty;
+    private shouldExclude;
+    private applySPMPackagesToTargets;
+    private getWatchSPMPackages;
+}

package/lib/services/ios-watch-app-service.js

@@ -4,7 +4,6 @@ exports.IOSWatchAppService = void 0;
 const path = require("path");
 const constants_1 = require("../constants");
 const yok_1 = require("../common/yok");
-const trapezedev_project_1 = require("@nstudio/trapezedev-project");
 const minimatch_1 = require("minimatch");
 const sourceExtensions = [
     ".swift",
@@ -54,12 +53,13 @@ const RESOURCES_TO_IGNORE = [
     "node_modules",
 ];
 class IOSWatchAppService {
-    constructor($fs, $pbxprojDomXcode, $xcode, $iOSNativeTargetService, $logger) {
+    constructor($fs, $pbxprojDomXcode, $xcode, $iOSNativeTargetService, $logger, $spmPbxprojService) {
         this.$fs = $fs;
         this.$pbxprojDomXcode = $pbxprojDomXcode;
         this.$xcode = $xcode;
         this.$iOSNativeTargetService = $iOSNativeTargetService;
         this.$logger = $logger;
+        this.$spmPbxprojService = $spmPbxprojService;
     }
     addResourceFile(project, path, opt, group = "WatchResources") {
         const file = project.addResourceFile(path, opt, group);
@@ -626,27 +626,20 @@ class IOSWatchAppService {
                 return;
             }
             this.$logger.debug(`Applying ${watchSPMPackages.length} SPM package(s) to targets:${targetNames}`);
-            const project = new trapezedev_project_1.MobileProject(platformData.projectRoot, {
-                ios: {
-                    path: ".",
-                },
-                enableAndroid: false,
-            });
-            await project.load();
-            if (!project.ios) {
-                this.$logger.debug("No iOS project found via trapeze");
-                return;
-            }
+            const assignments = [];
             for (const pkg of watchSPMPackages) {
                 if ("path" in pkg) {
                     pkg.path = path.resolve(basedir, pkg.path);
                 }
                 this.$logger.debug(`Adding SPM package ${JSON.stringify(pkg)} to targets ${targetNames}`);
                 for (const targetName of targetNames) {
-                    project.ios.addSPMPackage(targetName, pkg);
+                    assignments.push({ targetName, package: pkg });
                 }
             }
-            await project.commit();
+            if (!this.$spmPbxprojService.addPackages(platformData.projectRoot, assignments)) {
+                this.$logger.debug(`No SPM packages were applied to targets ${targetNames}`);
+                return;
+            }
             this.$logger.debug(`Successfully applied SPM packages to targets ${targetNames}`);
         }
         catch (err) {

package/lib/services/ip-service.d.ts

@@ -0,0 +1,10 @@
+import { Server } from "../common/declarations";
+export declare class IPService implements IIPService {
+    private $httpClient;
+    private $logger;
+    private static GET_IP_TIMEOUT;
+    constructor($httpClient: Server.IHttpClient, $logger: ILogger);
+    getCurrentIPv4Address(): Promise<string>;
+    private getIPAddressFromServiceReturningJSONWithIPProperty;
+    private getIPAddressFromIpifyOrgAPI;
+}

package/lib/services/itmstransporter-service.d.ts

@@ -0,0 +1,26 @@
+import { IITMSTransporterService, IITMSData } from "../declarations";
+import { IChildProcess, IErrors, IFileSystem, IPlistParser, IXcodeSelectService } from "../common/declarations";
+import { IApplePortalApplicationService } from "./apple-portal/definitions";
+import { IInjector } from "../common/definitions/yok";
+import { ITempService } from "../definitions/temp-service";
+export declare class ITMSTransporterService implements IITMSTransporterService {
+    private $applePortalApplicationService;
+    private $childProcess;
+    private $errors;
+    private $fs;
+    private $injector;
+    private $logger;
+    private $plistParser;
+    private $xcodeSelectService;
+    private $tempService;
+    constructor($applePortalApplicationService: IApplePortalApplicationService, $childProcess: IChildProcess, $errors: IErrors, $fs: IFileSystem, $injector: IInjector, $logger: ILogger, $plistParser: IPlistParser, $xcodeSelectService: IXcodeSelectService, $tempService: ITempService);
+    private get $projectData();
+    validate(appSpecificPassword?: string): Promise<void>;
+    upload(data: IITMSData): Promise<void>;
+    upload_iTMSTransporter(data: IITMSData): Promise<void>;
+    upload_altool(data: IITMSData): Promise<void>;
+    private getBundleIdentifier;
+    private getAltoolPath;
+    private getITMSTransporterPath;
+    private getITMSMetadataXml;
+}

package/lib/services/karma-execution.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/services/livesync/android-device-livesync-service-base.d.ts

@@ -0,0 +1,19 @@
+import { DeviceLiveSyncServiceBase } from "./device-livesync-service-base";
+import { IPlatformsDataService } from "../../definitions/platform";
+import { IProjectData } from "../../definitions/project";
+import { IFilesHashService } from "../../definitions/files-hash-service";
+import { IInjector } from "../../common/definitions/yok";
+export declare abstract class AndroidDeviceLiveSyncServiceBase extends DeviceLiveSyncServiceBase {
+    protected $injector: IInjector;
+    protected $platformsDataService: IPlatformsDataService;
+    protected $filesHashService: IFilesHashService;
+    protected $logger: ILogger;
+    protected device: Mobile.IAndroidDevice;
+    constructor($injector: IInjector, $platformsDataService: IPlatformsDataService, $filesHashService: IFilesHashService, $logger: ILogger, device: Mobile.IAndroidDevice);
+    abstract transferFilesOnDevice(deviceAppData: Mobile.IDeviceAppData, localToDevicePaths: Mobile.ILocalToDevicePathData[]): Promise<void>;
+    abstract transferDirectoryOnDevice(deviceAppData: Mobile.IDeviceAppData, localToDevicePaths: Mobile.ILocalToDevicePathData[], projectFilesPath: string): Promise<void>;
+    transferFiles(deviceAppData: Mobile.IDeviceAppData, localToDevicePaths: Mobile.ILocalToDevicePathData[], projectFilesPath: string, projectData: IProjectData, liveSyncDeviceDescriptor: ILiveSyncDeviceDescriptor, options: ITransferFilesOptions): Promise<Mobile.ILocalToDevicePathData[]>;
+    private transferFilesCore;
+    private getLocalToDevicePathsToTransfer;
+    private getChangedLocalToDevicePaths;
+}

package/lib/services/livesync/android-device-livesync-service.d.ts

@@ -0,0 +1,24 @@
+import { AndroidDeviceLiveSyncServiceBase } from "./android-device-livesync-service-base";
+import { IPlatformsDataService } from "../../definitions/platform";
+import { IProjectData } from "../../definitions/project";
+import { IFilesHashService } from "../../definitions/files-hash-service";
+import { IInjector } from "../../common/definitions/yok";
+export declare class AndroidDeviceLiveSyncService extends AndroidDeviceLiveSyncServiceBase implements IAndroidNativeScriptDeviceLiveSyncService, INativeScriptDeviceLiveSyncService {
+    private $mobileHelper;
+    private $devicePathProvider;
+    private $androidProcessService;
+    protected platformsDataService: IPlatformsDataService;
+    protected device: Mobile.IAndroidDevice;
+    private port;
+    constructor($mobileHelper: Mobile.IMobileHelper, $devicePathProvider: IDevicePathProvider, $injector: IInjector, $androidProcessService: Mobile.IAndroidProcessService, platformsDataService: IPlatformsDataService, device: Mobile.IAndroidDevice, $filesHashService: IFilesHashService, $logger: ILogger);
+    transferFilesOnDevice(deviceAppData: Mobile.IDeviceAppData, localToDevicePaths: Mobile.ILocalToDevicePathData[]): Promise<void>;
+    transferDirectoryOnDevice(deviceAppData: Mobile.IDeviceAppData, localToDevicePaths: Mobile.ILocalToDevicePathData[], projectFilesPath: string): Promise<void>;
+    restartApplication(projectData: IProjectData, liveSyncInfo: ILiveSyncResultInfo): Promise<void>;
+    shouldRestart(projectData: IProjectData, liveSyncInfo: IAndroidLiveSyncResultInfo): Promise<boolean>;
+    tryRefreshApplication(projectData: IProjectData, liveSyncInfo: ILiveSyncResultInfo): Promise<boolean>;
+    private cleanLivesyncDirectories;
+    beforeLiveSyncAction(deviceAppData: Mobile.IDeviceAppData): Promise<void>;
+    private reloadApplicationFiles;
+    removeFiles(deviceAppData: Mobile.IDeviceAppData, localToDevicePaths: Mobile.ILocalToDevicePathData[]): Promise<void>;
+    private awaitRuntimeReloadSuccessMessage;
+}

package/lib/services/livesync/android-device-livesync-sockets-service.d.ts

@@ -0,0 +1,36 @@
+import { AndroidDeviceLiveSyncServiceBase } from "./android-device-livesync-service-base";
+import { IProjectData } from "../../definitions/project";
+import { IPlatformsDataService } from "../../definitions/platform";
+import { IOptions } from "../../declarations";
+import { IFileSystem } from "../../common/declarations";
+import { IFilesHashService } from "../../definitions/files-hash-service";
+import { IInjector } from "../../common/definitions/yok";
+import { ICleanupService } from "../../definitions/cleanup-service";
+import { ITempService } from "../../definitions/temp-service";
+export declare class AndroidDeviceSocketsLiveSyncService extends AndroidDeviceLiveSyncServiceBase implements IAndroidNativeScriptDeviceLiveSyncService, INativeScriptDeviceLiveSyncService {
+    private data;
+    protected platformsDataService: IPlatformsDataService;
+    protected $staticConfig: Config.IStaticConfig;
+    protected device: Mobile.IAndroidDevice;
+    private $options;
+    private $cleanupService;
+    private $fs;
+    private $devicePlatformsConstants;
+    private $tempService;
+    private livesyncTool;
+    private static STATUS_UPDATE_INTERVAL;
+    private static MINIMAL_VERSION_LONG_LIVING_CONNECTION;
+    constructor(data: IProjectData, $injector: IInjector, platformsDataService: IPlatformsDataService, $staticConfig: Config.IStaticConfig, $logger: ILogger, device: Mobile.IAndroidDevice, $options: IOptions, $cleanupService: ICleanupService, $fs: IFileSystem, $devicePlatformsConstants: Mobile.IDevicePlatformsConstants, $tempService: ITempService, $filesHashService: IFilesHashService);
+    beforeLiveSyncAction(deviceAppData: Mobile.IDeviceAppData): Promise<void>;
+    private getPathToLiveSyncFileOnDevice;
+    finalizeSync(liveSyncInfo: ILiveSyncResultInfo, projectData: IProjectData): Promise<IAndroidLivesyncSyncOperationResult>;
+    private getCleanupCommand;
+    private doSync;
+    restartApplication(projectData: IProjectData, liveSyncInfo: ILiveSyncResultInfo): Promise<void>;
+    shouldRestart(projectData: IProjectData, liveSyncInfo: IAndroidLiveSyncResultInfo): Promise<boolean>;
+    tryRefreshApplication(projectData: IProjectData, liveSyncInfo: IAndroidLiveSyncResultInfo): Promise<boolean>;
+    removeFiles(deviceAppData: Mobile.IDeviceAppData, localToDevicePaths: Mobile.ILocalToDevicePathData[], projectFilesPath: string): Promise<void>;
+    transferFilesOnDevice(deviceAppData: Mobile.IDeviceAppData, localToDevicePaths: Mobile.ILocalToDevicePathData[]): Promise<void>;
+    transferDirectoryOnDevice(deviceAppData: Mobile.IDeviceAppData, localToDevicePaths: Mobile.ILocalToDevicePathData[], projectFilesPath: string): Promise<void>;
+    private connectLivesyncTool;
+}

package/lib/services/livesync/android-livesync-service.d.ts

@@ -0,0 +1,16 @@
+import { PlatformLiveSyncServiceBase } from "./platform-livesync-service-base";
+import { IPlatformsDataService } from "../../definitions/platform";
+import { IProjectFilesManager, IFileSystem, IProjectDir } from "../../common/declarations";
+import { IInjector } from "../../common/definitions/yok";
+import { IOptions } from "../../declarations";
+export declare class AndroidLiveSyncService extends PlatformLiveSyncServiceBase implements IPlatformLiveSyncService {
+    protected $platformsDataService: IPlatformsDataService;
+    protected $projectFilesManager: IProjectFilesManager;
+    private $injector;
+    private static MIN_SOCKETS_LIVESYNC_RUNTIME_VERSION;
+    constructor($platformsDataService: IPlatformsDataService, $projectFilesManager: IProjectFilesManager, $injector: IInjector, $devicePathProvider: IDevicePathProvider, $fs: IFileSystem, $logger: ILogger, $options: IOptions);
+    protected _getDeviceLiveSyncService(device: Mobile.IDevice, data: IProjectDir, frameworkVersion: string): INativeScriptDeviceLiveSyncService;
+    liveSyncWatchAction(device: Mobile.IDevice, liveSyncInfo: ILiveSyncWatchInfo): Promise<IAndroidLiveSyncResultInfo>;
+    fullSync(syncInfo: IFullSyncInfo): Promise<IAndroidLiveSyncResultInfo>;
+    private finalizeSync;
+}

package/lib/services/livesync/android-livesync-tool.d.ts

@@ -0,0 +1,58 @@
+import { IErrors, IFileSystem } from "../../common/declarations";
+import { IInjector } from "../../common/definitions/yok";
+export declare class AndroidLivesyncTool implements IAndroidLivesyncTool {
+    private $androidProcessService;
+    private $errors;
+    private $fs;
+    private $logger;
+    private $mobileHelper;
+    private $injector;
+    static DELETE_FILE_OPERATION: number;
+    static CREATE_FILE_OPERATION: number;
+    static DO_SYNC_OPERATION: number;
+    static ERROR_REPORT: number;
+    static OPERATION_END_REPORT: number;
+    static OPERATION_END_NO_REFRESH_REPORT_CODE: number;
+    static DO_REFRESH: number;
+    static SKIP_REFRESH: number;
+    static APP_IDENTIFIER_MISSING_ERROR: string;
+    static APP_PLATFORMS_PATH_MISSING_ERROR: string;
+    static SOCKET_CONNECTION_ALREADY_EXISTS_ERROR: string;
+    static SOCKET_CONNECTION_TIMED_OUT_ERROR: string;
+    static NO_SOCKET_CONNECTION_AVAILABLE_ERROR: string;
+    protocolVersion: string;
+    private operationPromises;
+    private socketError;
+    private socketConnection;
+    private configuration;
+    private pendingConnectionData;
+    constructor($androidProcessService: Mobile.IAndroidProcessService, $errors: IErrors, $fs: IFileSystem, $logger: ILogger, $mobileHelper: Mobile.IMobileHelper, $injector: IInjector);
+    connect(configuration: IAndroidLivesyncToolConfiguration): Promise<void>;
+    sendFile(filePath: string): Promise<void>;
+    sendFiles(filePaths: string[]): Promise<void>;
+    sendDirectory(directoryPath: string): Promise<void>;
+    removeFile(filePath: string): Promise<void>;
+    removeFiles(files: string[]): Promise<void>;
+    generateOperationIdentifier(): string;
+    isOperationInProgress(operationId: string): boolean;
+    sendDoSyncOperation(options?: IDoSyncOperationOptions): Promise<IAndroidLivesyncSyncOperationResult>;
+    end(error?: Error): void;
+    hasConnection(): boolean;
+    private sendFileHeader;
+    private sendFileContent;
+    private createSocket;
+    private checkConnectionStatus;
+    private verifyActiveConnection;
+    private handleConnection;
+    private connectEventuallyUntilTimeout;
+    private handleData;
+    private handleSyncEnd;
+    private handleSocketClose;
+    private handleSocketError;
+    private cleanState;
+    private rejectPendingSyncOperations;
+    private getErrorWithMessage;
+    private getFilePathData;
+    private resolveRelativePath;
+    private writeToSocket;
+}

package/lib/services/livesync/device-livesync-service-base.d.ts

@@ -0,0 +1,13 @@
+import { IPlatformsDataService } from "../../definitions/platform";
+import { IProjectData } from "../../definitions/project";
+export declare abstract class DeviceLiveSyncServiceBase {
+    protected platformsDataService: IPlatformsDataService;
+    protected device: Mobile.IDevice;
+    private static FAST_SYNC_FILE_EXTENSIONS;
+    constructor(platformsDataService: IPlatformsDataService, device: Mobile.IDevice);
+    canExecuteFastSync(liveSyncResult: ILiveSyncResultInfo, filePath: string, projectData: IProjectData, platform: string): boolean;
+    protected canExecuteFastSyncForPaths(liveSyncResult: ILiveSyncResultInfo, localToDevicePaths: Mobile.ILocalToDevicePathData[], projectData: IProjectData, platform: string): boolean;
+    private getFastLiveSyncFileExtensions;
+    transferFiles(deviceAppData: Mobile.IDeviceAppData, localToDevicePaths: Mobile.ILocalToDevicePathData[], projectFilesPath: string, projectData: IProjectData, liveSyncDeviceDescriptor: ILiveSyncDeviceDescriptor, options: ITransferFilesOptions): Promise<Mobile.ILocalToDevicePathData[]>;
+    finalizeSync(liveSyncInfo: ILiveSyncResultInfo, projectData: IProjectData): Promise<IAndroidLivesyncSyncOperationResult>;
+}