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

// apaproc.cpp

//

#include <apaproc.h> // stuff everyone will want ie most things

#include <apacln.h> // CleanupStack protection for CApaDocument

#include "APADLL.H" // class RApaApplication

#include "APASTD.H" // Panics etc.

#include <s32file.h>

#include "../apparc/TRACE.H"

#include <e32def_private.h> // MattR addition for __PROFILE_END error

const TInt KAppProcessArrayGranularity(1);

//

// CApaParentProcessMonitor

//

class CApaParentProcessMonitor : public CActive

	{

public: // Construction / destruction

	static CApaParentProcessMonitor* NewL(TProcessId aProcessId);

	~CApaParentProcessMonitor();

	void ConstructL();

private:

	CApaParentProcessMonitor(TProcessId aProcessId);

public: // From CActive

	void RunL();

	void DoCancel();

private:

	TProcessId iProcessId;

	RProcess iProcess;

	};

CApaParentProcessMonitor* CApaParentProcessMonitor::NewL(TProcessId aProcessId)

	{

	CApaParentProcessMonitor* self=new (ELeave) CApaParentProcessMonitor(aProcessId);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

CApaParentProcessMonitor::CApaParentProcessMonitor(TProcessId aProcessId)

	: CActive(EPriorityLow)

	{

	iProcessId=aProcessId;

	}

CApaParentProcessMonitor::~CApaParentProcessMonitor()

	{

	Cancel();

	}

void CApaParentProcessMonitor::ConstructL()

	{

	User::LeaveIfError(iProcess.Open(iProcessId));

	iProcess.Logon(iStatus);

	if(iStatus==KErrNoMemory)

		{

		User::WaitForRequest(iStatus);

		User::Leave(KErrNoMemory);

		}

	CActiveScheduler::Add(this);

	SetActive();

	}

void CApaParentProcessMonitor::RunL()

	{

	// Do something that will kill the child when the parent process terminates

	if(iStatus==KErrNone)

		{

		RProcess proc;

		proc.Terminate(KErrNone);

		}

	}

void CApaParentProcessMonitor::DoCancel()

	{

	iProcess.LogonCancel(iStatus);

	}

//

// CApaProcess

//

/** Constructor for CApaProcess */

EXPORT_C CApaProcess::CApaProcess()

	{

	}

EXPORT_C CApaProcess* CApaProcess::NewL(const RFs& aFs)

/** Creates and returns a pointer to a new application process.

This function is not used by UI applications.

@param aFs Handle to a file server session.

@return Pointer to the new application process. */

	{

	CApaProcess* self=new(ELeave) CApaProcess(aFs);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop();

	return self;

	}

EXPORT_C CApaProcess::CApaProcess(const RFs& aFs)

	:iFsSession(aFs)

/** Constructs the application process object with the specified file session handle.

Derived classes must define and implement a constructor through which 

the file session handle can be specified. A 

typical implementation calls this constructor through a constructor initialization 

list.

This constructor is used by the UI framework.

@deprecated

@param aFs Handle to a file server session */

	{}

const TInt KPriorityGreaterThanShutter=102;

EXPORT_C void CApaProcess::ConstructL()

/** Completes construction of the application process object.

Implementers of derived classes must call this function as part of the second 

stage construction of an object. Typically, derived classes implement their 

own NewL() function and call ConstructL() as part of that implementation. */

	{

	//

	iAppList = new(ELeave) CArrayPtrFlat<RApaApplication>(KAppProcessArrayGranularity);

	iDocList = new(ELeave) CArrayPtrFlat<CApaDocument>(KAppProcessArrayGranularity);

	iMainDocFileName = HBufC::NewL(KMaxFileName);

	iAsyncAppRemover = CIdle::NewL(KPriorityGreaterThanShutter);	// Use an idle object so that app has chance to clear its call stack

	}

EXPORT_C void CApaProcess::ConstructL(TProcessId aParentProcessId)

/** Completes construction of the application process object, passing in a Parent Process Identifier.

Implementers of derived classes must call this function as part of the second 

stage construction of an object. Typically, derived classes implement their 

own NewL() function and call ConstructL() as part of that implementation.

@param aParentProcessId Id of the parent process. This process will terminate when the parent does. */

	{

	ConstructL();

	if(KNullProcessId!=aParentProcessId)

		{

		iMonitor=CApaParentProcessMonitor::NewL(aParentProcessId);

		}

	}

/** Frees resources prior to destruction.

Documents must be saved before the application process is deleted, otherwise 

data may be lost.

In debug mode, the destructor raises an APPARC 6 panic if documents still 

exist, and an APPARC 5 panic if applications still exist. */

EXPORT_C CApaProcess::~CApaProcess()

// If this is called without calling ResetL() or CApaDocument::SaveL() first, data may be lost

//

	{

	if (iMainDoc)

		{

		DestroyDocument(iMainDoc);

		iMainDoc = NULL;

		}

	if (iDocList)

		{

		__ASSERT_DEBUG(iDocList->Count()==0,Panic(EPanicDocListNotEmpty));

		for (TInt i=iDocList->Count()-1 ; i>=0 ; i--)

			delete (*iDocList)[i]; // delete stray doc's in release mode, just to be tidy

		}

	if (iAppList)

		{

		for (TInt i = iAppList->Count()-1 ; i >= 0 ; i--)

			(*iAppList)[i]->Close();

		}

	delete iAppList;

	delete iDocList;

	delete iMainDocFileName;

	delete iAsyncAppRemover;

	delete iMonitor;

	}

/** Resets the the application process to its initial state.

Specifically, it saves the main document, deletes the main and all embedded 

documents from memory, resets the main document filename and deletes all applications 

except the main application.

The function can leave if saving the main document fails. */

EXPORT_C void CApaProcess::ResetL()

	{

	if (iMainDoc)

		{

		iMainDoc->SaveL();

		DeleteAllDocs(); // sets iMainDoc to NULL, deletes all apps except main

		}

	__ASSERT_DEBUG(iMainDocFileName, Panic(EPanicNoDocument));

	*iMainDocFileName = KNullDesC;

	}

void CApaProcess::DeleteAllDocs()

// deletes all docs

// deletes all apps except main app

// sets iMainDoc* to NULL

//

	{

	CApaApplication* mainApp = NULL;

	// If the main document has been constructed...

	if (iMainDoc) // then iDocList must also exist

		{

		__ASSERT_DEBUG(iMainDoc->Application(), Panic(EDPanicNoApp));

		mainApp = iMainDoc->Application();

		// ...find the main document in the list of documents and delete it.

		for (TInt i = iDocList->Count()-1; i >= 0; i--)

			{

			if ((*iDocList)[i] == iMainDoc)

				{

				iDocList->Delete(i); // removes from array, but doesnt destroy

				delete iMainDoc;

				iMainDoc = NULL;

				break;

				}

			}

		}

	// Remove all documents from the list of documents, without deleting them.

	if(iDocList)	

		{

		__ASSERT_ALWAYS(iDocList->Count()==0, Panic(EPanicDocListNotEmpty));

		iDocList->Reset();

		}

	// Delete all applications except the main one.

	if(iAppList)

		{

		for (TInt ii = iAppList->Count()-1; ii >= 0; ii--) // need to iterate backwards as the array changes size during the loop

			{

			if ((*iAppList)[ii]->Application() != mainApp)

				{

				(*iAppList)[ii]->Close();

				iAppList->Delete(ii);

				}

			}

		iAppList->Compress();

		}

	}

EXPORT_C void CApaProcess::SetMainDocFileName(const TDesC& aMainDocFileName)

/** Sets the filename of the main document.

@param aMainDocFileName The filename to be set.

@panic APPARC 7 If the length of aMainDocFileName is greater than KMaxFileName or the

length of the last filename set by SetMainDocFileNameL if greater

@see KMaxFileName */

	{

	__ASSERT_DEBUG( iMainDocFileName, Panic(EPanicNullPointer));

	__ASSERT_ALWAYS( aMainDocFileName.Length()<=iMainDocFileName->Des().MaxLength() ,Panic(EPanicFileNameTooLong));

	*iMainDocFileName = aMainDocFileName;

	}

EXPORT_C void CApaProcess::SetMainDocFileNameL(const TDesC& aMainDocFileName)

/** Sets the filename of the main document.

@param aMainDocFileName The filename to be set. There is no restriction on the

length of this descriptor. */

	{

	__ASSERT_ALWAYS( iMainDocFileName, Panic(EPanicNullPointer));

	const TInt newLength = aMainDocFileName.Length() < KMaxFileName ? KMaxFileName : aMainDocFileName.Length();

	if (newLength != iMainDocFileName->Des().MaxLength())

		{

		HBufC* const newMainDocFileName = HBufC::NewL(newLength);

		delete iMainDocFileName;

		iMainDocFileName = newMainDocFileName;

		}

	SetMainDocFileName(aMainDocFileName);

	}

/** Sets the main document.

@param aDocument A pointer to the document to be set as the main document 

of the application process. This must be a an object created by the AddNewDocumentL() 

or OpenNewDocumentL() functions 

@see CApaProcess::AddNewDocumentL()

@see CApaProcess::OpenNewDocumentL() */

EXPORT_C void CApaProcess::SetMainDocument(CApaDocument* aDocument)

	{

	__ASSERT_ALWAYS( iDocList, Panic(EPanicNullPointer));

	// check that the prospective main doc has actually been added to the array

	for (TInt i = iDocList->Count()-1 ; i >= 0 ; i--)

		{

		if ((*iDocList)[i] == aDocument)

			break;

		if (i==0)

			Panic(EPanicNoDocument);

		}

	// assign it once it has checked out

	iMainDoc = aDocument;

	}

/** Creates and adds a new document using the specified application factory.

The document may be a main document or an embedded document.

Any document created with this function must be destroyed using DestroyDocument().

@param aApplicationFactory Should be created implicitly by passing a pointer to

a factory function, an ECOM plugin UID, or a CImplementationInformation reference.

@return A pointer to the new document.

@see CApaProcess::DestroyDocument()

@see CApaApplication */

EXPORT_C CApaDocument* CApaProcess::AddNewDocumentL(TApaApplicationFactory aApplicationFactory)

	{

	__SHOW_TRACE(_L("Starting CApaProcess::AddNewDocumentL"));

	__APA_PROFILE_START(0);

	RApaApplication* app = AddAppL(aApplicationFactory);	

	// use the app to create a doc

	CApaDocument* doc = NULL;

	TRAPD(err, doc = CreateDocL(app->Application()));

	if (err)

		RemoveApp(app);	// remove app as it has been orphaned

	User::LeaveIfError(err);

	__PROFILE_END(0);

	return doc;

	} //lint !e1762 Member function could be made const - Not true

void CApaProcess::RemoveApp(RApaApplication* aApp)

// removes app exe from the list if it exists, panics otherwise

	{

	__ASSERT_ALWAYS(iAppList, Panic(EPanicNullPointer));

	TInt i = 0;

	for (i = iAppList->Count()-1; i >= 0; i--)

		{

		if ((*iAppList)[i] == aApp) // the main app may be alive on its own if Reset() has just been called

			{

			aApp->Close(); // the main app may be alive on its own if Reset() has just been called

			iAppList->Delete(i);

			break;

			}

		}

	if (i < 0)

		Panic(EPanicAppNotInList);

	}

/** Opens the specified file and restores the content as a document.

The created document can be merged into or embedded in another document.

Any document created with this function must be destroyed using DestroyDocument().

@param aStore On return, this contains a pointer to the store object created 

during the restore.

@param aStreamDic On return, this contains a pointer to the stream dictionary 

object created during the restore. 

@param aDocFullFileName The name of the file containing the document. 

@param aFileMode The mode in which to open the file. 

@return A pointer to the restored document.

@see TFileMode

@see CApaProcess::DestroyDocument() */

EXPORT_C CApaDocument* CApaProcess::OpenNewDocumentL(CFileStore*& aStore,CStreamDictionary*& aStreamDic,const TDesC& aDocFullFileName,TUint aFileMode)

	{

	__SHOW_TRACE(_L("Starting CApaProcess::OpenNewDocumentL"));

	__APA_PROFILE_START(1);

	TParse parser;

	User::LeaveIfError(iFsSession.Parse(aDocFullFileName,parser)); 

	// open doc as a file store & read in the header

	CFileStore* docStore;

	CStreamDictionary* streamDic = ReadRootStreamLC(FsSession(),docStore,parser.FullName(),aFileMode);

	CleanupStack::PushL(docStore);

	// read in the app id info

	TApaAppIdentifier appId=ReadAppIdentifierL(*docStore,*streamDic);

	// create the doc

	CApaDocument* importedDoc =	AddNewDocumentL(appId.iAppUid);

	// restore the document

	TApaDocCleanupItem cleanup(this,importedDoc);

	CleanupStack::PushL(cleanup);

	importedDoc->RestoreL(*docStore,*streamDic);

	CleanupStack::Pop(3); //docStore,importedDoc,streamDic

	aStore = docStore;

	aStreamDic = streamDic;

	__PROFILE_END(1);

	return importedDoc;

	}

/** Reads the application identifier from its stream in the specified store and 

returns it.

The location of the stream is found in the specified stream dictionary.

@param aStore The store from which the application identifier should be read. 

@param aStreamDic The stream dictionary containing the stream ID of the application 

identifier stream. The stream dictionary can be found in the root stream of 

the store.

@return The application identifier. */

EXPORT_C TApaAppIdentifier CApaProcess::ReadAppIdentifierL(const CStreamStore& aStore,const CStreamDictionary& aStreamDic)

	{

	// this is a static method

	__SHOW_TRACE(_L("Starting CApaProcess::ReadAppIdentifierL"));

	TStreamId infoStreamId = aStreamDic.At(KUidAppIdentifierStream);

	TApaAppIdentifier appId;

	// create a stream and read in the data

	RStoreReadStream stream;

	stream.OpenLC(aStore,infoStreamId);

	stream >> appId;

	stream.Close();

	CleanupStack::PopAndDestroy(); // stream

	return appId;	

	}

/** Writes the application identifier to a new stream in the specified store and 

records the location of this stream in the specified stream dictionary.

@param aStore The store to which the application identifier should be written. 

@param aStreamDic The stream dictionary. 

@param aAppId The application identifier to be externalised to a stream. */

EXPORT_C void CApaProcess::WriteAppIdentifierL(CStreamStore& aStore,CStreamDictionary& aStreamDic,const TApaAppIdentifier& aAppId)

	{

	// this is a static method

	__SHOW_TRACE(_L("Starting CApaProcess::WriteAppIdentifierL"));

	// create a stream

	RStoreWriteStream stream;

	TStreamId streamId = stream.CreateLC(aStore);

	// stream the header

	stream << aAppId;

	stream.CommitL();

	CleanupStack::PopAndDestroy(); // id stream

	// enter the stream in the dictionary

	aStreamDic.AssignL(KUidAppIdentifierStream, streamId);

	}

/** Reads the stream dictionary contained as the root stream in the specified document 

file.

The function constructs, and returns a pointer to the stream dictionary object 

and puts the pointer to the stream dictionary object onto the cleanup stack. 

It also returns a pointer to the created file store object through an argument 

reference. 

The file must be a valid document file; otherwise the function leaves with one of 

the system-wide error codes.

@param aFs Handle to a file server session.

@param aStore On return, a pointer to the newly created file store object. 

@param aDocFullFileName The full path name of the document file. 

@param aFileMode The mode in which to open the file.

@return A pointer to the stream dictionary object read from the root stream 

of the store. 

@see TFileMode */

EXPORT_C CStreamDictionary* CApaProcess::ReadRootStreamLC(RFs& aFs,CFileStore*& aStore,const TDesC& aDocFullFileName,TUint aFileMode)

	{ // static

	__SHOW_TRACE(_L("Starting CApaProcess::ReadRootStreamLC (file-name overload)"));

	CStreamDictionary* const streamDictionary=CStreamDictionary::NewLC();

	CFileStore* const store=CFileStore::OpenLC(aFs,aDocFullFileName,aFileMode);

	DoReadRootStreamL(*streamDictionary, *store);

	aStore=store; // delay assignment until nothing can go wrong to avoid destroying the store twice if a leave occurs

	CleanupStack::Pop(store);

	return streamDictionary;

	}

/**

@internalTechnology

*/

EXPORT_C CStreamDictionary* CApaProcess::ReadRootStreamLC(CFileStore*& aStore, const RFile& aFile)

	{ // static

	__SHOW_TRACE(_L("Starting CApaProcess::ReadRootStreamLC (file-handle overload)"));

	CStreamDictionary* const streamDictionary = CStreamDictionary::NewLC();

	RFile duplicateFile;

	CleanupClosePushL(duplicateFile);

	User::LeaveIfError(duplicateFile.Duplicate(aFile)); // this is because CFileStore::FromLC closes the file its passed (and stores its own duplicate)

	CFileStore* const store = CFileStore::FromL(duplicateFile);

	CleanupStack::PopAndDestroy(&duplicateFile);

	CleanupStack::PushL(store);

	DoReadRootStreamL(*streamDictionary, *store);

	aStore = store; // delay assignment until nothing can go wrong to avoid destroying the store twice if a leave occurs

	CleanupStack::Pop(store);

	return streamDictionary;