News » Eric Feminella

The Flash Platform and Android

Rather than going into any detail regarding my thoughts surrounding Apple’s updated iPhone developer license clause last week, I instead prefer to focus on the more exciting and positive developments the future has to hold for the Flash Platform in the mobile space; and at the moment, it’s Android

As you may be aware, beginning with Adobe Flash Player 10.1, the AIR 2.5 for Android SDK and Android, the Flash Platform will now begin to close the gap in terms of developing and deploying Web, Desktop and Mobile applications. Thus it appears this could open up some very exciting possibilities in the RIA space as, a write-once, deploy-anywhere solution for Mobile, Web and Desktop applications is obviously highly desirable.

For those of you unfamiliar with Android, it is a premiere software stack for mobile devices which provides an Operating System built on the Linux kernal, a very well designed middleware layer and core applications including an E-mail client, SMS program, calendar, maps, browser, contacts and more. Android also provides an Application framework, a Dalvik virtual machine which is optimized for Mobile Devices, an integrated web browser based on the widely known WebKit engine, SQLite storage, common Media support, hardware dependent Bluetooth, EDGE, 3G, WiFi, Camera, GPS, Compass, and Accelerometer support as well as many other features.

Originally developed by Android Inc., which was later acquired by Google, Android is now governed by the Open Handset Alliance; a consortium devoted to advancing open standards for mobile devices. Currently, over 50 mobile phones are expected to come shipped with Android in 2010. Moreover, Google and their hardware partners are now shipping 60,000 Android handset units each day! If this trend continues (which it certainly appears will be the case) this equates to over 21.9 million devices shipping with Android per year.

Traditionally, getting started with Android has been quite simple for developers who have experience with Java as one need only download and unpack the Android SDK distribution and install the Android Development Tools (ADT) Eclipse plugin. Managing different Android platforms as well as other SDK components is accomplished via AVD Manager which come with the SDK. As expected, the Android SDK also comes with a very high quality device emulator which feels similar to the BlackBerry JDEs device Simulators.

While developing applications for Android with ADT is certainly convenient (and quite fun), from a Flash Platform development perspective it is much more desirable (as well as economical) for developers to leverage their existing skill-set and APIs to develop a single application targeting Flash Player or the AIR runtime that will work with any device shipped with Android. And with Flash Player 10.1 and the current private beta of Android AIR 2.0, the Flash Platforms reach will now include the Android platform. The most significant of these new possibilities is the ability to develop a single application which supports both Web and Mobile devices alike. Thus considerably simplifying the development and deployment process. Of particular interest is the ability to leverage Mobile Device specific features such as Accelerometer, GPS, multi-touch, gestures screen orientation etc. from an AIR application.

Flash Player 10.1 will support devices running on Android that meet the minimum software and hardware requirements, which at the moment appear to be devices with an ARM v7 (Cortex) processor. Both Droid and Nexus One carry ARM v7. Architecturally, I am quite interested in seeing how this all comes together in terms of memory and cpu optimization.

Working in conjunction with Adobe, as part of the Open Screen Project, Motorola is helping to develop Flash Player 10.1 so it works on Android. Motorola will also be deploying the Flash Player broadly across its Android product portfolio going forward; releasing Flash Player updates for existing devices such as the Droid (which I happen be actively developing for).

Adobe is targeting the end of July 2010 to have the Android AIR 2.0 Beta and Flash 10.1 for Android available. For updates sign up for:

Adobe Flash Player 10.1 Beta for Android Notification

Adobe AIR 2.0 Beta Android Notification

5 comments

Data Binding with AS3 Signals

Over the past few years the Presentation Model Pattern has picked up a lot of traction in the Flex world as it allows for an abstracted representation of a views model and state which can easily be tested. Core to it’s implementation is the facilitation of data bindings between a PMs model and a corresponding View’s controls. Implementing data bindings between a view and its associated PM is quite straightforward when leveraging data binding in Flex – simply annotate a property, getter or class with [Bindable] metadata. A basic example of which can be seen as follows:

public class UserInfoPresentationModel extends EventDispatcher
{
private var _user:User = null;

[Bindable(event="userChangeEvent")]
public function get country() : String
{
return _user.location.country;
}

private function updateUser(value:User) : void
{
_user = value;
dispatchEvent(new Event("userChangeEvent"));
}
// ….
}

