/*

* 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 "btmcprotocol.h"

#include "btmcprotocolstatus.h"

#include "btmccallstatus.h"

#include "btmcmobileline.h"

#include "btmcvoipline.h"

#include "debug.h"

const TInt KRingTimerService = 10;

CBtmcCallStatus* CBtmcCallStatus::NewL(

    CBtmcProtocol& aProtocol, 

    RMobilePhone& aPhone,

    TBtmcProfileId aProfile)

    {

    CBtmcCallStatus* self=new (ELeave) CBtmcCallStatus(aProtocol);

    CleanupStack::PushL(self);

    self->ConstructL(aPhone, aProfile);

    CleanupStack::Pop(self);

    return self;

    }

// ==========================================================

// CBtmcCallStatus::~CBtmcCallStatus

// 

// ==========================================================

//

CBtmcCallStatus::~CBtmcCallStatus()

    {

    TRACE_FUNC_ENTRY

    delete iTimerActive;

    iTimer.Close();

    iLines.ResetAndDestroy();

    iLines.Close();

    TRACE_FUNC_EXIT

    }

// ==========================================================

// CBtmcCallStatus::CallStatus

// 

// ==========================================================

//

TInt CBtmcCallStatus::CallStatusL() const

    {

    TRACE_FUNC

    TInt mask = 0;

    TInt count = iLines.Count();

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

        {

        mask |= iLines[i]->CallStatusL();

        }

    TRACE_INFO((_L(" overall CALL STATUS 0x%08x"), mask))    

    return mask;    

    }

// ==========================================================

// CBtmcCallStatus::ReportCallStatusL

// 

// ==========================================================

//

void CBtmcCallStatus::ReportCallStatusL()

    {

    TInt callBits = CallStatusL();

    ReportCallEventL(iProtocol.ProtocolStatus().iCallBits, callBits);

    iProtocol.ProtocolStatus().iCallBits = callBits;    

    }

// ==========================================================

// CBtmcCallStatus::RequestCompleted

// 

// ==========================================================

//

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

    {

    TRACE_FUNC_ENTRY

    switch (aActive.ServiceId())

        {

        case KRingTimerService:

            {

            if (aErr == KErrNone)

                {

                ReportRingAndClipL();

                iTimer.After(aActive.iStatus, KRingInterval);

                aActive.GoActive();

                }

            break;

            }

        default:

            break;

        }

    TRACE_FUNC_EXIT

    }

// ==========================================================

// CBtmcCallStatus::CancelRequest

// Constructor

// ==========================================================

//

void CBtmcCallStatus::CancelRequest(TInt aServiceId)

    {

    TRACE_FUNC_ENTRY

    if (aServiceId == KRingTimerService)

        {

        iTimer.Cancel();

        }

    TRACE_FUNC_EXIT

    }

// ==========================================================

// CBtmcCallStatus::CBtmcCallStatus

// Constructor

// ==========================================================

//

CBtmcCallStatus::CBtmcCallStatus(CBtmcProtocol& aProtocol) : iProtocol(aProtocol)

    {

    }

// ==========================================================

// CBtmcCallStatus::ConstructL

// 

// ==========================================================

//

void CBtmcCallStatus::ConstructL(

    RMobilePhone& aPhone,

    TBtmcProfileId aProfile)

    {

    TRACE_FUNC_ENTRY

    CBtmcMobileLine* voiceline = CBtmcMobileLine::NewLC(*this, aPhone, KMmTsyVoice1LineName);

    iLines.AppendL(voiceline);

    CleanupStack::Pop(voiceline);

    CBtmcVoIPLine *voipline = NULL;

    TRAPD(err, voipline = CBtmcVoIPLine::NewL(*this, aPhone));

    if(!err)

        {

        CleanupStack::PushL(voipline);

        iLines.AppendL(voipline);

        CleanupStack::Pop(voipline);        

        }

    TRAP(err, voiceline = CBtmcMobileLine::NewL(*this, aPhone, KMmTsyVoice2LineName));

    if (!err)

        {

        CleanupStack::PushL(voiceline);

        iLines.AppendL(voiceline);

        CleanupStack::Pop(voiceline);

        }

    if (aProfile == EBtmcHFP0105 )

        {

        CBtmcMobileLine* dataline = CBtmcMobileLine::NewLC(*this, aPhone, KMmTsyDataLineName);

        iLines.AppendL(dataline);

        CleanupStack::Pop(dataline);

        }

    TRACE_FUNC_EXIT

    }

// ==========================================================

// CBtmcCallStatus::HandleClccL

// 

// ==========================================================

//

void CBtmcCallStatus::HandleClccL()

    {

    TRACE_FUNC_ENTRY

    RATResultPtrArray resarr;

    ATObjArrayCleanupResetAndDestroyPushL(resarr);

    if(CallStatusL() & KCallAllStatusMask)

        {

        TInt count = iLines.Count();        

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

            {            

            if( !iLines[i]->IsVoip() )

                {                

                const RPointerArray<CBtmcCallActive>& calls = iLines[i]->ActiveCalls();

                TInt count2 = calls.Count();            

                RMobileConferenceCall myConf;

                User::LeaveIfError(myConf.Open(iLines[i]->Phone()));

                CleanupClosePushL(myConf);

                TInt confcount;

                User::LeaveIfError(myConf.EnumerateCalls(confcount));                

                RMobileCall::TMobileCallInfoV1 info;

                RMobileCall::TMobileCallRemotePartyInfoV1 remote;                

                for(TInt j=0; j<count2; j++)

                    {                                        

                    calls[j]->GetCallInfo(info);                                        

                    if (info.iStatus != RMobileCall::EStatusIdle)

                        {

                        remote = info.iRemoteParty;

                        CATResult* cmd = MakeClccL(info, remote, confcount);

                        resarr.AppendL(cmd);

                        }

                    }

                CleanupStack::PopAndDestroy(&myConf);

                }

            else // VoIP case

                {                       

				const MCall& callInfo = iLines[i]->CallInformationL();

				if(&callInfo != NULL)

				    {				    

				    CATResult* cmd = MakeVoIPClccL(callInfo);

				    resarr.AppendL(cmd);

				    }				                    				

                }

            }

        }

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

    CleanupStack::PushL(ok);

    resarr.AppendL(ok);

    CleanupStack::Pop(ok);

    iProtocol.SendResponseL(resarr);

    CleanupStack::PopAndDestroy(&resarr);

    iProtocol.CmdHandlingCompletedL();

    TRACE_FUNC_EXIT

    }

// ==========================================================

// CBtmcCallStatus::GetRingingNumL

// 

// ==========================================================

//

void CBtmcCallStatus::GetRingingNumL(TDes8& aNum)

	{

    TRACE_FUNC_ENTRY

	if(CallStatusL() & KCallRingingBit)

		{

		TInt count = iLines.Count();

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

			{

			if(!iLines[i]->IsVoip())

			    {

                const RPointerArray<CBtmcCallActive>& calls = iLines[i]->ActiveCalls();

                TInt count2 = calls.Count();

                RMobileConferenceCall myConf;

                User::LeaveIfError(myConf.Open(iLines[i]->Phone()));

                CleanupClosePushL(myConf);

                RMobileCall::TMobileCallInfoV1 info;

                RMobileCall::TMobileCallRemotePartyInfoV1 remote;

                for(TInt j=0; j<count2; j++)

                    {

                    calls[j]->GetCallInfo(info);

                    if (info.iStatus == RMobileCall::EStatusRinging

                       && (info.iValid & RMobileCall::KCallRemoteParty)

                       && info.iRemoteParty.iRemoteIdStatus == RMobileCall::ERemoteIdentityAvailable)

                        {

                        aNum.Copy(info.iRemoteParty.iRemoteNumber.iTelNumber);

                        break;

                        }

                    }

                CleanupStack::PopAndDestroy(&myConf);

			    }

	        }

		}

	TRACE_FUNC_EXIT

	}

// ==========================================================

// CBtmcCallStatus::GetOutgoingNumL

// 

// ==========================================================

//

void CBtmcCallStatus::GetOutgoingNumL(TDes8& aNum)

	{

    TRACE_FUNC_ENTRY

	TInt count = iLines.Count();

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

		{

		const RPointerArray<CBtmcCallActive>& calls = iLines[i]->ActiveCalls();

		TInt count2 = calls.Count();

		RMobileCall::TMobileCallInfoV1 info;

		RMobileCall::TMobileCallRemotePartyInfoV1 remote;

		for(TInt j=0; j<count2; j++)

			{

			calls[j]->GetCallInfo(info);

			if (info.iStatus == RMobileCall::EStatusDialling

				&& (info.iValid & RMobileCall::KCallDialledParty))

			    {

				TPtrC tempPtrC(KNullDesC);

				tempPtrC.Set(info.iDialledParty.iTelNumber);

				aNum.Copy(tempPtrC);

				break;

			    }

			}

		}

	TRACE_FUNC_EXIT

	}

TBTMonoATPhoneNumberType CBtmcCallStatus::NumberType( const TDesC8& aNum )

    {

    if (aNum.Length() == 0)

        {

        return EBTMonoATPhoneNumberUnavailable;

        }

    if(aNum.Locate('+') == 0)

        {

        return EBTMonoATPhoneNumberInternational;

        }

    return EBTMonoATPhoneNumberNational;

    }

// ==========================================================

// CBtmcCallStatus::MakeClccL

// 

// ==========================================================

//

CATResult* CBtmcCallStatus::MakeClccL(RMobileCall::TMobileCallInfoV1& info, 

    RMobileCall::TMobileCallRemotePartyInfoV1& remote, TInt aConferenceCallCount)

    {

    TRACE_FUNC_ENTRY

    RArray<TATParam> params;

    CleanupClosePushL(params);

    if(info.iValid & RMobileCall::KCallId)

        {

        LEAVE_IF_ERROR(params.Append(TATParam(info.iCallId))) // Index number

        }

    else

        {

        LEAVE_IF_ERROR(params.Append(TATParam()))

        }

    if(remote.iDirection == RMobileCall::EMobileOriginated) // outgoing

        {

        LEAVE_IF_ERROR(params.Append(TATParam(0)))

        }

    else // unknown or incoming

        {

        LEAVE_IF_ERROR(params.Append(TATParam(1)))            

        }

    switch(info.iStatus) // status

        {

        case RMobileCall::EStatusDialling:

            {

            LEAVE_IF_ERROR(params.Append(TATParam(2)))

            break;

            }

        case RMobileCall::EStatusRinging:

            {

            TInt status = CallStatusL();

            if(status & KActiveCallMask)

            	{

            	LEAVE_IF_ERROR(params.Append(TATParam(5)))

            	}

            else

	            {

            	LEAVE_IF_ERROR(params.Append(TATParam(4)))

	            }

            break;

            }

        case RMobileCall::EStatusAnswering:

            {

            LEAVE_IF_ERROR(params.Append(TATParam(5)))

            break;

            }

        case RMobileCall::EStatusConnecting:

            {

            LEAVE_IF_ERROR(params.Append(TATParam(3)))

            break;

            }

        case RMobileCall::EStatusConnected:

            {

            LEAVE_IF_ERROR(params.Append(TATParam(0)))

            break;

            }

        case RMobileCall::EStatusHold:

            {

            LEAVE_IF_ERROR(params.Append(TATParam(1)))

            break;

            }

        default:

            LEAVE_IF_ERROR(params.Append(TATParam(0)))

        }

    switch(info.iService) // mode

        {

        case RMobilePhone::EVoiceService:

            {

            LEAVE_IF_ERROR(params.Append(TATParam(0)))

            break;

            }

        case RMobilePhone::ECircuitDataService:

        case RMobilePhone::EPacketDataService:

            {

            LEAVE_IF_ERROR(params.Append(TATParam(1)))

            break;

            }

        case RMobilePhone::EFaxService:

            {

            LEAVE_IF_ERROR(params.Append(TATParam(2)))

            break;

            }

        default:

            LEAVE_IF_ERROR(params.Append(TATParam(0)))    

        }

    // multiparty

    TATParam param;

    if(aConferenceCallCount)

        LEAVE_IF_ERROR(params.Append(TATParam(1)))

    else

        LEAVE_IF_ERROR(params.Append(TATParam(0)))

    // number (optional)

	TPtrC tempPtrC(KNullDesC);

    if ((info.iValid & RMobileCall::KCallRemoteParty) && 

         info.iRemoteParty.iRemoteIdStatus == RMobileCall::ERemoteIdentityAvailable)

        {

        tempPtrC.Set(info.iRemoteParty.iRemoteNumber.iTelNumber);

        }

	else if (info.iValid & RMobileCall::KCallDialledParty)

		{

		//append number for outgoing call

		tempPtrC.Set(info.iDialledParty.iTelNumber);

		}

	if(tempPtrC != KNullDesC)

		{

		TBuf8<100> tempBuf8;

		tempBuf8.Copy(tempPtrC); // conversion to 8 bit

    	LEAVE_IF_ERROR(params.Append(TATParam(tempBuf8, EATDQStringParam)))		

	    // type (optional)

	    TBTMonoATPhoneNumberType numType = NumberType( tempBuf8 );

	    params.AppendL(TATParam(numType));

		}

    CATResult* clcc = CATResult::NewL(EATCLCC, EATActionResult, &params);

    CleanupStack::PopAndDestroy(&params);

    TRACE_FUNC_EXIT

    return clcc;

    }

// ==========================================================

// CBtmcCallStatus::MakeVoIPClccL

// 

// ==========================================================

//

CATResult* CBtmcCallStatus::MakeVoIPClccL(const MCall &callinfo)

    {

    TRACE_FUNC_ENTRY

    RArray<TATParam> params;

    CleanupClosePushL(params);

    LEAVE_IF_ERROR(params.Append(TATParam(1))) // Index number

    if(callinfo.CallDirection() == CCPCall::EMobileOriginated) // outgoing

        {        

        LEAVE_IF_ERROR(params.Append(TATParam(0)))

        }

    else // unknown or incoming

        {        

        LEAVE_IF_ERROR(params.Append(TATParam(1)))            

        }       

    switch(callinfo.CallState()) // status

        {

        case CCPCall::EStateDialling:

            {            

            LEAVE_IF_ERROR(params.Append(TATParam(2)))

            break;

            }

        case CCPCall::EStateRinging:

            {            

            TInt status = CallStatusL();

            if(status & KActiveCallMask)

                {

                LEAVE_IF_ERROR(params.Append(TATParam(5)))

                }

            else

                {

                LEAVE_IF_ERROR(params.Append(TATParam(4)))

                }

            break;

            }

        case CCPCall::EStateAnswering:

            {            

            LEAVE_IF_ERROR(params.Append(TATParam(5)))

            break;

            }

        case CCPCall::EStateConnecting:

            {            

            LEAVE_IF_ERROR(params.Append(TATParam(3)))

            break;

            }

        case CCPCall::EStateConnected:

            {            

            LEAVE_IF_ERROR(params.Append(TATParam(0)))

            break;

            }

        case CCPCall::EStateHold:

            {         

            LEAVE_IF_ERROR(params.Append(TATParam(1)))

            break;

            }

        default:            

            LEAVE_IF_ERROR(params.Append(TATParam(0)))

        }

    LEAVE_IF_ERROR(params.Append(TATParam(1)))

    // multiparty

    LEAVE_IF_ERROR(params.Append(TATParam(0)))

    CATResult* clcc = CATResult::NewL(EATCLCC, EATActionResult, &params);

    CleanupStack::PopAndDestroy(&params);

    TRACE_FUNC_EXIT

    return clcc;

    }