launcher.as

jquery插件

		public function handleError(error:PlayerError, info:Object = null, throwError:Boolean = true):void {
			if (_flowplayer) {
				_flowplayer.dispatchError(error, info);
			} else {
				// initialization is not complete, create a dispatches just to dispatch this error
				new PlayerEventDispatcher().dispatchError(error, info);
			}
			doHandleError(error.code + ": " + error.message + ( info ? ": " + info : ""), throwError);
		}

		private function doHandleError(message:String, throwError:Boolean = true):void {
			if (_config && _config.playerId) {
				Logger.error(message);
			}
			showError(message);
			if (throwError && Capabilities.isDebugger) {
				throw new Error(message);
			}
		}

		private function createAnimationEngine(pluginRegistry:PluginRegistry):void {
			_animationEngine = new AnimationEngine(_panel, pluginRegistry);
		}

		private function addPluginsToPanel(_pluginRegistry:PluginRegistry):void {
			for each (var pluginObj:Object in _pluginRegistry.plugins) {
				if (pluginObj is DisplayPluginModel) {
					var model:DisplayPluginModel = pluginObj as DisplayPluginModel;
					log.debug("adding plugin '"+ model.name +"' to panel: " + model.visible + ", plugin object is " + model.getDisplayObject());
					if (model.visible) {
						if (model.zIndex == -1) {
							model.zIndex = 100;
						}
						_panel.addView(model.getDisplayObject(), undefined, model);
					}
					if (model.name == "controls") {
						_controlsModel = model;
					}
				}
			}
			if (_controlsModel) {
				arrangeCanvasLogo();
			}
		}
		
		private function addScreenToPanel():void {
			// if controls visible and screen was not explicitly configured --> place screen on top of controls
			var screen:DisplayProperties = _pluginRegistry.getPlugin("screen") as DisplayProperties;
			screen.display = "none";
			screen.getDisplayObject().visible = false;
			_panel.addView(screen.getDisplayObject(), null, screen);
		}
		
		private function arrangeScreen():void {
			var screen:DisplayProperties = _pluginRegistry.getPlugin("screen") as DisplayProperties;
			 
			if (_controlsModel && _controlsModel.visible) {
				
				if (isControlsAlwaysAutoHide() || (_controlsModel.position.bottom.px > 0)) {
					log.debug("controls is autoHide or it's in a non-default vertical position, configuring screen to take all available space");
					setScreenBottomAndHeight(screen, 100, 0);
				} else {
					var controlsHeight:Number = _controlsModel.getDisplayObject().height;
					var occupiedHeight:Number = screenTopOrBottomConfigured() ? getScreenTopOrBottomPx(screen) : controlsHeight;
					log.debug("occupied by controls or screen's configured bottom/top is " + occupiedHeight);

					var heightPct:Number = 0;
					if (screenTopOrBottomConfigured() && (screen.position.top.pct >= 0 || screen.position.bottom.pct >= 0)) {
						heightPct = 100 - Math.abs(50 - (screen.position.top.pct >= 0 ? screen.position.top.pct : screen.position.bottom.pct))*2; 
						setScreenBottomAndHeight(screen, heightPct, controlsHeight);
					} else {
						heightPct = ((stage.stageHeight - occupiedHeight) / stage.stageHeight) * 100;
						setScreenBottomAndHeight(screen, heightPct, controlsHeight);
					}
				}
			}
			log.debug("arranging screen to pos " + screen.position);
			screen.display = "block";
			screen.getDisplayObject().visible = true;
			_pluginRegistry.updateDisplayProperties(screen);
			_panel.update(screen.getDisplayObject(), screen);
			_panel.draw(screen.getDisplayObject());
		}
		
		private function getScreenTopOrBottomPx(screen:DisplayProperties):Number {
			var screenConf:Object = _config.getObject("screen");
			if (screenConf.hasOwnProperty("top")) return screen.position.top.toPx(stage.stageHeight);
			if (screenConf.hasOwnProperty("bottom")) return screen.position.bottom.toPx(stage.stageHeight);
			return 0;
		}

		private function setScreenBottomAndHeight(screen:DisplayProperties, heightPct:Number, bottom:Number = 0):void {
			if (! screenTopOrBottomConfigured()) {
				log.debug("screen vertical pos not configured, setting bottom to value " + bottom);
				screen.bottom = bottom;
			} else {
				log.debug("using configured top/bottom for screen");
			}
			
			var heightConfigured:Boolean = _config.getObject("screen") && _config.getObject("screen").hasOwnProperty("height");
			if (! heightConfigured) {
				log.debug("screen height not configured, setting it to value " + heightPct + "%");
				screen.height =  heightPct + "%";
			} else {
				log.debug("using configured height for screen");
			}
		}

		private function screenTopOrBottomConfigured():Boolean {
			var screen:Object = _config.getObject("screen");
			if (! screen) return false;
			if (screen.hasOwnProperty("top")) return true;
			if (screen.hasOwnProperty("bottom")) return true;
			return false;
		}

		private function isControlsAlwaysAutoHide():Boolean {
			if (!_controlsModel) return false;
			if (!_controlsModel.config) return false;
			log.debug("controlsModel.config.auotoHide == always", (_controlsModel.config.autoHide == 'always'));
			return  _controlsModel.config.autoHide == 'always';
		}

		private function createFlowplayer(playListController:PlayListController):void {
			_flowplayer = new Flowplayer(stage, playListController, _pluginRegistry, _panel, 
				_animationEngine, this, this, _config, _fullscreenManager, _pluginLoader, URLUtil.playerBaseUrl(loaderInfo));
			playListController.playerEventDispatcher = _flowplayer;
			
			_flowplayer.onBeforeFullscreen(onFullscreen);
//			_flowplayer.onFullscreenExit(onFullscreen);
		}
		
		private function onFullscreen(event:PlayerEvent):void {
				log.debug("entering fullscreen, disabling display clicks");
				_enteringFullscreen = true;
				var delay:Timer = new Timer(1000, 1);
				delay.addEventListener(TimerEvent.TIMER_COMPLETE, onTimerComplete);
				delay.start();
		}
		
		private function onTimerComplete(event:TimerEvent):void {
			log.debug("fullscreen wait delay complete, display clicks are enabled again");
			_enteringFullscreen = false;
		}

		private function createFlashVarsConfig():void {
			for (var prop:String in stage.loaderInfo.parameters) {
				log.debug(prop + ": " + (stage.loaderInfo.parameters[prop]));
			}
			if (! stage.loaderInfo.parameters) {
				return;
			}
			
			_config = ConfigLoader.flow_internal::parseConfig(stage.loaderInfo.parameters["config"], playerSwfName(), VersionInfo.controlsVersion, VersionInfo.audioVersion); 
		}

		private function createPlayListController():PlayListController {
			if (! _providers) {
				_providers = new Dictionary();
			}
			var httpProvider:NetStreamControllingStreamProvider = new NetStreamControllingStreamProvider();
			httpProvider.playerConfig = _config;
			_providers["http"] = httpProvider;
			return new PlayListController(_config.getPlaylist(), _providers, _config, createNewLoader());
		}
		
		private function createScreen():void {
			_screen = new Screen(_config.getPlaylist(), _animationEngine, _playButtonOverlay, _pluginRegistry);
			var screenModel:DisplayProperties = _config.getScreenProperties();
			initView(_screen, screenModel, null, false);
			if (_playButtonOverlay) {
				PlayButtonOverlayView(_playButtonOverlay.getDisplayObject()).setScreen(_screen, hasClip);
			}
//			addViewLiteners(_screen);
		}

		private function createPlayButtonOverlay():void {
			_playButtonOverlay = _config.getPlayButtonOverlay();
			if (! _playButtonOverlay) return;
			
			_playButtonOverlay.onLoad(onPluginLoad);
			_playButtonOverlay.onError(onPluginLoadError);

			log.debug("playlist has clips? " + hasClip);
			var overlay:PlayButtonOverlayView = new PlayButtonOverlayView(! playButtonOverlayWidthDefined(), _playButtonOverlay, _pluginRegistry, _config.getPlaylist());
			initView(overlay, _playButtonOverlay, null, false);
		}
		
		private function playButtonOverlayWidthDefined():Boolean {
			if (! _config.getObject("play")) return false;
			return _config.getObject("play").hasOwnProperty("width");
		}
		
		private function get hasClip():Boolean {
			var firstClip:Clip = _config.getPlaylist().current;
			var hasClip:Boolean = ! firstClip.isNullClip && (firstClip.url || firstClip.provider != 'http');
			return hasClip; 
		}
		
		private function createLogo():void {
			var logo:Logo = _config.getLogo() || new Logo();
			var logoView:LogoView = new LogoView(_panel, logo, _flowplayer);
			initView(logoView, logo, logoView.draw, false);
		}

		private function initView(view:DisplayObject, props:DisplayProperties, resizeListener:Function = null, addToPanel:Boolean = true):void {
			if (props.name != "logo" || VersionInfo.commercial) {
				_pluginRegistry.registerDisplayPlugin(props, view);
			}
			if (addToPanel) {
				_panel.addView(view, resizeListener, props);
			}
			if (props is Callable) {
				ExternalInterfaceHelper.initializeInterface(props as Callable, view);
			}
		}
		
		private function addListeners():void {
			_screen.addEventListener(MouseEvent.CLICK, onViewClicked);
			addEventListener(MouseEvent.ROLL_OVER, onMouseOver);
			addEventListener(MouseEvent.ROLL_OUT, onMouseOut);
			
			// add some color so that the ROLL_OVER/ROLL_OUT events are always triggered
			graphics.beginFill(0, 0);
			graphics.drawRect(0, 0, stage.stageWidth, stage.stageHeight);
			graphics.endFill();
		}
		
		private function onMouseOut(event:MouseEvent):void {
			_flowplayer.dispatchEvent(PlayerEvent.mouseOut());
		}

		private function onMouseOver(event:MouseEvent):void {
			_flowplayer.dispatchEvent(PlayerEvent.mouseOver());
		}

		private function createPanel():void {
			_panel = new Panel();
			addChild(_panel);
		}
		
		private function startStreams():void {
			var canStart:Boolean = true;
			if (_flowplayer.state != State.WAITING) {
				log.debug("streams have been started in player.onLoad(), will not start streams here.");
				canStart = false;
			}
			if (! hasClip) {
				log.info("Configuration has no clips to play.");
				canStart = false;
			}

			var playButton:PlayButtonOverlayView = _playButtonOverlay ? PlayButtonOverlayView(_playButtonOverlay.getDisplayObject()) : null;
			
			if (canStart) {
				if (_flowplayer.currentClip.autoPlay) {
					log.debug("clip is autoPlay");
					_flowplayer.play();
				} else if (_flowplayer.currentClip.autoBuffering) {
					log.debug("clip is autoBuffering");
					_flowplayer.startBuffering();
				} else {
					if (playButton) {
						playButton.stopBuffering();
						playButton.showButton();
					}
				}
			} else {
				// cannot start playing here, stop buffering indicator, don't show the button
				if (playButton) {
					playButton.stopBuffering();
				}
			}
		}
		
		private function addPlayListListeners():void {
			var playlist:Playlist = _config.getPlaylist();
			playlist.onError(onClipError);
		}
		
		private function onClipError(event:ClipEvent):void {
			doHandleError(event.info + ", " + event.info2 + ", " + event.info3 + ", clip: '" + Clip(event.target) + "'");
		}

		private function onViewClicked(event:MouseEvent):void {
			if (_enteringFullscreen) return;
			log.debug("onViewClicked, target " + event.target + ", current target " + event.currentTarget);

            if (_playButtonOverlay && isParent(DisplayObject(event.target), _playButtonOverlay.getDisplayObject())) {
				_flowplayer.toggle();

			} else if (isParent(DisplayObject(event.target), _screen)) {
                log.debug("screen clicked");
                var clip:Clip = _flowplayer.playlist.current; 
                if (clip.linkUrl) {
                    log.debug("opening linked page");
                    _flowplayer.pause();
                    navigateToURL(new URLRequest(clip.linkUrl), clip.linkWindow);
                    return;
                }
				_flowplayer.toggle();

			}

            event.stopPropagation();
		}
		
		private function isParent(child:DisplayObject, parent:DisplayObject):Boolean {
			if (DisplayObject(child).parent == parent) return true;
			if (! (parent is DisplayObjectContainer)) return false;
			for (var i:Number = 0;i < DisplayObjectContainer(parent).numChildren; i++) {
				var curChild:DisplayObject = DisplayObjectContainer(parent).getChildAt(i);
				if (isParent(child, curChild)) { 
					return true;
				}
			}
			return false;
		}

		private function onKeyDown(event:KeyboardEvent):void {
			log.debug("keydown");
			if (_enteringFullscreen) return;
			if (_flowplayer.dispatchBeforeEvent(PlayerEvent.keyPress(event.keyCode))) {
				_flowplayer.dispatchEvent(PlayerEvent.keyPress(event.keyCode));
				if (event.keyCode == Keyboard.SPACE) {
					_flowplayer.toggle();
				}
			}
		}
		
		override protected function onRedraw():void {
			if (bgImageHolder && getChildIndex(bgImageHolder) > getChildIndex(_panel)) {
				swapChildren(bgImageHolder, _panel);
			}
		}
		
		private function createLogoForCanvas():void {
			if (_canvasLogo) return;
			_copyrightNotice = LogoUtil.createCopyrightNotice(8);
			addChild(_copyrightNotice);
			
			_canvasLogo = new CanvasLogo();
			_canvasLogo.width = 85;
			_canvasLogo.scaleY = _canvasLogo.scaleX;
			_canvasLogo.alpha = .4;
			_canvasLogo.addEventListener(MouseEvent.CLICK, 
				function(event:MouseEvent):void { navigateToURL(new URLRequest("http://flowplayer.org"), "_self"); });
			_canvasLogo.buttonMode = true;
			log.debug("adding logo to display list");
			addChild(_canvasLogo);
			onStageResize();
		}
		
		private function createNewLoader():ResourceLoader {
			return new ResourceLoaderImpl(_config.playerId ? null : URLUtil.playerBaseUrl(loaderInfo), this);
		}
	}
}