Article

Forum.Nokia.com

Getting Started with AJAX on the Nokia Web Browser

Version 1.0; January 4, 2007

Introduction
JavaScript and AJAX are the enabling technologies of Web 2.0 and the new Rich Internet Applications. Web sites are no longer limited to static Web pages but applications on their own, providing engaging user experience and media capabilities for consumers. Millions of developers are familiar with the Web development model and new innovative applications are introduced at a rapid pace, while the gap between native applications and Web applications is blurring. The Web is becoming the platform for the next generation of applications, and the browser plays an essential role in this development. At the same time, the world is becoming increasingly mobile. Mobile Internet access is clearly a major driver for new innovative use of Web applications. The Web converges to mobile devices, making the market potential huge, much bigger than for desktop computers. Modern mobile devices have capable Web browsers that enable access to the same Web applications as on the desktop of a PC. The Web Browser for S60, shipped with the Nokia S60 3rd Edition devices, offers support for JavaScript and AJAX. The Web Browser for S60 is based on the Webkit open-source engine, the same that is used by the Safari desktop browser. JavaScript and AJAX enable an application-like experience for the Web. They make it possible to overcome some of the limitations of the mobile browsers, and improve user experience. The technologies enable a number of benefits to improve the user experience: The small screen can be divided into better logical and dynamic areas. Scrolling can be avoided with tabs. Navigation may be improved with dynamic elements. Page refreshes can be avoided by using AJAX. Data can be loaded faster with AJAX since only a portion of the page is transferred, also cutting back on data amounts transferred over the air.

This article introduces and explains the functionality of an example mobile Web application that uses XHTML, CSS, JavaScript, and AJAX, with the focus being on the last two. Note that this article is not a tutorial for any of these technologies: the reader should know the basics already.

Overview
The example application has been packaged in the file ajaxsample.zip. The package contains the following files: ajaxsample/main.html ajaxsample/mobile.css ajaxsample/main.js ajaxsample/ajax.js ajaxsample/widget.js ajaxsample/loading.gif ajaxsample/some.gif ajaxsample/ajaxget.xml ajaxsample/ajaxcalc.xml main XHTML source CSS main JavaScript AJAX-related JavaScript Widget-related JavaScript animated progress image an icon for illustration purposes simulated reply for AJAX GET simulated reply for AJAX POST (calculator)

ajaxsample/info.plist - Widget project file

Getting Started with AJAX on the Nokia Web Browser 1(12)

Article

Forum.Nokia.com

ajaxsample/icon.png

- Widget icon

Most of the JavaScript functionality runs fine when the main.html is launched in a browser from a local file system, either on desktop or on the S60 mobile browser. However, the AJAX part requires an online HTTP server which can provide the Ajax replies over the network. You can simulate the server replies by putting the two static XML files on the HTTP server. The widget functionality can currently be tested only in the S60 3rd Edition, Feature Pack 2 beta C++ SDK Emulator (launched in October 2007, available at Forum Nokia). Currently, there are no Feature Pack 2enabled devices publicly available. S60 3rd Edition, FP2 devices will be launched during 2008. The Forum Nokia Remote Device Access Web site does offer on-device testing of some units running prototype firmware. When the sample code is run in a desktop browser, the widget functionality is disabled. This is indicated with a red text in the widget tab. The sample code has been tested on a few desktop browsers and on the Nokia S60 3rd Edition, Feature Pack 1 and Feature Pack 2 Beta SDK emulators. Two S60 devices were used in testing, Nokia E61i (S60 3rd Edition) and Nokia N95 (Feature Pack 1). The test devices accessed the HTTP server over a WLAN connection. The Web application follows the best practises of Web development. It has a clean separation of content, presentation, and behaviour. The XHTML file is a well-structured document, which includes CSS and JavaScript from external files. The sample code runs in any standards-compliant browser, including the Web Browser for S60. Note that the sample code does not run in the S60 Services browser, available on the first S60 3rd Edition devices, since the Services browser only supports WML, not XHTML. JavaScript functionality This chapter explains the most important parts of JavaScript code in the main.js JavaScript file of the sample code. Code related to AJAX and widget is explained in the following chapters. First, some helper functions, $() and debug() are used. $() is just a convenience wrapper for calling the standard JavaScript function document.getElementById(). It is common in various JavaScript libraries to shorten the access to document.getElementById() via a helper function to improve the readability of the code. The getElementById() function is one of the most important functions in a browser. The debug() function provides help during development by giving an output of the given string into the debugging console in the Mozilla Firefox Web browser with the Firebug plug-in installed. This plug-in is a useful and highly recommended tool for Web development. The debug() function does nothing in the S60 browser, because there is no such plug-in available. Note that similar debugging plug-ins exist for other browsers, too. The JavaScript code is bootstrapped when the document is fully loaded by the browser. This is achieved by setting the onload()callback of the body element: <body onload="myonLoad()"> The myonLoad() function initializes the Web application by calling some initialization functions, as explained below. Note that the window.load function is not used since it is activated prematurely in Firefox, which is used to debug the sample code on the desktop. Tabbed interface Web applications today typically use a tabbed user interface to divide content into separate sections. Tabs allow more content within a page and quick access to other sections or content. Tabs are also easier to use than scrolling long
Getting Started with AJAX on the Nokia Web Browser 2(12)

