FCL/sf/app/conversations: comparison uiservicetab/vimpststorage/src/cvimpststorageserviceview.cpp

equal deleted inserted replaced

-:796276a1bdcc
+:9fdee5e1da30
 #include "vimpststorageutils.h"
 #include <MVPbkStoreContact.h>
 #include <VPbkContactStoreUris.h>
 #include <TVPbkContactStoreUriPtr.h>
-#include "vimpstdebugtrace.h"
+#include "uiservicetabtracer.h"
 #include "tvimpstconsts.h"
 #include "mvimpststoragecontact.h"
 // ============================ MEMBER FUNCTIONS ===============================
 CVIMPSTStorageServiceView::CVIMPSTStorageServiceView(TUint32 aServiceId) :
 iServiceId(aServiceId),
 iOwnContact( NULL ),
 iUnNamedText( NULL )
 {
-TRACE( T_LIT("CVIMPSTStorageServiceView::CVIMPSTStorageServiceView()") );
+	TRACER_AUTO;
 }
 // -----------------------------------------------------------------------------
 // CVIMPSTStorageServiceView::ConstructL
 // Symbian 2nd phase constructor can leave.
 // deleted elements from the persistent storage
 // -----------------------------------------------------------------------------
 //
 void CVIMPSTStorageServiceView::ConstructL(const TDesC& aStoreName, const TDesC& aServiceName)
 {
-TRACE( T_LIT("CVIMPSTStorageServiceView::ConstructL() begin") );
+	TRACER_AUTO;
 iActiveHandler =  CVIMPSTStorageActiveHandler::NewL(this);
 // create sorter for contacts
 iContactSorter = CVIMPSTStorageContactSorter::NewL();
 //set the sorting algorithem to order by presence.
 iContactSorter->SetSortAlgorithm( MVIMPSTStorageContact::ECompareByPresence);
-TRACE( T_LIT("SubServiceType() Type : %S"), &aStoreName );
+TRACE( "SubServiceType() Type : %S", &aStoreName );
 //find whether its a local store or xsp store
 	if ( VPbkContactStoreUris::DefaultCntDbUri().CompareC( aStoreName, 1, NULL )
 	                        != 0 )
 		{
-		TRACE( T_LIT("CVIMPSTStorageServiceView::ConstructL() service store created") );
+	TRACE( " service store created" );
 		//Create XSP Store
 	iVPbkContactStore =
 			CVIMPSTStorageVPbkServerStore::NewL(aStoreName,aServiceName ,*this );
 		}
 	else
 		{
-		TRACE( T_LIT("CVIMPSTStorageServiceView::ConstructL() local store created ") );
+	TRACE( "local store created " );
 		//Create Local Contacts.cdb store
 		iVPbkContactStore = CVIMPSTStorageVPbkLocalStore::NewL(VPbkContactStoreUris::DefaultCntDbUri(),
 															   aServiceName,
 															   *this );
 		}
-TRACE( T_LIT("CVIMPSTStorageServiceView::ConstructL() end") );;
 }
 // -----------------------------------------------------------------------------
 // CVIMPSTStorageServiceView::NewL
 //
 CVIMPSTStorageServiceView* CVIMPSTStorageServiceView::NewL(TUint32 aServiceId,
 										const TDesC& aStoreName,
 										const TDesC& aServiceName)
 {
-TRACE( T_LIT("CVIMPSTStorageServiceView::NewL() begin") );
+	TRACER_AUTO;
 CVIMPSTStorageServiceView* self = new( ELeave ) CVIMPSTStorageServiceView(aServiceId);
 CleanupStack::PushL( self );
 self->ConstructL(aStoreName, aServiceName);
 CleanupStack::Pop( self );
-TRACE( T_LIT("CVIMPSTStorageServiceView::NewL() end") );
 return self;
 }
 // -----------------------------------------------------------------------------
 // CVIMPSTStorageServiceView::~CVIMPSTStorageServiceView
 // Two-phased constructor.
 // -----------------------------------------------------------------------------
 // Destructor
 CVIMPSTStorageServiceView::~CVIMPSTStorageServiceView()
 {
-TRACE( T_LIT("CVIMPSTStorageServiceView::~CVIMPSTStorageServiceView() begin") );
+	TRACER_AUTO;
 if( iActiveHandler )
 	    {
 	    iActiveHandler->Cancel();
 	    delete iActiveHandler;
 	    }
 {
 delete iUnNamedText;
 iUnNamedText = NULL;
 }
-TRACE( T_LIT("CVIMPSTStorageServiceView::~CVIMPSTStorageServiceView() end") );
 }
 // -----------------------------------------------------------------------------
 // CVIMPSTStorageServiceView::AddObserverL
 // From MVIMPSTStorageServiceView
 // -----------------------------------------------------------------------------
 //
 void CVIMPSTStorageServiceView::AddObserverL( MVIMPSTStorageContactsObserver*
 aObserver )
 {
-TRACE( T_LIT("CVIMPSTStorageServiceView::AddObserverL() begin") );
+	TRACER_AUTO;
 User::LeaveIfError( aObserver ? KErrNone : KErrArgument );
 TInt index = iContactObservers.Find( aObserver );
 if( index == KErrNotFound )
 	    {
-	    TRACE( T_LIT("CVIMPSTStorageServiceView::AddObserverL() aObserver added ") );
+		TRACE( "aObserver added ");
 	    User::LeaveIfError( iContactObservers.Append( aObserver ) );
 	    }
-	TRACE( T_LIT("CVIMPSTStorageServiceView::AddObserverL() end") );
 }
 // -----------------------------------------------------------------------------
 // CVIMPSTStorageServiceView::RemoveObserverL
 // From MVIMPSTStorageServiceView
 // -----------------------------------------------------------------------------
 void CVIMPSTStorageServiceView::RemoveObserver( MVIMPSTStorageContactsObserver*
 aObserver )
 	{
-	TRACE( T_LIT("CVIMPSTStorageServiceView::RemoveObserver() begin") );
+	TRACER_AUTO;
 	__ASSERT_ALWAYS( aObserver, Panic( EObserverIsNull ));
 	const TInt index( iContactObservers.Find( aObserver ) );
 	if ( index >=0)
 		{
-		TRACE( T_LIT("CVIMPSTStorageServiceView::RemoveObserver() aObserver found") );
+		TRACE( "aObserver found" );
 		iContactObservers.Remove( index );
 		iContactObservers.Compress();
 		}
-	TRACE( T_LIT("CVIMPSTStorageServiceView::RemoveObserver() begin") );
 	}
 // -----------------------------------------------------------------------------
 // CVIMPSTStorageServiceView::SetUnnamedTextL
 // From MVIMPSTStorageServiceView
 //
 MVIMPSTStorageContactList* CVIMPSTStorageServiceView::CreateContactListL(
 										   const TDesC& aContactListId,
 const TDesC& aDisplayName )
 {
-TRACE( T_LIT("CVIMPSTStorageServiceView::CreateContactListL() begin") );
+	TRACER_AUTO;
 CVIMPSTStorageContactList* contactList =
 						CVIMPSTStorageContactList::NewLC(*iContactSorter,
 	  aContactListId,
 	  aDisplayName );
 TIdentityRelation< CVIMPSTStorageContactList > findBy(
 CVIMPSTStorageServiceView::ContactListFindByContactListId);
 TInt indexOfList( iContactListArray.Find( contactList, findBy ) );
 if( indexOfList == KErrNotFound )
 {
-TRACE( T_LIT("CVIMPSTStorageServiceView::CreateContactListL() list not exist in list") );
+		TRACE( "list not exist in list");
 TLinearOrder< CVIMPSTStorageContactList > order(
 CVIMPSTStorageServiceView::ContactListOrderByDisplayName );
 iContactListArray.InsertInOrderAllowRepeats( contactList, order );
 CleanupStack::Pop( contactList );
-TRACE( T_LIT("CVIMPSTStorageServiceView::CreateContactListL() new list created") );
+TRACE( " new list created");
 }
 else
 {
-TRACE( T_LIT("CVIMPSTStorageServiceView::CreateContactListL() list  already exist in list") );
+		TRACE( " list  already exist in list" );
 CleanupStack::PopAndDestroy( contactList );
 contactList = iContactListArray[ indexOfList ];
 }
-TRACE( T_LIT("CVIMPSTStorageServiceView::CreateContactListL() end") );
 return contactList;
 }
 // -----------------------------------------------------------------------------
 // CVIMPSTStorageServiceView::RemoveContactList
 // -----------------------------------------------------------------------------
 //
 void CVIMPSTStorageServiceView::RemoveContactList( const TDesC& aContactListId )
 {
-TRACE( T_LIT("CVIMPSTStorageServiceView::RemoveContactList() begin") );
+	TRACER_AUTO;
 TInt pos( FindContactListById( aContactListId ) );
 if( pos >= 0 )
 {
-TRACE( T_LIT("CVIMPSTStorageServiceView::RemoveContactList() aContactListId found") );
+		TRACE( "aContactListId found" );
 delete iContactListArray[ pos ];
 iContactListArray.Remove( pos );
 iContactListArray.Compress();
 }
-TRACE( T_LIT("CVIMPSTStorageServiceView::RemoveContactList() end") );
 }
 // -----------------------------------------------------------------------------
 // CVIMPSTStorageServiceView::ListCount
 // Count of contactlists
 // -----------------------------------------------------------------------------
 //
 TInt CVIMPSTStorageServiceView::ListCount() const
 {
-TRACE( T_LIT("CVIMPSTStorageServiceView::ListCount()") );
+	TRACER_AUTO;
 return iContactListArray.Count();
 }
 // -----------------------------------------------------------------------------
 // CVIMPSTStorageServiceView::ListAt
 // Reference to contact list
 // -----------------------------------------------------------------------------
 //
 MVIMPSTStorageContactList& CVIMPSTStorageServiceView::ListAt( TInt aIndex ) const
 {
-TRACE( T_LIT("CVIMPSTStorageServiceView::ListAt() begin") );
+	TRACER_AUTO;
 // User::LeaveIfError( aIndex < iContactListArray.Count() ? KErrNone : KErrArgument );
 __ASSERT_ALWAYS( (aIndex < iContactListArray.Count() && aIndex >=0 ), Panic( EContactsArrayOutOfSync ));
-TRACE( T_LIT("CVIMPSTStorageServiceView::ListAt() end") );
 return *iContactListArray[ aIndex ];
 }
 // -----------------------------------------------------------------------------
 // CVIMPSTStorageServiceView::ContactCount
 // Count of contacts
 // -----------------------------------------------------------------------------
 //
 TInt CVIMPSTStorageServiceView::ContactCount( TBool aSkipOfflineContacts ) const
 {
-TRACE( T_LIT("CVIMPSTStorageServiceView::ListAt() begin") );
+	TRACER_AUTO;
 TInt contactCount( 0 );
 TInt count( iContactListArray.Count() );
 for( TInt a( 0 ); a < count; ++a )
 {
 contactCount += iContactListArray[ a ]->ContactCount( aSkipOfflineContacts,
 EFalse );
 }
-TRACE( T_LIT("CVIMPSTStorageServiceView::ListAt() contactCount = %d") ,contactCount );
+		TRACE(" contactCount = %d" ,contactCount );
-TRACE( T_LIT("CVIMPSTStorageServiceView::ListAt() end") );
 return contactCount;
 }
 // -----------------------------------------------------------------------------
 // CVIMPSTStorageServiceView::UpdatepresenceL
 					                             TVIMPSTEnums::TOnlineStatus aStatus,
 					                             const TDesC& aStatusText,
 					                             const TDesC8& aAvatarData,
 					                             TBool aIsClearingAvatar /*= EFalse*/)
 	{
-	TRACE( T_LIT("CVIMPSTStorageServiceView::UpdatePresenceL() begin") );
+	TRACER_AUTO;
 	MVIMPSTStorageContact* contact = NULL;
 	if( iOwnContact && ( aContactId.Compare( iOwnContact->UserId() ) == 0  ) )
 	    {
-	    TRACE( T_LIT("CVIMPSTStorageServiceView::UpdatePresenceL() own Item presence") );
+		TRACE("own Item presence");
 	    if( aAvatarData.Compare(iOwnContact->AvatarContent() ) != 0 )
 	        {
 	        if((aIsClearingAvatar)||(aAvatarData.Length() > 0))
 	            {
-	            TRACE( T_LIT("CVIMPSTStorageServiceView::UpdatePresenceL() own avatar change NotifyAllObserversL") );
+				TRACE( "own avatar change NotifyAllObserversL");
 	            iOwnContact->SetAvatarContentL( aAvatarData ,*iVPbkContactStore );
 	            NotifyAllObserversL(TVIMPSTEnums::EStorageAvatarChange,NULL,iOwnContact,0);
 	            }
 	        }
 	    if( ( iOwnContact->OnlineStatus() !=  aStatus ) || ( aStatusText.Compare( iOwnContact->StatusText() ) != 0 ) )
 	        {
 		    // own presence has changes
 		    // update to own presence
 		    iOwnContact->SetOnlineStatus( aStatus );
 		    iOwnContact->SetStatusTextL(aStatusText);
-		    TRACE( T_LIT("CVIMPSTStorageServiceView::UpdatePresenceL() own presene NotifyAllObserversL") );
+		    TRACE( " own presene NotifyAllObserversL");
 		    NotifyAllObserversL(TVIMPSTEnums::EStorageOwnPresenceChange,NULL, iOwnContact,0);
 		    }
 	    contact = iOwnContact;
 		}
 	else
 		{
-		TRACE( T_LIT("CVIMPSTStorageServiceView::UpdatePresenceL() contact item ") );
+		TRACE( "contact item ");
 		contact = FindContactByUserId( aContactId );
 		if(contact)
 			{
-			TRACE( T_LIT("CVIMPSTStorageServiceView::UpdatePresenceL() contact exist ") );
+			TRACE( "contact exist " );
 			TInt index = KErrNotFound;
 			TVIMPSTEnums::TOnlineStatus oldOnlineStatus = contact->OnlineStatus();
-			TRACE( T_LIT("CVIMPSTStorageServiceView::UpdatePresenceL() contact oldOnlineStatus = %d"), oldOnlineStatus );
+			TRACE( "contact oldOnlineStatus = %d", oldOnlineStatus );
-			TRACE( T_LIT("CVIMPSTStorageServiceView::UpdatePresenceL() contact new presence = %d"), aStatus );
+			TRACE( "contact new presence = %d", aStatus );
 			//status text can be different for the sam status hence not inside the if condition.
 			if(  oldOnlineStatus != aStatus )
 			    {
-			    TRACE( T_LIT("CVIMPSTStorageServiceView::UpdatePresenceL() contact presence change ") );
+				TRACE( "contact presence change ");
 			    contact->SetOnlineStatus( aStatus );
 			    TInt count = iContactListArray.Count();
 			    for(TInt i = 0; i < count; i++)
 			        {
 			        index = iContactListArray[i]->FindIndexOfContact(contact);
 			        if(KErrNotFound != index )
 			            {
 			            iContactListArray[i]->ResortContact(contact);
-			            TRACE( T_LIT("CVIMPSTStorageServiceView::UpdatePresenceL() contact ResortContact ") );
+			            TRACE( "contact ResortContact " );
 			            // get the index of the sorted contact, as after sorting the
 			            // index would have changed based on presence.
 			            // break after the contact list is found and the contact is found
 			            break;
 			            }
 			    {
 			    TInt oldIndex = IndexOfContact (contact);
 			    contact->SetAvatarContentL( aAvatarData ,*iVPbkContactStore);
 			    NotifyAllObserversL(TVIMPSTEnums::EStorageAvatarChange,NULL, contact, oldIndex );
 			    }
-			TRACE( T_LIT("CVIMPSTStorageServiceView::UpdatePresenceL() aStatusText = %S "), &aStatusText );
+			TRACE("aStatusText = %S ", &aStatusText );
-			TRACE( T_LIT("CVIMPSTStorageServiceView::UpdatePresenceL() NotifyAllObserversL called") );
+			TRACE( "NotifyAllObserversL called" );
-			TRACE( T_LIT("CVIMPSTStorageServiceView::UpdatePresenceL() NotifyAllObserversL finish") );
+			TRACE( "NotifyAllObserversL finish" );
 			}
 	 	}
-	TRACE( T_LIT("CVIMPSTStorageServiceView::UpdatePresenceL() end") );
 return contact;
 }
 // -----------------------------------------------------------------------------
 // CVIMPSTStorageServiceView::UpdateAvatarL
 // -----------------------------------------------------------------------------
 //
 MVIMPSTStorageContact* CVIMPSTStorageServiceView::UpdateAvatarL(const TDesC& aContactId,
 							                  const TDesC8& aAvatarData )
 {
-TRACE( T_LIT("CVIMPSTStorageServiceView::UpdateAvatarL() begin") );
+TRACER_AUTO;
 MVIMPSTStorageContact* contact = NULL;
 if( iOwnContact && ( aContactId.Compare( iOwnContact->UserId() ) == 0  ) )
 		{
-		TRACE( T_LIT("CVIMPSTStorageServiceView::UpdateAvatarL() own avatar") );
+		TRACE( "own avatar" );
 		iOwnContact->SetAvatarContentL( aAvatarData ,*iVPbkContactStore);
 		NotifyAllObserversL(TVIMPSTEnums::EStorageOwnPresenceChange,NULL, iOwnContact,0);
 	    contact = iOwnContact;
 		}
 	else
 		{
-		TRACE( T_LIT("CVIMPSTStorageServiceView::UpdateAvatarL() buddy avatar") );
+		TRACE( "buddy avatar" );
 	    contact = FindContactByUserId( aContactId );
 		if(contact)
 			{
-			TRACE( T_LIT("CVIMPSTStorageServiceView::UpdateAvatarL() contact exit") );
+			TRACE( "contact exit");
 			contact->SetAvatarContentL( aAvatarData ,*iVPbkContactStore);
 			TInt index = IndexOfContact(contact);
 		    NotifyAllObserversL(TVIMPSTEnums::EStorageAvatarChange,NULL, contact,index);
-		    TRACE( T_LIT("CVIMPSTStorageServiceView::UpdateAvatarL() NotifyAllObserversL called") );
+		    TRACE( " NotifyAllObserversL called" );
 			}
 	   	}
-TRACE( T_LIT("CVIMPSTStorageServiceView::UpdateAvatarL() end") );
 return contact;
 }
 // -----------------------------------------------------------------------------
 // CVIMPSTStorageServiceView::FindContactListInternal
 // -----------------------------------------------------------------------------
 //
 CVIMPSTStorageContactList* CVIMPSTStorageServiceView::FindContactListInternal(
 const TDesC& aListId )
 {
-TRACE( T_LIT("CVIMPSTStorageServiceView::FindContactListInternal begin") );
+	TRACER_AUTO;
 	TInt contactListIndex( FindContactListById( aListId ) );
-	TRACE( T_LIT("CVIMPSTStorageServiceView::FindContactListInternal end ") );
 return ( contactListIndex >= 0 ? iContactListArray[ contactListIndex ] : NULL );
 }
 // -----------------------------------------------------------------------------
 // CVIMPSTStorageServiceView::FindContactList
 // -----------------------------------------------------------------------------
 //
 MVIMPSTStorageContactList* CVIMPSTStorageServiceView::FindContactList( const TDesC& aListId )
 {
-TRACE( T_LIT("CVIMPSTStorageServiceView::FindContactList") );
+	TRACER_AUTO;
 return FindContactListInternal( aListId );
 }
 // -----------------------------------------------------------------------------
 // CVIMPSTStorageServiceView::FindContactListById
 // -----------------------------------------------------------------------------
 //
 TInt CVIMPSTStorageServiceView::FindContactListById(const TDesC& aListId )
 	{
-	TRACE( T_LIT("CVIMPSTStorageServiceView::FindContactList begin") );
+	TRACER_AUTO;
 	TInt index = KErrNotFound;
 	TInt count( iContactListArray.Count() );
-	TRACE( T_LIT("CVIMPSTStorageServiceView::FindContactList count = %d"), count );
+	TRACE( " count = %d", count );
 	for( TInt i= 0  ; i < count ; i++ )
 		{
 		if( KErrNone == VIMPSTStorageUtils::NeutralCompare(
 							 aListId,
 iContactListArray[ i ]->ListId(), EFalse )   )
 			{
-			TRACE( T_LIT("CVIMPSTStorageServiceView::FindContactList contact list found") );
+			TRACE( " contact list found" );
 			index = i;
 			break;
 			}
 		}
-	TRACE( T_LIT("CVIMPSTStorageServiceView::FindContactList end") );
 	return index;
 	}
 // -----------------------------------------------------------------------------
 // CVIMPSTStorageServiceView::FindContactListById
 // -----------------------------------------------------------------------------
 //
 MVIMPSTStorageContact* CVIMPSTStorageServiceView::FindContactByLink(const MVPbkContactLink& aContactLink )
 	{
-	TRACE( T_LIT("CVIMPSTStorageServiceView::FindContactByLink begin") );
+	TRACER_AUTO;
 	MVIMPSTStorageContact* contact = NULL;
 	TInt count( iContactListArray.Count() );
 for( TInt i= 0  ; i < count ; i++ )
 {
 CVIMPSTStorageContactList* contactList = iContactListArray[ i ];
 contact = contactList->FindContactByContactLink( aContactLink );
 if( contact )
 {
-TRACE( T_LIT("CVIMPSTStorageServiceView::FindContactByLink contact found = %d "), i );
+TRACE( " contact found = %d ", i );
 break;
 }
 }
-TRACE( T_LIT("CVIMPSTStorageServiceView::FindContactByLink end") );
 return contact;
 	}
 // -----------------------------------------------------------------------------
 // CVIMPSTStorageServiceView::GetServiceId
 // -----------------------------------------------------------------------------
 //
 TUint32 CVIMPSTStorageServiceView::GetServiceId()
 {
-TRACE( T_LIT("CVIMPSTStorageServiceView::GetServiceId") );
+	TRACER_AUTO;
 return iServiceId;
 }
 // -----------------------------------------------------------------------------
 // CVIMPSTStorageServiceView::LocalStore
 // -----------------------------------------------------------------------------
 //
 TBool CVIMPSTStorageServiceView::IsLocalStore() const
 	{
-	TRACE( T_LIT("CVIMPSTStorageServiceView::IsLocalStore") );
+	TRACER_AUTO;
 	return iVPbkContactStore->LocalStore();
 	}
 // -----------------------------------------------------------------------------
 // CVIMPSTStorageServiceView::OwnContactL
 // -----------------------------------------------------------------------------
 //
 MVIMPSTStorageContact& CVIMPSTStorageServiceView::OwnContactL()
 	{
-	TRACE( T_LIT("CVIMPSTStorageServiceView::OwnContact begin") );
+	TRACER_AUTO;
 	if( !iOwnContact )
 		{
 		iOwnContact = CVIMPSTStorageContact::NewL(KNullDesC,
 		        								  KNullDesC )	;
 		}
-	TRACE( T_LIT("CVIMPSTStorageServiceView::OwnContact end") );
 	return *iOwnContact;
 	}
 // -----------------------------------------------------------------------------
 // CVIMPSTStorageServiceView::SetOwnUserIdL
 // -----------------------------------------------------------------------------
 //
 void CVIMPSTStorageServiceView::SetOwnUserIdL(const TDesC& aUserId )
 	{
-	TRACE( T_LIT("CVIMPSTStorageServiceView::SetOwnUserIdL begin") );
+	TRACER_AUTO;
 	if( !iOwnContact )
 		{
 		iOwnContact = CVIMPSTStorageContact::NewL(aUserId,
 		        								  KNullDesC
 		        								  )	;
-		TRACE( T_LIT("CVIMPSTStorageServiceView::SetOwnUserIdL iOwnContact created") );
+		TRACE( "iOwnContact created" );
 		}
 	else if( aUserId.Compare( iOwnContact->UserId() ) != 0 )
 		{
 	    _LIT (KNullWithSpace, " ");
-		TRACE( T_LIT("CVIMPSTStorageServiceView::SetOwnUserIdL iOwnContact was existing") );
+		TRACE( "SetOwnUserIdL iOwnContact was existing" );
 	    if(KNullWithSpace ().Compare(iOwnContact->UserId())!=0)
 	        {
 	        iVPbkContactStore->RemoveAllVPbkContactsL(); // if user id is changed remove all contacts
 	        RemoveAllCacheContactsL();
 	        }
 		iOwnContact->SetUserIdL( aUserId );
 		iOwnContact->SetAvatarContentL(KNullDesC8,*iVPbkContactStore );
 		NotifyAllObserversL( TVIMPSTEnums::EStorageEventOwnUserChanged,NULL,iOwnContact,0 );
-		TRACE( T_LIT("CVIMPSTStorageServiceView::SetOwnUserIdL NotifyAllObserversL delivered") );
+		TRACE( "NotifyAllObserversL delivered" );
 		}
-	TRACE( T_LIT("CVIMPSTStorageServiceView::SetOwnUserIdL end") );
 	}
 // -----------------------------------------------------------------------------
 // CVIMPSTStorageServiceView::FindContactByUserId
 // From MVIMPSTStorageServiceView.
 // Try to load with given ID, return NULL if not found.
 // -----------------------------------------------------------------------------
 MVIMPSTStorageContact* CVIMPSTStorageServiceView::FindContactByUserId( const TDesC& aUserId )
 	{
-	TRACE( T_LIT("CVIMPSTStorageServiceView::FindContactByUserId begin") );
+	TRACER_AUTO;
 	MVIMPSTStorageContact* contact = NULL;
 	CVIMPSTStorageContactList* contactList = NULL;
 	TInt count( iContactListArray.Count() );
 for( TInt a( 0 ); a < count; ++a )
 {
 contactList = iContactListArray[ a ];
 contact = contactList->FindContact( aUserId );
 if( contact )
 {
-TRACE( T_LIT("CVIMPSTStorageServiceView::FindContactByUserId contact found ") );
+TRACE(" contact found " );
 break;
 }
 }
-TRACE( T_LIT("CVIMPSTStorageServiceView::FindContactByUserId end") );
 return contact;
 	}
 // -----------------------------------------------------------------------------
 // CVIMPSTStorageServiceView::FindContactByUserId
 // From MVIMPSTStorageServiceView.
 // Try to load with given ID, return NULL if not found.
 // -----------------------------------------------------------------------------
 MVIMPSTStorageContact* CVIMPSTStorageServiceView::FindCacheContactByUserId( const TDesC& aUserId )
 {
-TRACE( T_LIT("CVIMPSTStorageServiceView::FindCacheContactByUserId") );
+	TRACER_AUTO;
 return FindContactByUserId( aUserId );
 }
 // -----------------------------------------------------------------------------
 // CVIMPSTStorageServiceView::FindCacheContactByLink
 // From MVIMPSTStorageServiceView.
 // Try to load with given ID, return NULL if not found.
 // -----------------------------------------------------------------------------
 MVIMPSTStorageContact* CVIMPSTStorageServiceView::FindCacheContactByLink(const MVPbkContactLink& aContactLink )
 {
-TRACE( T_LIT("CVIMPSTStorageServiceView::FindCacheContactByLink ") );
+	TRACER_AUTO;
 return FindContactByLink( aContactLink );
 }
 // -----------------------------------------------------------------------------
 // CVIMPSTStorageServiceView::CreateContactL
 // -----------------------------------------------------------------------------
 MVIMPSTStorageContact* CVIMPSTStorageServiceView::CreateNewContactL(const TDesC& aUserId,
 										   	   	         	const TDesC& aDisplayName /*= KNullDesC*/,
 										   	   	         	TBool aIsInvitationItem /*=EFalse*/,
 										   	   	         	TBool aInvitationAutoAccept /*= EFalse */)
 {
-TRACE( T_LIT("CVIMPSTStorageServiceView::CreateNewContactL begin") );
+	TRACER_AUTO;
 // This will create a contact in the CDB file.  It returns MVPbkContactLink link to the CDB file.
 MVIMPSTStorageContact* contact = FindCacheContactByUserId( aUserId );
 if( !contact )
 	    {
 	    iIsInvitationItem = aIsInvitationItem;
-	    TRACE( T_LIT("CVIMPSTStorageServiceView::CreateNewContactL contact does not exist in list") );
+	    TRACE( "contact does not exist in list" );
 	    iVPbkContactStore->CreateVPbkContactL( aUserId ,aDisplayName, aInvitationAutoAccept );
-	    TRACE( T_LIT("CVIMPSTStorageServiceView::CreateNewContactL new contact created") );
+	    TRACE( "new contact created");
 	    }
-	TRACE( T_LIT("CVIMPSTStorageServiceView::CreateNewContactL end") );
 return contact;
 }
 // -----------------------------------------------------------------------------
 // CVIMPSTStorageServiceView::CreateNewFetchContactsL
 // -----------------------------------------------------------------------------
 //
 void CVIMPSTStorageServiceView::CreateNewFetchContactsL( RArray <TPtrC> &aFirstNameList,
 RArray <TPtrC> &aServiceField )
 {
-TRACE( T_LIT("CVIMPSTStorageServiceView::CreateNewFetchContactsL begin") );
+	 TRACER_AUTO;
 if( !iVPbkContactStore->LocalStore() )
 {
 RemoveAllCacheContactsL();
 }
 iVPbkContactStore->AddVPbkFetchContactsL( aFirstNameList, aServiceField );
-TRACE( T_LIT("CVIMPSTStorageServiceView::CreateNewFetchContactsL end") );
 }
 // -----------------------------------------------------------------------------
 // CVIMPSTStorageServiceView::RemoveContactL
 // From MVIMPSTStorageServiceView.
 // Try to load with given ID, return NULL if not found.
 // -----------------------------------------------------------------------------
 TInt CVIMPSTStorageServiceView::RemoveContactL( MVIMPSTStorageContact* aContact )
 	{
-	TRACE( T_LIT("CVIMPSTStorageServiceView::RemoveContactL begin") );
+	TRACER_AUTO;
 	TInt error = KErrArgument;
 	if( aContact )
 		{
-		TRACE( T_LIT("CVIMPSTStorageServiceView::RemoveContactL contact found") );
+		TRACE( "contact found" );
 		error = iVPbkContactStore->RemoveVPbkContactL( *aContact->ContactLink() );
 		}
-	TRACE( T_LIT("CVIMPSTStorageServiceView::RemoveContactL end") );
 	return error;
 	}
 // -----------------------------------------------------------------------------
 // CVIMPSTStorageServiceView::RetriveLinkXSPIdsL
 // -----------------------------------------------------------------------------
 //
 TInt CVIMPSTStorageServiceView::RetriveLinkXSPIdsL(const TDesC8& aContactPackLink )
 {
-TRACE( T_LIT("CVIMPSTStorageServiceView::RetriveLinkXSPIdsL") );
+	TRACER_AUTO;
 // return the no of retrived xsp of contacts
 return iVPbkContactStore->RetrieveVPbkXSPIdL( aContactPackLink );
 }
 // ---------------------------------------------------------------------------
 // CVIMPSTStorageServiceView::GetRetrieveXSPIdL
 // ---------------------------------------------------------------------------
 //
 const TDesC& CVIMPSTStorageServiceView::GetRetrieveXSPIdL(TInt aIndex )
 	{
-	TRACE( T_LIT("CVIMPSTStorageServiceView::GetRetrieveXSPIdL aIndex = %d"),aIndex  );
+	TRACER_AUTO;
+	TRACE( " aIndex = %d",aIndex  );
 	return iVPbkContactStore->GetRetrieveVPbkXSPIdL( aIndex );
 }
 // -----------------------------------------------------------------------------
 // CVIMPSTStorageServiceView::CreateNewContactFromRetrivedIdL
 // -----------------------------------------------------------------------------
 //
 TInt CVIMPSTStorageServiceView::CreateNewContactFromRetrivedIdL( TInt aIndexToUse )
 {
-TRACE( T_LIT("CVIMPSTStorageServiceView::CreateNewContactFromRetrivedIdL aIndexToUse = %d"),aIndexToUse  );
+	TRACER_AUTO;
+TRACE( "aIndexToUse = %d",aIndexToUse  );
 // This will create a contact in the CDB file.  It returns MVPbkContactLink link to the CDB file.
 return iVPbkContactStore->CreateRetriveVPbkContactL( aIndexToUse );
 }
 // -----------------------------------------------------------------------------
 // CVIMPSTStorageServiceView::DeleteNewContactFromRetrivedIdL
 // -----------------------------------------------------------------------------
 //
 TInt CVIMPSTStorageServiceView::DeleteNewContactFromRetrivedIdL( TInt aIndexToUse )
 {
-TRACE( T_LIT("CVIMPSTStorageServiceView::DeleteNewContactFromRetrivedIdL aIndexToUse = %d"),aIndexToUse  );
+	TRACER_AUTO;
+TRACE( "aIndexToUse = %d",aIndexToUse  );
 // This will create a contact in the CDB file.  It returns MVPbkContactLink link to the CDB file.
 return iVPbkContactStore->deleteRetriveVPbkContactL( aIndexToUse );
 }
 // ----------------------------------------------------------
 // CVIMPSTStorageServiceView::DeleteDatabaseL
 // ----------------------------------------------------------
 void CVIMPSTStorageServiceView::DeleteDatabaseL()
 {
-TRACE( T_LIT("CVIMPSTStorageServiceView::DeleteDatabaseL") );
+	TRACER_AUTO;
 	iVPbkContactStore->DeleteDatabaseL();
 }
 //================================================== from writer interface=======================
 // -----------------------------------------------------------------------------
 MVIMPSTStorageContact* CVIMPSTStorageServiceView::UpdateCacheContactL(const MVPbkContactLink& aContactLink,
 																 const TDesC& aUserId,
 										   	   	         const TDesC& aDisplayName,
 										   	   	         const TDesC8& aAvatarContent)
 {
-TRACE( T_LIT("CVIMPSTStorageServiceView::UpdateCacheContactL begin") );
+	TRACER_AUTO;
 MVIMPSTStorageContact* contact = FindContactByLink(aContactLink);
 if( contact )
 	    {
 	    TInt oldIndex = IndexOfContact( contact );
 	    TBool sortNeeded = EFalse;
 	    if( contact->UserId().Compare( aUserId) != 0 )
 	        {
-	        TRACE( T_LIT("CVIMPSTStorageServiceView::UpdateCacheContactL user id changed") );
+	        TRACE( "user id changed" );
 	        NotifyAllObserversL( TVIMPSTEnums::EStorageEventUserIdPreChange,NULL, contact,oldIndex);
 	        contact->SetUserIdL( aUserId );
 	        if(aUserId.Length()== 0)
 {
 sortNeeded = ETrue;
 contact->SetOnlineStatus(TVIMPSTEnums::EUnknown);
 }
 	        NotifyAllObserversL( TVIMPSTEnums::EStorageEventUserIdPostChange,NULL, contact,oldIndex);
-	        TRACE( T_LIT("CVIMPSTStorageServiceView::UpdateCacheContactL NotifyAllObserversL delivered") );
+	        TRACE( "NotifyAllObserversL delivered" );
 	        }
 	    if(contact->Name().Compare(aDisplayName) != 0 )
 	        {
 sortNeeded = ETrue;
-	        TRACE( T_LIT("CVIMPSTStorageServiceView::UpdateCacheContactL display name changed") );
+	        TRACE( "display name changed" );
 	        if( aDisplayName.Length() <= 0 && iUnNamedText )
 				{
 				contact->SetNameL( *iUnNamedText );
 				}
 			else
 		        }
 	   NotifyAllObserversL( TVIMPSTEnums::EStorageEventContactChange,NULL,contact, oldIndex );
 	        }
 	   if( contact->AvatarContent().Compare( aAvatarContent ) != 0 )
 	        {
-	        TRACE( T_LIT("CVIMPSTStorageServiceView::UpdateCacheContactL user id changed") );
+	        TRACE( "User id changed" );
 	        contact->SetAvatarContentL( aAvatarContent,*iVPbkContactStore  );
 	        NotifyAllObserversL( TVIMPSTEnums::EStorageAvatarChange,NULL, contact, KErrNotFound);
-	        TRACE( T_LIT("CVIMPSTStorageServiceView::UpdateCacheContactL NotifyAllObserversL delivered") );
+	        TRACE( " NotifyAllObserversL delivered" );
 	        }
 	    }
-	TRACE( T_LIT("CVIMPSTStorageServiceView::UpdateCacheContactL end") );
 return contact;
 }
 // -----------------------------------------------------------------------------
 // CVIMPSTStorageServiceView::AddContactToCacheL
 // -----------------------------------------------------------------------------
 																 const TDesC& aUserId,
 										   	   	         const TDesC& aDisplayName,
 										   	   	         const TDesC8& aAvatarContent,
 										   	   	         TVIMPSTEnums::TVIMPSTStorgaeEventType aType )
 	{
-	TRACE( T_LIT("CVIMPSTStorageServiceView::AddContactToCacheL begin") );
+	TRACER_AUTO;
-	TRACE( T_LIT("CVIMPSTStorageServiceView::AddContactToCacheL user id: %S"), &aUserId);
+	TRACE(" user id: %S", &aUserId);
-	TRACE( T_LIT("CVIMPSTStorageServiceView::AddContactToCacheL storageeventtype: %d"), aType );
+	TRACE( " storageeventtype: %d", aType );
 	MVIMPSTStorageContactList* contactList = FindContactListInternal( KFriendList );
 	if( !contactList )
 		{
 		contactList = CreateContactListL(KFriendList,KNullDesC);
 		}
-	TRACE( T_LIT("CVIMPSTStorageServiceView::AddContactToCacheL before findcontactlink") );
+	TRACE(" Before findcontactlink" );
 	MVIMPSTStorageContact* contact = FindContactByLink(aContactLink);
-	TRACE( T_LIT("CVIMPSTStorageServiceView::AddContactToCacheL after findcontactlink ") );
+	TRACE( " After findcontactlink " );
 	if( !contact )
 		{
-		TRACE( T_LIT("CVIMPSTStorageServiceView::AddContactToCacheL contact not exist ") );
+		TRACE( " contact not exist ");
 		TInt error = KErrGeneral;
 		TInt index = KErrNotFound;
 		if( aDisplayName.Length() <= 0 && iUnNamedText )
 			{
-			TRACE( T_LIT("CVIMPSTStorageServiceView::AddContactToCacheL no display name ") );
+			TRACE(" no display name " );
 			contact = CVIMPSTStorageContact::NewLC( aUserId, *iUnNamedText , aContactLink ,aAvatarContent );
 			}
 		else
 			{
-			TRACE( T_LIT("CVIMPSTStorageServiceView::AddContactToCacheL has display name ") );
+			TRACE( " has display name " );
 			contact = CVIMPSTStorageContact::NewLC( aUserId, aDisplayName , aContactLink, aAvatarContent);
 			}
 		// if the xsp id is numm, then the presence state should be EUnknown;
 		if(0 == aUserId.Length())
 		    {
 	        // if user has choosen add contact set the default status as pending
 	        // to avoid any kind of flickering
 	        contact->SetOnlineStatus(TVIMPSTEnums::EPending);
 	        }
 		error = contactList->AddStorageContactToCacheL( contact, index );
-		TRACE( T_LIT("CVIMPSTStorageServiceView::AddContactToCacheL AddStorageContactToCacheL error= %d "),error );
+		TRACE( "AddStorageContactToCacheL error= %d ",error );
 		if( error == KErrNone )
 			{
-			TRACE( T_LIT("CVIMPSTStorageServiceView::AddContactToCacheL success ") );
+			TRACE( "success " );
 			CleanupStack::Pop(); // contact
 			TInt count = iContactListArray.Count();
 			for(TInt i = 0; i < count; i++)
 				{
 				index = iContactListArray[i]->FindIndexOfContact(contact);
 				if(KErrNotFound != index )
 				    {
 				    iContactListArray[i]->ResortContact(contact);
-				    TRACE( T_LIT("CVIMPSTStorageServiceView::AddContactToCacheL() contact ResortContact ") );
+				    TRACE( " contact ResortContact " );
 				    // get the index of the sorted contact, as after sorting the
 				    // index would have changed based on presence.
 				    // break after the contact list is found and the contact is found
 				    break;
 				    }
 			index = IndexOfContact(contact);
 		  	NotifyAllObserversL( aType,NULL, contact, index );
 			}
 		else
 			{
-			TRACE( T_LIT("CVIMPSTStorageServiceView::AddContactToCacheL not success ") );
+			TRACE( " not success " );
 			CleanupStack::PopAndDestroy(); // contact
 			contact = NULL;
 			}
 		}
 	iIsInvitationItem = EFalse; // reset the flag
-	TRACE( T_LIT("CVIMPSTStorageServiceView::AddContactToCacheL end") );
 	return contact;
 	}
 // -----------------------------------------------------------------------------
 // CVIMPSTStorageServiceView::AddStorageContactToCacheL
 // -----------------------------------------------------------------------------
 //
 TInt CVIMPSTStorageServiceView::AddStorageContactToCacheL(MVIMPSTStorageContact* aContactToAdd )
 	{
-	TRACE( T_LIT("CVIMPSTStorageServiceView::AddStorageContactToCacheL begin") );
+	TRACER_AUTO;
 	TInt error = KErrGeneral;
 MVIMPSTStorageContactList* contactList = FindContactListInternal( KFriendList );
 if( !contactList )
 {
 contactList = CreateContactListL(KFriendList,KNullDesC); // create the default list :TODO chnage to proper sol
 		if( aContactToAdd->Name().Length() <= 0 && iUnNamedText )
 			{
 			aContactToAdd->SetNameL( *iUnNamedText );
 			}
 		TInt index = KErrNotFound;
-TRACE( T_LIT("CVIMPSTStorageServiceView::AddStorageContactToCacheL online status = %d "), TVIMPSTEnums::EPending);
+TRACE( " online status = %d ", TVIMPSTEnums::EPending);
 // if the userid(xsp field is null then the presence is unknown.)
 if(aContactToAdd->UserId().Length() == 0)
 {
 aContactToAdd->SetOnlineStatus(TVIMPSTEnums::EUnknown);
 }
 else
 {
 aContactToAdd->SetOnlineStatus(TVIMPSTEnums::EPending);
 }
 		error = contactList->AddStorageContactToCacheL( aContactToAdd, index ); // aContactToAdd ownership is transfered
-		TRACE( T_LIT("CVIMPSTStorageServiceView::AddStorageContactToCacheL index = %d "),index );
+		TRACE( "index = %d ",index );
 		if( error == KErrNone )
 			{
 			TInt count = iContactListArray.Count();
 			for(TInt i = 0; i < count; i++)
 				{
 				index = iContactListArray[i]->FindIndexOfContact(aContactToAdd);
 				if(KErrNotFound != index )
 					{
 					iContactListArray[i]->ResortContact(aContactToAdd);
-					TRACE( T_LIT("CVIMPSTStorageServiceView::AddContactToCacheL() contact ResortContact ") );
+					TRACE( "contact ResortContact " );
 					// get the index of the sorted contact, as after sorting the
 					// index would have changed based on presence.
 					// break after the contact list is found and the contact is found
 					break;
 					}
 				}
 			index = IndexOfContact(aContactToAdd);
 			NotifyAllObserversL( TVIMPSTEnums::EStorageEventContactAddition,NULL, aContactToAdd, index );
 			}
 		}
-	TRACE( T_LIT("CVIMPSTStorageServiceView::AddStorageContactToCacheL error = %d "),error );
+	TRACE( " error = %d ",error );
-	TRACE( T_LIT("CVIMPSTStorageServiceView::AddStorageContactToCacheL end") );
 	return error;
 }
 // -----------------------------------------------------------------------------
 // CVIMPSTStorageServiceView::RemoveContactFromCacheL
 // From MVIMPSTStorageServiceView.
 // -----------------------------------------------------------------------------
 TInt CVIMPSTStorageServiceView::RemoveContactFromCacheL(const MVPbkContactLink& aContactLink,
 														 TVIMPSTEnums::TVIMPSTStorgaeEventType aType)
 	{
-	TRACE( T_LIT("CVIMPSTStorageServiceView::RemoveContactFromCacheL begin") );
+	TRACER_AUTO;
 	TInt error = KErrNotFound;
 	MVIMPSTStorageContactList* contactList = FindContactListInternal( KFriendList );
 if( !contactList )
 {
 contactList = CreateContactListL( KFriendList,KNullDesC ); // create the default list :TODO chnage to proper sol
 			}
 		TInt index = 0;
 	    error = contactList->RemoveContactFromCacheL( aContactLink, index );
 	    NotifyAllObserversL( TVIMPSTEnums::EStorageEventContactDelete ,NULL,NULL,index); //contact is not valid ,deleted
 		}
-	TRACE( T_LIT("CVIMPSTStorageServiceView::RemoveContactFromCacheL error = %d "),error );
+	TRACE("error = %d ",error );
-	TRACE( T_LIT("CVIMPSTStorageServiceView::RemoveContactFromCacheL begin") );
 return error;
 	}
 // -----------------------------------------------------------------------------
 // CVIMPSTStorageServiceView::RemoveAllCacheContactsL
 // -----------------------------------------------------------------------------
 //
 void CVIMPSTStorageServiceView::RemoveAllCacheContactsL()
 {
-TRACE( T_LIT("CVIMPSTStorageServiceView::RemoveContactFromCacheL begin") );
+	TRACER_AUTO;
-TRACE( T_LIT("CVIMPSTStorageServiceView::RemoveContactFromCacheL  count = %d"), iContactListArray.Count());
+TRACE( "  count = %d", iContactListArray.Count());
 iContactListArray.ResetAndDestroy();
-TRACE( T_LIT("CVIMPSTStorageServiceView::RemoveContactFromCacheL remove sucess") );
+TRACE( " remove sucess" );
 NotifyAllObserversL(TVIMPSTEnums::EStorageAllContactRemoved,NULL,NULL,0 );
-TRACE( T_LIT("CVIMPSTStorageServiceView::RemoveContactFromCacheL begin") );
 }
 // -----------------------------------------------------------------------------
 // CVIMPSTStorageServiceView::GetDefaultContactListL
 // -----------------------------------------------------------------------------
 //
 MVIMPSTStorageContactList* CVIMPSTStorageServiceView::GetDefaultContactListL()
 {
-TRACE( T_LIT("CVIMPSTStorageServiceView::GetDefaultContactListL begin") );
+	TRACER_AUTO;
 MVIMPSTStorageContactList* contactList = FindContactListInternal( KFriendList );
-TRACE( T_LIT("CVIMPSTStorageServiceView::GetDefaultContactListL end") );
 return contactList;
 }
 // -----------------------------------------------------------------------------
 // CVIMPSTStorageServiceView::NotifyServiceViewL
 // -----------------------------------------------------------------------------
 //
 void CVIMPSTStorageServiceView::NotifyServiceViewL( TVIMPSTEnums::TVIMPSTStorgaeEventType aEventType,
 													MVIMPSTStorageContact* aContact /*= NULL */ )
 {
-TRACE( T_LIT("CVIMPSTStorageServiceView::NotifyServiceViewL begin") );
+	TRACER_AUTO;
 NotifyAllObserversL(aEventType,NULL, aContact,0 );
-TRACE( T_LIT("CVIMPSTStorageServiceView::NotifyServiceViewL end") );
 }
 //================================================== from writer interface end ===========================
 // TLinearOrder
 // -----------------------------------------------------------------------------
 //
 TInt CVIMPSTStorageServiceView::ContactListOrderByDisplayName(
 const CVIMPSTStorageContactList& aContactListA,
 const CVIMPSTStorageContactList& aContactListB )
 {
-TRACE( T_LIT("CVIMPSTStorageServiceView::ContactListOrderByDisplayName") );
+	TRACER_AUTO;
 return aContactListA.DisplayName().CompareC( aContactListB.DisplayName() );
 }
 // TIdentityRelation
 // -----------------------------------------------------------------------------
 //
 TBool CVIMPSTStorageServiceView::ContactListFindByContactListId(
 const CVIMPSTStorageContactList& aContactListA,
 const CVIMPSTStorageContactList& aContactListB )
 {
-TRACE( T_LIT("CVIMPSTStorageServiceView::ContactListFindByContactListId start") );
+	TRACER_AUTO;
 const MVIMPSTStorageContactList& listA = aContactListA;
 const MVIMPSTStorageContactList& listB = aContactListB;
-TRACE( T_LIT("CVIMPSTStorageServiceView::ContactListFindByContactListId return") );
+TRACE(" return" );
 return ( VIMPSTStorageUtils::NeutralCompare( listA.ListId(),
 listB.ListId(), EFalse ) == 0 );
 }
 // -----------------------------------------------------------------------------
 // CVIMPSTStorageServiceView::Count
 // (other items were commented in a header).
 // -----------------------------------------------------------------------------
 //
 TInt CVIMPSTStorageServiceView::Count() const
 	{
-	TRACE( T_LIT("CVIMPSTStorageServiceView::Count start") );
+	TRACER_AUTO;
 	// fetch contact list count from storage
 	// and add contact counts from expanded contact lists
 	TInt listCount( ListCount() );
 	TInt itemCount( 0 );
 	TInt contactCount = 0;
 			// in this list to item count
 			itemCount += contactCount;
 		   //check for this
 			}
 	    }
