Developer case study: WebGate share UIQ 3 porting advice for P990 and M600 applications

My Rating Score

Back

April 26, 2006 Developer case study: WebGate share UIQ 3 porting advice for P990 and M600 applications	[Back]

WebGate specializes in the development of Symbian OS

mobile applications and are based in Bulgaria. Their call management application, Advanced Call Manager, is a successful UIQ 2.1 product for the Sony Ericsson P910 smartphone, available through global and regional distribution channels.

Now Advanced Call Manager has been ported to UIQ 3 to be preloaded on the Memory Stick that accompanies the new P990 and M600 UIQ 3-based phones.

Members of the WebGate team outline the development challenges they faced during this porting process, share code examples solving specific problems and give their top five tips for getting started with UIQ 3 development.

WebGate and UIQ-based phones
WebGate found working with the latest UIQ platform and some of the first mobile phones to support it to be both very useful and exciting

"WebGate has a long history in developing applications for Symbian OS and all its user interfaces. Nurturing and training an in-house team of experienced Symbian OS developers in line with our clear strategic focus in this technological domain has resulted into a line of successful mobile applications based exclusively on Symbian OS," says Spartak Kabakchiev, Managing Director of WebGate.

"Our experience has shown that Sony Ericsson UIQ phone users tend to add more third-party software than any other smartphone users, so naturally Sony Ericsson UIQ devices have always been our primary target," continues Spartak Kabakchiev.

"Our Advanced Call Manager application has been of great interest to end-users of Sony Ericsson UIQ-based phones and we have always been keen to make our application compatible with new device releases. Our users tend to upgrade their device to benefit the latest technology and features and we expect most of them to upgrade to the new P990 and M600 phones."

About Advanced Call Manager
Advanced Call Manager is a very flexible tool for the management of incoming calls on Symbian OS mobile phones. The application enables end-users to set different rules for different callers: accept, reject, forward calls, send a personalized SMS, play a personalized greeting or mute the ringer.

With Advanced Call Manager end-users can create and schedule different profiles. The application saves time by taking over the management of incoming calls, leaving the caller unaware of the end-user's availability and providing the end-user with the perfect alibi.

More information about the application can be found here>>

WebGate's development process

The WebGate team's application development process is a customized process similar to Rapid Prototyping – usually their development runs through the following major steps:

Discussion and definition of the concept in tight collaboration of both technical and marketing departments
Implementation of a quick prototype as a proof-of-concept
Evaluation of prototype and concept fine-tuning
Implementation of second prototype release according to the refined requirements
Evaluation of new prototype and concept fine-tuning
Implementation of third prototype release according to the refined requirements

The above process is cyclic, in continuous refinement until the product is optimized.

"Another interesting aspect of our development process is the QA and release management phases," explains Spartak Kabakchiev. "Due to the increasing amount and diversity of mobile phones on the market, testing and QA processes are staged to both in-house and external phases."

Ensuring that the numerous differences in the target devices and user environments are taken into account and end-users have a flawless experience with the application is a hard task. The WebGate approach to handling this challenge is to include a large number of external reviewers and beta testers with particular emphasis on:

test preparation including user/device sampling
test results analyses and validation
pilot/test launch (if necessary)

Call management examples.

Development challenges

In the course of WebGate's work to port Advanced Call Manager to UIQ 3 for the P990 and M600, the team had to cope with some new challenges:

1. Porting "on-the-fly" with regularly released firmware/SDK versions
Since WebGate's application is very much related to the telephony, they needed on-device testing. This meant that they had to wait for firmware updates which, when received, required a prompt response for customization and debugging, as well as on a few occasions adding unplanned modifications of the software later on.

2. Multiple language versions
As Advanced Call Manager is included on the P990 and M600 Memory Stick, WebGate had to translate the application into 21 different languages including Hungarian, Greek, Russian, Arabic, Chinese and the EFIGS languages (English, French, Italian, German and Spanish). The difficulty to find experienced translators locally along with the challenge to validate their work with third-party proof-reading, was an issue for the WebGate team.

This posed the following challenges:

translation of system terms
length of translated words due to screen size limitations
consistency of translations
quality assurance of localized versions of the application

"We wanted our products to be translated by native speakers, so we managed to find an agency that employs freelance native speakers from all over the world but we soon found out that all the specific commands in the application have to be explained carefully and double-checked for consistency to make sure the user experience is the same with all the localized versions," recollects Spartak Kabakchiev.

3. Beta testing on the P990 and M600
As these phones were not shipped at the time the application was being ported, the WebGate team found the lack of external beta testers to be a great difficulty. This impeded their internal QA process and they relied on internal resources, in-house simulations and ongoing assistance from the Sony Ericsson Developer World support team to overcome these issues.

"The Developer World support team were very helpful, replied to all our questions promptly and were responsive when we asked for clarifications or just needed to discuss some issues," comments Antony Stoyanov, Project Manager Mobile Solutions at WebGate.

Specific porting issues and solutions

As for the porting itself, WebGate found the tricky part to be the limited stack space on the P990 and M600. The reasons for stack exhaustion were almost impossible to trace on the real target as they appear as random, unexplained crashes.

The team found three workarounds to this problem and share them below:

1. Use heap allocated objects instead of stack
Be careful with the allocated objects and the cleanup. Always remember to destroy all the heap allocated objects after they are finished with.

A typical example is local TBuf objects which consume a valuable stack space. If you need more than a few hundred bytes allocated to a TBuf, then use HBufC. Here is an example of the recommended approach to the problem:

void CMyClass::GetMessageTitleL(const TDesC& aFileName, TDes& aTitle)
{
//some calculations here
//and finally we have some result into aResult
}

void CMyClass::GetFirst(TDes& aResult)
{
//some calculations here
//and finally we have some result into aResult
}

void CMyClass::GetSecond(TDes& aResult)
{
//some calculations here
//and finally we have some result into aResult
}

//
//Here is the problematic implementation which can cause a crash, because of stack exhaustion on the target device:
//
void CMyClass::ShowMessageWrongL()
{
TFileName fullFileName; //TFileName is TBuf<256>
fullFileName.Copy(KPath);
fullFileName.Append(iFileName);

TBuf<64> title;
GetMessageTitleL(fullFileName, title);

TBuf<256> messagePart1;
GetFirst(messagePart1);

TBuf<256> messagePart2;
GetSecond(messagePart1);

TBuf<512> message;
message.Append(messagePart1);
message.Append(messagePart2);

CEikonEnv::Static()->InfoWinL(title, message);
}

//
//Here is the modified implementation to cope with the problem; it is a little bit longer because of using heap descriptors:
//
void CMyClass::ShowMessageRightL()
{
HBufC* fullFileNameH = HBufC::NewLC(256); //+fullFileNameH
fullFileNameH->Des().Copy(KPath);
fullFileNameH->Des().Append(iFileName);

HBufC* titleH = HBufC::NewLC(64); //+titleH
TPtr title = titleH->Des();
GetMessageTitleL(*fullFileNameH, title);

CleanupStack::Pop(); //-titleH
CleanupStack::PopAndDestroy(); //-fullFileName
CleanupStack::PushL(titleH); //+titleH

HBufC* messagePart1H = HBufC::NewLC(256); //+messagePart1H
TPtr messagePart1 = messagePart1H->Des();
GetFirst(messagePart1);

HBufC* messagePart2H = HBufC::NewLC(256); //+messagePart2H
TPtr messagePart2 = messagePart2H->Des();
GetSecond(messagePart2);

HBufC* message = HBufC::NewL(messagePart1.Length() + messagePart2.Length());
message->Des().Append(messagePart1);
message->Des().Append(messagePart2);
CleanupStack::PopAndDestroy(2); //-messagePart2H, -messagePart1H
CleanupStack::PushL(message); //+message

CEikonEnv::Static()->InfoWinL(title, *message);
CleanupStack::PopAndDestroy(2); //-message, -titleH
}

2. Distribute the code in separate methods
The objects which are placed on the stack are freed after the program finishes the execution block in which they were created. So if for some reason you must use stack objects, you can distribute them into separated methods by keeping the stack object's size under approximately 500 bytes.

Here is an example of using a switch statement:

//example A, which can cause a crash, because of stack exhaustion on the target device
switch (x)
{
    case 1:
    {
        //Block of code using TBuf
        .........
        .........
        .........
        break;
    }

    case 2:
    {
        //Block of code using TBuf
        .........
        .........
        .........
        break;
    }
}

//example B, which is a workaround of the stack size problem

switch (x)
{
    case 1:
    {
        DoBlockMethod1();
        break;
    }

    case 2:
    {
        DoBlockMethod2();
        break;
    }
}

void MyClass::DoBlockMethod1()
{
    //Block of code using TBuf objects under few hundred bytes
    .........
    .........
    .........
}

void MyClass::DoBlockMethod2()
{
    //Block of code using TBuf objects under few hundred bytes
    .........
    .........
    .........
}

3. Increase the stack size in your MMP file
By default, processes have a stack size of 8K. This can be insufficient for some applications even following the rules described above. To increase the size, use an epocstacksize statement in your MMP file:

// set stack to 20K
epocstacksize 0x5000

Getting started with UIQ 3: Top five tips

The WebGate team used various documents and web resources to help them during the porting process and have listed them below:

1. Read all the available documentation
Here's some of the documentation that the team found useful and they recommend that you understand 100% of what is written in them.

2. Explore the provided examples
Make sure that you understand at least 50%.

3. Browse forums and read what other developers are discussing
If you come upon an unsolved question or problem, give these discussion forums a try:

4. Search the forums
In case of a specific problem make sure you have searched through forums for similar discussions before you post your question. Respect the community and keep the noise down.

5. Contact Sony Ericsson Developer World technical support
If you are stuck, do not hesitate to contact the Developer World support team.

"They proved to be knowledgeable and helpful!" remembers Antony Stoyanov.

Future plans

"All of our product concepts are carefully planned and based on extensive research, user requests and long brainstorming sessions within the team. Currently we are working on new prototypes for Symbian OS end-user apps which we hope to present soon. We are also very interested in developing for Java ME-enabled Sony Ericsson phones as we have built a lot of expertise in Java. We stay open to all kinds of suggestions for new applications and anyone that would like to share ideas is welcome to our website to post their opinion," concludes Spartak Kabakchiev.

About WebGate JSC
WebGate is an innovative software company specialized in development of Symbian OS-based mobile applications and client-server mobile content delivery solutions. WebGate's end-user Symbian OS applications offer useful functionality and add value to users in both their business and personal life. More information and trial downloads of WebGate's mobile products can be found here>>

Back

My Rating Score

Select a bookmark:

Member Login

Select a bookmark:

Member Login

Themes Creator tool

Video interviews and tutorials