/*

* Copyright (c) 2008 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:  View Manager

*

*/

// System includes

#include <AknUtils.h>

#include <AknsWallpaperUtils.h>

#include <AknSkinsInternalCRKeys.h>

#include <StringLoader.h>

#include <xnuiengine.rsg>

#include <aknnotewrappers.h>

#include <AknsConstants.h>

// User includes

#include "xnapplication.h"

#include "xnuiengine.h"

#include "xnproperty.h"

#include "xndomnode.h"

#include "xndomlist.h"

#include "xnnode.h"

#include "xncomposer.h"

#include "xneditor.h"

#include "xnrootdata.h"

#include "xnviewdata.h"

#include "xnappuiadapter.h"

#include "xncontroladapter.h"

#include "xnviewnodeimpl.h"

#include "xnviewadapter.h"

#include "xnodt.h"

#include "xndomdocument.h"

#include "xntype.h"

#include "xntext.h"

#include "xnpanic.h"

#include "xnmenu.h"

#include "xnmenuadapter.h"

#include "xncomponentnodeimpl.h"

#include "xnnodepluginif.h"

#include "xnoomsyshandler.h"

#include "xnbackgroundmanager.h"

#include "xneffectmanager.h"

// Constants

_LIT8( KEmptyWidgetUid, "0x2001f47f" );

_LIT8( KTemplateViewUID, "0x20026f50" );

const TInt KPSCategoryUid = 0x200286E3;

const TInt KPSCrashCountKey = 1;     

const TInt KStabilityInterval = 60000000; // 1 minute

const TInt KCrashRestoreThreshold = 3;

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

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

// BuildTriggerL

// Builds a trigger node

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

//

static CXnNode* BuildTriggerL( CXnUiEngine& aUiEngine,

    const TDesC8& aStringValue )

    {

    CXnNode* node = CXnNode::NewL();

    CleanupStack::PushL( node );

    CXnType* type = CXnType::NewL( XnPropertyNames::action::KTrigger );

    CleanupStack::PushL( type );

    CXnNodeImpl* impl = CXnNodeImpl::NewL( type );

    CleanupStack::Pop( type );

    node->SetImpl( impl );

    node->SetUiEngine( aUiEngine );

    CXnDomStringPool* sp( aUiEngine.ODT()->DomDocument().StringPool() );

    CXnProperty* name = CXnProperty::NewL(

        XnPropertyNames::action::trigger::KName, aStringValue,

        CXnDomPropertyValue::EString, *sp );

    CleanupStack::PushL( name );

    node->SetPropertyL( name );

    CleanupStack::Pop( name );

    CXnProperty* value = CXnProperty::NewL(

        XnPropertyNames::action::KValue,

        KNullDesC8, CXnDomPropertyValue::EString, *sp );

    CleanupStack::PushL( value );

    node->SetPropertyL( value );

    CleanupStack::Pop( value );

    CleanupStack::Pop( node ); 

    return node;

    }

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

// resolveIconId

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

//