Article

Forum.Nokia.com

documents. In the past, each tab was typically loaded individually on mouse click. Today, it is common that the content for all of the tabs is preloaded and only the main tab is displayed initially while others are hidden. Changing the active tab is immediate since there is no need to access the network. Tabs are useful in the mobile browsing context since they allow more content in a limited screen space and multiple sections without reloading the page. Avoiding reload is important in mobile browsing because of the bigger network latency. Page loads take more time than in a fixed network, and waiting for the page to load can be annoying for the user. In the sample application there are five tabs, all of them preloaded upon the initial document load. Only the main tab is initially displayed while the others are hidden. DOM elements are shown and hidden with the following code: elem.style.display = 'block'; elem.style.display = 'none'; // show element // hide element

Following good Web development practises and semantically correct content, the tabs are implemented with a single unordered list that has been visually formatted with CSS to look like horizontal tabs. Here is the XHTML: <div id="navcontainer"> <ul id="navlist"> <li><a href="#" class="current">Main</a></li> <li><a href="#">Clock</a></li> <li><a href="#">AJAX</a></li> <li><a href="#">AJAXCalc</a></li> <li><a href="#">Widget</a></li> </ul> </div> Note that there are no onclick()handlers in the anchors. Actually, there is no JavaScript at all in the XHTML code. The onclick() handlers are attached upon body load with the following JavaScript function: function associateTabClicks() { var tabs = $('navlist').getElementsByTagName('a'); for(var i=0; i < tabs.length; i++) { var t = tabs[i]; t.onclick = function() { onTabClick(this); return false; } } } Separating content and behaviour in this manner is recommendable when it improves readability, code reuse, and page maintenance. This technique is called unobtrusive JavaScript. Unobtrusive JavaScript is not used everywhere. In the example application, there are a few associated JavaScript handler functions embedded inline in the XHTML document itself. This is perfectly fine. Removing the handlers from the XHTML and having a JavaScript function instead to attach handlers should be judged case by case. In this short sample, the benefits of content and code separation may not be too apparent. However, in a longer Web application, the right balance of code and structure can make a difference. If the number of similar elements grows or the dynamicity increases, it may be beneficial to automate operations with JavaScript. Be aware of this technique and use it when appropriate. There is nothing new in the tab onclick() handler. When a tab is clicked, the onTabClick() function gets called. This function changes the display property of the tab DIV elements accordingly: the clicked tab becomes visible, others become hidden. Also, the active tab gets a new class "current" for visual standout. Note that the tab DIVs in the XHTML must be in the correct order! You could also use unique IDs for tabs instead, but this would be harder to automate. Again, it's a balance of structure and JavaScript.
Getting Started with AJAX on the Nokia Web Browser 3(12)

Article

Forum.Nokia.com

