// Copyright (c) 1998-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:
// f32\sfile\sf_disk.cpp
// 
//

#include "sf_std.h"

#if defined(_LOCKABLE_MEDIA)

LOCAL_C TInt DelayedWriter(TAny *aPtr);
LOCAL_C void DelayedWriterL(const TDelayedWriter *aDW);


EXPORT_C void WriteToDisk(const TDesC& aFileName, const TDesC8& aBuf)
// 
// Launches as separate thread that writes the contents of the pbus pswd
// store to disk.  It is possible that this function will be called again
// before the thread has finished writing.  In that case, a new thread
// will be created and it will wait on the global DelayedWriteSem semaphore.
// 
	{
	static TInt32 ctr = 0x00000000;				// ctr to create unique thd names
	
	__PRINT(_L("WriteToDisk"));
	__PRINT1(_L("wtd:afn%S"), &aFileName);

	TDelayedWriterInit dwi;
	dwi.iFileName = &aFileName;
	dwi.iData = &aBuf;

	// Create local semaphore this thread can wait on until the child thread has
	// made copies of the file name and the store data.

	__PRINT(_L("wtd:cr sem"));
	TBuf<3 + 8> semName;
	semName.Format(_L("dws%08x"), ctr++);
	dwi.iSemName = &semName;
	RSemaphore svrSem;
	if (svrSem.CreateGlobal(semName, 0) != KErrNone)
		return;

	// Spin off a thread with a unique name.

	__PRINT(_L("wtd:cr thd"));
	TName nm;
	nm.Format(_L("dw%08x"), ctr);
	RThread t;
	TInt hminsz = Max(KHeapMinSize, aFileName.Length() + aBuf.Length() + 1024);
	if (t.Create(
		nm, DelayedWriter, KDefaultStackSize,
		hminsz /* aHeapMinSize */, hminsz /* aHeapMaxSize */, &dwi) == KErrNone)
		{
		__PRINT(_L("wtd:set pri"));
		t.SetPriority(EPriorityMuchLess);		// run as low priority task
		__PRINT(_L("wtd:res"));
		t.Resume();
		__PRINT(_L("wtd:wait"));
		svrSem.Wait();
		__PRINT(_L("wtd:cls thd"));
		t.Close();								// get rid of our handle
		}
	
	__PRINT(_L("wtd:cls sem"));
	svrSem.Close();
	}


LOCAL_D TInt DelayedWriter(TAny *aPtr)
//
// Main thread function for thread that is spun off from WriteToDisk().
// After local copies of the data have been allocated (or failed), tell
// the server to continue.
// 
	{
	__PRINT(_L("DelayedWriter"));

	User::SetCritical(User::ESystemCritical);

	TInt r;

	TDelayedWriterInit *dwi = (TDelayedWriterInit *) aPtr;
	RSemaphore svrSem;							// signal svr when data copied
	CTrapCleanup *th = NULL;					// thread trap handler
	TDelayedWriter *dw = NULL;					// thread copy of data
	RSemaphore queueSem;						// queued delayed write threads

	// Allocate a trap handler.
	__PRINT(_L("dlw:alc tp"));
	if ((th = CTrapCleanup::New()) == NULL)
		{
		r = KErrNoMemory;
		goto cleanup;
		}

	// Make copies of the filename and store data.
	__PRINT(_L("dlw:cp dat"));
	TRAP(r, dw = TDelayedWriter::NewL(dwi));
	if (r != KErrNone)
		goto cleanup;
	
	// Tell file server made local copies of data and so can continue.
	__PRINT(_L("dlw:sg cp dat"));
	if ((r = svrSem.OpenGlobal(*dwi->iSemName)) != KErrNone)
		goto cleanup;
	svrSem.Signal();

	// Wait for the other store threads to finish.
	__PRINT(_L("dlw:wait"));
	if ((r = queueSem.OpenGlobal(_L("dwsem"))) != KErrNone)
		goto cleanup;
	queueSem.Wait();

	// Write the data and signal the global semaphore so follow up threads can run.
	__PRINT(_L("dlw:wrt"));
	TRAP(r, DelayedWriterL(dw));
	__PRINT1(_L("dlw:wrt r = %d"), r);
	queueSem.Signal();

cleanup:										// free any opened resources
	__PRINT(_L("dlw:cln"));
	svrSem.Close();
	delete th;
	delete dw;
	queueSem.Close();

	return KErrNone;
	}


LOCAL_D void DelayedWriterL(const TDelayedWriter *aDW)
//
// Replace any existing store file; write data and set file as hidden and system.
//
	{
	__PRINT(_L("DelayedWriterL"));

	RFs fs;										// connect to the file server
	CleanupClosePushL(fs);
	User::LeaveIfError(fs.Connect());

	RFile f;									// replace any existing file
	CleanupClosePushL(f);

	__PRINT(_L("dlw: opn"));

	// Create the directory if it doesn't already exist
	TInt r;
	r = fs.MkDirAll(*aDW->iFileName);
	if (r != KErrNone && r != KErrAlreadyExists)
		{
		__PRINT(_L("dlw: MkDirAll err"));
		User::Leave(r);
		}

	User::LeaveIfError(f.Replace(fs, *aDW->iFileName, EFileShareExclusive | EFileStream | EFileWrite));
	__PRINT(_L("dlw: wrt"));
	User::LeaveIfError(f.Write(*aDW->iData));
	__PRINT(_L("dlw: sat"));
#ifndef __WINS__								// cannot replace hidden | system file in WINS.
	User::LeaveIfError(f.SetAtt(KEntryAttHidden | KEntryAttSystem, 0x00000000));
#endif
	__PRINT(_L("dlw: dst"));
	CleanupStack::PopAndDestroy(2);				// f, fs
	}

//
// TDelayedWriter
// 

TDelayedWriter *TDelayedWriter::NewL(const TDelayedWriterInit *dwi)
//
// static
// Allocates a TDelayedWriter structure on the thread's heap that is used to
// persist the data that the writer thread will need during its lifetime.
// 
	{
	__PRINT(_L("TDelayedWriter::NewL"));

	TDelayedWriter *self = new(ELeave) TDelayedWriter();
	CleanupStack::PushL(self);
	self->ConstructL(dwi);
	CleanupStack::Pop();						// self
	return self;
	}


TDelayedWriter::TDelayedWriter()
	{
	__PRINT(_L("TDelayedWriter::TDelayedWriter"));

	// empty.
	}


void TDelayedWriter::ConstructL(const TDelayedWriterInit *dwi)
//
// 2y initialisation.  Makes own copy of filename and data.
// Fields are not popped onto CleanupStack because will be deleted in dtor
// 
	{
	__PRINT(_L("TDelayedWriter::ConstructL"));

	iFileName = dwi->iFileName->AllocL();
	iData = dwi->iData->AllocL();
	}

TDelayedWriter::~TDelayedWriter()
//
// dtor - frees filename and store data that was allocated in ConstructL().
//
	{
	__PRINT(_L("TDelayedWriter::~TDelayedWriter"));

	delete iFileName;							// alloc in ConstructL()
	delete iData;								// alloc in server
	}

#else

EXPORT_C void WriteToDisk(const TDesC& /*aFileName*/, const TDesC8& /*aBuf*/)
//
//
//
	{}

#endif