Java 类org.apache.cordova.file.NoModificationAllowedException 实例源码

public static int writeToUri(Context context, Filesystem filesystem, LocalFilesystemURL inputURL, String data, int offset, boolean isBinary) throws NoModificationAllowedException {
    Uri uri = filesystem.toNativeUri(inputURL);
    OutputStream outputStream = null;

    try {
        outputStream = context.getContentResolver().openOutputStream(uri);

        byte[] rawData;
        if (isBinary) {
            rawData = Base64.decode(data, Base64.DEFAULT);
        } else {
            rawData = data.getBytes(Charset.defaultCharset());
        }

        outputStream.write(rawData);
        outputStream.flush();
        outputStream.close();

        Intent intent = new Intent(Intent.ACTION_MEDIA_SCANNER_SCAN_FILE, uri);
        context.sendBroadcast(intent);

        return rawData.length;

    } catch (Exception e) {
        NoModificationAllowedException exception = new NoModificationAllowedException("Couldn't write to file given its content URI");
        exception.initCause(e);
        throw exception;
    }
}

private JSONObject copyDirectory(File paramFile1, File paramFile2)
  throws JSONException, IOException, NoModificationAllowedException, InvalidModificationException
{
  if ((paramFile2.exists()) && (paramFile2.isFile()))
    throw new InvalidModificationException("Can't rename a file to a directory");
  if (isCopyOnItself(paramFile1.getAbsolutePath(), paramFile2.getAbsolutePath()))
    throw new InvalidModificationException("Can't copy itself into itself");
  if ((!paramFile2.exists()) && (!paramFile2.mkdir()))
    throw new NoModificationAllowedException("Couldn't create the destination directory");
  File[] arrayOfFile = paramFile1.listFiles();
  int i = arrayOfFile.length;
  int j = 0;
  if (j < i)
  {
    File localFile = arrayOfFile[j];
    if (localFile.isDirectory())
      copyDirectory(localFile, paramFile2);
    while (true)
    {
      j++;
      break;
      copyFile(localFile, new File(paramFile2.getAbsoluteFile() + File.separator + localFile.getName()));
    }
  }
  return getEntry(paramFile2);
}

private JSONObject moveDirectory(File paramFile1, File paramFile2)
  throws IOException, JSONException, InvalidModificationException, NoModificationAllowedException, FileExistsException
{
  if ((paramFile2.exists()) && (paramFile2.isFile()))
    throw new InvalidModificationException("Can't rename a file to a directory");
  if (isCopyOnItself(paramFile1.getAbsolutePath(), paramFile2.getAbsolutePath()))
    throw new InvalidModificationException("Can't move itself into itself");
  if ((paramFile2.exists()) && (paramFile2.list().length > 0))
    throw new InvalidModificationException("directory is not empty");
  if (!paramFile1.renameTo(paramFile2))
  {
    copyDirectory(paramFile1, paramFile2);
    if (paramFile2.exists())
      removeDirRecursively(paramFile1);
  }
  else
  {
    return getEntry(paramFile2);
  }
  throw new IOException("moved failed");
}

private long truncateFile(String paramString, long paramLong)
  throws FileNotFoundException, IOException, NoModificationAllowedException
{
  if (paramString.startsWith("content://"))
    throw new NoModificationAllowedException("Couldn't truncate file given its content URI");
  RandomAccessFile localRandomAccessFile = new RandomAccessFile(FileHelper.getRealPath(paramString, this.cordova), "rw");
  try
  {
    if (localRandomAccessFile.length() >= paramLong)
      localRandomAccessFile.getChannel().truncate(paramLong);
    while (true)
    {
      return paramLong;
      long l = localRandomAccessFile.length();
      paramLong = l;
    }
  }
  finally
  {
    localRandomAccessFile.close();
  }
  throw localObject;
}

