/*
* 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:  Presence Server sub-session handler implementation
*                All clients sub-session related request are handler here
*
*/



// INCLUDE FILES
#include    <e32std.h>
#include    "CPEngSubSession.h"
#include    "TPEngServerMessages.h"
#include    "TPEngServerCommon.h"

#include    "MPEngServer.h"
#include    "RPEngMessage.h"
#include    "CPEngSessionSlotId.h"
#include    "CPEngCSPSessManager.h"


namespace
    {
    void LeaveIfNotAttachedL( TBool aAttached )
        {
        if ( !aAttached )
            {
            User::Leave( KErrNotReady );
            }
        }

    void LeaveIfAttachedL( TBool aAttached )
        {
        if ( aAttached )
            {
            User::Leave( KErrAlreadyExists );
            }
        }
    }

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

// -----------------------------------------------------------------------------
// CPEngSubSession::CPEngSubSession
// C++ default constructor can NOT contain any code, that
// might leave.
// -----------------------------------------------------------------------------
//
CPEngSubSession::CPEngSubSession(
    TInt32 aSessionId )
        : iSessionId( aSessionId )
    {
    }

// -----------------------------------------------------------------------------
// CPEngSubSession::ConstructL
// Symbian 2nd phase constructor can leave.
// -----------------------------------------------------------------------------
//
void CPEngSubSession::ConstructL(
    MPEngServer& aServer,
    const RPEngMessage& aMessage )
    {
    // app Id
    iType = aMessage.Function();
    iAppId = aMessage.ReadOneDescriptor16L( KMessageSlot1 );

    // Read session id from the message
    HBufC8* sessIdBuff = aMessage.ReadOneDescriptor8LC( KMessageSlot0 );
    CPEngSessionSlotId* sessId = CPEngSessionSlotId::NewLC();
    sessId->UnPackL( * sessIdBuff );

    // get Session manager from the server
    CPEngCSPSessManager* sessMan = aServer.CSPSessionManagerLC( *sessId );

    // if this is transaction sub session, check app Id validity
    if ( iType == EMainSessCreateTransactionSubSession )
        {
        sessMan->AppIdActiveL( *iAppId );
        }
    // open reference to the CPS holder
    sessMan->OpenL( *this );
    iSessionManager = sessMan;
    CleanupStack::PopAndDestroy( 3 ); // sessMan, sessId, sessIdBuff
    }

// -----------------------------------------------------------------------------
// CPEngSubSession::NewL
// Two-phased constructor.
// -----------------------------------------------------------------------------
//
CPEngSubSession* CPEngSubSession::NewL(
    MPEngServer& aServer,
    const RPEngMessage& aMessage,
    TInt32 aSessionId )
    {
    CPEngSubSession* self = NewLC( aServer, aMessage, aSessionId );

    CleanupStack::Pop(); // self

    return self;
    }

// -----------------------------------------------------------------------------
// CPEngSubSession::NewLC
// Two-phased constructor.
// -----------------------------------------------------------------------------
//
CPEngSubSession* CPEngSubSession::NewLC(
    MPEngServer& aServer,
    const RPEngMessage& aMessage,
    TInt32 aSessionId )
    {
    CPEngSubSession* self = new( ELeave ) CPEngSubSession( aSessionId );

    CleanupClosePushL( *self );
    self->ConstructL( aServer, aMessage );
    return self;
    }

// Destructor
CPEngSubSession::~CPEngSubSession()
    {
    // decrease count of state machine
    if ( iSessionManager )
        {
        iSessionManager->CancelAllSubSessionRquests( iSessionId, iHandle );
        iSessionManager->Close( this ); // normal reference
        if ( iAppIdAttached )
            {
            // remove appId reference
            iSessionManager->DetachAppId( *iAppId );
            }
        }
    delete iAppId;
    delete iRequestResult;
    }

// =============================================================================
// =========== New Functions of the MPengSubSession class ======================
// =============================================================================

// -----------------------------------------------------------------------------
// CPEngSubSession::StoreRequestResponse()
// Store request response for the sub-session
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CPEngSubSession::StoreRequestResponse(
    HBufC8* aResponse )
    {
    delete iRequestResult;
    iRequestResult = aResponse;
    }

// -----------------------------------------------------------------------------
// CPEngSubSession::AppId()
// Application Id of the sub-session
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
TDesC& CPEngSubSession::AppId()
    {
    return *iAppId;
    }

// -----------------------------------------------------------------------------
// CPEngSubSession::HandleLogInL()
// Handler successful application Id login
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CPEngSubSession::HandleLogInL()
    {
    // remove normal reference by the app Id reference
    iSessionManager->AttachAppIdL( *iAppId );
    iAppIdAttached = ETrue;
    }

// -----------------------------------------------------------------------------
// CPEngSubSession::HandleLogOut()
// Handler successful application Id logOut
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CPEngSubSession::HandleLogOut()
    {
    if ( iAppIdAttached )
        {
        iSessionManager->DetachAppId( *iAppId );
        iAppIdAttached = EFalse;
        }
    }

