/*

* 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 <startupdomainpskeys.h>

#include <AknUtils.h>

#include <AknsWallpaperUtils.h>

#include <AknSkinsInternalCRKeys.h>

#include <StringLoader.h>

#include <xnuiengine.rsg>

#include <aknnotewrappers.h>

#include <AknsConstants.h>

#include <aifwdefs.h>

#include <gfxtranseffect/gfxtranseffect.h>

#include <akntransitionutils.h>

#include <xnuiengine.rsg>

// 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"

#include "xnkeyeventdispatcher.h"

// Constants

_LIT8( KEmptyWidgetUid, "0x2001f47f" );

const TInt KPSCategoryUid( 0x200286E3 );

const TInt KPSCrashCountKey( 1 );     

const TInt KStabilityInterval( 60000000 ); // 1 minute

const TInt KActivationCompleteInterval( 2000000 ); // 2s

const TInt KCrashRestoreDefaultTreshold( 3 );

const TInt KCrashRestoreAllTreshold( 4 );

const TInt KCrashRestoreRomTreshold( 5 );

const TInt KCrashRestoreViewsTreshold( 6 );

// ============================ 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()

    {

    delete iAsyncCb;

    delete iStabilityTimer;

    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 );

    iAsyncCb = CPeriodic::NewL( CActive::EPriorityIdle ); 

    DoRobustnessCheckL();

    }

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

// 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.

    TInt err = iRootData->Load();

    if( err == EXnInvalidConfiguration )

        {

        // Configuration loading failed totally

        Panic( EXnInvalidConfiguration );

        }

    // Show the error note only once, if there are more views

    // the note should be shown from CXnRootData::RunLoadL()

    if( iRootData->PluginData().Count() == 1 )

        {        

        HandleErrorNotes( err );

        }

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

    // Load initial view publishers    

    ActiveViewData().SetActive( ETrue );    

    }

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

// 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() );

    if ( iAsyncCb->IsActive() )

        {

        iAsyncCb->Cancel();

        ContainerActivated( this );

        }

    delete iWidgetAmountTrigger;

    iWidgetAmountTrigger = NULL;

    // Destroy all publishers

    RPointerArray< CXnPluginData >& views( iRootData->PluginData() );

    for ( TInt i = 0; i < views.Count(); i++ )

        {

        CXnViewData* view = static_cast< CXnViewData* >( views[i] );

        view->DestroyPublishers( EAiFwSystemShutdown );        

        }

    // Destroy active view data

    ActiveViewData().Destroy();

    // Schedule application configuration destroyal

    iRootData->Destroy();

    iRootData = NULL;

    User::Heap().Compress();

    iUiReady = EFalse;

    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()

//

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

//

TInt CXnViewManager::LoadWidgetToPluginL( const CHsContentInfo& aContentInfo,

    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 )

            {

            TRAP_IGNORE( ShowErrorL( R_QTN_HS_OPERATION_FAILED_NO_DISK ) );            

            }

        }

    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 )

            {

            TRAP_IGNORE( ShowErrorL( R_QTN_HS_OPERATION_FAILED_NO_DISK ) );            

            }        

        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 );           

            }  

        // Handle the errors

        HandleErrorNotes( retval );        

        CleanupStack::PopAndDestroy(); // DisableRenderUiLC

        }

    return retval;

    }

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

// CXnViewManager::UnloadWidgetFromPluginL()

//

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

//

TInt CXnViewManager::UnloadWidgetFromPluginL( CXnPluginData& aPluginData, 

    TBool aForce )    

    {                  

    if ( !aForce )

        {

        if( !aPluginData.Occupied() )

            {

            // Plugin must have widget when about to remove

            return KErrNotFound;                    

            }

        if ( !aPluginData.Removable() )

            {

            // Not allowed to remove locked

            return KErrArgument;

            }