public long write(String paramString1, String paramString2, int paramInt)
  throws FileNotFoundException, IOException, NoModificationAllowedException
{
  if (paramString1.startsWith("content://"))
    throw new NoModificationAllowedException("Couldn't write to file given its content URI");
  String str = FileHelper.getRealPath(paramString1, this.cordova);
  boolean bool = false;
  if (paramInt > 0)
  {
    truncateFile(str, paramInt);
    bool = true;
  }
  byte[] arrayOfByte1 = paramString2.getBytes();
  ByteArrayInputStream localByteArrayInputStream = new ByteArrayInputStream(arrayOfByte1);
  FileOutputStream localFileOutputStream = new FileOutputStream(str, bool);
  byte[] arrayOfByte2 = new byte[arrayOfByte1.length];
  localByteArrayInputStream.read(arrayOfByte2, 0, arrayOfByte2.length);
  localFileOutputStream.write(arrayOfByte2, 0, arrayOfByte1.length);
  localFileOutputStream.flush();
  localFileOutputStream.close();
  return arrayOfByte1.length;
}

/**
 * Deletes a file or directory. It is an error to attempt to delete a directory that is not empty.
 * It is an error to attempt to delete the root directory of a filesystem.
 *
 * @param filePath file or directory to be removed
 * @return a boolean representing success of failure
 * @throws NoModificationAllowedException
 * @throws InvalidModificationException
 */
private boolean remove(String filePath) throws NoModificationAllowedException, InvalidModificationException {
    File fp = createFileObject(filePath);

    // You can't delete the root directory.
    if (atRootDirectory(filePath)) {
        throw new NoModificationAllowedException("You can't delete the root directory");
    }

    // You can't delete a directory that is not empty
    if (fp.isDirectory() && fp.list().length > 0) {
        throw new InvalidModificationException("You can't delete a directory that is not empty.");
    }

    return fp.delete();
}

/**
 * Truncate the file to size
 *
 * @param filename
 * @param size
 * @throws FileNotFoundException, IOException
 * @throws NoModificationAllowedException
 */
private long truncateFile(String filename, long size) throws FileNotFoundException, IOException, NoModificationAllowedException {
    if (filename.startsWith("content://")) {
        throw new NoModificationAllowedException("Couldn't truncate file given its content URI");
    }

    filename = FileHelper.getRealPath(filename, cordova);

    RandomAccessFile raf = new RandomAccessFile(filename, "rw");
    try {
        if (raf.length() >= size) {
            FileChannel channel = raf.getChannel();
            channel.truncate(size);
            return size;
        }

        return raf.length();
    } finally {
        raf.close();
    }
}

private JSONObject copyDirectory(File paramFile1, File paramFile2)
  throws JSONException, IOException, NoModificationAllowedException, InvalidModificationException
{
  if ((paramFile2.exists()) && (paramFile2.isFile()))
    throw new InvalidModificationException("Can't rename a file to a directory");
  if (isCopyOnItself(paramFile1.getAbsolutePath(), paramFile2.getAbsolutePath()))
    throw new InvalidModificationException("Can't copy itself into itself");
  if ((!paramFile2.exists()) && (!paramFile2.mkdir()))
    throw new NoModificationAllowedException("Couldn't create the destination directory");
  File[] arrayOfFile = paramFile1.listFiles();
  int i = arrayOfFile.length;
  int j = 0;
  if (j < i)
  {
    File localFile = arrayOfFile[j];
    if (localFile.isDirectory())
      copyDirectory(localFile, paramFile2);
    while (true)
    {
      j++;
      break;
      copyFile(localFile, new File(paramFile2.getAbsoluteFile() + File.separator + localFile.getName()));
    }
  }
  return getEntry(paramFile2);
}

private JSONObject moveDirectory(File paramFile1, File paramFile2)
  throws IOException, JSONException, InvalidModificationException, NoModificationAllowedException, FileExistsException
{
  if ((paramFile2.exists()) && (paramFile2.isFile()))
    throw new InvalidModificationException("Can't rename a file to a directory");
  if (isCopyOnItself(paramFile1.getAbsolutePath(), paramFile2.getAbsolutePath()))
    throw new InvalidModificationException("Can't move itself into itself");
  if ((paramFile2.exists()) && (paramFile2.list().length > 0))
    throw new InvalidModificationException("directory is not empty");
  if (!paramFile1.renameTo(paramFile2))
  {
    copyDirectory(paramFile1, paramFile2);
    if (paramFile2.exists())
      removeDirRecursively(paramFile1);
  }
  else
  {
    return getEntry(paramFile2);
  }
  throw new IOException("moved failed");
}

