diff -r 2eacb6118286 -r ba76fc04e6c2 phoneengine/phonemodel/src/cpeclientcommandhandlermonitor.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/phoneengine/phonemodel/src/cpeclientcommandhandlermonitor.cpp Fri Jun 04 10:19:18 2010 +0100 @@ -0,0 +1,463 @@ +/* +* 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 +#include +#include +#include + + +// ============================ 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( 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