Youtube AS3 Wrapper
I started building this AS3 to AS2 youtube wrapper some time back, from the need to add youtube support to actionscript 3 projects, and now i decided to share it.
I tried some of the wrappers available out there, some are good, soom are pretty bad but all of them had all sorts of issues. Some had problems with volume, some were not capable of supporting more than 1 instance of a player on the same page, some were using javascript which i found inacceptable, so i started writing my own wrapper.
SEE A TEST PLAYER HERE
DOWNLOAD WRAPPER HERE
SEE A HOW TO START TUTORIAL HERE
SEE FULL DOCUMENTATION HERE
SEE A MULTIPLE INSTANCES SAMPLE HERE
What came out, i might say that’s probably the best wrapper available yet: it uses LocalConnection to communicate to the As2 youtube player, but it’s still very responsive and fast.
Very easy to use, follows the youtube as2 chromeless style: load a swf, listen for a ready event and then you’re good to go!
It uses interfaces to support code completion on editors that support it: FDT, Flex Builder, Flash Develop, etc.
Small in size: 2 swf files – ytPlayer.swf only 4,230 Bytes <=> 4.13 KB
– ytODLCWrapper.swf only 4,305 Bytes <=> 4.20 KB
Optimized for responsivness – reduced to the minimum the number of LocalConnection calls
Uses the same method calls as youtube api with some minor changes and some additions.
So, for someone familiar with the youtube api will find this very easy to use.
And it’s also easy for the one that starts his way into youtube just now, with just a few lines of code youtube will be set up and running.
So how does this work?
As i mentioned above, there a are these 2 swf file: ytPlayer.swf and ytODLCWrapper.swf.
ytPlayer.swf is the as3 version, and the one that’s most important to you.
ytODLCWrapper.swf is the as2 version, and it’s handled in the background, you don’t need to worry about this one.
There is 1 interface
and 1 class
is the player, has all the methods of the player and
is the type of event that will be thrown by IYoutube.
There are only 3 types of events:
dispatched when the player is ready to play video clips: only after this event is fired, the methods can be called
dispatched when an error occurs: when this event is fired, a next clip should be played (in example)
dispatched when the player changes state
The error codes and player states are the same as for youtube as2.
returns the current error code, if any error occured for the current clip, or 0 if no error: error codes -> 100 – video not found, 101 and 150 – playback not allowed in users region or in chromeless player
returns the current state:
player states -> -1=Unstarted,0=Ended,1=Playing,2=Paused,3=Buffering,5=Video cued.
The first thing to do is to load ytPlayer.swf in a
object.
Youtube requires a developer key, in order to correctly pass the key load ytPlayer.swf with the apiKey=XXXXXX.. parameter
Example:
var loader : Loader = new Loader();
...
..
loader.load(new URLRequest("ytPlayer.swf?apiKey="+apiKey));
When the loading completes, Event.COMPLETE event fired, add the loader to the stage’s display list (can be through a child of the stage).
You should have
declared.
Set this variable to be the content property of the Loader object.
Example:
....
ytPlayer = loader.content as IYoutube;
Now we can start listening for the events mentioned:
ytPlayer.addEventListener(YoutubeEvent.PLAYER_ERROR, onYTPlayerError);
ytPlayer.addEventListener(YoutubeEvent.PLAYER_STATE_CHANGE, onYTPlayerStateChange);
Now we must declare the listener functions.
Inside onYTPlayerReady we can write some initializing code, or you can go ahead and play some video right frome there.
// maybe set the size
ytPlayer.setSize(500, 400);
// maybe set volume
ytPlayer.setVolume(80);
// maybe play a clip
ytPlayer.loadClip("0_fPV13lKm4");
}
function onYTPlayerError(event : YoutubeEvent) : void {
// maybe check the error code and do something based on it
switch(ytPlayer.getPlayerError()) {
case 100:
case 101:
case 150:
default: // maybe play a next clip
}
}
function onYTPlayerStateChange(event : YoutubeEvent) : void {
// maybe get the player state and do something based on it
switch(ytPlayer.getPlayerState()) {
case -1: break; // Unstarted
case 0: break; // Ended
case 1: break; // Playing
case 2: break; // Paused
case 3: break; // Buffering
case 5: break; // Video cued - when using cueVideo() method on ytPlayer
default: // Unknown
}
}
Of course you can handle play, pause.. and any other methods of the ytPlayer object,
just make sure you test that the player is loaded and ready
Example:
{
// call methods here
ytPlayer.playVideo();
}
Below is a implementation of this wrapper in a “test harness” player.
The test player is written in flex, but absolutelly the same principles work in flash too. (except the mxml code)
The entire source code for the player can be downloaded here.
The code is commented out (only what’s related to the wrapper and youtube).
The wrapper files can be downloaded here.
To start playing a video, click one title on the right or copy and paste a youtube video id (or entire link) in the Custom youtube input text field and click Load.
