// 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 "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:

// DBMS server: data source management and sharing classes

// 

//

#include "SD_STD.H"

extern const TDbDriver KBuiltinDriver;

// Class CDbsObserver::HObserver

// The server side of a RDbNotifier object

// All "observers" on the same database are held in a list on the

// primary CDbsObserver, which tracks the single notifier object

// on the data source.

inline CDbsObserver::HObserver::HObserver()

	:iPending(0)

	{}

//

// Complete the outstanding request, and reset the observer status

//

void CDbsObserver::HObserver::Complete(TInt aStatus)

	{

	iPending=0;

	iMessage.Complete(aStatus);

	}

//

// Notification request from the client

// Int0() has the notification type (CDbNotifier::TType)

//

void CDbsObserver::HObserver::Notify(const RMessage2& aMessage)

	{

	__ASSERT_ALWAYS(iPending>=0,Panic(EDbsObserverRequestPending));

	iMessage=aMessage;

	if (iPending>RDbNotifier::EUnlock)

		Complete(iPending);				// report any missed event first

	else if (iLink.iNext==&iLink)

		Complete(RDbNotifier::EClose);	// report a "closed" event

	else

		iPending=aMessage.Int0();		// wait for an event

	}

//

// Cancel the notification request (if pending)

//

void CDbsObserver::HObserver::Cancel()

	{

	if (iPending<0)

		Complete(KErrCancel);

	}

//

// An event occurs on the database

//

void CDbsObserver::HObserver::Event(TInt aEvent)

	{

	if (aEvent==RDbNotifier::EClose)

		{	// detach the observer when closed

		iLink.Deque();

		iLink.iPrev=iLink.iNext=&iLink;

		}

	TInt pending=iPending;

	if (pending<0)

		{	// request is pending

		if (aEvent==RDbNotifier::EUnlock && pending==CDbNotifier::EChange)

			;	// don't report unlock events to "change" requests

		else

			Complete(aEvent);

		}

	else if (aEvent>pending)

		iPending=aEvent;	// store more significant event

	}

//

// Client notifer is closed

//

CDbsObserver::HObserver::~HObserver()

	{

	Cancel();

	iLink.Deque();

	}

// Class CDbsObserver

// The central server-side observer active object for the database notifiers

// This maintains a list of all notifiers, and propogates events from the

// database source.

inline CDbsObserver::CDbsObserver(CDbsSource& aSource)

	:CActive(10),iSource(aSource),iQueue(_FOFF(HObserver,iLink))

	{}

CDbsObserver* CDbsObserver::NewL(CDbsSource& aSource)

	{

	CDbsObserver* self=new(ELeave) CDbsObserver(aSource);

	CleanupStack::PushL(self);

	self->iNotifier=aSource.Source().NotifierL();

	CActiveScheduler::Add(self);

	CleanupStack::Pop();	// self

	return self;

	}

//

// Used by the source to destroy the observer only when all client

// notifiers have been closed

//

CDbsObserver* CDbsObserver::Collect(CDbsObserver* aObserver)

	{

	if (!aObserver)

		return aObserver;

	if (!aObserver->iQueue.IsEmpty())

		return aObserver;

	delete aObserver;

	return 0;

	}

CDbsObserver::~CDbsObserver()

	{

	__ASSERT(iQueue.IsEmpty());

	CDbObject::Destroy(iNotifier);	// will cancel any request

	Cancel();

	}

//

// Create and initialise a new client-observer object

//

CDbsObserver::HObserver* CDbsObserver::ObserverL()

	{

	HObserver* observer=new(ELeave) HObserver;

	iQueue.AddLast(*observer);

	if (!IsActive())

		Queue();		// start receiving events

	return observer;

	}

//

// Request an event from the database

//

void CDbsObserver::Queue()

	{

	SetActive();

	iNotifier->Notify(CDbNotifier::EUnlock,iStatus);

	}

//

// Dispatch the event to all observers and re-queue

//

void CDbsObserver::RunL()

	{

	TDblQueIter<HObserver> iter(iQueue);

	for (HObserver* ob;(ob=iter++)!=0;)

		ob->Event(iStatus.Int());

	if (!iQueue.IsEmpty())

		Queue();

	else if (iStatus.Int()==RDbNotifier::EClose)

		iSource.Closed();	// disconnect and destroy on a close event

	}

