// Copyright (c) 2005-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:
// cwatcherssastartupmgr.cpp
//

#include "cwatcherssastartupmgr.h"

#include <ecom/ecom.h>
#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS 
#include "cwatcher.h"
#endif

static void CleanUpEComInfoArray(TAny* aInfoArray);

/** 
Factory function to create a new instance of the CWatcherSSAStartupMgr
SSA start-up manager.

The SSA start-up manager registers with the Domain Manager for the
domain KAppServicesDomain3 of the KDmHierarchyIdStartup.

@return
A new CWatcherSSAStartupMgr object.
*/

CWatcherSSAStartupMgr* CWatcherSSAStartupMgr::NewL()
	{
#ifndef SYMBIAN_SYSTEM_STATE_MANAGEMENT
	CWatcherSSAStartupMgr* self = new (ELeave) CWatcherSSAStartupMgr(KDmHierarchyIdStartup, KAppServicesDomain3);
#else
	CWatcherSSAStartupMgr* self = new (ELeave) CWatcherSSAStartupMgr(KDmHierarchyIdStartup, KSM2AppServicesDomain3);
#endif
	CleanupStack::PushL(self);
	self->ConstructL();
	CleanupStack::Pop(self);
	return self;
	}
	 

/**
Constructor of CWatcherSSAStartupMgr

@param aHierarchyId
The Id of the domain hierarchy to connect to
@param aDomainId
The Id of the domain to connect to
*/
CWatcherSSAStartupMgr::CWatcherSSAStartupMgr(TDmHierarchyId aHierarchyId, TDmDomainId aDomainId)
: CDmDomain(aHierarchyId,aDomainId), iCurrentStartupState(EStartupStateUndefined)
	{
	}
	 

/** 
Destructor
*/
CWatcherSSAStartupMgr::~CWatcherSSAStartupMgr()
	{
	Cancel();
	iWatcherList.ResetAndDestroy();
	delete iLog,
	iFs.Close();
	REComSession::FinalClose();
	}
	

/** 
Second-stage constructor.

This method indicates how the CWatcherSSAStartupMgr interacts with the 
Domain manager to keep aware of the startup state change.
*/
void CWatcherSSAStartupMgr::ConstructL()
	{
	
	// Get ready to log in \logs\watcher\watcher.txt
	User::LeaveIfError(iFs.Connect());
	iLog = CWatcherLog::NewL(iFs);
	
	// Connect to the Domain Manager

	TRAPD( err, CDmDomain::ConstructL() );

	if( err != KErrNone )
		{
		// The connection to the Domain Manager cannot be established,
		// we perform a full initialisation
		iLog->Printf(_L("CWatcherSSAStartupMgr::InitialiseL(): cannot connect to the Domain Manager, performing full init."));
		PerformFullInitL();
		iCurrentStartupState = EStartupStateNonCritical;
		return;
		}
			
	// Get the start-up state from the Domain Manager.
	TDmDomainState state = GetState();
	
	// Either something wrong with the Domain Manager or final state is reached
	if( state <= EStartupStateUndefined || state >= EStartupStateNonCritical )
		{
		// We perform a full initialisation
		iLog->Printf(_L("CWatcherSSAStartupMgr::InitialiseL(): wrong state, performing full init."));
		PerformFullInitL();
		iCurrentStartupState = EStartupStateNonCritical;
		return;
		}
			
	// Perform the initialisation for this state
	TBool notFinished = ProcessSSAEventL((TStartupStateIdentifier)state);
	if( notFinished )
		{
		// Still need to get the state from Domain Manager.
		RequestTransitionNotification();
		}
	}


/**
Executed when the startup state change is done, it does the same thing 
as the method InitialiseL().
*/
void CWatcherSSAStartupMgr::RunL()
	{
	// Leave if our previous request to be notified a state change has
	// returned an error and let RunError handle this.
	User::LeaveIfError(iStatus.Int()); 

	// Get the start-up state from the Domain Manager.
	TDmDomainState state = GetState();
	
	//If the state is EStartupStateUndefined there must be something wrong.
	if( state == EStartupStateUndefined ) 
		{
		AcknowledgeLastState(KErrBadHandle);
		User::Leave(KErrBadHandle); //RunError will handle this.
		}
	
	// Perform the initialisation for this state
	TBool notFinished = ProcessSSAEventL((TStartupStateIdentifier)state);
	
	// Tell domain manager that we have processed the last state change
	AcknowledgeLastState(KErrNone);
	
	if( notFinished )
		{
		RequestTransitionNotification();
		}
	}


/**
Handle the error if RunL leaves. Here, we just do a full initialisation.

@param aError 
Error code generated by the RunL(), not used here.
@return
KErrNone to avoid CActiveScheduler to panic. 
*/	
TInt CWatcherSSAStartupMgr::RunError(TInt /*aError*/)
	{
	iLog->Printf(_L("CWatcherSSAStartupMgr::RunL() leaves, do a full initialisation"));
	TRAP_IGNORE(DoRunErrorL());
	return KErrNone;
	}

	
