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

Revision 75, 8.1 KB checked in by jeroen, 5 years ago (diff)

air version is working, string of fixes to 4.2
  • 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:SWFLoader;
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:SWFLoader):void {
43                _config = cfg;
44                _config['client'] = 'FLASH '+Capabilities.version;
45                _skin = skn;
46                _skin.stage.scaleMode = "noScale";
47                _skin.stage.align = "TL";
48                _skin.stage.addEventListener(Event.RESIZE,resizeHandler);
49                loader = ldr;
50                controller = ctr;
51                model = mdl;
52                setListening();
53                if(ExternalInterface.available && _skin.loaderInfo.url.indexOf('http') == 0) {
54                        listeners = new Array();
55                        setJavascript();
56                }
57        };
58
59
60        /**  Getters for the config parameters, skinning parameters and playlist. **/
61        override public function get config():Object { return _config; };
62        private function getConfig():Object { return _config; };
63        override public function get playlist():Array { return controller.playlist; };
64        private function getPlaylist():Array { return controller.playlist; };
65        override public function get skin():MovieClip { return _skin; };
66
67
68        /**  Subscribers to the controller and model. **/
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 = '';
95                for (var i in dat) { prm += i+':'+dat[i]+','; }
96                if(prm.length > 0) {
97                        prm = '('+prm.substr(0,prm.length-1)+')';
98                }
99                if(config['tracer'] == 'arthropod') {
100                        var obj = {CONTROLLER:'0xFF6666',VIEW:'0x66FF66',MODEL:'0x6666FF'};
101                        Debug.log(typ+' '+prm,obj[tgt]);
102                } else if(config['tracer']) {
103                        ExternalInterface.call(config['tracer'],tgt+': '+typ+' '+prm);
104                } else {
105                        trace(tgt+': '+typ+' '+prm);
106                }
107                if(!dat) { dat = new Object(); }
108                dat.id = ExternalInterface.objectID;
109                dat.client = config['client'];
110                dat.version = config['version'];
111                for each (var itm in listeners) {
112                        if(itm['target'] == tgt && itm['type'] == typ) {
113                                ExternalInterface.call(itm['callee'],dat);
114                        }
115                }
116        };
117
118
119        /**
120        * Add a plugin to the player.
121        *
122        * @prm pgi      The name of the plugin to load.
123        * @prm str      A string of additional flashvars (separated by & and = signs).
124        *
125        * @return       Boolean true if succeeded.
126        **/
127        public function loadPlugin(pgi:String,str:String=null):Boolean {
128                if(str != null && str != '') {
129                        var ar1 = str.split('&');
130                        for(var i in ar1) {
131                                var ar2 = ar1[i].split('=');
132                                _config[ar2[0]] = Strings.serialize(ar2[1]); }
133                }
134                loader.loadPlugins(pgi);
135                return true;
136        };
137
138
139        /** Send a call to javascript that the player is ready. **/
140        private function playerReady():void {
141                var dat = {id:config['id'],client:config['client'],version:config['version']};
142                try {
143                        ExternalInterface.call("playerReady",dat);
144                } catch (err:Error) {}
145        };
146
147
148        /** Send a redraw request when the stage is resized. **/
149        private function resizeHandler(evt:Event=undefined):void {
150                dispatchEvent(new ViewEvent(ViewEvent.REDRAW));
151        };
152
153
154        /**  Dispatch events. **/
155        override public function sendEvent(typ:String,prm:Object=undefined):void {
156                typ = typ.toUpperCase();
157                var dat = new Object();
158                switch(typ) {
159                        case 'TRACE':
160                                dat['message'] = prm;
161                                break;
162                        case 'LINK':
163                                if (prm != null) {
164                                        dat['index'] = prm;
165                                }
166                                break;
167                        case 'LOAD':
168                                dat['object'] = prm;
169                                break;
170                        case 'ITEM':
171                                if (prm > -1) {
172                                        dat['index'] = prm;
173                                }
174                                break;
175                        case 'SEEK':
176                                dat['position'] = prm;
177                                break;
178                        case 'VOLUME':
179                                dat['percentage'] = prm;
180                                break;
181                        default:
182                                if(prm!=null && prm != '') {
183                                        if(prm == true || prm == 'true') {
184                                                dat['state'] = true;
185                                        } else if(prm == false || prm == 'false') {
186                                                dat['state'] = false;
187                                        }
188                                }
189                                break;
190                }
191                dispatchEvent(new ViewEvent(typ,dat));
192        };
193
194
195        /** Forward events to tracer and subscribers. **/
196        private function setController(evt:ControllerEvent):void { forward('CONTROLLER',evt.type,evt.data); };
197        private function setModel(evt:ModelEvent):void { forward('MODEL',evt.type,evt.data); };
198        private function setView(evt:ViewEvent):void { forward('VIEW',evt.type,evt.data); };
199
200
201        /** Setup javascript API. **/
202        private function setJavascript() {
203                try {
204                        setTimeout(playerReady,50);
205                        if(ExternalInterface.objectID) {
206                                _config['id'] = ExternalInterface.objectID;
207                        }
208                        ExternalInterface.addCallback("getConfig",getConfig);
209                        ExternalInterface.addCallback("getPlaylist",getPlaylist);
210                        ExternalInterface.addCallback("addControllerListener",addJSControllerListener);
211                        ExternalInterface.addCallback("addModelListener",addJSModelListener);
212                        ExternalInterface.addCallback("addViewListener",addJSViewListener);
213                        ExternalInterface.addCallback("sendEvent",sendEvent);
214                        ExternalInterface.addCallback("loadPlugin",loadPlugin);
215                } catch (err:Error) {}
216        };
217
218
219        /** Setup listeners to all events for tracing / javascript. **/
220        private function setListening():void {
221                if(config['tracer'] == 'arthropod') { Debug.clear(); }
222                addControllerListener(ControllerEvent.ERROR,setController);
223                addControllerListener(ControllerEvent.ITEM,setController);
224                addControllerListener(ControllerEvent.MUTE,setController);
225                addControllerListener(ControllerEvent.PLAY,setController);
226                addControllerListener(ControllerEvent.PLAYLIST,setController);
227                addControllerListener(ControllerEvent.QUALITY,setController);
228                addControllerListener(ControllerEvent.RESIZE,setController);
229                addControllerListener(ControllerEvent.SEEK,setController);
230                addControllerListener(ControllerEvent.STOP,setController);
231                addControllerListener(ControllerEvent.VOLUME,setController);
232                addModelListener(ModelEvent.BUFFER,setModel);
233                addModelListener(ModelEvent.ERROR,setModel);
234                addModelListener(ModelEvent.LOADED,setModel);
235                addModelListener(ModelEvent.META,setModel);
236                addModelListener(ModelEvent.STATE,setModel);
237                addModelListener(ModelEvent.TIME,setModel);
238                addViewListener(ViewEvent.FULLSCREEN,setView);
239                addViewListener(ViewEvent.ITEM,setView);
240                addViewListener(ViewEvent.LINK,setView);
241                addViewListener(ViewEvent.LOAD,setView);
242                addViewListener(ViewEvent.MUTE,setView);
243                addViewListener(ViewEvent.NEXT,setView);
244                addViewListener(ViewEvent.PLAY,setView);
245                addViewListener(ViewEvent.PREV,setView);
246                addViewListener(ViewEvent.QUALITY,setView);
247                addViewListener(ViewEvent.REDRAW,setView);
248                addViewListener(ViewEvent.SEEK,setView);
249                addViewListener(ViewEvent.STOP,setView);
250                addViewListener(ViewEvent.TRACE,setView);
251                addViewListener(ViewEvent.VOLUME,setView);
252        };
253
254
255}
256
257
258}
Note: See TracBrowser for help on using the repository browser.