I'm working on a straight AS3 project that has a dynamically generated pop-up type window which can contain a video player. You open the window, a video player is created - you close it, and the player is removed.  The client requested that we use Flash's FLVPlayback component.  When I started doing some profiling I noticed that instances of FLVPlayback and its subcomponents weren't getting garbage collected. After several hours of frustration, I created a project from scratch that just loaded and unloaded FLVPlaybacks to see if I could recreate the problem. Here it is:

Application - Source

You'll notice that each time you create a video player, System.totalMemory goes up by several megs!  (your results may vary)  and it never comes back down.  Here's what it looks like after creating and destroying 10 FLVPlaybacks:

Note that I sorted by current number of instances, and removed flash.*.* from the filters list so that I could see the Timers.

All of the objects in the fl.video.skin package are still hanging around.  I actually have no idea why it created two skins for each instance, but I'm sure there is a good explanation... the main point is that none of these objects were getting garbage collected.

It took a lot of rooting around in the source before figuring out what the culprits were, but I knew I would have to do some manual cleanup work in order to clear out all object references.  My solution was to subclass FLVPlayback and implement a dispose() method to do the necessary cleanup.  (Just for fun, I got the same solution working with an old school prototype hack, but I think we're supposed to pretend those don't exist anymore.)  Now, I may have been a little aggressive on my cleanup - but the overhead is tiny, and it's important to me that this always works.  If anybody knows of a simpler solution, please post it in the comments.  Here's the breakdown:

1. Call stop().  Obviously if the video is still playing it cannot be garbage collected.
2. Stop all timers in FLVPlayback and UIManager and remove the TimerEvent.TIMER event listeners attached to each one.
3. Call the close() method on the VideoPlayer instances.  This will stop their timers, remove event listeners, and close NetConnections.

Here's the same application, but using FLVPlayback2 and the FLVPlayback2.dispose() method:

Application -  Source

And here are the profiler results:

Success!  I wish that hadn't taken so much detective work... why aren't the Flash components built to the same standards as the Flex ones?

I have to credit Brian Holmes for providing a really easy way to do non-visual components without extending UIComponent. This makes the RPChangeWatcher (thusly named to avoid namespace conflicts) really lightweight. Check out the sample application:

application - source

This is a very simple example, but imagine you're using some form of MVC and the currentDP being a variable in your model. This particular view doesn't care how or why currentDP gets updated, it just wants to display an animation to transition between datasets. That isn't possible using regular data binding, but it's pretty clean and simple with an mxml ChangeWatcher.

I haven't experimented with this a lot yet, but given that you can use data binding on the host and chain properties, I can see some potential for some pretty advanced use cases.

Any thoughts?

Application - Source

I am working on a large project that has many different panels that populate with different kinds of data from HTTP requests... i.e. an image, or a "search" window that displays its results in a datagrid. Since they are all independent from each other, I wanted a way to disable a given control and show a load indicator while the application was waiting for a response. There could be one or several requests pending at the same time.

So I created a class called LoadCanvas which extends Canvas. The class is really simple. It has a loadImageSource property for the loading indicator swf (or image), and an isLoading property which tells it when to display the load indicator.

Here's an example app:

If you are using cairngorm (which I highly recommend), then you can create a boolean variable in your model that is set to true in your command's execute function and back to false in the result and fault functions. Then you can bind the LoadCanvas's isLoading property to this variable. I sometimes also bind the enabled property of some of the controls, like the buttons in my example, to that variable so that the user can't make the same request several times in a row. Notice how the buttons are disabled while the request is pending.

Note:
If you are performing an operation where you can track the progress... then I recommend using a progress bar. Your users will appreciate the additional feedback.

Application - Source

Update:
I have updated this component to use the Flex4 architecture. It's not fully skinnable yet, but will hopefully fix the compatibility issue that Keith mentioned below.
Load Canvas Flex 4 Edition

Application - Source

Flex MenuBars are lacking several features that are standard on most other platforms. The most glaring of these is that lack of support for displaying accelerators (shortcut key combos like Ctrl+N for opening a new file). After hunting around on the internet a bit, I came across some sample code by Campbell Anderson which uses the Menu's icon to display an accelerator. This is a step in the right direction, but the icons in a Flex Menu show up on the left side which is opposite of both Windows and Mac standards. I wrote my own class which overrides some of MenuItemRenderer's layout logic in order to place the icon on the right. (Scroll to the bottom for the source.) Now we can write a menu dataProvider that looks like this:

... and get a menu that looks like this:

It's a good start, but I wanted to take it a step further. Once you put together a bunch of accelerators, your key handler that listens to all of the accelerators is going to become a giant mess. Wouldn't it be nice if your app automatically listened for all accelerator events and utilized the same handler function that you already wrote for your menu?

Enter: the Accelerator class
My solution was to create a class that encapsulates an accelerator (e.g. control key plus the letter 'Z') and generate a list of all accelerators directly from the Menu's dataProvider. Notice that I am also storing the 'data' attribute from the menu xml... we'll be needing that later.

Under the hood, the Accelerator class basically splits the string by '+' and pulls out each component. It also has a handy little method called test() which accepts a KeyboardEvent, and checks to see if the event matches the accelerator.

Finally, I added a KEY_UP listener to the application that tests each accelerator, and if there is a match -- we can use that 'data' variable that we stored earlier to call the SAME handler that would have been called if the user clicked that menu item!

But - here's the down side...
Some browsers may trap certain key combos before they ever reach the Flash player. This means that - as far as I know - combos like Ctrl-N and Ctrl-S are out. You may have better luck in a standalone or projector player, but I haven't tested it. Also - It seems that you have to click on the movie to give it focus before it begins capturing key events. This is a bit disappointing, but there seem to be quite a few options still available. Maybe use Shift in place of Ctrl?

So, was this a failure? You be the judge... a nice by-product of this experiment though was the KeyUtils class which does conversions between strings and keyCodes - similar to what you can do with String.fromCharCode() and String.charCodeAt().

Check it out:
In this application, clicking on menu items just displays a message indicating which item was clicked. Try hitting some of the accelerator combos - you should get the same message you got when you clicked the item (its calling the same function.) Remember that you have to click on the app to give it focus first. Notice that the accelerators are compatible with 'check' and 'radio' types, and also items that branch. The only feature that you can't use is the icon, since it is getting used to display the accelerator.

Application - Source

Update:
In response to Steve's question below - here is an example which underlines characters in the menu item's label. An ampersand preceding the character indicates that it should be underlined, and because this is XML we have to XML encode the ampersand.

Here's the plan:
My goal is to extend this library to support docking. I'd like to take a cue from Adobe's CS3 product line, and enable three different types of docking:

1. Dragging or resizing a window to within a certain distance of another will cause it to "snap" into alignment.
2. Dragging a window onto the bottom section of another will cause them to combine into a window stack that moves and resizes as a single unit.
3. Dragging a window onto the title bar of another window will create a single window with a tab bar at the top.

To keep things simple, I'm tackling these one at a time. Here's part I:

Application - Source

The FlexMDI guys have graciously accepted my offer to include this in a future update of FlexLib, but the code will likely get refactored a bit first. To illustrate the added functionality, I separated it out into two new classes: MDIDockCanvas and MDIDockManager. These will probably end up getting merged back into the MDICanvas and MDIManager classes respectively.