Andreas Jakl's Blog

We're kicking of the webinar series for the new Series 40 Touch phones tomorrow! The first session will walk you through the new Java ME APIs introduced in the Developer Platform 2.0.

The packed agenda covers all the important topics that you will need to know about when you're moving your Java ME apps to the new touch UI:

•  Introduction
  • Platforms & Versions
• New features for developers
  • UI
  • LWUIT
  • Text Input
  • Touch Input
  • Sensors
  • Location & Maps
• App Compatibility
• Publishing & Monetization
• Resources
   

The recording of the first webinar session is online for viewing. The downloadable version of the slides is slightly extended, featuring some more details than in the 1h webinar. 

You can download the full source code of all the apps shown during the presentation - the blue text box in the top right corner or the slide always refers to the full example being demonstrated.

JavaME-Touch-Examples-v2.0.0.zip

As a special bonus, the example package and the downloadable slides also include a few exercises (+ the corresponding solutions), so that you can put your new knowledge about the APIs into use right away! The excercises are both based on 3D graphics:

• In Monkey Touch 3D you'll add drag & pinch support to view the 3D model of a monkey, and add orientation support to dynamically switch the app between landscape & portrait mode, depending on the physical orientation of the phone.
• Car Race 3D let's you extend an endless 3D racing game with support for controlling the car using acceleration sensors, instead of physical keys (which would no longer be availble on the new touch phones)
   

Registration

In different webinars during the following days we'll also look at the design aspect and the IDEs (both the new Nokia IDE for Java ME as well as NetBeans). Every session is held two times, so that you can join no matter which time zone you live in.

Register for the webinars now!

Recently at the WIMA conference in Monaco, Rovio revealed the new Angry Birds Magic together with Nokia. It unlocks additional levels when you touch the phones of friends, or if you find special promotional tags. This is done using Near Field Communication (NFC) technology.

How can you implement such exciting features yourself?

During the very same conference, Nokia hosted an NFC workshop where we were guiding through our new NFC developer offering. After an introduction by Sixten “Sigge” Sandstrom, Riikka Kivela explained the NFC architecture in Symbian devices. At the end of the event, Tuukka Ahoniemi from Digia quickly dissected their ShopWizer NFC app, followed by Jure Sustersic talking about business opportunities with NFC and Nokia.

During the main two hour tech session in the middle, I had the opportunity to first briefly introduce the large audience to Nokia’s NFC developer offering. After the environment setup with the latest Qt SDK 1.1 and Qt Mobility 1.2 Beta, you’re ready to code. At the moment, a Nokia C7 updated with a pre-release Symbian Anna is needed to test apps. This firmware version will be released soon, but is not publically available yet. Once you get the new version on your existing C7, the operating system's backend for Qt's NFC APIs are instantly available!

After those preparations were done, we went right into coding the first NFC app. Instead of starting totally from scratch, we took the Corkboards example from the Qt SDK and extended it with NFC functionality. The original app has several dynamic notes pinned to different corkboards; you can easily switch between boards by swipe gestures.

After following the step-by-step instructions of the NFC workshop materials, a new note instantly appears when touching an NDEF formatted NFC tag – the contents of the message are shown on the screen (URI and Text NDEF records are parsed). If you then press the little NFC flag glued to each note, the note’s current contents are written back to the tag. You can download a slightly extended version of the solution from Forum Nokia Projects.

Thanks to the separation of the NFC handling engine in C++ and the UI written with Qt Quick, the engine itself can simply be plugged into every other project to augment it with NFC. After the workshop, I saw the NFC engine working in an existing Cover Flow-like image browsing app; this was done in a matter of minutes without any modifications to the engine itself.

The second example was the NFC Chat. Simply by touching two phones, you can send chat messages back and forth. On the tech side, this is all handled by NFC, where two devices communicate using LLCP. Touching is enough to establish the connection between the app running on both phones.

This time, we created a new app from scratch – which can be done in a matter of minutes when using the Qt Quick Designer. The NFC target discovery is then very similar to the previous example – only that we’re this time setting up sockets to communicate to another device, instead of reading messages from a tag. A server socket is then used to send messages to the other device; the client socket receives our UTF-8 formatted text messages.

The workshop materials are now all online for you to enjoy:

