/*

* Copyright (c) 2005-2009 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: Implementation of CPhoneState class.

*

*/

// INCLUDE FILES

#include <avkon.rsg>

#include <bautils.h>

#include <eikenv.h>

#include <StringLoader.h>

#include <pevirtualengine.h>

#include <mpeclientinformation.h>

#include <mpeengineinfo.h>

#include <cpephonemodelif.h>

#include <featmgr.h>

#include <rconnmon.h>

#include <Profile.hrh>

#include <PUAcodes.hrh>

#include <telephonyvariant.hrh>

#include <aknsoundsystem.h>

#include <wlaninternalpskeys.h>

#include <btengdomainpskeys.h>

#include <btengdomaincrkeys.h>

#include <settingsinternalcrkeys.h>

#include <starterclient.h>

#include <rsssettings.h>

#include <telephonydomainpstypes.h>

#include <telinformationpskeys.h>

#include <coreapplicationuisdomainpskeys.h>

#include <mccecall.h>

#include <ccpdefs.h>

#include <LogsDomainCRKeys.h>

#include <spsettings.h>

#include <startupdomainpskeys.h>

#include <MediatorDomainUIDs.h>

#include <videotelcontrolmediatorapi.h>

#include <textresolver.h>

#include <phoneappvoipcommands.hrh>

#include <hwrmdomainpskeys.h>

#include <hal.h>

#include "phoneui.pan"

#include "cphonestate.h"

#include "mphonestatemachine.h"

#include "mphoneviewcommandhandle.h"

#include "tphonecmdparamboolean.h"

#include "tphonecmdparaminteger.h"

#include "tphonecmdparamkeyevent.h"

#include "tphonecmdparamdynmenu.h"

#include "tphonecmdparamcallheaderdata.h"

#include "tphonecmdparamincallindicatordata.h"

#include "tphonecmdparamnote.h"

#include "tphonecmdparamkeycapture.h"

#include "tphonecmdparamglobalnote.h"

#include "tphonecmdparamquery.h"

#include "tphonecmdparamstring.h"

#include "tphonecmdparamcallstatedata.h"

#include "tphonecmdparambitmap.h"

#include "tphonecmdparamappinfo.h"

#include "tphonecmdparamtranseffect.h"

#include "tphonecmdparamringtone.h"

#include "tphonecmdparamcustomdialer.h"

#include "cphonekeys.h"

#include "phoneui.hrh"

#include "phonerssbase.h"

#include "cphonebtaadisconnecthandler.h"

#include "cphonemainresourceresolver.h"

#include "cphonecenrepproxy.h"

#include "cphonepubsubproxy.h"

#include "phoneviewcommanddefinitions.h"

#include "phonelogger.h"

#include "phonestatedefinitions.h"

#include "cphonetimer.h"

#include "mphoneerrormessageshandler.h"

#include "cphoneclearblacklist.h"

#include "mphonecustomization.h"

#include "cphonemainerrormessageshandler.h"

#include "cphoneaccessorybthandler.h"

#include "cphonemediatorfactory.h"

#include "mphonemediatormessage.h"

#include "cphonemediatorsender.h"

#include "cphonereleasecommand.h"

#include "cphonecontinueemergencycallcommand.h"

#include "tphonecmdparamsfidata.h" 

#include "mphonestorage.h"

#include "phoneconstants.h"

#include "cphoneclearblacklist.h"

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

EXPORT_C CPhoneState::CPhoneState(

    MPhoneStateMachine* aStateMachine,

    MPhoneViewCommandHandle* aViewCommandHandle,

    MPhoneCustomization* aCustomization) :

    iStateMachine( aStateMachine ),

    iViewCommandHandle( aViewCommandHandle ),

    iCustomization( aCustomization )

    {

    // Need to get current SimState for inherited classis

    iPreviousSimState = SimState();

    __ASSERT_ALWAYS(

        aStateMachine && aViewCommandHandle,

        Panic( EPhoneCtrlParameterNotInitialized ) );

    }

EXPORT_C void CPhoneState::BaseConstructL()

    {

    __LOGMETHODSTARTEND(EPhoneControl, "CPhoneState::BaseConstructL() ");

    if ( !iUiCommandManager )

        {

        iUiCommandManager = CPhoneUiCommandManager::NewL(

                        this,

                        *iViewCommandHandle,

                        *iStateMachine );

        }

    if ( !iNumberEntryManager )

        {

        iNumberEntryManager = CPhoneNumberEntryManager::NewL(

                this,

                *iViewCommandHandle,

                *iStateMachine,

                iCustomization,

                *iUiCommandManager );

        }

    }

EXPORT_C CPhoneState::~CPhoneState()

    {

    delete iNumberEntryManager;

    delete iUiCommandManager;

    }

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

// CPhoneState::EikonEnv

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

//

EXPORT_C CEikonEnv* CPhoneState::EikonEnv() const

    {

    __LOGMETHODSTARTEND(EPhoneControl, "CPhoneState::EikonEnv( ) ");

    return iEnv;

    }

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

// CPhoneState::SetEikonEnv

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

//

EXPORT_C void CPhoneState::SetEikonEnv( CEikonEnv* aEnv )

    {

    __LOGMETHODSTARTEND(EPhoneControl, "CPhoneState::SetEikonEnv( ) ");

    iEnv = aEnv;

    }

// <-------------------------- PHONE ENGINE EVENTS --------------------------->

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

// CPhoneState::HandlePhoneEngineMessageL

// Default handling for Phone Engine messages

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

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

//

EXPORT_C void CPhoneState::HandlePhoneEngineMessageL(

    const TInt aMessage,

    TInt aCallId )

    {

    __LOGMETHODSTARTEND(EPhoneControl, "CPhoneState::HandlePhoneEngineMessageL() ");

    CPhoneAccessoryBTHandler* accessoryBtHandler;

    switch ( aMessage )

        {

        case MEngineMonitor::EPEMessageNetworkRegistrationStatusChange:

            {

            __PHONELOG1( EBasic, EPhoneControl,

               "PHONEUI_ERROR: EPEMessageNetworkRegistrationStatusChange - RegistrationStatus =%d ",

               iStateMachine->PhoneEngineInfo()->NetworkRegistrationStatus());

            }

            break;

        case MEngineMonitor::EPEMessageAudioMuteChanged:

            HandleAudioMuteChangedL();

            break;

        case MEngineMonitor::EPEMessageAudioOutputChanged:

            HandleAudioOutputChangedL();

            UpdateUiCommands();

            break;

        case MEngineMonitor::EPEMessageAvailableAudioOutputsChanged:

            HandleAudioAvailableOutputChangedL();

            if ( iStateMachine->PhoneEngineInfo()->AudioOutput() != EPENotActive )

                {

                UpdateUiCommands();

                }

            break;

        case MEngineMonitor::EPEMessageChangedCallDuration:

            HandleChangedCallDurationL( aCallId );

            break;

        case MEngineMonitor::EPEMessageRemoteBusy:

            break;

        case MEngineMonitor::EPEMessageCallWaiting:

        case MEngineMonitor::EPEMessageProfileChanged:

            break;

        case MEngineMonitor::EPEMessageRemoteTerminated:

            /* Flow through */

        case MEngineMonitor::EPEMessageDisconnecting:

            HandleDisconnectingL( aCallId );

            break;

        case MEngineMonitor::EPEMessageTransferDone:

            SendGlobalInfoNoteL( EPhoneInCallTransferred, ETrue );

            break;

       case MEngineMonitor::EPEMessageInitiatedEmergencyCall:

            HandleInitiatedEmergencyCallL( aCallId );

            break;

       case MEngineMonitor::EPEMessageInitiatedEmergencyWhileActiveVideo:

           HandleInitiatedEmergencyWhileActiveVideoL();

           break;

       case MEngineMonitor::EPEMessageCallSecureStatusChanged:

           HandleCallSecureStatusChangeL( aCallId );

           if ( iCustomization )

               {

               iCustomization->HandlePhoneEngineMessageL( aMessage,

                   aCallId );

               }

           break;

        case MEngineMonitor::EPEMessageIssuingUSSDRequest:

            {

            TPhoneCmdParamBoolean globalNotifierParam;

            globalNotifierParam.SetBoolean( EFalse );

            iViewCommandHandle->ExecuteCommandL(

                EPhoneViewSetGlobalNotifiersDisabled,

                &globalNotifierParam );

            iNumberEntryManager->NumberEntryClearL();

            }

            break;

        case MEngineMonitor::EPEMessageIssuedUSSDRequest:

            UpdateUiCommands();

            break;

        // *#9990#

        case MEngineMonitor::EPEMessageShowBTLoopback:

            iStateMachine->SendPhoneEngineMessage( MPEPhoneModel::EPEMessageEndDTMF );

            accessoryBtHandler = CPhoneAccessoryBTHandler::NewLC(

            accessoryBtHandler->ShowBTLoopbackL();

            CleanupStack::PopAndDestroy( accessoryBtHandler );

            break;

        // *#2820#

        case MEngineMonitor::EPEMessageShowBTDeviceAddress:

            iStateMachine->SendPhoneEngineMessage( MPEPhoneModel::EPEMessageEndDTMF );

            accessoryBtHandler = CPhoneAccessoryBTHandler::NewLC(

            accessoryBtHandler->ShowBTAddressL();

            CleanupStack::PopAndDestroy( accessoryBtHandler );

            break;

        // *#7370#

        case MEngineMonitor::EPEMessageActivateRfsDeep:

            iStateMachine->SendPhoneEngineMessage( MPEPhoneModel::EPEMessageEndDTMF );

            iViewCommandHandle->ExecuteCommandL( EPhoneViewLaunchRfsDeep );

            break;

        // *#7780#

        case MEngineMonitor::EPEMessageActivateRfsNormal:

            iStateMachine->SendPhoneEngineMessage( MPEPhoneModel::EPEMessageEndDTMF );

            iViewCommandHandle->ExecuteCommandL( EPhoneViewLaunchRfsNormal );

            break;

        // *#62209526#

        case MEngineMonitor::EPEMessageShowWlanMacAddress:

            iStateMachine->SendPhoneEngineMessage( MPEPhoneModel::EPEMessageEndDTMF );

            ShowWlanMacAddressL();

            break;

        case MEngineMonitor::EPEMessageThumbnailLoadingCompleted:

        case MEngineMonitor::EPEMessageRemotePartyInfoChanged:

            break;

        case MEngineMonitor::EPEMessageSIMStateChanged:

            __PHONELOG1( EBasic, EPhoneControl, "CPhoneState::HandlePhoneEngineMessageL - simStateChanged =%d", SimState()  );

            HandleSimStateChangedL();

            break;

        case MEngineMonitor::EPEMessageShowIncCallGroupIndex:

            HandleCugInUseNoteL();

            break;

        default:

            TBool handled( EFalse );

            if ( iCustomization )

                {

                handled = iCustomization->HandlePhoneEngineMessageL(

                                aMessage, aCallId );

                }

            if ( EFalse == handled )

                {

                MPhoneMediatorMessage* mediatorMessage = CPhoneMediatorFactory::Instance()->MediatorMessage( aMessage, aCallId );

                if( mediatorMessage )

                    {

                    CleanupDeletePushL( mediatorMessage );

                    mediatorMessage->ExecuteL();

                    CleanupStack::PopAndDestroy( mediatorMessage );

                    mediatorMessage = NULL;

                    }

                }

            break;

        }

    }

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

// CPhoneState::HandleAudioMuteChangedL

// Default handling for EPEMessageAudioMuteChanged message

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

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

//

EXPORT_C void CPhoneState::HandleAudioMuteChangedL()

    {

    __LOGMETHODSTARTEND(EPhoneControl, "CPhoneState::HandleAudioMuteChangedL() ");

    __ASSERT_DEBUG( iStateMachine->PhoneEngineInfo(),

        Panic( EPhoneCtrlInvariant ) );

    UpdateUiCommands();

    }

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

// CPhoneState::HandleAudioOutputChangedL

// Default handling for EPEMessageAudioOutputChanged message

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

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

//

EXPORT_C void CPhoneState::HandleAudioOutputChangedL()

    {

    __LOGMETHODSTARTEND(EPhoneControl, "CPhoneState::HandleAudioOutputChangedL() ");

    __ASSERT_DEBUG( iStateMachine->PhoneEngineInfo(), Panic( EPhoneCtrlInvariant ) );

    }

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

// CPhoneState::HandleSimStateChangedL

// Handles changes in the SIM card state.

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

//

void CPhoneState::HandleSimStateChangedL()

    {

    __LOGMETHODSTARTEND( EPhoneControl, "CPhoneState::HandleSimStateChangedL()" );

    CPhoneMainResourceResolver& resolver = *CPhoneMainResourceResolver::Instance();

    TPESimState simState = SimState();

    __PHONELOG2( EBasic, EPhoneControl, "SIM state was changed from %d to %d", iPreviousSimState, simState );

    switch ( simState )

        {

        case EPESimUsable: // Falls through.

        case EPESimReadable: // Falls through.

        case EPESimNotReady:

            {

            if ( iPreviousSimState == EPESimNotPresent )

                {

                __PHONELOG( EBasic, EPhoneControl, "SIM card was inserted, rebooting the phone" );

                RStarterSession starterSession;

                User::LeaveIfError( starterSession.Connect() );

                CleanupClosePushL( starterSession );

                HBufC* queryText = StringLoader::LoadLC( resolver.ResolveResourceID( EPhoneRebootRequired ) );

                TPhoneCmdParamQuery queryParams;

                queryParams.SetCommandParamId( TPhoneCommandParam::EPhoneParamRebootQuery );

                queryParams.SetQueryPrompt( *queryText );

                queryParams.SetDefaultCba( R_AVKON_SOFTKEYS_OK_EMPTY );

                iViewCommandHandle->ExecuteCommandL( EPhoneViewShowQuery, &queryParams );

                starterSession.Reset( RStarterSession::ESIMStatusChangeReset );

                CleanupStack::PopAndDestroy( 2, &starterSession ); // queryText

                }

            break;

            }

        case EPESimNotPresent:

            {

            if ( iPreviousSimState == EPESimUsable ||

                 iPreviousSimState == EPESimReadable ||

                 iPreviousSimState == EPESimNotReady )

                {

                __PHONELOG( EBasic, EPhoneControl, "SIM card was removed" );

                TPhoneCmdParamGlobalNote globalNoteParam;

                globalNoteParam.SetType( EPhoneMessageBoxInformation );

                globalNoteParam.SetTextResourceId(

                    CPhoneMainResourceResolver::Instance()->

                    ResolveResourceID( EPhoneSimRemoved ) );

                iViewCommandHandle->ExecuteCommandL(

                    EPhoneViewShowGlobalNote, &globalNoteParam );

                }

            // Show security note, if SIM not present and KFeatureIdFfSimlessOfflineSupport is disabled.

            else if ( !FeatureManager::FeatureSupported( KFeatureIdFfSimlessOfflineSupport ) &&

                    ( iPreviousSimState != EPESimNotSupported ) )

                {

                StartShowSecurityNoteL();

                }

            break;

            }

        default:

            break;

        }

    iPreviousSimState = simState;

    }

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

// CPhoneState::SendDtmfKeyEventL

// send dtmf event when,

// -touch dtmf dialer is NOT visible

// -query is not active

// -menubar is not open

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

//

void CPhoneState::SendDtmfKeyEventL( const TKeyEvent& aKeyEvent,

               TEventCode aEventCode  )

    {

    // Send the key event to the phone engine.

    SendKeyEventL( aKeyEvent, aEventCode );

    }

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

// CPhoneState::HandleErrorL

// Default handling for HandleError message

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

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

//

EXPORT_C void CPhoneState::HandleErrorL( const TPEErrorInfo& aErrorInfo )

    {

    __LOGMETHODSTARTEND(EPhoneControl, "CPhoneState::HandleErrorL()");

    __PHONELOG1( EBasic, EPhoneControl,

            "PhoneUIControl: CPhoneState::HandleErrorL - aErrorInfo.iErrorCode =%d ",

            aErrorInfo.iErrorCode );

    __PHONELOG1( EBasic, EPhoneControl,

        "PhoneUIControl: CPhoneState::HandleErrorL - aErrorInfo.iCallId =%d ",

        aErrorInfo.iCallId );

    // Do the common error handling (display proper notes etc)

    }

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

// CPhoneState::HandleChangedCallDurationL

// Default handling for EPEMessageChangedCallDuration message

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

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

void CPhoneState::HandleChangedCallDurationL( TInt aCallId )

    {

     __LOGMETHODSTARTEND(EPhoneControl, "CPhoneState::HandleChangedCallDurationL() ");

    TInt ret = KErrNone;

    TInt isDisplayOn;

    ret = HAL::Get( HALData::EDisplayState, isDisplayOn );

    // Update only if the display is on or if HAL::Get returns an error, 

    // in which case display value cannot be trusted.

    if ( ret || isDisplayOn )

        {

        // Get the call duration

        TTimeIntervalSeconds seconds =

            iStateMachine->PhoneEngineInfo()->CallDuration( aCallId );

        TPhoneCmdParamInteger time;

        time.SetInteger(seconds.Int());

        iViewCommandHandle->ExecuteCommandL(EPhoneViewUpdateCallHeaderCallDuration, aCallId, &time);

        }

    }	

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

// CPhoneState::HandleDisconnectingL

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

//

EXPORT_C void CPhoneState::HandleDisconnectingL( TInt aCallId )

    {

    __LOGMETHODSTARTEND(EPhoneControl, "CPhoneState::HandleDisconnectingL( ) ");

    iViewCommandHandle->ExecuteCommandL( EPhoneViewStopRingTone );

    CPhoneClearBlacklist::Instance()->ClearBlackListOnNextKey();

    }

// <------------------------------- KEY EVENTS ------------------------------->

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

// CPhoneState::HandleKeyMessageL( aMessage, aKeyCode )

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

//

EXPORT_C void CPhoneState::HandleKeyMessageL(

    TPhoneKeyEventMessages /*aMessage*/,

    TKeyCode /*aKeyCode*/ )

    {

    __LOGMETHODSTARTEND(EPhoneControl, "CPhoneState::HandleKeyMessageL( ) ");

    }

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

// CPhoneState::HandleKeyEventL( aKeyEvent, aEventCode )

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

//

EXPORT_C void CPhoneState::HandleKeyEventL(

    const TKeyEvent& aKeyEvent,

    TEventCode aEventCode )

    {