Then a typical Flex data binding expression can be defined within a particular property of a control where the binding is to take place against the property of the Presentation Model instance:

<!– Define the view bindings to the Presentation Model –>
<?xml version="1.0" encoding="utf-8"?>
<s:Group xmlns:fx = "http://ns.adobe.com/mxml/2009"
xmlns:s = "library://ns.adobe.com/flex/spark"
initialize = "init();" >
<fx:Script>
<![CDATA[
// Define the views presentation model instance
[Bindable]
private var _pm:UserInfoPresentationModel = null;

privatefunction init() : void
{
_pm = new UserInfoPresentationModel();
}
]]>
</fx:Script>
<s:Label text="{ _pm.country}" />
</s:Group>

As you can see this is quite simple and easy to implement. But how does one accomplish this without the use of Flex’s native data binding facility?

This may seem like a rather moot question as its hard to imagine why someone would choose to not take advantage of Flex data binding to accomplish synchronizing a view with its PM. However, just recently I found myself in need of a solution for this problem…

I have been experimenting with AS3 Signals lately as I find them to be a nice alternative to Flash Player Events. This especially makes sense in the context of Presentation Models as, at least in my experience, event Bubbling within the display list simply isn’t necessary when binding a component to a property of a PM. Furthermore, while I am not particularly biased against Flash Players event model, its implementation is very much a black-box, and AS3 Signals allows for a good level of abstraction and control of the Signaling mechanism. So I contemplated how this may improve a Presentation Models implementation and decided to see how Signals could be implemented with a PM; however I first needed to find a solution which would allow Signals to provide the same functionality as data binding.

Essentially, implementing “pseudo” data bindings with AS3 Signals can be accomplished much the same as can be seen in BindingUtils. I developed a SignalDataBinding API which will feel somewhat familiar to those who have worked with BindingUtils in the past. SignalDataBinding provides an API allowing for the creation of pseudo data bindings within a Signal against a property of a host object which is facilitated via the creation of runtime functions which are managed by the API.

For example, suppose you are using AS3Signals and wanted to bind a label’s text property to the value of another object. With the SignalDataBinding API this could be accomplished as follows:

// Define the object which utilizes the Signal messaging API
public class TitleModel
{
private var _bindings:SignalDataBinding = null;
private var _titleChanged:Signal = null;
private var _title:String = null;

public function get title() : String
{
return _title;
}

public function set title(value:String) : void
{
_title = value;
_titleChanged.dispatch( value );
}

// Model class provides an API for property specific
// bindings while not exposing the underlying binding
// mechanism, thus allowing the data binding facility
// to be changed transparent to that of a client’s
// implementation.
public function addTitleBinding(host:*, property:*):void
{
_bindings.addBindableListener(_titleChanged, host, property);
}
}

Then, in the view from which the bindings are to be defined you would explicitly add bindings as follows:

<?xml version="1.0" encoding="utf-8"?>
<s:Group xmlns:fx = "http://ns.adobe.com/mxml/2009"
xmlns:s = "library://ns.adobe.com/flex/spark"
initialize = "init();" >
<fx:Script>
<![CDATA[
// Define the views presentation model instance
private var _pm:TitleModel = null;

private function init() : void
{
_pm = new TitleModel();

// Add binding between the Model’s ‘title’
// property and the views ‘titleLabel.text’
// property. Assignments to "title" will now
// be reflected in ‘titleLabel.text’
_pm.addTitleBinding( titleLabel, "text" );
}
]]>
</fx:Script>
<s:Label id="titleLabel" />
</s:Group>

And that’s basically it. Additional levels of abstraction could easily be defined in order to provide common base classes which encapsulate the SignalDataBinding instance etc. Additionally, I do not see any reason why the SignalDataBinding API could not be utilized in AS3 projects as well as Flash projects; for the underlying implementation has no dependencies on the Flex Framework. Thus the SignalDataBinding API could be leveraged in any AS3 project as is, or adapted to implement the Flash Player Event model to provide a BindingUtils implementation for AS3 and / or Flash Projects.

You can view a basic example as well as download the SignalDataBinding API source, docs and binary.

March 22, 2010 News

6 comments

Global Error handling in Flash Player 10.1

A few years back I had the need to write a global exception management framework in order to provide a means from which unhandled errors could be handled gracefully throughout an application. Initially, I assumed there must be a listener available which could be added to SystemManager or Application, and from there all unhandled errors could be caught; however, after spending many hours trying to find a solution, it seemed this wasn’t possible to achieve in the Flash Player API at the time.

