/*
* Copyright (c) 2003-2009 Nokia Corporation and/or its subsidiary(-ies).
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of the License "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: 
*
*/


#include <caf/caf.h>
#include <caf/cafpanic.h>
#include <caf/dirstreamable.h>
#include "f32agentmanager.h"
#include "f32defaultattributes.h"
#include <caf/f32agentui.h>

using namespace ContentAccess;

CF32AgentManager* CF32AgentManager::NewL()
	{
	CF32AgentManager* self=new(ELeave) CF32AgentManager();
	CleanupStack::PushL(self);
	self->ConstructL();
	CleanupStack::Pop(self);
	return self;
	}

CF32AgentManager::CF32AgentManager()
	{
	}

CF32AgentManager::~CF32AgentManager()
	{
	delete iFileMan;
	iFs.Close();
	}
  
void CF32AgentManager::ConstructL()
	{
	User::LeaveIfError(iFs.Connect());
	iFileMan = CFileMan::NewL(iFs);
	}

TBool CF32AgentManager::IsRecognizedL(const TDesC&, TContentShareMode) const
	{
	// F32 should be the default agent and should never be called here
	return EFalse;
	}

TBool CF32AgentManager::IsRecognizedL(RFile& ) const
	{
	return EFalse;
	}	

TBool CF32AgentManager::RecognizeFileL(const TDesC&, const TDesC8&, TDes8&, TDes8&) const
	{
	// F32 should be the default agent and should never be called here
	return EFalse;
	}

TInt CF32AgentManager::DeleteFile(const TDesC &aFileName)
	{
	TInt err = KErrNone;
	CF32AgentUi* ui = NULL;
	TBool enableDelete = ETrue;
	
	// get a pointer to the UI
	TRAP(err, ui = &AgentUiL());
	if(err == KErrNone)
		{
		// UI confirmation supported, see if user wants to delete
		TRAP(err, enableDelete = ui->ConfirmDeleteL(aFileName));
		if(err == KErrNone && enableDelete)
			{
			// User agrees to delete
			err = iFs.Delete(aFileName);
			}
		}
	else if(err == KErrCANotSupported)
		{
		// UI is not supported, just delete it
		err = iFs.Delete(aFileName);
		}
	return err;
	}

TInt CF32AgentManager::CopyFile(const TDesC& aSource, const TDesC& aDestination)
	{
	return iFileMan->Copy(aSource, aDestination);
	}

TInt CF32AgentManager::CopyFile(RFile& aSource, const TDesC& aDestination)
	{
	return iFileMan->Copy(aSource, aDestination);
	}

TInt CF32AgentManager::RenameFile(const TDesC& aSource, const TDesC& aDestination)
	{
	TInt result = iFileMan->Rename(aSource, aDestination); 
	// If the files are on a different drive, Rename will fail 
	// Therefore we simulate the Move by doing a Copy, followed by Delete 
	if (result != KErrNone) 
		{ 
		result = iFileMan->Copy(aSource,aDestination); 
		if (result == KErrNone) 
			{ 
			// If the copy was successful try and delete the original 
			result = iFileMan->Delete(aSource); 
			if (result != KErrNone) 
				{
				 // Delete failed so try to cleanup the destination file as we're going to exit with an error 
				// We can safely ignore any error from this as the previous error is more important to propagate, since this is just cleanup
				iFileMan->Delete(aDestination); 
				} 
			} 
		} 
	return result; 
	}	

TInt CF32AgentManager::MkDir(const TDesC& aPath)
	{
	return iFs.MkDir(aPath);
	}

TInt CF32AgentManager::MkDirAll(const TDesC& aPath)
	{
	return iFs.MkDirAll(aPath);
	}

TInt CF32AgentManager::RmDir(const TDesC& aPath)
	{
	return iFs.RmDir(aPath);
	}

TInt CF32AgentManager::RenameDir(const TDesC& aOldName, const TDesC& aNewName)
	{
	return iFs.Rename(aOldName, aNewName);
	}

