1 // Copyright (c) 2000-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 // Multimode ETel API v1.0

    15 // Header file for ptr holder classes, used to store client data

    16 // 

    17 //

    18 

    19 /**

    20  @file

    21 */

    22 

    23 #ifndef _MM_HOLD_H_

    24 #define _MM_HOLD_H_

    25 

    26 #include <etelmm.h>

    27 

    28 

    29 class CMmPtrHolder : public CBase

    30 /**

    31 A base class for all ptr holder classes

    32 

    33 The ptr holder classes contain the TPtr8's used by asynchronous client-side functions.

    34 The API code also uses them to ensure BC by keeping size of R-classes constant.

    35 

    36 @publishedPartner

    37 @released

    38 */

    39 	{

    40 public:

    41 //	static CMmPtrHolder* NewL(TInt aSizeOfPtrArray,TInt aSizeOfPtrCArray);

    42 	virtual ~CMmPtrHolder();

    43 public:

    44 	template <typename T> inline TPtr8& Set(TInt aSlot,T& aObject)

    45 		{

    46 		TPtr8& ptr=Ptr(aSlot);

    47 		ptr.Set(REINTERPRET_CAST(TText8*,(&aObject)),sizeof(T),sizeof(T));

    48 		return ptr;

    49 		};

    50 

    51 	template <typename T> inline TPtrC8& SetC(TInt aSlot, const T& aObject)

    52 		{

    53 		TPtrC8& ptr=PtrC(aSlot);

    54 		ptr.Set(REINTERPRET_CAST(const TText8*,(&aObject)),sizeof(T));

    55 		return ptr;

    56 		};

    57 

    58 protected:

    59 	virtual void ConstructL(TInt aSizeOfPtrArray,TInt aSizeOfPtrCArray);	

    60 	CMmPtrHolder();

    61 private:

    62 	TPtr8& Ptr(TInt aIndex);

    63 	TPtrC8& PtrC(TInt aIndex);

    64 protected:

    65 	RArray<TPtr8> iPtrArray;

    66 	RArray<TPtrC8> iPtrCArray;

    67 	};

    68 

    69 

    70 

    71 class CMobilePhonePtrHolder : public CMmPtrHolder

    72 /**

    73 Holds the TPtr8 arrays for all RMobilePhone requests

    74 

    75 This class is internal.

    76 

    77 @publishedPartner

    78 @released

    79 */

    80 

    81 	{

    82 public:

    83 

    84 	// The ptr holder slot numbers used by RMobilePhone asynchronous requests

    85 

    86 	enum TPhonePtrHolderSlots

    87 		{

    88 		ESlot1NotifyIccAccessCapsChange =0,

    89 		ESlot1GetServiceTable,

    90 		ESlot1GetBatteryInfo,

    91 		ESlot1NotifyBatteryInfoChange,

    92 		ESlot1GetSignalStrength,

    93 		ESlot2GetSignalStrength,

    94 		ESlot1NotifySignalStrengthChange,

    95 		ESlot2NotifySignalStrengthChange,

    96 		ESlot1GetIndicator,

    97 		ESlot1NotifyIndicatorChange,

    98 		ESlot1GetPhoneId,

    99 		ESlot1GetSubscriberId,

   100 		ESlot1NotifyDTMFCapsChange,

   101 		ESlot1NotifyModeChange,

   102 		ESlot1GetCurrentNetwork,

   103 		ESlot1NotifyCurrentNetworkChange,

   104 		ESlot1GetNetworkRegistrationStatus,

   105 		ESlot1NotifyNetworkRegistrationStatusChange,

   106 		ESlot1NotifyNetworkSelectionSettingChange,

   107 		ESlot1NotifyNITZInfoChange,

   108 		ESlot1NotifyDefaultPrivacyChange,

   109 		ESlot1NotifyCallServiceCapsChange,

   110 		ESlot1GetFeatureCode,

   111 		ESlot1NotifyCallForwardingStatusChange,

   112 		ESlot1PhoneNotifyCallForwardingActive,

   113 		ESlot2PhoneNotifyCallForwardingActive,

   114 		ESlot2GetIdentityServiceStatus,

   115 		ESlot1NotifyCallBarringStatusChange,

   116 		ESlot1GetCCBSStatus,

   117 		ESlot2GetCCBSStatus,

   118 		ESlot1NotifyCCBSStatusChange,

   119 		ESlot1NotifyAlternatingCallCapsChange,

   120 		ESlot1NotifyAlternatingCallModeChange,

   121 		ESlot2NotifyAlternatingCallModeChange,

   122 		ESlot1NotifyALSLineChange,

   123 		ESlot1NotifyCostCapsChange,

   124 		ESlot1NotifySecurityCapsChange,

   125 		ESlot1NotifyLockInfoChange,

   126 		ESlot1NotifySecurityEvent,

   127 		ESlot1NotifyMessageWaiting,

   128 		ESlot2NotifyMessageWaiting,

   129 		ESlot1NotifyFdnStatusChange,

   130 		ESlot1GetIncomingCallType,

   131 		ESlot1NotifyIncomingCallTypeChange,

   132 		ESlot1GetUUSSetting,

   133 		ESlot1NotifyUUSSettingChange,

   134 		ESlot1NotifyMultimediaCallPreferenceChange,

   135 		ESlot1GetNetworkSecurityLevel,

   136 		ESlot1NotifyNetworkSecurityLevelChange,

   137 		ESlot1NotifyUSimApplicationsInfoChange,

   138 		ESlot2NotifyUSimApplicationsInfoChange,

   139 		ESlot1NotifyUSimAppsSelectionModeChange,

   140 		ESlot1EnumerateUSimApplications,

   141 		ESlot2EnumerateUSimApplications,

   142 		ESlot1NotifyCCBSRecall,

   143 		ESlot1GetFdnStatus,

   144 		ESlot1GetHomeNetworkSearchPeriod,

   145 		ESlot1GetLastUsedAccessTechnology,

   146 		ESlot1NotifyNetworkInvScanChange,

   147 		ESlot1NotifyNetworkInvScanEvent,

   148 		ESlot1EnumerateAPNEntries,

   149 		ESlot1NotifyAirTimeDurationChange,

   150 		ESlot1NotifyDTMFEvent,

   151 		ESlot1GetPersonalisationStatus,

   152 		ESlot1GetCipheringIndicatorStatus,

   153 		ESlot1NotifyCipheringIndicatorStatus,

   154 		ESlot1EnumerateSmartCardApplications,

   155 		ESlot1GetCurrentActiveUSimApplication,

   156 		ESlot1GetIccIdentity,

   157 		ESlot1NotifySecurityCodeInfoChange,

   158 		ESlot1SmartCardAuthenticate,

   159 		ESlot1GetAPNControlListServiceStatus,

   160 		ESlot1NotifyAPNControlListServiceStatusChange,

   161 		EMaxNumberPhonePtrSlots

   162 		};

   163 

   164 	enum TPhonePtrCHolderSlots

   165 		{

   166 		ESlot1SetNetworkSelectionSetting = 0,

   167 		ESlot1SetDefaultPrivacy,

   168 		ESlot1ProgramFeatureCode,

   169 		ESlot1SetCallForwardingStatus,

   170 		ESlot2SetCallForwardingStatus,

   171 		ESlot1GetIdentityServiceStatus,

   172 		ESlot1SetCallBarringStatus,

   173 		ESlot2SetCallBarringStatus,

   174 		ESlot1SetCallBarringPassword,

   175 		ESlot1SetCallWaitingStatus,

   176 		ESlot2SetCallWaitingStatus,

   177 		ESlot1SetAlternatingCallMode,

   178 		ESlot2SetAlternatingCallMode,

   179 		ESlot1SetALSLine,

   180 		ESlot1ClearCostMeter,

   181 		ESlot1SetMaxCostMeter,

   182 		ESlot1GetLockInfo,

   183 		ESlot1SetLockSetting,

   184 		ESlot2SetLockSetting,

   185 		ESlot1ChangeSecurityCode,

   186 		ESlot2ChangeSecurityCode,

   187 		ESlot1VerifySecurityCode,

   188 		ESlot2VerifySecurityCode,

   189 		ESlot1SetFdnSetting,

   190 		ESlot1SelectNetwork,

   191 		ESlot2SelectNetwork,

   192 		ESlot1SetMulticallParams,

   193 		ESlot1SetIncomingCallType,

   194 		ESlot1SetUUSSetting,

   195 		ESlot1SetUSimApplicationStatus,

   196 		ESlot2SetUSimApplicationStatus,

   197 		ESlot1GetUSimApplicationInfo,

   198 		ESlot1SetMultimediaCallPreference,

   199 		ESlot1GetPhoneStoreInfo,

   200 		ESlot1AcceptCCBSRecall,		

   201 		ESlot1DeactivateCCBS,	

   202 		ESlot1SetService,

   203 		ESlot1GetMmsConfig,

   204 		ESlot1NotifyMmsConfig,

   205 		ESlot1GetCompMethodName,

   206 		ESlot1GetAPNnameIndex,

   207 		ESlot1DeleteAPNNameIndex,

   208 		ESlot1SetAPNControlListServiceStatus,

   209 		ESlot1SendSSOperation,

   210 		ESlot1SetPersonalisationStatus,

   211 		ESlot1SetIdentityServiceStatus,

   212 		ESlot2SetIdentityServiceStatus,

   213 		ESlot1NotifyIdentityServiceStatus,

   214 		ESlot2NotifyIdentityServiceStatus,

   215 		ESlot1NotifyMulticallIndicatorChange,

   216 		ESlot1GetSmartCardApplicationInfo,

   217 		ESlot1NotifySmartCardApplicationInfoChange,

   218 		ESlot2NotifySmartCardApplicationInfoChange,

   219 		ESlot1SetSmartCardApplicationStatus,

   220 		ESlot2SetSmartCardApplicationStatus,

   221 		ESlot1GetScFileInfo,

   222 		ESlot1ReadScFile,

   223 		ESlot1UpdateScFile,

   224 		ESlot1GetSecurityCodeInfo,

   225 		ESlot1SetGbaBootstrapParams,

   226 		EMaxNumberPhonePtrCSlots

   227 		};

   228 

   229 public:

   230 	static CMobilePhonePtrHolder* NewL(TInt aSizeOfPtrArray,TInt aSizeOfPtrCArray);

   231 	~CMobilePhonePtrHolder();

   232 protected:

   233 	CMobilePhonePtrHolder();

   234 public:

   235 	// Storage for parameters from client which were passed by value.

   236 	RMobilePhone::TMobilePhoneServiceTable iServiceTable;

   237 	RMobilePhone::TMobilePhonePrivacy iPrivacySetting;

   238 	RMobilePhone::TMobilePhoneCFCondition iSetCFCondition;

   239 	RMobilePhone::TNetworkServiceAndAction iProgramFeatureCode;

   240 	RMobilePhone::TNetworkServiceAndAction iGetFeatureCode;

   241 	RMobilePhone::TIdServiceAndLocation iGetIdentityServiceStatus;

   242 	RMobilePhone::TMobilePhoneCBCondition iSetCBStatusCondition;

   243 	RMobilePhone::TMobileInfoLocation iGetCCBSStatusLocation;

   244 	RMobilePhone::TMobileService iSetCallWaitingStatusGroup;

   245 	RMobilePhone::TMobilePhoneServiceAction iSetCallWaitingStatusAction;

   246 	RMobilePhone::TMobilePhoneAlternatingCallMode iSetAlternatingCallModeMode;

   247 	RMobilePhone::TMobileService iSetAlternatingCallModeService;

   248 	RMobilePhone::TMobilePhoneALSLine iSetALSLine;

   249 	TUint iSetMaxCostMeterUnits;

   250 	RMobilePhone::TMobilePhoneCostMeters iClearCostMeter;

   251 	RMobilePhone::TMobilePhoneLock iLock;

   252 	RMobilePhone::TMobilePhoneLock iSetLockSettingLock;

   253 	RMobilePhone::TMobilePhoneLockSetting iSetLockSettingSetting;

   254 	RMobilePhone::TMobilePhoneSecurityCode iVerifySecurityCodeType;

   255 	RMobilePhone::TCodeAndUnblockCode iVerifySecurityCodeData;

   256 	RMobilePhone::TMobilePhoneSecurityCode iChangeSecurityCodeType;

   257 	RMobilePhone::TMobilePhoneFdnSetting iSetFdnSetting;

   258 	TBool iIsManual;

   259 	TInt  iUserMaxBearers;

   260 	RMobilePhone::TMobilePhoneIncomingCallType iCallType;

   261 	RMobilePhone::TMobilePhoneUUSSetting iSetUUSSetting;

   262 

   263 	RMobilePhone::TMobilePhoneMultimediaSettings iMmSettings;

   264 	RMobilePhone::TUSimSelectionMode iUSimSelectionMode;

   265 	RMobilePhone::TUSimAppAction iUSimAppAction;

   266 	TInt iUSimAppIndex;

   267 	RMobilePhone::TPhoneStoreNameAndIccType iPhoneStoreNameAndIccType;

   268 	RMobilePhone::TAID iAID;

   269 	TInt iDeactivateCCBSIndex;

   270 	TInt iAcceptCCBSRecallIndex;

   271 	TInt iBarringService;

   272 	RMobilePhone::TMmsConnParams iGetMmsConfig;

   273 	RMobilePhone::TMmsConnParams iNotifyMmsConfig;

   274 	TUint8	iCompMethodIdentifier;

   275 	TUint32 iGetAPNnameIndex;

   276 	TUint32 iDeleteAPNNameIndex;

   277 	RMobilePhone::TAPNControlListServiceStatus iSetAPNControlListServiceStatus;

   278 	RMobilePhone::TMobilePhoneNotifySendSSOperation iSendSSOperation;

   279 	RMobilePhone::TMobilePhonePersonalisation iSetPersonalisationScheme;

   280 	CBufBase* iStoreNetworkBuf;

   281 	TPtr8 iStoreNetworkPtr;

   282 	RMobilePhone::TMobilePhoneIdService iSetIdService;

   283 	RMobilePhone::TMobilePhoneIdServiceSetting iSetIdServiceSetting;

   284 	RMobilePhone::TMobilePhoneIdService iNotifyIdService;

   285 	TInt iScAppIndex;

   286 	RMobilePhone::TSmartCardApplicationAction iScAppAction;

   287 	RMobilePhone::TMobilePhoneSecurityCode iGetSecurityCodeInfoType;

   288 	RMobilePhone::TAID iScAuthAID;

   289 	RMobilePhone::TAID iAuthAID;

   290 	CBufBase* iStoreWlanSIDBuf;

   291 	TPtr8 iStoreWlanSIDPtr;

   292 	};	

   293 

   294 

   295 

   296 class CMobileLinePtrHolder : public CMmPtrHolder

   297 /**

   298 Holds the TPtr8 arrays for all RMobileLine requests.

   299 

   300 @publishedPartner

   301 @released

   302 */

   303 	{

   304 public:

   305 	// The ptr holder slot numbers used by RMobileLine asynchronous requests

   306 

   307 	enum TLinePtrHolderSlots

   308 		{

   309 		ESlot1LineNotifyMobileLineStatusChange=0,

   310 		EMaxNumberLinePtrSlots

   311 		};

   312 

   313 	enum TLinePtrCHolderSlots

   314 		{

   315 		EMaxNumberLinePtrCSlots = 0

   316 		};

   317 

   318 public:

   319 	static CMobileLinePtrHolder* NewL(TInt aSizeOfPtrArray, TInt aSizeOfPtrCArray);

   320 public:

   321 	};	

   322 

   323 

   324 

   325 class CMobileCallPtrHolder : public CMmPtrHolder

   326 /**

   327 Holds the TPtr8 arrays for all RMobileCall requests.

   328 

   329 @publishedPartner

   330 @released

   331 */

   332 	{

   333 public:

   334 		// The ptr holder slot numbers used by RMobileCall asynchronous requests

   335 

   336 	enum TCallPtrHolderSlots

   337 		{

   338 		ESlot1NotifyMobileCallStatusChange = 0,

   339 		ESlot1NotifyCallEvent,

   340 		ESlot1NotifyPrivacyConfirmation,

   341 		ESlot1NotifyTrafficChannelConfirmation,

   342 		ESlot1NotifyUUSCapsChange,

   343 		ESlot1ReceiveUUI,

   344 		ESlot1ActivateCcbs,

   345 		ESlot1AnswerMultimediaCallAsVoice,

   346 		EMaxNumberCallPtrSlots

   347 		};

   348 

   349 	enum TCallPtrCHolderSlots

   350 		{

   351 		ESlot1Deflect = 0,

   352 		ESlot2Deflect,

   353 		ESlot1SetDynamicHscsdParams,

   354 		ESlot2SetDynamicHscsdParams,

   355 		ESlot1GetMobileDataCallRLPRange,

   356 		ESlot1SendUUI,

   357 		ESlot2SendUUI,

   358 		ESlot1HangupWithUUI,

   359 		ESlot1AnswerWithUUI,

   360 		ESlot1DialNoFdnCheck,

   361 		EMaxNumberCallPtrCSlots

   362 		};

   363 

   364 public:

   365 	static CMobileCallPtrHolder* NewL(TInt aSizeOfPtrArray,TInt aSizeOfPtrCArray);

   366 public:

   367 	RMobileCall::TMobileCallAiur iAiur;

   368 	TInt iRxTimeslots;

   369 	TInt iRLPVersion;

   370 	TBool iMoreUUI;

   371 	RMobileCall::TMobileCallDeflect iDeflectType;

   372 	TName iFallbackCallName;

   373 	};	

   374 

   375 

   376 

   377 class CMobileConferenceCallPtrHolder : public CMmPtrHolder

   378 /**

   379 Holds the TPtr8 arrays for all RMobileConferenceCall requests.

   380 

   381 This class is internal.

   382 

   383 @publishedPartner

   384 @released

   385 */

   386 	{

   387 public:

   388 

   389 	// The ptr holder slot numbers used by RMobileConferenceCall asynchronous requests

   390 

   391 	enum TConferenceCallPtrHolderSlots

   392 		{

   393 		ESlot1NotifyConferenceCallCapsChange = 0,

   394 		ESlot1NotifyConferenceStatusChange,

   395 		ESlot1NotifyConferenceEvent,

   396 		EMaxNumberConferenceCallPtrSlots	

   397 		};

   398 

   399 	enum TConferenceCallPtrCHolderSlots

   400 		{

   401 		EMaxNumberConferenceCallPtrCSlots

   402 		};

   403 

   404 public:

   405 	static CMobileConferenceCallPtrHolder* NewL(TInt aSizeOfPtrArray,TInt aSizeOfPtrCArray);	

   406 	};	

   407 

   408 

   409 class CSmsMessagingPtrHolder : public CMmPtrHolder

   410 /**

   411 Holds the TPtr8 arrays for all RMobileSmsMessaging requests.

   412 

   413 This class is internal.

   414 

   415 @publishedPartner

   416 @released

   417 */

   418 

   419 	{

   420 public:

   421 	// The ptr holder slot numbers used by RMobileSmsMessaging asynchronous requests

   422 

   423 	enum TSmsPtrHolderSlots

   424 		{

   425 		ESlot1NotifyReceiveModeChange = 0,

   426 		ESlot1NotifyMoSmsBearerChange,

   427 		EMaxNumberSmsPtrSlots

   428 		};

   429 

   430 	enum TSmsPtrCHolderSlots

   431 		{

   432 		ESlot1AckSmsStored = 0,

   433 		ESlot1NackSmsStored,

   434 		ESlot1GetMessageStoreInfo,

   435 		ESlot1SetReceiveMode,

   436 		ESlot1SetMoSmsBearer,

   437 		EMaxNumberSmsPtrCSlots

   438 		};

   439 

   440 public:

   441 	static CSmsMessagingPtrHolder* NewL(TInt aSizeOfPtrArray,TInt aSizeOfPtrCArray);

   442 	~CSmsMessagingPtrHolder();

   443 protected:

   444 	CSmsMessagingPtrHolder();

   445 public:

   446 	TBool iAckSmsStoredFull;

   447 	TInt iNackSmsStoredCause;

   448 	TInt iGetMessageStoreInfoIndex;

   449 	RMobileSmsMessaging::TMobileSmsReceiveMode iReceiveMode;

   450 	RMobileSmsMessaging::TMobileSmsBearer iSmsBearer;

   451 	CBufBase* iSmspBuf;

   452 	TPtr8 iSmspPtr;

   453 	};	

   454 

   455 

   456 

   457 class CCbsMessagingPtrHolder : public CMmPtrHolder

   458 /**

   459 Holds the TPtr8 arrays for all RMobileBroadcastMessaging requests.

   460 

   461 @publishedPartner

   462 @released

   463 */

   464 	{

   465 public:

   466 

   467 	// The ptr holder slot numbers used by RMobileBroadcastMessaging asynchronous requests

   468 

   469 	enum TBroadcastPtrHolderSlots

   470 		{

   471 		ESlot1NotifyFilterSettingChange=0,

   472 		ESlot1StoreCbmiList,

   473 		EMaxNumberBroadcastPtrSlots

   474 		};

   475 

   476 	enum TBroadcastPtrCHolderSlots

   477 		{

   478 		ESlot1SetFilterSetting=0,

   479 		ESlot1StoreBroadcastIdListL,

   480 		EMaxNumberBroadcastPtrCSlots	

   481 		};

   482 

   483 public:

   484 	static CCbsMessagingPtrHolder* NewL(TInt aSizeOfPtrArray,TInt aSizeOfPtrCArray);

   485 	~CCbsMessagingPtrHolder();

   486 protected:

   487 	CCbsMessagingPtrHolder();

   488 public:

   489 	RMobileBroadcastMessaging::TMobilePhoneBroadcastFilter iSetFilterSetting;

   490 	RMobileBroadcastMessaging::TMobileBroadcastIdType iIdType;

   491 	CBufBase* iBroadcastIdBuf;

   492 	TPtr8 iBroadcastIdPtr;

   493 	};	

   494 

   495 class CUssdMessagingPtrHolder : public CMmPtrHolder

   496 /**

   497 @publishedPartner

   498 @released

   499 */

   500 	{

   501 public:

   502 

   503 	// The ptr holder slot numbers used by RMobileUssdMessaging asynchronous requests

   504 

   505 	enum TUssdPtrHolderSlots

   506 		{

   507 		EMaxNumberUssdPtrSlots=0,

   508 		};

   509 

   510 	enum TUssdPtrCHolderSlots

   511 		{

   512 		EMaxNumberUssdPtrCSlots=0

   513 		};

   514 

   515 public:

   516 	~CUssdMessagingPtrHolder();

   517 protected:

   518 	CUssdMessagingPtrHolder();

   519 public:

   520 	};	

   521 

   522 

   523 class CMobilePhoneStorePtrHolder : public CMmPtrHolder

   524 /** 

   525 A base class PtrHolder used by all classes which inherit from RMobilePhoneStore. 

   526 

   527 Holds the TPtr8 arrays for all RMobilePhoneStore requests.

   528 

   529 Each class derived from RMobilePhoneStore can create its own

   530 PtrHolder class derived from CMobilePhoneStorePtrHolder.  RMobilePhoneStore derived

   531 classes construct the appropriate PtrHolder class which is passed down to 

   532 RMobilePhoneStore via the RMobilePhoneStore::BaseConstruct method.  Both methods of 

   533 RMobilePhoneStore and a derived class must share the same PtrHolder.  It follows that

   534 they must cooperate to ensure that methods in the base and derived classes do not

   535 use the same slots.  The derived classes should use the slots that are equal to or

   536 greater than EMaxNumberPhoneStorePtrSlots & EMaxNumberPhoneStorePtrCSlots.

   537 

   538 

   539 @publishedPartner

   540 @released

   541 */

   542 	{

   543 public:

   544 	

   545 	// The ptr holder slot numbers used by RMobilePhoneStore asynchronous requests

   546 

   547 /** This member is internal. */

   548 	enum TPhoneStorePtrHolderSlots

   549 		{

   550 	/** This member is internal. */

   551 		ESlot1NotifyStoreEvent = 0,

   552 	/** This member is internal. */

   553 		ESlot2NotifyStoreEvent,

   554 	/** This member is internal. */

   555 		EMaxNumberPhoneStorePtrSlots

   556 		};

   557 

   558 /** This member is internal. */

   559 	enum TPhoneStorePtrCHolderSlots

   560 		{

   561 	/** This member is internal. */

   562 		ESlot1Delete = 0,

   563 	/** This member is internal. */

   564 		EMaxNumberPhoneStorePtrCSlots

   565 		};

   566 

   567 public:

   568 	static CMobilePhoneStorePtrHolder* NewL(TInt aSizeOfPtrArray,TInt aSizeOfPtrCArray);

   569 public:

   570 	TInt iDeleteIndex;

   571 	};	

   572 

   573 

   574 

   575 class CSmsStorePtrHolder : public CMobilePhoneStorePtrHolder

   576 /**

   577 Holds the TPtr8 arrays for all RMobileSmsStore requests.

   578 

   579 This class is internal.

   580 

   581 @publishedPartner

   582 @released

   583 */

   584 	{

   585 public:

   586 

   587 	// The ptr holder slot numbers used by RMobileSmsStore asynchronous requests

   588 

   589 	enum TSmsStorePtrHolderSlots

   590 		{

   591 		EMaxNumberSmsStorePtrSlots = EMaxNumberPhoneStorePtrSlots

   592 		};

   593 

   594 	enum TSmsStorePtrCHolderSlots

   595 		{

   596 		ESlot1GetStatusReport = EMaxNumberPhoneStorePtrCSlots,

   597 		EMaxNumberSmsStorePtrCSlots

   598 		};

   599 

   600 public:

   601 	static CSmsStorePtrHolder* NewL(TInt aSizeOfPtrArray,TInt aSizeOfPtrCArray);

   602 public:

   603 	TInt iGetStatusReportIndex;

   604 	};	

   605 

   606 

   607 

   608 class CNamStorePtrHolder : public CMobilePhoneStorePtrHolder

   609 /**

   610 Holds the TPtr8 arrays for all RMobileNamStore requests.

   611 

   612 This class is internal.

   613 

   614 @publishedPartner

   615 @released

   616 @deprecated 9.5

   617 */

   618 	{

   619 public:

   620 

   621 	// The ptr holder slot numbers used by RMobileNamStore asynchronous requests

   622 

   623 	enum TNamStorePtrHolderSlots

   624 		{

   625 		EMaxNumberNamStorePtrSlots = EMaxNumberPhoneStorePtrSlots

   626 		};

   627 

   628 	enum TNamStorePtrCHolderSlots

   629 		{

   630 		ESlot1SetActiveNam = EMaxNumberPhoneStorePtrCSlots,

   631 		ESlot1NamListStoreAll,

   632 		ESlot1NamListStoreAllV4,

   633 		EMaxNumberNamStorePtrCSlots

   634 		};

   635 

   636 public:

   637 	static CNamStorePtrHolder* NewL(TInt aSizeOfPtrArray,TInt aSizeOfPtrCArray);

   638 	~CNamStorePtrHolder();

   639 protected:

   640 	CNamStorePtrHolder();

   641 public:

   642 	CBufBase* iNamBuf;

   643 	CBufBase* iNamBufV4;

   644 	TPtr8 iNamPtr;

   645 	TPtr8 iNamPtrV4;

   646 	TInt iSetActiveNamNamId;

   647 	TInt iStoreAllNamId;

   648 	TInt iStoreAllV4NamId;

   649 	};	

   650 

   651 

   652 

   653 class CONStorePtrHolder : public CMobilePhoneStorePtrHolder

   654 /**

   655 Holds the TPtr8 arrays for all RMobileONStore requests.

   656 

   657 This class is internal.

   658 

   659 @publishedPartner

   660 @released

   661 */

   662 	{

   663 public:

   664 

   665 	// The ptr holder slot numbers used by RMobileOnStore asynchronous requests

   666 

   667 	enum TOnStorePtrHolderSlots

   668 		{

   669 		EMaxNumberONStorePtrSlots = EMaxNumberPhoneStorePtrSlots

   670 		};

   671 

   672 	enum TOnStorePtrCHolderSlots

   673 		{

   674 		EMaxNumberONStorePtrCSlots = EMaxNumberPhoneStorePtrCSlots

   675 		};

   676 

   677 public:

   678 	static CONStorePtrHolder* NewL(TInt aSizeOfPtrArray,TInt aSizeOfPtrCArray);

   679 	~CONStorePtrHolder();

   680 protected:

   681 	CONStorePtrHolder();

   682 public:

   683 	CBufBase* iONBuf;

   684 	TPtr8 iONPtr;

   685 	};	

   686 

   687 

   688 

   689 class CPhoneBookStorePtrHolder : public CMobilePhoneStorePtrHolder

   690 /**

   691 Holds the TPtr8 arrays for all RMobilePhonebookStore requests.

   692 

   693 This class is internal.

   694 

   695 @publishedPartner

   696 @released

   697 */

   698 	{

   699 public:

   700 

   701 	// The ptr holder slot numbers used by RMobilePhonebookStore asynchronous requests

   702 

   703 	enum TPhoneBookStorePtrHolderSlots

   704 		{

   705 		ESlot1PhoneBookStoreWrite = EMaxNumberPhoneStorePtrSlots,

   706 		EMaxNumberPhoneBookStorePtrSlots

   707 		};

   708 

   709 	enum TPhoneBookStorePtrCHolderSlots

   710 		{

   711 		ESlot1PhoneBookStoreRead = EMaxNumberPhoneStorePtrCSlots,

   712 		EMaxNumberPhoneBookStorePtrCSlots 

   713 		};

   714 

   715 public:

   716 	static CPhoneBookStorePtrHolder* NewL(TInt aSizeOfPtrArray,TInt aSizeOfPtrCArray);

   717 public:

   718 	RMobilePhoneBookStore::TPBIndexAndNumEntries iReadPhoneBookEntry;

   719 	};	

   720 

   721 /**

   722 Holds the TPtr8 arrays for all RMobileSmartCardEap requests

   723 

   724 This class is internal.

   725 

   726 @internalComponent

   727 @prototype

   728 */

   729 class CMobileSmartCardEapPtrHolder : public CMmPtrHolder

   730 	{

   731 public:

   732 	enum TSmartCardEapPtrHolderSlots

   733 		{

   734 		ESlot1GetAuthStatus,            // 0

   735 		ESlot1NotifyEapMethodAccess,    // 1

   736 		EMaxNumberSmartCardEapPtrSlots  // 2

   737 		};

   738 

   739 	enum TSmartCardEapPtrCHolderSlots

   740 		{

   741 		ESlot1InitialiseEapMethod,      // 0

   742 		ESlot1GetUserId,                // 1

   743 		ESlot1GetEapKey,                // 2

   744 		EMaxNumberSmartCardEapPtrCSlots // 3

   745 		};

   746 

   747 public:

   748 	static CMobileSmartCardEapPtrHolder* NewL(TInt aSizeOfPtrArray, TInt aSizeOfPtrCArray);

   749 	~CMobileSmartCardEapPtrHolder();

   750 

   751 protected:

   752 	CMobileSmartCardEapPtrHolder();

   753 

   754 public:

   755 	TThreadId iOwnerThreadId;

   756 	RMobileSmartCardEap::TEapUserIdType iEapUserIdType;

   757 	RMobileSmartCardEap::TEapKeyTag iReqEapKeyTag;

   758 	TPtr8 iReqAuthData;

   759 	};

   760 

   761 

   762 

   763 class CMobileLocationServicesPtrHolder : public CMmPtrHolder

   764 /**

   765 Holds the TPtr8 arrays for all RMobileLocationServices requests.

   766 

   767 This class is internal.

   768 

   769 @internalAll

   770 */

   771 	{

   772 public:

   773 

   774 	// The ptr holder slot numbers used by RMobileLocationServices asynchronous requests

   775 

   776 	enum TLocationServicesPtrHolderSlots

   777 		{

   778 		ESlot1LcsNotifyUeResetPositioningInformation,

   779 		EMaxNumberLocationServicesPtrSlots	

   780 		};

   781 

   782 	enum TLocationServicesPtrCHolderSlots

   783 		{

   784 		ESlot1LcsSendMtlrResponse,

   785 		ESlot1LcsSendMtlrError,

   786 		ESlot1LcsMtlrReject,

   787 		ESlot1LcsSendMeasurementControlFailure,

   788 		EMaxNumberLocationServicesPtrCSlots

   789 		};

   790 

   791 public:

   792 	static CMobileLocationServicesPtrHolder* NewL(TInt aSizeOfPtrArray,TInt aSizeOfPtrCArray);	

   793 	};	

   794 

   795 #endif // _MM_HOLD_H_