diff -r 000000000000 -r 8e480a14352b messagingfw/msgsrvnstore/server/src/MSVREG.CPP
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/messagingfw/msgsrvnstore/server/src/MSVREG.CPP	Mon Jan 18 20:36:02 2010 +0200
@@ -0,0 +1,729 @@
+// Copyright (c) 1998-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:
+// MSVREG.CPP
+//
+
+#include "MSVREG.H"
+#include "MSVRUIDS.H"
+#include "MSVPANIC.H"
+#include "MsvSecurityCapabilitySet.h"
+
+#include <f32file.h>
+#include <s32strm.h>
+#include <e32uid.h>
+
+#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS  
+#include "msvconsts.h"				
+#endif
+
+/** Creates a new CMtmDllInfo and initialises it with values describing an MTM 
+component. 
+
+@param aHumanReadableName Descriptor holding a descriptive name for the MTM 
+component 
+@param aUidType Group of UIDs for the MTM. The UIDs should be as follows: UID1: 
+always KDynamicLibraryUid UID2: identifies whether the MTM component is a 
+Client-side MTM, User Interface MTM, UI Data MTM, or Server-side MTM. UID3: 
+identifies this concrete MTM uniquely 
+@param aFilename A full filename (including drive and path) of the MTM dll
+@param aEntryPointOrdinalNumber Ordinal of factory function for the MTM 
+@param aVersion Version information for the MTM component 
+@leave KErrNoMemory A memory allocation failed 
+@return New CMtmDllInfo initialised with passed values */
+EXPORT_C CMtmDllInfo* CMtmDllInfo::NewL(const TDesC& aHumanReadableName,const TUidType& aUidType,const TDesC& aFilename,TInt aEntryPointOrdinalNumber,const TVersion aVersion)
+	{
+	CMtmDllInfo* mtmdllinfo=new(ELeave) CMtmDllInfo(aUidType,aEntryPointOrdinalNumber,aVersion);
+	CleanupStack::PushL(mtmdllinfo);
+	mtmdllinfo->ConstructL(aHumanReadableName, aFilename);
+	CleanupStack::Pop(mtmdllinfo);
+	return mtmdllinfo;	
+	}
+
+/** Creates a new CMtmDllInfo initialised from another CMtmDllInfo object. 
+
+@param aMtmDllInfo A CMtmDllInfo object from which to initialise this
+@leave KErrNoMemory A memory allocation failed 
+@return New CMtmDllInfo initialised with passed CMtmDllInfo */
+EXPORT_C CMtmDllInfo* CMtmDllInfo::NewL(const CMtmDllInfo& aMtmDllInfo)
+	{
+	CMtmDllInfo* mtmdllinfo = new(ELeave) CMtmDllInfo(aMtmDllInfo);
+	CleanupStack::PushL(mtmdllinfo);
+	mtmdllinfo->ConstructL(*aMtmDllInfo.iHumanReadableName, *aMtmDllInfo.iFilename);
+	CleanupStack::Pop(mtmdllinfo);
+	return mtmdllinfo;
+	}
+	
+
+/** Creates a new CMtmDllInfo and initialises it with values read from a stream. 
+
+The contents of the stream to read will have been created by CMtmDllInfo::ExternalizeL().
+
+@param aStream Stream to read from 
+@leave KErrNoMemory A memory allocation failed
+@return New CMtmDllInfo */
+EXPORT_C CMtmDllInfo* CMtmDllInfo::NewL(RReadStream& aStream)
+	{
+	CMtmDllInfo* mtmdllinfo=new(ELeave) CMtmDllInfo();
+	CleanupStack::PushL(mtmdllinfo);
+	mtmdllinfo->InternalizeL(aStream);
+	CleanupStack::Pop();
+	return mtmdllinfo;	
+	}
+
+/** Destructor. */
+EXPORT_C CMtmDllInfo::~CMtmDllInfo()
+	{
+	delete iHumanReadableName;
+	delete iFilename;
+	}
+
+EXPORT_C void CMtmDllInfo::SetHumanReadableNameL(const TDesC& aHumanReadableName)
+/** Sets the descriptive name of the MTM component for which the object holds registration 
+data.
+
+@param aHumanReadableName Descriptor holding a descriptive name for the MTM 
+component */
+	{
+	__ASSERT_DEBUG(aHumanReadableName.Length()<=KHumanReadableNameLength,PanicServer(EMsvHumanReadableNameTooLong));
+	HBufC* humanreadablename=HBufC::NewL(aHumanReadableName.Length());
+	delete iHumanReadableName;
+	iHumanReadableName=humanreadablename;
+	iHumanReadableName->Des().Copy(aHumanReadableName);
+	}
+
+/** Internalises the object from a stream. 
+
+The contents of the stream to read will have been created by CMtmDllInfo::ExternalizeL().
+
+@param aStream Stream to read from 
+@leave Error Standard streaming errors
+*/
+EXPORT_C void CMtmDllInfo::InternalizeL(RReadStream& aStream)
+	{
+	HBufC* humanreadablename=HBufC::NewL(aStream,KHumanReadableNameLength);
+	delete iHumanReadableName;
+	iHumanReadableName=humanreadablename;
+	iMessagingCapability = aStream.ReadInt8L();
+	iSendBodyCapability = aStream.ReadInt8L();
+	iCapabilitiesAvailable = aStream.ReadInt8L();
+	TUid uid1,uid2,uid3;
+	aStream >> uid1;
+	aStream >> uid2;
+	aStream >> uid3;
+	TUidType uidtype(uid1,uid2,uid3);
+	iUidType=uidtype;                 
+	iEntryPointOrdinalNumber=aStream.ReadInt32L();
+	iVersion.iMajor=aStream.ReadInt8L();
+	iVersion.iMinor=aStream.ReadInt8L();
+	iVersion.iBuild=aStream.ReadInt16L();
+	HBufC* temp;
+	if (uid3.iUid == KUidMtmDefaultSpecificVal)
+		{
+		// We can assume we are reading data from an updated stream.
+		// The version number should be <= 2.0.
+		__ASSERT_DEBUG((iVersion.iMajor < KMtmComponentCurrentMajorVersionNumber) || (iVersion.iMajor == KMtmComponentCurrentMajorVersionNumber&& iVersion.iMinor == KMtmComponentCurrentMinorVersionNumber), PanicServer(EMsvBadMtmVersionNumber));
+		
+		temp = HBufC::NewL(aStream, KMaxFileName);
+		}
+	else
+		{
+		// Just create a zero length filename for old versions
+		temp = KNullDesC().AllocL();
+		}
+	delete iFilename;
+	iFilename = temp;
+	}
+
+
+// no longer used but as it is exported it has been kept
+/** Externalises the object to a stream. 
+
+@param aStream Stream to write to 
+@leave Error Standard streaming errors
+*/
+EXPORT_C void CMtmDllInfo::ExternalizeL(RWriteStream& aStream) const
+	{
+	aStream << *iHumanReadableName;
+	aStream.WriteInt8L(iMessagingCapability);
+	aStream.WriteInt8L(iSendBodyCapability);
+	aStream.WriteInt8L(iCapabilitiesAvailable);
+	aStream << iUidType[0];                 
+	aStream << iUidType[1];                 
+	aStream << iUidType[2];                 
+	aStream.WriteInt32L(iEntryPointOrdinalNumber);
+	aStream.WriteInt8L(iVersion.iMajor);
+	aStream.WriteInt8L(iVersion.iMinor);
+	aStream.WriteInt16L(iVersion.iBuild);
+	if (iUidType[2].iUid == KUidMtmDefaultSpecificVal)
+		{
+		// The version number should be <= 2.0.
+		__ASSERT_DEBUG((iVersion.iMajor < KMtmComponentCurrentMajorVersionNumber) || (iVersion.iMajor == KMtmComponentCurrentMajorVersionNumber && iVersion.iMinor == KMtmComponentCurrentMinorVersionNumber), PanicServer(EMsvBadMtmVersionNumber));
+
+		aStream << FileName();
+		}
+	}
+
+/** Overloaded equality operator.
+@param aMtmDllInfo Object to compare
+@return True if the iFileName member and the UIDs (iUidType member) are the same in both objects,
+otherwise false
+*/
+
+EXPORT_C TBool CMtmDllInfo::operator==(const CMtmDllInfo& aMtmDllInfo) const
+	{
+	return (FileName().CompareF(aMtmDllInfo.FileName()) == 0 && (iUidType==aMtmDllInfo.iUidType));
+	}
+
+CMtmDllInfo::CMtmDllInfo(const TUidType& aUidType,TInt aEntryPointOrdinalNumber,const TVersion aVersion):
+	iUidType(aUidType),                
+	iEntryPointOrdinalNumber(aEntryPointOrdinalNumber),
+	iVersion(aVersion)
+	{
+	__DECLARE_NAME(_S("CMtmDllInfo"));
+	}
+
+
+CMtmDllInfo::CMtmDllInfo()
+	{
+	}
+
+CMtmDllInfo::CMtmDllInfo(const CMtmDllInfo& aMtmDllInfo):
+	iUidType(aMtmDllInfo.iUidType),
+	iEntryPointOrdinalNumber(aMtmDllInfo.iEntryPointOrdinalNumber),
+	iVersion(aMtmDllInfo.iVersion),
+	iMessagingCapability(aMtmDllInfo.iMessagingCapability),
+	iSendBodyCapability(aMtmDllInfo.iSendBodyCapability),
+	iCapabilitiesAvailable(aMtmDllInfo.iCapabilitiesAvailable)
+	{
+	}
+
+void CMtmDllInfo::ConstructL(const TDesC& aHumanReadableName, const TDesC& aFilename)
+	{
+	iHumanReadableName = aHumanReadableName.AllocL();
+	iFilename = aFilename.AllocL();
+	}
+
+TPtrC CMtmDllInfo::FileName() const
+	{
+	return *iFilename;
+	}
+
+
+/** Sets a flag to indicate that the MTM can send messages. 
+
+@param aCapability True to set the flag, false to clear it
+*/
+void CMtmDllInfo::SetMessagingCapability(TBool aCapability)
+	{
+	iMessagingCapability = aCapability;
+	}
+ 
+
+/** Sets a flag to indicate that the MTM can handle body text. 
+
+@param aCapability True to set the flag, false to clear it
+*/
+void CMtmDllInfo::SetSendBodyCapability(TBool aCapability)
+	{
+	iSendBodyCapability = aCapability;
+	}
+
+/** Sets a flag to indicate that settings have been made for 
+the MessagingCapability() and SendBodyCapability() flags.
+
+These settings are optional, so may not have been made 
+for all MTMs.  
+@param aCapability True if the settings exist; otherwise false
+*/
+void CMtmDllInfo::SetCapabilitiesAvailable(TBool aCapability)
+	{
+	iCapabilitiesAvailable = aCapability;
+	}
+
+/** Tests if the flag that indicates that the MTM can send 
+messages has been set. 
+
+@return True if the flag has been set; otherwise false
+*/
+EXPORT_C TBool CMtmDllInfo::MessagingCapability() const
+	{
+	return iMessagingCapability;
+	}
+
+/** Tests if the flag that indicates that the MTM can handle  
+body text has been set. 
+
+@return True if the flag has been set; otherwise false
+*/
+EXPORT_C TBool CMtmDllInfo::SendBodyCapability() const
+	{
+	return iSendBodyCapability;
+	}
+
+/** Tests if settings have been made for the MessagingCapability() 
+and SendBodyCapability() flags.
+
+These settings are optional, so may not have been made 
+for all MTMs.  
+@return True if the settings exist; otherwise false
+*/
+EXPORT_C TBool CMtmDllInfo::CapabilitiesAvailable() const
+	{
+	return iCapabilitiesAvailable;
+	}
+
+/** Default constructor. */
+EXPORT_C CMtmDllInfoArray::CMtmDllInfoArray():
+	CArrayPtrFlat<CMtmDllInfo>(8)
+	{
+	__DECLARE_NAME(_S("CMtmDllInfoArray"));
+	}
+
+/** Destructor. */
+EXPORT_C CMtmDllInfoArray::~CMtmDllInfoArray()
+	{
+	ResetAndDestroy();
+	}
+
+EXPORT_C void CMtmDllInfoArray::AddMtmDllInfoL(CMtmDllInfo* aMtmDllInfo)
+/** Appends a CMtmDllInfo to the array.
+
+@param aMtmDllInfo CMtmDllInfo to append 
+@leave KErrNoMemory A memory allocation failed */
+	{
+	CleanupStack::PushL(aMtmDllInfo);
+	AppendL(aMtmDllInfo);
+	CleanupStack::Pop();
+	}
+
+
+
+/** Creates a new CMtmGroupData and initialise it with registration data for an 
+MTM group. 
+
+@param aMtmTypeUid UID that uniquely identifies the MTM group 
+@param aTechnologyTypeUid UID that can be used to indicate the messaging technology 
+which the MTM group implements 
+@param aMtmDllInfoArray Array of registration data for the MTM components in 
+the group. This function takes immediate responsibility for aMtmDllInfoArray,
+so it should not be on the cleanup stack prior to the call. If successful, 
+the newly created CMtmGroupData takes ownership of the object
+@param aMtmRequiredCaps The required security capabilities for this MTM group
+@leave KErrNoMemory A memory allocation failed 
+@return New initialised CMtmGroupData */
+
+EXPORT_C CMtmGroupData* CMtmGroupData::NewL(TUid aMtmTypeUid, TUid aTechnologyTypeUid, CMtmDllInfoArray* aMtmDllInfoArray, const TCapabilitySet& aMtmRequiredCaps)
+	{
+	__ASSERT_DEBUG(aMtmDllInfoArray != NULL, PanicServer(EMsvConstructWithNullDllInfoArray));
+	CleanupStack::PushL(aMtmDllInfoArray);	
+	CMtmGroupData* self = new(ELeave) CMtmGroupData(aMtmTypeUid, aTechnologyTypeUid, aMtmDllInfoArray, aMtmRequiredCaps);
+	CleanupStack::Pop(aMtmDllInfoArray); 
+	return self;	
+	}
+
+/** Creates a new CMtmGroupData and initialises it with another CMtmGroupData
+
+@param aMtmTypeGroupData Another CMtmGroupData from which to copy
+@leave KErrNoMemory A memory allocation failed 
+@return New initialised CMtmGroupData */
+
+EXPORT_C CMtmGroupData* CMtmGroupData::NewL(const CMtmGroupData& aMtmGroupData)
+	{
+	CMtmGroupData* self = new(ELeave) CMtmGroupData(aMtmGroupData.iMtmTypeUid, aMtmGroupData.iTechnologyTypeUid, NULL, aMtmGroupData.iMtmRequiredCaps);
+	CleanupStack::PushL(self);
+	self->ConstructL(aMtmGroupData);
+	CleanupStack::Pop(self);
+	return self;
+	}
+
+CMtmGroupData::CMtmGroupData(TUid aMtmTypeUid, TUid aTechnologyTypeUid, CMtmDllInfoArray* aMtmDllInfoArray,const TCapabilitySet& aMtmRequiredCaps):
+	iMtmTypeUid(aMtmTypeUid),
+	iTechnologyTypeUid(aTechnologyTypeUid),
+	iMtmDllInfoArray(aMtmDllInfoArray),
+	iMtmRequiredCaps(aMtmRequiredCaps)
+	{
+	}
+		
+void CMtmGroupData::AppendMtmDllInfoArrayL(const CMtmDllInfoArray& aMtmDllInfoArray)
+	{
+	TInt count=aMtmDllInfoArray.Count();
+	for (TInt ii=0; ii<count; ++ii)
+		{
+		CMtmDllInfo* mtmdllinfo = CMtmDllInfo::NewL(*aMtmDllInfoArray[ii]);
+		AppendMtmDllInfoL(mtmdllinfo);
+		}
+	}
+	
+void CMtmGroupData::ConstructL(const CMtmGroupData& aMtmGroupData)
+	{
+	iMtmDllInfoArray = new(ELeave) CMtmDllInfoArray();
+	AppendMtmDllInfoArrayL(aMtmGroupData.MtmDllInfoArray());
+	}
+	
+void CMtmGroupData::ConstructL()
+	{
+	iMtmDllInfoArray = new(ELeave) CMtmDllInfoArray();
+	}
+
+
+EXPORT_C CMtmGroupData* CMtmGroupData::NewL(RReadStream& aStream)
+/** Creates a new CMtmGroupData and initialises it from the specified stream.
+
+@param aStream Stream from which to read previously externalised CMtmGroupData 
+
+@leave KErrNoMemory A memory allocation failed 
+@return New initialised CMtmGroupData */
+	{
+	CMtmGroupData* mtmgroupdata=new(ELeave) CMtmGroupData();
+	CleanupStack::PushL(mtmgroupdata);
+	mtmgroupdata->ConstructL();
+	mtmgroupdata->InternalizeL(aStream);
+	CleanupStack::Pop();
+	return mtmgroupdata;	
+	}
+
+/** Destructor. */
+EXPORT_C CMtmGroupData::~CMtmGroupData()
+	{
+	delete iMtmDllInfoArray;
+	}
+
+EXPORT_C void CMtmGroupData::InternalizeL(RReadStream& aStream)
+/** Internalises group registration data. 
+
+@param aStream Stream from which to internalise object */
+	{
+	MtmDllInfoArrayPrivate().ResetAndDestroy();
+	aStream >> iMtmTypeUid;
+	aStream >> iTechnologyTypeUid;
+	TInt count=aStream.ReadInt32L();
+	for (TInt i=0; i<count; i++)
+		{
+		CMtmDllInfo* mtmdllinfo=CMtmDllInfo::NewL(aStream);
+		AppendMtmDllInfoL(mtmdllinfo);
+		}
+	MsvSecurityCapabilitySetUtils::InternalizeL(aStream,iMtmRequiredCaps);
+	}
+
+
+/** Returns a constant reference to the array of MTM dll information objects owned by the CMtmGroupData.
+
+@return A constant reference to the MTM dll info array*/
+
+EXPORT_C const CMtmDllInfoArray& CMtmGroupData::MtmDllInfoArray() const
+	{
+	// Return a const reference to the dll info array
+	__ASSERT_DEBUG(iMtmDllInfoArray != NULL, PanicServer(EMsvAttemptToUseNullDllInfoArray));
+	return *iMtmDllInfoArray;
+	}
+	
+CMtmDllInfoArray& CMtmGroupData::MtmDllInfoArrayPrivate()
+	{
+	// Return a non-const reference to the dll info array. Only for use within
+	// this class
+	__ASSERT_DEBUG(iMtmDllInfoArray != NULL, PanicServer(EMsvAttemptToUseNullDllInfoArray));
+	return *iMtmDllInfoArray;
+	}
+		
+EXPORT_C const TCapabilitySet& CMtmGroupData::GetMtmRequiredCapabilities() const
+	{
+	return iMtmRequiredCaps;
+	}
+	
+
+ // not used but as it is exported it has been kept
+EXPORT_C void CMtmGroupData::ExternalizeL(RWriteStream& aStream) const
+/** Externalises group registration data. 
+
+This is the method by which registration data is written to a MTM registration 
+data file.
+
+@param aStream Stream to which to externalise object */
+	{
+	aStream << iMtmTypeUid;
+	aStream << iTechnologyTypeUid;
+	const CMtmDllInfoArray& mtmDllInfoArray = MtmDllInfoArray();
+	TInt count=mtmDllInfoArray.Count();
+	aStream.WriteInt32L(count);
+	for (TInt ii=0; ii<count; ++ii)
+		aStream << *mtmDllInfoArray[ii];
+
+	MsvSecurityCapabilitySetUtils::ExternalizeL(aStream,iMtmRequiredCaps);
+	}
+
+EXPORT_C TBool CMtmGroupData::operator==(const CMtmGroupData& aMtmGroupData) const
+/** Tests for equality with another CMtmGroupData object.
+
+@param aMtmGroupData CMtmGroupData object with which to compare 
+@return ETrue: equal, EFalse: unequal.  */
+	{
+	TBool isequal=((iMtmTypeUid==aMtmGroupData.iMtmTypeUid) && (iTechnologyTypeUid==aMtmGroupData.iTechnologyTypeUid));
+	if (isequal)
+		{
+		const CMtmDllInfoArray& mtmDllInfoArray1 = MtmDllInfoArray();
+		const CMtmDllInfoArray& mtmDllInfoArray2 = aMtmGroupData.MtmDllInfoArray();
+		TInt count1=mtmDllInfoArray1.Count();
+		TInt count2=mtmDllInfoArray2.Count();
+		TBool isequal=(count1==count2);
+		for (TInt ii=0; (ii<count1) && isequal; ++ii)
+			isequal=(mtmDllInfoArray1[ii]==mtmDllInfoArray2[ii]);
+		}
+	if (isequal)
+		{
+		isequal = (iMtmRequiredCaps.HasCapabilities(aMtmGroupData.iMtmRequiredCaps)
+			&& aMtmGroupData.iMtmRequiredCaps.HasCapabilities(iMtmRequiredCaps));
+		}
+	return isequal;
+	}
+
+CMtmGroupData::CMtmGroupData(TUid aMtmTypeUid,TUid aTechnologyTypeUid):
+	iMtmTypeUid(aMtmTypeUid),
+	iTechnologyTypeUid(aTechnologyTypeUid)
+	{
+	__DECLARE_NAME(_S("CMtmGroupData"));
+	}
+
+
+void CMtmGroupData::AppendMtmDllInfoL(CMtmDllInfo* aMtmDllInfo)
+	{
+	CMtmDllInfoArray& mtmDllInfoArray = MtmDllInfoArrayPrivate();
+	TInt index = mtmDllInfoArray.Count();
+	CleanupStack::PushL(aMtmDllInfo);
+	if (index==KMsvNumMtmDllTypes)
+		User::Leave(KErrNotSupported);  //  There may be a better error value
+	if (aMtmDllInfo->iUidType[0]!=KDynamicLibraryUid)  
+		User::Leave(KErrNotSupported);  
+
+	TUid mtmdlltypeuid[KMsvNumMtmDllTypes] = { KUidMtmServerComponentVal, KUidMtmClientComponentVal, KUidMtmUiComponentVal, KUidMtmUiDataComponentVal };
+	__ASSERT_DEBUG(aMtmDllInfo->iUidType[1]==mtmdlltypeuid[index],PanicServer(EMsvMtmDllInfoSecondUidIncorrect));
+	if (aMtmDllInfo->iUidType[1]!=mtmdlltypeuid[index])  
+		User::Leave(KErrNotSupported);
+	mtmDllInfoArray.AppendL(aMtmDllInfo);
+	CleanupStack::Pop(aMtmDllInfo);
+	}
+
+/**
+@internalComponent
+*/
+EXPORT_C CRegisteredMtmDll* CRegisteredMtmDll::NewL(TUid aMtmTypeUid,TUid aTechnologyTypeUid,const CMtmDllInfo& aMtmDllInfo,const TTimeIntervalMicroSeconds32 aTimeoutMicroSeconds32,MRegisteredMtmDllObserver& aRegisteredMtmDllObserver)
+	{
+	CRegisteredMtmDll* registereredmtmdll=new(ELeave) CRegisteredMtmDll(aMtmTypeUid,aTechnologyTypeUid,aTimeoutMicroSeconds32,aRegisteredMtmDllObserver);
+	CleanupStack::PushL(registereredmtmdll);
+	registereredmtmdll->ConstructL(aMtmDllInfo);
+	CleanupStack::Pop();
+	return registereredmtmdll;	
+	}
+
+EXPORT_C CRegisteredMtmDll::~CRegisteredMtmDll()
+	{
+	__ASSERT_DEBUG(iMtmDllRefCount==0,PanicServer(EMsvRegisteredMtmDllStillInUse));
+	Cancel();
+	delete iMtmDllInfo;
+	iMtmDllLibrary.Close();
+	}
+
+/**
+@internalComponent
+*/
+EXPORT_C TInt CRegisteredMtmDll::GetLibrary(RFs& aFs,RLibrary& aMtmDllLibrary)
+	{
+	TInt ret=KErrNone;
+	if (iMtmDllRefCount==0)
+		TRAP(ret,LoadLibraryL(aFs));
+	if (ret==KErrNone)
+		{
+		aMtmDllLibrary=iMtmDllLibrary;
+		iMtmDllRefCount++;
+		}
+	else
+		iMtmDllLibrary.Close();
+	return ret;
+	}
+
+/**
+@internalComponent
+*/
+EXPORT_C void CRegisteredMtmDll::ReleaseLibrary()
+	{
+	__ASSERT_DEBUG(iMtmDllRefCount>0,PanicServer(EMsvRegisteredMtmDllRefCountZero));
+	iMtmDllRefCount--;
+	if (iMtmDllRefCount==0)
+		{
+		iRegisteredMtmDllObserver.ReleaseMtmGroup(iMtmTypeUid);  //  Ignore error returned, this is safe client side
+		After(iTimeoutMicroSeconds32);
+		}
+	}
+
+CRegisteredMtmDll::CRegisteredMtmDll(TUid aMtmTypeUid,TUid aTechnologyTypeUid,const TTimeIntervalMicroSeconds32 aTimeoutMicroSeconds32,MRegisteredMtmDllObserver& aRegisteredMtmDllObserver):
+	CTimer(EPriorityLow),
+	iMtmTypeUid(aMtmTypeUid),
+	iTechnologyTypeUid(aTechnologyTypeUid),
+	iTimeoutMicroSeconds32(aTimeoutMicroSeconds32),
+	iRegisteredMtmDllObserver(aRegisteredMtmDllObserver)
+	{
+	__DECLARE_NAME(_S("CRegisteredMtmDll"));
+	CActiveScheduler::Add(this);
+	}
+
+void CRegisteredMtmDll::ConstructL(const CMtmDllInfo& aMtmDllInfo)
+	{
+	CTimer::ConstructL();
+	iMtmDllInfo = CMtmDllInfo::NewL(aMtmDllInfo);
+	}
+
+void CRegisteredMtmDll::LoadLibraryL(RFs& /*aFs*/)  
+	{
+	__ASSERT_DEBUG(iMtmDllRefCount==0,PanicServer(EMsvRegisteredMtmDllRefCountNonZero));
+	Cancel();  //  Cancel timer
+	if (iMtmDllLibrary.Handle()==0)
+		{
+		// Secure API and old UID support removed - load by filename
+		User::LeaveIfError(iMtmDllLibrary.Load(iMtmDllInfo->FileName()));
+		}
+	User::LeaveIfError(iRegisteredMtmDllObserver.UseMtmGroup(iMtmTypeUid));
+	}
+
+
+void CRegisteredMtmDll::RunL()
+	{
+	iMtmDllLibrary.Close();
+	}
+
+
+EXPORT_C CRegisteredMtmDllArray::CRegisteredMtmDllArray():
+	CArrayPtrFlat<CRegisteredMtmDll>(8)
+	{
+	__DECLARE_NAME(_S("CRegisteredMtmDllArray"));
+	}
+
+EXPORT_C CRegisteredMtmDllArray::~CRegisteredMtmDllArray()
+	{
+	ResetAndDestroy();
+	}
+
+EXPORT_C void CRegisteredMtmDllArray::AddRegisteredMtmDllL(CRegisteredMtmDll* aRegisteredMtmDll)
+	{
+	CleanupStack::PushL(aRegisteredMtmDll);
+	AppendL(aRegisteredMtmDll);
+	CleanupStack::Pop();
+	}
+
+EXPORT_C CMtmDllRegistry::~CMtmDllRegistry()
+	{
+	}
+
+EXPORT_C TUid CMtmDllRegistry::MtmTypeUid(TInt anIndex) const                                
+/** Gets the MTM UID of a registered MTM using its index.
+
+@param anIndex Indexed of registered MTM 
+@return MTM UID */
+	{
+	__ASSERT_DEBUG((0<=anIndex) && (anIndex<iRegisteredMtmDllArray.Count()),PanicServer(EMsvRegisteredMtmDllIndexOutRange));
+	return iRegisteredMtmDllArray[anIndex]->MtmTypeUid();
+	}
+
+EXPORT_C TUid CMtmDllRegistry::TechnologyTypeUid(TUid aMtmTypeUid) const
+/** Gets the technology type UID for the specified MTM.
+
+@param aMtmTypeUid UID of MTM 
+@return Technology type UID */
+	{
+	__ASSERT_DEBUG(IsPresent(aMtmTypeUid),PanicServer(EMsvRegisteredMtmDllNotFound));
+	TInt index=MtmTypeUidToIndex(aMtmTypeUid);
+	return iRegisteredMtmDllArray[index]->TechnologyTypeUid();
+	}
+
+EXPORT_C const CMtmDllInfo& CMtmDllRegistry::RegisteredMtmDllInfo(TUid aMtmTypeUid) const                                
+/** Gets the registration data for the specified MTM.
+
+@param aMtmTypeUid UID of MTM 
+@return Registration data for MTM */
+	{
+	__ASSERT_DEBUG(IsPresent(aMtmTypeUid),PanicServer(EMsvRegisteredMtmDllNotFound));
+	TInt index=MtmTypeUidToIndex(aMtmTypeUid);
+	return iRegisteredMtmDllArray[index]->MtmDllInfo();
+	}
+
+EXPORT_C TBool CMtmDllRegistry::IsInUse(TUid aMtmTypeUid) const
+/** Tests if the MTM with the specified UID is in use. You should check that the 
+MTM is registered, through IsPresent(), before calling this function.
+
+@param aMtmTypeUid UID of MTM to check 
+@return ETrue if the specified MTM in use, else EFalse */
+	{
+	__ASSERT_DEBUG(IsPresent(aMtmTypeUid),PanicServer(EMsvRegisteredMtmDllNotFound));
+	TInt index=MtmTypeUidToIndex(aMtmTypeUid);
+	return iRegisteredMtmDllArray[index]->MtmDllRefCount()>0;
+	}
+
+EXPORT_C TBool CMtmDllRegistry::IsInUse() const
+/** Tests if any registered MTM is in use. 
+
+@return ETrue if any MTM in use, else EFalse */
+	{
+	TInt count=iRegisteredMtmDllArray.Count();
+	TBool isinuse=EFalse;
+	for (TInt i=0; (i<count) && (!isinuse); i++)
+		isinuse=iRegisteredMtmDllArray[i]->MtmDllRefCount()>0;
+	return isinuse;
+	}
+
+EXPORT_C CMtmDllRegistry::CMtmDllRegistry(RFs& aFs,TUid aMtmDllTypeUid,TTimeIntervalMicroSeconds32 aTimeoutMicroSeconds32):
+	iFs(aFs),
+	iMtmDllTypeUid(aMtmDllTypeUid),
+	iTimeoutMicroSeconds32(aTimeoutMicroSeconds32)
+	{
+	__DECLARE_NAME(_S("CMtmDllRegistry"));
+	}
+
+EXPORT_C TInt CMtmDllRegistry::MtmTypeUidToIndex(TUid anMtmTypeUid) const
+	{
+	TInt i=0, count=iRegisteredMtmDllArray.Count();
+	for (;(i<count) && (iRegisteredMtmDllArray[i]->MtmTypeUid()!=anMtmTypeUid); i++)
+		{
+		}
+	return i;
+	}
+
+EXPORT_C TInt CMtmDllRegistry::AddRegisteredMtmDll(TUid aMtmTypeUid,TUid aTechnologyTypeUid,const CMtmDllInfo& aMtmDllInfo,MRegisteredMtmDllObserver& aRegisteredMtmDllObserver)
+	{
+	__ASSERT_DEBUG(!IsPresent(aMtmTypeUid),PanicServer(EMsvRegisteredMtmDllHasSameMtmTypeUid));
+	__ASSERT_DEBUG(aMtmDllInfo.iUidType[0]==KDynamicLibraryUid,PanicServer(EMsvRegisteredMtmDllHasSameMtmTypeUid));
+	__ASSERT_DEBUG(aMtmDllInfo.iUidType[1]==iMtmDllTypeUid,PanicServer(EMsvRegisteredMtmDllHasSameMtmTypeUid));
+	TRAPD(ret,DoAddRegisteredMtmDllL(aMtmTypeUid,aTechnologyTypeUid,aMtmDllInfo,aRegisteredMtmDllObserver));
+	return ret;
+	}
+
+EXPORT_C void CMtmDllRegistry::RemoveRegisteredMtmDll(TUid aMtmTypeUid)
+	{
+	TInt index=MtmTypeUidToIndex(aMtmTypeUid);
+	__ASSERT_DEBUG(index<iRegisteredMtmDllArray.Count(),PanicServer(EMsvRegisteredMtmDllNotFound));
+	__ASSERT_DEBUG(iRegisteredMtmDllArray[index]->MtmDllRefCount()==0,PanicServer(EMsvRegisteredMtmDllStillInUse));
+	delete iRegisteredMtmDllArray[index];
+	iRegisteredMtmDllArray.Delete(index);
+	}
+
+EXPORT_C void CMtmDllRegistry::RemoveAllRegisteredMtmDlls()
+	{
+	iRegisteredMtmDllArray.ResetAndDestroy();
+	}
+
+void CMtmDllRegistry::DoAddRegisteredMtmDllL(TUid aMtmTypeUid,TUid aTechnologyTypeUid,const CMtmDllInfo& aMtmDllInfo,MRegisteredMtmDllObserver& aRegisteredMtmDllObserver)
+	{
+	CRegisteredMtmDll* registeredmtmdll=CRegisteredMtmDll::NewL(aMtmTypeUid,aTechnologyTypeUid,aMtmDllInfo,iTimeoutMicroSeconds32,aRegisteredMtmDllObserver);
+	iRegisteredMtmDllArray.AddRegisteredMtmDllL(registeredmtmdll);
+	}
+
+
+