FCL/sf/app/conversations: comparison uiservicetab/vimpstengine/src/cvimpstenginepresencesubservice.cpp

equal deleted inserted replaced

-:796276a1bdcc
+:9fdee5e1da30
 #include   <ximpfeatureinfo.h>
 #include <avabilitytext.h>
 //Presence Observer
 #include "mvimpstenginepresencesubserviceeventobserver.h"
-#include "vimpstdebugtrace.h"
+#include "uiservicetabtracer.h"
 #include "vimpstcustomcleanupapi.h" //For customized cleanup function
 #include "mvimpstengineserviceconnectioneventobserver.h"
 // CONTANTS
 const TInt KUriMaxLength = 255;
 iChangeStatusSupported ( ETrue ),
 iChangeStatusMsgSupported( ETrue ),
 iAvatarSupported( EFalse ),
 iIsClearingAvatar(EFalse)
 {
-TRACE( T_LIT("CVIMPSTEnginePrecenseSubService::CVIMPSTEnginePrecenseSubService start"));
+	TRACER_AUTO;
-TRACE( T_LIT("CVIMPSTEnginePrecenseSubService::CVIMPSTEnginePrecenseSubService end"));
 }
 // ---------------------------------------------------------------------------
 // CVIMPSTEnginePresenceSubService::ConstructL()
 // ---------------------------------------------------------------------------
 //
 void CVIMPSTEnginePresenceSubService::ConstructL()
 {
-TRACE( T_LIT("CVIMPSTEnginePresenceSubService::ConstructL start"));
+	TRACER_AUTO;
 iCchHandler.RegisterCchObserverL(this,ECCHPresenceSub);
 TCCHSubserviceState serviceState = ECCHUninitialized;
 TInt error = iCchHandler.GetServiceState(
 iBlockListFetchReqPending = EFalse; //req of fetching blocked list has been completed.
 	iLogoutRequest = EFalse;
 	iSubscribeToAuthList = EFalse;
 	iAutoAccept = EFalse;
-TRACE( T_LIT("CVIMPSTEnginePresenceSubService::ConstructL end"));
 }
 // ---------------------------------------------------------------------------
 // CVIMPSTEnginePresenceSubService::NewL()
 CVIMPSTEngineCchHandler& aCchHandler,
 CVIMPSTEngineServiceTableFetcher& aTableFetcher,
 CVIMPSTEngineSessionCntxtObserver& aXimpEventObserver,
 MVIMPSTEngineServiceConnectionEventObserver& aObserver )
 {
-TRACE( T_LIT("CVIMPSTEnginePresenceSubService::NewL start"));
+	TRACER_AUTO;
 CVIMPSTEnginePresenceSubService* self = NewLC( aServiceId,aCchHandler, aTableFetcher,
 aXimpEventObserver,aObserver );
 CleanupStack::Pop(self);
-TRACE( T_LIT("CVIMPSTEnginePresenceSubService::NewL end"));
 return self;
 }
 // ---------------------------------------------------------------------------
 // CVIMPSTEnginePresenceSubService::NewLC()
 CVIMPSTEngineCchHandler& aCchHandler,
 CVIMPSTEngineServiceTableFetcher& aTableFetcher,
 CVIMPSTEngineSessionCntxtObserver& aXimpEventObserver,
 MVIMPSTEngineServiceConnectionEventObserver& aObserver )
 {
-TRACE( T_LIT("CVIMPSTEnginePresenceSubService::NewLC start"));
+	TRACER_AUTO;
 CVIMPSTEnginePresenceSubService* self =
 new (ELeave) CVIMPSTEnginePresenceSubService( aServiceId,aCchHandler, aTableFetcher,  aXimpEventObserver,aObserver);
 CleanupStack::PushL(self);
 self->ConstructL();
-TRACE( T_LIT("CVIMPSTEnginePresenceSubService::NewLC end"));
 return self;
 }
 // ---------------------------------------------------------------------------
 // CVIMPSTEnginePresenceSubService::
 //      ~CVIMPSTEnginePresenceSubService()
 // ---------------------------------------------------------------------------
 //
 CVIMPSTEnginePresenceSubService::~CVIMPSTEnginePresenceSubService()
 {
-TRACE( T_LIT("CVIMPSTEnginePresenceSubService::NewLC start"));
+	TRACER_AUTO;
 	iCchHandler.UnRegisterCchObserver(ECCHPresenceSub);
 delete iServiceName;
 delete iPresenceCacheReader ;
 delete iBlockedListMgr;
 iBlockedListMgr = NULL;
-TRACE( T_LIT("CVIMPSTEnginePresenceSubService::NewLC end"));
 }
 // ---------------------------------------------------------------------------
 // CVIMPSTEnginePresenceSubService::
 //      ServiceState()
 // ---------------------------------------------------------------------------
 //
 TVIMPSTEnums::TVIMPSTRegistrationState CVIMPSTEnginePresenceSubService::SubServiceState() const
 	{
-	TRACE( T_LIT("CVIMPSTEnginePresenceSubService::ServiceState start"));
+	TRACER_AUTO;
 	return iServiceState;
 	}
 // ---------------------------------------------------------------------------
 // CVIMPSTEnginePresenceSubService::
 //      Type()
 // ---------------------------------------------------------------------------
 //
 TVIMPSTEnums::SubServiceType CVIMPSTEnginePresenceSubService::Type() const
 	{
-	TRACE( T_LIT("CVIMPSTEnginePresenceSubService::Type") );
+	TRACER_AUTO;
-	TRACE( T_LIT("CVIMPSTEnginePresenceSubService: [0x%x]"), this );
+	TRACE( "CVIMPSTEnginePresenceSubService: [0x%x]", this );
 	return TVIMPSTEnums::EPresence;
 	}
 // ---------------------------------------------------------------------------
 // CVIMPSTEnginePresenceSubService::
 // ---------------------------------------------------------------------------
 //
 TBool CVIMPSTEnginePresenceSubService::Enabled()
 {
-TRACE( T_LIT("CVIMPSTEnginePresenceSubService::Enabled start"));
+	TRACER_AUTO;
 TBool ret = EFalse;
 if( TVIMPSTEnums::ESVCERegistered == iServiceState)
 {
 ret = ETrue;
 }
-TRACE( T_LIT("CVIMPSTEnginePresenceSubService::Enabled end"));
 return ret;
 }
 // ---------------------------------------------------------------------------
 // CVIMPSTEnginePresenceSubService::RetrieveSubscribedListL
 // ---------------------------------------------------------------------------
 //
 void CVIMPSTEnginePresenceSubService::RetrieveSubscribedListL()
 {
-TRACE( T_LIT("CVIMPSTEnginePresenceSubService::RetrieveSubscribedListL start"));
+	TRACER_AUTO;
 //Create group id
 TBuf<KUriMaxLength> buffer( KListNameAllBuddy );
 MXIMPIdentity* groupList = iXimpEventObserver.XimpPresenceContextL().ObjectFactory().NewIdentityLC();
 __ASSERT_ALWAYS( groupList , User::Leave( KErrNoMemory ) );
 *groupList );
 CVIMPSTEngineRequestMapper* requestMapper =iXimpEventObserver.GetRequestMapper();
 requestMapper->CreateRequestL(operationId,EFalse,EVIMPSTXimpOperationGetSubscribedList);
 CleanupStack::PopAndDestroy(); // groupList
 // list retrieving ok. Waiting for list.;