TInt CF32AgentManager::GetDir(const TDesC& aName,TUint aEntryAttMask,TUint aEntrySortKey, CDir*& aEntryList) const
	{
	return iFs.GetDir(aName, aEntryAttMask, aEntrySortKey, aEntryList);
	}

TInt CF32AgentManager::GetDir(const TDesC& aName,TUint aEntryAttMask,TUint aEntrySortKey, CDir*& aEntryList,CDir*& aDirList) const 
	{
	return iFs.GetDir(aName, aEntryAttMask, aEntrySortKey, aEntryList, aDirList);
	}

TInt CF32AgentManager::GetDir(const TDesC& aName,const TUidType& aEntryUid,TUint aEntrySortKey, CDir*& aFileList) const 
	{
	return iFs.GetDir( aName, aEntryUid, aEntrySortKey, aFileList);
	}

TInt CF32AgentManager::GetAttribute(TInt aAttribute, TInt& aValue, const TVirtualPathPtr& aVirtualPath)
	{
	// check that the virtual path exists
	if(TF32DefaultAttributes::CheckVirtualPath(aVirtualPath) != KErrNone)
		{
		return KErrNotFound;	
		}
		
	return TF32DefaultAttributes::GetAttribute(aAttribute, aValue, aVirtualPath.URI());
	}

TInt CF32AgentManager::GetAttributeSet(RAttributeSet& aAttributeSet, const TVirtualPathPtr& aVirtualPath)
	{
	// check that the virtual path exists
	if(TF32DefaultAttributes::CheckVirtualPath(aVirtualPath) != KErrNone)
		{
		return KErrNotFound;	
		}
		
	return TF32DefaultAttributes::GetAttributeSet(aAttributeSet, aVirtualPath.URI());
	}

TInt CF32AgentManager::GetStringAttribute(TInt aAttribute, TDes& aValue, const TVirtualPathPtr& aVirtualPath) 
	{
	// check that the virtual path exists
	if(TF32DefaultAttributes::CheckVirtualPath(aVirtualPath) != KErrNone)
		{
		return KErrNotFound;	
		}
		
	return TF32DefaultAttributes::GetStringAttribute(aAttribute, aValue, aVirtualPath.URI());
	}

TInt CF32AgentManager::GetStringAttributeSet(RStringAttributeSet& aAttributeSet, const TVirtualPathPtr& aVirtualPath) 
	{
	// check that the virtual path exists
	if(TF32DefaultAttributes::CheckVirtualPath(aVirtualPath) != KErrNone)
		{
		return KErrNotFound;	
		}
		
	return TF32DefaultAttributes::GetStringAttributeSet(aAttributeSet, aVirtualPath.URI());
	}

TInt CF32AgentManager::GetAttribute(TInt aAttribute, TInt& aValue, RFile& aFile, const TDesC& aUniqueId)
	{
	// Check that the client hasn't specified some incorrect UniqueId
	if(TF32DefaultAttributes::CheckUniqueId(aUniqueId) != KErrNone)
		{
		return KErrNotFound;
		}
		
	return TF32DefaultAttributes::GetAttribute(aAttribute, aValue, aFile);
	}

TInt CF32AgentManager::GetAttributeSet(RAttributeSet& aAttributeSet, RFile& aFile, const TDesC& aUniqueId)
	{
	// Check that the client hasn't specified some incorrect UniqueId
	if(TF32DefaultAttributes::CheckUniqueId(aUniqueId) != KErrNone)
		{
		return KErrNotFound;
		}
		
	return TF32DefaultAttributes::GetAttributeSet(aAttributeSet, aFile);
	}
	
TInt CF32AgentManager::GetStringAttributeSet(RStringAttributeSet& aStringAttributeSet, RFile& aFile, const TDesC& aUniqueId)
	{
	// Check that the client hasn't specified some incorrect UniqueId
	if(TF32DefaultAttributes::CheckUniqueId(aUniqueId) != KErrNone)
		{
		return KErrNotFound;
		}
		
	return TF32DefaultAttributes::GetStringAttributeSet(aStringAttributeSet, aFile);
	}
	
