Beispiel #1
0
  public static void main(String[] args) throws OptionsParsingException, IOException {

    FileSystem fileSystem = FileSystems.getDefault();
    OptionsParser parser = OptionsParser.newOptionsParser(PlMergeOptions.class);
    parser.parse(args);
    PlMergeOptions options = parser.getOptions(PlMergeOptions.class);

    MergingArguments data = null;

    if (usingControlProtobuf(options)) {
      InputStream in = Files.newInputStream(fileSystem.getPath(options.controlPath));
      Control control = Control.parseFrom(in);
      validateControl(control);
      data = new MergingArguments(control);
    } else if (usingCommandLineArgs(options)) {
      data = new MergingArguments(options);
    } else {
      missingArg("Either --control or --out_file and at least one --source_file");
    }

    PlistMerging merging =
        PlistMerging.from(
            data,
            ImmutableMap.<String, NSObject>of(),
            new KeysToRemoveIfEmptyString("CFBundleIconFile", "NSPrincipalClass"));
    if (data.getPrimaryBundleId() != null || data.getFallbackBundleId() != null) {
      // Only set the bundle identifier if we were passed arguments to do so.
      // This prevents CFBundleIdentifiers being put into strings files.
      merging.setBundleIdentifier(data.getPrimaryBundleId(), data.getFallbackBundleId());
    }
    merging.writePlist(fileSystem.getPath(data.getOutFile()));
  }
  public static Path getPathInClasspath(URL resource) throws IOException, URISyntaxException {

    Objects.requireNonNull(resource, "Resource URL cannot be null");
    URI uri = resource.toURI();

    String scheme = uri.getScheme();
    if (scheme.equals("file")) {
      return Paths.get(uri);
    }

    if (!scheme.equals("jar")) {
      throw new IllegalArgumentException("Cannot convert to Path: " + uri);
    }

    String s = uri.toString();
    int separator = s.indexOf("!/");
    String entryName = s.substring(separator + 2);
    URI fileURI = URI.create(s.substring(0, separator));

    FileSystem fs = null;

    try {

      fs = FileSystems.newFileSystem(fileURI, Collections.<String, Object>emptyMap());

    } catch (FileSystemAlreadyExistsException e) {
      fs = FileSystems.getFileSystem(fileURI);
    }

    return fs.getPath(entryName);
  }
Beispiel #3
0
  /**
   * Creates/opens a zip file at the specified location. Does <b>not</b> create parent folders.
   *
   * @param zipFile the path to the zip file
   * @param create true if the file should be created, if non-existent
   * @param rootFirst the root folder
   * @param rootMore the rest of the path
   * @throws IOException
   */
  public ZipFileDataStore(Path zipFile, boolean create, String rootFirst, String... rootMore)
      throws IOException {
    URI zipUri = zipFile.toUri();
    URI uri = URI.create("jar:file:" + zipUri.getPath());

    FileSystem fileSys;

    try {
      fileSys = FileSystems.getFileSystem(uri);
      log.info("Opened existing file " + uri);
    } catch (FileSystemNotFoundException e) {
      // create must always be set:
      // if not a FileSystem without "create" could be created
      // and would be used ever after - there is no way a FileSystem could be removed
      Map<String, String> env = new HashMap<>();
      env.put("create", "true");
      fileSys = FileSystems.newFileSystem(uri, env);

      log.info("Created file " + uri);
    }

    this.zipFile = uri;
    this.fileSystem = fileSys;
    this.root = fileSys.getPath(rootFirst, rootMore).toAbsolutePath();

    // checking if the root already exists is done in createDirs()
    if (create) {
      Files.createDirectories(root);
    }
  }
