/*

* 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 the SetUpMenu command from SIM.

*

*/

#include    <MSatShellController.h>

#include    "MSatApi.h"

#include    "MSatUiSession.h"

#include    "SatSOpcodes.h"

#include    "MSatSUiClientHandler.h"

#include    "CSetUpMenuHandler.h"

#include    "SATPrivateCRKeys.h"

#include    "SatLog.h"

const TInt KMaxSatAppName = 30;

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

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

// CSetUpMenuHandler::CSetUpMenuHandler

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

// might leave.

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

//

CSetUpMenuHandler::CSetUpMenuHandler() :

    CSatCommandHandler(),

    iSetUpMenuData(),

    iSetUpMenuPckg( iSetUpMenuData ),

    iArrivedSetUpMenuData(),

    iArrivedSetUpMenuPckg( iArrivedSetUpMenuData ),

    iSatAppNameUpdated( EFalse ),

    iSatServiceAvailable( EFalse ),

    // To be removed when icons are allowed in this command

    iIconCommand( EFalse )

    {

    LOG( SIMPLE,

        "SETUPMENU: CSetUpMenuHandler::CSetUpMenuHandler calling - exiting" )

    }

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

// CSetUpMenuHandler::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CSetUpMenuHandler::ConstructL()

    {

    LOG( SIMPLE, "SETUPMENU: CSetUpMenuHandler::ConstructL calling" )

    // Register Service request handler for this command handler.

    iUtils->RegisterServiceRequestL(

        ESatSProactiveSetUpMenu,

        ESatSNone,

        this );

    // Remove the sat ui client icon from the shell, otherwise

    // sat icon remains in shell once set in shell.

    iUtils->SatUiHandler().ShellController().RemoveSatUiL();

    // When sim session arrives, setupmenu may need to be displayed.

    iUtils->RegisterL( this, MSatUtils::ESimSessionEndExecuting );

    iUtils->RegisterL( this, MSatUtils::ESatUiLaunched );

    iUtils->RegisterL( this, MSatUtils::ESetUpMenuNeeded );

    iUtils->RegisterL( this, MSatUtils::EApplNameUpdated );

    iUtils->RegisterL( this, MSatUtils::ESimResetCalled );

    iUtils->RegisterL( this, MSatUtils::ERemoveSatUiCalled );

    iUtils->RegisterL( this, MSatUtils::EAddSatUiCalled );

    iUtils->RegisterL( this, MSatUtils::ECallControlDone );

    LOG( SIMPLE, "SETUPMENU: CSetUpMenuHandler::ConstructL exiting" )

    }

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

// CSetUpMenuHandler::NewL

// Two-phased constructor.

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

//

CSetUpMenuHandler* CSetUpMenuHandler::NewL( MSatUtils* aUtils )

    {

    LOG( SIMPLE, "SETUPMENU: CSetUpMenuHandler::NewL calling" )

    CSetUpMenuHandler* self = new( ELeave ) CSetUpMenuHandler;

    CleanupStack::PushL( self );

    self->BaseConstructL( aUtils ); // Need to be called before ConstructL

    self->ConstructL();

    CleanupStack::Pop( self );

    LOG( SIMPLE, "SETUPMENU: CSetUpMenuHandler::NewL exiting" )

    return self;

    }

// Destructor

CSetUpMenuHandler::~CSetUpMenuHandler()

    {

    LOG( SIMPLE, "SETUPMENU: CSetUpMenuHandler::~CSetUpMenuHandler calling" )

    Cancel();

    LOG( SIMPLE, "SETUPMENU: CSetUpMenuHandler::~CSetUpMenuHandler exiting" )

    }

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

// CSetUpMenuHandler::ClientResponse

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

//

void CSetUpMenuHandler::ClientResponse()

    {

    // This is needed to prevent Panic when UI is closed right after start

    }

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

// CSetUpMenuHandler::Event

// Event notification

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

//

void CSetUpMenuHandler::Event( TInt aEvent )

    {

    LOG( SIMPLE, "SETUPMENU: CSetUpMenuHandler::Event calling" )

    switch ( aEvent )

        {

        // Sim session has arrived from SIM or ui launched

        case MSatUtils::ESatUiLaunched:

            {

            LOG( NORMAL, "SETUPMENU:   Event: ESatUiLaunched" )

            // Send SetUpMenu to ui client if ui client is running,

            // ui client is launced by user and the set up menu data

            // has arrived from SIM.

            if ( iSetUpMenuArrived )

                {

                LOG( NORMAL, "SETUPMENU:   Event: iSetUpMenuArrived true" )

                SendSetUpMenuToClient();

                }

            else

                {

                SendEmptySetupMenuToClient();

                }

            break;

            }

        case MSatUtils::ESetUpMenuNeeded:

            {

            LOG( NORMAL, "SETUPMENU:   Event: ESetUpMenuNeeded" )

            // Some command has finished executing and needs SetUpMenu.

            SendSetUpMenuToClient();

            break;

            }

        case MSatUtils::EApplNameUpdated:

            {

            LOG( NORMAL, "SETUPMENU:   Event: EApplNameUpdated" )

            // Update SetUpMenu to ui client if ui client is running,

            // ui client is launced by user and the set up menu data

            // has arrived from SIM.

            TRAPD( err, UpdateSetUpMenuToClientL() );

            if ( KErrNone != err )

                {

                LOG2( SIMPLE, "SETUPMENU:   Error: %i", err )

                }            

            break;

            }

        case MSatUtils::ESimSessionEndExecuting:

            {

            LOG( NORMAL, "SETUPMENU:   Event: ESimSessionEndExecuting" )

            // If the sim session end is only command active currently

            // then send the setupmenu to client.

            if ( 1 == iUtils->NumberOfExecutingCommandHandlers() )

                {

                LOG( NORMAL, "SETUPMENU:   Event: setupmenu" )

                SendSetUpMenuToClient();

                }

            break;

            }

        case MSatUtils::ESimResetCalled:

            {

            LOG( NORMAL, "SETUPMENU:   Event: ESimResetCalled" )

            // Close SatUi and remove Sat icon from application shell

            MSatUiSession* uiSession = iUtils->SatUiHandler().UiSession();

            if ( uiSession )

                {

                LOG( NORMAL, "SETUPMENU:   Event: CloseUiSession" )

                uiSession->CloseUiSession();

                }

            TRAP_IGNORE( RemoveIconFromShellL() )

            break;

            }

        case MSatUtils::EAddSatUiCalled:

            {

            LOG( NORMAL, "SETUPMENU:   Event: EAddSatUiCalled" )

            iSatServiceAvailable = ETrue;

            if ( iSetUpMenuArrived )

                {

                LOG( NORMAL, "SETUPMENU:   Event: iSetUpMenuArrived true" )

                TRAP_IGNORE( AddIconToShellL(

                    iArrivedSetUpMenuData.iAlphaId.iAlphaId,

                    iArrivedSetUpMenuData.iIconId ) )

                }

            break;

            }

        case MSatUtils::ERemoveSatUiCalled:

            {

            iSatServiceAvailable = EFalse;

            LOG( NORMAL, "SETUPMENU:   Event: ERemoveSatUiCalled" )

            // Close SAT UI and remove SAT icon from Application Shell.

            MSatUiSession* uiSession = iUtils->SatUiHandler().UiSession();

            if ( uiSession )

                {

                LOG( NORMAL, "SETUPMENU:   Event: CloseUiSession" )

                uiSession->CloseUiSession();

                }

            TRAP_IGNORE( RemoveIconFromShellL() )

            break;

            }

        case MSatUtils::ECallControlDone:

            {

            // If all commands end up, send the setupmenu to client.

            if ( 0 == iUtils->NumberOfExecutingCommandHandlers() )

                {

                LOG( NORMAL, "SETUPMENU:   Event: setupmenu" )

                SendSetUpMenuToClient();

                }

            break;

            }

        default:

            {

            LOG2( NORMAL, "SETUPMENU:   Unexpected event: %i", aEvent )

            CSatCommandHandler::Event( aEvent );

            }

        }

    LOG( SIMPLE, "SETUPMENU: CSetUpMenuHandler::Event exiting" )

    }

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

// CSetUpMenuHandler::DoCancel

// Cancels the SetUpMenu notification from SIM.

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

//

void CSetUpMenuHandler::DoCancel()

    {

    LOG( SIMPLE, "SETUPMENU: CSetUpMenuHandler::DoCancel calling" )

    iUtils->USatAPI().NotifySetUpMenuCancel();

    LOG( SIMPLE, "SETUPMENU: CSetUpMenuHandler::DoCancel exiting" )

    }

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

// CSetUpMenuHandler::AddIconToShellL

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

//

void CSetUpMenuHandler::AddIconToShellL(

    const TDesC& aAlphaId, // Alpha id of SetUpMenu command

    const RSat::TIconId& aIconId ) // Icon id of SetUpMenu command

    {

    LOG( SIMPLE, "SETUPMENU: CSetUpMenuHandler::AddIconToShellL calling" )

    TPtrC name( aAlphaId );

    if ( 0 != aAlphaId.Length() )

        {

        LOG( SIMPLE, 

        "SETUPMENU: CSetUpMenuHandler::AddIconToShellL aAlphaId not null" )

        // Set new sat app name.

        iUtils->SetSatAppNameL( aAlphaId );

        }

    else

        {

        LOG( SIMPLE, 

        "SETUPMENU: CSetUpMenuHandler::AddIconToShellL aAlphaId null" )

        iUtils->RestoreSatAppNameL();

        name.Set( iUtils->SatAppName() );

        }

    // Menu application needs only a short name.

    if ( iUtils->SatAppName().Length() > KMaxSatAppName )

        {

        LOG( SIMPLE, 

        "SETUPMENU: CSetUpMenuHandler::AddIconToShellL AppName too long" )

        name.Set( iUtils->SatAppName().Left( KMaxSatAppName ) );

        }

    else

        {

        name.Set( iUtils->SatAppName() );

        }

    // Check if there is icon available.

    MSatShellController& controller = iUtils->SatUiHandler().ShellController();

    if ( ( RSat::ENoIconId == aIconId.iQualifier ) ||

         ( RSat::EIconQualifierNotSet == aIconId.iQualifier ) )

        {

        LOG( SIMPLE, 

        "SETUPMENU: CSetUpMenuHandler::AddIconToShellL no icon" )

        controller.AddSatUiL( name );

        }

    else

        {

        controller.AddSatUiL( name, aIconId.iIdentifier );

        }

    LOG( SIMPLE, "SETUPMENU: CSetUpMenuHandler::AddIconToShellL exiting" )

    }

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

// CSetUpMenuHandler::RemoveIconFromShellL

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

//

void CSetUpMenuHandler::RemoveIconFromShellL()

    {

    LOG( SIMPLE, "SETUPMENU: CSetUpMenuHandler::RemoveIconFromShellL calling" )

    iUtils->SatUiHandler().ShellController().RemoveSatUiL();

    // Restore the original name of SAT application.

    iUtils->RestoreSatAppNameL();

    LOG( SIMPLE, "SETUPMENU: CSetUpMenuHandler::RemoveIconFromShellL exiting" )

    }

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

// CSetUpMenuHandler::SendSetUpMenuToClient

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

//

void CSetUpMenuHandler::SendSetUpMenuToClient()

    {

    LOG( SIMPLE, "SETUPMENU: CSetUpMenuHandler::SendSetUpMenuToClient calling" )

    MSatUiSession* uiSession = iUtils->SatUiHandler().UiSession();

    if ( uiSession &&

         iUtils->SatUiHandler().UiLaunchedByUser() &&

         iSetUpMenuArrived )

        {

        LOG( SIMPLE, 

        "SETUPMENU: CSetUpMenuHandler::SendSetUpMenuToClient setupmenu" )

        // Does not update SIM application name when it is restored and service

        // is not available.

        if ( iSatServiceAvailable )

            {

            LOG( SIMPLE, 

            "SETUPMENU: CSetUpMenuHandler::SendSetUpMenuToClient \

            iSatServiceAvailable true" )

            // When ME is launched with special SIM and SetUpMenu made with

            // different name. Then also SetUpMenu data update is needed

            // when Menu name was already OK.

            iArrivedSetUpMenuData.iAlphaId.iAlphaId.Zero();

            iArrivedSetUpMenuData.iAlphaId.iAlphaId.Copy(

                iUtils->SatAppName() );

            }

        // Client does not respond to setupmenu cmd, therefore NULL.

        uiSession->SendCommand(

            &iArrivedSetUpMenuPckg,

            NULL,

            ESatSProactiveSetUpMenu );

        }

    LOG( SIMPLE, "SETUPMENU: CSetUpMenuHandler::SendSetUpMenuToClient exiting" )

    }

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

// CSetUpMenuHandler::SendEmptySetupMenuToClient

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

//

void CSetUpMenuHandler::SendEmptySetupMenuToClient()

    {

    LOG( SIMPLE, "SETUPMENU: CSetUpMenuHandler::SendEmptySetupMenuToClient\

     calling" )

    MSatUiSession* uiSession = iUtils->SatUiHandler().UiSession();

    if ( uiSession &&

         iUtils->SatUiHandler().UiLaunchedByUser() )

        {

        LOG( SIMPLE, "SETUPMENU: CSetUpMenuHandler::SendEmptySetupMenuToClient\

        send setupmenu" )

        // Client does not respond to setupmenu cmd, therefore NULL.

        uiSession->SendCommand(

            &iSetUpMenuPckg,

            NULL,

            ESatSProactiveSetUpMenu );

        }

    LOG( SIMPLE, "SETUPMENU: CSetUpMenuHandler::SendEmptySetupMenuToClient\

     exiting" )

    }

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

// CSetUpMenuHandler::UpdateSetUpMenuToClientL

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

//

void CSetUpMenuHandler::UpdateSetUpMenuToClientL()

    {

    LOG( SIMPLE,

        "SETUPMENU: CSetUpMenuHandler::UpdateSetUpMenuToClientL calling" )

    iSatAppNameUpdated = ETrue;

    if ( iSetUpMenuArrived )

        {

        // SetUpMenu application name update is needed.

        iArrivedSetUpMenuData.iAlphaId.iAlphaId.Zero();

        iArrivedSetUpMenuData.iAlphaId.iAlphaId.Append( iUtils->SatAppName() );

        LOG( NORMAL, "SETUPMENU:   Name updated" )

        // Restore icon after update.

        AddIconToShellL(

            iArrivedSetUpMenuData.iAlphaId.iAlphaId,

            iArrivedSetUpMenuData.iIconId );

        // Update display, when ui is launched.

        MSatUiSession* uiSession = iUtils->SatUiHandler().UiSession();

        if ( uiSession && iUtils->SatUiHandler().UiLaunchedByUser() )

            {

            LOG( SIMPLE,

            "SETUPMENU: CSetUpMenuHandler::UpdateSetUpMenuToClientL \

            UiLaunchedByUser" )

            // Update it only when it is not empty.

            if ( 0 != iArrivedSetUpMenuData.NumberOfItems() )

                {

                LOG( SIMPLE,

                "SETUPMENU: CSetUpMenuHandler::UpdateSetUpMenuToClientL \

                item not empty" )

                // Send update to ui.

                // Client does not respond to setupmenu cmd, therefore NULL.

                uiSession->SendCommand(

                    &iArrivedSetUpMenuPckg,

                    NULL,

                    ESatSProactiveSetUpMenu );

                }

            }

        }

    LOG( SIMPLE,

        "SETUPMENU: CSetUpMenuHandler::UpdateSetUpMenuToClientL exiting" )

    }

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

// CSetUpMenuHandler::IssueUSATRequest

// Makes the request of SetUpMenu from SIM

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

//

void CSetUpMenuHandler::IssueUSATRequest( TRequestStatus& aStatus )

    {

    LOG( SIMPLE, "SETUPMENU: CSetUpMenuHandler::IssueUSATRequest calling" )

    // Without reset, old menu items stay in the list.

    iSetUpMenuData.Reset();

#ifdef __WINS__

    // Empty the IPC data

    RSat::TSetUpMenuV2 temp;

    iSetUpMenuData = temp;

#endif

    iUtils->USatAPI().NotifySetUpMenu( aStatus, iSetUpMenuPckg );

    LOG( SIMPLE, "SETUPMENU: CSetUpMenuHandler::IssueUSATRequestx exiting" )

    }

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

// CSetUpMenuHandler::CommandAllowed

// SetUpMenu is allowed always.

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

//

TBool CSetUpMenuHandler::CommandAllowed()

    {

    LOG( SIMPLE,

        "SETUPMENU: CSetUpMenuHandler::CommandAllowed calling" )

    TBool commandAllowed( ETrue );

    TBool nullText( EFalse );

    TInt err ( KErrNone );

    RSat::TItem item;

    TUint numberOfItems( iSetUpMenuData.NumberOfItems() );

    TBool titleIcon(

        ( RSat::ENotSelfExplanatory == iSetUpMenuData.iIconId.iQualifier ) ||

        ( RSat::ESelfExplanatory == iSetUpMenuData.iIconId.iQualifier ) );

    TBool itemIcons(

        ( RSat::ENotSelfExplanatory == iSetUpMenuData.iIconListQualifier ) ||

        ( RSat::ESelfExplanatory == iSetUpMenuData.iIconListQualifier ) );

    RSat::TSetUpMenuRspV1 setUpMenuRsp;

    RSat::TSetUpMenuRspV1Pckg setUpMenuRspPckg( setUpMenuRsp );

    // Check if some item does not have text

    for ( TUint count = 1; ( count <= numberOfItems ) && !nullText &&

        ( KErrNone == err ); count++ )

        {

        err = iSetUpMenuData.GetItem( count, item );

        if ( ( KErrNone == err ) && ( 0 == item.iItemString.Length() ) )

            {

            LOG( SIMPLE,

            "SETUPMENU: CSetUpMenuHandler::CommandAllowed item null" )

            nullText = ETrue;

            }

        }

    LOG2( SIMPLE,

    "SETUPMENU: CSetUpMenuHandler::CommandAllowed numberOfItems:%d",

    numberOfItems )

    // If icon is provided without any text

    if ( ( ( RSat::EAlphaIdProvided != iSetUpMenuData.iAlphaId.iStatus ) &&

             titleIcon ) || ( nullText && itemIcons ) )

        {

        setUpMenuRsp.iGeneralResult = RSat::KCmdDataNotUnderstood;

        setUpMenuRsp.iInfoType = RSat::KNoAdditionalInfo;

        setUpMenuRsp.iAdditionalInfo.Zero();

        setUpMenuRsp.SetPCmdNumber( setUpMenuRsp.PCmdNumber() );

        TerminalRsp( RSat::ESetUpMenu, setUpMenuRspPckg );

        commandAllowed = EFalse;