class File

The folder containing the application's installed files.

The url property for this object uses the app URL scheme (not the file URL scheme). This means that the url string is specified starting with "app:" (not "file:"). Also, if you create a File object relative to the File.applicationDirectory directory (by using the resolvePath() method), the url property of the File object also uses the app URL scheme. The url property is currently unsupported on all targets execpt AIR.

Note: You cannot write to files or directories that have paths that use the app: URL scheme. Also, you cannot delete or create files or folders that have paths that use the app: URL scheme. Modifying content in the application directory is a bad practice, for security reasons, and is blocked by the operating system on some platforms. If you want to store application-specific data, consider using the application storage directory (File.applicationStorageDirectory). If you want any of the content in the application storage directory to have access to the application-privileged functionality (AIR APIs), you can expose that functionality by using a sandbox bridge.

The applicationDirectory property provides a way to reference the application directory that works across platforms. If you set a File object to reference the application directory using the nativePath or url property, it will only work on the platform for which that path is valid.

On Android, the nativePath property of a File object pointing to the application directory is an empty string. Use the url property to access application files.

See also:

• Working with File objects in OpenFL

The application's private storage directory.

Each application has a unique, persistent application storage directory, which is created when you first access File.applicationStorageDirectory. This directory is unique to each application and user. This directory is a convenient location to store user-specific or application-specific data.

The url property for this object uses the app-storage URL scheme (not the file URL scheme). This means that the url string is specified starting with "app-storage:" (not "file:"). Also, if you create a File object relative to the File.applicationStoreDirectory directory (by using the resolvePath() method), the url of the File object also uses the app-storage URL scheme (as in the example). The url property is currently unsupported on all targets execpt AIR.

The applicationStorageDirectory property provides a way to reference the application storage directory that works across platforms. If you set a File object to reference the application storage directory using the nativePath or url property, it will only work on the platform for which that path is valid.

The following code creates a File object pointing to the "images" subdirectory of the application storage directory.

import openfl.filesystem.File;

var tempFiles:File = File.applicationStorageDirectory;
tempFiles = tempFiles.resolvePath("images/");
trace(tempFiles.url); // app-storage:/images

See also:

• Working with File objects in OpenFL

The user's desktop directory.

The desktopDirectory property provides a way to reference the desktop directory that works across platforms. If you set a File object to reference the desktop directory using the nativePath or url property, it will only work on the platform for which that path is valid.

If an operating system does not support a desktop directory, a suitable directory in the file system is used instead.

The following code outputs a list of files and directories contained in the user's desktop directory.

import openfl.filesystem.File;
var desktop:File = File.desktopDirectory;

var files:Array = desktop.getDirectoryListing();

for (i in 0...files.length) {
	trace(files[i].nativePath);
}

See also:

• Working with File objects in OpenFL

The user's documents directory.

On Windows, this is the My Documents directory (for example, C:\Documents and Settings\userName\My Documents). On Mac OS, the default location is /Users/userName/Documents. On Linux, the default location is /home/userName/Documents (on an English system), and the property observes the xdg-user-dirs setting.

The documentsDirectory property provides a way to reference the documents directory that works across platforms. If you set a File object to reference the documents directory using the nativePath or url property, it will only work on the platform for which that path is valid.

If an operating system does not support a documents directory, a suitable directory in the file system is used instead.

The following code uses the File.documentsDirectory property and the File.createDirectory() method to ensure that a directory named "OpenFL Test" exists in the user's documents directory.

import openfl.filesystem.File;

var directory:File = File.documentsDirectory;
directory = directory.resolvePath("OpenFL Test");

File.createDirectory(directory);
trace(directory.exists); // true

See also:

• Working with File objects in OpenFL

The line-ending character sequence used by the host operating system.

On Mac OS and Linux, this is the line-feed character (character code 0x0A hexadecimal). On Windows, this is the carriage return character (character code 0x0D hexadecimal) followed by the line-feed character (character code 0x0A hexadecimal).

See also:

• Getting file system information

The host operating system's path component separator character.

On Mac OS and Linux, this is the forward slash (/) character. On Windows, it is the backslash (\) character.

Note: When using the backslash character in a String literal, remember to type the character twice (as in "directory\\file.ext"). Each pair of backslashes in a String literal represent a single backslash in the String.

See also:

• Getting file system information

The user's directory.

On Windows, this is the parent of the My Documents directory (for example, C:\Documents and Settings\userName). On Mac OS, it is /Users/userName. On Linux, it is /home/userName.

