// Copyright (c) 2002-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:

// f32test\ext\bitproxydrive.cpp

// extension to do XOR on every byte on 32 byte boundary read or written to media subsystem in same thread

// therefore RFile::Read/Write does not have this operation carried out on it

// 

//

#include <f32fsys.h>

class CBitExtProxyDrive : public CExtProxyDrive

	{

public:

	CBitExtProxyDrive(CMountCB* aMount, CExtProxyDriveFactory* aDevice);

	~CBitExtProxyDrive();

public:

	virtual TInt Initialise();

	virtual TInt Dismounted();

	virtual TInt Enlarge(TInt aLength);

	virtual TInt ReduceSize(TInt aPos, TInt aLength);

	virtual TInt Read(TInt64 aPos, TInt aLength, const TAny* aTrg, TInt aThreadHandle, TInt aOffset, TInt aFlags);

	virtual TInt Read(TInt64 aPos, TInt aLength, const TAny* aTrg, TInt aThreadHandle, TInt anOffset);

	virtual TInt Read(TInt64 aPos, TInt aLength, TDes8& aTrg);

	virtual TInt Write(TInt64 aPos, TInt aLength,const TAny* aSrc, TInt aThreadHandle, TInt aOffset, TInt aFlags);

	virtual TInt Write(TInt64 aPos, TInt aLength, const TAny* aSrc, TInt aThreadHandle, TInt anOffset);

	virtual TInt Write(TInt64 aPos,const TDesC8& aSrc);

	virtual TInt Caps(TDes8& anInfo);

	virtual TInt Format(TFormatInfo& aInfo);

	virtual TInt Format(TInt64 aPos,TInt aLength);

	virtual TInt SetInfo(const RMessage2 &msg, TAny* aMessageParam2, TAny* aMessageParam3);

	virtual TInt NotifyChange(TDes8 &aChanged,TRequestStatus* aStatus);

	virtual void NotifyChangeCancel();

    TInt SetMountInfo(const TDesC8* aMountInfo,TInt aMountInfoThreadHandle=KCurrentThreadHandle);

    TInt ForceRemount(TUint aFlags = 0);

    TInt Unlock(TMediaPassword& aPassword, TBool aStorePassword);

    TInt Lock(TMediaPassword& aOldPassword, TMediaPassword& aNewPassword, TBool aStorePassword);

    TInt Clear(TMediaPassword& aPassword);

    TInt ErasePassword();

	TInt GetInterface(TInt aInterfaceId,TAny*& aInterface,TAny* aInput);

private:

	TBusLocalDrive iDrive;

	TInt iLocalDriveNumber;

	TBool iChanged;

	TRequestStatus* iNotifyChangeStatus;

	};

class CBitProxyDriveFactory : public CExtProxyDriveFactory

	{

public:

	CBitProxyDriveFactory();

	~CBitProxyDriveFactory();

	virtual TInt Install();

	virtual TInt CreateProxyDrive(CProxyDrive*& aMountProxyDrive,CMountCB* aMount);

	};

CBitExtProxyDrive::CBitExtProxyDrive(CMountCB* aMount, CExtProxyDriveFactory* aDevice)

:   CExtProxyDrive(aMount,aDevice)

	{

	}

CBitExtProxyDrive::~CBitExtProxyDrive()

	{

	iDrive.Disconnect();

	}

/**

Initialise the proxy drive.

@return system wide error code.

*/

TInt CBitExtProxyDrive::Initialise()

	{

	TInt r = KErrNone;

    return r;

	}

TInt CBitExtProxyDrive::SetInfo(const RMessage2 &msg, TAny* /*aMessageParam2*/, TAny* /*aMessageParam3*/)

    {

	TInt r = KErrNone;

    TPckg<TInt> infoPckg(iLocalDriveNumber);

	TRAP(r, msg.ReadL(2, infoPckg));

	if(r != KErrNone)

		{

		RDebug::Print(_L("CBitExtProxyDrive::SetInfo(): cant read from the RMessage %d"), r);

		return r;

		}

	r = iDrive.Connect(iLocalDriveNumber, iChanged);

	if(r != KErrNone)

		{

		RDebug::Print(_L("CBitExtProxyDrive::SetInfo(): failed to connect to drive %d, r %d"), iDriveNumber, r);

		return r;

		}

    return r;

    }

TInt CBitExtProxyDrive::Dismounted()

	{

	TInt r = KErrNone;

    return r;

	}

TInt CBitExtProxyDrive::Enlarge(TInt /*aLength*/)

	{

	return KErrNotSupported;

	}

TInt CBitExtProxyDrive::ReduceSize(TInt /*aPos*/, TInt /*aLength*/)

	{

	return KErrNotSupported;

	}

TInt CBitExtProxyDrive::Read(TInt64 aPos, TInt aLength, const TAny* aTrg, TInt aThreadHandle, TInt aOffset)

	{

	TInt r = iDrive.Read(aPos, aLength, aTrg, aThreadHandle, aOffset);

    return r;

	}

