// 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:

//

#include "EIKBAKSV.H"

#include <babackup.h>

#include <basched.h>

#include <e32base.h>

#include <w32std.h>

#include <apaid.h>

#include <apacmdln.h>

#include <apgcli.h>

#include <apgtask.h>

#include <apgwgnam.h>

#include <coemain.h> // for TActivePriority only

#include <uikon/patchdata.h>

class RFindLib : public RLibrary

	{

public:

	inline TInt Open(const TFindLibrary& aFind,TOwnerType aType=EOwnerProcess);

	};

inline TInt RFindLib::Open(const TFindLibrary& aFind,TOwnerType aType)

	{return(RHandleBase::Open(aFind,aType));}

//

// class CEikServBackupServer

//

/**

Creates a CEikServBackupServer.  

Static factory function.

Does not call ConstructL  (BUT ConstructL is not EXPORTed !?!?)

@return Instantiated object

@publishedAll

@released

*/

EXPORT_C CEikServBackupServer* CEikServBackupServer::NewL()

	{ // static

	CEikServBackupServer* self=new(ELeave) CEikServBackupServer(EActivePriorityIpcEventsHigh);

	return self;

	}

/**

Constructor

@internalComponent

*/

CEikServBackupServer::CEikServBackupServer(TInt aPriority)

	: CBaBackupServer(aPriority)

	{}

/**

2nd phase constructor.  Opens connection to Window Server

Framework function

@see CBaBackupServer::ConstructL()

*/

void CEikServBackupServer::ConstructL()

	{

	CBaBackupServer::ConstructL();

	}

/**

Destructor

*/

CEikServBackupServer::~CEikServBackupServer()

	{

	delete iAppStarter;

	}

/**

Framework function

@see CBaBackupServer::IsOtherClientBusy(TUint32 aUniqueClientId)

*/

TBool CEikServBackupServer::IsOtherClientBusy(TUint32 aUniqueClientId) const

	{

	return (iAppStarter || CBaBackupServer::IsOtherClientBusy(aUniqueClientId));

	}

/**

Framework function

@see CBaBackupServer::CompleteClosingFiles(CArrayFix<CBaServBackupSession::TClosedFile>* aClosedFiles)

*/

void CEikServBackupServer::CompleteClosingFiles(CArrayFix<CBaServBackupSession::TClosedFile>* aClosedFiles)

	{

	delete iAppStarter;

	iAppStarter=NULL;

	TRAPD(err,iAppStarter=CAppStarter::NewL(*this,aClosedFiles));

	if (err!=KErrNone)

		{

		SetBusy(0);

		}

	}

/**

Framework function

@see CServer2:;::NewSessionL(const TVersion &aVersion, const RMessage2&)

*/

CSession2* CEikServBackupServer::NewSessionL(const TVersion &aVersion, const RMessage2&) const

	{

	const TVersion version(KBakServMajorVN,KBakServMinorVN,KBakServBuildVN);

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

		{

		User::Leave(KErrNotSupported);

		}

	return CEikServBackupSession::NewL();

	}

/**

Framework Function

@see MAppStarterObserver::HandleAppsStarted()

*/

void CEikServBackupServer::HandleAppsStarted()

	{

	SetBusy(0);

	delete iAppStarter;

	iAppStarter=NULL;

	}

//

// class CAppWatcher

//

/**

Static factory function

@param aThreadId - Of application to watch

@param aAppShutter - Called when watcher (this) sees app close.

@param aClosedFile - file that will need restarting

@return Instantiated and constructed object

@internalTechnology

*/

CAppWatcher* CAppWatcher::NewL(TThreadId aThreadId,CAppShutter& aAppShutter,

								const CEikServBackupSession::TClosedFile& aClosedFile)

	{ // static

	CAppWatcher* self=new(ELeave) CAppWatcher(aAppShutter,aClosedFile);

	CleanupStack::PushL(self);

	self->ConstructL(aThreadId);

	CleanupStack::Pop(); // self

	return self;

	}

/**

Destructor

*/

CAppWatcher::~CAppWatcher()

	{

	Cancel();

	iThread.Close();

	}

/**

@return Copy of the closed file

@internalTechnology

@see CEikServBackupSession::TClosedFile

*/

const CEikServBackupSession::TClosedFile& CAppWatcher::Info() const

	{

	return iClosedFile;

	}

/** 

Private constructor

@param aAppShutter - called when watcher (this) sees app close.

@param aClosedFile- the file that will need restarting

@internalComponent

*/