The getNextSibling() function is used to traverse the tabs in order. The standard elem.nextSibling() function is not satisfactory because there is variance among browsers (refer to the code). Tooltips Tooltips are common in Web applications. They can be implemented with CSS hover or link clicks. In a mobile browser, CSS hover is not always possible since there may not be a pointer at all. Therefore, it is better to use clicks to implement tooltips. This requires a bit of JavaScript. A common problem with tooltips and window popups in general in mobile browsing is that the popup window easily appears out of sight, outside the browser screen. Make sure that tooltips are visible. In the example application, a simple tooltip is always positioned in the upper right corner of the screen ("position: fixed"). The tooltip has a maximum width, no matter how large the page or tip text is. Positioning is achieved with CSS: #help { position: fixed; top: 5px; right: 5px; max-width: 170px; } JavaScript is only used to show and hide this popup, not to position it. Another lesson here: Use XHTML and CSS if they have a better solution than JavaScript. See the XHTML for an example of how the tooltip content is encoded as a hidden DIV within the anchor: <p>Another <a class="tip" href="#"><div>Another term explained here</div> thing</a> in this sentence.</p> This is also a typical way to construct tooltips: the content and the tip are carried in a single chunk. Consider the benefit when AJAX is used to load content from server: The text and the related tooltip are retrieved together. Having the tooltip simply in the upper right corner may not be the most optimal user interface solution. Positioning the popup with JavaScript is also possible, but this requires careful calculation of screen boundaries, and is not implemented in this example. Dynamic content With JavaScript, content can be manipulated dynamically in the page. There are many functions for DOM manipulation in JavaScript. The example uses just a few of these functions, such as document.createElement() and elem.appendChild(). See the "Insert Text" link on the right in the main tab. The onclick() handler of the link is associated with the following function: function appendText() { var newtext = $('testchunk').cloneNode(true); // clear the id so there will be no duplicate ids newtext.id = ""; $('tab1').appendChild(newtext); associateTipClicks(); } The new content is retrieved from a DIV with the ID 'testchunk'. The DIV is cloned and appended to the 'tab1' DIV. Without cloning, the chunk would be moved instead of copied into the new location. Note that tip onclick() handlers are attached to the new chunk in associateTipClicks().

Getting Started with AJAX on the Nokia Web Browser

4(12)

Article

Forum.Nokia.com

Clock The second tab of the application demonstrates the use of JavaScript timers in a browser. The example contains a clock that updates itself once a second. The clock runs completely in the browser, without server access. The timer is started with: setInterval(clockTimerCallback, 1000); setInterval is a standard JavaScript function that starts a periodic timer. Another function is setTimeout, which activates a one-time only timer. The clockTimerCallback() function is called once a second. It uses the JavaScript Date() object to retrieve the current time in the browser. Refer to the code to see how a paragraph is created dynamically and inserted in the DOM tree. Timers are the way to implement background processing in a Web application (note that JavaScript has no sleep function). Keep the code short and tight. Never run JavaScript code in a tight loop for long periods as this locks the browser! Note : The clock does not work correctly in the browser of the tested Nokia E61i device.

