source: branches/4.2/com/jeroenwijering/player/View.as @ 77

Revision 77, 8.2 KB checked in by jeroen, 5 years ago (diff)

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