SMARCOS CNR Paper Engineering
1 like310 views
This document summarizes an approach for preserving JavaScript state when migrating web applications across multiple devices. The key challenges addressed are maintaining the JavaScript state, including values of variables, function references, timers and dates. The solution uses a migration server to capture the current page state, including the DOM and JavaScript variables, and generate a new version of the page optimized for the target device while maintaining the same interactive state. Special techniques are required to handle JavaScript object references and circular references during state serialization and restoration.
![Engineering JavaScript State Persistence of Web
Applications Migrating across Multiple Devices
Federico Bellucci, Giuseppe Ghiani, Fabio Paternò, Carmen Santoro
CNR-ISTI, HIIS Laboratory
Via Moruzzi 1, 56124 Pisa, Italy
{federico.bellucci, giuseppe.ghiani, fabio.paterno, carmen.santoro}@isti.cnr.it
ABSTRACT implementation languages, with the state updated to the one
Ubiquitous environments call for user interfaces able to that was created through the source device.
migrate across various types of devices while preserving
The range of opportunities that migratory applications open
task continuity. One fundamental issue in migratory user
up can be beneficial in radically different application
interfaces is how to preserve the state while moving from
domains: for instance, applications whose tasks require
one device to another. In this paper we present a solution
time to be carried out (such as games, business
for the interactive part of Web applications. In particular,
applications) or applications that have some rigid deadline
we focus on the most problematic part, which is
and thus need to be completed wherever the user is (e.g.:
maintaining the JavaScript state. We also describe an
online auctions). We focus on Web applications, which
example application to illustrate the support provided by
have limited support for state persistence and continuity
our migration platform.
across various types of devices. Thus, if for some reason
ACM Classification: H5.2 [Information interfaces and users have to change device, the information entered can be
presentation]: User Interfaces. - Graphical user interfaces. lost and then they have to start over their interactive session
Keywords: Migratory User Interfaces, Multi-device on the new device from scratch.
Environments, User Interface Adaptation, Continuity. Previous solutions for supporting migration [1] proposed
General Terms: Design, Experimentation, Human Factors.
techniques for the migration of entire applications, but this
does not usually work because of the different interaction
INTRODUCTION resources of the various devices. Kozuch and
Recent advances in the capability of digital devices Satyanarayanan [5] proposed a migration solution based on
together with their progressive mass market penetration has the encapsulation of the volatile execution state of a virtual
led users to expect to be able to carry out their tasks in any machine, but only limited to migration of applications
context and in a seamless way regardless of the possibly among desktop or laptop systems. Chung and Dewan [2]
changing settings. proposed that, when migration is triggered, the
In order to address this kind of challenging scenario, we environment starts a fresh copy of the application process
propose our approach for migratory interactive in the target system, and replays the saved sequence of
applications, which are applications that are able to input events to the copy. However, this solution can have
preserve the state reached after some user interactions using performance issues if such a sequence is long. Quan et al.
a specific device, and then resume such state within a new [7] proposed to collect user parameters into an object called
version of the application that has been migrated to the new user interface continuation. Programs can create UI
device. The proposed architecture for migratory user continuations by specifying what information has to be
interfaces is composed of a number of software modules, collected from the user and supplying a callback (i.e., a
which support the dynamic generation of user interfaces continuation) to be notified with the collected information.
adapted to various types of target devices and However, differently from them, we support the possibility
of pausing the performance of a task, and then afterwards
being able to resume the performance on a new device from
Permission to make digital or hard copies of all or part of this work for
personal or classroom use is granted without fee provided that copies are
the point the user left off. A toolkit for Distributed User
not made or distributed for profit or commercial advantage and that copies Interfaces was proposed in [6], though our solution differs
bear this notice and the full citation on the first page. To copy otherwise, or in that Web applications can be migrated without posing
republish, to post on servers or to redistribute to lists, requires prior specific any constraint on the authoring technique to use for
permission and/or a fee.
EICS’11, June 13–16, 2011, Pisa, Italy.
developing the applications. Other solutions for migratory
Copyright 2011 ACM 978-1-4503-0670-6/11/06...$10.00. interfaces [4] were able to manage only the state of forms
and their adaptation process was not able to manage the
105](https://image.slidesharecdn.com/821cnreics2011paperengineering-120119171014-phpapp01/85/SMARCOS-CNR-Paper-Engineering-1-320.jpg)
![interaction resources available in the target device. this library in order to serialise the objects that are not
Afterwards, the Migration Server analyses such a target handled by standard JSON (Dates, array properties, DOM
logical description containing all the various presentations elements) and we manage the serialisation of objects that
and identifies the currently focused presentation. Finally, do not appear in global variables (e.g. timers), by using a
the identified logical presentation is then transformed in library-independent mechanism explained in the following
order to build the corresponding implementation for the section.
target device, which is sent to the target client so that the Global and BOM variables
user can load the adapted page with the state resulting from In JavaScript code, every object/variable defined in the
the interactions occurred on the source device and then global environment is simply a property of the global
continue the interaction with the new version of the page. Window object (which in turn represents the browser
The state that we preserve is composed of the values window). In order to programmatically capture the values
associated with all the forms elements, the current focus, of the user-defined global variables, we use the JavaScript
the cookies, and the state of the JavaScript code. The last for...in statement, which enumerates the properties of
one has shown to be the most problematic aspect, which objects (without knowing their names in advance).
was not supported by previous solutions for migratory user However, there are some window properties that, though
interfaces and, thus, in this paper we discuss extensively its enumerated, should not finally be included in the migration
solution, whose importance also derives from the state. These are the properties belonging to the so-called
increasing use of JavaScript code. Browser Object Model (BOM), an interface provided by
MANAGING JAVASCRIPT STATE WITHIN MIGRATION
the browser, which makes available a number of “utility”
The problem of correctly managing the JavaScript state in properties (e.g. the address of the page currently loaded in
migratory Web applications is a critical point, and since the browser, the reference to the DOM root, the history
Web applications are becoming more and more interactive, produced by using “Back” and “Forward” browser
it is likely to play an even more important role in the future. buttons). Such properties should be excluded from the
Indeed, if the state associated with JavaScript variables is migration state since on the one hand some of them are
not properly saved and restored, inconsistencies can be browser-dependent, while, on the other, some properties
experienced when the user migrates to the target device. (like the reference to the DOM root) are already handled by
This means that exceptions could be raised due to the fact the migration platform, thus they are useless for migration
that some variables no longer exist in the new version purposes. The mechanism we use to exclude the BOM-
uploaded on the target device, or even worse, no exception related variables is to create a “filter” list for each browser
is raised, but some variables might hold incorrect values considered (Internet Explorer, Safari, Opera, Firefox,
(namely, ones that are different from those held when the Chrome). This support works with any web application.
migration was triggered). Object References
To capture and restore the JavaScript state of a Web This case refers to when the migration platform has to
application we basically use JavaScript code (automatically serialise two variables or properties that refer to the same
included in the concerned Web page by the Migration value and the value type is non-primitive (then, it is a type
platform). Regarding the format for saving the state, we different from Number, Boolean, etc.). For instance:
use the JavaScript Object Notation (JSON), since it is a var x= <anObject> ;
lightweight format and in addition the JSON var y = x ;
serialisation/parsing support is natively integrated within In this situation, standard JSON would i) serialise twice
most currently available browsers. <anObject> and ii) serialise it into two separate objects
The data types that are supported by the standard JSON (one for the x variable and the other one for y). Instead, in
format are: i) primitive types (Number, String, Boolean, our solution the result of the serialiser is that the y variable
null); ii) arrays (like [value1, value2, ...]); iii) associative is associated with a unique reference to the x variable. With
arrays (also known as “Maps”), like {key1: value1, key2: this mechanism (called object referencing) we avoid
value2, ...}. However, just using a standard JSON serialiser duplication of value serialisation and preserve, after
is not sufficient, since – as we will see – some problems migration, the fact that the y variable will continue to refer
are not appropriately handled by using it alone (object to the x variable.
references, non-numeric properties of arrays, timers, …). In Circular References
the following sections we describe the main issues we have A special case of object references is represented by
addressed regarding the capture and restoration of circular references. We have circular references when there
migration JavaScript state, and the associated solutions we is a variable, which is defined through another variable,
adopted. As we will see, such solutions include using a which in turn is defined through the first one. Let us
JavaScript library (dojox.json.ref [3]), which we have consider the following JavaScript excerpt:
customized in order to properly handle specific issues. var johnJohnson = {
More specifically, we made a number of modifications to name : "John" ,
107](https://image.slidesharecdn.com/821cnreics2011paperengineering-120119171014-phpapp01/85/SMARCOS-CNR-Paper-Engineering-3-320.jpg)
![father : { global/public list of timers saved in the state and then, by
name : "Paul" , re-starting the central timer, all the connected timers will
son : johnJohnson
also be re-started. In this way, the active timers will be
}
consequently restored in the target device.
};
Dates
By using standard JSON, the variable johnJohnson could
The Date object is used to work with dates and times.
not be correctly serialised, since standard JSON serialises
Standard JSON does not support the serialisation of a Date
every object through its value and therefore an endless
object since it serialises it as a void object. The
recursion will result, eventually raising an exception. In our
dojox.json.ref library provides only a partial solution for
case, in order to correctly preserve the object state, we
this problem. Indeed, it correctly serialises the Date object
serialise the reference to the object (not the value). This has
into an ISO-UTC –formatted string, but it is not able to re-
been done by exploiting the dojox.json.ref library, which in
convert it again into a Date object without explicitly
correspondence of the value of the “son” property puts a
instructing the deserialiser with a list of Date property
reference by using a path-based referencing mechanism.
names. However, even doing this, the solution was not able
The latter technique supports the identification of an object
to cover some situations, for instance when an object has
property by specifying its location within the object’s
multiple properties of Date type at different nesting levels
structure. Thus, in this case, in order to identify the “son”
and the same name. In this case only the first occurrence
property of the object we provide the path that goes from
was correctly preserved with that technique. Our solution is
the root of the tree (where the tree represents the object), to
simpler and more general: we encapsulate the ISO-
the leaf (representing the property involved).
formatted date in an object holding a property that marks
Timers the object in such a way that the deserialiser can quickly
Timers are generally used when the developer wants to identify and correctly restore the object as a Date Object.
include some time dependency within the code (e.g.
indicating that a certain portion of the code should be Properties dynamically assigned to objects
executed after a specific number of seconds). They are In JavaScript all the non-primitive data types (like
handled through the methods setTimeout and setInterval associative arrays, arrays, strings, functions...) are objects
(resp.: to activate a single timer which triggers a handler at and, as such, can have dynamically assigned properties.
its end; to repeat a portion of code after a specific time Such properties are saved in the state by standard JSON
interval); and through the clearTimeout and clearInterval only if the object containing them is an associative array
methods (resp.: to stop a currently active timer, which is (or Map), otherwise (namely, if they are included by other
identified by an ID; and to clear a timer set with the types of objects) they are ignored. An example of this
setInterval method). In the following example handler is problem can occur while serialising the following excerpt:
the code excerpt to run after ms milliseconds have elapsed; var array = [value1 , value2];
timerId is the identifier associated with the timer: array.dynProp = someValue;
var timerId = setTimeout (handler , ms); In order to manage this issue, we have identified a solution
clearTimeout (timerId); that successfully manages saving such dynamic properties
Timers can affect the state in two possible manners: first, also for other types of objects apart from associative arrays.
we can have timers that are currently active/pending at the So far we have implemented this solution for managing
time when the migration occurs; secondly, in the code we arrays, though our solution is easily extendible to other
might have variables containing references to timers. cases. In our solution we appropriately modified the
Unfortunately, the ECMAScript APIs neither offer methods dojox.json.ref serialiser in such a way that it encapsulates
enabling to access the state of an active JavaScript Timer, each array in an object holding a property that contains all
nor do they allow enumerating the list of active Timers. the array’s dynamic properties.
In order to cope with this issue and allow the correct References to DOM nodes
restoring of timers after migration, in our solution we The JavaScript of a web page can access the DOM tree
override the standard behaviour of setTimeout by adding nodes by reference (e.g. to read or modify them). Thus, the
additional code able to appropriately handle the state of persistence of such references is needed in order to
timers. More specifically, the solution we adopted creates a preserve the state.
global/public list of Timers, by adding a Timer object to Indeed, one of the most common operations carried out on
such a list every time the setTimeout (or setInterval) is the DOM tree is to find a node by providing its identifier
invoked. Since such a list is global, it will be easily (by using the getElementById method, which provides a
accessed in the global state. The timers of such a list will be reference to a DOM node that has a unique ID).
updated by a single “central” timer which will invoke at Unfortunately, standard JSON is not able to correctly
regular intervals the update function of each active timer. In serialise JavaScript variables containing references to DOM
order to correctly restore timers after migration, in the nodes. The following cases can happen: either the
target device we build a list of timers starting from the
108](https://image.slidesharecdn.com/821cnreics2011paperengineering-120119171014-phpapp01/85/SMARCOS-CNR-Paper-Engineering-4-320.jpg)
![concerned element has an ID, or it does not have an ID, or However, the entire JavaScript state is now included in
it does not belong to the DOM. such a JSON message.
Consider the following excerpt:
Transmitting and restoring the state
var element = getElementById("myHtmlElement"); Regarding the transmission of such a JSON message, this is
var image = new Image("imageSource");
carried out by an AJAX request directed to the Migration
In our solution, when an object of type HtmlElement is Server. Through such a request, the client passes both the
actually a reference to a DOM node, we verify whether it DOM of the page and the JavaScript state to a servlet
has an ID. In this case, such an ID is saved within the state, (which is on the Migration Server). According to such
otherwise our solution assigns an ID to it. In the remaining information, the servlet creates the corresponding page.
case (when the object does not belong to the DOM, like the This means that first the servlet identifies the <body>
image variable included in the above code excerpt), the element of the page derived from the received DOM. Then,
value of the object is saved by storing the values of all of it appends a JavaScript function, whose goal is to update
its public properties using the JavaScript library JsonML the JavaScript variables contained in the page, to the
(http://jsonml.org/). current content (if any) of the onload attribute of the
SAVING, TRANSMITTING AND RESTORING THE STATE <body> element. After having done such modifications to
WITHIN THE MIGRATION PLATFORM the page, the servlet stores the updated page (containing the
In this section we focus on how the migration platform up-to-date state) in a specific location of the server, and
supports the saving, transmission and restoring of the also stores the JSON message received from the AJAX
JavaScript state of Web pages. The core of our solution is script in a file. According to such information, the server
represented by the JavaScript JSStateMigrator library we then builds the URL from which the target device browser
have developed for this goal. Such a library has two main will load the page with the updated state. So, by analysing
methods: the received JSON message the target device browser will
saveState(): saves the current JavaScript state into a be able to restore the state in the target device (loadState()
JSON message represented by a Map object, and method). This is done by deserialising all the properties of
includes all the global variables of the application and the abovementioned JSON object and restoring them onto
their properties; the corresponding global variables. Then, the pending
timers are also created and the central timer is started again
loadState(), takes as input parameter the JSON message (as explained above). So, the actual restoring of the
representing the state of the migrated application and JavaScript state of the Web application is carried out within
restores it within the target device. the client, after the Web page has been loaded.
In the following sections we describe them further. AN APPLICATION EXAMPLE: JS-TETRIS
Saving the State To show an example application, we consider a Web
The saveState() method works in the following way. As (XHTML+JavaScript) implementation of Tetris
previously mentioned, we use the for…in statement as the (http://www.gosu.pl/tetris/), a widely known arcade game.
main mechanism for saving the value of all the JavaScript The considered game (see Figure 2) is composed of a
global variables (which are properties of the window 12x22 grid, in which objects with different geometrical
object). As also noted before, we added to the for...in cycle shapes fall to the bottom of the game board. The player
a condition to check whether a certain property has to be controls the pieces by moving/rotating them, trying to make
excluded since it belongs to the BOM variables. After them fit each other so as to compose a horizontal line
having done this, we create a JSON message containing a through them. When this occurs, the line(s) of pieces
couple (key, value) for each property of the concerned disappear and the score increases. As the horizontal lines
global object. It is worth noting that the serialised are completed, the game becomes more difficult (e.g. the
JavaScript state is no longer in standard JSON, because the pieces fall progressively faster). Alternatively, if the player
serialised properties are enriched with additional leaves holes within the horizontal piece rows, they do not
information that will enable the custom deserialiser to disappear but start to pile up, until the player is no longer
correctly handle special objects that cannot be able to play, and the game will end. The UI of the game is
[de]serialised by using standard JSON (e.g. Date objects, composed of a number of nested DIV elements. First, there
array properties with non-numerical keys, DOM elements, is the top level DIV (representing the whole game), which
or even HTML elements which are not in the DOM). in turn is vertically decomposed into a DIV element (for the
menu) and another DIV element (with the game board).
109](https://image.slidesharecdn.com/821cnreics2011paperengineering-120119171014-phpapp01/85/SMARCOS-CNR-Paper-Engineering-5-320.jpg)
SMARCOS CNR Paper Engineering
- 1. Engineering JavaScript State Persistence of Web Applications Migrating across Multiple Devices Federico Bellucci, Giuseppe Ghiani, Fabio Paternò, Carmen Santoro CNR-ISTI, HIIS Laboratory Via Moruzzi 1, 56124 Pisa, Italy {federico.bellucci, giuseppe.ghiani, fabio.paterno, carmen.santoro}@isti.cnr.it ABSTRACT implementation languages, with the state updated to the one Ubiquitous environments call for user interfaces able to that was created through the source device. migrate across various types of devices while preserving The range of opportunities that migratory applications open task continuity. One fundamental issue in migratory user up can be beneficial in radically different application interfaces is how to preserve the state while moving from domains: for instance, applications whose tasks require one device to another. In this paper we present a solution time to be carried out (such as games, business for the interactive part of Web applications. In particular, applications) or applications that have some rigid deadline we focus on the most problematic part, which is and thus need to be completed wherever the user is (e.g.: maintaining the JavaScript state. We also describe an online auctions). We focus on Web applications, which example application to illustrate the support provided by have limited support for state persistence and continuity our migration platform. across various types of devices. Thus, if for some reason ACM Classification: H5.2 [Information interfaces and users have to change device, the information entered can be presentation]: User Interfaces. - Graphical user interfaces. lost and then they have to start over their interactive session Keywords: Migratory User Interfaces, Multi-device on the new device from scratch. Environments, User Interface Adaptation, Continuity. Previous solutions for supporting migration [1] proposed General Terms: Design, Experimentation, Human Factors. techniques for the migration of entire applications, but this does not usually work because of the different interaction INTRODUCTION resources of the various devices. Kozuch and Recent advances in the capability of digital devices Satyanarayanan [5] proposed a migration solution based on together with their progressive mass market penetration has the encapsulation of the volatile execution state of a virtual led users to expect to be able to carry out their tasks in any machine, but only limited to migration of applications context and in a seamless way regardless of the possibly among desktop or laptop systems. Chung and Dewan [2] changing settings. proposed that, when migration is triggered, the In order to address this kind of challenging scenario, we environment starts a fresh copy of the application process propose our approach for migratory interactive in the target system, and replays the saved sequence of applications, which are applications that are able to input events to the copy. However, this solution can have preserve the state reached after some user interactions using performance issues if such a sequence is long. Quan et al. a specific device, and then resume such state within a new [7] proposed to collect user parameters into an object called version of the application that has been migrated to the new user interface continuation. Programs can create UI device. The proposed architecture for migratory user continuations by specifying what information has to be interfaces is composed of a number of software modules, collected from the user and supplying a callback (i.e., a which support the dynamic generation of user interfaces continuation) to be notified with the collected information. adapted to various types of target devices and However, differently from them, we support the possibility of pausing the performance of a task, and then afterwards being able to resume the performance on a new device from Permission to make digital or hard copies of all or part of this work for personal or classroom use is granted without fee provided that copies are the point the user left off. A toolkit for Distributed User not made or distributed for profit or commercial advantage and that copies Interfaces was proposed in [6], though our solution differs bear this notice and the full citation on the first page. To copy otherwise, or in that Web applications can be migrated without posing republish, to post on servers or to redistribute to lists, requires prior specific any constraint on the authoring technique to use for permission and/or a fee. EICS’11, June 13–16, 2011, Pisa, Italy. developing the applications. Other solutions for migratory Copyright 2011 ACM 978-1-4503-0670-6/11/06...$10.00. interfaces [4] were able to manage only the state of forms and their adaptation process was not able to manage the 105
- 2. associated scripts. In this work, we present a solution able annotation phase. Such a script method sends the DOM of to preserve the state during a Web migration, including not the source page together with the current application state only the input entered by the users through the various to the Migration Server (6). The communication between interaction techniques available in the Web page, but also Migration Control Panel and the Web page is possible the state referred by JavaScript code (including Ajax because the Migration Control Panel window keeps a scripts). In particular, the latter point represents the main reference to the Web page window, and thus can access contribution of this paper, since it has not been addressed in data and structures of the Web application, which arrive via previous work on migratory user interfaces. the Migration Proxy. MIGRATION SOFTWARE ARCHITECTURE Our solution is mainly a server-based approach. We did not implement our solution as a browser extension because our idea was to be as general as possible thus allowing users to freely choose whatever browser they like. In our solution we just suppose the existence of the desktop version of the page to be migrated. Also, we do not consider a migration occurring between two existing different versions of the application (e.g. migration from an existing desktop version to an existing mobile version of the same application). Rather, we judged more challenging and interesting to migrate such desktop version by means of dynamically building a new version suitable for the target device. The proposed software architecture is illustrated in Figure 1. First, there is a device discovery phase (1), which allows Figure 1. An overview of the migration architecture. the various devices available in the environment to discover each other. This is done through a communication between Once the Migration server has obtained the information the Migration Server and the so-called “Migration Control about the current context in which the interaction is taking Panel”, a Web application (implemented in HTML and place (document, application state, focus), it generates the JavaScript) running on each migration device and allowing page for the new device with a state consistent with that of the user to manage the various migration features. In order the original page, and sends its URL to the Migration to support the device discovery phase, the Migration Control Panel of the target device (7), which opens it in a Control Panel periodically announces itself (via Ajax new window (8). The new window shows the target page requests) to the Migration Server, and then gets the list of with state persistence obtained from the Migration Server available target devices. After this discovery step, and (9). supposing a desktop-to-mobile migration, every time the The process which supports the generation of the page for browser currently running on the desktop requests a page the target device starting from the source device page is via the Migration Control Panel (2), this request is captured actually divided into a number of steps carried out by the by the Migration Proxy of the Migration Platform (3), Migration Server. First, by getting the DOM of the current which calls up the page concerned from the application page (which provides a description of the Web page server (4). Before sending the page back to the client considered) and the state of the page (namely: values device, the Migration Proxy annotates the page. contained within forms, currently selected options, etc.), Annotations consist in modifying the accessed page in the Migration Server returns as output a new page which is order to enable its migration. In particular, it includes i) the original one enriched with the state information adapting the links included in the page (to route any received in input (therefore, in the new page the form fields following connection through the Migration Proxy so as to contain the updated values, etc.). Then, such resulting page support migration of pages that are accessible from the undergoes a phase of reverse engineering, which builds the currently visited page), ii) adding IDs to the page corresponding logical description from (X)HTML, CSS components which can potentially be subject to migration and JavaScript implementations. It is worth mentioning that (e.g. “DIV”, “TABLE”, “FORM”); iii) including when the Web application contains Flash or Java applets, appropriate JavaScript code in the original Web page so as then they are either replaced with alternative content to support the various migration features (e.g. capture and provided by the application developers or they are passed transmission of the current state of the page). “as is” to the target device, if it is able to execute them. The output of this reverse engineering phase (which is a The Migration Control Panel also enables the user to concrete UI description for the desktop platform) is then trigger the page migration (5). When a migration trigger transformed to a corresponding concrete UI description for occurs, such a trigger has the effect of “waking up” a script the target platform, by mapping concrete interface elements method previously included in the original Web page in the on the source device into ones that are more suitable for the 106
- 3. interaction resources available in the target device. this library in order to serialise the objects that are not Afterwards, the Migration Server analyses such a target handled by standard JSON (Dates, array properties, DOM logical description containing all the various presentations elements) and we manage the serialisation of objects that and identifies the currently focused presentation. Finally, do not appear in global variables (e.g. timers), by using a the identified logical presentation is then transformed in library-independent mechanism explained in the following order to build the corresponding implementation for the section. target device, which is sent to the target client so that the Global and BOM variables user can load the adapted page with the state resulting from In JavaScript code, every object/variable defined in the the interactions occurred on the source device and then global environment is simply a property of the global continue the interaction with the new version of the page. Window object (which in turn represents the browser The state that we preserve is composed of the values window). In order to programmatically capture the values associated with all the forms elements, the current focus, of the user-defined global variables, we use the JavaScript the cookies, and the state of the JavaScript code. The last for...in statement, which enumerates the properties of one has shown to be the most problematic aspect, which objects (without knowing their names in advance). was not supported by previous solutions for migratory user However, there are some window properties that, though interfaces and, thus, in this paper we discuss extensively its enumerated, should not finally be included in the migration solution, whose importance also derives from the state. These are the properties belonging to the so-called increasing use of JavaScript code. Browser Object Model (BOM), an interface provided by MANAGING JAVASCRIPT STATE WITHIN MIGRATION the browser, which makes available a number of “utility” The problem of correctly managing the JavaScript state in properties (e.g. the address of the page currently loaded in migratory Web applications is a critical point, and since the browser, the reference to the DOM root, the history Web applications are becoming more and more interactive, produced by using “Back” and “Forward” browser it is likely to play an even more important role in the future. buttons). Such properties should be excluded from the Indeed, if the state associated with JavaScript variables is migration state since on the one hand some of them are not properly saved and restored, inconsistencies can be browser-dependent, while, on the other, some properties experienced when the user migrates to the target device. (like the reference to the DOM root) are already handled by This means that exceptions could be raised due to the fact the migration platform, thus they are useless for migration that some variables no longer exist in the new version purposes. The mechanism we use to exclude the BOM- uploaded on the target device, or even worse, no exception related variables is to create a “filter” list for each browser is raised, but some variables might hold incorrect values considered (Internet Explorer, Safari, Opera, Firefox, (namely, ones that are different from those held when the Chrome). This support works with any web application. migration was triggered). Object References To capture and restore the JavaScript state of a Web This case refers to when the migration platform has to application we basically use JavaScript code (automatically serialise two variables or properties that refer to the same included in the concerned Web page by the Migration value and the value type is non-primitive (then, it is a type platform). Regarding the format for saving the state, we different from Number, Boolean, etc.). For instance: use the JavaScript Object Notation (JSON), since it is a var x= <anObject> ; lightweight format and in addition the JSON var y = x ; serialisation/parsing support is natively integrated within In this situation, standard JSON would i) serialise twice most currently available browsers. <anObject> and ii) serialise it into two separate objects The data types that are supported by the standard JSON (one for the x variable and the other one for y). Instead, in format are: i) primitive types (Number, String, Boolean, our solution the result of the serialiser is that the y variable null); ii) arrays (like [value1, value2, ...]); iii) associative is associated with a unique reference to the x variable. With arrays (also known as “Maps”), like {key1: value1, key2: this mechanism (called object referencing) we avoid value2, ...}. However, just using a standard JSON serialiser duplication of value serialisation and preserve, after is not sufficient, since – as we will see – some problems migration, the fact that the y variable will continue to refer are not appropriately handled by using it alone (object to the x variable. references, non-numeric properties of arrays, timers, …). In Circular References the following sections we describe the main issues we have A special case of object references is represented by addressed regarding the capture and restoration of circular references. We have circular references when there migration JavaScript state, and the associated solutions we is a variable, which is defined through another variable, adopted. As we will see, such solutions include using a which in turn is defined through the first one. Let us JavaScript library (dojox.json.ref [3]), which we have consider the following JavaScript excerpt: customized in order to properly handle specific issues. var johnJohnson = { More specifically, we made a number of modifications to name : "John" , 107
- 4. father : { global/public list of timers saved in the state and then, by name : "Paul" , re-starting the central timer, all the connected timers will son : johnJohnson also be re-started. In this way, the active timers will be } consequently restored in the target device. }; Dates By using standard JSON, the variable johnJohnson could The Date object is used to work with dates and times. not be correctly serialised, since standard JSON serialises Standard JSON does not support the serialisation of a Date every object through its value and therefore an endless object since it serialises it as a void object. The recursion will result, eventually raising an exception. In our dojox.json.ref library provides only a partial solution for case, in order to correctly preserve the object state, we this problem. Indeed, it correctly serialises the Date object serialise the reference to the object (not the value). This has into an ISO-UTC –formatted string, but it is not able to re- been done by exploiting the dojox.json.ref library, which in convert it again into a Date object without explicitly correspondence of the value of the “son” property puts a instructing the deserialiser with a list of Date property reference by using a path-based referencing mechanism. names. However, even doing this, the solution was not able The latter technique supports the identification of an object to cover some situations, for instance when an object has property by specifying its location within the object’s multiple properties of Date type at different nesting levels structure. Thus, in this case, in order to identify the “son” and the same name. In this case only the first occurrence property of the object we provide the path that goes from was correctly preserved with that technique. Our solution is the root of the tree (where the tree represents the object), to simpler and more general: we encapsulate the ISO- the leaf (representing the property involved). formatted date in an object holding a property that marks Timers the object in such a way that the deserialiser can quickly Timers are generally used when the developer wants to identify and correctly restore the object as a Date Object. include some time dependency within the code (e.g. indicating that a certain portion of the code should be Properties dynamically assigned to objects executed after a specific number of seconds). They are In JavaScript all the non-primitive data types (like handled through the methods setTimeout and setInterval associative arrays, arrays, strings, functions...) are objects (resp.: to activate a single timer which triggers a handler at and, as such, can have dynamically assigned properties. its end; to repeat a portion of code after a specific time Such properties are saved in the state by standard JSON interval); and through the clearTimeout and clearInterval only if the object containing them is an associative array methods (resp.: to stop a currently active timer, which is (or Map), otherwise (namely, if they are included by other identified by an ID; and to clear a timer set with the types of objects) they are ignored. An example of this setInterval method). In the following example handler is problem can occur while serialising the following excerpt: the code excerpt to run after ms milliseconds have elapsed; var array = [value1 , value2]; timerId is the identifier associated with the timer: array.dynProp = someValue; var timerId = setTimeout (handler , ms); In order to manage this issue, we have identified a solution clearTimeout (timerId); that successfully manages saving such dynamic properties Timers can affect the state in two possible manners: first, also for other types of objects apart from associative arrays. we can have timers that are currently active/pending at the So far we have implemented this solution for managing time when the migration occurs; secondly, in the code we arrays, though our solution is easily extendible to other might have variables containing references to timers. cases. In our solution we appropriately modified the Unfortunately, the ECMAScript APIs neither offer methods dojox.json.ref serialiser in such a way that it encapsulates enabling to access the state of an active JavaScript Timer, each array in an object holding a property that contains all nor do they allow enumerating the list of active Timers. the array’s dynamic properties. In order to cope with this issue and allow the correct References to DOM nodes restoring of timers after migration, in our solution we The JavaScript of a web page can access the DOM tree override the standard behaviour of setTimeout by adding nodes by reference (e.g. to read or modify them). Thus, the additional code able to appropriately handle the state of persistence of such references is needed in order to timers. More specifically, the solution we adopted creates a preserve the state. global/public list of Timers, by adding a Timer object to Indeed, one of the most common operations carried out on such a list every time the setTimeout (or setInterval) is the DOM tree is to find a node by providing its identifier invoked. Since such a list is global, it will be easily (by using the getElementById method, which provides a accessed in the global state. The timers of such a list will be reference to a DOM node that has a unique ID). updated by a single “central” timer which will invoke at Unfortunately, standard JSON is not able to correctly regular intervals the update function of each active timer. In serialise JavaScript variables containing references to DOM order to correctly restore timers after migration, in the nodes. The following cases can happen: either the target device we build a list of timers starting from the 108
- 5. concerned element has an ID, or it does not have an ID, or However, the entire JavaScript state is now included in it does not belong to the DOM. such a JSON message. Consider the following excerpt: Transmitting and restoring the state var element = getElementById("myHtmlElement"); Regarding the transmission of such a JSON message, this is var image = new Image("imageSource"); carried out by an AJAX request directed to the Migration In our solution, when an object of type HtmlElement is Server. Through such a request, the client passes both the actually a reference to a DOM node, we verify whether it DOM of the page and the JavaScript state to a servlet has an ID. In this case, such an ID is saved within the state, (which is on the Migration Server). According to such otherwise our solution assigns an ID to it. In the remaining information, the servlet creates the corresponding page. case (when the object does not belong to the DOM, like the This means that first the servlet identifies the <body> image variable included in the above code excerpt), the element of the page derived from the received DOM. Then, value of the object is saved by storing the values of all of it appends a JavaScript function, whose goal is to update its public properties using the JavaScript library JsonML the JavaScript variables contained in the page, to the (http://jsonml.org/). current content (if any) of the onload attribute of the SAVING, TRANSMITTING AND RESTORING THE STATE <body> element. After having done such modifications to WITHIN THE MIGRATION PLATFORM the page, the servlet stores the updated page (containing the In this section we focus on how the migration platform up-to-date state) in a specific location of the server, and supports the saving, transmission and restoring of the also stores the JSON message received from the AJAX JavaScript state of Web pages. The core of our solution is script in a file. According to such information, the server represented by the JavaScript JSStateMigrator library we then builds the URL from which the target device browser have developed for this goal. Such a library has two main will load the page with the updated state. So, by analysing methods: the received JSON message the target device browser will saveState(): saves the current JavaScript state into a be able to restore the state in the target device (loadState() JSON message represented by a Map object, and method). This is done by deserialising all the properties of includes all the global variables of the application and the abovementioned JSON object and restoring them onto their properties; the corresponding global variables. Then, the pending timers are also created and the central timer is started again loadState(), takes as input parameter the JSON message (as explained above). So, the actual restoring of the representing the state of the migrated application and JavaScript state of the Web application is carried out within restores it within the target device. the client, after the Web page has been loaded. In the following sections we describe them further. AN APPLICATION EXAMPLE: JS-TETRIS Saving the State To show an example application, we consider a Web The saveState() method works in the following way. As (XHTML+JavaScript) implementation of Tetris previously mentioned, we use the for…in statement as the (http://www.gosu.pl/tetris/), a widely known arcade game. main mechanism for saving the value of all the JavaScript The considered game (see Figure 2) is composed of a global variables (which are properties of the window 12x22 grid, in which objects with different geometrical object). As also noted before, we added to the for...in cycle shapes fall to the bottom of the game board. The player a condition to check whether a certain property has to be controls the pieces by moving/rotating them, trying to make excluded since it belongs to the BOM variables. After them fit each other so as to compose a horizontal line having done this, we create a JSON message containing a through them. When this occurs, the line(s) of pieces couple (key, value) for each property of the concerned disappear and the score increases. As the horizontal lines global object. It is worth noting that the serialised are completed, the game becomes more difficult (e.g. the JavaScript state is no longer in standard JSON, because the pieces fall progressively faster). Alternatively, if the player serialised properties are enriched with additional leaves holes within the horizontal piece rows, they do not information that will enable the custom deserialiser to disappear but start to pile up, until the player is no longer correctly handle special objects that cannot be able to play, and the game will end. The UI of the game is [de]serialised by using standard JSON (e.g. Date objects, composed of a number of nested DIV elements. First, there array properties with non-numerical keys, DOM elements, is the top level DIV (representing the whole game), which or even HTML elements which are not in the DOM). in turn is vertically decomposed into a DIV element (for the menu) and another DIV element (with the game board). 109
- 6. Figure 2: Desktop-to-mobile Migration of the Example The menu is in turn composed of a number of DIV and describe its application to a case study in the game elements, each of them including a menu item (the control domain. Future work will be dedicated to carrying out a buttons, the next piece, the score data, ...). The board area number of user tests to assess the usability of the is a DIV element which initially contains only the twelve presented solution on various case studies. vertical columns, which act as guides for the pieces. ACKNOWLEDGMENTS However, as soon as the game progresses, such elements We gratefully acknowledge support from the Artemis EU will contain the various small, elementary squares (each SMARCOS and the ICT EU SERENOA projects. of them represented by a DIV element) composing each game piece. The game layout and the initial positioning of REFERENCES its elements are handled by an associated CSS stylesheet. 1. Bharat, K. A. and Cardelli L. Migratory Applications. In proceedings of User Interface Software and All the JavaScript code is included within the constructor Technology (UIST ‘95), 1995, pp. 133-142. function Tetris, instantiated after the Web page is loaded, and then saved in a global variable. Within this function, 2. Chung, G., Dewan P. A mechanism for Supporting various nested functions are defined: start, reset, pause, Client Migration in a Shared Window System, gameOver, random, as well as up, down, left, right, space Proceedings UIST’96, pp.11-20, ACM Press. in order to control the pieces. In addition, other 3. Dojox.json.ref library, available at constructor functions are defined such as Window, http://docs.dojocampus.org/dojox/json/ref Keyboard, Area, Puzzle, Stats, HighScores, which define 4. Ghiani, G., Paternò F., Santoro C. On-demand Cross- corresponding properties of the game. In addition, in the Device Interface Components Migration, Proceedings Tetris code there is also the definition of some anonymous Mobile HCI 2010, pp. 299 – 308, 2010, ACM Press. functions, which are assigned to properties of DOM nodes, for instance ($("tetris-menu-start").onclick is for 5. Kozuch, M., Satyanarayanan, M. Internet starting a new game). Finally, there are also additional Suspend/Resume, Proceedings of the Fourth IEEE properties defining the board area (unit, areaX, areaY). In Workshop on Mobile Computing Systems and the desktop-to-mobile migration of the Tetris game (see Applications (WMCSA’02) IEEE Press, 2002. Figure 2) our migration platform exploits some of the 6. Melchior, J., Grolaux, D., Vanderdonckt, J., Van Roy, features for managing the JavaScript state we described P. A toolkit for peer-to-peer distributed user interfaces: before. Indeed, this game has object references such as concepts, implementation, and applications. references to HTML elements, and timers. Proceedings ACM EICS 2009: 69-78. CONCLUSIONS AND FUTURE WORK 7. Quan, D., Huynh, D., Karger, D. R., and Miller, R. In this paper we have presented our approach for User interface Continuations. Proceedings 16th ACM supporting JavaScript state persistence and, consequently, UIST Symposium. 2003. ACM Press, pp. 145-148. task continuity in interactive Web migratory applications, 110