private long truncateFile(String paramString, long paramLong)
  throws FileNotFoundException, IOException, NoModificationAllowedException
{
  if (paramString.startsWith("content://"))
    throw new NoModificationAllowedException("Couldn't truncate file given its content URI");
  RandomAccessFile localRandomAccessFile = new RandomAccessFile(FileHelper.getRealPath(paramString, this.cordova), "rw");
  try
  {
    if (localRandomAccessFile.length() >= paramLong)
      localRandomAccessFile.getChannel().truncate(paramLong);
    while (true)
    {
      return paramLong;
      long l = localRandomAccessFile.length();
      paramLong = l;
    }
  }
  finally
  {
    localRandomAccessFile.close();
  }
  throw localObject;
}

public long write(String paramString1, String paramString2, int paramInt)
  throws FileNotFoundException, IOException, NoModificationAllowedException
{
  if (paramString1.startsWith("content://"))
    throw new NoModificationAllowedException("Couldn't write to file given its content URI");
  String str = FileHelper.getRealPath(paramString1, this.cordova);
  boolean bool = false;
  if (paramInt > 0)
  {
    truncateFile(str, paramInt);
    bool = true;
  }
  byte[] arrayOfByte1 = paramString2.getBytes();
  ByteArrayInputStream localByteArrayInputStream = new ByteArrayInputStream(arrayOfByte1);
  FileOutputStream localFileOutputStream = new FileOutputStream(str, bool);
  byte[] arrayOfByte2 = new byte[arrayOfByte1.length];
  localByteArrayInputStream.read(arrayOfByte2, 0, arrayOfByte2.length);
  localFileOutputStream.write(arrayOfByte2, 0, arrayOfByte1.length);
  localFileOutputStream.flush();
  localFileOutputStream.close();
  return arrayOfByte1.length;
}

/**
 * Deletes a file or directory. It is an error to attempt to delete a directory that is not empty.
 * It is an error to attempt to delete the root directory of a filesystem.
 *
 * @param filePath file or directory to be removed
 * @return a boolean representing success of failure
 * @throws NoModificationAllowedException
 * @throws InvalidModificationException
 */
private boolean remove(String filePath) throws NoModificationAllowedException, InvalidModificationException {
    File fp = createFileObject(filePath);

    // You can't delete the root directory.
    if (atRootDirectory(filePath)) {
        throw new NoModificationAllowedException("You can't delete the root directory");
    }

    // You can't delete a directory that is not empty
    if (fp.isDirectory() && fp.list().length > 0) {
        throw new InvalidModificationException("You can't delete a directory that is not empty.");
    }

    return fp.delete();
}

/**
 * Truncate the file to size
 *
 * @param filename
 * @param size
 * @throws FileNotFoundException, IOException
 * @throws NoModificationAllowedException
 */
private long truncateFile(String filename, long size) throws FileNotFoundException, IOException, NoModificationAllowedException {
    if (filename.startsWith("content://")) {
        throw new NoModificationAllowedException("Couldn't truncate file given its content URI");
    }

    filename = FileHelper.getRealPath(filename, cordova);

    RandomAccessFile raf = new RandomAccessFile(filename, "rw");
    try {
        if (raf.length() >= size) {
            FileChannel channel = raf.getChannel();
            channel.truncate(size);
            return size;
        }

        return raf.length();
    } finally {
        raf.close();
    }
}

private boolean remove(String paramString)
  throws NoModificationAllowedException, InvalidModificationException
{
  File localFile = createFileObject(paramString);
  if (atRootDirectory(paramString))
    throw new NoModificationAllowedException("You can't delete the root directory");
  if ((localFile.isDirectory()) && (localFile.list().length > 0))
    throw new InvalidModificationException("You can't delete a directory that is not empty.");
  return localFile.delete();
}

