// All rights reserved.

// This component and the accompanying materials are made available

// under the terms of "Eclipse Public License v1.0"

// which accompanies this distribution, and is available

// at the URL "http://www.eclipse.org/legal/epl-v10.html".

//

// Initial Contributors:

// Nokia Corporation - initial contribution.

//

// Contributors:

//

// Description:

//

#include <etelsat.h>

#include <in_sock.h>

#include "ccallcontroldispatcher.h"

#include "ccallcontrolmultipartydispatcher.h"

#include "ccellbroadcastdispatcher.h"

#include <ctsy/ltsy/cctsydispatchercallback.h>

#include "cpacketservicesdispatcher.h"

#include "cphonedispatcher.h"

#include "cphonebookdispatcher.h"

#include "cphonebookendispatcher.h"

#include "cphonebookondispatcher.h"

#include "csatdispatcher.h"

#include "csecuritydispatcher.h"

#include "csimdispatcher.h"

#include "csmsdispatcher.h"

#include "csupplementaryservicesdispatcher.h"

#include "ctsydispatcherpanic.h"

#include <ctsy/ltsy/ltsylogger.h>

#include "tdispatcherholder.h"

CCtsyDispatcherCallback::CCtsyDispatcherCallback()

	{

	}

CCtsyDispatcherCallback::~CCtsyDispatcherCallback()

	{

	}

CCtsyDispatcherCallback* CCtsyDispatcherCallback::NewLC()

	{

	CCtsyDispatcherCallback* self = new (ELeave) CCtsyDispatcherCallback();

	CleanupStack::PushL(self);

	self->ConstructL();

	return self;

	}

CCtsyDispatcherCallback* CCtsyDispatcherCallback::NewL()

	{

	CCtsyDispatcherCallback* self=CCtsyDispatcherCallback::NewLC();

	CleanupStack::Pop(self);

	return self;

	}

void CCtsyDispatcherCallback::ConstructL()

	{

	}

void CCtsyDispatcherCallback::SetDispatcherHolder(TDispatcherHolder& aDispatcherHolder)

/**

 * Set the dispatcher holder.

 *

 * @param aDispatcherHolder Reference to dispatcher holder.

 */

	{

	TSYLOGENTRYEXIT;

	iDispatcherHolder = &aDispatcherHolder;

	} // CCtsyDispatcherCallback::SetDispatcherHolder

EXPORT_C void CCtsyDispatcherCallback::CallbackCallControlNotifyCallStatusChangeInd(

	TInt aCauseCode, TInt aCallId, RMobileCall::TMobileCallStatus aMobileCallStatus)

/**

 * Used by an LTSY to indicate to the CTSY that there has been a change in the

 * status of a call. For example, if the CTSY has previously made a dial request

 * to make a voice call, the LTSY can call this API to notify the CTSY

 * of progress of the call through the dialling, connecting and connected states.

 *

 * The aCauseCode parameter should be used to indicate the reason for the change

 * in status of a call.

 *

 * In the case of a call going idle (aMobileCallStatus = RMobileCall::EStatusIdle)

 * specific cause codes need to be returned to the Common TSY to indicate

 * specific causes of status changes:

 *

 *  - To indicate that an active call has been released normally by either party,

 *  set aCauseCode = KErrGsmCCNormalCallClearing.

 *

 *  - To indicate that a mobile originated call that is being dialled has gone

 * idle because the remote party has rejected the call, set

 * aCauseCode = KErrGsmCCCallRejected or another error code (which is != KErrNone)

 * to indicate the reason for rejection.

 *

 * - If a mobile originated call is being dialled and the user cancels dialling,

 * causing the call to go idle, set aCauseCode = KErrGsmCCNormalCallClearing.

 *

 * - When an incoming call goes idle because the client has rejected it

 * (done using RCall::HangUp() on the ringing call), set

 * aCauseCode = KErrGsmCCUserBusy.

 *

 * @param aCauseCode The cause of the change in call status.

 *

 * @param aCallId The Call ID of the call whose status has changed.

 *

 * @param aMobileCallStatus The new status of the call refered to by aCallId.

 *

 * @see RMobileCall::NotifyMobileCallStatusChange()

 */

	{

	TSYLOGENTRYEXITARGS(_L8("aCauseCode=%d, aCallId=%d, aMobileCallStatus=%d"), aCauseCode, aCallId, aMobileCallStatus);

	// Forward completion to correct dispatcher object to handle

	__ASSERT_DEBUG(iDispatcherHolder, CtsyDispatcherPanic(EInvalidNullPtr));

	iDispatcherHolder->GetCallControlDispatcher().CallbackNotifyCallStatusChange(aCauseCode, aCallId, aMobileCallStatus);

	} // CCtsyDispatcherCallback::CallbackCallControlNotifyCallStatusChangeInd

