Exemplo n.º 1
0
  public static void copyFile(File srcFile, File destFile) throws Exception {
    int bufferSize = 2048;

    FileInputStream in = new FileInputStream(srcFile);
    FileOutputStream out = new FileOutputStream(destFile);
    FileChannel inChannel = in.getChannel();
    FileChannel outChannel = out.getChannel();

    ByteBuffer buffer = null;
    int length = -1;
    try {
      while (true) {
        if (inChannel.position() == inChannel.size()) {
          // finish copying
          break;
        } else if (inChannel.size() - inChannel.position() < length) {
          // copy last chunk of data
          length = (int) (inChannel.size() - inChannel.position());
        } else {
          length = bufferSize;
        }

        buffer = ByteBuffer.allocateDirect(length);
        inChannel.read(buffer);
        buffer.flip();
        outChannel.write(buffer);
        outChannel.force(false);
      }
    } finally {
      _close(inChannel);
      _close(in);
      _close(outChannel);
      _close(out);
    }
  }
Exemplo n.º 2
0
  public static long copyFile(java.nio.file.Path srcfile, java.nio.file.Path dstfile)
      throws java.io.IOException {
    java.nio.channels.FileChannel inchan =
        java.nio.channels.FileChannel.open(srcfile, OPENOPTS_READ);
    java.nio.channels.FileChannel outchan = null;
    long nbytes = 0;
    long filesize;

    try {
      filesize = inchan.size();
      outchan = java.nio.channels.FileChannel.open(dstfile, OPENOPTS_CREATE_WRITE_TRUNC);
      nbytes = outchan.transferFrom(inchan, 0, inchan.size());
    } finally {
      try {
        inchan.close();
      } catch (Exception ex) {
      }
      if (outchan != null)
        try {
          outchan.close();
        } catch (Exception ex) {
        }
    }
    if (nbytes != filesize)
      throw new java.io.IOException(
          "file-copy=" + nbytes + " vs " + filesize + " for " + srcfile + " => " + dstfile);
    return nbytes;
  }
Exemplo n.º 3
0
  /**
   * Create a PerfDataBuffer instance for accessing the specified instrumentation buffer.
   *
   * @param vmid the <em>file:</em> URI to the instrumentation buffer file
   * @throws MonitorException
   */
  public PerfDataBuffer(VmIdentifier vmid) throws MonitorException {
    File f = new File(vmid.getURI());
    String mode = vmid.getMode();

    try {
      FileChannel fc = new RandomAccessFile(f, mode).getChannel();
      ByteBuffer bb = null;

      if (mode.compareTo("r") == 0) {
        bb = fc.map(FileChannel.MapMode.READ_ONLY, 0L, (int) fc.size());
      } else if (mode.compareTo("rw") == 0) {
        bb = fc.map(FileChannel.MapMode.READ_WRITE, 0L, (int) fc.size());
      } else {
        throw new IllegalArgumentException("Invalid mode: " + mode);
      }

      fc.close(); // doesn't need to remain open

      createPerfDataBuffer(bb, 0);
    } catch (FileNotFoundException e) {
      throw new MonitorException("Could not find " + vmid.toString());
    } catch (IOException e) {
      throw new MonitorException("Could not read " + vmid.toString());
    }
  }
