What does this mean practically? From the official announcement:

Any individual or organization can now take, use and modify the code for any purpose, whether that be for a mobile device or for something else entirely.

And more:

All 108 packages containing the source code of the Symbian platform can now be downloaded from Symbian’s developer web site (tiny.symbian.org/open), under the terms of the Eclipse Public License and other open source licenses. Also available for download are the complete development kits for creating applications (the Symbian Developer Kit) and mobile devices (the Product Development Kit).

Even if already announced, this step is huge for the mobile ecosystem, and I could not agree more with the words of Eben Moglen, Founding Director, Software Freedom Law Center:

Software freedom on mobile hardware is absolutely necessary to the preservation of privacy and the encouragement of innovation in mobile technology, and to protecting the freedom of the Net overall.

Well done, Symbian!

Why I think it’s great? Because you have to perform 2 mouse clicks and wait a couple of seconds, and you can continue working on your WordPress (upgraded) blog without any other hassles.

Looking at that made me think about the update process of mobile applications.

In many cases, applications are simply not aware of the availability of updated versions, and so users are supposed to manually check (e.g.: going on the publisher website) for updates. What does this mean? Simple: terrible User Experience (if even we can say that), and in most cases old (and possibly bugged) versions of your applications running everywhere.

For this reasons, developers started to implement their own “updates-availability-check” systems, letting their applications check for updates and prompt the user about the availability of those. Anyway, this approach has 2 important drawbacks:

• users must open the application in order to have it check for updates
• the very same logic (checking for updates, downloading and installing the updated application) is replicated in each application

Luckily enough, mobile platforms are fast moving toward an integrated approach, based on the concept that updates have to be pushed to the user. Examples of this are iPhone and Maemo, both notifying the user in case of available updates.

While this is currently the best approach from a UX point of view, the same makes me wonder if a better approach (maybe totally transparent to the user?) could ever be possible, considering all the technology and security concerns of such an approach when talking about mobile devices.

Current features of SMS TAG include:

• Ability to choose a color for each label
• Text based search of SMS messages (currently, Inbox only)
• Integrated auto-update functionality: widget can update without the need to install a new version
• Integrated SMS forwarding and deleting

SMS TAG is available for free on the OVI Store: download SMS TAG from OVI Store.

Next versions will add some useful features, as a more powerful search functionality. If you have suggestions or feedbacks about SMS TAG, please leave a comment here, or on SMS TAG OVI page.

With S60 5th edition, Web Runtime and Flash Lite gained access to Platform Services: this means that you can finally access application data, location, sensors and system information directly from your Flash Lite application or WRT widget.

Talking about Web Runtime, new Service APIs were introduced to let you integrate those functionality with simple JavaScript code.

Among the various concepts to learn when dealing with these APIs, there is the synchronous/asynchronous way of calling each single method: this, apart from being a difference from a programming point of view, brings to different approaches and results on your WRT Widget.

This “WRT Service API Synchronous and Asynchronous calls” article on Forum Nokia Wiki will guide through the details of these differences, explaining how to use both of them, and underlining possible advantages of the one over the other.

As always, any kind of feedbacks is welcome!

Today, we’ll see how it is simple to create a FlashLite ringtone with caller-id support and an application that allows users to easily set and unset it.

Step 1: The FlashLite ringtone

To start, we’ll build a really simple FlashLite ringtone.

Let’s start building a simple interface, with these elements:

Now it’s time to add some ActionScript to our interface. So, let’s open frame 1 of our Actions layer.

Important note: when using KuneriLite from a ringtone SWF, you MUST use port 2001.

First, we’ll define a method to retrieve caller infos, and display it, depending on the returned data:

var loader:LoadVars = new LoadVars();
 
getCallerName();
 
function getCallerName()
{
	commandOutput.text = "Getting caller's info... ";
 
	loader.onLoad = callerNameHandler;
 
	loader.load("http://127.0.0.1:2001/Basic/ring?klCommand=callerid");
}
function callerNameHandler()
{
	commandOutput.text += this.toString();
 
	if(this.klError != 0)
	{
		callerName.text = "Command error: " + this.klError;
	}
	else if(this.klName != undefined)
	{
		callerName.text = this.klName;
	}
	else
	{
		callerName.text = this.klNumber;
	}
}

And then, let’s add the call answer/reject functionality to our ringtone. Two other KuneriLite calls will do the job (note that we’ll reuse the LoadVars instance defined above):

answer.onPress = function()
{
	commandOutput.text = "Answering call... ";
 
	loader.onLoad = callCommandHandler;
 
	loader.load("http://127.0.0.1:2001/Basic/ring?klCommand=answercall");
}
reject.onPress = function()
{
	commandOutput.text = "Rejecting call... ";
 
	loader.onLoad = callCommandHandler;
 
	loader.load("http://127.0.0.1:2001/Basic/ring?klCommand=hangupcall");
}
function callCommandHandler()
{
	commandOutput.text += this.toString();
}

Important note: since KuneriLite ringtone plugin already handles device answer and reject keys (the green and red one) you could avoid implementing your custom buttons in ringtone SWF (thanks Jukka for the reminder!)

