Below is the code and zip file with the entire project made in FDT 4. (So you can import it directly).

First you instantiate an new YouTubeLoader instance. Once the load is handled you pass the url bit of the movie on youtube.

_youTubeLoader = new YouTubeLoader();
_youTubeLoader.addEventListener(YouTubeLoaderEvent.LOADED, handleVideoLoaded, false, 0, true);
_youTubeLoader.addEventListener(YouTubeLoaderEvent.STATE_CHANGE, handleVideoStateChange, false, 0, true);
_youTubeLoader.create();

function handleVideoStateChange(event : YouTubeLoaderEvent) : void {
    switch(_youTubeLoader.getPlayerState( )) {
        case "0":
            _youTubeLoader.seekTo( 0 );
            break;
        }
}

function handleVideoLoaded(event : YouTubeLoaderEvent) : void {
    // This is the YouTube movie ID
    var id : String = "WbJX4RzfJ8E";

    trace( _youTubeLoader.getPlayerState( ) + "state", toString( ) );
    _youTubeLoader.loadVideoById( id );
    _youTubeLoader.setSize( 511, 383 );
    addChild( _youTubeLoader );
    _youTubeLoader.play();
}

The only thing left now is ta make sure the ExternalInterface communication with JavaScript works as it should. So you add this to your embed tag

    //init the youTubeLoader javascript methods
    SWFID = "application";

Then you complete embed tag becomes the following;

Here is the zip with the complete project.

But i can give you a sneak peak.

It does include some really nice new features like detecting changes in Mass storage devices. There is a new Class called StorageVolumeChangeEvent which dispatches two different events (STORAGE_VOLUME_MOUNT and STORAGE_VOLUME_UNMOUNT) when an USB device is mounted/unmounted (Think camera, external HDD and USB stick). I cannot tell you the specifics about it yet, but I’ve done some tests and it works like a charm!

There will also be some other long awaited extras that will be very VERY funky!
So check out this video to see all of it!

The StageDisplayState Class in Actionscript 3 has two states, NORMAL and FULL_SCREEN the AIR API add one more; FULL_SCREEN_INTERACTIVE. (WARNING! This is only available in AIR.)

So that means that we now have two modes for full screen, StageDisplayState.FULL_SCREEN and StageDisplayState.FULL_SCREEN_INTERACTIVE. The first just resizes your application in full screen however you cannot interact with it. All the controls like input fields and buttons are disabled. The last one, StageDisplayState.FULL_SCREEN_INTERACTIVE, does allow the user to interact with your application. This can be very convenient when developing for kiosks, fullscreen video players, image viewers etc. Remember that control bar youtube has when playing video in full screen? Now you can have that too! So on with the code!

What works best for me is that i always set the scaleMode to no_scale, so i know that all my content will be shown at 100% and is not stretched. I set it up like so:

stage.scaleMode = StageScaleMode.NO_SCALE;
stage.align = StageAlign.TOP_LEFT;

When we click the fullscreen button we need to check in what state we are in and change that to the full screen mode. and we need to be albe to respond to the resize event, so when we switch states our content is sized accordingly. (Also make sure that your content is positioned relatively and not with hard coded values)

stage.nativeWindow.addEventListener( Event.RESIZE, onResizeApp );
fullscreenButton.addEventListener( MouseEvent.CLICK, onFullscreenClick );

function onResizeApp( event:Event ):void {
// do repositioning of elements here
}

function onFullscreenClick( event:MouseEvent ):void {
if( stage.displayState == StageDisplayState.NORMAL ) {
stage.displayState = StageDisplayState.FULL_SCREEN_INTERACTIVE;
fullscreenButton.label = "Exit Fullscreen";
} else {
stage.displayState = StageDisplayState.NORMAL;
fullscreenButton.label = "Go Fullscreen";
}
}

So there you have it, an interactive full screen application. Source Files are included for you to play with. Have fun

A FileStream object is used to read and write files. Files can be opened synchronously by calling the open() method or asynchronously by calling the openAsync() method.

Synchronous File operations:
The benefit of using sync file operations is that it uses far less code to complete a file load and should actually only be used on small files. The rule of thumb I use is < 1MB.

import flash.filesystem.*;

var file:File = File.documentsDirectory;
file = file.resolvePath("someFile.txt");
var fs:FileStream = new FileStream();
fs.open(file, FileMode.READ);
var data:String = fs.readUTFBytes(fs.bytesAvailable, File.systemCharset);
fs.close();

When a file is loaded in in an sync matter the rest of the application is halted/ it freezes until the complete file is loaded in. This is one of the reasons why you should only use this on small files.

Aynchronous File operations:

The advantage of opening files asynchronously is that other code still runs while in the background while the read and write operations are done. When opened asynchronously, progress events are dispatched as operations proceed.

It uses more code to handle a loading of an file:

import flash.filesystem.*;

var file:File = File.documentsDirectory;
file = file.resolvePath("someFile.txt");

var fs:FileStream = new FileStream();
fs.addEventListener(Event.COMPLETE, onComplete);
fs.addEventListener(ProgressEvent.PROGRESS, onFileProgress);
fs.addEventListener(ProgressEvent.OUTPUT_PROGRESS, onFileOutputProgress);
fs.open(file, FileMode.READ);

