/*

* Copyright (c) 2005-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:  Phonebook 2 names list control.

*

*/

// INCLUDE FILES

#include "CPbk2NamesListControl.h"

// Phonebook 2

#include "CPbk2NamesListStateFactory.h"

#include "CPbk2ContactViewListBox.h"

#include "CPbk2ThumbnailLoader.h"

#include "cpbk2filteredviewstack.h"

#include "MPbk2NamesListState.h"

#include "MPbk2ControlObserver.h"

#include "MPbk2UiControlEventSender.h"

#include <CPbk2ControlContainer.h>

#include <CPbk2ViewState.h>

#include <Pbk2UIControls.hrh>

#include <MPbk2Command.h>

#include <MPbk2ContactUiControlExtension.h>

#include <pbk2contactuicontroldoublelistboxextension.h>

#include <MPbk2UIExtensionFactory.h>

#include <CPbk2UIExtensionManager.h>

#include "MPbk2FilteredViewStack.h"

#include "cpbk2predictiveviewstack.h"

#include <Pbk2Commands.hrh>

#include <Pbk2InternalUID.h>

#include "CPbk2PredictiveSearchFilter.h"

#include "cpbk2contactviewdoublelistbox.h"

#include <CPbk2ThumbnailManager.h>

#include "CPbk2AppUi.h"

// Virtual Phonebook

#include <MVPbkContactViewBase.h>

#include <MVPbkViewContact.h>

#include <MVPbkContactLink.h>

#include <CVPbkContactLinkArray.h>

// System includes

#include <barsread.h>

#include <aknsfld.h>

#include <AknPriv.hrh>

#include <featmgr.h>

#include <AknWaitDialog.h>

// Debugging headers

#include <Pbk2Debug.h>

/// Unnamed namespace for local definitions

namespace {

/**

 * Handles errors.

 *

 * @param aErrorCode    Error code.

 */

void HandleError( TInt aErrorCode )

    {

    if ( aErrorCode != KErrNone )

        {

        // Display standard error message

        CEikonEnv::Static()->HandleError( aErrorCode );

        }

    }

#ifdef _DEBUG

enum TPanicCode

    {

    EPanicLogic_ComponentControl = 1,

    };

void Panic(TPanicCode aReason)

    {

    _LIT(KPanicText, "CPbk2NamesListControl");

    User::Panic(KPanicText, aReason);

    }

#endif // _DEBUG

} /// namespace

/**

 * A helper class for sending control events.

 */

NONSHARABLE_CLASS( CPbk2UiControlEventSender ) : public CBase,

                                                public MPbk2UiControlEventSender

    {

    public: // Construction and destruction

        /**

         * Creates a new instance of this class.

         *

         * @param aControl      Control.

         * @param aObservers    Observers.

         * @return  A new instance of this class.

         */

        static CPbk2UiControlEventSender* NewL(

                CPbk2NamesListControl& aControl,

                RPointerArray<MPbk2ControlObserver>& aObservers );

        /**

         * Destructor.

         */

       ~CPbk2UiControlEventSender();

    public: /// From MPbk2UiControlEventSender

        TBool SendEventToObserversL(

                const TPbk2ControlEvent& aEvent );

        void Reset();

    private: // Implementation

        CPbk2UiControlEventSender(

                CPbk2NamesListControl& aControl,

                RPointerArray<MPbk2ControlObserver>& aObservers );

        void ConstructL();

        TBool SendEvent(

                const TPbk2ControlEvent& aEvent );

    private: // Data

        /// Ref: Control

        CPbk2NamesListControl& iControl;

        /// Ref: Observers

        RPointerArray<MPbk2ControlObserver>& iObservers;

        /// Own: Indicates has the ready event been sent

        TBool iReadyEventSend;

    };

/**

 * A helper class for hiding inheritance of MPbk2FilteredViewStackObserver

 * from CPbk2NamesListControl.

 */

