/*

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

*

*/

// INCLUDE FILES

#include "CPbkAppUi.h"       // This class' declaration

#include <pbkconfig.hrh>

#include <barsread.h>        // TResourceReader

#include <eikmenup.h>

#include <aknnavide.h>       // CAknNavigationDecorator

#include <aknnotewrappers.h>

#include <FeatMgr.h>

#include <hlplch.h>          // HlpLauncher

#include <Phonebook.rsg>     // Phonebook resources

#include "CPbkApplication.h" // Phonebook application class

#include "CPbkDocument.h"    // Phonebook document class

#include "PbkAppViewFactory.h"   // Application view factory

#include "CViewActivationTransactionImpl.h"

#include "CPbkAppGlobals.h"

#include "CPbkViewNavigator.h"

#include "CPbkStartupView.h"

//SendUi

#include <sendui.h>                 // Send UI API

#include <SenduiMtmUids.h>          // Send UI MTM uids

// PbkEng.dll header files

#include <DigViewGraph.h>

// PbkView.dll header files

#include <CPbkViewState.h>

#include <CPbkCompressUiImpl.h>  // Phonebook compression UI

#include <CPbkFFSCheck.h>

// PbkUI.dll header files

#include <CPbkAppViewBase.h>

#include <MPbkCommandFactory.h>

// From PbkExt

#include <MPbkExtensionFactory.h>

#include <CPbkExtGlobals.h>

// Engine classes

#include    <CPbkContactEngine.h> // Phonebook engine class

#include    <CPbkConstants.h>

// Debugging headers

#include <pbkdebug.h>

#include "PbkProfiling.h"

// CONSTANTS

// View UID constants

const TUid CPbkAppUi::KPbkNamesListViewUid          = { EPbkNamesListViewId         };

const TUid CPbkAppUi::KPbkGroupsListViewUid         = { EPbkGroupsListViewId        };

const TUid CPbkAppUi::KPbkGroupMembersListViewUid   = { EPbkGroupMembersListViewId  };

const TUid CPbkAppUi::KPbkContactInfoViewUid        = { EPbkContactInfoViewId       };

const TUid CPbkAppUi::KPbkPhotoViewUid              = { EPbkPhotoViewViewId         };

const TUid CPbkAppUi::KPbkPersonalInfoViewUid       = { EPbkPersonalInfoViewId      };

/// Unnamed namespace for local definitions

namespace {

// LOCAL CONSTANTS AND MACROS

#ifdef _DEBUG

enum TPanicCode

    {

    EPanicPreCond_ConstructL = 1,

    EPanicPostCond_ConstructL,

    };

#else

// Amount of free heap memory required for always-on functionality

const TInt KAlwaysOnMinimumTreshold = 200*1024; // 200 kB

#endif

// ==================== LOCAL FUNCTIONS ====================

#ifdef _DEBUG

void Panic(TPanicCode aReason)

    {

    _LIT(KPanicText, "CPbkAppUi");

    User::Panic(KPanicText, aReason);

    }

#endif

}  // namespace

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

CPbkAppUi::CPbkAppUi() :

    iViewResourceFile(*iCoeEnv)

    {

    }

inline void CPbkAppUi::CreateEngineL()

    {

    TRAPD(err, PbkDocument()->CreateEngineL(EFalse));

    if (err == KErrCorrupt)

        {

        // Database cannot be opened or recoverd -> replace it with an

        // empty one. Always notify caller about DB corruption, even if

        // replacing fails.

        CAknNoteWrapper* note = new(ELeave) CAknNoteWrapper;

        note->ExecuteLD(R_PBK_NOTE_DATABASE_CORRUPTED);

        PbkDocument()->CreateEngineL(ETrue);

        }

    else if (err != KErrNone)

        {

        User::Leave(err);

        }

    }

/**

 * Loads view navigation graph from resources.

 */

inline void CPbkAppUi::ReadViewGraphL()

    {

    TResourceReader reader;

    iCoeEnv->CreateResourceReaderLC(reader, R_PBK_VIEWNODES);

    iViewGraph = CDigViewGraph::NewL(reader);

    CleanupStack::PopAndDestroy(); // reader

    iAppUiExtension->ApplyExtensionViewGraphChangesL(*iViewGraph);

    }

void CPbkAppUi::ConstructL()

    {

    __ASSERT_DEBUG(

        !iViewGraph && !iNaviPane && !iCompressUi,

        Panic(EPanicPreCond_ConstructL));

    PBK_DEBUG_PRINT(PBK_DEBUG_STRING("PHONEBOOK: started"));

    // Init base class

    __PBK_PROFILE_START(PbkProfiling::EAppUiBaseConstruct);

    BaseConstructL(EAknEnableSkin);

    __PBK_PROFILE_END(PbkProfiling::EAppUiBaseConstruct);

    // Initialize feature manager

    FeatureManager::InitializeLibL();

    // Create Phonebook engine

    PBK_DEBUG_PRINT(PBK_DEBUG_STRING("Engine construct begin"));

    CreateEngineL();

    PBK_DEBUG_PRINT(PBK_DEBUG_STRING("Engine construct end"));

    PbkDocument()->CreateGlobalsL();

    PBK_DEBUG_PRINT(PBK_DEBUG_STRING("Extension construct start"));

    CPbkExtGlobals* extGlobal = CPbkExtGlobals::InstanceL();

    extGlobal->PushL();

    iAppUiExtension = extGlobal->FactoryL().

        CreatePbkAppUiExtensionL(*PbkDocument()->Engine());

    CleanupStack::PopAndDestroy(extGlobal);

    PBK_DEBUG_PRINT(PBK_DEBUG_STRING("Extension construct end"));

    // Create UI elements

    PBK_DEBUG_PRINT(PBK_DEBUG_STRING("Viewnavi construct start"));

    __PBK_PROFILE_START(PbkProfiling::EViewNaviConstruct);

    ReadViewGraphL();

    iNaviPane = static_cast<CAknNavigationControlContainer*>

        (StatusPane()->ControlL(TUid::Uid(EEikStatusPaneUidNavi)));

    iViewNavigator = CPbkViewNavigator::NewL(*iViewGraph, *this);

    __PBK_PROFILE_END(PbkProfiling::EViewNaviConstruct);

    PBK_DEBUG_PRINT(PBK_DEBUG_STRING("Viewnavi construct end"));

    // Load view dll resource file

    iViewResourceFile.OpenL();

    // Create FFS space checker

    iFFSCheck = CPbkFFSCheck::NewL(iCoeEnv);

    // Create the compression UI

    iCompressUi = CPbkCompressUiImpl::NewL(*PbkDocument()->Engine());

    // Enable compression always

    iCompressUi->EnableCompression(ETrue);

    PBK_DEBUG_PRINT(PBK_DEBUG_STRING("Views construct start"));

    CPbkStartupView* startupView = CPbkStartupView::NewLC(*iAppUiExtension);

    AddViewL(startupView);

    CleanupStack::Pop(startupView);

    SetDefaultViewL(*startupView);

    CreateViewsL();

    PBK_DEBUG_PRINT(PBK_DEBUG_STRING("Views construct end"));

    CCoeEnv::Static()->AddForegroundObserverL(*this);

    __PBK_PROFILE_START(PbkProfiling::EStartupViewActivation);

    __ASSERT_DEBUG(

        iViewGraph && iNaviPane && iCompressUi,

        Panic(EPanicPostCond_ConstructL));

    }

CPbkAppUi::~CPbkAppUi()

    {

    PBK_DEBUG_PRINT(PBK_DEBUG_STRING("CPbkAppUi::~CPbkAppUi()"));

    CCoeEnv::Static()->RemoveForegroundObserver(*this);

    // delete data members

    delete iCompressUi;

    delete iFFSCheck;

    iViewResourceFile.Close();

    // Application views will be deleted by the base class destructor.

    delete iViewNavigator;

    delete iViewGraph;

    delete iAppGlobals;

    Release(iAppUiExtension);

    FeatureManager::UnInitializeLib();

    }

CPbkDocument* CPbkAppUi::PbkDocument() const

    {

    // Explicit cast: the document must always be of type CPbkDocument

    return static_cast<CPbkDocument*>(Document());

    }

CPbkApplication* CPbkAppUi::PbkApplication() const

    {

    // Explicit cast: the application must always be of type CPbkApplication

    return static_cast<CPbkApplication*>(Application());

    }

void CPbkAppUi::ActivatePhonebookViewL

        (TUid aViewId,

        const CPbkViewState* aViewState/*=NULL*/)

    {

    if (aViewState)

        {

        HBufC8* stateBuf = aViewState->PackLC();

        ActivateLocalViewL(aViewId, CPbkViewState::Uid(), *stateBuf);

        CleanupStack::PopAndDestroy();  // stateBuf

        }

    else

        {

        ActivateLocalViewL(aViewId);

        }

    }

void CPbkAppUi::ActivatePreviousViewL

        (const CPbkViewState* aViewState /*=NULL*/)

    {

    // Find current view in the graph

    CDigViewNode* viewNode = iViewGraph->FindNodeWithViewId(iView->Id());

    if (viewNode)

        {

        // get previous node

        CDigViewNode* prevNode = viewNode->PreviousNode();

        if (!prevNode)

            {

            prevNode = viewNode->DefaultPreviousNode();

            }

        if (prevNode)

            {

            if (prevNode->ExitNode())

                {

                ExitL();

                }

            else

                {

                ActivatePhonebookViewL(prevNode->ViewId(), aViewState);

                }

            }

        }

    }

CAknNavigationControlContainer* CPbkAppUi::NaviPane()

    {

    return iNaviPane;

    }

void CPbkAppUi::FFSClCheckL(const MPbkCommandHandler& aCommandHandler,

                            TInt aBytesToWrite /*=0*/)

    {

    iFFSCheck->FFSClCheckL(aCommandHandler, aBytesToWrite);

    }

CPbkAppUi::CViewActivationTransaction* CPbkAppUi::HandleViewActivationLC

        (const TUid& aViewId, const TVwsViewId& aPrevViewId,

        const TDesC* aTitlePaneText,

        const CEikImage* aContextPanePicture,

        TUint aFlags)

    {

    // Create and return an instance of view activation transaction

    return CViewActivationTransactionImpl::NewLC

        (*this, aViewId, aPrevViewId, aTitlePaneText,

        aContextPanePicture, aFlags);

    }

CPbkAppGlobalsBase* CPbkAppUi::AppGlobalsL()

    {

    if (!iAppGlobals)

        {

        iAppGlobals = CPbkAppGlobals::NewL();

        }

    return iAppGlobals;

    }

void CPbkAppUi::ExitL()

    {

    // Set this flag to EFalse to signal that we're either dying or going

    // to background.

    iIsRunningForeground = EFalse;

#ifndef _DEBUG

    // Check that we have enough free heap memory to go to background.

    // User::Available() does not check for the possibility to grow the heap,

    // so we'll need to allocate a dummy block and release it immediately.

    TAny* tmp = User::Alloc(KAlwaysOnMinimumTreshold);

    delete tmp;

    if (!iEndKeyExit && tmp &&

        PbkDocument()->Engine()->Constants()->LocallyVariatedFeatureEnabled(

            EPbkLVAlwaysOnPhonebook))

        {

        CPbkViewState* state = CPbkViewState::NewLC();

        state->SetFlags(CPbkViewState::EInitialized | CPbkViewState::ESendToBackground);

        // Activation of Names list view will send application to background.

        // Application can not be sent here to background because

        // activation is asynchronous operation and application could be set

        // to background before the view activation.

        ActivatePhonebookViewL(KPbkNamesListViewUid, state);

        CleanupStack::PopAndDestroy();  // state

        }

    else

        {

        CAknViewAppUi::ProcessCommandL(EAknCmdExit);

        }

#else // _DEBUG

    CAknViewAppUi::ProcessCommandL(EAknCmdExit);

#endif // _DEBUG

    }

void CPbkAppUi::Exit()

    {

    CPbkAppUiBase::Exit();

    }

TBool CPbkAppUi::IsRunningForeground() const

    {

    return iIsRunningForeground;

    }

/**

 * Returns true if aViewId is a phonebook view.

 */

TBool CPbkAppUi::IsPhonebookView(const TVwsViewId& aViewId) const

    {

    if (aViewId.iAppUid == Application()->AppDllUid())

        {

        const CDigViewNode* viewNode =

            iViewGraph->FindNodeWithViewId(aViewId.iViewUid);

        return viewNode && !viewNode->ExitNode();

        }

    else

        {

        return EFalse;

        }

    }

inline void CPbkAppUi::CmdExitL()

    {

    PBK_DEBUG_PRINT(PBK_DEBUG_STRING("CPbkAppUi::CmdExitL()"));

    // notify views before the exit is executed

    CAknViewAppUi::ProcessCommandL(EPbkCmdExit);

    CAknViewAppUi::Exit();

    }

void CPbkAppUi::SendAppToBackgroundL()

    {

    // Get the current task

    RWsSession ws;

    User::LeaveIfError(ws.Connect());

    TApaTaskList tasklist(ws);

    TApaTask task = tasklist.FindApp(Application()->AppDllUid());

    CleanupClosePushL(ws);

    if (task.Exists())

        {

        task.SendToBackground();

        }

    CleanupStack::PopAndDestroy(); // ws

    }

void CPbkAppUi::HandleCommandL(TInt aCommand)

    {

    switch (aCommand)

        {

        case EAknCmdHelp:

            {

            HlpLauncher::LaunchHelpApplicationL(iEikonEnv->WsSession(),

                AppHelpContextL());

            break;

            }

        case EEikCmdExit:

            {

            // standard exit command

            CmdExitL();

            break;

            }

        case EAknSoftkeyExit:

        case EAknCmdExit:

        case EPbkCmdExit:

            {

            ExitL();

            break;

            }

        default:

            {

            break;

            }

        }

    }

void CPbkAppUi::DynInitMenuPaneL

        (TInt aResourceId,

        CEikMenuPane* aMenuPane)

    {

    switch (aResourceId)

        {

        case R_PHONEBOOK_SYSTEM_MENU:

            {

            if (!FeatureManager::FeatureSupported(KFeatureIdHelp))

                {

                // remove non-supported help from menu

                aMenuPane->SetItemDimmed(EAknCmdHelp, ETrue);

                }

            break;

            }

        default:

            {

            break;

            }

        }

    }

TKeyResponse CPbkAppUi::HandleKeyEventL

        (const TKeyEvent& aKeyEvent,

        TEventCode aType)

    {

    if (PbkProcessKeyEventL(aKeyEvent, aType))

        {

        PBK_DEBUG_PRINT(PBK_DEBUG_STRING("CPbkAppUi::HandleKeyEventL() processed key event"));

        return EKeyWasConsumed;

        }

    return EKeyWasNotConsumed;

    }

void CPbkAppUi::HandleForegroundEventL(TBool aForeground)

    {

    // Call base class

    CAknViewAppUi::HandleForegroundEventL(aForeground);

    }

void CPbkAppUi::HandleResourceChangeL(TInt aType)

    {

    CPbkAppUiBase::HandleResourceChangeL(aType);

    // This is needed to change the application

    // icon when the skin changes (especially if

    // a contact with a thumbnail is currently

    // selected and the app icon is not visible)

    CEikStatusPane* pane = StatusPane();

    if (pane)

        {

        pane->HandleResourceChange(aType);

        }

    // The resource change event has to be forwarded to

    // view navigator

    if(iViewNavigator)

        {

        iViewNavigator->HandleResourceChange(aType);

        }

    }

void CPbkAppUi::HandleWsEventL(const TWsEvent& aEvent, CCoeControl* aDestination)

    {

    switch (aEvent.Type())

        {

        case KAknUidValueEndKeyCloseEvent:

            {

            // Make a real exit on end-key event

            iEndKeyExit = ETrue;

            } // fallthrough

        default:

            {

            CPbkAppUiBase::HandleWsEventL(aEvent, aDestination);

            break;

            }

        }

    }

TBool CPbkAppUi::PbkProcessKeyEventL

        (const TKeyEvent& aKeyEvent, TEventCode aType)

    {

    // Ensure that navigator has already been constructed

    if (iViewNavigator)

        {

        return iViewNavigator->HandleNavigationKeyEventL(aKeyEvent,aType);

        }

    return EFalse;

    }

void CPbkAppUi::CreateViewsL()