Andreas Jakl's Forum Nokia Blog

Fundamental changes in native Symbian OS development

mopius — Fri, 27 Mar 2009 11:41:39 +0200

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.

Accelerometers Redefine the Game Experience

mopius — Thu, 19 Mar 2009 19:25:13 +0200

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

Nearly nobody noticed the Nokia 5500 Sports, most likely the first phone equipped with an accelerometer that was accessible for 3rd party developers. gBoarder (application for recording snowboarding statistics like the number of crashes or jumps) and CarMeter (measures g forces when driving a car) were one of the few applications that made use of it - already released in February 2007.

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).

Mopoid Workshop - Your Own Arkanoid-like Game for S60

mopius — Wed, 14 Jan 2009 00:23:36 +0200

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

Probably the largest and longest free workshop for S60 development is now available in a completely rewritten and updated version. The unique aspect: everything is explained based on a fully working Arkanoid-like game called Mopoid.

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!

Explore .sis-files Online

mopius — Sun, 04 Jan 2009 18:27:09 +0200

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

Ever wondered what's inside your .sis files? Which certificate was used to sign it? Does it have the right capabilities? Of course there are utilities that can help you with analyzing the contents. One of them is the SISXplorer utility, or you can also use the sisinfo Python-script. Both are available for free.

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.

Automatically Calling Back Saves Money

mopius — Tue, 26 Aug 2008 18:18:15 +0300

Auto Call Back can help you to save money.

Starting with today, I'm now also on one of the hugely popular all-inclusive phone tariff plans. In Austria, every operator currently has a plan with a certain number of minutes (usually 1000 or more) included - essentially, a flat rate for around €19/month.

On the other hand, many friends and relatives have minute-based plans, which can be rather expensive if they're calling to other operators.

Rationally, it'd be the best if I call someone with a minute-based plan back and don't accept his call. In this scenario, nobody of us pays anything (extra). Obviously, it's a bit of work - you have to discard the call, go to the call history and call back.

Automatic Call Back

Already two semesters ago, two students (Dominik Brandlberger and Daniel Haslinger) developed a solution to this called "Auto Call Back" (why always invent strange names if it can be that simple?). The whole call-back process is automated by the application.

The result after one semester is a prototype and no commercial application - after all, both didn't have any serious Symbian OS development experience before and the whole issue turned out to be not so easy.

Apparently, you can't easily cancel calls that you don't own through the public CTelephony-APIs of S60 3rd Edition-phones - it only seems to work if you accept them first and immediately cancel them. However, this means that the caller already has to pay up to one minute, no matter how short the call was. Therefore, the application now cancels the calls through simulating the red key. The disadvantage here is that the mailbox has to be turned off for rejected calls.

But how does the app know for which contacts to do it? After the first initial experiments with an own database, the best solution turned out to put all those contacts into a special group. This also allows the user to easily manage the call-back contacts through the normal contacts-app of the phone; the call-back app doesn't have to re-invent the wheel.

The prototype is available for free, but of course not yet ready for real-world usage. It lacks many features and is by far not bug-free. Also, you need to sign it yourself through the Open Signed-process from Symbian Signed.

If anyone is clueless what application to develop next, I'd be very interested in getting a finished and polished application that can do exactly what the prototype can do. Or is there already anything around on the web that I didn't find?

Efficiency Boost - New Carbide.c++ Panic Lookup Plug-In

mopius — Mon, 04 Feb 2008 14:28:21 +0200

Everyone who has spent at least a few hours developing in C++ for Symbian OS will know about Symbian OS system error and panic codes. No doubt one of the most “famous” is the KERN-EXEC 3 (null pointer exception). But what if you encounter an E32USER-CBase 71? What is the error -5? Nobody can know all the codes by heart, so you have to look them up:

The new PanicLookup-Plug-in allows comfortably searching panic and system error codes.
Of course, the panics are documented in the SDK-doc. But accessing it means going through the start menu to open the SDK doc and then navigating through a huge hierarchy of the index to get to the list: Symbian OS v9.x -> Symbian OS reference -> System panic reference -> KERN-EXEC -> ... go through a long list to find your code... The search function will list the codes as well, but somewhere hidden in lots of results. Error codes are even more difficult to find.
The famous NewLC Symbian OS Error Codes-list. This has been one of my favourite pages since I started Symbian OS development. A very comprehensive list, containing almost all codes.
However, you have to start the browser, fire up the bookmark or search in Google for something like “Symbian error codes” and then search the error on the page. Additionally, it does not list the panic codes.
Similar lists are of course available at the Forum Nokia Wiki. But it has the same restrictions as the previous list, requiring you to fire up the browser and get to the relevant page somehow.
Some Excel-spreadsheets are floating around the web from time to time. They’re nice, but who really wants to fire up Excel just for looking up an error? Again, no panic codes included.
There’s a Python-tool that allows easily looking up the error codes on the command line. But you have to remember it, fire up the command prompt and enter some command to fire up the tool (which you have to remember, again). Again, only error codes and no panics.

Unless you are a perfect developer with centuries of experience, you will regularly experience errors codes. Therefore, the idea is obvious – an integrated error and panic code lookup tool for the Carbide.c++ IDE would be a considerable timesaver.

PanicLookup-Plug-in

Wolfgang Damm and Andreas Pum, two “Mobile Computing”-students from the University of Applied Sciences in Hagenberg, have just finished a plug-in for Carbide.c++, which allows fast and efficient lookup of error codes.

Quite some time was spent on optimizing the integration, in order to maximize the efficiency. For example, the plug-in automatically parses the debug output for panic codes – you just have to switch to the plug-in window to read the description, which is in turn directly taken from the latest Symbian OS 9.3 system panic reference.

Features

Additionally, the plug-in allows manual lookup, featuring specialized auto-completion. Once you entered the first few letters of the panic category, you can jump to enter the number by pressing TAB. The standard Symbian OS error codes can be retrieved by searching for “Error -5” or in the other direction by entering “KErrNotSupported”.

By default, the devices do not display the error codes so that end-users are not confused. To enable error display, copy an empty ErrRd-file to the C:Resource-folder of your phone through the pkg-file of your application. It’s even easier if you just install a small ErrRd-SIS file, which creates this file for you.

Download

The plug-in along with documentation and installation instructions can be downloaded for free from symbianresources.com. Of course, the developers would like to hear your feedback, so don’t hesitate to comment here or email them if you find it useful or if you have any ideas on how to further improve the plug-in!

For additional comfort, the plug-in automatically parses the debug output and instantly displays the description, which was taken right from the latest SDK documentation.

Checking your code with SymScan in Carbide.c++

mopius — Tue, 30 Jan 2007 12:22:45 +0200

A few days ago, I was appointed as one of the new Forum Nokia Champions and am really glad to be part of the team! Nearly at the same time, the developer resources portal at http://www.symbianresources.com/ was updated with the latest material from the Symbian OS-courses that I held this winter-semester at the University of Applied Sciences in Hagenberg.

Many typical Symiban OS-topics are covered in a very detailed and up-to-date fashion, for example the Descriptors-part already contains exercises for the RBuf-classes. Generally, I try to explain everything in a rather graphical way with (for the most part) some code samples.

Apart from introducing this site, I want to post about one thing at the Forum Nokia Blogs, as I have not found similar instructions elsewhere.

SymScan and Carbide.c++

SymScan is a tool from Symbian that checks your code for potential problems as well as if it adheres to the Symbian OS coding guidelines – especially related to Leaves. I think it’s very useful to check the code from time to time, e.g. it can easily happen that you forget to add or remove the trailing L of a function name when tweaking your code.

After some research, I found a solution on how to integrate this tool with Carbide.c++. It’s not perfect – due to the way it’s integrated, the project will be compiled before running this tool. But that shouldn’t be an issue at all. To integrate it, follow these steps:

In Carbide.c++, select Run -> External Tools -> External Tools...
Create a new tool called SymScan for the “Symbian”-perspective.
Set the location of the SymScan-Tool (e.g. C:Program FilesCommon FilesSymbiantoolsSymScan.exe).
For the “Arguments”-field, enter: “${resource_loc}” – including the quotes (“”).
Add it to the favourites menu (Common-tab of the External Tools-Menu).
When a Symbian OS source file is open, run the tool through Run -> External Tools -> SymScan. The results will be displayed in the Console-window.