package org.osmf.net { import flash.events.NetStatusEvent; import flash.events.TimerEvent; import flash.net.NetConnection; import flash.net.NetStream; import flash.net.NetStreamPlayOptions; import flash.utils.Dictionary; import flash.utils.Timer; import org.osmf.events.MediaError; import org.osmf.events.MediaErrorEvent; import org.osmf.events.NetConnectionFactoryEvent; import org.osmf.media.MediaResourceBase; import org.osmf.media.MediaTypeUtil; import org.osmf.media.URLResource; import org.osmf.traits.LoadTrait; import org.osmf.traits.LoaderBase; import org.osmf.utils.OSMFStrings; import org.osmf.utils.URL; public class NetLoader extends LoaderBase { private static const PROTOCOL_RTMP:String = "rtmp"; private static const PROTOCOL_RTMPS:String = "rtmps"; private static const PROTOCOL_RTMPT:String = "rtmpt"; private static const PROTOCOL_RTMPE:String = "rtmpe"; private static const PROTOCOL_RTMPTE:String = "rtmpte"; private static const PROTOCOL_RTMFP:String = "rtmfp"; private static const PROTOCOL_HTTP:String = "http"; private static const PROTOCOL_HTTPS:String = "https"; private static const PROTOCOL_FILE:String = "file"; private static const PROTOCOL_EMPTY:String = ""; private static const STREAM_RECONNECT_TIMEOUT:Number = 120000; private static const STREAM_RECONNECT_TIMER_INTERVAL:int = 1000; private static const MEDIA_TYPES_SUPPORTED:Vector. = Vector.(["video"]); private static const MIME_TYPES_SUPPORTED:Vector. = Vector.(["video/x-flv","video/x-f4v","video/mp4","video/mp4v-es","video/x-m4v","video/3gpp","video/3gpp2","video/quicktime"]); private var netConnectionFactory:NetConnectionFactoryBase; private var pendingLoads:Dictionary = new Dictionary(); private var oldConnectionURLs:Dictionary = new Dictionary(); private var _reconnectStreams:Boolean = true; private var _reconnectTimeout:Number; public function NetLoader(param1:NetConnectionFactoryBase = null) { super(); _reconnectTimeout = 120000; netConnectionFactory = param1 || new NetConnectionFactory(); netConnectionFactory.addEventListener("creationComplete",onCreationComplete); netConnectionFactory.addEventListener("creationError",onCreationError); } public function get reconnectTimeout() : Number { return _reconnectTimeout; } public function set reconnectTimeout(param1:Number) : void { if(param1 < 0) { throw new ArgumentError(OSMFStrings.getString("invalidParam")); } _reconnectTimeout = param1; } protected function setReconnectStreams(param1:Boolean) : void { _reconnectStreams = param1; } public function get reconnectStreams() : Boolean { return _reconnectStreams; } override public function canHandleResource(param1:MediaResourceBase) : Boolean { var _loc3_:int = MediaTypeUtil.checkMetadataMatchWithResource(param1,MEDIA_TYPES_SUPPORTED,MIME_TYPES_SUPPORTED); if(_loc3_ != 2) { return _loc3_ == 0; } var _loc2_:URLResource = param1 as URLResource; var _loc4_:RegExp = /.flv$|.f4v$|.mov$|.mp4$|.mp4v$|.m4v$|.3gp$|.3gpp2$|.3g2$/i; var _loc5_:URL = _loc2_ != null ? new URL(_loc2_.url) : null; if(_loc5_ == null || _loc5_.rawUrl == null || _loc5_.rawUrl.length <= 0) { return false; } if(_loc5_.protocol == "") { return _loc4_.test(_loc5_.path); } if(NetStreamUtils.isRTMPStream(_loc5_.rawUrl)) { return true; } if(_loc5_.protocol.search(/file$|http$|https$/i) != -1) { return _loc5_.path == null || _loc5_.path.length <= 0 || _loc5_.path.indexOf(".") == -1 || _loc4_.test(_loc5_.path); } return false; } protected function createNetStream(param1:NetConnection, param2:URLResource) : NetStream { var _loc4_:NetStream = new NetStream(param1); var _loc3_:StreamingURLResource = param2 as StreamingURLResource; if(_loc3_ != null && _loc3_.streamType == "live" && _loc4_.bufferTime == 0) { _loc4_.bufferTime = 0.1; } return _loc4_; } protected function createNetStreamSwitchManager(param1:NetConnection, param2:NetStream, param3:DynamicStreamingResource) : NetStreamSwitchManagerBase { return null; } protected function processFinishLoading(param1:NetStreamLoadTrait) : void { updateLoadTrait(param1,"ready"); } override protected function executeLoad(param1:LoadTrait) : void { updateLoadTrait(param1,"loading"); var _loc2_:URL = new URL((param1.resource as URLResource).url); switch(_loc2_.protocol) { case "rtmp": case "rtmps": case "rtmpt": case "rtmpe": case "rtmpte": case "rtmfp": startLoadingRTMP(param1); break; case "http": case "https": case "file": case "": startLoadingHTTP(param1); break; default: updateLoadTrait(param1,"loadError"); param1.dispatchEvent(new MediaErrorEvent("mediaError",false,false,new MediaError(5))); } } override protected function executeUnload(param1:LoadTrait) : void { var _loc2_:NetStreamLoadTrait = param1 as NetStreamLoadTrait; updateLoadTrait(param1,"unloading"); _loc2_.netStream.close(); if(_loc2_.netConnectionFactory != null) { _loc2_.netConnectionFactory.closeNetConnection(_loc2_.connection); } else { _loc2_.connection.close(); } delete oldConnectionURLs[param1.resource]; updateLoadTrait(param1,"uninitialized"); } protected function createReconnectNetConnection() : NetConnection { return new NetConnection(); } protected function reconnect(param1:NetConnection, param2:URLResource) : void { var _loc3_:String = oldConnectionURLs[param2] as String; if(_loc3_ != null && _loc3_.length > 0 && param1 != null) { param1.connect(_loc3_); } } protected function reconnectStream(param1:NetStreamLoadTrait) : void { var _loc3_:NetStreamPlayOptions = new NetStreamPlayOptions(); param1.netStream.attach(param1.connection); _loc3_.transition = "resume"; var _loc2_:URLResource = param1.resource as URLResource; var _loc5_:Boolean = _loc2_ as StreamingURLResource != null ? (_loc2_ as StreamingURLResource).urlIncludesFMSApplicationInstance : false; var _loc4_:String = NetStreamUtils.getStreamNameFromURL(_loc2_.url,_loc5_); _loc3_.streamName = _loc4_; param1.netStream.play2(_loc3_); } private function finishLoading(param1:NetConnection, param2:LoadTrait, param3:NetConnectionFactoryBase = null) : void { var _loc4_:NetStream = null; var _loc5_:NetStreamLoadTrait = param2 as NetStreamLoadTrait; if(_loc5_ != null) { _loc5_.connection = param1; _loc4_ = createNetStream(param1,_loc5_.resource as URLResource); _loc4_.client = new NetClient(); _loc5_.netStream = _loc4_; _loc5_.switchManager = createNetStreamSwitchManager(param1,_loc4_,_loc5_.resource as DynamicStreamingResource); _loc5_.netConnectionFactory = param3; if(_reconnectStreams && _loc5_.resource is URLResource && supportsStreamReconnect(_loc5_.resource as URLResource)) { setupStreamReconnect(_loc5_); } processFinishLoading(param2 as NetStreamLoadTrait); } } private function supportsStreamReconnect(param1:URLResource) : Boolean { var _loc5_:String = null; var _loc3_:Array = null; var _loc6_:int = 0; var _loc7_:int = 0; var _loc4_:int = 0; var _loc2_:Boolean = true; if(NetStreamUtils.isRTMPStream(param1.url)) { _loc5_ = param1.getMetadataValue("http://www.osmf.org/fmsServerVersion/1.0") as String; if(_loc5_ != null && _loc5_.length > 0) { _loc3_ = _loc5_.split(","); if(_loc3_.length >= 3) { _loc6_ = int(_loc3_[0]); _loc7_ = int(_loc3_[1]); _loc4_ = int(_loc3_[2]); if(_loc6_ < 3 || _loc6_ == 3 && _loc7_ < 5 || _loc6_ == 3 && _loc7_ == 5 && _loc4_ < 3) { _loc2_ = false; } } } } else { _loc2_ = false; } return _loc2_; } private function setupStreamReconnect(param1:NetStreamLoadTrait) : void { var timeoutTimer:Timer; var streamIsPaused:Boolean; var bufferIsEmpty:Boolean; var reconnectHasTimedOut:Boolean; var fmsIdleTimeoutReached:Boolean; var loadTrait:NetStreamLoadTrait = param1; var setupReconnectTimer:* = function(param1:Boolean = true):void { if(param1) { reconnectTimer.addEventListener("timerComplete",onReconnectTimer); } else { reconnectTimer.removeEventListener("timerComplete",onReconnectTimer); reconnectTimer = null; } }; var setupTimeoutTimer:* = function(param1:Boolean = true):void { if(param1) { if(_reconnectTimeout > 0) { timeoutTimer = new Timer(_reconnectTimeout,1); timeoutTimer.addEventListener("timerComplete",onTimeoutTimer); } } else if(timeoutTimer != null) { timeoutTimer.removeEventListener("timerComplete",onTimeoutTimer); timeoutTimer = null; } }; var setupNetConnectionListeners:* = function(param1:Boolean = true):void { if(param1) { netConnection.addEventListener("netStatus",onNetStatus); } else { netConnection.removeEventListener("netStatus",onNetStatus); } }; var setupNetStreamListeners:* = function(param1:Boolean = true):void { if(loadTrait.netStream != null) { if(param1) { loadTrait.netStream.addEventListener("netStatus",onNetStatus); } else { loadTrait.netStream.removeEventListener("netStatus",onNetStatus); } } }; var onNetStatus:* = function(param1:NetStatusEvent):void { var _loc2_:NetConnection = null; switch(param1.info.code) { case "NetConnection.Connect.Success": _loc2_ = loadTrait.connection; loadTrait.connection = netConnection; oldConnectionURLs[loadTrait.resource] = netConnection.uri; if(timeoutTimer != null) { timeoutTimer.stop(); } reconnectStream(loadTrait); if(loadTrait.netConnectionFactory != null) { loadTrait.netConnectionFactory.closeNetConnection(_loc2_); } else { _loc2_.close(); } break; case "NetConnection.Connect.IdleTimeOut": fmsIdleTimeoutReached = true; break; case "NetConnection.Connect.Closed": case "NetConnection.Connect.Failed": if(loadTrait.loadState == "ready" && !reconnectHasTimedOut && !fmsIdleTimeoutReached) { reconnectTimer.start(); if(bufferIsEmpty || loadTrait.netStream.bufferLength == 0 || streamIsPaused) { if(timeoutTimer != null) { timeoutTimer.start(); } else { reconnectHasTimedOut = true; setupReconnectTimer(false); setupNetConnectionListeners(false); setupNetStreamListeners(false); setupTimeoutTimer(false); } } } else { setupReconnectTimer(false); setupNetConnectionListeners(false); setupNetStreamListeners(false); setupTimeoutTimer(false); } break; case "NetStream.Pause.Notify": streamIsPaused = true; break; case "NetStream.Unpause.Notify": streamIsPaused = false; break; case "NetStream.Buffer.Empty": if(!netConnection.connected) { if(timeoutTimer != null) { timeoutTimer.start(); } else { reconnectHasTimedOut = true; } } else { bufferIsEmpty = true; } break; case "NetStream.Buffer.Full": bufferIsEmpty = false; } }; var onTimeoutTimer:* = function(param1:TimerEvent):void { reconnectHasTimedOut = true; }; var onReconnectTimer:* = function(param1:TimerEvent):void { if(reconnectHasTimedOut) { return; } if(netConnection === loadTrait.connection) { setupNetConnectionListeners(false); netConnection = createReconnectNetConnection(); netConnection.client = new NetClient(); setupNetConnectionListeners(); } reconnect(netConnection,loadTrait.resource as URLResource); }; var netConnection:NetConnection = loadTrait.connection; var reconnectTimer:Timer = new Timer(1000,1); oldConnectionURLs[loadTrait.resource] = netConnection.uri; streamIsPaused = false; bufferIsEmpty = false; reconnectHasTimedOut = false; fmsIdleTimeoutReached = false; setupNetConnectionListeners(); setupNetStreamListeners(); setupReconnectTimer(); setupTimeoutTimer(); } private function startLoadingRTMP(param1:LoadTrait) : void { addPendingLoad(param1); netConnectionFactory.create(param1.resource as URLResource); } private function onCreationComplete(param1:NetConnectionFactoryEvent) : void { processCreationComplete(param1.netConnection,findAndRemovePendingLoad(param1.resource),param1.currentTarget as NetConnectionFactoryBase); } protected function processCreationComplete(param1:NetConnection, param2:LoadTrait, param3:NetConnectionFactoryBase = null) : void { finishLoading(param1,param2,param3); } private function onCreationError(param1:NetConnectionFactoryEvent) : void { var _loc2_:LoadTrait = findAndRemovePendingLoad(param1.resource); if(_loc2_ != null) { _loc2_.dispatchEvent(new MediaErrorEvent("mediaError",false,false,param1.mediaError)); updateLoadTrait(_loc2_,"loadError"); } } private function startLoadingHTTP(param1:LoadTrait) : void { var _loc2_:NetConnection = new NetConnection(); _loc2_.client = new NetClient(); _loc2_.connect(null); finishLoading(_loc2_,param1); } private function addPendingLoad(param1:LoadTrait) : void { if(pendingLoads[param1.resource] == null) { pendingLoads[param1.resource] = [param1]; } else { pendingLoads[param1.resource].push(param1); } } private function findAndRemovePendingLoad(param1:URLResource) : LoadTrait { var _loc3_:int = 0; var _loc4_:LoadTrait = null; var _loc2_:Array = pendingLoads[param1]; if(_loc2_ != null) { if(_loc2_.length == 1) { _loc4_ = _loc2_[0] as LoadTrait; delete pendingLoads[param1]; } else { _loc3_ = 0; while(_loc3_ < _loc2_.length) { _loc4_ = _loc2_[_loc3_]; if(_loc4_.resource == param1) { _loc2_.splice(_loc3_,1); break; } _loc3_++; } } } return _loc4_; } } }