File Management

You can perform operations on files and directories stored in the device filesystem.

The File API is mandatory for Tizen Mobile, Wearable, and TV profiles, which means that it is supported on all mobile, wearable, and TV devices. All mandatory APIs are supported on the Tizen emulators.

The main features of the File API include the following:

Resolving the filesystem

A basic step necessary to perform other file actions is to resolve a filesystem, which results in a FileSystem object (in mobile, wearable, and TV applications) being retrieved. You can use the root member to perform other actions on this filesystem.
Operating on directories

You can create or remove a directory or file, or read all entries from a specific directory.
Operating on entries

You can get metadata, and move, copy, and remove entries. You can also look up the parent directory of the entry or return the entry URL.
Operating on files

You can access file details.
Reading and writing file content

You can read file content, and create and write data to a file. Using the file readers and writers, you can read Blob objects in a specific format (data URL, test, binary string, and array buffer).

Prerequisites

To enable your application to use the file functionality, follow these steps:

To perform any Cordova-related operations, you must wait until Cordova is fully set up (the deviceready event occurs):

document.addEventListener('deviceready', onDeviceReady, false);

function onDeviceReady() {
    console.log('Cordova features now available');
}

To use the File API (in mobile, wearable, and TV applications), the application has to request permission by adding the following privileges to the config.xml file:

<!--To read from files-->
<tizen:privilege name="http://tizen.org/privilege/filesystem.read"/>
<!--To write to files-->
<tizen:privilege name="http://tizen.org/privilege/filesystem.write"/>

Resolve filesystem entries

To resolve the initial root for other filesystem operations, follow these steps:

Use the requestFileSystem() global async method:
- Define a callback for handling the success and failure of the operation:
```
successCallback = function(fs) {
    console.log('File system name ' + fs.name);
};

errorCallback = function(err) {
    console.log(err.code);
};
```
- Call the method with the created callbacks. The filesystem request can use a temporary or persistent filesystem with a defined size:
```
requestFileSystem(TEMPORARY, 1024*1024, successCallback, errorCallback);
```
The following output is shown in the system log:
```
File system name temporary
```
Use the resolveLocalFileSystemURL() global async method.
This method is used to retrieve DirectoryEntry objects (in mobile, wearable, and TV applications) or FileEntry objects (in mobile, wearable, and TV applications) using a local URI.
- Define the callbacks:
```
successCallback = function(entry) {
    console.log('Entry name ' + entry.name);
};

errorCallback = function(err) {
    console.log(err.code);
};
```
- Call the method with the provided valid URI for an existing file or directory:
```
var uri = 'file:///home/owner/content/Documents/example.txt';
resolveLocalFileSystemURL(uri, successCallback, errorCallback);
```
The following output is shown in the system log:
```
Entry name example.txt
```

Operate on directories

To create directories and files, delete directories, and read entries within directories, follow these steps:

To create a directory, you can use the getDirectory() method:
```
requestFileSystem(TEMPORARY, 100, function(fs) {
    fs.root.getDirectory('ert', {create:true}, function(dir) {
        console.log('Created dir: ' + dir.name);
    });
});
```
If the third parameter is {create:false} or NULL, the entry of the existing directory is returned in the success callback.
The following output is shown in the system log:
```
Created dir: ert
```
To create a file, use the getFile() method:
```
requestFileSystem(TEMPORARY, 100, function(fs) {
    fs.root.getFile('qa.txt', {create:true}, function(file) {
        console.log('Created file: ' + file.name);
    });
});
```
Similarly as when creating a directory, if the third parameter is {create:false} or NULL, the entry of the existing file is returned in the success callback.
The following output is shown in the system log:
```
Created file: qa.txt
```

To delete a directory and its entire content, you can use the removeRecursively() method:

requestFileSystem(TEMPORARY, 100, function(fs) {
    fs.root.getDirectory('testDirectory', {create:true}, function(directoryEntry) {
        directoryEntry.removeRecursively(function() {
            console.log('success');
        });
    });
});