Delete AndroidAppIdentifier

Author: Dimitar Kerezov

lib/bootstrap.ts

@@ -104,10 +104,10 @@ $injector.require("androidToolsInfo", "./android-tools-info");
 $injector.requireCommand("platform|clean", "./commands/platform-clean");
 
 $injector.require("liveSyncService", "./services/livesync/livesync-service"); // The name is used in https://github.com/NativeScript/nativescript-dev-typescript
+$injector.require("androidLiveSyncService", "./services/livesync/android-livesync-service");
+$injector.require("iOSLiveSyncService", "./services/livesync/ios-livesync-service");
 $injector.require("usbLiveSyncService", "./services/livesync/livesync-service"); // The name is used in https://github.com/NativeScript/nativescript-dev-typescript
 $injector.require("iosLiveSyncServiceLocator", "./services/livesync/ios-device-livesync-service");
-$injector.require("androidLiveSyncServiceLocator", "./services/livesync/android-device-livesync-service");
-
 $injector.require("sysInfo", "./sys-info");
 
 $injector.require("iOSNotificationService", "./services/ios-notification-service");

lib/constants.ts

@@ -66,7 +66,9 @@ class ItunesConnectApplicationTypesClass implements IiTunesConnectApplicationTyp
 }
 
 export const ItunesConnectApplicationTypes = new ItunesConnectApplicationTypesClass();
-
+export const SYNC_DIR_NAME = "sync";
+export const REMOVEDSYNC_DIR_NAME = "removedsync";
+export const FULLSYNC_DIR_NAME = "fullsync";
 export const ANGULAR_NAME = "angular";
 export const TYPESCRIPT_NAME = "typescript";
 export const BUILD_OUTPUT_EVENT_NAME = "buildOutput";

lib/definitions/livesync.d.ts

@@ -163,6 +163,7 @@ interface ILiveSyncResultInfo {
 interface IFullSyncInfo {
 projectData: IProjectData;
 device: Mobile.IDevice;
+watch: boolean;
 syncAllFiles: boolean;
 useLiveEdit?: boolean;
 }
@@ -194,3 +195,12 @@ interface INativeScriptDeviceLiveSyncService extends IDeviceLiveSyncServiceBase
  */
 removeFiles(appIdentifier: string, localToDevicePaths: Mobile.ILocalToDevicePathData[], projectId: string): Promise<void>;
 }
+
+interface IAndroidNativeScriptDeviceLiveSyncService {
+/**
+ * Retrieves the android device's hash service.
+ * @param {string} appIdentifier Application identifier.
+ * @return {Promise<Mobile.IAndroidDeviceHashService>} The hash service
+ */
+getDeviceHashService(appIdentifier: string): Mobile.IAndroidDeviceHashService;
+}

lib/providers/device-app-data-provider.ts

@@ -1,10 +1,5 @@
 import * as deviceAppDataBaseLib from "../common/mobile/device-app-data/device-app-data-base";
 import * as path from "path";
-import { AndroidDeviceHashService } from "../common/mobile/android/android-device-hash-service";
-import { DeviceAndroidDebugBridge } from "../common/mobile/android/device-android-debug-bridge";
-
-const SYNC_DIR_NAME = "sync";
-const FULLSYNC_DIR_NAME = "fullsync";
 
 export class IOSAppIdentifier extends deviceAppDataBaseLib.DeviceAppDataBase implements Mobile.IDeviceAppData {
 private static DEVICE_PROJECT_ROOT_PATH = "Library/Application Support/LiveSync/app";
@@ -43,46 +38,11 @@ export class IOSAppIdentifier extends deviceAppDataBaseLib.DeviceAppDataBase imp
 }
 }
 
