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

// Implementation of comms database session functions

// dealing with :

// session creation and destruction

// data version checking

// transaction management

// containment of helper classes for notification, mapping, database interaction etc    

// 

//

/**

 @file 

 @internalComponent

*/

#include "CommsDatInternalDefs.h"

//#include <commsdattypeinfov1_1.h>

#include <comms-infras/commsdatschema.h>

#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS

#include <commsdat_partner.h>

#endif

/**

   Last 4 digits of binary UID. This number has no meaning,

   but must be something that is very unlikely to be used by real

   fields in a database.

*/

#define MEANINGLESS_NUMBER 0x4DDB 

using namespace CommsDat; 

using namespace CommsDatInternal;

//

// Utilities for comparing items in arrays

TInt InsertNode(const TUint32& aFirst, const TUint32& aSecond)

/*

Utility function to find node in array

@internalComponent

*/

    {

    TUint mask = KCDMaskShowField | KCDUtilityFlag;

    if ((aFirst & mask ) == (aSecond & mask))

        return 0;

    if ((aFirst & mask) < (aSecond & mask))

        return -1;

     return 1;

    }

TBool FindNode(const TUint32& aFirst, const TUint32& aSecond)

/*

Utility function to find node in array

@internalComponent

*/

    {

    TUint mask = KCDMaskShowField | KCDUtilityFlag;    

    return (aFirst & mask ) == (aSecond & mask);

    }

TBool CompareElements(const CMDBElement& aFirst, const CMDBElement& aSecond)

/*

Utility function to compare elements in array

@internalComponent

*/

    {

    return  &aFirst == &aSecond;

    }

TInt InsertElements(const CMDBElement& aFirst, const CMDBElement& aSecond)

/*

Utility function to allow insertion of elements in array

@internalComponent

*/

    {

    if (&aFirst == &aSecond)

        return 0;

    if (&aFirst < &aSecond)

        return -1;

    return 1;

    }

TBool CompareElementsById(const CMDBElement& aFirst, const CMDBElement& aSecond)

/*

Utility function to compare elements in array by matching Table, Column and RecordId

@internalComponent

*/

    {

    return  (aFirst.ElementId() & KCDMaskShowField) == (aSecond.ElementId() & KCDMaskShowField);

    }

//

CMDBSessionImpl::CMDBSessionImpl(CMDBSession& aOwner)

/*

Constructor 

@internalComponent

*/

  : iOwner(aOwner), 

    iReadAttributeMask(KCDMaskShowReadAttributes),

    iWriteAttributeMask(KCDMaskShowReadWriteAttributes)

    {

    }

CMDBSessionImpl::~CMDBSessionImpl()

/*

Destructor

@internalComponent

*/

    {   

    Close();

    }

TInt CMDBSessionImpl::ConstructL( TVersion aRequiredVersion )

/*

Open a session with the storage server and compare data versions

The MetaDatabase always attempts to support the required version.  If the versions match,

KErrNone will be returned.  If the versions are not the same, but the requested version

is supported, a warning code will be returned. Otherwise an error will be 

returned.  The latest version is returned in the aLatestVersion parameter for information

@internalComponent

*/

    {

    if (iCommsStorage)

        {

        return KErrNone;

        }

    EstablishVersionL(aRequiredVersion); 

    // Connect to the repository

    iCommsStorage = ::CRepository::NewL(KCDCommsRepositoryId);

    // register for events

#ifndef __TOOLS2__

    TInt err = iCommitSeqProperty.Attach(KUidCommsDatStatusEvent, KCommsDatStatusEventCommitSeq);

    if (err != KErrNone)

        {

        __FLOG_STATIC1(KLogComponent, KCDErrLog, _L("CMDBSessionImpl::ConstructL() failed with error <%d>"), err);                                

        User::Leave(err);    

        }

#endif

    return KErrNone;

    }

void CMDBSessionImpl::Close()

/* 

Close session with storage server.

No session required with Central repository

@internalComponent

*/

    {

#ifndef __TOOLS2__

    TRAPD(

        err, 

        // Don't signal any roll-back, the reason we're performing a roll-back is because

        // the session is being CLOSED.

        NotifierL()->SuppressRollBackEvents();

        RollbackTransactionL();

        NotifierL()->NotifyClients(TCDNotifiableEvent::EClose);

        );

	err = err;	// suppress "unused-var" warning

    delete iNotifier;

    iNotifier=NULL;

#endif

#ifdef __TOOLS2__

	if (iCommsStorage)

		{

    		iCommsStorage->Flush();

		}

#endif

    delete iCommsStorage;

    iCommsStorage=NULL;    

	iCommitSeqProperty.Close();

    }

TBool CMDBSessionImpl::UsingLatestVersion()

/*

Check the flag that indicates whether using latest version

@internalComponent

*/

    {

    return iUsingLatestVersion;

    }

