Java ProcessOutputHandler类代码示例

import com.android.ide.common.process.ProcessOutputHandler; //导入依赖的package包/类
public static ProcessResult run(
            @NonNull DexProcessBuilder processBuilder,
            @NonNull DexOptions dexOptions,
            @NonNull ProcessOutputHandler outputHandler) throws IOException, ProcessException {
        ProcessOutput output = outputHandler.createOutput();
        int res;
        try {
//            DxConsole.out = outputHandler.createOutput().getStandardOutput();
//            DxConsole.err = outputHandler.createOutput().getErrorOutput();
            DxConsole dxConsole = new DxConsole();
            Main.Arguments args = buildArguments(processBuilder, dexOptions, dxConsole);
            res = new Main().run(args);
        } finally {
            output.close();
        }

        outputHandler.handleOutput(output);
        return new DexProcessResult(res);
    }
 

import com.android.ide.common.process.ProcessOutputHandler; //导入依赖的package包/类
@Override
public void convertByteCode(Collection<File> inputs,
                            File outDexFolder,
                            boolean multidex,
                            File mainDexList,
                            DexOptions dexOptions,
                            ProcessOutputHandler processOutputHandler)
    throws IOException, InterruptedException, ProcessException {

    boolean fastMultiDex = null != multiDexer;

    if (multidex) {
        super.convertByteCode(inputs, outDexFolder, multidex, mainDexList, dexOptions, processOutputHandler);
    } else {
        convertByteCode(inputs, outDexFolder, multidex, mainDexList, dexOptions, processOutputHandler, false);
    }

}
 

import com.android.ide.common.process.ProcessOutputHandler; //导入依赖的package包/类
public AidlProcessor(
        @NonNull String aidlExecutable,
        @NonNull String frameworkLocation,
        @NonNull List<File> importFolders,
        @NonNull File sourceOutputDir,
        @Nullable File parcelableOutputDir,
        @NonNull DependencyFileProcessor dependencyFileProcessor,
        @NonNull ProcessExecutor processExecutor,
        @NonNull ProcessOutputHandler processOutputHandler) {
    mAidlExecutable = aidlExecutable;
    mFrameworkLocation = frameworkLocation;
    mImportFolders = importFolders;
    mSourceOutputDir = sourceOutputDir;
    mParcelableOutputDir = parcelableOutputDir;
    mDependencyFileProcessor = dependencyFileProcessor;
    mProcessExecutor = processExecutor;
    mProcessOutputHandler = processOutputHandler;
}
 

import com.android.ide.common.process.ProcessOutputHandler; //导入依赖的package包/类
/**
 * Creates an AndroidBuilder.
 * <p/>
 * <var>verboseExec</var> is needed on top of the ILogger due to remote exec tools not being
 * able to output info and verbose messages separately.
 *
 * @param createdBy the createdBy String for the apk manifest.
 * @param logger the Logger
 * @param verboseExec whether external tools are launched in verbose mode
 */
public AndroidBuilder(
        @NonNull String projectId,
        @Nullable String createdBy,
        @NonNull ProcessExecutor processExecutor,
        @NonNull JavaProcessExecutor javaProcessExecutor,
        @NonNull ProcessOutputHandler processOutputHandler,
        @NonNull EvaluationErrorReporter errorHandler,
        @NonNull ILogger logger,
        boolean verboseExec) {
    mProjectId = checkNotNull(projectId);
    mCreatedBy = createdBy;
    mProcessExecutor = checkNotNull(processExecutor);
    mJavaProcessExecutor = checkNotNull(javaProcessExecutor);
    mProcessOutputHandler = checkNotNull(processOutputHandler);
    mErrorHandler = checkNotNull(errorHandler);
    mLogger = checkNotNull(logger);
    mVerboseExec = verboseExec;
}
 

import com.android.ide.common.process.ProcessOutputHandler; //导入依赖的package包/类
@NonNull
@Override
public ProcessResult execute(@NonNull JavaProcessInfo javaProcessInfo,
        @NonNull ProcessOutputHandler processOutputHandler) {
    try {
        Thread.sleep(1000);
        throw new IOException("foo");
    } catch (final Exception e) {
        return new ProcessResult() {
            @Override
            public ProcessResult assertNormalExitValue() throws ProcessException {
                return this;
            }

            @Override
            public int getExitValue() {
                return 0;
            }

            @Override
            public ProcessResult rethrowFailure() throws ProcessException {
                throw new ProcessException(null, e);
            }
        };
    }
}
 

