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.

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

The application's private storage directory.

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

When you uninstall an AIR application, whether the uninstaller deletes the application storage directory and its files depends on the platform.

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 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.

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

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.

AIR for TV devices have no concept of a user's desktop directory. Therefore, the desktopDirectory property references the same directory location as File.userDirectory property. The user directory is unique to the application.

var desktop = air.File.desktopDirectory;

var files = desktop.getDirectoryListing()

for (i = 0; i < files.length; i++) {
    air.trace(files[i].nativePath)
}

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.

AIR for TV devices have no concept of a user's documents directory. Therefore, the documentsDirectory property references the same directory location as the File.userDirectory property. The user directory is unique to the application.

var directory = air.File.documentsDirectory;
directory = directory.resolvePath("AIR Test");

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

Indicates whether the referenced file or directory was downloaded (from the internet) or not.

This property is only meaningful on operating systems in which files can be flagged as downloaded:

• Windows XP service pack 2 and later, and on Windows Vista
• Mac OS 10.5 and later

On systems that do not flag downloaded files, such as Linux, the property is not meaningful (and it is set to false).

See also

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.

var temp = air.File.createTempFile();
air.trace(temp.exists) // true
temp.deleteFile();
air.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.

var directory = air.File.documentsDirectory;
var bitmaps = file.icon.bitmaps;
var bmpData = new BitmapData(1, 1);
for (i = 0; i < bitmaps.length; i++) {
    if (bitmaps[i].height > bmpData.height) {
        bmpData = file.icon.bitmaps[i];
    }
}
var iconBmp = new Bitmap(bmpData);

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

var userDirFiles = air.File.userDirectory.getDirectoryListing();
for (i = 0; i < userDirFiles.length; i++) {
    if (userDirFiles[i].isDirectory) {
        air.trace(userDirFiles[i].nativePath);
    }
}    

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

var userDirFiles = air.File.userDirectory.getDirectoryListing();
for (i = 0; i < userDirFiles.length; i++) {
    if (userDirFiles[i].isHidden) {
        air.trace(userDirFiles[i].nativePath);
    }
}    

Indicates whether the referenced directory is a package.

The value is true if the referenced directory is a package, false otherwise. Note that the File class does not allow creating packages directly.

• On Mac OS, directories can be designated as packages and will show up in the Finder as a single file rather than as a directory. This property is set to true if the referenced directory is a package, and false if the file is not a directory, does not exist, or is not a package.
• On other operating systems, this property is always set to false.

Indicates whether the reference is a symbolic link.

The value is true if the File object is a symbolic link, false otherwise. Note that the File class does not allow creating symbolic links directly.

Symbolic links allow a file to point to another file or directory on disk. Although similar, symbolic links are not the same as aliases on Mac OS and shortcuts on Windows. An alias or a shortcut is always reported as a file (rather than a directory), and reading or writing to an alias or shortcut never affects the original file or directory that it points to. On the other hand, a symbolic link generally behaves like the file or directory it points to. It can be reported as a file or a directory, and reading or writing to a symbolic link affects the file or directory that it points to, not the symbolic link itself. Deleting a symbolic link, however, deletes the link and not the target of the link.

Mac^® OS^®, Linux, and Windows^® Vista^® support symbolic links. Additionally, on Windows the isSymbolicLink property for a File object referencing a junction point (used in the NTFS file system) is set to true.

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).

var str = "Hello\n" + 
        "World\n";
str = str.replace(/\n/g, air.File.lineEnding);
var file = air.File.documentsDirectory.resolvePath("AIR Test/test.txt");
var fileStream = new air.FileStream();
fileStream.open(file, air.FileMode.WRITE);
fileStream.writeUTF(str);
fileStream.close();

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.

Some Flex APIs, such as the source property of the SWFLoader class, use a URL (the url property of a File object), not a native path (the nativePath property).

Some APIs, such as the src property of an IMG object, use a URL (the url property of a File object), not a native path (the nativePath property).

