Mobile Development

2009-01-27T13:12:00.000+08:00

Symbian Naming Conventions

Correct Symbian vaiable naming:
i-prefix for member variables
a-prefix for method parameters.
C-prefix for classes that should be constructed on the heap.
T-prefix for classes that can fit on the stack.
L-postfix for methods that can leave.

2009-01-15T09:47:00.003+08:00

Nokia's QT Every Where

2008-10-30T16:48:00.001+08:00

How to detect if phone has 3G enabled.

Some items in you applications you want to do some action only when there is 3G network (like video streaming upload or video calling.) So how to detect that phone has 3G network.

TBool isSupported = CFeatureDiscovery:: IsFeatureSupportedL (KFeatureIdProtocolWcdma);
if (isSupported)
   {
   // activate the service
   }

2008-10-25T11:29:00.002+08:00

How to know current editing state of TextEditor.

You can use CAknEnv::EditingStateIndicator() to get then current editing starts.
code below show how to know if T9 is On or OFF.

TBool t9_mode;
MAknEditingStateIndicator* editingindicator = CAknEnv::Static()->EditingStateIndicator();
CAknIndicatorContainer* indicatorcontainer =editingindicator->IndicatorContainer();
if (indicatorcontainer->IndicatorState(TUid::Uid(EAknNaviPaneEditorIndicatorT9)))
  {
  t9_mode = ETrue;
  }
else
  {
  t9_mode = EFalse;
  }

2008-10-21T18:13:00.002+08:00

How to fource application to use AGPS instead of GPS.

Solution is you have circle through all the gps modules avaialble and select one with AGPS Support.

RPositionServer iPosServer;
RPositioner iPositioner;

srv.GetNumModules(moduleCount);

for(TInt i = 0 ; i < moduleCount ; i++)
 {
 TPositionModuleInfo modInfo;
 TInt error = iPosServer.GetModuleInfoByIndex( i, modInfo );
 if(modInfo.IsAvailable() && (modInfo.TechnologyType() == TPositionModuleInfo::ETechnologyAssisted))
     {
     iPositioner.Open(iPosServer,modInfo.ModuleId());
     break;
     }
 }

2008-10-21T18:03:00.001+08:00

How to get UserAgent for S60 v3.x devices.

use the following code to get the user agent of the device.

iRepository= CRepository::NewLC(TUid::Uid(0x101f8731));
TBuf<255> tmp;
iRepository->Get(7, tmp);
iUserAgent = HBufC8::NewL(tmp.Length());
iUserAgent->Des().Copy(tmp);

2008-10-21T17:58:00.000+08:00

How to make old sdk installations foot-print disappear.

Problem: some times the emulator or my sdk [v3.0 MR] installation gets corrupted due to prolonged usage. and i want to reinstall so i uninstall the SDK and reinstall it but the new installation takes S60_3rd_MR_2 as epoc path so how to default it to S60_3rd_MR.

Solution:
1. Uninstall S60_3rd_MR from you PC and delete S60_3rd_MR folder.
2. Open RegEdit
3. Go to HKEY_LOCAL_MACHINE\SOFTWARE\Nokia\com.nokia.s60 and check the counter value
4. if the counter value not "0" then set it to 0.
5. restart PC and install S60_3rd_MR again.

2008-10-01T15:48:00.000+08:00

How to observe the flip open and flip close event

If you wanted to observe the flip open and flip close event in case of N93. then you have to use EnableScreenChangeEvents and try capturing events EEventCaseClosed, EEventCaseOpen in RunL()

if(iStatus == KErrNone)
    {
    TWsEvent e;
    ws.GetEvent(e);
    switch(e.Type())
        {
        case EEventCaseClosed:
        case EEventCaseOpen:

        }
    }

2008-10-01T15:25:00.000+08:00

Taking ScreenShot in Symbian

Below are steps we have to take ScreenShot and saving it to the file as .jpeg.

1.Create blank bitmap:
iBitmap = new (ELeave)CFbsBitmap;
iBitmap->Create( TSize(176,208),EColor16M ); // Pass the Window Size to capture

2.Create a rectangle of the window you want to capture:
iScreenRect = TRect(TPoint(0,0),TSize(176,208)); // Pass the Window Size to capture

3. Copy Screen To this bitmap and save it into memory.
iScreenDevice->CopyScreenToBitmap(iBitmap,iScreenRect);

4. Now we have to Encode CFbsBitmap to JPEG Format.

TBuf<50> myBuf;
myBuf.Append(KFileName);
myBuf.AppendNum(iCaptureCount);
myBuf.Append(KExtension);

iEncoder = CImageEncoder::FileNewL(iFsSession, myBuf, CImageEncoder::EOptionAlwaysThread, KImageTypeJPGUid);

TRequestStatus status;
iEncoder->Convert(&status,*iBitmap);
SetActive();

5. The conversion process is asynchronous. When it is completed, RunL() is called. Inside RunL()

Indside RunL():
delete iEncoder;
iEncoder = NULL;

2008-10-01T13:56:00.000+08:00

How to simplify Symbian Classes using Template.

As you all know we have to have 2-Phase consutsction in heap based classes. And also know that it's repetitive code that we have to write for each and every classes. If you can minimize the coding effort that will help us in long run, for that we can use the Symbian Templates.

Define a class which is base class


// baseclass.h
#ifndef __BASE_CLASS_H__
#define __BASE_CLASS_H__

template <class T>
class CBaseClass : public CBase
   {
public:
   static T* NewL(RWsSession& aWsSession)
       {
       T *self = T::NewLC(aWsSession);
       CleanupStack::Pop(self);
       return self;
       }

   static T* NewLC(RWsSession& aWsSession)
       {
       T *self = new (ELeave) T(aWsSession);
       CleanupStack::PushL(self);
       self->ConstructL();
       return self;
       }

public:
   virtual void ConstructL() = 0;

   };
#endif

Now We can use in any class like below


#ifndef __MYCLASS_H__
#define __MYCLASS_H__

#include "baseclass.h"
class CMyClass;
class CMyClass : public CBaseClass<CMyClass>
   {
public:
   void ConstructL();
public:
   CMyClass()
   {
   }
   ~CMyClass();
   };
#endif

note: you can improve the above implemetaion as per your requirement.

2008-10-01T13:32:00.002+08:00

How to Copy BitMap Object to BitMap Object

We can load a bit map using CEikonEnv::CreateBitmapL()

CFbsBitmap* myBitmap = iEikonEnv->CreateBitmapL(KBmpPath,index);

Code below shows how to copy BitMap

CFbsBitmap* aBitmap = new (ELeave)CFbsBitmap;
aBitmap->Create(myBitmap->SizeInPixels(),myBitmap->DisplayMode());
TRect tempRect(TPoint(0,0),myBitmap->SizeInPixels() );
TInt iBufLength = tempRect.Width() * tempRect.Height() * 2;
Mem::Copy(aBitmap->DataAddress(),myBitmap->DataAddress(),iBufLength);

2008-10-01T12:51:00.000+08:00

How to choose a mobile platform

When it comes to choosing the target platform and technology for your mobile project the possibilities are numerous. There are several kinds of PDAs and mobile phone platforms to choose from, and they all have somewhat different characteristics. You'll consider very different factors when you develop applications for the Pocket PC versus the Palm OS, even though their target markets are nearly the same. On the other hand, using Mobile Information Device Profile (MIDP) for application development is quite different from doing it using Symbian, even though these two platforms tend to target the same devices.

Project scope and limitations

Before you even begin to consider technology platforms and target devices, you must have a crystal-clear picture of the software you're developing. To begin, ask yourself these questions:

* Who is your target audience? Is your application intended for consumer use, or will it be used more in business or corporate environments? Consumer devices are generally different from business devices, so knowing your target audience will help you narrow down your target device -- quickly. You won't get far developing a children’s game for the Pocket PC.
* Are you developing a game or an application? If it's a game, consider the demographics of the people who will play it (age, gender, economic bracket, and so on). That will give you an idea of which consumer devices to target.
* Are there any pre-existing requirements? If your distributor only handles Symbian applications, for example, then your choice is easy. Likewise if you're developing a business app for a company that already has Symbian phones in place.
* What's your skill-set? Assuming you're doing the coding, if you're a Java™ developer then you probably want to stick with the Java platform (unless you have a good reason for switching to some other technology).
* How quickly do you need the application or prototype? Some technology solutions add complexity, and thus development time, to a project, whereas others limit both.
* How much money do you have? Money is almost always the most important factor to consider.

While not so integral to choosing your development platform, it's also a good idea to know what niche your application will fall into. Is it unique enough to dominate the market on any target device, or will it be one application among many in a given genre? These considerations will help you decide how much time and money to invest in your application, as well as what kind of returns you can anticipate.

Mobile technology options

Mobile development technologies have quite a range -- from the stripped-down server-side scripting of Short Message Service (SMS) to the complete development platforms of Symbian and MIDP. Before I get into comparing the technologies most commonly used for mobile development, I'll briefly describe each one and discuss its pros and cons from both a development and a market perspective.

SMS and MMS
SMS (Short Message Service) and MMS (Multimedia Service) are by far the simplest technologies to use for mobile development. Both build on the basic functions of mobile phones, with the SMS/MMS development happening on the server side. The simplest way to make an SMS application (for example one that receives a message and sends a joke) is to sign a contract with a mobile service operator and write a simple PHP script that communicates with the operator's interface. MMS applications are the same but a bit more complicated, because you're handling different kinds of content.
MIDP
The Mobile Information Device Profile (better known as mobile Java) launched the mobile application revolution. Sadly, the technology fell flat of many developer's expectations when it turned out that its applications weren’t really write-once, run-everywhere. MIDP 2.0 fixed many of the problems inherent in the first version, but some developers still have doubts about MIDP. On the upside, MIDP development can be very fast, allowing you to make a working application or prototype in just a few days.
Symbian
Symbian is an increasingly popular operating system for smart phones. Symbian has a number of user interface platforms, including Nokia’s Series 40, Series 60, Series 80, and Series 90, and the UIQ, which is used by Sony Ericsson and Motorola among others. Symbian is a lot more complicated to work with than MIDP, but Symbian applications are designed and targeted for a particular UI and platform, making them more reliable. Symbian applications are written mainly in C++.
Pocket PC
Windows™ CE, Pocket PC Edition (aka Pocket PC or Windows mobile) is Microsoft’s operating system for PDAs. The Pocket PC platform resembles other Windows operating systems, which makes it quite easy to learn. A Pocket PC device also contains all the basic applications for word processing, personal information management, e-mail, and so on, making it a popular choice among consumers. On the other hand, Pocket PC devices don’t necessarily have network connections or phone functions. Pocket PC apps are typically written in C++, Visual Basic, or the Java language.
Smartphone
Smartphone is the smartphone version of Windows CE or Windows Mobile. It is aimed at smartphones and mainly competes in the same category as the Symbian OS. Smartphone development is similar to Pocket PC development. Because Smartphone is a mobile phone platform it is guaranteed to have phone functions and connectivity.
Palm OS
Palm OS is the operating system behind Palm devices, which were among the first practical handheld devices. These days there are Palm OS phones and PDAs. Palm devices have a loyal user base, which ensures a good market for Palm applications. Palm OS Garnet and Palm OS Cobalt are the two versions of the Palm platform, Cobalt being the newer version. Most Palm OS applications are written in C, but there are development environments that will let you create Palm OS applications in other languages including C++, Visual Basic, or Java programming.
Others.
iPhone, Android, Linux etc

Now you have a clear sense of your application and the mobile technologies you could use to build it, but you're probably not sure yet which is the best one. Asking more questions (and answering them) will help you narrow the decision down even further.

What can you afford?

Money is the bottom line in application development. Knowing what you have to spend lets you determine how much time you have to develop your application and how many developers you can assign to the project. Symbian is probably the slowest and, thus, most expensive mobile development technology, while MIDP, Pocket PC (with Visual Basic), and SMS can be quite fast and cheap. Table below summarizes the budgeting considerations for each of the mobile development technologies profiled.

Budget factors compared

Technology	Budgeting considerations
SMS and MMS	You can use standard Web development tools, like Java programming or PHP, and you'll find plenty of experienced developers. It's also easy to learn these technologies yourself. You'll need a Web host for your scripts and a contract with your local mobile operator.
MIDP	Development tools are free, although some of the commercial tools can make development faster and easier. The MIDP APIs are quite easy to learn and use. You can build a good application with a small team.
Symbian	Probably the most difficult to master, and thus expensive, but also rewarding. The software is reliable and has a solid reputation. Consumers are willing to pay more for Symbian. You will need a commercial development tool, which adds to the cost. Further, some distributors only accept tested applications, so you’ll have to use a third-party testing company to do the testing. And in the latest version of Symbian, you have to get your applications signed.
Pocket PC	Free tools let you start a development project with a small budget. Developing an application with a reasonable amount of features requires experience and time, however, as with any other Windows application.
Smartphone	Development is pretty straightforward if you’re familiar with Microsoft’s technologies and are fluent with Visual C++. You'll find a large community of experienced developers for Microsoft’s technologies, so the size of the team will depend on the size of your project.
Palm OS	You can download free development tools from Palmsource and get support for a small fee. Palm OS development is about as demanding as Windows Mobile (Pocket PC and Smartphone) development, with the same benefits and constraints.

How much time do you have?
Table below shows the factors that affect development time for each mobile technology, then categorizes them by speed. (Of course, a lot depends on the experience of the development team.)

Development time factors compared

Technology	Factors that affect development time	Speed
SMS and MMS	Getting the contracts with a mobile operator can take some time, but the development itself should go quickly if you're an experienced Web developer.	Fast
MIDP	Prototypes can be made very quickly. A simple application can be designed, implemented, and tested in a month.	Fast
Symbian	While this is the most time-consuming choice, it significantly increases the credibility of your application. You most likely need a development team that is experienced with Symbian. If you plan to learn the technology yourself make sure you reserve enough time.	Slow
Pocket PC	Visual Basic development is quite fast even for the beginner, but C++ development takes time. You can also use the Java platform, but doing so presents limitations for running the application easily in the device.	Medium
Smartphone	Quite like the Pocket PC.	Medium
Palm OS	Developing with C is slow compared to MIDP. Other options are faster.	Slow

What's the ROI?

Not all people who own certain devices are potential buyers. Some don’t even know that their mobile phone is Java-enabled -- or even know what "Java-enabled" means. Knowing what to expect in returns will help you decide how much time and money to put into your application up front; this is an important consideration for some mobile platforms. Table 3 describes the potential market for different platforms and explains some of the variables that will affect your application's return on investment.

