Two weeks ago me and my fellow co-workers have started our company blog which can be reached at
http://blog.publicis-modem.ch every open source initiative, project or library that we create will be published there.
I might do a cross link to a blog post or even write a little more about it, but I think you should keep an eye over there aswell, we already released two opensource projects (wallaGo and AS3Square) and there is more to come soon, so stay tuned for some fresh content and don’t forget to bookmark a new fresh blog.

You are in need of a simple video player, iightweight and easy to use?
You think OSMF is too complicated, let me correct you and present you the LightVideoElement Class.

Simple to use, quickly up and running and all needed “basic” features available.
It’s even a default in OSMF, I actually wonder why no one has written about it yet, it’s really easy to use and you can do all the basic things with it that a videoplayer needs to support nowadays and on top of it, it’s only 10k when compiled.

I’ve been using it for the last 2 projects I’ve made, and I couldn’t be happier, let’s have a quick look on how to use it:

_mediaPlayerSprite		= new MediaPlayerSprite();
_mediaPlayerSprite.graphics.beginFill(0x000000, 1 );
_mediaPlayerSprite.graphics.drawRect(0,0,640,360);
_mediaPlayerSprite.graphics.endFill();
 
_videoElement			= new LightweightVideoElement();
_videoElement.resource		= new URLResource( "pathtoyourvideo.flv" );
_videoElement.smoothing		= true;
 
addChild( _mediaPlayerSprite );
_mediaPlayerSprite.media		= _videoElement;

That’s it, no I’m not joking this is really it, you don’t need anything else to simply play a video,  now you might be asking yourself, well that’s cool but how can I control the playback? It’ easy and very intuitive, basically you only need to access the mediaplayer instance which is integrated into the _mediaPlayerSprite, there all public methods like play, pause, stop, events and so on are available for you to use. take a look at some of the functions i implemented to be able to control videoplayback.

public function play():void
{
	_mediaPlayerSprite.mediaPlayer.play();
}
 
public function pause():void
{
	_mediaPlayerSprite.mediaPlayer.pause();
}
 
public function stop():void
{
	_mediaPlayerSprite.mediaPlayer.stop();
}
 
public function get currentTime():int
{
	return _mediaPlayerSprite.mediaPlayer.currentTime;
}
 
public function get videoDuration():int
{
	return _mediaPlayerSprite.mediaPlayer.duration;
}

See, simple, easy and lighting fast.
But keep in mind that the LightWeightVideoElement has limited support, you can play every kind of flash supported videos, you can do everything a basic player needs to do, but as soon you start using SerialElements, Parallel elements and so on, then you should switch back to the default setup.
As usual you can get all the information and documentation from the official OSMF site.

Just as a quick update, I’ve updated the previously created unicode finder app, to be a bit more helpful for the everyday usage.
Here a list of things that have been changed:

• No double unicodes.
• Automatic generation of embed code, easy for you to copy & paste directly into your application.

One thing that I can’t handle for you is to define the source of the font with it’s according fontname as defined in your system, but hey if I find a way around this, I will update it.

And again if you would like to play around with it, here the app. Have fun!

You might have read on one of my previous tweets, where I was screaming about using “special” characters in Flash, with “special” I mean arabic, cyrillic, hebrew, chinese simplified and traditional, as well japanese.

I know,  I know, there is TLF (Text Layout Framework) that handles the whole text, but I’m talking about embedding the font, did you knew that the complete chinese Unicode range helds something around 20’000 characters? You might think so what? Let me tell you that the complete chinese character range is over 7MB big!!! Do you really want to let your viewers download a 7MB file just for the font? No.

So I’ve created a quick app that will enable you to read out the UTF code from the text you need to use, with it you can specifically embed only the characters you need and take the file size down to a minimum. Now there is only a downside of this method, if the textual content changes a day, you need to again import the new characters.
Apart from that, I haven’t seen any bad things about this implementation.

At the end of this post you will find an useful small tool to get all the needed characters.

As an example below with this line you are embedding a font only containing numerals typing 1234567890 will give you a range from U+0030 to U+0039

Embed(source="font_file_name", fontName="font_name", mimeType="application/x-font-truetype", unicodeRange="U+0030-U+0039,U+002E")]

So let’s assume you would like to write this: “Nemusíte oči vidět, musíte vidění” which means “You don’t need eyes to see, you need vision” and only embed the needed characters, you would embed your font like this