Beispiel #4
0
  /** File store properties examined */
  @Test
  public void testRetrieveFileStoreInforamtion() throws IOException {
    FileSystem fs = FileSystems.getDefault();
    assertNotNull(fs);

    List<FileStore> stores = iterableToList(fs.getFileStores());

    // file store is device such a drive, partition or volume
    // in my system I have 3 partitions
    assertEquals(3, stores.size());

    // for storing triples of basic file store identification
    Set<String> storeNames = new HashSet<>();
    for (FileStore store : stores) {
      storeNames.add(store.name() + ";" + store.type() + ";" + store.isReadOnly());
      long total = store.getTotalSpace();
      long unallocated = store.getUnallocatedSpace();
      long usable = store.getUsableSpace();
      assertTrue(total > 0);
      assertTrue(unallocated > 0 && total >= unallocated);
      assertTrue(usable > 0 && total >= usable);
      // Just for notice of NumberFormat class existence :)
      // System.out.println(NumberFormat.getInstance().format(total));
    }

    // environment dependent
    assertEquals(
        cSET("Windows7_OS;NTFS;false", "Data;NTFS;false", "Documents;NTFS;false"), storeNames);

    // can be used for determine if file store supports such attribute view
    assertTrue(stores.get(0).supportsFileAttributeView(BasicFileAttributeView.class));
    assertFalse(stores.get(0).supportsFileAttributeView(PosixFileAttributeView.class));
  }
  public static void saveData(String file, EnumMap<PlayerStats, Float> map, boolean overwrite) {
    FileSystem fileSystem = FileSystems.getDefault();
    Path path = fileSystem.getPath(file);
    if (Files.isDirectory(path))
      throw new IllegalArgumentException("This method is not supposed to read a directory");

    if (Files.exists(path) && Files.isReadable(path)) {
      if (overwrite == false) return;
    } else
      try {
        Files.createFile(path);
      } catch (IOException e) {
        e
            .printStackTrace(); // To change body of catch statement use File | Settings | File
                                // Templates.
      }

    try (ObjectOutputStream objectOutputStream =
        new ObjectOutputStream(Files.newOutputStream(path))) {
      objectOutputStream.writeObject(map);
    } catch (IOException e) {
      e
          .printStackTrace(); // To change body of catch statement use File | Settings | File
                              // Templates.
    }
  }
 /** @throws IOException ShrinkWrap errors */
 @Override
 protected void setupPathManager() throws IOException {
   final JavaArchive homeArchive = ShrinkWrap.create(JavaArchive.class);
   final FileSystem vfs = ShrinkWrapFileSystems.newFileSystem(homeArchive);
   PathManager.getInstance().useOverrideHomePath(vfs.getPath(""));
   PathManager.getInstance().setCurrentSaveTitle("world1");
 }
 public Path[] getJarPaths() {
   Path[] paths = new Path[this.jarFiles.length];
   FileSystem fs = FileSystems.getDefault();
   for (int index = 0; index < paths.length; index++)
     paths[index] = fs.getPath(this.jarFiles[index]);
   return paths;
 }
  private Toolbox loadToolbox() throws IOException, URISyntaxException {

    Path foundPath = findToolsDir();

    Toolbox box;
    if (Files.isDirectory(foundPath)) {
      box = new Toolbox(foundPath);

      Path tempDir = Files.createTempDirectory(TOOLS_DIR_NAME);
      Path tempZipFile = tempDir.resolve(TOOLS_ZIP_NAME);

      dirToZip(foundPath, tempZipFile);
      byte[] zipContents = Files.readAllBytes(tempZipFile);
      box.setZipContents(zipContents);
      Files.delete(tempZipFile);
      Files.delete(tempDir);
    }

    // found tools zip
    else {
      FileSystem fs = FileSystems.newFileSystem(foundPath, null);
      Path toolsPath = fs.getPath(TOOLS_DIR_NAME);
      box = new Toolbox(toolsPath);

      byte[] zipContents = Files.readAllBytes(foundPath);
      box.setZipContents(zipContents);
    }

    return box;
  }
  public static void main(String[] args) {
    //		String fileName = "READ";
    String fileName = "test";
    FileSystem fileSystem = FileSystems.getDefault();
    Path root = fileSystem.getPath("./");

    final Pattern pattern = Pattern.compile(fileName);

    FileVisitor<Path> visitor =
        new SimpleFileVisitor<Path>() {
          @Override
          public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) {
            Matcher matcher = pattern.matcher(file.toString());
            if (matcher.find()) {
              // マッチしたら、表示
              System.out.println(file);
            }
            return FileVisitResult.CONTINUE;
            //				return FileVisitResult.SKIP_SUBTREE;
            // http://docs.oracle.com/javase/jp/7/api/java/nio/file/FileVisitResult.html
          }
        };
    try {
      Files.walkFileTree(root, visitor);
    } catch (IOException e) {
      e.printStackTrace();
    }
  }
