• name
• drive
• fileSystemType
• isRemovable
• isWritable
• rootDirectory

The isRemovable property indicates whether the operating system considers the media it just detected as removable or not. Initially, this seemed pretty straightforward to me, but as I began playing with the APIs, I found I didn't always agree with the OS's assessment. For instance, my portable 500GB Western Digital USB hard drive is not considered removable even though I plug it in and remove it all the time (note that this is the operating system's decision -- not AIR's). And, for some reason, my Time Capsule is removable, but other network drives are not. Strange.

The table below shows the results of the testing I've done so far:

¹ Linux doesn't have a concept of a shared volume.

² No StorageVolumeChangeEvent is thrown when drives are mounted using SMB on Linux.

³ Windows considers empty card readers to be non-removable devices while OS X and Linux do not react to them at all.

I'm hoping to get other developers to try out whatever devices they have lying around on whichever OS they favor so we can make this chart as comprehensive as possible. If you have the opportunity to provide data for any of the missing cells, or if you have devices that aren't listed, please leave the information in the comments and I'll update the table. Over time, this should become a very valuable resource for developers googling for answers.

If you need a quick way to test, I threw together this little utility called StorageVolumeTest.air (source code) which will report all the StorageVolume properties as volumes are detected and mounted. This app requires the AIR 2 public beta which can be downloaded here.

For more information on the new storage volume detection capabilities of AIR 2, see Exploring the new file capabilities in Adobe AIR 2. Thanks for your help!

The code below shows how to indicate that you want to receive gesture events (as opposed to multi-touch, or no touch events at all), and registers for zoom, rotate, and pan gesture events (the watch variable refers to a Sprite which contains the bitmap image of the watch):

Multitouch.inputMode = MultitouchInputMode.GESTURE;
watch.addEventListener(TransformGestureEvent.GESTURE_ZOOM, onZoom);
watch.addEventListener(TransformGestureEvent.GESTURE_ROTATE, onRotate);
watch.addEventListener(TransformGestureEvent.GESTURE_PAN, onPan);

The three functions below show responding to each of the gesture events:

private function onZoom(e:TransformGestureEvent):void
{
    var watch:Sprite = e.target as Sprite;
    watch.scaleX *= e.scaleX;
    watch.scaleY *= e.scaleY;
}

private function onRotate(e:TransformGestureEvent):void
{
    var watch:Sprite = e.target as Sprite;
    watch.rotation += e.rotation;
}

private function onPan(e:TransformGestureEvent):void
{
    var watch:Sprite = e.target as Sprite;
    var watchBitmap:Bitmap = watch.getChildAt(0) as Bitmap;
    watchBitmap.x += e.offsetX;
    watchBitmap.y += e.offsetY;
}

For much more information on how multi-touch and gestures work in both AIR 2 and Flash Player 10.1 (including OS and hardware support, which gestures are supported where, and a thorough review of the APIs), and to download sample code, see Multi-touch and Gesture Support on the Flash Platform. Or, if you just want to see the code for this sample, you can download it here.

Adobe Labs

• AIR 2 Beta on Adobe Labs
• Download the AIR 2 Public Beta
• AIR 2 Beta Sample Applications
• AIR 2 Beta Release Notes
• AIR 2 Developer FAQ

Adobe Developer Center

• Introducing Adobe AIR 2 Beta
• Interacting with a Native Process
• Multi-touch and Gesture Support on the Flash Platform
• Exploring the New File Capabilities in Adobe AIR 2
• Drag-and-drop Support of Remote Files in Adobe AIR 2
• Creating a Socket Server in Adobe AIR 2
• Using the Microphone Capabilities in Adobe AIR 2
• Creating Accessible Applications in Adobe AIR and Flex

Adobe TV

• Desktop Integration in Adobe AIR 2 (video)
• Command Line Integration in Adobe AIR 2 (video)
• Kevin Lynch Demos AIR 2 Features at MAX (video)
• Multi-touch Demos in Adobe AIR 2 and Flash Player 10.1 (video)
• What's Coming in Adobe AIR 2 (MAX presentation video)
• Building Accessible Flex and Adobe AIR Applications (MAX presentation video)