Embed(source="font_file_name", fontName="font_name",  mimeType="application/x-font-truetype",  unicodeRange="U+004e, U+0065, U+006d, U+0075, U+0073, U+00ed, U+0074, U+0065, U+0020,  U+006f, U+010d, U+0069, U+0020, U+0076, U+0069, U+0064, U+011b, U+0074,  U+002c, U+0020, U+006d, U+0075, U+0073, U+00ed, U+0074, U+0065, U+0020,  U+0076, U+0069, U+0064, U+011b, U+006e, U+00ed")]

If you don’t know how to use this kind of font embedding, have a read here:

http://soledadpenades.com/2008/10/21/embedding-fonts-in-actionscript-3-using-flex-sdk/

Test ride it your self and have fun

After 4 years Tom Green and I just published our latest book, this time we are not talking about Flash & After Effects, rather the newest and coolest version since the history of Flash, Adobe’s Flash CS5. If you are just learning the ins and outs of flash, then this is a book you shouldn’t miss, lots of examples, code snippets, cool projects and even an Android game is being built.

Flash is one of the most engaging, innovative, and versatile technologies available—allowing the creation of anything from animated banners and simple cartoons, to Rich Internet Applications, interactive videos, and dynamic user interfaces for web sites, kiosks, devices, or DVDs. The possibilities are endless, and now it just got better.

Flash CS5 boasts a host of new features, including the much-anticipated iPhone application creation feature, a whole new animation engine enabling full manipulation of tweens and paths, custom easing, improved inverse kinematics, a revamped timeline, built-in 3D, and much more.

This book is all you’ll need to learn Flash CS5 from the ground up. If you already have Flash experience, this book will allow you to quickly catch up on all the cool new features. Flash experts Tom Green and Tiago Dias guide you step-by-step through all facets of Flash CS5, keeping the emphasis firmly on good design techniques that you use in your own projects.

• Learn Flash design from the ground up, or just get to grips with the new features, with a series of step-by-step tutorials.
• Provides an easy introduction to ActionScript 3.0 coding, but the focus is mainly kept on design.
• Learn from the experts—written by renowned Flash designers Tom Green and Tiago Dias.

What You’ll Learn

• How to create an iPhone application.
• The ins and outs of the Flash CS5 interface
• How to use all of Flash CS5′s essential features, such as text, graphics, and animation
• How to use video and sound effectively in Flash
• The fundamentals of Flash CS5’s new animation and timeline features
• The basics of ActionScript 3.0
• How to populate a Flash movie with dynamic data such as XML.

Who this book is for

This book is for both beginners who want a solid grounding in Flash CS5, and designers with previous Flash experience, who want to get up to speed with the new features.

Last week I had to do something that I never thought of, let me present you the case:

First of all we have a multiline, word-wrapped textfield in AS3, the text is picked up from an external XML file and gets styled with a CSS stylesheet, the textfield CAN have one line or multiple lines (depending on the translation and the language used), if the text is only an one-liner, the graphic (a simple small gray arrow) needs to be placed after the text in the middle of the first line, so you are able to visualize this, think about a standard <li> tag where you get the black dot, in my case just at the other side eg. at the end fo the line. have a look at the Example for a visual clarification what I want to achieve.

Basically a simple task, you grab the textlength add the gutter and margin to it and place the small arrow at that position.. but what do you do when the text goes multine and word wraps automatically?
After doing some experiments, I’ve came up with a simple yet appropriate solution for this.
Let’s start with a simple text field, containing some text and setup for multiline and wordwrapping.

var tf:TextField = new TextField();
tf.text = "Lorem Ipsum is simply dummy text of the printing and typesetting industry.";
tf.width = 100;
tf.multiline = true;
tf.wordWrap = true;
addChild( tf );

This will display a simple textfield without any formatting with 5 lines of content. Why did I set a width value on my textfield? Well without it, the textfield would just be as wide as the text, resulting in a single line text, and that’s not what we want.

Now we create a simple square / dot / arrow whatever you like acting as a marker for the end of line, so you can visualize what’s happening, I’ve created a small rectangle like this:

var rect:Sprite = new Sprite();
rect.graphics.beginFill(0xff0000);
rect.graphics.drawRect(0,0,10, 2);
rect.graphics.endFill();
addChild( rect );

Simple rectangle, doesn’t need much of an explanation, maybe you asking yourself why I’ve set it at x & y 0? Although I could position the rectangle right at the proper position I always preferred to use the setters of it so I rather create all my shapes/graphs at 0,0 and move them with myShape.x = 100, it makes things more obvious to read and you find it much quicker then doing directly on the drawRect() method.

Next up let’s have a look at our class that returns the requested values.

public class StringUtil
{
	private static var _lastChar		:TextLineMetrics;
	private static var _x			:int;
	private static var _y			:int;
 