Just recently I found myself once again in need of such an API, and thought there may be something new in Flash Player 10 that I wasn’t aware of. However, as it turns out the only thing I was able to find actually happened to be in the Adobe Bug database; specifically, issue FP-444. It was then that I referenced the feature set for the next revision of Flash Player – version 10.1, and learned that in addition to many other significant new enhancements Flash Player 10.1 will finally introduce the ability to manage exceptions globally!

This is an invaluable feature for all Flash based applications as it will allow for the ability to add a global listener from which you can catch any and all uncaught RTEs. The ability to provide a global exception management mechanism will undoubtedly improve Flash applications significantly as uncaught RTEs can then be handled gracefully by responding to the user accordingly.

This may be one of those new features that isn’t necessarily the main focal point in marketing campaigns. However, it is APIs like this that make life for developers (and QA) much easier and, equally as important, ultimateky have huge payoffs for users.

Coincidentally, this also just so happens to coincide with an open source Exception Framework I am planning to release. The framework will provide a foundation from which more robust exceptions can be defined (in comparison to the generic Error class), as well as common exception types which implement the framework. So if you are interested, check back soon as I plan to publish the framework this month.

November 8, 2009 News

3 comments

Maven dependency resolution with javacio.us

Ever need to determine what versions of a specific Maven dependency are available in a public repository? Or more importantly, determine if a dependency even exists in a public repository? If so, then javacio.us, a free, subscription based service available to anyone with a Google account can be used to help quickly and easily resolve maven dependencies.

Usage is simple:

Search Google for the name of the dependency (e.g. concurrent pom) and you will get a list of all groups in which the dependency is under a public repository.
Select the specific group you require
Select the version you require

And that’s it! Now you can simply copy the coordinates and the dependency has been resolved.

While there are certainly other services available which do more or less the same thing (e.g. Maven Repository Browser, etc.), the simplicity of being able to just search from Google is rather convenient.

October 21, 2009 News

No comments

Thoughts on Cairngorm 3

A week or so prior to MAX, the Cairngorm committee had a rather interesting discussion, during which Alex outlined what the team at Adobe Technical Services had been considering for Cairngorm 3. The meeting was focused on providing everyone with an overview of the collective ideas which Adobe had been gathering internally for some time now, and to also inquire feedback prior to the public announcement of Cairngorm 3.

Prior to the meeting I had anticipated the discussion would be based around a few new patterns and best practices which are currently being advocated, and possibly some additional libraries which help to address recent challenges in RIA development. However, what we discussed was actually quite different – in a good way.

As you are probably aware by now, Cairngorm 3 is focused around tried and tested best practices and guidelines which aid Flex developers in providing solutions to their day to day RIA challenges. These guidelines are primarily based upon that which has been realized by Adobe Technical Services, and also from the Flex community at large. Teams can leverage these guidelines where applicable to help deliver successful RIAs using frameworks of their choosing. While there may be specific frameworks and libraries recommended in Cairngorm 3, these are just that – recommendations. There is generally a framework agnostic approach which I must emphasize is highly preferable to that of suggesting one framework over another. This is precisely what I think is needed in the Flex community, for there is rarely a one size fits all approach to software architecture, especially in terms of specific framework implementations. This is a pretty easy concept to comprehend, as, what works for one team, in one context, may not always be appropriate for another team, or in another context.

Cairngorm 3 is a step forward towards what (IMHO) should be a general consensus in the Flex community at large; there are many existing frameworks out there which help address specific problems, with each providing unique qualities and solutions in their own right. This is the kind of thought leadership which helps a community progress and grow; it should be encouraged, as allowing for the shared knowledge of fundamental design principles and guidelines is something which provides value to all Flex developers, regardless of which framework they happen to prefer.

If there is one suggestion I would propose, it would be to have an entirely new name for these collections of best practices, guidelines and general Flex specific solutions. Personally, I would like to see the name Cairngorm (which, after all these years, I still pronounce as Care-in-gorm) refer to the original MVC framework, i.e. the framework implementation itself, as keeping the name the same while undergoing a different direction is bound to cause confusion to some extent. Whatever the new name would be is insignificant as long as the original name of Cairngorm applied to that of the actual framework implementation. This would perhaps be more intuitive as it would allow for the name Cairngorm to be used to describe a concrete framework as a potential solution, just as one could describe other frameworks; e.g. Spring ActionScript, Mate, Swiz, Parsley, Penne, Model-Glue, PureMVC, Flicc etc.