import com.android.ide.common.process.ProcessOutputHandler; //导入依赖的package包/类
private void doTaskAction(@Nullable Collection<File> inputFiles,
                          @Nullable File inputDir,
                          boolean incremental) throws InterruptedException, ProcessException, IOException {

    File outFolder = getOutputFolder();
    if (!incremental) {
        emptyFolder(outFolder);
    }

    // if some of our .jar input files exist, just reset the inputDir to null
    for (File inputFile : inputFiles) {
        if (inputFile.exists()) {
            inputDir = null;
        }
    }
    if (inputDir != null) {
        inputFiles = getProject().files(inputDir).getFiles();
    }
    ProcessOutputHandler outputHandler = new ParsingProcessOutputHandler(new ToolOutputParser(
        new DexParser(),
        Message.Kind.ERROR,
        getILogger()),
                                                                         new ToolOutputParser(
                                                                             new DexParser(),
                                                                             getILogger()),
                                                                         getBuilder().getErrorReporter());

    getBuilder().convertByteCode(inputFiles,
                                 getOutputFolder(),
                                 getMultiDexEnabled(),
                                 getMainDexListFile(),
                                 getDexOptions(),
                                 outputHandler);
}
 

import com.android.ide.common.process.ProcessOutputHandler; //导入依赖的package包/类
/**
 * Deal with awb resources
 *
 * @param aaptCommand
 * @param enforceUniquePackageName
 * @param processOutputHandler
 * @param mainSymbolFile
 */
public void processAwbResources(AaptPackageProcessBuilder aaptCommand,
                                boolean enforceUniquePackageName,
                                ProcessOutputHandler processOutputHandler,
                                File mainSymbolFile) throws IOException, InterruptedException, ProcessException {
    if (!atlasExtension.getTBuildConfig().getUseCustomAapt()) {
        throw new StopExecutionException("Must set useCustomAapt value to true for awb build!");
    }

    checkState(getTargetInfo() != null,
               "Cannot call processResources() before setTargetInfo() is called.");

    // launch aapt: create the command line
    ProcessInfo processInfo = aaptCommand.build(getTargetInfo().getBuildTools(),
                                                getTargetInfo().getTarget(),
                                                getLogger());

    processInfo = new TProcessInfo(processInfo, aaptCommand.getSymbolOutputDir());

    // Print log
    //        if (null != getLogger()) {
    //            getLogger().info("[Aapt]" + processInfo.getExecutable() + " "
    //                    + StringUtils.join(processInfo.getArgs(), " "));
    //        }

    ProcessResult result = getProcessExecutor().execute(processInfo, processOutputHandler);
    result.rethrowFailure().assertNormalExitValue();

    processAwbSymbols(aaptCommand, mainSymbolFile, enforceUniquePackageName);
}
 

import com.android.ide.common.process.ProcessOutputHandler; //导入依赖的package包/类
/**
 * Creates a new entry point to the original {@code aapt}.
 *
 * @param processExecutor      the executor for external processes
 * @param processOutputHandler the handler to process the executed process' output
 * @param buildToolInfo        the build tools to use
 * @param logger               logger to use
 * @param processMode          the process mode to run {@code aapt} on
 * @param cruncherProcesses    if using build tools that support crunching processes, how many
 *                             processes to use; if set to {@code 0}, the default number will be used
 */
public AtlasAapt(ProcessExecutor processExecutor,
                 ProcessOutputHandler processOutputHandler,
                 BuildToolInfo buildToolInfo,
                 ILogger logger,
                 PngProcessMode processMode,
                 int cruncherProcesses) {
    super(processExecutor,
          processOutputHandler,
          buildToolInfo,
          logger,
          processMode,
          cruncherProcesses);
}
 

import com.android.ide.common.process.ProcessOutputHandler; //导入依赖的package包/类
public void build(
        @NonNull ProcessExecutor processExecutor,
        @NonNull ProcessOutputHandler processOutputHandler)
        throws InterruptedException, ProcessException, LoggedErrorException, IOException {

    // gather the files to compile
    FileGatherer fileGatherer = new FileGatherer();
    SourceSearcher searcher = new SourceSearcher(mSourceFolders, "rs", "fs");
    searcher.setUseExecutor(false);
    searcher.search(fileGatherer);

    List<File> renderscriptFiles = fileGatherer.getFiles();

    if (renderscriptFiles.isEmpty()) {
        return;
    }

    // get the env var
    Map<String, String> env = Maps.newHashMap();
    if (SdkConstants.CURRENT_PLATFORM == SdkConstants.PLATFORM_DARWIN) {
        env.put("DYLD_LIBRARY_PATH", mBuildToolInfo.getLocation().getAbsolutePath());
    } else if (SdkConstants.CURRENT_PLATFORM == SdkConstants.PLATFORM_LINUX) {
        env.put("LD_LIBRARY_PATH", mBuildToolInfo.getLocation().getAbsolutePath());
    }

    doMainCompilation(renderscriptFiles, processExecutor, processOutputHandler, env);

    if (mSupportMode) {
        createSupportFiles(processExecutor, processOutputHandler, env);
    }
}
 

