/*
* Copyright (c) 2002-2009 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:  The Sat Server session manages a connection to a client and
*                handles client requests.
*
*/


#include    <fbs.h>
#include    "MSatUtils.h"
#include    "CSatIconHandler.h"
#include    "CSatSSession.h"
#include    "CSatSUiSubSession.h"
#include    "CSatSServer.h"
#include    "EnginePanic.h"
#include    "SatLog.h"
#include    "TSatEventMediator.h"
#include    "SatSOpcodes.h"
#include    "MSatApi.h"
#include    "MSatUtils.h"
#include    "CSatSRefreshSubSession.h"
#include    "MThreadDeathNotifier.h"
#include    "CSatSIconSubSession.h"

const TUint8 KHandleParam( 3 );

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

// -----------------------------------------------------------------------------
// Class constructor
// -----------------------------------------------------------------------------
//
CSatSSession::CSatSSession(
    CSatSServer* aServer,
    TSatEventMediator& aEventMediator,
    MSatApi& aSatApi,
    MThreadDeathNotifier& aThreadDeathNotifier ) :
    CSession2(),
    iSatServer( aServer ),
    iEventMediator( aEventMediator ),
    iSatApi( aSatApi ),
    iThreadDeathNotifier( aThreadDeathNotifier )
    {
    LOG( SIMPLE, "SATENGINE: CSatSSession::CSatSSession calling-exiting" )
    }

// -----------------------------------------------------------------------------
// Two-phased constructor
// -----------------------------------------------------------------------------
//
CSatSSession* CSatSSession::NewL(
    CSatSServer* aServer,
    TSatEventMediator& aEventMediator,
    MSatApi& aSatApi,
    MThreadDeathNotifier& aThreadDeathNotifier )
    {
    LOG( SIMPLE, "SATENGINE: CSatSSession::NewL calling" )

    // Perform construction.
    CSatSSession* self =
        new ( ELeave ) CSatSSession(
            aServer,
            aEventMediator,
            aSatApi,
            aThreadDeathNotifier );

    CleanupStack::PushL( self );
    self->ConstructL();
    CleanupStack::Pop( self );

    LOG( SIMPLE, "SATENGINE: CSatSSession::NewL exiting" )
    return self;
    }

// -----------------------------------------------------------------------------
// Destructor
// -----------------------------------------------------------------------------
//
CSatSSession::~CSatSSession()
    {
    LOG( SIMPLE, "SATENGINE: CSatSSession::~CSatSSession calling" )

    delete iSubSessionIx;
    delete iSubSessionCon;

    iSatServer = NULL;
    iUiSubSession = NULL;

    LOG( SIMPLE, "SATENGINE: CSatSSession::~CSatSSession exiting" )
    }

// -----------------------------------------------------------------------------
// CSatSSession::ConstructL
// -----------------------------------------------------------------------------
//
void CSatSSession::ConstructL()
    {
    LOG( SIMPLE, "SATENGINE: CSatSSession::ConstructL calling" )

    iSubSessionCon = iSatServer->CreateNewContainerL();
    iSubSessionIx = CObjectIx::NewL();

    LOG( SIMPLE, "SATENGINE: CSatSSession::ConstructL exiting" )
    }

// -----------------------------------------------------------------------------
// CSatSSession::UiSubSession
// -----------------------------------------------------------------------------
//
MSatUiSession* CSatSSession::UiSubSession()
    {
    LOG( DETAILED, "SATENGINE: CSatSSession::UiSubSession calling" )

    MSatUiSession* session = iUiSubSession;

    LOG( DETAILED, "SATENGINE: CSatSSession::UiSubSession exiting" )
    return session;
    }

// -----------------------------------------------------------------------------
// CSatSSession::CloseSubSession
// -----------------------------------------------------------------------------
TBool CSatSSession::CloseSubSession( const RMessage2& aMessage )
    {
    LOG( SIMPLE, "SATENGINE: CSatSSession::CloseSubSession calling" )

    // If subssession exists, return TRUE. Otherwise, return FALSE
    TInt result = ETrue;
    // Read the handle from client.
    const TInt handle( aMessage.Int3() );

    // Check that subsession exists before deleting the subsession
    if ( iSubSessionIx->At( handle ) )
        {
        LOG(
        SIMPLE, "SATENGINE: CSatSSession::CloseSubSession subsession exists" )
        // Delete the sub-session.
        iSubSessionIx->Remove( handle );
        }
    else
        {
        LOG( SIMPLE, 
        "SATENGINE: CSatSSession::CloseSubSession subsession doesn't exist" )
        // Sub-session handle was not valid.
        PanicClient( aMessage, ESatSBadDescriptor );
        result = EFalse;
        }

    LOG( SIMPLE, "SATENGINE: CSatSSession::CloseSubSession exiting" )
    return result;
    }

