// command_wrappers.h
// 
// Copyright (c) 2006 - 2010 Accenture. All rights reserved.
// This component and the accompanying materials are made available
// under the terms of the "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:
// Accenture - Initial contribution
//


#ifndef __COMMAND_WRAPPERS_H__
#define __COMMAND_WRAPPERS_H__

#include <e32base.h>
#include <fshell/iocli.h>
#include <fshell/ioutils.h>
#include "command_constructors.h"

using namespace IoUtils;


class MCommandObserver;


class MCommand
	{
public:
	virtual RIoReadHandle& CmndStdin() = 0;
	virtual RIoWriteHandle& CmndStdout() = 0;
	virtual RIoWriteHandle& CmndStderr() = 0;
	virtual TInt CmndRun(const TDesC& aCommandLine, IoUtils::CEnvironment& aEnv, MCommandObserver& aObserver, RIoSession& aIoSession) = 0;
	virtual void CmndForeground() = 0;
	virtual void CmndBackground() = 0;
	virtual void CmndKill() = 0;
	virtual TInt CmndSuspend() = 0;
	virtual TInt CmndResume() = 0;
	virtual void CmndRelease() = 0;
	virtual TExitType CmndExitType() const = 0;
	virtual TExitCategoryName CmndExitCategory() const = 0;
	virtual const TDesC& CmndName() const = 0;
	virtual TInt CmndReattachStdin(RIoEndPoint& aStdinEndPoint) = 0;
	virtual TInt CmndReattachStdout(RIoEndPoint& aStdoutEndPoint) = 0;
	virtual TInt CmndReattachStderr(RIoEndPoint& aStderrEndPoint) = 0;
	virtual TBool CmndIsDisownable() const = 0;
	virtual void CmndDisown() = 0;
	};


class MCommandObserver
	{
public:
	virtual void HandleCommandComplete(MCommand& aCommand, TInt aError) = 0;
	};


class CCommandWrapperBase : public CBase, public MCommand
	{
protected:
	CCommandWrapperBase();
	~CCommandWrapperBase();
	void BaseConstructL(const TDesC& aName);
protected: // From MCommand.
	virtual RIoReadHandle& CmndStdin();
	virtual RIoWriteHandle& CmndStdout();
	virtual RIoWriteHandle& CmndStderr();
	virtual const TDesC& CmndName() const;
	virtual TInt CmndReattachStdin(RIoEndPoint& aStdinEndPoint);
	virtual TInt CmndReattachStdout(RIoEndPoint& aStdoutEndPoint);
	virtual TInt CmndReattachStderr(RIoEndPoint& aStderrEndPoint);
	virtual TBool CmndIsDisownable() const;
	virtual void CmndDisown();
private: // From MCommand.
	virtual void CmndRelease();
private:
	HBufC* iName;	///< This is used by concrete classes as they see fit.
	RIoReadHandle iStdin;
	RIoWriteHandle iStdout;
	RIoWriteHandle iStderr;
	};


class CThreadCommand : public CCommandWrapperBase
	{
public:
	enum TFlags
		{
		EUpdateEnvironment = 0x00000001,
		ESharedHeap = 0x00000002, // Any command that accesses gShell must have this set
		};
public:
	static CThreadCommand* NewL(const TDesC& aName, TCommandConstructor aCommandConstructor, TUint aFlags);
	~CThreadCommand();
private:
	CThreadCommand(TCommandConstructor aCommandConstructor, TUint aFlags);
	void ConstructL(const TDesC& aName);
private: // From MCommand.
	virtual TInt CmndRun(const TDesC& aCommandLine, IoUtils::CEnvironment& aEnv, MCommandObserver& aObserver, RIoSession& aIoSession);
	virtual void CmndForeground();
	virtual void CmndBackground();
	virtual void CmndKill();
	virtual TInt CmndSuspend();
	virtual TInt CmndResume();
	virtual TExitType CmndExitType() const;
	virtual TExitCategoryName CmndExitCategory() const;
public:
	class TArgs
		{
	public:
		TArgs(TUint aFlags, CEnvironment& aEnv, TCommandConstructor aCommandConstructor, const TDesC& aCommandLine, TRequestStatus& aParentStatus);
	public:
		TUint iFlags;
		CEnvironment& iEnv;
		TCommandConstructor iCommandConstructor;
		const TPtrC iCommandLine;
		TRequestStatus* iParentStatus;
		TThreadId iParentThreadId;
		};
	class CThreadWatcher : public CActive
		{
	public:
		static CThreadWatcher* NewL();
		~CThreadWatcher();
		TInt Logon(CThreadCommand& aCommand, RThread& aThread, MCommandObserver& aObserver);
		void SetActive();
	private:
		CThreadWatcher();
	private: // From CActive.
		virtual void RunL();
		virtual void DoCancel();
	private:
		CThreadCommand* iCommand;
		RThread* iThread;
		MCommandObserver* iObserver;
		};
private:
	TUint iFlags;
	TCommandConstructor iCommandConstructor;
	MCommandObserver* iObserver;
	TArgs* iArgs;
	RThread iThread;
	CThreadWatcher* iWatcher;
	};