-	TRACE( T_LIT("CVIMPSTStorageServiceView::itemCount =%d"),itemCount );
+	TRACE( "itemCount =%d",itemCount );
-	TRACE( T_LIT("CVIMPSTStorageServiceView::Count end") );
 	return itemCount;
 	}
 // -----------------------------------------------------------------------------
 // CVIMPSTStorageServiceView::Item
 // (other items were commented in a header).
 // -----------------------------------------------------------------------------
 //
 MVIMPSTStorageItemModel::SItem CVIMPSTStorageServiceView::Item( TInt aIndex  ) const
 {
-TRACE( T_LIT("CVIMPSTStorageServiceView::Item start") );
+	TRACER_AUTO;
 MVIMPSTStorageItemModel::SItem item;
 item.iType = MVIMPSTStorageItemModel::EInvalid;
 item.iContactList = NULL;
 item.iContact = NULL;
 	TInt contactCount = 0;
 ++count;
 	    if( count > aIndex )
 	        {
 	        // there's a list in given index
 	        item.iType = MVIMPSTStorageItemModel::EContactList;
-	        TRACE( T_LIT("CVIMPSTStorageServiceView::Item end") );
+	        TRACE( "Item end" );
 	        return item;
 	        }
 	    contactCount = list.Count() ;
 if( contactCount > 0  )
 			{
 			    {
 			    // there's a contact in given index
 			    TInt contactIndex( aIndex - count );
 			    item.iType = MVIMPSTStorageItemModel::EContactItem;
 			    item.iContact = &list[contactIndex];
-			    TRACE( T_LIT("CVIMPSTStorageServiceView::Item end") );
+			    TRACE( "Item end" );
 			    return item;
 			    }
 			// add expanded list's contact count
 			count += contactCount;
 			}
 	    }
 // not found