Beispiel #10
0
  public static void main(String[] args) throws OptionsParsingException, IOException {
    FileSystem fileSystem = FileSystems.getDefault();
    OptionsParser parser = OptionsParser.newOptionsParser(PlMergeOptions.class);
    parser.parse(args);
    PlMergeOptions options = parser.getOptions(PlMergeOptions.class);

    if (options.controlPath == null) {
      missingArg("control");
    }

    InputStream in = Files.newInputStream(fileSystem.getPath(options.controlPath));
    Control control = Control.parseFrom(in);
    validateControl(control);

    PlistMerging merging =
        PlistMerging.from(
            control, new KeysToRemoveIfEmptyString("CFBundleIconFile", "NSPrincipalClass"));

    String primaryBundleId = Strings.emptyToNull(control.getPrimaryBundleId());
    String fallbackBundleId = Strings.emptyToNull(control.getFallbackBundleId());

    if (primaryBundleId != null || fallbackBundleId != null) {
      // Only set the bundle identifier if we were passed arguments to do so.
      // This prevents CFBundleIdentifiers being put into strings files.
      merging.setBundleIdentifier(primaryBundleId, fallbackBundleId);
    }
    merging.writePlist(fileSystem.getPath(control.getOutFile()));
  }
  /**
   * 修改渠道号
   *
   * <p>demo: <code>changeChannel("xxx../../my.apk", "hiapk");</code>
   *
   * @param zipFilename apk文件
   * @param channel 新渠道号
   * @return true or false
   */
  public static boolean buildChannel(String zipFilename, String channelPrefix, String channel) {
    try (FileSystem zipfs = createZipFileSystem(zipFilename, false)) {
      String channelBegin = "/META-INF/" + channelPrefix;
      String channelFlagName = channelBegin + channel;

      final Path root = zipfs.getPath("/META-INF/");
      ChannelFileVisitor visitor = new ChannelFileVisitor(channelBegin);
      Files.walkFileTree(root, visitor);

      Path existChannel = visitor.getChannelFile();
      Path newChannel = zipfs.getPath(channelFlagName);
      if (existChannel != null) {
        Files.move(existChannel, newChannel, StandardCopyOption.ATOMIC_MOVE);
      } else {
        Files.createFile(newChannel);
      }

      return true;

    } catch (IOException e) {
      e.printStackTrace();
    }

    return false;
  }
Beispiel #12
0
 @Test
 public void test2() {
   FileSystem fs = FileSystems.getDefault();
   Path child = fs.getPath("/tmp");
   for (Path name : fs.getPath("/tmp").relativize(fs.getPath("/tmp/test/qwe"))) {
     child = child.resolve(name);
   }
 }
Beispiel #13
0
 @Test
 public void test() throws Exception {
   FileSystem from = new DummyFileSystemProvider().getFileSystem(null);
   Path root = from.getRootDirectories().iterator().next();
   for (Path p : from.provider().newDirectoryStream(root, null)) {
     System.out.println(p);
   }
 }
Beispiel #14
0
 private static String read(String location, URI uri) throws Exception {
   try {
     FileSystem fileSystem = FileSystems.getFileSystem(uri);
     Path fsPath = fileSystem.getPath(location);
     return read(Files.newBufferedReader(fsPath, DEFAULT_CHARSET));
   } catch (ProviderNotFoundException ex) {
     return read(uri.toURL().openStream());
   }
 }
  public static void main(String[] args) {
    Path path = Paths.get("/home/docs/users.txt");
    FileSystem fileSystem = path.getFileSystem();
    Set<String> supportedViews = fileSystem.supportedFileAttributeViews();

    for (String view : supportedViews) {
      logger.debug(view);
    }
  }
