At the beginning of this week a beta 2 version of the AIR 3 SDK was released. The AIR 3 SDK and AIR 3 runtime will be a major release that will bring a lot of really cool features. One of the features that I’m really excited about is Captive Runtime, which lets you package your applications with a bundled AIR runtime. This is something that was available for the iOS platform from day one, and now it is also supported for both Android devices and desktops.

I think this is a really important feature for AIR. I heard many times from our customers and the community that we need a solution that enables users to install AIR applications without administrator rights. This is a common scenario especially in the enterprise environments where users don’t have full privileges. Also in some other cases it may improve user experience as there is no need to ask the user to install an additional runtime. It will also help when you need to distribute your application on a CD or other media that doesn’t let you use the browser-based badge installer.

Now how do you package your app for both Windows and Mac? It’s really simple. First thing what you need to do is to download and unzip the new SDK from Adobe Labs. Next compile your application either with the command line mxmlc compiler or using Flash Builder. To do it in Flash Builder, right-click your AIR application project, select Export… -> Flash Builder -> Release Build, and complete just the first step of this wizard without finishing it. This will create a bin-release-temp folder under your project directory with a compiled SWF and app descriptor file. Now go to the command line and invoke following adt command from your project/bin-release-temp folder.

On Windows:

c:\path\to\air3sdk\bin\adt.bat -package -storetype pkcs12 -keystore c:\path\to\certificate.p12 -target bundle myapp.exe myapp-app.xml -C . myapp.swf


On Mac:

/path/to/air3sdk/bin/adt -package -storetype pkcs12 -keystore /path/to/certificate.p12 -target bundle myapp.app myapp-app.xml -C . myapp.swf


You will receive slightly different results depending on your platform. On Mac your application is packaged into myapp.app, which is a single Mac package file. You can just double-click it to run the app. Also if you want to introspect its content you can right-click it and select the Show Package Contents option. On Windows you will get myapp.exe folder that has all the runtime files and the executable myapp.exe file in it. Now you can use your favorite installer builder to build a setup package for your application.

Generated folders structure on Windows:

Generated package structure on Mac:

For Android options check out this blog post by my new fellow evangelist Andy Trice.

If you’ve ever wondered if you can register your own URL schemes for your AIR mobile applications running on iOS or Android platforms the answer is yes! Actually it is very simple and you can do it by adding few extra lines in the *-app.xml document. Once you do your application can be invoked directly from other applications or browser with a simple <a href="my-scheme:">open app</a> link click.

(Custom URL schemes are especially useful if you are doing OAuth authentication in your app and you want to redirect the user back to your application after the authorization in the browser. You can find out more about OAuth in AS3/Flex applications in my ADC tutorials.)

To register a custom URL scheme like my-scheme: you simply add the following code in your *-app.xml.

Android settings:

<android>
    <manifestAdditions>
    <![CDATA[
        <manifest android:installLocation="auto">
            <application> 
                <activity> 
                    <intent-filter> 
                        <action android:name="android.intent.action.VIEW"/> 
                        <category android:name="android.intent.category.BROWSABLE"/> 
                        <category android:name="android.intent.category.DEFAULT"/> 
                        <data android:scheme="my-scheme"/> 
                    </intent-filter> 
                </activity> 
            </application> 
 
            <uses-permission android:name="android.permission.INTERNET"/>
 
        </manifest>
    ]]>
    </manifestAdditions>
</android>

iOS settings:

<iPhone>
	<InfoAdditions>
	<![CDATA[
		<key>UIDeviceFamily</key>
		<array>
			<string>1</string>
			<string>2</string>
		</array>
 
		<key>CFBundleURLTypes</key>
		<array>
			<dict>
				<key>CFBundleURLSchemes</key>
				<array>
					<string>my-scheme</string>
				</array>
				<key>CFBundleURLName</key>
				<string>com.myapp</string>
			</dict>
		</array>
 
	]]>
	</InfoAdditions>
        <requestedDisplayResolution>high</requestedDisplayResolution>
</iPhone>