The userDirectory property provides a way to reference the user directory that works across platforms. If you set the nativePath or url property of a File object directly, it will only work on the platform for which that path is valid.

If an operating system does not support a user directory, a suitable directory in the file system is used instead.

The following code outputs a list of files and directories contained in the root level of the user directory:

import openfl.filesystem.File;

var files:Array = File.userDirectory.listDirectory();
for (i in 0...files.length) {
	trace(files[i].nativePath);
}

See also:

• Working with File objects in OpenFL

The application's working directory.

Returns a reference to a new temporary directory. This is a new directory in the system's temporary directory path.

This method lets you identify a new, unique directory, without having to query the system to see that the directory is new and unique.

You may want to delete the temporary directory before closing the application, since on some devices it is not deleted automatically.

The following code uses the createTempFile() method to obtain a reference to a new temporary directory.

import openfl.File;

var temp:File = File.createTempDirectory();
trace(temp.nativePath);

Each time you run this code, a new (unique) file is created.

Returns:

See also:

• Working with directories

Returns a reference to a new temporary file. This is a new file in the system's temporary directory path.

This method lets you identify a new, unique file, without having to query the system to see that the file is new and unique.

You may want to delete the temporary file before closing the application, since it is not deleted automatically.

The following code uses the createTempFile() method to obtain a reference to a new temporary file.

import openfl.File;

var temp:File = File.createTempFile();
trace(temp.nativePath);

Returns:

See also:

• Working with files

Returns an array of File objects, listing the file system root directories.

For example, on Windows this is a list of volumes such as the C: drive and the D: drive. An empty drive, such as a CD or DVD drive in which no disc is inserted, is not included in this array. On Mac OS and Linux, this method always returns the unique root directory for the machine (the "/" directory)

On file systems for which the root is not readable, such as the Android file system, the properties of the returned File object do not always reflect the true value. For example, on Android, the spaceAvailable property reports 0.

The following code outputs a list of root directories:

import flash.filesystem.File;
var rootDirs:Array = File.getRootDirectories();

for (i in 0...rootDirs.length) {
	trace(rootDirs[i].nativePath);
}

Returns:

The constructor function for the File class.

If you pass a path argument, the File object points to the specified path, and the nativePath property and and url property are set to reflect that path.

Although you can pass a path argument to specify a file path, consider whether doing so may result in platform-specific code. For example, a native path such as "C:\Documents and Settings\bob\Desktop" or a URL such as "file:///C:/Documents%20and%20Settings/bob/Desktop" is only valid on Windows. It is far better to use the following static properties, which represent commonly used directories, and which are valid on all platforms:

*File.applicationDirectory
*File.applicationStorageDirectory
*File.desktopDirectory
*File.documentsDirectory
*File.userDirectory

You can then use the resolvePath() method to get a path relative to these directories. For example, the following code sets up a File object to point to the settings.xml file in the application storage directory:

var file:File = File.applicationStorageDirectory.resolvePath("settings.xml");

Parameters:

Throws:

Indicates whether the referenced file or directory exists. The value is true if the File object points to an existing file or directory, false otherwise.

The following code creates a temporary file, then deletes it and uses the File.exists property to check for the existence of the file.

import openfl.filesystem.*;

var temp:File = File.createTempFile();
trace(temp.exists); // true
temp.deleteFile();
trace(temp.exists); // false

An Icon object containing the icons defined for the file. An Icon object is an array of BitmapData objects corresponding to the various icon states. On Linux, the Icon object contains no icons. On Android, the icon property is null.

Indicates whether the reference is to a directory. The value is true if the File object points to a directory; false otherwise.

The following code creates an array of File objects pointing to files and directories in the user directory and then uses the isDirectory property to list only those File objects that point to directories (not to files).

import openfl.filesystem.*;

var userDirFiles:Array = File.userDirectory.getDirectoryListing();
for (i in 0...userDirFiles.length) {
	if (userDirFiles[i].isDirectory) {
		trace(userDirFiles[i].nativePath);
	}
}

See also:

• Working with directories

Indicates whether the referenced file or directory is "hidden." The value is true if the referenced file or directory is hidden, false otherwise.

The following code creates an array of File objects pointing to files and directories in the user directory and then uses the isHidden property to list hidden files and directories.

import openfl.filesystem.*;

var userDirFiles:Array = File.userDirectory.getDirectoryListing();
for (i in 0...userDirFiles.length) {
	if (userDirFiles[i].isHidden) {
		trace(userDirFiles[i].nativePath);
	}
}

