//	COMFTP.H
//
// Copyright (c) 1996-1999 Symbian Ltd.  All rights reserved.
//
//	File transfer classes
//
#ifndef __COMFTP_H__
#define __COMFTP_H__
#include <badesca.h>
#include <baliba.h>
#include <f32file.h>
#include <c32comm.h>

typedef TBuf<32> TProtocolName;

#ifdef _UNICODE
#define KUidCommsProtocolDll KUidCommsProtocolDll16
#define KUidCommsProtocolDllValue KUidCommsProtocolDllValue16
#else
#define KUidCommsProtocolDll KUidCommsProtocolDll8
#define KUidCommsProtocolDllValue KUidCommsProtocolDllValue8
#endif

#define KUidCommsProtocolDllValue8        0x100000e5
const TUid KUidCommsProtocolDll8         ={KUidCommsProtocolDllValue8};
const TInt KUidCommsProtocolDllValue16=0x10003A6B;
const TUid KUidCommsProtocolDll16         ={KUidCommsProtocolDllValue16};

enum TCommsProgressUpdate
	{
	ECommsProgressChangedNumberDone,
	ECommsProgressChangedNumberToDo,
	ECommsProgressChangedName,
	ECommsProgressChangedMessage,
	};

class CFileTransfer;

class CTransferTracker : public CBase
	{
public:
	IMPORT_C CTransferTracker();
	//
	IMPORT_C void Close();
	IMPORT_C void CancelTransfer();
	IMPORT_C TInt Open(CFileTransfer& aFileTranfer,TBool aUploading,const TDesC& aTitle);
	//
	IMPORT_C void SetDone(TInt aDone);
	IMPORT_C void SetTodo(TInt aTodo);
	IMPORT_C void SetName(const TDesC& aName);
	IMPORT_C void SetMessage(const TDesC& aMsg);
protected:
	IMPORT_C virtual void DoOpenL();
	IMPORT_C virtual void DoClose();
	IMPORT_C virtual void DoCancelTransfer();
	IMPORT_C virtual void DrawProgressChange(TCommsProgressUpdate aDraw);
	inline TInt Todo() const;
	inline TInt Done() const;
	inline TPtrC Name() const;
	inline TPtrC Title() const;
	inline TPtrC Message() const;
	inline TBool Uploading() const;
private:
	TInt iDone;
	TInt iTodo;
	TBool iUploading;
	TPtrC iName;
	TPtrC iTitle;
	TPtrC iMessage;
	CFileTransfer* iFileTransfer;
    };

class TFileTransferDataHandler
	{
public:
	IMPORT_C TFileTransferDataHandler(RFs& aFs);
	IMPORT_C TInt ReadInfo(const TDesC& aFilename,TTime& aDatestamp,TInt& aSize);
	IMPORT_C TInt ReadStart(const TDesC& aFilename);
	IMPORT_C TInt Read(TDes8& aDes,TInt aMaxLength);
	IMPORT_C void ReadClose();
	IMPORT_C TInt WriteStart(const TDesC& aFilename);
	inline TInt Write(const TDesC8& aBuffer);
	IMPORT_C TInt WriteClose(TInt aTruncationSize=0,TTime* aTimeStamp=NULL);
private:
	RFs* iFs;
	RFile iRFile;
	};

class TFileTransferCapabilities
	{
public:
	TBool iNeedFileNameForReceive;
	TBool iIgnoreEmptyUploads;
	TBool iHandleMultipleUploads;
//	TBool iSupportsAutoStart; // Added to support ZModem
//  TBool iSupportsTransferContinuation; // Added to support ZModem
	};

class CFileTransfer : public CActive
	{
public:
	IMPORT_C ~CFileTransfer();
public:
	virtual TPtrC Name() const=0;
	virtual TFileTransferCapabilities Capabilities() const=0;
	//
	IMPORT_C void UpLoad(const TCallBack& aCallBack,const TDesC& aDir,const CDesCArray& aFilesArray,CTransferTracker* aTransferTracker);
	IMPORT_C void DownLoad(const TCallBack& aCallBack,const TDesC& aDir,const TDesC* aFilename,CTransferTracker* aTransferTracker);
protected:
	IMPORT_C CFileTransfer(RFs& aFs,RComm& aRCom,TInt aPriority);
	IMPORT_C void DoCancel();
	IMPORT_C void CleanUpTransfer();
	IMPORT_C void Complete(TInt aResult);
	IMPORT_C void Panic(TInt aPanicNumber) const;
	//
	virtual void RunL()=0;
	virtual void DoUpLoad()=0;
	virtual void DoDownLoad()=0;
	//
	inline RComm& RCom();
	inline const RComm& RCom() const;
	inline TBool Uploading() const;
	inline TPtrC CurrentFile() const;
	inline TPtrC CurrentPathAndFile() const;
    inline void SetCurrentPathAndFile(const TFileName& aFileName);
	inline const CDesCArray* FileArray() const;
	IMPORT_C void SetCurrentFile(const TDesC& aFile);
	inline TFileTransferDataHandler& DataHandler();
	inline CTransferTracker* TransferTracker() const;
private:
	RComm* iRCom;
	TBool iUploading;
	TBool iCalledBack;
	TPtrC iDirectory;
	TCallBack iCallBack;
	TParse iFilename;
	TCommConfig iOriginalConfig;
	const CDesCArray* iFileArray;
	CTransferTracker* iTransferTracker;
	TFileTransferDataHandler iDataHandler;
	};