import com.android.ide.common.process.ProcessOutputHandler; //导入依赖的package包/类
private File createSupportObjFile(
        @NonNull File bcFile,
        @NonNull Abi abi,
        @NonNull String objName,
        @NonNull File objAbiFolder,
        @NonNull ProcessExecutor processExecutor,
        @NonNull ProcessOutputHandler processOutputHandler,
        @NonNull Map<String, String> env) throws ProcessException {

    ProcessInfoBuilder builder = new ProcessInfoBuilder();
    builder.setExecutable(mBuildToolInfo.getPath(BuildToolInfo.PathId.BCC_COMPAT));
    builder.addEnvironments(env);

    builder.addArgs("-O" + Integer.toString(mOptimLevel));

    File outFile = new File(objAbiFolder, objName);
    builder.addArgs("-o", outFile.getAbsolutePath());

    builder.addArgs("-fPIC");
    builder.addArgs("-shared");

    builder.addArgs("-rt-path", mLibClCore.get(abi.mDevice).getAbsolutePath());

    builder.addArgs("-mtriple", abi.mToolchain);

    builder.addArgs(bcFile.getAbsolutePath());

    processExecutor.execute(
            builder.createProcess(), processOutputHandler)
            .rethrowFailure().assertNormalExitValue();

    return outFile;
}
 

import com.android.ide.common.process.ProcessOutputHandler; //导入依赖的package包/类
private void createSupportLibFile(
        @NonNull File objFile,
        @NonNull Abi abi,
        @NonNull String soName,
        @NonNull File libAbiFolder,
        @NonNull ProcessExecutor processExecutor,
        @NonNull ProcessOutputHandler processOutputHandler,
        @NonNull Map<String, String> env) throws ProcessException {

    File intermediatesFolder = new File(mRsLib, "intermediates");
    File intermediatesAbiFolder = new File(intermediatesFolder, abi.mDevice);
    File packagedFolder = new File(mRsLib, "packaged");
    File packagedAbiFolder = new File(packagedFolder, abi.mDevice);

    ProcessInfoBuilder builder = new ProcessInfoBuilder();
    builder.setExecutable(mBuildToolInfo.getPath(abi.mLinker));
    builder.addEnvironments(env);

    builder.addArgs("--eh-frame-hdr")
            .addArgs(abi.mLinkerArgs)
            .addArgs("-shared", "-Bsymbolic", "-z", "noexecstack", "-z", "relro", "-z", "now");

    File outFile = new File(libAbiFolder, soName);
    builder.addArgs("-o", outFile.getAbsolutePath());

    builder.addArgs(
            "-L" + intermediatesAbiFolder.getAbsolutePath(),
            "-L" + packagedAbiFolder.getAbsolutePath(),
            "-soname",
            soName,
            objFile.getAbsolutePath(),
            new File(intermediatesAbiFolder, "libcompiler_rt.a").getAbsolutePath(),
            "-lRSSupport",
            "-lm",
            "-lc");

    processExecutor.execute(
            builder.createProcess(), processOutputHandler)
            .rethrowFailure().assertNormalExitValue();
}
 

import com.android.ide.common.process.ProcessOutputHandler; //导入依赖的package包/类
@NonNull
private static PngCruncher getCruncher() {
    ILogger logger = new StdLogger(StdLogger.Level.VERBOSE);
    ProcessExecutor processExecutor = new DefaultProcessExecutor(logger);
    ProcessOutputHandler processOutputHandler = new LoggedProcessOutputHandler(logger);
    File aapt = NinePatchAaptProcessorTestUtils.getAapt(FullRevision.parseRevision("21"));
    return new AaptCruncher(aapt.getAbsolutePath(), processExecutor, processOutputHandler);
}
 

