diff -r 6295dc2169f3 -r 8486d82aef45 adaptationlayer/modematadaptation/modematext_dll/src/modemat_atext.cpp --- a/adaptationlayer/modematadaptation/modematext_dll/src/modemat_atext.cpp Wed Apr 21 14:29:55 2010 +0300 +++ b/adaptationlayer/modematadaptation/modematext_dll/src/modemat_atext.cpp Tue Oct 19 13:16:20 2010 +0300 @@ -19,6 +19,19 @@ #include "modemat_atext.h" #include "modemattrace.h" +#include "OstTraceDefinitions.h" +#ifdef OST_TRACE_COMPILER_IN_USE +#include "modemat_atextTraces.h" +#endif + +const TInt KReplyTypeEditorStart( 1 ); +const TInt KReplyTypeEditorEnd( 2 ); +const TInt KReplyTypeOther( 3 ); +const TInt KReplyTypeEditor( 4 ); +const TUint8 KEscChar( 0x1B ); // from ascii table +const TUint8 KCtrlZChar( 0x1A ); // from ascii table +const TUint8 KEscDataSize( 2 ); +const TUint8 KErrorSize( 9 ); const char* const atCommands[] = { @@ -103,10 +116,6 @@ ("ATO0"), ("AT+DS"), ("AT+DR"), - ("ATB"), - ("ATB0"), - ("ATB1"), - ("ATB2"), ("AT+CSTA"), ("AT+CHUP"), ("AT+CR"), @@ -151,14 +160,10 @@ ("AT+CGDSCONT"), ("AT+CGTFT"), ("AT+CGCMOD"), - ("AT+CRSM"), ("AT+CSIM"), ("AT+CPNET"), ("AT+CPNSTAT"), ("AT+CGPADDR"), - ("AT+CPLS"), - ("AT+ES"), - ("AT+ESA"), ("AT"), ("LAST") }; @@ -175,6 +180,7 @@ TPtrC8 CModemATExt::GetAtCommand( TInt aNumber ) //list of supported commands for this plugin { + OstTrace1( TRACE_NORMAL, CMODEMATEXT_GETATCOMMAND, "CModemATExt::GetAtCommand;aNumber=%d", aNumber ); C_TRACE((_L("CModemATExt::GetAtCommand(%d)"), aNumber)); const TUint8 **keys = (const TUint8**) atCommands; TPtrC8 keyword( aNumber < KMaxCommandCount ? keys[ aNumber ] : keys[ KMaxCommandCount - 1 ] ); @@ -183,6 +189,7 @@ CModemATExt* CModemATExt::NewL() { + OstTrace0( TRACE_NORMAL, CMODEMATEXT_NEWL, "CModemATExt::NewL" ); C_TRACE((_L("CModemATExt::NewL"))); CModemATExt* self = new (ELeave) CModemATExt(); CleanupStack::PushL(self); @@ -193,6 +200,7 @@ CModemATExt::~CModemATExt() { + OstTrace0( TRACE_NORMAL, CMODEMATEXT_CMODEMATEXT, "CModemATExt::~CModemATExt" ); C_TRACE((_L("CModemATExt::~CModemATExt()"))); if (iReplyBuffer) { @@ -215,25 +223,31 @@ TBool CModemATExt::IsCommandSupported( const TDesC8& aCmd) { + OstTrace0( TRACE_NORMAL, CMODEMATEXT_ISCOMMANDSUPPORTED, "CModemATExt::IsCommandSupported" ); C_TRACE((_L("CModemATExt::IsCommandSupported"))); DUMP_MESSAGE((aCmd)); if(aCmd.Find( KATDCommand )!=KErrNotFound) { + OstTrace0( TRACE_NORMAL, DUP1_CMODEMATEXT_ISCOMMANDSUPPORTED, "CModemATExt::IsCommandSupported - ATD" ); C_TRACE((_L("ATD"))); return ETrue; } if(aCmd.Find(KATICommand)!=KErrNotFound) { + OstTrace0( TRACE_NORMAL, DUP2_CMODEMATEXT_ISCOMMANDSUPPORTED, "CModemATExt::IsCommandSupported - ATI" ); C_TRACE((_L("ATI"))); return ETrue; } for ( TInt i = 0; i < KMaxCommandCount; i++ ) { + OstTrace1( TRACE_NORMAL, DUP3_CMODEMATEXT_ISCOMMANDSUPPORTED, "CModemATExt::IsCommandSupported - round;i=%d", i ); C_TRACE((_L("round %d"),i)); if( GetAtCommand(i).Find(KLastCommand) != KErrNotFound) { // All messages have been searched so the command is not supported + OstTrace0( TRACE_NORMAL, DUP4_CMODEMATEXT_ISCOMMANDSUPPORTED, "CModemATExt::IsCommandSupported - ********* COMMAND IS NOT SUPPORTED ********* " ); + OstTraceExt1( TRACE_NORMAL, DUP5_CMODEMATEXT_ISCOMMANDSUPPORTED, "CModemATExt::IsCommandSupported;aCmd=%s", aCmd ); C_TRACE((_L("********* COMMAND IS NOT SUPPORTED ********* "))); DUMP_MESSAGE(aCmd); return EFalse; @@ -242,62 +256,83 @@ if(aCmd.Find(GetAtCommand(i))!=KErrNotFound) { //just command + OstTrace1( TRACE_NORMAL, DUP6_CMODEMATEXT_ISCOMMANDSUPPORTED, "CModemATExt::IsCommandSupported - Command;i=%d", i ); C_TRACE((_L("Command"),i)); if(aCmd.Length()==GetAtCommand(i).Length()) { + OstTrace1( TRACE_NORMAL, DUP7_CMODEMATEXT_ISCOMMANDSUPPORTED, "CModemATExt::IsCommandSupported - Ok;i=%d", i ); C_TRACE((_L("Ok"),i)); return ETrue; } if(aCmd.Length()>GetAtCommand(i).Length()) //setting command { + OstTrace0( TRACE_NORMAL, DUP8_CMODEMATEXT_ISCOMMANDSUPPORTED, "CModemATExt::IsCommandSupported - Setting" ); C_TRACE((_L("Setting"))); if( aCmd[GetAtCommand(i).Length()] == '=' || aCmd[GetAtCommand(i).Length()] == '?' ) { - C_TRACE((_L("Ok"),i)); + OstTrace1( TRACE_NORMAL, DUP9_CMODEMATEXT_ISCOMMANDSUPPORTED, "CModemATExt::IsCommandSupported - Ok;i=%d", i ); + C_TRACE((_L("Ok"),i)); return ETrue; } } } } + OstTrace0( TRACE_NORMAL, DUP10_CMODEMATEXT_ISCOMMANDSUPPORTED, "CModemATExt::IsCommandSupported - return EFalse" ); C_TRACE((_L("return EFalse"))); return EFalse; } void CModemATExt::HandleCommand( const TDesC8& aCmd, RBuf8& aReply, TBool aReplyNeeded ) { - C_TRACE((_L("CModemATExt::HandleCommand()" ))); + OstTrace1( TRACE_NORMAL, CMODEMATEXT_HANDLECOMMAND, "CModemATExt::HandleCommand() - is reply needed;aReplyNeeded=%d", aReplyNeeded ); + OstTraceExt1( TRACE_NORMAL, DUP1_CMODEMATEXT_HANDLECOMMAND, "CModemATExt::HandleCommand - dump;aCmd=%s", aCmd ); + C_TRACE((_L("CModemATExt::HandleCommand() is reply needed: %d" ), aReplyNeeded)); DUMP_MESSAGE(aCmd); - iReply = &aReply; - iReplyNeeded = aReplyNeeded; - if( iCommandBuf ) - { - delete iCommandBuf; - iCommandBuf = NULL; - } - iCommandBuf = HBufC8::New( aCmd.Length() + 1 ); - TPtr8 ptr = iCommandBuf->Des(); - ptr.Append( aCmd ); - ptr.Append( iCarriageReturn ); - iRModemAt.HandleATCommand( ptr, iReplyPtr ); + if( iIsTextInputMode ) + { + OstTrace0( TRACE_NORMAL, DUP2_CMODEMATEXT_HANDLECOMMAND, "CModemATExt::HandleCommand - text mode on" ); + C_TRACE((_L("CModemATExt::HandleCommand: text mode on") )); + AddDataToBuffer( aCmd, aReply ); + } + else + { + OstTrace0( TRACE_NORMAL, DUP3_CMODEMATEXT_HANDLECOMMAND, "CModemATExt::HandleCommand - normal mode on" ); + C_TRACE((_L("CModemATExt::HandleCommand: normal mode on") )); + iReply = &aReply; + iReplyNeeded = aReplyNeeded; + if( iCommandBuf ) + { + delete iCommandBuf; + iCommandBuf = NULL; + } + iCommandBuf = HBufC8::New( aCmd.Length() + 1 ); + TPtr8 ptr = iCommandBuf->Des(); + ptr.Append( aCmd ); + ptr.Append( iCarriageReturn ); + iRModemAt.HandleATCommand( ptr, iReplyPtr ); + } } void CModemATExt::HandleCommandCancel() { + OstTrace0( TRACE_NORMAL, CMODEMATEXT_HANDLECOMMANDCANCEL, "CModemATExt::HandleCommandCancel" ); C_TRACE((_L("CModemATExt::HandleCommandCancel()"))); iRModemAt.HandleATCommandCancel(); } TInt CModemATExt::NextReplyPartLength() { + OstTrace0( TRACE_NORMAL, CMODEMATEXT_NEXTREPLYPARTLENGTH, "CModemATExt::NextReplyPartLength" ); C_TRACE((_L("CModemATExt::NextReplyPartLength()"))); return Min( iReplyPtr.Length(), KPartLength); } TInt CModemATExt::GetNextPartOfReply( RBuf8& aNextReply ) { + OstTrace0( TRACE_NORMAL, CMODEMATEXT_GETNEXTPARTOFREPLY, "CModemATExt::GetNextPartOfReply" ); C_TRACE((_L("CModemATExt::GetNextPartOfReply()"))); aNextReply.Create(iReplyPtr,KPartLength); iReplyPtr.Delete(0,KPartLength); @@ -306,12 +341,14 @@ void CModemATExt::ReceiveUnsolicitedResult() { + OstTrace0( TRACE_NORMAL, CMODEMATEXT_RECEIVEUNSOLICITEDRESULT, "CModemATExt::ReceiveUnsolicitedResult" ); C_TRACE((_L("CModemATExt::ReceiveUnsolicitedResult()"))); - iRModemAt.ReceiveUnsolicitedResult(iUnsolicitedPtr); + iRModemAt.ReceiveUnsolicitedResult( iUnsolicitedPtr ); } void CModemATExt::ReceiveUnsolicitedResultCancel() { + OstTrace0( TRACE_NORMAL, CMODEMATEXT_RECEIVEUNSOLICITEDRESULTCANCEL, "CModemATExt::ReceiveUnsolicitedResultCancel" ); C_TRACE((_L("CModemATExt::ReceiveUnsolicitedResultCancel"))); iRModemAt.ReceiveUnsolicitedResultCancel(); } @@ -320,12 +357,14 @@ RBuf8& /*aReply*/, TBool& /*aEchoOn*/) { + OstTrace0( TRACE_NORMAL, CMODEMATEXT_HANDLEEDITORMODEINPUT, "CModemATExt::HandleEditorModeInput" ); C_TRACE((_L("CModemATExt::HandleEditorModeInput()"))); return EFalse; //commands are execute commands, this function is newer called } void CModemATExt::ReportNvramStatusChange( const TDesC8& /*aNvram*/ ) { + OstTrace0( TRACE_NORMAL, CMODEMATEXT_REPORTNVRAMSTATUSCHANGE, "CModemATExt::ReportNvramStatusChange" ); C_TRACE((_L("CModemATExt::ReportNvramStatusChange()"))); //Ignored in this plugin } @@ -337,21 +376,27 @@ iUnsolicitedPtr(0, 0), iUnsolicitedBuffer(NULL), iReply(NULL), - iReplyNeeded(EFalse) + iReplyNeeded(EFalse), + iIsTextInputMode( EFalse ), + iDiscardNextReply( EFalse ) { + OstTrace0( TRACE_NORMAL, DUP1_CMODEMATEXT_CMODEMATEXT, "CModemATExt::CModemATExt" ); C_TRACE((_L("CModemATExt::CModemATExt()"))); } void CModemATExt::ConstructL() { + OstTrace0( TRACE_NORMAL, CMODEMATEXT_CONSTRUCTL, "CModemATExt::ConstructL" ); C_TRACE((_L("CModemATExt::ConstructL()"))); iReplyBuffer = HBufC8::NewL( KDefaultCmdBufLength * KPackets ); iReplyPtr.Set( iReplyBuffer->Des() ); - iUnsolicitedBuffer = HBufC8::NewL(KDefaultCmdBufLength); + iUnsolicitedBuffer = HBufC8::NewL( KDefaultCmdBufLength ); + iUnsolicitedPtr.Set( iUnsolicitedBuffer->Des() ); } void CModemATExt::ReportConnectionName( const TDesC8& aName ) { + OstTrace0( TRACE_NORMAL, CMODEMATEXT_REPORTCONNECTIONNAME, "CModemATExt::ReportConnectionName" ); C_TRACE((_L("CModemATExt::ReportConnectionName()"))); DUMP_MESSAGE((aName)); iName.Copy(aName); @@ -360,43 +405,110 @@ void CModemATExt::HandleATCommandCompleted( TInt aErr ) { - C_TRACE((_L("CModemATExt::HandleATCommandCompleted()"))); - - if(iReplyNeeded) + OstTrace1( TRACE_NORMAL, CMODEMATEXT_HANDLEATCOMMANDCOMPLETED, "CModemATExt::HandleATCommandCompleted;aErr=%d", aErr ); + C_TRACE((_L("CModemATExt::HandleATCommandCompleted( %d )"), aErr)); + + if( !iDiscardNextReply ) { - C_TRACE((_L("Reply needed"))); - iReply->Create( iReplyPtr,KPartLength ); + if(iReplyNeeded) + { + OstTrace0( TRACE_NORMAL, DUP1_CMODEMATEXT_HANDLEATCOMMANDCOMPLETED, "CModemATExt::HandleATCommandCompleted - Reply needed" ); + C_TRACE((_L("Reply needed"))); + iReply->Create( iReplyPtr,KPartLength ); + } + iReplyPtr.Delete(0, KPartLength); + + if( aErr == KErrNone) + { + OstTrace0( TRACE_NORMAL, DUP2_CMODEMATEXT_HANDLEATCOMMANDCOMPLETED, "CModemATExt::HandleATCommandCompleted - No errors" ); + C_TRACE((_L("No errors"))); + if( iIsTextInputMode ) + { + iIsTextInputMode = EFalse; + } + HandleCommandCompleted( aErr, EReplyTypeOk); + } + else if( aErr == KErrGeneral ) + { + OstTrace0( TRACE_NORMAL, DUP3_CMODEMATEXT_HANDLEATCOMMANDCOMPLETED, "CModemATExt::HandleATCommandCompleted - Not supported (EReplyTypeUndefined)" ); + C_TRACE((_L("Not supported (EReplyTypeUndefined)"))); + if( iIsTextInputMode ) + { + iIsTextInputMode = EFalse; + } + HandleCommandCompleted( aErr, EReplyTypeUndefined ); + } + else if( aErr == KReplyTypeOther ) + { + OstTrace0( TRACE_NORMAL, DUP4_CMODEMATEXT_HANDLEATCOMMANDCOMPLETED, "CModemATExt::HandleATCommandCompleted - No errors (EReplyTypeOther)" ); + C_TRACE((_L("No errors (EReplyTypeOther)"))); + if( iIsTextInputMode ) + { + iIsTextInputMode = EFalse; + } + HandleCommandCompleted( KErrNone, EReplyTypeOther); + } + else if( aErr == KReplyTypeEditorStart ) + { + OstTrace0( TRACE_NORMAL, DUP5_CMODEMATEXT_HANDLEATCOMMANDCOMPLETED, "CModemATExt::HandleATCommandCompleted - EReplyTypeEditorStart" ); + C_TRACE((_L("EReplyTypeEditorStart"))); + if( !iIsTextInputMode ) + { + iIsTextInputMode = ETrue; + HandleCommandCompleted( KErrNone, static_cast( KReplyTypeEditor ) ); + } + } + else if( aErr == KReplyTypeEditorEnd ) + { + OstTrace0( TRACE_NORMAL, DUP6_CMODEMATEXT_HANDLEATCOMMANDCOMPLETED, "CModemATExt::HandleATCommandCompleted - EReplyTypeEditorEnd" ); + C_TRACE((_L("EReplyTypeEditorEnd"))); + iIsTextInputMode = EFalse; + HandleCommandCompleted( KErrNone, EReplyTypeOk); + } + else + { + OstTrace0( TRACE_NORMAL, DUP7_CMODEMATEXT_HANDLEATCOMMANDCOMPLETED, "CModemATExt::HandleATCommandCompleted - Reply Error" ); + C_TRACE((_L("Reply Error"))); + if( iIsTextInputMode ) + { + iIsTextInputMode = EFalse; + } + HandleCommandCompleted( aErr, EReplyTypeError ); + } } - - iReplyPtr.Delete(0, KPartLength); - C_TRACE((_L("Error status %d"),aErr)); - - if( aErr == KErrNone) + else { - C_TRACE((_L("No errors"))); - HandleCommandCompleted(aErr, EReplyTypeOk); - } - else - { - C_TRACE((_L("Reply Error"))); - HandleCommandCompleted(aErr, EReplyTypeError); + OstTrace0( TRACE_NORMAL, DUP8_CMODEMATEXT_HANDLEATCOMMANDCOMPLETED, "CModemATExt::HandleATCommandCompleted - reply discarded" ); + C_TRACE((_L("CModemATExt::HandleATCommandCompleted: reply discarded"))); + iDiscardNextReply = EFalse; } } -void CModemATExt::HandleUnsolicitedResultReceived( TInt /*aErr*/ ) +void CModemATExt::HandleUnsolicitedResultReceived( TInt aErr ) { - C_TRACE((_L("CModemATExt::HandleUnsolicitedResultReceived"))); - SendUnsolicitedResult( iUnsolicitedPtr ); + OstTrace1( TRACE_NORMAL, CMODEMATEXT_HANDLEUNSOLICITEDRESULTRECEIVED, "CModemATExt::HandleUnsolicitedResultReceived;aErr=%d", aErr ); + C_TRACE((_L("CModemATExt::HandleUnsolicitedResultReceived > ( %d )"), aErr)); + if( KErrNone == aErr ) + { + SendUnsolicitedResult( iUnsolicitedPtr ); + TInt length = iUnsolicitedPtr.Length(); + OstTrace1( TRACE_NORMAL, DUP1_CMODEMATEXT_HANDLEUNSOLICITEDRESULTRECEIVED, "CModemATExt::HandleUnsolicitedResultReceived - reply discarded;length=%d", length ); + C_TRACE((_L("clear unsolicited data buffer, length %d"), length)); + iUnsolicitedPtr.Delete( 0, length ); + } + C_TRACE((_L("CModemATExt::HandleUnsolicitedResultReceived <"))); } void CModemATExt::HandleSignalIndication( TInt /*aErr*/ ) { + OstTrace0( TRACE_NORMAL, CMODEMATEXT_HANDLESIGNALINDICATION, "CModemATExt::HandleSignalIndication" ); C_TRACE((_L("CModemATExt::HandleSignalIndication"))); //COMMON plugin handles signal indications } void CModemATExt::ReportExternalHandleCommandError() { + OstTrace0( TRACE_NORMAL, CMODEMATEXT_REPORTEXTERNALHANDLECOMMANDERROR, "CModemATExt::ReportExternalHandleCommandError" ); C_TRACE((_L("CModemATExt::ReportExternalHandleCommandError()"))); //external error occurred, cancel AT-command iRModemAt.HandleATCommandCancel(); @@ -404,7 +516,142 @@ void CModemATExt::HandleCommandModeChanged( TInt /*aErr*/, TCommandMode /*aMode*/ ) { + OstTrace0( TRACE_NORMAL, CMODEMATEXT_HANDLECOMMANDMODECHANGED, "CModemATExt::HandleCommandModeChanged" ); C_TRACE((_L("CModemATExt::HandleCommandModeChanged()"))); //COMMON plugin handles mode change requests } -// End of File + +void CModemATExt::AddDataToBuffer( + const TDesC8& aCmd, + RBuf8& aReply ) + { + OstTrace0( TRACE_NORMAL, CMODEMATEXT_ADDDATATOBUFFER, "CModemATExt::AddDataToBuffer" ); + C_TRACE((_L("CModemATExt::AddDataToBuffer()"))); + + TBool bufferingCanEnd( EFalse ); + TBool bufferExceeded( EFalse ); + + TInt offsetEscChar = aCmd.Locate( KEscChar ); + TInt offsetCtrlZChar = aCmd.Locate( KCtrlZChar ); + OstTrace1( TRACE_NORMAL, DUP1_CMODEMATEXT_ADDDATATOBUFFER, "CModemATExt::AddDataToBuffer: offsetEscChar: %d", offsetEscChar ); + OstTrace1( TRACE_NORMAL, DUP2_CMODEMATEXT_ADDDATATOBUFFER, "CModemATExt::AddDataToBuffer: offsetCtrlZChar: %d", offsetCtrlZChar ); + C_TRACE(( _L("CModemATExt::AddDataToBuffer: offsets: esc: %d, ctrl-z: %d"), offsetEscChar, offsetCtrlZChar )); + + if( KErrNotFound != offsetEscChar || + KErrNotFound != offsetCtrlZChar ) + { + OstTrace0( TRACE_NORMAL, DUP3_CMODEMATEXT_ADDDATATOBUFFER, "CModemATExt::AddDataToBuffer - end char detected" ); + C_TRACE((_L("CModemATExt::AddDataToBuffer: end char detected") )); + bufferingCanEnd = ETrue; + } + + if( KMaxSmsBufferSize < ( aCmd.Length() + iSmsBuffer.Length() ) ) + { + if( bufferingCanEnd ) + { + TInt offset = 0; + if( KErrNotFound != offsetEscChar ) + { + OstTrace0( TRACE_NORMAL, DUP4_CMODEMATEXT_ADDDATATOBUFFER, "CModemATExt::AddDataToBuffer: (truncated, esc)" ); + C_TRACE((_L("CModemATExt::AddDataToBuffer: buffering data (truncated) (esc char detected)") )); + offset = offsetEscChar + 1; + } + else + { + OstTrace0( TRACE_NORMAL, DUP5_CMODEMATEXT_ADDDATATOBUFFER, "CModemATExt::AddDataToBuffer: (truncated, ctrl-z)" ); + C_TRACE((_L("CModemATExt::AddDataToBuffer: buffering data (truncated) (ctrl-z detected)") )); + offset = offsetCtrlZChar + 1; + } + TInt smsBufferSize = iSmsBuffer.Length() + aCmd.Mid( 0, offset ).Length(); + OstTrace1( TRACE_NORMAL, DUP6_CMODEMATEXT_ADDDATATOBUFFER, "CModemATExt::AddDataToBuffer: current + received: %d", smsBufferSize ); + C_TRACE((_L("CModemATExt::AddDataToBuffer: current + received buffer length: %d"), smsBufferSize )); + if( KMaxSmsBufferSize >= smsBufferSize ) + { + iSmsBuffer.Append( aCmd.Mid( 0, offset ) ); + C_TRACE((_L("CModemATExt::AddDataToBuffer: sending data (end char detected)") )); + SendSmsBuffer( aReply, ETrue, EFalse ); + } + else + { + bufferExceeded = ETrue; + } + } + + if( !bufferingCanEnd || + bufferExceeded ) + { + OstTrace0( TRACE_NORMAL, DUP7_CMODEMATEXT_ADDDATATOBUFFER, "CModemATExt::AddDataToBuffer - too big data or esc" ); + C_TRACE((_L("CModemATExt::AddDataToBuffer: data is too big to buffer or esc char detected") )); + + iDiscardNextReply = ETrue; + iIsTextInputMode = EFalse; + + SendSmsBuffer( aReply, EFalse, ETrue ); + + TBuf8 reply; + reply.Append( iCarriageReturn ); + reply.Append( iLineFeed ); + reply.Append( _L( "ERROR" ) ); + reply.Append( iCarriageReturn ); + reply.Append( iLineFeed ); + + aReply.Create( reply, reply.Length() ); + HandleCommandCompleted( KErrNone, EReplyTypeOk ); + } + } + else + { + OstTrace0( TRACE_NORMAL, DUP8_CMODEMATEXT_ADDDATATOBUFFER, "CModemATExt::AddDataToBuffer - buffering data" ); + C_TRACE((_L("CModemATExt::AddDataToBuffer: buffering data") )); + iSmsBuffer.Append( aCmd ); + if( bufferingCanEnd ) + { + OstTrace0( TRACE_NORMAL, DUP9_CMODEMATEXT_ADDDATATOBUFFER, "CModemATExt::AddDataToBuffer - sending data in text mode" ); + C_TRACE((_L("CModemATExt::AddDataToBuffer: sending data in text mode") )); + SendSmsBuffer( aReply, ETrue, EFalse ); + } + else + { + OstTrace0( TRACE_NORMAL, DUP10_CMODEMATEXT_ADDDATATOBUFFER, "CModemATExt::AddDataToBuffer - data is not sent yet, completing request" ); + C_TRACE((_L("CModemATExt::AddDataToBuffer: data is not sent yet, let's complete request") )); + HandleCommandCompleted( KErrNone, static_cast( KReplyTypeEditor ) ); + } + } + } + +void CModemATExt::SendSmsBuffer( + RBuf8& aReply, + TBool aReplyNeeded, + TBool aCancel ) + { + OstTrace0( TRACE_NORMAL, CMODEMATEXT_SENDSMSBUFFER, "CModemATExt::SendSmsBuffer()" ); + C_TRACE((_L("CModemATExt::SendSmsBuffer() replyNeeded: %d, cancel: %d"), (TInt) aReplyNeeded, (TInt) aCancel )); + iReply = &aReply; + iReplyNeeded = aReplyNeeded; + if( iCommandBuf ) + { + delete iCommandBuf; + iCommandBuf = NULL; + } + if( !aCancel ) + { + iCommandBuf = HBufC8::New( iSmsBuffer.Length() + 1 ); + TPtr8 ptr = iCommandBuf->Des(); + ptr.Append( iSmsBuffer ); + ptr.Append( iCarriageReturn ); + iRModemAt.HandleATCommand( ptr, iReplyPtr ); + } + else + { + iCommandBuf = HBufC8::New( KEscDataSize ); + TPtr8 ptr = iCommandBuf->Des(); + ptr.Append( KEscChar ); + ptr.Append( iCarriageReturn ); + iRModemAt.HandleATCommand( ptr, iReplyPtr ); + } + iSmsBuffer.Zero(); + OstTrace0( TRACE_NORMAL, DUP1_CMODEMATEXT_SENDSMSBUFFER, "CModemATExt::SendSmsBuffer() done" ); + } + +// End of File +