private JSONObject transferTo(String paramString1, String paramString2, String paramString3, boolean paramBoolean)
  throws JSONException, NoModificationAllowedException, IOException, InvalidModificationException, EncodingException, FileExistsException
{
  String str1 = FileHelper.getRealPath(paramString1, this.cordova);
  String str2 = FileHelper.getRealPath(paramString2, this.cordova);
  if ((paramString3 != null) && (paramString3.contains(":")))
    throw new EncodingException("Bad file name");
  File localFile1 = new File(str1);
  if (!localFile1.exists())
    throw new FileNotFoundException("The source does not exist");
  File localFile2 = new File(str2);
  if (!localFile2.exists())
    throw new FileNotFoundException("The source does not exist");
  File localFile3 = createDestination(paramString3, localFile1, localFile2);
  if (localFile1.getAbsolutePath().equals(localFile3.getAbsolutePath()))
    throw new InvalidModificationException("Can't copy a file onto itself");
  JSONObject localJSONObject;
  if (localFile1.isDirectory())
    if (paramBoolean)
      localJSONObject = moveDirectory(localFile1, localFile3);
  while (true)
  {
    return localJSONObject;
    return copyDirectory(localFile1, localFile3);
    if (!paramBoolean)
      break;
    localJSONObject = moveFile(localFile1, localFile3);
    if (!paramString1.startsWith("content://"))
      continue;
    notifyDelete(paramString1);
    return localJSONObject;
  }
  return copyFile(localFile1, localFile3);
}

/**
 * Copy a directory
 *
 * @param srcDir directory to be copied
 * @param destinationDir destination to be copied to
 * @return a DirectoryEntry object
 * @throws JSONException
 * @throws IOException
 * @throws NoModificationAllowedException
 * @throws InvalidModificationException
 */
private JSONObject copyDirectory(File srcDir, File destinationDir) throws JSONException, IOException, NoModificationAllowedException, InvalidModificationException {
    // Renaming a file to an existing directory should fail
    if (destinationDir.exists() && destinationDir.isFile()) {
        throw new InvalidModificationException("Can't rename a file to a directory");
    }

    // Check to make sure we are not copying the directory into itself
    if (isCopyOnItself(srcDir.getAbsolutePath(), destinationDir.getAbsolutePath())) {
        throw new InvalidModificationException("Can't copy itself into itself");
    }

    // See if the destination directory exists. If not create it.
    if (!destinationDir.exists()) {
        if (!destinationDir.mkdir()) {
            // If we can't create the directory then fail
            throw new NoModificationAllowedException("Couldn't create the destination directory");
        }
    }

    for (File file : srcDir.listFiles()) {
        if (file.isDirectory()) {
            copyDirectory(file, destinationDir);
        } else {
            File destination = new File(destinationDir.getAbsoluteFile() + File.separator + file.getName());
            copyFile(file, destination);
        }
    }

    return getEntry(destinationDir);
}

/**
 * Move a directory
 *
 * @param srcDir directory to be copied
 * @param destinationDir destination to be copied to
 * @return a DirectoryEntry object
 * @throws JSONException
 * @throws IOException
 * @throws InvalidModificationException
 * @throws NoModificationAllowedException
 * @throws FileExistsException
 */
private JSONObject moveDirectory(File srcDir, File destinationDir) throws IOException, JSONException, InvalidModificationException, NoModificationAllowedException, FileExistsException {
    // Renaming a file to an existing directory should fail
    if (destinationDir.exists() && destinationDir.isFile()) {
        throw new InvalidModificationException("Can't rename a file to a directory");
    }

    // Check to make sure we are not copying the directory into itself
    if (isCopyOnItself(srcDir.getAbsolutePath(), destinationDir.getAbsolutePath())) {
        throw new InvalidModificationException("Can't move itself into itself");
    }

    // If the destination directory already exists and is empty then delete it.  This is according to spec.
    if (destinationDir.exists()) {
        if (destinationDir.list().length > 0) {
            throw new InvalidModificationException("directory is not empty");
        }
    }

    // Try to rename the directory
    if (!srcDir.renameTo(destinationDir)) {
        // Trying to rename the directory failed.  Possibly because we moved across file system on the device.
        // Now we have to do things the hard way
        // 1) Copy all the old files
        // 2) delete the src directory
        copyDirectory(srcDir, destinationDir);
        if (destinationDir.exists()) {
            removeDirRecursively(srcDir);
        } else {
            throw new IOException("moved failed");
        }
    }

    return getEntry(destinationDir);
}