import com.android.ide.common.process.ProcessOutputHandler; //导入依赖的package包/类
public AaptCruncher(
        @NonNull String aaptLocation,
        @NonNull ProcessExecutor processExecutor,
        @NonNull ProcessOutputHandler processOutputHandler) {
    mAaptLocation = aaptLocation;
    mProcessExecutor = processExecutor;
    mProcessOutputHandler = processOutputHandler;
}
 

import com.android.ide.common.process.ProcessOutputHandler; //导入依赖的package包/类
@Override
protected void doFullTaskAction() throws IOException {
    // we have to clean the source folder output in case the package name changed.
    File srcOut = getSourceOutputDir();
    if (srcOut != null) {
        // FileUtils.emptyFolder(srcOut);
        srcOut.delete();
        srcOut.mkdirs();
    }

    @Nullable
    File resOutBaseNameFile = getPackageOutputFile();

    // If are in instant run mode and we have an instant run enabled manifest

    File manifestFileToPackage = getManifestFile();

    // Add additional parameters required for the awb module to compile
    addAaptOptions();
    AaptPackageProcessBuilder aaptPackageCommandBuilder = new AaptPackageProcessBuilder(
        manifestFileToPackage,
        getAaptOptions()).setAssetsFolder(getAssetsDir())
        .setResFolder(getResDir())
        .setLibraries(getLibraries())
        .setPackageForR(getPackageForR())
        .setSourceOutputDir(absolutePath(srcOut))
        .setSymbolOutputDir(absolutePath(getTextSymbolOutputDir()))
        .setResPackageOutput(absolutePath(resOutBaseNameFile))
        .setProguardOutput(absolutePath(getProguardOutputFile()))
        .setType(getType())
        .setDebuggable(getDebuggable())
        .setPseudoLocalesEnabled(getPseudoLocalesEnabled())
        .setResourceConfigs(getResourceConfigs())
        .setSplits(getSplits())
        .setPreferredDensity(getPreferredDensity());

    @NonNull
    AtlasBuilder builder = (AtlasBuilder)getBuilder();

    // MergingLog mergingLog = new MergingLog(getMergeBlameLogFolder());
    //
    // ProcessOutputHandler processOutputHandler = new ParsingProcessOutputHandler(
    // new ToolOutputParser(new AaptOutputParser(), getILogger()),
    // builder.getErrorReporter());

    ProcessOutputHandler processOutputHandler = new LoggedProcessOutputHandler(getILogger());

    try {
        builder.processAwbResources(aaptPackageCommandBuilder,
                                    getEnforceUniquePackageName(),
                                    processOutputHandler,
                                    getMainSymbolFile());
    } catch (Throwable e) {
        throw new GradleException(e.getMessage(), e);
    }

}
 

import com.android.ide.common.process.ProcessOutputHandler; //导入依赖的package包/类
@Override
public void processResources(Aapt aapt,
                             Builder aaptConfigBuilder,
                             boolean enforceUniquePackageName)
    throws IOException, InterruptedException, ProcessException {

    if (aapt instanceof AaptV1) {
        try {

            getTargetInfo();

            AaptOptions aaptOptions = (AaptOptions)FieldUtils.readField(aaptConfigBuilder.build(),
                                                                        "mAaptOptions",
                                                                        true);

            ProcessExecutor processExecutor = (ProcessExecutor)FieldUtils.readField(aapt,
                                                                                    "mProcessExecutor",
                                                                                    true);
            ProcessOutputHandler processOutputHandler = (ProcessOutputHandler)FieldUtils.readField(
                aapt,
                "mProcessOutputHandler",
                true);
            BuildToolInfo buildToolInfo = (BuildToolInfo)FieldUtils.readField(aapt,
                                                                              "mBuildToolInfo",
                                                                              true);
            PngProcessMode processMode = (PngProcessMode)FieldUtils.readField(aapt,
                                                                              "mProcessMode",
                                                                              true);
            int cruncherProcesses = aaptOptions.getCruncherProcesses();

            aapt = new AtlasAapt(processExecutor,
                                 processOutputHandler,
                                 buildToolInfo,
                                 getLogger(),
                                 processMode,
                                 cruncherProcesses);
        } catch (Throwable e) {
            throw new GradleException("aapt exception", e);
        }
    }

    if (atlasExtension.getTBuildConfig().isIncremental()) {
        processResources2(aapt, aaptConfigBuilder, enforceUniquePackageName);
    } else {
        super.processResources(aapt, aaptConfigBuilder, enforceUniquePackageName);
    }
}