class CPbk2FilteredViewStackObserver  : public CBase,

                                                      public MPbk2FilteredViewStackObserver

    {

    public: /// Typedefs

        typedef void( CPbk2NamesListControl::* TopViewChangedFuncPtr )

            ( MVPbkContactViewBase& aOldView );

        typedef void( CPbk2NamesListControl::* ViewStackErrorFuncPtr )

            ( TInt aError );

        typedef void( CPbk2NamesListControl::* ContactAddedToBaseViewFuncPtr )

            ( MVPbkContactViewBase& aBaseView,

              TInt aIndex, const MVPbkContactLink& aContactLink );

        typedef void( CPbk2NamesListControl::* TopViewUpdatedFuncPtr )();

        typedef void( CPbk2NamesListControl::* BaseViewChangedFuncPtr )();

    public: // Construction and destruction

        /**

         * Creates a new instance of this class.

         *

         * @param aControl                          Control.

         * @param aViewStack                        View stack.

         * @param aTopViewChangedFuncPtr            Top view changed function pointer.

         * @param aTopViewUpdatedFuncPtr            Top view updated function pointer.

         * @param aBaseViewChangedFuncPtr           Base view changed function pointer.

         * @param aViewStackErrorFuncPtr            View stack error function pointer.

         * @param aContactAddedToBaseViewFuncPtr    Contact added to base view function pointer.

         * @return  A new instance of this class.

         */

        static CPbk2FilteredViewStackObserver* NewL(

                CPbk2NamesListControl& aControl,

                TopViewChangedFuncPtr aTopViewChangedFuncPtr,

                TopViewUpdatedFuncPtr aTopViewUpdatedFuncPtr,

                BaseViewChangedFuncPtr aBaseViewChangedFuncPtr,

                ViewStackErrorFuncPtr aViewStackErrorFuncPtr,

                ContactAddedToBaseViewFuncPtr aContactAddedToBaseViewFuncPtr );

        /**

         * Destructor.

         */

       ~CPbk2FilteredViewStackObserver();

    private: // From MPbk2FilteredViewStackObserver

        void TopViewChangedL(

                MVPbkContactViewBase& aOldView );

        void TopViewUpdatedL();

        void BaseViewChangedL();

        void ViewStackError(

                    TInt aError );

        void ContactAddedToBaseView(

                    MVPbkContactViewBase& aBaseView,

                    TInt aIndex,

                    const MVPbkContactLink& aContactLink );

    private: // Implementation

        CPbk2FilteredViewStackObserver(

                CPbk2NamesListControl& aControl,

                TopViewChangedFuncPtr aTopViewChangedFuncPtr,

                TopViewUpdatedFuncPtr aTopViewUpdatedFuncPtr,

                BaseViewChangedFuncPtr aBaseViewChangedFuncPtr,

                ViewStackErrorFuncPtr aViewStackErrorFuncPtr,

                ContactAddedToBaseViewFuncPtr aContactAddedToBaseViewFuncPtr );

        void ConstructL();

    private: // Data

        /// Ref: Control

        CPbk2NamesListControl& iControl;

        /// Ref: Top view changed function pointer

        TopViewChangedFuncPtr iTopViewChangedFuncPtr;

        /// Ref: Top view updated function pointer

        TopViewUpdatedFuncPtr iTopViewUpdatedFuncPtr;

        /// Ref: Base view changed function pointer

        BaseViewChangedFuncPtr iBaseViewChangedFuncPtr;

        /// Ref: View stack error function pointer

        ViewStackErrorFuncPtr iViewStackErrorFuncPtr;

        /// Ref: Contact added to base view function pointer

        ContactAddedToBaseViewFuncPtr iContactAddedToBaseViewFuncPtr;

    };

/**

 * An observer for list box selections. Sends control events

 * when the list box enters to or from the selection mode.

 */

NONSHARABLE_CLASS( CPbk2ListBoxSelectionObserver ) :  public CBase,

                                                        private MListBoxSelectionObserver

    {

    public: // Interface

        /**

         * Creates a new instance of this class.

         *

         * @param aListBox      The list box that is observed.

         * @param aEventSender  An event sender for sending control

         *                      events.

         * @return  A new instance of this class.

         */

        static CPbk2ListBoxSelectionObserver* NewL(

                CPbk2NamesListControl& aControl,

                CEikListBox& aListBox,

                MPbk2UiControlEventSender& aEventSender );

        /**

         * Destructor

         */

        ~CPbk2ListBoxSelectionObserver();

    private: /// From MListBoxSelectionObserver

        void SelectionModeChanged(

                CEikListBox* aListBox,

                TBool aSelectionModeEnabled );

    private: // Implementation

        CPbk2ListBoxSelectionObserver(

                CPbk2NamesListControl& aControl,

                CEikListBox& aListBox,

                MPbk2UiControlEventSender& aEventSender );

        void ConstructL();

    private: // Data

        /// Ref: Control

        CPbk2NamesListControl& iControl;

        /// Ref: List box

        CEikListBox& iListBox;

        /// Ref: Event sender

        MPbk2UiControlEventSender& iEventSender;

    };

