While there are countless reasons as to their success, I believe each benefited from similar strategies that can also improve your odds of winning.

Content is King

It’s a basic business principle – if you don’t have what people want they will seek it elsewhere. So where could this content come from? Well, there are (2) basic types from my perspective:

1. Specialized
2. Generalized

If your content is specialized or concentrated around a particular subject, it has to be truly compelling to gain mindshare of potential viewers as the outlets available are astounding and growing daily.

If your content isn’t married to a particular subject then you need an abundance to create the foundation for “sticky” sessions that will have your viewers losing track of time as they peruse your library of content which you have carefully woven together using tags, keywords, etc.

Specialized content may be the easiest to acquire initially but requires a greater effort to maintain over time. Your content would have to generate enough buzz that people are constantly engaging in a dialogue either on your site or around the Internet.

Even if that were to happen, the window of opportunity is finite. Also, the time and financial costs can become exorbitant rather quickly which has the effect of constantly diminishing your rate of return making this path an unattractive one.

Generalized content is typically the complete opposite, being harder to acquire initially but requiring less effort to maintain over time. How you reduce the maintenance effort is by taking advantage of the social network which is more than willing to help you in your cause. And, due to the constant advances in modern technology, this social workforce is becoming increasingly capable of sustaining your efforts.

Recruit Social Videographers

If you build it, they will come. Everyday more and more people are discovering the massiveness of the social network. And, because of the social nature of this network, people are looking for ways to make their presence known, to participate, to have a voice, to socialize.

What you must provide them is a solid platform on which to do so. If you can make it easy for potential users to either generate content or upload existing content into your system, you are well on your way. But, you also need the capability to syndicate that content across the social network.

The more outlets you can tap the more appealing you become to your users who are appreciative for you making their lives easier. This good-will generally equates to positive word-of-mouth which can help propel your endeavor into the stratosphere.

With a limitless army of social videographers now working together with you, quantity of content should never be an issue again. All you would need to do is implement any kind of quality control mechanisms, if so desired, to keep submissions inline with your overall strategy, brand, etc. At the end of the day, you’ll have a mountainous library of content while rewarding your users with a media platform for social expression.

Multiscreen/Multidevice

Once you have content that people want to see, you need to enable them to view it in as many configurations as possible. The more accessible your content is, the greater its reach. The potential for your content to go “viral” is dramatically increased if it’s available across all the desktop browsers, as well as, available on iOS and Android phones and tablets.

Guarantee the most bang for your buck by investing the time and money necessary to extend your content library to these screens and devices. You get an additional bonus if you can also extend user content generation to these devices as well. You will be glad that you did and your users will love you for it.

Adapt to Tech Changes

Adaptability is extremely crucial to reaping the rewards of a social media strategy. You can improve your adaptability but having a firm understanding of not only how users have communicated in the past, are communicating now but how they might communicate in the future.

Future communications is not only subject to end user desires and needs but also to shifts in the underlying technology that enables these communications. Some things worthwhile to remain aware of:

1) New mediums, screens or devices available to deliver your content (eg, TVs, kiosks, etc)
2) Costs associated with the storage and delivery of your content (eg, disk space, bandwidth, etc)
3) Emergence of new video codecs or license changes in existing ones

The list goes on and on but the key is to start thinking about those things today so they don’t bite you tomorrow.

Use Twitter and Facebook to Promote

So, you’ve amassed an impressive library of content that’s steadily fueled by a sea of social videographers. You’ve made your content and content generation accessible across multiple screens and devices plus you’re ready for whatever the future holds.

Now all that’s left to do is to help your promoters promote. Not only must you integrate Twitter and Facebook for your users so they can spread the word, but you must also engage the social network through – you guessed it, Twitter and Facebook.

It’s simple. The more personable you are or are perceived, the greater your reach. Remember, this is a social network so when you “mingle” with people act like it. Don’t engage contacts like a cold, callous enterprise machine. If you do, you won’t be well received.

On the same note, you can’t be reckless either. Instead, let your corporate ethos serve you well by ensuring all communications are refined, responsive and informative yet relaxed. You want each contact to walk away with a positive experience because it’s that experience they will share with others thereby defining your social brand.

THE END

These are my thoughts and I’m sticking to them. What do you think? Post a comment or question.

At some point I’d like to discuss revenue generation as a follow-up to this article.

• L2709_Presentation.ppt
• L2709_Workbook.pdf
• FlashP2PLib.fxpl
• MAX2011MobileVideoChat.fxp
• EyeChat.fxp
• EyeChatDesktop.fxp

The last two projects are completed versions that you can use for testing or to skip ahead.

I plan to follow up with posts related to the P2P logic used in this sample application. Any questions, let me know. Thanks to all who attended!!

L2709_DSMVCA.zip

