/*

* 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:  Message handler

*

*/

// INCLUDE FILES

#include "cpecenrepmonitor.h"

#include "cpeclientcallrequestmonitor.h"

#include "cpeclientcallrequestmonitor.h"

#include "cpeclientcommandhandlermonitor.h"

#include "cpeclientservices.h"

#include "cpeexternaldatahandler.h"

#include "cpemanualcallcontrolhandler.h"

#include "cpemessagehandler.h"

#include "cpeparseremergencynumberhandler.h"

#include "cpeparsermanufacturerhandler.h"

#include "cpeparsermischandler.h"

#include "cpeparserphonenumberhandler.h"

#include "cpeparsersimcontrolhandler.h"

#include "cpeparsersscallhandler.h"

#include "cpeparsersshandler.h"

#include "cpeparservoipnumberhandler.h"

#include "cpepcnparserprocedurehandler.h"

#include "cpesimstatemonitor.h"

#include "cpetimer.h"

#include "mpephonemodelinternal.h"

#include "mpeservicehandling.h"

#include "cperemotepartyinfomediator.h"

#include <apacmdln.h>

#include <apgcli.h>

#include <apgtask.h>

#include <AudioPreference.h>

#include <barsc.h> 

#include <barsread.h>

#include <bldvariant.hrh>

#include <ccpdefs.h>

#include <coreapplicationuisdomainpskeys.h>

#include <cpeclientinformation.h>

#include <cpegsmaudiodata.h>

#include <CPhoneGsmHandlerContainer.h>

#include <CPhoneGsmOptionContainerBase.h>

#include <CPhoneGsmParserBase.h>

#include <CPhoneGsmParserResult.h>

#include <featmgr.h>

#include <mccecall.h>

#include <mpeaudiodata.h>

#include <mpecallhandling.h>

#include <mpecontacthandling.h>

#include <mpedatastore.h>

#include <mpeloghandling.h>

#include <pathinfo.h>

#include <pepanic.pan>

#include <PhCltTypes.h>

#include <PhoneGsmParser.h>

#include <ProfileEngineDomainConstants.h>

#include <talogger.h>

#include <w32std.h>

// EXTERNAL DATA STRUCTURES

// None.

// EXTERNAL FUNCTION PROTOTYPES  

// None.

// CONSTANTS

// Prefix change off. See settingsinternalcrkeys.h

const TInt KPEPrefixChangeOff = 0;

// Prefix change on. See settingsinternalcrkeys.h

const TInt KPEPrefixChangeOn = 1;

// International prefix

_LIT( KPEIntPrefix, "+" );

// Japan prefix

_LIT( KPEJapanPrefix, "+81" );

// Zero prefix

_LIT( KPEZeroPrefix, "0" );

// Valid dtmf sting

_LIT( KValidDtmfChars, "0123456789pw*+#" );

// Timeout for automatic answer. 

const TInt KPEAutomaticAnswerTimeOut = 5000000;

_LIT( KPEClirSuppress, "*31#" );

_LIT( KPEClirInvoke, "#31#" );

const TInt KPENumberPlus = '+';

const TInt KPENumberHash = '#'; 

const TInt KPENumberAsterisk = '*'; 

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

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

// CPEMessageHandler::NewL

// Two-phased constructor.

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

//