ROI and target consumers compared

Technology	Market
SMS and MMS	Nearly everyone with a mobile phone is a potential user of SMS or MMS services, although you'll find more users in some demographics than others. Stock market applications are strictly for business people, whereas almost anyone could want to vote for their favorite reality television series candidate.
MIDP	Most mobile phones now include MIDP 2.0, but that doesn’t mean that consumers know what to do with it. As a test, ask all your friends and family if their phones are Java-enabled. How many of them know that they have Java-enabled phones? How many of them have used a mobile Java application?
Symbian	At the moment there are two market segments for Symbian: young people for games and business people for business apps. More users will tune into Symbian soon, but for now these are the early adopters who are willing to pay for applications.
Pocket PC	These devices are mostly owned by business people, which guides the applications built for them. Think PIM applications, travel applications, and the like.
Smartphone	Smartphone is relatively new (compared to Palm OS, for example) and so its market is quite fresh. There are not very many devices out yet, but the number is growing. The phones are quite large, so, at the moment it's unlikely to woo the masses.
Palm OS	The PDA's target audience is mainly business people or people with a high demand for contact and memo data. The phones could appeal to anyone, but their size and price suggests that they're targeted to business people or early adopters.

In conclusion

I've focused in this column on considerations to help you choose the right mobile platform, starting with some questions to help you define your software project. Knowing the scope and limitations of your application -- from both a development and a market perspective -- is paramount in choosing the right technology to build it. From there, you'll want to consider market factors such as whether your application falls into a niche that is already dominated by a given technology or range of devices and the anticipated return on investment from your app. Finally, think about the development itself.

Developing MIDP apps is relatively simple and takes place entirely on the Java platform. If you're building a lightweight consumer app and you know Java already, then MIDP is a good choice for you. If you want to build your application using Symbian -- a good choice for more robust applications that will compete for marketshare -- then you or your team must be proficient in C++ programming. An SMS application is easy to build and can target a wide audience, but offers a fairly limited user interface.

The key to choosing the right technology for your projects is to think from multiple perspectives. Here, I've introduced the most commonly used mobile technologies and compared them based on the three essential considerations for any project: budget, development time, and ROI.

2008-09-12T12:59:00.000+08:00

Why Should we use Resource Files in defining UIs ?

Symbian (and its Licensees S60 and UIQ) provides a lot of the infrastructure for an application in Symbian.C++ that is already prebuilt[like MFC] so it is not really practical to reinvent the wheel with more code to rebuild the controls.

Additionally to provide a consistent framework across devices, the underlying OS uses a framework calls LAF which dictates how controls should look and where they should be on the screen so that there is a common style to all applications.

Also Keeping source code and resource files separate, which gives lots of advantages
1. easy localization,
2. developer only need to recompile resource files if there are any changes in the UI elements.

2008-09-07T21:21:00.003+08:00

QT - Windows CE Application Framework

Qt for Windows® CE enables developers to write rich and high performance applications using an intuitive API available for a wide range of devices. Qt for Windows CE allows rapid application development, translation to numerous languages, and unparalleled ease of platform migration to Windows, Mac®, Linux®, embedded Linux® and Unix®. Enjoy efficient cross-platform development across multiple device types.

Qt Cross-Platform Application Framework

Qt is a cross-platform application framework for desktop and embedded development. It includes an intuitive API and a rich C++ class library, integrated tools for GUI development and internationalization, and support for Java™ and C++ development.

Innovate & Differentiate

Proven Technology

Qt for Windows CE inherits the power and advantages of Qt, Trolltech's leading C++ cross-platform application framework. Trolltech has always demonstrated both commitment and ability to remain ahead of the technology curve, freeing customers to focus on front-end value-adding innovation rather than maintaining the software infrastructure.

Power to Differentiate

With full source code and documentation provided, Qt for Windows CE offers the freedom to create and innovate. Device and application developers using Qt can efficiently differentiate their products by taking control of the user experience.

Independence
Qt for Windows CE has minimal hardware dependencies and supports most existing Windows CE configurations. Qt for Windows CE is easy to build even for custom hardware configurations.

High Productivity

Whether you are developing for the desktop or Windows CE, Qt comes with a rich toolset enabling rapid application development, seamlessly integrated with Visual Studio®.

High Quality API

Qt for Windows® CE supports the same API as Qt on the desktop: a growing library of over 600 C++ classes, which encapsulates a complete infrastructure for end-to-end application development. Qt for Windows CE benefits from Qt 4's leading technologies including high-quality rendering engine, concurrency abstraction, text rendering and multi-threading. Unused features can be excluded when compiling Qt for Windows CE in order to minimize software footprint.

Enhanced Graphics Capabilities

Speed optimization and visual quality, a primary focus for Qt, has even more impact on embedded devices. The Qt for Windows CE API allows for the capabilities of the hardware's accelerated graphics to be utilized. Qt integrates Scalable Vector Graphics (SVG 1.1/1.2 Tiny) drawings and animations on embedded with full support for multiple displays. OpenGL ES is supported including an OpenGL paint engine for accelerated 3D graphics.

Powerful 2D Graphics Canvas

Qt Graphics View – a powerful 2D graphics canvas – enables the creation of interactive applications that responsively handle thousands of 2D graphics objects. Graphics View provides support for collision detection, optimized level-of-detail rendering, affine item transformations, enhanced control over animations and enhanced drag-and-drop features.

Native and Customizable Look and Feel

Qt for Windows CE adds two new native styles to Qt: the Windows Mobile and Windows CE style. At runtime, Qt applications will detect which style to use. The look and feel of Qt applications can be easily customized further with its unique widget stylesheets. Qt Style Sheets are a powerful mechanism that allows customization of widget appearance. The concepts, terminology, and syntax of Qt Style Sheets are inspired by HTML Cascading Style Sheets (CSS), but adapted to the world of widgets. With Qt Style Sheets, complex styles can be defined by anyone familiar with CSS techniques, in a fraction of the time and lines of code required for traditional UI styling.

Multimedia Framework*

Qt 4.4 incorporates Phonon: a straightforward, high-level, open-source media playback API. Phonon provides cross-platform support for video and audio playback using native media facilities.

Qt WebKit Integration*

Qt's integration with WebKit – a powerful open source web rendering engine – allows you to display and integrate dynamic web content and functionality in your local application. Applications can incorporate real-time web content and services, and utilize HTML and application scripting skills enabling new ways of creating and delivering user interfaces.

Advanced Text Layout Engine

Qt for Windows CE supports TrueType® and raster fonts. Targeting the global market is easier with Qt for Windows CE, with its extended Unicode support and right-to-left languages. Qt's rich text engine adds capabilities for complex text layouts including tables, path tracing and text which flows around shapes. Using Qt, it's has never been this easy to create rich text content in your embedded application.

Invaluable Tools

Regardless of what platform you are targeting, Qt includes tools, which enable rapid and optimal development. All tools are seamlessly integrated with Visual Studio, making it possible to target multiple platforms from within the popular Windows IDE. Tools include automatic code completion and syntax highlighting, powerful GUI layout and forms design through an integrated Qt Designer, templates for the most common application types, and Qt documentation integrate with Visual Studio online help. Also included are a set of tools designed to smooth the internationalization workflow.

2008-08-26T18:13:00.000+08:00

How to retrieve a list of the languages supported by the phone.

    CPtiEngine* eng = CPtiEngine::NewL( ETrue );
 CleanupStack::PushL( eng );
 if ( eng->NumberOfLanguages() )
     {
     RArray<TInt> languages;
     CleanupClosePushL( languages );
     eng->GetAvailableLanguagesL( languages );
     ........
     CleanupStack::PopAndDestroy( &languages );
     }
 CleanupStack::Pop (eng);

2008-08-25T18:04:00.001+08:00

Naming convention used in Symbian

Why we require special "Naming convention" for symbian.

* provide common syntax for Symbian OS C++
* help reinforce Symbian OS programming idioms
* help communicate Symbian OS C++ class design for APIs
* serve as checklist for coding
* act as reference during code inspection/review
* helps produce efficient and reliable code for ROM-based devices

Fundamental data types in Symbian
* typedefs of built-in types for integer, floating-point, character, and pointer types (e32def.h), compiler-independent.
* TInt, TUint signed and unsigned 32-bit integers
* TBool, values ETrue (=1) and EFalse (=0)
* TReal, Double precision (64-bit) floating point number
* TText, Build independent general text character, In non-Unicode builds, this is mapped to TText8. In Unicode builds, this is mapped to TText16.
* TAny*, Pointer to anything (use instead of void*)

Symbian OS Classes
* Classes should have a clear role
* One class to one header file is recommended.
* Layout of header files:
#include files;
friend classes;
public,
protected,
private methods;
private,
protected,
public data.
* T-, C-, M-, R- convention to denote different class types

Types of Symbian.C++ classes

T Classes
* Behave like C++ built-in types
* No destructor => can be created on the stack and will be cleaned up correctly when the scope of function exits
* Contain member data which is:
-Built-in types
-Pointers and references with uses a relationship
* Contain all data internally
* Example:

          class TInitParams {
         public:
         TInt iN1;
         TInt iN2;
         }

C Classes
* CBase (defined in e32base.h) is the base class for all C classes.
* All C objects are allocated on the heap.
* When it is first allocated on the heap all member data will be zero-filled
* When no longer needed heap-based objects must be destroyed
* It has a virtual destructor (destroyed properly by deletion through a CBase pointer)
* Example:

          class CExample : public CBase
         {
         ...
         }

R Classes
* R classes are proxies for objects usually owned elsewhere.
* There are two main motivations for this,
- the real object is owned by a server in a different thread or address space
-implementation of real object must be hidden from the client.
* There is no common base class for all R classes.
* The initialization function has a variety of names, like Open(), Create(), Allocate(), etc.
* The termination function has a variety of names, like Close(), Destroy(), Free(), etc.

M Classes
* The only form of multiple inheritance allowed by Symbian OS is where the extra classes are Mixins.
* Mixins (M classes), define an interface but do not provide an implementation of it
* they do not have any data members.
* only pure virtual functions
* A concrete class derived from a Mixin must implement its interface.
* Example:

class MRadio
         {
         public:
         virtual void TuneL() =0;
         };

         class MClock
         {
         public:
         virtual void CurrentTimeL(TTime& aTime) =0;
         };

         class CClockRadio : public CBase, public MRadio, public MClock
         {
         public:
         void TuneL();
         void CurrentTimeL(TTime& aTime);
         };

Class members

* Data members: use prefix i -, should be private
* Arguments: prefix a-
* variables start with lower case, Functions Start With Capitals
* Setter functions: SetThing(aThing);
* Getter functions: myThing = Thing(); (return it)
GetThing(myThing); (pass it by ref.)
* Variables including arguments: & for uses-a and * for has-a
* Trailing L,C for functions that cause exceptions (L means leave function, LC means it may leave and the function keep object on cleanupstuck)
* Trailing D for functions that delete object

2008-08-21T18:19:00.000+08:00

How to Display Phone Model

_LIT(KFilename,"Z:\\resource\\versions\\model.txt");
RFile file;
User::LeaveIfError(file.Open(CCoeEnv::Static()->FsSession(),KFilename,EFileRead));
CleanupClosePushL(file);

TFileText text;
text.Set(file);
TBuf16<128> szModelName;
User::LeaveIfError(text.Read(szModelName));
CleanupStack::PopAndDestroy(&file);

CAknInformationNote* note = new (ELeave) CAknInformationNote(ETrue);
note->ExecuteLD(szModelName);

2008-08-14T10:37:00.000+08:00

How to know what is your device Bluetooth address.
The local bluetooth address of a device can usually be retrieved by typing the following star-hash code: *#2820# (*#BTA0#)

2008-08-13T10:06:00.001+08:00

Automating "Generating Errrd installing sis file"

Below code is just a .bat file code that automates the process of
1. creating a pkg file.
2. generating key and cert
3. generate a signed sis.

@echo off
echo #{"ErrRd"},(0xEEEEEEEE),0,0,0 >ErrRd.pkg
echo %%{"ErrRd"} >> ErrRd.pkg
echo :"ErrRd" >> ErrRd.pkg
echo [0x101F7961], 0, 0, 0, {"Series60ProductID"} >> ErrRd.pkg
echo "nul"-"c:\resource\ErrRd" >>ErrRd.pkg
makesis ErrRd.pkg
makekeys -cert -password test -dname "CN=Developer OU=MobileDev" test.key test.cert
signsis ErrRd.sis ErrRd.sisx test.cert test.key test
del test.key
del test.cert
del .rnd
del ErrRd.sis
del ErrRd.pkg
pause

How to use it.
1. Create a .bat file in c:\\
2. Copy above code to that file
3. Save File
4. double click on the .bat file.
5. Follow the on screen instructions.
6. At the end ErrRd.sisx will be generated.
7. Install this .sisx on your development device.

note: credit goes to original author "Wizard of Hungary" from forum.nokia.com
http://wiki.forum.nokia.com/index.php/Extended_panic_code

2008-08-09T14:09:00.001+08:00

How to know where on device my application is installed.

As you may want to provide user to install you application both on phone memory (C:\) OR on memory Card (E:\) So when try to access your data files you may require to find out which drive your application is installed.

Pre-v9 SDK suppoerted devices.


   TFileName fullPath(fileName);
   CompleteWithAppPath(fullPath);    // from aknutils.h
   // fullPath now will contain <drive>:\system\apps\<application_name>

v9.x SDK suppoerted devices.

    TFileName appPath;
   TBuf<2> appDrive;
   // Returns private path of this application
   // in following format: \Private\<SID of the application>\
   // (does not contain drive specification).
   iEikonEnv->FsSession().PrivatePath( appPath );
   // Extract drive letter into appDrive
   appDrive.Copy(iEikonEnv->EikAppUi()->Application()->AppFullName().Left(2));
   // Insert drive letter into path
   appPath.Insert(0, appDrive);

2008-08-09T09:12:00.001+08:00

How to get information about Profile [Online / Offline].

Profile information are enumerated as below.

EProfileUnknown = -1,
EProfileOffline = 5,
EProfileOffline = -2

Pre-v9 S60 devices.

    TInt profileIndex = EUnknownProfile;
   CSettingInfo* settingsInfo = CSettingInfo::NewL(NULL);
   CleanupStack::PushL(settingsInfo);
   User::LeaveIfError(settingsInfo->Get(SettingInfo::EActiveProfile, profileIndex));
   CleanupStack::PopAndDestroy(settingsInfo);
   // profileIndex contains the profile information

