// 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:
//



//INCLUDES
#include "cmmvoicelinetsy.h"
#include "cmmphonetsy.h"
#include "cmmvoicecalltsy.h"
#include "cmmcallextinterface.h"
#include "cmmlinelist.h"
#include "cmmcalllist.h"
#include "cmmtsyreqhandlestore.h"
#include <ctsy/pluginapi/cmmdatapackage.h>
#include <ctsy/pluginapi/mtelephonyaudiocontrol.h>

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

CMmVoiceLineTsy::CMmVoiceLineTsy()
    {
    }

void CMmVoiceLineTsy::ConstructL()
    {
    TFLOGSTRING("TSY: CMmVoiceLineTsy::ConstructL");
    CMmLineTsy::ConstructL();
    }

CMmVoiceLineTsy* CMmVoiceLineTsy::NewL(
    CMmPhoneTsy* aMmPhone,
    RMobilePhone::TMobileService aMode,
    const TDesC& aName,
    CMmMessageManagerBase* aMessageManager,
    MTelephonyAudioControl* aTelephonyAudioControl )
    {
    TFLOGSTRING2("TSY: CMmVoiceLineTsy::NewL, Voice line %S created", &aName);
    CMmVoiceLineTsy* mmLineTsy = NULL;

    if ( aMmPhone != NULL && ( aMode == RMobilePhone::EVoiceService 
        || aMode == RMobilePhone::EAuxVoiceService ) )
        {
        mmLineTsy = new ( ELeave ) CMmVoiceLineTsy();
        CleanupClosePushL( *mmLineTsy );
        mmLineTsy->iMmPhone  = aMmPhone;    
        mmLineTsy->iLineName = aName;
        mmLineTsy->iLineMode = aMode;
        mmLineTsy->iMessageManager = aMessageManager;
        mmLineTsy->iTelephonyAudioControl = aTelephonyAudioControl;
        mmLineTsy->ConstructL();
        CleanupStack::Pop();
        }
    return mmLineTsy;
    }

CMmVoiceLineTsy::~CMmVoiceLineTsy()
    {
    TFLOGSTRING2("TSY: CMmVoiceLineTsy::~CMmVoiceLineTsy. Line name: %S", \
        &iLineName);
    }

// ---------------------------------------------------------------------------
// CMmVoiceLineTsy::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* CMmVoiceLineTsy::OpenNewObjectL(
    TDes& aNewName )
    {
    CMmVoiceCallTsy* 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 = CMmVoiceCallTsy::NewL( iMmPhone, this, iLineMode, aNewName, 
            iMessageManager, iTelephonyAudioControl );

        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;
    }

// ---------------------------------------------------------------------------
// CMmVoiceLineTsy::InitInternalAttributesL
// Initialises miscellaneous internal attributes.
// (other items were commented in a header).
// ---------------------------------------------------------------------------
//
void CMmVoiceLineTsy::InitInternalAttributesL()
    {
    CMmLineTsy::InitInternalAttributesL();

    // The line supports voice connections.
    iLineCaps.iFlags = RLine::KCapsVoice | RLine::KCapsEventIncomingCall;

	if( RMobilePhone::EAuxVoiceService == iLineMode )
    	{
    	iLineCaps.iFlags |= RMobileLine::KCapsAuxVoice;
    	}
    
    //flag for swap handling
    iSwapStatus = EStatusSwapNotRequested;
    }

// ---------------------------------------------------------------------------
// CMmVoiceLineTsy::CreateCallObjectForIncomingCall
// This function creates and stores a Call object that is used for a incoming 
// call.
// (other items were commented in a header).
// ---------------------------------------------------------------------------
//
TInt CMmVoiceLineTsy::CreateCallObjectForIncomingCall()
    {
    TInt trapError( KErrNone );
    TInt result( CMmPhoneTsy::EMultimodePhoneOutOfMemory );

    if ( !iCallForIncomingCall )
        {
        TName newName;
        CreateNewCallName( newName );

        TRAP( trapError,
            iCallForIncomingCall = CMmVoiceCallTsy::NewL(
                iMmPhone, this, iLineMode, newName, iMessageManager, 
                iTelephonyAudioControl );
            );

        if ( trapError == KErrNone ) 
            {
            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;
    }

// ---------------------------------------------------------------------------
// CMmVoiceLineTsy::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* CMmVoiceLineTsy::CreateGhostCallObject(
    TInt aCallId,
    RMobilePhone::TMobileService,
    RMobileCall::TMobileCallStatus aCallStatus )
    {
    TInt trapError( KErrNone );

    TName newName;
    CreateNewCallName( newName );
    CMmVoiceCallTsy* mmCall = NULL;

    TRAP( trapError, ( mmCall = CMmVoiceCallTsy::NewL( iMmPhone, 
                    this, iLineMode, newName, iMessageManager, 
                    iTelephonyAudioControl ) ) );

    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::KCapsVoice | 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;
    }

// ---------------------------------------------------------------------------
// CMmVoiceLineTsy::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 CMmVoiceLineTsy::CompleteNotifyIncomingCall(
    CMmDataPackage* aDataPackage )
    {
    TInt callId( -1 );
    RMobilePhone::TMobileService callMode( RMobilePhone::EVoiceService );

    CCallDataPackage* callDataPackage = 
        reinterpret_cast<CCallDataPackage*>(aDataPackage);

    callDataPackage->GetCallIdAndMode( callId, callMode ); 

    TFLOGSTRING3("TSY: CMmVoiceLineTsy::CompleteNotifyIncomingCall - Line \
        name: %S, Call id: %d", &iLineName, callId );

    //reset req handle. Returns the deleted req handle
    TTsyReqHandle reqHandle = iTsyReqHandleStore->ResetTsyReqHandle( 
        EMultimodeLineNotifyIncomingCall );

    CMmVoiceCallTsy* mmCall = NULL;

    // Check if notification is requested
    if ( EMultimodeLineReqHandleUnknown != reqHandle )
        {
        mmCall = reinterpret_cast<CMmVoiceCallTsy*>(
            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 direction to EMobileTerminated
                mmCall->SetCallDirection( RMobileCall::EMobileTerminated );

                // Add answer capability and remove dial capability to
                // existing call capabilities
                TUint32 callCaps = mmCall->CallCaps();
                callCaps |= RCall::KCapsAnswer; 
                callCaps &= ~RCall::KCapsDial;
                mmCall->SetCallCaps( callCaps );

                //set data to gsm extension
                //( direction added because not uppdated in messagehandler)
                mmCall->ActiveCallExtension()->SetMobileCallData(
                    aDataPackage, RMobileCall::EMobileTerminated );

                iNameOfCallForAnswering = mmCall->CallName();
				iNumCalls++;

                *iRetIncomingCallName = mmCall->CallName(); 
                iCallForIncomingCall = NULL;
                ReqCompleted( reqHandle, KErrNone );

                // 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 );
            }
        }
    }

// ---------------------------------------------------------------------------
// CMmVoiceLineTsy::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 CMmVoiceLineTsy::CompleteNotifyDiallingStatus(
    CMmDataPackage* aDataPackage )
    {
    TFLOGSTRING("TSY: CMmVoiceLineTsy::CompleteNotifyDiallingStatus");
    TInt callId( -1 );
    TBool ghostCall( EFalse );
    RMobilePhone::TMobileService callMode( RMobilePhone::EVoiceService );

    CCallDataPackage* callData = 
        reinterpret_cast<CCallDataPackage*>(aDataPackage);

    callData->GetCallIdAndMode( callId, callMode );

    CMmVoiceCallTsy* mmCall = reinterpret_cast<CMmVoiceCallTsy*>(
        iMmPhone->CallList()->GetMmCallByMode( callMode ) );

    if ( NULL == mmCall )
        {
        TFLOGSTRING("TSY: CMmVoiceLineTsy::CompleteNotifyDiallingStatus - \
            GhostCall");
        ghostCall = ETrue;
        }
    else
        {
        TBool result( EFalse );
        TBool resultNoFdnCheck( EFalse );
        TBool resultISV( 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 );
         //now we have to check, if this is a ghost call (3rd party )
        resultISV = mmCall->IsServiceLocallyRequested( 
            CMmCallTsy::EMultimodeCallDialISV );

        if ( ( !result ) && ( !resultISV ) && ( !resultNoFdnCheck ) )
            {
            result = mmCall->IsServiceLocallyRequested( 
                CMmCallTsy::EMultimodeMobileCallDialEmergencyCall );
            }        

        if ( result || resultNoFdnCheck || resultISV )
            {
TFLOGSTRING("TSY: CMmVoiceLineTsy::CompleteNotifyDiallingStatus - Not Emergency call");
            for ( TInt i = 0; i < iMmPhone->CallList()->GetNumberOfObjects(); 
                      i++ )
                {    
                mmCall = reinterpret_cast<CMmVoiceCallTsy*>(
                    iMmPhone->CallList()->GetMmCallByIndex(i) );
                if ( ( ( mmCall->CallId() == 0 ) || ( mmCall->CallId() == -1 ))
                    && ( mmCall->ServiceRequested(
                        CMmCallTsy::EMultimodeCallDial ) 
                    ||  mmCall->ServiceRequested(
                        CMmCallTsy::EMultimodeMobileCallDialEmergencyCall )
                    || ( mmCall->ServiceRequested(
                        CMmCallTsy::EMultimodeCallDialISV ) ) 
                    || ( mmCall->ServiceRequested(
                        CMmCallTsy::EMultimodeCallDialNoFdnCheck ) ) ) )
                    {
                    mmCall->SetCallId( callId );
TFLOGSTRING2("TSY: CMmVoiceLineTsy::CompleteNotifyDiallingStatus - mmCall SetCallId: %d", callId);                      
                    mmCall->CompleteNotifyMobileCallInfoChange( 
                                aDataPackage );
                    break;   
                    }
                }
            }
        else
            {
            TFLOGSTRING("TSY: CMmVoiceLineTsy::CompleteNotifyDiallingStatus - \
                Dial not found");
            ghostCall = ETrue;
            }
        }
    //Ghost call handling starts here
    if ( ghostCall )
        {
        //complete call added notification directly from here
        CompleteNotifyAddBypassingCall( aDataPackage ); 
        }
    }

// ---------------------------------------------------------------------------
// CMmVoiceLineTsy::IsSwapReady
// Contains the logic for determining if a Swap request is ready
// (other items were commented in a header).
// ---------------------------------------------------------------------------
//
TBool CMmVoiceLineTsy::IsSwapReady(
    RMobileCall::TMobileCallStatus aCallStatus )
    {
    TBool ret( EFalse );
    CMmVoiceLineTsy* otherVoiceLine = NULL;

    CMmLineList* lineList = iMmPhone->LineList();
    TInt numberOfObjectsInLineList = lineList->GetNumberOfObjects();
    RMobilePhone::TMobileService lineMode( 
                                      RMobilePhone::EServiceUnspecified );

    //Required by ALS. We have to check what is the status of calls at the 
    //other line. This for loop find the other voice line (primary or aux).
    for ( TInt i = 0; i < numberOfObjectsInLineList; i++ )
        {
        CMmVoiceLineTsy* line = reinterpret_cast<CMmVoiceLineTsy*>(
            lineList->GetMmLineByIndex( i ) );
            
        if ( line != this && line != NULL )
            {
			lineMode = line->LineMode();
            if ( ( lineMode == RMobilePhone::EVoiceService ) ||
                ( lineMode == RMobilePhone::EAuxVoiceService ) )
                {
                otherVoiceLine = line;
                break;
                }
            }
        }

	CMmCallList* callList = iMmPhone->CallList();
	TInt numberOfObjectsInCallList = callList->GetNumberOfObjects();
    CMmVoiceCallTsy* mmCall = NULL;
		
    //is TSY still waiting both hold and connected status indications
    if ( EWaitingHoldAndResumeOk == iSwapStatus )
        {
        //TSY is still waiting both hold and connected status indications
        if ( RMobileCall::EStatusHold == aCallStatus )
            {
            //hold status indication received
            //-> still waiting connected status indication
            iSwapStatus = EWaitingResumeOk;
            }
        else if ( RMobileCall::EStatusConnected == aCallStatus )
            {
            //connected status indication received
            //-> still waiting hold status indication
            iSwapStatus = EWaitingHoldOk;
            }
        }
    //swap handling is going on. 
    else if ( ( EWaitingResumeOk == iSwapStatus &&
        RMobileCall::EStatusConnected == aCallStatus ) ||
              ( EWaitingHoldOk == iSwapStatus &&
        RMobileCall::EStatusHold == aCallStatus ) )
        {
        //find the call object from which the swap was requested.
        for ( TInt i = 0; i < numberOfObjectsInCallList; i++ )
            {
            mmCall = reinterpret_cast<CMmVoiceCallTsy*>(
                callList->GetMmCallByIndex(i) );
            if ( mmCall->ServiceRequested( 
                    CMmCallTsy::EMultimodeMobileCallSwap ) )
                {
                //complete swap request when the correct object has been found
                mmCall->CompleteSwap( KErrNone );
                break;
                }
            }
        //clear swap status.
        iSwapStatus = EStatusSwapNotRequested;
        //return value indicating that Swap was completed.
        ret = ETrue;
        }
    //swap handling is going on. This the case where the calls to be swapped 
    //are opened different lines (primary and aux).
    else if ( otherVoiceLine )
        {
        if ( ( EWaitingResumeOk == otherVoiceLine->SwapStatus() &&
            RMobileCall::EStatusConnected == aCallStatus ) ||
            ( EWaitingHoldOk == otherVoiceLine->SwapStatus() &&
            RMobileCall::EStatusHold == aCallStatus ) )
            {
            CMmCallList* callList = iMmPhone->CallList();
            TInt numberOfObjectsInCallList = callList->GetNumberOfObjects();
            CMmVoiceCallTsy* mmCall = NULL;
            //find the call object from which the swap was requested.
            for ( TInt i = 0; i < numberOfObjectsInCallList; i++ )
                {
                mmCall = reinterpret_cast<CMmVoiceCallTsy*>(
                    callList->GetMmCallByIndex(i) );
                if ( mmCall->ServiceRequested( 
                        CMmCallTsy::EMultimodeMobileCallSwap ) )
                    {
                    //complete swap request when the correct object has found
                    mmCall->CompleteSwap( KErrNone );
                    break;
                    }
                }
            //clear swap status.
            iSwapStatus = EStatusSwapNotRequested;
            //clear swap status also from the aux line
            otherVoiceLine->SetSwapStatus( EStatusSwapNotRequested );

            //return value indicating that Swap was completed.
            ret = ETrue;
            }
        }

    if ( numberOfObjectsInCallList==1 && !otherVoiceLine )
    	{

    	// Swapping a single call. 
        mmCall = reinterpret_cast<CMmVoiceCallTsy*>(
            callList->GetMmCallByIndex(0) );
        if ( mmCall->ServiceRequested( 
                CMmCallTsy::EMultimodeMobileCallSwap ) )
            {
            // Complete swap request when the correct object has been found
            mmCall->CompleteSwap( KErrNone );
            }    	
    	ret = ETrue;
    	}
    
    return ret;
    }

// ---------------------------------------------------------------------------
// CMmVoiceLineTsy::SetSwapStatus
// Sets status of Swap. This can be used by call objects opened from this line
// (other items were commented in a header).
// ---------------------------------------------------------------------------
//
void CMmVoiceLineTsy::SetSwapStatus(
    CMmVoiceLineTsy::TSwapStatus aSwapStatus )
    {
    iSwapStatus = aSwapStatus;
    }

// ---------------------------------------------------------------------------
// CMmVoiceLineTsy::SwapStatus
// Return status of Swap for this Line. This can be used by call objects  
// opened from this line.
// (other items were commented in a header).
// ---------------------------------------------------------------------------
//
CMmVoiceLineTsy::TSwapStatus CMmVoiceLineTsy::SwapStatus() const
    {
    return iSwapStatus;
    }

//  End of File