/*

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

#include <talogger.h>

#include <w32std.h>

// EXTERNAL DATA STRUCTURES

// None.

// EXTERNAL FUNCTION PROTOTYPES  

// None.

// CONSTANTS

const TInt KPEPrefixChangeOff = 0;

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

            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::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 ] == 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() );

            }

        }

    if ( dtmfString.Length() )  

        {

        TEFLOGSTRING2( KTAMESINT, "PE CPEMessageHandler::HandleSendDtmf(), Starting to play %S", &dtmfString );

        // send the dtmf string to call handling subsystem

        errorCode = iCallHandling.SendDtmf( dtmfString );

        }

    return errorCode;

    }

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

// CPEMessageHandler::CallBackHandleSendDtmf

// Asyncronous callback for HandleSendDtmf() function.

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

//

TInt CPEMessageHandler::CallBackHandleSendDtmf( TAny* aAny )

    {

    __ASSERT_ALWAYS( aAny , Panic( EPEPanicNullPointer ) );

    CPEMessageHandler* self = static_cast<CPEMessageHandler*>(aAny);

    delete self->iAsyncCallBack;