// Copyright (c) 1997-2009 Nokia Corporation and/or its subsidiary(-ies).

// All rights reserved.

// This component and the accompanying materials are made available

// which accompanies this distribution, and is available

//

// Initial Contributors:

// Nokia Corporation - initial contribution.

//

// Contributors:

//

// Description:

//

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

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

#include "APADLL.H" // CApaDll CApaExe CApaAppHolder

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

#include <e32uid.h> // KExecutableImageUid

#include <s32stor.h>

#include <s32file.h>

#include <s32std.h>

#ifdef USING_ECOM_RECOGS

#include <ecom/ecom.h>

#include <ecom/implementationinformation.h>

#endif

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

const TInt KAppProcessArrayGranularity(1);

_LIT(KApplicationLocation,"\\sys\\bin\\");

/////////////////////////////

// Doc cleanup method

/////////////////////////////

EXPORT_C void TApaDocCleanupItem::DoCleanup(TAny* aPtr)

	{

	__ASSERT_ALWAYS(aPtr,Panic(EPanicNoCleanupItem));

	TApaDocCleanupItem* cleanup = reinterpret_cast<TApaDocCleanupItem*>(aPtr);

	__ASSERT_ALWAYS(cleanup->iApaProcess,Panic(EPanicNoCleanupItem));//lint !e613 Possible use of null pointer - Asserted above

	cleanup->iApaProcess->DestroyDocument(cleanup->iApaDoc); //lint !e613 Possible use of null pointer - Asserted above

	}

/////////////////////////////

// CApaAppHolder

/////////////////////////////

CApaAppHolder::CApaAppHolder()

	{}

CApaAppHolder::~CApaAppHolder()

	{

	}

void CApaAppHolder::UpdateAppsRefToThis()

	{

	CApaApplication* app = Application();

	__ASSERT_ALWAYS(app,Panic(EPanicNoApplication));

	app->iAppHolder = this;	//lint !e613 Possible use of null pointer - Asserted above

	}

#ifdef USING_ECOM_RECOGS

/////////////////////////////

// CApaExe

/////////////////////////////

CApaExe::CApaExe()

	{}

CApaExe::~CApaExe()

	{

	delete iAppName;

	delete iApplication;

	}

TFileName CApaExe::FileName()const

	{

	if (iAppName)

		{

		return *iAppName;

		}

	else

		{

		return KNullDesC();

		}

	}

TUid CApaExe::Uid()const

	{

	return iFileUid;

	}

CApaApplication* CApaExe::Application() const

	{

	return iApplication;

	}

void CApaExe::CreateApplicationL(TApaApplicationFactory aApplicationFactory)

	{

	__ASSERT_ALWAYS(!iApplication,Panic(EPanicApplicationAlreadyExists));

	iApplication = aApplicationFactory.CreateApplicationL();

	iFileUid = aApplicationFactory.AppFileUid();

	User::LeaveIfNull(iApplication);

	iAppName = aApplicationFactory.AppFileNameL();

	UpdateAppsRefToThis();

	}

#endif // USING_ECOM_RECOGS

EXPORT_C void CApaDocument::OpenFileL(CFileStore*&, RFile&)

	{

	}

EXPORT_C void CApaDocument::Reserved_2()

	{}

/////////////////////

// CApaApplication

/////////////////////

/** Constructor for CApaApplication */

EXPORT_C CApaApplication::CApaApplication()

	{

	}

EXPORT_C TFileName CApaApplication::AppFullName()const

/** Returns the full name and path of the application.

The default implementation returns the full path name of the application DLL.

An application can provide its own implementation. 

@return Full path name of the application.

@see CApaApplication::DllName() */

	{

	return DllName();

	}

EXPORT_C TFileName CApaApplication::DllName()const

/** Returns the full name and path of the loaded application DLL.

@return Full path name of the application DLL. */

	{

	__ASSERT_DEBUG(iAppHolder, Panic(EDPanicNoAppHolder));

	return iAppHolder->FileName();

	}

