/*

* Copyright (c) 2006 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:  Presence connection host

 *

*/

#include <ximpprotocolconnection.h>

#include <ximpprotocolconnectionhostobserver.h>

#include "ximpapiobjbase.h"

#include "ximpstatusimp.h"

#include "ximpoperationbase.h"

#include "ximphostimp.h"

#include "ximpglobals.h"

#include "ximppluginfactory.h"

#include "ximpeventmanager.h"

#include "ximphoststates.h"

#include "ximpcontextstateeventimp.h"

#include "ximpobjectfactoryimp.h"

#include "ximppanics.h"

#include "ximppsccontextimp.h"

#include "presencedatacacheimp.h"

#include "ximpserviceinfoimp.h"

#include "ximpoperationbase.h"

#include "ximpoperationfactory.h"

#include "ximpoperationfactory1.h"

#include "ximpobjecthelpers.h"

#include "ximpoperationdefs.h"

#include "ximpcontexteventqueue.h"

#include "ximphostmanager.h"

#include "ximpidentityimp.h"

#include "ximprestrictedobjectcollectionimp.h"

#include "ximprequestcompleteeventimp.h"

#include "ximpcontextclientinfoimp.h"

#include "protocolpresencedatahostimp.h"

#include "protocolpresenceauthorizationdatahostimp.h"

#include "protocolpresencepublishingdatahostimp.h"

#include "protocolpresencewatchingdatahostimp.h"

#include "protocolpresentitygroupsdatahostimp.h"

#include "ximpprotocolrequestcompleteeventimp.h"

#include <protocoldatahost.h>

#include "ximpdlluids.hrh"

#include "ximptrace.h"

// TODO: illegal dependency to presence operations

#include "presenceoperationdefs.h"

// ======== LOCAL FUNCTIONS ========

const TInt KPluginArrayGranularity = 3;

// ---------------------------------------------------------------------------

// OrderOfObservers()

// ---------------------------------------------------------------------------

//

TInt OrderOfObservers( const MXIMPProtocolConnectionHostObserver& aA, 

                       const MXIMPProtocolConnectionHostObserver& aB )

    {

    if( &aA < &aB )

        {

        return -1;

        }

    else if( &aA > &aB )

        {

        return 1;

        }

    return 0;

    }

// ======== MEMBER FUNCTIONS ========

using namespace NXIMPHost;

// This should be variated. Branding variation can be one

// possibility. One is to leave adaptation deside how soon

// cleanup will be done.

// Now 5 sec used for testing purposes. Better value could be

// some minutes.

const TInt KPscHostCleanerTimerLength = 5; // in sec

// ---------------------------------------------------------------------------

// CXIMPHost::CXIMPHost()

// ---------------------------------------------------------------------------

//

CXIMPHost::CXIMPHost( MXIMPProtocolConnection& aConnection, TInt32 aProtocolUid  )

: iConnection( aConnection ), iProtocolUid( aProtocolUid )

    {

    iState = NXIMPHost::EXIMPNotConnected;

    iHostOriginatedOpIndex = 1;

    iReferences = 1;

    iReqIdBuilder.SetSessionId( (unsigned) this );

    iForcedTearDown = EFalse;

    }

// ---------------------------------------------------------------------------

// CXIMPHost::ConstructL()

// ---------------------------------------------------------------------------

//

void CXIMPHost::ConstructL()

    {

    iObjFactory = CXIMPObjectFactoryImp::NewL();

    iEventManager = CXIMPEventManager::NewL();

    iPresenceDataHost = CProtocolPresenceDataHostImp::NewL( *this );

    iDataHostArray = new(ELeave)CArrayFixFlat<MProtocolDataHost*>(KPluginArrayGranularity);

    LoadDataHostArrayL() ;

/*    iDataCache = CPresenceDataCache::NewL( *this );

    iAuthDataHost = CProtocolPresenceAuthorizationDataHostImp::NewL( *this );

    iPublishingDataHost = CProtocolPresencePublishingDataHostImp::NewL( *this );

    iWatchingDataHost = CProtocolPresenceWatchingDataHostImp::NewL( *this );

    iGroupsDataHost = CProtocolPresentityGroupsDataHostImp::NewL( *this );

*/

    iCleanerTimer = CPeriodic::NewL( CActive::EPriorityStandard );

    for ( int i = 0;i < 5;i++ )

        {

        }

    iCallBack[ECompleteRequestCallback]->Set( TCallBack( CompleteRequestCallback, this ) );

    iCallBack[ECompleteAdaptationRequestCallback]->Set( TCallBack( CompleteAdaptationRequestCallback, this ) );

    iCallBack[ECompleteSessionMgmtRequestCallback]->Set( TCallBack( CompleteSessionMgmtRequestCallback, this ) );

    iCallBack[ECompleteInternalRequestCallback]->Set( TCallBack( CompleteInternalRequestCallback, this ) );

    iCallBack[EStartProcessCallback]->Set( TCallBack( StartProcessCallback, this ) );

    iAdaptationReqCompleteEvent = CXIMPProtocolRequestCompleteEventImp::NewL();

    StartCleanerTimer();

    }

