/*

* Copyright (c) 2007 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:  

*     Item array for the message items to be displayed by mce.

*     Main view items are kept in memory (CArrayFixFlat<TMceListItem>) when created but

*     Message view list items are fetched from the msgs when needed in MdcaPoint function

*

*/

// INCLUDE FILES

#include <AknUtils.h>       // AknTextUtils

#include <mtudcbas.h>

#include <msvids.h>

#include <NpdApi.h>         // CNotepadApi

#include "MtmRegistryObserver.h" // MMtmUiDataRegistryObserver

#include <StringLoader.h>   // StringLoader

#include <mce.rsg>

#include <SenduiMtmUids.h>  // mtm uids

#include <eikenv.h>

#include <gulicon.h>

#include <e32property.h>

#include "MceOneRowMessageListArray.h"

#include "MceLogText.h"

#include <MTMStore.h>

#include <commonphoneparser.h>

#include <aknappui.h>

#include <akncontext.h>

#include <aknconsts.h>

#include <e32math.h>

#include <bldvariant.hrh>

#include <featmgr.h>

#include <NumberGrouping.h>

#include <mmsconst.h>

#include <mmsgenutils.h>

#include <mmsclient.h>

#include <mtclreg.h>

#include <muiu.mbg>

// security data caging

#include <data_caging_path_literals.hrh>

#include <miutset.h>

#include <msvapi.h>

#include "MceCommands.hrh"

#include "MceOneRowMessageListArrayLoader.h"

#include <smuthdr.h>

#include <messaginginternalpskeys.h> 

// CONSTANTS

// LOCAL CONSTANTS AND MACROS

const TInt KMceTimeHours    = 23;

const TInt KMceTimeMinutes  = 59;

const TInt KMceTimeSeconds  = 59;

const TInt KMceTimeMicroSeconds  = 999999;

const TInt KMceTimeOneDay   = 1;

const TInt KMceTimeOneWeek  = 7;

const TUid KUidMsvMessageListSortOrder  = {0x10005359};

_LIT( KSortSubjectSkipString, "*:*" );

const TChar KWhiteSpaceCharacter(' ');

const TInt KSortSubjectStringLength = 100;

const TInt KMceLoopCounter  = 200;

//cmail update

#define KUidMsgTypeCmailMtmVal               0x2001F406

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

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

// CMceOneRowListItemArrayLoader::NewL

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

CMceOneRowListItemArrayLoader* CMceOneRowListItemArrayLoader::NewL(

    CMsvSessionPtr aSession )

    {

    return CMceOneRowListItemArrayLoader::NewL(

        0x1002, //KMsvGlobalInBoxIndexEntryId,

        aSession );

    }

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

// CMceOneRowListItemArrayLoader::NewL

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

CMceOneRowListItemArrayLoader* CMceOneRowListItemArrayLoader::NewL(

    TMsvId aFolderId,

    CMsvSessionPtr aSession )

    {

    CMceOneRowListItemArrayLoader* self = new (ELeave) CMceOneRowListItemArrayLoader( aSession );

    CleanupStack::PushL( self );

    self->ConstructL( aFolderId );

    CleanupStack::Pop( self );

    return self;

    }

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

// C++ default constructor can NOT contain any code that

// might leave.

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

CMceOneRowListItemArrayLoader::CMceOneRowListItemArrayLoader(

    CMsvSessionPtr aSession )

:   CActive( CActive::EPriorityIdle ),

    iListType( EHCListTypeTime ),

    iSession( aSession ),

    iEmailFramework(EFalse)

    {

    }

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

// destructor

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

CMceOneRowListItemArrayLoader::~CMceOneRowListItemArrayLoader()

    {

    iHCListItemArray.Close();

    if ( &iSession )

        {

        iSession->RemoveObserver( *this );

        }

    Cancel();

    delete iFolderEntry;

    delete iEntriesToBeAdded;

    delete iEntriesReceivedDuringListCreation;

    if ( iEmailFramework )

        {

        delete iCmailSelectionList ;

        }

    iMarkedArray.Close();

    }

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

// CMceOneRowListItemArrayLoader::ConstructL

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

void CMceOneRowListItemArrayLoader::ConstructL(

    TMsvId aFolderId )

    {

    iSession->AddObserverL( *this );

    FeatureManager::InitializeLibL();

    if ( FeatureManager::FeatureSupported( KFeatureIdFfEmailFramework ) )

        {

        iEmailFramework = ETrue;

        }

    FeatureManager::UnInitializeLib();

    iFolderEntry = CMsvEntry::NewL(

        *iSession,

        aFolderId,

        TMsvSelectionOrdering(

            KMsvGroupByStandardFolders, EMsvSortByDateReverse ));

    CActiveScheduler::Add( this );

    }

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

// CMceOneRowListItemArrayLoader::StartL

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