Most importantly, however, is the prospect of choice, as choice is always a good thing. Moreover, an initiative being lead by Adobe in this area sends a very good message to the Flex community as a whole. I happen to leverage a number of different frameworks and patterns which address different problems. As new problems arise, I employ new solutions where existing solutions may not suffice, or develop custom solutions where none are currently available; never blindly choosing one solution over another. However, in every case, there are typically some basic, fundamental guidelines which hold true and can be followed to help drive a design in the right direction. Regular readers of this blog have probably noticed that the basis of the majority of my posts are heavily rooted within these fundamental design principles, as it is from these fundamental design principles and guidelines that developers can utilize the frameworks which work best for them in order to and meet their specific challenges.

Essentially, Software Architecture is all about managing complexity, and there are many fundamental patterns and guidelines which can help developers mange this complexity. The specific framework implementations are of less concern, for it is the understanding of these patterns and principles – and more importantly, when to apply them, which will ultimately drive the decisions to leverage a one framework over another. In my experience, I have found that the only constant in software architecture is that a pragmatic approach should be taken whenever possible, whereby context is always key, and simplicity is favored as much as possible. Cairngorm 3, I feel, is a nice illustration of this principle.

October 18, 2009 Agile / Design Patterns / News / Test Driven Development

4 comments

Why is programming fun?

Just recently while going through some old files I rediscovered a quote I found a long time ago that is rather inspiring.

The quote is an extract from the book “The Mythical Man-Month”, and while the book was originally published in 1974 before being republished in 1995, I feel it will always remain relevant:

Why is programming fun? What delights may its practitioner expect as his reward?

First is the sheer joy of making things. As the child delights in his mud pie, so the adult enjoys building things, especially things of his own design. I think this delight must be an image of God’s delight in making things, a delight shown in the distinctness and newness of each leaf and each snowflake.

Second is the pleasure of making things that are useful to other people. Deep within, we want others to use our work and to find it helpful. In this respect the programming system is not essentially different from the child’s first clay pencil holder “for Daddy’s office.”

Third is the fascination of fashioning complex puzzle-like objects of interlocking moving parts and watching them work in subtle cycles, playing out the consequences of principles built in from the beginning. The programmed computer has all the fascination of the pinball machine or the jukebox mechanism, carried to the ultimate.

Fourth is the joy of always learning, which springs from the non-repeating nature of the task. In one way or another the problem is ever new, and its solver learns something: sometimes practical, sometimes theoretical, and sometimes both.

Finally, there is the delight of working in such a tractable medium. The programmer, like the poet, works only slightly removed from pure thought-stuff. He builds his castles in the air, from air, creating by exertion of the imagination. Few media of creation are so flexible, so easy to polish and rework, so readily capable of realizing grand conceptual structures.

Yet the program construct, unlike the poet’s words, is real in the sense that it moves and works, producing visible outputs separately from the construct itself. It prints results, draws pictures, produces sounds, moves arms. The magic of myth and legend has come true in our time. One types the correct incantation on a keyboard, and a display screen comes to life, showing things that never were nor could be.

Programming then is fun because it gratifies creative longings built deep within us and delights sensibilities we have in common with all men.

This quote really hits home with me, so I shared it with my team and felt I should also share it with the community, as I imagine it will also inspire all of you as well.

September 16, 2009 Agile / News

7 comments

Open Source AS3 APIs

For the past 4 years or so I have provided quite a few AS3 APIs as Open Source to the Flex Community, via my blog. These APIs can typically be found at the Open Source AS3 APIs page however, the page is basically just a URI to a series of arbitrarily added AS3 source classes. It was originally intended to simply serve as a convenient location to access the source, and it had always been my intention to eventually break out all of these APIs into seperate SVN projects.

So with that being said I am finally in the process of making the structural changes I had originally envisioned. Moving forward I will begin the process of creating seperate SVN projects for these Open Source APIs; with the primary goal being to provide practical APIs that only require minimal (if any) dependencies on additional libraries, complete test coverage via Flex Unit 4 and Mavenized builds.