• Workshop slides: Qt Quick basics, NFC and NDEF messages basics, step-by-step walkthrough for both code both examples
• NFC Corkboard example
• NFC Chat example

To find out more about developing NFC apps, also take a look at the new NFC Wiki page. More event coverage - including an interview with Mark Selby about Nokia's NFC plans - check out Nokia Conversations.

On this weekend (Friday and Saturday, 5th + 6th of March), the University of Applied Sciences in Hagenberg (Austria) will host the Nokia App Forum Alps event.

During the conference, you will hear about technologies like MeeGo and Qt, plus about the Ovi services and success cases like Wikitude. In the evening, a Mobile Monday (this time on a Friday) will provide plenty of opportunity to extend your network.

The developer sessions are planned for Saturday. In small groups you will learn about interesting topics like the Qt Mobility APIs or touch and gesture events in Qt. You can take your laptop with you and start to code, as these sessions are partly held as hand-on trainings.

Until the end of March you have the chance to submit your Maemo / Symbian applications and also concepts to the competition. You have the chance of winning Nokia devices like the N900 plus price money of €17,000 (in total).

Attending the event is totally free of charge (of course with free food included as well). So there’s hardly a reason not to plan a short trip to Hagenberg if you live in the Alps region! Shuttle buses from Vienna are available for free as well.

Sensors like the acceleration sensor or compass (magnetometer) have been the base for most innovative and hyped applications in the recent years – Wikitude is one of the examples for this (ported to Symbian by Wolfgang Damm, Mobile Computing alumni). On Symbian phones, developing sensors has been possible for a long time: development on the gBoarder snowboard application for the Nokia 5500 Sports started in the end of 2006 and used the acceleration sensor for creating unusual statistics like the longest jump or the number of crashes – all based on the acceleration sensor.

However, accessing the sensors from source code wasn’t always easy. In the beginning, only a few of the sensors were accessible. Even though many S60 phones already featured a light sensor, it wasn’t public. The situation got better with the S60 Sensor Framework, which unified the access to various different sensors. However, many sensors were still missing and it still wasn’t possible to simulate sensors or to write own plug-ins as a third party. Therefore, development always required an actual mobile phone.

The mSense Middlware

The mSense middleware manages, controls, simulates and aggregates various sensors for mobile devices.

We wanted to change this with the mSense middleware. Over the past 1.5 years, Dominik Gusenbauer and Daniel Rothbauer have been developing a library that finally unifies the sensor access and gives the much-needed flexibility. When we started with the project, we decided to go with the just-released Qt for Symbian port, so the project is fully Qt based and has been adapted to the new additions over time. The latest version of the official Qt Mobility extensions is now also based on a more flexible plug-in architecture.

What are the advantages of mSense? Low-level sensor nodes encapsulate platform-level APIs for accessing hardware sensors, simulated sensors or web services. High-level sensor nodes (channels or aggregators) combine information from other sensor nodes to acquire and extract particular sensor information and generate new knowledge. For example, GPS, an accelerometer and a compass could be combined to provide a more accurate inertial sensor node.

Last year, we have published the current status at a small conference, now we have just released the full source code of the middleware under the GPL / Apache license. A small demo application is also available, which allows you to play around with all the sensors in your device and also demonstrates larger scenarios – like publishing your collected context information on Facebook.

Several nodes and channels are already integrated, but you can extend the middleware through own plug-ins. All nodes can be based on log-files to simulate the full sensor information.

Low-level sensor nodes

• Accelerometer: Sensor provides 3D acceleration of device at a configurable rate.
• Alarm Sensor: Sensor provides information as well as notifications of current active alarms.
• Calendar Sensor: Sensor provides current calendar data (meetings, etc.).
• Device Orientation: Sensor provides current device orientation and attitude (rotation information).
• GPS Location: Sensor provides GPS based location information of the device.
• Magnetic North: Sensor provides current heading of device with respect to magnetic north.
• Magnetometer: Sensor provides 3D geomagnetic flux density information.
• Profile Sensor: Sensor provides information about the current device profile.
• Weather Sensor: Sensor provides actual weather information via a web-service for a configurable area.

High-level sensor nodes (channels)

