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 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); } } }
