source: trunk/as3/com/jeroenwijering/player/View.as @ 211

Revision 211, 10.2 KB checked in by jeroen, 4 years ago (diff)

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