Filesystem API

/* Opening file for write - file is created if not exists, */
/* otherwise existing file is truncated. */
var fileHandleWrite = tizen.filesystem.openFile("documents/file", "w");
console.log("File opened for writing");
fileHandleWrite.writeString("Lorem ipsum dolor sit amet...");
console.log("String has been written to the file");
fileHandleWrite.close();

/* Opening file for read - this code assumes that there is */
/* a file named "file" in documents directory. */
var fileHandleRead = tizen.filesystem.openFile("documents/file", "r");
console.log("File opened for reading");
var fileContent = fileHandleRead.readString();
console.log("File content: " + fileContent);
fileHandleRead.close();

function errorCallback(error)
{
  console.log("An error occurred, during directory creation: " + error.message);
}

function successCallback(path)
{
  console.log("The directory has been created, path to created directory: " + path);
  /* Directory can now be accessed. */
}

try
{
  tizen.filesystem.createDirectory(
      "documents/foo_dir/bar_dir", true, successCallback, errorCallback);
}
catch (error)
{
  console.log("Directory cannot be created: " + error.message);
}

function errorCallback(error)
{
  console.log("An error occurred, during file deletion: " + error.message);
}

function successCallback(path)
{
  console.log("The file has been deleted, path to the parent of deleted file: " + path);
}

try
{
  tizen.filesystem.deleteFile("documents/foo", successCallback, errorCallback);
}
catch (error)
{
  console.log("File cannot be deleted: " + error.message);
}

function errorCallback(error)
{
  console.log("An error occurred, during directory deletion: " + error.message);
}

function successCallback(path)
{
  console.log("The directory has been deleted, path to the parent of deleted directory: " + path);
}

try
{
  tizen.filesystem.deleteDirectory("documents/foo_dir", true, successCallback, errorCallback);
}
catch (error)
{
  console.log("Directory cannot be deleted: " + error.message);
}

function errorCallback(error)
{
  console.log("An error occurred, during copy operation: " + error.message);
}

function successCallback(path)
{
  console.log("The file has been copied, path to copied file: " + path);
  /* File copy can now be accessed. */
}

try
{
  tizen.filesystem.copyFile("documents/foo", "documents/bar", true, successCallback, errorCallback);
}
catch (error)
{
  console.log("Copy operation cannot be performed: " + error.message);
}

function errorCallback(error)
{
  console.log("An error occurred, during copy operation: " + error.message);
}

function successCallback(path)
{
  console.log("The directory has been copied, path to copied directory: " + path);
  /* Directory copy can now be accessed. */
}

try
{
  tizen.filesystem.copyDirectory(
      "documents/foo_dir", "documents/bar_dir", true, successCallback, errorCallback);
}
catch (error)
{
  console.log("Copy operation cannot be performed: " + error.message);
}

function errorCallback(error)
{
  console.log("An error occurred: " + error.message);
}

function createFooDirCallback()
{
  tizen.filesystem.createDirectory(
      "documents/foo_dir/dir_2", true, createFileCallback, errorCallback);
}

function listCallback(files, path)
{
  console.log("Found inside " + path + " directory:");
  for (var i = 0; i < files.length; i++)
  {
    console.log(files[i]);
  }
}

function successCallback(path)
{
  console.log("The directory has been created and copied, path to directory: " + path);
  /* Directory 'documents/bar_dir' content is as below: */
  /* documents/bar_dir/dir_1 */
  /* documents/bar_dir/dir_2 */
  /* documents/bar_dir/dir_1/file */
  tizen.filesystem.listDirectory("documents/bar_dir", listCallback, errorCallback);
  tizen.filesystem.listDirectory("documents/bar_dir/dir_1", listCallback, errorCallback);
}

function createFileCallback()
{
  tizen.filesystem.openFile("documents/foo_dir/dir_1/file", "w").close();

  try
  {
    tizen.filesystem.copyDirectory(
        "documents/foo_dir", "documents/bar_dir", true, successCallback, errorCallback);
  }
  catch (error)
  {
    console.log("Copy operation cannot be performed: " + error.message);
  }
}

