/*

* Copyright (c) 2002-2008 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:  Ui sub session.

*

*/

// INCLUDE FILES

#include    <e32property.h>

#include    "CSatSUiSubSession.h"

#include    "CSatSSession.h"

#include    "CSatSServer.h"

#include    "CSatCommandHandler.h"

#include    "CSatCommandContainer.h"

#include    "MSatApi.h"

#include    "EnginePanic.h"

#include    "SatLog.h"

#include    "SATInternalPSKeys.h"

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

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

// CSatSUiSubSession::CSatSUiSubSession

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

// might leave.

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

//

//lint -e{1403, 1769} Can not be initialized, harmless.

CSatSUiSubSession::CSatSUiSubSession(

    CSatSSession& aSession,

    MSatApi& aSatApi,

    TSatEventMediator& aEventMediator ) // Session

    :

    CSatSSubSession( aSession ),

    iEventData(),

    iEventDataPckg( iEventData ),

    iSatApi( aSatApi ),

    iEventMediator( aEventMediator )

    {

    LOG( SIMPLE,

        "SATENGINE: CSatSUiSubSession::CSatSUiSubSession calling - exiting" )

    }

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

// CSatSUiSubSession::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CSatSUiSubSession::ConstructL()

    {

    LOG( SIMPLE, "SATENGINE: CSatSUiSubSession::ConstructL calling" )

    iEventMediator.RegisterL( this, MSatUtils::ESmsSent );

    // Get registered service requests from MSatUtils.

    iServiceRequest = iSession.SatServer()->SatUtils()->ServiceRequests();

    LOG( SIMPLE, "SATENGINE: CSatSUiSubSession::ConstructL exiting" )

    }

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

// CSatSUiSubSession::NewL

// Two-phased constructor.

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

//

CSatSUiSubSession* CSatSUiSubSession::NewL(

    CSatSSession& aSession,

    MSatApi& aSatApi,

    TSatEventMediator& aEventMediator )

    {

    LOG( SIMPLE, "SATENGINE: CSatSUiSubSession::NewL calling" )

    CSatSUiSubSession* self =

        new( ELeave ) CSatSUiSubSession( aSession, aSatApi, aEventMediator );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    LOG( SIMPLE, "SATENGINE: CSatSUiSubSession::NewL exiting" )

    return self;

    }

// Destructor

CSatSUiSubSession::~CSatSUiSubSession()

    {

    LOG( SIMPLE, "SATENGINE: CSatSUiSubSession::~CSatSUiSubSession calling" )

    iServiceRequest = NULL;

    // Unregister to listen events

    iEventMediator.Unregister( this );

    // Inform session that UI Session is closed.

    // Session tells to container of iServiceRequest to reset

    // request handlers.

    iSession.UiSessionClosed();

    LOG( SIMPLE, "SATENGINE: CSatSUiSubSession::~CSatSUiSubSession exiting" )

    }

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

// CSatSUiSubSession::HandleCommandL

// (other items were commented in a header).

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

//

