/* 
 *
 * Copyright (c) <2010> Comarch S.A. and/or its subsidiary(-ies).
 * All rights reserved.
 * This component and the accompanying materials are made available
 * under the terms of the License "Eclipse Public License v1.0"
 * which accompanies this distribution, and is available
 * at the URL "http://www.eclipse.org/legal/epl-v10.html".
 *
 * Original Contributors:
 * Comarch S.A. - original contribution.
 *
 * Contributors:
 *
 * Description:
 *
 */
#include "hfpconnectionmanagement.h"
#include "hfpcommand.h"
#include "hfpsettings.h"
#include "debug.h"
_LIT8(KHsHFPParamValue0,"0");
_LIT8(KHsHFPParamValue1,"1");
_LIT8(KHsHFPParamValue3,"3");
_LIT8(KHsHFPParamValue16,"16");

CHsHFPConnectionManagement* CHsHFPConnectionManagement::NewL(
        MHsHFPFeatureProviderObserver* aObserver )
    {
    CHsHFPConnectionManagement* self = CHsHFPConnectionManagement::NewLC(
            aObserver );
    CleanupStack::Pop( self );
    return self;
    }

CHsHFPConnectionManagement* CHsHFPConnectionManagement::NewLC(
        MHsHFPFeatureProviderObserver* aObserver )
    {
    CHsHFPConnectionManagement* self =
            new ( ELeave ) CHsHFPConnectionManagement( aObserver );
    CleanupStack::PushL( self );
    self->ConstructL();
    return self;
    }

CHsHFPConnectionManagement::~CHsHFPConnectionManagement()
    {
    TRACE_FUNC_ENTRY
    if ( iSettings )
        {
        iSettings->Release();
        }
    TRACE_FUNC_EXIT
    }

TInt CHsHFPConnectionManagement::EstablishServiceLevelConnection(
        const CHsHFPCommand &aInputCmd, CHsHFPCommand &aOutputCmd )
    {
    TRACE_FUNC_ENTRY
    TInt res = KErrNone;
    switch ( iEstablishmentState )
        {
        case EHFPNotConnected:
            {
            if ( aInputCmd.Type() == EHFPCmdUnknown )//initialization
                {
                aOutputCmd.SetType( EHFPCmdBRSF );
                aOutputCmd.SetMode( ECmdModeWrite );
                RATParamArray params;
                params.Append( TATParam( KHsHFPParamValue16 ) );
                aOutputCmd.SetParams( params );
                iEstablishmentState = EHFPWaitingForBrsfAndOk;
                }
            else
                {
                res = KErrArgument;
                }
            break;
            }
        case EHFPWaitingForBrsfAndOk:
            {
            if ( aInputCmd.Type() == EHFPCmdBRSF )
                {
                iWaitingForOK = ETrue;
                }
            else if ( iWaitingForOK && aInputCmd.Type() == EHFPCmdOK )
                {
                iWaitingForOK = EFalse;
                aOutputCmd.SetType( EHFPCmdCIND );
                aOutputCmd.SetMode( ECmdModeTest );
                iEstablishmentState = EHFPWaitingForCindTestAndOk;
                }
            else
                {
                res = KErrArgument;
                }
            break;
            }
        case EHFPWaitingForCindTestAndOk:
            {
            if ( aInputCmd.Type() == EHFPCmdCIND )
                {
                TRAP( res, InitializeIndicatorsL( &aInputCmd ) );
                iWaitingForOK = ETrue;
                }
            else if ( iWaitingForOK && aInputCmd.Type() == EHFPCmdOK )
                {
                iWaitingForOK = EFalse;
                aOutputCmd.SetType( EHFPCmdCIND );
                aOutputCmd.SetMode( ECmdModeRead );
                iEstablishmentState = EHFPWaitingForCindReadAndOk;
                }
            else
                {
                res = KErrArgument;
                }
            break;
            }
        case EHFPWaitingForCindReadAndOk:
            {
            if ( aInputCmd.Type() == EHFPCmdCIND )
                {
                TRAP( res, SetupIndicatorsL( &aInputCmd ) );
                iWaitingForOK = ETrue;
                }
            else if ( iWaitingForOK && aInputCmd.Type() == EHFPCmdOK )
                {
                iWaitingForOK = EFalse;
                aOutputCmd.SetType( EHFPCmdCMER );
                aOutputCmd.SetMode( ECmdModeWrite );
                RATParamArray params;
                params.Append( TATParam( KHsHFPParamValue3 ) );
                params.Append( TATParam( KHsHFPParamValue0 ) );
                params.Append( TATParam( KHsHFPParamValue0 ) );
                params.Append( TATParam( KHsHFPParamValue1 ) );
                aOutputCmd.SetParams( params );
                iEstablishmentState = EHFPWaitingForOk;
                }
            else
                {
                res = KErrArgument;
                }
            break;
            }
        case EHFPWaitingForOk:
            {
            if ( aInputCmd.Type() == EHFPCmdOK )
                {
                iEstablishmentState = EHFPConnected;

                // Initialize volume level synchronization
                aOutputCmd.SetType( EHFPCmdVGS );
                aOutputCmd.SetMode( ECmdModeWrite );
                RATParamArray params;
                TBuf8 <KHsHFPMaxVolumeLevelParamSize> vgsLevel;
                vgsLevel.AppendNum( iSettings->iVgsLevel );
                params.Append( TATParam( vgsLevel ) );
                aOutputCmd.SetParams( params );

                iObserver->HandleProcedureCompleted( KErrNone );
                }
            else
                {
                res = KErrArgument;
                }
            break;
            }
        default:
            res = KErrArgument;
            break;
        }
    TRACE_FUNC_EXIT
    return res;
    }

