/*

* Copyright (c) 2005-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:  Main AI framework class

*

*/

#include <bautils.h>

#include <coemain.h>

#include <ConeResLoader.h>

#include <e32property.h>

#include <startupdomainpskeys.h>

#include <activeidle2domainpskeys.h>

#include <activeidle2internalpskeys.h>

#include <cenrepnotifyhandler.h>

#include <aipspropertyobserver.h>

#include <aisystemuids.hrh>

#include <AknWaitDialog.h>

#include <AknGlobalNote.h>

#include <StringLoader.h>

#include <e32cmn.h>

#include <e32def.h>

#include "aifw.h"

#include "aifwpanic.h"

#include "aiutility.h"

#include "aiuicontrollermanager.h"

#include "aiuicontroller.h"

#include "aicontentmodel.h"

#include "aicontentpluginmanager.h"

#include "aiwspluginmanager.h"

#include "aipluginstatemanager.h"

#include "aiidleappregister.h"

#include "debug.h"

#include <centralrepository.h>

#include <activeidle2domaincrkeys.h>

#include "ainetworklistener.h"

#include <data_caging_path_literals.hrh>

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

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

// CAiFw::NewL()

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

//

CAiFw::CAiFw()

    {

    }

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

// CAiFw::ConstructL()

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

//

void CAiFw::ConstructL()

    {

#if 0

    // For AI3_test    

    RProcess proc;

    // 0x102750F0 in AI3, 0x2001CB4F in AI3_Test

    TSecureId secId( proc.SecureId() ); 

    if( secId == 0x2001CB4F )

        {

        iAIRepository = CRepository::NewL( TUid::Uid( 0x2001952B ) );

        }   

    else

        {

        iAIRepository = CRepository::NewL( TUid::Uid( KCRUidActiveIdleLV ) );

        }

#else

    iAIRepository = CRepository::NewL( TUid::Uid( KCRUidActiveIdleLV ) );

#endif

    TInt value( 0 );

    iAIRepository->Get( KAiMainUIController, value );

    if( !( value == AI_UID_ECOM_IMPLEMENTATION_UICONTROLLER_XML ||

           value == AI_UID_ECOM_IMPLEMENTATION_UICONTROLLER_NATIVE ||

           value == AI3_UID_ECOM_IMPLEMENTATION_UICONTROLLER_XML ||

           value == AI3_UID_ECOM_IMPLEMENTATION_UICONTROLLER_NATIVE ) )

        {

        // Someone wrote an invalid configuration! Reset repository.

        iAIRepository->Reset( KAiMainUIController );

        iAIRepository->Reset( KAiFirstUIController );

        iAIRepository->Delete( KAiFirstUIController + 1 );

        }

    iUiControllerManager = CAiUiControllerManager::NewL();

    iPluginManager = CAiContentPluginManager::NewL();

    // Hook framework as UI event observer

    iUiControllerManager->SetEventHandler( *this );    

    }

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

// CAiFw::NewLC()

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

//

EXPORT_C CAiFw* CAiFw::NewLC()

    {

    CAiFw* self = new ( ELeave ) CAiFw;

    CleanupStack::PushL( self );

    self->ConstructL();

    __TICK( "FW: Core FW constructed" );

    __HEAP( "FW: Core FW constructed" );

    return self;

    }

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

// CAiFw::~CAiFw()

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

//

CAiFw::~CAiFw()

    {

    if( iPluginManager )

        {

        delete iPluginManager;

        iPluginManager = NULL;

        }

    if( iIdleRestartObserver )

        {

        Release( iIdleRestartObserver );

        iIdleRestartObserver = NULL;

        }

    if( iWsPluginManager )

        {

        delete iWsPluginManager;

        iWsPluginManager = NULL;

        }

    if( iUiControllerManager )

        {

        delete iUiControllerManager;

        iUiControllerManager = NULL;

        }

    if( iNotifyHandler )

        {

        iNotifyHandler->StopListening();

        delete iNotifyHandler;

        iNotifyHandler = NULL;

        }

    if( iNotifyHandlerESS )

        {

        iNotifyHandlerESS->StopListening();

        delete iNotifyHandlerESS;

        iNotifyHandlerESS = NULL;

        }

    if( iAIRepository )

        {

        delete iAIRepository;

        iAIRepository = NULL;

        }

    iLibrary1.Close();

    iLibrary2.Close();

    iLibrary3.Close();

    }

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

// CAiFw::RunL()

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

//

EXPORT_C void CAiFw::RunL()

    {

    CAiIdleAppRegister* idleReg = CAiIdleAppRegister::NewLC();

    idleReg->RegisterL();

    CleanupStack::PopAndDestroy( idleReg );

    // Tell UI controller manager to start application framework and event loop.

    // This function returns only when the application is shut down.

    // See in CAiFw::HandleUiReadyEventL how the framework initialization continues.

    iUiControllerManager->RunApplicationL();

    }

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

