/*

* Copyright (c) 2002-2007 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:  Handles the refresh sub-session IPC.

*

*/

#include    <e32base.h>

#include    "MSatUtils.h"

#include    "CSatSRefreshSubSession.h"

#include    "SatSOpcodes.h"

#include    "CSatSSession.h"

#include    "EnginePanic.h"

#include    "CSatSServer.h"

#include    "SatLog.h"

const TInt KClientQueryDelay = 1000000; // 1 second.

const TInt KClientNotifyDelay = 60000000; // 1 minute.

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

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

// CSatSRefreshSubSession::CSatSRefreshSubSession

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

// might leave.

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

//

CSatSRefreshSubSession::CSatSRefreshSubSession(

    CSatSSession& aSession,

    TSatEventMediator& aEventMediator ) :

    CSatSSubSession( aSession ),

    iEventMediator( aEventMediator ),

    iClientQueryPending( EFalse ),

    iClientNotifyPending( EFalse ),

    iClientWaitingRefresh( EFalse )

    {

    LOG( SIMPLE,

        "SATENGINE: CSatSRefreshSubSession::CSatSRefreshSubSession \

        calling - exiting" )

    }

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

// CSatSRefreshSubSession::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CSatSRefreshSubSession::ConstructL()

    {

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

    CSatSServer* server =

        const_cast<CSatSServer*>(

            static_cast<const CSatSServer*>( iSession.Server() ) );

    server->AddL( this );

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

    }

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

// CSatSRefreshSubSession::NewL

// Two-phased constructor.

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

//

CSatSRefreshSubSession* CSatSRefreshSubSession::NewL(

    CSatSSession& aSession,

    TSatEventMediator& aEventMediator )

    {

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

    CSatSRefreshSubSession* self =

        new( ELeave ) CSatSRefreshSubSession( aSession, aEventMediator );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

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

    return self;

    }

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

// CSatSRefreshSubSession::~CSatSRefreshSubSession()

// Destructor.

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

//

CSatSRefreshSubSession::~CSatSRefreshSubSession()

    {

    LOG( SIMPLE,

        "SATENGINE: CSatSRefreshSubSession::~CSatSRefreshSubSession calling" )

    CSatSServer* server =

        const_cast<CSatSServer*>(

            static_cast<const CSatSServer*>( iSession.Server() ) );

    server->Remove( this );

    // Remove Client Query timer.

    if ( iQueryTimer )

        {

        iQueryTimer->Cancel();

        delete iQueryTimer;

        iQueryTimer = NULL;

        }

    // Remove Client Notify timer.

    if ( iNotifyTimer )

        {

        iNotifyTimer->Cancel();

        delete iNotifyTimer;

        iNotifyTimer = NULL;

        }

    LOG( SIMPLE,

        "SATENGINE: CSatSRefreshSubSession::~CSatSRefreshSubSession exiting" )

    }

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

// CSatSRefreshSubSession::HandleCommandL

// Handles the refresh sub-session requests.

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

//

void CSatSRefreshSubSession::HandleCommandL( const RMessage2& aMessage )

    {

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

    switch ( aMessage.Function() )

        {

        case ESatSRefreshAllowed:

            {

            LOG( NORMAL, "SATENGINE:   Command: ESatSRefreshAllowed" )

            // Client's response to refresh query.

            RefreshAllowed( aMessage );

            break;

            }

        case ESatSNotifyAllowRefresh:

            {

            LOG( NORMAL, "SATENGINE:   Command: ESatSNotifyAllowRefresh" )

            // Client is ready for refresh query.

            NotifyRefreshAllowed( aMessage );

            break;

            }

        case ESatSNotityAllowRefreshCancel:

            {

            LOG( NORMAL, "SATENGINE:   Command: ESatSNotityAllowRefreshCancel" )

            // Client cancels the refresh query.

            CancelNotifyAllowRefresh( aMessage );

            break;

            }

        case ESatSNotifyRefresh:

            {

            LOG( NORMAL, "SATENGINE:   Command: ESatSNotifyRefresh" )

            // Client is ready for refresh.

            NotifyRefresh( aMessage );

            break;

            }

        case ESatSCancelNotifyRefresh:

            {

            LOG( NORMAL, "SATENGINE:   Command: ESatSCancelNotifyRefresh" )

            // Client cancels the refresh.

            CancelNotifyRefresh( aMessage );

            break;

            }

        case ESatSRefreshEFRead:

            {

            LOG( NORMAL, "SATENGINE:   Command: ESatSRefreshEFRead" )

            // Client has completed refresh.

            CompleteRefresh( aMessage );

            break;

            }

        default:

            {

            LOG( NORMAL, "SATENGINE:   Unexpected command: ggg" )

            // A wrong message was sent.

            iSession.PanicClient( aMessage, ESatSBadDescriptor );

            }

        }

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

    }

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

// CSatSRefreshSubSession::RefreshAllowed

// Sends the client's response of refresh query to SatServer.

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

//

void CSatSRefreshSubSession::RefreshAllowed( const RMessage2& aMessage )

    {

    LOG( SIMPLE, "SATENGINE: CSatSRefreshSubSession::RefreshAllowed calling" )

    // Handle reply only when we are waiting for it.

    // It is possible, that query has timed out and we got a late response.

    if ( iClientQueryPending )

        {

        LOG( SIMPLE, "SATENGINE: CSatSRefreshSubSession::RefreshAllowed \

        iClientQueryPending true" )

        iClientQueryPending = EFalse;

        // Stop timer, client replied.

        if ( iQueryTimer )

            {

            LOG( SIMPLE, "SATENGINE: CSatSRefreshSubSession::RefreshAllowed \

            iQueryTimer true" )

            iQueryTimer->Cancel();

            }

        TBool allow( EFalse );

        TPckg<TBool> allowPckg( allow );

        TRAPD( err, aMessage.ReadL( 0, allowPckg ) );

        LOG2( SIMPLE, "SATENGINE: CSatSRefreshSubSession::RefreshAllowed \

              err: %i", err )

        if ( KErrNone == err )

            {

            //lint -e{774} Allow updated through allowPckg in ReadL.

            if ( allow )

                {

                LOG( SIMPLE, "SATENGINE: CSatSRefreshSubSession::\

                     RefreshAllowed allow refresh" )

                iEventMediator.Notify( MSatUtils::ERefreshAllowed );

                iClientWaitingRefresh = ETrue;

                }

            else

                {

                LOG( SIMPLE, "SATENGINE: CSatSRefreshSubSession::\

                     RefreshAllowed don't allow refresh" )

                iEventMediator.Notify( MSatUtils::ERefreshNotAllowed );

                }

            }

        else

            {

            iSession.PanicClient( aMessage, ESatSBadDescriptor );

            }

        }

    aMessage.Complete( KErrNone );

    LOG( SIMPLE, "SATENGINE: CSatSRefreshSubSession::RefreshAllowed exiting" )

    }

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

// CSatSRefreshSubSession::NotifyRefresh

// Stores the NotifyRefresh request information for later completion.

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

//

void CSatSRefreshSubSession::NotifyRefresh( const RMessage2& aMessage )

    {

    LOG( SIMPLE, "SATENGINE: CSatSRefreshSubSession::NotifyRefresh calling" )

    if ( !iNotifyRefreshPending )

        {

        iNotifyRefreshPending = ETrue;

        iNotifyRefreshMessage = aMessage;

        }

    else

        {

        LOG( SIMPLE, "SATENGINE:   Request already received" )

        aMessage.Complete( KErrInUse );

        }

    LOG( SIMPLE, "SATENGINE: CSatSRefreshSubSession::NotifyRefresh exiting" )

    }

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

// CSatSRefreshSubSession::CancelNotifyRefresh

// Cancels the refresh notification

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

//

void CSatSRefreshSubSession::CancelNotifyRefresh( const RMessage2& aMessage )

    {

    LOG( SIMPLE,

        "SATENGINE: CSatSRefreshSubSession::CancelNotifyRefresh calling" )

    if ( iNotifyRefreshPending )

        {

        LOG( SIMPLE, "SATENGINE: CSatSRefreshSubSession::CancelNotifyRefresh\

        iNotifyRefreshPending true" )

        iNotifyRefreshPending = EFalse;

        iNotifyRefreshMessage.Complete( KErrCancel );

        }

    aMessage.Complete( KErrNone );

    LOG( SIMPLE,

        "SATENGINE: CSatSRefreshSubSession::CancelNotifyRefresh exiting" )

    }

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

// CSatSRefreshSubSession::NotifyRefreshAllowed

// Storest the refresh notification for later completion

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

//

void CSatSRefreshSubSession::NotifyRefreshAllowed( const RMessage2& aMessage )

    {

    LOG( SIMPLE,

        "SATENGINE: CSatSRefreshSubSession::NotifyRefreshAllowed calling" )

    if ( !iRefreshAllowPending )

        {

        iRefreshAllowPending = ETrue;

        iRefreshAllowMessage = aMessage;

        }

    else

        {

        LOG( SIMPLE, "SATENGINE:   Request already received" )

        aMessage.Complete( KErrInUse );

        }

    LOG( SIMPLE,

        "SATENGINE: CSatSRefreshSubSession::NotifyRefreshAllowed exiting" )

    }

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

// CSatSRefreshSubSession::CancelNotifyAllowRefresh

// Cancels the refresh notification.

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

//

void CSatSRefreshSubSession::CancelNotifyAllowRefresh(

    const RMessage2& aMessage )

    {

    LOG( SIMPLE,

        "SATENGINE: CSatSRefreshSubSession::CancelNotifyAllowRefresh calling" )

    if ( iRefreshAllowPending )

        {

        LOG( SIMPLE, "SATENGINE: CSatSRefreshSubSession::\

        CancelNotifyAllowRefresh iRefreshAllowPending true" )

        iRefreshAllowPending = EFalse;

        iRefreshAllowMessage.Complete( KErrCancel );

        }

    aMessage.Complete( KErrNone );

    LOG( SIMPLE,

        "SATENGINE: CSatSRefreshSubSession::CancelNotifyAllowRefresh exiting" )

    }

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

// CSatSRefreshSubSession::CompleteRefresh

// Sends the client's completion to SatServer.

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

//

void CSatSRefreshSubSession::CompleteRefresh( const RMessage2& aMessage )

    {

    LOG( SIMPLE, "SATENGINE: CSatSRefreshSubSession::CompleteRefresh calling" )

    // Handle completion only when we are waiting for it.

    // It is possible, that it has timed out and we got a late response.

    if ( iClientNotifyPending )

        {

        LOG( SIMPLE, "SATENGINE: CSatSRefreshSubSession::CompleteRefresh \

        iClientNotifyPending true" )

        iClientNotifyPending = EFalse;

        // Stop timer, client replied.

        if ( iNotifyTimer )

            {

            LOG( SIMPLE, "SATENGINE: CSatSRefreshSubSession::CompleteRefresh \

            iNotifyTimer true" )

            iNotifyTimer->Cancel();

            }

        TBool additionEFRead( EFalse );

        TPckg<TBool> additionEFReadPckg( additionEFRead );

        TRAPD( err, aMessage.ReadL( 0, additionEFReadPckg ) );

        if ( KErrNone == err )

            {

            //lint -e{774} additionEFRead updated through additionEFReadPckg.

            if ( additionEFRead )

                {

                LOG( SIMPLE, "SATENGINE: CSatSRefreshSubSession::\

                     CompleteRefresh additionEFRead true" )

                iEventMediator.Notify( MSatUtils::ERefreshAdditionalEFRead );

                }

            else

                {

                LOG( SIMPLE, "SATENGINE: CSatSRefreshSubSession::\

                     CompleteRefresh additionEFRead false" )

                iEventMediator.Notify( MSatUtils::ERefreshEFRead );

                }

            }

        else

            {

            LOG( SIMPLE, "SATENGINE:   Bad descriptor" )

            iEventMediator.Notify( MSatUtils::ERefreshEFRead );

            }

        }

    aMessage.Complete( KErrNone );

    LOG( SIMPLE, "SATENGINE: CSatSRefreshSubSession::CompleteRefresh exiting" )

    }

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

// CSatSRefreshSubSession::QueryClient

// Notifies the client that response for refresh query has to be made.

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

//

void CSatSRefreshSubSession::QueryClient(

    const RSat::TRefreshV2& aRefresh )

    {

    LOG( SIMPLE, "SATENGINE: CSatSRefreshSubSession::QueryClient calling" )

    TBool allowRefreshNow( ETrue );

    if ( iRefreshAllowPending )

        {

        if ( VerifyObservedFiles( aRefresh ) )

            {

            // Write the refresh information to client.

            TPckg<RSat::TRefreshFileList> fileListPckg( aRefresh.iFileList );

            TPckg<RSat::TRefreshType> typePckg( aRefresh.iType );

            TRAPD(

                err,

                iRefreshAllowMessage.WriteL( 0, fileListPckg );

                iRefreshAllowMessage.WriteL( 1, typePckg ); )

            if ( KErrNone == err )

                {

                LOG( SIMPLE, "SATENGINE: CSatSRefreshSubSession::QueryClient \

                KErrNone == err" )

                iRefreshAllowPending = EFalse;

                iRefreshAllowMessage.Complete( err );

                iClientQueryPending = ETrue;

                allowRefreshNow = EFalse;

                // Start timer to prevent jam, when client will not reply.

                if ( iQueryTimer )

                    {

                    LOG( SIMPLE, "CSatSRefreshSubSession::QueryClient \

                         iQueryTimer true" )

                    iQueryTimer->Cancel();

                    }

                else

                    {

                    // Create Client Query timer when first time used.

                    TRAP(

                        err,

                        iQueryTimer =

                            CPeriodic::NewL( CActive::EPriorityStandard ); )

                    }

                if ( ( KErrNone == err ) && iQueryTimer )

                    {

                    LOG( SIMPLE, "SATENGINE: CSatSRefreshSubSession::\

                    QueryClient start iQueryTimer" )

                    TCallBack callback( TimerQueryCallback, this );

                    iQueryTimer->Start(

                        KClientQueryDelay,

                        KClientQueryDelay,

                        callback );

                    }

                }

            else

                {

                LOG2( SIMPLE, "SATENGINE:   QueryClient error: %i", err )

                }

            }

        }

    if ( allowRefreshNow )

        {

        LOG( SIMPLE, "CSatSRefreshSubSession::QueryClient \

        allowRefreshNow true" )

        iEventMediator.Notify( MSatUtils::ERefreshAllowed );

        }

    LOG( SIMPLE, "SATENGINE: CSatSRefreshSubSession::QueryClient exiting" )

    }

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

// CSatSRefreshSubSession::NotifyClient

// Notifies the client that refresh has happened.

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

//

void CSatSRefreshSubSession::NotifyClient(

    const RSat::TRefreshV2& aRefresh )

    {

    LOG( SIMPLE, "SATENGINE: CSatSRefreshSubSession::NotifyClient calling" )

    TBool completeRefreshNow( ETrue );

    if ( iNotifyRefreshPending && iClientWaitingRefresh )

        {

        TPckg<RSat::TRefreshFileList> fileListPckg( aRefresh.iFileList );

        #ifdef ENABLE_SAT_LOGGING

        TInt fileCount ( aRefresh.iFileList.Length() );

        LOG2( NORMAL, "SATENGINE:   Refresh file count: %d", fileCount )

        for ( TInt fileIndex = 0; fileIndex < fileCount; fileIndex++ )

            {

            LOG2( NORMAL, "SATENGINE:     Refresh file : %x",

                aRefresh.iFileList[ fileIndex ] )

            }

        #endif

        TPckg<RSat::TRefreshType> typePckg( aRefresh.iType );

        TRAPD(

            err,

            iNotifyRefreshMessage.WriteL( 0, fileListPckg );

            iNotifyRefreshMessage.WriteL( 1, typePckg ); )

        LOG2( SIMPLE, "SATENGINE:   NotifyClient error: %i", err )

        if ( KErrNone == err )

            {

            // ESimReset confirmation will not be waited.

            if ( RSat::ESimReset != aRefresh.iType )

                {

                LOG( SIMPLE, "SATENGINE: CSatSRefreshSubSession::NotifyClient\

                RSat::ESimReset != aRefresh.iType" )

                iClientNotifyPending = ETrue; // Waiting client

                completeRefreshNow = EFalse; // Client must complete this

                // Start timer to prevent jam, when client will not restart.