/*

* Copyright (c) 2002 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:  One Session manager of the presence server

* 				 Handles all management concerning one network session

*  				 Opening, closing, ownership handling, updating

*  				 of Session related data to network

*

*/

// INCLUDE FILES

#include	<e32std.h>

#include    "CPEngCSPSessManager.h"

#include	"CPEngAppAccessContainer.h"

#include	"MPEngSubSession.h"

#include	"MPEngRequestHandler.h"

#include	"CPEngHandlerLogIn.h"

#include	"CPEngHandlerLogOff.h"

#include	"CPEngHandlerSendData.h"

#include	"MPEngOutgoingTransactionHandler.h"

#include	"CPEngIncomingDataHandler.h"

#include	"TPEngServerMessages.h"

#include	"MPEngServer.h"

#include	"CPEngSessionSlotId.h"

#include	"CPEngSessionSlotEvent.h"

#include	"PEngWVServices2.h"

#include	"RObjectArray.h"

#include	"PEngTransferAdapter.h"

// transaction factories

#include	"MPEngTransactionFactory.h"

#include	"PEngAttrLibFactory.h"

#include	"PEngListLibraryFactory.h"

// pure data handler

#include	"MPEngPureDataHandler.h"

#include	"MPEngAccessHandler.h"

//	Own RMessage class wraper

#include	"RPEngMessage.h"

// Debug prints

#include	"PresenceDebugPrint.h"

// CONSTANTS

const TInt KLastRefAccessCount = 1;

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

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

// CPEngCSPSessManager::CPEngCSPSessManager

// C++ default constructor can NOT contain any code, that

// might leave.

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

//

CPEngCSPSessManager::CPEngCSPSessManager(

    MPEngServer& aServer )

        : iAccessCount( 1 ), // init access count to 1

        iState( EPEngNWPresenceSessionClosed ),

        iServer( aServer ),

        iRequestHandlers( 2 ),	// not many requests at time

        iTransFactories( 3 ) // there 3 three factories

    {

    PENG_DP( D_PENG_LIT( "CPEngCSPSessManager::CPEngCSPSessManager" ) );

    }

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

// CPEngCSPSessManager::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CPEngCSPSessManager::ConstructL(

    const CPEngSessionSlotId& aSessId,

    RPEngStorageAdminClient& aAdmin )

    {

    iSessionSlotId = aSessId.CloneL();

    iAccessCounters = CObjectCon::NewL();

    // we need to set Unique ID of the containers so they own their objects

    iAccessCounters->iUniqueID = reinterpret_cast<TInt> ( this );

    HBufC8* sessId = aSessId.PackLC();

    User::LeaveIfError( iStoreAdmin.Connect( aAdmin, *sessId ) );

    CleanupStack::PopAndDestroy( sessId ); // sessId

    }

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

// CPEngCSPSessManager::NewL

// Two-phased constructor.

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

//

CPEngCSPSessManager* CPEngCSPSessManager::NewLC(

    MPEngServer& aServer,

    const CPEngSessionSlotId& aSessId,

    RPEngStorageAdminClient& aAdmin )

    {

    CPEngCSPSessManager* self = new( ELeave ) CPEngCSPSessManager( aServer );

    CleanupClosePushL( *self );

    self->ConstructL( aSessId, aAdmin );

    return self;

    }

// Destructor

CPEngCSPSessManager::~CPEngCSPSessManager()

    {

    PENG_DP( D_PENG_LIT( "CPEngCSPSessManager::~CPEngCSPSessManager" ) );

    delete iSessionSlotId;

    ResetAccessContainers();

    delete iAccessCounters;

    iRequestHandlers.ResetAndDestroy();

    // set state to the Close, so all resources are sure deleted

    iState = EPEngNWPresenceSessionClosed;

    UnloadResources();

    iIncomingHandlers.ResetAndDestroy();

    iStoreAdmin.Close();

    iServer.RemoveCSPSessManager( this );

    iServSubSessions.Reset();

#if _BullseyeCoverage

    cov_write();

#endif

    }

/////////////////////////////////////////////////////////////////////////////////

// ========== Functions from MPEngRequestHandlerObserver ========================

/////////////////////////////////////////////////////////////////////////////////

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

// CPEngCSPSessManager::CompleteRequestHandler()

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

//

void CPEngCSPSessManager::CompleteRequestHandler(

    MPEngRequestHandler* aRequestHandler )

    {

    PENG_DP( D_PENG_LIT( "CPEngCSPSessManager::CompleteRequestHandler: %d" ),

             ( TInt )aRequestHandler  );

    TInt handlerIndex ( iRequestHandlers.Find( aRequestHandler ) );

    if ( handlerIndex != KErrNotFound )

        {

        iRequestHandlers.Remove( handlerIndex );

        }

    // if we are offline and there is no more request handler, unload

    // resources

    if (

        ( iState == EPEngNWPresenceSessionClosed )

        &&

        ( iRequestHandlers.Count() == 0 )

    )

        {

        UnloadResources();

        }

    CheckReferenceAccessD();

    }

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