// -----------------------------------------------------------------------------
// CPEngSubSession::DisconnectAppId()
// Disconnect Application Id
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CPEngSubSession::DisconnectAppId(
    const TDesC& aAppId )
    {
    if ( iAppId->Compare( aAppId ) != KErrNone )
        {
        // not our app Id
        return;
        }
    iAppIdAttached = EFalse;
    }

// -----------------------------------------------------------------------------
// CPEngSubSession::DisconnectAppId()
// Handle CSP closing
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CPEngSubSession::CSPSessionClosed()
    {
    iAppIdAttached = EFalse;
    }

// =============================================================================
// =============== Functions of the main class =================================
// =============================================================================

// -----------------------------------------------------------------------------
// CPEngSubSession::DispatchMessageL()
// Dispatch message from the client
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
TBool CPEngSubSession::DispatchMessageL(
    const RPEngMessage& aMessage,
    TInt aRequest )
    {
    TBool completeMessage( ETrue );
    switch ( aRequest )
        {
            // Storage Related Requests
        case ESubSessCancelRequest:
            {
            iSessionManager->CancelAsynchronousRequest( aMessage,
                                                        iSessionId,
                                                        iHandle );
            break;
            }

        // Holder client
        case ESubSessLogIn:
            {
            iSessionManager->HandleLogInRequestL( aMessage,
                                                  *this,
                                                  iSessionId,
                                                  iHandle );
            completeMessage = EFalse;
            break;
            }

        case ESubSessForceLogOut:
            {
            LeaveIfNotAttachedL( iAppIdAttached );
            iSessionManager->HandleForceLogOutRequestL( aMessage,
                                                        *this,
                                                        iSessionId,
                                                        iHandle );
            completeMessage = EFalse;
            break;
            }

        case ESubSessAttachHolder:
            {
            LeaveIfAttachedL( iAppIdAttached );
            iSessionManager->AttachAppIdL( *iAppId );
            iAppIdAttached = ETrue;
            break;
            }

        case ESubSessAttachWithProcessName:
            {
            LeaveIfAttachedL( iAppIdAttached );
            HBufC* processName = aMessage.ReadOneDescriptor16LC(
                                     KMessageSlot0 );

            iSessionManager->ActivateProcessL( *iAppId, *processName );
            iAppIdAttached = ETrue;
            CleanupStack::PopAndDestroy(); // processName
            break;
            }

        case ESubSessDetachHolder:
            {
            LeaveIfNotAttachedL( iAppIdAttached );
            iSessionManager->HandleDetachAppIdL( aMessage,
                                                 *this,
                                                 iSessionId,
                                                 iHandle );
            completeMessage = EFalse;
            break;
            }

        case ESubSessLeaveAlive:
            {
            LeaveIfNotAttachedL( iAppIdAttached );
            HBufC* processName = aMessage.ReadOneDescriptor16LC(
                                     KMessageSlot0 );

            iSessionManager->ReserveProcessL( *iAppId, *processName );
            iAppIdAttached = EFalse;
            CleanupStack::PopAndDestroy(); // processName
            break;
            }

        case ESubSessGetServiceTree:
        case ESubSessGetLogInData:
            {
            iSessionManager->HandleSynchronousRequestL( aMessage,
                                                        iSessionId,
                                                        iHandle );
            break;
            }

        // Transfer client
        case ESubSessUpdateData:
            {
            iSessionManager->HandleAsynchronousRequestL( aMessage,
                                                         *this,
                                                         iSessionId,
                                                         iHandle );
            completeMessage = EFalse;
            break;
            }

        case ESubSessFetchUpdateRqstResult:
            {
            FetchRequestresultL( aMessage );
            break;
            }

        default:
            {
            PanicClient( aMessage, EPECBadRequest );
            break;
            }
        }
    // check if message can be completed
    completeMessage &= aMessage.MessageValid();
    return completeMessage;
    }

// -----------------------------------------------------------------------------
// CPEngSubSession::SetSubSesionHandle()
// Set Sub-session handle ID for the Session
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CPEngSubSession::SetSubSesionHandle(
    TInt aHandle )
    {
    iHandle = aHandle;
    }

// =============================================================================
// =============== Private Functions from base class ===========================
// =============================================================================

// -----------------------------------------------------------------------------
// CPEngSubSession::PanicClient()
// Panic client
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CPEngSubSession::PanicClient(
    const RPEngMessage& aMessage,
    const TInt aPanic ) const
    {
    aMessage.Panic( KSessionName, aPanic );
    }

// -----------------------------------------------------------------------------
// CPEngSubSession::FetchRequestresultL()
// Fetch result of last asynchronous request
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CPEngSubSession::FetchRequestresultL(
    const RPEngMessage& aMessage )
    {
    if ( !iRequestResult )
        {
        User::Leave( KErrNotFound );
        }
    aMessage.WriteOneDescriptorL( KMessageSlot0, *iRequestResult );
    delete iRequestResult;
    iRequestResult = NULL;
    }

//  End of File