/*

* 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:  ClearScreen handler is responsible for clearing screen when

*                DisplayText has sent immediate response and it is still active

*                when any other command starts to execute.

*

*/

// INCLUDE FILES

#include    "MSatUtils.h"

#include    "SatSTypes.h"

#include    "CClearScreenHandler.h"

#include    "SatLog.h"

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

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

// CClearScreenHandler::CClearScreenHandler

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

// might leave.

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

//

CClearScreenHandler::CClearScreenHandler( MSatUtils& aUtils ) :

    iUtils( aUtils )

    {

    LOG( SIMPLE, "DISPLAYTEXT: \

        CClearScreenHandler::CClearScreenHandler calling - exiting" )

    }

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

// CClearScreenHandler::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CClearScreenHandler::ConstructL()

    {

    LOG( SIMPLE, "DISPLAYTEXT: CClearScreenHandler::ConstructL calling" )

    // Set immediate response to false.

    iImmediateResponse = EFalse;

    // List all events we should listen.

    iUtils.RegisterL( this, MSatUtils::ESetUpMenuExecuting );

    iUtils.RegisterL( this, MSatUtils::ESelectItemExecuting );

    iUtils.RegisterL( this, MSatUtils::ESetUpCallExecuting );

    iUtils.RegisterL( this, MSatUtils::EDisplayTextExecuting );

    iUtils.RegisterL( this, MSatUtils::ELaunchBrowserExecuting );

    iUtils.RegisterL( this, MSatUtils::EGetInputExecuting );

    iUtils.RegisterL( this, MSatUtils::EGetInkeyExecuting );

    iUtils.RegisterL( this, MSatUtils::ESendDtmfExecuting );

    iUtils.RegisterL( this, MSatUtils::ESendSsExecuting );

    iUtils.RegisterL( this, MSatUtils::ESendUssdExecuting );

    iUtils.RegisterL( this, MSatUtils::EPlayToneExecuting );

    iUtils.RegisterL( this, MSatUtils::ERefreshExecuting );

    iUtils.RegisterL( this, MSatUtils::ECallControlExecuting );

    iUtils.RegisterL( this, MSatUtils::ESendSmExecuting );

    iUtils.RegisterL( this, MSatUtils::EMoSmControlExecuting );

    LOG( SIMPLE, "DISPLAYTEXT: CClearScreenHandler::ConstructL exiting" )

    }

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

// CClearScreenHandler::NewL

// Two-phased constructor.

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

//

CClearScreenHandler* CClearScreenHandler::NewL( MSatUtils& aUtils )

    {

    LOG( SIMPLE, "DISPLAYTEXT: CClearScreenHandler::NewL calling" )

    CClearScreenHandler* self =

        new ( ELeave ) CClearScreenHandler( aUtils );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    LOG( SIMPLE, "DISPLAYTEXT: CClearScreenHandler::NewL exiting" )

    return self;

    }

// Destructor

CClearScreenHandler::~CClearScreenHandler()

    {

    LOG( SIMPLE,

        "DISPLAYTEXT: CClearScreenHandler::~CClearScreenHandler calling" )

    // Unregister this as an event observer

    iUtils.UnregisterEventObserver( this );

    LOG( SIMPLE,

        "DISPLAYTEXT: CClearScreenHandler::~CClearScreenHandler exiting" )

    }

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

// CClearScreenHandler::UpdateImmediateState

// Updates immediate response state.

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

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

//

void CClearScreenHandler::UpdateImmediateState( TBool aState )

    {

    LOG( SIMPLE,

        "DISPLAYTEXT: CClearScreenHandler::UpdateImmediateState calling" )

    iImmediateResponse = aState;

    LOG( SIMPLE,

        "DISPLAYTEXT: CClearScreenHandler::UpdateImmediateState exiting" )

    }

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

// CClearScreenHandler::Event

// Notification of an event.

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

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

//

void CClearScreenHandler::Event( TInt aEvent )

    {

    LOG2( SIMPLE, "DISPLAYTEXT: CClearScreenHandler::Event calling, \

          aEvent: %d", aEvent )

    LOG2( SIMPLE, "DISPLAYTEXT: CClearScreenHandler::Event, \

          iImmediateResponse: %d", iImmediateResponse )

    // We don't have to do anything if immediate response is not active.

    if ( iImmediateResponse )

        {

        switch ( aEvent )

            {

            case MSatUtils::ESetUpMenuExecuting:

            case MSatUtils::ESelectItemExecuting:

            case MSatUtils::ESetUpCallExecuting:

            case MSatUtils::EDisplayTextExecuting:

            case MSatUtils::ELaunchBrowserExecuting:

            case MSatUtils::EGetInputExecuting:

            case MSatUtils::EGetInkeyExecuting:

            case MSatUtils::ESendDtmfExecuting:

            case MSatUtils::ESendSsExecuting:

            case MSatUtils::ESendUssdExecuting:

            case MSatUtils::EPlayToneExecuting:

            case MSatUtils::ERefreshExecuting:

            case MSatUtils::ECallControlExecuting:

            case MSatUtils::ESendSmExecuting:

            case MSatUtils::EMoSmControlExecuting:

                {

                ClearScreen();

                break;

                }

            default:

                {

                // Do nothing.

                break;

                }

            }

        }

    LOG( SIMPLE, "DISPLAYTEXT: CClearScreenHandler::Event exiting" )

    }

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

// CClearScreenHandler::ClearScreen

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

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

//

void CClearScreenHandler::ClearScreen()

    {

    LOG( SIMPLE, "DISPLAYTEXT: CClearScreenHandler::ClearScreen calling" )

    LOG2( SIMPLE, "DISPLAYTEXT: CClearScreenHandler::ClearScreen, \

          iImmediateResponse: %d", iImmediateResponse )

    // Clear the screen if immediate response is active.

    //lint -e{961} Else block meaningless

    if ( iImmediateResponse )

        {

        iUtils.NotifyUiEvent(

            ESatSClearScreenEvent, ESatEventNone, KErrNone );

        iImmediateResponse = EFalse;

        iUtils.NotifyEvent( MSatUtils::ESustainedTextRemoved );

        }

    LOG( SIMPLE, "DISPLAYTEXT: CClearScreenHandler::ClearScreen exiting" )

    }

//  End of File