EXPORT_C void CCtsyDispatcherCallback::CallbackCallControlReceiveUuiInd(

	TInt aError, TInt aCallId, const TDesC& aCallUui)

/**

 * Indicates to the CTSY that the LTSY has received a User-to-User

 * Information notification. The User-to-User Supplementary Service

 * is detailed in 3GPP TS 24.087.

 *

 * @param aError KErrNone on success, or another error code indicating the error otherwise.

 * @param aCallId The Call ID of the call to which the information is being sent.

 * @param aCallUui The User-to-User Information that has been received.

 * This should be a descriptor of length RMobileCall::KMaxUUISize

 *

 * @see RMobileCall:ReceiveUUI()

 */

	{

	TSYLOGENTRYEXITARGS(_L8("aError=%d, aCallId=%d"), aError, aCallId);

	// Forward completion to correct dispatcher object to handle

	__ASSERT_DEBUG(iDispatcherHolder, CtsyDispatcherPanic(EInvalidNullPtr));

	iDispatcherHolder->GetCallControlDispatcher().CallbackReceiveUui(aError, aCallId, aCallUui);

	} // CCtsyDispatcherCallback::CallbackCallControlReceiveUuiInd

EXPORT_C void CCtsyDispatcherCallback::CallbackCallControlNotifyDataCallCapsChangeInd(

	TInt aError, TInt aCallId, const RMobileCall::TMobileCallDataCapsV1& aMobileCallDataCaps)

/**

 * Sends a notification to the Common TSY about a change in the data call

 * capabilities.

 *

 * @param aError KErrNone on success, or another error code indicating the error otherwise.

 *

 * @param aCallId The Call ID of the call whose capabilities have changed.

 *

 * @param aMobileCallDataCaps The new capabilities of the data call.

 *

 * @see RMobileCall::NotifyMobileDataCallCapsChange()

 */

	{

	TSYLOGENTRYEXITARGS(_L8("aError=%d, aCallId=%d"), aError, aCallId);

	// Forward completion to correct dispatcher object to handle

	__ASSERT_DEBUG(iDispatcherHolder, CtsyDispatcherPanic(EInvalidNullPtr));

	iDispatcherHolder->GetCallControlDispatcher().CallbackNotifyDataCallCapsChange(aError, aCallId, aMobileCallDataCaps);

	} // CCtsyDispatcherCallback::CallbackCallControlNotifyDataCallCapsChangeInd

EXPORT_C void CCtsyDispatcherCallback::CallbackCallControlNotifyIncomingCallInd(

	TInt aError, const RMobileCall::TMobileCallInfoV1& aCallInfo)

