cordova-dev mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From jasongin <...@git.apache.org>
Subject [GitHub] cordova-plugin-file pull request: adding sample section to readme
Date Mon, 04 Apr 2016 20:20:45 GMT
Github user jasongin commented on a diff in the pull request:

    https://github.com/apache/cordova-plugin-file/pull/176#discussion_r58441476
  
    --- Diff: README.md ---
    @@ -538,3 +540,263 @@ 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 ##
    +
    +The File plugin allows you to do things like store files in a temporary or persistent
storage location for your app (sandboxed storage). 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 can use the File plugin APIs, you must 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, 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.
    +
    +Here is a request for persistent storage.
    +
    +>*Note* When targeting devices (instead of a browser), you dont need to use `requestQuota`
before using persistent storage.
    +
    +```
    +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.
    +
    +```
    +window.requestFileSystem(window.TEMPORARY, 5 * 1024 * 1024, function (fs) {
    +
    +    console.log('file system open: ' + fs.name);
    +    createFile(fs.root, "newTempFile.txt");
    +
    +}, 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.
    +
    +```
    +// Creates a new file or returns the file if it already exists.
    +dirEntry.getFile(fileName, {create: true, exclusive: false}, function(fileEntry) {
    +
    +    writeFile(fileEntry);
    +
    +}, 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.
    +
    +```
    +function writeFile(fileEntry, dataObj) {
    +    // Create a FileWriter object for our FileEntry (log.txt).
    +    fileEntry.createWriter(function (fileWriter) {
    +
    +        fileWriter.onwriteend = function (e) {
    --- End diff --
    
    Remove the (e) parameter from this callback function, since there is not an error.


---
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 infrastructure@apache.org or file a JIRA ticket
with INFRA.
---

---------------------------------------------------------------------
To unsubscribe, e-mail: dev-unsubscribe@cordova.apache.org
For additional commands, e-mail: dev-help@cordova.apache.org


Mime
View raw message