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

Revision 118, 9.1 KB checked in by jeroen, 5 years ago (diff)

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