Also you can pass additional arguments to your app from the invoking source. Arguments can be passed in the URL scheme after the colon; for example: my-scheme:myparam. Then in your application you can listen for InvokeEvent.INVOKE event on the NativeApplication.nativeApplication instance. The received event object contains an arguments property that returns an Array with the invoking scheme and parameters in the first item, so it would be my-scheme:myparam value. Next you can parse the value of your argument, and take some action in the application based on its value.

In a Flex Mobile app you can register an InvokeEvent.INVOKE event listener in the preinitialize phase as in following snippet:

 
<?xml version="1.0" encoding="utf-8"?>
<s:Application xmlns:fx="http://ns.adobe.com/mxml/2009" 
			   xmlns:s="library://ns.adobe.com/flex/spark"
			   preinitialize="application_preinitializeHandler(event)">
 
	<fx:Script>
		<![CDATA[
			import mx.events.FlexEvent;
 
			protected function application_preinitializeHandler(event:FlexEvent):void
			{
				NativeApplication.nativeApplication.addEventListener(
					InvokeEvent.INVOKE, onInvoke);
			}
 
			private function onInvoke(event:InvokeEvent):void
			{
				// You can parse argument value from event.arguments property
				lblArguments.text = "Arguments: " + event.arguments;
			}
 
		]]>
	</fx:Script>
 
	<fx:Declarations>
		<!-- Place non-visual elements (e.g., services, value objects) here -->
	</fx:Declarations>
 
	<s:Label id="lblArguments" horizontalCenter="0" verticalCenter="0" />
 
</s:Application>

One caveat is that invoking other apps with the custom URL schemes from AIR apps is not possible. The AIR security model is more restrictive and it limits schemes to: http:, https:, sms:, tel:, mailto:, file:, app:, app-storage:, vipaccess: and connectpro:. You can find more about it here and here.

Recently I was looking for an example on how to create a skin that would work with the SkinnableContainer component class in a Flex mobile application. It turned out I couldn’t find any examples available in the wild so I had to dig it out myself. So below is the approach I took, which can also work for others.

The first thing I found out is that there is a SkinnableContainerSkin class in the spark.skins.mobile package that extends MobileSkin class. This is a basic implementation that works out-of-the-box when you use SkinnableContainer in mobile projects. Its only behavior is setting a contentGroup property with a new instance of the Group class and drawing a background rectangle filled with color based on the backgroundColor style.

Now my goal, instead of drawing the background with AS3, was to use a custom FXG file with some rounded corners, simple stroke and gradient. The screenshot below demonstrates what I was looking for:

In order to achieve the example above I extended SkinnableContainerSkin as in the following snippet:

package
{
	import spark.core.SpriteVisualElement;
	import spark.skins.mobile.SkinnableContainerSkin;
 
	public class MySkinnableContainerSkin extends SkinnableContainerSkin
	{
		protected var backgroundClass:Class;
 
		protected var background:SpriteVisualElement;
 
		public function MySkinnableContainerSkin()
		{
			super();
 
			// Here could be a DPI dependent logic, for demo purposes it is not necessary
			backgroundClass = MySkinnableContainerBackground;
		}
 
		override protected function createChildren():void
		{
			// Adding container background
			background = new backgroundClass;
			addChild(background);
 
			// Creating content group instance
			super.createChildren();
		}
 
		override protected function layoutContents(unscaledWidth:Number, unscaledHeight:Number):void
		{
			super.layoutContents(unscaledWidth, unscaledHeight);
 
			// Setting size of background container
			setElementSize(background, unscaledWidth, unscaledHeight);
		}
 
		override protected function drawBackground(unscaledWidth:Number, unscaledHeight:Number):void
		{
			// By default SkinnableContainerSkin draws Rect with backgroundColor but this is not
			// required in this case since background is constructed of MySkinnableContainerBackground fxg
		}
	}
}

My FXG file content looked like this:

<?xml version='1.0' encoding='UTF-8'?>
<Graphic xmlns:fc="http://ns.adobe.com/flashcatalyst/2009" xmlns:d="http://ns.adobe.com/fxg/2008/dt" 
		 xmlns="http://ns.adobe.com/fxg/2008" version="2.0"
		 scaleGridLeft="10" scaleGridTop="10" scaleGridRight="90" scaleGridBottom="90">
 
	<Rect radiusX="10" width="100" height="100">
		<fill>
			<LinearGradient rotation="90">
				<GradientEntry alpha="1.0" color="#CCCCCC" ratio="0"/>
				<GradientEntry alpha="1.0" color="#666666" ratio="1"/>
			</LinearGradient>
		</fill>
		<stroke>
			<SolidColorStroke color="#FF0000" weight="2"/>
		</stroke>
	</Rect>
 
</Graphic>

And the way I can use it now in my Flex mobile projects is as follows:

<s:SkinnableContainer left="10" top="10" right="10" bottom="10" skinClass="MySkinnableContainerSkin">
	<s:Label left="10" top="10" right="10" bottom="10">
		<s:text>Lorem ipsum dolor sit amet, consectetur adipiscing elit. Nam eget arcu et nibh vehicula pulvinar sit amet sit amet ligula. Duis a orci at nisi faucibus luctus. Quisque congue vulputate porttitor. Curabitur ac turpis nulla, a malesuada diam. Sed ullamcorper massa ac libero tincidunt vel ultrices odio cursus. Vestibulum ante ipsum primis in faucibus orci luctus et ultrices posuere cubilia Curae; Fusce pharetra varius tortor id rutrum. Duis tempor, nisl sit amet scelerisque dignissim, lorem nisl vehicula leo, in auctor dolor turpis at nisl. Quisque bibendum faucibus turpis vitae pulvinar. Sed mollis risus eget turpis molestie laoreet. Aenean metus nulla, vestibulum at egestas quis, aliquet tempus lectus.</s:text>
	</s:Label>
</s:SkinnableContainer>

Very recently I was looking for a simple and affordable solution to host Java-based services for the mobile version of my LCDS Samples application. Unfortunately, with the Java development, life is not as easy as with PHP where you can get affordable hosting that is managed and secured by your hosting provider. The reality is that with Java you usually end up having a VPS or an instance of a dedicated Linux server (of course Windows would work also). This is certainly a very good solution that gives you a lot of flexibility but you have to remember that the tasks of administering and securing your box are usually on your shoulders. Although I have some knowledge of Unix-type systems, to be honest I wouldn’t feel comfortable doing the whole administration on my own.

So after some research and trying out different options I ended up with an AWS Elastic Beanstalk service provided by Amazon (you can see it in action running here). I’m really excited about this service because it provides an instance of Tomcat (both 6.x and 7.x versions are available) hosted and managed on Amazon’s cloud infrastructure. On top of that and out-of-the-box, it provides a load balancer that will automatically launch additional instances if your application encounters the increased load. Also you have full access to your Tomcat logs and you can receive email notifications with the status and health of your running services.  Another important thing is that it is extremely easy to use, especially when you install the AWS Eclipse plugin that can also work well with Eclipse/Flash Builder.

The good thing is that the cost of all this is not really high, the entry level service is just about $35.27 a month, more details about pricing are available here.

Getting started

Follow these steps to get up and running:

1. Get an account (if  you don’t already have one) with AWS (Amazon Web Services). Once you get an account you can sign up for Elastic Beanstalk via the “Manage Your Account” section.
2. Configure your IDE environment. By default Flash Builder comes with a standard version of Eclipse that has only the JDT available. I suggest downloading the Eclipse IDE for Java EE Developers and to configure FB with this environment. It will give you additional tools to handle Tomcat instances and Java Web Projects, which you can use when developing for Elastic Beanstalk. Configuring FB with a custom installation of Eclipse is really straightforward. Once you download Eclipse from here and you extract it somewhere to your hard drive, you can go to the folder where you have FB installed and find the Adobe Flash Builder 4.5 Plug-in Utility application located in the utilities folder. In my case it is here “/Applications/Adobe Flash Builder 4.5/utilities/Adobe Flash Builder 4.5 Plug-in Utility.app” but it all depends where you have your FB installation and also on what OS you are on. Run this application and it will guide you with a few simple steps through the whole Flash Builder – Eclipse integration process.
3. Install the AWS Eclipse plugin. This can be done directly from Eclipse. Just go to the Help -> Install New Software menu and enter the following update site URL: http://aws.amazon.com/eclipse
   
