CWE-ou-minkata/Sources/Plasma/FeatureLib/pfSecurePreloader/pfSecurePreloader.h

/*==LICENSE==*

CyanWorlds.com Engine - MMOG client, server and tools
Copyright (C) 2011  Cyan Worlds, Inc.

This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.

You can contact Cyan Worlds, Inc. by email legal@cyan.com
 or by snail mail at:
      Cyan Worlds, Inc.
      14617 N Newport Hwy
      Mead, WA   99021

*==LICENSE==*/
#ifndef __pfSecurePreloader_h__
#define __pfSecurePreloader_h__

#include "hsTypes.h"
#include "hsStlUtils.h"
#include "hsCritSect.h"
#include "hsStream.h"
#include "plFile/plSecureStream.h"
#include "pnKeyedObject/hsKeyedObject.h"


class plOperationProgress;

///////////////////////////////////////////////////////////////////////////////
// pfSecurePreloader - a class for handling files we want downloaded from the
// server into a temporary directory, secured, and deleted on exit. Puts stuff
// into plStreamSource for us
///////////////////////////////////////////////////////////////////////////////
class pfSecurePreloader : public hsKeyedObject
{
private:
	static pfSecurePreloader * fInstance;

	struct fileRequest
	{
		enum requestType {kSingleFile, kFileList};
		requestType		fType;
		std::wstring	fPath; // filename if kSingleFile, path if kFileList
		std::wstring	fExt; // blank if kSingleFile, extension if kFileList
	};
	std::vector<fileRequest> fRequests;

	struct fileInfo
	{
		std::wstring	fOriginalNameAndPath; // the human-readable name
		std::wstring	fGarbledNameAndPath; // the garbled temp name of the file on disk
		UInt32			fSizeInBytes; // the total size of the file
		bool			fDownloading; // is this file currently downloading?
		bool			fDownloaded; // is this file completely downloaded?
		bool			fLocal; // is the file a local copy?
	};
	std::map<std::wstring, fileInfo> fFileInfoMap; // key is human-readable name
	std::map<std::wstring, hsStream*> fD2DStreams; // direct-to-disk streams, only used while downloading from the server

	UInt32 fNumInfoRequestsRemaining; // the number of file info requests that are still pending
	UInt32 fNumDownloadRequestsRemaining; // the number of file download requests that are still pending
	UInt32 fTotalDataDownload; // the amount of data we need to download, for progress bar tracking
	UInt32 fTotalDataReceived; // the amount of data we have already preloaded, for progress bar tracking
	bool   fNetError;
	bool   fInitialized;

	UInt32 fEncryptionKey[4]; // encryption key for all the secure files

	plOperationProgress* fProgressBar;

	void IIssueDownloadRequests ();
	void IPreloadComplete ();

	void ICleanupStreams(); // closes and deletes all streams

	void INotifyAuthReconnected ();
	
	pfSecurePreloader ();

public:
	CLASSNAME_REGISTER(pfSecurePreloader);
	GETINTERFACE_ANY(pfSecurePreloader, hsKeyedObject);

	~pfSecurePreloader ();
	
	void Init ();
	void Shutdown ();

	// Client interface functions
	void RequestSingleFile(std::wstring filename); // queues a single file to be preloaded (does nothing if already preloaded)
	void RequestFileGroup(std::wstring dir, std::wstring ext); // queues a group of files to be preloaded (does nothing if already preloaded)
	void Start(); // sends all queued requests (does nothing if already preloaded)
	void Cleanup(); // closes all file pointers and cleans up after itself

	// Functions for the network callbacks
	void RequestFinished(const std::vector<std::wstring> & filenames, const std::vector<UInt32> & sizes, bool succeeded);
	void UpdateProgressBar(UInt32 bytesReceived);
	void FinishedDownload(std::wstring filename, bool succeeded);

	// Instance handling
	static pfSecurePreloader * GetInstance ();
	static bool IsInstanced ();

	// hsKeyedObject
	hsBool MsgReceive (plMessage * msg);
};

#endif // __pfSecurePreloader_h__