	private static var _gutter		:int = 2;
 
	public static function getEndOfLine( tf:TextField, line:int ):Point
	{
		_lastChar 	= tf.getLineMetrics(line);
		_x		= tf.x + _lastChar.width + _gutter;
		_y		= _lastChar.height * line  + _lastChar.ascent;
 
		return new Point( _x, _y );
	}
}

What we are doing here is rather simple then you think. First we pass the textfield and the desired line to our static function, then using the getLineMetrics() method we return the desired line’s metrics, this can now be used to set an x and y position of the to be returned Point(). as you see at the _x value, I’m just telling it to add the textfields x position to the width of the requested line, at the end we add the gutter value for the textfield.
The vertical position is another story, here we need to get the height of the desired line and multiply with it. this has the reason that there is no method available to get the proper y position of the line, so by multiplying the textheight with the desired line you get the proper y position of it. After that calculation we add the _lastCahr.ascent property of the line, asking what ascent? Take a look at the image below for more information about it but basically it’s just the length of the baseline to the top of the line height in pixels, so exactly the middle of our text.

Have a look at the image below for a nice and clean overview about the gutter of a flash textfield as well about the other properties a textfield has.

Something you should also be aware of is that the width of the text line is relative to the textfield width, but you need to subtract the gutter width of 4 pixels (2 pixels on each side ).

Now that our class is available let’s take a look at how I used it for this example.

var point:Point = StringUtil.getEndOfLine( tf, tf.numLines - 1 );
rect.x = point.x;
rect.y = point.y;

What we are doing here is nothing else then creating a new Point based on the position returned by our class, passing the textfield and specially since I want to have the rectangle on the LAST line I just ask for the textfields number of lines – 1.

When running this example above you should see the small red rectangle on the last line of our textfield. yay!!!

You can download the StringUtil class here: StringUtil.as
Hope this serves you as well as it served me last week, and don’t forget to leave a comment if you have any questions about it.

Last week while working on the interface for my new upcoming library I needed a way to save some data on the users computer, altough I’m working with AIR I could easily save an xml or a txt file to the users local computer, but as soon as I would start writing a pure as3 project I would have to rewrite it again, as I can’t be sure that the client will have Flash Player 10 or even the rights to save to it’s local harddisk, some people working at bigger companies are not allowed to save anything to their local harddisk due to security rights.

The solution for this is simple yet effective, you need to use SharedObjects aka. Cookies in Flash.

Shared Objects can do the following:

• Maintain Local Persistence: Saves data locally on the users drive, for example you could save the last application state or the score of the last game, create a local highscore list and many many more applications for local use.
• Store and Share Data on FMS: Basically the same as before, but with the difference that you saving the shared object on a flash media server. Good thing about it, it can be shared throughout multiple computers, the same user using the same application on multiple computers can save its data on a server.
• Share data in realtime: using FMS you can aswell for example save the state of a multiuser application saving the current state of the applcation, every new user will get the current state based on the shared object

More information about Shared Objects can be found HERE

Let me show you a few lines of code and explain what you can do with it.

The most basic example is how to write data into a shared object.

var _so:SharedObject;
_so = SharedObject.getLocal("myLocalData");
_so.data.firstname = "myfirstname";
_so.data.lastname = "mylastname";
_so.data.age = "30";
_so.flush();

In the example above we create a new variable called _so of the type SharedObject, after that we use the getLocal() method to create the shared object, if no shared object does not already exist it will be created. if the call fails or the parameters passed along are invalid, flash throws an exception. Calling the flush() method the data will be saved to the users local harddisk.

Next up lets see how you can read from a persistent shared object.

var _so:SharedObject;
_so = SharedObject.getLocal("myLocalData");
trace( _so.data.firstname); //traces myfirstname
trace(_so.data.lastname); // traces mylastname
trace(_so.data.age); // traces 30

This time we do basically the same as before, but instead of saving data we call data, when calling _so.data.age you are going to grab the sharedobjects property named age which results in 30.

If you rather prefer to save SharedObjects to an FMS, you can use it this way:

var _nc:NetConnection;
var _so:SharedObject;
 
_nc = new NetConnection();
_nc.connect("rtmp://yourFMSserver/yourAppName");
_so = SharedObject.getRemote("myRemoteData", nc.uri, false);
_so.connect( nc );
_so.setProperty( "names", {firstame:myfirstname, lastname:myLastname} );
_so.setProperty( "age", {"30"} );

This time we create a new NetConnection to the Flash Media Server and it’s application, calling the getRemote() method acts the same as using the getLocal() method, but you also need to pass the netconnections URI to be able to save the the sharedobject remotely.
Differently from the local version we use the setProperty() method to save data on the remote Shared Object.

