/*

* Copyright (c) 2009 - 2010 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: This file implements classes CFSEmailUiMailListVisualiser, CMailListUpdater, CMsgMovedNoteTimer, CDateChangeTimer.

*

*/

// SYSTEM INCLUDES

#include "emailtrace.h"

#include <freestyleemailui.mbg>

#include <AknUtils.h>

#include <gulicon.h>

#include <StringLoader.h>

#include <FreestyleEmailUi.rsg>

#include <featmgr.h>

#include "cfsmailclient.h"

#include "cfsmailbox.h"

#include "cfsmailfolder.h"

#include "fscontrolbar.h"

#include "fscontrolbuttoninterface.h"

#include "fstreelist.h"

#include "fstreevisualizerbase.h"

#include "fstreeplainonelinenodedata.h"

#include "fstreeplainonelinenodevisualizer.h"

#include "fstreeplaintwolineitemdata.h"

#include "fstreeplaintwolineitemvisualizer.h"

#include "cfsmailcommon.h"

#include "ceuiemaillisttouchmanager.h"

#include "FSEmailBuildFlags.h"

#include "cfsccontactactionmenu.h"

#include "mfsccontactactionmenumodel.h"

#include <hlplch.h>

#include <AknIconArray.h>

#include <alf/alfdecklayout.h>

#include <alf/alfcontrolgroup.h>

#include <alf/alfframebrush.h>

#include <alf/alfevent.h>

#include <alf/alfstatic.h>

#include <aknnotewrappers.h>

#include <msvapi.h>

#include <akntitle.h>

#include "esmailsettingspluginuids.hrh"

#include "esmailsettingsplugin.h"

#include "mfsmailbrandmanager.h"

#include <AknWaitDialog.h>

#include <aknlayoutscalable_apps.cdl.h>

#include <aknlayoutscalable_avkon.cdl.h>

#include <layoutmetadata.cdl.h>

#include <csxhelp/cmail.hlp.hrh>

// Meeting request

#include <MeetingRequestUids.hrh>

#include "cesmricalviewer.h"

#include <aknstyluspopupmenu.h>

#include <akntoolbar.h>

// INTERNAL INCLUDES

#include "FreestyleEmailUiUtilities.h"

#include "FreestyleEmailUiLiterals.h"

#include "FreestyleEmailUiLayoutHandler.h"

#include "FreestyleEmailUiMailListModel.h"

#include "FreestyleEmailUiMailListVisualiser.h"

#include "FreestyleEmailUiFileSystemInfo.h"

#include "FreestyleEmailUiAppui.h"

#include "FreestyleEmailUi.hrh"

#include "FreestyleEmailUiTextureManager.h"

#include "FreestyleEmailUiMailListControl.h"

#include "FreestyleEmailUiStatusIndicator.h"

#include "freestyleemailcenrephandler.h"

#include "FreestyleEmailUiFolderListVisualiser.h"

#include "FreestyleEmailUiShortcutBinding.h"

#include "FreestyleEmailUiMsgDetailsVisualiser.h"

#include "FreestyleEmailDownloadInformationMediator.h"

#include "FreestyleEmailUiContactHandler.h"

#include "FreestyleEmailUiLauncherGridVisualiser.h"

#include "FreestyleEmailUiHtmlViewerView.h"

#include "FSDelayedLoader.h"

#include "FSEmail.pan"

#include "ipsplgcommon.h"

#include "cemailsettingsextension.h"

// CONST VALUES

const TInt KControlBarTransitionTime = 250;

const TInt KMaxPreviewPaneLength = 60;

const TInt KMsgUpdaterTimerDelay = 2500000; // Time to update list, 2,5sec

const TInt KNewMailTimerDelay = 20; // sleeping timer to start processing new messages

const TInt KSortTimerDelay = 40;    // sleeping timer to start sorting ( delay should be longer than abowe )

const TInt KSortCountdown = 5;      // number how many times will be tried do start sorting when it's forbidden

const TInt KNewMailMaxBatch = 7;    // number of new mails inserted into list at once

static const TInt KMsgDeletionWaitNoteAmount = 5;

_LIT( KMissingPreviewDataMarker, "..." );

static const TInt KMaxItemsFethed = 1000;

static const TInt KCMsgBlock = 15;

static const TInt KCMsgBlockSort = 50;

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

// Generic method for deleting a pointer and setting it NULL.

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

//

template <class T> void SafeDelete(T*& ptr)

    {

    delete ptr;

    ptr = NULL;

    }

// TDeleteTask

// Task class for deleting mail

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

// Class definition

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

template <class T> struct TDeleteTask

    {

public:

    typedef void ( T::*TDeleteMethod )( const RFsTreeItemIdList& aEntries );

public:    

    TDeleteTask(T& aObject, TDeleteMethod aMethod);    

    ~TDeleteTask();

    void ExecuteL();

    RFsTreeItemIdList& Entries();

    void Reset();

private:

    T& iObject;

    TDeleteMethod iMethod;    

    RFsTreeItemIdList iEntries;

    };

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