CAppWatcher::CAppWatcher(CAppShutter& aAppShutter,const CEikServBackupSession::TClosedFile& aClosedFile)

	: CActive(CActive::EPriorityStandard), iAppShutter(aAppShutter), iClosedFile(aClosedFile)

	{}

/**

Second phase constructor

Logs on to thread to wait for application to close.

@param aThreadId

@internalComponent

*/

void CAppWatcher::ConstructL(TThreadId aThreadId)

	{

	CActiveScheduler::Add(this);

	iStatus=KRequestPending;

	SetActive();

	User::LeaveIfError(iThread.Open(aThreadId));

	iThread.Logon(iStatus);

	}

/**

CActive framework function

Cancels thread logon

*/

void CAppWatcher::DoCancel()

	{

	if (iThread.Id() && iStatus==KRequestPending)

		{

		iThread.LogonCancel(iStatus);

		}

	}

/**

CActive framework function

Handles application closure. Calls App shutter

*/

void CAppWatcher::RunL()

	{

	iAppShutter.HandleAppClosedL(iClosedFile);

	}

/**

CActive framework function

*/

TInt CAppWatcher::RunError(TInt /*aError*/)

	{

	delete this;

	return KErrNone;

	}

//

// class CAppShutter

//

/**

@internalComponent

*/

CAppShutter::CShutterTimer* CAppShutter::CShutterTimer::NewL(TInt aPriority)

	{ // static

	CShutterTimer* self=new(ELeave) CShutterTimer(aPriority);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(); // self

	CActiveScheduler::Add(self);

	return self;

	}

/**

@internalComponent

*/

TInt CAppShutter::CShutterTimer::RunError(TInt aError)

	{

	if (aError==KLeaveWithoutAlert)

		{

		return KErrNone;

		}

	return aError;

	}

/**

@internalComponent

*/

CAppShutter::CShutterTimer::CShutterTimer(TInt aPriority)

	: CPeriodic(aPriority)

	{}

/**

@internalTechnology

*/

CAppShutter* CAppShutter::StartL(MAppShutterObserver& aObserver,

				 CArrayFix<CEikServBackupSession::TClosedFile>& aClosedFiles,

				 CBaBackupServer& aBackupServer)

	{ // static

	CAppShutter* self=new(ELeave) CAppShutter(aObserver,aClosedFiles, aBackupServer);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(); // self

	return self;

	}

/**

@internalComponent

*/

CAppShutter::~CAppShutter()

	{

	if (iAppWatchers)

		{

		iAppWatchers->ResetAndDestroy();

		delete iAppWatchers;

		}

	delete iTimer;

	delete iWgIds;

	iWsSession.Close();

	}

/**

@internalComponent

*/

CAppShutter::CAppShutter(MAppShutterObserver& aObserver,

			 CArrayFix<CEikServBackupSession::TClosedFile>& aClosedFiles,

			 CBaBackupServer& aBackupServer) 

			: iObserver(aObserver),iClosedFiles(aClosedFiles), iBackupServer(aBackupServer)

	{}

/**

@internalComponent

*/

void CAppShutter::ConstructL()

	{

	iTimer=CShutterTimer::NewL(CActive::EPriorityStandard);

	iTimer->Start(0,1,TCallBack(TimerCallBackL,this));

	iAppWatchers=new(ELeave) CArrayPtrFlat<CAppWatcher>(1);

	User::LeaveIfError(iWsSession.Connect());

	const TInt wgCount=iWsSession.NumWindowGroups(0);

	iWgIds=new(ELeave) RArray<RWsSession::TWindowGroupChainInfo>(wgCount);

	User::LeaveIfError(iWsSession.WindowGroupList(0,iWgIds));

	}

/**

@internalTechnology

*/

void CAppShutter::HandleAppClosedL(const CEikServBackupSession::TClosedFile& aClosedFile)

	{

	const TInt count=iAppWatchers->Count();

	for (TInt ii=0;ii<count;ii++)

		{

		CAppWatcher* watcher=(*iAppWatchers)[ii];

		if (watcher->Info()==aClosedFile)

			{

			iAppWatchers->Delete(ii);

			NextL();

			delete watcher;

			break;

			}

		}

	}

/**

@internalComponent

*/

TInt CAppShutter::TimerCallBackL(TAny* aPtr)

	{ // static

	REINTERPRET_CAST(CAppShutter*,aPtr)->HandleTimerCallBackL();

	return 0;

	}

/**

@internalComponent

*/

void CAppShutter::HandleTimerCallBackL()

	{

	NextL();

	}

/**

@internalComponent

*/

