Un simple player para ficheros MP3 y su implementación.

[as]
package com.mattimatti.media.player
{
import flash.events.ErrorEvent;
import flash.events.Event;
import flash.events.EventDispatcher;
import flash.events.IOErrorEvent;
import flash.events.ProgressEvent;
import flash.media.Sound;
import flash.media.SoundChannel;
import flash.net.URLRequest;

import mx.logging.ILogger;

[Event(name="loadcomplete", type="flash.events.Event")]

[Event(name="error", type="flash.events.ErrorEvent")]

[Event(name="stateChange", type="flash.events.Event")]

[Event(name="finished", type="flash.events.Event")]

public class Mp3Player extends EventDispatcher
{

private var sound:Sound;
private var channel:SoundChannel;
private var _position:Number = 0;
public var log:ILogger;
private var _paused:Boolean = false;
private var _loaded:Boolean = false;

public function Mp3Player() {
super();
}

/**
* facade switch for play pause buttons
*
*/
public function playOrPause():void {
if(paused){
play()
}else{
pause();
}

}

/**
* Pauses the current stream
*
*/
public function pause():void {
if(channel){
_position = channel.position;
channel.stop();
_paused = true;
changeState();
}

}

[Bindable]
public function get loaded():Boolean {
return _loaded;
}

public function set loaded(value:Boolean):void {

}

[Bindable]
public function get paused():Boolean {
return _paused;
}

public function set paused(value:Boolean):void {

}

/**
* Plays a sound
*
*/
public function play():void {
if(sound){
if(_paused){
channel = sound.play(_position);

}else{
channel = sound.play();
}
_paused = false;

channel.addEventListener(Event.SOUND_COMPLETE, endPlayHandler);

changeState();
}
}

/**
* Plays a sound
*
*/
public function clear():void {
try{

if(channel)channel.stop();
if(sound)sound.close();
_loaded = false;
_paused = false;

changeState();

}catch(error:Error){
if(log)log.error(error.message);
}
}

/**
* Load a Mp3 file an play
* @param inUrl
* @return Boolean if success
*
*/
public function load(inUrl:String):Boolean {

var stream:URLRequest = new URLRequest(inUrl);

try{

_loaded = false;

sound = new Sound();

sound.addEventListener(IOErrorEvent.IO_ERROR,onloadError);
sound.addEventListener(ProgressEvent.PROGRESS, onLoadProgress);
sound.addEventListener(Event.COMPLETE, onLoadComplete);

changeState();

sound.load(stream);

}catch(error:Error){
if(log)log.error(error.message);
return false
}
return true;
}

/**
*
* @param event
*
*/
private function onLoadProgress(event:ProgressEvent):void {
var loadedPct:uint = Math.round(100 * (event.bytesLoaded / event.bytesTotal));
// trace(“The sound is ” + loadedPct + “% loaded.”);
}

private function endPlayHandler(event:Event):void {
changeState(“finished”);
clear();
}

/**
*
* @param event
*
*/
private function onLoadComplete(event:Event):void {
var localSound:Sound = event.target as Sound;
_paused = false;
_loaded = true;
changeState(“loadcomplete”);
play();
}

/**
*
* @param event
*
*/
private function changeState(inEventType:String=null):void {
if(inEventType)dispatchEvent(new Event(inEventType,true,false));
dispatchEvent(new Event(“stateChange”,true,false));
}

/**
*
* @param event
*
*/
private function onloadError(event:IOErrorEvent):void {
dispatchEvent(new ErrorEvent(ErrorEvent.ERROR,true,false));
dispatchEvent(new Event(“stateChange”,true,false));
}

}
}
[/as]

Implementación en MXML en un canvas

[as]

creationComplete="creationCompleteHandler()"
>

import mx.logging.ILogger;

private var log:ILogger;

private function creationCompleteHandler(event:Event=null):void {

if(log)log.debug("creationCompleteHandler");
try{
var url:String = "some.mp3";

player.clear();
player.load(url);

}catch(error:Error){
if(log)log.error("error: " + error.message);
}
}

private function stateChangeHandler(event:Event):void{
if(log)log.debug("stateChangeHandler");
}

private function loadcompleteHandler(event:Event):void{
if(log)log.debug("loadcompleteHandler");
}

private function finishedHandler(event:Event):void{
if(log)log.debug("finishedHandler");
}

]]>