void CSatSUiSubSession::HandleCommandL(

    const RMessage2& aMessage ) // Message from ui client.

    {

    LOG( SIMPLE, "SATENGINE: CSatSUiSubSession::HandleCommandL calling" )

    LOG2( SIMPLE, "SATENGINE: CSatSUiSubSession::HandleCommandL \

          command: %i", aMessage.Function() )

    switch ( aMessage.Function() )

        {

        // Ui client is ready to handle setupmenu command.

        case ESatSProactiveSetUpMenu:

            {

            // Notifies that SetUpMenu command has been made because SAT Client

            // side application is returning to the main menu after SelectItem.

            // For example: Next action is LaunchBrowser command and after

            // Browser is launched then SAT Client side application has been

            // opened top of Browser. In some cases SAT client side application

            // stays topmost.

            iEventMediator.Notify( MSatUtils::ESetUpMenuRequested );

            // This service request is handled also like commands listed below.

            }

            //lint -fallthrough intended here

        case ESatSProactiveDisplayText:

        case ESatSProactiveGetInkey:

        case ESatSProactiveGetInput:

        case ESatSProactiveSelectItem:

        case ESatSProactivePlayTone:

        case ESatSProactiveRefresh:

        case ESatSProactiveDisplayTextResponse:

        case ESatSProactiveGetInkeyResponse:

        case ESatSProactiveGetInputResponse:

        case ESatSProactiveSelectItemResponse:

        case ESatSProactivePlayToneResponse:

        case ESatSProactiveQuery:

        case ESatSProactiveQueryResponse:

        case ESatSProactiveNotification:

        case ESatSProactiveNotificationResponse:

            {

            const TInt count( iServiceRequest->Count() );

            TBool requestHandled( EFalse );

            TInt index( 0 );

            // Loop until request is handled or no request handler found.

            while ( !requestHandled && index < count )

                {

                requestHandled = iServiceRequest->At( index )->

                    HandleRequest( aMessage );

                index++;

                }

            LOG2( SIMPLE, "SATENGINE: CSatSUiSubSession::HandleCommandL \

                  index: %i", index )

            break;

            }

        // Menu selection envelope.

        case ESatSActiveMenuSelection:

            {

            LOG( SIMPLE, "SATENGINE: CSatSUiSubSession: MenuSelection" )

            // Declare the IPC data structures.

            RSat::TMenuSelectionV1 menuSelection;

            RSat::TMenuSelectionV1Pckg menuSelectionPckg( menuSelection );

            // Perform the IPC transfer of response data.

            TRAPD( res, aMessage.ReadL( 0, menuSelectionPckg ) );

            // Send the response further only if IPC succeeded.

            if ( KErrNone != res )

                {

                LOG( SIMPLE, "SATENGINE: CSatSUiSubSession: KErrNone != res" )

                iSession.PanicClient( aMessage, ESatSBadDescriptor );

                }

            iSatApi.SendMenuSelection( menuSelectionPckg );

            // Complete the client request.

            aMessage.Complete( KErrNone );

            LOG( SIMPLE,

                "SATENGINE: CSatSUiSubSession::HandleCommandL exiting" )

            return;

            }

        case ESatSProactiveEvent:

            {

            LOG( SIMPLE, "SATENGINE: CSatSUiSubSession: Event" )

            iEventRequest = aMessage;

            iEventRequestAvailable = ETrue;

            if ( iCloseUiRequested )

                {

                LOG( SIMPLE,

                    "SATENGINE: CSatSUiSubSession::HandleCommandL closeui" )

                CloseUiSession();

                }

            else if ( iSmsSent )

                {

                LOG( SIMPLE,

                    "SATENGINE: CSatSUiSubSession::HandleCommandL smssent" )

                SendSmsSentEventToClient();

                }

            else if ( iClearScreenRequested )

                {

                LOG( SIMPLE, "SATENGINE: CSatSUiSubSession::HandleCommandL \

                     clearscreen" )

                ClearScreen();

                }

            else if ( iUiEventRequested )

                {

                LOG( SIMPLE, "SATENGINE: CSatSUiSubSession::HandleCommandL \

                     UiEventRequested" )

                HandleUiEventNotification();

                }

            else

                {

                LOG( SIMPLE, "SATENGINE:   Event request available" )

                }

            break;

            }

        case ESatSProactiveEventResponse:

            {

            LOG( SIMPLE, "SATENGINE: CSatSUiSubSession: EventResponse" )

            // Declare the IPC data structures.

            TSatEventV1 eventRsp;

            //lint -e{603} eventRsp read through eventRspPckg in ReadL.

            TSatEventV1Pckg eventRspPckg( eventRsp );

            // Perform the IPC transfer of response data.

            TRAPD( res, aMessage.ReadL( 0, eventRspPckg ) );

            if ( KErrNone != res )

                {

                LOG( SIMPLE, "SATENGINE: CSatSUiSubSession::HandleCommandL \

                     read response data error" )

                iSession.PanicClient( aMessage, ESatSBadDescriptor );

                }

            else

                {

                LOG( SIMPLE, "SATENGINE: CSatSUiSubSession::HandleCommandL \

                     no error" )

                aMessage.Complete( KErrNone );

                }

            break;

            }

        case ESatSSessionTerminated:

            {

            LOG( SIMPLE, "SATENGINE: CSatSUiSubSession: SessionTerminated" )

            TSatTermination temp;

            //lint -e{603} temp read through tempPckg in ReadL.

            TSatTerminationPckg tempPckg ( temp );

            TRAPD( res, aMessage.ReadL( 0, tempPckg ) );

            if ( KErrNone != res )

                {

                LOG( SIMPLE, "SATENGINE: CSatSUiSubSession::HandleCommandL \

                     read tempPckg error" )

                iSession.PanicClient( aMessage, ESatSBadDescriptor );

                }

            else

                {

                LOG2( SIMPLE, "SATENGINE: CSatSUiSubSession::HandleCommandL \

                      temp.type: %i", temp.type )

                switch ( temp.type )

                    {

                    case ETerminatedByCancel:

                        {

                        iEventMediator.Notify(

                            MSatUtils::ECommandCancelled );

                        break;

                        }

                    case ETerminatedByEndKey:

                        {

                        iEventMediator.Notify(

                            MSatUtils::ECancelledUsingEndKey );

                        PublishSatAppClosedUsingEndKey();

                        // Inform session that UI Session is closed.

                        // Session is not actually closed yet but this prevents

                        // sending data through this session.

                        // Notify thread death monitor

                        iSession.NotifyThreadDeathMonitor();

                        break;

                        }

                    default:

                        {

                        LOG( SIMPLE, "SATENGINE:   Unknown termination type" )

                        }

                    }

                }

            // Complete the client request.

            aMessage.Complete( KErrNone );

            break;

            }

        default:

            {

            LOG( SIMPLE, "  Unhandled command")

            }

        }

    LOG( SIMPLE, "SATENGINE: CSatSUiSubSession::HandleCommandL exiting" )

    }

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

// CSatSUiSubSession::CloseUiSession

// (other items were commented in a header).

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

//

void CSatSUiSubSession::CloseUiSession()

    {

    LOG( SIMPLE, "SATENGINE: CSatSUiSubSession::CloseUiSession calling" )

    // Set request flag to ETrue. Updated when command is successfully sent.

    iCloseUiRequested = ETrue;

    // Notify thread death monitor

    iSession.NotifyThreadDeathMonitor();

    iEventData.iEvent = ESatSCloseSatUiAppEvent;

    const TBool commandSent( SendCommandDataToClient( iEventRequestAvailable,

                             iEventDataPckg,

                             iEventRequest ) );

    if ( commandSent )

        {

        LOG( SIMPLE, 

        "SATENGINE: CSatSUiSubSession::CloseUiSession commandSent" )

        // If command was sent, set flag to false, so when next Event request

        // arrives, command data is not sent.

        iCloseUiRequested = EFalse;

        }

    LOG( SIMPLE, "SATENGINE: CSatSUiSubSession::CloseUiSession exiting" )

    }

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

// CSatSUiSubSession::ClearScreen

// (other items were commented in a header).

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

//

void CSatSUiSubSession::ClearScreen()

    {

    LOG( SIMPLE, "SATENGINE: CSatSUiSubSession::ClearScreen calling" )

    // Set request flag to ETrue. Updated when command is successfully sent.

    iClearScreenRequested = ETrue;

    iEventData.iEvent = ESatSClearScreenEvent;

    const TBool commandSent( SendCommandDataToClient( iEventRequestAvailable,

                             iEventDataPckg,

                             iEventRequest ) );

    if ( commandSent )

        {

        LOG( SIMPLE, 

        "SATENGINE: CSatSUiSubSession::ClearScreen commandSent" )

        // If command was sent, set flag to false, so when next Event request

        // arrives, command data is not sent.

        iClearScreenRequested = EFalse;

        }

    LOG( SIMPLE, "SATENGINE: CSatSUiSubSession::ClearScreen exiting" )

    }

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

// CSatSUiSubSession::UiEventNotification

// (other items were commented in a header).

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

//

void CSatSUiSubSession::UiEventNotification(

    TInt aEventId, TInt aEventStatus, TInt aEventError )

    {

    LOG( SIMPLE, "SATENGINE: CSatSUiSubSession::UiEventNotification calling" )

    // Set request flag to ETrue. Updated when command is successfully sent.

    iUiEventRequested = ETrue;

    iEventData.iEvent = static_cast< TSatSEvent >( aEventId );

    iEventData.iStatus = static_cast< TSatSEventStatus >( aEventStatus );

    iEventData.iError = aEventError;

    HandleUiEventNotification();

    LOG( SIMPLE, "SATENGINE: CSatSUiSubSession::UiEventNotification exiting" )

    }

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

// CSatSUiSubSession::HandleUiEventNotification

// (other items were commented in a header).

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

//

void CSatSUiSubSession::HandleUiEventNotification()

    {

    LOG( SIMPLE,

        "SATENGINE: CSatSUiSubSession::HandleUiEventNotification calling" )

    // Send Command to client

    const TBool commandSent( SendCommandDataToClient( iEventRequestAvailable,

                             iEventDataPckg,

                             iEventRequest ) );

    // Check the status of command sending

    if ( commandSent )

        {

        LOG( SIMPLE, 

        "SATENGINE: CSatSUiSubSession::HandleUiEventNotification commandSent" )

        // If command was sent, set flag to false, so when next Event request

        // arrives, command data is not sent.

        iUiEventRequested = EFalse;

        }

    LOG( SIMPLE,

        "SATENGINE: CSatSUiSubSession::HandleUiEventNotification exiting" )

    }

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

// CSatSUiSubSession::SendCommand

// (other items were commented in a header).

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

//

void CSatSUiSubSession::SendCommand(

    TDesC8* aCmdData, // Data from SIM.

    TDes8* aCmdRsp, // Response.

    TSatServerRequest aRequest ) // Request, which the aData is sent.

    {

    LOG( SIMPLE, "SATENGINE: CSatSUiSubSession::SendCommand calling" )

    const TInt count( iServiceRequest->Count() );

    TBool requestHandled( EFalse );

    TInt index( 0 );

    // Loop until request is handled or no request handler found.

    while ( !requestHandled && ( index < count ) )

        {

        requestHandled = iServiceRequest->At( index )->HandleCommand(

            aCmdData, aCmdRsp, aRequest );

        index++;

        }

    LOG2( SIMPLE, "SATENGINE: CSatSUiSubSession::SendCommand \

          index: %i", index )

    LOG( SIMPLE, "SATENGINE: CSatSUiSubSession::SendCommand exiting" )

    }

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

// CSatSUiSubSession::Event

// (other items were commented in a header).

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

//

void CSatSUiSubSession::Event( TInt aEvent )

    {

    LOG( SIMPLE, "SATENGINE: CSatSUiSubSession::Event calling" )

    if ( MSatUtils::ESmsSent == aEvent )

        {

        LOG( SIMPLE, "SATENGINE: CSatSUiSubSession::Event ESmsSent" )

        iSmsSent = ETrue;

        SendSmsSentEventToClient();

        }

    LOG( SIMPLE, "SATENGINE: CSatSUiSubSession::Event exiting" )

    }

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

// CSatSUiSubSession::SendCommandDataToClient

// Writes descriptor to clients address space and

// completes the request.

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

//

TBool CSatSUiSubSession::SendCommandDataToClient(

    TBool& aRequestAvailable, // Is request available

    const TDesC8& aData, // Data to be sent to client

    const RMessage2& aMessage ) const // Message of the request

    {

    LOG( SIMPLE,

        "SATENGINE: CSatSUiSubSession::SendCommandDataToClient calling" )

    TBool commandSent( EFalse );

    // Is ui client ready to receive the command data.

    if ( aRequestAvailable )

        {

        LOG( SIMPLE, "SATENGINE: SendCommandDataToClient: Sending to Client" )

        TRAPD( res, aMessage.WriteL( 0, aData ) );

        if ( KErrNone != res )

            {

            LOG( SIMPLE, 

            "SATENGINE: SendCommandDataToClient: KErrNone != res" )

            iSession.PanicClient( aMessage, ESatSBadDescriptor );

            }

        aMessage.Complete( KErrNone );

        aRequestAvailable = EFalse;

        commandSent = ETrue;

        }

    LOG( SIMPLE,

        "SATENGINE: CSatSUiSubSession::SendCommandDataToClient exiting" )

    return commandSent;

    }

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

// CSatSUiSubSession::SendSmsSentEventToClient

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

//

void CSatSUiSubSession::SendSmsSentEventToClient()

    {

    LOG( SIMPLE,

        "SATENGINE: CSatSUiSubSession::SendSmsSentEventToClient calling" )

    iEventData.iEvent = ESatSSmEndEvent;

    const TBool commandSent( SendCommandDataToClient( iEventRequestAvailable,

        iEventDataPckg, iEventRequest ) );