/**

 * Notify the Common TSY about an incoming call to the phone.

 *

 * The aCallInfo parameter is used to provide the Common TSY with details about

 * the incoming call.

 *

 * The field RMobileCall::TMobileCallInfoV1::iCallId is mandatory and should be

 * populated with a unique Call ID allocated by the LTSY. For more details about

 * how to set a valid Call ID, see the documentation on the aCallId parameter

 * in CCtsyDispatcherCallback::CallbackCallControlDialVoiceComp().

 *

 * The field RMobileCall::TMobileCallInfoV1::iService in the aCallInfo parameter

 * is mandatory

 * must be populated by the LTSY to indicate to the Common TSY the type of the

 * incoming call.

 *

 * 	- If there is an incoming voice call on the primary voice line,

 * this field should be set to RMobilePhone::EVoiceService.

 *

 *  - If the incoming voice call is on the auxiliary

 * voice line, this parameter should be set to RMobilePhone::EAuxVoiceService.

 *

 *  - If the incoming call is a data call, this parameter should be set to

 * RMobilePhone::ECircuitDataService.

 *

 * The remainder of the fields in the aCallInfo parameter can be used to

 * indicate other details about the incoming call. See the documentation for

 * RMobileCall::TMobileCallInfoV1 for more details.

 *

 * @param aError KErrNone on success, or another error code indicating the error otherwise.

 * @param aCallInfo Information about the incoming call.

 *

 * @see RLine::NotifyIncomingCall()

 */

	{

	TSYLOGENTRYEXITARGS(_L8("aError=%d, aCallInfo.iService=%d, aCallInfo.iCallId=%d"), aError, aCallInfo.iService, aCallInfo.iCallId);

	// Forward completion to correct dispatcher object to handle

	__ASSERT_DEBUG(iDispatcherHolder, CtsyDispatcherPanic(EInvalidNullPtr));

	iDispatcherHolder->GetCallControlDispatcher().CallbackNotifyIncomingCall(aError, aCallInfo);

	} // CCtsyDispatcherCallback::CallbackCallControlNotifyIncomingCallInd

EXPORT_C void CCtsyDispatcherCallback::CallbackCallControlNotifyHscsdInfoChangeInd(

	TInt aError, TInt aCallId, const RMobileCall::TMobileCallHscsdInfoV8& aCallParams,

	const RMobileCall::TMobileCallDataCapsV1& aCallCaps)

/**

 * Notify the Common TSY about a change in the parameters of other information

 * about the specified HSCSD call.

 *

 * @param aError KErrNone on success, or another error code indicating the error otherwise.

 *

 * @param aCallId The Call ID of the data call whose parameters / information has changed.

 *

 * @param aCallParams The new call parameters.  The fields of this

 * RMobileCall::TMobileCallHscsdInfoV8 parameter are returned to the client if

 * the client has requested to be notified of a change in the HSCSD information

 * of the call via RMobileCall::NotifyHscsdInfoChange()

 *

 * @param aCallCaps The new call capabilities.  The fields of this

 * RMobileCall::TMobileCallDataCapsV1 parameter are returned to the client if

 * the client has requested to be notified of a change in the HSCSD capabilities

 * of the call via RMobileCall::NotifyMobileDataCallCapsChange() if any of the

 * following fields have changed their value:

 * RMobileCall::TMobileCallDataCapsV1::iMaxRxTimeSlots ,

 * RMobileCall::TMobileCallDataCapsV1::iMaxTxTimeSlots ,

 * RMobileCall::TMobileCallDataCapsV1::iHscsdSupport ,

 * RMobileCall::TMobileCallDataCapsV1::iSpeedCaps ,

 *

 * @see RMobileCall::NotifyMobileDataCallCapsChange()

 * @see RMobileCall::NotifyHscsdInfoChange()

 */

	{

	TSYLOGENTRYEXITARGS(_L8("aError=%d, aCallId=%d"), aError, aCallId);

	// Forward completion to correct dispatcher object to handle

	__ASSERT_DEBUG(iDispatcherHolder, CtsyDispatcherPanic(EInvalidNullPtr));

	iDispatcherHolder->GetCallControlDispatcher().CallbackNotifyHscsdInfoChange(aError,

			aCallId, aCallParams, aCallCaps);

	} // CCtsyDispatcherCallback::CallbackCallControlNotifyHscsdInfoChangeInd

EXPORT_C void CCtsyDispatcherCallback::CallbackCallControlNotifyCallEventInd(

	TInt aError, TInt aCallId, RMobileCall::TMobileCallEvent aCallEvent)