tizen.filesystem.createDirectory(
    "documents/foo_dir/dir_1", true, createFooDirCallback, errorCallback);

function errorCallback(error)
{
  console.log("An error occurred, during move operation: " + error.message);
}

function successCallback(path)
{
  console.log("The file has been moved, path to moved file: " + path);
  /* Moved file can now be accessed. */
}

try
{
  tizen.filesystem.moveFile(
      "documents/foo", "documents/foo_dir/", false, successCallback, errorCallback);
}
catch (error)
{
  console.log("Move operation cannot be performed: " + error.message);
}

function errorCallback(error)
{
  console.log("An error occurred, during move operation: " + error.message);
}

function successCallback(path)
{
  console.log("The directory has been moved, path to moved directory: " + path);
  /* Moved directory can now be accessed. */
}

try
{
  tizen.filesystem.moveDirectory(
      "documents/foo_dir", "documents/bar_dir/", false, successCallback, errorCallback);
}
catch (error)
{
  console.log("Move operation cannot be performed: " + error.message);
}

function errorCallback(error)
{
  console.log("An error occurred, during rename operation: " + error.message);
}

function successCallback(path)
{
  console.log("The file has been renamed, path to renamed file or directory: " + path);
}

try
{
  tizen.filesystem.rename("documents/foo", "bar", successCallback, errorCallback);
}
catch (error)
{
  console.log("Rename operation cannot be performed: " + error.message);
}

function errorCallback(error)
{
  console.log("An error occurred, during directory listing: " + error.message);
}

function successCallback(files, path)
{
  console.log("Found directories in " + path + " directory:");
  for (var i = 0; i < files.length; i++)
  {
    console.log(files[i]);
  }
}

try
{
  var start = new Date("Jan 01 2018 00:00:00");
  tizen.filesystem.listDirectory("documents/", successCallback, errorCallback,
      {name: "foo_%", isDirectory: true, startModified: start});
}
catch (error)
{
  console.log("Directory listing cannot be performed: " + error.message);
}

var path1 = tizen.filesystem.toURI("documents/directory/file.ext");
var path2 = tizen.filesystem.toURI("/opt/usr/home/owner/content/Documents/directory/file.ext");
var path3 =
    tizen.filesystem.toURI("file:///opt/usr/home/owner/content/Documents/directory/file.ext");
/* All above paths point to the same file. */

console.log(path1);
console.log(path2);
console.log(path3);

var mmcPath = tizen.filesystem.toURI("removable_sda1/Documents/directory/file");
console.log(mmcPath);

console.log("documents/foo_file is " +
            (tizen.filesystem.isFile("documents/foo_file") ? "file" : "directory"));

console.log("documents/foo_dir is " +
            (tizen.filesystem.isDirectory("documents/foo_dir") ? "directory" : "file"));

console.log("documents/foo " +
            (tizen.filesystem.pathExists("documents/foo") ? "exists" : "does not exist"));

console.log(tizen.filesystem.getDirName("/home/owner/media/Documents"));

function onStorage(storage)
{
  /* Do something. */
}

function onStorageError(e)
{
  console.log("Storage not found: " + e.message);
}

tizen.filesystem.getStorage("music", onStorage, onStorageError);

function alertForCorruptedRemovableDrives(storages)
{
   for (var i = 0; i < storages.length; i++)
   {
      if (storages[i].type != "EXTERNAL")
         continue;
      if (storages[i].state == "UNMOUNTABLE")
         console.log("External drive " + storages[i].label + " is corrupted.");
   }
}

tizen.filesystem.listStorages(alertForCorruptedRemovableDrives);

var watchID;
function onStorageStateChanged(storage)
{
  if (storage.state == "MOUNTED") console.log("Storage " + storage.label + " was added!");
}

watchID = tizen.filesystem.addStorageStateChangeListener(onStorageStateChanged);

var watchID;
function onStorageStateChanged(storage)
{
  if (storage.state == "MOUNTED") console.log("Storage " + storage.label + " was added!");
  tizen.filesystem.removeStorageStateChangeListener(watchID);
}

