c# pdf diff : Excel pdf bookmarks control SDK platform web page winforms html web browser air_htmldevguide17-part461

165
HTML DEVELOPER’S GUIDE FOR ADOBE AIR
Working with the file system
Last updated 9/28/2011
var file = air.File.documentsDirectory;  
file = file.resolvePath("AIR Test/testFile.txt");
This example uses the 
File.documentsDirectory
property and the 
resolvePath()
method of a File object to 
initialize the File object. However, there are many other ways to point a File object to a file. For more information, see 
Pointing a File object to a file” on page  151.
Initialize a FileStream object. 
Call the open() method or the openAsync() method of the FileStream object.
The method you call depends on whether you want to open the file for synchronous or asynchronous operations. Use 
the File object as the 
file
parameter of the open method. For the 
fileMode
parameter, specify a constant from the 
FileMode class that specifies the way in which you will use the file. 
For example, the following code initializes a FileStream object that is used to create a file and overwrite any existing data:
var fileStream = new air.FileStream();  
fileStream.open(file, air.FileMode.WRITE); 
For more information, see “Initializing a FileStream object, and opening and closing files” on page  166   and 
FileStream open modes” on page  166.
If you opened the file asynchronously (using the openAsync() method), add and set up event listeners for the 
FileStream object. 
These event listener methods respond to events dispatched by the FileStream object in various situations. These 
situations include when data is read in from the file, when I/O errors are encountered, or when the complete amount 
of data to be written has been written. 
For details, see “Asynchronous programming and the events generated by a FileStream object opened asynchronously 
on page  170.
Include code for reading and writing data, as needed. 
There are many methods of the FileStream class related to reading and writing. (They each begin with "read" or 
"write".) The method you choose to use to read or write data depends on the format of the data in the target file.
For example, if the data in the target file is UTF-encoded text, you may use the 
readUTFBytes()
and 
writeUTFBytes()
methods. If you want to deal with the data as byte arrays, you may use the 
readByte()
readBytes()
writeByte()
, and 
writeBytes()
methods. For details, see “Data formats, and choosing the read and 
write methods to use” on page 171.
If you opened the file asynchronously, then be sure that enough data is available before calling a read method. For 
details, see “The read buffer and the bytesAvailable property of a FileStream object on page  169.
Before writing to a file, if you want to check the amount of disk space available, you can check the spaceAvailable 
property of the File object. For more information, see “Determining space available on a volume” on page  156.
Call the close() method of the FileStream object when you are done working with the file. 
Calling the close() method makes the file available to other applications. 
For details, see “Initializing a FileStream object, and opening and closing files” on page  166. 
To see a sample application that uses the FileStream class to read and write files, see the following articles at the Adobe 
AIR Developer Center:
• Building a text-file editor
Excel pdf bookmarks - add, remove, update PDF bookmarks in C#.net, ASP.NET, MVC, Ajax, WinForms, WPF
Empower Your C# Project with Rapid PDF Internal Navigation Via Bookmark and Outline
creating bookmarks in pdf documents; create bookmarks pdf files
Excel pdf bookmarks - VB.NET PDF bookmark library: add, remove, update PDF bookmarks in vb.net, ASP.NET, MVC, Ajax, WinForms, WPF
Empower Your VB.NET Project with Rapid PDF Internal Navigation Via Bookmark and Outline
bookmarks pdf files; adding bookmarks to a pdf
166
HTML DEVELOPER’S GUIDE FOR ADOBE AIR
Working with the file system
Last updated 9/28/2011
• Building a text-file editor
• Building a text-file editor
• Reading and writing from an XML preferences file
• Reading and writing from an XML preferences file
Working with FileStream objects
Adobe AIR 1.0 and later
The FileStream class defines methods for opening, reading, and writing files.
FileStream open modes 
Adobe AIR 1.0 and later
The 
open()
and 
openAsync()
methods of a FileStream object each include a 
fileMode
parameter, which defines 
some properties for a file stream, including the following: 
• The ability to read from the file 
• The ability to write to the file 
• Whether data will always be appended past the end of the file (when writing) 
• What to do when the file does not exist (and when its parent directories do not exist) 
The following are the various file modes (which you can specify as the 
fileMode
parameter of the 
open()
and 
openAsync()
methods):
Initializing a FileStream object, and opening and closing files 
Adobe AIR 1.0 and later
When you open a FileStream object, you make it available to read and write data to a file. You open a FileStream object 
by passing a File object to the 
open()
or 
openAsync()
method of the FileStream object: 
var myFile = air.File.documentsDirectory;  
myFile = myFile.resolvePath("AIR Test/test.txt");  
var myFileStream = new air.FileStream();  
myFileStream.open(myFile, air.FileMode.READ);
The 
fileMode
parameter (the second parameter of the 
open()
and 
openAsync()
methods), specifies the mode in 
which to open the file: for read, write, append, or update. For details, see the previous section, “FileStream open 
modes” on page 166. 
File mode
Description
FileMode.READ
Specifies that the file is open for reading only.
FileMode.WRITE
Specifies that the file is open for writing. If the file does not exist, it is created when the FileStream object 
is opened. If the file does exist, any existing data is deleted. 
FileMode.APPEND
Specifies that the file is open for appending. The file is created if it does not exist. If the file exists, existing 
data is not overwritten, and all writing begins at the end of the file.
FileMode.UPDATE
Specifies that the file is open for reading and writing. If the file does not exist, it is created. Specify this 
mode for random read/write access to the file. You can read from any position in the file. When writing 
to the file, only the bytes written overwrite existing bytes (all other bytes remain unchanged).
VB.NET PDF File Compress Library: Compress reduce PDF size in vb.
document file. Remove bookmarks, annotations, watermark, page labels and article threads from PDF while compressing. Also a preview
pdf bookmark editor; export bookmarks from pdf to excel
C# PDF File Split Library: Split, seperate PDF into multiple files
Split PDF file by top level bookmarks. The following C# codes explain how to split a PDF file into multiple ones by PDF bookmarks or outlines.
how to add bookmarks on pdf; edit pdf bookmarks
167
HTML DEVELOPER’S GUIDE FOR ADOBE AIR
Working with the file system
Last updated 9/28/2011
If you use the 
openAsync()
method to open the file for asynchronous file operations, set up event listeners to handle 
the asynchronous events: 
var myFile = air.File.documentsDirectory.resolvePath("AIR Test/test.txt");  
var myFileStream = new air.FileStream();  
myFileStream.addEventListener(air.Event.COMPLETE, completeHandler);  
myFileStream.addEventListener(air.ProgressEvent.PROGRESS, progressHandler);  
myFileStream.addEventListener(air.IOErrorEvent.IOError, errorHandler);  
myFileStream.open(myFile, air.FileMode.READ);  
function completeHandler(event) {  
// ...  
}  
function progressHandler(event) {  
// ...  
}  
function errorHandler(event) {  
// ...  
}
The file is opened for synchronous or asynchronous operations, depending upon whether you use the 
open()
or 
openAsync()
method. For details, see “AIR file basics” on page  145. 
If you set the 
fileMode
parameter to 
FileMode.READ
or 
FileMode.UPDATE
in the open method of the FileStream 
object, data is read into the read buffer as soon as you open the FileStream object. For details, see “The read buffer and 
the bytesAvailable property of a FileStream object” on page 169. 
You can call the 
close()
method of a FileStream object to close the associated file, making it available for use by other 
applications. 
The position property of a FileStream object 
Adobe AIR 1.0 and later
The 
position
property of a FileStream object determines where data is read or written on the next read or write 
method. 
Before a read or write operation, set the 
position
property to any valid position in the file. 
For example, the following code writes the string 
"hello"
(in UTF encoding) at position 8 in the file: 
var myFile = air.File.documentsDirectory;  
myFile = myFile.resolvePath("AIR Test/test.txt");  
var myFileStream = new air.FileStream();  
myFileStream.open(myFile, air.FileMode.UPDATE);  
myFileStream.position = 8;  
myFileStream.writeUTFBytes("hello"); 
When you first open a FileStream object, the 
position
property is set to 0. 
Before a read operation, the value of 
position
must be at least 0 and less than the number of bytes in the file (which 
are existing positions in the file). 
The value of the 
position
property is modified only in the following conditions: 
• When you explicitly set the 
position
property. 
• When you call a read method. 
VB.NET PDF File Split Library: Split, seperate PDF into multiple
Demo Code in VB.NET. The following VB.NET codes explain how to split a PDF file into multiple ones by PDF bookmarks or outlines.
export excel to pdf with bookmarks; pdf reader with bookmarks
C# PDF File Compress Library: Compress reduce PDF size in C#.net
NET framework. Remove bookmarks, annotations, watermark, page labels and article threads from PDF while compressing. C# class demo
delete bookmarks pdf; create bookmarks pdf file
168
HTML DEVELOPER’S GUIDE FOR ADOBE AIR
Working with the file system
Last updated 9/28/2011
• When you call a write method. 
When you call a read or write method of a FileStream object, the 
position
property is immediately incremented by 
the number of bytes that you read or write. Depending on the read method you use, the 
position
property is either 
incremented by the number of bytes you specify to read or by the number of bytes available. When you call a read or 
write method subsequently, it reads or writes starting at the new position. 
var myFile = air.File.documentsDirectory;  
myFile = myFile.resolvePath("AIR Test/test.txt");  
var myFileStream = new air.FileStream();  
myFileStream.open(myFile, air.FileMode.UPDATE);  
myFileStream.position = 4000;  
alert(myFileStream.position);  // 4000  
myFileStream.writeBytes(myByteArray, 0, 200);  
alert(myFileStream.position); // 4200 
There is, however, one exception: for a FileStream opened in append mode, the 
position
property is not changed after 
a call to a write method. (In append mode, data is always written to the end of the file, independent of the value of the 
position
property.) 
For a file opened for asynchronous operations, the write operation does not complete before the next line of code is 
executed. However, you can call multiple asynchronous methods sequentially, and the runtime executes them in order: 
var myFile = air.File.documentsDirectory;  
myFile = myFile.resolvePath("AIR Test/test.txt");  
var myFileStream = new air.FileStream();  
myFileStream.openAsync(myFile, air.FileMode.WRITE);  
myFileStream.writeUTFBytes("hello");  
myFileStream.writeUTFBytes("world");  
myFileStream.addEventListener(air.Event.CLOSE, closeHandler);  
myFileStream.close();  
air.trace("started.");  
closeHandler(event)  
{  
air.trace("finished.");  
}
The trace output for this code is the following: 
started.  
finished.
You can specify the 
position
value immediately after you call a read or write method (or at any time), and the next 
read or write operation will take place starting at that position. For example, note that the following code sets the 
position
property right after a call to the 
writeBytes()
operation, and the 
position
is set to that value (300) even 
after the write operation completes: 
var myFile = air.File.documentsDirectory.resolvePath("AIR Test/test.txt");  
var myFileStream = new air.FileStream();  
myFileStream.openAsync(myFile, air.FileMode.UPDATE);  
myFileStream.position = 4000;  
air.trace(myFileStream.position); // 4000  
myFileStream.writeBytes(myByteArray, 0, 200);  
myFileStream.position = 300;  
air.trace(myFileStream.position); // 300
XDoc.Excel for .NET, Comprehensive .NET Excel Imaging Features
zooming & rotation; Outlines, bookmarks, & thumbnail display; Integrated annotation; More about Web Viewer ▶. Excel Convert. Convert Excel to PDF; Convert Excel
copy pdf bookmarks to another pdf; copy bookmarks from one pdf to another
.NET PDF SDK - Description of All PDF Processing Control Feastures
bookmarks, & thumbnail display; Integrated annotation; More about Web Viewer ▶. Conversion. PDF Create. Create PDF from Word (docx, doc); Create PDF from Excel
how to add bookmarks to a pdf; how to create bookmarks in pdf file
169
HTML DEVELOPER’S GUIDE FOR ADOBE AIR
Working with the file system
Last updated 9/28/2011
The read buffer and the bytesAvailable property of a FileStream object 
Adobe AIR 1.0 and later
When a FileStream object with read capabilities (one in which the 
fileMode
parameter of the 
open()
or 
openAsync()
method was set to 
READ
or 
UPDATE
) is opened, the runtime stores the data in an internal buffer. The FileStream object 
begins reading data into the buffer as soon as you open the file (by calling the 
open()
or 
openAsync()
method of the 
FileStream object). 
For a file opened for synchronous operations (using the 
open()
method), you can always set the 
position
pointer to 
any valid position (within the bounds of the file) and begin reading any amount of data (within the bounds of the file), 
as shown in the following code (which assumes that the file contains at least 100 bytes): 
var myFile = air.File.documentsDirectory.resolvePath("AIR Test/test.txt");  
var myFileStream = new air.FileStream();  
myFileStream.open(myFile, air.FileMode.READ);  
myFileStream.position = 10;  
myFileStream.readBytes(myByteArray, 0, 20);  
myFileStream.position = 89;  
myFileStream.readBytes(myByteArray, 0, 10);  
Whether a file is opened for synchronous or asynchronous operations, the read methods always read from the 
"available" bytes, represented by the 
bytesAvalable
property. When reading synchronously, all of the bytes of the file 
are available all of the time. When reading asynchronously, the bytes become available starting at the position specified 
by the 
position
property, in a series of asynchronous buffer fills signaled by 
progress
events.
For files opened for synchronous operations, the 
bytesAvailable
property is always set to represent the number of 
bytes from the 
position
property to the end of the file (all bytes in the file are always available for reading). 
For files opened for asynchronous operations, you need to ensure that the read buffer has consumed enough data 
before calling a read method. For a file opened asynchronously, as the read operation progresses, the data from the file, 
starting at the 
position
specified when the read operation started, is added to the buffer, and the 
bytesAvailable
property increments with each byte read. The 
bytesAvailable
property indicates the number of bytes available 
starting with the byte at the position specified by the 
position
property to the end of the buffer. Periodically, the 
FileStream object sends a 
progress
event. 
For a file opened asynchronously, as data becomes available in the read buffer, the FileStream object periodically 
dispatches the 
progress
event. For example, the following code reads data into a ByteArray object, 
bytes
, as it is read 
into the buffer: 
var bytes = new air.ByteArray();  
var myFile = new air.File.documentsDirectory.resolvePath("AIR Test/test.txt");  
var myFileStream = new air.FileStream();  
myFileStream.addEventListener(air.ProgressEvent.PROGRESS, progressHandler);  
myFileStream.openAsync(myFile, air.FileMode.READ);  
function progressHandler(event)   
{  
myFileStream.readBytes(bytes, myFileStream.position, myFileStream.bytesAvailable);  
}
For a file opened asynchronously, only the data in the read buffer can be read. Furthermore, as you read the data, it is 
removed from the read buffer. For read operations, you need to ensure that the data exists in the read buffer before 
calling the read operation. For example, the following code reads 8000 bytes of data starting from position 4000 in the 
file: 
XDoc.Word for .NET, Advanced .NET Word Processing Features
& rotation; Outlines, bookmarks, & thumbnail display; Integrated annotation; More about Web Viewer ▶. Conversion. Word Create. Create Word from PDF; Create Word
create pdf with bookmarks from word; export pdf bookmarks to text
XDoc.PowerPoint for .NET, All Mature Features Introductions
& rotation; Outlines, bookmarks, & thumbnail display; Integrated annotation; More about Web Viewer ▶. PowerPoint Convert. Convert PowerPoint to PDF; Convert
add bookmarks pdf; bookmark pdf documents
170
HTML DEVELOPER’S GUIDE FOR ADOBE AIR
Working with the file system
Last updated 9/28/2011
var myFile = air.File.documentsDirectory.resolvePath("AIR Test/test.txt");  
var myFileStream = new air.FileStream();  
myFileStream.addEventListener(air.ProgressEvent.PROGRESS, progressHandler);  
myFileStream.addEventListener(air.Event.COMPLETE, completed);  
myFileStream.openAsync(myFile, air.FileMode.READ);  
myFileStream.position = 4000;  
var str = "";  
function progressHandler(event)   
{  
if (myFileStream.bytesAvailable > 8000 )  
 
str += myFileStream.readMultiByte(8000, "iso-8859-1");  
 
}
During a write operation, the FileStream object does not read data into the read buffer. When a write operation 
completes (all data in the write buffer is written to the file), the FileStream object starts a new read buffer (assuming 
that the associated FileStream object was opened with read capabilities), and starts reading data into the read buffer, 
starting from the position specified by the 
position
property. The 
position
property may be the position of the last 
byte written, or it may be a different position, if the user specifies a different value for the 
position
object after the 
write operation. 
Asynchronous programming and the events generated by a FileStream object opened asynchronously 
Adobe AIR 1.0 and later
When a file is opened asynchronously (using the 
openAsync()
method), reading and writing files are done 
asynchronously. As data is read into the read buffer and as output data is being written, other ActionScript code can 
execute. 
This means that you need to register for events generated by the FileStream object opened asynchronously. 
By registering for the 
progress
event, you can be notified as new data becomes available for reading, as in the 
following code: 
var myFile = air.File.documentsDirectory.resolvePath("AIR Test/test.txt");  
var myFileStream = new air.FileStream();  
myFileStream.addEventListener(air.ProgressEvent.PROGRESS, progressHandler);  
myFileStream.openAsync(myFile, air.FileMode.READ);  
var str = "";  
function progressHandler(event)   
{  
str += myFileStream.readMultiByte(myFileStream.bytesAvailable, "iso-8859-1");  
}
You can read the entire data by registering for the 
complete
event, as in the following code: 
171
HTML DEVELOPER’S GUIDE FOR ADOBE AIR
Working with the file system
Last updated 9/28/2011
var myFile = air.File.documentsDirectory.resolvePath("AIR Test/test.txt");  
var myFileStream = new air.FileStream();  
myFileStream.addEventListener(air.Event.COMPLETE, completed);  
myFileStream.openAsync(myFile, air.FileMode.READ);  
var str = "";  
function completeHandler(event)  
{  
str = myFileStream.readMultiByte(myFileStream.bytesAvailable, "iso-8859-1");  
}
In much the same way that input data is buffered to enable asynchronous reading, data that you write on an 
asynchronous stream is buffered and written to the file asynchronously. As data is written to a file, the FileStream 
object periodically dispatches an 
OutputProgressEvent
object. An 
OutputProgressEvent
object includes a 
bytesPending
property that is set to the number of bytes remaining to be written. You can register for the 
outputProgress
event to be notified as this buffer is actually written to the file, perhaps in order to display a progress 
dialog. However, in general, it is not necessary to do so. In particular, you may call the 
close()
method without 
concern for the unwritten bytes. The FileStream object will continue writing data and the 
close
event will be delivered 
after the final byte is written to the file and the underlying file is closed.
Data formats, and choosing the read and write methods to use
Adobe AIR 1.0 and later
Every file is a set of bytes on a disk. In ActionScript, the data from a file can always be represented as a ByteArray. For 
example, the following code reads the data from a file into a ByteArray object named 
bytes
var myFile = air.File.documentsDirectory.resolvePath("AIR Test/test.txt");  
var myFileStream = new air.FileStream();  
myFileStream.addEventListener(air.Event.COMPLETE, completeHandler);  
myFileStream.openAsync(myFile, air.FileMode.READ);  
var bytes = new air.ByteArray();  
function completeHandler(event)  
{  
myFileStream.readBytes(bytes, 0, myFileStream.bytesAvailable);  
}
Similarly, the following code writes data from a ByteArray named 
bytes
to a file: 
var myFile = air.File.documentsDirectory.resolvePath("AIR Test/test.txt");  
var myFileStream = new air.FileStream();  
myFileStream.open(myFile, air.FileMode.WRITE);  
myFileStream.writeBytes(bytes, 0, bytes.length);
However, often you do not want to store the data in an ActionScript ByteArray object. And often the data file is in a 
specified file format. 
For example, the data in the file may be in a text file format, and you may want to represent such data in a String object. 
For this reason, the FileStream class includes read and write methods for reading and writing data to and from types 
other than ByteArray objects. For example, the 
readMultiByte()
method lets you read data from a file and store it to 
a string, as in the following code: 
172
HTML DEVELOPER’S GUIDE FOR ADOBE AIR
Working with the file system
Last updated 9/28/2011
var myFile = air.File.documentsDirectory.resolvePath("AIR Test/test.txt");  
var myFileStream = new air.FileStream();  
myFileStream.addEventListener(air.Event.COMPLETE, completed);  
myFileStream.openAsync(myFile, air.FileMode.READ);  
var str = "";  
function completeHandler(event)   
{  
str = myFileStream.readMultiByte(myFileStream.bytesAvailable, "iso-8859-1");  
}
The second parameter of the 
readMultiByte()
method specifies the text format that ActionScript uses to interpret 
the data ("iso-8859-1" in the example). Adobe AIR supports common character set encodings (see Supported character 
sets). 
The FileStream class also includes the 
readUTFBytes()
method, which reads data from the read buffer into a string 
using the UTF-8 character set. Since characters in the UTF-8 character set are of variable length, do not use 
readUTFBytes()
in a method that responds to the 
progress
event, since the data at the end of the read buffer may 
represent an incomplete character. (This is also true when using the 
readMultiByte()
method with a variable-length 
character encoding.) For this reason, read the entire set of data when the FileStream object dispatches the 
complete
event. 
There are also similar write methods, 
writeMultiByte()
and 
writeUTFBytes()
, for working with String objects and 
text files. 
The 
readUTF()
and the 
writeUTF()
methods (not to be confused with 
readUTFBytes()
and 
writeUTFBytes()
also read and write the text data to a file, but they assume that the text data is preceded by data specifying the length of 
the text data, which is not a common practice in standard text files. 
Some UTF-encoded text files begin with a "UTF-BOM" (byte order mark) character that defines the endianness as well 
as the encoding format (such as UTF-16 or UTF-32). 
For an example of reading and writing to a text file, see “Example: Reading an XML file into an XML object” on 
page  173. 
The 
readObject()
and 
writeObject()
are convenient ways to store and retrieve data for complex ActionScript 
objects. The data is encoded in AMF (ActionScript Message Format). Adobe AIR, Flash Player, Flash Media Server, 
and Flex Data Services include APIs for working with data in this format. 
There are some other read and write methods (such as 
readDouble()
and 
writeDouble()
). However, if you use 
these, make sure that the file format matches the formats of the data defined by these methods. 
File formats are often more complex than simple text formats. For example, an MP3 file includes compressed data that 
can only be interpreted with the decompression and decoding algorithms specific to MP3 files. MP3 files also may 
include ID3 tags that contain meta tag information about the file (such as the title and artist for a song). There are 
multiple versions of the ID3 format, but the simplest (ID3 version 1) is discussed in the “Example: Reading and writing 
data with random access” on page 175 section. 
Other files formats (for images, databases, application documents, and so on) have different structures, and to work 
with their data in ActionScript, you must understand how the data is structured. 
173
HTML DEVELOPER’S GUIDE FOR ADOBE AIR
Working with the file system
Last updated 9/28/2011
Using the load() and save() methods
Flash Player 10 and later, Adobe AIR 1.5 and later
Flash Player 10 added the 
load()
and 
save()
methods to the FileReference class. These methods are also in AIR 1.5, 
and the File class inherits the methods from the FileReference class. These methods were designed to provide a secure 
means for users to load and save file data in Flash Player. However, AIR applications can also use these methods as an 
easy way to load and save files asynchronously.
For example, the following code saves a string to a text file:
var file = air.File.applicationStorageDirectory.resolvePath("test.txt");  
var str = "Hello.";  
file.addEventListener(air.Event.COMPLETE, fileSaved);  
file.save(str);  
function fileSaved(event)  
{  
air.trace("Done.");  
}
The 
data
parameter of the 
save()
method can take a String or ByteArray value. When the argument is a String value, 
the method saves the file as a UTF-8–encoded text file.
When this code sample executes, the application displays a dialog box in which the user selects the saved file 
destination.
The following code loads a string from a UTF-8–encoded text file:
var file = air.File.applicationStorageDirectory.resolvePath("test.txt");  
file.addEventListener(air.Event.COMPLETE, loaded);  
file.load();  
var str;  
function loaded(event)  
{  
var bytes = file.data;  
str = bytes.readUTFBytes(bytes.length);  
air.trace(str);  
}
The FileStream class provides more functionality than that provided by the 
load()
and 
save()
methods: 
• Using the FileStream class, you can read and write data both synchronously and asynchronously. 
• Using the FileStream class lets you write incrementally to a file.
• Using the FileStream class lets you open a file for random access (both reading from and writing to any section of 
the file).
• The FileStream class lets you specify the type of file access you have to the file, by setting the 
fileMode
parameter 
of the 
open()
or 
openAsync()
method. 
• The FileStream class lets you save data to files without presenting the user with an Open or Save dialog box.
• You can directly use types other than byte arrays when reading data with the FileStream class.
Example: Reading an XML file into an XML object
Adobe AIR 1.0 and later
The following examples demonstrate how to read and write to a text file that contains XML data. 
174
HTML DEVELOPER’S GUIDE FOR ADOBE AIR
Working with the file system
Last updated 9/28/2011
To read from the file, initialize the File and FileStream objects, call the 
readUTFBytes()
method of the FileStream and 
convert the string to an XML object: 
var file = air.File.documentsDirectory.resolvePath("AIR Test/preferences.xml");  
var fileStream = new air.FileStream();  
fileStream.open(file, air.FileMode.READ);  
var prefsXML = fileStream.readUTFBytes(fileStream.bytesAvailable);  
fileStream.close();
Similarly, writing the data to the file is as easy as setting up appropriate File and FileStream objects, and then calling a 
write method of the FileStream object. Pass the string version of the XML data to the write method as in the following 
code: 
var file = air.File.documentsDirectory.resolvePath("AIR Test/preferences.xml");  
fileStream = new air.FileStream();  
fileStream.open(file, air.FileMode.WRITE);  
var outputString = '<?xml version="1.0" encoding="utf-8"?>\n';  
outputString += '<prefs><autoSave>true</autoSave></prefs>'  
fileStream.writeUTFBytes(outputString);  
fileStream.close();
These examples use the 
readUTFBytes()
and 
writeUTFBytes()
methods, because they assume that the files are in 
UTF-8 format. If not, you may need to use a different method (see “Data formats, and choosing the read and write 
methods to use” on page 171). 
The previous examples use FileStream objects opened for synchronous operation. You can also open files for 
asynchronous operations (which rely on event listener functions to respond to events). For example, the following 
code shows how to read an XML file asynchronously: 
var file = air.File.documentsDirectory.resolvePath("AIR Test/preferences.xml");  
var fileStream= new air.FileStream();  
fileStream.addEventListener(air.Event.COMPLETE, processXMLData);  
fileStream.openAsync(file, air.FileMode.READ);  
var prefsXML;  
function processXMLData(event)   
{  
var xmlString = fileStream.readUTFBytes(fileStream.bytesAvailable);  
prefsXML = domParser.parseFromString(xmlString, "text/xml");  
fileStream.close();  
}
The 
processXMLData()
method is invoked when the entire file is read into the read buffer (when the FileStream 
object dispatches the 
complete
event). It calls the 
readUTFBytes()
method to get a string version of the read data, 
and it creates an XML object, 
prefsXML
, based on that string. 
To see a sample application that shows these capabilities, see Reading and writing from an XML preferences file.
To see a sample application that shows these capabilities, see Reading and writing from an XML Preferences File.
Documents you may be interested
Documents you may be interested