v9.x S60 devices.

    CRepository* repository = CRepository::NewL(KCRUidProfileEngine);
   CleanupStack::PushL(repository);
   User::LeaveIfError(repository->Get(KProEngActiveProfile, profileIndex));
   CleanupStack::PopAndDestroy(repository);
   // profileInde contains the profile information

2008-08-08T10:57:00.002+08:00

10 Tips when using Symbian Descriptors

Tip 1: Never instantiate a TDes or a TDesC
The default constructors of TDes and TDesC are declared private so the compiler won’t let you construct them directly. But there is no copy constructor declared for either class, so the compiler won’t complain if you make a copy of a valid descriptor (in fact, it will go as far as to help you, by invoking an implicitly generated copy constructor).

_LIT(KExample, "Fred");
TPtrC original(KExample); // a valid TDesC-derived descriptor
TDesC copy(original); // Uses the implicit copy constructor

Your code probably won’t crash if it has been written safely, but you will rarely have a valid reason for doing this. The code will fail to work anyway, because TDes and TDesC contain no string data, so in effect are abstract classes.

Tip 2: Check that there is sufficient space before writing to a descriptor.
An attempt to access an area outside the area allocated for descriptor data will cause a panic in both debug and release builds, because the descriptor functions use __ASSERT_ALWAYS internally to check for out-of-bounds access. A panic causes your code will stop executing immediately, whether running in an application, server or test framework. So be absolutely certain that there is space in your target descriptor, if necessary, by doing a check first by using the Length() or MaxLength() methods.

_LIT8(KImageGif, “image/gif”); // 9 characters
TBuf8<8> mimeType8; // Space for only 8 characters
mimeType8.Copy(KImageGif); // So Panic!

Tip 3: Need a small known length descriptor? Use TBuf or TBufC.
These are suitable for when you know the required length at compile time. The recommended maximum length is 256 bytes or fewer (remember that’s 128 characters, a TBuf<128>, because each character occupies 2 bytes).

Tip 4: Need a larger or unknown length descriptor? Use HBufC.
Heap-based descriptors, HBufC, are allocated on the heap at run time. They can be used as local variables or as class members. As with all heap-based objects, memory leaks must be avoided through use of the cleanup stack - for local variables - or deleted by a destructor if ownership is through a member variable.

Tip 5: Need to modify an HBufC? Call Des().
An HBufC is derived from TDesC, and inherits non-modifiable descriptor functionality. Because it is not derived from TDes, it isn’t modifiable. So to write into it, you have to create a modifiable descriptor over the data area. This is done by calling HBufC::Des() which returns a TPtr and thus gives you access to all the modification functions such as Format(), Append() and Fill():

HBufC* buffer = HBufC::NewL(4); // Read Only buffer
TPtr ptrBuffer(buffer->Des()); // Read Write buffer
_LIT(KBert, "Bert");
ptrBuffer.Copy(KBert); // The data area of robert now contains Bert

Remember that that there must be space in the HBufC for the required change because descriptors don’t resize themselves automatically. If there isn’t, it will still compile - but you’ll get a panic at runtime.

HBufC* buffer = HBufC::NewL(2); // Read Only buffer
TPtr ptrBuffer(buffer->Des()); // Read Write buffer
_LIT(KBert, "Bert");
ptrBuffer.Copy(KBert); // Panic! Not enough memory allocated to hold "Bert"

Tip 6: Need to read from an HBufC? Don't call Des().
To read from a descriptor, you only need it to be non-modifiable, a TDesC. Class HBufC derives from TDesC, so it has access to all the non-modifiable functions implemented by TDesC. All you need to do is dereference the pointer.

_LIT(KBert, "Bert");
HBufC* bert = KBert.AllocL();
TPtrC halfOfBert = bert->Left(2);

One of the most common mistakes made when using descriptors is to call Des() on an HBufC* when you only need a constant descriptor.

_LIT(KBert, "Bert");
HBufC* bert = KBert().AllocL();
TPtrC halfOfBert = bert->Des().Left(2); // Unnecessary call to Des()

Tip 7: For API design, use the descriptor base classes as parameters and return values.
In your APIs, use the descriptor base classes TDes and TDesC as parameters and return values. And remember to pass them by reference for efficiency, and never by value. Thus, descriptor parameters should be passed and returned either as const TDesC& for constant descriptors or TDes& when modifiable.

Thus, when defining functions you should always use the abstract base classes as parameters or return values. For example, class RFile defines straightforward file read and write methods as follows:

IMPORT_C TInt Write(const TDesC8& aDes);
IMPORT_C TInt Read(TDes8& aDes) const;

The descriptor to write to the file is a constant descriptor, while to read from the file into a descriptor requires the parameter to be modifiable (the maximum length of the modifiable descriptor determines how much file data can be read into it).

Tip 8: Don't confuse Size() and Length().
The base class TDesC defines both Size() and Length() methods, which are easy to confuse.

Size() returns the number of bytes the descriptor occupies.
Length() returns the number of characters the descriptor contains.

For 8-bit descriptors, where each character occupies a byte, this is the same thing. However, on all releases of Symbian OS since v5u, the native character width has been 16 bits; that is, each character occupies two bytes.

note: Size() always returns a value which is double that of Length().

Tip 9: Beware of calling MaxLength() on the TPtr returned from HBufC::Des()
There's an interesting side effect to calling Des() on an HBufC to return a modifiable descriptor.

Tip 10: Use operator>> and operator<< to internalize and externalize descriptor data. But remember that they can leave!
When externalizing data to a writable stream, or internalizing it from a readable stream, use the operators crafted for this purpose rather than 'rolling your own'.

// Write the contents of aDes to aStream
void CMyClass::ExternalizeL(RWriteStream& aStream, const TDesC& aDes) const
{
aStream << aDes;
}

// Read the contents of aStream and create an HBufC
HBufC* CMyClass::InternalizeL(RReadStream& aStream)
{// KMaxLength is defined elsewhere as the maximum length read from the stream
HBufC* heapBuf = HBufC::NewL(aStream, KMaxLength);
}
referance: http://descriptors.blogspot.com/

2008-08-05T22:43:00.001+08:00

How to know which capabilities a symbian v9.x exe has.

You can see capability information using petran tool provided with SDK.
you have to use > petran -dump s

exmaple:

C:\Symbian\9.1\S60_3rd_MR\Epoc32\release\GCCE\UREL>petran -dump s testUi.exe

PETRAN - PE file preprocessor V02.01 (Build 549)
Copyright (c) 1996-2005 Symbian Software Ltd.

E32ImageFile 'testUi.exe'
Secure ID: ecb33de7
Vendor ID: 00000000
Capabilities: 00000000 00010010
              ReadDeviceData
              WriteUserData

2008-08-04T11:29:00.003+08:00

S60 Editions and Feature Packs

What are S60 Editions?

S60 platform release versions are named as Editions. Editions include all the main features of the release. The latest S60 release is S60 3rd Edition. S60 3rd Edition includes all the main features of the S60 2nd Edition plus some new features.

What are Feature Packs?

Feature Packs include features that are additional to Edition. Feature Packs may also include device specific features. For example, S60 2nd Edition, Feature Pack 2 introduces WCDMA technology into S60 devices.

The talk about "Feature Packs" is a bit misleading, as they are not something that you can easily upgrade to old devices, like the way you update Service Packs on Windows PCs. Instead, S60 and its Feature Packs are tightly integrated with certain Symbian releases and your hardware, to ensure the best possible user experience. If upgrading new S60 platform versions to old devices becomes possible in the future, I promise that you will hear about it.

2008-08-03T23:44:00.001+08:00

Symbian, S60 and Nokia Phones

S60 Edition	S60 version	Symbian OS version	Phone Models
S60, version 0.9	0.9	6.1	Nokia 7650
S60 1st Edition	1.2	6.1	Nokia 3600 Nokia 3620 Nokia 3650 Nokia 3660 Nokia N-Gage Nokia N-Gage QD Sendo X Sendo X2 Siemens SX1
S60 2nd Edition	2.0	7.0s	Lenovo P930 Nokia 6600 Panasonic X700 Panasonic X800 Samsung SGH-D720 Samsung SGH-D730
S60 2nd Edition, Feature Pack 1	2.1	7.0s	Nokia 3230 Nokia 6260 Nokia 6620 Nokia 6670 Nokia 7610
S60 2nd Edition, Feature Pack 2	2.6	8.0a	Nokia 6630 Nokia 6680 Nokia 6681 Nokia 6682
S60 2nd Edition, Feature Pack 3	2.8	8.1a	Nokia N70 Nokia N72 Nokia N90
S60 3rd Edition	3.0	9.1	Nokia 3250 Nokia 5500 sport Nokia E50 Nokia E60 Nokia E61 Nokia E62 Nokia E65 Nokia E70 Nokia N71 Nokia N73 Nokia N75 Nokia N77 Nokia N80 Nokia N91 Nokia N91 8GB Nokia N92 Nokia N93
S60 3rd Edition, Feature Pack 1	3.1	9.2	Nokia 5700 XpressMusic Nokia 6110 Navigator Nokia 6120 Classic Nokia 6121 Classic Nokia 6124 Classic Nokia 6290 Nokia E51 Nokia E66 Nokia E71 Nokia E90 Communicator Nokia N76 Nokia N81 Nokia N81 8GB Nokia N82 Nokia N95 Nokia N95 8GB
S60 3rd Edition, Feature Pack 2	3.2	9.3	Nokia 5320 XpressMusic Nokia 6210 Navigator Nokia 6220 Classic Nokia 6650 Nokia N78 Nokia N96

2008-08-02T20:31:00.001+08:00

When to return a TPtr or TPtrC?

TPtr or TPtrC are descriptors which do not own string data; they simply refer to data that exists in another descriptor. So you can use them to return a descriptor which references part of another descriptor argument, as long as its lifetime will not extend beyond that descriptor's lifetime. For example:

TPtrC LeftChar(const TDesC& aInput)
{
if (aInput.Length()>0)
return aInput.Left(1); // Returns the left-most character
else
return KNullDesC;
}

This, however, is not OK because stack-based fred will cease to exist when GetFred() returns:

TPtrC GetFred()
{
_LIT(KFred, "Fred");
TBufC<4> fred(KFred());
TPtrC fredPtr(fred);
return (fredPtr);
}

further reading http://descriptors.blogspot.com/

2008-08-02T20:22:00.002+08:00

How to use heap descriptors as return types?

I want to create a new descriptor in my function. How do I return it to the caller?
You must return an HBufC* as follows:

HBufC* CreateSomeDescriptorL()
{
_LIT(KBert, "bert");
HBufC* newBert = KBert().AllocL();
return (newBert);
}

The calling function needs to know that it must take ownership of the returned heap-based descriptor and be responsible for deleting it when it has finished with it. Failure to do this is a common cause of memory leaks.

A similar function, which leaves the created descriptor on the cleanup stack for the caller, would be coded as follows:

HBufC* CreateSomeDescriptorLC()
{
_LIT(KBert, "bert");
HBufC* newBert = KBert().AllocLC();
return (newBert);
}

further reading http://descriptors.blogspot.com/

2008-08-02T20:15:00.001+08:00

How to make a descriptor parameter read/write?

Pass it as a non-constant reference to a modifiable descriptor (TDes&). For example:

void SomeFunction(TDes& aReadWriteDescriptor);

further reading http://descriptors.blogspot.com/

2008-08-02T20:10:00.000+08:00

How to make a descriptor parameter read-only?

Pass it as a constant reference to a non-modifiable descriptor (const TDesC&). For example:

void SomeFunction(const TDesC& aReadOnlyDescriptor);

further reading http://descriptors.blogspot.com/

2008-08-02T20:09:00.000+08:00

How to use descriptors as parameters?

The base classes provide and implement the constant and modifiable descriptor operations regardless of the actual type of the derived descriptor. For consistency, they (basic types) should be used as arguments to functions, allowing descriptors to be passed without restricting the caller of the function to using a specific type.

For example, the calling function can call a function with anything derived from TDesC and TDes. For example an HBufC and a TBuf<8>, or a TPtr and a TBuf<3>:

void SomeFunction(const TDesC& aReadOnlyDescriptor, TDes& aReadWriteDescriptor);

further reading http://descriptors.blogspot.com/

2008-08-02T19:55:00.001+08:00

When to call Des() on an HBufC.

This is a common mistake. Des() gives you a modifiable descriptor, TDes, which itself derives from TDesC, so you can use it to call any of the TDesC functions. But it‚is unnecessary.

Here‚is an example of this common mistake:

TBuf<4> stackbasedFred(heapBasedFred->Des()); // Unnecessary, just use
it must be
TBuf<4> stackBasedFred(*heapBasedFred); // More efficient

further reading http://descriptors.blogspot.com/

2008-08-02T19:43:00.001+08:00

How do I read from HBufC?
You can just dereference the HBufC pointer, like this:

TBuf<15> stackbasedFred(*heapBasedFred);

further reading http://descriptors.blogspot.com/

2008-08-02T19:21:00.001+08:00

How do I then write to a heap descriptor? HBufC is not derived from a modifiable descriptor class?

First you must call HBufC::Des() to get a TPtr, which is modifiable. You can then use that:

TPtr fredPtr(heapbasedFred->Des());
_LIT(KDes,"My Desc");
fredPtr.Copy(KDes);

further reading http://descriptors.blogspot.com/

2008-08-02T18:55:00.001+08:00

How do I create a heap based descriptor? And how do I use it when I've got it?

Create an HBufC (or an HBufC8 if you explicitly need 8-bit text).

HBufC* heapbasedDesc=HBufC::NewL(512);

further reading http://descriptors.blogspot.com/

2008-08-02T18:38:00.001+08:00

What if I want a descriptor to hold ASCII text?

There are some cases where you do need to hold 8-bit text: MIME types, or binary data, for example. To do this, you should explicitly use the 8 bit descriptors:

_LIT8(KImageGif,"image/gif");
TBufC8<15> mimeType(KImageGif);

further reading http://descriptors.blogspot.com/

2008-08-02T18:06:00.002+08:00

How do I create a small, stack-based descriptor?

If it needs to be modifiable, use a TBuf.
If it's constant, use a TBufC. You'll need to specify the size of stack space allocated for the descriptor's data.

Here‚is an example:

_LIT(KFred, ‚"My sting"); // A string literal, these will be described later
TBufC<8> constantFred(KFred);

In reality, you probably wouldn't do this for a non-modifiable descriptor, since you can use the literal, KFred directly by calling the operator() function. That is, instead of creating constantFred, you could just call KFred().

However, this approach is still useful for modifiable descriptors, for example, for logging purposes:

_LIT8(KError, "RunError: %d");
TBuf8<35> errorBuf;
errorBuf.Format(KError, aError);