The business world today is much more empowered; empowered to act and react to dynamic changes often the moment they occur. For your organization to reap the benefits of the social media phenomenon, you must adapt and become more flexible in how you engage your customers, partners and community. To do so involves cultivating social connections that focus on solving business and customer challenges rather than the traditional PR techniques of selling your prospects on just how great you are.

Now that you’ve established the need for a social strategy there are a few things that should be done before you actually devise the strategy.

A) Help the CEO formulate a social media strategy team that will include internal leaders and managers spanning the entire organization.

The social team’s job will be to help create the strategy and oversee its implementation. As internal buy-in is critical to overall strategy success, the choices made in team selection are extremely crucial. Remember, you can’t build success on a rocky foundation.

Once the team is assembled, it wouldn’t hurt to…

B) Conduct a session with your company’s executive team where you explore social tech’s ability to and success in transforming organizations.

Be sure to fully explore how the same and more can be realized by your organization. Once the seeds have been planted and the bosses are on board, you can start building out your strategy. And because you’re building on a solid foundation, you should really be able to maximize your competitive advantage by following sound principles catered to your unique value position. Does this guarantee you’ll be the next Facebook or Twitter? No, but it will guarantee a much better fate than just blindly approaching the socialsphere, hoping for the best.

Based on a recently published Forrester Research report, Social Business Strategy, there are four key ingredients to a successful social business strategy:

#1 Know Thy Neighbor
There’s no way that you can create value through social engagement if you don’t truly understand who your employees and customers are, as well as, how they use social technology. According to Forrester, 62 million US adults visited a social networking site at least monthly between 2007 – 2010 representing a 50% increase in social networking usage.

#2 Define Your Goals
What do you expect to achieve by becoming more social? Do you want to improve customer perception? Increase customer sat? Increase sales? Whatever the case may be, get specific, associate each goal with a strategy and detail the steps to achieve the goal. Once that’s established, review what emerging social technology trends make the most sense in support of accomplishing your goals.

#3 Weigh the Pros and Cons
Determine which of your goals has the greatest output (return) for the least input (investment). Don’t get caught up in ego. Realistically assess the risk, effort and complexity of each goal/strategy so you can formulate the clearest picture of which ones should be pursued and which ones to abandon. If a project requires a high investment with very little return, it should be tossed. On the other hand, if you discover a gem of a project that essentially costs nothing to implement but yields untold riches, be smart and fast-track that one.

#4 Pick the Right Tool for the Job
You’ll likely need a myriad of services to support your golden social strategy so choose wisely. Explore all your options whether it be SaaS, PaaS or even IaaS. Determine which ones integrate with your existing infrastructure the best. You ultimately want your technology selection to be the icing on your well baked plan.

I’ve personally found success with this approach and feel that it can effectively be applied to a variety of operational/strategical models. How about you?

RELATED RESOURCES
http://www.forrester.com/rb/Research/social_business_strategy/q/id/57541/t/2

The only problem is this new functionality only works out of the box for NativeWindow instances. A Spark Window, however, manages its NativeWindow internally and does not currently include support for the new owned window logic. Now, you could subclass Window and override commitProperties to add in the functionality but, that’s neither desired nor maintainable.

Why does it even matter? Because a Spark Window is skinnable and if you’ve already taken the time to build an application using skinnable Windows, you don’t want to labor over the changes necessary just to use this functionality.

So, I chose to take a different approach because I’m confident that the AIR SDK will eventually include support for ownable Spark Windows. Until then, I’m using an OwnableWindow interface that all of my Window subclasses I want to be owned are required to implement. This way I can take advantage of the new functionality in the least obtrusive way possible.

Here’s the code for OwnableWindow:

package labs.otuome.air.myapp.view.panel
{
   import flash.display.NativeWindow;
   import flash.events.Event;
   import flash.events.NativeWindowDisplayStateEvent;
 
   public interface OwnableWindow
   {
      function get windowOwner():NativeWindow;
      function set windowOwner( value:NativeWindow ):void;
 
      function respondToOwnerWindowActivated( event:Event ):void;
      function respondToOwnerWindowMinimizedOrRestored( event:NativeWindowDisplayStateEvent ):void;
      function respondToOwnerWindowClosing( event:Event ):void;
   }
}

Now, in my Spark Window subclass I implement the interface like so:

package labs.otuome.air.myapp.view.panel
{
   import flash.display.NativeWindow;
   import flash.display.NativeWindowDisplayState;
   import flash.events.Event;
   import flash.events.MouseEvent;
   import flash.events.NativeWindowDisplayStateEvent;
 
   import mx.events.FlexEvent;
 
   import spark.components.Button;
   import spark.components.RichText;
 
   /**
    * Spark Window component subclass.
    * @author Hasan Otuome
    */
   public class FloatingPanelView extends FloatingPanelUI implements OwnableWindow
   {
      ///////////////////////////////////////////////////////////////////////////
      // PRIVATE PROPERTIES
      ///////////////////////////////////////////////////////////////////////////
      private var _panelTitle:String;
      private var _windowOwner:NativeWindow;
      //////////////////////////////////////////////////////////////////////////
      // PUBLIC PROPERTIES
      /////////////////////////////////////////////////////////////////////////
      [SkinPart (required=false)]
      public var header:Button;
 
      [SkinPart (required=false)]
      public var toggle:Button;
 
      [SkinPart (required=false)]
      public var contentTitle:RichText;
 
      /**
      * Sets the panel's title. 
      * @param value
      */		
      public function set panelTitle( value:String ):void
      {
           _panelTitle = value;
      }
      /**
      * Allows you to specify an owner for this Spark 
      * Window instance. Used only until the Flex SDK 
      * adds support for owned native windows to Spark 
      * Windows.
      */		
      public function get windowOwner():NativeWindow
      {
           return _windowOwner;
      }
      public function set windowOwner( value:NativeWindow ):void
      {
           _windowOwner = value;
      }
      ///////////////////////////////////////////////////////////////////////////
      // PUBLIC METHODS
      ///////////////////////////////////////////////////////////////////////////
      /**
      * Constructor 
      */		
      public function FloatingPanelView()
      {
        super();
 
        addEventListener( FlexEvent.CREATION_COMPLETE, _onCreationComplete, false, 0, true );
      }
      //---------- OwnableWindow implementations --------------------
      /**
      * Adjust the display ordering of this 
      *	instance as it relates to its owner. 
      */
      public function respondToOwnerWindowActivated( event:Event ):void
      {
        this.nativeWindow.orderInFrontOf( _windowOwner );
      }
 
      /**
      * Show/hide this instance based 
      *	on the display state of its owner. 
      */
      public function respondToOwnerWindowMinimizedOrRestored( event:NativeWindowDisplayStateEvent ):void
      {
        switch (true)
        {
           case (event.beforeDisplayState == NativeWindowDisplayState.MINIMIZED):
             this.restore();
             break;
           case (event.afterDisplayState == NativeWindowDisplayState.MINIMIZED):
             this.minimize();
             break;
        }
      }
 
      /**
      * Close this instance when its owner is closed. This 
      *	will be handled automatically if the owner is 
      *	the main application window.  
      */
      public function respondToOwnerWindowClosing( event:Event ):void
      {
        this.close();
      }
      //////////////////////////////////////////////////////////////////////////
      // OVERRIDES
      /////////////////////////////////////////////////////////////////////////
 
      ////////////////////////////////////////////////////////////////////////
      // PRIVATE METHODS
      ///////////////////////////////////////////////////////////////////////
      /**
      * CREATION_COMPLETE event handler. 
      * Ensures this instance responds to 
      * display state changes of the 
      * instance's owner. 
      * @param e
      */		
      private function _onCreationComplete( e:FlexEvent ):void
      {
        if (_windowOwner)
        {
           _windowOwner.addEventListener( Event.ACTIVATE, respondToOwnerWindowActivated, false, 0, true );
           _windowOwner.addEventListener( NativeWindowDisplayStateEvent.DISPLAY_STATE_CHANGE, respondToOwnerWindowMinimizedOrRestored, false, 0, true );
           _windowOwner.addEventListener( Event.CLOSING, respondToOwnerWindowClosing, false, 0, true );
        }
 
        removeEventListener( FlexEvent.CREATION_COMPLETE, _onCreationComplete );
      }
   }
}

I set the windowOwner property when I instantiate the class(es) and I have a skinnable Spark Window(s) that can be owned by another NativeWindow. Downside is that the z-ordering produces a noticeable flicker and only works on the 1st click of the owner window.

Did I have to use an interface? Not at all, but it’s nice to be able to enforce the contract and easily tear it up once it’s no longer needed. Taking a different approach? Share it…

• Cost savings (e.g. lower taxes, cheaper labor, etc)
• Quality improvement
• Reduced time to market
• Capacity management
• Risk management/mitigation
• Scalability

During the late 90s and early 00s, there was a definite boom in offshore outsourcing a/k/a offshoring where mega-corporations were able to take advantage of large resource pools in lower cost economies due to an extremely disparate gap in wages that existed between the industrialized nations seeking to outsource and the developing nations providing the services. It was not uncommon to see companies like HP outsource their entire customer support operations to call centers in Hong Kong, Shanghai or Bangladesh. When planned effectively, those kinds of strategic business decisions have shown the potential to reap generous dividends on a relatively low-cost investment.