//

void CMceOneRowListItemArrayLoader::StartL()

    {

    //Before Starting to prepare the list, set the value to zero.

    TInt r = RProperty::Set( KPSUidMuiu, KMuiuOneRowListPopulated, EFalse );

    if ( r != KErrNone )

        {

        User::LeaveIfError( r );

        }

    Cancel();

    InitialiseSearch();

    delete iEntriesToBeAdded;

    iEntriesToBeAdded = NULL;

    iEntriesToBeAdded = iFolderEntry->ChildrenL();

    iEntryToBeAdded = 0;

    LoadMessagesL();

    QueueLoad();

    }

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

// CMceOneRowListItemArrayLoader::FinishL

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

//

void CMceOneRowListItemArrayLoader::FinishL()

    {

    if(IsActive())

        {

        // First consume the outstanding completion.

        Cancel();

        }

    // Loop until all entries and subtitles has been added to iHCListItemArray

    while ( iEntriesToBeAdded && iEntriesToBeAdded->Count() )

        {

        LoadMessagesL();

        }

    }

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

// CMceOneRowListItemArrayLoader::DoCancel

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

//

void CMceOneRowListItemArrayLoader::DoCancel()

    {

    }

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

// CMceOneRowListItemArrayLoader::RunL

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

//

void CMceOneRowListItemArrayLoader::RunL()

    {

    TRAP_IGNORE( LoadMessagesL( ) );

    QueueLoad();

    if(!IsActive())

        {

        }

    }

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

// CMceOneRowListItemArrayLoader::QueueLoad

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

//

void CMceOneRowListItemArrayLoader::QueueLoad()

    {

    if ( IsActive() )

        {

        return;

        }

    if ( iEntriesToBeAdded->Count() || iEntriesReceivedDuringListCreation )

        {

        TRequestStatus *s = &iStatus;

        User::RequestComplete(s, KErrNone);

        SetActive();

        }

    }

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

// CMceOneRowListItemArrayLoader::LoadMessagesL

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

//

void CMceOneRowListItemArrayLoader::LoadMessagesL()

    {

    if ( iEntriesToBeAdded->Count() )

        {

        if ( iEmailFramework ) 

            {

            TRAP_IGNORE( CreateCmailEntryIndexL() ) ;

            }

        AppendMessagesL();

        }

    else if ( iEntriesReceivedDuringListCreation )

        {

        Cancel();

        // do something

        const TInt count = iEntriesReceivedDuringListCreation->Count();

        for (TInt i=0; i<count; i++)

            {

            EntryCreatedL( (*iEntriesReceivedDuringListCreation)[i] );

            }

        delete iEntriesReceivedDuringListCreation;

        iEntriesReceivedDuringListCreation = NULL;

        }

    }

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

// CMceOneRowListItemArray::ItemIndex

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

TInt CMceOneRowListItemArrayLoader::ItemIndex(TMsvId aItemId) const

    {

    TInt foundItem = KErrNotFound;

    const TInt count = iHCListItemArray.Count();

    for( TInt loop = 0; loop < count && foundItem == KErrNotFound ; loop++)

        {

        if ( iHCListItemArray[loop].iEntryId == aItemId &&

            iHCListItemArray[loop].iItemType == EHListItemEntry )

            {

            foundItem = loop;

            }

        }

    return foundItem;

    }

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

// CMceOneRowListItemArray::HCItemType

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

//THListItemType CMceOneRowListItemArray::HCItemType( TInt aIndex )

TInt CMceOneRowListItemArrayLoader::HCItemType(TInt aIndex )

    {

    return iHCListItemArray[aIndex].iItemType;

    }

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

// CMceOneRowListItemArray::ItemId

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

TMsvId CMceOneRowListItemArrayLoader::ItemId( TInt aIndex ) const

    {

    TMsvId id = KErrNotFound;

    if ( aIndex >= 0 && iHCListItemArray.Count() > aIndex )

        {

        if ( iHCListItemArray[aIndex].iItemType == EHListItemEntry )

            {

            id = iHCListItemArray[aIndex].iEntryId;

            }

        }

    return id;

    }

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

// CMceOneRowListItemArrayLoader::SetEntryL

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

void CMceOneRowListItemArrayLoader::SetEntryL( TMsvId aFolderId )

    {

    iHCListItemArray.Reset();

    iFolderEntry->SetEntryL( aFolderId );

    TMsvSelectionOrdering ordering = iFolderEntry->SortType();

    TMsvSorting sorting = iFolderEntry->SortType().Sorting();

    ordering.SetSorting( sorting );

    iFolderEntry->SetSortTypeL( ordering );

    StartL();

    }

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

// CMceOneRowListItemArrayLoader::Count

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