further reading http://descriptors.blogspot.com/

2008-08-02T17:48:00.002+08:00

Large stack-based descriptors

The amount of stack space on Symbian OS is pretty limited. So you should avoid creating large stack-based descriptors when it is unnecessary to do so. Every symbian developer should be aware of the this and only use stack-based descriptors.

For example, TFileName is typedef-ed as follows:

typedef TBuf TFileName;
where: const TInt KMaxFileName=0x100; // = 256 decimal

Each character in a descriptor is 2 bytes, since Symbian OS is a wide, UNICODE. So each TFileName object created on the stack occupies 512 bytes, it does not matter if it does filled with data or not.

For stack conservation, it's advisable to be aware of the amount of space the following objects consume:

* TFileName 512 bytes
* TEntry 544 bytes
* TFullName 512 bytes
* TName 256 bytes

so it is suggested that you try using little of above descriptor types, or try converting then to heap based descriptors.

further reading http://descriptors.blogspot.com/

2008-08-01T15:29:00.001+08:00

Symbian Developer FAQs [Descriptors]

1. What are descriptors?
Descriptors are Symbian OS strings.

2. why are they called 'descriptors' rather than strings?
They're names as 'descriptors', because they are self describing (not literally, it means you donot have to give any parameters). Each descriptor object holds the length of the string of data it represents as well as its 'type', which identifies the underlying memory layout of the data it holds.

3. Descriptors can be used to store text?
Descriptors can be used for storing text and binary data.

4. Do they store text data as ASCII or Unicode?
It can store both types. There are two types, 8-bit and 16-bit descriptors. The 8-bit variant is used to store ASCII characters and raw binary data. while 16-bit for Unicode.

5. How do I know which I have got?
Each type ends in 8-bit or 16-bit, for example TDesC8 or TDesC16. If nothing specified then default is 16-bit [Platform specific mostly symbian supports 16-bit as default now].

6. Which width/type should I use?
If you need to use 8-bit data, for example, to call a particular API method (such as the RFile::Read() or RFile::Write() functions ), for Internet email, or to manipulate ASCII data, you should use the explicitly 8-bit descriptors. If you want to store a chunk of binary data, use the 8 bit variety too.

If you need to work with 16-bit text, for example, Java strings, and want to indicate this explicitly, use the 16-bit descriptors.

Note: In general, unless you need to make the data width explicit, use the neutral descriptors. If nothing else, your code is more readable and it may even be portable if the default character width changes on a later platform.

7. Are they NULL-terminated like C strings?
No. as the name suggests they're self-describing, descriptors know the length of their internal data. This means there’s no need for the data to be NULL-terminated to mark where the data ends. It also means that binary data can be stored in the same descriptor classes as store text data.

Note: This isn’t possible with C strings because there’s no way of distinguishing the NULL terminating character from valid binary data.

8. Can I use standard C arrays to store my text and binary data, and the C string library to manipulate them, like I have always done?
Yes you can, but symbian native suggests using literals where possible.

9. Why it is recommended to use standard C arrays in native symbian programming.
Standard C arrays are unsafe, as they have no concept of how big they are. Null-terminated strings are clunky and inefficient. What’s more, if you want to write past the end of the allocated space of a standard C string, nothing is going to stop you. This leads to all kinds of mayhem, such as data corruption

10. Do descriptors automatically resize themselves if I need more memory?
No. The memory allocated for a descriptor is fixed, and specified on construction. They do not resize themselves dynamically.

Agree that would make life easier for the programmer, but it could also make them less efficient, and it would require complex code to be exception-safe.

On Symbian OS, efficiency is paramount, so the programmer must take responsibility for memory management.

11. What happens if I overrun a descriptor’s allocated space?
You will get a panic in both debug and release builds. The panic will be part of the USER category.

12. Do descriptors perform garbage collection?
No. In the same way that descriptors do not perform allocation or re-allocation, they do not perform garbage collection, because of the extra overhead that would carry on OS.

13. Is there any size limit for a descriptor?
Yes. Descriptors can be stored on the stack or heap. The normal limitations apply as for other Symbian OS variables:
* Stack descriptors should be kept small: a 256 byte limit (128 double-byte characters) is a good guide.
* Heap descriptors can be much larger, depending on the size of heap memory available on device.

Note: For Heap descriptors the layout of a descriptor object will limit the maximum size of a descriptor to 2^28 bytes (256 MB). Since each UNICODE character = 2 bytes, the maximum length of a descriptor is thus 2^27 characters.

reference: http://descriptors.blogspot.com/

2008-07-03T22:42:00.000+08:00

How to know what all capabilities i need for my application.

This process is called "PlatSecDiagnostics" and is performed on the emulator.
Steps are
1. Edit EPOCROOT/epoc32/data/epoc.ini File
2. Check that you have this line
PlatSecDiagnostics ON.
3. Run your application with steps your application have to follow.
note: emulator will not give any error.
4. EPOCWIND.OUT from windows temp folder.
5. If you inspect EPOCWIND.OUT file you will come to know which capabilities are required.
For Example

    *PlatSec* ERROR - Capability check failed - A Message (function number=0x000000cf) from Thread  helloworld[10008ace]0001::HelloWorld, sent to Server !CntLockServer, was checked by Thread CNTSRV.EXE[10003a73]0001::!CntLockServer and was found to be missing the capabilities: WriteUserData . Additional diagnostic message: Checked by CPolicyServer::RunL

2008-07-03T14:18:00.002+08:00

How to speedup emulator startup time.

Find and download "starer.rsc" file.

1. Search in you SDK Epoc folder for file named "sartup.rsc".
2. You will find this files in 2 places
a) Epoc32\Data\z\resource\apps
b) Epoc32\release\winscw\udeb\z\resource\apps
3. Rename both files to "sartup_backup.rsc".
4. Copy "starer.rsc" you downloaded to both folders.
5. you are ready to go.

Note: This is a hack to start emulator without a splash screen . USE IT IN YOUR OWN Risk.

2008-07-01T11:46:00.001+08:00

How to auto start when application installed in memory card

You must not hard code the autostart exe path in your autostart rSC file

RESOURCE STARTUP_ITEM_INFO startexe
{
executable_name = "!:\\sys\\bin\\startexe.exe";
recovery = EStartupItemExPolicyNone;
}

2008-07-01T11:30:00.001+08:00

How to call python module from Symbian C++

You can execute python code from Symbian C++ application ! Here's an simple example :

CSPyInterpreter* it = CSPyInterpreter::NewInterpreterL();
CleanupStack::PushL(it);
PyEval_RestoreThread(PYTHON_TLS->thread_state);

PyRun_SimpleString("open(r'c:\\foo.txt', 'w').write('hello')\n");

PyEval_SaveThread();
CleanupStack::PopAndDestroy(it);

2008-07-01T11:29:00.001+08:00

How to create an instance of a T–class into heap with a new operator

It is possible to create an instance of a T Class with a new operator, but these precautions must be taken:

* Instances of T Classes can be safely placed into the CleanupStack, assuming that they do not contain any pointers or references to external objects. CleanupStack handles the cleanup simply by calling User::Free().

* Member variables are not zeroed automatically on construction. Only CBase’s new operator zeroes members.

2008-07-01T11:27:00.000+08:00

How to take Control of the Call Application

RWindowGroup *pWG = &CCoeEnv::Static()->RootWin();
pWG->SetOrdinalPosition(0, 2000);
CAknInformationNote* informationNote;
informationNote = new ( ELeave ) CAknInformationNote;
TBuf16<30>message;
message.ZeroTerminate();
message.Copy(_L("Calling"));
message.Append(aNumber);
informationNote->ExecuteLD(message);

2008-07-01T11:18:00.000+08:00

How to add any app to "Go To" for pre-v9 phones

TInt eError;
TBuf8<KMaxFileName> lBuf;
CPinbLinkBase *lBaseLnk = CPinbLinkBase::NewL(KLinkUidApplication);
CleanupStack::PushL(lBaseLnk);
lBaseLnk->SetNameL(_L("Hunter"));
lBaseLnk->SetDocumentIdIconL(EPinbUnknown);
lBaseLnk->SetParametersL(_L8("E:\\System\\Apps\\MyApp\\MyApp.app"));
lBaseLnk->SetTailParametersL();
lBaseLnk->SetLinkFileNameL(_L("C:\\system\\favourites\\MyApp.lnk"));
lBaseLnk->SetApplicationUidL(KUidMyApp);
TInt lError = lBaseLnk->ValidateLinkL();
lBaseLnk->UpdateLinkInDiskL();
CleanupStack::PopAndDestroy(lBaseLnk);

Note: Above method does not work for symbian v9.x

2008-06-27T11:10:00.001+08:00

How to Open Browser with a url in UIQ3.x

OpenBrowserWithUrlL(const TDesC& aUrl, CCoeEnv& aCoeEnv)
   {
   TVwsViewId id( KUidQWebApp, KUidQWebPageView);
   TQWebDNLUrlEntry obj;
   obj.iUrl = aUrl;
   TQWebDNLUrlEntryBuf buf(obj);
   aCoeEnv.AppUi()->ActivateViewL(id, KQWebCustomMsgId, buf);
   }

2008-06-26T16:54:00.001+08:00

Auto-start In UIQ

The auto starter in UIQ did not have any particular order

To register with the auto starter your application must write a .ast file to the auto starter's import folder [\private\10274b9f]. On start-up the auto launcher parses the .ast files and will then add new ast files to its database of applications to be started. The ast format contains only the .exe name in plain text as the following example indicates:
calc.ast:

calc.exe

Note:
1. No path is needed: the file is a plain text, one-line executable name. The auto launcher will look across different drives for the executable to launch and no path need be specified; if you install to a MS then the auto launcher will launch from the MS; if the executable cannot be found it will be ignored. The ast file must be written (either by the application or via SIS) to the following import folder:- c:\private\10274b9f\import\

2. Security : The Auto starter will only start your application if it has the capability "WriteUserData".

2008-06-26T14:43:00.001+08:00

Using Linux(Ubuntu) for Symbian.C++ 3rd edition application

Below are the steps i followed.
Step 1: Setup EPOCROOT and Points where you have symbian tools.
a) export PATH=~/gnupoc:${PATH}
b) export EPOCROOT=~/symbian-sdks/s60_31/

Step 2: Compile source code
a) cd ~/symbian-sdks/s60_31/s60ex/helloworldbasic/group
b) bldmake bldfiles
c) abld build gcce urel

Step 3: Create a SIS File
a) cd ../sis
b) makesis helloworldbasic_gcce.pkg helloworldbasic.sis

Step 4: Genearet key and certificate pair
makekeys -cert myselfcer.key myselfcer.cer

Step 5: Sign SIS
signsis helloworldbasic.sis helloworldbasic.sisx myselfcer.cer myselfcer.key

2008-06-26T14:30:00.000+08:00

Setting Up a Symbian C++ Development Environment with Linux(Ubuntu)

Below are the steps i followed.

Step 1: Install Ubuntu 8.04 on a 32Bit system.

Step 2: The Default Ubuntu Install does not come with any Development Tools so you have to use ubuntu apt-get command to install tools and libraries we require.
a) sudo apt-get install build-essential [Compiler to build symbian build system ]
b) sudo apt-get install zlib1g zlib1g-dev [ZLIB Header files needed while building symbian build system ]
c) sudo apt-get install libssl-dev [OpenSSL Header files needed while building symbian build system (signsis / createsis etc)]
d) sudo apt-get install flex [Requred if you want to compile the gcce cross compiler on your own].
e) sudo apt-get install bison [Requred if you want to compile the gcce cross compiler on your own].

Step 3: You have to download some build scripts, compiler [/code] and SDKs
a) gnupoc-package latest. {http://www.4shared.com/account/file/52785287/c117ddb6/gnupoc-package-109tar.html}[It will contain the EKA2 and EKA1 toolchain].
b) gcc cross compiler for symbian source. {http://www.symbianos.org/download/gcc-539-2aeh-source.tar.bz2} [If you are compiling for Pre-v9 devices]
c) gcce cross compiler for symbian source. {http://www.codesourcery.com/gnu_toolchains/arm/releases/2005Q1C} [If you are compiling for 9.x devices]
d) gcc and gcce cross compiler binaries for symbian [If you donot want to compile gcc / gcce from source]
i. http://www.4shared.com/account/file/52785285/2f19bc9a/gnu-csl-arm-2005Q1C-arm-none-symbianelf-i686-pc-linux-gnutar.html

Step 4: Copy all downloaded files [step 3] files to "~/" of your system.

Step 5: Install symbian install Scripts for linux:
tar -zxvf gnupoc-package-1.09.tar.gz

Step 6: Install ARM Build system
If you want to compile tools your self:
a) cd gnupoc-package-1.09/tools
b) ./install_gcc_539 ../../gcc-539-2aeh-source.tar.bz2 ~/symbian-gcc [If using for EKA1]
c) ./install_csl_gcc ../../gnu-csl-arm-2005Q1C-arm-none-symbianelf.src.tar.bz2 ~/csl-gcc [If using for EKA2]

If you want to use pre-compiles tools:
a) mkdir csl-gcc
b) cd csl-gcc
c) tar -jxvf ../gnu-csl-arm-2005Q1C-arm-none-symbianelf-i686-pc-linux-gnu.tar.bz2

Step 7: Install remaining tools
a) cd gnupoc-package-1.09/tools
b) ./install_eka1_tools ~/symbian-gcc [If using for EKA2]
b) ./install_eka2_tools ~/csl-gcc [If using for EKA2]

Step 8: To Set Evenvironment variable to point to your SDK and add the toolchain directory.
./install_wrapper ~/gnupoc

What you can't do with this method:
1. you can't build for emulator.
2. you can't run emulator.

Note:
1. I don't mind using any other Ubuntu linux infect i have tried using OpenSuse and RedHat. Will post the steps for OpenSuse Soon.
2. Some of the sort comes like emulator specific can be over come with WINE will post how to use WINE in coming posts.
2. Refer to http://martin.st/symbian/ for more info.
3. Contact me at skumar.mobiledev@gmail.com with Subject [symbian on linux] if you have any problem.

2008-06-26T11:47:00.000+08:00

How to launch a UI application with Arguments and Handle in Launched UI application

H to launch a application with Arguments.