In the US, there has always been mixed emotions/views on outsourcing. Opponents claim it leads to job displacement, especially as it relates to offshoring. Supporters argue that offshoring actually lowers prices thereby yielding a greater overall economic benefit. Regardless of the position taken, the decision to offshore often carries its own set of consequences and repercussions that must be accounted for and dealt with such as:

• Physical distance (ie, geographic proximity, time zones, etc)
• Quality of service
• Language/cultural barriers
• Security issues
• Governmental policies/restrictions

Considerations like these coupled with the recent global economic downturn and the proliferation of cloudsourcing have cooled the heels of the once agressive business strategists to take a slower, more stable approach to offshoring in particular and outsourcing in general. This change in landscape, attitude and strategy has given rise to alternatives like nearshoring and as a result, has seeded socio-economic growth in neighboring countries like Brazil, Chile, Canada and Mexico.

What makes nearshoring appealing is that it allows an organization to mitigate several of the concerns/risks associated with offshoring while still reaping the benefits that an outsourcing strategy provides. By providing increased flexibility for organizational alignment, nearshoring can be an effective means to increase ROI.

Eventually, business strategists may shift back towards insourcing as some analysts suggest. This will especially become true as the once developing nations become more industrialized and the labor cost savings increasingly diminish. Would that signal the death of outsourcing? Hardly. I believe outsourcing is here to stay and will see increased/decreased implementation as market and economic conditions dictate. What do you think?

Enter: ANT to the rescue!

By creating an ANT build script, you can alleviate all of the above concerns and stay super-flexible at the same time. Here’s a template that I’ve been using lately with great success:

<?xml version="1.0" encoding="UTF-8"?> 
<project default="4. Package Application" name="[Your Flex Project Name]"> 
	<!-- Framework properties -->
	<property name="FLEX_HOME" value="[/path/to/your/flex/4.5/sdk]" /> 
	<property name="AIR_GLOBAL" value="${FLEX_HOME}/frameworks/libs/air/airglobal.swc" /> 
	<property name="ADL" value="${FLEX_HOME}/bin/adl" /> 
	<property name="ADT" value="${FLEX_HOME}/lib/adt.jar" /> 
	<property name="PFI" value="${FLEX_HOME}/lib/pfi.jar" /> 
	<property name="FLEX_TASKS" value="${FLEX_HOME}/ant/lib/flexTasks.jar" /> 
	<property name="LOCALE" value="en_US" /> 
 
	<!-- Project properties --> 
	<property name="project_root" value="[/path/to/your/flex/mobile/project]" /> 
	<property name="class_path" value="${project_root}/src" /> 
	<property name="lib_path" value="${project_root}/libs" />
	<property name="splash_path" value="${class_path}/Default.png" /> 
	<property name="app_name" value="[YourApp]" /> 
	<property name="app_root_dir" value="." /> 
	<property name="app_type" value="mxml" /> 
	<property name="assets_dir_name" value="[name_of_your_assets_dir]" />
	<property name="debug_mode" value="false" />
 
	<!-- Certificate properties --> 
	<property name="cert_loc" value="${app_root_dir}/[path/to/your/certs]" />
	<property name="ios_keystore" value="${cert_loc}/[your_cert_name].p12" /> 
	<property name="ios_pass" value="[your_cert_password]" />
	<property name="ios_provisioning" value="${cert_loc}/[your_provisioning_profile].mobileprovision" />
 
	<!-- Application properties -->
	<property name="swf_file" value="${app_name}.swf" /> 
	<property name="air_file" value="${app_name}.air" /> 
	<property name="ipa_file" value="${app_name}.ipa" /> 
	<property name="app_descriptor" value="${class_path}/${app_name}-app.xml" /> 
	<property name="main_class" value="${class_path}/${app_name}.${app_type}" />
	<property name="build_dir" location="${app_root_dir}/build" /> 
	<property name="debug_dir" location="${app_root_dir}/build/debug" /> 
	<property name="publish_dir" location="${app_root_dir}/build/deploy" /> 
	<property name="assets_dir" location="${class_path}/${assets_dir_name}" />
	<property name="output_loc" location="${publish_dir}/${swf_file}" />
 
	<!-- Use the Flex ANT tasks for easier compilation -->
	<taskdef name="mxmlc" classname="flex.ant.MxmlcTask" classpath="${FLEX_TASKS}"/>
 
	<!-- Clean existing directories --> 
	<target name="1. Cleanup Directories" description="clean up"> 
		<delete dir="${debug_dir}" /> 
		<delete dir="${publish_dir}" /> 
		<delete dir="${build_dir}" /> 
	</target> 
 
	<!-- Create required directories --> 
	<target name="2. Build New Directories" depends="1. Cleanup Directories"> 
		<mkdir dir="${build_dir}" /> 
		<mkdir dir="${debug_dir}" /> 
		<mkdir dir="${publish_dir}" /> 
	</target>
 
	<!-- Compile SWF to build-directory for packaging --> 
	<target name="3. Compile SWF" depends="2. Build New Directories"> 
		<mxmlc 
			file="${main_class}" 
			output="${output_loc}" 
			locale="${LOCALE}" 
			static-rsls="false" 
			accessible="false" 
			configname="airmobile" 
			debug="${debug_mode}" 
			failonerror="true" 
			fork="true" 
			maxmemory="512m">
			<source-path path-element="${class_path}"/>
			<compiler.library-path dir="${FLEX_HOME}/frameworks" append="true">
				<include name="libs/*" />
			</compiler.library-path>
			<library-path file="${FLEX_HOME}/frameworks/locale/${LOCALE}" append="true"/>
			<library-path dir="${lib_path}" includes="*.swc" append="true"/>
			<external-library-path file="${AIR_GLOBAL}" append="true"/>
		</mxmlc>
	</target>
 
	<!-- Package the application to an ipa file & save it in the publish directory --> 
	<target name="4. Package Application" depends="3. Compile SWF"> 
		<java jar="${ADT}" fork="true" failonerror="true"> 
			<arg value="-package"/>
			<arg value="-target"/>
			<arg value="ipa-test"/>
			<arg value="-provisioning-profile"/>
			<arg value="${ios_provisioning}"/>
 
      			<arg value="-storetype"/>
			<arg value="pkcs12"/>
			<arg value="-keystore"/>
			<arg value="${ios_keystore}"/>
			<arg value="-storepass"/>
			<arg value="${ios_pass}"/>
 
			<arg value="${ipa_file}"/>
			<arg value="${app_descriptor}"/>
			<arg value="${output_loc}"/>
 
			<arg value="-C" /> 
			<arg value="${class_path}"/>
			<arg value="${splash_path}"/>
 
			<arg value="-C" /> 
			<arg value="${class_path}"/>
			<arg value="${assets_dir}/icons/." /> 
		</java> 
	</target>
