/*
* Copyright (c) 2007-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: 
* Implements the UPS database handle manager.  See class and function
* definitions for more information.
*
*/


/**
 @file
*/
#include <f32file.h>
#include "upscommon.h"
#include <ups/upsdbw.h>
#include "upsdbmanager.h"

namespace UserPromptService
{

RUpsDbHandleMaster::RUpsDbHandleMaster(RFs &aFs)
/**
	Construct the handle master

	This class should be used for synchronous database operations.

	If you need to do asynchronous operations then create/use an instance of the RUpsDbHandleSlave
	linked to the master.

	If your database operation fails, particularly due to OOM, then you should call Close your handle. You probably
	do NOT need to explicitly re-open it - it will automatically re-open when the -> operator is used.

	Note that the -> operator may leave.
*/
	: iFs(aFs), iDatabase(0), iClientListHead(0)
	{
	}

RUpsDbHandleMaster::~RUpsDbHandleMaster()
/**
	Destroy the handle master
*/
	{
	ASSERT(iClientListHead == 0); // Should be no clients!!!!
	Close(); // Deletes iDatabase...
	iClientListHead = 0;
	// Do NOT close the iFs (it is a reference to the main server's handle).
	}

_LIT(KDatabaseFile,"?:\\private\\10283558\\database\\ups.db");
void RUpsDbHandleMaster::OpenL()
/**
	Open the database handle

       It is probably clearer to explictly call this function to open the handle before first use, but the -> operator will
       auto-open it if called on a closed handle. Note that the -> operator can leave.

	If any database operation fails, particularly due to OOM, then you should Close your handle. Instead of 
	immediately re-opening it, it is generally safer to let it auto-reopen when the -> operator is next called.

*/
	{
	BULLSEYE_OFF
	if(iDatabase != 0)
		{
		// Close/delete the existing database handle.
		Close();
		}
	BULLSEYE_RESTORE

	// Open up a new handle.
	TFileName databaseFileBuf = KDatabaseFile();

	databaseFileBuf[0] = iFs.GetSystemDriveChar();
	TParsePtrC databaseFile(databaseFileBuf);

	// Make sure the dir exists
	(void)iFs.MkDirAll(databaseFile.DriveAndPath());
	// Create/Open the database
	iDatabase = CDecisionDbW::NewL(databaseFile.FullName(), iFs);
	}

void RUpsDbHandleMaster::Close()
/**
	Notify all client handles that the master (real) database handle is about to be closed, and then close it.
*/
	{
	// Notify all registered clients that we are about to delete the database handle
	RUpsDbHandleSlave *p = iClientListHead;
	while(p)
		{
		ASSERT(p->iClient != 0);
		p->iClient->DbHandleAboutToBeDeleted();
		p = p->iClientListNext;
		}

	// Delete database handle
	delete iDatabase;
	iDatabase = 0;
	}

TBool RUpsDbHandleMaster::IsOpen() const
/**
	Returns true if the handle is already open.
*/
	{
	return iDatabase != 0;
	}

CDecisionDbW *RUpsDbHandleMaster::operator->()
/**
	Returns the database handle so -> can be used on an RUpsDbHandleMaster instance to call database functions

	If the database is not already open then it calls OpenL.

	This operator CAN leave.
*/
	{
	if(iDatabase == 0)
		{
		OpenL();
		}
	return iDatabase;
	}

void RUpsDbHandleMaster::Register(RUpsDbHandleSlave *aClient)
/**
	Register new client with us.
*/
	{
	BULLSEYE_OFF
	if(aClient == 0)
		{
		return;
		}
	BULLSEYE_RESTORE
		
	aClient->iClientListNext = iClientListHead;
	iClientListHead = aClient;
	}

void RUpsDbHandleMaster::UnRegister(RUpsDbHandleSlave *aClient)
/**
	UnRegister client with us.
*/
	{
	RUpsDbHandleSlave **pp = &iClientListHead;
BULLSEYE_OFF
	while(*pp)
		{
BULLSEYE_RESTORE
		if(*pp == aClient)
			{
			// Found ptr to client, so remove it.
			*pp = (*pp)->iClientListNext;
			aClient->iClientListNext = 0;
			break;
			}
		pp = &(*pp)->iClientListNext;
		}
	}



RUpsDbHandleSlave::RUpsDbHandleSlave(RUpsDbHandleMaster & aMaster, MDbHandleClient * aClient)
/**
	Initialise new client and register it with the RUpsDbHandleMaster

	This class is intended for use when asynchronous database operations are being performed. These may then be failed
	due to another database operation failing, BUT the asycnhronous operation classes (eg. a db view) needs deleting
	before the actual database handle is deleted/re-created.
*/
	: iInUse(EFalse), iMaster(aMaster), iClient(aClient), iClientListNext(0)
	{
	ASSERT(aClient != 0);
	//RDebug::Printf("RUpsDbHandleSlave(%x, %x) - %x\n", &aMaster, aClient, this);
	}

RUpsDbHandleSlave::~RUpsDbHandleSlave()
	{
	//RDebug::Printf("~RUpsDbHandleSlave() master %x client %x - %x\n", &iMaster, iClient, this);
	Close();
	}

CDecisionDbW *RUpsDbHandleSlave::operator->()
/**
	Returns the database handle so -> can be used on an RUpsDbHandleMaster instance to call database functions

	If the database is not already open, then the master will open it.

	This operator CAN leave.
*/
	{
	if(!iInUse)
		{
		iMaster.Register(this);
		iInUse = ETrue;
		}
	return iMaster.operator->();
	}

void RUpsDbHandleSlave::SetCallback(MDbHandleClient *aClient)
/**
	Change what callback should be run if the master handle is closed.
	Do NOT set it to 0.
*/
	{
	ASSERT(aClient != 0);
	//RDebug::Printf("RUpsDbHandleSlave::SetCallback client %x - %x\n", aClient, this);
	iClient = aClient;
	}

void RUpsDbHandleSlave::Close()
/**
	Close this slave handle. This does NOT close the master, it just means we de-register with the
	master to we are no longer notified if the master is closed.
	It will automatically re-register if the -> operator is subsequently used.
*/
	{
	if(iInUse)
		{
		iMaster.UnRegister(this);
		iInUse = 0;
		}
	}

void RUpsDbHandleSlave::CloseMaster()
/**
	Notify all client handles that the master (real) database handle is about to be closed, and then close it.

	Typically used after a database error (particularly OOM) in an attempt to recover. Usually the database is not 
	explicitly re-opened, instead the re-open is defered until the next use of the -> operator on either tha master
	or a client handle.
*/
	{
		Close();
		iMaster.Close();
	}


} // End of UserPromptService namespace

// End of file