--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/mmsharing/mmshavailability/tsrc/ut_availability/Stubs/src/mm_phone.cpp	Thu Dec 17 08:44:37 2009 +0200
@@ -0,0 +1,2012 @@
+/*
+* Copyright (c) 2000 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:
+*
+*/
+
+#include <ETelExt.h>
+
+// Multimode header files
+#include "etelmm.h"
+//#include <mmlist.h>
+
+#include "CSipSseTestTls.h"
+#include "musunittesting.h"
+//#include "mm_hold.h"
+
+/*GLDEF_C TInt E32Dll(TDllReason)
+//
+// DLL entry point
+//
+	{
+	return KErrNone;
+	}
+*/
+/************************************************************************/
+//
+//  TMobileAddress
+//
+/************************************************************************/
+
+EXPORT_C RMobilePhone::TMobileAddress::TMobileAddress() 
+	: iTypeOfNumber(EUnknownNumber),
+	  iNumberPlan(EUnknownNumberingPlan)
+	{
+	}
+
+void RMobilePhone::TMobileAddress::InternalizeL(RReadStream& aStream)
+/**
+ * This method internalizes the mobile address from a stream 
+ *
+ * \param aStream The read stream containing the mobile address
+ */
+	{
+	iTypeOfNumber=STATIC_CAST(TMobileTON, aStream.ReadUint32L());
+	iNumberPlan=STATIC_CAST(TMobileNPI, aStream.ReadUint32L());
+	aStream >> iTelNumber;
+	}
+
+void RMobilePhone::TMobileAddress::ExternalizeL(RWriteStream& aStream) const
+/**
+ * This method externalizes the mobile address into a stream 
+ *
+ * \param aStream The write stream that will contain the mobile address
+ */
+	{
+	aStream.WriteUint32L(iTypeOfNumber);
+	aStream.WriteUint32L(iNumberPlan);
+	aStream << iTelNumber;
+	}
+
+
+/************************************************************************/
+//
+//  RMobilePhone
+//
+/************************************************************************/
+
+EXPORT_C RMobilePhone::RMobilePhone()
+	: iMmPtrHolder(NULL)
+	{
+	}
+
+EXPORT_C void RMobilePhone::ConstructL()
+	{
+	RPhone::ConstructL();
+//	__ASSERT_ALWAYS(iMmPtrHolder==NULL,PanicClient(EEtelPanicHandleNotClosed));
+//	iMmPtrHolder = CMobilePhonePtrHolder::NewL(CMobilePhonePtrHolder::EMaxNumberPhonePtrSlots,CMobilePhonePtrHolder::EMaxNumberPhonePtrCSlots);
+	}
+
+EXPORT_C void RMobilePhone::Destruct()
+	{
+	RPhone::Destruct();
+//	delete iMmPtrHolder;
+//	iMmPtrHolder = NULL;
+	}
+
+/************************************************************************/
+//
+//  TMultimodeType
+//
+/************************************************************************/
+
+RMobilePhone::TMultimodeType::TMultimodeType()
+	{}
+
+EXPORT_C TInt RMobilePhone::TMultimodeType::ExtensionId() const
+/**
+ * This method returns the multimode API extension number of the class
+ *
+ * \return TInt An integer that will indicate the version of the type
+ */
+	{
+	return iExtensionId;
+	}
+
+void RMobilePhone::TMultimodeType::InternalizeL(RReadStream& aStream)
+/**
+ * This method internalizes the multimode type from a stream 
+ *
+ * \param aStream The read stream containing the multimode type
+ */
+	{
+	iExtensionId=aStream.ReadInt32L();	
+	}
+
+void RMobilePhone::TMultimodeType::ExternalizeL(RWriteStream& aStream) const
+/**
+ * This method externalizes the multimode type into a stream 
+ *
+ * \param aStream The write stream that will contain the multimode type
+ */
+	{
+	aStream.WriteInt32L(iExtensionId);
+	}
+
+
+/***********************************************************************************/
+//
+// MobilePhoneCapability functional unit
+//
+/***********************************************************************************/
+
+EXPORT_C TInt RMobilePhone::GetMultimodeAPIVersion(TInt& aVersion) const
+/**
+ * This method returns the current version of the multimode ETel API
+ *
+ * \param aVersion Will contain the current version of the multimode ETel API
+ * \return KErrNone
+ */
+	{
+	aVersion=KETelExtMultimodeV1;
+	return KErrNone;
+	}
+
+EXPORT_C TInt RMobilePhone::GetMultimodeCaps(TUint32& aCaps) const
+/**
+ * This method returns the multimode capabilities of the phone
+ *
+ * \retval aCaps An integer that will contain the bit-wise sum of the multimode capabilities
+ * \return KErrNone
+ */
+	{
+	TPckg<TUint32> ptr1(aCaps);
+	return Get(EMobilePhoneGetMultimodeCaps, ptr1);
+	}
+
+EXPORT_C void RMobilePhone::GetPhoneStoreInfo(TRequestStatus& aReqStatus, TDes8& aInfo, const TDesC& aStoreName) const
+/**
+ * This method returns the information related to a particular phone store
+ *
+ * \param aStoreName Specifies the name of the store, for which information is required
+ * \retval aInfo A descriptor that will contain the phone store information
+ */
+	{
+	SetAndGet(EMobilePhoneGetPhoneStoreInfo,aReqStatus, aInfo, aStoreName);
+	}
+
+/***********************************************************************************/
+//
+// MobilePhoneSimAccess functional unit
+//
+/***********************************************************************************/
+
+EXPORT_C TInt RMobilePhone::GetIccAccessCaps(TUint32& aCaps) const
+/**
+ * This method returns the ICC (Integrated circuit card) access capabilities of the phone
+ *
+ * \retval aCaps An integer that will contain the bit-wise sum of the ICC access capabilities
+ * \return KErrNone
+ * \exception KErrNotSupported if ICC access is never supported
+ */
+	{
+	TPckg<TUint32> ptr1(aCaps);
+	return Get(EMobilePhoneGetIccAccessCaps, ptr1);
+	}
+
+EXPORT_C void RMobilePhone::NotifyIccAccessCapsChange(TRequestStatus& aReqStatus, TUint32& aCaps) const
+/**
+ * This notification completes if the ICC access capabilities of the phone change
+ *
+ * \retval aCaps An integer that will contain the new ICC access capabilities
+ */
+	{
+/*	__ASSERT_ALWAYS(iMmPtrHolder!=NULL,PanicClient(EEtelPanicNullHandle));
+
+	TPtr8& ptr1=iMmPtrHolder->Set(CMobilePhonePtrHolder::ESlot1NotifyIccAccessCapsChange,aCaps);
+
+	Get(EMobilePhoneNotifyIccAccessCapsChange,aReqStatus,ptr1);*/
+	}
+
+EXPORT_C RMobilePhone::TMobilePhoneCspFileV1::TMobilePhoneCspFileV1()
+	: iCallOfferingServices(0),iCallRestrictionServices(0),iOtherSuppServices(0),
+	iCallCompletionServices(0),iTeleservices(0),iCphsTeleservices(0),iCphsFeatures(0),
+	iNumberIdentServices(0),iPhase2PlusServices(0),iValueAddedServices(0)
+	{
+	iExtensionId=KETelExtMultimodeV1;
+	}
+
+EXPORT_C void RMobilePhone::GetCustomerServiceProfile(TRequestStatus& aReqStatus, TDes8& aCsp) const
+/**
+ * This method returns the Customer Service Profile (CSP) stored on the SIM
+ *
+ * \retval aCsp A descriptor that will contain the CSP information
+ */
+	{
+//	Get(EMobilePhoneGetCustomerServiceProfile, aReqStatus, aCsp);
+	}
+
+EXPORT_C RMobilePhone::TMobilePhoneServiceTableV1::TMobilePhoneServiceTableV1()
+	: iServices1To8(0),iServices9To16(0),iServices17To24(0),iServices25To32(0),
+	iServices33To40(0)
+	{
+	iExtensionId=KETelExtMultimodeV1;
+	}
+
+EXPORT_C void RMobilePhone::GetServiceTable(TRequestStatus& aReqStatus, TMobilePhoneServiceTable aTable, TDes8& aSst) const
+/**
+ * This method returns the Service Table (SIM or CDMA) stored on the ICC
+ *
+ * \param aTable Specifies whether the SIM or CDMA service table is to be retrieved
+ * \retval aTable A descriptor that will contain the service table information
+ */
+	{
+/*	__ASSERT_ALWAYS(iMmPtrHolder!=NULL,PanicClient(EEtelPanicNullHandle));
+
+	iMmPtrHolder->iServiceTable = aTable;
+	TPtrC8& ptr1=iMmPtrHolder->SetC(CMobilePhonePtrHolder::ESlot1GetServiceTable, iMmPtrHolder->iServiceTable);
+
+	SetAndGet(EMobilePhoneGetServiceTable, aReqStatus, ptr1, aSst);*/
+	}
+
+/***********************************************************************************/
+//
+// MobilePhonePower functional unit
+//
+/***********************************************************************************/
+
+EXPORT_C TInt RMobilePhone::GetBatteryCaps(TUint32& aCaps) const
+/**
+ * This method returns the battery capabilities of the phone
+ *
+ * \retval aCaps An integer that will contain the bit-wise sum of the battery capabilities
+ * \return KErrNone
+ * \exception KErrNotSupported if battery information is not supported
+ */
+	{
+//	TPckg<TUint32> ptr1(aCaps);
+//	return Get(EMobilePhoneGetBatteryCaps, ptr1);
+    return 0;
+	}
+
+EXPORT_C RMobilePhone::TMobilePhoneBatteryInfoV1::TMobilePhoneBatteryInfoV1() :
+		iStatus(EPowerStatusUnknown), iChargeLevel(0)
+	{
+	iExtensionId=KETelExtMultimodeV1;
+	}
+
+EXPORT_C void RMobilePhone::GetBatteryInfo(TRequestStatus& aReqStatus, TMobilePhoneBatteryInfoV1& aInfo) const
+/**
+ * This method returns the current battery information of the phone
+ *
+ * \retval aInfo Will contain the battery information
+ */
+	{
+	/*__ASSERT_ALWAYS(iMmPtrHolder!=NULL,PanicClient(EEtelPanicNullHandle));
+
+	TPtr8& ptr1=iMmPtrHolder->Set(CMobilePhonePtrHolder::ESlot1GetBatteryInfo,aInfo);
+
+	Get(EMobilePhoneGetBatteryInfo,aReqStatus,ptr1);*/
+	}
+
+EXPORT_C void RMobilePhone::NotifyBatteryInfoChange(TRequestStatus& aReqStatus, TMobilePhoneBatteryInfoV1& aInfo) const
+/**
+ * This notification completes if the battery information changes
+ *
+ * \retval aInfo Will contain the new battery information
+ */
+	{
+	/*__ASSERT_ALWAYS(iMmPtrHolder!=NULL,PanicClient(EEtelPanicNullHandle));
+
+	TPtr8& ptr1=iMmPtrHolder->Set(CMobilePhonePtrHolder::ESlot1NotifyBatteryInfoChange,aInfo);
+
+	Get(EMobilePhoneNotifyBatteryInfoChange,aReqStatus,ptr1);*/
+	}
+
+/***********************************************************************************/
+//
+// MobilePhoneSignal functional unit
+//
+/***********************************************************************************/
+
+EXPORT_C TInt RMobilePhone::GetSignalCaps(TUint32& aCaps) const
+/**
+ * This method returns the signal strength capabilities of the phone
+ *
+ * \retval aCaps An integer that will contain the bit-wise sum of the signal strength capabilities
+ * \return KErrNone
+ * \exception KErrNotSupported if signal strength information is not supported
+ */
+	{
+//	TPckg<TUint32> ptr1(aCaps);
+//	return Get(EMobilePhoneGetSignalCaps, ptr1);
+    return 0;
+	}
+
+EXPORT_C void RMobilePhone::GetSignalStrength(TRequestStatus& aReqStatus, TInt32& aSignalStrength, TInt8& aBar) const
+/**
+ * This method returns the current signal strength of the phone
+ *
+ * \retval aSignalStrength Will contain the signal strength, expressed in dBm
+ * \retval aBar Will contain the number of bars of signal strength to display
+ */
+	{
+/*	__ASSERT_ALWAYS(iMmPtrHolder!=NULL,PanicClient(EEtelPanicNullHandle));
+
+	TPtr8& ptr1=iMmPtrHolder->Set(CMobilePhonePtrHolder::ESlot1GetSignalStrength,aSignalStrength);
+	TPtr8& ptr2=iMmPtrHolder->Set(CMobilePhonePtrHolder::ESlot2GetSignalStrength,aBar);
+
+	Get(EMobilePhoneGetSignalStrength,aReqStatus,ptr1,ptr2);*/
+	}
+
+EXPORT_C void RMobilePhone::NotifySignalStrengthChange(TRequestStatus& aReqStatus, TInt32& aSignalStrength, TInt8& aBar) const
+/**
+ * This notification completes if the signal strength of the phone changes
+ *
+ * \retval aSignalStrength Will contain the new signal strength, expressed in dBm
+ * \retval aBar Will contain the new number of bars of signal strength to display
+ */
+	{
+/*	__ASSERT_ALWAYS(iMmPtrHolder!=NULL,PanicClient(EEtelPanicNullHandle));
+
+	TPtr8& ptr1=iMmPtrHolder->Set(CMobilePhonePtrHolder::ESlot1NotifySignalStrengthChange,aSignalStrength);
+	TPtr8& ptr2=iMmPtrHolder->Set(CMobilePhonePtrHolder::ESlot2NotifySignalStrengthChange,aBar);
+
+	Get(EMobilePhoneNotifySignalStrengthChange, aReqStatus, ptr1, ptr2);*/
+	}
+
+/***********************************************************************************/
+//
+// MobilePhoneIndicator functional unit
+//
+/***********************************************************************************/
+
+EXPORT_C TInt RMobilePhone::GetIndicatorCaps(TUint32& aActionCaps, TUint32& aIndCaps) const
+/**
+ * This method returns the indicator capabilities of the phone
+ *
+ * \retval aActionCaps An integer that will contain the bit-wise sum of TMobilePhoneIndicatorCaps flags
+ * \retval aIndCaps An integer that will contain the bit-wise sum of supported TMobilePhoneIndicators flags
+ * \return KErrNone
+ * \exception KErrNotSupported if indicators are not supported
+ */
+	{
+	/*TPckg<TUint32> ptr1(aActionCaps);
+	TPckg<TUint32> ptr2(aIndCaps);
+	return Get(EMobilePhoneGetIndicatorCaps, ptr1, ptr2);*/
+	return 0;
+	}
+
+EXPORT_C void RMobilePhone::GetIndicator(TRequestStatus& aReqStatus, TUint32& aIndicator) const
+/**
+ * This method returns the current value of the supported indicators from the phone
+ *
+ * \retval aIndicator Will contain bit-wise sum of the current values of each indicator
+ * \exception KErrNotSupported if indicators are not supported
+ */
+	{
+	/*__ASSERT_ALWAYS(iMmPtrHolder!=NULL,PanicClient(EEtelPanicNullHandle));
+
+	TPtr8& ptr1=iMmPtrHolder->Set(CMobilePhonePtrHolder::ESlot1GetIndicator,aIndicator);
+
+	Get(EMobilePhoneGetIndicator,aReqStatus,ptr1);*/
+	}
+
+EXPORT_C void RMobilePhone::NotifyIndicatorChange(TRequestStatus& aReqStatus, TUint32& aIndicator) const
+/**
+ * This notification completes if any of the supported indicators change state
+ *
+ * \retval aIndicator Will contain bit-wise sum of the new values of each indicator
+ * \exception KErrNotSupported if indicators are not supported
+ */
+	{
+	/*__ASSERT_ALWAYS(iMmPtrHolder!=NULL,PanicClient(EEtelPanicNullHandle));
+
+	TPtr8& ptr1=iMmPtrHolder->Set(CMobilePhonePtrHolder::ESlot1NotifyIndicatorChange,aIndicator);
+
+	Get(EMobilePhoneNotifyIndicatorChange, aReqStatus, ptr1);*/
+	}
+
+/***********************************************************************************/
+//
+// MobilePhoneIdentity functional unit
+//
+/***********************************************************************************/
+
+EXPORT_C TInt RMobilePhone::GetIdentityCaps(TUint32& aCaps) const
+/**
+ * This method returns the identity capabilities of the phone
+ *
+ * \retval aCaps An integer that will contain the bit-wise sum of the identity capabilities
+ * \return KErrNone
+ * \exception KErrNotSupported if phone and subscriber identity information is not supported
+ */
+	{
+//	TPckg<TUint32> ptr1(aCaps);
+//	return Get(EMobilePhoneGetIdentityCaps, ptr1);
+    return 0;
+	}
+
+EXPORT_C RMobilePhone::TMobilePhoneIdentityV1::TMobilePhoneIdentityV1()
+	{
+	iExtensionId=KETelExtMultimodeV1;
+	}
+
+EXPORT_C void RMobilePhone::GetPhoneId(TRequestStatus& aReqStatus, TMobilePhoneIdentityV1& aId) const
+/**
+ * This method returns the identity of the phone
+ *
+ * \retval aId Will contain the identity, which can consist of manufacturer, model, revision and serial numbers
+ */
+	{
+/*	__ASSERT_ALWAYS(iMmPtrHolder!=NULL,PanicClient(EEtelPanicNullHandle));
+
+	TPtr8& ptr1=iMmPtrHolder->Set(CMobilePhonePtrHolder::ESlot1GetPhoneId,aId);
+
+	Get(EMobilePhoneGetPhoneId, aReqStatus, ptr1);*/
+	}
+
+EXPORT_C void RMobilePhone::GetSubscriberId(TRequestStatus& aReqStatus, TMobilePhoneSubscriberId& aId) const
+/**
+ * This method returns the identity of the subscriber (IMSI)
+ *
+ * \retval aId Will contain the identity
+ */
+	{
+/*	__ASSERT_ALWAYS(iMmPtrHolder!=NULL,PanicClient(EEtelPanicNullHandle));
+
+	TPtr8& ptr1=iMmPtrHolder->Set(CMobilePhonePtrHolder::ESlot1GetSubscriberId,aId);
+
+	Get(EMobilePhoneGetSubscriberId, aReqStatus, ptr1);*/
+	}
+
+/***********************************************************************************/
+//
+// MobilePhoneDTMF functional unit
+//
+/***********************************************************************************/
+
+EXPORT_C TInt RMobilePhone::GetDTMFCaps(TUint32& aCaps) const
+/**
+ * This method returns the DTMF capabilities of the phone
+ *
+ * \retval aCaps An integer that will contain the bit-wise sum of the DTMF capabilities
+ * \return KErrNone
+ * \exception KErrNotSupported if DTMF is not supported
+ */
+	{
+//	TPckg<TUint32> ptr1(aCaps);
+//	return Get(EMobilePhoneGetDTMFCaps, ptr1);
+    return 0;
+	}
+
+EXPORT_C void RMobilePhone::NotifyDTMFCapsChange(TRequestStatus& aReqStatus, TUint32& aCaps) const
+/**
+ * This notification completes if the DTMF capabilities of the phone change
+ *
+ * \retval aCaps An integer that will contain the new DTMF capabilities
+ */
+	{
+/*	__ASSERT_ALWAYS(iMmPtrHolder!=NULL,PanicClient(EEtelPanicNullHandle));
+
+	TPtr8& ptr1=iMmPtrHolder->Set(CMobilePhonePtrHolder::ESlot1NotifyDTMFCapsChange, aCaps);
+
+	Get(EMobilePhoneNotifyDTMFCapsChange, aReqStatus, ptr1);*/
+	}
+
+EXPORT_C void RMobilePhone::SendDTMFTones(TRequestStatus& aReqStatus, const TDesC& aTones) const
+/**
+ * This method sends a series of DTMF tones across a connected and active voice call
+ *
+ * \param aTones Supplies the tones to send
+ */
+	{
+//	Set(EMobilePhoneSendDTMFTones, aReqStatus, aTones);
+	}
+
+EXPORT_C TInt RMobilePhone::StartDTMFTone(TChar aTone) const
+/**
+ * This method starts the transmission of a single DTMF tone across a connected and active voice call
+ *
+ * \param aTone Supplies the tone to send
+ */
+	{
+	/*TPckgC<TChar> ptr1(aTone);
+	return Set(EMobilePhoneStartDTMFTone,ptr1);*/
+	}
+
+EXPORT_C TInt RMobilePhone::StopDTMFTone() const
+/**
+ * This method stops the transmission of a single DTMF tone across a connected and active voice call
+ */
+	{
+//	return Blank(EMobilePhoneStopDTMFTone);
+    return 0;
+	}
+
+EXPORT_C void RMobilePhone::NotifyStopInDTMFString(TRequestStatus& aRequestStatus) const
+/**
+ * This notification completes if a stop character is found within a DTMF string
+ */
+	{
+	//Blank(EMobilePhoneNotifyStopInDTMFString,aRequestStatus);
+	}
+
+EXPORT_C TInt RMobilePhone::ContinueDTMFStringSending(TBool aContinue) const
+/**
+ * This method either continues or cancels the sending of a string of DTMF tones
+ * It assumes that a stop character has previously been found within the string
+ *
+ * \param aContinue A boolean that specifies whether the sending will continue or stop
+ */
+	{
+	/*TPckg<TBool> ptr1(aContinue);
+	return Set(EMobilePhoneContinueDTMFStringSending,ptr1);*/
+	}
+
+/***********************************************************************************/
+//
+// MobilePhoneNetwork functional unit
+//
+/***********************************************************************************/
+
+EXPORT_C RMobilePhone::TMobilePhoneNetworkInfoV1::TMobilePhoneNetworkInfoV1()
+:	iMode(ENetworkModeUnknown),
+	iStatus(ENetworkStatusUnknown),
+	iBandInfo(EBandUnknown)
+	{
+	iExtensionId=KETelExtMultimodeV1;
+	}
+
+void RMobilePhone::TMobilePhoneNetworkInfoV1::InternalizeL(RReadStream& aStream)
+/**
+ * This method internalizes the mobile network information from a stream 
+ *
+ * \param aStream The read stream containing the mobile network information
+ */
+	{
+/*	TMultimodeType::InternalizeL(aStream);
+	iMode=STATIC_CAST(TMobilePhoneNetworkMode, aStream.ReadUint32L());
+	iStatus=STATIC_CAST(TMobilePhoneNetworkStatus, aStream.ReadUint32L());
+	iBandInfo=STATIC_CAST(TMobilePhoneNetworkBandInfo, aStream.ReadUint32L());
+	aStream >> iCountryCode;
+	aStream >> iCdmaSID;
+	aStream >> iAnalogSID;
+	aStream >> iNetworkId;
+	aStream >> iDisplayTag;
+	aStream >> iShortName;
+	aStream >> iLongName;*/
+	}
+
+void RMobilePhone::TMobilePhoneNetworkInfoV1::ExternalizeL(RWriteStream& aStream) const
+/**
+ * This method externalizes the mobile network information into a stream 
+ *
+ * \param aStream The write stream that will contain the mobile network information
+ */
+	{
+/*	TMultimodeType::ExternalizeL(aStream);
+	aStream.WriteUint32L(iMode);
+	aStream.WriteUint32L(iStatus);
+	aStream.WriteUint32L(iBandInfo);
+	aStream << iCountryCode;
+	aStream << iCdmaSID;
+	aStream << iAnalogSID;
+	aStream << iNetworkId;
+	aStream << iDisplayTag;
+	aStream << iShortName;
+	aStream << iLongName;*/
+	}
+
+EXPORT_C TInt RMobilePhone::GetNetworkCaps(TUint32& aCaps) const
+/**
+ * This method returns the network capabilities of the phone
+ *
+ * \retval aCaps An integer that will contain the bit-wise sum of the network capabilities
+ * \return KErrNone
+ * \exception KErrNotSupported if network access/information is not supported
+ */
+	{
+	/*TPckg<TUint32> ptr1(aCaps);
+	return Get(EMobilePhoneGetNetworkCaps, ptr1);*/
+	return 0;
+	}
+
+EXPORT_C TInt RMobilePhone::GetCurrentMode(TMobilePhoneNetworkMode& aNetworkMode) const
+/**
+ * This method returns the current mode of the phone
+ *
+ * \retval aNetworkMode Will contain the mode (GSM, WCDMA, CDMA, TDMA, AMPS)
+ */
+	{ 
+	TInt err = 0;
+    CSipSseTestTls* tls = CSipSseTestTls::Storage();
+    if ( tls )
+        {
+        aNetworkMode  = tls->PhoneNetworkModeStatus();
+        err = tls->Error();
+        }
+        
+	return err;
+	}
+
+EXPORT_C void RMobilePhone::NotifyModeChange(TRequestStatus& aReqStatus, TMobilePhoneNetworkMode& aNetworkMode) const
+/**
+ * This notification completes if the mode of the phone changes
+ *
+ * \retval aNetworkMode Will contain the new mode (GSM, WCDMA, CDMA, TDMA, AMPS)
+ */
+	{
+/*	__ASSERT_ALWAYS(iMmPtrHolder!=NULL,PanicClient(EEtelPanicNullHandle));
+
+	TPtr8& ptr1=iMmPtrHolder->Set(CMobilePhonePtrHolder::ESlot1NotifyModeChange, aNetworkMode);
+
+	Get(EMobilePhoneNotifyModeChange,aReqStatus, ptr1);*/
+	iReqStatus = &aReqStatus;
+	iNetworkMode = &aNetworkMode;
+	}
+	
+void RMobilePhone::DoNotifyModeChange( TMobilePhoneNetworkMode aNetworkMode, TInt aErrorCode )
+    {
+    *iNetworkMode = aNetworkMode;
+    *iReqStatus = KRequestPending;
+  	TRequestStatus* stat = iReqStatus;
+    User::RequestComplete( stat, aErrorCode );
+
+    }
+	
+void RMobilePhone::CancelAsyncRequest(TInt aReqToCancel) const
+    {
+    *iReqStatus = KRequestPending;
+  	TRequestStatus* stat = iReqStatus;
+    User::RequestComplete( stat, KErrNone );
+    }
+
+
+EXPORT_C void RMobilePhone::GetHomeNetwork(TRequestStatus& aReqStatus, TDes8& aNetworkInfo) const
+/**
+ * This method returns information on the subscriber's home network
+ *
+ * \retval aNetworkInfo Will contain the home network information
+ */
+	{
+	//Get(EMobilePhoneGetHomeNetwork, aReqStatus, aNetworkInfo);
+	}
+
+EXPORT_C RMobilePhone::TMobilePhoneLocationAreaV1::TMobilePhoneLocationAreaV1() 
+:	iAreaKnown(EFalse), iLocationAreaCode(0), iCellId(0)
+	{
+	iExtensionId=KETelExtMultimodeV1;
+	}
+
+EXPORT_C void RMobilePhone::GetCurrentNetwork(TRequestStatus& aReqStatus, TDes8& aNetworkInfo, TMobilePhoneLocationAreaV1& aArea) const
+/**
+ * This method returns information on the phone's current serving network
+ *
+ * \retval aNetworkInfo Will contain the information related to the current network
+ * \retval aArea Will contain the phone's current location area
+ */
+	{
+	/*__ASSERT_ALWAYS(iMmPtrHolder!=NULL,PanicClient(EEtelPanicNullHandle));
+
+	TPtr8& ptr2=iMmPtrHolder->Set(CMobilePhonePtrHolder::ESlot1GetCurrentNetwork, aArea);
+
+	Get(EMobilePhoneGetCurrentNetwork, aReqStatus, aNetworkInfo, ptr2);*/
+	}
+
+EXPORT_C void RMobilePhone::NotifyCurrentNetworkChange(TRequestStatus& aReqStatus, TDes8& aNetworkInfo, TMobilePhoneLocationAreaV1& aArea) const
+/**
+ * This notification completes if the serving network of the phone changes
+ *
+ * \retval aNetworkInfo Will contain the information related to the new network
+ * \retval aArea Will contain the phone's new location area
+ */
+	{
+	/*__ASSERT_ALWAYS(iMmPtrHolder!=NULL,PanicClient(EEtelPanicNullHandle));
+
+	TPtr8& ptr2=iMmPtrHolder->Set(CMobilePhonePtrHolder::ESlot1NotifyCurrentNetworkChange, aArea);
+
+	Get(EMobilePhoneNotifyCurrentNetworkChange, aReqStatus, aNetworkInfo, ptr2);*/
+	}
+
+EXPORT_C void RMobilePhone::GetNetworkRegistrationStatus(TRequestStatus& aReqStatus, TMobilePhoneRegistrationStatus& aStatus) const
+/**
+ * This method returns the phone's current network registration status
+ *
+ * \retval aStatus Will contain the network registration status
+ */
+	{
+    CSipSseTestTls* tls = CSipSseTestTls::Storage();
+    if ( tls )
+        {
+        tls->RegistrationStatus( aStatus );
+        }
+        
+	/*__ASSERT_ALWAYS(iMmPtrHolder!=NULL,PanicClient(EEtelPanicNullHandle));
+
+	TPtr8& ptr1=iMmPtrHolder->Set(CMobilePhonePtrHolder::ESlot1GetNetworkRegistrationStatus, aStatus);
+
+	Get(EMobilePhoneGetNetworkRegistrationStatus, aReqStatus, ptr1);*/
+	}
+
+EXPORT_C void RMobilePhone::NotifyNetworkRegistrationStatusChange(TRequestStatus& aReqStatus, TMobilePhoneRegistrationStatus& aStatus) const
+/**
+ * This notification completes if the network registration status of the phone changes
+ *
+ * \retval aStatus Will contain the new network registration status
+ */
+	{
+	/*__ASSERT_ALWAYS(iMmPtrHolder!=NULL,PanicClient(EEtelPanicNullHandle));
+
+	TPtr8& ptr1=iMmPtrHolder->Set(CMobilePhonePtrHolder::ESlot1NotifyNetworkRegistrationStatusChange, aStatus);
+
+	Get(EMobilePhoneNotifyNetworkRegistrationStatusChange, aReqStatus, ptr1);*/
+	CSipSseTestTls* tls = CSipSseTestTls::Storage();
+    if ( tls )
+        {
+        tls->SetRegistrationStatus( &aStatus );
+        tls->SetRequestStatus( aReqStatus );
+        }
+	}
+
+EXPORT_C RMobilePhone::TMobilePhoneNetworkSelectionV1::TMobilePhoneNetworkSelectionV1()
+	: iMethod(ENetworkSelectionUnknown), 
+	  iBandClass(ENetworkBandClassUnknown), 
+	  iOperationMode(ENetworkOperationUnknown)
+	{
+	iExtensionId=KETelExtMultimodeV1;
+	}
+
+EXPORT_C TInt RMobilePhone::GetNetworkSelectionSetting(TDes8& aSetting) const
+/**
+ * This method returns the phone's current network selection setting
+ *
+ * \retval aSetting Will contain the network selection setting
+ */
+	{
+	//return Get(EMobilePhoneGetNetworkSelectionSetting, aSetting);
+	return 0;
+	}
+
+EXPORT_C void RMobilePhone::SetNetworkSelectionSetting(TRequestStatus& aReqStatus, const TDes8& aSetting) const
+/**
+ * This method sets a new value for the phone's network selection setting
+ *
+ * \param aSetting Supplies the new network selection setting
+ */
+	{
+	//Set(EMobilePhoneSetNetworkSelectionSetting,aReqStatus,aSetting);
+	}
+
+EXPORT_C void RMobilePhone::NotifyNetworkSelectionSettingChange(TRequestStatus& aReqStatus, TDes8& aSetting) const
+/**
+ * This notification completes if the network selection setting of the phone changes
+ *
+ * \retval aSetting Will contain the new setting
+ */
+	{
+	//Get(EMobilePhoneNotifyNetworkSelectionSettingChange, aReqStatus, aSetting);
+	}
+
+EXPORT_C void RMobilePhone::SelectNetwork(TRequestStatus& aReqStatus, TBool aIsManual, const TMobilePhoneNetworkManualSelection& aManualSelection) const
+/**
+ * This method instructs the phone to initiate network selection
+ *
+ * \param aIsManual Specifies whether phone should manual or automatic network selection method
+ * \param aManualSelection If aIsManual=ETrue, then this parameter contain the user's manually selected network
+ */
+	{
+	/*__ASSERT_ALWAYS(iMmPtrHolder!=NULL,PanicClient(EEtelPanicNullHandle));
+
+	iMmPtrHolder->iIsManual = aIsManual;
+	TPtrC8& ptr1=iMmPtrHolder->SetC(CMobilePhonePtrHolder::ESlot1SelectNetwork, iMmPtrHolder->iIsManual);
+	TPtrC8& ptr2=iMmPtrHolder->SetC(CMobilePhonePtrHolder::ESlot2SelectNetwork, aManualSelection);
+
+	Set(EMobilePhoneSelectNetwork,aReqStatus, ptr1, ptr2);*/
+	}
+
+EXPORT_C RMobilePhone::TMobilePhoneNITZ::TMobilePhoneNITZ() 
+	: iNitzFieldsUsed(0), iTimeZone(0), iDST(0)
+	{
+	}
+
+EXPORT_C RMobilePhone::TMobilePhoneNITZ::TMobilePhoneNITZ(TInt aYear, TMonth aMonth, TInt aDay, TInt aHour, TInt aMinute, TInt aSecond, TInt aMicroSecond) 
+	: TDateTime(aYear,aMonth,aDay,aHour,aMinute,aSecond,aMicroSecond), iNitzFieldsUsed(0), iTimeZone(0), iDST(0)
+	{
+	}
+
+EXPORT_C TInt RMobilePhone::GetNITZInfo(TMobilePhoneNITZ& aNITZInfo) const
+/**
+ * This method returns the current snapshot of network time & date information
+ *
+ * \retval aNITZInfo Will contain the time & date information
+ */
+	{
+	TPckg<TMobilePhoneNITZ> ptr1(aNITZInfo);
+	return Get(EMobilePhoneGetNITZInfo,ptr1);
+	}
+
+EXPORT_C void RMobilePhone::NotifyNITZInfoChange(TRequestStatus& aReqStatus, TMobilePhoneNITZ& aNITZInfo) const
+/**
+ * This notification completes if the time & date information sent by the network changes
+ *
+ * \retval aNITZInfo Will contain the new time & date information
+ */
+	{
+	/*__ASSERT_ALWAYS(iMmPtrHolder!=NULL,PanicClient(EEtelPanicNullHandle));
+
+	TPtr8& ptr1 = iMmPtrHolder->Set(CMobilePhonePtrHolder::ESlot1NotifyNITZInfoChange,aNITZInfo);
+	Get(EMobilePhoneNotifyNITZInfoChange,aReqStatus,ptr1);*/
+	}
+
+/***********************************************************************************/
+//
+// MobilePrivacy functional unit
+//
+/***********************************************************************************/
+
+EXPORT_C TInt RMobilePhone::GetDefaultPrivacy(TMobilePhonePrivacy& aSetting) const
+/**
+ * This method returns the phone's default voice privacy setting in CDMA mode
+ *
+ * \retval aSetting An enum that will contain the current privacy setting
+ * \return KErrNone
+ * \exception KErrNotSupported if user network access is not supported
+ */
+	{
+	//TPckg<TMobilePhonePrivacy> ptr1(aSetting);
+	//return Get(EMobilePhoneGetDefaultPrivacy, ptr1);
+	return 0;
+	}
+
+EXPORT_C void RMobilePhone::SetDefaultPrivacy(TRequestStatus& aReqStatus, TMobilePhonePrivacy aSetting) const
+/**
+ * This method sets the phone's default voice privacy setting in CDMA mode
+ *
+ * \param aSetting Supplies the new voice privacy setting
+ */
+	{
+	/*__ASSERT_ALWAYS(iMmPtrHolder!=NULL,PanicClient(EEtelPanicNullHandle));
+	
+	iMmPtrHolder->iPrivacySetting = aSetting;
+	TPtrC8& ptr1=iMmPtrHolder->SetC(CMobilePhonePtrHolder::ESlot1SetDefaultPrivacy,iMmPtrHolder->iPrivacySetting);
+
+	Set(EMobilePhoneSetDefaultPrivacy,aReqStatus, ptr1);*/
+	}
+
+EXPORT_C void RMobilePhone::NotifyDefaultPrivacyChange(TRequestStatus& aReqStatus, TMobilePhonePrivacy& aSetting) const
+/**
+ * This notification completes if the default voice privacy setting of the phone changes
+ *
+ * \retval aSetting An enum that will contain the new privacy setting
+ */
+	{
+	/*__ASSERT_ALWAYS(iMmPtrHolder!=NULL,PanicClient(EEtelPanicNullHandle));
+
+	TPtr8& ptr1=iMmPtrHolder->Set(CMobilePhonePtrHolder::ESlot1NotifyDefaultPrivacyChange, aSetting);
+
+	Get(EMobilePhoneNotifyDefaultPrivacyChange, aReqStatus, ptr1);*/
+	}
+
+/***********************************************************************************/
+//
+// TSY Capabilities for supplementary call services
+//
+/***********************************************************************************/
+
+EXPORT_C TInt RMobilePhone::GetCallServiceCaps(TUint32& aCaps) const
+/**
+ * This method returns the supplementary call service capabilities of the phone
+ *
+ * \retval aCaps An integer that will contain the bit-wise sum of the call service caps
+ * \return KErrNone
+ * \exception KErrNotSupported if user network access is not supported
+ */
+	{
+	//TPckg<TUint32> ptr1(aCaps);
+	//return Get(EMobilePhoneGetCallServiceCaps, ptr1);
+	return 0;
+	}
+
+EXPORT_C void RMobilePhone::NotifyCallServiceCapsChange(TRequestStatus& aReqStatus, TUint32& aCaps) const
+/**
+ * This notification completes if the call service capabilities of the phone change
+ *
+ * \retval aCaps An integer that will contain the new call service capabilities
+ */
+	{
+    /*__ASSERT_ALWAYS(iMmPtrHolder!=NULL,PanicClient(EEtelPanicNullHandle));
+
+	TPtr8& ptr1=iMmPtrHolder->Set(CMobilePhonePtrHolder::ESlot1NotifyCallServiceCapsChange, aCaps);
+
+	Get(EMobilePhoneNotifyCallServiceCapsChange, aReqStatus, ptr1);*/
+	}
+
+/***********************************************************************************/
+//
+// MobilePhoneUserNetworkAccess functional unit
+//
+/***********************************************************************************/
+
+EXPORT_C void RMobilePhone::ProgramFeatureCode(TRequestStatus& aReqStatus, const TDesC& aFCString, TMobilePhoneNetworkService aService, TMobilePhoneServiceAction aAction) const
+/**
+ * This method programs a feature code string against a network service action
+ *
+ * \param aFCString Supplies the feature code string to be programmed
+ * \param aService Specifies which service is applicable to the feature code string
+ * \param aAction Specifies which action is applicable to the feature code string
+ */
+	{
+	/*__ASSERT_ALWAYS(iMmPtrHolder!=NULL,PanicClient(EEtelPanicNullHandle));
+	
+	iMmPtrHolder->iProgramFeatureCode.iService = aService;
+	iMmPtrHolder->iProgramFeatureCode.iAction = aAction;
+	TPtrC8& ptr1=iMmPtrHolder->SetC(CMobilePhonePtrHolder::ESlot1ProgramFeatureCode,iMmPtrHolder->iProgramFeatureCode);
+
+	Set(EMobilePhoneProgramFeatureCode,aReqStatus, ptr1, aFCString);*/
+	}
+
+EXPORT_C void RMobilePhone::GetFeatureCode(TRequestStatus& aReqStatus, TDes& aFCString, TMobilePhoneNetworkService aService, TMobilePhoneServiceAction aAction) const
+/**
+ * This method returns the feature code string programmed against a network service action
+ *
+ * \param aService Specifies which service is applicable to the feature code string
+ * \param aAction Specifies which action is applicable to the feature code string
+ * \retval aFCString Will contain the feature code string programmed
+ */
+	{
+	/*__ASSERT_ALWAYS(iMmPtrHolder!=NULL,PanicClient(EEtelPanicNullHandle));
+	
+	iMmPtrHolder->iGetFeatureCode.iService = aService;
+	iMmPtrHolder->iGetFeatureCode.iAction = aAction;
+	TPtr8& ptr1=iMmPtrHolder->Set(CMobilePhonePtrHolder::ESlot1GetFeatureCode,iMmPtrHolder->iGetFeatureCode);
+
+	Get(EMobilePhoneGetFeatureCode,aReqStatus, ptr1, aFCString);*/
+	}
+
+EXPORT_C void RMobilePhone::SendNetworkServiceRequest(TRequestStatus& aReqStatus, const TDesC& aServiceString) const
+/**
+ * This method sends a request to the network in the form of a character and digit string
+ * It will complete either when the network has confirmed the request or after the phone has sent it
+ * depending upon whether network confirmation is supported by serving network
+ *
+ * \param aServiceString Supplies the supplementary service or feature code string to be sent
+ */
+	{
+	//Set(EMobilePhoneSendNetworkServiceRequest, aReqStatus, aServiceString);
+	}
+
+/***********************************************************************************/
+//
+// MobilePhoneCallForwarding functional unit
+// 
+/***********************************************************************************/
+
+EXPORT_C RMobilePhone::TMobilePhoneCFInfoEntryV1::TMobilePhoneCFInfoEntryV1() 
+:	iCondition(ECallForwardingUnspecified), 
+	iServiceGroup(EServiceUnspecified),
+	iStatus(ECallForwardingStatusUnknown),
+	iTimeout(0)
+	{
+	iExtensionId=KETelExtMultimodeV1;
+	}
+
+void RMobilePhone::TMobilePhoneCFInfoEntryV1::InternalizeL(RReadStream& aStream)
+/**
+ * This method internalizes the call forwarding information from a stream 
+ *
+ * \param aStream The read stream containing the call forwarding information
+ */
+	{
+    /*TMultimodeType::InternalizeL(aStream);
+	iCondition=STATIC_CAST(TMobilePhoneCFCondition, aStream.ReadUint32L());
+	iServiceGroup=STATIC_CAST(TMobileService, aStream.ReadUint32L());
+	iStatus=STATIC_CAST(TMobilePhoneCFStatus, aStream.ReadUint32L());
+	aStream >> iNumber;
+	iTimeout=aStream.ReadInt32L();*/
+	}
+
+void RMobilePhone::TMobilePhoneCFInfoEntryV1::ExternalizeL(RWriteStream& aStream) const
+/**
+ * This method externalizes the call forwarding information into a stream 
+ *
+ * \param aStream The write stream that will contain the call forwarding information
+ */
+	{
+	/*TMultimodeType::ExternalizeL(aStream);
+	aStream.WriteUint32L(iCondition);
+	aStream.WriteUint32L(iServiceGroup);
+	aStream.WriteUint32L(iStatus);
+	aStream << iNumber;
+	aStream.WriteInt32L(iTimeout);*/
+	}
+
+EXPORT_C void RMobilePhone::NotifyCallForwardingStatusChange(TRequestStatus& aReqStatus, TMobilePhoneCFCondition& aCondition) const
+/**
+ * This notification completes if the status of a call forwarding service changes
+ *
+ * \retval aCondition Will contain the name of the changed service (CFU, CFB, CFNRc, CFNRy)
+ */
+	{
+	/*__ASSERT_ALWAYS(iMmPtrHolder!=NULL,PanicClient(EEtelPanicNullHandle));
+	
+	TPtr8& ptr1=iMmPtrHolder->Set(CMobilePhonePtrHolder::ESlot1NotifyCallForwardingStatusChange,aCondition);
+
+	Get(EMobilePhoneNotifyCallForwardingStatusChange,aReqStatus, ptr1);*/
+	}
+
+EXPORT_C RMobilePhone::TMobilePhoneCFChangeV1::TMobilePhoneCFChangeV1() 
+:	iServiceGroup(EServiceUnspecified),
+	iAction(EServiceActionUnspecified), 
+	iTimeout(0)
+	{
+	iExtensionId=KETelExtMultimodeV1;
+	}
+
+EXPORT_C void RMobilePhone::SetCallForwardingStatus(TRequestStatus& aReqStatus, TMobilePhoneCFCondition aCondition, const TMobilePhoneCFChangeV1& aInfo) const
+/**
+ * This method sets the call forwarding status for incoming calls across all lines
+ * It will complete either when the network has confirmed the request or after the phone has sent it
+ * depending upon whether network confirmation is supported by serving network
+ *
+ * \param aCondition Specifies which call forwarding service (CFU, CFB, CFNRy, CFNRc) is being set
+ * \param aInfo Supplies the new status and/or registered information of the call forwarding service, as applied to all basic services (i.e. all lines)
+ */
+	{
+	/*__ASSERT_ALWAYS(iMmPtrHolder!=NULL,PanicClient(EEtelPanicNullHandle));
+	
+	iMmPtrHolder->iSetCFCondition = aCondition;
+	TPtrC8& ptr1=iMmPtrHolder->SetC(CMobilePhonePtrHolder::ESlot1SetCallForwardingStatus,iMmPtrHolder->iSetCFCondition);
+
+	TPtrC8& ptr2=iMmPtrHolder->SetC(CMobilePhonePtrHolder::ESlot2SetCallForwardingStatus,aInfo);
+
+	Set(EMobilePhoneSetCallForwardingStatus, aReqStatus, ptr1, ptr2);*/
+	}
+
+EXPORT_C void RMobilePhone::NotifyCallForwardingActive(TRequestStatus& aReqStatus, TMobileService& aServiceGroup, TMobilePhoneCFActive& aActiveType) const
+/**
+ * This notification completes if a call is made on this line while call forwarding is active on it
+ *
+ * \retval aActiveType Will indicate whether unconditional (CFU) or one of the conditional (CFB, CFNRy, CFNRc) services is active
+ */
+	{
+	/*__ASSERT_ALWAYS(iMmPtrHolder!=NULL,PanicClient(EEtelPanicNullHandle));
+
+	TPtr8& ptr1=iMmPtrHolder->Set(CMobilePhonePtrHolder::ESlot1PhoneNotifyCallForwardingActive, aServiceGroup);
+	TPtr8& ptr2=iMmPtrHolder->Set(CMobilePhonePtrHolder::ESlot2PhoneNotifyCallForwardingActive, aActiveType);
+
+	Get(EMobilePhoneNotifyCallForwardingActive, aReqStatus, ptr1, ptr2);*/
+	}
+
+/***********************************************************************************/
+//
+// Mobile Identity Service functional unit
+// 
+/***********************************************************************************/
+
+EXPORT_C void RMobilePhone::GetIdentityServiceStatus(TRequestStatus& aReqStatus, const TMobilePhoneIdService aService, TMobilePhoneIdServiceStatus& aStatus, TMobileInfoLocation aLocation) const
+/**
+ * This method returns the current status of the specified identity service
+ *
+ * \param aService Specifies which identity service (CLIP, CLIR, COLP, COLR etc.) is being interrogated
+ * \retval aStatus Will contain the current status of the service
+ * \param aLocation Specifies whether the information should be retrieved from phone cache or network
+ */
+	{
+	/*)__ASSERT_ALWAYS(iMmPtrHolder!=NULL,PanicClient(EEtelPanicNullHandle));
+
+	iMmPtrHolder->iGetIdentityServiceStatus.iLocation = aLocation;
+	iMmPtrHolder->iGetIdentityServiceStatus.iService = aService;
+	TPtrC8& ptr1 = iMmPtrHolder->SetC(CMobilePhonePtrHolder::ESlot1GetIdentityServiceStatus,iMmPtrHolder->iGetIdentityServiceStatus);
+	TPtr8& ptr2 = iMmPtrHolder->Set(CMobilePhonePtrHolder::ESlot2GetIdentityServiceStatus,aStatus);
+
+	SetAndGet(EMobilePhoneGetIdentityServiceStatus,aReqStatus,ptr1,ptr2);*/
+	}
+
+/***********************************************************************************/
+//
+// Mobile Call Barring functional unit
+// 
+/***********************************************************************************/
+
+EXPORT_C RMobilePhone::TMobilePhoneCBInfoEntryV1::TMobilePhoneCBInfoEntryV1() 
+:	iCondition(EBarUnspecified), 
+	iServiceGroup(EServiceUnspecified), 
+	iStatus(ECallBarringStatusUnknown)
+	{
+	iExtensionId=KETelExtMultimodeV1;
+	}
+
+void RMobilePhone::TMobilePhoneCBInfoEntryV1::InternalizeL(RReadStream& aStream)
+/**
+ * This method internalizes the call barring inforamation from a stream 
+ *
+ * \param aStream The read stream containing the call barring inforamation
+ */
+	{
+	/*TMultimodeType::InternalizeL(aStream);
+	iCondition = STATIC_CAST(TMobilePhoneCBCondition,aStream.ReadUint32L());
+	iServiceGroup = STATIC_CAST(TMobileService,aStream.ReadUint32L());
+	iStatus = STATIC_CAST(TMobilePhoneCBStatus,aStream.ReadUint32L());*/
+	}
+
+void RMobilePhone::TMobilePhoneCBInfoEntryV1::ExternalizeL(RWriteStream& aStream) const
+/**
+ * This method externalizes the call barring information into a stream 
+ *
+ * \param aStream The write stream that will contain the call barring information
+ */
+	{
+	/*TMultimodeType::ExternalizeL(aStream);
+	aStream.WriteUint32L(iCondition);
+	aStream.WriteUint32L(iServiceGroup);
+	aStream.WriteUint32L(iStatus);*/
+	}
+
+EXPORT_C RMobilePhone::TMobilePhoneCBChangeV1::TMobilePhoneCBChangeV1() 
+:	iServiceGroup(EServiceUnspecified),
+	iAction(EServiceActionUnspecified)
+	{
+	iExtensionId=KETelExtMultimodeV1;
+	}
+
+EXPORT_C void RMobilePhone::SetCallBarringStatus(TRequestStatus& aReqStatus, TMobilePhoneCBCondition aCondition, const TMobilePhoneCBChangeV1& aInfo) const
+/**
+ * This method sets the call barring status for calls across all lines
+ * It will complete either when the network has confirmed the request or after the phone has sent it
+ * depending upon whether network confirmation is supported by serving network
+ *
+ * \param aCondition Specifies which call barring program (BAOC, BIC etc) is being set
+ * \param aInfo Supplies the new status of the call barring service, as applied to all basic services (i.e. all lines)
+ */
+	{
+	/*__ASSERT_ALWAYS(iMmPtrHolder!=NULL,PanicClient(EEtelPanicNullHandle));
+
+	iMmPtrHolder->iSetCBStatusCondition = aCondition;
+	TPtrC8& ptr1 = iMmPtrHolder->SetC(CMobilePhonePtrHolder::ESlot1SetCallBarringStatus,iMmPtrHolder->iSetCBStatusCondition);
+	TPtrC8& ptr2 = iMmPtrHolder->SetC(CMobilePhonePtrHolder::ESlot2SetCallBarringStatus,aInfo);
+
+	Set(EMobilePhoneSetCallBarringStatus,aReqStatus,ptr1,ptr2);*/
+	}
+
+EXPORT_C void RMobilePhone::NotifyCallBarringStatusChange(TRequestStatus& aReqStatus, TMobilePhoneCBCondition& aCondition) const
+/**
+ * This notification completes if the status of a call barring program changes
+ *
+ * \retval aCondition Will contain the name of the changed barring program (BAOC, BIC etc.)
+ */
+	{
+	/*__ASSERT_ALWAYS(iMmPtrHolder!=NULL,PanicClient(EEtelPanicNullHandle));
+
+	TPtr8& ptr1 = iMmPtrHolder->Set(CMobilePhonePtrHolder::ESlot1NotifyCallBarringStatusChange,aCondition);
+
+	Get(EMobilePhoneNotifyCallBarringStatusChange,aReqStatus,ptr1);*/
+	}
+
+EXPORT_C RMobilePhone::TMobilePhonePasswordChangeV1::TMobilePhonePasswordChangeV1()
+	{
+	iExtensionId=KETelExtMultimodeV1;
+	}
+
+EXPORT_C void RMobilePhone::SetCallBarringPassword(TRequestStatus& aReqStatus, const TMobilePhonePasswordChangeV1& aPassword) const
+/**
+ * This method sets the call barring password that is part of the subscription for any call barring program
+ * It will complete either when the network has confirmed the request or after the phone has sent it
+ * depending upon whether network confirmation is supported by serving network
+ *
+ * \param aPassword Supplies the old and new call barring passwords
+ */
+	{
+	/*__ASSERT_ALWAYS(iMmPtrHolder!=NULL,PanicClient(EEtelPanicNullHandle));
+
+	TPtrC8& ptr1 = iMmPtrHolder->SetC(CMobilePhonePtrHolder::ESlot1SetCallBarringPassword,aPassword);
+
+	Set(EMobilePhoneSetCallBarringPassword,aReqStatus,ptr1);*/
+	}
+
+/***********************************************************************************/
+//
+// Mobile Call Waiting functional unit
+// 
+/***********************************************************************************/
+
+void RMobilePhone::TMobilePhoneCWInfoEntryV1::InternalizeL(RReadStream& aStream)
+/**
+ * This method internalizes the call waiting inforamation from a stream 
+ *
+ * \param aStream The read stream containing the call waiting inforamation
+ */
+	{
+	/*TMultimodeType::InternalizeL(aStream);
+	iServiceGroup = STATIC_CAST(TMobileService,aStream.ReadUint32L());
+	iStatus = STATIC_CAST(TMobilePhoneCWStatus,aStream.ReadUint32L());*/
+	}
+
+void RMobilePhone::TMobilePhoneCWInfoEntryV1::ExternalizeL(RWriteStream& aStream) const
+/**
+ * This method externalizes the call waiting information into a stream 
+ *
+ * \param aStream The write stream that will contain the call waiting information
+ */
+	{
+	/*TMultimodeType::ExternalizeL(aStream);
+	aStream.WriteUint32L(iServiceGroup);
+	aStream.WriteUint32L(iStatus);*/
+	}
+
+EXPORT_C RMobilePhone::TMobilePhoneCWInfoEntryV1::TMobilePhoneCWInfoEntryV1() 
+:	iServiceGroup(EServiceUnspecified), 
+	iStatus(ECallWaitingStatusUnknown)
+	{
+	iExtensionId=KETelExtMultimodeV1;
+	}
+
+EXPORT_C void RMobilePhone::SetCallWaitingStatus(TRequestStatus& aReqStatus, TMobileService aServiceGroup, TMobilePhoneServiceAction aAction) const
+/**
+ * This method sets the status of the call waiting service for all lines
+ * It will complete either when the network has confirmed the request or after the phone has sent it
+ * depending upon whether network confirmation is supported by serving network
+ *
+ * \param aAction Supplies the new status of the call waiting service, as applied to all basic services
+ */
+	{
+	/*__ASSERT_ALWAYS(iMmPtrHolder!=NULL,PanicClient(EEtelPanicNullHandle));
+
+	iMmPtrHolder->iSetCallWaitingStatusGroup = aServiceGroup;
+	iMmPtrHolder->iSetCallWaitingStatusAction = aAction;
+	
+	TPtrC8& ptr1 = iMmPtrHolder->SetC(CMobilePhonePtrHolder::ESlot1SetCallWaitingStatus,iMmPtrHolder->iSetCallWaitingStatusGroup);
+	TPtrC8& ptr2 = iMmPtrHolder->SetC(CMobilePhonePtrHolder::ESlot2SetCallWaitingStatus,iMmPtrHolder->iSetCallWaitingStatusAction);
+
+	Set(EMobilePhoneSetCallWaitingStatus,aReqStatus,ptr1,ptr2);*/
+	}
+
+EXPORT_C void RMobilePhone::NotifyCallWaitingStatusChange(TRequestStatus& aReqStatus, TDes8& aCWStatus) const
+/**
+ * This notification completes if the status of the call waiting service changes
+ *
+ * \retval aCWStatus Will contain the new status of the call waiting service
+ */
+	{
+	//Get(EMobilePhoneNotifyCallWaitingStatusChange,aReqStatus,aCWStatus);
+	}
+
+
+/***********************************************************************************/
+//
+// Mobile Call Completion functional unit
+// 
+/***********************************************************************************/
+	
+EXPORT_C void RMobilePhone::GetCCBSStatus(TRequestStatus& aReqStatus, TMobilePhoneCCBSStatus& aCcbsStatus, TMobileInfoLocation aLocation) const
+/**
+ * This method returns the current status of the CCBS service
+ *
+ * \retval aCcbsStatus Will contain the current status of the service
+ * \param aLocation Specifies whether the information should be retrieved from phone cache or network
+ */
+	{
+	/*__ASSERT_ALWAYS(iMmPtrHolder!=NULL,PanicClient(EEtelPanicNullHandle));
+
+	iMmPtrHolder->iGetCCBSStatusLocation = aLocation;
+	TPtr8& ptr1 = iMmPtrHolder->Set(CMobilePhonePtrHolder::ESlot1GetCCBSStatus,aCcbsStatus);
+	TPtr8& ptr2 = iMmPtrHolder->Set(CMobilePhonePtrHolder::ESlot2GetCCBSStatus,iMmPtrHolder->iGetCCBSStatusLocation);
+
+	Get(EMobilePhoneGetCCBSStatus,aReqStatus,ptr1,ptr2);*/
+	}
+
+EXPORT_C void RMobilePhone::NotifyCCBSStatusChange(TRequestStatus& aReqStatus, TMobilePhoneCCBSStatus& aCcbsStatus) const
+/**
+ * This notification completes if the status of the CCBS service changes
+ *
+ * \retval aCcbsStatus Will contain the new status of the CCBS service
+ */
+	{
+	/*__ASSERT_ALWAYS(iMmPtrHolder!=NULL,PanicClient(EEtelPanicNullHandle));
+
+	TPtr8& ptr1 = iMmPtrHolder->Set(CMobilePhonePtrHolder::ESlot1NotifyCCBSStatusChange,aCcbsStatus);
+
+	Get(EMobilePhoneNotifyCCBSStatusChange,aReqStatus,ptr1);*/
+	}
+
+/*EXPORT_C void RMobilePhone::DeactivateAllCCBS(TRequestStatus& aReqStatus) const
+/**
+ * This method deactivates all currently active CCBS requests
+ * It will complete either when the network has confirmed the request or after the phone has sent it
+ * depending upon whether network confirmation is supported by serving network
+ *
+ */
+	//{
+	//Blank(EMobilePhoneDeactivateAllCCBS,aReqStatus);
+	//}
+
+void RMobilePhone::TMobilePhoneCCBSEntryV1::InternalizeL(RReadStream& aStream)
+/**
+ * This method internalizes the CCBS inforamation from a stream 
+ *
+ * \param aStream The read stream containing the CCBS inforamation
+ */
+	{
+	/*TMultimodeType::InternalizeL(aStream);
+	aStream >> iCallName;
+	iServiceGroup = STATIC_CAST(TMobileService,aStream.ReadUint32L());
+	iCcbsIndex = STATIC_CAST(TInt,aStream.ReadUint32L());
+	aStream >> iDestination;*/
+	}
+
+void RMobilePhone::TMobilePhoneCCBSEntryV1::ExternalizeL(RWriteStream& aStream) const
+/**
+ * This method externalizes the CCBS information into a stream 
+ *
+ * \param aStream The write stream that will contain the CCBS information
+ */
+	{
+	/*TMultimodeType::ExternalizeL(aStream);
+	aStream << iCallName;
+	aStream.WriteInt32L(iServiceGroup);
+	aStream.WriteInt32L(iCcbsIndex);
+	aStream << iDestination;*/
+	}
+
+EXPORT_C RMobilePhone::TMobilePhoneCCBSEntryV1::TMobilePhoneCCBSEntryV1() 
+:	iCcbsIndex(0), iServiceGroup(EServiceUnspecified)
+	{
+	iExtensionId=KETelExtMultimodeV1;
+	}
+
+/***********************************************************************************/
+//
+// Mobile Alternating Call functional unit
+// 
+/***********************************************************************************/
+
+EXPORT_C TInt RMobilePhone::GetAlternatingCallCaps(TUint32& aCaps) const
+/**
+ * This method returns the alternating call capabilities of the phone
+ *
+ * \retval aCaps An integer that will contain the bit-wise sum of the alternating call capabilities
+ * \return KErrNone
+ * \exception KErrNotSupported if alternating calls are not supported
+ */
+	{
+	/*TPckg<TUint32> ptr1(aCaps);
+	return Get(EMobilePhoneGetAlternatingCallCaps,ptr1);*/
+	return 0;
+	}
+
+EXPORT_C void RMobilePhone::NotifyAlternatingCallCapsChange(TRequestStatus& aReqStatus, TUint32& aCaps) const
+/**
+ * This notification completes if the alternating call capabilities of the phone change
+ *
+ * \retval aCaps An integer that will contain the new alternating call capabilities
+ */
+	{
+	/*__ASSERT_ALWAYS(iMmPtrHolder!=NULL,PanicClient(EEtelPanicNullHandle));
+
+	TPtr8& ptr1 = iMmPtrHolder->Set(CMobilePhonePtrHolder::ESlot1NotifyAlternatingCallCapsChange,aCaps);
+
+	Get(EMobilePhoneNotifyAlternatingCallCapsChange,aReqStatus,ptr1);*/
+	}
+
+EXPORT_C TInt RMobilePhone::GetAlternatingCallMode(TMobilePhoneAlternatingCallMode& aMode, TMobileService& aFirstService) const
+/**
+ * This method returns the current alternating call mode
+ *
+ * \retval aMode Will contain the current alternating call mode
+ * \retval aFirstService Will contain the service that will be first in an alternating call (voice, data, fax)
+ */
+	{
+	/*TPckg<TMobilePhoneAlternatingCallMode> ptr1(aMode);
+	TPckg<TMobileService> ptr2(aFirstService);
+
+	return Get(EMobilePhoneGetAlternatingCallMode,ptr1,ptr2);*/
+	}
+
+EXPORT_C void RMobilePhone::SetAlternatingCallMode(TRequestStatus& aReqStatus, TMobilePhoneAlternatingCallMode aMode, TMobileService aFirstService) const
+/**
+ * This method sets a new value for alternating call mode
+ *
+ * \param aMode Specifies the new alternating call mode
+ * \param aFirstService Specifies the service that will be first in an alternating call (voice, data, fax)
+ */
+	{
+	/*__ASSERT_ALWAYS(iMmPtrHolder!=NULL,PanicClient(EEtelPanicNullHandle));
+
+	iMmPtrHolder->iSetAlternatingCallModeMode = aMode;
+	iMmPtrHolder->iSetAlternatingCallModeService = aFirstService;
+	TPtrC8& ptr1 = iMmPtrHolder->SetC(CMobilePhonePtrHolder::ESlot1SetAlternatingCallMode,iMmPtrHolder->iSetAlternatingCallModeMode);
+	TPtrC8& ptr2 = iMmPtrHolder->SetC(CMobilePhonePtrHolder::ESlot2SetAlternatingCallMode,iMmPtrHolder->iSetAlternatingCallModeService);
+	
+	Set(EMobilePhoneSetAlternatingCallMode,aReqStatus,ptr1,ptr2);*/
+	}
+
+EXPORT_C void RMobilePhone::NotifyAlternatingCallModeChange(TRequestStatus& aReqStatus, TMobilePhoneAlternatingCallMode& aMode,TMobileService& aFirstService) const
+/**
+ * This notification completes if the alternating call mode of the phone changes
+ *
+ * \retval aMode Will contain the new alternating call mode
+ * \retval aFirstService Will contain the service that will be first in an alternating call (voice, data, fax)
+ */
+	{
+	/*__ASSERT_ALWAYS(iMmPtrHolder!=NULL,PanicClient(EEtelPanicNullHandle));
+
+	TPtr8& ptr1 = iMmPtrHolder->Set(CMobilePhonePtrHolder::ESlot1NotifyAlternatingCallModeChange,aMode);
+	TPtr8& ptr2 = iMmPtrHolder->Set(CMobilePhonePtrHolder::ESlot2NotifyAlternatingCallModeChange,aFirstService);
+
+	Get(EMobilePhoneNotifyAlternatingCallModeChange,aReqStatus,ptr1,ptr2);*/
+	}
+
+/***********************************************************************************/
+//
+// Mobile Alternate Line Service functional unit
+// 
+/***********************************************************************************/
+
+
+EXPORT_C TInt RMobilePhone::GetALSLine(TMobilePhoneALSLine& aALSLine) const
+/**
+ * This method returns the current ALS line selected
+ *
+ * \retval aALSLine Will contain the ALS line selected
+ */
+	{
+	/*TPckg<TMobilePhoneALSLine> ptr1(aALSLine);
+	return Get(EMobilePhoneGetALSLine,ptr1);*/
+	return 0;
+	}
+
+EXPORT_C void RMobilePhone::SetALSLine(TRequestStatus& aReqStatus, TMobilePhoneALSLine aALSLine) const
+/**
+ * This method sets a new values for the ALS line selected
+ *
+ * \param aALSLine Specifies the new ALS line selected
+ */
+	{
+	/*__ASSERT_ALWAYS(iMmPtrHolder!=NULL,PanicClient(EEtelPanicNullHandle));
+
+	iMmPtrHolder->iSetALSLine = aALSLine;
+	TPtrC8& ptr1 = iMmPtrHolder->SetC(CMobilePhonePtrHolder::ESlot1SetALSLine,iMmPtrHolder->iSetALSLine);
+
+	Set(EMobilePhoneSetALSLine,aReqStatus,ptr1);*/
+	}
+
+EXPORT_C void RMobilePhone::NotifyALSLineChange(TRequestStatus& aReqStatus, TMobilePhoneALSLine& aALSLine) const
+/**
+ * This notification completes if the ALS line selected changes
+ *
+ * \retval aALSLine Will contain the new ALS line selected
+ */
+	{
+	/*__ASSERT_ALWAYS(iMmPtrHolder!=NULL,PanicClient(EEtelPanicNullHandle));
+
+	TPtr8& ptr1 = iMmPtrHolder->Set(CMobilePhonePtrHolder::ESlot1NotifyALSLineChange,aALSLine);
+
+	Get(EMobilePhoneNotifyALSLineChange,aReqStatus,ptr1);*/
+	}
+
+/***********************************************************************************/
+//
+// Mobile Cost functional unit
+// 
+/***********************************************************************************/
+
+
+EXPORT_C TInt RMobilePhone::GetCostCaps(TUint32& aCaps) const
+/**
+ * This method returns the call cost information capabilities of the phone
+ *
+ * \retval aCaps An integer that will contain the bit-wise sum of the call cost information capabilities
+ * \return KErrNone
+ * \exception KErrNotSupported if call cost information is not supported
+ */
+	{
+	//TPckg<TUint32> ptr1(aCaps);
+	//return Get(EMobilePhoneGetCostCaps,ptr1);
+	return 0;
+	}
+
+EXPORT_C void RMobilePhone::NotifyCostCapsChange(TRequestStatus& aReqStatus, TUint32& aCaps) const
+/**
+ * This notification completes if the call cost information capabilities of the phone change
+ *
+ * \retval aCaps An integer that will contain the new call cost information capabilities
+ */
+	{
+	/*__ASSERT_ALWAYS(iMmPtrHolder!=NULL,PanicClient(EEtelPanicNullHandle));
+
+	TPtr8& ptr1 = iMmPtrHolder->Set(CMobilePhonePtrHolder::ESlot1NotifyCostCapsChange,aCaps);
+
+	Get(EMobilePhoneNotifyCostCapsChange,aReqStatus,ptr1);*/
+	}
+
+EXPORT_C void RMobilePhone::ClearCostMeter(TRequestStatus& aReqStatus, TMobilePhoneCostMeters aMeter) const
+/**
+ * This method clears the Accumulated Cost Meter (ACM) on the SIM
+ * It will complete either when the SIM confirms that ACM is cleared or after the phone has
+ * been denied access due to the requirement for PIN2 entry first
+ */
+	{
+	/*__ASSERT_ALWAYS(iMmPtrHolder!=NULL,PanicClient(EEtelPanicNullHandle));
+
+	iMmPtrHolder->iClearCostMeter = aMeter;
+	TPtrC8& ptr1 = iMmPtrHolder->SetC(CMobilePhonePtrHolder::ESlot1ClearCostMeter,iMmPtrHolder->iClearCostMeter);
+
+	Set(EMobilePhoneClearCostMeter,aReqStatus,ptr1);*/
+	}
+
+EXPORT_C void RMobilePhone::SetMaxCostMeter(TRequestStatus& aReqStatus, TUint aUnits) const
+/**
+ * This method sets a new value for the Max Accumulated Cost Meter (ACMmax) on the SIM
+ * It will complete either when the SIM confirms that ACMmax is set or after the phone has
+ * been denied access due to the requirement for PIN2 entry first
+ *
+ * \param aUnits Specifies the number of units to set ACMmax to
+ */
+	{
+	/*__ASSERT_ALWAYS(iMmPtrHolder!=NULL,PanicClient(EEtelPanicNullHandle));
+
+	iMmPtrHolder->iSetMaxCostMeterUnits = aUnits;
+	TPtrC8& ptr1 = iMmPtrHolder->SetC(CMobilePhonePtrHolder::ESlot1SetMaxCostMeter,iMmPtrHolder->iSetMaxCostMeterUnits);
+
+	Set(EMobilePhoneSetMaxCostMeter,aReqStatus,ptr1);*/
+	}
+
+EXPORT_C RMobilePhone::TMobilePhonePuctV1::TMobilePhonePuctV1() 
+: iPricePerUnit(0.0)
+	{
+	iExtensionId=KETelExtMultimodeV1;
+	}
+
+	
+EXPORT_C void RMobilePhone::SetPuct(TRequestStatus& aReqStatus, const TDesC8& aPuct) const
+/**
+ * This method sets a new value for the Price Per Unit & Currency Table (PUCT) on the SIM
+ * It will complete either when the SIM confirms that PUCT is set or after the phone has
+ * been denied access due to the requirement for PIN2 entry first
+ *
+ * \param aPuct Supplies the new PUCT setting
+ */
+	{
+	Set(EMobilePhoneSetPuct,aReqStatus,aPuct);
+	}
+
+EXPORT_C RMobilePhone::TMobilePhoneCostInfoV1::TMobilePhoneCostInfoV1() 
+:	iService(ECostServiceUnknown), 
+	iCCM(0), 
+	iACM(0), 
+	iACMmax(0)
+	{
+	iExtensionId=KETelExtMultimodeV1;
+	}
+	
+EXPORT_C void RMobilePhone::GetCostInfo(TRequestStatus& aReqStatus, TDes8& aCostInfo) const
+/**
+ * This method returns the current snapshot of the phone's call cost information
+ *
+ * \retval aCostInfo Will contain the cost information
+ */
+	{
+	//Get(EMobilePhoneGetCostInfo,aReqStatus,aCostInfo);
+	}
+
+EXPORT_C void RMobilePhone::NotifyCostInfoChange(TRequestStatus& aReqStatus, TDes8& aCostInfo) const
+/**
+ * This notification completes if the call cost information changes
+ *
+ * \retval aCostInfo Will contain the new call cost information
+ */
+	{
+	//Get(EMobilePhoneNotifyCostInfoChange,aReqStatus,aCostInfo);
+	}
+
+
+/***********************************************************************************/
+//
+// Mobile Security functional unit
+// 
+/***********************************************************************************/
+
+EXPORT_C TInt RMobilePhone::GetSecurityCaps(TUint32& aCaps) const
+/**
+ * This method returns the security capabilities of the phone
+ *
+ * \retval aCaps An integer that will contain the bit-wise sum of the security capabilities
+ * \return KErrNone
+ * \exception KErrNotSupported if security is not supported
+ */
+	{
+	/*TPckg<TUint32> ptr1(aCaps);
+	return Get(EMobilePhoneGetSecurityCaps,ptr1);*/
+	return 0;
+	}
+
+EXPORT_C void RMobilePhone::NotifySecurityCapsChange(TRequestStatus& aReqStatus, TUint32& aCaps) const
+/**
+ * This notification completes if the security capabilities of the phone change
+ *
+ * \retval aCaps An integer that will contain the new security capabilities
+ */
+	{
+	/*__ASSERT_ALWAYS(iMmPtrHolder!=NULL,PanicClient(EEtelPanicNullHandle));
+	
+	TPtr8& ptr1 = iMmPtrHolder->Set(CMobilePhonePtrHolder::ESlot1NotifySecurityCapsChange,aCaps);
+
+	Get(EMobilePhoneNotifySecurityCapsChange,aReqStatus,ptr1);*/
+	}
+
+EXPORT_C RMobilePhone::TMobilePhoneLockInfoV1::TMobilePhoneLockInfoV1() 
+:	iStatus(EStatusLocked), 
+	iSetting(ELockSetEnabled)
+	{
+	iExtensionId=KETelExtMultimodeV1;
+	}
+
+EXPORT_C void RMobilePhone::GetLockInfo(TRequestStatus& aReqStatus, TMobilePhoneLock aLock, TDes8& aLockInfo) const
+/**
+ * This method returns the current status and setting of the specified lock
+ *
+ * \param aLock Specifies which lock is being interrogated
+ * \retval aLockInfo Will contain the lock's current status and setting
+ */
+	{
+	/*__ASSERT_ALWAYS(iMmPtrHolder!=NULL,PanicClient(EEtelPanicNullHandle));
+
+	iMmPtrHolder->iLock = aLock;
+	TPtrC8& ptr1 = iMmPtrHolder->SetC(CMobilePhonePtrHolder::ESlot1GetLockInfo,iMmPtrHolder->iLock);
+
+	SetAndGet(EMobilePhoneGetLockInfo,aReqStatus,ptr1,aLockInfo);*/
+	}
+
+EXPORT_C void RMobilePhone::NotifyLockInfoChange(TRequestStatus& aReqStatus, TMobilePhoneLock& aLock, TDes8& aLockInfo) const
+/**
+ * This notification completes if the status or information of a lock changes
+ *
+ * \retval aLockInfo Will contain the new lock status and information
+ */
+	{
+	/*__ASSERT_ALWAYS(iMmPtrHolder!=NULL,PanicClient(EEtelPanicNullHandle));
+
+	TPtr8& ptr1 = iMmPtrHolder->Set(CMobilePhonePtrHolder::ESlot1NotifyLockInfoChange,aLock);
+	
+	Get(EMobilePhoneNotifyLockInfoChange,aReqStatus,ptr1,aLockInfo);*/
+	}
+
+EXPORT_C void RMobilePhone::SetLockSetting(TRequestStatus& aReqStatus, TMobilePhoneLock aLock, TMobilePhoneLockSetting aSetting) const
+/**
+ * This method sets a new value for the setting of the specified lock
+ *
+ * \param aLock Specifies which lock is being set
+ * \param aSetting Supplies the lock's new setting
+ */
+	{
+	/*__ASSERT_ALWAYS(iMmPtrHolder!=NULL,PanicClient(EEtelPanicNullHandle));
+
+	iMmPtrHolder->iSetLockSettingLock = aLock;
+	iMmPtrHolder->iSetLockSettingSetting = aSetting;
+
+	TPtrC8& ptr1 = iMmPtrHolder->SetC(CMobilePhonePtrHolder::ESlot1SetLockSetting,iMmPtrHolder->iSetLockSettingLock);
+	TPtrC8& ptr2 = iMmPtrHolder->SetC(CMobilePhonePtrHolder::ESlot2SetLockSetting,iMmPtrHolder->iSetLockSettingSetting);
+
+	Set(EMobilePhoneSetLockSetting,aReqStatus,ptr1,ptr2);*/
+	}
+
+EXPORT_C void RMobilePhone::ChangeSecurityCode(TRequestStatus& aReqStatus, TMobilePhoneSecurityCode aType, const TMobilePhonePasswordChangeV1& aChange) const
+/**
+ * This method changes the value of the specified security code
+ *
+ * \param aType Specifies which security code is being changed
+ * \param aChange Supplies the old and new values for the security code
+ */
+	{
+	/*__ASSERT_ALWAYS(iMmPtrHolder!=NULL,PanicClient(EEtelPanicNullHandle));
+
+	iMmPtrHolder->iChangeSecurityCodeType = aType;
+	TPtrC8& ptr1 = iMmPtrHolder->SetC(CMobilePhonePtrHolder::ESlot1ChangeSecurityCode,iMmPtrHolder->iChangeSecurityCodeType);
+	TPtrC8& ptr2 = iMmPtrHolder->SetC(CMobilePhonePtrHolder::ESlot2ChangeSecurityCode,aChange);
+
+	Set(EMobilePhoneChangeSecurityCode,aReqStatus,ptr1,ptr2);*/
+	}
+
+EXPORT_C void RMobilePhone::NotifySecurityEvent(TRequestStatus& aReqStatus, TMobilePhoneSecurityEvent& aEvent) const
+/**
+ * This notification completes if the phone recognises that a security event has occurred
+ *
+ * \retval aEvent Will contain the security event
+ */
+	{
+	/*__ASSERT_ALWAYS(iMmPtrHolder!=NULL,PanicClient(EEtelPanicNullHandle));
+
+	TPtr8& ptr1 = iMmPtrHolder->Set(CMobilePhonePtrHolder::ESlot1NotifySecurityEvent,aEvent);
+
+	Get(EMobilePhoneNotifySecurityEvent,aReqStatus,ptr1);*/
+	}
+
+EXPORT_C void RMobilePhone::VerifySecurityCode(TRequestStatus& aReqStatus, TMobilePhoneSecurityCode aType, const TMobilePassword& aCode,
+		const TMobilePassword& aUnblockCode) const
+/**
+ * This method verifies the user's code agains the specified stored security code
+ *
+ * \param aType Specifies which security code is being verified
+ * \param aCode Supplies the user's code
+ * \param aUnblockCode Supplies the user's unblock code which may be needed if the user is actually unblocking a security code (e.g. PIN1 or PIN2)
+ */
+	{
+	/*__ASSERT_ALWAYS(iMmPtrHolder!=NULL,PanicClient(EEtelPanicNullHandle));
+
+	iMmPtrHolder->iVerifySecurityCodeType = aType;
+	iMmPtrHolder->iVerifySecurityCodeData.iCode = aCode;
+	iMmPtrHolder->iVerifySecurityCodeData.iUnblockCode = aUnblockCode;
+	
+	TPtrC8& ptr1 = iMmPtrHolder->SetC(CMobilePhonePtrHolder::ESlot1VerifySecurityCode,iMmPtrHolder->iVerifySecurityCodeType);
+	TPtrC8& ptr2 = iMmPtrHolder->SetC(CMobilePhonePtrHolder::ESlot2VerifySecurityCode,iMmPtrHolder->iVerifySecurityCodeData);
+
+	Set(EMobilePhoneVerifySecurityCode,aReqStatus,ptr1,ptr2);*/	
+	}
+
+EXPORT_C TInt RMobilePhone::AbortSecurityCode(TMobilePhoneSecurityCode aType) const
+/**
+ * This method informs the phone that the user has cancelled the request for a security code to be entered
+ */
+	{
+	/*TPckg<TMobilePhoneSecurityCode> ptr1(aType);
+	return Set(EMobilePhoneAbortSecurityCode,ptr1);*/
+	}
+
+EXPORT_C RMobilePhone::TMobilePhoneMulticallSettingsV1::TMobilePhoneMulticallSettingsV1()
+	: iUserMaxBearers(-1),iServiceProviderMaxBearers(-1),iNetworkSupportedMaxBearers(-1),
+	iUESupportedMaxBearers(-1)
+	{
+	iExtensionId=KETelExtMultimodeV1;
+	}
+
+EXPORT_C void RMobilePhone::GetMulticallParams(TRequestStatus& aReqStatus, TDes8& aMulticallParams) const
+/** 
+ * This method retrieves the maximum number of simultaneous CS service bearers defined by 
+ * the user, defined by the service provider, supported by the network and supported by the phone.
+ *
+ * \param aMulticallParams Will contain the multicall bearer settings
+ */
+	{
+	//Get(EMobilePhoneGetMulticallParams, aReqStatus, aMulticallParams);	
+	}
+
+EXPORT_C void RMobilePhone::SetMulticallParams(TRequestStatus& aReqStatus, TInt aUserMaxBearers) const
+/**
+ * This method is used by client application to set the maximum number of 
+ * simultaneous CS bearers specified by the user (iUserMaxBearers)
+ *
+ * \param aUserMaxBearers Supplies the new user specified value
+ */	
+	{
+	/*__ASSERT_ALWAYS(iMmPtrHolder!=NULL,PanicClient(EEtelPanicNullHandle));
+
+	iMmPtrHolder->iUserMaxBearers = aUserMaxBearers;
+	TPtrC8& ptr1=iMmPtrHolder->SetC(CMobilePhonePtrHolder::ESlot1SetMulticallParams, iMmPtrHolder->iUserMaxBearers);
+
+	Set(EMobilePhoneSetMulticallParams,aReqStatus,ptr1);*/
+	}
+
+EXPORT_C void RMobilePhone::NotifyMulticallParamsChange(TRequestStatus& aReqStatus, TDes8& aMulticallParams) const
+/**
+ * This notification completes if the multicall parameters of the phone change
+ *
+ * \retval aMulticallParams Will contain the new Multicall parameters set by the network
+ */
+	{
+	//Get(EMobilePhoneNotifyMulticallParamsChange, aReqStatus, aMulticallParams);
+	}
+
+/***********************************************************************************/
+//
+// Mobile Message Waiting functional unit
+// 
+/***********************************************************************************/
+
+EXPORT_C RMobilePhone::TMobilePhoneMessageWaitingV1::TMobilePhoneMessageWaitingV1()
+: iVoiceMsgs(0), iAuxVoiceMsgs(0), iDataMsgs(0), iFaxMsgs(0), iEmailMsgs(0), iOtherMsgs(0)
+	{
+	iExtensionId=KETelExtMultimodeV1;
+	}
+
+EXPORT_C void RMobilePhone::NotifyMessageWaiting(TRequestStatus& aReqStatus, TInt& aCount) const
+/**
+ * This notification completes if the phone receives a "message waiting" message from the network
+ *
+ * \retval aCount Will contain the number of voicemail messages waiting
+ */
+	{
+	/*__ASSERT_ALWAYS(iMmPtrHolder!=NULL,PanicClient(EEtelPanicNullHandle));
+
+	TPtr8& ptr1 = iMmPtrHolder->Set(CMobilePhonePtrHolder::ESlot1NotifyMessageWaiting,aCount);
+
+	Get(EMobilePhoneNotifyMessageWaiting,aReqStatus,ptr1);*/
+	}
+
+EXPORT_C void RMobilePhone::GetIccMessageWaitingIndicators(TRequestStatus& aReqStatus, TDes8& aMsgIndicators) const
+/**
+ * This method retrieves the set of message waiting indicators from the current ICC
+ *
+ * \retval aMsgIndicators Will contain the type and number of waiting messages
+ */
+	{
+	//Get(EMobilePhoneGetIccMessageWaitingIndicators,aReqStatus,aMsgIndicators);
+	}
+
+EXPORT_C void RMobilePhone::SetIccMessageWaitingIndicators(TRequestStatus& aReqStatus, const TDesC8& aMsgIndicators) const
+/**
+ * This method sets the message waiting indicators on the current ICC
+ *
+ * \retval aMsgIndicators Will contain the type and number of waiting messages
+ */
+	{
+	//Set(EMobilePhoneSetIccMessageWaitingIndicators,aReqStatus,aMsgIndicators);
+	}
+
+EXPORT_C void RMobilePhone::NotifyIccMessageWaitingIndicatorsChange(TRequestStatus& aReqStatus, TDes8& aMsgIndicators) const
+/**
+ * This notification completes if the message waiting indicators change on the current ICC
+ *
+ * \retval aMsgIndicators Will contain the type and number of waiting messages
+ */
+	{
+	//Get(EMobilePhoneNotifyIccMessageWaitingIndicatorsChange,aReqStatus,aMsgIndicators);
+	}
+
+/***********************************************************************************/
+//
+// Mobile Fixed Dialling Numbers functional unit
+// 
+/***********************************************************************************/
+
+
+EXPORT_C TInt RMobilePhone::GetFdnStatus(TMobilePhoneFdnStatus& aFdnStatus) const
+/**
+ * This method returns the current status of the Fixed Dialling Number (FDN) service
+ *
+ * \retval aFdnStatus Will contain the current status of FDN
+ */
+	{
+	/*TPckg<TMobilePhoneFdnStatus> ptr1(aFdnStatus);
+
+	return Get(EMobilePhoneGetFdnStatus,ptr1);*/
+	}
+
+EXPORT_C void RMobilePhone::SetFdnSetting(TRequestStatus& aReqStatus, TMobilePhoneFdnSetting aFdnSetting) const
+/**
+ * This method sets a new value for the status of the Fixed Dialling Number (FDN) service
+ *
+ * \retval aFdnSetting Supplies the new status of FDN
+ */
+	{
+	/*__ASSERT_ALWAYS(iMmPtrHolder!=NULL,PanicClient(EEtelPanicNullHandle));
+
+	iMmPtrHolder->iSetFdnSetting = aFdnSetting;
+	TPtrC8& ptr1 = iMmPtrHolder->SetC(CMobilePhonePtrHolder::ESlot1SetFdnSetting,iMmPtrHolder->iSetFdnSetting);
+	
+	Set(EMobilePhoneSetFdnSetting,aReqStatus,ptr1);*/
+	}
+
+EXPORT_C void RMobilePhone::NotifyFdnStatusChange(TRequestStatus& aReqStatus, TMobilePhoneFdnStatus& aFdnStatus) const
+/**
+ * This notification completes if the status of the FDN service changes
+ *
+ * \retval aFdnStatus Will contain the new FDN status
+ */
+	{
+	/*__ASSERT_ALWAYS(iMmPtrHolder!=NULL,PanicClient(EEtelPanicNullHandle));
+
+	TPtr8& ptr1 = iMmPtrHolder->Set(CMobilePhonePtrHolder::ESlot1NotifyFdnStatusChange,aFdnStatus);
+
+	Get(EMobilePhoneNotifyFdnStatusChange,aReqStatus,ptr1);*/
+	}
+
+/************************************************************************************/
+//
+// Single Numbering Scheme functional unit
+//
+/************************************************************************************/
+
+
+EXPORT_C void RMobilePhone::GetIncomingCallType(TRequestStatus& aReqStatus, TMobilePhoneIncomingCallType& aCallType, TDes8& aDataParams) const
+/**
+ * This method retrieves the current setting of the incoming call type
+ *
+ * \retval aType Will contain the incoming call types supported by the phone
+ * 
+ * \param aDataParams Will contain the data bearer service settings if aType
+ *  indicates that incoming calls will include a data bearer element
+ */
+	{
+	/*__ASSERT_ALWAYS(iMmPtrHolder!=NULL,PanicClient(EEtelPanicNullHandle));
+
+	TPtr8& ptr1 = iMmPtrHolder->Set(CMobilePhonePtrHolder::ESlot1GetIncomingCallType, aCallType);
+
+	Get(EMobilePhoneGetIncomingCallType, aReqStatus, ptr1, aDataParams);*/
+	}
+
+EXPORT_C void RMobilePhone::SetIncomingCallType(TRequestStatus& aReqStatus, TMobilePhoneIncomingCallType aCallType, TDes8& aDataParams) const
+/**
+ * This method sets the incoming call type.
+ *
+ * \param aCallType Supplies the new settings for the incoming call types
+ * \param aDataParam Suppies the new data settings in the case of a data bearer
+ */
+	{
+	/*)__ASSERT_ALWAYS(iMmPtrHolder!=NULL,PanicClient(EEtelPanicNullHandle));
+
+	iMmPtrHolder->iCallType = aCallType;
+	TPtrC8& ptr1 = iMmPtrHolder->SetC(CMobilePhonePtrHolder::ESlot1SetIncomingCallType, iMmPtrHolder->iCallType);
+
+	Set(EMobilePhoneSetIncomingCallType, aReqStatus, ptr1, aDataParams);*/
+	}
+
+EXPORT_C void RMobilePhone::NotifyIncomingCallTypeChange(TRequestStatus& aReqStatus, TMobilePhoneIncomingCallType& aCallType, TDes8& aDataParams) const
+/**
+ * This method notifies the client if the setting of the incoming call type changes. 
+ *
+ * \retval aCallType Will contain the new incoming call type.
+ * 
+ * \param aDataParams Will contain the data bearer service settings if aCallType
+ *  indicates that incoming calls will include a data bearer element
+ */
+	{
+	/*__ASSERT_ALWAYS(iMmPtrHolder!=NULL,PanicClient(EEtelPanicNullHandle));
+
+	TPtr8& ptr1 = iMmPtrHolder->Set(CMobilePhonePtrHolder::ESlot1NotifyIncomingCallTypeChange, aCallType);
+
+	Get(EMobilePhoneNotifyIncomingCallTypeChange, aReqStatus, ptr1, aDataParams);*/
+	}
+
+/************************************************************************************/
+//
+// User-To-User Signalling functional unit
+//
+/************************************************************************************/
+
+
+EXPORT_C void RMobilePhone::GetUUSSetting(TRequestStatus& aReqStatus, TMobilePhoneUUSSetting& aSetting) const
+/**
+ * This method retrieves the current User-User Signalling settings of the phone
+ *
+ * \retval aSetting An integer that will contain the current UUS settings
+ * \return KErrNone
+ * \exception KErrNotSupported if UUS functionality is not supported by the phone/TSY
+ */
+	{
+	/*__ASSERT_ALWAYS(iMmPtrHolder!=NULL,PanicClient(EEtelPanicNullHandle));
+	
+	TPtr8& ptr1 = iMmPtrHolder->Set(CMobilePhonePtrHolder::ESlot1GetUUSSetting, aSetting);
+	Get(EMobilePhoneGetUUSSetting, aReqStatus, ptr1);*/
+	}
+
+EXPORT_C void RMobilePhone::SetUUSSetting(TRequestStatus& aReqStatus, TMobilePhoneUUSSetting aSetting) const
+/**
+ * This method sets the User-User Signalling settings of the phone
+ *
+ * \param aSetting Supplies the new UUS settings
+ */
+	{
+	/*__ASSERT_ALWAYS(iMmPtrHolder!=NULL,PanicClient(EEtelPanicNullHandle));
+
+	iMmPtrHolder->iSetUUSSetting = aSetting;
+	TPtrC8& ptr1 = iMmPtrHolder->SetC(CMobilePhonePtrHolder::ESlot1SetUUSSetting, iMmPtrHolder->iSetUUSSetting);
+	
+	Set(EMobilePhoneSetUUSSetting, aReqStatus, ptr1);*/
+	}
+
+EXPORT_C void RMobilePhone::NotifyUUSSettingChange(TRequestStatus& aReqStatus, TMobilePhoneUUSSetting& aSetting) const
+/**
+ * This notification completes if the User-User Signalling settings of the phone change
+ *
+ * \retval aCaps An integer that will contain the new UUS settings
+ */
+	{
+	/*__ASSERT_ALWAYS(iMmPtrHolder!=NULL,PanicClient(EEtelPanicNullHandle));
+
+	TPtr8& ptr1 = iMmPtrHolder->Set(CMobilePhonePtrHolder::ESlot1NotifyUUSSettingChange,aSetting);
+
+	Get(EMobilePhoneNotifyUUSSettingChange, aReqStatus, ptr1);*/
+	}
+
+/***********************************************************************************/