• User Availability: Sensor provides information of the current user status (if the user is available or not). This is done by a combination of the calendar and device profile data.
• Movement Status: Sensor provides information if the user is currently moving or not. This is done by a combination of the GPS location and the accelerometer sensor.
• Position / Address: Sensor provides current position information of the user based on current GPS location. An additional a reverse geo-coder is used to retrieve the current position description (address data) for the GPS location.

Last week, I’ve been giving a talk at the first Austrian Android Developers Day (a2d2, organized by T-Mobile) about Android as a mobile operating system. It has been a very interesting experience – is there something that Nokia can possibly learn from this event?

Let’s start with the location: the event took place in Vienna. It was fully booked; nearly all attendants were from Austria. Most developer events that I know of try to gather an international audience and are therefore hosted in the larger cities. But the a2d2 clearly demonstrated that it’s perfectly feasible to host regional developer events. After all, the country size doesn’t say anything about the quality of developers: I've been told that when taking the number of inhabitants into account, most entries/finalists from the Android developer challenge came from Austria.

One of the most interesting aspects about the event was the mixed audience. About one third was actually developing for the platform, while another third didn’t really know a lot about Android beforehand! This is unique compared to most developer events, where attendants are experienced developers or managers who wish to extend their business. At the a2d2, students, small and big companies were all thrown together and enjoyed talking to each other. For example, several of our students (some from 2nd semester!) presented their projects at the tech sessions; on the other hand, there have been representatives from large companies like Red Bull or bwin. This resulted in a very relaxed atmosphere that lead to many new ideas.

The choice of date and time is the last fact I’d like to point out: the a2d2 started in the late afternoon and lasted until 10 pm. This made it a lot easier to attend after work, instead of having to take several days off to drive to some big developer event.

Developer Events

Obviously, huge events like the recent Nokia Developer Summit in Monaco are important as well. These serve the business target group and bring together the dedicated core of development companies, who can and want to spend the time and the resources required to travel there. The events demonstrate the dedication of Nokia to their business and show the value that lies in the ecosystem – which is bigger than on any other platform.

However, smaller companies, individuals and students are more or less left out. They need regional events that are easy to reach and cheap to attend. These events help to build the regional network that's needed to acquire new projects. And: this group is where the real innovation comes from. While they do not generate money for the platform or Nokia in the short term, it’ll pay off in the long run.

The interaction of Nokia with bloggers and with dedicated members of the community (through the FN Champions program) is excellent. Additionally, companies that are really interested in working on Nokia platforms are taken care of through the FN Launchpad / Pro programs.

Now, the goal should be to take care of the rest – developers who are not yet working on the platform, but might be interested. And those who are already doing something, but don’t have the resources to travel to big events or spend time on engaging in the online community. This is vital for creating a buzz around the platforms and for showing developers that they are being taken seriously. Just imagine how great it is for a student to be able to demonstrate his project at an event organized by a company like T-Mobile – or Nokia!

Just announced rather silently in the Symbian Developer Newsletter, one of the biggest changes in the world of Symbian OS development is on its way. It's all about the letter L, which represents the new idiom of L-classes. According to the documentation PDF: "The L prefix denotes that these classes may be Liberal when it comes to Leaving, while being Leave-safe themselves."

When working with Symbian OS and of course especially when teaching it, the biggest issue have always been the descriptors. While they are a nice concept and a good example of polymorphism, even the simplest string modifications often required looking up some code examples or documentation. Now, the new LString class can finally take care of automatically resizing its buffer (on the heap) and memory cleanup. Additionally, the LString is also derived from TDesC, making it possible to use it with all the standard Symbian OS APIs.

Other changes include the possibiliy to put everything from the two-phase construction into a single C++ constructor, by using macros and special templates. Makes the code easier to read and shorter, and is therefore also a welcome change. Memory management (plus cleanup stack) usage has also been simplified through the use of new class templates (LCleanedupX and LManagedX), which provide automatic resource management.