</project>

UPDATED 3/23/11: changed the Package Application target to use ADT vs PFI now that AIR 2.6 is official.

You should only have to modify the values wrapped in brackets [ ] to match your system setup. Once that’s done, you’ll need to tweak your application’s descriptor file (ie, myapp-app.xml) as follows:

#1 Modify the initialWindow’s content value to match the output path from your ANT script:

<content>[This value will be overwritten by Flash Builder in the output app.xml]</content>

becomes:

<content>/path/to/your/application.swf</content>

#2 Add the following iOS-required data, either before or after the Android data section:

<iPhone>
    <InfoAdditions><![CDATA[
<key>UIDeviceFamily</key>
<array>
<string>1</string>
<string>2</string>
</array>
]]></InfoAdditions>
    <requestedDisplayResolution>high</requestedDisplayResolution>
</iPhone>

After that, you should be able to compile your app using the ANT script without problem from any IDE that supports ANT or even from the CLI. This certainly isn’t the only way to accomplish this, it’s just my take on it. Feel free to hack away at it and share what you come up with.

If you should decide to bypass the template and build a script from scratch, here are a few caveats to remember:

• update your application descriptor to use the output SWF path from your ANT script instead of the default placeholder text provided by Adobe
• add the appropriate iOS tags to your descriptor
• modify the ANT template to point to your system specific config (SDK, project, certs)
• don’t forget to add your certificate’s password
• remember to load the airmobile-config.xml (configname=airmobile vs air)
• change ipa-test to ipa-app-store before publishing to the App Store.

Checkout some of the related resources for alternatives to tackling the same problem and just general information on developing AIR applications for iOS devices.

RELATED RESOURCES
http://www.ivanalvarez.com/2010/10/flex-4-in-ios-3/
http://www.terrenceryan.com/blog/post.cfm/compiling-flex-hero-apps-with-mxmlc-in-ant
http://blogs.adobe.com/cantrell/archives/2010/09/packager-for-iphone-refresher.html
http://help.adobe.com/en_US/air/build/WS901d38e593cd1bac1e63e3d128fc240122-7ff2.html
http://help.adobe.com/en_US/air/build/WSBE9908A0-8E3A-4329-8ABD-12F2A19AB5E9.html
http://help.adobe.com/en_US/as3/iphone/air_deviphoneapps.pdf

The Internet that we’ve become accustomed to will soon cease to exist. It’s fast-approaching that point where it can no longer exist as it does today. This is due to the fact that we’re running out of addresses under the current Internet Layer protocol, Internet Protocol version 4 (IPv4). IPv4 is responsible for relaying data across the Internet from source host to destination host based solely on their addresses. IPv4 uses 32-bit (2 to the 32nd power) addresses and can support 4.3 billion devices connected directly to the Internet.

