/*

* Copyright (c) 2005 Nokia Corporation and/or its subsidiary(-ies). 

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of "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: Implementation of policymanagement components

*     

*

*/

// INCLUDE FILES

#include "PMRfsPlugin.h"

#include <rfsClient.h>

#include <PolicyEngineClient.h>

#include "DMUtilClient.h"

#include "CentRepToolClient.h"

#include "debug.h"

#ifdef RD_MULTIPLE_DRIVE

#include <driveinfo.h>

#include <pathinfo.h>

#include <s32file.h>

#endif //RD_MULTIPLE_DRIVE

#ifndef RD_MULTIPLE_DRIVE

_LIT( KScriptFormat_E, "z:\\private\\1020783F\\format_e_.txt");

#endif

_LIT( KDMUtilServerPrivatePath, "\\private\\10207843\\" );

_LIT( MDriveColon, ":");

_LIT( KMMCEraseFlagFileName, "fmmc.dat");

// ================= MEMBER FUNCTIONS =======================

// C++ default constructor can NOT contain any code, that

// might leave.

//

CPMRfsPlugin::CPMRfsPlugin()

    {

    RDEBUG("CPMRfsPlugin::CPMRfsPlugin()");

    }

CPMRfsPlugin::CPMRfsPlugin(TAny* /*aInitParams*/)

    {

    RDEBUG("CPMRfsPlugin::CPMRfsPlugin()");

    }

// Destructor

CPMRfsPlugin::~CPMRfsPlugin()

    {

   	RDEBUG("CPMRfsPlugin::~CPMRfsPlugin()");

    }

// ---------------------------------------------------------

// NewL

// ---------------------------------------------------------

//

CPMRfsPlugin* CPMRfsPlugin::NewL(TAny* aInitParams)

    {

    RDEBUG("CPMRfsPlugin::NewL()");

    CPMRfsPlugin* self = new (ELeave) CPMRfsPlugin(aInitParams);

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop();

    return self;

    }

// ---------------------------------------------------------

// ConstructL

// ---------------------------------------------------------

//

void CPMRfsPlugin::ConstructL()

    {

    RDEBUG("CPMRfsPlugin::ConstructL()");

    }

void CPMRfsPlugin::RestoreFactorySettingsL( const TRfsReason aType )

    {

    RDEBUG("CPMRfsPlugin::RestoreFactorySettingsL()");

    if( aType == ENormalRfs )

    	{

    	//Perform DMUtil RFS

    	RDEBUG("	-> CPMRfsPlugin: Perform DMUtil RFS ... ");

    	RDMUtil dmutil;

		User::LeaveIfError( dmutil.Connect() );

		CleanupClosePushL( dmutil );

    	User::LeaveIfError( dmutil.PerformRFS() );

		CleanupStack::PopAndDestroy( &dmutil );

		RDEBUG("	-> CPMRfsPlugin: Perform DMUtil RFS ... DONE!");

    	//Perform CentRepToolClient RFS

    	RDEBUG("	-> CPMRfsPlugin: Perform CentRepToolClient RFS ... ");

		RCentRepTool centRepTool;

		User::LeaveIfError( centRepTool.Connect() );

		CleanupClosePushL( centRepTool );

		User::LeaveIfError( centRepTool.PerformRFS() );

		CleanupStack::PopAndDestroy( &centRepTool );

		RDEBUG("	-> CPMRfsPlugin: Perform CentRepToolClient RFS ... DONE!");

		//Perform PolicyEngine RFS

		RDEBUG("	-> CPMRfsPlugin: Perform PolicyEngine RFS ... ");

		RPolicyEngine policyEngine;

		User::LeaveIfError( policyEngine.Connect() );

		CleanupClosePushL( policyEngine );

		User::LeaveIfError( policyEngine.PerformRFS() );

		CleanupStack::PopAndDestroy( &policyEngine );

		RDEBUG("	-> CPMRfsPlugin: Perform PolicyEngine RFS ... DONE!");

    	}

    RDEBUG("CPMRfsPlugin::RestoreFactorySettingsL() ... DONE!");

	}