void CHsHFPConnectionManagement::HandleServiceLevelConnectionRelease( TInt aErr )
    {
    TRACE_FUNC_ENTRY
    iEstablishmentState = EHFPNotConnected;
    iObserver->HandleProcedureCompleted( KErrNone );
    TRACE_FUNC_EXIT
    }

CHsHFPConnectionManagement::CHsHFPConnectionManagement(
        MHsHFPFeatureProviderObserver* aObserver ) :
    iObserver( aObserver )
    {
    }

void CHsHFPConnectionManagement::ConstructL()
    {
    TRACE_FUNC_ENTRY

    iSettings = CHsHFPSettings::InstanceL();
    TRACE_FUNC_EXIT
    }

void CHsHFPConnectionManagement::InitializeIndicatorsL(
        const CHsHFPCommand* aCommand )
    {
    TRACE_FUNC_ENTRY

    TInt params = aCommand->Params().Count();

    TChar end( '\"' );

    const TInt prefixLength = 2;
    const TInt suffixLength = 2;
    for ( TInt i = 0; i < params; i++ )
        {
        TInt pos = aCommand->Params()[i].Des().LocateReverse( end );

        if ( pos == KErrNotFound )
            {
            User::Leave( KErrArgument );
            }

        RBuf8 buf;
        buf.CreateL( aCommand->Params()[i].Des() );
        buf.CleanupClosePushL();

        buf.Delete( 0, prefixLength );

        buf.Delete( pos - suffixLength, buf.Length() - 1 );

        iSettings->iSettingsArr.AppendL( THsHFPIndicatorSetting( buf, 0 ) );
        CleanupStack::PopAndDestroy( &buf );

        }
    TRACE_FUNC_EXIT
    }

void CHsHFPConnectionManagement::SetupIndicatorsL(
        const CHsHFPCommand* aCommand )
    {
    TRACE_FUNC_ENTRY

    for ( TInt i = 0; i < aCommand->Params().Count(); i++ )
        {
        if ( iSettings->iSettingsArr.Count() > ( i + 1 ) )
            {
            iSettings->iSettingsArr[i + 1].SetValueL(
                    aCommand->Params()[i].Des() );
            TRACE_INFO( (_L8("INDICATOR: %S - value: %d "),
                            &iSettings->iSettingsArr[i + 1].Des(),
                            iSettings->iSettingsArr[i + 1].Int() ) );
            }
        }

    TRACE_FUNC_EXIT
    }