/**

 * Notify the Common TSY about a remote call event that has occurred, for example,

 * the remote party has put the call on hold.

 *

 * @param aError The error code associated with this notification.

 * KErrNone if there is no error.

 *

 * @param aCallId The Call ID of the call that this call event relates to.

 *

 * @param aCallEvent The event that has occurred to the call specified in aCallId.

 * Current valid values supported by the Common TSY are RMobileCall::ERemoteHold,

 * RMobileCall::ERemoteResume, RMobileCall::ERemoteTerminated and

 * RMobileCall::ERemoteConferenceCreate

 *

 * @see RMobileCall::NotifyCallEvent()

 */

	{

	TSYLOGENTRYEXITARGS(_L8("aError=%d, aCallId=%d, aCallEvent=%d"), aError, aCallId, aCallEvent);

	// Forward completion to correct dispatcher object to handle

	__ASSERT_DEBUG(iDispatcherHolder, CtsyDispatcherPanic(EInvalidNullPtr));

	iDispatcherHolder->GetCallControlDispatcher().CallbackNotifyCallEvent(aError, aCallId, aCallEvent);

	} // CCtsyDispatcherCallback::CallbackCallControlNotifyCallEventInd

EXPORT_C void CCtsyDispatcherCallback::CallbackCallControlNotifyCallInfoChangeInd(

	TInt aError, const RMobileCall::TMobileCallInfoV1& aMobileCallInfo)

/**

 * This function should be used by the LTSY to supply information about a call

 * to the Common TSY.  For example, details about the remote party and whether

 * the call has been forwarded. See RMobileCall::TMobileCallInfoV1 for more

 * details on what information about the call can be returned to the CTSY.

 *

 * In aMobileCallInfo, RMobileCall::TMobileCallInfoV1::iCallId must be populated

 * with the Call ID of the call the aMobileCallInfo parameter is referring to.

 *

 * @param aError The error code associated with this notification.

 * KErrNone if there is no error.

 *

 * @param aMobileCallInfo The call information relating to the call identified

 * by aCallId.

 *

 * @see RMobileCall::GetMobileCallInfo()

 * @see RMobileCall::NotifyRemotePartyInfoChange()

 */

	{

	TSYLOGENTRYEXITARGS(_L8("aError=%d, callId=%d, callMode=%d"), aError, aMobileCallInfo.iCallId, aMobileCallInfo.iService);

	// Forward completion to correct dispatcher object to handle

	__ASSERT_DEBUG(iDispatcherHolder, CtsyDispatcherPanic(EInvalidNullPtr));

	iDispatcherHolder->GetCallControlDispatcher().CallbackNotifyCallInfoChange(aError, aMobileCallInfo);

	} // CCtsyDispatcherCallback::CallbackCallControlNotifyCallInfoChangeInd

EXPORT_C void CCtsyDispatcherCallback::CallbackCallControlRemoteAlertingToneChangeInd(

	TInt aError, RMmCustomAPI::TRemoteAlertingToneStatus aRemoteAlertingTone)

/**

 * This function should be used by the LTSY to indicate to the CTSY that the remote alerting tone had

 * been set or changed.

 *

 * @param aError The error code associated with this notification.

 * KErrNone if there is no error.

 *

 * @param aRemoteAlertingTone The new remote alerting status (either RMmCustomAPI::EUiRbtTone

 *                            when it is a ringback tone or RMmCustomAPI::EUiStopTone when it's a stop tone)

 *

 * @see RMmCustomAPI::GetRemoteAlertingToneStatus()

 * @see RMmCustomAPI::NotifyRemoteAlertingToneStatusChange()

 */

	{

	TSYLOGENTRYEXITARGS(_L8("aError=%d, aRemoteAlertingTone=%d"), aError, aRemoteAlertingTone);

	// Forward completion to correct dispatcher object to handle

	__ASSERT_DEBUG(iDispatcherHolder, CtsyDispatcherPanic(EInvalidNullPtr));

	iDispatcherHolder->GetCallControlDispatcher().CallbackRemoteAlertingToneChange(aError, aRemoteAlertingTone);

	} // CCtsyDispatcherCallback::CallbackCallControlRemoteAlertingToneChangeInd

EXPORT_C void CCtsyDispatcherCallback::CallbackCallControlAnswerComp(TInt aError, TInt aCallId)

