Ett av de vanligaste sätten att använda det externa API:t är för att låta ActionScript-program kommunicera med en webbläsare. Med det externa API:t kan ActionScript-metoder anropa kod som skrivits i JavaScript och vice versa. Eftersom webbläsare är så komplicerade och eftersom de renderar sidor internt går det inte att garantera att ett SWF-dokument kan registrera sina callback-funktioner innan den första JavaScripten på HTML-sidan körs. Därför bör alltid SWF-dokumentet anropa HTML-sidan för att meddela den att SWF-dokumentet är klart att ta emot anslutningar innan funktionerna i SWF-dokumentet anropas från JavaScript.
Introvert IM avgör till exempel genom en serie steg som utförs av klassen IMManager om webbläsaren är klar för kommunikation och förbereder SWF-filen för kommunikation. Det första steget, som avgör när webbläsaren är klar för kommunikation, utförs i IMManager-konstruktorn på följande sätt:
public function IMManager(initialStatus:IMStatus)
{
_status = initialStatus;
// Check if the container is able to use the external API.
if (ExternalInterface.available)
{
try
{
// This calls the isContainerReady() method, which in turn calls
// the container to see if Flash Player has loaded and the container
// is ready to receive calls from the SWF.
var containerReady:Boolean = isContainerReady();
if (containerReady)
{
// If the container is ready, register the SWF's functions.
setupCallbacks();
}
else
{
// If the container is not ready, set up a Timer to call the
// container at 100ms intervals. Once the container responds that
// it's ready, the timer will be stopped.
var readyTimer:Timer = new Timer(100);
readyTimer.addEventListener(TimerEvent.TIMER, timerHandler);
readyTimer.start();
}
}
...
}
else
{
trace("External interface is not available for this container.");
}
}
Först kontrolleras om det externa API:t överhuvudtaget är tillgängligt i den aktuella behållaren med hjälp av egenskapen
ExternalInterface.available
. I så fall börjar kommunikationen upprättas. På grund av att säkerhetsundantag och andra fel kan uppstå när du försöker kommunicera med ett externt program är koden placerad i ett
try
-block (motsvarande
catch
-block har utelämnats i exemplet av utrymmesskäl).
Sedan anropas metoden
isContainerReady()
som listas här:
private function isContainerReady():Boolean
{
var result:Boolean = ExternalInterface.call("isReady");
return result;
}
Metoden
isContainerReady()
använder i sin tur metoden
ExternalInterface.call()
för att anropa JavaScript-funktionen
isReady()
på följande sätt:
<script language="JavaScript">
<!--
// ------- Private vars -------
var jsReady = false;
...
// ------- functions called by ActionScript -------
// called to check if the page has initialized and JavaScript is available
function isReady()
{
return jsReady;
}
...
// called by the onload event of the <body> tag
function pageInit()
{
// Record that JavaScript is ready to go.
jsReady = true;
}
...
//-->
</script>
Funktionen
isReady()
returnerar helt enkelt värdet för variabeln
jsReady
. Den variabeln är från början
false
. När webbsidans
onload
-händelse aktiveras ändras variabelns värde till
true
. Med andra ord svarar JavaScript
false
på anropet
ExternalInterface.call("isReady")
om ActionScript anropar funktionen
isReady()
innan sidan har lästs in. Det gör i sin tur att ActionScript-metoden
isContainerReady()
returnerar
false
. När sidan har lästs in returnerar JavaScript-funktionen
isReady()
true
så att även ActionScript-metoden
isContainerReady()
returnerar
true
.
I IMManager-konstruktorn händer en av två saker beroende på om behållaren är klar eller inte. Om
isContainerReady()
returnerar
true
anropar koden helt enkelt metoden
setupCallbacks()
som slutför processen att upprätta kommunikation med JavaScript. Om
isContainerReady()
å andra sidan returnerar
false
pausas i stället processen. Ett Timer-objekt skapas och instrueras att anropa metoden
timerHandler()
var hundrade millisekund på följande sätt:
private function timerHandler(event:TimerEvent):void
{
// Check if the container is now ready.
var isReady:Boolean = isContainerReady();
if (isReady)
{
// If the container has become ready, we don't need to check anymore,
// so stop the timer.
Timer(event.target).stop();
// Set up the ActionScript methods that will be available to be
// called by the container.
setupCallbacks();
}
}
Varje gång metoden
timerHandler()
anropas kontrollerar den resultatet av metoden
isContainerReady()
. När behållaren har initierats returnerar metoden
true.
Sedan stoppar koden Timer-objektet och anropar metoden
setupCallbacks()
som slutför processen att upprätta kommunikation med webbläsaren.