Exemplo n.º 4
0
  public static BlockLink[] loadBlockMatches(String fileName) {
    File f = new File(fileName);
    if (!f.exists()) {
      return null;
    }
    try {
      FileChannel roChannel = new RandomAccessFile(f, "r").getChannel();

      int count = (int) ((roChannel.size() - 1) / 6);
      ByteBuffer buffer = roChannel.map(FileChannel.MapMode.READ_ONLY, 0, roChannel.size());
      roChannel.close();
      buffer.order(ByteOrder.LITTLE_ENDIAN);
      if (buffer.get() != version) {
        return null;
      }

      BlockLink[] links = new BlockLink[count];
      for (int i = 0; i < links.length; i++) {
        links[i] = new BlockLink(buffer.getShort(), buffer.get(), buffer.get(), buffer.getShort());
      }

      return links;

    } catch (Exception e) {
      e.printStackTrace();
      return null;
    }
  }
 public boolean storeFilesUpgradeable(File neoStoreFile) {
   File storeDirectory = neoStoreFile.getParentFile();
   for (String fileName : fileNamesToExpectedVersions.keySet()) {
     String expectedVersion = fileNamesToExpectedVersions.get(fileName);
     FileChannel fileChannel = null;
     byte[] expectedVersionBytes = UTF8.encode(expectedVersion);
     try {
       File storeFile = new File(storeDirectory, fileName);
       if (!fs.fileExists(storeFile)) {
         return false;
       }
       fileChannel = fs.open(storeFile, "r");
       if (fileChannel.size() < expectedVersionBytes.length) {
         return false;
       }
       fileChannel.position(fileChannel.size() - expectedVersionBytes.length);
       byte[] foundVersionBytes = new byte[expectedVersionBytes.length];
       fileChannel.read(ByteBuffer.wrap(foundVersionBytes));
       if (!expectedVersion.equals(UTF8.decode(foundVersionBytes))) {
         return false;
       }
     } catch (IOException e) {
       throw new RuntimeException(e);
     } finally {
       if (fileChannel != null) {
         try {
           fileChannel.close();
         } catch (IOException e) {
           // Ignore exception on close
         }
       }
     }
   }
   return true;
 }
Exemplo n.º 6
0
 public void put(String key, String value) throws IOException {
   int hash = hash(key);
   int i = indexFor(hash, capacity);
   int position = i * block_size;
   WordBlock b = readWordBlock(position);
   for (; b.nextPosition > 0; b = readWordBlock(b.nextPosition)) {
     Object k;
     if (hash(b.word) == hash && ((k = b.word) == key || key.equals(k))) {
       b.translate = value;
       writeWordBlock(b);
       return;
     }
   }
   if (b.nextPosition == 0) {
     b = new WordBlock(b.position);
   } else {
     int nextPosition = 0;
     if (fileChannel.size() > capacity * block_size) {
       nextPosition = (int) fileChannel.size();
     } else {
       nextPosition = capacity * block_size;
     }
     System.out.println(key + "  " + b.word);
     b.nextPosition = nextPosition;
     writeWordBlock(b);
     b = new WordBlock(nextPosition);
   }
   b.word = key;
   b.translate = value;
   b.nextPosition = -1;
   writeWordBlock(b);
 }
Exemplo n.º 7
0
    private boolean loadFromFile() {
      File GeoCrc = new File(fileName);
      if (!GeoCrc.exists()) {
        return false;
      }
      try {
        FileChannel roChannel = new RandomAccessFile(GeoCrc, "r").getChannel();
        if (roChannel.size() != GeoEngine.BLOCKS_IN_MAP * 4) {
          roChannel.close();
          return false;
        }

        ByteBuffer buffer = roChannel.map(FileChannel.MapMode.READ_ONLY, 0, roChannel.size());
        roChannel.close();
        buffer.order(ByteOrder.LITTLE_ENDIAN);
        int[] _checkSums = new int[GeoEngine.BLOCKS_IN_MAP];
        for (int i = 0; i < GeoEngine.BLOCKS_IN_MAP; i++) {
          _checkSums[i] = buffer.getInt();
        }
        checkSums[geoX][geoY] = _checkSums;
        return true;

      } catch (Exception e) {
        e.printStackTrace();
        return false;
      }
    }
