// Copyright (c) 1997-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:

//

#ifndef SYMBIAN_ENABLE_SPLIT_HEADERS

#include "shutdownsrv.h"

#else //SYMBIAN_ENABLE_SPLIT_HEADERS

#include "shutdownsess.h"

#endif //SYMBIAN_ENABLE_SPLIT_HEADERS

#include "savenotf.h"

#include "savepriv.h"

#include "shutdowntimer.h"

#include <hal.h>

#include <f32file.h>

#include <bautils.h>

#ifdef SYMBIAN_SSM_GRACEFUL_SHUTDOWN

#include <s32mem.h>

#include <ssm/ssmpatchableconstants.h>

#endif

//The function used to start the profiler, while profiling the shutdown.

#ifdef __PROFILE_SHUTDOWN

_LIT(KProfilerCmd,"start -noui");

void StartProfiler()

	{

	RProcess p;

	TInt r=p.Create(KProfilerName,KProfilerCmd);

	if (r==KErrNone)

		{

		p.Resume();

		p.Close();

		}

	}

#endif

//The function used to unload the profiler, while profiling the shutdown.

#ifdef __PROFILE_SHUTDOWN

void UnloadProfiler()

	{

	TFullName name;

	TFindServer findSvr(KProfilerName);

	Profiler::Unload();

	while(findSvr.Next(name) == KErrNone)

		{

		User::After(1000000);

		findSvr.Find(KProfilerName);

		}

	}

#endif

//

// class CServShutdownServer

//

/**

Standard phase-one factory method for creating CServShutdownServer instances.

@return A newly-constructed shutdown server object.

@leave Some system-wide error codes including KErrNoMemory.

*/

EXPORT_C CServShutdownServer* CServShutdownServer::NewL()

	{ // static

	CServShutdownServer* self=new(ELeave) CServShutdownServer(CActive::EPriorityStandard);

	return self;

	}

/**

Destructor.

Releases CShutdownTimer object if it has been allocated.

*/

EXPORT_C CServShutdownServer::~CServShutdownServer()

	{

	delete iShutdownTimer;

	}

/**

This method iterates through all session instances and checks that all they have pending

requests (which means that all clients have completed their powerdown related processing

and re-registered itself back to the shutdown server).. If that's true (all sessions have

pending requests) and iPowerOff flag is nonzero, the method will call SwitchOff() - the

power will be switched off. 

@see CServShutdownServer::SwitchOff()

@see CServShutdownSession::HasPendingRequest()

*/

EXPORT_C void CServShutdownServer::HandlePowerNotifRequest(const RThread& /*aClient*/)

	{

	// if all sessions have a pending request then they've all saved their data and we can switch off

	TBool completed=ETrue;

	TDblQueIter<CSession2> iter(iSessionIter);

	iter.SetToFirst();

	for (CSession2* session=iter++; session!=NULL; session=iter++)

		{

		if (!static_cast<CServShutdownSession*>(session)->HasPendingRequest())

			{

			completed=EFalse;

			break;

			}

		}

	if (completed && iPowerOff)

		{

		SwitchOff();

		}

	}

/**

This method will call SwitchOff(), if there are no sessions, so - no clients.

If there are registered clients (sessions), the method will call CServShutdownSession::NotifySave()

for each of them.

If the timer object has been initialised, it calculates the shutdown timeout value 

and adds the timer to the active scheduler.

@param aSaveType The action, which will be given to the clients, when calling their 

                 MSaveObserver::SaveL() implementations.

@see CServShutdownServer::SwitchOff()

@see CServShutdownSession::NotifySave()

*/

EXPORT_C void CServShutdownServer::NotifySave(MSaveObserver::TSaveType aSaveType)

	{

	TDblQueIter<CSession2> iter(iSessionIter);

	iter.SetToFirst();

	CSession2* p=iter++;

	if (p==NULL)

		{

		if (iPowerOff)

			{

			SwitchOff();

			}

		}

	else

		{

		TInt numClients = 0;

		iter.SetToFirst();

	    for (CSession2* session=iter++; session!=NULL; session=iter++)

			{

			static_cast<CServShutdownSession*>(session)->NotifySave(aSaveType);

			numClients++;  

			}

		if(iShutdownTimer && !iShutdownTimer->IsActive())

			{

			iShutdownTimer->Start(numClients);

			}

		}

	}

