File src = directoryInput.getFile(); File dst = invocation.getOutputProvider().getContentLocation( directoryInput.getName(), directoryInput.getContentTypes(), directoryInput.getScopes(), Format.DIRECTORY); try { scanDir(src, initClasses);
File inputDir = directoryInput.getFile(); if (transformInvocation.isIncremental()) { for (Map.Entry<File, Status> changedInput : directoryInput.getChangedFiles().entrySet()) {
@Test public void addDirectoryInput_builtShouldReturnCorrectFile() throws Exception { File file = getTmpFile("tmp"); TransformInput input = builder.addDirectoryInput(file).build(); assertThat(input.getDirectoryInputs()).hasSize(1); assertThat(input.getDirectoryInputs().toArray(new DirectoryInput[1])[0].getFile()) .isEqualTo(file); }
.getChangedFiles() .entrySet()) { try { splitsToBuild.add( new DexFiles(dexFiles, directoryInput.getName())); } catch (Exception e) { throw new TransformException(e); File[] files = directoryInput.getFile().listFiles(); if (files == null) { continue; new DexFiles(ImmutableSet.copyOf(files), directoryInput.getName())); } catch (Exception e) { throw new TransformException(e);
for (TransformInput input : invocation.getReferencedInputs()) { for (DirectoryInput directoryInput : input.getDirectoryInputs()) { if (!directoryInput.getContentTypes() .contains(ExtendedContentType.CLASSES_ENHANCED)) { continue; final File folder = directoryInput.getFile(); if (invocation.isIncremental()) { for (Map.Entry<File, Status> entry : directoryInput.getChangedFiles().entrySet()) { if (entry.getValue() != Status.REMOVED) { File file = entry.getKey();
private static boolean hasChangedInputs(Collection<TransformInput> inputs) { for (TransformInput input : inputs) { for (DirectoryInput directoryInput : input.getDirectoryInputs()) { if (!directoryInput.getChangedFiles().isEmpty()) { return true; } } for (JarInput jarInput : input.getJarInputs()) { if (jarInput.getStatus() != Status.NOTCHANGED) { return true; } } } return false; } }
private Stream<Path> toStream(DirectoryInput dir) { try { return Files.walk(dir.getFile().toPath()).filter(Files::isRegularFile); } catch (IOException e) { throw new UncheckedIOException(e); } } }
private static boolean isIncrementalRun( boolean isIncremental, @NonNull Collection<TransformInput> referencedInputs) { if (!isIncremental) { return false; } for (TransformInput referencedInput : referencedInputs) { for (JarInput jarInput : referencedInput.getJarInputs()) { if (jarInput.getStatus() != Status.NOTCHANGED) { return false; } } for (DirectoryInput directoryInput : referencedInput.getDirectoryInputs()) { if (!directoryInput.getChangedFiles().isEmpty()) { return false; } } } return true; }
Collection<DirectoryInput> directoryInputs = input.getDirectoryInputs(); for (DirectoryInput directoryInput : directoryInputs) { MyInjects.inject(directoryInput.getFile().getAbsolutePath(),mProject); File dest = outputProvider.getContentLocation(directoryInput.getName(),directoryInput.getContentTypes(),directoryInput.getScopes(), Format.DIRECTORY); FileUtils.copyDirectory(directoryInput.getFile(),dest);
for (Map.Entry<File, Status> changedFile : directoryInput.getChangedFiles() .entrySet()) { fileToProcess, directoryInput.getFile());
DirectoryTask(DirectoryInput directory, boolean includeNotChanged, boolean incremental, boolean write, Visitor.Factory factory, @Nullable Set<String> targets) { this.d = directory; this.includeNotChanged = includeNotChanged; this.incremental = incremental; this.write = write; this.factory = factory; this.targets = targets; this.base = d.getFile().toURI(); }
private void incrementalUpdate(@NonNull Collection<TransformInput> inputs) { inputs.forEach(input -> input.getDirectoryInputs().forEach(directoryInput -> { directoryInput.getChangedFiles().forEach((file, status) -> { if (isResource(file.getName())) { switch (status) {
if (incremental && d.getChangedFiles().isEmpty()) { return null; List<Future<ClassEntry>> futures = !write ? null : new ArrayList<>(); File outRoot = invocation.getOutputProvider().getContentLocation(d.getName(), d.getContentTypes(), d.getScopes(), Format.DIRECTORY); if (d.getFile().exists()) { // we check if directory removed for capt in full mode & transform in incremental mode for (File file : Files.fileTreeTraverser().preOrderTraversal(d.getFile())) { if (file.isFile() && file.getName().endsWith(".class")) { String className = fileToClassName(file); Map<File, Status> changed = d.getChangedFiles(); if (includeNotChanged) { for (File file : Files.fileTreeTraverser().preOrderTraversal(d.getFile())) { if (file.isFile() && file.getName().endsWith(".class")) { String className = fileToClassName(file); for (Map.Entry<File, Status> entry : d.getChangedFiles().entrySet()) { Status status = entry.getValue(); if (entry.getKey().getName().endsWith(".class")) {
directoryInput -> !directoryInput.getChangedFiles().isEmpty()); File[] files = directoryInput.getFile().listFiles(); if (files != null) { dexFiles.add(files);
private static void addAllClassLocations(TransformInput transformInput, List<URL> into) throws MalformedURLException { for (DirectoryInput directoryInput : transformInput.getDirectoryInputs()) { into.add(directoryInput.getFile().toURI().toURL()); } for (JarInput jarInput : transformInput.getJarInputs()) { into.add(jarInput.getFile().toURI().toURL()); } }
for (final Map.Entry<File, Status> changedFile : directoryInput.getChangedFiles().entrySet()) { mExecutor.execute(new Callable<Void>() { @Override
for (; iterator.hasNext(); ) { DirectoryInput input = iterator.next(); File file = input.getFile(); if (file.isDirectory()) { processRecursively(file); File dest = outputProvider.getContentLocation(input.getName(), input.getContentTypes(), input.getScopes(), Format.DIRECTORY); FileUtils.copyDirectory(input.getFile(), dest); } else { System.out.println("outputProvider is null");
@Override public void transform(@NonNull TransformInvocation invocation) throws IOException, TransformException, InterruptedException { checkNotNull(invocation.getOutputProvider(), "Missing output object for transform " + getName()); File outputDir = invocation.getOutputProvider().getContentLocation( "main", getOutputTypes(), getScopes(), Format.DIRECTORY); FileUtils.mkdirs(outputDir); TransformInput input = Iterables.getOnlyElement(invocation.getInputs()); // we don't want jar inputs. Preconditions.checkState(input.getJarInputs().isEmpty()); DirectoryInput directoryInput = Iterables.getOnlyElement(input.getDirectoryInputs()); File inputDir = directoryInput.getFile(); Instrumenter instrumenter = new Instrumenter(new OfflineInstrumentationAccessGenerator()); if (invocation.isIncremental()) { instrumentFilesIncremental(instrumenter, inputDir, outputDir, directoryInput.getChangedFiles()); } else { instrumentFilesFullRun(instrumenter, inputDir, outputDir); } }
@Override public void proceed() { Stream.concat( streamOf(inputs, TransformInput::getDirectoryInputs).map(input -> { Path src = input.getFile().toPath(); Path dst = getTargetPath.apply(input); return new DirProcessor(transform, src, dst); }), streamOf(inputs, TransformInput::getJarInputs).map(input -> { Path src = input.getFile().toPath(); Path dst = getTargetPath.apply(input); return new JarProcessor(transform, src, dst); }) ).forEach(Processor::proceed); }
Path inDir = directoryInput.getFile().toPath(); Path outDir = transformInvocation.getOutputProvider().getContentLocation( directoryInput.getName(), directoryInput.getContentTypes(), directoryInput.getScopes(), Format.DIRECTORY).toPath(); outDir.toFile().mkdirs(); changedFiles = directoryInput.getChangedFiles().entrySet(); } else { changedFiles = nonIncrementalFiles(inDir);