This first release includes the following newspapers:

• Ansa
• Corriere della Sera
• Corriere dello Sport
• Gazzetta dello Sport
• Il Giornale
• Il Mattino
• Il Messaggero
• Il Sole 24 Ore
• La Repubblica
• La Stampa
• Tuttosport

You can download News Italy from the Ovi Store.

Specifically:

• Fixed the 3 star rating bug: now the correct rating will be shown for all items
• Broken content removed: items with missing pieces (e.g.: title, thumbnail) now will not be visible anymore
• Optimized data loading: new data is now loaded only when necessary, to optimize network traffic
• JavaScript code reduced, to diminish start-up time
• Other small fixes

So, this download is recommended for all users that have already downloaded Ovi Show!, and have experienced these or other issues. You can download it using the following link, or by using the Ovi Show! inbuilt update mechanism.

With different backgrounds, we all aim at providing useful information about the mobile environment, in all its aspects. From its manifesto:

The aim of this community is to share as much as possible information related to the mobile development using all the social networks and the new capabilities of the NET to make easier find updated contents and to create a deep feeling of connection between developers.

The journey is at the beginning, hope you’ll join in!

How to use it? Just add it to your home screen and, when you see some cool content, click on it and you’ll be redirected to its Ovi Store download page. Simple!

Ovi Show! is configurable through a settings menu, that you find opening the widget from its icon, in your phone’s menu. You can choose which content categories to filter, and how to sort the content retrieved from the store, choosing from “Top Free”, “Best Seller” and “New”.

Once you have chosen the desired settings, don’t forget to click on “Save”, or your preferences will not be applied.

Being just  a first release, Ovi Show! can be improved thanks to your feedback, so please post here your comments or thoughts about it!

Ovi Show! is available for download here:

Note: to use Ovi Show!, your Nokia device must support home screen widgets. Currently the devices supporting home screen widgets are: Nokia N97 and Nokia N97 mini.

]]> http://www.jappit.com/blog/2010/05/23/explore-the-ovi-store-on-your-home-screen-with-ovi-show/feed/ 8 http://www.jappit.com/blog/2010/03/17/forum-nokia-web-developers-library-1-9-available/ http://www.jappit.com/blog/2010/03/17/forum-nokia-web-developers-library-1-9-available/#comments Wed, 17 Mar 2010 09:20:57 +0000 pit http://www.jappit.com/blog/?p=1339 Forum Nokia has just updated its excellent resource for mobile Web development, the Web Developer’s Library, adding a lot of resources to support the design and development of Web Runtime widgets.

Changes in this last release include:

• Samples and packaging information for Platform Services 2.0
• Guidelines and how-to’s for home-screen widgets
• Optimization of performances and battery life

If you’re a mobile Web developer, check it out!

For single-person and small developer teams, the whole Symbian process could be a not suitable option. For this reason, I’ve looked for an alternative deployment approach that could bypass this process. The approach presented here is based on a delayed deploy model, meaning that the API Bridge engine is not deployed with your application, but in a successive moment: actually, it is deployed only when the application needs it.

How this can be achieved? Basically, there are 2 possible options to implement this model, and they’re based on:

• AppManager API from Platform Services
• Local HTTP calls

Using the AppManager API to check API Bridge

If the target devices support Platform Services, the AppManager API can be used to retrieve the list of installed applications, and so to check if API Bridge is installed on the device itself.

The code below shows how this can be achieved by using JavaScript in a WRT widget. The same approach can be easily ported to ActionScript, and so used in a Flash Lite application.

var apiBridgeFound = false;
var apiBridgeCheckError = null;
 
var so = device.getServiceObject("Service.AppManager", "IAppManager");
 
var criteria = new Object();
criteria.Type = 'Application';
 
var result = so.IAppManager.GetList(criteria);
 
if(result.ErrorCode == 0)
{
	var iterator = result.ReturnValue;
 
	var application;
 
	while((application = iterator.getNext()) != undefined)
	{
		if(application.Uid == '0x20023710')
		{
			apiBridgeFound = true;
 
			break;
		}
	}
}
else
{
	apiBridgeCheckError = result.ErrorMessage;
}

The code works by checking the UID of all the installed applications, comparing them with the API Bridge UID (0×20023710). This code snipped defined 2 variables, that can be used to check for API Bridge availability:

• apiBridgeFound: if true, it means that the API Bridge engine is installed on the device. If false, the API Bridge engine is not installed.
• apiBridgeCheckError: if not null, it means that there was an error while checking for API Bridge, due to the AppManager API. In this case, the application cannot actually know if the API Bridge engine is installed or not.

So, once these 2 variable have been set, the application can perform the most appropriate operation, based on the AppManager call result. The code snippet below shows a possible implementation:

if(apiBridgeCheckError != null)
{
	alert("There was an error! " + apiBridgeCheckError);
}
else if(!apiBridgeFound)
{
	if(confirm("You have to install API Bridge to continue, press OK to download it"))
	{
		widget.openURL('http://www.yourserver.com/APIBridge_v1_1.sis');
	}
}
else
{
	alert("API Bridge is already installed on the device!");
}

And below you can see this code running on a Nokia 5800 XpressMusic:

Using local HTTP calls to check API Bridge

Since the API Bridge engine works as a local HTTP server running on the mobile phone, the other possible approach is to make an HTTP request, and to check if any response from API Bridge comes.

Note: this approach works by using the API Bridge default port (9080). There are no guarantees that this port number is fixed, and that it will not be changed in future API Bridge releases. For this reason, my advice would be to use this second approach only when Platform Services are not available.

The code below shows how to make a request to the local API Bridge HTTP server, and how to check if it’s running or not: if it is running, the response status of the XMLHttpRequest object has to be different than zero.

function pollApiBridgeServer(_callback)
{
	var request = new XMLHttpRequest();
 
	request.open("GET", "http://127.0.0.1:9080", true );
 
	request.send(null);
 
	request.onreadystatechange = function()
	{
		if( request.readyState == 4)
		{
			if(request.status != 0)
			{
				_callback(true);
			}
			else
			{
				_callback(false);
			}
		}
	}
}

The approach described here can be used also when using API Bridge from other languages, as Flash Lite or Java ME. Anyway, when working with Flash Lite, in the scenario where API Bridge is not yet installed, you will incur in the typical (and horrible) error popups, that will inform you (and so the user) that the network call failed.

How to use the code above? First, define a callback:

function pollApiBridgeCallback(apiBridgeInstalled)
{
	if(apiBridgeInstalled)
	{
		alert("API Bridge is already installed on the device");
	}
	else
	{
		if(confirm("You have to install API Bridge to continue, press OK to download it"))
		{
			widget.openURL('http://www.yourserver.com/APIBridge_v1_1.sis');
		}
	}
}

Then, just call the pollApiBridgeServer() method by passing a reference to this callback:

pollApiBridgeServer(pollApiBridgeCallback);

Pros and cons

Using one of the two approaches discussed above as some important advantages over the standard API Bridge deployment mechanism:

• You don’t have to build a SIS package
• You don’t have to sign your application to distribute it
• You will save money

On the other side, these approaches have the main drawback on the user-experience side, since your users could be asked to download and install an additional component when they start to use your application. Anyway, this event will happen only once at most, so it could be considered reasonable in most scenarios.

The document focuses on three kind of applications: websites, web apps, and stand-alone Adobe Flash applications, covering all topics involved in design and development of a RIA, from development tools to user experience design and evaluation, from testing to going to market.

Mobile offers significant opportunities for RIAs. The ability to access data and information anywhere there is a suitable network connection is of significant appeal to mobile users. The knowledge that their data is also securely stored on a remote server, regardless of what happens to the mobile device, is a significant attraction as well.
With many hundreds of millions of Nokia devices already in the market place that can run RIAs now, there has never been a better time to go mobile with your RIA.

Check it out!

Ovi Maps offers a complete and flexible platform to build rich location-based services. By providing a consistent set of components and libraries, Ovi Maps allows developers to build both a web a mobile version of their applications with minimum effort.

Interested in what can be done with Ovi Maps? Here are some links taken from the article:

• Interactive features of the Ovi Maps Player
• Lonely Planet showcasing its Ovi Maps Player mash up
• Associated Press showcasing its Ovi Maps Player mash up

Next steps? Check out the whole article: Ovi – Opportunities for developers, and then sign up for the Ovi Maps beta program!

For this reason, in this article I’ll try to explain how to setup a single environment that may allow development on both technologies, so leveraging the development phase from continuous swaps between different IDEs, and by boosting it all thanks to the powerful Eclipse platform.

Installing Eclipse and plugins

First of all, download Eclipse. I currently use version 3.5 on my own machine, but other versions should work as well.

Once downloaded, proceed installing the following plugins:

1. Aptana plugin for Eclipse: http://www.aptana.org/studio/plugin
2. Web Runtime plugin for Aptana: http://tools.ext.nokia.com/wrt/prod/aptana/plugin/
3. FDT plugin for Eclipse: http://www.fdt.powerflasher.com/developer-tools/fdt-3/download/

After you’ve installed the above plugins, you’ll notice two new project types in your Eclipse project wizard: Flash and Nokia Web Runtime projects.