Exemplo n.º 8
0
  /**
   * Mapped File way MappedByteBuffer 可以在处理大文件时,提升性能
   *
   * @param filename
   * @return
   * @throws IOException
   */
  public static byte[] toByteArray3(String filePath) throws IOException {

    FileChannel fc = null;
    RandomAccessFile rf = null;
    try {
      rf = new RandomAccessFile(filePath, "r");
      fc = rf.getChannel();
      MappedByteBuffer byteBuffer = fc.map(MapMode.READ_ONLY, 0, fc.size()).load();
      // System.out.println(byteBuffer.isLoaded());
      byte[] result = new byte[(int) fc.size()];
      if (byteBuffer.remaining() > 0) {
        // System.out.println("remain");
        byteBuffer.get(result, 0, byteBuffer.remaining());
      }
      return result;
    } catch (IOException e) {
      e.printStackTrace();
      throw e;
    } finally {
      try {
        rf.close();
        fc.close();
      } catch (IOException e) {
        e.printStackTrace();
      }
    }
  }
Exemplo n.º 9
0
  public void write(Tag tag, RandomAccessFile raf, RandomAccessFile tempRaf)
      throws CannotWriteException, IOException {
    FileChannel fc = raf.getChannel();

    int oldTagSize = 0;

    if (tagExists(fc)) {
      // read the length
      if (!canOverwrite(raf))
        throw new CannotWriteException("Overwritting of this kind of ID3v2 tag not supported yet");
      fc.position(6);

      ByteBuffer buf = ByteBuffer.allocate(4);
      fc.read(buf);
      oldTagSize = (buf.get(0) & 0xFF) << 21;
      oldTagSize += (buf.get(1) & 0xFF) << 14;
      oldTagSize += (buf.get(2) & 0xFF) << 7;
      oldTagSize += buf.get(3) & 0xFF;
      oldTagSize += 10;

      // System.err.println("Old tag size: "+oldTagSize);
      int newTagSize = tc.getTagLength(tag);

      if (oldTagSize >= newTagSize) {
        // replace
        // System.err.println("Old ID32v Tag found, replacing the old
        // tag");
        fc.position(0);

        fc.write(tc.convert(tag, oldTagSize - newTagSize));

        // ID3v2 Tag Written

        return;
      }
    }

    // create new tag with padding
    // System.err.println("Creating a new ID3v2 Tag");
    fc.position(oldTagSize);

    if (fc.size() > 15 * 1024 * 1024) {
      FileChannel tempFC = tempRaf.getChannel();

      tempFC.position(0);
      tempFC.write(tc.convert(tag, Id3v2TagCreator.DEFAULT_PADDING));
      tempFC.transferFrom(fc, tempFC.position(), fc.size() - oldTagSize);

      fc.close();
    } else {
      ByteBuffer[] content = new ByteBuffer[2];

      content[1] = ByteBuffer.allocate((int) fc.size());
      fc.read(content[1]);
      content[1].rewind();
      content[0] = tc.convert(tag, Id3v2TagCreator.DEFAULT_PADDING);
      fc.position(0);
      fc.write(content);
    }
  }
Exemplo n.º 10
0
  private static void testExceptions(FileChannel fc) throws IOException {
    checkException(fc, null, 0L, fc.size(), NullPointerException.class);

    checkException(fc, MapMode.READ_ONLY, -1L, fc.size(), IllegalArgumentException.class);

    checkException(
        fc, null, -1L, fc.size(), IllegalArgumentException.class, NullPointerException.class);

    checkException(fc, MapMode.READ_ONLY, 0L, -1L, IllegalArgumentException.class);

    checkException(fc, null, 0L, -1L, IllegalArgumentException.class, NullPointerException.class);

    checkException(
        fc, MapMode.READ_ONLY, 0L, Integer.MAX_VALUE + 1L, IllegalArgumentException.class);

    checkException(
        fc,
        null,
        0L,
        Integer.MAX_VALUE + 1L,
        IllegalArgumentException.class,
        NullPointerException.class);

    checkException(fc, MapMode.READ_ONLY, Long.MAX_VALUE, 1L, IllegalArgumentException.class);

    checkException(
        fc, null, Long.MAX_VALUE, 1L, IllegalArgumentException.class, NullPointerException.class);
  }