/**

@return Non-zero If the powerdown sequence has been initiated.

*/

EXPORT_C TBool CServShutdownServer::IsPowerOff() const

	{

	return iPowerOff;

	}

/**

Cancels any power off request.

*/

EXPORT_C void CServShutdownServer::CancelPowerOff()

	{

	iPowerOff=EFalse;

	// Cancel the timer.

	if (iShutdownTimer)

		{

		iShutdownTimer->Cancel();

		}

	}

/**

@param aPriority The active object priority.

*/

EXPORT_C CServShutdownServer::CServShutdownServer(TInt aPriority):

	CServer2(aPriority), iShutdownTimer(0)

	{

    }

/**

Completes the server construction by adding the server to the active scheduler and initializing the

CShutdownTimer object if applicable.

@leave See CServer2::StartL() leave error codes.

@see CServer2::StartL()

@panic KErrNotSupported Incorrect patchable variables configuration.

*/

EXPORT_C void CServShutdownServer::ConstructL()

	{

	iShutdownTimer = CShutdownTimer::NewL(*this);

	#ifdef TEST_SHUTDOWN_SERVER 

	StartL(__TEST_SHUTDOWN_SERVER_NAME);

	#else

	StartL(__SHUTDOWN_SERVER_NAME);

	#endif

	}

/**

This method switches off the power using the Power API.

If there is a defined SYSLIBS_TEST macro, the method does nothing.

*/

void CServShutdownServer::DoSwitchOff()

	{

	//Finalize the drives before shutting down

	RFs fs;

	TInt r=fs.Connect(); 

	if (r==KErrNone) 

		{

		//Ignore the error code, as it is not a critical call

		r=fs.FinaliseDrives();

		fs.Close();

		}

#ifdef 	SYSLIBS_TEST 

		// Test mode, only prints debug message.

		RDebug::Printf("CServShutdownServer::SwitchOff() gets run in SYSLIBS_TEST mode.\n");

#else 	//SYSLIBS_TEST

	// restart or standby/shutdown using Power API 

	if (Power::EnableWakeupEvents(iPowerEvent) == KErrNone)

		{

		// Prepare to wake up if power event is standby

		TRequestStatus s;

		Power::RequestWakeupEventNotification(s);

		Power::PowerDown(); // if event is Restart, this function should never return

		User::WaitForRequest(s);

		}

#endif //SYSLIBS_TEST

	} 

void CServShutdownServer::SwitchOff()

	{

	// If the timer has applied, cancel any outstanding requests, 

	// no matter SwitchOff() has been triggered by the timer or the shutdown server.

	if (iShutdownTimer)

		{

		iShutdownTimer->Cancel();

		}

	if (iPowerOff)

		{

#ifdef __PROFILE_SHUTDOWN

		UnloadProfiler();

#endif //__PROFILE_SHUTDOWN

		}

	//SSM shutdown is used only when patchable constant KSsmGracefulShutdown is true 

#ifdef SYMBIAN_SSM_GRACEFUL_SHUTDOWN

	if (iPowerOff && !IsSsmGracefulShutdown())

#else

	if (iPowerOff)

#endif

		{

		//Shutdown using old shutdownsrv, not SSM

		DoSwitchOff();

		}

	iPowerOff = EFalse;

	}

/**

This method creates a new server side session object.

@param aVersion Shutdown server version number.

@return A pointer to the created session object.

@leave KErrNotSupported Unknown shutdown server version

@leave Some system-wide error codes including KErrNoMemory.

*/

CSession2* CServShutdownServer::NewSessionL(const TVersion& aVersion,const RMessage2& /*aMessage*/) const

	{

	TVersion v(KShutdownMajorVN,KShutdownMinorVN,KShutdownBuildVN);

	if (!User::QueryVersionSupported(v,aVersion))

		User::Leave(KErrNotSupported);

	CSession2* pSession = CServShutdownSession::NewL();

	return pSession;

	}