watchID = tizen.filesystem.addStorageStateChangeListener(onStorageStateChanged);

var dataToWrite = new Uint8Array([11, 21, 31, 44, 55, 66, 71, 81, 91]);
/* Opening file for write - file is created if not exists, */
/* otherwise existing file is truncated. */
var fileHandleWrite = tizen.filesystem.openFile("documents/file", "w");
fileHandleWrite.writeData(dataToWrite);
fileHandleWrite.close();
console.log("Data has been written");

/* Opening file for read - this code assumes that there is */
/* a file named "file" in documents directory. */
var fileHandleRead = tizen.filesystem.openFile("documents/file", "r");
var firstThreeBytes = fileHandleRead.readData(3);
console.log("First three bytes: " + firstThreeBytes);
var position =
    fileHandleRead.seek(-3, "END");  /* Moving to position three bytes to the end of file. */
var lastThreeBytes = fileHandleRead.readData(3);
console.log("Last three bytes: " + lastThreeBytes);
fileHandleRead.seek(3, "BEGIN");  /* Moving to position at third byte. */
var bytesBetween = fileHandleRead.readData(position - 3);
console.log("Bytes between: " + bytesBetween);
fileHandleRead.close();

/* Opening file for write - file is created if not exists, */
/* otherwise existing file is truncated. */
var fileHandleWrite = tizen.filesystem.openFile("documents/file", "w");
fileHandleWrite.writeStringNonBlocking("Lorem ipsum dolor sit amet...",
    function(bytesCount)
    {
      console.log("Number of bytes written: " + bytesCount);
    },
    function(error)
    {
      console.log(error);
    });

/* Moving to position 3 bytes to the end of file to alter three dots ("..."). */
fileHandleWrite.seekNonBlocking(-3,
    function(new_position)
    {
      console.log("Moved to position: " + new_position);
    },
    function(error)
    {
      console.log(error);
    },
    "END");
fileHandleWrite.writeStringNonBlocking(", consectetur adipiscing elit...",
    function(bytesCount)
    {
      console.log("Number of bytes written: " + bytesCount);
    },
    function(error)
    {
      console.log(error);
    });

/* Moving to position 3 bytes to the end of file to alter three dots ("..."). */
fileHandleWrite.seekNonBlocking(-3,
    function(new_position)
    {
      console.log("Moved to position: " + new_position);
    },
    function(error)
    {
      console.log(error);
    },
    "END");
fileHandleWrite.writeStringNonBlocking(", sed do eiusmod...",
    function(bytesCount)
    {
      console.log("Number of bytes written: " + bytesCount);
    },
    function(error)
    {
      console.log(error);
    });
fileHandleWrite.closeNonBlocking(
    function()
    {
      console.log("File handle closed");
    },
    function(error)
    {
      console.log(error);
    });

/* Opening file for read - this code assumes that there is */
/* a file named "file" in documents directory. */
var fileHandleRead = tizen.filesystem.openFile("documents/file", "r");
/* ReadStringSuccessCallback should be executed. */
fileHandleRead.readStringNonBlocking(
    function(output)
    {
      console.log("File content: " + output);
    },
    function(error)
    {
      console.log(error);
    });
fileHandleRead.closeNonBlocking(
    function()
    {
      console.log("File handle closed");
    },
    function(error)
    {
      console.log(error);
    });

/* Opening file for write - file is created if not exists, */
/* otherwise existing file is truncated. */
var fileHandleWrite = tizen.filesystem.openFile("documents/file", "w");
console.log("File opened for writing");
fileHandleWrite.writeString("Lorem ipsum dolor sit amet...");
console.log("String has been written to the file");
fileHandleWrite.close();

/* Opening file for read - this code assumes that there is */
/* a file named "file" in documents directory. */
var fileHandleRead = tizen.filesystem.openFile("documents/file", "r");
console.log("File opened for reading");
var fileContent = fileHandleRead.readString();
console.log("File content: " + fileContent);
fileHandleRead.close();