/**
 * Write contents of file.
 *
 * @param filename          The name of the file.
 * @param data              The contents of the file.
 * @param offset            The position to begin writing the file.
 * @param isBinary          True if the file contents are base64-encoded binary data
 * @throws FileNotFoundException, IOException
 * @throws NoModificationAllowedException
 */
/**/
public long write(String filename, String data, int offset, boolean isBinary) throws FileNotFoundException, IOException, NoModificationAllowedException {
    if (filename.startsWith("content://")) {
        throw new NoModificationAllowedException("Couldn't write to file given its content URI");
    }

    filename = FileHelper.getRealPath(filename, cordova);

    boolean append = false;
    if (offset > 0) {
        this.truncateFile(filename, offset);
        append = true;
    }

    byte[] rawData;
    if (isBinary) {
        rawData = Base64.decode(data, Base64.DEFAULT);
    } else {
        rawData = data.getBytes();
    }
    ByteArrayInputStream in = new ByteArrayInputStream(rawData);
    FileOutputStream out = new FileOutputStream(filename, append);
    byte buff[] = new byte[rawData.length];
    in.read(buff, 0, buff.length);
    out.write(buff, 0, rawData.length);
    out.flush();
    out.close();

    return rawData.length;
}

private boolean remove(String paramString)
  throws NoModificationAllowedException, InvalidModificationException
{
  File localFile = createFileObject(paramString);
  if (atRootDirectory(paramString))
    throw new NoModificationAllowedException("You can't delete the root directory");
  if ((localFile.isDirectory()) && (localFile.list().length > 0))
    throw new InvalidModificationException("You can't delete a directory that is not empty.");
  return localFile.delete();
}

private JSONObject transferTo(String paramString1, String paramString2, String paramString3, boolean paramBoolean)
  throws JSONException, NoModificationAllowedException, IOException, InvalidModificationException, EncodingException, FileExistsException
{
  String str1 = FileHelper.getRealPath(paramString1, this.cordova);
  String str2 = FileHelper.getRealPath(paramString2, this.cordova);
  if ((paramString3 != null) && (paramString3.contains(":")))
    throw new EncodingException("Bad file name");
  File localFile1 = new File(str1);
  if (!localFile1.exists())
    throw new FileNotFoundException("The source does not exist");
  File localFile2 = new File(str2);
  if (!localFile2.exists())
    throw new FileNotFoundException("The source does not exist");
  File localFile3 = createDestination(paramString3, localFile1, localFile2);
  if (localFile1.getAbsolutePath().equals(localFile3.getAbsolutePath()))
    throw new InvalidModificationException("Can't copy a file onto itself");
  JSONObject localJSONObject;
  if (localFile1.isDirectory())
    if (paramBoolean)
      localJSONObject = moveDirectory(localFile1, localFile3);
  while (true)
  {
    return localJSONObject;
    return copyDirectory(localFile1, localFile3);
    if (!paramBoolean)
      break;
    localJSONObject = moveFile(localFile1, localFile3);
    if (!paramString1.startsWith("content://"))
      continue;
    notifyDelete(paramString1);
    return localJSONObject;
  }
  return copyFile(localFile1, localFile3);
}

/**
 * Copy a directory
 *
 * @param srcDir directory to be copied
 * @param destinationDir destination to be copied to
 * @return a DirectoryEntry object
 * @throws JSONException
 * @throws IOException
 * @throws NoModificationAllowedException
 * @throws InvalidModificationException
 */