4. Create a new AWS Java Web Project. After a successful install of the AWS plugin you will have an option to create new AWS projects. Use the wizard available from the top bar of Eclipse (with an AWS icon on it) to create a New AWS Java Web Project. First you will need to enter a project name, and credentials like Access Key ID and Secret Access Key. These values are generated when you sign up for an AWS account and you can copy them from the Security Credentials section of your AWS account.
   You can select the Basic Java Web Application option (see the screenshot above), this will be enough for the LCDS/BlazeDS scenario. More info about other options is available through this site, with an in-depth video tutorial.
5. Configure the LCDS/BlazeDS  environment. In order to do that you need to, copy all necessary jars into the WebContent/WEB-INF/lib folder of the newly created project. In my case I used a turnkey installation of LCDS and I just copied jars from the lcds-samples application and also jars from tomcat/lib/activemq4.1.1, tomcat/lib/jotm2.0.10 and tomcat/lib/lcds (this wouldn’t be necessary for BlazeDS but for LCDS it was required to make the DataServices and Messaging work properly). Next you will also need to copy all configuration files from the WEB-INF/flex folder and the web.xml that has all necessary LCDS/BlazeDS servlets/listeners configured. The important thing to note here is that by default the AWS Elastic Beanstalk service enables only port 80 and HTTP channels; in order to enable other ports that could be required for RTMP channels you can modify the AWS EC2 Security group settings (but that is a topic for another blog post and I will not cover it here). Another solution you have is to stick to the default settings and to configure LCDS services to use only HTTP channels; this is actually what I did for my lcds.riaspace.comservice.    One last thing I had to do to make the LCDS function properly was to create a WebContent/META-INF/context.xml file in which I defined the transaction configuration as in the following snippet:

   <?xml version="1.0" encoding="UTF-8"?>
   <Context reloadable="true">
     <Transaction factory="org.objectweb.jotm.UserTransactionFactory" jotm.timeout="60"/>
   </Context>

6. Deploy your application to the cloud. Once you have the configuration completed and all the services built you can deploy your application directly from Eclipse. Just right-click on the project and select the Amazon Web Services -> Deploy to AWS Elastic Beanstalk… option. Another wizard will pop up that will ask you to specify names for your application and environment.Next you will need to select the server type, which would be AWS Elastic Beanstalk for Tomcat 6 (you also have the option to deploy to Tomcat 7 instances).
   At last you will be able to specify the CNAME of your server (you can assign your own domain name in the DNS configuration, that is actually what I used to get the default lcds-samples.elasticbeanstalk.com configured as lcds.riaspace.com). Another valuable option here is to enter your email address, which will receive notifications of any changes to the service’s state and health.

   

   Now you are ready to click the Finish button and it will start uploading and configuring your application in the cloud. Be aware that this process may take several minutes the first time. Once it is done you will be able to access your services via the following URL: http://yourcname.elasticbeanstalk.com. To redeploy any changes made to your services you just need to follow this last step all over again.

Below you will find links to my two video tutorials about OAuth authorization with Flash and Flex apps:

1) Introduction to OAuth for secure user and application authorization

2) OAuth in Adobe AIR applications built with Flash or Flex

You can also download example code from here.

My tutorial about updating AIR apps packaged with a native installer was published on Adobe Developer Connection – it is available here.

It goes step-by-step through how a custom updater can be built for Windows; it also explains how a similar process could be applied for the Mac OS X platform.

This tutorial is also a good starting point to understand how my NativeApplicationUpdater library works.

