/*

* Copyright (c) 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 pusher for downstream

*

*/

/*

 * Filtering categories for multiple commands on one line (DunAtCmdPusher.cpp)

 * (here "OTHER" reply means a reply which is something else than "OK" and "ERROR")

 * One reply:     OK           -> OK

 * One reply:     OTHER        -> OTHER

 * One reply:     ERROR        -> ERROR

 * Two replies:   OK, OK       -> OK

 * Two replies:   OTHER, OTHER -> OTHER, OTHER

 * Two replies:   OK, OTHER    -> OTHER

 * Two replies:   OTHER, OK    -> OTHER

 * Two replies:   OK, ERROR    -> ERROR

 * Two replies:   OTHER, ERROR -> OTHER, ERROR

 * Note: "OK" replies are skipped. The "OK" string is stripped from the "OTHER"

 * replies and manually added the the downstream as the last operation if either

 * "OK" or "OTHER" was received before.

 */

#include "DunAtCmdPusher.h"

#include "DunDownstream.h"

#include "DunDebug.h"

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

// Two-phased constructor.

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

//

CDunAtCmdPusher* CDunAtCmdPusher::NewL(

    RATExt* aAtCmdExt,

    MDunAtCmdPusher* aCallback,

    MDunStreamManipulator* aDownstream,

    TDesC8* aOkBuffer )

    {

    CDunAtCmdPusher* self = NewLC( aAtCmdExt,

                                   aCallback,

                                   aDownstream,

                                   aOkBuffer );

    CleanupStack::Pop( self );

    return self;

    }

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

// Two-phased constructor.

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

//

