/*

* Copyright (c) 2008 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:   missed alarm store class description

*

*/

//Include files

#include "missedalarmstore.h"

#include "missedalarm.h"

#include "missedalarmstoreconstants.h"

#include "alarmenginesdebug.h"

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

// CMissedAlarmStore::NewLc

// 1st phase of construction

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

//

EXPORT_C CMissedAlarmStore* CMissedAlarmStore::NewLC()

    {

    TRACE_ENTRY_POINT;

    CMissedAlarmStore* self = new (ELeave) CMissedAlarmStore();

    CleanupStack::PushL(self);

    TRACE_EXIT_POINT;

    return self;

    }

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

// CMissedAlarmStore::NewL

// 1st phase of construction

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

//

EXPORT_C CMissedAlarmStore* CMissedAlarmStore::NewL(CRepository& aRepository)

    {

    TRACE_ENTRY_POINT;

    CMissedAlarmStore* self=new (ELeave) CMissedAlarmStore(aRepository);

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    TRACE_EXIT_POINT;

    return self;

    }

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

// CMissedAlarmStore::~CMissedAlarmStore

// Class destructor.Frees all resources used by this class

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

CMissedAlarmStore::~CMissedAlarmStore()

	{

	TRACE_ENTRY_POINT;

	if(iRepository)

	    {

	    delete iRepository;

	    iRepository = NULL;

	    }

	TRACE_EXIT_POINT;

	}

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

// CMissedAlarmStore::CMissedAlarmStore

// Default constructor

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

//

CMissedAlarmStore::CMissedAlarmStore()

    {

    TRACE_ENTRY_POINT;

    TRAP_IGNORE(iRepository = CRepository::NewL(KUidRepository));

    TRACE_EXIT_POINT;

    }

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

// CMissedAlarmStore::CMissedAlarmStore

// Default constructor

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

//

CMissedAlarmStore::CMissedAlarmStore(CRepository& aRepository)

    : iRepository(&aRepository)

    {

    TRACE_ENTRY_POINT;

    TRACE_EXIT_POINT;

    }

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

// CMissedAlarmStore::ConstructL

// Second stage constructor

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

//

void CMissedAlarmStore::ConstructL()

    {

    TRACE_ENTRY_POINT;

    TRACE_EXIT_POINT;

    }

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

// CMissedAlarmStore::AddL

// Add the list of CMissedAlarm in the Central Repository.

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

//

EXPORT_C void CMissedAlarmStore::AddL(RPointerArray<CMissedAlarm>& aMissedAlarmList)

	{

	TRACE_ENTRY_POINT;

	TUint count = aMissedAlarmList.Count();

	for( TUint i = 0; i < count; i++)

		{

		CMissedAlarm& missedalarm = *(aMissedAlarmList[i]);

		SetL( missedalarm.iLuid, missedalarm.iInstanceTime, missedalarm.iCalFileName );

		}

	TRACE_EXIT_POINT;

	}

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

// CMissedAlarmStore::GetL

// Gets the list of CMissedAlarm from the Central Repository.

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

//

EXPORT_C void CMissedAlarmStore::GetL(RPointerArray<CMissedAlarm> &aArray)

	{

	TRACE_ENTRY_POINT;

	RArray<TUint32> foundIds;

	TUint32 key;

	TInt err = 0;

	CMissedAlarm *missedalarm = NULL;

    TReal instanceTime;

    TInt luid;

    TBuf<256> calFileName;

	err = iRepository->FindL( KLuidPartialKey, KLuidMask, foundIds);

	TUint count = foundIds.Count();

	if( count && KErrNone == err)

	    {

	    for(TUint32 i =0; i < count; i++)

		    {

            key = foundIds[i];

            err = iRepository->Get( key, luid);

            if( KErrNone == err )

	            {

	            err = iRepository->Get( key | KTTimeShift, instanceTime );

	            if( KErrNone == err )

		            {

		            err = iRepository->Get( key | KCalFileNameShift, calFileName );

		            if( KErrNone == err )

		                {

                        missedalarm = CMissedAlarm::NewL( luid,

                                                        TTime(TInt64(instanceTime)), calFileName );

                        CleanupStack::PushL( missedalarm );

                        aArray.Append( missedalarm );

                        CleanupStack::Pop(missedalarm );

		                }

		            }

	            }

		    }

	    }

    foundIds.Reset();

    TRACE_EXIT_POINT;

	}

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

// CMissedAlarmStore::RemoveAllL

// Removes all the entries from the central repository.

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

//

EXPORT_C void CMissedAlarmStore::RemoveAllL()

	{

	TRACE_ENTRY_POINT;

	RArray<TUint32> foundIds;

	TUint32 key;

	TInt err = 0;

	err = iRepository->FindL( KLuidPartialKey, KLuidMask, foundIds);

	TUint count = foundIds.Count();

	if( count && KErrNone == err)

	    {

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

		    {

            key = foundIds[i];

            iRepository->Delete(key);

            iRepository->Delete(key | KTTimeShift);

            iRepository->Delete(key | KCalFileNameShift);

		    }

	    }

    foundIds.Reset();

    TRACE_EXIT_POINT;

	}

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

// CMissedAlarmStore::RemoveL

// Removes an entry from the central repository.

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

//