Exemplo n.º 11
0
 // from https://gist.github.com/889747
 // TODO use Jakarta Commons IO..! This implementation needs to be improved.
 private static void copyFile(File sourceFile, File destFile) throws IOException {
   if (!destFile.exists()) {
     destFile.createNewFile();
   }
   FileInputStream fIn = null;
   FileOutputStream fOut = null;
   FileChannel source = null;
   FileChannel destination = null;
   try {
     fIn = new FileInputStream(sourceFile);
     source = fIn.getChannel();
     fOut = new FileOutputStream(destFile);
     destination = fOut.getChannel();
     long transfered = 0;
     long bytes = source.size();
     while (transfered < bytes) {
       transfered += destination.transferFrom(source, 0, source.size());
       destination.position(transfered);
     }
   } finally {
     if (source != null) {
       source.close();
     } else if (fIn != null) {
       fIn.close();
     }
     if (destination != null) {
       destination.close();
     } else if (fOut != null) {
       fOut.close();
     }
   }
 }
Exemplo n.º 12
0
  @Test
  public void testSize() throws IOException {
    RegularFile file = regularFile(10);
    FileChannel channel = channel(file, READ);

    assertEquals(10, channel.size());

    file.write(10, new byte[90], 0, 90);
    assertEquals(100, channel.size());
  }
Exemplo n.º 13
0
  public void run() {
    FileChannel channel = null;
    ByteBuffer buffer = null;
    buffer = ByteBuffer.allocate(262144);
    if (this.logListener != null) this.logListener.inicioLog(null);
    try {
      while (isContinuar()) {
        channel = new FileInputStream(this.arquivo).getChannel();
        if (channel.size() > this.bytesLidos) {
          int lidos = 0;
          while ((lidos = channel.read(buffer, this.bytesLidos)) != -1) {
            buffer.flip();
            byte[] b = new byte[lidos];
            buffer.get(b);
            if (this.logListener != null) this.logListener.log(new String(b));
            buffer.clear();
            this.bytesLidos += lidos;
          }
        } else if (channel.size() < this.bytesLidos) {
          this.bytesLidos = (this.arquivo.length() - 16384L);
          if (this.bytesLidos < 0L) this.bytesLidos = 0L;
          if (this.logListener != null)
            this.logListener.log(
                System.getProperty("line.separator")
                    + "********Parte do arquivo foi apagada. Reinicializando leitura********"
                    + System.getProperty("line.separator"));
        }

        try {
          Thread.sleep(500L);
        } catch (InterruptedException e) {
          e.printStackTrace();
          setContinuar(false);
        }
        channel.close();
      }
    } catch (IOException e) {
      e.printStackTrace();
      ByteArrayOutputStream bos = new ByteArrayOutputStream();
      PrintStream s = new PrintStream(bos);
      e.printStackTrace(s);
      s.flush();
      JOptionPane.showMessageDialog(null, new ErroPainel(new String(bos.toByteArray())), "Erro", 0);
    } finally {
      if ((channel != null) && (!channel.isOpen()))
        try {
          channel.close();
        } catch (IOException localIOException1) {
        }
    }
  }
Exemplo n.º 14
0
 public static void copyFile(File srcFile, File dstFile) {
   if (!dstFile.exists()) {
     try {
       dstFile.createNewFile();
     } catch (IOException e) {
       e.printStackTrace();
     }
   }
   FileChannel source = null;
   FileChannel destination = null;
   try {
     source = new FileInputStream(srcFile).getChannel();
     destination = new FileOutputStream(dstFile).getChannel();
     destination.transferFrom(source, 0, source.size());
   } catch (IOException e) {
     e.printStackTrace();
   } finally {
     if (source != null) {
       try {
         source.close();
       } catch (IOException e) {
         e.printStackTrace();
       }
     }
     if (destination != null) {
       try {
         destination.close();
       } catch (IOException e) {
         e.printStackTrace();
       }
     }
   }
 }
 public long getContentLength() {
   try {
     return Math.min(mChunkSize, mChannel.size() - mChannel.position());
   } catch (IOException e) {
     return mChunkSize;
   }
 }