/* Opening file for write - file is created if not exists, */
/* otherwise existing file is truncated. */
var fileHandleWrite = tizen.filesystem.openFile("documents/file", "w");
console.log("File opened for writing");
fileHandleWrite.writeStringNonBlocking("Lorem ipsum dolor sit amet...",
    function(bytesCount)
    {
      console.log("Number of bytes written: " + bytesCount);
    },
    function(error)
    {
      console.log(error);
    });
fileHandleWrite.closeNonBlocking(
    function()
    {
      console.log("File handle closed");
    },
    function(error)
    {
      console.log(error);
    });

/* Opening file for read - below code assumes that there is */
/* a file named "file" in documents directory. */
var fileHandleRead = tizen.filesystem.openFile("documents/file", "r");
/* ReadStringSuccessCallback should be executed. */
fileHandleRead.readStringNonBlocking(
    function(output)
    {
      console.log("File content: " + output);
    },
    function(error)
    {
      console.log(error);
    });
fileHandleRead.closeNonBlocking(
    function()
    {
      console.log("File handle closed");
    },
    function(error)
    {
      console.log(error);
    });

/* Opening file for write - file is created if not exists, */
/* otherwise existing file is truncated. */
var fileHandleWrite = tizen.filesystem.openFile("documents/file", "w");
console.log("File opened for writing");
fileHandleWrite.writeString("Lorem ipsum dolor sit amet...");
console.log("String has been written to the file");
fileHandleWrite.close();

/* Opening file for read - this code assumes that there is */
/* a file named "file" in documents directory. */
var fileHandleRead = tizen.filesystem.openFile("documents/file", "r");
console.log("File opened for reading");
var fileContent = fileHandleRead.readString();
console.log("File content: " + fileContent);
fileHandleRead.close();

/* Opening file for write - file is created if not exists, */
/* otherwise existing file is truncated. */
var fileHandleWrite = tizen.filesystem.openFile("documents/file", "w");
fileHandleWrite.writeStringNonBlocking("Lorem ipsum dolor sit amet...",
    function(bytesCount)
    {
      console.log("Number of bytes written: " + bytesCount);
    },
    function(error)
    {
      console.log(error);
    });
fileHandleWrite.closeNonBlocking(
    function()
    {
      console.log("File handle closed");
    },
    function(error)
    {
      console.log(error);
    });

/* Opening file for read - below code assumes that there is */
/* a file named "file" in documents directory. */
var fileHandleRead = tizen.filesystem.openFile("documents/file", "r");
/* ReadStringSuccessCallback should be executed. */
fileHandleRead.readStringNonBlocking(
    function(output)
    {
      console.log("File content: " + output);
    },
    function(error)
    {
      console.log(error);
    });
fileHandleRead.closeNonBlocking(
    function()
    {
      console.log("File handle closed");
    },
    function(error)
    {
      console.log(error);
    });

/* Opening file for write - file is created if not exists, */
/* otherwise existing file is truncated. */
var fileHandleWrite = tizen.filesystem.openFile("documents/file", "w");
var b = new Blob(["Lorem ipsum dolor sit amet..."], {type: "text/plain"});
fileHandleWrite.writeBlob(b);
fileHandleWrite.close();
console.log("Blob content has been written to file");

/* Opening file for read - this code assumes that there is */
/* a file named "file" in documents directory. */
var fileHandleRead = tizen.filesystem.openFile("documents/file", "r");
var fileContentInBlob = fileHandleRead.readBlob();
fileHandleRead.close();
const reader = new FileReader();
/* Event fires after the blob has been read/loaded. */
reader.onloadend = function(content)
{
  const text = content.srcElement.result;
  console.log("File content: " + text);
};

/* Starts reading the blob as text. */
reader.readAsText(fileContentInBlob);

/* Opening file for write - file is created if not exists, */
/* otherwise existing file is truncated. */
var fileHandleWrite = tizen.filesystem.openFile("documents/file", "w");
var b = new Blob(["Lorem ipsum dolor sit amet..."], {type: "text/plain"});
fileHandleWrite.writeBlobNonBlocking(b,
    function()
    {
      console.log("Blob content has been written to file");
    },
    function(error)
    {
      console.log(error);
    });