CDunAtCmdPusher* CDunAtCmdPusher::NewLC(

    RATExt* aAtCmdExt,

    MDunAtCmdPusher* aCallback,

    MDunStreamManipulator* aDownstream,

    TDesC8* aOkBuffer )

    {

    CDunAtCmdPusher* self = new (ELeave) CDunAtCmdPusher( aAtCmdExt,

                                                          aCallback,

                                                          aDownstream,

                                                          aOkBuffer );

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

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

// Destructor.

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

//

CDunAtCmdPusher::~CDunAtCmdPusher()

    {

    FTRACE(FPrint( _L("CDunAtCmdPusher::~CDunAtCmdPusher()") ));

    ResetData();

    FTRACE(FPrint( _L("CDunAtCmdPusher::~CDunAtCmdPusher() complete") ));

    }

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

// Resets data to initial values

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

//

void CDunAtCmdPusher::ResetData()

    {

    FTRACE(FPrint( _L("CDunAtCmdPusher::ResetData()") ));

    // APIs affecting this:

    // IssueRequest()

    Stop();

    // Internal

    Initialize();

    FTRACE(FPrint( _L("CDunAtCmdPusher::ResetData() complete") ));

    }

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

// Starts AT command handling

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

//

TInt CDunAtCmdPusher::IssueRequest( TDesC8& aInput, TBool aNormalMode )

    {

    FTRACE(FPrint( _L("CDunAtCmdPusher::IssueRequest()") ));

    FTRACE(FPrint( _L("CDunAtCmdPusher::IssueRequest() send ATEXT:") ));

    FTRACE(FPrintRaw(aInput) );

    if ( iAtPushState!=EDunStateIdle && aNormalMode )

        {

        FTRACE(FPrint( _L("CDunAtCmdPusher::IssueRequest() (not ready) complete") ));

        return KErrNotReady;

        }

    if ( iDownstream->IsDataInQueue(&iRecvBuffer) )

        {

        FTRACE(FPrint( _L("CDunAtCmdPusher::IssueRequest() (in queue!) complete") ));

        return KErrGeneral;

        }

    iStatus = KRequestPending;

    iAtCmdExt->HandleCommand( iStatus,

                              aInput,

                              iRecvBuffer,

                              iReplyLeftPckg,

                              iReplyTypePckg );

    SetActive();

    iAtPushState = EDunStateAtCmdPushing;

    FTRACE(FPrint( _L("CDunAtCmdPusher::IssueRequest() complete") ));

    return KErrNone;

    }

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

// Stops AT command handling

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

//

TInt CDunAtCmdPusher::Stop()

    {

    FTRACE(FPrint( _L("CDunAtCmdPusher::Stop()") ));

    SetEndOfCmdLine();

    if ( iAtPushState != EDunStateAtCmdPushing )

        {

        FTRACE(FPrint( _L("CDunAtCmdHandler::Stop() (not ready) complete" )));

        return KErrNotReady;

        }

    // As the EDunStateAtCmdHandling can be set even when the actual request

    // has completed (when replying with NotifyDataPushComplete() and setting

    // idle eventually), cancel the actual operation in DoCancel()

    Cancel();

    iAtPushState = EDunStateIdle;

    FTRACE(FPrint( _L("CDunAtCmdPusher::Stop() complete") ));

    return KErrNone;

    }

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

// Manages request to abort command handling

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

//

TInt CDunAtCmdPusher::ManageAbortRequest()

    {

    FTRACE(FPrint( _L("CDunAtCmdPusher::ManageAbortRequest()") ));

    if ( iAtPushState != EDunStateAtCmdPushing )

        {

        FTRACE(FPrint( _L("CDunAtCmdHandler::ManageAbortRequest() (not ready) complete" )));

        return KErrNotReady;

        }

    if ( iCmdAbort )

        {

        FTRACE(FPrint( _L("CDunAtCmdPusher::ManageAbortRequest() (already exists) complete") ));

        return KErrAlreadyExists;

        }

    TInt retTemp = iAtCmdExt->ReportHandleCommandAbort( iStop );

    if ( retTemp != KErrNone )

        {

        FTRACE(FPrint( _L("CDunAtCmdPusher::ManageAbortRequest() (ERROR) complete") ));

        return retTemp;

        }

    iCmdAbort = ETrue;

    FTRACE(FPrint( _L("CDunAtCmdPusher::ManageAbortRequest() complete") ));

    return KErrNone;

    }

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

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

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

//

void CDunAtCmdPusher::SetEndOfCmdLine()

    {

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

    iNoErrorReceived = EFalse;

    iLastOkPush = EFalse;

    iCmdAbort = EFalse;

    iStop = EFalse;

    iEditorMode = EFalse;

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

    }

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

// Gets the editor mode status

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

//

TBool CDunAtCmdPusher::EditorMode()

    {

    FTRACE(FPrint( _L("CDunAtCmdPusher::EditorMode()") ));

    FTRACE(FPrint( _L("CDunAtCmdPusher::EditorMode() complete") ));

    return iEditorMode;

    }

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

// CDunAtCmdPusher::CDunAtCmdPusher

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

//

CDunAtCmdPusher::CDunAtCmdPusher( RATExt* aAtCmdExt,

                                  MDunAtCmdPusher* aCallback,

                                  MDunStreamManipulator* aDownstream,

                                  TDesC8* aOkBuffer ) :

    CActive( EPriorityHigh ),

    iAtCmdExt( aAtCmdExt ),

    iCallback( aCallback ),

    iDownstream( aDownstream ),

    iOkBuffer( aOkBuffer ),

    iReplyLeftPckg( iReplyBytesLeft ),

    iReplyTypePckg( iReplyType )

    {

    Initialize();

    }

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

// CDunAtCmdPusher::ConstructL

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

//

void CDunAtCmdPusher::ConstructL()

    {

    FTRACE(FPrint( _L("CDunAtCmdPusher::ConstructL()") ));

    if ( !iAtCmdExt || !iCallback || !iDownstream || !iOkBuffer )

        {

        User::Leave( KErrGeneral );

        }

    CActiveScheduler::Add( this );

    FTRACE(FPrint( _L("CDunAtCmdPusher::ConstructL() complete") ));

    }

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

// Initializes this class

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

//

void CDunAtCmdPusher::Initialize()

    {

    // Don't initialize iAtCmdExt here (it is set through NewL)

    // Don't initialize iCallback here (it is set through NewL)

    // Don't initialize iDownstream here (it is set through NewL)

    // Don't initialize iOkBuffer here (it is set through NewL)

    iAtPushState = EDunStateIdle;

    iReplyBytesLeft = 0;

    iReplyType = EReplyTypeUndefined;

    SetEndOfCmdLine();

    }

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

// Sets state to idle and notifies about subcommand handling completion

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

//

void CDunAtCmdPusher::SetToIdleAndNotifyEnd( TInt aError )

    {

    FTRACE(FPrint( _L("CDunAtCmdPusher::SetToIdleAndNotifyEnd()") ));

    iCmdAbort = EFalse;

    iAtPushState = EDunStateIdle;

    iCallback->NotifyEndOfProcessing( aError );

    FTRACE(FPrint( _L("CDunAtCmdPusher::SetToIdleAndNotifyEnd() complete") ));

    }

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

// Checks if "OK" (verbose) or "0" (numeric) string or exists at the end of

// buffer and removes it

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

//

TInt CDunAtCmdPusher::CheckAndRemoveOkString()

    {

    FTRACE(FPrint( _L("CDunAtCmdPusher::CheckAndRemoveOkString()") ));

    TInt recvBufferLength = iRecvBuffer.Length();

    TInt okBufferLength = iOkBuffer->Length();

    // Skip the removal if removing not possible, if removal results in zero

    // length (plugin should have used KErrReplyTypeOk) or if string to be

    // removed is zero.

    // Note also that if plugin sends a final reply when quiet mode is on, DUN

    // can't remove the possibly existing result code as it is different from

    // iOkReply (zero length).

    if ( recvBufferLength<=okBufferLength || okBufferLength<=0 )

        {

        FTRACE(FPrint( _L("CDunAtCmdPusher::CheckAndRemoveOkString() (skip) complete") ));

        return KErrGeneral;

        }

    TInt lengthWithNoOk = recvBufferLength - okBufferLength;

    TPtr8 recvBufferDes( &iRecvBuffer[lengthWithNoOk], okBufferLength, okBufferLength );

    if ( recvBufferDes.Compare(*iOkBuffer) != 0 )

        {

        FTRACE(FPrint( _L("CDunAtCmdPusher::CheckAndRemoveOkString() (not found) complete") ));

        return KErrNotFound;

        }

    iRecvBuffer.SetLength( lengthWithNoOk );

    FTRACE(FPrint( _L("CDunAtCmdPusher::CheckAndRemoveOkString() complete") ));

    return KErrNone;

    }

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

// Sends reply data to downstream

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

//

void CDunAtCmdPusher::SendReplyData( TBool aRecvBuffer )

    {

    FTRACE(FPrint( _L("CDunAtCmdPusher::SendReplyData()") ));

    TDesC8* sendBuffer = iOkBuffer;

    if ( aRecvBuffer )

        {

        sendBuffer = &iRecvBuffer;

        // Check if last block of long push and remove "OK" if exists

        if ( iReplyType==EReplyTypeOther && iReplyBytesLeft==0 )

            {

            CheckAndRemoveOkString();

            }

        }

    FTRACE(FPrint( _L("CDunAtCmdPusher::SendReplyData() send reply:") ));

    FTRACE(FPrintRaw(*sendBuffer) );

    iDownstream->NotifyDataPushRequest( sendBuffer, this );

    FTRACE(FPrint( _L("CDunAtCmdPusher::SendReplyData() complete") ));

    }

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

// Manages change in reply type to EReplyTypeOther

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

//

void CDunAtCmdPusher::ManageReplyTypeChangeToOther()

    {

    FTRACE(FPrint( _L("CDunAtCmdPusher::ManageReplyTypeChangeToOther()") ));

    iNoErrorReceived = ETrue;

    SendReplyData();

    FTRACE(FPrint( _L("CDunAtCmdPusher::ManageReplyTypeChangeToOther() complete") ));

    }

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

// Manages change in reply type to EReplyTypeOk

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

//

void CDunAtCmdPusher::ManageReplyTypeChangeToOk()

    {

    FTRACE(FPrint( _L("CDunAtCmdPusher::ManageReplyTypeChangeToOk()") ));

    // Skip the "OK" replies if not last. Only push the "OK" reply at the end.

    // iStop changes it so that the we have to send the "OK" immediately and

    // only stop with NotifyDataPushComplete()

    TBool found = iCallback->NotifyNextCommandPeekRequest();

    if ( !found || iStop )

        {

        SendReplyData();

        }

    else

        {

        iNoErrorReceived = ETrue;

        SetToIdleAndNotifyEnd( KErrNone );

        }

    FTRACE(FPrint( _L("CDunAtCmdPusher::ManageReplyTypeChangeToOk() complete") ));

    }

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

// Manages change in reply type to EReplyTypeError

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

//

void CDunAtCmdPusher::ManageReplyTypeChangeToError()

    {

    FTRACE(FPrint( _L("CDunAtCmdPusher::ManageReplyTypeChangeToError()") ));

    if ( iNoErrorReceived )

       {

       iAtCmdExt->ReportExternalHandleCommandError();

       }

    SendReplyData();

    FTRACE(FPrint( _L("CDunAtCmdPusher::ManageReplyTypeChangeToError() complete") ));

    }

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

// Manages change in reply type to EReplyTypeEditor

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

//

void CDunAtCmdPusher::ManageReplyTypeChangeToEditor()

    {

    FTRACE(FPrint( _L("CDunAtCmdPusher::ManageReplyTypeChangeToEditor()") ));

    if ( !iEditorMode )

        {

        // First change to editor mode: manage it as EReplyTypeOther (prompt)

        iEditorMode = ETrue;

        ManageReplyTypeChangeToOther();

        FTRACE(FPrint( _L("CDunAtCmdPusher::ManageReplyTypeChangeToEditor() (editor) complete") ));

        return;

        }

    // The same reply to editor mode as before: no reply, only notification for

    // echo/forwarding purposes

    iCallback->NotifyEditorModeReply();

    // Do nothing after notifying. The next ForwardEditorModeInput() triggers

    // the next call of this function.

    FTRACE(FPrint( _L("CDunAtCmdPusher::ManageReplyTypeChangeToEditor() complete") ));

    }

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

// Manages change in reply type

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

//

void CDunAtCmdPusher::ManageReplyTypeChange()

    {

    FTRACE(FPrint( _L("CDunAtCmdPusher::ManageReplyTypeChange()") ));

    switch ( iReplyType )

        {

        case EReplyTypeOther:

            {

            FTRACE(FPrint( _L("CDunAtCmdPusher::ManageReplyTypeChange() EReplyTypeOther") ));

            iEditorMode = EFalse;

            ManageReplyTypeChangeToOther();

            }

            break;

        case EReplyTypeOk:

            {

            FTRACE(FPrint( _L("CDunAtCmdPusher::ManageReplyTypeChange() EReplyTypeOk") ));

            iEditorMode = EFalse;

            ManageReplyTypeChangeToOk();

            }

            break;

        case EReplyTypeError:

            {

            FTRACE(FPrint( _L("CDunAtCmdPusher::ManageReplyTypeChange() EReplyTypeError") ));

            iEditorMode = EFalse;

            ManageReplyTypeChangeToError();

            }

            break;

        case EReplyTypeEditor:

            FTRACE(FPrint( _L("CDunAtCmdPusher::ManageReplyTypeChange() EReplyTypeEditor") ));

            ManageReplyTypeChangeToEditor();

            break;

        default:

            {

            FTRACE(FPrint( _L("CDunAtCmdPusher::ManageReplyTypeChange() EReplyTypeUndefined") ));

            iEditorMode = EFalse;

            SetToIdleAndNotifyEnd( KErrNone );

            }

            break;

        }

    FTRACE(FPrint( _L("CDunAtCmdPusher::ManageReplyTypeChange() complete") ));

    }

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

// From class CActive.

// Gets called when AT command handled

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

//

void CDunAtCmdPusher::RunL()

    {

    FTRACE(FPrint( _L("CDunAtCmdPusher::RunL()") ));

    TInt retTemp = iStatus.Int();

    if ( retTemp != KErrNone )

        {

        SetToIdleAndNotifyEnd( retTemp );

        FTRACE(FPrint( _L("CDunAtCmdPusher::RunL() (ERROR) complete (%d)"), retTemp));

        return;

        }

    ManageReplyTypeChange();

    FTRACE(FPrint( _L("CDunAtCmdPusher::RunL() complete") ));

    }

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

// From class CActive.

// Gets called on cancel

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

//

void CDunAtCmdPusher::DoCancel()

    {

    FTRACE(FPrint( _L("CDunAtCmdPusher::DoCancel()") ));

    iAtCmdExt->CancelHandleCommand();

    FTRACE(FPrint( _L("CDunAtCmdPusher::DoCancel() complete") ));

    }

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

// From class MDunCompletionReporter.

// Gets called when data push is complete

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

//

void CDunAtCmdPusher::NotifyDataPushComplete( TBool /*aAllPushed*/ )

    {

    FTRACE(FPrint( _L("CDunAtCmdPusher::NotifyDataPushComplete()") ));

    // First check if error or stop condition detected

    if ( iReplyType==EReplyTypeError || iStop )

        {

        SetEndOfCmdLine();

        iAtPushState = EDunStateIdle;

        iCallback->NotifyEndOfCmdLineProcessing();

        FTRACE(FPrint( _L("CDunAtCmdPusher::NotifyDataPushComplete() (error reply) complete") ));

        return;

        }

    // Secondly check only the case where push restart is required

    if ( iReplyType==EReplyTypeOther && iReplyBytesLeft>0 )

        {

        iAtCmdExt->GetNextPartOfReply( iRecvBuffer, iReplyBytesLeft );

        SendReplyData();

        FTRACE(FPrint( _L("CDunAtCmdPusher::NotifyDataPushComplete() (push restart) complete") ));

        return;

        }

    // Next check the case where other than "OK" and "ERROR" reply is received

    // and that is the last one in the command line. Then just send "OK".

    if ( !iLastOkPush && iReplyType==EReplyTypeOther )

        {

        TBool found = iCallback->NotifyNextCommandPeekRequest();

        if ( !found )

            {

            // Force iReplyType here to match the correct one in NotifyDataPushComplete()

            iReplyType = EReplyTypeOk;

            iLastOkPush = ETrue;

            SendReplyData( EFalse );

            FTRACE(FPrint( _L("CDunAtCmdPusher::NotifyDataPushComplete() (last OK) complete") ));

            return;

            }

        // Now the next command was found so just fall through

        }

    // As a last step just set to idle

    SetToIdleAndNotifyEnd( KErrNone );

    FTRACE(FPrint( _L("CDunAtCmdPusher::NotifyDataPushComplete() complete") ));

    }