home *** CD-ROM | disk | FTP | other *** search
/ Computer Active 2010 August / CA08.iso / Multimedija / shufflr.air / ShufflrClient.swf / scripts / mx / rpc / AbstractInvoker.as next >
Encoding:
Text File  |  2010-06-23  |  7.8 KB  |  242 lines
  1. package mx.rpc
  2. {
  3.    import flash.events.Event;
  4.    import flash.events.EventDispatcher;
  5.    import flash.utils.getQualifiedClassName;
  6.    import mx.core.mx_internal;
  7.    import mx.logging.ILogger;
  8.    import mx.logging.Log;
  9.    import mx.messaging.errors.MessagingError;
  10.    import mx.messaging.events.MessageEvent;
  11.    import mx.messaging.events.MessageFaultEvent;
  12.    import mx.messaging.messages.AsyncMessage;
  13.    import mx.messaging.messages.IMessage;
  14.    import mx.netmon.NetworkMonitor;
  15.    import mx.resources.IResourceManager;
  16.    import mx.resources.ResourceManager;
  17.    import mx.rpc.events.AbstractEvent;
  18.    import mx.rpc.events.FaultEvent;
  19.    import mx.rpc.events.InvokeEvent;
  20.    import mx.rpc.events.ResultEvent;
  21.    import mx.utils.ObjectProxy;
  22.    
  23.    use namespace mx_internal;
  24.    
  25.    public class AbstractInvoker extends EventDispatcher
  26.    {
  27.       mx_internal static const BINDING_RESULT:String = "resultForBinding";
  28.       
  29.       mx_internal var _makeObjectsBindable:Boolean;
  30.       
  31.       public var operationManager:Function;
  32.       
  33.       mx_internal var _responseHeaders:Array;
  34.       
  35.       private var _asyncRequest:AsyncRequest;
  36.       
  37.       private var _log:ILogger;
  38.       
  39.       mx_internal var activeCalls:ActiveCalls;
  40.       
  41.       public var resultType:Class;
  42.       
  43.       public var resultElementType:Class;
  44.       
  45.       mx_internal var _result:Object;
  46.       
  47.       private var resourceManager:IResourceManager = ResourceManager.getInstance();
  48.       
  49.       public function AbstractInvoker()
  50.       {
  51.          super();
  52.          _log = Log.getLogger("mx.rpc.AbstractInvoker");
  53.          mx_internal::activeCalls = new ActiveCalls();
  54.       }
  55.       
  56.       mx_internal function getNetmonId() : String
  57.       {
  58.          return null;
  59.       }
  60.       
  61.       public function cancel(param1:String = null) : AsyncToken
  62.       {
  63.          if(param1 != null)
  64.          {
  65.             return mx_internal::activeCalls.removeCall(param1);
  66.          }
  67.          return mx_internal::activeCalls.cancelLast();
  68.       }
  69.       
  70.       mx_internal function faultHandler(param1:MessageFaultEvent) : void
  71.       {
  72.          var _loc4_:Fault = null;
  73.          var _loc5_:FaultEvent = null;
  74.          var _loc2_:MessageEvent = MessageEvent.createEvent(MessageEvent.MESSAGE,param1.message);
  75.          var _loc3_:AsyncToken = mx_internal::preHandle(_loc2_);
  76.          if(_loc3_ == null && AsyncMessage(param1.message).correlationId != null && AsyncMessage(param1.message).correlationId != "" && param1.faultCode != "Client.Authentication")
  77.          {
  78.             return;
  79.          }
  80.          if(mx_internal::processFault(param1.message,_loc3_))
  81.          {
  82.             _loc4_ = new Fault(param1.faultCode,param1.faultString,param1.faultDetail);
  83.             _loc4_.content = param1.message.body;
  84.             _loc4_.rootCause = param1.rootCause;
  85.             _loc5_ = FaultEvent.createEvent(_loc4_,_loc3_,param1.message);
  86.             _loc5_.headers = mx_internal::_responseHeaders;
  87.             mx_internal::dispatchRpcEvent(_loc5_);
  88.          }
  89.       }
  90.       
  91.       public function clearResult(param1:Boolean = true) : void
  92.       {
  93.          if(param1)
  94.          {
  95.             setResult(null);
  96.          }
  97.          else
  98.          {
  99.             mx_internal::_result = null;
  100.          }
  101.       }
  102.       
  103.       mx_internal function get asyncRequest() : AsyncRequest
  104.       {
  105.          if(_asyncRequest == null)
  106.          {
  107.             _asyncRequest = new AsyncRequest();
  108.          }
  109.          return _asyncRequest;
  110.       }
  111.       
  112.       mx_internal function dispatchRpcEvent(param1:AbstractEvent) : void
  113.       {
  114.          param1.mx_internal::callTokenResponders();
  115.          if(!param1.isDefaultPrevented())
  116.          {
  117.             dispatchEvent(param1);
  118.          }
  119.       }
  120.       
  121.       [Bindable("resultForBinding")]
  122.       public function get lastResult() : Object
  123.       {
  124.          return mx_internal::_result;
  125.       }
  126.       
  127.       public function setResult(param1:Object) : void
  128.       {
  129.          mx_internal::_result = param1;
  130.          dispatchEvent(new Event(mx_internal::BINDING_RESULT));
  131.       }
  132.       
  133.       mx_internal function set asyncRequest(param1:AsyncRequest) : void
  134.       {
  135.          _asyncRequest = param1;
  136.       }
  137.       
  138.       mx_internal function preHandle(param1:MessageEvent) : AsyncToken
  139.       {
  140.          return mx_internal::activeCalls.removeCall(AsyncMessage(param1.message).correlationId);
  141.       }
  142.       
  143.       mx_internal function processResult(param1:IMessage, param2:AsyncToken) : Boolean
  144.       {
  145.          var _loc3_:Object = param1.body;
  146.          if(makeObjectsBindable && _loc3_ != null && getQualifiedClassName(_loc3_) == "Object")
  147.          {
  148.             mx_internal::_result = new ObjectProxy(_loc3_);
  149.          }
  150.          else
  151.          {
  152.             mx_internal::_result = _loc3_;
  153.          }
  154.          return true;
  155.       }
  156.       
  157.       mx_internal function resultHandler(param1:MessageEvent) : void
  158.       {
  159.          var _loc3_:ResultEvent = null;
  160.          var _loc2_:AsyncToken = mx_internal::preHandle(param1);
  161.          if(_loc2_ == null)
  162.          {
  163.             return;
  164.          }
  165.          if(mx_internal::processResult(param1.message,_loc2_))
  166.          {
  167.             dispatchEvent(new Event(mx_internal::BINDING_RESULT));
  168.             _loc3_ = ResultEvent.createEvent(mx_internal::_result,_loc2_,param1.message);
  169.             _loc3_.headers = mx_internal::_responseHeaders;
  170.             mx_internal::dispatchRpcEvent(_loc3_);
  171.          }
  172.       }
  173.       
  174.       mx_internal function monitorRpcEvent(param1:AbstractEvent) : void
  175.       {
  176.          if(NetworkMonitor.isMonitoring())
  177.          {
  178.             if(param1 is ResultEvent)
  179.             {
  180.                NetworkMonitor.monitorResult(param1.message,ResultEvent(param1).result);
  181.             }
  182.             else if(param1 is FaultEvent)
  183.             {
  184.                NetworkMonitor.monitorFault(param1.message,FaultEvent(param1).fault);
  185.             }
  186.          }
  187.       }
  188.       
  189.       mx_internal function processFault(param1:IMessage, param2:AsyncToken) : Boolean
  190.       {
  191.          return true;
  192.       }
  193.       
  194.       mx_internal function invoke(param1:IMessage, param2:AsyncToken = null) : AsyncToken
  195.       {
  196.          var fault:Fault = null;
  197.          var errorText:String = null;
  198.          var message:IMessage = param1;
  199.          var token:AsyncToken = param2;
  200.          if(token == null)
  201.          {
  202.             token = new AsyncToken(message);
  203.          }
  204.          else
  205.          {
  206.             token.mx_internal::setMessage(message);
  207.          }
  208.          mx_internal::activeCalls.addCall(message.messageId,token);
  209.          try
  210.          {
  211.             mx_internal::asyncRequest.invoke(message,new Responder(mx_internal::resultHandler,mx_internal::faultHandler));
  212.             mx_internal::dispatchRpcEvent(InvokeEvent.createEvent(token,message));
  213.          }
  214.          catch(e:MessagingError)
  215.          {
  216.             _log.warn(e.toString());
  217.             errorText = resourceManager.getString("rpc","cannotConnectToDestination",[mx_internal::asyncRequest.destination]);
  218.             fault = new Fault("InvokeFailed",e.toString(),errorText);
  219.             new AsyncDispatcher(mx_internal::dispatchRpcEvent,[FaultEvent.createEvent(fault,token,message)],10);
  220.          }
  221.          catch(e2:Error)
  222.          {
  223.             _log.warn(e2.toString());
  224.             fault = new Fault("InvokeFailed",e2.message);
  225.             new AsyncDispatcher(mx_internal::dispatchRpcEvent,[FaultEvent.createEvent(fault,token,message)],10);
  226.          }
  227.          return token;
  228.       }
  229.       
  230.       public function set makeObjectsBindable(param1:Boolean) : void
  231.       {
  232.          mx_internal::_makeObjectsBindable = param1;
  233.       }
  234.       
  235.       public function get makeObjectsBindable() : Boolean
  236.       {
  237.          return mx_internal::_makeObjectsBindable;
  238.       }
  239.    }
  240. }
  241.  
  242.