// Copyright (c) 1997-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://#include <commsdattypesv1_1.h>#include <cdblen.h>#include "ATDIAL.H"#include "mSLOGGER.H"#include "PHONE.H"#include "CALL.H"#include "ATNOCARR.H"#include "NOTIFY.H"#include "ATIO.H"#include <etelmm.h>#include "Matstd.h"const TInt KWaitForConnect=30000; CATDialVoice* CATDialVoice::NewL(CATIO* aIo, CTelObject* aTelObject,CATInit* aInit,CPhoneGlobals* aPhoneGlobals) { CATDialVoice* dial=new(ELeave) CATDialVoice(aIo, aTelObject, aInit,aPhoneGlobals); CleanupStack::PushL(dial); dial->ConstructL(); // This ConstructL call is required to allow our base classes to construct CleanupStack::Pop(); return dial; }CATDialVoice::CATDialVoice(CATIO* aIo, CTelObject* aTelObject,CATInit* aInit,CPhoneGlobals* aPhoneGlobals) : CATVoiceCallConnectCommands(aIo,aTelObject,aInit,aPhoneGlobals) {}void CATDialVoice::Start(TTsyReqHandle aTsyReqHandle, TAny* aParams) { LOGTEXT(_L8("Starting Voice Dial Command")); iState=EATInitialising; iTelnum=REINTERPRET_CAST(TDesC*,aParams); CATVoiceCallConnectCommands::Start(aTsyReqHandle,aParams); }void CATDialVoice::Stop(TTsyReqHandle aTsyReqHandle)//// Attempt to halt the dial process by sending a carriage return, expecting a NO CARRIER// message, or if the pre-dial commands are still being sent then simply wait for OK// { __ASSERT_ALWAYS(aTsyReqHandle == iReqHandle,Panic(EIllegalTsyReqHandle)); __ASSERT_ALWAYS(iState!=EATNotInProgress,Panic(EATCommand_NotInProgress)); LOGTEXT(_L8("Cancelling Voice Dial Command")); iIo->WriteAndTimerCancel(this); if (iState!=EATInitialising) { Write(KCarriageReturn(),1); iState = EATCancellingWaitForWriteComplete; iPreConnectState=CATCallConnectCommands::ENotInProgress; } else { AddStdExpectStrings(); iPreConnectState=CATCallConnectCommands::ECancelling; iState = EATNotInProgress; } }TInt CATDialVoice::AddDialExpectStrings() { LOGTEXT2(_L8("Entered CATDialVoice::AddDialExpectStringsL with iNoDialToneExpectString of %x"),iNoDialToneExpectString); AddCommonExpectStrings(); TInt ret(KErrNone); if (!iCallMonitoringExpectString) { iCallMonitoringExpectString=iIo->AddExpectString(this,KCallMonitoringEventString); } if (!iBusyExpectString) { ret=iPhoneGlobals->iConfiguration->ConfigModemString(TPtrC(KCDTypeNameBusy),iBusyString); if(ret!=KErrNone) return ret; AppendWildCardChar(iBusyString); iBusyExpectString=iIo->AddExpectString(this,iBusyString); } if (!iNoDialToneExpectString) { ret=iPhoneGlobals->iConfiguration->ConfigModemString(TPtrC(KCDTypeNameNoDialTone),iNoDialToneString); if(ret!=KErrNone) return ret; iNoDialToneExpectString=iIo->AddExpectString(this,iNoDialToneString); } if (!iNoAnswerExpectString) { ret=iPhoneGlobals->iConfiguration->ConfigModemString(TPtrC(KCDTypeNameNoAnswer),iNoAnswerString); if(ret!=KErrNone) return ret; AppendWildCardChar(iNoAnswerString); iNoAnswerExpectString=iIo->AddExpectString(this,iNoAnswerString); } if (!iDelayedExpectString) iDelayedExpectString=iIo->AddExpectString(this,KDelayedString); LOGTEXT(_L8("Leaving CATDialVoice::AddDialExpectStringsL")); return KErrNone; }TInt CATDialVoice::ValidateDialExpectString() { CCommChatString* foundChatString = iIo->FoundChatString(); if (foundChatString == iOKExpectString) return KErrNone; if (foundChatString == iCallMonitoringExpectString) { LOGTEXT(_L8("Modem returned *ECAV Ericsson Call Monitoring (similar to NO CARRIER) in response to dial command")); return KErrEtelNoCarrier; } if (foundChatString == iNoCarrierExpectString) { LOGTEXT(_L8("Modem returned NO CARRIER in response to dial command")); return KErrEtelNoCarrier; } if (foundChatString == iNoDialToneExpectString) { LOGTEXT(_L8("Modem returned NO DIALTONE in response to dial command")); return KErrEtelNoDialTone; } if (foundChatString == iBusyExpectString) { LOGTEXT(_L8("Modem returned BUSY in response to dial command")); return KErrEtelBusyDetected; } if (foundChatString == iNoAnswerExpectString) { LOGTEXT(_L8("Modem returned NO ANSWER in response to dial command")); return KErrEtelNoAnswer; } if (foundChatString == iDelayedExpectString) { LOGTEXT(_L8("Modem returned DELAYED in response to dial command")); return KErrEtelBusyDetected; // No 'Delayed' error message } LOGTEXT(_L8("Voice dial command\tunexpected match!")); return KErrGeneral; }void CATDialVoice::RemoveDialExpectStrings() { RemoveCommonExpectStrings(); iIo->RemoveExpectString(iCallMonitoringExpectString); iCallMonitoringExpectString=NULL; // Set pointer to NULL to denote we have removed the expect string iIo->RemoveExpectString(iBusyExpectString); iBusyExpectString=NULL; // Set pointer to NULL to denote we have removed the expect string iIo->RemoveExpectString(iNoDialToneExpectString); iNoDialToneExpectString=NULL; // Set pointer to NULL to denote we have removed the expect string iIo->RemoveExpectString(iNoAnswerExpectString); iNoAnswerExpectString=NULL; // Set pointer to NULL to denote we have removed the expect string iIo->RemoveExpectString(iDelayedExpectString); iDelayedExpectString=NULL; // Set pointer to NULL to denote we have removed the expect string }void CATDialVoice::CompleteWithIOError(TEventSource aSource,TInt aStatus) { if (iState!=EATNotInProgress) { iState = EATNotInProgress; CATCallConnectCommands::CompleteWithIOError(aSource,aStatus); } }void CATDialVoice::EventSignal(TEventSource aSource) { LOGTEXT2(_L8("CATDialVoice::EventSignal with iState %d"),iState); if ((aSource==ETimeOutCompletion)&&(iState!=EATCancellingReadCompleted) &&(iState!=CATDialVoice::EATNotInProgress) &&(iState!=CATDialVoice::EDTRDropped) &&(iState!=CATDialVoice::EWaitForDTRRaiseSettle) &&(iState!=CATDialVoice::EATHangupReadCompleted)) { LOGTEXT(_L8("Timeout Error during voice Dial")); RemoveDialExpectStrings(); RemoveStdExpectStrings(); iState = EATNotInProgress; Complete(KErrTimedOut,aSource); return; } // // Read Completions can happen in unexpected places with the // Ericsson Call Monitoring (AT*ECAM=1) turned on, so need check // it outside of the state machine. // // The Ericsson call monitoring replaces the Ericsson SH888 hack also // if ((aSource==EReadCompletion)) { // Does it match a General Expect String? TInt ret=ValidateExpectString(); // Not General, so does it match a Dial Specific Expect String? if (ret != KErrNone) ret=ValidateDialExpectString(); // It doesn't match any Expect Strings at all, so complete with error // otherwise just continue with the state machine as normal if (ret != KErrNone) { LOGTEXT2(_L8("Completing call with Error %d"), ret); Complete(ret,aSource); return; } } if (iPreConnectState!=CATCallConnectCommands::EATInitCompleted && iPreConnectState!=CATCallConnectCommands::ENotInProgress) { CATCallConnectCommands::PreConnectEventSignal(aSource); if (iPreConnectState==CATCallConnectCommands::ENotInProgress) // cancelled iState=EATNotInProgress; if (iPreConnectState!=CATCallConnectCommands::EATInitCompleted) return; else iState=EATSendDialCommand; } switch(iState) { case EATSendDialCommand: { ChangeLineStatus(RCall::EStatusDialling); // Setting to EStatusDialling always returns KErrNone (void)ChangeCallStatus(RMobileCall::EStatusDialling); iPhoneGlobals->iNotificationStore->CheckNotification(REINTERPRET_CAST(CCallBase*,iTelObject),EBegunConnecting); TBuf8<KCommsDbSvrMaxFieldLength> dialModifier; TInt ret = iPhoneGlobals->iConfiguration->ConfigModemString(TPtrC(KCDTypeNameDialToneWaitModifier),dialModifier); if (ret) { Complete(ret,aSource); break; } TInt len = iTelnum->Length(); HBufC8* buf = NULL; TRAP(ret,buf = HBufC8::NewL(len)); if (ret) { Complete(ret,aSource); break; } TPtr8 newTelnum(buf->Des()); newTelnum.Copy(*iTelnum); TInt aPos=newTelnum.FindF(dialModifier); if (aPos!=KErrNotFound) newTelnum.Delete(aPos,1); iTxBuffer.Format(KDialVoiceCommandFormat,&newTelnum); delete buf; iIo->Write(this,iTxBuffer); iIo->SetTimeOut(this); iState=EATDialWaitForWriteComplete; } break; case EATDialWaitForWriteComplete: { __ASSERT_ALWAYS(aSource==EWriteCompletion,Panic(EATCommand_IllegalCompletionWriteExpected)); TInt ret=AddDialExpectStrings(); AddStdExpectStrings(); if (ret) { Complete(ret,aSource); break; } iIo->SetTimeOut(this,KWaitForConnect); // 30 seconds for the other end to pick up. iState=EATDialReadComplete; } break; case EATDialReadComplete: __ASSERT_ALWAYS(aSource==EReadCompletion,Panic(EATCommand_IllegalCompletionReadExpected)); { iIo->WriteAndTimerCancel(this); RemoveDialExpectStrings(); RemoveStdExpectStrings(); iState = EATNotInProgress; Complete(KErrNone,aSource); } break; case EATCancellingWaitForWriteComplete: { __ASSERT_ALWAYS(aSource==EWriteCompletion,Panic(EATCommand_IllegalCompletionWriteExpected)); TInt ret=AddDialExpectStrings(); if (ret) { Complete(ret,aSource); break; } if (!iOKExpectString) { iOKExpectString=iIo->AddExpectString(this,KOkString); } iIo->SetTimeOut(this); iState=EATCancellingReadCompleted; } break; case EATCancellingReadCompleted: { iState = EATNotInProgress; if (aSource==EReadCompletion) { TInt ret=ValidateDialExpectString(); RemoveDialExpectStrings(); iOKExpectString=NULL; if (ret==KErrNone) { iIo->DropDtr(); iIo->SetTimeOut(this,KDTRLowPeriod); iState=EDTRDropped; return; } } RemoveDialExpectStrings(); Complete(KErrCancel,aSource); } break; case EDTRDropped: __ASSERT_ALWAYS(aSource==ETimeOutCompletion,Panic(EATCommand_IllegalCompletionWaitExpected)); iIo->Cancel(); iIo->RaiseDTR(); iIo->Read(); iIo->SetTimeOut(this,KDTRHighSettle); iState=EWaitForDTRRaiseSettle; break; case EWaitForDTRRaiseSettle: __ASSERT_ALWAYS(aSource==ETimeOutCompletion,Panic(EATCommand_IllegalCompletionWaitExpected)); Write(KHangUpCommand(),1); iState=EATHangupWaitForWriteComplete; break; case EATHangupWaitForWriteComplete: __ASSERT_ALWAYS(aSource==EWriteCompletion,Panic(EATCommand_IllegalCompletionWriteExpected)); if (!iNoCarrierExpectString) iNoCarrierExpectString=iIo->AddExpectString(this,KNoCarrierString); StandardWriteCompletionHandler(aSource,2); iState=EATHangupReadCompleted; break; case EATHangupReadCompleted: __ASSERT_ALWAYS(aSource!=EWriteCompletion,Panic(EATCommand_IllegalCompletionWriteNotExpected)); Complete(KErrCancel,aSource); break; default: ; } }//// Dial number for data call. Remove the dial modifier W if found and only add it again if the// call parameters indicate that we are to wait for dial tone.//CATDialData* CATDialData::NewL(CATIO* aIo, CTelObject* aTelObject,CATInit* aInit,CPhoneGlobals* aPhoneGlobals) { CATDialData* dial=new(ELeave) CATDialData(aIo, aTelObject, aInit,aPhoneGlobals); CleanupStack::PushL(dial); dial->ConstructL(); CleanupStack::Pop(); return dial; }CATDialData::CATDialData(CATIO* aIo, CTelObject* aTelObject,CATInit* aInit,CPhoneGlobals* aPhoneGlobals) : CATDataCallConnectCommands(aIo,aTelObject,aInit,aPhoneGlobals) {}void CATDialData::Start(TTsyReqHandle aTsyReqHandle, TAny* aParams) { LOGTEXT(_L8("Starting ATD Dial Command")); iState=EATInitialising; iTelnum=REINTERPRET_CAST(TDesC*,aParams); CATDataCallConnectCommands::Start(aTsyReqHandle,aParams); }void CATDialData::Stop(TTsyReqHandle aTsyReqHandle)//// Attempt to halt the dial process by sending a carriage return, expecting a NO CARRIER// message, or if the pre-dial commands are still being sent then simply wait for OK// { __ASSERT_ALWAYS(aTsyReqHandle == iReqHandle,Panic(EIllegalTsyReqHandle)); __ASSERT_ALWAYS(iState!=EATNotInProgress,Panic(EATCommand_NotInProgress)); LOGTEXT(_L8("Cancelling ATD Dial Command")); if (iState!=EATInitialising) { iIo->WriteAndTimerCancel(this); Write(KCarriageReturn(),1); iState = EATCancellingWaitForWriteComplete; iPreConnectState=CATCallConnectCommands::ENotInProgress; } else { AddStdExpectStrings(); iPreConnectState=CATCallConnectCommands::ECancelling; iState = EATNotInProgress; } }void CATDialData::AddDialExpectStringsL() { LOGTEXT2(_L8("Entered CATDialData::AddDialExpectStringsL with iNoDialToneExpectString of %x"),iNoDialToneExpectString); (void)User::LeaveIfError(AddCommonExpectStrings()); if (!iBusyExpectString) { (void)User::LeaveIfError(iPhoneGlobals->iConfiguration->ConfigModemString(TPtrC(KCDTypeNameBusy),iBusyString)); AppendWildCardChar(iBusyString); iBusyExpectString=iIo->AddExpectString(this,iBusyString); } if (!iNoDialToneExpectString) { (void)User::LeaveIfError(iPhoneGlobals->iConfiguration->ConfigModemString(TPtrC(KCDTypeNameNoDialTone),iNoDialToneString)); iNoDialToneExpectString=iIo->AddExpectString(this,iNoDialToneString); } if (!iNoAnswerExpectString) { (void)User::LeaveIfError(iPhoneGlobals->iConfiguration->ConfigModemString(TPtrC(KCDTypeNameNoAnswer),iNoAnswerString)); AppendWildCardChar(iNoAnswerString); iNoAnswerExpectString=iIo->AddExpectString(this,iNoAnswerString); } if (!iDelayedExpectString) iDelayedExpectString=iIo->AddExpectString(this,KDelayedString); LOGTEXT(_L8("Leaving CATDialData::AddDialExpectStringsL")); }void CATDialData::ValidateDialExpectStringL() { CCommChatString* foundChatString = iIo->FoundChatString(); if (foundChatString == iConnectExpectString) { return; } if (foundChatString == iNoCarrierExpectString) { LOGTEXT(_L8("Modem returned NO CARRIER in response to dial command")); User::Leave(KErrEtelNoCarrier); } if (foundChatString == iNoDialToneExpectString) { LOGTEXT(_L8("Modem returned NO DIALTONE in response to dial command")); User::Leave(KErrEtelNoDialTone); } if (foundChatString == iBusyExpectString) { LOGTEXT(_L8("Modem returned BUSY in response to dial command")); User::Leave(KErrEtelBusyDetected); } if (foundChatString == iNoAnswerExpectString) { LOGTEXT(_L8("Modem returned NO ANSWER in response to dial command")); User::Leave(KErrEtelNoAnswer); } if (foundChatString == iDelayedExpectString) { LOGTEXT(_L8("Modem returned DELAYED in response to dial command")); User::Leave(KErrEtelBusyDetected); // No 'Delayed' error message } LOGTEXT(_L8("Data dial command\tunexpected match!")); User::Leave(KErrGeneral); }void CATDialData::RemoveDialExpectStrings() { RemoveCommonExpectStrings(); iIo->RemoveExpectString(iBusyExpectString); iBusyExpectString=NULL; iIo->RemoveExpectString(iNoDialToneExpectString); iNoDialToneExpectString=NULL; iIo->RemoveExpectString(iNoAnswerExpectString); iNoAnswerExpectString=NULL; iIo->RemoveExpectString(iDelayedExpectString); iDelayedExpectString=NULL; }void CATDialData::CompleteWithIOError(TEventSource aSource,TInt aStatus) { if (iState!=EATNotInProgress) { iState = EATNotInProgress; CATCallConnectCommands::CompleteWithIOError(aSource,aStatus); } }void CATDialData::EventSignal(TEventSource aSource) { LOGTEXT3(_L8("CATDialData::EventSignal with iState:%d aSource:%d"),iState,aSource); if(aSource==ETimeOutCompletion) { if(iState!=EATSpeedReadComplete && iState!=EATCancellingReadCompleted && iState!=EATNotInProgress && iState!=EDTRDropped && iState!=EWaitForDTRRaiseSettle && iState!=EATHangupReadCompleted) { LOGTEXT(_L8("CATDialData::EventSignal Timeout Error during Dial")); RemoveDialExpectStrings(); iState = EATNotInProgress; Complete(KErrTimedOut,aSource); return; } } if (iPreConnectState!=CATCallConnectCommands::EATInitCompleted && iPreConnectState!=CATCallConnectCommands::ENotInProgress) { CATCallConnectCommands::PreConnectEventSignal(aSource); if (iPreConnectState==CATCallConnectCommands::ENotInProgress) // cancelled { LOGTEXT2(_L8("CATDialData::EventSignal1 with iPreConnectState %d"),iPreConnectState); iState=EATNotInProgress; } if (iPreConnectState!=CATCallConnectCommands::EATInitCompleted) { LOGTEXT2(_L8("CATDialData::EventSignal2 with iPreConnectState %d"),iPreConnectState); return; } else { // // Start the sending of the +CBST= command. // // If the SendBearerCapsCommand fails to start the sending // of the +CBST= command then we have to start the dial instead if(!SendBearerCapsCommand(aSource)) // Will set iState=EATBearerCapsWaitForWriteComplete StartDialCommand(aSource); // Will set iState=EATDialWaitForWriteComplete return; } } switch(iState) { case EATBearerCapsWaitForWriteComplete: __ASSERT_DEBUG(iCallType==EDataCall,Panic(ENotDataCallType)); __ASSERT_ALWAYS(aSource==EWriteCompletion,Panic(EATCommand_IllegalCompletionWriteExpected)); StandardWriteCompletionHandler(aSource,4); iState=EATBearerCapsReadComplete; break; case EATBearerCapsReadComplete: __ASSERT_DEBUG(iCallType==EDataCall,Panic(ENotDataCallType)); __ASSERT_ALWAYS(aSource==EReadCompletion,Panic(EATCommand_IllegalCompletionReadExpected)); // // Ignore any OK, ERROR or any other response from the modem. // This is because some modems, eg. those with out speakers, will ERROR these // configuration commands even though the call can go ahead. RemoveStdExpectStrings(); // // Start the dial command StartDialCommand(aSource); // This will set iState to EATDialWaitForWriteComplete break; case EATDialWaitForWriteComplete: { __ASSERT_ALWAYS(aSource==EWriteCompletion,Panic(EATCommand_IllegalCompletionWriteExpected)); TRAPD(ret,AddDialExpectStringsL()); if (ret) { Complete(ret,aSource); break; } iIo->SetTimeOut(this,(iPhoneGlobals->iPhoneStatus.iWaitForCarrierTime*1000)+KExtraWaitTime); iState=EATDialReadComplete; } break; case EATDialReadComplete: __ASSERT_ALWAYS(aSource==EReadCompletion,Panic(EATCommand_IllegalCompletionReadExpected)); { TRAPD(ret,ValidateDialExpectStringL()); RemoveDialExpectStrings(); if (ret!=KErrNone) { iState = EATNotInProgress; Complete(ret,aSource); break; } iIo->SetTimeOut(this,(KTimeForExtraRxData*5)); iState=EATSpeedReadComplete; } break; case EATSpeedReadComplete: { __ASSERT_ALWAYS(aSource==ETimeOutCompletion,Panic(EATCommand_IllegalCompletionWaitExpected)); iIo->WriteAndTimerCancel(this); TInt ret=ParseForBearerCapsResponse(); iState = EATNotInProgress; if (ret!=KErrNone) { Complete(ret,aSource); break; } ret=ParseForBearerSpeedResponse(); Complete(ret,aSource); break; } case EATCancellingWaitForWriteComplete: { __ASSERT_ALWAYS(aSource==EWriteCompletion,Panic(EATCommand_IllegalCompletionWriteExpected)); TRAPD(ret,AddDialExpectStringsL()); if (ret) { Complete(ret,aSource); break; } if (!iOKExpectString) { iOKExpectString=iIo->AddExpectString(this,KOkString); } iIo->SetTimeOut(this); iState=EATCancellingReadCompleted; } break; case EATCancellingReadCompleted: { if (aSource==ETimeOutCompletion) { // The phone ignored the request to cancel the connection. // The modem will be forced to drop the connection when we // lower the DTR. LOGTEXT(_L8("Phone ignored dial cancel request")); } else if (aSource==EReadCompletion) { if (iIo->FoundChatString() != iOKExpectString) { // The modem did not respond with OK as expected. LOGTEXT(_L8("Phone returned an unexpected response to a dial cancel request")); } } RemoveDialExpectStrings(); iIo->RemoveExpectString(iOKExpectString); iOKExpectString=NULL; iIo->DropDtr(); iIo->SetTimeOut(this,KDTRLowPeriod); iState=EDTRDropped; } break; case EDTRDropped: __ASSERT_ALWAYS(aSource==ETimeOutCompletion,Panic(EATCommand_IllegalCompletionWaitExpected)); iIo->Cancel(); iIo->RaiseDTR(); iIo->Read(); iIo->SetTimeOut(this,KDTRHighSettle); iState=EWaitForDTRRaiseSettle; break; case EWaitForDTRRaiseSettle: __ASSERT_ALWAYS(aSource==ETimeOutCompletion,Panic(EATCommand_IllegalCompletionWaitExpected)); Write(KHangUpCommand(),1); iState=EATHangupWaitForWriteComplete; break; case EATHangupWaitForWriteComplete: __ASSERT_ALWAYS(aSource==EWriteCompletion,Panic(EATCommand_IllegalCompletionWriteExpected)); if (!iNoCarrierExpectString) iNoCarrierExpectString=iIo->AddExpectString(this,KNoCarrierString); StandardWriteCompletionHandler(aSource,2); iState=EATHangupReadCompleted; break; case EATHangupReadCompleted: __ASSERT_ALWAYS(aSource!=EWriteCompletion,Panic(EATCommand_IllegalCompletionWriteNotExpected)); Complete(KErrCancel,aSource); // if ret!=KErrNone, perhaps don't complete but carry on break; default: ; } }void CATDialData::StartDialCommand(TEventSource aSource) { // // Start the dial command ChangeLineStatus(RCall::EStatusDialling); // Setting to EStatusDialling always returns KErrNone (void)ChangeCallStatus(RMobileCall::EStatusDialling); iPhoneGlobals->iNotificationStore->CheckNotification(REINTERPRET_CAST(CCallBase*,iTelObject),EBegunConnecting); TBuf8<KCommsDbSvrMaxFieldLength> dialModifier; TInt ret = iPhoneGlobals->iConfiguration->ConfigModemString(TPtrC(KCDTypeNameDialToneWaitModifier),dialModifier); if (ret) { Complete(ret,aSource); return; } TInt len = iTelnum->Length(); HBufC8* buf = NULL; TRAP(ret,buf = HBufC8::NewL(len)); if (ret) { Complete(ret,aSource); return; } TPtr8 newTelnum(buf->Des()); newTelnum.Copy(*iTelnum); TInt aPos=newTelnum.FindF(dialModifier); if (aPos!=KErrNotFound) { newTelnum.Delete(aPos,1); } iTxBuffer.Format(KDialDataCommandFormat,&newTelnum); delete buf; iIo->Write(this,iTxBuffer); iIo->SetTimeOut(this); iState=EATDialWaitForWriteComplete; }TBool CATDialData::SendBearerCapsCommand(TEventSource /*aSource*/)/* * @return ETrue if +CBST= was sent * @return EFalse if +CBST= was not sent due to not having enough specified params */ { LOGTEXT(_L8("CATDataDial::SendBearerCapsCommand")); // // Assemble and send (if required) the +CBST=... string to the phone // to configure the settings for the next data call. // Use utility function provided by CCallMobileData CCallMobileData* parent=static_cast<CCallMobileData*>(iTelObject); if(parent->AssembleCBSTSetString(iTxBuffer)==KErrNone) { // // Send our AT command to the phone iIo->Write(this,iTxBuffer); iIo->SetTimeOut(this); iState=EATBearerCapsWaitForWriteComplete; return ETrue; } return EFalse; // We were unable to send a +CBST string }