/*

* 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.

 */

/*

 * 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)

 */

#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;

    }

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

// Parses an AT command

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

//

EXPORT_C TInt CDunAtCmdHandler::ParseCommand( TDesC8& aCommand,

                                              TBool& aPartialInput )

    {

    FTRACE(FPrint( _L("CDunAtCmdHandler::ParseCommand()") ));

    FTRACE(FPrint( _L("CDunAtCmdHandler::ParseCommand() received:") ));

    FTRACE(FPrintRaw(aCommand) );

    TBool editorMode = iCmdPusher->EditorMode();

    if ( editorMode )

        {

        // Note: return here with "no partial input" and some error to fool

        // CDunUpstream into not reissuing the read request.

        iCmdPusher->IssueRequest( aCommand, EFalse );

        aPartialInput = EFalse;

        return KErrGeneral;

        }

    iCommand = &aCommand;  // iCommand only for normal mode

    // Manage partial AT command

    TBool needsCarriage = ETrue;

    TBool okToExit = ManagePartialCommand( aCommand, needsCarriage );

    if ( okToExit )

        {

        FTRACE(FPrint( _L("CDunAtCmdHandler::ParseCommand() (ok to exit) complete") ));

        aPartialInput = ETrue;

        return KErrNone;

        }

    if ( iHandleState != EDunStateIdle )

        {

        aPartialInput = EFalse;

        ResetParseBuffers();

        FTRACE(FPrint( _L("CDunAtCmdHandler::ParseCommand() (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.

        aPartialInput = ETrue;

        ResetParseBuffers();

        FTRACE(FPrint( _L("CDunAtCmdHandler::ParseCommand() (A/) complete") ));

        return KErrNone;

        }

    FTRACE(FPrint( _L("CDunAtCmdHandler::ParseCommand() received total:") ));

    FTRACE(FPrintRaw(iInputBuffer) );

    iHandleState = EDunStateAtCmdHandling;

    iUpstream->NotifyAtCmdHandlingStart();

    iDecodeInfo.iFirstDecode = ETrue;

    iDecodeInfo.iDecodeIndex = 0;

    HandleNextDecodedCommand();

    FTRACE(FPrint( _L("CDunAtCmdHandler::ParseCommand() complete") ));

    aPartialInput = 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;

    }

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

// Sets end of command line marker on for the possible series of AT commands.

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

//

EXPORT_C void CDunAtCmdHandler::SetEndOfCmdLine( TBool aClearInput )

    {

    FTRACE(FPrint( _L("CDunAtCmdHandler::SetEndOfCmdLine()") ));

    ManageEndOfCmdHandling( EFalse, ETrue, aClearInput );

    FTRACE(FPrint( _L("CDunAtCmdHandler::SetEndOfCmdLine() complete") ));

    }

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

// 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 HandleNextDecodedCommand() returns

    // without resetting the iInputBuffer because of the way it checks the

    // iHandleState.

    ManageEndOfCmdHandling( EFalse, ETrue, ETrue );

    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;

    iCommand = NULL;

    iDecodeInfo.iFirstDecode = ETrue;

    iDecodeInfo.iDecodeIndex = KErrNotFound;

    iDecodeInfo.iPrevChar = 0;

    iDecodeInfo.iPrevExists = EFalse;

    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 ( ;; )

        {

        retTemp = iAtCmdExt.GetNextSpecialCommand( iInputBuffer, firstSearch );

        if ( retTemp != KErrNone )

            {

            break;

            }

        HBufC8* specialCmd = HBufC8::NewMaxLC( iInputBuffer.Length() );

        TPtr8 specialCmdPtr = specialCmd->Des();

        specialCmdPtr.Copy( iInputBuffer );

        specialCmdPtr.UpperCase();

        iSpecials.AppendL( specialCmd );

        CleanupStack::Pop( specialCmd );

        }

    iInputBuffer.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()") ));

    iOkBuffer.Zero();

    if ( iQuietOn )

        {

        FTRACE(FPrint( _L("CDunAtCmdHandler::RegenerateOkReply() (quiet) complete") ));

        return ETrue;

        }

    if ( iVerboseOn )

        {

        _LIT8( KVerboseOk, "OK" );