void CMDBSessionImpl::EstablishVersionL(TVersion aRequiredVersion)

/*

Check the version in use at the moment and set a flag if using latest version

Return an error code KErrDeprecated if version is deprecated

Return KErrNone if the version is current

MAINTENANCE - this function needs updating whenever the latest version changes

@internalComponent

*/

    {

#ifdef SYMBIAN_NON_SEAMLESS_NETWORK_BEARER_MOBILITY  

    if ( aRequiredVersion.iMajor == KCDVersion1_2.iMajor  &&

    	 aRequiredVersion.iMinor == KCDVersion1_2.iMinor  &&

    	 aRequiredVersion.iBuild == KCDVersion1_2.iBuild    )

	    {

        iClientsDataSetVersion = aRequiredVersion;

        iUsingLatestVersion = ETrue;

        __FLOG_STATIC3(KLogComponent, KCDInfoLog, _L("CMDBSessionImpl::EstablishVersionL()  Current dataset version <%d.%d.%d> in use.  Mapping disabled"), KCDVersion1_2.iMajor, KCDVersion1_2.iMinor, KCDVersion1_2.iBuild);

        return;

        }	       

	else if( (aRequiredVersion.iMajor == KCDVersion1_1.iMajor &&

			  aRequiredVersion.iMinor == KCDVersion1_1.iMinor &&

			  aRequiredVersion.iBuild == KCDVersion1_1.iBuild) ||

			  //the orig KCDLatesVersion was (0,0,0)

			 (aRequiredVersion.iMajor == 0 &&

			  aRequiredVersion.iMinor == 0 &&

			  aRequiredVersion.iBuild == 0) )

	    {

        iClientsDataSetVersion = KCDVersion1_1;

        iUsingLatestVersion = EFalse;

        __FLOG_STATIC3(KLogComponent, KCDInfoLog, _L("CMDBSessionImpl::EstablishVersionL()  Deprecated dataset version <%d.%d.%d> in use.  Mapping enabled"), aRequiredVersion.iMajor, aRequiredVersion.iMinor, aRequiredVersion.iBuild);

        return;

	    }

#else

	if( (aRequiredVersion.iMajor == KCDVersion1_1.iMajor &&

	     aRequiredVersion.iMinor == KCDVersion1_1.iMinor &&

	     aRequiredVersion.iBuild == KCDVersion1_1.iBuild) ||

		  //the orig KCDLatesVersion was (0,0,0)

		 (aRequiredVersion.iMajor == 0 &&

		  aRequiredVersion.iMinor == 0 &&

		  aRequiredVersion.iBuild == 0) )

	    {

        iClientsDataSetVersion = KCDVersion1_1;

        iUsingLatestVersion = ETrue;

        __FLOG_STATIC3(KLogComponent, KCDInfoLog, _L("CMDBSessionImpl::EstablishVersionL()  Current dataset version <%d.%d.%d> in use.  Mapping disabled"), aRequiredVersion.iMajor, aRequiredVersion.iMinor, aRequiredVersion.iBuild);

        return;

	    }

#endif    

    // MAINTENANCE - as versions are deprecated, allow them to still be used and return KCDDeprecatedVersion here.

    __FLOG_STATIC3(KLogComponent, KCDErrLog, _L("*** CMDBSessionImpl::EstablishVersionL()  Requested dataset version <%d.%d.%d> not supported"), aRequiredVersion.iMajor, aRequiredVersion.iMinor, aRequiredVersion.iBuild);

    User::Leave(KErrNotSupported);

    return;

    }

//

// Accessors

TVersion CMDBSessionImpl::LatestVersion()

/*

Lookup latest data format version

@Deprecated 

@internalComponent

*/

    {

    return KCDCurrentVersion;

    }

TVersion CMDBSessionImpl::VersionInUse()

/*

Lookup data format version currently in use by client

@internalComponent

*/

    {

    return iClientsDataSetVersion;

    }

CRepository* CMDBSessionImpl::StorageL()

/*

Return Storage class for Comms data

@internalComponent

*/

    {

    if (! iCommsStorage)

        {

        iCommsStorage = ::CRepository::NewL(KCDCommsRepositoryId);

        }

    return iCommsStorage;

    }

#ifndef __TOOLS2__

CCDNotifier* CMDBSessionImpl::NotifierL()

/*

return notifier object, creating it if necessary.

@internalComponent

*/

    {

    if (! iNotifier)

        {

        iNotifier = ::CCDNotifier::NewL(*this);

        }

    return iNotifier;

    }

#endif

//

//  TRANSACTIONS WITH THE DATABASE SERVER

//

TBool CMDBSessionImpl::MaybeOpenTransactionL()

