preverificationbuilder.java

eclipseme的最新版本的source,欢迎j2me程序员使用

		}

		Manifest jarManifest = new Manifest();
		Attributes mainAttributes = jarManifest.getMainAttributes();
		mainAttributes.putValue(Attributes.Name.MANIFEST_VERSION.toString(), "1.0");
		
		if (buildLoggingConfig.isPreverifierTraceEnabled()) {
			BuildConsoleProxy.instance.traceln("- PreverificationBuilder.generateDeployedManifest setting properties into Manifest object");
		}
		Iterator iterator = manifestProperties.entrySet().iterator();
		while (iterator.hasNext()) {
			Map.Entry entry = (Map.Entry) iterator.next();
			try {
				if (buildLoggingConfig.isPreverifierTraceEnabled()) {
					BuildConsoleProxy.instance.traceln("- PreverificationBuilder.generateDeployedManifest -- " + entry.getKey() + " -> " + entry.getValue());
				}
				mainAttributes.putValue((String) entry.getKey(), (String) entry.getValue());
			} catch (IllegalArgumentException e) {
				if (buildLoggingConfig.isPreverifierTraceEnabled()) {
					BuildConsoleProxy.instance.traceln("- PreverificationBuilder.generateDeployedManifest exception: " + e);
				}

				Status s = new Status(
					IStatus.ERROR, 
					IEclipseMECoreConstants.PLUGIN_ID, 
					-999,
					"Illegal Manifest Entry Key or Value \"" + e.getMessage() + "\"", 
					e);

				throw new CoreException(s);
			}
		}
		
		if (buildLoggingConfig.isPreverifierTraceEnabled()) {
			BuildConsoleProxy.instance.traceln("- PreverificationBuilder.generateDeployedManifest setting MIDlet definitions");
		}
		int index = 1;
		Iterator iter = applicationDescriptor.getMidletDefinitions().iterator();
		while (iter.hasNext()) {
			MidletDefinition def = (MidletDefinition) iter.next();
			String key = ApplicationDescriptor.MIDLET_PREFIX + (index++);
			String value = def.toString();
			if (buildLoggingConfig.isPreverifierTraceEnabled()) {
				BuildConsoleProxy.instance.traceln("- PreverificationBuilder.generateDeployedManifest -- " + key + " -> " + value);
			}
			mainAttributes.putValue(key, value);
		}

		FileOutputStream fos = null;
		File manifestFile = new File(getRuntimeJar(project, monitor), "META-INF/MANIFEST.MF");
		if (buildLoggingConfig.isPreverifierTraceEnabled()) {
			BuildConsoleProxy.instance.traceln("- PreverificationBuilder.generateDeployedManifest writing manifest file: " + manifestFile);
		}
		try {
			fos = new FileOutputStream(manifestFile);
			jarManifest.write(fos);
		} catch (IOException e) {
			if (buildLoggingConfig.isPreverifierTraceEnabled()) {
				BuildConsoleProxy.instance.traceln("- PreverificationBuilder.generateDeployedManifest exception: " + e);
			}
			Status s = new Status(
				IStatus.ERROR, 
				IEclipseMECoreConstants.PLUGIN_ID, 
				-999,
				"Illegal Manifest Entry Key or Value \"" + e.getMessage() + "\"", 
				e);

			throw new CoreException(s);
		} finally {
			try { fos.close(); } catch (IOException e) {}
		}

		if (buildLoggingConfig.isPreverifierTraceEnabled()) {
			BuildConsoleProxy.instance.traceln("< PreverificationBuilder.generateDeployedManifest suite = " + midletSuite.getProject());
		}
	}

	/**
	 * Construct a new builder instance.
	 *
	 */
	public PreverificationBuilder() {
	}
	
	/**
	 * @see org.eclipse.core.resources.IncrementalProjectBuilder#build(int, java.util.Map, org.eclipse.core.runtime.IProgressMonitor)
	 */
	protected IProject[] build(int kind, Map args, IProgressMonitor monitor)
		throws CoreException 
	{	
		IProject project = getProject();
		if (buildLoggingConfig.isPreverifierTraceEnabled()) {
			BuildConsoleProxy.instance.traceln("> PreverificationBuilder.build project = " + project);
		}
		
		IJavaProject rootJavaProject = JavaCore.create(project); 
		IJavaProject javaProject = rootJavaProject;
		IJavaProject[] requiredProjects = getRequiredProjects(javaProject, monitor);

		// TODO Fix monitoring	
		monitor.beginTask("Preverification", requiredProjects.length + 1);
		BuildInfo buildInfo = new BuildInfo(kind, args,	javaProject);
		
		// Update the manifest version if specified
		boolean updateVersionForProject = 
			PreferenceAccessor.instance.getAutoversionPackage(project) &&
			buildInfo.isBuildArgumentTrue(ARG_UPDATE_VERSION);
		if (updateVersionForProject) {
			updateJADVersion(buildInfo, monitor);
		} else {
			generateDeployedManifest(buildInfo.getMidletSuite(), monitor);
		}

		// Start with our project
		preverifyProject(buildInfo, monitor);
		
		// Now prereq projects
		for (int i = 0; i < requiredProjects.length; i++) {
			javaProject = requiredProjects[i];
			if (javaProject != null) {
				buildInfo.setCurrentJavaProject(javaProject);
				preverifyProject(buildInfo, monitor);
			}
		}
		
		// Make sure all of the libraries in the project have been
		// preverified
		if (buildInfo.isClasspathChanged() && buildInfo.areLibrariesPreverified()) {
			IFolder libsFolder = buildInfo.getVerifiedLibsFolder(monitor);
			Utils.clearContainer(libsFolder, monitor);

			buildInfo.setCurrentJavaProject(rootJavaProject);
			preverifyLibraries(buildInfo, monitor);

			for (int i = 0; i < requiredProjects.length; i++) {
				javaProject = requiredProjects[i];
				buildInfo.setCurrentJavaProject(javaProject);
				preverifyLibraries(buildInfo, monitor);
			}
		}
		
		// Convert to IProject instances 
		IProject[] interestingProjects = new IProject[requiredProjects.length];
		for (int i = 0; i < requiredProjects.length; i++) {
			interestingProjects[i] = requiredProjects[i].getProject();
		}
		
		// Make sure that the TrueZIP caches are forced out to the file system
		// and update the JAD file to contain the correct size
		if (buildInfo.isPackageDirty()) {
			try {
				File runtimeJar = buildInfo.getRuntimeJarFile(monitor);
				File.umount(runtimeJar, true, true, true, true);
				writeJADFile(buildInfo, runtimeJar, buildInfo.getRuntimeFolder(monitor), true, monitor);
			} catch (ArchiveException e) {
				EclipseMECorePlugin.throwCoreException(IStatus.ERROR, -999, e);
			}
		}

		// Obfuscate as requested
		if (buildInfo.isBuildArgumentTrue(ARG_DO_PACKAGE)) {
			buildInfo.setPackageDirty(true);

			if (buildInfo.isBuildArgumentTrue(ARG_DO_OBFUSCATION)) {
				doObfuscation(buildInfo, monitor);
			} else {
				copyRuntimeJarToDeploymentFolder(buildInfo, monitor);
			}
		}

		// Refresh...
		if (buildInfo.isPackageDirty()) {
			generateDeployedManifest(buildInfo.getMidletSuite(), monitor);
			IFolder deployedFolder = getDeploymentFolder(project, monitor);
			deployedFolder.refreshLocal(IResource.DEPTH_INFINITE, monitor);
			
			// Set all of the resources in the verified path
			// to be derived resources
			setResourcesAsDerived(buildInfo.getVerifiedClassesFolder(monitor), monitor);
			setResourcesAsDerived(buildInfo.getVerifiedLibsFolder(monitor), monitor);
			setResourcesAsDerived(buildInfo.getRuntimeFolder(monitor), monitor);
		}
		
		monitor.done();
		
		if (buildLoggingConfig.isPreverifierTraceEnabled()) {
			BuildConsoleProxy.instance.traceln("< PreverificationBuilder.build project = " + project);
		}
		return interestingProjects;
	}

	/* (non-Javadoc)
	 * @see org.eclipse.core.internal.events.InternalBuilder#clean(org.eclipse.core.runtime.IProgressMonitor)
	 */
	protected void clean(IProgressMonitor monitor) 
		throws CoreException 
	{
		IProject project = getProject();
		
		if (buildLoggingConfig.isPreverifierTraceEnabled()) {
			BuildConsoleProxy.instance.traceln("> PreverificationBuilder.clean project = " + project);
		}

		super.clean(monitor);
		cleanProject(project, false, monitor);
		
		// Regenerate the manifest
		IMidletSuiteProject suite = 
			MidletSuiteFactory.getMidletSuiteProject(JavaCore.create(getProject()));
		generateDeployedManifest(suite, monitor);

		if (buildLoggingConfig.isPreverifierTraceEnabled()) {
			BuildConsoleProxy.instance.traceln("< PreverificationBuilder.clean project = " + project);
		}
	}

	/**
	 * Copy the runtime jar file to the deployed folder.
	 * 
	 * @param buildInfo
	 * @param monitor
	 * @throws CoreException
	 */
	private void copyRuntimeJarToDeploymentFolder(BuildInfo buildInfo, IProgressMonitor monitor)
		throws CoreException
	{
		if (buildLoggingConfig.isPreverifierTraceEnabled()) {
			BuildConsoleProxy.instance.traceln("> PreverificationBuilder.copyRuntimeJarToDeploymentFolder");
		}

		FileInputStream fis = null;
		
		try {
			File runtimeJar = getRuntimeJar(getProject(), monitor);
			fis = new FileInputStream(runtimeJar);
			
			IFolder deploymentFolder = getDeploymentFolder(buildInfo, monitor);
			IFile deployedJar = deploymentFolder.getFile(runtimeJar.getName());
			if (deployedJar.exists()) {
				deployedJar.setContents(fis, true, false, monitor);
			} else {
				deployedJar.create(fis, true, monitor);
			}
				
			writeJADFile(buildInfo, new File(deployedJar.getLocation().toFile()), deploymentFolder, false, monitor);

		} catch (IOException e) {
			EclipseMECorePlugin.throwCoreException(IStatus.ERROR, 999, e);
		} finally {
			if (fis != null) {
				try { fis.close(); } catch (IOException e) { }
			}
		}
		
		if (buildLoggingConfig.isPreverifierTraceEnabled()) {
			BuildConsoleProxy.instance.traceln("< PreverificationBuilder.copyRuntimeJarToDeploymentFolder");
		}
	}

	/**
	 * Do the work to obfuscate the jar file.
	 * @param deployedJarFile
	 * @param monitor
	 * 
	 * @throws CoreException
	 */
	private void doObfuscation(BuildInfo buildInfo, IProgressMonitor monitor) 
		throws CoreException 
	{
		if (buildLoggingConfig.isPreverifierTraceEnabled()) {
			BuildConsoleProxy.instance.traceln("> PreverificationBuilder.doObfuscation");
		}

		final StringBuffer errorText = new StringBuffer();

		File runtimeJar = buildInfo.getRuntimeJarFile(monitor);
		BuildConsoleProxy.instance.traceln("Obfuscating " + runtimeJar);

		// Calculate the name of the obfuscated jar file name...
		Path runtimeJarPath = new Path(runtimeJar.getAbsolutePath());
		String basename = runtimeJarPath.lastSegment();
		basename = basename.substring(0, basename.length() - 4); // Making an assumption of .jar file extension
			
		IFolder deploymentFolder = getDeploymentFolder(buildInfo, monitor);
		IFile obfuscatedJarFile = deploymentFolder.getFile(basename + "_obf.jar");
		IFile deployedJarFile = deploymentFolder.getFile(runtimeJarPath.lastSegment());
		
		BuildConsoleProxy.instance.traceln("Obfuscating to output jar " + obfuscatedJarFile.getLocation().toFile());
		
		ObfuscatorTool obfuscator = 
			new ObfuscatorTool(buildInfo.getMidletSuite(), runtimeJar, obfuscatedJarFile.getLocation().toFile());
		ILaunch launch = obfuscator.launch(monitor);
		
		// Snag any error output that might occur
		final StringBuffer stdoutBuffer = new StringBuffer();
		IProcess[] processes = launch.getProcesses();
		if ((processes != null) && (processes.length > 0)) {
			IProcess process = processes[0];
			IStreamsProxy proxy = process.getStreamsProxy();
			
			// Wire up a listener to write to the console if logging is 
			// enabled
			if (buildLoggingConfig.isObfuscationOutputEnabled()) {
				BuildConsoleProxy.instance.traceln("======================== Launching Obfuscation =========================");
				BuildConsoleProxy.instance.addConsoleStreamListener(
					IBuildConsoleProxy.ID_ERROR_STREAM, 
					proxy.getErrorStreamMonitor());
				BuildConsoleProxy.instance.addConsoleStreamListener(
					IBuildConsoleProxy.ID_OUTPUT_STREAM, 
					proxy.getOutputStreamMonitor());
			}
			
			proxy.getErrorStreamMonitor().addListener(new IStreamListener() {
				public void streamAppended(String text, IStreamMonitor monitor) {
					errorText.append(text);
				}
			});
			
			// Wait until completion
			while ((!monitor.isCanceled()) && (!process.isTerminated())) {
				try { Thread.sleep(1000); } catch (InterruptedException e) {};
			}

			if (buildLoggingConfig.isObfuscationOutputEnabled()) {
				BuildConsoleProxy.instance.traceln("======================== Obfuscation exited with code: " + process.getExitValue());
			}
			
			// Log the stdout if requested
			if (stdoutBuffer.length() > 0) {
				EclipseMECorePlugin.log(IStatus.INFO, stdoutBuffer.toString());
			}
			
			// Let the user know that something went wrong if necessary
			boolean doFinalPreverify = true;
			if (errorText.length() > 0) {
				String text = errorText.toString();
				IStatus status = new Status(
					IStatus.ERROR, 
					IEclipseMECoreConstants.PLUGIN_ID, 
					IEclipseMECoreConstants.ERR_OBFUSCATION_ERRORS, 
					text, null);
				
				Boolean response = (Boolean) EclipseMECorePlugin.statusPrompt(status, this);
				doFinalPreverify = (response != null) ? response.booleanValue() : false;
			} 
			
			if (doFinalPreverify) {
				doPostObfuscationPreverification(buildInfo, obfuscatedJarFile, deployedJarFile, monitor);
			}
		}