/**

 * Callback function to be used by the Licensee LTSY to complete a pending

 * MLtsyDispatchCallControlAnswer::HandleAnswerReqL()

 *

 * Used to indicate to the Common TSY the outcome of the request to answer an

 * incoming call.

 *

 * @param aError The error code to be returned to the CTSY by the LTSY

 * indicating the outcome of the attempt to answer the requested call.  This should

 * be KErrNone if the dialling process could be started successfully.  Otherwise

 * another error code to indicate the failure should be returned.

 *

 * @param aCallId The Call ID which could not be answered.

 *

 * @see RCall::AnswerIncomingCall()

 * @see RCall::AnswerIncomingCallISV()

 * @see CTelephony::AnswerIncomingCall()

 */

	{

	TSYLOGENTRYEXITARGS(_L8("aError=%d, aCallId=%d"), aError, aCallId);

	// Forward completion to correct dispatcher object to handle

	__ASSERT_DEBUG(iDispatcherHolder, CtsyDispatcherPanic(EInvalidNullPtr));

	iDispatcherHolder->GetCallControlDispatcher().CallbackAnswer(aError, aCallId);

	} // CCtsyDispatcherCallback::CallbackCallControlAnswerComp

EXPORT_C void CCtsyDispatcherCallback::CallbackCallControlHoldComp(

	TInt aError, TInt aCallId)

/**

 *

 * Callback function to be used by the Licensee LTSY to complete a pending

 * MLtsyDispatchCallControlHold::HandleHoldReqL()

 *

 * The result of the hold request on the call specified in aCallId is passed back

 * to the Common TSY.

 *

 * @param aError The error code to be returned to the CTSY by the LTSY

 * indicating the outcome of the attempt to hold the requested call.  This should

 * be KErrNone if the hold process could be started successfully.  Otherwise

 * another error code to indicate the failure should be returned.

 *

 * @param aCallId The Call ID of the call which was requested to be held.

 *

 * @see RMobileCall::Hold()

 */

	{

	TSYLOGENTRYEXITARGS(_L8("aError=%d, aCallId=%d"), aError, aCallId);

	// Forward completion to correct dispatcher object to handle

	__ASSERT_DEBUG(iDispatcherHolder, CtsyDispatcherPanic(EInvalidNullPtr));

	iDispatcherHolder->GetCallControlDispatcher().CallbackHold(aError, aCallId);

	} // CCtsyDispatcherCallback::CallbackCallControlHoldComp

EXPORT_C void CCtsyDispatcherCallback::CallbackCallControlDialEmergencyComp(

	TInt aError, TInt aCallId)

/**

 *

 * Callback function to be used by the Licensee LTSY to complete a pending

 * MLtsyDispatchCallControlDialEmergency::HandleDialEmergencyReqL()

 *

 * This callback is used to inform the CTSY of the outcome of the request to

 * initiate the dialling process to dial an emergency call.

 *

 * This callback is similar to CCtsyDispatcherCallback::CallbackCallControlDialVoiceComp()

 * but refers specifically to the dialling of an emergency call.

 *

 * @param aError KErrNone on success, or another error code indicating the error otherwise.

 * @param aCallId The call ID of the call that the dial attempt refers to which

 * has been allocated by the LTSY. The call ID needs to be unique across all

 * calls and modes(emergency and non-emergency included). See the documentation for

 * CCtsyDispatcherCallback::CallbackCallControlDialVoiceComp for precise details

 * on how to allocate a valid call ID.

 *

 * @see RMobileCall::DialEmergencyCall()

 */

	{

	TSYLOGENTRYEXITARGS(_L8("aError=%d, aCallId=%d"), aError, aCallId);

	// Forward completion to correct dispatcher object to handle

	__ASSERT_DEBUG(iDispatcherHolder, CtsyDispatcherPanic(EInvalidNullPtr));

	iDispatcherHolder->GetCallControlDispatcher().CallbackDialEmergency(aError, aCallId);

	} // CCtsyDispatcherCallback::CallbackCallControlDialEmergencyComp

EXPORT_C void CCtsyDispatcherCallback::CallbackCallControlStopDtmfToneComp(TInt aError)