class CProcessCommand : public CCommandWrapperBase
	{
public:
	static CProcessCommand* NewL(const TDesC& aExeName);
	static CProcessCommand* NewL(const TDesC& aExeName, RProcess& aProcess);
	~CProcessCommand();
protected:
	CProcessCommand();
	void ConstructL(const TDesC& aExeName, RProcess* aProcess = NULL);
	virtual void CreateProcessL(const TDesC& aCommandLine, CEnvironment& aEnv);
private:
	void CmndRunL(const TDesC& aCommandLine, IoUtils::CEnvironment& aEnv, MCommandObserver& aObserver);
protected: // From MCommand.
	virtual TInt CmndRun(const TDesC& aCommandLine, IoUtils::CEnvironment& aEnv, MCommandObserver& aObserver, RIoSession& aIoSession);
	virtual void CmndForeground();
	virtual void CmndBackground();
	virtual void CmndKill();
	virtual TInt CmndSuspend();
	virtual TInt CmndResume();
	virtual TExitType CmndExitType() const;
	virtual TExitCategoryName CmndExitCategory() const;
	virtual TBool CmndIsDisownable() const;
	virtual void CmndDisown();
public:
	class CProcessWatcher : public CActive
		{
	public:
		static CProcessWatcher* NewL();
		~CProcessWatcher();
		TInt Logon(CProcessCommand& aCommand, RProcess& aProcess, MCommandObserver& aObserver);
	private:
		CProcessWatcher();
	private: // From CActive.
		virtual void RunL();
		virtual void DoCancel();
	private:
		CProcessCommand* iCommand;
		RProcess* iProcess;
		MCommandObserver* iObserver;
		};
protected:
	MCommandObserver* iObserver;
	RProcess iProcess;
	CProcessWatcher* iWatcher;
	};


class CPipsCommand : public CProcessCommand
	{
public:
	static CPipsCommand* NewL(const TDesC& aExeName);
	CPipsCommand();
	~CPipsCommand();
private: // From MCommand.
	virtual TInt CmndRun(const TDesC& aCommandLine, IoUtils::CEnvironment& aEnv, MCommandObserver& aObserver, RIoSession& aIoSession);
	virtual void CmndKill();
private: // From CProcessCommand.
	virtual void CreateProcessL(const TDesC& aCommandLine, IoUtils::CEnvironment& aEnv);
private:
	TBool iUsingPipsRun;
	TInt iPipsRunChildProcessId;
	};


class CAliasCommand : public CCommandWrapperBase, public MCommandObserver
	{
public:
	static CAliasCommand* NewL(MCommand& aAliasedCommand, const TDesC* aAdditionalArguments, const TDesC* aReplacementArguments);
	~CAliasCommand();
private:
	CAliasCommand(MCommand& aAliasedCommand);
	void ConstructL(const TDesC* aAdditionalArguments, const TDesC* aReplacementArguments);
private: // From MCommand.
	RIoReadHandle& CmndStdin();
	RIoWriteHandle& CmndStdout();
	RIoWriteHandle& CmndStderr();
	TInt CmndRun(const TDesC& aCommandLine, IoUtils::CEnvironment& aEnv, MCommandObserver& aObserver, RIoSession& aIoSession);
	void CmndForeground();
	void CmndBackground();
	void CmndKill();
	TInt CmndSuspend();
	TInt CmndResume();
	TExitType CmndExitType() const;
	TExitCategoryName CmndExitCategory() const;
private: // From MCommandObserver.
	virtual void HandleCommandComplete(MCommand& aCommand, TInt aError);
private:
	MCommand& iAliasedCommand;
	HBufC* iAdditionalArguments;
	HBufC* iReplacementArguments;
	MCommandObserver* iCommandObserver;
	};


#endif // __COMMAND_WRAPPERS_H__