fileHandleWrite.closeNonBlocking(
    function()
    {
      console.log("File handle closed");
    },
    function(error)
    {
      console.log(error);
    });

/* Opening file for read - this code assumes that there is */
/* a file named "file" in documents directory. */
var fileHandleRead = tizen.filesystem.openFile("documents/file", "r");
/* Creation of a reader capable of extracting Blob content. */
const reader = new FileReader();

/* Event fires after the blob has been read/loaded. */
reader.onloadend = function(content)
{
  const text = content.srcElement.result;
  console.log("File content: " + text);
};
function readBlobCallback(fileContentInBlob)
{
  reader.readAsText(fileContentInBlob);
}

/* readBlobCallback should be executed. */
fileHandleRead.readBlobNonBlocking(readBlobCallback, function(error)
{
  console.log(error);
});
fileHandleRead.closeNonBlocking(
    function()
    {
      console.log("File handle closed");
    },
    function(error)
    {
      console.log(error);
    });

/* Opening file for write - file is created if not exists, */
/* otherwise existing file is truncated. */
var fileHandleWrite = tizen.filesystem.openFile("documents/file", "w");
var b = new Blob(["Lorem ipsum dolor sit amet..."], {type: "text/plain"});
fileHandleWrite.writeBlob(b);
fileHandleWrite.close();
console.log("Blob content has been written to file");

/* Opening file for read - this code assumes that there is */
/* a file named "file" in documents directory. */
var fileHandleRead = tizen.filesystem.openFile("documents/file", "r");
var fileContentInBlob = fileHandleRead.readBlob();
fileHandleRead.close();
console.log("File content has been read from file");
const reader = new FileReader();

/* Event fires after the blob has been read/loaded. */
reader.onloadend = function(content)
{
  const text = content.srcElement.result;
  console.log("File content: " + text);
};

/* Starts reading the blob as text. */
reader.readAsText(fileContentInBlob);

/* Opening file for write - file is created if not exists, */
/* otherwise existing file is truncated. */
var fileHandleWrite = tizen.filesystem.openFile("documents/file", "w");
var b = new Blob(["Lorem ipsum dolor sit amet..."], {type: "text/plain"});
fileHandleWrite.writeBlobNonBlocking(b,
    function()
    {
      console.log("Blob content has been written to file");
    },
    function(error)
    {
      console.log(error);
    });
fileHandleWrite.closeNonBlocking(
    function()
    {
      console.log("File handle closed");
    },
    function(error)
    {
      console.log(error);
    });

/* Opening file for read - this code assumes that there is */
/* a file named "file" in documents directory. */
var fileHandleRead = tizen.filesystem.openFile("documents/file", "r");
/* Creation of a reader capable of extracting Blob content. */
const reader = new FileReader();

/* Event fires after the blob has been read/loaded. */
reader.onloadend = function(content)
{
  const text = content.srcElement.result;
  console.log("File content: " + text);
};
function readBlobCallback(fileContentInBlob)
{
  reader.readAsText(fileContentInBlob);
}

/* readBlobCallback should be executed. */
fileHandleRead.readBlobNonBlocking(readBlobCallback);
fileHandleRead.closeNonBlocking(
    function()
    {
      console.log("File handle closed");
    },
    function(error)
    {
      console.log(error);
    });

var dataToWrite = new Uint8Array([11, 21, 31, 71, 81, 91]);
/* Opening file for write - file is created if not exists, */
/* otherwise existing file is truncated. */
var fileHandleWrite = tizen.filesystem.openFile("documents/file", "w");
fileHandleWrite.writeData(dataToWrite);
fileHandleWrite.close();
console.log("Data has been written");

/* Opening file for read - below code assumes that there is */
/* a file named "file" in documents directory. */
var fileHandleRead = tizen.filesystem.openFile("documents/file", "r");
var fileContentInUint8Array = fileHandleRead.readData();
fileHandleRead.close();
console.log("Data read from file: " + fileContentInUint8Array);