The full path in the host operating system representation. On Mac OS and Linux, the forward slash (/) character is used as the path separator. However, in Windows, you can set the nativePath property by using the forward slash character or the backslash () character as the path separator, and AIR automatically replaces forward slashes with the appropriate backslash character.

Before writing code to set the nativePath property directly, consider whether doing so may result in platform-specific code. For example, a native path such as "C:\Documents and Settings\bob\Desktop" is only valid on Windows. It is far better to use the following static properties, which represent commonly used directories, and which are valid on all platforms:

*File.applicationDirectory
*File.applicationStorageDirectory
*File.desktopDirectory
*File.documentsDirectory
*File.userDirectory

You can use the resolvePath() method to get a path relative to these directories.

Throws:

import openfl.filesystem.File;
var docs:File = File.documentsDirectory;
trace(docs.nativePath); // C:\Documents and Settings\turing\My Documents
trace(docs.url); // file:///C:/Documents%20and%20Settings/turing/My%20Documents

The directory that contains the file or directory referenced by this File object.

If the file or directory does not exist, the parent property still returns the File object that points to the containing directory, even if that directory does not exist.

This property is identical to the return value for resolvePath("..") except that the parent of a root directory is null.

The following code uses the parent property to show the directory that contains a temporary file.

import openfl.filesystem.File;

var tempFile:File = File.createTempDirectory();
trace(tempFile.parent.nativePath);
tempFile.deleteFile();

See also:

• Working with directories

Displays a file-browsing dialog box that lets the user select a file to upload.

Displays a directory chooser dialog box, in which the user can select a directory. When the user selects the directory, the select event is dispatched. The target property of the select event is the File object pointing to the selected directory.

The directory chooser dialog is not always displayed in front of windows that are "owned" by another window (windows that have a non-null owner property). To avoid window ordering issues, hide owned windows before calling this method.

Parameters:

Throws:

import openfl.filesystem.File;
import openfl.events.Event;
var directory:File = File.documentsDirectory;
try
{
	directory.browseForDirectory("Select Directory");
	directory.addEventListener(Event.SELECT, directorySelected);
}
catch (error:Error)
{
	trace("Failed:", error.message);
}
function directorySelected(event:Event):Void
{
	directory = event.target as File;
	var files:Array = directory.getDirectoryListing();
	for(i in 0...files.length)
	{
		trace(files[i].name);
	}
}

Events:

Displays the Open File dialog box, in which the user can select a file to open.

When the user selects the file, the select event is dispatched. The target property of the select event is the File object pointing to the selected file.

The Open File dialog is not always displayed in front of windows that are "owned" by another window (windows that have a non-null owner property). To avoid window ordering issues, hide owned windows before calling this method.

Parameters:

Throws:

import openfl.filesystem.*;
import openfl.events.Event;
import openfl.net.FileFilter;
var fileToOpen:File = new File();
var txtFilter:FileFilter = new FileFilter("Text", "*.as;*.css;*.html;*.txt;*.xml");
try
{
	fileToOpen.browseForOpen("Open", [txtFilter]);
	fileToOpen.addEventListener(Event.SELECT, fileSelected);
}
catch (error:Error)
{
	trace("Failed:", error.message);
}
function fileSelected(event:Event):Void
{
	var stream:FileStream = new FileStream();
	stream.open(event.target, FileMode.READ);
	var fileData:String = stream.readUTFBytes(stream.bytesAvailable);
	trace(fileData);
}

Events:

Displays the Open File dialog box, in which the user can select one or more files to open.

When the user selects the files, the selectMultiple event is dispatched. The target property of the select event is this File object. Unlike browseForOpen(), with the browseForOpenMultiple() method, this File object is not updated to reference any of the chosen files. Instead, the resulting selectMultiple event contains an array of the chosen files.

The Open File dialog is not always displayed in front of windows that are "owned" by another window (windows that have a non-null owner property). To avoid window ordering issues, hide owned windows before calling this method.

Parameters:

Throws:

import openfl.filesystem.*;
import openfl.events.FileListEvent;
var docsDir:File = File.documentsDirectory;
try
{
	docsDir.browseForOpenMultiple("Select Files");
	docsDir.addEventListener(FileListEvent.SELECT_MULTIPLE, filesSelected);
}
catch (error:Error)
{
	trace("Failed:", error.message);
}
function filesSelected(event:FileListEvent):Void
{
	for (i in 0...event.files.length)
	{
		trace(event.files[i].nativePath);
	}
}