function onComplete( e:Event ):void {
	var data:String = fs.readUTFBytes(fs.bytesAvailable, File.systemCharset);
	fs.close();
}
function onFileProgress( e:ProgressEvent):void {
        // You can show a loader while its still processing
        // Signals the availability of new data on the stream.
	trace(e.bytesLoaded);
}
function onFileOutputProgress( e:ProgressEvent):void {
        // You can show a loader while its still processing
        // Signals that buffered data has been written to the file.
	trace(e.bytesTotal, e.bytesPending);
}

For prototyping synchronous is the way to go, because it is fast and not used in real life situations. If you have really big files you are loading in, FLV files that are 500 MB or other huge files, asynchronous is your best option.
I hope this clears things up about the difference in loading files in different manners. Comments are always welcome!

- When you are not idle for a period of time, the application syncs with and online database.
- Complex Screensavers – Show full screen for how long the user has been away from its desk
- An Application that warns you when to take breaks because you been sitting way too long behind your computer. The possibilities are endless!

Other fun functions you can use with this is:

timeSinceLastUserInput — The time, in seconds, since the last mouse or keyboard input.
and

idleThreshold – The number of seconds that must elapse without keyboard or mouse input before a presenceChange event is dispatched. By default, the idle threshold is 300 seconds (5 minutes).

import flash.desktop.NativeApplication;
import nl.funkymonkey.firelog.core.*;
var IDLETIME:int = 5;//Yes that is seconds.

initIdleExampleApp();

function initIdleExampleApp():void
{
	NativeApplication.nativeApplication.idleThreshold = IDLETIME;
	NativeApplication.nativeApplication.addEventListener(Event.USER_IDLE, onUserIdle);
	NativeApplication.nativeApplication.addEventListener(Event.USER_PRESENT, onUserPresence);
	Logger.info("Status: Active - status will change if idle for more than " + IDLETIME + " seconds");
}

function onUserIdle(event:Event):void
{
	Logger.info("User has been Idle for at least " + IDLETIME + " seconds".);
	Logger.info("Here you can do what you want.");
}

function onUserPresence(event:Event):void
{
	Logger.info("User is active again, after being idle for " + IDLETIME + " seconds.");
	Logger.info("Now you can make your app get back to its normal state.");
}

What I have noticed with idle time is that the time is an indication and not a real value, it can be a second or two off (this can be caused by the Timer class, as Keith Peters describes here). So keep that in mind.

In my code I trace with FireLog, a simple logger for AIR, and you can find that here.

Here is an example AIR file:
[airbadge]Idle User,http://www.funky-monkey.nl/air/example/idle_screensaver.air,1.0.2[/airbadge]
Have fun coding you own little play things!

Thawte is not the fastest company when it comes to replying back to the customer or sending notifications when they say they will. It took me almost two months to get it. (Got to love outsourced customer support where every employee is named the same and are based in Africa, Germany and England. Where can I declare the costs of these endless conversations, couldn’t find it on their site? . Glad to got that off my chest Anyway, I finally have it, and am a very happy camper! Thank you Adobe and Thawte!

Below is a screenshot:

At the Adobe AIR Marketplace you can download the new version of my Funky TAX Calculator. Feature requests, bugs or remarks – place them in the comments

The FileFilter instances can also be passed to a browse() function. If you use a FileFilter instance, extensions and file types that aren’t specified in the FileFilter instance are filtered out; that is, they are not available to the user to select for uploading. If no FileFilter object is passed to browse(), all files are shown in the dialog box.
You can use FileFilter instances in one of two ways:

1. A description with Windows file extensions only
2. A description with Windows file extensions and Macintosh file types

The two formats are not interchangeable within a single browse() call. You must use one or the other.

You can pass one or more FileFilter instances to FileReference.browse() or FileReferenceList.browse(). The following examples show different ways to create and pass FileFilter instances to a browse() call (for Windows only). The first example creates FileFilter instances outside of the browse() call:

var imagesFilter:FileFilter = new FileFilter("Images", "*.jpg;*.gif;*.png");
var docFilter:FileFilter = new FileFilter("Documents", "*.pdf;*.doc;*.txt");
var myFileReference:FileReference = new FileReference();
myFileReference.browse([imagesFilter, docFilter]);

The second example creates FileFilter instances within the browse() call:

myFileReference.browse( [ new FileFilter("Images", "*.jpg;*.gif;*.png"), new FileFilter("Flash Movies", "*.swf") ] );

The list of extensions in the FileFilter.extension property is used to filter the files in Windows, depending on the file selected by the user. It is not actually displayed in the dialog box; to display the file types for users, you must list the file types in the description string as well as in the extension list. The description string is displayed in the dialog box in Windows. (It is not used on the Macintosh.) On the Mac, if you supply a list of file types, that list is used to filter the files. If not, the list of Windows extensions is used.

You can find it here

Have fun with it

Install the front end with the big button below and download the class file here. Files that are written are saved to the desktop. (so its easier to drag and drop the files in the front end. You can however change this in the class file.)

Place this file either in you global class path or in a project specific class path. You import and set it up it using:

import AirLogger;

AirLogger.init("somefile.txt");
AirLogger.log("write some text here");
AirLogger.newLine();
AirLogger.log("write other text here");

Please upgrade your Flash Player

Please comment any thoughts or ideas so i can make this logger better. Enjoy!

NOTE:The logger does not yet trace out objects, working hard on that.