/*
* Copyright (c) 2010 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: Implementation of server session class.
*
*/

#include "posindicatorserversession.h"
#include "posindicatorservercore.h"
#include "posindicatorserversubsession.h"
#include "posindicatorserverconst.h"
#include "posindicatorsubsessionregistry.h"
#include "posindicatorlogger.h"

//---------------------------------------------------------------
// CPosIndicatorServerSession::NewL
//---------------------------------------------------------------
CPosIndicatorServerSession* CPosIndicatorServerSession::NewL(
                            const CPosIndicatorServerCore& aServerCore )
    {
    FUNC("CPosIndicatorServerSession::NewL");
    CPosIndicatorServerSession* self = new( ELeave )
                                  CPosIndicatorServerSession( aServerCore );
    CleanupStack::PushL( self );
    self->ConstructL();
    CleanupStack::Pop( self );
    return self;
    }

//---------------------------------------------------------------
// CPosIndicatorServerSession::CPosIndicatorServerSession
//---------------------------------------------------------------
CPosIndicatorServerSession::CPosIndicatorServerSession(
                            const CPosIndicatorServerCore& aServerCore ):
                            iServerCore( aServerCore )
    {
    FUNC("CPosIndicatorServerSession::CPosIndicatorServerSession");
    }

// ---------------------------------------------------------------------------
// CPosIndicatorServerSession::~CPosIndicatorServerSession
// Destructor
// ---------------------------------------------------------------------------
//
CPosIndicatorServerSession::~CPosIndicatorServerSession()
    {
    FUNC("CPosIndicatorServerSession::~CPosIndicatorServerSession");
    delete iSubSessionRegistry;
    iServerCore.HandleSessionClosure();
    }

// ---------------------------------------------------------------------------
// CPosIndicatorServerSession::ConstructL()
// 2nd phase constructor for instantiating member variables
// ---------------------------------------------------------------------------
void CPosIndicatorServerSession::ConstructL()
    {
    FUNC("CPosIndicatorServerSession::ConstructL");
    iSubSessionRegistry = CPosIndicatorSubSessionRegistry::NewL();
    }

//---------------------------------------------------------------
// CPosIndicatorServerSession::SecureId
//---------------------------------------------------------------
void CPosIndicatorServerSession::ServiceL( const RMessage2 &aMessage )
    {
    FUNC("CPosIndicatorServerSession::ServiceL");
    switch( aMessage.Function() )
        {
        case ESubSessionOpen:
            {
            FUNC("ESubSessionOpen");
            CreateSubSessionL( aMessage );                
            break;
            }
        case ESubSessionClose:
            {
            FUNC("ESubSessionClose");
            // Close the sub-session and free the sub-session object
            TInt retVal = iSubSessionRegistry->CloseSubSession( aMessage.Int3() );
            aMessage.Complete( retVal );
            break;
            }
        default: // Forward other messages to the sub-session
            {
            ForwardToSubSessionL( aMessage );
            break;
            }
        }
    }

//---------------------------------------------------------------
// CPosIndicatorServerSession::SecureId
//---------------------------------------------------------------
void CPosIndicatorServerSession::ServiceError( const RMessage2& aMessage,
                                               TInt aError )
    {
    FUNC("CPosIndicatorServerSession::ServiceError");
    aMessage.Complete( aError );
    }

//---------------------------------------------------------------
// CPosIndicatorServerSession::Disconnect
//---------------------------------------------------------------
void CPosIndicatorServerSession::Disconnect( const RMessage2& aMessage )
    {
    FUNC("CPosIndicatorServerSession::Disconnect");
    CSession2::Disconnect( aMessage );
    }

// ---------------------------------------------------------------------------
// CPosIndicatorServerSession::CreateSubSessionL
// ---------------------------------------------------------------------------
//
void CPosIndicatorServerSession::CreateSubSessionL( const RMessage2& aMessage )
    {
    FUNC("CPosIndicatorServerSession::CreateSubSessionL");
    CPosIndicatorServerSubsession* subSession = 
                        CPosIndicatorServerSubsession::NewL(
                                    *iServerCore.GetLocationRequestorHandle());
    CleanupStack::PushL( subSession );
    // If the NewL cannot allocate then it leaves with KErrMemory. In such a
    // scenario the ServiceError is invoked which responds to the IPC message
    // with the error code. Hence no special handling is required for
    // KErrNoMemory here.

    TInt subSessionHandle = iSubSessionRegistry->AddSubSessionL( subSession );
    CleanupStack::Pop(subSession); // subSession ownership taken by registry
   
    // Set the client subsession identifier.    
    TPckg<TInt> handlePackage( subSessionHandle );    
    TInt retVal = aMessage.Write( KParamSubsessionHandle,handlePackage );

    // The error code from Write has to be handled as below,
    // If the retVal is an error code then 
    //      close the open subsession first.
    //      If error is KErrBadDescriptor then panic the client
    //      else complete the message with the error code.
    // else complete the message with KErrNone.
    if ( retVal != KErrNone )
        {
        // close the open subsession first.
        iSubSessionRegistry->CloseSubSession( subSessionHandle );     
        }
    aMessage.Complete( retVal );
    }

// ---------------------------------------------------------------------------
// CPosIndicatorServerSession::ForwardToSubSessionL
// ---------------------------------------------------------------------------
void CPosIndicatorServerSession::ForwardToSubSessionL(const RMessage2& aMessage)
    {
    FUNC("CPosIndicatorServerSession::ForwardToSubSessionL");
    CPosIndicatorServerSubsession* subSession = 
            iSubSessionRegistry->SubSessionFromHandle(aMessage.Int3());
            
    if (!subSession)
        {
        // Complete client's request if the sub-session handle is not 
        // present in the registry
        aMessage.Complete( KErrNotFound );              
        }
    else
        {
        subSession->ServiceL(aMessage);
        }
    }
// End of file.