LaunchApplicationWithArgumentL(const TDesC& aExeName, const TDesC8& aArg = KNullDesC8())
    {
    CApaCommandLine* commandLine = CApaCommandLine::NewLC(); 
    commandLine->SetCommandL(EApaCommandRun);
    commandLine->SetExecutableNameL(aExecName);
    commandLine->SetTailEndL(aArg);
    RApaLsSession apaLsSession;
    User::LeaveIfError(apaLsSession.Connect());
    CleanupClosePushL(apaLsSession); 
    User::LeaveIfError(apaLsSession.StartApp(*commandLine));
    CleanupStack::PopAndDestroy();
    CleanupStack::PopAndDestroy(commandLine);
    }

Handle Arguments in UI Application.

Over ride the virtual function ProcessCommandParametersL() of AppUi Class. 3rd parameter of the function aTail contains application parameters

TBool CMySymbianAppUi::ProcessCommandParametersL(TApaCommand aCommand, TFileName &aDocumentName, const TDesC8 &aTail)
{
    iLogger.WriteFormat(_L("ProcessCommandParametersL %d"), aTail.Length());
}

2008-06-13T00:03:00.001+08:00

What does the Application framework takes care while launching an application ?

The Framework will do following before starting the application.

1. Create a connection to the file server.

2. Create a connection to the window server.

3. Create a connection to the memory manager.

4. Do some application registration.

5. Make sure the application is able to handle erroe and out-of-memory situtions.

6. Initalize other application services like font etc.

7. create default screen elements like status bar, menu bar, soft keys etc.

8. Start active scheduler. (or you can send event loop)

2008-06-13T00:01:00.003+08:00

What the term "Downgrade path" mean in UIQ3.

If a application is not coded to work on all available "UI Configurations" the UIQ3 UI framework will try to look for a nearest match and configures the Screen to that configuration, this process is called "Downgrade path".

"Downgrade path" also makes it possible for an application to run on a device which has a UI configuration that was not available at the time the application was written.

2008-06-12T23:59:00.002+08:00

How to configure UIQ3 emulator to a specific "UI Configuration" ?

When launching the emulator we have to pass -ui parameter to it get the desired "UI Configuration"
eg. uiqenv -ui softkey
OR
We can use the SDKConfig application provided by the SDK.

2008-06-12T23:57:00.001+08:00

What does UIQ3 UI Configuration is consist of ?

UI of UIQ3 is very versatile and can be configured by a 4 high-level configuration parameters. Combination all these parameters are called a UI configuration.

1. Screen Mode.

The following resolutions are commonly used.

a) Portrait (QVGA, 240x320 pixels)

b) Landscape (QVGA, 320x240 pixels)

c) Portrait Small(240x256 pixels)

d) Landscape Small(256x240 pixels)

2. Screen orientation.

Indicates whether screen is used in

a) Normal Mode.

b) Inverted Mode. (screen roated in 180 degrees)

3. Touch Screen.

Indicates whether to use advanced digitizer (Touch Screen) or Not.

4. Interaction style.

There are 2 general interaction styles used.

a) Pen-Style. Optimized for pen use. also know as (Point Touch method)

b) Softkey-Style. Optimized for one-handed navigation.

UI Configurations are enumerated in "Qikon.hrh" as

#define KQikSoftkeyStylePortrait (EQikScreenModePortrait | EQikTouchScreenNo | EQikUiStyleSoftkey | EQikOrientationNormal)

As you can see the UI Configuration can have any combination above 4 parameters. But most commonly used paramets are

a) KQikSoftkeyStylePortrait. Generally known as "SoftKey Style"

b) KQikPenTouchPortrait. Generally known as "Pen Style".

2008-06-12T23:53:00.000+08:00

What a UIQ3 SDK contains ?

1. Library, header and binary files.

2. Compilers

a) GCCE compiler for device build,

b) Nokia x86 compiler for emulator builds.

3. Tools and scripts (including perl scripts) for building application in C++ and creating installation files to distribute applications.

4. PC-Based emulator (No Simulator) of the UIQ3 platform to enable fast development and turn around time.

5. Documentation.

a) API reference.

b) Guides.

c) Sample code.

2008-05-22T12:21:00.001+08:00

Suggested Development process for Symbian S60 C++ Development.

1. Analysis and design:
Before starting to develop an application with an S60 C++ SDK, you must define at least
a) requirements,
b) scope, and
c) functionality
that you wish to implement in the application.
It is good idea to take into account the various capabilities required by the APIs that you intend to utilize in your application at this Phase only.

2. Coding
It is recommended that you use one of the supported IDEs [Visual Studio 2003/2005 with carbide.vs or Carbide.C++]. They provide project templates that you can use to create a standard project from a selection of project types. The template takes care of creating some of the basic folders and files that you need in developing an application. So developer donot have to worry and waste about creating repeated code sections.
note: I will be realsing a set of perl scripts that will generate templates projects to help development by avaoiding IDE. [I am making fixed to these scripts hopfully soon i will complete]

3. Creating and updating your build files.
Before you can build your project, you must first create or update the bld.inf, mmp and extension makefiles.
note: Different IDEs support these files in different ways. Your development environment may maintain these files or just use them when importing the existing project into the IDE, then you are a lucky developer.

4. Building the source files.
In S60 application development, builds are typically created for two different environments:

a) the emulator and
An emulator build is intended to be run on an SDK emulator for debugging purposes. The build process outputs are placed in the correct folder under the SDK emulator directory

b) the target mobile device.
The device build is intended to be run on a mobile device and the output is a file that can be installed on a mobile device. You have to specify which file goes where in a PKG file. Or your IDE can handle it.

Because the operating systems of the emulator and target device are different, two separate builds using different compilers are required. Here are some of the differances between both the builds.
01) emulator and device builds require different compilers.
02) installation of an application on a target device requires a sis file for installation
03) the emulator and device environments treat the processes and threads differently
04) the emulator and device environments treat the maximum stack sizes for applications differently

5. Testing and signing
All S60 C++ application installation files must be signed before they can be installed to a mobile device. Typically, builds are first tested in the emulator and then final testing is performed on the target device.

6. Deploying
Once your application is ready for deploying in a general release, package and deploy your application according to the steps in "Deploying". And you start making money if your application is not Free Application.

Note:
1. This development process is only a suggestion. Your process may different completely or partially from this, depending your type of application and organizational environment.

2008-05-22T10:16:00.000+08:00

How to Set-up S60 v9.x CommandLineInterface(CLI) environment

Install
1. ActivePerl Active Perl 5.6.1.x .... [Upper Versions may not work with out editing some scripts]
2. Java Run-Time Environment (JRE) latest and
3. S60 Platform SDK for Symbian OS, for C++ Feature Pack 1.
4. Carbide.c++ Express .

5. Locate "Carbide.c++ Express" Installation folder usually
"C:\Program Files\Nokia\Carbide.c++ v1.x\x86Build" -> "env_switch" -> "env_update.exe"
6. Run "env_update.exe" by double-clicking on the exe file.
7. You will be provided with all available WINSCW compiler versions.
8. Choose select the latest one.
9. Close the command prompt window.

Now you are ready to build emulator builds using command line.

2008-05-22T10:14:00.000+08:00

Types of Compilers Supported in S60 v9.x SDKs.

1. WINSCW : Used to build an S60 application for the emulator. A WINSCW compiler is delivered with the Carbide products.
2. GCCE : A free GNU C Compiler (GCC) Embedded Application Binary Interface (EABI). The compiler is delivered with the S60 SDK and can be used for compiling S60 applications for mobile devices.
3. ARMV5 : ARMV5 builds are created with ARM Real View Compilation Tools (RVCT, version 2.2). ARM Real View Compilation Tools are usually used for performance reasons, when compiling S60 applications for mobile devices.

Note:
1. When compiling for Device code compiled with ARMV5 is usually faster and small size then GCCE.
2. If you want to improve GCCE performance or want to upgrade to newer version then you can get it from http://www.codesourcery.com/gnu_toolchains/arm
3. Abouve recommendations are not must have but what i use, so you can differ with it.

2008-05-22T10:01:00.001+08:00

Required Environment and Tools for Symbian S60 C++ Development.

1. Computer running
a. Microsoft Windows 2000 SP4 / XP SP2 [Stay away from Vista]
b. Active Perl 5.6.1.x .... [Upper Versions may not work with out editing some scripts]
c. Java Run-Time Environment (JRE) latest.
2. S60 Platform SDK for Symbian OS, for C++ (S60 C++ SDK)
You can get the S60 SDKs Free from forum.nokia.com. Loging required.
3. A C++ IDE or Good Source Code Editor
If are looking for free IDE then i suggest Carbide.C++ Express.
If are looking for a free Source code Editor then i suggest NotePad++.
4. A target device [mobile device] based on the platform version that matches your development SDK.
5. Setup connection between your PC and your mobile device. [Bluetooth or USB], i suggest using PC Suites that come with Phone Driver CD.

2008-04-24T14:03:00.000+08:00

What is "S60 platform services"

S60 platform services are the fundamental services provided by the S60 platform, these include:

1. Application Framework Services — providing the basic capabilities for

a) launching applications and servers,

b) state persistence management, and

c) UI components.

2. UI Framework Services — providing

a) concrete look and feel for UI components and

b) handling UI events.

3. Graphics Services — providing

a) capabilities for the creation of graphics and

b) drawing to the screen.

4. Location Services — allowing the S60 platform to be aware of a device’s location.

5. Web-Based Services — providing

a) services to establish connections and interact with Web-based functionality, including browsing, file download, and messaging.

6. Multimedia Services — providing

a) capabilities to play audio and video,

b) support for streaming and speech recognition.

7. Communication Services — providing

a) support for local and wide area communications, ranging from Bluetooth technology to voice calls.

2008-04-21T13:04:00.001+08:00

How how to get information about my Certificate [Dev Cert].

I do generate a lots of numbers of dev certs for development in office and personal use. and i am not used to generating a dev cert that have all the capabilities that it can have and all my device IMEIs. So each dev cert is different from other by following parameters.

1. Capabilities.
2. IMEIs

let us say if i forget which capabilities and IMEIs a particular Dev cert has, and i do not have time to generate new ones.

;-)

I simple found the answer .... as follows.

devertlist [/c] [/i] [/b] [/?] devcert.cer

- /c - List the capabilities associated
- /i - List the IMEI's associated with the devcert
- /b - List the output as bare, suitable for pipelining
- /? - print out the about information and command list

2008-04-18T18:33:00.000+08:00

How to use mobile theme skin as a background for our application.

1. Enable skins support in our application by calling apps AppUi base constructor:

void CMyAppUi::ConstructL()
{
 BaseConstructL(EAknEnableSkin);
 ...
}

2. We will require a specific context to hold the skin bitmap for your control.

CAknsBasicBackgroundControlContext* iBgContext;

3. Initialise context to a reference of the background bitmap:

void CMyAppView::ConstructL()
{
 ...
 iBgContext = CAknsBasicBackgroundControlContext::NewL( KAknsIIDQsnBgAreaMain,aRect,ETrue);
 ...
}

4. Don't forget to call the context destructor:

void CSkinDemoAppView::~CSkinDemoAppView()
{
 ...
 delete iBgContext;
 ...
}

5. As we are ready with a context that has the backgoround that we want to use in all controls. This is done throgh MOP relationship and we need to override the MopSupplyObject():

TTypeUid::Ptr CMyAppView::MopSupplyObject(TTypeUid aId)
{
 if (iBgContext )
 {
   return MAknsControlContext::SupplyMopObject( aId, iBgContext );
 }
 return CCoeControl::MopSupplyObject(aId);
}

6. Each control Draw now be updated to display the skin as background:

void CMyAppView::Draw(const TRect& aRect) const
{
 // Get the standard graphics context
 CWindowGc& gc = SystemGc();
  
 // Redraw the background using the default skin
 MAknsSkinInstance* skin = AknsUtils::SkinInstance();
 MAknsControlContext* cc = AknsDrawUtils::ControlContext( this );
 AknsDrawUtils::Background( skin, cc, this, gc, aRect );

 ...
}

and

void CMyAppView::SizeChanged()
{
 if(iBgContext)
 {
       iBgContext->SetRect(Rect());
    if ( &Window() )
    {
        iBgContext->SetParentPos( PositionRelativeToScreen() );
    }
 }
}

7. Now we are ready so if we have to use it in a list box then we can use as below.
ListBox->ItemDrawer()->ColumnData()->SetSkinEnabledL(ETrue)

Header Files: AknsDrawUtils.h, AknsBasicBackgroundControlContext.h
Lib Files: aknskins.lib aknskinsrv.lib

note:
1. Nokia has introduced skin support only in S60 v2.
2. Unfortunately, the Skin API is not very well documented and may not be compatible in S60 3rd Edition

2008-04-04T19:15:00.001+08:00

Nokia OS [NOS / ISA]

Nokia OS (NOS) is an informal name for the operating system in many Nokia mobile phones. These are informal names, there is no such product or trademark. Officially it is referred as ISA platform. It is a proprietary platform only for Nokia's internal use, it is not licensed to anyone. No direct API is provided either, but most ISA phones can be programmed with J2ME. It is sometimes called the "domestic OS"..

ISA powers Nokia Series 40 and Series 30 mobile phones.

2008-04-04T19:12:00.000+08:00

Obtaining UID of a calling application.

The Call Application UID is 0x10005883.

you can find in the following way :
1) Firstly retrieve window id of Call Application.
2) Then passe this Window id to CApaWindowGroupName::FindByAppUid function which returns the UID.

2008-04-04T16:40:00.001+08:00

How to start a application in a specific orientation

By default, applications are started in the current orientation of the device screen. In order to force an application to be started in landscape mode or portrait mode, a corresponding flag needs to be passed to the BaseConstructL() function in AknAppUi::ConstructL():

void CMyAppUi::ConstructL()
   {
   BaseConstructL( EAknEnableSkin | EAppOrientationLandscape );    // start in landscape mode
   //BaseConstructL( EAknEnableSkin | EAppOrientationPortrait );    // start in Portrait mode
   ...
   }

Note: enums Passed BaseConstructL() are different from enums that are passed to SetOrientationL().

2008-04-04T16:38:00.000+08:00

How to change screen orientation of UI application

void CMyClass::RotateMe()
    {

    // Change the screen orientation.
    if (CAknAppUi::EAppUiOrientationPortrait != AppUi()->Orientation())
        {
        AppUi()->SetOrientationL(CAknAppUi::EAppUiOrientationPortrait);
        }
    else
        {
        AppUi()->SetOrientationL(CAknAppUi::EAppUiOrientationLandscape);
        }
    }

2008-04-04T15:58:00.000+08:00

How to handle Foreground / Background events

The application framework calls CCoeAppUI::HandleForegroundEventL() when the application is switched to the foreground or background. While the default implementation of this method is empty, it can be, for example, used to display messages or pause a game when a focus change event occurs.

Example:

void CMyViewAppUi::HandleForegroundEventL(TBool aForeground)
    {
    if (aForeground==TRUE)
        {
        iEikonEnv->InfoMsg(_L("Foreground true"));
        }
    else
        {
        iEikonEnv->InfoMsg(_L("Foreground false"));
        }
    }

Note: The aForeground parameter is true if the application is switched to the foreground (is visible) and false if the application has gone to the background.

2008-04-04T15:57:00.001+08:00

How to handle Layout change events

Layout change events are generated when the screen size or layout is changed. The S60 platform supports multiple screen resolutions[also called as "Scalable UI"]. Thus, layout awareness is particularly crucial for those applications to reorganize the position as required. Applications can detect the changes in layout with, for example, the following methods:

1. Controls can override the CCoeControl::HandleResourceChange() to detect the KEikDynamicLayoutVariantSwitch message.
The following example code for HandleResourceChange():

    void CMyControl::HandleResourceChange(TInt aType)
        {
        CCoeControl::HandleResourceChange(aType); //call base class implementation
        if ( aType==KEikDynamicLayoutVariantSwitch )
            {
            TRect rect;
            // ask where container's rectangle should be
            // EMainPane equals to area returned by
            //CEikAppUi::ClientRect()
            AknLayoutUtils::LayoutMetricsRect(AknLayoutUtils::EMainPane,rect);
            SetRect(rect);
            }
        }

2. UI controllers can override the CEikAppUi::HandleResourceChangeL() to detect the KEikDynamicLayoutVariantSwitch message.

The following example code for HandleResourceChangeL():

    void CExampleAppUi::HandleResourceChangeL(TInt aType)
        {
        CAknAppUi::HandleResourceChangeL( aType );
        if ( aType == KEikDynamicLayoutVariantSwitch )
            {
            // do the re-layout of the components
            }
        // Controls derived from CCoeControl, handled in a
        // container class
        iExampleControlContainer->HandleResourceChange( aType );
        //Must not call this if the components are on the control stack
        //iView->HandleResourceChangeL( aType );
        }

2008-04-04T15:53:00.000+08:00

S60 View based UI application architecture

The S60 view architecture only allows one view to be active in each application. If a new view is switched to within an application, the current view is immediately deactivated.

S60 platform applications that follow the S60 view architecture require:

1. A UI controller derived from CAknViewAppUi
Responsibilities are
a) It creates one or more CAknView-derived view controllers.
b) It handles events that are not handled by the view controllers.
c) To switch between views, it activates and deactivates views.
d) It handles menu commands passed to it by the view controllers.
e) It receives events such as layout and foreground notifications from the run-time environment.

2. A view controller derived from CAknView
Responsibilities are
a) It creates one of more CCoeControl-derived views.
b) It handles registering controls for key event handling.
c) It handles menu commands.

3. 1 or more views derived from CCoeControl
Responsibilities are
a) Shows application data and state on the screen.

As this architecture allows one view to be active in each application, so it is not appropriate in the following cases:

1. Applications with any view that cannot cleanly handle unexpected activation of another view in that application.
2. Applications that provide views that can be nested over other applications, [except where embedding is used.]
3. Applications that provide controls that can be used inside other applications (for example, using a Web control inside an e-mail viewer to show an e-mail with HTML content).

2008-04-04T15:50:00.000+08:00

Traditional Symbian OS UI application architecture

The traditional Symbian OS UI application architecture provides the most flexible approach to application UI construction. Traditional architecture is easier to port across different platforms. Traditional architecture is also the best choice for single-view applications, if launching the view from external applications is not required.

S60 platform applications that follow the traditional Symbian OS UI application architecture require:

1. A UI controller derived from CAknAppUi
Responsibilities are
a. It creates one or more CCoeControl-derived views.
b. It handles events, including enabling views to handle key events.
c. To switch between views, it creates and destroys or shows and hides views.
d. It handles menu commands.
e. It receives events such as layout and foreground notifications from the run-time environment.
2. 1 or more views derived from CCoeControl
Responsibilities are
a. Shows application data and state on the screen.
b. Receives user input.
c. Notifies the CAknAppUi-derived class of relevant events.
d. Often observes model changes (directly or via the UI controller) and updates the screen accordingly.

2008-04-04T15:48:00.000+08:00

UI Controller in S60

UI controller is an object derived from either CAknAppUi or CAknViewAppUi, depending on your UI architecture. The UI controller is part of the controller structure in the Model - View - Controller (MVC) design pattern used to design the architecture of many GUI-based mobile applications.

Examples of services and responsibilities provided by the UI controller are as follows:

1. control stack for event handling
2. construction of views for applications
3. the top-level window owning control of the application

The UI controller is implemented in one of the following classes:

1. In a traditional architecture application architecture, the UI controller must be derived from CAknAppUi.
2. In S60 View application architecture, the UI controller must be derived from CAknViewAppUi.
3. In dialog architecture, the UI controller is typically derived from CAknAppUi

2008-04-03T19:51:00.001+08:00

3 things you must have in mind while making your application scalable.

If your application is scala then you allow your application to support the different display sizes, resolutions, and layouts for different S60 devices.

1. Layout information should not be hard-coded.
The S60 platform provides the AknLayoutUtils class for building layouts from resource files.
Note: that you need to override CCoeControl::HandleResourceChange and CEikAppUi::HandleResourceChangeL in your application to draw your application again in the event that the orientation of the display changes.
2. Scalable fonts should be used.
The S60 platform provides methods in the AknLayoutUtils for using logical fonts from an enumeration in the avkon.hrh file.
3. Scalable icons should be used.
Scalable icons are based on SVG Tiny (SVG-T) format graphics.

2008-04-03T19:50:00.001+08:00

10 things you must remember when doing internationalization of your application:

1. Keep code and content separate.
2. Use Locales.
3. In UI component design, allow for text expansion.
4. Do not concatenate. [Localizing concatenated strings is difficult or impossible.]
5. Do not reuse strings. [The context, meaning, or the space available may change, making localization difficult.]
6. Use re-orderable parameters in strings.
7. Do not use text in graphics. [It all needs to be localizable.]
8. Comment the text strings.
9. Use common components
* Use AVKON component library wherever possible.
* Use StringLoader.h for re-orderable parameters.
* Use CharConv for inbound and outbound character conversions.
* CharConv contains conversion tables for all supported S60 languages and most common encodings.
* Use locale for sorting.
* Use AVKON time and date formatter strings for time/date formatting, or if you need to have new formats, use locale formatters.
10. Follow the formats / templates provided by symbian.

2008-04-03T18:41:00.000+08:00

What is Data Caging in Symbian V9.x?

Data caging means that different applications are allowed to access only particular data areas. This prevents applications from accessing the private data of other applications.

The following list describes where different file types are stored on a mobile device:

1. The \sys\bin folder contains all binaries. This is the only folder from where an application can be launched.
Note: An application cannot read (or write) anything under the \sys\ folder without AllFiles (or TCB) capability.

2. The private (\private\) folder includes folders for all applications. The \ subfolders are application-specific and applications can access only their own folders. An application with AllFiles capability can access all private directories. The directory name under \private is determined by the SecureId (SID) of the application. If an SID is not specified, the UID3 provided in the mmp file is used.

3. The resource folder (\resource\apps\) is used for resource files of applications. This data can be icons, bitmaps, and other material useful for all the applications. Read access is allowed by all applications, write access only by processes with the AllFiles capability.

Note: So if you want to shared File / databse for both read and write between applications or between 2 exes of same application, then use a folder in c:\data\

2008-04-03T18:38:00.001+08:00

What are @publishedAll APIs and How to find out which is @publishedAll API or not.

These Group/set of symbian APIs can be used by a 3rd party developer to futre proof his application. That means these APIs will be changed in feature versions of the SDK. So @publishedAll APIs are binary and source compatible across OS releases

By checking the .h files for the API a developer can find out if the API is @publishedAll or not.

Other tags included in Symbian headers are.
01) @internalTechnology
02) @internalComponent
03) @internalAll
04) @publishedPartner
05) @publishedAll
06) @prototype
07) @interim (a deprecated synonym of @prototype)
08) @released
09) @deprecated
10) @removed
11) @test

2008-04-03T18:01:00.002+08:00

How To: Remove an installed application from the WINS Emulator?

All applications on symbian os emulator must reside in
[EPOCROOT]\epoc32\release\wins\udeb\z\system\apps\
or
[EPOCROOT]\epoc32\release\wins\urel\z\system\apps\
or
[EPOCROOT]\epoc32\wins\c\system\apps\

just delete the dir of the application you want.

Note: only applicable to pre-Symbian v9

2008-04-03T17:59:00.000+08:00

How To: display global notes (independent of the focused view)

CAknGlobalNote* iGlobalNote = CAknGlobalNote::NewL();
CleanupStack::PushL( iGlobalNote );
iGlobalNote->ShowNoteL(EAknGlobalConfirmationNote, _L(”Screenshot taken!”));
CleanupStack::PopAndDestroy();

2008-04-03T17:58:00.000+08:00

How To: make asynchronous functions synchronous?

Simply add WaitForRequest() and remove SetActive();

Example:

TRequestStatus iStat = KRequestPending;
iEncoder->Convert(&iStat, *iImage, iJpgImageData);
User::WaitForRequest(iStat); //Remove SetActive();

2008-04-03T17:49:00.001+08:00

How To: avoid repetitive key events when pressing a key?

Use TEventCode to only capture EEventKeyDown:

TKeyResponse CAppUi::HandleKeyEventL(const TKeyEvent& aKeyEvent, TEventCode aType)
{
if((aKeyEvent.iScanCode == ‘*’)&& aType == EEventKeyDown)
{
iMenuView->HandleCommandL(ECommand);
return EKeyWasConsumed;
}
else
return EKeyWasNotConsumed;
}

2008-04-03T17:48:00.001+08:00

How To: Externalizing and internalizing descriptors

Example:

TBuf KMaxFileNameLength iFileName
void TSettings Settings::ExternalizeL(RWriteStream& aStream) const
{
    aStream << iFileName;
}

void TSettings::InternalizeL(RReadStream& aStream)
{
    aStream >> iFileName;
}

2008-04-03T17:47:00.002+08:00

In which files are UIDs used? (In Symbian v9.x)

a. in xxxApplication.cpp file static const TUid KUidXXXApp = {0xXXXXXXXX};
b. in .pkg file Header #{”XXX”},(0xXXXXXXXX),1,0,0
“..\sis\backup_registration.xml” -”!:\private\xxxxxxxx\backup_registration.xml”
private directory
c. in resource file xxx_reg-rss UID3 0xXXXXXXXX
d. when sending application to the background (HandleCommandL)
e. in paths to private directory
f. In project/properties!

2008-04-03T17:47:00.001+08:00

In which files are UIDs used? (In Pre-Symbian v9.x)

UIDs have to be stored in several locations:
1. in xxxApplication.cpp file static const TUid KUidXXXApp = {0xXXXXXXXX};
2. in .pkg file Header #{”XXX”},(0xXXXXXXXX),1,05,223
3. in .mmp file UID 0×100039CE 0xXXXXXXXX
4. in iaf resource file xxxaif.rss RESOURCE AIF_DATA { app_uid=0xXXXXXXX;….}
5. when sending application to the background:

CApaWindowGroupName* wgName = CApaWindowGroupName::NewLC(CCoeEnv::Static()->WsSession(), task.WgId());
if (wgName->AppUid().iUid == 0xXXXXXXXX) //ur application uid
{
response = ETrue;
task.SendToBackground();
}

2008-04-03T17:44:00.002+08:00

How To: Symbian Signing and unsigning a sis

a. During development and testing a developer or self-signed certificate is used ( sis-file is signed with Createsis wrapper tool in Carbide)
b. Before submitting to test house developer certificate is stripped using “createsis strip” : createsis strip xxx.sis xxxstripped.sis
c. For freeware the stripped sis-file can be sent to user.( to be signed by user on there own)
d. For Commerical applications the sis-file has to be signed with ACS publisher ID with “signsis” :
signsis xxxstripped.sis xxxsigned.sis xxxx.cer xxxx.key
remark: “createsis sign” should perform the same but does not seem to work
e. At each stage the signing status of the file can be checked with “VerifySymbianSigned” : verifysymbiansigned xxx.sis
verifysymbiansigned.exe You need to log in and then download.

2008-04-03T17:44:00.001+08:00

HowTo: Backporting from 3rd to 2nd edition

1. Create new S60 project
- File | new |C++ application for S60 project (choose view based app)
- Add UID
2. Delete all unnecessary files
Keep following files:
src: xxxapp.cpp xxxdocument.cpp
inc: xxxapp.h xxxdocument.h xxx.loc xxx.hrh
data: xxx.rss xxx_caption.rss
aif: xxx.aifdef xxxaif.rss
sis: xxx.pkg
3. Import 3d edition files
src/inc: from appui
aif: icons + add them in aifdef
4. Overwrite files
rss
hrh
loc
pkg
5. Add libraries
6. Add include path inc/icl
7. Change include and class names in xxxdocument.cpp and xxxdocument.h
8. Change parts of code (back port)
9. Change file location (settings file, sounds, images,…)
10. Replace name of all xxx.rsg , xxx.hrh xxx.mbg files
11. Replace all UIDs
12. Replace svg images with mbm files
13. pur resource files in right places

2008-04-03T17:42:00.000+08:00

HowTo: Security diagnostics and capability violations

In order to check capability violations build and run for the emulator and chsck the epocwind.out log-file located in “C:\Documents and Settings\myName\Local Settings\Temp\EPOCWIND.OUT” Lines to search for start with *PlatSec* . PlatSecDiagnostics has to be turned to ON in the Epoc.ini file located in Epoc32/data Capabilities allowed with self-signing : ReadUserData, WriteUserData, UserEnvironment, LocalServices, NetworkServices Leave all certificate fields including password empty

2008-04-03T17:41:00.000+08:00

Free Symbian code verification tools

Automatic code verification tools are a great help to increase the production quality of software and also increase the probability to pass certification. They offer a quick and powerful way to get your code at a professional level.

Below an overview of the available tools:

1. The Symbian C++ compiler

The compiler is of course the first verification tool for your code, though at the most basic level to get your code working. However, warnings often are not taken seriously although they are an important indicator for the cleanliness of your code.

2.SymScan

SymScan is a free command line tool scanning for deprecated literal macro (“_L()”) , correct usage of the Cleanup stack , opening and closing of ‘R’ classes, functions marked as non-leaving which can leave and correct use of descriptors in function calls. It is available for download at the offical Symbian site.

This utility is installed in the C:\Program Files\Common Files\Symbian\Tools\ directory.

