home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2009 March / PCWMAR09.iso / Software / Freeware / Adobe Media Player 1.6 / adobe_media_player.air / AMP.swf / scripts / mx / modules / ModuleManager.as < prev    next >
Encoding:
Text File  |  2008-11-25  |  15.5 KB  |  582 lines
  1. package mx.modules
  2. {
  3.    import mx.core.IFlexModuleFactory;
  4.    import mx.core.mx_internal;
  5.    
  6.    use namespace mx_internal;
  7.    
  8.    public class ModuleManager
  9.    {
  10.       mx_internal static const VERSION:String = "3.2.0.3958";
  11.       
  12.       public function ModuleManager()
  13.       {
  14.          super();
  15.       }
  16.       
  17.       public static function getModule(param1:String) : IModuleInfo
  18.       {
  19.          return getSingleton().getModule(param1);
  20.       }
  21.       
  22.       private static function getSingleton() : Object
  23.       {
  24.          if(!ModuleManagerGlobals.managerSingleton)
  25.          {
  26.             ModuleManagerGlobals.managerSingleton = new ModuleManagerImpl();
  27.          }
  28.          return ModuleManagerGlobals.managerSingleton;
  29.       }
  30.       
  31.       public static function getAssociatedFactory(param1:Object) : IFlexModuleFactory
  32.       {
  33.          return getSingleton().getAssociatedFactory(param1);
  34.       }
  35.    }
  36. }
  37.  
  38. import flash.display.Loader;
  39. import flash.events.ErrorEvent;
  40. import flash.events.Event;
  41. import flash.events.EventDispatcher;
  42. import flash.events.IOErrorEvent;
  43. import flash.events.ProgressEvent;
  44. import flash.events.SecurityErrorEvent;
  45. import flash.net.URLRequest;
  46. import flash.system.ApplicationDomain;
  47. import flash.system.LoaderContext;
  48. import flash.system.Security;
  49. import flash.system.SecurityDomain;
  50. import flash.utils.ByteArray;
  51. import flash.utils.Dictionary;
  52. import flash.utils.getQualifiedClassName;
  53. import mx.core.IFlexModuleFactory;
  54. import mx.events.ModuleEvent;
  55.  
  56. class ModuleInfoProxy extends EventDispatcher implements IModuleInfo
  57. {
  58.    private var _data:Object;
  59.    
  60.    private var info:ModuleInfo;
  61.    
  62.    private var referenced:Boolean = false;
  63.    
  64.    public function ModuleInfoProxy(param1:ModuleInfo)
  65.    {
  66.       super();
  67.       this.info = param1;
  68.       param1.addEventListener(ModuleEvent.SETUP,moduleEventHandler,false,0,true);
  69.       param1.addEventListener(ModuleEvent.PROGRESS,moduleEventHandler,false,0,true);
  70.       param1.addEventListener(ModuleEvent.READY,moduleEventHandler,false,0,true);
  71.       param1.addEventListener(ModuleEvent.ERROR,moduleEventHandler,false,0,true);
  72.       param1.addEventListener(ModuleEvent.UNLOAD,moduleEventHandler,false,0,true);
  73.    }
  74.    
  75.    public function get loaded() : Boolean
  76.    {
  77.       return info.loaded;
  78.    }
  79.    
  80.    public function release() : void
  81.    {
  82.       if(referenced)
  83.       {
  84.          info.removeReference();
  85.          referenced = false;
  86.       }
  87.    }
  88.    
  89.    public function get error() : Boolean
  90.    {
  91.       return info.error;
  92.    }
  93.    
  94.    public function get factory() : IFlexModuleFactory
  95.    {
  96.       return info.factory;
  97.    }
  98.    
  99.    public function publish(param1:IFlexModuleFactory) : void
  100.    {
  101.       info.publish(param1);
  102.    }
  103.    
  104.    public function set data(param1:Object) : void
  105.    {
  106.       _data = param1;
  107.    }
  108.    
  109.    public function get ready() : Boolean
  110.    {
  111.       return info.ready;
  112.    }
  113.    
  114.    public function load(param1:ApplicationDomain = null, param2:SecurityDomain = null, param3:ByteArray = null) : void
  115.    {
  116.       var _loc4_:ModuleEvent = null;
  117.       info.resurrect();
  118.       if(!referenced)
  119.       {
  120.          info.addReference();
  121.          referenced = true;
  122.       }
  123.       if(info.error)
  124.       {
  125.          dispatchEvent(new ModuleEvent(ModuleEvent.ERROR));
  126.       }
  127.       else if(info.loaded)
  128.       {
  129.          if(info.setup)
  130.          {
  131.             dispatchEvent(new ModuleEvent(ModuleEvent.SETUP));
  132.             if(info.ready)
  133.             {
  134.                _loc4_ = new ModuleEvent(ModuleEvent.PROGRESS);
  135.                _loc4_.bytesLoaded = info.size;
  136.                _loc4_.bytesTotal = info.size;
  137.                dispatchEvent(_loc4_);
  138.                dispatchEvent(new ModuleEvent(ModuleEvent.READY));
  139.             }
  140.          }
  141.       }
  142.       else
  143.       {
  144.          info.load(param1,param2,param3);
  145.       }
  146.    }
  147.    
  148.    private function moduleEventHandler(param1:ModuleEvent) : void
  149.    {
  150.       dispatchEvent(param1);
  151.    }
  152.    
  153.    public function get url() : String
  154.    {
  155.       return info.url;
  156.    }
  157.    
  158.    public function get data() : Object
  159.    {
  160.       return _data;
  161.    }
  162.    
  163.    public function get setup() : Boolean
  164.    {
  165.       return info.setup;
  166.    }
  167.    
  168.    public function unload() : void
  169.    {
  170.       info.unload();
  171.       info.removeEventListener(ModuleEvent.SETUP,moduleEventHandler);
  172.       info.removeEventListener(ModuleEvent.PROGRESS,moduleEventHandler);
  173.       info.removeEventListener(ModuleEvent.READY,moduleEventHandler);
  174.       info.removeEventListener(ModuleEvent.ERROR,moduleEventHandler);
  175.       info.removeEventListener(ModuleEvent.UNLOAD,moduleEventHandler);
  176.    }
  177. }
  178.  
  179. class ModuleManagerImpl extends EventDispatcher
  180. {
  181.    private var moduleList:Object;
  182.    
  183.    public function ModuleManagerImpl()
  184.    {
  185.       moduleList = {};
  186.       super();
  187.    }
  188.    
  189.    public function getModule(param1:String) : IModuleInfo
  190.    {
  191.       var _loc2_:ModuleInfo = moduleList[param1] as ModuleInfo;
  192.       if(!_loc2_)
  193.       {
  194.          _loc2_ = new ModuleInfo(param1);
  195.          moduleList[param1] = _loc2_;
  196.       }
  197.       return new ModuleInfoProxy(_loc2_);
  198.    }
  199.    
  200.    public function getAssociatedFactory(param1:Object) : IFlexModuleFactory
  201.    {
  202.       var m:Object = null;
  203.       var info:ModuleInfo = null;
  204.       var domain:ApplicationDomain = null;
  205.       var cls:Class = null;
  206.       var object:Object = param1;
  207.       var className:String = getQualifiedClassName(object);
  208.       for each(m in moduleList)
  209.       {
  210.          info = m as ModuleInfo;
  211.          if(info.ready)
  212.          {
  213.             domain = info.applicationDomain;
  214.             try
  215.             {
  216.                cls = Class(domain.getDefinition(className));
  217.                if(object is cls)
  218.                {
  219.                   return info.factory;
  220.                }
  221.             }
  222.             catch(error:Error)
  223.             {
  224.                continue;
  225.             }
  226.          }
  227.       }
  228.       return null;
  229.    }
  230. }
  231.  
  232. class ModuleInfo extends EventDispatcher
  233. {
  234.    private var _error:Boolean = false;
  235.    
  236.    private var loader:Loader;
  237.    
  238.    private var factoryInfo:FactoryInfo;
  239.    
  240.    private var limbo:Dictionary;
  241.    
  242.    private var _loaded:Boolean = false;
  243.    
  244.    private var _ready:Boolean = false;
  245.    
  246.    private var numReferences:int = 0;
  247.    
  248.    private var _url:String;
  249.    
  250.    private var _setup:Boolean = false;
  251.    
  252.    public function ModuleInfo(param1:String)
  253.    {
  254.       super();
  255.       _url = param1;
  256.    }
  257.    
  258.    private function clearLoader() : void
  259.    {
  260.       if(loader)
  261.       {
  262.          if(loader.contentLoaderInfo)
  263.          {
  264.             loader.contentLoaderInfo.removeEventListener(Event.INIT,initHandler);
  265.             loader.contentLoaderInfo.removeEventListener(Event.COMPLETE,completeHandler);
  266.             loader.contentLoaderInfo.removeEventListener(ProgressEvent.PROGRESS,progressHandler);
  267.             loader.contentLoaderInfo.removeEventListener(IOErrorEvent.IO_ERROR,errorHandler);
  268.             loader.contentLoaderInfo.removeEventListener(SecurityErrorEvent.SECURITY_ERROR,errorHandler);
  269.          }
  270.          try
  271.          {
  272.             if(loader.content)
  273.             {
  274.                loader.content.removeEventListener("ready",readyHandler);
  275.                loader.content.removeEventListener("error",moduleErrorHandler);
  276.             }
  277.          }
  278.          catch(error:Error)
  279.          {
  280.          }
  281.          if(_loaded)
  282.          {
  283.             try
  284.             {
  285.                loader.close();
  286.             }
  287.             catch(error:Error)
  288.             {
  289.             }
  290.          }
  291.          try
  292.          {
  293.             loader.unload();
  294.          }
  295.          catch(error:Error)
  296.          {
  297.          }
  298.          loader = null;
  299.       }
  300.    }
  301.    
  302.    public function get size() : int
  303.    {
  304.       return !limbo && Boolean(factoryInfo) ? int(factoryInfo.bytesTotal) : 0;
  305.    }
  306.    
  307.    public function get loaded() : Boolean
  308.    {
  309.       return !limbo ? Boolean(_loaded) : false;
  310.    }
  311.    
  312.    public function release() : void
  313.    {
  314.       if(Boolean(_ready) && !limbo)
  315.       {
  316.          limbo = new Dictionary(true);
  317.          limbo[factoryInfo] = 1;
  318.          factoryInfo = null;
  319.       }
  320.       else
  321.       {
  322.          unload();
  323.       }
  324.    }
  325.    
  326.    public function get error() : Boolean
  327.    {
  328.       return !limbo ? Boolean(_error) : false;
  329.    }
  330.    
  331.    public function get factory() : IFlexModuleFactory
  332.    {
  333.       return !limbo && Boolean(factoryInfo) ? factoryInfo.factory : null;
  334.    }
  335.    
  336.    public function completeHandler(param1:Event) : void
  337.    {
  338.       var _loc2_:ModuleEvent = new ModuleEvent(ModuleEvent.PROGRESS,param1.bubbles,param1.cancelable);
  339.       _loc2_.bytesLoaded = loader.contentLoaderInfo.bytesLoaded;
  340.       _loc2_.bytesTotal = loader.contentLoaderInfo.bytesTotal;
  341.       dispatchEvent(_loc2_);
  342.    }
  343.    
  344.    public function publish(param1:IFlexModuleFactory) : void
  345.    {
  346.       if(factoryInfo)
  347.       {
  348.          return;
  349.       }
  350.       if(_url.indexOf("published://") != 0)
  351.       {
  352.          return;
  353.       }
  354.       factoryInfo = new FactoryInfo();
  355.       factoryInfo.factory = param1;
  356.       _loaded = true;
  357.       _setup = true;
  358.       _ready = true;
  359.       _error = false;
  360.       dispatchEvent(new ModuleEvent(ModuleEvent.SETUP));
  361.       dispatchEvent(new ModuleEvent(ModuleEvent.PROGRESS));
  362.       dispatchEvent(new ModuleEvent(ModuleEvent.READY));
  363.    }
  364.    
  365.    public function initHandler(param1:Event) : void
  366.    {
  367.       var moduleEvent:ModuleEvent = null;
  368.       var event:Event = param1;
  369.       factoryInfo = new FactoryInfo();
  370.       try
  371.       {
  372.          factoryInfo.factory = loader.content as IFlexModuleFactory;
  373.       }
  374.       catch(error:Error)
  375.       {
  376.       }
  377.       if(!factoryInfo.factory)
  378.       {
  379.          moduleEvent = new ModuleEvent(ModuleEvent.ERROR,event.bubbles,event.cancelable);
  380.          moduleEvent.bytesLoaded = 0;
  381.          moduleEvent.bytesTotal = 0;
  382.          moduleEvent.errorText = "SWF is not a loadable module";
  383.          dispatchEvent(moduleEvent);
  384.          return;
  385.       }
  386.       loader.content.addEventListener("ready",readyHandler);
  387.       loader.content.addEventListener("error",moduleErrorHandler);
  388.       try
  389.       {
  390.          factoryInfo.applicationDomain = loader.contentLoaderInfo.applicationDomain;
  391.       }
  392.       catch(error:Error)
  393.       {
  394.       }
  395.       _setup = true;
  396.       dispatchEvent(new ModuleEvent(ModuleEvent.SETUP));
  397.    }
  398.    
  399.    public function resurrect() : void
  400.    {
  401.       var _loc1_:Object = null;
  402.       if(!factoryInfo && Boolean(limbo))
  403.       {
  404.          var _loc2_:int = 0;
  405.          var _loc3_:* = limbo;
  406.          for(_loc1_ in _loc3_)
  407.          {
  408.             factoryInfo = _loc1_ as FactoryInfo;
  409.          }
  410.          limbo = null;
  411.       }
  412.       if(!factoryInfo)
  413.       {
  414.          if(_loaded)
  415.          {
  416.             dispatchEvent(new ModuleEvent(ModuleEvent.UNLOAD));
  417.          }
  418.          loader = null;
  419.          _loaded = false;
  420.          _setup = false;
  421.          _ready = false;
  422.          _error = false;
  423.       }
  424.    }
  425.    
  426.    public function errorHandler(param1:ErrorEvent) : void
  427.    {
  428.       _error = true;
  429.       var _loc2_:ModuleEvent = new ModuleEvent(ModuleEvent.ERROR,param1.bubbles,param1.cancelable);
  430.       _loc2_.bytesLoaded = 0;
  431.       _loc2_.bytesTotal = 0;
  432.       _loc2_.errorText = param1.text;
  433.       dispatchEvent(_loc2_);
  434.    }
  435.    
  436.    public function get ready() : Boolean
  437.    {
  438.       return !limbo ? Boolean(_ready) : false;
  439.    }
  440.    
  441.    private function loadBytes(param1:ApplicationDomain, param2:ByteArray) : void
  442.    {
  443.       var _loc3_:LoaderContext = new LoaderContext();
  444.       _loc3_.applicationDomain = !!param1 ? param1 : new ApplicationDomain(ApplicationDomain.currentDomain);
  445.       if("allowLoadBytesCodeExecution" in _loc3_)
  446.       {
  447.          _loc3_["allowLoadBytesCodeExecution"] = true;
  448.       }
  449.       loader = new Loader();
  450.       loader.contentLoaderInfo.addEventListener(Event.INIT,initHandler);
  451.       loader.contentLoaderInfo.addEventListener(Event.COMPLETE,completeHandler);
  452.       loader.contentLoaderInfo.addEventListener(IOErrorEvent.IO_ERROR,errorHandler);
  453.       loader.contentLoaderInfo.addEventListener(SecurityErrorEvent.SECURITY_ERROR,errorHandler);
  454.       loader.loadBytes(param2,_loc3_);
  455.    }
  456.    
  457.    public function removeReference() : void
  458.    {
  459.       --numReferences;
  460.       if(numReferences == 0)
  461.       {
  462.          release();
  463.       }
  464.    }
  465.    
  466.    public function addReference() : void
  467.    {
  468.       ++numReferences;
  469.    }
  470.    
  471.    public function progressHandler(param1:ProgressEvent) : void
  472.    {
  473.       var _loc2_:ModuleEvent = new ModuleEvent(ModuleEvent.PROGRESS,param1.bubbles,param1.cancelable);
  474.       _loc2_.bytesLoaded = param1.bytesLoaded;
  475.       _loc2_.bytesTotal = param1.bytesTotal;
  476.       dispatchEvent(_loc2_);
  477.    }
  478.    
  479.    public function load(param1:ApplicationDomain = null, param2:SecurityDomain = null, param3:ByteArray = null) : void
  480.    {
  481.       if(_loaded)
  482.       {
  483.          return;
  484.       }
  485.       _loaded = true;
  486.       limbo = null;
  487.       if(param3)
  488.       {
  489.          loadBytes(param1,param3);
  490.          return;
  491.       }
  492.       if(_url.indexOf("published://") == 0)
  493.       {
  494.          return;
  495.       }
  496.       var _loc4_:URLRequest = new URLRequest(_url);
  497.       var _loc5_:LoaderContext = new LoaderContext();
  498.       _loc5_.applicationDomain = !!param1 ? param1 : new ApplicationDomain(ApplicationDomain.currentDomain);
  499.       _loc5_.securityDomain = param2;
  500.       if(param2 == null && Security.sandboxType == Security.REMOTE)
  501.       {
  502.          _loc5_.securityDomain = SecurityDomain.currentDomain;
  503.       }
  504.       loader = new Loader();
  505.       loader.contentLoaderInfo.addEventListener(Event.INIT,initHandler);
  506.       loader.contentLoaderInfo.addEventListener(Event.COMPLETE,completeHandler);
  507.       loader.contentLoaderInfo.addEventListener(ProgressEvent.PROGRESS,progressHandler);
  508.       loader.contentLoaderInfo.addEventListener(IOErrorEvent.IO_ERROR,errorHandler);
  509.       loader.contentLoaderInfo.addEventListener(SecurityErrorEvent.SECURITY_ERROR,errorHandler);
  510.       loader.load(_loc4_,_loc5_);
  511.    }
  512.    
  513.    public function get url() : String
  514.    {
  515.       return _url;
  516.    }
  517.    
  518.    public function get applicationDomain() : ApplicationDomain
  519.    {
  520.       return !limbo && Boolean(factoryInfo) ? factoryInfo.applicationDomain : null;
  521.    }
  522.    
  523.    public function moduleErrorHandler(param1:Event) : void
  524.    {
  525.       var _loc2_:ModuleEvent = null;
  526.       _ready = true;
  527.       factoryInfo.bytesTotal = loader.contentLoaderInfo.bytesTotal;
  528.       clearLoader();
  529.       if(param1 is ModuleEvent)
  530.       {
  531.          _loc2_ = ModuleEvent(param1);
  532.       }
  533.       else
  534.       {
  535.          _loc2_ = new ModuleEvent(ModuleEvent.ERROR);
  536.       }
  537.       dispatchEvent(_loc2_);
  538.    }
  539.    
  540.    public function readyHandler(param1:Event) : void
  541.    {
  542.       _ready = true;
  543.       factoryInfo.bytesTotal = loader.contentLoaderInfo.bytesTotal;
  544.       clearLoader();
  545.       dispatchEvent(new ModuleEvent(ModuleEvent.READY));
  546.    }
  547.    
  548.    public function get setup() : Boolean
  549.    {
  550.       return !limbo ? Boolean(_setup) : false;
  551.    }
  552.    
  553.    public function unload() : void
  554.    {
  555.       clearLoader();
  556.       if(_loaded)
  557.       {
  558.          dispatchEvent(new ModuleEvent(ModuleEvent.UNLOAD));
  559.       }
  560.       limbo = null;
  561.       factoryInfo = null;
  562.       _loaded = false;
  563.       _setup = false;
  564.       _ready = false;
  565.       _error = false;
  566.    }
  567. }
  568.  
  569. class FactoryInfo
  570. {
  571.    public var bytesTotal:int = 0;
  572.    
  573.    public var factory:IFlexModuleFactory;
  574.    
  575.    public var applicationDomain:ApplicationDomain;
  576.    
  577.    public function FactoryInfo()
  578.    {
  579.       super();
  580.    }
  581. }
  582.