/*

* 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 start-up monitor.

*

*/

#include "CPbk2StartupMonitor.h"

// Phonebook 2

#include "CPbk2AppUi.h"

#include <CPbk2StoreProperty.h>

#include <CPbk2StorePropertyArray.h>

#include <Pbk2ProcessDecoratorFactory.h>

#include <CPbk2AppUiBase.h>

#include <Pbk2ViewId.hrh>

#include <MPbk2AppUiExtension.h>

#include <CPbk2StoreConfiguration.h>

#include <MPbk2StartupObserver.h>

#include <MPbk2ApplicationServices.h>

#include <MPbk2ContactViewSupplier.h>

#include <Pbk2UIControls.rsg>

#include <Pbk2CommonUi.rsg>

#include <CPbk2AppViewBase.h>

// Virtual Phonebook

#include <MVPbkContactStore.h>

#include <MVPbkContactStoreProperties.h>

#include <MVPbkContactViewBase.h>

#include <CVPbkContactStoreUriArray.h>

#include <MVPbkContactStoreList.h>

#include <CVPbkContactManager.h>

// System includes

#include <StringLoader.h>

#include <aknnotewrappers.h>

#include <aknview.h>

// Debugging headers

#include <Pbk2Debug.h>

const TInt KOneSecond = 1000000;

const TInt KGranularity = 4;

/// Unnamed namespace for local definitions

namespace {

#ifdef _DEBUG

enum TPanicCode

    {

    EPanicNullPointer = 1,

    };

void Panic(TPanicCode aReason)

    {

    _LIT( KPanicText, "CPbk2StartupMonitor" );

    User::Panic(KPanicText,aReason);

    }

#endif // _DEBUG

} /// namespace

/**

 * Utility class that implements the wait logic and

 * process decoration if needed.

 */

class CPbk2StartupMonitor::CPbk2StartupWaiter :

        public CTimer,

        private MPbk2ProcessDecoratorObserver

    {

    public: // Construction and destruction

        /**

         * Creates a new instance of this class.

         *

         * @return  A new instance of this class.

         */

        static CPbk2StartupWaiter* NewL();

        /**

         * Destructor.

         */

        ~CPbk2StartupWaiter();

    public: // Interface

        /**

         * Stops the monitor.

         */

        void Stop();

        /**

         * Restart monitor. 

         */

        void Restart();

        /**

         * Disables wait note if waiter is started.

         */

        void DisableWaitNote();

    private: // From CTimer

        void RunL();

        TInt RunError(

                TInt aError );

    private: // From MPbk2ProcessDecoratorObserver

        void ProcessDismissed(

                TInt aCancelCode );

    private: // Implementation

        CPbk2StartupWaiter();

        void ConstructL();

    private: // Data

        /// Own: Decorator for the process

        MPbk2ProcessDecorator* iDecorator;

        /// Is decorator launched

        TBool iStarted;

        /// Own: There are exception that even if monitor is started

        /// wait note should not be displayed.

        TBool iDisplayWaitNote;

    };

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

// CPbk2StartupMonitor::CPbk2StartupWaiter::CPbk2StartupWaiter

// EPriorityHigh because the timer must not be delayed due to other

// active objects in this thread.

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

//

CPbk2StartupMonitor::CPbk2StartupWaiter::CPbk2StartupWaiter() :

        CTimer( CActive::EPriorityHigh )

    {

    CActiveScheduler::Add(this);

    }

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

// CPbk2StartupMonitor::CPbk2StartupWaiter::~CPbk2StartupWaiter

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

//

CPbk2StartupMonitor::CPbk2StartupWaiter::~CPbk2StartupWaiter()

    {

    Cancel();

    delete iDecorator;

    }

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

// CPbk2StartupMonitor::CPbk2StartupWaiter::ConstructL

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

//

inline void CPbk2StartupMonitor::CPbk2StartupWaiter::ConstructL()

    {

    CTimer::ConstructL();

    // According to the Notes specification the wait note is showed if the

    // operation takes more than a second. And when it's showed it should

    // be visible at least 1,5 seconds. In our case the operation starts

    // when the first view is launched i.e. the view's DoActivateL notifies

    // the start up monitor.

    // Wait KOneSecond and then launch the wait note without delay.

    After( TTimeIntervalMicroSeconds32( KOneSecond ) );

    iDisplayWaitNote = ETrue;

    }

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

// CPbk2StartupMonitor::CPbk2StartupWaiter::NewL

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

//