To scan single files, type from a Windows command prompt:

symscan “filename.cpp” where filename.cpp is the name of the file you want to scan.

To save the results you can pipe the output to a file e.g. symscan myfile.cpp > output.txt

There are several command line options, to limit the scanning to look for specific warnings.

-H : Display help on available commands
-C : Scan for CleanupStack violations
-D : Scan for misuse of descriptors
-S : Scan for standards violations i.e. deprecated _L()
-L : LeaveScan will be executed when SymScan has completed parsing of the source file.
-A : Perform all scans

e.g. to scan for misuse of descriptors use the following: symscan -D t1.cpp >output.txt

Symscan can also be run from the command line to scan whole directories and output to a file. Use the Windows “for” command to scan directories, eg:

for /R %i in (*.cpp) do SymScan “%i” >> SymScan.txt

SymScan guarantees your code is compliant with the basic Symbian guidelines.

3.Review-X

The trial version of Review-X available at the website of Tieto-X is limited to checks on Leaving function naming, class naming and function parameter naming. The price of the registered version is 500 Euros per license and includes:

• constant naming
• delete without reassignment
• standard C++ construction
• member variable destruction
• leave with KErrNone
• T-class member variable types
• member variable naming
• multiple inclusion
• member variable cleanup
• standard C++ types
• NewLC used in a trap

The full version also offers access to the command line interface, which can be integrated into your build scripts. Review-X features an easy to use graphical interface and html based reporting.

4. LowMem

Although strictly speaking LowMem is not a code verification tool, it indirectly points to badly written Symbian code. LowMem checks the start-up behaviour under simulated low-memory conditions by systematically increasing the available memory at startup by 1 kbyte, starting at 40 kbyte.
Although this test is often described as “strange” it is very effective at exposing code which is not compliant with the Symbian code idioms. LowMem also reports the number of memory leaks. To pass the test a score of at least 90 % is required (less than 10 % failed startups).

5. AppTest Lite

As LowMem, not a code verification tool. AppTest Lite for Symbian OS pre-v9 from SysOpen Digia aims at fully testing against the Symbian Signed Test citeria:

PKG-01: ACS PUBLISHER ID
PKG-02: INSTALLATION AND START UP
PKG-03: FILE CREATION LOCATION
PKG-04: UNINSTALL
PKG-05: INSTALLATION TO ALL MEMORY DEVICES
PKG-06: REINSTALL
PKG-07: UID
GEN-01: SYSTEM FEATURES AND OS FRIENDLY
GEN-02: STRESS TEST
MEM-02: LOW STORAGE MEMORY DURING EXECUTION
PHN-01: SERVICE INTERRUPTION
PHN-02: UNEXPECTED REBOOT
CON-01: TASK LIST
CON-03: BILLABLE EVENTS
MEM-01: LOW MEMORY START-UP

When your application passes all of the above tests you can submit it for certification with some confidence (but no guarantee of passing).

LowMem and AppTest Lite are available at the SymbianSigned website.
Note: At the time of writing there is no avaliable LowMem tool for Symbian v9.x.

Conclusion

Code verification tools and related utilities are becoming very important in Symbian mobile development. They allow to quickly verify if your code is compliant with the Symbian guidelines and increase the likelyhood to pass certification tests. They highlight the importance of the quality and robustness of mobile software in the constrained and demanding environment of mobile devices.

2008-04-01T15:26:00.002+08:00

Using MIF files in Symbian OS (Part 1)

What is a Mif File

.mif files - Machine-readable files with all the SVG-t/bmp icons packed into them.

How to create a MIF File.

There are at least three ways.
1. The easiest way is to buy Adobe Illustrator CS2 to draw icons. Illustrator CS2 can save to SVG-Tiny format. It costs some money but it will save you a lot of time. If you're not great at drawing - there's a feature that will convert a photo to an SVG line drawing with color fills. So, make a photo of an object with your phone and have illustrator convert it to a line drawing.

2. You can download a free editor named Inkscape. Inkscape saves to SVG format but not SVG-Tiny. You'll have to use the SVG2SVGT tool to convert the icon (found under S60Tools folder in SDK). But there's a problem. If you use certain draw object types then Inkscape will produce SVG code that will not work. Start with a very simple image such as a box - test it - and then add some details. (Inkscape is open source Java so anyone of us could fix it to directly generate SVG-T for S60.)

3. You can type an SVG file into a text editor. It's XML syntax. {not recomended}

How to create a MIF file.

1. Direct mifconv call method
go to your folder where your SDKs tools folder then run following command

c:\Symbian\9.1\S60_3rd_MR\Epoc32\tools>mifconv MyNewApp.mif /c32 C:\TestIConPrj\gfx\Test_Icon1.svg ...
in this case the mif is created in the tools folder.

2. Using Make File Method
a) Edit bld.inf File

        PRJ_MMPFILES
       gnumakefile Test_Icon.mk
       TestIConPrj.mmp

b) Create Test_Icon.mk file
You can use the Templete as given below.

  
       ifeq (WINS,$(findstring WINS, $(PLATFORM)))
       ZDIR=$(EPOCROOT)epoc32\release\$(PLATFORM)\$(CFG)\Z
       else
       ZDIR=$(EPOCROOT)epoc32\data\z
       endif
      
       TARGETDIR=$(ZDIR)\resource\apps
       ICONTARGETFILENAME=$(TARGETDIR)\Test_Icon.mif
      
       HEADERDIR=$(EPOCROOT)epoc32\include
       HEADERFILENAME=$(HEADERDIR)\Test_Icon.mbg
      
       ICONDIR=..\gfx
      
       do_nothing :
           @rem do_nothing
      
       MAKMAKE : do_nothing
      
       BLD : do_nothing
      
       CLEAN : do_nothing
      
       LIB : do_nothing
      
       CLEANLIB : do_nothing
      
       # In the below lines the c32,8 the 32 is for the image and
       # 8 is for it's mask. See how the BMP file is mentioned
       # below the SVG's here.
      
       RESOURCE :  
           mifconv $(ICONTARGETFILENAME) /h$(HEADERFILENAME) \
               /c32,8 $(ICONDIR)\Test_Icon1.svg\
               /c32,8 $(ICONDIR)\Test_Icon2.svg\
               /c32,8 $(ICONDIR)\Test_IconN.svg\
               /c24  $(ICONDIR)\Test_BMPIcon1.bmp\
               /c8  $(ICONDIR)\Test_BMPIcon1_Mask.bmp\
               /c24  $(ICONDIR)\Test_BMPIcon2.bmp\
               /c8  $(ICONDIR)\Test_BMPIcon2_Mask.bmp\
               /c24  $(ICONDIR)\Test_BMPIconN.bmp\
               /c8  $(ICONDIR)\Test_BMPIconN_Mask.bmp
      
             
       FREEZE : do_nothing
      
       SAVESPACE : do_nothing
      
       RELEASABLES :
           @echo $(HEADERFILENAME)&& \
           @echo $(ICONTARGETFILENAME)
      
       FINAL : do_nothing

c) Clean build your project.
(note: you can't do this step from carbide.c++ or carbide.vs you have to use commandline).

        bldmake bldfiles
       abld reallyclean
       abld build gcce urel

Note:
1. Make your icon on a 44x44 pixel canvas. This might not be necessary in some cases but it is not clear whether S60 will scale your icon in all the places it can be used.

2. Keep in mind that S60 caches icons between runs of your application - so sometimes when you update an icon you still see the previous version. Do not losing your mind - it's caching the icon. Try restarting the phone when updating icons.

2008-04-01T13:03:00.000+08:00

S60 3rd Edition SDK FP2 - Workarounds and Updates

What is carbide.VS

Carbide.vs is targeted at developers with Visual Studio skills who want to create C++ applications for Symbian OS platforms. Carbide.vs provides easy entry into Symbian OS C++ development with wizards and other automated functions that integrate with Visual Studio. User can get started with minimal manual configuration. Carbide.vs also contains functionality to automate several development tasks specific to Symbian OS.

Versions

1. Carbide.vs 2.x is a Visual Studio 2003 plugin which enables developers to use Visual Studio.NET 2003 as the IDE for Symbian development.

2. Carbide.vs 3.x is a Visual Studio 2005 plugin that enables efficient Symbian OS C++ application development using the Microsoft Visual Studio.NET 2005 IDE and Symbian OS SDKs.

Workarounds for S60 3rd Edition FP2

The available Carbide.vs versions (2.0.2 and 3.0.1) do not detect the S60 3rd Edition FP2 SDK. The steps given below must be followed to ensure that Carbide.vs detects this SDK.
Carbide.vs 2.0.2:

Install Carbide.vs 2.0.2. Copy the S60_3rd_FP2_v2.xml file to the folder C:\Program Files\Common Files\Symbian\SDK Descriptors\Nokia for Carbide.vs to detect the SDK.

Carbide.vs 3.0.1:

Case I: No Previous SDKs are installed in the system

Step 1:
To skip the SDK detection while installation of Carbide.vs 3.0.1 make following registry entry HKEY_LOCAL_MACHINE\SOFTWARE\Nokia\Carbide.vs.30 -> Add String value "ForcePrereq" = "1".

Step 2:
To enable S60 3rd Edition, FP2 SDK detection in Carbide.vs 3.0.1, copy the S60_3rd_FP2_v3.xml file to the folder C:\Program Files\Common Files\Symbian\SDK Descriptors\Nokia.

Case II: Previous SDKs are already installed in the system

Step 1:
To enable S60 3rd Edition, FP2 SDK detection copy the S60_3rd_FP2_v3.xml file to the folder C:\Program Files\Common Files\Symbian\SDK Descriptors\Nokia.

2008-03-26T15:44:00.000+08:00

Symbian Signing Reference Wallpaper

2008-03-25T13:17:00.000+08:00

How to open SMS editor on self signed application?

If you like to open a SMS Editor with some pre-inserted text from youe Symbian.C++ Application then you can use
CSendUi::CreateAndSendMessageL().
Note: this api requitres DRM capabilty some how. [may be it can be used for sending DMD protected MMS]
But problem is you have can't Self Sign with this application.
The work around is you have to use
RSendAsMessage::LaunchEditorAndCloseL()

2008-03-25T12:26:00.000+08:00

How to Display Task List Programmaticaly.

Task list is actually part of the Eikon environment so its a simply to call via Eikon of your application.

CEikonEnv::Static()->DisplayTaskList();

2008-03-24T15:51:00.000+08:00

Getting Country Code and Operator name.

class CNetwork : public CActive
{
public:
    CNetwork(CTelephony* aTelephony);
   
    void ConstructL();
   
    ~CNetwork();
   
public: // New functions
    void StartL(TTimeIntervalMicroSeconds32 aDelay);
    void Stop();
   
private: // From CActive
    void RunL();
    void DoCancel();
   
public:
    CTelephony* iTelephony; // telephony object we own
    CTelephony::TNetworkInfoV1 iV1;
    CTelephony::TNetworkInfoV1Pckg iPkg;
    TTimeIntervalMicroSeconds32 iDelay;//get network interval
    TNetworkInfo iNetworkInfo;
};

CNetwork::CNetwork(CTelephony* aTelephony) : CActive(EPriorityStandard)
,iTelephony(aTelephony), iPkg(iV1)
{}

void CNetwork::ConstructL()
{
    CActiveScheduler::Add(this);
}

CNetwork::~CNetwork()
{
    Cancel(); // Cancel any request, if outstanding
}

void CNetwork::DoCancel()
{
    iTelephony->CancelAsync(CTelephony::EGetCurrentNetworkInfoCancel);
}

void CNetwork::StartL(TTimeIntervalMicroSeconds32 aDelay)
{
    Stop();
    iStatus=KRequestPending;
    iTelephony->GetCurrentNetworkInfo(iStatus, iPkg);
    SetActive();
}

void CNetwork::Stop()
{
    Cancel();
}

void CNetwork::RunL()
{
    if(iStatus == KErrNone)
    {
        TNetworkInfo tempNetworkInfo;
        TBuf<30>strTemp;
        strTemp = iPkg().iCountryCode;
        CAknInformationNote* note = new (ELeave) CAknInformationNote();
        note->ExecuteLD(strTemp);
    }
}

2008-03-20T18:15:00.001+08:00

Create a self-signed sisx using OpenSSL

If you want to create a self-signed certificate with validity periods other than 1 year, or with additional information about yourself, you can use a tool such as Open SSL to create it, rather than the standard MakeKeys utility that comes with the SDK.

1. Download OpenSSL for your OS. [In my case windows so i will use "Shining Light Productions" - > (Win32 OpenSSL v0.9.8g Light). here
2. Install on your platform. (I assume that you installed on c:\OpenSSL)
3. Open a Command line and change directory to c:\OpenSSL\. [cd c:\OpenSSL\]
4. Run command "bin\openssl genrsa 1024 >selfsigned.key"
5. Run command "bin\openssl req -new -x509 -nodes -sha1 -days 3650 -key selfsigned.key >selfsigned.cer"
6. Fill in the information when assked for it.

You are about to be asked to enter information that will be incorporated
into your certificate request.
What you are about to enter is what is called a Distinguished Name or a DN.
There are quite a few fields but you can leave some blank
For some fields there will be a default value,
If you enter '.', the field will be left blank.
-----
Country Name (2 letter code) [AU]:SG
State or Province Name (full name) [Some-State]:Singapore
Locality Name (eg, city) []:Singapore
Organization Name (eg, company) [Internet Widgits Pty Ltd]:My Company
Organizational Unit Name (eg, section) []:Mobile Div
Common Name (eg, YOUR name) []:Sunil Kumar
Email Address []:skumar.mobiledev@gmail.com

7. copy selfsigned.key and selfsigned.cer to your sis folder.
8. change your path to sis folder.
9. Run Command "signsis -s my_unsigned_sis.sis my_singed_sis.sisx selfsigned.cer selfsigned.key"
10. Now you can use my_singed_sis.sisx to install on any symbian v3 device.

2008-03-19T15:19:00.000+08:00

Signing With Open Signed - A Tutorial...

A lot of people have been howling about the way Symbian Signed is going and criticising the change in system. As of now, nobody without a Publisher ID can create developer certificates and instead users are forced to use the new Online System. Open Signed has some positives and even more negatives although signing files capable of being signed (applications which are using unprotected UID range) is easier now and even need an account is not needed anymore. A lot of great freeware thus currently cannot be signed that way.

Bery from the SymbianWebBlog has wriiten a complete guide on how to sign files using that system. He is using “GenialSis 2.0? for the purpose. So if you are looking to sign any of these LandscapePro, RockNScroll, ShakeMe, Gnubox, FlipSilent, ShakeLock, LargeTime, Audio Cube, Autolock, Callfilter, Calsync, CuteKeys, EmTube, Themes Laucher and so on jump over for the complete how to.

Read More ...
Try getting "GenialSis 2.0" from authers Site. here.

2008-03-18T12:32:00.002+08:00

Capabilities grouped by Signing procedure ...

1. Self-Signing (Basic capabilities)
* LocalServices
* UserEnvironment
* NetworkServices
* ReadUserData
* WriteUserData

2. Express Signing (Extended capabilities)
* Location
* SwEvent
* SurroundingsDD
* ProtServ
* PowerMgmt
* ReadDeviceData
* WriteDeviceData
* TrustedUI

3. Certified Signed (Extended capabilities)
* NetworkControl
* MultimediaDD
* CommDD
* DiskAdmin

4. OEM + Certified Signed (Manufacturer-approved capabilities)
* AllFiles
* DRM
* TCB

2008-03-18T12:27:00.000+08:00

How to sign applications for free?

Note: This is only applicable to Symbian v3 onwards.

If you are a freeware developer, you may want to be able to develop your own stuff for your device (or No IMEI restriction) for free. You don't want to buy a Publisher ID, nor would you pay for any external testing or signing.

Then here are the steps...

To make a S60 3rd Ed (Symbian OS v9) application you have to:

1. Write you application (use UID from the unprotected range, 0xe0000000 - 0xefffffff ) on Windows PC/ Linux / Mac.
2. Try to use Symbian APIs that require only user granted capabilites. [LocalServices, UserEnvironment, NetworkServices, ReadUserData, WriteUserData ]
3. Test it on Symbian EMULATOR that comes with SDK.
4. make a SIS (use makesis)
5. make your own certificate and key. (use keygen)
6. sign it (the SIS file). (use signsis)
7. transfer it to device usign PC Suit or Bluetooth.

Note: If you are using APIs that are Non-user granted capabilites, then you have to get a Publisher ID and havet opay for signing and/or testing.

2008-03-17T20:16:00.000+08:00

Signed Online vs Developer Certificate Q&A

1.1 Why did you suddenly turn off the ability to download Developer Certificates without a Publisher ID?.

Current plans and approach were announced in consultation with the developer community in September 2007 and implementation has been phased in since that time.

Many non-developers have been accessing the site through unapproved tools; hence it may have appeared sudden to these users as these unapproved tools would have stopped working and any documentation provided may not have been updated.

1.2 My friends have certificates which are still valid for their phone, why can't I get one?

In September 2007, we announced that we would provide an alternate solution to Developer Certificates using Open Signed Online, which is now in beta (since February 2008). Test applications can now be signed more simply without the need to acquire a Developer Certificate.

1.3 My phone was broken and returned and my certificate does not work, why can't I get a new one?
Open Signed Online will work for developing applications on your new phone. Developer Certificates are not necessary.

1.4 I paid money for my phone and should be able to install whatever software I want, why are you stopping me?

There are 10,000+ applications available, where developers have followed the correct release and deployment process, such that they can be installed on your phone without requiring you (the end-user) to use Symbian Signed service.

This is approach is in line with agreed mobile industry recommendations.

Symbian Signed is provided for development and testing purposes only. The policy of what an end-user can install on their phone, without Symbian Signed, is determined by your device manufacturer, via the concept of “User-Grantable Capabilities” configured by the manufacturer on shipment.

A small number of developers are forcing end-users to go through a process intended for developers only.

1.5 Why can I not get a certificate to sign Freeware, there is no other way to install Freeware?

Contact your freeware developer and request him/her to re-release the application such that Developer Certificates are not required.

a) Approx 60% of APIs do not require any Capabilities and applications using only those APIs do not need to use Symbian Signed services.

b) The Capabilities; LocalServices, Location*, NetworkServices,ReadUserData ,UserEnvironment, WriteUserData: are user-grantable on the device. Applications using these Capabilities are not required to be Symbian Signed; an end-user can grant the permissions on their device. This allows people to do application development with a large amount of functionality for interesting apps. At least 25% of commercial apps are released without needing to use any Symbian Signed services.