void CPMRfsPlugin::GetScriptL( const TRfsReason /*aType*/, TDes& aPath )

    {

    RDEBUG("CPMRfsPlugin::GetScriptL()");

    if( IsMMCFormatFlagEnabledL() )

        {

        RDEBUG("CPMRfsPlugin::GetScriptL() - Format MMC flag enabled");

    #ifndef RD_MULTIPLE_DRIVE

        aPath.Copy( KScriptFormat_E );

    #else

    	aPath.Copy( iFileName);

    #endif

        }

    else

        {

        RDEBUG("CPMRfsPlugin::GetScriptL() - Format MMC flag disabled");

        }

    }

void CPMRfsPlugin::ExecuteCustomCommandL( const TRfsReason /*aType*/,

                                        TDesC& /*aCommand*/ )

    {

    RDEBUG("CPMRfsPlugin::ExecuteCustomCommandL()");

    }

TBool CPMRfsPlugin::IsMMCFormatFlagEnabledL()

	{

	RDEBUG("CPMRfsPlugin::IsMMCFormatFlagEnabledL()");

	RFs rfs;

	User::LeaveIfError( rfs.Connect() );

	CleanupClosePushL( rfs );	

#ifndef RD_MULTIPLE_DRIVE

	TFileName fullPath;

	fullPath.Append( _L("e") );

	fullPath.Append( MDriveColon );	

	fullPath.Append( KDMUtilServerPrivatePath );

	fullPath.Append( KMMCEraseFlagFileName );

	RFile file;

	TInt err = file.Open( rfs, fullPath, EFileRead );

	file.Close();

	CleanupStack::PopAndDestroy( &rfs );

	if( err == KErrNone )

		{

		RDEBUG("CPMRfsPlugin::IsMMCFormatFlagEnabled() - returned: ETrue");

		return ETrue;

		}

	RDEBUG_2("CPMRfsPlugin::IsMMCFormatFlagEnabled() - returned: EFalse: %d)", err);

	return EFalse;

#else

	TDriveList driveList;

	TInt driveCount;

	TBool fileReplace = EFalse;

	TInt err = KErrNone;

	//Get all removeable drive, both physically and logically

	User::LeaveIfError(DriveInfo::GetUserVisibleDrives(

            rfs,  driveList,  driveCount, KDriveAttRemovable ));

    TInt max(driveList.Length());

    RFileWriteStream file;

    for(TInt i=0; i<max;++i)

    {

    	if (driveList[i])

    	{

    		TUint status;

    		DriveInfo::GetDriveStatus(rfs, i, status);

    		//To make sure the drive is physically removeable not logically removeable	

    		//need to format internal mass memory also. So no need to check the below condition

    		//if (status & DriveInfo::EDriveRemovable)

    		{

    			TChar driveLetter;

    			rfs.DriveToChar(i,driveLetter);

				TFileName fullPath;

				fullPath.Append( driveLetter );

				fullPath.Append( MDriveColon );

				fullPath.Append( KDMUtilServerPrivatePath );

				fullPath.Append( KMMCEraseFlagFileName );

				RFile flagfile;

				err = flagfile.Open( rfs, fullPath, EFileRead );

				flagfile.Close();

				if( err == KErrNone )

				{

					if (!fileReplace)

					{

						User::LeaveIfError(file.Temp(rfs, _L("C:\\"),iFileName, EFileWrite));	

						file.WriteInt16L(65279);

						CleanupClosePushL(file);  

						fileReplace = ETrue;

						RDEBUG("CPMRfsPlugin::IsMMCFormatFlagEnabled() - File created on private path");

					}

					file.WriteL(_L("FORMAT"));

					file.WriteL(_L(" "));

					TBuf<4> DriveLetterBuf;

					DriveLetterBuf.Append(driveLetter);

					file.WriteL(DriveLetterBuf);

					file.WriteL(_L(":"));

					file.WriteL(_L("\r\n"));

				}

			}

    	}

     }

   	if (fileReplace)

   	{

   		file.CommitL();

   		CleanupStack::PopAndDestroy(); // pop file

   	}

	CleanupStack::PopAndDestroy( &rfs );	

     if (fileReplace)

     {

     	RDEBUG("CPMRfsPlugin::IsMMCFormatFlagEnabled() - returned: ETrue:");

     	return ETrue;

     }

     else

     {

     	RDEBUG_2("CPMRfsPlugin::IsMMCFormatFlagEnabled() - returned: EFalse: %d)", err);

     	return EFalse;

     }

#endif //RD_MULTIPLE_DRIVE

	}

// End of file