typedef TLibAssoc<CFileTransfer> TFileTransferPtr;

class CFileTransferManager : public CBase
	{
public:
	IMPORT_C CFileTransferManager();
	IMPORT_C TInt FindProtocolF(TInt& aProtocol,const TDesC& aName) const;
	IMPORT_C CFileTransfer* CreateProtocolByNameL(const TDesC& aName,RFs& aFs,RComm& aComm,TInt aPriority) const;
	//
	virtual TInt ProtocolCount() const=0;
	virtual TProtocolName ProtocolName(TInt aProtocol) const=0;
	virtual TFileTransferCapabilities ProtocolCapabilities(TInt aProtocol) const=0;
	virtual CFileTransfer* CreateProtocolL(TInt aProtocol,RFs& aFs,RComm& aComm,TInt aPriority) const=0;
	};

typedef TLibAssoc<CFileTransferManager> TFileTransferManagerPtr;

const TInt KCommsProtocolListGranularity=8;
const TInt KCommsDefaultTransferProtocolIndex=0;

class CProtocolNamesAndCaps : public CBase
	{
public:
	IMPORT_C CProtocolNamesAndCaps();
	IMPORT_C ~CProtocolNamesAndCaps();
	IMPORT_C static CProtocolNamesAndCaps* NewL();
	IMPORT_C void ConstructL();
	IMPORT_C TPtrC Name(TInt aIndex);
	IMPORT_C TFileTransferCapabilities Cap(TInt aIndex);
	inline CDesCArray* Names() {return(iNames);}; // required to pass to dialog choicelist
	IMPORT_C void AddNameAndCapsL(TDesC& aName,TFileTransferCapabilities& aCaps);
private:
	CDesCArray* iNames;
	CArrayFixFlat<TFileTransferCapabilities>* iCaps;
	};

class TProtocolManager
	{
public:
	IMPORT_C void PopulateProtocolNameListL(RFs& aFs,CProtocolNamesAndCaps& aNameList) const;
	IMPORT_C TFileTransferCapabilities ProtocolCapabilitiesL(RFs& aFs,const TDesC& aName) const;
	IMPORT_C TFileTransferPtr CreateProtocolL(const TDesC& aName,RFs& aFs,RComm& aComm,TInt aPriority) const;
private:
	void DoAddProtocolNamesL(const TDesC& aFileName,CProtocolNamesAndCaps& aNameList) const;
	TInt DoCreateFileTransferManager(const TDesC& aFileName,TFileTransferManagerPtr& aFileTransferManager) const;
	void DoCreateWithProtocolL(TFileTransferManagerPtr& aManager,TInt& aIndex,RLibrary& aLibrary,RFs& aFs,const TDesC& aName) const;
	};

//	class CTransferTracker
inline TInt CTransferTracker::Todo() const
	{
	return(iTodo);
	}
inline TInt CTransferTracker::Done() const
	{
	return(iDone);
	}
inline TPtrC CTransferTracker::Name() const
	{
	return(iName);
	}
inline TPtrC CTransferTracker::Title() const
	{
	return(iTitle);
	}
inline TPtrC CTransferTracker::Message() const
	{
	return(iMessage);
	}
inline TBool CTransferTracker::Uploading() const
	{
	return(iUploading);
	}

//	class CFileTransfer
inline CTransferTracker* CFileTransfer::TransferTracker() const
	{
	return(iTransferTracker);
	}
inline RComm& CFileTransfer::RCom()
	{
	return(*iRCom);
	}
inline const RComm& CFileTransfer::RCom() const
	{
	return(*iRCom);
	}
inline TFileTransferDataHandler& CFileTransfer::DataHandler()
	{
	return(iDataHandler);
	}
inline TBool CFileTransfer::Uploading() const
	{
	return(iUploading);
	}
inline TPtrC CFileTransfer::CurrentFile() const
	{
	return(iFilename.NameAndExt());
	}
inline TPtrC CFileTransfer::CurrentPathAndFile() const
	{
	return(iFilename.FullName());
	}
inline void CFileTransfer::SetCurrentPathAndFile(const TFileName& aFileName)
    {
    iFilename.Set(aFileName,NULL,NULL);
    }
inline const CDesCArray* CFileTransfer::FileArray() const
	{
	return(iFileArray);
	}

//	class TFileTransferDataHandler
inline TInt TFileTransferDataHandler::Write(const TDesC8& aBuffer)
	{
	return iRFile.Write(aBuffer);
	}
#endif