--- a/localconnectivityservice/dun/atext/src/DunAtCmdHandler.cpp Tue Aug 31 16:03:15 2010 +0300
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,1991 +0,0 @@
-/*
-* Copyright (c) 2009-2010 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 handler and notifier
-*
-*/
-
-/*
- * Points to consider:
- * - Each of the AT commands sent to ATEXT are converted to upper case form.
- * Thus the ATEXT plugins don't need to check for case. The conversion to
- * upper case form stops when carriage return or '=' character is found.
- */
-
-/*
- * This file has the following functionality:
- * 1) Line buffer filler:
- * AddDataForParsing(), ManagePartialCommand(), ExtractLineFromInputBuffer(),
- * etc. This buffer is used for parsing. These functions are used for
- * splitter-combiner logic described below. CDunAtCmdPusher is used
- * separately for each element in the line buffer.
- * 2) Parser and splitter-combiner to handle the separater elements (subcommands)
- * in the line buffer. When end of line is detected, iEndIndex is used to
- * extract the next line in iInput to the line buffer (ManageEndOfCmdHandling()
- * and ExtractLineFromInputBuffer()).
- * 3) When end of iEndIndex is found (ExtractLineFromInputBuffer()), more data
- * is asked from CDunUpstream.
- * Note: There is separate handling for "one character input data" and "A/"
- * command handling which should be supported only for one line based data
- * (ManagePartialCommand()).
- */
-
-/*
- * The AT command handling is splitted to two parts on high level:
- * 1) Splitter: splitting the sub-commands in a command line to multiple ones
- * for ATEXT to process.
- * 2) Combiner: combining the replies coming from ATEXT using a filter
- * (the filter categories are explained in DunAtCmdPusher.cpp)
- */
-
-/*
- * Note1: This file uses AT command parsing based on heuristics.
- * Refer to test specification if planning to change the heuristic.
- * Note2: Input buffer management (ExtractLineFromInputBuffer()) can be tested
- * with non-line based terminals such as HyperTerminal or Realterm.
- */
-
-#include "DunAtCmdHandler.h"
-#include "DunAtUrcHandler.h"
-#include "DunDownstream.h"
-#include "DunDebug.h"
-
-const TInt8 KDunCancel = 24; // Used for line editing, cancel character
-const TInt8 KDunEscape = 27; // Used for editor ending, escape character
-
-// ---------------------------------------------------------------------------
-// Two-phased constructor.
-// ---------------------------------------------------------------------------
-//
-EXPORT_C CDunAtCmdHandler* CDunAtCmdHandler::NewL(
- MDunAtCmdStatusReporter* aUpstream,
- MDunStreamManipulator* aDownstream,
- const TDesC8* aConnectionName )
- {
- CDunAtCmdHandler* self = new (ELeave) CDunAtCmdHandler(
- aUpstream,
- aDownstream,
- aConnectionName );
- CleanupStack::PushL( self );
- self->ConstructL();
- CleanupStack::Pop( self );
- return self;
- }
-
-// ---------------------------------------------------------------------------
-// Destructor.
-// ---------------------------------------------------------------------------
-//
-CDunAtCmdHandler::~CDunAtCmdHandler()
- {
- FTRACE(FPrint( _L("CDunAtCmdHandler::~CDunAtCmdHandler()") ));
- ResetData();
- FTRACE(FPrint( _L("CDunAtCmdHandler::~CDunAtCmdHandler() complete") ));
- }
-
-// ---------------------------------------------------------------------------
-// Resets data to initial values
-// ---------------------------------------------------------------------------
-//
-EXPORT_C void CDunAtCmdHandler::ResetData()
- {
- FTRACE(FPrint( _L("CDunAtCmdHandler::ResetData()") ));
- // APIs affecting this:
- // IssueRequest()
- Stop();
- // NewL()
- DeletePluginHandlers();
- delete iCmdEchoer;
- iCmdEchoer = NULL;
- delete iNvramListen;
- iNvramListen = NULL;
- delete iModeListen;
- iModeListen = NULL;
- delete iEcomListen;
- iEcomListen = NULL;
- delete iAtSpecialCmdHandler;
- iAtSpecialCmdHandler = NULL;
- if ( iAtCmdExtCommon.Handle() )
- {
- iAtCmdExtCommon.SynchronousClose();
- iAtCmdExtCommon.Close();
- }
- if ( iAtCmdExt.Handle() )
- {
- iAtCmdExt.SynchronousClose();
- iAtCmdExt.Close();
- }
- iSpecials.ResetAndDestroy();
- iSpecials.Close();
- // AddCmdModeCallback()
- iCmdCallbacks.Close();
- // Internal
- Initialize();
- FTRACE(FPrint( _L("CDunAtCmdHandler::ResetData() complete") ));
- }
-
-// ---------------------------------------------------------------------------
-// Adds callback for command mode notification
-// The callback will be called when command mode starts or ends
-// ---------------------------------------------------------------------------
-//
-EXPORT_C TInt CDunAtCmdHandler::AddCmdModeCallback( MDunCmdModeMonitor* aCallback )
- {
- FTRACE(FPrint( _L("CDunAtCmdHandler::AddCmdModeCallback()" ) ));
- if ( !aCallback )
- {
- FTRACE(FPrint( _L("CDunAtCmdHandler::AddCmdModeCallback() (aCallback) not initialized!" ) ));
- return KErrGeneral;
- }
- TInt retTemp = iCmdCallbacks.Find( aCallback );
- if ( retTemp != KErrNotFound )
- {
- FTRACE(FPrint( _L("CDunAtCmdHandler::AddCmdModeCallback() (already exists) complete" ) ));
- return KErrAlreadyExists;
- }
- retTemp = iCmdCallbacks.Append( aCallback );
- if ( retTemp != KErrNone )
- {
- FTRACE(FPrint( _L("CDunAtCmdHandler::AddCmdModeCallback() (append failed!) complete" ) ));
- return retTemp;
- }
- FTRACE(FPrint( _L("CDunAtCmdHandler::AddCmdModeCallback() complete" ) ));
- return KErrNone;
- }
-
-// ---------------------------------------------------------------------------
-// Adds data for parsing and parses if necessary
-// ---------------------------------------------------------------------------
-//
-EXPORT_C TInt CDunAtCmdHandler::AddDataForParsing( TDesC8& aInput,
- TBool& aMoreNeeded )
- {
- FTRACE(FPrint( _L("CDunAtCmdHandler::AddDataForParsing()") ));
- FTRACE(FPrint( _L("CDunAtCmdHandler::AddDataForParsing() received (%d bytes):"), aInput.Length() ));
- FTRACE(FPrintRaw(aInput) );
- TBool editorMode = iCmdPusher->EditorMode();
- if ( editorMode )
- {
- // Note: return here with "no more data needed" and some error to fool
- // CDunUpstream into not reissuing the read request.
- iCmdPusher->IssueRequest( aInput, EFalse );
- aMoreNeeded = EFalse;
- return KErrGeneral;
- }
- iInput = &aInput; // iInput only for normal mode
- // Manage partial AT command
- TBool moreNeeded = ManagePartialCommand();
- if ( moreNeeded )
- {
- aMoreNeeded = ETrue;
- FTRACE(FPrint( _L("CDunAtCmdHandler::AddDataForParsing() (more partial) complete") ));
- return KErrNone;
- }
- if ( iHandleState != EDunStateIdle )
- {
- aMoreNeeded = EFalse;
- ManageEndOfCmdHandling( EFalse, EFalse );
- FTRACE(FPrint( _L("CDunAtCmdHandler::AddDataForParsing() (not ready) complete") ));
- return KErrNotReady;
- }
- TBool pushStarted = HandleASlashCommand();
- if ( pushStarted )
- {
- // Note: return here with "partial input" status to fool CDunUpstream
- // into reissuing the read request. The AT command has not really
- // started yet so this is necessary.
- aMoreNeeded = ETrue;
- ManageEndOfCmdHandling( EFalse, EFalse );
- FTRACE(FPrint( _L("CDunAtCmdHandler::AddDataForParsing() (A/) complete") ));
- return KErrNone;
- }
- iHandleState = EDunStateAtCmdHandling;
- iDecodeInfo.iFirstDecode = ETrue;
- iDecodeInfo.iDecodeIndex = 0;
- iDecodeInfo.iPrevExists = EFalse;
- iParseInfo.iLimit = KErrNotFound;
- iParseInfo.iSendBuffer.Zero();
- iEditorModeInfo.iContentFound = EFalse;
- HandleNextSubCommand();
- FTRACE(FPrint( _L("CDunAtCmdHandler::AddDataForParsing() complete") ));
- aMoreNeeded = EFalse;
- return KErrNone;
- }
-
-// ---------------------------------------------------------------------------
-// Manages request to abort command handling
-// ---------------------------------------------------------------------------
-//
-EXPORT_C TInt CDunAtCmdHandler::ManageAbortRequest()
- {
- FTRACE(FPrint( _L("CDunAtCmdHandler::ManageAbortRequest()") ));
- // Just forward the request, do no other own processing
- TInt retVal = iCmdPusher->ManageAbortRequest();
- FTRACE(FPrint( _L("CDunAtCmdHandler::ManageAbortRequest() complete") ));
- return retVal;
- }
-
-// ---------------------------------------------------------------------------
-// Sends a character to be echoed
-// ---------------------------------------------------------------------------
-//
-EXPORT_C TInt CDunAtCmdHandler::SendEchoCharacter( const TDesC8* aInput,
- MDunAtCmdEchoer* aCallback )
- {
- FTRACE(FPrint( _L("CDunAtCmdHandler::SendEchoCharacter()") ));
- TInt retVal = iCmdEchoer->SendEchoCharacter( aInput, aCallback );
- FTRACE(FPrint( _L("CDunAtCmdHandler::SendEchoCharacter() complete") ));
- return retVal;
- }
-
-// ---------------------------------------------------------------------------
-// Stops sending of AT command from parse buffer
-// ---------------------------------------------------------------------------
-//
-EXPORT_C TInt CDunAtCmdHandler::Stop()
- {
- FTRACE(FPrint( _L("CDunAtCmdHandler::Stop()") ));
- // Only stop iCmdPusher here, not iUrcHandlers!
- if ( iHandleState != EDunStateAtCmdHandling )
- {
- FTRACE(FPrint( _L("CDunAtCmdHandler::Stop() (not ready) complete" )));
- return KErrNotReady;
- }
- iCmdPusher->Stop();
- // The line below is used in the case when this function is called by
- // CDunUpstream as a result of "data mode ON" change notification.
- // In this case it is possible that HandleNextSubCommand() returns
- // without resetting the iSendBuffer because of the way it checks the
- // iHandleState.
- ManageEndOfCmdHandling( ETrue, EFalse );
- FTRACE(FPrint( _L("CDunAtCmdHandler::Stop() complete") ));
- return KErrNone;
- }
-
-// ---------------------------------------------------------------------------
-// Starts URC message handling
-// ---------------------------------------------------------------------------
-//
-EXPORT_C TInt CDunAtCmdHandler::StartUrc()
- {
- FTRACE(FPrint( _L("CDunAtCmdHandler::StartUrc()") ));
- TInt i;
- TInt count = iUrcHandlers.Count();
- for ( i=0; i<count; i++ )
- {
- TInt retTemp = iUrcHandlers[i]->IssueRequest();
- if ( retTemp!=KErrNone && retTemp!=KErrNotReady )
- {
- FTRACE(FPrint( _L("CDunAtCmdHandler::StartUrc() (ERROR) complete") ));
- return retTemp;
- }
- }
- FTRACE(FPrint( _L("CDunAtCmdHandler::StartUrc() complete") ));
- return KErrNone;
- }
-
-// ---------------------------------------------------------------------------
-// Stops URC message handling
-// ---------------------------------------------------------------------------
-//
-EXPORT_C TInt CDunAtCmdHandler::StopUrc()
- {
- FTRACE(FPrint( _L("CDunAtCmdHandler::StopUrc()") ));
- TInt i;
- TInt retVal = KErrNone;
- TInt count = iUrcHandlers.Count();
- for ( i=0; i<count; i++ )
- {
- retVal = iUrcHandlers[i]->Stop();
- }
- FTRACE(FPrint( _L("CDunAtCmdHandler::StopUrc() complete") ));
- return retVal;
- }
-
-// ---------------------------------------------------------------------------
-// CDunAtCmdHandler::CDunAtCmdHandler
-// ---------------------------------------------------------------------------
-//
-CDunAtCmdHandler::CDunAtCmdHandler( MDunAtCmdStatusReporter* aUpstream,
- MDunStreamManipulator* aDownstream,
- const TDesC8* aConnectionName ) :
- iUpstream( aUpstream ),
- iDownstream( aDownstream ),
- iConnectionName( aConnectionName )
- {
- Initialize();
- }
-
-// ---------------------------------------------------------------------------
-// CDunAtCmdHandler::ConstructL
-// ---------------------------------------------------------------------------
-//
-void CDunAtCmdHandler::ConstructL()
- {
- FTRACE(FPrint( _L("CDunAtCmdHandler::ConstructL()") ));
- if ( !iUpstream || !iDownstream || !iConnectionName )
- {
- User::Leave( KErrGeneral );
- }
- // Connect to AT command extension (must succeed)
- TInt retTemp = KErrNone;
- CleanupClosePushL( iAtCmdExt );
- retTemp = iAtCmdExt.Connect( EDunATExtension, *iConnectionName );
- if ( retTemp != KErrNone )
- {
- FTRACE(FPrint( _L("CDunAtCmdHandler::ConstructL() connect (%d)"), retTemp));
- User::Leave( retTemp );
- }
- CleanupClosePushL( iAtCmdExtCommon );
- retTemp = iAtCmdExtCommon.Connect( *iConnectionName );
- if ( retTemp != KErrNone )
- {
- FTRACE(FPrint( _L("CDunAtCmdHandler::ConstructL() common connect (%d)"), retTemp));
- User::Leave( retTemp );
- }
- // Create the array of special commands
- CreateSpecialCommandsL();
- // Create the plugin handlers
- CreatePluginHandlersL();
- // Create the echo handler
- iCmdEchoer = CDunAtCmdEchoer::NewL( iDownstream );
- // Create the listeners
- iEcomListen = CDunAtEcomListen::NewL( &iAtCmdExt, this );
- iModeListen = CDunAtModeListen::NewL( &iAtCmdExtCommon, this );
- iNvramListen = CDunAtNvramListen::NewL( &iAtCmdExt, &iAtCmdExtCommon );
- iAtSpecialCmdHandler = CDunAtSpecialCmdHandler::NewL();
- // Set the default modes (+report) and characters
- GetAndSetDefaultSettingsL();
- // Start listening
- iEcomListen->IssueRequest();
- iModeListen->IssueRequest();
- iNvramListen->IssueRequest();
- CleanupStack::Pop( &iAtCmdExtCommon );
- CleanupStack::Pop( &iAtCmdExt );
- FTRACE(FPrint( _L("CDunAtCmdHandler::ConstructL() complete") ));
- }
-
-// ---------------------------------------------------------------------------
-// Initializes this class
-// ---------------------------------------------------------------------------
-//
-void CDunAtCmdHandler::Initialize()
- {
- // Don't initialize iUpstream here (it is set through NewL)
- // Don't initialize iDownstream here (it is set through NewL)
- // Don't initialize iConnectionName here (it is set through NewL)
- iHandleState = EDunStateIdle;
- iCarriageReturn = 0;
- iLineFeed = 0;
- iBackspace = 0;
- iInput = NULL;
- iDecodeInfo.iFirstDecode = ETrue;
- iDecodeInfo.iDecodeIndex = KErrNotFound;
- iDecodeInfo.iExtendedIndex = KErrNotFound;
- iDecodeInfo.iPrevChar = 0;
- iDecodeInfo.iPrevExists = EFalse;
- iDecodeInfo.iAssignFound = EFalse;
- iDecodeInfo.iInQuotes = EFalse;
- iDecodeInfo.iSpecialFound = EFalse;
- iDecodeInfo.iCmdsHandled = 0;
- iEditorModeInfo.iContentFound = EFalse;
- iCmdPusher = NULL;
- iEcomListen = NULL;
- iModeListen = NULL;
- iNvramListen = NULL;
- iDataMode = EFalse;
- iEchoOn = EFalse;
- iQuietOn = EFalse;
- iVerboseOn = EFalse;
- iEndIndex = KErrNotFound;
- }
-
-// ---------------------------------------------------------------------------
-// Creates plugin handlers for this class
-// ---------------------------------------------------------------------------
-//
-void CDunAtCmdHandler::CreatePluginHandlersL()
- {
- FTRACE(FPrint( _L("CDunAtCmdHandler::CreatePluginHandlersL()") ));
- if ( !iAtCmdExt.Handle() )
- {
- FTRACE(FPrint( _L("CDunAtCmdHandler::CreatePluginHandlersL() complete") ));
- User::Leave( KErrGeneral );
- }
- // First create the command reply pusher
- CDunAtCmdPusher* cmdPusher = CDunAtCmdPusher::NewLC( &iAtCmdExt,
- this,
- iDownstream,
- &iOkBuffer );
- // Next create the URC handlers
- TInt i;
- TInt numOfPlugins = iAtCmdExt.NumberOfPlugins();
- for ( i=0; i<numOfPlugins; i++ )
- {
- AddOneUrcHandlerL();
- }
- CleanupStack::Pop( cmdPusher );
- iCmdPusher = cmdPusher;
- FTRACE(FPrint( _L("CDunAtCmdHandler::CreatePluginHandlersL() complete") ));
- }
-
-// ---------------------------------------------------------------------------
-// Creates an array of special commands
-// ---------------------------------------------------------------------------
-//
-void CDunAtCmdHandler::CreateSpecialCommandsL()
- {
- FTRACE(FPrint( _L("CDunAtCmdHandler::CreateSpecialCommandsL()") ));
- TInt retTemp = KErrNone;
- TBool firstSearch = ETrue;
- for ( ;; )
- {
- // Let's borrow iLineBuffer for this purpose
- retTemp = iAtCmdExt.GetNextSpecialCommand( iLineBuffer, firstSearch );
- if ( retTemp != KErrNone )
- {
- break;
- }
- TInt lineLength = iLineBuffer.Length();
- HBufC8* specialCmd = HBufC8::NewMaxLC( lineLength );
- *specialCmd = iLineBuffer;
- iSpecials.AppendL( specialCmd );
- CleanupStack::Pop( specialCmd );
- }
- iLineBuffer.Zero();
- FTRACE(FPrint( _L("CDunAtCmdHandler::CreateSpecialCommandsL() complete") ));
- }
-
-// ---------------------------------------------------------------------------
-// Recreates special command data.
-// This is done when a plugin is installed or uninstalled.
-// ---------------------------------------------------------------------------
-//
-TInt CDunAtCmdHandler::RecreateSpecialCommands()
- {
- FTRACE(FPrint( _L("CDunAtCmdHandler::RecreateSpecialCommands()") ));
- iSpecials.ResetAndDestroy();
- TRAPD( retTrap, CreateSpecialCommandsL() );
- FTRACE(FPrint( _L("CDunAtCmdHandler::RecreateSpecialCommands() complete") ));
- return retTrap;
- }
-
-// ---------------------------------------------------------------------------
-// Gets default settings from RATExtCommon and sets them to RATExt
-// ---------------------------------------------------------------------------
-//
-void CDunAtCmdHandler::GetAndSetDefaultSettingsL()
- {
- FTRACE(FPrint( _L("CDunAtCmdHandler::GetAndSetDefaultSettingsL()") ));
- // Note: Let's assume command mode is off by default
- TUint modeSet = GetCurrentModeL( KModeEcho | KModeQuiet | KModeVerbose );
- iEchoOn = ( modeSet & KEchoModeBase ) ? ETrue : EFalse;
- iQuietOn = ( modeSet & KQuietModeBase ) ? ETrue : EFalse;
- iVerboseOn = ( modeSet & KVerboseModeBase ) ? ETrue : EFalse;
- iCarriageReturn = GetCurrentModeL( KModeCarriage );
- iLineFeed = GetCurrentModeL( KModeLineFeed );
- iBackspace = GetCurrentModeL( KModeBackspace );
- iAtCmdExt.ReportQuietModeChange( iQuietOn );
- iAtCmdExt.ReportVerboseModeChange( iVerboseOn );
- iAtCmdExt.ReportCharacterChange( ECharTypeCarriage, iCarriageReturn );
- iAtCmdExt.ReportCharacterChange( ECharTypeLineFeed, iLineFeed );
- iAtCmdExt.ReportCharacterChange( ECharTypeBackspace, iBackspace );
- RegenerateReplyStrings();
- FTRACE(FPrint( _L("CDunAtCmdHandler::GetAndSetDefaultSettingsL() settings: E=%d, Q=%d, V=%d"), iEchoOn, iQuietOn, iVerboseOn ));
- FTRACE(FPrint( _L("CDunAtCmdHandler::GetAndSetDefaultSettingsL() settings: CR=%u, LF=%u, BS=%u"), iCarriageReturn, iLineFeed, iBackspace ));
- FTRACE(FPrint( _L("CDunAtCmdHandler::GetAndSetDefaultSettingsL() complete") ));
- }
-
-// ---------------------------------------------------------------------------
-// Regenerates the reply strings based on settings
-// ---------------------------------------------------------------------------
-//
-TBool CDunAtCmdHandler::RegenerateReplyStrings()
- {
- FTRACE(FPrint( _L("CDunAtCmdHandler::RegenerateReplyStrings()") ));
- TBool retVal = EFalse;
- retVal |= RegenerateOkReply();
- retVal |= RegenerateErrorReply();
- FTRACE(FPrint( _L("CDunAtCmdHandler::RegenerateReplyStrings() complete") ));
- return retVal;
- }
-
-// ---------------------------------------------------------------------------
-// Regenerates the ok reply based on settings
-// ---------------------------------------------------------------------------
-//
-TBool CDunAtCmdHandler::RegenerateOkReply()
- {
- FTRACE(FPrint( _L("CDunAtCmdHandler::RegenerateOkReply()") ));
- if ( iDownstream->IsDataInQueue(&iOkBuffer) )
- {
- FTRACE(FPrint( _L("CDunAtCmdHandler::RegenerateOkReply() (in queue!) complete") ));
- return iQuietOn;
- }
- iOkBuffer.Zero();
- if ( iQuietOn )
- {
- FTRACE(FPrint( _L("CDunAtCmdHandler::RegenerateOkReply() (quiet) complete") ));
- return ETrue;
- }
- if ( iVerboseOn )
- {
- _LIT8( KVerboseOk, "OK" );
- iOkBuffer.Append( iCarriageReturn );
- iOkBuffer.Append( iLineFeed );
- iOkBuffer.Append( KVerboseOk );
- iOkBuffer.Append( iCarriageReturn );
- iOkBuffer.Append( iLineFeed );
- }
- else
- {
- _LIT8( KNumericOk, "0" );
- iOkBuffer.Append( KNumericOk );
- iOkBuffer.Append( iCarriageReturn );
- }
- FTRACE(FPrint( _L("CDunAtCmdHandler::RegenerateOkReply() complete") ));
- return EFalse;
- }
-
-// ---------------------------------------------------------------------------
-// Regenerates the error reply based on settings
-// ---------------------------------------------------------------------------
-//
-TBool CDunAtCmdHandler::RegenerateErrorReply()
- {
- FTRACE(FPrint( _L("CDunAtCmdHandler::RegenerateErrorReply()") ));
- if ( iDownstream->IsDataInQueue(&iErrorBuffer) )
- {
- FTRACE(FPrint( _L("CDunAtCmdHandler::RegenerateErrorReply() (in queue!) complete") ));
- return iQuietOn;
- }
- iErrorBuffer.Zero();
- if ( iQuietOn )
- {
- FTRACE(FPrint( _L("CDunAtCmdHandler::RegenerateErrorReply() (quiet) complete") ));
- return ETrue;
- }
- if ( iVerboseOn )
- {
- _LIT8( KVerboseError, "ERROR" );
- iErrorBuffer.Append( iCarriageReturn );
- iErrorBuffer.Append( iLineFeed );
- iErrorBuffer.Append( KVerboseError );
- iErrorBuffer.Append( iCarriageReturn );
- iErrorBuffer.Append( iLineFeed );
- }
- else
- {
- _LIT8( KNumericError, "4" );
- iErrorBuffer.Append( KNumericError );
- iErrorBuffer.Append( iCarriageReturn );
- }
- FTRACE(FPrint( _L("CDunAtCmdHandler::RegenerateErrorReply() complete") ));
- return EFalse;
- }
-
-// ---------------------------------------------------------------------------
-// Gets current mode
-// ---------------------------------------------------------------------------
-//
-TUint CDunAtCmdHandler::GetCurrentModeL( TUint aMask )
- {
- FTRACE(FPrint( _L("CDunAtCmdHandler::GetCurrentModeL()") ));
- TUint maskCheck = aMask & ( ~KSupportedModes );
- if ( maskCheck != 0 )
- {
- FTRACE(FPrint( _L("CDunAtCmdHandler::GetCurrentModeL() (not supported) complete") ));
- User::Leave( KErrNotSupported );
- }
- TUint newMode = 0;
- TInt retTemp = iAtCmdExtCommon.GetMode( aMask, newMode );
- if ( retTemp != KErrNone )
- {
- FTRACE(FPrint( _L("CDunAtCmdHandler::GetCurrentModeL() (ERROR) complete") ));
- User::Leave( retTemp );
- }
- FTRACE(FPrint( _L("CDunAtCmdHandler::GetCurrentModeL() complete") ));
- return newMode & (KModeChanged-1);
- }
-
-// ---------------------------------------------------------------------------
-// Instantiates one URC message handling class instance and adds it to the URC
-// message handler array
-// ---------------------------------------------------------------------------
-//
-CDunAtUrcHandler* CDunAtCmdHandler::AddOneUrcHandlerL()
- {
- FTRACE(FPrint( _L("CDunAtCmdHandler::AddOneUrcHandlerL()") ));
- CDunAtUrcHandler* urcHandler = CDunAtUrcHandler::NewLC( &iAtCmdExt,
- iDownstream );
- iUrcHandlers.AppendL( urcHandler );
- CleanupStack::Pop( urcHandler );
- FTRACE(FPrint( _L("CDunAtCmdHandler::AddOneUrcHandlerL() complete") ));
- return urcHandler;
- }
-
-// ---------------------------------------------------------------------------
-// Deletes all instantiated URC message handlers
-// ---------------------------------------------------------------------------
-//
-void CDunAtCmdHandler::DeletePluginHandlers()
- {
- FTRACE(FPrint( _L("CDunAtCmdHandler::DeletePluginHandlers()") ));
- delete iCmdPusher;
- iCmdPusher = NULL;
- TInt i;
- TInt count = iUrcHandlers.Count();
- for ( i=0; i<count; i++ )
- {
- delete iUrcHandlers[i];
- iUrcHandlers[i] = NULL;
- }
- iUrcHandlers.Reset();
- iUrcHandlers.Close();
- FTRACE(FPrint( _L("CDunAtCmdHandler::DeletePluginHandlers() complete") ));
- }
-
-// ---------------------------------------------------------------------------
-// Manages partial AT command
-// ---------------------------------------------------------------------------
-//
-TBool CDunAtCmdHandler::ManagePartialCommand()
- {
- FTRACE(FPrint( _L("CDunAtCmdHandler::ManagePartialCommand()") ));
- // Check one character (or unit) based input data
- if ( iInput->Length() == KDunChSetMaxCharLen )
- {
- EchoCommand();
- // Handle backspace and cancel characters
- TBool found = HandleSpecialCharacters();
- if ( found )
- {
- FTRACE(FPrint( _L("CDunAtCmdHandler::ManagePartialCommand() (special) complete") ));
- return ETrue;
- }
- }
- TBool moreNeeded = ExtractLineFromInputBuffer();
- if ( moreNeeded )
- {
- // More data is not needed with "A/" (no carriage return), check that
- // special case here, otherwise continue processing
- if ( !IsASlashCommand() )
- {
- FTRACE(FPrint( _L("CDunAtCmdHandler::ManagePartialCommand() (more) complete") ));
- return ETrue;
- }
- }
- // If something went wrong, do nothing (return consumed)
- if ( iLineBuffer.Length() <= 0 )
- {
- FTRACE(FPrint( _L("CDunAtCmdHandler::ManagePartialCommand() (length) complete") ));
- return ETrue;
- }
- // For other commands, just return with consumed
- FTRACE(FPrint( _L("CDunAtCmdHandler::ManagePartialCommand() complete") ));
- return EFalse;
- }
-
-// ---------------------------------------------------------------------------
-// Echoes a command if echo is on
-// ---------------------------------------------------------------------------
-//
-TBool CDunAtCmdHandler::EchoCommand()
- {
- FTRACE(FPrint( _L("CDunAtCmdHandler::EchoCommand()") ));
- if ( iInput->Length() > KDunChSetMaxCharLen )
- {
- FTRACE(FPrint( _L("CDunAtCmdHandler::EchoCommand() (wrong length) complete") ));
- return EFalse;
- }
- if ( iEchoOn )
- {
- if ( iDownstream->IsDataInQueue(&iEchoBuffer) )
- {
- FTRACE(FPrint( _L("CDunAtCmdHandler::EchoCommand() (in queue!) complete") ));
- return EFalse;
- }
- iEchoBuffer.Copy( *iInput );
- iDownstream->NotifyDataPushRequest( &iEchoBuffer, NULL );
- FTRACE(FPrint( _L("CDunAtCmdHandler::EchoCommand() complete") ));
- return ETrue;
- }
- FTRACE(FPrint( _L("CDunAtCmdHandler::EchoCommand() (not started) complete") ));
- return EFalse;
- }
-
-// ---------------------------------------------------------------------------
-// Handles backspace and cancel characters
-// ---------------------------------------------------------------------------
-//
-TBool CDunAtCmdHandler::HandleSpecialCharacters()
- {
- FTRACE(FPrint( _L("CDunAtCmdHandler::HandleSpecialCharacters()") ));
- if ( iInput->Length() != KDunChSetMaxCharLen )
- {
- FTRACE(FPrint( _L("CDunAtCmdHandler::HandleSpecialCharacters() (wrong length) complete") ));
- return EFalse;
- }
- if ( (*iInput)[0] == iBackspace )
- {
- TInt lineLength = iLineBuffer.Length();
- if ( lineLength > 0 )
- {
- iLineBuffer.SetLength( lineLength-1 );
- }
- FTRACE(FPrint( _L("CDunAtCmdHandler::HandleSpecialCharacters() (backspace) complete") ));
- return ETrue;
- }
- if ( (*iInput)[0] == KDunCancel )
- {
- ManageEndOfCmdHandling( EFalse, EFalse );
- FTRACE(FPrint( _L("CDunAtCmdHandler::HandleSpecialCharacters() (cancel) complete") ));
- return ETrue;
- }
- FTRACE(FPrint( _L("CDunAtCmdHandler::HandleSpecialCharacters() complete") ));
- return EFalse;
- }
-
-// ---------------------------------------------------------------------------
-// Extracts line from input buffer to line buffer
-// ---------------------------------------------------------------------------
-//
-TBool CDunAtCmdHandler::ExtractLineFromInputBuffer()
- {
- FTRACE(FPrint( _L("CDunAtCmdHandler::ExtractLineFromInputBuffer()") ));
- FTRACE(FPrint( _L("CDunAtCmdHandler::ExtractLineFromInputBuffer() before (%d bytes):"), iLineBuffer.Length() ));
- FTRACE(FPrintRaw(iLineBuffer) );
- // Case1: If no data in iLineBuffer and end-of-line character in iInputBuffer[start]:
- // - Skip end-of-line characters, find start-of-line condition, find end-of-line character
- // - If partial line found (start-of-line condition and no end-of-line character):
- // - Save partial line to iLineBuffer
- // - Set iEndIndex to end of iInputBuffer
- // - If full line found (start-of-line condition and end-of-line character):
- // - Save full line to iLineBuffer
- // - Skip multiple end-of-line characters until next start-of-line
- // condition or end of iInputBuffer -> save this position to iEndIndex
- // Case2: If no data in iLineBuffer and non-end-of-line character in iInputBuffer[start]:
- // - Find end-of-line character
- // - If partial line found (no end-of-line character):
- // - Save partial line to iLineBuffer
- // - Set iEndIndex to end of iLineBuffer
- // - If full line found (end-of-line character):
- // - Save full line to iLineBuffer
- // - Skip multiple end-of-line characters until next start-of-line
- // condition or end of iInputBuffer -> save this position to iEndIndex
- // Case3: If data in iLineBuffer and end-of-line character in iInputBuffer[start]:
- // - Skip end-of-line characters
- // - Keep string currently in iLineBuffer
- // - Skip end-of-line characters until non-end-of-line or end of
- // iInputBuffer -> save this position to iEndIndex
- // Case4: If data in iLineBuffer and non-end-of-line character in iInputBuffer[start]:
- // - Processed the same way as Case1, however "Skip end-of-line characters" does
- // not have any effect
- if ( iInput->Length() <= 0 )
- {
- FTRACE(FPrint( _L("CDunAtCmdHandler::ExtractLineFromInputBuffer() (wrong length) complete") ));
- return ETrue;
- }
- TBool moreNeeded = ETrue;
- TBool copyNeeded = EFalse;
- TInt copyLength = KErrNotFound;
- TInt lineLength = iLineBuffer.Length();
- TInt lineMaxLength = iLineBuffer.MaxLength();
- TInt freeLineSpace = lineMaxLength - lineLength;
- TInt inputLength = iInput->Length();
- TInt startIndex = ( iEndIndex>=0 ) ? iEndIndex : 0;
- if ( startIndex >= inputLength )
- {
- iEndIndex = KErrNotFound;
- FTRACE(FPrint( _L("CDunAtCmdHandler::ExtractLineFromInputBuffer() (input end) complete") ));
- return ETrue;
- }
- // Cases here:
- // Case1: If no data in iLineBuffer and end-of-line character in iInputBuffer[start]
- // Case2: If no data in iLineBuffer and non-end-of-line character in iInputBuffer[start]
- // Case3: If data in iLineBuffer and end-of-line character in iInputBuffer[start]
- // Case4: If data in iLineBuffer and non-end-of-line character in iInputBuffer[start]
- // Summary: Cases 1, 2 and 4 can be combined. Case 3 needs a separate check.
- TChar character = (*iInput)[startIndex];
- TBool endOfLine = IsEndOfLine(character);
- if ( lineLength>0 && endOfLine )
- {
- moreNeeded = HandleSpecialBufferManagement( startIndex,
- copyLength,
- copyNeeded );
- }
- else
- {
- moreNeeded = HandleGenericBufferManagement( startIndex,
- copyLength,
- copyNeeded );
- }
- if ( copyNeeded && copyLength>0 )
- {
- // Check the case copyLength does not fit to iLineBuffer
- // This case should be handled by returning "more data needed"
- // Also reset the iLineBuffer to ensure the handling doesn't stuck
- // for rest of the commands (usability case)
- if ( copyLength > freeLineSpace )
- {
- iLineBuffer.Zero();
- iEndIndex = KErrNotFound;
- FTRACE(FPrint( _L("CDunAtCmdHandler::ExtractLineFromInputBuffer() after (%d bytes):"), iLineBuffer.Length() ));
- FTRACE(FPrintRaw(iLineBuffer) );
- FTRACE(FPrint( _L("CDunAtCmdHandler::ExtractLineFromInputBuffer() (overflow) complete") ));
- return ETrue;
- }
- iLineBuffer.Append( &(*iInput)[startIndex], copyLength );
- FTRACE(FPrint( _L("CDunAtCmdHandler::ExtractLineFromInputBuffer() after (%d bytes):"), iLineBuffer.Length() ));
- FTRACE(FPrintRaw(iLineBuffer) );
- }
- if ( moreNeeded )
- {
- iEndIndex = KErrNotFound;
- FTRACE(FPrint( _L("CDunAtCmdHandler::ExtractLineFromInputBuffer() (more needed) complete") ));
- return ETrue;
- }
- FTRACE(FPrint( _L("CDunAtCmdHandler::ExtractLineFromInputBuffer() (line found) complete") ));
- return EFalse;
- }
-
-// ---------------------------------------------------------------------------
-// Handles generic buffer management
-// (explanation in ExtractLineFromInputBuffer())
-// ---------------------------------------------------------------------------
-//
-TBool CDunAtCmdHandler::HandleGenericBufferManagement( TInt& aStartIndex,
- TInt& aCopyLength,
- TBool& aCopyNeeded )
- {
- FTRACE(FPrint( _L("CDunAtCmdHandler::HandleGenericBufferManagement()") ));
- TInt inputLength = iInput->Length();
- TInt currentIndex = SkipEndOfLineCharacters( aStartIndex );
- if ( currentIndex >= inputLength )
- {
- // No data in iLineBuffer and only end-of-lines in new buffer
- // return with "need more data"
- iEndIndex = inputLength;
- aCopyLength = 0;
- aCopyNeeded = EFalse;
- FTRACE(FPrint( _L("CDunAtCmdHandler::HandleGenericBufferManagement() (new end for old no data) complete") ));
- return ETrue;
- }
- // No data in iLineBuffer and non-end-of-line character found
- // Try to find the first start-of-line condition
- TInt lineLength = iLineBuffer.Length();
- if ( lineLength == 0 )
- {
- currentIndex = SkipSubCommandDelimiterCharacters( aStartIndex );
- if ( currentIndex >= inputLength )
- {
- // No data in iLineBuffer and only end-of-lines+delimiter in new buffer
- // return with "need more data"
- iEndIndex = inputLength;
- aCopyLength = 0;
- aCopyNeeded = EFalse;
- FTRACE(FPrint( _L("CDunAtCmdHandler::HandleGenericBufferManagement() (new end+delim for old no data) complete") ));
- return ETrue;
- }
- }
- aStartIndex = currentIndex;
- // No data in iLineBuffer and other than end-of-line or delimiter character found
- // Variable currentIndex is now the start of new command
- // Next try to find the end of the command
- TInt endIndex = FindEndOfLine( aStartIndex );
- if ( endIndex >= inputLength )
- {
- // No data in iLineBuffer and start of command found without end
- // return with "need more data"
- iEndIndex = inputLength;
- aCopyLength = inputLength - aStartIndex;
- aCopyNeeded = ETrue;
- FTRACE(FPrint( _L("CDunAtCmdHandler::HandleGenericBufferManagement() (start but no end for old no data) complete") ));
- return ETrue;
- }
- // No data in iLineBuffer and end-of-line character found
- // Try to skip possible multiple end-of-line characters
- currentIndex = SkipEndOfLineCharacters( endIndex );
- // Variable currentIndex is now either start of next command or end of iInput
- // Note that this requires that Case 2 must skip the possible IsDelimiterCharacter()s
- iEndIndex = currentIndex;
- aCopyLength = endIndex - aStartIndex;
- aCopyNeeded = ETrue;
- FTRACE(FPrint( _L("CDunAtCmdHandler::HandleGenericBufferManagement() (line found) complete") ));
- return EFalse;
- }
-
-// ---------------------------------------------------------------------------
-// Handles special buffer management
-// (explanation in ExtractLineFromInputBuffer())
-// ---------------------------------------------------------------------------
-//
-TBool CDunAtCmdHandler::HandleSpecialBufferManagement( TInt aStartIndex,
- TInt& aCopyLength,
- TBool& aCopyNeeded )
- {
- FTRACE(FPrint( _L("CDunAtCmdHandler::HandleSpecialBufferManagement()") ));
- TInt currentIndex = SkipEndOfLineCharacters( aStartIndex );
- // Variable currentIndex is now either start of next command or end of iInput
- iEndIndex = currentIndex;
- aCopyLength = 0;
- aCopyNeeded = EFalse;
- FTRACE(FPrint( _L("CDunAtCmdHandler::HandleSpecialBufferManagement() complete") ));
- return EFalse;
- }
-
-// ---------------------------------------------------------------------------
-// Skips end-of-line characters
-// ---------------------------------------------------------------------------
-//
-TInt CDunAtCmdHandler::SkipEndOfLineCharacters( TInt aStartIndex )
- {
- FTRACE(FPrint( _L("CDunAtCmdHandler::SkipEndOfLineCharacters()") ));
- TInt foundIndex = iInput->Length();
- TInt inputLength = foundIndex;
- for ( TInt i=aStartIndex; i<inputLength; i++ )
- {
- TChar character = (*iInput)[i];
- if ( !IsEndOfLine(character) )
- {
- foundIndex = i;
- break;
- }
- }
- FTRACE(FPrint( _L("CDunAtCmdHandler::SkipEndOfLineCharacters() complete") ));
- return foundIndex;
- }
-
-// ---------------------------------------------------------------------------
-// Skips subcommand delimiter characters
-// ---------------------------------------------------------------------------
-//
-TInt CDunAtCmdHandler::SkipSubCommandDelimiterCharacters( TInt aStartIndex )
- {
- FTRACE(FPrint( _L("CDunAtCmdHandler::SkipSubCommandDelimiterCharacters()") ));
- TInt inputLength = iInput->Length();
- TInt foundIndex = inputLength;
- for ( TInt i=aStartIndex; i<inputLength; i++ )
- {
- TChar character = (*iInput)[i];
- if ( !IsDelimiterCharacter(character) )
- {
- foundIndex = i;
- break;
- }
- }
- FTRACE(FPrint( _L("CDunAtCmdHandler::SkipSubCommandDelimiterCharacters() complete") ));
- return foundIndex;
- }
-
-// ---------------------------------------------------------------------------
-// Finds the end of the line
-// ---------------------------------------------------------------------------
-//
-TInt CDunAtCmdHandler::FindEndOfLine( TInt aStartIndex )
- {
- FTRACE(FPrint( _L("CDunAtCmdHandler::FindEndOfLine()") ));
- TInt inputLength = iInput->Length();
- TInt foundIndex = inputLength;
- for ( TInt i=aStartIndex; i<inputLength; i++ )
- {
- TChar character = (*iInput)[i];
- // Checking for IsDelimiterCharacter() here needs more logic (a parser).
- // Just check with "IsEndOfLine()"
- if ( IsEndOfLine(character) )
- {
- foundIndex = i;
- break;
- }
- }
- FTRACE(FPrint( _L("CDunAtCmdHandler::FindEndOfLine() complete") ));
- return foundIndex;
- }
-
-// ---------------------------------------------------------------------------
-// Handles next subcommand from line buffer
-// ---------------------------------------------------------------------------
-//
-TBool CDunAtCmdHandler::HandleNextSubCommand()
- {
- FTRACE(FPrint( _L("CDunAtCmdHandler::HandleNextSubCommand()") ));
- if ( iHandleState != EDunStateAtCmdHandling )
- {
- FTRACE(FPrint( _L("CDunAtCmdHandler::HandleNextSubCommand() (not ready) complete") ));
- return EFalse;
- }
- TBool extracted = ExtractNextSubCommand();
- if ( !extracted )
- {
- ManageEndOfCmdHandling( ETrue, ETrue );
- FTRACE(FPrint( _L("CDunAtCmdHandler::HandleNextSubCommand() (last) complete") ));
- return EFalse;
- }
- // Next convert the decoded AT command to uppercase
- // Don't check for case status -> let mixed cases pass
- TInt oldLength = iParseInfo.iSendBuffer.Length();
- iParseInfo.iSendBuffer.SetLength( iParseInfo.iLimit );
- iParseInfo.iSendBuffer.UpperCase();
- iParseInfo.iSendBuffer.SetLength( oldLength );
- // Next always send the command to ATEXT
- iCmdPusher->IssueRequest( iParseInfo.iSendBuffer );
- FTRACE(FPrint( _L("CDunAtCmdHandler::HandleNextSubCommand() complete") ));
- return ETrue;
- }
-
-// ---------------------------------------------------------------------------
-// Manages end of AT command handling
-// ---------------------------------------------------------------------------
-//
-void CDunAtCmdHandler::ManageEndOfCmdHandling( TBool aNotifyLocal,
- TBool aNotifyExternal )
- {
- FTRACE(FPrint( _L("CDunAtCmdHandler::ManageEndOfCmdHandling()") ));
- FTRACE(FPrint( _L("CDunAtCmdHandler::ManageEndOfCmdHandling() (loc=%d, ext=%d)"), aNotifyLocal, aNotifyExternal ));
- // If iEndIndex is (>=0 && <iInput.Length()) it means more data waits in
- // iInput that didn't fit in iInputBuffer.
- TInt cmdLength = iInput->Length();
- TBool subBlock = ( iEndIndex>=0&&iEndIndex<cmdLength ) ? ETrue : EFalse;
- if ( iLineBuffer.Length()>0 && !subBlock )
- {
- // Line buffer set and no partial subblock, copy to lastbuffer
- iLastBuffer.Copy( iLineBuffer );
- }
- iLineBuffer.Zero();
- iDecodeInfo.iFirstDecode = ETrue;
- iDecodeInfo.iDecodeIndex = 0;
- iDecodeInfo.iPrevExists = EFalse;
- iParseInfo.iLimit = KErrNotFound;
- iParseInfo.iSendBuffer.Zero();
- iEditorModeInfo.iContentFound = EFalse;
- iHandleState = EDunStateIdle;
- if ( aNotifyLocal )
- {
- iCmdPusher->SetEndOfCmdLine();
- }
- // iEndIndex must not be reset to KErrNotFound only when
- // ExtractLineFromInputBuffer() found the next line
- // (when moreNeeded is EFalse)
- TBool resetIndex = ETrue;
- if ( aNotifyExternal )
- {
- TBool moreNeeded = ExtractLineFromInputBuffer();
- if ( moreNeeded )
- {
- iUpstream->NotifyParserNeedsMoreData();
- }
- else
- {
- // AppendBlockToInputBuffer() was able to fill with known end, handle next
- iHandleState = EDunStateAtCmdHandling;
- HandleNextSubCommand();
- resetIndex = EFalse;
- }
- }
- if ( resetIndex )
- {
- iEndIndex = KErrNotFound;
- }
- FTRACE(FPrint( _L("CDunAtCmdHandler::ManageEndOfCmdHandling() complete") ));
- }
-
-// ---------------------------------------------------------------------------
-// Extracts next subcommand from line buffer to send buffer
-// ---------------------------------------------------------------------------
-//
-TBool CDunAtCmdHandler::ExtractNextSubCommand( TBool aPeek )
- {
- FTRACE(FPrint( _L("CDunAtCmdHandler::ExtractNextSubCommand()") ));
- TDunDecodeInfo oldInfo = iDecodeInfo;
- iParseInfo.iLimit = KErrNotFound;
- iParseInfo.iSendBuffer.Zero();
- // Find start of subcommand from line buffer
- TInt startIndex = FindStartOfSubCommand();
- if ( startIndex < 0 )
- {
- RestoreOldDecodeInfo( aPeek, oldInfo );
- FTRACE(FPrint( _L("CDunAtCmdHandler::ExtractNextDecodedCommand() (no start) complete") ));
- return EFalse;
- }
- iDecodeInfo.iDecodeIndex = startIndex;
- TBool specialCmd = EFalse;
- TInt endIndex = KErrNotFound;
- specialCmd = CheckSpecialCommand( endIndex );
- if ( !specialCmd )
- {
- FindSubCommand( endIndex );
- }
- TInt lineLength = iLineBuffer.Length();
- TBool inStartLimits = ( startIndex >= 0 && startIndex < lineLength ) ? ETrue : EFalse;
- TBool inEndLimits = ( endIndex >= 0 && endIndex < lineLength ) ? ETrue : EFalse;
- if ( !inStartLimits || !inEndLimits )
- {
- RestoreOldDecodeInfo( aPeek, oldInfo );
- FTRACE(FPrint( _L("CDunAtCmdHandler::ExtractNextSubCommand() (no end) complete") ));
- return EFalse;
- }
- TInt cmdLength = endIndex - startIndex + 1;
- // If the limit was not already set then do it now
- if ( iParseInfo.iLimit < 0 )
- {
- iParseInfo.iLimit = cmdLength;
- }
- // Next create a new command
- if ( !iDecodeInfo.iFirstDecode )
- {
- _LIT( KAtPrefix, "AT" );
- iParseInfo.iSendBuffer.Append( KAtPrefix );
- if ( !specialCmd ) // Already added with CheckSpecialCommand()
- {
- iParseInfo.iLimit += 2; // Length of "AT"
- }
- // Note: The length of iDecodeBuffer is not exceeded here because "AT"
- // is added only for the second commands after that.
- }
- iParseInfo.iSendBuffer.Append( &iLineBuffer[startIndex], cmdLength );
- // Change settings for the next decode round
- iDecodeInfo.iFirstDecode = EFalse;
- iDecodeInfo.iDecodeIndex = endIndex + 1;
- RestoreOldDecodeInfo( aPeek, oldInfo );
- if ( !aPeek )
- {
- iDecodeInfo.iCmdsHandled++;
- FTRACE(FPrint( _L("CDunAtCmdHandler::ExtractNextSubCommand() (handled=%d)"), iDecodeInfo.iCmdsHandled ));
- }
- FTRACE(FPrint( _L("CDunAtCmdHandler::ExtractNextSubCommand() complete") ));
- return ETrue;
- }
-
-// ---------------------------------------------------------------------------
-// Finds the start of subcommand from line buffer
-// ---------------------------------------------------------------------------
-//
-TBool CDunAtCmdHandler::FindStartOfSubCommand()
- {
- FTRACE(FPrint( _L("CDunAtCmdHandler::FindStartOfSubCommand()") ));
- TInt i;
- TInt foundIndex = KErrNotFound;
- TInt lineLength = iLineBuffer.Length();
- for ( i=iDecodeInfo.iDecodeIndex; i<lineLength; i++ )
- {
- TChar character = iLineBuffer[i];
- if ( !IsDelimiterCharacter(character) )
- {
- foundIndex = i;
- break;
- }
- }
- FTRACE(FPrint( _L("CDunAtCmdHandler::FindStartOfSubCommand() complete") ));
- return foundIndex;
- }
-
-// ---------------------------------------------------------------------------
-// Restores old decode info. For ExtractNextDecodedCommand() when aPeeks is
-// ETrue.
-// ---------------------------------------------------------------------------
-//
-void CDunAtCmdHandler::RestoreOldDecodeInfo( TBool aPeek,
- TDunDecodeInfo& aOldInfo )
- {
- FTRACE(FPrint( _L("CDunAtCmdHandler::RestoreOldDecodeInfo()") ));
- if ( aPeek )
- {
- iEditorModeInfo.iPeekInfo = iDecodeInfo;
- iDecodeInfo = aOldInfo;
- }
- FTRACE(FPrint( _L("CDunAtCmdHandler::RestoreOldDecodeInfo() complete") ));
- }
-
-// ---------------------------------------------------------------------------
-// Tests for end of AT command line
-// ---------------------------------------------------------------------------
-//
-TBool CDunAtCmdHandler::IsEndOfLine( TChar& aCharacter )
- {
- FTRACE(FPrint( _L("CDunAtCmdHandler::IsEndOfCommand()") ));
- if ( aCharacter==iCarriageReturn || aCharacter==iLineFeed )
- {
- FTRACE(FPrint( _L("CDunAtCmdHandler::IsEndOfCommand() (found) complete") ));
- return ETrue;
- }
- FTRACE(FPrint( _L("CDunAtCmdHandler::IsEndOfCommand() (not found) complete") ));
- return EFalse;
- }
-
-// ---------------------------------------------------------------------------
-// Checks if character is delimiter character
-// ---------------------------------------------------------------------------
-//
-TBool CDunAtCmdHandler::IsDelimiterCharacter( TChar aCharacter )
- {
- FTRACE(FPrint( _L("CDunAtCmdHandler::IsDelimiterCharacter()") ));
- if ( aCharacter.IsSpace() || aCharacter==';' || aCharacter==0x00 )
- {
- FTRACE(FPrint( _L("CDunAtCmdHandler::IsDelimiterCharacter() complete") ));
- return ETrue;
- }
- FTRACE(FPrint( _L("CDunAtCmdHandler::IsDelimiterCharacter() (not delimiter) complete") ));
- return EFalse;
- }
-
-// ---------------------------------------------------------------------------
-// Checks if character is of extended group
-// ---------------------------------------------------------------------------
-//
-TBool CDunAtCmdHandler::IsExtendedCharacter( TChar aCharacter )
- {
- FTRACE(FPrint( _L("CDunAtCmdHandler::IsExtendedCharacter()") ));
- if ( aCharacter=='+' || aCharacter=='&' || aCharacter=='%' ||
- aCharacter=='\\' || aCharacter=='*' || aCharacter=='#' ||
- aCharacter=='$' || aCharacter=='^' )
- {
- FTRACE(FPrint( _L("CDunAtCmdHandler::IsExtendedCharacter() complete") ));
- return ETrue;
- }
- FTRACE(FPrint( _L("CDunAtCmdHandler::IsExtendedCharacter() (not extended) complete") ));
- return EFalse;
- }
-
-// ---------------------------------------------------------------------------
-// Checks special command
-// ---------------------------------------------------------------------------
-//
-TBool CDunAtCmdHandler::CheckSpecialCommand( TInt& aEndIndex )
- {
- FTRACE(FPrint( _L("CDunAtCmdHandler::CheckSpecialCommand()") ));
- TInt atPrefixLen = 0;
- TInt startIndex = iDecodeInfo.iDecodeIndex;
- TInt newLength = iLineBuffer.Length() - startIndex;
- TBuf8<KDunLineBufLength> upperBuf;
- if ( !iDecodeInfo.iFirstDecode )
- {
- // For cases such as "ATM1L3DT*99#" "DT" must have "AT"
- _LIT8( KAtPrefix, "AT" );
- upperBuf.Copy( KAtPrefix );
- atPrefixLen = 2; // "AT"
- newLength += atPrefixLen;
- }
- upperBuf.Append( &iLineBuffer[startIndex], newLength );
- upperBuf.UpperCase();
- TInt i;
- TInt count = iSpecials.Count();
- for ( i=0; i<count; i++ )
- {
- HBufC8* specialCmd = iSpecials[i];
- TInt specialLength = specialCmd->Length();
- if ( newLength < specialLength )
- {
- continue;
- }
- TInt origLength = newLength;
- if ( newLength > specialLength )
- {
- upperBuf.SetLength( specialLength );
- }
- TInt cmpResult = upperBuf.Compare( *specialCmd );
- upperBuf.SetLength( origLength );
- if ( cmpResult == 0 )
- {
- iParseInfo.iLimit = specialLength;
- aEndIndex = (origLength-1) + startIndex - atPrefixLen;
- FTRACE(FPrint( _L("CDunAtCmdHandler::CheckSpecialCommand() complete") ));
- return ETrue;
- }
- }
- FTRACE(FPrint( _L("CDunAtCmdHandler::CheckSpecialCommand() (not found) complete") ));
- return EFalse;
- }
-
-// ---------------------------------------------------------------------------
-// Saves character decode state for a found character
-// ---------------------------------------------------------------------------
-//
-void CDunAtCmdHandler::SaveFoundCharDecodeState( TChar aCharacter,
- TBool aAddSpecial )
- {
- FTRACE(FPrint( _L("CDunAtCmdHandler::SaveFoundCharDecodeState()") ));
- iDecodeInfo.iPrevExists = ETrue;
- iDecodeInfo.iPrevChar = aCharacter;
- if ( aAddSpecial )
- {
- iDecodeInfo.iSpecialFound =
- iAtSpecialCmdHandler->IsCompleteSubCommand( aCharacter );
- }
- FTRACE(FPrint( _L("CDunAtCmdHandler::SaveFoundCharDecodeState() complete") ));
- }
-
-// ---------------------------------------------------------------------------
-// Saves character decode state for a not found character
-// ---------------------------------------------------------------------------
-//
-void CDunAtCmdHandler::SaveNotFoundCharDecodeState()
- {
- FTRACE(FPrint( _L("CDunAtCmdHandler::SaveNotFoundCharDecodeState()") ));
- iDecodeInfo.iPrevExists = EFalse;
- // Note: don't set iAssignFound or iInQuotes here
- iDecodeInfo.iSpecialFound = EFalse;
- FTRACE(FPrint( _L("CDunAtCmdHandler::SaveNotFoundCharDecodeState() complete") ));
- }
-
-// ---------------------------------------------------------------------------
-// Find quotes within subcommands
-// ---------------------------------------------------------------------------
-//
-TBool CDunAtCmdHandler::FindSubCommandQuotes( TChar aCharacter,
- TInt aStartIndex,
- TInt& aEndIndex )
- {
- FTRACE(FPrint( _L("CDunAtCmdHandler::FindSubCommandQuotes()") ));
- if ( aCharacter == '"' )
- {
- if ( iParseInfo.iLimit < 0 ) // Only first the first '"'
- {
- iParseInfo.iLimit = aEndIndex - aStartIndex;
- }
- iDecodeInfo.iInQuotes ^= ETrue; // EFalse to ETrue or ETrue to EFalse
- SaveFoundCharDecodeState( aCharacter, EFalse );
- FTRACE(FPrint( _L("CDunAtCmdHandler::FindSubCommandQuotes() (quote) complete") ));
- return ETrue;
- }
- // The next ones are those that are not in quotes.
- // We still need to save the iParseInfo.iLimit and skip non-delimiter characters.
- if ( aCharacter == '=' )
- {
- if ( iParseInfo.iLimit < 0 ) // Only first the first '"'
- {
- iParseInfo.iLimit = aEndIndex - aStartIndex;
- }
- iDecodeInfo.iAssignFound = ETrue;
- SaveFoundCharDecodeState( aCharacter, EFalse );
- FTRACE(FPrint( _L("CDunAtCmdHandler::FindSubCommandQuotes() (equals) complete") ));
- return ETrue;
- }
- if ( iDecodeInfo.iInQuotes )
- {
- SaveNotFoundCharDecodeState();
- FTRACE(FPrint( _L("CDunAtCmdHandler::FindSubCommandQuotes() (in quotes) complete") ));
- return ETrue;
- }
- FTRACE(FPrint( _L("CDunAtCmdHandler::FindSubCommandQuotes() (not found) complete") ));
- return EFalse;
- }
-
-// ---------------------------------------------------------------------------
-// Check if in next subcommand's extended border
-// ---------------------------------------------------------------------------
-//
-TBool CDunAtCmdHandler::IsExtendedBorder( TChar aCharacter,
- TInt aStartIndex,
- TInt& aEndIndex )
- {
- FTRACE(FPrint( _L("CDunAtCmdHandler::IsExtendedBorder()") ));
- TInt expectedIndex = 0; // "+CMD" when iDecodeInfo.iFirstDecode is EFalse
- TInt extendedIndex = aEndIndex - aStartIndex; // absolute index to the extended character
- if ( iDecodeInfo.iFirstDecode )
- {
- expectedIndex = 2; // "AT+CMD"
- }
- if ( extendedIndex == expectedIndex )
- {
- iDecodeInfo.iExtendedIndex = aEndIndex;
- SaveFoundCharDecodeState( aCharacter );
- FTRACE(FPrint( _L("CDunAtCmdHandler::IsExtendedBorder() (no border normal) complete") ));
- return EFalse;
- }
- // Now suspect border found so peek the next character after the suspected
- // extended character. If it is not alphabetical character, return with EFalse.
- // This case is to detect the cases such as "AT+VTS={*,3000}", where '*' would
- // be the start of the next command in normal cases.
- TInt peekIndex = aEndIndex + 1;
- TInt lineLength = iLineBuffer.Length();
- if ( peekIndex < lineLength )
- {
- TChar nextCharacter = iLineBuffer[peekIndex];
- if ( !nextCharacter.IsAlpha() )
- {
- SaveFoundCharDecodeState( aCharacter );
- FTRACE(FPrint( _L("CDunAtCmdHandler::IsExtendedBorder() (no border special) complete") ));
- return EFalse;
- }
- }
- aEndIndex--;
- FTRACE(FPrint( _L("CDunAtCmdHandler::IsExtendedBorder() (border) complete") ));
- return ETrue;
- }
-
-// ---------------------------------------------------------------------------
-// Finds subcommand with alphanumeric borders
-// ---------------------------------------------------------------------------
-//
-TBool CDunAtCmdHandler::FindSubCommandAlphaBorder( TChar aCharacter,
- TInt& aEndIndex )
- {
- FTRACE(FPrint( _L("CDunAtCmdHandler::FindSubCommandAlphaBorder()") ));
- if ( iDecodeInfo.iAssignFound && !iDecodeInfo.iInQuotes )
- {
- // Check the special case when assigning a number with "basic" command
- // and there is no delimiter after it. In this case <Numeric>|<Alpha>
- // border must be detected but only for a "basic" command, not for
- // extended.
- if ( iDecodeInfo.iExtendedIndex<0 && iDecodeInfo.iPrevExists &&
- iDecodeInfo.iPrevChar.IsDigit() && aCharacter.IsAlpha() )
- {
- aEndIndex--;
- FTRACE(FPrint( _L("CDunAtCmdHandler::FindSubCommandAlphaBorder() (N|A) complete") ));
- return ETrue;
- }
- // The code below is for the following type of cases:
- // (do not check alphanumeric borders if "=" set without quotes):
- // AT+CMD=a
- FTRACE(FPrint( _L("CDunAtCmdHandler::FindSubCommandAlphaBorder() (skip) complete") ));
- return EFalse;
- }
- if ( !iDecodeInfo.iPrevExists || !aCharacter.IsAlpha() )
- {
- FTRACE(FPrint( _L("CDunAtCmdHandler::FindSubCommandAlphaBorder() (not found) complete") ));
- return EFalse;
- }
- if ( iDecodeInfo.iPrevChar.IsAlpha() )
- {
- // The check below detects the following type of cases
- // (note that special handling is needed to separate the Alpha|Alpha boundary):
- // AT&FE0
- if ( iDecodeInfo.iSpecialFound )
- {
- // Special command was found before and this is Alpha|Alpha boundary -> end
- aEndIndex--;
- FTRACE(FPrint( _L("CDunAtCmdHandler::FindSubCommandAlphaBorder() (special) complete") ));
- return ETrue;
- }
- // The code below is for the following type of cases
- // (note there is no border between C|M, for example -> continue):
- // ATCMD
- FTRACE(FPrint( _L("CDunAtCmdHandler::FindSubCommandAlphaBorder() (continue) complete") ));
- return EFalse;
- }
- // The code below is for skipping the following type of cases:
- // AT+CMD [the '+' must be skipped]
- if ( aEndIndex-1 == iDecodeInfo.iExtendedIndex )
- {
- FTRACE(FPrint( _L("CDunAtCmdHandler::FindSubCommandAlphaBorder() (extended) complete") ));
- return EFalse;
- }
- // The code below is for the following type of cases:
- // ATCMD?ATCMD
- FTRACE(FPrint( _L("CDunAtCmdHandler::FindSubCommandAlphaBorder() (boundary) complete") ));
- aEndIndex--;
- return ETrue;
- }
-
-// ---------------------------------------------------------------------------
-// Finds subcommand
-// ---------------------------------------------------------------------------
-//
-TInt CDunAtCmdHandler::FindSubCommand( TInt& aEndIndex )
- {
- FTRACE(FPrint( _L("CDunAtCmdHandler::FindSubCommand()") ));
- TInt startIndex = iDecodeInfo.iDecodeIndex;
- aEndIndex = startIndex;
- TBool found = EFalse;
- TInt lineLength = iLineBuffer.Length();
- iDecodeInfo.iAssignFound = EFalse;
- iDecodeInfo.iInQuotes = EFalse;
- iDecodeInfo.iExtendedIndex = KErrNotFound;
- SaveNotFoundCharDecodeState();
- iAtSpecialCmdHandler->ResetComparisonBuffer(); // just to be sure
- for ( ; aEndIndex<lineLength; aEndIndex++ )
- {
- TChar character = iLineBuffer[aEndIndex];
- found = FindSubCommandQuotes( character, startIndex, aEndIndex );
- if ( found )
- {
- continue;
- }
- if ( character == '?' )
- {
- FTRACE(FPrint( _L("CDunAtCmdHandler::FindSubCommand() (?) complete") ));
- return KErrNone;
- }
- // The check below detects the following type of cases:
- // ATCMD<delimiter>
- if ( IsDelimiterCharacter(character) )
- {
- aEndIndex--;
- FTRACE(FPrint( _L("CDunAtCmdHandler::FindSubCommand() (delimiter) complete") ));
- return KErrNone;
- }
- // The check below detects the following type of cases:
- // ATCMD+CMD [first + as delimiter]
- // AT+CMD+CMD [second + as delimiter]
- if ( IsExtendedCharacter(character) )
- {
- found = IsExtendedBorder( character, startIndex, aEndIndex );
- if ( !found )
- {
- continue;
- }
- FTRACE(FPrint( _L("CDunAtCmdHandler::FindSubCommand() (extended) complete") ));
- return KErrNone;
- }
- found = FindSubCommandAlphaBorder( character, aEndIndex );
- if ( found )
- {
- FTRACE(FPrint( _L("CDunAtCmdHandler::FindSubCommand() (alpha sub) complete") ));
- return KErrNone;
- }
- SaveFoundCharDecodeState( character );
- }
- aEndIndex--;
- FTRACE(FPrint( _L("CDunAtCmdHandler::FindSubCommand() (not found) complete") ));
- return KErrNotFound;
- }
-
-// ---------------------------------------------------------------------------
-// Check if "A/" command
-// ---------------------------------------------------------------------------
-//
-TBool CDunAtCmdHandler::IsASlashCommand()
- {
- FTRACE(FPrint( _L("CDunAtCmdHandler::IsASlashCommand()") ));
- if ( iLineBuffer.Length() == 2 )
- {
- if ( iLineBuffer[1] == '/' &&
- (iLineBuffer[0] == 'A' || iLineBuffer[0] == 'a') )
- {
- FTRACE(FPrint( _L("CDunAtCmdHandler::IsASlashCommand() (found) complete") ));
- return ETrue;
- }
- }
- FTRACE(FPrint( _L("CDunAtCmdHandler::IsASlashCommand() (not found) complete") ));
- return EFalse;
- }
-
-// ---------------------------------------------------------------------------
-// Handles "A/" command
-// ---------------------------------------------------------------------------
-//
-TBool CDunAtCmdHandler::HandleASlashCommand()
- {
- FTRACE(FPrint( _L("CDunAtCmdHandler::HandleASlashCommand()") ));
- // If not "A/" command, return
- if ( !IsASlashCommand() )
- {
- FTRACE(FPrint( _L("CDunAtCmdHandler::HandleASlashCommand() (no push) complete") ));
- return EFalse;
- }
- iEndIndex = iInput->Length(); // Causes skipping of last '/' in ManageEndOfCmdHandling()
- // If "A/" command and last buffer exist, set the last buffer as the current buffer
- if ( iLastBuffer.Length() > 0 )
- {
- iLineBuffer.Copy( iLastBuffer );
- FTRACE(FPrint( _L("CDunAtCmdHandler::HandleASlashCommand() (copy) complete") ));
- return EFalse;
- }
- // Last buffer not set so return "ERROR"
- iDownstream->NotifyDataPushRequest( &iErrorBuffer, NULL );
- FTRACE(FPrint( _L("CDunAtCmdHandler::HandleASlashCommand() complete") ));
- return ETrue;
- }
-
-// ---------------------------------------------------------------------------
-// Manages command mode change
-// ---------------------------------------------------------------------------
-//
-TBool CDunAtCmdHandler::ManageCommandModeChange( TUint aMode )
- {
- FTRACE(FPrint( _L("CDunAtCmdHandler::ManageCommandModeChange()" ) ));
- if ( aMode & KCommandModeChanged )
- {
- if ( aMode & KModeCommand ) // command mode ON
- {
- ReportCommandModeChange( ETrue );
- FTRACE(FPrint( _L("CDunAtCmdHandler::ManageCommandModeChange() command mode changed ON" ) ));
- }
- else // command mode OFF
- {
- ReportCommandModeChange( EFalse );
- FTRACE(FPrint( _L("CDunAtCmdHandler::ManageCommandModeChange() command mode changed OFF" ) ));
- }
- FTRACE(FPrint( _L("CDunAtCmdHandler::ManageCommandModeChange() (change) complete" ) ));
- return ETrue;
- }
- FTRACE(FPrint( _L("CDunAtCmdHandler::ManageCommandModeChange()" ) ));
- return EFalse;
- }
-
-// ---------------------------------------------------------------------------
-// Reports command mode start/end change
-// ---------------------------------------------------------------------------
-//
-void CDunAtCmdHandler::ReportCommandModeChange( TBool aStart )
- {
- FTRACE(FPrint( _L("CDunAtCmdHandler::ReportCommandModeChange()" ) ));
- TInt i;
- TInt count = iCmdCallbacks.Count();
- if ( aStart )
- {
- if ( iDataMode )
- {
- for ( i=0; i<count; i++ )
- {
- iCmdCallbacks[i]->NotifyCommandModeStart();
- }
- iDataMode = EFalse;
- }
- }
- else // end
- {
- if ( !iDataMode )
- {
- for ( i=0; i<count; i++ )
- {
- iCmdCallbacks[i]->NotifyCommandModeEnd();
- }
- iDataMode = ETrue;
- }
- }
- FTRACE(FPrint( _L("CDunAtCmdHandler::ReportCommandModeChange() complete" ) ));
- }
-
-// ---------------------------------------------------------------------------
-// Manages echo mode change
-// ---------------------------------------------------------------------------
-//
-TBool CDunAtCmdHandler::ManageEchoModeChange( TUint aMode )
- {
- FTRACE(FPrint( _L("CDunAtCmdHandler::ManageEchoModeChange()" ) ));
- if ( aMode & KEchoModeChanged )
- {
- FTRACE(FPrint( _L("CDunAtCmdHandler::ManageEchoModeChange() checking echo mode..." ) ));
- if ( aMode & KModeEcho ) // echo mode ON
- {
- iEchoOn = ETrue;
- FTRACE(FPrint( _L("CDunAtCmdHandler::ManageEchoModeChange() echo mode changed ON" ) ));
- }
- else // echo mode OFF
- {
- iEchoOn = EFalse;
- FTRACE(FPrint( _L("CDunAtCmdHandler::ManageEchoModeChange() echo mode changed OFF" ) ));
- }
- FTRACE(FPrint( _L("CDunAtCmdHandler::ManageEchoModeChange() (change) complete" ) ));
- return ETrue;
- }
- FTRACE(FPrint( _L("CDunAtCmdHandler::ManageEchoModeChange() complete" ) ));
- return EFalse;
- }
-
-// ---------------------------------------------------------------------------
-// Manages quiet mode change
-// ---------------------------------------------------------------------------
-//
-TBool CDunAtCmdHandler::ManageQuietModeChange( TUint aMode )
- {
- FTRACE(FPrint( _L("CDunAtCmdHandler::ManageQuietModeChange()" ) ));
- if ( aMode & KQuietModeChanged )
- {
- FTRACE(FPrint( _L("CDunAtCmdHandler::ManageEchoModeChange() checking quiet mode..." ) ));
- if ( aMode & KModeQuiet ) // quiet mode ON
- {
- iAtCmdExt.ReportQuietModeChange( ETrue );
- iQuietOn = ETrue;
- FTRACE(FPrint( _L("CDunAtCmdHandler::ManageQuietModeChange() quiet mode changed ON" ) ));
- }
- else // quiet mode OFF
- {
- iAtCmdExt.ReportQuietModeChange( EFalse );
- iQuietOn = EFalse;
- FTRACE(FPrint( _L("CDunAtCmdHandler::ManageQuietModeChange() quiet mode changed OFF" ) ));
- }
- FTRACE(FPrint( _L("CDunAtCmdHandler::ManageQuietModeChange() (change) complete" ) ));
- return ETrue;
- }
- FTRACE(FPrint( _L("CDunAtCmdHandler::ManageQuietModeChange() complete" ) ));
- return EFalse;
- }
-
-// ---------------------------------------------------------------------------
-// Manages quiet mode change
-// ---------------------------------------------------------------------------
-//
-TBool CDunAtCmdHandler::ManageVerboseModeChange( TUint aMode )
- {
- FTRACE(FPrint( _L("CDunAtCmdHandler::ManageVerboseModeChange()" ) ));
- if ( aMode & KVerboseModeChanged )
- {
- FTRACE(FPrint( _L("CDunAtCmdHandler::ManageVerboseModeChange() checking verbose mode..." ) ));
- if ( aMode & KModeVerbose ) // verbose mode ON
- {
- iAtCmdExt.ReportVerboseModeChange( ETrue );
- iVerboseOn = ETrue;
- FTRACE(FPrint( _L("CDunAtCmdHandler::NotifyVerboseStatusChange() verbose mode changed ON" ) ));
- }
- else // verbose mode OFF
- {
- iAtCmdExt.ReportVerboseModeChange( EFalse );
- iVerboseOn = EFalse;
- FTRACE(FPrint( _L("CDunAtCmdHandler::NotifyVerboseStatusChange() verbose mode changed OFF" ) ));
- }
- FTRACE(FPrint( _L("CDunAtCmdHandler::ManageVerboseModeChange() (change) complete" ) ));
- return ETrue;
- }
- FTRACE(FPrint( _L("CDunAtCmdHandler::ManageVerboseModeChange() complete" ) ));
- return EFalse;
- }
-
-// ---------------------------------------------------------------------------
-// Manages character change
-// ---------------------------------------------------------------------------
-//
-void CDunAtCmdHandler::ManageCharacterChange( TUint aMode )
- {
- FTRACE(FPrint( _L("CDunAtCmdHandler::ManageCharacterChange()" ) ));
- if ( aMode & KCarriageChanged )
- {
- iCarriageReturn = aMode & (KModeChanged-1);
- iAtCmdExt.ReportCharacterChange( ECharTypeCarriage, iCarriageReturn );
- FTRACE(FPrint( _L("CDunAtCmdHandler::ManageCharacterChange() carriage return changed" ) ));
- }
- else if ( aMode & KLineFeedChanged )
- {
- iLineFeed = aMode & (KModeChanged-1);
- iAtCmdExt.ReportCharacterChange( ECharTypeLineFeed, iLineFeed );
- FTRACE(FPrint( _L("CDunAtCmdHandler::ManageCharacterChange() line feed changed" ) ));
- }
- else if ( aMode & KBackspaceChanged )
- {
- iBackspace = aMode & (KModeChanged-1);
- iAtCmdExt.ReportCharacterChange( ECharTypeBackspace, iBackspace );
- FTRACE(FPrint( _L("CDunAtCmdHandler::ManageCharacterChange() backspace changed" ) ));
- }
- FTRACE(FPrint( _L("CDunAtCmdHandler::ManageCharacterChange() complete" ) ));
- }
-
-// ---------------------------------------------------------------------------
-// Manages editor mode reply
-// ---------------------------------------------------------------------------
-//
-TInt CDunAtCmdHandler::ManageEditorModeReply( TBool aStart )
- {
- FTRACE(FPrint( _L("CDunAtCmdHandler::ManageEditorModeReply()" ) ));
- // Two modes possible here:
- // 1) Sending data directly from DTE to DCE, i.e. no subsequent data in
- // the input buffer -> Reissue read request from DTE.
- // 2) Sending data from input buffer to DCE -> Do not reissue read request
- // from DTE: send the data in a loop
- // In summary: send data byte-by-byte in editor mode until end of input.
- // When end of input notify CDunUpstream to reissue the read request.
- TBool nextContentFound = FindNextContent( aStart );
- if ( !nextContentFound )
- {
- iUpstream->NotifyEditorModeReply( aStart );
- FTRACE(FPrint( _L("CDunAtCmdHandler::ManageEditorModeReply() complete") ));
- return KErrNone;
- }
- // In block mode end the block mode by sending <ESC> and hope it works.
- iEscapeBuffer.Zero();
- iEscapeBuffer.Append( KDunEscape );
- iCmdPusher->IssueRequest( iEscapeBuffer, EFalse );
- FTRACE(FPrint( _L("CDunAtCmdHandler::ManageEditorModeReply() complete" ) ));
- return KErrNone;
- }
-
-// ---------------------------------------------------------------------------
-// Finds the next content from the input data
-// ---------------------------------------------------------------------------
-//
-TBool CDunAtCmdHandler::FindNextContent( TBool aStart )
- {
- FTRACE(FPrint( _L("CDunAtCmdHandler::FindNextContent()" ) ));
- if ( !aStart )
- {
- FTRACE(FPrint( _L("CDunAtCmdHandler::FindNextContent() (skip) complete" ) ));
- return iEditorModeInfo.iContentFound;
- }
- // If iEndIndex is (>=0 && <iInput.Length()) it means more data waits in
- // iInput that didn't fit in iInputBuffer. Only check FindStartOfCommand()
- // if iEndIndex < 0, meaning more data is needed from CDunUpstream.
- TBool contentFound = EFalse;
- TInt cmdLength = iInput->Length();
- TBool subBlock = ( iEndIndex>=0&&iEndIndex<cmdLength ) ? ETrue : EFalse;
- if ( subBlock )
- {
- contentFound = ETrue;
- }
- if ( !contentFound )
- {
- contentFound = ExtractNextSubCommand( ETrue ); // peek
- }
- iEditorModeInfo.iContentFound = contentFound;
- FTRACE(FPrint( _L("CDunAtCmdHandler::FindNextContent() complete" ) ));
- return contentFound;
- }
-
-// ---------------------------------------------------------------------------
-// From class MDunAtCmdPusher.
-// Notifies about end of AT command processing. This is after all reply data
-// for an AT command is multiplexed to the downstream.
-// ---------------------------------------------------------------------------
-//
-TInt CDunAtCmdHandler::NotifyEndOfProcessing( TInt /*aError*/ )
- {
- FTRACE(FPrint( _L("CDunAtCmdHandler::NotifyEndOfProcessing()" ) ));
- TBool editorMode = iCmdPusher->EditorMode();
- if ( editorMode )
- {
- ManageEditorModeReply( ETrue );
- FTRACE(FPrint( _L("CDunAtCmdHandler::NotifyEndOfProcessing() (editor) complete" ) ));
- return KErrNone;
- }
- HandleNextSubCommand();
- FTRACE(FPrint( _L("CDunAtCmdHandler::NotifyEndOfProcessing() complete" ) ));
- return KErrNone;
- }
-
-// ---------------------------------------------------------------------------
-// From class MDunAtCmdPusher.
-// Notifies about request to stop AT command handling for the rest of the
-// command line data
-// ---------------------------------------------------------------------------
-//
-void CDunAtCmdHandler::NotifyEndOfCmdLineProcessing()
- {
- FTRACE(FPrint( _L("CDunAtCmdHandler::NotifyEndOfCmdLineProcessing()" ) ));
- ManageEndOfCmdHandling( ETrue, ETrue );
- FTRACE(FPrint( _L("CDunAtCmdHandler::NotifyEndOfCmdLineProcessing() complete" ) ));
- }
-
-// ---------------------------------------------------------------------------
-// From class MDunAtCmdPusher.
-// Notifies about request to peek for the next command
-// ---------------------------------------------------------------------------
-//
-TBool CDunAtCmdHandler::NotifyNextCommandPeekRequest()
- {
- FTRACE(FPrint( _L("CDunAtCmdHandler::NotifyNextCommandPeekRequest()") ));
- TBool extracted = ExtractNextSubCommand( ETrue );
- FTRACE(FPrint( _L("CDunAtCmdHandler::NotifyNextCommandPeekRequest() complete") ));
- return extracted;
- }
-
-// ---------------------------------------------------------------------------
-// From class MDunAtCmdPusher.
-// Notifies about editor mode reply
-// ---------------------------------------------------------------------------
-//
-TInt CDunAtCmdHandler::NotifyEditorModeReply()
- {
- FTRACE(FPrint( _L("CDunAtCmdHandler::NotifyEditorModeReply()") ));
- TInt retVal = ManageEditorModeReply( EFalse );
- FTRACE(FPrint( _L("CDunAtCmdHandler::NotifyEditorModeReply() complete") ));
- return retVal;
- }
-
-// ---------------------------------------------------------------------------
-// From class MDunAtEcomListen.
-// Notifies about new plugin installation
-// ---------------------------------------------------------------------------
-//
-TInt CDunAtCmdHandler::NotifyPluginInstallation( TUid& /*aPluginUid*/ )
- {
- FTRACE(FPrint( _L("CDunAtCmdHandler::NotifyPluginInstallation()" ) ));
- CDunAtUrcHandler* urcHandler = NULL;
- TRAPD( retTrap, urcHandler=AddOneUrcHandlerL() );
- if ( retTrap != KErrNone )
- {
- FTRACE(FPrint( _L("CDunAtCmdHandler::NotifyPluginInstallation() (trapped!) complete" ) ));
- return retTrap;
- }
- TInt retTemp = urcHandler->IssueRequest();
- if ( retTemp != KErrNone )
- {
- FTRACE(FPrint( _L("CDunAtCmdHandler::NotifyPluginInstallation() (issuerequest) complete" ) ));
- return retTemp;
- }
- TUid ownerUid = urcHandler->OwnerUid();
- iAtCmdExt.ReportListenerUpdateReady( ownerUid, EEcomTypeInstall );
- // As a last step recreate the special command data
- retTemp = RecreateSpecialCommands();
- if ( retTemp != KErrNone )
- {
- FTRACE(FPrint( _L("CDunAtCmdHandler::NotifyPluginInstallation() (recreate) complete" ) ));
- return retTemp;
- }
- FTRACE(FPrint( _L("CDunAtCmdHandler::NotifyPluginInstallation() complete" ) ));
- return KErrNone;
- }
-
-// ---------------------------------------------------------------------------
-// From class MDunAtEcomListen.
-// Notifies about existing plugin uninstallation
-// ---------------------------------------------------------------------------
-//
-TInt CDunAtCmdHandler::NotifyPluginUninstallation( TUid& aPluginUid )
- {
- FTRACE(FPrint( _L("CDunAtCmdHandler::NotifyPluginUninstallation()" ) ));
- TInt i;
- TInt count = iUrcHandlers.Count();
- for ( i=count-1; i>=0; i-- )
- {
- TUid ownerUid = iUrcHandlers[i]->OwnerUid();
- if ( ownerUid == aPluginUid )
- {
- delete iUrcHandlers[i];
- iUrcHandlers.Remove( i );
- iAtCmdExt.ReportListenerUpdateReady( ownerUid,
- EEcomTypeUninstall );
- }
- }
- // As a last step recreate the special command data
- TInt retTemp = RecreateSpecialCommands();
- if ( retTemp != KErrNone )
- {
- FTRACE(FPrint( _L("CDunAtCmdHandler::NotifyPluginUninstallation() (recreate) complete" ) ));
- return retTemp;
- }
- FTRACE(FPrint( _L("CDunAtCmdHandler::NotifyPluginUninstallation() complete" ) ));
- return KErrNone;
- }
-
-// ---------------------------------------------------------------------------
-// From class MDunAtModeListen.
-// Gets called on mode status change
-// ---------------------------------------------------------------------------
-//
-TInt CDunAtCmdHandler::NotifyModeStatusChange( TUint aMode )
- {
- FTRACE(FPrint( _L("CDunAtCmdHandler::NotifyModeStatusChange()") ));
- TBool commandModeSet = ManageCommandModeChange( aMode );
- TBool echoModeSet = ManageEchoModeChange( aMode );
- TBool quietModeSet = ManageQuietModeChange( aMode );
- TBool verboseModeSet = ManageVerboseModeChange( aMode );
- if ( quietModeSet || verboseModeSet )
- {
- FTRACE(FPrint( _L("CDunAtCmdHandler::NotifyModeStatusChange() new settings: E=%d, Q=%d, V=%d"), iEchoOn, iQuietOn, iVerboseOn ));
- FTRACE(FPrint( _L("CDunAtCmdHandler::NotifyModeStatusChange() (regenerate) mode set" ) ));
- RegenerateReplyStrings();
- return KErrNone;
- }
- // Keep the following after "quietModeSet || verboseModeSet" in order to
- // regenerate the reply also if two modes change at the same time
- if ( commandModeSet || echoModeSet )
- {
- FTRACE(FPrint( _L("CDunAtCmdHandler::NotifyModeStatusChange() new settings: E=%d, Q=%d, V=%d"), iEchoOn, iQuietOn, iVerboseOn ));
- FTRACE(FPrint( _L("CDunAtCmdHandler::NotifyModeStatusChange() mode set" ) ));
- return KErrNone;
- }
- ManageCharacterChange( aMode );
- FTRACE(FPrint( _L("CDunAtCmdHandler::NotifyModeStatusChange() new settings: CR=%u, LF=%u, BS=%u"), iCarriageReturn, iLineFeed, iBackspace ));
- RegenerateReplyStrings();
- FTRACE(FPrint( _L("CDunAtCmdHandler::NotifyModeStatusChange() complete") ));
- return KErrNone;
- }