/*

* Copyright (c) 2004-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:  AT command request monitor

*

*/

// INCLUDE FILES

#include "cpeclientcommandhandlermonitor.h"

#include "cpemanualcallcontrolhandler.h"

#include "cpemessagehandler.h"

#include "mpecallhandling.h"

#include "mpephonemodelinternal.h"

#include <mpedatastore.h>

#include <RPhCltServer.h>

#include <talogger.h>

#include <telephonyvariant.hrh>

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

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

// CPEClientCommandHandlerMonitor::CPEClientCommandHandlerMonitor

// Constructor can NOT contain any code, that

// might leave.

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

//

CPEClientCommandHandlerMonitor::CPEClientCommandHandlerMonitor(

    MPECallHandling& aCallHandling,

    CPEMessageHandler& aMessageHandler,

    MPEPhoneModelInternal& aModel,

    RPhCltServer& aServer,

    CPEManualCallControlHandler& aManualCallControlHandler )

    : iServer ( aServer ),

      iCallHandling( aCallHandling ),

      iMessageHandler ( aMessageHandler),

      iModel ( aModel ),

      iManualCallControlHandler( aManualCallControlHandler )

    {

    iWaitingForResponse = EFalse;

    }

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

// CPEClientCommandHandlerMonitor::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CPEClientCommandHandlerMonitor::ConstructL()

    {

    iNotify = CPhCltCallNotify::NewL();

    // Open subsession

    User::LeaveIfError( iNotify->Open( iServer ) );

    }

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

// CPEClientCommandHandlerMonitor::NewL

// Two-phased constructor.

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

//