-TRACE( T_LIT("CVIMPSTStorageServiceView::Item end") );
 return item;
 	}
 // -----------------------------------------------------------------------------
 // CVIMPSTStorageServiceView::IndexOfContact
 // (other items were commented in a header).
 // -----------------------------------------------------------------------------
 //
 TInt CVIMPSTStorageServiceView::IndexOfContact( MVIMPSTStorageContact* aContact ) const
 	{
-	TRACE( T_LIT("CVIMPSTStorageServiceView::IndexOfContact begin") );
+	TRACER_AUTO;
 	TInt listCount( ListCount() );
 	TInt itemCount( 0 );
 	TInt contactCount = 0;
 	TInt indexOfContact = KErrNotFound;
 	for( TInt i(0); i < listCount; ++i )
 			{
 			itemCount += contactCount;
 			}
 		//add the code for if contact not found in first list
 		}
-	TRACE( T_LIT("CVIMPSTStorageServiceView::IndexOfContact indexOfContact = %d"), indexOfContact );
+	TRACE( " indexOfContact = %d", indexOfContact );
-	TRACE( T_LIT("CVIMPSTStorageServiceView::IndexOfContact end") );
 	return indexOfContact;
 	}
 // -----------------------------------------------------------------------------
 // CVIMPSTStorageServiceView::IndexOfList
 //
 TInt CVIMPSTStorageServiceView::IndexOfList( MVIMPSTStorageContactList* aList,
 TBool /*aIgnoreOwnItem = EFalse*/,
 TBool /*aIgnoreEmptyLists = ETrue*/ ) const
 {
-TRACE( T_LIT("CVIMPSTStorageServiceView::IndexOfList begin") );
+	TRACER_AUTO;
 	TInt listCount( ListCount() );
 	TInt itemCount( 0 );
 	for( TInt i(0); i<listCount; ++i )
 	    {
 	    MVIMPSTStorageContactList& list = ListAt(i);
 	    if( &list == aList )
 	        {
-	        TRACE( T_LIT("CVIMPSTStorageServiceView::IndexOfList list matched"));
+	        TRACE( "list matched");
 	        break;
 	        }
 	    else
 		    {
 		    // list will be consider for calculating the index
 	    	// at initial state of fetching the list.count will be zero
 	    	// because all the lists will be fetched first and the contacts
 	    	itemCount = itemCount+ list.Count() + 1;
 		    }
 	    }
-	TRACE( T_LIT("CVIMPSTStorageServiceView::IndexOfList itemCount = %d"),itemCount );
+	TRACE( "itemCount = %d",itemCount );
-	TRACE( T_LIT("CVIMPSTStorageServiceView::IndexOfList end") );
 	return itemCount;
 }
 // -----------------------------------------------------------------------------
 // CVIMPSTContactListModel::MdcaCount
 // (other items were commented in a header).
 // -----------------------------------------------------------------------------
 //
 TInt CVIMPSTStorageServiceView::MdcaCount() const
 {
-TRACE( T_LIT("CVIMPSTStorageServiceView::MdcaCount") );
+	TRACER_AUTO;
 return Count();
 }
 // -----------------------------------------------------------------------------
 // CVIMPSTContactListModel::MdcaPoint
 // (other items were commented in a header).
 // -----------------------------------------------------------------------------
 //
 TPtrC CVIMPSTStorageServiceView::MdcaPoint( TInt /*aIndex */) const
 {
-TRACE( T_LIT("CVIMPSTStorageServiceView::MdcaPoint") );
+	TRACER_AUTO;
 // These will be filtered out
 return KNullDesC();
 }
 // -----------------------------------------------------------------------------
 // CVIMPSTStorageServiceView::Sort
 /// KNullDesC -> sort all
 // -----------------------------------------------------------------------------
 //
 void CVIMPSTStorageServiceView::Sort( const TDesC& aContactListId /* = KNullDesC */ )
 {
-TRACE( T_LIT("CVIMPSTStorageServiceView::Sort() begin") );
+	TRACER_AUTO;
 if( aContactListId.Length() != 0 )
 {
 MVIMPSTStorageContactList* list = FindContactList( aContactListId );
 if( list )
 {
-TRACE( T_LIT("CVIMPSTStorageServiceView::Sort() list sort") );
+TRACE( " list sort" );
 list->Sort();
 }
 }
 else
 {
 TInt count( iContactListArray.Count() );
 for( TInt a( 0 ); a < count; ++a )
 {
 MVIMPSTStorageContactList& list = *iContactListArray[ a ];
-TRACE( T_LIT("CVIMPSTStorageServiceView::Sort() all list sort") );
+TRACE( " all list sort" );
 list.Sort();
 }
 }
-TRACE( T_LIT("CVIMPSTStorageServiceView::Sort() end") );
 }
 // -----------------------------------------------------------------------------
 // CVIMPSTStorageServiceView::NotifyAllObservers
 void CVIMPSTStorageServiceView::NotifyAllObserversL( TVIMPSTEnums::TVIMPSTStorgaeEventType aType,
 					        						  MVIMPSTStorageContactList *aList,
 					                                  MVIMPSTStorageContact* aContact,
 					                                  TInt aContactIndex )
 {
-TRACE( T_LIT("CVIMPSTStorageServiceView::NotifyAllObserversL() begin") );
+	TRACER_AUTO;
 	TInt count = iContactObservers.Count();
 	for( TInt i=0; i<count; i++ )
 		{
 		iContactObservers[i]->HandleStorageChangeL(  aType, aList, aContact, aContactIndex );
 		}
-TRACE( T_LIT("CVIMPSTStorageServiceView::NotifyAllObserversL() end") );
 }
 // -----------------------------------------------------------------------------
 // CVIMPSTStorageServiceView::NotifyAllObserversWithDelay
 // -----------------------------------------------------------------------------
 void CVIMPSTStorageServiceView::NotifyAllObserversWithDelay( TVIMPSTEnums::TVIMPSTStorgaeEventType aType,
 							        						 MVIMPSTStorageContactList *aList,
 							                                 MVIMPSTStorageContact* aContact,
 							                                 TInt aContactIndex )
 	{
-TRACE( T_LIT("CVIMPSTStorageServiceView::NotifyAllObserversWithDelay() begin") );
+	TRACER_AUTO;
 if(iActiveHandler->IsActive() )
 {
 iActiveHandler->Cancel();
 }
 iActiveHandler->IssueRequest( aType, aList, aContact, aContactIndex );
-TRACE( T_LIT("CVIMPSTStorageServiceView::NotifyAllObserversWithDelay() end") );
 }
 // -----------------------------------------------------------------------------
 // CVIMPSTStorageServiceView::HandleDelayedNotificationL
 // -----------------------------------------------------------------------------
 void CVIMPSTStorageServiceView::HandleDelayedNotificationL(TVIMPSTEnums::TVIMPSTStorgaeEventType aType,
 														   MVIMPSTStorageContactList *aList,
 								                           MVIMPSTStorageContact* aContact,
 								                           TInt aContactIndex)
 	{
-	TRACE( T_LIT("CVIMPSTStorageServiceView::HandleDelayedNotificationL() begin") );
+	TRACER_AUTO;
 	NotifyAllObserversL( aType, aList, aContact, aContactIndex );
-	TRACE( T_LIT("CVIMPSTStorageServiceView::HandleDelayedNotificationL() end") );
 	}
 //  End of File

branch	RCL_3
changeset 14	9fdee5e1da30
parent 10	78867dafe7eb
child 19	76f25fb7a6a1