Ajax functionality
This chapter explains the AJAX functionality of the example application. The relevant code is located in ajax.js. There are two tabs in the example application that demonstrate the use of AJAX. The AJAX tab shows how to perform a HTTP GET operation. The AJAXCalc tab shows how to perform a HTTP POST operation via AJAX. At the heart of AJAX, there is a standard XMLHttpRequest object that is instantiated as follows: var req = new XMLHttpRequest(); All AJAX operations are performed through this object. Because using the object can get a bit low-level, the example application introduces a more convenient higher-level function called ajaxFetch() to perform Ajax operations. This function can be safely reused in other applications. The convenience function ajaxFetch() is: function ajaxFetch(url, param, callback, isXML, isPost) { var req = new XMLHttpRequest(); req.onreadystatechange = function() { if (req.readyState == 4 && req.status == 200) { if(!isXML && req.responseText != null) callback(req.responseText); else if(isXML && req.responseXML != null) callback(req.responseXML); else callback(null); } else if (req.readyState == 4 && req.status != 200) { // fetched the wrong page or network error... var err = "Error: "+req.status; alert(err); callback(err); } }

Getting Started with AJAX on the Nokia Web Browser

5(12)

Article

Forum.Nokia.com

if (!isPost) { req.open("GET", url+"?data="+escape(param), true); req.send(null); } else { // POST, doesn't work in the emulator! req.open("POST", url, true); req.setRequestHeader("Content-type", "application/x-www-form-urlencoded"); req.send("data="+encodeURIComponent(param)); } } Refer to Web sources for a detailed explanation on how XMLHttpRequest and its different notification states work. The ajaxFetch() function takes five parameters. URL is the server address to be called with the parameters provided in the second parameter (param). The callback parameter defines the JavaScript callback function that is called upon server reply or error. The isXML boolean value defines whether the reply should be XML or not, and finally isPost defines the call method to be used (GET or POST). The results of the ajaxFetch() function are delivered via the callback function. When the server request returns (server sends the results), the system calls the callback function with the results as the parameter. The callback function in its simplest form is: function processXML(data) { // insert XML via innerHTML $('mydiv').innerHTML = data; } Note that ajaxFetch() always performs an asynchoronous ajax request. This is recommended since a synchronous request blocks the browser for the duration of the call. GET vs. POST It is good to understand the difference between the AJAX GET and POST methods. The logic is similar to normal HTTP GET and POST: GET should be used when data is read from the server and POST should be used when data is written or sent to the server. The reason to have the distinction is that a GET reply may be cached by intermediate Internet proxies, while POST is never cached. In other words, a POST request always ends up in the originating server, while a GET request may not reach the originating server if there is caching in between. By understanding and following this distinction, your application will behave in a good manner in the environment with a multitude of other Internet applications. Note that the POST functionality does not work properly in the Nokia S60 SDK emulator and can only be used in real devices! Invoking an HTTP POST operation in the emulator issues an error message. Take this into account during development. Processing the reply AJAX is not restricted to transfer only XML. The AJAX reply from the server may come in various formats: XML, plain text, or (X)HTML, for example. Each format has its pros and cons. The example application uses XHTML as the reply format. As XHTML is a dialect of XML, also XHTML is valid XML.

Getting Started with AJAX on the Nokia Web Browser

6(12)

Article

Forum.Nokia.com

The XHTML format is commonly used because it is a structured document to begin with, and it can be processed via regular DOM functions or attached directly into the main document (without parsing strings manually with JavaScript). These are the main benefits of XML. Another consideration is how the reply from the server should be inserted to the main document. Can elem.innerHTML be used or should the standard DOM functions be used instead? While not an official standard, elem.innerHTML works in all browsers, including the Web Browser for S60. In fact, it works better than its standard counterpart document.importNode(), which does not preserve the structure of the received XHTML reply correctly in the current S60 browser. Therefore, it is recommended to use elem.innerHTML. The example application returns the following AJAX XHTML reply: <?xml version="1.0" encoding="UTF-8"?> <html xmlns="http://www.w3.org/1999/xhtml"> <div> <p>This comes from server, <i>time</i>: 11:55:08</p><p>This <b>second</b> paragraph also comes from server. Time is:11:55:08</p><p class="hid">Hidden paragraph here. May contain any data.</p> </div> </html> The example always uses XHTML as the reply format. In addition, the reply format must be reported for the XMLHttpRequest object, either as XML or HTML. The example demonstrates both cases. Having the reply as XML has the advantage that the received XML can be parsed with standard DOM functions. Refer to ajax.js for details. CSS class .hid is used to hide the third paragraph in the reply. Hidden data may contain logical data which is not meant to be displayed on the page, but transferred just for JavaScript. Before new AJAX content is inserted, the old content is removed from the target DIV: function replaceElem(target, source) { // remove earlier content from subpage-div var target = $('subpage'); while (target.firstChild) { target.removeChild(target.firstChild); } } The HTML reply is then processed like this: // process HTML reply function processHTML(data) { // hide progress animation gif $('waitpic').style.display = 'none'; // insert HTML via innerHTML $('subpage').innerHTML = data; } The example application includes an animated progress image that is displayed while the AJAX request is active. This is good practise especially in a mobile environment because of bigger latencies inform the user that a request is still ongoing. The AJAXCalc tab in the example application demonstrated the use of the AJAX POST method. The calculation line is sent to the server for calculation. The server has to perform the calculation, using PHP eval(), for example. The server reply is just a single paragraph: <?xml version="1.0" encoding="UTF-8"?>

Getting Started with AJAX on the Nokia Web Browser

7(12)

Article

Forum.Nokia.com

<html lang="en" xmlns="http://www.w3.org/1999/xhtml"><div><p>Answer is: 34</p></div> </html> The paragraph in the reply is directly inserted in the DOM via this function: function processAnswer(data) { var answer = data.getElementsByTagName('p')[0]; var newnode = document.importNode(answer, true); replaceElem($('calcresult'), newnode); } The first line extracts the single paragraph from the reply. The paragraph is imported to the current DOM and then inserted to the correct location with the utility function replaceElem(). innerHTML is not used here, because the reply only contains a single paragraph.

Widgets
Widgets are a future Web technology for creating stand-alone Web applications for Nokia devices. A widget is a small Web application, running independently outside the browser application. For the user, a widget appears just like a regular S60 application: A widget can be seen in the application list and run without first launching a browser. Widgets enable rapid development of new applications. Web developers who are not familiar with S60 C++ or Java development may create S60 applications with common Web technologies. Widgets lower the barrier to develop mobile applications and open new ways to utilize Web technologies in the device. Widgets are built with XHTML, CSS, and JavaScript. The files are packaged in a ZIP file with the extension.wgz. This package can then be installed on the device just like any other application. Widgets utilize the Web Run-Time (WRT) platform. Currently available in the S60 3rd Edition, Feature Pack 2 SDK Emulator, the Web Run-Time will be publicly available in the upcoming S60 3rd Edition, FP2 devices. The example application has been developed in the emulator environment. The Web Run-Time provides more JavaScript functionality than is normally available for regular Web pages used within the browser. There are a few new global JavaScript objects that provide access to the system. Refer to the Widgets section on Forum Nokia for more information.

Widget functionality in the example application

This chapter describes the widget functionality of the example application. Note that the entire example Web application explained above is included in the widget. This demonstrates the possibility that any Web page can be packaged as a widget. All the regular JavaScript and AJAX functionality are available in the widget. The example application contains 5 tabs. The last tab, Widget, contains widget-specific functionality and is disabled when the tab is viewed as a regular Web page. The functionality is enabled when the application is installed on a device as a widget. The actual widget JavaScript code is located in widget.js. Note that the XHTML file contains one widget-specific element: <embed> after the <body> element. The <embed> element is required for utilizing system information. Remove the comments around the <embed> element to enable the SystemInfo functionality.

Getting Started with AJAX on the Nokia Web Browser

8(12)

Article

Forum.Nokia.com

Structure A widget application must be packaged as a ZIP file with the extension .wgz. Note that the package must contain a single subfolder (ajaxsample/ in this example). In the example, there are only two new widget-specific files: info.plist and icon.png. info.plist is a mandatory project file that reports the files included in the widget. The example application has the following info.plist: <?xml version="1.0" encoding="UTF-8"?> <!DOCTYPE plist PUBLIC "-//Nokia//DTD PLIST 1.0//EN" "http://www.nokia.com/NOKIA_COM_1/DTDs/plist-1.0.dtd"> <plist version="1.0"> <dict> <key>DisplayName</key> <string>AJAXSample</string> <key>Identifier</key> <string>supercool.ajaxsample.widget</string> <key>MainHTML</key> <string>main.html</string> </dict> </plist> icon.png provides an icon for the widget. This icon is used in the S60 applications list after installation, and can be used to launch the widget. The icon is an 88-x-88-pixel .png image file. Installation To install the example application as a widget in the FP2 C++ SDK emulator: 1) Remove the comments around the <embed> element in the main.html file. 2) Rename ajaxsample.zip to ajaxsample.wgz. 3) Copy the file to the following directory of the installed FP2 C++ SDK: \Symbian\9.3\S60_3rd_FP2_Beta\epoc32\winscw\c\Data\Others Open the emulator, and use the File Manager to install the widget. Once the widget is installed, you should see its icon appear in the application list. Select and launch the widget. The widget occupies the whole screen and there are no scroll bars. The widget run-time is hidden from the end user. Features The example application demonstrates a few features that are only available through the Web Run-Time: Associating left and right softkey with custom menu actions. Reporting system status in the screen. Changing screen mode. Beep and vibration.

The Nokia Widget API offers extensive documentation on the use of the API. Refer to the API documentation. The menus in widget.js are created in a data-driven way from a prefilled JavaScript array. Functions createMenus() and onMenuItemSelected() can be re-used in your own widget applications. Just modify the menu_items array to suit your own widget.

Getting Started with AJAX on the Nokia Web Browser

9(12)

Article

Forum.Nokia.com

Note that as the widget has not been loaded from any URL, there is no base URL from which to retrieve the AJAX XML replys. Therefore, you need to write a full server URL in ajax.js, and place the AJAX XML reply files on the specific HTTP server.

Security
Security is an important factor in Web applications where JavaScript is being executed on the mobile device. The platform should be secure enough to make sure that Web applications cannot access any device resources without the users permission. For example, a Web application should not be able to access and forward user contact data without the users knowledge and acceptance. Security for mobile Web applications is enforced with the same means as on desktop: mobile Web applications and widgets are run inside a strict security sandbox. The sandbox is carefully engineered to minimize access points to the system services. Only a selected set of functionality, such as file upload and download, is available to Web applications. There is no functionality to access contact data or any other system data. Let's take one good example of the security sandbox in action. An HTML form may contain an input field for uploading a file to the server. The S60 browser also includes this upload functionality. In a hazardous scenario, adding harmful JavaScript code could be used to upload several files from the device to the server without additional user confirmations. By setting the file path to point to a system file, and automatically activating the submit function (and repeating this several times), an attacker could retrieve a number of system files from the device. Fortunately, this is not possible due to the security sandbox. The sandbox ensures sure that a path cannot be assigned via JavaScript to an input field of type file. It is possible to write data to other input fields, but not to an input field with the type file. Widgets have more extensive JavaScript API for their disposal but they do not pose a larger security problem. Additional functionality has been added only after thorough analysis of the benefits and risks. There are currently no new JavaScript calls that could access the system in a harmful way. For example, the new Widget SystemInfo API is for getting data, not setting data, applying the security sandbox philosophy. Currently, widgets are not certified and signed by trusted third parties like regular S60 applications are. This may change in the future, if the widget API is expanded to access more system data. Nokia is highly committed to strong security and developing ways for running applications safely in the mobile platform. Note : When using the JavaScript eval() function, do not run eval() for the data you have received from the network through AJAX. The eval:ed code cannot access system services because of the sandbox. Instead, it could cause a denial of service by running the alert() function in a loop, for example. The Web Browser for S60 supports full encryption via SSL. SSL encrypts all communication between the client and the server with strong cryptography. For example, banking applications utilize this level of security. HTTP basic and digest authentications provide good user authentication mechanisms.

Optimization
This chapter introduces some JavaScript optimization techniques that improve the user experience of mobile Web applications. Generally, these are the same techniques that are used on desktop browsers. However, optimization for mobile phones is more important because of the smaller bandwidth, hardware resources, and longer network latency. Tip 1: Minimize the network round-trips to the server. This is common for all Web resources, not just for JavaScript files. Round-trips are minimized by setting the "Expires" response header of the HTTP server reply. The header tells the browser that the file can be cached locally for the specified duration, and is not fetched repeatedly from the server with each page load.

Getting Started with AJAX on the Nokia Web Browser

10(12)

Article

Forum.Nokia.com

Tip 2: Use external and not internal JavaScript. That is, use: <script src="url_to_js" type="text/javascript"/> and do not use <script type="text/javascript"> ... </script> in an HTML file. External JavaScript files can be cached independent of HTML files which is good because JavaScript is usually more static than HTML. Just remember to set the Expires header. External JavaScript can be shared between pages. Tip 3: Minimize the size of the final output JavaScript code, for example with automation tools. Strip comments from your code. Strip excess whitespace. Minimize and pack the code, using GZIP compression. Remember to consider the good balance of the XHTML structure and unobtrusive JavaScript. Tip 4: If possible, do not run a long running JavaScript function on page load or anywhere else. Web applications do not multitask and the browser is thus blocked from the user input for the duration. If you have a long running script, think about speeding it up, for example by profiling the functions and improving the XHTML structure. Tip 5: Be conservative with AJAX calls. Do not poll frequently or do not poll at all. Maybe only use AJAX on demand. Fetch all the data in a single AJAX call instead of performing many smaller calls. Use XML format and parse each piece of data from the reply with the standard DOM functions. Send straight XHTML to avoid excessive parsing in the browser. Tip 6: Do not use JavaScript where CSS can be used instead. For example, menus and rollover images can be implemented with CSS instead of JavaScript.

Getting Started with AJAX on the Nokia Web Browser

11(12)

Article

Forum.Nokia.com

Copyright 2007 Nokia Corporation. All rights reserved. Nokia and Forum Nokia are registered trademarks of Nokia Corporation. Java and all Java-based marks are trademarks or registered trademarks of Sun Microsystems, Inc. Other product and company names mentioned herein may be trademarks or trade names of their respective owners. Disclaimer The information in this document is provided as is, with no warranties whatsoever, including any warranty of merchantability, fitness for any particular purpose, or any warranty otherwise arising out of any proposal, specification, or sample. Furthermore, information provided in this document is preliminary, and may be changed substantially prior to final release. This document is provided for informational purposes only. Nokia Corporation disclaims all liability, including liability for infringement of any proprietary rights, relating to implementation of information presented in this document. Nokia Corporation does not warrant or represent that such use will not infringe such rights. Nokia Corporation retains the right to make changes to this specification at any time, without notice. License A license is hereby granted to download and print a copy of this specification for personal use only. No other license to any other intellectual property rights is granted herein.

Getting Started with AJAX on the Nokia Web Browser

12(12)