private JSONObject copyDirectory(File srcDir, File destinationDir) throws JSONException, IOException, NoModificationAllowedException, InvalidModificationException {
    // Renaming a file to an existing directory should fail
    if (destinationDir.exists() && destinationDir.isFile()) {
        throw new InvalidModificationException("Can't rename a file to a directory");
    }

    // Check to make sure we are not copying the directory into itself
    if (isCopyOnItself(srcDir.getAbsolutePath(), destinationDir.getAbsolutePath())) {
        throw new InvalidModificationException("Can't copy itself into itself");
    }

    // See if the destination directory exists. If not create it.
    if (!destinationDir.exists()) {
        if (!destinationDir.mkdir()) {
            // If we can't create the directory then fail
            throw new NoModificationAllowedException("Couldn't create the destination directory");
        }
    }

    for (File file : srcDir.listFiles()) {
        if (file.isDirectory()) {
            copyDirectory(file, destinationDir);
        } else {
            File destination = new File(destinationDir.getAbsoluteFile() + File.separator + file.getName());
            copyFile(file, destination);
        }
    }

    return getEntry(destinationDir);
}

/**
 * Move a directory
 *
 * @param srcDir directory to be copied
 * @param destinationDir destination to be copied to
 * @return a DirectoryEntry object
 * @throws JSONException
 * @throws IOException
 * @throws InvalidModificationException
 * @throws NoModificationAllowedException
 * @throws FileExistsException
 */
private JSONObject moveDirectory(File srcDir, File destinationDir) throws IOException, JSONException, InvalidModificationException, NoModificationAllowedException, FileExistsException {
    // Renaming a file to an existing directory should fail
    if (destinationDir.exists() && destinationDir.isFile()) {
        throw new InvalidModificationException("Can't rename a file to a directory");
    }

    // Check to make sure we are not copying the directory into itself
    if (isCopyOnItself(srcDir.getAbsolutePath(), destinationDir.getAbsolutePath())) {
        throw new InvalidModificationException("Can't move itself into itself");
    }

    // If the destination directory already exists and is empty then delete it.  This is according to spec.
    if (destinationDir.exists()) {
        if (destinationDir.list().length > 0) {
            throw new InvalidModificationException("directory is not empty");
        }
    }

    // Try to rename the directory
    if (!srcDir.renameTo(destinationDir)) {
        // Trying to rename the directory failed.  Possibly because we moved across file system on the device.
        // Now we have to do things the hard way
        // 1) Copy all the old files
        // 2) delete the src directory
        copyDirectory(srcDir, destinationDir);
        if (destinationDir.exists()) {
            removeDirRecursively(srcDir);
        } else {
            throw new IOException("moved failed");
        }
    }

    return getEntry(destinationDir);
}

/**
 * Write contents of file.
 *
 * @param filename          The name of the file.
 * @param data              The contents of the file.
 * @param offset            The position to begin writing the file.
 * @param isBinary          True if the file contents are base64-encoded binary data
 * @throws FileNotFoundException, IOException
 * @throws NoModificationAllowedException
 */
/**/
public long write(String filename, String data, int offset, boolean isBinary) throws FileNotFoundException, IOException, NoModificationAllowedException {
    if (filename.startsWith("content://")) {
        throw new NoModificationAllowedException("Couldn't write to file given its content URI");
    }

    filename = FileHelper.getRealPath(filename, cordova);

    boolean append = false;
    if (offset > 0) {
        this.truncateFile(filename, offset);
        append = true;
    }

    byte[] rawData;
    if (isBinary) {
        rawData = Base64.decode(data, Base64.DEFAULT);
    } else {
        rawData = data.getBytes();
    }
    ByteArrayInputStream in = new ByteArrayInputStream(rawData);
    FileOutputStream out = new FileOutputStream(filename, append);
    byte buff[] = new byte[rawData.length];
    in.read(buff, 0, buff.length);
    out.write(buff, 0, rawData.length);
    out.flush();
    out.close();

    return rawData.length;
}

/**
 * A setup method that handles the move/copy of files/directories
 *
 * @param fileName to be copied/moved
 * @param newParent is the location where the file will be copied/moved to
 * @param newName for the file directory to be called, if null use existing file name
 * @param move if false do a copy, if true do a move
 * @return a Entry object
 * @throws NoModificationAllowedException
 * @throws IOException
 * @throws InvalidModificationException
 * @throws EncodingException
 * @throws JSONException
 * @throws FileExistsException
 */