EXPORT_C TInt CApaApplication::GenerateFileName(RFs& aFs,TFileName& aRootName)

/** Generates a unique filename based on the file name contained within the specified 

full path name.

If necessary, the function creates the directory structure that is defined 

in the specified full path name.

If the file name does not yet exist, then this is the file name chosen. If 

this file name already exists, then a file name of the form: name(nn) is generated, 

where nn are decimal digits. The value of nn is incremented until a name is 

generated that is unique within the directory structure. A minimum of two 

decimal digits is generated.

The function is used by the UI framework.

@param aFs Handle to a file server session. 

@param aRootName The full path name.

@return KErrNone if successful, otherwise one of the other system-wide error 

codes. Specifically: KErrBadName if the file name portion of the specified 

full path name has invalid format; KErrArgument if the drive, path or file 

name parts are missing from the specified full path name; KErrOverflow if 

the generated filename becomes too long; KErrNoMemory if there is insufficient 

memory to perform the operation.

@see CEikAppUi */

	{

	// check that filename is valid

	if (!aFs.IsValidName(aRootName))

		return KErrBadName;

	//

	// check that a drive, path and root filename have been specified

	TParsePtr parsePtr(aRootName);

	if (!parsePtr.DrivePresent() || !parsePtr.PathPresent() || !parsePtr.NamePresent())

		return KErrArgument;

	//

	// create the path if necessary

	TInt ret=aFs.MkDirAll(parsePtr.DriveAndPath());

	if (ret!=KErrNone && ret!=KErrAlreadyExists)

		return ret;

	//

	// Create the Rbuf object to hold a filename (return if no mem available)

	RBuf newName;

	ret = newName.Create(aRootName, KMaxFileName+8);

	if (ret!=KErrNone)

		return KErrNoMemory;

	//	

	// generate a valid filename that doesn't already exist...

	TEntry entry;

	TInt i=1;

	_LIT(KFormatStringOne,"%S%S(%02d)%S");

	TBuf<16> format;

	format=KFormatStringOne;

	while (aFs.Entry(newName,entry)==KErrNone)		// Continue until DoesNotExist or PathDoesNotExist, etc

		{

		if (i>=100)

			{

			_LIT(KFormatStringTwo,"%S%S(%d)%S");

			format=KFormatStringTwo;

			}

		TPtrC driveAndPath=parsePtr.DriveAndPath();

		TPtrC name=parsePtr.Name();

		TPtrC ext=parsePtr.Ext();

		newName.Format(format,&driveAndPath,&name,i++,&ext);

		if (newName.Length()>KMaxFileName)

			{

			newName.Close();

			return KErrOverflow;

			}

		}

	//

	// set the new filename and return

	aRootName = newName;

	newName.Close();

	return KErrNone;

	}

EXPORT_C CDictionaryStore* CApaApplication::OpenIniFileL(RFs& aFs)const

/** Opens the .ini file associated with the application, constructs the dictionary 

store object and returns a pointer to it.

The implementation of this function is provided by the OpenIniFileLC() function. 

The function pops the pointer returned by OpenIniFileLC() from the cleanup 

stack.

@param aFs Handle to a file server session. 

@return A pointer to the dictionary store object representing the application's 

.ini file. 

@see CApaApplication::OpenIniFileLC() */

	{

	CDictionaryStore* store=OpenIniFileLC(aFs);

	CleanupStack::Pop(); // store

	return store;

	}

EXPORT_C CApaApplication::~CApaApplication()

	{

#ifdef USING_ECOM_RECOGS

	if (iDtorKey!=TUid::Null()) // only some CApaApplication objects are ECom objects (i.e. only those corresponding to embedded applications, not top-level applications)

		{

		REComSession::DestroyedImplementation(iDtorKey);

		}

#endif // USING_ECOM_RECOGS

	iAppHolder = NULL;

	}