//

// Provided fo CActive: should never have to do anything as called only

// via the d'tor which destroys the notifier first, completing the message

//

void CDbsObserver::DoCancel()

	{

	__ASSERT(iStatus!=KRequestPending);

	}

// Class CDbsDatabaseStub

// This class is used as a stub object between the two phases of

// authentication on a secure database

CDbsDatabaseStub* CDbsDatabaseStub::NewL()

	{

	return new(ELeave) CDbsDatabaseStub;

	}

//

// Authenticate the access, on success destroy this object and return the

// real database interface object

//

CDbDatabase* CDbsDatabaseStub::AuthenticateL()

	{

	CDbSource& src=CDbsConnection::Source(*this).Source();

	CDbDatabase* db=src.AuthenticateL();

	Attach(db);

	Destroy(this);

	return db;

	}

// Class CDbsConnection

// The context for all interface objects residing in the server, which

// owns a reference on the data source.

CDbsConnection::~CDbsConnection()

	{

	if (iSource)

		iSource->Close();

	}

// Class CDbsSource

// The sharing point for databases in the server, this maintains access

// to the CDbSource interface object, allowing multiple connections to the

// same database.

//

// Something has closed. Check if we are still needed, and delete if not

//

void CDbsSource::Closed()

	{

	__ASSERT(iConnections==0);

	iObserver=CDbsObserver::Collect(iObserver);

	if (!iObserver)

		delete this;

	}

//

// A connection has been removed

//

void CDbsSource::Close()

	{

	__ASSERT(iConnections>0);

	__ASSERT(iSource);

	if (--iConnections==0)

		{	// last connection is closed

		CDbSource* s=iSource;

		iSource=0;

		CDbObject::Destroy(s);

		iLink.Deque();			// cannot connect this source again

		Closed();

		}

	}

CDbsSource::~CDbsSource()

	{

	__ASSERT(!iSource);

	__ASSERT(!iObserver);

	delete iName;

	}

//

// Construct a new source object from a database using the driver discovery

//

CDbsSource* CDbsSource::NewL(RFs& aFs,const TDesC& aSource)

	{

    //The following two statements are here to check the file path and raise (if have to) 

    //the same errors as they were raised before by the previous (DbDriver related) source code.

	::TEntry fileEntry;

	__LEAVE_IF_ERROR(aFs.Entry(aSource, fileEntry));

	const TDbFormat& fmt=KBuiltinDriver.iFormats[0];

	CDbsSource* self=new(ELeave) CDbsSource(fmt);

	CleanupStack::PushL(self);

	self->iName=aSource.AllocL();

	self->iSource=fmt.OpenL(aFs,aSource,TDbFormat::EReadWrite);

	CleanupStack::Pop();	// self

	return self;

	}

//

// [Create and] return the active observer of the data source

//

CDbsObserver::HObserver* CDbsSource::ObserverL()

	{

	__ASSERT(iSource);

	CDbsObserver* observer=iObserver;

	if (!observer)

		iObserver=observer=CDbsObserver::NewL(*this);

	return observer->ObserverL();

	}

//

// Test to find an identical source, in order to share it

//

TBool CDbsSource::Is(const TDesC& aSource) const

	{

	if (iName->CompareF(aSource)!=0)

		return EFalse;

	  return ETrue;

	}

// Class RDbsSources

// The collection of all shared sources in the server

//

// Open a source for sharing

//

CDbsConnection* RDbsSources::OpenLC(RFs& aFs,const TDesC& aSource,const TDesC& /*aFormat*/)

	{

	CDbsConnection* connect=new(ELeave) CDbsConnection;

	CleanupStack::PushL(connect);

  // try and find the source already open

  	TIter iter(iSources);

  	CDbsSource* src;

  	for (;;)

  		{

  		src=iter++;

  		if (src==0)

  			{	// not already open, have to open a new source

  			src=CDbsSource::NewL(aFs,aSource);

  			iSources.AddFirst(*src);

  			break;

  			}

  		if (src->Is(aSource))

  			break;	// share this source

  		}

  // we have a source

	connect->Set(*src);

	return connect;

	}