This Blog

• Exhaustive List of Everything That's New in AIR 2
• Global Error Handling in AIR 2.0 and Flash 10.1
• A Screencast Explaining and Demoing File Promises (video)
• A Demonstration of the ServerSocket API in AIR 2 (video)
• A Demonstration of the New Storage Volume APIs in AIR 2 (video)
• A Demonstration of the NativeProcess APIs in AIR 2 (video)
• A Demonstration of Encrypted Socket Support in AIR 2 (video)
• New AIR 2 API: URLRequest.idleTimeout

Community

• #air on Twitter
• AIR Smart Category on Adobe Feeds
• Google Blog Search for "Adobe AIR"
• Labs Forum for AIR 2
• Adobe AIR-Tight Google Group
• Adobe AIR Support Forum
• Feature Request and Bug Report Form

The new SecureSocket class extends Socket, so MenuMail can use either encrypted or non-encrypted sockets without really having to know the difference:

this.socket = (this.secure) ? new SecureSocket() : new Socket();

The MenuMail application, and all the code for MenuMail, will be available on Adobe Labs after the AIR 2 public beta launch (which is very close!).

The NativeProcess APIs are very simple to use. The code below invokes the mdfind command on OS X, and sets up an event listener to read the results from standard out:

private function onSearch():void
{
    var npInfo:NativeProcessStartupInfo = new NativeProcessStartupInfo();
    npInfo.executable = this.mdfindFile; // A reference to the mdfind command
    var args:Vector.<String> = new Vector.<String>;
    args.push("-interpret");
    args.push(this.searchTerm.text);
    npInfo.arguments = args;
    this.processBuffer = new ByteArray();
    this.nativeProcess = new NativeProcess();
    this.nativeProcess.addEventListener(ProgressEvent.STANDARD_OUTPUT_DATA, onStandardOutputData);
    this.nativeProcess.addEventListener(NativeProcessExitEvent.EXIT, onStandardOutputExit);
    this.setStatus("Searching for " + this.searchTerm.text + "...", true);
    this.nativeProcess.start(npInfo);
}

The code below shows buffering the data from standard out:

private function onStandardOutputData(e:ProgressEvent):void
{
    this.nativeProcess.standardOutput.readBytes(this.processBuffer, this.processBuffer.length);
}

And finally, the code blow is an abbreviated version of the function that parses the data from standard out and puts it into the data grid:

private function onStandardOutputExit(e:Event):void
{
    var output:String = new String(this.processBuffer);
    var outputArray:Array = output.split("\n");
    var data:Array = new Array();
    for each(var path:String in outputArray)
    {
        var f:File = new File(path);
        if (!f.exists) continue;
        var o:Object = new Object();
        if (f.isDirectory)
        {
            o.name = "/" + f.name;
        }
        else
        {
            o.name = f.name;
        }
        o.type = f.extension;
        o.lastModified = f.modificationDate;
        o.path = f.nativePath;
        data.push(o);
    }
    var dp:ArrayCollection = new ArrayCollection(data);
    this.fileGrid.dataProvider = dp;
    this.setStatus(dp.length + " items found");
}

The code for SearchCentral will be available on on Adobe Labs as soon as the AIR 2 Beta is public (very soon!). The code for SearchCentral is now available on Google Code. If you have any questions, drop them in the comments below.

Detecting the mounting and unmounting of a storage volume in AIR 2 is very easy. The code below shows using the new StorageVolumeInfo class to register for mount and unmount events:

StorageVolumeInfo.storageVolumeInfo.addEventListener(StorageVolumeChangeEvent.STORAGE_VOLUME_MOUNT, onVolumeMount);
StorageVolumeInfo.storageVolumeInfo.addEventListener(StorageVolumeChangeEvent.STORAGE_VOLUME_UNMOUNT, onVolumeUnmount);

Below are the two functions that react to the mounting and unmounting of storage volumes:

private function onVolumeMount(e:StorageVolumeChangeEvent):void
{
    if (e.storageVolume.isRemovable)
    {
        this.nativeWindow.activate();
        this.volumeName.text = e.storageVolume.name;
        this.targetVolume = e.storageVolume.rootDirectory;
        this.currentVolumeNativePath = this.targetVolume.nativePath;
        this.start();
    }
}