// CAiFw::AppEnvReadyL()

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

//

void CAiFw::AppEnvReadyL()

    {

    // Initialize members which need to be connected to the app environment's

    // active scheduler or depend on the app environment being initialized.

    // Create state managers system state observers

    CAiPluginStateManager& stateManager( iPluginManager->StateManager() );

    stateManager.CreateSystemStateObserversL();

    // Connect state managers UI observer to UI controllers

    MAiUiFrameworkObserver* fwObserver( stateManager.UiFwObserver() );

    if ( fwObserver )

        {

        iUiControllerManager->AddObserverL( *fwObserver );

        }

    // Create WS pluign manager

    iWsPluginManager = CAiWsPluginManager::NewL

        ( iUiControllerManager->CoeEnv() );

    // CenRep notifier to listen key changes in cenrep. Application is restarted

    // if key value is changed.

    iNotifyHandler = CCenRepNotifyHandler::NewL( *this,

                                                 *iAIRepository,

                                                 CCenRepNotifyHandler::EIntKey,

                                                 KAiMainUIController );

    iNotifyHandler->StartListeningL();

    // Cenrep notifier to listen ESS changes in cenrep

    //

    iNotifyHandlerESS = CCenRepNotifyHandler::NewL( *this,

                                                    *iAIRepository,

                                                     CCenRepNotifyHandler::EIntKey,

                                                     KAIExternalStatusScreen );

    iNotifyHandlerESS->StartListeningL();

    iIdleRestartObserver = AiUtility::CreatePSPropertyObserverL(

                        TCallBack( HandleRestartEvent, this ),

                        KPSUidAiInformation,

                        KActiveIdleRestartAI2 );

    stateManager.ReportStateChange( ESMAISystemBoot );

    }

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

// CAiFw::HandleUiReadyEventL()

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

//

void CAiFw::HandleUiReadyEventL( CAiUiController& aUiController )

    {         

    if( iUiControllerManager->IsMainUiController( aUiController ) )

        {

        iUiControllerManager->LoadUIDefinition();

        TInt value( EIdlePhase1Ok );

        RProperty::Get( KPSUidStartup, 

                        KPSIdlePhase1Ok, 

                        value );

        if( value == EIdlePhase1NOK )

            {

            RProperty::Set( KPSUidStartup, 

                            KPSIdlePhase1Ok, 

                            EIdlePhase1Ok );                                                          

            }    

        if( !iLibrariesLoaded )

            {

            _LIT( KAIVoiceUIDialer, "VoiceUiNameDialer.dll" );

            _LIT( KAIVoiceUIRecog, "VoiceUiRecognition.dll" );

            _LIT( KAIVCommandHandler, "vcommandhandler.dll" );

            iLibrary1.Load( KAIVoiceUIDialer );

            iLibrary2.Load( KAIVoiceUIRecog );

            iLibrary3.Load( KAIVCommandHandler );        

            iLibrariesLoaded = ETrue;

            }

        }

    }

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

// CAiFw::HandleActivateUI()

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

//

void CAiFw::HandleActivateUI()

    {

    iUiControllerManager->ActivateUI();         

    }

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

// CAiFw::HandleUiShutdown()

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

//

void CAiFw::HandleUiShutdown( CAiUiController& aUiController )

    {

    if( iUiControllerManager->IsMainUiController( aUiController ) )

        {

        if( iNotifyHandler )

            {

            iNotifyHandler->StopListening();

            delete iNotifyHandler;

            iNotifyHandler = NULL;

            }

        if( iNotifyHandlerESS )

            {

            iNotifyHandlerESS->StopListening();

            delete iNotifyHandlerESS;

            iNotifyHandlerESS = NULL;

            }

        iPluginManager->PluginFactory().DestroyPlugins();

        iPluginManager->StateManager().DestroySystemStateObservers();

        iUiControllerManager->DestroySecondaryUiControllers();

        iUiControllerManager->RemoveObserver( 

                *iPluginManager->StateManager().UiFwObserver() );

        if( iWsPluginManager )

            {

            delete iWsPluginManager;

            iWsPluginManager = NULL;

            }

        if( iIdleRestartObserver )

            {

            Release( iIdleRestartObserver );

            iIdleRestartObserver = NULL;

            } 

        }

    }

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

// CAiFw::HandleLoadPluginL()

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

//

void CAiFw::HandleLoadPluginL( const TAiPublisherInfo& aPublisherInfo )

    {           

    iPluginManager->PluginFactory().CreatePluginL( 

       aPublisherInfo, iUiControllerManager->UiControllers() );                                                                                                                                                 

    }

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

// CAiFw::HandleDestroyPluginL()

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

//

void CAiFw::HandleDestroyPluginL( const TAiPublisherInfo& aPublisherInfo )

    {    

    iPluginManager->PluginFactory().DestroyPluginL(

        aPublisherInfo, iUiControllerManager->UiControllers() );                                                                            

    }

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