TInt CMceOneRowListItemArrayLoader::Count()

    {

    TInt count = 0;

    count = iHCListItemArray.Count();

    return count;

    }

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

// CMceOneRowListItemArrayLoader::GetEntry

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

TInt CMceOneRowListItemArrayLoader::GetEntry( TMsvId aEntryId, TMsvEntry& aEntry )

    {

    TMsvId serviceId;

    TInt error = iSession->GetEntry( aEntryId, serviceId, aEntry );

    return error;

    }

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

// CMceOneRowListItemArrayLoader::GetEntry

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

TInt CMceOneRowListItemArrayLoader::GetEntry( TInt aIndex, TMsvEntry& aEntry )

    {

    if ( aIndex < 0 || aIndex > iHCListItemArray.Count() )

        {

        return KErrNotFound;

        }

    TMsvId serviceId;

    TMsvId entryId;

    entryId = iHCListItemArray[aIndex].iEntryId;

    TInt error = iSession->GetEntry( entryId, serviceId, aEntry );

    if ( error == KErrNone )

        {

        if ( iHCListItemArray[aIndex].iItemType == EHListItemSubtitle )

            {

            error = iListType;

            }

        }

    return error;

    }

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

// CMceOneRowListItemArrayLoader::GetTimeBasedSubtitle

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

TInt CMceOneRowListItemArrayLoader::GetTimeBasedSubtitle( TInt aIndex )

    {

    if ( aIndex < 0 || aIndex > iHCListItemArray.Count() )

        {

        return KErrNotFound;

        }

    TInt value = KErrNotSupported;

    if ( iListType == EHCListTypeTime )

        {

        if ( iHCListItemArray[aIndex].iItemType == EHListItemSubtitle )

            {

            value = iHCListItemArray[aIndex].iSubtitleType;

            }

        else

            {

            TInt subtitleIndex = ParentItemIndex( aIndex );

            if ( subtitleIndex >= 0 )

                {

                value = iHCListItemArray[subtitleIndex].iSubtitleType;

                }

            }

        }

    return value;

    }

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

// CMceOneRowListItemArrayLoader::GetCurrentEntry

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

void CMceOneRowListItemArrayLoader::GetCurrentEntry( TMsvEntry& aEntry )

    {

    aEntry = iFolderEntry->Entry();

    }

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

// CMceOneRowListItemArrayLoader::CurrentEntryId

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

TMsvId CMceOneRowListItemArrayLoader::CurrentEntryId()

    {

    return iFolderEntry->EntryId();

    }

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

// CMceOneRowListItemArrayLoader::SetListItemArrayObserver

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

void CMceOneRowListItemArrayLoader::SetListItemArrayObserver( MMceOneRowListItemArrayObserver* aObserver )

    {

    iListItemArrayObserver = aObserver;

    }

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

// CMceOneRowListItemArrayLoader::InitialiseSearch

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

void CMceOneRowListItemArrayLoader::InitialiseSearch()

    {

    iHCListItemArray.Reset();

    iCounter = 0;

    iStep = 0;

    for (TInt i=EMondayAdded; i<=EOlderAdded; i++)

        {

        iSubtitleAdded[i] = EFalse;

        }

    UpdateCurrentTime();

    iAddSubtitle = EFalse;

    }

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

// CMceOneRowListItemArrayLoader::HandleSessionEventL

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

void CMceOneRowListItemArrayLoader::HandleSessionEventL(

    TMsvSessionEvent aEvent, TAny* aArg1, TAny* aArg2, TAny* /*aArg3*/)

    {

    MCELOGGER_ENTERFN("CMceOneRowListItemArrayLoader::HandleSessionEventL");

// if active...

    if ( !IsActive() )

        {

        MCELOGGER_LEAVEFN("CMceOneRowListItemArrayLoader::HandleSessionEventL not active");

        return;

        }

    TMsvId changedFolderId = (*(TMsvId*) (aArg2));

    if ( changedFolderId != iFolderEntry->EntryId() )

        {

        // not in our folder...

        return;

        }

    switch (aEvent)

        {

        case EMsvEntriesChanged:

        case EMsvEntriesCreated:

            {

            if ( !iEntriesReceivedDuringListCreation )

                {

                iEntriesReceivedDuringListCreation = new( ELeave ) CMsvEntrySelection();

                }

            CMsvEntrySelection* selection = (CMsvEntrySelection*) aArg1;

            const TInt count = selection->Count();

            for (TInt i=0; i<count; i++)

                {

                iEntriesReceivedDuringListCreation->AppendL( (*selection)[i] );

                }

            }

            break;

        case EMsvEntriesDeleted:

            {

            // ?

            }

        case EMsvEntriesMoved:

            {

            }

            break;

        default:

            break;

        };

    MCELOGGER_LEAVEFN("CMceOneRowListItemArrayLoader::HandleSessionEventL");

    }