Basically, these 3 plugins are all you need to start developing both Web Runtime and Flash Lite applications. Anyway, FDT needs some further configuration steps to properly work with Flash Lite apps.

Configure the FDT plugin

FDT needs to know how to compile your Flash Lite projects. You basically have two choices: use the Adobe Flash IDE, or use MTASC.

• The first choice is available if you have already installed a copy of a Flash IDE, and can be configured by going into the “Window” -> “Preferences” -> “FDT” -> “Tools” -> “Flash” settings panel. Once there, just enter the paths of your Flash IDE and Player.

• The second one, quicker and free, needs MTASC to be installed on your machine (you can get it here), and configured in the “Window” -> “Preferences” -> “FDT” -> “Tools” -> “MTASC” panel. I actually prefer this option, as it allows you to develop Flash Lite applications also on machines where the Flash IDE is not available.

Add Flash Lite-specific classes and functions

FDT uses the standard ActionScript 2 classes to allow you to compile your Flash Lite project. Anyway, these lack some Flash Lite-specific classes and functions, as ExtendedKey and SharedObject.addListener() method, that have to be manually added, as also explained here.

To do this, go into the “<ECLIPSE_ROOT_FOLDER>\configuration\com.powerflasher.fdt.core\.config\core\as2\” folder and:

1. Create a file called “ExtendedKey.as” with this content:

   intrinsic class ExtendedKey
   {
   static var SOFT1:String = "soft1";
   static var SOFT2:String = "soft2";
   static var SOFT3:String = "soft3";
   static var SOFT4:String = "soft4";
   static var SOFT5:String = "soft5";
   static var SOFT6:String = "soft6";
   static var SOFT7:String = "soft7";
   static var SOFT8:String = "soft8";
   static var SOFT9:String = "soft9";
   static var SOFT10:String = "soft10";
   static var SOFT11:String = "soft11";
   static var SOFT12:String = "soft12";
   }

2. Open “SharedObject.as” and add these lines to the class definition:

   var scope : Object;
   static function GetMaxSize() : Number;
   static function addListener(objectName:String, notifyFunction:Function) : Void;
   static function removeListener(objectName:String) : Void;

3. Now, switch to the “<ECLIPSE_ROOT_FOLDER>\configuration\com.powerflasher.fdt.core\.config\topLevel\” folder, open TopLevel.as, and add this function definition:

   function fscommand2(command:String, parameters:Object):Void;

If you plan to use MTASC to compile your Flash Lite applications, the above changes have to be performed also to the ActionScript files used by MTASC itself. These files are typically placed in the “<MTASC_ROOT_FOLDER>\std” folder: go there and repeat the 3 steps above for ExtendedKey.as, SharedObject.as and TopLevel.as.

That’s all! Now let’s give FDT a quick test to check if all is correctly configured.

Testing the FDT configuration

Creating a new Flash Lite project is straightforward: just select “New Flash project” from the Eclipse project wizard, and then choose a name for your project. In the Project Language section, be sure to select “ActionScript 2″.

Once the project has been created, switch to the “Flash FDT” perspective by selecting “Window” -> “Open perspective” -> “Flash FDT”.

Now, create the project’s main class. The only required method to be implemented is the static main(), that has to perform all the initialization operations:

class com.jappit.flashlitetest1.MainMovie
{
  public function MainMovie()
  {
  }
 
  public static function main(container : MovieClip) : Void
  {
    Stage.align = "TL";
    Stage.scaleMode = "noScale";
    container.createTextField("tf", 1, 0, 0, 100, 100);
    var tf : TextField = container["tf"];
    tf.text = "Hello World";
  }
}

Now, if the FDT configuration was properly done, you shouldn’t get any errors. So, if all is ok, open the “Run Configurations…” panel from the “Run” menu.

Under “FDT MTASC” create a new launch configuration. In the “Main” sub-panel select the main class created just above.

Then, go to the “Miscellaneous” sub-panel and check the “Start SWF after compilation” option. This way, the SWF will be immediately launched, after each build, in the Eclipse’s internal SWF viewer.

Now, all is ready to be tested: just run the created launch configuration, and enjoy your new Flash Lite app

And here’s the generated SWF running on a real device:

What’s next?

Next tutorials will focus on using both Web Runtime and FDT plugins to develop Flash Lite-enabled widgets. So, stay tuned!

In this first version, the online simulator allows you to pick one of 4 devices (Nokia 5800 XpressMusic, Nokia N95 8GB, Apple iPhone and HTC Dream), and see how the MobileJoomla! website looks on that.

MobileJoomla! allows you to turn your Joomla web site into a mobile one, compatible with all the existing mobile phones. For more information, you can take a look at MobileJoomla! Wiki.