--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/commsprocess/commsrootserverconfig/configurator/src/c32start.h	Thu Dec 17 09:22:25 2009 +0200
@@ -0,0 +1,302 @@
+// Copyright (c) 2003-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:
+// Defines the reference Comms Configurator
+//
+//
+
+/**
+ @file
+ @internalTechnology
+*/
+
+#if !defined(__C32START_H__)
+#define __C32START_H__
+#include <c32root.h>
+#include "c32cmi.h"
+#include "c32startshared.h"
+#include <e32property.h>
+#include <domainmember.h>
+#include <comms-infras/commsdebugutility.h>
+/** Subsystem name, used for logging.
+*/
+__FLOG_STMT(_LIT8(KSubsys,"C32Start");)
+
+/** Component name, used for logging.
+*/
+__FLOG_STMT(_LIT8(KComponent,"Events");)
+
+/** Name of the application.
+*/
+_LIT(KC32StartName, "C32Start");
+
+/** Name of the Rootserver executable.
+*/
+_LIT(KRootServerExe, "c32exe.exe");
+
+/** Default priority of the Rootserver executeable and
+thus the priority Comms Process.
+*/
+const TProcessPriority KRootServerDefaultPriority=EPriorityHigh;
+
+class CCommsProcessStarter;
+class CBindingRef;
+
+/** Type of module.
+*/
+enum TModuleType {
+     /** A module which can only be at the top end of a hierarchical binding.
+     */
+     EServerModule,
+     /** Standard Comms Provider Module.
+     */
+     EProviderModule
+     };
+
+/** State of module.
+*/
+enum TModuleState {
+     /** The module is not currently loaded.
+     */
+     ENotLoaded,
+     /** The module is currently being loaded by the Rootserver.
+     */
+     ELoading,
+     /** The module has been loaded and is running.
+     */
+     ELoaded,
+     /** The module could not be loaded by the Rootserver.
+     */
+     ELoadFailed
+     /** The module is being currently Unloaded by the root server
+     */
+     ,EUnLoading
+     };
+
+/** State of a binding
+*/
+enum TBindingState {
+     /** The binding is not currently active.
+     */
+     ENotBound,
+     /** The binding is being set up by the Rootserver.
+     */
+     EBinding,
+     /** The binding has been created and is active.
+     */
+     EBound,
+     /** The Rootserver was unable to set up the binding.
+     */
+     EBindFailed
+     /** Either 'end' module of the binding has failed to load, result being binding won't start
+     */
+     ,EBindInComplete
+     };
+
+class CModuleRef : public CActive
+/** An instance of this object represents one module to be-, being- or which is
+loaded by the RootServer. The public inheritance of CActive
+*/
+	{
+public:
+	static CModuleRef* NewLC(RRootServ& aRootServer, CCommsProcessStarter& aCommsProcess, C32CmiData& aCModuleCMIData);
+	~CModuleRef();
+	const inline TCFGroupNameF& GroupName() const;
+	TModuleState State() const		{ return iState; }
+	const TCFModuleNameF& Name() const		{ return static_cast<const TCFModuleNameF&>(iParams.iParams.iName); }
+	TUint32 ScaledStartupState() const	{ return iScaledStartupState; }
+	TBool SystemCritical() const	{ return iSystemCritical; }
+	TBool SystemCriticalAfterInit() const {return iSystemCriticalAfterInit;}
+
+	void Load();
+	TBool Resurrect();
+	TBool operator==(const TCFModuleNameF& aModuleName) const;
+	static TInt CompareScaledStartupState(const CModuleRef& aModule1, const CModuleRef& aModule2);
+
+	inline HBufC8* GetIniData() const;
+	inline TBool IsOnDemand() const;
+	inline void SetRMessage(const RMessage2& aMessage);
+	const RMessage2& Message() const { return iRMessage; }
+	void MaybeCompleteMessage(TInt aReturnValue);
+	void UnLoadCpm(const TCFModuleNameF& aModuleName,TRSUnLoadType aType);
+	void CancelUnLoadCpm(const TCFModuleNameF& aModuleName);
+	void CancelLoadCpm(const TCFModuleNameF& aModuleName);
+	void UnBindCpm();
+	inline void IncrementBindings() { ++iNumBindings; }
+	inline void IncrementCompletedBindings() { ++iCompletedBindings; }
+	void UpdateCompletedBinding(TInt aReturnvalue);
+	inline void SetHasBindings() { iHasBinding = ETrue; }
+
+protected:
+	void DoCancel();
+	void RunL();
+
+private:
+	CModuleRef(RRootServ& aRootServer, CCommsProcessStarter& aCommsProcess);
+	void ConstructL(C32CmiData& aCModuleCMIData);
+
+private:
+	RPointerArray<CBindingRef> iBindings;
+	TUint32 iScaledStartupState;
+	TUint iNumBindings;
+	RRootServ& iRootServer;
+	CCommsProcessStarter& iCommsProcess;
+	TModuleState iState;
+	TModuleType iType;
+	HBufC8* iIniData;
+	TRSStartModuleParams iParams;
+	TBool iSystemCritical;
+	TBool iSystemCriticalAfterInit;
+	TConfiguratorModuleParams iConfigParams;
+	RMessage2 iRMessage;
+	TUint iCompletedBindings; 	// when iNumBindings == iCompletedBindings, Message is completed
+	TBool iHasBinding;
+	};
+
+class CBindingRef : public CActive
+/** An instance of this object represents one binding to be-, being- or which is
+bound by the RootServer.
+*/
+	{
+public:
+	CBindingRef(RRootServ& aRootServer, CCommsProcessStarter& aStartConfigProcess,
+				const TRSBindingInfo& aBinding);
+	~CBindingRef();
+	inline void SetState(TBindingState aState);
+	void UpdateCompletedBinding(TInt aReturnValue);
+	const TCFSubModuleAddress& FromModule() const;
+	const TCFSubModuleAddress& ToModule() const;
+	TInt BindIfReady();
+protected:
+	void DoCancel();
+	void RunL();
+
+private:
+	CBindingRef();
+	void ConstructL(RRootServ& aRootServer, CCommsProcessStarter& aStartConfigProcess,
+					TRSBindingInfo& aBinding);
+private:
+	RRootServ& iRootServer;
+	CCommsProcessStarter& iStartProcess;
+	TBindingState iState;
+	TRSBindingInfo iBindInfo;
+	};
+
+class CDeathWatcher : public CActive
+/** Observes the death publication and notifies the CommsProcessStarter
+*/
+	{
+public:
+	static CDeathWatcher* NewL(CCommsProcessStarter& aStartConfigProcess);
+	~CDeathWatcher();
+protected:
+	void DoCancel();
+	void RunL();
+private:
+	CDeathWatcher(CCommsProcessStarter& aStartConfigProcess);
+	void Construct();
+private:
+	CCommsProcessStarter& iStartProcess;
+	RProperty iDeathProperty;
+	};
+
+class CStartupStateObserver : public CDmDomain
+/** Observes the Generic Start-up Architecture state transitions, if the GSA is available. The
+need to cope with its absence prevents the more obvious approach of simply deriving
+CCommsProcessStarter from CDmDomain.
+*/
+	{
+public:
+	static CStartupStateObserver* NewL(CCommsProcessStarter& aStarter);
+	~CStartupStateObserver();
+protected:
+	void RunL();
+private:
+	CStartupStateObserver(CCommsProcessStarter& aStarter);
+private:
+	CCommsProcessStarter& iStarter;
+	};
+
+	class CRsConfiguratorServer;
+class CCommsProcessStarter : public CBase
+/** The main class orchestrating loading and binding of the Comms Provider
+Modules as specified by the .CMI files.
+*/
+	{
+public:
+	enum TModuleState { ELoadingModule, EListeningforDeath };
+
+	static CCommsProcessStarter* NewLC(RRootServ& aRootServer, RProperty& aProperty);
+	~CCommsProcessStarter();
+	void ReadConfigAndStartAllL(const TDesC& aCMISuppressions);
+	CModuleRef* GetModule(const TCFModuleNameF& aModule ) const;
+	void NotifyLoadCompletion(CModuleRef& aModule);
+	void NotifyBindCompletion(CBindingRef& aBinding);
+	void NotifySuddenDeath(TInt aDeathCount, TInt aDeathStatus);
+	void NotifyStartupStateChange();
+	TBool ConfigurationComplete() const;
+	TBool InTestMode() const
+		{
+		return iTestMode;
+		}
+    void PrintSummary();
+	void LoadOnDemandModule(CModuleRef& aModule);
+    RPointerArray<CModuleRef>& GetModulesList()
+		{
+		return iModules;
+		}
+	RPointerArray<CBindingRef>& GetBindingList()
+		{
+		return iBindings;
+		}
+protected:
+	TInt UnloadedModuleIdx() const
+		{
+		return iUnloadedModuleIdx;
+		}
+private:
+	CCommsProcessStarter(RRootServ& aRootServer, RProperty& aProperty);
+	TBool SplitInt(TPtrC8 &aDes, TInt& aValue) const;
+    TBool SplitUint(TPtrC8 &aDes, TUint& aValue) const;
+	void ContinueLoading();
+    void Shutdown();
+
+private:
+	TInt iUnloadedModuleIdx;
+	TInt iModulesLoading;
+	TInt iModulesLoaded;
+	RRootServ& iRootServer;
+	RPointerArray<CModuleRef> iModules;
+	RPointerArray<CBindingRef> iBindings;
+	CDeathWatcher* iDeathWatcher;
+	TInt iDeathCount;
+	RProperty& iConfigurationProperty;
+	enum TPublicationLevel { EUnpublished = 0, EPublishedCore, EPublishedComplete };
+	TPublicationLevel iPublicationLevel;
+	// Because of monitoring startup state changes we can come through twice in the "final" state,
+	// but only want one summary dump (avoid deluging the user with apparent ambiguity)
+	__FLOG_STMT(TBool iSummaryAlreadyPrinted; )
+	TUint iBindCount;
+#ifndef SYMBIAN_ZERO_COPY_NETWORKING
+ 	TInt iInitMBufPoolSize;
+  	TInt iMaxMBufPoolSize;
+#endif
+	TBool iTestMode;
+	CStartupStateObserver* iStartupStateObserver;
+	TBool iNeedToAckLastState;
+	TUint32 iScaledStartupState;
+	TBool iFinishedloading;
+	CRsConfiguratorServer* iConfiguratorServer;
+	};
+#include "c32start.inl"
+#endif