Socks, Dregs and Bacon Roll

Responding to write operations using the FileStream object

Recently I’ve been playing alot with Adobe AIR trying to get myself up to speed with all the major features, so when I come up with an idea for something I’ll usually try and write it in AIR.

Shortly after my son was born last November I began writing a slide show app in Flex to show the snaps of the little guy to close family (thats still not completely written but I’ve learned alot about using URLStreams!). Anyway I quickly realised that the super high-res images that my camara produces are going to fill my hosting space very quickly not to mention take ages for my parents to download. What I needed was to be able to quickly batch process images at the same downscale percentage and the same quality. Now Im sure this is quite possible to do using actions in Photoshop, but then Im not a designer so what better than to re-invent the wheel and write my own app using AIR, right?

So thats what I have done – well almost still crossing the T’s and dotting the I’s. I’ll release it here once I have it at a reasonable state of completeness.

Anyway, getting back to the point of the post: What I decided should happen is that once you have references to all the files that are to be processed it should follow the steps below for each image:

1. Stream in the image data.
2. Convert to a Bitmap.
3. Parse the BitmapData with JPEGEncoder.
4. Write the resulting ByteArray to a FileStream object.
5. When the write is complete go back to step 1 until all images are processed.

Pretty simple stuff. However since FileStream read operations dispatch Event.COMPLETE events when reading is finished I made the assumption that the write operations would do the same thing. This isnt the case, FileStream write operations do not dispatch COMPLETE events. So whats left for detecting the end of write operation? Well there are a couple of possibilities depending on whether you are writing syncronously or asynchronously (read the docs if you dont know what this is ). If you are writing synchronously then the whole of the data is written before any more code is executed so  you can simply close the FileStream in the lines following the write and listen to the close event e.g.:


public function write () : void
{
var myFile:File=File.documentsDirectory.resolvePath("test.txt");
var myFileStream:FileStream = new FileStream();
myFileStream.addEventListener(Event.CLOSE, closeHandler);
myFileStream.open(myFile, FileMode.WRITE);
myFileStream.writeUTFBytes("hello world");
myFileStream.close();
trace("started.");
}

public function closeHandler(event:Event):void 
{
       trace("finished.");
}

Now thats fine for many situations, but in this case it wasnt for me as I wanted to monitor write progress as I might be dealing with some quite large files, so the file for writing must be asynchronous writing so the progress events can be written. The problem with this is that the rest of the code in the example above would continue while the writing is happening including the close, which would probably end up with the event being dispatched prematurely and worse not all of the file being written.

public function write () : void
{
var myFile:File=File.documentsDirectory.resolvePath("test.txt");
var myFileStream:FileStream = new FileStream();
myFileStream.addEventListener(Event.CLOSE, closeHandler);
myFileStream.addEventListener(OutputProgressEvent.OUTPUT_PROGRESS, progressHandler);
myFileStream.openAsync(myFile, FileMode.WRITE);
myFileStream.writeUTFBytes("hello world");
trace("started.");
}

public function closeHandler(event:Event):void
{
trace("finished.");
}

So here we’re still waiting for the stream to dispatch a close event before continuing, but we’re only closing the stream once we are sure that all the bytes have been written.