As I wrote last week, the first way in which we want to help organize experiences is around fixed physical locations: things in physical space that don’t move (much).

Let me start with a potential application for public service.

We know going back the last several years that there’s a huge need in the US for infrastructure improvement.  This means fixing bridges, filling potholes, greening our tall buildings, expanding pedways to be more accessible.  Local, State and even Federal municipalities are responsible for this, in partnership with private citizens, small and large companies – but the resources to apply to the myriad of problems are scarce (like lots of resources these days).  One way we all could save money, accelerate improvements and help allocate proper resources scaled to critical needs is by opening up the information gathering and helping organize user-identified issues through aggregation means we already know how to employ.  Then, municipalities could apply experts in architecture, civil engineering and/or environmental science to determine a course of action instead of expend resources in just finding out where the problems are to begin with.

Ideally, mobile phone users could take pictures or video encoded with geo-location metadata of visible issues on their streets, bridges, buildings, etc into a shared repository on the Internet.  That repository could be made publicly available for a number of different purposes:

• Mapping services (like Google Maps, Yahoo, etc) could use the information to provide some visual information on where clusters of issues might be.
• Color-coding and shading to identify types and severity of issues, which might help identify related concerns.
• An application could export tagged structures and descriptive data related to them into a variety of formats (RSS, MS Project, ???) to aggregate that information into something else.
• Watchdog groups could use the same data set that Local, State and Federal resources use cross-agency to monitor the status of improvement efforts, promoting transparency and reducing wasteful redundancies that come from multiple data stores.
• Mashups with other available datastores (perhaps a visual mashup to highlight to what extent identified infrastructure needs may correlate with degrees of air quality, water quality, etc)

What the services on the back-end would help with would be in terms of:

• Organizing the information in terms of proximal location and granular details within a fixed location (what building, which floor of a building, what room, where in a room, etc).
• Make the data available and interoperable.
• Support the need to aggregate and filter all that user-generated metadata.
• Enable multiple points of entry to the data pool.

That last point is really important – not necessarily more important than the others, but pretty huge.  In my mind, we don’t want one application for mobile or web-enabled users to enter such information – we want to cast a wider net to empower more end-users to easily support and accelerate data collection and, thusly, infrastructure improvement.  Building a straight-up tagging application is one use, but what if someone wanted to create a scavenger hunt game to flesh out details about infrastructure improvement?  What if yet another game was a massively multiplayer game where discovery of infrastructure defects acted as multipliers or Mana in-game?

By abstracting the data collection aspect from the application, but making that data set widely available across applications, you enable more than one type of user activity while solving a larger problem.

In the case of collecting information for infrastructure improvements, it’s not that there aren’t people trying to do this already, or that there aren’t pockets of applications to help make this easier for our municipalities – it’s that many of the data stores aren’t well known, widely available and more critically shared.  By opening up the collection, filtering and aggregation of the data, we hopefully save time and money to accelerate solving a very big issue.

This is one way in which BAQON can be used.  In the coming weeks, I’ll highlight many more.

Related posts:

1. What BAQON Enables: Gaming
2. What About BAQON?

Breakdown of the interface for the browser.swf

UPDATED:  Download the project files here: browser.zip

XML-Driven iTunes-like Browser in ActionScript 3 by Aaron Silvers is licensed under a Creative Commons Attribution-Noncommercial-Share Alike 3.0 United States License.
Based on a work at www.aaronsilvers.com.

So, I’ve scripted me up an application with two listboxes, working off of one set of XML data exported (as previously detailed) from MS Access.

Now for the explanations…

import flash.geom.ColorTransform;

In order to dynamically change the color of a movieclip, you need to bring in the ColorTransform class. I use this to change the background_mc shown in the diagram above — I want to change the color to indicate if the resource being presented is currently available, or available when there’s a big enough pool to demand a course as instructor led training.

var xmlLoader:URLLoader = new URLLoader();
var xmlData:XML = new XML();
xmlLoader.addEventListener(Event.COMPLETE, LoadXML );
 
xmlLoader.load( new URLRequest( "resources.xml" ) );

With AS3, you can’t just call getURL anymore. It’s deprecated. So, you need to create an instance of the URLLoader class and use its internal method of load to bring it in. The nice thing about these events is that Flash’s Run-Time can detect when you’ve actually completely loaded the URLRequest — which is why the addEventListener above calls on my function/method LoadXML when the loading event is complete.

var MasterArray:Array = [];
var TopLevelArray:Array = [];
var TempSecondLevelArray:Array = [];
var TopIndexLength:Number;
var TempSecondIndexLength:Number;