var docs = air.File.documentsDirectory;
air.trace(docs.nativePath); // C:\Documents and Settings\turing\My Documents
air.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.

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

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.

var directory = air.File.documentsDirectory.resolvePath("Apollo Test");
var file = air.File.documentsDirectory.resolvePath("Apollo Test/employees/bob/test.txt");

var relativePath = directory.getRelativePath(file); // employees/bob/test.txt
relativePath = relativePath.replace(/\//g, air.File.separator);
air.trace(relativePath); 

The space available for use at this File location, in bytes.

If the File object references a directory, spaceAvailable indicates the space in the directory that files can use. If the File object references a file, spaceAvailable indicates the space into which the file could grow. If the file location does not exist, spaceAvailable is set to 0. If the File object references a symbolic link, spaceAvailable indicates the space available at the location the symbolic link points to.

Typically the space available for a directory or file is the same as the space available on the volume containing the directory or file. However, space available can take into account quotas and per-directory limits.

Adding a file or directory to a volume generally requires more space than the actual size of the file or the size of the contents of the directory. For example, the operating system may require more space to store index information. Or the disk sectors required may use additional space. Also, available space changes dynamically. So, you cannot expect to allocate all of the reported space for file storage.

The default encoding used by the host operating system.

Possible values include "windows-1252" "shift-jis", "cn-gb", "iso-8859-1", and others. For a complete list, see Supported Character Sets.

You can use this value when using the readMultiByte() and writeMultiByte() methods of the FileStream class.

See also

var file = air.File.documentsDirectory.resolvePath("AIR Test/test.txt");
var fileStream = new air.FileStream();
fileStream.open(file, air.FileMode.READ);
var str = fileStream.readMultiByte(file.size, air.File.systemCharset);
air.trace(str);    

The URL for this file path.

If this is a reference to a path in the application storage directory, the URL scheme is "app-storage"; if it is a reference to a path in the application directory, the URL scheme is "app"; otherwise the scheme is "file".

You can use blank space characters (rather than "%20") when assigning a value to the url property; AIR automatically encodes the strings (for instance, converting spaces to "%20").

See also

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

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.

On AIR for TV devices, the userDirectory property references a user directory that is unique to the application.

var files = air.File.userDirectory.getDirectoryListing();
for (i = 0; i < files.length; i++) {
    air.trace(files[i].nativePath);
}

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 = air.File.applicationStorageDirectory.resolvePath("settings.xml");

Important: If you pass a URL string in the path parameter, the URL is decoded to resolve the file path. For example, the statement, new File("file:///c:/test/demo%20file%201%2e0.txt") creates a File object with the native path, "c:\test\demo file 1.0.txt". (A URL uses the file:, app:, or app-storage: scheme prefixes.) However, if the valid URL prefixes are omitted, the path string is treated like a native path and no decoding takes place. You must take this behavior into consideration when validating paths derived from potentially untrusted sources. If you simply validate the input string, URL decoding may allow an attacker to bypass your validation checks. Always validate the final path of the instantiated File object:

     var file = new air.File( taintedString );

     validate( file.nativePath ); //where validate() is your path validation function

     

See also

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.

Note: On Android devices, browseForDirectory() is not supported. The File object dispatches a cancel event immediately.

Parameters

See also

var directory = air.File.documentsDirectory;

try
{
    directory.browseForDirectory("Select Directory");
    directory.addEventListener(air.Event.SELECT, directorySelected);
}
catch (error)
{
    air.trace("Failed:", error.message)
}

function directorySelected(event) 
{
    directory = event.target ;
    var files = directory.getDirectoryListing();
    for(var i = 0; i < files.length; i++)
    {
        air.trace(files[i].name);
    }
}

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.

Note: On Android devices, the file dialog title cannot be set. The title parameter is ignored.

Parameters

See also

var fileToOpen = new air.File();
var txtFilter = new air.FileFilter("Text", "*.as;*.css;*.html;*.txt;*.xml");

try 
{
    fileToOpen.browseForOpen("Open", [txtFilter]);
    fileToOpen.addEventListener(air.Event.SELECT, fileSelected);
}
catch (error)
{
    air.trace("Failed:", error.message)
}

function fileSelected(event) 
{
    var stream = new air.FileStream();
    stream.open(event.target, air.FileMode.READ);
    var fileData = stream.readUTFBytes(stream.bytesAvailable);
    air.trace(fileData);
}

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.

Note: On Android devices, the file dialog title cannot be set. The title parameter is ignored.

Parameters

See also

var docsDir = air.File.documentsDirectory;
try
{
    docsDir.browseForOpenMultiple("Select Files");
    docsDir.addEventListener(air.FileListEvent.SELECT_MULTIPLE, filesSelected);
}
catch (error)
{
    air.trace("Failed:", error.message)
}

function filesSelected(event) 
{
    for (i = 0; i < event.files.length; i++) 
    {
        air.trace(event.files[i].nativePath);
    }
}

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.

Note: On Android devices, the file dialog title cannot be set. The title parameter is ignored.

Parameters

See also

var docsDir = air.File.documentsDirectory;
try
{
    docsDir.browseForSave("Save As");
    docsDir.addEventListener(air.Event.SELECT, saveData);
}
catch (error)
{
    air.trace("Failed:", error.message)
}

function saveData(event) 
{
    var newFile = event.target ;
    var str = "Hello.";
    if (!newFile.exists)
    {
        var stream = new air.FileStream();
        stream.open(newFile, air.FileMode.WRITE);
        stream.writeUTFBytes(str);
        stream.close();
    }
}

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).

