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