These are the basics for handling Shared Objects, if you have any further questions just drop me a line and I might be able to help you out.

Facebook.. Could you live without facebook nowadays? Sometimes I’m happy when I don’t get anything on facebook, just to have a bit of peace and quiet of it.

Well, nevertheless, I’m writing this article because I’ve seen this post on the Adobe Forums by dmennenoh where he asked for the possibilities of using the Facebook AS3 API without Flex or AIR and the possibility of uploading pictures to Facebook.

Short answer: yes, it’s possible but…. it’s not a very well documented process of achieving it.

Before we start, I would like to recommend you a few tutorials on the Adobe Developer Connection, Jeanette Stallons wrote a whole series about the usage of the Facebook AS3 API, and it’s an absolute must read if you want to start developing flash applications or websites using facebook data and connectivity. First I recommend you starting with the Quick Start to get a feeling for it, after that move on to Part 1: Build and Test Locally, Part 2: Deploy on Facebook and Part 3: Deploy using Facebook Connect

First of all before we start be sure to get the newest FacebookAS3 library, be sure to download the Flash version of it. At this point the current version is Facebook_library_v3.4_flash.swc you can get newest version on the Project page.

As I prefer using MinimalComps by Keith Peters (aka. BIT-101) we are going to download his classes here. If you don’t know MinimalComps, it’s a set of components like you know from Flex or the Flash IDE, it contains the default set of components like button, textfield, textarea, but also has various interesting components like dials, calendars, knobs and much much more. I strongly recommend you read through the documentation and work through a few tutorials so you get your hands dirty with it.
Again this is not a MUST-USE, I just feel more comfortable using these then any other components.

I strongly recommend to use the deMonsterDebugger to trace events and data returned from facebook, it has a simple to use interface and is far better then the normal trace() functionality.

1. Setup
1.1 Let’s start by opening Flash Builder and creating a new Actionscript Project with the name FacebookAS3. We are not going to use any Flex Components neither any AIR methods, you could also build this in the Flash IDE, but I prefer to use Flash Builder for it’s Code Completion features and it’s the tool I prefer when coding AS3.

1.2 Import the .SWC file by right clicking on the Project name and selecting Properties, then go to Actionscript Build Path and select the Library path tab, press the Add SWC button and locate the downloaded facebook_library_flash.swc you downloaded previously. Press OK and we are ready to go.

1.3 If you using MinimalComps for the UserInterface, don’t forget to import the source to your project so you can use them properly.

1.4 If you using deMonsterDebugger to trace and debug your application, don’t forget to import the needed classes to your project src folder.

2. Login
Below you will find my main class that handles the whole login procedure of our small application.