/**

This method has to be called, when the registered clients have to be notified that a 

particular action has to be done, such as MSaveObserver::ESaveData, MSaveObserver::ESaveAll, 

MSaveObserver::EReleaseRAM,...

If this is a beginning of a powerdown sequence, the method will store the locales and the HAL

properties.

If the requested action is not MSaveObserver::ESaveNone, the method will call 

CServShutdownServer::NotifySave().

@param aAction The type of the requested action

@param aPowerOff If it is non-zero, this is the beginning of a powerdown sequence.

@param aEvent The type of the powerdown event (power off or restart)

@leave KErrNotSupported Leaves if aEvent is invalid  

@see CServShutdownServer::NotifySave()

@see TPowerState

*/

EXPORT_C void CServShutdownServer::HandleShutdownEventL(MSaveObserver::TSaveType aAction,TBool aPowerOff, TPowerState aEvent)

	{

	if( aPowerOff )

		{

		__ASSERT_ALWAYS((aEvent>EPwActive)&&(aEvent<EPwLimit), User::Leave(KErrNotSupported));

#ifdef __PROFILE_SHUTDOWN

		StartProfiler();

#endif

#ifdef SYMBIAN_SSM_GRACEFUL_SHUTDOWN

		if (!IsSsmGracefulShutdown())

			{

			// Save the state of the HAL

			// The state of the locale should be saved before the HAL

			BaflUtils::PersistLocale();

			BaflUtils::PersistHAL();

			}

#else

		// Save the state of the HAL

		// The state of the locale should be saved before the HAL

		BaflUtils::PersistLocale();

		BaflUtils::PersistHAL();

#endif

		}

	iPowerOff=aPowerOff;

	iPowerEvent = aEvent;

	// add LAF setting for powering down screen (& keyboard??)

	if (aAction != MSaveObserver::ESaveNone)

		{

		NotifySave(aAction);

		}

	}

/**

This method returns an information about the shutdown status.

@param aPowerOff An output parameter, where iPowerOff value will be stored. 

                 It will be non-zero, if a powerdown sequence has been initiated.

@param aAllSessionsHavePendingRequest An output parameter. It will be non-zero, if

                 all clients has pending requests.

*/

EXPORT_C void CServShutdownServer::GetShutdownState(TBool& aPowerOff, TBool& aAllSessionsHavePendingRequest) const

	{

	aAllSessionsHavePendingRequest = AllSessionsHavePendingRequest();

	aPowerOff = iPowerOff;

	}

/**

This method creates an array of CArrayFix<TThreadId> type and appends to it the

thread id-s of the all registered clients.

The created CArrayFix<TThreadId> instance will be pushed on the cleanup stack.

@return A pointer to a CArrayFix<TThreadId> array with the client thread id-s.

@leave Some system-wide error codes including KErrNoMemory.

*/

EXPORT_C CArrayFix<TThreadId>* CServShutdownServer::ClientArrayLC()

	{

	CArrayFix<TThreadId>* clientArray=new(ELeave) CArrayFixFlat<TThreadId>(2);

	CleanupStack::PushL(clientArray);

	TDblQueIter<CSession2> iter(iSessionIter);

	iter.SetToFirst();

	TKeyArrayFix key(0,ECmpTInt);

    for (CSession2* session=iter++; session!=NULL; session=iter++)

		{

		TThreadId id=static_cast<CServShutdownSession*>(session)->ClientThreadId();

		TInt pos;

		if (clientArray->Find(id,key,pos)!=0)

			{

			clientArray->AppendL(id);

			}

		}

	return clientArray;

	}

#ifdef SYMBIAN_SSM_GRACEFUL_SHUTDOWN

/**

This method will write thread id-s of all clients that are registered for shutdown notification in to a streem.

@param aMessage consists of buffer, clientside array count and server side array count 

*/