We'll see how these new additions work out in real life, but at least on paper, they do sound promising and make it easier for newcomers to start developing with Symbian OS. The only problem is that those new concepts are added to many other already existing idioms, increasing the total amount of information you have to know when you really want to do a lot - and it'll not be possible to get entirely rid of old descriptor classes like the HBufC, as they're still used by many system APIs. Also, that these resource management tasks are done automatically usually means less efficiency compared to the manual way that has always been in Symbian OS - one of the reasons why the OS is so fast, even on low spec hardware. Most probably, you'd use native Symbian OS C++ code for the more low-level and highest performance code (and do resource management manually), and prefer Qt or Widgets instead for other applications in the future.

Another interesting sidenote: if you take a look at the new header files, you'll see that they are already released under the "Symbian Foundation License v1.0" (even though the source code is not included yet) and that they are contributed by Nokia. In case I didn't miss anything, this is most probably the first public third party contribution to the Symbian Foundation. Let's hope we'll see more of those welcome additions in the future - even though it means that I'll have to rewrite many parts of the Symbian OS course slides when there's time...

Read more about the L-classes at the Symbian Developer Network, especially at the pdf linked to at the end of the article.

CarChallenge is controlled through the compass of the mobile phone.

A traditional compass only works when it is held horizontally. As Paul Coulton recently described in his Forum Nokia Blogs posting, the Nokia 6210 includes a 3-axis magnetometer. Through some calculations, it is possible to find out the absolute direction in which the phone is facing, no matter how the phone is oriented. The S60 Sensor Framework provides a processed sensor output that gives you the degrees relative to the North Pole.

Compass Applications

Traditional applications that greatly benefit from a compass are apps like the “Magic Wand” (recently described by Paul; our students have also been working on a similar app during the winter semester): just point the phone to a building and the phone tells you what it is. By combining information from GPS, the accelerometer and the compass, it is possible to determine where the user is pointing his phone and for example to augment the camera picture with additional information about what he sees.

Another possibility would be to use the same method for showing information about the stars and constellations. Just point your phone to a star and instantly get information about it. I’m not yet aware of any such applications for S60 phones that integrate the magnetometer. General planetariums are of course available, like for example Solun’.

A few days ago, I’ve been chatting with Philipp Breuss, one of the winners of the first Android challenge and now teaching Android at our Mobile Computing department in Hagenberg. He told me that there are currently two such planetarium applications that make use of the magnetometer for the Android platform; one of them being his own. An easy to understand concept that has great potential.

Compass Games

The compass is of course not limited to applications. A novel idea is to use it for controlling games. Christian Feldbacher and his colleagues Philipp Rakuschan and Clemens Stangl have been busy developing a 3D car game with a clever artificial intelligence over the last two semesters - called CarChallenge. As an experiment, we decided to include the compass as an additional control method.

Playing the game with the compass requires physical action – the car drives in the absolute direction you’re facing. Want to turn the car left? Just turn yourself to the left. How to turn the car around? Make a 180° turn yourself (e.g, from North to South).

In contrast to the compass, the acceleration sensor is only able to measure relative movements on this axis. The rather small resulting sidewise acceleration forces would not be sufficient for accurate game control. Instead, accelerometer based car games usually rely on tilting the device – something that can be measured easily through the different distribution of gravity to the three accelerometer axes. However, there would not be a difference at all if you’re facing to the North or the South – the gravity is always just directed downwards. Through the compass, the game is now able to integrate the absolute direction in which you’re facing.

His video on YouTube demonstrates the look and feel of the game, as well as the compass-based control mechanism. Of course, steering via the compass isn’t well suited for playing the game in a bus and is probably problematic for long gaming sessions. However, it’s great fun!

As a next step, why not make a game that determines how often you can turn around before you get dizzy and fall to the ground (detected by the accelerometer, to use the available sensors to their full extent)?

CarChallenge is essentially finished and will be released shortly. Watch the project page at symbianresources.com for updates!

Accelerometers fully integrated into the game design - turn your phone to change the gravity of the environment!

When Nokia finally released the R&D API for the N95, the boom began and many acceleration sensor-based applications appeared. Many of them are useful (pyPozentica), others are just for fun (Light Sabre). And of course, there are some entertaining games as well (Groove Labyrinth, pyWuzzler).

Especially with the iPhone lacking any keyboard, many game concepts simply were not really possible – as an effect, the accelerometer got to be an accepted control method for commercial games. Racing games are a good example, where the tilt of the phone simulates a steering wheel. Much like in ShakerRacer, which uses the same concept for controlling a real car.