-TRACE( T_LIT("CVIMPSTEnginePresenceSubService::RetrieveSubscribedListL end"));
 }
 // ---------------------------------------------------------------------------
 // CVIMPSTEnginePresenceSubService::SubscribePresenceOfSingleContactL
 // ---------------------------------------------------------------------------
 //
 void CVIMPSTEnginePresenceSubService::SubscribePresenceOfSingleContactL( const TDesC& aUriOfTheContact)
 {
-TRACE( T_LIT("CVIMPSTEnginePresenceSubService::SubscribePrecenseOfSingleContactL start"));
+	TRACER_AUTO;
 __ASSERT_ALWAYS( aUriOfTheContact.Length(), User::Leave( KErrArgument ) );
 //if anything is there with colon eg sip:user@presence1. strip the part before :
 TInt len = aUriOfTheContact.Find(_L(":"));
 TPtrC buddyId = aUriOfTheContact.Right( aUriOfTheContact.Length() - len - KColon().Length());
 HBufC* name = HBufC::NewLC( KPropertyMaxLength );
 // append the service name followed by user id ,seperated by colon
 namePtr.Append(*iServiceName);
 namePtr.Append(KColon);
 namePtr.Append(buddyId);
-TRACE( T_LIT("CVIMPSTEnginePresenceSubService::SubscribeToPresenceCacheL: %S"), &namePtr );
+TRACE("SubscribeToPresenceCacheL: %S", &namePtr );
 iPresenceCacheReader->SubscribePresenceBuddyChangeL(*name);
 CleanupStack::PopAndDestroy(name); //  name
-TRACE( T_LIT("CVIMPSTEnginePresenceSubService::SubscribePrecenseOfSingleContactL end"));
 }
 // ---------------------------------------------------------------------------
 // CVIMPSTEnginePresenceSubService::
 //      UnsubscribePrecenseOfSingleContactL
 // ---------------------------------------------------------------------------
 //
 void CVIMPSTEnginePresenceSubService::UnSubscribePresenceOfSingleContactL(
 const TDesC& aUriOfTheContact )
 {
-TRACE( T_LIT("CVIMPSTEnginePresenceSubService::UnsubscribePrecenseOfSingleContactL start"));
+	TRACER_AUTO;
 HBufC* name = HBufC::NewLC( KPropertyMaxLength );
 TPtr namePtr( name->Des() );
 namePtr.Zero();
 // append the service name followed by user id ,seperated by colon
 namePtr.Append(*iServiceName);
 namePtr.Append(KColon);
 namePtr.Append(aUriOfTheContact);
-TRACE( T_LIT("CVIMPSTEnginePresenceSubService::UnSubscribeToPresenceCacheL: %S"), &namePtr);
+TRACE( "UnSubscribeToPresenceCacheL: %S", &namePtr);
 iPresenceCacheReader->UnSubscribePresenceBuddyChangeL(*name);
 CleanupStack::PopAndDestroy(name); //  name
-TRACE( T_LIT("CVIMPSTEnginePresenceSubService::UnsubscribePrecenseOfSingleContactL end")) ;
 }
 // ---------------------------------------------------------------------------
 // CVIMPSTEnginePresenceSubService::
 //      DoHandlePresentityGroupContentEventL
 void CVIMPSTEnginePresenceSubService::
 DoHandlePresentityGroupContentEventL(
 const MXIMPContext& /*aContext*/,
 const MXIMPBase& aEvent )
 {
-TRACE( T_LIT("CVIMPSTEnginePresenceSubService::DoHandlePresentityGroupContentEventL start"));
+	TRACER_AUTO;
 const MPresentityGroupContentEvent& event =
 	*TXIMPGetInterface< const MPresentityGroupContentEvent >::From(
 aEvent,
 MXIMPBase::EPanicIfUnknown );
 //this needs to be checked if server contacts is supported only then update to
 //store else don't.
 	TInt supportedFeatures = iXimpEventObserver.GetSupportedFeatures();
 	if(EVIMPSTFeatureFetch & supportedFeatures)
 		{
-	    TRACE( T_LIT(" -> storing into respective service store" ));
+	TRACE(" -> storing into respective service store" );
 	    StoreToVirtualStoreL( event );
 		}
 	//this is to ensure the presence for the local sotre contacts is not lost.
-	TRACE( T_LIT(" -> new member count: %d" ), event.NewMembersCount() );
+	TRACE( "new member count: %d" , event.NewMembersCount() );
-TRACE( T_LIT(" -> current member count: %d" ), event.CurrentMembersCount() );
+TRACE( " current member count: %d" , event.CurrentMembersCount() );
-TRACE( T_LIT(" -> disappeared member count: %d" ), event.DisappearedMembersCount() );
+TRACE( "disappeared member count: %d" , event.DisappearedMembersCount() );
-TRACE( T_LIT("CVIMPSTEnginePresenceSubService::DoHandlePresentityGroupContentEventL end"));
 }
 // ---------------------------------------------------------------------------
 // CVIMPSTEnginePresenceSubService::
 //      DoHandlePresenceGrantRequestListEventL
 void CVIMPSTEnginePresenceSubService::
 DoHandlePresenceGrantRequestListEventL(
 const MXIMPContext& /*aContext*/,
 const MXIMPBase& aEvent )
 {
-TRACE( T_LIT("CVIMPSTEnginePresenceSubService::DoHandlePresenceGrantRequestListEventL start"));
+	TRACER_AUTO;
 TVIMPSTEnums::TVIMPSTPresenceRequestStatus autoAccept = iSettingsTableFetcher.PresenceRequestStatusL(iServiceId);
 if(autoAccept == TVIMPSTEnums::ESVCEPresenceRequestStatusAutoAccept)
 {
 iAutoAccept = ETrue;
 }
 const MPresenceGrantRequestListEvent& event =
 							*TXIMPGetInterface<const MPresenceGrantRequestListEvent >::From(
 								aEvent, MXIMPBase::EPanicIfUnknown );
-TRACE( T_LIT(" -> new watcher count: %d" ), event.NewRequestsCount() );
+TRACE("new watcher count: %d" , event.NewRequestsCount() );
-TRACE( T_LIT(" -> current watcher count: %d" ), event.CurrentRequestsCount() );
+TRACE("current watcher count: %d" , event.CurrentRequestsCount() );
 HBufC* identbuf(NULL);
 HBufC* displayName(NULL);
 TInt newcount     = event.NewRequestsCount();
 TInt currentcount = event.CurrentRequestsCount();
 if(newcount)
 {
-TRACE( T_LIT("CVIMPSTEnginePresenceSubService::DoHandlePresenceGrantRequestListEventL newcount =%d" ), newcount );
+TRACE( " newcount =%d" , newcount );
-TRACE( T_LIT("CVIMPSTEnginePresenceSubService::DoHandlePresenceGrantRequestListEventL iServiceState =%d" ), iServiceState );
+TRACE( "iServiceState =%d" , iServiceState );
 for(TInt i=0; i<newcount; i++)
 {
 const MPresenceGrantRequestInfo& reqInfo = event.NewRequest ( i );// its always a new request
 identbuf = reqInfo.RequestorId().Identity().AllocLC();
 displayName = reqInfo.RequestorDisplayName().AllocLC();
 TPtr identbufPtr = identbuf->Des();
-TRACE( T_LIT(" -> identity: %S" ), &identbufPtr );
+TRACE( "identity: %S" , &identbufPtr );
 if(identbuf->Length())
 {
-TRACE( T_LIT(" -> pass to command process" ));
+TRACE( " pass to command process" );
 if( iAutoAccept &&
 TVIMPSTEnums::ESVCERegistered == iServiceState)
 {
 TInt error = SendPresenceGrantPresentityL( identbufPtr, ETrue );
 }
 else if( iSubServiceObserver )
 {
-TRACE( T_LIT(" -> informed observer." ));
+TRACE( " informed observer." );
 iSubServiceObserver->HandleAddRequestEventL( TVIMPSTEnums::EAddItem , *identbuf, *displayName);
 }
-TRACE( T_LIT(" -> pass to command process" ));
+TRACE( " pass to command process" );
 }
 CleanupStack::PopAndDestroy( displayName );
 CleanupStack::PopAndDestroy( identbuf );
 }
 }
 {
 const MPresenceGrantRequestInfo& reqInfo = event.CurrentRequest(0 );// its always a new request
 identbuf = reqInfo.RequestorId().Identity().AllocLC();
 displayName  = reqInfo.RequestorDisplayName().AllocLC();
 TPtr identbufPtr = identbuf->Des();
-TRACE( T_LIT(" -> identity: %S" ), &identbufPtr );
+TRACE( "identity: %S" , &identbufPtr );
 if(identbuf->Length())
 {
-TRACE( T_LIT(" -> pass to command process" ));
+TRACE( " pass to command process" );
 if( iAutoAccept)
 {
 TInt error = SendPresenceGrantPresentityL( identbufPtr, ETrue );
 }
 else if( iSubServiceObserver )
 {
-TRACE( T_LIT(" -> informed observer." ));
+TRACE( " informed observer.");
 iSubServiceObserver->HandleAddRequestEventL(TVIMPSTEnums::EAddItem ,*identbuf, *displayName);
 }
-TRACE( T_LIT(" -> pass to command process" ));
+TRACE( "pass to command process" );
 }
 CleanupStack::PopAndDestroy( displayName );
 CleanupStack::PopAndDestroy ( identbuf );
 }
-TRACE( T_LIT("CVIMPSTEnginePresenceSubService::DoHandlePresenceGrantRequestListEventL end"));
 }
 // ---------------------------------------------------------------------------
 // CVIMPSTEnginePresenceSubService::ResolveServiceStateL
 TVIMPSTEnums::TVIMPSTRegistrationState CVIMPSTEnginePresenceSubService::ResolveServiceStateL(
 TCCHSubserviceState aState,
 TInt aServiceError )
 {
-TRACE( T_LIT("CVIMPSTEnginePresenceSubService::ResolveServiceStateL start"));
+	TRACER_AUTO;
 TVIMPSTEnums::TVIMPSTRegistrationState state = TVIMPSTEnums::ESVCENotRegistered;
-TRACE( T_LIT("ResolveServiceStateL() iServiceId: %d, ServiceState: %d"),
-iServiceId, aState );
+TRACE( " iServiceId: %d, ServiceState: %d",  iServiceId, aState );
 TBool handleServiceStates = ETrue;
 if ( aServiceError && ECCHDisabled != aState )
 {
 //Only if the Service supports ALR, the state can goto WaitingForNetwork
 //Still API from CCH is required to know whether ALR is supported or not
 //Not sure whether the below is right - have mailed to Markus for MoreInfo on this state
 if ( (KCCHErrorInvalidSettings != aServiceError) && (ECCHConnecting == aState) )
 {
-TRACE( T_LIT("ResolveServiceStateL() ESVCEWaitingForNetwork") );
+TRACE( " ESVCEWaitingForNetwork");
 handleServiceStates = EFalse;
 //state = TVIMPSTEnums::ESVCEWaitingForNetwork;
 state = TVIMPSTEnums::ESVCENotRegistered;
 }
 }
 {
 switch ( aState )
 {
 case ECCHEnabled:
 {
-TRACE( T_LIT("ResolveServiceStateL() ESVCERegistered") );
+TRACE( "ESVCERegistered" );
 state = TVIMPSTEnums::ESVCEUpdatingContacts;
 break;
 }
 case ECCHDisconnecting:
 {
-TRACE( T_LIT("ResolveServiceStateL() ESVCERegistered") );
+TRACE( " ESVCERegistered" );
 state = TVIMPSTEnums::ESVCENetworkDisConnecting;
 }
 break;
 case ECCHUninitialized:
 case ECCHDisabled:
 {
-TRACE( T_LIT("ResolveServiceStateL() ESVCENotRegistered") );
+TRACE( "ESVCENotRegistered");
 state = TVIMPSTEnums::ESVCENotRegistered;
 }
 break;
 case ECCHConnecting:
 {
-TRACE( T_LIT("ResolveServiceStateL() ESVCENoNetworkConnecting") );
+TRACE( " ESVCENoNetworkConnecting");
 state = TVIMPSTEnums::ESVCENetworkConnecting;
 }
 break;
 default:
 break;
 }
 }
-TRACE( T_LIT("CVIMPSTEnginePresenceSubService::ResolveServiceStateL end"));
 return state;
 }
 TUint /*aServiceId*/,
 TCCHSubserviceState aState,
 TInt aServiceError )
 {
-TRACE( T_LIT("CVIMPSTEnginePresenceSubService::CchEventOccuredL start"));
+	TRACER_AUTO;
-TRACE( T_LIT("CchEventOccuredL() TCCHSubserviceState : %d, ServiceErr: %d"),
-aState, aServiceError );
+TRACE("TCCHSubserviceState : %d, ServiceErr: %d", aState, aServiceError );
 if ( aServiceError && ECCHDisabled != aState )
 {
 //we might even end up in waiting for connection state for all
 //those service which are ALR enabled
 			{
 			iServiceState = ResolveServiceStateL( aState, aServiceError );
 		    iObserver.HandleServceConnectionEventL();			}
 }
-TRACE( T_LIT("CVIMPSTEnginePresenceSubService::CchEventOccuredL end"));
 }
 // ---------------------------------------------------------------------------
 //
 void CVIMPSTEnginePresenceSubService::DoHandleCchErrorL(
 TInt aServiceError )
 {
-TRACE( T_LIT("CVIMPSTEnginePresenceSubService::DoHandleCchErrorL start"));
+	TRACER_AUTO;
-TRACE( T_LIT("DoHandleCchErrorL() ServiceErr: %d"),
+	   TRACE( "ServiceErr: %d",  aServiceError );
-aServiceError );
 if ( aServiceError )
 {
 //unsubscribe can only be done, when bind is already done
 if(TVIMPSTEnums::EVIMPSTBindDone ==iXimpEventObserver.ContextBindStatus())
 {
-TRACE( T_LIT("CVIMPSTEnginePresenceSubService::DoHandleCchErrorL unscribe and unbind"));
+TRACE( "unscribe and unbind");
 TRAP_IGNORE( UnsubscribeListsL() );
 iXimpEventObserver.ServerUnBindL( ETrue );
 }
 }
-TRACE( T_LIT("CVIMPSTEnginePresenceSubService::DoHandleCchErrorL end"));
 }
 // ---------------------------------------------------------
 // CVIMPSTEnginePresenceSubService::PublishOwnPresenceL
 //
 														  const TDesC& aValue,
 						         						  const TDesC& aFilename /*= KNullDesC*/,
 						         						  const TDesC8& aMimetype /*= KNullDesC8*/,
 						         						  TBool aIsAvatar /*= EFalse*/ )
 {
-	TRACE( T_LIT("CVIMPSTEnginePresenceSubService::PublishOwnPresenceL start"));
+	TRACER_AUTO;
 // Take handles to object factory and publish interface
 MPresencePublishing& publisher = iXimpEventObserver.XimpPresencePublishingL();
 //Fill presence doc with presence components and attributes
 MPresenceInfo* myPresence = iXimpEventObserver.PresenceObjectFactoryL().NewPresenceInfoLC();//1
 MPersonPresenceInfo *personPresence = iXimpEventObserver.PresenceObjectFactoryL().NewPersonPresenceInfoLC();//2
 MPresenceInfoFieldCollection& attributeFields = personPresence->Fields();
 	MPresenceInfoField* infoField = NULL;
-	TRACE( T_LIT("PublishOwnPresenceL aIsAvatar: %d"),  aIsAvatar );
+	TRACE( "aIsAvatar: %d",  aIsAvatar );
 	// avatar field set || clear
 	if ( aIsAvatar )
 {
-TRACE( T_LIT(" PublishOwnPresenceL adding avatar field"));
+	TRACE( " PublishOwnPresenceL adding avatar field");
 	infoField = iXimpEventObserver.PresenceObjectFactoryL().NewInfoFieldLC();
 MPresenceInfoFieldValueBinary* avatarField = iXimpEventObserver.PresenceObjectFactoryL().NewBinaryInfoFieldLC();
-TRACE( T_LIT(" PublishOwnPresenceL processing image data"));
+TRACE( " PublishOwnPresenceL processing image data");
 CVIMPSTEngineImageHandler* imageHandler = CVIMPSTEngineImageHandler::NewL();
 CleanupStack::PushL(imageHandler);
 // get the avatar content from the image processor
 // returns image content if the  processing succesful
 HBufC8* avatarContent = imageHandler->ProcessImageFromFileL( aFilename , aMimetype);
-TRACE( T_LIT(" PublishOwnPresenceL processing image data completed "));
+TRACE( " PublishOwnPresenceL processing image data completed ");
 if ( avatarContent )
 			{
-			TRACE( T_LIT("PublishOwnPresenceL valid image data found "));
+TRACE( "PublishOwnPresenceL valid image data found ");
 			CleanupStack::PushL(avatarContent);
 			// set a new avatar
 			avatarField->SetBinaryValueL(*avatarContent);
 			avatarField->SetMimeTypeL(aMimetype);
 			CleanupStack::PopAndDestroy(); // avatarContent
 			}
 		else
 			{
-			TRACE( T_LIT("PublishOwnPresenceL NULL image data found "));
+		TRACE("PublishOwnPresenceL NULL image data found ");
 			//  clear the avatar
 			avatarField->SetBinaryValueL(KNullDesC8);
 			iIsClearingAvatar = ETrue;  //set iIsClearingAvatar to ETrue
 			}
 CleanupStack::PopAndDestroy(imageHandler); // imageHandler
 	infoField->SetFieldValue( avatarField );  // avatarField ownership transfered
 CleanupStack::Pop(); // avatarField
 		attributeFields.AddOrReplaceFieldL(infoField ); // infofield ownership transfered
 CleanupStack::Pop(); // infoField
 		infoField = NULL;
-		TRACE( T_LIT(" PublishOwnPresenceL adding avatar field completed "));
+		TRACE( "adding avatar field completed ");
 }
 // availabilty field
 infoField = iXimpEventObserver.PresenceObjectFactoryL().NewInfoFieldLC();//3
 //based on the state conver it to  ximpfw status.
 // not own
 CVIMPSTEngineRequestMapper* mapper = iXimpEventObserver.GetRequestMapper();
 mapper->CreateRequestL(reqId, ETrue,EVIMPSTXimpOperationPublisOwnPresence);// waite here
 TInt error = iXimpEventObserver.GetCompletedReqResult(); // get the result error
 CleanupStack::PopAndDestroy(1); // myPresence
-TRACE( T_LIT("CVIMPSTEnginePresenceSubService::PublishOwnPresenceL end "));
 return error;
 }
 // ---------------------------------------------------------
 // CVIMPSTEnginePresenceSubService::UpdateStatusToServerL
 //
 // ---------------------------------------------------------
 NPresenceInfo::TAvailabilityValues CVIMPSTEnginePresenceSubService::ConvertPresenceStatus(TVIMPSTEnums::TOnlineStatus aStatus)
 {
+	TRACER_AUTO;
 NPresenceInfo::TAvailabilityValues availablity;
 switch(aStatus)
 {
 case TVIMPSTEnums::EOffline:
 {
 TInt  CVIMPSTEnginePresenceSubService::FetchPresenceFromCache()
 {
 //TODO::Figure out how to get the service name.
 // passed the service id to see the member count
 TInt error( KErrArgument );
-TRACE( T_LIT("CVIMPSTEnginePresenceSubService::FetchPresenceFormCache() start") );
+TRACER_AUTO;
 	if( iServiceName )
 		{
 		TPtr serviceNamePtr = iServiceName->Des();
-		TRACE( T_LIT("CVIMPSTEnginePresenceSubService::FetchPresenceFormCache() - %S"),
+		TRACE( "CVIMPSTEnginePresenceSubService::FetchPresenceFormCache() - %S", &serviceNamePtr );
-		        &serviceNamePtr );
 		// passed the service to register for notification
 		error = iPresenceCacheReader->AllBuddiesPresenceInService(*iServiceName, this );
 		}
-	TRACE( T_LIT("CVIMPSTEnginePresenceSubService::FetchPresenceFormCache() end") );
 	return error;
 }
 // ---------------------------------------------------------------------------
 // CVIMPSTEnginePresenceSubService::HandlePresenceReadL
 // ---------------------------------------------------------------------------
 //
 void CVIMPSTEnginePresenceSubService::HandlePresenceReadL(TInt /*aErrorCode*/,
 RPointerArray<MPresenceBuddyInfo2>& aPresenceBuddyInfoList)
 {
-TRACE( T_LIT("CVIMPSTEnginePresenceSubService::HandlePresenceReadL start"));
+	TRACER_AUTO;
 // we have the ownership of  aPresenceBuddyInfoList : Push it to customize cleanupstack
 // aPresenceBuddyInfoList is collection of owned object and each object need to be deleted
 CustomCleanupResetAndDestroyPushL(aPresenceBuddyInfoList);
 MVIMPSTStorageServiceView* storage =
 				CVIMPSTStorageManagerFactory::ContactListInterfaceL(iServiceId);
 TInt buddyCount = aPresenceBuddyInfoList.Count();
-TRACE( T_LIT("CVIMPSTEnginePresenceSubService::HandlePresenceReadL - count: %d" ), buddyCount );
+TRACE( "count: %d" , buddyCount );
 for ( TInt i =0 ; i < buddyCount ; ++i)
 		{
-		TRACE( T_LIT("CVIMPSTEnginePresenceSubService::HandlePresenceReadL - buddy index: %d" ), i );
+TRACE( " buddy index: %d" , i );
 		MPresenceBuddyInfo2* buddyinfo = aPresenceBuddyInfoList[i];
 		// read the buddyID : returns in XSP format
 		TPtrC buddyXSPId = buddyinfo->BuddyId();
-		TRACE( T_LIT("CVIMPSTEnginePresenceSubService::HandlePresenceReadL - Status Message: %s" ), &buddyXSPId );
+		TRACE( "Status Message: %s" , &buddyXSPId );
 		TPtrC buddyId = buddyXSPId.Right( buddyXSPId.Length() - iServiceName->Length() - KColon().Length());
 		// read the availability /presence state enum value
 		MPresenceBuddyInfo2::TAvailabilityValues availabilityEnum = buddyinfo->Availability();
-		TRACE( T_LIT("CVIMPSTEnginePresenceSubService::HandlePresenceReadL - Availability ENUM value: %d" ), availabilityEnum );
+		TRACE( "Availability ENUM value: %d" , availabilityEnum );
 		TPtrC avablityText = buddyinfo->AvailabilityText();
 		// convert the presence cache enum value to service tab enum
 		TVIMPSTEnums::TOnlineStatus status = ConvertPresenceCacheEnums( availabilityEnum , avablityText);
 		//  get the GetAnyFiled(which has only pending and blocked states.)
 		if(TVIMPSTEnums::EUnKnown == status)
 			{
 			GetKeyFieldsAndValuesL(*buddyinfo,status);
 			}
 		// read the  status message
 		TPtrC statusMsg = buddyinfo->StatusMessage();
-		TRACE( T_LIT("CVIMPSTEnginePresenceSubService::HandlePresenceReadL - Status Message: %s" ), &statusMsg );
+		TRACE("Status Message: %s" , &statusMsg );
 		TPtrC8 avatarContent = buddyinfo->Avatar();
 		HBufC8* avatarScaledData = NULL;
 		if ( avatarContent.Length() )
 			{
-			TRACE( T_LIT("CVIMPSTEnginePresenceSubService::HandlePresenceReadL - avatarContent Content available" ) );
+			TRACE( "avatarContent Content available"  );
 			CVIMPSTEngineImageHandler* imageHandler = CVIMPSTEngineImageHandler::NewL();
 			CleanupStack::PushL(imageHandler);
-			TRACE( T_LIT("CVIMPSTEnginePresenceSubService::HandlePresenceReadL - imageHandler created " ) );
+			TRACE( "imageHandler created "  );
 		    avatarScaledData = imageHandler->ProcessImageFromDataL( avatarContent , KNullDesC8() );
-		    TRACE( T_LIT("CVIMPSTEnginePresenceSubService::HandlePresenceReadL - ProcessImageFromDataL returned " ) );
+		    TRACE( "ProcessImageFromDataL returned " );
 			CleanupStack::PopAndDestroy();//imageHandler
 			}
 		if( avatarScaledData && avatarScaledData->Length() )
 			{
 			CleanupStack::PushL(avatarScaledData);
 			}
 		}
 aPresenceBuddyInfoList.ResetAndDestroy();
 CleanupStack::PopAndDestroy();  //  aPresenceBuddyInfoList
-TRACE( T_LIT("CVIMPSTEnginePresenceSubService::HandlePresenceReadL end"));
 }
 // ---------------------------------------------------------------------------
 // CVIMPSTEnginePresenceSubService::HandlePresenceNotificationL
 // ---------------------------------------------------------------------------
 //
 void CVIMPSTEnginePresenceSubService::HandlePresenceNotificationL(TInt /*aErrorCode*/,
 MPresenceBuddyInfo2* aPresenceBuddyInfo)
 {
-TRACE( T_LIT("CVIMPSTEnginePresenceSubService::HandlePresenceNotificationL start"));
+	TRACER_AUTO;
 if ( aPresenceBuddyInfo )
 {
 CleanupDeletePushL( aPresenceBuddyInfo );
 DoHandlePresenceNotificationL(*aPresenceBuddyInfo);
 CleanupStack::PopAndDestroy(1); // aPresenceBuddyInfo
 }
-TRACE( T_LIT("CVIMPSTEnginePresenceSubService::HandlePresenceNotificationL end"));
 }
 // ---------------------------------------------------------
 // CVIMPSTEnginePresenceSubService::SubscribeForAuthorizationL
 //
 // ---------------------------------------------------------
 void  CVIMPSTEnginePresenceSubService::SubscribeForAuthorizationL()
 {
+	TRACER_AUTO;
 TXIMPRequestId req;
 MPresenceAuthorization& authorization = iXimpEventObserver.XimpAuthorizationL();
 req = authorization.SubscribePresenceGrantRequestListL();
 // mapper is not own
 CVIMPSTEngineRequestMapper* mapper = iXimpEventObserver.GetRequestMapper();
 // CVIMPSTEnginePresenceSubService::SendPresenceGrantPresentityResponseL
 //
 // ---------------------------------------------------------
 TInt CVIMPSTEnginePresenceSubService::SendPresenceGrantPresentityL( const TDesC& aContactId , TBool aResponse )
 {
-TRACE( T_LIT("CVIMPSTEnginePresenceSubService::SendPresenceGrantPresentityL stat"));
+	TRACER_AUTO;
 __ASSERT_ALWAYS( aContactId.Length(), User::Leave( KErrArgument ) );
 // return the response to the server.
 MPresenceAuthorization& authorization = iXimpEventObserver.XimpAuthorizationL();
 // mapper is not own
 if( ( ( error == KPREQUESTERRSUCCESSFUL) || ( error == KErrNone )  || iAutoAccept)  )
 {
 MVIMPSTStorageServiceView* storage = CVIMPSTStorageManagerFactory::ContactListInterfaceL(iServiceId) ;
 if(storage && ( !storage->IsLocalStore() || iAutoAccept  ) && aResponse )
 {
-TRACE( T_LIT("CVIMPSTEnginePresenceSubService::SendPresenceGrantPresentityL server store") );
+TRACE( " server store" );
 storage->CreateNewContactL( aContactId,KNullDesC, ETrue, iAutoAccept ); // ETrue is for invitation item
 }
 }
 CleanupStack::PopAndDestroy(); //contactIdentity
-TRACE( T_LIT("CVIMPSTEnginePresenceSubService::SendPresenceGrantPresentityL end"));
 return error;
 }
 // ---------------------------------------------------------
 // CVIMPSTEnginePresenceSubService::HandleSessionContextEventL
 // ---------------------------------------------------------
 void CVIMPSTEnginePresenceSubService::HandleSessionContextEventL(const MXIMPContext& aContext,
 const MXIMPBase& aEvent,
 TXimpOperation aXimpOperation /*= EVIMPSTXimpOperationNoOperation*/ )
 {
-TRACE( T_LIT("CVIMPSTEnginePresenceSubService::HandleSessionContextEventL start"));
+	TRACER_AUTO;
 TInt32 eventId = aEvent.GetInterfaceId();
 switch( aEvent.GetInterfaceId() )
 {
 case MXIMPRequestCompleteEvent::KInterfaceId:
 {
-TRACE( T_LIT("InsideCallbackswitch::MXIMPRequestCompleteEvent"));
+TRACE( "MXIMPRequestCompleteEvent");
 //temp fix TBD
 //Only use the operations that u r intertest in
 if ( aXimpOperation <= EVIMPSTXimpOperationUnsubscribe )
 {
 TRAP_IGNORE( HandleXimpRequestCompleteL(
 aXimpOperation,
 event->CompletionResult().ResultCode(),
 aEvent ) );
 }
-TRACE( T_LIT("InsideCallback::HandlePresenceContextEvent"));
+TRACE( "HandlePresenceContextEvent");
 break;
 }
 case MXIMPContextStateEvent::KInterfaceId:
 {
-TRACE( T_LIT("InsideCallbackswitch::MXIMPContextStateEvent"));
+TRACE( "InsideCallbackswitch::MXIMPContextStateEvent");
-TRACE( T_LIT("InsideCallback::MXIMPContextStateEvent"));
+TRACE("InsideCallback::MXIMPContextStateEvent");
 break;
 }
 case MPresentityGroupContentEvent::KInterfaceId:
 {
-TRACE( T_LIT("CVIMPSTEnginePresenceSubService::MPresentityGroupContentEvent"));
+TRACE( "MPresentityGroupContentEvent");
 DoHandlePresentityGroupContentEventL( aContext, aEvent );
-TRACE( T_LIT("CVIMPSTEnginePresenceSubService::MPresentityGroupContentEvent"));
+TRACE( "MPresentityGroupContentEvent");
 break;
 }
 case MPresenceGrantRequestListEvent::KInterfaceId:
 {
-TRACE( T_LIT("CVIMPSTEnginePresenceSubService::MPresenceGrantRequestListEvent"));
+TRACE( "MPresenceGrantRequestListEvent");
 DoHandlePresenceGrantRequestListEventL( aContext, aEvent );
-TRACE( T_LIT("CVIMPSTEnginePresenceSubService::MPresenceGrantRequestListEvent"));
+TRACE( "MPresenceGrantRequestListEvent");
 break;
 }
 case MPresenceBlockListEvent::KInterfaceId:
 {
-TRACE( T_LIT("CVIMPSTEnginePresenceSubService::MPresenceBlockListEvent"));
+TRACE( "MPresenceBlockListEvent");
 DoHandlePresenceBlockListEventL( aContext, aEvent );
-TRACE( T_LIT("CVIMPSTEnginePresenceSubService::MPresenceBlockListEvent"));
+TRACE( "MPresenceBlockListEvent");
 break;
 }
 default:
 {
 break;
 }
 }
-TRACE( T_LIT("CVIMPSTEnginePresenceSubService::HandleSessionContextEventL end"));
 }
 // ---------------------------------------------------------------------------
 // CVIMPSTEnginePresenceSubService::HandleListEventCompleteL
 // ---------------------------------------------------------------------------
 //
 void CVIMPSTEnginePresenceSubService::HandleListEventCompleteL(TXimpOperation aType,
 TInt aCompleteCode,
 const MXIMPBase& /*aEvent*/)
 {
-TRACE( T_LIT("CVIMPSTEnginePresenceSubService::HandleListEventCompleteL start"));
+	TRACER_AUTO;
 switch ( aType )
 {
 case EVIMPSTXimpOperationBind:
 {
 break;
 }
 default:
 break;
 }
-TRACE( T_LIT("CVIMPSTEnginePresenceSubService::HandleListEventCompleteL end"));
 }
 // ---------------------------------------------------------------------------
 // CVIMPSTEnginePresenceSubService::HandleXimpRequestCompleteL
 // ---------------------------------------------------------------------------
 //
 void CVIMPSTEnginePresenceSubService::HandleXimpRequestCompleteL(TXimpOperation aType,
 TInt aCompleteCode,const MXIMPBase& aEvent )
 {
-TRACE( T_LIT("CVIMPSTEnginePresenceSubService::HandleXimpRequestCompleteL start"));
+	TRACER_AUTO;
 switch ( aType )
 {
 case EVIMPSTXimpOperationBind:
 case EVIMPSTXimpOperationGetSubscribedList:
 case EVIMPSTXimpOperationGetBlockList:
 break;
 }
 }
-TRACE( T_LIT("CVIMPSTEnginePresenceSubService::HandleXimpRequestCompleteL end"));
 }
 // -----------------------------------------------------------------------------
 // CVIMPSTEnginePresenceSubService::StoreToVirtualStoreL
 // -----------------------------------------------------------------------------
 //
 void CVIMPSTEnginePresenceSubService::StoreToVirtualStoreL(
 const MPresentityGroupContentEvent& aListEvent )
 {
-TRACE( T_LIT("CVIMPSTEnginePresenceSubService::StoreToVirtualStoreL start"));
+	TRACER_AUTO;
-TRACE( T_LIT("CurrentMembersCount count = %d"),aListEvent.CurrentMembersCount() );
+	TRACE( " count = %d",aListEvent.CurrentMembersCount() );
-TRACE( T_LIT("NewMembersCount count = %d"),aListEvent.NewMembersCount() );
+TRACE("NewMembersCount count = %d",aListEvent.NewMembersCount() );
-TRACE( T_LIT("UpdatedMembersCount count = %d"),aListEvent.UpdatedMembersCount() );
+TRACE( "UpdatedMembersCount count = %d",aListEvent.UpdatedMembersCount() );
 MVIMPSTStorageServiceView* storage =
 CVIMPSTStorageManagerFactory::ContactListInterfaceL(iServiceId) ;
 TLinearOrder< TPtrC > linearOrder (*CompareAlphabetically );
 if (storage)
 {
 firstNameList.Reset();
 serviceField.Reset();
 // number of contact in this list
 TInt currentMembrcount = aListEvent.CurrentMembersCount();
-TRACE( T_LIT("currentMembrcount count = %d"),currentMembrcount );
+TRACE( "currentMembrcount count = %d",currentMembrcount );
 // Handle first current items
 for(TInt j = 0; j < currentMembrcount ;j++ )
 {
 const MPresentityGroupMemberInfo& memberInfo =
 aListEvent.CurrentMember( j ) ;
 firstNameList.AppendL(displayeName );
 }
 // number of contact in this list
 TInt newMembrcount = aListEvent.NewMembersCount() ;
-TRACE( T_LIT("newMembrcount count = %d"),newMembrcount );
+TRACE("newMembrcount count = %d",newMembrcount );
 for(TInt i = 0; i < newMembrcount ;i++ )
 {
 const MPresentityGroupMemberInfo& memberInfo =
 aListEvent.NewMember( i ) ;
 const MXIMPIdentity& memberIdentity = memberInfo.GroupMemberId() ;
 if(KErrAlreadyExists != error)
 {
 firstNameList.Append(displayeName);
 }
 }
-TRACE( T_LIT(" calling CreateNewFetchContactsL") );
+TRACE( " calling CreateNewFetchContactsL" );
-TRACE( T_LIT(" serviceField count %d"),serviceField.Count());
+TRACE( " serviceField count %d",serviceField.Count());
-TRACE( T_LIT(" firstNameList count %d"),firstNameList.Count());
+TRACE( " firstNameList count %d",firstNameList.Count());
 // If count in both arrays does not match, storage side can panic
 __ASSERT_ALWAYS( firstNameList.Count() == serviceField.Count(), User::Leave( KErrCorrupt));
 storage->CreateNewFetchContactsL(firstNameList, serviceField);
 iIsFetchingContact = EFalse;
 		        const MPresentityGroupMemberInfo& memberInfo =
 		                                        aListEvent.NewMember( i ) ;
 		        const MXIMPIdentity& memberIdentity = memberInfo.GroupMemberId() ;
 		        TPtrC userId = memberIdentity.Identity();
 		        TPtrC displayeName = memberInfo.GroupMemberDisplayName();
-		        TRACE( T_LIT("CVIMPSTEnginePresenceSubService: newMember %S"), &userId );
+		        TRACE( " newMember %S", &userId );
 		        storage->CreateNewContactL(userId,displayeName,ETrue,ETrue);
 		        }
 		   TInt removedMembrcount = aListEvent.DisappearedMembersCount() ;
 		   for(TInt i = 0; i < removedMembrcount ;i++ )
 		        {
 		        const MPresentityGroupMemberInfo& memberInfo =
 		                                        aListEvent.DisappearedMember( i ) ;
 		        const MXIMPIdentity& memberIdentity = memberInfo.GroupMemberId() ;
 		        TPtrC userId = memberIdentity.Identity();
-				TRACE( T_LIT("CVIMPSTEnginePresenceSubService: deleteMember %S"), &userId );
+		        TRACE( "deleteMember %S", &userId );
 		    	MVIMPSTStorageContact* contactExist = storage->FindContactByUserId(userId);
 		    	if(contactExist)
 		    	    {
 		    	    storage->RemoveContactL(contactExist);
 		    	    }
 		        }
 			}
 }
-TRACE( T_LIT("CVIMPSTEnginePresenceSubService::StoreToVirtualStoreL end"));
 }
 // ---------------------------------------------------------
 // CVIMPSTEnginePresenceSubService::IsChangeOwnStatusSupported
 //
 // CVIMPSTEnginePresenceSubService::ConvertXimpToClientPresenceStatus
 // ---------------------------------------------------------------------------
 //
 TVIMPSTEnums::TOnlineStatus CVIMPSTEnginePresenceSubService::ConvertPresenceCacheEnums(MPresenceBuddyInfo2::TAvailabilityValues aAvailabilityEnum,TPtrC aAvabilityText)
 {
+	TRACER_AUTO;
 // convert the presence cache enums to UI enumvalues
 // by default if the enum doesnot match then its  TVIMPSTEnums::UnKnown
 TVIMPSTEnums::TOnlineStatus status;
 switch( aAvailabilityEnum )
 {
 // ---------------------------------------------------------
 //TODO::Should be named as RegisterPresenceEventObserverL
 void CVIMPSTEnginePresenceSubService::RegisterPresenceEventObserverL(
 MVIMPSTEnginePresenceSubServiceEventObserver* aObserver)
 {
-TRACE( T_LIT("CVIMPSTEnginePresenceSubService::RegisterPresenceEventObserver start"));
+	TRACER_AUTO;
 __ASSERT_ALWAYS( aObserver, User::Leave( KErrArgument ));
 iSubServiceObserver = aObserver;
-TRACE( T_LIT("CVIMPSTEnginePresenceSubService::RegisterPresenceEventObserver end"));
 }
 // ---------------------------------------------------------
 // CVIMPSTEnginePresenceSubService::UnRegisterPresenceEventObserver
 //
 // ---------------------------------------------------------
 void CVIMPSTEnginePresenceSubService::UnRegisterPresenceEventObserver(
 MVIMPSTEnginePresenceSubServiceEventObserver* /*aObserver*/)
 {
-TRACE( T_LIT("CVIMPSTEnginePresenceSubService::UnRegisterPresenceEventObserver start"));
+	TRACER_AUTO;
 iSubServiceObserver = NULL;
-TRACE( T_LIT("CVIMPSTEnginePresenceSubService::UnRegisterPresenceEventObserver end"));
 }
 // ---------------------------------------------------------------------------
 // CVIMPSTEnginePresenceSubService::RetrieveBlockListL
 // ---------------------------------------------------------------------------
 //
 void CVIMPSTEnginePresenceSubService::RetrieveBlockListL()
 {
-TRACE( T_LIT("CVIMPSTEnginePresenceSubService::RetrieveBlockListL start"));
+	TRACER_AUTO;
 //Subscribe block list
 // do get block list"));
 TXIMPRequestId operationId = TXIMPRequestId::Null();
 operationId = iXimpEventObserver.XimpAuthorizationL().SubscribePresenceBlockListL();
 CVIMPSTEngineRequestMapper* requestMapper =iXimpEventObserver.GetRequestMapper();
 requestMapper->CreateRequestL(operationId,EFalse,EVIMPSTXimpOperationGetBlockList);
 // list retrieving ok. Waiting for list.;
-TRACE( T_LIT("CVIMPSTEnginePresenceSubService::RetrieveBlockListL end"));
 }
 // ---------------------------------------------------------------------------
 // CVIMPSTEnginePresenceSubService::DoHandlePresenceNotificationL
 // ---------------------------------------------------------------------------
 //
 void CVIMPSTEnginePresenceSubService::DoHandlePresenceNotificationL(MPresenceBuddyInfo2& aPresenceBuddyInfo)
 {
-TRACE( T_LIT("CVIMPSTEnginePresenceSubService::DoHandlePresenceNotificationL start" ) );
+	TRACER_AUTO;
 MVIMPSTStorageServiceView* storage =
 						CVIMPSTStorageManagerFactory::ContactListInterfaceL(iServiceId);
 TPtrC ownUserId = storage->OwnContactL().UserId();
 // read the buddyID : returns in XSP format
 TPtrC buddyXSPId = aPresenceBuddyInfo.BuddyId();
 TPtrC buddyId = buddyXSPId.Right( buddyXSPId.Length() - iServiceName->Length() - KColon().Length());
-TRACE( T_LIT("CVIMPSTEnginePresenceSubService::DoHandlePresenceNotificationL buddyId : %s" ), &buddyId );
+TRACE( " buddyId : %s" , &buddyId );
 // read the availability /presence state enum value
 MPresenceBuddyInfo2::TAvailabilityValues availabilityEnum = aPresenceBuddyInfo.Availability();
-TRACE( T_LIT("CVIMPSTEnginePresenceSubService::DoHandlePresenceNotificationL - Availability ENUM value: %d" ), availabilityEnum );
+TRACE( "Availability ENUM value: %d" , availabilityEnum );
 TPtrC avablityText = aPresenceBuddyInfo.AvailabilityText();
 // convert the presence cache enum value to service tab enum
 TVIMPSTEnums::TOnlineStatus status = ConvertPresenceCacheEnums( availabilityEnum, avablityText);
 //TRACE( T_LIT("CVIMPSTEnginePresenceSubService::DoHandlePresenceNotificationL - status: %d" ), status );
 //check if its pending or blocked contact.
 if(TVIMPSTEnums::EUnKnown == status)
 {
 GetKeyFieldsAndValuesL(aPresenceBuddyInfo,status);
 //TRACE( T_LIT("DoHandlePresenceNotificationL after GetKeyFieldsAndValuesL- status: %d" ), status );
 }
-TRACE( T_LIT("DoHandlePresenceNotificationL - status: %d" ), status );
+TRACE( " status: %d" , status );
 // Read  the  status message
 TPtrC statusMsg = aPresenceBuddyInfo.StatusMessage();
-TRACE( T_LIT("CVIMPSTEnginePresenceSubService::DoHandlePresenceNotificationL - Status Message: %s" ), &statusMsg );
+TRACE("Status Message: %s" , &statusMsg );
 TPtrC8 avatarContent = aPresenceBuddyInfo.Avatar();
 ////////////////////////////////////////////////////////////////
 HBufC8* avatarScaledData = NULL;
 	if ( avatarContent.Length() )
 		{
-		TRACE( T_LIT("CVIMPSTEnginePresenceSubService::DoHandlePresenceNotificationL - avatarContent Content available" ) );
+	TRACE( "avatarContent Content available" );
 		CVIMPSTEngineImageHandler* imageHandler = CVIMPSTEngineImageHandler::NewL();
 		CleanupStack::PushL(imageHandler);
-		TRACE( T_LIT("CVIMPSTEnginePresenceSubService::DoHandlePresenceNotificationL - imageHandler created " ) );
+		TRACE( "imageHandler created " );
 		avatarScaledData = imageHandler->ProcessImageFromDataL( avatarContent , KNullDesC8() );
-		TRACE( T_LIT("CVIMPSTEnginePresenceSubService::DoHandlePresenceNotificationL - ProcessImageFromDataL returned " ) );
+		TRACE( " ProcessImageFromDataL returned " );
 		CleanupStack::PopAndDestroy();//imageHandler
 		}
 if( avatarScaledData && avatarScaledData->Length())
 {
 CleanupStack::PushL(avatarScaledData);
 }
 else
 {
 storage->UpdatePresenceL(buddyId, status, statusMsg, KNullDesC8 );
 }
-	TRACE( T_LIT("CVIMPSTEnginePresenceSubService::DoHandlePresenceNotificationL end" ) );
 }
 // ---------------	------------------------------------------------------------
 // CVIMPSTEnginePresenceSubService::
 //      DoHandlePresentityGroupContentEventL
 // ---------------------------------------------------------------------------
 //
 void CVIMPSTEnginePresenceSubService::DoHandlePresenceBlockListEventL(
 const MXIMPContext& /*aContext*/,
 const MXIMPBase& aEvent )
 {
-TRACE( T_LIT("CVIMPSTEnginePresenceSubService::DoHandlePresenceBlockListEventL start"));
+	TRACER_AUTO;
 const MPresenceBlockListEvent& event  =
 *TXIMPGetInterface< const MPresenceBlockListEvent >::From(
 aEvent,
 MXIMPBase::EPanicIfUnknown );
 // if the feature is supported then we need to add this contact into virtual store.
 // that logic  needs to be implemented.
 // inform ui about the state change from updatingcontacts to registered.
 if(TVIMPSTEnums::ESVCEUpdatingContacts == iServiceState )
 {
-TRACE( T_LIT(" -> CVIMPSTEnginePresenceSubService:state is ESVCEUpdatingContacts" ));
+TRACE( " -> DoHandlePresentityGroupContentEventL:state is ESVCEUpdatingContacts" );
 }
-TRACE( T_LIT(" -> new member count: %d" ), event.NewBlocksCount());
+TRACE( " new member count: %d" , event.NewBlocksCount());
 TInt subscriptionCount  =  event.NewBlocksCount();
-TRACE( T_LIT(" -> subscriptionCount: %d"), subscriptionCount );
+TRACE(" subscriptionCount: %d", subscriptionCount );
-TRACE( T_LIT(" -> handling buddy list" ) );
+TRACE( "  handling buddy list"  );
 HBufC* subsbuf(NULL);
 for( TInt i =0; i < subscriptionCount; i++ )
 {
 const MPresenceBlockInfo& blockedEntitys = event.NewBlock(i);
 const MXIMPIdentity& ident = blockedEntitys.BlockedEntityId();
 subsbuf = ident.Identity().AllocLC();
 TPtr subsbufPtr = subsbuf->Des();
-TRACE( T_LIT(" -> identity: %S"), &subsbufPtr );
+TRACE( " -> identity: %S", &subsbufPtr );
-TRACE( T_LIT(" -> subscribe to cache" ) );
+TRACE(" -> subscribe to cache"  );
 SubscribePresenceOfSingleContactL(*subsbuf);
 iBlockedListMgr->AddToBlockedListL(*subsbuf);
 CleanupStack::PopAndDestroy( subsbuf );
 }
 TInt disappearedCount = event.DisappearedBlocksCount();
 {
 const MPresenceBlockInfo& blockedEntitys = event.DisappearedBlock( j );
 const MXIMPIdentity& ident = blockedEntitys.BlockedEntityId();
 subsbuf = ident.Identity().AllocLC();
 TPtr subsbufPtr = subsbuf->Des();
-TRACE( T_LIT(" -> identity: %S"), &subsbufPtr );
+TRACE( " identity: %S", &subsbufPtr );
 iBlockedListMgr->RemoveFromBlockListL( *subsbuf );
 CleanupStack::PopAndDestroy( subsbuf );
 }
 if(iBlockedListObserver)
 	        {
 	        iBlockedListObserver->HandleBlockedListFetchCompleteL();
 	        iBlockListFetchReqPending = EFalse;
 	        }
-TRACE( T_LIT("CVIMPSTEnginePresenceSubService::DoHandlePresenceBlockListEventL end"));
 }
 // ---------------------------------------------------------------------------
 // CVIMPSTEnginePresenceSubService::AddToBlockListL
 // ---------------------------------------------------------------------------
 //
 TInt CVIMPSTEnginePresenceSubService::AddToBlockListL( const TDesC& aContactId )
 {
-TRACE( T_LIT("CVIMPSTEnginePresenceSubService::AddToBlockListL start"));
+	TRACER_AUTO;
 if(TVIMPSTEnums::ESVCERegistered != iServiceState)
 return KErrNotSupported;
 //if aContactId is zero.
 if( 0 == aContactId.Length())
 return KErrArgument;
-TRACE( T_LIT(" -> aContactId: %s" ), &aContactId);
+TRACE( " aContactId: %s" , &aContactId);
-TRACE( T_LIT(" -> perform block operation" ) );
+TRACE( " perform block operation" );
 MXIMPIdentity* identity = iXimpEventObserver.XimpPresenceContextL().ObjectFactory().NewIdentityLC();
 identity->SetIdentityL( aContactId );
 		CVIMPSTStorageManagerFactory::ContactListInterfaceL(iServiceId);
 		storage->UpdateAvatarL(aContactId,KNullDesC8);
 	    }
 //when pres. cache call will come.
 CleanupStack::PopAndDestroy(); // identity
-TRACE( T_LIT("CVIMPSTEnginePresenceSubService::AddToBlockListL end"));
 return error;
 }
 // ---------------------------------------------------------------------------
 // CVIMPSTEnginePresenceSubService::RemoveFromBlockListL
 // ---------------------------------------------------------------------------
 //
 TInt CVIMPSTEnginePresenceSubService::RemoveFromBlockListL( const TDesC& aUriOfTheContact )
 {
-TRACE( T_LIT("CVIMPSTEnginePresenceSubService::RemoveFromBlockListL start"));
+	TRACER_AUTO;
 if(TVIMPSTEnums::ESVCERegistered != iServiceState)
 return KErrNotSupported;
 //if aUriOfTheCOntact is zero.
 if( 0 == aUriOfTheContact.Length())
 return KErrNotFound;
-TRACE( T_LIT(" -> aUriOfTheContact: %s" ), &aUriOfTheContact);
+TRACE(" -> aUriOfTheContact: %s" , &aUriOfTheContact);
-TRACE( T_LIT(" -> perform unblock operation" ) );
+TRACE( " -> perform unblock operation"  );
 MXIMPIdentity* identity = iXimpEventObserver.XimpPresenceContextL().ObjectFactory().NewIdentityLC();
 identity->SetIdentityL( aUriOfTheContact );
 TXIMPRequestId reqId = iXimpEventObserver.XimpAuthorizationL().CancelPresenceBlockFromPresentityL(*identity );
 	    {
 	    iBlockedListMgr->RemoveFromBlockListL(aUriOfTheContact);
 	    }
 CleanupStack::PopAndDestroy( 1 ); // identity
-TRACE( T_LIT("CVIMPSTEnginePresenceSubService::RemoveFromBlockListL end"));
 return error;
 }
 // ---------------------------------------------------------------------------
 // CVIMPSTEnginePresenceSubService::GetBlockedList
 // CVIMPSTEnginePresenceSubService::FetchBlockedListFromServer
 // ---------------------------------------------------------------------------
 //
 void CVIMPSTEnginePresenceSubService::FetchBlockedListFromServerL(MVIMPSTEngineBlockedListFetchEventObserver* aOb)
 	{
+	TRACER_AUTO;
 	if(EFalse == iBlockListFetchReqPending)
 		{
 		//set the observer to give call back; Fetch from server is completed.
 		iBlockedListObserver = aOb;
 // CVIMPSTEnginePresenceSubService::GetKeyFieldsAndValuesL
 // ---------------------------------------------------------------------------
 //
 void CVIMPSTEnginePresenceSubService::GetKeyFieldsAndValuesL(MPresenceBuddyInfo2& aPresenceBuddyInfo,TVIMPSTEnums::TOnlineStatus &aStatus)
 {
+	TRACER_AUTO;
 TPtrC8 value = aPresenceBuddyInfo.GetAnyField( KExtensionKey());
 // At any point of time fro remote and blocked contact only one of the keys
 // KPendingRequestExtensionValue/KBlockedExtensionValue will be assigned, and not both the keys.
 if(value.Compare( KPendingRequestExtensionValue ) == 0)
 {
 // CVIMPSTEnginePresenceSubService::UpdatePresenceStateL
 // ---------------------------------------------------------------------------
 //
 void CVIMPSTEnginePresenceSubService::UpdatePresenceStateL()
 {
-TRACE( T_LIT("CVIMPSTEnginePresenceSubService::UpdatePresenceStateL start") );
+	TRACER_AUTO;
 //inform ui about the state change from updatingcontacts to registered.
 iServiceState = TVIMPSTEnums::ESVCERegistered;
 iObserver.HandleServceConnectionEventL();
-TRACE( T_LIT(" -> HandleContactFetchedL:state is ESVCERegistered" ));
+TRACE( " -> HandleContactFetchedL:state is ESVCERegistered" );
-TRACE( T_LIT("CVIMPSTEnginePresenceSubService::UpdatePresenceStateL end"));
 }
 // ---------------------------------------------------------------------------
 // CVIMPSTEnginePresenceSubService::FetchPresenceOfSingleContactL
 // ---------------------------------------------------------------------------
 //
 void CVIMPSTEnginePresenceSubService::FetchPresenceOfSingleContactL(const TDesC& aContact)
 {
-TRACE( T_LIT("CVIMPSTEnginePresenceSubService::FetchPresenceOfSingleContactL Start"));
+	TRACER_AUTO;
 if(aContact.Length() && iServiceName->Length())
 {
 HBufC* name = HBufC::NewLC( iServiceName->Length() + KColon().Length() + aContact.Length()  ); // 1. on to cleanup stack
 TPtr namePtr( name->Des() );
 namePtr.Zero();
 // append the service name followed by user id ,seperated by colon
 namePtr.Append(*iServiceName);
 namePtr.Append(KColon);
 namePtr.Append(aContact);
-TRACE( T_LIT("CVIMPSTEnginePresenceSubService::FetchPresenceOfSingleContactL namePtr = %S"), &namePtr);
+TRACE( " namePtr = %S", &namePtr);
 MPresenceBuddyInfo2* presenceBuddyInfo = iPresenceCacheReader->PresenceInfoLC(namePtr); // 2. on to cleanupstack
 if ( presenceBuddyInfo )
 {
-TRACE( T_LIT("CVIMPSTEnginePresenceSubService::FetchPresenceOfSingleContactL presenceBuddyInfo"));
+TRACE("presenceBuddyInfo");
 DoHandlePresenceNotificationL(*presenceBuddyInfo);
 CleanupStack::PopAndDestroy();  // presenceBuddyInfo
-TRACE( T_LIT("CVIMPSTEnginePresenceSubService::FetchPresenceOfSingleContactL presenceBuddyInfo end"));
+TRACE("presenceBuddyInfo end");
 }
 CleanupStack::PopAndDestroy(name);  // name
 }
-TRACE( T_LIT("CVIMPSTEnginePresenceSubService::FetchPresenceOfSingleContactL End"));
 }
 // ---------------------------------------------------------------------------
 // CVIMPSTEnginePresenceSubService::UnsubscribeListsL
 // ---------------------------------------------------------------------------
 //
 void CVIMPSTEnginePresenceSubService::UnsubscribeListsL()
 {
-TRACE( T_LIT("CVIMPSTEnginePresenceSubService::UnsubscribeListsL IN"));
+TRACER_AUTO;
-TRACE( T_LIT("CVIMPSTEnginePresenceSubService::UnsubscribeListsL - unsubscribe buddy list"));
 // It is assumed here that buddy list and authorization list has been always
 // subscribed if bind has been done. Caller of this function must check
 // that session has been bound before calling this.
 TBuf<KUriMaxLength> buddyGroupBuffer( KFriendList );
 CleanupStack::PopAndDestroy(); // buddyGroupList
 // Auth list
 if(iSubscribeToAuthList)
 {
-TRACE( T_LIT("CVIMPSTEnginePresenceSubService::UnsubscribeListsL - unsubscribe auth list"));
+TRACE("unsubscribe auth list");
 iSubscribeToAuthList = EFalse;
 iXimpEventObserver.XimpAuthorizationL().UnsubscribePresenceGrantRequestListL();
 }
 // block list
-TRACE( T_LIT("CVIMPSTEnginePresenceSubService::UnsubscribeListsL - check if block is supported"));
+TRACE( "check if block is supported");
 TInt supportedFeatures = iXimpEventObserver.GetSupportedFeatures();
 if ( (EVIMPSTFeatureBlock & supportedFeatures) && (EVIMPSTFeatureUnBlock & supportedFeatures) )
 {
-TRACE( T_LIT("CVIMPSTEnginePresenceSubService::UnsubscribeListsL - unsubscribe block list"));
+TRACE( "unsubscribe block list");
 iXimpEventObserver.XimpAuthorizationL().UnsubscribePresenceBlockListL();
 }
-TRACE( T_LIT("CVIMPSTEnginePresenceSubService::UnsubscribeListsL OUT"));
 }
 // End of file

branch	RCL_3
changeset 14	9fdee5e1da30
parent 0	5e5d6b214f4f