// CAiFw::HandlePluginEvent()

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

//

void CAiFw::HandlePluginEvent( const TDesC& aParam )

    {

    iPluginManager->HandlePluginEvent( aParam );

    }

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

// CAiFw::HandlePluginEventL()

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

//

void CAiFw::HandlePluginEventL( const TAiPublisherInfo& aPublisherInfo, 

    const TDesC& aParam )

    {

    iPluginManager->HandlePluginEventL( aPublisherInfo, aParam );

    }

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

// CAiFw::HasMenuItemL()

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

//

TBool CAiFw::HasMenuItemL( const TAiPublisherInfo& aPublisherInfo, 

    const TDesC& aMenuItem )

    {            

    return iPluginManager->HasMenuItemL( aPublisherInfo, aMenuItem ); 

    }

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

// CAiFw::RefreshContent()

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

//

TBool CAiFw::RefreshContent( const TDesC& aContentCid )

    {

    return iPluginManager->RefreshContent( aContentCid );

    }

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

// CAiFw::ProcessStateChange()

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

//

void CAiFw::ProcessStateChange( TAifwStates aState )     

    {

    switch ( aState )

    	{

    	case EAifwOnline :

    		{

    		iPluginManager->ProcessOnlineState( ETrue );

    		}

    		break;

    	case EAifwOffline :

			{

			iPluginManager->ProcessOnlineState( EFalse );

			}

			break;

    	case EAifwPageSwitch:

    		{

    		iPluginManager->StateManager().ReportStateChange( ESMAIPageSwitch );

    		}

    		break;

    	default : 

    		break;

    	}

    }

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

// CAiFw::QueryIsMenuOpen()

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

//

TBool CAiFw::QueryIsMenuOpen()

    {

    return iUiControllerManager->MainUiController().IsMenuOpen();

    }

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

// CAiFw::HandleNotifyInt()

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

//

void CAiFw::HandleNotifyInt( TUint32 aId, TInt aNewValue )

    {

    switch( aId )

        {

        case KAiMainUIController:

            if( aNewValue == AI_UID_ECOM_IMPLEMENTATION_UICONTROLLER_XML ||

                aNewValue == AI_UID_ECOM_IMPLEMENTATION_UICONTROLLER_NATIVE ||

                aNewValue == AI3_UID_ECOM_IMPLEMENTATION_UICONTROLLER_XML ||

                aNewValue == AI3_UID_ECOM_IMPLEMENTATION_UICONTROLLER_NATIVE )

                {

                iUiControllerManager->ExitMainController();

                }

            else

                {

                // Someone wrote an invalid configuration! Reset repository.

                if( iAIRepository )

                    {

                    iAIRepository->Reset( KAiMainUIController );

                    iAIRepository->Reset( KAiFirstUIController );

                    iAIRepository->Delete( KAiFirstUIController + 1 );

                    }

                }

            break;

        case KAIExternalStatusScreen:

            if( ( aNewValue & 0x7FFFFFFF ) != 0 )

                {

                TRAP_IGNORE( SwapUiControllerL( EFalse ) );

                }

            else

                {

                TRAP_IGNORE( SwapUiControllerL( ETrue ) );

                }

            break;

        default:

            break;

        }

    }

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

// CAiFw::SwapUiControllerL()

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

//

void CAiFw::SwapUiControllerL( TBool aToExtHS )

    {

    TUid uid = { KCRUidActiveIdleLV };

    CRepository* cenRep = CRepository::NewL( uid );

    if( !aToExtHS ) // Switch to XML UI

        {

        cenRep->Create( KAiFirstUIController, 

                AI_UID_ECOM_IMPLEMENTATION_UICONTROLLER_NATIVE );

        cenRep->Set( KAiFirstUIController, 

                AI_UID_ECOM_IMPLEMENTATION_UICONTROLLER_NATIVE );

        cenRep->Delete( KAiFirstUIController + 1 );

        cenRep->Set( KAiMainUIController, 

                AI_UID_ECOM_IMPLEMENTATION_UICONTROLLER_XML );

        }

    else // Switch to ExtHS

        {

        cenRep->Delete( KAiFirstUIController );

        cenRep->Delete( KAiFirstUIController + 1 );

        cenRep->Set( KAiMainUIController, 

                AI_UID_ECOM_IMPLEMENTATION_UICONTROLLER_NATIVE );

        }

    delete cenRep;

    // Restart

    iUiControllerManager->ExitMainController();

    }

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

// CAiFw::HandleRestartEvent()

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

//

TInt CAiFw::HandleRestartEvent( TAny* aSelf )

    {

    CAiFw* self = static_cast<CAiFw*>( aSelf );

    TInt value( 0 );

    if( self->iIdleRestartObserver )

        {