CPEClientCommandHandlerMonitor* CPEClientCommandHandlerMonitor::NewL(

    MPECallHandling& aCallHandling,

    CPEMessageHandler& aMessageHandler,

    MPEPhoneModelInternal& aModel,

    RPhCltServer& aPhoneServer,

    CPEManualCallControlHandler& aManualCallControlHandler )

    {

    CPEClientCommandHandlerMonitor* self = new( ELeave ) CPEClientCommandHandlerMonitor(

        aCallHandling, aMessageHandler, aModel, aPhoneServer, aManualCallControlHandler );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

// Destructor

CPEClientCommandHandlerMonitor::~CPEClientCommandHandlerMonitor()

    {

    Cancel();

    if ( iNotify )

        {

        iNotify->Close();

        delete iNotify;

        }

    iLibrary.Close();

    }

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

// CPEClientCommandHandlerMonitor::Start

// Start listening for AT command requests.

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

//

void CPEClientCommandHandlerMonitor::Start()

    {

    TEFLOGSTRING( KTAOBJECT, "PE CPEClientCommandHandlerMonitor::Start()" );

    iNotify->NotifyComHandCommand( this, iArgs );

    }

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

// CPEClientCommandHandlerMonitor::Respond

// Sends response to AT command request 

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

//

void CPEClientCommandHandlerMonitor::Respond( const TInt aErrorCode )

    {

    TEFLOGSTRING2( KTAINT, 

        "PE CPEClientCommandHandlerMonitor::Respond: error %d", aErrorCode );

    SendResponse( aErrorCode );

    Start();

    }

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

// CPEClientCommandHandlerMonitor::SendResponse

// Sends response to server.

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

//

void CPEClientCommandHandlerMonitor::SendResponse( const TInt aResponse )

    {

    iNotify->RespondComHandClient( aResponse );

    }

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

// CPEClientCommandHandlerMonitor::RunL

// 

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

//

void CPEClientCommandHandlerMonitor::ComHandRequest()

    {

    TEFLOGSTRING( KTAREQEND, "PE CPEClientCommandHandlerMonitor::ComHandRequest");

    TRAPD( err, HandleCommandRequestL( iArgs() ) );

    if ( err != ECCPErrorNone )

        {

        Respond( err );

        }

    }

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

// CPEClientCommandHandlerMonitor::DoCancel

// 

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

//

void CPEClientCommandHandlerMonitor::Cancel()

    {

    TEFLOGSTRING( KTAINT, "PE CPEClientCommandHandlerMonitor::Cancel" );

    if ( iNotify )

        {

        iNotify->CancelNotifyComHandCommand();

        }

    }

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

// CPEClientCommandHandlerMonitor::HandleAtCommandRequestL

// Processing various supported BT AT commands

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

//

void CPEClientCommandHandlerMonitor::HandleCommandRequestL(

        const TPhCltComHandCommandParameters& aArgs )

    {

    TEFLOGSTRING2( KTAINT, 

        "PE CPEClientCommandHandlerMonitor::HandleCommandRequestL: command %d"

        , aArgs.iCommandHandlerCommand );

    switch ( aArgs.iCommandHandlerCommand )

        {

        case EPhCltCommandAta:

            HandleCmdAta();

            break;

        case EPhCltCommandChup:

            HandleCmdChup();

            break;

        case EPhCltCommandVts:

            HandleCmdVtsL( aArgs.iDtmfTone, aArgs.iDtmfAction );

            break;

        case EPhCltCommandAtd:

            HandleCmdAtdL( aArgs.iTelNumber );

            break;

        case EPhCltCommandChld:

            HandleCmdChldL( aArgs.iChldCommand, aArgs.iChldCallNumber );

            break;

        case EPhCltCommandMuteMic:

            HandleCmdMuteMic( aArgs.iMute );

            break;

        case EPhCltCommandMuteRingingTone:

            HandleCmdMuteRingingTone();

            break;

        default:

            Respond( ECCPErrorNotSupported );

            break;

        }

    }

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

// CPEClientCommandHandlerMonitor::HandleCmdAta

// Processing ATA command

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

//

void CPEClientCommandHandlerMonitor::HandleCmdAta()

    {

    TEFLOGSTRING( KTAINT, "PE CPEClientCommandHandlerMonitor::HandleCmdAta" );

    // Checking for available ringing call is done in CallHandling,

    // no need to do it here. If a ringing call was not found, the

    // error code equals "ECCPErrorNotFound".

    Respond( iMessageHandler.HandleAnswerCall( EFalse ));

    }

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

// CPEClientCommandHandlerMonitor::HandleCmdChup

// Processing CHUP command

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

//

void CPEClientCommandHandlerMonitor::HandleCmdChup()

    {

    TEFLOGSTRING( KTAINT, "PE CPEClientCommandHandlerMonitor::HandleCmdChup" );

    if ( iCallHandling.IsCallInState( EPEStateRinging ) &&

         iCallHandling.GetNumberOfCalls() == 1 )

        {

        Respond( iCallHandling.RejectCall() );

        }

    else if( iCallHandling.GetNumberOfCalls() > 1 )

        {

        // Hang up the calls in the order specified by Multicall Handling UI spec. 

        // If the call has a hang up request pending already, hang up the next call. 

        TInt err = HangUp( EPEStateDisconnecting );

        if ( ECCPErrorNone != err )

             {

             err = HangUp( EPEStateCreatingConference );

             if ( ECCPErrorNone != err ) 

                 {

                 err = HangUp( EPEStateDialing ); 

                 if ( ECCPErrorNone != err ) 

                     { 

                     err = HangUp( EPEStateConnecting ); 

                     if ( ECCPErrorNone != err ) 

                         { 

                         err = HangUp( EPEStateConnectedConference ); 

                         if ( ECCPErrorNone != err ) 

                             { 

                             err = HangUp( EPEStateConnected ); 

                             if ( ECCPErrorNone != err ) 

                                 { 

                                 err = HangUp( EPEStateHeldConference ); 

                                 if ( ECCPErrorNone != err ) 

                                     { 

                                     err = HangUp( EPEStateHeld ); 

                                     } 

                                 } 

                             } 

                         } 

                     } 

                 } 

             }

        Respond( err ); // Responds KErrNone or any error code 

        }

    else if( iCallHandling.GetNumberOfCalls() == 1 )

        {

        Respond( iCallHandling.ReleaseAll() );    

        }

    else

        {

        Respond( ECCPErrorGeneral );

        }

    }

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

// CPEClientCommandHandlerMonitor::HandleCmdVtsL

// Processing VTS command

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

//

void CPEClientCommandHandlerMonitor::HandleCmdVtsL(

        const TPhCltDtmfTone aDtmfTone,

        const TPhCltDtmfAction aAction )

    {

    TEFLOGSTRING( KTAINT, "PE CPEClientCommandHandlerMonitor::HandleCmdVtsL" );

    TInt errorCode;

    switch ( aAction )

        {

        case EPhCltDtmfNotUsed:

            iModel.DataStore()->SetKeyCode( aDtmfTone );

            iMessageHandler.HandlePlayDTMFL();

            errorCode = iMessageHandler.HandleEndDTMF();

            break;

        case EPhCltDtmfStart:

            iModel.DataStore()->SetKeyCode( aDtmfTone );

            iMessageHandler.HandlePlayDTMFL();

            errorCode = ECCPErrorNone;

            break;

        case EPhCltDtmfStop:

            errorCode = iMessageHandler.HandleEndDTMF();

            break;

        default:

            errorCode = ECCPErrorNotSupported;

            break;

        }

    Respond( errorCode );

    }

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

// CPEClientCommandHandlerMonitor::HandleCmdAtdL

// Handle AT dial.

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

//

void CPEClientCommandHandlerMonitor::HandleCmdAtdL( 

        const TPhCltTelephoneNumber& aPhoneNumber )

    {

    TEFLOGSTRING( KTAINT, "PE CPEClientCommandHandlerMonitor::HandleCmdAtdL" );

    iModel.DataStore()->SetPhoneNumber( 

        static_cast<TPEPhoneNumber>( aPhoneNumber ) );

    iWaitingForResponse = ETrue;

    iModel.SendMessage( MEngineMonitor::EPEMessageStartATDialing );

    }

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

// CPEClientCommandHandlerMonitor::HandleCmdChldL

// Processing CHLD command

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

//

void CPEClientCommandHandlerMonitor::HandleCmdChldL( 

        const TPhCltChldCommand aChldCommand,

        const TUint aCallNo ) // Only used in GSM.

    {

    TEFLOGSTRING( KTAINT, "PE CPEClientCommandHandlerMonitor::HandleCmdChldL" );

    TInt errorCode = ECCPErrorNone;

    // All commands are meant for incall situations.

    if ( iCallHandling.GetNumberOfCalls() > 0 )

        {

        // Leaves on error code. The leave error is sent as a response

        // to the client.

        TRAP( errorCode, iManualCallControlHandler.HandleChldL( aChldCommand, aCallNo ));

        }

    else

        {

        errorCode = ECCPErrorGeneral;

        }

    Respond( errorCode );

    }

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

// CPEClientCommandHandlerMonitor::DoCompleteCmdAtd

// Processing response from Phone UI (dialing started indication)

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

//

void CPEClientCommandHandlerMonitor::DoCompleteCmdAtd( TBool aFlag )

    {

    TEFLOGSTRING( KTAINT, "PE CPEClientCommandHandlerMonitor::DoCompleteCmdAtd" );

    if ( iWaitingForResponse )

        {

        iWaitingForResponse = EFalse;

        if ( aFlag )

            {

            Respond( ECCPErrorNone );

            }

        else

            {

            Respond( ECCPErrorGeneral );

            }

        }

    }

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

// CPEClientCommandHandlerMonitor::HandleCmdMuteRingingTone

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

//

void CPEClientCommandHandlerMonitor::HandleCmdMuteRingingTone()

    {

    TEFLOGSTRING( KTAINT, "PE CPEClientCommandHandlerMonitor::HandleCmdMuteRingingTone" );

    TInt errorCode( ECCPErrorNone );

    // command is meant for incall situations.

    if ( iCallHandling.GetNumberOfCalls() > 0 )

        {

        iModel.SendMessage( MEngineMonitor::EPEMessageMuteRingingTone );

        }

    else

        {

        errorCode = ECCPErrorGeneral;

        }

    Respond( errorCode );

    }

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

// CPEClientCommandHandlerMonitor::HandleCmdMuteMic

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

//

void CPEClientCommandHandlerMonitor::HandleCmdMuteMic( TBool aMute )

    {

    TEFLOGSTRING( KTAINT, "PE CPEClientCommandHandlerMonitor::HandleCmdMuteMic" );

    // command is meant for incall situations.

    if ( iCallHandling.GetNumberOfCalls() > 0 )

        {

        iModel.DataStore()->SetAudioMuteCommand( aMute );

        iMessageHandler.HandleSetAudioMute();

        Respond( ECCPErrorNone );

        }

    else

        {

        Respond( ECCPErrorGeneral );

        }

    }

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

// CPEClientCommandHandlerMonitor::HangUp 

// Finds a conference call or a single call (in that order) in specified 

// state and tries to hang it up. 

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

// 

TInt CPEClientCommandHandlerMonitor::HangUp( TPEState aState ) 

    { 

    TEFLOGSTRING2( KTAINT, "CPEClientCommandHandlerMonitor::HangUp aState=%d", aState); 

    TInt ret( ECCPErrorNotFound ); 

    TPEState conferenceState = iCallHandling.GetCallState( KPEConferenceCallID ); 

    if ( conferenceState == aState ) 

        { 

        ret = iCallHandling.HangUp( KPEConferenceCallID, ETPEHangUpDefault ); 

        } 

    else 

        { 

        TInt callId = iCallHandling.GetCallIdByState( aState ); 

        if ( KPECallIdNotUsed != callId ) 

            { 

            ret = iCallHandling.HangUp( callId, ETPEHangUpDefault ); 

            } 

        } 

    TEFLOGSTRING2( KTAINT, "CPEClientCommandHandlerMonitor::HangUp ret=%d", ret ); 

    return ret; 

    } 

//  End of File