MCL/sf/app/conversations: comparison uiservicetab/vimpstengine/src/cvimpstenginesessioncntxtobserver.cpp

equal deleted inserted replaced

-:796276a1bdcc
+:9fdee5e1da30
 #include <searchelement.h>
 #include <searchkeysevent.h>
 #include <searchkeyinfo.h>
 #include <ximpfeatureinfo.h>
-#include "vimpstdebugtrace.h"
+#include "uiservicetabtracer.h"
 //xmppsettings
 #include "xmppparams.h"
 #include "xmppservicesettingsapi.h"
 // CVIMPSTEngineSessionCntxtObserver::NewL
 // two phase construction
 // ---------------------------------------------------------
 CVIMPSTEngineSessionCntxtObserver* CVIMPSTEngineSessionCntxtObserver::NewL( TUint32 aServiceId )
 {
+	TRACER_AUTO;
 CVIMPSTEngineSessionCntxtObserver* self =
 					CVIMPSTEngineSessionCntxtObserver::NewLC( aServiceId);
 CleanupStack::Pop( self );
 return self;
 }
 // CVIMPSTEngineSessionCntxtObserver::NewLC
 // two phase construction
 // ---------------------------------------------------------
 CVIMPSTEngineSessionCntxtObserver* CVIMPSTEngineSessionCntxtObserver::NewLC(TUint32 aServiceId)
 {
+	TRACER_AUTO;
 CVIMPSTEngineSessionCntxtObserver* self = new
 					(ELeave) CVIMPSTEngineSessionCntxtObserver( aServiceId);
 CleanupStack::PushL( self );
 self->ConstructL();
 return self;
 // CVIMPSTEngineSessionCntxtObserver::ConstructL
 // two phase construction
 // ---------------------------------------------------------
 void CVIMPSTEngineSessionCntxtObserver::ConstructL()
 	{
+	TRACER_AUTO;
 	iRequestMapper = CVIMPSTEngineRequestMapper::NewL();
 	iReqResult = KErrNone;
 	iClient = MXIMPClient::NewClientL();
 //Create new sink to receive ximp context events
 	iPresenceCtx = iClient->NewPresenceContextLC();
 // CVIMPSTEngineSessionCntxtObserver::~CVIMPSTEngineSessionCntxtObserver
 // destructor
 // ---------------------------------------------------------
 CVIMPSTEngineSessionCntxtObserver::~CVIMPSTEngineSessionCntxtObserver()
 {
+	TRACER_AUTO;
 iObserverArray.Reset();
 iObserverArray.Close();
 iAcceptedEventTypes.Reset();
 iAcceptedEventTypes.Close();
 // ---------------------------------------------------------
 void CVIMPSTEngineSessionCntxtObserver::HandlePresenceContextEvent(
 const MXIMPContext& aContext,
 const MXIMPBase& aEvent )
 {
-TRACE( T_LIT("InsideCallback::HandlePresenceContextEvent start"));
+	TRACER_AUTO;
 TRAP_IGNORE(DoHandlePresenceContextEventL( aContext, aEvent ));
-	TRACE( T_LIT("InsideCallback::HandlePresenceContextEvent end"));
 }
 // ---------------------------------------------------------
 // CVIMPSTEngineSessionCntxtObserver::GetCompletedReqResult
 // CVIMPSTEngineSessionCntxtObserver::ServerBindL
 // ---------------------------------------------------------------------------
 //
 TInt CVIMPSTEngineSessionCntxtObserver::ServerBindL(TUid aProtocolUid)
 {
-TRACE( T_LIT("CVIMPSTEngineSessionCntxtObserver::ServerBindL start"));
+	TRACER_AUTO;
 TInt err = KErrNotFound;
 //Bind context to desired presence service
 if ( TVIMPSTEnums::EVIMPSTBindDone != iBindStatus )
 {
 TXIMPRequestId operationId = TXIMPRequestId::Null();
 // with KErrAlreadyExists. Client side is not ideal place to
 // handle this type of logic so to work around this problem, this
 // case is flagged here. When unbind completes, rebind is done.
 // If unbind is called between these operations, flag is set
 // ESVCEPresenceBindNotDone to avoid bind if service was disabled
-TRACE( T_LIT("CVIMPSTEngineSessionCntxtObserver::ServerBindL err: %d"), err);
+TRACE( "err: %d", err);
 iBindStatus = TVIMPSTEnums::EVIMPSTBindFailureMode;
 }
 else
 {
 //create the requestmapper for the corresponidng reuqest id.
 }
 else
 {
 err = KErrNone;
 }
-TRACE( T_LIT("CVIMPSTEngineSessionCntxtObserver::ServerBindL end"));
 return err;
 }
 // ---------------------------------------------------------------------------
 // CVIMPSTEngineVoIPPrecenseHandler::ServerUnBindL
 // ---------------------------------------------------------------------------
 //
 TInt CVIMPSTEngineSessionCntxtObserver::ServerUnBindL(
 TBool aDoUnsubscribe )
 {
-	TRACE( T_LIT("CVIMPSTEngineSessionCntxtObserver::ServerUnBind start"));
+	TRACER_AUTO;
 	TInt err = KErrNotFound;
 	if ( TVIMPSTEnums::EVIMPSTBindDone == iBindStatus )
 		{
 		if ( aDoUnsubscribe )
 			{
 			iBindStatus = TVIMPSTEnums::EVIMPSTUnBinding;
 			}
-TRACE( T_LIT("CVIMPSTEngineSessionCntxtObserver::ServerUnBind - do unbind"));
+TRACE( " do unbind");
 		TXIMPRequestId operationId = TXIMPRequestId::Null();
 		TRAP( err, operationId = iPresenceCtx->UnbindL());
 		iBindStatus = TVIMPSTEnums::EVIMPSTUnBindWaiting;
 		iRequestMapper->CreateRequestL(operationId,EFalse,EVIMPSTXimpOperationUnBind) ;
 		iBindStatus = TVIMPSTEnums::EVIMPSTBindNotDone;
 		{
 		// Disable flag here. If service is really disabled, we must not
 		// rebind when unbind completes.
 		iBindStatus = TVIMPSTEnums::EVIMPSTBindNotDone;
 		}
-	TRACE( T_LIT("CVIMPSTEngineSessionCntxtObserver::ServerUnBind end"));
 	return err;
 }
 // ---------------------------------------------------------------------------
 // CVIMPSTEngineSessionCntxtObserver::UriFromXimpOperationLC
 // ---------------------------------------------------------------------------
 //
 HBufC* CVIMPSTEngineSessionCntxtObserver::UriFromXimpOperationLC(const MXIMPBase& aEvent )
 {
-TRACE( T_LIT("CVIMPSTEngineSessionCntxtObserver::UriFromXimpOperationLC start"));
+	TRACER_AUTO;
 const MPresentityPresenceEvent& event =
 *TXIMPGetInterface< const MPresentityPresenceEvent >::From(
 aEvent, MXIMPBase::EPanicIfUnknown );
 HBufC* retValue = NULL;
 retValue = event.PresentityId().Identity().AllocLC();
 if(!retValue)
 {
 retValue = KNullDesC().AllocLC();
 }
-TRACE( T_LIT("CVIMPSTEngineSessionCntxtObserver::UriFromXimpOperationLC end"));
 return retValue;
 }
 // ---------------------------------------------------------------------------
 // CVIMPSTEngineSessionCntxtObserver::DoHandlePresenceContextEventL
 //
 void CVIMPSTEngineSessionCntxtObserver::DoHandlePresenceContextEventL(
 const MXIMPContext& aContext,
 const MXIMPBase& aEvent )
 {
-TRACE( T_LIT("CVIMPSTEngineSessionCntxtObserver::DoHandlePresenceContextEventL start"));
+	TRACER_AUTO;
 const TInt32 eventId = aEvent.GetInterfaceId();
 switch( aEvent.GetInterfaceId() )
 {
 case MXIMPRequestCompleteEvent::KInterfaceId:
 {
-TRACE( T_LIT("InsideCallbackswitch::MXIMPRequestCompleteEvent start"));
+TRACE( "InsideCallbackswitch::MXIMPRequestCompleteEvent start");
 const MXIMPRequestCompleteEvent* event =
 TXIMPGetInterface< const MXIMPRequestCompleteEvent >::From(
 aEvent, MXIMPBase::EPanicIfUnknown );
 iReqResult = event->CompletionResult().ResultCode();
 	                    iObserverArray[i]->HandleSessionContextEventL(aContext,
 	                    						aEvent,
 	                    						operation);
 	                    }
 }
-TRACE( T_LIT("InsideCallbackswitch::MXIMPRequestCompleteEvent end"));
+TRACE("InsideCallbackswitch::MXIMPRequestCompleteEvent end");
 break;
 }
 case MXIMPContextStateEvent::KInterfaceId:
 {
-TRACE( T_LIT("InsideCallbackswitch::MXIMPContextStateEvent"));
+TRACE( "InsideCallbackswitch::MXIMPContextStateEvent");
 break;
 }
 case MPresentityPresenceEvent::KInterfaceId:
 {
-TRACE( T_LIT("InsideCallbackswitch::::MPresentityPresenceEvent start"));
+TRACE( "InsideCallbackswitch::::MPresentityPresenceEvent start");
 TInt count = iObserverArray.Count();
 for(TInt i = 0; i < count; i++)
 {
 iObserverArray[i]->HandleSessionContextEventL(aContext,aEvent);
 }
-TRACE( T_LIT("InsideCallbackswitch::::MPresentityPresenceEvent end"));
+TRACE( "InsideCallbackswitch::::MPresentityPresenceEvent end");
 break;
 }
 case MPresentityGroupContentEvent::KInterfaceId:
 {
-TRACE( T_LIT("InsideCallbackswitch::::MPresentityGroupContentEvent start"));
+TRACE( "InsideCallbackswitch::::MPresentityGroupContentEvent start");
 TInt count = iObserverArray.Count();
 for(TInt i = 0; i < count; i++)
 {
 iObserverArray[i]->HandleSessionContextEventL(aContext,aEvent);
 }
-TRACE( T_LIT("InsideCallbackswitch::::MPresentityGroupContentEvent end"));
+TRACE( "InsideCallbackswitch::::MPresentityGroupContentEvent end");
 break;
 }
 case MPresenceGrantRequestListEvent::KInterfaceId:
 {
-TRACE( T_LIT("InsideCallbackswitch::::MPresentityGroupContentEvent start"));
+TRACE("InsideCallbackswitch::::MPresenceGrantRequestListEvent start");
 TInt count = iObserverArray.Count();
 for(TInt i = 0; i < count; i++)
 {
 iObserverArray[i]->HandleSessionContextEventL(aContext,aEvent);
 }
-TRACE( T_LIT("InsideCallbackswitch::::MPresentityGroupContentEvent end"));
+TRACE( "InsideCallbackswitch::::MPresenceGrantRequestListEvent end");
 break;
 }
 case MSearchEvent::KInterfaceId:
 {
-TRACE( T_LIT("InsideCallbackswitch::::MSearchEvent start"));
+TRACE( "InsideCallbackswitch::::MSearchEvent start");
 TInt count = iObserverArray.Count();
 for(TInt i = 0; i < count; i++)
 {
 iObserverArray[i]->HandleSessionContextEventL(aContext,aEvent);
 }
-TRACE( T_LIT("InsideCallbackswitch::::MSearchEvent end"));
+TRACE( "InsideCallbackswitch::::MSearchEvent end");
 break;
 }
 case MSearchKeysEvent::KInterfaceId:
 {
-TRACE( T_LIT("InsideCallbackswitch::::MSearchKeysEvent start"));
+TRACE( "InsideCallbackswitch::::MSearchKeysEvent start");
 TInt count = iObserverArray.Count();
 for(TInt i = 0; i < count; i++)
 {
 iObserverArray[i]->HandleSessionContextEventL(aContext,aEvent);
 }
-TRACE( T_LIT("InsideCallbackswitch::::MSearchKeysEvent end"));
+TRACE( "InsideCallbackswitch::::MSearchKeysEvent end");
 break;
 }
 case MPresenceBlockListEvent::KInterfaceId:
 {
-TRACE( T_LIT("InsideCallbackswitch::::MPresenceBlockListEvent start"));
+TRACE( "InsideCallbackswitch::::MPresenceBlockListEvent start");
 TInt count = iObserverArray.Count();
 for(TInt i = 0; i < count; i++)
 {
 iObserverArray[i]->HandleSessionContextEventL(aContext,aEvent);
 }
-TRACE( T_LIT("InsideCallbackswitch::::MPresenceBlockListEvent end"));
+TRACE( "InsideCallbackswitch::::MPresenceBlockListEvent end");
 break;
 }
 default:
 {
 break;
 }
 }
-TRACE( T_LIT("CVIMPSTEngineSessionCntxtObserver::DoHandlePresenceContextEventL end"));
 }
 // ---------------------------------------------------------------------------
 // CVIMPSTEngineSessionCntxtObserver::XimpAuthorizationL
 // ---------------------------------------------------------------------------
 //
 MPresenceAuthorization&
 CVIMPSTEngineSessionCntxtObserver::XimpAuthorizationL()
 {
+	TRACER_AUTO;
 __ASSERT_ALWAYS( iFeatures, User::Leave( KErrNotSupported ));
 __ASSERT_ALWAYS( &iFeatures->PresenceAuthorization(),
 User::Leave( KErrNotSupported ));
 return iFeatures->PresenceAuthorization();
 }
 // CVIMPSTEngineSessionCntxtObserver::RegisterObserver
 // ---------------------------------------------------------------------------
 //
 void CVIMPSTEngineSessionCntxtObserver::RegisterObserver(MVIMPSTEngineSessionCntxtObserver* aObserver)
 {
+	TRACER_AUTO;
 if (aObserver)
 	    {
 	    TInt index = iObserverArray.Find(aObserver);
 if( index == KErrNotFound )
 // CVIMPSTEngineSessionCntxtObserver::UnRegisterObserver
 // ---------------------------------------------------------------------------
 //
 void CVIMPSTEngineSessionCntxtObserver::UnRegisterObserver(MVIMPSTEngineSessionCntxtObserver* aObserver)
 {
+	TRACER_AUTO;
 if (aObserver)
 	    {
 	    TInt index = iObserverArray.Find(aObserver);
 	    if( index >=0 )
 // CVIMPSTEngineSessionCntxtObserver::IdentifySupportedFeaturesL
 // ---------------------------------------------------------------------------
 //
 void CVIMPSTEngineSessionCntxtObserver::IdentifySupportedFeaturesL()
 {
-TRACE( T_LIT("CVIMPSTEngineSessionCntxtObserver::IdentifySupportedFeaturesL start"));
+	TRACER_AUTO;
 using namespace NXIMPFeature::Presence;
 using namespace NXIMPFeature::InstantMessage;
 using namespace NXIMPFeature::Search;
 using namespace NXIMPFeature::PresentityGroups;
 			    }
 		    }
 	delete ximpCtxFeats;
 }
-TRACE( T_LIT("CVIMPSTEngineSessionCntxtObserver::IdentifySupportedFeaturesL end"));
 }
 // ---------------------------------------------------------------------------
 // CVIMPSTEngineSessionCntxtObserver::GetSupportedFeatures

branch	RCL_3
changeset 9	9fdee5e1da30
parent 0	5e5d6b214f4f