TInt CBitExtProxyDrive::Read(TInt64 aPos, TInt aLength, const TAny* aTrg, TInt aThreadHandle, TInt aOffset, TInt aFlags)

	{

	TInt r = iDrive.Read(aPos, aLength, aTrg, aThreadHandle, aOffset, aFlags);

    return r;

	}

TInt CBitExtProxyDrive::Read(TInt64 aPos, TInt aLength, TDes8& aTrg)

	{

	TInt r = iDrive.Read(aPos, aLength, aTrg);

    return r;

	}

TInt CBitExtProxyDrive::Write(TInt64 aPos, TInt aLength, const TAny* aSrc, TInt aThreadHandle, TInt aOffset)

	{

	TInt r = iDrive.Write(aPos, aLength, aSrc, aThreadHandle, aOffset);

    return r;

	}

TInt CBitExtProxyDrive::Write(TInt64 aPos, TInt aLength, const TAny* aSrc, TInt aThreadHandle, TInt aOffset, TInt aFlags)

	{

	TInt r = iDrive.Write(aPos, aLength, aSrc, aThreadHandle, aOffset, aFlags);

    return r;

	}

TInt CBitExtProxyDrive::Write(TInt64 aPos,const TDesC8& aSrc)

	{

	TInt r = iDrive.Write(aPos, aSrc);

    return r;

	}

TInt CBitExtProxyDrive::Caps(TDes8& anInfo)

	{

	TLocalDriveCapsV6Buf caps;

    caps.FillZ();

//    TLocalDriveCapsV6& c = caps();

	TInt r = iDrive.Caps(caps);

	caps.SetLength( Min(caps.Length(), anInfo.MaxLength()) );

	anInfo.Copy(caps);

	return r;

	}

TInt CBitExtProxyDrive::Format(TInt64 aPos, TInt aLength)

	{

	TInt r = iDrive.Format(aPos, aLength);

    return r;

	}

TInt CBitExtProxyDrive::Format(TFormatInfo& aInfo)

	{

	TInt r = iDrive.Format(aInfo);

    return r;

    }

TInt CBitExtProxyDrive::NotifyChange(TDes8& /*aChanged*/, TRequestStatus* aStatus)

	{

//	iDrive.NotifyChange(aStatus);

	iNotifyChangeStatus = aStatus;

	return KErrNone;

	}

void CBitExtProxyDrive::NotifyChangeCancel()

	{

//	iDrive.NotifyChangeCancel();

	if (iNotifyChangeStatus)

		User::RequestComplete(iNotifyChangeStatus, KErrCancel);

	}

TInt CBitExtProxyDrive::SetMountInfo(const TDesC8* aMountInfo,TInt aMountInfoThreadHandle)

    {

	TInt r = iDrive.SetMountInfo(aMountInfo, aMountInfoThreadHandle);

    return r;

    }

TInt CBitExtProxyDrive::ForceRemount(TUint aFlags)

    {

	TInt r = iDrive.ForceRemount(aFlags);

    return r;

    }

TInt CBitExtProxyDrive::Unlock(TMediaPassword& aPassword, TBool aStorePassword)

    {

	TInt r = iDrive.Unlock(aPassword, aStorePassword);

    return r;

    }

TInt CBitExtProxyDrive::Lock(TMediaPassword& aOldPassword, TMediaPassword& aNewPassword, TBool aStorePassword)

    {

	TInt r = iDrive.SetPassword(aOldPassword, aNewPassword, aStorePassword);

    return r;

    }

TInt CBitExtProxyDrive::Clear(TMediaPassword& aPassword)

    {

	TInt r = iDrive.Clear(aPassword);

    return r;

    }

TInt CBitExtProxyDrive::ErasePassword()

    {

	TInt r = iDrive.ErasePassword();

    return r;

    }

TInt CBitExtProxyDrive::GetInterface(TInt aInterfaceId, TAny*& /*aInterface*/, TAny* /*aInput*/)

	{

	switch(aInterfaceId)

		{

		case ELocalBufferSupport:

			return KErrNone;

		default:

			return KErrNotSupported;

		}

	}

CBitProxyDriveFactory::CBitProxyDriveFactory()

	{

	}

CBitProxyDriveFactory::~CBitProxyDriveFactory()

	{

	}

TInt CBitProxyDriveFactory::Install()

	{

	_LIT(KProxyName,"bitproxydrive");

	return SetName(&KProxyName);

	}

TInt CBitProxyDriveFactory::CreateProxyDrive(CProxyDrive*& aMountProxyDrive,CMountCB* aMount)

	{

    aMountProxyDrive = new CBitExtProxyDrive(aMount,this);

    return (aMountProxyDrive==NULL) ? KErrNoMemory : KErrNone;

	}

extern "C" {

/* 

Create the proxy drive factory object for the usbhost mass storage proxy

*/

EXPORT_C CExtProxyDriveFactory* CreateFileSystem()

	{

	return new CBitProxyDriveFactory();

	}

}