Context Navigation

Controller.as @ 411

Visit:

Revision 411, 12.0 KB checked in by pablo, 4 years ago (diff)
Hooked up controller to view events

Line
1	package com.longtailvideo.jwplayer.controller {
2	import com.longtailvideo.jwplayer.events.GlobalEventDispatcher;
3	import com.longtailvideo.jwplayer.events.MediaEvent;
4	import com.longtailvideo.jwplayer.events.PlayerEvent;
5	import com.longtailvideo.jwplayer.events.PlaylistEvent;
6	import com.longtailvideo.jwplayer.events.ViewEvent;
7	import com.longtailvideo.jwplayer.model.Model;
8	import com.longtailvideo.jwplayer.model.PlaylistItem;
9	import com.longtailvideo.jwplayer.player.Player;
10	import com.longtailvideo.jwplayer.player.PlayerState;
11	import com.longtailvideo.jwplayer.player.PlayerV4Emulation;
12	import com.longtailvideo.jwplayer.plugins.IPlugin;
13	import com.longtailvideo.jwplayer.utils.RootReference;
14	import com.longtailvideo.jwplayer.utils.Strings;
15	import com.longtailvideo.jwplayer.view.View;
16
17	import flash.events.ErrorEvent;
18	import flash.events.Event;
19	import flash.net.URLRequest;
20	import flash.net.navigateToURL;
21
22	/**
23	* Sent when the player has been initialized and skins and plugins have been successfully loaded.
24	*
25	* @eventType com.longtailvideo.jwplayer.events.PlayerEvent.JWPLAYER_READY
26	*/
27	[Event(name="jwplayerReady", type = "com.longtailvideo.jwplayer.events.PlayerEvent")]
28
29	/**
30	* Sent when the player has entered the ERROR state
31	*
32	* @eventType com.longtailvideo.jwplayer.events.PlayerEvent.JWPLAYER_ERROR
33	*/
34	[Event(name="jwplayerError", type = "com.longtailvideo.jwplayer.events.PlayerEvent")]
35
36	/**
37	* The Controller is responsible for handling Model / View events and calling the appropriate responders
38	*
39	* @author Pablo Schklowsky
40	*/
41	public class Controller extends GlobalEventDispatcher {
42
43	/ MVC References /
44	private var _player:Player;
45	private var _model:Model;
46	private var _view:View;
47
48	/ Current blocking state /
49	private var _blocking:Boolean = false;
50
51	/ File extensions of all supported mediatypes. /
52	private var extensions:Object = {
53	'3g2':'video',
54	'3gp':'video',
55	'aac':'video',
56	'f4b':'video',
57	'f4p':'video',
58	'f4v':'video',
59	'flv':'video',
60	'gif':'image',
61	'jpg':'image',
62	'jpeg':'image',
63	'm4a':'video',
64	'm4v':'video',
65	'mov':'video',
66	'mp3':'sound',
67	'mp4':'video',
68	'png':'image',
69	'rbs':'sound',
70	'sdp':'video',
71	'swf':'image',
72	'vp6':'video'
73	};
74
75	/ A list with legacy CDN classes that are now redirected to buit-in ones. /
76	private var cdns:Object = {
77	bitgravity:{'http.startparam':'starttime', provider:'http'},
78	edgecast:{'http.startparam':'ec_seek', provider:'http'},
79	flvseek:{'http.startparam':'fs', provider:'http'},
80	highwinds:{'rtmp.loadbalance':true, provider:'rtmp'},
81	lighttpd:{'http.startparam':'start', provider:'http'},
82	vdox:{'rtmp.loadbalance':true, provider:'rtmp'}
83	};
84
85	public function Controller(player:Player, model:Model, view:View) {
86	_player = player;
87	_model = model;
88	_view = view;
89	}
90
91	/**
92	* Begin player setup
93	* @param readyConfig If a PlayerConfig object is already available, use it to configure the player.
94	* Otherwise, load the config from XML / flashvars.
95	*/
96	public function setupPlayer():void {
97	var setup:PlayerSetup = new PlayerSetup(_player, _model, _view);
98
99	setup.addEventListener(Event.COMPLETE, setupComplete);
100	setup.addEventListener(ErrorEvent.ERROR, errorHandler);
101
102	addViewListeners();
103	addModelListeners();
104
105	setup.setupPlayer();
106	}
107
108	private function addViewListeners():void {
109	_view.addEventListener(ViewEvent.JWPLAYER_VIEW_PLAY, playHandler);
110	_view.addEventListener(ViewEvent.JWPLAYER_VIEW_PAUSE, pauseHandler);
111	_view.addEventListener(ViewEvent.JWPLAYER_VIEW_STOP, stopHandler);
112	_view.addEventListener(ViewEvent.JWPLAYER_VIEW_ITEM, itemHandler);
113	_view.addEventListener(ViewEvent.JWPLAYER_VIEW_NEXT, nextHandler);
114	_view.addEventListener(ViewEvent.JWPLAYER_VIEW_PREV, prevHandler);
115	_view.addEventListener(ViewEvent.JWPLAYER_VIEW_SEEK, seekHandler);
116	_view.addEventListener(ViewEvent.JWPLAYER_VIEW_MUTE, muteHandler);
117	_view.addEventListener(ViewEvent.JWPLAYER_VIEW_VOLUME, volumeHandler);
118	_view.addEventListener(ViewEvent.JWPLAYER_VIEW_FULLSCREEN, fullscreenHandler);
119	_view.addEventListener(ViewEvent.JWPLAYER_VIEW_LOAD, loadHandler);
120	_view.addEventListener(ViewEvent.JWPLAYER_VIEW_REDRAW, redrawHandler);
121	}
122
123	private function playHandler(evt:ViewEvent):void { play(); }
124	private function stopHandler(evt:ViewEvent):void { stop(); }
125	private function pauseHandler(evt:ViewEvent):void { pause(); }
126	private function itemHandler(evt:ViewEvent):void { loadNumber(evt.data); }
127	private function nextHandler(evt:ViewEvent):void { next(); }
128	private function prevHandler(evt:ViewEvent):void { previous(); }
129	private function seekHandler(evt:ViewEvent):void { seek(evt.data); }
130	private function muteHandler(evt:ViewEvent):void { mute(evt.data); }
131	private function volumeHandler(evt:ViewEvent):void { setVolume(evt.data); }
132	private function fullscreenHandler(evt:ViewEvent):void { fullscreen(evt.data); }
133	private function loadHandler(evt:ViewEvent):void { load(evt.data); }
134	private function redrawHandler(evt:ViewEvent):void { redraw(); }
135
136	private function addModelListeners():void {
137	_model.playlist.addEventListener(PlaylistEvent.JWPLAYER_PLAYLIST_LOADED, playlistLoadHandler);
138	_model.playlist.addEventListener(ErrorEvent.ERROR, errorHandler);
139	_model.playlist.addEventListener(PlaylistEvent.JWPLAYER_PLAYLIST_ITEM, playlistItemHandler);
140	}
141
142	private function setupComplete(evt:Event):void {
143	dispatchEvent(new PlayerEvent(PlayerEvent.JWPLAYER_READY));
144	RootReference.stage.dispatchEvent(new Event(Event.RESIZE));
145	loadFirstItem();
146	}
147
148	private function playlistLoadHandler(evt:PlaylistEvent):void {
149	// This stuff moved to playlist item handler
150	}
151
152	private function playlistItemHandler(evt:PlaylistEvent):void {
153	var item:PlaylistItem = _model.playlist.currentItem;
154	if (item.provider) {
155
156	// Backwards compatibility for CDNs in the 'type' flashvar.
157	if (cdns.hasOwnProperty(item.provider)) {
158	_model.config.setConfig(cdns[item.provider]);
159	}
160
161	// If the model doesn't have an instance of the provider, load & instantiate it
162	if (!_model.hasMediaProvider(item.provider)) {
163	var mediaLoader:MediaProviderLoader = new MediaProviderLoader();
164	mediaLoader.addEventListener(Event.COMPLETE, mediaSourceLoaded);
165	mediaLoader.addEventListener(ErrorEvent.ERROR, errorHandler);
166	mediaLoader.loadSource(item.provider);
167	return;
168	}
169
170	_model.setActiveMediaProvider(item.provider);
171	}
172
173	if (_player.config.autostart) {
174	load(_model.playlist.currentItem);
175	}
176	}
177
178	private function mediaSourceLoaded(evt:Event):void {
179	var loader:MediaProviderLoader = evt.target as MediaProviderLoader;
180	_model.setMediaProvider(_model.playlist.currentItem.provider, loader.loadedSource);
181	_model.setActiveMediaProvider(_model.playlist.currentItem.provider);
182	load(_model.playlist.currentItem);
183	}
184
185	private function errorHandler(evt:ErrorEvent):void {
186	errorState(evt.text);
187	}
188
189	private function errorState(message:String=""):void {
190	dispatchEvent(new PlayerEvent(PlayerEvent.JWPLAYER_ERROR, message));
191	}
192
193	////////////////////
194	// Public methods //
195	////////////////////
196
197	public function get blocking():Boolean {
198	return _blocking;
199	}
200
201	/**
202	* @private
203	* @copy com.longtailvideo.jwplayer.player.Player#blockPlayback
204	*/
205	public function blockPlayback(plugin:IPlugin):Boolean {
206	if (!_blocking) {
207	_blocking = true;
208	return true;
209	} else {
210	return false;
211	}
212	}
213
214	/**
215	* @private
216	* @copy com.longtailvideo.jwplayer.player.Player#unblockPlayback
217	*/
218	public function unblockPlayback(target:IPlugin):Boolean {
219	if (_blocking) {
220	_blocking = false;
221	return true;
222	} else {
223	return false;
224	}
225	}
226
227	public function setVolume(vol:Number):Boolean {
228	if (_model.media) {
229	_model.config.volume = vol;
230	_model.media.setVolume(vol);
231	return true;
232	} else {
233	return false;
234	}
235	}
236
237	public function mute(muted:Boolean):Boolean {
238	if (muted && !_model.mute) {
239	_model.mute = true;
240	_model.media.mute(true);
241	return true;
242	} else if (!muted && _model.mute) {
243	_model.mute = false;
244	_model.media.mute(false);
245	return true;
246	}
247
248	return false;
249	}
250
251	public function play():Boolean {
252	if (_model.playlist.currentItem) {
253	switch (_player.state) {
254	case PlayerState.IDLE:
255	load(_model.playlist.currentItem);
256	break;
257	case PlayerState.PAUSED:
258	_model.media.play();
259	break;
260	}
261	}
262	return true;
263	}
264
265	public function pause():Boolean {
266	if (!_model.media)
267	return false;
268
269	switch (_model.media.state) {
270	case PlayerState.PLAYING:
271	case PlayerState.BUFFERING:
272	_model.media.pause();
273	return true;
274	break;
275	}
276
277	return false;
278	}
279
280	public function stop():Boolean {
281	if (!_model.media)
282	return false;
283
284	switch (_model.media.state) {
285	case PlayerState.PLAYING:
286	case PlayerState.BUFFERING:
287	case PlayerState.PAUSED:
288	_model.media.stop();
289	return true;
290	break;
291	}
292
293	return false;
294	}
295
296	public function next():Boolean {
297	if (_model.playlist.currentIndex == _model.playlist.length-1) {
298	return false;
299	} else {
300	loadNumber(_model.playlist.currentIndex+1);
301	return true;
302	}
303	}
304
305	public function previous():Boolean {
306	if (_model.playlist.currentIndex <= 0) {
307	return false;
308	} else {
309	loadNumber(_model.playlist.currentIndex-1);
310	return true;
311	}
312	}
313
314	public function seek(pos:Number):Boolean {
315	if (!_model.media)
316	return false;
317
318	switch (_model.media.state) {
319	case PlayerState.PLAYING:
320	case PlayerState.BUFFERING:
321	case PlayerState.PAUSED:
322	_model.media.seek(pos);
323	return true;
324	break;
325	}
326
327	return false;
328	}
329
330	public function load(item:*):Boolean {
331	//if (!_model.media) return false;
332
333	if (item is PlaylistItem) {
334	return loadPlaylistItem(item as PlaylistItem);
335	} else if (item is String) {
336	return loadString(item as String);
337	} else if (item is Number) {
338	return loadNumber(item as Number);
339	} else if (item is Object) {
340	return loadObject(item as Object);
341	}
342	return false;
343	}
344
345	private function loadPlaylistItem(item:PlaylistItem):Boolean {
346	_model.setActiveMediaProvider(item.provider);
347	_model.media.addEventListener(MediaEvent.JWPLAYER_MEDIA_BUFFER_FULL, lockHandler);
348	_model.media.load(item);
349	return true;
350	}
351
352	private function loadString(item:String):Boolean {
353	var ext:String = Strings.extension(item);
354	if (extensions.hasOwnProperty(ext)) {
355	var type:String = extensions[ext];
356	_model.setActiveMediaProvider(type);
357	_model.media.addEventListener(MediaEvent.JWPLAYER_MEDIA_BUFFER_FULL, lockHandler);
358	_model.media.load(new PlaylistItem({file:item}));
359	} else {
360	_model.playlist.load(item);
361	}
362	return false;
363	}
364
365	private function loadNumber(item:Number):Boolean {
366	if (item >= 0 && item < _model.playlist.length) {
367	_model.media.addEventListener(MediaEvent.JWPLAYER_MEDIA_BUFFER_FULL, lockHandler);
368	_model.media.load(_model.playlist.getItemAt(item));
369	return true;
370	}
371	return false;
372	}
373
374	private function loadObject(item:Object):Boolean {
375	if (Object(item).hasOwnProperty('file')) {
376	_model.media.addEventListener(MediaEvent.JWPLAYER_MEDIA_BUFFER_FULL, lockHandler);
377	_model.media.load(new PlaylistItem(item));
378	return true;
379	}
380	return false;
381	}
382
383	private function lockHandler(evt:MediaEvent):void {
384	_model.media.play();
385	}
386
387	public function redraw():Boolean {
388	_view.redraw();
389	return true;
390	}
391
392	public function fullscreen(mode:Boolean):Boolean {
393	_view.fullscreen(mode);
394	return true;
395	}
396
397	public function link(playlistIndex:Number=NaN):Boolean {
398	if (isNaN(playlistIndex))
399	playlistIndex = _model.playlist.currentIndex;
400
401	if (playlistIndex >= 0 && playlistIndex < _model.playlist.length) {
402	navigateToURL(new URLRequest(_model.playlist.getItemAt(playlistIndex).link), _model.config.linktarget);
403	return true;
404	}
405
406	return false;
407	}
408
409	private function loadFirstItem():void {
410	// if (_model.playlist.currentItem) {
411	// load(_model.playlist.currentItem);
412	// }
413	}
414
415
416	}
417	}

Note: See TracBrowser for help on using the repository browser.

Download in other formats:

Original Format