EXPORT_C void CApaApplication::NewAppServerL(CApaAppServer*& /*aAppServer*/)

/** Virtual function called by the framework when the application

has been launched as a server application.

Applications that wish to be used as server applications must

override this function to return their implemetation of the server.

@param aAppServer The server pointer to be set. */

	{

	User::Leave(KErrNotSupported);

	}

/** Reserved for future use */

EXPORT_C void CApaApplication::CApaApplication_Reserved1()

	{

	}

/** Reserved for future use */

EXPORT_C void CApaApplication::CApaApplication_Reserved2()

	{

	}

/////////////////////////////

// CApaDocument

/////////////////////////////

/** Constructor for CApaDocument */

EXPORT_C CApaDocument::CApaDocument()

	{

	}

EXPORT_C CApaDocument::CApaDocument(CApaApplication& aApp,CApaProcess& aProcess)

	: iApplication(&aApp),

	iApaProcess(&aProcess)

/** Constructs the document object with the specified application and process.

Derived classes must define and implement a constructor through which both 

the associated application and process can be specified. A typical implementation 

calls this constructor through a constructor initialization list.

@param aApp The application.

@param aProcess The process.

@see CEikDocument */

	{}

EXPORT_C CApaDocument::~CApaDocument()

/** Destructor.

The implementation is empty. */

	{

	iContainer = NULL;

	iApplication = NULL;

	iApaProcess = NULL;

	}

EXPORT_C CApaDocument::TCapability CApaDocument::Capability() const

/** Gets the document's capabilities.

Capabilities are encapsulated by an instance of a TCapability class, a public 

class defined inside this class.

The default implementation returns a default TCapability object, indicating 

that the document does not support any of the defined capabilities.

If a document does support one or more of the capabilities, it should override 

this function to return a suitably initialised object.

@return The document's capabilities */

	{

	return TCapability();

	}

EXPORT_C void CApaDocument::ValidatePasswordL() const

/** Checks the document password.

The default implementation is empty.

If a document is intended to be password protected, the UI application should 

provide an implementation that forces the user to enter the password and validate 

the input.

If the document is protected by a password and the password entered by the 

user is incorrect, the function should leave with KErrLocked, otherwise it 

should just return. */

	{}

EXPORT_C CPicture* CApaDocument::GlassPictureL()

// Return handle to glass picture, creating one if not already created.

// returns NULL as glass pictures are not supported by default

/** Gets an object that can draw a representation of the document's content.

If the document supports being embedded as a glass door, then the UI application 

must provide an implementation for this function.

The default implementation raises an APPARC 8 panic.

@return A pointer to a glass door. */

	{

	Panic(EPanicNoGlassDoorMethodSupplied);

	//

	return NULL;

	}

EXPORT_C void CApaDocument::ExternalizeL(RWriteStream& /*aStream*/)const

	{}

EXPORT_C CApaDocument::TCapability::TCapability()

	:iCapability(0),TCapability_Reserved1(0)

/** Constructs a default capability object.

All capabilities are marked as "not supported". */

	{}

/////////////////////////////

// TApaAppHolderInfo

/////////////////////////////

class TApaAppHolderInfo

	{

public:

	TApaAppHolderInfo(CApaAppHolder* aAppHolder);

public:

	CApaAppHolder* iAppHolder;

	TBool iToBeRemoved;

	};

TApaAppHolderInfo::TApaAppHolderInfo(CApaAppHolder* aAppHolder)

	:iAppHolder(aAppHolder), iToBeRemoved(EFalse)

	{

	}

/////////////////////////////

// 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) CArrayFixFlat<TApaAppHolderInfo>(KAppProcessArrayGranularity);

	iDocList = new(ELeave) CArrayFixFlat<CApaDocument*>(KAppProcessArrayGranularity);

	iMainDocFileName = HBufC::NewL(KMaxFileName);

	iApplicationRemover=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. */

	{