মুখোশে মেফিস্টোফিলিস

boost c++ library for mac OS X

2011-05-26T01:23:00.003+06:00

Just tried out boost c++ library with eclipse c++ for mac OS X. The procedure is as follows:

I have used this boost library for mac OS X.

1. Download the library.

2. unpack it.

3. run sudo ./bootstrap.sh

4. run sudo ./bjam architecture=x86 address-model=32_64

please note the command options. For the latest gcc (4.2.1) you need to explicitly state the address-model. Otherwise you will get linker error while trying to use any binary libraries of boost.

5. In Eclipse, go to project --> properties --> C/C++ build -->Settings

a) In Mac OS X C++ Linker --> Libraries --> Libraries(-l) add the library names without the prefix "lib" and suffix ".dy.lib" . So, if you are using libboost_system.dy.lib then add "boost_system".

b) In Mac OS X C++ Linker --> Libraries --> Library Search Path (-L) add the boost c++ installation library folder (e.g. "add /usr/local/boost_1_46_1/lib") .

6. Go to project-->Properties--> C/C++ build-->Settings --> GCC C++ Compiler-->Directories-->Include Paths (-I) and add the boost c++ installation folder there.

Then compile and run a code using boost c++ binary library.

A very small but good tutorial on thread safety in C++

2011-05-19T08:09:00.001+06:00

Here it is

Elegance of STL

2011-01-06T23:33:00.006+06:00

What could be a simple example as an answer to the question "Why anyone should use STL?" I think the answer should be given in a comparative way. Lets say, someone asks you to

"take some unknown number integers as input. Then shuffle the integers and then print those back as output".

Without using STL , the whole thing would be messy (kindof). You will have to take the integers from standard input until eof is reached, then you will have to manually write a shuffle function to shuffle them and then you will have to print those back to the output. Someone with a little C++ experience can discern how many lines of code he has to write. But with STL, the same thing can be done in pretty elegant and clean way.

1. Take a std::istream_iterator (cin) which iterates on inputs taken from cin

2. take a vector where you will have to copy all the integers from cin iterator

3. Copy the whole input stream iterated values into the vector using std::copy();

4. use std::random_shuffle() function to shuffle them

5. copy the vector with shuffled numbers back to ostream_iterator (cout) where those will be printed out with given delimiter.

The code looks like this :

Boost C++ . 01.05.2011

2011-01-05T09:07:00.003+06:00

I am using Boost C++ 1_35_0 with VS 2008 (vs9). Here are some quick starting comments.

-> you wont have to build boost libraries unless you are using a legacy IDE or commadn line tools. If you are using VS9, it is pretty straight forward. There are two kinds of libraries in boost:

1. Header only libraries (all the code is inline, and put into the header (.hpp) file). So, merely including the .hpp file into your code is enough. For this you have to follow the standard include directory adding process (go to Configuration Properties > C/C++ > General > Additional Include Directories put the boost directory address in the field )

2. There are some libraries for which are binaries (i.e boost.regex). If you want to use any of those, just follow the standard library adding procedure in VS9 ( the boost\lib full directory path either in Configuration Properties > Linker > Additional Library Directories, or in Configuration Properties > C/C++ > General > Additional Include Directories, both worked for me ).

But if you are going any other way around (if you want to build the boost source instead of installing the boost binaries, or if you are using an earlier visual studio IDE), then you have to do some housekeeping work(see 5.2 and 5.3 from here). Further if you want to use boost libraries on unix systems then you have to follow these rules.

Nokia QT

2011-01-04T09:42:00.004+06:00

I have just started using the QT creator for building applications in QT for Nokia. As a first step, I am not using any wizard kind of stuff which provides initial framework code. Just one thing I have noted this far - the folder where you are are putting your project files in, should not contain any special characters(I ran into problem with space). Other than that, building a project is really easy:

New Project-> Other Project-> Empty QT Project

Add a .c++ file to it, add your simple code. and then run the makefile for the project.

Detect memory leaks in debug mode in VC++ 2005

2010-10-21T05:20:00.005+06:00

The main tutorial is here. However, I have tried it out, so one can just follow the following steps

1. In Project-> Properties-> Configuration Properties-> C/C++ -> Preprocessor -> PreProcesor Definitions , append the two lines _DEBUG;_CRTDBG_MAP_ALLOC

2.Include the libraries

#include stdlib.h

#include crtdbg.h

3. Add the following lines at the beginning of you program. These will enable showing the file name and line number of the memory leak.

#ifdef _DEBUG

#define DEBUG_NEW new(_NORMAL_BLOCK, __FILE__, __LINE__)

#define new DEBUG_NEW

#endif

4. Add the following line at the beginning of main function :

_CrtSetDbgFlag(_CRTDBG_ALLOC_MEM_DF|_CRTDBG_LEAK_CHECK_DF);

Note :

1. This system will detect memory leak in the code that is in another file.

2. Do not use the _CrtDumpMemoryLeaks(); function. Because this function wont be able to detect the destruction of automatic variables which are done just before the program exits. Doing just the above 4 steps will be enough.

OO design & C++ buzzwords - 3

2010-06-19T03:00:00.006+06:00