Exemplo n.º 16
0
  /** Reply a specific WAL. */
  private void replayLog(Path logPath) throws KevaDBException {
    // Now look at the disk.
    if (logPath != null) {
      // Get a list of the sstables already in place.
      Map<String, Integer> manifest =
          db.getDiskService().getDataManifests(db, 0, SSTableService.MAX_LEVELS);

      FileLock fileLock = null;
      try {
        // Must open in "rw" mode so that we can use filelock.
        FileChannel fc =
            FileChannel.open(logPath, StandardOpenOption.READ, StandardOpenOption.WRITE);
        MappedByteBuffer in = fc.map(FileChannel.MapMode.READ_ONLY, 0, (int) fc.size());

        fileLock = fc.tryLock();
        if (fileLock != null) {
          for (; ; ) {
            if (!unroll(in, manifest)) {
              break;
            }
          }
        }

        if (fileLock != null) {
          fileLock.release();
        }

        fc.close();
      } catch (IOException e) {
        e.printStackTrace();
      }
    }
  }
Exemplo n.º 17
0
  private ByteList bufferedRead(int number) throws IOException, BadDescriptorException {
    checkReadable();
    ensureRead();

    int resultSize = 0;

    // 128K seems to be the minimum at which the stat+seek is faster than reallocation
    final int BULK_THRESHOLD = 128 * 1024;
    if (number >= BULK_THRESHOLD
        && descriptor.isSeekable()
        && descriptor.getChannel() instanceof FileChannel) {
      //
      // If it is a file channel, then we can pre-allocate the output buffer
      // to the total size of buffered + remaining bytes in file
      //
      FileChannel fileChannel = (FileChannel) descriptor.getChannel();
      resultSize =
          (int)
              Math.min(
                  fileChannel.size() - fileChannel.position() + bufferedInputBytesRemaining(),
                  number);
    } else {
      //
      // Cannot discern the total read length - allocate at least enough for the buffered data
      //
      resultSize = Math.min(bufferedInputBytesRemaining(), number);
    }

    ByteList result = new ByteList(resultSize);
    bufferedRead(result, number);
    return result;
  }
Exemplo n.º 18
0
  public String getFileBinaryBase64(String fileName) throws APIException {
    if ((new File(fileName)).exists()) {
      FileInputStream stream = null;
      try {
        stream = new FileInputStream(new File(fileName));
        FileChannel fc = stream.getChannel();
        MappedByteBuffer bb = fc.map(FileChannel.MapMode.READ_ONLY, 0, fc.size());
        /* Instead of using default, pass in a decoder. */
        byte[] b = new byte[bb.remaining()];
        bb.get(b);

        return Base64.encodeBytes(b);
      } catch (Exception e) {
        throw new APIException(fileName + " could not have its files extracte!");
      } finally {
        try {
          stream.close();
        } catch (Exception e) {
          throw new APIException(fileName + " could not be closed!");
        }
      }
    } else {
      throw new APIException(fileName + " doesn't exist!");
    }
  }
Exemplo n.º 19
0
  /**
   * Parses the FileChannel, in the range [start, end) and prints the elements found
   *
   * <p>Elements are printed, indented by "level" number of spaces. If an element is a container,
   * then its contents will be, recursively, printed, with a greater indentation.
   *
   * @param fc
   * @param level
   * @param start
   * @param end
   * @throws IOException
   */
  private void print(FileChannel fc, int level, long start, long end) throws IOException {
    fc.position(start);
    if (end <= 0) {
      end = start + fc.size();
      System.out.println("Setting END to " + end);
    }
    while (end - fc.position() > 8) {
      long begin = fc.position();
      ByteBuffer bb = ByteBuffer.allocate(8);
      fc.read(bb);
      bb.rewind();
      long size = IsoTypeReader.readUInt32(bb);
      String type = IsoTypeReader.read4cc(bb);
      long fin = begin + size;
      // indent by the required number of spaces
      for (int i = 0; i < level; i++) {
        System.out.print(" ");
      }

      System.out.println(type + "@" + (begin) + " size: " + size);
      if (containers.contains(type)) {
        print(fc, level + 1, begin + 8, fin);
        if (fc.position() != fin) {
          System.out.println("End of container contents at " + fc.position());
          System.out.println("  FIN = " + fin);
        }
      } else {

      }

      fc.position(fin);
    }
  }