// CPEngCSPSessManager::SetCSPSessionOpenedL()

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

//

void CPEngCSPSessManager::SetCSPSessionOpenedL()

    {

    PENG_DP( D_PENG_LIT( "CPEngCSPSessManager::SetCSPSessionOpenedL: %d" ) );

    // Load resources

    LoadResourcesL();

    // set state to online

    iState	= EPEngNWPresenceSessionOpen;

    }

/////////////////////////////////////////////////////////////////////////////////

// ========== Functions from MPEngRequestHandlerObserver ========================

/////////////////////////////////////////////////////////////////////////////////

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

// CPEngCSPSessManager::StatusChangedL()

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

//

void CPEngCSPSessManager::StatusChangedL(

    TPEngNWSessionSlotState aNewState,

    TPEngNWSessionSlotEvent aNewEvent )

    {

    PENG_DP( D_PENG_LIT( "CPEngCSPSessManager::StatusChangedL: state:%d Event:%d" ),

             aNewState,

             aNewEvent );

    // is tate different than holder is

    if ( aNewState == iState )

        {

        // state is same, do nothing

        return;

        }

    // update state and inform about it

    iState = aNewState;

    if ( iState == EPEngNWPresenceSessionClosed )

        {

        // we are closed, unload resources

        UnloadResources();

        TInt count( iAccessCounters->Count() );

        for ( TInt x( 0 ) ; x < count ; ++x )

            {

            NotifyNewEventL( aNewEvent,

                             static_cast<CPEngAppAccessContainer*>

                             ( ( *iAccessCounters )[ x ] )->AppId(),

                             EPEngNWPresenceSessionClosed );

            }

        // remove all access containers

        ResetAccessContainers();

        }

    else if ( iState == EPEngNWPresenceSessionOpen )

        {

        LoadResourcesL();

        // Do not notify, it will be done by LogIn Handler

        }

    }

/////////////////////////////////////////////////////////////////////////////////

//======================== New Functions of main class ==========================

/////////////////////////////////////////////////////////////////////////////////

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

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

// CPEngCSPSessManager::Open()

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

//

void CPEngCSPSessManager::Open()

    {

    iAccessCount++;

    }

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

// CPEngCSPSessManager::Close()

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

//

void CPEngCSPSessManager::Close()

    {

    iAccessCount--;

    CheckReferenceAccessD();

    }

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

// CPEngCSPSessManager::OpenL()

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

//

void CPEngCSPSessManager::OpenL(

    MPEngSubSession& aServSubSession )

    {

    iServSubSessions.AppendL( &aServSubSession );

    iAccessCount++;

    }

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

// CPEngCSPSessManager::Close()

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

//

void CPEngCSPSessManager::Close(

    MPEngSubSession* aServSubSession )

    {

    TInt x( iServSubSessions.Find( aServSubSession ) );

    if ( x != KErrNotFound )

        {

        iServSubSessions.Remove( x );

        iAccessCount--;

        }

    CheckReferenceAccessD();

    }

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

// CPEngCSPSessManager::AttachAppIdL()

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

//

void CPEngCSPSessManager::AttachAppIdL(

    const TDesC& aAppId )

    {

    PENG_DP( D_PENG_LIT( "CPEngCSPSessManager::AttachAppIdL:%S" ), &aAppId );

    // allow attaching of the App Id only if CSP is opened

    LeaveIfNotConnectedL();

    CPEngAppAccessContainer* accessCounter = AccessCounter( aAppId );

    if ( accessCounter )

        {

        TInt val = accessCounter->Open(); // CSI: 65 #

        return;

        }

    // does not exist, create and append

    CPEngAppAccessContainer* newContainer =

        CPEngAppAccessContainer::NewLC( aAppId );

    iAccessCounters->AddL( newContainer );

    // notify about new App Id logging

    NotifyNewEventL( EPEngEventAppNWPresenceSessionOpened,

                     aAppId,

                     EPEngNWPresenceSessionOpen );

    CleanupStack::Pop( newContainer ); // newContainer

    }

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

// CPEngCSPSessManager::DetachAppId()

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

//

void CPEngCSPSessManager::DetachAppId(

    const TDesC& aAppId )

    {

    PENG_DP( D_PENG_LIT( "CPEngCSPSessManager::DetachAppId:%S " ), &aAppId );

    CPEngAppAccessContainer* accessCounter = AccessCounter( aAppId );

    TBool notify( EFalse );

    if ( accessCounter )

        {

        notify = accessCounter->CloseAccess();

        }

    if ( iState == EPEngNWPresenceSessionClosed )

        {

        // no need to notify, it was already done

        notify = EFalse;

        }

    // do we need to do Log Out from CSP?

    else if ( !( iAccessCounters->Count() ) )

        {

        // quite brutal, but unload everything, we cannot do lot more

        iRequestHandlers.ResetAndDestroy();

        UnloadResources();

        iState = EPEngNWPresenceSessionClosed;

        notify = ETrue;

        }

    // notify event

    if ( notify )

        {

        TRAP_IGNORE( NotifyNewEventL( EPEngEventAppNWPresenceSessionClosed,

                                      aAppId,

                                      EPEngNWPresenceSessionClosed ) );

        }

    CheckReferenceAccessD();

    }

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