-export class AndroidAppIdentifier extends deviceAppDataBaseLib.DeviceAppDataBase implements Mobile.IDeviceAppData {
-constructor(_appIdentifier: string,
-public device: Mobile.IDevice,
-public platform: string,
-private $options: IOptions,
-private $injector: IInjector) {
-super(_appIdentifier);
-}
-
-private _deviceProjectRootPath: string;
-
-public async getDeviceProjectRootPath(): Promise<string> {
-if (!this._deviceProjectRootPath) {
-let syncFolderName = await this.getSyncFolderName();
-this._deviceProjectRootPath = `/data/local/tmp/${this.appIdentifier}/${syncFolderName}`;
-}
-
-return this._deviceProjectRootPath;
-}
-
-public async isLiveSyncSupported(): Promise<boolean> {
-return true;
-}
-
-private async getSyncFolderName(): Promise<string> {
-let adb = this.$injector.resolve(DeviceAndroidDebugBridge, { identifier: this.device.deviceInfo.identifier });
-let deviceHashService: AndroidDeviceHashService = this.$injector.resolve(AndroidDeviceHashService, { adb: adb, appIdentifier: this.appIdentifier });
-let hashFile = this.$options.force ? null : await deviceHashService.doesShasumFileExistsOnDevice();
-return this.$options.watch || hashFile ? SYNC_DIR_NAME : FULLSYNC_DIR_NAME;
-}
-}
-
 export class DeviceAppDataProvider implements Mobile.IDeviceAppDataProvider {
 public createFactoryRules(): IDictionary<Mobile.IDeviceAppDataFactoryRule> {
 return {
 iOS: {
 vanilla: IOSAppIdentifier
-},
-Android: {
-vanilla: AndroidAppIdentifier
 }
 };
 }

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

@@ -1,13 +1,14 @@
 import { DeviceAndroidDebugBridge } from "../../common/mobile/android/device-android-debug-bridge";
 import { AndroidDeviceHashService } from "../../common/mobile/android/android-device-hash-service";
 import * as helpers from "../../common/helpers";
+import { SYNC_DIR_NAME, FULLSYNC_DIR_NAME, REMOVEDSYNC_DIR_NAME } from "../../constants";
 import { cache } from "../../common/decorators";
 import * as path from "path";
 import * as net from "net";
 import { EOL } from "os";
 
-export class AndroidLiveSyncService implements INativeScriptDeviceLiveSyncService {
-private static FAST_SYNC_FILE_EXTENSIONS = [".css", ".xml", ".html"];
+export class AndroidDeviceLiveSyncService implements IAndroidNativeScriptDeviceLiveSyncService {
+private static FAST_SYNC_FILE_EXTENSIONS = [".css", ".xml", ".html"];
 
 private static BACKEND_PORT = 18182;
 private device: Mobile.IAndroidDevice;
@@ -37,7 +38,7 @@ export class AndroidLiveSyncService implements INativeScriptDeviceLiveSyncServic
 `/data/local/tmp/${deviceAppData.appIdentifier}/sync`]
 );
 
-let canExecuteFastSync = ! liveSyncInfo.isFullSync && !_.some(localToDevicePaths,
+let canExecuteFastSync = !liveSyncInfo.isFullSync && !_.some(localToDevicePaths,
 (localToDevicePath: Mobile.ILocalToDevicePathData) => !this.canExecuteFastSync(localToDevicePath.getLocalPath(), projectData, this.device.deviceInfo.platform));
 
 if (canExecuteFastSync) {
@@ -50,7 +51,7 @@ export class AndroidLiveSyncService implements INativeScriptDeviceLiveSyncServic
 @cache()
 private getFastLiveSyncFileExtensions(platform: string, projectData: IProjectData): string[] {
 const platformData = this.$platformsData.getPlatformData(platform, projectData);
-const fastSyncFileExtensions = AndroidLiveSyncService.FAST_SYNC_FILE_EXTENSIONS.concat(platformData.fastLivesyncFileExtensions);
+const fastSyncFileExtensions = AndroidDeviceLiveSyncService.FAST_SYNC_FILE_EXTENSIONS.concat(platformData.fastLivesyncFileExtensions);
 return fastSyncFileExtensions;
 }
 
@@ -87,13 +88,13 @@ export class AndroidLiveSyncService implements INativeScriptDeviceLiveSyncServic
 await this.device.adb.executeShellCommand(["rm", "-f", deviceRootPath]);
 }
 
-this.device.adb.executeShellCommand(["rm", "-rf", this.$mobileHelper.buildDevicePath(deviceRootPath, "fullsync"),
-this.$mobileHelper.buildDevicePath(deviceRootPath, "sync"),
-await this.$mobileHelper.buildDevicePath(deviceRootPath, "removedsync")]);
+this.device.adb.executeShellCommand(["rm", "-rf", this.$mobileHelper.buildDevicePath(deviceRootPath, FULLSYNC_DIR_NAME),
+this.$mobileHelper.buildDevicePath(deviceRootPath, SYNC_DIR_NAME),
+await this.$mobileHelper.buildDevicePath(deviceRootPath, REMOVEDSYNC_DIR_NAME)]);
 }
 
 private async reloadPage(deviceAppData: Mobile.IDeviceAppData, localToDevicePaths: Mobile.ILocalToDevicePathData[]): Promise<void> {
-await this.device.adb.executeCommand(["forward", `tcp:${AndroidLiveSyncService.BACKEND_PORT.toString()}`, `localabstract:${deviceAppData.appIdentifier}-livesync`]);
+await this.device.adb.executeCommand(["forward", `tcp:${AndroidDeviceLiveSyncService.BACKEND_PORT.toString()}`, `localabstract:${deviceAppData.appIdentifier}-livesync`]);
 if (!await this.sendPageReloadMessage()) {
 await this.restartApplication(deviceAppData);
 }
@@ -104,13 +105,19 @@ export class AndroidLiveSyncService implements INativeScriptDeviceLiveSyncServic
 
 for (let localToDevicePathData of localToDevicePaths) {
 let relativeUnixPath = _.trimStart(helpers.fromWindowsRelativePathToUnix(localToDevicePathData.getRelativeToProjectBasePath()), "/");
-let deviceFilePath = this.$mobileHelper.buildDevicePath(deviceRootPath, "removedsync", relativeUnixPath);
+let deviceFilePath = this.$mobileHelper.buildDevicePath(deviceRootPath, REMOVEDSYNC_DIR_NAME, relativeUnixPath);
 await this.device.adb.executeShellCommand(["mkdir", "-p", path.dirname(deviceFilePath), " && ", "touch", deviceFilePath]);
 }
 
 await this.getDeviceHashService(projectId).removeHashes(localToDevicePaths);
 }
 
+@cache()
+public getDeviceHashService(appIdentifier: string): Mobile.IAndroidDeviceHashService {
+let adb = this.$injector.resolve(DeviceAndroidDebugBridge, { identifier: this.device.deviceInfo.identifier });
+return this.$injector.resolve(AndroidDeviceHashService, { adb, appIdentifier });
+}
+
 private getDeviceRootPath(appIdentifier: string): string {
 return `/data/local/tmp/${appIdentifier}`;
 }
@@ -120,7 +127,7 @@ export class AndroidLiveSyncService implements INativeScriptDeviceLiveSyncServic
 let isResolved = false;
 let socket = new net.Socket();
 
-socket.connect(AndroidLiveSyncService.BACKEND_PORT, '127.0.0.1', () => {
+socket.connect(AndroidDeviceLiveSyncService.BACKEND_PORT, '127.0.0.1', () => {
 socket.write(new Buffer([0, 0, 0, 1, 1]));
 });
 socket.on("data", (data: any) => {
@@ -141,15 +148,4 @@ export class AndroidLiveSyncService implements INativeScriptDeviceLiveSyncServic
 });
 });
 }
