Github user jasongin commented on a diff in the pull request:
https://github.com/apache/cordova-plugin-file/pull/176#discussion_r58929077
--- Diff: README.md ---
@@ -538,3 +540,298 @@ Android also supports a special filesystem named
"documents", which represents a
* `root`: The entire device filesystem
By default, the library and documents directories can be synced to iCloud.
You can also request two additional filesystems, `library-nosync` and
`documents-nosync`, which represent a special non-synced directory within the
`/Library` or `/Documents` filesystem.
+
+## Sample: Create Files and Directories, Write, Read, and Append files <a
name="sample"></a>
+
+The File plugin allows you to do things like store files in a temporary or
persistent storage location for your app (sandboxed storage) and to store files
in other platform-dependent locations. The code snippets in this section
demonstrate different tasks including:
+* Accessing the file system
+* Using cross-platform Cordova file URLs to store your files (see _Where
to Store Files_ for more info)
+* Creating files and directories
+* Writing to files
+* Reading files
+* Appending files
+
+## Create a persistent file
+
+Before you use the File plugin APIs, you can get access to the file system
using `requestFileSystem`. When you do this, you can request either persistent
or temporary storage. Persistent storage will not be removed unless permission
is granted by the user.
+
+When you get file system access using `requestFileSystem`, access is
granted for the sandboxed file system only (the sandbox limits access to the
app itself), not for general access to any file system location on the device.
(To access file system locations outside the sandboxed storage, use other
methods such as window.requestLocalFileSystemURL, which support
platform-specific locations. For one example of this, see _Append a File_.)
+
+Here is a request for persistent storage.
+
+>*Note* When targeting WebView clients (instead of a browser) or native
apps (Windows), you dont need to use `requestQuota` before using persistent
storage.
+
+```js
+window.requestFileSystem(LocalFileSystem.PERSISTENT, 0, function (fs) {
+
+ console.log('file system open: ' + fs.name);
+ fs.root.getFile("newPersistentFile.txt", { create: true, exclusive:
false }, function (fileEntry) {
+
+ console.log("fileEntry is file?" + fileEntry.isFile.toString());
+ // fileEntry.name == 'someFile.txt'
+ // fileEntry.fullPath == '/someFile.txt'
+ writeFile(fileEntry, null);
+
+ }, onErrorCreateFile);
+
+}, onErrorLoadFs);
+```
+
+The success callback receives FileSystem object (fs). Use `fs.root` to
return a DirectoryEntry object, which you can use to create or get a file (by
calling `getFile`). In this example, `fs.root` is a DirectoryEntry object that
represents the persistent storage in the sandboxed file system.
+
+The success callback for `getFile` receives a FileEntry object. You can
use this to perform file write and file read operations.
+
+## Create a temporary file
+
+Here is an example of a request for temporary storage. Temporary storage
may be deleted by the operating system if the device runs low on memory.
+
+```js
+window.requestFileSystem(window.TEMPORARY, 5 * 1024 * 1024, function (fs) {
+
+ console.log('file system open: ' + fs.name);
+ createFile(fs.root, "newTempFile.txt", false);
+
+}, onErrorLoadFs);
+```
+When you are using temporary storage, you can create or get the file by
calling `getFile`. As in the persistent storage example, this will give you a
FileEntry object that you can use for read or write operations.
+
+```js
+function createFile(dirEntry, fileName, isAppend) {
+ // Creates a new file or returns the file if it already exists.
+ dirEntry.getFile(fileName, {create: true, exclusive: false},
function(fileEntry) {
+
+ writeFile(fileEntry, null, isAppend);
+
+ }, onErrorCreateFile);
+
+}
+```
+
+## Write to a file
+
+Once you have a FileEntry object, you can write to the file by calling
`createWriter`, which returns a FileWriter object in the success callback. Call
the `write` method of FileWriter to write to the file.
+
+```js
+function writeFile(fileEntry, dataObj) {
+ // Create a FileWriter object for our FileEntry (log.txt).
+ fileEntry.createWriter(function (fileWriter) {
+
+ fileWriter.onwriteend = function (e) {
+ console.log("Successful file read...");
+ readFile(fileEntry);
+ };
+
+ fileWriter.onerror = function (e) {
+ console.log("Failed file read: " + e.toString());
+ };
+
+ // If data object is not passed in,
+ // create a new Blob instead.
+ if (!dataObj) {
+ dataObj = new Blob(['some file data'], { type: 'text/plain' });
+ }
+
+ fileWriter.write(dataObj);
+ });
+}
+```
+
+## Read a file
+
+You also need a FileEntry object to read an existing file. Use the file
property of FileEntry to get the file reference, and then create a new
FileReader object. You can use methods like `readAsText` to start the read
operation. When the read operation is complete, `this.result` stores the result
of the read operation.
+
+```js
+function readFile(fileEntry) {
+
+ fileEntry.file(function (file) {
+ var reader = new FileReader();
+
+ reader.onloadend = function() {
+ console.log("Successful file read: " + this.result);
+ displayFileData(fileEntry.fullPath + ": " + this.result);
+ };
+
+ reader.readAsText(file);
+
+ }, onErrorReadFile);
+}
+```
+
+## Append a file using alternative methods
+
+Of course, you will often want to append existing files instead of
creating new ones. Here is an example of that. This example shows another way
that you can access the file system using window.resolveLocalFileSystemURL. In
this example, pass the cross-platform Cordova file URL,
cordova.file.dataDirectory, to the function. The success callback receives a
DirectoryEntry object, which you can use to do things like create a file.
+
+```js
+window.resolveLocalFileSystemURL(cordova.file.dataDirectory, function
(dirEntry) {
+ console.log('file system open: ' + dirEntry.name);
+ var isAppend = true;
+ createFile(dirEntry, "fileToAppend.txt", isAppend);
+}, onErrorLoadFs);
+```
+
+In addition to this usage, you can use `resolveLocalFileSystemURL` to get
access to some file system locations that are not part of the sandboxed storage
system. See _Where to store Files_ for more information; many of these storage
locations are platform-specific. You can also pass cross-platform file system
locations to `resolveLocalFileSystemURL` using the _cdvfile protocol_.
+
+For the append operation, there is nothing new in the `createFile`
function that is called in the preceding code (see the preceding examples for
the actual code). `createFile` calls `writeFile`. In `writeFile`, you check
whether an append operation is requested.
+
+Once you have a FileWriter object, call the `seek` method, and pass in the
index value for the position where you want to write. In this example, you also
test whether the file exists. After calling seek, then call the write method of
FileWriter.
+
+```js
+function writeFile(fileEntry, dataObj, isAppend) {
+ // Create a FileWriter object for our FileEntry (log.txt).
+ fileEntry.createWriter(function (fileWriter) {
+
+ fileWriter.onwriteend = function (e) {
+ console.log("Successful file read...");
+ readFile(fileEntry);
+ };
+
+ fileWriter.onerror = function (e) {
+ console.log("Failed file read: " + e.toString());
+ };
+
+ // If we are appending data to file, go to the end of the file.
+ if (isAppend) {
+ try {
+ fileWriter.seek(fileWriter.length);
+ }
+ catch (e) {
+ console.log("file doesn't exist!");
+ }
+ }
+ fileWriter.write(dataObj);
+ });
+}
+```
+
+## Store an existing binary file
+
+We already showed how to write to a file that you just created in the
sandboxed file system. What if you need to get access to an existing file and
convert that to something you can store on your device? In this example, you
obtain a file using an xhr request, and then save it to the cache in the
sandboxed file system.
+
+Before you get the file, get a FileSystem reference using
`requestFileSystem`. By passing window.TEMPORARY in the method call (same as
before), the returned FileSystem object (fs) represents the cache in the
sandboxed file system. Use `fs.root` to get the DirectoryEntry object that you
need.
+
+```js
+window.requestFileSystem(window.TEMPORARY, 5 * 1024 * 1024, function (fs) {
+
+ console.log('file system open: ' + fs.name);
+ getSampleFile(fs.root);
+
+}, onErrorLoadFs);
+```
+
+For completeness, here is the xhr request to get a Blob image. There is
nothing Cordova-specific in this code, except that you forward the
DirectoryEntry reference that you already obtained as an argument to the
saveFile function. You will save the blob image and display it later after
reading the file (to validate the operation).
+
+```js
+function getSampleFile(dirEntry) {
+
+ var xhr = new XMLHttpRequest();
+ xhr.open('GET',
'http://cordova.apache.org/static/img/cordova_bot.png', true);
+ xhr.responseType = 'blob';
+
+ xhr.onload = function() {
+ if (this.status == 200) {
+
+ var blob = new Blob([this.response], { type: 'image/png' });
+ saveFile(dirEntry, blob, "downloadedImage.png");
+ }
+ };
+ xhr.send();
+}
+```
+>*Note* For Cordova 5 security, the preceding code requires that you add
the domain name, http://cordova.apache.org, to the Content-Security-Policy
<meta> element in index.html.
+
+After getting the file, copy the contents to a new file. The current
DirectoryEntry object is already associated with the app cache.
+
+```js
+function saveFile(dirEntry, fileData, fileName) {
+
+ dirEntry.getFile(fileName, { create: true, exclusive: false },
function (fileEntry) {
+
+ writeFile(fileEntry, fileData);
+
+ }, onErrorCreateFile);
+}
+```
+
+In writeFile, you pass in the Blob object as the dataObj and you will save
that in the new file.
+
+```js
+function writeFile(fileEntry, dataObj, isAppend) {
+
+ // Create a FileWriter object for our FileEntry (log.txt).
+ fileEntry.createWriter(function (fileWriter) {
+
+ fileWriter.onwriteend = function() {
+ console.log("Successful file write...");
+ if (dataObj.type == "image/png") {
+ readBinaryFile(fileEntry);
+ }
+ else {
+ readFile(fileEntry);
+ }
+ };
+
+ fileWriter.onerror = function() {
+ console.log("Failed file write: " + e.toString());
--- End diff --
Oops, this e parameter is actually used below.
---
If your project is set up for it, you can reply to this email and have your
reply appear on GitHub as well. If your project does not have this feature
enabled and wishes so, or if the feature is enabled but not working, please
contact infrastructure at [email protected] or file a JIRA ticket
with INFRA.
---
---------------------------------------------------------------------
To unsubscribe, e-mail: [email protected]
For additional commands, e-mail: [email protected]
