--- a/meetingrequest/mrdb/src/cesmrcaldbmgr.cpp Mon Mar 15 12:39:10 2010 +0200
+++ b/meetingrequest/mrdb/src/cesmrcaldbmgr.cpp Wed Mar 31 21:08:33 2010 +0300
@@ -1,5 +1,5 @@
/*
-* Copyright (c) 2005 Nokia Corporation and/or its subsidiary(-ies).
+* Copyright (c) 2005 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"
@@ -23,9 +23,9 @@
#include "cesmrentrycmditeratorao.h"
#include "esmrhelper.h"
#include "esmrentryhelper.h"
-//<cmail>
+#include "mesmrcalentry.h"
#include "mesmrutilstombsext.h"
-//</cmail>
+#include "mruidomaincrkeys.h"
// From System
#include <ct/rcpointerarray.h>
@@ -36,16 +36,48 @@
#include <calentry.h>
#include <calcommon.h>
#include <caluser.h>
-#include <CalenInterimUtils2.h>
+#include <caleninterimutils2.h>
+#include <sysutil.h>
+#include <errorui.h>
+#include <coemain.h>
+#include <calcalendarinfo.h>
+#include <centralrepository.h>
// CONSTANTS
// Unnamed namespace for local definitions
namespace {
-const TInt KDbInitReady = 100;
+const TInt KDbInitReady( 100 );
+
+/**
+ * Reads last used database index from central repository
+ *
+ * @param aIndex on return contains the last used database index
+ */
+void ReadDatabaseIndexL( TInt& aIndex )
+ {
+ FUNC_LOG;
-#ifdef _DEBUG
+ CRepository* repository = CRepository::NewLC( KCRUidESMRUIFeatures );
+ User::LeaveIfError( repository->Get( KMRUIDefaultCalDbIndex, aIndex ) );
+ CleanupStack::PopAndDestroy( repository );
+ }
+
+/**
+ * Writes used database index into central repository
+ *
+ * @param database index
+ */
+void WriteDatabaseIndexL( TInt aIndex )
+ {
+ FUNC_LOG;
+
+ CRepository* repository = CRepository::NewLC( KCRUidESMRUIFeatures );
+ User::LeaveIfError( repository->Set( KMRUIDefaultCalDbIndex, aIndex ) );
+ CleanupStack::PopAndDestroy( repository );
+ }
+
// Panic code definitions
enum TPanicCode
@@ -55,7 +87,9 @@
EPanicAsyncOpAlreadyExists,
EPanicIllegalEntryStatus,
EPanicIllegalResurrect,
- EPanicUnexpectedUidValue
+ EPanicUnexpectedUidValue,
+ EPanicLoadMultiDbInfoFail,
+ EPanicInvalidDbIndex
};
// Panic string definition
@@ -70,8 +104,6 @@
User::Panic( KPanicMsg, aReason );
}
-#endif // _DEBUG
-
} // namespace
@@ -94,7 +126,6 @@
self->ConstructL();
CleanupStack::Pop();
-
return self;
}
@@ -123,6 +154,12 @@
CESMRCalDbMgr::~CESMRCalDbMgr()
{
FUNC_LOG;
+
+ iCalInstanceViewArray.ResetAndDestroy();
+ iCalEntryViewArray.ResetAndDestroy();
+ iCalendarInfoArray.ResetAndDestroy();
+ iCalSessionArray.ResetAndDestroy();
+
delete iCmdIterator;
delete iNormalDb;
}
@@ -138,6 +175,9 @@
iNormalDb = CESMRCalDbNormal::NewL( iCalSession, *this, *this );
iCmdIterator = CESMREntryCmdIteratorAO::NewL( *this );
+ TRAPD( err, LoadMultiCalenInfoL() );
+ __ASSERT_ALWAYS( err == KErrNone, Panic( EPanicLoadMultiDbInfoFail ) );
+ User::LeaveIfError( err );
}
// ----------------------------------------------------------------------------
@@ -168,7 +208,6 @@
iObserver.HandleCalEngStatus( MMRUtilsObserver::ENotAvailable );
}
-
// In other cases either db is not yet finished
}
@@ -203,7 +242,6 @@
iObserver.HandleOperation( iCurrentAsyncOp, KDbInitReady, aError );
iCurrentAsyncOp = CMRUtils::ENoOperation;
-
}
// ----------------------------------------------------------------------------
@@ -227,6 +265,16 @@
}
// ----------------------------------------------------------------------------
+// CESMRCalDbMgr::NormalDbAllCalenInstanceView
+// ----------------------------------------------------------------------------
+//
+RPointerArray<CCalInstanceView> CESMRCalDbMgr::NormalDbAllCalenInstanceView()
+ {
+ FUNC_LOG;
+ return iCalInstanceViewArray;
+ }
+
+// ----------------------------------------------------------------------------
// CESMRCalDbMgr::FetchEntriesL
// ----------------------------------------------------------------------------
//
@@ -277,7 +325,6 @@
CleanupStack::PopAndDestroy(); // tmpFetchArray
-
return retVal;
}
@@ -293,15 +340,21 @@
TInt retVal( KErrNone );
- if(aToNormalDb)
+ if ( CheckSpaceBelowCriticalLevelL() )
{
- CCalenInterimUtils2::StoreL( *( iNormalDb->EntryView() ),
- aCalEntry,
- ETrue );
-
+ retVal = KErrNoMemory;
}
-
+ else
+ {
+ if( aToNormalDb )
+ {
+ CCalenInterimUtils2::StoreL( *(iCalEntryViewArray[iCurCalenIndex]),
+ aCalEntry,
+ ETrue );
+ WriteDatabaseIndexL( iCurCalenIndex );
+ }
+ }
return retVal;
}
@@ -319,10 +372,9 @@
calEntryTmpArray.AppendL( &aCalEntry );
TInt numSuccessfulEntry( 0 );
// entry view surely exists when status is 'available':
- iNormalDb->EntryView()->UpdateL( calEntryTmpArray, numSuccessfulEntry );
+ EntryViewL( aCalEntry )->UpdateL( calEntryTmpArray, numSuccessfulEntry );
TInt retVal( numSuccessfulEntry == 1 ? KErrNone : KErrGeneral );
- CleanupStack::PopAndDestroy(); // calEntryTmpArray, only close array
-
+ CleanupStack::Pop(); // calEntryTmpArray, only close array
return retVal;
}
@@ -331,7 +383,7 @@
// CESMRCalDbMgr::DeleteEntryL
// ----------------------------------------------------------------------------
//
-TInt CESMRCalDbMgr::DeleteEntryL( const TDesC8& aUid )
+TInt CESMRCalDbMgr::DeleteEntryL( const TDesC8& aUid, TInt aCalenIndex )
{
FUNC_LOG;
@@ -339,10 +391,9 @@
CleanupStack::PushL( uidArray );
uidArray->AppendL( aUid );
// entry view surely exists when status is 'available':
- iNormalDb->EntryView()->DeleteL( *uidArray );
+ iCalEntryViewArray[aCalenIndex]->DeleteL( *uidArray );
CleanupStack::PopAndDestroy( uidArray );
-
return KErrNone;
}
@@ -350,7 +401,7 @@
// CESMRCalDbMgr::DeleteEntryL
// ----------------------------------------------------------------------------
//
-TInt CESMRCalDbMgr::DeleteEntryL( const TCalLocalUid& aLocalUid )
+TInt CESMRCalDbMgr::DeleteEntryL( const TCalLocalUid& aLocalUid, TInt aCalenIndex )
{
FUNC_LOG;
@@ -358,7 +409,7 @@
CleanupClosePushL( localUidArray );
localUidArray.AppendL( aLocalUid );
TInt numSuccessfulEntry( 0 );
- iNormalDb->EntryView()->DeleteL( localUidArray, numSuccessfulEntry );
+ iCalEntryViewArray[aCalenIndex]->DeleteL( localUidArray, numSuccessfulEntry );
TInt retVal( numSuccessfulEntry == 1 ? KErrNone : KErrGeneral );
CleanupStack::PopAndDestroy(); // localUidArray
@@ -378,58 +429,64 @@
TBool aCheckOnly )
{
FUNC_LOG;
-
- RCPointerArray<CCalEntry> tmpFetchArray;
- CleanupClosePushL( tmpFetchArray );
-
MESMRUtilsTombsExt::TESMRUtilsDbResult entryStatus(
MESMRUtilsTombsExt::EUndefined );
- TInt index( -1 );
- // 1. Normal db part, if entry is found in there then tombstones aren't
- // checked at all:
+ if ( CheckSpaceBelowCriticalLevelL() )
+ {
+ entryStatus = MESMRUtilsTombsExt::EErrorCancelled;
+ }
+ else
+ {
+ RCPointerArray<CCalEntry> tmpFetchArray;
+ CleanupClosePushL( tmpFetchArray );
+
+ TInt index( -1 );
+
+ // 1. Normal db part, if entry is found in there then tombstones aren't
+ // checked at all:
- if ( EntryExistsInDbL( aCalEntry, *iNormalDb, tmpFetchArray, index ) )
- { // Entry exists in normal db
- entryStatus = EvaluateExistingEntryL( aCalEntry,
- *( tmpFetchArray[index] ) );
- if ( entryStatus == MESMRUtilsTombsExt::ECheckedValidUpdate &&
- !aCheckOnly )
- {
- StoreEntryL( aCalEntry );
- entryStatus = MESMRUtilsTombsExt::EStoredUpdate;
- }
- else if ( entryStatus == MESMRUtilsTombsExt::EErrorCancelled &&
- aResurrect )
- {
- __ASSERT_DEBUG( !aCheckOnly, Panic( EPanicIllegalResurrect ) );
- StoreEntryL( aCalEntry );
- entryStatus = MESMRUtilsTombsExt::EResurrectedCancelled;
- }
- // entry can't be new if it exists in the db already:
- __ASSERT_DEBUG( entryStatus != MESMRUtilsTombsExt::ECheckedValidNew,
- Panic( EPanicIllegalEntryStatus) );
- }
-
- // 2. New entry in this phone:
-
- else
- { // Completely new entry (or tombstone has disappeared)
- entryStatus = EvaluateNewEntryL( aCalEntry );
- if ( entryStatus == MESMRUtilsTombsExt::ECheckedValidNew && !aCheckOnly )
- {
- StoreEntryL( aCalEntry );
- entryStatus = MESMRUtilsTombsExt::EStoredNew;
+ if ( EntryExistsInDbL( aCalEntry, *iNormalDb, tmpFetchArray, index ) )
+ { // Entry exists in normal db
+ entryStatus = EvaluateExistingEntryL( aCalEntry,
+ *( tmpFetchArray[index] ) );
+ if ( entryStatus == MESMRUtilsTombsExt::ECheckedValidUpdate &&
+ !aCheckOnly )
+ {
+ StoreEntryL( aCalEntry );
+ entryStatus = MESMRUtilsTombsExt::EStoredUpdate;
+ }
+ else if ( entryStatus == MESMRUtilsTombsExt::EErrorCancelled &&
+ aResurrect )
+ {
+ __ASSERT_DEBUG( !aCheckOnly, Panic( EPanicIllegalResurrect ) );
+ StoreEntryL( aCalEntry );
+ entryStatus = MESMRUtilsTombsExt::EResurrectedCancelled;
+ }
+ // entry can't be new if it exists in the db already:
+ __ASSERT_DEBUG( entryStatus != MESMRUtilsTombsExt::ECheckedValidNew,
+ Panic( EPanicIllegalEntryStatus) );
}
- // entry can't be update if doesn't exist in the db already:
- __ASSERT_DEBUG( entryStatus != MESMRUtilsTombsExt::ECheckedValidUpdate,
- Panic( EPanicIllegalEntryStatus) );
+ // 2. New entry in this phone:
+
+ else
+ { // Completely new entry (or tombstone has disappeared)
+ entryStatus = EvaluateNewEntryL( aCalEntry );
+ if ( entryStatus == MESMRUtilsTombsExt::ECheckedValidNew && !aCheckOnly )
+ {
+ StoreEntryL( aCalEntry );
+ entryStatus = MESMRUtilsTombsExt::EStoredNew;
+ }
+
+ // entry can't be update if doesn't exist in the db already:
+ __ASSERT_DEBUG( entryStatus != MESMRUtilsTombsExt::ECheckedValidUpdate,
+ Panic( EPanicIllegalEntryStatus) );
+ }
+
+ CleanupStack::PopAndDestroy(); // tmpFetchArray
}
- CleanupStack::PopAndDestroy(); // tmpFetchArray
-
-
return entryStatus;
}
@@ -445,12 +502,18 @@
CleanupClosePushL( tmpFetchArray );
// 1. Delete all found entries from normal db:
-
- iNormalDb->EntryView()->FetchL( aUid, tmpFetchArray );
- DeleteEntryL( aUid );
+ TInt count = iCalEntryViewArray.Count();
+ for( TInt i(0); i < count; i++ )
+ {
+ iCalEntryViewArray[i]->FetchL( aUid, tmpFetchArray );
+ if( tmpFetchArray.Count() > 0 )
+ {
+ DeleteEntryL( aUid, i );
+ tmpFetchArray.ResetAndDestroy();
+ }
+ }
CleanupStack::PopAndDestroy(); // tmpFetchArray
-
}
// ----------------------------------------------------------------------------
@@ -461,14 +524,17 @@
{
FUNC_LOG;
- CCalEntry* entry = iNormalDb->EntryView()->FetchL( aLocalUid );
- if ( entry )
+ TInt count = iCalEntryViewArray.Count();
+ for( TInt i(0); i < count; i++ )
{
- CleanupStack::PushL( entry );
- DeleteEntryCondL( *entry );
- CleanupStack::PopAndDestroy( entry );
+ CCalEntry* entry = iCalEntryViewArray[i]->FetchL( aLocalUid );
+ if ( entry )
+ {
+ CleanupStack::PushL( entry );
+ DeleteEntryCondL( *entry );
+ CleanupStack::PopAndDestroy( entry );
+ }
}
-
}
// ----------------------------------------------------------------------------
@@ -483,14 +549,29 @@
{
// Modifying entry
// 1. Delete entry from normal db:
- iNormalDb->EntryView()->DeleteL( aCalEntry );
+
+ CCalInstance* instance = FindInstanceL( (CCalEntry&)aCalEntry );
+ CleanupStack::PushL( instance );
+ TInt colId = instance->InstanceIdL().iCollectionId;
+
+ TInt index = 0;
+ TInt count = iCalSessionArray.Count();
+ for( TInt i = 0; i < count; i++ )
+ {
+ if( colId == iCalSessionArray[i]->CollectionIdL() )
+ {
+ index = i;
+ break;
+ }
+ }
+ iCalEntryViewArray[index]->DeleteL( aCalEntry );
+ CleanupStack::PopAndDestroy( instance );
}
else
{ // Originating entry, this is the same case as deleting with GUID:
DeleteEntryCondL( aCalEntry.UidL() );
}
-
}
// ----------------------------------------------------------------------------
@@ -527,13 +608,384 @@
}
// ----------------------------------------------------------------------------
+// CESMRCalDbMgr::FindInstanceL
+// ----------------------------------------------------------------------------
+//
+CCalInstance* CESMRCalDbMgr::FindInstanceL(
+ const CCalEntry& aEntry )
+ {
+ FUNC_LOG;
+
+ CCalInstance* instance = NULL;
+ RCPointerArray<CCalInstance> calInstances;
+ CleanupClosePushL( calInstances );
+
+ CalCommon::TCalViewFilter instanceFilter =
+ CalCommon::EIncludeAppts |
+ CalCommon::EIncludeEvents |
+ CalCommon::EIncludeReminder |
+ CalCommon::EIncludeAnnivs |
+ CalCommon::EIncludeCompletedTodos |
+ CalCommon::EIncludeIncompletedTodos;
+
+ // Removing one seconds from start time and adding one second to stop
+ // time. Otherwise wanted entry is not included into results.
+ TCalTime startTime;
+ startTime.SetTimeLocalL(
+ aEntry.StartTimeL().TimeLocalL() - TTimeIntervalSeconds( 1 ) );
+ TCalTime endTime;
+ endTime.SetTimeLocalL(
+ aEntry.EndTimeL().TimeLocalL() + TTimeIntervalSeconds( 1 ) );
+
+ TDateTime start = startTime.TimeLocalL().DateTime();
+ TDateTime end = endTime.TimeLocalL().DateTime();
+
+ CalCommon::TCalTimeRange timeRange(
+ startTime,
+ endTime );
+
+
+ TInt count = iCalInstanceViewArray.Count();
+ for( TInt i = 0; i < count && !instance; i++ )
+ {
+ iCalInstanceViewArray[i]->FindInstanceL(
+ calInstances,
+ instanceFilter,
+ timeRange);
+ if( calInstances.Count() > 0 )
+ {
+ TInt instanceCount( calInstances.Count() );
+ for (TInt i = 0; (i < instanceCount && !instance); ++i)
+ {
+ CCalEntry& entry = calInstances[i]->Entry();
+
+ // Finding the entry we are intrested for
+ if ( !entry.UidL().Compare( aEntry.UidL() ) )
+ {
+ instance = calInstances[i];
+ calInstances.Remove( i );
+ }
+ }
+ }
+ }
+
+ CleanupStack::PopAndDestroy(); // arrayCleanup
+ return instance;
+ }
+
+// ----------------------------------------------------------------------------
+// CESMRCalDbMgr::GetCalendarColorByEntryL
+// ----------------------------------------------------------------------------
+//
+TRgb CESMRCalDbMgr::GetCalendarColorByEntryL(MESMRCalEntry& aEntry)
+ {
+ FUNC_LOG;
+ TInt count = iCalSessionArray.Count();
+ TRgb color(0);
+ if( count < 1 )
+ return color;
+
+ if( !aEntry.IsStoredL() )
+ {
+ color = iCalendarInfoArray[0]->Color();
+ }
+ else
+ {
+ CCalInstance* instance = aEntry.InstanceL();
+ CleanupStack::PushL( instance );
+ TInt collectionId = instance->InstanceIdL().iCollectionId;
+
+ for( TInt i = 0; i < count; i++ )
+ {
+ if( collectionId == iCalSessionArray[i]->CollectionIdL() )
+ {
+ color = iCalendarInfoArray[i]->Color();
+ break;
+ }
+ }
+
+ CleanupStack::PopAndDestroy( instance );
+ }
+
+ return color;
+ }
+// ----------------------------------------------------------------------------
+// CESMRCalDbMgr::GetMultiCalendarNameListL
+// ----------------------------------------------------------------------------
+//
+void CESMRCalDbMgr::GetMultiCalendarNameListL(RArray<TPtrC>& aCalendarNameList)
+ {
+ FUNC_LOG;
+ TInt count = iCalendarInfoArray.Count();
+ aCalendarNameList.ReserveL( count );
+
+ for( TInt i = 0; i < count; i++ )
+ {
+ const TDesC& calenName = iCalendarInfoArray[i]->NameL();
+ aCalendarNameList.AppendL( TPtrC( calenName ) );
+ }
+ }
+
+// ----------------------------------------------------------------------------
+// CESMRCalDbMgr::GetCalendarNameByEntryL
+// ----------------------------------------------------------------------------
+//
+TPtrC CESMRCalDbMgr::GetCalendarNameByEntryL(MESMRCalEntry& aEntry)
+ {
+ FUNC_LOG;
+
+ TInt count = iCalSessionArray.Count();
+
+ TRgb color(0);
+ TPtrC calenName;
+
+ if( !aEntry.IsStoredL() )
+ {
+ //while create new entry, use current calendar db
+ if( count > 0 )
+ {
+ calenName.Set(iCalendarInfoArray[iCurCalenIndex]->NameL());
+ }
+ }
+ else
+ {
+ CCalInstance* instance = NULL;
+ TRAPD( err, instance = aEntry.InstanceL() );
+ CleanupStack::PushL( instance );
+ if( err == KErrNotFound || instance == NULL )
+ calenName.Set(iCalendarInfoArray[iCurCalenIndex]->NameL());
+ else
+ {
+ TInt collectionId = instance->InstanceIdL().iCollectionId;
+ TBuf<16> val;
+
+ for( TInt i = 0; i < count; i++ )
+ {
+ if( collectionId == iCalSessionArray[i]->CollectionIdL() )
+ {
+ calenName.Set(iCalendarInfoArray[i]->NameL());
+ break;
+ }
+ }
+ }
+ CleanupStack::PopAndDestroy( instance );
+ }
+
+ return calenName;
+ }
+
+// ----------------------------------------------------------------------------
+// CESMRCalDbMgr::GetCalendarColorByNameL
+// ----------------------------------------------------------------------------
+//
+TRgb CESMRCalDbMgr::GetCalendarColorByNameL(TDesC& aCalendarName)
+ {
+ FUNC_LOG;
+ TInt count = iCalendarInfoArray.Count();
+ TRgb color(0);
+
+ for ( TInt i = 0; i < count; i++)
+ {
+ if( aCalendarName.Compare( iCalendarInfoArray[i]->NameL() ) == 0 )
+ {
+ color = iCalendarInfoArray[i]->Color();
+ }
+ }
+
+ return color;
+ }
+
+// ----------------------------------------------------------------------------
+// CESMRCalDbMgr::SetCurCalendarByNameL
+// ----------------------------------------------------------------------------
+//
+void CESMRCalDbMgr::SetCurCalendarByNameL( TDesC& aCalendarName )
+ {
+ FUNC_LOG;
+ TInt count = iCalendarInfoArray.Count();
+
+ for( TInt i(0); i < count; i++ )
+ {
+ if( aCalendarName.Compare( iCalendarInfoArray[i]->NameL() ) == 0 )
+ {
+ SetCurCalendarByIndex( i );
+ break;
+ }
+ }
+ }
+
+// ----------------------------------------------------------------------------
+// CESMRCalDbMgr::SetCurCalendarByColIdL
+// ----------------------------------------------------------------------------
+//
+void CESMRCalDbMgr::SetCurCalendarByColIdL( TInt aColId )
+ {
+ FUNC_LOG;
+ TInt count = iCalSessionArray.Count();
+
+ for( TInt i = 0; i < count; i++ )
+ {
+ if( aColId == iCalSessionArray[i]->CollectionIdL() )
+ {
+ SetCurCalendarByIndex( i );
+ break;
+ }
+ }
+ }
+
+// ----------------------------------------------------------------------------
+// CESMRCalDbMgr::SetCurCalendarByEntry
+// ----------------------------------------------------------------------------
+//
+void CESMRCalDbMgr::SetCurCalendarByEntryL( MESMRCalEntry& aEntry )
+ {
+ TPtrC calenName = GetCalendarNameByEntryL( aEntry );
+ SetCurCalendarByNameL( calenName );
+ }
+
+// ----------------------------------------------------------------------------
+// CESMRCalDbMgr::SetCurCalendarByIndex
+// ----------------------------------------------------------------------------
+//
+void CESMRCalDbMgr::SetCurCalendarByIndex( TInt aIndex )
+ {
+ FUNC_LOG;
+ iCurCalenIndex = aIndex;
+ }
+
+// ----------------------------------------------------------------------------
+// CESMRCalDbMgr::GetCurCalendarColor
+// ----------------------------------------------------------------------------
+//
+TRgb CESMRCalDbMgr::GetCurCalendarColor()
+ {
+ FUNC_LOG;
+ __ASSERT_ALWAYS(
+ iCurCalenIndex < iCalendarInfoArray.Count(),
+ Panic( EPanicInvalidDbIndex ) );
+ return iCalendarInfoArray[iCurCalenIndex]->Color();
+ }
+
+// ----------------------------------------------------------------------------
+// CESMRCalDbMgr::GetCurCalendarColIdL
+// ----------------------------------------------------------------------------
+//
+TInt CESMRCalDbMgr::GetCurCalendarColIdL()
+ {
+ FUNC_LOG;
+ __ASSERT_ALWAYS(
+ iCurCalenIndex < iCalSessionArray.Count(),
+ Panic( EPanicInvalidDbIndex ) );
+
+ return iCalSessionArray[iCurCalenIndex]->CollectionIdL();
+ }
+
+// ----------------------------------------------------------------------------
+// CESMRCalDbMgr::GetCurCalendarIndex
+// ----------------------------------------------------------------------------
+//
+TInt CESMRCalDbMgr::GetCurCalendarIndex()
+ {
+ return iCurCalenIndex;
+ }
+
+// ----------------------------------------------------------------------------
+// CESMRCalDbMgr::EntryViewL
+// ----------------------------------------------------------------------------
+//
+CCalEntryView* CESMRCalDbMgr::EntryViewL(const CCalEntry& aCalEntry )
+ {
+ FUNC_LOG;
+ CCalInstance* instance = FindInstanceL( aCalEntry );
+ if( !instance )
+ {
+ return NULL;
+ }
+
+ CleanupStack::PushL( instance );
+ CCalEntryView* entryView = NULL;
+
+ TInt colId = instance->InstanceIdL().iCollectionId;
+ TInt count = iCalSessionArray.Count();
+
+ for( TInt i = 0; i < count; i++ )
+ {
+ if( colId == iCalSessionArray[i]->CollectionIdL() )
+ {
+ entryView = iCalEntryViewArray[i];
+ break;
+ }
+ }
+
+ if ( !entryView )
+ {
+ User::Leave( KErrNotFound );
+ }
+
+ CleanupStack::PopAndDestroy( instance );
+ return entryView;
+ }
+
+// ----------------------------------------------------------------------------
+// CESMRCalDbMgr::InstanceViewL
+// ----------------------------------------------------------------------------
+//
+CCalInstanceView* CESMRCalDbMgr::InstanceViewL(const CCalEntry& aCalEntry )
+ {
+ FUNC_LOG;
+ CCalInstance* instance = FindInstanceL( aCalEntry );
+ if( !instance )
+ {
+ return NULL;
+ }
+
+ CleanupStack::PushL( instance );
+ CCalInstanceView* instanceView = NULL;
+
+ TInt colId = instance->InstanceIdL().iCollectionId;
+ TInt count = iCalSessionArray.Count();
+
+ for( TInt i = 0; i < count; i++ )
+ {
+ if( colId == iCalSessionArray[i]->CollectionIdL() )
+ {
+ instanceView = iCalInstanceViewArray[i];
+ break;
+ }
+ }
+
+ if ( !instanceView )
+ {
+ User::Leave( KErrNotFound );
+ }
+
+ CleanupStack::PopAndDestroy( instance );
+ return instanceView;
+ }
+
+// ----------------------------------------------------------------------------
+// CESMRCalDbMgr::EntryView
+// ----------------------------------------------------------------------------
+//
+CCalEntryView* CESMRCalDbMgr::EntryView()
+ {
+ FUNC_LOG;
+ __ASSERT_ALWAYS(
+ iCurCalenIndex < iCalEntryViewArray.Count(),
+ Panic( EPanicInvalidDbIndex ) );
+ return iCalEntryViewArray[iCurCalenIndex];
+ }
+
+
+
+// ----------------------------------------------------------------------------
// CESMRCalDbMgr::EntryExistsInDbL
// ----------------------------------------------------------------------------
//
TBool CESMRCalDbMgr::EntryExistsInDbL(
const TDesC8& aUid,
const TCalTime& aRecurrenceId,
- const CESMRCalDbBase& aDb,
+ const CESMRCalDbBase& /*aDb*/,
RPointerArray<CCalEntry>& aCalEntryArray,
TInt& aIndex ) const
{
@@ -542,7 +994,16 @@
TBool retVal( EFalse );
aIndex = KErrNotFound;
- aDb.EntryView()->FetchL( aUid, aCalEntryArray );
+ TInt sessionCount = iCalSessionArray.Count();
+ for( TInt i = 0; i < sessionCount; i++ )
+ {
+ iCalEntryViewArray[i]->FetchL( aUid, aCalEntryArray );
+ if( aCalEntryArray.Count() > 0)
+ {
+ break;
+ }
+ }
+
TInt count( aCalEntryArray.Count() );
for ( TInt i( 0 ); i < count; ++i )
{
@@ -555,7 +1016,6 @@
}
}
-
return retVal;
}
@@ -587,9 +1047,11 @@
{
FUNC_LOG;
- __ASSERT_DEBUG( aEntry.UidL() == aEntry.UidL(),
+ __ASSERT_DEBUG( aEntry.UidL() == aDbEntry.UidL(),
Panic( EPanicUnexpectedUidValue ) );
- MESMRUtilsTombsExt::TESMRUtilsDbResult retVal( MESMRUtilsTombsExt::EUndefined );
+
+ MESMRUtilsTombsExt::TESMRUtilsDbResult retVal(
+ MESMRUtilsTombsExt::EUndefined );
TInt seq( aEntry.SequenceNumberL() );
TInt dbSeq( aDbEntry.SequenceNumberL() );
@@ -617,7 +1079,6 @@
retVal = MESMRUtilsTombsExt::EErrorObsolete;
}
-
return retVal;
}
@@ -643,7 +1104,6 @@
retVal = MESMRUtilsTombsExt::ECheckedValidNew;
}
-
return retVal;
}
@@ -666,6 +1126,21 @@
CalCommon::EIncludeAppts,
range );
TInt count( instances.Count() );
+
+ // The entry can also be in other calendar than the default one,
+ // so the instance view array should be checked in this case.
+ if( count == 0 )
+ {
+ TInt instanceViewCount = iCalInstanceViewArray.Count();
+ for( TInt i(0); i < instanceViewCount; i++ )
+ {
+ iCalInstanceViewArray[i]->FindInstanceL( instances,
+ CalCommon::EIncludeAppts,
+ range );
+ }
+ count = instances.Count();
+ }
+
for ( TInt i( 0 ); i < count; ++i )
{
// When creating a new modifying entry, recurrence id must match
@@ -680,7 +1155,6 @@
}
CleanupStack::PopAndDestroy(); // instances, delete array items
-
return retVal;
}
@@ -702,9 +1176,97 @@
retVal = ETrue;
}
-
return retVal;
}
+// ---------------------------------------------------------------------------
+// CESMRCalDbMgr::CheckSpaceBelowCriticalLevelL
+// ---------------------------------------------------------------------------
+//
+TBool CESMRCalDbMgr::CheckSpaceBelowCriticalLevelL()
+ {
+ FUNC_LOG;
+
+ TBool retcode(EFalse);
+
+ CCoeEnv* coeEnv = CCoeEnv::Static();
+
+ if ( SysUtil::FFSSpaceBelowCriticalLevelL( &( coeEnv->FsSession() ) ) )
+ {
+ CErrorUI* errorUi = CErrorUI::NewLC();
+ errorUi->ShowGlobalErrorNoteL( KErrDiskFull );
+ CleanupStack::PopAndDestroy(); // errorUi
+ retcode = ETrue;
+ }
+
+ return retcode;
+ }
+
+// ---------------------------------------------------------------------------
+// CESMRCalDbMgr::LoadMultiCalenInfo
+// ---------------------------------------------------------------------------
+//
+void CESMRCalDbMgr::LoadMultiCalenInfoL()
+ {
+ FUNC_LOG;
+
+ CDesCArray* fileArray = iCalSession.ListCalFilesL();
+ CleanupStack::PushL( fileArray );
+
+ TInt count = fileArray->Count();
+
+ iCalSessionArray.ReserveL( count );
+ iCalEntryViewArray.ReserveL( count );
+ iCalInstanceViewArray.ReserveL( count );
+ iCalendarInfoArray.ReserveL( count );
+
+ for( TInt i = 0; i < count; i++ )
+ {
+ CCalSession* file = CCalSession::NewL();
+ CleanupStack::PushL( file );
+
+ const TDesC& fileName = (*fileArray)[i];
+ file->OpenL( fileName );
+ CCalCalendarInfo* calendarInfo = file->CalendarInfoL();
+
+ if( calendarInfo->IsValid()
+ && calendarInfo->Enabled() )
+ {
+ // Push info into CleanupStack because NewL may leave
+ CleanupStack::PushL( calendarInfo );
+
+ CCalEntryView* entryView = CCalEntryView::NewL( *file );
+ // Push entryView into CleanupStack because NewL may leave
+ CleanupStack::PushL( entryView );
+
+ CCalInstanceView* instanceView = CCalInstanceView::NewL( *file );
+
+ // Space has been reserved so AppendL won't leave
+ iCalInstanceViewArray.AppendL( instanceView );
+
+ iCalEntryViewArray.AppendL( entryView );
+ CleanupStack::Pop( entryView );
+
+ iCalendarInfoArray.AppendL( calendarInfo );
+ CleanupStack::Pop( calendarInfo );
+
+ iCalSessionArray.AppendL( file );
+ CleanupStack::Pop( file );
+ }
+ else
+ {
+ delete calendarInfo;
+ CleanupStack::PopAndDestroy( file );
+ }
+ }
+
+ CleanupStack::PopAndDestroy( fileArray );
+
+ // Restore default database index from repository
+ ReadDatabaseIndexL( iCurCalenIndex );
+ }
+
+
// End of file
+