Today I published my Resicon application to Adobe InMarket. At the moment Adobe InMarket is just a front end for online application stores like Adobe Marketplace or Intel AppUp. It’s goal is to make distribution and monetization of AIR based applications as simple as possible. Adobe is also working to integrate it with other online application stores as well.

The process of publishing my application was really straightforward. The first thing I had to do was to sign up to the InMarket service with my Adobe ID. Next I applied for the free code signing certificate (this is a really great promotional offer from Adobe because you get a trusted certificate completely for free). To get myself validated I had to fill in a form and have it faxed to the US phone number with my signature on it and a scan of my personal ID. I know it can be tricky to find the fax machine these days, but hey it is worth the effort .

After I got the certificate I was ready to do some additional steps on my application side. It only required me to copy and paste few lines of code that enable the LicenseManager API that comes with the InMarket SDK and its licensing.swc. In addition to the distribution and licensing, InMarket also provides the functionality for application updates. To enable it I only had to create a config folder with an updateConfig.xml file in my application directory structure. The updateConfig.xml is exactly the same file as you would use for standard AIR Update Framework.

Once all of the above steps were done I was ready to compile and sign my application. Next using InMarket portal I uploaded my *.air file and provided additional information like: an application description, screenshots, a and 495×250 px promotional image that will be displayed in the Adobe Marketplace.

After that done I was able to publish Resicon targeting both Adobe Markeplace and Intel AppUp stores with just a single click from a single place!

In my case the application is free but still I find it worth publishing it via InMarket since hopefully I will get wider distribution, place for hosting my application binaries and also nice reports with downloads stats etc. Those of you that will publish paid applications you can also see reports with numbers of: Trails, Purchases, Revenue, Activations and Trial to Purchase Histogram.

Really great resource with more in-depth information about InMarket is this wiki. You can also find links to the InMarket video tutorials on this page.

I wanted to share a video recording with an un-framework overview. This simple library has evolved a little bit from my previous post but I expect it will stay in this form for good I don’t think it can evolve to anything more sophisticated but I hope that it will serve as an inspiration to others when building their own sets of helpers. I plan to use it solely as a substitue for my favorite DI frameworks when doing mobile Flex development.

Those who know me or at least subscribe to my blog know that I’m a big fan of Flex/AS3 frameworks. At this year’s Adobe MAX conference I even had my own session where I covered five major DI frameworks. Usually these frameworks provide a lot of productivity features and helpers like: IoC/DI, Event/Messaging bus, implementation of some architectural or design patterns (MVC, Command…), and many others. But what happens if we can’t or don’t want to use any of these frameworks?

Well, we fall back to pure Flex and we start missing things…

This is something that happened to me very recently when I started to play with Flex Hero and I wanted to build my first Flex mobile application. As the targeted runtimes are rather constrained in processing power I knew I would have to make certain sacrifices in order to make things as light as possible.

First I started to wonder what general architectural pattern I should follow. After looking at Flex Hero and its new MobileApplication, ViewNavigator and View concepts, I knew that I was still okay with using the Presentation Model pattern.

Next I took a look at DI frameworks – well here I really didn’t find a suitable candidate. Most of these rely heavily on reflection, metadata processing, or stage events capturing for view wiring, and these unfortunately are not really very lightweight. That is why at the end of the day I made a decision not to use any of these, and instead decided to substitute some of their features with simple helpers or pure Flex functionality.

Global Event Dispatcher

The thing I missed most thing was a global dispatcher that I could use to dispatch events from my Presentation Model or any other pure AS3 classes. The approach I took was as simple as creating a global eventDispatcher property in the default package in a eventDispatcher.as file, as follows:

// eventDispatcher.as script file
 
package 
{
	import flash.events.IEventDispatcher;
 
	public function get eventDispatcher():IEventDispatcher
	{
		return _eventDispatcher;
	}
}
 
import flash.events.EventDispatcher;
import flash.events.IEventDispatcher;
 
var _eventDispatcher:IEventDispatcher = new EventDispatcher();

That step gave me access to eventDispatcher object anywhere in my code:

public class MyViewPM
{
    public function btn_clickHandler():void
    {
        eventDispatcher.dispatchEvent(new MyEvent(MyEvent.EVENT_TYPE));
    }
}

RemoteObject’s handling

The next thing I wanted was a clean and simple way of handling RemoteObject calls and configuration. What I really missed here was the approach from the Swiz Framework with its ServiceHelper.executeServiceCall function where you can pass an AsyncToken object returned from the RemoteObject call together with the ResultEvent and FaultEvent handlers as the other two parameters.

Another thing I really wanted was a declarative (MXML based) configuration of my RemoteObjects and to have a services registry without the use of ServiceLocator pattern. That is why the following code is a bit more complex but I think it’s still worth it and of course very light:

// remoteService.as script file
 
package
{
	import com.riaspace.un.IRemoteService;
 
	public function get remoteService():IRemoteService
	{
		return _remoteService;
	}
}
 
var _remoteService:IRemoteService = new RemoteService();
 
import com.riaspace.un.IRemoteService;
 
import mx.rpc.AsyncToken;
import mx.rpc.Responder;
import mx.rpc.remoting.Operation;
import mx.rpc.remoting.RemoteObject;
 
internal class RemoteService implements IRemoteService
{
	private var configObj:Object;
 
	public function set config(value:Class):void
	{
		configObj = new value();
	}
 
	public function getRemoteObject(remoteObjectId:String):RemoteObject
	{
		if (configObj)
			return configObj[remoteObjectId];
		return null;
	}
 
	public function callDirectly(token:AsyncToken, resultHandler:Function, faultHandler:Function):void
	{
		token.addResponder(new Responder(resultHandler, faultHandler));
	}
 
	public function call(remoteObjectId:String, methodName:String, args:Array = null, resultHandler:Function = null, faultHandler:Function = null):void
	{
		var remoteObject:RemoteObject = getRemoteObject(remoteObjectId);
		if (!remoteObject)
			throw new Error(remoteObjectId + " not configured!");
 
		var method:Operation = remoteObject[methodName];
		method.arguments = args;
		callDirectly(method.send(), resultHandler, faultHandler);
	}
}

As you can see you can use the above code in multiple ways. The first one requires no additional configuration and uses only remoteService.callDirectly function:

// some AS3 class
 
...
remoteService.callDirectly(myRemoteObject.remoteMethod(param), remoteMethod_resultHandler, 
    remoteMethod_faultHandler);
...
 
private function remoteMethod_resultHandler(event:ResultEvent):void
{
    // Handle remote method call result
}
 
private function remoteMethod_faultHandler(event:ResultEvent):void
{
    // Handle remote method call fault
}

The next option requires defining a config class that should extend simple Object; the best way is to do it in MXML like this:

// RemoteServiceConfig.mxml file
 
<?xml version="1.0" encoding="utf-8"?>
<fx:Object xmlns:fx="http://ns.adobe.com/mxml/2009" xmlns:s="library://ns.adobe.com/flex/spark">
 
	<fx:Declarations>
 
		<s:ChannelSet id="channels">
			<s:AMFChannel url="http://yourhost.tld/services/amf" />
		</s:ChannelSet>
 
		<s:RemoteObject id="myRemoteObject" destination="someDestination" channelSet="{channels}" />
 
	</fx:Declarations>
 
</fx:Object>

After you have your configuration class defined you can set it to the remoteService.config property, most probably somewhere at the very beginning of your application lifecycle:

// Main.mxml file
...
 
protected function mobileapplication_creationCompleteHandler(event:FlexEvent):void
{
    remoteService.config = RemoteServiceConfig;
}
 
...

So now you are ready to call the RemoteObject methods, and you can do that like this:

// some AS3 class
 
...
remoteService.call("myRemoteObject", "remoteMethod", [param], remoteMethod_resultHandler, 
    remoteMethod_faultHandler);
...
 
private function remoteMethod_resultHandler(event:ResultEvent):void
{
    // Handle remote method call result
}
 
private function remoteMethod_faultHandler(event:ResultEvent):void
{
    // Handle remote method call fault
}