Beispiel #16
0
  public static void watchDirectoryPath(Path path) {
    // Sanity check - Check if path is a folder
    try {
      Boolean isFolder = (Boolean) Files.getAttribute(path, "basic:isDirectory", NOFOLLOW_LINKS);
      if (!isFolder) {
        throw new IllegalArgumentException("Path: " + path + " is not a folder");
      }
    } catch (IOException ioe) {
      // Folder does not exists
      ioe.printStackTrace();
    }

    // System.out.println("Watching path: " + path);

    // We obtain the file system of the Path
    FileSystem fs = path.getFileSystem();

    // We create the new WatchService using the new try() block
    try (WatchService service = fs.newWatchService()) {

      // We register the path to the service
      // We watch for creation events
      path.register(service, ENTRY_CREATE);

      // Start the infinite polling loop
      WatchKey key = null;
      while (true) {
        key = service.take();

        // Dequeueing events
        Kind<?> kind = null;
        for (WatchEvent<?> watchEvent : key.pollEvents()) {
          // Get the type of the event
          kind = watchEvent.kind();
          if (OVERFLOW == kind) {
            continue; // loop
          } else if (ENTRY_CREATE == kind) {
            // A new Path was created
            // Path newPath = ((WatchEvent<Path>)
            // watchEvent).context();
            // Output
            // System.out.println("New path created: " + newPath);
          }
        }

        if (!key.reset()) {
          break; // loop
        }
      }

    } catch (IOException ioe) {
      ioe.printStackTrace();
    } catch (InterruptedException ie) {
      ie.printStackTrace();
    }
  }
  /**
   * Method to save the selected Experiment, in xml and xls (if possible), in a temporary folder.
   * The files will be contained inside a zip.
   *
   * @return String with the path of the zip file.
   * @throws IOException
   */
  private String saveExpInTempFolder() throws IOException {
    String toRet = "";

    // Create temporary File
    String filePath = Files.createTempDirectory("").toString() + "/";
    filePath = filePath.replace("\\", "/");

    // Get bioID
    String bioID = selExp.getBioID();
    if (bioID.isEmpty()) {
      bioID = "bio_";
    }

    DataToFile.saveXMLData(selExp, filePath + "xml");
    // Only save in XLS if the Experiment is an IntraExperiment
    if (!isInter) {
      DataToFile.saveXLSData(selExp, filePath + "xls");
    }

    // Generate ZIP file with Java 7
    Map<String, String> zipProperties = new HashMap<>();
    zipProperties.put("create", "true");
    zipProperties.put("encoding", "UTF-8");

    // Create zip file
    URI zipDisk;
    toRet = filePath + bioID + ".zip";
    if (toRet.startsWith("/")) {
      zipDisk = URI.create("jar:file:" + toRet);
    } else {
      zipDisk = URI.create("jar:file:/" + toRet);
    }

    // Adding files to zip
    try (FileSystem zipfs = FileSystems.newFileSystem(zipDisk, zipProperties)) {
      // Create file inside zip
      Path zipFilePath = zipfs.getPath(bioID + ".xml");
      // Path where the file to be added resides
      Path addNewFile = Paths.get(filePath + "xml.xml");
      // Append file to ZIP File
      Files.copy(addNewFile, zipFilePath);

      if (!isInter) {
        // Now go for the xls file
        zipFilePath = zipfs.getPath(bioID + ".xls");
        addNewFile = Paths.get(filePath + "xls.xls");
        Files.copy(addNewFile, zipFilePath);
      }
    }

    // Delete temp files
    Files.deleteIfExists(Paths.get(filePath + "xml.xml"));
    Files.deleteIfExists(Paths.get(filePath + "xls.xls"));

    return toRet;
  }
 public PathFilteringService(Path ignoreRulesFilePath) throws IOException {
   if (Files.exists(ignoreRulesFilePath)) {
     FileSystem fs = FileSystems.getDefault();
     this.ignoreFilesRules = new ArrayList<PathMatcher>();
     List<String> lines = Files.readAllLines(ignoreRulesFilePath, Charset.defaultCharset());
     for (String line : lines) {
       this.ignoreFilesRules.add(fs.getPathMatcher("glob:" + line));
     }
   }
 }