In addition, canonicalization converts short filenames to long filenames on Windows.

var path = air.File.desktopDirectory.resolvePath("air test");
air.trace(path.nativePath); 
path.canonicalize();
air.trace(path.nativePath); // ...\AIR Test

var path = new air.File();
path.nativePath = "C:\\AIR~1";
path.canonicalize();
air.trace(path.nativePath); // C:\AIR 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 JavaScript 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).

Parameters

See also

var sourceFile = air.File.documentsDirectory;
sourceFile = sourceFile.resolvePath("AIR Test/test1.txt");
var destination = air.File.documentsDirectory;
destination = destination.resolvePath("AIR Test/test2.txt");

if (sourceFile.copyTo(destination, true)) {
    air.trace("Done.")
}

var sourceFile = air.File.documentsDirectory;
sourceFile = sourceFile.resolvePath("AIR Test/test1.txt");
var destination = air.File.documentsDirectory;
destination = destination.resolvePath("AIR Test/test2.txt");

try 
{
    if (sourceFile.copyTo(destination, true)) {
}
catch (error)
{
    air.trace("Error:" error.message)
}

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

See also

var sourceFile = air.File.documentsDirectory;
sourceFile = sourceFile.resolvePath("AIR Test/test1.txt");
var destination = air.File.documentsDirectory;
destination = destination.resolvePath("AIR Test/test2.txt");

var sourceFile.copyToAsync(destination, true);
sourceFile.addEventListener(air.Event.COMPLETE, fileCopiedHandler);

function fileCopiedHandler(event): void {
    air.trace("Done.")
}

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

var source = air.File.desktopDirectory.resolvePath("test.txt");
var target = air.File.documentsDirectory.resolvePath("AIR Test/test.txt");
var targetParent = target.parent;
targetParent.createDirectory();
source.moveTo(target, true);

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.

See also

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

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.

See also

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

Deletes the directory. If this File is actually a symbolic link to a directory, then the link, and not the directory, is removed.

Parameters

See also

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

Deletes the directory asynchronously. If this File is actually a symbolic link to a directory, then the link, and not the directory, is removed.

Parameters

See also

Deletes the file. If this File is actually a symbolic link, then the link, not the target file, is removed.

See also

var file = air.File.createTempFile();
air.trace(file.exists); // true
file.deleteFile();
air.trace(file.exists); // false

Deletes the file asynchronously. If this File is actually a symbolic link, then the link, not the target file, is removed.

See also

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.

See also

var directory = air.File.userDirectory;
var list = directory.getDirectoryListing();
for (i = 0; i < list.length; i++) {
    air.trace(list[i].nativePath);
}

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

See also

var directory = air.File.userDirectory;
directory.getDirectoryListingAsync();
directory.addEventListener(air.FileListEvent.DIRECTORY_LISTING, directoryListingHandler);

function directoryListingHandler(event) {
    var list = event.files;
    for (i = 0; i < list.length; i++) {
        air.trace(list[i].nativePath);
    }
}

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 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.

var rootDirs = air.File.getRootDirectories();

for (i = 0; i < rootDirs.length; i++) {
    air.trace(rootDirs[i].nativePath)
}

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

See also

var sourceFile = air.File.documentsDirectory;
sourceFile = sourceFile.resolvePath("AIR Test/test1.txt");
var destination = air.File.documentsDirectory;
destination = destination.resolvePath("AIR Test/test2.txt");

try  
{
    sourceFile.moveTo(destination, true);
}
catch (error)
{
    air.trace("Error:" error.message);
}

var sourceFile = air.File.documentsDirectory;
sourceFile = sourceFile.resolvePath("AIR Test/test1.txt");
var destination = air.File.documentsDirectory;
destination = destination.resolvePath("AIR Test/Results/test1.txt");

try 
{
    sourceFile.moveTo(destination, true);
}
catch (error)
{
    air.trace("Error:" error.message);
}

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).