EXPORT_C void CMissedAlarmStore::RemoveL( CMissedAlarm& aMissedAlarm )

	{

	TRACE_ENTRY_POINT;

	RArray<TUint32> foundIds;

	TUint32 key;

	TInt err = 0;

	err = iRepository->FindEqL( KLuidPartialKey, KLuidMask, 

	                            aMissedAlarm.iLuid, foundIds );

	TUint count = foundIds.Count();

	TBool remAllLUids = EFalse;

	if( count && KErrNone == err)

	    {

		TReal instTime;

		TReal aInstTime = TReal( (aMissedAlarm.iInstanceTime).Int64());

		TBuf<256> calFileName;

		for( TUint j = 0; j < count; j++ )

			{

			key = foundIds[j];

			err = iRepository->Get( key | KTTimeShift, instTime );

			if( remAllLUids || 

			    ( KErrNone == err && aInstTime == instTime ))

				{

				err = iRepository->Get( key | KCalFileNameShift, calFileName );

				if( KErrNone == err && !aMissedAlarm.iCalFileName.CompareF( calFileName ) )

				    {

	                DeleteEntryAndReArrangeL( key );

	                foundIds.Reset();

				    }

				return;

				}

			}

	    }

    foundIds.Reset();

    TRACE_EXIT_POINT;

	}

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

// CMissedAlarmStore::CountL

// Counts the number of entries in the central repository.

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

//

EXPORT_C void CMissedAlarmStore::CountL(TUint32 &aCount)

	{

	TRACE_ENTRY_POINT;

	RArray<TUint32> foundIds;

	TInt err = 0;

	err = iRepository->FindL( KLuidPartialKey, KLuidMask, foundIds);

	if( KErrAbort == err || KErrPermissionDenied == err )

		{

		User::Leave( err );

		}

	aCount = foundIds.Count();

    foundIds.Reset();

    TRACE_EXIT_POINT;

	}

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

// CMissedAlarmStore::SetL

// Add the single entry in the Central Repository.

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

//

void CMissedAlarmStore::SetL( const TInt aLuid, const TTime aInstanceTime, const TDesC& aCalFileName)

	{

	TRACE_ENTRY_POINT;

	TUint32 keyId;

	RArray<TUint32> foundIds;

    TInt err = 0;

	err = iRepository->FindEqL( KLuidPartialKey, KLuidMask, aLuid, foundIds );

	TUint32 count = foundIds.Count();

	TReal istTime;

	TBuf<256> calFileName;

	for( TUint32 j = 0; j < count; j++ )

		{

		TUint32 val = foundIds[j];

		err = iRepository->Get( foundIds[j] | KTTimeShift, istTime );

		if( KErrNone == err && TReal( aInstanceTime.Int64()) == istTime )

			{

			err = iRepository->Get( foundIds[j] | KCalFileNameShift, calFileName );

			if( KErrNone == err && !calFileName.CompareF( aCalFileName ) )

			    {

                //entryexists = ETrue;

                foundIds.Reset();

                return;

			    }

			}

		}

	foundIds.Reset();    

	CountL(count);

	TUint32 key = count;

	if( count >= KMaxKeys )

		{

		DeleteEntryAndReArrangeL(0);

		key = KMaxKeys - 1;

		}

    // Begin read write transaction

    err = iRepository->StartTransaction(CRepository::EReadWriteTransaction);

  	// perform some write operations

	err = iRepository->Create(key, aLuid);

	err = iRepository->Create(key | KTTimeShift, TReal( aInstanceTime.Int64()) );

	err = iRepository->Create(key | KCalFileNameShift, aCalFileName );

	err = iRepository->CommitTransaction( keyId );

	if (err != KErrNone)

		{

		iRepository->FailTransaction();

		}

	TRACE_EXIT_POINT;

	}

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

// CMissedAlarmStore::DeleteEntryAndReArrangeL

// Delete old entry and insert new entry when the missed alarms count is more

// than 10 entries

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

//

void CMissedAlarmStore::DeleteEntryAndReArrangeL(TInt aDeletedIndex)

	{

	TRACE_ENTRY_POINT;

    TInt err;

    TUint32 keyInfo;

    TUint32 count = 0;

    CountL(count);    

    err = iRepository->StartTransaction(CRepository::EReadWriteTransaction);

    iRepository->CleanupCancelTransactionPushL();

    TInt idx = 0;

    for( idx = aDeletedIndex; idx < KMaxKeys-1 && idx < count-1; idx++ )

	    {

	    // Move the key to the target position

	    iRepository->Delete( idx );

	    iRepository->Delete( idx | KTTimeShift );

	    iRepository->Delete( idx | KCalFileNameShift );

	    err = User::LeaveIfError(iRepository->Move(idx+1, idx, 0xFFFFFFFF, keyInfo));

	    err = User::LeaveIfError(iRepository->Move((idx+1) | KTTimeShift,

	                            idx | KTTimeShift, 0xFFFFFFFF, keyInfo));

	    err = User::LeaveIfError(iRepository->Move((idx+1) | KCalFileNameShift,

	                                    idx | KCalFileNameShift, 0xFFFFFFFF, keyInfo));

	    }

    iRepository->Delete( idx );

    iRepository->Delete( idx | KTTimeShift );

    iRepository->Delete( idx | KCalFileNameShift );

    CleanupStack::Pop(); // transaction

    err = iRepository->CommitTransaction(keyInfo);

    User::LeaveIfError(err);

    TRACE_EXIT_POINT;

	}

// End of file