calendarui/globaldata/src/calenglobaldata.cpp
branchRCL_3
changeset 30 bd7edf625bdd
parent 29 12af337248b1
--- a/calendarui/globaldata/src/calenglobaldata.cpp	Tue Aug 31 15:13:43 2010 +0300
+++ b/calendarui/globaldata/src/calenglobaldata.cpp	Wed Sep 01 12:32:31 2010 +0100
@@ -11,27 +11,59 @@
 *
 * Contributors:
 *
-* Description:  Global Data for Calendar application
+* Description:   Global Data for Calendar application
 *
 */
 
 
+
 //debug
 #include "calendarui_debug.h"
 
 // INCLUDE FILES
-#include "calenglobaldata.h"        // CalenGlobalData
-#include "calencontext.h"           // Calendar context
+#include "calenglobaldata.h"        // CCalenGlobalData
+#include "RImplInfoPtrArrayOwn.inl" // Wrapper class with array deletion on close
+#include "calensend.h"              // CCalenSend
+#include "CalenInterimUtils2.h"     // CalenInterimUtils
 #include "calencontextimpl.h"       // Calendar context implementation
-#include "hb_calencommands.hrh"
-#include <CalSession.h>             // Calendar database session
+#include "calenfilemapping.h"
+#include "missedalarmstore.h"
+#include "CleanupResetAndDestroy.h"
+#include "calendar.hrh"
+
+#include <Calendar.rsg>             // Calendar resources
+#include <cmrmailboxutils.h>        // CMRMailboxUtils
+#include <utf.h>                    // CnvUtfConverter
+#include <StringLoader.h>           // Loads strings from resource files
+#include <featmgr.h>                // Feature discovery API
+#include <calsession.h>             // Calendar database session
 #include <calinstanceview.h>        // Calendar Instance view
 #include <calentryview.h>           // Calendar Entry view
+#include <cmrmailboxutils.h>        // CMRMailboxUtils
+#include <calencommands.hrh>            // Calendar commands
+#include <aknlists.h>
+#include <aknPopup.h>
+#include <AknUtils.h>
+#include <AknQueryDialog.h>
+#include <calencontext.h>
+#include <calcalendarinfo.h>
+#include <calcalendariterator.h>
+#include <CalendarInternalCRKeys.h>
+#include <calenmulticalutil.h>
 
+#include <bautils.h>
+#include <calensvrmissedalarmmanagerresource.rsg>
 // Default Calendar database path
-_LIT( KCalendarDatabaseFilePath, "c:Calendar" );
+_LIT( KCalendarDatabaseFilePath, "c:calendar" );
+_LIT( KPhoneCalendar,"Personal" );
+_LIT( KExtCalendar,"Ext calendar" );
+const TInt KBuffLength = 24;
 
 
+_LIT(KPersonal,"Personal");
+
+_LIT( KMissedAlarmResourceFile, "z:\\resource\\CalenSvrMissedAlarmManagerResource.rsc"); // changes done
+
 // ============================ MEMBER FUNCTIONS ===============================
 
 // -----------------------------------------------------------------------------
@@ -40,14 +72,16 @@
 // (other items were commented in a header).
 // -----------------------------------------------------------------------------
 //
-
 CCalenGlobalData::CCalenGlobalData( MCalProgressCallBack& aCalCallBack )
     : iCalCallBack( aCalCallBack )
     {
     TRACE_ENTRY_POINT;
 
     iGlobalDataOwnsCalSession = EFalse;
-
+    iGlobalDataOwnsEntryView = EFalse;
+    
+    iCalendarForcedExit = EFalse;
+    
     TRACE_EXIT_POINT;
     }
 
@@ -61,9 +95,11 @@
 // ----------------------------------------------------------------------------
 //
 EXPORT_C CCalenGlobalData* CCalenGlobalData::NewL( MCalProgressCallBack& aCalCallBack,
-                                                   MCalenContextChangeObserver* aNotifier )
+                                                   MCalenContextChangeObserver* aNotifier,
+                                                   MCalenDBChangeObserver* aDBNotifier)
     {
     TRACE_ENTRY_POINT;
+
     CCalenGlobalData* self = NULL;
     TAny* tlsPtr = Dll::Tls();
 
@@ -79,7 +115,7 @@
         // calls CCalenGlobalData::InstanceL in ConstructL and then ConstructL
         // leaves, we will double delete the global data.
         ++self->iRefCount;
-        self->ConstructL( aNotifier );
+        self->ConstructL( aNotifier, aDBNotifier );
         CleanupStack::Pop( self );
         }
     else
@@ -99,7 +135,7 @@
 // (other items were commented in a header).
 // -----------------------------------------------------------------------------
 EXPORT_C CCalenGlobalData* CCalenGlobalData::InstanceL()