public class Main extends Sprite
	{
		private static const API_KEY	:String				= "xxxxx";
		private static const SECRET	:String				= "xxxxx";
 
		private var _overlaySprite		:Sprite;
		private var _userInterface		:UserInterface;
		private var _photoBA			:ByteArray;
 
		private var _fb					:Facebook;
		private var _fbSession			:FacebookSessionUtil;
		private var _userData			:FacebookUser;
		private var _uid				:String;
		private var _batchCollection	:BatchCollection;
		private var _batchRun			:BatchRun;
		private var _albumArray			:Array;
		private var _uploadPhoto		:UploadPhoto;
 
		public function Main()
		{
			MonsterDebugger.trace(this, "init - Facebook integration" );
 
			stage.scaleMode = StageScaleMode.NO_SCALE;
			stage.align		= StageAlign.TOP_LEFT;
 
			_overlaySprite = new Sprite();
			_overlaySprite.graphics.beginFill(0xcccccc, 0.5 );
			_overlaySprite.graphics.drawRect( 0, 0, stage.stageWidth, stage.stageHeight );
			_overlaySprite.graphics.endFill();
			addChild( _overlaySprite );
			_overlaySprite.visible = false;
 
			_userInterface				= new UserInterface();
			_userInterface.addEventListener( Event.SELECT, uploadImage );
			addChild( _userInterface );
			_userInterface.visible = false;
			login();
		}
 
		private function login():void
		{
			_fbSession					= new FacebookSessionUtil( API_KEY, SECRET, loaderInfo );
			_fb							= _fbSession.facebook;
 
			_fbSession.addEventListener( FacebookEvent.CONNECT, connectHandle );
			_fbSession.addEventListener( FacebookEvent.WAITING_FOR_LOGIN, loginWaitHandler );
 
			_fbSession.login();
 
		}
 
		private function connectHandle( e:FacebookEvent ):void
		{
 
			if ( e.success )
			{
				_uid 					= ( e.data as GetSessionData ).uid;
 
				_batchCollection		= new BatchCollection();
				_batchCollection.addItem( new HasAppPermission( HasAppPermissionValues.PHOTO_UPLOAD ) );
				_batchCollection.addItem( new GetInfo([_uid], [GetInfoFieldValues.FIRST_NAME, GetInfoFieldValues.CURRENT_LOCATION]));
				_batchCollection.addItem( new GetAlbums() );
 
				_batchRun				= _fb.post( new BatchRun( _batchCollection ) ) as BatchRun;
				_batchRun.addEventListener( FacebookEvent.COMPLETE, batchCompleteHandler );
			}
		}
 
		private function batchCompleteHandler( e:FacebookEvent ):void
		{
			if ( e.success )
			{
				var results:Array = ( e.data as BatchResult ).results;
 
				var hasPermission:BooleanResultData = results[0];
				var getInfoResult:GetInfoData = results[1];
				var getAlbumsResult:GetAlbumsData = results[2];
 
				if ( !hasPermission.value )
				{
					MonsterDebugger.trace(this, "no permission" );
					getPermissions();
				}
 
					/*_userData = getInfoResult.userCollection.getItemAt(0) as FacebookUser;
					_userInterface.username = _userData.first_name + _userData.last_name;
					_userInterface.albumList = getAlbumsResult.albumCollection.toArray();*/
 
			}
 
		}
 
		private function getPermissions():void
		{
			_fb.grantExtendedPermission( ExtendedPermissionValues.PHOTO_UPLOAD );
		}
 
		private function uploadImage( e:Event ):void
		{
			_uploadPhoto = new UploadPhoto(_userInterface.snapshot);
			_fb.post(_uploadPhoto);
		}
 
		private function loginWaitHandler( e:FacebookEvent ):void
		{
			_overlaySprite.visible = true;
			_overlaySprite.addEventListener( MouseEvent.CLICK, confirmConnect );
		}
 
		private function confirmConnect( e:MouseEvent ):void
		{
			_overlaySprite.visible = false;
			_userInterface.visible = true;
			_overlaySprite.removeEventListener( MouseEvent.CLICK, confirmConnect );
			_fbSession.validateLogin();
		}
	}

Let’s take a look at what’s happening here, first of all we create instances of the facebook and the facebooksessionutil classes, those are going to help using Facebook throughout the whole application.
We setup an overlaysprite (this could also be a simple button or an alert panel) that will let us know when the user came back from the facebook login page. When the overlaysprite is clicked we validate the login and enable our userinterface. When the user is connected successfully to the application we start our BatchCollection to make multiple calls to FB, We check if the user has allowed permission to upload pictures, get his basic information like id, name and so on, and also get the album list from his profile (currently not working due to API bug)
When the batch is completed we assign the result to various variables and check the status of the extended permission if this is false, then we ask the user to confirm the permission so we are able to upload pictures, the getPermission() method.
After that we are ready to move on to our interface.

In this example I’m not going to create a seamless experience with Facebook that you know from other applications mostly on Mobile Phones, that involves a bunch of HTML and Javascript scripting and is covered on Jeanette Stallons Part 3: Deploy using Facebook Connect

3. Interface (UserInterface.as)
Next up we are going to create a simple interface so you can preview the webcam image and take a snapshot, we also going to create a small logger window so we get informed about what’s going on without having to switch to the deMonsterDebugger to view the status. Therefore I’m going to create a custom class named UserInterface which will have the visual assets and placeholders for the data received.

Below the Userinterface.as class:

public class UserInterface extends Sprite
	{
		private var _video			:Video;
		private var _camera			:Camera;
 
		private var _bitmap			:Bitmap;
		private var _bitmapData			:BitmapData;
 
		private var _snapshotBA			:ByteArray;
 
		private var _pushButton			:PushButton;
 
		private var _albumArray			:Array;
		private var _albumList			:List;
 
		public function UserInterface()
		{
			_camera				= Camera.getCamera();
			_camera.setMode( 640, 480, 25, true );
			_video				= new Video( _camera.width / 2, _camera.height / 2 );
			_video.attachCamera( _camera );
			addChild( _video );
 
			_pushButton				= new PushButton();
			_pushButton.width			= 80;
			_pushButton.x				= _video.width - _pushButton.width;
			_pushButton.y				= _video.height + 5;
			_pushButton.label			= "CAPTURE";
			_pushButton.addEventListener( MouseEvent.CLICK, createSnapshot );
			addChild( _pushButton );
 
			_bitmapData				= new BitmapData( _camera.width / 2, _camera.height / 2 );
			_bitmap					= new Bitmap( _bitmapData );
 
		}
 
		private function createSnapshot( e:MouseEvent ):void
		{
			_bitmapData.draw( _video );
			_video.visible = false;
			addChild( _bitmap );
 
			var enc:JPGEncoder = new JPGEncoder( 80 );
			_snapshotBA = enc.encode( _bitmapData );
 
			_pushButton.removeEventListener( MouseEvent.CLICK, createSnapshot );
			_pushButton.label = "UPLOAD IMAGE";
			_pushButton.addEventListener( MouseEvent.CLICK, sendSnapshot );
		}
 
		private function sendSnapshot( e:MouseEvent ):void
		{
			dispatchEvent( new Event( Event.SELECT ) )
		}
 
		private function createList():void
		{
			_albumList			= new List( this, _video.x + _video.width + 20, _video.y, _albumArray );
			addChild( _albumList );
 
		}
 
		public function set albumList( arr:Array ):void
		{
			_albumArray = arr;
			//MonsterDebugger.trace(this, _albumArray );
			//createList();
		}
 
		public function get snapshot():ByteArray
		{
			return _snapshotBA;
		}
	}

As you see I’m creaing a Camera instance with the size of 640x480px and attaching it to a video class to be displayed on the stage at halfsize, you could also keep it the full size but I prefer working with the 320×240 format.
The Bitmap and BitmapData instances are created and create a getter to return the bytearray to our mainapplication.

4. Using the Webcam
Let’s take a quicklook what we are doing to take a snapshot of the webcam and how to prepare the image to be uploaded to Facebook. As mentioned on my previous post we take a snapshot of the webcam by creating a bitmapdata of it, then we use the JPGEncoder classes from the AS3Corelib (these are as well already inside the AS3Facebook Library) and encode them into a ByteArray.

private function createSnapshot( e:MouseEvent ):void
		{
			_bitmapData.draw( _video );
			_video.visible = false;
			addChild( _bitmap );
 
			var enc:JPGEncoder = new JPGEncoder( 80 );
			_snapshotBA = enc.encode( _bitmapData );
}

5. Choosing Album and uploading Picture
As mentioned before there is currently a bug with the AS3Facebook API 3.4, you cannot get the Albumlist from the logged in user, even if you give the application the proper extended permissions. So in our case we are just going to upload our photos to the default album, now you’re asking what’s the default album?

It’s not very clear to me as well, but basically Facebook creates a Photoalbum for every application that uploads an image to it, let’s say your application is called “APU” the user using the application will get a APU PhotoGallery folder in his profile. So choose wisely what name your application will have.

Below the upload code:

private function uploadImage( e:Event ):void
		{
			_uploadPhoto = new UploadPhoto(_userInterface.snapshot);
			_fb.post(_uploadPhoto);
		}

That’s it, the most difficult part developing applications using Facebook is barely the way the whole data communication works, the API is very stable and things work well ( let’s forget the GetAlbum bug ).
Most tutorials out there have been written for Flex or AIR, simply because it gives you the best userinterface to handle FB needs nevertheless I prefer using pure AS3.

This time I didn’t want to create a nice interface to use it, as this is solely a programming article, feel free to modify it, download it, share it, whatever you would like to do with it.

You can download the project here: Source (Flash Builder Project)

While writing my next post, about Facebook and Flash development, I noticed that there is something in my post drafts that I haven’t published yet, so I changed it a bit and here you go.

On one of my last posts taking a screenshot with AS3 I’ve explained how to create a snapshot by using the Bitmap and the BitmapData classes.

Sometimes you need to convert the bitmaps to bytearrays to send them to a server-side script, save it directly to an AIR database or send it with AMF.

Something that is still a bit unclear, is how to convert the freshly created BitmapData to a ByteArray, there are no methods available in the default packages that come along with Flash Builder or Flash Professional, there are a few other ways, but they are in my opinion not really the best way on doing it. After all we all like to write short, smart clean code right?

Make sure you download the JPG/PNG Encoder classes from the AS3 corelib, without these you will not be able to create a proper bytearray of the snapshot,

To start off, let’s refresh our memory on how to create a bitmapdata.

_bitmapData					= new BitmapData( _sprite.width, _sprite.height );
_bitmap						= new Bitmap( _bitmapData );
_bitmapData.draw ( _sprite );
addChild( _bitmap );

Now that we remember how we create the bitmapdata object, let’s move on to the creation of a ByteArray, don’t be afraid it’s really easy, and it doesn’t cost you more then two lines of code.