-
-private _deviceHashService: Mobile.IAndroidDeviceHashService;
-private getDeviceHashService(projectId: string): Mobile.IAndroidDeviceHashService {
-if (!this._deviceHashService) {
-let adb = this.$injector.resolve(DeviceAndroidDebugBridge, { identifier: this.device.deviceInfo.identifier });
-this._deviceHashService = this.$injector.resolve(AndroidDeviceHashService, { adb: adb, appIdentifier: projectId });
-}
-
-return this._deviceHashService;
-}
 }
-$injector.register("androidLiveSyncServiceLocator", { factory: AndroidLiveSyncService });

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

@@ -1,6 +1,6 @@
-import * as deviceAppDataIdentifiers from "../../providers/device-app-data-provider";
 import * as path from "path";
-import * as adls from "./android-device-livesync-service";
+import { AndroidDeviceLiveSyncService } from "./android-device-livesync-service";
+import { APP_FOLDER_NAME, SYNC_DIR_NAME, FULLSYNC_DIR_NAME } from "../../constants";
 
 export class AndroidLiveSyncService implements IPlatformLiveSyncService {
 constructor(private $projectFilesManager: IProjectFilesManager,
@@ -14,14 +14,13 @@ export class AndroidLiveSyncService implements IPlatformLiveSyncService {
 public async fullSync(syncInfo: IFullSyncInfo): Promise<ILiveSyncResultInfo> {
 const projectData = syncInfo.projectData;
 const device = syncInfo.device;
-const deviceLiveSyncService = this.$injector.resolve<adls.AndroidLiveSyncService>(adls.AndroidLiveSyncService, { _device: device });
+const deviceLiveSyncService = this.$injector.resolve<AndroidDeviceLiveSyncService>(AndroidDeviceLiveSyncService, { _device: device });
 const platformData = this.$platformsData.getPlatformData(device.deviceInfo.platform, projectData);
-const deviceAppData = this.$injector.resolve(deviceAppDataIdentifiers.AndroidAppIdentifier,
-{ _appIdentifier: projectData.projectId, device, platform: device.deviceInfo.platform });
 
+const deviceAppData = await this.getAppData(syncInfo, deviceLiveSyncService);
 await deviceLiveSyncService.beforeLiveSyncAction(deviceAppData);
 
-const projectFilesPath = path.join(platformData.appDestinationDirectoryPath, "app");
+const projectFilesPath = path.join(platformData.appDestinationDirectoryPath, APP_FOLDER_NAME);
 const localToDevicePaths = await this.$projectFilesManager.createLocalToDevicePaths(deviceAppData, projectFilesPath, null, []);
 await this.transferFiles(deviceAppData, localToDevicePaths, projectFilesPath, true);
 
@@ -34,8 +33,9 @@ export class AndroidLiveSyncService implements IPlatformLiveSyncService {
 
 public async liveSyncWatchAction(device: Mobile.IDevice, liveSyncInfo: ILiveSyncWatchInfo): Promise<ILiveSyncResultInfo> {
 const projectData = liveSyncInfo.projectData;
-const deviceAppData = this.$injector.resolve(deviceAppDataIdentifiers.AndroidAppIdentifier,
-{ _appIdentifier: projectData.projectId, device, platform: device.deviceInfo.platform });
+const syncInfo = _.merge<IFullSyncInfo>({ device, watch: true }, liveSyncInfo);
+const deviceLiveSyncService = this.$injector.resolve<AndroidDeviceLiveSyncService>(AndroidDeviceLiveSyncService, { _device: device });
+const deviceAppData = await this.getAppData(syncInfo, deviceLiveSyncService);
 
 let modifiedLocalToDevicePaths: Mobile.ILocalToDevicePathData[] = [];
 if (liveSyncInfo.filesToSync.length) {
@@ -52,7 +52,7 @@ export class AndroidLiveSyncService implements IPlatformLiveSyncService {
 
 if (existingFiles.length) {
 let platformData = this.$platformsData.getPlatformData(device.deviceInfo.platform, projectData);
-const projectFilesPath = path.join(platformData.appDestinationDirectoryPath, "app");
+const projectFilesPath = path.join(platformData.appDestinationDirectoryPath, APP_FOLDER_NAME);
 let localToDevicePaths = await this.$projectFilesManager.createLocalToDevicePaths(deviceAppData,
 projectFilesPath, mappedFiles, []);
 modifiedLocalToDevicePaths.push(...localToDevicePaths);
@@ -65,11 +65,11 @@ export class AndroidLiveSyncService implements IPlatformLiveSyncService {
 let platformData = this.$platformsData.getPlatformData(device.deviceInfo.platform, projectData);
 
 const mappedFiles = _.map(filePaths, filePath => this.$projectFilesProvider.mapFilePath(filePath, device.deviceInfo.platform, projectData));
-const projectFilesPath = path.join(platformData.appDestinationDirectoryPath, "app");
+const projectFilesPath = path.join(platformData.appDestinationDirectoryPath, APP_FOLDER_NAME);
 let localToDevicePaths = await this.$projectFilesManager.createLocalToDevicePaths(deviceAppData, projectFilesPath, mappedFiles, []);
 modifiedLocalToDevicePaths.push(...localToDevicePaths);
 
-const deviceLiveSyncService = this.$injector.resolve<INativeScriptDeviceLiveSyncService>(adls.AndroidLiveSyncService, { _device: device });
+const deviceLiveSyncService = this.$injector.resolve<INativeScriptDeviceLiveSyncService>(AndroidDeviceLiveSyncService, { _device: device });
 deviceLiveSyncService.removeFiles(projectData.projectId, localToDevicePaths, projectData.projectId);
 }
 
@@ -80,12 +80,9 @@ export class AndroidLiveSyncService implements IPlatformLiveSyncService {
 };
 }
 
-public async refreshApplication(
-projectData: IProjectData,
-liveSyncInfo: ILiveSyncResultInfo
-): Promise<void> {
+public async refreshApplication(projectData: IProjectData, liveSyncInfo: ILiveSyncResultInfo): Promise<void> {
 if (liveSyncInfo.isFullSync || liveSyncInfo.modifiedFilesData.length) {
-let deviceLiveSyncService = this.$injector.resolve<INativeScriptDeviceLiveSyncService>(adls.AndroidLiveSyncService, { _device: liveSyncInfo.deviceAppData.device });
+let deviceLiveSyncService = this.$injector.resolve<INativeScriptDeviceLiveSyncService>(AndroidDeviceLiveSyncService, { _device: liveSyncInfo.deviceAppData.device });
 this.$logger.info("Refreshing application...");
 await deviceLiveSyncService.refreshApplication(projectData, liveSyncInfo);
 }
@@ -97,7 +94,21 @@ export class AndroidLiveSyncService implements IPlatformLiveSyncService {
 } else {
 await deviceAppData.device.fileSystem.transferFiles(deviceAppData, localToDevicePaths);
 }
+}
 
-console.log("TRANSFEREEDDDDDDD!!!!!!");
+private async getAppData(syncInfo: IFullSyncInfo, deviceLiveSyncService: IAndroidNativeScriptDeviceLiveSyncService): Promise<Mobile.IDeviceAppData> {
+return {
+appIdentifier: syncInfo.device.deviceInfo.identifier,
+device: syncInfo.device,
+platform: syncInfo.device.deviceInfo.platform,
+getDeviceProjectRootPath: async () => {
+const hashService = deviceLiveSyncService.getDeviceHashService(syncInfo.device.deviceInfo.identifier);
+const hashFile = syncInfo.syncAllFiles ? null : await hashService.doesShasumFileExistsOnDevice();
+const syncFolderName = syncInfo.watch || hashFile ? SYNC_DIR_NAME : FULLSYNC_DIR_NAME;
+return `/data/local/tmp/${syncInfo.device.deviceInfo.identifier}/${syncFolderName}`;
+},
+isLiveSyncSupported: async () => true
+};
 }
 }
+$injector.register("androidLiveSyncService", AndroidLiveSyncService);

lib/services/livesync/ios-livesync-service.ts

@@ -76,7 +76,7 @@ export class IOSLiveSyncService implements IPlatformLiveSyncService {
 
 if (liveSyncInfo.isRebuilt) {
 // In this case we should execute fullsync:
-await this.fullSync({ projectData, device, syncAllFiles: liveSyncInfo.syncAllFiles });
+await this.fullSync({ projectData, device, syncAllFiles: liveSyncInfo.syncAllFiles, watch: true });
 } else {
 if (liveSyncInfo.filesToSync.length) {
 const filesToSync = liveSyncInfo.filesToSync;
@@ -138,3 +138,4 @@ export class IOSLiveSyncService implements IPlatformLiveSyncService {
 console.log("### ios TRANSFEREEDDDDDDD!!!!!!");
 }
 }
+$injector.register("iOSLiveSyncService", IOSLiveSyncService);

lib/services/livesync/livesync-service.ts

@@ -1,7 +1,5 @@
 import * as path from "path";
 import * as choki from "chokidar";
-import * as iOSLs from "./ios-livesync-service";
-import * as androidLs from "./android-livesync-service";
 import { EventEmitter } from "events";
 import { exported } from "../../common/decorators";
 import { hook } from "../../common/helpers";
@@ -123,9 +121,9 @@ export class LiveSyncService extends EventEmitter implements ILiveSyncService {
 // TODO: Register both livesync services in injector
 private getLiveSyncService(platform: string): IPlatformLiveSyncService {
 if (this.$mobileHelper.isiOSPlatform(platform)) {
-return this.$injector.resolve(iOSLs.IOSLiveSyncService);
+return this.$injector.resolve("iOSLiveSyncService");
 } else if (this.$mobileHelper.isAndroidPlatform(platform)) {
-return this.$injector.resolve(androidLs.AndroidLiveSyncService);
+return this.$injector.resolve("androidLiveSyncService");
 }
 
 throw new Error(`Invalid platform ${platform}. Supported platforms are: ${this.$mobileHelper.platformNames.join(", ")}`);