/*
* 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:  Handles Refresh command
*
*/


#include    <msatrefreshobserver.h>
#include    "MSatSUiClientHandler.h"
#include    "CRefreshHandler.h"
#include    "MSatApi.h"
#include    "MSatUtils.h"
#include    "MSatSystemState.h"
#include    "MSatUiSession.h"
#include    "SatSOpcodes.h"
#include    "MSatRefreshSubSession.h"
#include    "SatLog.h"

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

// -----------------------------------------------------------------------------
// CRefreshHandler::CRefreshHandler
// C++ default constructor can NOT contain any code, that
// might leave.
// -----------------------------------------------------------------------------
//
CRefreshHandler::CRefreshHandler() :
    CSatCommandHandler(),
    iRefreshData(),
    iRefreshPckg( iRefreshData ),
    iRefreshRsp(),
    iRefreshRspPckg( iRefreshRsp ),
    iRefreshNotifyClientCount( 0 ),
    iAdditionalEFRead( EFalse ),
    iSimResetExecuting( EFalse )
    {
    LOG( SIMPLE,
        "REFRESH: CRefreshHandler::CRefreshHandler calling - exiting" )
    }

// -----------------------------------------------------------------------------
// CRefreshHandler::ConstructL
// Symbian 2nd phase constructor can leave.
// -----------------------------------------------------------------------------
//
void CRefreshHandler::ConstructL()
    {
    LOG( SIMPLE, "REFRESH: CRefreshHandler::ConstructL calling" )

    // Register events to be listen.
    iUtils->RegisterL( this, MSatUtils::ERefreshEFRead );
    iUtils->RegisterL( this, MSatUtils::ERefreshAdditionalEFRead );
    iUtils->RegisterL( this, MSatUtils::ESimResetCalled );

    LOG( SIMPLE, "REFRESH: CRefreshHandler::ConstructL exiting" )
    }

// -----------------------------------------------------------------------------
// CRefreshHandler::NewL
// Two-phased constructor.
// -----------------------------------------------------------------------------
//
CRefreshHandler* CRefreshHandler::NewL( MSatUtils* aUtils )
    {
    LOG( SIMPLE, "REFRESH: CRefreshHandler::NewL calling" )

    CRefreshHandler* self = new( ELeave ) CRefreshHandler;

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

    LOG( SIMPLE, "REFRESH: CRefreshHandler::NewL exiting" )
    return self;
    }


// Destructor
CRefreshHandler::~CRefreshHandler()
    {
    LOG( SIMPLE, "REFRESH: CRefreshHandler::~CRefreshHandler calling" )

    Cancel();

    LOG( SIMPLE, "REFRESH: CRefreshHandler::~CRefreshHandler exiting" )
    }

// -----------------------------------------------------------------------------
// CRefreshHandler::Event
// -----------------------------------------------------------------------------
//
void CRefreshHandler::Event( TInt aEvent )
    {
    LOG( SIMPLE, "REFRESH: CRefreshHandler::Event calling" )

    switch ( aEvent )
        {
        case MSatUtils::ERefreshAdditionalEFRead:
            {
            LOG( NORMAL, "REFRESH:   Event: Additional EF read" )

            // At least one client indicates additional EF read.
            iAdditionalEFRead = ETrue;
            }
            //lint -fallthrough intended here

        case MSatUtils::ERefreshEFRead:
            {
            LOG( NORMAL, "REFRESH:   Event: Client Completed" )

            if ( 0 < iRefreshNotifyClientCount )
                {
                iRefreshNotifyClientCount--;
                // Check whether all clients have replied.
                if ( 0 == iRefreshNotifyClientCount )
                    {
                    LOG( NORMAL, "REFRESH:   All clients are complete" )
                    // Construct and send terminal response..
                    CompleteRefresh();
                    }
                }
            break;
            }

        case MSatUtils::ESimResetCalled:
            {
            LOG( NORMAL, "REFRESH:   Event: Sim Reset called" )
            iSimResetExecuting = ETrue;
            break;
            }

        default:
            {
            LOG2( NORMAL, "REFRESH:   Event: %i", aEvent )
            CSatCommandHandler::Event( aEvent );
            }
        }

    LOG( SIMPLE, "REFRESH: CRefreshHandler::Event exiting" )
    }

// -----------------------------------------------------------------------------
// CRefreshHandler::DoCancel
// Cancels the sat request.
// -----------------------------------------------------------------------------
//
void CRefreshHandler::DoCancel()
    {
    LOG( SIMPLE, "REFRESH: CRefreshHandler::DoCancel calling" )

    iUtils->USatAPI().NotifyRefreshCancel();

    LOG( SIMPLE, "REFRESH: CRefreshHandler::DoCancel exiting" )
    }

// -----------------------------------------------------------------------------
// CRefreshHandler::IssueUSATRequest
// -----------------------------------------------------------------------------
//
void CRefreshHandler::IssueUSATRequest( TRequestStatus& aStatus )
    {
    LOG( SIMPLE, "REFRESH: CRefreshHandler::IssueUSATRequest calling" )

    // Refresh has been cancelled, lets notify clients waiting for it.
    if ( KErrGeneral == aStatus.Int() )
        {
        LOG( SIMPLE, "REFRESH:   Refresh cancelled" )
        NotifyRefreshClientsCancel();

        if ( iSimResetExecuting )
            {
            LOG( SIMPLE, "CRefreshHandler::IssueUSATRequest \
            iSimResetExecuting" )
            iUtils->NotifyEvent( MSatUtils::EAddSatUiCalled );
            iUtils->NotifyEvent( MSatUtils::ESimResetCancelled );

            iSimResetExecuting = EFalse;
            }
        }

    // Clear the IPC package.
    new (&iRefreshData) RSat::TRefreshV2();

    iUtils->USatAPI().NotifyRefresh( aStatus, iRefreshPckg );

    LOG( SIMPLE, "REFRESH: CRefreshHandler::IssueUSATRequest exiting" )
    }