Exemplo n.º 20
0
 /**
  * Based on <a href="http://www.screaming-penguin.com/node/7749">Backing up your Android SQLite
  * database to the SD card</a>
  *
  * @param src
  * @param dst
  * @return true if success
  * @throws IOException
  */
 boolean copyFile(File src, File dst) throws IOException {
   long sizeIn = -1;
   long sizeCopied = 0;
   boolean ok = false;
   if (src != null && src.exists()) {
     sizeIn = src.length();
     if (!dst.createNewFile()) {
       MyLog.e(this, "New file was not created: '" + dst.getCanonicalPath() + "'");
     } else if (src.getCanonicalPath().compareTo(dst.getCanonicalPath()) == 0) {
       MyLog.d(this, "Cannot copy to itself: '" + src.getCanonicalPath() + "'");
     } else {
       FileInputStream fileInputStream = null;
       java.nio.channels.FileChannel inChannel = null;
       FileOutputStream fileOutputStream = null;
       java.nio.channels.FileChannel outChannel = null;
       try {
         fileInputStream = new FileInputStream(src);
         inChannel = fileInputStream.getChannel();
         fileOutputStream = new FileOutputStream(dst);
         outChannel = fileOutputStream.getChannel();
         sizeCopied = inChannel.transferTo(0, inChannel.size(), outChannel);
         ok = (sizeIn == sizeCopied);
       } finally {
         DbUtils.closeSilently(outChannel);
         DbUtils.closeSilently(fileOutputStream);
         DbUtils.closeSilently(inChannel);
         DbUtils.closeSilently(fileInputStream);
       }
     }
   }
   MyLog.d(this, "Copied " + sizeCopied + " bytes of " + sizeIn);
   return ok;
 }
Exemplo n.º 21
0
 public void run(String[] args) {
   String script = null;
   try {
     FileInputStream stream = new FileInputStream(new File(args[0]));
     try {
       FileChannel fc = stream.getChannel();
       MappedByteBuffer bb = fc.map(FileChannel.MapMode.READ_ONLY, 0, fc.size());
       script = Charset.availableCharsets().get("UTF-8").decode(bb).toString();
     } finally {
       stream.close();
     }
   } catch (Exception ex) {
     ex.printStackTrace();
     System.exit(1);
   }
   Context cx = Context.enter();
   try {
     ScriptableObject scope = cx.initStandardObjects();
     scope.putConst("language", scope, "java");
     scope.putConst("platform", scope, "android");
     scope.put("util", scope, new Util(cx, scope));
     cx.evaluateString(scope, script, args[0], 1, null);
   } catch (Error ex) {
     ex.printStackTrace();
     System.exit(1);
   } catch (Exception ex) {
     ex.printStackTrace();
     System.exit(1);
   } finally {
     Context.exit();
   }
   System.exit(0);
 }
