// Copyright (c) 2006-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:

//

//INCLUDE FILES

#include "cmmdatalinetsy.h"

#include "cmmphonetsy.h"

#include "cmmdatacalltsy.h"

#include "cmmcallextinterface.h"

#include "cmmlinelist.h"

#include "cmmcalllist.h"

#include "cmmtsyreqhandlestore.h"

#include "cmmmessagemanagerbase.h"

#include "CMmCommonStaticUtility.h"

#include <ctsy/pluginapi/cmmdatapackage.h>

// ======== MEMBER FUNCTIONS ========

CMmDataLineTsy::CMmDataLineTsy()

    {

    }

void CMmDataLineTsy::ConstructL()

    {

TFLOGSTRING("TSY: CMmDataLineTsy::ConstructL");

    CMmLineTsy::ConstructL();

    }

CMmDataLineTsy* CMmDataLineTsy::NewL(

    CMmPhoneTsy* aMmPhone,

    RMobilePhone::TMobileService aMode,

    const TDesC& aName,

    CMmMessageManagerBase* aMessageManager )

    {

TFLOGSTRING2("TSY: CMmDataLineTsy::NewL - Data line %S created", &aName);

    CMmDataLineTsy* mmLineTsy = NULL;

    if ( NULL != aMmPhone && RMobilePhone::ECircuitDataService == aMode )

        {

        mmLineTsy = new ( ELeave ) CMmDataLineTsy();

        CleanupClosePushL( *mmLineTsy );

        mmLineTsy->iMmPhone  = aMmPhone;    

        mmLineTsy->iLineName = aName;

        mmLineTsy->iLineMode = aMode;

        mmLineTsy->iMessageManager = aMessageManager;

        mmLineTsy->ConstructL();

        CleanupStack::Pop();

        }

    return mmLineTsy;

    }

CMmDataLineTsy::~CMmDataLineTsy()

    {

TFLOGSTRING2("TSY: CMmDataLineTsy::~CMmDataLineTsy - Line name: %S",

    &iLineName);

    }

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

// CMmDataLineTsy::OpenNewObjectL

// This method creates a new name for a call and opens a new  call. This  

// method is called when the client uses RCall::OpenNewCall method. Currently 

// the maximum number of opened calls from tsy is 20.

// (other items were commented in a header).

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

//

CTelObject* CMmDataLineTsy::OpenNewObjectL(

    TDes& aNewName )

    {

    CMmDataCallTsy* mmCall = NULL;

    //Logic here to prevent creation of unlimited amount of call objects

    //by clients. The proposed maximum amount of call objects is 20:

    //

    //  - 2 voice call object (1 for each line for incoming calls

    //  - 1 data call object (for incoming data call)

    //  - 1 emergency call object

    //  - 1+7 call objects for Confence call (max number of CC participants)

    //  - phonebook 1

    //  - javaphone 1

    //  - WTA 1

    //  - voice mail box 1

    //  - csd 1

    //  - fax 1

    //  - 3rd party 2

    //

    //Incoming calls can not be created if the maximum number is exceeded!

    if ( KMaxNumberOfCallObjectsFromTsy 

            > iMmPhone->CallList()->GetNumberOfObjects() )

        {

        CreateNewCallName( aNewName );

        mmCall = CMmDataCallTsy::NewL( iMmPhone, this, iLineMode, aNewName,

            iMessageManager );

        iNameOfLastCallAdded = aNewName;

        // Add the new call to the list of calls

        TInt ret = iMmPhone->CallList()->AddObject( mmCall );

        if ( KErrNone != ret )

            {

            //If call cannot be added to CallList -> leave with KErrNoMemory

            //CallList has to have information about every call.

            mmCall->Close();

            mmCall = NULL;

            User::Leave( KErrNoMemory );

            }

        else

            {

            CompleteNotifyCallAdded( aNewName );

            }

        }

    else

        {

        User::Leave( KErrAccessDenied );

        }

    return mmCall;

    }

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

// CMmDataLineTsy::InitInternalAttributesL

// Initialises miscellaneous internal attributes.

// (other items were commented in a header).

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

//

void CMmDataLineTsy::InitInternalAttributesL()

    {

    CMmLineTsy::InitInternalAttributesL();

    // The line supports data connections.

    iLineCaps.iFlags = RLine::KCapsData | RLine::KCapsEventIncomingCall;

    }

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

// CMmDataLineTsy::CreateCallObjectForIncomingCall

// This function creates and stores a Call object that is used for a incoming 

// call.

// (other items were commented in a header).

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

//

TInt CMmDataLineTsy::CreateCallObjectForIncomingCall()

    {

    TInt trapError( KErrNone );

    TInt result( CMmPhoneTsy::EMultimodePhoneOutOfMemory );

    if ( !iCallForIncomingCall )

        {

        TName newName;

        CreateNewCallName( newName );

        TRAP( trapError,

            iCallForIncomingCall = CMmDataCallTsy::NewL(

                iMmPhone, this, iLineMode, newName, iMessageManager );

            );

        if ( KErrNone == trapError ) 

            {

            iNameOfLastCallAdded = newName;

            // Don't add the new call to the list of calls yet. Will be

            // Added when incoming call has been received...

            result = KErrNone;

            }

        }

    return result;

    }

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

// CMmDataLineTsy::CreateGhostCallObject

// This method creates a Call object for the Ghost call. A ghost call is a  

// call that has been initiated bypassing the ETel.

// (other items were commented in a header).

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

//

CMmCallTsy* CMmDataLineTsy::CreateGhostCallObject(

    TInt aCallId,

    RMobilePhone::TMobileService,

    RMobileCall::TMobileCallStatus aCallStatus )

    {

    TInt trapError( KErrNone );

    TName newName;

    CreateNewCallName( newName );

    CMmDataCallTsy* mmCall = NULL;

    TRAP( trapError,

        mmCall = CMmDataCallTsy::NewL(

            iMmPhone, this, iLineMode, newName, iMessageManager );

        );

    if ( KErrNone == trapError && NULL != mmCall )

        {

        //set call ID

        mmCall->SetCallId( aCallId );

        //set call status

        if( aCallStatus >= RMobileCall::EStatusDialling )

            {

            //Status is allways set to dialing. If call is alredy

            //e.g. connecting, missed status changes are simulated.

            mmCall->SetCallStatus(

                RCall::EStatusDialling, RMobileCall::EStatusDialling );

            }

        //set call caps

        mmCall->SetCallCaps( RCall::KCapsData | RCall::KCapsHangUp );

        //set call direction to MO call

        mmCall->SetCallDirection( RMobileCall::EMobileOriginated );

        //set flag indicating that this is a ghost call

        mmCall->SetGhostCall( ETrue );

        //save name of the last added call

        iNameOfLastCallAdded = mmCall->CallName();

        }

    return mmCall;

    }

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

// CMmDataLineTsy::CompleteNotifyIncomingCall

// This method notifies clients about incoming call. Basic information: one 

// Call object is allocated in the boot-up for incoming call. When an incoming 

// call occurs the call object will be given to the client that answers the

// call. Therefore TSY creates a new call object for the next incoming call.

// In case of out of memory situation, the next incoming call cannot be

// received! General error message about OutOfMemory situation is sent to the

// client. 

// (other items were commented in a header).

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

//

void CMmDataLineTsy::CompleteNotifyIncomingCall(

    CMmDataPackage* aDataPackage )

    {

    TInt callId( -1 );

    RMobilePhone::TMobileService callMode( RMobilePhone::EVoiceService );

    CCallDataPackage* callDataPackage =

        reinterpret_cast<CCallDataPackage*>(aDataPackage);

    callDataPackage->GetCallIdAndMode( callId, callMode ); 

TFLOGSTRING3("TSY: CMmDataLineTsy::CompleteNotifyIncomingCall - \

    Line name: %S, Call id: %d", &iLineName, callId );

    //reset req handle. Returns the deleted req handle

    TTsyReqHandle reqHandle = iTsyReqHandleStore->ResetTsyReqHandle( 

        EMultimodeLineNotifyIncomingCall );

    CMmDataCallTsy* mmCall = NULL;

    // First check if the incoming call is for Call Back functionality.

    // E.g. client has dialled server, which calls back to save user

    // the data call charging.

    mmCall = reinterpret_cast<CMmDataCallTsy*>(

        iMmPhone->WaitingCallForData() );

    if ( mmCall )

        {

        // If call object is valid, then there is already a call object and

        // client waiting for this incoming call!

        // Set new call id

        mmCall->SetCallId( callId );

        // Set call status

        mmCall->SetCallStatus(

            RCall::EStatusRinging, RMobileCall::EStatusRinging );        

        // Set call direction to EMobileTerminated

        mmCall->SetCallDirection( RMobileCall::EMobileTerminated );

        // Remove dial capability from existing call capabilities

        TUint32 callCaps = mmCall->CallCaps();

        callCaps &= ~RCall::KCapsDial;

        mmCall->SetCallCaps( callCaps );

        mmCall->ActiveCallExtension()->RemoveGSMCallCaps(

            RCall::KCapsDial );

        mmCall->CompleteNotifyMobileCallCapsChange( KErrNone );

        iNameOfCallForAnswering = mmCall->CallName();

        *iRetIncomingCallName = mmCall->CallName(); 

        iCallForIncomingCall = NULL;

        // Used to pass information for call object's GetMobileCallInfo.

        // Set data to gsm extension

        //( direction added because not uppdated in messagehandler)

        mmCall->ActiveCallExtension()->SetMobileCallData(

            aDataPackage, RMobileCall::EMobileTerminated );

        // Data caps are changed

        RMobileCall::TMobileCallDataCapsV1 caps;

        mmCall->ActiveCallExtension()->GetMobileDataCallCapsV1( caps );

        caps.iSpeedCaps = RMobileCall::KCapsSpeedAutobauding;

        caps.iProtocolCaps = 0x00;

        caps.iServiceCaps = 0x00;

        caps.iQoSCaps = 0x00;

        caps.iHscsdSupport = EFalse;

        caps.iMaxRxTimeSlots = 0x00;

        caps.iMaxTxTimeSlots = 0x00;

        caps.iCodingCaps = 0x00;

        caps.iAsymmetryCaps = 0x00;

        caps.iUserInitUpgrade = EFalse;

        caps.iRLPVersionCaps = 0x00;

        caps.iV42bisCaps = 0x00;

        mmCall->ActiveCallExtension()->ReceivedMobileDataCallCaps( &caps );

        mmCall->CompleteNotifyMobileDataCallCapsChange();

        // If notification is requested, complete it here!

        if ( EMultimodeLineReqHandleUnknown != reqHandle )

            {

            ReqCompleted( reqHandle, KErrNone );

            }

        mmCall = NULL;

        }

    // Check if notification is requested

    else if ( EMultimodeLineReqHandleUnknown != reqHandle )

        {

        mmCall = reinterpret_cast<CMmDataCallTsy*>(

            CallObjectForIncomingCall() );

        if ( mmCall )

            {

            // Add the new call to the list of calls

            TInt ret = iMmPhone->CallList()->AddObject( mmCall );

            if ( KErrNone == ret )

                {

                // Set flag indicating that this is a unowned incoming call

                mmCall->SetUnownedCallObjectFlag( ETrue );

                // Set call ID

                mmCall->SetCallId( callId );

                // Set call status

                mmCall->SetCallStatus(

                    RCall::EStatusRinging, RMobileCall::EStatusRinging );                

                // Set call direction to EMobileTerminated

                mmCall->SetCallDirection( RMobileCall::EMobileTerminated );

                // Remove dial capability from existing call capabilities

                TUint32 callCaps = mmCall->CallCaps();

                callCaps &= ~RCall::KCapsDial;

                mmCall->SetCallCaps( callCaps );

                mmCall->ActiveCallExtension()->RemoveGSMCallCaps(

                    RCall::KCapsDial );

                mmCall->CompleteNotifyMobileCallCapsChange( KErrNone );

                // Set data to gsm extension

                //( direction added because not uppdated in messagehandler)

                mmCall->ActiveCallExtension()->SetMobileCallData(

                    aDataPackage, RMobileCall::EMobileTerminated );

                iNameOfCallForAnswering = mmCall->CallName();

                *iRetIncomingCallName = mmCall->CallName(); 

                iCallForIncomingCall = NULL;

				iNumCalls++;

                ReqCompleted( reqHandle, KErrNone );

                // Data caps are changed

                RMobileCall::TMobileCallDataCapsV1 caps;

                mmCall->ActiveCallExtension()->GetMobileDataCallCapsV1( caps );                   

                caps.iSpeedCaps = RMobileCall::KCapsSpeedAutobauding;

                caps.iProtocolCaps = 0x00;

                caps.iServiceCaps = 0x00;

                caps.iQoSCaps = 0x00;

                caps.iHscsdSupport = EFalse;

                caps.iMaxRxTimeSlots = 0x00;

                caps.iMaxTxTimeSlots = 0x00;

                caps.iCodingCaps = 0x00;

                caps.iAsymmetryCaps = 0x00;

                caps.iUserInitUpgrade = EFalse;

                caps.iRLPVersionCaps = 0x00;

                caps.iV42bisCaps = 0x00;

                mmCall->ActiveCallExtension()->

                    ReceivedMobileDataCallCaps( &caps );

                mmCall->CompleteNotifyMobileDataCallCapsChange();

                // Create and store a new Call Object for incoming call.

                CreateCallObjectForIncomingCall();

                }

            else

                {

                //call object could not be added to the call list. Incoming 

                //call cannot be received.

                ReqCompleted( reqHandle, KErrNoMemory );

                }

            }

        else

            {

            //call object could not be get. Incoming call cannot be received.

            //General error message about OutOfMemory situation has been sent

            //to the client.

            ReqCompleted( reqHandle, KErrNoMemory );

            }

        }

    }

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

// CMmDataLineTsy::CompleteNotifyDiallingStatus

// This method notifies line that a call has entered Dialling state. It means

// that Call ID should be saved and in case of ghost call a new call object

// should be created.

// (other items were commented in a header).

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

//

void CMmDataLineTsy::CompleteNotifyDiallingStatus(

    CMmDataPackage* aDataPackage )

    {

TFLOGSTRING("TSY: CMmDataLineTsy::CompleteNotifyDiallingStatus");

    TInt callId( -1 );

    TBool ghostCall( EFalse );

    RMobilePhone::TMobileService callMode( 

                                      RMobilePhone::ECircuitDataService );

    CCallDataPackage* callData =

        reinterpret_cast<CCallDataPackage*>( aDataPackage );

    callData->GetCallIdAndMode( callId, callMode );

    CMmDataCallTsy* mmCall = reinterpret_cast<CMmDataCallTsy*>(

        iMmPhone->CallList()->GetMmCallByMode( callMode ) );

    if ( NULL == mmCall )

        {

        TFLOGSTRING("TSY: CMmDataLineTsy::CompleteNotifyDiallingStatus - \

            GhostCall");

        ghostCall = ETrue;

        }

    else

        {

        TBool result( EFalse );

        TBool resultNoFdnCheck( EFalse );

        //now we have to check, if this is a ghost call

        result = mmCall->IsServiceLocallyRequested(

            CMmCallTsy::EMultimodeCallDial );

        //now we have to check, if this is a ghost call

        resultNoFdnCheck = mmCall->IsServiceLocallyRequested( 

            CMmCallTsy::EMultimodeCallDialNoFdnCheck );

TFLOGSTRING2("TSY: CMmDataLineTsy::CompleteNotifyDiallingStatus - IsDial: %d", result );  

TFLOGSTRING2("TSY: CMmDataLineTsy::CompleteNotifyDiallingStatus - IsDialNoFdnCheck: %d", resultNoFdnCheck );  

        if ( result || resultNoFdnCheck )

            {

            for ( TInt i = 0; i < iMmPhone->CallList()->

                                                GetNumberOfObjects(); i++ )

                {    

                mmCall = reinterpret_cast<CMmDataCallTsy*>(

                    iMmPhone->CallList()->GetMmCallByIndex(i) );

                if ( ( mmCall->ServiceRequested(

                        CMmCallTsy::EMultimodeCallDial ) )

                    || ( mmCall->ServiceRequested(

                        CMmCallTsy::EMultimodeCallDialNoFdnCheck ) ) )

                    {

                    mmCall->SetCallId( callId );

TFLOGSTRING2("TSY: CMmDataLineTsy::CompleteNotifyDiallingStatus - mmCall SetCallId: %d", callId);                           

                    mmCall->CompleteNotifyMobileCallInfoChange( 

                                aDataPackage );

                    break;

                    }

                }

            }

        else

            {

TFLOGSTRING("TSY: CMmDataLineTsy::CompleteNotifyDiallingStatus - Dial not found");

            ghostCall = ETrue;

            }

        }

    //Ghost call handling starts here

    if ( ghostCall )

        {

TFLOGSTRING("TSY: CMmDataLineTsy::CompleteNotifyDiallingStatus -> CompleteNotifyAddBypassingCall");        

        //complete call added notification directly from here

        CompleteNotifyAddBypassingCall( aDataPackage ); 

        }

    }