/*
 * Xorax AS2 Player - Action Script 2 flash class for designer
 *
 * Copyright (c) 2008 Martin Panel (contact@xorax.info)
 * licensed under the MIT (MIT-LICENSE.txt)
*/
/**
 * @see <a href="http://xorax.info/labs/flash-mp3-player-as2/">flash mp3 player as2</a>
 * @author <a href="http://www.xorax.info/">Xorax</a>
 * @license http://www.opensource.org/licenses/mit-license.php copyright Martin PANEL : MIT license
 * @version 20080523
 * @description fournit les fonctions nécéssaires à la lecture de fichier audio.
 */
 
 class xorax.player.base {
	private var playing;
	private var loading:Number;
	private var _src;
	private var sound:Sound;
	private var volume;
	private var responders;
	private var pausedAt:Number;
	
	/**
	 * source du son (fichier mp3, flux...)
	 */
	public var src:String;
	
	/**
	 * Le son doit-il être traité comme un flux. si oui la lecture démarre dés que possible. (par défaut : true)
	 */
	public var streaming:Boolean;
	
	/**
	 * cran d'incrémentation du volume (par default: 10)
	 */
	public var volumeStage:Number;
	
	/**
	 * si = true, alors le constructor cherchera les variables passées en paramètre à l'animation (_root.*)
	 */
	public static var auto:Boolean = true;
	/**
	 * constructeur de la classe
	 * @param	auto	autoconfigure le lecteur en fonction de flashvars (variables disponibles sur _root)
	 * il existe 3 variables de configuration :
	 *	- callable : exporte certaines fonctions pour qu'elle soit disponible en javascript dans la page html
	 *	- src : url de la source audio. permet de préconfigurer le son (mp3, stream ou autre) à jouer.
	 *	- auto : démarre automatiquement la lecture lorsque l'animation est chargé.
	 *	exemple :
	 *	_root.src = 'son.mp3';
	 *	var myPlayer = new xorax.player.base(true);
	 *	//myPlayer a préenregistré la valeur _root.src en tant que source audio.
	 *	myPlayer.play(); // va démarrer la lecture de 'son.mp3'
	 */
	function base (){
		//this.config = {};
		this.playing = -1;
		this.loading = -1;
		this.pausedAt = -1;
		//this.src = undefined;
		this.sound = new Sound();
		this.sound.setVolume(100);
		this.volume = this.sound.getVolume();
		this.streaming = true;
		this.responders = {};
		AsBroadcaster.initialize(this.responders);
		this.volumeStage = 10; //int interval for up/down volume
		var th = this;
		this.sound.onSoundComplete = function(){th.onComplete();};
		this.sound.onLoad = function(succ){th.onLoading(succ);};
		
		if(xorax.player.base.auto){
			if(_root.callable !== false) this.initExternalMethod();
			if(_root.src) this.src = _root.src;
			if(this.src && _root.autoplay) this.play();
		}
	}
	
	function addListener (obj){
		this.responders.addListener(obj);
	}
	
	function removeListener (obj){
		this.responders.removeListener(obj);
	}
	
	function onLoading (success){
		/*if(this.playing === false){
			this.sound.start(0);
			this.playing = setInterval(this,"onPlaying",200);
		}*/
		if(success && this.isOnLoading()){
			this.sound.onLoad = null;
			clearInterval(this.loading);
			this.loading = -1;
		}
		this.responders.broadcastMessage('onLoading',success);
	}
	
	function onPlaying (){
		this.responders.broadcastMessage('onPlaying');
	}
	
	function onComplete (){
		this.stopPlaying();
		this.pausedAt = -1;
	}
	
	/**
	 * Permet de connaitre la durée du son en millisecond. Si le chargement du son est en cour, la durée est approximative.
	 * @return int la durée du son chargé en millisecond
	 */
	public function duration ():Number {
		if(this.isOnLoading()){
			if(!this.sound.duration){
				return this.position() * this.sound.getBytesTotal() / this.sound.getBytesLoaded();
			} else {
				return this.sound.duration * this.sound.getBytesTotal() / this.sound.getBytesLoaded();
			}
		} else return this.sound.duration;
	}
	
	/**
	 * Si msec est défni, la tête de lecture se déplacera à msec milliseconde (ou plutôt à msec/1000 seconde) et commencera la lecture.
	 * Sinon, renovi la postion de la tête de lecture en milliseconde.
	 * @param	msec	en milliseconde (arrondie plus tard à la second). (optionnel)
	 */
	function position (msec:Number):Number {
		if(msec == null) return (this.sound.position) || 0;
		if(this.isOnLoading() && this.sound.duration - _root._soundbuftime*1000 < msec ){
			this.sound.start(this.sound.duration/1000 - _root._soundbuftime);		
		} else this.sound.start(msec/1000);
		this.startPlaying();
		return this.position();
	}
	
	function startPlaying ():Void {
		if(!this.isOnPlaying()){
			this.responders.broadcastMessage('onStart');
			this.playing = setInterval(this,"onPlaying",50);
			this.volumeSet(this.volume);
		}
	}
	
	function stopPlaying ():Void {
		if(this.isOnPlaying()){
			clearInterval(this.playing);
			this.playing = -1;
		}
	}
	
	/**
	 * renvoi si oui ou non le son est en cour de lecture.
	 */
	public function isOnPlaying ():Boolean {
		return (this.playing !== -1);
	}
	
	/**
	 * renvoi si oui ou non le son est en cour de chargement
	 */
	public function isOnLoading():Boolean {
		return (this.loading !== -1);
	}
	
	/**
	 * renvoi si oui ou non le son est en pause
	 */
	public function isOnPause():Boolean {
		return (this.pausedAt !== -1);
	}
	
	/**
	 * renvoi le nombre de Bytes télécharger pour le son en cour
	 */
	public function getBytesLoaded():Number {
		return this.sound.getBytesLoaded() || 0;
	}
	
	/**
	 * renvoi la taille en Bytes du son en cour
	 */
	public function getBytesTotal():Number {
		return this.sound.getBytesTotal() || 0;
	}
	
	/**
	 * joue le son, redémarre un son qui était en pause
	 * @param	src	nouvelle source du son (optionnel)
	 */
	public function play (src:String):Void{
		if(src) this.src = src;
		if( this.src != this._src){
			this.stop();
			this._src = this.src;
			this.loading = setInterval(this,"onLoading", 100, false);
			var th = this;
			this.sound.onLoad =  function(s){th.onLoading(s);};
			this.sound.loadSound(this._src,this.streaming);
			if(this.streaming) this.startPlaying();
		} else{
			if(this.isOnPause()){ // && this.playing
				this.sound.start(this.pausedAt);
				this.pausedAt = -1;
			} else {
				this.sound.start(0);
			}
			this.startPlaying();
		}
	}
	
	/**
	 * met le son en pause
	 */
	public function pause ():Void{
		this.stopPlaying();
		if(!this.isOnPause()) this.pausedAt = Math.round((this.sound.position || 0)/1000);
		this.sound.stop();
	}
	
	/**
	 * arrète la lecture (le son reprendra au début)
	 */
	public function stop ():Void{
		this.sound.start(0);
		this.sound.stop();
		//on attend une dernière exécution afin que les bar de position se remette à 0
		this.onPlaying();
		var tp = setInterval(function(){
			this.stopPlaying();
			clearInterval(tp);
		},50);
		this.pausedAt = -1;
	}
	
	/**
	 * défini le volume audio
	 * @param	v	volume du son / 100
	 */
	public function volumeSet(v:Number):Number{
		v = Math.round(Math.max(0,Math.min(100,v)));
		this.volume = v;
		this.responders.broadcastMessage('onVolumeChange');
		if(this.isOnPlaying()) this.sound.setVolume(v);
		return v;
	}
	
	/**
	 * renvoi le volume du son / 100
	 */
	public function volumeGet():Number {
		return this.volume;
	}
	
	/**
	 * incrémente le volume de volumeStage point (par défaut 10/100)
	 */
	public function volumeInc ():Number{
		return this.volumeSet(this.volumeGet() + this.volumeStage);
	}
	
	/**
	 * décrémente le voolume de volumeStage poin (par défaut 10/100)t
	 */
	public function volumeDec ():Number {
		return this.volumeSet(this.volumeGet() - this.volumeStage);
	}
	
	/**
	 * déplace la tête de lecture à la position pos.
	 * méthode utilisé pour les appels javascript
	 * @param	pos	rapport de position de la tête de lecture (0 à 1)
	 */
	public function positionSet (pos):Void { // 0 à 1
		if(pos < 0) pos = 0;
		if(pos > 100) pos = 100;
		this.sound.start(this.duration() * pos / 100 );
		this.startPlaying();
	}
	/**
	 * méthode utilisé pour les appels javascript.
	 * @return numbre entre 0 et 1 : position de la tête de lecture par rapport à la durée du son
	 */
	public function positionGet ():Number { // 0 à 1
		var d = this.duration();
		return (d) ? this.position()/d : 0;
	}
	
	/**
	 * initialize les fonctions javascript qui seront disponible dans l'object flash de la page web.
	 * les fonctions suivante de cette class seront exportées :
	 * play, pause, stop, volumeDec, volumeInc, volumeSet, volumeGet, positionSet, positionGet, isOnPlaying, isOnLoading, isOnPause
	 */
	public function initExternalMethod(){
		if(!flash.external.ExternalInterface.available) return trace("External Interface not available");
		var m = ['play','pause','stop','volumeDec','volumeInc','volumeSet','volumeGet','positionSet','positionGet','isOnPlaying','isOnLoading','isOnPause'];
		for(var i=0; i < m.length; i++){
			var su = flash.external.ExternalInterface.addCallback('xorax_player_'+m[i], this, this[m[i]]);
		}
		
	}
	
}