private JSONObject transferTo(String fileName, String newParent, String newName, boolean move) throws JSONException, NoModificationAllowedException, IOException, InvalidModificationException, EncodingException, FileExistsException {
    String newFileName = FileHelper.getRealPath(fileName, cordova);
    newParent = FileHelper.getRealPath(newParent, cordova);

    // Check for invalid file name
    if (newName != null && newName.contains(":")) {
        throw new EncodingException("Bad file name");
    }

    File source = new File(newFileName);

    if (!source.exists()) {
        // The file/directory we are copying doesn't exist so we should fail.
        throw new FileNotFoundException("The source does not exist");
    }

    File destinationDir = new File(newParent);
    if (!destinationDir.exists()) {
        // The destination does not exist so we should fail.
        throw new FileNotFoundException("The source does not exist");
    }

    // Figure out where we should be copying to
    File destination = createDestination(newName, source, destinationDir);

    //Log.d(LOG_TAG, "Source: " + source.getAbsolutePath());
    //Log.d(LOG_TAG, "Destin: " + destination.getAbsolutePath());

    // Check to see if source and destination are the same file
    if (source.getAbsolutePath().equals(destination.getAbsolutePath())) {
        throw new InvalidModificationException("Can't copy a file onto itself");
    }

    if (source.isDirectory()) {
        if (move) {
            return moveDirectory(source, destination);
        } else {
            return copyDirectory(source, destination);
        }
    } else {
        if (move) {
            JSONObject newFileEntry = moveFile(source, destination);

            // If we've moved a file given its content URI, we need to clean up.
            if (fileName.startsWith("content://")) {
                notifyDelete(fileName);
            }

            return newFileEntry;
        } else {
            return copyFile(source, destination);
        }
    }
}

/**
 * A setup method that handles the move/copy of files/directories
 *
 * @param fileName to be copied/moved
 * @param newParent is the location where the file will be copied/moved to
 * @param newName for the file directory to be called, if null use existing file name
 * @param move if false do a copy, if true do a move
 * @return a Entry object
 * @throws NoModificationAllowedException
 * @throws IOException
 * @throws InvalidModificationException
 * @throws EncodingException
 * @throws JSONException
 * @throws FileExistsException
 */
private JSONObject transferTo(String fileName, String newParent, String newName, boolean move) throws JSONException, NoModificationAllowedException, IOException, InvalidModificationException, EncodingException, FileExistsException {
    String newFileName = FileHelper.getRealPath(fileName, cordova);
    newParent = FileHelper.getRealPath(newParent, cordova);

    // Check for invalid file name
    if (newName != null && newName.contains(":")) {
        throw new EncodingException("Bad file name");
    }

    File source = new File(newFileName);

    if (!source.exists()) {
        // The file/directory we are copying doesn't exist so we should fail.
        throw new FileNotFoundException("The source does not exist");
    }

    File destinationDir = new File(newParent);
    if (!destinationDir.exists()) {
        // The destination does not exist so we should fail.
        throw new FileNotFoundException("The source does not exist");
    }

    // Figure out where we should be copying to
    File destination = createDestination(newName, source, destinationDir);

    //Log.d(LOG_TAG, "Source: " + source.getAbsolutePath());
    //Log.d(LOG_TAG, "Destin: " + destination.getAbsolutePath());

    // Check to see if source and destination are the same file
    if (source.getAbsolutePath().equals(destination.getAbsolutePath())) {
        throw new InvalidModificationException("Can't copy a file onto itself");
    }

    if (source.isDirectory()) {
        if (move) {
            return moveDirectory(source, destination);
        } else {
            return copyDirectory(source, destination);
        }
    } else {
        if (move) {
            JSONObject newFileEntry = moveFile(source, destination);

            // If we've moved a file given its content URI, we need to clean up.
            if (fileName.startsWith("content://")) {
                notifyDelete(fileName);
            }

            return newFileEntry;
        } else {
            return copyFile(source, destination);
        }
    }
}