/*

* 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