/**

 * Background Task Handler.

 */

NONSHARABLE_CLASS(CPbk2NamesListControlBgTask) : public CActive

    {

    public:

        CPbk2NamesListControlBgTask( CPbk2NamesListControl& aControl );

        ~CPbk2NamesListControlBgTask();

        void AddEvent( CPbk2NamesListControl::TPbk2NamesListBgEvents aEvent );

        void ClearAllEvents();

        void RemoveEvent( CPbk2NamesListControl::TPbk2NamesListBgEvents aEvent );

    private: // From CActive

        void DoCancel();

        void RunL();

        TInt RunError(TInt aError);

    private:

        //Owns

        RArray <CPbk2NamesListControl::TPbk2NamesListBgEvents> iEventQueue;

        //doesnt Own

        CPbk2NamesListControl& iControl;

    };

/**

 * A helper class for mass update cases.

 */

NONSHARABLE_CLASS( CPbk2HandleMassUpdate ) : public CBase

    {

    public: // Construction and destruction

        /**

         * Creates new instance of this class.

         * @return new instance of this class.

         */

        static CPbk2HandleMassUpdate* NewL(CEikListBox& iListBox);

        /**

         * Destructor.

         */

       ~CPbk2HandleMassUpdate();

    public:

        /**

         * Call this function after each update event.

         * @return  ETrue if this event is part of a mass update.

         */

       TBool MassUpdateCheckThis();

        /**

         * Call this function to check if mass update process is ongoing.

         * @return  ETrue if mass update process is ongoing.

         */

       TBool MassUpdateDetected();

       /**

        * Call this function to skip the showing of blocking progress note.

        */

      void MassUpdateSkipProgressNote( TBool aSkip );       

    private:

        CPbk2HandleMassUpdate(CEikListBox& iListBox);

        void ConstructL();

        TBool HandleMassUpdateCheckL();

        void HandleMassUpdateBurstL(

            const TTimeIntervalMicroSeconds aFromFirst, 

            const TInt64 aDeltaMax64);        

        void HandleMassUpdateResetCounters();

        void HandleMassUpdateDone();

        static TInt HandleMassUpdateTimerCallBack(TAny* aAny);

    private:

        TBool iHandleMassUpdateDetected;

        TTime iHandleMassUpdateFirst;

        TTime iHandleMassUpdatePrev;

        TInt  iHandleMassUpdateCount;

        TBool iHandleMassUpdateSkipDialog;        

        CPeriodic* iHandleMassUpdateTimer;

    };

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

// CPbk2UiControlEventSender::CPbk2UiControlEventSender

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

//

CPbk2UiControlEventSender::CPbk2UiControlEventSender

        ( CPbk2NamesListControl& aControl,

          RPointerArray<MPbk2ControlObserver>& aObservers ) :

            iControl( aControl ),

            iObservers( aObservers )

    {

    }

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

// CPbk2UiControlEventSender::NewL

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

//

CPbk2UiControlEventSender* CPbk2UiControlEventSender::NewL(

        CPbk2NamesListControl& aControl,

        RPointerArray<MPbk2ControlObserver>& aObservers )

    {

    CPbk2UiControlEventSender* self =

        new ( ELeave ) CPbk2UiControlEventSender( aControl, aObservers );

    return self;

    }

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

// CPbk2UiControlEventSender::~CPbk2UiControlEventSender

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

//

CPbk2UiControlEventSender::~CPbk2UiControlEventSender()

    {

    }

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

// CPbk2UiControlEventSender::SendEventToObserversL

// Sends control observer events in reverse order to disable the possibility

// of crash if aObserver is changed during the loop.

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

//