var dataToWrite = new Uint8Array([11, 21, 31, 71, 81, 91]);
/* Opening file for write - file is created if not exists, */
/* otherwise existing file is truncated. */
var fileHandleWrite = tizen.filesystem.openFile("documents/file", "w");
fileHandleWrite.writeDataNonBlocking(dataToWrite,
    function(dataRead)
    {
      console.log("Write done");
    },
    function(error)
    {
      console.log(error);
    });
fileHandleWrite.closeNonBlocking(
    function()
    {
      console.log("File handle closed");
    },
    function(error)
    {
      console.log(error);
    });

/* Opening file for read - below code assumes that there is */
/* a file named "file" in documents directory. */
var fileHandleRead = tizen.filesystem.openFile("documents/file", "r");
fileHandleRead.readDataNonBlocking(
    function(dataRead)
    {
      console.log("Data read from file: " + dataRead);
    },
    function(error)
    {
      console.log(error);
    });
fileHandleRead.closeNonBlocking(
    function()
    {
      console.log("File handle closed");
    },
    function(error)
    {
      console.log(error);
    });

var dataToWrite = new Uint8Array([11, 21, 31, 71, 81, 91]);
/* Opening file for write - file is created if not exists, */
/* otherwise existing file is truncated. */
var fileHandleWrite = tizen.filesystem.openFile("documents/file", "w");
fileHandleWrite.writeData(dataToWrite);
fileHandleWrite.close();
console.log("Data has been written");

/* Opening file for read - below code assumes that there is */
/* a file named "file" in documents directory. */
var fileHandleRead = tizen.filesystem.openFile("documents/file", "r");
var fileContentInUint8Array = fileHandleRead.readData();
fileHandleRead.close();
console.log("Data read from file: " + fileContentInUint8Array);

var dataToWrite = new Uint8Array([11, 21, 31, 71, 81, 91]);
/* Opening file for write - file is created if not exists, */
/* otherwise existing file is truncated. */
var fileHandleWrite = tizen.filesystem.openFile("documents/file", "w");
fileHandleWrite.writeDataNonBlocking(dataToWrite,
    function(dataRead)
    {
      console.log("Write done");
    },
    function(error)
    {
      console.log(error);
    });
fileHandleWrite.closeNonBlocking(
    function()
    {
      console.log("File handle closed");
    },
    function(error)
    {
      console.log(error);
    });

/* Opening file for read - below code assumes that there is */
/* a file named "file" in documents directory. */
var fileHandleRead = tizen.filesystem.openFile("documents/file", "r");
fileHandleRead.readDataNonBlocking(
    function(dataRead)
    {
      console.log("Data read from file: " + dataRead);
    },
    function(error)
    {
      console.log(error);
    });
fileHandleRead.closeNonBlocking(
    function()
    {
      console.log("File handle closed");
    },
    function(error)
    {
      console.log(error);
    });

/* Opening file for write - file is created if not exists, */
/* otherwise existing file is truncated. */
var fileHandleWrite = tizen.filesystem.openFile("documents/file", "w");
var fileHandleRead = tizen.filesystem.openFile("documents/file", "r");
fileHandleWrite.writeString("Lorem ipsum dolor sit amet...");
console.log("Data has been written to file");

/* Calling flush() ensures that content has been written to file descriptor and can be read by any */
/* process. */
fileHandleWrite.flush();
console.log("Data has been flushed to system file buffer and now can be read");

var fileContent = fileHandleRead.readString();
console.log("Read data: " + fileContent);
fileHandleWrite.close();
fileHandleRead.close();

/* Opening file for write - file is created if not exists, */
/* otherwise existing file is truncated. */
var fileHandleWrite = tizen.filesystem.openFile("documents/file", "w");
fileHandleWrite.writeStringNonBlocking("Lorem ipsum dolor sit amet...",
    function(bytesCount)
    {
      console.log("Number of bytes written: " + bytesCount);
    },
    function(error)
    {
      console.log(error);
    });

