uiservicetab/vimpstengine/src/cvimpstenginepresencesubservice.cpp
branchRCL_3
changeset 29 9a48e301e94b
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/uiservicetab/vimpstengine/src/cvimpstenginepresencesubservice.cpp	Wed Sep 01 12:33:36 2010 +0100
@@ -0,0 +1,1692 @@
+/*
+* Copyright (c) 2007 Nokia Corporation and/or its subsidiary(-ies).
+* All rights reserved.
+* This component and the accompanying materials are made available
+* under the terms of "Eclipse Public License v1.0"
+* which accompanies this distribution, and is available
+* at the URL "http://www.eclipse.org/legal/epl-v10.html".
+*
+* Initial Contributors:
+* Nokia Corporation - initial contribution.
+*
+* Contributors:
+*
+* Description:  Handles the use of Precense Framework
+ *
+*/
+
+
+// INCLUDE FILES
+/*#include <ximpclient.h>*/
+#include <ximpcontext.h>
+#include <ximpobjectfactory.h>
+#include <presenceobjectfactory.h>
+#include <ximpidentity.h> //for MXIMPIdentity
+#include <presentitygroups.h>
+#include <presencewatching.h> //for MximpPresenceWatching
+#include <ximpstatus.h> //Presence info test
+#include <presentitygroupcontentevent.h>
+#include <presentitygroupmemberinfo.h>
+#include <presenceauthorization.h>
+#include <presentitypresenceevent.h>
+#include <presencegrantrequestlistevent.h> // Grant request list
+#include <presencegrantrequestinfo.h>
+#include <ximpcontextstateevent.h>
+#include <ximprequestcompleteevent.h>
+#include <presenceblocklistevent.h>
+#include <presenceblockinfo.h>
+
+
+#include <presencefeatures.h>
+#include <presenceinfofilter.h> //info filtter
+#include <presenceinfofield.h> //MximpPresenceInfoField
+#include <presenceinfofieldcollection.h> //MximpPresenceInfoFieldCollection
+#include <presenceinfofieldvaluetext.h> //MximpPresenceInfoFieldValueText
+#include <presenceinfofieldvalueenum.h>
+#include <personpresenceinfo.h> // MximpPersonPresenceInfo
+#include <presencepublishing.h>//MximpPresencePublishing
+#include <ximperrors.hrh> //ximp errors
+#include <presenceinfofieldvaluebinary.h>
+//presence cache headers 
+#include <presencecachereader2.h> // cache reader
+
+
+#include "cvimpstenginepresencesubservice.h"
+#include "cvimpststoragemanagerfactory.h"
+#include "mvimpststoragecontact.h"
+#include "mvimpststoragecontactlist.h"
+#include "cvimpstenginerequestmapper.h"
+#include "cvimpstenginecchhandler.h"
+#include "mvimpststorageserviceview.h"
+#include "tvimpstconsts.h"
+#include "cvimpstengineservicetablefetcher.h"
+#include "cvimpstenginecchhandler.h"
+#include "cvimpstenginesessioncntxtobserver.h"
+#include "vimpstutilsnotemapper.h"
+#include "vimpstallerrors.h"
+#include "cvimpstenginerequest.h"
+#include "cvimpstblockedlistmanager.h"
+#include "mvimpstengineblockedlistfetcheventobserver.h"
+
+#include   <ximpfeatureinfo.h>
+#include <avabilitytext.h>
+
+//Presence Observer
+#include "mvimpstenginepresencesubserviceeventobserver.h"
+#include "uiservicetabtracer.h"
+#include "vimpstcustomcleanupapi.h" //For customized cleanup function
+#include "mvimpstengineserviceconnectioneventobserver.h"
+
+// CONTANTS
+const TInt KUriMaxLength = 255; 
+_LIT( KListNameAllBuddy ,"buddylist" );
+const TInt KCollationLevel = 1;
+
+// Compares alphabetically using MVIMPSTStorageContact::Identification and 
+// TDesC::CompareC
+TInt CompareAlphabetically( const TPtrC& aFirst, 
+                            const TPtrC& aSecond )
+    {
+    return aFirst.CompareC( aSecond, KCollationLevel, NULL );
+    }
+
+
+// ================= MEMBER FUNCTIONS =======================
+
+// ---------------------------------------------------------------------------
+// CVIMPSTEnginePresenceSubService::
+//      CVIMPSTEnginePresenceSubService()
+// ---------------------------------------------------------------------------
+//
+CVIMPSTEnginePresenceSubService::CVIMPSTEnginePresenceSubService( TUint32 aServiceId, 
+        CVIMPSTEngineCchHandler& aCchHandler,
+        CVIMPSTEngineServiceTableFetcher& aTableFetcher,
+        CVIMPSTEngineSessionCntxtObserver& aXimpEventObserver,
+        MVIMPSTEngineServiceConnectionEventObserver& aObserver ) 
+:iServiceId( aServiceId ),
+iCchHandler(aCchHandler),
+iSettingsTableFetcher(aTableFetcher),
+iXimpEventObserver(aXimpEventObserver),
+    iObserver(aObserver),
+    iChangeStatusSupported ( ETrue ),
+    iChangeStatusMsgSupported( ETrue ),
+    iAvatarSupported( EFalse ),
+    iIsClearingAvatar(EFalse)
+        {
+	TRACER_AUTO;
+        }
+
+// ---------------------------------------------------------------------------
+// CVIMPSTEnginePresenceSubService::ConstructL()
+// ---------------------------------------------------------------------------
+//
+void CVIMPSTEnginePresenceSubService::ConstructL()
+    {
+	TRACER_AUTO;
+
+    iCchHandler.RegisterCchObserverL(this,ECCHPresenceSub);
+
+    TCCHSubserviceState serviceState = ECCHUninitialized;    
+    TInt error = iCchHandler.GetServiceState( 
+            iServiceId, ECCHPresenceSub, serviceState );
+
+    iServiceState = ResolveServiceStateL(serviceState, error);   
+    //initialize the presence cache.
+    iPresenceCacheReader = MPresenceCacheReader2::CreateReaderL();                                                        
+
+    iPresenceCacheReader->SetObserverForSubscribedNotifications(this);
+    iServiceName = HBufC::NewL( KVIMPSTUISPSMaxPropertyLength );
+    TPtr serviceNamePtr( iServiceName->Des() );    
+    iSettingsTableFetcher.GetServiceNameL(iServiceId, serviceNamePtr);      
+    iBlockedListMgr = CVIMPSTBlockedListManager::NewL();
+    iBlockListFetchReqPending = EFalse; //req of fetching blocked list has been completed.
+    
+	iLogoutRequest = EFalse;
+	iSubscribeToAuthList = EFalse;
+	iAutoAccept = EFalse;
+
+    }
+
+// ---------------------------------------------------------------------------
+// CVIMPSTEnginePresenceSubService::NewL()
+// ---------------------------------------------------------------------------
+//
+CVIMPSTEnginePresenceSubService* 
+CVIMPSTEnginePresenceSubService::NewL( TUint32 aServiceId, 
+        CVIMPSTEngineCchHandler& aCchHandler,
+        CVIMPSTEngineServiceTableFetcher& aTableFetcher,
+        CVIMPSTEngineSessionCntxtObserver& aXimpEventObserver,
+        MVIMPSTEngineServiceConnectionEventObserver& aObserver )
+    {
+	TRACER_AUTO;
+    CVIMPSTEnginePresenceSubService* self = NewLC( aServiceId,aCchHandler, aTableFetcher, 
+            aXimpEventObserver,aObserver );
+    CleanupStack::Pop(self);
+    return self;
+    }
+
+// ---------------------------------------------------------------------------
+// CVIMPSTEnginePresenceSubService::NewLC()
+// ---------------------------------------------------------------------------
+//
+CVIMPSTEnginePresenceSubService* 
+CVIMPSTEnginePresenceSubService::NewLC( TUint32 aServiceId, 
+        CVIMPSTEngineCchHandler& aCchHandler,
+        CVIMPSTEngineServiceTableFetcher& aTableFetcher,
+        CVIMPSTEngineSessionCntxtObserver& aXimpEventObserver,
+        MVIMPSTEngineServiceConnectionEventObserver& aObserver )
+    {
+	TRACER_AUTO;
+    CVIMPSTEnginePresenceSubService* self =
+    new (ELeave) CVIMPSTEnginePresenceSubService( aServiceId,aCchHandler, aTableFetcher,  aXimpEventObserver,aObserver);
+    CleanupStack::PushL(self);
+    self->ConstructL();
+    return self;
+    }
+
+// ---------------------------------------------------------------------------
+// CVIMPSTEnginePresenceSubService::
+//      ~CVIMPSTEnginePresenceSubService()
+// ---------------------------------------------------------------------------
+//
+CVIMPSTEnginePresenceSubService::~CVIMPSTEnginePresenceSubService()
+    {
+	TRACER_AUTO;
+	
+	iCchHandler.UnRegisterCchObserver(ECCHPresenceSub);
+    
+    delete iServiceName;
+    delete iPresenceCacheReader ; 
+    
+    delete iBlockedListMgr;
+    iBlockedListMgr = NULL;
+       
+    }
+
+// ---------------------------------------------------------------------------
+// CVIMPSTEnginePresenceSubService::
+//      ServiceState()
+// ---------------------------------------------------------------------------
+//
+
+TVIMPSTEnums::TVIMPSTRegistrationState CVIMPSTEnginePresenceSubService::SubServiceState() const
+	{
+	TRACER_AUTO;
+	return iServiceState;
+	}
+
+// ---------------------------------------------------------------------------
+// CVIMPSTEnginePresenceSubService::
+//      Type()
+// ---------------------------------------------------------------------------
+//
+TVIMPSTEnums::SubServiceType CVIMPSTEnginePresenceSubService::Type() const
+	{
+	TRACER_AUTO;
+	TRACE( "CVIMPSTEnginePresenceSubService: [0x%x]", this );
+	return TVIMPSTEnums::EPresence;
+	}
+
+// ---------------------------------------------------------------------------
+// CVIMPSTEnginePresenceSubService::
+//      Enabled()
+// ---------------------------------------------------------------------------
+//
+
+TBool CVIMPSTEnginePresenceSubService::Enabled()
+    {
+	TRACER_AUTO;
+    TBool ret = EFalse;
+    if( TVIMPSTEnums::ESVCERegistered == iServiceState)
+        {
+        ret = ETrue;
+        }
+    return ret;    
+    }
+
+// ---------------------------------------------------------------------------
+// CVIMPSTEnginePresenceSubService::RetrieveSubscribedListL
+// ---------------------------------------------------------------------------
+//
+void CVIMPSTEnginePresenceSubService::RetrieveSubscribedListL()
+    {
+	TRACER_AUTO;
+
+    //Create group id
+    TBuf<KUriMaxLength> buffer( KListNameAllBuddy );
+    MXIMPIdentity* groupList = iXimpEventObserver.XimpPresenceContextL().ObjectFactory().NewIdentityLC();
+     __ASSERT_ALWAYS( groupList , User::Leave( KErrNoMemory ) );		
+    groupList->SetIdentityL( buffer );
+    iIsFetchingContact = ETrue;
+    //Subscribe buddy list
+    // do get subscribe list"));
+    TXIMPRequestId operationId = TXIMPRequestId::Null();
+    operationId = iXimpEventObserver.XimpPresentityGroupsL().SubscribePresentityGroupContentL( 
+            *groupList );
+    CVIMPSTEngineRequestMapper* requestMapper =iXimpEventObserver.GetRequestMapper();
+    requestMapper->CreateRequestL(operationId,EFalse,EVIMPSTXimpOperationGetSubscribedList);
+    CleanupStack::PopAndDestroy(); // groupList
+    // list retrieving ok. Waiting for list.;
+    }
+
+// ---------------------------------------------------------------------------
+// CVIMPSTEnginePresenceSubService::SubscribePresenceOfSingleContactL
+// ---------------------------------------------------------------------------
+//
+void CVIMPSTEnginePresenceSubService::SubscribePresenceOfSingleContactL( const TDesC& aUriOfTheContact)
+    {
+	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 );
+    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(buddyId);
+    
+    TRACE("SubscribeToPresenceCacheL: %S", &namePtr );
+    iPresenceCacheReader->SubscribePresenceBuddyChangeL(*name);
+    CleanupStack::PopAndDestroy(name); //  name    
+    }
+
+// ---------------------------------------------------------------------------
+// CVIMPSTEnginePresenceSubService::
+//      UnsubscribePrecenseOfSingleContactL
+// ---------------------------------------------------------------------------
+//
+void CVIMPSTEnginePresenceSubService::UnSubscribePresenceOfSingleContactL(
+        const TDesC& aUriOfTheContact )
+    {
+	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( "UnSubscribeToPresenceCacheL: %S", &namePtr);
+    iPresenceCacheReader->UnSubscribePresenceBuddyChangeL(*name);
+    CleanupStack::PopAndDestroy(name); //  name                  
+    }
+
+// ---------------------------------------------------------------------------
+// CVIMPSTEnginePresenceSubService::
+//      DoHandlePresentityGroupContentEventL
+// ---------------------------------------------------------------------------
+//
+void CVIMPSTEnginePresenceSubService::
+DoHandlePresentityGroupContentEventL(
+        const MXIMPContext& /*aContext*/,
+        const MXIMPBase& aEvent )
+    {
+	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(" -> storing into respective service store" );
+	    StoreToVirtualStoreL( event );
+		}
+	//this is to ensure the presence for the local sotre contacts is not lost.
+  	TRACE( "new member count: %d" , event.NewMembersCount() ); 
+    TRACE( " current member count: %d" , event.CurrentMembersCount() );  
+    TRACE( "disappeared member count: %d" , event.DisappearedMembersCount() );   
+    }
+
+// ---------------------------------------------------------------------------
+// CVIMPSTEnginePresenceSubService::
+//      DoHandlePresenceGrantRequestListEventL
+// ---------------------------------------------------------------------------
+//
+void CVIMPSTEnginePresenceSubService::
+DoHandlePresenceGrantRequestListEventL(
+        const MXIMPContext& /*aContext*/,
+        const MXIMPBase& aEvent )
+    {
+	TRACER_AUTO;
+    TVIMPSTEnums::TVIMPSTPresenceRequestStatus autoAccept = iSettingsTableFetcher.PresenceRequestStatusL(iServiceId);
+    if(autoAccept == TVIMPSTEnums::ESVCEPresenceRequestStatusAutoAccept)
+        {
+        iAutoAccept = ETrue;
+        }
+    else
+        {
+        iAutoAccept = EFalse;
+        }
+    
+     const MPresenceGrantRequestListEvent& event = 
+     							*TXIMPGetInterface<const MPresenceGrantRequestListEvent >::From( 
+								aEvent, MXIMPBase::EPanicIfUnknown );
+
+     TRACE("new watcher count: %d" , event.NewRequestsCount() );   
+     TRACE("current watcher count: %d" , event.CurrentRequestsCount() ); 
+    HBufC* identbuf(NULL);
+    HBufC* displayName(NULL);
+    TInt newcount     = event.NewRequestsCount();
+    TInt currentcount = event.CurrentRequestsCount();
+    if(newcount)
+        {
+    TRACE( " newcount =%d" , newcount );    
+    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( "identity: %S" , &identbufPtr );   
+            if(identbuf->Length())
+                {
+            TRACE( " pass to command process" );   
+                if( iAutoAccept &&
+                        TVIMPSTEnums::ESVCERegistered == iServiceState)
+                    {
+                    TInt error = SendPresenceGrantPresentityL( identbufPtr, ETrue );                    
+                    }
+                 else if( iSubServiceObserver )
+                    {
+                 TRACE( " informed observer." ); 
+                    iSubServiceObserver->HandleAddRequestEventL( TVIMPSTEnums::EAddItem , *identbuf, *displayName);
+                    }                    
+                TRACE( " pass to command process" );
+                }
+            CleanupStack::PopAndDestroy( displayName );
+            CleanupStack::PopAndDestroy( identbuf );
+            }
+        }
+    else if(currentcount)
+        {
+        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( "identity: %S" , &identbufPtr );  
+        if(identbuf->Length())
+            {
+        TRACE( " pass to command process" );
+            if( iAutoAccept)
+                {
+                TInt error = SendPresenceGrantPresentityL( identbufPtr, ETrue );                    
+                }
+             else if( iSubServiceObserver )
+                {
+             TRACE( " informed observer."); 
+                iSubServiceObserver->HandleAddRequestEventL(TVIMPSTEnums::EAddItem ,*identbuf, *displayName);
+                }      
+            TRACE( "pass to command process" ); 
+            }
+        CleanupStack::PopAndDestroy( displayName );
+        CleanupStack::PopAndDestroy ( identbuf );
+        }    
+
+    }
+
+// ---------------------------------------------------------------------------
+// CVIMPSTEnginePresenceSubService::ResolveServiceStateL
+// ---------------------------------------------------------------------------
+// 
+TVIMPSTEnums::TVIMPSTRegistrationState CVIMPSTEnginePresenceSubService::ResolveServiceStateL(
+        TCCHSubserviceState aState, 
+        TInt aServiceError )
+    {
+
+	TRACER_AUTO;
+
+    TVIMPSTEnums::TVIMPSTRegistrationState state = TVIMPSTEnums::ESVCENotRegistered;       
+
+    
+    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( " ESVCEWaitingForNetwork");
+            handleServiceStates = EFalse;  
+            //state = TVIMPSTEnums::ESVCEWaitingForNetwork;
+            state = TVIMPSTEnums::ESVCENotRegistered; 
+            }
+        }
+
+    if ( handleServiceStates )
+        {        
+        switch ( aState )
+            {
+            case ECCHEnabled:
+                {
+                TRACE( "ESVCERegistered" );
+                state = TVIMPSTEnums::ESVCEUpdatingContacts;   
+                break;
+                }
+            case ECCHDisconnecting:      
+                {
+                TRACE( " ESVCERegistered" );   
+                state = TVIMPSTEnums::ESVCENetworkDisConnecting;
+                }
+                break;
+
+            case ECCHUninitialized:
+            case ECCHDisabled:  
+                {
+                TRACE( "ESVCENotRegistered");
+                state = TVIMPSTEnums::ESVCENotRegistered;                
+                }
+                break;
+
+            case ECCHConnecting:               
+                {
+                TRACE( " ESVCENoNetworkConnecting");  
+                state = TVIMPSTEnums::ESVCENetworkConnecting;
+                }
+                break;
+
+            default:
+                break;
+            }
+        }        
+
+
+    return state;  
+
+    }
+
+
+// ---------------------------------------------------------------------------
+// CVIMPSTEnginePresenceSubService::CchEventOccuredL
+// ---------------------------------------------------------------------------
+//
+void CVIMPSTEnginePresenceSubService::CchEventOccuredL( 
+        TUint /*aServiceId*/, 
+        TCCHSubserviceState aState, 
+        TInt aServiceError )
+    {
+
+	TRACER_AUTO;
+	
+    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
+        //So better check here if you get any CCH errors=        
+        iServiceState = ResolveServiceStateL( aState, aServiceError );
+        iObserver.HandleServceConnectionEventL();
+        DoHandleCchErrorL( aServiceError );
+        }
+    else
+        {
+        TVIMPSTEnums::TVIMPSTRegistrationState currentState = 
+        							ResolveServiceStateL( aState, aServiceError );
+        							
+		if ( TVIMPSTEnums::ESVCERegistered == iServiceState 
+				&& TVIMPSTEnums::ESVCEUpdatingContacts == currentState )
+			{
+			//dont do anything
+			//updating contacts is a special case
+			//Once updating contacts, we fetch the groups and once this is done
+			//we end up changing the state to registered
+			//but CCH might send the same callback twice	
+			//to handle this situation we add a check here
+			//because we might have already moved from Updatin to Registered state
+			}
+		else
+			{
+			iServiceState = ResolveServiceStateL( aState, aServiceError );    
+		    iObserver.HandleServceConnectionEventL();			}
+        }   
+
+
+    }
+
+
+// ---------------------------------------------------------------------------
+// CVIMPSTEnginePresenceSubService::DoHandleCchErrorL()
+// ---------------------------------------------------------------------------
+// 
+void CVIMPSTEnginePresenceSubService::DoHandleCchErrorL( 
+        TInt aServiceError )
+    {
+
+	TRACER_AUTO;
+	   TRACE( "ServiceErr: %d",  aServiceError );
+
+    if ( aServiceError )
+        {
+        //unsubscribe can only be done, when bind is already done
+        if(TVIMPSTEnums::EVIMPSTBindDone ==iXimpEventObserver.ContextBindStatus())
+            {
+            TRACE( "unscribe and unbind");
+            TRAP_IGNORE( UnsubscribeListsL() ); 
+            iXimpEventObserver.ServerUnBindL( ETrue );
+            }
+        }
+
+
+    }
+
+// ---------------------------------------------------------
+// CVIMPSTEnginePresenceSubService::PublishOwnPresenceL
+// 
+// ---------------------------------------------------------    
+TInt CVIMPSTEnginePresenceSubService::PublishOwnPresenceL(TVIMPSTEnums::TOnlineStatus aStatus, 
+														  const TDesC& aValue,
+						         						  const TDesC& aFilename /*= KNullDesC*/, 
+						         						  const TDesC8& aMimetype /*= KNullDesC8*/,
+						         						  TBool aIsAvatar /*= EFalse*/ )
+    {
+	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( "aIsAvatar: %d",  aIsAvatar );
+	// avatar field set || clear
+	if ( aIsAvatar )
+        {
+	TRACE( " PublishOwnPresenceL adding avatar field");
+        
+     	infoField = iXimpEventObserver.PresenceObjectFactoryL().NewInfoFieldLC();
+        MPresenceInfoFieldValueBinary* avatarField = iXimpEventObserver.PresenceObjectFactoryL().NewBinaryInfoFieldLC(); 
+        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( " PublishOwnPresenceL processing image data completed ");
+        if ( avatarContent )
+			{
+        TRACE( "PublishOwnPresenceL valid image data found ");
+			CleanupStack::PushL(avatarContent);
+			// set a new avatar
+			avatarField->SetBinaryValueL(*avatarContent);
+ 			avatarField->SetMimeTypeL(aMimetype);
+			CleanupStack::PopAndDestroy(); // avatarContent
+			}
+		else
+			{
+		TRACE("PublishOwnPresenceL NULL image data found ");
+			//  clear the avatar 
+			avatarField->SetBinaryValueL(KNullDesC8);
+			iIsClearingAvatar = ETrue;  //set iIsClearingAvatar to ETrue
+			}
+        CleanupStack::PopAndDestroy(imageHandler); // imageHandler
+        
+ 	    //Fill presence doc with presence components and attributes
+        infoField->SetFieldTypeL( NPresenceInfo::NFieldType::KAvatar ); 
+        // for clear avatar mimetye is KNUllDesc so set for all the cases
+       	infoField->SetFieldValue( avatarField );  // avatarField ownership transfered
+        CleanupStack::Pop(); // avatarField
+		attributeFields.AddOrReplaceFieldL(infoField ); // infofield ownership transfered
+        CleanupStack::Pop(); // infoField
+		infoField = NULL;
+		TRACE( "adding avatar field completed ");
+        }
+
+    // availabilty field
+    infoField = iXimpEventObserver.PresenceObjectFactoryL().NewInfoFieldLC();//3
+    //based on the state conver it to  ximpfw status.
+    NPresenceInfo::TAvailabilityValues availablity = ConvertPresenceStatus( aStatus );
+    // "availability" attribute
+    MPresenceInfoFieldValueEnum* availabilityField = iXimpEventObserver.PresenceObjectFactoryL().NewEnumInfoFieldLC();//4
+    availabilityField->SetValueL( availablity );
+    infoField->SetFieldTypeL( NPresenceInfo::NFieldType::KAvailabilityEnum ); 
+    infoField->SetFieldValue( availabilityField );
+    CleanupStack::Pop(); // availabilityField
+    attributeFields.AddOrReplaceFieldL(infoField );
+    CleanupStack::Pop(); // infoField
+
+    //status text field
+    infoField = iXimpEventObserver.PresenceObjectFactoryL().NewInfoFieldLC();//7
+    MPresenceInfoFieldValueText* statustextField = iXimpEventObserver.PresenceObjectFactoryL().NewTextInfoFieldLC();//8
+    //ownership is transfered to statustextField
+    HBufC* statusText = aValue.AllocLC();
+    //ownership is not transferred
+    statustextField->SetTextValueL( *statusText); // some status text
+    CleanupStack::PopAndDestroy();//statusText
+    infoField->SetFieldTypeL( NPresenceInfo::NFieldType::KStatusMessage );
+    infoField->SetFieldValue( statustextField );
+    CleanupStack::Pop(); // statustextField
+    attributeFields.AddOrReplaceFieldL( infoField );
+    CleanupStack::Pop(); // infoField
+	
+
+	myPresence->SetPersonPresenceL(personPresence);
+    CleanupStack::Pop(); // personPresence
+  
+    TXIMPRequestId reqId;
+    reqId = publisher.PublishOwnPresenceL( *myPresence );
+    // wait completion
+    // 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
+    
+    return error;
+    }
+
+// ---------------------------------------------------------
+// CVIMPSTEnginePresenceSubService::UpdateStatusToServerL
+// 
+// ---------------------------------------------------------    
+NPresenceInfo::TAvailabilityValues CVIMPSTEnginePresenceSubService::ConvertPresenceStatus(TVIMPSTEnums::TOnlineStatus aStatus)
+    {
+	TRACER_AUTO;
+    NPresenceInfo::TAvailabilityValues availablity;
+    switch(aStatus)
+        {
+        case TVIMPSTEnums::EOffline:
+            {
+            availablity = NPresenceInfo::ENotAvailable;
+            break;
+            }
+        case TVIMPSTEnums::EOnline:
+            {
+            availablity = NPresenceInfo::EAvailable;
+            break;
+            }
+        case TVIMPSTEnums::EInvisible:
+            {
+            availablity = NPresenceInfo::EHidden;
+            break;
+            }
+        case TVIMPSTEnums::EAway:
+            {
+            availablity = NPresenceInfo::EAway;
+            break;
+            }
+        case TVIMPSTEnums::EBusy:
+            {
+            availablity = NPresenceInfo::EBusy;
+            break;
+            }
+        case TVIMPSTEnums::EOnPhone:
+            {
+            availablity = NPresenceInfo::EOnPhone;
+            break;
+            }
+        case TVIMPSTEnums::EDoNotDisturb:
+            {
+            availablity = NPresenceInfo::EDoNotDisturb;
+            break;
+            }
+        default: 
+            {
+            availablity = NPresenceInfo::ENotAvailable;
+            break;
+            }
+        }
+    return availablity;
+    }
+/// ---------------------------------------------------------
+// CVIMPSTEnginePresenceSubService::FetchPresenceFromCache
+// 
+// ---------------------------------------------------------    
+TInt  CVIMPSTEnginePresenceSubService::FetchPresenceFromCache()
+    {
+    //TODO::Figure out how to get the service name.
+    // passed the service id to see the member count
+    TInt error( KErrArgument );
+    TRACER_AUTO;
+	if( iServiceName )
+		{
+		TPtr serviceNamePtr = iServiceName->Des();
+		TRACE( "CVIMPSTEnginePresenceSubService::FetchPresenceFormCache() - %S", &serviceNamePtr );
+		// passed the service to register for notification
+		error = iPresenceCacheReader->AllBuddiesPresenceInService(*iServiceName, this );		
+		}
+	return error;
+    }
+
+// ---------------------------------------------------------------------------
+// CVIMPSTEnginePresenceSubService::HandlePresenceReadL
+// ---------------------------------------------------------------------------
+//  
+void CVIMPSTEnginePresenceSubService::HandlePresenceReadL(TInt /*aErrorCode*/,
+        RPointerArray<MPresenceBuddyInfo2>& aPresenceBuddyInfoList)
+    {
+	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( "count: %d" , buddyCount );
+    for ( TInt i =0 ; i < buddyCount ; ++i)
+		{
+    TRACE( " buddy index: %d" , i );
+		MPresenceBuddyInfo2* buddyinfo = aPresenceBuddyInfoList[i];
+		// read the buddyID : returns in XSP format
+		TPtrC buddyXSPId = buddyinfo->BuddyId();
+		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( "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("Status Message: %s" , &statusMsg );
+		TPtrC8 avatarContent = buddyinfo->Avatar();
+		HBufC8* avatarScaledData = NULL;
+		if ( avatarContent.Length() )
+			{
+			TRACE( "avatarContent Content available"  );
+			CVIMPSTEngineImageHandler* imageHandler = CVIMPSTEngineImageHandler::NewL();
+			CleanupStack::PushL(imageHandler);
+			TRACE( "imageHandler created "  );
+		    avatarScaledData = imageHandler->ProcessImageFromDataL( avatarContent , KNullDesC8() );
+		    TRACE( "ProcessImageFromDataL returned " );
+			CleanupStack::PopAndDestroy();//imageHandler
+			}
+		if( avatarScaledData && avatarScaledData->Length() )
+			{
+			CleanupStack::PushL(avatarScaledData);
+			storage->UpdatePresenceL(buddyId,status,statusMsg, *avatarScaledData );	
+			CleanupStack::PopAndDestroy();//avatarScaledData
+			}
+		else  
+			{
+			storage->UpdatePresenceL(buddyId, status, statusMsg, KNullDesC8 );		
+			}
+		}
+    aPresenceBuddyInfoList.ResetAndDestroy();
+ 
+    CleanupStack::PopAndDestroy();  //  aPresenceBuddyInfoList
+    }
+
+// ---------------------------------------------------------------------------
+// CVIMPSTEnginePresenceSubService::HandlePresenceNotificationL
+// ---------------------------------------------------------------------------
+//  
+void CVIMPSTEnginePresenceSubService::HandlePresenceNotificationL(TInt /*aErrorCode*/,
+        MPresenceBuddyInfo2* aPresenceBuddyInfo)
+    {
+	TRACER_AUTO;
+       
+    if ( aPresenceBuddyInfo )
+        {
+        CleanupDeletePushL( aPresenceBuddyInfo );
+        DoHandlePresenceNotificationL(*aPresenceBuddyInfo);
+        CleanupStack::PopAndDestroy(1); // aPresenceBuddyInfo
+        
+        }
+    }
+
+
+// ---------------------------------------------------------
+// CVIMPSTEnginePresenceSubService::SubscribeForAuthorizationL
+//  
+// ---------------------------------------------------------    
+void  CVIMPSTEnginePresenceSubService::SubscribeForAuthorizationL()
+    {
+	TRACER_AUTO;
+    TXIMPRequestId req;
+    MPresenceAuthorization& authorization = iXimpEventObserver.XimpAuthorizationL();
+    req = authorization.SubscribePresenceGrantRequestListL();  
+    // mapper is not own
+    CVIMPSTEngineRequestMapper* mapper = iXimpEventObserver.GetRequestMapper(); 
+    mapper->CreateRequestL(req, EFalse,EVIMPSTXimpOperationSubcribeGrantRequestList);
+    
+    iSubscribeToAuthList = ETrue;
+    }
+// ---------------------------------------------------------
+// CVIMPSTEnginePresenceSubService::SendPresenceGrantPresentityResponseL
+//  
+// ---------------------------------------------------------    
+TInt CVIMPSTEnginePresenceSubService::SendPresenceGrantPresentityL( const TDesC& aContactId , TBool aResponse )
+    {
+	TRACER_AUTO;
+    __ASSERT_ALWAYS( aContactId.Length(), User::Leave( KErrArgument ) );
+      
+    // return the response to the server.    
+    MPresenceAuthorization& authorization = iXimpEventObserver.XimpAuthorizationL();
+    // mapper is not own
+    CVIMPSTEngineRequestMapper* mapper = iXimpEventObserver.GetRequestMapper();
+
+    MXIMPIdentity* contactIdentity = iXimpEventObserver.XimpPresenceContextL().ObjectFactory().NewIdentityLC();
+     __ASSERT_ALWAYS( contactIdentity , User::Leave( KErrNoMemory ) );		
+    contactIdentity->SetIdentityL( aContactId ) ;    
+    TXIMPRequestId req;
+    //accepted the request.
+    if(aResponse)
+        {
+        MPresenceInfoFilter* infoFilt = iXimpEventObserver.PresenceObjectFactoryL().NewPresenceInfoFilterLC();
+        if( infoFilt )
+            {
+            infoFilt->AcceptPersonFilterL( NPresenceInfo::NFieldType::KAcceptAll );
+            req = authorization.GrantPresenceForPresentityL(*contactIdentity ,*infoFilt );
+            CleanupStack::PopAndDestroy(); //infoFilt   	
+            }
+        }
+    else// rejected the request.
+        {        
+        req = authorization.WithdrawPresenceGrantFromPresentityL(*contactIdentity);         
+        }
+    if( iSubServiceObserver && !iAutoAccept )
+        {
+        iSubServiceObserver->HandleAddRequestEventL(TVIMPSTEnums::ERemoveItem ,aContactId, KNullDesC() );
+        }
+    mapper->CreateRequestL(req, !iAutoAccept, EVIMPSTXimpOperationGrantPresenceForPresentity );
+
+    TInt error = iXimpEventObserver.GetCompletedReqResult(); // get the result error    
+    if( ( ( error == KPREQUESTERRSUCCESSFUL) || ( error == KErrNone )  || iAutoAccept)  )
+        {        
+        MVIMPSTStorageServiceView* storage = CVIMPSTStorageManagerFactory::ContactListInterfaceL(iServiceId) ;
+        if(storage && ( !storage->IsLocalStore() || iAutoAccept  ) && aResponse )
+            {   
+        TRACE( " server store" );
+            storage->CreateNewContactL( aContactId,KNullDesC, ETrue, iAutoAccept ); // ETrue is for invitation item 
+            } 
+        }
+    CleanupStack::PopAndDestroy(); //contactIdentity
+    return error;
+    }  
+// ---------------------------------------------------------
+// CVIMPSTEnginePresenceSubService::HandleSessionContextEventL
+// ---------------------------------------------------------
+void CVIMPSTEnginePresenceSubService::HandleSessionContextEventL(const MXIMPContext& aContext,
+        const MXIMPBase& aEvent,
+        TXimpOperation aXimpOperation /*= EVIMPSTXimpOperationNoOperation*/ )
+    {
+	TRACER_AUTO;
+    TInt32 eventId = aEvent.GetInterfaceId();
+
+    switch( aEvent.GetInterfaceId() )
+        {
+        case MXIMPRequestCompleteEvent::KInterfaceId:
+            {
+            TRACE( "MXIMPRequestCompleteEvent");
+            //temp fix TBD
+            //Only use the operations that u r intertest in
+            if ( aXimpOperation <= EVIMPSTXimpOperationUnsubscribe )  
+                {
+
+                const MXIMPRequestCompleteEvent* event =
+                TXIMPGetInterface< const MXIMPRequestCompleteEvent >::From( 
+                        aEvent, MXIMPBase::EPanicIfUnknown );
+                TRAP_IGNORE( HandleXimpRequestCompleteL( 
+                        aXimpOperation,
+                        event->CompletionResult().ResultCode(),
+                        aEvent ) );
+                }
+            TRACE( "HandlePresenceContextEvent");  
+
+            break;
+            }
+        case MXIMPContextStateEvent::KInterfaceId:
+            {
+            TRACE( "InsideCallbackswitch::MXIMPContextStateEvent");
+            TRACE("InsideCallback::MXIMPContextStateEvent");
+            break;
+            }
+        case MPresentityGroupContentEvent::KInterfaceId:
+            {
+            TRACE( "MPresentityGroupContentEvent");
+            DoHandlePresentityGroupContentEventL( aContext, aEvent );
+            TRACE( "MPresentityGroupContentEvent");
+            break;  
+            }
+        case MPresenceGrantRequestListEvent::KInterfaceId:
+            {
+            TRACE( "MPresenceGrantRequestListEvent");
+            DoHandlePresenceGrantRequestListEventL( aContext, aEvent );
+            TRACE( "MPresenceGrantRequestListEvent");
+            break;
+            }
+        case MPresenceBlockListEvent::KInterfaceId:
+           {
+           TRACE( "MPresenceBlockListEvent");
+           DoHandlePresenceBlockListEventL( aContext, aEvent );
+           TRACE( "MPresenceBlockListEvent");
+
+           break;
+           }
+           
+        default:
+            {
+            break;
+            }
+        }
+    }    
+
+// ---------------------------------------------------------------------------
+// CVIMPSTEnginePresenceSubService::HandleListEventCompleteL
+// ---------------------------------------------------------------------------
+//
+void CVIMPSTEnginePresenceSubService::HandleListEventCompleteL(TXimpOperation aType,
+        TInt aCompleteCode,
+        const MXIMPBase& /*aEvent*/)
+    { 
+	TRACER_AUTO;
+
+    switch ( aType )
+        {
+        case EVIMPSTXimpOperationBind:
+            {
+            if(iLogoutRequest)
+                {
+                //since logout is requested, no need to Subscribe and Retrieve list
+                break;
+                }
+            if ( KErrNone == aCompleteCode )
+                {         
+			    SubscribeForAuthorizationL();
+                // get the list.
+                RetrieveSubscribedListL();
+                
+                }
+            break;
+
+            }
+        case EVIMPSTXimpOperationGetSubscribedList:
+            {
+            if(iLogoutRequest)
+                {
+                //Since logout is requested need not to retrive block list
+                break;
+                }
+            // check if blocking is supported then get the blocked list and 
+            // subscribe those to persence cache.
+            TInt supportedFeatures = iXimpEventObserver.GetSupportedFeatures();
+            if ( (EVIMPSTFeatureBlock & supportedFeatures) && (EVIMPSTFeatureUnBlock & supportedFeatures) )
+               {
+               RetrieveBlockListL();
+               }
+            break;
+            }
+        case EVIMPSTXimpOperationUnBind:
+            {
+            //Logout request completed
+            iLogoutRequest = EFalse;
+            break;
+            }            
+        default:
+            break;   
+        }
+    }
+
+// ---------------------------------------------------------------------------
+// CVIMPSTEnginePresenceSubService::HandleXimpRequestCompleteL
+// ---------------------------------------------------------------------------
+//
+void CVIMPSTEnginePresenceSubService::HandleXimpRequestCompleteL(TXimpOperation aType,
+        TInt aCompleteCode,const MXIMPBase& aEvent )
+    {
+	TRACER_AUTO;
+    switch ( aType )
+        {
+        case EVIMPSTXimpOperationBind:
+        case EVIMPSTXimpOperationGetSubscribedList:
+        case EVIMPSTXimpOperationGetBlockList:
+            //case TVIMPSTEnums::ESVCEXimpOperationGetWatcherList:
+        case EVIMPSTXimpOperationUnBind:        
+            {
+            HandleListEventCompleteL( aType, aCompleteCode,aEvent );
+            break;
+            }
+        case EVIMPSTXimpOperationWithdrawPresenceGrant:
+            {
+            break;
+            }
+        case EVIMPSTXimpOperationBlockPresenceForPresentity:
+        case EVIMPSTXimpOperationCancelPresenceBlockFromPresentity:
+        default:
+            {
+            break;
+            }
+        }
+
+
+    }
+// -----------------------------------------------------------------------------
+// CVIMPSTEnginePresenceSubService::StoreToVirtualStoreL
+// -----------------------------------------------------------------------------
+//  
+void CVIMPSTEnginePresenceSubService::StoreToVirtualStoreL(
+                            const MPresentityGroupContentEvent& aListEvent )
+    {
+	TRACER_AUTO;
+	TRACE( " count = %d",aListEvent.CurrentMembersCount() );
+    TRACE("NewMembersCount count = %d",aListEvent.NewMembersCount() );
+    TRACE( "UpdatedMembersCount count = %d",aListEvent.UpdatedMembersCount() );
+    MVIMPSTStorageServiceView* storage = 
+    CVIMPSTStorageManagerFactory::ContactListInterfaceL(iServiceId) ;	
+    TLinearOrder< TPtrC > linearOrder (*CompareAlphabetically );
+    if (storage)
+        {		
+        //currMembrCount will be 0 when you login to the service
+        if( iIsFetchingContact)  
+            {
+            // there are contacts process each
+            TPtrC listName = aListEvent.GroupId().Identity() ;
+            RArray <TPtrC> firstNameList;
+            CleanupClosePushL( firstNameList );
+            RArray <TPtrC> serviceField;
+            CleanupClosePushL( serviceField );
+            
+            firstNameList.Reset();
+            serviceField.Reset();
+            // number of contact in this list
+           TInt currentMembrcount = aListEvent.CurrentMembersCount();
+           TRACE( "currentMembrcount count = %d",currentMembrcount );
+            // Handle first current items
+            for(TInt j = 0; j < currentMembrcount ;j++ )
+                {
+                const MPresentityGroupMemberInfo& memberInfo = 
+                    aListEvent.CurrentMember( j ) ;
+                const MXIMPIdentity& memberIdentity = memberInfo.GroupMemberId() ;
+                TPtrC userId = memberIdentity.Identity();
+                TPtrC displayeName = memberInfo.GroupMemberDisplayName();
+                serviceField.AppendL(userId );    
+                firstNameList.AppendL(displayeName );
+                }
+
+            // number of contact in this list
+            TInt newMembrcount = aListEvent.NewMembersCount() ;
+            TRACE("newMembrcount count = %d",newMembrcount );
+            for(TInt i = 0; i < newMembrcount ;i++ )
+                {
+                const MPresentityGroupMemberInfo& memberInfo = 
+                aListEvent.NewMember( i ) ;
+                const MXIMPIdentity& memberIdentity = memberInfo.GroupMemberId() ;
+                TPtrC userId = memberIdentity.Identity();
+                TPtrC displayeName = memberInfo.GroupMemberDisplayName();
+                TInt error = serviceField.InsertInOrder(userId,linearOrder);
+                if(KErrAlreadyExists != error)
+                    {
+                    firstNameList.Append(displayeName);
+                    }
+                }
+            TRACE( " calling CreateNewFetchContactsL" );
+            TRACE( " serviceField count %d",serviceField.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;
+            
+            CleanupStack::PopAndDestroy( &serviceField );
+            CleanupStack::PopAndDestroy( &firstNameList );
+            }
+        //in case of delayed fetch contact and add contact 
+	 	else 
+			{
+			// number of contact in this list
+			TInt currentMembrcount = aListEvent.CurrentMembersCount() ;
+			for(TInt i = 0; i < currentMembrcount ; i++ )
+                {
+                const MPresentityGroupMemberInfo& memberInfo = 
+                                                aListEvent.CurrentMember( i ) ;
+                const MXIMPIdentity& memberIdentity = memberInfo.GroupMemberId() ;
+                RDebug::Print( _L("CVIMPSTEnginePresenceSubService: newMember %S"), &memberIdentity.Identity() );   
+                if ( !storage->FindContactByUserId( memberIdentity.Identity() ) )
+                    {
+                    storage->CreateNewContactL( memberIdentity.Identity(), 
+                             memberInfo.GroupMemberDisplayName(), ETrue, ETrue );     
+                    }
+                }
+		    // number of contact in this list
+		    TInt newMembrcount = aListEvent.NewMembersCount() ;
+		    // there are contacts process each
+		    TPtrC listName = aListEvent.GroupId().Identity() ;
+		    for(TInt i = 0; i < newMembrcount ;i++ )
+		        {
+		        const MPresentityGroupMemberInfo& memberInfo = 
+		                                        aListEvent.NewMember( i ) ;
+		        const MXIMPIdentity& memberIdentity = memberInfo.GroupMemberId() ;
+		        TPtrC userId = memberIdentity.Identity();
+		        TPtrC displayeName = memberInfo.GroupMemberDisplayName();
+		        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( "deleteMember %S", &userId );
+		    	MVIMPSTStorageContact* contactExist = storage->FindContactByUserId(userId);
+		    	if(contactExist)
+		    	    {
+		    	    storage->RemoveContactL(contactExist);	
+		    	    }
+		        }
+			}
+         
+        }
+    }
+
+// ---------------------------------------------------------
+// CVIMPSTEnginePresenceSubService::IsChangeOwnStatusSupported
+// 
+// ---------------------------------------------------------        
+
+TBool CVIMPSTEnginePresenceSubService::IsChangeOwnStatusSupported() 
+    {
+    //TODO:: get the feature supported from ximp and return
+    return iChangeStatusSupported;
+    }
+
+// ---------------------------------------------------------
+// CVIMPSTEnginePresenceSubService::IsStatusMsgSupported
+// 
+// ---------------------------------------------------------        
+TBool CVIMPSTEnginePresenceSubService::IsStatusMsgSupported()
+    {
+    //TODO:: get the feature supported from ximp and return
+    return iChangeStatusMsgSupported;
+    }
+
+// ---------------------------------------------------------
+// CVIMPSTEnginePresenceSubService::IsAvatarSupported
+// 
+// ---------------------------------------------------------        
+TBool CVIMPSTEnginePresenceSubService::IsAvatarSupported()
+    {
+    return iAvatarSupported;
+    }
+ 
+ // ---------------------------------------------------------
+// CVIMPSTEnginePresenceSubService::SetAvatarSupported
+// 
+// ---------------------------------------------------------        
+void CVIMPSTEnginePresenceSubService::SetAvatarSupported(TBool aSupported )
+    {
+    iAvatarSupported = aSupported;
+    }
+// ---------------------------------------------------------------------------
+// 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 )
+        {
+        case MPresenceBuddyInfo2::EBusy:
+			{
+			status  = TVIMPSTEnums::EBusy;
+			if(0==aAvabilityText.Compare(KAwayState))
+			    {
+			    status  = TVIMPSTEnums::EAway;
+			    }
+			if(0==aAvabilityText.Compare(KOnPhoneState))
+			    {
+			    status  = TVIMPSTEnums::EOnPhone;
+			    }
+			if(0==aAvabilityText.Compare(KDndState))
+			    {
+			    status  = TVIMPSTEnums::EDoNotDisturb;
+			    }
+            break;
+			}
+        case MPresenceBuddyInfo2::EAvailable:
+            {
+            status  = TVIMPSTEnums::EOnline;
+            break;
+            }
+        case MPresenceBuddyInfo2::ENotAvailable:
+            {
+            status  = TVIMPSTEnums::EOffline;
+            break;
+            }
+        case MPresenceBuddyInfo2::EUnknownAvailability:
+            {
+            status  = TVIMPSTEnums::EUnknown;
+			if(0==aAvabilityText.Compare(KInvisibleState))
+			    {
+			    status  = TVIMPSTEnums::EInvisible;
+			    }
+			
+            break;
+            }   
+        default:
+	        {
+            status  = TVIMPSTEnums::EUnknown;
+            break;
+	        }
+        }
+    return status;
+    }
+
+
+// ---------------------------------------------------------
+// CVIMPSTEnginePresenceSubService::RegisterPresenceEventObserver
+// 
+// ---------------------------------------------------------	
+//TODO::Should be named as RegisterPresenceEventObserverL
+void CVIMPSTEnginePresenceSubService::RegisterPresenceEventObserverL(
+        MVIMPSTEnginePresenceSubServiceEventObserver* aObserver)
+    {
+	TRACER_AUTO;
+    __ASSERT_ALWAYS( aObserver, User::Leave( KErrArgument ));		
+    iSubServiceObserver = aObserver;
+    }
+
+// ---------------------------------------------------------
+// CVIMPSTEnginePresenceSubService::UnRegisterPresenceEventObserver
+// 
+// ---------------------------------------------------------	
+
+void CVIMPSTEnginePresenceSubService::UnRegisterPresenceEventObserver(
+        MVIMPSTEnginePresenceSubServiceEventObserver* /*aObserver*/)
+    {
+	TRACER_AUTO;
+    iSubServiceObserver = NULL;
+    }   
+// ---------------------------------------------------------------------------
+// CVIMPSTEnginePresenceSubService::RetrieveBlockListL
+// ---------------------------------------------------------------------------
+//
+void CVIMPSTEnginePresenceSubService::RetrieveBlockListL()
+    {
+	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.;
+    }
+// ---------------------------------------------------------------------------
+// CVIMPSTEnginePresenceSubService::DoHandlePresenceNotificationL
+// ---------------------------------------------------------------------------
+//
+void CVIMPSTEnginePresenceSubService::DoHandlePresenceNotificationL(MPresenceBuddyInfo2& aPresenceBuddyInfo)
+    {
+	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( " buddyId : %s" , &buddyId );
+    // read the availability /presence state enum value 
+    MPresenceBuddyInfo2::TAvailabilityValues availabilityEnum = aPresenceBuddyInfo.Availability();
+    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( " status: %d" , status );
+    // Read  the  status message 
+    TPtrC statusMsg = aPresenceBuddyInfo.StatusMessage();
+    TRACE("Status Message: %s" , &statusMsg );
+    TPtrC8 avatarContent = aPresenceBuddyInfo.Avatar();
+    
+    ////////////////////////////////////////////////////////////////
+    HBufC8* avatarScaledData = NULL;
+	if ( avatarContent.Length() )
+		{
+	TRACE( "avatarContent Content available" );
+		CVIMPSTEngineImageHandler* imageHandler = CVIMPSTEngineImageHandler::NewL();
+		CleanupStack::PushL(imageHandler);
+		TRACE( "imageHandler created " );
+		avatarScaledData = imageHandler->ProcessImageFromDataL( avatarContent , KNullDesC8() );
+		TRACE( " ProcessImageFromDataL returned " );
+		CleanupStack::PopAndDestroy();//imageHandler
+		}
+    if( avatarScaledData && avatarScaledData->Length())
+        {
+        CleanupStack::PushL(avatarScaledData);
+        storage->UpdatePresenceL(buddyId,status,statusMsg, *avatarScaledData ); 
+        CleanupStack::PopAndDestroy();//avatarScaledData
+        }
+    else if( iIsClearingAvatar ) //clear own avatar
+        {
+        storage->UpdatePresenceL(buddyId, status, statusMsg, KNullDesC8, ETrue );
+        iIsClearingAvatar = EFalse;  
+        }
+    else
+        {
+        storage->UpdatePresenceL(buddyId, status, statusMsg, KNullDesC8 );      
+        }
+    }
+// ---------------	------------------------------------------------------------
+// CVIMPSTEnginePresenceSubService::
+//      DoHandlePresentityGroupContentEventL
+// ---------------------------------------------------------------------------
+//
+void CVIMPSTEnginePresenceSubService::DoHandlePresenceBlockListEventL(
+                                                        const MXIMPContext& /*aContext*/,
+                                                        const MXIMPBase& aEvent )
+    {
+	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( " -> DoHandlePresentityGroupContentEventL:state is ESVCEUpdatingContacts" );
+        }
+        
+    TRACE( " new member count: %d" , event.NewBlocksCount());  
+
+    TInt subscriptionCount  =  event.NewBlocksCount();
+
+    TRACE(" subscriptionCount: %d", subscriptionCount );
+
+        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( " -> identity: %S", &subsbufPtr );   
+
+            TRACE(" -> subscribe to cache"  );    
+            SubscribePresenceOfSingleContactL(*subsbuf);
+            iBlockedListMgr->AddToBlockedListL(*subsbuf);
+            CleanupStack::PopAndDestroy( subsbuf );
+            }
+        TInt disappearedCount = event.DisappearedBlocksCount();  
+                
+            for( TInt j =0; j < disappearedCount; j++ )
+                {
+                const MPresenceBlockInfo& blockedEntitys = event.DisappearedBlock( j );
+                const MXIMPIdentity& ident = blockedEntitys.BlockedEntityId();
+                subsbuf = ident.Identity().AllocLC();
+                TPtr subsbufPtr = subsbuf->Des();
+                TRACE( " identity: %S", &subsbufPtr );
+              
+                iBlockedListMgr->RemoveFromBlockListL( *subsbuf );    
+                
+            CleanupStack::PopAndDestroy( subsbuf );
+            }
+        
+        if(iBlockedListObserver)
+	        {
+	        iBlockedListObserver->HandleBlockedListFetchCompleteL();
+	        iBlockListFetchReqPending = EFalse;
+	        }
+
+    }
+
+// ---------------------------------------------------------------------------
+// CVIMPSTEnginePresenceSubService::AddToBlockListL
+// ---------------------------------------------------------------------------
+//
+TInt CVIMPSTEnginePresenceSubService::AddToBlockListL( const TDesC& aContactId )
+    {
+	TRACER_AUTO;
+    if(TVIMPSTEnums::ESVCERegistered != iServiceState)
+       return KErrNotSupported;
+    //if aContactId is zero.
+    if( 0 == aContactId.Length())
+       return KErrArgument;
+    
+    TRACE( " aContactId: %s" , &aContactId);
+    TRACE( " perform block operation" ); 
+    
+    MXIMPIdentity* identity = iXimpEventObserver.XimpPresenceContextL().ObjectFactory().NewIdentityLC();
+    
+    identity->SetIdentityL( aContactId ); 
+
+    TXIMPRequestId reqId = iXimpEventObserver.XimpAuthorizationL().BlockPresenceForPresentityL(*identity );
+    CVIMPSTEngineRequestMapper* mapper = iXimpEventObserver.GetRequestMapper();
+    mapper->CreateRequestL(reqId, ETrue,EVIMPSTXimpOperationBlockPresenceForPresentity);// waite here
+    TInt error = iXimpEventObserver.GetCompletedReqResult(); // get the result error
+    														 //Contact will be added to blocked list manager,
+    //Delete avatar of contact
+    if(KErrNone == error && IsAvatarSupported())
+	    {
+   		MVIMPSTStorageServiceView* storage = 
+    		CVIMPSTStorageManagerFactory::ContactListInterfaceL(iServiceId);
+		storage->UpdateAvatarL(aContactId,KNullDesC8);
+	    }
+    //when pres. cache call will come.
+    CleanupStack::PopAndDestroy(); // identity    
+    return error;
+    }
+
+// ---------------------------------------------------------------------------
+// CVIMPSTEnginePresenceSubService::RemoveFromBlockListL
+// ---------------------------------------------------------------------------
+//
+TInt CVIMPSTEnginePresenceSubService::RemoveFromBlockListL( const TDesC& aUriOfTheContact )
+    {
+	TRACER_AUTO;
+    if(TVIMPSTEnums::ESVCERegistered != iServiceState)
+       return KErrNotSupported;
+    //if aUriOfTheCOntact is zero.
+    if( 0 == aUriOfTheContact.Length())
+       return KErrNotFound;
+    
+    TRACE(" -> aUriOfTheContact: %s" , &aUriOfTheContact);
+    TRACE( " -> perform unblock operation"  );  
+    
+    MXIMPIdentity* identity = iXimpEventObserver.XimpPresenceContextL().ObjectFactory().NewIdentityLC();
+    identity->SetIdentityL( aUriOfTheContact ); 
+   
+    TXIMPRequestId reqId = iXimpEventObserver.XimpAuthorizationL().CancelPresenceBlockFromPresentityL(*identity );
+    CVIMPSTEngineRequestMapper* mapper = iXimpEventObserver.GetRequestMapper();
+    mapper->CreateRequestL(reqId, ETrue,EVIMPSTXimpOperationCancelPresenceBlockFromPresentity);// waite here
+    TInt error = iXimpEventObserver.GetCompletedReqResult(); // get the result error
+    //if blocked contact is unblocked, then remove it from
+    //locally maintained blocked list..
+    if(KErrNone == error)
+	    {
+	    iBlockedListMgr->RemoveFromBlockListL(aUriOfTheContact);
+	    }
+    CleanupStack::PopAndDestroy( 1 ); // identity    
+    
+    return error;
+    }
+    
+// ---------------------------------------------------------------------------
+// CVIMPSTEnginePresenceSubService::GetBlockedList
+// ---------------------------------------------------------------------------
+//
+RPointerArray<HBufC>* CVIMPSTEnginePresenceSubService::GetBlockedList()
+	{
+	if(iBlockedListMgr)
+		{
+		return iBlockedListMgr->BlockedList();
+		}
+	return NULL;	
+	}
+
+// ---------------------------------------------------------------------------
+// CVIMPSTEnginePresenceSubService::GetBlockedList
+// ---------------------------------------------------------------------------
+//
+void CVIMPSTEnginePresenceSubService::ResetBlockedListManagerL()
+	{
+	iBlockedListMgr->ResetL();
+	}
+	
+// ---------------------------------------------------------------------------
+// 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;
+	
+		//unsubscribe blocked list.
+	    TXIMPRequestId operationId = TXIMPRequestId::Null();
+	    operationId = iXimpEventObserver.XimpAuthorizationL().UnsubscribePresenceBlockListL();
+	    CVIMPSTEngineRequestMapper* requestMapper =iXimpEventObserver.GetRequestMapper();
+	    requestMapper->CreateRequestL(operationId,ETrue,EVIMPSTXimpOperationGetBlockList);
+		
+		iBlockListFetchReqPending = ETrue; 
+		//subscribe again to get fresh blocked list from server.
+		RetrieveBlockListL();
+		}
+	}
+	
+	
+// ---------------------------------------------------------------------------
+// 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)
+        {
+        aStatus = TVIMPSTEnums::EPending;
+        }
+    else if(value.CompareF( KBlockedExtensionValue ) == 0)
+        {
+        aStatus = TVIMPSTEnums::EBlocked;
+        }
+    else if(value.CompareF( KServiceExtensionValue ) == 0)
+        {
+        aStatus = TVIMPSTEnums::EServiceOut;
+        }
+    else if(value.CompareF( KCallForwardExtensionValue ) == 0)
+        {
+        aStatus = TVIMPSTEnums::ECallForward;
+        }
+    else
+		{
+		aStatus  = TVIMPSTEnums::EOffline;
+		}
+    }
+	
+// ---------------------------------------------------------------------------
+// CVIMPSTEnginePresenceSubService::UpdatePresenceStateL
+// ---------------------------------------------------------------------------
+//
+void CVIMPSTEnginePresenceSubService::UpdatePresenceStateL()
+    {
+	TRACER_AUTO;
+    //inform ui about the state change from updatingcontacts to registered.
+    iServiceState = TVIMPSTEnums::ESVCERegistered;    
+    iObserver.HandleServceConnectionEventL();
+    
+    TRACE( " -> HandleContactFetchedL:state is ESVCERegistered" ); 
+    }
+
+// ---------------------------------------------------------------------------
+// CVIMPSTEnginePresenceSubService::FetchPresenceOfSingleContactL
+// ---------------------------------------------------------------------------
+//
+void CVIMPSTEnginePresenceSubService::FetchPresenceOfSingleContactL(const TDesC& aContact)
+    {
+	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( " namePtr = %S", &namePtr);  
+        MPresenceBuddyInfo2* presenceBuddyInfo = iPresenceCacheReader->PresenceInfoLC(namePtr); // 2. on to cleanupstack
+        if ( presenceBuddyInfo )
+            {
+        TRACE("presenceBuddyInfo");            
+            DoHandlePresenceNotificationL(*presenceBuddyInfo);
+            CleanupStack::PopAndDestroy();  // presenceBuddyInfo
+            TRACE("presenceBuddyInfo end");  
+            }
+        CleanupStack::PopAndDestroy(name);  // name
+        }
+    }
+
+// ---------------------------------------------------------------------------
+// CVIMPSTEnginePresenceSubService::UnsubscribeListsL
+// ---------------------------------------------------------------------------
+//
+void CVIMPSTEnginePresenceSubService::UnsubscribeListsL()
+    {
+    TRACER_AUTO;
+
+    // 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 );
+    MXIMPIdentity* buddyGroupList = iXimpEventObserver.XimpPresenceContextL().ObjectFactory().NewIdentityLC();
+    __ASSERT_ALWAYS( buddyGroupList , User::Leave( KErrNoMemory ) );        
+    buddyGroupList->SetIdentityL( buddyGroupBuffer );        
+    iXimpEventObserver.XimpPresentityGroupsL().UnsubscribePresentityGroupContentL(
+                   *buddyGroupList );
+    CleanupStack::PopAndDestroy(); // buddyGroupList
+           
+   // Auth list
+   if(iSubscribeToAuthList)
+       {
+       TRACE("unsubscribe auth list");
+       iSubscribeToAuthList = EFalse;
+      iXimpEventObserver.XimpAuthorizationL().UnsubscribePresenceGrantRequestListL();  
+       }
+ 
+   // block list
+   TRACE( "check if block is supported");
+   TInt supportedFeatures = iXimpEventObserver.GetSupportedFeatures();
+   if ( (EVIMPSTFeatureBlock & supportedFeatures) && (EVIMPSTFeatureUnBlock & supportedFeatures) )
+       {
+       TRACE( "unsubscribe block list");
+       iXimpEventObserver.XimpAuthorizationL().UnsubscribePresenceBlockListL();        
+       }
+    
+    }
+
+// End of file