// ---------------------------------------------------------------------------

// CXIMPHost::NewLC()

// ---------------------------------------------------------------------------

//

EXPORT_C CXIMPHost* CXIMPHost::NewLC( MXIMPProtocolConnection& aConnection, TInt32 aProtocolUid  )

    {

    CXIMPHost* self = new( ELeave ) CXIMPHost( aConnection, aProtocolUid );

    CleanupClosePushL( *self );

    self->ConstructL();

    return self;

    }

// ---------------------------------------------------------------------------

// CXIMPHost::~CXIMPHost()

// ---------------------------------------------------------------------------

//

CXIMPHost::~CXIMPHost()

    {

    __ASSERT_ALWAYS( iReferences == 0, User::Panic( NXIMPPrivPanic::KCategory, NXIMPPrivPanic::EHostStillReferenced ) );

    delete iCleanerTimer;

    delete iObjFactory;

    iOperations.Close();

    delete iEventManager;

    __ASSERT_ALWAYS( iCurrentOperation == 0,

                User::Panic( NXIMPPrivPanic::KCategory, NXIMPPrivPanic::EHostCurrentOperationStillActive ) );

    iRegSessions.Close();

    delete iPresenceDataHost;

    if ( iDataHostArray )

    {

    	TInt idx = KErrNotFound;

    	while( iDataHostArray->Count() )

        {

	        idx = iDataHostArray->Count() - 1;

	        // Delete object

	        delete iDataHostArray->At( idx );

	        // Delete element

	        iDataHostArray->Delete( idx );

        }

    }

    delete iDataHostArray;

  /*  delete iDataCache;

    delete iAuthDataHost;

    delete iPublishingDataHost;

    delete iWatchingDataHost;

    delete iGroupsDataHost;

*/

    // delete iCallBack;

    iCallBack.ResetAndDestroy();

    CXIMPGlobals::Instance()->HostManager()->DisassociateHost( this );

    delete iAdaptationReqCompleteEvent;

    iConnectionHostObservers.Reset();

    }

// ---------------------------------------------------------------------------

// CXIMPHost::Open()

// ---------------------------------------------------------------------------

//

void CXIMPHost::Open()

    {

    iReferences++;

    }

// ---------------------------------------------------------------------------

// CXIMPHost::Close()

// ---------------------------------------------------------------------------

//

void CXIMPHost::Close()

    {

    __ASSERT_ALWAYS( iReferences >= 0, User::Panic( NXIMPPrivPanic::KCategory, NXIMPPrivPanic::EHostNegativeReferenceCount ));

    iReferences--;

    if ( iReferences <= 0 )

        {

        delete this;

        }

    }

// ---------------------------------------------------------------------------

// Implement supported interface access.

// ---------------------------------------------------------------------------

//

XIMPIMP_IF_BASE_GET_INTERFACE_BEGIN( CXIMPHost, MXIMPProtocolConnectionHost )

XIMPIMP_IF_BASE_GET_INTERFACE_END()

XIMPIMP_IF_BASE_GET_CONST_INTERFACE_BEGIN( CXIMPHost, MXIMPProtocolConnectionHost )

XIMPIMP_IF_BASE_GET_INTERFACE_END()

// ---------------------------------------------------------------------------

// CXIMPHost::ObjectFactory()

// ---------------------------------------------------------------------------

//

MXIMPObjectFactory& CXIMPHost::ObjectFactory()

    {

    return *iObjFactory;

    }

// ---------------------------------------------------------------------------

// From MXIMPProtocolConnectionHost class.

// CXIMPHost::AuthorizationDataHost()

// ---------------------------------------------------------------------------

//

MProtocolPresenceDataHost& CXIMPHost::ProtocolPresenceDataHost()

    {

    return *iPresenceDataHost;

    }

// ---------------------------------------------------------------------------

// CXIMPHost::RegisterObserverL()

// ---------------------------------------------------------------------------

//

