Public

transform

getInputTypes

getName

getOutputTypes

getParameterInputs

getReferencedScopes

getScopes

getSecondaryDirectoryOutputs

getSecondaryFileInputs

getSecondaryFileOutputs

getSecondaryFiles

isIncremental

Point

Running tasks concurrently on multiple threads

A Rectangle specifies an area in a coordinate space that is enclosed by the 
Rectangle object's top-

java.awt.Rectangle

An "abstract" representation of a file system entity identified by a pathname.
The pathname may be a

java.io.File

A charset is a named mapping between Unicode characters and byte sequences.
Every Charset can decode

java.nio.charset.Charset

A counting semaphore. Conceptually, a semaphore maintains a set of permits. Each
#acquire blocks if 

java.util.concurrent.Semaphore

javax.swing.JCheckBox

javax.swing.JFrame

Return the original filename in the client's filesystem.This may contain path
information depending 

getOriginalFilename

scheduleAtFixedRate

getSharedPreferences

"/////////////////////////begin inputs///////////////////////////////////"

/*System.out.println("-----------------enter directory " + input.getFile().getAbsolutePath() + "------------");
                if (input.getFile().isDirectory()) {
                    File[] files = input.getFile().listFiles();
                    assert files != null;
                    System.out.println("----files size->" + files.length + "----");
                    for (File file : files) {
                        String name = file.getName();
                        System.out.println("--file name->" + name + "---");
                        if (name.endsWith(".class") && !name.startsWith("R\\$") &&
                                !"R.class".equals(name) && !"BuildConfig.class".equals(name)) {
                            byte[] bytes = Files.readAllBytes(Paths.get(file.getPath()));
                            ClassReader classReader = new ClassReader(bytes);
                            ClassWriter classWriter = new ClassWriter(classReader, ClassWriter.COMPUTE_MAXS);
                            String className = name.split(".class")[0];
                            ClassVisitor classVisitor = new MyClassVisitor(className, classWriter);
                            classReader.accept(classVisitor, ClassReader.EXPAND_FRAMES);
                            byte[] code = classWriter.toByteArray();
                            String processName = file.getParentFile().getAbsolutePath() + File.separator + name;
                            FileOutputStream fos = new FileOutputStream(processName);
                            fos.write(code);
                            fos.close();
                            System.out.println("processed file-> " + processName);
                        }
                    }
                }
                File dest = outputProvider.getContentLocation(input.getName(), input.getContentTypes(), input.getScopes(), Format.DIRECTORY);
                FileUtils.copyDirectory(input.getFile(), dest);

                System.out.println("-----------------leave directory " + input.getFile().getAbsolutePath() + "------------");*/

"/////////////////////////end inputs/////////////////////////////////////"

/**
     * Executes the Transform.
     *
     * <p>The inputs are packaged as an instance of {@link TransformInvocation}
     * <ul>
     *     <li>The <var>inputs</var> collection of {@link TransformInput}. These are the inputs
     *     that are consumed by this Transform. A transformed version of these inputs must
     *     be written into the output. What is received is controlled through
     *     {@link #getInputTypes()}, and {@link #getScopes()}.</li>
     *     <li>The <var>referencedInputs</var> collection of {@link TransformInput}. This is
     *     for reference only and should be not be transformed. What is received is controlled
     *     through {@link #getReferencedScopes()}.</li>
     * </ul>
     *
     * A transform that does not want to consume anything but instead just wants to see the content
     * of some inputs should return an empty set in {@link #getScopes()}, and what it wants to
     * see in {@link #getReferencedScopes()}.
     *
     * <p>Even though a transform's {@link Transform#isIncremental()} returns true, this method may
     * be receive <code>false</code> in <var>isIncremental</var>. This can be due to
     * <ul>
     *     <li>a change in secondary files ({@link #getSecondaryFiles()},
     *     {@link #getSecondaryFileOutputs()}, {@link #getSecondaryDirectoryOutputs()})</li>
     *     <li>a change to a non file input ({@link #getParameterInputs()})</li>
     *     <li>an unexpected change to the output files/directories. This should not happen unless
     *     tasks are improperly configured and clobber each other's output.</li>
     *     <li>a file deletion that the transform mechanism could not match to a previous input.
     *     This should not happen in most case, except in some cases where dependencies have
     *     changed.</li>
     * </ul>
     * In such an event, when <var>isIncremental</var> is false, the inputs will not have any
     * incremental change information:
     * <ul>
     *     <li>{@link JarInput#getStatus()} will return {@link Status#NOTCHANGED} even though
     *     the file may be added/changed.</li>
     *     <li>{@link DirectoryInput#getChangedFiles()} will return an empty map even though
     *     some files may be added/changed.</li>
     * </ul>
     *
     * @param transformInvocation the invocation object containing the transform inputs.
     * @throws IOException if an IO error occurs.
     * @throws InterruptedException
     * @throws TransformException Generic exception encapsulating the cause.
     */

// Just delegate to old method, for code that uses the old API.

How to use transformmethodin com.android.build.api.transform.Transform

Best Java code snippets using com.android.build.api.transform.Transform.transform (Showing top 3 results out of 315)

How to use
transform
method
in
com.android.build.api.transform.Transform