// 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.H

//

/**

 * @file 

 * @publishedAll

 * @released

 */

#if !defined(__MSVREG_H__)

#define __MSVREG_H__

#if !defined(__E32BASE_H__)

#include <e32base.h>

#endif

#if !defined(__F32FILE_H__)

#include <f32file.h>

#endif

const TInt KHumanReadableNameLength=50;

typedef TBuf<KHumanReadableNameLength> THumanReadableName;   //  could be used client side

#define KMsvDefaultTimeoutMicroSeconds32 30000000

// forward declarations

class RWriteStream;

class RReadStream;

class RFs;

class CMtmDllInfo : public CBase

/** Encapsulates the registration data for a single concrete MTM component. 

It is used in the creation of registration data for an MTM group. Typically, 

an application gathers a number of CMtmDllInfo objects into an CMtmDllInfoArray. 

@publishedAll

@released

*/

	{

public:

	IMPORT_C static CMtmDllInfo* NewL(const TDesC& aHumanReadableName,const TUidType& aUidType,const TDesC& aFilename,TInt aEntryPointOrdinalNumber,const TVersion aVersion);

	IMPORT_C static CMtmDllInfo* NewL(const CMtmDllInfo& aMtmDllInfo);

	IMPORT_C static CMtmDllInfo* NewL(RReadStream& aStream);

	IMPORT_C ~CMtmDllInfo();

	IMPORT_C void SetHumanReadableNameL(const TDesC& aHumanReadableName);

	IMPORT_C void InternalizeL(RReadStream& aStream);

	IMPORT_C void ExternalizeL(RWriteStream& aStream) const;  // not used but as it is exported it has been kept

	IMPORT_C TBool operator==(const CMtmDllInfo& aMtmDllInfo) const; 

	void SetMessagingCapability(TBool aCapability);

	void SetSendBodyCapability(TBool aCapability);

	void SetCapabilitiesAvailable(TBool aBool);

	IMPORT_C TBool MessagingCapability() const;

	IMPORT_C TBool SendBodyCapability() const;

	IMPORT_C TBool CapabilitiesAvailable() const;

	TPtrC FileName() const;

private:

	CMtmDllInfo();

	CMtmDllInfo(const TUidType& aUidType,TInt aEntryPointOrdinalNumber,const TVersion aVersion);

	CMtmDllInfo(const CMtmDllInfo& aMtmDllInfo);

	void ConstructL(const TDesC& aHumanReadableName, const TDesC& aFilename);

private:

	HBufC* iHumanReadableName;         //  Should be less than KHumanReadableNameLength

public:

	/** Group of UIDs for the MTM. See NewL() for details. */

	TUidType iUidType;                 //  Three uids

	/** Ordinal of factory function for the MTM component */

	TInt iEntryPointOrdinalNumber;

	/** Version information for the MTM component */

	TVersion iVersion;

	/** Flag that indicates if the MTM can send messages */

	TBool iMessagingCapability;

	/** Flag that indicates if the MTM can handle body text */

	TBool iSendBodyCapability;

	/** Flag that indicates if settings have been made for the 

	MessagingCapability() and SendBodyCapability() flags */	

	TBool iCapabilitiesAvailable;

private:

	HBufC* iFilename;

	};

class CMtmDllInfoArray : public CArrayPtrFlat<CMtmDllInfo>

/** Collects the registration data for concrete MTM components, as encapsulated 

in CMtmDllInfo objects, into an array.

Basic array functionality is provided by the base class CArrayPtrFlat<CMtmDllInfo>.

It is used in the creation of registration data for an MTM group: see CMtmGroupData. 

@publishedAll

@released

*/

	{

public:

	IMPORT_C CMtmDllInfoArray();

	IMPORT_C ~CMtmDllInfoArray();

	IMPORT_C void AddMtmDllInfoL(CMtmDllInfo* aMtmDllInfo);

	};

class TCapabilitySet;

class CMtmGroupData : public CBase

/** Encapsulates the registration data for an MTM group. 

It is used to access and write the registration data file for an MTM group.

@publishedAll

@released

*/

	{

public:

	IMPORT_C static CMtmGroupData* NewL(TUid aMtmTypeUid, TUid aTechnologyTypeUid,CMtmDllInfoArray* aMtmDllInfoArray, const TCapabilitySet& aMtmRequiredCaps);

	IMPORT_C static CMtmGroupData* NewL(const CMtmGroupData& aMtmGroupData);

	IMPORT_C static CMtmGroupData* NewL(RReadStream& aStream);

	IMPORT_C ~CMtmGroupData();

	IMPORT_C void InternalizeL(RReadStream& aStream);

	IMPORT_C void ExternalizeL(RWriteStream& aStream) const;  // not used but as it is exported it has been kept

	IMPORT_C const CMtmDllInfoArray& MtmDllInfoArray() const;

	IMPORT_C const TCapabilitySet& GetMtmRequiredCapabilities() const;

	IMPORT_C TBool operator==(const CMtmGroupData& aMtmGroupData) const;

private:

	CMtmGroupData(TUid aMtmTypeUid, TUid aTechnologyTypeUid, CMtmDllInfoArray* aMtmDllInfoArray, const TCapabilitySet& aMtmRequiredCaps);

	void ConstructL(const CMtmGroupData& aMtmGroupData);

	void ConstructL();

	void AppendMtmDllInfoArrayL(const CMtmDllInfoArray& aMtmDllInfoArray);

	CMtmDllInfoArray& MtmDllInfoArrayPrivate();

	CMtmGroupData(TUid aMtmTypeUid=KNullUid,TUid aTechnologyTypeUid=KNullUid);

	void AppendMtmDllInfoL(CMtmDllInfo* aMtmDllInfo);  // Leaves if second uid wrong

private:

	TUid iMtmTypeUid;

	TUid iTechnologyTypeUid;

	CMtmDllInfoArray* iMtmDllInfoArray;

	TCapabilitySet iMtmRequiredCaps;

	};