Beispiel #19
0
  public static void main(String[] args) throws Exception {

    final FileSystem fs = FileSystems.getFileSystem(URI.create("jrt:/"));
    final Path root = fs.getPath("/modules");

    final List<String> names =
        Files.walk(root)
            .filter(p -> p.getNameCount() > 2)
            .filter(p -> Layer.boot().findModule(p.getName(1).toString()).isPresent())
            .map(p -> p.subpath(2, p.getNameCount()))
            .map(p -> p.toString())
            .filter(s -> s.endsWith(".class") && !s.endsWith("module-info.class"))
            .collect(Collectors.toList());

    Runnable r =
        new Runnable() {
          @Override
          public void run() {
            names.forEach(
                name -> {
                  String cn = name.substring(0, name.length() - 6).replace('/', '.');
                  try {
                    Class.forName(cn, false, ClassLoader.getSystemClassLoader());
                  } catch (Exception ex) {
                    System.err.println(Thread.currentThread() + " " + ex.getClass());
                  }
                });
          }
        };

    Thread[] threads = new Thread[NTHREADS];

    for (int i = 0; i < NTHREADS; i++) {
      Thread thread = new Thread(r);
      threads[i] = thread;
      thread.start();
    }

    Thread.sleep(1);

    for (int i = 0; i < NTHREADS; i++) {
      Thread thread = threads[i];

      if (thread.isAlive()) {
        thread.interrupt();
        break;
      }
    }

    for (int i = 0; i < NTHREADS; i++) {
      Thread thread = threads[i];
      thread.join();
    }
  }
Beispiel #20
0
  private static void eachLine(String location, URI uri, EachLine eachLine) throws Exception {
    try {
      FileSystem fileSystem = FileSystems.getFileSystem(uri);
      Path fsPath = fileSystem.getPath(location);
      BufferedReader buf = Files.newBufferedReader(fsPath, DEFAULT_CHARSET);
      eachLine(buf, eachLine);

    } catch (ProviderNotFoundException ex) {
      eachLine(uri.toURL().openStream(), eachLine);
    }
  }
Beispiel #21
0
 public static void main(String[] args) throws IOException {
   Path jarfile = Paths.get("/home/punki/test.zip");
   FileSystem fs = FileSystems.newFileSystem(jarfile, null);
   Path path = fs.getPath("tekst.txt");
   System.out.println("path.toString() = " + path.toString());
   ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
   Files.copy(path, outputStream);
   System.out.println("bytes = " + new String(outputStream.toByteArray()));
   List<String> lines = Files.readAllLines(path, Charset.defaultCharset());
   for (String line : lines) {
     System.out.println("line = " + line);
   }
 }
