/*

* 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: This file implements class CESMRCalDbMgr.

*

*/

//INCLUDE FILES

#include "emailtrace.h"

#include "cesmrcaldbmgr.h"

#include "cesmrcaldbnormal.h"

#include "cesmrentrycmditeratorao.h"

#include "esmrhelper.h"

#include "esmrentryhelper.h"

#include "mesmrutilstombsext.h"

// From System

#include <ct/rcpointerarray.h>

#include <calsession.h>

#include <calentryview.h>

#include <calinstance.h>

#include <calinstanceview.h>

#include <calentry.h>

#include <calcommon.h>

#include <caluser.h>

// CONSTANTS

// Unnamed namespace for local definitions

namespace {

// Panic code definitions

enum TPanicCode

    {

    EPanicIllegalFetchParams = 1,

    EPanicAccessedWhenUnavailable,

    EPanicAsyncOpAlreadyExists,

    EPanicIllegalEntryStatus,

    EPanicIllegalResurrect,

    };

// Panic string definition

_LIT( KPanicMsg, "CESMRCalDbMgr" );

/**

 * Raises system panic

 * @param aReason Panic reason.

 */

void Panic( TPanicCode aReason )

    {

    User::Panic( KPanicMsg, aReason );

    }

}  // namespace

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

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

// CESMRCalDbMgr::NewL

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

//

EXPORT_C CESMRCalDbMgr* CESMRCalDbMgr::NewL(

    CCalSession& aCalSession,

    MMRUtilsObserver& aObserver )

    {

    FUNC_LOG;

    CESMRCalDbMgr* self =

            new( ELeave ) CESMRCalDbMgr(

                aCalSession,

                aObserver );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop();

    return self;

    }

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

// CESMRCalDbMgr::CESMRCalDbMgr

//

// Constructor.

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

//

CESMRCalDbMgr::CESMRCalDbMgr(

    CCalSession& aCalSession,

    MMRUtilsObserver& aObserver )

    : iCurrentAsyncOp( CMRUtils::ENoOperation ),

      iCalSession( aCalSession ),

      iObserver( aObserver )

    {

    FUNC_LOG;

    }

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

// CESMRCalDbMgr::~CESMRCalDbMgr

//

// Destructor.

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

//

CESMRCalDbMgr::~CESMRCalDbMgr()

    {

    FUNC_LOG;

    delete iCmdIterator;

    delete iNormalDb;

    }

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

// CESMRCalDbMgr::ConstructL

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

//

void CESMRCalDbMgr::ConstructL()

    {

    FUNC_LOG;

    iNormalDb    = CESMRCalDbNormal::NewL( iCalSession, *this, *this );

    iCmdIterator = CESMREntryCmdIteratorAO::NewL( *this );

    }

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

// CESMRCalDbMgr::HandleCalDbStatus

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

//

void CESMRCalDbMgr::HandleCalDbStatus(

    const CESMRCalDbBase* /*aNotifier*/,

    MESMRCalDbObserver::TDbStatus aStatus )

    {

    FUNC_LOG;

    if ( aStatus == EReseting )

        { // reset db is ongoing, engine becomes unavailable

        iObserver.HandleCalEngStatus( MMRUtilsObserver::ENotReady );

        }

    else if ( iNormalDb->DbStatus() == MESMRCalDbObserver::EFinishedOk )

        {

        iObserver.HandleCalEngStatus( MMRUtilsObserver::EAvailable );

        }

    else if ( iNormalDb->DbStatus() == MESMRCalDbObserver::EFinishedOk )

        {

        iObserver.HandleCalEngStatus(

            MMRUtilsObserver::EAvailableWithoutTombs );

        }

    else if ( iNormalDb->DbStatus() == MESMRCalDbObserver::EFinishedError )

        {

        iObserver.HandleCalEngStatus( MMRUtilsObserver::ENotAvailable );

        }

    // In other cases either db is not yet finished

    }

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

// CESMRCalDbMgr::Progress

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

//

void CESMRCalDbMgr::Progress( TInt /*aPercentageCompleted*/ )

    {

    FUNC_LOG;

    // Not interested in progress currently

    }

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

// CESMRCalDbMgr::NotifyProgress

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

//

TBool CESMRCalDbMgr::NotifyProgress()

    {

    FUNC_LOG;

    // Not interested in progress currently

    return EFalse;

    }

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

// CESMRCalDbMgr::Completed

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

//

void CESMRCalDbMgr::Completed( TInt aError )

    {

    FUNC_LOG;

    iObserver.HandleOperation( iCurrentAsyncOp, KDbInitReady, aError );

    iCurrentAsyncOp = CMRUtils::ENoOperation;

    }

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

// CESMRCalDbMgr::NormalDbEntryView

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

//

CCalEntryView* CESMRCalDbMgr::NormalDbEntryView()

    {

    FUNC_LOG;

    return iNormalDb->EntryView();

    }

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