class MRegisteredMtmDllObserver

/** 

@publishedAll

@released

*/

	{

public:

	virtual TInt UseMtmGroup(TUid aMtmTypeUid)=0;

	virtual TInt ReleaseMtmGroup(TUid aMtmTypeUid)=0;

	};

//  Real non-derivable class

class CRegisteredMtmDll : public CTimer

/** Allows an MTM object to access registry information about itself.

@publishedAll

@released

*/

	{

public:

	IMPORT_C static CRegisteredMtmDll* NewL(TUid aMtmTypeUid,TUid aTechnologyTypeUid,const CMtmDllInfo& aMtmDllInfo,const TTimeIntervalMicroSeconds32 aTimeoutMicroSeconds32,MRegisteredMtmDllObserver& aRegisteredMtmDllObserver);

	IMPORT_C ~CRegisteredMtmDll();

	IMPORT_C TInt GetLibrary(RFs& aFs,RLibrary& aMtmDllLibrary);   // Increments reference count if successful or returns error 

	IMPORT_C void ReleaseLibrary();                       // Decrements access count

	                                                      // Should be called from destructor of any objects created from the library 

private:

	CRegisteredMtmDll(TUid aMtmTypeUid,TUid aTechnologyTypeUid,const TTimeIntervalMicroSeconds32 aTimeoutMicroSeconds32,MRegisteredMtmDllObserver& aRegisteredMtmDllObserver);

	void ConstructL(const CMtmDllInfo& aMtmDllInfo);

	void LoadLibraryL(RFs& aFs);   

	void RunL();

private:

	TUid iMtmTypeUid;

	TUid iTechnologyTypeUid;

	CMtmDllInfo* iMtmDllInfo;

	RLibrary iMtmDllLibrary;

	TInt iMtmDllRefCount;

	TTimeIntervalMicroSeconds32 iTimeoutMicroSeconds32;

	MRegisteredMtmDllObserver& iRegisteredMtmDllObserver;

	};

class CRegisteredMtmDllArray : public CArrayPtrFlat<CRegisteredMtmDll>

/**

@publishedAll

@released

*/

	{

public:

	IMPORT_C CRegisteredMtmDllArray();

	IMPORT_C ~CRegisteredMtmDllArray();

	IMPORT_C void AddRegisteredMtmDllL(CRegisteredMtmDll* aRegisteredMtmDll);

	};

//  Base class

class CMtmDllRegistry : public CBase

/** Accesses the various MTM component registries. 

The derived classes used by 

clients are CClientMtmRegistry, CMtmUiDataRegistry, and CMtmUiRegistry. It 

provides functions to discover the MTMs registered in such a registry. The 

registered MTMs can be regarded as existing in a list: you can use NumRegisteredMtmDlls() 

to get the number in the list, and MtmTypeUid() to index into it.

@publishedAll

@released

*/

	{

public:

	IMPORT_C ~CMtmDllRegistry();

	IMPORT_C TUid MtmTypeUid(TInt anIndex) const;                                

	inline TBool IsPresent(TUid aMtmTypeUid) const;

	IMPORT_C TUid TechnologyTypeUid(TUid aMtmTypeUid) const;

	IMPORT_C const CMtmDllInfo& RegisteredMtmDllInfo(TUid aMtmTypeUid) const;                                

	IMPORT_C TBool IsInUse(TUid aMtmTypeUid) const;        // returns true if specified DLL in use 

	IMPORT_C TBool IsInUse() const;                        // returns true if any DLL in use 

protected:

	IMPORT_C CMtmDllRegistry(RFs& aFs,TUid aMtmDllTypeUid,TTimeIntervalMicroSeconds32 aTimeoutMicroSeconds32=KMsvDefaultTimeoutMicroSeconds32); 

	IMPORT_C TInt MtmTypeUidToIndex(TUid anMtmTypeUid) const;

	IMPORT_C TInt AddRegisteredMtmDll(TUid aMtmTypeUid,TUid aTechnologyTypeUid,const CMtmDllInfo& aMtmDllInfo,MRegisteredMtmDllObserver& aRegisteredMtmDllObserver); // returns error

	IMPORT_C void RemoveRegisteredMtmDll(TUid aMtmTypeUid);         

	IMPORT_C void RemoveAllRegisteredMtmDlls();                     

private:

	void DoAddRegisteredMtmDllL(TUid aMtmTypeUid,TUid aTechnologyTypeUid,const CMtmDllInfo& aMtmDllInfo,MRegisteredMtmDllObserver& aRegisteredMtmDllObserver); // returns error

protected:

	RFs& iFs;

	TUid iMtmDllTypeUid;  //  Second Uid in all Dlls

	CRegisteredMtmDllArray iRegisteredMtmDllArray;  // Inline CArray, OK because no NewL();

	TTimeIntervalMicroSeconds32 iTimeoutMicroSeconds32;

	};

#endif