nativescript 9.1.0-alpha.15 → 9.1.0-alpha.17

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",
@@ -23,26 +22,26 @@ const resourceExtensions = [
     ".jpeg",
     ".gif",
     ".svg",
-    ".pdf", // Images
+    ".pdf",
     ".ttf",
     ".otf",
     ".woff",
-    ".woff2", // Fonts
-    ".xcassets", // Asset catalogs
+    ".woff2",
+    ".xcassets",
     ".storyboard",
-    ".xib", // Interface files
+    ".xib",
     ".strings",
-    ".stringsdict", // Localization
+    ".stringsdict",
     ".json",
     ".xml",
-    ".plist", // Data files
+    ".plist",
     ".m4a",
     ".mp3",
     ".wav",
-    ".caf", // Audio
+    ".caf",
     ".mp4",
-    ".mov", // Video
-    ".bundle", // Resource bundles
+    ".mov",
+    ".bundle",
 ];
 const WATCH_APP_IDENTIFIER = "watchkitapp";
 const WACTCH_EXTENSION_IDENTIFIER = "watchkitextension";
@@ -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);
@@ -76,7 +76,6 @@ class IOSWatchAppService {
         const appPath = path.join(watchAppFolderPath, constants_1.IOS_WATCHAPP_FOLDER);
         const extensionPath = path.join(watchAppFolderPath, constants_1.IOS_WATCHAPP_EXTENSION_FOLDER);
         const hasWatchExtension = this.$fs.exists(extensionPath);
-        // Check if watchapp exists - it's required
         if (!this.$fs.exists(appPath)) {
             return false;
         }
@@ -95,7 +94,6 @@ class IOSWatchAppService {
         await this.configureTarget(appFolder, path.join(appPath, appFolder), `${projectData.projectIdentifiers.ios}.${WATCH_APP_IDENTIFIER}`, configPath, config, watchApptarget, project, projectData, platformData, pbxProjPath, !hasWatchExtension);
         targetUuids.push(watchApptarget.uuid);
         targetNames.push(appFolder);
-        // Extension is optional (Xcode 14+ supports single target)
         if (hasWatchExtension) {
             const extensionFolder = this.$iOSNativeTargetService.getTargetDirectories(extensionPath)[0];
             const configPath = path.join(path.join(extensionPath, extensionFolder), "extension.json");
@@ -114,10 +112,8 @@ class IOSWatchAppService {
             this.$logger.debug("No watch extension found - using single target mode (Xcode 14+)");
         }
         this.$fs.writeFile(pbxProjPath, project.writeSync({ omitEmptyValues: true }));
-        // Add SPM packages (file needs to be saved first)
         const watchSPMPackages = this.getWatchSPMPackages(platformData);
         await this.applySPMPackagesToTargets(targetNames, platformData, projectData.projectDir, watchSPMPackages);
-        // nothing done after we dont need to reload project
         this.$iOSNativeTargetService.prepareSigning(targetUuids, projectData, pbxProjPath);
         if (disableStubBinary) {
             this.applyWatchAppStubBinaryOverrides(appFolder, pbxProjPath);
@@ -128,7 +124,6 @@ class IOSWatchAppService {
         const targetPath = path.join(targetRootPath, targetFolder);
         const targetRelativePath = path.relative(platformData.projectRoot, targetPath);
         const target = project.addTarget(targetFolder, targetType, targetRelativePath, parentTarget, productTargetType);
-        // Add build phases
         project.addBuildPhase([], "PBXSourcesBuildPhase", "Sources", target.uuid);
         project.addBuildPhase([], "PBXResourcesBuildPhase", "Resources", target.uuid);
         project.addBuildPhase([], "PBXFrameworksBuildPhase", "Frameworks", target.uuid);
@@ -136,14 +131,10 @@ class IOSWatchAppService {
         project.addToHeaderSearchPaths(targetPath, target.pbxNativeTarget.productName);
         return target;
     }
-    /**
-     * Recursively add source files from a directory to a target
-     */
     addSourceFilesFromDirectory(dirPath, targetUuid, project, platformData, groupName, excludePatterns) {
         const items = this.getFolderFiles(dirPath, platformData.projectRoot, excludePatterns);
         for (const item of items) {
             const relativePath = path.relative(platformData.projectRoot, item);
-            // Check if file is a source file by extension
             const ext = path.extname(item).toLowerCase();
             if (sourceExtensions.includes(ext)) {
                 this.$logger.debug(`Adding source file: ${relativePath}`);
@@ -166,38 +157,30 @@ class IOSWatchAppService {
             this.$logger.warn(`Error adding watch app resources: ${err.message}`);
         }
     }
-    /**
-     * Recursively add resources from a directory to a target
-     */
     addResourcesFromDirectory(dirPath, targetUuid, project, platformData, groupName, excludePatterns) {
         const items = this.$fs.readDirectory(dirPath);
         for (const item of items) {
-            // Skip hidden files and excluded files/directories
             if (item.startsWith(".") || RESOURCES_TO_IGNORE.indexOf(item) !== -1) {
                 continue;
             }
             const itemPath = path.join(dirPath, item);
             const stats = this.$fs.getFsStats(itemPath);
             const relativePath = path.relative(platformData.projectRoot, itemPath);
-            // Check if file/directory should be excluded based on patterns
             if (excludePatterns &&
                 this.shouldExclude(relativePath, excludePatterns)) {
                 this.$logger.debug(`Excluding from resources: ${relativePath}`);
                 continue;
             }
             if (stats.isDirectory()) {
-                // Special handling for .xcassets, .bundle, and other resource bundles
                 if (item.endsWith(".xcassets") || item.endsWith(".bundle")) {
                     this.$logger.debug(`Adding resource bundle: ${relativePath}`);
                     this.addResourceFile(project, relativePath, { target: targetUuid }, groupName);
                 }
                 else {
-                    // Recursively scan subdirectories
                     this.addResourcesFromDirectory(itemPath, targetUuid, project, platformData, groupName, excludePatterns);
                 }
             }
             else {
-                // Check if file is a resource by extension
                 const ext = path.extname(item).toLowerCase();
                 if (resourceExtensions.includes(ext)) {
                     this.$logger.debug(`Adding resource file: ${relativePath}`);
@@ -221,7 +204,6 @@ class IOSWatchAppService {
         const identifierParts = identifier.split(".");
         identifierParts.pop();
         const wkAppBundleIdentifier = identifierParts.join(".");
-        // Build configuration properties
         const buildConfigProperties = [
             { name: "PRODUCT_BUNDLE_IDENTIFIER", value: identifier },
             { name: "SDKROOT", value: "watchos" },
@@ -257,7 +239,6 @@ class IOSWatchAppService {
         }
         const resourcesExclude = (config === null || config === void 0 ? void 0 : config.resourcesExclude) || [];
         const srcExclude = (config === null || config === void 0 ? void 0 : config.srcExclude) || [];
-        // Handle custom Info.plist path
         if (config === null || config === void 0 ? void 0 : config.infoPlistPath) {
             const infoPlistPath = path.resolve(basedir, config.infoPlistPath);
             if (this.$fs.exists(infoPlistPath)) {
@@ -272,7 +253,6 @@ class IOSWatchAppService {
                 this.$logger.warn(`Custom Info.plist not found at: ${infoPlistPath}`);
             }
         }
-        // Handle custom xcprivacy file path
         if (config === null || config === void 0 ? void 0 : config.xcprivacyPath) {
             const xcprivacyPath = path.resolve(basedir, config.xcprivacyPath);
             if (this.$fs.exists(xcprivacyPath)) {
@@ -294,7 +274,6 @@ class IOSWatchAppService {
             await this.addTargetResources(path.dirname(configPath), [target.uuid], project, platformData, resourcesGroup, resourcesExclude);
         }
         if (config) {
-            // Process additional configurations
             await this.processWatchAppConfiguration(config, basedir, targetName, target, project, projectData, platformData, pbxProjPath, srcExclude, resourcesExclude);
         }
     }
@@ -309,7 +288,6 @@ class IOSWatchAppService {
     }
     async processWatchAppConfiguration(config, basedir, targetName, target, project, projectData, platformData, pbxProjPath, srcExclude, resourcesExclude) {
         this.$logger.debug(`processWatchAppConfiguration ${JSON.stringify(config)}`);
-        // Handle custom resources
         if (config.resources && Array.isArray(config.resources)) {
             this.$logger.debug(`Processing ${config.resources.length} custom resource(s) for watch target: ${targetName}`);
             for (const resourcePath of config.resources) {
@@ -323,8 +301,6 @@ class IOSWatchAppService {
             }
         }
         if (config.SPMPackages && Array.isArray(config.SPMPackages)) {
-            // to be able to add SPM the file needs to be saved
-            // but it means we need to reload it again after spm packages addition
             this.$fs.writeFile(pbxProjPath, project.writeSync({ omitEmptyValues: true }));
             await this.applySPMPackagesToTargets([targetName], platformData, basedir, config.SPMPackages);
             project.parseSync();
@@ -394,7 +370,6 @@ class IOSWatchAppService {
         const items = this.getFolderFiles(dirPath, platformData.projectRoot, excludePatterns);
         for (const item of items) {
             const relativePath = path.relative(platformData.projectRoot, item);
-            // Check if file is a source file by extension
             const ext = path.extname(item).toLowerCase();
             if (sourceExtensions.includes(ext)) {
                 this.$logger.debug(`Adding source file: ${relativePath}`);
@@ -417,7 +392,6 @@ class IOSWatchAppService {
                 return;
             }
             if (stats.isDirectory()) {
-                // Special handling for .xcassets, .bundle - add as bundles, not recursively
                 if (item.endsWith(".xcassets") || item.endsWith(".bundle")) {
                     this.$logger.debug(`Adding resource bundle: ${relativePath} for target:${targetUuid}`);
                     this.addResourceFile(project, relativePath, { target: targetUuid }, groupName);
@@ -446,11 +420,9 @@ class IOSWatchAppService {
         const isFolder = stats.isDirectory() && !isFramework;
         this.$logger.debug(`Adding module dependency: ${JSON.stringify(moduleDef)} to ${targetName}, basedir:${basedir}, isFramework:${isFramework} isFolder:${isFolder}`);
         if (isFramework) {
-            // Handle compiled frameworks (xcframework, framework)
             this.addCompiledFramework(moduleDef, relativePath, targetName, target, project);
         }
         else if (isFolder) {
-            // Handle folder-based modules
             await this.addFolderModule(moduleDef, modulePath, relativePath, targetName, target, config, project, basedir, srcExclude, resourcesExclude, projectData, platformData);
         }
         else {
@@ -474,7 +446,7 @@ class IOSWatchAppService {
         project.addFramework(relativePath, {
             target: target.uuid,
             customFramework: true,
-            embed: moduleDef.embed !== false, // Default to true
+            embed: moduleDef.embed !== false,
         });
         const frameworkDir = path.dirname(relativePath);
         project.addBuildProperty("FRAMEWORK_SEARCH_PATHS", `"$(inherited)" "${frameworkDir}"`, null, targetName);
@@ -524,7 +496,6 @@ class IOSWatchAppService {
             explicitFileType: "wrapper.framework",
             ...otherProps,
         });
-        // Add build phases
         project.addBuildPhase([], "PBXSourcesBuildPhase", "Sources", moduleTarget.uuid);
         project.addBuildPhase([], "PBXResourcesBuildPhase", "Resources", moduleTarget.uuid);
         project.addBuildPhase([], "PBXFrameworksBuildPhase", "Frameworks", moduleTarget.uuid);
@@ -582,8 +553,6 @@ class IOSWatchAppService {
             }
         }
         if (moduleDef.SPMPackages && Array.isArray(moduleDef.SPMPackages)) {
-            // to be able to add SPM the file needs to be saved
-            // but it means we need to reload it again after spm packages addition
             this.$fs.writeFile(project.filepath, project.writeSync({ omitEmptyValues: true }));
             await this.applySPMPackagesToTargets([moduleName], platformData, basedir, moduleDef.SPMPackages.map((t) => {
                 if (typeof t === "string") {
@@ -606,9 +575,6 @@ class IOSWatchAppService {
         }
         this.$logger.debug(`Added folder-based module ${moduleName} at ${relativePath}`);
     }
-    /**
-     * Add linker flags to a target's build settings
-     */
     addLinkerFlags(flags, targetName, project) {
         for (const flag of flags) {
             const currentFlags = this.getBuildProperty("OTHER_LDFLAGS", targetName, project);
@@ -624,11 +590,7 @@ class IOSWatchAppService {
             this.$logger.debug(`Added linker flag: ${flag}`);
         }
     }
-    /**
-     * Get build property value for a specific target
-     */
     getBuildProperty(propertyName, targetName, project) {
-        // Access the project hash to read build settings
         const projectHash = project.hash;
         if (!projectHash) {
             return null;
@@ -648,9 +610,6 @@ class IOSWatchAppService {
         }
         return null;
     }
-    /**
-     * Check if a path should be excluded based on glob patterns
-     */
     shouldExclude(filePath, excludePatterns) {
         for (const pattern of excludePatterns) {
             const matcher = new minimatch_1.Minimatch(pattern, { dot: true });
@@ -660,9 +619,6 @@ class IOSWatchAppService {
         }
         return false;
     }
-    /**
-     * Apply SPM packages to watch app targets
-     */
     async applySPMPackagesToTargets(targetNames, platformData, basedir, watchSPMPackages) {
         try {
             this.$logger.debug(`applySPMPackagesToTargets ${JSON.stringify(watchSPMPackages)}`);
@@ -670,44 +626,31 @@ 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;
-            }
-            // Add SPM packages to each watch target
+            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) {
             this.$logger.debug(`Error applying SPM packages to targets ${targetNames} "`, err);
         }
     }
-    /**
-     * Get SPM packages configured for watch app targets
-     */
     getWatchSPMPackages(platformData) {
         const $projectConfigService = yok_1.injector.resolve("projectConfigService");
-        // Check for watch-specific SPM packages in config
         const watchPackages = $projectConfigService.getValue(`${platformData.platformNameLowerCase}.watchApp.SPMPackages`, []);
         return watchPackages;
     }
 }
 exports.IOSWatchAppService = IOSWatchAppService;
 yok_1.injector.register("iOSWatchAppService", IOSWatchAppService);
-//# sourceMappingURL=ios-watch-app-service.js.map

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/ip-service.js

@@ -38,7 +38,6 @@ class IPService {
         return ipAddress;
     }
     async getIPAddressFromIpifyOrgAPI() {
-        // https://www.ipify.org/
         const ipifyOrgAPIEndpoint = "https://api.ipify.org";
         let ipAddress = null;
         try {
@@ -62,4 +61,3 @@ __decorate([
     (0, decorators_1.cache)()
 ], IPService.prototype, "getCurrentIPv4Address", null);
 yok_1.injector.register("ipService", IPService);
-//# sourceMappingURL=ip-service.js.map

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/itmstransporter-service.js

@@ -191,4 +191,3 @@ __decorate([
     (0, decorators_1.cache)()
 ], ITMSTransporterService.prototype, "getITMSTransporterPath", null);
 yok_1.injector.register("itmsTransporterService", ITMSTransporterService);
-//# sourceMappingURL=itmstransporter-service.js.map

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

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

package/lib/services/karma-execution.js

@@ -9,10 +9,8 @@ process.on("message", (data) => {
         });
         const KarmaServer = require(path.join(pathToKarma, "lib/server"));
         const karma = new KarmaServer(data.karmaConfig, (exitCode) => {
-            // Exit with the correct exit code and signal the manager process.
             process.exit(exitCode);
         });
         karma.start();
     }
 });
-//# sourceMappingURL=karma-execution.js.map

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-base.js

@@ -49,4 +49,3 @@ class AndroidDeviceLiveSyncServiceBase extends device_livesync_service_base_1.De
     }
 }
 exports.AndroidDeviceLiveSyncServiceBase = AndroidDeviceLiveSyncServiceBase;
-//# sourceMappingURL=android-device-livesync-service-base.js.map

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-service.js

@@ -97,7 +97,6 @@ class AndroidDeviceLiveSyncService extends android_device_livesync_service_base_
         ]);
         const regex = new RegExp(`^-.*${deviceRootBasename}$`, "m");
         const matchingFile = (listResult || "").match(regex);
-        // Check if there is already a file with deviceRootBasename. If so, delete it as it breaks LiveSyncing.
         if (matchingFile && matchingFile[0] && _.startsWith(matchingFile[0], "-")) {
             await this.device.adb.executeShellCommand(["rm", "-f", deviceRootPath]);
         }
@@ -173,4 +172,3 @@ __decorate([
 __decorate([
     (0, decorators_1.performanceLog)()
 ], AndroidDeviceLiveSyncService.prototype, "removeFiles", null);
-//# sourceMappingURL=android-device-livesync-service.js.map

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-device-livesync-sockets-service.js

@@ -95,8 +95,6 @@ class AndroidDeviceSocketsLiveSyncService extends android_device_livesync_servic
                 await this.$cleanupService.removeCleanupCommand(cleanupCommand);
             };
             await this.$cleanupService.addCleanupCommand(cleanupCommand);
-            // We need to clear resources when the action fails
-            // But we also need the real result of the action.
             await doSyncPromise.then(actionOnEnd.bind(this), actionOnEnd.bind(this));
             result = await doSyncPromise;
         }
@@ -166,4 +164,3 @@ class AndroidDeviceSocketsLiveSyncService extends android_device_livesync_servic
 exports.AndroidDeviceSocketsLiveSyncService = AndroidDeviceSocketsLiveSyncService;
 AndroidDeviceSocketsLiveSyncService.STATUS_UPDATE_INTERVAL = 10000;
 AndroidDeviceSocketsLiveSyncService.MINIMAL_VERSION_LONG_LIVING_CONNECTION = "0.2.0";
-//# sourceMappingURL=android-device-livesync-sockets-service.js.map

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-service.js

@@ -53,4 +53,3 @@ __decorate([
     (0, decorators_1.performanceLog)()
 ], AndroidLiveSyncService.prototype, "fullSync", null);
 yok_1.injector.register("androidLiveSyncService", AndroidLiveSyncService);
-//# sourceMappingURL=android-livesync-service.js.map

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/android-livesync-tool.js

@@ -140,12 +140,9 @@ class AndroidLivesyncTool {
             error =
                 error ||
                     this.getErrorWithMessage("Socket connection ended before sync operation is complete.");
-            //remove listeners and delete this.socketConnection
             this.cleanState(socketUid);
-            //call end of the connection (close and error callbacks won't be called - listeners removed)
             socket.end();
             socket.destroy();
-            //reject all pending sync requests and clear timeouts
             this.rejectPendingSyncOperations(socketUid, error);
         }
     }
@@ -407,4 +404,3 @@ AndroidLivesyncTool.SOCKET_CONNECTION_ALREADY_EXISTS_ERROR = "Socket connection
 AndroidLivesyncTool.SOCKET_CONNECTION_TIMED_OUT_ERROR = "Socket connection timed out.";
 AndroidLivesyncTool.NO_SOCKET_CONNECTION_AVAILABLE_ERROR = "No socket connection available.";
 yok_1.injector.register("androidLivesyncTool", AndroidLivesyncTool);
-//# sourceMappingURL=android-livesync-tool.js.map

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>;
+}