TInt CF32AgentManager::GetStringAttribute(TInt aAttribute, TDes& aValue, RFile& aFile, const TDesC& aUniqueId)
	{
	// Check that the client hasn't specified some incorrect UniqueId
	if(TF32DefaultAttributes::CheckUniqueId(aUniqueId) != KErrNone)
		{
		return KErrNotFound;
		}

	return TF32DefaultAttributes::GetStringAttribute(aAttribute, aValue, aFile);
	}		


void CF32AgentManager::NotifyStatusChange(const TDesC& , TEventMask , TRequestStatus& aStatus) 
	{
	TRequestStatus* ptr = &aStatus;
	User::RequestComplete(ptr, KErrCANotSupported);
	}

TInt CF32AgentManager::CancelNotifyStatusChange(const TDesC& , TRequestStatus& ) 
	{
	return KErrCANotSupported;
	}

TInt CF32AgentManager::SetProperty(TAgentProperty aProperty, TInt aValue)
	{
	if(aProperty==EAgentPropertyAgentUI)
		// should only pass type EAgentPropertyAgentUI 
		{
		
		CF32AgentUi* ui = NULL;
		// get a pointer to the UI
		TRAPD(err, ui = &AgentUiL());
		if(err)
			{
			return err;
			}
		return ui->SetProperty(aProperty, aValue);
		}
	else
		{
		return KErrCANotSupported;
		}
	}

void CF32AgentManager::DisplayInfoL(TDisplayInfo aInfo, const TVirtualPathPtr& aVirtualPath) 
	{
#ifdef SYMBIAN_ENABLE_64_BIT_FILE_SERVER_API
	RFile64 file;
#else
	RFile file;
#endif // SYMBIAN_ENABLE_64_BIT_FILE_SERVER_API

	// Check that the client hasn't specified some incorrect UniqueId
	User::LeaveIfError(TF32DefaultAttributes::CheckUniqueId(aVirtualPath.UniqueId()));

	// Open the file as read only
	User::LeaveIfError(file.Open(iFs, aVirtualPath.URI(), EFileShareReadersOnly | EFileStream | EFileRead));
	CleanupClosePushL(file);
	AgentUiL().DisplayInfoL(aInfo, file);
	CleanupStack::PopAndDestroy(&file);
	}

void CF32AgentManager::DisplayInfoL(TDisplayInfo aInfo, RFile& aFile, const TDesC& aUniqueId) 
	{
	// Check that the client hasn't specified some incorrect UniqueId
	User::LeaveIfError(TF32DefaultAttributes::CheckUniqueId(aUniqueId));

	// Open the file as read only
	AgentUiL().DisplayInfoL(aInfo, aFile);
	}


TInt CF32AgentManager::AgentSpecificCommand(TInt , const TDesC8& , TDes8& )
	{
	return KErrCANotSupported;
	}

void CF32AgentManager::AgentSpecificCommand(TInt , const TDesC8& , TDes8& , TRequestStatus& aStatus) 
	{
	TRequestStatus* ptr = &aStatus;
	User::RequestComplete(ptr, KErrCANotSupported);
	}

void CF32AgentManager::DisplayManagementInfoL() 
	{
	User::Panic(KCafPanicString, ECafPanicF32AgentManagementInfoNotSupported);
	}

CF32AgentUi& CF32AgentManager::AgentUiL()
	{
	if(!iAgentUi)
		{
		iAgentUi = TF32AgentUiFactory::CreateF32AgentUiL();
		}
	return *iAgentUi;
	}

void CF32AgentManager::PrepareHTTPRequestHeaders(RStringPool& /*aStringPool*/, RHTTPHeaders& /*aRequestHeaders*/) const
	{
	User::Panic(KCafPanicString, ECafPanicF32AgentPrepareHTTPHeadersNotSupported);
	}
