WIP

Author: rosen-vladimirov

lib/bootstrap.ts

@@ -39,6 +39,7 @@ $injector.requireCommand("platform|*list", "./commands/list-platforms");
 $injector.requireCommand("platform|add", "./commands/add-platform");
 $injector.requireCommand("platform|remove", "./commands/remove-platform");
 $injector.requireCommand("platform|update", "./commands/update-platform");
+$injector.requireCommand("run|*all", "./commands/run");
 $injector.requireCommand("run|ios", "./commands/run");
 $injector.requireCommand("run|android", "./commands/run");
 
@@ -102,6 +103,7 @@ $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("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");

lib/commands/debug.ts

@@ -1,13 +1,83 @@
 import { EOL } from "os";
+import { LiveSyncService } from "../services/livesync/livesync-service";
+export class DebugLiveSyncService extends LiveSyncService {
 
+constructor(protected $platformService: IPlatformService,
+$projectDataService: IProjectDataService,
+protected $devicesService: Mobile.IDevicesService,
+$mobileHelper: Mobile.IMobileHelper,
+$nodeModulesDependenciesBuilder: INodeModulesDependenciesBuilder,
+protected $logger: ILogger,
+$processService: IProcessService,
+$hooksService: IHooksService,
+$projectChangesService: IProjectChangesService,
+protected $injector: IInjector,
+private $options: IOptions,
+private $debugDataService: IDebugDataService,
+private $projectData: IProjectData,
+private debugService: IPlatformDebugService,
+private $config: IConfiguration) {
+
+super($platformService,
+$projectDataService,
+$devicesService,
+$mobileHelper,
+$nodeModulesDependenciesBuilder,
+$logger,
+$processService,
+$hooksService,
+$projectChangesService,
+$injector);
+}
+
+protected async refreshApplication(projectData: IProjectData, liveSyncResultInfo: ILiveSyncResultInfo): Promise<void> {
+const debugOptions = this.$options;
+const deployOptions: IDeployPlatformOptions = {
+clean: this.$options.clean,
+device: this.$options.device,
+emulator: this.$options.emulator,
+platformTemplate: this.$options.platformTemplate,
+projectDir: this.$options.path,
+release: this.$options.release,
+provision: this.$options.provision,
+teamId: this.$options.teamId
+};
+
+let debugData = this.$debugDataService.createDebugData(this.$projectData, this.$options);
+
+await this.$platformService.trackProjectType(this.$projectData);
+
+if (this.$options.start) {
+return this.printDebugInformation(await this.debugService.debug<string[]>(debugData, debugOptions));
+}
+
+const deviceAppData = liveSyncResultInfo.deviceAppData;
+this.$config.debugLivesync = true;
+
+await this.debugService.debugStop();
+
+let applicationId = deviceAppData.appIdentifier;
+await deviceAppData.device.applicationManager.stopApplication(applicationId, projectData.projectName);
+
+const buildConfig: IBuildConfig = _.merge({ buildForDevice: !deviceAppData.device.isEmulator }, deployOptions);
+debugData.pathToAppPackage = this.$platformService.lastOutputPath(this.debugService.platform, buildConfig, projectData);
+
+this.printDebugInformation(await this.debugService.debug<string[]>(debugData, debugOptions));
+}
+
+protected printDebugInformation(information: string[]): void {
+_.each(information, i => {
+this.$logger.info(`To start debugging, open the following URL in Chrome:${EOL}${i}${EOL}`.cyan);
+});
+}
+}
 export abstract class DebugPlatformCommand implements ICommand {
 public allowedParameters: ICommandParameter[] = [];
+public platform: string;
 
 constructor(private debugService: IPlatformDebugService,
 private $devicesService: Mobile.IDevicesService,
 private $injector: IInjector,
-private $config: IConfiguration,
-private $usbLiveSyncService: ILiveSyncService,
 private $debugDataService: IDebugDataService,
 protected $platformService: IPlatformService,
 protected $projectData: IProjectData,
@@ -19,16 +89,16 @@ export abstract class DebugPlatformCommand implements ICommand {
 
 public async execute(args: string[]): Promise<void> {
 const debugOptions = this.$options;
-const deployOptions: IDeployPlatformOptions = {
-clean: this.$options.clean,
-device: this.$options.device,
-emulator: this.$options.emulator,
-platformTemplate: this.$options.platformTemplate,
-projectDir: this.$options.path,
-release: this.$options.release,
-provision: this.$options.provision,
-teamId: this.$options.teamId
-};
+// const deployOptions: IDeployPlatformOptions = {
+// clean: this.$options.clean,
+// device: this.$options.device,
+// emulator: this.$options.emulator,
+// platformTemplate: this.$options.platformTemplate,
+// projectDir: this.$options.path,
+// release: this.$options.release,
+// provision: this.$options.provision,
+// teamId: this.$options.teamId
+// };
 
 let debugData = this.$debugDataService.createDebugData(this.$projectData, this.$options);
 
@@ -38,26 +108,67 @@ export abstract class DebugPlatformCommand implements ICommand {
 return this.printDebugInformation(await this.debugService.debug<string[]>(debugData, debugOptions));
 }
 
-const appFilesUpdaterOptions: IAppFilesUpdaterOptions = { bundle: this.$options.bundle, release: this.$options.release };
+// const appFilesUpdaterOptions: IAppFilesUpdaterOptions = { bundle: this.$options.bundle, release: this.$options.release };
 
-await this.$platformService.deployPlatform(this.$devicesService.platform, appFilesUpdaterOptions, deployOptions, this.$projectData, this.$options);
-this.$config.debugLivesync = true;
-let applicationReloadAction = async (deviceAppData: Mobile.IDeviceAppData): Promise<void> => {
-let projectData: IProjectData = this.$injector.resolve("projectData");
+// await this.$platformService.deployPlatform(this.$devicesService.platform, appFilesUpdaterOptions, deployOptions, this.$projectData, this.$options);
+// this.$config.debugLivesync = true;
+// let applicationReloadAction = async (deviceAppData: Mobile.IDeviceAppData): Promise<void> => {
+// let projectData: IProjectData = this.$injector.resolve("projectData");
 
-await this.debugService.debugStop();
+// await this.debugService.debugStop();
 
-let applicationId = deviceAppData.appIdentifier;
-await deviceAppData.device.applicationManager.stopApplication(applicationId, projectData.projectName);
+// let applicationId = deviceAppData.appIdentifier;
+// await deviceAppData.device.applicationManager.stopApplication(applicationId, projectData.projectName);
 
-const buildConfig: IBuildConfig = _.merge({ buildForDevice: !deviceAppData.device.isEmulator }, deployOptions);
-debugData.pathToAppPackage = this.$platformService.lastOutputPath(this.debugService.platform, buildConfig, projectData);
+// const buildConfig: IBuildConfig = _.merge({ buildForDevice: !deviceAppData.device.isEmulator }, deployOptions);
+// debugData.pathToAppPackage = this.$platformService.lastOutputPath(this.debugService.platform, buildConfig, projectData);
 
-this.printDebugInformation(await this.debugService.debug<string[]>(debugData, debugOptions));
-};
+// this.printDebugInformation(await this.debugService.debug<string[]>(debugData, debugOptions));
+// };
 
 // TODO: Fix this call
-return this.$usbLiveSyncService.liveSync(this.$devicesService.platform, this.$projectData, applicationReloadAction, this.$options);
+await this.$devicesService.initialize({ deviceId: this.$options.device, platform: this.platform, skipDeviceDetectionInterval: true, skipInferPlatform: true });
+await this.$devicesService.detectCurrentlyAttachedDevices();
+
+const devices = this.$devicesService.getDeviceInstances();
+// Now let's take data for each device:
+const deviceDescriptors: ILiveSyncDeviceInfo[] = devices.filter(d => !this.platform || d.deviceInfo.platform === this.platform)
+.map(d => {
+const info: ILiveSyncDeviceInfo = {
+identifier: d.deviceInfo.identifier,
+buildAction: async (): Promise<string> => {
+const buildConfig: IBuildConfig = {
+buildForDevice: !d.isEmulator, // this.$options.forDevice,
+projectDir: this.$options.path,
+clean: this.$options.clean,
+teamId: this.$options.teamId,
+device: this.$options.device,
+provision: this.$options.provision,
+release: this.$options.release,
+keyStoreAlias: this.$options.keyStoreAlias,
+keyStorePath: this.$options.keyStorePath,
+keyStoreAliasPassword: this.$options.keyStoreAliasPassword,
+keyStorePassword: this.$options.keyStorePassword
+};
+
+await this.$platformService.buildPlatform(d.deviceInfo.platform, buildConfig, this.$projectData);
+const pathToBuildResult = await this.$platformService.lastOutputPath(d.deviceInfo.platform, buildConfig, this.$projectData);
+console.log("3##### return path to buildResult = ", pathToBuildResult);
+return pathToBuildResult;
+}
+}
+
+return info;
+});
+
+const liveSyncInfo: ILiveSyncInfo = {
+projectDir: this.$projectData.projectDir,
+shouldStartWatcher: this.$options.watch,
+syncAllFiles: this.$options.syncAllFiles
+};
+
+const debugLiveSyncService = this.$injector.resolve<ILiveSyncService>(DebugLiveSyncService, { debugService: this.debugService });
+await debugLiveSyncService.liveSync(deviceDescriptors, liveSyncInfo);
 }
 
 public async canExecute(args: string[]): Promise<boolean> {
@@ -92,14 +203,14 @@ export class DebugIOSCommand extends DebugPlatformCommand {
 $devicesService: Mobile.IDevicesService,
 $injector: IInjector,
 $config: IConfiguration,
-$usbLiveSyncService: ILiveSyncService,
+$liveSyncService: ILiveSyncService,
 $debugDataService: IDebugDataService,
 $platformService: IPlatformService,
 $options: IOptions,
 $projectData: IProjectData,
 $platformsData: IPlatformsData,
 $iosDeviceOperations: IIOSDeviceOperations) {
-super($iOSDebugService, $devicesService, $injector, $config, $usbLiveSyncService, $debugDataService, $platformService, $projectData, $options, $platformsData, $logger);
+super($iOSDebugService, $devicesService, $injector, $debugDataService, $platformService, $projectData, $options, $platformsData, $logger);
 // Do not dispose ios-device-lib, so the process will remain alive and the debug application (NativeScript Inspector or Chrome DevTools) will be able to connect to the socket.
 // In case we dispose ios-device-lib, the socket will be closed and the code will fail when the debug application tries to read/send data to device socket.
 // That's why the `$ tns debug ios --justlaunch` command will not release the terminal.
@@ -120,6 +231,8 @@ export class DebugIOSCommand extends DebugPlatformCommand {
 super.printDebugInformation(information);
 }
 }
+
+public platform = "iOS";
 }
 
 $injector.registerCommand("debug|ios", DebugIOSCommand);
@@ -132,13 +245,13 @@ export class DebugAndroidCommand extends DebugPlatformCommand {
 $devicesService: Mobile.IDevicesService,
 $injector: IInjector,
 $config: IConfiguration,
-$usbLiveSyncService: ILiveSyncService,
+$liveSyncService: ILiveSyncService,
 $debugDataService: IDebugDataService,
 $platformService: IPlatformService,
 $options: IOptions,
 $projectData: IProjectData,
 $platformsData: IPlatformsData) {
-super($androidDebugService, $devicesService, $injector, $config, $usbLiveSyncService, $debugDataService, $platformService, $projectData, $options, $platformsData, $logger);
+super($androidDebugService, $devicesService, $injector, $debugDataService, $platformService, $projectData, $options, $platformsData, $logger);
 }
 
 public async canExecute(args: string[]): Promise<boolean> {
@@ -148,6 +261,8 @@ export class DebugAndroidCommand extends DebugPlatformCommand {
 
 return await super.canExecute(args) && await this.$platformService.validateOptions(this.$options.provision, this.$projectData, this.$platformsData.availablePlatforms.Android);
 }
+
+public platform = "Android";
 }
 
 $injector.registerCommand("debug|android", DebugAndroidCommand);