However, most of the games just use the acceleration sensor as an input method that fits to the game (up to some degree). Only very few games completely base the whole game concept on the use of the accelerometer. One of those few games has been developed by the Mobile Computing students David Berger and Stefan Poremba from the Hagenberg University o.a.S.

SlideEscape / SlidersEdge

On the first sight, the game SlideEscape / SlidersEdge could be seen as a normal jump & run. The fact that the left/right-movement of the character can be controlled by tilting the phone and jumping by quickly pulling the phone towards you is nice, but not something new either.

The innovation comes from the fact that turning the phone changes the gravity of the virtual game world. An example: the character is standing in front of an uncrossable abyss. How to get over it? Turn your phone upside down to walk on the ceiling and safely pass the depths!

Through this mechanism, the acceleration sensor not only influences the movement, but is directly integrated in the whole game experience as well as the level design. It’s not just an add-on that could be easily replaced by a key control mechanism (like in a racing game), but an essential part of the game.

The video on YouTube demonstrates how this works in real life:

The project is available as a free download from David’s official homepage, as well as from the project page at symbianresources.com.

Please note that the game is a prototype and therefore not really bug-free. The main game is a Java ME application. As it still isn’t possible to access accelerometer data from Java ME on Nokia phones, a native S60 application is provided as well, which runs in the background and provides acceleration data to the game via an internal socket (does not lead to data charges, even though the Java ME game warns you upon start-up).

Draw abstract objects on the screen; they will instantly get physical properties!

Even if the dedicated physics PCI card for the PC, the PhysX by AGEIA, did not really succeed in reaching the mass market, it increased the awareness that the game experience is greatly enhanced if physics are accurately simulated. Nowadays, NVidia has bought this company and physics simulations are often calculated directly on the 3D graphics hardware.

The oldest game I can remember that heavily relied on physics simulation was called The Incredible Machine. Released in 1993, players had to place various objects in a 2D plane to solve puzzles. This included placing machines, lights, ropes, balls and much more.

Another game, Bridge Builder, has now been around for quite some time (first release in 2000) and also uses physics as the main gameplay element. Players have to build bridges and ensure that they do not break. Later examples like World of Goo follow a similar basic concept, but make the game a lot more accessibly by integrating a different scenario and pleasant graphics.

Another possibility for games that mainly rely on physics simulation is represented by Crayon Physics. In a pre-defined scenario, players have to move an abstract object (like a circle) from its starting position to a target. This can be done by drawing 2D objects (like other circles that behave like balls, rectangles, or ropes); physical attributes are applied to those. Of course, solving the levels gets very challenging over time.

Mobile Physics

Even if advanced 3D physics like found in Half Life 2 would still be too much for today’s mobile devices, they are certainly up to the task of running 2D physics engines. A good example is Numpty Physics, available for free for the Maemo-platform.

David Berger, a student in the 3rd semester of Mobile Computing in Hagenberg, has now ported the open source 2D physics engine called Chipmunk to the S60 platform.

With the help of the OpenC++ libraries, it was possible to run the engine without any serious modifications. As the foundation for the user interface, he used the Mobile Paint example from Nokia. All objects that you draw on the screen instantly get physical properties and move according to the current gravity level as well as collisions with other objects.

David’s video on YouTube demonstrates how well the engine works. Unfortunately, there were some problems with regards to the screen update and the TV out when drawing – but as you can see in the video, the engine works totally fluid and fast. Now, I’m looking forward to seeing the first physics-based games on the S60 platform!

More information, the download of the demo plus source code is available on David’s website as well as on the project website on symbianresources.com.

Develop a full-blown Arkanoid-like game - and play it!

While reading through 76 pages and 175 slides, you will explore most of the important concepts behind Symbian OS / S60 – including using the UI designer of Carbide.c++, scalable vector graphics, localizable text and of course all the traditional topics like the cleanup stack, descriptors or periodic timers.

The Origins

In 2004, I prepared my very first Symbian OS workshop at the University of Applied Sciences in Hagenberg. Its aim was to give a compressed overview of the most important concepts of development for S60 – in form of a large, fully working game. Students would implement certain parts; the specialities of native Symbian OS C++ development were explained right when they were relevant. I still remember working through the whole night on the day before the workshop, testing everything ten times to make sure that everything really worked as expected.