Normally, 4.3 billion would seem like a massive number but with the proliferation of Internet-hungry devices, that number has become almost entirely consumed. As it stands now, less than 5% of IPv4 addresses are left unallocated to the regional Internet registries, who in turn issue them out to network operators. These network operators are then responsible for issuing them to their service subscribers. Think about that for a second, 5% of 4.3 billion. That leaves only 215 million addresses left to issue before IPv4 reaches its end. Experts expect the free pool of IPv4 addresses to be depleted in a matter of weeks. So, it seems that we’ve pushed IPv4 as far as it can possibly go and we did so in only 30 years. Without diminishing the incredible nature of that thought, what will happen once that eventual day finally comes? Will we no longer be able to surf the Net, check email, buy movie or plane tickets? Hopefully not. That’s what IPv6 was created to prevent.

IPv6 defines a new addressing method that’s infinitely more robust than its predecessor. It uses 128-bit addresses which supports a virtually unlimited number of devices (2 to 128th power). In other words, it will take a LOT longer than 30 years to exhaust those many addresses. We’ll have enough addresses to issue our future extraterrestrial networks on the Moon and Mars.

To get planet Earth ready for the mandatory switch to IPv6, the Internet Society is sponsoring World IPv6 Day on June 8, 2011. This global trial requires participants to support native IPv6 traffic on their main Web sites on that day. Google, Yahoo and Facebook, along with leading content delivery networks like Akamai and Limelight have all committed to the IPv6 trial. In order to participate in the trial, these companies must commit to running a dual-stack deployment which will allow IPv6 traffic to run alongside IPv4 traffic without utilizing shortcuts like DNS whitelisting. Until now, content providers like Facebook and Google have been supporting IPv6 via dedicated addresses separate from their main traffic-heavy sites.

These companies aren’t the only ones that believe change is eminent. Recently, the US Military started nudging its IT vendors to begin supporting IPv6 on their public facing sites. And, in September of 2010, the Office of Management and Budget mandated federal agencies to support IPv6 in dual-stack mode on their public facing sites by the fall of 2012.

The ball is definitely in motion to transition the world to the next version of the IP protocol. Hopefully this trial will prompt content providers, ISPs and manufacturers to start their transitions to IPv6 as soon as possible. As someone that’s ultimately responsible for technology and IT at my company, I am definitely excited to smoothly transition our internal and external operations over to IPv6.

First thing you want to do is to signup for a GA account or create a tracking account that can be used by your AIR app if you’ve already signed up for GA. As part of the tracking account creation, you’ll supply a domain to track which should be related to your application but doesn’t have to be. I’d advise it to be though because it keeps everything cohesive by grouping your app usage metrics with your product site metrics. If you’ve done everything correctly, you’ll now have access to a unique web property ID that maps to your newly created tracking account. This will be very important later on.

Now that you’ve got your tracking account setup, it’s wise to take the time to create your conversion goals. These goals are completely up to you but they need to be defined to allow GA to calculate goal conversion metrics for you. I personally consider the following goals essential to any desktop application:

• Downloads
• Installs
• Trials
• Purchases
• Registrations
• Errors

With the exception of Downloads, all of the above will be tracked via your AIR application through the definition of pageview patterns and application events. When you create your conversion goals you have the option to set the goal’s type as a URL destination which is perfect for generating your pageview patterns because it allows you to specify a goal URL. This URL now becomes the trigger for this metric. So, anytime GA registers a hit on the specified URL it also registers a hit on the corresponding goal. GA allows you to create up to 20 goals split into 4 sets. Here’s what the goal config would look like for a goal that tracks # of registrations via a virtual URL:

Once you’ve setup your conversion goals, you’re pretty much done on the GA side. You can now take the JS embed code that GA generates for you and add it to all the physical pages of your product website before moving on to your AIR application.

Now that the GA side is setup, you can concentrate your efforts on the AIR side of things. First on the AIR todo list is to grab the latest GA library SWC from the gaforflash project site. Once you’ve done that, you want to add the SWC to the library path of your Flex or Flash project. With the SWC on your library path, you can now start wiring your application’s events and user interactions to your pageview patterns that you previously defined.

In a project that I’m currently working on, I chose to tackle this through the use of a value object (VO) that transports the tracking data collected throughout my application to a proxy that handles data submission to GA. The VO includes read/write properties for everything required by the GA methods supplied via the SWC, as well as, static constants for the pageview patterns that I want to track:

package labs.otuome.air.myapp.model.vo.google
{
	/**
	 * Value object representing 
	 * application analytics data.
	 * @author Hasan Otuome
	 */
	public class AnalyticsData
	{
		///////////////////////////////////////////////////////////////////////
		// PRIVATE PROPERTIES
		//////////////////////////////////////////////////////////////////////
 
		/////////////////////////////////////////////////////////////////////
		// PUBLIC PROPERTIES
		/////////////////////////////////////////////////////////////////////
		//------------------- Track Types ---------------------------------//
		public static const URL:String 			= 'myapp_pageViewTrack';
		public static const EVENT:String 		= 'myapp_eventTrack';
		//------------------- Virtual URLs ---------------------------------//
		public static const INSTALL:String 		= '/app/installed';
		public static const TRIAL:String 		= '/app/trial';
		public static const PURCHASE:String 		= '/app/purchase';
		public static const REGISTRATION:String 	= '/app/registered';
		public static const HELP:String 		= '/view/help';
		public static const BUG:String 			= '/report/bug';
		/**
		 * The type of data this instance 
		 * represents, either AnalyticsData.VIEW 
		 * or AnalyticsData.EVENT. 
		 */		
		public var type:String;
		/**
		 * The data value to associate with this track. 
		 */		
		public var value:Object;
		//------------------- Event-only ---------------------------------//
		/**
		 * For event tracks, a custom event category. 
		 */		
		public var category:String;
		/**
		 * For event tracks, the action related to the event. 
		 */		
		public var action:String;
		/**
		 * For event tracks, a custom label to 
		 * associate with the event. 
		 */		
		public var label:String;
		/////////////////////////////////////////////////////////////////////
		// PUBLIC METHODS
		/////////////////////////////////////////////////////////////////////
		/**
		 * Constructor 
		 */		
		public function AnalyticsData(){}
 
		/////////////////////////////////////////////////////////////////////
		// OVERRIDES
		/////////////////////////////////////////////////////////////////////
 
		/////////////////////////////////////////////////////////////////////
		// PRIVATE METHODS
		/////////////////////////////////////////////////////////////////////
	}
}

And here’s the GA proxy class:

package labs.otuome.air.myapp.model.proxy.google
{
	import com.google.analytics.AnalyticsTracker;
	import com.google.analytics.GATracker;
 
	import flash.display.DisplayObject;
 
	import labs.otuome.air.myapp.model.proxy.AbstractProxy;
	import labs.otuome.air.myapp.model.vo.google.AnalyticsData;
 
	import org.puremvc.as3.interfaces.IProxy;
 
	/**
	 * The <code>AnalyticsProxy</code> class 
	 * provides access to the AnalyticsData, which 
	 * contains all of the associated analytics data. 
	 * 
	 * @author Hasan Otuome (core)
	 */	
	public class AnalyticsProxy extends AbstractProxy implements IProxy
	{
		/////////////////////////////////////////////////////////////////////
		// PRIVATE PROPERTIES
		/////////////////////////////////////////////////////////////////////
		/**
		 * The GA tracker object. 
		 */		
		private var _googleAnalyticsTracker:AnalyticsTracker;
		/////////////////////////////////////////////////////////////////////
		// PUBLIC PROPERTIES
		/////////////////////////////////////////////////////////////////////
		/**
		 * Reference to class name for framework caching. 
		 */		
		public static const NAME:String = 'AnalyticsProxy';
		/**
		 * The web property ID associated with this application. 
		 */		
		public static const GOOGLE_ANALYTICS_PROPERTY_ID:String = 'UA-12346578-1';
		/**
		 * Returns the AnalyticsData.
		 */		
		public function get track():AnalyticsData{ return getData() as AnalyticsData; }
		/////////////////////////////////////////////////////////////////////
		// PUBLIC METHODS
		/////////////////////////////////////////////////////////////////////
		/**
		 * Constructor
		 *  
		 * @param aName
		 * @param aData
		 */		
		public function AnalyticsProxy( aName:String, aData:Object=null )
		{
			super( aName, aData );
		}
		/**
		 * Starts the GA tracker. 
		 * @param displayObject
		 * @param debug
		 */		
		public function initializeGoogleTracker( displayObject:DisplayObject, debug:Boolean=false ):void
		{
			_googleAnalyticsTracker = new GATracker( displayObject, GOOGLE_ANALYTICS_PROPERTY_ID, 'AS3', false );
		}
		/**
		 * Submits the analytics data to 
		 * the analytics tracking service.
		 */		
		public function submitUsageData():void
		{
			if (track.type && track.value)
			{
				switch (track.type)
				{
					case AnalyticsData.URL:
						_trackPageView();
						break;
					case AnalyticsData.EVENT:
						_trackEvent();
						break;
				}
			}
		}
		/////////////////////////////////////////////////////////////////////
		// OVERRIDES
		/////////////////////////////////////////////////////////////////////
		/**
		 * Proxy registration handler.
		 */
		override public function onRegister():void
		{
			debugTrace( '[ AnalyticsProxy :: onRegister() ]' );
 
			data = new AnalyticsData();
		}
		////////////////////////////////////////////////////////////////////
		// PRIVATE METHODS
		////////////////////////////////////////////////////////////////////
		/**
		 * Submits a virtual page view. 
		 */		
		private function _trackPageView():void
		{
			if (_googleAnalyticsTracker) 
			{
				_googleAnalyticsTracker.trackPageview( track.value.toString() );
 
				// reset the VO
				track.type = null;
				track.value = null;
				track.category = null;
				track.action = null;
				track.label = null;
			}	
		}
		/**
		 * Submits a virtual event. 
		 */		
		private function _trackEvent():void
		{
			if (_googleAnalyticsTracker) 
			{
				_googleAnalyticsTracker.trackEvent( track.category, track.action, track.label, Number(track.value) );
 
				// reset the VO
				track.type = null;
				track.value = null;
				track.category = null;
				track.action = null;
				track.label = null;
			}
		}
	}
}

