         return invoke(message);
     }
 
+    /**
+     * @inheritDoc
+     */
+    override public function cancel(id:String = null):AsyncToken
+    {
+        if (showBusyCursor)
+        {
+            CursorManager.removeBusyCursor();
+        }
+        return super.cancel(id);
+    }
+
+    override mx_internal function setService(ro:AbstractService):void
+    {
+        super.setService(ro);
+        remoteObject = mx.rpc.remoting.RemoteObject(ro);
+    }
+
+    override mx_internal function invoke(message:IMessage, token:AsyncToken = null):AsyncToken
+    {
+        if (showBusyCursor)
+        {
+            CursorManager.setBusyCursor();
+        }
+
+        return super.invoke(message, token);
+    }
+
+    /*
+     * Kill the busy cursor, find the matching call object and pass it back
+     */
+    override mx_internal function preHandle(event:MessageEvent):AsyncToken
+    {
+        if (showBusyCursor)
+        {
+            CursorManager.removeBusyCursor();
+        }
+
+        var wasLastCall:Boolean = activeCalls.wasLastCall(AsyncMessage(event.message).correlationId);
+        var token:AsyncToken = super.preHandle(event);
+
+        if (Concurrency.LAST == concurrency && !wasLastCall)
+        {
+            return null;
+        }
+        //else
+        return token;
+    }
+
+
+    //--------------------------------------------------------------------------
+    //
+    // Variables
+    // 
+    //--------------------------------------------------------------------------
+
+    /**
+     *  @private
+     */
+    private var resourceManager:IResourceManager = ResourceManager.getInstance();
+
+    mx_internal var remoteObject:mx.rpc.remoting.RemoteObject;
 }
+    
 
 }

{

import mx.core.mx_internal;
import mx.messaging.messages.RemotingMessage;
import mx.rpc.AbstractOperation;
import mx.rpc.AbstractService;
import mx.rpc.AsyncToken;
import mx.utils.ObjectUtil;

use namespace mx_internal;


        if (operationManager != null)
            return operationManager(args);

        if (Concurrency.SINGLE == concurrency && activeCalls.hasActiveCalls())
        {
            var token:AsyncToken = new AsyncToken(null);
            var m:String = resourceManager.getString(
                "rpc", "pendingCallExists");
            var fault:Fault = new Fault("ConcurrencyError", m);
            var faultEvent:FaultEvent = FaultEvent.createEvent(fault, token);
            new AsyncDispatcher(dispatchRpcEvent, [faultEvent], 10);
            return token;
        }

        // We delay endpoint initialization until now because MXML codegen may set 
        // the destination attribute after the endpoint and will clear out the 
        // channelSet.
        if (asyncRequest.channelSet == null && remoteObject.endpoint != null)
        {
            remoteObject.mx_internal::initEndpoint();
        }

        if (!args || (args.length == 0 && this.arguments))
        {
