fix: move the ios debug and livesync sockets logic in the iOS devices

Author: DimitarTachev

.vscode/launch.json

@@ -7,7 +7,7 @@
 		{
 			"type": "node",
 			"request": "launch",
-			"cwd": "/Users/tachev/Work/Test/testJsHw",
+			"cwd": "/Users/tachev/Work/Test/debugTest",
 			"sourceMaps": true,
 			// In case you want to debug child processes started from CLI:
 			// "autoAttachChildProcesses": true,
@@ -16,7 +16,8 @@
 			// example commands
 			"args": [
 				"debug",
-				"ios"
+				"ios",
+				"--hmr"
 			]
 			// "args": [ "test", "android", "--justlaunch"]
 			// "args": [ "platform", "add", "android@1.3.0", "--path", "cliapp"]

lib/bootstrap.ts

@@ -14,7 +14,6 @@ $injector.require("androidPluginBuildService", "./services/android-plugin-build-
 $injector.require("iOSEntitlementsService", "./services/ios-entitlements-service");
 $injector.require("iOSProjectService", "./services/ios-project-service");
 $injector.require("iOSProvisionService", "./services/ios-provision-service");
-$injector.require("iOSDeviceSocketService", "./services/ios-device-socket-service");
 $injector.require("xCConfigService", "./services/xcconfig-service");
 
 $injector.require("cocoapodsService", "./services/cocoapods-service");

lib/common/definitions/mobile.d.ts

@@ -111,7 +111,8 @@ declare module Mobile {
 	}
 
 	interface IiOSDevice extends IDevice {
-		connectToPort(port: number): Promise<any>;
+		getLiveSyncSocket(appId: string, projectDir: string): Promise<any>;
+		getDebugSocket(appId: string, projectDir: string): Promise<any>;
 		openDeviceLogStream(options?: IiOSLogStreamOptions): Promise<void>;
 	}
 
@@ -130,8 +131,6 @@ declare module Mobile {
 		getDeviceHashService(appIdentifier: string): Mobile.IAndroidDeviceHashService;
 	}
 
-	// interface IiOSSimulator extends IDevice { }
-
 	/**
 	 * Describes log stream options
 	 */

lib/common/mobile/ios/device/ios-device.ts

@@ -1,6 +1,7 @@
 import * as applicationManagerPath from "./ios-application-manager";
 import * as fileSystemPath from "./ios-device-file-system";
-import * as constants from "../../../constants";
+import * as commonConstants from "../../../constants";
+import * as constants from "../../../../constants";
 import * as net from "net";
 import { cache } from "../../../decorators";
 
@@ -10,39 +11,32 @@ export class IOSDevice implements Mobile.IiOSDevice {
 	public deviceInfo: Mobile.IDeviceInfo;
 	private socket: net.Socket;
 
-	// private static sockets: { [id: string]: net.Socket; } = {};
-
-	// get socket(): net.Socket {
-	// 	return IOSDevice.sockets[this.deviceInfo.identifier];
-	// }
-	// set socket(newSocket: net.Socket) {
-	// 	IOSDevice.sockets[this.deviceInfo.identifier] = newSocket;
-	// }
-
 	private _deviceLogHandler: (...args: any[]) => void;
 
 	constructor(private deviceActionInfo: IOSDeviceLib.IDeviceActionInfo,
+		private $errors: IErrors,
 		private $injector: IInjector,
+		private $iOSDebuggerPortService: IIOSDebuggerPortService,
+		private $iOSSocketRequestExecutor: IiOSSocketRequestExecutor,
 		private $processService: IProcessService,
 		private $deviceLogProvider: Mobile.IDeviceLogProvider,
 		private $devicePlatformsConstants: Mobile.IDevicePlatformsConstants,
 		private $iOSDeviceProductNameMapper: Mobile.IiOSDeviceProductNameMapper,
 		private $iosDeviceOperations: IIOSDeviceOperations,
-		private $logger: ILogger,
 		private $mobileHelper: Mobile.IMobileHelper) {
 
 		this.applicationManager = this.$injector.resolve(applicationManagerPath.IOSApplicationManager, { device: this, devicePointer: this.deviceActionInfo });
 		this.fileSystem = this.$injector.resolve(fileSystemPath.IOSDeviceFileSystem, { device: this, devicePointer: this.deviceActionInfo });
 
 		const productType = deviceActionInfo.productType;
 		const isTablet = this.$mobileHelper.isiOSTablet(productType);
-		const deviceStatus = deviceActionInfo.status || constants.UNREACHABLE_STATUS;
+		const deviceStatus = deviceActionInfo.status || commonConstants.UNREACHABLE_STATUS;
 		this.deviceInfo = {
 			identifier: deviceActionInfo.deviceId,
 			vendor: "Apple",
 			platform: this.$devicePlatformsConstants.iOS,
 			status: deviceStatus,
-			errorHelp: deviceStatus === constants.UNREACHABLE_STATUS ? `Device ${deviceActionInfo.deviceId} is ${constants.UNREACHABLE_STATUS}` : null,
+			errorHelp: deviceStatus === commonConstants.UNREACHABLE_STATUS ? `Device ${deviceActionInfo.deviceId} is ${commonConstants.UNREACHABLE_STATUS}` : null,
 			type: "Device",
 			isTablet: isTablet,
 			displayName: this.$iOSDeviceProductNameMapper.resolveProductName(deviceActionInfo.deviceName) || deviceActionInfo.deviceName,
@@ -69,31 +63,45 @@ export class IOSDevice implements Mobile.IiOSDevice {
 
 	@cache()
 	public async openDeviceLogStream(): Promise<void> {
-		if (this.deviceInfo.status !== constants.UNREACHABLE_STATUS) {
+		if (this.deviceInfo.status !== commonConstants.UNREACHABLE_STATUS) {
 			this._deviceLogHandler = this.actionOnDeviceLog.bind(this);
-			this.$iosDeviceOperations.on(constants.DEVICE_LOG_EVENT_NAME, this._deviceLogHandler);
+			this.$iosDeviceOperations.on(commonConstants.DEVICE_LOG_EVENT_NAME, this._deviceLogHandler);
 			this.$iosDeviceOperations.startDeviceLog(this.deviceInfo.identifier);
 		}
 	}
 
 	public detach(): void {
 		if (this._deviceLogHandler) {
-			this.$iosDeviceOperations.removeListener(constants.DEVICE_LOG_EVENT_NAME, this._deviceLogHandler);
+			this.$iosDeviceOperations.removeListener(commonConstants.DEVICE_LOG_EVENT_NAME, this._deviceLogHandler);
 		}
 	}
 
-	// This function works only on OSX
-	public async connectToPort(port: number): Promise<net.Socket> {
-		console.log("connectToPort");
+	public async getLiveSyncSocket(appId: string, projectDir: string): Promise<net.Socket> {
+		return this.getSocket(appId, projectDir);
+	}
+
+	public async getDebugSocket(appId: string, projectDir: string): Promise<net.Socket> {
+		return this.getSocket(appId, projectDir);
+	}
+
+	private async getSocket(appId: string, projectDir: string): Promise<net.Socket> {
+		if (this.socket) {
+			return this.socket;
+		}
+
+		await this.$iOSSocketRequestExecutor.executeAttachRequest(this, constants.AWAIT_NOTIFICATION_TIMEOUT_SECONDS, appId);
+		const port = await this.$iOSDebuggerPortService.getPort({ projectDir, deviceId: this.deviceInfo.identifier, appId });
+		if (!port) {
+			this.$errors.fail("NativeScript debugger was not able to get inspector socket port.");
+		}
+
 		const deviceId = this.deviceInfo.identifier;
 		const deviceResponse = _.first((await this.$iosDeviceOperations.connectToPort([{ deviceId: deviceId, port: port }]))[deviceId]);
 
-		const _socket = new net.Socket();
-		_socket.connect(deviceResponse.port, deviceResponse.host);
-		this.socket = _socket;
-		_socket.on("close", () => {
+		this.socket = new net.Socket();
+		this.socket.connect(deviceResponse.port, deviceResponse.host);
+		this.socket.on("close", () => {
 			this.socket = null;
-			this.$logger.info("iOS Device socket closed!");
 		});
 
 		this.$processService.attachToProcessExitSignals(this, this.destroySocket);

lib/common/mobile/ios/simulator/ios-emulator-services.ts

@@ -1,10 +1,7 @@
 import * as net from "net";
-import { connectEventuallyUntilTimeout } from "../../../helpers";
 import { APPLE_VENDOR_NAME, DeviceTypes, RUNNING_EMULATOR_STATUS, NOT_RUNNING_EMULATOR_STATUS } from "../../../constants";
 
 class IosEmulatorServices implements Mobile.IiOSSimulatorService {
-	private static DEFAULT_TIMEOUT = 10000;
-
 	constructor(private $logger: ILogger,
 		private $devicePlatformsConstants: Mobile.IDevicePlatformsConstants,
 		private $iOSSimResolver: Mobile.IiOSSimResolver,
@@ -72,7 +69,7 @@ class IosEmulatorServices implements Mobile.IiOSSimulatorService {
 
 	public async connectToPort(data: Mobile.IConnectToPortData): Promise<net.Socket> {
 		try {
-			const socket = await connectEventuallyUntilTimeout(async () => net.connect(data.port), data.timeout || IosEmulatorServices.DEFAULT_TIMEOUT);
+			const socket = net.connect(data.port);
 			return socket;
 		} catch (e) {
 			this.$logger.debug(e);

lib/common/mobile/ios/simulator/ios-simulator-device.ts

@@ -3,36 +3,58 @@ import * as fileSystemPath from "./ios-simulator-file-system";
 import * as constants from "../../../constants";
 import * as net from "net";
 import { cache } from "../../../decorators";
+import * as helpers from "../../../../common/helpers";
 
 export class IOSSimulator implements Mobile.IiOSDevice {
+	private static socketConnectionTimeout = 30000;
 	private _applicationManager: Mobile.IDeviceApplicationManager;
 	private _fileSystem: Mobile.IDeviceFileSystem;
 	private socket: net.Socket;
 
-	// private static sockets: { [id: string]: net.Socket; } = {};
-
-	// get socket(): net.Socket {
-	// 	return IOSSimulator.sockets[this.deviceInfo.identifier];
-	// }
-	// set socket(newSocket: net.Socket) {
-	// 	IOSSimulator.sockets[this.deviceInfo.identifier] = newSocket;
-	// }
-
 	constructor(private simulator: Mobile.IiSimDevice,
 		private $devicePlatformsConstants: Mobile.IDevicePlatformsConstants,
+		private $errors: IErrors,
 		private $injector: IInjector,
+		private $iOSDebuggerPortService: IIOSDebuggerPortService,
 		private $iOSSimResolver: Mobile.IiOSSimResolver,
 		private $iOSEmulatorServices: Mobile.IiOSSimulatorService,
+		private $iOSNotification: IiOSNotification,
 		private $iOSSimulatorLogProvider: Mobile.IiOSSimulatorLogProvider,
 		private $logger: ILogger) { }
 
-	public async connectToPort(port: number): Promise<net.Socket> {
-		console.log("connectToPort");
-		this.socket = await this.$iOSEmulatorServices.connectToPort({ port });
-		this.socket.on("close", () => {
-			this.socket = null;
-			this.$logger.info("iOS Simulator socket closed!");
-		});
+	public async getLiveSyncSocket(appId: string, projectDir: string): Promise<net.Socket> {
+		return this.getSocket(appId, projectDir);
+	}
+
+	public async getDebugSocket(appId: string, projectDir: string): Promise<net.Socket> {
+		return this.getSocket(appId, projectDir);
+	}
+
+	private async getSocket(appId: string, projectDir: string): Promise<net.Socket> {
+		if (this.socket) {
+			return this.socket;
+		}
+
+		const attachRequestMessage = this.$iOSNotification.getAttachRequest(appId, this.deviceInfo.identifier);
+		await this.$iOSEmulatorServices.postDarwinNotification(attachRequestMessage, this.deviceInfo.identifier);
+		const port = await this.$iOSDebuggerPortService.getPort({ projectDir, deviceId: this.deviceInfo.identifier, appId });
+		if (!port) {
+			this.$errors.fail("NativeScript debugger was not able to get inspector socket port.");
+		}
+
+		try {
+			this.socket = await helpers.connectEventuallyUntilTimeout(
+				async () => { return this.$iOSEmulatorServices.connectToPort({ port }) },
+				IOSSimulator.socketConnectionTimeout);
+		} catch (e) {
+			this.$logger.warn(e);
+		}
+
+		if (this.socket) {
+			this.socket.on("close", () => {
+				this.socket = null;
+			});
+		}
 
 		return this.socket;
 	}

lib/device-sockets/ios/socket-proxy-factory.ts

@@ -3,7 +3,6 @@ import { CONNECTION_ERROR_EVENT_NAME } from "../../constants";
 import { PacketStream } from "./packet-stream";
 import * as net from "net";
 import * as ws from "ws";
-import * as helpers from "../../common/helpers";
 import temp = require("temp");
 
 export class SocketProxyFactory extends EventEmitter implements ISocketProxyFactory {
@@ -12,7 +11,6 @@ export class SocketProxyFactory extends EventEmitter implements ISocketProxyFact
 
 	constructor(private $logger: ILogger,
 		private $errors: IErrors,
-		private $iOSDeviceSocketService: Mobile.IiOSDeviceSocketsService,
 		private $options: IOptions,
 		private $net: INet) {
 		super();
@@ -32,9 +30,6 @@ export class SocketProxyFactory extends EventEmitter implements ISocketProxyFact
 			throw new Error(`TCP socket proxy is already running for device '${deviceIdentifier}'`);
 		}
 
-		// await here?
-		const socketFactory = async (callback: (_socket: net.Socket) => void) => helpers.connectEventually(factory, callback);
-
 		this.$logger.info("\nSetting up proxy...\nPress Ctrl + C to terminate, or disconnect.\n");
 
 		const server = net.createServer({
@@ -45,42 +40,40 @@ export class SocketProxyFactory extends EventEmitter implements ISocketProxyFact
 
 		server.on("connection", async (frontendSocket: net.Socket) => {
 			this.$logger.info("Frontend client connected.");
-
 			frontendSocket.on("end", () => {
 				this.$logger.info('Frontend socket closed!');
 				if (!this.$options.watch) {
 					process.exit(0);
 				}
 			});
 
-			await socketFactory((backendSocket: net.Socket) => {
-				this.$logger.info("Backend socket created.");
+			const backendSocket = await factory();
+			this.$logger.info("Backend socket created.");
+
+			backendSocket.on("end", () => {
+				this.$logger.info("Backend socket closed!");
+				if (!this.$options.watch) {
+					process.exit(0);
+				}
+			});
 
-				backendSocket.on("end", () => {
-					this.$logger.info("Backend socket closed!");
-					if (!this.$options.watch) {
-						process.exit(0);
-					}
-				});
-
-				frontendSocket.on("close", () => {
-					this.$logger.info("Frontend socket closed");
-					if (!(<any>backendSocket).destroyed) {
-						backendSocket.destroy();
-					}
-				});
-
-				backendSocket.on("close", () => {
-					this.$logger.info("Backend socket closed");
-					if (!(<any>frontendSocket).destroyed) {
-						frontendSocket.destroy();
-					}
-				});
-
-				backendSocket.pipe(frontendSocket);
-				frontendSocket.pipe(backendSocket);
-				frontendSocket.resume();
+			frontendSocket.on("close", () => {
+				this.$logger.info("Frontend socket closed");
+				if (!(<any>backendSocket).destroyed) {
+					backendSocket.destroy();
+				}
 			});
+
+			backendSocket.on("close", () => {
+				this.$logger.info("Backend socket closed");
+				if (!(<any>frontendSocket).destroyed) {
+					frontendSocket.destroy();
+				}
+			});
+
+			backendSocket.pipe(frontendSocket);
+			frontendSocket.pipe(backendSocket);
+			frontendSocket.resume();
 		});
 
 		const socketFileLocation = temp.path({ suffix: ".sock" });
@@ -115,8 +108,7 @@ export class SocketProxyFactory extends EventEmitter implements ISocketProxyFact
 				this.$logger.info("Frontend client connected.");
 				let _socket;
 				try {
-					const existingServerSocket = this.$iOSDeviceSocketService.getSocket(deviceIdentifier);
-					_socket = existingServerSocket || await helpers.connectEventuallyUntilTimeout(factory, 10000);
+					_socket = await factory();
 				} catch (err) {
 					err.deviceIdentifier = deviceIdentifier;
 					this.$logger.trace(err);
@@ -166,8 +158,6 @@ export class SocketProxyFactory extends EventEmitter implements ISocketProxyFact
 				this.$logger.info('Frontend socket closed!');
 				packets.destroy();
 				deviceSocket.destroy();
-				// delete this.deviceWebServers[deviceIdentifier];
-				// server.close();
 				if (!this.$options.watch) {
 					process.exit(0);
 				}