var enc:JPGEncoder = new JPGEncoder( 80 );
var _snapshotBA = enc.encode( _bitmapData );

That was it, as you see, I kept my promise, only 2 lines of code to create a ByteArray.

Stay tuned for the next post.

Based on this post on the Adobe’s AS3 forum, I thought  I would create a simple class that takes care of the requested task.

The whole idea is basically to draw a line dynamically between 2 displayobjects, on top of it when one object is being dragged the line is redrawn along based on the second sprite position.

There is  a lot more that can be done, like avoiding other sprites, drawing multiple lines attached to multiple buttons and so on. but I think this class can give you a good head start for future implementations.

First of all there are a few things that we need to consider before starting, let’s take a look at the first few tasks

1. Every Sprite needs to know to which button it has been linked to. You need to store this somewhere.
2. Every Sprite needs a specific anchor point that is used as endpoint of the drawn line.
3. As soon the drag method is started we need to know where  the one end of the line (from the sprite that is not being dragged by the mouse) is positioned at. This is something that we really need to do once on a startDrag method.

Here’s what I’ve done:
Based on the notices above, I’ve created a new Class called ConnectedSprite a simple class which extends the Sprite Class but with a few more options that helps us towards our goal and this is how our class looks like:

package
{
	import flash.display.DisplayObject;
	import flash.display.Sprite;
	import flash.geom.Point;
 
	public class ConnectedSprite extends Sprite
	{
		private var _anchorPoint			:Point;
		private var _relativeObject		:ConnectedSprite;
 
		public function ConnectedSprite()
		{
			super();
		}
 
		public function set anchorPoint ( p:Point ):void
		{
			_anchorPoint = p;
		}
 
		public function get anchorPoint():Point
		{
			return _anchorPoint;
		}
 
		public function set relativeObject ( co:ConnectedSprite ):void
		{
			_relativeObject = co;
		}
 
		public function get relativeObject():ConnectedSprite
		{
			return _relativeObject;
		}
	}
}

Just to give you quick overview of what we are doing here:
Basically we are extending the Sprite class and adding two new variables _anchorPoint and _relativeObject, those are accessible by using getters & setters.
The _anchorpoint variable holds a fixed x and y position where our line should connect to and the _relativeObject has a reference to the other sprite which is being conntected to.
Pretty simple but effective.

That was already it, we now just need to create two new ConnectedSprite instances pass the needed values and there you go, below the BaseClass I’ve built for this example:

public class AnchoredSprite extends Sprite
	{
		private var _spriteA			:ConnectedSprite;
		private var _spriteB			:ConnectedSprite;
 
		private var _movingTarget		:ConnectedSprite;
		private var _staticTargetPos		:Point		= new Point();
 
		private var _connector			:Sprite;
 
		public function AnchoredSprite()
		{
			_connector = new Sprite();
			addChild( _connector );
 
			_spriteA = new ConnectedSprite();
			_spriteA.graphics.beginFill( 0xff0000, 1 );
			_spriteA.graphics.drawRect( 0, 0, 50, 50 );
			_spriteA.graphics.endFill();
			_spriteA.anchorPoint = new Point( _spriteA.width / 2, _spriteA.height / 2 );
			addChild( _spriteA );
			_spriteA.addEventListener( MouseEvent.MOUSE_DOWN, mouseDownHandler );
			_spriteA.addEventListener( MouseEvent.MOUSE_UP, mouseUpHandler );
 
			_spriteB = new ConnectedSprite();
			_spriteB.graphics.beginFill( 0x0000ff, 1 );
			_spriteB.graphics.drawRect( 0, 0, 50, 50 );
			_spriteB.graphics.endFill();
			_spriteB.anchorPoint = new Point( _spriteB.width / 2, _spriteB.height / 2 );
			addChild( _spriteB );
			_spriteB.addEventListener( MouseEvent.MOUSE_DOWN, mouseDownHandler );
			_spriteB.addEventListener( MouseEvent.MOUSE_UP, mouseUpHandler );
 
			_spriteA.relativeObject = _spriteB;
			_spriteB.relativeObject = _spriteA;
		}
 
		private function mouseDownHandler( e:MouseEvent ):void
		{
			e.target.startDrag( false );
			_movingTarget = e.target as ConnectedSprite;
			_staticTargetPos.x = _movingTarget.relativeObject.x + _movingTarget.relativeObject.anchorPoint.x;
			_staticTargetPos.y = _movingTarget.relativeObject.y + _movingTarget.relativeObject.anchorPoint.y;
			addEventListener( MouseEvent.MOUSE_MOVE, drawLine );
		}
 
		private function mouseUpHandler( e:MouseEvent ):void
		{
			e.target.stopDrag();
			_movingTarget = null;
 
			removeEventListener( MouseEvent.MOUSE_MOVE, drawLine );
		}
 
		private function drawLine( e:MouseEvent ):void
		{
			_connector.graphics.clear();
			_connector.graphics.lineStyle( 1, 0x333333 );
			_connector.graphics.moveTo( _staticTargetPos.x, _staticTargetPos.y );
			_connector.graphics.lineTo( _movingTarget.x + _movingTarget.anchorPoint.x, _movingTarget.y + _movingTarget.anchorPoint.y );
			e.updateAfterEvent();
		}
	}