void CServShutdownServer::ClientArrayL(const RMessage2& aMessage)

	{

	const TInt arrayItemCount = ClientArrayCount();

	//write all registered client array in a buffer only when client side 

	//array count is equal to server side array count

	if(arrayItemCount == aMessage.Int1())

		{

		const TInt sizeRequired = arrayItemCount * sizeof(TThreadId);

		CBufFlat* const buf=CBufFlat::NewL(sizeRequired);

		CleanupStack::PushL(buf);

		RBufWriteStream writeStream(*buf);

		CleanupClosePushL(writeStream); 

		TDblQueIter<CSession2> iter(iSessionIter);

		iter.SetToFirst();

    	for (CSession2* session=iter++; session!=NULL; session=iter++)

			{

			TThreadId id=static_cast<CServShutdownSession*>(session)->ClientThreadId();

			//Thread id (which is TUint64) is broken in to two TUint32 and written as RWriteStream doesnt 

			//support TUint64. Client API will recreate TUint64 value from these TUint32 values.

			if(id.Id())

				{

				//RWriteStream there is no API to writes a TUint64 value as a 64 bit value to stream

				writeStream.WriteUint32L(I64HIGH(id.Id()));

				writeStream.WriteUint32L(I64LOW(id.Id()));

				}

			}

		writeStream.CommitL();

		aMessage.WriteL(0, buf->Ptr(0));

		CleanupStack::PopAndDestroy(2,buf);	//writeStream, buf 

		}

	else

		{

		aMessage.Write(2, TPckg<TInt>(arrayItemCount));

		}	

	}

/**

This method will return the number of client that are registered for Shutdown notification with ShutDown server.

@return Number of registered clients.

*/

TInt CServShutdownServer::ClientArrayCount()

	{

	TDblQueIter<CSession2> iter(iSessionIter);

	iter.SetToFirst();

	TInt count =0;

    for (CSession2* session=iter++; session!=NULL; session=iter++)

		{

		TThreadId id=static_cast<CServShutdownSession*>(session)->ClientThreadId();

		//Clients which are not registered for notification will not have RMessage in the session and hence 

		//thread id will be NULL(e.g.CLafShutdownEventObserverAdaptor). Avoid such clients. 		

		if(id.Id())

			{

			++count;

			}

		}

	return count;

	}

#endif	//SYMBIAN_SSM_GRACEFUL_SHUTDOWN	

/**

@return Non-zero, if all registered clients have pending requests.

*/

TBool CServShutdownServer::AllSessionsHavePendingRequest() const

	{

	TBool ret=ETrue;

	TDblQueIter<CSession2> iter(iSessionIter);

	iter.SetToFirst();

	for (CSession2* session=iter++; session!=NULL; session=iter++)

		{

		const CServShutdownSession* mySession=static_cast<CServShutdownSession*>(session);

		if (!mySession->HasPendingRequest())

			{

			ret=EFalse;

			break;

			}

		}

	return ret;

	}

/**

@param aId Client's thread id.

@return Non-zero if the client with this thread id has no pending request.

*/

EXPORT_C TBool CServShutdownServer::IsClientHung(TThreadId aId) const

	{

	TBool ret=EFalse;

	TDblQueIter<CSession2> iter(iSessionIter);

	iter.SetToFirst();

	for (CSession2* session=iter++; session!=NULL; session=iter++)

		{

		const CServShutdownSession* mySession=static_cast<CServShutdownSession*>(session);

		if (mySession->ClientThreadId()==aId)

			{

			if (!mySession->HasPendingRequest())

				{

				ret=ETrue;

				break;

				}

			}

		}

	return ret;

	}

//

// class CServShutdownSession

//

/**

*/

EXPORT_C CServShutdownSession::CServShutdownSession()

	: CSession2(),

	iCurrentEvent(-1), iOutstandingEvent(-1)

	{}

/**

*/

EXPORT_C CServShutdownSession::~CServShutdownSession()

	{

	}

/**

Standard phase-one factor method for creating CServShutdownSession instances.

@return A pointer to the created CServShutdownSession instance.

@leave KErrNoMemory Not enough memory to complete the operation.

*/

CServShutdownSession* CServShutdownSession::NewL()

	{

	return new (ELeave) CServShutdownSession;

	}

/**

@return Non-zero, if the client has a pending request.

*/

TBool CServShutdownSession::HasPendingRequest() const

	{

	return !iPtr.IsNull();

	}

/**

This method will complete the pending asychronous client request, effectivelly notifying it

about the action, which the client has to do.

@param aSaveType The type of the requested save action.

*/

void CServShutdownSession::NotifySave(MSaveObserver::TSaveType aSaveType)

	{

	const TInt saveType=(TInt)aSaveType;

	if (HasPendingRequest())

		{

		iPtr.Complete(saveType);

		iCurrentEvent=saveType;

		}

	else