c) The Capabilities; PowerMgmt, Location*, ProtServ, ReadDeviceData, SurroundingsDD, SwEvent, TrustedUI, WriteDeviceData: are grantable by Open Signed Online, as well as all the user grantable permissions described in (2) .There is a requirement (as requested by the developer community) that you must own the application’s UID, or you may use a test UID (i.e. in the range 0xE0000000 to 0xEFFFFFFF). This protects the integrity of UID allocation process and prevents developers signing applications with UIDs which have been reserved by other developers.

Note: Location* depends on device type

1.6 I donated money to Freeware providers for their software and now I cannot install it because my phone has changed, why are you stopping me doing this?

Contact your freeware developer (especially if they are accepting money) and request him/her to be responsible and release the application appropriately as most other developers have done; i.e. Express Sign the applications to assure end users that the application comes from a trusted source and meets the recommended minimum quality level as detailed in the Symbian Signed Test Criteria.

1.7 Why is Symbian trying to make me pay $200 to get developer certificates, they are just trying to make more money?

Symbian does not receive any money for a Publisher ID. Publisher IDs are available from TC Trustcenter and meet industry-agreed identity requirements for tracing the origin of an application.

Publisher IDs are required to release applications to end-users in the mass market; developers using Express Signed and Certified Signed only need to obtain a Publisher ID once.

1.8 I bought my phone specifically so that I can install applications like RotateMe, why can I no longer get a Developer Certificate?

A beta UIQ version of RotateMe is being successfully signed via Open Signed Online the correct appropriate manner.

1.9 Why does Open Signed Online not work with Freeware applications?

There are 1000s of applications (including freeware) being successfully signed using Open Signed Online. Please contact the developer and encourage them to release their application in the correct manner.

1.10 The Freeware route through Symbian does not work, how else can I distribute my Freeware application?

There are already 1000s of applications (including freeware) being successfully signed using Open Signed Online?

Once tested and as your freeware application becomes more popular, please consider going through Express Signed; it provides more trust to end users and Open Signed has a finite capacity which may have to be limited if it is over-used.

1.11 Why is there all this security on Symbian OS, why can’t my phone just be completely open like others’ mobile phones?

Symbian Signed’s approach to security is in line with mobile industry recommendations http://www.omtp.org/ProductProfile/ . All open mobile phones shipping in mass market volumes are required to have some degree of trust and quality to protect mass market consumers’ from damage caused by poor applications.

Symbian Signed aims to allow developers to sign an application once to deploy globally, without needing to be concerned by other stakeholders controlling the channel for deployment to a device.

It is important that on behalf of mass market consumers, developers meet the requirements of Symbian Signed Services to provide trust and quality to deploy applications to 100s-of-millions of devices.

1.12 I am not a developer I just own a phone, why do you keep saying you are thinking about developers?

Symbian Signed is provided as a tool for developers to develop and release trusted applications for Symbian OS. The expectation is that developers should provide trusted and high quality applications to end users by ensuring their applications meet the Symbian Signed Test Criteria (using Express Signed and Certified Signed).

Unfortunately a small number of developers are encouraging end-users to access Symbian Signed themselves rather than release applications in the correct manner.

Device Manufacturers implement “User-Grantable Capabilites” on your device which determine what can be installed on your device without being Symbian Signed. As such many applications (and most certainly end-users) do not need to be aware of Symbian Signed.

By installing an application that has been signed only with a Developer Certificate, you have no guarantee of origin and you put your device at increased risk of damage through a poorly performing application.

1.13 I just want to sign the “Hello World” application that I have developed using Carbide to run on my Nokia phone.

You should not need to use any Symbian Signed services to do this successfully. Check the documentation on Forum Nokia’s web site via the following link:
http://wiki.forum.nokia.com/index.php/Carbide.vs_Creating_and_deploying_projects_on_hardware

1.14 Why do you only allow developers with a Publisher ID to acquire a Developer Certificates?

This allows traceability to and accountability of the company responsible for signing (including Developer Certificates).

1.15 I would like to purchase a Publisher ID, but I was told that only professional developers are able to get them. Is that right, or can anyone purchase such a certificate ?

In compliance with industry recommendations (e.g. http://www.omtp.org/ProductProfile/) for Signing Schemes, a Class 3 Publisher ID is obtainable from TC Trustcenter.

An Authorised Entity MUST be validated by either of the following:
- Confirmation of articles of incorporation or
- Registration with 3rd party databases (e.g. Dun and Bradstreet, German Handelsregister)
- Or equivalent

Class 3 certificates establish a level of trust that meets high standards for commercial needs. Any organizational data contained in a certificate is confirmed on the basis of the company memorandum (or similar documents) or documents signed by authorized employees.

Class 3 certificates state, in addition to the checks required that

1. A natural person be responsible for the certificate has been identified on the basis of his official identity card or passport.
2. Personal data contained in the certificate matches with that in the identity card or passport. “

1.16 I want to purchase a publisher ID, but before I do, I have some questions: how many IMEIs can I enter when creating a .csr file?.

Open Signed Offline using a Publisher ID allows a Developer Certificate to be created with up to 1000 IMEIs

1.17 How many certificates can I generate per day on www.symbiansigned.com if I use a publisher ID? Are there any other limits when I have a publisher ID?

There are daily limits in place to ensure fair usage. The limits are subject to change and are in line with reasonable development scenarios; i.e. a small number each day.

1.18 Will Developer Certificates be available for users without a Publisher ID again? if not,why?

Open Signed Online grants the same functionality as Developer Certificates, allows fair usage and has an easier to use interface with no registration/login required.

1.19 What is the UID Range for Open Signed Online?

Open Signed Online allows SIS files to be signed where
- UIDs are in the Test Range (0xE0000000 to 0xEFFFFFFF) OR
- UIDs where the email address of the submitter matches the email address of the UID owner for the Protected Range (0x20000000 - 0x2FFFFFFF) and Unprotected Range (0xA0000000 - 0xAFFFFFFF)

1.20 I tried out the Open Signed Online beta now, with an application with an UID from the unprotected range (0xa000112c). Despite this, I got this error message:
“FAILURE: Submitted .sis file uses a UID that is not allocated to the account holder matching this email address (0xa000112c)”

Open Signed Online allows SIS files to be signed where
- UIDs are in the Test Range (0xE0000000 to 0xEFFFFFFF) OR
- UIDs where the email address of the submitter matches the email address of the UID owner for the Protected Range (0x20000000 - 0x2FFFFFFF) and Unprotected Range (0xA0000000 - 0xAFFFFFFF)

1.21 Aren’t packages with UIDs from this range intended to be signable by anyone?

The approach that has been implemented was at the request of developers to ensure they retain control over how their UIDs were used. Current recommendations are

- Protected Range (0x20000000 - 02AFFFFFFF): Only to be used in Open Signed by the owner of the UID and required for Express Signed and Certified Signed.
- Unprotected Range (0xA0000000 - 0xAFFFFFFF): Only to be used in Open Signed by the owner of the UID, cannot be used in Express Signed and Certified Signed.

1.22 Do I need to register an account on symbiansigned.com to use Open Signed Online?

Registration/Login is not required to use Open Signed Online.

However if you need to use UIDs in the Protected (0x20000000 - 0x2FFFFFFF) and Unprotected Range (0xA0000000 - 0xAFFFFFFF)your submission email address must match the email address of the UID owner.

1.23 What is the Size limitation on files submitted for signing?

- Open Signed Offline: No effective limit, done locally on your development machine
- Open Signed Online: 4Mb
- Express Signed: 40Mb
- Certified Signed: 40Mb

2008-03-15T13:37:00.000+08:00

Some Suggestion to Symbian Signing ....

ReadMore

2008-03-04T12:33:00.000+08:00

Symbian Dev Certs without Publisher ID

Well, Symbian has taken away the facility to create dev certs without a publisher ID. (For Time being)

This means people can’t sign and use many of the freeware applications currently available. Symbian intend to introduce the new Open Signed process soon but until then there are lots of unhappy and confused people.

No need to panic it will be back soon and it will get better then what was in past.

From symbian Docs..

2008-03-02T01:43:00.000+08:00

Open Signed Online starts next Week

I think most of us hardcore Symbian users will have noticed that Symbian Signed was offline for all the ordinary people without a publisher ID.

A real shame, just now when unsigned great applications like “RockNScroll” are being published and people can’t use it because of the nerving signing process.
Signing has been introduced by Symbian to raise security, but the current result is more than disappointing. The basic idea doesn’t seem bad, but signing should at least be possible EVERYTIME.

It’s clear that this is not the case. The current offline state is no exception. Symbian Signed had quite much failures in the past. This keeps not only developers away from developing for Symbian, also newbies are not able to use great 3rd party software.

Although we don’t know anything about Symbian Signed is working at the problems for ordinary users, Symbian Signed has finally announced today an overworked signing service for developers without a publisher ID:

We will commence roll-out the Beta version of Open Signed Online at the beginning of next week.

As demand is currently higher than the PKI signing capacity, you may experience some restrictions on availability. We are in the process of adding new PKI signing hardware to the signing service to increase signing capacity (but this will take several weeks to configure)As outlined below there is a maximum number of requests that we can service each hour which limits the number of users that can request at one time.Open Signed Online Beta will be available next week with the following restrictions:

• The Open Signed Online process is fully described here
• During initial stages of the Open Signed Online beta, the service may only be available from 0900-1500 GMT (UK time) Monday-Friday.
• Until capacity is increased with additional servers, there is a maximum number of requests that can be serviced each hour, if there is excessive demand (which is expected), some users may find Open Signed Online beta is not available.
• As for any beta, there may be issues that impact the performance and/or functionality of the service. Such problems may result in the service being taken off-line at short notice and/or for extended periods.
• Note: Open Signed Online does not allow you to sign a SIS that uses a UID from the “Protected Range”, unless the email address you use for Open Signed Online MATCHES the email address of the account which owns/created the UID.
• If you attempt to sign the same SIS file in rapid succession, the service you receive will proportionally slow down. This is to provide fair access to all.
• Installation of the signed SIS file will be restricted to a single IMEI (i.e. mobile phone) that you enter and valid for 36 months.
• SIS files that have been Open Signed will present a notification upon installation that the SIS file is intended for development purposes only.
• SIS files can be signed for all Platform Security Capabilities except CommDD, MultimediaDD, NetworkControl, DiskAdmin, DRM, AllFiles, TCB.

Let’s hope that the new Open Signed service will win over even more developers for Symbian. And Symbian Signed should work on the signing problems for normal people…

More information: http://www.symbiansigned.com/app/page