/*

* 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 );

         && iAudioStatus == ECSPCallAudioStatusActive )

        {

        iAudioStatus = ECSPCallAudioStatusInactive;

        iAudioHandler->Stop();

        }

    delete iCallEventMonitor;

    delete iCallStatusMonitor;

    delete iCallInfoMonitor;

    delete iForwardProvider;

    delete iTransferProvider;

    delete iUUIMonitor;

    delete iUUIMessageSender;

    delete iSkypeId;

    if ( iCall.SubSessionHandle() )

        {

        iCall.Close();

        }

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

    }

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

// CSPCall::SetAudioHandler

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

//

    {

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

    iAudioHandler = aHandler;

    }

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

// CSPCall::SecuritySettingChanged

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

//

void CSPCall::SecuritySettingChanged( TInt aValue )

    {

    switch ( aValue )

        {

            {

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

            NotifyCallEventOccurred( MCCPCallObserver::ECCPSecureCall );

            {

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

            NotifyCallEventOccurred( MCCPCallObserver::ECCPNotSecureCall );

            }

            {

                    "CSPCall::SecuritySettingChanged Sending SecureNotSpecified");

            NotifyCallEventOccurred( MCCPCallObserver::ECCPSecureNotSpecified );

            }

            {

            CSPLOGSTRING(CSPERROR, "CSPCall::SecuritySettingChanged, \

            }

        }

    }

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

// CSPCall::RemoteAlertingToneStatusChanged

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

//

// observer should be notified.

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

//

void CSPCall::RemoteAlertingToneStatusChanged(

    RMmCustomAPI::TRemoteAlertingToneStatus aNewStatus )

    {

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

    if ( aNewStatus == RMmCustomAPI::EUiStopTone ||

        {

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

        if ( iCallState == MCCPCallObserver::ECCPStateConnecting )

            {

                MCCPCallObserver::ECCCSPEarlyMediaStarted );

            }

        }

    }

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

// CSPCall::NotifyCallStateChangedETel

// Notifies observers about state changes

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

//

    {

                  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

                 && iAudioHandler

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

                {

                iAudioStatus = ECSPCallAudioStatusInactive;

                iAudioHandler->Stop();

                }

            // Notify error in case not going through disconnecting

                     && !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;

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

        case RMobileCall::EStatusAnswering:

            {

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

            if ( !iMobileOriginated

                && 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

        case RMobileCall::EStatusConnecting:

            {

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

                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.

            break;

            }

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

        case RMobileCall::EStatusDisconnecting:

            {

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

            if ( !iTerminationErrorNotified )

                {

                CheckAndNotifyTerminationError();

                }

            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:

            {

                "CSPCall::NotifyCallStateChangedETel DisconnectingWithInband");

            if ( !iTerminationErrorNotified )

                {

                CheckAndNotifyTerminationError();

                }

            break;

            }

        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

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

            {

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

            break;

            }

        default:

            {

                    "CSPCall::NotifyCallStateChangedETel callstate UNKNOWN");

            break;

            }

        }

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

    }

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

// CSPCall::NotifyCallEventOccurred

// Notifies observers about call events

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

//

    MCCPCallObserver::TCCPCallEvent aEvent )

    {

            "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

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

//

    {

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

    // forward the method call to CSPTransferProvider object

    iTransferProvider->TransferEventOccurred( aEvent );

    }

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

// CSPCall::NotifyForwardEventOccurred

// Notifies observers about call events

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

//

    MCCPForwardObserver::TCCPForwardEvent aEvent )

    {

    CSPLOGSTRING2(CSPINT, "CSPCall::NotifyForwardEventOccurred %d", 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;

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

                   RMobileCall::RMobileCall::EStatusUnknown )

        {

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