16.RTTI
RTTI means run-time type identification. It is a form of dynamic type checking or dynamic typing. Dynamic type checking is specially discouraged because with dynamic type checking code is used to find code which creates extensibility problems later on.
Dynamic type checking can be done in a number of ways. We will present two of the ways.
1. Using explicit class identifiers to check whether a class is of a specific type.
2. Using dynamic_cast to identify whether an object referred by the base class reference actually is an object of a particular subtype. The dynamic cast is a compiler provided infrastructure to downcast an object by its pointer. (This means getting the derived class object from the base class pointer or reference pointing to that object.) RTTI.cpp
Note that upcasting is always automatic; we don’t have to use any explicit casting mechanism to impose upcasting. But downcasting is not.
17.Static type checking / Static Typing
Static typing means when the compiler statically checks the object to determine whether the function being called on the object is a valid statement or not
Class CBase{
Public:
Void f();
};
Int main()
{
Cbase x;
x.f(); // here compiler does the static type checking
{
18.Down casting
Casting a Base class reference or pointer to a derived class reference or a pointer. There are two ways to do that : either by using old c-style cast (RTTI.cpp), or by using dynamic_cast(Downcast.cpp). The program that uses the downcasting infrastructure of the mentioned kind is subject to error and non-extensible. Addition of new type generates a ripple effect which needs updating of a lot of code.
19.Dynamic Typing/Dynamic Type Checking
This is what happens when a base class reference is used to call the appropriate derived class virtual function.

C++ compiler automatically does that for the developer.

However, programmers can go around this OO feature and deploy their own dynamic type checking scheme as mentioned in the FAQ 16.

20.Places where dynamic type checking is necessary
There are some cases where dynamic/runtime type checking (explicitly downcasting,, capability query etc) is necessary. One example case is that when objects are de-serialized from persistent storage. So, when we have to construct an object from its serialized form, we have to do dynamic type checking.
21.Alternative to downcasting
Using virtual functions to call appropriate version of the function.
22.Dynamic_cast
Dynamic cast is a newer version of old C-Style cast. So, in broad sense it means that the dynamic casting casts the value of object x to its type T. Here T is normally a pointer or a reference of the same class. Dynamic casting is pretty much the same thing as the old-style casting. However, it provides some extra features, like returning NULL if the the value we are trying to cast to the type is not actually of the same type.

So, dynamic casts return NULL if the conversion is not valid.

CMyClass* q = dynamic_cast(aMyClass);

CMyClass& q = dynamic_cast(aMyClass);

23.Can a function be able to throw more than one exception and how

Yes it can.

A function can be able to throw more than one exception.

void MyClassFunc() throw(int,char)

{

int y = rand();

cout<"\n";

if(y <>

throw 10;

if(y > 1000)

throw 'a';

}
24.Explicit specialization of templates

it can also be called overloaded templates

Templates can be used to handle special cases. The term used for this is called explicit specialization. When we write code using class templates, we actually generalize on the type or the class on which that template will work. For example, if we write a code which does a sorting on the array of objects that will be passed at runtime, same code and algorithm is used for all of the compatible types (int,float, string, or any user defined one) that can be passed to that template. But we might want to implement a special case, i.e. for a particular type of object (say for double), we might want the internal data structure or the algorithm of the template to be special. That’s where we can use the explicit specialization of class templates to be used. Note that explicit specialization of function templates is not possible (To be more specific, syntactically, explicit specialization of function templates can be written, but does not make any sense semantically).

For reference, please look at the code.

Please note that when implementing the explicit specialization of class templates, we have to omit the template<> from the beginning of the function definition. Otherwise will result in compiler error.

25.Function Templates

Function templates are just cookie cutters for a generation of functions which can take any type or objects of class to work on.

template<class A, class B> void MyTemplateFunction(A aObj, B aAnotherObject)

{

cout<<<" "<<

return;

}

26.Remote ownership

When a pointer or reference to an object(which is allocated in the heap) is assigned to the data member of another object, depending on the implementation, the ownership of that object remains to the original reference/pointer or the object in which that reference or pointer has been copied to. If the programmer makes a shallow copy (just assigning the reference/pointer to the member object), then the original reference/pointer retains the ownership of the object remotely. Otherwise, the ownership is transferred to the member reference/pointer.

Here is a simple code in which the ownership is retained by the original pointer remotely.

27.Copy on Write Semantics

Copy on write semantics is the principle that one can have as many read-only copies of an object as he needs. It is only when he tries to modify the
data inside the object, is the objects data gets actually copied into the object.

Copy on write semantics is used by the compiler to make an API memory efficient. So, if a developer is writing an API which is going to be hard on memory(means it is goiong to use a lot of memory),he should look forward to make use of the copy on write semantics.

There is another reason behind the copy on write semantics. That is refenrece counting.

C++ copy on write semantics suggests that the member objects are not copied when copy constructor or assignment operator is called. The actual values are written only when then copied or assigned object is actually tried to be modified somewhere.

So, in the copy constructor or assignmnet operator we just update the reference count but dont copy the original data. If any mutator function is called
where the user is going to modify on the copied object , then we actually copy the contents of the data.

Source http://www.c2.com/cgi/wiki?CopyOnWrite

28. Final Class or Leaf Class DONE
Final class or leaf class is the class which cannot anymore be inherited. There is no "final" keyword in C++ which can be used to
mark a class as a final class. This can be done in two ways. Either by properly commenting on the code. Or by enforcing the compiler to do it.
The way we can enforce a compiler to make a class final is - we can declare all the constructors of that class as private and provide static
create() fucntion (just as we have done in the names constructor idiom example) so that a class cannot derived from this class. If the constructor
of the class is private then the compiler prevents any other class from inheriting that class.
We should also make the protected: member data private.
And the class which we want to make final should not declare any new virtual functions.

29. Final Member Function
Final member fuinctions are the functions which cannnot be overriden anymore. It means that the function was a virtual one in the base class but in the derived class it does not remain virutal anymore so that any class which derives from this class cannot override the function.
There is no final keyword that we can use before the function declaration. We can enforce the compiler to make a function final.we can declare all the virtual functions that the class inherits from the base class non-virtual . That is we eliminate the virtual keyword from the declaration of the function.

30.Hiding Rule
The C++ hiding rule – if not know in advance and done accidentally or inadvertently, can confuse programmers. So, it is better to know about the hiding rule in advance.
The C++ hiding rule is
An entity in the inner scope hides the entity with the same name in the outer scope
An example of this can be
A function in the derived class can hide the same function on the base class

Redefining a virtual function in the derived class which has the same name as the function in the base class but different signature in the derived class, hides the function in the base class

Redefining a non-virtual function in the derived class where a function with the same name (but with different signature) already exists in the base class, can hide the function in the base class.

As a result of this hiding rule imposed by the C++ compiler, the following confusion arises :
Normally dynamic binding depends on the type of the object, not on the type of the reference used to refer that object. But if compiler imposes the hiding rule, then the dynamic binding (or a normal function call) will depend on the type of the reference, not on the type of the actual object being referred.

The above statement can be examined by the HidingRule.cpp code included.

So, what to do with the C++ hiding rule? Avoid causing the occurrence of hiding rule; and if the hiding rule cannot be avoided, use the following workaround.

OO design & C++ buzzwords - 2

2010-06-11T23:41:00.010+06:00

11. Covariant return type [1]

Covariant return type is a C++ language feature that makes us free of all the hassles that comes with downcasting. First we give an example of what kind of hassles that we have o take in case of downcasting.
From the code we can see that the clone function makes a copy of the object and returns it in an “upcasted” state (so, if we call the CloneMe() function from a subclass CDerived, we will have to receive it in a CBase* and then downcast it again to get a CDerived) .
This kind of downcasting actually can complicate things. Firstly, we have to use dynamic_cast<> to downcast it again to its actual type (CDerived*) from what is returned (CBase*). Secondly, we have to check it again to see whether downcast was successful or not (if CDerived is not the actual object it was cloned from?? Maybe the CloneMe was called from CDerived2 which also derives from CBase and we are trying to cast it to CDerived? In this situation, dynamic_cast<> will return NULL. )
So, to relieve us, C++ has a language feature which is called Covariant return type. In that thing we can just return a CDerived* instead of a CBase* in the virtual CloneMe() function. And also we can upcast it to CBase* without any problem. The compiler does that for us.

12. Maximal Munch rule
Look at the code of MaximalMunch.cpp . The decleration of "vector>" will give errors in some compilers that it cannot recognize the statement construct. This is due to the absence of a space in the underscored position (vector_>). This is because , the compilers tokenizer parses it to become a different operator (>> operator) so, the whole statement does not make any sense to the compiler.
So, the important thing to remember is to put a space simply to make the compiler stop complaining.
For more see here

13. Zombie objects
Zombie objects are created if no facilities are provided to throw and catch exception from constructor and if any exception occurs in the middle of the construction process. This situation creates the objects which are halfway alive.
Zombie objects are also created when the language does not provide support exception handling mechanism in the constructor or the language at all.
So, in the case the exception handling mechanism is not provided with the constructors, each object has to be checked to see whether it is in its zombie state or not .

14. Resource deallocation primitives
It simply means the overloads of operator delete, closing file stopping semaphores etc.

15. Named Constructor Idiom
Named constructor idiom is needed for the situations where one has to have two overloaded constructors but the both the constructors take the same number and types of parameters. It is the internal processing of the parameters to create the object that differs. For Example
CPoint(float aX, float aY); //rectangular coordinate system
CPoint(float aRadius, float aTheta); // polar coordinates system
In the situation, the overloaded constructor will not work. So, we have to use the named constructor idiom.
How the named constructor Idiom works? The code shows you how to do that.

Source1

OO design & C++ buzzwords

2010-06-11T06:08:00.015+06:00

Here are some C++ important buzzwords that are worth knowing and worth looking into. The buzzwords are kind of mixed in the sense that some are basic and more regularly used and other are kind of advanced and not that much regularly used. So, I am not going to keep any kind of order in that sense. The second thing is – the description and explanation are not directly copied from the source. I have put down my own understanding about each term. The readers are open to leave comments if they find anything which is not properly defined or which does not seem to fit.
1. Virtual Destructor
Virtual destructor is a necessary thing when there is the possibility that a derived class object is deleted via a base class pointer. And when that is done, when the destructor is called, the base class does not know a damn about which class the object is originally and so, the corresponding destructor of that class is never called. This can introduce serious error because the derived class might have some resource to de-allocate. This can be shown by the following example.
The code is attached at VirtualDestructor.cpp
The output of the above code is
”Inside CBase Destructor”
Here, we can see that the derived class destructor is not called at all. To remove this problem, we need to declare the base class destructor as virtual. So, instead of writing the destructor as
~CBase1() throw()
{
cout<<"Inside CBase Destructor \n"; } we will write as follows virtual ~CBase1() throw() { cout<<"Inside CBase Destructor \n"; } This removes the problem. The output then becomes Inside CDerived Destructor Inside CBase Destructor The actual rule of when to declare the base class destructor as virtual is not trivial. But the rule of thumb (without hurting performance), we can say that, whenever a class has a virtual function (so, that class is likely to be derived in future), the destructor should be virtual.

2. Pure virtual destructor
Pure virtual destructor is the only class member function that has to be defined even after it is declared as pure virtual.
class CMyClass1{
public:
CMyClass1() throw();
virtual ~CMyClass1() = 0;
private:
};

CMyClass1::CMyClass1() throw(){
}

CMyClass1::~CMyClass1(){
}
So, why would someone need a pure virtual destructor? The argument is that, there is no reason why there cannot be a pure virtual destructor. As destructor is just a function like any other member function in a class, that is why there can be a pure virtual destructor just like any other functions. Apart from that there is no special reason why we need a pure virtual destructor. Some people say that we can make the destructor pure virtual so that we can turn a normal class into an ABC. But that is not a strong enough reasoning.
The special thing about pure virtual destructor is that we have to put a definition of the function even if it is pure virtual destructor. This is because the destructor must be defined for all classes as destructor are always called when objects are destroyed.

3. Inline virtual member function
A compiler can actually inline a member function which is declared as inline in the case when the compiler can statically resolve the actual type of the object which is called on that function. So, a virtual function can only be inclined when the object that is used to call it is a pointer or reference (because that case the type of the object must be resolved dynamically). So, only in the case when the compiler can resolve the type of the object statically, only then the compiler can keep an inline function as inline. Otherwise it won’t happen.
So, a very useful rule of thumb when declaring the functions as inline is to think whether it is going to be accessed by an object or a pointer or a reference to an object.
Here an important thing to remember, a compiler has the ,liberty to ignore the inline specifier even if the object can be resolved at compile time. So, we cannot say that the places where a virtual inline function is called via an object (the type of which the compiler can resolve statically) will always be inlined . But the reverse is always true (if an inline virtual function is called via a pointer or reference, that function calling part cannot be inlined because the compiler cannot resolve the type of the object at compile time).
N.B. A short note on what happens when an inline function is called. The compiler puts the inline member function code directly in that place removing the function call and thus removing some unnecessary stack operations made during a function call.

4. Virtual Constructor idiom
So, what to virtual constructors do? They can construct the actual object in the class hierarchy without knowing the actual type of the object during construction. The concept of virtual constructor comes into life when you are trying to construct an object of a class which you don’t know of (Which derived class). Like the following piece of code.
Class CBase{};
Class CDerived: public CBase{};

int main(){
CBase *f = new CDerived();
CBase* f2 = aObj.Clone(); // here f2 does not actually know that aObj is a CDerived
//Object }
So, how can we do it? We can do it using the virtual constructor idiom. The code is in VirtualConstructor.cpp.

5. Constructor initialization list
It is the best way to initialize the member variables of an object. It is always better to use the constructor initialization list rather than manually creating values to the member variables. It works in the following way:
class CPerson{
public:
CPerson(string& aName) throw(bad_alloc);
private:
string iName;
};

CPerson::CPerson(string& aName) throw(bad_alloc)
:iName(aName)
{}
In the above example, instead of manually initializing the string variable in the constructor body, we just use the initilization list.

6. Virtual friends
The following code can be used as a virtual friend
VirtualFriend.cpp
Using the above style, we can get a virtual friend function – which depending on the runtime type of the object, calls the appropriate function in the class hierarchy.

7. Initialization order dependency
The initialization order dependency means , no matter how the member objects are ordered in the initialiers list, the initialization will occur in the same order in which the members are declared In the class declaration. An example will help to understand the issue. InitializationOrder.cpp
From the code, if we run it, we will see that the member objects are written in the opposite order on the CMyClass constructor initilizers list that the way in which they are declared in CMyClass. But during construction, the copy constructor of the two classes ( during the execution of the initialiers list in CMyClass constructor) ,are called in the same order in which they are declared in the class, not by the order in which they are declared in the initializes list.

8. Argument screening
It is nothing actually. Argument screening means the sanity checking of the parameters of a constructor. In that case when argument screening is needed, the code for screening becomes too much and then we cannot initialize the argument using constructor initialization list.

9. The {…} initializer syntax
This is actually nothing compared to how intimidating it sounds. It is actually the array initialization syntax. Take a look at the code InitializerSyntax.cpp
In the above example we can see that the first element of the array is handed an already constructed object. So, it explicitly calls the copy constructor.

10. The overloaded parenthesis operator [operator ()]
The overloaded parenthesis operator can take as many parameters as one would like to pass into the operator function.
Just look at the following code OverloadedParenthesis.cpp
In the above code, the () operator has been overloaded thrice to do three kind of things. The one returning the reference to double is used to set the value;
The one returning the const double is used to get the value of the array element.
And the last one with no parameters is used to reset the array inside the object.
But we have to remember one thing that I have said in an earlier post. Do not do anything for the sake of doing it. The whole idea of operator overloading is to ease the user of the class and make him comfortable by providing all the common an intuitive usage of the operator . In the above example the three overloaded operators and their functionality is not intuitive. The only scenario in which this overloaded parenthesis operator can be intuitive and appropriately useful is the matrix class.That is because we cannot define overloaded double subscript operator Matrix[][] ,, but we can use something like Matrix(x,y); Which looks pretty much same as the subscripted version.

Source1
Source2

Stream and Store in Symbian C++ -1

2010-05-03T00:58:00.034+06:00

ow to use the overloaded Stream Operator in Symbian

In C++, we can overlaod the istream and ostream operators ("<<" and ">>") for writing to any kind of stream (standard IO, files stores etc).

In Symbian there is a similar group of classes for stream input and output. The base classes are RReadStream and RWriteStream.

To get the same effect of the overloaded stream operators in Symbian OS, we have to implement the following two functions:

void ExternalizeL(RWriteStream& aStream) const;
void InternalizeL(RReadStream& aStream);

As the names suggest, the ExternalizeL function is for writing to a stream and the InternalizeL function is for reading from a stream.

So, if we want to overload the stream operators for any class , we have to implements these to functions in that class.

So, the class looks like this :

#ifndef TESTCLASS_H

#define TESTCLASS_H

class CTestClass : public CBase

{

public:

~CTestClass();

static CTestClass* NewL();

static CTestClass* NewLC();

void ExternalizeL(RWriteStream& aStream) const;

void InternalizeL(RReadStream& aStream);

private:

CTestClass();

void ConstructL();

TInt16 a;

TInt16 c;

};

#endif

and the class definition is :

void CTestClass::ExternalizeL(RWriteStream& aStream) const

{

//aStream.WriteInt16L(this->a);

//aStream.WriteInt16L(this->c);

aStream << mytestclass =" CTestClass::NewL();">ExternalizeL(); would do the same thing

CleanupStack::PopAndDestroy();

writer.CommitL();

writer.Pop();

writer.Release();

CleanupStack::PopAndDestroy();

}

Here is how we can use it:

void CASDTestAppUi::WriteToStream()

{

RFs fs;

RFileWriteStream writer;

fs.Connect();

CleanupClosePushL(fs);

writer.PushL();

if(writer.Create(fs,_L("c:\\zafar1.txt"),EFileRead|EFileWrite) == KErrAlreadyExists)

writer.Open(fs,_L("c:\\zafar1.txt"),EFileRead|EFileWrite);

CTestClass* myTestClass = CTestClass::NewL();

CleanupStack::PushL(myTestClass);

writer << *myTestClass;

CleanupStack::PopAndDestroy();

writer.CommitL();

writer.Pop();

writer.Release();

CleanupStack::PopAndDestroy();

}

N.B: Common mistakes:

As we have taken a pointer to CTestClass variable, forgetting to add the dereferencing operator will result in STORE-Stream 9 panic.
We could use CleanupReleasePushL(writer); in place of writer.PushL();

Here, how the stream operator can be overloaded for writing to a file is shown. We can use other RReadStream and RWriteStream subclasses to overload the stream operators for writing user defined class objects to different kinds of streams and stores.

*** missing operator in Symbian

2010-04-16T20:49:00.005+06:00

2 years in the buisiness and still I stumble upon fairly easy things.... I was building a peoject in carbide and it gave an error called "*** missing operator" .., I tried to find out what was happening. Eventually I got two threads which actually describes the problem

http://dev.eclipse.org/newslists/news.eclipse.tools.cdt/msg06739.html

http://www.forum.nokia.com/forum/showthread.php?t=129440

Actually the project was built in Windows XP. In windows 7 (when I tried to build it again) , it replaced the tab in the icon_scalable_dc.mk file and replaced those with a bunch of spaces; that is why it was not getting that error.

Periodic task without using Active Objects

2009-10-20T12:19:00.011+06:00

Sometimes you may want to call a function or do some task in regular interval without extending the class from CActive (i.e. You may want to show a informationNote on map - just like google maps does ;-)) . In that Situation it would be appropriate to a CPeriodic Object. Usage is trivial -
In the header file add:
CPeriodic* iTimer;

Use two functions which should look like following

/*Use this function whenever you have to start the time*/
void StartTimerL(TInt aStart, TInt aInterval)
{
if(iTimer)
{
delete iTimer;
iTimer = NULL;
}
iTimer = CPeriodic::NewL(EPriorityLow);
iTimer->Start(aStart, aInterval, TCallBack(TimerCallback, this));
}

/*This function will be called after the specified interval*/
TInt TimerCallback(TAny* aThis)
{
// Do whatever you have to do locally or you may call the following function
static_cast<>(aThis)->GlobalNoteProcessTimerEvent();
return 0;
}

/*Use this function to stop the timer*/
void CancelTimer()
{
iTimer->Cancel();
}

Thats it!!

Transparent Animated GIF

2009-10-08T10:39:00.004+06:00

I was trying to show an animated GIF over the maps as a blip to indicate user's position on the map. But I could not show a gif with transparent background. The gif background was shown to be white although the gif uimage had a transparent background. Then I changed a few lines of the tutorial and then it worked. The lines I have changed is as follows :

void CGifAnimatorContainer::Draw(const TRect& aRect) const
{
CWindowGc& gc = SystemGc();
if(iIsVisible)
{
if(iGif_Reader)
{
if(iGif_Reader->Bitmap() && iGif_Reader->BitmapImg() && iGif_Reader->BitmapMsk())
{
if(iGif_Reader->Bitmap()->Handle() && iGif_Reader->BitmapImg()->Handle() && iGif_Reader->BitmapMsk()->Handle())
{
TSize gifSize = TSize(iGif_Reader->Bitmap()->SizeInPixels());
TSize screenSize = TSize(aRect.Size());
TRect tempRect = TRect(TPoint((screenSize.iWidth - gifSize.iWidth)/2 ,(screenSize.iHeight - gifSize.iHeight)/2),gifSize);
gc.DrawBitmapMasked(tempRect,iGif_Reader->BitmapImg(),
TRect(0, 0, iGif_Reader->BitmapImg()->SizeInPixels().iWidth, iGif_Reader->BitmapImg()->SizeInPixels().iHeight),
iGif_Reader->BitmapMsk(), EFalse);
//gc.DrawBitmapMasked
}
}
}
}

}

Just replace the original function with mine.

Performance tips for Symbian Developers

2009-05-27T00:35:00.003+06:00

Have you seen it? If not, take a quick look:

Specifying default installation drive in .pkg file

2009-04-08T13:44:00.002+06:00

in the .pkg file , if we want to select the installation drive (Phone memory or Memory Card)at runtime , we put a "!" instead of the drive letter. If we dont want to show the drive selection dialog during installation, we can specify the drive letter in which we want to install out exe instead of the "!" letter. Like this:
"C:\S60\devices\S60_3rd_FP2_SDK\epoc32\data\z\resource\apps\MyApp.rsc"-"C:\resource\apps\MyApp.rsc"

But in Visual Studio 2005 , this solution does not work if we build the .SIS file using the VS2005 IDE. So, to make this thing work we have to go to the "sis" folder under the project folder and run the following command:
makesis MyApp.pkg

Then this thing will work. So, what we need to do when we are using the VS2005 as development environment is to rebuild the solution and then run the above stated command. Building the SIS file using the IDE wont work.

leaves and traps..... (II)

2009-02-17T01:06:00.027+06:00

How to work with leaves

We assume that a function has previously allocated memory on the heap and this memory is pointed to by a local pointer variable. Now,if a leave occurs within that function then ,that pointer will be destroyed by the Leave (As Leave unwinds the stack frame upto the TRAP macro). Lets see,

Eventually the memory pointed to by "test" variable is unallocated and will result in a memory leak.
How to prevent this?

If we have to use any local variable which point to heap objects, we must push the variable to the CleanupStack before calling any function that may leave.

Important Note:
1. Member variables are leave-safe
2.Neither a constructor nor a destructor should contain code that may
leave, since doing so would potentially leak memory.

Leaves Vs Panics

1. Leaves occur in exceptional conditions (Out of memory or Out of disk conditions). Leaves should be handled properly to continue the normal flow of execution. Leaves do not terminate the normal flow of execution. On the other hand, Panics cannot be caught and handled.

2. Leaves occur at program runtime due to exception situation. Panics , on the other hand occur at the development time. If they occur at runtime, they cannot be fixed. So, the cause pf panics should be searched and fixed at development period.

Leaves and traps (I)

2009-02-17T00:35:00.052+06:00

How funny this should sound to a Symbian C++ programmer? Till now, I do not have a clear idea on Leave and Trap mechanism of Symbian OS. Anyways, better let than never!! Here are some informations that I found essential to know about Leave - Trap mechanism of Symbian C++.

BASICS
1. Standard C++ exception handling mechanism adds substantially to the size of compiled code and RAM overheads (irrespective of whether the exceptions are thrown or not). That is why Symbian OS introduced the Leave - Trap mechanism. Before Symbian OS version 9 , the standars C++ exception handling were disabled in compilers so that any call to try catch or throw would result in a compilation error.But in Symbian OS 9, the standars C++ is supported (Hurrah!!!!).

2. The Leave - Trap mechanism is an alternative to standard C++ exception and conventional error checking. In other words, Leave- Trap constitutes to lightweight error handling of Symbian OS.

3. a "leave" (i.e. User::Leave() or User::LeaveifError()) suspends the code execution at the point where the leave occurs and resumes the execution at the point where the "leave" is "Trap"ped. The trap harness in Symbian is actually a "TRAP" macro. The "leave" sets the stack pointer to the context of the "TRAP" and jumps to that location.

4. User::Leave() or User::LeaveIfError() ---- Throw
TRAP ------------------------------------- try + catch

5. Critical Information on Leave:
Unlike C++ throw, a Leave will simply deallocate objects on the stack - it does not call the descriptor of that object. So, if a stack object owns a resource which must be deallocated or released as a part of destruction, that resource is not released if a leave occurs. That is why we have a class naming convention of Symbian OS which clearly states which kinds of classes can be instantiated and used safely on the stack (T classes). So, only a stack based T class will be cleaned up correctly if a Leave occurs (because there is nothing of an object of T class in any place other than stack).

6.R classes may also be created on the stack, but they must be made ‘‘leave safe’’, if used in functions that may leave, by using the cleanup stack.

new(ELeave)

1. The overloaded new operator which takes ELeave as a parameter guarantees that the pointer return value will be valid if a Leave is not occured in the constructor. Use of this overload allows the pointer to be used without further test that the allcation was successful(The allocation would leave if it were not successful).

Giving Shadowed or Custom Background to CEikEdwin

2009-01-25T17:13:00.023+06:00

If we look at the flash lite editbox, we will observe a shadowed background in the text boxes.
How can we give the shadow on the textbox background like this? Flash lite application runs on Symbian phones, so they must have done some kind of tricks using Symbian. In my application, I was required to do the same thing. There is a way to put custom drawed background on the CEikEdwin. I dont know if it is the way that flashlite used to show shadow on TextBox background, but it surely works.

The things is , you have to implement MFormCustomDraw interface. Just take a Class which looks like

#include
#include
class CMyCustomDraw : public MFormCustomDraw
{
public: // Constructors and destructor
virtual void DrawBackground(const TParam &aParam, const TRgb &aBackground, TRect &aDrawn) const;
virtual void DrawLineGraphics(const TParam &aParam, const TLineInfo &aLineInfo) const;
};

The MFormCustomDraw has two some virtual functions (Drawbackground() and DrawLineGraphics()). We have to implement these two functions (Or preferrably only the first one) in order to get a custom shadow on the CEikEdwin background.
So, we have to just write the implementation of DrawBackground() function. The implementation is straight forward - you have the graphics Conrtext (aParam.iGc), you have the CEikEdwin Background Rectangle (aParam.iDrawRect), so you have everything. So, just put your code in
CMyCustomDraw::DrawBackground(const TParam &aParam, const TRgb &aBackground, TRect &aDrawn) const{} function.

Now, how do we use it with our CEikEdwin. Lets say, you have a CEikEdwin in your container.So, you create your CEikEdwin in the natural way and after constructing you write,

CMyCustomDraw* iCustomDraw = new (ELeave) CMyCustomDraw();
and iTextField->TextLayout()->SetCustomDraw(iCustomDraw);

and not only that. In the containers draw function, you have to set it everytime.
iTextField->TextLayout()->SetCustomDraw(iCustomDraw);

This is how we do it !!!!

How to get the Screen Size Anywhere in a GUI application

2009-01-13T12:42:00.006+06:00

Just a simple line of code to access the Application related data from any file.
If you want to access the application rectangle or screen size then -
CEikonEnv::Static()->EikAppUi()->ApplicationRect().Size().iWidth
and you have to include -
eikenv.h and eikappui.h

Developing a console Application That works in Background - 2

2008-11-03T10:56:00.000+06:00

Specifically what I did to achieve the above 4 requirements is most important to document.
For requirement 1, we have to do this
For requirement 2,we have to create a console exe program. The usefulness of such programs is that it works in background. So, one cannot view the program as a task in running application viewer.
For requirement 3, we have to install an active scheduler in the ConsoleApp.cpp file (where the function E32Main() resides). We can put the following 3 lines of code in the E32Main() function :

CActiveScheduler* scheduler = new (ELeave) CActiveScheduler();
CleanupStack::PushL(scheduler);
CActiveScheduler::Install(scheduler);

This active scheduler is what the program will work taking the help of.Then after initializing the appropriate classes, we have to start the active scheduler. Let me give a specific example:

And then in the DoStartL() function -

Now, if any class (i.e CCallStatusNotifier or CImageDownloader in my example) is an active object type class then we can add the active object to active scheduler like this:
void CCallStatusNotifier::ConstructL()
{
CActiveScheduler::Add(this);
}

And then you will be able to use that active scheduler like normal active scheduler

Symbian Console Exe auto run after isntalling

2008-08-31T11:48:00.000+06:00

I have written a console exe which I need to start just after installing. This is very easy to do as they say . Just put FR,RI in the .pkg after the application name:
"C:\Symbian\9.2\S60_3rd_FP1\epoc32\release\gcce\urel\consoleapp.exe"-"!:\sys\bin\consoleapp.exe",FR,RI

But even after doing this the application was not working in the device. After getting screwed for several hours and trying some unearthly things, I resorted to a friend for help. He said that self signing wont work. I have to go to make it Symbian Signed. Bummer...

Developing a console Application That works in Background - 1

2008-08-10T17:45:00.001+06:00

May be this kinda short-ass article has been written many times before. But I am sort of a dumb-truck and I cannot remember things for long. That is why I am writing this for myself.

My requirement is : I want to build an application that :

1. Will Auto start right after installing.
2. Will be a console application - so it will work on background.
3. It will periodically do something (for now - it will write some files).
4. May be it will have to restart whenever the device is restarted.

To create an Application that fulfills the above stated requirements isnt that hard if one has sufficient amount of experience with Symbian. Like, for requirement No.2 - we can build a console Application that does not have a UI. The console Application skeleton that VS2005 creates for us have some things related to colsole which waits for user input in a command prompt like thing. Only if we scrape off all those codes , we can then have a true background Application that does not show up in the task managers running tasks and which does not have any kind of GUI either.

Now, for requirement No.1 we have to write FR(FileRun) and RI(RunInstall) in the .pkg file. Here is a sample line :
"C:\Symbian\9.1\S60_3rd\epoc32\release\gcce\urel\consoleapp.exe"-"!:\sys\bin\consoleapp.exe, FR,RI. This will make the application auto run right after installing. (Important thing: You have to make it symbian signed if you want to use it on device.Self signing does not work for FR,RI options - as far as I know!!)

For requirement No.4 one has to look at this , although this is for S60 2nd edition devices. They say that one has to use at least two of the four APIs described in the article. I was building the App for Symbian S60 3rd edition (init release) phones. So, I did not need the "SonyEricsson AutoStarter API".

For requirement No.3 , we have to set up an activescheduler so that we can install an active object. And after constructing the active object and adding it to the scheduler, we have to start the scheduler(Because active scheduler needs at least one active object waiting on it when it is started.)

Porting from 2nd Edition to Third Edition - 3

2008-07-30T13:25:00.000+06:00

We were trying to use the bluetooth API for S60 3rd edition(Initial Release) SDK. But, whenever we tried to discover devices , the app crashed giving the User -Exec 3 error . But in 2nd edition, this app were working fine. Then we discovered that we need to add LocalServices capability to make this work.

Porting from 2nd Edition to Third Edition - 2

2008-07-30T13:12:00.000+06:00

We have finally made a .SIS build for Nokia N73 and uploaded it to the phone . Whenever we tried to run the app , it showed a bizarre error called "Menu System Error(-1)" . Now, many has got the same error while porting from 2nd edition to 3rd edition, as there were quite a few posts and individual threads about this error in NewLC and Nokia Discussion Forum. The error is grotesque because the execution did not even come to E32Main() function. So, we were not being able to debug this thing. In many of the discussions, they were telling about the resource file (.rss), registration file (_reg.rss) problems. We tried all of those fixes and still we were getting that error. Then the solution came magically when one of the team member thought out of the box and checked to see what happens if we eliminate the .gif file that we were using. And it worked like a charm. The problem is that, the AppUi class had a reference to a class which used a .gif file for busy screen animation. And the .gif file was included in the .pkg file. What (probably!!!) happens is that when the application is invoked, it tries to load the .gif file from the specified location, but for some reasons , it does not find it (That is why it gets KErrNotFound (-1) ).We have tried to install the .gif file in many other places but still not being able to fix that problem. The problem still occurs whenever we include the .gif file in the .pkg file.Lets see if we can find the solution of this problem...

Symbian 3rd Edition : Displaying Error Code on Device

2008-07-28T11:08:00.001+06:00

In Symbian S60 3rd edition , to display error codes on emulator, we have to put a file Called "ErrRd" (without extension) in the "\Epoc32\winscw\c\resource" folder . This same file can be used to display error codes on device too. we have to just use a .sis file provided by the forum nokia . This .SIS file can be downloaded from here. The .SIS file is self signed , so we dont have to worry about signing it before installing. The "ErrRd" file is then installed in the "c:\resource\" folder of the device. After installing the .SIS file , you can see the extended panic code in the device so that you can get a feel of what's going wrong. Hope this helps.

Symbian 3rd Edition .SIS file signing

2008-07-22T15:51:00.000+06:00

We are working on a Symbian Project. Till a couple of weeks ago, we were developing it on the Symbian S60 2nd Edition platform. But now, we have to port it for later OS'es like Symbian 9.1 and 9.2 . Now, apparently these platforms API's have more access to OS core than the previous OS'es like 8.0x or 8.1x. So, now we have to sign a .SIS file with the IME number of the mobile phone on which we want to install and run it. The .SIS file that is created for out project is 940 KB (!!!) and at 90% of the time we fail to upload the file. So, we had to use the self-signing process. its very good for development and debugging phase.
The whole procedure is simple
makekeys -cert -password "urPassWord" -len 512 -dname "CN=WW CO=BD" keyfile.key certfile.cer

here 512 is the length of the key that is created by which we have to sign the program. It should be at least 512 (I tried for like 10 because , at the time of creating the key the program asks for random mouse clicks and the more the len the
more there are mouse clicks :-( )
and CN = company name and CO = country code

Then a .key file and a .cer file will be created. You can later sign all your test .SIS files using these two files as long as the certificate files does not expire.
Then all you have to do is : run the following command :

signsis MyFile.sis MyFile.sis certfile.cer keyfile.key "urPassWord"

Then the .SIS file will be signed. At the time of installing, it will give some warning messages, but it will get installed and you will be relieved of the signing process.

Porting from 2nd Edition to Third Edition - 1

2008-07-20T00:06:00.000+06:00

We are now porting a Symbian S60 2nd edition to 3rd edition. before starting to actually port, we had several speculations as how much pain the porting process is gonna give us.However, it turned out to be quite different from what we anticipated. The first step was to successfully install the 3rd edition SDK's and carbide for VS2005 so that everything works fine. This step caused some travail. Anyways, we succeeded to install and run an application both with 3rd edition and 3rd edition fp2 sdk. The device signing is a thoroughly painful thing until we find a work around of this.

The reason behind such circumlocutions is a little bit subtle here. I thought porting will be tough because of two special API's that we have used in our project : bluetooth connectivity and http connectivity. But, it turned out that the porting process caused us pain from totally different aspect : from C++ programming construct aspect. i will try to mention the places and situation where I have encountered error when porting from 2nd Edition to third edition. Its not too much technical (I assume, of course - the symbian team has full fledged documentation of what places can get error when porting from 2nd to 3rd ), its just some sharing experience.

Symbian S60 3rd edition Installation

2008-07-18T08:57:00.000+06:00

Here is just a cursory installation procedure of symbian s60 3rd edition sdk for VS2005.
1. Download and install ActivePerl-5.6.1.633-MSWin32-x86.msi (other versions wont work for symbian s60 3rd edition - at least I couldn't)
2. Download and install Symbian S60 3rd edition SDK from forum nokia
(S60-SDK-0548-3.0-f.3.215f.zip)
3. Download and instll S60 3rd edition fp2 sdk
S60-3.2-SDK-f.inc3.2130_S603rdEdition.zip
4. Download and install Carbide for Vs 3.0.1

You will be immediately able to use the Symbian s60 3rd edition SDk. But probably the S60 3rd edition fp2 sdk will be disabled for VS2005. To enable it go here

Then you will be able to use both SDK in vs2005.

Changing Font of Rich Text Editor in Symbian

2008-07-01T12:12:00.000+06:00

In CEikRichTextEditor, sometimes we may have to change the font, its size or color etc. Normally, the CEikRichTextEditor comes with its default font Attribute. If we use the default font then it looks like this :

To change its font color or font specification we have to do as follows:

_LIT(KFontSpec, "LatinPlain12");
TFontSpec fontSpec(KFontSpec,20*6);
CGraphicsDevice* screenDevice=iEikonEnv->ScreenDevice( );
CFont* font;
screenDevice->GetNearestFontInTwips(font,fontSpec);
TCharFormat iCharFormat;
iCharFormat.iFontSpec.iTypeface = fontSpec.iTypeface;
iCharFormat.iFontSpec.iHeight = fontSpec.iHeight;

TCharFormatMask iCharFormatMask;
iCharFormatMask.SetAll();

iEditBox->ApplyCharFormatL(iCharFormat,iCharFormatMask);

Then the Rich Text Editor Looks like this:

Nothing apocalyptic in it. Just a bit of information which might be necessary.

Drawing a Custom Control using CTimer

2008-06-03T09:35:00.000+06:00

There are some occasions where one may need to use asynchronous timer event in container i.e. to create a ticker container which can afterwords be added to other containers as well. I am actually talking about a control that has timer events and which looks something like this.

Obviously it will have some other features of a standard CCoeControl

class like making it visible or not. These features automatically comes from the CCoeControl class . So, there is nothing top worry about that.So, I started out like this : I created a custom control class with an extra added feature , it also inherits the CActive class so that I can provide the animation things. So, the class looked like ,

class CTickerContainer : public CCoeControl, MCoeControlObserver,CActive

{

// Container class funvtions

//Other things

public:

void StartL(TTimeIntervalMicroSeconds32 aDelay);

private:

void RunL();

void DoCancel();

private:

enum TTickerContainer State

{

EUninitialized, // Uninitialized

EInitialized, // Initalized

EError // Error condition

};

private:

TInt iState;

RTimer iTimer;

}

The red marked codes are from CActive class . So, What we do is we start the animation when the CTickerContainer is constructed and in the RunL() function , we provide the animation thing (That can be either drawing the text one character ahead each time or drawing a bitmap one pixel ahead , whatever soooths.) So, the RunL() function should look something like

void CTickerContainer::RunL()

{

//Do the animation Things...

DrawNow();// This is called to reflect the animation on the container

iTimer.After(iStatus, 1000000);

SetActive();

}

Works like a Charm!!! Then we can use this control in Other containers just as we use built in controls like CEikLabel or others. It worked too and ran on the emulator smoothly, no problem. But whenever I tried to build the ARM version so that I can take the installer on the

device and test this baby, I got an error :

"Request for method 'operator new' is ambiguous."

WTF? Then I found this link that explains everything.

Multiple inheritance is not supported in Symbian. Crap!! So, now a turn around has to be used to do the same thing. Obviously I cannot use CActive as a member variable because I cannot instantiate abstract class.

The solution to this problem is the CTimer class which if extended by another class can then be used as a class member variable. The extra things that we have to do is first to write a class that extends the CTimer class and write an observer interface which will be used to call the specific animation things of the container from the RunL() method of the CTimer extended class. So, the whole thing now looks like :

1. The CTimer extended class:

class MTimerObserver; //This is the Observer mixin class

class CTimerDerived : public CTimer

{

public:

static CTimerDerived* NewL( const TInt aPriority,

MTimerObserver& aTimeOutObserver );

static CTimerDerived* NewLC( const TInt aPriority,

MTimerObserver& aTimeOutObserver );

virtual ~ CTimerDerived();

void SetActive();

protected:

void RunL();

private:

CTimerDerived( const TInt aPriority,

MTimerObserver& aTimeOutObserver );

void ConstructL();

private:

MTimerObserver& iTimeOutObserver;

};

The MTimerObserver mixin class looks like :

class MTimerObserver

{

public:

virtual void TimerExpired() = 0;

};

So, The RunL() function now looks like :

void CTimeOutTimer::RunL()

{

if ( iStatus == KErrNone )

{

iTimeOutObserver. TimerExpired();

}

else{..............}

}

And The Ticker Container looks like:

Class CTickerContainer : public CCoeControl, MCoeControlObserver,MTimeOutNotifier

{

public:

void TimerExpired()

{

// Do the animation things

DrawNow();

}

Buffer

2008-05-05T15:29:00.000+06:00

Sometimes we need a buffer of which we do not know how much data would come in. So, in those cases , we cannot use simple HBufC of TBuf like buffers because these are of fixed sizes and aer not expandable at runtime. So, the simple solution is to use CBufFlat buffer. This is an expandable buffer. There is not much to show inside . Just simple construction , usage and some other stuffs.

Construction :
CBufFlat* iBuf = CBufFlat::NewL(50); //Here 50 is the granularity or expansion // size
Inserting Data:
iBuf->InsertL(iCurrentInsertionPos,aData); // inserts the data at current offset
Using the Data:
To use the data of this buffer, we have to first make this pointed to by a TPtr
TPtrC8 myPtr = iBuf->Ptr(0);
And then access the data via that pointer.
Destruction:
delete iBuf;

and iBuf->Reset(); will simply reset the whole buffer and delete all data stored inside.

Some subtle Symbian panics - 1

2008-03-03T13:39:00.000+06:00

Symbian OS produces some panic codes during program exit. Most of the time , we can locate what has gone wrong by seeing only the code number - like User 11 or user130. These panics are very much deterministic. But every once in a while one may encounter some panic codes which are very much subtle, the description of that panic code does not describe anything. Like the CONE 8 error.So,

Cone 8 error -
you do this CFbsBitmap* bitmap = iEikonEnv->CreateBitmapL( KNavigationDemo,EMbmNavigation_newBack);

but you dont delete it after working

Cone 36 - You use a RTimer by iTimer.CreateLocal();
but you dont close it by iTimer.Close();

CEikEdwin character Deletion

2008-01-21T13:29:00.001+06:00

The CEikEdwin component is nasty in the sense that many a times it gets a ETEXT 12 panic whenever one tries to delete characters from the written text. After grappling with this thing for some time , I have managed to write a code that does not get ETEXT panic if we delete characters from it from no matter what position.

1. Create an entry for the textfield in the resource file
RESOURCE EDWIN r_addressinput_edwin
{
//flags = EAknEditorNumericInputMode;
flags = EAknEditorFlagDefault;
width = 10;
lines= 1;
maxlength =10;
}

2.Construct the Textfield from the resource file:
TResourceReader reader;
iCoeEnv->CreateResourceReaderLC( reader, R_ADDRESSINPUT_EDWIN );
iTextField1 = new ( ELeave ) CEikEdwin;
iTextField1->SetContainerWindowL( *this );
iTextField1->ConstructFromResourceL( reader );
iTextField1->SetAknEditorInputMode(EAknEditorNumericInputMode|
EAknEditorTextInputMode);
CleanupStack::PopAndDestroy(); // Resource reader
3. Put the code inside the OfferkeyEventL() function of the corresponding container which holds the CEikEdwin Object

case EStdKeyBackspace:
{
if(iTextField1->CursorPos() == 0)
break;
TInt cursorPos = iTextField1->CursorPos();
if(iTextField1->CursorPos() == iTextField1->TextLength())
iTextField1->InsertDeleteCharsL(iTextField1->TextLength()-1,_L(""),TCursorSelection
(iTextField1->TextLength(), iTextField1->TextLength()-1));
else
iTextField1->InsertDeleteCharsL(cursorPos,_L(""),
TCursorSelection(cursorPos,cursorPos-1));
iTextField1->SetCursorPosL(cursorPos-1,EFalse);
DrawNow();
break;
}

It worked for me.... I guess it work for others.

Taking ScreenShot in Symbian

2007-12-18T09:28:00.000+06:00

Here is an example of how to take ScreenShot and saving it to the file as .jpeg. With this, we can take ScreenShot of any other running program.
1.Create blank bitmap:
iBitmap = new (ELeave)CFbsBitmap;

iBitmap->Create( TSize(176,208),EColor16M );

2.Create a rectangle with size of whole Device Screen:
iScreenRect = TRect(TPoint(0,0),TSize(176,208));

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

TBuf<50> myBuf;

myBuf.Append(KFileName);

myBuf.AppendNum(iCaptureCount);

myBuf.Append(KExtension);

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

myBuf.Delete(0,50);

TRequestStatus status;

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

SetActive();

The conversion process is asynchronous. When it is completed, RunL() is called. Inside RunL()
do whatever is needed if you want to take continuous screenshots.
Indside RunL():
delete iEncoder;

iEncoder = NULL;

iCaptureCount++;

We can control continuous screenShot simply by using a timer.
When We run the program , then we can send this screen Capturing program into background and then the screenshot of whatever that is in foreground will be taken. Elementaire!!!

Creating a transparent Shadow on Container

2007-12-13T13:11:00.000+06:00

These Days I was working on creating a customized Context menu on Symbian.Unlike the default context menu that symbian OS provides , it has to be drawn by hand. But, it can be constructed as a UI control, so that we can use common keyEvent Handler functions like OfferKeyEventL or HandleControlEventL . So, first I made a context menu which looked like this:

Here I gave a shadow effect on the context menu. But the shadow was covering the container below it. Then I found that symbian CGraphicsContext class provides a cool thing called TDrawMode. It is set by CGraphicsContext::SetDrawMode(CGraphicsContext::TDrawMode). If we set it to EDrawModeAND then the effect is :

KHUOL.......

Sending Symbian Application to the Background

2007-11-18T11:24:00.000+06:00

So simple, yet so hard to find. So, saving it into my blog for future reference.
Suppose we want to send the application to the background when the Call Disconnect Button is pressed. To do that, we have to do the following:

1. Add void HandleWsEventL(const TWsEvent& aEvent,CCoeControl* aDestination); function in our AppUi Class.
2.Add the following lines in our AppUi ConstructL() function:
RWindowGroup& groupWin = CCoeEnv::Static()->RootWin();
iEndKey1 = groupWin.CaptureKeyUpAndDowns( EStdKeyNo, 0, 0 );
iEndKey2 = groupWin.CaptureKey( EKeyNo, 0, 0 );
3. Add the following lines in the AppUi destructor function:
RWindowGroup& groupWin = CCoeEnv::Static()->RootWin(); groupWin.CancelCaptureKeyUpAndDowns( iEndKey1 );
groupWin.CancelCaptureKey( iEndKey2 );
4. Add the following lines in the HandleWsEvent function of our AppUi class :
TInt key = aEvent.Key()->iScanCode;
if(EStdKeyNo == key && aEvent.Type() == EEventKey)
{
RWsSession fSession;
User::LeaveIfError(fSession.Connect());
TApaTaskList taskList2(fSession);
TApaTask task2 = taskList2.FindApp(TUid::Uid(0x04ca2be8)); //The app UID if(task2.Exists())
{
task2.SendToBackground();
}
fSession.Close();
}
else
{
CAknAppUi::HandleWsEventL(aEvent,aDestination);
}
This will send the Application to the background...

Messaging Type Module in Symbian S60 -1

2007-10-25T15:29:00.000+06:00

There is a very interesting thing in Symbian OS . This is called messaging type modules. This works as follows. Suppose, someone has developed an project for sharing of mobile pictures. It can be something like mobile flickr. There is a software part for mobile (either J2me or Symbian) and there is a server part. Using the software from mobile, anyone can upload a picture to the server and also add title description, set rating etc. Using the same software, some other mobile user can log onto the server and browse the pictures uploaded by others. There are many software and applications now available in the market. For example, there is LivTv. But there is a little user experience related issue here. A user has to use the software in order to upload a picture to the server. He has to run the software, take pictures from inside that software and then upload it to the server. He cannot just use the default camera application of the mobile phone , take a picture and the send it to the server. But, actually, he can if he uses Symbian phone.
Lets look at the following picture, although the picture is from the emulator
of Symbian S60 2nd edition phones.

There is an option in the default camera application of the mobile phone, that is send . We can send the picture taken as MMS , via bluetooth , or via infrared. Here is the twist - we can also send to a custom server of our own. This is done via the MTM or messaging type modules of Symbian OS. This is really an interesting option. If we use this , we wont have to use the software just to upload a picture to the server.
When we install the MTM software in the phone , we get another option in all or some selected modules of the phone - like in camera, in SMS , etc. The option is inside the "send" option like "via MyApp". Using this option , one can upload the
data to his own server. The technical details are to be found here and here
I wont go to the technical details, I will try to describe just how to configure the MTM example provided by the Symbian to make a simple MTM work.

Writing a template class in Symbian C++

2007-10-22T17:33:00.000+06:00

This is for the new born Symbian-Babies . This is the beginning of the beginning of Development in Symbian C++. Here, it will be shown how to write a template class in Symbian C++. Remember, this is an overly simplified example of writing template class.But with common C++ and Object Oriented Paradigm knowledge , anyone can extend to fulfill their purpose.
The template class looks like this...
and to use the template class...
Just as a reminder, there is an issue regarding using the template class. Click here to check that.
We can easily use a user defined class as a parameterized data type of the template class.
Let a simple class be..
The definition is also pretty simple... But just in case , we add here ...
And to use the template class with the parameterized data type as CSimpleClass...
This is how we can use template classes. Actually, anyone with a good OO and C++ knowledge can at once device or at least grasp this thing...

Implementation of Observer Pattern Using Symbian View+Container And ActiveObject

2007-10-07T19:09:00.000+06:00

Here we will give an implementation example of the observer design pattern in Symbian C++. We will implement it in Symbian S60 2nd Edition, although the developer SDK version is not important that here because we will not be doing any extensive of any SDK API.
The original Observer pattern need not to be described here because that is available over the net or reference books.

Symbian Application depends on the view based architecture. That is , we can use Symbian view and Container classes together to present some Model on the application. So, we will use Symbian View (CAknView) and Container (CCoeControl) classes for the view part of the Observer pattern implementation. Actually, sample application implementing the Observer Pattern needs two Views + containers , one of which will be the opening or Default view, and the other will present the changing data (Which is actually the view used in the Observer pattern).

Along with demonstrating the implementation of the Observer pattern , here we have used multiple views in my application. In my next blog I will show how to do that.Otherwise, carefully looking at the current example will also do.

For implementing the observer pattern , we will need Model which holds the transient or changing data. For simulating the changing data, we will use Active objects. In other cases, it can be a class with asynchronous functions. Its a simple class which extends the CActive class and holds a list of Observers (Described later) which observers on the change of Data. It also contains functions for attaching and detaching observers and also for notifying the observer upon change in Data.

The Class which acts as the model is called "CUserData" (just for the record)..

For now, it is enough to show only the model class decleration. Now we turn to Observers. One things should be kept in mind here, this is not optimal example of implementation of Observer Pattern, (i.e. Programming to interface, not implementation etc).

For creating Observers , we first create an Observer interface through which the actual observers will be attached , detached or notified by the model.

Now, the observer interface is ready. Now we declare the Observer (The View + Container classes) which implements this MObserver interface.
The View Part: This is the main part.. This will keep connection with the Model.

Now , we need a controller. Here, the AppUI will act as a controller. It has reference to the view and the Model. It controls the change in view too. Here is the snapshot of our AppUI class...
Now, we see how it works...

1. Create the Observer View and Subject (CUserData) from inside the AppUI.

void CObserverTestAppUi::ConstructL()
{
BaseConstructL();
iAppContainer = new (ELeave) CObserverTestContainer;

//we create the Observer
iUserStatusView = new (ELeave) CUserStatusView(*this,KNoView);
iUserStatusView->ConstructL();
AddViewL(iUserStatusView);

//We create another View which is the default view
iOpeningView = new (ELeave) COpeningView(*this,KNoView);
iOpeningView->ConstructL();
AddViewL(iOpeningView);

//we create the Subject
iGpsData = new (ELeave) CUserData();
iGpsData->ConstructL();

iAppContainer->SetMopParent( this );
iAppContainer->ConstructL( ClientRect() );
SetDefaultViewL(*iOpeningView);

AddToStackL( iAppContainer );
}
2. In the CUserStatusView class , there is not much to show, we just have an Update Function which is called from the Subject;s Notify() function.

void CUserStatusView::Update(CUserData* theChangedSubject)
{
iContainer->SetSize(theChangedSubject->GetRectSize());
iContainer->SetAngle(theChangedSubject->DirectionAngle());
}

It is evident what this function does.... :-)

3. There is not also much to show the UserStatusContainer , inside its draw function , the data from CUserData is taken and shown in appropriate format to the screen.

4. The Subject (CUserData) class has some importatnt functions which are notable.
void CUserData::Attach(MObserver* anObserver)
{
iObservers.Append(anObserver);//attaches the observer to this
}

void CUserData::Detach(MObserver* anObserver)
{

}

void CUserData::Notify()
{
//notifies all the observers...
TInt numObservers = iObservers.Count();
for(TInt index =0; index <>Update(this);//this is the views Update function stated at step 2
}

5. And the above Notify() function is called from the Active Objects RunL() function..
void CUserData::RunL()
{
...................

Notify();
if (iState == EUninitialized) {
// Do something the first time RunL() is called
iState = EInitialized;
} else if (iState != EError) {
// Do something
}
iTimer.After(iStatus, 1000000); // Set for 1 sec later
SetActive(); // Tell scheduler a request is active
}

6. Now the most important thing... controlliing the view from AppUI...

void CObserverTestAppUi::HandleCommandL(TInt aCommand)
{
switch ( aCommand )
{
case EAknSoftkeyBack:
case EEikCmdExit:
{
Exit();
break;
}
case EObserverTestCmdAppTest:
{
iGpsData->Attach(iUserStatusView);
iGpsData->StartL(1000000);
ActivateViewL(TVwsViewId(KUidObserverTest,KUserStatusViewId));
break;
}

case EViewChangeCmd:
{
iGpsData->Detach(iUserStatusView);
iGpsData->Cancel();
ActivateViewL(TVwsViewId(KUidObserverTest,KOpeningViewId));
break;
}

default:
break;
}
}

This is the implementation details of the Observer pattern in Symbian C++ platform. Because of the Symbian OS architecture, the implementation is so Easy. There , is not much to customize, the great Symbian has it all made up from before....

Easiest Way To Use Font on Canvas

2007-09-11T17:06:00.000+06:00

There are many ways to use CFont in Symbian with the help of which we can draw texts on Canvas. But most easy way (IMHO!) is the following one:

1. Keep a CFont* as class member variable.
CFont* iFont;

2. Load font in the class's ConstructL() like :
TInt fontSize = 5;
_LIT(KMyFontName,"Nokia Sans SemiBold S60");
TFontSpec myFontSpec(KMyFontName,fontSize*20);
CGraphicsDevice* iScreenDevice = iCoeEnv->ScreenDevice();
iScreenDevice->GetNearestFontInTwips(iFont,myFontSpec);

3.Use the font whenever needed:
gc.UseFont(iFont);
gc.SetPenColor(KRgbRed);
gc.DrawText(_L("MyText"),TPoint(100,100));
gc.DiscardFont();

4. Release the font in the class's Destructor:
iCoeEnv->ScreenDevice()->ReleaseFont(iFont);

Usage of RPointerArray

2007-09-02T14:01:00.001+06:00

RPointerArray is one of the most frequently used Data Structures in Symbian C++ SDK. But due to the complexity of Symbian C++, its usage sometimes becomes a nightmare. If not properly handled, using RPointerArray may introduce a lot of memory leaks and bugs.
To Not one thing about RPointerArray : it always keeps a pointer to the instance and not the copy of the instance. So if we write RPointerArraya then it actually means an array of Pointer to TPoint.
The most common pattern of usage of RPointerArray will be discussed here.
RPointerArray can be of several types:
1.RPointerArray<'T'> myPointerArray;
2.RPointerArray<'T*'> myPointerArray;
3.RPointerArray<'T*'>* myPointerArray;
However, the usage and cleanup of the RPointerArray differs according to the declaration type.Here they will be with real examples:
Type 1: As Member Variable:
Construction
void CMyClass::ConstructL()
{
............................
iArray1 = RPointerArray(10);
for(TInt index = 0; index ‘<’10; index++)

iArray1.Append(new (ELeave)TPoint(index*10, index*10));
}
Usage Inside Function
void CMyClass::void f()
{
TPoint tempPoint;
for(TInt index = 0; index ‘<’iArray1.Count(); index ++) tempPoint = TPoint(*iArray1[index]);
}
Destruction
CMyClass::~CMyClass()
{
for(TInt index = 0; index’<’ iArray1.Count(); index++)

delete iArray1[index];
iArray1.Close();
}
Here We have not pushed the RpointerArray into the cleanup stack for two reasons:
1. We should never push a member valriable into the cleanup stack
2. Although RPointerArray holds pointers , but it is not itself a pointer (As declaration Suggests) and we cannot push a variable into the cleanup stack if it is not a pointer.
Type 1:Local Usage
Construction and Usage And Destruction
void CMyClass::MyFunction()
{
RPointerArray array1 = RPointerArray(10);//construction
for(TInt index = 0; index ‘<’10; index++)//put values inside array
array1.Append(new (ELeave) TPoint(index*10,index*10));
DoSomeThing();//do something with It
/*******************Destruction**************************************/
// for(index = 0 ; index’<’ array1.Count(); index++)
// delete array1[index] ;
//array1.Close();//For T Classes , we have to use this type of cleanup
/*******************Destruction**************************************/
array1.ResetAndDestroy(); //For C Classes and Basic Data Types(TReal), we have to use this

//type of cleanup
}

Type 2: As a member Variable:
Construction
Void CMyClass:ConstructL()
{
iArray2 = new (ELeave) RPointerArray<’TPoint’>(10);
for(TInt index = 0; index ‘<’ 10; index++)
iArray2-‘>’Append(new (ELeave)TPoint(index*10, index*10));
}

Usage
Void CMyClass::DoSomeThing()
{
TPoint tempPoint;
for(TInt index = 0; index ‘<’ iArray2-‘>’Count(); index ++)
tempPoint = TPoint(*(*iArray2)[index]);
}
Destruction
CMyClass::~CMyClass()
{
for(TInt index = 0;index ‘<’ iArray2-‘>’Count(); index ++)
delete (*iArray2)[index];
iArray2-‘>’Reset();
delete iArray2
}

Local Usage
Void CMyClass::MyFunction()
{
RPointerArray<’TPoint’>* iArray3 = new (ELeave)RPointerArray<’TPoint’>(10);
CleanupStack::PushL(iArray3);
CleanupClosePushL(*iArray3);
//Append Values
for(TInt index = 0; index ‘<’ 10; index ++) iArray3-‘>’Append(new (ELeave) TPoint(index,index));
//Sample Usage
TPoint tempPoint;
for(index =0; index ‘<’ iArray3-‘>’Count(); index++)
tempPoint = TPoint(*(*iArray3)[index]);
//....................
//Deleition and Cleanup.
for(index = 0 ; index ‘<’ iArray3-‘>’Count(); index++)
delete (*iArray3)[index];
CleanupStack::PopAndDestroy(iArray3);
CleanupStack::PopAndDestroy(iArray3);
}

RPointerArray<’TPoint*’>*array4 = new (ELeave)RPointerArray<’TPoint*’>(10);
TPoint* myPoint2 = new (ELeave) TPoint;
myPoint2-‘>’SetXY(100,100);
array4-‘>’Append(&myPoint2);
TPoint* myPoint1;
for(TInt index = 0; index ‘<’ array4-‘>’Count(); index++)
{
myPoint1 = new TPoint(**(*array4)[index]);
}

delete myPoint1;
for(TInt index = 0; index ‘<’ array4-‘>’Count(); index ++)
delete *(*array4)[index];
array4-‘>’Reset();
delete array4;

How to develop and Install a DLL in Symbian Development Environment.

2007-08-29T16:21:00.000+06:00

It is not necessary to describe what dll is and why they are used. I will just try to discuss dll from Symbian development point of view.

1. How to write a DLL.
2. Building a DLL.
3. How to use dll in Program.
4. How to load dll in Symbian devices.
5. An example of a usage of Messaging Type Module , a symbian System Level Dll.

In Symbian OS architecture, DLLs (Dynamic Link Library) are heavily used. However the discussion will start with polymorphic DLLs. From the usage point of view, Polymorphic are no different from static Interface DLLs – both of these are loaded and linked at runtime. In Symbian development, there is a bit difference between static interface dll and polymorphic interface dll.

Static interface DLL s have a specific and unique set of functions – in other words, 2 dlls with the same function name can not co exist in memory (One can not be loaded if other is loaded already).Static interfaces DLLs always have .dll extension.

Polymorphic DLLs are kind of different. Polymorphic DLL s work as a plug in that implements an abstract interface – it implements a concrete class that extends an abstract interface. Polymorphic dlls are explicitly loaded by RLibrary::Load() and closed using RLibrary::Close();
Polymorphic DLL s normally do not end in .dll but it has other extensions like .prn , .prt .app (more descriptive of the type of plug in they are implementing).

Developing a static interface dll is straightforward and there are many articles found in the internet which describes how to build a static DLL. However, here is the process in a nutshell.

What Clients Get :
1. A .h file which will be normally included by a normal #include “mydll.h”
2. A .lib file which will be linked against.
3. A .dll file which contains the implementations of all functions in the DLL.

What DLL developers need to Do:
1. Declare The class

class CDLL : public CBase
{
public:
IMPORT_C static CDLL* NewL();
IMPORT_C static CDLL* NewLC();
IMPORT_C void MyPublicMethod();
IMPORT_C void AnotherPublicMethod();
private:
CDLL();
void ConstructL();
void SomePrivateMethod();
};

The public functions are tagged with “IMPORT_C” macro to indicate that they will be used as dll functions. The NewL() and NewLC() functions are used to initialize the instance from client code.

2. Define the implementation:
In case of implementation , the functions that are to be Exported (Used as dll functions) will have EXPORT_C tag before the function definitions.

Creating a static interface dll through VS2003 IDE is pretty straightforward. It has some other issues related which will be discussed later.

Build a Symbian Os Dll application by VS2003 IDE . All the necessary changes will be made automatically in the .mmp file.
Write code and specific Export functions.
Build The Solution . The bld.inf file will be created.
Go into the Group Folder inside the project folder from Command Prompt. Write:
bldmake bldfiles
abld build armi urel ;
MakeSis urDLL.pkg
Then the necessary .h , .lib and .dll will be created

To use this on another application
1. Include the .h file in ur code.
2. Include the .lib in your project
3. Do the works as needed.

To install the DLL on the device :
1.Go to the .mmp file and and this line
TARGETPATH /system/libs after TARGETTYPE line

2.Go to the pkg file and Update the target Path from

; Target "C:\Symbian\8.0a\S60_2nd_FP2\Epoc32\release\armi\UREL\UrDLL.dll"
-"!:\system\libs\UrDLL.dll"

Then the sis file will be created and then if we install this on the device, then the .dll will be automatically loaded into the /system/libs

From programming point of view, A polymorphic DLL does not pose much difference.To write a polymorphic DLL we, have to first declare an interface and its functions which all the concrete classes inheriting this interface will implement.

The Abstract Base Class

class CMyBase : public CBase{ public : virtual void DoThis(const TDesC& aValue) = 0; };

The Derived Class Implementing The Interface

class CDerived : public CMyBase
{ public:
~CDerived();
static CDerived* NewL();
static CDerived* NewLC(); public:
void DoThis(const TDesC& aValue); private:
CDerived();
void ConstructL();
};

The Definition (Only the implemented Function)
void CDerived::DoThis(const TDesC& aValue)
{
CAknInformationNote* note = new (ELeave)CAknInformationNote();
note->ExecuteLD(_L("From Derived"));
}

Now we can use this as:
CMyBase* myBase; myBase = CDerived::NewL(); myBase->DoThis(_L("ZAFAR"));
That’s it. This is the whole concept, simple and Elegant . Now any one can write another DLL which implements The CMyBase class And he will be able to write his own implementation of DoThis() Fucntion. Each implementing Concrete class now resides in separate DLL.

The next discussion will be about the messaging type modules....

Installing Symbian SDK for VS2003 Platform

2007-08-28T16:04:00.000+06:00

I found installing Symbian SDK and Development Environment Quite Complex. There are a bunch of ways to Establish the envirnment for developing Symbian Programs. I have not a single complete Installation Manual for Development in Symbian . After searching the internet and doing some trial and Error, I have been able to install Symbian Development Environment in a go. I am stating here the installation steps. I dont question myself while following the steps , I just become a dumbTruck. Anywayz, Here are the steps to install Symbian Development Environment in Visual Studio 2003 IDE(There may be other more elegant ways Available, but mine will surely work).
1. Install Visual Studio 2003 IDE.
2. Install JRE 5.0
3. Install Active Perl (ActivePerl-5.8.8.819-MSWin32-x86-267479.msi - Found on the internet)
4. Install the Symbian SDK for visual studio 2003 (S60_SDK_v2.0_FP2_msb.zip)
5. Install the visual j# redistributable package.
6. Install Carbide plug-in, which is compatible for visual studio 2003.(carbide_vs_201.exe)
7. After installing the files in appropriate places, when we open the visual studio 2003 a form comes asking to register for the carbide plug-in. If we select the register form internet option, then it takes us to the forum.nokia.com site and after logging in there, it gives us a serial; number. Putting the serial number in the dialog of register options, Carbide is registered!!
8. Open the visual studio 2003 IDE.
9. Select new->project->visual c++ projects->Symbian OS and select New Symbian OS project from the template tab.
10. Then the wizard tells us to select the SDK of Symbian we are going to use for the project.

Hope This Helps.

Copying Bitmap Image in Symbian C++

2007-08-28T15:25:00.000+06:00

Here Is a simple way as how to copy an Offscreen Bitmap into another Bitmap.Suppose that we have loaded a Bitmap from the mbm (multi Bitmap File) Like this
CFbsBitmap* myBitmap = iEikonEnv->CreateBitmapL(KBmpPath,index);
Now we want to copy this bitmap into another CFbsBitmap object. But we dont want to pointer assignment , that is , we want to copy the contents of myBitmap into another bitmap. The way to do it is :
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);
And Its Done.Now we can use aBitmap in the same way as myBitmap.

Simple C++

2007-08-20T11:46:00.000+06:00

This is a simple technique for Symbian, especially C++ programmers. Suppose want to change the value of a member data of an instance. But the only way you get that instance as a const object. in that case, normally calling the value changing function wont work. Suppose you want to call the function SetHumanReadbleName() on the instance of CMtmDllInfo class. But the only way you get the reference of the instance is by calling CRegisteredMtmDll::MtmDllInfo() function which returns a const CMtmDllInfo object. In that case, SetHumanReadbleName() wont be allowed to be called on this object. So to call the function , you have to write :
const_cast"<"CMtmDllInfo&">"
(aRegisteredDll.MtmDllInfo()).SetHumanReadableNameL(_L("X"));