/*

* Copyright (c) 2007-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:  Implements class CSPCall which provides call functionality

*

*/

#include <etelmm.h>

#include <etel.h>

#include <centralrepository.h>

#include <settingsinternalcrkeys.h>

#include <ccpdefs.h>

#include <gsmerror.h>

#include <etelsat.h>

#include <cccpcallparameters.h>

#include "cspcall.h"

#include "cspetelcallrequester.h"

#include "cspetelcalleventmonitor.h"

#include "cspcallinfomonitor.h"

#include "cspetelcallstatusmonitor.h"

#include "cspetelcallcapsmonitor.h"

#include "csptransferprovider.h"

#include "cspforwardprovider.h"

#include "csplogger.h"

#include "csppanic.pan"

#include "cspconsts.h"

#include "cspaudiohandler.h"

#include "mcspcommoninfo.h"

#include "mcspsecuritysettingobserver.h"

#include "tcspskypeidparser.h"

#include "cspuuimonitor.h"

#include "cspuuimessagesender.h"

const TInt KTimesToSplitValue = 16;

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

// CSPCall::~CSPCall

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

//

CSPCall::~CSPCall()

    {

    CSPLOGSTRING(CSPOBJECT, "CSPCall::~CSPCall <");

    delete iParams;

    iCommonInfo.IndicateHangupComplete( *this );

    if ( iAudioHandler 

         && iAudioStatus == ECSPCallAudioStatusActive )

        {

        iAudioStatus = ECSPCallAudioStatusInactive;

        iAudioHandler->Stop();

        }

    delete iUserToUserInformation;    

    delete iRequester;    

    delete iCallEventMonitor;

    delete iCallStatusMonitor;

    delete iCallCapsMonitor; 

    delete iCallInfoMonitor;

    delete iForwardProvider;

    delete iTransferProvider;

    delete iUUIMonitor;

    delete iUUIMessageSender;

    delete iSkypeId;

    iObservers.Close();        

    if ( iCall.SubSessionHandle() )

        {

        iCall.Close();

        }

    CSPLOGSTRING(CSPOBJECT, "CSPCall::~CSPCall >");

    }

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

// CSPCall::SetAudioHandler

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

//

void CSPCall::SetAudioHandler( CSPAudioHandler* aHandler )

    {

    CSPLOGSTRING2(CSPINT, "CSPCall::SetAudioHandler handler: %x", aHandler);

    iAudioHandler = aHandler;

    }

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

// CSPCall::SecuritySettingChanged

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

//

void CSPCall::SecuritySettingChanged( TInt aValue )

    {

    switch ( aValue )

        {

        case MCSPSecuritySettingObserver::ESecureCall:         

            {

            CSPLOGSTRING(CSPINT, 

                    "CSPCall::SecuritySettingChanged Sending 'secure call' event");

            NotifyCallEventOccurred( MCCPCallObserver::ECCPSecureCall );

            break; 

            }            

        case MCSPSecuritySettingObserver::ENotSecureCall:                     

            {

            CSPLOGSTRING(CSPINT, 

                    "CSPCall::SecuritySettingChanged Sending 'not secure call' event");

            NotifyCallEventOccurred( MCCPCallObserver::ECCPNotSecureCall );

            break;  

            }

        case MCSPSecuritySettingObserver::ESecureNotSpecified:                     

            {

            CSPLOGSTRING(CSPINT, 

                    "CSPCall::SecuritySettingChanged Sending SecureNotSpecified");

            NotifyCallEventOccurred( MCCPCallObserver::ECCPSecureNotSpecified );

            break;  

            }

        default: 

            {

            CSPLOGSTRING(CSPERROR, "CSPCall::SecuritySettingChanged, \

                unknown event");            

            break;  

            }

        }

    }

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

// CSPCall::RemoteAlertingToneStatusChanged

// Sends EarlyMediaStarted event to observer if network has started to 

// play remote alerting tone. There is only one known use case: Network

// starts playing alerting tone during connecting state. 

//

// This RemoteAlertingToneStatusChanged is called for every call, 

// so it is calls responsibility to determine if the 

// observer should be notified.

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

//

void CSPCall::RemoteAlertingToneStatusChanged(

    RMmCustomAPI::TRemoteAlertingToneStatus aNewStatus )

    {

    CSPLOGSTRING2(CSPINT, 

        "CSPCall::RemoteAlertingToneStatusChanged new status: %d", aNewStatus );

    if ( aNewStatus == RMmCustomAPI::EUiStopTone ||

         aNewStatus == RMmCustomAPI::EUiNoTone ) // NW tells us to stop playing 

        {

        // Connecting is only state where network starts playing the tone.

        if ( iCallState == MCCPCallObserver::ECCPStateConnecting )

            {

            NotifyCallEventOccurred( 

                MCCPCallObserver::ECCCSPEarlyMediaStarted );

            }

        }

    }

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

// CSPCall::NotifyCallStateChangedETel

// Notifies observers about state changes

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

//

void CSPCall::NotifyCallStateChangedETel( RMobileCall::TMobileCallStatus aState ) 

    {

    CSPLOGSTRING3(CSPINT, 

                  "CSPCall::NotifyCallStateChangedETel < state: %d this: %x", 

                  aState, this );

    switch ( aState )

        {

        /*

        Cannot receive any mapping call statuses from ETel to following

        optional states:

        ECCPStateForwarding   MO call is being forwarded at receiver end

        ECCPStateQueued       Call is queued locally.

        The commented observer calls are for CS specific call states.

        */

        // Indicates that the call is idle or unknown.

        case RMobileCall::EStatusIdle:

        case RMobileCall::EStatusUnknown:

            {

            CSPLOGSTRING(CSPINT, "CSPCall::NotifyCallStateChangedETel Idle");

            // If audio still active

            if ( iAudioStatus == ECSPCallAudioStatusActive 

                 && iAudioHandler

                 && iParams->CallType() == CCPCall::ECallTypeCSVoice )

                {

                iAudioStatus = ECSPCallAudioStatusInactive;

                iAudioHandler->Stop();

                }

            // Notify error in case not going through disconnecting

            if ( iCallState != MCCPCallObserver::ECCPStateDisconnecting 

                     && !iTerminationErrorNotified )

                {

                CheckAndNotifyTerminationError();

                }

            NotifyCallStateChanged( MCCPCallObserver::ECCPStateIdle );

            iCommonInfo.IndicateHangupComplete( *this );

            break;

            }

        // The call is dialling.

        case RMobileCall::EStatusDialling:

            CSPLOGSTRING(CSPINT, "CSPCall callstate Dialling");

            {

            if ( iAudioHandler && iParams->CallType() == CCPCall:: ECallTypeCSVoice )

                {

                iAudioStatus = ECSPCallAudioStatusActive;

                iAudioHandler->Start();

                }

            iDontReportTerm = EFalse;

            NotifyCallStateChanged( MCCPCallObserver::ECCPStateDialling );

            break;

            }            

        //Indicates that the MT call is ringing but not answered yet by 

        // the local user

        case RMobileCall::EStatusRinging:

            {

            CSPLOGSTRING(CSPINT, "CSPCall::NotifyCallStateChangedETel Ringing");

            NotifyCallStateChanged( MCCPCallObserver::ECCPStateRinging );

            break;

            }

        // Indicates that the local user has answered the MT call but

        // the network has not acknowledged the call connection yet. 

        case RMobileCall::EStatusAnswering:

            {

            CSPLOGSTRING(CSPINT, "CSPCall::NotifyCallStateChangedETel Answering");

            if ( !iMobileOriginated

                && iAudioHandler 

                && iAudioStatus == ECSPCallAudioStatusInactive

                && iParams->CallType() == CCPCall::ECallTypeCSVoice )

                {

                iAudioStatus = ECSPCallAudioStatusActive;

                iAudioHandler->Start();

                }

            NotifyCallStateChanged( MCCPCallObserver::ECCPStateAnswering );

            break;

            }

        // MO Call: the network notifies to the MS that the remote party

        // is now ringing. 

        case RMobileCall::EStatusConnecting:

            {

            CSPLOGSTRING(CSPINT, "CSPCall::NotifyCallStateChangedETelConnecting");

            RMmCustomAPI::TRemoteAlertingToneStatus tone = 

                iCommonInfo.GetRemoteAlertingToneStatus();

            if ( tone == RMmCustomAPI::EUiNoTone ||

                 tone == RMmCustomAPI::EUiStopTone )

                {

                NotifyCallStateChangedWithInband( MCCPCallObserver::ECCPStateConnecting );

                }

            else

                {

                NotifyCallStateChanged( MCCPCallObserver::ECCPStateConnecting );

                }

            break;

            }

        // Indicates that call is connected and active.

        case RMobileCall::EStatusConnected:

            {

            CSPLOGSTRING(CSPINT, "CSPCall::NotifyCallStateChangedETel Connected");

            iDontReportTerm = ETrue;

            NotifyCallStateChanged( MCCPCallObserver::ECCPStateConnected );

            // Agreement with TSY is that the

            // COLP number is available in connected state.

            NotifyRemotePartyNumberChanged();            

            break;

            }

        // Indicates that call is disconnecting. (Same as RCall::HangingUp)

        case RMobileCall::EStatusDisconnecting:

            {

            CSPLOGSTRING(CSPINT, "CSPCall::NotifyCallStateChangedETel Disconnecting");

            if ( !iTerminationErrorNotified )

                {

                CheckAndNotifyTerminationError();

                }

            NotifyCallStateChanged( MCCPCallObserver::ECCPStateDisconnecting );                

            break;

            }

        // Indicates that the call is disconnecting with inband data

        // (to enable the network to send an audio tone), signifying

        // that the call is not to be released until user terminates call

        case RMobileCall::EStatusDisconnectingWithInband:

            {

            CSPLOGSTRING(CSPINT, 

                "CSPCall::NotifyCallStateChangedETel DisconnectingWithInband");

            if ( !iTerminationErrorNotified )

                {

                CheckAndNotifyTerminationError();

                }

            NotifyCallStateChangedWithInband( 

                                MCCPCallObserver::ECCPStateDisconnecting );

            break;

            }

        // Indicates that the call is connected but on hold.  

        case RMobileCall::EStatusHold:

            {

            CSPLOGSTRING(CSPINT, "CSPCall::NotifyCallStateChangedETel Hold");

            NotifyCallStateChanged( MCCPCallObserver::ECCPStateHold );

            break;

            }

        case RMobileCall::EStatusTransferring:

            {

            CSPLOGSTRING(CSPINT, "CSPCall::NotifyCallStateChangedETel Transferring");

            NotifyCallStateChanged( MCCPCallObserver::ECCPStateTransferring );

            break;

            }

        // Indicates that call is undergoing temporary channel loss

        // and it may or may not be reconnected.  

        case RMobileCall::EStatusReconnectPending: // fall through 

        //Indicates that the call is the non-active half of an alternating

        // call. This call is waiting for its active half or the remote

        // end to switch alternating call mode.

        case RMobileCall::EStatusWaitingAlternatingCallSwitch: // fall through

        case RMobileCall::EStatusTransferAlerting:

            {

            CSPLOGSTRING2(CSPINT, 

                    "CSPCall::NotifyCallStateChangedETel no special handling for state %d",

                    aState);            

            break;

            }

        default:

            {

            CSPLOGSTRING(CSPERROR, 

                    "CSPCall::NotifyCallStateChangedETel callstate UNKNOWN");

            break;

            }

        }

    CSPLOGSTRING(CSPREQIN, "CSPCall::NotifyCallStateChangedETel >");

    }

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

// CSPCall::NotifyCallEventOccurred

// Notifies observers about call events

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

//

void CSPCall::NotifyCallEventOccurred( 

    MCCPCallObserver::TCCPCallEvent aEvent )

    {

    CSPLOGSTRING2(CSPINT, 

            "CSPCall::NotifyCallEventOccurred < event: %d", aEvent);

    TInt obsCount = iObservers.Count();

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

        {

        CSPLOGSTRING2(CSPINT, "CSPCall::NotifyCallEventOccurred obs=%d",i);

        MCCPCallObserver *obs = iObservers[i];

        if ( obs )

            {

            obs->CallEventOccurred( aEvent, this );

            }

        CSPLOGSTRING2(CSPINT, "CSPCall::NotifyCallEventOccurred ok obs=%d",i);

        }

    CSPLOGSTRING2(CSPINT, "CSPCall::NotifyCallEventOccurred > event: %d", aEvent);

    }

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

// CSPCall::NotifyTransferCallEventOccurred

// Forward notification of transfer event to it's provider

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

//

void CSPCall::NotifyTransferCallEventOccurred( 

    MCCPTransferObserver::TCCPTransferEvent aEvent ) 

    {

    CSPLOGSTRING2(CSPINT, "CSPCall::NotifyTransferCallEventOccurred %d", aEvent);

    // forward the method call to CSPTransferProvider object

    iTransferProvider->TransferEventOccurred( aEvent );

    }

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

// CSPCall::NotifyForwardEventOccurred

// Notifies observers about call events

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

//

void CSPCall::NotifyForwardEventOccurred( 

    MCCPForwardObserver::TCCPForwardEvent aEvent )

    {

    CSPLOGSTRING2(CSPINT, "CSPCall::NotifyForwardEventOccurred %d", aEvent);

    iForwardProvider->NotifyForwardEventOccurred( aEvent );    

    }

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

// CSPCall::CallName

// Get call name

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

//

void CSPCall::CallName( TName& aCallName )

    {

    CSPLOGSTRING(CSPINT, "CSPCall::CallName");

    aCallName.Zero();

    aCallName.Append( iCallName );

    }

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

// CSPCall::DialRequestFailed

// Handles situations when dial fails

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

//

void CSPCall::DialRequestFailed( TInt aErrorCode )

    {

    CSPLOGSTRING(CSPERROR, "CSPCall::DialRequestFailed");

    iDialCompletionCode = aErrorCode;

    // If state has not changed 

    // ( e.g. in case of dial could not be initiated by network problem)

    if ( iCallStatusMonitor->State() == 

                   RMobileCall::RMobileCall::EStatusUnknown )

        {

	    NotifyErrorOccurred( iRequester->MapError( aErrorCode ) );	        	

        // Force release since otherwise call remains unreleased

        CSPLOGSTRING(CSPERROR, "CSPCall::DialRequestFailed() Force Idle");

        NotifyCallStateChanged( MCCPCallObserver::ECCPStateIdle );

        }

    // If dial request has completed after notifying disconnecting state

    else if ( iCallState == MCCPCallObserver::ECCPStateDisconnecting

             && !iTerminationErrorNotified )

        {

        CheckAndNotifyTerminationError();

        }

    }

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

// CSPCall::EmergencyDialRequestFailed

// Handles situations when emergency dial fails

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

//

void CSPCall::EmergencyDialRequestFailed( TInt /*aErrorCode*/ )

    {

    CSPLOGSTRING(CSPERROR, "CSPCall::EmergencyDialRequestFailed");

    // Always same error code for CCE

    NotifyErrorOccurred( ECCPEmergencyFailed );

    // Mark that exit code will not be used

    iTerminationErrorNotified = ETrue;

    }

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

// CSPCall::NotifyErrorOccurred

// Notifies observers about errors

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

//

void CSPCall::NotifyErrorOccurred( TCCPError aError )

    {

    CSPLOGSTRING2(CSPERROR, "CSPCall::NotifyErrorOccurred err %d", aError );

    TInt obsCount = iObservers.Count();

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

        {

        MCCPCallObserver *obs = iObservers[i];

        if ( obs )

            {

            obs->ErrorOccurred( aError, this );

            }

        }

    }

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

// CSPCall::CallCapsChanged

// Notifies observers about new capabilities.

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

//

void CSPCall::CallCapsChanged( const TUint32 aCapsFlags )

    {

    CSPLOGSTRING2(CSPERROR, "CSPCall::CallCapsChanged %b", aCapsFlags );

    iCapsFlags = aCapsFlags;

    TInt obsCount = iObservers.Count();

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

        {

        MCCPCallObserver *obs = iObservers[i];

        if ( obs )

            {

            obs->CallCapsChanged( aCapsFlags, this );

            }

        }

    }

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

// From class MCCPCSCall

// CSPCall::GetMobileCallInfo

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

//

TInt CSPCall::GetMobileCallInfo( TDes8& aCallInfo ) const

    {

    CSPLOGSTRING(CSPINT, "CSPCall::GetMobileCallInfo");

    return iCall.GetMobileCallInfo( aCallInfo );

    }

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

// From class MCCPCSCall

// CSPCall::GetMobileDataCallCaps

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

//

TInt CSPCall::GetMobileDataCallCaps( TDes8& /*aCaps*/ ) const

    {

    CSPLOGSTRING(CSPERROR, 

            "CSPCall::GetMobileDataCallCaps ERROR, Not supported");

    return KErrNotSupported;

    }

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

// From class MCCPCall