Events:

Displays the Save File dialog box, in which the user can select a file destination.

When the user selects the file, the select event is dispatched. The target property of the select event is the File object pointing to the selected Save destination.

The Save File dialog is not always displayed in front of windows that are "owned" by another window (windows that have a non-null owner property). To avoid window ordering issues, hide owned windows before calling this method.

Parameters:

Throws:

import openfl.filesystem.*;
import openfl.events.Event;
var docsDir:File = File.documentsDirectory;
try
{
	docsDir.browseForSave("Save As");
	docsDir.addEventListener(Event.SELECT, saveData);
}
catch (error:Error)
{
	trace("Failed:", error.message);
}
function saveData(event:Event):Void
{
	var newFile:File = event.target as File;
	var str:String = "Hello.";
	if (!newFile.exists)
	{
		var stream:FileStream = new FileStream();
		stream.open(newFile, FileMode.WRITE);
		stream.writeUTFBytes(str);
		stream.close();
	}
}

Events:

Cancels any pending asynchronous operation.

Canonicalizes the File path.

If the File object represents an existing file or directory, canonicalization adjusts the path so that it matches the case of the actual file or directory name. If the File object is a symbolic link, canonicalization adjusts the path so that it matches the file or directory that the link points to, regardless of whether the file or directory that is pointed to exists. On case sensitive file systems (such as Linux), when multiple files exist with names differing only in case, the canonicalize() method adjusts the path to match the first file found (in an order determined by the file system).

The following code shows how to use the canonicalize() method to find the correct capitalization of a directory name. Before running this example, create a directory named OpenFL Test on the desktop of your computer.

import openfl.filesystem.*;

var path:File = File.desktopDirectory.resolvePath("openfl test");
trace(path.nativePath);
path.canonicalize();
trace(path.nativePath); // ...\OpenFL Test

Returns a copy of this File object. Event registrations are not copied.

Note: This method does not copy the file itself. It simply makes a copy of the instance of the Haxe File object. To copy a file, use the copyTo() method.

Copies the file or directory at the location specified by this File object to the location specified by the newLocation parameter. The copy process creates any required parent directories (if possible). When overwriting files using copyTo(), the file attributes are also overwritten.

Parameters:

Throws:

import openfl.filesystem.File;
import openfl.events.Event;
var sourceFile:FileReference = File.documentsDirectory;
sourceFile = sourceFile.resolvePath("OpenFL Test/test1.txt");
var destination:FileReference = File.documentsDirectory;
destination = destination.resolvePath("OpenFL Test/test2.txt");
if (sourceFile.copyTo(destination, true)) {
	trace("Done.");
}

import openfl.filesystem.File;
var sourceFile:File = File.documentsDirectory;
sourceFile = sourceFile.resolvePath("OpenFL Test/test1.txt");
var destination:File = File.documentsDirectory;
destination = destination.resolvePath("OpenFL Test/test2.txt");
try
{
	sourceFile.copyTo(destination, true);
}
catch (error:Error)
{
	trace("Error:", error.message);
}

See also:

• Working with files

Begins copying the file or directory at the location specified by this File object to the location specified by the destination parameter.

Upon completion, either a complete event (successful) or an ioError event (unsuccessful) is dispatched. The copy process creates any required parent directories (if possible).

Parameters:

Throws:

import openfl.filesystem.File;
import openfl.events.Event;
var sourceFile:File = File.documentsDirectory;
sourceFile = sourceFile.resolvePath("OpenFL Test/test1.txt");
var destination:File = File.documentsDirectory;
destination = destination.resolvePath("OpenFL Test/test2.txt");
sourceFile.copyToAsync(destination, true);
sourceFile.addEventListener(Event.COMPLETE, fileCopiedHandler);
function fileCopiedHandler(event:Event):Void {
	trace("Done.");
}

Events:

See also:

• Working with files

Creates the specified directory and any necessary parent directories. If the directory already exists, no action is taken.

Throws:

import openfl.filesystem.*;
var source:File = File.desktopDirectory.resolvePath("test.txt");
var target:File = File.documentsDirectory.resolvePath("OpenFL Test/test.txt");
var targetParent:File = target.parent;
targetParent.createDirectory();
source.moveTo(target, true);

See also:

• Working with directories

Deletes the directory.

Parameters:

Throws:

import openfl.filesystem.File;
var directory:File = File.documentsDirectory.resolvePath("Empty Junk Directory/");
File.createDirectory(directory);
trace(directory.exists); // true
directory.deleteDirectory();
trace(directory.exists); // false

See also:

• Working with directories

Deletes the directory asynchronously.

Parameters:

Throws:

Events:

See also:

• Working with directories

Deletes the file.

Throws:

import openfl.filesystem.*;
var file:File = File.createTempFile();
trace(file.exists); // true
file.deleteFile();
trace(file.exists); // false

See also:

• Working with files

Deletes the file asynchronously.

Throws:

Events:

See also:

• Working with files

Returns an array of File objects corresponding to files and directories in the directory represented by this File object. This method does not explore the contents of subdirectories.

The following code shows how to use the getDirectoryListing() method to enumerate the contents of the user directory.

import openfl.filesystem.File;

var directory:File = File.userDirectory;
var list:Array = directory.getDirectoryListing();
for (i in 0...list.length) {
	trace(list[i].nativePath);
}

Returns:

See also:

• Working with directories

Asynchronously retrieves an array of File objects corresponding to the contents of the directory represented by this File object.

Events:

import openfl.filesystem.File;
import openfl.events.FileListEvent;
var directory:File = File.userDirectory;
directory.getDirectoryListingAsync();
directory.addEventListener(FileListEvent.DIRECTORY_LISTING, directoryListingHandler);
function directoryListingHandler(event:FileListEvent):Void {
	var list:Array = event.files;
	for (i in 0...list.length) {
		trace(list[i].nativePath);
	}
}

See also:

• Working with directories

Finds the relative path between two File paths.

The relative path is the list of components that can be appended to (resolved against) this reference in order to locate the second (parameter) reference. The relative path is returned using the "/" separator character.

Optionally, relative paths may include ".." references, but such paths will not cross conspicuous volume boundaries.

Parameters:

Returns:

Throws:

Moves the file or directory at the location specified by this File object to the location specified by the destination parameter.

To rename a file, set the destination parameter to point to a path that is in the file's directory, but with a different filename.

The move process creates any required parent directories (if possible).

Parameters:

Throws:

import openfl.filesystem.File;
import openfl.events.Event;
var sourceFile:File = File.documentsDirectory;
sourceFile = sourceFile.resolvePath("OpenFL Test/test1.txt");
var destination:File = File.documentsDirectory;
destination = destination.resolvePath("Apollo Test/test2.txt");
try
{
	sourceFile.moveTo(destination, true);
}
catch (error:Error)
{
	trace("Error:" + error.message);
}

See also:

• Working with files

Begins moving the file or directory at the location specified by this File object to the location specified by the newLocation parameter.

To rename a file, set the destination parameter to point to a path that is in the file's directory, but with a different filename.

The move process creates any required parent directories (if possible).

@see Working with files

Parameters:

Throws:

import openfl.filesystem.File;
import openfl.events.Event;
var sourceFile:File = File.documentsDirectory;
sourceFile = sourceFile.resolvePath("OpenFL Test/test1.txt");
var destination:File = File.documentsDirectory;
destination = destination.resolvePath("OpenFL Test/test2.txt");
sourceFile.moveToAsync(destination, true);
sourceFile.addEventListener(Event.COMPLETE, fileMoveCompleteHandler);
function fileMoveCompleteHandler(event:Event):Void
{
	trace("Done.")
}
		```
		

Events:

Opens the file in the application registered by the operating system to open this file type.

Creates a new File object with a path relative to this File object's path, based on the path parameter (a string).

You can use a relative path or absolute path as the path parameter.

If you specify a relative path, the given path is "appended" to the path of the File object. However, use of ".." in the path can return a resulting path that is not a child of the File object. The resulting reference need not refer to an actual file system location.

If you specify an absolute file reference, the method returns the File object pointing to that path. The absolute file reference should use valid native path syntax for the user's operating system (such as "C:\test" on Windows). Do not use a URL (such as "file:///c:/test") as the path parameter.

All resulting paths are normalized as follows:

Any "." element is ignored.
Any ".." element consumes its parent entry.
No ".." reference that reaches the file system root or the application-persistent storage root passes
that node; it is ignored.

You should always use the forward slash (/) character as the path separator. On Windows, you can also use the backslash () character, but you should not. Using the backslash character can lead to applications that do not work on other platforms.

Filenames and directory names are case-sensitive on Linux.

Parameters:

Returns: