/*

* 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 <AknUtils.h>

#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 <UikonInternalPSKeys.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 "tphonecmdparamaudiooutput.h"

#include "tphonecmdparamaudioavailability.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 "cphonereconnectquery.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 "cphonecallheadermanager.h"

#include "cphonenumberentrymanager.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 ),

    iEnv( *CEikonEnv::Static() )

    {

    // Need to get current SimState for inherited classis

    iPreviousSimState = SimState();

    __ASSERT_ALWAYS(

        aStateMachine && aViewCommandHandle,

        Panic( EPhoneCtrlParameterNotInitialized ) );

    if ( FeatureManager::FeatureSupported( KFeatureIdOnScreenDialer ) )

        {

        iOnScreenDialer = ETrue;

        }

    }

EXPORT_C void CPhoneState::BaseConstructL()

    {

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

    if ( !iCbaManager )

        {

        iCbaManager = CPhoneCbaManager::NewL(

                        this,

                        *iViewCommandHandle,

                        *iStateMachine );

        }

    }

EXPORT_C CPhoneState::~CPhoneState()

    {

    if( iAlsLineChangeKeyPressTimer )

        {

        if( iAlsLineChangeKeyPressTimer->IsActive() )

            {

            iAlsLineChangeKeyPressTimer->CancelTimer();

            }

        delete iAlsLineChangeKeyPressTimer;

        }

    delete iNumberEntryManager;

    delete iCallHeaderManager;

    delete iCbaManager;

    }

// <-------------------------- 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();

            // Go to current state implementation

            iCbaManager->UpdateInCallCbaL();

            SetTouchPaneButtons(0);

            break;

        case MEngineMonitor::EPEMessageAvailableAudioOutputsChanged:

            HandleAudioAvailableOutputChangedL();

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

                {

                // Go to current state implementation

                iCbaManager->UpdateInCallCbaL();

                SetTouchPaneButtons(0);

                }

            break;

        case MEngineMonitor::EPEMessageChangedCallDuration:

            HandleChangedCallDurationL( aCallId );

            break;

        case MEngineMonitor::EPEMessageRemoteBusy:

            HandleRemoteBusyL( aCallId );

            break;

        case MEngineMonitor::EPEMessageCallWaiting:

            // No need to send waiting notification for user.

            //SendGlobalInfoNoteL( EPhoneWaitingText, ETrue );

            break;

        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:

            {

             // Enable global notes

            TPhoneCmdParamBoolean globalNotifierParam;

            globalNotifierParam.SetBoolean( EFalse );

            iViewCommandHandle->ExecuteCommandL(

                EPhoneViewSetGlobalNotifiersDisabled,

                &globalNotifierParam );

            if ( !IsOnScreenDialerSupported() && IsNumberEntryUsedL() )

                {

                // Remove number entry from screen

                iViewCommandHandle->ExecuteCommandL(

                    EPhoneViewRemoveNumberEntry );

                }

            else if ( IsOnScreenDialerSupported() )

                {

                NumberEntryClearL();

                }

            }

            break;

        case MEngineMonitor::EPEMessageIssuedUSSDRequest:

            // Go to current state implementation

            iCbaManager->UpdateInCallCbaL();

            break;

        // *#9990#

        case MEngineMonitor::EPEMessageShowBTLoopback:

            // Stop playing DTMF tone

            iStateMachine->SendPhoneEngineMessage( MPEPhoneModel::EPEMessageEndDTMF );

            accessoryBtHandler = CPhoneAccessoryBTHandler::NewLC(

                iViewCommandHandle, iStateMachine, this );

            accessoryBtHandler->ShowBTLoopbackL();

            CleanupStack::PopAndDestroy( accessoryBtHandler );

            break;

        // *#2820#

        case MEngineMonitor::EPEMessageShowBTDeviceAddress:

            // Stop playing DTMF tone

            iStateMachine->SendPhoneEngineMessage( MPEPhoneModel::EPEMessageEndDTMF );

            accessoryBtHandler = CPhoneAccessoryBTHandler::NewLC(

                iViewCommandHandle, iStateMachine, this );

            accessoryBtHandler->ShowBTAddressL();

            CleanupStack::PopAndDestroy( accessoryBtHandler );

            break;

        // *#7370#

        case MEngineMonitor::EPEMessageActivateRfsDeep:

            // Stop playing DTMF tone

            iStateMachine->SendPhoneEngineMessage( MPEPhoneModel::EPEMessageEndDTMF );

            // Launch RFS

            iViewCommandHandle->ExecuteCommandL( EPhoneViewLaunchRfsDeep );

            if ( !IsOnScreenDialerSupported() )

                {

                // Do state-specific operation when number entry is cleared

                HandleNumberEntryClearedL();

                }

            break;

        // *#7780#

        case MEngineMonitor::EPEMessageActivateRfsNormal:

            // Stop playing DTMF tone

            iStateMachine->SendPhoneEngineMessage( MPEPhoneModel::EPEMessageEndDTMF );

            // Launch RFS

            iViewCommandHandle->ExecuteCommandL( EPhoneViewLaunchRfsNormal );

            if ( !IsOnScreenDialerSupported() )

                {

                // Do state-specific operation when number entry is cleared

                HandleNumberEntryClearedL();

                }

            break;

        // *#62209526#

        case MEngineMonitor::EPEMessageShowWlanMacAddress:

            // Stop playing DTMF tone

            iStateMachine->SendPhoneEngineMessage( MPEPhoneModel::EPEMessageEndDTMF );

            ShowWlanMacAddressL();

            break;

        case MEngineMonitor::EPEMessageThumbnailLoadingCompleted:

            // Update call buble

            UpdateRemoteInfoDataL( aCallId );

            break;

        case MEngineMonitor::EPEMessageRemotePartyInfoChanged:

            UpdateRemoteInfoDataL ( aCallId );

            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 ) );

    TPhoneCmdParamBoolean booleanParam;

    const TBool audioMute = iStateMachine->PhoneEngineInfo()->AudioMute();

    booleanParam.SetBoolean( audioMute );

    iViewCommandHandle->ExecuteCommandL( EPhoneViewActivateMuteUIChanges,

        &booleanParam );

    SetTouchPaneButtons(0);

    }

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

// 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 ) );

    TPhoneCmdParamAudioOutput outputParam;

    // Output

    const TPEAudioOutput audioOutput =

        iStateMachine->PhoneEngineInfo()->AudioOutput();

    outputParam.SetAudioOutput( audioOutput );

    // view update

    iViewCommandHandle->ExecuteCommandL( EPhoneViewActivateAudioPathUIChanges,

        &outputParam );

    // Previous Output

    TPEPhoneAudioRouteParameters RouteParameters = iStateMachine->

        PhoneEngineInfo()->RouteParameters();

    const TPEAudioOutput previousOutput =

        RouteParameters.iPreviousOutput;

    // BT availability

    TBool btAvailable = iStateMachine->PhoneEngineInfo()->AudioOutputAvailable(

            EPEBTAudioAccessory );

    // Show note or BT disconnect handler

    if ( audioOutput != EPENotActive &&

         previousOutput == EPEBTAudioAccessory &&

         !btAvailable )

        {

        CPhoneBtaaDisconnectHandler::InstanceL()->HandleConnectionLostL();

        }

    else if ( audioOutput == EPEBTAudioAccessory && 

            previousOutput != EPEBTAudioAccessory &&

            btAvailable )

        {

        CPhoneAccessoryBTHandler* bt = CPhoneAccessoryBTHandler::NewLC(

            iViewCommandHandle, iStateMachine, this );

        bt->ShowBTActivatedL();

        CleanupStack::PopAndDestroy( bt );

        }

    else if ( audioOutput == EPENotActive &&

              CPhoneBtaaDisconnectHandler::InstanceL()->IsQuery() )

        {

        CPhoneBtaaDisconnectHandler::InstanceL()->Cancel();

        }

    else if ( RouteParameters.iShowNote && audioOutput == EPELoudspeaker )

        {

        CAknKeySoundSystem* keySounds =

               static_cast<CAknAppUi*>( iEnv.EikAppUi() )->KeySounds();

        keySounds->PlaySound( EAvkonSIDIHFActive );

        }

    }

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

// 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.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;