// CPEngCSPSessManager::AppIdActiveL()

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

//

void CPEngCSPSessManager::AppIdActiveL(

    const TDesC& aAppId )

    {

    PENG_DP( D_PENG_LIT( "CPEngCSPSessManager::AppIdActiveL:%S" ), &aAppId );

    CPEngAppAccessContainer* accessCounter = AccessCounter( aAppId );

    if ( !accessCounter )

        {

        User::Leave( KErrNotReady );

        }

    }

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

// CPEngCSPSessManager::ReserveProcessL()

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

//

void CPEngCSPSessManager::ReserveProcessL(

    const TDesC& aAppId,

    const TDesC& aProcessId )

    {

    PENG_DP( D_PENG_LIT( "CPEngCSPSessManager::ReserveProcessL: %S : %S" ),

             &aAppId,

             &aProcessId );

    CPEngAppAccessContainer* accessCounter = AccessCounter( aAppId );

    if ( accessCounter )

        {

        accessCounter->ReserveProcessL( aProcessId );

        return;

        }

    // does not exist, leave

    User::Leave( KErrNotFound );

    }

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

// CPEngCSPSessManager::ActivateProcessL()

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

//

void CPEngCSPSessManager::ActivateProcessL(

    const TDesC& aAppId,

    const TDesC& aProcessId )

    {

    PENG_DP( D_PENG_LIT( "CPEngCSPSessManager::ReserveProcessL: %S : %S" ),

             &aAppId,

             &aProcessId );

    CPEngAppAccessContainer* accessCounter = AccessCounter( aAppId );

    if ( accessCounter )

        {

        // it will leave if not find

        accessCounter->ActivateProcessIdL( aProcessId );

        return;

        }

    User::Leave( KErrNotReady );

    }

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

// CPEngCSPSessManager::SessionId()

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

//

const CPEngSessionSlotId& CPEngCSPSessManager::SessionId() const

    {

    return *iSessionSlotId;

    }

////////////////////////////////////////////////////////////////////////////////

// =========== New Function for Request handling ===============================

////////////////////////////////////////////////////////////////////////////////

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

// CPEngCSPSessManager::HandleAsynchronousRequestL()

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

//

void  CPEngCSPSessManager::HandleAsynchronousRequestL(

    const RPEngMessage& aMessage,

    MPEngSubSession& aServSubSession,

    TInt32 aServSessionId,

    TInt   aServSubSessionId )

    {

    PENG_DP( D_PENG_LIT( "CPEngCSPSessManager::HandleAsynchronousRequestL:%d" ),

             aMessage.Function() );

    TInt function( aMessage.Function() );

    // first check that this kind of request is allowed

    CheckRequestValidityL( function, aServSessionId, aServSubSessionId );

    // request can be proceeded

    switch ( function )

        {

        case ESubSessUpdateData:

            {

            HandleUpdateDataRequestL( aMessage,

                                      aServSubSession,

                                      aServSessionId,

                                      aServSubSessionId );

            break;

            }

        default:

            {

            User::Leave( KErrNotSupported );

            }

        }

    }

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

// CPEngCSPSessManager::HandleSynchronousRequestL()

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

//

void  CPEngCSPSessManager::HandleSynchronousRequestL(

    const RPEngMessage& aMessage,

    TInt32 /* aServSessionId */,

    TInt /* aServSubSessionId */ )

    {

    PENG_DP( D_PENG_LIT( "CPEngCSPSessManager::HandleSynchronousRequestL:%d" ),

             aMessage.Function() );

    // first check that this kind of request is allowed

    TInt function( aMessage.Function() );

    switch ( function )

        {

            // Get Session service tree

        case ESubSessGetServiceTree:

            {

            LeaveIfNotConnectedL();

            TPckgBuf<TPEngWVCspServicesTree2> serviceTree(

                iAccessHandler->ServiceCapabilities() );

            aMessage.WriteOneDescriptorL( KMessageSlot0, serviceTree );

            break;

            }

        // get Session Log in data

        case ESubSessGetLogInData:

            {

            LeaveIfNotConnectedL();

            TInt err( aMessage.WriteOneDescriptor( KMessageSlot0,

                                                   iAccessHandler->LogInData() ) );

            if ( err == KErrOverflow )

                {

                User::Leave( iAccessHandler->LogInData().Length() );

                }

            User::LeaveIfError( err );

            break;

            }

        default:

            {

            User::Leave( KErrNotSupported );

            break;

            }

        }

    }

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

// CPEngCSPSessManager::HandleLogInRequestL