The Update

Back then, the tutorial was based on the free Borland C++ Builder Mobile Edition, which already featured a UI designer. While the IDE had potential, it was slow and buggy. Soon after, it was abandoned.

The mobile world moves quickly, and the tutorial soon got outdated. Still based on S60 1st Edition, the game wouldn’t run on current devices. Also, Borland C++ Builder does no longer exist, with the (much better) Carbide.c++ IDE now being the standard for Symbian OS development.

As it would have been a pity to simply let dust settle on Mopoid and watch it disappear, I decided to take on the task of updating the tutorial for today’s environment. The game has now been greatly extended and improved - for example, it includes support for scalable screens. Of course, most parts of the tutorial had to be rewritten as well. The slides are completely new.

The Future

The workshop was just published on the Symbian Developer Network and is now also available from symbianresources.com. The whole tutorial might be a bit too steep if you don’t have any experience with Symbian OS at all, but for a little more advanced developers, it’ll be interesting to see how all the idioms and concepts fit together in a real game.

The source code is released using the GPL license. Mopoid already supports level files, saving the high score and much more. If someone wants to add more features or levels, it’d be great to release a polished game without some rough edges to the public in the future!

SpyPhone / BabyPhone is a Python-application that monitors the surrounding sound level.

At the core of every mobile phone, there’s still the voice channel. Therefore, every phone is equipped with a microphone that’s optimized at recording the human voice. Add the aspect that the phone is mobile and that the owner usually carries it with him all the time, it’s no surprising thought that the phone can be used as a remote surveillance tool.

BiBUnit is based on a rather simple concept and essentially accepts incoming video calls if a previously set number is calling, allowing you to monitor the surroundings through the phone camera. SpyManager on the other hand lets you take remote snapshots of through phone, also through a PC server application.

Similar, but with a different usage scenario is Phone Guardian, which allows remotely controlling aspects of the device in case it was stolen from you. SecureMe is built based on the same concept.

SkyeSpy turns the situation around and alerts the observer autonomously. The application on the "spy"-phone is able to monitor the audio level of the surroundings. If it exceeds a threshold, the phone will contact a previously paired phone per SMS or a call.

There might be other applications around that I missed, but the list should give you an overview of what is currently possible on a S60 phone.

SpyPhone / BabyPhone

Now the students Clemens Rainer and Daniel Haslinger went up to the task of implementing this application via PyS60 and have released their results for free as an open source application called SpyPhone or BabyPhone.

Like the SkyeSpy-application, the phone constantly monitors the audio level of the surroundings. If a pre-defined threshold is exceeded, the phone automatically calls the number of a pre-defined "agent".

A good use-case would be the monitoring of a baby. When it starts to cry, the phone will automatically call the number of the parents. As the call is a normal voice connection, they can hear what’s actually happening. If it sounds serious, it’s about time they pay a visit to the child.

Technically, the application is constantly working on two tasks. The first records the sound into a file on the device. In the meantime, the other task analyzes the previous sound file. The next step would be to add more sophisticated sound processing to the application. Instead of just calculating the volume like SkyeSpy does it as well, it would be possible to measure the frequencies in the recorded sounds and only react if these are in the range of the human voice.

As the SpyPhone / BabyPhone application is available as open source, it provides an ideal starting place for your own audio experiments in Python for S60.

whatisinmysis.com analyzes the contents of your.sis files.

But what if you don't want to install an application just to take a look at the contents of the .sis-file? Or what if you are working on a friend's PC that doesn't have the same, perfect setup as your own? Stefan Damm got into this situation from time to time, and then decided to make an online tool available.

The website whatisinmysis.com is an online interface to the sisinfo Python-script. You simply upload the .sis-file to the website, and it will display all the information about its contents. Easy, fast and free. No setup on your PC is required. The privacy statement on the site ensures that your uploaded files are deleted immediately after analysis.

whatisinmysis.com will display the following:

• Contents of .sis file and installation directory of each entry
• Capabilities of each executable (exe, dll, .pyd)
• Certificate chain