void CXIMPHost::RegisterObserverL(

        MXIMPProtocolConnectionHostObserver& aObserver,

        const TArray<TInt32>* aEventFilter /*= NULL*/ )

    {

    XIMP_UNUSED_FORMAL_PARAM( aEventFilter );

    TLinearOrder< MXIMPProtocolConnectionHostObserver > order( *OrderOfObservers );

    TInt error = iConnectionHostObservers.InsertInOrder( &aObserver, order );

    if( error != KErrAlreadyExists )

        {

        User::LeaveIfError( error );

        }

    }

// ---------------------------------------------------------------------------

// CXIMPHost::UnregisterConnectionHostObserver()

// ---------------------------------------------------------------------------

//

void CXIMPHost::UnregisterConnectionHostObserver(

        MXIMPProtocolConnectionHostObserver& aObserver )

    {

    TLinearOrder< MXIMPProtocolConnectionHostObserver > order( *OrderOfObservers );

    TInt index = iConnectionHostObservers.FindInOrder( &aObserver, order );

    if( index > KErrNotFound )

        {

        iConnectionHostObservers.Remove( index );

        }

    }

// ---------------------------------------------------------------------------

// CXIMPHost::HandleRequestCompleted()

// ---------------------------------------------------------------------------

//

void CXIMPHost::HandleRequestCompleted(

    TXIMPRequestId aReqId,

    TInt aResultCode )

    {

    CXIMPOperationBase& operation = OperationForRequestId( aReqId );

    operation.SetResultCode( aResultCode );

    CompleteRequest( aReqId );

    }

// ---------------------------------------------------------------------------

// CXIMPHost::HandleRequestCompleted()

// ---------------------------------------------------------------------------

//

void CXIMPHost::HandleRequestCompleted( TXIMPRequestId aReqId,

                                       MXIMPStatus* aResult )

    {

    CXIMPOperationBase& operation = OperationForRequestId( aReqId );

    operation.SetStatus( aResult );

    CompleteRequest( aReqId );

    }

// ---------------------------------------------------------------------------

// CXIMPHost::HandleRequestCompleted()

// ---------------------------------------------------------------------------

//

void CXIMPHost::HandleRequestCompleted( TXIMPRequestId aReqId,

                                       MXIMPStatus* aResult,

                                       MXIMPBase* aParameter )

    {    

    CXIMPOperationBase& operation = OperationForRequestId( aReqId );

    operation.SetObjectCollection( aParameter );

    HandleRequestCompleted( aReqId, aResult );

    }

// ---------------------------------------------------------------------------

// CXIMPHost::CompleteRequest()

// ---------------------------------------------------------------------------

//

void CXIMPHost::CompleteRequest( TXIMPRequestId aReqId )

    {

    CXIMPOperationBase& operation = OperationForRequestId( aReqId );

#ifdef _DEBUG

	if ( operation.Context() )	

		TRACE_2( _L("Operation completed for client \"%S\" with result code: %d"), 

			 	&operation.Context()->ClientInfo()->ClientId().Identity(), 

			 	operation.Status().ResultCode() );

#endif			 

    // iCallBack->Set( TCallBack( CompleteRequestCallback, this ) );

    iCallBack[ECompleteRequestCallback]->CallBack();

    }

// ---------------------------------------------------------------------------

// CXIMPHost::HandleConnectionTerminated()

// ---------------------------------------------------------------------------

//

TXIMPRequestId CXIMPHost::HandleConnectionTerminated( MXIMPStatus* aReason )

    {

	TRACE_1( _L("CXIMPHost::HandleConnectionTerminated aReason = %d"), aReason );

    // This should be set for operation as a reason.

    XIMP_UNUSED_FORMAL_PARAM( aReason );

/*

    if ( iState != EXIMPConnected )

        {

        // we are not in a valid state

        User::Panic( NXIMPPrivPanic::KCategory,

                NXIMPPrivPanic::EInvalidStateForSessionLost );

        }

*/

    TXIMPRequestId reqId;

    // tear down

    // we must run the cached unbinds to force teardown

    // Right way to do this is using non leaving operation add. This can be done

    // if operation queue is implemented as linked list. When operation queue is fixed

    // assert should be removed.

    TRAPD( error, reqId = AddNewOperationL( NXIMPOps::EXIMPForcedTeardown ) );

    __ASSERT_ALWAYS( error == KErrNone, User::Panic( _L("HandleSessionLost"), -667 ) );

    iForcedTearDown = ETrue;

    return reqId;

    }

// ---------------------------------------------------------------------------

// CXIMPHost::UnregisterSession()