static TAknsItemID ResolveIconId( TInt aIndex )

    {

    TAknsItemID ret( KAknsIIDNone );

    switch( aIndex )

        {

        case 0:

            {

            ret = KAknsIIDQgnHomePage11;

            }

            break;

        case 1:

            {

            ret = KAknsIIDQgnHomePage21;

            }

            break;

        case 2:

            {

            ret = KAknsIIDQgnHomePage22;

            }

            break;

        case 3:

            {

            ret = KAknsIIDQgnHomePage31;

            }

            break;

        case 4:

            {

            ret = KAknsIIDQgnHomePage32;

            }     

            break;

        case 5:

            {

            ret = KAknsIIDQgnHomePage33;

            }    

            break;

        case 6:

            {

            ret = KAknsIIDQgnHomePage41;

            }

            break;

        case 7:

            {

            ret = KAknsIIDQgnHomePage42;

            }   

            break;

        case 8:

            {

            ret = KAknsIIDQgnHomePage43;

            }   

            break;

        case 9:

            {

            ret = KAknsIIDQgnHomePage44;

            }     

            break;

        case 10:

            {

            ret = KAknsIIDQgnHomePage51;

            }     

            break;

        case 11:

            {

            ret = KAknsIIDQgnHomePage52;

            }     

            break;

        case 12:

            {

            ret = KAknsIIDQgnHomePage53;

            } 

            break;

        case 13:

            {

            ret = KAknsIIDQgnHomePage54;

            }     

            break;

        case 14:

            {

            ret = KAknsIIDQgnHomePage55;

            }

            break;

        case 15:

            {

            ret = KAknsIIDQgnHomePage61;

            }    

            break;

        case 16:

            {

            ret = KAknsIIDQgnHomePage62;

            }   

            break;

        case 17:

            {

            ret = KAknsIIDQgnHomePage63;

            }    

            break;

        case 18:

            {

            ret = KAknsIIDQgnHomePage64;

            }

            break;

        case 19:

            {

            ret = KAknsIIDQgnHomePage65;

            }

            break;            

        case 20:

            {

            ret = KAknsIIDQgnHomePage66;

            }            

            break;            

        default:

            {

            }

            break;

        }

    return ret;

    }

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

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

// CXnViewManager::NewL()

// Two-phased constructor.

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

//

CXnViewManager* CXnViewManager::NewL( CXnAppUiAdapter& aAdapter )    

    {

    CXnViewManager* self = CXnViewManager::NewLC( aAdapter );

    CleanupStack::Pop( self );

    return self;

    }

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

// CXnViewManager::NewLC()

// Two-phased constructor.

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

//

CXnViewManager* CXnViewManager::NewLC( CXnAppUiAdapter& aAdapter )

    {

    CXnViewManager* self = new( ELeave ) CXnViewManager( aAdapter );

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

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

// CXnViewManager::CXnViewManager()

// C++ default constructor

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

//

CXnViewManager::CXnViewManager( CXnAppUiAdapter& aAdapter ) 

    : iAppUiAdapter( aAdapter ), 

      iApplicationUid( iAppUiAdapter.Application()->AppDllUid() )

    {

    }

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

// CXnViewManager::~CXnViewManager()

// C++ default destructor.

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

//

CXnViewManager::~CXnViewManager()

    {

    if( iStabilityTimer )

        {

        iStabilityTimer->Cancel();

        delete iStabilityTimer;

        iStabilityTimer = NULL;

        }

    iObservers.Reset();

    delete iRootData;

    delete iWidgetAmountTrigger;       

    if ( iResources )

        {

        iResources->Reset();

        }

    delete iResources;

    iControls.Reset();

    iAppearanceNodes.Reset();

    delete iComposer;

    delete iEditor;

    delete iOomSysHandler;

    }

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

// CXnViewManager::ConstructL()

// 2nd phase constructor

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

//

void CXnViewManager::ConstructL()

    iOomSysHandler = CXnOomSysHandler::NewL();

    // Create resource list

    iResources = new ( ELeave ) CArrayPtrSeg< CXnResource > ( 16 );

    const TInt KMaxUidLength( 10 );

    _LIT8( KUint, "%u" );

    TBuf8< KMaxUidLength > uid;

    uid.Format( KUint, iApplicationUid.iUid );

    iEditor = CXnEditor::NewL( *this, uid );

    iHspsWrapper = &iEditor->HspsWrapper();

    iComposer = CXnComposer::NewL( *iHspsWrapper );

    // Robustness checks.

    TInt crashCount = 0;

    RProperty::Get( TUid::Uid( KPSCategoryUid ),

                    KPSCrashCountKey,

                    crashCount );    

    if( crashCount >= KCrashRestoreThreshold )

        {

        iHspsWrapper->RestoreRootL();

        ResetCrashCount();        

        ShowErrorNoteL( R_QTN_HS_ERROR_WIDGETS_REMOVED );        

        }

    else if( crashCount > 0 )

        {

        // Start stability timer to ensure that

        // if system is stabile at least KStabilityInterval

        // then crash count is reset to 0. 

        iStabilityTimer = CPeriodic::NewL( CActive::EPriorityStandard );

        iStabilityTimer->Start( KStabilityInterval,

                                KStabilityInterval,

                                TCallBack( SystemStabileTimerCallback, this ) );

        }

    }

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

