// 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 "cmmcalltsy.h"

#include <featmgr/featurecontrol.h>

#include <featureuids.h>

#include "cmmphonetsy.h"

#include "cmmlinetsy.h"

#include "cmmtsyreqhandlestore.h"

#include "cmmcalllist.h"

#include "CMmCommonStaticUtility.h"

#include "cmmlinelist.h"

#include "cmmmessagemanagerbase.h"

#include <ctsy/pluginapi/cmmdatapackage.h>

#include <ctsy/serviceapi/gsmerror.h>

#include "cmmcallgsmwcdmaext.h"

#include <ctsy/pluginapi/mtelephonyaudiocontrol.h>

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

CMmCallTsy::CMmCallTsy() : iCallParamsPckg(iCallParams)

    {

    }

void CMmCallTsy::ConstructL( 

	RMobilePhone::TMobileService aMode )

    {    

#ifdef REQHANDLE_TIMER   

    //Create req handle store

    iTsyReqHandleStore = CMmTsyReqHandleStore::NewL( this, iMmPhone, 

        EMultimodeCallMaxNumOfRequests, iCallReqHandles);

#else

    //Create req handle store

    iTsyReqHandleStore = CMmTsyReqHandleStore::NewL( 

        EMultimodeCallMaxNumOfRequests, iCallReqHandles);

#endif

    iCallMode = aMode;

    //Call ownership change request list

    iList = CAcquireOwnerList::NewL();

    //initialise call duration notifier

    iCallTimer = CHeartbeatRunner::NewL( this );

    //Initialise extension modules

    InitExtensionModulesL( aMode );

    //Initialise miscellaneous internal attributes

    InitInternalAttributes();

    }

CMmCallTsy::~CMmCallTsy()

    {

TFLOGSTRING3("TSY: CMmCallTsy::~CMmCallTsy. Call deleted iCallId:%d iCallName:%S",iCallId, &iCallName);

    TInt trapError( KErrNone );

    //Hang up call if call is still connecting or active and hang up is not

    //called

    if( iTsyReqHandleStore )

        {

        if ( !( RMobileCall::EStatusIdle == iMobileCallStatus ||

            RMobileCall::EStatusDisconnecting == iMobileCallStatus ||

            RMobileCall::EStatusDisconnectingWithInband == iMobileCallStatus ) 

            && ( 0 == iTsyReqHandleStore->GetTsyReqHandle( 

                                                    EMultimodeCallHangUp ) ) )

            {

                TBool timerStarted = EFalse;

                if( iCallTimer )

                    {

                    timerStarted = iCallTimer->Stop();

                    }

            //Check air time timer only if call was in active state(call timer 

            //was started)

            if ( timerStarted )

                {

                if( iMmPhone )

                	{

                	iMmPhone->AirTimeTimerCheckStop();

                	//TODO: attention reviewers - please check if UpdateLifeTimer should/shouldn't be called here

                    UpdateLifeTimer();

                    }

                }

            //Send call release request before deleting this object

            TInt symbianHangUpCause( KErrGsmReleaseByUser );

    		//Create package

    		CCallDataPackage package;

    		//Set call id and call mode

    		package.SetCallIdAndMode( iCallId, iCallMode );

    		TBool autoStChangeDisable = EFalse;

    		//Pack call parameters and mobile call info

    		package.PackData( &symbianHangUpCause, &autoStChangeDisable );

    		//Send request to the Domestic OS layer.

            if( iMessageManager )

            	{

            	TRAP( trapError,

                iMessageManager->HandleRequestL( EEtelCallHangUp, &package );

                );

                // inform telephony audio control that we're hanging up the call	

                if ( iTelephonyAudioControlSetup && iTelephonyAudioControl )

                    {

                    iTelephonyAudioControl->TeardownTelephonyAudio( iCallName, 

                                                                    KErrNone );

TFLOGSTRING2("TSY: CMmCallTsy::~CMmCallTsy Call routing tear down: Call name:%S", &iCallName );

                    }

            	}

            // We can't do nothing if hanguprequest fails here,

            // because call object is closed.

            }

        }

    //delete req handle store

    if ( iTsyReqHandleStore )

        {

        delete iTsyReqHandleStore;

        }

    iTsyReqHandleStore = NULL;

    //delete req handle store

    if ( iList )

        {

        delete iList;

        }

    iList = NULL;

    //delete call ownership change request list

    if ( iCallTimer )

        {

        delete iCallTimer;

        }

    iCallTimer = NULL;

    //Decrement number of opened calls from line.

    if( iMmLine )

    	{

    	iMmLine->DecrementNumberOfCalls();

    	}

    // Remove the call from the list of calls

    if( iMmPhone )

    	{

    	iMmPhone->CallList()->RemoveObject( this );

    	}

    //delete call extension

    if ( iMmCallExtInterface )

        {

    	delete iMmCallExtInterface;

        }

    iMmCallExtInterface = NULL;

    iMmPhone = NULL;

    iMmLine = NULL;

    iCallTimer = NULL;

    iRetNotifyMobileCallCaps = NULL;

    iRetCaps = NULL;

    iRetStatus = NULL;

    iRetMobileCallStatus = NULL;

    iRetRemotePartyInfo = NULL;

    iRetTimeIntervalSeconds = NULL;

    iRetCallEvent = NULL;

    iList = NULL;

    iTsyReqHandleStore = NULL;

    iRetPrivacyStatus = NULL;

    iMessageManager = NULL;

    iRetUUI = NULL; 

    }

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

// CMmCallTsy::InitExtensionModulesL

// Initialises extension modules for CMmCallTsy

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

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

//

void CMmCallTsy::InitExtensionModulesL(

    RMobilePhone::TMobileService aMode )

    {

    RMobilePhone::TMobilePhoneNetworkMode currentMode;

    iMmPhone->GetStaticExtensionMode( &currentMode );

    iMmCallExtInterface  = reinterpret_cast<CMmCallExtInterface*> 

        (CMmCallGsmWcdmaExt::NewL( this, aMode, iMessageManager ) );

    }

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

// CMmCallTsy::InitInternalAttributes

// Initialises miscellaneous internal attributes.

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

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

//

void CMmCallTsy::InitInternalAttributes()

    {

    //Set status parameters

    iCallStatus = RCall::EStatusIdle;

    iMobileCallStatus = RMobileCall::EStatusIdle;

    //Initialise call params

    iCallParams.iSpeakerControl = RCall::EMonitorSpeakerControlOnUntilCarrier;

    iCallParams.iSpeakerVolume = RCall::EMonitorSpeakerVolumeLow;

    iCallParams.iInterval = 4;

    iCallParams.iWaitForDialTone = RCall::EDialToneWait;

    iCallParams.iIdRestrict = RMobileCall::EIdRestrictDefault;

    iCallParams.iCug.iExplicitInvoke = EFalse;

    iCallParams.iCug.iCugIndex = 0;

    iCallParams.iCug.iSuppressPrefCug = EFalse;

    iCallParams.iCug.iSuppressOA = EFalse;

    iCallParams.iAutoRedial = EFalse;

    // CallParamsV2

    iCallParams.iBearerMode = RMobileCall::EMulticallNotSupported;

    // CallParamsV7

    iCallParams.iCallParamOrigin = RMobileCall::EOriginatorUnknown;

    iCallParams.iBCRepeatIndicator = RMobileCall::EBCAlternateMode;

    iCallParams.iIconId.iQualifier = RMobileCall::EIconQualifierNotSet;

    iCallParams.iIconId.iIdentifier = 0;

    iCallParams.iAlphaId.Zero();

    iCallParams.iSubAddress.Zero();

    iCallParams.iBearerCap1.Zero();

    iCallParams.iBearerCap2.Zero();

    iCallParams.iBCRepeatIndicator = RMobileCall::EBCAlternateMode;

    iDialCancelFlag = CMmCallTsy::EDialCancelNotCalled;

    iAnswerCancelFlag = EFalse;

    iHangUpFlag = EFalse; 

    //this is required for the Conference call.

    iPreviousCallId = -1;

    //Initialize last exit code

    iLastExitCode = KErrNotFound;

    //this is required for custom tsy

    iDiagnosticOctet = NULL;

    //by default a call object has been created through ETel

    iGhostCall = EFalse;

    iEtelOriginated = ETrue;

    iPreviousCallControlCaps = 0;

	iIsRemoteReleasedCall = EFalse;

    }

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

// CMmCallTsy::OpenNewObjectByNameL

// Creates new  object and returns a pointer to it. Not supported.

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

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

//

CTelObject* CMmCallTsy::OpenNewObjectByNameL(    

    const TDesC& )

    {

    //Not supported

    User::Leave( KErrNotSupported );

	//lint -e{527} "unreachable code"

    return NULL;

    }

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

// CMmCallTsy::OpenNewObjectL

// Creates new object and returns a pointer to it. Not supported.

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

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

//

CTelObject* CMmCallTsy::OpenNewObjectL(

    TDes& )

    {

    // Not supported

    User::Leave( KErrNotSupported );

	//lint -e{527} "unreachable code"

    return NULL;

    }

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

// CMmCallTsy::ExtFunc

// TRAP's all CMmCallTsy related MM API requests in case that they fail. This 

// method functions only as a centralized TRAP for the DoExtFuncL method that 

// does the actual mapping of IPC number to TSY method call.

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

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

//

TInt CMmCallTsy::ExtFunc( 

    const TTsyReqHandle aTsyReqHandle,

    const TInt aIpc,

    const TDataPackage& aPackage )

    {    

    TInt ret( KErrNone );

    TInt trapError( KErrNone );

    //reset last tsy request type

    iReqHandleType = EMultimodeCallReqHandleUnknown;

    //before processing further the request, check if offline mode status

    //is enabled and if the given request can be perfomed in that case.

    if ( ERfsStateInfoInactive == iMmPhone->GetRfStateInfo () &&

        !IsRequestPossibleInOffline( aIpc ) )  

        {

TFLOGSTRING2("TSY: Offline mode ON, request is not allowed: %d", aIpc );

        ret = CMmCommonStaticUtility::EpocErrorCode(

            KErrGeneral, KErrGsmOfflineOpNotAllowed );

        //Complete the request with appropiate error

        ReqCompleted ( aTsyReqHandle, ret ); 

        }

    else

        {

        TRAP( trapError, ret = DoExtFuncL( aTsyReqHandle, aIpc, aPackage ); );

        if ( trapError != KErrNone )

            {

            //error handling. Object cannot be created. 

            ReqCompleted( aTsyReqHandle, trapError );

            }

        else if ( ret != KErrNone )

            {

            ReqCompleted( aTsyReqHandle, ret );

            }   

        //save request handle

        if ( EMultimodeCallReqHandleUnknown != iReqHandleType )

            {

#ifdef REQHANDLE_TIMER

            SetTypeOfResponse( iReqHandleType, aTsyReqHandle );

#else

            iTsyReqHandleStore->SetTsyReqHandle(

                iReqHandleType, aTsyReqHandle );

#endif

            }

        }

    return KErrNone;

    }

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

// CMmCallTsy::GetInfo

// This CORE API method returns core Call information.

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

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

//

TInt CMmCallTsy::GetInfo(

    const TTsyReqHandle aTsyReqHandle,

    RCall::TCallInfo* aCallInfo )

    {

    //Fill Core Call information

    aCallInfo->iCallName = iCallName;

    aCallInfo->iStatus = iCallStatus;

    aCallInfo->iLineName = iMmLine->LineName();

    aCallInfo->iHookStatus = RCall::EHookStatusUnknown;

    aCallInfo->iDuration = GetCallDurationInSeconds();

    ReqCompleted( aTsyReqHandle, KErrNone );

    return KErrNone;

    }

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

// CMmCallTsy::NotifyCapsChange

// This CORE API method requests notifications when core caps change.

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

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

//

TInt CMmCallTsy::NotifyCapsChange(

    const TTsyReqHandle aTsyReqHandle,

    RCall::TCaps* aCaps )

    {

    iRetCaps = aCaps;

    //Store the current capabilities

    iPreviousCaps =  iCallCaps;

    iTsyReqHandleStore->SetTsyReqHandle(

        EMultimodeCallCapsChangeNotification, aTsyReqHandle );

    return KErrNone;

    }

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

// CMmCallTsy::NotifyCapsChangeCancel

// This CORE API method cancels core caps change notifications.

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

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

//

TInt CMmCallTsy::NotifyCapsChangeCancel(

    const TTsyReqHandle aTsyReqHandle )

    {    

    iRetCaps = NULL;

    iTsyReqHandleStore->ResetTsyReqHandle(

        EMultimodeCallCapsChangeNotification );

    ReqCompleted( aTsyReqHandle, KErrCancel );

    return KErrNone;

    }

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

// CMmCallTsy::CompleteNotifyCapsChange

// Complete notification when caps change.

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

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

//

void CMmCallTsy::CompleteNotifyCapsChange()

    {

    //reset req handle. Returns the deleted req handle

    TTsyReqHandle reqHandle = iTsyReqHandleStore->ResetTsyReqHandle(

        EMultimodeCallCapsChangeNotification );

    //if caps have changed and client has requested capability notifications

    if ( EMultimodeCallReqHandleUnknown != reqHandle &&

        iRetCaps != NULL &&

        iCallCaps.iFlags != iPreviousCaps.iFlags )

        {

        iRetCaps->iFlags = iCallCaps.iFlags;

        ReqCompleted( reqHandle, KErrNone );

        }

    }

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

// CMmCallTsy::NotifyHookChange

// This CORE API method requests notifications on hook change.

// Feature not supported.

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

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

//

TInt CMmCallTsy::NotifyHookChange(

    const TTsyReqHandle aTsyReqHandle,

    RCall::THookStatus* )

    {

    ReqCompleted( aTsyReqHandle, KErrNotSupported );

    return KErrNone;

    }

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

// CMmCallTsy::NotifyHookChange

// This CORE API method cancels hook change notifications.

// Feature not supported.

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

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

//

TInt CMmCallTsy::NotifyHookChangeCancel(

    const TTsyReqHandle aTsyReqHandle )

    {

    ReqCompleted( aTsyReqHandle, KErrNotSupported );

    return KErrNone;

    }

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

// CMmCallTsy::NotifyStatusChange

// This CORE API method requests notifications when Core status changes.

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

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

//

TInt CMmCallTsy::NotifyStatusChange(

    const TTsyReqHandle aTsyReqHandle,

    RCall::TStatus* aStatus )

    {

    // Save request handle and ptr to aStatus. 

    iRetStatus = aStatus;

    iTsyReqHandleStore->SetTsyReqHandle(

        EMultimodeCallNotifyStatusChange, aTsyReqHandle );

    return KErrNone;

    }

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

// CMmCallTsy::NotifyStatusChangeCancel

// This CORE API method cancels core status change notifications.

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

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

//

TInt CMmCallTsy::NotifyStatusChangeCancel(

    const TTsyReqHandle aTsyReqHandle )

    {

    iRetStatus = NULL;

    iTsyReqHandleStore->ResetTsyReqHandle( EMultimodeCallNotifyStatusChange );

    ReqCompleted( aTsyReqHandle, KErrCancel );

    return KErrNone;

    }

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

// CMmCallTsy::HandleGhostCallStatusChange

// Handles status change notifications of a call object that is not monitored 

// by any client (handle to this call object has not been opened by any client).

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

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

//

void CMmCallTsy::HandleGhostCallStatusChange(

    TInt aResult,

    CMmDataPackage* aDataPackage )

    {

    RMobileCall::TMobileCallStatus callStatus( RMobileCall::EStatusIdle );

    RMobileCall::TMobileCallStatus receivedCallStatus( 

        RMobileCall::EStatusIdle );

    aDataPackage->UnPackData( receivedCallStatus );

    TTsyReqHandle mobileStatusHandle = iTsyReqHandleStore->GetTsyReqHandle(

        EMultimodeCallNotifyMobileCallStatusChange );

    //client is ready for receiving status change indications

    //or call has entered either idle or active status -> no

    //more status changes are assumed soon.

    if ( mobileStatusHandle ||

        ( receivedCallStatus == RMobileCall::EStatusConnected ) ||

        ( receivedCallStatus == RMobileCall::EStatusIdle ) )

        {

        //this call is not anymore a ghost call

        iGhostCall = EFalse;

        //idle state indicated -> no more indications waited.

        if ( RMobileCall::EStatusIdle == receivedCallStatus )

            {