// ---------------------------------------------------------------------------

//

void CXIMPHost::UnregisterSession( CXIMPPscContext* aContext )

    {

    if( !aContext )

        {

        return;

        }

    iEventManager->UnregisterSessionQueue( aContext->EventQueue() );

    TLinearOrder< CXIMPPscContext > order( *CXIMPPscContext::OrderOfContexts );

    TInt index = iRegSessions.FindInOrder( aContext, order );

    if( index >= 0 )

        {

        iPresenceDataHost->PresenceDataCache().CleanResources( *aContext );

        iRegSessions.Remove( index );

        }

    }

// ---------------------------------------------------------------------------

// CXIMPHost::FakeCompleteRequest()

// ---------------------------------------------------------------------------

//

void CXIMPHost::FakeCompleteRequest( TXIMPRequestId aReqId, TInt aResult )

    {

    HandleRequestCompleted( aReqId, aResult );

    }

// ---------------------------------------------------------------------------

// CXIMPHost::HandleAdaptationRequestCompleted()

// ---------------------------------------------------------------------------

//

void CXIMPHost::HandleAdaptationRequestCompleted( TXIMPRequestId aReqId, TInt aResult )

    {

    CXIMPOperationBase& operation = OperationForRequestId( aReqId );

    operation.SetResultCode( aResult );

    // iCallBack->Set( TCallBack( CompleteAdaptationRequestCallback, this ) );

    iCallBack[ECompleteAdaptationRequestCallback]->CallBack();

    }

// ---------------------------------------------------------------------------

// CXIMPHost::HandleSessionMgmtRequestCompleted()

// ---------------------------------------------------------------------------

//

void CXIMPHost::HandleSessionMgmtRequestCompleted( TXIMPRequestId aReqId, TInt aResult )

    {

    CXIMPOperationBase& operation = OperationForRequestId( aReqId );

    operation.SetResultCode( aResult );

    // iCallBack->Set( TCallBack( CompleteSessionMgmtRequestCallback, this ) );

    iCallBack[ECompleteSessionMgmtRequestCallback]->CallBack();

    }

// ---------------------------------------------------------------------------

// CXIMPHost::HandleInternalRequestCompleted()

// ---------------------------------------------------------------------------

//

void CXIMPHost::HandleInternalRequestCompleted( TXIMPRequestId aReqId, TInt aResult )

    {

    CXIMPOperationBase& operation = OperationForRequestId( aReqId );

    operation.SetResultCode( aResult );

    // iCallBack->Set( TCallBack( CompleteInternalRequestCallback, this ) );

    iCallBack[ECompleteInternalRequestCallback]->CallBack();

    }

// ---------------------------------------------------------------------------

// CXIMPHost::PresenceDataAccess()

// ---------------------------------------------------------------------------

//

CProtocolPresenceDataHostImp& CXIMPHost::PresenceDataAccess()

    {

    return *iPresenceDataHost;

    }

// ---------------------------------------------------------------------------

// CXIMPHost::DataAccess()

// ---------------------------------------------------------------------------

//

/*CPresenceDataCache& CXIMPHost::DataAccess()

    {

    return *iDataCache;

    }

// ---------------------------------------------------------------------------

// CXIMPHost::AuthorizationDataAccess()

// ---------------------------------------------------------------------------

//

CProtocolPresenceAuthorizationDataHostImp& CXIMPHost::AuthorizationDataAccess()

    {

    return *iAuthDataHost;

    }

// ---------------------------------------------------------------------------

// CXIMPHost::PublishingDataAccess()

// ---------------------------------------------------------------------------

//

CProtocolPresencePublishingDataHostImp& CXIMPHost::PublishingDataAccess()

    {

    return *iPublishingDataHost;

    }

// ---------------------------------------------------------------------------

// CXIMPHost::WatchingDataAccess()

// ---------------------------------------------------------------------------

//

CProtocolPresenceWatchingDataHostImp& CXIMPHost::WatchingDataAccess()

    {

    return *iWatchingDataHost;

    }

// ---------------------------------------------------------------------------

// CXIMPHost::GroupsDataAccess()

// ---------------------------------------------------------------------------

//

CProtocolPresentityGroupsDataHostImp& CXIMPHost::GroupsDataAccess()

    {

    return *iGroupsDataHost;

    }

*/

// ---------------------------------------------------------------------------

// CXIMPHost::RegisterSessionL()

// ---------------------------------------------------------------------------

//

void CXIMPHost::RegisterSessionL( CXIMPPscContext* aContext )

    {

    if( !aContext )

        {