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 PacketServices related features.

    16 //

    17 

    18 

    19 

    20 

    21 /**

    22  @file

    23  @internalAll 

    24 */

    25 

    26 

    27 #ifndef MLTSYDISPATCHPACKETSERVICESINTERFACE_H_

    28 #define MLTSYDISPATCHPACKETSERVICESINTERFACE_H_

    29 

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

    31 #include <etelpckt.h>

    32 #include <etelqos.h>

    33 

    34 

    35 

    36 

    37 class MLtsyDispatchPacketServicesPacketAttach : public MLtsyDispatchInterface

    38 	{

    39 public:

    40 

    41 	static const TInt KLtsyDispatchPacketServicesPacketAttachApiId = KDispatchPacketServicesFuncUnitId + 1;

    42 

    43 	/**

    44 	 * The CTSY Dispatcher shall invoke this function on receiving the EPacketAttach

    45 	 * request from the CTSY.

    46 	 *

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

    48 	 * CCtsyDispatcherCallback::CallbackPacketServicesPacketAttachComp()

    49 	 *

    50 	 * Implementation of this interface should issue an attach request to the LTSY.

    51 	 * 	

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

    53 	 * failure.

    54 	 */

    55 	virtual TInt HandlePacketAttachReqL() = 0;

    56 

    57 	}; // class MLtsyDispatchPacketServicesPacketAttach

    58 

    59 

    60 

    61 class MLtsyDispatchPacketServicesGetPacketAttachMode : public MLtsyDispatchInterface

    62 	{

    63 public:

    64 

    65 	static const TInt KLtsyDispatchPacketServicesGetPacketAttachModeApiId = KDispatchPacketServicesFuncUnitId + 2;

    66 

    67 	/**

    68 	 * The CTSY Dispatcher shall invoke this function on receiving the EPacketGetAttachMode

    69 	 * request from the CTSY.

    70 	 *

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

    72 	 * CCtsyDispatcherCallback::CallbackPacketServicesGetPacketAttachModeComp()

    73 	 *

    74 	 * Implementation of this interface will return the attach mode. However if the call is

    75 	 * being made during a packet service open process it will skip the get attach mode call.

    76 	 * 		 	

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

    78 	 * failure.

    79 	 */

    80 	virtual TInt HandleGetPacketAttachModeReqL() = 0;

    81 

    82 	}; // class MLtsyDispatchPacketServicesGetPacketAttachMode

    83 

    84 

    85 

    86 class MLtsyDispatchPacketServicesGetPacketNetworkRegistrationStatus : public MLtsyDispatchInterface

    87 	{

    88 public:

    89 

    90 	static const TInt KLtsyDispatchPacketServicesGetPacketNetworkRegistrationStatusApiId = KDispatchPacketServicesFuncUnitId + 3;

    91 

    92 	/**

    93 	 * The CTSY Dispatcher shall invoke this function on receiving the EPacketGetNtwkRegStatus

    94 	 * request from the CTSY.

    95 	 *

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

    97 	 * CCtsyDispatcherCallback::CallbackPacketServicesGetPacketNetworkRegistrationStatusComp()

    98 	 *

    99 	 * Implementation of this interface should retrieve the packet network registration status 

   100 	 * from the baseband.

   101 	 *

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

   103 	 * failure.

   104 	 */

   105 	virtual TInt HandleGetPacketNetworkRegistrationStatusReqL() = 0;

   106 

   107 	}; // class MLtsyDispatchPacketServicesGetPacketNetworkRegistrationStatus

   108 

   109 

   110 

   111 class MLtsyDispatchPacketServicesPacketDetach : public MLtsyDispatchInterface

   112 	{

   113 public:

   114 

   115 	static const TInt KLtsyDispatchPacketServicesPacketDetachApiId = KDispatchPacketServicesFuncUnitId + 4;

   116 

   117 	/**

   118 	 * The CTSY Dispatcher shall invoke this function on receiving the EPacketDetach

   119 	 * request from the CTSY.

   120 	 *

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

   122 	 * CCtsyDispatcherCallback::CallbackPacketServicesPacketDetachComp()

   123 	 * 	 

   124 	 * Implementation of this interface should issue a detach request to the LTSY.

   125 	 *

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

   127 	 * failure.

   128 	 */

   129 	virtual TInt HandlePacketDetachReqL() = 0;

   130 

   131 	}; // class MLtsyDispatchPacketServicesPacketDetach

   132 

   133 

   134 

   135 class MLtsyDispatchPacketServicesSetPdpContextConfig : public MLtsyDispatchInterface

   136 	{	

   137 public:

   138 

   139 	static const TInt KLtsyDispatchPacketServicesSetPdpContextConfigApiId = KDispatchPacketServicesFuncUnitId + 5;

   140 

   141 	/**

   142 	 * The CTSY Dispatcher shall invoke this function on receiving the EPacketContextSetConfig

   143 	 * request from the CTSY.

   144 	 *

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

   146 	 * CCtsyDispatcherCallback::CallbackPacketServicesSetPdpContextConfigComp()

   147 	 * Implementation of this interface should pass LTSY the parameters it needs to set the 

   148 	 * context configuration 

   149 	 *

   150 	 * @param aContextId the context name

   151 	 * @param aAccessPointName the access name which identifies the GGSN to be used

   152  	 * @param aPdpType the protocol type

   153  	 * @param aPdpAddress the PDP address for this context

   154  	 * @param aPcoBuffer the pco buffer

   155  	 *

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

   157 	 * failure.

   158 	 */

   159 	virtual TInt HandleSetPdpContextConfigReqL(const TDesC& aContextId,

   160 			const TDesC8& aAccessPointName,

   161 			const RPacketContext::TProtocolType aPdpType,

   162 			const TDesC8& aPdpAddress,

   163 			const TDesC8& aPcoBuffer) = 0;

   164 

   165 	}; // class MLtsyDispatchPacketServicesSetPdpContextConfig

   166 

   167 

   168 

   169 class MLtsyDispatchPacketServicesModifyActivePdpContext : public MLtsyDispatchInterface

   170 	{

   171 public:

   172 

   173 	static const TInt KLtsyDispatchPacketServicesModifyActivePdpContextApiId = KDispatchPacketServicesFuncUnitId + 6;

   174 

   175 	/**

   176 	 * The CTSY Dispatcher shall invoke this function on receiving the EPacketContextModifyActiveContext

   177 	 * request from the CTSY.

   178 	 *

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

   180 	 * CCtsyDispatcherCallback::CallbackPacketServicesModifyActivePdpContextComp()

   181 	 * Implementation of this interface should signal to the Licensee TSY that it can action the modification

   182 	 * of an existing context, the changes being indicated via appropriate RPacketContext::SetConfig and 

   183 	 * RPacketContext::SetProfileParameters calls

   184 	 *

   185 	 * @param aContextName the context name.

   186 	 *

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

   188 	 * failure.

   189 	 */

   190 	virtual TInt HandleModifyActivePdpContextReqL(const TDesC& aContextName) = 0;

   191 	}; // class MLtsyDispatchPacketServicesModifyActivePdpContext

   192 

   193 

   194 

   195 class MLtsyDispatchPacketServicesInitialisePdpContext : public MLtsyDispatchInterface

   196 	{

   197 public:

   198 

   199 	static const TInt KLtsyDispatchPacketServicesInitialisePdpContextApiId = KDispatchPacketServicesFuncUnitId + 7;

   200 

   201 	/**

   202 	 * The CTSY Dispatcher shall invoke this function on receiving the EPacketContextInitialiseContext

   203 	 * request from the CTSY.

   204 	 *

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

   206 	 * CCtsyDispatcherCallback::CallbackPacketServicesInitialisePdpContextComp()

   207 	 * Implementation of this interface should initialise either primary or secondary contexts

   208 	 *

   209 	 *

   210      * @param aPrimaryContextName Primary context name in the form of a character string, 

   211 	 * the maximum length of the descriptor should not exceed KMaxInfoName.

   212      * @param aSecondaryContextName Optional secondary context name in the form of a character

   213      * string, the maximum length of the descriptor should not exceed KMaxInfoName.

   214 	 *

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

   216 	 * failure.

   217 	 */

   218 	virtual TInt HandleInitialisePdpContextReqL(const TDesC& aPrimaryContextName, const TDesC& aSecondaryContextName) = 0;

   219 	}; // class MLtsyDispatchPacketServicesInitialisePdpContext

   220 

   221 

   222 

   223 class MLtsyDispatchPacketServicesDeletePdpContext : public MLtsyDispatchInterface

   224 	{

   225 public:

   226 

   227 	static const TInt KLtsyDispatchPacketServicesDeletePdpContextApiId = KDispatchPacketServicesFuncUnitId + 8;

   228 

   229 	/**

   230 	 * The CTSY Dispatcher shall invoke this function on receiving the EPacketContextDelete

   231 	 * request from the CTSY.

   232 	 *

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

   234 	 * CCtsyDispatcherCallback::CallbackPacketServicesDeletePdpContextComp()

   235 	 *

   236 	 * Implementation of this interface should delete the context given.      

   237 	 * 

   238 	 * @param aContextName The name of the context to delete, 

   239 	 * the maximum length of the descriptor should not exceed KMaxInfoName.

   240 	 * 

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

   242 	 * failure.

   243 	 */

   244 	virtual TInt HandleDeletePdpContextReqL(const TDesC& aContextName) = 0;

   245 

   246 	}; // class MLtsyDispatchPacketServicesDeletePdpContext

   247 

   248 

   249 

   250 class MLtsyDispatchPacketServicesSetPacketAttachMode : public MLtsyDispatchInterface

   251 	{

   252 public:

   253 

   254 	static const TInt KLtsyDispatchPacketServicesSetPacketAttachModeApiId = KDispatchPacketServicesFuncUnitId + 9;

   255 

   256 	/**

   257 	 * The CTSY Dispatcher shall invoke this function on receiving the EPacketSetAttachMode

   258 	 * request from the CTSY.

   259 	 *

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

   261 	 * CCtsyDispatcherCallback::CallbackPacketServicesSetPacketAttachModeComp()

   262 	 *

   263 	 * Implementation of this interface should set the packet service attach mode.

   264 	 * @param aAttachMode the attach mode due to be set.

   265 	 *

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

   267 	 * failure.

   268 	 */

   269 	virtual TInt HandleSetPacketAttachModeReqL(RPacketService::TAttachMode aAttachMode) = 0;

   270 

   271 	}; // class MLtsyDispatchPacketServicesSetPacketAttachMode

   272 

   273 

   274 

   275 class MLtsyDispatchPacketServicesNotifyPacketStatusChange : public MLtsyDispatchInterface

   276 	{

   277 public:

   278 

   279 	static const TInt KLtsyDispatchPacketServicesNotifyPacketStatusChangeApiId = KDispatchPacketServicesFuncUnitId + 10;

   280 

   281 	/**

   282 	 * The CTSY Dispatcher shall invoke this function on receiving the EPacketNotifyStatusChange

   283 	 * request from the CTSY.

   284 	 *

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

   286 	 * CCtsyDispatcherCallback::CallbackPacketServicesNotifyPacketStatusChangeComp()

   287 	 *

   288 	 * Implementation of this interface should notify when the status of the packet service was changed.

   289 	 * 

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

   291 	 * failure.

   292 	 */

   293 	virtual TInt HandleNotifyPacketStatusChangeReqL() = 0;

   294 

   295 	}; // class MLtsyDispatchPacketServicesNotifyPacketStatusChange

   296 

   297 

   298 

   299 class MLtsyDispatchPacketServicesSetDefaultPdpContextGprsParams : public MLtsyDispatchInterface

   300 	{

   301 public:

   302 

   303 	static const TInt KLtsyDispatchPacketServicesSetDefaultPdpContextGprsParamsApiId = KDispatchPacketServicesFuncUnitId + 11;

   304 

   305 	/**

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

   307 	 * request from the CTSY.

   308 	 *

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

   310 	 * CCtsyDispatcherCallback::CallbackPacketServicesSetDefaultPdpContextParamsComp()

   311 	 *

   312 	 * Implementation of this interface should set default configuration for Packet Context using GPRS params.

   313 	 *

   314 	 * @param aContextConfigGprs GPRS configuration input parameters.

   315 	 *

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

   317 	 * failure.

   318 	 */

   319 	virtual TInt HandleSetDefaultPdpContextGprsParamsReqL(const RPacketContext::TContextConfigGPRS& aContextConfigGprs) = 0;

   320 

   321 	}; // class MLtsyDispatchPacketServicesSetDefaultPdpContextGprsParams

   322 

   323 class MLtsyDispatchPacketServicesSetDefaultPdpContextR99R4Params : public MLtsyDispatchInterface

   324 	{

   325 public:

   326 

   327 	static const TInt KLtsyDispatchPacketServicesSetDefaultPdpContextR99R4ParamsApiId = KDispatchPacketServicesFuncUnitId + 12;

   328 

   329 	/**

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

   331 	 * request from the CTSY.

   332 	 * 

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

   334 	 * CCtsyDispatcherCallback::CallbackPacketServicesSetDefaultPdpContextParamsComp()

   335 	 * 

   336 	 * Implementation of this interface should set default configuration for Packet Context using R99/R4 params.

   337 	 *

   338 	 * @param aContextConfigR99R4 R99/R4 configuration input parameters.

   339 	 *

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

   341 	 * failure.

   342 	 */

   343 	virtual TInt HandleSetDefaultPdpContextR99R4ParamsReqL(const RPacketContext::TContextConfigR99_R4& aContextConfigR99R4) = 0;

   344 

   345 	}; // class MLtsyDispatchPacketServicesSetDefaultPdpContextR99R4Params

   346 

   347 

   348 class MLtsyDispatchPacketServicesActivatePdpContext : public MLtsyDispatchInterface

   349 	{

   350 public:

   351 

   352 	static const TInt KLtsyDispatchPacketServicesActivatePdpContextApiId = KDispatchPacketServicesFuncUnitId + 13;

   353 

   354 	/**

   355 	 * The CTSY Dispatcher shall invoke this function on receiving the EPacketContextActivate

   356 	 * request from the CTSY.

   357 	 *

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

   359 	 * CCtsyDispatcherCallback::CallbackPacketServicesActivatePdpContextComp()

   360 	 *

   361 	 * Implementation of this interface should activate the context given.

   362 	 * 

   363 	 * @param aContextName The context name, the maximum length of the descriptor 

   364 	 * should not exceed KMaxInfoName.	 

   365 	 *

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

   367 	 * failure.

   368 	 */

   369 	virtual TInt HandleActivatePdpContextReqL(const TDesC& aContextName) = 0;

   370 

   371 	}; // class MLtsyDispatchPacketServicesActivatePdpContext

   372 

   373 

   374 

   375 class MLtsyDispatchPacketServicesSetPdpContextQosGprs : public MLtsyDispatchInterface

   376 	{

   377 public:

   378 

   379 	static const TInt KLtsyDispatchPacketServicesSetPdpContextQosGprsApiId = KDispatchPacketServicesFuncUnitId + 14;

   380 

   381 	/**

   382 	 * The CTSY Dispatcher shall invoke this function on receiving the EPacketQoSSetProfileParams

   383 	 * request from the CTSY.

   384 	 * 

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

   386 	 * CCtsyDispatcherCallback::CallbackPacketServicesSetPdpContextQosComp()

   387 	 * 

   388 	 * Implementation of this interface should set GPRS QoS parametes for the given context.

   389 	 *

   390 	 * @param aContextName The name of the context, the maximum length of the 

   391      * descriptor should not exceed KMaxInfoName.

   392 	 * @param aQoSConfig The QoS configuration parameters.

   393 	 *

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

   395 	 * failure.

   396 	 */

   397 	virtual TInt HandleSetPdpContextQosGprsReqL(const TDesC& aContextName, const RPacketQoS::TQoSGPRSRequested& aQoSConfig) = 0;

   398 

   399 	}; // class MLtsyDispatchPacketServicesSetPdpContextQosGprs

   400 

   401 class MLtsyDispatchPacketServicesSetPdpContextQosR99R4 : public MLtsyDispatchInterface

   402 	{

   403 public:

   404 

   405 	static const TInt KLtsyDispatchPacketServicesSetPdpContextQosR99R4ApiId = KDispatchPacketServicesFuncUnitId + 15;

   406 

   407 	/**

   408 	 * The CTSY Dispatcher shall invoke this function on receiving the EPacketQoSSetProfileParams

   409 	 * request from the CTSY.

   410 	 * 

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

   412 	 * CCtsyDispatcherCallback::CallbackPacketServicesSetPdpContextQosComp()

   413 	 * 

   414 	 * Implementation of this interface should set R99R4 QoS parametes for the given context.

   415 	 * 

   416 	 *

   417 	 * @param aContextName the name of the context.

   418 	 * @param aQoSConfig the QoS configuration parameters.

   419 	 *

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

   421 	 * failure.

   422 	 */

   423 	virtual TInt HandleSetPdpContextQosR99R4ReqL(const TDesC& aContextName, const RPacketQoS::TQoSR99_R4Requested& aQoSConfig) = 0;

   424 

   425 	}; // class MLtsyDispatchPacketServicesSetPdpContextQosR99R4

   426 

   427 class MLtsyDispatchPacketServicesSetPdpContextQosR5 : public MLtsyDispatchInterface

   428 	{

   429 public:

   430 

   431 	static const TInt KLtsyDispatchPacketServicesSetPdpContextQosR5ApiId = KDispatchPacketServicesFuncUnitId + 16;

   432 

   433 	/**

   434 	 * The CTSY Dispatcher shall invoke this function on receiving the EPacketQoSSetProfileParams

   435 	 * request from the CTSY.

   436 	 *

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

   438 	 * CCtsyDispatcherCallback::CallbackPacketServicesSetPdpContextQosComp()

   439 	 *

   440 	 * Implementation of this interface should set R5 QoS parametes for the given context.

   441 	 *

   442 	 *

   443 	 * @param aContextName The name of the context, the maximum length of the 

   444 	 * descriptor should not exceed KMaxInfoName.

   445 	 * @param aQoSConfig The QoS configuration parameters.

   446 	 *

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

   448 	 * failure.

   449 	 */

   450 	virtual TInt HandleSetPdpContextQosR5ReqL(const TDesC& aContextName, const RPacketQoS::TQoSR5Requested& aQoSConfig) = 0;

   451 

   452 	}; // class MLtsyDispatchPacketServicesSetPdpContextQosR5

   453 

   454 

   455 

   456 

   457 class MLtsyDispatchPacketServicesRejectNetworkInitiatedContextActivationRequest : public MLtsyDispatchInterface

   458 	{

   459 public:

   460 

   461 	static const TInt KLtsyDispatchPacketServicesRejectNetworkInitiatedContextActivationRequestApiId = KDispatchPacketServicesFuncUnitId + 17;

   462 

   463 	/**

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

   465 	 * request from the CTSY.

   466 	 *

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

   468 	 * CCtsyDispatcherCallback::CallbackPacketServicesRejectNetworkInitiatedContextActivationRequestComp()

   469 	 *

   470 	 * Implementation of this interface should reject the network initiated context activation request.

   471 	 * 

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

   473 	 * failure.

   474 	 */

   475 	virtual TInt HandleRejectNetworkInitiatedContextActivationRequestReqL() = 0;

   476 

   477 	}; // class MLtsyDispatchPacketServicesRejectNetworkInitiatedContextActivationRequest

   478 

   479 

   480 

   481 class MLtsyDispatchPacketServicesDeactivatePdpContext : public MLtsyDispatchInterface

   482 	{

   483 public:

   484 

   485 	static const TInt KLtsyDispatchPacketServicesDeactivatePdpContextApiId = KDispatchPacketServicesFuncUnitId + 18;

   486 

   487 	/**

   488 	 * The CTSY Dispatcher shall invoke this function on receiving the EPacketContextDeactivate

   489 	 * request from the CTSY.

   490 	 *

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

   492 	 * CCtsyDispatcherCallback::CallbackPacketServicesDeactivatePdpContextComp()

   493 	 * Implementation of this interface should deactivate the context indicated by the context name.

   494 	 *

   495 	 *

   496 	 * @param aContextName The context name that is to be deactivated, 

   497 	 * the maximum length of the descriptor should not exceed KMaxInfoName.

   498 	 *

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

   500 	 * failure.

   501 	 */

   502 	virtual TInt HandleDeactivatePdpContextReqL(const TDesC& aContextName) = 0;

   503 

   504 	}; // class MLtsyDispatchPacketServicesDeactivatePdpContext

   505 

   506 

   507 

   508 class MLtsyDispatchPacketServicesAddPacketFilter : public MLtsyDispatchInterface

   509 	{

   510 public:

   511 

   512 	static const TInt KLtsyDispatchPacketServicesAddPacketFilterApiId = KDispatchPacketServicesFuncUnitId + 19;

   513 

   514 	/**

   515 	 * The CTSY Dispatcher shall invoke this function on receiving the EPacketContextAddPacketFilter

   516 	 * request from the CTSY.

   517 	 * Implementation of this interface should add a packet filter to the packet service.

   518 	 * 

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

   520 	 * CCtsyDispatcherCallback::CallbackPacketServicesSetPdpContextConfigComp()	 

   521 	 * 

   522 	 * @param aContextName The name of the context, the maximum length of the 

   523 	 * descriptor should not exceed KMaxInfoName.

   524 	 * @param aContextFilter An array contains up to eight filters to be used

   525 	 * for configuring the secondary context.

   526 	 * 

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

   528 	 * failure.

   529 	 */

   530 	virtual TInt HandleAddPacketFilterSyncL(const TDesC& aContextName,  CArrayFixFlat<RPacketContext::TPacketFilterV2>& aContextFilter) = 0;

   531 

   532 	}; // class MLtsyDispatchPacketServicesAddPacketFilter

   533 

   534 class MLtsyDispatchPacketServicesGetStatus : public MLtsyDispatchInterface

   535 	{

   536 public:

   537 

   538 	static const TInt KLtsyDispatchPacketServicesGetStatusApiId = KDispatchPacketServicesFuncUnitId + 20;

   539 

   540 	/**

   541 	 * The CTSY Dispatcher shall invoke this function during the packet services bootup

   542 	 * as part of EPacketNotifyStatusChange call.

   543 	 * 

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

   545 	 * CCtsyDispatcherCallback::CallbackPacketServicesGetStatusComp()

   546 	 * 

   547 	 * Implemetation of this interface should retrieve the packet service status.

   548 	 * 

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

   550 	 * failure.

   551 	 */

   552 	virtual TInt HandleGetStatusReqL() = 0;

   553 

   554 	}; // class MLtsyDispatchPacketServicesGetStatus

   555 

   556 class MLtsyDispatchPacketServicesGetStaticCapabilities : public MLtsyDispatchInterface

   557 	{

   558 public:

   559 

   560 	static const TInt KLtsyDispatchPacketServicesGetStaticCapabilitiesApiId = KDispatchPacketServicesFuncUnitId + 21;

   561 

   562 	/**

   563 	 * The CTSY Dispatcher shall invoke this function during the packet services bootup

   564 	 * as part of EPacketGetStaticCaps call.

   565 	 * 

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

   567 	 * CCtsyDispatcherCallback::CallbackPacketServicesGetStaticCapabilitiesComp()

   568 	 * 

   569 	 * Implemetation of this interface should retrieve the packet service static capabilities.

   570 	 * 

   571 	 * Calls to RPacketService::GetStaticCaps() will then return the static capabilities returned

   572 	 * in the callback.

   573 	 * 

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

   575 	 * failure.

   576 	 * 

   577 	 * @see RPacketService::GetStaticCaps()

   578 	 */

   579 	virtual TInt HandleGetStaticCapabilitiesReqL() = 0;

   580 

   581 	}; // class MLtsyDispatchPacketServicesGetStaticCapabilities

   582 

   583 class MLtsyDispatchPacketServicesGetMaxNoMonitoredServiceLists : public MLtsyDispatchInterface

   584 	{

   585 public:

   586 

   587 	static const TInt KLtsyDispatchPacketServicesGetMaxNoMonitoredServiceListsApiId = KDispatchPacketServicesFuncUnitId + 22;

   588 

   589 	/**

   590 	 * The CTSY Dispatcher shall invoke this function during the packet services bootup

   591 	 * as part of EPacketEnumerateMbmsMonitorServiceList call.

   592 	 * 

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

   594 	 * CCtsyDispatcherCallback::CallbackPacketServicesGetMaxNoMonitoredServiceListsComp()

   595 	 * 

   596 	 * Implemetation of this interface should retrieve the maximum number of monitored service lists.

   597 	 * 

   598 	 * Calls to RPacketService::EnumerateMbmsMonitorServiceList() will then return the 

   599 	 * maximum number of monitored service lists in the aMaxAllowed field.

   600 	 * 

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

   602 	 * failure.

   603 	 * 

   604 	 * @see RPacketService::EnumerateMbmsMonitorServiceList()

   605 	 */

   606 	virtual TInt HandleGetMaxNoMonitoredServiceListsReqL() = 0;

   607 

   608 	}; // class MLtsyDispatchPacketServicesGetMaxNoMonitoredServiceLists

   609 

   610 class MLtsyDispatchPacketServicesGetMaxNoActiveServices : public MLtsyDispatchInterface

   611 	{

   612 public:

   613 

   614 	static const TInt KLtsyDispatchPacketServicesGetMaxNoActiveServicesApiId = KDispatchPacketServicesFuncUnitId + 23;

   615 

   616 	/**

   617 	 * The CTSY Dispatcher shall invoke this function during the packet services bootup

   618 	 * as part of EPacketEnumerateMbmsActiveServiceList call.

   619 	 * 

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

   621 	 * CCtsyDispatcherCallback::CallbackPacketServicesGetMaxNoActiveServicesComp()

   622 	 * 

   623 	 * Implemetation of this interface should retrieve the maximum number of active services allowed

   624 	 * (hence the maximum number of contexts allowed).

   625 	 * 

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

   627 	 * failure.

   628 	 * 

   629 	 */

   630 	virtual TInt HandleGetMaxNoActiveServicesReqL() = 0;

   631 

   632 	}; // class MLtsyDispatchPacketServicesGetMaxNoActiveServices

   633 

   634 class MLtsyDispatchPacketServicesInitialiseMbmsContext : public MLtsyDispatchInterface

   635 	{

   636 public:

   637 

   638 	static const TInt KLtsyDispatchPacketServicesInitialiseMbmsContextApiId = KDispatchPacketServicesFuncUnitId + 24;

   639 

   640 	/**

   641 	 * The CTSY Dispatcher shall invoke this function on receiving the ECtsyPacketMbmsInitialiseContextReq

   642 	 * request from the CTSY.

   643 	 *

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

   645 	 * CCtsyDispatcherCallback::CallbackPacketServicesInitialiseMbmsContextComp()

   646 	 * 

   647 	 * Implementation of this interface should initialise the Mbms Context

   648 	 * (Multimedia Broadcast Multicast Service).

   649 	 *

   650      * @param aContextName The context name in the form of a character string 

   651 	 * the maximum length of the descriptor should not exceed KMaxInfoName.

   652 	 * 

   653 	 *

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

   655 	 * failure.

   656 	 * 

   657 	 * @see RPacketMbmsContext::InitialiseContext()

   658 	 */

   659 	virtual TInt HandleInitialiseMbmsContextReqL(const TDesC& aContextName) = 0;

   660 

   661 	}; // class MLtsyDispatchPacketServicesInitialiseMbmsContext

   662 

   663 class MLtsyDispatchPacketServicesGetMbmsNetworkServiceStatus : public MLtsyDispatchInterface

   664 	{

   665 public:

   666 

   667 	static const TInt KLtsyDispatchPacketServicesGetMbmsNetworkServiceStatusApiId = KDispatchPacketServicesFuncUnitId + 25;

   668 

   669 	/**

   670 	 * The CTSY Dispatcher shall invoke this function on receiving the EPacketGetMbmsNetworkServiceStatus

   671 	 * request from the CTSY.

   672 	 *

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

   674 	 * CCtsyDispatcherCallback::CallbackPacketServicesGetMbmsNetworkServiceStatusComp()

   675 	 * 

   676 	 * Implementation of this interface should retrieve the current MBMS

   677 	 * (Multimedia Broadcast Multicast Service) network state. 

   678 	 * 

   679 	 * There can be 3 states that MBMS feature availability could return,

   680 	 *  Unknown - when UE is not GMM Attached.

   681 	 *  Supported - When UE is GMM Attached and it is known that cell supports MBMS.

   682 	 *  Not Supported - When UE is GMM Attached and it is know that cell does not support MBMS.

   683 	 * 

   684 	 * The state is only known from GMM Attach response from the network or during a Routing Area update.

   685 	 * A consequence of this is that it is required for the UE to be in GMM Attach mode in order 

   686 	 * for either of these messages to be received. If the UE is not in GMM ATTACH then it is unable 

   687 	 * to determine MBMS network support.

   688 	 *

   689      * @param aAttemptAttach If a GMM attached is to be performed.

   690 	 *

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

   692 	 * failure.

   693 	 * 

   694 	 * @see  RPacketService::GetMbmsNetworkServiceStatus()

   695 	 */

   696 	virtual TInt HandleGetMbmsNetworkServiceStatusReqL(TBool aAttemptAttach) = 0;

   697 

   698 	}; // class MLtsyDispatchPacketServicesInitialiseMbmsContext

   699 

   700 class MLtsyDispatchPacketServicesUpdateMbmsMonitorServiceList : public MLtsyDispatchInterface

   701 	{

   702 public:

   703 

   704 	static const TInt KLtsyDispatchPacketServicesUpdateMbmsMonitorServiceListApiId = KDispatchPacketServicesFuncUnitId + 26;

   705 

   706 	/**

   707 	 * The CTSY Dispatcher shall invoke this function on receiving the EPacketUpdateMbmsMonitorServiceList

   708 	 * request from the CTSY.

   709 	 *

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

   711 	 * CCtsyDispatcherCallback::CallbackPacketServicesUpdateMbmsMonitorServiceListComp()

   712 	 * 

   713 	 * Implementation of this interface should request to update the MBMS (Multimedia Broadcast Multicast Service)

   714 	 * monitor service availability list with the change list entries as per the action mentioned. 

   715 	 * The CTSY stores the monitor service availability list, this list is updated on a successful completion.

   716 	 * 

   717      * @param aAction The MBMS action (add, remove or remove all).

   718      * @param aServiceList The current MBMS monitor service availability list as held by the CTSY.

   719      * @param aChangeList The list of entries to be changed as per the action. (e.g. the action = Add,

   720      * the change list will contain entries to be added to the MBMS monitor service availability list)

   721 	 *

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

   723 	 * failure.

   724 	 * 

   725 	 * @see RPacketService::UpdateMbmsMonitorServiceListL()

   726 	 * @see RPacketService::NotifyMbmsServiceAvailabilityChange()

   727 	 * @see CRetrievePcktMbmsMonitoredServices()

   728 	 */

   729 	virtual TInt HandleUpdateMbmsMonitorServiceListsReqL(TMbmsAction aAction, const CPcktMbmsMonitoredServiceList& aServiceList, const CPcktMbmsMonitoredServiceList& aChangeList) = 0;

   730 

   731 	}; // class MLtsyDispatchPacketServicesUpdateMbmsMonitorServiceList

   732 

   733 class MLtsyDispatchPacketServicesUpdateMbmsSessionList : public MLtsyDispatchInterface

   734 	{

   735 public:

   736 

   737 	static const TInt KLtsyDispatchPacketServicesUpdateMbmsSessionListApiId = KDispatchPacketServicesFuncUnitId + 27;

   738 

   739 	/**

   740 	 * The CTSY Dispatcher shall invoke this function on receiving the EPacketContextUpdateMbmsSessionList

   741 	 * request from the CTSY.

   742 	 *

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

   744 	 * CCtsyDispatcherCallback::CallbackPacketServicesUpdateMbmsSessionListComp()

   745 	 * 

   746 	 * Implementation of this interface should request to add a new session to be received or remove 

   747 	 * an existing session to/from the MBMS services table.

   748 	 * The CTSY stores the MBMS services table, this table is updated on a successful completion.

   749 	 * 

   750 	 * @param aContextName The MBMS context name in the form of a character string.

   751      * @param aAction The action to be performed (add, remove or remove all).

   752      * @param aSessionId The MBMS session identifier which needs to be received or removed.

   753      * @param aServiceList The MBMS services table as held by the CTSY.

   754 	 *

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

   756 	 * failure.

   757 	 * 

   758 	 * @see RPacketService::UpdateMbmsSessionList()

   759 	 * @see CRetrievePcktMbmsSessionList()

   760 	 */

   761 	virtual TInt HandleUpdateMbmsSessionListReqL(const TDesC& aContextName, TMbmsAction aAction, TMbmsSessionId aSessionId, const TMbmsSessionIdList& aServiceList) = 0;

   762 

   763 	}; // class MLtsyDispatchPacketServicesUpdateMbmsSessionList

   764 

   765 class MLtsyDispatchPacketServicesRemovePacketFilter : public MLtsyDispatchInterface

   766 	{

   767 public:

   768 

   769 	static const TInt KLtsyDispatchPacketServicesRemovePacketFilterApiId = KDispatchPacketServicesFuncUnitId + 28;

   770 	/**

   771 	 * The CTSY Dispatcher shall invoke this function on receiving the EPacketContextRemovePacketFilter

   772 	 * request from the CTSY.

   773 	 * Implementation of this interface should remove a packet filter from the packet service.

   774 	 * 

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

   776 	 * CCtsyDispatcherCallback::CallbackPacketServicesSetPdpContextConfigComp()	 

   777 	 * 

   778 	 * @param aContextName The name of the context, the maximum length of the 

   779 	 * descriptor should not exceed KMaxInfoName.

   780 	 * @param aFilterId The filter Id to remove.

   781 	 * 

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

   783 	 * failure.

   784 	 */

   785 	virtual TInt HandleRemovePacketFilterSyncL(const TDesC& aContextName,  TInt aFilterId) = 0;

   786 

   787 	}; // class MLtsyDispatchPacketServicesRemovePacketFilter

   788 

   789 #endif /*MLTSYDISPATCHPACKETSERVICESINTERFACE_H_*/