/**
Leaving method trapped by RunError

If RunError has been called that means RunL has left.
Because watcher.exe is started in the critical-dynamic state it is quite
likely the critical init has been done already (in ConstructL) when RunL
is called so we just want to do the non-critical part of the init.
We check our internal state for confirmation and run the non-critical init.
If our internal state is EStartupStateCriticalDynamic or before we
perform a full init.
*/	
void CWatcherSSAStartupMgr::DoRunErrorL()
	{
	if ( iCurrentStartupState > EStartupStateCriticalDynamic )
		{
		PerformNonCriticalInitL();
		}
	else
		{	
		PerformFullInitL();
		}
	}

	
/**
Perform the initialisation for a particular state.

@param aKnownState 
The startup state passed into the MStartupStateObserver objects
@return
Whether or not a transition notification should be requested
*/	
TBool CWatcherSSAStartupMgr::ProcessSSAEventL(TStartupStateIdentifier aKnownState)
	{
	TBool notFinished = ETrue;
	
	if ( aKnownState != iCurrentStartupState )
		{
		
		//if we have not performed critical dynamic initialisation and receive a 
		//notification for it or a state that comes after 

		if(iCurrentStartupState<EStartupStateCriticalDynamic &&
		   aKnownState >= EStartupStateCriticalDynamic)
			{
			PerformCriticalInitL();
			iCurrentStartupState = EStartupStateCriticalDynamic;
			}
		
		//if we have not performed non-critical initialisation and receive a notification
		//for it or a state that comes after 

		if(iCurrentStartupState<EStartupStateNonCritical &&
		   aKnownState >= EStartupStateNonCritical)
			{
			PerformNonCriticalInitL();
			notFinished = EFalse;
			iCurrentStartupState = EStartupStateNonCritical;
			}
		
		}
		
	return notFinished;
	}


/**
Perform a full initialisation = start all the watchers
*/	
void CWatcherSSAStartupMgr::PerformFullInitL()
	{
	// Watchers for the critical-dynamic state:
	PerformCriticalInitL();
	// Watchers for the non-critical state:
	PerformNonCriticalInitL();
	}


/**
Perform initialisation for the 'critical-dynamic' start-up state
*/	
void CWatcherSSAStartupMgr::PerformCriticalInitL()
	{
	StartWatchersL(KUidEComWatcher);             // Legacy watchers
	StartWatchersL(KUidMsgCriticalWatchers); 
	}

/**
Perform initialisation for the 'non-critical' start-up state
*/	
void CWatcherSSAStartupMgr::PerformNonCriticalInitL()
	{
	StartWatchersL(KUidMsgNonCriticalWatchers);
	}

/**
Starts all the watchers implementing the specified ECom interface

@param aEComInterface 
The ECom interface of the watchers to be started
*/	
void CWatcherSSAStartupMgr::StartWatchersL(TUid aEComInterface)
	{
	RImplInfoPtrArray watcherInfoArray;
	TCleanupItem cleanup(CleanUpEComInfoArray, &watcherInfoArray);
	CleanupStack::PushL(cleanup);
	TEComResolverParams eComResolverParams;

	// Get the list of active watcher implementations.
	// (list only watcher implementations that are ROM, as it would be 
	// insecure to load RAM implementations)
	REComSession::ListImplementationsL(	aEComInterface, eComResolverParams, 
										KRomOnlyResolverUid, watcherInfoArray);

	const TInt count = watcherInfoArray.Count();

	#ifdef __WINS__
		_LIT(KLaunchingWatcher, "Launching ECOM watcher %S");
	#endif
	
	for( TInt ii=0; ii < count; ++ii )
		{
		CImplementationInformation* info = watcherInfoArray[ii];
		
		// Log details of the watcher
		const TDesC& name = info->DisplayName();
		#ifdef __WINS__
			iLog->Printf(KLaunchingWatcher, &name);
		#endif
	
		// Create the watcher launcher
		CWatcherLauncher* launcher = CWatcherLauncher::NewL(name, 
															info->ImplementationUid(), 
															iFs, 
															*iLog);
		CleanupStack::PushL(launcher);
		iWatcherList.AppendL(launcher);
		CleanupStack::Pop(launcher);
		
		}
	CleanupStack::PopAndDestroy(&watcherInfoArray);
	}


// CleanupEComArray function is used for cleanup support 
// of locally declared arrays.
void CleanUpEComInfoArray(TAny* aInfoArray)
	{
	RImplInfoPtrArray* infoArray = (static_cast<RImplInfoPtrArray*>(aInfoArray));
	infoArray->ResetAndDestroy();
	infoArray->Close();
	}