1 // Copyright (c) 2008-2009 Nokia Corporation and/or its subsidiary(-ies).

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

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

     5 // which accompanies this distribution, and is available

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

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 //

    15 

    16 #include <etelsat.h>

    17 #include <in_sock.h>

    18 #include "ccallcontroldispatcher.h"

    19 #include "ccallcontrolmultipartydispatcher.h"

    20 #include "ccellbroadcastdispatcher.h"

    21 #include <ctsy/ltsy/cctsydispatchercallback.h>

    22 #include "cpacketservicesdispatcher.h"

    23 #include "cphonedispatcher.h"

    24 #include "cphonebookdispatcher.h"

    25 #include "cphonebookendispatcher.h"

    26 #include "cphonebookondispatcher.h"

    27 #include "csatdispatcher.h"

    28 #include "csecuritydispatcher.h"

    29 #include "csimdispatcher.h"

    30 #include "csmsdispatcher.h"

    31 #include "csupplementaryservicesdispatcher.h"

    32 #include "ctsydispatcherpanic.h"

    33 #include <ctsy/ltsy/ltsylogger.h>

    34 #include "tdispatcherholder.h"

    35 

    36 CCtsyDispatcherCallback::CCtsyDispatcherCallback()

    37 	{

    38 	}

    39 

    40 CCtsyDispatcherCallback::~CCtsyDispatcherCallback()

    41 	{

    42 	}

    43 

    44 CCtsyDispatcherCallback* CCtsyDispatcherCallback::NewLC()

    45 	{

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

    47 	CleanupStack::PushL(self);

    48 	self->ConstructL();

    49 	return self;

    50 	}

    51 

    52 CCtsyDispatcherCallback* CCtsyDispatcherCallback::NewL()

    53 	{

    54 	CCtsyDispatcherCallback* self=CCtsyDispatcherCallback::NewLC();

    55 	CleanupStack::Pop(self);

    56 	return self;

    57 	}

    58 

    59 void CCtsyDispatcherCallback::ConstructL()

    60 	{

    61 	}

    62 

    63 void CCtsyDispatcherCallback::SetDispatcherHolder(TDispatcherHolder& aDispatcherHolder)

    64 /**

    65  * Set the dispatcher holder.

    66  *

    67  * @param aDispatcherHolder Reference to dispatcher holder.

    68  */

    69 	{

    70 	TSYLOGENTRYEXIT;

    71 

    72 	iDispatcherHolder = &aDispatcherHolder;

    73 	} // CCtsyDispatcherCallback::SetDispatcherHolder

    74 

    75 EXPORT_C void CCtsyDispatcherCallback::CallbackCallControlNotifyCallStatusChangeInd(

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

    77 /**

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

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

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

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

    82  *

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

    84  * in status of a call.

    85  *

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

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

    88  * specific causes of status changes:

    89  *

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

    91  *  set aCauseCode = KErrGsmCCNormalCallClearing.

    92  *

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

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

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

    96  * to indicate the reason for rejection.

    97  *

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

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

   100  *

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

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

   103  * aCauseCode = KErrGsmCCUserBusy.

   104  *

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

   106  *

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

   108  *

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

   110  *

   111  * @see RMobileCall::NotifyMobileCallStatusChange()

   112  */

   113 	{

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

   115 

   116 	// Forward completion to correct dispatcher object to handle

   117 	__ASSERT_DEBUG(iDispatcherHolder, CtsyDispatcherPanic(EInvalidNullPtr));

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

   119 

   120 	} // CCtsyDispatcherCallback::CallbackCallControlNotifyCallStatusChangeInd

   121 

   122 

   123 EXPORT_C void CCtsyDispatcherCallback::CallbackCallControlReceiveUuiInd(

   124 	TInt aError, TInt aCallId, const TDesC& aCallUui)

   125 /**

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

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

   128  * is detailed in 3GPP TS 24.087.

   129  *

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

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

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

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

   134  *

   135  * @see RMobileCall:ReceiveUUI()

   136  */

   137 	{

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

   139 

   140 	// Forward completion to correct dispatcher object to handle

   141 	__ASSERT_DEBUG(iDispatcherHolder, CtsyDispatcherPanic(EInvalidNullPtr));

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

   143 

   144 	} // CCtsyDispatcherCallback::CallbackCallControlReceiveUuiInd

   145 

   146 

   147 EXPORT_C void CCtsyDispatcherCallback::CallbackCallControlNotifyDataCallCapsChangeInd(

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

   149 /**

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

   151  * capabilities.

   152  *

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

   154  *

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

   156  *

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

   158  *

   159  * @see RMobileCall::NotifyMobileDataCallCapsChange()

   160  */

   161 	{

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

   163 

   164 	// Forward completion to correct dispatcher object to handle

   165 	__ASSERT_DEBUG(iDispatcherHolder, CtsyDispatcherPanic(EInvalidNullPtr));

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

   167 

   168 	} // CCtsyDispatcherCallback::CallbackCallControlNotifyDataCallCapsChangeInd

   169 

   170 EXPORT_C void CCtsyDispatcherCallback::CallbackCallControlNotifyIncomingCallInd(

   171 	TInt aError, const RMobileCall::TMobileCallInfoV1& aCallInfo)

   172 /**

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

   174  *

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

   176  * the incoming call.

   177  *

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

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

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

   181  * in CCtsyDispatcherCallback::CallbackCallControlDialVoiceComp().

   182  *

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

   184  * is mandatory

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

   186  * incoming call.

   187  *

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

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

   190  *

   191  *  - If the incoming voice call is on the auxiliary

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

   193  *

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

   195  * RMobilePhone::ECircuitDataService.

   196  *

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

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

   199  * RMobileCall::TMobileCallInfoV1 for more details.

   200  *

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

   202  * @param aCallInfo Information about the incoming call.

   203  *

   204  * @see RLine::NotifyIncomingCall()

   205  */

   206 	{

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

   208 

   209 	// Forward completion to correct dispatcher object to handle

   210 	__ASSERT_DEBUG(iDispatcherHolder, CtsyDispatcherPanic(EInvalidNullPtr));

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

   212 

   213 	} // CCtsyDispatcherCallback::CallbackCallControlNotifyIncomingCallInd

   214 

   215 EXPORT_C void CCtsyDispatcherCallback::CallbackCallControlNotifyHscsdInfoChangeInd(

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

   217 	const RMobileCall::TMobileCallDataCapsV1& aCallCaps)

   218 /**

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

   220  * about the specified HSCSD call.

   221  *

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

   223  *

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

   225  *

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

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

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

   229  * of the call via RMobileCall::NotifyHscsdInfoChange()

   230  *

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

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

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

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

   235  * following fields have changed their value:

   236  * RMobileCall::TMobileCallDataCapsV1::iMaxRxTimeSlots ,

   237  * RMobileCall::TMobileCallDataCapsV1::iMaxTxTimeSlots ,

   238  * RMobileCall::TMobileCallDataCapsV1::iHscsdSupport ,

   239  * RMobileCall::TMobileCallDataCapsV1::iSpeedCaps ,

   240  *

   241  * @see RMobileCall::NotifyMobileDataCallCapsChange()

   242  * @see RMobileCall::NotifyHscsdInfoChange()

   243  */

   244 	{

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

   246 

   247 	// Forward completion to correct dispatcher object to handle

   248 	__ASSERT_DEBUG(iDispatcherHolder, CtsyDispatcherPanic(EInvalidNullPtr));

   249 	iDispatcherHolder->GetCallControlDispatcher().CallbackNotifyHscsdInfoChange(aError,

   250 			aCallId, aCallParams, aCallCaps);

   251 

   252 	} // CCtsyDispatcherCallback::CallbackCallControlNotifyHscsdInfoChangeInd

   253 

   254 EXPORT_C void CCtsyDispatcherCallback::CallbackCallControlNotifyCallEventInd(

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

   256 /**

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

   258  * the remote party has put the call on hold.

   259  *

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

   261  * KErrNone if there is no error.

   262  *

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

   264  *

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

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

   267  * RMobileCall::ERemoteResume, RMobileCall::ERemoteTerminated and

   268  * RMobileCall::ERemoteConferenceCreate

   269  *

   270  * @see RMobileCall::NotifyCallEvent()

   271  */

   272 	{

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

   274 

   275 	// Forward completion to correct dispatcher object to handle

   276 	__ASSERT_DEBUG(iDispatcherHolder, CtsyDispatcherPanic(EInvalidNullPtr));

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

   278 

   279 	} // CCtsyDispatcherCallback::CallbackCallControlNotifyCallEventInd

   280 

   281 

   282 EXPORT_C void CCtsyDispatcherCallback::CallbackCallControlNotifyCallInfoChangeInd(

   283 	TInt aError, const RMobileCall::TMobileCallInfoV1& aMobileCallInfo)

   284 /**

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

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

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

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

   289  *

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

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

   292  *

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

   294  * KErrNone if there is no error.

   295  *

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

   297  * by aCallId.

   298  *

   299  * @see RMobileCall::GetMobileCallInfo()

   300  * @see RMobileCall::NotifyRemotePartyInfoChange()

   301  */

   302 	{

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

   304 

   305 	// Forward completion to correct dispatcher object to handle

   306 	__ASSERT_DEBUG(iDispatcherHolder, CtsyDispatcherPanic(EInvalidNullPtr));

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

   308 

   309 	} // CCtsyDispatcherCallback::CallbackCallControlNotifyCallInfoChangeInd

   310 

   311 

   312 EXPORT_C void CCtsyDispatcherCallback::CallbackCallControlRemoteAlertingToneChangeInd(

   313 	TInt aError, RMmCustomAPI::TRemoteAlertingToneStatus aRemoteAlertingTone)

   314 /**

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

   316  * been set or changed.

   317  *

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

   319  * KErrNone if there is no error.

   320  *

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

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

   323  *

   324  * @see RMmCustomAPI::GetRemoteAlertingToneStatus()

   325  * @see RMmCustomAPI::NotifyRemoteAlertingToneStatusChange()

   326  */

   327 	{

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

   329 

   330 	// Forward completion to correct dispatcher object to handle

   331 	__ASSERT_DEBUG(iDispatcherHolder, CtsyDispatcherPanic(EInvalidNullPtr));

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

   333 

   334 	} // CCtsyDispatcherCallback::CallbackCallControlRemoteAlertingToneChangeInd

   335 

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

   337 /**

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

   339  * MLtsyDispatchCallControlAnswer::HandleAnswerReqL()

   340  *

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

   342  * incoming call.

   343  *

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

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

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

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

   348  *

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

   350  *

   351  * @see RCall::AnswerIncomingCall()

   352  * @see RCall::AnswerIncomingCallISV()

   353  * @see CTelephony::AnswerIncomingCall()

   354  */

   355 	{

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

   357 

   358 	// Forward completion to correct dispatcher object to handle

   359 	__ASSERT_DEBUG(iDispatcherHolder, CtsyDispatcherPanic(EInvalidNullPtr));

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

   361 

   362 	} // CCtsyDispatcherCallback::CallbackCallControlAnswerComp

   363 

   364 

   365 EXPORT_C void CCtsyDispatcherCallback::CallbackCallControlHoldComp(

   366 	TInt aError, TInt aCallId)

   367 /**

   368  *

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

   370  * MLtsyDispatchCallControlHold::HandleHoldReqL()

   371  *

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

   373  * to the Common TSY.

   374  *

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

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

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

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

   379  *

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

   381  *

   382  * @see RMobileCall::Hold()

   383  */

   384 	{

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

   386 

   387 	// Forward completion to correct dispatcher object to handle

   388 	__ASSERT_DEBUG(iDispatcherHolder, CtsyDispatcherPanic(EInvalidNullPtr));

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

   390 

   391 	} // CCtsyDispatcherCallback::CallbackCallControlHoldComp

   392 

   393 EXPORT_C void CCtsyDispatcherCallback::CallbackCallControlDialEmergencyComp(

   394 	TInt aError, TInt aCallId)

   395 /**

   396  *

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

   398  * MLtsyDispatchCallControlDialEmergency::HandleDialEmergencyReqL()

   399  *

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

   401  * initiate the dialling process to dial an emergency call.

   402  *

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

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

   405  *

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

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

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

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

   410  * CCtsyDispatcherCallback::CallbackCallControlDialVoiceComp for precise details

   411  * on how to allocate a valid call ID.

   412  *

   413  * @see RMobileCall::DialEmergencyCall()

   414  */

   415 	{

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

   417 

   418 	// Forward completion to correct dispatcher object to handle

   419 	__ASSERT_DEBUG(iDispatcherHolder, CtsyDispatcherPanic(EInvalidNullPtr));

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

   421 

   422 	} // CCtsyDispatcherCallback::CallbackCallControlDialEmergencyComp

   423 

   424 EXPORT_C void CCtsyDispatcherCallback::CallbackCallControlStopDtmfToneComp(TInt aError)

   425 /**

   426  *

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

   428  * MLtsyDispatchCallControlStopDtmfTone::HandleStopDtmfToneReqL()

   429  *

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

   431  *

   432  * @see RMobilePhone::StopDTMFTone()

   433  */

   434 	{

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

   436 

   437 	// Forward completion to correct dispatcher object to handle

   438 	__ASSERT_DEBUG(iDispatcherHolder, CtsyDispatcherPanic(EInvalidNullPtr));

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

   440 

   441 	} // CCtsyDispatcherCallback::CallbackCallControlStopDtmfToneComp

   442 

   443 

   444 EXPORT_C void CCtsyDispatcherCallback::CallbackCallControlSetActiveAlsLineComp(TInt aError)

   445 /**

   446  *

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

   448  * MLtsyDispatchCallControlSetActiveAlsLine::HandleSetActiveAlsLineReqL()

   449  *

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

   451  *

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

   453  *

   454  * @see RMobilePhone::SetALSLine()

   455  */

   456 	{

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

   458 

   459 	// Forward completion to correct dispatcher object to handle

   460 	__ASSERT_DEBUG(iDispatcherHolder, CtsyDispatcherPanic(EInvalidNullPtr));

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

   462 

   463 	} // CCtsyDispatcherCallback::CallbackCallControlSetActiveAlsLineComp

   464 

   465 EXPORT_C void CCtsyDispatcherCallback::CallbackCallControlSendDtmfTonesCancelComp(TInt aError)

   466 /**

   467  *

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

   469  * MLtsyDispatchCallControlSendDtmfTonesCancel::HandleSendDtmfTonesCancelReqL()

   470  *

   471  *

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

   473  *

   474  * @see RMobilePhone::SendDTMFTones()

   475  */

   476 	{

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

   478 

   479 	// Forward completion to correct dispatcher object to handle

   480 	__ASSERT_DEBUG(iDispatcherHolder, CtsyDispatcherPanic(EInvalidNullPtr));

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

   482 

   483 	} // CCtsyDispatcherCallback::CallbackCallControlSendDtmfTonesCancelComp

   484 

   485 EXPORT_C void CCtsyDispatcherCallback::CallbackCallControlHangUpComp(

   486 	TInt aError, TInt aCallId)

   487 /**

   488  *

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

   490  * MLtsyDispatchCallControlHangUp::HandleHangUpReqL()

   491  *

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

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

   494  * the failure otherwise.

   495  *

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

   497  *

   498  * @see RCall::HangUp()

   499  */

   500 	{

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

   502 

   503 	// Forward completion to correct dispatcher object to handle

   504 	__ASSERT_DEBUG(iDispatcherHolder, CtsyDispatcherPanic(EInvalidNullPtr));

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

   506 

   507 	} // CCtsyDispatcherCallback::CallbackCallControlHangUpComp

   508 

   509 EXPORT_C void CCtsyDispatcherCallback::CallbackCallControlResumeComp(

   510 	TInt aError, TInt aCallId)

   511 /**

   512  *

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

   514  * MLtsyDispatchCallControlResume::HandleResumeReqL()

   515  *

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

   517  * passed back to the Common TSY.

   518  *

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

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

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

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

   523  *

   524  * @param aCallId The Call ID of the call which has been requested to be resumed.

   525  *

   526  * @see RMobileCall::Resume()

   527  */

   528 	{

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

   530 

   531 	// Forward completion to correct dispatcher object to handle

   532 	__ASSERT_DEBUG(iDispatcherHolder, CtsyDispatcherPanic(EInvalidNullPtr));

   533 	iDispatcherHolder->GetCallControlDispatcher().CallbackResume(aError, aCallId);

   534 

   535 	} // CCtsyDispatcherCallback::CallbackCallControlResumeComp

   536 

   537 EXPORT_C void CCtsyDispatcherCallback::CallbackCallControlSetDynamicHscsdParamsComp(

   538 	TInt aError, TInt aCallId)

   539 /**

   540  *

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

   542  * MLtsyDispatchCallControlSetDynamicHscsdParams::HandleSetDynamicHscsdParamsReqL()

   543  *

   544  * This callback indicates that the request to set the dynamic HSCSD parameters

   545  * has been made (successfully or unsuccessfully). To notify the CTSY of a change

   546  * in the HSCSD information of the call, see the API

   547  * CCtsyDispatcherCallback::CallbackCallControlNotifyHscsdInfoChangeInd()

   548  *

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

   550  *

   551  * @see RMobileCall::SetDynamicHscsdParams()

   552  */

   553 	{

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

   555 

   556 	// Forward completion to correct dispatcher object to handle

   557 	__ASSERT_DEBUG(iDispatcherHolder, CtsyDispatcherPanic(EInvalidNullPtr));

   558 	iDispatcherHolder->GetCallControlDispatcher().CallbackSetDynamicHscsdParams(aError, aCallId);

   559 

   560 	} // CCtsyDispatcherCallback::CallbackCallControlSetDynamicHscsdParamsComp

   561 

   562 EXPORT_C void CCtsyDispatcherCallback::CallbackCallControlDialVoiceComp(

   563 	TInt aError, TInt aCallId)

   564 /**

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

   566  * MLtsyDispatchCallControlDialVoice::HandleDialVoiceReqL()

   567  *

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

   569  * initiate the dialling process. To indicate progress of the call as it becomes

   570  * connected, use

   571  * CCtsyDispatcherCallback::CallbackCallControlNotifyCallStatusChangeInd().

   572  *

   573  * When a dial attempt is made via the above mentioned interface, the LTSY has the

   574  * responsibility of allocating a unique Call ID to the call.  For more

   575  * information, see the documentation on aCallId below.

   576  *

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

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

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

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

   581  *

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

   583  * has been allocated by the LTSY.  This should be a number between 1 and

   584  * KMaxCallIdValue and should be unique across all call modes (voice, data etc.

   585  * including emergency calls). For example, if a request for a voice call is made

   586  * and the LTSY allocates

   587  * this call an ID of 1 and a request for a data call is requested, the LTSY

   588  * should allocate a Call ID which is not the same as that already allocated for

   589  * the first voice call.

   590  *

   591  * @see RCall::Dial()

   592  */

   593 	{

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

   595 

   596 	// Forward completion to correct dispatcher object to handle

   597 	__ASSERT_DEBUG(iDispatcherHolder, CtsyDispatcherPanic(EInvalidNullPtr));

   598 	iDispatcherHolder->GetCallControlDispatcher().CallbackDialVoice(aError, aCallId);

   599 

   600 	} // CCtsyDispatcherCallback::CallbackCallControlDialVoiceComp

   601 

   602 EXPORT_C void CCtsyDispatcherCallback::CallbackCallControlTransferComp(TInt aError)

   603 /**

   604  *

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

   606  * MLtsyDispatchCallControlTransfer::HandleTransferReqL()

   607  *

   608  * Informs the CTSY of the outcome of initiating the transfer process.

   609  *

   610  * Successful completion of the transfer process is indicated by a change

   611  * in the call status of the calls which were transferred.

   612  *

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

   614  *

   615  * @see RMobileCall::Transfer()

   616  */

   617 	{

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

   619 

   620 	// Forward completion to correct dispatcher object to handle

   621 	__ASSERT_DEBUG(iDispatcherHolder, CtsyDispatcherPanic(EInvalidNullPtr));

   622 	iDispatcherHolder->GetCallControlDispatcher().CallbackTransfer(aError);

   623 

   624 	} // CCtsyDispatcherCallback::CallbackCallControlTransferComp

   625 

   626 EXPORT_C void CCtsyDispatcherCallback::CallbackCallControlSendDtmfTonesComp(

   627 		TInt aError)

   628 /**

   629  *

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

   631  * MLtsyDispatchCallControlSendDtmfTones::HandleSendDtmfTonesReqL()

   632  *

   633  * This callback indicates that the DTMF string has been sent.

   634  *

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

   636  *

   637  * @see RMobilePhone::SendDTMFTones()

   638  */

   639 	{

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

   641 

   642 	// Forward completion to correct dispatcher object to handle

   643 	__ASSERT_DEBUG(iDispatcherHolder, CtsyDispatcherPanic(EInvalidNullPtr));

   644 	iDispatcherHolder->GetCallControlDispatcher().CallbackSendDtmfTones(aError);

   645 

   646 	} // CCtsyDispatcherCallback::CallbackCallControlSendDtmfTonesComp

   647 

   648 EXPORT_C void CCtsyDispatcherCallback::CallbackCallControlGetIdentityServiceStatusComp(

   649 	TInt aError, RMobilePhone::TMobilePhoneIdServiceStatus aIdentityServiceStatus)

   650 /**

   651  *

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

   653  * MLtsyDispatchCallControlGetIdentityServiceStatus::HandleGetIdentityServiceStatusReqL()

   654  *

   655  *

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

   657  *

   658  * @param aIdentityServiceStatus The status of the service requested in

   659  * MLtsyDispatchCallControlGetIdentityServiceStatus::HandleGetIdentityServiceStatusReqL()

   660  *

   661  * @see RMobilePhone::GetIdentityServiceStatus()

   662  */

   663 	{

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

   665 

   666 	// Forward completion to correct dispatcher object to handle

   667 	__ASSERT_DEBUG(iDispatcherHolder, CtsyDispatcherPanic(EInvalidNullPtr));

   668 	iDispatcherHolder->GetCallControlDispatcher().CallbackGetIdentityServiceStatus(aError, aIdentityServiceStatus);

   669 

   670 	} // CCtsyDispatcherCallback::CallbackCallControlGetIdentityServiceStatusComp

   671 

   672 EXPORT_C void CCtsyDispatcherCallback::CallbackCallControlSwapComp(

   673 	TInt aError)

   674 /**

   675  *

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

   677  * MLtsyDispatchCallControlSwap::HandleSwapReqL()

   678  *

   679  *

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

   681  * indicating the outcome of the attempt to swap the requested calls.  This should

   682  * be KErrNone if the swap process could be started successfully.  Otherwise

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

   684  *

   685  * @see RMobileCall::Swap()

   686  */

   687 	{

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

   689 

   690 	// Forward completion to correct dispatcher object to handle

   691 	__ASSERT_DEBUG(iDispatcherHolder, CtsyDispatcherPanic(EInvalidNullPtr));

   692 	iDispatcherHolder->GetCallControlDispatcher().CallbackSwap(aError);

   693 

   694 	} // CCtsyDispatcherCallback::CallbackCallControlSwapComp

   695 

   696 EXPORT_C void CCtsyDispatcherCallback::CallbackCallControlStartDtmfToneComp(TInt aError)

   697 /**

   698  *

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

   700  * MLtsyDispatchCallControlStartDtmfTone::HandleStartDtmfToneReqL()

   701  *

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

   703  * indicating the outcome of the request to send the DTMF tone.

   704  *

   705  * @see RMobilePhone::StartDTMFTone()

   706  */

   707 	{

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

   709 

   710 	// Forward completion to correct dispatcher object to handle

   711 	__ASSERT_DEBUG(iDispatcherHolder, CtsyDispatcherPanic(EInvalidNullPtr));

   712 	iDispatcherHolder->GetCallControlDispatcher().CallbackStartDtmfTone(aError);

   713 

   714 	} // CCtsyDispatcherCallback::CallbackCallControlStartDtmfToneComp

   715 

   716 EXPORT_C void CCtsyDispatcherCallback::CallbackCallControlNotifyIccCallForwardingStatusChangeInd(

   717 	TInt aError, const RMobilePhone::TMobileAddress& aCallForwardingNo,

   718 	RMobilePhone::TCFUIndicatorStatusFlags aCallForwardingStatusFlags,

   719 	RMmCustomAPI::TMultipleSubscriberProfileID aMultipleSubscriberProfileId

   720 	)

   721 /**

   722  * Callback function to be used to indicate a change in ICC Call Forwarding.

   723  *

   724  * @param aError The error code to be returned to the CTSY Dispatcher.

   725  * @param aCallForwardingNo the number that is being forwarded.

   726  * @param aCallForwardingStatusFlags flags defined in RMobilePhone::TCFUIndicatorStatus.

   727  * @param aMultipleSubscriberProfileId in case of Multiple Subscriber (SIM) the Profile ID.

   728  * @see RMmCustomApi::NotifyIccCallForwardingStatusChange()

   729  */

   730 	{

   731 	TSYLOGENTRYEXITARGS(_L8("aError=%d,aCFSFlags=%x,aMSPId=%d"), 

   732 			aError,aCallForwardingStatusFlags,static_cast<TUint32>(aMultipleSubscriberProfileId));

   733 

   734 	// Forward completion to correct dispatcher object to handle

   735 	__ASSERT_DEBUG(iDispatcherHolder, CtsyDispatcherPanic(EInvalidNullPtr));

   736 	iDispatcherHolder->GetCallControlDispatcher().CallbackNotifyIccCallForwardingStatusChange(aError, 

   737 			aCallForwardingNo, aCallForwardingStatusFlags, aMultipleSubscriberProfileId);

   738 

   739 	} // CCtsyDispatcherCallback::CallbackCallControlNotifyIccCallForwardingStatusChangeInd

   740 

   741 EXPORT_C void CCtsyDispatcherCallback::CallbackPhoneGetFdnStatusComp(

   742 		TInt aError,

   743 		RMobilePhone::TMobilePhoneFdnStatus aFdnStatus)

   744 /**

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

   746  * MLtsyDispatchPhoneGetFdnStatus::HandleGetFdnStatusReqL()

   747  * back to the CTSY Dispatcher.

   748  *

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

   750  * @param aFdnStatus The FDN status to be returned to the CTSY Dispatcher.

   751  *

   752  * @see RMobilePhone::GetFdnStatus()

   753  */

   754 	{

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

   756 

   757 	// Forward completion to correct dispatcher object to handle

   758 	__ASSERT_DEBUG(iDispatcherHolder, CtsyDispatcherPanic(EInvalidNullPtr));

   759 	iDispatcherHolder->GetPhoneDispatcher().CallbackGetFdnStatus(aError, aFdnStatus);

   760 

   761 	} // CCtsyDispatcherCallback::CallbackPhoneGetFdnStatusComp

   762 

   763 

   764 EXPORT_C void CCtsyDispatcherCallback::CallbackPhoneGetNetworkRegistrationStatusComp(

   765 	TInt aError, RMobilePhone::TMobilePhoneRegistrationStatus aRegStatus)

   766 /**

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

   768  * MLtsyDispatchPhoneGetNetworkRegistrationStatus::HandleGetNetworkRegistrationStatusReqL()

   769  * back to the CTSY Dispatcher.

   770  *

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

   772  * @param aRegStatus Current network registration status.

   773  *

   774  * @see RMobilePhone::GetNetworkRegistrationStatus()

   775  */

   776 	{

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

   778 

   779 	// Forward completion to correct dispatcher object to handle

   780 	__ASSERT_DEBUG(iDispatcherHolder, CtsyDispatcherPanic(EInvalidNullPtr));

   781 	iDispatcherHolder->GetPhoneDispatcher().CallbackGetNetworkRegistrationStatus(aError, aRegStatus);

   782 

   783 	} // CCtsyDispatcherCallback::CallbackPhoneGetNetworkRegistrationStatusComp

   784 

   785 EXPORT_C void CCtsyDispatcherCallback::CallbackSatUssdControlSupportedChangeInd(

   786 	TInt aError, TBool aSupported)

   787 /**

   788  *

   789  * This indicator is used by the LTSY to inform the CTSY as to whether USSD TLV

   790  * are supported by the NAA for control.

   791  *

   792  *

   793  * @param aError The error code to be returned to the CTSY Dispatcher.

   794  * @param aSupported ETrue if USSD control TLV is supported, EFalse otherwise.

   795  * @see RSat::NotifyCallControlRequest()

   796  */

   797 	{

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

   799 

   800 	// Forward completion to correct dispatcher object to handle

   801 	__ASSERT_DEBUG(iDispatcherHolder, CtsyDispatcherPanic(EInvalidNullPtr));

   802 	iDispatcherHolder->GetSatDispatcher().CallbackUssdControlSupported(aError, aSupported);

   803 

   804 	} // CCtsyDispatcherCallback::CallbackSatUssdControlSupportedChangeInd

   805 

   806 

   807 

   808 EXPORT_C void CCtsyDispatcherCallback::CallbackPhoneBootNotifyModemStatusReadyComp(TInt aError, TRfStateInfo aRfStatus)

   809 /**

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

   811  * MLtsyDispatchPhoneBootNotifyModemStatusReady::HandleBootNotifyModemStatusReadyReqL()

   812  * back to the CTSY Dispatcher.

   813  *

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

   815  * @param aRfStatus The current RF status. See TRfStateInfo.

   816  */

   817 	{

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

   819 

   820 	// Forward completion to correct dispatcher object to handle

   821 	__ASSERT_DEBUG(iDispatcherHolder, CtsyDispatcherPanic(EInvalidNullPtr));

   822 	iDispatcherHolder->GetPhoneDispatcher().CallbackBootNotifyModemStatusReady(aError, aRfStatus);

   823 

   824 	} // CCtsyDispatcherCallback::CallbackPhoneBootNotifyModemStatusReady

   825 

   826 

   827 EXPORT_C void CCtsyDispatcherCallback::CallbackPhoneBootNotifySimStatusReadyComp(TInt aError)

   828 /**

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

   830  * MLtsyDispatchPhoneBootNotifySimStatusReady::HandleBootNotifySimStatusReadyReqL()

   831  * back to the CTSY Dispatcher.

   832  *

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

   834  */

   835 	{

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

   837 

   838 	// Forward completion to correct dispatcher object to handle

   839 	__ASSERT_DEBUG(iDispatcherHolder, CtsyDispatcherPanic(EInvalidNullPtr));

   840 	iDispatcherHolder->GetPhoneDispatcher().CallbackBootNotifySimStatusReady(aError);

   841 

   842 	} // CCtsyDispatcherCallback::CallbackPhoneBootNotifySimStatusReadyComp

   843 

   844 EXPORT_C void CCtsyDispatcherCallback::CallbackPhoneGetHomeNetworkComp(TInt aError,

   845 		const RMobilePhone::TMobilePhoneNetworkInfoV5& aNetworkInfo)

   846 /**

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

   848  * MLtsyDispatchPhoneGetHomeNetwork::HandleGetHomeNetworkReqL()

   849  * back to the CTSY Dispatcher.

   850  *

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

   852  * @param aNetworkInfo Contains home network information.

   853  * request.

   854  *

   855  * @see RMobilePhone::GetHomeNetwork()

   856  */

   857 	{

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

   859 

   860 	// Forward completion to correct dispatcher object to handle

   861 	__ASSERT_DEBUG(iDispatcherHolder, CtsyDispatcherPanic(EInvalidNullPtr));

   862 	iDispatcherHolder->GetPhoneDispatcher().CallbackGetHomeNetwork(aError, aNetworkInfo);

   863 

   864 	} // CCtsyDispatcherCallback::CallbackPhoneGetHomeNetworkComp

   865 

   866 EXPORT_C void CCtsyDispatcherCallback::CallbackCallControlGetActiveAlsLineComp(

   867 	TInt aError, RMobilePhone::TMobilePhoneALSLine aAlsLine)

   868 /**

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

   870  * MLtsyDispatchCallControlGetActiveAlsLine::HandleGetActiveAlsLineReqL()

   871  * back to the CTSY Dispatcher.

   872  *

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

   874  * @param aAlsLine The current active ALS line.

   875  *

   876  * @see RMobilePhone::GetALSLine()

   877  */

   878 	{

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

   880 

   881 	// Forward completion to correct dispatcher object to handle

   882 	__ASSERT_DEBUG(iDispatcherHolder, CtsyDispatcherPanic(EInvalidNullPtr));

   883 	iDispatcherHolder->GetCallControlDispatcher().CallbackGetActiveAlsLine(aError, aAlsLine);

   884 

   885 	} // CCtsyDispatcherCallback::CallbackPhoneGetActiveAlsLineComp

   886 

   887 EXPORT_C void CCtsyDispatcherCallback::CallbackSimGetIccMessageWaitingIndicatorsComp(

   888 	TInt aError, const RMobilePhone::TMobilePhoneMessageWaitingV1& aMessageWaiting)

   889 /**

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

   891  * MLtsyDispatchPhoneGetIccMessageWaitingIndicators::HandleGetIccMessageWaitingIndicatorsReqL()

   892  * back to the CTSY Dispatcher.

   893  *

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

   895  * @param aMessageWaiting The message waiting indicators to return.

   896  *

   897  * @see RMobilePhone::GetIccMessageWaitingIndicators()

   898  */

   899 	{

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

   901 

   902 	// Forward completion to correct dispatcher object to handle

   903 	__ASSERT_DEBUG(iDispatcherHolder, CtsyDispatcherPanic(EInvalidNullPtr));

   904 	iDispatcherHolder->GetSimDispatcher().CallbackGetIccMessageWaitingIndicators(aError, aMessageWaiting);

   905 

   906 	} // CCtsyDispatcherCallback::CallbackPhoneGetIccMessageWaitingIndicatorsComp

   907 

   908 EXPORT_C void CCtsyDispatcherCallback::CallbackSimGetServiceTableComp(

   909 	TInt aError, const RMobilePhone::TMobilePhoneServiceTableV1& aServiceTable)

   910 /**

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

   912  * MLtsyDispatchSimGetServiceTable::HandleGetServiceTableReqL()

   913  * back to the CTSY Dispatcher.

   914  *

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

   916  * @param aServiceTable The service table to return.

   917  *

   918  * @see RMobilePhone::GetServiceTable()

   919  */

   920 	{

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

   922 

   923 	// Forward completion to correct dispatcher object to handle

   924 	__ASSERT_DEBUG(iDispatcherHolder, CtsyDispatcherPanic(EInvalidNullPtr));

   925 	iDispatcherHolder->GetSimDispatcher().CallbackGetServiceTable(aError, aServiceTable);

   926 

   927 	} // CCtsyDispatcherCallback::CallbackSimGetServiceTable

   928 

   929 EXPORT_C void CCtsyDispatcherCallback::CallbackPhoneNotifyNetworkModeChangeInd(

   930 	TInt aError,

   931 	RMobilePhone::TMobilePhoneNetworkMode aNetworkMode)

   932 /**

   933  *

   934  * Callback function to be used by the Licensee LTSY to indicate changes to the current network mode

   935  *

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

   937  * @param aNetworkMode The network mode to be sent to the CTSY Dispatcher.

   938  */

   939 	{

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

   941 

   942 	// Forward completion to correct dispatcher object to handle

   943 	__ASSERT_DEBUG(iDispatcherHolder, CtsyDispatcherPanic(EInvalidNullPtr));

   944 	iDispatcherHolder->GetPhoneDispatcher().CallbackNotifyNetworkModeChange(aError, aNetworkMode);

   945 

   946 	} // CCtsyDispatcherCallback::CallbackPhoneNotifyNetworkModeChangeInd

   947 

   948 EXPORT_C void CCtsyDispatcherCallback::CallbackPhoneNotifyEgprsInfoChangeInd(

   949 	TInt aError,

   950 	TBool aEdgeSupported)

   951 /**

   952  *

   953  * Callback function to be used by the Licensee LTSY to indicate an EGPRS/GPRS information change.

   954  *

   955  *

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

   957  * @param aEdgeSupported If EGPRS is supported on the current cell.

   958  */

   959 	{

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

   961 

   962 	// Forward completion to correct dispatcher object to handle

   963 	__ASSERT_DEBUG(iDispatcherHolder, CtsyDispatcherPanic(EInvalidNullPtr));

   964 	iDispatcherHolder->GetPhoneDispatcher().CallbackNotifyEgprsInfoChange(aError, aEdgeSupported);

   965 

   966 	} // CCtsyDispatcherCallback::CallbackPhoneNotifyEgprsInfoChangeInd

   967 

   968 EXPORT_C void CCtsyDispatcherCallback::CallbackPhoneNotifySignalStrengthChangeInd(

   969 	TInt aError,

   970 	TInt32 aSignalStrength,

   971 	TInt8 aBar)

   972 /**

   973  *

   974  * Callback function to be used by the Licensee LTSY to indicate change to signal strength.

   975  *

   976  *

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

   978  * @param aSignalStrength The signal strength to be sent to the CTSY Dispatcher

   979  * @param aBar The number of bars to display.

   980  *

   981  * @see RMobilePhone::NotifySignalStrengthChange()

   982  * @see RMobilePhone::GetSignalStrength()

   983  */

   984 	{

   985 	TSYLOGENTRYEXITARGS(_L8("aError=%d, aSignalStrength=%d, aBar=%d"), aError, aSignalStrength, aBar);

   986 

   987 	// Forward completion to correct dispatcher object to handle

   988 	__ASSERT_DEBUG(iDispatcherHolder, CtsyDispatcherPanic(EInvalidNullPtr));

   989 	iDispatcherHolder->GetPhoneDispatcher().CallbackNotifySignalStrengthChange(aError, aSignalStrength, aBar);

   990 

   991 	} // CCtsyDispatcherCallback::CallbackPhoneNotifySignalStrengthChangeInd

   992 

   993 

   994 EXPORT_C void CCtsyDispatcherCallback::CallbackPhoneNotifyNetworkRegistrationStatusChangeInd(

   995 	TInt aError,

   996 	RMobilePhone::TMobilePhoneRegistrationStatus aRegStatus)

   997 /**

   998  * Callback function to be used by the Licensee LTSY to indicate a change in the

   999  * network registration status.

  1000  *

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

  1002  * @param aRegStatus Current network registration status.

  1003  *

  1004  * @see RMobilePhone::NotifyNetworkRegistrationStatusChange()

  1005  */

  1006 	{

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

  1008 

  1009 	// Forward completion to correct dispatcher object to handle

  1010 	__ASSERT_DEBUG(iDispatcherHolder, CtsyDispatcherPanic(EInvalidNullPtr));

  1011 	iDispatcherHolder->GetPhoneDispatcher().CallbackNotifyNetworkRegistrationStatusChange(aError, aRegStatus);

  1012 

  1013 	} // CCtsyDispatcherCallback::CallbackPhoneNotifyNetworkRegistrationStatusChangeInd

  1014 

  1015 EXPORT_C void CCtsyDispatcherCallback::CallbackPhoneNotifyNitzInfoChangeInd(

  1016 	TInt aError,

  1017 	const RMobilePhone::TMobilePhoneNITZ& aNitzInfo)

  1018 /**

  1019  *

  1020  * Callback function to be used by the Licensee LTSY to indicate a change in the current

  1021  * Network Information and Time Zone (NITZ).

  1022  *

  1023  *  - The RMobilePhone::TMobilePhoneNITZ::iNitzFieldsUsed field in the

  1024  *  aNitzInfo parameter should be used to reflect which of the data fields are present.

  1025  *  The fields RMobilePhone::TMobilePhoneNITZ::iShortNetworkId and

  1026  *  RMobilePhone::TMobilePhoneNITZ::iLongNetworkId may be left

  1027  *  blank if not known at this time.

  1028  *

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

  1030  *

  1031  * @param aNitzInfo The current NITZ information to be sent to the CTSY Dispatcher.

  1032  *

  1033  * @see RMobilePhone::NotifyNITZInfoChange()

  1034  */

  1035 	{

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

  1037 

  1038 	// Forward completion to correct dispatcher object to handle

  1039 	__ASSERT_DEBUG(iDispatcherHolder, CtsyDispatcherPanic(EInvalidNullPtr));

  1040 	iDispatcherHolder->GetPhoneDispatcher().CallbackNotifyNitzInfoChange(aError, aNitzInfo);

  1041 

  1042 	} // CCtsyDispatcherCallback::CallbackPhoneNotifyNitzInfoChangeInd

  1043 

  1044 EXPORT_C void CCtsyDispatcherCallback::CallbackPhoneNotifyBatteryInfoChangeInd(

  1045 	TInt aError,

  1046 	const RMobilePhone::TMobilePhoneBatteryInfoV1& aBatteryInfo)

  1047 /**

  1048  *

  1049  * Callback function to be used by the Licensee LTSY to indicate any changes

  1050  * in the battery information.

  1051  *

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

  1053  * @param aBatteryInfo The battery information to be sent to the CTSY Dispatcher.

  1054  *

  1055  * @see RMobilePhone::GetBatteryInfo()

  1056  * @see RMobilePhone::NotifyBatteryInfoChange()

  1057  */

  1058 	{

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

  1060 

  1061 	// Forward completion to correct dispatcher object to handle

  1062 	__ASSERT_DEBUG(iDispatcherHolder, CtsyDispatcherPanic(EInvalidNullPtr));

  1063 	iDispatcherHolder->GetPhoneDispatcher().CallbackNotifyBatteryInfoChange(aError, aBatteryInfo);

  1064 

  1065 	} // CCtsyDispatcherCallback::CallbackPhoneNotifyBatteryInfoChangeInd

  1066 

  1067 EXPORT_C void CCtsyDispatcherCallback::CallbackPhoneNotifyCurrentNetworkChangeInd(

  1068 	TInt aError,

  1069 	const RMobilePhone::TMobilePhoneNetworkInfoV5& aNetworkInfo,

  1070 	const RMobilePhone::TMobilePhoneLocationAreaV1& aLocationArea)

  1071 /**

  1072  *

  1073  * Callback function to be used by the Licensee LTSY to indicate any changes in the current network.

  1074  *

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

  1076  * @param aNetworkInfo The network information to be sent to the CTSY Dispatcher.

  1077  * @param aLocationArea The mobile phone location area

  1078  *

  1079  * @see RMobilePhone::NotifyCurrentNetworkChange()

  1080  * @see RMobilePhone::GetCurrentNetwork()

  1081  */

  1082 	{

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

  1084 

  1085 	// Forward completion to correct dispatcher object to handle

  1086 	__ASSERT_DEBUG(iDispatcherHolder, CtsyDispatcherPanic(EInvalidNullPtr));

  1087 	iDispatcherHolder->GetPhoneDispatcher().CallbackNotifyCurrentNetworkChange(aError, aNetworkInfo, aLocationArea);

  1088 

  1089 	} // CCtsyDispatcherCallback::CallbackPhoneNotifyCurrentNetworkChangeInd

  1090 

  1091 

  1092 EXPORT_C void CCtsyDispatcherCallback::CallbackPhoneGetCurrentNetworkInfoComp(

  1093 	TInt aError,

  1094 	const RMobilePhone::TMobilePhoneNetworkInfoV5& aNetworkInfo,

  1095 	const RMobilePhone::TMobilePhoneLocationAreaV1& aLocationArea)

  1096 /**

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

  1098  * MLtsyDispatchPhoneGetCurrentNetworkInfo::HandleGetCurrentNetworkInfoReqL()

  1099  * back to the CTSY Dispatcher.

  1100  *

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

  1102  * @param aNetworkInfo The network information to be returned to the CTSY Dispatcher.

  1103  * @param aLocationArea The mobile phone location area.

  1104  *

  1105  * @see RMobilePhone::NotifyCurrentNetworkChange()

  1106  * @see RMobilePhone::GetCurrentNetwork()

  1107  */

  1108 	{

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

  1110 

  1111 	// Forward completion to correct dispatcher object to handle

  1112 	__ASSERT_DEBUG(iDispatcherHolder, CtsyDispatcherPanic(EInvalidNullPtr));

  1113 	iDispatcherHolder->GetPhoneDispatcher().CallbackGetCurrentNetworkInfo(aError, aNetworkInfo, aLocationArea);

  1114 

  1115 	} // CCtsyDispatcherCallback::CallbackPhoneGetCurrentNetworkInfoComp

  1116 

  1117 

  1118 EXPORT_C void CCtsyDispatcherCallback::CallbackPhoneGetNetworkModeComp(

  1119 	TInt aError,

  1120 	RMobilePhone::TMobilePhoneNetworkMode aNetworkMode)

  1121 /**

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

  1123  * MLtsyDispatchPhoneGetNetworkMode::HandleGetNetworkModeReqL()

  1124  * back to the CTSY Dispatcher.

  1125  *

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

  1127  * @param aNetworkMode The network mode to be sent to the CTSY Dispatcher.

  1128  *

  1129  * @see RMobilePhone::GetCurrentMode()

  1130  */

  1131 	{

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

  1133 

  1134 	// Forward completion to correct dispatcher object to handle