/**

 *

 * Callback function to be used by the Licensee LTSY to complete a pending

 * MLtsyDispatchCallControlStopDtmfTone::HandleStopDtmfToneReqL()

 *

 * @param aError KErrNone on success, or another error code indicating the error otherwise.

 *

 * @see RMobilePhone::StopDTMFTone()

 */

	{

	TSYLOGENTRYEXITARGS(_L8("aError=%d"), aError);

	// Forward completion to correct dispatcher object to handle

	__ASSERT_DEBUG(iDispatcherHolder, CtsyDispatcherPanic(EInvalidNullPtr));

	iDispatcherHolder->GetCallControlDispatcher().CallbackStopDtmfTone(aError);

	} // CCtsyDispatcherCallback::CallbackCallControlStopDtmfToneComp

EXPORT_C void CCtsyDispatcherCallback::CallbackCallControlSetActiveAlsLineComp(TInt aError)

/**

 *

 * Callback function to be used by the Licensee LTSY to complete a pending

 * MLtsyDispatchCallControlSetActiveAlsLine::HandleSetActiveAlsLineReqL()

 *

 * This callback indicates the outcome of the request to set the active ALS line.

 *

 * @param aError KErrNone on success, or another error code indicating the error otherwise.

 *

 * @see RMobilePhone::SetALSLine()

 */

	{

	TSYLOGENTRYEXITARGS(_L8("aError=%d"), aError);

	// Forward completion to correct dispatcher object to handle

	__ASSERT_DEBUG(iDispatcherHolder, CtsyDispatcherPanic(EInvalidNullPtr));

	iDispatcherHolder->GetCallControlDispatcher().CallbackSetActiveAlsLine(aError);

	} // CCtsyDispatcherCallback::CallbackCallControlSetActiveAlsLineComp

EXPORT_C void CCtsyDispatcherCallback::CallbackCallControlSendDtmfTonesCancelComp(TInt aError)

/**

 *

 * Callback function to be used by the Licensee LTSY to complete a pending

 * MLtsyDispatchCallControlSendDtmfTonesCancel::HandleSendDtmfTonesCancelReqL()

 *

 *

 * @param aError KErrNone on success, or another error code indicating the error otherwise.

 *

 * @see RMobilePhone::SendDTMFTones()

 */

	{

	TSYLOGENTRYEXITARGS(_L8("aError=%d"), aError);

	// Forward completion to correct dispatcher object to handle

	__ASSERT_DEBUG(iDispatcherHolder, CtsyDispatcherPanic(EInvalidNullPtr));

	iDispatcherHolder->GetCallControlDispatcher().CallbackSendDtmfTonesCancel(aError);

	} // CCtsyDispatcherCallback::CallbackCallControlSendDtmfTonesCancelComp

EXPORT_C void CCtsyDispatcherCallback::CallbackCallControlHangUpComp(

	TInt aError, TInt aCallId)

/**

 *

 * Callback function to be used by the Licensee LTSY to complete a pending

 * MLtsyDispatchCallControlHangUp::HandleHangUpReqL()

 *

 * @param aError The error code to return to the CTSY relating to the request to

 * hang up.  This should be KErrNone on success or another error code to indicate

 * the failure otherwise.

 *

 * @param aCallId The Call ID of the call which has just been hung up.

 *

 * @see RCall::HangUp()

 */

	{

	TSYLOGENTRYEXITARGS(_L8("aError=%d, aCallId=%d"), aError, aCallId);

	// Forward completion to correct dispatcher object to handle

	__ASSERT_DEBUG(iDispatcherHolder, CtsyDispatcherPanic(EInvalidNullPtr));

	iDispatcherHolder->GetCallControlDispatcher().CallbackHangUp(aError, aCallId);

	} // CCtsyDispatcherCallback::CallbackCallControlHangUpComp

EXPORT_C void CCtsyDispatcherCallback::CallbackCallControlResumeComp(

	TInt aError, TInt aCallId)

/**

 *

 * Callback function to be used by the Licensee LTSY to complete a pending

 * MLtsyDispatchCallControlResume::HandleResumeReqL()

 *

 * The result of the pending resume request on the call specified in aCallId is

 * passed back to the Common TSY.

 *

 * @param aError The error code to be returned to the CTSY by the LTSY

 * indicating the outcome of the attempt to resume the held call.  This should

 * be KErrNone if the resume process could be started successfully.  Otherwise

 * another error code to indicate the failure should be returned.