rtmpt fallback if rtmp not working ?

import com.jeroenwijering.events.*;
import com.jeroenwijering.models.ModelInterface;
import com.jeroenwijering.player.Model;
import com.jeroenwijering.utils.NetClient;
import com.jeroenwijering.utils.TEA;

import flash.display.DisplayObject;
import flash.events.*;
import flash.media.*;
import flash.net.*;
import flash.utils.*;

public class RTMPModel implements ModelInterface {

/** reference to the model. **/
private var model:Model;
/** Video object to be instantiated. **/
private var video:Video;
/** NetConnection object for setup of the video stream. **/
private var connection:NetConnection;
/** NetStream instance that handles the stream IO. **/
private var stream:NetStream;
/** Sound control object. **/
private var transform:SoundTransform;
/** Interval ID for the time. **/
private var timeinterval:Number;
/** Timeout ID for live stream subscription pings. **/
private var timeout:Number;
/** Metadata have been received. **/
private var metadata:Boolean;

/** NetConnection connection timer. **/
private var ncConnectTimer:Number = 0;
/** NetConnection connection timeout (ms). **/
private var ncConnectTimeout:Number = 3000; // 3 seconds
/** NetConnection connection try. **/
private var ncTryIndex:Number = 0;
/** Streamer list (splited string, each streamer is separated with a pipe |). **/
private var ncStreamers:Array = new Array();

/** Constructor; sets up the connection and display. **/
public function RTMPModel(mod:Model):void {
model = mod;
connection = new NetConnection();
connection.addEventListener(NetStatusEvent.NET_STATUS,statusHandler);
connection.addEventListener(SecurityErrorEvent.SECURITY_ERROR,errorHandler);
connection.addEventListener(IOErrorEvent.IO_ERROR,errorHandler);
connection.addEventListener(AsyncErrorEvent.ASYNC_ERROR,metaHandler);
connection.objectEncoding = ObjectEncoding.AMF0;
connection.client = new NetClient(this);
video = new Video(320,240);
quality(model.config['quality']);
transform = new SoundTransform();
model.config['mute'] == true ? volume(0): volume(model.config['volume']);

ncStreamers = model.playlist[model.config['item']]['streamer'].split("|");
};

/** Catch security errors. **/
private function errorHandler(evt:ErrorEvent):void {
model.sendEvent(ModelEvent.ERROR,{message:evt.text});
};

/** Extract the correct rtmp syntax from the file string. **/
private function getID(url:String):String {
var ext:String = url.substr(-4);
if(ext == '.mp3') {
return 'mp3:'+url.substr(0,url.length-4);
} else if(ext == '.mp4' || ext == '.mov' || ext == '.aac' || ext == '.m4a') {
return 'mp4:'+url;
} else if (ext == '.flv') {
return url.substr(0,url.length-4);
} else {
return url;
}
};

/** Reset connection timer. **/
function clearConnectTimer():void {
if (ncConnectTimer != 0)
clearInterval(ncConnectTimer);
ncConnectTimer = 0;
}

/** Reset connection timer and try next available url. **/
function tryReconnect():void {
clearConnectTimer();
ncTryIndex++;
tryConnect();
}

/** Try to connect to server with next available url. **/
function tryConnect():void {
clearConnectTimer();

var url:String = "";
if(ncTryIndex < ncStreamers.length)
url = ncStreamers[ncTryIndex];
else
model.sendEvent(ModelEvent.ERROR,{message:"Failed to connect after "+ncTryIndex+" tries"});

if (url.length > 0)
{
connection.connect(url);
ncConnectTimer = setInterval(tryReconnect, ncConnectTimeout);
}
}

/** Load content. **/
public function load():void {
video.clear();
model.mediaHandler(video);
tryConnect();
model.sendEvent(ModelEvent.STATE,{newstate:ModelStates.BUFFERING});
};

/** Catch noncritical errors. **/
private function metaHandler(evt:ErrorEvent):void {
model.sendEvent(ModelEvent.META,{error:evt.text});
};

/** Get metadata information from netstream class. **/
public function onData(dat:Object):void {
if(dat.type == 'metadata' && !metadata) {
if(dat.width) {
video.width = dat.width;
video.height = dat.height;
}
if(model.playlist[model.config['item']]['start'] > 0) {
seek(model.playlist[model.config['item']]['start']);
}
metadata = true;
} else if(dat.type == 'complete') {
clearInterval(timeinterval);
model.sendEvent(ModelEvent.STATE,{newstate:ModelStates.COMPLETED});
} else if(dat.type == 'fcsubscribe') {
if(dat.code == "NetStream.Play.StreamNotFound" ) {
model.sendEvent(ModelEvent.ERROR,{message:"Subscription failed: "+model.playlist[model.config['item']]['file']});
}else if(dat.code == "NetStream.Play.Start") {
setStream();
}
clearInterval(timeout);
}
model.sendEvent(ModelEvent.META,dat);
};

/** Pause playback. **/
public function pause():void {
clearInterval(timeinterval);
stream.pause();
model.sendEvent(ModelEvent.STATE,{newstate:ModelStates.PAUSED});
};

/** Resume playing. **/
public function play():void {
clearTimeout(timeout);
clearInterval(timeinterval);
stream.resume();
model.sendEvent(ModelEvent.STATE,{newstate:ModelStates.PLAYING});
timeinterval = setInterval(timeHandler,100);
};

/** Change the smoothing mode. **/
public function quality(qua:Boolean):void {
if(qua == true) {
video.smoothing = true;
video.deblocking = 3;
} else {
video.smoothing = false;
video.deblocking = 1;
}
};

/** Change the smoothing mode. **/
public function seek(pos:Number):void {
clearTimeout(timeout);
clearInterval(timeinterval);
if(model.config['state'] == ModelStates.PAUSED) {
stream.resume();
} else {
model.sendEvent(ModelEvent.STATE,{newstate:ModelStates.PLAYING});
}
stream.seek(pos);
};

/** Set streaming object **/
public function setStream():void {
var url = getID(model.playlist[model.config['item']]['file']);
stream = new NetStream(connection);
stream.addEventListener(NetStatusEvent.NET_STATUS,statusHandler);
stream.addEventListener(IOErrorEvent.IO_ERROR,errorHandler);
stream.addEventListener(AsyncErrorEvent.ASYNC_ERROR,metaHandler);
stream.bufferTime = model.config['bufferlength'];
stream.client = new NetClient(this);
video.attachNetStream(stream);
stream.soundTransform = transform;
stream.play(url);
var res:Responder = new Responder(streamlengthHandler);
connection.call("getStreamLength",res,url);
connection.call("checkBandwidth",null);
clearInterval(timeinterval);
timeinterval = setInterval(timeHandler,100);
};

/** Receive NetStream status updates. **/
private function statusHandler(evt:NetStatusEvent):void {
switch (evt.info.code) {
case 'NetConnection.Connect.Success':
clearConnectTimer();
if(evt.info.secureToken != undefined) {
connection.call("secureTokenResponse",null,TEA.decrypt(evt.info.secureToken,model.config['token']));
}
if(model.config['subscribe']) {
timeout = setInterval(subscribe,2000,getID(model.playlist[model.config['item']]['file']));
} else {
setStream();
}
break;
case  'NetStream.Seek.Notify':
clearInterval(timeinterval);
timeinterval = setInterval(timeHandler,100);
break;
case 'NetConnection.Connect.Rejected':
if(evt.info.ex.code == 302) {
model.playlist[model.config['item']]['streamer'] = evt.info.ex.redirect;
connection.connect(model.playlist[model.config['item']]['streamer']);
break;
}
case 'NetStream.Play.StreamNotFound':
model.sendEvent(ModelEvent.ERROR,{message:"Stream not found: "+model.playlist[model.config['item']]['file']});
break;
case 'NetConnection.Connect.Failed':
tryReconnect();
break;
default:
model.sendEvent(ModelEvent.META,{info:evt.info.code});
break;
}
};

/** Destroy the stream. **/
public function stop():void {
clearInterval(timeinterval);
connection.close();
if(stream) { stream.close(); }
video.attachNetStream(null);
};

/** Get the streamlength returned from the connection. **/
private function streamlengthHandler(len:Number):void {
onData({type:'streamlength',duration:len});
};

/** Akamai & Limelight subscribes. **/
private function subscribe(nme:String):void {
connection.call("FCSubscribe",null,nme);
};

/** Interval for the position progress **/
private function timeHandler():void {
var bfr = Math.round(stream.bufferLength/stream.bufferTime*100);
var pos = Math.round(stream.time*10)/10;
var dur = model.playlist[model.config['item']]['duration'];
if(bfr < 95 && pos < Math.abs(dur-stream.bufferTime-1)) {
model.sendEvent(ModelEvent.BUFFER,{percentage:bfr});
if(model.config['state'] != ModelStates.BUFFERING) {
connection.call("checkBandwidth",null);
model.sendEvent(ModelEvent.STATE,{newstate:ModelStates.BUFFERING});
}
} else if (model.config['state'] == ModelStates.BUFFERING) {
model.sendEvent(ModelEvent.STATE,{newstate:ModelStates.PLAYING});
}
model.sendEvent(ModelEvent.TIME,{position:pos});
};

/** Set the volume level. **/
public function volume(vol:Number):void {
transform.volume = vol/100;
if(stream) {
stream.soundTransform = transform;
}
};

};

}

        import flash.events.*;
        import flash.media.*;
        import flash.net.*;
        import flash.utils.*;

        public class RTMPMediaProvider extends MediaProvider {
                /** Video object to be instantiated. **/
                protected var _video:Video;
                /** NetConnection object for setup of the _video _stream. **/
                protected var _connection:NetConnection;

                private var _connector1:Connector;
                private var _connector2:Connector;
                private var _connectionClient:Object;

                /** Loader instance that loads the XML file. **/
                private var _loader:URLLoader;
                /** NetStream instance that handles the _stream IO. **/
                protected var _stream:NetStream;
                /** Sound control object. **/
                protected var _transformer:SoundTransform;
                /** Save the location of the XML redirect. **/
                private var _smil:String;
                /** Save that the _video has been _started. **/
                protected var _started:Boolean;
                /** ID for the position _positionInterval. **/
                protected var _positionInterval:Number;
                /** Save that a file is _unpublished. **/
                protected var _unpublished:Boolean;
                /** Whether the buffer has filled **/
                private var _bufferFull:Boolean;

                public function RTMPMediaProvider() {
                        super('rtmp');
                }

                /** Constructor; sets up the connection and display. **/
                public override function initializeMediaProvider(cfg:PlayerConfig):void {
                        super.initializeMediaProvider(cfg);
//                      _connection = new NetConnection();
//                      _connection.addEventListener(NetStatusEvent.NET_STATUS, statusHandler);
//                      _connection.addEventListener(SecurityErrorEvent.SECURITY_ERROR, errorHandler);
//                      _connection.addEventListener(IOErrorEvent.IO_ERROR, errorHandler);
//                      _connection.addEventListener(AsyncErrorEvent.ASYNC_ERROR, errorHandler);
//                      _connection.objectEncoding = ObjectEncoding.AMF0;
//                      _connection.client = new NetClient(this);
                        _connectionClient = new NetClient(this);
                        _loader = new URLLoader();
                        _loader.addEventListener(Event.COMPLETE, loaderHandler);
                        _loader.addEventListener(SecurityErrorEvent.SECURITY_ERROR, errorHandler);
                        _loader.addEventListener(IOErrorEvent.IO_ERROR, errorHandler);
                        _video = new Video(320, 240);
                        _video.smoothing = config.smoothing;
                        _transformer = new SoundTransform();
                }

                        doConnect(_connector1, "best", ObjectEncoding.AMF0);

                        // RTMPT connect is started after 250 ms
                        var delay:Timer = new Timer( 250, 1);
                        delay.addEventListener(TimerEvent.TIMER, function(event:TimerEvent):void {
                                doConnect(_connector2, "best", ObjectEncoding.AMF0);
                        });
                        delay.start();

                        config.mute == true ? setVolume(0) : setVolume(config.volume);
                        sendMediaEvent(MediaEvent.JWPLAYER_MEDIA_LOADED);
                }

                private function doConnect(connector:Connector, proxyType:String, objectEncoding:uint):void {
                        connector.connect(proxyType, objectEncoding, null);
                }

                private function onConnectorSuccess(connector:Connector, connection:NetConnection, evt:NetStatusEvent):void {
                        if (_connection) return;
                        _connection = connection;
                        if (connector == _connector2 && _connector1) {
                                _connector1.stop();
                        } else if (_connector2) {
                                _connector2.stop();
                        }
                        statusHandler(evt);
                }

                private function onConnectorFailure(evt:NetStatusEvent):void {
                        if (isFailedOrNotUsed(_connector1) && isFailedOrNotUsed(_connector2)) {
                                statusHandler(evt);
                        }
                }

                private function isFailedOrNotUsed(connector:Connector):Boolean {
                        if (! connector) return true;
                        return connector.failed;
                }
                private function getUrlParts(url:String):Array {
                        var pos:int = url.indexOf('://');
                        if (pos > 0) {
                                return [url.substring(0, pos), url.substring(pos + 3)];
                        }
                        return null;
                }

    import flash.utils.setTimeout;

    import com.longtailvideo.jwplayer.utils.Logger;

    public class Connector {
        private var _url:String;
        private var _successListener:Function;
        private var _connectionClient:Object;
        private var _connection:NetConnection;
        private var _failureListener:Function;
        private var _failed:Boolean;

        public function Connector(url:String, connectionClient:Object, onSuccess:Function, onFailure:Function) {
            _url = url;
            _connectionClient = connectionClient;
            _successListener = onSuccess;
            _failureListener = onFailure;
            _failed = false;
            Logger.log("created with connection client " + _connectionClient);
        }

        public function connect(proxyType:String, objectEncoding:uint, connectionArgs:Array):void {
            Logger.log(this +"::connect() using proxy type '" + proxyType + "'" + ", object encoding " + objectEncoding);
            if (_successListener == null) {
                Logger.log(this + ", this connector has been stopped, will not proceed with connect()");
                return;
            }
            _connection = new NetConnection();
            _connection.proxyType = proxyType;
            _connection.objectEncoding = objectEncoding;

            Logger.log("using connection client " + _connectionClient);
            if (_connectionClient) {
                _connection.client = _connectionClient;
            }
            _connection.addEventListener(NetStatusEvent.NET_STATUS, onConnectionStatus);

            Logger.log("netConnectionUrl is " + _url);
            if (connectionArgs && connectionArgs.length > 0) {
                _connection.connect.apply(_connection, [ _url ].concat(connectionArgs));
            } else {
                _connection.connect(_url);
            }
        }

        private function onConnectionStatus(event:NetStatusEvent):void {
            Logger.log(this + "::onConnectionStatus() " + event.info.code);

            if (event.info.code == "NetConnection.Connect.Success") {
                if (_successListener != null) {
                    _successListener(this, _connection, event);
                } else {
                    Logger.log("this connector is stopped, will not call successListener");
                    _connection.close();
                }
                return;
               
            }

            if (event.info.code == "NetConnection.Connect.Rejected" && event.info.ex && event.info.ex.code == 302) {
                Logger.log("starting a timeout to connect to a redirected URL " + event.info.ex.redirect);
                setTimeout(function():void{
                    Logger.log("connecting to a redirected URL " + event.info.ex.redirect);
                    _connection.connect(event.info.ex.redirect);
                }, 100);
                return;
            }

            if (["NetConnection.Connect.Failed", "NetConnection.Connect.Rejected", "NetConnection.Connect.AppShutdown", "NetConnection.Connect.InvalidApp"].indexOf(event.info.code) >= 0) {
                _failed = true;
                if (_failureListener != null) {
                    _failureListener(event);
                }
            }
        }

        public function stop():void {
            Logger.log("stop()");
            if (_connection) {
                _connection.close();
            }
            _successListener = null;
        }

        public function toString():String {
            return "Connector, [" + _url + "]";
        }

        public function get failed():Boolean {
            return _failed;
        }
    }
}