--- a/convergedcallengine/csplugin/src/cspcall.cpp Thu Aug 19 10:28:14 2010 +0300
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,1971 +0,0 @@
-/*
-* 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
- || iParams->CallType() == CCPCall::ECallTypeVideo ) )
- {
- 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");
- {
- // Start streams also for MO video call to prevent audio routing problems
- // with other applications.
- if ( iAudioHandler
- && ( iParams->CallType() == CCPCall::ECallTypeCSVoice
- || iParams->CallType() == CCPCall::ECallTypeVideo ) )
- {
- 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();
-
- // Stop streams for MO video call so that Video Telephony can
- // receive RemCon commands instead of Phone.
- if ( iMobileOriginated
- && iAudioHandler
- && iAudioStatus == ECSPCallAudioStatusActive
- && iParams->CallType() == CCPCall::ECallTypeVideo )
- {
- iAudioStatus = ECSPCallAudioStatusInactive;
- iAudioHandler->Stop();
- }
- 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
-// CSPCall::Dial
-// ---------------------------------------------------------------------------
-//
-TInt CSPCall::Dial()
- {
- CSPLOGSTRING( CSPREQIN, "CSPCall::Dial" );
- // Parameters not given, must create empty descriptor.
- TBuf8<1> params;
- return Dial(params);
- }
-
-// ---------------------------------------------------------------------------
-// From class MCCPCall
-// CSPCall::RemoteParty
-// ---------------------------------------------------------------------------
-//
-const TDesC& CSPCall::RemoteParty() const
- {
- CSPLOGSTRING(CSPREQIN, "CSPCall::RemoteParty");
- return iRemotePartyNumber;
- }
-
-// ---------------------------------------------------------------------------
-// From class MCCPCall
-// CSPCall::RemotePartyName
-// ---------------------------------------------------------------------------
-//
-const TDesC& CSPCall::RemotePartyName()
- {
- CSPLOGSTRING(CSPREQIN, "CSPCall::RemotePartyName");
- return iRemotePartyName;
- }
-
-// ---------------------------------------------------------------------------
-// From class MCCPCall
-// CSPCall::DialledParty
-// ---------------------------------------------------------------------------
-//
-const TDesC& CSPCall::DialledParty() const
- {
- CSPLOGSTRING2(CSPREQIN, "CSPCall::DialledParty %S", &iRemotePartyNumber);
- return iRemotePartyNumber;
- }
-
-// ---------------------------------------------------------------------------
-// From class MCCPCall
-// CSPCall::Answer
-// ---------------------------------------------------------------------------
-//
-TInt CSPCall::Answer()
- {
- CSPLOGSTRING(CSPREQIN, "CSPCall::Answer <");
- TInt ret( KErrNone );
-
- if ( iCallState == MCCPCallObserver::ECCPStateRinging
- || iCallState == MCCPCallObserver::ECCPStateQueued )
- {
- if( iMobileOriginated )
- {
- ret = KErrGeneral;
- }
- else if( iCallState != MCCPCallObserver::ECCPStateRinging &&
- iCallState != MCCPCallObserver::ECCPStateQueued )
- {
- ret = KErrAccessDenied;
- }
- else
- {
- ret = iCommonInfo.IndicateAnswerRequest( *this );
- }
- }
- else
- {
- // Not correct state for answer
- ret = KErrNotReady;
- }
-
- CSPLOGSTRING2(CSPREQIN, "CSPCall::Answer > ret %d", ret);
- return ret;
- }
-
-// ---------------------------------------------------------------------------
-// From class MCCPCallCommandHandling
-// CSPCall::PerformAnswerRequest
-// ---------------------------------------------------------------------------
-//
-TInt CSPCall::PerformAnswerRequest()
- {
- CSPLOGSTRING(CSPREQIN, "CSPCall::PerformAnswerRequest");
-
- TInt ret = iRequester->MakeRequest( CSPEtelCallRequester::ERequestTypeAnswer );
- CSPLOGSTRING3(CSPINT,
- "CSPCall::Answer request performed, call state %d ret: %d", iCallState, ret);
-
- return ret;
- }
-
-// ---------------------------------------------------------------------------
-// From class MCCPCall
-// CSPCall::Reject
-// ---------------------------------------------------------------------------
-//
-TInt CSPCall::Reject()
- {
- CSPLOGSTRING(CSPREQIN, "CSPCall::Reject <");
- TInt ret;
- if ( iCallState == MCCPCallObserver::ECCPStateRinging
- || iCallState == MCCPCallObserver::ECCPStateQueued
- || iCallState == MCCPCallObserver::ECCPStateAnswering )
- {
- CSPLOGSTRING( CSPREQIN, "CSPCall::Reject 2" );
- ret = HangUp();
- }
- else
- {
- ret = KErrNotReady;
- }
- CSPLOGSTRING2(CSPREQIN, "CSPCall::Reject > ret: %d", ret );
- return ret;
- }
-
-// ---------------------------------------------------------------------------
-// From class MCCPCall
-// CSPCall::Queue
-// ---------------------------------------------------------------------------
-//
-TInt CSPCall::Queue()
- {
- CSPLOGSTRING(CSPREQIN, "CSPCall::Queue");
- TBool callWaitingState;
- iDontReportTerm = ETrue;
-
- TRAPD( res, iCommonInfo.GetCallWaitingL( *iParams, callWaitingState ) );
- if( res == KErrNone )
- {
- if ( callWaitingState )
- {
- CSPLOGSTRING(CSPREQIN, "CSPCall::Queue Call Waiting On");
- iCallState = MCCPCallObserver::ECCPStateQueued;
-
- // Notify Queued state
- TInt obsCount = iObservers.Count ( );
- for (TInt i = 0; i < obsCount; i++ )
- {
- MCCPCallObserver *obs = iObservers[i];
- if ( obs )
- {
- obs->CallStateChanged ( iCallState, this );
- }
- }
- CSPLOGSTRING(CSPOBJECT, "CSPCall::Queue ok");
-
- return KErrNone;
- }
- else
- {
- CSPLOGSTRING(CSPREQIN, "CSPCall::Queue Call Waiting Off");
- }
- }
- else
- {
- CSPLOGSTRING2(CSPERROR,
- "CSPCall::Queue Error %d with CR. Call Waiting Off",
- res);
- }
-
- return KErrNotSupported;
- }
-
-// ---------------------------------------------------------------------------
-// From class MCCPCall
-// CSPCall::Ringing
-// ---------------------------------------------------------------------------
-//
-TInt CSPCall::Ringing()
- {
- CSPLOGSTRING(CSPREQIN, "CSPCall::Ringing");
- iDontReportTerm = ETrue;
-
- // Ringing state is accepted because MT-call goes to ringing
- // state in the beginning based on ETel state maching.
- if ( iCallState == MCCPCallObserver::ECCPStateIdle ||
- iCallState == MCCPCallObserver::ECCPStateRinging )
- {
- NotifyRingingState();
- return KErrNone;
- }
- else if ( iCallState == MCCPCallObserver::ECCPStateAnswering )
- {
- // Do nothing if already in Answering state (autoanswer).
- return KErrNone;
- }
-
- return KErrNotReady;
- }
-
-// ---------------------------------------------------------------------------
-// From class MCCPCall
-// CSPCall::HangUp
-// ---------------------------------------------------------------------------
-//
-TInt CSPCall::HangUp()
- {
- CSPLOGSTRING2(CSPREQIN, "CSPCall::HangUp this: %x", this);
- TInt ret( KErrNone );
-
- CSPEtelCallRequester::TRequestType req = iRequester->Request();
- if ( req == CSPEtelCallRequester::ERequestTypeDial ||
- ( req == CSPEtelCallRequester::ERequestTypeDialEmergency ) )
- {
- CSPLOGSTRING(CSPREQIN, "CSPCall::HangUp 1: Cancel ongoing dial");
- ret = iRequester->DialCancel();
- CSPLOGSTRING(CSPREQIN, "CSPCall::HangUp Canceled");
- }
- else if ( req == CSPEtelCallRequester::ERequestTypeHangup )
- {
- CSPLOGSTRING(CSPREQIN, "CSPCall::HangUp 2");
- ret = KErrAlreadyExists;
- }
- else if ( req == CSPEtelCallRequester::ERequestTypeNone
- && iCallState != MCCPCallObserver::ECCPStateIdle )
- {
- CSPLOGSTRING(CSPREQIN, "CSPCall::HangUp 3");
- ret = iRequester->MakeRequest( CSPEtelCallRequester::ERequestTypeHangup );
- iCommonInfo.IndicateActiveHangup( *this );
- }
- else if ( req == CSPEtelCallRequester::ERequestTypeNone )
- {
- CSPLOGSTRING(CSPREQIN, "CSPCall::HangUp 4");
- ret = KErrAlreadyExists;
- }
- else
- {
- CSPLOGSTRING(CSPREQIN, "CSPCall::HangUp 5");
- // Request pending, must be canceled
- iRequester->Cancel();
- ret = iRequester->MakeRequest( CSPEtelCallRequester::ERequestTypeHangup );
- iCommonInfo.IndicateActiveHangup( *this );
- }
-
- return ret;
- }
-
-// ---------------------------------------------------------------------------
-// From class MCCPCall
-// CSPCall::Cancel
-// ---------------------------------------------------------------------------
-//
-TInt CSPCall::Cancel()
- {
- CSPLOGSTRING(CSPREQIN, "CSPCall::Cancel");
- return HangUp();
- }
-
-// ---------------------------------------------------------------------------
-// From class MCCPCall
-// CSPCall::Hold
-// ---------------------------------------------------------------------------
-//
-TInt CSPCall::Hold()
- {
- CSPLOGSTRING2(CSPREQIN, "CSPCall::Hold this: %x", this);
- TInt ret;
-
- if ( iCallState == MCCPCallObserver::ECCPStateConnected )
- {
- CSPLOGSTRING(CSPREQOUT, "CSPCall::Hold make request");
-
- // Set call on hold
- ret = iRequester->MakeRequest(
- CSPEtelCallRequester::ERequestTypeHold );
- if ( ret != KErrNone )
- {
- CSPLOGSTRING2(CSPERROR,
- "CSPCall::Hold ERROR: %d", ret);
- }
- }
- else if ( iCallState == MCCPCallObserver::ECCPStateHold )
- {
- CSPLOGSTRING(CSPERROR, "CSPCall::Hold : already held");
- ret = KErrAlreadyExists;
- }
- else
- {
- CSPLOGSTRING(CSPERROR, "CSPCall::Hold not allowed");
- ret = KErrNotReady;
- }
-
- return ret;
- }
-
-// ---------------------------------------------------------------------------
-// From class MCCPCall
-// CSPCall::Resume
-// ---------------------------------------------------------------------------
-//
-TInt CSPCall::Resume()
- {
- CSPLOGSTRING2(CSPREQIN, "CSPCall::Resume this: %x", this);
- TInt ret;
-
- if ( iCallState == MCCPCallObserver::ECCPStateHold )
- {
- CSPLOGSTRING(CSPREQOUT, "CSPCall::Resume request");
-
- ret = iRequester->MakeRequest(
- CSPEtelCallRequester::ERequestTypeResume );
- if ( KErrNone != ret )
- {
- CSPLOGSTRING2(CSPERROR, "CSPCall::Resume ERROR %d", ret);
- }
- }
- else if ( iCallState == MCCPCallObserver::ECCPStateConnected )
- {
- CSPLOGSTRING(CSPERROR, "CSPCall::Resume already connected" );
- ret = KErrAlreadyExists;
- }
- else
- {
- CSPLOGSTRING(CSPERROR, "CSPCall::Resume not held state" );
- ret = KErrNotReady;
- }
-
- return ret;
- }
-
-// ---------------------------------------------------------------------------
-// From class MCCPCall
-// CSPCall::Swap
-// ---------------------------------------------------------------------------
-//
-TInt CSPCall::Swap()
- {
- CSPLOGSTRING2(CSPREQIN, "CSPCall::Swap this: %x", this);
- TInt ret;
- if ( iCallState == MCCPCallObserver::ECCPStateConnected
- || iCallState == MCCPCallObserver::ECCPStateHold )
- {
- ret = iRequester->MakeRequest( CSPEtelCallRequester::ERequestTypeSwap );
- if ( ret )
- {
- CSPLOGSTRING2( CSPERROR, "CSPCall::Swap Error %d", ret );
- }
- }
- else
- {
- ret = KErrNotReady;
- }
- return ret;
- }
-
-// ---------------------------------------------------------------------------
-// From class MCCPCall
-// CSPCall::IsMobileOriginated
-// ---------------------------------------------------------------------------
-//
-TBool CSPCall::IsMobileOriginated() const
- {
- CSPLOGSTRING(CSPREQIN, "CSPCall::IsMobileOriginated");
- return iMobileOriginated;
- }
-
-// ---------------------------------------------------------------------------
-// From class MCCPCall
-// CSPCall::State
-// ---------------------------------------------------------------------------
-//
-MCCPCallObserver::TCCPCallState CSPCall::State() const
- {
- CSPLOGSTRING2(CSPREQIN, "CSPCall::State %d", iCallState);
- return iCallState;
- }
-
-// ---------------------------------------------------------------------------
-// From class MCCPCall
-// CSPCall::Uid
-// ---------------------------------------------------------------------------
-//
-TUid CSPCall::Uid() const
- {
- CSPLOGSTRING2(CSPREQIN, "CSPCall::Uid %d", KCSPImplementationUid);
- return KCSPImplementationUid;
- }
-
-// ---------------------------------------------------------------------------
-// From class MCCPCall
-// CSPCall::Caps
-// ---------------------------------------------------------------------------
-//
-MCCPCallObserver::TCCPCallControlCaps CSPCall::Caps( ) const
- {
- CSPLOGSTRING2(CSPREQIN, "CSPCall::Caps %b", iCapsFlags );
- return (MCCPCallObserver::TCCPCallControlCaps) iCapsFlags;
- }
-
-// ---------------------------------------------------------------------------
-// From class MCCPCall
-// CSPCall::SetParameters
-// ---------------------------------------------------------------------------
-//
-void CSPCall::SetParameters( const CCCPCallParameters& /*aNewParams*/ )
- {
- CSPLOGSTRING(CSPOBJECT, "CSPCall::SetParameters ERROR Can't set params");
- }
-
-// ---------------------------------------------------------------------------
-// From class MCCPCall
-// CSPCall::Parameters
-// ---------------------------------------------------------------------------
-//
-const CCCPCallParameters& CSPCall::Parameters() const
- {
- CSPLOGSTRING(CSPINT, "CSPCall::Parameters");
- return *iParams;
- }
-
-// ---------------------------------------------------------------------------
-// From class MCCPCall
-// CSPCall::TransferProvider
-// ---------------------------------------------------------------------------
-//
-MCCPTransferProvider* CSPCall::TransferProviderL(const MCCPTransferObserver&
- aObserver )
- {
- CSPLOGSTRING(CSPREQIN, "CSPCall::TransferProvider");
- iTransferProvider->AddObserverL( aObserver );
- return iTransferProvider;
- }
-
-// ---------------------------------------------------------------------------
-// From class MCCPCall
-// CSPCall::ForwardProvider
-// ---------------------------------------------------------------------------
-//
-MCCPForwardProvider* CSPCall::ForwardProviderL(
- const MCCPForwardObserver& aObserver )
- {
- CSPLOGSTRING(CSPREQIN, "CSPCall::ForwardProvider");
- iForwardProvider->AddObserverL( aObserver );
- return iForwardProvider;
- }
-
-// ---------------------------------------------------------------------------
-// From class MCCPCall
-// CSPCall::AddObserverL
-// ---------------------------------------------------------------------------
-//
-void CSPCall::AddObserverL( const MCCPCallObserver& aObserver )
- {
- CSPLOGSTRING2(CSPREQIN, "CSPCall::AddObserverL %x", &aObserver);
- if ( iObservers.Find( &aObserver ) == KErrNotFound )
- {
- iObservers.AppendL( &aObserver );
- }
- }
-
-// ---------------------------------------------------------------------------
-// From class MCCPCall
-// Removes observer.
-// ---------------------------------------------------------------------------
-//
-TInt CSPCall::RemoveObserver( const MCCPCallObserver& aObserver )
- {
- CSPLOGSTRING2(CSPREQIN, "CSPCall::RemoveObserver %x", &aObserver);
-
- TInt found = iObservers.Find( &aObserver );
- if ( found != KErrNotFound )
- {
- iObservers.Remove( found );
- return KErrNone;
- }
-
- return found;
- }
-
-// ---------------------------------------------------------------------------
-// From class MCCPCall
-// CSPCall::IsCallForwarded
-// ---------------------------------------------------------------------------
-//
-TBool CSPCall::IsCallForwarded( ) const
- {
- CSPLOGSTRING(CSPREQIN, "CSPCall::IsCallForwarded <");
- TBool ret( EFalse );
- TInt err( KErrNone );
- RMobileCall::TMobileCallInfoV3 callInfo;
- RMobileCall::TMobileCallInfoV3Pckg pck( callInfo );
- err = iCall.GetMobileCallInfo( pck );
- if (err == KErrNone )
- {
- ret = callInfo.iForwarded;
- }
-
- CSPLOGSTRING2(CSPREQIN,
- "CSPCall::IsCallForwarded > forwarder: %d", ret );
-
- return ret;
- }
-
-// ---------------------------------------------------------------------------
-// From class MCCPCall
-// CSPCall::IsSecured
-// ---------------------------------------------------------------------------
-//
-TBool CSPCall::IsSecured( ) const
- {
- CSPLOGSTRING(CSPREQIN, "CSPCall::IsSecured");
- return iCommonInfo.NetworkSecurityStatus();
- }
-
-// ---------------------------------------------------------------------------
-// From class MCCPCall
-// CSPCall::SecureSpecified
-// ---------------------------------------------------------------------------
-//
-TBool CSPCall::SecureSpecified( ) const
- {
- CSPLOGSTRING(CSPREQIN, "CSPCall::SecureSpecified");
- return iCommonInfo.SecureSpecified();
- }
-
-// ---------------------------------------------------------------------------
-// From class MCCPCall
-// CSPCall::Tone
-// ---------------------------------------------------------------------------
-//
-TCCPTone CSPCall::Tone() const
- {
- CSPLOGSTRING(CSPREQIN, "CSPCall::Tone <");
- TCCPTone tone( ECCPNoSoundSequence );
-
- if ( iCallState == MCCPCallObserver::ECCPStateConnecting )
- {
- RMmCustomAPI::TRemoteAlertingToneStatus ts = iCommonInfo.GetRemoteAlertingToneStatus();
-
- if (ts == RMmCustomAPI::EUiRbtTone )
- {
- tone = ECCPRemoteAlerting;
- }
- else if ( ts == RMmCustomAPI::EUiStopTone )
- {
- tone = ECCPNoSoundSequence;
- }
- else
- {
- // No tone
- tone = ECCPNoSoundSequence;
- }
- }
- else
- {
- // Handle disconnecting tones
- TInt callDisconnectingError = ExitCodeError();
- CSPLOGSTRING2(CSPINT, "CSPCall::Tone exit code err: %d", callDisconnectingError);
-
- switch( callDisconnectingError )
- {
- case KErrNone:
- // GSM: DIAL TONE (optional) - not used in Nokia phones
- CSPLOGSTRING(CSPERROR, "CSPCall::Tone: No sound");
- break;
- case KErrGsmCCUserBusy:
- // GSM: SUBSCRIBER BUSY
- tone = ECCPToneUserBusy;
- CSPLOGSTRING(CSPINT, "CSPCall::Tone: Subscriber Busy");
- break;
- // Fall through
- case KErrGsmCCNumberChanged:
- case KErrGsmCCResponseToStatusEnquiry:
- case KErrGsmCCNormalUnspecified:
- // GSM: NONE, Nokia phones: radio path not available
- tone = ECCPToneRadioPathNotAvailable;
- CSPLOGSTRING(CSPINT, "CSPCall::Tone: RadioPathNotAvailable");
- break;
- case KErrGsmCCNoChannelAvailable:
- case KErrGsmCCTemporaryFailure:
- case KErrGsmCCSwitchingEquipmentCongestion:
- case KErrGsmCCRequestedChannelNotAvailable:
- case KErrGsmCCQualityOfServiceNotAvailable:
- case KErrGsmCCBearerCapabilityNotCurrentlyAvailable:
- // GSM: CONGESTION
- tone = ECCPToneCongestion;
- CSPLOGSTRING(CSPINT, "CSPCall::Tone: Congestion");
- break;
- case KErrGsmCCUnassignedNumber:
- case KErrGsmCCNoRouteToDestination:
- case KErrGsmCCChannelUnacceptable:
- case KErrGsmCCOperatorDeterminedBarring:
- case KErrGsmCCUserNotResponding:
- case KErrGsmCCUserAlertingNoAnswer:
- case KErrGsmCCCallRejected:
- case KErrGsmCCNonSelectedUserClearing:
- case KErrGsmCCDestinationOutOfOrder:
- case KErrGsmCCInvalidNumberFormat:
- case KErrGsmCCFacilityRejected:
- case KErrGsmCCNetworkOutOfOrder:
- case KErrGsmCCAccessInformationDiscarded:
- case KErrGsmCCResourceNotAvailable:
- case KErrGsmCCRequestedFacilityNotSubscribed:
- case KErrGsmCCIncomingCallsBarredInCug:
- case KErrGsmCCBearerCapabilityNotAuthorised:
- case KErrGsmCCServiceNotAvailable:
- case KErrGsmCCBearerServiceNotImplemented:
- case KErrGsmCCChannelTypeNotImplemented:
- case KErrGsmCCAcmGreaterThanAcmMax:
- case KErrGsmCCRequestedFacilityNotImplemented:
- case KErrGsmCCOnlyRestrictedDigitalInformationBCAvailable:
- case KErrGsmCCServiceNotImplemented:
- case KErrGsmCCInvalidCallReferenceValue:
- case KErrGsmCCChannelDoesNotExist:
- case KErrGsmCCSuspendedCallExistsButCallIdentityDoesNotWork:
- case KErrGsmCCCallIdentityInUse:
- case KErrGsmCCNoCallSuspended:
- case KErrGsmCCRequestedCallIdentityAlreadyCleared:
- case KErrGsmCCUserNotInCug:
- case KErrGsmCCIncompatibleDestination:
- case KErrGsmCCInvalidTransitNetworkSelection:
- case KErrGsmCCIncompatibleSegmentedMessage:
- case KErrGsmCCSemanticallyIncorrectMessage:
- case KErrGsmCCInvalidMandatoryInformation:
- case KErrGsmCCNonExistentMessageType:
- case KErrGsmCCIncompatibleMessageInProtocolState:
- case KErrGsmCCNonExistentInformationElement:
- case KErrGsmCCConditionalIEError:
- case KErrGsmCCIncompatibleMessageInCallState:
- case KErrGsmCCRecoveryOnTimerExpiry:
- case KErrGsmCCUnspecifiedProtocolError:
- case KErrGsmCCUnspecifiedInterworkingError:
- // GSM: SPECIAL INFORMATION
- tone = ECCPToneSpecialInformation;
- CSPLOGSTRING(CSPINT, "CSPCall::Tone: Special Information");
- break;
- default:
- CSPLOGSTRING(CSPERROR, "CSPCall::Tone: ERROR not found");
- break;
- }
- }
-
- CSPLOGSTRING2(CSPREQIN, "CSPCall::Tone > tone: %d", tone);
- return tone;
- }
-
-// ---------------------------------------------------------------------------
-// From class MCCPCSCall
-// CSPCall::NoFdnCheck
-// ---------------------------------------------------------------------------
-//
-void CSPCall::NoFDNCheck( )
- {
- CSPLOGSTRING(CSPREQIN, "CSPCall::NoFDNCheck");
- iFdnCheck = EFalse;
- }
-
-// ---------------------------------------------------------------------------
-// CSPCall::LogDialedNumber
-// ---------------------------------------------------------------------------
-//
-TBool CSPCall::LogDialedNumber() const
- {
- CSPLOGSTRING(CSPREQIN, "CSPCall::LogDialedNumber true");
- return ETrue;
- }
-
-// ---------------------------------------------------------------------------
-// From class MCCPCSCall
-// CSPCall::Dial
-// ---------------------------------------------------------------------------
-//
-TInt CSPCall::Dial( const TDesC8& /*aCallParams*/ )
- {
- CSPLOGSTRING(CSPREQIN, "CSPCall::Dial");
- return iCommonInfo.IndicateDialRequest( *this );
- }
-
-// ---------------------------------------------------------------------------
-// From class MCCPCallCommandHandling
-// CSPCall::PerformDialRequest
-// ---------------------------------------------------------------------------
-//
-TInt CSPCall::PerformDialRequest()
- {
- CSPLOGSTRING(CSPREQIN, "CSPCall::PerformDialRequest");
- iDialCompletionCode = KErrNone;
- iTerminationErrorNotified = EFalse;
-
- // Send the User to User Information.
- if( iUserToUserInformation->Length() )
- {
- iUUIMessageSender->SendUUIMessage( *iUserToUserInformation );
- }
-
- return DialFdnCond( iFdnCheck );
- }
-
-// ---------------------------------------------------------------------------
-// CSPCall::CSPCall
-// ---------------------------------------------------------------------------
-//
-CSPCall::CSPCall( RMobileLine& aLine,
- TBool aMobileOriginated,
- const TDesC& aName,
- MCSPCommonInfo& aCommonInfo,
- TBool aIsEmergencyCall ) :
- iLine( aLine ),
- iMobileOriginated( aMobileOriginated ),
- iName( aName ),
- iCommonInfo( aCommonInfo ),
- iTerminationErrorNotified( EFalse ),
- iIsEmergencyCall( aIsEmergencyCall),
- iFdnCheck(ETrue),
- iAudioStatus( ECSPCallAudioStatusInactive )
-
- {
- CSPLOGSTRING(CSPOBJECT, "CSPCall::CSPCall");
- }
-
-// ---------------------------------------------------------------------------
-// CSPCall::ConstructL
-// Constructing CSPCall in 2nd phase
-// ---------------------------------------------------------------------------
-//
-void CSPCall::ConstructL( const CCCECallParameters& aParams )
- {
- CSPLOGSTRING(CSPOBJECT, "CSPCall::ConstructL <");
-
- // Create cloned copy of call parameters
- iParams = static_cast<CCCECallParameters*>( aParams.CloneL() );
-
- // Open call handle
- OpenCallHandleL();
-
- // Update call info
- UpdateCallInfo();
-
- // Update call state from ETel
- UpdateCallState();
-
- // Create call handlers for call related requests
- // and for monitoring call related events
- CreateCallHandlersL();
-
- CSPLOGSTRING(CSPOBJECT, "CSPCall::ConstructL >");
- }
-
-// ---------------------------------------------------------------------------
-// CSPCall::OpenCallHandleL
-// Open call handle, calls either OpenNewCallL or OpenExistingCallL depending
-// of the call direction and if the call is a client call
-// ---------------------------------------------------------------------------
-//
-void CSPCall::OpenCallHandleL()
- {
- CSPLOGSTRING(CSPINT, "CSPCall::OpenCallHandleL <");
-
- if ( iMobileOriginated )
- {
- // There is no existing call on line, open new call
- OpenNewCall();
- }
- else
- {
- // Mobile terminated call on line, open existing call
- OpenExistingCallL( iName );
- }
-
- CSPLOGSTRING(CSPINT, "CSPCall::OpenCallHandleL >");
- }
-
-// ---------------------------------------------------------------------------
-// CSPCall::UpdateCallInfoL
-// Update call info including remote party name and number data
-// ---------------------------------------------------------------------------
-//
-void CSPCall::UpdateCallInfo()
- {
- CSPLOGSTRING(CSPINT, "CSPCall::UpdateCallInfo <");
- RMobileCall::TMobileCallInfoV7 callInfo;
- RMobileCall::TMobileCallInfoV7Pckg pck( callInfo );
- TInt err = iCall.GetMobileCallInfo( pck );
-
- UpdateCallInfoImpl( callInfo );
-
- CSPLOGSTRING(CSPINT, "CSPCall::UpdateCallInfo >");
- }
-
-// ---------------------------------------------------------------------------
-// CSPCall::UpdateCallInfoImpl
-// Implementation for UpdateCallInfo().
-// ---------------------------------------------------------------------------
-//
-void CSPCall::UpdateCallInfoImpl( RMobileCall::TMobileCallInfoV7 aCallInfo )
- {
- CSPLOGSTRING(CSPINT, "CSPCall::UpdateCallInfoImpl <");
-
- if ( iMobileOriginated )
- {
- // Call wasn't added by ETel monitor, update info accordingly
- UpdateCallNameNumberInfo( aCallInfo, EFalse );
- }
- else
- {
- // Call was added by ETel monitor, update info accordingly
- UpdateCallNameNumberInfo( aCallInfo, ETrue );
- }
-
-
- CSPLOGSTRING(CSPINT, "CSPCall::UpdateCallInfoImpl >");
- }
-
-// ---------------------------------------------------------------------------
-// CSPCall::UpdateCallOrigin
-// Set call origin to CCCECallParameters.
-// ---------------------------------------------------------------------------
-//
-void CSPCall::UpdateCallOrigin( RMobileCall::TMobileCallInfoV7 aCallInfo )
- {
- CSPLOGSTRING(CSPINT, "CSPCall::UpdateCallOrigin <");
-
- if ( iMobileOriginated )
- {
- if ( RMobileCall::EOriginatorSIM == aCallInfo.iCallParamOrigin )
- {
- iParams->SetOrigin(CCCECallParameters::ECCECallOriginSAT);
- }
- }
- CSPLOGSTRING(CSPINT, "CSPCall::UpdateCallOrigin >");
- }
-
-
-
-// ---------------------------------------------------------------------------
-// CSPCall::UpdateCallStateL
-//
-// ---------------------------------------------------------------------------
-//
-int CSPCall::UpdateCallState()
- {
- CSPLOGSTRING(CSPINT, "CSPCall::UpdateCallState <");
- TInt err( KErrNone );
-
- // Update call state from ETel
- RMobileCall::TMobileCallStatus etelState;
- err = iCall.GetMobileCallStatus( etelState );
- if ( KErrNone == err )
- {
- iCallState = CCPStateFromETelState( etelState );
- }
- CSPLOGSTRING2(CSPINT, "CSPCall::UpdateCallState > res %d", err);
-
- return err;
- }
-
-// ---------------------------------------------------------------------------
-// CSPCall::NotifyRemotePartyNumberChanged
-//
-// ---------------------------------------------------------------------------
-//
-void CSPCall::NotifyRemotePartyNumberChanged()
- {
- CSPLOGSTRING(CSPINT, "CSPCall::NotifyRemotePartyNumberChanged <");
-
- // If COLP number is different from original dialled number
- // it is available in connected state of a MO call.
- // TSY does not send notification so number must be fetched.
- if ( IsMobileOriginated() )
- {
- RMobileCall::TMobileCallInfoV3 callInfo;
- RMobileCall::TMobileCallInfoV3Pckg callInfoPckg( callInfo );
-
- GetMobileCallInfo( callInfoPckg );
- callInfo = callInfoPckg();
-
-
- if ( callInfo.iRemoteParty.iRemoteNumber.iTelNumber.Length() )
- {
- NotifyRemotePartyInfoChanged( KNullDesC(),
- callInfo.iRemoteParty.iRemoteNumber.iTelNumber);
- }
- }
- }
-
-
-// ---------------------------------------------------------------------------
-// CSPCall::CreateCallHandlersL
-// Create call handlers for call related requests and call monitoring
-// ---------------------------------------------------------------------------
-//
-void CSPCall::CreateCallHandlersL()
- {
- CSPLOGSTRING(CSPINT, "CSPCall::CreateCallHandlersL <");
-
- iRequester = CSPEtelCallRequester::NewL( *this, iCall );
-
- iCallEventMonitor = CSPEtelCallEventMonitor::NewL( *this, iCall );
- iCallEventMonitor->StartMonitoring();
- iCallStatusMonitor = CSPEtelCallStatusMonitor::NewL( *this, iCall );
- iCallStatusMonitor->StartMonitoring();
-
- iCallCapsMonitor = CSPEtelCallCapsMonitor::NewL( *this, iCall );
- iCallCapsMonitor->StartMonitoring();
- iCapsFlags = iCallCapsMonitor->FetchCallControlCapsL();
-
- iCallInfoMonitor = CSPCallInfoMonitor::NewL( *this, iCall );
- iCallInfoMonitor->StartMonitoring();
-
- // Start UUI monitor and create message sender
- iSkypeId = TCSPSkypeIdParser::CreateSkypeIdBufferL();
- iUUIMonitor = CSPUUIMonitor::NewL( iCall,*this );
- iUUIMonitor->StartMonitor();
- iUUIMessageSender = CSPUUIMessageSender::NewL( iCall );
- iUserToUserInformation = iParams->UUSId().AllocL();
-
- // Transfer provider
- iTransferProvider = CSPTransferProvider::NewL( iCall, *this, iCommonInfo );
-
- // Forward provider
- iForwardProvider = CSPForwardProvider::NewL();
-
- CSPLOGSTRING(CSPINT, "CSPCall::CreateCallHandlersL >");
- }
-
-// ---------------------------------------------------------------------------
-// CSPCall::NotifyRingingState
-// Gets to ringing state
-// ---------------------------------------------------------------------------
-//
-void CSPCall::NotifyRingingState( )
- {
- CSPLOGSTRING(CSPREQIN, "CSPCall::NotifyRingingState");
- iCallState = MCCPCallObserver::ECCPStateRinging;
-
- TInt obsCount = iObservers.Count ( );
- for (TInt i = 0; i < obsCount; i++ )
- {
- MCCPCallObserver *obs = iObservers[i];
- if ( obs )
- {
- obs->CallStateChanged ( iCallState, this );
- }
- }
- }
-
-// ---------------------------------------------------------------------------
-// CSPCall::CCPStateFromETelState
-// Simple mapping between state enumerations.
-// ---------------------------------------------------------------------------
-//
-MCCPCallObserver::TCCPCallState CSPCall::CCPStateFromETelState(
- RMobileCall::TMobileCallStatus aEtelState )
- {
- MCCPCallObserver::TCCPCallState ret = MCCPCallObserver::ECCPStateIdle;
- switch ( aEtelState )
- {
- case RMobileCall::EStatusUnknown:
- {
- CSPLOGSTRING( CSPREQIN,
- "CSPCall::State > RMobileCall::Unknown" );
- ret = MCCPCallObserver::ECCPStateIdle;
- break;
- }
- case RMobileCall::EStatusIdle:
- {
- CSPLOGSTRING( CSPREQIN,
- "CSPCall::State > RMobileCall::EStatusIdle" );
- ret = MCCPCallObserver::ECCPStateIdle;
- break;
- }
- case RMobileCall::EStatusRinging:
- {
- CSPLOGSTRING( CSPREQIN,
- "CSPCall::State > RMobileCall::EStatusRinging" );
- ret = MCCPCallObserver::ECCPStateRinging;
- break;
- }
- // Map the following to connecting status
- case RMobileCall::EStatusDialling:
- {
- CSPLOGSTRING( CSPREQIN, "CSPCall::State > \
- RMobileCall::EStatusDialling" );
- ret = MCCPCallObserver::ECCPStateDialling;
- break;
- }
- case RMobileCall::EStatusConnecting:
- {
- CSPLOGSTRING( CSPREQIN, "CSPCall::State > \
- RMobileCall::Connecting" );
- ret = MCCPCallObserver::ECCPStateConnecting;
- break;
- }
- case RMobileCall::EStatusAnswering:
- {
- CSPLOGSTRING( CSPREQIN, "CSPCall::State > \
- RMobileCall::Answering" );
- ret = MCCPCallObserver::ECCPStateAnswering;
- break;
- }
- // Call is connected and active.
- case RMobileCall::EStatusConnected:
- {
- CSPLOGSTRING( CSPREQIN,
- "CSPCall::State > RMobileCall::EStatusConnected" );
- ret = MCCPCallObserver::ECCPStateConnected;
- break;
- }
- case RMobileCall::EStatusDisconnectingWithInband:
- case RMobileCall::EStatusDisconnecting:
- {
- CSPLOGSTRING( CSPREQIN,
- "CSPCall::State > RMobileCall::EStatusDisconnecting/Inband?");
- ret = MCCPCallObserver::ECCPStateDisconnecting;
- break;
- }
- case RMobileCall::EStatusReconnectPending:
- {
- CSPLOGSTRING( CSPREQIN,
- "CSPCall::State > RMobileCall::EStatusHangingUp" );
- ret = MCCPCallObserver::ECCPStateDisconnecting;
- break;
- }
- case RMobileCall::EStatusHold:
- {
- CSPLOGSTRING( CSPREQIN,
- "CSPCall::State > RMobileCall::EStatusHold" );
- ret = MCCPCallObserver::ECCPStateHold;
- break;
- }
- case RMobileCall::EStatusWaitingAlternatingCallSwitch:
- {
- // This state is not used in real life.
- CSPLOGSTRING( CSPREQIN,
- "CSPCall::State > RMobileCall::EStatusWaitingAlternatingCallSwitch" );
- ret = MCCPCallObserver::ECCPStateConnected;
- break;
- }
- case RMobileCall::EStatusTransferring:
- {
- CSPLOGSTRING( CSPREQIN,
- "CSPCall::State > RMobileCall::EStatusHold" );
- ret = MCCPCallObserver::ECCPStateTransferring;
- break;
- }
- case RMobileCall::EStatusTransferAlerting:
- {
- CSPLOGSTRING( CSPREQIN,
- "CSPCall::State > RMobileCall::EStatusHold" );
- ret = MCCPCallObserver::ECCPStateTransferring;
- break;
- }
- default:
- {
- CSPLOGSTRING( CSPREQIN,
- "CSPCall::CCPStateFromETelState unhandled state ");
- }
- }
-
- CSPLOGSTRING3(CSPINT,
- "CSPCall::CCPStateFromETelState ETel: %d CCP: %d", aEtelState, ret);
- return ret;
- }
-
-// ---------------------------------------------------------------------------
-// CSPCall::NotifyCallStateChanged
-// Notifies observers about state changes
-// ---------------------------------------------------------------------------
-//
-void CSPCall::NotifyCallStateChanged( MCCPCallObserver::TCCPCallState aState )
- {
- CSPLOGSTRING3(CSPINT,
- "CSPCall::NotifyCallStateChanged < state: %d this: %x",
- aState, this );
-
- iCallState = aState;
- TBool notifyObservers( ETrue );
-
- if ( !iMobileOriginated && MCCPCallObserver::ECCPStateRinging == aState )
- {
- CSPLOGSTRING2(CSPINT, "CSPCall::No notify on ringing MT", aState);
- notifyObservers = EFalse;
- }
-
- if ( notifyObservers )
- {
- TInt obsCount = iObservers.Count();
- for ( TInt i = 0; i < obsCount; i++ )
- {
- MCCPCallObserver *obs = iObservers[i];
- if ( obs )
- {
- obs->CallStateChanged( aState, this );
- }
- }
- }
-
- CSPLOGSTRING3(CSPINT,
- "CSPCall::NotifyCallStateChanged > state: %d this: %x",
- aState, this );
- }
-
-// ---------------------------------------------------------------------------
-// CSPCall::NotifyCallStateChangedWithInband
-// Notifies observers about state changes
-// ---------------------------------------------------------------------------
-//
-void CSPCall::NotifyCallStateChangedWithInband(
- MCCPCallObserver::TCCPCallState aState )
- {
- CSPLOGSTRING3(CSPINT,
- "CSPCall::NotifyCallStateChangedWithInBand < state: %d this: %x",
- aState, this );
-
- iCallState = aState;
-
- if ( !iMobileOriginated && MCCPCallObserver::ECCPStateRinging == aState )
- {
- CSPLOGSTRING2(CSPINT, "CSPCall::No notify on ringing MT", aState);
- }
- else
- {
- TInt obsCount = iObservers.Count();
- for ( TInt i = 0; i < obsCount; i++ )
- {
- MCCPCallObserver *obs = iObservers[i];
- if ( obs )
- {
- obs->CallStateChangedWithInband( aState, this );
- }
- }
- }
- CSPLOGSTRING3(CSPINT,
- "CSPCall::NotifyCallStateChangedWithInband > state: %d this: %x",
- aState, this);
- }
-
-// ---------------------------------------------------------------------------
-// CSPCall::ReadRepositoryL
-// Reads the given information from Central Repository.
-// ---------------------------------------------------------------------------
-//
-void CSPCall::ReadRepositoryL( TUid aUid, TUint aKey, TInt& aVal)
- {
- CSPLOGSTRING(CSPINT, "CSPCall::ReadRepositoryL");
-
- CRepository* cr = CRepository::NewL( aUid );
- TInt err = cr->Get( aKey, aVal );
- delete cr;
- User::LeaveIfError( err );
- }
-
-// ---------------------------------------------------------------------------
-// CSPCall::CheckAndNotifyTerminationError
-// Reads error code from ETel.
-// ---------------------------------------------------------------------------
-//
-void CSPCall::CheckAndNotifyTerminationError()
- {
- CSPLOGSTRING2(CSPINT,
- "CSPCall::CheckAndNotifyTerminationError dial completion code: %d",
- iDialCompletionCode);
-
- // Emergency error handling is separated into CSPEtelCallRequester
- if ( !iIsEmergencyCall )
- {
- TInt termErr = ExitCodeError();
- CSPLOGSTRING2(CSPINT,
- "CSPCall::CheckAndNotifyTerminationError exit code error: %d",
- termErr);
-
- if ( termErr == KErrNone )
- {
- // Handle KErrGsmCCUnassignedNumber correctly
- // because the value is not stored in exit code.
- termErr = iDialCompletionCode;
- CSPLOGSTRING(CSPINT,
- "CSPCall::CheckAndNotifyTerminationError use dial completion code");
- }
-
- if ( termErr == KErrGsmRRPreEmptiveRelease )
- {
- // Error KErrGsmRRPreEmptiveRelease occurs when there is active call
- // and user make emergency call, can be ignored.
- CSPLOGSTRING3(
- CSPERROR,
- "CSPCall::CheckAndNotifyTerminationError preemptive release, ignore: %d",
- termErr,
- this );
- }
- else if ( iDontReportTerm
- && ( termErr == KErrGsmCCNormalUnspecified
- || termErr == KErrGsmCCCallRejected ) )
- {
- // Not an error, since this happens on normal
- // call termination situation after connected call.
- CSPLOGSTRING3(CSPERROR,
- "CSPCall::CheckAndNotifyTerminationError DISCARD this: %x err: %d",
- this,
- termErr);
- }
- else if ( termErr )
- {
- TCCPError ccpErr(ECCPErrorNone);
-
- // Only a couple of error codes can have diagnostic information.
- // aDiagnostic ought to be undefined in other situatios,
- // but at least in this way we can really guarantee it.
- if ( termErr == KErrGsmCCFacilityRejected ||
- termErr == KErrGsmCCRequestedFacilityNotSubscribed ||
- termErr == KErrGsmCCIncomingCallsBarredInCug ||
- termErr == KErrGsmCCRequestedFacilityNotImplemented ||
- termErr == KErrGsmCCUserNotInCug )
- {
- TName name;
- CallName( name );
- TInt diagErr = iCommonInfo.GetDiagnosticError( name );
- ccpErr = iRequester->MapError( diagErr );
-
- // Finally use exit code if diagnostic did not contain
- // any useful information.
- if ( ccpErr == ECCPRequestFailure )
- {
- ccpErr = iRequester->MapError( termErr );
- }
- }
- else
- {
- ccpErr = iRequester->MapError( termErr );
- }
-
- NotifyErrorOccurred( ccpErr );
- iTerminationErrorNotified = ETrue;
- }
- }
- }
-
-// ---------------------------------------------------------------------------
-// CSPCall::ExitCodeError
-// Reads error code from ETel call info's iExitCode.
-// ---------------------------------------------------------------------------
-//
-TInt CSPCall::ExitCodeError() const
- {
- CSPLOGSTRING2(CSPINT, "CSPCall::ExitCodeError < this: %x",
- this );
- TInt callError;
- RMobileCall::TMobileCallInfoV3 callInfo;
- RMobileCall::TMobileCallInfoV3Pckg pck( callInfo );
- TInt getErr = iCall.GetMobileCallInfo( pck );
- // Is there value in higher 16 bits
- if ( KErrNone == getErr && (callInfo.iExitCode & 0xFFFF0000) )
- {
- CSPLOGSTRING2(CSPINT, "CSPCall::ExitCodeError callInfo.iExitCode %d",
- callInfo.iExitCode );
- callError = ( callInfo.iExitCode >> KTimesToSplitValue );
-
- if ( callError > KErrEtelGsmBase )
- // Not in valid exteded range
- {
- // Ignore invalid extented code
- if ( ( callInfo.iExitCode & 0x0000FFFF ) == KErrNone )
- // core error is zero
- {
- callError = KErrNone;
- }
- else
- {
- callError = ( ( callInfo.iExitCode & 0x0000FFFF )
- | 0xFFFF0000 );
- }
- }
- }
- // Higher and lower 16 bits are zero
- else if ( !( callInfo.iExitCode & 0xFFFFFFFF ) )
- {
- callError = KErrNone;
- }
- else
- {
- // No extended error, expand value to full range
- callError = ( callInfo.iExitCode | 0xFFFF0000 );
- }
-
- CSPLOGSTRING2(CSPINT, "CSPCall::ExitCodeError > err: %d", callError);
-
- return callError;
- }
-
-// ---------------------------------------------------------------------------
-// CSPCall::UUSMessageReceived
-// ---------------------------------------------------------------------------
-//
- void CSPCall::UUSMessageReceived( TDesC& aMessage )
- {
- CSPLOGSTRING(CSPREQIN, "CSPCall::UUSMessageReceived");
- TCSPSkypeIdParser parser;
-
- TPtr ptr = iSkypeId->Des();
- ptr.Zero();
- const TInt error( parser.Parse( aMessage, ptr ) );
-
- if ( !error )
- {
- iRemotePartyName = ptr;
- NotifyCallEventOccurred( MCCPCallObserver::ECCPNotifyRemotePartyInfoChange );
- }
- CSPLOGSTRING2(CSPINT, "CSPCall::UUSMessageReceived err: %d", error );
- }
-
-// ---------------------------------------------------------------------------
-// CSPCall::NotifyRemotePartyInfoChanged
-// ---------------------------------------------------------------------------
-//
-void CSPCall::NotifyRemotePartyInfoChanged( const TDesC& aRemotePartyName,
- const TDesC& aRemotePartyNumber )
- {
- CSPLOGSTRING(CSPREQIN, "CSPCall::NotifyRemotePartyInfoChanged");
-
- if ( aRemotePartyName.Length() )
- {
- iRemotePartyName = aRemotePartyName;
- }
-
- if ( aRemotePartyNumber.Length() )
- {
- iRemotePartyNumber = aRemotePartyNumber;
- }
-
- NotifyCallEventOccurred( MCCPCallObserver::ECCPNotifyRemotePartyInfoChange );
- }
-
-// ---------------------------------------------------------------------------
-// CSPCall::DontReportTerminationError
-// ---------------------------------------------------------------------------
-//
-void CSPCall::DontReportTerminationError()
- {
- CSPLOGSTRING(CSPREQIN, "CSPCall::DontReportTerminationError");
- iDontReportTerm = ETrue;
- }
-
-// ---------------------------------------------------------------------------
-// CSPCall::UpdateCallNameNumberInfo
-// Update call info including remote party name and number data
-// ---------------------------------------------------------------------------
-//
-void CSPCall::UpdateCallNameNumberInfo(
- RMobileCall::TMobileCallInfoV3& aCallInfo,
- TBool aCallAddedByMonitor )
- {
- CSPLOGSTRING(CSPINT, "CSPCall::UpdateCallNameNumberInfo <");
-
- iCallName.Zero();
- iRemotePartyNumber.Zero();
- iRemotePartyName.Zero();
-
- if ( aCallAddedByMonitor )
- {
- CSPLOGSTRING(CSPINT,
- "CSPCall::UpdateCallNameNumberInfo call added by monitor");
-
- // If call was created by ETel line status or incoming call monitor
- // the call name is already known, only remote party info is fetched from
- // call info
- iCallName.Append( iName );
- iRemotePartyName.Append( aCallInfo.iRemoteParty.iCallingName );
- iRemotePartyNumber.Append( aCallInfo.iRemoteParty.iRemoteNumber.iTelNumber );
- }
- else
- {
- CSPLOGSTRING(CSPINT,
- "CSPCall::UpdateCallNameNumberInfo call added by plugin owner");
-
- // The call was not created by monitor and the remote number is already known,
- // fetch only call name from call info
- iCallName.Append( aCallInfo.iCallName );
- iRemotePartyNumber.Append( iName );
- }
-
- CSPLOGSTRING2(CSPINT,
- "CSPCall::UpdateCallNameNumberInfo iCallName: %S", &iCallName );
- CSPLOGSTRING2(CSPINT,
- "CSPCall::UpdateCallNameNumberInfo iRemotePartyNumber: %S", &iRemotePartyNumber );
- CSPLOGSTRING2(CSPINT,
- "CSPCall::UpdateCallNameNumberInfo iRemotePartyName: %S", &iRemotePartyName );
-
- CSPLOGSTRING(CSPINT, "CSPCall::UpdateCallNameNumberInfo >");
- }
-
-// ---------------------------------------------------------------------------
-// CSPCall::OpenNewCall
-// Open new call
-// ---------------------------------------------------------------------------
-//
-void CSPCall::OpenNewCall()
- {
- CSPLOGSTRING(CSPINT, "CSPCall::OpenNewCall <");
-
- // Open new call
- __ASSERT_ALWAYS( iCall.OpenNewCall( iLine ) == KErrNone,
- Panic( ECSPPanicNoEtel ) );
-
- CSPLOGSTRING(CSPINT, "CSPCall::OpenNewCall >");
- }
-
-// ---------------------------------------------------------------------------
-// CSPCall::OpenExistingCallL
-// Open existing call
-// ---------------------------------------------------------------------------
-//
-void CSPCall::OpenExistingCallL( const TDesC& aName )
- {
- CSPLOGSTRING2(CSPINT,
- "CSPCall::OpenExistingCallL < aName: %S", &aName);
-
- // Open existing call with given name from current line
- TInt err = iCall.OpenExistingCall( iLine, aName );
-
- if ( KErrNone != err )
- {
- CSPLOGSTRING2(CSPERROR,
- "CSPCall::OpenCallHandleL OpenExistingCall error: %d, leaving", err);
- User::Leave( err );
- }
-
- CSPLOGSTRING(CSPINT, "CSPCall::OpenExistingCallL >");
- }
-
-// End of File
-