Beispiel #22
0
  public Schema load() throws IOException {
    ImmutableList<Path> directories = this.directories.build();
    if (directories.isEmpty()) {
      throw new IllegalStateException("No directories added.");
    }

    Deque<Path> protos = new ArrayDeque<>(this.protos.build());
    if (protos.isEmpty()) {
      // TODO traverse all files in every directory.
    }

    Map<Path, ProtoFile> loaded = new LinkedHashMap<>();
    while (!protos.isEmpty()) {
      Path proto = protos.removeFirst();
      if (loaded.containsKey(proto)) {
        continue;
      }

      ProtoFileElement element = null;
      for (Path directory : directories) {
        if (proto.isAbsolute() && !proto.startsWith(directory)) {
          continue;
        }
        Path resolvedPath = directory.resolve(proto);
        if (Files.exists(resolvedPath)) {
          Location location = Location.get(directory.toString(), proto.toString());
          try (Source source = Okio.source(resolvedPath)) {
            String data = Okio.buffer(source).readUtf8();
            element = ProtoParser.parse(location, data);
          } catch (IOException e) {
            throw new IOException("Failed to load " + proto, e);
          }
          break;
        }
      }
      if (element == null) {
        throw new FileNotFoundException("Failed to locate " + proto + " in " + directories);
      }

      ProtoFile protoFile = ProtoFile.get(element);
      loaded.put(proto, protoFile);

      // Queue dependencies to be loaded.
      FileSystem fs = proto.getFileSystem();
      for (String importPath : element.imports()) {
        protos.addLast(fs.getPath(importPath));
      }
    }

    return new Linker(loaded.values()).link();
  }
Beispiel #23
0
  private static List<String> readLines(String location, URI uri) throws Exception {
    try {
      String path = location;
      path = getWindowsPathIfNeeded(path);

      FileSystem fileSystem = FileSystems.getFileSystem(uri);
      Path fsPath = fileSystem.getPath(path);

      // Paths.get()
      return Files.readAllLines(fsPath, DEFAULT_CHARSET);
    } catch (ProviderNotFoundException ex) {
      return readLines(uri.toURL().openStream());
    }
  }
Beispiel #24
0
 public static void main(String[] args) throws IOException {
   System.out.format("%-20s %12s %12s %12s\n", "Filesystem", "kbytes", "used", "avail");
   if (args.length == 0) {
     FileSystem fs = FileSystems.getDefault();
     for (FileStore store : fs.getFileStores()) {
       printFileStore(store);
     }
   } else {
     for (String file : args) {
       FileStore store = Files.getFileStore(Paths.get(file));
       printFileStore(store);
     }
   }
 }
  public void dirToZip(final Path srcDir, Path destZip) throws IOException, URISyntaxException {

    logger.debug("packaging " + srcDir + " -> " + destZip);

    if (Files.exists(destZip)) {
      logger.info("deleting existing " + destZip);
      Files.delete(destZip);
    }

    // destZip.toUri() does not work
    URI zipLocation = new URI("jar:file:" + destZip);

    // create zip
    Map<String, String> env = new HashMap<String, String>();
    env.put("create", "true");
    final FileSystem zipFs = FileSystems.newFileSystem(zipLocation, env);

    // copy recursively
    Files.walkFileTree(
        srcDir,
        new SimpleFileVisitor<Path>() {
          public FileVisitResult visitFile(Path file, BasicFileAttributes attrs)
              throws IOException {
            return copy(file);
          }

          public FileVisitResult preVisitDirectory(Path dir, BasicFileAttributes attrs)
              throws IOException {
            return copy(dir);
          }

          private FileVisitResult copy(Path src) throws IOException {
            Path dest = src.subpath(srcDir.getNameCount() - 1, src.getNameCount());
            Path destInZip = zipFs.getPath(dest.toString());

            // permissions are not necessarily correct though, so they are also reset in comp
            Files.copy(
                src,
                destInZip,
                new CopyOption[] {
                  StandardCopyOption.COPY_ATTRIBUTES, StandardCopyOption.REPLACE_EXISTING
                });
            return FileVisitResult.CONTINUE;
          }
        });

    zipFs.close();
  }
  @Override
  public void validate(Path zipFile, ApplicationData validationData)
      throws ApplicationUploadException {
    try {
      FileSystem fs = FileSystems.newFileSystem(zipFile, null);

      ValidationContext validationContext = new ValidationContext();
      Files.walkFileTree(fs.getPath("/"), new ApplicationFileVisitor(validationContext));

      for (ValidationRule rule : getValidationRules()) {
        rule.validate(validationContext, validationData);
      }
    } catch (IOException e) {
      throw new ApplicationUploadException(e);
    }
  }