// -----------------------------------------------------------------------------
// CSatSSession::GetSubSessionFromHandle
// Returns the subsession which handle is aHandle.
// -----------------------------------------------------------------------------
CSatSSubSession* CSatSSession::GetSubSessionFromHandle( TInt aHandle ) const
    {
    LOG( DETAILED, "SATENGINE: CSatSSession::GetSubSessionFromHandle calling" )

    CSatSSubSession* session =
        static_cast<CSatSSubSession*>( iSubSessionIx->At( aHandle ) );

    LOG( DETAILED, "SATENGINE: CSatSSession::GetSubSessionFromHandle exiting" )
    return session;
    }

// -----------------------------------------------------------------------------
// CSatSSession::AddSubSessionL
// -----------------------------------------------------------------------------
void CSatSSession::AddSubSessionL(
    CSatSSubSession* aSubSession,
    const RMessage2& aMessage )
    {
    LOG( SIMPLE, "SATENGINE: CSatSSession::AddSubSessionL calling" )

    __ASSERT_ALWAYS( aSubSession, PanicSatEngine( ESatEngineNullPointer ) );

    CleanupStack::PushL( aSubSession );
    iSubSessionCon->AddL( aSubSession );
    const TInt handle( iSubSessionIx->AddL( aSubSession ) );
    CleanupStack::Pop( aSubSession );

    // Send the handle to client.
    TPckg<TInt> handlePckg( handle );
    TRAPD( err, aMessage.WriteL( KHandleParam, handlePckg ) );

    if ( KErrNone != err )
        {
        // Remove the handle, will also cause destruction
        // of session.
        iSubSessionIx->Remove( handle );
        LOG2( SIMPLE, 
        "SATENGINE: CSatSSession::AddSubSessionL panic: %i", err )
        PanicClient( aMessage, ESatSBadDescriptor );
        User::Leave( err ); 
        }

    LOG( SIMPLE, "SATENGINE: CSatSSession::AddSubSessionL exiting" )
    }

// -----------------------------------------------------------------------------
// CSatSSession::ServiceL
// Dispatches the commands to their appropriate handlers. For asynchronous
// messages, the message object is save for future processing.
// -----------------------------------------------------------------------------
//
void CSatSSession::ServiceL( const RMessage2& aMessage )
    {
    LOG( SIMPLE, "SATENGINE: CSatSSession::ServiceL calling" )

    if ( !aMessage.HasCapability( ECapabilityReadDeviceData ) )
        {
        // Legal client should at least have ReadDeviceData capability
        LOG( SIMPLE, "SATENGINE: CSatSSession::ServiceL client \
        has no ReadDeviceData capability. Panic it" )
        PanicClient( aMessage, ESatSBadDescriptor );
        }
    else
        {
        // Client has enough capability
        
        LOG2( NORMAL, "SATENGINE: CSatSSession::ServiceL \
              aMessage.Function is %d", aMessage.Function() )

        switch ( aMessage.Function() )
            {
            //  Ui Sub-session indicator.
            case ESatSOpenUiSubSession:
                {
                LOG( SIMPLE, 
                "SATENGINE: CSatSSession::ServiceL ESatSOpenUiSubSession" )
                CSatSUiSubSession* subsession = CSatSUiSubSession::NewL(
                    *this,
                    iSatApi,
                    iEventMediator );

                TRAPD( err, AddSubSessionL( subsession, aMessage ) );
                if ( KErrNone == err )
                    {
                    // Store the ui clients thread handle.
                    RThread uiClientThread;
                    User::LeaveIfError( aMessage.Client( uiClientThread ) );

                    iUiSubSession = subsession;

                    // Start observing threads state
                    TThreadId threadId = uiClientThread.Id();
                    iThreadDeathNotifier.SetObserveredThread( threadId );
                    iThreadDeathNotifier.StartObservingThread();
                    uiClientThread.Close();

                    // Complete message before notifying SAT Server since notifying may
                    // be very time consuming operation dependening on the situation
                    aMessage.Complete( KErrNone );

                    // Event has to be send after the iUiSubSession has been set.
                    // Otherwise NULL pointer error in commandhandlers.
                    iEventMediator.Notify( MSatUtils::ESatUiLaunched );
                    }
                break;
                }

            case ESatSOpenRefreshSubSession:
                {
                LOG( SIMPLE, 
                "SATENGINE: CSatSSession::ServiceL ESatSOpenRefreshSubSession" )
                CSatSRefreshSubSession* subsession = CSatSRefreshSubSession::NewL(
                    *this,
                    iEventMediator );
                
                TRAPD( err, AddSubSessionL( subsession, aMessage ) );
                if ( KErrNone == err )
                    {
                    aMessage.Complete( KErrNone );
                    }
                break;
                }

            case ESatSOpenIconSubSession:
                {
                LOG( SIMPLE, 
                "SATENGINE: CSatSSession::ServiceL ESatSOpenIconSubSession" )
                CSatSIconSubSession* subsession = CSatSIconSubSession::NewL(
                    *this,
                    iEventMediator );

                TRAPD( err, AddSubSessionL( subsession, aMessage ) );
                if ( KErrNone == err )
                    {
                    aMessage.Complete( KErrNone );
                    }
                break;
                }

            case ESatSCloseUiSubSession:
                {
                LOG( SIMPLE, 
                "SATENGINE: CSatSSession::ServiceL ESatSCloseUiSubSession" )
                iEventMediator.Notify( MSatUtils::ESatUiClosed );
                iSatUiSubSessionClosed = ETrue;
                iUiSubSession = NULL;
                if ( CloseSubSession( aMessage ) )
                    {
                    aMessage.Complete( KErrNone );
                    }
                break;
                }

            case ESatSCloseRefreshSubSession:
                {
                LOG( SIMPLE, 
                "SATENGINE: CSatSSession::ServiceL ESatSCloseRefreshSubSession" )
                if ( CloseSubSession( aMessage ) )
                    {
                    aMessage.Complete( KErrNone );
                    }
                break;
                }

            case ESatSCloseIconSubSession:
                {
                LOG( SIMPLE, 
                "SATENGINE: CSatSSession::ServiceL ESatSCloseIconSubSession" )
                if ( CloseSubSession( aMessage ) )
                    {
                    aMessage.Complete( KErrNone );
                    }
                break;
                }

            default:
                {
                LOG( SIMPLE, "SATENGINE: CSatSSession::ServiceL others" )
                CSatSSubSession* subsession =
                    GetSubSessionFromHandle( aMessage.Int3() );

                if ( NULL != subsession )
                    {
                    LOG( SIMPLE, 
                    "SATENGINE: CSatSSession::ServiceL NULL != subsession" )
                    subsession->HandleCommandL( aMessage );
                    }
                else
                    {
                    PanicClient( aMessage, ESatSBadDescriptor );
                    }
                }
            }
        }
        LOG( SIMPLE, "SATENGINE: CSatSSession::ServiceL exiting" )
    }