Exemplo n.º 22
0
 private static long getRecord(String storeDir, long recordPosition) {
   RandomAccessFile file = null;
   try {
     file = new RandomAccessFile(new File(storeDir), "rw");
     FileChannel channel = file.getChannel();
     /*
      * We have to check size, because the store version
      * field was introduced with 1.5, so if there is a non-clean
      * shutdown we may have a buffer underflow.
      */
     if (recordPosition > 3 && channel.size() < RECORD_SIZE * 5) {
       return -1;
     }
     channel.position(RECORD_SIZE * recordPosition + 1 /*inUse*/);
     ByteBuffer buffer = ByteBuffer.allocate(8);
     channel.read(buffer);
     buffer.flip();
     long previous = buffer.getLong();
     return previous;
   } catch (IOException e) {
     throw new RuntimeException(e);
   } finally {
     try {
       if (file != null) file.close();
     } catch (IOException e) {
       throw new RuntimeException(e);
     }
   }
 }
  public void writeRequest(final OutputStream out) throws IOException {
    int readCount = 0;
    Iterator<OnDatatransferProgressListener> it = null;

    try {
      mChannel.position(mOffset);
      long size = mFile.length();
      if (size == 0) size = -1;
      long maxCount = Math.min(mOffset + mChunkSize, mChannel.size());
      while (mChannel.position() < maxCount) {
        readCount = mChannel.read(mBuffer);
        out.write(mBuffer.array(), 0, readCount);
        mBuffer.clear();
        if (mTransferred < maxCount) { // condition to avoid accumulate progress for repeated chunks
          mTransferred += readCount;
        }
        synchronized (mDataTransferListeners) {
          it = mDataTransferListeners.iterator();
          while (it.hasNext()) {
            it.next().onTransferProgress(readCount, mTransferred, size, mFile.getName());
          }
        }
      }

    } catch (IOException io) {
      Log.e(TAG, io.getMessage());
      throw new RuntimeException(
          "Ugly solution to workaround the default policy of retries when the server falls while uploading ; temporal fix; really",
          io);
    }
  }
Exemplo n.º 24
0
  /*Function to read file */
  public byte[] getFile(String fname) throws Exception {

    /*FileInputStream and FileChannel for performance. */
    FileInputStream in = new FileInputStream(fname);
    FileChannel ch = in.getChannel();
    MappedByteBuffer mb = ch.map(FileChannel.MapMode.READ_ONLY, 0L, ch.size());
    long l = (new File(fname)).length();

    /*Currently, supported max size is 20MB*/
    if (l > MAX_SIZE) {
      // errorMessage("File size too large. Max file size allowed
      // is"+(Integer.MAX_VALUE/1000)+"KB");
      return null;
    }

    byte[] barray = new byte[(int) l];
    int nGet;
    /*Read the file in to barray*/
    while (mb.hasRemaining()) {
      nGet = Math.min(mb.remaining(), Integer.MAX_VALUE);
      mb.get(barray, 0, nGet);
    }
    if (in != null) in.close();

    /*Return barray*/
    return barray;
  }
Exemplo n.º 25
0
 private void insertRecord(int recordPosition, long value) throws IOException {
   try {
     FileChannel channel = getFileChannel();
     long previousPosition = channel.position();
     channel.position(RECORD_SIZE * recordPosition);
     int trail = (int) (channel.size() - channel.position());
     ByteBuffer trailBuffer = null;
     if (trail > 0) {
       trailBuffer = ByteBuffer.allocate(trail);
       channel.read(trailBuffer);
       trailBuffer.flip();
     }
     ByteBuffer buffer = ByteBuffer.allocate(RECORD_SIZE);
     buffer.put(Record.IN_USE.byteValue());
     buffer.putLong(value);
     buffer.flip();
     channel.position(RECORD_SIZE * recordPosition);
     channel.write(buffer);
     if (trail > 0) {
       channel.write(trailBuffer);
     }
     channel.position(previousPosition);
   } catch (IOException e) {
     throw new RuntimeException(e);
   }
 }
Exemplo n.º 26
0
  public void copy() {
    try {
      File sd = AndroidSensors.DataPath;
      File data = Environment.getDataDirectory();

      if (sd.exists() == false) sd.mkdirs();

      String currentDBPath =
          "//data//" + "winlab.sensoradventure" + "//databases//" + "InstantReading.db";
      String backupDBPath = "InstantReading.db";
      File currentDB = new File(data, currentDBPath);

      File backupDB = new File(sd, backupDBPath);

      FileChannel src = new FileInputStream(currentDB).getChannel();
      FileChannel dst = new FileOutputStream(backupDB).getChannel();
      dst.transferFrom(src, 0, src.size());
      src.close();
      dst.close();
      Message msg = handler.obtainMessage();
      msg.arg1 = 1;
      handler.sendMessage(msg);

    } catch (Exception e) {

      Message msg = handler.obtainMessage();
      msg.arg1 = 2;
      handler.sendMessage(msg);
    }
  }
