/*

* Copyright (c) 2005 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:  

*

*/

#include "atcodec.h"

#include <mmtsy_names.h> // for etel

#include <bttypes.h>

#include <badesca.h>

#include "btmcprotocol.h"

#include "btmccallinghandler.h"

#include "btmcphonestatus.h"

#include "btmccallstatus.h"

#include "btmcprotocolstatus.h"

#include "btmcobserver.h"

#include "btmcmobileline.h"

#include "btmcnumber.h"

#include "btmcoperator.h"

#include "debug.h"

// Service Level Monitoring

const TInt KCmerFromHF = 0x01;

const TInt KCmerFromAG = 0x02;

const TInt KSLC_No3WayCalling = KCmerFromHF | KCmerFromAG;

const TInt KChldFromHF = 0x04;

const TInt KChldFromAG = 0x08;

const TInt KSLC_3WayCalling = KChldFromHF | KChldFromAG;

const TInt KBerUnknown = 99;

const TInt KServiceSlcTimer = 1;

const TInt KServiceGetSubscriber = 3;

const TInt KServiceGetOperator = 4;

const TInt KServiceCmdHandling = 5;

const TInt KQueryIMEI = 6;

const TInt KQueryIMSI = 7;

const TInt KServiceFirstHspCkpdTrap = 8;

CBtmcProtocol* CBtmcProtocol::NewL(

    MBtmcObserver& aObserver, TBtmcProfileId aProfile, const TDesC8& aBTDevAddr, TBool aAccessoryInitiated)

    {

    CBtmcProtocol* self=new (ELeave) CBtmcProtocol(aObserver);

    CleanupStack::PushL(self);

    self->ConstructL(aProfile, aBTDevAddr, aAccessoryInitiated);

    CleanupStack::Pop(self);

    return self;

    }

CBtmcProtocol::~CBtmcProtocol()

    {

    TRACE_FUNC_ENTRY

    delete iCallingHandler;

    delete iCmdHanldingActive;

    delete iAtExt;

    delete iTimerActive;

    iTimer.Close();

    delete iProtocolStatus;

    delete iCallStatus;

    delete iPhoneStatus;

    delete iNumber;

    delete iOperator;

    delete iEtelQuery;

    iPhone.Close();

    iServer.UnloadPhoneModule(KMmTsyModuleName);

    iServer.Close();

    delete iOutgoPacketQueue;

    TRACE_FUNC_EXIT

    }

void CBtmcProtocol::NewProtocolDataL(const TDesC8& aData)

    {

    TRACE_FUNC

    TInt err = iInDataBuf.Append(aData);

    if (err)

        {

        CATResult* nok = CATResult::NewLC(EATERROR);

        SendResponseL(*nok);

        CleanupStack::PopAndDestroy(nok);

        }

    else if (!iCmdHanldingActive->IsActive())

        {

        TRequestStatus* sta = &iCmdHanldingActive->iStatus;

        *sta = KRequestPending;

        User::RequestComplete(sta, KErrNone);

        iCmdHanldingActive->GoActive();

        }

    }

void CBtmcProtocol::SendResponseL(const CATResult& aResult)

    {

    TRACE_FUNC

    iOutgoPacketQueue->InsertL(0, aResult.Des());

    iCredit = iOutgoPacketQueue->MdcaCount();

    DoSendProtocolDataL();

    }

void CBtmcProtocol::SendResponseL(const RPointerArray<CATResult>& aResults)

    {

    TRACE_FUNC

    TInt count = aResults.Count();

    for (TInt i = 0; i < count; i++)

        {

        iOutgoPacketQueue->InsertL(i, aResults[i]->Des());

        }

    iCredit = iOutgoPacketQueue->MdcaCount();

    DoSendProtocolDataL();

    }

void CBtmcProtocol::SendUnsoltResultL(const CATResult& aResult)

    {

    TRACE_FUNC_ENTRY

    if (aResult.Id() == EATVGS)

        {

        iOutgoPacketQueue->InsertL(0, aResult.Des());

        iCredit++;

        }

    else

        {

        iOutgoPacketQueue->AppendL(aResult.Des());

        if (!iCallingHandler->ActiveCmdHandling() && !iHandleCmdPending)

            {

            iCredit++;

            }

        }

    DoSendProtocolDataL();

    TRACE_FUNC_EXIT

    }

void CBtmcProtocol::CmdHandlingCompletedL()

    {

    TRACE_FUNC

    iHandleCmdPending = EFalse;

    TRequestStatus* sta = &iCmdHanldingActive->iStatus;

    *sta = KRequestPending;

    User::RequestComplete(sta, KErrNone);

    iCmdHanldingActive->GoActive();

    }

TBtmcProtocolStatus& CBtmcProtocol::ProtocolStatus()

    {

    return *iProtocolStatus;

    }

void CBtmcProtocol::VoiceRecognitionError()

    {

    iPhoneStatus->SetRecognitionInitiator(EBTMonoVoiceRecognitionDefaultInitiator);

    }

void CBtmcProtocol::HandleNrecCompletedL(TInt aErr)

    {

    TATId id = aErr ? EATERROR : EATOK;

    CATResult* nok = CATResult::NewLC(id);

    SendResponseL(*nok);

    CleanupStack::PopAndDestroy(nok);

    CmdHandlingCompletedL();

    }

void CBtmcProtocol::ActivateRemoteVolumeControl()

    {

    TRACE_FUNC

    if (iPhoneStatus)

        iPhoneStatus->ActivateRemoteVolumeControl();

    else

        {

        TRACE_INFO(_L("WARNING, null vol handler!"))

        }

    }

void CBtmcProtocol::DeActivateRemoteVolumeControl()

    {

    TRACE_FUNC

    if (iPhoneStatus)

        iPhoneStatus->DeActivateRemoteVolumeControl();

    else

        {

        TRACE_INFO(_L("WARNING, null vol handler!"))

        }

    }

TInt CBtmcProtocol::GetRemoteSupportedFeature()

    {

    return iProtocolStatus->iAccSupportedFeature;

    }

TBool CBtmcProtocol::ActiveChldHandling() const

    {

    return iCallingHandler->ActiveChldHandling();

    }

void CBtmcProtocol::SetHspRvcSupported(TBool aSupported)

    {

    TRACE_FUNC

    // Only update the supported feature field if this

    // is for HSP controlling to avoid denial of

    // HFP service

    if ( iProtocolStatus->iProfile == EBtmcHSP )

        {

        if ( aSupported )

            {

            // volume control must be enabled now:

            if ( !iPhoneStatus)

                {

                TRAP_IGNORE( iPhoneStatus = 

                    CBtmcPhoneStatus::NewL(*this, iPhone, iProtocolStatus->iProfile) );

                }

            if ( iPhoneStatus )

                {

                // We just do the best effort. If enabling volume control fails,

                // other functionalities on the HSP will still work:

                TRAP_IGNORE( iPhoneStatus->SetVolumeControlFeatureL(ETrue) );

                }

            }

        else

            {

            // When this serves the controlling of a HSP connection, iPhoneStatus is only

            // used for volume control, deleting it will disable volume control:

            delete iPhoneStatus;

            iPhoneStatus = NULL;

            }

        }

    }

void CBtmcProtocol::RequestCompletedL(CBtmcActive& aActive, TInt aErr)

    {

    TRACE_FUNC_ENTRY

    switch (aActive.ServiceId())

        {

        case KServiceSlcTimer:

            {

            if (aErr == KErrNone)

                {

                StopTimer(KServiceSlcTimer);

                iObserver.SlcIndicateL(EFalse);

                }

            break;

            }

        case KServiceGetSubscriber:

            {

            delete iNumber;

            iNumber = NULL;

            CmdHandlingCompletedL();

            break;

            }

        case KServiceGetOperator:

            {

            delete iOperator;

            iOperator = NULL;

            CmdHandlingCompletedL();

            break;

            }

        case KServiceCmdHandling:

            {

            TRAPD(err, DoHandleCommandL());

            if (err)

                {

                CATResult* nok = CATResult::NewLC(EATERROR);

                SendResponseL(*nok);

                CleanupStack::PopAndDestroy(nok);

                CmdHandlingCompletedL();

                }

            break;

            }

       	case KQueryIMSI:

       		{

       		TBuf8<RMobilePhone::KIMSISize> buf;

       		buf.Copy(iId);

            CATResult* cimi = CATResult::NewLC(EATCIMI, EATReadResult, TATParam(buf));

            SendResponseL(*cimi);

	        CleanupStack::PopAndDestroy(cimi);

	        CATResult* ok = CATResult::NewLC(EATOK);

	        SendResponseL(*ok);

	        CleanupStack::PopAndDestroy(ok);

	        CmdHandlingCompletedL();      		

					break;

       		}

       	case KServiceFirstHspCkpdTrap:

       	    {

       	    // No handling here. From now on, any incoming CKPD command 

       	    // will be processed normally.

       	    TRACE_INFO((_L("CKPD trapper terminated")));

       	    break;

       	    }

        default:

            break;

        }

    TRACE_FUNC_EXIT

    }

void CBtmcProtocol::CancelRequest(TInt aServiceId)

    {

    TRACE_FUNC_ENTRY

    if (aServiceId == KServiceSlcTimer || aServiceId == KServiceFirstHspCkpdTrap )

        {

        iTimer.Cancel();

        }

    TRACE_FUNC_EXIT

    }

CBtmcProtocol::CBtmcProtocol(MBtmcObserver& aObserver)

    : iObserver(aObserver),

      iSlcMask(0x00)

    {

    }

void CBtmcProtocol::ConstructL(TBtmcProfileId aProfile, const TDesC8& aBTDevAddr, TBool aAccessoryInitiated)

    {

    TRACE_FUNC_ENTRY

    iProtocolStatus = new (ELeave) TBtmcProtocolStatus();

    iProtocolStatus->iProfile = aProfile;

    iAccessoryInitiated = aAccessoryInitiated;

    iProtocolStatus->iAGSupportedFeature = KBTAGSupportedFeatureV15;

    LEAVE_IF_ERROR(iServer.Connect())

    TInt err = iServer.LoadPhoneModule(KMmTsyModuleName);

    if (err != KErrNone && err != KErrAlreadyExists)

        LEAVE(err);

    LEAVE_IF_ERROR(iPhone.Open(iServer, KMmTsyPhoneName))

    iCallStatus = CBtmcCallStatus::NewL(*this, iPhone, aProfile);

    iProtocolStatus->iCallBits = iCallStatus->CallStatusL();

    iEtelQuery = CBtmcActive::NewL(*this, CActive::EPriorityStandard, KQueryIMEI);

    iPhone.GetPhoneId(iEtelQuery->iStatus, iIdentity);

    iEtelQuery->GoActive();

    switch (aProfile)

        {

        case EBtmcHFP0105:

            {

            TRACE_INFO((_L("constructing option HFP 1.5")))

            iPhoneStatus = CBtmcPhoneStatus::NewL(*this, iPhone, aProfile);

            StartTimerL(KServiceSlcTimer, KSlcTimeout);

            break;

            }

        case EBtmcHSP:

            {

            TRACE_INFO((_L("constructing option HSP")))

            if (aBTDevAddr.Length() != KBTDevAddrSize)

                {

                LEAVE(KErrBadDescriptor);

                }

            // HSP doesn't have an SLC protocol except the RFCOMM connection itself:

            iProtocolStatus->iSlc = ETrue;

            if ( iAccessoryInitiated && ( iProtocolStatus->iCallBits & KCallConnectedBit ) )

                {

                TRACE_INFO((_L("Incoming HSP connected, start CKPD trapper")));

                // In case of incoming HSP connection during a voice call, 

                // start timer to trap the CKPD command as part of the audio transfer of HSP.

                // If the first CKPD command is received during this period, it will be ignored.

                StartTimerL(KServiceFirstHspCkpdTrap, KFirstHspCkpdTimeout);

                }

            break;

            }

        default:

            LEAVE(KErrArgument);

        }

    TRAP_IGNORE(iAtExt = CHFPAtCmdHandler::NewL(*this));

    iOutgoPacketQueue = new (ELeave) CDesC8ArrayFlat(1);

    iCallingHandler = CBtmcCallingHandler::NewL(*this);

    iCmdHanldingActive = CBtmcActive::NewL(*this, CActive::EPriorityStandard, KServiceCmdHandling);

    if (iProtocolStatus->iSlc)

        {

        iCallStatus->ReportCallStatusL();

        }

    TRACE_FUNC_EXIT

    }

void CBtmcProtocol::DoHandleCommandL()

    {

    TRACE_FUNC

    if (iHandleCmdPending)

        {

        return;

        }

    TBuf8<KMaxATSize> cmddes;

    if (iInDataBuf.NextCommand(cmddes))

        {

        return;

        }

    if (cmddes.Length() == 0)

        {

        return;

        }

    TRACE_INFO_SEG(

        {

        TBuf8<KMaxATSize> buf;

        buf = cmddes;

        buf.Trim();

        Trace(_L8("[HFP] [I] %S"), &buf);

        })

    CATCommand* cmd = NULL;

    TRAPD(err, cmd = CATCommand::NewL(cmddes));

    if (err)

        {

      	if(iAtExt)

        	{

      		iAtExt->HandleCommand(cmddes, _L8("\n\rERROR\n\r"));

        	return;

        	}

        CATResult* nok = CATResult::NewLC(EATERROR);

        SendResponseL(*nok);

        CleanupStack::PopAndDestroy(nok);

        return;

        }

    CleanupStack::PushL(cmd);

    iHandleCmdPending = ETrue;

	TATId id = cmd->Id();

    if (id == EATA || 

        id == EATD2 || 

        id == EATD1 ||

        (id == EATCHLD && cmd->Type() != EATTestCmd)||

        id == EATCHUP || 

        id == EATVTS || 

        (id == EATBVRA && cmd->Type() == EATWriteCmd) ||

        id == EATBLDN )

    	{

    	if (id == EATBVRA)

    	    {

    	    TRACE_ASSERT(cmd->ParamNum() == 1, KErrArgument);

            TATParam param = TATParam();

            LEAVE_IF_ERROR(cmd->Parameter(0, param))

            TInt value;

            LEAVE_IF_ERROR(param.Int(value))

            TBTMonoVoiceRecognitionInitiator initor;

            initor = (value) ? EBTMonoVoiceRecognitionActivatedByRemote

                : EBTMonoVoiceRecognitionDeactivatedByRemote;

            iPhoneStatus->SetRecognitionInitiator(initor);

    	    }

    	iCallingHandler->HandleCallingCmdL(*cmd);

    	}

    else if ( id == EATCKPD )

        {

        if ( iTimerActive && iTimerActive->IsActive() )

            {

            // incoming HSP was just connected and the first CKPD is received, 

            // ignore this command as audio establishment will be done via Acc FW 

            StopTimer( KServiceFirstHspCkpdTrap );

            TRACE_INFO((_L("First CKPD, do nothing")));

            CATResult* nok = CATResult::NewLC( EATOK );

            SendResponseL(*nok);

            CleanupStack::PopAndDestroy(nok);

            CmdHandlingCompletedL();

            }

        else

            {

            iCallingHandler->HandleCallingCmdL(*cmd);

            }

        }

    else if (id == EATNREC && cmd->Type() == EATWriteCmd)

        {

	    TRACE_ASSERT(cmd->ParamNum() == 1, KErrArgument);

        TATParam param = TATParam();

        LEAVE_IF_ERROR(cmd->Parameter(0, param))

        TInt value;

        LEAVE_IF_ERROR(param.Int(value))

        if (!value &&

        	ServiceLevelConnected() )

            {

            //Always respond OK to +NREC=0

            HandleNrecCompletedL(0);

            }

        else

            {

            LEAVE(KErrArgument);

            }

        }

    else

        {

        // for HSP profile we support only VGS & VGM commands

        // CKPD is handled elsewhere

        if(iProtocolStatus->iProfile == EBtmcHSP &&

           ((cmd->Id() != EATVGS &&

             cmd->Id() != EATVGM)) )

            {

            LEAVE(KErrNotSupported);

            }

        switch (cmd->Type())

            {

            case EATTestCmd:

                {

                HandleTestCommandL(*cmd);

                break;

                }

            case EATReadCmd:

                {

                HandleReadCommandL(*cmd);

                break;

                }

            case EATWriteCmd:

                {

                HandleWriteCommandL(*cmd);

                break;

                }

            case EATActionCmd:

                {

                HandleActionCommandL(*cmd);