Code Cook

Handling Different File Types in Apollo

Monday, June 4th, 2007

So, I've finally snagged some time to whip out a post about dealing with different file types with the File API in Apollo AIR.

The contents of a file can be read into a ByteArray and manipulated there. For example if we had a simple text file we could read in its contents to a ByteArray with the following code:

You should see something that looks like the following image when you run this code:

If we wanted to out put some of the data in the ByteArray we could add the following:

This would jsut output the first 9 items int he ByteArray. So, you'd see something like the following:

I asked myself, well what good is that? We'll lets say the file you were reading was a PNG. You could figure out how to write that file data out to the PNG file format, or you could check out the AS3 libraries that has a PNG and JPEG encoder already.With that said you now have control...hold that, TOTAL control of the file as you read/write the bytes to/from a file.

In my previous posts (Reading a File & Reading a file Asynchronously), the file contents were read into a String variable. This was accomplished with the FileStream readMultiByte() method.

The readMultiByte(length:uint, charSet:String) method takes two (2) parameters:

1. length: uint - The number of bytes to read from the stream
2. charSet: String - The String specifying the character set to use to interpret the bytes read from the stream. I'm looking for a nice list of supported character sets, but have yet to find them. I'll let you know when I do. For now we can use the livedoc examples of "shift-jis", "cn-gb" & "iso-8859-1".

We've checked out reading image data and text data, you could extend either of these to accommodate most situations. I'll keep playing and if I run into anything I'll be sure to add to this series.

Posted in air, flash, flex |

Reading a file Asynchronously with ActionScript 3

Thursday, May 31st, 2007

Sometimes (okay, manytimes) files are large enough that the process of opening and reading its contents may take some time. To solve issues related to the extra time this may take AS3 allows you to open files asynchronously. I'd like to add to the information from the reading files with AS3 post. Here we'll cover the code necessary to open a file asynchronously and read the file contents as they become available.

Because we are now doing something asynchronously, we will be dealing with events. As the file contents are being read The FileStream object broadcasts progress events that we can listen for and respond to. This ensures that when we are reading data when the data is available.

So, onto the code:

As for what all that code does - first off, import the required classes:

Then we'll need to create a couple variables. First, the FileStream which we'll use to read our file and second, a String variable that we'll use to display the file contents.

Now we'll create an onCreationComplete() method. This method will handle the creationComplete event of the application to get things rolling. Inside the onCreationComplete() method we'll need to create out File object as well as the FileStream object.

Still in the onCreationComplete() method, we'll need to handle those events that will be dispatched while reading the file asynchronously. The events that we will handle are:

• ProgressEvent.PROGRESS - This will fire as the bytes are read from the file into the buffer.
• Event.COMPLETE - This will fire when all the bytes of the file have been read into the buffer.

The final part of the onCreationComplete() method is to open the file asynchronously. Add the following line to the end of the method:

Now to handle those events and read our file. First, we'll deal with the PROGRESS event. Inside the onFileProgress() event handler method, we read the availableBytes from the file and add it to our String variable. Notice the second parameter of the readMultiByte() method - "iso-859-1". This specifies the content type of the file that we are reading. I'll cover some of the other content types in a later post. So, keep an eye out for that one if you're curious. Finally, we update the TextArea, to show we are actually reading the file.

We still need to clean up after ourselves, so in the onFileComplete() method, we'll need to close out FileStream object.

A very simple example, and it is still only text that we are reading. Next time I'd like to cover how to read different file types. So, like I said, keep an eye our for that post.

Posted in air |

Reading a file with ActionScript 3

Saturday, May 26th, 2007

The ALPHA release of Apollo, Adobe's cross-operating system runtime allows for some pretty sweet functionality:

• Drag-and-drop support
• Rich clipboard access
• Desktop and system
  shortcuts

What I was excited about was the File API. The ability to access, read and write to files is something that is completely necessary in a desktop applications, not to mention, exciting to just play with in ActionScript. Its also something that allows for those Web applications that will be ported to desktop applications, to break out of the constraints of the Web (browser security etc.).

I'd like to give a simple example of the File API and get you started on the how's. Its not that difficult, so lets get started. I'll show you the code...then explain.

Simple File Read Example:

First, we'll need to import the following classes:

Next, we'll need to create our File object so we can let our application know where the file we want to read exists. We'll use the file.appResourceDeirectory to locate the file in relation to our application, then the resolve method of the File object myFile to locate the actual file.

Now we'll need to actually open the file using the FileStream object. So, we create a new FileStream object, then call the open() method and pass it the File object as well as the FileMode of READ.

We have our file open, so lets go ahead and read the contents of the file. The file is a text file, so we'll simple read the file contents into a String variable using the readUTFBytes() method of out FileStream object. Depending on the type of file and the contents of that file, you will want to use a different read method. Like I said, we'll keep it simple for now. The readUTFBytes() method requires the number of bytes to read. We'll pass the bytesAvailable property of the FileStream object for this parameter. The bytesAvailable prooperty, in this case, is the total bytes for the file. Finally set the value returned from the readUTFBytes() call equal to our String variable.

Alright! Now we have our String variable that contains the contents of our text file. From this point you can do anything you want with it. In this example, I've just set the text property of a TextArea to the value of our String variable

There is one final thing to do, and that is clean up. Make sure you call the close() method of the FileStream object once you are done reading the file.

So that is all you need to get started with the File API. There are a few more things that I'd like to go into detail about, so I'll make sure to post about reading file types other than plain text. I'd also like to create an example of opening a file asynchronously, so look for posts on these subjects soon.

Posted in air |