Step 2: Setting and unsetting the ringtone

Now, it’s time to build the “main” SWF application, that is the one that the user would launch from phone menu to manage its FlashLite ringtones.

As usual, let’s create a basic interface, with this layout:

Now, let’s add the necessary ActionScript code to our Buttons.
This is for the enable button:

enableButton.onPress = function()
{
	commandOutput.text = "Enabling ringtone..";
 
	var loader:LoadVars = new LoadVars();
 
	loader.onLoad = handleResponse;
 
	loader.load("http://127.0.0.1:1001/Basic/ring?klCommand=enableringswf&klPath=ringtone.swf");
}

And similarly, this is for the disable button:

disableButton.onPress = function()
{
	commandOutput.text = "Disabling ringtone..";
 
	var loader:LoadVars = new LoadVars();
 
	loader.onLoad = handleResponse;
 
	loader.load("http://127.0.0.1:1001/Basic/ring?klCommand=disableringswf&klPath=ringtone.swf");
}

And here’s the handler, used by both commands calls, to print out the KuneriLite response error code:

function handleResponse()
{
	commandOutput.text += " Error code: " + this.klError;
}

Step 3: building and testing

Building a KuneriLite app is easy as always, but you need to follow these 4 specific steps to make the ringtone correctly work:

1. Select Ringtone plugin
   
2. Place your ringtone SWF in a separate folder, containing only that SWF, and then select it on Wizard Step 2
   
3. Select the ringtone setter as main SWF
   
4. Since Ringtone plugin needs signing, on Step 3 fill in the certificate infos
   

Once done, just compile and transfer your SIS on your phone, install and launch it:

• on main app screen, click the enable button
• check the command output, to see if the command executed successfully: you should see this message

  Enabling ringtone... Error code: 0

• if yes, just close the app and call your own phone, and your FlashLite ringtone will magically appear!
• within the ringtone SWF you will see the caller’s name (if available on your phonebook), otherwise its phone number
• to answer or reject the incoming call, simply use the buttons we previously placed on stage

That’s it!

Conclusions

Now, add this with the other KuneriLite features, and you could end up having:

• browsable ringtones catalogs, directly downloadable from your FlashLite app
• ringones for specific contacts (a phonebook plugin would be great!)
• location-based ringones!

Isn’t this enough?

For all nightly coders, SDK is already available here.

New improvements and features are available for quite every supported technologies, but biggest ones seems to be related to Flash Lite and Web platforms.

Both Web and Flash Lite developers now gain access to a previously unavailable (at least, without using any external engine, like KuneriLite or Janus) set of infos and platform services that will allow them to finally build full-blown apps with native functionalities, and no more simple web-aware ones.

A quick tour of these will explain why we should expect great Flash Lite (and Web) apps in the next future:

• Calendar
• Contacts
• Logs
• Messaging (SMS and MMS)
• device location and landmarks
• system information
• sensors

Nokia direction towards Web technologies was already clear (Widget Contributions Contest has just finished on Forum Nokia Wiki), but now we finally have a platform that could let those technologies literally explore new paths.

Ready?

Forum Nokia Code Camps are stimulating workshops that are specially designed for mobile developers around the globe. These free Code Camps combine speaker presentations with hands-on coding to help you get up to speed quickly on a wide range of mobile development topics.

This will be my first participation to a Forum Nokia Code Camp, and I’m really excited!

So, the question is: will you be there?

The setup process is really simple: you must register, and then download the software (a single SIS installer). Done that, you’re ready to share all your phone content! More in details, here are the features of the last release:

• Guest and friend user accounts
• Calendar – manage your calendar, and share your availability for others too
• Messaging – SMS inbox/outbox and SMS sending
• Phone log – view missed calls
• Contacts – manage your contacts easily
• Blog – tell stories on your journeys
• Camera – share instant pictures
• Gallery – browse pictures taken with camera phone, and share them to others
• Guestbook – visitors can leave their comments
• Contact me – visitors can send instant messages to you
• Presence – share your status and device state
• Web chat – communicate with friends

The concept behind it is really attractive: have your web server always with you, and share things without the need to upload anything anywhere. Even letting users use your phone features, like taking instant picture with the phone camera!

For sure, at least here in Italy, network speed and operator plans should evolve a bit to fully allow this technology to be really used. Also, with a lot of tools to upload you content on your favorite sites, I’m a bit unsure about the real target, in terms of users and possible usages, of this product.

Said that, I definitely think It’s cool, at least for real geeks!

And, for the curious out there, if you want to browse my phone content, you can simply go to: http://jappit.mymobilesite.net.

Practically, you interact with KuneriLite engine via localhost calls. For example, if you want to get recursive folder listing starting from current application base path, you can simply do:

loadVariables("http://127.0.0.1:1001/Basic/file?
klCommand=dir&klPath=\\&klArgs=/s", targetMc);

Their tool comes with an integrated wizard and an emulator, to be used with Symbian S60 3rd edition SDK Maintenance Release, to allow full development without the need of a real device.

Now they’ve just released 0.9.6.1 version, that fixes issues with Flash Lite 3 and add new cool features, as you can read on their blog, and it’s more than ever worth a try!