/*
* 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