it’s quite a long base class for this simple task, it could have been reduced using other drawing methods, but that is something that I leave up to you.

Below a working example and you can download the source files here: ConnectedSprite

Who doesn’t know SWFObject & SWFAddress? These two JavaScript buddies are the best a serious Flash Developer can have.

SWFObject embeds your Flash nicely and browser independent, it has gone a long way and now it’s even the default publishing method in Flash Builder and Flash Catalyst (not sure about Flash CS5 ), you can read a more detailed history on the projects history site.

SWFAddress is a small library that provides deep-linking functionality in your Flash projects, it enables you to create unique virtual URL’s which enables Search Engines to index your flash content and of course the utilisation of the browsers back and forward buttons eg. history capabilities.

Usually in our development process we integrate these 2 buddies right at the beginning of the project, before we even code any AS3 line, these two are already in the html template inside FlashBuilder. Last time I started a new project I downloaded the latest versions (at that time) from these libraries and implemented them. Everything was working fine, and it works fine, but sadly only on FF3+ and IE8.. what happened to the strength of SWFObject?

After scrolling through a few posts and forums I decided to gradually downgrade every version of each Library backwards to see what happens. I must mention that the default embedding and display of flash content works perfectly, but when you need to send flashvars or parameters to your swf, there’s when things break.

Solution?
It’s an easy one, but painful to find out as it took me a few hours to get it to work.
SWFObject and SWFAddress are in deed buddies, but they need to be coordinated  properly.

First pitfall:
The order that the javascript is being placed is very important, you NEED to place it in the order:
1. SWFObject 2. SWFAddress all other Javascripts you might have in place shouldn’t bother these two, but it’s always safer to put your custom stuff after the SWFAddress import.

Second pitfall:
There are various versions of each library some work together some don’t. I didn’t had the time to create a nice working table, but I promise you that I’m going to post one in the near future, but I can tell you what definately works 100%, SWFObject 2.2 & SWFAddress 2.2, yes both libraries with the same version number.

Third pitfall:
Sometimes ( I can’t tell you in which formation ) flashvars as parameters don’t get through to the SWF, the only workaround I found was to instead of using a parameters array I’ve passed an arguments array, that fixed all the troubles.

I know it’ s weird and I would like to elaborate more on this, but currently I just don’t have the time to do it, but don’t be afraid I will get a list up soon with my testing results.
If you have any questions to this topic, drop me a line and I will try to help you out.

UPDATE:
Changed version numbers from 2.3 to 2.2, thanks to Ven

During the last project I worked on for ChocolatFrey I had a small problem that was bugging me. with the help of our inhouse stagemanager class where you can define minimum width & height of the stage the flash website always looked good, but as sson as the screen was smaller then the minimum defined width & height it broke the layout.
After a few minutes of searching I found this awesome little JavaScript called SWFFit it resizes the flash movie based on the minimum dimensions set.

The usage of it is let’s say SIMPLE!! Even if you didn’t really care about JS, you can easily understand how it works, this is a simple example of how to use it:

swffit.fit("my_flash", 960, 670);

What the script above would do, is just create browser scrollbars when the defined size has been reached.
You can even set more options like min/max width & height and how the flash content should be centered.

Below a short explanation of the possible options:

swffit.fit('flashID', minW, minH, maxW, maxH, hCenter, vCenter);

flashID: the id of the flash embed/object tag
minW: minimum width in pixels
minH: minimum height in pixels
maxW: maximum width in pixels
maxH: maximumheight in pixels
hCenter: flash content will be centered horizontally when the maximum size has been reached ( Boolean )
vCenter: flash content will be centered vertically when the maximum size has been reached ( Boolean )

This is one of the Javascripts that should always be handy as Flash Developer together with SWFObject & SWFAddress.

So go have a look at it, and try it out, I can only recommend it and give a big thank you out to Miller Medeiros for sharing this with us.