1 // Copyright (c) 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 // CLtsySupplementaryServicesHandler

    15 

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

    17 #include <mmtsy_ipcdefs.h>

    18 

    19 

    20 

    21 #include "cltsysupplementaryserviceshandler.h"

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

    23 #include "ltsymacros.h"

    24 

    25 

    26 

    27 CLtsySupplementaryServicesHandler::CLtsySupplementaryServicesHandler(

    28 	CCtsyDispatcherCallback& aCtsyDispatcherCallback)

    29 	: iCtsyDispatcherCallback(aCtsyDispatcherCallback)

    30 	{

    31 	}

    32 

    33 	

    34 CLtsySupplementaryServicesHandler::~CLtsySupplementaryServicesHandler()

    35 	{

    36 	}

    37 

    38 

    39 CLtsySupplementaryServicesHandler* CLtsySupplementaryServicesHandler::NewLC(

    40 	CCtsyDispatcherCallback& aCtsyDispatcherCallback)

    41 	{

    42 	TSYLOGENTRYEXIT;

    43 	CLtsySupplementaryServicesHandler* self = new (ELeave) CLtsySupplementaryServicesHandler(aCtsyDispatcherCallback);

    44 	CleanupStack::PushL(self);

    45 	self->ConstructL();

    46 	return self;

    47 	}

    48 

    49 

    50 CLtsySupplementaryServicesHandler* CLtsySupplementaryServicesHandler::NewL(CCtsyDispatcherCallback& aCtsyDispatcherCallback)

    51 	{

    52 	TSYLOGENTRYEXIT;

    53 	CLtsySupplementaryServicesHandler* self=

    54 			CLtsySupplementaryServicesHandler::NewLC(aCtsyDispatcherCallback);

    55 	CleanupStack::Pop(self);

    56 	return self;

    57 	}

    58 

    59 

    60 void CLtsySupplementaryServicesHandler::ConstructL()

    61 /**

    62  * Second phase constructor.

    63  */

    64 	{

    65 	TSYLOGENTRYEXIT;

    66 	

    67 	

    68 	} // CLtsySupplementaryServicesHandler::ConstructL

    69 

    70 TBool CLtsySupplementaryServicesHandler::IsInterfaceSupported(TLtsyDispatchInterfaceApiId aDispatchApiId)

    71 /**

    72  * Returns whether a Dispatch Interface APi is supported or not.

    73  * 

    74  * @param aDispatchApiId Id of Dispatch interface being queried.

    75  * @return indication whether interface is supported or not.

    76  */

    77 	{

    78 

    79 	switch(aDispatchApiId)

    80 		{

    81 		// Insert ApiIds when support is provided in LTSY e.g.

    82 		// case MLtsyDispatchPhoneBootNotifySimStatusReady::KLtsyDispatchPhoneBootNotifySimStatusReadyApiId: return ETrue;

    83 		

    84 		default:

    85 			return EFalse;

    86 		}

    87 	}

    88 

    89 void CLtsySupplementaryServicesHandler::IsCallbackIndicatorSupported(TLtsyDispatchIndIdGroup /*aIdGroup*/, TUint32& /*aIndIdBitMask*/)

    90 /**

    91  * Returns the set of callback indicators that are supported.

    92  * 

    93 * @param aIdGroup ID of group that is being queried e.g. aIdGroup=EIndIdGroup1.

    94 * @param aIndIdBitMask [out] argument that should return a bitmask indicating which indicator callbacks are supported.

    95  */

    96 	{

    97 

    98 	//Create bitmask with bitset for each indicator ID that is supported. E.g.

    99 	/*

   100 	if(aIdGroup == EIndIdGroup1)

   101 		aIndIdBitMask = KLtsyDispatchPhoneNotifyNetworkModeChangeIndId | 

   102 						KLtsyDispatchPhoneNotifyEgprsInfoChangeIndId | 

   103 						KLtsyDispatchPhoneNotifySignalStrengthChangeIndId;

   104 	else

   105 		aIndIdBitMask = 0; //no indicators from other groups supported

   106 	*/

   107 	}

   108 

   109 

   110 TInt CLtsySupplementaryServicesHandler::HandleSendNetworkServiceRequestNoFdnCheckReqL(const TDesC& /*aRequest*/)

   111 /**

   112  * This request is completed by invoking

   113  * CCtsyDispatcherCallback::CallbackSupplementaryServicesSendNetworkServiceRequestNoFdnCheckComp()

   114  *

   115  * @param aRequest The supplementary services string that was entered by the user and need to be send to the network.

   116  *

   117  * @return KErrNone on success, KErrNotSupported if this request is not supported,

   118  * or another error code to indicate the failure otherwise.

   119  */

   120 	{

   121 	TSYLOGENTRYEXIT;

   122 

   123 	TInt ret = KErrNotSupported;

   124 

   125 	// TODO: Add implementation here.......

   126 

   127 

   128 	return TSYLOGSETEXITERR(ret);

   129 	} // CLtsySupplementaryServicesHandler::HandleSendNetworkServiceRequestNoFdnCheckReqL

   130 

   131 

   132 TInt CLtsySupplementaryServicesHandler::HandleGetCallWaitingStatusReqL()

   133 /**

   134  * This request is completed by invoking

   135  * CCtsyDispatcherCallback::CallbackSupplementaryServicesGetCallWaitingStatusComp()

   136  *

   137  * @return KErrNone on success, KErrNotSupported if this request is not supported,

   138  * or another error code to indicate the failure otherwise.

   139  */

   140 	{

   141 	TSYLOGENTRYEXIT;

   142 

   143 	TInt ret = KErrNotSupported;

   144 

   145 

   146 	return TSYLOGSETEXITERR(ret);

   147 	} // CLtsySupplementaryServicesHandler::HandleGetCallWaitingStatusReqL

   148 

   149 

   150 TInt CLtsySupplementaryServicesHandler::HandleSendNetworkServiceRequestReqL(const TDesC& /*aRequest*/)

   151 /**

   152  * This request is completed by invoking

   153  * CCtsyDispatcherCallback::CallbackSupplementaryServicesSendNetworkServiceRequestComp()

   154  *

   155  * @param aRequest The supplementary services string that was entered by the user and need to be send to the network.

   156  *

   157  * @return KErrNone on success, KErrNotSupported if this request is not supported,

   158  * or another error code to indicate the failure otherwise.

   159  */

   160 	{

   161 	TSYLOGENTRYEXIT;

   162 

   163 	TInt ret = KErrNotSupported;

   164 

   165 	// TODO: Add implementation here.......

   166 

   167 

   168 	return TSYLOGSETEXITERR(ret);

   169 	} // CLtsySupplementaryServicesHandler::HandleSendNetworkServiceRequestReqL

   170 

   171 

   172 TInt CLtsySupplementaryServicesHandler::HandleGetCallBarringStatusReqL(RMobilePhone::TMobilePhoneCBCondition /*aCondition*/)

   173 /**

   174  * This request is completed by invoking

   175  * CCtsyDispatcherCallback::CallbackSupplementaryServicesGetCallBarringStatusComp()

   176  *

   177  * @param aCondition The barring conditions to interrogate.

   178  *

   179  * @return KErrNone on success, KErrNotSupported if this request is not supported,

   180  * or another error code to indicate the failure otherwise.

   181  */

   182 	{

   183 	TSYLOGENTRYEXIT;

   184 

   185 	TInt ret = KErrNotSupported;

   186 

   187 	// TODO: Add implementation here.......

   188 

   189 

   190 	return TSYLOGSETEXITERR(ret);

   191 	} // CLtsySupplementaryServicesHandler::HandleGetCallBarringStatusReqL

   192 

   193 

   194 TInt CLtsySupplementaryServicesHandler::HandleSetCallBarringStatusReqL(RMobilePhone::TMobilePhoneCBCondition /*aCondition*/,

   195         RMobilePhone::TMobilePhoneServiceAction /*aAction*/,

   196         RMobilePhone::TMobileService /*aGroup*/,

   197         const TDesC& /*aPassword*/)

   198 /**

   199  * This request is completed by invoking

   200  * CCtsyDispatcherCallback::CallbackSupplementaryServicesSetCallBarringStatusComp()

   201  *

   202  * @param aCondition the call barring condition to set.

   203  * @param aAction the call barring action.

   204  * @param aGroup the call barring service group.

   205  * @param aPassword the password of the call barring service.

   206  *

   207  * @return KErrNone on success, KErrNotSupported if this request is not supported,

   208  * or another error code to indicate the failure otherwise.

   209  */

   210 	{

   211 	TSYLOGENTRYEXIT;

   212 

   213 	TInt ret = KErrNotSupported;

   214 

   215 	// TODO: Add implementation here.......

   216 

   217 

   218 	return TSYLOGSETEXITERR(ret);

   219 	} // CLtsySupplementaryServicesHandler::HandleSetCallBarringStatusReqL

   220 

   221 

   222 TInt CLtsySupplementaryServicesHandler::HandleSetCallForwardingStatusReqL(RMobilePhone::TMobilePhoneCFCondition /*aCondition*/,

   223 		RMobilePhone::TMobileService /*aServiceGroup*/,

   224 		RMobilePhone::TMobilePhoneServiceAction /*aAction*/,

   225 		const TDesC& /*aNumber*/,

   226 		TInt /*aTimeout*/)

   227 /**

   228  * This request is completed by invoking

   229  * CCtsyDispatcherCallback::CallbackSupplementaryServicesSetCallForwardingStatusComp()

   230  *

   231  * @param aCondition the call forwarding condition to set.

   232  * @param aServiceGroup The basic service group to apply the CF status change to.

   233  * @param aAction The action to take.

   234  * @param aNumber The forwarding number.

   235  * @param aTimeout The time out when aCondition is ECallForwardingNoReply.

   236  *

   237  * @return KErrNone on success, KErrNotSupported if this request is not supported,

   238  * or another error code to indicate the failure otherwise.

   239  */

   240 	{

   241 	TSYLOGENTRYEXIT;

   242 

   243 	TInt ret = KErrNotSupported;

   244 

   245 	// TODO: Add implementation here.......

   246 

   247 

   248 	return TSYLOGSETEXITERR(ret);

   249 	} // CLtsySupplementaryServicesHandler::HandleSetCallForwardingStatusReqL

   250 

   251 

   252 TInt CLtsySupplementaryServicesHandler::HandleSetCallWaitingStatusReqL(RMobilePhone::TMobileService /*aServiceGroup*/,

   253 		RMobilePhone::TMobilePhoneServiceAction /*aAction*/) 

   254 /**

   255  * This request is completed by invoking

   256  * CCtsyDispatcherCallback::CallbackSupplementaryServicesSetCallWaitingStatusComp()

   257  *

   258  * @param aServiceGroup The service group to change.

   259  * @param aAction The action to do with that service group.

   260  *

   261  * @return KErrNone on success, KErrNotSupported if this request is not supported,

   262  * or another error code to indicate the failure otherwise.

   263  */

   264 	{

   265 	TSYLOGENTRYEXIT;

   266 

   267 	TInt ret = KErrNotSupported;

   268 

   269 	// TODO: Add implementation here.......

   270 

   271 

   272 	return TSYLOGSETEXITERR(ret);

   273 	} // CLtsySupplementaryServicesHandler::HandleSetCallWaitingStatusReqL

   274 

   275 

   276 TInt CLtsySupplementaryServicesHandler::HandleSetSsPasswordReqL(const TDesC& /*aOldPassword*/,

   277 		const TDesC& /*aNewPassword*/,

   278 		MLtsyDispatchSupplementaryServicesSetSsPassword::TServiceType /*aService*/)

   279 /**

   280  * This request is completed by invoking

   281  * CCtsyDispatcherCallback::CallbackSupplementaryServicesSetSsPasswordComp()

   282  *

   283  * @param aOldPassword The old password.

   284  * @param aNewPassword The new password.

   285  * @param aService The service.

   286  *

   287  * @return KErrNone on success, KErrNotSupported if this request is not supported,

   288  * or another error code to indicate the failure otherwise.

   289  */

   290 	{

   291 	TSYLOGENTRYEXIT;

   292 

   293 	TInt ret = KErrNotSupported;

   294 

   295 	// TODO: Add implementation here.......

   296 

   297 

   298 	return TSYLOGSETEXITERR(ret);

   299 	} // CLtsySupplementaryServicesHandler::HandleSetSsPasswordReqL

   300 

   301 

   302 TInt CLtsySupplementaryServicesHandler::HandleGetCallForwardingStatusReqL(RMobilePhone::TMobilePhoneCFCondition /*aCondition*/, RMobilePhone::TMobileService /*aService*/)

   303 /**

   304  * This request is completed by invoking

   305  * CCtsyDispatcherCallback::CallbackSupplementaryServicesGetCallForwardingStatusComp()

   306  *

   307  * @param aCondition the call forwarding condition.

   308  * @param aService The service group.

   309  *

   310  * @return KErrNone on success, KErrNotSupported if this request is not supported,

   311  * or another error code to indicate the failure otherwise.

   312  */

   313 	{

   314 	TSYLOGENTRYEXIT;

   315 

   316 	TInt ret = KErrNotSupported;

   317 

   318 	// TODO: Add implementation here.......

   319 

   320 

   321 	return TSYLOGSETEXITERR(ret);

   322 	} // CLtsySupplementaryServicesHandler::HandleGetCallForwardingStatusReqL

   323 

   324 

   325 TInt CLtsySupplementaryServicesHandler::HandleSendUssdMessageReqL(const TDesC8& /*aData*/, TUint8 /*aDcs*/, 

   326 		RMobileUssdMessaging::TMobileUssdDataFormat /*aFormat*/, RMobileUssdMessaging::TMobileUssdMessageType /*aType*/)

   327 /**

   328  * This request is completed by invoking

   329  * CCtsyDispatcherCallback::CallbackSupplementaryServicesSendUssdMessageComp()

   330  *

   331  * @param aData The data to send in the message.

   332  * @param aDcs The data coding scheme of the message.

   333  * @param aFormat The message format.

   334  * @param aType The message type.

   335  *

   336  * @return KErrNone on success, KErrNotSupported if this request is not supported,

   337  * or another error code to indicate the failure otherwise.

   338  */

   339 	{

   340 	TSYLOGENTRYEXIT;

   341 

   342 	TInt ret = KErrNotSupported;

   343 

   344 	// TODO: Add implementation here.......

   345 

   346 

   347 	return TSYLOGSETEXITERR(ret);

   348 	} // CLtsySupplementaryServicesHandler::HandleSendUssdMessageReqL

   349 

   350 TInt CLtsySupplementaryServicesHandler::HandleSendUssdMessageNoFdnCheckReqL(const TDesC8& /*aData*/, TUint8 /*aDcs*/, 

   351 		RMobileUssdMessaging::TMobileUssdDataFormat /*aFormat*/, RMobileUssdMessaging::TMobileUssdMessageType /*aType*/)

   352 /**

   353  * This request is completed by invoking

   354  * CCtsyDispatcherCallback::CallbackSupplementaryServicesSendUssdMessageNoFdnCheckComp()

   355  *

   356  * @param aData The data to send in the message.

   357  * @param aDcs The data coding scheme of the message.

   358  * @param aFormat The message format.

   359  * @param aType The message type.

   360  *

   361  * @return KErrNone on success, KErrNotSupported if this request is not supported,

   362  * or another error code to indicate the failure otherwise.

   363  */

   364 	{

   365 	TSYLOGENTRYEXIT;

   366 

   367 	TInt ret = KErrNotSupported;

   368 

   369 	// TODO: Add implementation here.......

   370 

   371 

   372 	return TSYLOGSETEXITERR(ret);

   373 	} // CLtsySupplementaryServicesHandler::HandleSendUssdMessageNoFdnCheckReqL

   374 

   375 TInt CLtsySupplementaryServicesHandler::HandleSendUssdReleaseReqL()

   376 /**

   377  * This request is completed by invoking

   378  * CCtsyDispatcherCallback::CallbackSupplementaryServicesSendUssdReleaseComp()

   379  *

   380  * @return KErrNone on success, KErrNotSupported if this request is not supported,

   381  * or another error code to indicate the failure otherwise.

   382  */

   383 	{

   384 	TSYLOGENTRYEXIT;

   385 

   386 	TInt ret = KErrNotSupported;

   387 

   388 	// TODO: Add implementation here.......

   389 

   390 	return TSYLOGSETEXITERR(ret);

   391 	} // CLtsySupplementaryServicesHandler::HandleSendUssdReleaseReqL

   392 

   393 

   394 TInt CLtsySupplementaryServicesHandler::HandleClearBlacklistReqL()

   395 /**

   396  * This request is completed by invoking

   397  * CCtsyDispatcherCallback::CallbackSupplementaryServicesClearBlacklistComp()

   398  *

   399  * @return KErrNone on success, KErrNotSupported if this request is not supported,

   400  * or another error code to indicate the failure otherwise.

   401  */

   402 	{

   403 	TSYLOGENTRYEXIT;

   404 

   405 	TInt ret = KErrNotSupported;

   406 

   407 	// TODO: Add implementation here.......

   408 

   409 	return TSYLOGSETEXITERR(ret);

   410 	} // CLtsySupplementaryServicesHandler::HandleClearBlacklistReqL

   411 

   412 

   413 

   414 

   415