TBool CPbk2UiControlEventSender::SendEventToObserversL(

        const TPbk2ControlEvent& aEvent )

    {

    // Loop backwards in case some observer destroys itself in the

    // event handler

    TBool okToSendEvent( SendEvent( aEvent ) );

    for ( TInt i = iObservers.Count() - 1; i >= 0 && okToSendEvent; --i )

        {

        iObservers[i]->HandleControlEventL( iControl, aEvent );

        }

    return okToSendEvent;

    }

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

// CPbk2UiControlEventSender::Reset

// Resets event sender

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

//

void CPbk2UiControlEventSender::Reset()

    {

    iReadyEventSend = EFalse;

    }

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

// CPbk2UiControlEventSender::SendEvent

// Makes sure that ready event is send only ones and reset the status

// if control goes unavailable

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

//

TBool CPbk2UiControlEventSender::SendEvent

        ( const TPbk2ControlEvent& aEvent )

    {

    TBool ret( ETrue );

    if ( aEvent.iEventType == TPbk2ControlEvent::EUnavailable )

        {

        iReadyEventSend = EFalse;

        }

    else if ( aEvent.iEventType == TPbk2ControlEvent::EReady )

        {

        if ( iReadyEventSend )

            {

            ret = EFalse;

            }

        else

            {

            iReadyEventSend = ETrue;

            }

        }

    return ret;

    }

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

// CPbk2FilteredViewStackObserver::CPbk2FilteredViewStackObserver

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

//

CPbk2FilteredViewStackObserver::CPbk2FilteredViewStackObserver(

        CPbk2NamesListControl& aControl,

        TopViewChangedFuncPtr aTopViewChangedFuncPtr,

        TopViewUpdatedFuncPtr aTopViewUpdatedFuncPtr,

        BaseViewChangedFuncPtr aBaseViewChangedFuncPtr,

        ViewStackErrorFuncPtr aViewStackErrorFuncPtr,

        ContactAddedToBaseViewFuncPtr aContactAddedToBaseViewFuncPtr ) :

            iControl( aControl ),

            iTopViewChangedFuncPtr( aTopViewChangedFuncPtr ),

            iTopViewUpdatedFuncPtr( aTopViewUpdatedFuncPtr ),

            iBaseViewChangedFuncPtr( aBaseViewChangedFuncPtr ),

            iViewStackErrorFuncPtr( aViewStackErrorFuncPtr ),

            iContactAddedToBaseViewFuncPtr( aContactAddedToBaseViewFuncPtr )

    {

    }

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

// CPbk2FilteredViewStackObserver::NewL

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

//

CPbk2FilteredViewStackObserver* CPbk2FilteredViewStackObserver::NewL(

        CPbk2NamesListControl& aControl,

        TopViewChangedFuncPtr aTopViewChangedFuncPtr,

        TopViewUpdatedFuncPtr aTopViewUpdatedFuncPtr,

        BaseViewChangedFuncPtr aBaseViewChangedFuncPtr,

        ViewStackErrorFuncPtr aViewStackErrorFuncPtr,

        ContactAddedToBaseViewFuncPtr aContactAddedToBaseViewFuncPtr )

    {

    CPbk2FilteredViewStackObserver* self =

        new ( ELeave ) CPbk2FilteredViewStackObserver( aControl,

            aTopViewChangedFuncPtr,

            aTopViewUpdatedFuncPtr,

            aBaseViewChangedFuncPtr,

            aViewStackErrorFuncPtr,

            aContactAddedToBaseViewFuncPtr );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CPbk2FilteredViewStackObserver::ConstructL

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

//

void CPbk2FilteredViewStackObserver::ConstructL()

    {

    }

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

// CPbk2FilteredViewStackObserver::~CPbk2FilteredViewStackObserver

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

//

CPbk2FilteredViewStackObserver::~CPbk2FilteredViewStackObserver()

    {

    }

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

// CPbk2FilteredViewStackObserver::TopViewChangedL

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

//

void CPbk2FilteredViewStackObserver::TopViewChangedL(

        MVPbkContactViewBase& aOldView )

    {

    ( iControl.*iTopViewChangedFuncPtr )( aOldView );

    }

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

// CPbk2FilteredViewStackObserver::TopViewUpdatedL

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

//

void CPbk2FilteredViewStackObserver::TopViewUpdatedL()

    {