// CESMRCalDbMgr::NormalDbInstanceView

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

//

CCalInstanceView* CESMRCalDbMgr::NormalDbInstanceView()

    {

    FUNC_LOG;

    return iNormalDb->InstanceView();

    }

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

// CESMRCalDbMgr::FetchEntriesL

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

//

void CESMRCalDbMgr::FetchEntriesL(

    RPointerArray<CCalEntry>& aCalEntryArray,

    const CalCommon::TCalTimeRange& aTimeRange )

    {

    FUNC_LOG;

    __ASSERT_DEBUG( aCalEntryArray.Count() == 0,

                    Panic( EPanicIllegalFetchParams ) );

    aCalEntryArray.ResetAndDestroy();

    // caller definitely wants to get full copies -> ETrue as 3rd argument:

    iNormalDb->FetchWithRangeL( aCalEntryArray,

                                aTimeRange,

                                ETrue );

    }

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

// CESMRCalDbMgr::FetchEntryL

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

//

CCalEntry* CESMRCalDbMgr::FetchEntryL(

    const TDesC8& aUid,

    const TCalTime& aRecurrenceId )

    {

    FUNC_LOG;

    __ASSERT_DEBUG( aUid.Length() > 0,

                    Panic( EPanicIllegalFetchParams ) );

    RCPointerArray<CCalEntry> tmpFetchArray;

    CleanupClosePushL( tmpFetchArray );

    CCalEntry* retVal = NULL;

    TInt index( -1 );

    if ( EntryExistsInDbL( aUid,

                           aRecurrenceId,

                           *iNormalDb,

                           tmpFetchArray,

                           index ) )

        {

        retVal = tmpFetchArray[index];

        tmpFetchArray.Remove( index ); // ownership transferred to retVal

        }

    CleanupStack::PopAndDestroy(); // tmpFetchArray

    return retVal;

    }

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

// CESMRCalDbMgr::StoreEntryL

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

//

TInt CESMRCalDbMgr::StoreEntryL(

    CCalEntry& aCalEntry,

    TBool aToNormalDb )

    {

    FUNC_LOG;

    TInt retVal( KErrNone );

        {

        }

    return retVal;

    }

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

// CESMRCalDbMgr::UpdateEntryL

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

//

TInt CESMRCalDbMgr::UpdateEntryL( const CCalEntry& aCalEntry )

    {

    FUNC_LOG;

    RPointerArray<CCalEntry> calEntryTmpArray( 1 ); // entry not own

    CleanupClosePushL( calEntryTmpArray );

    calEntryTmpArray.AppendL( &aCalEntry );

    TInt numSuccessfulEntry( 0 );

    // entry view surely exists when status is 'available':

    TInt retVal( numSuccessfulEntry == 1 ? KErrNone : KErrGeneral );

    return retVal;

    }

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

// CESMRCalDbMgr::DeleteEntryL

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

//

    {

    FUNC_LOG;

    CDesC8ArrayFlat* uidArray = new( ELeave ) CDesC8ArrayFlat( 1 );

    CleanupStack::PushL( uidArray );

    uidArray->AppendL( aUid );

    // entry view surely exists when status is 'available':

    CleanupStack::PopAndDestroy( uidArray );

    return KErrNone;

    }

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

// CESMRCalDbMgr::DeleteEntryL

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

//

    {

    FUNC_LOG;

    RArray<TCalLocalUid> localUidArray( 1 );

    CleanupClosePushL( localUidArray );

    localUidArray.AppendL( aLocalUid );

    TInt numSuccessfulEntry( 0 );

    TInt retVal( numSuccessfulEntry == 1 ? KErrNone : KErrGeneral );

    CleanupStack::PopAndDestroy(); // localUidArray

    return retVal;

    }

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

// CESMRCalDbMgr::StoreEntryCondL

// aResurrect can only be ETrue if aCheckOnly is EFalse, i.e. when user is

// really trying to store something.

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

//

MESMRUtilsTombsExt::TESMRUtilsDbResult CESMRCalDbMgr::StoreEntryCondL(

    CCalEntry& aCalEntry,

    TBool aResurrect,

    TBool aCheckOnly )

    {

    FUNC_LOG;

    MESMRUtilsTombsExt::TESMRUtilsDbResult entryStatus(

        MESMRUtilsTombsExt::EUndefined );

            }

        }

    return entryStatus;

    }

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

// CESMRCalDbMgr::DeleteEntryCondL

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

//

void CESMRCalDbMgr::DeleteEntryCondL( const TDesC8& aUid )

    {

    FUNC_LOG;

    RCPointerArray<CCalEntry> tmpFetchArray;

    CleanupClosePushL( tmpFetchArray );

    // 1. Delete all found entries from normal db:

    CleanupStack::PopAndDestroy(); // tmpFetchArray