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 // This file contains all the interfaces classes that can be implemented by

    15 // the Licensee LTSY relating to Phone related features.

    16 //

    17 

    18 

    19 

    20 

    21 /**

    22  @file

    23  @internalAll 

    24 */

    25 

    26 

    27 #ifndef MLTSYDISPATCHPHONEINTERFACE_H_

    28 #define MLTSYDISPATCHPHONEINTERFACE_H_

    29 

    30 #include <ctsy/ltsy/mltsydispatchinterface.h>

    31 #include <etelmm.h>

    32 #include <ctsy/rmmcustomapi.h>

    33 

    34 class MLtsyDispatchPhoneBootNotifyModemStatusReady : public MLtsyDispatchInterface

    35 	{

    36 public:

    37 

    38     static const TInt KLtsyDispatchPhoneBootNotifyModemStatusReadyApiId = KDispatchPhoneFuncUnitId+1;

    39 

    40 	/**

    41 	 * The CTSY Dispatcher shall invoke this function on receiving the EMmTsyBootNotifyModemStatusReadyIPC

    42 	 * request from the CTSY.

    43 	 *

    44 	 * It is a request call that is completed by invoking CCtsyDispatcherCallback::CallbackPhoneBootNotifyModemStatusReadyComp()

    45 	 *

    46 	 * Implementation of this interface should indicate when the

    47 	 * Modem is ready for requests made from the CTSY.

    48 	 *

    49 	 * @return KErrNone on success otherwise another error code indicating the

    50 	 * failure.

    51 	 */

    52 	virtual TInt HandleBootNotifyModemStatusReadyReqL() = 0;

    53 

    54 	}; // class MLtsyDispatchPhoneBootNotifyModemStatusReady

    55 

    56 

    57 class MLtsyDispatchPhoneBootNotifySimStatusReady : public MLtsyDispatchInterface

    58 	{

    59 public:

    60 

    61     static const TInt KLtsyDispatchPhoneBootNotifySimStatusReadyApiId = KDispatchPhoneFuncUnitId+2;

    62 

    63 	/**

    64 	 * The CTSY Dispatcher shall invoke this function on receiving the EMmTsyBootNotifySimStatusReadyIPC

    65 	 * request from the CTSY.

    66 	 *

    67 	 * It is a request call that is completed by invoking CCtsyDispatcherCallback::CallbackPhoneBootNotifySimStatusReadyComp()

    68 	 *

    69 	 * Implementation of this interface should indicate when the SIM is ready

    70 	 * for requests made from the CTSY.

    71 	 * For example, any caching of data has been completed.

    72 	 *

    73 	 * @return KErrNone on success, otherwise another error code indicating the

    74 	 * failure.

    75 	 */

    76 	virtual TInt HandleBootNotifySimStatusReadyReqL() = 0;

    77 

    78 	}; // class MLtsyDispatchPhoneBootNotifySimStatusReady

    79 

    80 

    81 class MLtsyDispatchPhoneGetFdnStatus : public MLtsyDispatchInterface

    82 	{

    83 public:

    84 

    85     static const TInt KLtsyDispatchPhoneGetFdnStatusApiId = KDispatchPhoneFuncUnitId + 3;

    86 

    87 	/**

    88 	 * The CTSY Dispatcher shall invoke this function on receiving the EMobilePhoneGetFdnStatus

    89 	 * request from the CTSY.

    90 	 *

    91 	 * It is a request call that is completed by invoking CCtsyDispatcherCallback::CallbackPhoneGetFdnStatusComp()

    92 	 *

    93 	 * Implementation of this interface should get the current FDN status.

    94 	 *

    95 	 * @return KErrNone on success, otherwise another error code indicating the

    96 	 * failure.

    97 	 */

    98 	virtual TInt HandleGetFdnStatusReqL() = 0;

    99 

   100 	}; // class MLtsyDispatchPhoneGetFdnStatus

   101 

   102 

   103 class MLtsyDispatchPhoneGetHomeNetwork : public MLtsyDispatchInterface

   104 	{

   105 public:

   106 

   107     static const TInt KLtsyDispatchPhoneGetHomeNetworkApiId = KDispatchPhoneFuncUnitId + 4;

   108 

   109 	/**

   110 	 * The CTSY Dispatcher shall invoke this function on receiving the EMobilePhoneGetHomeNetwork

   111 	 * request from the CTSY.

   112 	 *

   113 	 * It is a request call that is completed by invoking CCtsyDispatcherCallback::CallbackPhoneGetHomeNetworkComp()

   114 	 *

   115 	 * Implementation of this interface should get the current home network.

   116 	 *

   117 	 * @return KErrNone on success, otherwise another error code indicating the

   118 	 * failure.

   119 	 */

   120 	virtual TInt HandleGetHomeNetworkReqL() = 0;

   121 

   122 	}; // class MLtsyDispatchPhoneGetHomeNetwork

   123 

   124 

   125 class MLtsyDispatchPhoneGetNetworkRegistrationStatus : public MLtsyDispatchInterface

   126 	{

   127 public:

   128 

   129     static const TInt KLtsyDispatchPhoneGetNetworkRegistrationStatusApiId = KDispatchPhoneFuncUnitId + 5;

   130 

   131 	/**

   132 	 * The CTSY Dispatcher shall invoke this function on receiving the EMobilePhoneGetNetworkRegistrationStatus

   133 	 * request from the CTSY.

   134 	 *

   135 	 * It is a request call that is completed by invoking CCtsyDispatcherCallback::CallbackPhoneGetNetworkRegistrationStatusComp()

   136 	 *

   137 	 * Implementation of this interface should get the current network registration status.

   138 	 *

   139 	 * @return KErrNone on success, otherwise another error code indicating the

   140 	 * failure.

   141 	 */

   142 	virtual TInt HandleGetNetworkRegistrationStatusReqL() = 0;

   143 

   144 	}; // class MLtsyDispatchPhoneGetNetworkRegistrationStatus

   145 

   146 

   147 class MLtsyDispatchPhoneSimRefreshRegister : public MLtsyDispatchInterface

   148 	{

   149 public:

   150 

   151     static const TInt KLtsyDispatchPhoneSimRefreshRegisterApiId = KDispatchPhoneFuncUnitId + 6;

   152 

   153 	/**

   154 	 * The CTSY Dispatcher shall invoke this function on receiving the EMmTsySimRefreshRegisterIPC

   155 	 * request from the CTSY.

   156 	 *

   157 	 * It is a request call that is completed by invoking CCtsyDispatcherCallback::CallbackPhoneSimRefreshRegisterComp()

   158 	 *

   159 	 * Implementation of this interface should return whether registering for refresh indications on a list of SIM files was successful.

   160 	 * Note: When the LTSY needs to notify the CTSY of a refresh CCtsyDispatcherCallback::CallbackPhoneSimRefreshNowInd() should be invoked.

   161 	 *

   162 	 * @param aFilesToRegister  Bitmask containing list of files to register for refresh indications.

   163 	 *                           The list of possible files is specified in TCacheFileTypes.

   164 	 *

   165 	 * @return KErrNone on success, otherwise another error code indicating the

   166 	 * failure.

   167 	 */

   168 	virtual TInt HandleSimRefreshRegisterReqL(TUint16 aFilesToRegister) = 0;

   169 

   170 	}; // class MLtsyDispatchPhoneSimRefreshRegister

   171 

   172 

   173 

   174 class MLtsyDispatchPhoneGetServiceProviderName : public MLtsyDispatchInterface

   175 	{

   176 public:

   177 

   178 	static const TInt KLtsyDispatchPhoneGetServiceProviderNameApiId = KDispatchPhoneFuncUnitId + 7;

   179 

   180 	/**

   181 	 * The CTSY Dispatcher shall invoke this function on receiving the EMobilePhoneGetServiceProviderName

   182 	 * request from the CTSY.

   183 	 *

   184 	 * It is a request call that is completed by invoking

   185 	 * CCtsyDispatcherCallback::CallbackPhoneGetServiceProviderNameComp()

   186 	 *

   187 	 * The service provider information to be returned is in the form RMobilePhone::TMobilePhoneServiceProviderNameV2.

   188 	 *

   189 	 *

   190 	 * @return KErrNone on success, otherwise another error code indicating the

   191 	 * failure.

   192 	 */

   193 	virtual TInt HandleGetServiceProviderNameReqL() = 0;

   194 

   195 	}; // class MLtsyDispatchPhoneGetServiceProviderName

   196 

   197 

   198 

   199 class MLtsyDispatchPhoneGetPhoneId : public MLtsyDispatchInterface

   200 	{

   201 public:

   202 

   203 	static const TInt KLtsyDispatchPhoneGetPhoneIdApiId = KDispatchPhoneFuncUnitId + 8;

   204 

   205 	/**

   206 	 * The CTSY Dispatcher shall invoke this function on receiving the EMobilePhoneGetPhoneId

   207 	 * request from the CTSY.

   208 	 *

   209 	 * It is a request call that is completed by invoking

   210 	 * CCtsyDispatcherCallback::CallbackPhoneGetPhoneIdComp()

   211 	 *

   212 	 * Implementation of this interface should get the phone's identity as described by the

   213 	 * fields in RMobilePhone::TMobilePhoneIdentityV1.

   214 	 *

   215 	 * @return KErrNone on success, otherwise another error code indicating the

   216 	 * failure.

   217 	 */

   218 	virtual TInt HandleGetPhoneIdReqL() = 0;

   219 

   220 	}; // class MLtsyDispatchPhoneGetPhoneId

   221 

   222 

   223 

   224 class MLtsyDispatchPhoneGetDetectedNetworks : public MLtsyDispatchInterface

   225 	{

   226 public:

   227 

   228 	static const TInt KLtsyDispatchPhoneGetDetectedNetworksApiId = KDispatchPhoneFuncUnitId + 9;

   229 

   230 	/**

   231 	 * The CTSY Dispatcher shall invoke this function on receiving the EMobilePhoneGetDetectedNetworksV2Phase1

   232 	 * request from the CTSY.

   233 	 *

   234 	 * It is a request call that is completed by invoking

   235 	 * CCtsyDispatcherCallback::CallbackPhoneGetDetectedNetworksComp()

   236 	 *

   237 	 * Implementation of this interface should get the current detected networks.

   238 	 *

   239 	 * @return KErrNone on success, otherwise another error code indicating the

   240 	 * failure.

   241 	 */

   242 	virtual TInt HandleGetDetectedNetworksReqL() = 0;

   243 

   244 	}; // class MLtsyDispatchPhoneGetDetectedNetworks

   245 

   246 

   247 

   248 class MLtsyDispatchPhoneGetDetectedNetworksCancel : public MLtsyDispatchInterface

   249 	{

   250 public:

   251 

   252 	static const TInt KLtsyDispatchPhoneGetDetectedNetworksCancelApiId = KDispatchPhoneFuncUnitId + 10;

   253 

   254 	/**

   255 	 * The CTSY Dispatcher shall invoke this function on receiving the EMobilePhoneGetDetectedNetworksCancel

   256 	 * request from the CTSY.

   257 	 *

   258 	 * It is a request call that is completed by invoking

   259 	 * CCtsyDispatcherCallback::CallbackPhoneGetDetectedNetworksCancelComp()

   260 	 *

   261 	 * Implementation of this interface should cancel a pending retrieval of the detected networks.

   262 	 *

   263 	 * @return KErrNone on success, otherwise another error code indicating the

   264 	 * failure.

   265 	 */

   266 	virtual TInt HandleGetDetectedNetworksCancelReqL() = 0;

   267 

   268 	}; // class MLtsyDispatchPhoneGetDetectedNetworksCancel

   269 

   270 

   271 

   272 class MLtsyDispatchPhoneSelectNetwork : public MLtsyDispatchInterface

   273 	{

   274 public:

   275 

   276 	static const TInt KLtsyDispatchPhoneSelectNetworkApiId = KDispatchPhoneFuncUnitId + 11;

   277 

   278 	/**

   279 	 * The CTSY Dispatcher shall invoke this function on receiving the EMobilePhoneSelectNetwork

   280 	 * request from the CTSY.

   281 	 *

   282 	 * It is a request call that is completed by invoking

   283 	 * CCtsyDispatcherCallback::CallbackPhoneSelectNetworkComp()

   284 	 *

   285 	 * Implementation of this interface should attempt a network selection.

   286 	 *

   287 	 * @param aIsManual Specifies whether phone should use a manual or automatic network selection method.

   288 	 * @param aNetworkManualSelection If aIsManual==ETrue, then this parameter contain the user's manually selected network.

   289 	 *

   290 	 * @return KErrNone on success, otherwise another error code indicating the

   291 	 * failure.

   292 	 */

   293 	virtual TInt HandleSelectNetworkReqL(TBool aIsManual, const RMobilePhone::TMobilePhoneNetworkManualSelection& aNetworkManualSelection) = 0;

   294 

   295 	}; // class MLtsyDispatchPhoneSelectNetwork

   296 

   297 

   298 

   299 class MLtsyDispatchPhoneSelectNetworkCancel : public MLtsyDispatchInterface

   300 	{

   301 public:

   302 

   303 	static const TInt KLtsyDispatchPhoneSelectNetworkCancelApiId = KDispatchPhoneFuncUnitId + 12;

   304 

   305 	/**

   306 	 * The CTSY Dispatcher shall invoke this function on receiving the EMobilePhoneSelectNetworkCancel

   307 	 * request from the CTSY.

   308 	 *

   309 	 * It is a request call that is completed by invoking

   310 	 * CCtsyDispatcherCallback::CallbackPhoneSelectNetworkCancelComp()

   311 	 *

   312 	 * Implementation of this interface should cancel a pending network selection.

   313 	 *

   314 	 * @return KErrNone on success, otherwise another error code indicating the

   315 	 * failure.

   316 	 */

   317 	virtual TInt HandleSelectNetworkCancelReqL() = 0;

   318 

   319 	}; // class MLtsyDispatchPhoneSelectNetworkCancel

   320 

   321 

   322 

   323 class MLtsyDispatchPhoneSetNetworkSelectionSetting : public MLtsyDispatchInterface

   324 	{

   325 public:

   326 

   327 	static const TInt KLtsyDispatchPhoneSetNetworkSelectionSettingApiId = KDispatchPhoneFuncUnitId + 13;

   328 

   329 	/**

   330 	 * The CTSY Dispatcher shall invoke this function on receiving the EMobilePhoneSetNetworkSelectionSetting

   331 	 * request from the CTSY.

   332 	 *

   333 	 * It is a request call that is completed by invoking

   334 	 * CCtsyDispatcherCallback::CallbackPhoneSetNetworkSelectionSettingComp()

   335 	 *

   336 	 * Implementation of this interface should set the new network selection.

   337 	 * Note: 	The completion of this will also invoke the network selection change

   338 	 * 			notifier in the CTSY (EMobilePhoneNotifyNetworkSelectionSettingChange).

   339 	 *

   340 	 * @param aPhoneNetworkSelection The new network selection setting.

   341 	 *

   342 	 * @return KErrNone on success, otherwise another error code indicating the

   343 	 * failure.

   344 	 */

   345 	virtual TInt HandleSetNetworkSelectionSettingReqL(const RMobilePhone::TMobilePhoneNetworkSelectionV1& aPhoneNetworkSelection) = 0;

   346 

   347 	}; // class MLtsyDispatchPhoneSetNetworkSelectionSetting

   348 

   349 

   350 class MLtsyDispatchPhoneGetCurrentNetworkInfo : public MLtsyDispatchInterface

   351 	{

   352 public:

   353 

   354     static const TInt KLtsyDispatchPhoneGetCurrentNetworkInfoApiId = KDispatchPhoneFuncUnitId + 14;

   355 

   356 	/**

   357 	 * The CTSY Dispatcher shall invoke this function after a NotifyModemReadyReceived event occurs,

   358 	 * normally during phone boot-up. It is an internal call.

   359 	 *

   360 	 * It is a request call that is completed by invoking CCtsyDispatcherCallback::CallbackPhoneGetCurrentNetworkInfoComp()

   361 	 *

   362 	 * Implementation of this interface should get the current network information.

   363 	 *

   364 	 * @return KErrNone on success, otherwise another error code indicating the

   365 	 * failure.

   366 	 */

   367 	virtual TInt HandleGetCurrentNetworkInfoReqL() = 0;

   368 

   369 	}; // class MLtsyDispatchPhoneGetCurrentNetworkInfo

   370 

   371 

   372 class MLtsyDispatchPhoneGetNetworkMode : public MLtsyDispatchInterface

   373 	{

   374 public:

   375 

   376     static const TInt KLtsyDispatchPhoneGetNetworkModeApiId = KDispatchPhoneFuncUnitId + 15;

   377 

   378 	/**

   379 	 * The CTSY Dispatcher shall invoke this function after a NotifyModemReadyReceived event occurs,

   380 	 * normally during phone boot-up. It is an internal call.

   381 	 *

   382 	 * It is a request call that is completed by invoking CCtsyDispatcherCallback::CallbackPhoneGetNetworkModeComp()

   383 	 *

   384 	 * Implementation of this interface should get the current network information.

   385 	 *

   386 	 * @return KErrNone on success, otherwise another error code indicating the

   387 	 * failure.

   388 	 */

   389 	virtual TInt HandleGetNetworkModeReqL() = 0;

   390 

   391 	}; // class MLtsyDispatchPhoneGetNetworkMode

   392 

   393 

   394 class MLtsyDispatchPhoneGetNitzInfo : public MLtsyDispatchInterface

   395 	{

   396 public:

   397 

   398     static const TInt KLtsyDispatchPhoneGetNitzInfoApiId = KDispatchPhoneFuncUnitId + 16;

   399 

   400 	/**

   401 	 * The CTSY Dispatcher shall invoke this function after a NotifyModemReadyReceived event occurs,

   402 	 * normally during phone boot-up. It is an internal call.

   403 	 *

   404 	 * It is a request call that is completed by invoking CCtsyDispatcherCallback::CallbackPhoneGetNitzInfoComp()

   405 	 *

   406 	 * Implementation of this interface should get the current network NITZ information.

   407 	 *

   408 	 * @return KErrNone on success, otherwise another error code indicating the

   409 	 * failure.

   410 	 */

   411 	virtual TInt HandleGetNitzInfoReqL() = 0;

   412 

   413 	}; // class MLtsyDispatchPhoneGetNitzInfo

   414 

   415 class MLtsyDispatchPhoneGetSignalStrength : public MLtsyDispatchInterface

   416 	{

   417 public:

   418 

   419     static const TInt KLtsyDispatchPhoneGetSignalStrengthApiId = KDispatchPhoneFuncUnitId + 17;

   420 

   421 	/**

   422 	 * The CTSY Dispatcher shall invoke this function after a NotifyModemReadyReceived event occurs,

   423 	 * normally during phone boot-up. It is an internal call.

   424 	 *

   425 	 * It is a request call that is completed by invoking CCtsyDispatcherCallback::CallbackPhoneGetSignalStrengthComp()

   426 	 *

   427 	 * Implementation of this interface should get the current network signal strength information.

   428 	 *

   429 	 * @return KErrNone on success, otherwise another error code indicating the

   430 	 * failure.

   431 	 */

   432 	virtual TInt HandleGetSignalStrengthReqL() = 0;

   433 

   434 	}; // class MLtsyDispatchPhoneGetSignalStrength

   435 

   436 class MLtsyDispatchPhoneGetBatteryInfo : public MLtsyDispatchInterface

   437 	{

   438 public:

   439 

   440     static const TInt KLtsyDispatchPhoneGetBatteryInfoApiId = KDispatchPhoneFuncUnitId + 18;

   441 

   442 	/**

   443 	 * The CTSY Dispatcher shall invoke this function after a NotifyModemReadyReceived event occurs,

   444 	 * normally during phone boot-up. It is an internal call.

   445 	 *

   446 	 * It is a request call that is completed by invoking CCtsyDispatcherCallback::CallbackPhoneGetBatteryInfoComp()

   447 	 *

   448 	 * Implementation of this interface should get the current battery information.

   449 	 *

   450 	 * @return KErrNone on success, otherwise another error code indicating the

   451 	 * failure.

   452 	 */

   453 	virtual TInt HandleGetBatteryInfoReqL() = 0;

   454 

   455 	}; // class MLtsyDispatchPhoneGetBatteryInfo

   456 

   457 class MLtsyDispatchPhoneNspsWakeup : public MLtsyDispatchInterface

   458 	{

   459 public:

   460 

   461     static const TInt KLtsyDispatchPhoneNspsWakeupApiId = KDispatchPhoneFuncUnitId + 19;

   462 

   463 	/**

   464 	 * The CTSY Dispatcher shall invoke this function on receiving the ECustomNetWakeupIPC

   465 	 * request from the CTSY.

   466 	 *

   467 	 * It is a request call that is completed by invoking

   468 	 * CCtsyDispatcherCallback::CallbackPhoneNspsWakeupComp().

   469 	 *

   470 	 * Implementation of this interface should wake the phone from a NSPS (No Service Power Save) state.

   471 	 *

   472 	 * @return KErrNone on success, otherwise another error code indicating the

   473 	 * failure.

   474 	 */

   475 	virtual TInt HandleNspsWakeupReqL() = 0;

   476 

   477 	}; // class MLtsyDispatchPhoneNspsWakeup

   478 

   479 class MLtsyDispatchPhoneSetSystemNetworkMode : public MLtsyDispatchInterface

   480 	{

   481 public:

   482 

   483     static const TInt KLtsyDispatchPhoneSetSystemNetworkModeApiId = KDispatchPhoneFuncUnitId + 20;

   484 

   485 	/**

   486 	 * The CTSY Dispatcher shall invoke this function on receiving the ECustomSetSystemNetworkModeIPC

   487 	 * request from the CTSY.

   488 	 *

   489 	 * It is a request call that is completed by invoking

   490 	 * CCtsyDispatcherCallback::CallbackPhoneSetSystemNetworkModeComp().

   491 	 *

   492 	 * Implementation of this interface should set the system network mode.

   493 	 *

   494 	 * @param aMode The new mode to set the system network to.

   495 	 *

   496 	 * @return KErrNone on success, otherwise another error code indicating the

   497 	 * failure.

   498 	 */

   499 	virtual TInt HandleSetSystemNetworkModeReqL(RMmCustomAPI::TNetworkModeCaps aMode) = 0;

   500 

   501 	}; // class MLtsyDispatchPhoneSetSystemNetworkMode

   502 

   503 class MLtsyDispatchPhoneGetCurrentSystemNetworkModes : public MLtsyDispatchInterface

   504 	{

   505 public:

   506 

   507     static const TInt KLtsyDispatchPhoneGetCurrentSystemNetworkModesApiId = KDispatchPhoneFuncUnitId + 21;

   508 

   509 	/**

   510 	 * The CTSY Dispatcher shall invoke this function on receiving the ECustomGetCurrentSystemNetworkModesIPC

   511 	 * request from the CTSY.

   512 	 *

   513 	 * It is a request call that is completed by invoking

   514 	 * CCtsyDispatcherCallback::CallbackPhoneGetCurrentSystemNetworkModesComp().

   515 	 *

   516 	 * Implementation of this interface should return the current system network mode.

   517 	 *

   518 	 * @return KErrNone on success, otherwise another error code indicating the

   519 	 * failure.

   520 	 */

   521 	virtual TInt HandleGetCurrentSystemNetworkModesReqL() = 0;

   522 

   523 	}; // class MLtsyDispatchPhoneGetCurrentSystemNetworkModes

   524 

   525 class MLtsyDispatchPhoneResetNetServer : public MLtsyDispatchInterface

   526 	{

   527 public:

   528 

   529     static const TInt KLtsyDispatchPhoneResetNetServerApiId = KDispatchPhoneFuncUnitId + 22;

   530 

   531 	/**

   532 	 * The CTSY Dispatcher shall invoke this function on receiving the ECustomResetNetServerIPC

   533 	 * request from the CTSY.

   534 	 *

   535 	 * It is a request call that is completed by invoking

   536 	 * CCtsyDispatcherCallback::CallbackPhoneResetNetServerComp().

   537 	 *

   538 	 * Implementation of this interface should reset the net server.

   539 	 *

   540 	 * @return KErrNone on success, otherwise another error code indicating the

   541 	 * failure.

   542 	 */

   543 	virtual TInt HandleResetNetServerReqL() = 0;

   544 

   545 	}; // class MLtsyDispatchPhoneResetNetServer

   546 

   547 class MLtsyDispatchPhoneSetAlwaysOnMode : public MLtsyDispatchInterface

   548 	{

   549 public:

   550 

   551     static const TInt KLtsyDispatchPhoneSetAlwaysOnModeApiId = KDispatchPhoneFuncUnitId + 23;

   552 

   553 	/**

   554 	 * The CTSY Dispatcher shall invoke this function on receiving the ECustomSetAlwaysOnMode

   555 	 * request from the CTSY.

   556 	 *

   557 	 * It is a request call that is completed by invoking

   558 	 * CCtsyDispatcherCallback::CallbackPhoneSetAlwaysOnModeComp().

   559 	 *

   560 	 * Implementation of this interface should set the "always on" mode.

   561 	 *

   562 	 * @param aMode The new "always on" mode to set, can be

   563      *               RMmCustomAPI::EAlwaysModeVPLMN for VPLMN (Visited Public Land Mobile Network) always on,

   564      *               RMmCustomAPI::EAlwaysModeHPLMN for HPLMN (Home Public Land Mobile Network) always on,

   565      *               RMmCustomAPI::EAlwaysModeBoth for VPLMN and HPLMN always on,

   566      *               RMmCustomAPI::EAlwaysModeNeither for neither VPLMN nor HPLMN always on.

   567 	 *

   568 	 * @return KErrNone on success, otherwise another error code indicating the

   569 	 * failure.

   570 	 */

   571 	virtual TInt HandleSetAlwaysOnModeReqL(RMmCustomAPI::TSetAlwaysOnMode aMode) = 0;

   572 

   573 	}; // class MLtsyDispatchPhoneSetAlwaysOnMode

   574 

   575 class MLtsyDispatchPhoneSetDriveMode : public MLtsyDispatchInterface

   576 	{

   577 public:

   578 

   579     static const TInt KLtsyDispatchPhoneSetDriveModeApiId = KDispatchPhoneFuncUnitId + 24;

   580 

   581 	/**

   582 	 * The CTSY Dispatcher shall invoke this function on receiving the ECustomSetDriveModeIPC

   583 	 * request from the CTSY.

   584 	 *

   585 	 * It is a request call that is completed by invoking

   586 	 * CCtsyDispatcherCallback::CallbackPhoneSetDriveModeComp().

   587 	 *

   588 	 * Implementation of this interface should set the drive mode status.

   589 	 *

   590 	 * @param aMode The new mode to set (RMmCustomAPI::EDeactivateDriveMode for deactivate drive mode

   591      *               or RMmCustomAPI::EActivateDriveMode to activate drive mode).

   592 	 *

   593 	 * @return KErrNone on success, otherwise another error code indicating the

   594 	 * failure.

   595 	 */

   596 	virtual TInt HandleSetDriveModeReqL(RMmCustomAPI::TSetDriveMode aMode) = 0;

   597 

   598 	}; // class MLtsyDispatchPhoneSetDriveMode

   599 

   600 class MLtsyDispatchPhoneGetHspaStatus : public MLtsyDispatchInterface

   601 	{

   602 public:

   603 

   604     static const TInt KLtsyDispatchPhoneGetHspaStatusApiId = KDispatchPhoneFuncUnitId + 25;

   605 

   606 	/**

   607 	 * The CTSY Dispatcher shall invoke this function on receiving the ECustomReadHSxPAStatusIPC

   608 	 * request from the CTSY.

   609 	 *

   610 	 * It is a request call that is completed by invoking

   611 	 * CCtsyDispatcherCallback::CallbackPhoneGetHspaStatusComp().

   612 	 *

   613 	 * Implementation of this interface should return the phone high speed channel status.

   614 	 *

   615 	 * @return KErrNone on success, otherwise another error code indicating the

   616 	 * failure.

   617 	 */

   618 	virtual TInt HandleGetHspaStatusReqL() = 0;

   619 

   620 	}; // class MLtsyDispatchPhoneGetHspaStatus

   621 

   622 class MLtsyDispatchPhoneSetHspaStatus : public MLtsyDispatchInterface

   623 	{

   624 public:

   625 

   626     static const TInt KLtsyDispatchPhoneSetHspaStatusApiId = KDispatchPhoneFuncUnitId + 26;

   627 

   628 	/**

   629 	 * The CTSY Dispatcher shall invoke this function on receiving the ECustomWriteHSxPAStatusIPC

   630 	 * request from the CTSY.

   631 	 *

   632 	 * It is a request call that is completed by invoking

   633 	 * CCtsyDispatcherCallback::CallbackPhoneSetHspaStatusComp().

   634 	 *

   635 	 * Implementation of this interface should set the phone high speed channel status.

   636 	 *

   637 	 * @param aStatus The new HSxPA status (enabled or disabled).

   638 	 *

   639 	 * @return KErrNone on success, otherwise another error code indicating the

   640 	 * failure.

   641 	 */

   642 	virtual TInt HandleSetHspaStatusReqL(RMmCustomAPI::THSxPAStatus aStatus) = 0;

   643 

   644 	}; // class MLtsyDispatchPhoneSetHspaStatus

   645 

   646 class MLtsyDispatchPhoneGetNetworkProviderName : public MLtsyDispatchInterface

   647 	{

   648 public:

   649 

   650     static const TInt KLtsyDispatchPhoneGetNetworkProviderNameApiId = KDispatchPhoneFuncUnitId + 27;

   651 

   652 	/**

   653 	 * The CTSY Dispatcher shall invoke this function on receiving the ECustomGetNetworkProviderNameIPC

   654 	 * request from the CTSY.

   655 	 *

   656 	 * It is a request call that is completed by invoking

   657 	 * CCtsyDispatcherCallback::CallbackPhoneGetNetworkProviderNameComp().

   658 	 *

   659 	 * Implementation of this interface should return the name of the current network provider.

   660 	 *

   661 	 * @return KErrNone on success, otherwise another error code indicating the

   662 	 * failure.

   663 	 */

   664 	virtual TInt HandleGetNetworkProviderNameReqL() = 0;

   665 

   666 	}; // class MLtsyDispatchPhoneGetNetworkProviderName

   667 

   668 class MLtsyDispatchPhoneGetOperatorName : public MLtsyDispatchInterface

   669 	{

   670 public:

   671 

   672     static const TInt KLtsyDispatchPhoneGetOperatorNameApiId = KDispatchPhoneFuncUnitId + 28;

   673 

   674 	/**

   675 	 * The CTSY Dispatcher shall invoke this function on receiving the ECustomGetOperatorNameIPC

   676 	 * request from the CTSY.

   677 	 *

   678 	 * It is a request call that is completed by invoking

   679 	 * CCtsyDispatcherCallback::CallbackPhoneGetOperatorNameComp().

   680 	 *

   681 	 * Implementation of this interface should return the name of the current operator.

   682 	 *

   683 	 * @return KErrNone on success, otherwise another error code indicating the

   684 	 * failure.

   685 	 */

   686 	virtual TInt HandleGetOperatorNameReqL() = 0;

   687 

   688 	}; // class MLtsyDispatchPhoneGetOperatorName

   689 

   690 class MLtsyDispatchPhoneGetCellInfo : public MLtsyDispatchInterface

   691 	{

   692 public:

   693 

   694     static const TInt KLtsyDispatchPhoneGetCellInfoApiId = KDispatchPhoneFuncUnitId + 29;

   695 

   696 	/**

   697 	 * The CTSY Dispatcher shall invoke this function on receiving the ECustomGetCellInfoIPC

   698 	 * request from the CTSY.

   699 	 *

   700 	 * It is a request call that is completed by invoking one of the

   701 	 * CCtsyDispatcherCallback::CallbackPhoneGetCellInfoComp().

   702 	 *

   703 	 * Implementation of this interface should return the cell information.

   704 	 *

   705 	 * @return KErrNone on success, otherwise another error code indicating the

   706 	 * failure.

   707 	 */

   708 	virtual TInt HandleGetCellInfoReqL() = 0;

   709 

   710 	}; // class MLtsyDispatchPhoneGetCellInfo

   711 

   712 class MLtsyDispatchPhoneRegisterCellInfoChangeNotification : public MLtsyDispatchInterface

   713 	{

   714 public:

   715 

   716     static const TInt KLtsyDispatchPhoneRegisterCellInfoChangeNotificationApiId = KDispatchPhoneFuncUnitId + 30;

   717 

   718 	/**

   719 	 * The CTSY Dispatcher shall invoke this function on receiving the ECtsyPhoneCellInfoIndReq

   720 	 * request from the CTSY.

   721 	 *

   722 	 * It is a request call that is completed by invoking CCtsyDispatcherCallback::CallbackPhoneRegisterCellInfoChangeNotificationComp()

   723 	 *

   724 	 * Implementation of this interface should inform the LTSY that the CTSY wishes to register for

   725 	 * notifications when the Cell Information has changed.

   726 	 * 

   727 	 * These notifications can be provided via the LTSY by invoking

   728 	 * CCtsyDispatcherCallback::CallbackPhoneNotifyCellInfoChangeInd()

   729 	 * 

   730 	 * This call from the CTSY only occurs once on the first client side call of RMobilePhone::NotifyCellInfoChange().

   731 	 *

   732 	 * @return KErrNone on success, otherwise another error code indicating the

   733 	 * failure.

   734 	 * 

   735 	 * @see RMobilePhone::NotifyCellInfoChange()

   736 	 */

   737 	virtual TInt HandleRegisterCellInfoChangeNotificationReqL() = 0;

   738 

   739 	}; // class MLtsyDispatchPhoneRegisterCellInfoChangeNotification

   740 

   741 class MLtsyDispatchPhoneGetPhoneCellInfo : public MLtsyDispatchInterface

   742 	{

   743 public:

   744 

   745     static const TInt KLtsyDispatchPhoneGetPhoneCellInfoApiId = KDispatchPhoneFuncUnitId + 31;

   746 

   747 	/**

   748 	 * The CTSY Dispatcher shall invoke this function on receiving the ECtsyPhoneCellInfoReq

   749 	 * request from the CTSY.

   750 	 *

   751 	 * It is a request call that is completed by invoking CCtsyDispatcherCallback::CallbackPhoneGetPhoneCellInfoComp()

   752 	 *

   753 	 * Implementation of this interface should retrieve the current Cell Information.

   754 	 * 

   755 	 * Cell information is cached within the CTSY thus this handler is only invoked if the

   756 	 * CTSY does not currently hold valid cell information. E.g. the CTSY's cache has never

   757 	 * been populated as GetPhoneCellInfo Request-Complete has never been exercised, or never

   758 	 * been populated via CallbackPhoneNotifyCellInfoChangeInd(), or CallbackPhoneNotifyCellInfoChangeInd()

   759 	 * is completed with an error thus marking the cache as dirty.

   760 	 *

   761 	 * @return KErrNone on success, otherwise another error code indicating the

   762 	 * failure.

   763 	 * 

   764 	 * @see RMobilePhone::GetCellInfo()

   765 	 */

   766 	virtual TInt HandleGetPhoneCellInfoReqL() = 0;

   767 

   768 	}; // class MLtsyDispatchPhoneGetPhoneCellInfo

   769 

   770 class MLtsyDispatchPhoneGetUsimServiceSupport : public MLtsyDispatchInterface

   771 	{

   772 public:

   773 

   774     static const TInt KLtsyDispatchPhoneGetUsimServiceSupportApiId = KDispatchPhoneFuncUnitId + 32;

   775 

   776 	/**

   777 	 * The CTSY Dispatcher shall invoke this function on receiving the ECustomGetServiceTableSupportbyApplicationIPC

   778 	 * request from the CTSY.

   779 	 *

   780 	 * It is a request call that is completed by invoking CCtsyDispatcherCallback::CallbackPhoneGetUsimServiceSupportComp()

   781 	 *

   782 	 * Implementation of this interface should retrieve if the application is supported.

   783 	 * 

   784 	 * @param aApplicationNumber The application number to check support for in the USIM.

   785 	 *

   786 	 * @return KErrNone on success, otherwise another error code indicating the

   787 	 * failure.

   788 	 * 

   789 	 *  @see RMmCustomAPI::GetUSIMServiceSupport()

   790 	 */

   791 	virtual TInt HandleGetGetUsimServiceSupportReqL(TInt aApplicationNumber) = 0;

   792 

   793 	}; // class MLtsyDispatchPhoneGetUsimServiceSupport

   794 

   795 class MLtsyDispatchPhoneGetCurrentActiveUsimApplication : public MLtsyDispatchInterface

   796 	{

   797 public:

   798 

   799     static const TInt KLtsyDispatchPhoneGetCurrentActiveUsimApplicationApiId = KDispatchPhoneFuncUnitId + 33;

   800 

   801 	/**

   802 	 * The CTSY Dispatcher shall invoke this function on receiving the EMobilePhoneGetCurrentActiveUSimApplication

   803 	 * request from the CTSY.

   804 	 *

   805 	 * It is a request call that is completed by invoking CCtsyDispatcherCallback::CallbackPhoneGetCurrentActiveUsimApplicationComp()

   806 	 *

   807 	 * Implementation of this interface should retrieve the AID of the current active USIM application.

   808 	 * (There is only ever at most one USIM application active at a time)

   809 	 *

   810 	 * @return KErrNone on success, otherwise another error code indicating the

   811 	 * failure.

   812 	 * 

   813 	 *  @see RMmCustomAPI::GetCurrentActiveUSimApplication()

   814 	 */

   815 	virtual TInt HandleGetCurrentActiveUsimApplicationReqL() = 0;

   816 

   817 	}; // class MLtsyDispatchPhoneGetCurrentActiveUsimApplication

   818 

   819 class MLtsyDispatchPhoneTerminateAllCalls : public MLtsyDispatchInterface

   820 	{

   821 public:

   822 

   823     static const TInt KLtsyDispatchPhoneTerminateAllCallsApiId = KDispatchPhoneFuncUnitId + 34;

   824 

   825 	/**

   826 	 * The CTSY Dispatcher shall invoke this function on receiving the ECtsyPhoneTerminateAllCallsReq

   827 	 * request from the CTSY.

   828 	 *

   829 	 * It is a request call that is completed by invoking CCtsyDispatcherCallback::CallbackPhoneTerminateAllCallsComp()

   830 	 *

   831 	 * Implementation of this interface should terminate all active calls.

   832 	 * 

   833 	 * @param aCallId if a call is in the connecting state then this parameter will contain the id of that call, else 0.

   834 	 * 

   835 	 * @return KErrNone on success, otherwise another error code indicating the

   836 	 * failure.

   837 	 * 

   838 	 *  @see RMobilePhone::TerminateAllCalls()

   839 	 */

   840 	virtual TInt HandleTerminateAllCallsReqL(TInt aCallId) = 0;

   841 

   842 	}; // class MLtsyDispatchPhoneTerminateAllCalls

   843 

   844 class MLtsyDispatchPhoneGetSystemNetworkBand : public MLtsyDispatchInterface

   845 	{

   846 public:

   847 

   848     static const TInt KLtsyDispatchPhoneGetSystemNetworkBandApiId = KDispatchPhoneFuncUnitId + 35;

   849 

   850 	/**

   851 	 * The CTSY Dispatcher shall invoke this function on receiving the ECustomGetBandSelectionIPC

   852 	 * request from the CTSY.

   853 	 *

   854 	 * It is a request call that is completed by invoking CCtsyDispatcherCallback::CallbackPhoneGetSystemNetworkBandComp()

   855 	 *

   856 	 * Implementation of this interface should return the current band and network mode.	 

   857 	 * 

   858 	 * @return KErrNone on success, otherwise another error code indicating the

   859 	 * failure.

   860 	 * 

   861 	 *  @see RMmCustomApi::GetSystemNetworkBand()

   862 	 */

   863 	virtual TInt HandleGetSystemNetworkBandReqL() = 0;

   864 

   865 	}; // class MLtsyDispatchPhoneGetSystemNetworkBand

   866 

   867 class MLtsyDispatchPhoneSetSystemNetworkBand : public MLtsyDispatchInterface

   868 	{

   869 public:

   870 

   871     static const TInt KLtsyDispatchPhoneSetSystemNetworkBandApiId = KDispatchPhoneFuncUnitId + 36;

   872 

   873 	/**

   874 	 * The CTSY Dispatcher shall invoke this function on receiving the ECustomSetBandSelectionIPC

   875 	 * request from the CTSY.

   876 	 *

   877 	 * It is a request call that is completed by invoking CCtsyDispatcherCallback::CallbackPhoneSetSystemNetworkBandComp()

   878 	 *

   879 	 * Implementation of this interface should set the current band and network mode.	 

   880 	 * 

   881 	 * @param aBand the desired network band.

   882 	 * @param aMode the desired network mode.

   883 	 * 

   884 	 * @return KErrNone on success, otherwise another error code indicating the

   885 	 * failure.

   886 	 * 

   887 	 *  @see RMmCustomApi::SetSystemNetworkBand()

   888 	 */

   889 	virtual TInt HandleSetSystemNetworkBandReqL(RMmCustomAPI::TBandSelection aBand, RMmCustomAPI::TNetworkModeCaps aMode) = 0;

   890 

   891 	}; // class MLtsyDispatchPhoneSetSystemNetworkBand

   892 

   893 #endif /*MLTSYDISPATCHPHONEINTERFACE_H_*/