private function onVolumeUnmount(e:StorageVolumeChangeEvent):void
{
    if (this.currentVolumeNativePath == e.rootDirectory.nativePath)
    {
        this.reset();
        this.mainView.selectedChild = instructionBox;
    }
}

FileTile is a free, open-source application. The code can be downloaded from Google Code.

Most of the HTTPeek code is dedicated to implementing just enough of the HTTP protocol to be an effective proxy, but the socket portion of the code is actually not all that complex. And the creation of the ServerSocket itself is very simple. The function below gets called when the user clicks on the "Listen" button:

private function onListen():void
{
    this.sockets = new Array();
    this.server = new ServerSocket();
    this.server.addEventListener(Event.CONNECT, onConnect);
    try
    {
        this.server.bind(Number(this.portNumber.text), String(this.interfaces.value));
        this.server.listen();
        this.listenButton.label = "Close";
    }
    catch (e:Error)
    {
        Alert.show(e.message, "Error", Alert.OK);
        return;
    }
    this.debugButton.enabled = true;
}

HTTPeek is open-source and hosted here on Google Code. Feel free to check out the source to see how it works.

I ran the script again the other day (after some updating since screen scraping scripts always break), and here's what I found:

Some things to keep in mind about this data:

• I was only able to test applications that were listed on the Adobe AIR Marketplace. These stats don't include the (hundreds? thousands?) of AIR applications not listed.
• I was only able to test applications that have direct links to their AIR files on the Marketplace. 121 applications only have links to their sites rather than links to their AIR apps, so that's a fair percentage of missing data (16.7%). Maybe I'll fix that limitation in the future.
• I don't have any statistic on "hybrid" apps, or applications that load a SWF as their main content, but then load HTML/JS into an HTMLLoader (or the opposite -- HTML apps that load Flash content). I've personally written several applications that combine Flash/ActionScript/HTML/JS, and I suspect a substantial portion of the SWF-based applications on the Marketplace are hybrids, as well.

I plan on updating the script to look for any HTML/JS files in the application bundle in order to give an indication of the number of hybrid applications out there. I'll post the results when I have them.

So my questions for you guys are:

• Any other statistics you'd like to see?
• Anything we can do for the HTML/JS/Ajax developers out there to get more HTML-based apps?
• Will any of the new HTML features in AIR 2 give HTML devs what they need to build on AIR?

Here's the code that creates a URLFilePromise for every file to be downloaded and puts them on the clipboard. But first, some code context:

• onDragStart is the event handler that gets called when the user starts dragging items from the list of objects.
• bucketList is the ComboBox of bucket names.
• objectList is the DataGrid of objects.
• The function s3.getTemporaryObjectURL(...) generates a temporary public URL that points to the specified object. It's the URL that the URLFilePromise will use to access the file.

private function onDragStart(e:DragEvent):void
{
    if (bucketList.selectedIndex == 0 || objectList.selectedItems == null) return;
    var c:Clipboard = new Clipboard();
    var items:Array = objectList.selectedItems;
    this.filePromises = new Array();
    for each (var item:Object in items)
    {
        var fp:URLFilePromise = new URLFilePromise();
        var req:URLRequest = new URLRequest(s3.getTemporaryObjectURL(bucketList.selectedItem.name, item.key, 60));
        fp.request = req;
        fp.relativePath = item.key;
        this.filePromises.push(fp);
    }
    c.setData(ClipboardFormats.FILE_PROMISE_LIST_FORMAT, this.filePromises);
    NativeDragManager.doDrag(objectList, c, null, null, null);
}

Below is the function that gets called when the drop is complete. It's responsible for opening the ProgressWindow component and passing it the array of URLFilePromise objects which the ProgressWindow component hooks into in order to receive progress events.

private function onDragComplete(e:DragEvent):void
{
    var progressWindow:ProgressWindow = new ProgressWindow();
    progressWindow.open(false);
    progressWindow.setFilePromises(this.filePromises);
}