Beispiel #27
0
 @Before
 public void before() throws Exception {
   fileSystem = MemoryFileSystemBuilder.newEmpty().build("test");
   defaultFile =
       TestUtil.storeFile(
           fileSystem.getPath("cpuinfo"), this.getClass().getResourceAsStream("cpuinfo.txt"));
 }
Beispiel #28
0
 public PluginContext(
     PluginManager pluginManager,
     ClassLoader classLoader,
     PluginSourceType pluginType,
     URI location,
     Plugin plugin,
     PluginImplementation pluginImplementation,
     String classLocation)
     throws IOException {
   this.pluginManager = pluginManager;
   this.classLoader = classLoader;
   this.pluginType = pluginType;
   this.location = location;
   this.plugin = plugin;
   this.pluginImplementation = pluginImplementation;
   this.classLocation = classLocation;
   switch (pluginType) {
     case ECLIPSE_PROJECT:
       fileSystem = FileSystems.getDefault();
       rootPath = Paths.get(location);
       break;
     case INTERNAL:
       break;
     case JAR_FILE:
       fileSystem = pluginManager.getOrCreateFileSystem(location);
       rootPath = fileSystem.getPath("/");
       break;
     default:
       break;
   }
 }
Beispiel #29
0
  public static void main(String[] args) {
    Stopwatch timer = Stopwatch.createStarted();
    OptionsParser optionsParser = OptionsParser.newOptionsParser(Options.class);
    optionsParser.parseAndExitUponError(args);
    Options options = optionsParser.getOptions(Options.class);

    checkFlags(options);

    FileSystem fileSystem = FileSystems.getDefault();
    Path working = fileSystem.getPath("").toAbsolutePath();

    AndroidResourceProcessor resourceProcessor =
        new AndroidResourceProcessor(new StdLogger(com.android.utils.StdLogger.Level.VERBOSE));

    try {
      Path resourcesOut = Files.createTempDirectory("tmp-resources");
      resourcesOut.toFile().deleteOnExit();
      Path assetsOut = Files.createTempDirectory("tmp-assets");
      assetsOut.toFile().deleteOnExit();
      logger.fine(String.format("Setup finished at %dms", timer.elapsed(TimeUnit.MILLISECONDS)));

      ImmutableList<DirectoryModifier> modifiers =
          ImmutableList.of(
              new PackedResourceTarExpander(working.resolve("expanded"), working),
              new FileDeDuplicator(
                  Hashing.murmur3_128(), working.resolve("deduplicated"), working));
      MergedAndroidData mergedData =
          resourceProcessor.mergeData(
              options.mainData,
              options.dependencyData,
              resourcesOut,
              assetsOut,
              modifiers,
              null,
              options.strictMerge);
      logger.info(String.format("Merging finished at %dms", timer.elapsed(TimeUnit.MILLISECONDS)));

      writeAar(options.aarOutput, mergedData, options.manifest, options.rtxt, options.classes);
      logger.info(
          String.format("Packaging finished at %dms", timer.elapsed(TimeUnit.MILLISECONDS)));

    } catch (IOException | MergingException e) {
      logger.log(Level.SEVERE, "Error during merging resources", e);
      System.exit(1);
    }
    System.exit(0);
  }
  private void insertFile(
      Path apkPath, Map<String, String> zip_properties, File insert, String method, Path location)
      throws AndrolibException, IOException {
    // ZipFileSystem only writes at .close()
    // http://mail.openjdk.java.net/pipermail/nio-dev/2012-July/001764.html
    try (FileSystem fs = FileSystems.newFileSystem(apkPath, null)) {
      Path root = fs.getPath("/");

      // in order to get the path relative to the zip, we strip off the absolute path, minus what we
      // already have in the zip. thus /var/files/apktool/apk/unknown/folder/file => /folder/file
      Path dest =
          fs.getPath(root.toString(), insert.getAbsolutePath().replace(location.toString(), ""));
      Path newFile = Paths.get(insert.getAbsolutePath());
      Files.copy(newFile, dest, StandardCopyOption.REPLACE_EXISTING);
      fs.close();
    }
  }