void CAppShutter::NextL()

	{

		{

		const RWsSession::TWindowGroupChainInfo wgId=(*iWgIds)[iNextWgIndex++];

		CApaWindowGroupName* wgName=CApaWindowGroupName::NewLC(iWsSession,wgId.iId);

			{

			}

		else

			{

			TPtrC docName=wgName->DocName();

			CEikServBackupSession::TClosedFile data;

			if (docName.Length())

				{

				data.iDocName=docName;

				}

			data.iUid=wgName->AppUid();

			// We don't want to restart server apps

			if (wgId.iParentId <= 0)

				{

				iClosedFiles.AppendL(data);

				}

			TThreadId threadId;

			User::LeaveIfError(iWsSession.GetWindowGroupClientThreadId(wgId.iId,threadId));

			CAppWatcher* watcher=CAppWatcher::NewL(threadId,*this,data);

			CleanupStack::PushL(watcher);

			iAppWatchers->AppendL(watcher);

			CleanupStack::Pop(); // watcher

			TApaTask task(iWsSession);

			task.SetWgId(wgId.iId);

			task.SendSystemEvent(EApaSystemEventShutdown);

			if (iTimer->IsActive())

				{

				iTimer->Cancel();

				}

			// If hardware use patchable constant if not default to 5 seconds

			iTimer->Start(KUIKONBackupCloseAllFilesTimeout,KUIKONBackupCloseAllFilesTimeout,TCallBack(TimerCallBackL,this));

			}

		}

	}

/**

@internalComponent

*/

void CAppShutter::CheckCompleteL()

	{

	// see if any new window groups exist.  If they do, add them to the end of iWgIds and go back to NextL

	const TInt wgCount=iWsSession.NumWindowGroups(0);

	RArray<RWsSession::TWindowGroupChainInfo>* wgIds=new(ELeave) RArray<RWsSession::TWindowGroupChainInfo>(wgCount);

	CleanupStack::PushL(wgIds);

	User::LeaveIfError(iWsSession.WindowGroupList(0,wgIds));

	TBool foundNewWg=EFalse;

	for (TInt ii=0;ii<wgCount;ii++)

		{

		if (iWgIds->Find((*wgIds)[ii])<0)

			{

			iWgIds->AppendL((*wgIds)[ii]);

			foundNewWg=ETrue;

			}

		}

	CleanupStack::PopAndDestroy(); // wgIds

	if (foundNewWg)

		{

		NextL();

		}

	else // if iAppWatchers is non-empty then some tasks are still closing.  Give them up to 5 seconds to terminate

		{

		// Check all files that have been registered for file lock notifications have been updated

		TBool filesAllLocked = iBackupServer.HaveAllCloseAllFilesClientsReRegistered();

		// If all registered files are locked and all app watchers are done we can proceed

		if ((filesAllLocked && (iAppWatchers->Count() == 0)) || (iCheckCount == 3))

			{

			const TBool allAppsClosed=(iAppWatchers->Count()==0);

			iObserver.HandleAppsClosedL(allAppsClosed);

			}

		else

			{

			iCheckCount++;

			if (iTimer->IsActive())

				{

				iTimer->Cancel();

				}

			// If hardware use patchable constant if not default to 5 seconds

			iTimer->Start(KUIKONBackupCloseAllFilesTimeout,KUIKONBackupCloseAllFilesTimeout,TCallBack(TimerCallBackL,this));

			}

		}

	}

//

// class CEikServAppShutter

//

/**

@internalTechnology

*/

CEikServAppShutter::CEikServAppShutter(const RMessage2& aMessage)

	: iMessage(aMessage)

	{}

/**

@internalTechnology

*/

void CEikServAppShutter::ConstructL(MAppShutterObserver& aObserver,

				    CArrayFix<CEikServBackupSession::TClosedFile>& aClosedFiles,

				    CBaBackupServer* aBackupServer)

	{

	iShutter=CAppShutter::StartL(aObserver,aClosedFiles, *aBackupServer);

	}

/**

@internalTechnology

*/

CEikServAppShutter::~CEikServAppShutter()

	{

	delete iShutter;

	}

/**

@internalTechnology

*/

const RMessage2& CEikServAppShutter::Message() const

	{

	return iMessage;

	}

//

// class CEikServBackupSession

//

/**

Static factory function

@return Instantiated and constructed object.

@internalTechnology

*/

CEikServBackupSession* CEikServBackupSession::NewL()

	{ // static

	CEikServBackupSession* self=new(ELeave) CEikServBackupSession();

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self); 

	return self;

	}

/**

@internalTechnology

*/

CEikServBackupSession::~CEikServBackupSession()

	{

	}