// -----------------------------------------------------------------------------
// CSatSSession::PanicClient
// Panics the client.
// -----------------------------------------------------------------------------
//
void CSatSSession::PanicClient( const RMessage2& aMessage, TInt aPanic ) const
    {
    LOG( SIMPLE, "SATENGINE: CSatSSession::PanicClient calling" )

    _LIT( KTxtServer, "SatS server" );
    aMessage.Panic( KTxtServer, aPanic );

    LOG( SIMPLE, "SATENGINE: CSatSSession::PanicClient exiting" )
    }

// -----------------------------------------------------------------------------
// CSatSSession::NotifyThreadDeathMonitor
// Notifies ThreadDeathMonitor for thread is dying
// -----------------------------------------------------------------------------
//
void CSatSSession::NotifyThreadDeathMonitor()
    {
    LOG( SIMPLE, "SATENGINE: CSatSSession::NotifyThreadDeathMonitor calling" )

    iThreadDeathNotifier.NotifyThreadDeath();

    LOG( SIMPLE, "SATENGINE: CSatSSession::NotifyThreadDeathMonitor exiting" )
    }

// -----------------------------------------------------------------------------
// CSatSSession::SatServer
// Returns pointer to SatServer - class
// -----------------------------------------------------------------------------
//
CSatSServer* CSatSSession::SatServer()
    {
    LOG( SIMPLE, "SATENGINE: CSatSSession::SatServer calling-exiting" )
    return iSatServer;
    }

// -----------------------------------------------------------------------------
// CSatSSession::UiSessionClosed
// Notifies SatEngine that UI session has closed
// -----------------------------------------------------------------------------
//
void CSatSSession::UiSessionClosed()
    {
    LOG( SIMPLE, "SATENGINE: CSatSSession::UiSessionClosed calling" )

    if ( !iSatUiSubSessionClosed )
        {
        LOG( SIMPLE, "SATENGINE: CSatSSession::UiSessionClosed close satui" )
        iEventMediator.Notify( MSatUtils::ESatUiClosed );
        iSatUiSubSessionClosed = ETrue;
        }

    LOG( SIMPLE, "SATENGINE: CSatSSession::UiSessionClosed exiting" )
    }

// -----------------------------------------------------------------------------
// CSatSSession::CreateIconHandlerL
// Creates and returns CSatIconHandler
// -----------------------------------------------------------------------------
//
MSatSIconAPI* CSatSSession::CreateIconHandlerL()
    {
    LOG( SIMPLE, "SATENGINE: CSatSSession::CreateIconHandlerL calling-exiting" )
    return new( ELeave ) CSatIconHandler( iSatApi );
    }