/*

Start transaction with storage server if available

Returns ETrue if opens transaction

Returns EFalse if already in transaction

@internalComponent

*/

    {     

    TBool ownTransaction = EFalse;

    if ( ! iInTransaction )

        {

    	TInt err = StorageL()->StartTransaction(CRepository::EReadWriteTransaction); 

        if (err != KErrNone)

		    {

			__FLOG_STATIC1(KLogComponent, KCDErrLog, _L("CMDBSessionImpl::MaybeOpenTransactionL() - CentralRepository::StartTransactionL() failed with err = %d"), err);

            User::Leave(err);

            }

	    else

		    {

			iInTransaction = ETrue;

			ownTransaction = ETrue;

            }

		}

    return ownTransaction;

    }   

void CMDBSessionImpl::RollbackTransactionL()

/* 

Explicitly request rollback of transaction restoring database state to before transaction started.

@internalComponent

*/

    {

    if (iInTransaction)

	    {

		StorageL()->RollbackTransaction();

	    __FLOG_STATIC(KLogComponent, KCDInfoLog, _L("CMDBSessionImpl::RollbackTransactionL()  Has rolled back storage server Transaction "));

		iInTransaction = EFalse;

#ifndef __TOOLS2__

        //delete notifications if there are any

        NotifierL()->ClearPubSubNotifications();

        // Notify any clients.

        NotifierL()->NotifyClients(TCDNotifiableEvent::ERollback);

#endif

	    }

    }

TInt CMDBSessionImpl::MaybeCommitTransactionL(TBool aOwnTransaction, CMDBElement* aElement, TInt aErr)

/*

Commit transaction if outstanding and owned by caller

Rollback transaction if an error has occurred

Mapping and notification tasks may be required after commit

    Load/Find    ->  map  & sync

    Update       ->  map 

    Store/Modify ->  sync & notify       

    Delete       ->         notify 

@internalComponent

*/

    {  

    __FLOG_STATIC3(KLogComponent, KCDInfoLog, _L("CMDBSessionImpl::MaybeCommitTransactionL() aOwnTransaction = %b, aElementId = %08x, Err = %d"), aOwnTransaction, aElement ? aElement->ElementId() : 0, aErr);

    // Stop compiler complaining abot unused variables in UREL builds.

    (void)aElement;

	if (aErr != KErrNone)

	    {	

		__FLOG_STATIC2(KLogComponent, KCDErrLog, _L("CMDBSessionImpl::MaybeCommitTransactionL() Commit transaction for element <%08x> failed with error <%d>.  The transaction will be rolled back"), aElement ? aElement->ElementId() : 0, aErr);                                                  

		RollbackTransactionL();

        User::Leave(aErr);

        }

    TInt err(KErrNone);

    if ( aOwnTransaction && iInTransaction )

        {

  		TUint32 errLoc;

#ifndef __TOOLS2__

		// Update the global commit sequence. If we can't fetch the current one then we set it to the FastCounter() as a best effort

		// signal of change to observers

		TInt currCommitSeq;

        if(iCommitSeqProperty.Get(currCommitSeq) != KErrNone)

			{

			currCommitSeq = User::FastCounter();

			}

		iCommitSeqProperty.Set(currCommitSeq + 1);

#endif

        err = StorageL()->CommitTransaction(errLoc);

        if (err != KErrNone)  

            {

            __FLOG_STATIC2(KLogComponent, KCDErrLog, _L("CMDBSessionImpl::MaybeCommitTransactionL() CentralRepository::CommitTransaction failed with err = %d at %08x"), err, errLoc);

			RollbackTransactionL();

            User::Leave(err);

            }

#ifndef __TOOLS2__

        //notify any changes via pubsub if necessary

        NotifierL()->NotifyAllChanges();

        // Notify any clients.

        /*

        NOTE: Documented or not, our Licensees expect EUnlock notification to be returned if

        CommitTransaction didn't have anything to commit (probably because user container remained unchanged or

        the user used it as a read transaction). So we are to notify with ECommit, if and only the database actually changed.        

        This behaviour SHOULD not be changed without a BC break. Death, Destruction, rage, pillage and horror will follow if not.. 

        */

        if(errLoc > 0)

        	{

        	NotifierL()->NotifyClients(TCDNotifiableEvent::ECommit);	

        	}       	

        else

        	{

        	//errLoc will be 0 if the db wasn't changed..

        	NotifierL()->NotifyClients(TCDNotifiableEvent::EUnlock);	

        	}

#endif

        iInTransaction = EFalse;

        }

    return aErr;

    }

TBool CMDBSessionImpl::IsInTransaction()

/* 

Query if transaction is already underway in this session

@internalComponent

*/

    {

    //__FLOG_STATIC1(KLogComponent, KCDInfoLog, _L("IsInTransaction - returning = %b "), iInTransaction );

    return iInTransaction;

    }

void CMDBSessionImpl::SetAttributeMask(TMDBAttributeFlags aAttributeMask)

/*