fix: don't pass VALID_ARCHS and ARCHS to xcodebuild command

Don't pass VALID_ARCHS and ARCHS to xcodebuild command in order to allow user to specify them from `build.xcconfig` file

Author: Fatme

lib/definitions/platform.d.ts

@@ -83,6 +83,15 @@ interface IPlatformService extends IBuildPlatformAction, NodeJS.EventEmitter {
 	 */
 	shouldInstall(device: Mobile.IDevice, projectData: IProjectData, release: IRelease, outputPath?: string): Promise<boolean>;
 
+	/**
+	 * 
+	 * @param {Mobile.IDevice} device The device where the application should be installed.
+	 * @param {IProjectData} projectData DTO with information about the project.
+	 * @param {string} @optional outputPath Directory containing build information and artifacts.
+	 * @returns {Promise<boolean>} true indicates that the application should be installed.
+	 */
+	validateInstall(device: Mobile.IDevice, projectData: IProjectData, release: IRelease, outputPath?: string): Promise<void>;
+
 	/**
 	 * Determines whether the project should undergo the prepare process.
 	 * @param {IShouldPrepareInfo} shouldPrepareInfo Options needed to decide whether to prepare.
@@ -307,6 +316,13 @@ interface INodeModulesDependenciesBuilder {
 interface IBuildInfo {
 	prepareTime: string;
 	buildTime: string;
+	/** 
+	 * Currently it is used only for iOS.
+	 * As `xcrun` command does not throw an error when IPHONEOS_DEPLOYMENT_TARGET is provided in `xcconfig` file and
+	 * the simulator's version does not match IPHONEOS_DEPLOYMENT_TARGET's value, we need to save it to buildInfo file
+	 * in order check it on livesync and throw an error to the user.
+	*/
+	deploymentTarget?: string;
 }
 
 interface IPlatformDataComposition {

lib/definitions/project.d.ts

@@ -444,6 +444,27 @@ interface IPlatformProjectService extends NodeJS.EventEmitter, IPlatformProjectS
 	 * Traverse through the production dependencies and find plugins that need build/rebuild
 	 */
 	checkIfPluginsNeedBuild(projectData: IProjectData): Promise<Array<any>>;
+	
+	/**
+	 * Get the deployment target's version
+	 * Currently implemented only for iOS -> returns the value of IPHONEOS_DEPLOYMENT_TARGET property from xcconfig file
+	 */
+	getDeploymentTarget(projectData: IProjectData): IDeploymentTargetData;
+}
+
+interface IDeploymentTargetData {
+	/**
+	 * The whole version's value
+	 */
+	version: string;
+	/**
+	 * The major's version
+	 */
+	majorVersion: number;
+	/**
+	 * The minor's version
+	 */
+	minorVersion: number;
 }
 
 interface IValidatePlatformOutput {

lib/services/android-project-service.ts

@@ -665,6 +665,8 @@ export class AndroidProjectService extends projectServiceBaseLib.PlatformProject
 		// Nothing android specific to check yet.
 	}
 
