A couple of questions have surfaced from community members recently with regard to execution contexts in a Titanium Mobile application. I thought I would take a few minutes to explain execution contexts to folks for whom the concept is still a little foggy. First, let me explain what I mean when I say “execution context”.
A JavaScript application running in a web browser is single threaded and has a global variable scope for the entire application. A Titanium Mobile application is similar, except that a single application may have multiple JavaScript processes running at once, each with it’s own unique scope. We call these “execution contexts”.
Every Titanium Mobile application has at least one execution context, the one created by the app.js JavaScript program which bootstraps your entire application. New execution contexts are created when a window is created that points to an external JavaScript file, which would then bootstrap the new window. We refer to windows that have their own execution contexts as “heavyweight” windows (making those that do not “lightweight” windows, since a window need not point to an external JavaScript file). The syntax for creating a heavyweight window is below, and familiar to the majority of you I am sure:
var win = Titanium.UI.createWindow({
title: ‘New Window’,
url: ‘win.js’
});
When this new window is opened, it will have it’s own context and scope, so any variables declared in other contexts will not be available. Say that my app.js file contains the following code:
var awesome = true; //this is visible in the current execution context
var win = Ti.UI.createWindow({
title: ‘New Window’,
url: ‘win.js’,
backgroundColor:’#fff’
});
win.open();
And win.js contains the following code:
var label = Ti.UI.createLabel({
text: (awesome) ? ‘JavaScript is awesome!’ : ‘Yeah, well so’s your old lady!’
});
Ti.UI.currentWindow.add(label);
This example would fail because the code in win.js is not executed in the same context as the code in app.js, so the variable awesome is out of scope.
Occasionally, it is necessary for one context to communicate with another. This is accomplished using the custom events facility that is built into the Titanium API. You can fire application-level events that will be received in all currently active execution contexts (app.js plus any open windows) via fireEvent. Custom events can have arbitrary data passed along with them, as shown in the example below:
Ti.App.fireEvent(‘myCustomEvent’, {
myCustomEventValue: ‘someValue’
});
You can listen for these custom events in any context by using addEventListener at the application level as well. The example below listens for our custom event – you’ll notice that any properties of the object passed as the second argument to fireEvent are available on the event object the callback function takes as an argument:
Ti.App.addEventListener(‘myCustomEvent’, function(event) {
Ti.API.info(‘You sent me: ‘+event.myCustomEventValue);
});
Note that only ACTIVE execution contexts will receive a custom event when it is sent, so any windows that are not yet open will not receive the event.
While not every application requires multiple execution contexts, it is good to know when execution contexts are created and how they work. Hope that helps, and let us know if you have any questions.
Follow us on social