--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/messagingfw/msgsrvnstore/server/inc/MSVREG.H Mon Jan 18 20:36:02 2010 +0200
@@ -0,0 +1,267 @@
+// 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);
+ inline TPtrC HumanReadableName() const;
+ 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
+ inline TUid MtmTypeUid() const;
+ inline TUid TechnologyTypeUid() const;
+ 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();
+
+ inline TUid MtmTypeUid() const;
+ inline TUid TechnologyTypeUid() const;
+ inline const CMtmDllInfo& MtmDllInfo() const;
+
+ inline TInt MtmDllRefCount() const;
+
+ 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();
+
+ inline TInt NumRegisteredMtmDlls() const;
+ 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;
+ };
+
+
+#include <msvreg.inl>
+
+#endif