Parameters

See also

var sourceFile = air.File.documentsDirectory;
sourceFile = sourceFile.resolvePath("Apollo Test/test1.txt");
var destination = air.File.documentsDirectory;
destination = destination.resolvePath("Apollo Test/test2.txt");

var sourceFile.moveToAsync(destination, true);
sourceFile.addEventListener(air.Event.COMPLETE, fileMoveCompleteHandler);

function fileMoveCompleteHandler(event): void 
{
    air.trace("Done.")
}

Moves a file or directory to the trash.

Note: On operating systems that do not support the concept of a recoverable trash folder, the files are removed immediately.

See also

Asynchronously moves a file or directory to the trash.

Note: On operating systems that do not support the concept of a recoverable trash folder, the files are removed immediately.

See also

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

AIR prevents you from using the File.openWithDefaultApplication() method to open certain files. On Windows, AIR prevents you from opening files that have certain file types (files with specific extensions, listed below). On Mac OS and Linux, AIR prevents you from opening files that will launch in specific applications, specified below. Attempting to open one of these files using the openWithDefaultApplication() method results in an exception. However, AIR applications installed with a native installer (extended desktop profile applications) are not restricted by these limitations; they can open files of any type.

You cannot open documents from the application directory.

The tables below list file extensions that are prohibited on Windows, as well as the prevented applications on Mac OS and Linux:

See also

var file = air.File.documentsDirectory; 
var mp3Filter = new air.FileFilter("MP3 Files", "*.mp3"); 
file.browseForOpen("Open", [mp3Filter]); 
file.addEventListener(air.Event.SELECT, fileSelected); 

function fileSelected(event) 
{ 
    file.openWithDefaultApplication(); 
}

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

Dispatched when a pending asynchronous operation is canceled.

This event has the following properties:

Dispatched when an asynchronous operation is complete.

This event has the following properties:

Dispatched when a directory list is available as a result of a call to the getDirectoryListingAsync() method.

This event has the following properties:

See also

Dispatched when an error occurs during an asynchronous file operation.

This event has the following properties:

Dispatched when an operation violates a security constraint.

This event has the following properties:

Dispatched when the user selects a file or directory from a file- or directory-browsing dialog box.

This event has the following properties:

Dispatched when the user selects files from the dialog box opened by a call to the browseForOpenMultiple() method.

See also