The code for S3E is open source and available on Google Code.]]> 2009-11-06T21:23:55Z 2009-10-29T17:44:46Z tag:blogs.adobe.com,2009:/cantrell/333.43830 2009-10-29T17:44:46Z

<?xml version="1.0" encoding="utf-8"?>
<mx:WindowedApplication xmlns:mx="http://www.adobe.com/2006/mxml" applicationComplete="onApplicationComplete();">

    <mx:Script>
        <![CDATA[
            private function onApplicationComplete():void
            {
                loaderInfo.uncaughtErrorEvents.addEventListener(UncaughtErrorEvent.UNCAUGHT_ERROR, onUncaughtError);
            }

            private function onUncaughtError(e:UncaughtErrorEvent):void
            {
                // Do something with your error.
                if (e.error is Error)
                {
                    var error:Error = e.error as Error;
                    trace(error.errorID, error.name, error.message);
                }
                else
                {
                    var errorEvent:ErrorEvent = e.error as ErrorEvent;
                    trace(errorEvent.errorID);
                }
            }
            
            private function onCauseError(e:MouseEvent):void
            {
                var foo:String = null;
                try
                {
                    trace(foo.length);
                }
                catch (e:TypeError)
                {
                    trace("This error is caught.");
                }
                
                // Since this error isn't caught, it will cause the global error handler to fire.
                trace(foo.length);
            }
        ]]>
    </mx:Script>
      
    <mx:Button label="Cause TypeError" click="onCauseError(event);"/>
 
</mx:WindowedApplication>

Registering for uncaught errors is hugely convenient, but it doesn't entirely excuse developers from handling errors where they're most likely to happen. For instance, you should still always register for things like IOError events and other errors that are likely to happen at some point, and that you can usually recover from. But starting with AIR 2.0 (and FP 10.1), you will also be able to register globally for errors that you weren't able to anticipate, and handle them at least somewhat gracefully.

The big question is what you do once you've caught an unhandled error. That will probably depend on the application. Since it's likely that a function exited without executing all the way through, there's no telling what state your app will be in. The safest thing to do is probably to log the error, show a very contrite dialog box, and then exit the app (after all, if the error had been predictable and easy to recover from, you should have caught it explicitly). You might try sending the error message to your server, including instructions for emailing the log file to a support email address, or if it's an internal application, provide a telephone extension to call for someone to come take a look. It's entirely up to you. We provide the API, you provide the solution.

• URLRequest.idleTimeout
• URLRequestDefaults.idleTimeout

These setters specify the amount of time (in milliseconds) that a connection will remain open before receiving any data. Certainly not as sexy as some of our other new features (native processes, file promises, multi-touch, accessibility, volume detection, socket servers, etc.), but if you're trying to use long polling, you'll probably find this API useful.

var codeXML:XML =
<code>
    <class name="Order">
        <function name="getId">
            <access>public</access>
            <return>Number</return>
        </function>
    </class>
</code>;

Since this XML is full of reserved words, you won't be able to access nodes like this:

trace(codeXML.class.function.return);

Instead, use bracket syntax like this:

trace(codeXML["class"].@name);
trace(codeXML["class"]["function"].access);
trace(codeXML["class"]["function"]["return"]);

var inventory:XML =
	<inventory>
		<product id="111" price="2999.99">Laptop</product>
	</inventory>;

But what if you want to generate the XML dynamically and use variables as attribute values or text nodes? Just use curly braces like this:

var products:Array = new Array();

products.push({name:"Laptop", id:111, price:2999.99});
products.push({name:"Mouse", id:222, price:49.99});
products.push({name:"Phone", id:333, price:199.99});

var inventory:XML = <inventory/>;

for each (var o:Object in products)
{
	inventory.appendChild(<product id={o.id} price={o.price}>{o.name}</product>);
}

The resulting XML is exactly what you'd expect:

<inventory>
	<product id="111" price="2999.99">Laptop</product>
	<product id="222" price="49.99">Mouse</product>
	<product id="333" price="199.99">Phone</product>
</inventory>

Simple and elegant!

Feel free to leave questions in the comments.