In this scenario, the GA tracker is initialized at application startup and from there, anytime usage data needs to be relayed to GA, the VO tied to the proxy is updated and then the submitUsageData() method is called.

That’s all there is to it. If it seems eerily similar to GA implementations for browser-based SWFs, that’s because it’s pretty much the same except usage from AIR apps is currently unsupported by Google or Adobe. Even still, it’s nice to know that AIR developers don’t have to be left out in the cold completely.

One additional thing to note, it can take up to 24hrs before you’re able to see the analytics data via your GA dashboard but after that period just look under the Content and Goals tabs and you should start seeing data trickle in for all your virtual pageviews and events.

Features:
1 GHz dual core processor
1 GB RAM
Pair PlayBook with your BlackBerry smartphone via Bluetooth
Uses the same tech Cisco uses to power the World Wide Web (QNX)
Dual HD cameras (3MP front cam/5MP rear cam)
Video codecs supported: 1080p, h.264, mp4, wmv
HDMI video out
micro USB + HDMI
Weighs < 1lb (400g)
Multitouch gestures (4 touch points)
802.11 a/b/g/n WiFi
Support for POSIX, Open GL, BB 6, WebKit, Flash, Java and AIR

The feature set alone should tempt you and if you're already developing apps with Flash Builder 4, PlayBook dev is as simple as adding another SDK in your config properties and setting up the VMWare simulator for testing. Once you're set up, create a new AS3 project and code away. When you compile your project, the AS3 is compiled into a SWF which is then converted to a BAR file before launching inside the simulator. There are even techniques to convert your APKs from your Android projects to the BAR format.

RIM is serious about helping you get started with your PlayBook development career. They’ve compiled a ton of resources to help you get up and running. Here’s a short list:

us.blackberry.com/developers/tablet/devresources.jsp
supportforums.blackberry.com/t5/Tablet-OS-SDK-for-Adobe-AIR/bd-p/tablet
devblog.blackberry.com
labs.adobe.com/technologies/flash/blackberrytabos
adobe.com/devnet/devices/articles/blackberry_tablet_os_sdk.html

And, RIM not only wants you developing applications, they want you earning money as well. Some of the features of their monetization program include:
- Carrier billing, credit card and PayPal in over 70 countries and 21 currencies
- 70/30 revenue split (70% Developer/30% RIM)
- In-app payments (unlockables, powerups, etc)

They’re also arming you with an integrated advertising service that allows you to earn even more revenue from your PlayBook adventures. Here’s a brief overview of the ad service’s features:
- 60/40 revenue split (60% Developer/40% RIM)
- Ability to leverage RIMs existing vendor network to get you earning more ad revenue faster
- Maintain full control over which ads you want to display
- Benefit from an open/transparent platform whose goal is to enable devs to generate revenue

Now, if you’re still undecided, RIM is even offering a FREE PlayBook. That’s right FREE!! Full details here. The basics are create a PlayBook app, submit it to BlackBerry AppWorld and once it’s approved, you’ll get a free PlayBook when it ships!!

The excitement surrounding the PlayBook is most definitely brewing so, I strongly encourage you to take advantage of RIM’s generosity to join the forefront of this new mobile application revolution.

PROS

• Support SVG + HTML 5

- canvas
- scaleable
- accessible text

• Generate CSS3
• Live, selectable text

- use JS to manipulate

• Lots of power to chop up designs (think PS slices)
• CSS Export!!! (Export Selected as CSS)

- export object
- export object styles
- export text styles via Character Styles tab
- export gradients!!

• Link to exported CSS via DW
• FREE download from Adobe Labs on 9/13 (Get it Today!!)

CONS

• Doesn’t generate HTML; just CSS
• IE9 can render natively; older versions have to use a plugin

Would write more but I’m anxious myself so I’m off to install my copy and start creating!!!