/*

* Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of "Eclipse Public License v1.0"

* which accompanies this distribution, and is available

* at the URL "http://www.eclipse.org/legal/epl-v10.html".

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description: Handles commands "ATL", "ATL0", "ATL1", "ATL2", "ATL3", "ATM",

*              "ATM0", "ATM1" and "ATM2"

*

*/

#include "monitorspeakerparser.h"

#include "debug.h"

_LIT8( KAtlCmd,  "ATL"  );

_LIT8( KAtl0Cmd, "ATL0" );

_LIT8( KAtl1Cmd, "ATL1" );

_LIT8( KAtl2Cmd, "ATL2" );

_LIT8( KAtl3Cmd, "ATL3" );

_LIT8( KAtmCmd,  "ATM"  );

_LIT8( KAtm0Cmd, "ATM0" );

_LIT8( KAtm1Cmd, "ATM1" );

_LIT8( KAtm2Cmd, "ATM2" );

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

// Two-phased constructor.

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

//

CMonitorSpeakerParser* CMonitorSpeakerParser::NewL(

    MLegacyModemPlugin* aCallback )

    {

    CMonitorSpeakerParser* self = new (ELeave) CMonitorSpeakerParser( aCallback );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// Destructor.

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

//

CMonitorSpeakerParser::~CMonitorSpeakerParser()

    {

    }

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

// CHfpExtParserMisc::CHfpExtParserMisc

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

//

CMonitorSpeakerParser::CMonitorSpeakerParser( MLegacyModemPlugin* aCallback ) :

    iCallback( aCallback )

    {

    iCmdHandlerType = ECmdHandlerTypeUndefined;

    iDetectedCmd = EDetectedCmdUndefined;

    }

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

// CHfpExtParserMisc::ConstructL

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

//

void CMonitorSpeakerParser::ConstructL()

    {

    if ( !iCallback )

        {

        User::Leave( KErrGeneral );

        }

    }

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

// Checks if the command is speaker loudness command

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

//

TBool CMonitorSpeakerParser::CheckSpeakerLoudnessCommand( const TDesC8& aCmd )

    {

    TRACE_FUNC_ENTRY

    // The ATL command only supports one type: base

    // The ATL0 command only supports one type: base

    // The ATL1 command only supports one type: base

    // The ATL2 command only supports one type: base

    // The ATL3 command only supports one type: base

    iCmdHandlerType = iCallback->CheckCommandType( KAtlCmd, aCmd );

    if ( iCmdHandlerType == ECmdHandlerTypeBase )

        {

        iDetectedCmd = EDetectedCmdATL;

        TRACE_FUNC_EXIT

        return ETrue;

        }

    iCmdHandlerType = iCallback->CheckCommandType( KAtl0Cmd, aCmd );

    if ( iCmdHandlerType == ECmdHandlerTypeBase )

        {

        iDetectedCmd = EDetectedCmdATL0;

        TRACE_FUNC_EXIT

        return ETrue;

        }

    iCmdHandlerType = iCallback->CheckCommandType( KAtl1Cmd, aCmd );

    if ( iCmdHandlerType == ECmdHandlerTypeBase )

        {

        iDetectedCmd = EDetectedCmdATL1;

        TRACE_FUNC_EXIT

        return ETrue;

        }

    iCmdHandlerType = iCallback->CheckCommandType( KAtl2Cmd, aCmd );

    if ( iCmdHandlerType == ECmdHandlerTypeBase )

        {

        iDetectedCmd = EDetectedCmdATL2;

        TRACE_FUNC_EXIT

        return ETrue;

        }

    iCmdHandlerType = iCallback->CheckCommandType( KAtl3Cmd, aCmd );

    if ( iCmdHandlerType == ECmdHandlerTypeBase )

        {

        iDetectedCmd = EDetectedCmdATL3;

        TRACE_FUNC_EXIT

        return ETrue;

        }

    TRACE_FUNC_EXIT

    return EFalse;

    }

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

// Checks if the command is speaker mode command

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

//

TBool CMonitorSpeakerParser::CheckSpeakerModeCommand( const TDesC8& aCmd )

    {

    TRACE_FUNC_ENTRY

    // The ATM command only supports one type: base

    // The ATM0 command only supports one type: base

    // The ATM1 command only supports one type: base

    // The ATM2 command only supports one type: base

    iCmdHandlerType = iCallback->CheckCommandType( KAtmCmd, aCmd );

    if ( iCmdHandlerType == ECmdHandlerTypeBase )

        {

        iDetectedCmd = EDetectedCmdATM;

        TRACE_FUNC_EXIT

        return ETrue;

        }

    iCmdHandlerType = iCallback->CheckCommandType( KAtm0Cmd, aCmd );

    if ( iCmdHandlerType == ECmdHandlerTypeBase )

        {

        iDetectedCmd = EDetectedCmdATM0;

        TRACE_FUNC_EXIT

        return ETrue;

        }

    iCmdHandlerType = iCallback->CheckCommandType( KAtm1Cmd, aCmd );

    if ( iCmdHandlerType == ECmdHandlerTypeBase )

        {

        iDetectedCmd = EDetectedCmdATM1;

        TRACE_FUNC_EXIT

        return ETrue;

        }

    iCmdHandlerType = iCallback->CheckCommandType( KAtm2Cmd, aCmd );

    if ( iCmdHandlerType == ECmdHandlerTypeBase )

        {

        iDetectedCmd = EDetectedCmdATM2;

        TRACE_FUNC_EXIT

        return ETrue;

        }

    TRACE_FUNC_EXIT

    return EFalse;

    }

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

// Main command handler (leaving version)

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

//

TBool CMonitorSpeakerParser::HandleCommandL()

    {

    TRACE_FUNC_ENTRY

    TBool cmdUnderstood = EFalse;

    // Just return "OK" for all detected commands

    if ( iDetectedCmd != EDetectedCmdUndefined )

        {

        iCallback->CreateReplyAndComplete( EReplyTypeOk );

        cmdUnderstood = ETrue;

        }

    TRACE_FUNC_EXIT

    return cmdUnderstood;

    }

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

// From CLegacyModemPluginBase.

// Reports the support status of an AT command. This is a synchronous API.

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

//

TBool CMonitorSpeakerParser::IsCommandSupported( const TDesC8& aCmd )

    {

    TRACE_FUNC_ENTRY

    TBool cmdUnderstood = EFalse;

    // Set all to undefined if either the command or its type is unknown

    // HandleCommand() should be round only when both are set

    cmdUnderstood = CheckSpeakerLoudnessCommand( aCmd );

    if ( cmdUnderstood )

        {

        TRACE_FUNC_EXIT

        return ETrue;

        }

    cmdUnderstood = CheckSpeakerModeCommand( aCmd );

    if ( cmdUnderstood )

        {

        TRACE_FUNC_EXIT

        return ETrue;

        }

    iCmdHandlerType = ECmdHandlerTypeUndefined;

    iDetectedCmd = EDetectedCmdUndefined;

    TRACE_FUNC_EXIT

    return EFalse;

    }

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

// From CLegacyModemPluginBase.

// Handles an AT command. Cancelling of the pending request is done by

// HandleCommandCancel(). The implementation in the extension plugin should

// be asynchronous.

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

//

void CMonitorSpeakerParser::HandleCommand( const TDesC8& /*aCmd*/,

                                           RBuf8& /*aReply*/,

                                           TBool aReplyNeeded )

    {

    TRACE_FUNC_ENTRY

    if ( !aReplyNeeded )

        {

        TRACE_FUNC_EXIT

        return;

        }

    // Checking the iDetectedCmd here means that the failure is the

    // failing cmd type (set/read/test) for the command, not the command

    // itself (when cmdUnderstood is EFalse)

    TBool cmdUnderstood = EFalse;

    TRAPD( retTrap, cmdUnderstood=HandleCommandL() )

    if ( !cmdUnderstood || retTrap!=KErrNone )

        {

        iCallback->CreateReplyAndComplete( EReplyTypeError );

        }

    TRACE_FUNC_EXIT

    }

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

// From CLegacyModemPluginBase.

// Cancels a pending HandleCommand request.

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

//

void CMonitorSpeakerParser::HandleCommandCancel()

    {

    TRACE_FUNC_ENTRY

    TRACE_FUNC_EXIT

    }