New file |
0,0 → 1,224 |
/** |
A wrapper around Flash 8's ExternalInterface; DojoExternalInterface is needed so that we |
can do a Flash 6 implementation of ExternalInterface, and be able |
to support having a single codebase that uses DojoExternalInterface |
across Flash versions rather than having two seperate source bases, |
where one uses ExternalInterface and the other uses DojoExternalInterface. |
|
DojoExternalInterface class does a variety of optimizations to bypass ExternalInterface's |
unbelievably bad performance so that we can have good performance |
on Safari; see the blog post |
http://codinginparadise.org/weblog/2006/02/how-to-speed-up-flash-8s.html |
for details. |
|
@author Brad Neuberg, bkn3@columbia.edu |
*/ |
import flash.external.ExternalInterface; |
|
class DojoExternalInterface{ |
public static var available:Boolean; |
public static var dojoPath = ""; |
|
private static var flashMethods:Array = new Array(); |
private static var numArgs:Number; |
private static var argData:Array; |
private static var resultData = null; |
|
public static function initialize(){ |
// extract the dojo base path |
DojoExternalInterface.dojoPath = DojoExternalInterface.getDojoPath(); |
|
// see if we need to do an express install |
var install:ExpressInstall = new ExpressInstall(); |
if(install.needsUpdate){ |
install.init(); |
} |
|
// register our callback functions |
ExternalInterface.addCallback("startExec", DojoExternalInterface, startExec); |
ExternalInterface.addCallback("setNumberArguments", DojoExternalInterface, |
setNumberArguments); |
ExternalInterface.addCallback("chunkArgumentData", DojoExternalInterface, |
chunkArgumentData); |
ExternalInterface.addCallback("exec", DojoExternalInterface, exec); |
ExternalInterface.addCallback("getReturnLength", DojoExternalInterface, |
getReturnLength); |
ExternalInterface.addCallback("chunkReturnData", DojoExternalInterface, |
chunkReturnData); |
ExternalInterface.addCallback("endExec", DojoExternalInterface, endExec); |
|
// set whether communication is available |
DojoExternalInterface.available = ExternalInterface.available; |
DojoExternalInterface.call("loaded"); |
} |
|
public static function addCallback(methodName:String, instance:Object, |
method:Function) : Boolean{ |
// register DojoExternalInterface methodName with it's instance |
DojoExternalInterface.flashMethods[methodName] = instance; |
|
// tell JavaScript about DojoExternalInterface new method so we can create a proxy |
ExternalInterface.call("dojox.flash.comm._addExternalInterfaceCallback", |
methodName); |
|
return true; |
} |
|
public static function call(methodName:String, |
resultsCallback:Function) : Void{ |
// we might have any number of optional arguments, so we have to |
// pass them in dynamically; strip out the results callback |
var parameters = new Array(); |
for(var i = 0; i < arguments.length; i++){ |
if(i != 1){ // skip the callback |
parameters.push(arguments[i]); |
} |
} |
|
var results = ExternalInterface.call.apply(ExternalInterface, parameters); |
|
// immediately give the results back, since ExternalInterface is |
// synchronous |
if(resultsCallback != null && typeof resultsCallback != "undefined"){ |
resultsCallback.call(null, results); |
} |
} |
|
/** |
Called by Flash to indicate to JavaScript that we are ready to have |
our Flash functions called. Calling loaded() |
will fire the dojox.flash.loaded() event, so that JavaScript can know that |
Flash has finished loading and adding its callbacks, and can begin to |
interact with the Flash file. |
*/ |
public static function loaded(){ |
DojoExternalInterface.call("dojox.flash.loaded"); |
} |
|
public static function startExec():Void{ |
DojoExternalInterface.numArgs = null; |
DojoExternalInterface.argData = null; |
DojoExternalInterface.resultData = null; |
} |
|
public static function setNumberArguments(numArgs):Void{ |
DojoExternalInterface.numArgs = numArgs; |
DojoExternalInterface.argData = new Array(DojoExternalInterface.numArgs); |
} |
|
public static function chunkArgumentData(value, argIndex:Number):Void{ |
//getURL("javascript:console.debug('FLASH: chunkArgumentData, value="+value+", argIndex="+argIndex+"')"); |
var currentValue = DojoExternalInterface.argData[argIndex]; |
if(currentValue == null || typeof currentValue == "undefined"){ |
DojoExternalInterface.argData[argIndex] = value; |
}else{ |
DojoExternalInterface.argData[argIndex] += value; |
} |
} |
|
public static function exec(methodName):Void{ |
// decode all of the arguments that were passed in |
for(var i = 0; i < DojoExternalInterface.argData.length; i++){ |
DojoExternalInterface.argData[i] = |
DojoExternalInterface.decodeData(DojoExternalInterface.argData[i]); |
} |
|
var instance = DojoExternalInterface.flashMethods[methodName]; |
DojoExternalInterface.resultData = instance[methodName].apply( |
instance, DojoExternalInterface.argData); |
// encode the result data |
DojoExternalInterface.resultData = |
DojoExternalInterface.encodeData(DojoExternalInterface.resultData); |
|
//getURL("javascript:console.debug('FLASH: encoded result data="+DojoExternalInterface.resultData+"')"); |
} |
|
public static function getReturnLength():Number{ |
if(DojoExternalInterface.resultData == null || |
typeof DojoExternalInterface.resultData == "undefined"){ |
return 0; |
} |
var segments = Math.ceil(DojoExternalInterface.resultData.length / 1024); |
return segments; |
} |
|
public static function chunkReturnData(segment:Number):String{ |
var numSegments = DojoExternalInterface.getReturnLength(); |
var startCut = segment * 1024; |
var endCut = segment * 1024 + 1024; |
if(segment == (numSegments - 1)){ |
endCut = segment * 1024 + DojoExternalInterface.resultData.length; |
} |
|
var piece = DojoExternalInterface.resultData.substring(startCut, endCut); |
|
//getURL("javascript:console.debug('FLASH: chunking return piece="+piece+"')"); |
|
return piece; |
} |
|
public static function endExec():Void{ |
} |
|
private static function decodeData(data):String{ |
// we have to use custom encodings for certain characters when passing |
// them over; for example, passing a backslash over as //// from JavaScript |
// to Flash doesn't work |
data = DojoExternalInterface.replaceStr(data, "&custom_backslash;", "\\"); |
|
data = DojoExternalInterface.replaceStr(data, "\\\'", "\'"); |
data = DojoExternalInterface.replaceStr(data, "\\\"", "\""); |
|
return data; |
} |
|
private static function encodeData(data){ |
//getURL("javascript:console.debug('inside flash, data before="+data+"')"); |
|
// double encode all entity values, or they will be mis-decoded |
// by Flash when returned |
data = DojoExternalInterface.replaceStr(data, "&", "&"); |
|
// certain XMLish characters break Flash's wire serialization for |
// ExternalInterface; encode these into a custom encoding, rather than |
// the standard entity encoding, because otherwise we won't be able to |
// differentiate between our own encoding and any entity characters |
// that are being used in the string itself |
data = DojoExternalInterface.replaceStr(data, '<', '&custom_lt;'); |
data = DojoExternalInterface.replaceStr(data, '>', '&custom_gt;'); |
|
// encode control characters and JavaScript delimiters |
data = DojoExternalInterface.replaceStr(data, "\n", "\\n"); |
data = DojoExternalInterface.replaceStr(data, "\r", "\\r"); |
data = DojoExternalInterface.replaceStr(data, "\f", "\\f"); |
data = DojoExternalInterface.replaceStr(data, "'", "\\'"); |
data = DojoExternalInterface.replaceStr(data, '"', '\"'); |
|
//getURL("javascript:console.debug('inside flash, data after="+data+"')"); |
return data; |
} |
|
/** |
Flash ActionScript has no String.replace method or support for |
Regular Expressions! We roll our own very simple one. |
*/ |
private static function replaceStr(inputStr:String, replaceThis:String, |
withThis:String):String { |
var splitStr = inputStr.split(replaceThis) |
inputStr = splitStr.join(withThis) |
return inputStr; |
} |
|
private static function getDojoPath(){ |
var url = _root._url; |
var start = url.indexOf("baseRelativePath=") + "baseRelativePath=".length; |
var path = url.substring(start); |
var end = path.indexOf("&"); |
if(end != -1){ |
path = path.substring(0, end); |
} |
return path; |
} |
} |
|
// vim:ts=4:noet:tw=0: |