// CXnViewManager::LoadUiL()

// Loads the application UI and initial view

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

//

void CXnViewManager::LoadUiL()

    {

    iUiEngine->DisableRenderUiLC();

    // Load application root configuration

    iRootData = CXnRootData::NewL( *this, iApplicationUid );

    // Load root configuration and initial view.

    iRootData->Load();

    CleanupStack::PopAndDestroy(); // DisableRenderUiLC();

    }

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

// CXnViewManager::ReloadUiL()

// Reloads the application UI and initial ivew

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

void CXnViewManager::ReloadUiL()  

    {

#ifdef _XN_PERFORMANCE_TEST_

    RDebug::Print( _L( "CXnViewManager::ReloadUiL() - start" ) );

#endif //_XN_PERFORMANCE_TEST_

    NotifyViewDeactivatedL( ActiveViewData() );

    delete iWidgetAmountTrigger;

    iWidgetAmountTrigger = NULL;

    // Destroy active view data

    ActiveViewData().Destroy();

    // Schedule application configuration destroyal

    iRootData->Destroy();

    iRootData = NULL;

    User::Heap().Compress();

    LoadUiL();

    // Activate first view from the new configuration

    iAppUiAdapter.ViewAdapter().ActivateContainerL( ActiveViewData() );    

#ifdef _XN_PERFORMANCE_TEST_

    RDebug::Print( _L( "CXnViewManager::ReloadUiL() - end" ) );

#endif //_XN_PERFORMANCE_TEST_

    }

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

// CXnViewManager::LoadWidgetToPluginL()

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

//

    CXnPluginData& aPluginData )

    {

    // Plugin must not have widget when about to add

    if ( aPluginData.Occupied() )

        {

        return KErrAlreadyExists;

        }

    CXnViewData& viewData( 

        static_cast< CXnViewData& >( *aPluginData.Parent() ) );

    TBool emptyInUse( viewData.UseEmptyWidget() );

    // By default widget is added to active view configuration

    const TDesC8& configurationId( viewData.ConfigurationId() );

    TInt retval( KErrGeneral );

    if ( emptyInUse && aPluginData.Empty() )

        {

        retval = iHspsWrapper->ReplacePluginL( 

            aPluginData.PluginId(), aContentInfo.Uid() );   

        if( retval == KErrDiskFull )

            {

            ShowDiskFullMessageL();

            }

        }

    else

        {

        TInt index( viewData.PluginData().Find( &aPluginData ) );

        CAddPluginResult* result = iHspsWrapper->AddPluginL( 

            configurationId, aContentInfo.Uid(), index );

        CleanupStack::PushL( result );

        retval = result->Status();        

        if ( retval == KErrNone )

            {

            aPluginData.SetPluginIdL( result->PluginId() );

            }

        else if( retval == KErrDiskFull )

            {

            ShowDiskFullMessageL();

            }        

        CleanupStack::PopAndDestroy( result ); 

        }

    if ( retval == KErrNone )

        {              

        iUiEngine->DisableRenderUiLC();

        NotifyConfigureWidgetL( aContentInfo, aPluginData );

        retval = aPluginData.Load();

        if ( retval == KErrNone )

            {

            UpdateCachesL();

            NotifyWidgetAdditionL( aPluginData );

            // Report widget amount in the view

            ReportWidgetAmountL( viewData );           

            }  

        else if ( retval == KErrNoMemory )

            {

            aPluginData.ShowOutOfMemError();

            }

        else if ( retval == KXnErrPluginFailure )

            {            

            aPluginData.ShowContentRemovedError();

            }