# HG changeset patch
# User Tom Pritchard <tomp@symbian.org>
# Date 1281615601 -3600
# Node ID ab1d0f4d2aa42d2408a20bc0ffe903321468aa7b
# Parent  4a8d14a1a8ca785fb3042d94cb2e00e0b02ad5dd
Adding the "WishList" state Telephony APIs

diff -r 4a8d14a1a8ca -r ab1d0f4d2aa4 Telephony/basebandabstraction/basebandchanneladaptor/inc/bca2.h
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Telephony/basebandabstraction/basebandchanneladaptor/inc/bca2.h	Thu Aug 12 13:20:01 2010 +0100
@@ -0,0 +1,328 @@
+
+/**
+* Copyright (c) 2005-2009 Nokia Corporation and/or its subsidiary(-ies).
+* All rights reserved.
+* This component and the accompanying materials are made available
+* under the terms of "Eclipse Public License v1.0"
+* which accompanies this distribution, and is available
+* at the URL "http://www.eclipse.org/legal/epl-v10.html".
+*
+* Initial Contributors:
+* Nokia Corporation - initial contribution.
+*
+* Contributors:
+*
+* Description:
+* Baseband Channel Adaptor(BCA) APIs.
+* This file contains all the APIs required to implement a BCA interface for Symbian OS.
+* 
+*
+*/
+
+
+
+/**
+ @file
+ @publishedPartner
+ @prototype
+ @released
+*/
+#ifndef BCA2_H
+#define BCA2_H
+
+/** This namespace includes the BCA component names.*/
+namespace BasebandChannelAdaptation2
+{
+/**
+ * The class implemented by an upper component to accept control signals from the lower component
+
+ * @publishedPartner
+ * @prototype
+ */
+class MUpperControl
+	{
+public:
+	/**
+	* Indicates to the layer above (link layer) that the Bca is ready to start 
+	* receiving packets from the upper layer (either after MBca start 
+	* completes or following congestion)
+	
+	* @param none
+	* @return none.
+	*/
+	virtual void StartSending()=0;
+	
+	/**
+	* Any fatal error which occurs during the send/receive session is reported 
+	* to the client by a call to this function. Fatal errors are errors which can’t 
+	* be recovered from (e.g.:  connection down) in which case MBca has become 
+	* defunct and can no longer be used to send and receive data
+	
+	* @param aErr TThe fatal error code from the session failures propagated 
+	* to the upper layer of the communications stack . Non fatal errors keep 
+	* the MBca2 functional which in the context of MBca2 implementation may 
+	* include KErrNoMemory, KErrCommsParity, KErrCommsOverrun, KErrCommsFrame. 
+	* @return none.
+	*/
+	virtual void Error(TInt aErr)=0;
+
+	};
+	
+/**
+ * The Class implemented by an upper component to accept inbound data travelling 
+ * upwards from the lower component
+
+ * @publishedPartner
+ * @prototype
+ */ 	
+class MUpperDataReceiver
+	{
+public:
+	/**
+	* This function is called whenever data has been received by MBca which 
+	* should be processed by its client. The implementer takes ownership of the 
+	* buffer and is responsible for its deletion.
+	
+	* @param aCommsBufChain - The list of comms buffers containing data to be processed. 
+         * Destination keeps the custody of the buffer.
+	* @return none.
+	*/
+	virtual void Process(RCommsBufChain& aCommsBufChain)=0;
+	};
+
+/**
+ * The interface implemented by the lower component to accept data from the upper component
+
+ * @publishedPartner
+ * @prototype
+ */
+ 	
+class MLowerDataSender
+	{
+	public:
+	enum TSendResult
+		{
+			// data accepted, send no more until MUpperControl::StartSending() is called
+			ESendBlocked,
+			// data accepted, can send more.
+			ESendAccepted
+		};
+	/**
+	* Sends the specified buffer data down to the base-band. The implementer takes 
+	* ownership of the buffer and is responsible for its deletion.
+	
+	* @param aCommsBufChain the comms buffer list to be sent.The buffer ownership is passed 
+	* to the BCA
+	* @return TTSendResult either ESendBlocked or SendAccepted. When the Bca 
+	* is congested and cannot send any data beyond the current packet (which is 
+	* always accepted), the implementation returns ESendBlocked. If BCA is not
+	* congested then ESendAccepted is returned to continue sending. When congestion 
+	* passes, the Bca calls StartSending on the upper layer to resume sending. The
+	* implementation is recommended to panic any attempts to call Send during congestion 
+	*/
+	virtual	TSendResult Send(RCommsBufChain& aCommsBufChain)=0;
+	};
+
+/**
+ * The interface implemented by the lower component to accept control signals from the upper component
+ 
+ * @publishedPartner
+ * @prototype
+ */ 
+class MBca2
+	{
+public:
+	 struct TBcaParams 
+		{
+		RCommsBufPond iCommsBufPond;	// Pond to be used by BCA implementation for creating, using pools and buffers
+		const TDesC& iChannelId;				// port number or channel which BCA uses to communicate with its lower layers 
+		TBcaParams(RCommsBufPond aCommsBufPond,const TDesC& aChannelId)
+		: iCommsBufPond(aCommsBufPond),
+		iChannelId(aChannelId){}
+	 	};
+
+		
+	/**
+	* Opens the BCA instance and commences a BCA session (::Close() terminates the session). 
+	
+	* @param aControl reference to a MUpperControl implementation, which will 
+	* serve as the call-back interface for incoming control calls
+	* @param aData - reference to a MUpperDataReceiver implementation, which
+	* will serve as the call-back interface for incoming data
+	* @param aBcaParams A reference to the BCA start up params
+	* @return KErrNone if successful, system-wide error code otherwise. All 
+	* other error codes reported are fatal denoting that MBca interface has 
+	* failed to open and MBca is not good for transferring data
+	*/
+	virtual TInt Open(MUpperControl& aControl, 
+					MUpperDataReceiver& aData, 
+					const TBcaParams& aBcaParams)=0;
+	
+	/**
+	 * The API starts the baseband connection asynchronously. The Start () request 
+	 * API’s successful completion is acknowledged with MUpperControl::StartSending(). 
+	 * The request failure is acknowledged with MUpperControl::Error(). Client should 
+	 * take care of scenarios when MUpperControl::StartSending() gets very delayed 
+	 * or not called at all
+ 	
+	* @param none
+	* @return none
+	*/
+	virtual void Start()=0;
+	
+	/**
+	 * Returns a reference to the MLowerDataSender, This reference is used by 
+	 * upper components to send packets to the lower components. This API must be 
+	 * called only after Start() completes, otherwise the implementation should panic.
+ 	
+	* @param none
+	* @return reference to the MLowerDataSender. 
+	*/
+	virtual MLowerDataSender& GetSender()=0;
+	
+	/**
+	* Synchronously closes the BCA immediately. Informs the BCA is no longer 
+	* required by the client and can release its resources. Close cancels all 
+	* pending asynchronous operations which can only be ::Start() or ::Control() .
+	* To use the BCA instance it needs to be re-opened. Close operation must not fail.
+	
+	* @param none
+	* @return none.
+	*/
+	virtual void Close()=0;
+	
+	/**
+	* Release/deletes the BCA instance. Derived classes will typically implement 
+	* this as ‘delete this’.
+	
+	* @param none
+	* @return none.
+	*/
+	virtual void Release()=0;
+	
+	enum TBlockOption
+		{
+			//stop sending [block] data on interface
+			EBlockFlow, 
+			// start sending [unblock] data on interface
+			EUnblockFlow
+		};
+	/**
+	* Either blocks or unblocks the pushing of received data to the upper layers, 
+	* depending on TBlockOption. If the upper layers can’t process any more
+	* data to stop receiving packets this API is called with EBlockFlow. 
+	* Later after the congestion eases, to start receiving packets again call 
+	* this API with EUnblockFlow
+	
+	* @param aOption either block or unblock receive flow
+	* @return none.
+	*/
+	virtual void SetFlowControl(TBlockOption aOption)=0;
+
+	/**
+	* The BCA control function to get or set the options of the BCA in an 
+	* asynchronous manner.
+	
+	* @param aStatus  asynchronous completion status, KErrNone if successful, 
+         * system-wide error code otherwise
+	* @param aOptLevel option level to be used KBcaOptLevelGeneric 
+	* or KBcaOptLevelExtSerial
+	* @param aOptName option name to be used.
+	* @param aOpt an optional parameter,holds the option value on return or the
+	* option value to be set.
+	* @return none.
+	*/
+	virtual void Control(TRequestStatus& aStatus,
+							TUint aOptLevel,
+							TUint aOptName,
+							TDes8& aOpt)=0;
+
+	/**
+	* Cancels the Control request in a synchronous way.
+	
+	* @param none
+	* @return none.
+	*/
+	virtual void CancelControl()=0;
+	};
+
+/**
+* Control option level.
+*/
+const TUint KBcaOptLevelGeneric 		= 0x0194;
+const TUint KBcaOptLevelExtSerial 		= 0x0195;
+
+/**
+* C32 BCA capability
+*/
+const TUint KBcaCapSerial			= 0x01; //Serial port capability supported
+
+/**
+* Generic Control option name
+*/
+const TUint KBCAMru	                = 0x12;
+const TUint KBCAMtu	                = 0x13;
+const TUint KBCASpeedMetric	        = 0x14;
+const TUint KBCACaps	            = 0x15;
+const TUint KBCASetIapId	        = 0x16;
+const TUint KBCASetBcaStack	        = 0x1e;
+const TUint KVersionNumber	        = 0x1c;
+/** 
+Purges the buffers */
+const TUint KBCAResetBuffers        = 0x1f;
+
+/**
+* Serial Control option name
+*/
+const TUint KSerialCaps	            = 0x17;
+const TUint KSerialConfig	        = 0x18;
+const TUint KSerialSetConfig	    = 0x1a;
+const TUint KSerialPortName	        = 0x19;
+const TUint KSerialSetCsyName	    = 0x1b;
+const TUint KSerialSetCommRole	    = 0x1d;
+
+/**
+Set the size of receive & transmit buffers.
+Provided for compatibility with C32 RComm */
+const TUint KSerialSetTxRxBufferSize  = 0x2a;
+
+/** Retrieves the size of the receive & transmit buffers */
+const TUint KSerialTxRxBufferSize     = 0x2b;
+
+/** Set and/or clear signal lines */
+const TUint KSerialSetControlLines	  = 0x2c;
+
+struct TSerialSetControlLines {
+/**
+Structure associated with KSerialSetSignals control.
+Indicates which control lines to set/clear. 
+*/
+	TUint	iSetMask;
+	TUint	iClearMask;
+};
+
+//
+// Bitmasks specifying which buffer to reset. Used with KBCaResetBuffers
+//
+
+/** Reset Rx buffer only */
+const TUint KResetRxBuf = 0x01;
+
+/** Reset Tx buffer only */
+const TUint KResetTxBuf = 0x02;
+
+
+/** Monitor EIA-232 control lines and take action specified. */
+const TUint KSerialMonitorControlLines = 0x30;
+
+/** Turn control line monitoring off - do not fail on line change */
+const TUint KMonitorOff = 0x0;
+
+/** Fail when BCA-specific lines go from high to low. 
+This is the "Default" option, where the BCA itself selects what lines to monitor 
+This mask must not be specified in conjunction with other masks, as the BCA will monitor
+& fail on its specific lines ONLY. The other lines will be ignored.*/
+const TUint KFailBcaSpecificOnly = 0xFFFFFFFF; 
+}
+
+#endif // BCA2_H
diff -r 4a8d14a1a8ca -r ab1d0f4d2aa4 Telephony/ctsydispatchlayer/exportinc/cctsydispatchercallback.h
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Telephony/ctsydispatchlayer/exportinc/cctsydispatchercallback.h	Thu Aug 12 13:20:01 2010 +0100
@@ -0,0 +1,611 @@
+// Copyright (c) 2008-2009 Nokia Corporation and/or its subsidiary(-ies).
+// All rights reserved.
+// This component and the accompanying materials are made available
+// under the terms of "Eclipse Public License v1.0"
+// which accompanies this distribution, and is available
+// at the URL "http://www.eclipse.org/legal/epl-v10.html".
+//
+// Initial Contributors:
+// Nokia Corporation - initial contribution.
+//
+// Contributors:
+//
+// Description:
+//
+
+/**
+ @file
+ @internalAll 
+*/
+
+#ifndef CCTSYDISPATCHERCALLBACK_H
+#define CCTSYDISPATCHERCALLBACK_H
+
+// INCLUDES
+#include <ctsy/serviceapi/cmmutility.h>
+#include <ctsy/serviceapi/mmtsy_ipcdefs.h>
+#include <e32base.h>
+#include <e32std.h>
+#include <etelmm.h>
+#include <etelsat.h>
+#include <ctsy/ltsy/mltsydispatchinterface.h>
+#include <ctsy/ltsy/mltsydispatchphonebookinterface.h>
+#include <ctsy/ltsy/mltsydispatchsatinterface.h>
+#include <ctsy/ltsy/mltsydispatchsmsinterface.h>
+#include <ctsy/ltsy/mltsydispatchcellbroadcastinterface.h>
+#include <ctsy/ltsy/mltsydispatchsiminterface.h>
+
+#include <mmlist.h>
+#include <ctsy/rmmcustomapi.h>
+
+
+
+// FORWARD DECLARATIONS
+class TDispatcherHolder;
+
+/**
+ * These are the IDs used to identify the callback indicators APIs
+ * offered through CCtsyDispatcherCallback. There is one for each callback indicator API.
+ *
+ * The indicators are used as part of a MLtsyDispatchFactoryV1::IsCallbackIndicatorSupported
+ * implementation to indicate whether the baseband supports indication.
+ *
+ * Each Id is identified by its funcitonal unit and group.  All Ids are contained within an enum whose name ends
+ * with a group number e.g.  TLtsyDispatchCallControlCallbackIndicatorIds_Group1.
+ *
+ * When there is a need to identify >32 IDs for a functional unit a new group enum
+ * must be created e.g.  TLtsyDispatchCallControlCallbackIndicatorIds_Group2
+ *
+ * @see MLtsyDispatchFactoryV1::IsCallbackIndicatorSupported()
+ */
+
+/**
+ * Call Control callback indicator IDs
+ */
+enum TLtsyDispatchCallControlCallbackIndicatorIds_Group1
+  {
+  KLtsyDispatchCallControlNotifyCallStatusChangeIndId = 1,
+  KLtsyDispatchCallControlReceiveUuiIndId = 2,
+  KLtsyDispatchCallControlNotifyDataCallCapsChangeIndId = 4,
+  KLtsyDispatchCallControlNotifyIncomingCallIndId = 8,
+  KLtsyDispatchCallControlNotifyHscsdInfoChangeIndId = 16,
+  KLtsyDispatchCallControlNotifyCallEventIndId = 32,
+  KLtsyDispatchCallControlGetCallInfoIndId = 64,
+  KLtsyDispatchCallControlNotifyIccCallForwardingStatusChangeIndId = 128
+  										// = 256
+  };
+
+/**
+ * Call Control Multiparty callback indicator IDs
+ */
+enum TLtsyDispatchCallControlMultipartyCallbackIndicatorIds_Group1
+  {
+  // = 1 Put multiparty indicator IDs here if some are added. Follow naming convention.
+  // = 2
+  // = 4
+  };
+
+/**
+ * Cell Broadcast callback indicator IDs
+ */
+enum TLtsyDispatchCellBroadcastCallbackIndicatorIds_Group1
+  {
+  KLtsyDispatchCellBroadcastGsmBroadcastNotifyMessageReceivedIndId = 1,
+  KLtsyDispatchCellBroadcastWcdmaBroadcastMessageReceivedIndId = 2,
+  };
+
+/**
+ * Packet Services callback indicator IDs
+ */
+enum TLtsyDispatchPacketServicesCallbackIndicatorIds_Group1
+  {
+  KLtsyDispatchPacketServicesNotifyPacketAttachModeChangeIndId = 1,
+  KLtsyDispatchPacketServicesNotifyQosProfileChangedIndId = 2,
+  KLtsyDispatchPacketServicesNotifyRatTransferCapsChangeIndId = 4,
+  KLtsyDispatchPacketServicesNotifyPacketMsClassChangeIndId = 8,
+  KLtsyDispatchPacketServicesNotifyPacketDynamicCapsChangeIndId = 16,
+  KLtsyDispatchPacketServicesNotifyPdpContextAddedIndId = 32,
+  KLtsyDispatchPacketServicesNotifyNetworkInitiatedContextActivationRequestIndId = 64,
+  KLtsyDispatchPacketServicesNotifyPdpContextConfigChangedIndId = 128,
+  KLtsyDispatchPacketServicesNotifyPdpContextStatusChangeIndId = 256,
+  KLtsyDispatchPacketServicesNotifyPacketNetworkRegistrationStatusIndId = 512,
+  KLtsyDispatchPacketServicesNotifyMbmsContextConfigChangedIndId = 1024,
+  KLtsyDispatchPacketServicesNotifyMbmsNetworkServiceStatusChangeIndId = 2048,
+  KLtsyDispatchPacketServicesNotifyMbmsServiceAvailabilityChangeIndId = 4096
+  };
+
+
+/**
+ * Phonebook callback indicator IDs
+ */
+enum TLtsyDispatchPhonebookCallbackIndicatorIds_Group1
+  {
+  KLtsyDispatchPhonebookStoreResetCacheIndId = 1,
+  KLtsyDispatchPhonebookStoreGetFdnInfoIndId = 2
+  };
+
+/**
+ * Phonebook ON callback indicator IDs
+ */
+enum TLtsyDispatchPhonebookONCallbackIndicatorIds_Group1
+  {
+  KLtsyDispatchPhonebookOnStoreReadAllIndId = 1,
+  KLtsyDispatchPhonebookOnStoreWriteAllIndId = 2
+  };
+
+/**
+ * Phone callback indicator IDs
+ */
+enum TLtsyDispatchPhoneCallbackIndicatorIds_Group1
+  {
+  KLtsyDispatchPhoneNotifyNetworkModeChangeIndId = 1,
+  KLtsyDispatchPhoneNotifyEgprsInfoChangeIndId = 2,
+  KLtsyDispatchPhoneNotifySignalStrengthChangeIndId = 4,
+  KLtsyDispatchPhoneNotifyNetworkRegistrationStatusChangeIndId = 8,
+  KLtsyDispatchPhoneNotifyNitzInfoChangeIndId = 16,
+  KLtsyDispatchPhoneNotifyBatteryInfoChangeIndId = 32,
+  KLtsyDispatchPhoneNotifyCurrentNetworkChangeIndId = 64,
+  KLtsyDispatchPhoneNotifyRfStatusChangeIndId = 128,
+  KLtsyDispatchPhoneNotifyCellInfoChangeIndId = 256
+  };
+
+/**
+ * SAT callback indicator IDs
+ */
+enum TLtsyDispatchSatCallbackIndicatorIds_Group1
+  {
+  KLtsyDispatchSatUssdStatusIndId = 1,
+  KLtsyDispatchSatNotifyCallControlRequestIndId = 2,
+  KLtsyDispatchSatPcmdIndId = 4,
+  KLtsyDispatchSatNotifyProactiveSimSessionEndIndId = 8,
+  KLtsyDispatchSatNotifyLocalInfoIndId = 16,
+  KLtsyDispatchSatTimeZoneIndId = 32,
+  KLtsyDispatchSatAccessTechnologyChangeIndId = 64,
+  KLtsyDispatchSatSetProactiveCommandOnGoingStatusIndId = 128,
+  KLtsyDispatchSatCallConnectedIndId = 256,
+  KLtsyDispatchSatSsStatusIndId = 512,
+  KLtsyDispatchSatCallDisconnectedIndId = 1024,
+  KLtsyDispatchSatMtCallIndId = 2048,
+  KLtsyDispatchSatCheckAtkDataForAlphaIdIndId = 4096,
+  KLtsyDispatchSatCreateEnvelopeIndId = 8192,
+  KLtsyDispatchSatSmControlEnvelopeIndId = 16384,
+  KLtsyDispatchSatImsiChangedIndId = 32768,
+  KLtsyDispatchSatLocationStatusIndId = 65536,
+  KLtsyDispatchSatRemoveEventListIndId = 131072,
+  KLtsyDispatchSatRefreshIndId = 262144,
+  KLtsyDispatchSatSmControlResponseIndId = 524288,
+  };
+
+/**
+ * Security callback indicator IDs
+ */
+enum TLtsyDispatchSecurityCallbackIndicatorIds_Group1
+  {
+  KLtsyDispatchSecurityBootNotifySecurityReadyIndId = 1,
+  KLtsyDispatchSecurityNotifySecurityEventIndId = 2,
+  KLtsyDispatchSecurityNotifyLockInfoChangeIndId = 4
+  };
+
+/**
+ * SIM callback indicator IDs
+ */
+enum TLtsyDispatchSimCallbackIndicatorIds_Group1
+  {
+  KLtsyDispatchSimRefreshSimFilesIndId = 1,
+  KLtsyDispatchSimNotifyIccMessageWaitingIndicatorsChangeIndId = 2,
+  KLtsyDispatchSimNotifyApnListChangeIndId = 4,
+  KLtsyDispatchSimNotifyApnControlListServiceStatusChangeIndId = 8,
+  KLtsyDispatchSimGetActiveIccApplicationTypeIndId = 16,
+  };
+
+/**
+ * Sms callback indicator IDs
+ */
+enum TLtsyDispatchSmsCallbackIndicatorIds_Group1
+  {
+  KLtsyDispatchSmsNotifyReceiveSmsMessageIndId = 1
+  };
+
+/**
+ * Supplementary Services callback indicator IDs
+ */
+enum TLtsyDispatchSupplementaryServicesCallbackIndicatorIds_Group1
+  {
+  KLtsyDispatchSupplementaryServicesNotifyCallBarringStatusChangeIndId = 1,
+  KLtsyDispatchSupplementaryServicesReceiveUssdMessageIndId = 2,
+  KLtsyDispatchSupplementaryServicesNotifyCallWaitingStatusChangeIndId = 4,
+  KLtsyDispatchSupplementaryServicesNotifyCallForwardingStatusChangeIndId = 8,
+  KLtsyDispatchSupplementaryServicesNotifyCallForwardingActiveIndId = 16,
+  KLtsyDispatchSupplementaryServicesNotifySendNetworkServiceRequestIndId = 32
+  };
+
+// CLASS DECLARATION
+
+/**
+ * CCtsyDispatcherCallback
+ *
+ * This class is responsible for receiving completions from the Licensee LTSY and
+ * forwarding them onto the relevant dispatcher object in the CTSY Dispatcher which
+ * will handle the completion.
+ */
+class CCtsyDispatcherCallback : public CBase
+	{
+public:
+
+	virtual ~CCtsyDispatcherCallback();
+	static CCtsyDispatcherCallback* NewL();
+	static CCtsyDispatcherCallback* NewLC();
+
+	// Callback functions called by the Licensee LTSY to complete a request Callback<something>Comp()
+	// or to send an unsolicited completion Callback<something>Ind().
+
+	// CallControl related callbacks
+	IMPORT_C void CallbackCallControlNotifyCallStatusChangeInd(TInt aError, TInt aCallId, RMobileCall::TMobileCallStatus aMobileCallStatus);
+	IMPORT_C void CallbackCallControlReceiveUuiInd(TInt aError, TInt aCallId, const TDesC& aCallUui);
+	IMPORT_C void CallbackCallControlNotifyDataCallCapsChangeInd(TInt aError, TInt aCallId, const RMobileCall::TMobileCallDataCapsV1& aMobileCallDataCaps);
+	IMPORT_C void CallbackCallControlNotifyIncomingCallInd(TInt aError, const RMobileCall::TMobileCallInfoV1& aCallInfo);
+	IMPORT_C void CallbackCallControlNotifyHscsdInfoChangeInd(TInt aError, TInt aCallId, const RMobileCall::TMobileCallHscsdInfoV8& aCallParams, const RMobileCall::TMobileCallDataCapsV1& aCallCaps);
+	IMPORT_C void CallbackCallControlNotifyCallEventInd(TInt aError, TInt aCallId, RMobileCall::TMobileCallEvent aCallEvent);
+	IMPORT_C void CallbackCallControlNotifyCallInfoChangeInd(TInt aError, const RMobileCall::TMobileCallInfoV1& aMobileCallInfo);
+    IMPORT_C void CallbackCallControlRemoteAlertingToneChangeInd(TInt aError, RMmCustomAPI::TRemoteAlertingToneStatus aRemoteAlertingTone);
+	IMPORT_C void CallbackCallControlAnswerComp(TInt aError, TInt aCallId);
+	IMPORT_C void CallbackCallControlHoldComp(TInt aError, TInt aCallId);
+	IMPORT_C void CallbackCallControlDialEmergencyComp(TInt aError, TInt aCallId);
+	IMPORT_C void CallbackCallControlStopDtmfToneComp(TInt aError);
+	IMPORT_C void CallbackCallControlSetActiveAlsLineComp(TInt aError);
+	IMPORT_C void CallbackCallControlSendDtmfTonesCancelComp(TInt aError);
+	IMPORT_C void CallbackCallControlHangUpComp(TInt aError, TInt aCallId);
+	IMPORT_C void CallbackCallControlResumeComp(TInt aError, TInt aCallId);
+	IMPORT_C void CallbackCallControlSetDynamicHscsdParamsComp(TInt aError, TInt aCallId);
+	IMPORT_C void CallbackCallControlDialVoiceComp(TInt aError, TInt aCallId);
+	IMPORT_C void CallbackCallControlTransferComp(TInt aError);
+	IMPORT_C void CallbackCallControlSendDtmfTonesComp(TInt aError);
+	IMPORT_C void CallbackCallControlGetIdentityServiceStatusComp(TInt aError, RMobilePhone::TMobilePhoneIdServiceStatus aIdentityServiceStatus);
+	IMPORT_C void CallbackCallControlSwapComp(TInt aError);
+	IMPORT_C void CallbackCallControlStartDtmfToneComp(TInt aError);
+	IMPORT_C void CallbackCallControlGetActiveAlsLineComp(TInt aError, RMobilePhone::TMobilePhoneALSLine aAlsLine);
+	IMPORT_C void CallbackCallControlDialDataComp(TInt aError, TInt aCallId);
+	IMPORT_C void CallbackCallControlUpdateLifeTimerComp(TInt aError);
+	IMPORT_C void CallbackCallControlNotifyIccCallForwardingStatusChangeInd(TInt aError, const RMobilePhone::TMobileAddress& aCallForwardingNo,
+				 		RMobilePhone::TCFUIndicatorStatusFlags aCallForwardingStatusFlags,
+				 		RMmCustomAPI::TMultipleSubscriberProfileID aMultipleSubscriberProfileId);
+    IMPORT_C void CallbackCallControlGetAlsPpSupportComp(TInt aError, RMmCustomAPI::TAlsSupport aAlsSupport);
+    IMPORT_C void CallbackCallControlGetAlsBlockedStatusComp(TInt aError, RMmCustomAPI::TGetAlsBlockStatus aAlsStatus);
+    IMPORT_C void CallbackCallControlSetAlsBlockedComp(TInt aError);
+    IMPORT_C void CallbackCallControlGetLifeTimeComp(TInt aError);
+    IMPORT_C void CallbackCallControlGetLifeTimeComp(TInt aError, TUint32 aHours, TUint8 aMinutes);
+    IMPORT_C void CallbackCallControlGetLifeTimeComp(TInt aError, const TDateTime &aManufacturingDate);
+    IMPORT_C void CallbackCallControlGetLifeTimeComp(TInt aError, const TDateTime &aManufacturingDate, TUint32 aHours, TUint8 aMinutes);
+    IMPORT_C void CallbackCallControlTerminateErrorCallComp(TInt aError);
+    IMPORT_C void CallbackCallControlTerminateAllCallsComp(TInt aError);
+    IMPORT_C void CallbackCallControlGetCallForwardingIndicatorComp(TInt aError, RMobilePhone::TMobileTON aTypeOfNumber,
+                                                                    RMobilePhone::TMobileNPI aMobilePlan,
+                                                                    const TDesC &aNumber,
+                                                                    RMobilePhone::TCFUIndicatorStatusFlags aCFUIndicatorStatusFlags,
+                                                                    RMobilePhone::TMultipleSubscriberProfileID aMultipleSubscriberProfileId);
+
+	// Phone related callbacks
+	IMPORT_C void CallbackPhoneGetFdnStatusComp(TInt aError, RMobilePhone::TMobilePhoneFdnStatus aFdnStatus);
+	IMPORT_C void CallbackPhoneGetNetworkRegistrationStatusComp(TInt aError, RMobilePhone::TMobilePhoneRegistrationStatus aRegStatus);
+	IMPORT_C void CallbackPhoneBootNotifyModemStatusReadyComp(TInt aError, TRfStateInfo aRfStatus);
+	IMPORT_C void CallbackPhoneBootNotifySimStatusReadyComp(TInt aError);
+	IMPORT_C void CallbackPhoneGetHomeNetworkComp(TInt aError, const RMobilePhone::TMobilePhoneNetworkInfoV5& aNetworkInfo);
+	IMPORT_C void CallbackPhoneNotifyNetworkModeChangeInd(TInt aError, RMobilePhone::TMobilePhoneNetworkMode aNetworkMode);
+	IMPORT_C void CallbackPhoneNotifyEgprsInfoChangeInd(TInt aError, TBool aEdgeSupported);
+	IMPORT_C void CallbackPhoneNotifySignalStrengthChangeInd(TInt aError, TInt32 aSignalStrength, TInt8 aBar);
+	IMPORT_C void CallbackPhoneNotifyNetworkRegistrationStatusChangeInd(TInt aError, RMobilePhone::TMobilePhoneRegistrationStatus aRegStatus);
+	IMPORT_C void CallbackPhoneNotifyNitzInfoChangeInd(TInt aError, const RMobilePhone::TMobilePhoneNITZ& aNitzInfo);
+	IMPORT_C void CallbackPhoneNotifyBatteryInfoChangeInd(TInt aError, const RMobilePhone::TMobilePhoneBatteryInfoV1& aBatteryInfo);
+	IMPORT_C void CallbackPhoneNotifyCurrentNetworkChangeInd(TInt aError, const RMobilePhone::TMobilePhoneNetworkInfoV5& aNetworkInfo, const RMobilePhone::TMobilePhoneLocationAreaV1& aLocationArea);
+	IMPORT_C void CallbackPhoneGetServiceProviderNameComp(TInt aError, const RMobilePhone::TMobilePhoneServiceProviderNameV2& aServiceProvider);
+	IMPORT_C void CallbackPhoneGetPhoneIdComp(TInt aError, const RMobilePhone::TMobilePhoneIdentityV1& aPhoneId);
+	IMPORT_C void CallbackPhoneGetDetectedNetworksComp(TInt aError, const CMobilePhoneNetworkListV2& aPhoneNetworkList);
+	IMPORT_C void CallbackPhoneGetDetectedNetworksCancelComp(TInt aError);
+	IMPORT_C void CallbackPhoneSelectNetworkComp(TInt aError);
+	IMPORT_C void CallbackPhoneSelectNetworkCancelComp(TInt aError);
+	IMPORT_C void CallbackPhoneSetNetworkSelectionSettingComp(TInt aError, RMobilePhone::TMobilePhoneSelectionMethod aSelectionMethod);
+	IMPORT_C void CallbackPhoneNotifyRfStatusChangeInd(TInt aError, TRfStateInfo aRfStatus);
+	IMPORT_C void CallbackPhoneGetCurrentNetworkInfoComp(TInt aError, const RMobilePhone::TMobilePhoneNetworkInfoV5& aNetworkInfo, const RMobilePhone::TMobilePhoneLocationAreaV1& aLocationArea);
+	IMPORT_C void CallbackPhoneGetNetworkModeComp(TInt aError, RMobilePhone::TMobilePhoneNetworkMode aNetworkMode);
+	IMPORT_C void CallbackPhoneGetNitzInfoComp(TInt aError, const RMobilePhone::TMobilePhoneNITZ& aNitzInfo);
+	IMPORT_C void CallbackPhoneGetSignalStrengthComp(TInt aError, TInt32 aSignalStrength, TInt8 aBar);
+	IMPORT_C void CallbackPhoneGetBatteryInfoComp(TInt aError, const RMobilePhone::TMobilePhoneBatteryInfoV1& aBatteryInfo);
+	IMPORT_C void CallbackPhoneSimRefreshRegisterComp(TInt aError);
+	IMPORT_C void CallbackPhoneNotifyNspsStatusChangeInd(TInt aError, TBool aEnabled);
+	IMPORT_C void CallbackPhoneNotifyNetworkSelectionSettingChangeInd(TInt aError, RMobilePhone::TMobilePhoneSelectionMethod aSelectionMethod);
+	IMPORT_C void CallbackPhoneGetCellInfoComp(TInt aError);
+	IMPORT_C void CallbackPhoneGetCellInfoComp(TInt aError, const RMmCustomAPI::TMmCellInfo::TGSMCellInfo &aInfo);
+    IMPORT_C void CallbackPhoneGetCellInfoComp(TInt aError,
+                                               const RMmCustomAPI::TMmCellInfo::TWCDMACellInfo &aInfo);
+	IMPORT_C void CallbackPhoneNotifyCellInfoChangedInd(TInt aError);
+	IMPORT_C void CallbackPhoneNotifyCellInfoChangedInd(TInt aError, const RMmCustomAPI::TMmCellInfo::TGSMCellInfo &aInfo);
+	IMPORT_C void CallbackPhoneNotifyCellInfoChangedInd(TInt aError, const RMmCustomAPI::TMmCellInfo::TWCDMACellInfo &aInfo);
+    IMPORT_C void CallbackPhoneNspsWakeupComp(TInt aError);
+    IMPORT_C void CallbackPhoneSetSystemNetworkModeComp(TInt aError);
+    IMPORT_C void CallbackPhoneGetCurrentSystemNetworkModesComp(TInt aError, TUint32 aCurrentSystemNetworkModes);
+	IMPORT_C void CallbackPhoneNotifyRauEventInd(TInt aError, RMmCustomAPI::TRauEventStatus aRauEvent);
+	IMPORT_C void CallbackPhoneNotifyNetworkConnectionFailureInd(TInt aError);
+	IMPORT_C void CallbackPhoneNotifyDtmfEventInd(TInt aError, RMmCustomAPI::TDtmfEventType aType,
+                                                  RMmCustomAPI::TDtmfEvent aEvent, TChar aTone);
+	IMPORT_C void CallbackPhoneNotifyDtmfEventInd(TInt aError, RMobilePhone::TMobilePhoneDTMFEvent aEventType);
+    IMPORT_C void CallbackPhoneResetNetServerComp(TInt aError);
+    IMPORT_C void CallbackPhoneSetAlwaysOnModeComp(TInt aError);
+    IMPORT_C void CallbackPhoneSetDriveModeComp(TInt aError);
+    IMPORT_C void CallbackPhoneGetHspaStatusComp(TInt aError, RMmCustomAPI::THSxPAStatus aStatus);
+    IMPORT_C void CallbackPhoneSetHspaStatusComp(TInt aError);
+	IMPORT_C void CallbackPhoneNotifyHspaStatusChangedInd(TInt aError, RMmCustomAPI::THSxPAStatus aStatus);
+    IMPORT_C void CallbackPhoneGetNetworkProviderNameComp(TInt aError, const TDesC& aName);
+    IMPORT_C void CallbackPhoneGetOperatorNameComp(TInt aError, RMmCustomAPI::TOperatorNameType aType, const TDesC& aName);
+    IMPORT_C void CallbackPhoneRegisterCellInfoChangeNotificationComp(TInt aError);
+	IMPORT_C void CallbackPhoneGetPhoneCellInfoComp(TInt aError, const RMobilePhone::TMobilePhoneCellInfoV9& aCellInfo);
+	IMPORT_C void CallbackPhoneNotifyCellInfoChangeInd(TInt aError, const RMobilePhone::TMobilePhoneCellInfoV9& aCellInfo);
+	IMPORT_C void CallbackPhoneGetUsimServiceSupportComp(TInt aError, TInt aApplicationNumber, TBool aSupported);
+	IMPORT_C void CallbackPhoneGetCurrentActiveUsimApplicationComp(TInt aError, const TDesC8& aAid);
+	IMPORT_C void CallbackPhoneTerminateAllCallsComp(TInt aError);
+	IMPORT_C void CallbackPhoneGetSystemNetworkBandComp(TInt aError, RMmCustomAPI::TBandSelection aBand, RMmCustomAPI::TNetworkModeCaps aMode);
+	IMPORT_C void CallbackPhoneSetSystemNetworkBandComp(TInt aError);
+
+	// Security related callbacks
+	IMPORT_C void CallbackSecurityBootNotifySecurityReadyInd(TInt aError);
+	IMPORT_C void CallbackSecurityNotifySecurityEventInd(TInt aError, RMobilePhone::TMobilePhoneSecurityEvent aSecEvent);
+	IMPORT_C void CallbackSecurityNotifyLockInfoChangeInd(TInt aError, RMobilePhone::TMobilePhoneLockStatus aStatus, RMobilePhone::TMobilePhoneLockSetting aSetting, RMobilePhone::TMobilePhoneLock aLock);
+	IMPORT_C void CallbackSecurityGetSecurityCodeInfoComp(TInt aError, RMobilePhone::TMobilePhoneSecurityCode aSecCode, 
+	                      TInt aRemainingEntryAttempts);
+	IMPORT_C void CallbackSecurityGetLockInfoComp(TInt aError, RMobilePhone::TMobilePhoneLockStatus aLockStatus, RMobilePhone::TMobilePhoneLockSetting aLockSetting);
+	IMPORT_C void CallbackSecurityAbortSecurityCodeComp(TInt aError);
+	IMPORT_C void CallbackSecurityGetCurrentActivePinComp(TInt aError, RMobilePhone::TMobilePhoneSecurityCode aSecCode);
+	IMPORT_C void CallbackSecuritySetLockSettingComp(TInt aError);	                     
+	IMPORT_C void CallbackSecurityVerifySecurityCodeComp(TInt aError);
+	IMPORT_C void CallbackSecurityGetPin1DisableSupportedComp(TInt aError, TBool aIsSupported);
+	IMPORT_C void CallbackSecurityNotifyCipheringInfoChangeInd(TInt aError, const RMmCustomAPI::TCipheringInfo& aInfo);
+	IMPORT_C void CallbackSecurityCheckSecurityCodeComp(TInt aError);
+	IMPORT_C void CallbackSecurityDisablePhoneLockComp(TInt aError);
+	IMPORT_C void CallbackSecurityGetCipheringInfoComp(TInt aError, TBool aIndStatus);
+	IMPORT_C void CallbackSecurityIsSecurityCodeBlockedComp(TInt aError, TBool aIsBlocked);	
+	IMPORT_C void CallbackSecurityCheckSecurityCodeCancelComp(TInt aError);
+
+	// PhonebookEn related callbacks
+	IMPORT_C void CallbackPhonebookEnStoreGetInfoComp(TInt aError, TInt aUsedEntries);
+	IMPORT_C void CallbackPhonebookEnStoreReadAllComp(TInt aError, TInt aIndex, const TDesC& aNumber, TBool aMoreToCome);
+	IMPORT_C void CallbackPhonebookEnStoreReadEntryComp(TInt aError, TInt aIndex, const TDesC& aNumber);
+
+	// CellBroadcast related callbacks
+	IMPORT_C void CallbackCellBroadcastGsmBroadcastNotifyMessageReceivedInd(TInt aError, const TDesC8& aCbsMsg);
+	IMPORT_C void CallbackCellBroadcastWcdmaBroadcastMessageReceivedInd(TInt aError, const TDesC8& aWcdmaCbsData, const DispatcherCellBroadcast::TWcdmaCbsMsgBase& aWcdmaCbsMsgBase, TBool aMoreToCome);
+	IMPORT_C void CallbackCellBroadcastSetBroadcastFilterSettingComp(TInt aError);
+	IMPORT_C void CallbackCellBroadcastActivateBroadcastReceiveMessageComp(TInt aError);
+	IMPORT_C void CallbackCellBroadcastReceiveMessageCancelComp(TInt aError);
+	IMPORT_C void CallbackCellBroadcastStartSimCbTopicBrowsingComp(TInt aError, const CArrayFixFlat< RMmCustomAPI::TSimCbTopic >& aSimTopicArray );
+	IMPORT_C void CallbackCellBroadcastDeleteSimCbTopicComp(TInt aError);
+
+	// PhonebookOn related callbacks
+	IMPORT_C void CallbackPhonebookOnStoreReadAllInd(TInt aError);
+	IMPORT_C void CallbackPhonebookOnStoreReadComp(TInt aError, TInt aIndex, const TDesC& aName, const TDesC& aNumber);
+	IMPORT_C void CallbackPhonebookOnStoreDeleteAllComp(TInt aError);
+	IMPORT_C void CallbackPhonebookOnStoreReadEntryComp(TInt aError, TInt aIndex, const TDesC& aName, const TDesC& aNumber);
+	IMPORT_C void CallbackPhonebookOnStoreGetInfoComp(TInt aError, TInt aNumOfEntries, TInt aUsedEntries, TInt aNameLen, TInt aNumLen);
+	IMPORT_C void CallbackPhonebookOnStoreGetReadStoreSizeComp(TInt aError, TInt aSize);
+	IMPORT_C void CallbackPhonebookOnStoreDeleteEntryComp(TInt aError);
+	IMPORT_C void CallbackPhonebookOnStoreWriteEntryComp(TInt aError);
+	IMPORT_C void CallbackPhonebookOnStoreWriteComp(TInt aError, TInt aLocation);
+	IMPORT_C void CallbackPhonebookOnStoreGetStoreSizeComp(TInt aError, TInt aSize);
+
+	// Phonebook related callbacks
+	IMPORT_C void CallbackPhonebookStoreResetCacheInd(TInt aError, DispatcherPhonebook::TPhonebook aPhonebook);
+	IMPORT_C void CallbackPhonebookStoreSetFdnPhonebookInfoInd(TInt aError, TInt aTotalEntries , TInt aMaxTextLength , TInt aMaxNumberLength);
+	IMPORT_C void CallbackPhonebookStoreReadEntryComp(TInt aError, DispatcherPhonebook::TPhonebook aPhonebook, const TDesC8& aPhonebookEntries);
+	IMPORT_C void CallbackPhonebookStoreDeleteEntryComp(TInt aError, DispatcherPhonebook::TPhonebook aPhonebook, TInt aMaxNumberLength = -1);
+	IMPORT_C void CallbackPhonebookStoreCacheComp(TInt aError, DispatcherPhonebook::TPhonebook aPhonebook, const TDesC8& aPhonebookEntries);
+	IMPORT_C void CallbackPhonebookStoreGetPhonebookInfoComp(TInt aError, DispatcherPhonebook::TPhonebook aPhonebook, TInt aUsedEntries);
+	IMPORT_C void CallbackPhonebookStoreInitialiseComp(TInt aError, const DispatcherPhonebook::TPhonebookStoreInfoV1& aPhonebookStoreInfo);
+	IMPORT_C void CallbackPhonebookStoreDeleteAllComp(TInt aError, DispatcherPhonebook::TPhonebook aPhonebook, TInt aMaxNumberLength = -1);
+	IMPORT_C void CallbackPhonebookStoreWriteEntryComp(TInt aError, DispatcherPhonebook::TPhonebook aPhonebook, TUint16 aIndex, TInt aMaxNumberLength = -1);
+	IMPORT_C void CallbackPhonebookGetPhoneStoreInfoComp(TInt aError, const RMobilePhoneStore::TMobilePhoneStoreInfoV1& aPhoneStoreInfo);
+	IMPORT_C void CallbackPhonebookSmsStoreReadAllComp(TInt aError, const DispatcherPhonebook::TSmsData& aSmsData, TInt aIndex, TBool aMoreToCome, TBool aReceivedClass2ToBeResent);
+	IMPORT_C void CallbackPhonebookSmsStoreDeleteEntryComp(TInt aError);
+	IMPORT_C void CallbackPhonebookSmsStoreDeleteAllComp(TInt aError);
+	IMPORT_C void CallbackPhonebookSmsStoreGetInfoComp(TInt aError, TInt aTotalEntries, TInt aUsedEntries);
+	IMPORT_C void CallbackPhonebookSmsStoreReadEntryComp(TInt aError, const DispatcherPhonebook::TSmsData& aSmsData);
+	IMPORT_C void CallbackPhonebookSmsStoreWriteEntryComp(TInt aError, TInt aLocation, TBool aReceivedClass2ToBeResent);
+
+	// Sim related callbacks
+	IMPORT_C void CallbackSimRefreshSimFilesInd(TInt aError, TUint16 aRefreshFileList);
+	IMPORT_C void CallbackSimNotifyIccMessageWaitingIndicatorsChangeInd(TInt aError, const RMobilePhone::TMobilePhoneMessageWaitingV1& aIndicators);
+	IMPORT_C void CallbackSimNotifyApnListChangeInd(TInt aError);
+	IMPORT_C void CallbackSimNotifyApnControlListServiceStatusChangeInd(TInt aError, RMobilePhone::TAPNControlListServiceStatus aStatus);
+	IMPORT_C void CallbackSimGetApnControlListServiceStatusComp(TInt aError, RMobilePhone::TAPNControlListServiceStatus aStatus);
+	IMPORT_C void CallbackSimDeleteApnNameComp(TInt aError);
+	IMPORT_C void CallbackSimEnumerateApnEntriesComp(TInt aError, TUint32 aNumEntries);
+	IMPORT_C void CallbackSimChangeSecurityCodeComp(TInt aError);
+	IMPORT_C void CallbackSimSetFdnSettingComp(TInt aError);
+	IMPORT_C void CallbackSimGetCustomerServiceProfileComp(TInt aError, const RMobilePhone::TMobilePhoneCspFileV1& aCsp);
+	IMPORT_C void CallbackSimGetSubscriberIdComp(TInt aError, const TDesC8& aId);
+	IMPORT_C void CallbackSimAppendApnNameComp(TInt aError);
+	IMPORT_C void CallbackSimGetActiveIccApplicationTypeComp(TInt aError, MLtsyDispatchSimGetActiveIccApplicationType::TIccType aIccType);
+	IMPORT_C void CallbackSimSetIccMessageWaitingIndicatorsComp(TInt aError);
+	IMPORT_C void CallbackSimSetApnControlListServiceStatusComp(TInt aError);
+	IMPORT_C void CallbackSimGetApnNameComp(TInt aError, const RMobilePhone::TAPNEntryV3& aEntry);
+	IMPORT_C void CallbackSimGetServiceTableComp(TInt aError, const RMobilePhone::TMobilePhoneServiceTableV1& aServiceTable);
+	IMPORT_C void CallbackSimGetIccMessageWaitingIndicatorsComp(TInt aError, const RMobilePhone::TMobilePhoneMessageWaitingV1& aMessageWaiting);
+	IMPORT_C void CallbackSimNotifySimCardStatusInd(TInt aError, RMmCustomAPI::TSIMCardStatus aSimCardStatus);
+	IMPORT_C void CallbackSimSimLockActivateComp(TInt aError);
+	IMPORT_C void CallbackSimSimLockDeActivateComp(TInt aError);
+	IMPORT_C void CallbackSimGetAnswerToResetComp(TInt aError, const TDesC8& aAnswerToReset);
+	IMPORT_C void CallbackSimGetSimCardReaderStatusComp(TInt aError, TUint8 aSimCardReaderStatus);
+	IMPORT_C void CallbackSimGetSimAuthenticationDataComp(TInt aError, const TDesC8& aSignedResponse, const TDesC8& aCipheringKey);
+	IMPORT_C void CallbackSimGetSimAuthenticationDataComp(TInt aError, const TDesC8& aResponse, const TDesC8& aCipheringKey, const TDesC8& aIntegrityKey, const TDesC8& aAUTS);
+	IMPORT_C void CallbackSimPowerSimOffComp(TInt aError);
+	IMPORT_C void CallbackSimPowerSimOnComp(TInt aError);
+	IMPORT_C void CallbackSimReadSimFileComp(TInt aError, const TDesC8& aResponseBytes);
+	IMPORT_C void CallbackSimSendApduRequestComp(TInt aError, TUint8 aServiceType, TUint8 aCardReaderNumber, TUint8 aApplicationType, const TDesC8& aResponseData);
+	IMPORT_C void CallbackSimSendApduRequestV2Comp(TInt aError, const TDesC8& aResponseData);
+	IMPORT_C void CallbackSimSimWarmResetComp(TInt aError);
+	IMPORT_C void CallbackSimSetSimMessageStatusReadComp(TInt aError);
+
+	// Sms related callbacks
+	IMPORT_C void CallbackSmsNotifyReceiveSmsMessageInd(TInt aError, TBool aInd, const TSmsMsg& aSmsMessage);
+	IMPORT_C void CallbackSmsSendSatSmsComp(TInt aError);
+	IMPORT_C void CallbackSmsGetSmsStoreInfoComp(TInt aError, TInt aTotalEntries, TInt aUsedEntries);
+	IMPORT_C void CallbackSmsGetSmspListComp(TInt aError, const TDesC& aServiceCenterAddress, const TDesC& aDestinationAddress,
+				  const TDesC& aAlphaTagData, const DispatcherSim::TSmsParameters& aSmsParameters, TBool aMoreToCome);
+	IMPORT_C void CallbackSmsNackSmsStoredComp(TInt aError);
+	IMPORT_C void CallbackSmsAckSmsStoredComp(TInt aError);
+	IMPORT_C void CallbackSmsResumeSmsReceptionComp(TInt aError);
+	IMPORT_C void CallbackSmsSendSmsMessageComp(TInt aError, TInt aMsgRef, const TDesC8& aSmsSubmitReport);
+	IMPORT_C void CallbackSmsSendSmsMessageNoFdnCheckComp(TInt aError, TInt aMsgRef, const TDesC8& aSmsSubmitReport);
+	IMPORT_C void CallbackSmsSetMoSmsBearerComp(TInt aError);
+	IMPORT_C void CallbackSmsStoreSmspListEntryComp(TInt aError);
+
+	// CallControlMultiparty related callbacks
+	IMPORT_C void CallbackCallControlMultipartyConferenceHangUpComp(TInt aError);
+	IMPORT_C void CallbackCallControlMultipartyConferenceAddCallComp(TInt aError);
+	IMPORT_C void CallbackCallControlMultipartyCreateConferenceComp(TInt aError);
+	IMPORT_C void CallbackCallControlMultipartyConferenceSwapComp(TInt aError);
+	IMPORT_C void CallbackCallControlMultipartyConferenceGoOneToOneComp(TInt aError, TInt aCallId);
+
+	// SupplementaryServices related callbacks
+	IMPORT_C void CallbackSupplementaryServicesNotifyCallBarringStatusChangeInd(TInt aError, RMobilePhone::TMobilePhoneCBCondition aCondition);
+	IMPORT_C void CallbackSupplementaryServicesReceiveUssdMessageInd(TInt aError, const TDesC8& aMessage, TUint8 aDcs, RMobileUssdMessaging::TMobileUssdMessageType aType, RMobileUssdMessaging::TMobileUssdDataFormat aFormat);
+	IMPORT_C void CallbackSupplementaryServicesNotifyCallWaitingStatusChangeInd(TInt aError, RMobilePhone::TMobileService aServiceGrouop, RMobilePhone::TMobilePhoneCWStatus aStatus);
+	IMPORT_C void CallbackSupplementaryServicesNotifyCallForwardingStatusChangeInd(TInt aError, RMobilePhone::TMobilePhoneCFCondition aCallForwardingCondition);
+	IMPORT_C void CallbackSupplementaryServicesNotifyCallForwardingActiveInd(TInt aError, RMobilePhone::TMobileService aServiceGroup, RMobilePhone::TMobilePhoneCFActive aActiveType);
+	IMPORT_C void CallbackSupplementaryServicesGetDiagnosticOctetsInd(TInt aError, TInt aCallId, TUint8 aOctet);
+	IMPORT_C void CallbackSupplementaryServicesNotifyAdditionalInfoInd(TInt aError, TUint8 aOperationCode, const TDesC8& aAdditionalInfo);
+	IMPORT_C void CallbackSupplementaryServicesNotifyRequestCompleteInd(TInt aError, TInt aStatus);
+	IMPORT_C void CallbackSupplementaryServicesNotifySendNetworkServiceRequestInd(TInt aError, RMobilePhone::TMobilePhoneNotifySendSSOperation aOperationCode, const TDesC& aAdditionalInfo);
+	// NotifySS options
+	IMPORT_C void CallbackSupplementaryServicesNotifyNetworkEventForwardModeInd(TInt aError, RMmCustomAPI::TSsType aType, RMmCustomAPI::TSsMode aMode, RMmCustomAPI::TSsForwMode aForwardMode);
+	IMPORT_C void CallbackSupplementaryServicesNotifyNetworkEventCallWaitingInd(TInt aError, RMmCustomAPI::TSsMode aMode, TBool aCallIsWaiting);
+	IMPORT_C void CallbackSupplementaryServicesNotifyNetworkEventHoldModeInd(TInt aError, RMmCustomAPI::TSsType aType, RMmCustomAPI::TSsMode aMode, RMmCustomAPI::TSsHoldMode aHoldMode);
+	IMPORT_C void CallbackSupplementaryServicesNotifyNetworkEventConfrenceInd(TInt aError, RMmCustomAPI::TSsType aType, RMmCustomAPI::TSsMode aMode, TBool aConferenceIndicator);
+	IMPORT_C void CallbackSupplementaryServicesNotifyNetworkEventCugInd(TInt aError, RMmCustomAPI::TSsType aType, RMmCustomAPI::TSsMode aMode, TUint16 aCugIndex);
+	IMPORT_C void CallbackSupplementaryServicesNotifyNetworkEventClirSuppressionInd(TInt aError, RMmCustomAPI::TSsMode aMode, TBool aClirSuppressionRejected);
+	IMPORT_C void CallbackSupplementaryServicesNotifyNetworkEventEctCallStateInd(TInt aError, RMmCustomAPI::TSsType aType, RMmCustomAPI::TSsMode aMode, RMmCustomAPI::TSsEctState aEctCallState, RMmCustomAPI::TSsChoice aEctChoice, const TDesC& aRemotePartyNumber);
+	IMPORT_C void CallbackSupplementaryServicesNotifyNetworkEventInd(TInt aError, RMmCustomAPI::TSsType aType, RMmCustomAPI::TSsMode aMode);
+	
+	IMPORT_C void CallbackSupplementaryServicesSendNetworkServiceRequestNoFdnCheckComp(TInt aError);
+	IMPORT_C void CallbackSupplementaryServicesGetCallWaitingStatusComp(TInt aError, const CMobilePhoneCWList& aCallWaitingList);
+	IMPORT_C void CallbackSupplementaryServicesSendNetworkServiceRequestComp(TInt aError);
+	IMPORT_C void CallbackSupplementaryServicesGetCallBarringStatusComp(TInt aError, const CMobilePhoneCBList& aCallBarringList);
+	IMPORT_C void CallbackSupplementaryServicesSetCallBarringStatusComp(TInt aError);
+	IMPORT_C void CallbackSupplementaryServicesSetCallForwardingStatusComp(TInt aError);
+	IMPORT_C void CallbackSupplementaryServicesSetCallWaitingStatusComp(TInt aError);
+	IMPORT_C void CallbackSupplementaryServicesSetSsPasswordComp(TInt aError);
+	IMPORT_C void CallbackSupplementaryServicesGetCallForwardingStatusComp(TInt aError, const CMobilePhoneCFList& aCallForwardingList);
+	IMPORT_C void CallbackSupplementaryServicesSendUssdMessageComp(TInt aError);
+	IMPORT_C void CallbackSupplementaryServicesSendUssdMessageNoFdnCheckComp(TInt aError);
+	IMPORT_C void CallbackSupplementaryServicesSendUssdReleaseComp(TInt aError, TUint8 aOpCode, const TDesC& aAdditionalInfo);
+	IMPORT_C void CallbackSupplementaryServicesClearBlacklistComp(TInt aError);
+
+	// PacketServices related callbacks
+	IMPORT_C void CallbackPacketServicesNotifyPacketAttachModeChangeInd(TInt aError, RPacketService::TPreferredBearer aBearer);
+	IMPORT_C void CallbackPacketServicesNotifyQosProfileChangedGPRSInd(TInt aError, const TDesC& aContextName, const RPacketQoS::TQoSGPRSNegotiated&  aQoSGPRSNegotiated);
+	IMPORT_C void CallbackPacketServicesNotifyQosProfileChangedR99Ind(TInt aError, const TDesC& aContextName, const RPacketQoS::TQoSR99_R4Negotiated& aQoSR99_R4Negotiated);
+	IMPORT_C void CallbackPacketServicesNotifyQosProfileChangedR5Ind(TInt aError, const TDesC& aContextName, const RPacketQoS::TQoSR5Negotiated& aQoSR5Negotiated);
+	IMPORT_C void CallbackPacketServicesNotifyRatTransferCapsChangeInd(TInt aError, TDynamicTransferCapsFlags aCaps);
+	IMPORT_C void CallbackPacketServicesNotifyPacketMsClassChangeInd(TInt aError, RPacketService::TMSClass aMSClass);
+	IMPORT_C void CallbackPacketServicesNotifyPacketDynamicCapsChangeInd(TInt aError, TBool aGprsIsSupportedOnCell, TBool aCsServicesIsSupportedOnCell);
+	IMPORT_C void CallbackPacketServicesNotifyPdpContextAddedInd(TInt aError, const TDesC& aContextName);
+	IMPORT_C void CallbackPacketServicesNotifyNetworkInitiatedContextActivationRequestInd(TInt aError, const RPacketContext::TContextConfigGPRS& aContextConfigGPRS);
+	IMPORT_C void CallbackPacketServicesNotifyNetworkInitiatedContextActivationRequestInd(TInt aError, const RPacketContext::TContextConfigR99_R4& aContextConfigR99_R4);
+	IMPORT_C void CallbackPacketServicesNotifyNetworkInitiatedContextActivationRequestInd(TInt aError, const RPacketContext::TContextConfig_R5& aContextConfig_R5);				
+	IMPORT_C void CallbackPacketServicesNotifyPdpContextConfigChangedInd(TInt aError, const TDesC& aContextName, const TDesC8& aAccessPointName, const TDesC8& aPdpAddress, const TUint aPdpCompression, const TDesC8& aPcoBuffer);
+	IMPORT_C void CallbackPacketServicesNotifyPdpContextStatusChangeInd(TInt aError, const TDesC& aContextName, const TContextMisc& aContextMisc);
+	IMPORT_C void CallbackPacketServicesNotifyPdpContextConnectionSpeedChangeInd(TInt aError, const TDesC& aContextName, TUint aConnectionSpeed);
+	IMPORT_C void CallbackPacketServicesNotifyPacketNetworkRegistrationStatusInd(TInt aError, RPacketService::TRegistrationStatus aRegistrationStatus);
+	IMPORT_C void CallbackPacketServicesNotifyMbmsContextConfigChangedInd(TInt aError, const TDesC& aContextName, const RPacketMbmsContext::TContextConfigMbmsV1& aContextConfigMbms);
+	IMPORT_C void CallbackPacketServicesNotifyMbmsNetworkServiceStatusChangeInd(TInt aError, TMbmsNetworkServiceStatus aMbmsNetworkServiceStatus);
+	IMPORT_C void CallbackPacketServicesNotifyMbmsServiceAvailabilityChangeInd(TInt aError, const RArray<TUint>& aAvailableServiceIds);
+	IMPORT_C void CallbackPacketServicesNotifyConnectionInfoChangeInd(TInt aError, const TDesC& aContextName, const RPacketContext::TConnectionInfoV1& aConnectionInfo);
+	IMPORT_C void CallbackPacketServicesPacketAttachComp(TInt aError);
+	IMPORT_C void CallbackPacketServicesGetPacketAttachModeComp(TInt aError, RPacketService::TAttachMode aAttachMode);
+	IMPORT_C void CallbackPacketServicesGetPacketNetworkRegistrationStatusComp(TInt aError, RPacketService::TRegistrationStatus aRegistrationStatus);
+	IMPORT_C void CallbackPacketServicesPacketDetachComp(TInt aError);
+	IMPORT_C void CallbackPacketServicesSetPdpContextConfigComp(TInt aError, const TDesC& aContextName);
+	IMPORT_C void CallbackPacketServicesModifyActivePdpContextComp(TInt aError, const TDesC& aContextName, TInt8 aRejectionCode);
+	IMPORT_C void CallbackPacketServicesInitialisePdpContextComp(TInt aError, const TDesC& aContextName, const TDesC& aChannelId);
+	IMPORT_C void CallbackPacketServicesDeletePdpContextComp(TInt aError, const TDesC& aContextName);
+	IMPORT_C void CallbackPacketServicesSetPacketAttachModeComp(TInt aError);
+	IMPORT_C void CallbackPacketServicesSetDefaultPdpContextParamsComp(TInt aError);
+	IMPORT_C void CallbackPacketServicesActivatePdpContextComp(TInt aError, const TDesC& aContextName, const TDesC8& aAccessPointName, RPacketContext::TProtocolType aPdpType);
+	IMPORT_C void CallbackPacketServicesSetPdpContextQosComp(TInt aError, const TDesC& aContextName);
+	IMPORT_C void CallbackPacketServicesRejectNetworkInitiatedContextActivationRequestComp(TInt aError);
+	IMPORT_C void CallbackPacketServicesDeactivatePdpContextComp(TInt aError, const TDesC& aContextName);
+	IMPORT_C void CallbackPacketServicesGetStatusComp(TInt aError, RPacketService::TStatus aPacketStatus, TBool aIsResumed);
+	IMPORT_C void CallbackPacketServicesGetStaticCapabilitiesComp(TInt aError, TUint aStaticCapabilities);
+	IMPORT_C void CallbackPacketServicesGetMaxNoMonitoredServiceListsComp(TInt aError, TInt aMaxNoMonitoredServiceLists);
+	IMPORT_C void CallbackPacketServicesGetMaxNoActiveServicesComp(TInt aError, TInt aMaxNoActiveServices);
+	IMPORT_C void CallbackPacketServicesInitialiseMbmsContextComp(TInt aError, const TDesC& aContextName, const TDesC& aChannelId);
+	IMPORT_C void CallbackPacketServicesGetMbmsNetworkServiceStatusComp(TInt aError, TMbmsNetworkServiceStatus aMbmsNetworkServiceStatus);
+	IMPORT_C void CallbackPacketServicesUpdateMbmsMonitorServiceListComp(TInt aError);
+	IMPORT_C void CallbackPacketServicesUpdateMbmsMonitorServiceListComp(TInt aError, const RArray<TUint>& aFailedServiceIds);
+	IMPORT_C void CallbackPacketServicesUpdateMbmsSessionListComp(TInt aError, const TDesC& aContextName);
+	
+	// Sat related callbacks
+	IMPORT_C void CallbackSatUssdControlSupportedChangeInd(TInt aError, TBool aSupported);
+	IMPORT_C void CallbackSatPcmdInd(TInt aError, const TDesC8& aData);
+	IMPORT_C void CallbackSatNotifyProactiveSimSessionEndInd(TInt aError, TUint8 aStatusWord1, TUint8 aStatusWord2);
+	IMPORT_C void CallbackSatTimeZoneChangeInd(TInt aError, TUint8 aTimeZone);
+	IMPORT_C void CallbackSatAccessTechnologyChangeInd(TInt aError, TUint8 aCurrentAccessTechnology);
+	IMPORT_C void CallbackSatCallConnectedInd(TInt aError, TUint8 aTransactionId, TBool aNearEnd);
+	IMPORT_C void CallbackSatSsChangeInd(TInt aError, DispatcherSat::TSsStatus aStatus);
+	IMPORT_C void CallbackSatCallDisconnectedInd(TInt aError, TUint8 aTransactionId, TBool aNearEnd, const TDesC8& aCause);
+	IMPORT_C void CallbackSatMtCallInd(TInt aError, TUint8 aTransactionId, const TDesC8& aAddress, const TDesC8& aSubAddress);
+	IMPORT_C void CallbackSatCallControlEnvelopeResponseInd(TInt aError, const TDesC8& aResponseTlv);
+	IMPORT_C void CallbackSatCreateCallControlEnvelopeInd(TInt aError, TUint8 aTag, const TDesC8& aBcc1, const TDesC8& aBcc2, const TDesC8& aAddress, TUint8 aTonNpi, TUint8 aDcs);
+	IMPORT_C void CallbackSatCreateSmControlEnvelopeInd(TInt aError, const TDesC8& aRpDestinationAddress, const TDesC8& aTpDestinationAddress);
+	IMPORT_C void CallbackSatImsiChangedInd(TInt aError);
+	IMPORT_C void CallbackSatLocationStatusInd(TInt aError, TUint8 aLcnStatus, const TDesC8& aCountryCode,
+			TUint16 aLcnAreaCode, TUint16 aCellId);
+	IMPORT_C void CallbackSatRemoveEventListInd(TInt aError);
+	IMPORT_C void CallbackSatCreateRefreshTerminalRspInd(TInt aError, RSat::TPCmdResult aGeneralResult, const TDesC& aAdditionalInfo);
+	IMPORT_C void CallbackSatSmControlEnvelopeResponseInd(TInt aError, const TDesC8& aResponseTlv);
+	IMPORT_C void CallbackSatCreateSmsPpDownloadEnvelopeInd(TInt aError, const TDesC8& aRpOriginatingAddress, const TDesC8& aSmsTpdu);
+	IMPORT_C void CallbackSatCreateSmsDeliverReportInd(TInt aError);
+	IMPORT_C void CallbackSatCreateCellBroadcastEnvelopeInd(TInt aError, const TDesC8& aCellBroadcastPage);
+	IMPORT_C void CallbackSatGetImageInstanceComp(TInt aError, const TDesC8& aImageInstanceData, const TDesC8& aImageInstanceBody);
+	IMPORT_C void CallbackSatGetIconDataComp(TInt aError, const TDesC8& aIconEfImgRecord);
+	IMPORT_C void CallbackSatGetClutComp(TInt aError, const TDesC8& aClut);
+	IMPORT_C void CallbackSatGetDefaultBearerCapabilityComp(TInt aError, const TDesC8& aCapability);
+	IMPORT_C void CallbackSatGetSmsPpDownloadSupportedComp(TInt aError, TBool aSupported);
+	IMPORT_C void CallbackSatGetSmsControlActivatedComp(TInt aError, TBool aActivated);
+	IMPORT_C void CallbackSatGetAccessTechnologyComp(TInt aError, TUint8 aAccessTechnology);
+	IMPORT_C void CallbackSatTimingAdvanceComp(TInt aError, TUint8 aTimingAdvance, TUint8 aMeStatus);
+	IMPORT_C void CallbackSatProvideLocationInfoComp(TInt aError, TUint16 aLocationAreaCode, TUint16 aCellId,
+			const TDesC8& aOperatorCode);
+	IMPORT_C void CallbackSatSetPollingIntervalComp(TInt aError, TUint8 aPollingInterval);
+	IMPORT_C void CallbackSatLocalInformationNmrComp(TInt aError, const TDesC8& aNmr, const TDesC& aBcchList);
+	IMPORT_C void CallbackSatGetUssdControlSupportedComp(TInt aError, TBool aSupported);
+	IMPORT_C void CallbackSatTerminalRspComp(TInt aError);
+	IMPORT_C void CallbackSatRefreshAllowedComp(TInt aError);
+	IMPORT_C void CallbackSatReadyComp(TInt aError);
+	IMPORT_C void CallbackSatUssdControlEnvelopeErrorComp(TInt aError);
+	
+protected:
+
+
+private:
+
+	// So that the CMessageRouter can call SetDispatcherHolder (which we do not want
+	// to export) on it to give it the dispatcher object references.
+	friend class CMessageRouter;
+
+	void SetDispatcherHolder(TDispatcherHolder& aDispatcherHolder);
+
+	CCtsyDispatcherCallback();
+	void ConstructL();
+
+private:
+
+	// Not Owned
+
+	/**
+	 * Holds pointers to dispatcher objects.  Completions sent by the Licensee LTSY
+	 * are forwarded by this class to the relevant dispatcher stored in the
+	 * dispatcher holder.
+	 */
+	TDispatcherHolder* iDispatcherHolder;
+
+	}; // class CCtsyDispatcherCallback
+
+#endif // CCTSYDISPATCHERCALLBACK_H
diff -r 4a8d14a1a8ca -r ab1d0f4d2aa4 Telephony/ctsydispatchlayer/exportinc/cphonebookentry.h
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Telephony/ctsydispatchlayer/exportinc/cphonebookentry.h	Thu Aug 12 13:20:01 2010 +0100
@@ -0,0 +1,84 @@
+// Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).
+// All rights reserved.
+// This component and the accompanying materials are made available
+// under the terms of "Eclipse Public License v1.0"
+// which accompanies this distribution, and is available
+// at the URL "http://www.eclipse.org/legal/epl-v10.html".
+//
+// Initial Contributors:
+// Nokia Corporation - initial contribution.
+//
+// Contributors:
+//
+// Description:
+//
+
+
+
+/**
+ @file
+ @internalAll 
+*/
+
+#ifndef CPHONEBOOKENTRY_H_
+#define CPHONEBOOKENTRY_H_
+
+#include <e32def.h>
+#include <e32cmn.h>
+
+#include <mpbutil.h>
+
+class CPhoneBookEntry : public CBase
+	{
+public:
+
+	IMPORT_C static CPhoneBookEntry* NewL();
+	IMPORT_C static CPhoneBookEntry* NewLC();
+	
+	IMPORT_C void Reset();
+	
+	IMPORT_C TInt GetIndex() const;
+	IMPORT_C const TDesC& GetFirstName() const;
+	IMPORT_C const TDesC& GetDiallingNumber() const;
+	IMPORT_C const RArray<RBuf>& GetEmailAddresss() const;
+	IMPORT_C const RArray<RBuf>& GetSecondNames() const;
+	IMPORT_C const RArray<RBuf>& GetAdditionalNumbers() const;
+	
+	IMPORT_C void SetIndex(TInt aIndex);
+	IMPORT_C TInt SetFirstName(const TDesC& aFirstName);
+	IMPORT_C TInt SetDiallingNumber(const TDesC& aDiallingNumber);
+	
+	IMPORT_C TInt AddEmailAddress(const TDesC& aEmailAddress);
+	IMPORT_C TInt AddSecondName(const TDesC& aSecondName);
+	IMPORT_C TInt AddAdditionalNumber(const TDesC& aAdditionalNumber);
+	
+	IMPORT_C TInt ExternalizeToTlvEntry(CPhoneBookBuffer& aPhoneBookBuffer) const;
+	IMPORT_C TInt InternalizeFromTlvEntry(CPhoneBookBuffer& aPhoneBookBuffer, TBool aNewEntryTagRead = EFalse);
+
+	IMPORT_C TInt TlvLength() const;
+	
+	IMPORT_C TBool operator== (const CPhoneBookEntry& aPhoneBookEntry) const;
+
+	~CPhoneBookEntry();
+	
+private:
+
+	void ConstructL();
+	CPhoneBookEntry();
+	
+	TInt GetText(TPtrC16& text, CPhoneBookBuffer::TPhBkTagType aTagType, CPhoneBookBuffer& aPhoneBookBuffer) const;
+	void DesSize(TInt& aSize, const TDesC& aDes) const;
+
+	
+private:
+	
+	TInt iIndex;
+	TBool iIndexSet;
+	RBuf iFirstName;
+	RBuf iDiallingNumber;
+	RArray<RBuf> iEmailAddresss;
+	RArray<RBuf> iSecondNames;
+	RArray<RBuf> iAdditionalNumbers;
+	};
+
+#endif /*CPHONEBOOKENTRY_H_*/
diff -r 4a8d14a1a8ca -r ab1d0f4d2aa4 Telephony/ctsydispatchlayer/exportinc/distribution.policy.s60
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Telephony/ctsydispatchlayer/exportinc/distribution.policy.s60	Thu Aug 12 13:20:01 2010 +0100
@@ -0,0 +1,1 @@
+7
\ No newline at end of file
diff -r 4a8d14a1a8ca -r ab1d0f4d2aa4 Telephony/ctsydispatchlayer/exportinc/ltsylogger.h
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Telephony/ctsydispatchlayer/exportinc/ltsylogger.h	Thu Aug 12 13:20:01 2010 +0100
@@ -0,0 +1,101 @@
+// Copyright (c) 2008-2010 Nokia Corporation and/or its subsidiary(-ies).
+// All rights reserved.
+// This component and the accompanying materials are made available
+// under the terms of "Eclipse Public License v1.0"
+// which accompanies this distribution, and is available
+// at the URL "http://www.eclipse.org/legal/epl-v10.html".
+//
+// Initial Contributors:
+// Nokia Corporation - initial contribution.
+//
+// Contributors:
+//
+// Description:
+// CommsDebugUtil logging support for the CTSY Dispatcher.
+//
+
+
+
+
+/**
+ @file
+ @internalAll 
+*/
+
+#ifndef __LTSYLOGGER_H_
+#define __LTSYLOGGER_H_
+
+#include <e32base.h>
+
+#ifdef OST_TRACE_COMPILER_IN_USE
+
+_LIT8(KTsySubSystem, "tsy");
+_LIT8(KTsyCompnt, "ctsydis");
+
+	/** Macros to log function entry and exit */
+	//#define TSYLOGENTRYEXIT(aFunc) 	TLogEntryExit __logger((aFunc), KTsyCompnt)
+	
+	//#define TSYLOGENTRYEXITARGS(aFunc, aFmt, ARGS...) 	TLogEntryExit __logger((aFunc), KTsyCompnt, (aFmt), ##ARGS); 
+
+	#define TSYLOGENTRYEXIT 	/*lint -save -e40*/	TLogEntryExit __logger(TPtrC8((const TUint8*)__PRETTY_FUNCTION__), KTsyCompnt)/*lint -restore*/
+	
+	// N.B. The function name does not need to be specified
+	#define TSYLOGENTRYEXITARGS(aFmt, ARGS...) 	/*lint -save -e40*/ TLogEntryExit __logger(TPtrC8((const TUint8*)__PRETTY_FUNCTION__), KTsyCompnt, (aFmt), ##ARGS)/*lint -restore*/
+
+	#define TSYLOGSETEXITERR(aErr) 	__logger.SetExitErrorCode( aErr )
+
+
+/**
+Automatic class that logs function entry and exit
+*/
+class TLogEntryExit
+	{
+public:
+	IMPORT_C TLogEntryExit(const TDesC8& aFnName, const TDesC8& aLayer);
+	IMPORT_C TLogEntryExit(const TDesC8& aFnName, const TDesC8& aLayer, TRefByValue<const TDesC8> aFmt, ...);
+	IMPORT_C TLogEntryExit(const TDesC8& aFnName, const TDesC8& aLayer, TRefByValue<const TDesC16> aFmt, ...);
+	IMPORT_C ~TLogEntryExit();
+	inline TInt SetExitErrorCode(TInt aErr);
+private:
+	TPtrC8 iFnName;
+	TPtrC8 iLayer;
+	TInt   iErr;
+	}; // class TLogEntryExit
+
+/** 
+Set the error that will be logged at function exit
+
+@param aErr error code to log
+@return the given error code. This is to allow to pipe the function call
+*/
+TInt TLogEntryExit::SetExitErrorCode(TInt aErr)
+	{
+	return iErr = aErr;
+	}
+	
+	
+	
+#else // _DEBUG
+
+	#define TSYLOGENTRYEXIT
+	#define TSYLOGENTRYEXITARGS(aFunc, aFmt, ARGS...)
+	#define TSYLOGSETEXITERR(aErr)	aErr // So that we don't lose the return code in UREL!
+
+	
+/**
+Stub class for urel builds, required for exports.
+*/
+class TLogEntryExit
+	{
+public:
+	IMPORT_C TLogEntryExit(const TDesC8& aFnName, const TDesC8& aLayer);
+	IMPORT_C TLogEntryExit(const TDesC8& aFnName, const TDesC8& aLayer, TRefByValue<const TDesC8> aFmt, ...);
+	IMPORT_C TLogEntryExit(const TDesC8& aFnName, const TDesC8& aLayer, TRefByValue<const TDesC16> aFmt, ...);
+	IMPORT_C ~TLogEntryExit();
+	};
+
+
+
+#endif // _DEBUG
+
+#endif // __LTSYLOGGER_H_
diff -r 4a8d14a1a8ca -r ab1d0f4d2aa4 Telephony/ctsydispatchlayer/exportinc/mltsydispatchcallcontrolinterface.h
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Telephony/ctsydispatchlayer/exportinc/mltsydispatchcallcontrolinterface.h	Thu Aug 12 13:20:01 2010 +0100
@@ -0,0 +1,938 @@
+// Copyright (c) 2008-2009 Nokia Corporation and/or its subsidiary(-ies).
+// All rights reserved.
+// This component and the accompanying materials are made available
+// under the terms of "Eclipse Public License v1.0"
+// which accompanies this distribution, and is available
+// at the URL "http://www.eclipse.org/legal/epl-v10.html".
+//
+// Initial Contributors:
+// Nokia Corporation - initial contribution.
+//
+// Contributors:
+//
+// Description:
+// This file contains all the interfaces classes that can be implemented by
+// the Licensee LTSY relating to CallControl related features.
+//
+
+
+
+
+/**
+ @file
+ @internalAll 
+*/
+
+
+#ifndef MLTSYDISPATCHCALLCONTROLINTERFACE_H_
+#define MLTSYDISPATCHCALLCONTROLINTERFACE_H_
+
+#include <ctsy/ltsy/mltsydispatchinterface.h>
+#include <etelmm.h>
+#include <ctsy/rmmcustomapi.h>
+
+class MLtsyDispatchCallControlAnswer : public MLtsyDispatchInterface
+	{
+public:
+
+	static const TInt KLtsyDispatchCallControlAnswerApiId = KDispatchCallControlFuncUnitId + 1;
+
+	/**
+	 * The CTSY Dispatcher shall invoke this function on receiving the EEtelCallAnswer
+	 * request from the CTSY.
+	 *
+	 * It is a request call that is completed by invoking
+	 * CCtsyDispatcherCallback::CallbackCallControlAnswerComp()
+	 *
+	 * Implementation of this interface should answer the specified incoming call.
+	 *
+	 * @param aCallId The Call ID of the call to answer.
+	 *
+	 * @param aIsIsvCall ETrue if the request to answer the call comes from a
+	 * 3rd party application, EFalse otherwise. This parameter exists in case the
+	 * LTSY wishes to perform special handling of ISV calls.
+	 *
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 *
+	 * @see RCall::AnswerIncomingCall()
+	 * @see RCall::AnswerIncomingCallISV()
+	 * @see CTelephony::AnswerIncomingCall()
+	 */
+	virtual TInt HandleAnswerReqL(TInt aCallId, TBool aIsIsvCall) = 0;
+
+	}; // class MLtsyDispatchCallControlAnswer
+
+
+
+class MLtsyDispatchCallControlHold : public MLtsyDispatchInterface
+	{
+public:
+
+	static const TInt KLtsyDispatchCallControlHoldApiId = KDispatchCallControlFuncUnitId + 2;
+
+	/**
+	 * The CTSY Dispatcher shall invoke this function on receiving the EMobileCallHold
+	 * request from the CTSY.
+	 *
+	 * It is a request call that is completed by invoking
+	 * CCtsyDispatcherCallback::CallbackCallControlHoldComp()
+	 *
+	 * Implementation of this interface should hold the specified call.
+	 *
+	 * @param aCallId The Call ID of the call to hold.
+	 *
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 *
+	 * @see RMobileCall::Hold()
+	 */
+	virtual TInt HandleHoldReqL(TInt aCallId) = 0;
+
+	}; // class MLtsyDispatchCallControlHold
+
+
+
+class MLtsyDispatchCallControlDialEmergency : public MLtsyDispatchInterface
+	{
+public:
+
+	static const TInt KLtsyDispatchCallControlDialEmergencyApiId = KDispatchCallControlFuncUnitId + 3;
+
+	/**
+	 * The CTSY Dispatcher shall invoke this function on receiving the EMobileCallDialEmergencyCall
+	 * request from the CTSY.
+	 *
+	 * It is a request call that is completed by invoking
+	 * CCtsyDispatcherCallback::CallbackCallControlDialEmergencyComp()
+	 *
+	 * Implementation of this interface should dial an emergency call to the specified
+	 * number.
+	 *
+	 * @param aEmergencyNumber The emergency phone number to dial.  The descriptor
+	 * should be of type RMobileENStore::TEmergencyNumber.
+	 *
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 *
+	 * @see RMobileCall::DialEmergencyCall()
+	 */
+	virtual TInt HandleDialEmergencyReqL(const TDes& aEmergencyNumber) = 0;
+
+	}; // class MLtsyDispatchCallControlDialEmergency
+
+
+class MLtsyDispatchCallControlStopDtmfTone : public MLtsyDispatchInterface
+	{
+public:
+
+	static const TInt KLtsyDispatchCallControlStopDtmfToneApiId = KDispatchCallControlFuncUnitId + 4;
+
+	/**
+	 * The CTSY Dispatcher shall invoke this function on receiving the EMobilePhoneStopDTMFTone
+	 * request from the CTSY.
+	 *
+	 * It is a request call that is completed by invoking
+	 * CCtsyDispatcherCallback::CallbackCallControlStopDtmfToneComp()
+	 *
+	 * Implementation of this interface should stop sending the DTMF tone previously
+	 * started by MLtsyDispatchCallControlStartDtmfTone::HandleStartDtmfToneReqL().
+	 *
+	 * @param aCallId Call ID of the connected call the stop request will be sent
+	 * through.
+	 *
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 *
+	 * @see RMobileCall::StopDTMFTone()
+	 */
+	virtual TInt HandleStopDtmfToneReqL(TInt aCallId) = 0;
+
+	}; // class MLtsyDispatchCallControlStopDtmfTone
+
+
+
+class MLtsyDispatchCallControlSetActiveAlsLine : public MLtsyDispatchInterface
+	{
+public:
+
+	static const TInt KLtsyDispatchCallControlSetActiveAlsLineApiId = KDispatchCallControlFuncUnitId + 5;
+
+	/**
+	 * The CTSY Dispatcher shall invoke this function on receiving the EMobilePhoneSetALSLine
+	 * request from the CTSY.
+	 *
+	 * It is a request call that is completed by invoking
+	 * CCtsyDispatcherCallback::CallbackCallControlSetActiveAlsLineComp()
+	 *
+	 * Implementation of this interface should set the active ALS line to that
+	 * specified.
+	 *
+	 * @param aAlsLine The new active ALS line.
+	 *
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 *
+	 * @see RMobilePhone::SetALSLine()
+	 */
+	virtual TInt HandleSetActiveAlsLineReqL(RMobilePhone::TMobilePhoneALSLine aAlsLine) = 0;
+
+	}; // class MLtsyDispatchCallControlSetActiveAlsLine
+
+
+
+class MLtsyDispatchCallControlSendDtmfTonesCancel : public MLtsyDispatchInterface
+	{
+public:
+
+	static const TInt KLtsyDispatchCallControlSendDtmfTonesCancelApiId = KDispatchCallControlFuncUnitId + 6;
+
+	/**
+	 * The CTSY Dispatcher shall invoke this function on receiving the EMobilePhoneSendDTMFTonesCancel
+	 * request from the CTSY.
+	 *
+	 * It is a request call that is completed by invoking
+	 * CCtsyDispatcherCallback::CallbackCallControlSendDtmfTonesCancelComp()
+	 *
+	 * Implementation of this interface should attempt to cancel the sending of
+	 * a string of DTMF tones which were previously sent by
+	 * MLtsyDispatchCallControlSendDtmfTones::HandleSendDtmfTonesReqL()
+	 *
+	 * @param aCallId The Call ID of the active call that the cancel request relates
+	 * to.
+	 *
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 *
+	 * @see RMobilePhone::SendDTMFTones()
+	 */
+	virtual TInt HandleSendDtmfTonesCancelReqL(TInt aCallId) = 0;
+
+	}; // class MLtsyDispatchCallControlSendDtmfTonesCancel
+
+
+
+class MLtsyDispatchCallControlHangUp : public MLtsyDispatchInterface
+	{
+public:
+
+	static const TInt KLtsyDispatchCallControlHangUpApiId = KDispatchCallControlFuncUnitId + 7;
+
+	/**
+	 * The CTSY Dispatcher shall invoke this function on receiving the EEtelCallHangUp
+	 * request from the CTSY.
+	 *
+	 * It is a request call that is completed by invoking
+	 * CCtsyDispatcherCallback::CallbackCallControlHangUpComp()
+	 *
+	 * Implementation of this interface should
+	 * make a request to the modem to hang up the call specified
+	 * in aCallId.  The completion should be called to indicate the result of
+	 * placing the hang up request with the baseband.
+	 *
+	 *  - If aCallId refers to a connected call, the Common TSY will pass
+	 * a hang up cause of KErrGsmReleaseByUser to indicate that the call is
+	 * being released by the user.
+	 *
+	 *  - If aCallId refers to a mobile terminated call which is ringing,
+	 * the Common TSY will pass a hang up cause of KErrGsmBusyUserRequest to
+	 * indicate that the user is rejecting the incoming call.
+	 *
+	 * @param aCallId The Call ID of the call to hang up.
+	 *
+	 * @param aHangupCause The reason for the hang up request.
+	 *
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 *
+	 * @see RCall::HangUp()
+	 */
+	virtual TInt HandleHangUpReqL(TInt aCallId, TInt aHangupCause) = 0;
+
+	}; // class MLtsyDispatchCallControlHangUp
+
+
+
+class MLtsyDispatchCallControlResume : public MLtsyDispatchInterface
+	{
+public:
+
+	static const TInt KLtsyDispatchCallControlResumeApiId = KDispatchCallControlFuncUnitId + 8;
+
+	/**
+	 * The CTSY Dispatcher shall invoke this function on receiving the EMobileCallResume
+	 * request from the CTSY.
+	 *
+	 * It is a request call that is completed by invoking
+	 * CCtsyDispatcherCallback::CallbackCallControlResumeComp()
+	 *
+	 * Implementation of this interface should resume the specified call.
+	 * See 3GPP 24.083
+	 *
+	 * @param aCallId The Call ID of the call to resume.
+	 *
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 *
+	 * @see RMobileCall::Resume()
+	 */
+	virtual TInt HandleResumeReqL(TInt aCallId) = 0;
+
+	}; // class MLtsyDispatchCallControlResume
+
+
+
+class MLtsyDispatchCallControlSetDynamicHscsdParams : public MLtsyDispatchInterface
+	{
+public:
+
+	static const TInt KLtsyDispatchCallControlSetDynamicHscsdParamsApiId = KDispatchCallControlFuncUnitId + 9;
+
+	/**
+	 * The CTSY Dispatcher shall invoke this function on receiving the EMobileCallSetDynamicHscsdParams
+	 * request from the CTSY.
+	 *
+	 * It is a request call that is completed by invoking
+	 * CCtsyDispatcherCallback::CallbackCallControlSetDynamicHscsdParamsComp()
+	 *
+	 * Implementation of this interface should set the dynamic HSCSD parameters
+	 * of the specified data call.
+	 *
+	 * @param aCallId The call ID of the data call.
+	 *
+	 * @param aHscsdParams The requested dynamic HSCSD parameters.
+	 *
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 *
+	 * @see RMobileCall::SetDynamicHscsdParams()
+	 */
+	virtual TInt HandleSetDynamicHscsdParamsReqL(TInt aCallId, const RMobileCall::TMobileHscsdCallParamsV1& aHscsdParams) = 0;
+
+	}; // class MLtsyDispatchCallControlSetDynamicHscsdParams
+
+
+
+class MLtsyDispatchCallControlDialVoice : public MLtsyDispatchInterface
+	{
+public:
+
+	static const TInt KLtsyDispatchCallControlDialVoiceApiId = KDispatchCallControlFuncUnitId + 10;
+
+	/**
+	 * The CTSY Dispatcher shall invoke this function on receiving the EEtelCallDial
+	 * request from the CTSY for dialling a voice call.
+	 *
+	 * It is a request call that is completed by invoking
+	 * CCtsyDispatcherCallback::CallbackCallControlDialVoiceComp()
+	 *
+	 * Implementation of this interface should
+	 * dial the requested voice call and complete the callback to indicate
+	 * that an attempt to dial the call has been made.  The callback function is used
+	 * to indicate the outcome of this attempt to initiate the dialling process.
+	 *
+	 * @param aCallLine The line to use to dial the call. This parameter can have
+	 * one of two possible values RMobilePhone::EAlternateLinePrimary to use the
+	 * primary voice line or RMobilePhone::EAlternateLineAuxiliary to use the
+	 * auxiliary voice line.
+	 *
+	 * @param aDialledParty Details about the dialled party including the phone
+	 * number to dial.
+	 *
+	 * @param aCallParamsV1 The call parameters of the call to dial. If aIsIsvCall
+	 * is set to ETrue, only the RMobileCall::TMobileCallParamsV1::iIdRestrict
+	 * and RMobileCall::TMobileCallParamsV1::iAutoRedial fields are valid.
+	 *
+	 * @param aIsIsvCall Indicates whether the call originated from a third party
+	 * application which would have used the CTelephony class to dial the call.
+	 * This information is provided in case the LTSY wishes to do special handling
+	 * for third party calls, for example, not allow third party applications to
+	 * place emergency calls. See also
+	 * MLtsyDispatchCallControlQueryIsEmergencyNumber::HandleQueryIsEmergencyNumberSyncL()
+	 * See also: CTelephony::DialNewCall() and RMobileCall::DialISV()
+	 *
+	 * @param aCallOrigin The origin of the dial request. e.g. Whether the dial
+	 * came from an Etel client or the SIM or another source.
+	 * 
+	 * @param aPerformFdnCheck whether or not an FDN (Fixed Dialling Number) check should be performed.
+	 *
+	 * @return KErrNone on success; KErrNotSupported if the LTSY does not
+	 * support handling of this request or another error code indicating the
+	 * failure otherwise.
+	 *
+	 * @see RCall::Dial()
+	 * @see RMobileCall::DialISV()
+	 * @see RMobileCall::DialNoFdnCheck()
+	 */
+	virtual TInt HandleDialVoiceReqL(RMobilePhone::TMobilePhoneALSLine aCallLine, const RMobilePhone::TMobileAddress& aDialledParty, const RMobileCall::TMobileCallParamsV1& aCallParamsV1, TBool aIsIsvCall, RMobileCall::TCallParamOrigin aCallOrigin,
+			TBool aPerformFdnCheck) = 0;
+
+	}; // class MLtsyDispatchCallControlDialVoice
+
+
+
+class MLtsyDispatchCallControlTransfer : public MLtsyDispatchInterface
+	{
+public:
+
+	static const TInt KLtsyDispatchCallControlTransferApiId = KDispatchCallControlFuncUnitId + 11;
+
+	/**
+	 * The CTSY Dispatcher shall invoke this function on receiving the EMobileCallTransfer
+	 * request from the CTSY.
+	 *
+	 * It is a request call that is completed by invoking
+	 * CCtsyDispatcherCallback::CallbackCallControlTransferComp()
+	 *
+	 * This request should be completed when the request to transfer the call has
+	 * been placed.
+	 *
+	 * Implementation of this interface should transfer the specified held call.
+	 * Transferring a call can be requested when there is one held call and another
+	 * call either connected or in the ringing state. When the two remote parties
+	 * are transferred to each other, the party requesting this operation (us)
+	 * drops out of the call.
+	 *
+	 * @param aHeldCallId Call ID of the call held call to transfer.
+	 *
+	 * @param aOtherCallId Call ID of the other call to transfer the held call to.
+	 * This call is either an incoming call in the ringing state or a connected call.
+	 *
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 *
+	 * @see RMobileCall::Transfer()
+	 */
+	virtual TInt HandleTransferReqL(TInt aHeldCallId, TInt aOtherCallId) = 0;
+
+	}; // class MLtsyDispatchCallControlTransfer
+
+
+
+class MLtsyDispatchCallControlSendDtmfTones : public MLtsyDispatchInterface
+	{
+public:
+
+	static const TInt KLtsyDispatchCallControlSendDtmfTonesApiId = KDispatchCallControlFuncUnitId + 12;
+
+	/**
+	 * The CTSY Dispatcher shall invoke this function on receiving the EMobilePhoneSendDTMFTones
+	 * request from the CTSY.
+	 *
+	 * It is a request call that is completed by invoking
+	 * CCtsyDispatcherCallback::CallbackCallControlSendDtmfTonesComp()
+	 *
+	 * Implementation of this interface should send the specified DTMF string through
+	 * the currently active call.
+	 *
+	 * @param aCallId The Call ID of the call through which the DTMF string will be
+	 * sent.
+	 *
+	 * @param aTones Tones to send through the active call.
+	 *
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 *
+	 * @see RMobilePhone::SendDTMFTones()
+	 */
+	virtual TInt HandleSendDtmfTonesReqL(TInt aCallId, const TDesC& aTones) = 0;
+
+	}; // class MLtsyDispatchCallControlSendDtmfTones
+
+
+
+class MLtsyDispatchCallControlGetIdentityServiceStatus : public MLtsyDispatchInterface
+	{
+public:
+
+	static const TInt KLtsyDispatchCallControlGetIdentityServiceStatusApiId = KDispatchCallControlFuncUnitId + 13;
+
+	/**
+	 * The CTSY Dispatcher shall invoke this function on receiving the EMobilePhoneGetIdentityServiceStatus
+	 * request from the CTSY.
+	 *
+	 * It is a request call that is completed by invoking
+	 * CCtsyDispatcherCallback::CallbackCallControlGetIdentityServiceStatusComp()
+	 *
+	 * Implementation of this interface should request for the status of the
+	 * specified identity service such as the Caller ID Presentation Service.
+	 *
+	 * @param aService The service whose status needs to be retrieved.
+	 *
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 *
+	 * @see RMobilePhone::GetIdentityServiceStatus()
+	 */
+	virtual TInt HandleGetIdentityServiceStatusReqL(RMobilePhone::TMobilePhoneIdService aService) = 0;
+
+	}; // class MLtsyDispatchCallControlGetIdentityServiceStatus
+
+
+
+class MLtsyDispatchCallControlSwap : public MLtsyDispatchInterface
+	{
+public:
+
+	static const TInt KLtsyDispatchCallControlSwapApiId = KDispatchCallControlFuncUnitId + 14;
+	static const TInt KLtsyDispatchCallControlSingleSwapApiId = KDispatchCallControlFuncUnitId + 29;
+
+	/**
+	 * The CTSY Dispatcher shall invoke this function on receiving the EMobileCallSwap
+	 * request from the CTSY.
+	 *
+	 * It is a request call that is completed by invoking
+	 * CCtsyDispatcherCallback::CallbackCallControlSwapComp()
+	 *
+	 * This request should be completed when the request to swap two calls has
+	 * been placed. One is held and the other connected. The held call becomes connected
+	 * (RMobileCall::EStatusConnected) and the connected call becomes held 
+	 * (RMobileCall::EStatusHold).
+	 *
+	 * Implementation of this interface should request that the Licensee TSY
+	 * swap the specified calls. Swapping is allowed for one or two active calls.
+	 *
+	 * @param aCallId The Call ID of the call to swap.
+	 *
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 *
+	 * @see RMobileCall::Swap()
+	 */
+	virtual TInt HandleSwapReqL(TInt aCallId, TInt aSecondCallId) = 0;
+
+	/**
+	 * The CTSY Dispatcher shall invoke this function on receiving the EMobileCallSwap
+	 * request, for a single call, from the CTSY.
+	 *
+	 * It is a request call that is completed by invoking
+	 * CCtsyDispatcherCallback::CallbackCallControlSwapComp()
+	 *
+	 * This request should be completed when the request to swap the single call has
+	 * been placed.
+	 *
+	 * Implementation of this interface should request that the Licensee TSY
+	 * swap the specified call. The state of the call will be swapped from held to connected 
+	 * (or visa versa)
+	 *
+	 * @param aCallId The Call ID of the single call to swap.
+	 *
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 *
+	 * @see RMobileCall::Swap()
+	 */
+	virtual TInt HandleSwapReqL(TInt aCallId) = 0;
+
+	}; // class MLtsyDispatchCallControlSwap
+
+
+	
+class MLtsyDispatchCallControlLoanDataPort : public MLtsyDispatchInterface
+	{
+public:
+
+	static const TInt KLtsyDispatchCallControlLoanDataPortApiId = KDispatchCallControlFuncUnitId + 15;
+
+	/**
+	 * The CTSY Dispatcher shall invoke this function on receiving the EEtelCallLoanDataPort
+	 * request from the CTSY.
+	 *
+	 * Implementation of this interface should read the port name from CommDat
+	 * for use in a data call. This API may be adaptation specific.
+	 *
+	 * It is a sync call where the output parameters should be completed before returning
+	 * from this function.
+	 *
+	 * @param aCallId Call ID of the data call requiring the data port.
+	 *
+	 * @param aCommPort Output parameter. The communications port information
+	 * retrieved by a client using the RCall::LoanDataPort() API.
+	 *
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 */
+	virtual TInt HandleLoanDataPortSyncL(TInt aCallId, RCall::TCommPort& aCommPort) = 0;
+
+	}; // class MLtsyDispatchCallControlLoanDataPort
+
+
+
+class MLtsyDispatchCallControlRecoverDataPort : public MLtsyDispatchInterface
+	{
+public:
+
+	static const TInt KLtsyDispatchCallControlRecoverDataPortApiId = KDispatchCallControlFuncUnitId + 16;
+
+	/**
+	 * The CTSY Dispatcher shall invoke this function on receiving the EEtelCallRecoverDataPort
+	 * request from the CTSY.
+	 *
+	 * Implementation of this interface should recover the data port loaned by a
+	 * previous call to
+	 * MLtsyDispatchCallControlLoanDataPort::HandleLoanDataPortSyncL()
+	 * and matches a client side call to RCall::RecoverDataPort().
+	 *
+	 * It is a sync call where the data arguments should be completed before returning.
+	 *
+	 * @param aCallId Call ID of the data call requiring the data port.
+	 *
+	 * @param aCommPort The data port to recover.  This contains the details previously
+	 * returned by a call to RCall::LoanDataPort()
+	 *
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 */
+	virtual TInt HandleRecoverDataPortSyncL(TInt aCallId, RCall::TCommPort& aCommPort) = 0;
+
+	}; // class MLtsyDispatchCallControlRecoverDataPort
+
+
+
+class MLtsyDispatchCallControlStartDtmfTone : public MLtsyDispatchInterface
+	{
+public:
+
+	static const TInt KLtsyDispatchCallControlStartDtmfToneApiId = KDispatchCallControlFuncUnitId + 17;
+
+	/**
+	 * The CTSY Dispatcher shall invoke this function on receiving the EMobilePhoneStartDTMFTone
+	 * request from the CTSY.
+	 *
+	 * Implementation of this interface should send the specified DTMF tone
+	 * through the currently active call.
+	 *
+	 * @param aCallId Call ID of the connected call through which the DTMF tone
+	 * will be sent.
+	 *
+	 * @param aTone The tone character to send through the call.
+	 *
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 *
+	 * @see RMobilePhone::StartDTMFTone()
+	 */
+	virtual TInt HandleStartDtmfToneReqL(TInt aCallId, const TChar& aTone) = 0;
+
+	}; // class MLtsyDispatchCallControlStartDtmfTone
+
+
+
+
+class MLtsyDispatchCallControlGetActiveAlsLine : public MLtsyDispatchInterface
+	{
+public:
+	static const TInt KLtsyDispatchCallControlGetActiveAlsLineApiId = KDispatchCallControlFuncUnitId + 18;
+
+public:
+
+	/**
+	 * The CTSY Dispatcher shall invoke this function on receiving the EMobilePhoneGetActiveAlsLine
+	 * request from the CTSY.
+	 *
+	 * It is a request call that is completed by invoking
+	 * CCtsyDispatcherCallback::CallbackCallControlGetActiveAlsLineComp()
+	 *
+	 * Implementation of this interface should retrieve the currently selected ALS line.
+	 *
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 *
+	 * @see RMobilePhone::GetALSLine()
+	 */
+	virtual TInt HandleGetActiveAlsLineReqL() = 0;
+
+	}; // class MLtsyDispatchCallControlGetActiveAlsLine
+
+
+class MLtsyDispatchCallControlDialData : public MLtsyDispatchInterface
+	{
+public:
+	static const TInt KLtsyDispatchCallControlDialDataApiId = KDispatchCallControlFuncUnitId + 19;
+public:
+
+	/**
+	 * The CTSY Dispatcher shall invoke this function on receiving the EEtelCallDial
+	 * request from the CTSY when a data call is requested.
+	 *
+	 * It is a request call that is completed by invoking
+	 * CCtsyDispatcherCallback::CallbackCallControlDialDataComp()
+	 *
+	 * Implementation of this interface should dial the data call to the
+	 * specified destination. The callback should be completed when the dial
+	 * request has been sent to the baseband and should indicate
+	 * that an attempt to dial the call has been made.  The callback function is used
+	 * to indicate the outcome of this attempt to initiate the dialling process.
+	 *
+	 * @param aLine The line to use to dial the call.
+	 *
+	 * @param aDialledParty Details about the dialled party including the phone
+	 * number to dial.
+	 *
+	 * @param aCallParamsV1 The call parameters of the call to dial.
+	 * 
+	 * @param aPerformFdnCheck whether or not an FDN (Fixed Dialling Number) check should be performed.
+	 *
+	 * @return KErrNone on success; KErrNotSupported if the LTSY does not
+	 * support handling of this request or another error code indicating the
+	 * failure otherwise.
+	 *
+	 * @see RCall::Dial()
+	 */
+	virtual TInt HandleDialDataReqL(const RMobilePhone::TMobileAddress& aDialledParty, const RMobileCall::TMobileDataCallParamsV1& aCallParamsV1,
+			TBool aPerformFdnCheck) = 0;
+
+	}; // class MLtsyDispatchCallControlDialData
+
+
+class MLtsyDispatchCallControlQueryIsEmergencyNumber : public MLtsyDispatchInterface
+	{
+public:
+	static const TInt KLtsyDispatchCallControlQueryIsEmergencyNumberApiId = KDispatchCallControlFuncUnitId + 20;
+public:
+
+	/**
+	 * The CTSY Dispatcher shall invoke this function on receiving the
+	 * ECustomCheckEmergencyNumberIPC request from the CTSY.
+	 *
+	 * It is a sync call where the output data arguments should be completed
+	 * before returning.
+	 *
+	 * Implementation of this interface should check whether the specified
+	 * number is an emergency number and return the result back to the caller
+	 * via the output parameter.
+	 *
+	 * @param aNumber Input parameter. The phone number being queried to see
+	 * if it is an emergency number or not.
+	 *
+	 * @param aIsEmergencyNumber Output parameter used to indicate whether the
+	 * aNumber parameter is an emergency number. ETrue if it is, EFalse otherwise.
+	 *
+	 * @return KErrNone if the LTSY was successful in determining whether the
+	 * queried number is an emergency one; KErrNotSupported if the LTSY does not
+	 * support handling of this request or another error code indicating the
+	 * failure otherwise.
+	 */
+	virtual TInt HandleQueryIsEmergencyNumberSyncL(const TDesC& aNumber, TBool& aIsEmergencyNumber) = 0;
+
+	}; // class MLtsyDispatchCallControlQueryIsEmergencyNumber
+
+
+class MLtsyDispatchCallControlGetAlsPpSupport : public MLtsyDispatchInterface
+	{
+public:
+
+	static const TInt KLtsyDispatchCallControlGetAlsPpSupportApiId = KDispatchCallControlFuncUnitId + 21;
+
+	/**
+	 * The CTSY Dispatcher shall invoke this function on receiving the ECustomCheckAlsPpSupportIPC
+	 * request from the CTSY.
+	 *
+	 * It is a request call that is completed by invoking
+	 * CCtsyDispatcherCallback::CallbackCallControlGetAlsPpSupportComp()
+	 *
+	 * Implementation of this interface should return check if the product profile support ALS.
+	 *
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 *
+	 * @see RMmCustomAPI::CheckAlsPpSupport()
+	 */
+	virtual TInt HandleGetAlsPpSupportL() = 0;
+
+	}; // class MLtsyDispatchCallControlGetAlsPpSupport
+
+
+class MLtsyDispatchCallControlGetAlsBlockedStatus : public MLtsyDispatchInterface
+	{
+public:
+
+	static const TInt KLtsyDispatchCallControlGetAlsBlockedStatusApiId = KDispatchCallControlFuncUnitId + 22;
+
+	/**
+	 * The CTSY Dispatcher shall invoke this function on receiving the ECustomGetAlsBlockedIPC
+	 * request from the CTSY.
+	 *
+	 * It is a request call that is completed by invoking
+	 * CCtsyDispatcherCallback::CallbackCallControlGetAlsBlockedStatusComp()
+	 *
+	 * Implementation of this interface should return the blocked status of the ALS service.
+	 *
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 *
+	 * @see RMmCustomAPI::GetAlsBlocked()
+	 */
+	virtual TInt HandleGetAlsBlockedStatusL() = 0;
+
+	}; // class MLtsyDispatchCallControlGetAlsBlockedStatus
+
+
+class MLtsyDispatchCallControlSetAlsBlocked : public MLtsyDispatchInterface
+	{
+public:
+
+	static const TInt KLtsyDispatchCallControlSetAlsBlockedApiId = KDispatchCallControlFuncUnitId + 23;
+
+	/**
+	 * The CTSY Dispatcher shall invoke this function on receiving the ECustomSetAlsBlockedIPC
+	 * request from the CTSY.
+	 *
+	 * It is a request call that is completed by invoking
+	 * CCtsyDispatcherCallback::CallbackCallControlSetAlsBlockedComp()
+	 *
+	 * Implementation of this interface should set the ALS blocked status.
+	 *
+     * @param aBlocked RMmCustomAPI::EDeactivateBlock when the ALS block needs to be deactivated,
+     *                 RMmCustomAPI::EActivateBlock when the ALS block needs to be activated.
+     *
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 *
+	 * @see RMmCustomAPI::SetAlsBlocked()
+	 */
+	virtual TInt HandleSetAlsBlockedL(RMmCustomAPI::TSetAlsBlock aBlocked) = 0;
+
+	}; // class MLtsyDispatchCallControlSetAlsBlocked
+
+
+class MLtsyDispatchCallControlGetLifeTime : public MLtsyDispatchInterface
+	{
+public:
+
+	static const TInt KLtsyDispatchCallControlGetLifeTimeApiId = KDispatchCallControlFuncUnitId + 24;
+
+	/**
+	 * The CTSY Dispatcher shall invoke this function on receiving the ECustomGetLifeTimeIPC
+	 * request from the CTSY.
+	 *
+	 * It is a request call that is completed by invoking one of the 
+	 * CCtsyDispatcherCallback::CallbackCallControlGetLifeTimeComp()
+	 *
+	 * Implementation of this interface should return the lifetime of the phone. The lifetime
+     * information includes the manufacturing date of the phone and/or the total amount of air time used
+     * from the manufacturing date until the call to this method. Calling this method does not reset any data. 
+	 *
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 *
+	 * @see RMmCustomAPI::GetLifeTime()
+	 */
+	virtual TInt HandleGetLifeTimeL() = 0;
+
+	}; // class MLtsyDispatchCallControlGetLifeTimeStatus
+
+
+class MLtsyDispatchCallControlTerminateErrorCall : public MLtsyDispatchInterface
+	{
+public:
+
+	static const TInt KLtsyDispatchCallControlTerminateErrorCallApiId = KDispatchCallControlFuncUnitId + 25;
+
+	/**
+	 * The CTSY Dispatcher shall invoke this function on receiving the ECustomTerminateCallIPC
+	 * request from the CTSY with a valid call id.
+	 *
+	 * It is a request call that is completed by invoking
+	 * CCtsyDispatcherCallback::CallbackCallControlTerminateErrorCallComp()
+	 *
+	 * Implementation of this interface should terminate the call with an error.
+	 *
+	 * @param aCallId The Call ID of the call to terminate.
+     *
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 *
+	 * @see RMmCustomAPI::TerminateCall()
+	 */
+	virtual TInt HandleTerminateErrorCallL(TInt aCallId) = 0;
+
+	}; // class MLtsyDispatchCallControlTerminateErrorCall
+
+
+class MLtsyDispatchCallControlTerminateAllCalls : public MLtsyDispatchInterface
+	{
+public:
+
+	static const TInt KLtsyDispatchCallControlTerminateAllCallsApiId = KDispatchCallControlFuncUnitId + 26;
+
+	/**
+	 * The CTSY Dispatcher shall invoke this function on receiving the ECustomTerminateCallIPC
+	 * request from the CTSY with an invalid call id.
+	 *
+	 * It is a request call that is completed by invoking
+	 * CCtsyDispatcherCallback::CallbackCallControlTerminateAllCallsComp()
+	 *
+	 * Implementation of this interface should terminate all the active, connecting and held calls.
+	 *
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 *
+	 * @see RMmCustomAPI::TerminateCall()
+	 */
+	virtual TInt HandleTerminateAllCallsL() = 0;
+
+	}; // class MLtsyDispatchCallControlTerminateAllCalls
+
+
+class MLtsyDispatchCallControlGetCallForwardingIndicator : public MLtsyDispatchInterface
+	{
+public:
+
+	static const TInt KLtsyDispatchCallControlGetCallForwardingIndicatorApiId = KDispatchCallControlFuncUnitId + 27;
+
+	/**
+	 * The CTSY Dispatcher shall invoke this function on receiving the ECustomGetIccCallForwardingStatusIPC
+	 * request from the CTSY.
+	 *
+	 * It is a request call that is completed by invoking one of the 
+	 * CCtsyDispatcherCallback::CallbackCallControlGetCallForwardingIndicatorComp()
+	 *
+	 * Implementation of this interface should return the call forwarding indicator from the network.
+	 *
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 *
+	 * @see RMmCustomAPI::GetIccCallForwardingIndicatorStatus()
+	 */
+	virtual TInt HandleGetCallForwardingIndicatorL() = 0;
+
+	}; // class MLtsyDispatchCallControlGetCallForwardingIndicator
+
+class MLtsyDispatchCallControlUpdateLifeTimer : public MLtsyDispatchInterface
+	{
+public:
+	static const TInt KLtsyDispatchCallControlUpdateLifeTimerApiId = KDispatchCallControlFuncUnitId + 28;
+public:
+
+	/**
+	 * The CTSY Dispatcher shall invoke this function on receiving the
+	 * ECtsyUpdateLifeTimeReq request from the CTSY.
+	 *
+	 * It is a request call that is completed by invoking
+	 * CCtsyDispatcherCallback::CallbackCallControlUpdateLifeTimerComp()
+	 *
+	 * Implementation of this interface can accumulate the number of seconds that
+	 * have elapsed since a call started. By initialising a variable in the LTSY when a 
+	 * call is dialed, then adding the value contained in aDuration to this variable 
+	 * it is possible to track the duration of a call.
+	 * 
+	 * HandleUpdateLifeTimerReqL is usually invoked every 10 seconds.
+	 *
+	 * @param aDuration The number of seconds that have elapsed since the last time
+	 * this interface was invoked (or since the start of the call if the first invocation).
+	 *
+	 * @return KErrNone if the LTSY was successful; KErrNotSupported if the LTSY does not
+	 * support handling of this request or another error code indicating the
+	 * failure otherwise.
+	 */
+	virtual TInt HandleUpdateLifeTimerReqL(TUint32 aDuration) = 0;
+
+	}; // class MLtsyDispatchCallControlUpdateLifeTimer
+
+	
+// Note: A static constant has been defined in MLtsyDispatchCallControlSwap (abbove) with the highest Id 
+// in this file... "KLtsyDispatchCallControlSingleSwapApiId = KDispatchCallControlFuncUnitId + 29"
+// If adding a new Id it must be greater than KDispatchCallControlFuncUnitId + 29.
+
+#endif /*MLTSYDISPATCHCALLCONTROLINTERFACE_H_*/
diff -r 4a8d14a1a8ca -r ab1d0f4d2aa4 Telephony/ctsydispatchlayer/exportinc/mltsydispatchcallcontrolmultipartyinterface.h
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Telephony/ctsydispatchlayer/exportinc/mltsydispatchcallcontrolmultipartyinterface.h	Thu Aug 12 13:20:01 2010 +0100
@@ -0,0 +1,203 @@
+// Copyright (c) 2008-2009 Nokia Corporation and/or its subsidiary(-ies).
+// All rights reserved.
+// This component and the accompanying materials are made available
+// under the terms of "Eclipse Public License v1.0"
+// which accompanies this distribution, and is available
+// at the URL "http://www.eclipse.org/legal/epl-v10.html".
+//
+// Initial Contributors:
+// Nokia Corporation - initial contribution.
+//
+// Contributors:
+//
+// Description:
+// This file contains all the interfaces classes that can be implemented by
+// the Licensee LTSY relating to CallControlMultiparty related features.
+//
+
+
+
+
+/**
+ @file
+ @internalAll 
+*/
+
+
+#ifndef MLTSYDISPATCHCALLCONTROLMULTIPARTYINTERFACE_H_
+#define MLTSYDISPATCHCALLCONTROLMULTIPARTYINTERFACE_H_
+
+#include <ctsy/ltsy/mltsydispatchinterface.h>
+
+class MLtsyDispatchCallControlMultipartyConferenceHangUp : public MLtsyDispatchInterface
+	{
+public:
+
+	static const TInt KLtsyDispatchCallControlMultipartyConferenceHangUpApiId = KDispatchCallControlMultipartyFuncUnitId + 1;
+
+	/**
+	 * The CTSY Dispatcher shall invoke this function on receiving the EMobileConferenceCallHangUp
+	 * request from the CTSY.
+	 *
+	 * It is a request call that is completed by invoking
+	 * CCtsyDispatcherCallback::CallbackCallControlMultipartyConferenceHangUpComp()
+	 *
+	 * Implementation of this interface should terminate the active conference call.
+	 *
+	 * @param aCallIds Array of all Call IDs, which belong to the conference.
+	 * This array will be destroyed after the function call returns.
+	 *
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 *
+	 * @see RMobileConferenceCall::HangUp()
+	 */
+	virtual TInt HandleConferenceHangUpReqL(const RArray<TInt>& aCallIds) = 0;
+
+	}; // class MLtsyDispatchCallControlMultipartyConferenceHangUp
+
+
+
+class MLtsyDispatchCallControlMultipartyConferenceAddCall : public MLtsyDispatchInterface
+	{
+public:
+
+	static const TInt KLtsyDispatchCallControlMultipartyConferenceAddCallApiId = KDispatchCallControlMultipartyFuncUnitId + 2;
+
+	/**
+	 * The CTSY Dispatcher shall invoke this function on receiving the EMobileConferenceCallAddCall
+	 * request from the CTSY.
+	 *
+	 * It is a request call that is completed by invoking
+	 * CCtsyDispatcherCallback::CallbackCallControlMultipartyConferenceAddCallComp()
+	 *
+	 * Implementation of this interface should add the specified call to the conference
+	 * call.  Typically, there will be an ongoing conference call containing at least
+	 * 2 remote parties.  The conference call gets swapped into the held state and
+	 * either a new call is dialled or an incoming call is answered.  This call can
+	 * then be added to the conference call using this API.
+	 *
+	 *
+	 * @param aCallId The Call ID of the connected call to be added to the multiparty (conference) call.
+	 * @param aExistingCallId The Call ID of one of the calls which is already a part of the conference call.
+	 * This can be the Call ID of any of the existing calls in the conference, not necessarily the first one that was added.
+	 *
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 *
+	 * @see RMobileconferenceCall::AddCall()
+	 */
+	virtual TInt HandleConferenceAddCallReqL(TInt aCallId, TInt aExistingCallId) = 0;
+
+	}; // class MLtsyDispatchCallControlMultipartyConferenceAddCall
+
+
+
+class MLtsyDispatchCallControlMultipartyCreateConference : public MLtsyDispatchInterface
+	{
+public:
+
+	static const TInt KLtsyDispatchCallControlMultipartyCreateConferenceApiId = KDispatchCallControlMultipartyFuncUnitId + 3;
+
+	/**
+	 * The CTSY Dispatcher shall invoke this function on receiving the EMobileConferenceCallCreateConference
+	 * request from the CTSY.
+	 *
+	 * It is a request call that is completed by invoking
+	 * CCtsyDispatcherCallback::CallbackCallControlMultipartyCreateConferenceComp()
+	 *
+	 * Implementation of this interface should join the two specified calls into a
+	 * multiparty (conference) call.
+	 *
+	 *
+	 * @param aHeldCallId The Call ID of the held call which will be one of the calls
+	 * joined to the conference.
+	 *
+	 * @param aSecondCallId The Call ID of the active / alerting call which will be
+	 * the other call joined to the conference.
+	 *
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 *
+	 * @see RMobileConferenceCall::CreateConference()
+	 */
+	virtual TInt HandleCreateConferenceReqL(TInt aHeldCallId, TInt aSecondCallId) = 0;
+
+	}; // class MLtsyDispatchCallControlMultipartyCreateConference
+
+
+
+class MLtsyDispatchCallControlMultipartyConferenceSwap : public MLtsyDispatchInterface
+	{
+public:
+
+	static const TInt KLtsyDispatchCallControlMultipartyConferenceSwapApiId = KDispatchCallControlMultipartyFuncUnitId + 4;
+
+	/**
+	 * The CTSY Dispatcher shall invoke this function on receiving the EMobileConferenceCallSwap
+	 * request from the CTSY.
+	 *
+	 * It is a request call that is completed by invoking
+	 * CCtsyDispatcherCallback::CallbackCallControlMultipartyConferenceSwapComp()
+	 *
+	 * Implementation of this interface should swap the ongoing conference call and
+	 * the other call. If the conference call is on hold,
+	 * it will become connected and the other call will be held.
+	 *
+	 * If it is connected, it will be put on hold and the other call will become
+	 * connected.
+	 *
+	 * @param aHeldCallId The Call ID of the currently held call. If the conference
+	 * call is on hold then this will be the call ID of one of the calls in the
+	 * conference.
+	 *
+	 * @param aConnectedCallId The Call ID of the currently connected call.
+	 * If the conference call is connected then this will be the call ID of one
+	 * of the calls in the conference.
+	 *
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 *
+	 * @see RMobileConferenceCall::Swap()
+	 */
+	virtual TInt HandleConferenceSwapReqL(TInt aHeldCallId, TInt aConnectedCallId) = 0;
+
+	}; // class MLtsyDispatchCallControlMultipartyConferenceSwap
+
+
+class MLtsyDispatchCallControlMultipartyConferenceGoOneToOne : public MLtsyDispatchInterface
+	{
+public:
+
+	static const TInt KLtsyDispatchCallControlMultipartyConferenceGoOneToOneApiId = KDispatchCallControlMultipartyFuncUnitId + 5;
+
+	/**
+	 * The CTSY Dispatcher shall invoke this function on receiving the EMobileCallGoOneToOne
+	 * request from the CTSY.
+	 *
+	 * It is a request call that is completed by invoking
+	 * CCtsyDispatcherCallback::CallbackCallControlMultipartyConferenceGoOneToOneComp()
+	 *
+	 * Implementation of this interface should setup a private communication with the specified call
+	 * in the conference.  This call will then become connected when the call status notification
+	 * arrives from the LTSY and the other call(s) will go on hold.
+	 *
+	 * If at the time of the go one-to-one request, there are two remote parties in the conference
+	 * call, after the one to one is successful, the other call will go on hold and the conference
+	 * will go idle (as there are not enough participants to be a valid conference anymore). If there
+	 * are more than two remote parties in the conference call, then the conference call should go
+	 * on hold.
+	 *
+	 * @param aCallId The Call ID of the call which the client wishes to set up a private communication with.
+	 * This should be a call currently in the conference.
+	 *
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 *
+	 * @see RMobileCall::GoOneToOne()
+	 */
+	virtual TInt HandleConferenceGoOneToOneReqL(TInt aCallId) = 0;
+
+	}; // class MLtsyDispatchCallControlMultipartyConferenceGoOneToOne
+
+#endif /*MLTSYDISPATCHCALLCONTROLMULTIPARTYINTERFACE_H_*/
diff -r 4a8d14a1a8ca -r ab1d0f4d2aa4 Telephony/ctsydispatchlayer/exportinc/mltsydispatchcellbroadcastinterface.h
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Telephony/ctsydispatchlayer/exportinc/mltsydispatchcellbroadcastinterface.h	Thu Aug 12 13:20:01 2010 +0100
@@ -0,0 +1,207 @@
+// Copyright (c) 2008-2009 Nokia Corporation and/or its subsidiary(-ies).
+// All rights reserved.
+// This component and the accompanying materials are made available
+// under the terms of "Eclipse Public License v1.0"
+// which accompanies this distribution, and is available
+// at the URL "http://www.eclipse.org/legal/epl-v10.html".
+//
+// Initial Contributors:
+// Nokia Corporation - initial contribution.
+//
+// Contributors:
+//
+// Description:
+// This file contains all the interfaces classes that can be implemented by
+// the Licensee LTSY relating to CellBroadcast related features.
+//
+
+
+
+
+/**
+ @file
+ @internalAll 
+*/
+
+
+#ifndef MLTSYDISPATCHCELLBROADCASTINTERFACE_H_
+#define MLTSYDISPATCHCELLBROADCASTINTERFACE_H_
+
+#include <ctsy/ltsy/mltsydispatchinterface.h>
+#include <etelmm.h>
+
+
+namespace DispatcherCellBroadcast
+	{
+	
+	/**
+	 * This namespace contains all types relating to the Cell Broadcast dispatcher.
+	 */
+	
+	
+	struct TWcdmaCbsMsgBase
+		{
+	    /*
+	     * Number of Pages
+	     */
+		TInt iNumberOfPages;
+
+	    /*
+	     * Message Type
+	     */ 			
+		TUint8 iMessageType;
+
+	    /*
+	     * Message ID
+	     */ 		
+		TUint16 iMessageId;
+
+	    /*
+	     * Serial Number
+	     */
+		TUint16 iSerialNum;
+		
+	    /*
+	     * Data Coding Scheme
+	     */
+		TUint8 iDCS;
+
+	    /*
+	     * Info length
+	     */
+		TUint8 iInfoLength;
+		};
+
+	}
+
+class MLtsyDispatchCellBroadcastSetBroadcastFilterSetting : public MLtsyDispatchInterface
+	{
+public:
+
+	static const TInt KLtsyDispatchCellBroadcastSetBroadcastFilterSettingApiId = KDispatchCellBroadcastFuncUnitId + 1;
+
+	/**
+	 * The CTSY Dispatcher shall invoke this function on receiving the EMobileBroadcastMessagingSetFilterSetting
+	 * request from the CTSY.
+	 *
+	 * It is a request call that is completed by invoking
+	 * CCtsyDispatcherCallback::CallbackCellBroadcastSetBroadcastFilterSettingComp()
+	 * 
+	 * Implementation of this interface sets a new value for the filter setting.
+	 * The filter specifies which broadcast messages are accepted and which are rejected
+	 *
+	 *
+     * @param aFilterSetting struct settings for a filter to accept/reject messages
+	 *
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 * 
+	 * @see RMobileBroadcastMessaging::SetFilterSetting()
+	 */
+	virtual TInt HandleSetBroadcastFilterSettingReqL(RMobileBroadcastMessaging::TMobilePhoneBroadcastFilter aFilterSetting) = 0;
+
+	}; // class MLtsyDispatchCellBroadcastSetBroadcastFilterSetting
+
+
+
+class MLtsyDispatchCellBroadcastActivateBroadcastReceiveMessage : public MLtsyDispatchInterface
+	{
+public:
+
+	static const TInt KLtsyDispatchCellBroadcastActivateBroadcastReceiveMessageApiId = KDispatchCellBroadcastFuncUnitId + 2;
+
+	/**
+	 * The CTSY Dispatcher shall invoke this function on receiving the EMobileBroadcastMessagingReceiveMessage
+	 * request from the CTSY.
+	 *
+	 * It is a request call that is completed by invoking
+	 * CCtsyDispatcherCallback::CallbackCellBroadcastActivateBroadcastReceiveMessageComp()
+	 * 
+	 * RMobileBroadcastMessaging::ReceiveMessage will be completed when a new incoming broadcast message has been received
+	 * via CallbackCellBroadcastGsmBroadcastNotifyMessageReceivedInd() or CallbackCellBroadcastWcdmaBroadcastMessageReceivedInd()
+	 * 
+     * @param aFilterSetting struct settings for a filter to accept/reject messages
+	 *
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 * 
+	 * @see RMobileBroadcastMessaging::ReceiveMessage()
+	 * @see CCtsyDispatcherCallback::CallbackCellBroadcastGsmBroadcastNotifyMessageReceivedInd()
+	 * @see CCtsyDispatcherCallback::CallbackCellBroadcastWcdmaBroadcastMessageReceivedInd()
+	 */
+	virtual TInt HandleActivateBroadcastReceiveMessageReqL(RMobileBroadcastMessaging::TMobilePhoneBroadcastFilter aFilterSetting) = 0;
+
+	}; // class MLtsyDispatchCellBroadcastActivateBroadcastReceiveMessage
+
+
+
+class MLtsyDispatchCellBroadcastReceiveMessageCancel : public MLtsyDispatchInterface
+	{
+public:
+
+	static const TInt KLtsyDispatchCellBroadcastReceiveMessageCancelApiId = KDispatchCellBroadcastFuncUnitId + 3;
+
+	/**
+	 * The CTSY Dispatcher shall invoke this function on receiving the EMobileBroadcastMessagingReceiveMessageCancel
+	 * request from the CTSY.
+	 *
+	 * It is a request call that is completed by invoking
+	 * CCtsyDispatcherCallback::CallbackCellBroadcastReceiveMessageCancelComp()
+	 *
+	 *
+     * @param aFilterSetting struct settings for a filter to accept/reject messages
+	 *
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 * 
+	 * @see RMobileBroadcastMessaging::ReceiveMessage()
+	 * @see RMobileBroadcastMessaging::Close()
+	 */
+	virtual TInt HandleReceiveMessageCancelReqL(RMobileBroadcastMessaging::TMobilePhoneBroadcastFilter aFilterSetting ) = 0;
+
+	}; // class MLtsyDispatchCellBroadcastReceiveMessageCancel
+	
+class MLtsyDispatchCellBroadcastStartSimCbTopicBrowsing : public MLtsyDispatchInterface
+	{
+public:
+
+	static const TInt KLtsyDispatchCellBroadcastStartSimCbTopicBrowsingApiId = KDispatchCellBroadcastFuncUnitId + 4;
+
+	/**
+	 * The CTSY Dispatcher shall invoke this function on receiving the ECustomStartSimCbTopicBrowsingIPC
+	 * request from the CTSY.
+	 *
+	 * It is a request call that is completed by invoking
+	 * CCtsyDispatcherCallback::CallbackCellBroadcastStartSimCbTopicBrowsingComp()
+	 *     
+	 *
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 */
+	virtual TInt HandleStartSimCbTopicBrowsingReqL() = 0;
+
+	}; // class MLtsyDispatchCellBroadcastStartSimCbTopicBrowsing	
+
+class MLtsyDispatchCellBroadcastDeleteSimCbTopic : public MLtsyDispatchInterface
+	{
+public:
+
+	static const TInt KLtsyDispatchCellBroadcastDeleteSimCbTopicApiId = KDispatchCellBroadcastFuncUnitId + 5;
+
+	/**
+	 * The CTSY Dispatcher shall invoke this function on receiving the ECustomDeleteSimCbTopicIPC
+	 * request from the CTSY.
+	 *
+	 * It is a request call that is completed by invoking
+	 * CCtsyDispatcherCallback::CallbackCellBroadcastDeleteSimCbTopicComp()
+	 *     
+	 *
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 */
+	virtual TInt HandleDeleteSimCbTopicReqL(TUint aIndex, TBool aDeleteFlag) = 0;
+
+	}; // class MLtsyDispatchCellBroadcastDeleteSimCbTopic	
+
+
+#endif /*MLTSYDISPATCHCELLBROADCASTINTERFACE_H_*/
diff -r 4a8d14a1a8ca -r ab1d0f4d2aa4 Telephony/ctsydispatchlayer/exportinc/mltsydispatchinterface.h
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Telephony/ctsydispatchlayer/exportinc/mltsydispatchinterface.h	Thu Aug 12 13:20:01 2010 +0100
@@ -0,0 +1,71 @@
+// Copyright (c) 2008-2009 Nokia Corporation and/or its subsidiary(-ies).
+// All rights reserved.
+// This component and the accompanying materials are made available
+// under the terms of "Eclipse Public License v1.0"
+// which accompanies this distribution, and is available
+// at the URL "http://www.eclipse.org/legal/epl-v10.html".
+//
+// Initial Contributors:
+// Nokia Corporation - initial contribution.
+//
+// Contributors:
+//
+// Description:
+//
+
+
+
+/**
+ @file
+ @internalAll 
+*/
+
+#ifndef MLTSYDISPATCHINTERFACE_H_
+#define MLTSYDISPATCHINTERFACE_H_
+
+#include <e32std.h>
+#include <e32def.h>
+
+typedef const TInt TLtsyCallbackIndId;
+typedef const TInt TLtsyDispatchInterfaceApiId;
+
+// Offsets of IDs used to identify API calls and also indicator callbacks
+const TInt KDispatchCallControlFuncUnitId = 0;
+const TInt KDispatchPhoneFuncUnitId = 2000;
+const TInt KDispatchSecurityFuncUnitId = 4000;
+const TInt KDispatchPhonebookEnFuncUnitId = 6000;
+const TInt KDispatchCellBroadcastFuncUnitId = 8000;
+const TInt KDispatchPhonebookOnFuncUnitId = 10000;
+const TInt KDispatchPhonebookFuncUnitId = 12000;
+const TInt KDispatchSimFuncUnitId = 14000;
+const TInt KDispatchSmsFuncUnitId = 16000;
+const TInt KDispatchCallControlMultipartyFuncUnitId = 18000;
+const TInt KDispatchSupplementaryServicesFuncUnitId = 20000;
+const TInt KDispatchPacketServicesFuncUnitId = 22000;
+const TInt KDispatchSatFuncUnitId = 24000;
+
+/**
+ * Identifies the group that a set of IDs belong to.  
+ * Used with MLtsyDispatchFactoryV1::IsCallbackIndicatorSupported
+ *
+ * @see MLtsyDispatchFactoryV1::IsCallbackIndicatorSupported
+ */
+enum TLtsyDispatchIndIdGroup
+	{	
+	EIndIdGroup1, //< Callback indicator IDs 1 to 32
+	EIndIdGroup2, //< Callback indicator IDs 33 to 63
+	EIndIdGroup3  //< Callback indicator IDs 64 to 95
+	};
+
+class MLtsyDispatchInterface
+/**
+ * Base class from which all dispatch interfaces to be implemented by the Licensee LTSY
+ * derive.
+ */
+	{
+public:
+
+
+	}; // class MLtsyDispatchInterface
+
+#endif /*MLTSYDISPATCHINTERFACE_H_*/
diff -r 4a8d14a1a8ca -r ab1d0f4d2aa4 Telephony/ctsydispatchlayer/exportinc/mltsydispatchpacketservicesinterface.h
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Telephony/ctsydispatchlayer/exportinc/mltsydispatchpacketservicesinterface.h	Thu Aug 12 13:20:01 2010 +0100
@@ -0,0 +1,789 @@
+// Copyright (c) 2008-2009 Nokia Corporation and/or its subsidiary(-ies).
+// All rights reserved.
+// This component and the accompanying materials are made available
+// under the terms of "Eclipse Public License v1.0"
+// which accompanies this distribution, and is available
+// at the URL "http://www.eclipse.org/legal/epl-v10.html".
+//
+// Initial Contributors:
+// Nokia Corporation - initial contribution.
+//
+// Contributors:
+//
+// Description:
+// This file contains all the interfaces classes that can be implemented by
+// the Licensee LTSY relating to PacketServices related features.
+//
+
+
+
+
+/**
+ @file
+ @internalAll 
+*/
+
+
+#ifndef MLTSYDISPATCHPACKETSERVICESINTERFACE_H_
+#define MLTSYDISPATCHPACKETSERVICESINTERFACE_H_
+
+#include <ctsy/ltsy/mltsydispatchinterface.h>
+#include <etelpckt.h>
+#include <etelqos.h>
+
+
+
+
+class MLtsyDispatchPacketServicesPacketAttach : public MLtsyDispatchInterface
+	{
+public:
+
+	static const TInt KLtsyDispatchPacketServicesPacketAttachApiId = KDispatchPacketServicesFuncUnitId + 1;
+
+	/**
+	 * The CTSY Dispatcher shall invoke this function on receiving the EPacketAttach
+	 * request from the CTSY.
+	 *
+	 * It is a request call that is completed by invoking
+	 * CCtsyDispatcherCallback::CallbackPacketServicesPacketAttachComp()
+	 *
+	 * Implementation of this interface should issue an attach request to the LTSY.
+	 * 	
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 */
+	virtual TInt HandlePacketAttachReqL() = 0;
+
+	}; // class MLtsyDispatchPacketServicesPacketAttach
+
+
+
+class MLtsyDispatchPacketServicesGetPacketAttachMode : public MLtsyDispatchInterface
+	{
+public:
+
+	static const TInt KLtsyDispatchPacketServicesGetPacketAttachModeApiId = KDispatchPacketServicesFuncUnitId + 2;
+
+	/**
+	 * The CTSY Dispatcher shall invoke this function on receiving the EPacketGetAttachMode
+	 * request from the CTSY.
+	 *
+	 * It is a request call that is completed by invoking
+	 * CCtsyDispatcherCallback::CallbackPacketServicesGetPacketAttachModeComp()
+	 *
+	 * Implementation of this interface will return the attach mode. However if the call is
+	 * being made during a packet service open process it will skip the get attach mode call.
+	 * 		 	
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 */
+	virtual TInt HandleGetPacketAttachModeReqL() = 0;
+
+	}; // class MLtsyDispatchPacketServicesGetPacketAttachMode
+
+
+
+class MLtsyDispatchPacketServicesGetPacketNetworkRegistrationStatus : public MLtsyDispatchInterface
+	{
+public:
+
+	static const TInt KLtsyDispatchPacketServicesGetPacketNetworkRegistrationStatusApiId = KDispatchPacketServicesFuncUnitId + 3;
+
+	/**
+	 * The CTSY Dispatcher shall invoke this function on receiving the EPacketGetNtwkRegStatus
+	 * request from the CTSY.
+	 *
+	 * It is a request call that is completed by invoking
+	 * CCtsyDispatcherCallback::CallbackPacketServicesGetPacketNetworkRegistrationStatusComp()
+	 *
+	 * Implementation of this interface should retrieve the packet network registration status 
+	 * from the baseband.
+	 *
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 */
+	virtual TInt HandleGetPacketNetworkRegistrationStatusReqL() = 0;
+
+	}; // class MLtsyDispatchPacketServicesGetPacketNetworkRegistrationStatus
+
+
+
+class MLtsyDispatchPacketServicesPacketDetach : public MLtsyDispatchInterface
+	{
+public:
+
+	static const TInt KLtsyDispatchPacketServicesPacketDetachApiId = KDispatchPacketServicesFuncUnitId + 4;
+
+	/**
+	 * The CTSY Dispatcher shall invoke this function on receiving the EPacketDetach
+	 * request from the CTSY.
+	 *
+	 * It is a request call that is completed by invoking
+	 * CCtsyDispatcherCallback::CallbackPacketServicesPacketDetachComp()
+	 * 	 
+	 * Implementation of this interface should issue a detach request to the LTSY.
+	 *
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 */
+	virtual TInt HandlePacketDetachReqL() = 0;
+
+	}; // class MLtsyDispatchPacketServicesPacketDetach
+
+
+
+class MLtsyDispatchPacketServicesSetPdpContextConfig : public MLtsyDispatchInterface
+	{	
+public:
+
+	static const TInt KLtsyDispatchPacketServicesSetPdpContextConfigApiId = KDispatchPacketServicesFuncUnitId + 5;
+
+	/**
+	 * The CTSY Dispatcher shall invoke this function on receiving the EPacketContextSetConfig
+	 * request from the CTSY.
+	 *
+	 * It is a request call that is completed by invoking
+	 * CCtsyDispatcherCallback::CallbackPacketServicesSetPdpContextConfigComp()
+	 * Implementation of this interface should pass LTSY the parameters it needs to set the 
+	 * context configuration 
+	 *
+	 * @param aContextId the context name
+	 * @param aAccessPointName the access name which identifies the GGSN to be used
+ 	 * @param aPdpType the protocol type
+ 	 * @param aPdpAddress the PDP address for this context
+ 	 * @param aPcoBuffer the pco buffer
+ 	 *
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 */
+	virtual TInt HandleSetPdpContextConfigReqL(const TDesC& aContextId,
+			const TDesC8& aAccessPointName,
+			const RPacketContext::TProtocolType aPdpType,
+			const TDesC8& aPdpAddress,
+			const TDesC8& aPcoBuffer) = 0;
+
+	}; // class MLtsyDispatchPacketServicesSetPdpContextConfig
+
+
+
+class MLtsyDispatchPacketServicesModifyActivePdpContext : public MLtsyDispatchInterface
+	{
+public:
+
+	static const TInt KLtsyDispatchPacketServicesModifyActivePdpContextApiId = KDispatchPacketServicesFuncUnitId + 6;
+
+	/**
+	 * The CTSY Dispatcher shall invoke this function on receiving the EPacketContextModifyActiveContext
+	 * request from the CTSY.
+	 *
+	 * It is a request call that is completed by invoking
+	 * CCtsyDispatcherCallback::CallbackPacketServicesModifyActivePdpContextComp()
+	 * Implementation of this interface should signal to the Licensee TSY that it can action the modification
+	 * of an existing context, the changes being indicated via appropriate RPacketContext::SetConfig and 
+	 * RPacketContext::SetProfileParameters calls
+	 *
+	 * @param aContextName the context name.
+	 *
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 */
+	virtual TInt HandleModifyActivePdpContextReqL(const TDesC& aContextName) = 0;
+	}; // class MLtsyDispatchPacketServicesModifyActivePdpContext
+
+
+
+class MLtsyDispatchPacketServicesInitialisePdpContext : public MLtsyDispatchInterface
+	{
+public:
+
+	static const TInt KLtsyDispatchPacketServicesInitialisePdpContextApiId = KDispatchPacketServicesFuncUnitId + 7;
+
+	/**
+	 * The CTSY Dispatcher shall invoke this function on receiving the EPacketContextInitialiseContext
+	 * request from the CTSY.
+	 *
+	 * It is a request call that is completed by invoking
+	 * CCtsyDispatcherCallback::CallbackPacketServicesInitialisePdpContextComp()
+	 * Implementation of this interface should initialise either primary or secondary contexts
+	 *
+	 *
+     * @param aPrimaryContextName Primary context name in the form of a character string, 
+	 * the maximum length of the descriptor should not exceed KMaxInfoName.
+     * @param aSecondaryContextName Optional secondary context name in the form of a character
+     * string, the maximum length of the descriptor should not exceed KMaxInfoName.
+	 *
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 */
+	virtual TInt HandleInitialisePdpContextReqL(const TDesC& aPrimaryContextName, const TDesC& aSecondaryContextName) = 0;
+	}; // class MLtsyDispatchPacketServicesInitialisePdpContext
+
+
+
+class MLtsyDispatchPacketServicesDeletePdpContext : public MLtsyDispatchInterface
+	{
+public:
+
+	static const TInt KLtsyDispatchPacketServicesDeletePdpContextApiId = KDispatchPacketServicesFuncUnitId + 8;
+
+	/**
+	 * The CTSY Dispatcher shall invoke this function on receiving the EPacketContextDelete
+	 * request from the CTSY.
+	 *
+	 * It is a request call that is completed by invoking
+	 * CCtsyDispatcherCallback::CallbackPacketServicesDeletePdpContextComp()
+	 *
+	 * Implementation of this interface should delete the context given.      
+	 * 
+	 * @param aContextName The name of the context to delete, 
+	 * the maximum length of the descriptor should not exceed KMaxInfoName.
+	 * 
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 */
+	virtual TInt HandleDeletePdpContextReqL(const TDesC& aContextName) = 0;
+
+	}; // class MLtsyDispatchPacketServicesDeletePdpContext
+
+
+
+class MLtsyDispatchPacketServicesSetPacketAttachMode : public MLtsyDispatchInterface
+	{
+public:
+
+	static const TInt KLtsyDispatchPacketServicesSetPacketAttachModeApiId = KDispatchPacketServicesFuncUnitId + 9;
+
+	/**
+	 * The CTSY Dispatcher shall invoke this function on receiving the EPacketSetAttachMode
+	 * request from the CTSY.
+	 *
+	 * It is a request call that is completed by invoking
+	 * CCtsyDispatcherCallback::CallbackPacketServicesSetPacketAttachModeComp()
+	 *
+	 * Implementation of this interface should set the packet service attach mode.
+	 * @param aAttachMode the attach mode due to be set.
+	 *
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 */
+	virtual TInt HandleSetPacketAttachModeReqL(RPacketService::TAttachMode aAttachMode) = 0;
+
+	}; // class MLtsyDispatchPacketServicesSetPacketAttachMode
+
+
+
+class MLtsyDispatchPacketServicesNotifyPacketStatusChange : public MLtsyDispatchInterface
+	{
+public:
+
+	static const TInt KLtsyDispatchPacketServicesNotifyPacketStatusChangeApiId = KDispatchPacketServicesFuncUnitId + 10;
+
+	/**
+	 * The CTSY Dispatcher shall invoke this function on receiving the EPacketNotifyStatusChange
+	 * request from the CTSY.
+	 *
+	 * It is a request call that is completed by invoking
+	 * CCtsyDispatcherCallback::CallbackPacketServicesNotifyPacketStatusChangeComp()
+	 *
+	 * Implementation of this interface should notify when the status of the packet service was changed.
+	 * 
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 */
+	virtual TInt HandleNotifyPacketStatusChangeReqL() = 0;
+
+	}; // class MLtsyDispatchPacketServicesNotifyPacketStatusChange
+
+
+
+class MLtsyDispatchPacketServicesSetDefaultPdpContextGprsParams : public MLtsyDispatchInterface
+	{
+public:
+
+	static const TInt KLtsyDispatchPacketServicesSetDefaultPdpContextGprsParamsApiId = KDispatchPacketServicesFuncUnitId + 11;
+
+	/**
+	 * The CTSY Dispatcher shall invoke this function on receiving the EPacketSetDefaultContextParams
+	 * request from the CTSY.
+	 *
+	 * It is a request call that is completed by invoking
+	 * CCtsyDispatcherCallback::CallbackPacketServicesSetDefaultPdpContextParamsComp()
+	 *
+	 * Implementation of this interface should set default configuration for Packet Context using GPRS params.
+	 *
+	 * @param aContextConfigGprs GPRS configuration input parameters.
+	 *
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 */
+	virtual TInt HandleSetDefaultPdpContextGprsParamsReqL(const RPacketContext::TContextConfigGPRS& aContextConfigGprs) = 0;
+
+	}; // class MLtsyDispatchPacketServicesSetDefaultPdpContextGprsParams
+
+class MLtsyDispatchPacketServicesSetDefaultPdpContextR99R4Params : public MLtsyDispatchInterface
+	{
+public:
+
+	static const TInt KLtsyDispatchPacketServicesSetDefaultPdpContextR99R4ParamsApiId = KDispatchPacketServicesFuncUnitId + 12;
+
+	/**
+	 * The CTSY Dispatcher shall invoke this function on receiving the EPacketSetDefaultContextParams
+	 * request from the CTSY.
+	 * 
+	 * It is a request call that is completed by invoking
+	 * CCtsyDispatcherCallback::CallbackPacketServicesSetDefaultPdpContextParamsComp()
+	 * 
+	 * Implementation of this interface should set default configuration for Packet Context using R99/R4 params.
+	 *
+	 * @param aContextConfigR99R4 R99/R4 configuration input parameters.
+	 *
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 */
+	virtual TInt HandleSetDefaultPdpContextR99R4ParamsReqL(const RPacketContext::TContextConfigR99_R4& aContextConfigR99R4) = 0;
+
+	}; // class MLtsyDispatchPacketServicesSetDefaultPdpContextR99R4Params
+
+
+class MLtsyDispatchPacketServicesActivatePdpContext : public MLtsyDispatchInterface
+	{
+public:
+
+	static const TInt KLtsyDispatchPacketServicesActivatePdpContextApiId = KDispatchPacketServicesFuncUnitId + 13;
+
+	/**
+	 * The CTSY Dispatcher shall invoke this function on receiving the EPacketContextActivate
+	 * request from the CTSY.
+	 *
+	 * It is a request call that is completed by invoking
+	 * CCtsyDispatcherCallback::CallbackPacketServicesActivatePdpContextComp()
+	 *
+	 * Implementation of this interface should activate the context given.
+	 * 
+	 * @param aContextName The context name, the maximum length of the descriptor 
+	 * should not exceed KMaxInfoName.	 
+	 *
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 */
+	virtual TInt HandleActivatePdpContextReqL(const TDesC& aContextName) = 0;
+
+	}; // class MLtsyDispatchPacketServicesActivatePdpContext
+
+
+
+class MLtsyDispatchPacketServicesSetPdpContextQosGprs : public MLtsyDispatchInterface
+	{
+public:
+
+	static const TInt KLtsyDispatchPacketServicesSetPdpContextQosGprsApiId = KDispatchPacketServicesFuncUnitId + 14;
+
+	/**
+	 * The CTSY Dispatcher shall invoke this function on receiving the EPacketQoSSetProfileParams
+	 * request from the CTSY.
+	 * 
+	 * It is a request call that is completed by invoking
+	 * CCtsyDispatcherCallback::CallbackPacketServicesSetPdpContextQosComp()
+	 * 
+	 * Implementation of this interface should set GPRS QoS parametes for the given context.
+	 *
+	 * @param aContextName The name of the context, the maximum length of the 
+     * descriptor should not exceed KMaxInfoName.
+	 * @param aQoSConfig The QoS configuration parameters.
+	 *
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 */
+	virtual TInt HandleSetPdpContextQosGprsReqL(const TDesC& aContextName, const RPacketQoS::TQoSGPRSRequested& aQoSConfig) = 0;
+
+	}; // class MLtsyDispatchPacketServicesSetPdpContextQosGprs
+
+class MLtsyDispatchPacketServicesSetPdpContextQosR99R4 : public MLtsyDispatchInterface
+	{
+public:
+
+	static const TInt KLtsyDispatchPacketServicesSetPdpContextQosR99R4ApiId = KDispatchPacketServicesFuncUnitId + 15;
+
+	/**
+	 * The CTSY Dispatcher shall invoke this function on receiving the EPacketQoSSetProfileParams
+	 * request from the CTSY.
+	 * 
+	 * It is a request call that is completed by invoking
+	 * CCtsyDispatcherCallback::CallbackPacketServicesSetPdpContextQosComp()
+	 * 
+	 * Implementation of this interface should set R99R4 QoS parametes for the given context.
+	 * 
+	 *
+	 * @param aContextName the name of the context.
+	 * @param aQoSConfig the QoS configuration parameters.
+	 *
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 */
+	virtual TInt HandleSetPdpContextQosR99R4ReqL(const TDesC& aContextName, const RPacketQoS::TQoSR99_R4Requested& aQoSConfig) = 0;
+
+	}; // class MLtsyDispatchPacketServicesSetPdpContextQosR99R4
+
+class MLtsyDispatchPacketServicesSetPdpContextQosR5 : public MLtsyDispatchInterface
+	{
+public:
+
+	static const TInt KLtsyDispatchPacketServicesSetPdpContextQosR5ApiId = KDispatchPacketServicesFuncUnitId + 16;
+
+	/**
+	 * The CTSY Dispatcher shall invoke this function on receiving the EPacketQoSSetProfileParams
+	 * request from the CTSY.
+	 *
+	 * It is a request call that is completed by invoking
+	 * CCtsyDispatcherCallback::CallbackPacketServicesSetPdpContextQosComp()
+	 *
+	 * Implementation of this interface should set R5 QoS parametes for the given context.
+	 *
+	 *
+	 * @param aContextName The name of the context, the maximum length of the 
+	 * descriptor should not exceed KMaxInfoName.
+	 * @param aQoSConfig The QoS configuration parameters.
+	 *
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 */
+	virtual TInt HandleSetPdpContextQosR5ReqL(const TDesC& aContextName, const RPacketQoS::TQoSR5Requested& aQoSConfig) = 0;
+
+	}; // class MLtsyDispatchPacketServicesSetPdpContextQosR5
+
+
+
+
+class MLtsyDispatchPacketServicesRejectNetworkInitiatedContextActivationRequest : public MLtsyDispatchInterface
+	{
+public:
+
+	static const TInt KLtsyDispatchPacketServicesRejectNetworkInitiatedContextActivationRequestApiId = KDispatchPacketServicesFuncUnitId + 17;
+
+	/**
+	 * The CTSY Dispatcher shall invoke this function on receiving the EPacketRejectActivationRequest
+	 * request from the CTSY.
+	 *
+	 * It is a request call that is completed by invoking
+	 * CCtsyDispatcherCallback::CallbackPacketServicesRejectNetworkInitiatedContextActivationRequestComp()
+	 *
+	 * Implementation of this interface should reject the network initiated context activation request.
+	 * 
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 */
+	virtual TInt HandleRejectNetworkInitiatedContextActivationRequestReqL() = 0;
+
+	}; // class MLtsyDispatchPacketServicesRejectNetworkInitiatedContextActivationRequest
+
+
+
+class MLtsyDispatchPacketServicesDeactivatePdpContext : public MLtsyDispatchInterface
+	{
+public:
+
+	static const TInt KLtsyDispatchPacketServicesDeactivatePdpContextApiId = KDispatchPacketServicesFuncUnitId + 18;
+
+	/**
+	 * The CTSY Dispatcher shall invoke this function on receiving the EPacketContextDeactivate
+	 * request from the CTSY.
+	 *
+	 * It is a request call that is completed by invoking
+	 * CCtsyDispatcherCallback::CallbackPacketServicesDeactivatePdpContextComp()
+	 * Implementation of this interface should deactivate the context indicated by the context name.
+	 *
+	 *
+	 * @param aContextName The context name that is to be deactivated, 
+	 * the maximum length of the descriptor should not exceed KMaxInfoName.
+	 *
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 */
+	virtual TInt HandleDeactivatePdpContextReqL(const TDesC& aContextName) = 0;
+
+	}; // class MLtsyDispatchPacketServicesDeactivatePdpContext
+
+
+
+class MLtsyDispatchPacketServicesAddPacketFilter : public MLtsyDispatchInterface
+	{
+public:
+
+	static const TInt KLtsyDispatchPacketServicesAddPacketFilterApiId = KDispatchPacketServicesFuncUnitId + 19;
+
+	/**
+	 * The CTSY Dispatcher shall invoke this function on receiving the EPacketContextAddPacketFilter
+	 * request from the CTSY.
+	 * Implementation of this interface should add a packet filter to the packet service.
+	 * 
+	 * It is a request call that is completed by invoking
+	 * CCtsyDispatcherCallback::CallbackPacketServicesSetPdpContextConfigComp()	 
+	 * 
+	 * @param aContextName The name of the context, the maximum length of the 
+	 * descriptor should not exceed KMaxInfoName.
+	 * @param aContextFilter An array contains up to eight filters to be used
+	 * for configuring the secondary context.
+	 * 
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 */
+	virtual TInt HandleAddPacketFilterSyncL(const TDesC& aContextName,  CArrayFixFlat<RPacketContext::TPacketFilterV2>& aContextFilter) = 0;
+
+	}; // class MLtsyDispatchPacketServicesAddPacketFilter
+
+class MLtsyDispatchPacketServicesGetStatus : public MLtsyDispatchInterface
+	{
+public:
+
+	static const TInt KLtsyDispatchPacketServicesGetStatusApiId = KDispatchPacketServicesFuncUnitId + 20;
+
+	/**
+	 * The CTSY Dispatcher shall invoke this function during the packet services bootup
+	 * as part of EPacketNotifyStatusChange call.
+	 * 
+	 * It is a request call that is completed by invoking
+	 * CCtsyDispatcherCallback::CallbackPacketServicesGetStatusComp()
+	 * 
+	 * Implemetation of this interface should retrieve the packet service status.
+	 * 
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 */
+	virtual TInt HandleGetStatusReqL() = 0;
+
+	}; // class MLtsyDispatchPacketServicesGetStatus
+
+class MLtsyDispatchPacketServicesGetStaticCapabilities : public MLtsyDispatchInterface
+	{
+public:
+
+	static const TInt KLtsyDispatchPacketServicesGetStaticCapabilitiesApiId = KDispatchPacketServicesFuncUnitId + 21;
+
+	/**
+	 * The CTSY Dispatcher shall invoke this function during the packet services bootup
+	 * as part of EPacketGetStaticCaps call.
+	 * 
+	 * It is a request call that is completed by invoking
+	 * CCtsyDispatcherCallback::CallbackPacketServicesGetStaticCapabilitiesComp()
+	 * 
+	 * Implemetation of this interface should retrieve the packet service static capabilities.
+	 * 
+	 * Calls to RPacketService::GetStaticCaps() will then return the static capabilities returned
+	 * in the callback.
+	 * 
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 * 
+	 * @see RPacketService::GetStaticCaps()
+	 */
+	virtual TInt HandleGetStaticCapabilitiesReqL() = 0;
+
+	}; // class MLtsyDispatchPacketServicesGetStaticCapabilities
+
+class MLtsyDispatchPacketServicesGetMaxNoMonitoredServiceLists : public MLtsyDispatchInterface
+	{
+public:
+
+	static const TInt KLtsyDispatchPacketServicesGetMaxNoMonitoredServiceListsApiId = KDispatchPacketServicesFuncUnitId + 22;
+
+	/**
+	 * The CTSY Dispatcher shall invoke this function during the packet services bootup
+	 * as part of EPacketEnumerateMbmsMonitorServiceList call.
+	 * 
+	 * It is a request call that is completed by invoking
+	 * CCtsyDispatcherCallback::CallbackPacketServicesGetMaxNoMonitoredServiceListsComp()
+	 * 
+	 * Implemetation of this interface should retrieve the maximum number of monitored service lists.
+	 * 
+	 * Calls to RPacketService::EnumerateMbmsMonitorServiceList() will then return the 
+	 * maximum number of monitored service lists in the aMaxAllowed field.
+	 * 
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 * 
+	 * @see RPacketService::EnumerateMbmsMonitorServiceList()
+	 */
+	virtual TInt HandleGetMaxNoMonitoredServiceListsReqL() = 0;
+
+	}; // class MLtsyDispatchPacketServicesGetMaxNoMonitoredServiceLists
+
+class MLtsyDispatchPacketServicesGetMaxNoActiveServices : public MLtsyDispatchInterface
+	{
+public:
+
+	static const TInt KLtsyDispatchPacketServicesGetMaxNoActiveServicesApiId = KDispatchPacketServicesFuncUnitId + 23;
+
+	/**
+	 * The CTSY Dispatcher shall invoke this function during the packet services bootup
+	 * as part of EPacketEnumerateMbmsActiveServiceList call.
+	 * 
+	 * It is a request call that is completed by invoking
+	 * CCtsyDispatcherCallback::CallbackPacketServicesGetMaxNoActiveServicesComp()
+	 * 
+	 * Implemetation of this interface should retrieve the maximum number of active services allowed
+	 * (hence the maximum number of contexts allowed).
+	 * 
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 * 
+	 */
+	virtual TInt HandleGetMaxNoActiveServicesReqL() = 0;
+
+	}; // class MLtsyDispatchPacketServicesGetMaxNoActiveServices
+
+class MLtsyDispatchPacketServicesInitialiseMbmsContext : public MLtsyDispatchInterface
+	{
+public:
+
+	static const TInt KLtsyDispatchPacketServicesInitialiseMbmsContextApiId = KDispatchPacketServicesFuncUnitId + 24;
+
+	/**
+	 * The CTSY Dispatcher shall invoke this function on receiving the ECtsyPacketMbmsInitialiseContextReq
+	 * request from the CTSY.
+	 *
+	 * It is a request call that is completed by invoking
+	 * CCtsyDispatcherCallback::CallbackPacketServicesInitialiseMbmsContextComp()
+	 * 
+	 * Implementation of this interface should initialise the Mbms Context
+	 * (Multimedia Broadcast Multicast Service).
+	 *
+     * @param aContextName The context name in the form of a character string 
+	 * the maximum length of the descriptor should not exceed KMaxInfoName.
+	 * 
+	 *
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 * 
+	 * @see RPacketMbmsContext::InitialiseContext()
+	 */
+	virtual TInt HandleInitialiseMbmsContextReqL(const TDesC& aContextName) = 0;
+
+	}; // class MLtsyDispatchPacketServicesInitialiseMbmsContext
+
+class MLtsyDispatchPacketServicesGetMbmsNetworkServiceStatus : public MLtsyDispatchInterface
+	{
+public:
+
+	static const TInt KLtsyDispatchPacketServicesGetMbmsNetworkServiceStatusApiId = KDispatchPacketServicesFuncUnitId + 25;
+
+	/**
+	 * The CTSY Dispatcher shall invoke this function on receiving the EPacketGetMbmsNetworkServiceStatus
+	 * request from the CTSY.
+	 *
+	 * It is a request call that is completed by invoking
+	 * CCtsyDispatcherCallback::CallbackPacketServicesGetMbmsNetworkServiceStatusComp()
+	 * 
+	 * Implementation of this interface should retrieve the current MBMS
+	 * (Multimedia Broadcast Multicast Service) network state. 
+	 * 
+	 * There can be 3 states that MBMS feature availability could return,
+	 *  Unknown - when UE is not GMM Attached.
+	 *  Supported - When UE is GMM Attached and it is known that cell supports MBMS.
+	 *  Not Supported - When UE is GMM Attached and it is know that cell does not support MBMS.
+	 * 
+	 * The state is only known from GMM Attach response from the network or during a Routing Area update.
+	 * A consequence of this is that it is required for the UE to be in GMM Attach mode in order 
+	 * for either of these messages to be received. If the UE is not in GMM ATTACH then it is unable 
+	 * to determine MBMS network support.
+	 *
+     * @param aAttemptAttach If a GMM attached is to be performed.
+	 *
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 * 
+	 * @see  RPacketService::GetMbmsNetworkServiceStatus()
+	 */
+	virtual TInt HandleGetMbmsNetworkServiceStatusReqL(TBool aAttemptAttach) = 0;
+
+	}; // class MLtsyDispatchPacketServicesInitialiseMbmsContext
+
+class MLtsyDispatchPacketServicesUpdateMbmsMonitorServiceList : public MLtsyDispatchInterface
+	{
+public:
+
+	static const TInt KLtsyDispatchPacketServicesUpdateMbmsMonitorServiceListApiId = KDispatchPacketServicesFuncUnitId + 26;
+
+	/**
+	 * The CTSY Dispatcher shall invoke this function on receiving the EPacketUpdateMbmsMonitorServiceList
+	 * request from the CTSY.
+	 *
+	 * It is a request call that is completed by invoking
+	 * CCtsyDispatcherCallback::CallbackPacketServicesUpdateMbmsMonitorServiceListComp()
+	 * 
+	 * Implementation of this interface should request to update the MBMS (Multimedia Broadcast Multicast Service)
+	 * monitor service availability list with the change list entries as per the action mentioned. 
+	 * The CTSY stores the monitor service availability list, this list is updated on a successful completion.
+	 * 
+     * @param aAction The MBMS action (add, remove or remove all).
+     * @param aServiceList The current MBMS monitor service availability list as held by the CTSY.
+     * @param aChangeList The list of entries to be changed as per the action. (e.g. the action = Add,
+     * the change list will contain entries to be added to the MBMS monitor service availability list)
+	 *
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 * 
+	 * @see RPacketService::UpdateMbmsMonitorServiceListL()
+	 * @see RPacketService::NotifyMbmsServiceAvailabilityChange()
+	 * @see CRetrievePcktMbmsMonitoredServices()
+	 */
+	virtual TInt HandleUpdateMbmsMonitorServiceListsReqL(TMbmsAction aAction, const CPcktMbmsMonitoredServiceList& aServiceList, const CPcktMbmsMonitoredServiceList& aChangeList) = 0;
+
+	}; // class MLtsyDispatchPacketServicesUpdateMbmsMonitorServiceList
+
+class MLtsyDispatchPacketServicesUpdateMbmsSessionList : public MLtsyDispatchInterface
+	{
+public:
+
+	static const TInt KLtsyDispatchPacketServicesUpdateMbmsSessionListApiId = KDispatchPacketServicesFuncUnitId + 27;
+
+	/**
+	 * The CTSY Dispatcher shall invoke this function on receiving the EPacketContextUpdateMbmsSessionList
+	 * request from the CTSY.
+	 *
+	 * It is a request call that is completed by invoking
+	 * CCtsyDispatcherCallback::CallbackPacketServicesUpdateMbmsSessionListComp()
+	 * 
+	 * Implementation of this interface should request to add a new session to be received or remove 
+	 * an existing session to/from the MBMS services table.
+	 * The CTSY stores the MBMS services table, this table is updated on a successful completion.
+	 * 
+	 * @param aContextName The MBMS context name in the form of a character string.
+     * @param aAction The action to be performed (add, remove or remove all).
+     * @param aSessionId The MBMS session identifier which needs to be received or removed.
+     * @param aServiceList The MBMS services table as held by the CTSY.
+	 *
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 * 
+	 * @see RPacketService::UpdateMbmsSessionList()
+	 * @see CRetrievePcktMbmsSessionList()
+	 */
+	virtual TInt HandleUpdateMbmsSessionListReqL(const TDesC& aContextName, TMbmsAction aAction, TMbmsSessionId aSessionId, const TMbmsSessionIdList& aServiceList) = 0;
+
+	}; // class MLtsyDispatchPacketServicesUpdateMbmsSessionList
+
+class MLtsyDispatchPacketServicesRemovePacketFilter : public MLtsyDispatchInterface
+	{
+public:
+
+	static const TInt KLtsyDispatchPacketServicesRemovePacketFilterApiId = KDispatchPacketServicesFuncUnitId + 28;
+	/**
+	 * The CTSY Dispatcher shall invoke this function on receiving the EPacketContextRemovePacketFilter
+	 * request from the CTSY.
+	 * Implementation of this interface should remove a packet filter from the packet service.
+	 * 
+	 * It is a request call that is completed by invoking
+	 * CCtsyDispatcherCallback::CallbackPacketServicesSetPdpContextConfigComp()	 
+	 * 
+	 * @param aContextName The name of the context, the maximum length of the 
+	 * descriptor should not exceed KMaxInfoName.
+	 * @param aFilterId The filter Id to remove.
+	 * 
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 */
+	virtual TInt HandleRemovePacketFilterSyncL(const TDesC& aContextName,  TInt aFilterId) = 0;
+
+	}; // class MLtsyDispatchPacketServicesRemovePacketFilter
+
+#endif /*MLTSYDISPATCHPACKETSERVICESINTERFACE_H_*/
diff -r 4a8d14a1a8ca -r ab1d0f4d2aa4 Telephony/ctsydispatchlayer/exportinc/mltsydispatchphonebookeninterface.h
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Telephony/ctsydispatchlayer/exportinc/mltsydispatchphonebookeninterface.h	Thu Aug 12 13:20:01 2010 +0100
@@ -0,0 +1,110 @@
+// Copyright (c) 2008-2009 Nokia Corporation and/or its subsidiary(-ies).
+// All rights reserved.
+// This component and the accompanying materials are made available
+// under the terms of "Eclipse Public License v1.0"
+// which accompanies this distribution, and is available
+// at the URL "http://www.eclipse.org/legal/epl-v10.html".
+//
+// Initial Contributors:
+// Nokia Corporation - initial contribution.
+//
+// Contributors:
+//
+// Description:
+// This file contains all the interfaces classes that can be implemented by
+// the Licensee LTSY relating to PhonebookEn related features.
+//
+
+
+
+
+/**
+ @file
+ @internalAll 
+*/
+
+
+#ifndef MLTSYDISPATCHPHONEBOOKENINTERFACE_H_
+#define MLTSYDISPATCHPHONEBOOKENINTERFACE_H_
+
+#include <ctsy/ltsy/mltsydispatchinterface.h>
+
+
+class MLtsyDispatchPhonebookEnStoreGetInfo : public MLtsyDispatchInterface
+	{
+public:
+
+	static const TInt KLtsyDispatchPhonebookEnStoreGetInfoApiId = KDispatchPhonebookEnFuncUnitId + 1;
+
+	/**
+	 * The CTSY Dispatcher shall invoke this function on receiving the EMmTsyENStoreGetInfoIPC
+	 * request from the CTSY.
+	 *
+	 * It is a request call that is completed by invoking
+	 * CCtsyDispatcherCallback::CallbackPhonebookEnStoreGetInfoComp()
+	 *
+	 * Implementation of this interface should handle retrieving of the information of the EN storage.
+	 *
+	 *
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 */
+	virtual TInt HandleStoreGetInfoReqL() = 0;
+
+	}; // class MLtsyDispatchPhonebookEnStoreGetInfo
+
+
+
+class MLtsyDispatchPhonebookEnStoreReadAll : public MLtsyDispatchInterface
+	{
+public:
+
+	static const TInt KLtsyDispatchPhonebookEnStoreReadAllApiId = KDispatchPhonebookEnFuncUnitId + 2;
+
+	/**
+	 * The CTSY Dispatcher shall invoke this function on receiving the EMmTsyENStoreReadAllPhase1IPC
+	 * request from the CTSY.
+	 *
+	 * It is a request call that is completed by invoking
+	 * CCtsyDispatcherCallback::CallbackPhonebookEnStoreReadAllComp()
+	 *
+	 * Implementation of this interface should handle reading all the entries from the EN storage.
+	 *
+	 *
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 */
+	virtual TInt HandleStoreReadAllReqL() = 0;
+
+	}; // class MLtsyDispatchPhonebookEnStoreReadAll
+
+
+
+class MLtsyDispatchPhonebookEnStoreReadEntry : public MLtsyDispatchInterface
+	{
+public:
+
+	static const TInt KLtsyDispatchPhonebookEnStoreReadEntryApiId = KDispatchPhonebookEnFuncUnitId + 3;
+
+	/**
+	 * The CTSY Dispatcher shall invoke this function on receiving the EMmTsyENStoreReadIPC
+	 * request from the CTSY.
+	 *
+	 * It is a request call that is completed by invoking
+	 * CCtsyDispatcherCallback::CallbackPhonebookEnStoreReadEntryComp()
+	 *
+	 * Implementation of this interface should handle reading of an entry from the EN storage with a given index.
+	 *
+	 *
+	 * @param aIndex The index of the EN entry.
+	 *
+	 *
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 */
+	virtual TInt HandleStoreReadEntryReqL(TInt aIndex) = 0;
+
+	}; // class MLtsyDispatchPhonebookEnStoreReadEntry
+
+
+#endif /*MLTSYDISPATCHPHONEBOOKENINTERFACE_H_*/
diff -r 4a8d14a1a8ca -r ab1d0f4d2aa4 Telephony/ctsydispatchlayer/exportinc/mltsydispatchphonebookinterface.h
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Telephony/ctsydispatchlayer/exportinc/mltsydispatchphonebookinterface.h	Thu Aug 12 13:20:01 2010 +0100
@@ -0,0 +1,595 @@
+// Copyright (c) 2008-2009 Nokia Corporation and/or its subsidiary(-ies).
+// All rights reserved.
+// This component and the accompanying materials are made available
+// under the terms of "Eclipse Public License v1.0"
+// which accompanies this distribution, and is available
+// at the URL "http://www.eclipse.org/legal/epl-v10.html".
+//
+// Initial Contributors:
+// Nokia Corporation - initial contribution.
+//
+// Contributors:
+//
+// Description:
+// This file contains all the interfaces classes that can be implemented by
+// the Licensee LTSY relating to Phonebook related features.
+//
+
+
+
+
+/**
+ @file
+ @internalAll 
+*/
+
+
+#ifndef MLTSYDISPATCHPHONEBOOKINTERFACE_H_
+#define MLTSYDISPATCHPHONEBOOKINTERFACE_H_
+
+#include <ctsy/ltsy/mltsydispatchinterface.h>
+#include <etelmm.h>
+
+#include <ctsy/serviceapi/cmmsmsutility.h>
+
+namespace DispatcherPhonebook
+	{
+	
+	/**
+	 * This namespace contains all types relating to the phonebook dispatcher.
+	 */
+	
+	/**
+	 * Enum containing all the supported phonebook types
+	 */
+	enum TPhonebook
+		{
+		EIccAdn = 0, 	//Abbriviated Dailling Numbers
+		EIccBdn,		//Barred Dailling Numbers
+		EIccSdn,		//Service Dialling numbers
+		EIccFdn,		//Fixed Dialling numbers
+		EIccVmb,		//Voice Mail Box
+		EIccMbdn,		//Mailbox dialling numbers
+		EUnknown
+		};
+	
+	class TPhonebookStoreInfoV1
+		{
+		
+		/**
+		 * This structure contains the details required by the CTSY about the various
+		 * phonebook stores, it is used in the initialisation procedure.
+		 * 
+		 * Total Entries 			- The total number of entries the store can contain.
+		 * Maximum Text Length 		- The maximum length of a text field in the store.
+		 * Maximum Number Length 	- The maximum length of a number in the store.
+		 * Capabilities 			- The Bit field of the stores capabilities (RMobilePhoneStore::TMobilePhoneStoreCaps).
+		 * Maximum Fields Per Entry - The maximum number of fields in a given entry.
+		 */
+		
+	public:
+		
+		TPhonebookStoreInfoV1() :
+			iAdnTotalEntries(-1),
+			iAdnMaximumTextLength(-1),
+			iAdnMaximumNumberLength(-1),
+			iFdnTotalEntries(-1),
+			iFdnMaximumTextLength(-1),
+			iFdnMaximumNumberLength(-1),
+			iSdnTotalEntries(-1),
+			iSdnMaximumTextLength(-1),
+			iSdnMaximumNumberLength(-1),
+			iVmbTotalEntries(-1),
+			iVmbMaximumTextLength(-1),
+			iVmbMaximumNumberLength(-1),
+			iVmbCapabilities(0),
+			iMbdnTotalEntries(-1),
+			iMbdnMaximumTextLength(-1),
+			iMbdnMaximumNumberLength(-1),
+			iMbdnCapabilities(0),
+			iSecondNameMaximumFieldsPerEntry(-1),
+			iSecondNameMaximumLength(-1),
+			iEmailMaximumFieldsPerEntry(-1),
+			iEmailMaximumLength(-1),
+			iAdditionalNumberMaximumFieldsPerEntry(-1),
+			iAdditionalNumberMaximumLength(-1)
+			{
+			}
+		
+		//Abbriviated Dailling Numbers
+		TInt iAdnTotalEntries; 
+		TInt iAdnMaximumTextLength;
+		TInt iAdnMaximumNumberLength;
+
+		//Fixed Dialling numbers
+		TInt iFdnTotalEntries;
+		TInt iFdnMaximumTextLength;
+		TInt iFdnMaximumNumberLength;
+
+		//Service Dialling numbers
+		TInt iSdnTotalEntries;
+		TInt iSdnMaximumTextLength;
+		TInt iSdnMaximumNumberLength;
+
+		//Voice Mail Box
+		TInt iVmbTotalEntries;
+		TInt iVmbMaximumTextLength;
+		TInt iVmbMaximumNumberLength;
+		TInt iVmbCapabilities;
+
+		//Mailbox dialling numbers
+		TInt iMbdnTotalEntries;
+		TInt iMbdnMaximumTextLength;
+		TInt iMbdnMaximumNumberLength;
+		TInt iMbdnCapabilities;
+		
+		//3G Information - Second Names
+		TInt iSecondNameMaximumFieldsPerEntry;
+		TInt iSecondNameMaximumLength;
+
+		//3G Information - Email Address
+		TInt iEmailMaximumFieldsPerEntry;
+		TInt iEmailMaximumLength;
+
+		//3G Information - Additional Number
+		TInt iAdditionalNumberMaximumFieldsPerEntry;
+		TInt iAdditionalNumberMaximumLength;
+		};
+	
+	
+	struct TSmsData
+		{
+	public:	
+	    TBuf8<231> iSmsMsg;
+	    TBuf<KMaxAddressBufferSize> iServiceCentre;
+	    RMobilePhone::TMobileTON iMobileScTON;
+	    RMobilePhone::TMobileNPI iMobileScNPI;
+	    TInt8 iMessageStatus;
+		};
+	
+	}
+
+
+class MLtsyDispatchPhonebookStoreReadEntry : public MLtsyDispatchInterface
+	{
+public:
+
+	static const TInt KLtsyDispatchPhonebookStoreReadEntryApiId = KDispatchPhonebookFuncUnitId + 1;
+
+	/**
+	 * The CTSY Dispatcher shall invoke this function on receiving the EMmTsyPhoneBookStoreReadIPC
+	 * request from the CTSY.
+	 *
+	 * It is a request call that is completed by invoking
+	 * CCtsyDispatcherCallback::CallbackPhonebookStoreReadEntryComp()
+	 *
+	 * Implementation of this interface should request to read a number of entries from a given phonebook.
+	 * The entries are returned in the callback.
+	 *
+	 *
+	 * @param aPhonebook The phonebook to read entries from.
+	 * @param aIndex Specifies the index to start reading from, must be >= 1.
+	 * @param aNumSlots Specifies the number of slots to read, must be >= 1 and <= total number of slots.
+	 * 
+	 *
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 * 
+	 * @see RMobilePhoneBookStore::Read()
+	 */
+	virtual TInt HandleStoreReadEntryReqL(DispatcherPhonebook::TPhonebook aPhonebook, TInt aIndex, TInt aNumberOfSlots) = 0;
+
+	}; // class MLtsyDispatchPhonebookStoreReadEntry
+
+
+
+class MLtsyDispatchPhonebookStoreDeleteEntry : public MLtsyDispatchInterface
+	{
+public:
+
+	static const TInt KLtsyDispatchPhonebookStoreDeleteEntryApiId = KDispatchPhonebookFuncUnitId + 2;
+
+	/**
+	 * The CTSY Dispatcher shall invoke this function on receiving the EMmTsyPhoneBookStoreDeleteIPC
+	 * request from the CTSY.
+	 *
+	 * It is a request call that is completed by invoking
+	 * CCtsyDispatcherCallback::CallbackPhonebookStoreDeleteEntryComp()
+	 *
+	 * Implementation of this interface should request to delete an entry from a given phonebook, the
+	 * callback indicates when the operation has been completed.
+	 *
+	 *
+	 * @param aPhonebook The phonebook to delete an entry from.
+	 * @param aIndex The entry index in the phonebook to delete.
+	 *
+	 *
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 * 
+	 * @see RMobilePhoneBookStore::Delete()
+	 * 
+	 */
+	virtual TInt HandleStoreDeleteEntryReqL(DispatcherPhonebook::TPhonebook aPhonebook, TInt aIndex) = 0;
+
+	}; // class MLtsyDispatchPhonebookStoreDeleteEntry
+
+
+
+class MLtsyDispatchPhonebookStoreCache : public MLtsyDispatchInterface
+	{
+public:
+
+	static const TInt KLtsyDispatchPhonebookStoreCacheApiId = KDispatchPhonebookFuncUnitId + 3;
+
+	/**
+	 * The CTSY Dispatcher shall invoke this function on receiving the EMmTsyPhoneBookStoreCacheIPC
+	 * request from the CTSY.
+	 *
+	 * It is a request call that is completed by invoking
+	 * CCtsyDispatcherCallback::CallbackPhonebookStoreCacheComp()
+	 *
+	 * Implementation of this interface should request to cache a given phonebook, the entire 
+	 * phonebook entries are returned in the callback.
+	 *
+	 *
+	 * @param aPhonebook The phonebook to cache.
+	 *
+	 *
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 */
+	virtual TInt HandleStoreCacheReqL(DispatcherPhonebook::TPhonebook aPhonebook) = 0;
+
+	}; // class MLtsyDispatchPhonebookStoreCache
+
+
+
+class MLtsyDispatchPhonebookStoreCacheCancel : public MLtsyDispatchInterface
+	{
+public:
+
+	static const TInt KLtsyDispatchPhonebookStoreCacheCancelApiId = KDispatchPhonebookFuncUnitId + 4;
+
+	/**
+	 * The CTSY Dispatcher shall invoke this function on receiving the EMmTsyPhoneBookStoreCacheCancelIPC
+	 * request from the CTSY.
+	 *
+	 * It is a request call that has no complete call.
+	 *
+	 *
+	 * Implementation of this interface should request to cancel an outstanding cache of a given phonebook.
+	 *
+	 * @param aPhonebook The phonebook to cancel the pending cache.
+	 *
+	 *
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 */
+	virtual TInt HandleStoreCacheCancelReqL(DispatcherPhonebook::TPhonebook aPhonebook) = 0;
+
+	}; // class MLtsyDispatchPhonebookStoreCacheCancel
+
+
+
+class MLtsyDispatchPhonebookStoreGetPhonebookInfo : public MLtsyDispatchInterface
+	{
+public:
+
+	static const TInt KLtsyDispatchPhonebookStoreGetPhonebookInfoApiId = KDispatchPhonebookFuncUnitId + 5;
+
+	/**
+	 * The CTSY Dispatcher shall invoke this function on receiving the EMmTsyPhoneBookStoreGetInfoIPC
+	 * request from the CTSY.
+	 *
+	 * It is a request call that is completed by invoking
+	 * CCtsyDispatcherCallback::CallbackPhonebookStoreGetPhonebookInfoComp()
+	 *
+	 * Implementation of this interface should request to get the information of a given phonebook. The 
+	 * callback should be completed with the information.
+	 * 
+	 * This call to the LTSY is only used when the CTSY requires the information about the number of used entries
+	 * in a phonebook, thus calls to RMobilePhoneBookStore::GetInfo() on cached phonebooks can be completed immediately 
+	 * as the CTSY will already hold this information.
+	 *
+	 *
+	 * @param aPhonebook The phonebook to retrieve the information from.
+	 *
+	 *
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 * 
+	 * @see RMobilePhoneBookStore::GetInfo()
+	 * 
+	 */
+	virtual TInt HandleStoreGetPhonebookInfoReqL(DispatcherPhonebook::TPhonebook aPhonebook) = 0;
+
+	}; // class MLtsyDispatchPhonebookStoreGetPhonebookInfo
+
+
+
+class MLtsyDispatchPhonebookStoreInitialise : public MLtsyDispatchInterface
+	{
+public:
+
+	static const TInt KLtsyDispatchPhonebookStoreInitialiseApiId = KDispatchPhonebookFuncUnitId + 6;
+
+	/**
+	 * The CTSY Dispatcher shall invoke this function on receiving the EMmTsyPhoneBookStoreInitIPC
+	 * request from the CTSY.
+	 *
+	 * It is a request call that is completed by invoking
+	 * CCtsyDispatcherCallback::CallbackPhonebookStoreInitialiseComp()
+	 *
+	 * Implementation of this interface should request to initialise the phonebook store, the callback should
+	 * be completed when store initialisation is completed.
+	 *
+	 *
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 */
+	virtual TInt HandleStoreInitialiseReqL() = 0;
+
+	}; // class MLtsyDispatchPhonebookStoreInitialise
+
+
+
+class MLtsyDispatchPhonebookStoreDeleteAll : public MLtsyDispatchInterface
+	{
+public:
+
+	static const TInt KLtsyDispatchPhonebookStoreDeleteAllApiId = KDispatchPhonebookFuncUnitId + 7;
+
+	/**
+	 * The CTSY Dispatcher shall invoke this function on receiving the EMmTsyPhoneBookStoreDeleteAllIPC
+	 * request from the CTSY.
+	 *
+	 * It is a request call that is completed by invoking
+	 * CCtsyDispatcherCallback::CallbackPhonebookStoreDeleteAllComp()
+	 *
+	 * Implementation of this interface should request to delete all entries from a given phonebook, the
+	 * callback indicates when the operation is completed.
+	 *
+	 *
+	 * @param aPhonebook The phonebook to delete all entries from.
+	 *
+	 *
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 * 
+	 * @see RMobilePhoneBookStore::DeleteAll()
+	 * 
+	 */
+	virtual TInt HandleStoreDeleteAllReqL(DispatcherPhonebook::TPhonebook aPhonebook) = 0;
+
+	}; // class MLtsyDispatchPhonebookStoreDeleteAll
+
+
+
+class MLtsyDispatchPhonebookStoreWriteEntry : public MLtsyDispatchInterface
+	{
+public:
+
+	static const TInt KLtsyDispatchPhonebookStoreWriteEntryApiId = KDispatchPhonebookFuncUnitId + 8;
+
+	/**
+	 * The CTSY Dispatcher shall invoke this function on receiving the EMmTsyPhoneBookStoreWriteIPC
+	 * request from the CTSY.
+	 *
+	 * It is a request call that is completed by invoking
+	 * CCtsyDispatcherCallback::CallbackPhonebookStoreWriteEntryComp()
+	 *
+	 * Implementation of this interface should request to write an entry to a given phonebook.
+	 * The callback indicates when the operation is complete.
+	 *
+	 *
+	 * @param aPhonebook The phonebook to be written to.
+	 * @param aEntry The entry to be written, this is coded as a TLV, this can be decoded either
+	 * directly via a CPhoneBookBuffer() or via the CPhoneBookEntry::InternalizeFromTlvEntry() utility.
+	 *
+	 *
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 * 
+	 * @see RMobilePhoneBookStore::Write()
+	 * @see CPhoneBookBuffer()
+	 * @see CPhoneBookEntry::InternalizeFromTlvEntry()
+	 * 
+	 */
+	virtual TInt HandleStoreWriteEntryReqL(DispatcherPhonebook::TPhonebook aPhonebook, const TDesC8& aEntry) = 0;
+
+	}; // class MLtsyDispatchPhonebookStoreWriteEntry
+
+
+
+class MLtsyDispatchPhonebookGetPhoneStoreInfo : public MLtsyDispatchInterface
+	{
+public:
+
+	static const TInt KLtsyDispatchPhonebookGetPhoneStoreInfoApiId = KDispatchPhonebookFuncUnitId + 9;
+
+	/**
+	 * The CTSY Dispatcher shall invoke this function on receiving the EMobilePhoneGetPhoneStoreInfo
+	 * request from the CTSY.
+	 *
+	 * It is a request call that is completed by invoking
+	 * CCtsyDispatcherCallback::CallbackPhonebookGetPhoneStoreInfoComp()
+	 *
+	 * Implementation of this interface should request to get the information of a given store. The 
+	 * callback should be completed with the information. 
+	 *
+	 *
+	 * @param aStoreName The name of the store to retrieve the information from (e.g. KETelIccFdnPhoneBook).
+	 *
+	 *
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 * 
+	 * @see RMobilePhone::GetPhoneStoreInfo()
+	 */
+	virtual TInt HandleGetPhoneStoreInfoReqL(const TDesC& aStoreName) = 0;
+
+	}; // class MLtsyDispatchPhonebookGetPhoneStoreInfo
+
+
+
+class MLtsyDispatchPhonebookSmsStoreReadAll : public MLtsyDispatchInterface
+	{
+public:
+
+	static const TInt KLtsyDispatchPhonebookSmsStoreReadAllApiId = KDispatchPhonebookFuncUnitId + 10;
+
+	/**
+	 * The CTSY Dispatcher shall invoke this function on receiving the EMobilePhoneStoreReadAllPhase1
+	 * request from the CTSY.
+	 *
+	 * It is a request call that is completed by invoking
+	 * CCtsyDispatcherCallback::CallbackPhonebookSmsStoreReadAllComp()
+	 *
+	 * Implementation of this interface should handle phase 1 of reading all entries in the SMS storage.
+	 *
+	 *
+	 *
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 */
+	virtual TInt HandleSmsStoreReadAllReqL() = 0;
+
+	}; // class MLtsyDispatchPhonebookSmsStoreReadAll
+
+
+
+class MLtsyDispatchPhonebookSmsStoreDeleteEntry : public MLtsyDispatchInterface
+	{
+public:
+
+	static const TInt KLtsyDispatchPhonebookSmsStoreDeleteEntryApiId = KDispatchPhonebookFuncUnitId + 11;
+
+	/**
+	 * The CTSY Dispatcher shall invoke this function on receiving the EMobilePhoneStoreDelete
+	 * request from the CTSY.
+	 *
+	 * It is a request call that is completed by invoking
+	 * CCtsyDispatcherCallback::CallbackPhonebookSmsStoreDeleteEntryComp()
+	 *
+	 * Implementation of this interface should handle deletion of an entry in the SMS storage.
+	 *
+	 * @param aIndex index of the entry to be deleted.
+	 *
+	 *
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 */
+	virtual TInt HandleSmsStoreDeleteEntryReqL(TInt aIndex) = 0;
+
+	}; // class MLtsyDispatchPhonebookSmsStoreDeleteEntry
+
+
+
+class MLtsyDispatchPhonebookSmsStoreDeleteAll : public MLtsyDispatchInterface
+	{
+public:
+
+	static const TInt KLtsyDispatchPhonebookSmsStoreDeleteAllApiId = KDispatchPhonebookFuncUnitId + 12;
+
+	/**
+	 * The CTSY Dispatcher shall invoke this function on receiving the EMobilePhoneStoreDeleteAll
+	 * request from the CTSY.
+	 *
+	 * Implementation of this interface should handle deletion of all entries in the SMS storage.
+	 *
+	 *
+	 * It is a request call that is completed by invoking
+	 * CCtsyDispatcherCallback::CallbackPhonebookSmsStoreDeleteAllComp()
+	 *
+	 *
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 */
+	virtual TInt HandleSmsStoreDeleteAllReqL() = 0;
+
+	}; // class MLtsyDispatchPhonebookSmsStoreDeleteAll
+
+
+
+class MLtsyDispatchPhonebookSmsStoreGetInfo : public MLtsyDispatchInterface
+	{
+public:
+
+	static const TInt KLtsyDispatchPhonebookSmsStoreGetInfoApiId = KDispatchPhonebookFuncUnitId + 13;
+
+	/**
+	 * The CTSY Dispatcher shall invoke this function on receiving the EMobilePhoneStoreGetInfo
+	 * request from the CTSY.
+	 *
+	 * Implementation of this interface should handle retrieval information of the SMS storage.
+	 *
+	 * 
+	 * It is a request call that is completed by invoking
+	 * CCtsyDispatcherCallback::CallbackPhonebookSmsStoreGetInfoComp()
+	 *
+	 *
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 */
+	virtual TInt HandleSmsStoreGetInfoReqL() = 0;
+
+	}; // class MLtsyDispatchPhonebookSmsStoreGetInfo
+
+
+
+class MLtsyDispatchPhonebookSmsStoreReadEntry : public MLtsyDispatchInterface
+	{
+public:
+
+	static const TInt KLtsyDispatchPhonebookSmsStoreReadEntryApiId = KDispatchPhonebookFuncUnitId + 14;
+
+	/**
+	 * The CTSY Dispatcher shall invoke this function on receiving the EMobilePhoneStoreRead
+	 * request from the CTSY.
+	 *
+	 * It is a request call that is completed by invoking
+	 * CCtsyDispatcherCallback::CallbackPhonebookSmsStoreReadEntryComp()
+	 *
+	 * Implementation of this interface should handle reading of an entry in the SMS storage.
+	 *
+	 * @param aIndex the index of the entry to read from.
+	 *
+	 *
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 */
+	virtual TInt HandleSmsStoreReadEntryReqL(TInt aIndex) = 0;
+
+	}; // class MLtsyDispatchPhonebookSmsStoreReadEntry
+
+
+
+class MLtsyDispatchPhonebookSmsStoreWriteEntry : public MLtsyDispatchInterface
+	{
+public:
+
+	static const TInt KLtsyDispatchPhonebookSmsStoreWriteEntryApiId = KDispatchPhonebookFuncUnitId + 15;
+
+	/**
+	 * The CTSY Dispatcher shall invoke this function on receiving the EMobilePhoneStoreWrite
+	 * request from the CTSY.
+	 *
+	 * It is a request call that is completed by invoking
+	 * CCtsyDispatcherCallback::CallbackPhonebookSmsStoreWriteEntryComp()
+	 *
+	 * Implementation of this interface should handle the storing of a Gsm Sms entry.
+	 *
+	 * Defines contents of a fixed-size, stored GSM SMS entry.
+	 *
+	 * @param aMobileGsmEntry Defines contents of a fixed-size GSM SMS entry to be stored.
+	 *
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 */
+	virtual TInt HandleSmsStoreWriteEntryReqL(const RMobileSmsStore::TMobileGsmSmsEntryV1& aMobileGsmEntry) = 0;
+
+	}; // class MLtsyDispatchPhonebookSmsStoreWriteEntry
+
+
+#endif /*MLTSYDISPATCHPHONEBOOKINTERFACE_H_*/
diff -r 4a8d14a1a8ca -r ab1d0f4d2aa4 Telephony/ctsydispatchlayer/exportinc/mltsydispatchphonebookoninterface.h
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Telephony/ctsydispatchlayer/exportinc/mltsydispatchphonebookoninterface.h	Thu Aug 12 13:20:01 2010 +0100
@@ -0,0 +1,272 @@
+// Copyright (c) 2008-2009 Nokia Corporation and/or its subsidiary(-ies).
+// All rights reserved.
+// This component and the accompanying materials are made available
+// under the terms of "Eclipse Public License v1.0"
+// which accompanies this distribution, and is available
+// at the URL "http://www.eclipse.org/legal/epl-v10.html".
+//
+// Initial Contributors:
+// Nokia Corporation - initial contribution.
+//
+// Contributors:
+//
+// Description:
+// This file contains all the interfaces classes that can be implemented by
+// the Licensee LTSY relating to PhonebookOn related features.
+//
+
+
+
+
+/**
+ @file
+ @internalAll 
+*/
+
+
+#ifndef MLTSYDISPATCHPHONEBOOKONINTERFACE_H_
+#define MLTSYDISPATCHPHONEBOOKONINTERFACE_H_
+
+#include <ctsy/ltsy/mltsydispatchinterface.h>
+#include <etelmm.h>
+
+class MLtsyDispatchPhonebookOnStoreRead : public MLtsyDispatchInterface
+	{
+public:
+
+	static const TInt KLtsyDispatchPhonebookOnStoreReadApiId = KDispatchPhonebookOnFuncUnitId + 1;
+
+	/**
+	 * The CTSY Dispatcher shall invoke this function on receiving the EMmTsyONStoreReadIPC
+	 * request from the CTSY.
+	 *
+	 * It is a request call that is completed by invoking
+	 * CCtsyDispatcherCallback::CallbackPhonebookOnStoreReadComp()
+	 *
+	 * Implementation of this interface should handle reading a ON entry from the storage.
+	 *
+	 *
+	 * @param aIndex index of the ON entry.
+	 *
+	 *
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 */
+	virtual TInt HandleStoreReadReqL(TInt aIndex) = 0;
+
+	}; // class MLtsyDispatchPhonebookOnStoreRead
+
+
+
+class MLtsyDispatchPhonebookOnStoreDeleteAll : public MLtsyDispatchInterface
+	{
+public:
+
+	static const TInt KLtsyDispatchPhonebookOnStoreDeleteAllApiId = KDispatchPhonebookOnFuncUnitId + 2;
+
+	/**
+	 * The CTSY Dispatcher shall invoke this function on receiving the EMmTsyONStoreDeleteAllIPC
+	 * request from the CTSY.
+	 *
+	 * It is a request call that is completed by invoking
+	 * CCtsyDispatcherCallback::CallbackPhonebookOnStoreDeleteAllComp()
+	 *
+	 * Implementation of this interface should handle deletion of all entries of the storage.
+	 *
+	 *
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 */
+	virtual TInt HandleStoreDeleteAllReqL() = 0;
+
+	}; // class MLtsyDispatchPhonebookOnStoreDeleteAll
+
+
+
+class MLtsyDispatchPhonebookOnStoreReadEntry : public MLtsyDispatchInterface
+	{
+public:
+
+	static const TInt KLtsyDispatchPhonebookOnStoreReadEntryApiId = KDispatchPhonebookOnFuncUnitId + 3;
+
+	/**
+	 * The CTSY Dispatcher shall invoke this function on receiving the EMmTsyONStoreReadEntryIPC
+	 * request from the CTSY.
+	 *
+	 * It is a request call that is completed by invoking
+	 * CCtsyDispatcherCallback::CallbackPhonebookOnStoreReadEntryComp()
+	 *
+	 * Implementation of this interface should handle reading an entry from ON storage as one step of reading of all entries.
+	 *
+	 *
+	 * @param aIndex index of the entry,
+	 *
+	 *
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 */
+	virtual TInt HandleStoreReadEntryReqL(TInt aIndex) = 0;
+
+	}; // class MLtsyDispatchPhonebookOnStoreReadEntry
+
+
+
+class MLtsyDispatchPhonebookOnStoreGetInfo : public MLtsyDispatchInterface
+	{
+public:
+
+	static const TInt KLtsyDispatchPhonebookOnStoreGetInfoApiId = KDispatchPhonebookOnFuncUnitId + 4;
+
+	/**
+	 * The CTSY Dispatcher shall invoke this function on receiving the EMmTsyONStoreGetInfoIPC
+	 * request from the CTSY.
+	 *
+	 * It is a request call that is completed by invoking
+	 * CCtsyDispatcherCallback::CallbackPhonebookOnStoreGetInfoComp()
+	 *
+	 * Implementation of this interface should request to get the information of a given storage. The 
+	 * callback should be completed with the information.
+	 *
+	 *
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 */
+	virtual TInt HandleStoreGetInfoReqL() = 0;
+
+	}; // class MLtsyDispatchPhonebookOnStoreGetInfo
+
+
+
+class MLtsyDispatchPhonebookOnStoreGetReadStoreSize : public MLtsyDispatchInterface
+	{
+public:
+
+	static const TInt KLtsyDispatchPhonebookOnStoreGetReadStoreSizeApiId = KDispatchPhonebookOnFuncUnitId + 5;
+
+	/**
+	 * The CTSY Dispatcher shall invoke this function on receiving the EMmTsyONStoreReadSizeIPC
+	 * request from the CTSY.
+	 *
+	 * It is a request call that is completed by invoking
+	 * CCtsyDispatcherCallback::CallbackPhonebookOnStoreGetReadStoreSizeComp()
+	 *
+	 * Implementation of this interface should handle retrieving the size of the storage for read all operation.
+	 *
+	 *
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 */
+	virtual TInt HandleStoreGetReadStoreSizeReqL() = 0;
+
+	}; // class MLtsyDispatchPhonebookOnStoreGetReadStoreSize
+
+
+
+class MLtsyDispatchPhonebookOnStoreDeleteEntry : public MLtsyDispatchInterface
+	{
+public:
+
+	static const TInt KLtsyDispatchPhonebookOnStoreDeleteEntryApiId = KDispatchPhonebookOnFuncUnitId + 6;
+
+	/**
+	 * The CTSY Dispatcher shall invoke this function on receiving the EMmTsyONStoreDeleteIPC
+	 * request from the CTSY.
+	 *
+	 * It is a request call that is completed by invoking
+	 * CCtsyDispatcherCallback::CallbackPhonebookOnStoreDeleteEntryComp()
+	 *
+	 * Implementation of this interface should handle deletion of an ON entry.
+	 *
+	 *
+	 * @param aIndex index of the ON entry.
+	 *
+	 *
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 */
+	virtual TInt HandleStoreDeleteEntryReqL(TInt aIndex) = 0;
+
+	}; // class MLtsyDispatchPhonebookOnStoreDeleteEntry
+
+
+
+class MLtsyDispatchPhonebookOnStoreWriteEntry : public MLtsyDispatchInterface
+	{
+public:
+
+	static const TInt KLtsyDispatchPhonebookOnStoreWriteEntryApiId = KDispatchPhonebookOnFuncUnitId + 7;
+
+	/**
+	 * The CTSY Dispatcher shall invoke this function on receiving the EMmTsyONStoreWriteEntryIPC
+	 * request from the CTSY.
+	 *
+	 * It is a request call that is completed by invoking
+	 * CCtsyDispatcherCallback::CallbackPhonebookOnStoreWriteEntryComp()
+	 *
+	 * Implementation of this interface should handle storing of a ON entry as one step of storing of all entries in the ON storage.
+	 *
+	 *
+	 * @param aMobileOnEntry defines contents of a fixed-size ON entry to be stored. 
+	 *
+	 *
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 */
+	virtual TInt HandleStoreWriteEntryReqL(const RMobileONStore::TMobileONEntryV1& aMobileOnEntry) = 0;
+
+	}; // class MLtsyDispatchPhonebookOnStoreWriteEntry
+
+
+
+class MLtsyDispatchPhonebookOnStoreWrite : public MLtsyDispatchInterface
+	{
+public:
+
+	static const TInt KLtsyDispatchPhonebookOnStoreWriteApiId = KDispatchPhonebookOnFuncUnitId + 8;
+
+	/**
+	 * The CTSY Dispatcher shall invoke this function on receiving the EMmTsyONStoreWriteIPC
+	 * request from the CTSY.
+	 *
+	 * It is a request call that is completed by invoking
+	 * CCtsyDispatcherCallback::CallbackPhonebookOnStoreWriteComp()
+	 *
+	 * Implementation of this interface should handle storing of a ON entry.
+	 *
+	 * @param aMobileOnEntry defines contents of a fixed-size ON entry to be stored. 
+	 *
+	 *
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 */
+	virtual TInt HandleStoreWriteReqL(const RMobileONStore::TMobileONEntryV1& aMobileOnEntry) = 0;
+
+	}; // class MLtsyDispatchPhonebookOnStoreWrite
+
+
+
+class MLtsyDispatchPhonebookOnStoreGetStoreSize : public MLtsyDispatchInterface
+	{
+public:
+
+	static const TInt KLtsyDispatchPhonebookOnStoreGetStoreSizeApiId = KDispatchPhonebookOnFuncUnitId + 9;
+
+	/**
+	 * The CTSY Dispatcher shall invoke this function on receiving the EMmTsyONStoreWriteSizeIPC
+	 * request from the CTSY.
+	 *
+	 * It is a request call that is completed by invoking
+	 * CCtsyDispatcherCallback::CallbackPhonebookOnStoreGetStoreSizeComp()
+	 *
+	 * Implementation of this interface should handle retrieving of the size of the storage.
+	 *
+	 *
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 */
+	virtual TInt HandleStoreGetStoreSizeReqL() = 0;
+
+	}; // class MLtsyDispatchPhonebookOnStoreGetStoreSize
+
+
+#endif /*MLTSYDISPATCHPHONEBOOKONINTERFACE_H_*/
diff -r 4a8d14a1a8ca -r ab1d0f4d2aa4 Telephony/ctsydispatchlayer/exportinc/mltsydispatchphoneinterface.h
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Telephony/ctsydispatchlayer/exportinc/mltsydispatchphoneinterface.h	Thu Aug 12 13:20:01 2010 +0100
@@ -0,0 +1,893 @@
+// Copyright (c) 2008-2009 Nokia Corporation and/or its subsidiary(-ies).
+// All rights reserved.
+// This component and the accompanying materials are made available
+// under the terms of "Eclipse Public License v1.0"
+// which accompanies this distribution, and is available
+// at the URL "http://www.eclipse.org/legal/epl-v10.html".
+//
+// Initial Contributors:
+// Nokia Corporation - initial contribution.
+//
+// Contributors:
+//
+// Description:
+// This file contains all the interfaces classes that can be implemented by
+// the Licensee LTSY relating to Phone related features.
+//
+
+
+
+
+/**
+ @file
+ @internalAll 
+*/
+
+
+#ifndef MLTSYDISPATCHPHONEINTERFACE_H_
+#define MLTSYDISPATCHPHONEINTERFACE_H_
+
+#include <ctsy/ltsy/mltsydispatchinterface.h>
+#include <etelmm.h>
+#include <ctsy/rmmcustomapi.h>
+
+class MLtsyDispatchPhoneBootNotifyModemStatusReady : public MLtsyDispatchInterface
+	{
+public:
+
+    static const TInt KLtsyDispatchPhoneBootNotifyModemStatusReadyApiId = KDispatchPhoneFuncUnitId+1;
+
+	/**
+	 * The CTSY Dispatcher shall invoke this function on receiving the EMmTsyBootNotifyModemStatusReadyIPC
+	 * request from the CTSY.
+	 *
+	 * It is a request call that is completed by invoking CCtsyDispatcherCallback::CallbackPhoneBootNotifyModemStatusReadyComp()
+	 *
+	 * Implementation of this interface should indicate when the
+	 * Modem is ready for requests made from the CTSY.
+	 *
+	 * @return KErrNone on success otherwise another error code indicating the
+	 * failure.
+	 */
+	virtual TInt HandleBootNotifyModemStatusReadyReqL() = 0;
+
+	}; // class MLtsyDispatchPhoneBootNotifyModemStatusReady
+
+
+class MLtsyDispatchPhoneBootNotifySimStatusReady : public MLtsyDispatchInterface
+	{
+public:
+
+    static const TInt KLtsyDispatchPhoneBootNotifySimStatusReadyApiId = KDispatchPhoneFuncUnitId+2;
+
+	/**
+	 * The CTSY Dispatcher shall invoke this function on receiving the EMmTsyBootNotifySimStatusReadyIPC
+	 * request from the CTSY.
+	 *
+	 * It is a request call that is completed by invoking CCtsyDispatcherCallback::CallbackPhoneBootNotifySimStatusReadyComp()
+	 *
+	 * Implementation of this interface should indicate when the SIM is ready
+	 * for requests made from the CTSY.
+	 * For example, any caching of data has been completed.
+	 *
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 */
+	virtual TInt HandleBootNotifySimStatusReadyReqL() = 0;
+
+	}; // class MLtsyDispatchPhoneBootNotifySimStatusReady
+
+
+class MLtsyDispatchPhoneGetFdnStatus : public MLtsyDispatchInterface
+	{
+public:
+
+    static const TInt KLtsyDispatchPhoneGetFdnStatusApiId = KDispatchPhoneFuncUnitId + 3;
+
+	/**
+	 * The CTSY Dispatcher shall invoke this function on receiving the EMobilePhoneGetFdnStatus
+	 * request from the CTSY.
+	 *
+	 * It is a request call that is completed by invoking CCtsyDispatcherCallback::CallbackPhoneGetFdnStatusComp()
+	 *
+	 * Implementation of this interface should get the current FDN status.
+	 *
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 */
+	virtual TInt HandleGetFdnStatusReqL() = 0;
+
+	}; // class MLtsyDispatchPhoneGetFdnStatus
+
+
+class MLtsyDispatchPhoneGetHomeNetwork : public MLtsyDispatchInterface
+	{
+public:
+
+    static const TInt KLtsyDispatchPhoneGetHomeNetworkApiId = KDispatchPhoneFuncUnitId + 4;
+
+	/**
+	 * The CTSY Dispatcher shall invoke this function on receiving the EMobilePhoneGetHomeNetwork
+	 * request from the CTSY.
+	 *
+	 * It is a request call that is completed by invoking CCtsyDispatcherCallback::CallbackPhoneGetHomeNetworkComp()
+	 *
+	 * Implementation of this interface should get the current home network.
+	 *
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 */
+	virtual TInt HandleGetHomeNetworkReqL() = 0;
+
+	}; // class MLtsyDispatchPhoneGetHomeNetwork
+
+
+class MLtsyDispatchPhoneGetNetworkRegistrationStatus : public MLtsyDispatchInterface
+	{
+public:
+
+    static const TInt KLtsyDispatchPhoneGetNetworkRegistrationStatusApiId = KDispatchPhoneFuncUnitId + 5;
+
+	/**
+	 * The CTSY Dispatcher shall invoke this function on receiving the EMobilePhoneGetNetworkRegistrationStatus
+	 * request from the CTSY.
+	 *
+	 * It is a request call that is completed by invoking CCtsyDispatcherCallback::CallbackPhoneGetNetworkRegistrationStatusComp()
+	 *
+	 * Implementation of this interface should get the current network registration status.
+	 *
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 */
+	virtual TInt HandleGetNetworkRegistrationStatusReqL() = 0;
+
+	}; // class MLtsyDispatchPhoneGetNetworkRegistrationStatus
+
+
+class MLtsyDispatchPhoneSimRefreshRegister : public MLtsyDispatchInterface
+	{
+public:
+
+    static const TInt KLtsyDispatchPhoneSimRefreshRegisterApiId = KDispatchPhoneFuncUnitId + 6;
+
+	/**
+	 * The CTSY Dispatcher shall invoke this function on receiving the EMmTsySimRefreshRegisterIPC
+	 * request from the CTSY.
+	 *
+	 * It is a request call that is completed by invoking CCtsyDispatcherCallback::CallbackPhoneSimRefreshRegisterComp()
+	 *
+	 * Implementation of this interface should return whether registering for refresh indications on a list of SIM files was successful.
+	 * Note: When the LTSY needs to notify the CTSY of a refresh CCtsyDispatcherCallback::CallbackPhoneSimRefreshNowInd() should be invoked.
+	 *
+	 * @param aFilesToRegister  Bitmask containing list of files to register for refresh indications.
+	 *                           The list of possible files is specified in TCacheFileTypes.
+	 *
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 */
+	virtual TInt HandleSimRefreshRegisterReqL(TUint16 aFilesToRegister) = 0;
+
+	}; // class MLtsyDispatchPhoneSimRefreshRegister
+
+
+
+class MLtsyDispatchPhoneGetServiceProviderName : public MLtsyDispatchInterface
+	{
+public:
+
+	static const TInt KLtsyDispatchPhoneGetServiceProviderNameApiId = KDispatchPhoneFuncUnitId + 7;
+
+	/**
+	 * The CTSY Dispatcher shall invoke this function on receiving the EMobilePhoneGetServiceProviderName
+	 * request from the CTSY.
+	 *
+	 * It is a request call that is completed by invoking
+	 * CCtsyDispatcherCallback::CallbackPhoneGetServiceProviderNameComp()
+	 *
+	 * The service provider information to be returned is in the form RMobilePhone::TMobilePhoneServiceProviderNameV2.
+	 *
+	 *
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 */
+	virtual TInt HandleGetServiceProviderNameReqL() = 0;
+
+	}; // class MLtsyDispatchPhoneGetServiceProviderName
+
+
+
+class MLtsyDispatchPhoneGetPhoneId : public MLtsyDispatchInterface
+	{
+public:
+
+	static const TInt KLtsyDispatchPhoneGetPhoneIdApiId = KDispatchPhoneFuncUnitId + 8;
+
+	/**
+	 * The CTSY Dispatcher shall invoke this function on receiving the EMobilePhoneGetPhoneId
+	 * request from the CTSY.
+	 *
+	 * It is a request call that is completed by invoking
+	 * CCtsyDispatcherCallback::CallbackPhoneGetPhoneIdComp()
+	 *
+	 * Implementation of this interface should get the phone's identity as described by the
+	 * fields in RMobilePhone::TMobilePhoneIdentityV1.
+	 *
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 */
+	virtual TInt HandleGetPhoneIdReqL() = 0;
+
+	}; // class MLtsyDispatchPhoneGetPhoneId
+
+
+
+class MLtsyDispatchPhoneGetDetectedNetworks : public MLtsyDispatchInterface
+	{
+public:
+
+	static const TInt KLtsyDispatchPhoneGetDetectedNetworksApiId = KDispatchPhoneFuncUnitId + 9;
+
+	/**
+	 * The CTSY Dispatcher shall invoke this function on receiving the EMobilePhoneGetDetectedNetworksV2Phase1
+	 * request from the CTSY.
+	 *
+	 * It is a request call that is completed by invoking
+	 * CCtsyDispatcherCallback::CallbackPhoneGetDetectedNetworksComp()
+	 *
+	 * Implementation of this interface should get the current detected networks.
+	 *
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 */
+	virtual TInt HandleGetDetectedNetworksReqL() = 0;
+
+	}; // class MLtsyDispatchPhoneGetDetectedNetworks
+
+
+
+class MLtsyDispatchPhoneGetDetectedNetworksCancel : public MLtsyDispatchInterface
+	{
+public:
+
+	static const TInt KLtsyDispatchPhoneGetDetectedNetworksCancelApiId = KDispatchPhoneFuncUnitId + 10;
+
+	/**
+	 * The CTSY Dispatcher shall invoke this function on receiving the EMobilePhoneGetDetectedNetworksCancel
+	 * request from the CTSY.
+	 *
+	 * It is a request call that is completed by invoking
+	 * CCtsyDispatcherCallback::CallbackPhoneGetDetectedNetworksCancelComp()
+	 *
+	 * Implementation of this interface should cancel a pending retrieval of the detected networks.
+	 *
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 */
+	virtual TInt HandleGetDetectedNetworksCancelReqL() = 0;
+
+	}; // class MLtsyDispatchPhoneGetDetectedNetworksCancel
+
+
+
+class MLtsyDispatchPhoneSelectNetwork : public MLtsyDispatchInterface
+	{
+public:
+
+	static const TInt KLtsyDispatchPhoneSelectNetworkApiId = KDispatchPhoneFuncUnitId + 11;
+
+	/**
+	 * The CTSY Dispatcher shall invoke this function on receiving the EMobilePhoneSelectNetwork
+	 * request from the CTSY.
+	 *
+	 * It is a request call that is completed by invoking
+	 * CCtsyDispatcherCallback::CallbackPhoneSelectNetworkComp()
+	 *
+	 * Implementation of this interface should attempt a network selection.
+	 *
+	 * @param aIsManual Specifies whether phone should use a manual or automatic network selection method.
+	 * @param aNetworkManualSelection If aIsManual==ETrue, then this parameter contain the user's manually selected network.
+	 *
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 */
+	virtual TInt HandleSelectNetworkReqL(TBool aIsManual, const RMobilePhone::TMobilePhoneNetworkManualSelection& aNetworkManualSelection) = 0;
+
+	}; // class MLtsyDispatchPhoneSelectNetwork
+
+
+
+class MLtsyDispatchPhoneSelectNetworkCancel : public MLtsyDispatchInterface
+	{
+public:
+
+	static const TInt KLtsyDispatchPhoneSelectNetworkCancelApiId = KDispatchPhoneFuncUnitId + 12;
+
+	/**
+	 * The CTSY Dispatcher shall invoke this function on receiving the EMobilePhoneSelectNetworkCancel
+	 * request from the CTSY.
+	 *
+	 * It is a request call that is completed by invoking
+	 * CCtsyDispatcherCallback::CallbackPhoneSelectNetworkCancelComp()
+	 *
+	 * Implementation of this interface should cancel a pending network selection.
+	 *
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 */
+	virtual TInt HandleSelectNetworkCancelReqL() = 0;
+
+	}; // class MLtsyDispatchPhoneSelectNetworkCancel
+
+
+
+class MLtsyDispatchPhoneSetNetworkSelectionSetting : public MLtsyDispatchInterface
+	{
+public:
+
+	static const TInt KLtsyDispatchPhoneSetNetworkSelectionSettingApiId = KDispatchPhoneFuncUnitId + 13;
+
+	/**
+	 * The CTSY Dispatcher shall invoke this function on receiving the EMobilePhoneSetNetworkSelectionSetting
+	 * request from the CTSY.
+	 *
+	 * It is a request call that is completed by invoking
+	 * CCtsyDispatcherCallback::CallbackPhoneSetNetworkSelectionSettingComp()
+	 *
+	 * Implementation of this interface should set the new network selection.
+	 * Note: 	The completion of this will also invoke the network selection change
+	 * 			notifier in the CTSY (EMobilePhoneNotifyNetworkSelectionSettingChange).
+	 *
+	 * @param aPhoneNetworkSelection The new network selection setting.
+	 *
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 */
+	virtual TInt HandleSetNetworkSelectionSettingReqL(const RMobilePhone::TMobilePhoneNetworkSelectionV1& aPhoneNetworkSelection) = 0;
+
+	}; // class MLtsyDispatchPhoneSetNetworkSelectionSetting
+
+
+class MLtsyDispatchPhoneGetCurrentNetworkInfo : public MLtsyDispatchInterface
+	{
+public:
+
+    static const TInt KLtsyDispatchPhoneGetCurrentNetworkInfoApiId = KDispatchPhoneFuncUnitId + 14;
+
+	/**
+	 * The CTSY Dispatcher shall invoke this function after a NotifyModemReadyReceived event occurs,
+	 * normally during phone boot-up. It is an internal call.
+	 *
+	 * It is a request call that is completed by invoking CCtsyDispatcherCallback::CallbackPhoneGetCurrentNetworkInfoComp()
+	 *
+	 * Implementation of this interface should get the current network information.
+	 *
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 */
+	virtual TInt HandleGetCurrentNetworkInfoReqL() = 0;
+
+	}; // class MLtsyDispatchPhoneGetCurrentNetworkInfo
+
+
+class MLtsyDispatchPhoneGetNetworkMode : public MLtsyDispatchInterface
+	{
+public:
+
+    static const TInt KLtsyDispatchPhoneGetNetworkModeApiId = KDispatchPhoneFuncUnitId + 15;
+
+	/**
+	 * The CTSY Dispatcher shall invoke this function after a NotifyModemReadyReceived event occurs,
+	 * normally during phone boot-up. It is an internal call.
+	 *
+	 * It is a request call that is completed by invoking CCtsyDispatcherCallback::CallbackPhoneGetNetworkModeComp()
+	 *
+	 * Implementation of this interface should get the current network information.
+	 *
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 */
+	virtual TInt HandleGetNetworkModeReqL() = 0;
+
+	}; // class MLtsyDispatchPhoneGetNetworkMode
+
+
+class MLtsyDispatchPhoneGetNitzInfo : public MLtsyDispatchInterface
+	{
+public:
+
+    static const TInt KLtsyDispatchPhoneGetNitzInfoApiId = KDispatchPhoneFuncUnitId + 16;
+
+	/**
+	 * The CTSY Dispatcher shall invoke this function after a NotifyModemReadyReceived event occurs,
+	 * normally during phone boot-up. It is an internal call.
+	 *
+	 * It is a request call that is completed by invoking CCtsyDispatcherCallback::CallbackPhoneGetNitzInfoComp()
+	 *
+	 * Implementation of this interface should get the current network NITZ information.
+	 *
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 */
+	virtual TInt HandleGetNitzInfoReqL() = 0;
+
+	}; // class MLtsyDispatchPhoneGetNitzInfo
+
+class MLtsyDispatchPhoneGetSignalStrength : public MLtsyDispatchInterface
+	{
+public:
+
+    static const TInt KLtsyDispatchPhoneGetSignalStrengthApiId = KDispatchPhoneFuncUnitId + 17;
+
+	/**
+	 * The CTSY Dispatcher shall invoke this function after a NotifyModemReadyReceived event occurs,
+	 * normally during phone boot-up. It is an internal call.
+	 *
+	 * It is a request call that is completed by invoking CCtsyDispatcherCallback::CallbackPhoneGetSignalStrengthComp()
+	 *
+	 * Implementation of this interface should get the current network signal strength information.
+	 *
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 */
+	virtual TInt HandleGetSignalStrengthReqL() = 0;
+
+	}; // class MLtsyDispatchPhoneGetSignalStrength
+
+class MLtsyDispatchPhoneGetBatteryInfo : public MLtsyDispatchInterface
+	{
+public:
+
+    static const TInt KLtsyDispatchPhoneGetBatteryInfoApiId = KDispatchPhoneFuncUnitId + 18;
+
+	/**
+	 * The CTSY Dispatcher shall invoke this function after a NotifyModemReadyReceived event occurs,
+	 * normally during phone boot-up. It is an internal call.
+	 *
+	 * It is a request call that is completed by invoking CCtsyDispatcherCallback::CallbackPhoneGetBatteryInfoComp()
+	 *
+	 * Implementation of this interface should get the current battery information.
+	 *
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 */
+	virtual TInt HandleGetBatteryInfoReqL() = 0;
+
+	}; // class MLtsyDispatchPhoneGetBatteryInfo
+
+class MLtsyDispatchPhoneNspsWakeup : public MLtsyDispatchInterface
+	{
+public:
+
+    static const TInt KLtsyDispatchPhoneNspsWakeupApiId = KDispatchPhoneFuncUnitId + 19;
+
+	/**
+	 * The CTSY Dispatcher shall invoke this function on receiving the ECustomNetWakeupIPC
+	 * request from the CTSY.
+	 *
+	 * It is a request call that is completed by invoking
+	 * CCtsyDispatcherCallback::CallbackPhoneNspsWakeupComp().
+	 *
+	 * Implementation of this interface should wake the phone from a NSPS (No Service Power Save) state.
+	 *
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 */
+	virtual TInt HandleNspsWakeupReqL() = 0;
+
+	}; // class MLtsyDispatchPhoneNspsWakeup
+
+class MLtsyDispatchPhoneSetSystemNetworkMode : public MLtsyDispatchInterface
+	{
+public:
+
+    static const TInt KLtsyDispatchPhoneSetSystemNetworkModeApiId = KDispatchPhoneFuncUnitId + 20;
+
+	/**
+	 * The CTSY Dispatcher shall invoke this function on receiving the ECustomSetSystemNetworkModeIPC
+	 * request from the CTSY.
+	 *
+	 * It is a request call that is completed by invoking
+	 * CCtsyDispatcherCallback::CallbackPhoneSetSystemNetworkModeComp().
+	 *
+	 * Implementation of this interface should set the system network mode.
+	 *
+	 * @param aMode The new mode to set the system network to.
+	 *
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 */
+	virtual TInt HandleSetSystemNetworkModeReqL(RMmCustomAPI::TNetworkModeCaps aMode) = 0;
+
+	}; // class MLtsyDispatchPhoneSetSystemNetworkMode
+
+class MLtsyDispatchPhoneGetCurrentSystemNetworkModes : public MLtsyDispatchInterface
+	{
+public:
+
+    static const TInt KLtsyDispatchPhoneGetCurrentSystemNetworkModesApiId = KDispatchPhoneFuncUnitId + 21;
+
+	/**
+	 * The CTSY Dispatcher shall invoke this function on receiving the ECustomGetCurrentSystemNetworkModesIPC
+	 * request from the CTSY.
+	 *
+	 * It is a request call that is completed by invoking
+	 * CCtsyDispatcherCallback::CallbackPhoneGetCurrentSystemNetworkModesComp().
+	 *
+	 * Implementation of this interface should return the current system network mode.
+	 *
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 */
+	virtual TInt HandleGetCurrentSystemNetworkModesReqL() = 0;
+
+	}; // class MLtsyDispatchPhoneGetCurrentSystemNetworkModes
+
+class MLtsyDispatchPhoneResetNetServer : public MLtsyDispatchInterface
+	{
+public:
+
+    static const TInt KLtsyDispatchPhoneResetNetServerApiId = KDispatchPhoneFuncUnitId + 22;
+
+	/**
+	 * The CTSY Dispatcher shall invoke this function on receiving the ECustomResetNetServerIPC
+	 * request from the CTSY.
+	 *
+	 * It is a request call that is completed by invoking
+	 * CCtsyDispatcherCallback::CallbackPhoneResetNetServerComp().
+	 *
+	 * Implementation of this interface should reset the net server.
+	 *
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 */
+	virtual TInt HandleResetNetServerReqL() = 0;
+
+	}; // class MLtsyDispatchPhoneResetNetServer
+
+class MLtsyDispatchPhoneSetAlwaysOnMode : public MLtsyDispatchInterface
+	{
+public:
+
+    static const TInt KLtsyDispatchPhoneSetAlwaysOnModeApiId = KDispatchPhoneFuncUnitId + 23;
+
+	/**
+	 * The CTSY Dispatcher shall invoke this function on receiving the ECustomSetAlwaysOnMode
+	 * request from the CTSY.
+	 *
+	 * It is a request call that is completed by invoking
+	 * CCtsyDispatcherCallback::CallbackPhoneSetAlwaysOnModeComp().
+	 *
+	 * Implementation of this interface should set the "always on" mode.
+	 *
+	 * @param aMode The new "always on" mode to set, can be
+     *               RMmCustomAPI::EAlwaysModeVPLMN for VPLMN (Visited Public Land Mobile Network) always on,
+     *               RMmCustomAPI::EAlwaysModeHPLMN for HPLMN (Home Public Land Mobile Network) always on,
+     *               RMmCustomAPI::EAlwaysModeBoth for VPLMN and HPLMN always on,
+     *               RMmCustomAPI::EAlwaysModeNeither for neither VPLMN nor HPLMN always on.
+	 *
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 */
+	virtual TInt HandleSetAlwaysOnModeReqL(RMmCustomAPI::TSetAlwaysOnMode aMode) = 0;
+
+	}; // class MLtsyDispatchPhoneSetAlwaysOnMode
+
+class MLtsyDispatchPhoneSetDriveMode : public MLtsyDispatchInterface
+	{
+public:
+
+    static const TInt KLtsyDispatchPhoneSetDriveModeApiId = KDispatchPhoneFuncUnitId + 24;
+
+	/**
+	 * The CTSY Dispatcher shall invoke this function on receiving the ECustomSetDriveModeIPC
+	 * request from the CTSY.
+	 *
+	 * It is a request call that is completed by invoking
+	 * CCtsyDispatcherCallback::CallbackPhoneSetDriveModeComp().
+	 *
+	 * Implementation of this interface should set the drive mode status.
+	 *
+	 * @param aMode The new mode to set (RMmCustomAPI::EDeactivateDriveMode for deactivate drive mode
+     *               or RMmCustomAPI::EActivateDriveMode to activate drive mode).
+	 *
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 */
+	virtual TInt HandleSetDriveModeReqL(RMmCustomAPI::TSetDriveMode aMode) = 0;
+
+	}; // class MLtsyDispatchPhoneSetDriveMode
+
+class MLtsyDispatchPhoneGetHspaStatus : public MLtsyDispatchInterface
+	{
+public:
+
+    static const TInt KLtsyDispatchPhoneGetHspaStatusApiId = KDispatchPhoneFuncUnitId + 25;
+
+	/**
+	 * The CTSY Dispatcher shall invoke this function on receiving the ECustomReadHSxPAStatusIPC
+	 * request from the CTSY.
+	 *
+	 * It is a request call that is completed by invoking
+	 * CCtsyDispatcherCallback::CallbackPhoneGetHspaStatusComp().
+	 *
+	 * Implementation of this interface should return the phone high speed channel status.
+	 *
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 */
+	virtual TInt HandleGetHspaStatusReqL() = 0;
+
+	}; // class MLtsyDispatchPhoneGetHspaStatus
+
+class MLtsyDispatchPhoneSetHspaStatus : public MLtsyDispatchInterface
+	{
+public:
+
+    static const TInt KLtsyDispatchPhoneSetHspaStatusApiId = KDispatchPhoneFuncUnitId + 26;
+
+	/**
+	 * The CTSY Dispatcher shall invoke this function on receiving the ECustomWriteHSxPAStatusIPC
+	 * request from the CTSY.
+	 *
+	 * It is a request call that is completed by invoking
+	 * CCtsyDispatcherCallback::CallbackPhoneSetHspaStatusComp().
+	 *
+	 * Implementation of this interface should set the phone high speed channel status.
+	 *
+	 * @param aStatus The new HSxPA status (enabled or disabled).
+	 *
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 */
+	virtual TInt HandleSetHspaStatusReqL(RMmCustomAPI::THSxPAStatus aStatus) = 0;
+
+	}; // class MLtsyDispatchPhoneSetHspaStatus
+
+class MLtsyDispatchPhoneGetNetworkProviderName : public MLtsyDispatchInterface
+	{
+public:
+
+    static const TInt KLtsyDispatchPhoneGetNetworkProviderNameApiId = KDispatchPhoneFuncUnitId + 27;
+
+	/**
+	 * The CTSY Dispatcher shall invoke this function on receiving the ECustomGetNetworkProviderNameIPC
+	 * request from the CTSY.
+	 *
+	 * It is a request call that is completed by invoking
+	 * CCtsyDispatcherCallback::CallbackPhoneGetNetworkProviderNameComp().
+	 *
+	 * Implementation of this interface should return the name of the current network provider.
+	 *
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 */
+	virtual TInt HandleGetNetworkProviderNameReqL() = 0;
+
+	}; // class MLtsyDispatchPhoneGetNetworkProviderName
+
+class MLtsyDispatchPhoneGetOperatorName : public MLtsyDispatchInterface
+	{
+public:
+
+    static const TInt KLtsyDispatchPhoneGetOperatorNameApiId = KDispatchPhoneFuncUnitId + 28;
+
+	/**
+	 * The CTSY Dispatcher shall invoke this function on receiving the ECustomGetOperatorNameIPC
+	 * request from the CTSY.
+	 *
+	 * It is a request call that is completed by invoking
+	 * CCtsyDispatcherCallback::CallbackPhoneGetOperatorNameComp().
+	 *
+	 * Implementation of this interface should return the name of the current operator.
+	 *
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 */
+	virtual TInt HandleGetOperatorNameReqL() = 0;
+
+	}; // class MLtsyDispatchPhoneGetOperatorName
+
+class MLtsyDispatchPhoneGetCellInfo : public MLtsyDispatchInterface
+	{
+public:
+
+    static const TInt KLtsyDispatchPhoneGetCellInfoApiId = KDispatchPhoneFuncUnitId + 29;
+
+	/**
+	 * The CTSY Dispatcher shall invoke this function on receiving the ECustomGetCellInfoIPC
+	 * request from the CTSY.
+	 *
+	 * It is a request call that is completed by invoking one of the
+	 * CCtsyDispatcherCallback::CallbackPhoneGetCellInfoComp().
+	 *
+	 * Implementation of this interface should return the cell information.
+	 *
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 */
+	virtual TInt HandleGetCellInfoReqL() = 0;
+
+	}; // class MLtsyDispatchPhoneGetCellInfo
+
+class MLtsyDispatchPhoneRegisterCellInfoChangeNotification : public MLtsyDispatchInterface
+	{
+public:
+
+    static const TInt KLtsyDispatchPhoneRegisterCellInfoChangeNotificationApiId = KDispatchPhoneFuncUnitId + 30;
+
+	/**
+	 * The CTSY Dispatcher shall invoke this function on receiving the ECtsyPhoneCellInfoIndReq
+	 * request from the CTSY.
+	 *
+	 * It is a request call that is completed by invoking CCtsyDispatcherCallback::CallbackPhoneRegisterCellInfoChangeNotificationComp()
+	 *
+	 * Implementation of this interface should inform the LTSY that the CTSY wishes to register for
+	 * notifications when the Cell Information has changed.
+	 * 
+	 * These notifications can be provided via the LTSY by invoking
+	 * CCtsyDispatcherCallback::CallbackPhoneNotifyCellInfoChangeInd()
+	 * 
+	 * This call from the CTSY only occurs once on the first client side call of RMobilePhone::NotifyCellInfoChange().
+	 *
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 * 
+	 * @see RMobilePhone::NotifyCellInfoChange()
+	 */
+	virtual TInt HandleRegisterCellInfoChangeNotificationReqL() = 0;
+
+	}; // class MLtsyDispatchPhoneRegisterCellInfoChangeNotification
+
+class MLtsyDispatchPhoneGetPhoneCellInfo : public MLtsyDispatchInterface
+	{
+public:
+
+    static const TInt KLtsyDispatchPhoneGetPhoneCellInfoApiId = KDispatchPhoneFuncUnitId + 31;
+
+	/**
+	 * The CTSY Dispatcher shall invoke this function on receiving the ECtsyPhoneCellInfoReq
+	 * request from the CTSY.
+	 *
+	 * It is a request call that is completed by invoking CCtsyDispatcherCallback::CallbackPhoneGetPhoneCellInfoComp()
+	 *
+	 * Implementation of this interface should retrieve the current Cell Information.
+	 * 
+	 * Cell information is cached within the CTSY thus this handler is only invoked if the
+	 * CTSY does not currently hold valid cell information. E.g. the CTSY's cache has never
+	 * been populated as GetPhoneCellInfo Request-Complete has never been exercised, or never
+	 * been populated via CallbackPhoneNotifyCellInfoChangeInd(), or CallbackPhoneNotifyCellInfoChangeInd()
+	 * is completed with an error thus marking the cache as dirty.
+	 *
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 * 
+	 * @see RMobilePhone::GetCellInfo()
+	 */
+	virtual TInt HandleGetPhoneCellInfoReqL() = 0;
+
+	}; // class MLtsyDispatchPhoneGetPhoneCellInfo
+
+class MLtsyDispatchPhoneGetUsimServiceSupport : public MLtsyDispatchInterface
+	{
+public:
+
+    static const TInt KLtsyDispatchPhoneGetUsimServiceSupportApiId = KDispatchPhoneFuncUnitId + 32;
+
+	/**
+	 * The CTSY Dispatcher shall invoke this function on receiving the ECustomGetServiceTableSupportbyApplicationIPC
+	 * request from the CTSY.
+	 *
+	 * It is a request call that is completed by invoking CCtsyDispatcherCallback::CallbackPhoneGetUsimServiceSupportComp()
+	 *
+	 * Implementation of this interface should retrieve if the application is supported.
+	 * 
+	 * @param aApplicationNumber The application number to check support for in the USIM.
+	 *
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 * 
+	 *  @see RMmCustomAPI::GetUSIMServiceSupport()
+	 */
+	virtual TInt HandleGetGetUsimServiceSupportReqL(TInt aApplicationNumber) = 0;
+
+	}; // class MLtsyDispatchPhoneGetUsimServiceSupport
+
+class MLtsyDispatchPhoneGetCurrentActiveUsimApplication : public MLtsyDispatchInterface
+	{
+public:
+
+    static const TInt KLtsyDispatchPhoneGetCurrentActiveUsimApplicationApiId = KDispatchPhoneFuncUnitId + 33;
+
+	/**
+	 * The CTSY Dispatcher shall invoke this function on receiving the EMobilePhoneGetCurrentActiveUSimApplication
+	 * request from the CTSY.
+	 *
+	 * It is a request call that is completed by invoking CCtsyDispatcherCallback::CallbackPhoneGetCurrentActiveUsimApplicationComp()
+	 *
+	 * Implementation of this interface should retrieve the AID of the current active USIM application.
+	 * (There is only ever at most one USIM application active at a time)
+	 *
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 * 
+	 *  @see RMmCustomAPI::GetCurrentActiveUSimApplication()
+	 */
+	virtual TInt HandleGetCurrentActiveUsimApplicationReqL() = 0;
+
+	}; // class MLtsyDispatchPhoneGetCurrentActiveUsimApplication
+
+class MLtsyDispatchPhoneTerminateAllCalls : public MLtsyDispatchInterface
+	{
+public:
+
+    static const TInt KLtsyDispatchPhoneTerminateAllCallsApiId = KDispatchPhoneFuncUnitId + 34;
+
+	/**
+	 * The CTSY Dispatcher shall invoke this function on receiving the ECtsyPhoneTerminateAllCallsReq
+	 * request from the CTSY.
+	 *
+	 * It is a request call that is completed by invoking CCtsyDispatcherCallback::CallbackPhoneTerminateAllCallsComp()
+	 *
+	 * Implementation of this interface should terminate all active calls.
+	 * 
+	 * @param aCallId if a call is in the connecting state then this parameter will contain the id of that call, else 0.
+	 * 
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 * 
+	 *  @see RMobilePhone::TerminateAllCalls()
+	 */
+	virtual TInt HandleTerminateAllCallsReqL(TInt aCallId) = 0;
+
+	}; // class MLtsyDispatchPhoneTerminateAllCalls
+
+class MLtsyDispatchPhoneGetSystemNetworkBand : public MLtsyDispatchInterface
+	{
+public:
+
+    static const TInt KLtsyDispatchPhoneGetSystemNetworkBandApiId = KDispatchPhoneFuncUnitId + 35;
+
+	/**
+	 * The CTSY Dispatcher shall invoke this function on receiving the ECustomGetBandSelectionIPC
+	 * request from the CTSY.
+	 *
+	 * It is a request call that is completed by invoking CCtsyDispatcherCallback::CallbackPhoneGetSystemNetworkBandComp()
+	 *
+	 * Implementation of this interface should return the current band and network mode.	 
+	 * 
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 * 
+	 *  @see RMmCustomApi::GetSystemNetworkBand()
+	 */
+	virtual TInt HandleGetSystemNetworkBandReqL() = 0;
+
+	}; // class MLtsyDispatchPhoneGetSystemNetworkBand
+
+class MLtsyDispatchPhoneSetSystemNetworkBand : public MLtsyDispatchInterface
+	{
+public:
+
+    static const TInt KLtsyDispatchPhoneSetSystemNetworkBandApiId = KDispatchPhoneFuncUnitId + 36;
+
+	/**
+	 * The CTSY Dispatcher shall invoke this function on receiving the ECustomSetBandSelectionIPC
+	 * request from the CTSY.
+	 *
+	 * It is a request call that is completed by invoking CCtsyDispatcherCallback::CallbackPhoneSetSystemNetworkBandComp()
+	 *
+	 * Implementation of this interface should set the current band and network mode.	 
+	 * 
+	 * @param aBand the desired network band.
+	 * @param aMode the desired network mode.
+	 * 
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 * 
+	 *  @see RMmCustomApi::SetSystemNetworkBand()
+	 */
+	virtual TInt HandleSetSystemNetworkBandReqL(RMmCustomAPI::TBandSelection aBand, RMmCustomAPI::TNetworkModeCaps aMode) = 0;
+
+	}; // class MLtsyDispatchPhoneSetSystemNetworkBand
+
+#endif /*MLTSYDISPATCHPHONEINTERFACE_H_*/
diff -r 4a8d14a1a8ca -r ab1d0f4d2aa4 Telephony/ctsydispatchlayer/exportinc/mltsydispatchsatinterface.h
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Telephony/ctsydispatchlayer/exportinc/mltsydispatchsatinterface.h	Thu Aug 12 13:20:01 2010 +0100
@@ -0,0 +1,896 @@
+// Copyright (c) 2008-2009 Nokia Corporation and/or its subsidiary(-ies).
+// All rights reserved.
+// This component and the accompanying materials are made available
+// under the terms of "Eclipse Public License v1.0"
+// which accompanies this distribution, and is available
+// at the URL "http://www.eclipse.org/legal/epl-v10.html".
+//
+// Initial Contributors:
+// Nokia Corporation - initial contribution.
+//
+// Contributors:
+//
+// Description:
+// This file contains all the interfaces classes that can be implemented by
+// the Licensee LTSY relating to Sat related features.
+//
+
+
+
+
+/**
+ @file
+ @internalAll 
+*/
+
+
+#ifndef MLTSYDISPATCHSATINTERFACE_H_
+#define MLTSYDISPATCHSATINTERFACE_H_
+
+#include <ctsy/ltsy/mltsydispatchinterface.h>
+
+namespace DispatcherSat
+	{
+	
+	/**
+	 * This namespace contains all types relating to the SAT dispatcher.
+	 */
+	
+	/**
+	 * Enum containing the SS status
+	 */
+	enum TSsStatus
+		{
+		ENotBusy,
+		ESsBusy,
+		EUssdBusy
+		};
+	
+	}
+
+class MLtsyDispatchSatSmsDeliverReport : public MLtsyDispatchInterface
+	{
+public:
+
+	static const TInt KLtsyDispatchSatSmsDeliverReportApiId = KDispatchSatFuncUnitId + 1;
+
+	/**
+	 * This API is optional and should only be used if the licensee wishes to including the
+	 * Dispatcher beneath their own SIM ATK TSY.
+	 * 
+	 * The CTSY Dispatcher shall invoke this function on receiving the ESatTsySmsDeliverReport
+	 * request from the CTSY.
+	 * 
+	 * 
+	 * It is a request call that does not have an associated complete callback.
+	 *
+	 * Implementation of this interface should handle the requested SMS DELIVER REPORT Tpdu as
+	 * a result of the CCtsyDispatcherCallback::CallbackSatCreateSmsDeliverReportInd()
+	 * 
+	 * An SMS DELIVER REPORT TPDU is carried as a RP User Data element within an RP ERROR PDU 
+	 * and is part of the negative acknowledgement to an SMS DELIVER or SMS STATUS REPORT.
+	 * 
+	 * An SMS DELIVER REPORT TPDU is also carried as a RP User Data element within an RP ACK PDU 
+	 * and is part of a positive acknowledgement to a SMS DELIVER or SMS STATUS REPORT.
+	 * 
+	 *
+	 * @param aSmsDeliverReportTpdu The SMS-DELIVER-REPORT TPDU element to be contained in a 
+	 * RP-ERROR-PDU (negative acknowledgement) or RP-ACK-PDU (a positive acknowledgement) to a
+	 * SMS DELIVER or SMS STATUS REPORT
+	 *
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 */
+	virtual TInt HandleSmsDeliverReportReqL(const TDesC8& aSmsDeliverReportTpdu) = 0;
+
+	}; // class MLtsyDispatchSatSmsDeliverReport
+
+
+
+class MLtsyDispatchSatGetImageInstance : public MLtsyDispatchInterface
+	{
+public:
+
+	static const TInt KLtsyDispatchSatGetImageInstanceApiId = KDispatchSatFuncUnitId + 2;
+
+	/**
+	 * This API is optional and should only be used if the licensee wishes to including the
+	 * Dispatcher beneath their own SIM ATK TSY.
+	 * 
+	 * The CTSY Dispatcher shall invoke this function on receiving the ESatTsyGetImageInstance
+	 * request from the CTSY.
+	 * 
+	 * It is a request call that is completed by invoking
+	 * CCtsyDispatcherCallback::CallbackSatGetImageInstanceComp()
+	 * 
+	 * Implementation of this interface should retrieve an icon's image data from the UICC 
+	 * designated by aEfImgRecordNumber & aInstanceNumberInEfImgRecord
+	 *
+	 * @param aEfImgRecordNumber 			The record number of the icons EF(img) record for the 
+	 * 										icon image instance being retrieved. 
+	 * @param aInstanceNumberInEfImgRecord 	The record number of the icon instance, in the icons EF(img) record
+	 * 										for the icon image instance being retrieved. 
+	 *
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 */
+	virtual TInt HandleGetImageInstanceReqL(TUint8 aEfImgRecordNumber, TUint8 aInstanceNumberInEfImgRecord) = 0;
+
+	}; // class MLtsyDispatchSatGetImageInstance
+
+
+class MLtsyDispatchSatGetIconData : public MLtsyDispatchInterface
+	{
+public:
+
+	static const TInt KLtsyDispatchSatGetIconDataApiId = KDispatchSatFuncUnitId + 3;
+
+	/**
+	 * This API is optional and should only be used if the licensee wishes to including the
+	 * Dispatcher beneath their own SIM ATK TSY.
+	 * 
+	 * The CTSY Dispatcher shall invoke this function on receiving the ESatTsyGetIconData
+	 * request from the CTSY.
+	 * 
+	 * It is a request call that is completed by invoking
+	 * CCtsyDispatcherCallback::CallbackSatGetIconDataComp()
+	 * 
+	 * Implementation of this interface should retrieve an icon's EF record from the UICC based
+	 * on the record number (see ETSI TS 131 102 Under EFIMG (Image) & Files of USIM)
+	 *
+	 * @param aEfImgRecordNumber 	EF(img) record number of the icon to retrieve 
+	 * @param aSimFilePath 			The full file path to the EF(Img) 
+	 * 								Bytes 	0-1 MF 			(0x3F00)
+	 * 								Bytes	2-3 DF(Telecom) (0x7F10) 
+	 * 								Bytes	4-5 DF(Graphics)(0x5F50)
+	 * 								Bytes	6-7 EF(Ef(Img)) 	(0x4F20)
+	 *
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 */
+	virtual TInt HandleGetIconDataReqL(TUint8 aEfImgRecordNumber, const TDesC8& aSimFilePath) = 0;
+
+	}; // class MLtsyDispatchSatGetIconData
+
+
+
+class MLtsyDispatchSatGetClut : public MLtsyDispatchInterface
+	{
+public:
+
+	static const TInt KLtsyDispatchSatGetClutApiId = KDispatchSatFuncUnitId + 4;
+
+	/**
+	 * This API is optional and should only be used if the licensee wishes to including the
+	 * Dispatcher beneath their own SIM ATK TSY.
+	 * 
+	 * The CTSY Dispatcher shall invoke this function on receiving the ESatTsyGetClut
+	 * request from the CTSY.
+	 * 
+	 * It is a request call that is completed by invoking
+	 * CCtsyDispatcherCallback::CallbackSatGetClutComp()
+	 * 
+	 * Implementation of this interface should retrieve the CLUT (Colour Lookup Table) for an image instance 
+	 * designated by aEfImgRecordNumber & aInstanceNumberInEfImgRecord
+	 *
+	 * @param aEfImgRecordNumber 			The record number of the icons EF(Img) record for the 
+	 * 										CLUT being retrieved.
+	 * @param aInstanceNumberInEfImgRecord 	The record number of the icon instance, in the icons EF(Img) record
+	 * 										for the CLUT being retrieved.
+	 *
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 */
+	virtual TInt HandleGetClutReqL(TUint8 aEfImgRecordNumber, TUint8 aInstanceNumberInEfImgRecord) = 0;
+
+	}; // class MLtsyDispatchSatGetClut
+
+
+
+class MLtsyDispatchSatGetDefaultBearerCapability : public MLtsyDispatchInterface
+	{
+public:
+
+	static const TInt KLtsyDispatchSatGetDefaultBearerCapabilityApiId = KDispatchSatFuncUnitId + 5;
+
+	/**
+	 * This API is optional and should only be used if the licensee wishes to including the
+	 * Dispatcher beneath their own SIM ATK TSY.
+	 * 
+	 * The CTSY Dispatcher shall invoke this function on receiving the ESatTsyGetBearerCapability
+	 * request from the CTSY.
+	 * 
+	 * It is a request call that is completed by invoking
+	 * CCtsyDispatcherCallback::CallbackSatGetDefaultBearerCapabilityComp()
+	 * 
+	 * Implementation of this interface should retrieve the current default bearer capability configuration.
+	 * 
+	 * The default bearer capability configuration (coding as defined by the access technologies) will be used 
+	 * by the CTSY when creating a Call Control ENVELOPE (the capability configuration parameters) if a zero length 
+	 * capability parameters is passed when creating the Envelope. 
+	 * See "ETSI TS 102 223" "Structure of ENVELOPE (CALL CONTROL)"
+	 * 
+	 * @see MLtsyDispatchSatCallAndSmsControlEnvelope::HandleCallAndSmsControlEnvelopeReqL()
+	 * @see CCtsyDispatcherCallback::CallbackSatCallControlEnvelopeResponseInd()
+	 *
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 */
+	virtual TInt HandleGetDefaultBearerCapabilityReqL() = 0;
+
+	}; // class MLtsyDispatchSatGetDefaultBearerCapability
+
+
+
+class MLtsyDispatchSatGetSmsPpDownloadSupported : public MLtsyDispatchInterface
+	{
+public:
+
+	static const TInt KLtsyDispatchSatGetSmsPpDownloadSupportedApiId = KDispatchSatFuncUnitId + 6;
+
+	/**
+	 * This API is optional and should only be used if the licensee wishes to including the
+	 * Dispatcher beneath their own SIM ATK TSY.
+	 * 
+	 * The CTSY Dispatcher shall invoke this function on receiving the ESatTsySmsPpDdlStatus
+	 * request from the CTSY.
+	 * 
+	 * It is a request call that is completed by invoking
+	 * CCtsyDispatcherCallback::CallbackSatGetSmsPpDownloadSupportedComp()
+	 * 
+	 * Implementation of this interface should retrieve if the service 
+	 * "data download via SMS Point-to-point" is allocated and activated in the SIM Service Table
+	 * and return the result via CCtsyDispatcherCallback::CallbackSatGetSmsPpDownloadSupportedComp()
+	 * 
+	 * @see 3GPP TS 11.14 section 7.1
+	 * @see 3GPP TS 11.11 section 11.6.12
+	 *
+	 *
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 */
+	virtual TInt HandleGetSmsPpDownloadSupportedReqL() = 0;
+
+	}; // class MLtsyDispatchSatGetSmsPpDownloadSupported
+
+
+
+class MLtsyDispatchSatGetSmsControlActivated : public MLtsyDispatchInterface
+	{
+public:
+
+	static const TInt KLtsyDispatchSatGetSmsControlActivatedApiId = KDispatchSatFuncUnitId + 7;
+
+	/**
+	 * This API is optional and should only be used if the licensee wishes to including the
+	 * Dispatcher beneath their own SIM ATK TSY.
+	 * 
+	 * The CTSY Dispatcher shall invoke this function on receiving the ESatTsyMoSmsControlActivation
+	 * request from the CTSY.
+	 * 
+	 * It is a request call that is completed by invoking
+	 * CCtsyDispatcherCallback::CallbackSatGetSmsControlActivatedComp()
+	 * 
+	 * Implementation of this interface should retrieve the current activation state of 
+	 * MO-SMS Control by USIM (Service n°31 in EFust).
+	 * 
+	 * @see 3GPP TS 11.11 section 11.6.16
+	 * @see 3GPP TS 31.102 section 4.2.8
+	 * 
+	 *
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 */
+	virtual TInt HandleGetSmsControlActivatedReqL() = 0;
+
+	}; // class MLtsyDispatchSatGetSmsControlActivated
+
+class MLtsyDispatchSatGetAccessTechnology : public MLtsyDispatchInterface
+	{
+public:
+
+	static const TInt KLtsyDispatchSatGetAccessTechnologyApiId = KDispatchSatFuncUnitId + 8;
+
+	/**
+	 * This API is optional and should only be used if the licensee wishes to including the
+	 * Dispatcher beneath their own SIM ATK TSY.
+	 * 
+	 * The CTSY Dispatcher shall invoke this function on receiving the ESatTsyAccTech
+	 * request from the CTSY.
+	 * 
+	 * It is a request call that is completed by invoking
+	 * CCtsyDispatcherCallback::CallbackSatGetAccessTechnologyComp()
+	 * 
+	 * Implementation of this interface should cause the current access technology to be
+	 * sent up to the CTSY via the CallbackSatGetAccessTechnologyComp() callback.
+	 * 
+	 * This request is generated when a LOCAL INFORMATION (access technology)
+	 * proactive command is received from UICC.
+	 * 
+	 *
+	 *
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 */
+	virtual TInt HandleGetAccessTechnologyReqL() = 0;
+
+	}; // class MLtsyDispatchSatGetAccessTechnology
+
+class MLtsyDispatchSatCellBroadcastEnvelope : public MLtsyDispatchInterface
+	{
+public:
+
+	static const TInt KLtsyDispatchSatCellBroadcastEnvelopeApiId = KDispatchSatFuncUnitId + 9;
+
+	/**
+	 * This API is optional and should only be used if the licensee wishes to including the
+	 * Dispatcher beneath their own SIM ATK TSY.
+	 * 
+	 * The CTSY Dispatcher shall invoke this function on receiving the ESatTsyCellBroadcast
+	 * request from the CTSY.
+	 * 
+	 * It is a request call that does not have an associated complete callback.
+	 * 
+	 * 
+	 * Implementation of this interface should hanldle Cell Broadcast Envelope commands.
+	 * This ENVELOPE is created as a result of a CallbackSatCreateCellBroadcastEnvelopeInd() call.
+	 *
+	 * Once the ME receives a new Cell Broadcast message and the service, if "data download via SMS-CB" is 
+	 * allocated and activated in the SIM Service Table and if the message identifier of the Cell Broadcast 
+	 * is contained within the message identifiers of the EF(CBMID), the the cell broadcast page is passed 
+	 * to the SIM using the ENVELOPE (CELL BROADCAST DOWNLOAD) command.
+	 * 
+	 * See "3GPP TS 11.14" Under "Cell Broadcast data download"
+	 * 
+	 *
+	 * @param aEnvelope BER-TLV encoded data containing an (CELL BROADCAST DOWNLOAD) ENVELOPE command. 
+	 *
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 */
+	virtual TInt HandleCellBroadcastEnvelopeReqL(const TDesC8& aEnvelope) = 0;
+
+	}; // class MLtsyDispatchSatCellBroadcastEnvelope
+
+
+
+class MLtsyDispatchSatTimingAdvance : public MLtsyDispatchInterface
+	{
+public:
+
+	static const TInt KLtsyDispatchSatTimingAdvanceApiId = KDispatchSatFuncUnitId + 10;
+
+	/**
+	 * This API is optional and should only be used if the licensee wishes to including the
+	 * Dispatcher beneath their own SIM ATK TSY.
+	 * 
+	 * The CTSY Dispatcher shall invoke this function on receiving the ESatTsyTimingAdvance
+	 * request from the CTSY.
+	 * 
+	 * It is a request call that is completed by invoking
+	 * CCtsyDispatcherCallback::CallbackSatTimingAdvanceComp()
+	 * 
+	 * Implementation of this interface should ascertain the Timing Advance measurement from the GSM/3G
+	 * protocol. It can then be provided to the SIM application in response to a PROVIDE LOCAL INFO 
+	 * proactive command.
+	 * 
+	 *
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 */
+	virtual TInt HandleTimingAdvanceReqL() = 0;
+
+	}; // class MLtsyDispatchSatTimingAdvance
+
+
+
+class MLtsyDispatchSatSmControlResponseData : public MLtsyDispatchInterface
+	{
+public:
+
+	static const TInt KLtsyDispatchSatSmControlResponseDataApiId = KDispatchSatFuncUnitId + 11;
+
+	/**
+	 * This API is optional and should only be used if the licensee wishes to including the
+	 * Dispatcher beneath their own SIM ATK TSY.
+	 * 
+	 * The CTSY Dispatcher shall invoke this function on receiving the ESatNotifyMoSmControlRequest
+	 * request from the CTSY.
+	 * 
+	 * It is a request call that does not have an associated complete callback.
+	 * 
+	 * Implementation of this interface should handle the parsed Mo Short Message Control response TLV data.
+	 * 
+	 * As a result of the ENVELOPE (MO SHORT MESSAGE CONTROL) command sent to the SIM, the SIM will respond
+	 * with a response TLV, this is can be passed to the LTSY via the 
+	 * CCtsyDispatcherCallback::CallbackSatSmControlEnvelopeResponseInd().
+	 * The CTSY parses this TLV, completes the RSat::NotifySmControlRequest() on the client side and passes
+	 * down the parsed data to the LTSY via this handler.
+	 * 
+	 * See "3GPP 11.14 - MO Short Message Control by SIM"
+	 *
+	 * @param aResult MO short message control result the SIM gives to the ME concerning whether to 
+	 * allow, bar or modify the proposed short message, encoded as defined in "3GPP TS 11.10-4, 27.22.8 MO SHORT MESSAGE CONTROL BY SIM" 
+	 * @param aRpDestinationAddress RP Destination Address of the Service Center to which the ME is proposing to send the short message.
+	 * If the address data is not present (zero length), then assume the RP Destination Address of the Service Center is not to be modified. 
+	 * @param aTpDestinationAddress TP Destination Address to which the ME is proposing to send the short message.
+	 * If the address data is not present (zero length), then assume the TP Destination Address is not to be modified. 
+	 *
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 */
+	virtual TInt HandleSmControlResponseDataReqL(
+			TUint8 aResult, const TDesC8& aRpDestinationAddress, const TDesC8& aTpDestinationAddress) = 0;
+
+	}; // class MLtsyDispatchSatSmControlResponseData
+
+
+
+class MLtsyDispatchSatProvideLocationInfo : public MLtsyDispatchInterface
+	{
+public:
+
+	static const TInt KLtsyDispatchSatProvideLocationInfoApiId = KDispatchSatFuncUnitId + 12;
+
+	/**
+	 * This API is optional and should only be used if the licensee wishes to including the
+	 * Dispatcher beneath their own SIM ATK TSY.
+	 * 
+	 * The CTSY Dispatcher shall invoke this function on receiving the ESatTsyProvideLocalInfo
+	 * request from the CTSY.
+	 * 
+	 * It is a request call that is completed by invoking
+	 * CCtsyDispatcherCallback::CallbackSatProvideLocationInfoComp()
+	 * 
+	 * Implementation of this interface should cause location information data to be provided, which can then be used
+	 * for Call/SS/USSD Control.
+	 * 
+	 * See "3GPP TS 11.14" section 9.1.1
+	 * 
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 */
+	virtual TInt HandleProvideLocationInfoReqL() = 0;
+
+	}; // class MLtsyDispatchSatProvideLocationInfo
+
+
+
+class MLtsyDispatchSatSetPollingInterval : public MLtsyDispatchInterface
+	{
+public:
+
+	static const TInt KLtsyDispatchSatSetPollingIntervalApiId = KDispatchSatFuncUnitId + 13;
+
+	/**
+	 * This API is optional and should only be used if the licensee wishes to including the
+	 * Dispatcher beneath their own SIM ATK TSY.
+	 * 
+	 * The CTSY Dispatcher shall invoke this function on receiving the ESatTsySetPolling
+	 * request from the CTSY.
+	 * 
+	 * It is a request call that is completed by invoking
+	 * CCtsyDispatcherCallback::CallbackSatSetPollingIntervalComp()
+	 * 
+	 * Implementation of this interface should attempt to update the polling interval in the LTSY.
+	 * 
+	 * A Proactive command from the UICC indicates the poll interval it requests from then onwards.
+	 * The CTSY then notifies the LTSY the maximum poll interval it should use in seconds 
+	 * (via a HandleSetPollingIntervalReqL()), the LTSY completes the request (via a CallbackSatSetPollingIntervalComp())
+	 * indicating the interval that will be used. If successful the CTSY then sends a terminal response, in response 
+	 * to the original proactive command. If unsuccessful and polling is currently off a terminal response is sent
+	 * with a result of Unable To Process Command, in the case where polling is currently on the request to the LTSY is 
+	 * re-attempted with a legacy polling interval of 25 seconds.
+	 * 
+	 * The polling interval ranges from a minimum of 5 and maximum of 255 seconds, 
+	 * a polling interval of zero (0) indiates that polling should be turned off.
+	 * 
+	 * See "ETSI TS 102 223" "POLL INTERVAL"
+	 *
+	 * @param aPollingInterval The polling interval in seconds indicating how often the 
+	 * terminal sends STATUS commands related to Proactive Polling 
+	 * (zero indicates Polling should be turned off) 
+	 *
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 */
+	virtual TInt HandleSetPollingIntervalReqL(TUint8 aPollingInterval) = 0;
+
+	}; // class MLtsyDispatchSatSetPollingInterval
+
+
+
+class MLtsyDispatchSatSmsPpDownloadEnvelope : public MLtsyDispatchInterface
+	{
+public:
+
+	static const TInt KLtsyDispatchSatSmsPpDownloadEnvelopeApiId = KDispatchSatFuncUnitId + 14;
+
+	/**
+	 * This API is optional and should only be used if the licensee wishes to including the
+	 * Dispatcher beneath their own SIM ATK TSY.
+	 * 
+	 * The CTSY Dispatcher shall invoke this function on receiving the ESatTsySmsPpDdl
+	 * request from the CTSY.
+	 * 
+	 * It is a request call that does not have an associated complete callback.
+	 * 
+	 * Implementation of this interface should hanlde a SMS-PP DOWNLOAD, ENVELOPE command 
+	 * to be passed to the SIM.
+	 * 
+	 * See "3GPP 11.14" Under "SMS-PP data download"
+	 * 
+	 * @param aEnvelope BER-TLV encoded data containing an (SMS-PP DOWNLOAD) ENVELOPE command 
+	 *
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 */
+	virtual TInt HandleSmsPpDownloadEnvelopeReqL(const TDesC8& aEnvelope) = 0;
+
+	}; // class MLtsyDispatchSatSmsPpDownloadEnvelope
+
+
+
+class MLtsyDispatchSatLocalInformationNmr : public MLtsyDispatchInterface
+	{
+public:
+
+	static const TInt KLtsyDispatchSatLocalInformationNmrApiId = KDispatchSatFuncUnitId + 15;
+
+	/**
+	 * This API is optional and should only be used if the licensee wishes to including the
+	 * Dispatcher beneath their own SIM ATK TSY.
+	 * 
+	 * The CTSY Dispatcher shall invoke this function on receiving the ESatTsyLocalInformationNmr
+	 * request from the CTSY.
+	 * 
+	 * It is a request call that is completed by invoking
+	 * CCtsyDispatcherCallback::CallbackSatLocalInformationNmrComp()
+	 * 
+	 * Implementation of this interface should request Network Measurement Results (NMR).
+	 * They can be requested by a "LOCAL INFO" proactive command and this API is called
+	 * during the construction of the command's Terminal Response.
+	 * 
+	 *
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 */
+	virtual TInt HandleLocalInformationNmrReqL() = 0;
+
+	}; // class MLtsyDispatchSatLocalInformationNmr
+
+class MLtsyDispatchSatCallAndSmsControlEnvelope : public MLtsyDispatchInterface
+	{
+public:
+
+	static const TInt KLtsyDispatchSatCallAndSmsControlEnvelopeApiId = KDispatchSatFuncUnitId + 16;
+
+	/**
+	 * This API is optional and should only be used if the licensee wishes to including the
+	 * Dispatcher beneath their own SIM ATK TSY.
+	 * 
+	 * The CTSY Dispatcher shall invoke this function on receiving the ESatTsySendEnvelope
+	 * request from the CTSY.
+	 * 
+	 * It is a request call that does not have an associated complete callback.
+	 * 
+	 * Implementation of this interface should cause the TLV data to be sent in an ENVELOPE
+	 * to the UICC. This interface is used for ENVELOPE commands related to call control events. 
+	 * 
+	 *
+	 * @param aEnvelope BER-TLV encoded data containing a Call Control or MO SMS control by SIM ENVELOPE command. 
+	 *
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 */
+	virtual TInt HandleCallAndSmsControlEnvelopeReqL(const TDesC8& aEnvelope) = 0;
+
+	}; // class MLtsyDispatchSatCallAndSmsControlEnvelope
+
+
+
+class MLtsyDispatchSatRefreshAllowed : public MLtsyDispatchInterface
+	{
+public:
+
+	static const TInt KLtsyDispatchSatRefreshAllowedApiId = KDispatchSatFuncUnitId + 17;
+
+	/**
+	 * This API is optional and should only be used if the licensee wishes to including the
+	 * Dispatcher beneath their own SIM ATK TSY.
+	 * 
+	 * The CTSY Dispatcher shall invoke this function on receiving the ESatTsyServiceRequest
+	 * request from the CTSY.
+	 * 
+	 * It is a request call that is completed by invoking
+	 * CCtsyDispatcherCallback::CallbackSatRefreshAllowedComp()
+	 *
+	 * 
+	 * Implementation of this interface allows the main RSat clients report (RSat::RefreshAllowed()) 
+	 * if the refresh can be carried out to be passed to the LTSY.
+	 * The completion CCtsyDispatcherCallback::CallbackSatRefreshAllowedComp()
+	 * completes any outstanding RSat::NotifyRefreshPCmd() requests.
+	 * 
+	 *
+	 * @param aRefreshFileList The list of files (full path) that have been changed by the UICC (see ETSI 102 221 or ETSI 151 011)
+	 * @param aAid Indicates the application on the UICC to be refreshed (as defined ETSI TS 101 220) . 
+	 * @param aTsyCache Bit field of files that are cached in SIM ATK TSY (examin using CSatNotificationsTsy::TCachedSimAtkFiles) 
+	 * 
+	 * @see RSat::NotifyRefreshRequired()
+	 * @see RSat::RefreshAllowed()
+	 * @see RMmCustomAPI::SatRefreshCompleteNotification()
+	 *
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 */
+	virtual TInt HandleRefreshAllowedReqL(const TDesC8& aRefreshFileList, const TDesC8& aAid, TUint16 aTsyCache) = 0;
+
+	}; // class MLtsyDispatchSatRefreshAllowed
+
+
+
+class MLtsyDispatchSatReady : public MLtsyDispatchInterface
+	{
+public:
+
+	static const TInt KLtsyDispatchSatReadyApiId = KDispatchSatFuncUnitId + 18;
+
+	/**
+	 * This API is optional and should only be used if the licensee wishes to including the
+	 * Dispatcher beneath their own SIM ATK TSY.
+	 * 
+	 * The CTSY Dispatcher shall invoke this function on receiving the ESatTsyReady
+	 * request from the CTSY.
+	 * 
+	 * Implementation of this interface allows the CTSY to signal that it is ready to receive proactive commands.
+	 *
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 */
+	virtual TInt HandleReadyReqL() = 0;
+
+	}; // class MLtsyDispatchSatReady
+
+
+
+class MLtsyDispatchSatPCmdNotification : public MLtsyDispatchInterface
+	{
+public:
+
+	static const TInt KLtsyDispatchSatPCmdNotificationApiId = KDispatchSatFuncUnitId + 19;
+
+	/**
+	 * This API is optional and should only be used if the licensee wishes to including the
+	 * Dispatcher beneath their own SIM ATK TSY.
+	 * 
+	 * The CTSY Dispatcher shall invoke this function on receiving the ESatTsyGetIfPendingNotification
+	 * request from the CTSY.
+	 * 
+	 * It is a request call that does not have an associated complete callback.
+	 * 
+	 * This function uses this API to register an interest in a particular proactive command. Once this notification
+	 * has been set up, the LTSY should call CCtsyDispatcherCallback::CallbackSatPcmdInd() to notify the CTSY the next 
+	 * time this proactive command is generated by the UICC (or provide notification immediately if the command is pending).
+	 * 
+	 * Proactive commands which are received via CCtsyDispatcherCallback::CallbackSatPcmdInd() while a notification has not 
+	 * been requested for this proactive command then a Terminal Response containing the return code "KMeUnableProcessCmd" 
+	 * will be sent back to the UICC. Therfore it is perfectly acceptable for the LTSY to pass all proactive commands directly
+	 * to the CTSY if it is preferred to have CTSY process proactive commands. If the latter implementation is chosen, LTSY does 
+	 * not have to implement the MLtsyDispatchSatPCmdNotification interface at all. 
+	 * 
+	 * @param aPCmdType The number of the proactive command for which notification is being requested (e.g. KSetUpMenu),
+	 *  as defined in ETSI 102 223 etc. these are defined in bertlv_defs.h  
+	 *
+	 * @see bertlv_defs.h
+	 * 
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 */
+	virtual TInt HandlePCmdNotificationReqL(TUint8 aPCmdType) = 0;
+
+	}; // class MLtsyDispatchSatPCmdNotification
+
+
+
+class MLtsyDispatchSatUssdControlEnvelopeError : public MLtsyDispatchInterface
+	{
+public:
+
+	static const TInt KLtsyDispatchSatUssdControlEnvelopeErrorApiId = KDispatchSatFuncUnitId + 20;
+
+	/**
+	 * This API is optional and should only be used if the licensee wishes to including the
+	 * Dispatcher beneath their own SIM ATK TSY.
+	 * 
+	 * The CTSY Dispatcher shall invoke this function on receiving the ESatTsyEnvelopeError
+	 * request from the CTSY.
+	 * 
+	 * It is a request call that is completed by invoking
+	 * CCtsyDispatcherCallback::CallbackSatGetUssdControlSupportedComp()
+	 * 
+	 * This interface is invoked if it has not been possible to construct an envelope for 
+	 * USSD control. This would occur if USSD strings are not supported for call control,
+	 * and the USSD control request cannot be submitted as an SS control request because it 
+	 * contains characters other than *, #, 0-9.
+	 * 
+	 * Implementation of this interface should handle this error appropriately (such as by
+	 * continuing the USSD setup process). 
+	 * 
+	 * @see MLtsyDispatchSatGetUssdControlSupported::HandleGetUssdControlSupportedReqL()
+	 *
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 */
+	virtual TInt HandleUssdControlEnvelopeErrorReqL() = 0;
+
+	}; // class MLtsyDispatchSatUssdControlEnvelopeError
+
+
+
+class MLtsyDispatchSatTimerExpirationEnvelope : public MLtsyDispatchInterface
+	{
+public:
+
+	static const TInt KLtsyDispatchSatTimerExpirationEnvelopeApiId = KDispatchSatFuncUnitId + 21;
+
+	/**
+	 * This API is optional and should only be used if the licensee wishes to including the
+	 * Dispatcher beneath their own SIM ATK TSY.
+	 * 
+	 * The CTSY Dispatcher shall invoke this function on receiving the ESatTsyTimerExpiredIPC
+	 * request from the CTSY.
+	 * 
+ 	 * It is a request call that does not have an associated complete callback.
+	 * 
+	 * The Timer managment proactive command requests the terminal to manage timers 
+	 * running physically in the terminal.
+	 * 
+	 * When a timer expires (i.e. reaches zero), the terminal shall use the Timer Expiration 
+	 * mechanism to transfer the identifier of the timer that has expired and the difference 
+	 * between the time when this transfer occurs and the time when the timer was initially started. 
+	 * The terminal then deactivates the timer.
+	 * 
+	 * This handler passes to the LTSY the Timer expiration ENVELOPE command, when a timer 
+	 * previously started by a TIMER MANAGEMENT proactive command has expired.
+	 * 
+	 * Note that the command will not be sent until any proactive command is no longer ongoing.
+	 * (i.e. the Terminal responses completion (CCtsyDispatcherCallback::CallbackSatTerminalRspComp() )
+	 * to the proactive command has been completed by the LTSY) 
+	 *
+	 *
+	 * @param aEnvelope BER-TLV encoded Timer expiration ENVELOPE command
+	 * see "ETSI TS 102 223" under "ENVELOPE commands" "Timer expiration" 
+	 *
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 */
+	virtual TInt HandleTimerExpirationEnvelopeReqL(const TDesC8& aEnvelope) = 0;
+
+	}; // class MLtsyDispatchSatTimerExpirationEnvelope
+
+
+
+class MLtsyDispatchSatTerminalRsp : public MLtsyDispatchInterface
+	{
+public:
+
+	static const TInt KLtsyDispatchSatTerminalRspApiId = KDispatchSatFuncUnitId + 22;
+
+	/**
+	 * This API is optional and should only be used if the licensee wishes to including the
+	 * Dispatcher beneath their own SIM ATK TSY.
+	 * 
+	 * The CTSY Dispatcher shall invoke this function on receiving the ESatTerminalRsp
+	 * request from the CTSY.
+	 *
+	 * It is a request call that is completed by invoking
+	 * CCtsyDispatcherCallback::CallbackSatTerminalRspComp()
+	 *
+	 * Implementation of this interface should allow responses to Proactive Commands to be provided to the LTSY.
+	 *
+	 * @param aTerminalRsp The terminal response TLV as formatted in "ETSI TS 102 223" Under "Structure of TERMINAL RESPONSE" 
+	 *
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 */
+	virtual TInt HandleTerminalRspReqL(const TDesC8& aTerminalRsp) = 0;
+
+	}; // class MLtsyDispatchSatTerminalRsp
+
+
+
+class MLtsyDispatchSatMenuSelectionEnvelope : public MLtsyDispatchInterface
+	{
+public:
+ 
+	static const TInt KLtsyDispatchSatMenuSelectionEnvelopeApiId = KDispatchSatFuncUnitId + 23;
+
+	/**
+	 * This API is optional and should only be used if the licensee wishes to including the
+	 * Dispatcher beneath their own SIM ATK TSY.
+	 * 
+	 * The CTSY Dispatcher shall invoke this function on receiving the ESatMenuSelection
+	 * request from the CTSY.
+	 * 
+	 * It is a request call that does not have an associated complete callback.
+	 * 
+	 * When the SIM application has previously specified a menu to the ME via the SETUP MENU proactive
+	 * command, this API is used by the ME to communicate to the SIM application either that the user has 
+	 * selected one of the menu items, or that the user has requested help information for one of the 
+	 * menu items.
+	 *  
+	 *
+	 * @param aEnvelope BER-TLV encoded Envelope containing the identifier of a menu item and whether the 
+	 * user of the ME has selected the menu item or requested help about it. 
+	 *
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 */
+	virtual TInt HandleMenuSelectionEnvelopeReqL(const TDesC8& aEnvelope) = 0;
+
+	}; // class MLtsyDispatchSatMenuSelectionEnvelope
+
+
+
+class MLtsyDispatchSatEventDownloadEnvelope : public MLtsyDispatchInterface
+	{
+public:
+
+	static const TInt KLtsyDispatchSatEventDownloadEnvelopeApiId = KDispatchSatFuncUnitId + 24;
+
+	/**
+	 * This API is optional and should only be used if the licensee wishes to including the
+	 * Dispatcher beneath their own SIM ATK TSY.
+	 * 
+	 * The CTSY Dispatcher shall invoke this function on receiving the ESatEventDownload
+	 * request from the CTSY.
+	 * 
+	 * It is a request call that does not have an associated complete callback.
+	 * 
+	 * The SET UP EVENT LIST proactive command gives the phone a list of events that may occur
+	 * to the phone.  The event list may include a change of access technology, user
+	 * action, browser termination and more.   The UICC must be informed when an event
+	 * on the list occurs - this is via  
+	 * MLtsyDispatchSatEventDownloadEnvelope::HandleEventDownloadEnvelopeReqL()
+	 *
+	 * @param aEnvelope BER-TLV encoded Event Download ENVELOPE command
+	 * see "ETSI TS 102 223" under "ENVELOPE commands" "Event Download" 
+	 *
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 * 
+	 * @see RSat::EventDownload()
+	 */
+	virtual TInt HandleEventDownloadEnvelopeReqL(const TDesC8& aEnvelope) = 0;
+
+	}; // class MLtsyDispatchSatEventDownloadEnvelope
+
+
+class MLtsyDispatchSatGetUssdControlSupported : public MLtsyDispatchInterface
+	{
+public:
+	
+	static const TInt KLtsyDispatchSatGetUssdControlSupportedApiId = KDispatchSatFuncUnitId + 25;
+	
+	/**
+	 * This API is optional and should only be used if the licensee wishes to including the
+	 * Dispatcher beneath their own SIM ATK TSY.
+	 * 
+	 * The CTSY Dispatcher shall invoke this function on receiving the ESatTsyUssdControlSupported
+	 * request from the CTSY.
+	 * 
+	 * It is a request call that is completed by invoking
+	 * CCtsyDispatcherCallback::CallbackSatGetUssdControlSupportedComp()
+	 *
+	 * Asks whether USSD string data objects are supported in call control. This setting is 
+	 * stored in EF-SST - see ETSI 151 011 etc. If USSD control is not supported, USSD control 
+	 * requests that can be coded as an SS string (i.e. *,#,0-9) will be submitted in this format.  
+	 *
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 */
+	virtual TInt HandleGetUssdControlSupportedReqL() = 0;
+	
+	}; //class MLtsyDispatchSatGetUssdControlSupported
+
+#endif /*MLTSYDISPATCHSATINTERFACE_H_*/
diff -r 4a8d14a1a8ca -r ab1d0f4d2aa4 Telephony/ctsydispatchlayer/exportinc/mltsydispatchsecurityinterface.h
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Telephony/ctsydispatchlayer/exportinc/mltsydispatchsecurityinterface.h	Thu Aug 12 13:20:01 2010 +0100
@@ -0,0 +1,358 @@
+// Copyright (c) 2008-2009 Nokia Corporation and/or its subsidiary(-ies).
+// All rights reserved.
+// This component and the accompanying materials are made available
+// under the terms of "Eclipse Public License v1.0"
+// which accompanies this distribution, and is available
+// at the URL "http://www.eclipse.org/legal/epl-v10.html".
+//
+// Initial Contributors:
+// Nokia Corporation - initial contribution.
+//
+// Contributors:
+//
+// Description:
+// This file contains all the interfaces classes that can be implemented by
+// the Licensee LTSY relating to Security related features.
+//
+
+
+
+
+/**
+ @file
+ @internalAll 
+*/
+
+
+#ifndef MLTSYDISPATCHSECURITYINTERFACE_H_
+#define MLTSYDISPATCHSECURITYINTERFACE_H_
+
+#include <ctsy/ltsy/mltsydispatchinterface.h>
+#include <etelmm.h>
+#include <ctsy/serviceapi/cmmutility.h>
+
+namespace DispatcherSecurity
+	{
+	
+	/**
+	 * This namespace contains all types relating to the Security dispatcher.
+	 */
+
+	enum TSecurityCodeId
+	    {   
+	    ESecCodeSecurity = 1,
+	    ESecCodePin,
+	    ESecCodePuk,
+	    ESecCodePin2,
+	    ESecCodePuk2,
+	    ESecCodeUpin = 7    
+	    };
+
+	}
+
+class MLtsyDispatchSecurityGetSecurityCodeInfo : public MLtsyDispatchInterface
+	{
+public:
+
+	static const TInt KLtsyDispatchSecurityGetSecurityCodeInfoApiId = KDispatchSecurityFuncUnitId + 1;
+
+	/**
+	 * The CTSY Dispatcher shall invoke this function on receiving the EMobilePhoneGetSecurityCodeInfo
+	 * request from the CTSY.
+	 *
+	 * It is a request call that is completed by invoking
+	 * CCtsyDispatcherCallback::CallbackSecurityGetSecurityCodeInfoComp()
+	 *
+	 * Implementation of this interface should allow a client to retrieve the current number or remaining entry attempts of a
+     *  security code.
+	 *
+	 * @param aSecCode The security code whose information is to be retrieved.
+	 *
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 */
+	virtual TInt HandleGetSecurityCodeInfoReqL(RMobilePhone::TMobilePhoneSecurityCode aSecCode) = 0;
+
+	}; // class MLtsyDispatchSecurityGetSecurityCodeInfo
+
+
+
+class MLtsyDispatchSecurityGetLockInfo : public MLtsyDispatchInterface
+	{
+public:
+
+	static const TInt KLtsyDispatchSecurityGetLockInfoApiId = KDispatchSecurityFuncUnitId + 2;
+
+	/**
+	 * The CTSY Dispatcher shall invoke this function on receiving the EMobilePhoneGetLockInfo
+	 * request from the CTSY.
+	 *
+	 * It is a request call that is completed by invoking
+	 * CCtsyDispatcherCallback::CallbackSecurityGetLockInfoComp()
+	 *
+	 * Implementation of this interface should retrieve the current status and setting of a lock.
+	 *
+	 * @param aLockType The lock type whose information is to be retrieved.
+	 *
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 */
+	virtual TInt HandleGetLockInfoReqL(RMobilePhone::TMobilePhoneLock aLockType) = 0;
+
+	}; // class MLtsyDispatchSecurityGetLockInfo
+
+
+
+class MLtsyDispatchSecurityAbortSecurityCode : public MLtsyDispatchInterface
+	{
+public:
+
+	static const TInt KLtsyDispatchSecurityAbortSecurityCodeApiId = KDispatchSecurityFuncUnitId + 3;
+
+	/**
+	 * The CTSY Dispatcher shall invoke this function on receiving the EMobilePhoneAbortSecurityCode
+	 * request from the CTSY.
+	 *
+	 * It is a request call that is completed by invoking
+	 * CCtsyDispatcherCallback::CallbackSecurityAbortSecurityCodeComp()
+	 *
+	 * Implementation of this interface should inform the phone that the user has cancelled an outstanding 
+     *  "get security code" or "verify security code" request.
+	 *
+	 * @param aSecCode Specifies which code request has been cancelled.
+	 *
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 */
+	virtual TInt HandleAbortSecurityCodeReqL(RMobilePhone::TMobilePhoneSecurityCode aSecCode) = 0;
+
+	}; // class MLtsyDispatchSecurityAbortSecurityCode
+
+
+
+class MLtsyDispatchSecurityGetCurrentActivePin : public MLtsyDispatchInterface
+	{
+public:
+
+	static const TInt KLtsyDispatchSecurityGetCurrentActivePinApiId = KDispatchSecurityFuncUnitId + 4;
+
+	/**
+	 * The CTSY Dispatcher shall invoke this function on receiving the EMmTsySecurityGetSimActivePinStateIPC
+	 * request from the CTSY.
+	 *
+	 * It is a request call that is completed by invoking
+	 * CCtsyDispatcherCallback::CallbackSecurityGetCurrentActivePinComp()
+	 *
+	 * Implementation of this interface should prepare the updating the information of the currently active PIN.
+	 *
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 */
+	virtual TInt HandleGetCurrentActivePinReqL() = 0;
+
+	}; // class MLtsyDispatchSecurityGetCurrentActivePin
+
+
+
+class MLtsyDispatchSecuritySetLockSetting : public MLtsyDispatchInterface
+	{
+public:
+
+	static const TInt KLtsyDispatchSecuritySetLockSettingApiId = KDispatchSecurityFuncUnitId + 5;
+
+	/**
+	 * The CTSY Dispatcher shall invoke this function on receiving the EMobilePhoneSetLockSetting
+	 * request from the CTSY.
+	 *
+	 * It is a request call that is completed by invoking
+	 * CCtsyDispatcherCallback::CallbackSecuritySetLockSettingComp()
+	 *
+	 * Implementation of this interface should allow a client to change the current setting of a lock.
+	 *
+	 * @param aLock The lock to change.
+	 * @param aSetting The new settings for the lock.
+	 * @param aPassword The password paramaters.
+	 *
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 * 
+	 * @see RMobilePhone::SetLockSetting()
+	 */
+	virtual TInt HandleSetLockSettingReqL(RMobilePhone::TMobilePhoneLock aLock, RMobilePhone::TMobilePhoneLockSetting aSetting, const TDesC& aPassword) = 0;
+
+	}; // class MLtsyDispatchSecuritySetLockSetting
+
+
+
+class MLtsyDispatchSecurityVerifySecurityCode : public MLtsyDispatchInterface
+	{
+public:
+
+	static const TInt KLtsyDispatchSecurityVerifySecurityCodeApiId = KDispatchSecurityFuncUnitId + 6;
+
+	/**
+	 * The CTSY Dispatcher shall invoke this function on receiving the EMobilePhoneVerifySecurityCode
+	 * request from the CTSY.
+	 *
+	 * It is a request call that is completed by invoking
+	 * CCtsyDispatcherCallback::CallbackSecurityVerifySecurityCodeComp()
+	 *
+	 * Implementation of this interface should send a security code requiring verification to the phone.
+	 * 
+	 *  If the security code required is one of the unblock codes (either PUK1 or 
+	 *  PUK2), then the user must supply a new PIN1 or PIN2 code as well as the associated 
+	 *  unblocking code. In this case, aUnblockCode will contain the unblocking code 
+     *  and aCode will contain the new PIN1 or PIN2 value. If the security code required 
+	 *  is NOT one of the unblock codes, then the user only has to supply the one 
+	 *  security code. In this case, aUnblockCode will be invalid and aCode will contain 
+	 *  the required security code (PIN1, PIN2 or Phone Password).
+	 *
+	 * @param aSecCode The type of code that is to be verified.
+	 * @param aCodes The actual code and if a PUK1 or PUK2 is specified, the PUK code.
+	 *
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 */
+	virtual TInt HandleVerifySecurityCodeReqL(
+				RMobilePhone::TMobilePhoneSecurityCode aSecCode,
+				const RMobilePhone::TCodeAndUnblockCode& aCodes) = 0;
+
+	}; // class MLtsyDispatchSecurityVerifySecurityCode
+
+class MLtsyDispatchSecurityGetPin1DisableSupported : public MLtsyDispatchInterface
+	{
+public:
+	static const TInt KLtsyDispatchSecurityGetPin1DisableSupportedApiId = KDispatchSecurityFuncUnitId + 7;
+	/**
+	 * The CTSY Dispatcher shall invoke this function on receiving the EMmTsyPhoneGetPin1DisableSupportedIPC
+	 * request from the CTSY.
+	 *
+	 * It is a request call that is completed by invoking
+	 * CCtsyDispatcherCallback::CallbackSecurityGetPin1DisableSupportedComp()
+	 *
+	 * Implementation of this interface should complete whether the SIM supports disabling of PIN1.
+	 * This is retrieved from either the EFsst (defined in 3GPP TS 31.102) or
+	 * EFust (defined in 3GPP TS 11.11) tables.
+	 *
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 */
+	virtual TInt HandleGetPin1DisableSupportedReqL() = 0;
+
+	}; // class MLtsyDispatchSimGetPin1DisableSupported
+	
+class MLtsyDispatchSecurityCheckSecurityCode : public MLtsyDispatchInterface
+	{
+public:
+	static const TInt KLtsyDispatchSecurityCheckSecurityCodeApiId = KDispatchSecurityFuncUnitId + 8;
+	/**
+	 * The CTSY Dispatcher shall invoke this function on receiving the ECustomCheckSecurityCodeIPC
+	 * request from the CTSY.
+	 * 
+	 * It is a request call that is completed by invoking
+	 * CCtsyDispatcherCallback::CallbackSecurityCheckSecurityCodeComp()
+	 * 
+	 * Implementation of this interface should anwser the check security code request.
+	 *
+	 * @param aCodeID Code ID. 
+	 * @param aSecCode Security code (maximum length = KMaxMobilePasswordSize).
+	 *
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 */
+	virtual TInt HandleCheckSecurityCodeReqL(DispatcherSecurity::TSecurityCodeId aSecCodeID, const TDes& aSecCode) = 0;
+
+	}; // class MLtsyDispatchSecurityCheckSecurityCode
+
+
+class MLtsyDispatchSecurityDisablePhoneLock : public MLtsyDispatchInterface
+	{
+public:
+	static const TInt KLtsyDispatchSecurityDisablePhoneLockApiId = KDispatchSecurityFuncUnitId + 9;
+	/**
+	 * The CTSY Dispatcher shall invoke this function on receiving the ECustomDisablePhoneLockIPC
+	 * request from the CTSY.
+	 * 
+	 * It is a request call that is completed by invoking
+	 * CCtsyDispatcherCallback::CallbackSecurityDisablePhoneLockComp()
+	 *
+	 * Implementation of this interface should disable phone lock.
+	 *
+	 * @param aSecCode Security code (maximum length = KMaxMobilePasswordSize).
+	 *
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 */
+	virtual TInt HandleDisablePhoneLockReqL(const TDesC& aSecCode) = 0;
+
+	}; // class MLtsyDispatchSecurityDisablePhoneLock
+
+class MLtsyDispatchSecurityGetCipheringInfo : public MLtsyDispatchInterface
+	{
+public:
+	static const TInt KLtsyDispatchSecurityGetCipheringInfoApiId = KDispatchSecurityFuncUnitId + 10;
+	/**
+	 * The CTSY Dispatcher shall invoke this function on receiving the ECustomGetCipheringInfoIPC
+	 * request from the CTSY.
+	 * 
+	 * It is a request call that is completed by invoking
+	 * CCtsyDispatcherCallback::CallbackSecurityGetCipheringInfoComp()
+	 * 
+	 * Implementation of this interface should allow retrieving ciphering info: indicator and ciphering status.
+	 *
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 */
+	virtual TInt HandleGetCipheringInfoReqL() = 0;
+
+	}; // class MLtsyDispatchSecurityGetCipheringInfo
+
+
+class MLtsyDispatchSecurityIsSecurityCodeBlocked : public MLtsyDispatchInterface
+	{
+public:
+	static const TInt KLtsyDispatchSecurityIsSecurityCodeBlockedApiId = KDispatchSecurityFuncUnitId + 11;
+	/**
+	 * The CTSY Dispatcher shall invoke this function on receiving the ECustomIsBlockedIPC
+	 * request from the CTSY.
+	 * 
+	 * It is a request call that is completed by invoking
+	 * CCtsyDispatcherCallback::CallbackSecurityIsSecurityCodeBlockedComp()
+	 *
+	 * Implementation of this interface should support retrieving synchronously the information
+	 * if the security code is blocked or not. 
+     *
+	 * @param aCodeID Code ID.
+	 *
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 */
+	virtual TInt HandleIsSecurityCodeBlockedReqL(DispatcherSecurity::TSecurityCodeId aSecCodeID) = 0;
+
+	}; // class MLtsyDispatchSecurityIsSecurityCodeBlocked
+
+class MLtsyDispatchSecurityCheckSecurityCodeCancel : public MLtsyDispatchInterface
+	{
+public:
+	static const TInt KLtsyDispatchSecurityCheckSecurityCodeCancelApiId = KDispatchSecurityFuncUnitId + 12;	
+	/**
+	 * The CTSY Dispatcher shall invoke this function on receiving the ECustomCheckSecurityCodeCancelIPC
+	 * request from the CTSY.
+	 * 
+	 * It is a request call that is completed by invoking
+	 * CCtsyDispatcherCallback::CallbackSecurityCheckSecurityCodeCancelComp()
+	 * 
+	 * Implementation of this interface should cancel check security code request.
+	 *
+	 * @param aCodeID Code ID.
+	 *
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 */
+	virtual TInt HandleCheckSecurityCodeCancelReqL(DispatcherSecurity::TSecurityCodeId aSecCodeID) = 0;
+
+	}; // class MLtsyDispatchSecurityCheckSecurityCodeCancel
+
+	
+
+#endif /*MLTSYDISPATCHSECURITYINTERFACE_H_*/
diff -r 4a8d14a1a8ca -r ab1d0f4d2aa4 Telephony/ctsydispatchlayer/exportinc/mltsydispatchsiminterface.h
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Telephony/ctsydispatchlayer/exportinc/mltsydispatchsiminterface.h	Thu Aug 12 13:20:01 2010 +0100
@@ -0,0 +1,775 @@
+// Copyright (c) 2008-2009 Nokia Corporation and/or its subsidiary(-ies).
+// All rights reserved.
+// This component and the accompanying materials are made available
+// under the terms of "Eclipse Public License v1.0"
+// which accompanies this distribution, and is available
+// at the URL "http://www.eclipse.org/legal/epl-v10.html".
+//
+// Initial Contributors:
+// Nokia Corporation - initial contribution.
+//
+// Contributors:
+//
+// Description:
+// This file contains all the interfaces classes that can be implemented by
+// the Licensee LTSY relating to Sim related features.
+//
+
+
+
+
+/**
+ @file
+ @internalAll 
+*/
+
+
+#ifndef MLTSYDISPATCHSIMINTERFACE_H_
+#define MLTSYDISPATCHSIMINTERFACE_H_
+
+#include <ctsy/ltsy/mltsydispatchinterface.h>
+#include <etelmm.h>
+#include <ctsy/rmmcustomapi.h>
+
+
+class MLtsyDispatchSimGetApnControlListServiceStatus : public MLtsyDispatchInterface
+	{
+public:
+
+	static const TInt KLtsyDispatchSimGetApnControlListServiceStatusApiId = KDispatchSimFuncUnitId + 1;
+
+	/**
+	 * The CTSY Dispatcher shall invoke this function on receiving the EMobilePhoneGetAPNControlListServiceStatus
+	 * request from the CTSY.
+	 *
+	 * It is a request call that is completed by invoking
+	 * CCtsyDispatcherCallback::CallbackSimGetApnControlListServiceStatusComp()
+	 *
+	 * Implementation of this interface should get the current Apn Control List Service status from the LTSY.
+	 *
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 */
+	virtual TInt HandleGetApnControlListServiceStatusReqL() = 0;
+
+	}; // class MLtsyDispatchSimGetApnControlListServiceStatus
+
+
+
+class MLtsyDispatchSimDeleteApnName : public MLtsyDispatchInterface
+	{
+public:
+
+	static const TInt KLtsyDispatchSimDeleteApnNameApiId = KDispatchSimFuncUnitId + 2;
+
+	/**
+	 * The CTSY Dispatcher shall invoke this function on receiving the EMobilePhoneDeleteAPNName
+	 * request from the CTSY.
+	 *
+	 * It is a request call that is completed by invoking
+	 * CCtsyDispatcherCallback::CallbackSimDeleteApnNameComp()
+	 *
+	 * Implementation of this interface should delete the given entry from the APN control list.
+	 *
+	 * @param aIndex The index of the entry to delete.
+	 *
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 */
+	virtual TInt HandleDeleteApnNameReqL(TUint32 aIndex) = 0;
+
+	}; // class MLtsyDispatchSimDeleteApnName
+
+
+
+class MLtsyDispatchSimEnumerateApnEntries : public MLtsyDispatchInterface
+	{
+public:
+
+	static const TInt KLtsyDispatchSimEnumerateApnEntriesApiId = KDispatchSimFuncUnitId + 3;
+
+	/**
+	 * The CTSY Dispatcher shall invoke this function on receiving the EMobilePhoneEnumerateAPNEntries
+	 * request from the CTSY.
+	 *
+	 * It is a request call that is completed by invoking
+	 * CCtsyDispatcherCallback::CallbackSimEnumerateApnEntriesComp()
+	 *
+	 * Implementation of this interface should enumerate the available APN names in the Access Control list.
+	 *
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 */
+	virtual TInt HandleEnumerateApnEntriesReqL() = 0;
+
+	}; // class MLtsyDispatchSimEnumerateApnEntries
+
+
+
+class MLtsyDispatchSimChangeSecurityCode : public MLtsyDispatchInterface
+	{
+public:
+
+	static const TInt KLtsyDispatchSimChangeSecurityCodeApiId = KDispatchSimFuncUnitId + 4;
+
+	/**
+	 * The CTSY Dispatcher shall invoke this function on receiving the EMobilePhoneChangeSecurityCode
+	 * request from the CTSY.
+	 *
+	 * It is a request call that is completed by invoking
+	 * CCtsyDispatcherCallback::CallbackSimChangeSecurityCodeComp()
+	 *
+	 * Implementation of this interface should allow a client to change a security code.
+	 *
+	 * @param aSecCode The security code to be changed.
+	 * @param aPasswds The old and the new values of the security code.
+	 *
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 */
+	virtual TInt HandleChangeSecurityCodeReqL(RMobilePhone::TMobilePhoneSecurityCode aSecCode,
+			   								  const RMobilePhone::TMobilePhonePasswordChangeV1& aPasswds) = 0;
+
+	}; // class MLtsyDispatchSimChangeSecurityCode
+
+
+
+class MLtsyDispatchSimSetFdnSetting : public MLtsyDispatchInterface
+	{
+public:
+
+	static const TInt KLtsyDispatchSimSetFdnSettingApiId = KDispatchSimFuncUnitId + 5;
+
+	/**
+	 * The CTSY Dispatcher shall invoke this function on receiving the EMobilePhoneSetFdnSetting
+	 * request from the CTSY.
+	 *
+	 * It is a request call that is completed by invoking
+	 * CCtsyDispatcherCallback::CallbackSimSetFdnSettingComp()
+	 *
+	 * Implementation of this interface should activate or deactivate the Fixed Dialling Numbers (FDN) service
+	 * PIN2 must have been verified prior to changing the Fixed Dialling Numbers setting.
+	 *
+	 * @param aFdnSetting The FDN setting value.
+	 *
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 */
+	virtual TInt HandleSetFdnSettingReqL(RMobilePhone::TMobilePhoneFdnSetting aFdnSetting) = 0;
+
+	}; // class MLtsyDispatchSimSetFdnSetting
+
+
+
+class MLtsyDispatchSimGetCustomerServiceProfile : public MLtsyDispatchInterface
+	{
+public:
+
+	static const TInt KLtsyDispatchSimGetCustomerServiceProfileApiId = KDispatchSimFuncUnitId + 6;
+
+	/**
+	 * The CTSY Dispatcher shall invoke this function on receiving the EMobilePhoneGetCustomerServiceProfile
+	 * request from the CTSY.
+	 *
+	 * It is a request call that is completed by invoking
+	 * CCtsyDispatcherCallback::CallbackSimGetCustomerServiceProfileComp()
+	 *
+	 * Implementation of this interface should retrieve the whole Customer Service Profile file from LTSY.
+	 *
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 */
+	virtual TInt HandleGetCustomerServiceProfileReqL() = 0;
+
+	}; // class MLtsyDispatchSimGetCustomerServiceProfile
+
+
+
+class MLtsyDispatchSimGetSubscriberId : public MLtsyDispatchInterface
+	{
+public:
+
+	static const TInt KLtsyDispatchSimGetSubscriberIdApiId = KDispatchSimFuncUnitId + 7;
+
+	/**
+	 * The CTSY Dispatcher shall invoke this function on receiving the EMobilePhoneGetSubscriberId
+	 * request from the CTSY.
+	 *
+	 * It is a request call that is completed by invoking
+	 * CCtsyDispatcherCallback::CallbackSimGetSubscriberIdComp()
+	 *
+	 * Implementation of this interface should get the subscriber's identity as described by its IMSI from the LTSY.
+	 *
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 */
+	virtual TInt HandleGetSubscriberIdReqL() = 0;
+
+	}; // class MLtsyDispatchSimGetSubscriberId
+
+
+
+class MLtsyDispatchSimAppendApnName : public MLtsyDispatchInterface
+	{
+public:
+
+	static const TInt KLtsyDispatchSimAppendApnNameApiId = KDispatchSimFuncUnitId + 8;
+
+	/**
+	 * The CTSY Dispatcher shall invoke this function on receiving the EMobilePhoneAppendAPNName
+	 * request from the CTSY.
+	 *
+	 * It is a request call that is completed by invoking
+	 * CCtsyDispatcherCallback::CallbackSimAppendApnNameComp()
+	 *
+	 * Implementation of this interface should append the given entry to the end of the APN control list.
+	 *
+	 * @param aEntry The entry to append to the APN list.
+	 *
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 */
+	virtual TInt HandleAppendApnNameReqL(const RMobilePhone::TAPNEntryV3& aEntry) = 0;
+
+	}; // class MLtsyDispatchSimAppendApnName
+
+
+
+class MLtsyDispatchSimGetActiveIccApplicationType : public MLtsyDispatchInterface
+	{
+public:
+
+	static const TInt KLtsyDispatchSimGetActiveIccApplicationTypeApiId = KDispatchSimFuncUnitId + 9;
+
+	/**
+	 * The CTSY Dispatcher shall invoke this function on receiving the EMmTsySimGetICCType
+	 * request from the CTSY.
+	 *
+	 * It is a request call that is completed by invoking
+	 * CCtsyDispatcherCallback::CallbackSimGetActiveIccApplicationTypeComp()
+	 *
+	 * This handler is called by the CTSY to retrieve the current active ICC application type.
+	 * Types are defined in MLtsyDispatchSimGetActiveIccApplicationType::TIccType.
+	 *
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 */
+	
+	enum TIccType
+	    {
+	    EIccTypeSim2GGsm,
+	    EIccTypeSim3G,
+	    EIccTypeSimUnknown
+	    };
+	
+	virtual TInt HandleGetActiveIccApplicationTypeReqL() = 0;
+
+	}; // class MLtsyDispatchSimGetActiveIccApplicationType
+
+
+
+class MLtsyDispatchSimSetIccMessageWaitingIndicators : public MLtsyDispatchInterface
+	{
+public:
+
+	static const TInt KLtsyDispatchSimSetIccMessageWaitingIndicatorsApiId = KDispatchSimFuncUnitId + 10;
+
+	/**
+	 * The CTSY Dispatcher shall invoke this function on receiving the EMobilePhoneSetIccMessageWaitingIndicators
+	 * request from the CTSY.
+	 *
+	 * It is a request call that is completed by invoking
+	 * CCtsyDispatcherCallback::CallbackSimSetIccMessageWaitingIndicatorsComp()
+	 *
+	 * Implementation of this interface should set the message waiting indicators on the current ICC.
+	 *
+	 * @param aIndicators The message waiting indicators to set.
+	 *
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 */
+	virtual TInt HandleSetIccMessageWaitingIndicatorsReqL(const RMobilePhone::TMobilePhoneMessageWaitingV1& aIndicators) = 0;
+
+	}; // class MLtsyDispatchSimSetIccMessageWaitingIndicators
+
+
+
+class MLtsyDispatchSimSetApnControlListServiceStatus : public MLtsyDispatchInterface
+	{
+public:
+
+	static const TInt KLtsyDispatchSimSetApnControlListServiceStatusApiId = KDispatchSimFuncUnitId + 11;
+
+	/**
+	 * The CTSY Dispatcher shall invoke this function on receiving the EMobilePhoneSetAPNControlListServiceStatus
+	 * request from the CTSY.
+	 *
+	 * It is a request call that is completed by invoking
+	 * CCtsyDispatcherCallback::CallbackSimSetApnControlListServiceStatusComp()
+	 *
+	 * Implementation of this interface should set the status of the APN Control List Service.
+	 *
+	 * @param aStatus The service status to set.
+	 *
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 */
+	virtual TInt HandleSetApnControlListServiceStatusReqL(RMobilePhone::TAPNControlListServiceStatus aStatus) = 0;
+
+	}; // class MLtsyDispatchSimSetApnControlListServiceStatus
+
+
+
+class MLtsyDispatchSimGetApnName : public MLtsyDispatchInterface
+	{
+public:
+
+	static const TInt KLtsyDispatchSimGetApnNameApiId = KDispatchSimFuncUnitId + 12;
+
+	/**
+	 * The CTSY Dispatcher shall invoke this function on receiving the EMobilePhoneGetAPNname
+	 * request from the CTSY.
+	 *
+	 * It is a request call that is completed by invoking
+	 * CCtsyDispatcherCallback::CallbackSimGetApnNameComp()
+	 *
+	 * Implementation of this interface should get the APN entry from the APN list at the index specified.
+	 *
+	 * @param aIndex The index of the APN entry to get from LTSY.
+	 *
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 */
+	virtual TInt HandleGetApnNameReqL(TUint32 aIndex) = 0;
+
+	}; // class MLtsyDispatchSimGetApnName
+
+
+
+class MLtsyDispatchSimSimRefreshDone : public MLtsyDispatchInterface
+	{
+public:
+	
+	static const TInt KLtsyDispatchSimSimRefreshDoneApiId = KDispatchSimFuncUnitId + 13;
+
+	/**
+	 * The CTSY Dispatcher shall invoke this function on receiving the EMmTsySimRefreshDoneIPC
+	 * request from the CTSY.
+	 *
+	 * It is a request call that has no complete.
+	 *
+	 *
+	 * Implementation of this interface indicates to the LTSY the SIM refresh has finished.
+	 *
+	 *
+	 * @param aError An error code relating to the result of the refresh.
+	 *
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 */
+	virtual TInt HandleSimRefreshDoneReqL(TInt aError) = 0;
+
+	}; // class MLtsyDispatchSimSimRefreshDone
+
+class MLtsyDispatchSimGetServiceTable : public MLtsyDispatchInterface
+	{
+public:
+	
+	static const TInt KLtsyDispatchSimGetServiceTableApiId = KDispatchSimFuncUnitId + 14;
+
+	/**
+	 * The CTSY Dispatcher shall invoke this function on receiving the EMobilePhoneGetServiceTable
+	 * request from the CTSY.
+	 *
+	 * It is a request call that is completed by invoking CCtsyDispatcherCallback::CallbackSimGetServiceTableComp()
+	 *
+	 * Implementation of this interface should read the EFust or EFsst service tables as specified by aServiceTable.
+	 *
+	 * @param aServiceTable Specifies the service table to retrieve.
+	 *
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 */
+	virtual TInt HandleGetServiceTableReqL(RMobilePhone::TMobilePhoneServiceTable aServiceTable) = 0;
+
+	}; // class MLtsyDispatchSimGetServiceTable
+
+class MLtsyDispatchSimGetIccMessageWaitingIndicators : public MLtsyDispatchInterface
+	{
+public:
+	
+	static const TInt KLtsyDispatchSimGetIccMessageWaitingIndicatorsApiId = KDispatchSimFuncUnitId + 15;
+
+	/**
+	 * The CTSY Dispatcher shall invoke this function on receiving the EMobilePhoneGetIccMessageWaitingIndicators
+	 * request from the CTSY.
+	 *
+	 * It is a request call that is completed by invoking CCtsyDispatcherCallback::CallbackSimGetIccMessageWaitingIndicatorsComp()
+	 *
+	 * Implementation of this interface should get the ICC message waiting indicators from the (U)SIM field EFmwis.
+	 *
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 */
+	virtual TInt HandleGetIccMessageWaitingIndicatorsReqL() = 0;
+
+	}; // class MLtsyDispatcSimGetIccMessageWaitingIndicators
+
+class MLtsyDispatchSimSimLockActivate : public MLtsyDispatchInterface
+	{
+public:
+
+	static const TInt KLtsyDispatchSimSimLockActivateApiId = KDispatchSimFuncUnitId + 16;
+
+	/**
+	 * The CTSY Dispatcher shall invoke this function on receiving the ECustomSimLockActivateIPC
+	 * request from the CTSY.
+	 * 
+	 * It is a request call that is completed by invoking
+	 * CCtsyDispatcherCallback::CallbackSimSimLockActivateComp()
+	 * 
+	 * Implementation of this interface should send a SIM Lock Activation request.
+	 *
+	 * @param aPassword The password used for the SIM Lock activation.
+	 * @param aLockNumber The lock number that defines SIM Lock types.
+	 *
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 */
+	virtual TInt HandleSimLockActivateReqL(const TDesC& aPassword, RMmCustomAPI::TLockNumber aLockNumber) = 0;
+
+	}; // class MLtsyDispatchSimSimLockActivate
+
+
+class MLtsyDispatchSimSimLockDeActivate : public MLtsyDispatchInterface
+	{
+public:
+
+	static const TInt KLtsyDispatchSimSimLockDeActivateApiId = KDispatchSimFuncUnitId + 17;
+
+	/**
+	 * The CTSY Dispatcher shall invoke this function on receiving the ECustomSimLockDeActivateIPC
+	 * request from the CTSY.
+	 * 
+	 * It is a request call that is completed by invoking
+	 * CCtsyDispatcherCallback::CallbackSimSimLockDeActivateComp()
+	 * 
+	 * Implementation of this interface should send a SIM Lock Deactivation request. 
+	 * 
+	 * @param aPassword The password used for the SIM Lock deactivation.
+	 * @param aLockNumber The lock number that defines SIM Lock types.
+	 *
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 */
+	virtual TInt HandleSimLockDeActivateReqL(const TDesC& aPassword, RMmCustomAPI::TLockNumber aLockNumber) = 0;
+
+	}; // class MLtsyDispatchSimSimLockDeActivate
+
+
+class MLtsyDispatchSimGetAnswerToReset : public MLtsyDispatchInterface
+	{
+public:
+
+	static const TInt KLtsyDispatchSimGetAnswerToResetApiId = KDispatchSimFuncUnitId + 18;
+
+	/**
+	 * The CTSY Dispatcher shall invoke this function on receiving the ECustomGetATRIPC
+	 * request from the CTSY.
+	 * 
+	 * It is a request call that is completed by invoking
+	 * CCtsyDispatcherCallback::CallbackSimGetAnswerToResetComp()
+	 * 
+	 * Implementation of this interface should retrieve the answer to reset. 
+	 *
+	 * @param aAnswerToReset The answer to reset information which contains details of the request.
+	 *
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 */
+	virtual TInt HandleGetAnswerToResetReqL(const TDesC8& aAnswerToReset) = 0;
+
+	}; // class MLtsyDispatchSimGetAnswerToReset
+
+
+class MLtsyDispatchSimGetSimCardReaderStatus : public MLtsyDispatchInterface
+	{
+public:
+
+	static const TInt KLtsyDispatchSimGetSimCardReaderStatusApiId = KDispatchSimFuncUnitId + 19;
+
+	/**
+	 * The CTSY Dispatcher shall invoke this function on receiving the ECustomGetSimCardReaderStatusIPC
+	 * request from the CTSY.
+	 * 
+	 * It is a request call that is completed by invoking
+	 * CCtsyDispatcherCallback::CallbackSimGetSimCardReaderStatusComp()
+	 * 
+	 * Implementation of this interface should retrieve the card reader status.
+	 *
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 */
+	virtual TInt HandleGetSimCardReaderStatusReqL() = 0;
+
+	}; // class MLtsyDispatchSimGetSimCardReaderStatus
+
+
+class MLtsyDispatchSimGetSimAuthenticationEapSimData : public MLtsyDispatchInterface
+	{
+public:
+
+	static const TInt KLtsyDispatchSimGetSimAuthenticationEapSimDataApiId = KDispatchSimFuncUnitId + 20;
+
+	/**
+	 * The CTSY Dispatcher shall invoke this function on receiving the ECustomGetSimAuthenticationDataIPC for 
+ 	 * Extensible Authentication Protocol Subscriber Identity Module authentication method
+	 * request from the CTSY.
+	 * 
+	 * It is a request call that is completed by invoking
+	 * CCtsyDispatcherCallback::CallbackSimGetSimAuthenticationEapSimDataComp()
+	 * 
+	 * Implementation of this interface should retrieve Sim Authentication Data for EapSim authentication method.
+	 *
+	 * @param aRandomParameters The random parameters from the client.
+	 * @param aRFStateInfo The RF state info.
+	 * 
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 */
+	virtual TInt HandleGetSimAuthenticationEapSimDataReqL(const TDesC8& aRandomParameters, TInt aRFStateInfo) = 0;
+
+	}; // class MLtsyDispatchSimGetSimAuthenticationEapSimData
+
+class MLtsyDispatchSimGetSimAuthenticationEapAkaData : public MLtsyDispatchInterface
+	{
+public:
+
+	static const TInt KLtsyDispatchSimGetSimAuthenticationEapAkaDataApiId = KDispatchSimFuncUnitId + 21;
+
+	/**
+	 * The CTSY Dispatcher shall invoke this function on receiving the ECustomGetSimAuthenticationDataIPC for 
+	 * Extensible Authentication Protocol UMTS Authentication and Key Agreement authentication method
+	 * request from the CTSY.
+	 * 
+	 * It is a request call that is completed by invoking
+	 * CCtsyDispatcherCallback::CallbackSimGetSimAuthenticationEapAkaDataComp()
+	 * 
+	 * Implementation of this interface should retrieve Sim Authentication Data for EapAka authentication method.
+	 *
+	 * @param aRandomParameters The random parameters from the client.
+	 * @param aAUTN The AUTN parameter. AUTN is an authentication value generated by
+	 *        the Authentication Centre, which, together with the random parameters, authenticates the server to the peer, 128 bits.
+	 * @param aRFStateInfo The RF state info.
+	 *
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 */
+	virtual TInt HandleGetSimAuthenticationEapAkaDataReqL(const TDesC8& aRandomParameters, const TDesC8& aAUTN, TInt aRFStateInfo) = 0;
+
+	}; // class MLtsyDispatchSimGetSimAuthenticationEapAkaData
+
+class MLtsyDispatchSimPowerSimOff : public MLtsyDispatchInterface
+	{
+public:
+
+	static const TInt KLtsyDispatchSimPowerSimOffApiId = KDispatchSimFuncUnitId + 22;
+
+	/**
+	 * The CTSY Dispatcher shall invoke this function on receiving the ECustomPowerSimOffIPC
+	 * request from the CTSY.
+	 * 
+	 * It is a request call that is completed by invoking
+	 * CCtsyDispatcherCallback::CallbackSimPowerSimOffComp()
+	 * 
+	 * Implementation of this interface should send a Power SIM Off request to the APDU server.
+	 *
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 * 
+	 * @see RMmCustomAPI::PowerSimOff()
+	 */
+	virtual TInt HandlePowerSimOffReqL() = 0;
+
+	}; // class MLtsyDispatchSimPowerSimOff
+
+
+class MLtsyDispatchSimPowerSimOn : virtual MLtsyDispatchInterface
+	{
+public:
+
+	static const TInt KLtsyDispatchSimPowerSimOnApiId = KDispatchSimFuncUnitId + 23;
+
+	/**
+	 * The CTSY Dispatcher shall invoke this function on receiving the ECustomPowerSimOnIPC
+	 * request from the CTSY.
+	 * 
+	 * It is a request call that is completed by invoking
+	 * CCtsyDispatcherCallback::CallbackSimPowerSimOnComp()
+	 * 
+	 * Implementation of this interface should send a Power SIM On request to the APDU server.
+	 *
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 * 
+	 * @see RMmCustomAPI::PowerSimOn()
+	 */
+	virtual TInt HandlePowerSimOnReqL() = 0;
+
+	}; // class MLtsyDispatchSimPowerSimOn
+
+
+class MLtsyDispatchSimReadSimFile : virtual MLtsyDispatchInterface
+	{
+public:
+
+	static const TInt KLtsyDispatchSimReadSimFileApiId = KDispatchSimFuncUnitId + 24;
+
+	/**
+	 * The CTSY Dispatcher shall invoke this function on receiving the ECustomReadSimFileIPC
+	 * request from the CTSY.
+	 * 
+	 * It is a request call that is completed by invoking
+	 * CCtsyDispatcherCallback::CallbackSimReadSimFileComp()
+	 * 
+	 * Implementation of this interface should request to read full or partial contents of a 
+	 * given SIM file. The path, size and offset for the requested SIM file are provided.
+	 * 
+	 *
+	 * @param aPath The absolute file path of the SIM file in the file system of the SIM.
+	 * see ETSI TS 131 102 Under "Files of USIM"
+	 * @param aOffset The value of the Offset, the offset is related with the type of SIM file being read.
+	 * @param aSize The amount of bytes to be read from the SIM file.
+	 *
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 * 
+	 * @see RMmCustomAPI::ReadSimFile()
+	 */
+	virtual TInt HandleReadSimFileReqL(const TDesC8& aPath, TUint16 aOffset, TUint16 aSize) = 0;
+
+	}; // class MLtsyDispatchSimReadSimFile
+
+
+class MLtsyDispatchSimSendApduRequest : virtual MLtsyDispatchInterface
+	{
+public:
+
+	static const TInt KLtsyDispatchSimSendApduRequestApiId = KDispatchSimFuncUnitId + 25;
+
+	/**
+	 * The CTSY Dispatcher shall invoke this function on receiving the ECustomSendAPDUReqIPC
+	 * request from the CTSY.
+	 * 
+	 * It is a request call that is completed by invoking
+	 * CCtsyDispatcherCallback::CallbackSimSendApduRequestComp()
+	 * 
+	 * Implementation of this interface should pass the send APDU request to the baseband.
+	 * 
+	 * The service type, card reader number and application type is the address information 
+	 * and the data is an envelope. The client side and baseband are responsible for the 
+	 * consistency of the data buffer's content (i.e. they have to have an agreement on the contents).
+	 * 
+	 *
+	 * @param aServiceType The value for the service type of the request.
+	 * @param aCardReaderNumber The value for the card reader number of the request.
+	 * @param aApplicationType The value for the application type of the request.
+	 * @param aCommandData The transparent data to be conveyed to the Baseband.
+	 *
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 * 
+	 * @see RMmCustomAPI::SendAPDUReq()
+	 */
+	virtual TInt HandleSimSendApduRequestReqL(TUint8 aServiceType, TUint8 aCardReaderNumber, TUint8 aApplicationType, const TDesC8& aCommandData) = 0;
+
+	}; // class MLtsyDispatchSimSendApduRequest
+
+class MLtsyDispatchSimSendApduRequestV2 : virtual MLtsyDispatchInterface
+	{
+public:
+
+	static const TInt KLtsyDispatchSimSendApduRequestV2ApiId = KDispatchSimFuncUnitId + 26;
+
+	/**
+	 * The CTSY Dispatcher shall invoke this function on receiving the ECustomSendAPDUReqV2IPC
+	 * request from the CTSY.
+	 * 
+	 * It is a request call that is completed by invoking
+	 * CCtsyDispatcherCallback::CallbackSimSendApduRequestV2Comp()
+	 * 
+	 * Implementation of this interface should pass the send APDU request to the baseband.
+	 * 
+	 * The client side and baseband are responsible for the consistency of the data buffer's content 
+	 * (i.e. they have to have an agreement on the contents).
+	 * 
+	 *
+	 * @param aCardReaderId The value for the card reader Id of the request.
+	 * @param aCommandData The transparent data to be conveyed to the Baseband.
+	 *
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 * 
+	 * @see RMmCustomAPI::SendAPDUReq()
+	 */
+	virtual TInt HandleSimSendApduRequestV2ReqL(TUint8 aCardReaderId, const TDesC8& aCommandData) = 0;
+
+	}; // class MLtsyDispatchSimSendApduRequest
+
+class MLtsyDispatchSimSimWarmReset : virtual MLtsyDispatchInterface
+	{
+public:
+
+	static const TInt KLtsyDispatchSimSimWarmResetApiId = KDispatchSimFuncUnitId + 27;
+
+	/**
+	 * The CTSY Dispatcher shall invoke this function on receiving the ECustomSimWarmResetIPC
+	 * request from the CTSY.
+	 * 
+	 * It is a request call that is completed by invoking
+	 * CCtsyDispatcherCallback::CallbackSimSimWarmResetComp()
+	 * 
+	 * Implementation of this interface should handle the reqest for a SIM warm reset.
+	 * 
+	 * See ETSI TS 102 221 under "Reset procedures"
+	 *
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 * 
+	 * @see RMmCustomAPI::SimWarmReset()
+	 */
+	virtual TInt HandleSimWarmResetReqL() = 0;
+
+	}; // class MLtsyDispatchSimSimWarmReset
+
+
+class MLtsyDispatchSimSetSimMessageStatusRead : virtual MLtsyDispatchInterface
+	{
+public:
+
+	static const TInt KLtsyDispatchSimSetSimMessageStatusReadApiId = KDispatchSimFuncUnitId + 28;
+
+	/**
+	 * The CTSY Dispatcher shall invoke this function on receiving the ECustomSetSimMessageStatusReadIPC
+	 * request from the CTSY.
+	 * 
+	 * It is a request call that is completed by invoking
+	 * CCtsyDispatcherCallback::CallbackSimSetSimMessageStatusReadComp()
+	 * 
+	 * No error code is returned to the ETel client - if no SMS message with matching timestamp is identified
+	 * on the SIM then this error will be silently ignored.
+	 *
+	 * @param aTimestamp timestamp that uniquely identifies a particular message in the message store.
+	 * @param aTimezoneDiff the difference, expressed in quarters of an hour, between the service centre local time and GMT
+	 *
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 * 
+	 * @see RMmCustomAPI::SetSimMessageStatusRead()
+	 */
+	virtual TInt HandleSetSimMessageStatusReadReqL(const TTime& aTimestamp, TInt aTimezoneDiff) = 0;
+
+	}; // class MLtsyDispatchSimSetSimMessageStatusRead
+
+
+#endif /*MLTSYDISPATCHSIMINTERFACE_H_*/
diff -r 4a8d14a1a8ca -r ab1d0f4d2aa4 Telephony/ctsydispatchlayer/exportinc/mltsydispatchsmsinterface.h
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Telephony/ctsydispatchlayer/exportinc/mltsydispatchsmsinterface.h	Thu Aug 12 13:20:01 2010 +0100
@@ -0,0 +1,436 @@
+// Copyright (c) 2008-2009 Nokia Corporation and/or its subsidiary(-ies).
+// All rights reserved.
+// This component and the accompanying materials are made available
+// under the terms of "Eclipse Public License v1.0"
+// which accompanies this distribution, and is available
+// at the URL "http://www.eclipse.org/legal/epl-v10.html".
+//
+// Initial Contributors:
+// Nokia Corporation - initial contribution.
+//
+// Contributors:
+//
+// Description:
+// This file contains all the interfaces classes that can be implemented by
+// the Licensee LTSY relating to Sms related features.
+//
+
+
+
+
+/**
+ @file
+ @internalAll 
+*/
+
+
+#ifndef MLTSYDISPATCHSMSINTERFACE_H_
+#define MLTSYDISPATCHSMSINTERFACE_H_
+
+#include <ctsy/ltsy/mltsydispatchinterface.h>
+#include <etelmm.h>
+
+namespace DispatcherSim
+	{
+	
+	/**
+	 * This namespace contains all types relating to the Sim dispatcher.
+	 */
+
+	/** SMS parameters */
+	struct TSmsParameters
+	    {
+	    /*
+	     * LocationNumber
+	     */    
+	    TUint8 iLocationNumber;
+
+	    /*
+	     * Parameter Indicator
+	     */    
+	    TUint8 iParameterIndicator;
+
+	    /*
+	     * ProtocolId
+	     */    
+	    TUint8 iProtocolId;
+
+	    /*
+	     * Data Coding Scheme
+	     */    
+	    TUint8 iDataCodingScheme;
+
+	    /*
+	     * Validity Period
+	     */    
+	    TUint8 iValidityPeriod;
+
+	    /*
+	     * MobileSc TON
+	     */    
+	    RMobilePhone::TMobileTON iMobileScTON;
+
+	    /*
+	     * MobileSc NPI
+	     */    
+	    RMobilePhone::TMobileNPI iMobileScNPI;
+
+	     /*
+	     * Mobile De TON
+	     */    
+	    RMobilePhone::TMobileTON iMobileDeTON;
+
+	    /*
+	     * Mobile De NPI
+	     */    
+	    RMobilePhone::TMobileNPI iMobileDeNPI;
+
+	    /*
+	     * Alpha Tag Present
+	     */    
+	    TBool iAlphaTagPresent;
+	    };	
+	}
+
+class MLtsyDispatchSmsSendSatSms : public MLtsyDispatchInterface
+	{
+public:
+
+	static const TInt KLtsyDispatchSmsSendSatSmsApiId = KDispatchSmsFuncUnitId + 1;
+
+	/**
+	 * The CTSY Dispatcher shall invoke this function on receiving the EMmTsySmsSendSatMessage
+	 * request from the CTSY.
+	 *
+	 * It is a request call that is completed by invoking
+	 * CCtsyDispatcherCallback::CallbackSmsSendSatSmsComp()
+	 *
+	 * Implementation of this interface should handle a request to send a SMS message initiated from a client
+	 * side RSat::SendMessageNoLogging() call.
+	 *
+	 * @param aDestination The mobile telephone number.
+	 * @param aSmsTpdu The SMS TPDU.
+	 * @param aDataFormat The SMS data format.
+	 * @param aGsmServiceCentre The service centre number.
+	 * @param aMore  This indicates whether the client is going to send another SMS immediately 
+	                 after this one.
+	 *
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 */
+	virtual TInt HandleSendSatSmsReqL( const TDesC8& aSmsTpdu,
+										   RMobileSmsMessaging::TMobileSmsDataFormat aDataFormat,
+										   const RMobilePhone::TMobileAddress& aGsmServiceCentre,
+										   TBool aMoreMessages
+										  ) = 0;
+	
+	}; // class MLtsyDispatchSmsSendSatSms
+
+
+
+class MLtsyDispatchSmsGetSmsStoreInfo : public MLtsyDispatchInterface
+	{
+public:
+
+	static const TInt KLtsyDispatchSmsGetSmsStoreInfoApiId = KDispatchSmsFuncUnitId + 2;
+
+	/**
+	 * The CTSY Dispatcher shall invoke this function on receiving the EMobileSmsMessagingGetMessageStoreInfo
+	 * request from the CTSY.
+	 *
+	 * It is a request call that is completed by invoking
+	 * CCtsyDispatcherCallback::CallbackSmsGetSmsStoreInfoComp()
+	 *
+	 * Implementation of this interface should retrieve the current Sms store information.
+	 *
+	 *
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 * 
+	 * @see RMobileSmsMessaging::GetMessageStoreInfo
+	 */
+	virtual TInt HandleGetSmsStoreInfoReqL() = 0;
+
+	}; // class MLtsyDispatchSmsGetSmsStoreInfo
+
+
+
+class MLtsyDispatchSmsGetSmspList : public MLtsyDispatchInterface
+	{
+public:
+
+	static const TInt KLtsyDispatchSmsGetSmspListApiId = KDispatchSmsFuncUnitId + 3;
+
+	/**
+	 * The CTSY Dispatcher shall invoke this function on receiving the EMobileSmsMessagingGetSmspListPhase1
+	 * request from the CTSY.
+	 *
+	 * It is a request call that is completed by invoking
+	 * CCtsyDispatcherCallback::CallbackSmsGetSmspListComp()
+	 *
+	 * Implementation of this interface should request to read the SMS parameter list from the SIM's SMSP store.
+	 *
+	 *
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 * 
+	 * @see CMobilePhoneSmspList()
+	 * @see CRetrieveMobilePhoneSmspList()
+	 */
+	virtual TInt HandleGetSmspListReqL() = 0;
+
+	}; // class MLtsyDispatchSmsGetSmspList
+
+
+
+class MLtsyDispatchSmsNackSmsStored : public MLtsyDispatchInterface
+	{
+public:
+
+	static const TInt KLtsyDispatchSmsNackSmsStoredApiId = KDispatchSmsFuncUnitId + 4;
+
+	/**
+	 * The CTSY Dispatcher shall invoke this function on receiving the EMobileSmsMessagingNackSmsStored
+	 * request from the CTSY.
+	 *
+	 * It is a request call that is completed by invoking
+	 * CCtsyDispatcherCallback::CallbackSmsNackSmsStoredComp()
+	 * 
+	 * Implementation of this interface should accept this negative acknowledgment: when the client receives an unstored SMS,
+	 * it will use this member function to return a negative acknowledgment if it fails to decode and/or store that SMS.
+	 * This TPDU will contain the TP error cause that prevents the client from acknowledging the SMS. 
+	 * The client should also provide the RP error cause by placing it in the aRpCause parameter.
+	 *
+	 * @param aTpdu Holds the TPDU defined for a SMS-DELIVER-REPORT (for RP-ERROR) in GSM 03.40.
+	 * @param aRpCause Contain one of the MS related extended error codes.
+	 *
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 * 
+	 * @see RMobileSmsMessaging::NackSmsStored()
+	 */
+	virtual TInt HandleNackSmsStoredReqL(const TDesC8& aTpdu, TInt aRpCause) = 0;
+
+	/**
+	 * The CTSY Dispatcher shall invoke this function on receiving the EMobileSmsMessagingNackSmsStored
+	 * request from the CTSY.
+	 *
+	 * It is a request call that is completed by invoking
+	 * CCtsyDispatcherCallback::CallbackSmsNackSmsStoredComp()
+	 * 
+	 * Implementation of this interface should accept this negative acknowledgment: when the client receives an unstored SMS,
+	 * it will use this member function to return a negative acknowledgment if it fails to decode and/or store that SMS.
+	 * The client should also provide the RP error cause by placing it in the aRpCause parameter.
+	 *
+	 * @param aRpCause Contain one of the MS related extended error codes.
+	 *
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 * 
+	 * @see RMobileSmsMessaging::NackSmsStored()
+	 */
+	virtual TInt HandleNackSmsStoredReqL(TInt aRpCause) = 0;
+
+	}; // class MLtsyDispatchSmsNackSmsStored
+
+
+
+class MLtsyDispatchSmsAckSmsStored : public MLtsyDispatchInterface
+	{
+public:
+
+	static const TInt KLtsyDispatchSmsAckSmsStoredApiId = KDispatchSmsFuncUnitId + 5;
+
+	/**
+	 * The CTSY Dispatcher shall invoke this function on receiving the EMobileSmsMessagingAckSmsStored
+	 * request from the CTSY.
+	 *
+	 * It is a request call that is completed by invoking
+	 * CCtsyDispatcherCallback::CallbackSmsAckSmsStoredComp()
+	 * 
+	 * Implementation of this interface should accept the acknowledgment: when the client receives an unstored SMS, 
+	 * it will trigger this function to return a positive acknowledgment if it manages to successfully decode and store that SMS.
+	 * If the client wishes to send a SMS-DELIVER-REPORT in response to the received SMS-DELIVER , 
+	 * then the aTpdu parameter will be used to hold the TPDU defined for a SMS-DELIVER-REPORT (for RP-ACK) in GSM 03.40. 
+	 *
+	 * 
+	 * @param aTpdu Holds the TPDU defined for a SMS-DELIVER-REPORT (for RP-ACK) in GSM 03.40.
+	 *
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 * 
+	 * @see RMobileSmsMessaging::AckSmsStored()
+	 */
+	virtual TInt HandleAckSmsStoredReqL(const TDesC8& aTpdu) = 0;
+	
+	/**
+	 * The CTSY Dispatcher shall invoke this function on receiving the EMobileSmsMessagingAckSmsStored
+	 * request from the CTSY.
+	 *
+	 * It is a request call that is completed by invoking
+	 * CCtsyDispatcherCallback::CallbackSmsAckSmsStoredComp()
+	 * 
+	 * Implementation of this interface should accept the acknowledgment: when the client receives an unstored SMS, 
+	 * it will trigger this function to return a positive acknowledgment if it manages to successfully decode and store that SMS.
+	 *
+	 * 
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 * 
+	 * @see RMobileSmsMessaging::AckSmsStored()
+	 */
+	virtual TInt HandleAckSmsStoredReqL() = 0;
+
+	}; // class MLtsyDispatchSmsAckSmsStored
+
+
+
+class MLtsyDispatchSmsResumeSmsReception : public MLtsyDispatchInterface
+	{
+public:
+
+	static const TInt KLtsyDispatchSmsResumeSmsReceptionApiId = KDispatchSmsFuncUnitId + 6;
+
+	/**
+	 * The CTSY Dispatcher shall invoke this function on receiving the EMobileSmsMessagingResumeSmsReception
+	 * request from the CTSY.
+	 *
+	 * It is a request call that is completed by invoking
+	 * CCtsyDispatcherCallback::CallbackSmsResumeSmsReceptionComp()
+	 *
+	 * Implementation of this interface should allow a client to resume sms reception 
+	 *
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 */
+	virtual TInt HandleResumeSmsReceptionReqL() = 0;
+
+	}; // class MLtsyDispatchSmsResumeSmsReception
+
+
+class MLtsyDispatchSmsSendSmsMessage : public MLtsyDispatchInterface
+	{
+public:
+
+	static const TInt KLtsyDispatchSmsSendSmsMessageApiId = KDispatchSmsFuncUnitId + 7;
+
+	/**
+	 * The CTSY Dispatcher shall invoke this function on receiving the EMobileSmsMessagingSendMessage
+	 * request from the CTSY.
+	 * 
+	 * It is a request call that is completed by invoking
+	 * CCtsyDispatcherCallback::CallbackSmsSendSmsMessageComp()
+	 * 
+	 * Implementation of this interface should allow a client to send a SMS message 
+	 * 
+	 * @param aDestination The mobile telephone number.
+	 * @param aSmsTpdu The SMS TPDU.
+	 * @param aDataFormat The SMS data format.
+	 * @param aGsmServiceCentre The service centre number.
+	 * @param aMore  This indicates whether the client is going to send another SMS immediately 
+	 *                after this one.
+	 *
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 */
+	virtual TInt HandleSendSmsMessageReqL( const RMobilePhone::TMobileAddress& aDestination,
+										   const TDesC8& aSmsTpdu,
+										   RMobileSmsMessaging::TMobileSmsDataFormat aDataFormat,
+										   const RMobilePhone::TMobileAddress& aGsmServiceCentre,
+										   TBool aMoreMessages
+										  ) = 0;
+
+
+	}; // class MLtsyDispatchSmsSendSmsMessage
+
+
+class MLtsyDispatchSmsSendSmsMessageNoFdnCheck : public MLtsyDispatchInterface
+	{
+public:
+
+	static const TInt KLtsyDispatchSmsSendSmsMessageNoFdnCheckApiId = KDispatchSmsFuncUnitId + 8;
+
+	/**
+	 * The CTSY Dispatcher shall invoke this function on receiving the EMobileSmsMessagingSendMessageNoFdnCheck
+	 * request from the CTSY.
+	 * 
+	 * It is a request call that is completed by invoking
+	 * CCtsyDispatcherCallback::CallbackSmsSendSmsMessageNoFdnCheckComp()
+	 * 
+	 * Implementation of this interface should allow a client to send a SMS message
+	 * 
+	 *
+	 * @param aDestination The mobile telephone number.
+	 * @param aSmsTpdu The SMS TPDU.
+	 * @param aDataFormat The SMS data format.
+	 * @param aGsmServiceCentre The service centre number.
+	 * @param aMore  This indicates whether the client is going to send another SMS immediately 
+	                 after this one.
+	 *
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 */
+	virtual TInt HandleSendSmsMessageNoFdnCheckReqL( const RMobilePhone::TMobileAddress& aDestination,
+												     const TDesC8& aSmsTpdu,
+													 RMobileSmsMessaging::TMobileSmsDataFormat aDataFormat,
+													 const RMobilePhone::TMobileAddress& aGsmServiceCentre,
+													 TBool aMoreMessages
+												   ) = 0;
+
+	}; // class MLtsyDispatchSmsSendSmsMessageNoFdnCheck
+
+
+class MLtsyDispatchSmsSetMoSmsBearer : public MLtsyDispatchInterface
+	{
+public:
+
+	static const TInt KLtsyDispatchSmsSetMoSmsBearerApiId = KDispatchSmsFuncUnitId + 9;
+
+	/**
+	 * The CTSY Dispatcher shall invoke this function on receiving the EMobileSmsMessagingSetMoSmsBearer
+	 * request from the CTSY.
+	 *
+	 * It is a request call that is completed by invoking
+	 * CCtsyDispatcherCallback::CallbackSmsSetMoSmsBearerComp()
+	 *
+	 * Implementation of this interface should allow client to set SMS bearer
+	 * 
+	 * @param aBearer The SMS bearer.
+	 * 
+	 *
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 */
+	virtual TInt HandleSetMoSmsBearerReqL(RMobileSmsMessaging::TMobileSmsBearer aBearer) = 0;
+
+	}; // class MLtsyDispatchSmsSetMoSmsBearer
+
+
+
+class MLtsyDispatchSmsStoreSmspListEntry : public MLtsyDispatchInterface
+	{
+public:
+
+	static const TInt KLtsyDispatchSmsStoreSmspListEntryApiId = KDispatchSmsFuncUnitId + 10;
+
+	/**
+	 * The CTSY Dispatcher shall invoke this function on receiving the EMobileSmsMessagingStoreSmspList
+	 * request from the CTSY.
+	 * 
+	 * It is a request call that is completed by invoking
+	 * CCtsyDispatcherCallback::CallbackSmsStoreSmspListComp()
+	 * 
+	 * Implementation of this interface should handle the request to store a SMSP entry 
+	 * in the SIM's SMSP file
+	 *
+	 * @param aSmspEntry Defines a set of SMS parameters
+	 *
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 */
+	virtual TInt HandleStoreSmspListEntryReqL(const RMobileSmsMessaging::TMobileSmspEntryV1& aSmspEntry) = 0;
+
+	}; // class MLtsyDispatchSmsStoreSmspList
+
+
+#endif /*MLTSYDISPATCHSMSINTERFACE_H_*/
diff -r 4a8d14a1a8ca -r ab1d0f4d2aa4 Telephony/ctsydispatchlayer/exportinc/mltsydispatchsupplementaryservicesinterface.h
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Telephony/ctsydispatchlayer/exportinc/mltsydispatchsupplementaryservicesinterface.h	Thu Aug 12 13:20:01 2010 +0100
@@ -0,0 +1,410 @@
+// Copyright (c) 2008-2009 Nokia Corporation and/or its subsidiary(-ies).
+// All rights reserved.
+// This component and the accompanying materials are made available
+// under the terms of "Eclipse Public License v1.0"
+// which accompanies this distribution, and is available
+// at the URL "http://www.eclipse.org/legal/epl-v10.html".
+//
+// Initial Contributors:
+// Nokia Corporation - initial contribution.
+//
+// Contributors:
+//
+// Description:
+// This file contains all the interfaces classes that can be implemented by
+// the Licensee LTSY relating to SupplementaryServices related features.
+//
+
+
+
+
+/**
+ @file
+ @internalAll 
+*/
+
+
+#ifndef MLTSYDISPATCHSUPPLEMENTARYSERVICESINTERFACE_H_
+#define MLTSYDISPATCHSUPPLEMENTARYSERVICESINTERFACE_H_
+
+#include <ctsy/ltsy/mltsydispatchinterface.h>
+#include <etelmm.h>
+
+
+class MLtsyDispatchSupplementaryServicesSendNetworkServiceRequestNoFdnCheck : public MLtsyDispatchInterface
+	{
+public:
+
+	static const TInt KLtsyDispatchSupplementaryServicesSendNetworkServiceRequestNoFdnCheckApiId = KDispatchSupplementaryServicesFuncUnitId + 1;
+
+	/**
+	 * The CTSY Dispatcher shall invoke this function on receiving the EMobilePhoneSendNetworkServiceRequestNoFdnCheck
+	 * request from the CTSY.
+	 *
+	 * It is a request call that is completed by invoking
+	 * CCtsyDispatcherCallback::CallbackSupplementaryServicesSendNetworkServiceRequestNoFdnCheckComp()
+	 * 
+	 * Implementation of this interface should send the request to the network without FDN check.
+	 *
+	 *
+	 * @param aRequest The supplementary services string that was entered by the user and need to be send to the network.
+	 *
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 */
+	virtual TInt HandleSendNetworkServiceRequestNoFdnCheckReqL(const TDesC& aRequest) = 0;
+
+	}; // class MLtsyDispatchSupplementaryServicesSendNetworkServiceRequestNoFdnCheck
+
+
+
+class MLtsyDispatchSupplementaryServicesGetCallWaitingStatus : public MLtsyDispatchInterface
+	{
+public:
+
+	static const TInt KLtsyDispatchSupplementaryServicesGetCallWaitingStatusApiId = KDispatchSupplementaryServicesFuncUnitId + 2;
+
+	/**
+	 * The CTSY Dispatcher shall invoke this function on receiving the EMobilePhoneGetWaitingStatusPhase1
+	 * request from the CTSY.
+	 *
+	 * It is a request call that is completed by invoking
+	 * CCtsyDispatcherCallback::CallbackSupplementaryServicesGetCallWaitingStatusComp()
+	 *
+	 * Implementation of this interface should get the call waiting list.
+	 *
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 */
+	virtual TInt HandleGetCallWaitingStatusReqL() = 0;
+
+	}; // class MLtsyDispatchSupplementaryServicesGetCallWaitingStatus
+
+
+
+class MLtsyDispatchSupplementaryServicesSendNetworkServiceRequest : public MLtsyDispatchInterface
+	{
+public:
+
+	static const TInt KLtsyDispatchSupplementaryServicesSendNetworkServiceRequestApiId = KDispatchSupplementaryServicesFuncUnitId + 3;
+
+	/**
+	 * The CTSY Dispatcher shall invoke this function on receiving the EMobilePhoneSendNetworkServiceRequest
+	 * request from the CTSY.
+	 *
+	 * It is a request call that is completed by invoking
+	 * CCtsyDispatcherCallback::CallbackSupplementaryServicesSendNetworkServiceRequestComp()
+	 * 
+	 * Implementation of this interface should send the request to the network after FDN check.
+	 *
+	 *
+	 * @param aRequest The supplementary services string that was entered by the user and need to be send to the network.
+	 *
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 */
+	virtual TInt HandleSendNetworkServiceRequestReqL(const TDesC& aRequest) = 0;
+
+	}; // class MLtsyDispatchSupplementaryServicesSendNetworkServiceRequest
+
+
+
+class MLtsyDispatchSupplementaryServicesGetCallBarringStatus : public MLtsyDispatchInterface
+	{
+public:
+
+	static const TInt KLtsyDispatchSupplementaryServicesGetCallBarringStatusApiId = KDispatchSupplementaryServicesFuncUnitId + 4;
+
+	/**
+	 * The CTSY Dispatcher shall invoke this function on receiving the EMobilePhoneGetBarringStatusPhase1
+	 * request from the CTSY.
+	 *
+	 * It is a request call that is completed by invoking
+	 * CCtsyDispatcherCallback::CallbackSupplementaryServicesGetCallBarringStatusComp()
+	 * 
+	 * Implementation of this interface should get the call barring list.
+	 *
+	 *
+	 * @param aCondition The barring conditions to interrogate.
+	 *
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 */
+	virtual TInt HandleGetCallBarringStatusReqL(RMobilePhone::TMobilePhoneCBCondition aCondition) = 0;
+
+	}; // class MLtsyDispatchSupplementaryServicesGetCallBarringStatus
+
+
+
+class MLtsyDispatchSupplementaryServicesSetCallBarringStatus : public MLtsyDispatchInterface
+	{
+public:
+
+	static const TInt KLtsyDispatchSupplementaryServicesSetCallBarringStatusApiId = KDispatchSupplementaryServicesFuncUnitId + 5;
+
+	/**
+	 * The CTSY Dispatcher shall invoke this function on receiving the EMobilePhoneSetCallBarringStatus
+	 * request from the CTSY.
+	 *
+	 * It is a request call that is completed by invoking
+	 * CCtsyDispatcherCallback::CallbackSupplementaryServicesSetCallBarringStatusComp()
+	 * 
+	 * Implementation of this interface should set the call barring status for a call barring condition.
+	 *
+	 *
+	 * @param aCondition The call barring condition to set.
+	 * @param aAction The call barring action.
+	 * @param aGroup The call barring service group.
+	 * @param aPassword The password of the call barring service.
+	 *
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 */
+	virtual TInt HandleSetCallBarringStatusReqL(RMobilePhone::TMobilePhoneCBCondition aCondition,
+        RMobilePhone::TMobilePhoneServiceAction aAction,
+        RMobilePhone::TMobileService aGroup,
+        const TDesC& aPassword) = 0;
+
+	}; // class MLtsyDispatchSupplementaryServicesSetCallBarringStatus
+
+
+
+class MLtsyDispatchSupplementaryServicesSetCallForwardingStatus : public MLtsyDispatchInterface
+	{
+public:
+
+	static const TInt KLtsyDispatchSupplementaryServicesSetCallForwardingStatusApiId = KDispatchSupplementaryServicesFuncUnitId + 6;
+
+	/**
+	 * The CTSY Dispatcher shall invoke this function on receiving the EMobilePhoneSetCallForwardingStatus
+	 * request from the CTSY.
+	 *
+	 * It is a request call that is completed by invoking
+	 * CCtsyDispatcherCallback::CallbackSupplementaryServicesSetCallForwardingStatusComp()
+	 * 
+	 * Implementation of this interface should sets a new call forwarding status and/or registered 
+	 * information for the call forwarding condition.
+	 *
+	 *
+	 * @param aCondition The condition of the new call forwarding setting.
+	 * @param aServiceGroup The basic service group to apply the CF status change to.
+	 * @param aAction The action to take.
+	 * @param aNumber The forwarding number.
+	 * @param aTimeout The time out when aCondition is ECallForwardingNoReply.
+	 *
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 */
+	virtual TInt HandleSetCallForwardingStatusReqL(RMobilePhone::TMobilePhoneCFCondition aCondition,
+			RMobilePhone::TMobileService aServiceGroup,
+			RMobilePhone::TMobilePhoneServiceAction aAction,
+			const TDesC& aNumber,
+			TInt aTimeout) = 0;
+
+	}; // class MLtsyDispatchSupplementaryServicesSetCallForwardingStatus
+
+
+
+class MLtsyDispatchSupplementaryServicesSetCallWaitingStatus : public MLtsyDispatchInterface
+	{
+public:
+
+	static const TInt KLtsyDispatchSupplementaryServicesSetCallWaitingStatusApiId = KDispatchSupplementaryServicesFuncUnitId + 7;
+
+	/**
+	 * The CTSY Dispatcher shall invoke this function on receiving the EMobilePhoneSetCallWaitingStatus
+	 * request from the CTSY.
+	 *
+	 * It is a request call that is completed by invoking
+	 * CCtsyDispatcherCallback::CallbackSupplementaryServicesSetCallWaitingStatusComp()
+	 * 
+	 * Implementation of this interface should set the call waiting status.
+	 *
+	 *
+	 * @param aServiceGroup The service group to change.
+	 * @param aAction The action to do with that service group.
+	 *
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 */
+	virtual TInt HandleSetCallWaitingStatusReqL(RMobilePhone::TMobileService aServiceGroup, RMobilePhone::TMobilePhoneServiceAction aAction) = 0;
+
+	}; // class MLtsyDispatchSupplementaryServicesSetCallWaitingStatus
+
+
+
+class MLtsyDispatchSupplementaryServicesSetSsPassword : public MLtsyDispatchInterface
+	{
+public:
+
+	static const TInt KLtsyDispatchSupplementaryServicesSetSsPasswordApiId = KDispatchSupplementaryServicesFuncUnitId + 8;
+
+	enum TServiceType
+		{
+		EAllSupplementaryServices = 0,
+		ECallBarring = 330
+		};
+	
+	/**
+	 * The CTSY Dispatcher shall invoke this function on receiving the EMobilePhoneSetSSPassword
+	 * request from the CTSY.
+	 *
+	 * It is a request call that is completed by invoking
+	 * CCtsyDispatcherCallback::CallbackSupplementaryServicesSetSsPasswordComp()
+	 * 
+	 * Implementation of this interface should set the password of the call barring or common Supplementary Services password.
+	 *
+	 *
+	 * @param aOldPassword The old password.
+	 * @param aNewPassword The new password.
+	 * @param aService The service.
+	 *
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 */
+	virtual TInt HandleSetSsPasswordReqL(const TDesC& aOldPassword,
+			const TDesC& aNewPassword,
+			TServiceType aService) = 0;
+
+	}; // class MLtsyDispatchSupplementaryServicesSetSsPassword
+
+
+
+class MLtsyDispatchSupplementaryServicesGetCallForwardingStatus : public MLtsyDispatchInterface
+	{
+public:
+
+	static const TInt KLtsyDispatchSupplementaryServicesGetCallForwardingStatusApiId = KDispatchSupplementaryServicesFuncUnitId + 9;
+
+	/**
+	 * The CTSY Dispatcher shall invoke this function on receiving the EMobilePhoneGetCallForwardingStatusPhase1
+	 * request from the CTSY.
+	 *
+	 * It is a request call that is completed by invoking
+	 * CCtsyDispatcherCallback::CallbackSupplementaryServicesGetCallForwardingStatusComp()
+	 * 
+	 * Implementation of this interface should get the call forwarding list.
+	 *
+	 * @param aCondition The call forwarding condition.
+	 * @param aService The service group.
+	 *
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 */
+	virtual TInt HandleGetCallForwardingStatusReqL(RMobilePhone::TMobilePhoneCFCondition aCondition, 
+			RMobilePhone::TMobileService aService) = 0;
+
+	}; // class MLtsyDispatchSupplementaryServicesGetCallForwardingStatus
+
+
+
+class MLtsyDispatchSupplementaryServicesSendUssdMessage : public MLtsyDispatchInterface
+	{
+public:
+
+	static const TInt KLtsyDispatchSupplementaryServicesSendUssdMessageApiId = KDispatchSupplementaryServicesFuncUnitId + 10;
+
+	/**
+	 * The CTSY Dispatcher shall invoke this function on receiving the EMobileUssdMessagingSendMessage
+	 * request from the CTSY.
+	 *
+	 * It is a request call that is completed by invoking
+	 * CCtsyDispatcherCallback::CallbackSupplementaryServicesSendUssdMessageComp()
+	 * 
+	 * Implementation of this interface should send an USSD message to the network.
+	 *
+	 *
+	 * @param aData The actual data to send in the message.
+	 * @param aDcs The data coding scheme of the message.
+	 * @param aFormat The message format.
+	 * @param aType The message type (RMobileUssdMessaging::EUssdMORequest, RMobileUssdMessaging::EUssdMOReply 
+	 * or RMobileUssdMessaging::EUssdMOAcknowledgement).
+	 *
+	 * @return KErrNone on success, KErrGsmSSUssdBusy if the latest USSD session was not yet released, 
+	 * otherwise another error code indicating the failure.
+	 */
+	virtual TInt HandleSendUssdMessageReqL(const TDesC8& aData, TUint8 aDcs, 
+			RMobileUssdMessaging::TMobileUssdDataFormat aFormat, RMobileUssdMessaging::TMobileUssdMessageType aType) = 0;
+
+	}; // class MLtsyDispatchSupplementaryServicesSendUssdMessage
+
+
+class MLtsyDispatchSupplementaryServicesSendUssdMessageNoFdnCheck : public MLtsyDispatchInterface
+	{
+public:
+
+	static const TInt KLtsyDispatchSupplementaryServicesSendUssdMessageNoFdnCheckApiId = KDispatchSupplementaryServicesFuncUnitId + 11;
+
+	/**
+	 * The CTSY Dispatcher shall invoke this function on receiving the EMobileUssdMessagingSendMessageNoFdnCheck
+	 * request from the CTSY.
+	 *
+	 * It is a request call that is completed by invoking
+	 * CCtsyDispatcherCallback::CallbackSupplementaryServicesSendUssdMessageNoFdnCheckComp()
+	 * 
+	 * Implementation of this interface should send an USSD message to the network without initially checking FDN lsit.
+	 *
+	 *
+	 * @param aData The actual data to send in the message.
+	 * @param aDcs The data coding scheme of the message.
+	 * @param aFormat The message format.
+	 * @param aType The message type (RMobileUssdMessaging::EUssdMORequest, RMobileUssdMessaging::EUssdMOReply 
+	 * or RMobileUssdMessaging::EUssdMOAcknowledgement).
+	 *
+	 * @return KErrNone on success, KErrGsmSSUssdBusy if the latest USSD session was not yet released, 
+	 * otherwise another error code indicating the failure.
+	 */
+	virtual TInt HandleSendUssdMessageNoFdnCheckReqL(const TDesC8& aData, TUint8 aDcs, 
+			RMobileUssdMessaging::TMobileUssdDataFormat aFormat, RMobileUssdMessaging::TMobileUssdMessageType aType) = 0;
+
+	}; // class MLtsyDispatchSupplementaryServicesSendUssdMessageNoFdnCheck
+
+
+class MLtsyDispatchSupplementaryServicesSendUssdRelease : public MLtsyDispatchInterface
+	{
+public:
+
+	static const TInt KLtsyDispatchSupplementaryServicesSendUssdReleaseApiId = KDispatchSupplementaryServicesFuncUnitId + 12;
+
+	/**
+	 * The CTSY Dispatcher shall invoke this function on receiving the EMobileUssdMessagingSendRelease
+	 * request from the CTSY.
+	 *
+	 * It is a request call that is completed by invoking
+	 * CCtsyDispatcherCallback::CallbackSupplementaryServicesSendUssdReleaseComp()
+	 *
+	 * Implementation of this interface should send a USSD release message to the network.
+	 *
+	 * @return KErrNone on success, otherwise another error code indicating the
+	 * failure.
+	 */
+	virtual TInt HandleSendUssdReleaseReqL() = 0;
+
+	}; // class MLtsyDispatchSupplementaryServicesSendUssdRelease
+
+
+
+class MLtsyDispatchSupplementaryServicesClearBlacklist : public MLtsyDispatchInterface
+	{
+public:
+
+	static const TInt KLtsyDispatchSupplementaryServicesClearBlacklistApiId = KDispatchSupplementaryServicesFuncUnitId + 13;
+
+	/**
+	 * The CTSY Dispatcher shall invoke this function on receiving the ECustomClearCallBlackListIPC
+	 * request from the CTSY.
+	 *
+	 * It is a request call that is completed by invoking
+	 * CCtsyDispatcherCallback::CallbackSupplementaryServicesClearBlacklistComp()
+	 * 
+	 * Implementation of this interface should clear the blacklist.
+	 *
+	 *
+	 * @return KErrNone on success, otherwise another error code indicating the failure.
+	 */
+	virtual TInt HandleClearBlacklistReqL() = 0;
+
+	}; // class MLtsyDispatchSupplementaryServicesClearBlacklist
+
+
+#endif /*MLTSYDISPATCHSUPPLEMENTARYSERVICESINTERFACE_H_*/
diff -r 4a8d14a1a8ca -r ab1d0f4d2aa4 Telephony/ctsydispatchlayer/exportinc/sat_defs.h
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Telephony/ctsydispatchlayer/exportinc/sat_defs.h	Thu Aug 12 13:20:01 2010 +0100
@@ -0,0 +1,1201 @@
+// Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).
+// All rights reserved.
+// This component and the accompanying materials are made available
+// under the terms of "Eclipse Public License v1.0"
+// which accompanies this distribution, and is available
+// at the URL "http://www.eclipse.org/legal/epl-v10.html".
+//
+// Initial Contributors:
+// Nokia Corporation - initial contribution.
+//
+// Contributors:
+//
+// Description:
+//
+
+
+
+/**
+ @file
+ @internalAll 
+*/
+
+#ifndef SAT_DEFS_H_
+#define SAT_DEFS_H_
+
+//  INCLUDES
+#include <etelsat.h>    // Symbian Etel Sat related types
+
+#ifndef BERTLV_DEFS_H
+#define BERTLV_DEFS_H
+
+#include <e32base.h>				// for class CBase
+//  CONSTANTS 
+const TUint8 KTlvLengthStartPosition                            = 0x01;
+const TUint8 KTlvDataAreaStartPosition                          = 0x02;
+const TUint8 KTlvHeaderLength                                   = 0x02;
+const TUint8 KTwoByteLengthCoding                               = 0x81;
+const TUint8 KMccAndMncLength                                   = 0x03;
+const TUint8 KLocationAreaCodeLength                            = 0x02;
+const TUint8 KCApduLengthWithoutLc                              = 0x06;
+const TUint8 KCommonTlvHeaderLength                             = 0x02;
+const TUint8 KDefaultCommandNumber                              = 0x01;
+const TUint8 KDefaultGetInkeyCodingScheme                       = 0x04;
+const TUint8 KTagValueMask                                      = 0x7f;
+const TUint8 KTagCrMask                                         = 0x80;
+const TUint8 KMaxOneByteLength                                  = 0x7f;
+const TUint8 KReservedTonNpi1 									= 0x7F;
+const TUint8 KReservedTonNpi2 									= 0xF7;
+
+
+// In 242 octets, it is possible to pack (242x8)/7=277 characters.
+// See ref. 3GPP TS 23.038.
+const TInt16 KTextBufferMaxSize                                 = 277;
+const TUint8 KCommandQualifier                                  = 4;
+const TUint8 KTlvMaxSize                                        = 255;
+
+// Proactive SIM commands
+const TUint8 KRefresh                                           = 0x01;
+const TUint8 KMoreTime                                          = 0x02;
+const TUint8 KPollInterval                                      = 0x03;
+const TUint8 KPollingOff                                        = 0x04;
+const TUint8 KSetUpEventList                                    = 0x05;
+const TUint8 KSetUpCall                                         = 0x10;
+const TUint8 KSendSs                                            = 0x11;
+const TUint8 KSendUssd                                          = 0x12;
+const TUint8 KSendShortMessage                                  = 0x13;
+const TUint8 KSendDtmf                                          = 0x14;
+const TUint8 KLaunchBrowser                                     = 0x15;
+const TUint8 KPlayTone                                          = 0x20;
+const TUint8 KDisplayText                                       = 0x21;
+const TUint8 KGetInkey                                          = 0x22;
+const TUint8 KGetInput                                          = 0x23;
+const TUint8 KSelectItem                                        = 0x24;
+const TUint8 KSetUpMenu                                         = 0x25;
+const TUint8 KProvideLocalInformation                           = 0x26;
+const TUint8 KTimerManagement                                   = 0x27;
+const TUint8 KSetUpIdleModeText                                 = 0x28;
+const TUint8 KPerformCardApdu                                   = 0x30;
+const TUint8 KPowerOnCard                                       = 0x31;
+const TUint8 KPowerOffCard                                      = 0x32;
+const TUint8 KGetReaderStatus                                   = 0x33;
+const TUint8 KRunAtCommand                                      = 0x34;
+const TUint8 KLanguageNotification                              = 0x35;
+const TUint8 KOpenChannel                                       = 0x40;
+const TUint8 KCloseChannel                                      = 0x41;
+const TUint8 KReceiveData                                       = 0x42;
+const TUint8 KSendData                                          = 0x43;
+const TUint8 KGetChannelStatus                                  = 0x44;
+const TUint8 KEndOfTheProactiveSession                          = 0x81;
+
+
+// TAG Values
+// BER-TLV tags in ME to SIM direction
+const TUint8 KBerTlvSmsPpDownloadTag                            = 0xD1;
+const TUint8 KBerTlvCellBroadcastTag                            = 0xD2;
+const TUint8 KBerTlvMenuSelectionTag                            = 0xD3;
+const TUint8 KBerTlvCallControlTag                              = 0xD4;
+const TUint8 KBerTlvMoShortMessageControlTag                    = 0xD5;
+const TUint8 KBerTlvEventDownloadTag                            = 0xD6;
+const TUint8 KBerTlvTimerExpirationTag                          = 0xD7;
+
+// BER-TLV tags in SIM to ME direction
+const TUint8 KBerTlvProactiveSimCommandTag                      = 0xD0;
+
+// SIMPLE-TLV tags in both directions
+// TLV tags, Tag value, bits 1-7 (Range: '01' - '7E')
+const TUint8 KTlvCommandDetailsTag                              = 0x01;
+const TUint8 KTlvDeviceIdentityTag                              = 0x02;
+const TUint8 KTlvResultTag                                      = 0x03;
+const TUint8 KTlvDurationTag                                    = 0x04;
+const TUint8 KTlvAlphaIdentifierTag                             = 0x05;
+const TUint8 KTlvAddressTag                                     = 0x06;
+const TUint8 KTlvCapabilityConfigurationParametersTag           = 0x07;
+const TUint8 KTlvSubaddressTag                                  = 0x08;
+const TUint8 KTlvSsStringTag                                    = 0x09;
+const TUint8 KTlvUssdStringTag                                  = 0x0A;
+const TUint8 KTlvSmsTpduTag                                     = 0x0B;
+const TUint8 KTlvCellBroadcastPageTag                           = 0x0C;
+const TUint8 KTlvTextStringTag                                  = 0x0D;
+const TUint8 KTlvToneTag                                        = 0x0E;
+const TUint8 KTlvItemTag                                        = 0x0F;
+const TUint8 KTlvItemIdentifierTag                              = 0x10;
+const TUint8 KTlvResponseLengthTag                              = 0x11;
+const TUint8 KTlvFileListTag                                    = 0x12;
+const TUint8 KTlvLocationInformationTag                         = 0x13;
+const TUint8 KTlvImeiTag                                        = 0x14;
+const TUint8 KTlvHelpRequestTag                                 = 0x15;
+const TUint8 KTlvNetworkMeasurementResultsTag                   = 0x16;
+const TUint8 KTlvDefaultTextTag                                 = 0x17;
+const TUint8 KTlvItemsNextActionIndicatorTag                    = 0x18;
+const TUint8 KTlvEventListTag                                   = 0x19;
+const TUint8 KTlvCauseTag                                       = 0x1A;
+const TUint8 KTlvLocationStatusTag                              = 0x1B;
+const TUint8 KTlvTransactionIdentifierTag                       = 0x1C;
+const TUint8 KTlvBccdChannelListTag                             = 0x1D;
+const TUint8 KTlvIconIdentifierTag                              = 0x1E;
+const TUint8 KTlvItemIconIdentifierListTag                      = 0x1F;
+const TUint8 KTlvCardReaderStatusTag                            = 0x20;
+const TUint8 KTlvCardAtrTag                                     = 0x21;
+const TUint8 KTlvCApduTag                                       = 0x22;
+const TUint8 KTlvRApduTag                                       = 0x23;
+const TUint8 KTlvTimerIdentifierTag                             = 0x24;
+const TUint8 KTlvTimerValueTag                                  = 0x25;
+const TUint8 KTlvDateTimeAndTimeZoneTag                         = 0x26;
+const TUint8 KTlvCallControlRequestedActionTag                  = 0x27;
+const TUint8 KTlvAtCommandTag                                   = 0x28;
+const TUint8 KTlvAtResponseTag                                  = 0x29;
+const TUint8 KTlvBcRepeatIndicatorTag                           = 0x2A;
+const TUint8 KTlvImmediateResponseTag                           = 0x2B;
+const TUint8 KTlvDtmfStringTag                                  = 0x2C;
+const TUint8 KTlvLanguageTag                                    = 0x2D;
+const TUint8 KTlvTimingAdvanceTag                               = 0x2E;
+const TUint8 KTlvAIDTag                                         = 0x2F;
+const TUint8 KTlvBrowserIdentityTag                             = 0x30;
+const TUint8 KTlvUrlTag                                         = 0x31;
+const TUint8 KTlvBearerTag                                      = 0x32;
+const TUint8 KTlvProvisioningReferenceFileTag                   = 0x33;
+const TUint8 KTlvBrowserTerminationCauseTag                     = 0x34;
+const TUint8 KTlvBearerDescriptionTag                           = 0x35;
+const TUint8 KTlvChannelDataTag                                 = 0x36;
+const TUint8 KTlvChannelDataLengthTag                           = 0x37;
+const TUint8 KTlvChannelStatusTag                               = 0x38;
+const TUint8 KTlvBufferSizeTag                                  = 0x39;
+const TUint8 KTlvCardReaderIdentifierTag                        = 0x3A;
+const TUint8 KTlvTextStringTagUserPassword                      = 0x3B;
+const TUint8 KTlvSimMeTransportLevelTag                         = 0x3C;
+const TUint8 KTlvURLTag                                         = 0x3D;
+const TUint8 KTlvOtherAddressTag                                = 0x3E;
+const TUint8 KTlvAccessTechnologyTag                            = 0x3F;
+const TUint8 KTlvESNTag                                         = 0x46;
+const TUint8 KTlvNetworkAccessNameTag                           = 0x47;
+const TUint8 KTlvTimerIdentifierTagCRBitOn                      = 0xA4;
+
+// TLV Coding
+
+// Event download - Event list event coding
+const TUint8 KEventMTCall                                       = 0x00;
+const TUint8 KEventCallConnected                                = 0x01;
+const TUint8 KEventCallDisconnected                             = 0x02;
+const TUint8 KEventLocationStatus                               = 0x03;
+const TUint8 KEventUserActivity                                 = 0x04;
+const TUint8 KEventIdleScreenAvailable                          = 0x05;
+const TUint8 KEventCardReaderStatus                             = 0x06;
+const TUint8 KEventLanguageSelection                            = 0x07;
+const TUint8 KEventBrowserTermination                           = 0x08;
+const TUint8 KEventDataAvailable                                = 0x09;
+const TUint8 KEventChannelStatus                                = 0x0A;
+const TUint8 KEventAccessTechnologyChange                       = 0x0B;
+
+// Event download - Location status coding
+const TUint8 KLocationStatusNormalService                       = 0x00;
+const TUint8 KLocationStatusLimitedService                      = 0x01;
+const TUint8 KLocationStatusNoService                           = 0x02;
+
+// Event download - Browser termination coding
+const TUint8 KBrowserTerminationUser                            = 0x00;
+const TUint8 KBrowserTerminationError                           = 0x01;
+
+// REFRESH;
+const TUint8 KSimInitFullFileChangeNotification                 = 0x00;
+const TUint8 KFileChangeNotification                            = 0x01;
+const TUint8 KSimInitFileChangeNotification                     = 0x02;
+const TUint8 KSimInit                                           = 0x03;
+const TUint8 KSimReset                                          = 0x04;
+const TUint8 KUSIMApplicationReset                              = 0x05;
+const TUint8 K3GSessionReset                                    = 0x06;
+const TUint8 KMaxPathLength                                     = 16;
+
+// SET UP CALL;
+const TUint8 KSetUpCallIfNotCurrentlyBusy                       = 0x00;
+const TUint8 KSetUpCallIfNotCurrentlyBusyWithRedial             = 0x01;
+const TUint8 KSetUpCallPuttingOtherCallsOnHold                  = 0x02;
+const TUint8 KSetUpCallPuttingOtherCallsOnHoldWithRedial        = 0x03;
+const TUint8 KSetUpCallDisconnectingOtherCalls                  = 0x04;
+const TUint8 KSetUpCallDisconnectingOtherCallsWithRedial        = 0x05;
+const TUint8 KAuthorityFormatIdentifier                         = 0x50;
+const TUint8 KMinutes                                           = 0x00;
+const TUint8 KSeconds                                           = 0x01;
+const TUint8 KTenthsOfSeconds                                   = 0x02;
+
+// SEND SHORT MESSAGE;
+const TUint8 KSmsPackingRequiredMask                            = 0x01;
+const TUint8 KDCSAlphabetMask                                   = 0x06;
+const TUint8 KSmsMaxSize                                        = 160;
+const TUint8 KSmsMaxSizeWithoutPacking                          = 140;
+const TUint8 KSMSCommandMaxSize                                 = 152;
+
+// DISPLAY TEXT,
+const TUint8 KPriorityMask                                      = 0x01;
+const TUint8 KMessageClearMask                                  = 0x80;
+
+// GET INKEY,
+const TUint8 KAlphabetMask                                      = 0x01;
+const TUint8 KUCS2AlphabetMask                                  = 0x02;
+const TUint8 KYesNoMask                                         = 0x04;
+const TUint8 KImmediateDigitResponse                            = 0x08;
+const TUint8 KHelpAvailabilityMask                              = 0x80;
+
+// GET INPUT,
+const TUint8 KUserInputMask                                     = 0x04;
+const TUint8 KGetInputSmsPackedMask                             = 0x08;
+const TUint8 KUCS2DCS                                           = 0x08;
+const TUint8 K7BitDefaultSmsDCS                                 = 0x00;
+const TUint8 K8BitDCS                                           = 0x04;
+
+// SELECT ITEM.
+const TUint8 KSelectItemPresentationTypeMask                    = 0x03;
+const TUint8 KSelectItemChoiceOfData                            = 0x01;
+const TUint8 KSelectItemChoiceOfNavigation                      = 0x03;
+const TUint8 KSelectItemSelectUsingSoftKeyMask                  = 0x04;
+
+// SET UP MENU.
+const TUint8 KSelectionUsingSoftKey                             = 0x01;
+
+// TIMER MANAGEMENT
+const TUint8 KDeactivateTimer                                   = 0x01;
+const TUint8 KGetTimerValue                                     = 0x02;
+
+// LAUNCH BROWSER
+const TUint8 KLaunchBrowserIfNotYetLaunched                     = 0x00;
+const TUint8 KUseExistingBrowser                                = 0x02;
+const TUint8 KCloseAndLaunchNewBrowser                          = 0x03;
+
+// PROVIDE LOCAL INFORMATION
+const TUint8 KNetworkModeGsm                                    = 0x00;
+const TUint8 KNetworkModeUtran                                  = 0x03;
+
+// BEARER INDEPENDENT PROTOCOL
+const TUint8 KIPV4                                              = 0x21;
+const TUint8 KIPV6                                              = 0x57;
+
+// MO SM CONTROL
+const TUint8 KMoSmCtrlMaxLengthAddr1Addr2						= 249;
+
+// General result
+// All other values are reserved.
+// Results '0X' and '1X' indicate that the command has been performed.
+const TUint8 KCommandPerformedSuccessfully                              = 0x00;
+const TUint8 KCommandPerformedWithPartialComprehension                  = 0x01;
+const TUint8 KCommandPerformedWithMissingInformation                    = 0x02;
+const TUint8 KRefreshPerformedWithAdditionalEfsRead                     = 0x03;
+const TUint8 KCommandPerformedSuccessfullyIconCouldNotBeDisplayed       = 0x04;
+const TUint8 KCommandPerformedButModifiedByCallControlBySim             = 0x05;
+const TUint8 KCommandPerformedSuccessfullyLimitedService                = 0x06;
+const TUint8 KCommandPerformedWithModification                          = 0x07;
+const TUint8 KProactiveSimSessionTerminatedByTheUser                    = 0x10;
+const TUint8 KBackwardMoveInTheProactiveSimSessionRequestedByTheUser    = 0x11;
+const TUint8 KNoResponseFromUser                                        = 0x12;
+const TUint8 KHelpInformationRequiredByTheUser                          = 0x13;
+const TUint8 KUssdOrSsTransactionTerminatedByTheUser                    = 0x14;
+
+// Results '2X' Indicate To The SIM That It May Be Worth Re-Trying The Command 
+// At A Later Opportunity.
+const TUint8 KMeCurrentlyUnableToProcessCommand                         = 0x20;
+const TUint8 KNetworkCurrentlyUnableToProcessCommand                    = 0x21;
+const TUint8 KUserDidNotAcceptTheProactiveCommand                       = 0x22;
+const TUint8 KUserClearedDownCallBeforeConnectionOrNetworkRelease       = 0x23;
+const TUint8 KActionInContradictionWithTheCurrentTimerState             = 0x24;
+const TUint8 KInteractionWithCallControlBySimTemporaryProblem           = 0x25;
+const TUint8 KLaunchBrowserGenericErrorCode                             = 0x26;
+
+// Results '3X' Indicate That It Is Not Worth The SIM Re-Trying With An 
+// Identical Command, As It Will Only Get The Same Response. However, The 
+// Decision To Retry Lies With The SIM Application.
+const TUint8 KCommandBeyondMeCapabilities                               = 0x30;
+const TUint8 KCommandTypeNotUnderstoodByMe                              = 0x31;
+const TUint8 KCommandDataNotUnderstoodByMe                              = 0x32;
+const TUint8 KCommandNumberNotKnownByMe                                 = 0x33;
+const TUint8 KSsReturnError                                             = 0x34;
+const TUint8 KSmsRpError                                                = 0x35;
+const TUint8 KErrorRequiredValuesAreMissing                             = 0x36;
+const TUint8 KUssdReturnError                                           = 0x37;
+const TUint8 KMultiplecardCommandsError                                 = 0x38;
+const TUint8 KSimPermanentProblem                                       = 0x39;
+const TUint8 KBearerIndependentProtocolError                            = 0x3a;
+
+// Additional information
+// Contents: For the general result "Command performed successfully", some 
+// proactive commands require additional information in the command result. 
+// This is defined in the subclauses below. For the general results '20', '21', 
+// '26', '34', '35', '37', '38' and '39' and '3A', it is mandatory for the ME 
+// to provide a specific cause value as additional information, as defined in 
+// the subclauses below. For the other general results, the ME may optionally 
+// supply additional information. If additional information is not supplied, 
+// then the length of the value part of the data object need only contain the 
+// general result. See 3GPP TS 11.14 V8.8.0, chapters 12.12.1 - 12.12.11 for 
+// more details.
+
+// Additional information for ME problem
+// Additional information for network problem
+// Additional information for SS problem
+const TUint8 KNoSpecificCauseCanBeGiven                         = 0x00;
+const TUint8 KScreenIsBusy                                      = 0x01;
+const TUint8 KMeCurrentlyBusyOnCall                             = 0x02;
+const TUint8 KMeCurrentlyBusyOnSsTransaction                    = 0x03;
+const TUint8 KNoService                                         = 0x04;
+const TUint8 KAccessControlClassBar                             = 0x05;
+const TUint8 KRadioResourceNotGranted                           = 0x06;
+const TUint8 KNotInSpeechCall                                   = 0x07;
+const TUint8 KMeCurrentlyBusyOnUssdTransaction                  = 0x08;
+const TUint8 KMeCurrentlyBusyOnSendDtmfCommand                  = 0x09;
+
+// Additional information for interaction with call control or MO SM control
+const TUint8 KActionNotAllowed                                  = 0x01;
+const TUint8 KTypeOfRequestHasChanged                           = 0x02;
+
+// Additional information for MultipleCard commands
+const TUint8 KCardReaderRemovedOrNotPresent                     = 0x01;
+const TUint8 KCardRemovedOrNotPresent                           = 0x02;
+const TUint8 KCardReaderBusy                                    = 0x03;
+const TUint8 KCardPoweredOff                                    = 0x04;
+const TUint8 KCApduFormatError                                  = 0x05;
+const TUint8 KMuteCard                                          = 0x06;
+const TUint8 KTransmissionError                                 = 0x07;
+const TUint8 KProtocolNotSupported                              = 0x08;
+const TUint8 KSpecifiedReaderNotValid                           = 0x09;
+
+// Additional information for Launch Browser problem
+const TUint8 KBearerUnavailable                                 = 0x01;
+const TUint8 KBrowserUnavailable                                = 0x02;
+const TUint8 KMeUnableToReadTheProvisioningData                 = 0x03;
+
+// Additional information for Bearer Independent Protocol
+const TUint8 KNoChannelAvailable                                = 0x01;
+const TUint8 KChannelClosed                                     = 0x02;
+const TUint8 KChannelIdentifierNotValid                         = 0x03;
+const TUint8 KRequestedBufferSizeNotAvailable                   = 0x04;
+const TUint8 KSecurityError                                     = 0x05;
+const TUint8 KRequestedSimMeInterfaceTransportLevelNotAvailable = 0x06;
+
+// Source and Destination device identities are coded as follows:
+const TUint8 KKeypad				                            = 0x01;
+const TUint8 KDisplay				                            = 0x02;
+const TUint8 KEarpiece				                            = 0x03;
+const TUint8 KAdditionalCardReader0                             = 0x10;
+const TUint8 KAdditionalCardReader1                             = 0x11;
+const TUint8 KAdditionalCardReader2                             = 0x12;
+const TUint8 KAdditionalCardReader3                             = 0x13;
+const TUint8 KAdditionalCardReader4                             = 0x14;
+const TUint8 KAdditionalCardReader5                             = 0x15;
+const TUint8 KAdditionalCardReader6                             = 0x16;
+const TUint8 KAdditionalCardReader7                             = 0x17;
+const TUint8 KChannel1				                            = 0x21;
+const TUint8 KChannel2				                            = 0x22;
+const TUint8 KChannel3				                            = 0x23;
+const TUint8 KChannel4				                            = 0x24;
+const TUint8 KChannel5				                            = 0x25;
+const TUint8 KChannel6				                            = 0x26;
+const TUint8 KChannel7				                            = 0x27;
+const TUint8 KSim					                            = 0x81;
+const TUint8 KMe					                            = 0x82;
+const TUint8 KNetwork				                            = 0x83;
+
+
+// TLV Specific Data Types
+enum TTlvSpesificDataType
+    {
+    ETLV_TonAndNpi,
+    ETLV_DiallingNumberString,
+    ETLV_AlphaIdentifier,
+    ETLV_SubAddress,
+    ETLV_CapabilityConfigurationParameters,
+    ETLV_CellBroadcastPage,
+    ETLV_CommandNumber,
+    ETLV_TypeOfCommand,
+    ETLV_CommandQualifier,
+    ETLV_SourceDeviceIdentity,
+    ETLV_DestinationDeviceIdentity,
+    ETLV_TimeUnit,
+    ETLV_TimeInterval,
+    ETLV_IdentifierOfItem,
+    ETLV_TextStringOfItem,
+    ETLV_IdentifierOfItemChosen,
+    ETLV_MinimumLengthOfResponse,
+    ETLV_MaximumLengthOfResponse,
+    ETLV_GeneralResult,
+    ETLV_AdditionalInformationOnResult,
+    ETLV_SmsTPdu,
+    ETLV_DataCodingScheme,
+    ETLV_SsOrUssdString,
+    ETLV_TextString,
+    ETLV_Tone,
+    ETLV_UssdString,
+    ETLV_NumberOfFiles,
+    ETLV_Files,
+    ETLV_LocationAreaCode,
+    ETLV_CellIdentityValue,
+    ETLV_MccAndMnc,
+    ETLV_Imei,
+    ETLV_NetworkMeasurementResults,
+    ETLV_DefaultText,
+    ETLV_ItemsNextActionIndicator,
+    ETLV_EventList,
+    ETLV_Cause,
+    ETLV_LocationStatus,
+    ETLV_TransactionIdentifier,
+    ETLV_BcchChannelList,
+    ETLV_IconIdentifier,
+    ETLV_IconQualifier,
+    ETLV_IconListQualifier,
+    ETLV_IconIdentifierList,
+    ETLV_CardReaderStatus,
+    ETLV_CommandClassCLA,
+    ETLV_CommandInstructionCodeIns,
+    ETLV_P1Parameter,
+    ETLV_P2Parameter,
+    ETLV_Lc,
+    ETLV_Data,
+    ETLV_Le,
+    ETLV_RApduData,
+    ETLV_StatusWordSW1,
+    ETLV_StatusWordSW2,
+    ETLV_TimerIdentifier,
+    ETLV_TimerValue,
+    ETLV_DateTimeAndTimeZone,
+    ETLV_AtCommand,
+    ETLV_AtResponse,
+    ETLV_BcRepeatIndicatorValues,
+    ETLV_DtmfString,
+    ETLV_Language,
+    ETLV_MeStatus,
+    ETLV_TimingAdvance,
+    ETLV_BrowserIdentity,
+    ETLV_Url,
+    ETLV_ListOfBearers,
+    ETLV_PathToProvisioningFile,
+    ETLV_BrowserTerminationCause,
+    ETLV_BearerType,
+    ETLV_BearerParameters,
+    ETLV_ChannelDataString,
+    ETLV_ChannelDataLength,
+    ETLV_BufferSize,
+    ETLV_ChannelStatus,
+    ETLV_IdentifierOfCardReader,
+    ETLV_TypeOfAddress,
+    ETLV_Address,
+    ETLV_TransportProtocolType,
+    ETLV_PortNumber,
+    ETLV_NetworkAccessName,
+    ETLV_CallControlRequestedAction,
+    ETLV_Atr,
+    ETLV_AID
+    };
+
+#endif
+
+#ifndef CTLV_H
+#define CTLV_H
+
+// DESCRIPTION
+// TLV Base class. methods common for CTlv and CBerTlv
+
+class CTlvBase : public CBase
+    {
+    public:
+
+        /**
+        * Constructor
+        */
+        CTlvBase();
+
+        /**
+        * Get pointer to TLV data
+        * @return Pointer to TLV data
+        */
+        TPtrC8 Data() const;
+
+        /**
+        * Set TLV data
+        * @param aData: Data to be inserted
+        * @return None
+        */
+        void SetData( TPtrC8 aData );
+
+        /**
+        * Get total size, including tag
+        * @return size
+        */
+        TInt GetSize() const;
+
+        /**
+        * Get tag part of TLV
+        * @return tag value
+        */
+        TUint8 GetTag() const;
+                        
+        /**
+        * Returns true if comprehension flag is on
+        * @return boolean
+        */
+        TBool GetComprehensionRequired() const;
+
+        /**
+        * Get length part of TLV
+        * @return length
+        */
+        TUint8 GetLength () const;
+
+        /**
+        * Get value part of TLV
+        * @return value
+        */
+        TPtrC8 GetValue() const;
+
+    protected: // Data
+
+        TPtrC8 iData;
+    };
+
+
+// DESCRIPTION
+// CTlv contains methods to read simple TLV data
+
+class CTlv : public CTlvBase
+    {
+    public: // Constructor
+
+        /**
+        * Default constructor
+        */
+        IMPORT_C CTlv();
+
+    public: // Methods
+
+		/**
+        * Returns short info defined by aType.
+        * @param aType: wanted data type.
+        * @return wanted data.
+        */
+        IMPORT_C TUint8 GetShortInfo( TTlvSpesificDataType aType );
+		
+        /**
+        * Returns the Data defined by aType. Index and length of the 
+        * data depends on data type.
+        * @param aType: data type.
+        * @return pointer to the data.
+        */
+        IMPORT_C TPtrC8 GetData( TTlvSpesificDataType aType );
+
+		/**
+        * Returns long info by aType.
+        * @param aType: data type.
+        * @return returned data
+        */
+        IMPORT_C TUint16 GetLongInfo( TTlvSpesificDataType aType );
+    };
+
+#endif 
+
+#ifndef CBERTLV_H
+#define CBERTLV_H
+
+// DESCRIPTION
+// CBerTlv contains methods to read BER-TLV data
+
+class CBerTlv  : public CTlvBase
+    {
+
+    public: // Constructor
+
+        /**
+        * Default constructor
+        */
+        IMPORT_C CBerTlv();
+
+    public: // Methods
+
+        /**
+        * Find TLV by tag value
+        * @param aTlv: 
+        * @param aTlvTag: TlvTag
+        * @param aItemNbr: number of requested TLV, default is 0
+        * @return TInt: KErrNone or KErrNotFound
+        */
+        IMPORT_C TInt TlvByTagValue( CTlv* aTlv, TUint8 aTlvTag, 
+            TInt aItemNbr = 0 );
+            
+        /**
+        * Find several TLVs by tag value
+        * @param aSubBlock: retruns TLVs
+        * @param aSubBlockId: TlvTag
+        * @return TInt: KErrNone or KErrNotFound
+        */
+        IMPORT_C TInt TlvByTagValueMulti( CTlv* aTlv, TUint8 aTlvTag );	
+    };
+
+#endif
+
+#ifndef TSATUTILITY_H
+#define TSATUTILITY_H
+
+// CONSTANTS
+const TUint8 KZeroCharacterCode		        = 0x30;
+const TUint8 KPacked7BitTextMask	        = 0x0C;
+const TUint8 KCrShiftedOneBitToLeft 	    = 0x1A;
+const TUint8 KUCS2TextCodingMask    	    = 0x08;
+const TUint8 KUCS2ArabicCoding 	    	    = 0x80;
+const TUint8 KUCS2GreekCoding	    	    = 0x81;
+const TUint8 KUCS2TurkishCoding	    	    = 0x82;
+// The card ID is always zero as long as only one supported
+const TUint8 KCardId0                        = 0x00;
+
+// From 3GPP TS 51.11, 9.4.2 Responses to commands which are postponed
+const TUint8 KSw1SatBusy 		    	    = 0x93;
+
+// From 3GPP TS 03.40, 9.2.3.22	TP Failure Cause (TP FCS) 
+// SMS-PP SIM DDL error
+const TUint8 KSmsPpSimDdlError 	    	    = 0xD5;
+// SMSP-PP SAT busy
+const TUint8 KSmsPpSatBusy 		    	    = 0xD4;
+
+// From 3GPP TS 11.11, 9.4	Status conditions returned by the card
+const TUint8 KSw1NormalEnding               = 0x90;
+const TUint8 KSw2NormalEnding               = 0x00;
+
+// From 3GPP TS 11.10-4, 27.22.8 MO SHORT MESSAGE CONTROL BY SIM 
+const TUint8 KMoSmCtrlResultAllowed 					= 0x00;
+const TUint8 KMoSmCtrlResultNotAllowed 					= 0x01;
+const TUint8 KMoSmCtrlResultAllowedWithModifications 	= 0x02;
+
+// From 3GPP TS 22.030 7.0.0 Structure of the MMI (Annex B)
+const TUint16 KSsAllForwardings             = 0x0002; 
+const TUint16 KSsAllCondForwardings         = 0x0004; 
+const TUint16 KSsForwUnconditional          = 0x0015; 
+const TUint16 KSsForwBusy                   = 0x0043; 
+const TUint16 KSsForwNoReply                = 0x003D; 
+const TUint16 KSsForwNotReachable           = 0x003E;
+ 
+// TON NPI
+// This just indicates that the TON NPI value is not set, TSY specific def.
+const TUint8 KTonNpiNotSet                  = 0xff;               
+// From 3GPP TS 27.007-460, 8.33 Set Voice Call Number +CSVM
+const TUint8 KTonNpiInternational           = 0x91;
+const TUint8 KTonNpiUnknown                 = 0x81;
+
+// General string length limitations
+const TUint8 KMaxAddressLength          	= 255;
+// From 3GPP TS 23.038-450, 6.1.2.3	USSD packing
+// String max length 160b + additional info in TR (1b) and DCS in PCmd (1b)
+const TUint8 KMaxUssdStringLengthInChars    = 182;
+const TUint8 KMaxUssdStringLengthInBytes    = 161;
+// Etel accepts SS strings with maximum length 242
+const TUint8 KMaxSSStringLength             = 242;
+const TUint8 KSizeOfConversionArray         = 63;
+const TUint8 KNumberMaxLength 		        = 123;
+const TUint8 KOperatorCodeLength            = 3;
+const TUint8 KAsciiBcdTableLength           = 15;
+
+// This applies for Parameters, DCS and Protocol ID (3GPP TS 23.038, 5 CBS Data
+// Coding Scheme; 3GPP TS 23.040, 9.2.3.9 TP Protocol Identifier (TP PID);
+// 3GPP TS 23.040, 9.2.3.1 - 9.2.3.5
+const TUint8 KSmsTpduByteUnknownOrReserved  = 0xFF;
+
+// Constants used in bit operations
+const TUint8 KMaskF0                        = 0xF0;
+
+// Bcd->ascii translation table
+static const TUint8 KAscii[16] =
+    {
+     '0', '1', '2', '3', '4', '5', '6', '7',
+     '8', '9', '*', '#', 'p', 'w', '.',  0
+    };
+
+// 3GPP TS 11.11, EFadn
+static const TUint8 KAsciiToBCD[KAsciiBcdTableLength][2] =
+    { 
+    { '0', 0x00 }, { '1', 0x01 }, { '2', 0x02 }, { '3', 0x03 },
+    { '4', 0x04 }, { '5', 0x05 }, { '6', 0x06 }, { '7', 0x07 },
+    { '8', 0x08 }, { '9', 0x09 }, { '*', 0x0A }, { '#', 0x0B },
+    { 'p', 0x0C }, /*DTMF*/ 
+    { 'w', 0x0D }, /*Wild*/ 
+    { '.', 0x0E }, /*RFU*/ };
+    
+// GSM 7-bit ->unicode translation table
+// See 3GPP TS 23.038
+static const TUint16 KUnicode[128] =
+    {
+    0x0040, 0x00A3, 0x0024, 0x00A5, 0x00E8, 0x00E9, 0x00F9, 0x00EC, 
+    0x00F2, 0x00C7, 0x000A, 0x00D8, 0x00F8, 0x000D, 0x00C5, 0x00E5,
+    0x0394, 0x005F, 0x03A6, 0x0393, 0x039B, 0x03A9, 0x03A0, 0x03A8, 
+    0x03A3, 0x0398, 0x039E, 0x001B, 0x00C6, 0x00E6, 0x00DF, 0x00C9,
+    0x0020, 0x0021, 0x0022, 0x0023, 0x00A4, 0x0025, 0x0026, 0x0027,
+    0x0028, 0x0029, 0x002A, 0x002B, 0x002C, 0x002D, 0x002E, 0x002F,
+    0x0030, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 0x0037,
+    0x0038, 0x0039, 0x003A, 0x003B, 0x003C, 0x003D, 0x003E, 0x003F,
+    0x00A1, 0x0041, 0x0042, 0x0043, 0x0044, 0x0045, 0x0046, 0x0047,
+    0x0048, 0x0049, 0x004A, 0x004B, 0x004C, 0x004D, 0x004E, 0x004F,
+    0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056, 0x0057, 
+    0x0058, 0x0059, 0x005A, 0x00C4, 0x00D6, 0x00D1, 0x00DC, 0x00A7, 
+    0x00BF, 0x0061, 0x0062, 0x0063, 0x0064, 0x0065, 0x0066, 0x0067, 
+    0x0068, 0x0069, 0x006A, 0x006B, 0x006C, 0x006D, 0x006E, 0x006F,
+    0x0070, 0x0071, 0x0072, 0x0073, 0x0074, 0x0075, 0x0076, 0x0077, 
+    0x0078, 0x0079, 0x007A, 0x00E4, 0x00F6, 0x00F1, 0x00FC, 0x00E0  
+    };
+
+
+static const TUint16 KUnicode16ToSms7[63][2] =
+    { 
+    { 0x0040, 0x00 }, { 0x00A3, 0x01 }, { 0x0024, 0x02 }, { 0x00A5, 0x03 },
+    { 0x00E8, 0x04 }, { 0x00E9, 0x05 }, { 0x00F9, 0x06 }, { 0x00EC, 0x07 },
+    { 0x00F2, 0x08 }, { 0x00C7, 0x09 }, { 0x00D8, 0x0B }, { 0x00F8, 0x0C },
+    { 0x21B5, 0x0D }, { 0x000D, 0x0D }, { 0x2029, 0x0D }, { 0x00C5, 0x0E },
+    { 0x00E5, 0x0F }, { 0x0394, 0x10 }, { 0x005F, 0x11 }, { 0x03A6, 0x12 },
+    { 0x0393, 0x13 }, { 0x039B, 0x14 }, { 0x03A9, 0x15 }, { 0x03A0, 0x16 },
+    { 0x03A8, 0x17 }, { 0x03A3, 0x18 }, { 0x0398, 0x19 }, { 0x039E, 0x1A },
+    { 0x00C6, 0x1C }, { 0x00E6, 0x1D }, { 0x00DF, 0x1E }, { 0x00C9, 0x1F },
+    { 0x00A4, 0x24 }, { 0x00A1, 0x40 }, { 0x00C4, 0x5B }, { 0x00D6, 0x5C },
+    { 0x00D1, 0x5D }, { 0x00DC, 0x5E }, { 0x00A7, 0x5F }, { 0x00BF, 0x60 },
+    { 0x00E4, 0x7B }, { 0x00F6, 0x7C }, { 0x00F1, 0x7D }, { 0x00FC, 0x7E },
+    { 0x00E0, 0x7F }, { 0x007B, 0x1B }, { 0x007B, 0x28 }, { 0x007D, 0x1B },
+    { 0x007D, 0x29 }, { 0x005B, 0x1B }, { 0x005B, 0x3C }, { 0x007E, 0x1B },
+    { 0x007E, 0x3D }, { 0x005D, 0x1B }, { 0x005D, 0x3E }, { 0x005C, 0x1B },
+    { 0x005C, 0x2F }, { 0x005E, 0x1B }, { 0x005E, 0x14 }, { 0x007C, 0x1B },
+    { 0x007C, 0x40 }, { 0x20AC, 0x1B }, { 0x20AC, 0x65 } 
+    };
+
+// SMS data coding schemes
+enum TSmsDcs
+	{
+	ESmsUnknownOrReservedDcs = KSmsTpduByteUnknownOrReserved,
+	ESms7BitDcs = 0x00,
+	ESms8BitDcs = 0x04,
+	ESms16BitDcs = 0x08
+	};
+
+// DESCRIPTION
+/**
+* This class includes small aid fuctions
+* @since S60 3.1
+*/
+class TSatUtility
+    {
+
+    public: // New functions
+
+        /**
+        * Map TON and NPI to RSat TON and NPI values
+        * @param aTonAndNpi: Source TON and NPI
+        * @param aTon: Mapped Type of number
+        * @param aNpi: Mapped Numbering plan
+        */
+		IMPORT_C static void TonAndNpi( TInt aTonAndNpi, 
+            RSat::TTypeOfNumber* aTon,
+            RSat::TNumberingPlan* aNpi );
+
+        /**
+        * Converts 7-bit packed string to 8-bit unpacked format
+        * @param aSource: Pointer to the const data
+        * @param aTarget converted 8-bit unpacked string
+        * @return KErrNone or KErrOverflow if string was too long
+        */
+        IMPORT_C static TInt Packed7to8Unpacked( const TPtrC8 aSource, 
+            TDes8& aTarget );
+
+        /**
+        * Converts UCS2 string to 7-bit packed format
+        * @param aInput: is source
+        * @param aOutput: converted 7-bit packed string
+        */
+        IMPORT_C static void UCSToPacked7( const TPtrC aInput, 
+            TDes8& aOutput );
+        
+        /**
+        * Converts Binary Coded Decimal to ASCII
+        * @param aInput is source
+        * @param aOutput converted 8-bit string
+        * @return KErrNone or KErrOverflow if string was too long
+        */
+        IMPORT_C static TInt BCDToAscii( const TPtrC8 aInput, TDes8& aOutput );	
+
+        /**
+        * Converts Ascii string to Binary Coded Decimal
+        * @param aInput is source
+        * @param aOutput converted 8-bit string
+        * @return KErrNone or KErrOverflow if string was too long
+        */
+        IMPORT_C static TInt AsciiToBCD( const TDesC8& aInput, 
+            TDes8& aOutput );
+
+        /**
+        * Remove Wild 'w' and Expansion digit '.' from EFadn string.
+        * @param aInput is source
+        * @param aOutput converted 8-bit string
+        */
+        IMPORT_C static void RemoveWildAndExpansionDigit( const TPtrC8 aInput,
+            TDes8& aOutput );
+
+        /**
+        * Set Alpha identifier as a Unicode text string
+        * and according to the alphabet used
+        * @param aRawData input data that was extracted with 
+        * ETLV_AlphaIdentifier
+        * @param aAlphaId output
+        */
+        IMPORT_C static void SetAlphaId( const TPtrC8 aRawData, TDes& aAlphaId );		
+
+        /**
+        * Convert integer to BCD format. If number is more than 100 only last
+        * two digits is converted.
+        * @param aTime time
+        * @return converted BCD value
+        */
+        IMPORT_C static TUint8 ConvertToSemiOctet( const TInt aTime );
+
+        /**
+        * Browse a text in Unicode format, and for some specific characters 
+        * replace with the correct byte value
+        * @param aInput: GSM 7 bit default alphabet string
+        * @param aOutput: Unicode 16 string
+        */
+        IMPORT_C static void Convert7BitToUnicode16( const TDesC8& aInput,
+            TDes16& aOutput );
+
+        /**
+        * Converts unicode16 string to 7 bit character mode
+        * @param aInput: Unicode 16 string
+        * @param aOutput: Resulting GSM 7 bit default alphabet string
+        * @return KErrNone or KErrOverflow (input string is too long) 
+        */
+        IMPORT_C static TInt ConvertUnicode16To7Bit( const TDesC16& aInput,
+            TDes8& aOutput );
+
+        /**
+        * Fill in a TDuration structure
+        * @param aBerTlv tlv containing duration data
+        * @param aTDuration duration structure
+        */
+        IMPORT_C static void FillDurationStructure( CBerTlv& aBerTlv, 
+            RSat::TDuration& aTDuration );
+
+        /**
+        * Fill in a TIconId structure
+        * @param aBerTlv data containing icon address data
+        * @param aTIconId icon id structure
+        * @param aItemNmb item number
+        */
+        IMPORT_C static void FillIconStructure( CBerTlv& aBerTlv, 
+            RSat::TIconId& aTIconId, const TInt aItemNmb = 0 );
+
+        /**
+        * Set Text string as a Unicode text string
+        * @param aTextString text string
+        * @param aText unicode output text string
+        */
+        IMPORT_C static void SetText( CTlv& aTextTlv, TDes& aUnicodeOutput );
+
+        /**
+        * Convert Alpha field text string to a Unicode text string. 
+        * @param aSource text string
+        * @param aText unicode output text string
+        */
+        IMPORT_C static void ConvertAlphaFieldsToUnicode( 
+            const TDesC8& aSource, TDes& aTarget );
+            
+        /**
+        * Copy from 16 bit descriptor to 8 bit descriptor with little endian.
+        * Function uses Append method.
+        * @param aSource: source
+        * @param aTarget: target
+        * @return KErrNone or KErrOverflow if string was too long
+        */
+		IMPORT_C static TInt Copy16to8LE( const TDesC16& aSource, 
+            TDes8& aTarget );
+
+        /**
+        * Copy from 8 bit descriptor to 16 bit descriptor with little endian.
+        * Function uses Append method.
+        * @param aSource: source
+        * @param aTarget: target
+        * @return KErrNone or KErrOverflow if string was too long
+        */
+        IMPORT_C static TInt Copy8to16LE( const TDesC8& aSource, 
+            TDes16& aTarget );
+
+        /**
+        * Finds whether the data coding scheme, coded in CBS format,
+        * is 7-bit, 8-bit or 16-bit
+        * @param aDcs Input data coding scheme
+        * @return Converted DCS ( SMS format )
+        */
+        IMPORT_C static TSmsDcs DecodeCbsDcs( const TUint8 aDcs ); 
+        
+        /**
+        * Gets 8 bit byte and copy it to the 16 bit byte with right endian.
+        * @param aSource: source
+        * @param aTarget: target
+        * @param aIndex: index
+        * @return KErrNone or KErrOverflow if string was too long
+        */
+        IMPORT_C static TInt CopyTwo8toOne16LE( const TDesC8& aSource, 
+            TUint16& aTarget, const TInt aIndex ); 
+	};
+
+#endif
+
+const TUint8 KLaunchBrowserCmdQualifierNotUsed    = 0x01;
+const TUint8 KLaunchBrowserCmdQualifierReserved   = 0x04;
+const TUint8 KCsdBearer                           = 0x01;
+const TUint8 KGprsBearer                          = 0x03;
+
+const TUint8 KOnlyIfNotBusy                       = 0x00;
+const TUint8 KOnlyIfNotBusyWithRedial             = 0x01;
+const TUint8 KHoldOtherCalls                      = 0x02;
+const TUint8 KHoldOtherCallsWithRedial            = 0x03;
+const TUint8 KDisconnectOtherCalls                = 0x04;
+const TUint8 KDisconnectOtherCallsWithRedial      = 0x05;
+
+const TUint8 KSpecificLanguage                    = 0x01;
+const TUint8 KBipCsdBearer                        = 0x01;
+const TUint8 KBipGprsBearer                       = 0x02;
+const TUint8 KBipDefaultBearer                    = 0x03;
+const TUint8 KBipLocalLinkBearer                  = 0x04;
+const TUint8 KBipSendDataImmediately              = 0x01;
+
+const TUint8 KNoCause                             = 0x00;
+const TUint8 KSmsVPFRelative                      = 0x10;
+const TUint8 KSmsVPFEnhanced                      = 0x08;
+const TUint8 KSmsVPFAbsolute                      = 0x18;
+//const TUint8 	KMaxAddressLength          	= 255;
+const TUint8 	KMaxCommandDetailsLength	= 5;
+const TInt 		KImeiLength=16; //the structure defined in CSatNotifyLocalInfo was 16 bytes however ETSI TS 123 003 V7.7.0 specifies 15 bytes for IMEIs.
+//const TUint8 	KOperatorCodeLength            	= 3;
+const TUint8 	KAdditionalInfoMaxSize		=	244;
+
+typedef TBuf8<KImeiLength> TImeiBuf;
+
+const TUint8  KMaxBccLength                       = 16;
+const TUint16 KMaxLengthDefaultBearerData         = 258;
+
+
+// Max address length
+const TUint8 KAddrMaxLength = 255;
+
+/*
+* This structure contains local information.
+* Used in event handling and by CSatNotifyLocalInfo
+*/
+struct TLocalInformation
+    {
+    TUint16 iLocationAreaCode;      // Location area code 
+    TUint16 iCellId;                // Cell Id
+    TBuf8<KOperatorCodeLength> iOperatorCode;   // Operator code
+    };
+
+
+struct TTerminalRespData 
+    {
+    // Proactive command number
+    TUint8 iPCmdNumber;   
+    // Command details tlv     
+    TBuf8<KMaxCommandDetailsLength>iCommandDetails;
+    // General result for NotifySetUpEventList    
+    TUint8 iGeneralResult;  
+    // Additional info   
+    TBuf<KAdditionalInfoMaxSize> iAdditionalInfo; 
+    };
+
+//icon defs
+const TUint8 KGetIconDataPckgLength     = 2;
+const TUint8 KIconInfoLength            = 6;
+const TUint8 KBasicIconDataLength		= 2;
+const TUint8 KColourIconDataLength		= KIconInfoLength;
+const TUint8 KFilePathLength            	= 8;		
+/**
+ * Used for Location Status
+ */
+const TUint8 KCountryCodeLength = 3;
+
+
+/*
+* The data in this structure contains information 
+* needed in Get Icon, Get image instance and get clut.
+*/
+struct TIconInfo
+    {
+    TUint16 iOffset;                      // Offset
+    TUint16 iLength;                      // Length
+	TBuf8<KFilePathLength> iSimFilePath;  // Sim file path
+    };
+
+
+enum TSsStatus
+	{
+	ENotBusy,
+	ESsBusy,
+	EUssdBusy
+	};
+
+enum TCachedSimAtkFiles
+	{
+	ECacheEFSST = 0x01,  // EF-SST, (U)SIM Service table
+	ECacheEFCBMID = 0x02,// EF-CBMID, CB DataDownload message IDs
+	// Next 0x04, 0x08 etc..
+	};
+
+/**
+* This Structure provides Refresh specific information
+* Used: CSatNotifyRefresh::RefreshAllowed()
+*/
+
+struct TRefreshInfo
+    {
+    TBuf8<RSat::KRefreshedFileListMaxSize> iFileList;
+    TBuf8<RSat::KAidMaxSize> iAid;
+    TUint16 iInternalCache;
+    };
+
+/*
+* This structure contains data needed for LocationStatus
+* envelope. (used by EventDownload and MoSmContol)
+*/
+struct TLocationStatusEnvelope 
+    {
+    TUint8 iLocationStatus;  // Location satus
+    TBuf8<KCountryCodeLength> iCountryCode;     // Country code
+    TUint16 iLocationAreaCode;// Location area code
+    TUint16 iCellId;          // Cell id
+	};
+
+
+const TUint8  KMaxCauseLength	   = 248;
+	
+/**
+* This structure contains data needed for CallDisconnected
+* envelope.
+*/
+struct TCallDisconnectedEnvelope 
+    {
+    TUint8 iCmdNumber;      		// Command number
+    TBool iNearEnd;     			// MO flag
+    TBool iCauseGiven;     	    	// Cause given
+    TBuf8<KMaxCauseLength>  iCause; // Cause
+    };
+
+/**
+ * This structure contains data needed for MTCall
+ * envelope.
+ */
+ struct TMTCallEnvelope 
+	 {
+	 TUint8 iCmdNumber;               // Command number
+	 TUint8 iTONandNPI;               // Ton and Npi
+	 TBuf8<KNumberMaxLength> iDiallingNumber;// Calling Party BCD number
+	 TPtrC8 iCalledPartySubAddress;   // Calling Party Subaddress
+	 };
+ 
+ /*
+ * This structure contains the address data of the service center
+ * needed for MO-SMS Control envelope.
+ */
+ struct TAddressData 
+     {
+     TPtrC8 iRPDestinationAddr;	// RP Destination Address
+     TPtrC8 iTPDestinationAddr;	// TP Destination Address 
+     };
+
+ /**
+ * The data in this structure is used for a response to the NAA for a
+ * MO SM Control notification request. The possible values of the
+ * result are defined in TSatUtility.h
+ */
+ struct TMoSmCtrlData 
+     { 
+     TAddressData iAddressData;  // RP and TP Destination addresses 
+     RSat::TAlphaId*	iAlphaId;	// Pointer to the Alpha ID object
+     TBool iIsAlphaIdEmpty;		// Declares id Alpha ID is empty
+     TUint8 iResult;				// MO SM Ctrl Result, 
+     };
+
+
+/*
+* This structure contains information needed in constructing Call 
+* Control (call/SS/USSD) Envelope and handling the call control events.
+*/
+struct TCCInfo
+    {
+    TUint8 iTag;                // Tag of envelope
+    TBuf8<KMaxBccLength> iBcc1; // For storing bearer capability 1            
+    TBuf8<KMaxBccLength> iBcc2; // For storing bearer capability 2
+    TBuf8<KMaxAddressLength> iAddress; // For storing address
+    TUint8 iTonNpi;             // For storing ton&npi
+    TUint8 iDcs;                // For storing DCS (only USSD)
+    };
+
+
+typedef TBuf8<16> TNmrBuf;
+typedef TBuf<32> TBcchListBuf;
+
+// Cell Broadcast isi msg length
+const TUint8 KCbsMsgMaxLength           = 92;
+
+
+// --------------
+
+//  INCLUDES
+#include <e32base.h>				// Etel base
+
+// CONSTANTS
+
+// The internal SAT IPC values are agreed to be between 1001600 - 1002000
+// See ETel_Telephony_Server_Design.doc, chapter 6.3 Policing Custom APIs
+const TInt KSatInternalIpcOffset = 1001600;
+const TInt KSatInternalIpcMaxOffset = 1002000;
+
+// Contains IPC definitions used by SAT TSY Layering.
+
+// TSatTsyLayerIPC enumerates IPC values used by SAT API.
+enum TSatTsyLayerIPC
+    {
+    ESatTsyReady = KSatInternalIpcOffset,
+    ESatTsyPCmd,
+    ESatTsyTimerExpiredIPC,	
+    ESatTsyGetIfPendingNotification,
+	ESatTsyGetBearerCapability,
+    ESatTsyGetIMEI,              	// 1001605   
+    ESatTsyTimeZone,
+    ESatTsyTimingAdvance,  
+    ESatTsyCreateEnvelope,                  
+    ESatTsySendEnvelope,   
+    ESatTsyEnvelopeError,        	// 1001610	
+	ESatTsyMoSmControlEnvelope,                   	
+    ESatTsyCallConnected,			
+    ESatTsyCallDisconnected,     	  
+    ESatTsyLocationStatus,
+    ESatTsyMTCall,   				// 1001615 
+    ESatTsyAccessTechnologyChange,    
+    ESatTsyCellBroadcast,
+    ESatTsySmsPpDdl,                
+    ESatTsyReadCbmids,				
+    ESatTsyNetStatus,              	// 1001620 
+    ESatTsyProvideLocalInfo,        
+    ESatTsyLocalInformationNmr,     
+    ESatTsyAccTech,
+    ESatTsyNotifyLocalInfo,       
+    ESatTsyServiceRequest,			// 1001625	
+    ESatTsyRefresh,		            		
+    ESatTsyCompleteRefresh,      
+    ESatTsySetPolling,
+    ESatTsySetProactiveCommandOnGoingStatus, 
+	ESatTsyGetIconData,				// 1001630
+	ESatTsyGetImageInstance,
+	ESatTsyGetClut,		
+	ESatTsyCallControlActivation,   
+	ESatTsyMoSmsControlActivation,
+	ESatTsyUssdControlActivation,	// 1001635
+	ESatTsySmsPpDdlStatus,
+	ESatTsySsStatus,
+	ESatTsyUssdStatus,				
+	ESatTsyImsiChanged,             
+	ESatTsyCheckAtkDataForAlphaId,  // 1001640
+	ESatTsyCallEvent,				
+	ESatTsySSEvent,
+	ESatTsyUSSDEvent,				
+	ESatTsyEmergencyNbrCheck,       
+	ESatTsyFdnStatusCheck,          // 1001645
+	ESatTsyRemoveEventList,
+	ESatTsySmsDeliverReport
+    }; // end enum TSatTsyLayerIPC
+
+
+#endif /*SAT_DEFS_H_*/