1 /*

     2 * Copyright (c) 2002-2008 Nokia Corporation and/or its subsidiary(-ies).

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:   Global Data for Calendar application

    15 *

    16 */

    17 

    18 

    19 

    20 //debug

    21 #include "calendarui_debug.h"

    22 

    23 // INCLUDE FILES

    24 #include "calenglobaldata.h"        // CCalenGlobalData

    25 #include "RImplInfoPtrArrayOwn.inl" // Wrapper class with array deletion on close

    26 #include "calensend.h"              // CCalenSend

    27 #include "CalenInterimUtils2.h"     // CalenInterimUtils

    28 #include "calencontextimpl.h"       // Calendar context implementation

    29 #include "calenfilemapping.h"

    30 

    31 #include <Calendar.rsg>             // Calendar resources

    32 #include <cmrmailboxutils.h>        // CMRMailboxUtils

    33 #include <utf.h>                    // CnvUtfConverter

    34 #include <StringLoader.h>           // Loads strings from resource files

    35 #include <featmgr.h>                // Feature discovery API

    36 #include <calsession.h>             // Calendar database session

    37 #include <calinstanceview.h>        // Calendar Instance view

    38 #include <calentryview.h>           // Calendar Entry view

    39 #include <cmrmailboxutils.h>        // CMRMailboxUtils

    40 #include <calencommands.hrh>            // Calendar commands

    41 #include <aknlists.h>

    42 #include <aknPopup.h>

    43 #include <AknUtils.h>

    44 #include <AknQueryDialog.h>

    45 #include <calencontext.h>

    46 #include <calcalendarinfo.h>

    47 #include <calcalendariterator.h>

    48 #include <CalendarInternalCRKeys.h>

    49 #include <calenmulticalutil.h>

    50 

    51 // Default Calendar database path

    52 _LIT( KCalendarDatabaseFilePath, "c:calendar" );

    53 _LIT( KPhoneCalendar,"Personal" );

    54 _LIT( KExtCalendar,"Ext calendar" );

    55 const TInt KBuffLength = 24;

    56 

    57 // ============================ MEMBER FUNCTIONS ===============================

    58 

    59 // -----------------------------------------------------------------------------

    60 // CCalenGlobalData::CCalenGlobalData

    61 // C++ default constructor can NOT contain any code, that might leave.

    62 // (other items were commented in a header).

    63 // -----------------------------------------------------------------------------

    64 //

    65 CCalenGlobalData::CCalenGlobalData( MCalProgressCallBack& aCalCallBack )

    66     : iCalCallBack( aCalCallBack )

    67     {

    68     TRACE_ENTRY_POINT;

    69 

    70     iGlobalDataOwnsCalSession = EFalse;

    71     iGlobalDataOwnsEntryView = EFalse;

    72     

    73     iCalendarForcedExit = EFalse;

    74     

    75     TRACE_EXIT_POINT;

    76     }

    77 

    78 // ----------------------------------------------------------------------------

    79 // CCalenGlobalData::NewL

    80 // Two phased construction. This will leave if an instance of global data

    81 // already exists.  All access to an instance of the global data should be

    82 // through the InstanceL function, except for the initial construction

    83 // which should be handled by the controller.

    84 // (other items were commented in a header).

    85 // ----------------------------------------------------------------------------

    86 //

    87 EXPORT_C CCalenGlobalData* CCalenGlobalData::NewL( MCalProgressCallBack& aCalCallBack,

    88                                                    MCalenContextChangeObserver* aNotifier )

    89     {

    90     TRACE_ENTRY_POINT;

    91 

    92     CCalenGlobalData* self = NULL;

    93     TAny* tlsPtr = Dll::Tls();

    94 

    95     // Check Thread local storage

    96     if (!tlsPtr)

    97         {

    98         // TLS is NULL, so no CCalenGlobalData has been created yet.

    99         self = new( ELeave ) CCalenGlobalData( aCalCallBack );

   100         CleanupStack::PushL( self );

   101         // Store a self pointer in TLS

   102         User::LeaveIfError( Dll::SetTls( static_cast<TAny*>( self ) ) );

   103         // Increment ref count right away. If we don't do it here, and someone

   104         // calls CCalenGlobalData::InstanceL in ConstructL and then ConstructL

   105         // leaves, we will double delete the global data.

   106         ++self->iRefCount;

   107         self->ConstructL( aNotifier );

   108         CleanupStack::Pop( self );

   109         }

   110     else

   111         {

   112         // An instance of the global data exists already.

   113         // This function should only have been called once, by CCalenAppUi

   114         User::Leave( KErrAlreadyExists );

   115         }

   116 

   117     TRACE_EXIT_POINT;

   118     return self;

   119     }

   120 

   121 // -----------------------------------------------------------------------------

   122 // CCalenGlobalData::InstanceL

   123 // Two-phased constructor.

   124 // (other items were commented in a header).

   125 // -----------------------------------------------------------------------------

   126 EXPORT_C CCalenGlobalData* CCalenGlobalData::InstanceL()

   127     {

   128     TRACE_ENTRY_POINT;

   129 

   130     CCalenGlobalData* self = NULL;

   131     TAny* tlsPtr = Dll::Tls();

   132 

   133     // Check Thread local storage

   134     if (!tlsPtr)

   135         {

   136         // The global data has not yet been constructed.

   137         // FIXME - Revise comment

   138         //TLS is NULL, so no CCalenGlobalData has been created yet.

   139       /*  self = new( ELeave ) CCalenGlobalData;

   140         CleanupStack::PushL( self );

   141         self->ConstructL();

   142         //Store a self pointer in TLS

   143         User::LeaveIfError( Dll::SetTls(static_cast<TAny*>(self)));

   144         CleanupStack::Pop(self);*/

   145         User::Leave( KErrNotReady );

   146         }

   147     else

   148         {

   149         self = static_cast<CCalenGlobalData*>( tlsPtr );

   150         }

   151 

   152     ++self->iRefCount;

   153 

   154     TRACE_EXIT_POINT;

   155     return self;

   156     }

   157 

   158 // -----------------------------------------------------------------------------

   159 // CCalenGlobalData::InstanceL

   160 // Two-phased constructor.  Creates the CCalenGlobalData with an existing

   161 // CCalSession.  CCalenGlobalData does NOT take ownership of the passed session

   162 // The caller is responsible for ensuring that the session exists until all

   163 // open references to the CCalenGlobalData are released.

   164 // Calls User::Invariant() if CCalenGlobalData already has a valid session.

   165 // (other items were commented in a header).

   166 // -----------------------------------------------------------------------------

   167 EXPORT_C CCalenGlobalData* CCalenGlobalData::InstanceL(CCalSession& aSession)

   168     {

   169     TRACE_ENTRY_POINT;

   170 

   171     CCalenGlobalData* self = CCalenGlobalData::InstanceL();

   172     CleanupStack::PushL(self);

   173     self->SetSessionL(&aSession);

   174     CleanupStack::Pop(self);

   175 

   176     TRACE_EXIT_POINT;

   177     return self;

   178     }

   179 

   180 // -----------------------------------------------------------------------------

   181 // CCalenGlobalData::InstanceL

   182 // Non-leaving version of constructor. Returns an instance of

   183 // CCalenGlobalData if one exists or NULL otherwise

   184 // (other items were commented in a header).

   185 // -----------------------------------------------------------------------------

   186 EXPORT_C CCalenGlobalData* CCalenGlobalData::Instance()

   187     {

   188     TRACE_ENTRY_POINT;

   189 

   190     TAny* tlsPtr = Dll::Tls();

   191     CCalenGlobalData* self = static_cast<CCalenGlobalData*>( tlsPtr );

   192 

   193     if ( self )

   194         {

   195         ++self->iRefCount;

   196         }

   197 

   198     TRACE_EXIT_POINT;

   199     return self;

   200     }

   201 

   202 // -----------------------------------------------------------------------------

   203 // CCalenGlobalData::ConstructL

   204 // Symbian 2nd phase constructor can leave.

   205 // (other items were commented in a header).

   206 // -----------------------------------------------------------------------------

   207 void CCalenGlobalData::ConstructL( MCalenContextChangeObserver* aNotifier )

   208     {

   209     TRACE_ENTRY_POINT;

   210 

   211     iContext = new (ELeave ) CCalenContextImpl( aNotifier );  

   212     

   213     iNewInstanceViewCreation = NULL;

   214     

   215     TRACE_EXIT_POINT;

   216     }

   217 

   218 // -----------------------------------------------------------------------------

   219 // CCalenGlobalData::SetSessionL

   220 // Sets the CCalenGlobalData to use an externally created CCalSession.

   221 // Leaves with KErrAlreadyExists if a session has already been created by the

   222 // CCalenGlobalData

   223 // (other items were commented in a header).

   224 // -----------------------------------------------------------------------------

   225 void CCalenGlobalData::SetSessionL(CCalSession* aSession)

   226     {

   227     TRACE_ENTRY_POINT;

   228 

   229     if (iCalSession)

   230         {

   231         __ASSERT_ALWAYS(iCalSession == aSession, User::Leave(KErrAlreadyExists));

   232         }

   233     else

   234         {

   235         iGlobalDataOwnsCalSession = EFalse;

   236         iCalSession = aSession;

   237         }

   238 

   239     TRACE_EXIT_POINT;

   240     }

   241 

   242 // -----------------------------------------------------------------------------

   243 // CCalenGlobalData::Release

   244 // Release handle to CCalenGlobalData.  If no other objects are referencing

   245 // this class it will be deleted

   246 // (other items were commented in a header).

   247 // -----------------------------------------------------------------------------

   248 EXPORT_C void CCalenGlobalData::Release()

   249     {

   250     TRACE_ENTRY_POINT;

   251 

   252     --iRefCount;

   253     if (iRefCount == 0)

   254         {

   255         delete this;

   256         }

   257 

   258     TRACE_EXIT_POINT;

   259     }

   260 

   261 // -----------------------------------------------------------------------------

   262 // Destructor

   263 // This is private and should only be called from the Release() function above

   264 // (other items were commented in a header).

   265 // -----------------------------------------------------------------------------

   266 CCalenGlobalData::~CCalenGlobalData()

   267     {

   268     TRACE_ENTRY_POINT;

   269 

   270     delete iSend;

   271     delete iInterimUtils;

   272     delete iUtilsAs;

   273     delete iMailboxUtils;

   274     delete iMRUtils;

   275 

   276     if (iInstanceView)

   277         {

   278         delete iInstanceView;

   279         iInstanceView = NULL;

   280         }

   281 

   282     if (iInstanceViewCreation)

   283         {

   284         delete iInstanceViewCreation;

   285         iInstanceViewCreation = NULL;

   286         }

   287 

   288     if (iEntryViewCreation)

   289         {

   290         delete iEntryViewCreation;

   291         iEntryViewCreation = NULL;

   292         }

   293 

   294     if (iNewInstanceViewCreation)

   295         {

   296         delete iNewInstanceViewCreation;

   297         iNewInstanceViewCreation = NULL;

   298         }

   299 

   300     if (iNewInstanceView)

   301         {

   302         delete iNewInstanceView;

   303         iNewInstanceView = NULL;

   304         }

   305 

   306     delete iContext;

   307     

   308     if(iGlobalDataOwnsEntryView)

   309         {

   310         if(iEntryView)

   311             {

   312             delete iEntryView;

   313             iEntryView = NULL;           

   314             }

   315         }

   316 

   317    if (iGlobalDataOwnsCalSession)

   318         {

   319         delete iCalSession;

   320         }

   321     

   322     if( iFileMappingArray.Count() )

   323         {

   324         iFileMappingArray.ResetAndDestroy();

   325         }

   326     

   327     iKeyQueue.Reset();

   328     

   329     iHashDbidIndexMap.Close();

   330 

   331     Dll::SetTls(NULL);

   332 

   333     if (iCalendarInfoList.Count())

   334         {

   335         iCalendarInfoList.ResetAndDestroy();

   336         }

   337 

   338     if (iCalendarsSession)

   339         {

   340         delete iCalendarsSession;

   341         iCalendarsSession = NULL;

   342         }

   343 

   344     TRACE_EXIT_POINT;

   345     }

   346 

   347 // -----------------------------------------------------------------------------

   348 // CCalenGlobalData::MailboxUtilsL

   349 // Create MailBoxUtils if necessary and returns a reference

   350 // (other items were commented in a header).

   351 // -----------------------------------------------------------------------------

   352 EXPORT_C CMRMailboxUtils& CCalenGlobalData::MRMailboxUtilsL()

   353     {

   354     TRACE_ENTRY_POINT;

   355 

   356     if (!iMailboxUtils)

   357         {

   358         if (InterimUtilsL().MRViewersEnabledL())

   359             {

   360             iMailboxUtils = CMRMailboxUtils::NewL();

   361             }

   362         else

   363             {

   364             User::Leave(KErrNotSupported);

   365             }

   366         }

   367 

   368     TRACE_EXIT_POINT;

   369     return *iMailboxUtils;

   370     }

   371 

   372 // -----------------------------------------------------------------------------

   373 // CCalenGlobalData::CalSessionL

   374 // Create a Calendar session if necessary and return a reference

   375 // (other items were commented in a header).

   376 // -----------------------------------------------------------------------------

   377 EXPORT_C CCalSession& CCalenGlobalData::CalSessionL()

   378     {

   379     TRACE_ENTRY_POINT;

   380     

   381     if (!iCalSession)

   382         {

   383         iGlobalDataOwnsCalSession = ETrue;

   384         iCalSession = CCalSession::NewL();

   385 

   386         TRAPD( err, iCalSession->OpenL(KCalendarDatabaseFilePath));

   387         if (err == KErrNotFound)

   388             {

   389             CCalCalendarInfo* calendarInfo = GetDefaultCalendarInfoL();

   390             CleanupStack::PushL(calendarInfo);

   391             iCalSession->CreateCalFileL( KCalendarDatabaseFilePath,

   392                                         *calendarInfo);

   393             iCalSession->OpenL(KCalendarDatabaseFilePath);

   394             CleanupStack::PopAndDestroy(calendarInfo);

   395             }

   396         else if(err == KErrNone)

   397             {

   398             // temp solution...need to handle this case

   399             CCalCalendarInfo* calendarInfo = iCalSession->CalendarInfoL();

   400             CleanupStack::PushL(calendarInfo);

   401             if( !calendarInfo->NameL().Compare(KNullDesC) && 

   402                  !calendarInfo->Enabled() )

   403                 {

   404                 calendarInfo->SetNameL(KExtCalendar);

   405                 calendarInfo->SetColor(KRgbBlack.Value());

   406                 iCalSession->SetCalendarInfoL(*calendarInfo);

   407                 }

   408             CleanupStack::PopAndDestroy(calendarInfo);

   409             

   410             }

   411         else

   412             {

   413             User::LeaveIfError( err );

   414             }

   415         }

   416 

   417     TRACE_EXIT_POINT;

   418     return *iCalSession;

   419     }

   420 

   421 // -----------------------------------------------------------------------------

   422 // CCalenGlobalData::CalSessionL

   423 // Based on the calendar name return already cached session from iFileMappingArray

   424 // (other items were commented in a header).

   425 // -----------------------------------------------------------------------------

   426 EXPORT_C CCalSession& CCalenGlobalData::CalSessionL(const TDesC& aCalendar)

   427     {

   428     TRACE_ENTRY_POINT;

   429     CCalSession* session = NULL;

   430     HBufC* calendarFileName = aCalendar.AllocLC();

   431     TInt index = iFileMappingArray.Find(

   432             *calendarFileName,CCalenGlobalData::CalenInfoIdentifierL);

   433     CleanupStack::PopAndDestroy(calendarFileName);

   434     if(KErrNotFound != index)

   435         {

   436         session = iFileMappingArray[index]->GetSessionPtr();

   437         }

   438     else

   439         {

   440         User::LeaveIfError(KErrNotFound);

   441         }

   442     

   443     TRACE_EXIT_POINT;

   444     return *session;

   445     }

   446 

   447 // -----------------------------------------------------------------------------

   448 // CCalenGlobalData::InstanceViewL

   449 // Create an instance view if necessary and returns a reference.  Creating an

   450 // instance view is an asynchronous operation, but this call returns

   451 // synchronously.  When the view is created, Completed() is called, which stops

   452 // iAs allowing this function to complete.

   453 // Leaves with KErrInUse if this class is in the process of creating the

   454 // instance view

   455 // (other items were commented in a header).

   456 // -----------------------------------------------------------------------------

   457 EXPORT_C CCalInstanceView* CCalenGlobalData::InstanceViewL()

   458     {

   459     TRACE_ENTRY_POINT;

   460     

   461     if (!iInstanceView && !iInstanceViewCreation)

   462         {

   463         if ( iEntryViewCreation )

   464             {

   465             iQueued = &CreateInstanceViewL;

   466             }

   467         else

   468             {

   469             CreateInstanceViewL();

   470             }

   471         }

   472     

   473     TRACE_EXIT_POINT;

   474     return iInstanceView;

   475     }

   476 

   477 // -----------------------------------------------------------------------------

   478 // CCalenGlobalData::InstanceViewL

   479 // Based on collection id array Create an instance view if necessary and returns a reference.

   480 // Creating an instance view is an asynchronous operation, but this call returns

   481 // synchronously.  When the view is created, Completed() is called, which stops

   482 // iAs allowing this function to complete.

   483 // Leaves with KErrInUse if this class is in the process of creating the

   484 // instance view

   485 // (other items were commented in a header).

   486 // -----------------------------------------------------------------------------

   487 EXPORT_C CCalInstanceView* CCalenGlobalData::InstanceViewL(

   488                                         const RArray<TInt>& aCollectionIds)

   489     {

   490     TRACE_ENTRY_POINT;

   491     

   492     if(!iNewInstanceView && !iNewInstanceViewCreation)

   493         {

   494         CreateInstanceViewL(aCollectionIds);

   495         }

   496     

   497     TRACE_EXIT_POINT;

   498     return iNewInstanceView;

   499     }

   500 

   501 // -----------------------------------------------------------------------------

   502 // CCalenGlobalData::EntryViewL

   503 // Create an entry view if necessary and returns a reference.  Creating an

   504 // entry view is an asynchronous operation, but this call returns

   505 // synchronously.  When the view is created, Completed() is called, which stops

   506 // iAs allowing this function to complete.

   507 // Leaves with KErrInUse if this class is in the process of creating the

   508 // entry view

   509 // (other items were commented in a header).

   510 // -----------------------------------------------------------------------------

   511 EXPORT_C CCalEntryView* CCalenGlobalData::EntryViewL()

   512     {

   513     TRACE_ENTRY_POINT;

   514     

   515      if (!iEntryView && !iEntryViewCreation)

   516         {

   517         if ( iInstanceViewCreation )

   518             {

   519             iQueued = &CreateEntryViewL;

   520             }

   521         else

   522             {

   523             CreateEntryViewL();

   524             }

   525         }

   526     

   527      TRACE_EXIT_POINT;

   528     return iEntryView;

   529     }

   530 

   531 

   532 // -----------------------------------------------------------------------------

   533 // CCalenGlobalData::EntryViewL

   534 // Based on collection id array Create an entry view if necessary and returns a reference.  

   535 // Creating an entry view is an asynchronous operation, but this call returns

   536 // synchronously.  When the view is created, Completed() is called, which stops

   537 // iAs allowing this function to complete.

   538 // Leaves with KErrInUse if this class is in the process of creating the

   539 // entry view

   540 // (other items were commented in a header).

   541 // -----------------------------------------------------------------------------

   542 EXPORT_C CCalEntryView* CCalenGlobalData::EntryViewL(

   543                                                 const TCalCollectionId aCollectionId)

   544     {

   545     TRACE_ENTRY_POINT;

   546     __ASSERT_ALWAYS(aCollectionId > 0 ,User::Panic(_L("CCalenGlobalData"),-1));

   547     

   548     CCalEntryView* entryView = NULL;

   549     

   550     TInt index = iHashDbidIndexMap.FindL(aCollectionId);

   551     if(index != KErrNotFound)

   552         {

   553         entryView = iFileMappingArray[index]->GetEntryView();

   554         }    

   555     

   556     if(!entryView)

   557         {

   558         User::LeaveIfNull(entryView);

   559         }

   560     

   561     TRACE_EXIT_POINT;

   562     return entryView;

   563     }

   564 

   565 // -----------------------------------------------------------------------------

   566 // CCalenGlobalData::RegisterEntryViewObserver

   567 // Add observer into view observers entry observer list.

   568 // (other items were commented in a header).

   569 // -----------------------------------------------------------------------------

   570 EXPORT_C TBool CCalenGlobalData::EntryViewExists()

   571     {

   572     TRACE_ENTRY_POINT;

   573     TRACE_EXIT_POINT;

   574     return ( iEntryView != NULL );

   575     }

   576 

   577 // -----------------------------------------------------------------------------

   578 // CCalenGlobalData::MeetingRequestUtilsL

   579 // Create MR Utils if necessary and returns a reference

   580 // (other items were commented in a header).

   581 // -----------------------------------------------------------------------------

   582 EXPORT_C CMRUtils& CCalenGlobalData::MeetingRequestUtilsL()

   583     {

   584     TRACE_ENTRY_POINT;

   585 

   586     iCreateError = KErrNone;

   587     if (!iUtilsAs)

   588         {

   589         iUtilsAs = new (ELeave) CActiveSchedulerWait;

   590         }

   591     if (!iMRUtils)

   592         {

   593         if (InterimUtilsL().MRViewersEnabledL())

   594             {

   595             if (iUtilsAs->IsStarted())

   596                 {

   597                 User::Leave(KErrInUse);

   598                 }

   599             else

   600                 {

   601                 //Get the currently selected mailbox

   602                 CMRMailboxUtils::TMailboxInfo defaultMailbox;

   603                 MRMailboxUtilsL().GetDefaultMRMailBoxL(defaultMailbox);

   604                 //CMRUtils resolves meeting request utilities based on mtm uid

   605                 TBuf8<KMaxUidName> mrMtm;

   606                 CnvUtfConverter::ConvertFromUnicodeToUtf8(mrMtm, defaultMailbox.iMtmUid.Name());

   607                 iMRUtils = CMRUtils::NewL(mrMtm, *this, CalSessionL(), NULL);

   608                 iUtilsAs->Start();

   609                 User::LeaveIfError(iCreateError);

   610                 }

   611             }

   612         else

   613             {

   614             User::Leave(KErrNotSupported);

   615             }

   616         }

   617 

   618     TRACE_EXIT_POINT;

   619     return *iMRUtils;

   620     }

   621 

   622 // -----------------------------------------------------------------------------

   623 // CCalenGlobalData::InterimUtilsL

   624 // Create a CCalenInterimUtils object if neccessary and return a reference

   625 // (other items were commented in a header).

   626 // -----------------------------------------------------------------------------

   627 EXPORT_C CCalenInterimUtils2& CCalenGlobalData::InterimUtilsL()

   628     {

   629     TRACE_ENTRY_POINT;

   630 

   631     if(!iInterimUtils)

   632         {

   633         iInterimUtils = CCalenInterimUtils2::NewL();

   634         }

   635 

   636     TRACE_EXIT_POINT;

   637     return *iInterimUtils;

   638     }

   639 

   640 // -----------------------------------------------------------------------------

   641 // CCalenGlobalData::CalenSendL

   642 // Create a CCalenSend object if neccessary and return a reference

   643 // (other items were commented in a header).

   644 // -----------------------------------------------------------------------------

   645 EXPORT_C CCalenSend& CCalenGlobalData::CalenSendL()

   646     {

   647     TRACE_ENTRY_POINT;

   648 

   649     if( !iSend )

   650         {

   651         iSend = CCalenSend::NewL( ECalenSend, CalSessionL() );

   652         }

   653 

   654     TRACE_EXIT_POINT;

   655     return *iSend;

   656     }

   657 

   658 // -----------------------------------------------------------------------------

   659 // CCalenGlobalData::Context

   660 // Return a reference to the CCalenContext object

   661 // (other items were commented in a header).

   662 // -----------------------------------------------------------------------------

   663 EXPORT_C MCalenContext& CCalenGlobalData::Context()

   664     {

   665     TRACE_ENTRY_POINT;

   666     TRACE_EXIT_POINT;

   667     return *iContext;

   668     }

   669 

   670 // -----------------------------------------------------------------------------

   671 // CCalenEditUi::AttemptToRetrieveDefaultMailboxL

   672 // Check to see if we have any mailboxes defined, and if we have a default

   673 // mailbox. If we don't, inform the user and return EFalse. This function

   674 // returns ETrue if aDefaultMailbox was initialised, and it is OK to create

   675 // a new MR.

   676 // (other items were commented in a header).

   677 // -----------------------------------------------------------------------------

   678 EXPORT_C TBool CCalenGlobalData::AttemptToRetrieveDefaultMailboxL( CMRMailboxUtils::TMailboxInfo& aDefaultMailbox)

   679     {

   680     TRACE_ENTRY_POINT;

   681 

   682     CMRMailboxUtils& mbUtils = MRMailboxUtilsL();

   683     // Get the currently defined mailboxes.

   684     RArray<CMRMailboxUtils::TMailboxInfo> mailboxes;

   685     CleanupClosePushL(mailboxes);

   686     mbUtils.ListMailBoxesL(mailboxes);

   687 

   688     TBool canCreateMeetingRequest=EFalse;

   689     TInt mbCount = mailboxes.Count();

   690 

   691     // The following 'if-else' block should always initialise

   692     // defaultMailBox if canCreateMeetingRequest comes out as ETrue.

   693     if(mbCount > 0)

   694         {

   695         TInt res = KErrNone;

   696         TRAPD(err, res = mbUtils.GetDefaultMRMailBoxL(aDefaultMailbox));

   697         if( res == KErrNone && err == KErrNone)

   698             {

   699             canCreateMeetingRequest = ETrue;

   700             }

   701         else

   702             {

   703             // We have one or more mailboxes defined, but failed to get a default.

   704             // Ask user to answer "Select default mailbox" query.  The available mailboxes must

   705             // first be reduced to only show mailboxes with an associated meetnig request solution

   706             RImplInfoPtrArrayOwn implArray;

   707              CleanupClosePushL( implArray );

   708             //Get all MRViewers Implementation

   709              const TUid mrViewersIface = {KMRViewersInterfaceUID};

   710              REComSession::ListImplementationsL(mrViewersIface, implArray );

   711 

   712             for (TInt i = mailboxes.Count() - 1; i >= 0; --i)

   713                 {

   714                 //See if any meeting request implementation matches this mailbox

   715                 for (TInt j=0; j<implArray.Count(); ++j)

   716                      {

   717                      TBuf16<KMaxUidName> mbName;

   718                      CnvUtfConverter::ConvertToUnicodeFromUtf8( mbName, implArray[j]->DataType() );

   719                      if(mailboxes[i].iMtmUid.Name().CompareF(mbName) == 0)

   720                          {

   721                          //Found a match

   722                         break;

   723                         }

   724                     //Mailbox has no matching meeting request solution

   725                     //remove from list

   726                     mailboxes.Remove(i);

   727                     }

   728                 }

   729             CleanupStack::PopAndDestroy();    //implArray

   730             

   731             TInt selected = PromptToSelectDefaultMailboxL(mailboxes);

   732 

   733             if(selected >= KErrNone)

   734                 {

   735                 mbUtils.SetDefaultMRMailBoxL( mailboxes[selected].iEntryId );

   736                 canCreateMeetingRequest = ETrue;

   737                 __ASSERT_ALWAYS((mbUtils.GetDefaultMRMailBoxL( aDefaultMailbox ) == KErrNone), User::Invariant()); // so we don't return ref to local variable.

   738                 }

   739             }

   740         }

   741     else

   742         {

   743         // Force the check of MR Impl existing

   744         InterimUtilsL().MRViewersEnabledL(ETrue); //ignore result

   745         }

   746    

   747     CleanupStack::PopAndDestroy(); // mailboxes

   748 

   749     TRACE_EXIT_POINT;

   750     return canCreateMeetingRequest;

   751     }

   752 

   753 // -----------------------------------------------------------------------------

   754 // CCalenGlobalData::ResetKeyEventQueue

   755 // Reset Keyevents queue

   756 // (other items were commented in a header).

   757 // -----------------------------------------------------------------------------

   758 EXPORT_C void CCalenGlobalData::ResetKeyEventQueue()

   759     {

   760     TRACE_ENTRY_POINT;

   761     iKeyQueue.Reset();

   762     TRACE_EXIT_POINT;

   763     }

   764 

   765 // -----------------------------------------------------------------------------

   766 // CCalenGlobalData::QueueKeyEvent

   767 // Queue key press event in a queue

   768 // (other items were commented in a header).

   769 // -----------------------------------------------------------------------------

   770 EXPORT_C TBool CCalenGlobalData::QueueKeyEvent(const TKeyEvent& aEvent,

   771                                                TEventCode aType)

   772     {

   773     TRACE_ENTRY_POINT;

   774     TBool result(EFalse);

   775     TQueuedKeyEvent item;

   776     item.iType = aType;

   777     item.iEvent = aEvent;

   778     if( iKeyQueue.Insert(item, iKeyQueue.Count()) == KErrNone) // add to last

   779         {

   780         result = ETrue;

   781         }

   782     TRACE_EXIT_POINT;

   783     return result;

   784     }

   785 

   786 // -----------------------------------------------------------------------------

   787 // CCalenGlobalData::GetQueueKeyEvent

   788 // Get 1 queued event from the queue

   789 // (other items were commented in a header).

   790 // -----------------------------------------------------------------------------

   791 EXPORT_C TBool CCalenGlobalData::GetQueuedKeyEvent(TKeyEvent& aEvent, TEventCode& aType)

   792     {

   793     TRACE_ENTRY_POINT;

   794     TBool result(EFalse);

   795     if(iKeyQueue.Count() > 0)

   796         {

   797         TQueuedKeyEvent item;

   798         item = iKeyQueue[0];// get first

   799         aEvent = item.iEvent;

   800         aType = item.iType;

   801         iKeyQueue.Remove(0); // remove first

   802         result = ETrue;

   803         iKeyQueue.Compress();

   804         }

   805     TRACE_EXIT_POINT;

   806     return result;

   807     }

   808 

   809 // -----------------------------------------------------------------------------

   810 // CCalenGlobalData::ConstructFileMappingL

   811 // Constructs mapping between symbian calendar file and metabd info

   812 // -----------------------------------------------------------------------------

   813 EXPORT_C TBool CCalenGlobalData::ConstructFileMappingL()

   814     {

   815     TRACE_ENTRY_POINT;

   816     iCalendarsSession = CCalSession::NewL();

   817     

   818     ConstructCalendarsListL();

   819     

   820     iFileMappingArray.Reset();

   821         

   822     for(TInt index = 0; index < iCalendarInfoList.Count(); index++)

   823         {

   824         TPtrC calendarFileName = iCalendarInfoList[index]->FileNameL();

   825         CCalenFileMapping* filemap = CCalenFileMapping::NewL(); 

   826         CleanupStack::PushL(filemap);

   827         filemap->SetCalendarFileNameL(calendarFileName);

   828         

   829         iNewEntryView  = NULL;

   830         iNewEntryViewCreation  = NULL;  

   831         if(iCalSession)

   832             {

   833             iNewCalSession = NULL;

   834             CCalCalendarInfo* calendarInfo = iCalendarInfoList[index];

   835             

   836             CCalSession& tempSession = CreateNewSessionL( calendarFileName,

   837                                     *calendarInfo );

   838             filemap->SetSessionPtr(&tempSession);

   839             filemap->SetCollectionId(tempSession.CollectionIdL());

   840             CreateEntryViewL(tempSession);

   841             filemap->SetEntryView( iNewEntryView );

   842             }            

   843          else

   844             {

   845             CCalSession& tempSession = CalSessionL();

   846             filemap->SetSessionPtr(&tempSession);

   847             filemap->SetCollectionId(tempSession.CollectionIdL());

   848             CreateEntryViewL(tempSession);

   849             filemap->SetEntryView( iNewEntryView );

   850             iGlobalDataOwnsEntryView = EFalse;

   851             iGlobalDataOwnsCalSession = EFalse;

   852             }

   853         iFileMappingArray.Append(filemap);        

   854         CleanupStack::Pop(filemap);

   855         }   

   856     

   857     for(TInt index = 0; index < iFileMappingArray.Count(); index++)

   858         {

   859         iHashDbidIndexMap.InsertL( iFileMappingArray[index]->GetCollectionId(),

   860                                     index);

   861         }

   862     

   863     TRACE_EXIT_POINT

   864     return ETrue;

   865     }

   866 

   867 // -----------------------------------------------------------------------------

   868 // CCalenGlobalData::InitializeGlobalDataL

   869 // Initializes multiple db related objects

   870 // -----------------------------------------------------------------------------

   871 EXPORT_C void CCalenGlobalData::InitializeGlobalDataL()

   872     {

   873     TRACE_ENTRY_POINT

   874     

   875     ConstructFileMappingL();

   876     

   877     TRACE_EXIT_POINT

   878     }

   879 

   880 // -----------------------------------------------------------------------------

   881 // CCalenGlobalData::PromptToSelectDefaultMailboxL

   882 // Prompts the user to select the default mailbox. If the user cancels, the

   883 // function returns KErrCancel, otherwise it returns the index of the selected

   884 // mailbox. This function does not set the default mailbox, but rather returns

   885 // the index of the given array to which the default should be set.

   886 // (other items were commented in a header).

   887 // -----------------------------------------------------------------------------

   888 TInt CCalenGlobalData::PromptToSelectDefaultMailboxL( RArray<CMRMailboxUtils::TMailboxInfo>& aMailboxes )

   889     {

   890     TRACE_ENTRY_POINT;

   891 

   892     TInt mbCount = aMailboxes.Count();

   893 

   894     TInt selected;

   895     if (mbCount > 0)

   896         {

   897         CAknSinglePopupMenuStyleListBox* list =

   898             new (ELeave) CAknSinglePopupMenuStyleListBox;

   899         CleanupStack::PushL(list);

   900 

   901         CAknPopupList* popupList = CAknPopupList::NewL(list, R_AVKON_SOFTKEYS_OK_CANCEL);

   902         CleanupStack::PushL(popupList);

   903 

   904         list->ConstructL(popupList, CEikListBox::ELeftDownInViewRect);

   905         list->CreateScrollBarFrameL(ETrue);

   906         list->ScrollBarFrame()->SetScrollBarVisibilityL(

   907             CEikScrollBarFrame::EOff, CEikScrollBarFrame::EAuto);

   908 

   909         CEikonEnv* eikEnv = CEikonEnv::Static();

   910 

   911         CDesCArrayFlat* items = new (ELeave)CDesCArrayFlat(mbCount);

   912         CleanupStack::PushL(items);

   913         for(TInt i=0; i<mbCount; ++i)

   914             {

   915             items->AppendL( aMailboxes[i].iName );

   916             }

   917         CleanupStack::Pop(items);

   918         CTextListBoxModel* model = list->Model();

   919 

   920         //Pass ownersip of items to model

   921         model->SetItemTextArray(items);

   922 

   923         HBufC* title = StringLoader::LoadLC(R_CALEN_SELECT_MAILBOX, eikEnv);

   924         popupList->SetTitleL(*title);

   925         CleanupStack::PopAndDestroy(title);

   926 

   927         TBool accepted = popupList->ExecuteLD();

   928         CleanupStack::Pop(); // popupList

   929 

   930         if(accepted)

   931             {

   932             selected = list->CurrentItemIndex();

   933             }

   934         else

   935             {

   936             selected = KErrCancel;

   937             }

   938 

   939         CleanupStack::PopAndDestroy();  // list

   940         }

   941     else

   942         {

   943         //No mailboxes defined.  Could prompt user to define one here?

   944         selected = KErrCancel;

   945         }

   946 

   947     TRACE_EXIT_POINT;

   948     return selected;

   949     }

   950 

   951 // -----------------------------------------------------------------------------

   952 // CCalenGlobalData::HandleCalEngStatus

   953 // Called when Meeting Request utils are creation is complete.

   954 // Stops the CActiveSchedulerWait, allowing MeetingRequestUtilsL() to complete

   955 // (other items were commented in a header).

   956 // -----------------------------------------------------------------------------

   957 void CCalenGlobalData::HandleCalEngStatus( TMRUtilsCalEngStatus aStatus )

   958     {

   959     TRACE_ENTRY_POINT;

   960 

   961     ASSERT(iUtilsAs);

   962 

   963     switch (aStatus)

   964         {

   965         case ENotReady:

   966             {

   967             //Keep waiting

   968             }

   969         break;

   970         case EAvailableWithoutTombs:

   971         case EAvailable:

   972             {

   973             //Ready for use.  Stop the CActiveSchedulerWait and return

   974             iUtilsAs->AsyncStop();

   975             iCreateError = KErrNone;

   976             }

   977         break;

   978         case ENotAvailable:

   979             {

   980             //Somethings gone wrong.  Stop the CActiveSchedulerWait but force

   981             //MeetingRequestUtilsL to leave.

   982             //We'll use KErrNotFound for now but we don't know what the problem is.

   983             iUtilsAs->AsyncStop();

   984             iCreateError = KErrNotFound;

   985             }

   986         break;

   987         default:

   988             {

   989             //Shouldn't ever get called.

   990             iUtilsAs->AsyncStop();

   991             iCreateError = KErrArgument;

   992             }

   993         break;

   994         }

   995 

   996     TRACE_EXIT_POINT;

   997     }

   998 

   999 // -----------------------------------------------------------------------------

  1000 // CCalenGlobalData::HandleNotification

  1001 // Handle any notification if registered for

  1002 // -----------------------------------------------------------------------------

  1003 void CCalenGlobalData::HandleNotification(const TCalenNotification aNotification )

  1004 	{

  1005 	TRACE_ENTRY_POINT;

  1006 

  1007 	switch(aNotification)

  1008 		{

  1009 		case ECalenNotifyEntryInstanceViewCreated:

  1010 			{

  1011 			ViewCreationCompleted( ETrue );

  1012 			}

  1013 			break;

  1014 		case ECalenNotifyEntryInstanceViewCreationFailed:

  1015 			{

  1016 			ViewCreationCompleted( EFalse );

  1017 			}

  1018 			break;

  1019 		case ECalenNotifyDeleteInstanceView:

  1020 			{

  1021 			//InstanceView has to be deleted since deleting any session(Calendar) 

  1022 			//entryView and instanceView has to be deleted before deleting session.

  1023 			if(iNewInstanceView)

  1024 				{

  1025 				delete iNewInstanceView;

  1026 				iNewInstanceViewCreation = iNewInstanceView =  NULL;

  1027 				}

  1028 			

  1029 			//If InstanceView is called by any component single instanceView 

  1030 			// without the knowledge of multi session (calendar).

  1031 			//This instance also should be deleted for deleting the session.  

  1032 			if(iInstanceView)

  1033 				{

  1034 				delete iInstanceView;

  1035 				iInstanceView = iInstanceViewCreation = NULL;

  1036 				}

  1037 			}

  1038 			break;

  1039 		case ECalenNotifyRealExit:

  1040 			{

  1041 			iCalendarForcedExit = ETrue;

  1042 			}

  1043 			break;

  1044 		case ECalenNotifyCalendarInfoCreated:

  1045 			{

  1046 			HandleCalendarInfoCreatedL();

  1047 			}

  1048 			break;

  1049 		case ECalenNotifyCalendarInfoUpdated:

  1050 			{

  1051 			HandleCalendarInfoUpdatedL();

  1052 			}

  1053 			break;

  1054 		case ECalenNotifyCalendarFileDeleted:

  1055 			{

  1056 			HandleCalendarFileDeletedL();

  1057 			}

  1058 			break;

  1059 		default:

  1060 			break;

  1061 		}

  1062 

  1063     TRACE_EXIT_POINT;

  1064     }

  1065 

  1066 // -----------------------------------------------------------------------------

  1067 // CCalenGlobalData::CreateEntryViewL

  1068 // -----------------------------------------------------------------------------

  1069 void CCalenGlobalData::CreateEntryViewL()

  1070     {

  1071     TRACE_ENTRY_POINT;

  1072 

  1073     HBufC* calendarFileName = KCalendarDatabaseFilePath().AllocLC();

  1074     TInt index  = iFileMappingArray.Find(   

  1075             *calendarFileName, CCalenGlobalData::CalenInfoIdentifierL);

  1076     CleanupStack::PopAndDestroy(calendarFileName);

  1077     if(index != KErrNotFound)

  1078         {

  1079         iEntryView = iFileMappingArray[index]->GetEntryView();

  1080         }

  1081     

  1082     if(!iEntryView)

  1083         {

  1084         User::LeaveIfNull(iEntryView);

  1085         }

  1086     

  1087     TRACE_EXIT_POINT;

  1088     }

  1089 

  1090 // -----------------------------------------------------------------------------

  1091 // CCalenGlobalData::CreateEntryViewL

  1092 // -----------------------------------------------------------------------------

  1093 void  CCalenGlobalData::CreateEntryViewL(CCalSession& session)

  1094     {

  1095     TRACE_ENTRY_POINT;

  1096     iNewEntryViewCreation = CCalEntryView::NewL( session, iCalCallBack );

  1097     

  1098     if(iNewEntryViewCreation)

  1099         {

  1100         iNewEntryView = iNewEntryViewCreation;

  1101         }

  1102     

  1103     TRACE_EXIT_POINT;

  1104     }

  1105 

  1106 // -----------------------------------------------------------------------------

  1107 // CCalenGlobalData::CreateInstanceViewL

  1108 // -----------------------------------------------------------------------------

  1109 void CCalenGlobalData::CreateInstanceViewL()

  1110     {

  1111     TRACE_ENTRY_POINT;

  1112     iInstanceViewCreation = CCalInstanceView::NewL( CalSessionL(), iCalCallBack );

  1113      if(iInstanceViewCreation)

  1114         {

  1115         iInstanceView = iInstanceViewCreation;

  1116         }

  1117     TRACE_EXIT_POINT;

  1118     }

  1119 

  1120 // -----------------------------------------------------------------------------

  1121 // CCalenGlobalData::CreateEntryViewL

  1122 // -----------------------------------------------------------------------------

  1123 void CCalenGlobalData::CreateInstanceViewL(const RArray<TInt>& aCollectionIds)

  1124     {

  1125     TRACE_ENTRY_POINT;

  1126     

  1127     RPointerArray<CCalSession> sessionArray;

  1128     

  1129     for(TInt i = 0; i < aCollectionIds.Count() ; i++)

  1130         {

  1131         TInt index = iHashDbidIndexMap.FindL(aCollectionIds[i]);

  1132         if(index != KErrNotFound)

  1133            {

  1134            CCalSession* sessionPtr = iFileMappingArray[index]->GetSessionPtr();