CPbk2StartupMonitor::CPbk2StartupWaiter*

        CPbk2StartupMonitor::CPbk2StartupWaiter::NewL()

    {

    CPbk2StartupMonitor::CPbk2StartupWaiter* self =

        new ( ELeave ) CPbk2StartupMonitor::CPbk2StartupWaiter();

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CPbk2StartupMonitor::CPbk2StartupWaiter::Stop

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

//

void CPbk2StartupMonitor::CPbk2StartupWaiter::Stop()

    {

    Cancel();

    if ( iDecorator )

        {

        iDecorator->ProcessStopped();

        }

    iDisplayWaitNote = ETrue;

    }

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

// CPbk2StartupMonitor::CPbk2StartupWaiter::Restart

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

//

void CPbk2StartupMonitor::CPbk2StartupWaiter::Restart()

    {

    Cancel();

    After( TTimeIntervalMicroSeconds32( KOneSecond ) );

    }

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

// CPbk2StartupMonitor::CPbk2StartupWaiter::DisableWaitNote

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

//

void CPbk2StartupMonitor::CPbk2StartupWaiter::DisableWaitNote()

    {

    iDisplayWaitNote = EFalse;

    }

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

// CPbk2StartupMonitor::CPbk2StartupWaiter::RunL

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

//

void CPbk2StartupMonitor::CPbk2StartupWaiter::RunL()

    {

    // Timer has elapsed

    if( !iDecorator )

    	{

		iDecorator = Pbk2ProcessDecoratorFactory::CreateWaitNoteDecoratorL

				( R_QTN_FDN_READING_MEMORY_WAIT_NOTE, EFalse );

		iDecorator->SetObserver(*this);

    	}

    if( !iStarted && iDisplayWaitNote ) // don't start twice

    	{

		const TInt dummy = 0; // wait note doesn't care about amount

		iDecorator->ProcessStartedL(dummy);

		iStarted = ETrue;

    	}

    iDisplayWaitNote = ETrue;

    }

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

// CPbk2StartupMonitor::CPbk2StartupWaiter::RunError

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

//

TInt CPbk2StartupMonitor::CPbk2StartupWaiter::RunError( TInt aError )

    {

    CCoeEnv::Static()->HandleError(aError);

    iStarted = EFalse;

    iDisplayWaitNote = ETrue;

    if (iDecorator)

        {

        iDecorator->ProcessStopped();

        }

    return KErrNone;

    }

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

// CPbk2StartupMonitor::CPbk2StartupWaiter::ProcessDismissed

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

//

void CPbk2StartupMonitor::CPbk2StartupWaiter::ProcessDismissed

        ( TInt aCancelCode )

    {

    iStarted = EFalse;

    if ( aCancelCode == EAknSoftkeyCancel )

        {

        CPbk2AppUi& appUi = static_cast<CPbk2AppUi&>

            ( *CEikonEnv::Static()->EikAppUi() );

        appUi.RunAppShutter();

        }

    }

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

// CPbk2StartupMonitor::CPbk2StartupMonitor

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

//

CPbk2StartupMonitor::CPbk2StartupMonitor

        ( MPbk2AppUiExtension& aAppUiExtension,

          CPbk2StorePropertyArray& aStoreProperties,

          CPbk2StoreConfiguration& aStoreConfiguration,

          CVPbkContactManager& aContactManager ) :

            iAppUiExtension( aAppUiExtension ),

            iStoreProperties( aStoreProperties ),

            iStoreConfiguration( aStoreConfiguration ),

            iContactManager( aContactManager ),

            iFirstViewId( TUid::Uid( EPbk2NullViewId ) )

    {

    }

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

// CPbk2StartupMonitor::~CPbk2StartupMonitor

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

//

CPbk2StartupMonitor::~CPbk2StartupMonitor()

    {

    delete iStoreUris;

    delete iUnavailableStoreNames;

    delete iWaiter;

    delete iIdleNotifier;

    iObservers.Close();

    }

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

// CPbk2StartupMonitor::ConstructL

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

//

inline void CPbk2StartupMonitor::ConstructL()

    {

    iIdleNotifier = CIdle::NewL( CActive::EPriorityIdle );

    }

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

// CPbk2StartupMonitor::NewL

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

//

CPbk2StartupMonitor* CPbk2StartupMonitor::NewL

        ( MPbk2AppUiExtension& aAppUiExtension,

          CPbk2StorePropertyArray& aStoreProperties,

          CPbk2StoreConfiguration& aStoreConfiguration,

          CVPbkContactManager& aContactManager )

    {

    CPbk2StartupMonitor* self = new ( ELeave ) CPbk2StartupMonitor

        ( aAppUiExtension, aStoreProperties,

          aStoreConfiguration, aContactManager );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CPbk2StartupMonitor::StartupBeginsL

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

//

void CPbk2StartupMonitor::StartupBeginsL()

    {

    // Well, actually start up monitor runs when first application view is

    // activated in NotifyViewActivationL but let the UI extensions start

    // their task before that.

    iIdleNotifier->Cancel();

    iAppUiExtension.ExtensionStartupL( *this );

    }

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

// CPbk2StartupMonitor::RestartStartupL

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

//

void CPbk2StartupMonitor::RestartStartupL()

    {

    //Updated Functionality (EHKN-7RRBR8):

    //When PB goes to background or foreground, its not necessary to be in 

    //EPbk2NamesListViewId. It can be even in the xspview.

    //Hence only if the Active view was EPbk2NamesListViewId, we need to emulate

    //the view activation of EPbk2NamesListViewId.

    //By this way we can reduce the unnecessary note which gets shown

    //in xsp views. Leave it to xsp views what to do when this happens

    //Previous Functionality :

    // This function is used in "Always On" mode. When application goes

    // background it activates EPbk2NamesListViewId. When coming back to

    // foreground again we need to emulate the view activation of

    // EPbk2NamesListViewId.

    //Fix for TSW Err : EHKN-7RRBR8 "Checking contacts" shown when selecting search for WLAN

    CPbk2AppViewBase* activeView = Phonebook2::Pbk2AppUi()->ActiveView();

    TUid activeViewId ( TUid::Uid( EPbk2NullViewId ) );

    if ( activeView )

        {

        activeViewId = activeView->Id();

        }

    if ( 

            ( iFirstViewId != TUid::Uid( EPbk2NullViewId ) ) &&

            //Perform the Startup monitor only of its the PhoneBook Views

            //exclude the xsp views

            ( IsNativePhoneBookView( activeViewId ) )

        )

        {

        TBool isMonitorActive = ( iStoreUris && iStoreUris->Count() > 0 );

        if ( !isMonitorActive )

            {

            StartupBeginsL();

            // Reset the first application view id and then call

            // NotifyViewActivationL as it would be called from

            // the DoActivateL.

            iFirstViewId = TUid::Uid( EPbk2NullViewId );

            NotifyViewActivationL( TUid::Uid( EPbk2NamesListViewId ) );

            }

        }

    }

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

// CPbk2StartupMonitor::HandleStartupComplete

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

//

void CPbk2StartupMonitor::HandleStartupComplete()

    {

    // Core Phonebook2 is not actually interested of others because it

    // it wants that the start up is as fast as possible.

    // E.g if a UI extension is doing something heavy in the start up

    // it will not cause delay to user.

    }

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

// CPbk2StartupMonitor::HandleStartupFailed

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

//

void CPbk2StartupMonitor::HandleStartupFailed( TInt aError )

    {

    HandleError( aError );

    }

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

// CPbk2StartupMonitor::RegisterEventsL

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

//

void CPbk2StartupMonitor::RegisterEventsL( MPbk2StartupObserver& aObserver )

    {

    if (iObservers.Find(&aObserver) == KErrNotFound)

        {

        iObservers.AppendL(&aObserver);

        }

    }

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

// CPbk2StartupMonitor::DeregisterEvents

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

//

void CPbk2StartupMonitor::DeregisterEvents( MPbk2StartupObserver& aObserver )

    {

    TInt pos = iObservers.Find(&aObserver);

    if (pos != KErrNotFound)

        {

        iObservers.Remove(pos);

        }

    }

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

// CPbk2StartupMonitor::NotifyViewActivationL

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

//

void CPbk2StartupMonitor::NotifyViewActivationL( TUid aViewId )

    {

    // Default is: wait all contacts view.

    NotifyViewActivationL( aViewId,

            *Phonebook2::Pbk2AppUi()->ApplicationServices().

                ViewSupplier().AllContactsViewL() );

    }

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

// CPbk2StartupMonitor::NotifyViewActivationL

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

//

void CPbk2StartupMonitor::NotifyViewActivationL( TUid aViewId,

        MVPbkContactViewBase& aContactView )

    {

    if ( iFirstViewId == TUid::Uid( EPbk2NullViewId ) )

        {

        // Start monitor actions only if it hasn't been notified before.

        // Only the first application view activation is important for

        // the monitor.

        iFirstViewId = aViewId;

        // Start listening to store events

        RegisterStoreEventsForViewL( aContactView );

        // Don't start anything if there are no stores to listen.

        if ( iStoreUris && iStoreUris->Count() > 0 )

            {

            // Start wait note with delay

            if( !iWaiter )

            	{

            	iWaiter = CPbk2StartupWaiter::NewL();

            	}

            else

            	{

				iWaiter->Restart();

            	}

            // Start listening to view events

            aContactView.AddObserverL( *this );

            }

        else

            {

            // There is no view/store events coming to monitor so send

            // completion event to monitor's observers.

            StartAsyncCompletionNotification();

			StopWaiter();

            }

        }

    }

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

// CPbk2StartupMonitor::StoreReady

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

//

void CPbk2StartupMonitor::StoreReady(MVPbkContactStore& aContactStore)

    {

    PBK2_DEBUG_PRINT(PBK2_DEBUG_STRING

        ("CPbk2StartupMonitor::StoreReady(0x%x)"), this);

    TRAPD( res, HandleStoreNotificationL( aContactStore ) );

    HandleError( res );

    }

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

// CPbk2StartupMonitor::StoreUnavailable

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

//

void CPbk2StartupMonitor::StoreUnavailable

        ( MVPbkContactStore& aContactStore, TInt /*aReason*/ )

    {

    PBK2_DEBUG_PRINT(PBK2_DEBUG_STRING

        ("CPbk2StartupMonitor::StoreUnavailable(0x%x)"), this);

    TRAPD( res, HandleStoreUnavailableL( aContactStore ) );

    HandleError( res );

    }