// TDeleteTask<T>::TDeleteTask

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

//

template <class T> TDeleteTask<T>::TDeleteTask( T& aObject, TDeleteMethod aMethod )

    : iObject(aObject), iMethod(aMethod)

    {    

    }

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

// TDeleteTask<T>::~TDeleteTask

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

//

template <class T> TDeleteTask<T>::~TDeleteTask()

    {

    iEntries.Close();

    }

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

// TDeleteTask<T>::ExecuteL

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

//

template <class T> void TDeleteTask<T>::ExecuteL()

    {

    (iObject.*iMethod)(iEntries);

    Reset();

    }

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

// TDeleteTask<T>::Entries

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

//

template <class T> RFsTreeItemIdList& TDeleteTask<T>::Entries()

    {

    return iEntries;

    }

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

// TDeleteTask<T>::Reset

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

//

template <class T> void TDeleteTask<T>::Reset()

    {

    iEntries.Reset();

    }

// CMailListModelUpdater

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

// CMailListModelUpdater::NewL

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

//

CMailListModelUpdater* CMailListModelUpdater::NewL()

    {

    CMailListModelUpdater* self = new (ELeave) CMailListModelUpdater();

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CMailListModelUpdater::ConstructL

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

//

void CMailListModelUpdater::ConstructL()

    {

    User::LeaveIfError( iTimer.CreateLocal() );

    }

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

// CMailListModelUpdater::CMailListModelUpdater

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

//

CMailListModelUpdater::CMailListModelUpdater() : CActive(EPriorityStandard)

    {

    CActiveScheduler::Add(this);

    iBlockSize = KCMsgBlock;

    }

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

// CMailListModelUpdater::~CMailListModelUpdater

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

//

CMailListModelUpdater::~CMailListModelUpdater()

    {

    iObserver = NULL;

    Cancel();

    iSorting.Close();

    iTimer.Close();

    }

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

// Returns arrays for sorting parameters. Updater owns the arrays because

// it has to stay alive as long as the iterator is being used.

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

//

RArray<TFSMailSortCriteria>& CMailListModelUpdater::Sorting()

    {

    iSorting.Reset();

    return iSorting;

    }

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

// Update the mail list model from given iterator. Update progress will be

// informed to the observer.

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

//

void CMailListModelUpdater::UpdateModelL(MObserver& aObserver, 

                                         MFSMailIterator* aIterator, TInt aBlockSize)

    {

    Cancel();

    iObserver = &aObserver;

    iIterator = aIterator;

    Signal(EInitialize);

    iBlockSize = aBlockSize;

    }

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

// Internal method. Sets new state and signals itself.

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

//

void CMailListModelUpdater::Signal(TState aState, TInt /*aError*/)

    {

    const TInt KDelayInMicroSeconds = 5 * 1000; // 5 ms

    // timer used to get CAknWaitDialog animation working

    iState = aState;

    iTimer.After(iStatus, KDelayInMicroSeconds);

    SetActive();

    //iState = aState;

    //iStatus = KRequestPending;

    //SetActive();

    //TRequestStatus* status = &iStatus;

    //User::RequestComplete(status, aError);

    }

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

// Initialization state. Reset update and call UpdateBeginL() for the observer.

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

//

void CMailListModelUpdater::InitializeL()

    {

    iParentId = KFsTreeRootID;

    iId = TFSMailMsgId();

    iItemsFetched = 0;

    iObserver->UpdateBeginL();

    Signal(EFetch);

    }

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

// Fetch state. Fetch next messages and if there is more messages signal

// fetch state again OR proceed to finalizing state.

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

//

void CMailListModelUpdater::FetchL()

    {

    TInt blockSize = iBlockSize;

    if ( iItemsFetched == 0 )

        {

        blockSize = KCMsgBlock;

        }

    RPointerArray<CFSMailMessage> messages(blockSize);

    CleanupClosePushL(messages);

    const TBool moreMessages(iIterator->NextL(iId, blockSize, messages));

    if (messages.Count() > 0)

        {

        iItemsFetched += messages.Count();

        iId = messages[messages.Count() - 1]->GetMessageId();

        iObserver->UpdateProgressL(iParentId, messages);

        }

    CleanupStack::PopAndDestroy(); // messages.Close()

    if (moreMessages && iItemsFetched < KMaxItemsFethed)

        {

        Signal(EFetch);

        }

    else

        {

        Signal(EFinalize);

        }

    }

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

// Finalizing state. Notify observer that model update has been done and

// free the resources.

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

//

void CMailListModelUpdater::FinalizeL()

    {

    iObserver->UpdateCompleteL();

    Reset();

    }

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

// If the state is anything but EIdle, returns ETrue.

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

//

TBool CMailListModelUpdater::IsUpdating() const

    {

    return iState > EIdle;

    }

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

// Reset the state to EIdle and free resources.

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

//

void CMailListModelUpdater::Reset()

    {

    iSorting.Reset();

    SafeDelete(iIterator);

    iState = EIdle;

    }

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

// Active objects RunL()

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

//

void CMailListModelUpdater::RunL()

    {

    const TInt error(iStatus.Int());

    if (!error)

        {

        switch (iState)

            {

            case EInitialize:

                InitializeL();

                break;

            case EFetch:

                FetchL();

                break;

            case EFinalize:

            default:

                FinalizeL();

                break;

            }

        }

    else

        {

        User::Leave(error);  // causes RunError to be called

        }

    }

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

// Update has been cancelled. Inform the observer and free resources.

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

//

void CMailListModelUpdater::DoCancel()

    {

    if (iObserver)

        {

        iObserver->UpdateCancelled(IsUpdating());

        }

    Reset();

    iTimer.Cancel();

    }

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

// CMailListModelUpdater::RunError

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

//

TInt CMailListModelUpdater::RunError(TInt aError)

    {

    if ( aError != KErrNone )

        {

        TRAP_IGNORE( iObserver->UpdateErrorL( aError ) );

        }

    return aError;

    }

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

// Static constructor.

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

//

CFSEmailUiMailListVisualiser* CFSEmailUiMailListVisualiser::NewL(CAlfEnv& aEnv,

																 CFreestyleEmailUiAppUi* aAppUi,

																 CAlfControlGroup& aMailListControlGroup )

    {

    FUNC_LOG;

    CFSEmailUiMailListVisualiser* self = CFSEmailUiMailListVisualiser::NewLC(aEnv, aAppUi, aMailListControlGroup );

    CleanupStack::Pop(self);

    return self;

    }

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

// Static constructor.

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

//

CFSEmailUiMailListVisualiser* CFSEmailUiMailListVisualiser::NewLC(CAlfEnv& aEnv,

																  CFreestyleEmailUiAppUi* aAppUi,

																  CAlfControlGroup& aMailListControlGroup)

    {

    FUNC_LOG;

    CFSEmailUiMailListVisualiser* self =

        new (ELeave) CFSEmailUiMailListVisualiser( aEnv, aAppUi, aMailListControlGroup );

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

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

// Second phase constructor.

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

//

void CFSEmailUiMailListVisualiser::ConstructL()

	{

    FUNC_LOG;

	BaseConstructL( R_FSEMAILUI_MAIL_LIST_VIEW );

	iMailListModelUpdater = CMailListModelUpdater::NewL();

	// Don't construct this anywhere else than here.

	// Don't delete this until in the destructor to avoid NULL checks.

    iModel = CFSEmailUiMailListModel::NewL( &iAppUi );

	// Set list as initial focused control

	iFocusedControl = EMailListComponent;

	iThisViewActive = EFalse;

	iSkinChanged = EFalse;

	iFirstStartCompleted = EFalse;

	iAsyncCallback = new (ELeave) CAsyncCallBack( CActive::EPriorityStandard );

	iAsyncRedrawer = new (ELeave) CAsyncCallBack( CActive::EPriorityLow );

	iLastFocus = EFalse;

    iDeleteTask = new (ELeave) TDeleteTask<CFSEmailUiMailListVisualiser> (*this, HandleDeleteTaskL);

    iNewMailTimer = CFSEmailUiGenericTimer::NewL( this );

    iSortTimer = CFSEmailUiGenericTimer::NewL( this );

    iSortState = ESortNone;

	iTouchFeedBack = MTouchFeedback::Instance();

 	}

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

// Second phase constructor.

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

//

// CFSEmailUiMailListVisualiser::DoFirstStartL()

// Purpose of this function is to do first start things only when list is

// really needed to be shown. Implemented to make app startuo faster.

void CFSEmailUiMailListVisualiser::DoFirstStartL()

    {

    FUNC_LOG;

    // Create mail list updater timer

    iMailListUpdater = CMailListUpdater::NewL( this );

    // Set initial sort criteria

    iCurrentSortCriteria.iField = EFSMailSortByDate;

    iCurrentSortCriteria.iOrder = EFSMailDescending;

    // Create screen control and anchor layout

    iMailListControl = CFreestyleEmailUiMailListControl::NewL( iEnv, this );

    iScreenAnchorLayout = CAlfAnchorLayout::AddNewL( *iMailListControl );

    iScreenAnchorLayout->SetFlags(EAlfVisualFlagAutomaticLocaleMirroringEnabled);

    iTouchManager = CEUiEmailListTouchManager::NewL(*this);

    // Create control bar control and append to control group and anchor layout

    iControlBarControl = CFsControlBar::NewL( iEnv );

    iControlBarControl->AddObserverL( *this );

    iControlBarControl->AddObserverL( *iTouchManager );

    CreateControlBarLayoutL();

    SetMailListLayoutAnchors();