/* Calling flushNonBlocking() ensures that content will be written to file descriptor */
/* and can be read by any process. */
fileHandleWrite.flushNonBlocking(
    function()
    {
      console.log("Data has been flushed to system file buffer and now can be read");
    },
    function(error)
    {
      console.log(error);
    });

/* Opening file for read - this code assumes that there is */
/* a file named "file" in documents directory. */
var fileHandleRead = tizen.filesystem.openFile("documents/file", "r");
fileHandleRead.readStringNonBlocking(
    function(output)
    {
      console.log("File content: " + output);
    },
    function(error)
    {
      console.log(error);
    });
fileHandleWrite.closeNonBlocking(
    function()
    {
      console.log("File handle closed");
    },
    function(error)
    {
      console.log(error);
    });
fileHandleRead.closeNonBlocking(
    function()
    {
      console.log("File handle closed");
    },
    function(error)
    {
      console.log(error);
    });

var dataToWrite = new Uint8Array([11, 21, 31, 71, 81, 91]);
/* Opening file for write - file is created if not exists, */
/* otherwise existing file is truncated. */
var fileHandleWrite = tizen.filesystem.openFile("documents/file", "w");
fileHandleWrite.writeData(dataToWrite);

/* Calling sync() forces a physical write of data, so it is safe */
/* even after system crash or power shut down. */
fileHandleWrite.sync();
console.log("Data has been synced");

/* close() method provides the same functionality as sync() and ends access to file. */
fileHandleWrite.close();

var dataToWrite = new Uint8Array([11, 21, 31, 71, 81, 91]);
/* Opening file for write - file is created if not exists, */
/* otherwise existing file is truncated. */
var fileHandleWrite = tizen.filesystem.openFile("documents/file", "w");
fileHandleWrite.writeDataNonBlocking(dataToWrite,
    function(dataRead)
    {
      console.log("Write done");
    },
    function(error)
    {
      console.log(error);
    });

/* Calling syncNonBlocking() will force a physical write of data, so it will be safe */
/* even after system crash or power shut down. */
fileHandleWrite.syncNonBlocking(
    function()
    {
      console.log("Data has been synced");
    },
    function(error)
    {
      console.log(error);
    });

/* close() method provides the same functionality as sync() and ends access to file. */
fileHandleWrite.closeNonBlocking(
    function()
    {
      console.log("File handle closed");
    },
    function(error)
    {
      console.log(error);
    });

/* Opening file for write - file is created if not exists, */
/* otherwise existing file is truncated. */
var fileHandleWrite = tizen.filesystem.openFile("documents/file", "w");
fileHandleWrite.writeString("Lorem ipsum dolor sit amet...");
fileHandleWrite.close();
console.log("String has been written to the file");

/* Opening file for read - this code assumes that there is */
/* a file named "file" in documents directory. */
var fileHandleRead = tizen.filesystem.openFile("documents/file", "r");
var positionOfFileEnd = fileHandleRead.seek(0, "END");
console.log("Seek operation done. Position of file end: " + positionOfFileEnd);
fileHandleRead.close();
console.log("File is now closed");

/* Opening file for write - file is created if not exists, */
/* otherwise existing file is truncated. */
var fileHandleWrite = tizen.filesystem.openFile("documents/file", "w");
fileHandleWrite.writeStringNonBlocking("Lorem ipsum dolor sit amet...",
    function(bytesCount)
    {
      console.log("Number of bytes written: " + bytesCount);
    },
    function(error)
    {
      console.log(error);
    });
fileHandleWrite.closeNonBlocking(
    function()
    {
      console.log("File handle closed");
    },
    function(error)
    {
      console.log(error);
    });

/* Opening file for read - this code assumes that there is */
/* a file named "file" in documents directory. */
var fileHandleRead = tizen.filesystem.openFile("documents/file", "r");
var positionOfFileEnd = fileHandleRead.seekNonBlocking(0,
    function(new_position)
    {
      console.log("Moved to position: " + new_position);
    },
    function(error)
    {
      console.log(error);
    },
    "END");
fileHandleRead.closeNonBlocking(
    function()
    {
      console.log("File handle closed");
    },
    function(error)
    {
      console.log(error);
    });