Exemplo n.º 27
0
  /**
   * Internal copy file method.
   *
   * @param srcFile the validated source file, must not be <code>null</code>
   * @param destFile the validated destination file, must not be <code>null</code>
   * @throws IOException if an error occurs
   */
  private static void doCopyFile(File srcFile, File destFile) throws IOException {
    if (destFile.exists() && destFile.isDirectory()) {
      throw new IOException("Destination '" + destFile + "' exists but is a directory");
    }

    FileInputStream fis = null;
    FileOutputStream fos = null;
    FileChannel input = null;
    FileChannel output = null;
    try {
      fis = new FileInputStream(srcFile);
      fos = new FileOutputStream(destFile);
      input = fis.getChannel();
      output = fos.getChannel();
      long size = input.size();
      long pos = 0;
      long count = 0;
      while (pos < size) {
        count = (size - pos) > FIFTY_MB ? FIFTY_MB : (size - pos);
        pos += output.transferFrom(input, pos, count);
      }
    } finally {
      Streams.closeQuietly(output);
      Streams.closeQuietly(fos);
      Streams.closeQuietly(input);
      Streams.closeQuietly(fis);
    }

    if (srcFile.length() != destFile.length()) {
      throw new IOException(
          "Failed to copy full contents from '" + srcFile + "' to '" + destFile + "'");
    }
  }
Exemplo n.º 28
0
  public static void copyFile(@NotNull File from, @NotNull File to, boolean append)
      throws IOException {
    FileInputStream in = null;
    FileOutputStream out = null;

    try {
      out = createOutputStream(to, append);

      in = new FileInputStream(from);

      FileChannel readChannel = in.getChannel();
      FileChannel writeChannel = out.getChannel();

      long size = readChannel.size();

      for (long position = 0; position < size; ) {
        position += readChannel.transferTo(position, MB, writeChannel);
      }

      if (from.length() != to.length()) {
        throw new IOException("Failed to copy full contents from " + from + " to " + to);
      }
    } finally {
      close(in);
      close(out);
    }
  }
  public String getJsonFile() {

    String jString = null;

    try {

      File dir = Environment.getExternalStorageDirectory();
      File yourFile = new File(dir, "form.json");
      FileInputStream stream = new FileInputStream(yourFile);

      try {
        FileChannel fc = stream.getChannel();
        MappedByteBuffer bb = fc.map(FileChannel.MapMode.READ_ONLY, 0, fc.size());
        /* Instead of using default, pass in a decoder. */
        jString = Charset.defaultCharset().decode(bb).toString();
      } finally {
        stream.close();
      }

      jObject = new JSONObject(jString);

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

    return jObject.toString();
  }
Exemplo n.º 30
0
  public boolean backupConfig(@NonNull String sourceString, @NonNull String destString) {
    try {
      File sourceFile = new File(sourceString);
      File destFile = new File(destString);
      if (!sourceFile.exists()) return false;

      if (!destFile.exists()) destFile.createNewFile();

      FileChannel source = null;
      FileChannel destination = null;

      try {
        source = new FileInputStream(sourceFile).getChannel();
        destination = new FileOutputStream(destFile).getChannel();
        destination.transferFrom(source, 0, source.size());
      } finally {
        if (source != null) source.close();
        if (destination != null) destination.close();
      }

      if (source != null) source.close();
      if (destination != null) destination.close();

    } catch (IOException ex) {
      Warning.load("Cannot backup config: " + sourceString, false);
      return false;
    }
    return true;
  }