I’m manipulating the XML in a couple of different ways. I have a hunch that Flash handles its own array data a lot faster than it manipulates XML, even when it’s internalized. That’s the way it used to be, and that’s just what guides my decision making, so I’m going to use MasterArray to do a direct capture of the XML data as an Array inside of Flash, and then use the TopLevelArray and the TempSecondLevelArray to help me maintain just the information I need to populate those two listboxes, respectively.

// Hide the Launch button by default
availability_mc.launch_btn.visible = 0;
 
function LoadXML( e:Event ):void
{
	xmlData = new XML( e.target.data );
	ParseData( xmlData );
}

The LoadXML method uses the data from the Event object and references it as an XML object, which is then used by my ParseData method, below…

function ParseData( newXML:XML ):void
{
var newList:XMLList = newXML.resources;
 
// Populate the MasterArray so we don't have to keep manipulating a huge honking XML file
for each (var newItem:XML in newList)
{
	MasterArray.push( {
			 learningRoadmapId:newItem.learningRoadmapId,
			 cardinality:newItem.cardinality,
			 resourceId:newItem.resourceId,
			 availabilityId:newItem.availabilityId,
			 availabilityStatus:newItem.availabilityStatus,
			 tCategories_name:newItem.tCategories_name,
			 tTracks_name:newItem.tTracks_name,
			 tTypes_name:newItem.tTypes_name,
			 tResources_name:newItem.tResources_name,
			 description:newItem.description,
			 link:newItem.link
			 } );
}

…just to interject, I’m creating an Object for each node of the XML data and making each Object an element of the MasterArray. Everywhere above where it says newItem, I’m pulling a node from the xml file (so newItem.resourceId means I’m pulling the resourceId value exported from the MS Access database for the current record. The for each allows me to loop through this series of actions as many times as there are records in the xml file I’m reading. Moving on…

// Now populate an array of just the top-level Learning Map IDs, so that it's easier to sort
for ( var i:Number = 0; i < MasterArray.length; i++ )
{
	TopIndexLength = TopLevelArray.length;
	if( TopIndexLength == 0 ) TopLevelArray.push( {label:MasterArray[i].learningRoadmapId, data:MasterArray[i].learningRoadmapId} );
	if( TopIndexLength >= 1 )
	{
		var now = MasterArray[i];
		var lastIdentified = TopLevelArray[ TopIndexLength - 1 ];
		if ( now.learningRoadmapId != lastIdentified.label ) TopLevelArray.push( {label:MasterArray[i].learningRoadmapId, data:MasterArray[i].learningRoadmapId} );
	}
}

The “Top” Listbox is only to list out all the learning maps in the database. Even though I’ve stored everything as a resource in my previous posts so they are flat in the database, I’m customizing a view to reflect the real-world hierarchy, which I can do because I’ve categorized my information in the database such that I can easily identify what type of resource any one resource is.

//Now populate the top-level listbox
for ( var j:Number = 0; j < TopIndexLength; j++ )
{
	top_lst.addItem( TopLevelArray[j] );
}
}

Bam. That wasn’t so difficult, right? Next up? What do we do when someone selects a LearningMap from the “Top” listbox?

top_lst.addEventListener(Event.CHANGE, topItemChange);
 
function topItemChange( e:Event ):void
{
	// Remove every item out of the second-level listbox
	middle_lst.removeAll();
 
	// Reset the length of the second-level array
	TempSecondLevelArray = [];
 
	// Sort through the MasterArray for any resources that have the selected
	// Learning Map as its parent.
	var selectedLearningMap:String = top_lst.selectedItem.data;
 
	for ( var i:Number = 0; i < MasterArray.length; i++ )
	{
		if( MasterArray[i].learningRoadmapId == selectedLearningMap )
		{
			TempSecondLevelArray.push( {label:MasterArray[i].resourceId, data:MasterArray[i]} );
			TempSecondIndexLength = TempSecondLevelArray.length;
		}
	}
 
	// Now populate the middle listbox (currently only the label and description)
	for each ( var ResourceItem in TempSecondLevelArray )
	{
		middle_lst.addItem( ResourceItem );
	}
 
}

The commments above should be pretty self-explanatory. We need to wipe out anything that’s in that “Middle” listbox and repopulate it based on what is currently selected in the “Top” listbox.

middle_lst.addEventListener(Event.CHANGE, middleItemChange);
 
function middleItemChange( e:Event ):void
{
	// Populate the textfield with formatted text
	var myText = middle_lst.selectedItem.data.description;
	pane_txt.htmlText = myText;
 
	// Hide the Launch button by default
	availability_mc.launch_btn.visible = 0;
 
	// Show the availability of the selected resource
	availability_mc.label_txt.text = middle_lst.selectedItem.data.availabilityStatus;
 
	// Change the color of the availability status bar based on the status of the resource
	var avStatus = middle_lst.selectedItem.data.availabilityId;
 
	var newColorTransform:ColorTransform = availability_mc.background_mc.transform.colorTransform;
 
	// If the resource is "available"
	if ( avStatus == "1" )
	{
		newColorTransform.color = 0xFF0000;
		availability_mc.background_mc.transform.colorTransform = newColorTransform;
	}
	// If the resource is "on demand"
	else if( avStatus == "3" )
	{
		newColorTransform.color = 0xF69200;
		availability_mc.background_mc.transform.colorTransform = newColorTransform;
	}
 
	// Show a button to launch the resource if a link is provided
	if ( middle_lst.selectedItem.data.link != "0" )
	{
		availability_mc.launch_btn.visible = 1;
		availability_mc.launch_btn.addEventListener( MouseEvent.CLICK, button_function );
		function button_function( evt:MouseEvent )
		{
			var request:URLRequest = new URLRequest( middle_lst.selectedItem.data.link );
			try
			{
				navigateToURL(request, '_blank'); // second argument is target
			}
			catch (e:Error)
			{
  				trace("Error occurred!");
			}
		}
	}
}

Related posts:

1. Adventures in Actionscript 3.0: Making the Data Available to Flash from an Access Database
2. Adventures in Actionscript 3.0: Working with Microsoft Access
3. Using Sounds Embedded in the Library and Other Tricks

So, in the previous post, I went through a bit of my rationale behind the architecture I came up with for the database, and how it models the way in which my organization is looking at career learning mapping. With all that data organized in Microsoft Access, everyone with the software in the organization can maintain the database if they understood what I put in the last post. But to use the data in the little Flash browser I built (and you can build after my next post), we still need to spit that data out in a format that makes sense. Flash can’t read an Access database directly (not without some help), but Flash can read XML just fine, and we can export XML from Microsoft Access.

Now, we could do an entire data dump of the database to XML, but that file would be very difficult to work with. By running a query and exporting the results of a query to XML, we can have a little more control over the output (Access doesn’t give you any options for how to format the XML), and when the XML is easier to work with, you’ll have a much easier time building an application to work with it.

So the first thing we need to do is figure out how we want to eventually use this data. The way I envisioned an employee browsing for information about a learning map was like using the browser in iTunes…

Going from left-to-right along the three lists, you can browse iTunes first by selecting a Genre, which then filters the list of Artists down to the artists that qualify in that Genre. When you select the artist you want, you can additionally filter down to the Album you’re most interested in by that artist and go on to select a song from that album. Using the iTunes browser, I can manage my own library of 23,907 songs (66.3 days of music) and find what I want in seconds.

Our learning maps are organized similarly, but the total population is not nearly as large (currently only 300 or so resources) organized into only about 8 defined learning maps. Our browsing dig-down (at the moment) really only needs to go from Learning Map -> Course ID -> Descriptive information. Because of the way we’ve structured the database, we can actually support far more robust searches if we needed them, but it’s admittedly overkill to build extensive search features for a population of data that’s so tiny.

Nevertheless, the query we need to put together to pull information that will format nicely to this (that Access will just natively kick out so a guy like me isn’t always stuck maintaining either the database or the Flash application) is pretty significant.

SELECT tAggregations.learningRoadmapId, tAggregations.cardinality, tAggregations.resourceId,
tAggregations.trackId, tAvailability.availabilityId, tAvailability.availabilityStatus,
tCategories.name AS tCategories_name, tResources.name AS tResources_name, tResources.description, tResources.link,
tTracks.name AS tTracks_name, tTypes.name AS tTypes_name

FROM (tTypes INNER JOIN (tCategories INNER JOIN (tAvailability INNER JOIN tResources ONtAvailability.availabilityId = tResources.availabilityId) ON tCategories.categoryId = tResources.categoryId)ON tTypes.typeId = tResources.typeId) INNER JOIN (tTracks INNER JOIN tAggregations ONtTracks.trackId = tAggregations.trackId) ON tResources.resourceId = tAggregations.resourceId

ORDER BY tAggregations.learningRoadmapId, tAggregations.cardinality, tAggregations.resourceId;

Fortunately, you don’t need to know how to write Inner Joins or SQL-style query language in order to pull good information out of the database. Access, for what it is, does it pretty much all for you.

In Design mode, you can define your relationships like this (note how this looks exactly the same as the relationships in my previous post):

Once you’ve established the relationships, you can then simply select the fields you want a report on based on how some of the fields are related to each other (these are those INNER JOIN statements written in SQL — for example, I JOIN the Tracks table to the Aggregations table where the field trackId in both tables are the same.

When you run this query, you’ll get a whole report based on the data you already entered in the database and the way your Query describes it to be produced. This query can then be exported out of Access directly as XML, and the structure of this particular query will output data that looks like the following:

<resources>

<learningRoadmapId>LM-SAMPLE</learningRoadmapId>

<cardinality>0</cardinality>

<resourceId>EMT500</resourceId>

<trackId>4</trackId>

<availabilityId>1</availabilityId>

<availabilityStatus>Currently available.</availabilityStatus>

<tCategories_name>Compliance</tCategories_name>

<tResources_name>Business Conduct Guidelines for Monkeys</tResources_name>

<description />

<link>http://sizzler.com/</link>

<tTracks_name>Onboarding</tTracks_name>

<tTypes_name>Course</tTypes_name>

Related posts:

1. Adventures in Actionscript 3.0: Working with Microsoft Access
2. Adventures in Actionscript 3.0: Building an iTunes-like Browser with Flash and XML
3. Flash For Learning: The Group

In December, I was presented with a knowledge management problem for my real job as an internal consultant. Like many large organizations, we have some curricula established for career advancement, but this information is scattered all over the company intranet, which is usually littered with a lot of irrelevant or outdated materials. I was asked to come up with a way for our employees to easily find out what courses they need to register for in the LMS in the learning map they wish to follow — and to have this information available for a number of learning maps in one location.

Modeling in Microsoft Access

The old way of organizing learning maps for our employees was for one HR employee to update a bunch of separate powerpoint decks, one tied to each learning map. They were formatted similarly, but the first thing I thought about was coming up with a model to fit each learning map in so they were using the same taxonomy (category names and labels) and the same structure.

The powerpoint decks illustrated learning maps that at a high level look like this:

1. There are a bunch of courses lumped together in a couple of high level categories, which I decided to call “Tracks.” The reason for calling them “Tracks” is because each of the courses also had their own category — some are product courses, some are compliance courses, some are technology courses, etc. A Track might pull on courses from multiple categories. That implied some kind of distinction, if not some kind of hierarchy — and that different way of looking at a collection of courses an employee might need to take meant that I needed to have separate ways (at least two) of organizing these courses in one learning map.
2. There are several learning maps that I have documentation for (who knows how many might be out there that I don’t know about). Each learning map could potentially pull some of the same courses, so that also implied a need to have yet another, abstracted way of organizing courses separate from the learning maps.
3. In some of the powerpoint decks, there were internal links being referenced and aggregated in some of the tracks. Some tracks even pulled in another learning map! To me, this implied that they type of resource had to be distinct from the resource itself, because sometimes a course is part of a learning map. Sometimes a course may be aggregated with a learning map. And a learning map might consist of a collection of courses, links and learning maps.

Confused? Hopefully not. After stewing over a couple of these decks, I very quickly came up with a relational database structure that looks exactly like this:

Here’s how it actually plays out. In slides 2, 8, 14, 21 and 28 in the above (almost unreadable) slide deck, you see a bunch of a boxes in columns. Each column potentially represents a category, but the aggregation of columns on a single slide represents a track. Once I could discern a repeatable logic from this model and found it applicable to the other powerpoint decks, the rest of the database came easy.

You notice in that high level view of the slide deck the three different colors (red, blue and that mustard)? Each color represents the availability of the given resource. Red represented content that was already available through the LMS. Mustard represented content that could be reserved, and blue represented content that was not available at the moment. This indicated to me that I needed to provide some way for people to know the availability of a given piece of content.

Each resource has a name, a type (intranet link or web course or learning map), an availability status, a link associated with it to launch the resource and some description information. All this information should stay consistent about the resource no matter what other aggregation, or collection of resources, the one may be part of later on. This way, if this particular resource needs to change (say it’s a course like Business Conduct Guidelines for Mammals), we only change the information in this one listing, and the change is absorbed in every instance of the resource.

Notice in the relationships diagram inside of Microsoft Access (shown above), the tables for Categories, Availability and Types are abstracted from the Resources? I did that because somewhere along the line I may have a need to add or combine how I categorize my resources. Perhaps I’ll have more types of resources to work with later on (virtual rooms, might be a new resource in the future). I may need tiers of availability status instead of just the available, on request or not available. In any of these cases, these are things that apply to all resources, potentially — I don’t want to make a change to one of these on potentially hundreds or thousands of entries. So we associate each label in these tables with its own identifier, and use that identifier in the Resources table.

Now the Tracks table works the same way — I have a numeric identifier that’s a primary key and I have a label associated with it. Why did I not include the Track with a resource like I did the Category? Well, a couple of reasons. First, there was a hierarchy implied (as I wrote about earlier), so I know that Tracks are higher up the chain of taxonomy than Categories. Secondly, I know that I can have multiple types of Resources, and potentially a Resource like a course for Social Skills for Muppets might be part of some kind of Soft Skills Track in one curriculum or learning map, but it might be part of a Management track in a different learning map. This assumption adds no real extra work if it turns out that a course is always used in the same Track universally, but it saves a lot of work in maintenance if the assumption proves correct as our curriculum mapping builds.

But this means we need to associate a Resource with a Track in yet another table — the Aggregations table. In this one table, I put together every learning map, because learning maps are how we’re aggregating our resources in the context of tracks. So each row in the Aggregations table has it’s own numeric identifier, or primary key, the identifier for a LearningRoadmapId which is tied to a resourceId from the Resources table (remember that Resources, as I defined them could be Learning Maps themselves); this means I’m using “LearningRoadmapId” as a parent identifier in the same table. I have another field listing the individual resource I’m mapping to the parent resource, and that maps again, to a ResourceId in the Resources table; this represents the actual child in how a resource might be part of another resource. That specific resource’s trackId is provided from the Tracks table. And, we ever need to specify an order to how learners should experience these resources, I put in an extra field for cardinality which would allow me to custom sort by LearningRoadmapId and then by cardinality.

My next posts will be on Making the Data Available to Flash and Manipulating XML Data in Flash.

Related posts:

1. Adventures in Actionscript 3.0: Making the Data Available to Flash from an Access Database
2. Adventures in Actionscript 3.0: Building an iTunes-like Browser with Flash and XML
3. On Authoring Tools…

1. Why am I good at keeping friends but bad at starting businesses with partners? I’ve been married for over twelve years and we still love each other.   I’ve moved several times across the country with my expanding family and I’ve been able to hold onto friends from everywhere I’ve lived and worked.   We talk/IM/email/tweet almost every day.   I’m even finding friends from the long long ago when there was no Internet to speak of.   I’m an a**hole, but the evidence clearly demonstrates that I’m the kind of a**hole that has a lot of real friends with high tolerances for a**holes.   That said, two times now, I’ve tried to start a business venture with former co-workers (who were also friends), and it hasn’t worked out.   The first time was like six years ago, and the chips were stacked against us with everyone physically moving so far away from each other, and I went passive aggressive in trying to deal with the frustration (mea culpa).   I thought I learned from that experience, but I guess there’s something more for me to learn as my new consulting business went from a partnership to a solo effort barely a month after launching.   So in 2009 I’ll continue to be a company of one.   I still love the idea of partnering in business — maybe not with former co-workers?   It seems to fly contrary to logic…
2. What the hell happened with Rhymefest’s second album, “El Che?” It was supposed to drop in April of 2008.   The Michael Jackson tribute “Man in the Mirror” was so fantastic, I was really looking forward to it — and the album never came out with no news (not even news on MySpace) as to why it was delayed.
3. Why is so much E-Learning content done in Flash if there’s no Flash “coolness” going on? Don’t get me wrong, the more maintenance on your old courses are chores and pain spots, the more sidework I’m going to get updating it and converting it to SCORM or AICC — but if a page-turner is a page-turner, there’s a lot of easier (and cheaper) ways of creating E-Learning content than putting it all in Flash.   This is a topic I hope to explore with Learning Ninjas in 2009 (more to come on that).
4. Why is growing old so painful? Seriously, this tendonitis I have?   Everytime there’s precipitation this last month (and there’s been a lot), my left leg/foot and back hurt like hell.   I could accept it, I guess, if I was some kind of athlete with a storied career that was hard on my joints or whatever — but I’m a nerd whose joints for the most part have been mostly guarded from anything that might cause them stress or harm.
5. How many life and career coaches does the Internet need? It seems like I get followed each week by a new career coach (on Twitter).   Some punk just out of college is going to coach me on my career?   Really?   Try having a career (or 3) first before imparting me with all the wisdom from your BA in English (note:   not ranking on English majors — I’m married to one).   I know of one career coach who’s doing “something” (that’s you, @melissapierce) and she’s not even trying to coach me.

Technorati Tags: twitter, life coach, career coach, tendonitis, pain, growing older, e-learning, flash, page-turner, scorm, aicc, learning ninas, consulting, sidework, business, partnering, partnerships, friends, relationships, rant, opinion, 2008, 2009

Related posts:

1. Catching Up
2. Curriculum is Not the (Whole) Problem
3. Life in Perpetual Beta

Elliott Masie, Learning 2008

As I have the day on Monday, October 27 to attend sessions, I’ll blog as I attend all the sessions I’m in. Turns out Tweeting is a good skill to have in doing live blogging. Watch here for the goods, and I’ll try and put pictures in-line when possible (it’s tough to edit as I type and listen, but what’s a little more multi-tasking, right?).

Related posts:

1. Learning 2008
2. Learning 2008 – Live Blogging the Kickoff
3. Learning 2008 – Day 2 Live Blogging

Basically, what’s happened is that Adobe wants Flash on as many screens and devices as possible. To do that, they’re pretty much COMPLETELY OPENING UP THE PLATFORM. What does “completely opening up the platform” actually mean?

* Removing restrictions on the use of the SWF and FLV/F4V specifications
* Publishing the device porting layer APIs for Adobe Flash Player
* Removing license fees –making next major releases of Adobe Flash Player and Adobe AIR for devices free
* Publishing the Adobe Flash Cast protocol and AMF protocol for robust data services

So what does this have to do with learning? I think it’s going to have a huge impact on creating all sorts of learning applications (content engines and assessment tools) that can play on lots of different devices. I think when you start rolling integrated content tools into your Learning Management Systems (if you really need to track the experience), the ability to throw in Flash Remoting via AMF becomes a VERY easy way to just track using methods that Flash developers know how to do — without the encumberance of necessary web services or JavaScript or whatever else. Adding to that — most organizations embrace Flash because it deploys the same regardless of browser… now imagine a world a few years from now where Flash deploys the same regardless of mobile device.

I’m glad I plunked down the cash for CS3….

Related posts:

1. All Hail Blaze DS

With ActionScript 3.0, there is no attachSound, so you need to do a little workaround. It took me a while to find this, but here you go:

import flash.utils.getDefinitionByName;
import flash.media.Sound;

var mySound:Sound;

var librarySound:Class = getDefinitionByName ( "nameOfYourSoundasLinkedFromTheLibrary" ) as Class;

mySound = new librarySound();

Basically, anything that you’re referring to as an Object in ActionScript 3.0 seems to require having a class file. So when you go to your library and export your sound objects for ActionScript, a class file is published for each one, and you need to call on these as a class in your code in order to use them like you would an external .mp3 or other audio file.

Now, for the fun part — remember what a pain in the ass it was to trigger some kind of event when an audio file would stop playing in Flash circa ActionScript 2.0? Throw the following code in to the above:

import flash.media.SoundLoaderContext;
import flash.media.SoundChannel;

var myChannel:SoundChannel;

myChannel = mySound.play();
myChannel.addEventListener( Event.SOUND_COMPLETE, AudioDoneAction );

function AudioDoneAction( event:Event ):void
{
	// Do something when the audio is done
}

So basically, the *Sound* class in ActionScript 3.0 allows you to load sounds and play them, but if you want to manipulate them or use them to evaluate other stuff, you want to include the Sound object as a reference in a *SoundChannel* object.

This seems pretty overcomplicated for my simple example here, but think about it this way. What if you had five different external audio files you wanted to load as a playlist for just one slide in an E-Learning piece, and you wanted to trigger different images and text with each audio file. You can code yourself a playlist and trigger changes upon completion of an audio file — and even track where you are in the playlist so that you could have different actions upon completion of the first and/or the last (or really at any defined place in the order of) audio in the playlist.

I couldn’t figure out the embedded audio as class thing on my own. It took a while of experimenting and searching until I found the solution [here](http://www.flepstudio.org/forum/tutorials/449-library-sounds-flash-cs3.html) and [here](http://www.kirupa.com/forum/archive/index.php/f-141-p-2.html).

Related posts:

1. Shiny Button Code
2. Adventures in Actionscript 3.0: Building an iTunes-like Browser with Flash and XML
3. Adventures in Actionscript 3.0: Making the Data Available to Flash from an Access Database

Anyway, I took an approach of updating Luka Maras’ really nice code that makes buttons in that glassy “Web 2.0″ style from its original code in ActionScript 2.0 to ActionScript 3.0.

Based only on this one experience, the good news for you if you want to upgrade your existing code to ActionScript 3.0: much of the foundation of the original ActionScript 2.0 code stayed in-tact. The bad news: figuring out how to convert the way you reference things in ActionScript 3.0 is a bit awkward when you’re used to working with AS2.0 and it took me a lot longer than I expected.

In some ways, upgrading my Asteroids code from ActionScript 1.0 might be easier than my experiments trying to do it in ActionScript 2.0, but… I need to budget a lot of time to accomplish that feat, I think.

Feel free to give this a try and if you have any questions or changes — if you have a way to improve or expand it, please share because I am always looking to improve (and I’m trying to get better about demonstrating that).

This code can actually go on the main timeline (I know, not cool for you OOP types, but I wanted to make it easy for people to just copy, paste and play). It assumes that you have a font (Verdana, in this case) in your library called “Verdana” that is exported to ActionScript.

I’ve made the attempt to have the font size increase or decrease relative to the height of the button.

import flash.geom.*;
import flash.display.*;

// FEEL FREE TO CHANGE THESE VALUES, AS THE REST OF THE CODE WILL ADAPT
var radius:int = 24; 		// The corners of your button
var btnW:int = 360; 		// Button Width
var btnH:int = 120; 		// Button Height
var colors:Array = [0xff0090, 0xff0000];	// The main gradient of your button
var strID:String = "Shiny Button";	// Button Label
var intX:int = 0;			// X-Position of your button's upper-left corner
var intY:int = 0;			// Y-Position of your button's upper-left corner

// PLAY WITH THESE AT YOUR RISK
var fillType:String = GradientType.LINEAR;
var alphas:Array = [100, 100];
var ratios:Array = [0, 245];

// TRY TO LEAVE EVERYTHING ELSE ALONE...
var matr:Matrix = new Matrix();
matr.createGradientBox( btnW, btnH, 90/180*Math.PI, 0, 0 );
var spreadMethod:String = SpreadMethod.PAD;

var myButton:MovieClip = new MovieClip();
this.addChild( myButton );

myButton.x = intX;
myButton.y = intY;

// BUTTON BACKGROUND
var buttonBkg:Sprite = new Sprite();
buttonBkg.graphics.lineStyle(0, 0xE88A41, 100, true, "none", "square", "round");
buttonBkg.graphics.beginGradientFill(fillType, colors, alphas, ratios, matr, spreadMethod );
buttonBkg.graphics.moveTo(radius, 0);
buttonBkg.graphics.lineTo((btnW-radius), 0);
buttonBkg.graphics.curveTo(btnW, 0, btnW, radius);
buttonBkg.graphics.lineTo(btnW, (btnH-radius));
buttonBkg.graphics.curveTo(btnW, btnH, (btnW-radius), btnH);
buttonBkg.graphics.lineTo(radius, btnH);
buttonBkg.graphics.curveTo(0, btnH, 0, (btnH-radius));
buttonBkg.graphics.lineTo(0, radius);
buttonBkg.graphics.curveTo(0, 0, radius, 0);
buttonBkg.graphics.endFill();

// ADD THE BUTTON BACKGROUND TO THE FANCY BUTTON ONLY AFTER IT'S READY
myButton.addChild( buttonBkg );

// THE SHINY GLASSY EFFECT
var shineRadius:Number = radius * 2 / 3;
var shineW:Number = btnW - ( 0.0333 * btnW );
var shineH:Number = btnH / 2 - ( 0.0667 * btnH );
var shineFillType:String = GradientType.LINEAR;
var shineColors:Array = [0xFFFFFF, 0xFFFFFF];
var shineAlphas:Array = [70, 0];
var shineRatios:Array = [0, 255];
var shineMatr:Matrix = new Matrix();
shineMatr.createGradientBox( shineW, shineH, 90/180*Math.PI, 0, 0 );
var shine:Sprite = new Sprite();
shine.x = ( 0.0333 * btnW ) / 2;
shine.y = ( 0.0667 * btnH ) / 2;
shine.graphics.lineStyle(0, 0xFFFFFF, 0);
shine.graphics.beginGradientFill(shineFillType, shineColors, shineAlphas, shineRatios, shineMatr, spreadMethod );
shine.graphics.moveTo(shineRadius, 0);
shine.graphics.lineTo((shineW-shineRadius), 0);
shine.graphics.curveTo(shineW, 0, shineW, shineRadius);
shine.graphics.lineTo(shineW, (shineH-shineRadius));
shine.graphics.curveTo(shineW, shineH, (shineW-shineRadius), shineH);
shine.graphics.lineTo(shineRadius, shineH);
shine.graphics.curveTo(0, shineH, 0, (shineH-shineRadius));
shine.graphics.lineTo(0, shineRadius);
shine.graphics.curveTo(0, 0, shineRadius, 0);
shine.graphics.endFill();

// ADD THE SHINY PART TO THE BUTTON ONLY AFTER IT'S BEEN GENERATED
myButton.addChild( shine );

// TEXT FORMAT FOR THE BUTTON LABEL
var myFormat:TextFormat = new TextFormat();
myFormat.align = "left";
myFormat.font = "Verdana";
myFormat.size = 12 * Math.round( 0.0125 * btnH );
myFormat.bold = true;
myFormat.color = 0xFFFFFF;

// THE BUTTON LABEL
var labelText:TextField = new TextField();
labelText.x = ( 0.0333 * btnW ) / 2;
labelText.y = ( 0.333 * btnH );
labelText.text = strID;
labelText.embedFonts = true;
labelText.selectable = false;
labelText.type = TextFieldType.DYNAMIC;
labelText.autoSize = TextFieldAutoSize.LEFT;
labelText.antiAliasType = "advanced";
labelText.setTextFormat( myFormat );

// ADD THE TEXTFIELD ONLY AFTER IT'S COMPLETE
myButton.addChild ( labelText );

Related posts:

1. Using Sounds Embedded in the Library and Other Tricks

I’ll be the first to admit, this project could’ve gone wrong from jump in so many ways. We had an internal client who, like many clients, was very risk-averse, so the thought of doing a “game” was a risky move and required a lot of handholding. They could have bailed at any time. We had an incredibly tight deadline for a project like this. Normally, a multimedia-heavy project like this one, you’d like a solid six months to develop it out. We gave our vendor three, and by a lucky break for all of us, the delivery was delayed by a month which was needed.

We used a brand new vendor who was brought to us initially by our CLO. I’ll be the first to admit based only on the sample products they provided that I would not have chosen them — mostly because they seemed more like an Agency than a game development house and the look and feel of the products I saw were similar in nature, and I felt their production would be a disconnect with our audience (and our internal client). When the project was emerging from the Instructional Designer on the project, I ballparked the project at a certain cost. I expected the vendor to come in high and then we’d have to haggle and negotiate. I expected that working with the vendor, like many vendors I’ve both worked for and worked with, would be a painful tug-of-war, followed by some finger pointing, followed by relief that the project just “got done.”

I could not have been more wrong about this vendor, and I’m very, very happy to say so. They came in so close to the number I ballparked, I began to think they were taking us seriously. I waited with baited breath to see their first draft of the storyboards indicating the look and feel for the game, and having taken the time to visit and talk with one of our branch stores close to their office, they produced storyboards that I felt so perfectly blended my expectations for how to be at once “cool” and at the same time “mindful” of the people we were looking to instruct, as well as the complexity of the subject matter we were looking to demystify. They made learning the material (and the subject itself) “fun” and still “tasteful.” I was very impressed, and I’m the kind of person (as you know on this blog) that doesn’t run out of opinions. I became hopeful that this really could work.

They created the project in a very complete Alpha state. We tested it in our network and found that the bandwidth required would be a major obstacle for the target audience. We talked with our vendor about reducing the audio and video quality a bit and retesting it in our network before doing any more work on integrating it with the LMS — because if it wouldn’t perform as “content” out of the LMS, there was no point on troubleshooting the LMS communication. They had new files to us in a matter of days. We retested and got a green light on performance.

Then we moved onto LMS integration. I put together the API Wrapper and the rest of the SCORM packaging for our vendor, because they had not built for an LMS deployment before, and it would be just silly to make them go through the learning curve when I could just do that heavy lifting with little effort. They were able to write and read from the LMS at the prototype level (we did a technical test before they even tried to get the real content working to debug the communication issues). Not looking at their ActionScript at all, when we noticed some issues with suspend_data not being sent to the LMS, even though the code was the same as the prototype. It turned out that the content was sending consecutive JavaScript calls, which goes back to the whole synchronous/asynchronous deal about ActionScript and JavaScript (we had to use Flash 7 Player because my organization had not upgraded to Flash 9 Player at the time). Moving the calls so they were separated and event-driven made a huge difference. I was on the phone for a day and a half with the vendor. In ten years, I never worked as, for or with a more willing partner.

For reasons I’m sure you can understand, I can’t show you the game. I probably can’t talk much about what the game is about or what we’re trying to teach. I probably can’t broadcast the vendor we’re working with (though if you ask me offline, depending on whom you work for, I’ll be happy to tell you).

The point of this posting is to get off my chest in as public a means as I can how happy I am to be able to help make the vision of one of our Instructional Designers a reality — even if all I am is the babelfish (Hitchhiker’s Guide reference). We have our foot in the door for serious gaming. I’m betting it’s going to be a smashing success and will usher in a shift in instructional approach, both as far as what we propose and what our internal clients will consider.

And… I’m just happy as hell that after years of producing cool and not-so-cool page turning stuff, I get to finally be part of something different. I worked with a fantastic Instructional Designer and a really incredible Project Manager (I actually am gushing over Project Management and Instructional Design) — both of whom really “get it.” I had a boss who was willing to take a chance and a CLO who was ready to be a sponsor on something different. Best yet: I had an internal client who, despite their concerns, was willing to trust us and get the job done right.

And one more thing: I’m very humbled that there are vendors out there that can really be a partner in making great learning experiences, on-time, on-budget and far-exceeding expectations.

For the first time in as long as I can remember, I have a happy project story and it didn’t kill us.

No related posts.