Application context

The last thing I was really missing was some type of global application context/registry where I could read or write application objects. The approach I took goes beyond a simple singleton dynamic object. It is actually a bindable (event dispatching) singleton dynamic object You can see it’s implementation below:

// applicationContext.as file
 
package
{
	public function get applicationContext():ApplicationContext
	{
		return _applicationContext;
	}
}
 
var _applicationContext:ApplicationContext = new ApplicationContext();
 
import flash.events.Event;
import flash.events.EventDispatcher;
import flash.events.IEventDispatcher;
import flash.utils.Proxy;
import flash.utils.flash_proxy;
 
import mx.events.PropertyChangeEvent;
import mx.events.PropertyChangeEventKind;
 
use namespace flash_proxy;
 
internal dynamic class ApplicationContext extends Proxy implements IEventDispatcher
{
 
	private var values:Object;
 
	private var contextEventHandler:IEventDispatcher;
 
	public function ApplicationContext()
	{
		contextEventHandler = new EventDispatcher(this);
		values = new Object();
	}
 
	flash_proxy override function getProperty(name:*):*
	{
		return values[name];
	}
 
	flash_proxy override function setProperty(name:*, value:*):void
	{
		var oldValue:* = values[name];
		values[name] = value;
		var kind:String = PropertyChangeEventKind.UPDATE;
		dispatchEvent(new PropertyChangeEvent(PropertyChangeEvent.PROPERTY_CHANGE, false, false, kind, name, oldValue, value, this));
	}
 
	public function hasEventListener(type:String):Boolean
	{
		return contextEventHandler.hasEventListener(type);
	}
 
	public function willTrigger(type:String):Boolean
	{
		return contextEventHandler.willTrigger(type);
	}
 
	public function addEventListener(type:String, listener:Function, useCapture:Boolean=false, priority:int=0.0, useWeakReference:Boolean=false):void
	{
		contextEventHandler.addEventListener(type, listener, useCapture, priority, useWeakReference);
	}
 
	public function removeEventListener(type:String, listener:Function, useCapture:Boolean=false):void
	{
		contextEventHandler.removeEventListener(type, listener, useCapture);
	}
 
	public function dispatchEvent(event:Event):Boolean
	{
		return contextEventHandler.dispatchEvent(event);
	}
}

The way to use this is, of course, very simple:

// some AS3 class
...
applicationContext.myObject = new MyObject();
...
 
 
// another AS3 class
...
var myObject:MyObject = applicationContext.myObject;
...

The cool thing about this approach is that you can actually bind to your applicationContext.myObject without getting this nasty warning: unable to bind to property 'foo' on class 'Object' (class is not an IEventDispatcher).

Also if you would like to listen for changes done to applicationContext properties you can do it like this (in order to make code completion work you need to cast applicationContext to IEventDispatcher):

// some AS3 class
...
IEventDispatcher(applicationContext).addEventListener(
    PropertyChangeEvent.PROPERTY_CHANGE, applicationContext_changeHandler);
...

My UnFramework approach summary

So in the end you can see there is actually life without frameworks, especially when you are building not very complex applications that don’t require module support (in that case the singleton approach used here would fail).

Now please don’t accuse me of building yet another framework (we already have plenty of really great ones available) but I have packaged all these helper functions into a Flex Library project and pushed it into a GitHub repository. As I said this is not a framework so its called un-framework and it is available for download from here and as a swc from here.

Stay tuned for my upcoming posts where you will see these functions in action on some of my Flex Mobile apps.

Today I published a microsite (http://amf.riaspace.com/) on my blog dedicated to AMF communication. The goal of it is to gather necessary information needed for quick start with AMF.

You will find there:

• Publicly available AMF services for the start without setting up your own server environment
• Code snippets demonstrating how to utilize AMF services
• Video tutorials on how to setup your own Flex/Zend_Amf projects
• Demo applications with a source code

At the moment I’m hosting only PHP based services but I’m also thinking about Java based backend to be able to play with messaging.