/*

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

* All rights reserved.

* This component and the accompanying materials are made available

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

* which accompanies this distribution, and is available

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

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description:   Global Data for Calendar application

*

*/

//debug

#include "calendarui_debug.h"

// INCLUDE FILES

#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 "calenfilemapping.h"

#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 <calensvrmissedalarmmanagerresource.rsg>

// Default Calendar database path

_LIT( KCalendarDatabaseFilePath, "c:calendar" );

_LIT( KPhoneCalendar,"Personal" );

_LIT( KExtCalendar,"Ext calendar" );

const TInt KBuffLength = 24;

_LIT(KPersonal,"Personal");

_LIT(KFamily,"Family");

_LIT(KFriends,"Friends");

_LIT( KMissedAlarmResourceFile, "z:\\resource\\CalenSvrMissedAlarmManagerResource.rsc"); // changes done

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

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

// CCalenGlobalData::CCalenGlobalData

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

// (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;

    }

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

// CCalenGlobalData::NewL

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

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

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

// which should be handled by the controller.

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

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

//

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

                                                   MCalenContextChangeObserver* aNotifier,

                                                   MCalenDBChangeObserver* aDBNotifier)

    {

    TRACE_ENTRY_POINT;

    CCalenGlobalData* self = NULL;

    TAny* tlsPtr = Dll::Tls();

    // Check Thread local storage

    if (!tlsPtr)

        {

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

        self = new( ELeave ) CCalenGlobalData( aCalCallBack );

        CleanupStack::PushL( self );

        // Store a self pointer in TLS

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

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

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

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

        ++self->iRefCount;

        self->ConstructL( aNotifier, aDBNotifier );

        CleanupStack::Pop( self );

        }

    else

        {

        // An instance of the global data exists already.

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

        User::Leave( KErrAlreadyExists );

        }

    TRACE_EXIT_POINT;

    return self;

    }

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

// CCalenGlobalData::InstanceL

// Two-phased constructor.

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

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

EXPORT_C CCalenGlobalData* CCalenGlobalData::InstanceL()

    {

    TRACE_ENTRY_POINT;

    CCalenGlobalData* self = NULL;

    TAny* tlsPtr = Dll::Tls();

    // Check Thread local storage

    if (!tlsPtr)

        {

        // The global data has not yet been constructed.

        // FIXME - Revise comment

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

        {

        self = static_cast<CCalenGlobalData*>( tlsPtr );

        }

    ++self->iRefCount;

    TRACE_EXIT_POINT;

    return self;

    }

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

// CCalenGlobalData::InstanceL

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

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

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

// open references to the CCalenGlobalData are released.

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

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

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

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

    {

    TRACE_ENTRY_POINT;

    CCalenGlobalData* self = CCalenGlobalData::InstanceL();

    CleanupStack::PushL(self);

    self->SetSessionL(&aSession);

    CleanupStack::Pop(self);

    TRACE_EXIT_POINT;

    return self;

    }

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

// CCalenGlobalData::InstanceL

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

// CCalenGlobalData if one exists or NULL otherwise

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

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

EXPORT_C CCalenGlobalData* CCalenGlobalData::Instance()

    {

    TRACE_ENTRY_POINT;

    TAny* tlsPtr = Dll::Tls();

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

    if ( self )

        {

        ++self->iRefCount;

        }

    TRACE_EXIT_POINT;

    return self;

    }

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

// CCalenGlobalData::ConstructL

// Symbian 2nd phase constructor can leave.

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

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

void CCalenGlobalData::ConstructL( MCalenContextChangeObserver* aNotifier,

                                    MCalenDBChangeObserver* aDBNotifier)

    {

    TRACE_ENTRY_POINT;

    iContext = new (ELeave ) CCalenContextImpl( aNotifier );  

    iNewInstanceViewCreation = NULL;

    iDBChangeNotifier = aDBNotifier;

    TRACE_EXIT_POINT;

    }

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

// CCalenGlobalData::SetSessionL

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

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

// CCalenGlobalData

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

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

void CCalenGlobalData::SetSessionL(CCalSession* aSession)

    {

    TRACE_ENTRY_POINT;

    if (iCalSession)

        {

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

        }

    else

        {

        iGlobalDataOwnsCalSession = EFalse;

        iCalSession = aSession;

        }

    TRACE_EXIT_POINT;

    }

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

// CCalenGlobalData::Release

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

// this class it will be deleted

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

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

EXPORT_C void CCalenGlobalData::Release()

    {

    TRACE_ENTRY_POINT;

    --iRefCount;

    if (iRefCount == 0)

        {

        delete this;

        }

    TRACE_EXIT_POINT;

    }

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

// Destructor

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

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

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

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;

        }

    if (iNewInstanceViewCreation)

        {

        delete iNewInstanceViewCreation;

        iNewInstanceViewCreation = NULL;

        }

    if (iNewInstanceView)

        {

        delete iNewInstanceView;

        iNewInstanceView = NULL;

        }

    delete iContext;

    if(iGlobalDataOwnsEntryView)

        {

        if(iEntryView)

            {

            delete iEntryView;

            iEntryView = NULL;           

            }

        }

   if (iGlobalDataOwnsCalSession)

        {

        delete iCalSession;

        }

    if( iFileMappingArray.Count() )

        {

        iFileMappingArray.ResetAndDestroy();

        }

    iKeyQueue.Reset();

    iHashDbidIndexMap.Close();

    Dll::SetTls(NULL);

    if (iCalendarInfoList.Count())

        {

        iCalendarInfoList.ResetAndDestroy();

        }

    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

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

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

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

EXPORT_C CCalSession& CCalenGlobalData::CalSessionL()

    {

    TRACE_ENTRY_POINT;

    if (!iCalSession)

        {

        iGlobalDataOwnsCalSession = ETrue;

        iCalSession = CCalSession::NewL();

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

        if (err == KErrNotFound)

            {

            CCalCalendarInfo* calendarInfo = GetDefaultCalendarInfoL();

            CleanupStack::PushL(calendarInfo);

            iCalSession->CreateCalFileL( KCalendarDatabaseFilePath,

                                        *calendarInfo);

            iCalSession->OpenL(KCalendarDatabaseFilePath);

            CleanupStack::PopAndDestroy(calendarInfo);

            }

        else if(err == KErrNone)

            {

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

    return *iCalSession;

    }

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

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

// 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()

    {

    TRACE_ENTRY_POINT;

    if (!iInstanceView && !iInstanceViewCreation)

        {

        if ( iEntryViewCreation )

            {

            iQueued = &CreateInstanceViewL;

            }

        else

            {

            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

// 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()

    {

    TRACE_ENTRY_POINT;