I’ll keep you posted on my progress, thanks for the fantastic information

I am trying to get data from a oracle database which can be done by executing a dwr.execute method from flex. for doing that, I am using External Interface API to call a javascript function and does this dwr.execute method. But , it doesn;t work.
can you help me in this.

Thanks for the help in advance,
stranger.

/**
* This class provides access to Dwr. It assumes
* that flex is being used in an Html container that
* has access to dwrWrapper.js.
* Each instance wraps a single Dwr controller.
*/
public class DwrWrap
private var functionMap:Array;
private var wrapUID:String;

public var controllerName:String;

/**
* Constructor for DwrWrap. Initializes function
* map and registers ExternalInterface callbacks
* @param controllerName The name of the
* JS/Dwr controller to use
*/
public function DwrWrap(controllerName:String){
this.controllerName = controllerName;
this.functionMap = new Array();
this.wrapUID = UIDUtil.getUID(this);

// register AS3 callbacks as name + UUID
ExternalInterface.addCallback(“handleJsCallback” +
this.wrapUID.replace(/-/gi, “”),
handleJsCallback);
ExternalInterface.addCallback(“handleJsError” +
this.wrapUID.replace(/-/gi, “”),
handleJsError);
}

/**
* Method that calls JS using ExternalInterface.
* @param jsMethodName JS/Dwr function to call
* @param jsArgs A single argument or an
* ArrayCollection of arguments to use in JS call
* @param callback An untyped object with callback
* and errorHandler properties
*/
public function serverCall(jsMethodName:String,
jsArgs:*, callback:Object = null):void{

var jsCallback:Object = new Object();

// map UUIDs to AS3 callback function references
var callbackUID:String =
UIDUtil.getUID(callback.callback);
jsCallback.callback = callbackUID;
functionMap[callbackUID] = callback.callback;

var errorUID:String =
UIDUtil.getUID(callback.errorHandler);
jsCallback.errorHandler = errorUID;
functionMap[errorUID] = callback.errorHandler;

// make sure jsArgs is an array – assumption in JS
if (jsArgs is ArrayCollection){
jsArgs = jsArgs.toArray();
}
else if (!(jsArgs is Array)){
var argArray:Array = new Array();
argArray.push(jsArgs);
jsArgs = argArray;
}
else if (jsArgs == null){
jsArgs = new Array();
}

ExternalInterface.call(“dwrCall”, this.wrapUID,
(controllerName + “.” + jsMethodName), jsArgs,
jsCallback);
}

/**
* This method receives the callback from JS and
* then calls the appropriate AS3 callback
* @param dwrResponse The response from Dwr
* @param asCallback UUID of AS3 function to call
*/
public function handleJsCallback(dwrResponse:*,
asCallback:String):void{

// use the UUID to look up the function reference
var callbackFunction:Function =
functionMap[asCallback];

if (callbackFunction != null){
delete functionMap[asCallback];
callbackFunction(dwrResponse);
}
}

/**
* This method receives errors from JS and
* then calls the appropriate AS3 errorHandler
* @param dwrResponse The error response from Dwr
* @param asErrorHandler UUID of the AS3 function
*/
public function handleJsError(dwrResponse:*,
asErrorHandler:String):void{

// use the UUID to look up the function reference
var errorFunction:Function =
functionMap[asErrorHandler];

if (errorFunction != null){
delete functionMap[asErrorHandler];
errorFunction(dwrResponse);
}
}
}
}

There would probably be some serialization/de-serialization effort for parameters and such, before doing this hacked-bridge approach I started writing basically a DWREngine.as to serve as a more complete Actionscript alternative but ran into enough issues that I didn’t feel up to the effort.