If you find online services like the new one from Stefan Damm interesting, you might also want to bookmark WhyTheFuckWontMySisFileInstall.com. It has got a slightly different focus: it provides information about the signing status and prints reasons or suggestions why installation of this .sis-file might fail on a device.

Of course, whatisinmysis.com has now also been added to symbianresources.com.

As you will most likely have noticed, Qt for S60 is going to be really big. Therefore, it’s a good idea to start learning Qt as soon as possible.

One chance to do this is going to be the first public “Qt on S60” webinar (as announced by Lucian Tomuta), which will be broadcasted in just two days (December 17th).

To get an overview of what Qt can do for you and how to get Qt to do just that, you might additionally want to take a look at the new Qt course materials that have just been published at symbianresources.com.  (More)

TDS-S uses NFC technology to secure your skis.

Near Field Communication (NFC) is mostly associated with micro payment systems or access solutions. These are the ideal use cases for rather slow, but contactless information transmission over distances of up to some centimeters.

Theft Deterrent System for Skis (TDS-S) is a novel approach to using NFC technology – it protects your skis from being stolen.

The students Markus Eder, Florian Lettner and Carina Madlmayr from the Mobile Computing department of the FH Hagenberg are fond of skiing – rather natural, considering they’re from Austria. Everyone who has already been on a slope in his life will know the slightly worrying thoughts when you go into a ski hut: “Are my skis still going to be here when I return?”

Especially if you know that there are more than 10,000 registered ski thefts every year only in Austria, it’s certainly not inappropriate to think about securing your expensive skiing equipment. Naturally, cameras outside of the restaurants usually don’t help much. If you consider what everyone is usually wearing when skiing, you’ll usually have a hard time to identify the thief should the police ever catch him. The only commercial solution that’s available today is to the skis together using a lock (like the simple bike locks). Unfortunately, this isn’t the most comfortable solution.

Near Field Communication is here to help

Surprisingly, NFC is the technology that proves to be incredibly useful to prevent ski theft, while still offering all the comfort you might want to have. The project “Theft Deterrent System for Skis (TDS-S)” is essentially about pairing the boot with the ski and doesn’t let the thief step into the binding if the secure code doesn’t match.

This is done by putting an MIFARE-tag into the boot. A small RFID-module is inserted into the ski and connected to one of the new bindings that electronically control the operation of the binding – like the Atomic Neox EBM. A Near Field Communication-enabled mobile phone or a PC is able to pair the boot with the ski. If anything else than the trusted boot steps into the binding, it refuses fastening and doesn’t let the thief drive away with your skis.

The project is currently still in development - you can read more about it at symbianresources.com or the project homepage. The first prototype has already been published and managed to be among the winners of several global competitions – the 1st Austrian NFC Developer Competition as well as the NFC Forum Global Competition. Who knows how much longer it’ll take until skis, which started out as simple wooden planks (The word “ski” meant “a stick of wood” in Old Norse) will finally turn into a product full of high tech.

NFC Congress

By the way, if you're interested in NFC, the place to go is the third annual NFC Congress from the 24th - 26th of February, 2009. It'll take place again in Hagenberg. After the successful previous two events, it has now turned even bigger and now consists of the conference, a workshop, an exhibition, a competition and even an IEEE scientific workshop day. Register now!

It will certainly be interesting to have technology from Dolby integrated into phones, like it was demonstrated at the CTIA Wireless in 2008. However, there is no precise information about future roadmaps or products.

What the students Stefan Damm and Arnold Ahrer from the Mobile Computing-department of the University of Applied Sciences in Hagenberg (Austria) created is a small solution to enable real surround sound through mobile phones - called Mobile Surround Sound.

It works by using four different mobile phones, which have to be placed into the corners of the room. Essentially, the phones are turned into speakers, albeit with a bit more intelligence than the usual speaker. A central control PC is connected via WLAN to the phones and is able to control them in real time.

Once all phones are connected, the PC starts the sound on all phones at the same time. The user can now move the sound source on the graphical interface of the server. This automatically adjusts the volume of the different speakers, thus leading to the impression that the sound is moving around in the room.

Also great to put your phones to good use if you've already got too many of them ;-)

The application was developed by Stefan and Arnold as a small project for the Interaction Technology course during the summer semester. It is written in Java (Server) / Java ME (Client) and is available for free (open source).