root/trunk/as3/com/jeroenwijering/player/View.as

Revision 388, 10.1 kB (checked in by jeroen, 6 weeks ago)

switched to mxmlc for ompiling the player

  • Property svn:executable set to *
Line 
1/**
2* Wrap all views and plugins and provides them with MVC access pointers.
3**/
4package com.jeroenwijering.player {
5
6
7import com.jeroenwijering.events.*;
8import com.jeroenwijering.utils.*;
9
10import flash.display.*;
11import flash.events.*;
12import flash.external.ExternalInterface;
13import flash.system.*;
14import flash.ui.ContextMenu;
15import flash.utils.setTimeout;
16
17
18public class View extends AbstractView {
19
20
21        /** Object with all configuration parameters **/
22        private var _config:Object;
23        /** Reference to all stage graphics. **/
24        private var _skin:MovieClip;
25        /** Object that load the skin and plugins. **/
26        private var sploader:SPLoader;
27        /** Controller of the MVC cycle. **/
28        private var controller:Controller;
29        /** Model of the MVC cycle. **/
30        private var model:Model;
31        /** Reference to the contextmenu. **/
32        private var context:ContextMenu;
33        /** A list with all javascript listeners. **/
34        private var listeners:Array;
35        /** Player is ready **/
36        private var ready:Boolean;
37
38
39        /** Constructor, save references and subscribe to events. **/
40        public function View(cfg:Object,skn:MovieClip,ldr:SPLoader,ctr:Controller,mdl:Model):void {
41                Security.allowDomain("*");
42                _config = cfg;
43                _config['client'] = 'FLASH '+Capabilities.version;
44                _skin = skn;
45                _skin.stage.scaleMode = "noScale";
46                _skin.stage.align = "TL";
47                _skin.stage.addEventListener(Event.RESIZE,resizeHandler);
48                sploader = ldr;
49                controller = ctr;
50                model = mdl;
51                setListening();
52                listeners = new Array();
53        };
54
55
56        /**  Getters for the config parameters, skinning parameters and playlist. **/
57        override public function get config():Object { return _config; };
58        override public function get playlist():Array { return controller.playlist; };
59        override public function get skin():MovieClip { return _skin; };
60
61
62        /**  Subscribers to the controller, model and view. **/
63        override public function addControllerListener(typ:String,fcn:Function):void {
64                controller.addEventListener(typ.toUpperCase(),fcn);
65        };
66        private function addJSControllerListener(typ:String,fcn:String):Boolean {
67                listeners.push({target:'CONTROLLER',type:typ.toUpperCase(),callee:fcn});
68                return true;
69        };
70        override public function addModelListener(typ:String,fcn:Function):void {
71                model.addEventListener(typ.toUpperCase(),fcn);
72        };
73        private function addJSModelListener(typ:String,fcn:String):Boolean {
74                listeners.push({target:'MODEL',type:typ.toUpperCase(),callee:fcn});
75                return true;
76        };
77        override public function addViewListener(typ:String,fcn:Function):void {
78                this.addEventListener(typ.toUpperCase(),fcn);
79        };
80        private function addJSViewListener(typ:String,fcn:String):Boolean {
81                listeners.push({target:'VIEW',type:typ.toUpperCase(),callee:fcn});
82                return true;
83        };
84
85
86        /** Send event to listeners and tracers. **/
87        private function forward(tgt:String,typ:String,dat:Object):void {
88                var prm:String = '';
89                for (var i:String in dat) { prm += i+':'+dat[i]+','; }
90                if(prm.length > 0) {
91                        prm = '('+prm.substr(0,prm.length-1)+')';
92                }
93                if(!dat) { dat = new Object(); }
94                dat.id = config['id'];
95                dat.client = config['client'];
96                dat.version = config['version'];
97                for (var itm:String in listeners) {
98                        if(listeners[itm]['target'] == tgt && listeners[itm]['type'] == typ) {
99                                ExternalInterface.call(listeners[itm]['callee'],dat);
100                        }
101                }
102        };
103
104
105        /** Javascript getters for the config, pluginconfig and playlist. **/
106        private function getConfig():Object {
107                var cfg:Object = new Object();
108                for(var s:String in _config) {
109                        if(s.indexOf('.') == -1 && _config[s] != undefined) {
110                                cfg[s] = _config[s];
111                        }
112                }
113                return cfg;
114        };
115
116
117        /** Return the current playlist. **/
118        private function getPlaylist():Array {
119                var arr:Array = new Array();
120                var cfg:Object = new Object();
121                if(controller.playlist) {
122                        for(var i:Number=0; i<controller.playlist.length; i++) {
123                                cfg = new Object();
124                                for(var s:String in controller.playlist[i]) {
125                                        if(s.indexOf('.') == -1) {
126                                                cfg[s] = controller.playlist[i][s];
127                                        }
128                                }
129                                arr.push(cfg);
130                        }
131                }
132                return arr;
133        };
134
135
136        /** Return the config object of a specific plugin. **/
137        override public function getPluginConfig(nam:Object):Object {
138                return sploader.getPluginConfig(nam);
139        };
140
141
142        /** Return the config object of a specific plugin. **/
143        public function getJSPluginConfig(nam:String):Object {
144                try {
145                        var plg:Object = getPlugin(nam);
146                        var cfg:Object = getPluginConfig(plg);
147                } catch (err:Error) {
148                        return {error:'plugin not loaded'}
149                }
150                var obj:Object = new Object();
151                for(var s:String in cfg) {
152                        if(cfg[s] is String || cfg[s] is Boolean || cfg[s] is Number) {
153                                obj[s] = cfg[s];
154                        }
155                }
156                return obj;
157        };
158
159
160
161
162        /** Get a reference to a specific plugin. **/
163        override public function getPlugin(nam:String):Object {
164                return sploader.getPlugin(nam);
165        };
166
167
168        /** Load a plugin into the player at runtime. **/
169        override public function loadPlugin(url:String,vrs:String=null):Boolean {
170                sploader.loadPlugin(url,vrs);
171                return true;
172        };
173
174
175        /** Send a ready ping to javascript. **/
176        public function playerReady():void {
177                if(ExternalInterface.available && _skin.loaderInfo.url.indexOf('http') == 0 && ready != true) {
178                        ready = true;
179                        setTimeout(playerReadyPing,50);
180                }
181        };
182
183
184        /** The timeout on this ping is needed for IE - it'll not get the playerReady call. **/
185        private function playerReadyPing():void {
186                try {
187                        if(ExternalInterface.objectID && !_config['id']) {
188                                _config['id'] = ExternalInterface.objectID;
189                        }
190                        if(_config['id']) {
191                                ExternalInterface.addCallback("addControllerListener",addJSControllerListener);
192                                ExternalInterface.addCallback("addModelListener",addJSModelListener);
193                                ExternalInterface.addCallback("addViewListener",addJSViewListener);
194                                ExternalInterface.addCallback("removeControllerListener",removeJSControllerListener);
195                                ExternalInterface.addCallback("removeModelListener",removeJSModelListener);
196                                ExternalInterface.addCallback("removeViewListener",removeJSViewListener);
197                                ExternalInterface.addCallback("getConfig",getConfig);
198                                ExternalInterface.addCallback("getPlaylist",getPlaylist);
199                                ExternalInterface.addCallback("getPluginConfig",getJSPluginConfig);
200                                ExternalInterface.addCallback("loadPlugin",loadPlugin);
201                                ExternalInterface.addCallback("sendEvent",sendEvent);
202                                ExternalInterface.call("playerReady",{
203                                        id:config['id'],
204                                        client:config['client'],
205                                        version:config['version']
206                                });
207                        }
208                } catch (err:Error) {}
209        }
210
211
212        /**  Unsubscribers to the controller, model and view. **/
213        override public function removeControllerListener(typ:String,fcn:Function):void {
214                controller.removeEventListener(typ.toUpperCase(),fcn);
215        };
216        private function removeJSControllerListener(typ:String,fcn:String):Boolean {
217                removeJSListener('CONTROLLER',typ.toUpperCase(),fcn);
218                return true;
219        };
220        override public function removeModelListener(typ:String,fcn:Function):void {
221                model.removeEventListener(typ.toUpperCase(),fcn);
222        };
223        private function removeJSModelListener(typ:String,fcn:String):Boolean {
224                removeJSListener('MODEL',typ.toUpperCase(),fcn);
225                return true;
226        };
227        override public function removeViewListener(typ:String,fcn:Function):void {
228                this.removeEventListener(typ.toUpperCase(),fcn);
229        };
230        private function removeJSViewListener(typ:String,fcn:String):Boolean {
231                removeJSListener('VIEW',typ.toUpperCase(),fcn);
232                return true;
233        };
234        private function removeJSListener(tgt:String,typ:String,fcn:String):void {
235                for(var i:Number=0; i<listeners.length; i++) {
236                        if(listeners[i]['target'] == tgt && listeners[i]['type'] == typ && listeners[i]['callee'] == fcn) {
237                                listeners.splice(i,1);
238                                return;
239                        }
240                }
241        };
242
243
244        /** Send a redraw request when the stage is resized. **/
245        private function resizeHandler(evt:Event=undefined):void {
246                dispatchEvent(new ViewEvent(ViewEvent.REDRAW));
247        };
248
249
250        /**  Dispatch events. **/
251        override public function sendEvent(typ:String,prm:Object=undefined):void {
252                typ = typ.toUpperCase();
253                var dat:Object = new Object();
254                switch(typ) {
255                        case 'ITEM':
256                                dat['index'] = prm;
257                                break;
258                        case 'LINK':
259                                dat['index'] = prm;
260                                break;
261                        case 'LOAD':
262                                dat['object'] = prm;
263                                break;
264                        case 'SEEK':
265                                dat['position'] = prm;
266                                break;
267                        case 'VOLUME':
268                                dat['percentage'] = prm;
269                                break;
270                        default:
271                                if(prm == true || prm == 'true') {
272                                        dat['state'] = true;
273                                } else if(prm === false || prm == 'false') {
274                                        dat['state'] = false;
275                                }
276                                break;
277                }
278                Logger.log(prm,typ);
279                dispatchEvent(new ViewEvent(typ,dat));
280        };
281
282
283        /** Forward events to tracer and subscribers. **/
284        private function setController(evt:ControllerEvent):void { forward('CONTROLLER',evt.type,evt.data); };
285        private function setModel(evt:ModelEvent):void { forward('MODEL',evt.type,evt.data); };
286        private function setView(evt:ViewEvent):void { forward('VIEW',evt.type,evt.data); };
287
288
289        /** Setup listeners to all events for tracing / javascript. **/
290        private function setListening():void {
291                addControllerListener(ControllerEvent.ERROR,setController);
292                addControllerListener(ControllerEvent.ITEM,setController);
293                addControllerListener(ControllerEvent.MUTE,setController);
294                addControllerListener(ControllerEvent.PLAY,setController);
295                addControllerListener(ControllerEvent.PLAYLIST,setController);
296                addControllerListener(ControllerEvent.RESIZE,setController);
297                addControllerListener(ControllerEvent.SEEK,setController);
298                addControllerListener(ControllerEvent.STOP,setController);
299                addControllerListener(ControllerEvent.VOLUME,setController);
300                addModelListener(ModelEvent.BUFFER,setModel);
301                addModelListener(ModelEvent.ERROR,setModel);
302                addModelListener(ModelEvent.LOADED,setModel);
303                addModelListener(ModelEvent.META,setModel);
304                addModelListener(ModelEvent.STATE,setModel);
305                addModelListener(ModelEvent.TIME,setModel);
306                addViewListener(ViewEvent.FULLSCREEN,setView);
307                addViewListener(ViewEvent.ITEM,setView);
308                addViewListener(ViewEvent.LINK,setView);
309                addViewListener(ViewEvent.LOAD,setView);
310                addViewListener(ViewEvent.MUTE,setView);
311                addViewListener(ViewEvent.NEXT,setView);
312                addViewListener(ViewEvent.PLAY,setView);
313                addViewListener(ViewEvent.PREV,setView);
314                addViewListener(ViewEvent.REDRAW,setView);
315                addViewListener(ViewEvent.SEEK,setView);
316                addViewListener(ViewEvent.STOP,setView);
317                addViewListener(ViewEvent.TRACE,setView);
318                addViewListener(ViewEvent.VOLUME,setView);
319        };
320
321
322}
323
324
325}
Note: See TracBrowser for help on using the browser.