// -----------------------------------------------------------------------------
// CRefreshHandler::CommandAllowed
// -----------------------------------------------------------------------------
//
TBool CRefreshHandler::CommandAllowed()
    {
    LOG( SIMPLE, "REFRESH: CRefreshHandler::CommandAllowed calling - exiting" )

    // Now we must always allow Refresh. We had our last chnage to deny it in
    // RefreshRequired command.
    return ETrue;
    }

// -----------------------------------------------------------------------------
// CRefreshHandler::NeedUiSession
// -----------------------------------------------------------------------------
//
TBool CRefreshHandler::NeedUiSession()
    {
    LOG( SIMPLE, "REFRESH: CRefreshHandler::NeedUiSession calling - exiting" )
    return EFalse;
    }

// -----------------------------------------------------------------------------
// CRefreshHandler::HandleCommand
// -----------------------------------------------------------------------------
//
void CRefreshHandler::HandleCommand()
    {
    LOG( SIMPLE, "REFRESH: CRefreshHandler::HandleCommand calling" )

    // Refresh has been done.
    iSimResetExecuting = EFalse;

    #ifdef ENABLE_SAT_LOGGING
    TInt fileCount( iRefreshData.iFileList.Length() );
    LOG2( NORMAL, "REFRESH:   Refresh file count: %d", fileCount )
    for ( TInt fileIndex = 0; fileIndex < fileCount; fileIndex++ )
        {
        LOG2( NORMAL, "REFRESH:     Refresh file : %x",
            iRefreshData.iFileList[ fileIndex ] )
        }
    #endif

    // Notify all registered clients about refresh.
    // Whether any clients exists, we must wait them all to complete EF read,
    // otherwise we can complete now.
    // Count must be local variable, due some client may reply before
    // all other has been notified.
    TInt clientCount( iUtils->RefreshSubSessions().Count() );
    iRefreshNotifyClientCount = clientCount; // Actually notified clients.
    iAdditionalEFRead = EFalse;
    if ( 0 != clientCount )
        {
        LOG2( NORMAL, "REFRESH:   Refresh client count: %d",
            iRefreshNotifyClientCount )

        // Notify refresh clients about refresh completion.
        for ( TInt i = 0; i < clientCount ; i++ )
            {
            iUtils->RefreshSubSessions()[i]->NotifyClient( iRefreshData );
            }
        }
    else
        {
        // Construct and send terminal response..
        CompleteRefresh();
        }

    LOG( SIMPLE, "REFRESH: CRefreshHandler::HandleCommand exiting" )
    }

// -----------------------------------------------------------------------------
// CRefreshHandler::UiLaunchFailed
// -----------------------------------------------------------------------------
//
void CRefreshHandler::UiLaunchFailed()
    {
    // This command will not launch ui.
    LOG( SIMPLE, "REFRESH: CRefreshHandler::UiLaunchFailed calling-exiting" )
    }

// -----------------------------------------------------------------------------
// CRefreshHandler::CompleteRefresh
// Waits for all clients complete.
// -----------------------------------------------------------------------------
//
void CRefreshHandler::CompleteRefresh()
    {
    LOG( SIMPLE, "REFRESH: CRefreshHandler::CompleteRefresh calling" )

    // Remove the idle mode text and icon for initialization type refreshes.
    // Note that idle mode text was removed for ESimReset already in
    // RefreshRequired command.
    if ( ( RSat::EFileChangeNotification != iRefreshData.iType ) &&
         ( RSat::ESimReset != iRefreshData.iType ) )
        {
        LOG( SIMPLE, "REFRESH: CRefreshHandler::CompleteRefresh ESimInitDone" )
        iUtils->NotifyEvent( MSatUtils::ESimInitDone );
        }

    // Construct a proper refresh response data package.
    if ( iAdditionalEFRead )
        {
        LOG( SIMPLE, "REFRESH: CRefreshHandler::CompleteRefresh \
             iAdditionalEFRead" )
        iRefreshRsp.iGeneralResult = RSat::KRefreshAdditionEFRead;
        iAdditionalEFRead = EFalse;
        }
    else
        {
        iRefreshRsp.iGeneralResult = RSat::KSuccess;
        }

    iRefreshRsp.iInfoType = RSat::KNoAdditionalInfo;
    iRefreshRsp.iAdditionalInfo.Zero();
    iRefreshRsp.SetPCmdNumber( iRefreshData.PCmdNumber() );

    // Send the response
    TerminalRsp( RSat::ERefresh, iRefreshRspPckg );

    LOG( SIMPLE, "REFRESH: CRefreshHandler::CompleteRefresh exiting" )
    }

// -----------------------------------------------------------------------------
// CRefreshHandler::NotifyRefreshClientsCancel
// Notifies waiting clients about refrsh cancel.
// -----------------------------------------------------------------------------
//
void CRefreshHandler::NotifyRefreshClientsCancel()
    {
    LOG( SIMPLE,
        "REFRESH: CRefreshHandler::NotifyRefreshClientsCancel calling" )
    LOG2( SIMPLE,
        "REFRESH: CRefreshHandler::NotifyRefreshClientsCancel \
        iRefreshNotifyClientCount: %d", iRefreshNotifyClientCount )
    for ( TInt i = 0; i < iRefreshNotifyClientCount ; i++ )
        {
        iUtils->RefreshSubSessions()[i]->NotifyClientCancel();
        }
    iRefreshNotifyClientCount = 0;

    LOG( SIMPLE,
        "REFRESH: CRefreshHandler::NotifyRefreshClientsCancel exit" )
    }