The first project to move over to the new project structure will be the AS3 collections project as the classes in this package, specifically HashMap, have proven to provide the most value according to community feedback.

So stayed tuned!

August 30, 2009 APIs / News / Refactoring / Test Driven Development

8 comments

AS3 Quick Tip: Object.setPropertyIsEnumerable

Most ActionScript developers are very familiar with Anonymous Objects in ActionScript 3.0 as they provide a convenient mechanism from which properties of an object which are not known at design time can be defined at runtime. This post is just a quick tip on the Object.setPropertyIsEnumerable() method, for more detailed information on using Objects in ActionScript 3.0 visit livedocs.

The Object class has a few useful methods, specifically toString();, hasOwnProperty(); and propertyIsEnumerable();. There is also another method of the Object class which is very useful: setPropertyIsEnumerable() which can be utilized to explicitly omit a property from being included in an enumeration of an object.

Consider the following example:

var object:Object = { propA: "value A",
propB: "value B",
propC: "value C" };

var isEnumerable:Boolean;
isEnumerable = object.propertyIsEnumerable( "propA" );
// true
isEnumerable = object.propertyIsEnumerable( "propB" );
// true
isEnumerable = object.propertyIsEnumerable( "propC" );
// true

for (var prop:String in object)
{
trace( prop + " = " + object[prop] );
}
// propA = value A
// propB = value B
// propC = value C

When enumerating the object instance all properties and their values can easily be retrieved, however it is important to keep in mind that when enumerating an Object the order in which properties are retrieved is not guaranteed. So executing the same loop against the same object instance could yield different results each time, such as “value B, value A, value C” as opposed to what you might have expected, i.e. “value A, value B, value C”.

Now suppose you do not want a property to be exposed via an enumeration of the object, this can be achieved via:

Object.setPropertyIsEnumerable( property, true | false );

So based on the above examples, if we did not want to expose the “propA” property in a for in… loop we could omit the property as follows:

var object:Object = { propA: "value A",
propB: "value B",
propC: "value C" };

object.setPropertyIsEnumerable( "propA", false );

var isEnumerable:Boolean;
isEnumerable = object.propertyIsEnumerable( "propA" );
// false
isEnumerable = object.propertyIsEnumerable( "propB" );
// true
isEnumerable = object.propertyIsEnumerable( "propC" );
// true

for ( var prop:String in object )
{
trace( prop + " = " + object[prop] );
}
// propB = value B
// propC = value C

So when you need to omit properties from being included in an enumeration of an object, Object.setPropertyIsEnumerable(); proves very useful.

December 29, 2008 News

3 comments

Cairngorm moving forward

This week Adobe announced that Cairngorm has been moved to from Labs to opensource.adobe.com.

So what does this mean for you, as a developer, building RIAs targeting the Adobe Flex platform on top of Cairngorm?

It means a lot.

The most significant being that Cairngorm now has a formal community based initiative. This in itself facilitates positive growth as it encourages community feedback and collaboration. It allows the community to have an open podium for discussion, collaboration and most important, knowledge sharing.

So how can you contribute? To begin, start by signing up as a member and sharing your thoughts and experiences. Get involved; engage in conversations with the rest of the community. Take a look under the hood; get to know Cairngorm internals (if you don’t already).

I have a lot of confidence in the future of Cairngorm and I think we can all expect good things to come.

August 8, 2008 Agile / Design Patterns / News

No comments

Embedding assets with ResourceBundle

Here’s a quick tip you won’t find easily on live docs…

Yesterday I found myself needing to embed assets in a .properties file (ResourceBundle) however after looking through the Flex documentation I wasn’t completely satisfied with the examples that were available. So I tried something pretty simple and it works perfectly.

To embed an external asset such as an image, audio file, font etc you need only specify an embed directive just as one normally would for an asset, and the file will be embedded in the application. This approach is very much like using the embed directive to embed assets in CSS but only with properties files instead.

For example, suppose you wanted to embed an image named, “image.jpg” using a properties file. To do so simply define the image as follows:

IMAGE = Embed(source="image.jpg")

Then to display the embedded image simply reference the class object to which it has been embedded as follows:

ResourceManager.getInstance().getClass("images", "IMAGE");

And that’s it. Same applies for all embedded assets. I also provided a quick example as well – complete with my son Anthony on the Piano!.

August 4, 2008 News

4 comments

Eric Feminella

Thoughts on Software Design and Development