source: trunk/fl5/src/com/longtailvideo/jwplayer/player/PlayerV4Emulation.as @ 627

Revision 627, 16.6 KB checked in by pablo, 4 years ago (diff)
  • PLAYLIST_ITEM event sent after PLAYER_READY if playlist was loaded during player setup
  • V4 COMPLETE state set in view.config if playlist is at last item during IDLE state
  • Fixed playlist masking issue
Line 
1package com.longtailvideo.jwplayer.player {
2        import com.jeroenwijering.events.AbstractView;
3        import com.jeroenwijering.events.ControllerEvent;
4        import com.jeroenwijering.events.ModelEvent;
5        import com.jeroenwijering.events.ModelStates;
6        import com.longtailvideo.jwplayer.controller.Controller;
7        import com.longtailvideo.jwplayer.events.MediaEvent;
8        import com.longtailvideo.jwplayer.events.PlayerEvent;
9        import com.longtailvideo.jwplayer.events.PlayerStateEvent;
10        import com.longtailvideo.jwplayer.events.PlaylistEvent;
11        import com.longtailvideo.jwplayer.events.ViewEvent;
12        import com.longtailvideo.jwplayer.model.IPlaylist;
13        import com.longtailvideo.jwplayer.model.Model;
14        import com.longtailvideo.jwplayer.model.PlaylistItem;
15        import com.longtailvideo.jwplayer.plugins.PluginConfig;
16        import com.longtailvideo.jwplayer.plugins.V4Plugin;
17        import com.longtailvideo.jwplayer.utils.Logger;
18        import com.longtailvideo.jwplayer.utils.Strings;
19        import com.longtailvideo.jwplayer.view.interfaces.IControlbarComponent;
20        import com.longtailvideo.jwplayer.view.interfaces.IDisplayComponent;
21        import com.longtailvideo.jwplayer.view.interfaces.IDockComponent;
22        import com.longtailvideo.jwplayer.view.interfaces.IPlaylistComponent;
23       
24        import flash.display.DisplayObject;
25        import flash.events.EventDispatcher;
26        import flash.utils.describeType;
27
28        /**
29         * This singleton class acts as a wrapper between the Player and plugins or javascripts that were
30         * written for version 4 of the player.  It extends version 4's AbstractView class, and translates
31         * Player 5 event dispatches into their version 4 counterparts.
32         *
33         * @see com.longtailvideo.jwplayer.plugins.V4Plugin 
34         */
35        public class PlayerV4Emulation extends AbstractView {
36                private static var instance:PlayerV4Emulation;
37               
38                private var _player:IPlayer;
39               
40                private var viewEventDispatcher:EventDispatcher;
41                private var modelEventDispatcher:EventDispatcher;
42                private var controllerEventDispatcher:EventDispatcher;
43               
44                private var id:String;
45                private var client:String;
46                private var version:String;
47               
48                public function PlayerV4Emulation(player:IPlayer) {
49                        viewEventDispatcher = new EventDispatcher();
50                        modelEventDispatcher = new EventDispatcher();
51                        controllerEventDispatcher = new EventDispatcher();
52                               
53                        _player = player;
54                        _player.addEventListener(PlayerEvent.JWPLAYER_READY, playerReady);
55                }
56               
57                public static function getInstance(player:IPlayer):PlayerV4Emulation {
58                        if (!instance) {
59                                instance = new PlayerV4Emulation(player);
60                        }
61                        return instance;
62                }
63               
64                private function playerReady(evt:PlayerEvent):void {
65                        var newEvt:PlayerEvent = new PlayerEvent("");
66                        id = newEvt.id;
67                        client = newEvt.client;
68                        version = newEvt.version;
69                         
70                        dispatchEvent(new com.jeroenwijering.events.PlayerEvent(com.jeroenwijering.events.PlayerEvent.READY));
71                        setupListeners();
72                }
73               
74                private function setupListeners():void {
75                       
76                        var m:Model;
77                        var v:IControlbarComponent;
78                        var c:Controller
79                       
80                        _player.addEventListener(PlayerEvent.JWPLAYER_ERROR, errorHandler);
81                       
82                        _player.addEventListener(MediaEvent.JWPLAYER_MEDIA_BUFFER, mediaBuffer);
83                        _player.addEventListener(MediaEvent.JWPLAYER_MEDIA_ERROR, mediaError);
84                        _player.addEventListener(MediaEvent.JWPLAYER_MEDIA_LOADED, mediaLoaded);
85                        _player.addEventListener(MediaEvent.JWPLAYER_MEDIA_TIME, mediaTime);
86                        _player.addEventListener(MediaEvent.JWPLAYER_MEDIA_VOLUME, mediaVolume);
87                        _player.addEventListener(MediaEvent.JWPLAYER_MEDIA_META, mediaMeta);
88                        _player.addEventListener(PlayerStateEvent.JWPLAYER_PLAYER_STATE, stateHandler);
89
90                        _player.addEventListener(ViewEvent.JWPLAYER_VIEW_FULLSCREEN, viewFullscreen);
91                        _player.addEventListener(ViewEvent.JWPLAYER_VIEW_ITEM, viewItem);
92                        _player.addEventListener(ViewEvent.JWPLAYER_VIEW_LOAD, viewLoad);
93                        _player.addEventListener(ViewEvent.JWPLAYER_VIEW_MUTE, viewMute);
94                        _player.addEventListener(ViewEvent.JWPLAYER_VIEW_NEXT, viewNext);
95                        _player.addEventListener(ViewEvent.JWPLAYER_VIEW_PAUSE, viewPause);
96                        _player.addEventListener(ViewEvent.JWPLAYER_VIEW_PLAY, viewPlay);
97                        _player.addEventListener(ViewEvent.JWPLAYER_VIEW_PREV, viewPrev);
98                        _player.addEventListener(ViewEvent.JWPLAYER_VIEW_SEEK, viewSeek);
99                        _player.addEventListener(ViewEvent.JWPLAYER_VIEW_STOP, viewStop);
100                        _player.addEventListener(ViewEvent.JWPLAYER_VIEW_VOLUME, viewVolume);
101                       
102                        _player.playlist.addEventListener(PlaylistEvent.JWPLAYER_PLAYLIST_ITEM, playlistItem);
103                        _player.playlist.addEventListener(PlaylistEvent.JWPLAYER_PLAYLIST_LOADED, playlistLoad);
104                }
105               
106                // Player Event Handlers
107               
108                private function errorHandler(evt:PlayerEvent):void {
109                        controllerEventDispatcher.dispatchEvent(new ControllerEvent(ControllerEvent.ERROR, {message:evt.message, id:id, client:client, version:version}));
110                }
111               
112                // Media Event Handlers
113               
114                private function mediaBuffer(evt:MediaEvent):void {
115                        modelEventDispatcher.dispatchEvent(new ModelEvent(ModelEvent.BUFFER, {percentage:evt.bufferPercent, id:id, client:client, version:version}));
116                }
117               
118                private function mediaError(evt:MediaEvent):void {
119                        modelEventDispatcher.dispatchEvent(new ModelEvent(ModelEvent.ERROR, {message:evt.message, id:id, client:client, version:version}));
120                }
121               
122                private function mediaLoaded(evt:MediaEvent):void {
123                        modelEventDispatcher.dispatchEvent(new ModelEvent(ModelEvent.LOADED, {loaded:0, total:0, offset:0, id:id, client:client, version:version}));
124                }
125               
126                private function mediaTime(evt:MediaEvent):void {
127                        modelEventDispatcher.dispatchEvent(new ModelEvent(ModelEvent.TIME, {duration:evt.duration, position:evt.position, id:id, client:client, version:version}));
128                }
129               
130                private function mediaVolume(evt:MediaEvent):void {
131                        controllerEventDispatcher.dispatchEvent(new ControllerEvent(ControllerEvent.VOLUME, {percentage:evt.volume, id:id, client:client, version:version}));
132                }
133
134                private function mediaMeta(evt:MediaEvent):void {
135                        evt.metadata['id'] = id;
136                        evt.metadata['client'] = client;
137                        evt.metadata['version'] = version;
138                        modelEventDispatcher.dispatchEvent(new ModelEvent(ModelEvent.META, evt.metadata));
139                }
140               
141                private function stateHandler(evt:PlayerStateEvent):void {
142                        if (evt.newstate == PlayerState.IDLE && (evt.oldstate == PlayerState.BUFFERING || evt.oldstate == PlayerState.PLAYING)) {
143                                controllerEventDispatcher.dispatchEvent(new ControllerEvent(ControllerEvent.STOP, {id:id, client:client, version:version}));
144                        }
145                       
146                        modelEventDispatcher.dispatchEvent(new ModelEvent(ModelEvent.STATE, {oldstate:evt.oldstate, newstate:evt.newstate}));
147                }
148
149                // View Event Handlers
150
151                private function viewFullscreen(evt:ViewEvent):void {
152                        viewEventDispatcher.dispatchEvent(new com.jeroenwijering.events.ViewEvent(com.jeroenwijering.events.ViewEvent.FULLSCREEN, {state:evt.data, id:id, client:client, version:version}));
153                }
154               
155                private function viewItem(evt:ViewEvent):void {
156                        viewEventDispatcher.dispatchEvent(new com.jeroenwijering.events.ViewEvent(com.jeroenwijering.events.ViewEvent.ITEM, {index:evt.data, id:id, client:client, version:version}));
157                }
158
159                private function viewLoad(evt:ViewEvent):void {
160                        viewEventDispatcher.dispatchEvent(new com.jeroenwijering.events.ViewEvent(com.jeroenwijering.events.ViewEvent.LOAD, {object:evt.data, id:id, client:client, version:version}));
161                }
162               
163                private function viewMute(evt:ViewEvent):void {
164                        viewEventDispatcher.dispatchEvent(new com.jeroenwijering.events.ViewEvent(com.jeroenwijering.events.ViewEvent.MUTE, {state:evt.data, id:id, client:client, version:version}));
165                        controllerEventDispatcher.dispatchEvent(new ControllerEvent(ControllerEvent.MUTE, {state:evt.data, client:client, version:version}));
166                }
167               
168                private function viewNext(evt:ViewEvent):void {
169                        viewEventDispatcher.dispatchEvent(new com.jeroenwijering.events.ViewEvent(com.jeroenwijering.events.ViewEvent.NEXT, {id:id, client:client, version:version}));
170                }
171               
172                private function viewPause(evt:ViewEvent):void {
173                        viewEventDispatcher.dispatchEvent(new com.jeroenwijering.events.ViewEvent(com.jeroenwijering.events.ViewEvent.PLAY, {state:false, id:id, client:client, version:version}));
174                        controllerEventDispatcher.dispatchEvent(new ControllerEvent(ControllerEvent.PLAY, {state:false, id:id, client:client, version:version}));
175                }
176
177                private function viewPlay(evt:ViewEvent):void {
178                        viewEventDispatcher.dispatchEvent(new com.jeroenwijering.events.ViewEvent(com.jeroenwijering.events.ViewEvent.PLAY, {state:true, id:id, client:client, version:version}));
179                        controllerEventDispatcher.dispatchEvent(new ControllerEvent(ControllerEvent.PLAY, {state:true, id:id, client:client, version:version}));
180                }
181               
182                private function viewPrev(evt:ViewEvent):void {
183                        viewEventDispatcher.dispatchEvent(new com.jeroenwijering.events.ViewEvent(com.jeroenwijering.events.ViewEvent.PREV, {id:id, client:client, version:version}));
184                }
185               
186                private function viewRedraw(width:Number, height:Number):void {
187                        viewEventDispatcher.dispatchEvent(new com.jeroenwijering.events.ViewEvent(com.jeroenwijering.events.ViewEvent.REDRAW, {id:id, client:client, version:version}));
188                        controllerEventDispatcher.dispatchEvent(new ControllerEvent(ControllerEvent.RESIZE, {width:width, height:height, fullscreen:_player.fullscreen, client:client, version:version}));
189                }
190
191                private function viewSeek(evt:ViewEvent):void {
192                        viewEventDispatcher.dispatchEvent(new com.jeroenwijering.events.ViewEvent(com.jeroenwijering.events.ViewEvent.SEEK, {position:evt.data, id:id, client:client, version:version}));
193                        controllerEventDispatcher.dispatchEvent(new ControllerEvent(ControllerEvent.SEEK, {position:evt.data, id:id, client:client, version:version}));
194                }
195               
196                private function viewStop(evt:ViewEvent):void {
197                        viewEventDispatcher.dispatchEvent(new com.jeroenwijering.events.ViewEvent(com.jeroenwijering.events.ViewEvent.STOP, {id:id, client:client, version:version}));
198                }
199               
200                private function viewVolume(evt:ViewEvent):void {
201                        viewEventDispatcher.dispatchEvent(new com.jeroenwijering.events.ViewEvent(com.jeroenwijering.events.ViewEvent.VOLUME, {state:evt.data, id:id, client:client, version:version}));
202                        controllerEventDispatcher.dispatchEvent(new ControllerEvent(ControllerEvent.VOLUME, {percentage:evt.data, id:id, client:client, version:version}));
203                }
204               
205                // Playlist Event Handlers
206               
207                private function playlistItem(evt:PlaylistEvent):void {
208                        controllerEventDispatcher.dispatchEvent(new ControllerEvent(ControllerEvent.ITEM, {index:_player.playlist.currentIndex, id:id, client:client, version:version}));
209                }
210
211                private function playlistLoad(evt:PlaylistEvent):void {
212                        controllerEventDispatcher.dispatchEvent(new ControllerEvent(ControllerEvent.PLAYLIST, {playlist:playlistToArray(_player.playlist), id:id, client:client, version:version}));
213                }
214               
215               
216                // Listeners
217
218                public override function addModelListener(type:String, listener:Function):void {
219                        modelEventDispatcher.addEventListener(type, listener);
220                }
221                public override function removeModelListener(type:String, listener:Function):void {
222                        modelEventDispatcher.removeEventListener(type, listener);
223                }
224
225                public override function addViewListener(type:String, listener:Function):void {
226                        viewEventDispatcher.addEventListener(type, listener);
227                }
228                public override function removeViewListener(type:String, listener:Function):void {
229                        viewEventDispatcher.removeEventListener(type, listener);
230                }
231
232                public override function addControllerListener(type:String, listener:Function):void {
233                        controllerEventDispatcher.addEventListener(type, listener);
234                }
235                public override function removeControllerListener(type:String, listener:Function):void {
236                        controllerEventDispatcher.removeEventListener(type, listener);
237                }
238               
239                // Event "dispatcher"
240               
241                public override function sendEvent(typ:String, prm:Object=undefined) : void {
242                        Logger.log("V4 plugin sending event: " + typ);
243                        switch (typ) {
244                                case com.jeroenwijering.events.ViewEvent.FULLSCREEN:
245                                        _player.fullscreen = prm['state'];
246                                        break;
247                                case com.jeroenwijering.events.ViewEvent.ITEM:
248                                        _player.playlist.currentIndex = Number(prm);
249                                        break;
250                                case com.jeroenwijering.events.ViewEvent.LINK:
251                                        _player.link(Number(prm['index']));
252                                        break;
253                                case com.jeroenwijering.events.ViewEvent.LOAD:
254                                        _player.load(prm);
255                                        break;
256                                case com.jeroenwijering.events.ViewEvent.MUTE:
257                                        _player.mute = prm['state'];
258                                        break;
259                                case com.jeroenwijering.events.ViewEvent.NEXT:
260                                        _player.playlist.currentIndex++;
261                                        break;
262                                case com.jeroenwijering.events.ViewEvent.PLAY:
263                                        if (prm != null && Strings.serialize(prm.toString()) == false) {
264                                                _player.pause();
265                                        } else {
266                                                _player.play();
267                                        }
268                                        break;
269                                case com.jeroenwijering.events.ViewEvent.PREV:
270                                        _player.playlist.currentIndex--;
271                                        break;
272                                case com.jeroenwijering.events.ViewEvent.REDRAW:
273                                        _player.redraw();
274                                        break;
275                                case com.jeroenwijering.events.ViewEvent.SEEK:
276                                        _player.seek(prm['position']);
277                                        break;
278                                case com.jeroenwijering.events.ViewEvent.STOP:
279                                        _player.stop();
280                                        break;
281                                case com.jeroenwijering.events.ViewEvent.TRACE:
282                                        Logger.log(prm);
283                                        break;
284                                case com.jeroenwijering.events.ViewEvent.VOLUME:
285                                        _player.volume(prm['percentage']);
286                                        break;
287                        }
288                }
289
290                public override function get config():Object {
291                        var cfg:Object = {};
292                        var descType:XML = describeType(_player.config)
293                        for each (var i:String in descType.accessor.@name) {
294                                if (_player.config[i] != null) {
295                                        cfg[i] = Strings.serialize(_player.config[i].toString());
296                                }
297                               
298/*                              if (_player.config[i] is Number) {
299                                        cfg[i] = isNaN(_player.config[i]) ? "" : String(_player.config[i]);
300                                } else if (_player.config[i] is Boolean) {
301                                        cfg[i] = _player.config[i];
302                                } else if (_player.config[i] != null) {
303                                        cfg[i] = _player.config[i].toString();
304                                }
305*/                      }
306                       
307                        for each (var j:String in _player.config.pluginIds) {
308                                var pluginConfig:PluginConfig = _player.config.pluginConfig(j);
309                                for (var k:String in pluginConfig){
310                                        cfg[j+"."+k] = pluginConfig[k];
311                                }
312                        }
313
314                        switch(_player.state) {
315                                case PlayerState.BUFFERING:
316                                        cfg['state'] = ModelStates.BUFFERING;
317                                        break;
318                                case PlayerState.PLAYING:
319                                        cfg['state'] = ModelStates.PLAYING;
320                                        break;
321                                case PlayerState.PAUSED:
322                                        cfg['state'] = ModelStates.PAUSED;
323                                        break;
324                                case PlayerState.IDLE:
325                                        if (_player.playlist.currentIndex > 0 && _player.playlist.currentIndex == (_player.playlist.length-1)) {
326                                                cfg['state'] = ModelStates.COMPLETED;
327                                        } else {
328                                                cfg['state'] = ModelStates.IDLE;
329                                        }
330                                        break;
331                        }
332
333                        cfg['mute'] = _player.mute;
334                        cfg['fullscreen'] = _player.fullscreen;
335                        cfg['version'] = _player.version;
336                       
337                        return cfg;
338                }
339
340                public override function get playlist():Array {
341                        return playlistToArray(_player.playlist);
342                }
343               
344                private function playlistToArray(list:IPlaylist):Array {
345                        var arry:Array = [];
346                       
347                        for (var i:Number=0; i < list.length; i++) {
348                                arry.push(playlistItemToObject(list.getItemAt(i)));
349                        }
350                       
351                        return arry;
352                }
353               
354                private function playlistItemToObject(item:PlaylistItem):Object {
355                        var obj:Object = {
356                                'author':               item.author,
357                                'date':                 item.date,
358                                'description':  item.description,
359                                'duration':             item.duration,
360                                'file':                 item.file,
361                                'image':                item.image,
362                                'link':                 item.link,
363                                'mediaid':              item.mediaid,
364                                'start':                item.start,
365                                'streamer':             item.streamer,
366                                'tags':                 item.tags,
367                                'title':                item.title,
368                                'type':                 item.provider
369                        };
370                       
371                        for each (var i:String in item) {
372                                obj[i] = item[i];
373                        }
374                       
375                        return obj;
376                }
377               
378                public override function getPluginConfig(plugin:Object):Object {
379                        var pluginParent:V4Plugin = (plugin as DisplayObject).parent as V4Plugin;
380                        if (pluginParent) {
381                                return _player.config.pluginConfig(pluginParent.pluginId);
382                        } else if (plugin is IDockComponent) {
383                                return _player.config.pluginConfig('dock');
384                        } else if (plugin is IDisplayComponent) {
385                                return _player.config.pluginConfig('display');
386                        } else if (plugin is IControlbarComponent) {
387                                return _player.config.pluginConfig('controlbar');
388                        } else if (plugin is IPlaylistComponent) {
389                                return _player.config.pluginConfig('playlist');
390                        } else {
391                                return new PluginConfig('');
392                        }
393                }
394               
395                public function resize(width:Number, height:Number):void {
396                        viewRedraw(width, height);
397                }
398               
399                public override function getPlugin(plugin:String):Object {
400                        var result:Object;
401                        switch (plugin){
402                                case 'dock':
403                                        result = _player.controls.dock as Object;
404                                        break;
405                                case 'controlbar':
406                                        result = _player.controls.controlbar as Object;
407                                        break;
408                                case 'display':
409                                        result = _player.controls.display as Object;
410                                        break;
411                                case 'playlist':
412                                        result = _player.controls.playlist as Object;
413                                        break;
414                                default:
415                                        // Backwards compatibility for 4.x plugins
416                                        try {
417                                                result = (_player as Object).getPlugin(plugin);
418                                        } catch (e:Error) {}
419                        }
420                        return result;
421                }
422        }
423}
Note: See TracBrowser for help on using the repository browser.