CPEMessageHandler* CPEMessageHandler::NewL

        ( 

        MPEPhoneModelInternal& aModel,

        MPECallHandling& aCallHandling,

        MEngineMonitor& aEngineMonitor,

        CPEGsmAudioData& aAudioData,

        MPELogHandling& aLogHandling,

        MPEContactHandling& aContactHandling,

        CPESimStateMonitor& aSimStateMonitor,

        CPEExternalDataHandler& aGsmExternalDataHandler,

        MPEServiceHandling& aServiceHandling,

        RFs& aFsSession )

    {

    CPEMessageHandler* self = new ( ELeave ) CPEMessageHandler( 

        aModel, 

        aCallHandling, 

        aEngineMonitor, 

        aAudioData, 

        aLogHandling, 

        aContactHandling, 

        aSimStateMonitor,

        aGsmExternalDataHandler,

        aServiceHandling,

        aFsSession );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CPEMessageHandler::CPEMessageHandler

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

// might leave.

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

//

CPEMessageHandler::CPEMessageHandler( 

        MPEPhoneModelInternal& aModel,                 // The model of the phone object which owns this object

        MPECallHandling& aCallHandling,              // The reference parameter of the phone data object which is used to create call handling request

        MEngineMonitor& aEngineMonitor,        // The reference parameter of the engine monitor object which is used to communication with phone application

        CPEGsmAudioData& aAudioData,              // The reference parameter of the audio data object which is used to handle audio requests

        MPELogHandling& aLogHandling,                // The reference parameter of the logs data object which is used to handle log requests   

        MPEContactHandling& aContactHandling,          // The reference parameter of the contact data object which is used to handle contact requests

        CPESimStateMonitor& aSimStateMonitor,

        CPEExternalDataHandler& aExternalDataHandler, // The reference parameter of external data handler object

        MPEServiceHandling& aServiceHandling,

        RFs& aFsSession )                // The reference parameter of CustomAPI

        : iModel( aModel ), 

            iCallHandling( aCallHandling ),

            iEngineMonitor( aEngineMonitor ),

            iGsmAudioData( aAudioData ),

            iLogHandling( aLogHandling ),

            iContactHandling( aContactHandling ),

            iExternalDataHandler( aExternalDataHandler ),

            iSimStateMonitor( aSimStateMonitor ),

            iFsSession( aFsSession ),

			iSwitchToVidCalReconFlag( EFalse ),

            iServiceHandling( aServiceHandling ),

            iDataStore( *aModel.DataStore() )

    {

    }

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

// CPEMessageHandler::BaseConstructL

// Performs base construction of the object.

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

//

void CPEMessageHandler::ConstructL()

    {

    iClientInformation = CPEClientInformation::NewL();

    iParser = PhoneGsmParser::CreateParserL();

    iOptions = PhoneGsmParser::CreateOptionContainerL();

    iManualCallControlHandler = CPEManualCallControlHandler::NewL( iCallHandling, *this, iDataStore );

    iClientServices = CPEClientServices::NewL( iModel, *this, iCallHandling, *iManualCallControlHandler );

    iParserHandlerContainer = CPhoneGsmHandlerContainer::NewL();

    // NOTE: The handler objects will break some CleanUpStack usage rules:

    // CPEMessageHandler class construct handler objects but ownership will be 

    // transfered to Handler Container. And therefore CleanUpStack will be 

    // used to member object because if iParserHandlerContainer->AddHandlerL 

    // leaves CPEMessageHandler don't delete handler object hence CleanUpStack

    // must delete handler object. 

    // Handles manufacturer specific codes from the parser.

    CPEParserManufacturerHandler* manufacturerHandler = 

        new ( ELeave ) CPEParserManufacturerHandler( iModel, iCallHandling, iFsSession );

    CleanupStack::PushL( manufacturerHandler );

    iParserHandlerContainer->AddHandlerL( *manufacturerHandler ); // ownership will be transfered to Handler Container.

    CleanupStack::Pop( manufacturerHandler );

    // Handles misc codes from the parser.

    CPEParserMiscHandler* miscHandler = new ( ELeave ) CPEParserMiscHandler( 

        *this, 

        iCallHandling );

    CleanupStack::PushL( miscHandler );

    iParserHandlerContainer->AddHandlerL( *miscHandler );// ownership will be transfered to Handler Container.

    CleanupStack::Pop( miscHandler );

    CPEParserPhoneNumberHandler* tempPhoneNumberHandler = 

        new ( ELeave ) CPEParserPhoneNumberHandler( *this, 

                                                       iCallHandling, 

                                                       iDataStore );

    CleanupStack::PushL( tempPhoneNumberHandler );

    iParserHandlerContainer->AddHandlerL( *tempPhoneNumberHandler ); // ownership will be transfered to Handler Container.

    CleanupStack::Pop( tempPhoneNumberHandler );

    iPhoneNumberHandler = tempPhoneNumberHandler;

    // Handles sim control procedures from the parser.

    CPEParserSimControlHandler* simControlHandler = CPEParserSimControlHandler::NewL( 

        iModel, 

        iContactHandling );

    CleanupStack::PushL( simControlHandler );

    iParserHandlerContainer->AddHandlerL( *simControlHandler );// ownership will be transfered to Handler Container.

    CleanupStack::Pop( simControlHandler );

    // Handles supplementary services during calls from the parser.

    CPEParserSSCallHandler* sSCallHandler = new ( ELeave ) CPEParserSSCallHandler( 

        *this, 

        iModel, 

        *iManualCallControlHandler );

    CleanupStack::PushL( sSCallHandler );

    iParserHandlerContainer->AddHandlerL( *sSCallHandler );// ownership will be transfered to Handler Container.

    CleanupStack::Pop( sSCallHandler );

    iSSHandler = CPEParserSSHandler::NewL( *this, iModel ); 

    iParserHandlerContainer->AddHandlerL( *iSSHandler );// ownership will be transfered to Handler Container.

    // Handles pcn service requests from the parser.

    CPEPcnParserProcedureHandler* pcnProcedureHandler = CPEPcnParserProcedureHandler::NewL( 

        *this, 

        iModel ); 

    CleanupStack::PushL( pcnProcedureHandler );

    iParserHandlerContainer->AddHandlerL( *pcnProcedureHandler );// ownership will be transfered to Handler Container.

    CleanupStack::Pop( pcnProcedureHandler );

    // Handles emergency phone number

    CPEParserEmergencyNumberHandler* tempEmergencyNumberHandler 

        = new ( ELeave ) CPEParserEmergencyNumberHandler( *this, 

                                                          iCallHandling, 

                                                          iDataStore );

    CleanupStack::PushL( tempEmergencyNumberHandler );

    iParserHandlerContainer->AddHandlerL( *tempEmergencyNumberHandler ); // ownership will be transfered to Handler Container.

    CleanupStack::Pop( tempEmergencyNumberHandler );

    iEmergencyNumberHandler = tempEmergencyNumberHandler;

    CPEParserVoipNumberHandler* tempVoipNumberHandler

        = CPEParserVoipNumberHandler::NewLC( *this, 

                                               iCallHandling, 

                                               iServiceHandling,

                                               iDataStore );

    iParserHandlerContainer->AddHandlerL( *tempVoipNumberHandler ); // ownership will be transfered to Handler Container.

    CleanupStack::Pop( tempVoipNumberHandler );

    iVoipNumberHandler = tempVoipNumberHandler;

    iAutomaticAnswerTimer = CPETimer::NewL( iModel );

    // Reserve needed callinfo and remoteinfo from heap.

    iCallInfo = new ( ELeave ) RMobileCall::TMobileCallInfoV3;

    iResult = PhoneGsmParser::CreateResultL();

    }

// Destructor

CPEMessageHandler::~CPEMessageHandler()

    {

    delete iClientInformation;

    delete iAsyncCallBack;

    delete iCallInfo;

    delete iAutomaticAnswerTimer;

    delete iParserHandlerContainer;

    delete iClientServices;

    delete iManualCallControlHandler;

    delete iOptions;

    delete iParser;

    delete iResult;

    }

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

// CPEMessageHandler::HandleAnswerCall

// Handles answer message from phone application. Method calls AnswerCall 

// method from the CallHandling subsystem.

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

//

TInt CPEMessageHandler::HandleAnswerCall(

        const TBool aAutomaticAnswer ) // Informs is this automatic answer or not

    {

    // Stop DTMF sending and empty buffers if answer was requested in the

    // middle of DTMF sequence.

    StopDtmfSending();

    //Check if this is automatic answer and play redialCompletedTone (confusing naming)

    if( !aAutomaticAnswer )

        {

        iAutomaticAnswerTimer->Cancel();

        }

    return iCallHandling.AnswerCall();

    }

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

// CPEMessageHandler::HandleAudioRouting

// Handles accessory mode changed message from AudioHandling subsystem. Method 

// fecths accessory mode from AudioHandling subsystem and method sets new accessory

// mode value to the CPEEngineInfo class. Method finds previously used volume

// values for accessory and changes volume accordingly.

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

//

TInt CPEMessageHandler::HandleAudioRouting( TBool aVideoCall, TInt aCallId )

    {

    TInt error( ECCPErrorNone );

    if ( aCallId == KPEEmergencyCallId )     

         {

         error = iGsmAudioData.HandleEnergencyCallStarting();

         }

     else

         {

         error = iGsmAudioData.HandleCallStarting( aVideoCall );

         }

    return error;

    }

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

// CPEMessageHandler::HandleRoutePreferenceChanged

// Handles route preference changed message from AudioHandling subsystem. 

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

//

TInt CPEMessageHandler::HandleRoutePreferenceChanged()

    {

    TInt error( ECCPErrorNone );

    TEFLOGSTRING( KTAMESINT, "PE CPEMessageHandler::HandleRoutePreferenceChanged()" );

    error = iGsmAudioData.CallAudioRoutePreferenceChanged();

    return error;

    }    

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

// CPEMessageHandler::HandleContinueDtmfSending

// Handles continue dtmf sending after 'w' character in the dtmf string

// Method calls ContinueDtmfSending or StopDtmfSending method from the 

// CallHandling subsystem.

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

//

void CPEMessageHandler::HandleContinueDtmfSending( 

        const TBool aContinue )

    {

    if ( aContinue )

        {

        HandleSendDtmf();

        }

    else

        {

        StopDtmfSending();

        }

    }

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

// CPEMessageHandler::HandleReleaseAll

// Handles release all message from phone application

// Method calls ReleaseAll method from the CallHandling subsystem object..

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

//

TInt CPEMessageHandler::HandleReleaseAll()

    {

    return iCallHandling.ReleaseAll();

    }

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

// CPEMessageHandler::HandleReleaseCall

// Handles release message from phone application

// Method fecths call id number from the CPEEngineInfo structure and then

// Method calls HangUp method from the CallHandling subsystem.

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

//

TInt CPEMessageHandler::HandleReleaseCall( TPEHangUpOptions aAutoResumeOption )

    {

    TInt callId;

    TInt errorCode( ECCPErrorNone );

    callId = iDataStore.CallId();

    if ( CallIdCheck::IsVideo( callId ) )

        {

        //Video call

        iGsmAudioData.StopInbandTonePlay();

        errorCode = iCallHandling.HangUp( callId, ETPEHangUpNotResumeHeldCall );

        }

    else

        {

        errorCode = iCallHandling.HangUp( callId, aAutoResumeOption );

        }

    return errorCode;

    }

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

// CPEMessageHandler::HandleReleaseConference

// Handles release message from phone application

// Method calls HangUp method from the CallHandling subsystem.

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

//

TInt CPEMessageHandler::HandleReleaseConference()

    {

    return iCallHandling.ReleaseConference(); 

    }

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

// CPEMessageHandler::HandleSendDtmf

// Handles send dtmf message from phone application

// Method fetches dtmf string from the CPEEngineInfo class and then

// Method parses the DTMF string and then take action properly: 

// hard pause: triggers sending MEngineMonitor::EPEMessageStoppedDTMF 

//      to phone model

// '+': triggers substitution speed dial digit with speed dial number. 

//

// Method calls SendDtmf method from the CallHandling subsystem.

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

//

TInt CPEMessageHandler::HandleSendDtmf()

    {

    TInt errorCode( ECCPErrorNone );

    TPEDtmfString dtmfString = iDataStore.DtmfStringCommand();

    RemoveInvalidChars( dtmfString, KPEClientValidChars, EFalse );

    if ( dtmfString.Length() == 0 )

        {

        iDataStore.SetDtmfString( KNullDesC() ); 

        errorCode = KErrArgument;

        }

    // Parse the first character of the string

    else if ( dtmfString[ 0 ] == KPEDtmfStopCharLowercase || 

              dtmfString[ 0 ] == KPEDtmfStopCharUppercase ) // hard pause

        {

        TEFLOGSTRING( KTAMESINT, "PE CPEMessageHandler::HandleSendDtmf(), Processing W" );

        // remove the hard pause char from the string

        iDataStore.SetDtmfString( dtmfString.Mid( 1 ) );

        iDataStore.SetDtmfStringCommand( dtmfString.Mid( 1 ) );

        // Send EPEMessageStoppedDTMF message asynchronic.

        TCallBack callBack( CallbackSendMessageStoppedDTMF, this );

        delete iAsyncCallBack;

        iAsyncCallBack = NULL;

        // Function does not allow to leave.

        iAsyncCallBack = new CAsyncCallBack( callBack, CActive::EPriorityHigh );

        if ( iAsyncCallBack )

            {

            iAsyncCallBack->CallBack();

            }

        else

            {

            iModel.SendMessage( MEngineMonitor::EPEMessageStoppedDTMF );

            }

        dtmfString = KNullDesC;

        }    

    else if ( dtmfString[ 0 ] == KPEDtmfPlusChar ) // speed-dial substitution

        {

        TEFLOGSTRING( KTAMESINT, "PE CPEMessageHandler::HandleSendDtmf(), Processing +" );

        HandlePlusSignInDtmf( dtmfString );

        dtmfString = KNullDesC;

        }

    else if ( dtmfString[ 0 ] == KPEDtmfPauseCharLowercase || 

              dtmfString[ 0 ] == KPEDtmfPauseCharUppercase ) // soft pause

        {

        TEFLOGSTRING( KTAMESINT, "PE CPEMessageHandler::HandleSendDtmf(), Processing P" );

        // store the full string for UI to display 

        iDataStore.SetDtmfString( dtmfString );

        if ( dtmfString.Length() > 1 )

            {

            // store the remainder of the string to be processed later

            iDataStore.SetDtmfStringCommand( dtmfString.Mid( 1 ) ); 

            }

        else

            {

            // nothing left to process

            iDataStore.SetDtmfStringCommand( KNullDesC() );

            }

        // set the dtmf string to send 

        dtmfString = dtmfString.Left( 1 );

        }

    else 

        {

        // store the full string for UI to display 

        iDataStore.SetDtmfString( dtmfString );

        // Find the next stop point

        TInt stopPoint = ECCPErrorNotFound;

        TPtrC validDtmfStringStopChars( KPEValidDTMFStringStopChars );

        for ( TInt index = 0 ; index < dtmfString.Length(); index++ )

            {

            if ( validDtmfStringStopChars.Locate( dtmfString[index] ) != ECCPErrorNotFound )

                {

                stopPoint = index;

                break; 

                }

            }

        if ( stopPoint != ECCPErrorNotFound ) 

            {

            // store the remainder of the string to be processed later

            iDataStore.SetDtmfStringCommand( dtmfString.Mid( stopPoint ) ); 

            // set the dtmf string to send 

            dtmfString = dtmfString.Left( stopPoint );            

            }

        else

            {

            // nothing left to process

            iDataStore.SetDtmfStringCommand( KNullDesC() );

            }

        }