+	public getDeploymentTarget(projectData: IProjectData): IDeploymentTargetData { return; }
+
 	private copy(projectRoot: string, frameworkDir: string, files: string, cpArg: string): void {
 		const paths = files.split(' ').map(p => path.join(frameworkDir, p));
 		shell.cp(cpArg, paths, projectRoot);

lib/services/ios-project-service.ts

@@ -384,12 +384,6 @@ export class IOSProjectService extends projectServiceBaseLib.PlatformProjectServ
 	}
 
 	private async buildForDevice(projectRoot: string, args: string[], buildConfig: IBuildConfig, projectData: IProjectData): Promise<void> {
-		const defaultArchitectures = [
-			'ARCHS=armv7 arm64',
-			'VALID_ARCHS=armv7 arm64'
-		];
-
-		// build only for device specific architecture
 		if (!buildConfig.release && !buildConfig.architectures) {
 			await this.$devicesService.initialize({
 				platform: this.$devicePlatformsConstants.iOS.toLowerCase(), deviceId: buildConfig.device,
@@ -402,18 +396,15 @@ export class IOSProjectService extends projectServiceBaseLib.PlatformProjectServ
 				.uniq()
 				.value();
 			if (devicesArchitectures.length > 0) {
-				const architectures = [
-					`ARCHS=${devicesArchitectures.join(" ")}`,
-					`VALID_ARCHS=${devicesArchitectures.join(" ")}`
-				];
+				const architectures = this.getBuildArchitectures(projectData, buildConfig, devicesArchitectures);
 				if (devicesArchitectures.length > 1) {
 					architectures.push('ONLY_ACTIVE_ARCH=NO');
 				}
 				buildConfig.architectures = architectures;
 			}
 		}
 
-		args = args.concat((buildConfig && buildConfig.architectures) || defaultArchitectures);
+		args = args.concat((buildConfig && buildConfig.architectures) || this.getBuildArchitectures(projectData, buildConfig, ["armv7", "arm64"]));
 
 		args = args.concat([
 			"-sdk", "iphoneos",
@@ -457,6 +448,28 @@ export class IOSProjectService extends projectServiceBaseLib.PlatformProjectServ
 		return commandResult;
 	}
 
+	private getBuildArchitectures(projectData: IProjectData, buildConfig: IBuildConfig, architectures: string[]): string[] {
+		let result: string[] = [];
+
+		const frameworkVersion = this.getFrameworkVersion(projectData);
+		if (semver.valid(frameworkVersion) && semver.validRange(frameworkVersion) && semver.lt(semver.coerce(frameworkVersion), "5.1.0")) {
+			const target = this.getDeploymentTarget(projectData);
+			if (target && target.majorVersion >= 11) {
+				// We need to strip 32bit architectures as of deployment target >= 11 it is not allowed to have such
+				architectures = _.filter(architectures, arch => {
+					const is64BitArchitecture = arch === "x86_64" || arch === "arm64";
+					if (!is64BitArchitecture) {
+						this.$logger.warn(`The architecture ${arch} will be stripped as it is not supported for deployment target ${target.version}.`);
+					}
+					return is64BitArchitecture;
+				});
+			}
+			result = [`ARCHS=${architectures.join(" ")}`, `VALID_ARCHS=${architectures.join(" ")}`];
+		}
+
+		return result;
+	}
+
 	private async setupSigningFromTeam(projectRoot: string, projectData: IProjectData, teamId: string) {
 		const xcode = this.$pbxprojDomXcode.Xcode.open(this.getPbxProjPath(projectData));
 		const signing = xcode.getSigning(projectData.projectName);
@@ -555,13 +568,14 @@ export class IOSProjectService extends projectServiceBaseLib.PlatformProjectServ
 	}
 
 	private async buildForSimulator(projectRoot: string, args: string[], projectData: IProjectData, buildConfig?: IBuildConfig): Promise<void> {
+		const architectures = this.getBuildArchitectures(projectData, buildConfig, ["i386", "x86_64"]);
+
 		args = args
+			.concat(architectures)
 			.concat([
 				"build",
 				"-configuration", buildConfig.release ? "Release" : "Debug",
 				"-sdk", "iphonesimulator",
-				"ARCHS=i386 x86_64",
-				"VALID_ARCHS=i386 x86_64",
 				"ONLY_ACTIVE_ARCH=NO",
 				"CONFIGURATION_BUILD_DIR=" + path.join(projectRoot, "build", "emulator"),
 				"CODE_SIGN_IDENTITY=",
@@ -1031,6 +1045,20 @@ We will now place an empty obsolete compatability white screen LauncScreen.xib f
 		return [];
 	}
 
+	public getDeploymentTarget(projectData: IProjectData): IDeploymentTargetData {
+		const target = this.$xCConfigService.readPropertyValue(this.getBuildXCConfigFilePath(projectData), "IPHONEOS_DEPLOYMENT_TARGET");
+		if (!target) {
+			return null;
+		}
+
+		const parts = target.split(".");
+		return {
+			version: target,
+			majorVersion: parseInt(parts[0]),
+			minorVersion: parseInt(parts[1])
+		};
+	}
+
 	private getAllLibsForPluginWithFileExtension(pluginData: IPluginData, fileExtension: string): string[] {
 		const filterCallback = (fileName: string, pluginPlatformsFolderPath: string) => path.extname(fileName) === fileExtension;
 		return this.getAllNativeLibrariesForPlugin(pluginData, IOSProjectService.IOS_PLATFORM_NAME, filterCallback);

lib/services/livesync/livesync-service.ts

@@ -463,6 +463,7 @@ export class LiveSyncService extends EventEmitter implements IDebugLiveSyncServi
 			});
 		}
 
+		await this.$platformService.validateInstall(options.device, options.projectData, options, options.deviceBuildInfoDescriptor.outputPath);
 		const shouldInstall = await this.$platformService.shouldInstall(options.device, options.projectData, options, options.deviceBuildInfoDescriptor.outputPath);
 		if (shouldInstall) {
 			await this.$platformService.installApplication(options.device, { release: false }, options.projectData, pathToBuildItem, options.deviceBuildInfoDescriptor.outputPath);

lib/services/platform-service.ts

@@ -436,13 +436,20 @@ export class PlatformService extends EventEmitter implements IPlatformService {
 
 	public saveBuildInfoFile(platform: string, projectDir: string, buildInfoFileDirname: string): void {
 		const buildInfoFile = path.join(buildInfoFileDirname, buildInfoFileName);
+		const projectData = this.$projectDataService.getProjectData(projectDir);
+		const platformData = this.$platformsData.getPlatformData(platform, projectData);
 
-		const prepareInfo = this.$projectChangesService.getPrepareInfo(platform, this.$projectDataService.getProjectData(projectDir));
-		const buildInfo = {
+		const prepareInfo = this.$projectChangesService.getPrepareInfo(platform, projectData);
+		const buildInfo: IBuildInfo = {
 			prepareTime: prepareInfo.changesRequireBuildTime,
 			buildTime: new Date().toString()
 		};
 
+		const deploymentTarget = platformData.platformProjectService.getDeploymentTarget(projectData);
+		if (deploymentTarget) {
+			buildInfo.deploymentTarget = deploymentTarget.version;
+		}
+
 		this.$fs.writeJson(buildInfoFile, buildInfo);
 	}
 
@@ -455,9 +462,21 @@ export class PlatformService extends EventEmitter implements IPlatformService {
 		const platformData = this.$platformsData.getPlatformData(platform, projectData);
 		const deviceBuildInfo: IBuildInfo = await this.getDeviceBuildInfo(device, projectData);
 		const localBuildInfo = this.getBuildInfo(platform, platformData, { buildForDevice: !device.isEmulator, release: release.release }, outputPath);
+
 		return !localBuildInfo || !deviceBuildInfo || deviceBuildInfo.buildTime !== localBuildInfo.buildTime;
 	}
 
+	public async validateInstall(device: Mobile.IDevice, projectData: IProjectData, release: IRelease, outputPath?: string): Promise<void> {
+		const platform = device.deviceInfo.platform;
+		const platformData = this.$platformsData.getPlatformData(platform, projectData);
+		const localBuildInfo = this.getBuildInfo(device.deviceInfo.platform, platformData, { buildForDevice: !device.isEmulator, release: release.release }, outputPath);
+		if (localBuildInfo.deploymentTarget) {
+			if (semver.lt(semver.coerce(device.deviceInfo.version), semver.coerce(localBuildInfo.deploymentTarget))) {
+				this.$errors.fail(`Unable to install on device with version ${device.deviceInfo.version} as deployment target is ${localBuildInfo.deploymentTarget}`);
+			}
+		}
+	}
+
 	public async installApplication(device: Mobile.IDevice, buildConfig: IBuildConfig, projectData: IProjectData, packageFile?: string, outputFilePath?: string): Promise<void> {
 		this.$logger.out(`Installing on device ${device.deviceInfo.identifier}...`);