-    {    	
+    {
     TRACE_ENTRY_POINT;
 
     CCalenGlobalData* self = NULL;
@@ -110,7 +146,13 @@
         {
         // The global data has not yet been constructed.
         // FIXME - Revise comment
-        //TLS is NULL, so no CCalenGlobalData has been created yet.      
+        //TLS is NULL, so no CCalenGlobalData has been created yet.
+      /*  self = new( ELeave ) CCalenGlobalData;
+        CleanupStack::PushL( self );
+        self->ConstructL();
+        //Store a self pointer in TLS
+        User::LeaveIfError( Dll::SetTls(static_cast<TAny*>(self)));
+        CleanupStack::Pop(self);*/
         User::Leave( KErrNotReady );
         }
     else
@@ -155,6 +197,7 @@
 EXPORT_C CCalenGlobalData* CCalenGlobalData::Instance()
     {
     TRACE_ENTRY_POINT;
+
     TAny* tlsPtr = Dll::Tls();
     CCalenGlobalData* self = static_cast<CCalenGlobalData*>( tlsPtr );
 
@@ -172,12 +215,17 @@
 // Symbian 2nd phase constructor can leave.
 // (other items were commented in a header).
 // -----------------------------------------------------------------------------
-void CCalenGlobalData::ConstructL( MCalenContextChangeObserver* aNotifier)
+void CCalenGlobalData::ConstructL( MCalenContextChangeObserver* aNotifier,
+                                    MCalenDBChangeObserver* aDBNotifier)
     {
     TRACE_ENTRY_POINT;
 
-    iContext = new (ELeave ) CalenContextImpl( aNotifier );
-
+    iContext = new (ELeave ) CCalenContextImpl( aNotifier );  
+    
+    iNewInstanceViewCreation = NULL;
+    
+    iDBChangeNotifier = aDBNotifier;
+    
     TRACE_EXIT_POINT;
     }
 
@@ -232,33 +280,109 @@
 CCalenGlobalData::~CCalenGlobalData()
     {
     TRACE_ENTRY_POINT;
+
+    delete iSend;
+    delete iInterimUtils;
+    delete iUtilsAs;
+    delete iMailboxUtils;
+    delete iMRUtils;
+
+    if (iInstanceView)
+        {
+        delete iInstanceView;
+        iInstanceView = NULL;
+        }
+
+    if (iInstanceViewCreation)
+        {
+        delete iInstanceViewCreation;
+        iInstanceViewCreation = NULL;
+        }
+
+    if (iEntryViewCreation)
+        {
+        delete iEntryViewCreation;
+        iEntryViewCreation = NULL;
+        }
     
-    delete iInterimUtils;    
-    delete iEntryView;
-    delete iInstanceView;
-    delete iEntryViewCreation;
-    delete iInstanceViewCreation;
+    if (iNewInstanceView)
+        {
+        delete iNewInstanceView;
+        iNewInstanceView = NULL;
+        iNewInstanceViewCreation = NULL;
+        }
+
+    if (iNewInstanceViewCreation)
+        {
+        delete iNewInstanceViewCreation;
+        iNewInstanceViewCreation = NULL;
+        }
+
     delete iContext;
+    
+    if(iGlobalDataOwnsEntryView)
+        {
+        if(iEntryView)
+            {
+            delete iEntryView;
+            iEntryView = NULL;           
+            }
+        }
 
-    if (iGlobalDataOwnsCalSession)
+   if (iGlobalDataOwnsCalSession)
         {
         delete iCalSession;
         }
     
-    --iRefCount;
+   if (iCalendarInfoList.Count())
+       {
+       iCalendarInfoList.ResetAndDestroy();
+       }
+   
+    if( iFileMappingArray.Count() )
+        {
+        iFileMappingArray.ResetAndDestroy();
+        }
     
-    // The controller owns its own instance of the services, therefore the
-    // reference count will be one, immediatley before deletion.
-    if (iRefCount == 1)
-        {
-        delete this;
-        }
+    iKeyQueue.Reset();
+    
+    iHashDbidIndexMap.Close();
 
     Dll::SetTls(NULL);
 
+    if (iCalendarsSession)
+        {
+        delete iCalendarsSession;
+        iCalendarsSession = NULL;
+        }
+
     TRACE_EXIT_POINT;
     }
 
+// -----------------------------------------------------------------------------
+// CCalenGlobalData::MailboxUtilsL
+// Create MailBoxUtils if necessary and returns a reference
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+EXPORT_C CMRMailboxUtils& CCalenGlobalData::MRMailboxUtilsL()
+    {
+    TRACE_ENTRY_POINT;
+
+    if (!iMailboxUtils)
+        {
+        if (InterimUtilsL().MRViewersEnabledL())
+            {
+            iMailboxUtils = CMRMailboxUtils::NewL();
+            }
+        else
+            {
+            User::Leave(KErrNotSupported);
+            }
+        }
+
+    TRACE_EXIT_POINT;
+    return *iMailboxUtils;
+    }
 
 // -----------------------------------------------------------------------------
 // CCalenGlobalData::CalSessionL
@@ -268,23 +392,41 @@
 EXPORT_C CCalSession& CCalenGlobalData::CalSessionL()
     {
     TRACE_ENTRY_POINT;
-
+    
     if (!iCalSession)
         {
         iGlobalDataOwnsCalSession = ETrue;
         iCalSession = CCalSession::NewL();
 
         TRAPD( err, iCalSession->OpenL(KCalendarDatabaseFilePath));
-        if ( err == KErrNotFound )
+        if (err == KErrNotFound)
+            {
+            CCalCalendarInfo* calendarInfo = GetDefaultCalendarInfoL();
+            CleanupStack::PushL(calendarInfo);
+            iCalSession->CreateCalFileL( KCalendarDatabaseFilePath,
+                                        *calendarInfo);
+            iCalSession->OpenL(KCalendarDatabaseFilePath);
+            CleanupStack::PopAndDestroy(calendarInfo);
+            }
+        else if(err == KErrNone)
             {
-            iCalSession->CreateCalFileL(KCalendarDatabaseFilePath);
-            iCalSession->OpenL(KCalendarDatabaseFilePath); // not trapped anymore
+            // temp solution...need to handle this case
+            CCalCalendarInfo* calendarInfo = iCalSession->CalendarInfoL();
+            CleanupStack::PushL(calendarInfo);
+            if( !calendarInfo->NameL().Compare(KNullDesC) && 
+                 !calendarInfo->Enabled() )
+                {
+                calendarInfo->SetNameL(KExtCalendar);
+                calendarInfo->SetColor(KRgbBlack.Value());
+                iCalSession->SetCalendarInfoL(*calendarInfo);
+                }
+            CleanupStack::PopAndDestroy(calendarInfo);
+            
             }
         else
             {
             User::LeaveIfError( err );
             }
-
         }
 
     TRACE_EXIT_POINT;
@@ -292,6 +434,32 @@
     }
 
 // -----------------------------------------------------------------------------
+// CCalenGlobalData::CalSessionL
+// Based on the calendar name return already cached session from iFileMappingArray
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+EXPORT_C CCalSession& CCalenGlobalData::CalSessionL(const TDesC& aCalendar)
+    {
+    TRACE_ENTRY_POINT;
+    CCalSession* session = NULL;
+    HBufC* calendarFileName = aCalendar.AllocLC();
+    TInt index = iFileMappingArray.Find(
+            *calendarFileName,CCalenGlobalData::CalenInfoIdentifierL);
+    CleanupStack::PopAndDestroy(calendarFileName);
+    if(KErrNotFound != index)
+        {
+        session = iFileMappingArray[index]->GetSessionPtr();
+        }
+    else
+        {
+        User::LeaveIfError(KErrNotFound);
+        }
+    
+    TRACE_EXIT_POINT;
+    return *session;
+    }
+
+// -----------------------------------------------------------------------------
 // CCalenGlobalData::InstanceViewL
 // Create an instance view if necessary and returns a reference.  Creating an
 // instance view is an asynchronous operation, but this call returns
@@ -304,16 +472,11 @@
 EXPORT_C CCalInstanceView* CCalenGlobalData::InstanceViewL()
     {
     TRACE_ENTRY_POINT;
-
+    
     if (!iInstanceView && !iInstanceViewCreation)
         {
         if ( iEntryViewCreation )
             {
-            /* We need queueing to avoid two immediate instance and entry view creation requests to symbian.
-             * Though symbian handle two immediate requests ,this we require because we have only one observer
-             * for callback and we would not be able to differentiate whether instance view got created or entry view got created.
-             * If we dont queue the second request, we may end up giving incomplete object to the caller function.
-             */
             iQueued = &CreateInstanceViewL;
             }
         else
@@ -321,12 +484,36 @@
             CreateInstanceViewL();
             }
         }
-
+    
     TRACE_EXIT_POINT;
     return iInstanceView;
     }
 
 // -----------------------------------------------------------------------------
+// CCalenGlobalData::InstanceViewL
+// Based on collection id array Create an instance view if necessary and returns a reference.
+// Creating an instance view is an asynchronous operation, but this call returns
+// synchronously.  When the view is created, Completed() is called, which stops
+// iAs allowing this function to complete.
+// Leaves with KErrInUse if this class is in the process of creating the
+// instance view
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+EXPORT_C CCalInstanceView* CCalenGlobalData::InstanceViewL(
+                                        const RArray<TInt>& aCollectionIds)
+    {
+    TRACE_ENTRY_POINT;
+    
+    if(!iNewInstanceView && !iNewInstanceViewCreation)
+        {
+        CreateInstanceViewL(aCollectionIds);
+        }
+    
+    TRACE_EXIT_POINT;
+    return iNewInstanceView;
+    }
+
+// -----------------------------------------------------------------------------
 // CCalenGlobalData::EntryViewL
 // Create an entry view if necessary and returns a reference.  Creating an
 // entry view is an asynchronous operation, but this call returns
@@ -339,16 +526,11 @@
 EXPORT_C CCalEntryView* CCalenGlobalData::EntryViewL()
     {
     TRACE_ENTRY_POINT;
-
-    if (!iEntryView && !iEntryViewCreation)
+    
+     if (!iEntryView && !iEntryViewCreation)
         {
         if ( iInstanceViewCreation )
             {
-            /* We need queueing to avoid two immediate instance and entry view creation requests to symbian.
-             * Though symbian handle two immediate requests ,this we require because we have only one observer
-             * for callback and we would not be able to differentiate whether instance view got created or entry view got created.
-             * If we dont queue the second request, we may end up giving incomplete object to the caller function.
-             */
             iQueued = &CreateEntryViewL;
             }
         else
@@ -356,21 +538,636 @@
             CreateEntryViewL();
             }
         }
-    TRACE_EXIT_POINT;
+    
+     TRACE_EXIT_POINT;
     return iEntryView;
     }
 
+
+// -----------------------------------------------------------------------------
+// CCalenGlobalData::EntryViewL
+// Based on collection id array Create an entry view if necessary and returns a reference.  
+// Creating an entry view is an asynchronous operation, but this call returns
+// synchronously.  When the view is created, Completed() is called, which stops
+// iAs allowing this function to complete.
+// Leaves with KErrInUse if this class is in the process of creating the
+// entry view
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+EXPORT_C CCalEntryView* CCalenGlobalData::EntryViewL(
+                                                const TCalCollectionId aCollectionId)
+    {
+    TRACE_ENTRY_POINT;
+    __ASSERT_ALWAYS(aCollectionId > 0 ,User::Panic(_L("CCalenGlobalData"),-1));
+    
+    CCalEntryView* entryView = NULL;
+    
+    TInt index = iHashDbidIndexMap.FindL(aCollectionId);
+    if(index != KErrNotFound)
+        {
+        entryView = iFileMappingArray[index]->GetEntryView();
+        }    
+    
+    if(!entryView)
+        {
+        User::LeaveIfNull(entryView);
+        }
+    
+    TRACE_EXIT_POINT;
+    return entryView;
+    }
+
+// -----------------------------------------------------------------------------
+// CCalenGlobalData::RegisterEntryViewObserver
+// Add observer into view observers entry observer list.
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+EXPORT_C TBool CCalenGlobalData::EntryViewExists()
+    {
+    TRACE_ENTRY_POINT;
+    TRACE_EXIT_POINT;
+    return ( iEntryView != NULL );
+    }
+
+// -----------------------------------------------------------------------------
+// CCalenGlobalData::MeetingRequestUtilsL
+// Create MR Utils if necessary and returns a reference
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+EXPORT_C CMRUtils& CCalenGlobalData::MeetingRequestUtilsL()
+    {
+    TRACE_ENTRY_POINT;
+
+    iCreateError = KErrNone;
+    if (!iUtilsAs)
+        {
+        iUtilsAs = new (ELeave) CActiveSchedulerWait;
+        }
+    if (!iMRUtils)
+        {
+        if (InterimUtilsL().MRViewersEnabledL())
+            {
+            if (iUtilsAs->IsStarted())
+                {
+                User::Leave(KErrInUse);
+                }
+            else
+                {
+                //Get the currently selected mailbox
+                CMRMailboxUtils::TMailboxInfo defaultMailbox;
+                MRMailboxUtilsL().GetDefaultMRMailBoxL(defaultMailbox);
+                //CMRUtils resolves meeting request utilities based on mtm uid
+                TBuf8<KMaxUidName> mrMtm;
+                CnvUtfConverter::ConvertFromUnicodeToUtf8(mrMtm, defaultMailbox.iMtmUid.Name());
+                iMRUtils = CMRUtils::NewL(mrMtm, *this, CalSessionL(), NULL);
+                iUtilsAs->Start();
+                User::LeaveIfError(iCreateError);
+                }
+            }
+        else
+            {
+            User::Leave(KErrNotSupported);
+            }
+        }
+
+    TRACE_EXIT_POINT;
+    return *iMRUtils;
+    }
+
+// -----------------------------------------------------------------------------
+// CCalenGlobalData::InterimUtilsL
+// Create a CCalenInterimUtils object if neccessary and return a reference
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+EXPORT_C CCalenInterimUtils2& CCalenGlobalData::InterimUtilsL()
+    {
+    TRACE_ENTRY_POINT;
+
+    if(!iInterimUtils)
+        {
+        iInterimUtils = CCalenInterimUtils2::NewL();
+        }
+
+    TRACE_EXIT_POINT;
+    return *iInterimUtils;
+    }
+
+// -----------------------------------------------------------------------------
+// CCalenGlobalData::CalenSendL
+// Create a CCalenSend object if neccessary and return a reference
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+EXPORT_C CCalenSend& CCalenGlobalData::CalenSendL()
+    {
+    TRACE_ENTRY_POINT;
+
+    if( !iSend )
+        {
+        iSend = CCalenSend::NewL( ECalenSend, CalSessionL() );
+        }
+
+    TRACE_EXIT_POINT;
+    return *iSend;
+    }
+
+// -----------------------------------------------------------------------------
+// CCalenGlobalData::Context
+// Return a reference to the CCalenContext object
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+EXPORT_C MCalenContext& CCalenGlobalData::Context()
+    {
+    TRACE_ENTRY_POINT;
+    TRACE_EXIT_POINT;
+    return *iContext;
+    }
+
+// -----------------------------------------------------------------------------
+// CCalenEditUi::AttemptToRetrieveDefaultMailboxL
+// Check to see if we have any mailboxes defined, and if we have a default
+// mailbox. If we don't, inform the user and return EFalse. This function
+// returns ETrue if aDefaultMailbox was initialised, and it is OK to create
+// a new MR.
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+EXPORT_C TBool CCalenGlobalData::AttemptToRetrieveDefaultMailboxL( CMRMailboxUtils::TMailboxInfo& aDefaultMailbox)
+    {
+    TRACE_ENTRY_POINT;
+
+    CMRMailboxUtils& mbUtils = MRMailboxUtilsL();
+    // Get the currently defined mailboxes.
+    RArray<CMRMailboxUtils::TMailboxInfo> mailboxes;
+    CleanupClosePushL(mailboxes);
+    mbUtils.ListMailBoxesL(mailboxes);
+
+    TBool canCreateMeetingRequest=EFalse;
+    TInt mbCount = mailboxes.Count();
+
+    // The following 'if-else' block should always initialise
+    // defaultMailBox if canCreateMeetingRequest comes out as ETrue.
+    if(mbCount > 0)
+        {
+        TInt res = KErrNone;
+        TRAPD(err, res = mbUtils.GetDefaultMRMailBoxL(aDefaultMailbox));
+        if( res == KErrNone && err == KErrNone)
+            {
+            canCreateMeetingRequest = ETrue;
+            }
+        else
+            {
+            // We have one or more mailboxes defined, but failed to get a default.
+            // Ask user to answer "Select default mailbox" query.  The available mailboxes must
+            // first be reduced to only show mailboxes with an associated meetnig request solution
+            RImplInfoPtrArrayOwn implArray;
+             CleanupClosePushL( implArray );
+            //Get all MRViewers Implementation
+             const TUid mrViewersIface = {KMRViewersInterfaceUID};
+             REComSession::ListImplementationsL(mrViewersIface, implArray );
+
+            for (TInt i = mailboxes.Count() - 1; i >= 0; --i)
+                {
+                //See if any meeting request implementation matches this mailbox
+                for (TInt j=0; j<implArray.Count(); ++j)
+                     {
+                     TBuf16<KMaxUidName> mbName;
+                     CnvUtfConverter::ConvertToUnicodeFromUtf8( mbName, implArray[j]->DataType() );
+                     if(mailboxes[i].iMtmUid.Name().CompareF(mbName) == 0)
+                         {
+                         //Found a match
+                        break;
+                        }
+                    //Mailbox has no matching meeting request solution
+                    //remove from list
+                    mailboxes.Remove(i);
+                    }
+                }
+            CleanupStack::PopAndDestroy();    //implArray
+            
+            TInt selected = PromptToSelectDefaultMailboxL(mailboxes);
+
+            if(selected >= KErrNone)
+                {
+                mbUtils.SetDefaultMRMailBoxL( mailboxes[selected].iEntryId );
+                canCreateMeetingRequest = ETrue;
+                __ASSERT_ALWAYS((mbUtils.GetDefaultMRMailBoxL( aDefaultMailbox ) == KErrNone), User::Invariant()); // so we don't return ref to local variable.
+                }
+            }
+        }
+    else
+        {
+        // Force the check of MR Impl existing
+        InterimUtilsL().MRViewersEnabledL(ETrue); //ignore result
+        }
+   
+    CleanupStack::PopAndDestroy(); // mailboxes
+
+    TRACE_EXIT_POINT;
+    return canCreateMeetingRequest;
+    }
+
+// -----------------------------------------------------------------------------
+// CCalenGlobalData::ResetKeyEventQueue
+// Reset Keyevents queue
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+EXPORT_C void CCalenGlobalData::ResetKeyEventQueue()
+    {
+    TRACE_ENTRY_POINT;
+    iKeyQueue.Reset();
+    TRACE_EXIT_POINT;
+    }
+
+// -----------------------------------------------------------------------------
+// CCalenGlobalData::QueueKeyEvent
+// Queue key press event in a queue
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+EXPORT_C TBool CCalenGlobalData::QueueKeyEvent(const TKeyEvent& aEvent,
+                                               TEventCode aType)
+    {
+    TRACE_ENTRY_POINT;
+    TBool result(EFalse);
+    TQueuedKeyEvent item;
+    item.iType = aType;
+    item.iEvent = aEvent;
+    if( iKeyQueue.Insert(item, iKeyQueue.Count()) == KErrNone) // add to last
+        {
+        result = ETrue;
+        }
+    TRACE_EXIT_POINT;
+    return result;
+    }
+
+// -----------------------------------------------------------------------------
+// CCalenGlobalData::GetQueueKeyEvent
+// Get 1 queued event from the queue
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+EXPORT_C TBool CCalenGlobalData::GetQueuedKeyEvent(TKeyEvent& aEvent, TEventCode& aType)
+    {
+    TRACE_ENTRY_POINT;
+    TBool result(EFalse);
+    if(iKeyQueue.Count() > 0)
+        {
+        TQueuedKeyEvent item;
+        item = iKeyQueue[0];// get first
+        aEvent = item.iEvent;
+        aType = item.iType;
+        iKeyQueue.Remove(0); // remove first
+        result = ETrue;
+        iKeyQueue.Compress();
+        }
+    TRACE_EXIT_POINT;
+    return result;
+    }
+
+// -----------------------------------------------------------------------------
+// CCalenGlobalData::ConstructFileMappingL
+// Constructs mapping between symbian calendar file and metabd info
+// -----------------------------------------------------------------------------
+EXPORT_C TBool CCalenGlobalData::ConstructFileMappingL()
+    {
+    TRACE_ENTRY_POINT;
+    iCalendarsSession = CCalSession::NewL();
+    
+    ConstructCalendarsListL();
+    
+    iFileMappingArray.Reset();
+        
+    for(TInt index = 0; index < iCalendarInfoList.Count(); index++)
+        {
+        TPtrC calendarFileName = iCalendarInfoList[index]->FileNameL();
+        CCalenFileMapping* filemap = CCalenFileMapping::NewL(); 
+        CleanupStack::PushL(filemap);
+        filemap->SetCalendarFileNameL(calendarFileName);
+        
+        iNewEntryView  = NULL;
+        iNewEntryViewCreation  = NULL;
+        CCalenDbChangeNotifier* dbChangeNotifier = NULL;
+        if(iCalSession)
+            {
+            iNewCalSession = NULL;
+            CCalCalendarInfo* calendarInfo = iCalendarInfoList[index];
+            
+            CCalSession& tempSession = CreateNewSessionL( calendarFileName,
+                                    *calendarInfo );
+            filemap->SetSessionPtr(&tempSession);
+            filemap->SetCollectionId(tempSession.CollectionIdL());
+            CreateEntryViewL(tempSession);
+            filemap->SetEntryView( iNewEntryView );
+            dbChangeNotifier = CCalenDbChangeNotifier::NewL( tempSession );
+            dbChangeNotifier->RegisterObserverL(*iDBChangeNotifier);
+            filemap->SetDBChangeNotifier(dbChangeNotifier);
+            }            
+         else
+            {
+            CCalSession& tempSession = CalSessionL();
+            filemap->SetSessionPtr(&tempSession);
+            filemap->SetCollectionId(tempSession.CollectionIdL());
+            CreateEntryViewL(tempSession);
+            filemap->SetEntryView( iNewEntryView );
+            iGlobalDataOwnsEntryView = EFalse;
+            iGlobalDataOwnsCalSession = EFalse;
+            dbChangeNotifier = CCalenDbChangeNotifier::NewL( tempSession );
+            dbChangeNotifier->RegisterObserverL(*iDBChangeNotifier);
+            filemap->SetDBChangeNotifier(dbChangeNotifier);
+            }
+        iFileMappingArray.Append(filemap);        
+        CleanupStack::Pop(filemap);
+        }   
+    
+    for(TInt index = 0; index < iFileMappingArray.Count(); index++)
+        {
+        iHashDbidIndexMap.InsertL( iFileMappingArray[index]->GetCollectionId(),
+                                    index);
+        }
+    
+    TRACE_EXIT_POINT
+    return ETrue;
+    }
+
+// -----------------------------------------------------------------------------
+// CCalenGlobalData::InitializeGlobalDataL
+// Initializes multiple db related objects
+// -----------------------------------------------------------------------------
+EXPORT_C void CCalenGlobalData::InitializeGlobalDataL()
+    {
+    TRACE_ENTRY_POINT
+    
+    ConstructFileMappingL();
+    
+    TRACE_EXIT_POINT
+    }
+
+// -----------------------------------------------------------------------------
+// CCalenGlobalData::PromptToSelectDefaultMailboxL
+// Prompts the user to select the default mailbox. If the user cancels, the
+// function returns KErrCancel, otherwise it returns the index of the selected
+// mailbox. This function does not set the default mailbox, but rather returns
+// the index of the given array to which the default should be set.
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+TInt CCalenGlobalData::PromptToSelectDefaultMailboxL( RArray<CMRMailboxUtils::TMailboxInfo>& aMailboxes )
+    {
+    TRACE_ENTRY_POINT;
+
+    TInt mbCount = aMailboxes.Count();
+
+    TInt selected;
+    if (mbCount > 0)
+        {
+        CAknSinglePopupMenuStyleListBox* list =
+            new (ELeave) CAknSinglePopupMenuStyleListBox;
+        CleanupStack::PushL(list);
+
+        CAknPopupList* popupList = CAknPopupList::NewL(list, R_AVKON_SOFTKEYS_OK_CANCEL);
+        CleanupStack::PushL(popupList);
+
+        list->ConstructL(popupList, CEikListBox::ELeftDownInViewRect);
+        list->CreateScrollBarFrameL(ETrue);
+        list->ScrollBarFrame()->SetScrollBarVisibilityL(
+            CEikScrollBarFrame::EOff, CEikScrollBarFrame::EAuto);
+
+        CEikonEnv* eikEnv = CEikonEnv::Static();
+
+        CDesCArrayFlat* items = new (ELeave)CDesCArrayFlat(mbCount);
+        CleanupStack::PushL(items);
+        for(TInt i=0; i<mbCount; ++i)
+            {
+            items->AppendL( aMailboxes[i].iName );
+            }
+        CleanupStack::Pop(items);
+        CTextListBoxModel* model = list->Model();
+
+        //Pass ownersip of items to model
+        model->SetItemTextArray(items);
+
+        HBufC* title = StringLoader::LoadLC(R_CALEN_SELECT_MAILBOX, eikEnv);
+        popupList->SetTitleL(*title);
+        CleanupStack::PopAndDestroy(title);
+
+        TBool accepted = popupList->ExecuteLD();
+        CleanupStack::Pop(); // popupList
+
+        if(accepted)
+            {
+            selected = list->CurrentItemIndex();
+            }
+        else
+            {
+            selected = KErrCancel;
+            }
+
+        CleanupStack::PopAndDestroy();  // list
+        }
+    else
+        {
+        //No mailboxes defined.  Could prompt user to define one here?
+        selected = KErrCancel;
+        }
+
+    TRACE_EXIT_POINT;
+    return selected;
+    }
+
+// -----------------------------------------------------------------------------
+// CCalenGlobalData::HandleCalEngStatus
+// Called when Meeting Request utils are creation is complete.
+// Stops the CActiveSchedulerWait, allowing MeetingRequestUtilsL() to complete
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+void CCalenGlobalData::HandleCalEngStatus( TMRUtilsCalEngStatus aStatus )
+    {
+    TRACE_ENTRY_POINT;
+
+    ASSERT(iUtilsAs);
+
+    switch (aStatus)
+        {
+        case ENotReady:
+            {
+            //Keep waiting
+            }
+        break;
+        case EAvailableWithoutTombs:
+        case EAvailable:
+            {
+            //Ready for use.  Stop the CActiveSchedulerWait and return
+            iUtilsAs->AsyncStop();
+            iCreateError = KErrNone;
+            }
+        break;
+        case ENotAvailable:
+            {
+            //Somethings gone wrong.  Stop the CActiveSchedulerWait but force
+            //MeetingRequestUtilsL to leave.
+            //We'll use KErrNotFound for now but we don't know what the problem is.
+            iUtilsAs->AsyncStop();
+            iCreateError = KErrNotFound;
+            }
+        break;
+        default:
+            {
+            //Shouldn't ever get called.
+            iUtilsAs->AsyncStop();
+            iCreateError = KErrArgument;
+            }
+        break;
+        }
+
+    TRACE_EXIT_POINT;
+    }
+
+// -----------------------------------------------------------------------------
+// CCalenGlobalData::HandleNotification
+// Handle any notification if registered for
+// -----------------------------------------------------------------------------
+void CCalenGlobalData::HandleNotification(const TCalenNotification aNotification )
+	{
+	TRACE_ENTRY_POINT;
+
+	switch(aNotification)
+		{
+		case ECalenNotifyEntryInstanceViewCreated:
+			{
+			ViewCreationCompleted( ETrue );
+			}
+			break;
+		case ECalenNotifyEntryInstanceViewCreationFailed:
+			{
+			ViewCreationCompleted( EFalse );
+			}
+			break;
+		case ECalenNotifyDeleteInstanceView:
+			{
+			//InstanceView has to be deleted since deleting any session(Calendar) 
+			//entryView and instanceView has to be deleted before deleting session.
+			if(iNewInstanceView)
+				{
+				delete iNewInstanceView;
+				iNewInstanceViewCreation = iNewInstanceView =  NULL;
+				}
+			
+			//If InstanceView is called by any component single instanceView 
+			// without the knowledge of multi session (calendar).
+			//This instance also should be deleted for deleting the session.  
+			if(iInstanceView)
+				{
+				delete iInstanceView;
+				iInstanceView = iInstanceViewCreation = NULL;
+				}
+			}
+			break;
+		case ECalenNotifyRealExit:
+			{
+			iCalendarForcedExit = ETrue;
+			}
+			break;
+		case ECalenNotifyCalendarInfoCreated:
+			{
+			TRAP_IGNORE(HandleCalendarInfoCreatedL());
+			}
+			break;
+		case ECalenNotifyCalendarInfoUpdated:
+			{
+			TRAP_IGNORE(HandleCalendarInfoUpdatedL());
+			}
+			break;
+		case ECalenNotifyCalendarFileDeleted:
+			{
+			TRAP_IGNORE(HandleCalendarFileDeletedL());
+			}
+			break;
+		default:
+			break;
+		}
+
+    TRACE_EXIT_POINT;
+    }
+
+// -----------------------------------------------------------------------------
+// CCalenGlobalData::CreateEntryViewL
+// -----------------------------------------------------------------------------
 void CCalenGlobalData::CreateEntryViewL()
     {
     TRACE_ENTRY_POINT;
-    iEntryViewCreation = CCalEntryView::NewL( CalSessionL(), iCalCallBack );
+
+    HBufC* calendarFileName = KCalendarDatabaseFilePath().AllocLC();
+    TInt index  = iFileMappingArray.Find(   
+            *calendarFileName, CCalenGlobalData::CalenInfoIdentifierL);
+    CleanupStack::PopAndDestroy(calendarFileName);
+    if(index != KErrNotFound)
+        {
+        iEntryView = iFileMappingArray[index]->GetEntryView();
+        }
+    
+    if(!iEntryView)
+        {
+        User::LeaveIfNull(iEntryView);
+        }
+    
     TRACE_EXIT_POINT;
     }
 
+// -----------------------------------------------------------------------------
+// CCalenGlobalData::CreateEntryViewL
+// -----------------------------------------------------------------------------
+void  CCalenGlobalData::CreateEntryViewL(CCalSession& session)
+    {
+    TRACE_ENTRY_POINT;
+    iNewEntryViewCreation = CCalEntryView::NewL( session, iCalCallBack );
+    
+    if(iNewEntryViewCreation)
+        {
+        iNewEntryView = iNewEntryViewCreation;
+        }
+    
+    TRACE_EXIT_POINT;
+    }
+
+// -----------------------------------------------------------------------------
+// CCalenGlobalData::CreateInstanceViewL
+// -----------------------------------------------------------------------------
 void CCalenGlobalData::CreateInstanceViewL()
     {
     TRACE_ENTRY_POINT;
     iInstanceViewCreation = CCalInstanceView::NewL( CalSessionL(), iCalCallBack );
+     if(iInstanceViewCreation)
+        {
+        iInstanceView = iInstanceViewCreation;
+        }
+    TRACE_EXIT_POINT;
+    }
+
+// -----------------------------------------------------------------------------
+// CCalenGlobalData::CreateEntryViewL
+// -----------------------------------------------------------------------------
+void CCalenGlobalData::CreateInstanceViewL(const RArray<TInt>& aCollectionIds)
+    {
+    TRACE_ENTRY_POINT;
+    
+    RPointerArray<CCalSession> sessionArray;
+    
+    for(TInt i = 0; i < aCollectionIds.Count() ; i++)
+        {
+        TInt index = iHashDbidIndexMap.FindL(aCollectionIds[i]);
+        if(index != KErrNotFound)
+           {
+           CCalSession* sessionPtr = iFileMappingArray[index]->GetSessionPtr();
+           sessionArray.AppendL(sessionPtr);
+           }
+        }
+    
+    if(sessionArray.Count())
+        {
+        iNewInstanceViewCreation = CCalInstanceView::NewL( sessionArray, iCalCallBack );
+        if(iNewInstanceViewCreation)
+           {
+           iNewInstanceView = iNewInstanceViewCreation;        
+           }
+        }
+    
+    sessionArray.Reset();
     TRACE_EXIT_POINT;
     }
 
@@ -387,8 +1184,39 @@
     if ( !aSuccess )
         {
         // Something has gone wrong
-        delete iEntryViewCreation;
-        delete iInstanceViewCreation;
+        if (iEntryViewCreation)
+            {
+            delete iEntryViewCreation;
+            iEntryViewCreation = NULL;
+            }
+        if (iInstanceViewCreation)
+            {
+            delete iInstanceViewCreation;
+            iInstanceViewCreation = NULL;
+            }
+
+        if (iNewEntryViewCreation)
+            {
+            delete iNewEntryViewCreation;
+            iNewEntryViewCreation = NULL;
+
+            HBufC* fileName = iContext->GetCalendarFileNameL().AllocLC();
+            TInt index = iFileMappingArray.Find(*fileName,
+                    CCalenGlobalData::CalenInfoIdentifierL);
+            CleanupStack::PopAndDestroy(fileName);
+
+            if (index != KErrNotFound)
+                {
+                iFileMappingArray[index]->SetEntryView(NULL);
+                }
+            }
+
+        if (iNewInstanceViewCreation)
+            {
+            delete iNewInstanceViewCreation;
+            iNewInstanceViewCreation = NULL;
+            }
+
         }
     else
         {
@@ -400,11 +1228,22 @@
             {
             iInstanceView = iInstanceViewCreation;
             }
+        
+        if ( iNewEntryViewCreation )
+            {
+            iNewEntryView = iNewEntryViewCreation;
+            }
+        else if ( iNewInstanceViewCreation )
+            {
+            iNewInstanceView = iNewInstanceViewCreation;
+            }
         }
 
     iEntryViewCreation = NULL;
     iInstanceViewCreation = NULL;
-
+    iNewEntryViewCreation = NULL;
+    iNewInstanceViewCreation = NULL;
+    
     if ( iQueued )
         {
         (this->*iQueued)();
@@ -415,44 +1254,617 @@
     }
 
 // -----------------------------------------------------------------------------
-// CCalenGlobalData::RegisterEntryViewObserver
-// Add observer into view observers entry observer list.
+// CCalenGlobalData::CreateNewSessionL
+// Create a Calendar session if necessary and return a reference
 // (other items were commented in a header).
 // -----------------------------------------------------------------------------
-EXPORT_C TBool CCalenGlobalData::EntryViewExists()
-    {
-    TRACE_ENTRY_POINT;
-    TRACE_EXIT_POINT;
-    return ( iEntryView != NULL );
-    }
-
-
-// -----------------------------------------------------------------------------
-// CCalenGlobalData::Context
-// Return a reference to the CCalenContext object
-// (other items were commented in a header).
-// -----------------------------------------------------------------------------
-EXPORT_C MCalenContext& CCalenGlobalData::Context()
-    {
-    TRACE_ENTRY_POINT;
-    TRACE_EXIT_POINT;
-    return *iContext;
-    }
-
-void CCalenGlobalData::HandleNotification(const TCalenNotification aNotification )
+CCalSession& CCalenGlobalData::CreateNewSessionL( const TDesC& aCalendar )
     {
     TRACE_ENTRY_POINT;
 
-    if ( aNotification == ECalenNotifyEntryInstanceViewCreated )
+    if(!iNewCalSession)
         {
-        ViewCreationCompleted( ETrue );
+        iNewCalSession = CCalSession::NewL(*iCalSession);
+        
+        TRAPD( err, iNewCalSession->OpenL(aCalendar));
+        if ( err == KErrNotFound )
+           {
+           iNewCalSession->CreateCalFileL(aCalendar);
+           iNewCalSession->OpenL(aCalendar); // not trapped anymore
+           }
+        else
+           {
+           User::LeaveIfError( err );
+           }
         }
-    else if (aNotification == ECalenNotifyEntryInstanceViewCreationFailed )
+    TRACE_EXIT_POINT;
+    return *iNewCalSession;
+    }
+
+// -----------------------------------------------------------------------------
+// CCalenGlobalData::CalenInfoIdentifierL
+// -----------------------------------------------------------------------------
+//
+TBool CCalenGlobalData::CalenInfoIdentifierL( const HBufC* aName,
+                                        const CCalenFileMapping& aFileMapping)
+    {
+    TRACE_ENTRY_POINT;
+    TPtrC calendarFileName = aFileMapping.GetCalendarFileName();
+    TRACE_EXIT_POINT;
+    return (!calendarFileName.CompareF(*aName));
+    }
+
+// -----------------------------------------------------------------------------
+// CCalenGlobalData::AddCalendarL
+// adds new calendar file and sets calendar info to it 
+// -----------------------------------------------------------------------------
+//
+EXPORT_C void CCalenGlobalData::AddCalendarL(CCalCalendarInfo* aCalendarInfo)
+	{	
+	TRACE_ENTRY_POINT;
+	CleanupStack::PushL(aCalendarInfo);
+	
+	CCalenFileMapping* fileMapping = CCalenFileMapping::NewL();
+	CleanupStack::PushL(fileMapping);
+	
+	HBufC* calendarFileName = CCalenMultiCalUtil::GetNextAvailableCalFileL();
+	CleanupStack::PushL(calendarFileName);
+	fileMapping->SetCalendarFileNameL(calendarFileName->Des());
+	CleanupStack::PopAndDestroy(calendarFileName);
+	if(iCalSession)
+		{
+		iNewCalSession = NULL;
+		iNewEntryView  = NULL;
+		iNewEntryViewCreation  = NULL;
+		TPtrC calFileName = fileMapping->GetCalendarFileName();
+		CCalSession& tempSession = CreateNewSessionL( calFileName,
+													*aCalendarInfo );
+		fileMapping->SetSessionPtr(&tempSession);
+		fileMapping->SetCollectionId(tempSession.CollectionIdL());
+		
+		if(!iCalendarForcedExit)
+			{
+			CreateEntryViewL(tempSession);
+			}
+		fileMapping->SetEntryView( iNewEntryView );
+		CCalenDbChangeNotifier* dbChangeNotifier = CCalenDbChangeNotifier::NewL( tempSession );
+		dbChangeNotifier->RegisterObserverL(*iDBChangeNotifier);
+		fileMapping->SetDBChangeNotifier(dbChangeNotifier);
+		iCalendarInfoList.Append(tempSession.CalendarInfoL());
+		}
+	
+	CleanupStack::Pop(fileMapping);
+	iFileMappingArray.Append(fileMapping);
+	
+	iHashDbidIndexMap.Close();   
+	for(TInt index = 0; index < iFileMappingArray.Count(); index++)
+	    {
+	    iHashDbidIndexMap.InsertL( iFileMappingArray[index]->GetCollectionId(),
+                                   index);
+	    }
+	
+	CleanupStack::PopAndDestroy(aCalendarInfo);
+	aCalendarInfo = NULL;
+	
+	TRACE_EXIT_POINT
+	}
+
+// -----------------------------------------------------------------------------
+// CCalenGlobalData::RemoveDeadCalendarsL
+// removes dead calendar files from the file system
+// -----------------------------------------------------------------------------
+//
+EXPORT_C void CCalenGlobalData::RemoveDeadCalendarsL()
+    {
+    TRACE_ENTRY_POINT;
+    CCalCalendarIterator* calendarIterator = 
+                      CCalCalendarIterator::NewL(*iCalendarsSession);
+    CleanupStack::PushL(calendarIterator);
+    
+    for( CCalCalendarInfo* calendarInfo = calendarIterator->FirstL();
+         calendarInfo!=NULL;calendarInfo = calendarIterator->NextL())
         {
-        ViewCreationCompleted( EFalse );
+        CleanupStack::PushL(calendarInfo);
+        HBufC* filename = calendarInfo->FileNameL().AllocLC();
+        TInt index = iFileMappingArray.Find( *filename, 
+                                 CCalenGlobalData::CalenInfoIdentifierL);
+        if(KErrNotFound == index)
+            {
+            CCalSession* session = CCalSession::NewL(*iCalSession);
+            CleanupStack::PushL(session);
+            TRAP_IGNORE(session->DeleteCalFileL( *filename ));
+            CleanupStack::PopAndDestroy(session);
+            }
+        CleanupStack::PopAndDestroy(filename);
+        CleanupStack::PopAndDestroy(calendarInfo);
         }
-
+    CleanupStack::PopAndDestroy(calendarIterator);
     TRACE_EXIT_POINT;
     }
 
-// Enf of file
+// -----------------------------------------------------------------------------
+// CCalenGlobalData::RemoveCalendarL
+// removes calendar file from the file system
+// -----------------------------------------------------------------------------
+//
+EXPORT_C void CCalenGlobalData::RemoveCalendarL(const TDesC& aCalendarFileName)
+	{
+	TRACE_ENTRY_POINT;
+
+	HBufC* calendarFilename = aCalendarFileName.AllocLC();
+	TInt index = iFileMappingArray.Find( *calendarFilename, 
+				CCalenGlobalData::CalenInfoIdentifierL);
+	
+    if( KErrNotFound == index )
+        {
+        CleanupStack::PopAndDestroy(calendarFilename);
+        // reconstruct the calendar list using the iterator
+        ConstructCalendarsListL();
+        
+        TRACE_EXIT_POINT;
+        return;
+        }
+
+	if( index >= 0 )
+		{
+        CCalenFileMapping* filemap = iFileMappingArray.operator [](index);
+        CCalSession* session = filemap->GetSessionPtr();
+		if(session)
+			{
+            TRAPD(err, session->DeleteCalFileL(aCalendarFileName));
+            if( err == KErrInUse )
+                {
+                //Calendar file is opened by other application.
+                //Mark the file as deleted. Try delete the file at later time.
+                // Get the CalFile
+                CCalCalendarInfo* caleninfo = session->CalendarInfoL();
+                CleanupStack::PushL(caleninfo);
+                
+                // Mark the CalFile as Hidden
+                caleninfo->SetEnabled( EFalse );
+                            
+                
+                TBuf8<KBuffLength> keyBuff;
+                
+                // Set the modification time as home time.
+                keyBuff.Zero();
+                keyBuff.AppendNum(EModificationTime);
+                TTime modificationTime;
+                modificationTime.HomeTime();
+                TPckgC<TTime> pkgModificationTime(modificationTime);
+                caleninfo->SetPropertyL(keyBuff, pkgModificationTime);
+                
+                // Set the SyncStatus to False
+                keyBuff.Zero();
+                keyBuff.AppendNum( ESyncStatus );
+                TBool syncstatus( EFalse );
+                TPckgC<TBool> pckgSyncStatusValue( syncstatus );
+                caleninfo->SetPropertyL( keyBuff, pckgSyncStatusValue );
+                
+                // Mark the meta property as SoftDeleted
+                keyBuff.Zero();
+                keyBuff.AppendNum(EMarkAsDelete);
+                TPckgC<TBool> pkgSoftDelete( ETrue );
+                caleninfo->SetPropertyL(keyBuff, pkgSoftDelete);
+                
+                session->SetCalendarInfoL( *caleninfo );
+                CleanupStack::PopAndDestroy(caleninfo);            
+                }
+            
+            TRAP_IGNORE(DeleteCalendarMissedAlarmsL(aCalendarFileName));
+            
+            TInt infoListIndex = iCalendarInfoList.Find(*calendarFilename,
+                        CCalenGlobalData::CalenCalendarInfoIdentiferL);
+            
+            CCalCalendarInfo* calendarInfo = iCalendarInfoList[infoListIndex];
+            iCalendarInfoList.Remove(infoListIndex);
+            delete calendarInfo;
+            calendarInfo = NULL;
+
+            iHashDbidIndexMap.Close();
+
+            iFileMappingArray.Remove(index);
+            delete filemap;
+            for(TInt index = 0; index < iFileMappingArray.Count(); index++)
+                {
+                iHashDbidIndexMap.InsertL(iFileMappingArray[index]->GetCollectionId(), index);
+                }
+			}
+		}
+
+	
+	CleanupStack::PopAndDestroy(calendarFilename);        
+	TRACE_EXIT_POINT;
+	}
+
+// -----------------------------------------------------------------------------
+// CCalenGlobalData::UpdateCalendarL
+// updates calendar info for the calendar file
+// -----------------------------------------------------------------------------
+//
+EXPORT_C void CCalenGlobalData::UpdateCalendarL(CCalCalendarInfo* aCalendarInfo)
+	{
+	TRACE_ENTRY_POINT;
+
+	HBufC* calendar = aCalendarInfo->FileNameL().AllocLC();
+	TInt index = iFileMappingArray.Find( *calendar, 
+				CCalenGlobalData::CalenInfoIdentifierL);
+
+	if(index != KErrNotFound)
+		{
+		CCalSession* session = iFileMappingArray[index]->GetSessionPtr();
+		if(session)
+			{
+			session->SetCalendarInfoL(*aCalendarInfo);
+			}
+		}
+	CleanupStack::PopAndDestroy(calendar);
+
+	TRACE_EXIT_POINT;
+	}
+
+// -----------------------------------------------------------------------------
+// CCalenGlobalData::GetCalFileNameForCollectionId
+// Get Calendar file name for the given collectionid
+// -----------------------------------------------------------------------------
+//
+EXPORT_C const TDesC& CCalenGlobalData::GetCalFileNameForCollectionId( 
+     const TCalCollectionId aColId)
+	{
+	TRACE_ENTRY_POINT;
+
+	TInt index = iFileMappingArray.Find( aColId,
+			CCalenGlobalData::CalenFileMapIdentifierForColId );
+	
+	if(index != KErrNotFound)
+		{
+		TRACE_EXIT_POINT;
+		return iFileMappingArray[index]->GetCalendarFileName();
+		}
+	else
+	    {
+	    TRACE_EXIT_POINT;
+	    return KNullDesC;
+	    }
+	}
+
+// -----------------------------------------------------------------------------
+// CCalenGlobalData::GetAllCalendarInfoL
+// Get all available calendar info
+// -----------------------------------------------------------------------------
+//
+EXPORT_C void CCalenGlobalData::GetAllCalendarInfoL( 
+                    RPointerArray<CCalCalendarInfo>& aCalendarInfoList )
+	{
+	TRACE_ENTRY_POINT;
+	CleanupClosePushL(aCalendarInfoList);
+    RFs fsSession;
+    CleanupClosePushL( fsSession );
+    RResourceFile resourceFile;
+    CleanupClosePushL( resourceFile );
+    User::LeaveIfError( fsSession.Connect() );
+    TFileName resourceFileName( KMissedAlarmResourceFile );
+		
+    BaflUtils::NearestLanguageFile( fsSession, resourceFileName );
+    resourceFile.OpenL(fsSession, resourceFileName );
+    resourceFile.ConfirmSignatureL( 0 );   
+	for(TInt index=0;index < iCalendarInfoList.Count();index++)
+	    {
+        
+	    TPtrC calendarNamePtr = iCalendarInfoList[index]->NameL();
+        if(calendarNamePtr.Compare(KPersonal) == 0)
+            {  
+            HBufC8* personalBuffer = resourceFile.AllocReadLC( R_CALE_DB_PERSONAL );    
+            const TPtrC16 ptrPBuffer(( TText16*) personalBuffer->Ptr(),
+                                             ( personalBuffer->Length()+1 )>>1 );    
+            HBufC *personalCalendar = ptrPBuffer.AllocL();    
+            CleanupStack::PushL(personalCalendar);
+            iCalendarInfoList[index]->SetNameL(*personalCalendar);
+            CleanupStack::PopAndDestroy( 2,personalBuffer );
+            }
+       
+	   
+            aCalendarInfoList.AppendL(iCalendarInfoList[index]);
+	        
+	    }
+	 CleanupStack::PopAndDestroy(2);
+	 CleanupStack::Pop(&aCalendarInfoList);
+	TRACE_EXIT_POINT;
+	}
+
+// -----------------------------------------------------------------------------
+// CCalenGlobalData::CreateNewSessionL
+// Create new session with metadata
+// -----------------------------------------------------------------------------
+//
+CCalSession& CCalenGlobalData::CreateNewSessionL( const TDesC& aCalendar,
+                     const CCalCalendarInfo& aCalendarInfo )
+	{
+	TRACE_ENTRY_POINT;
+
+	if(!iNewCalSession)
+		{
+		iNewCalSession = CCalSession::NewL(*iCalSession);
+		
+		TRAPD( err, iNewCalSession->OpenL(aCalendar));
+		if ( err == KErrNotFound )
+		   {
+		   iNewCalSession->CreateCalFileL( aCalendar, aCalendarInfo );
+		   iNewCalSession->OpenL(aCalendar); // not trapped anymore
+		   }
+		else
+		   {
+		   User::LeaveIfError( err );
+		   }
+		}
+	TRACE_EXIT_POINT;
+	return *iNewCalSession;
+	}
+
+// -----------------------------------------------------------------------------
+// CCalenGlobalData::CalenFileMapIdentifierForColId
+// Search for filemap index based on collection id
+// -----------------------------------------------------------------------------
+//
+TBool CCalenGlobalData::CalenFileMapIdentifierForColId(const TCalCollectionId* aId,
+                                       const CCalenFileMapping& aFileMapping )
+	{
+	TRACE_ENTRY_POINT;
+	TRACE_EXIT_POINT;
+	return (*aId == (aFileMapping.GetCollectionId()));
+	}
+
+// -----------------------------------------------------------------------------
+// CCalenGlobalData::CalenCalendarInfoIdentiferL
+// Construct calendar list from the calendar iterator
+// -----------------------------------------------------------------------------
+//
+TBool CCalenGlobalData::CalenCalendarInfoIdentiferL(const HBufC* aFileName,
+                                                        const CCalCalendarInfo& aCalendarInfo)
+    {
+    TRACE_ENTRY_POINT
+    TPtrC calendarFileName = aCalendarInfo.FileNameL();
+    TRACE_EXIT_POINT
+    return (!calendarFileName.CompareF(*aFileName) );
+    }
+
+// -----------------------------------------------------------------------------
+// CCalenGlobalData::ConstructCalendarsListL
+// Construct calendar list from the calendar iterator
+// -----------------------------------------------------------------------------
+//
+void CCalenGlobalData::ConstructCalendarsListL()
+    {
+    TRACE_ENTRY_POINT;
+    
+    iCalendarInfoList.ResetAndDestroy();
+    CCalCalendarIterator* calendarIterator = 
+        CCalCalendarIterator::NewL(*iCalendarsSession);
+    CleanupStack::PushL(calendarIterator);
+    
+    for( CCalCalendarInfo* calendarInfo = calendarIterator->FirstL();
+         calendarInfo!=NULL;calendarInfo = calendarIterator->NextL())
+        {
+        TBuf8<KBuffLength> keyBuff;
+        // Mark the meta property as SoftDeleted
+        keyBuff.Zero();
+        keyBuff.AppendNum(EMarkAsDelete);
+        TBool softDelete = EFalse;
+        TPckgC<TBool> pkgSoftDelete( softDelete );
+        TRAPD(err,pkgSoftDelete.Set(calendarInfo->PropertyValueL(keyBuff)));
+        if( KErrNone == err )
+            {
+            softDelete = pkgSoftDelete();
+            }
+        if( softDelete && 
+                calendarInfo->FileNameL().CompareF(CalSessionL().DefaultFileNameL()) )
+            {
+            // delete caleninfo except for default calendar.
+            delete calendarInfo;
+            }
+        else
+            {
+            iCalendarInfoList.Append(calendarInfo);
+            }
+        }
+    CleanupStack::PopAndDestroy(calendarIterator);
+    
+    TRACE_EXIT_POINT;
+    }
+
+// -----------------------------------------------------------------------------
+// CCalenGlobalData::UpdateCalendarListL
+// Update calendar list whenever CalendarInfoUpdated notification is received.
+// -----------------------------------------------------------------------------
+//
+void CCalenGlobalData::UpdateCalendarListL()
+    {
+	//Getting calendar name updated from calennotifier infochangednotification
+    HBufC* calendarNameUpdated = iContext->GetCalendarFileNameL().AllocLC();
+    TInt index = iFileMappingArray.Find( *calendarNameUpdated, 
+                    CCalenGlobalData::CalenInfoIdentifierL);
+
+    if(index != KErrNotFound)
+        {
+        CCalSession* session = iFileMappingArray[index]->GetSessionPtr();
+        for(TInt i=0; i<iCalendarInfoList.Count() ;i++)
+            {
+            if( !iCalendarInfoList[i]->FileNameL().CompareF(calendarNameUpdated->Des()))
+                {
+                iCalendarInfoList[i] = session->CalendarInfoL();
+                }
+            }
+        }
+    CleanupStack::PopAndDestroy(calendarNameUpdated);
+    }
+// -----------------------------------------------------------------------------
+// CCalenGlobalData::GetDefaultCalendarInfoL
+// Get default calendar info
+// -----------------------------------------------------------------------------
+//
+CCalCalendarInfo* CCalenGlobalData::GetDefaultCalendarInfoL()
+	{
+	TRACE_ENTRY_POINT;
+
+	CCalCalendarInfo* defaultCalendarInfo = CCalCalendarInfo::NewL();
+	CleanupStack::PushL(defaultCalendarInfo);
+	defaultCalendarInfo->SetColor(KCalenBlue.Value());
+	defaultCalendarInfo->SetEnabled(ETrue);
+	defaultCalendarInfo->SetNameL(KPhoneCalendar);
+	CleanupStack::Pop(defaultCalendarInfo);
+
+	TRACE_EXIT_POINT;
+	return defaultCalendarInfo;
+	}
+
+// -----------------------------------------------------------------------------
+// CCalenGlobalData::HandleCalendarInfoCreatedL
+// Handles the notification ECalenNotifyCalendarInfoCreated
+// -----------------------------------------------------------------------------
+//
+void CCalenGlobalData::HandleCalendarInfoCreatedL()
+	{
+	TRACE_ENTRY_POINT;
+	// get the filename from the context
+	TDesC& fileName = iContext->GetCalendarFileNameL();
+
+	// check for the calendar file already exists in filemap list
+	HBufC* calendar = fileName.AllocLC();
+	TInt index = iFileMappingArray.Find(*calendar,
+			CCalenGlobalData::CalenInfoIdentifierL);
+	CleanupStack::PopAndDestroy(calendar);
+	
+	// if not exists,add to filemapper list
+	if (KErrNotFound == index)
+		{
+		CCalenFileMapping* fileMapper = CCalenFileMapping::NewL();
+		CleanupStack::PushL(fileMapper);
+		fileMapper->SetCalendarFileNameL(fileName);
+
+		iNewEntryView  = NULL;
+		iNewEntryViewCreation  = NULL;
+		CCalSession* newSession = NULL;
+		if(iCalSession)
+			{
+			// create the new session using default session
+			newSession = CCalSession::NewL(*iCalSession);
+			CleanupStack::PushL(newSession);
+			TRAPD(err,newSession->OpenL(fileName));
+			User::LeaveIfError( err );
+			CleanupStack::Pop(newSession);
+			// set filemapper data 
+			fileMapper->SetSessionPtr(newSession);
+			fileMapper->SetCollectionId(newSession->CollectionIdL());
+			 
+			if(!iCalendarForcedExit)
+				{
+				CreateEntryViewL(*newSession);
+				}
+			fileMapper->SetEntryView( iNewEntryView );
+			
+			iCalendarInfoList.AppendL(newSession->CalendarInfoL());
+		    CCalenDbChangeNotifier* dbChangeNotifier = CCalenDbChangeNotifier::NewL( *newSession );
+		    dbChangeNotifier->RegisterObserverL(*iDBChangeNotifier);
+		    fileMapper->SetDBChangeNotifier(dbChangeNotifier);
+			}
+		else
+			{
+			// create the first session
+			iCalSession = CCalSession::NewL();
+			TRAPD(err,iCalSession->OpenL(fileName));
+			User::LeaveIfError(err);
+			
+			// set filemapper data 
+			fileMapper->SetSessionPtr(iCalSession);
+			fileMapper->SetCollectionId(iCalSession->CollectionIdL());
+			
+			if(!iCalendarForcedExit)
+				{
+				CreateEntryViewL(*iCalSession);
+				}
+			
+			fileMapper->SetEntryView(iNewEntryView);
+	        CCalenDbChangeNotifier* dbChangeNotifier = CCalenDbChangeNotifier::NewL( *iCalSession );
+	        fileMapper->SetDBChangeNotifier(dbChangeNotifier);
+	        dbChangeNotifier->RegisterObserverL(*iDBChangeNotifier);
+			iGlobalDataOwnsEntryView = EFalse;
+			iGlobalDataOwnsCalSession = EFalse;
+			iCalendarInfoList.AppendL(iCalSession->CalendarInfoL());
+			}
+		// append to filemapper list
+		iFileMappingArray.Append(fileMapper);
+		CleanupStack::Pop(fileMapper);
+
+		iHashDbidIndexMap.Close();
+		for(TInt index = 0; index < iFileMappingArray.Count(); index++)
+			{
+			iHashDbidIndexMap.InsertL(
+				iFileMappingArray[index]->GetCollectionId(), index);
+			}
+		}
+	TRACE_EXIT_POINT;
+	}
+
+// -----------------------------------------------------------------------------
+// CCalenGlobalData::HandleCalendarInfoUpdatedL
+// Handles the notification ECalenNotifyCalendarInfoUpdated
+// -----------------------------------------------------------------------------
+//
+void CCalenGlobalData::HandleCalendarInfoUpdatedL()
+	{
+	TRACE_ENTRY_POINT;
+    
+	//Update Calendar list.
+    	UpdateCalendarListL();
+	    
+	TRACE_EXIT_POINT;
+	}
+
+// -----------------------------------------------------------------------------
+// CCalenGlobalData::HandleCalendarFileDeletedL
+// Handles the notification ECalenNotifyCalendarFileDeleted
+// -----------------------------------------------------------------------------
+//
+void CCalenGlobalData::HandleCalendarFileDeletedL()
+	{
+	TRACE_ENTRY_POINT;
+
+	// get the filename from the context
+	TDesC& fileName = iContext->GetCalendarFileNameL();
+
+	// delete the calendar file
+	RemoveCalendarL(fileName);
+	
+	TRACE_EXIT_POINT;
+	}
+
+// -----------------------------------------------------------------------------
+// CCalenGlobalData::DeleteCalendarMissedAlarmsL
+// Delete all missed alarms for deleted calendar 
+// -----------------------------------------------------------------------------
+//
+void CCalenGlobalData::DeleteCalendarMissedAlarmsL(const TDesC& aCalendarFilename)
+    {
+    TRACE_ENTRY_POINT
+    //Clear all missed alarms related to this calendar
+    CMissedAlarmStore* missedAlarmStore = CMissedAlarmStore::NewLC();
+    RPointerArray<CMissedAlarm> missedAlarms;
+    CleanupResetAndDestroyPushL(missedAlarms);
+
+    missedAlarmStore->GetL(missedAlarms);
+
+    for (TInt idx = 0; idx < missedAlarms.Count(); idx++)
+        {
+        CMissedAlarm* missedAlarm = missedAlarms[idx];
+        if (!missedAlarm->iCalFileName.CompareF(aCalendarFilename))
+            {
+            missedAlarmStore->RemoveL(*missedAlarm);
+            }
+        }
+
+    CleanupStack::PopAndDestroy(&missedAlarms);
+    CleanupStack::PopAndDestroy(missedAlarmStore);
+    TRACE_EXIT_POINT    
+    }
+
+// End of file