/*
* 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:  UI controller manager class
*
*/


#include "aiuicontrollermanager.h"
#include "aiuicontroller.h"
#include "aicontentpublisher.h"
#include "aicontentobserver.h"
#include "activeidle2domaincrkeys.h"
#include "aifwpanic.h"
#include <ecom/ecom.h>
#include <ecom/implementationinformation.h>
#include <centralrepository.h>

#include <aisystemuids.hrh>

#include "debug.h"

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

// ----------------------------------------------------------------------------
// CAiUiControllerManager::CAiUiControllerManager()
// ----------------------------------------------------------------------------
//
CAiUiControllerManager::CAiUiControllerManager()
    {
    }

// ----------------------------------------------------------------------------
// CAiUiControllerManager::LoadMainControllerL()
// ----------------------------------------------------------------------------
//
void CAiUiControllerManager::LoadMainControllerL(
    CRepository& aCenRepConfig )
    {
    TInt value( 0 );
    
    // Main UI Controller must be configured correctly
    User::LeaveIfError( aCenRepConfig.Get( KAiMainUIController, value ) );
    
    CAiUiController* controller = CAiUiController::NewL( TUid::Uid( value ) );
    
    iCreatedUICList.Append( value );
    CleanupStack::PushL( controller );
    
    iMainUiController = controller->MainInterface();
    
    // Main UI controller must be configured correctly
    if( !iMainUiController )
        {
        __PRINT( __DBG_FORMAT("Main UI controller interface not found from controller 0x%x"), value );
        User::Leave( KErrNotFound );
        }
    
    iUiControllerArray.AppendL( controller );
    CleanupStack::Pop( controller );
    
    // Register this as a UI framework observer of the main UI controller
    iMainUiController->SetUiFrameworkObserver( *this );
    }

// ----------------------------------------------------------------------------
// CAiUiControllerManager::LoadSecondaryControllersL()
// ----------------------------------------------------------------------------
//
void CAiUiControllerManager::LoadSecondaryControllersL(
    CRepository& aCenRepConfig )
    {
    TInt value( 0 );
    
    // Instantiate rest of the UI controllers.
    for( TInt key = KAiFirstUIController; 
         key <= KAiLastUIController && aCenRepConfig.Get( key, value ) == KErrNone;
        ++key )
        {
        // skip empty entries
        if( value == 0 )
            {
            continue;
            }
        
        if( iCreatedUICList.Find( value ) != KErrNotFound )
            {
            continue;
            }
        
        iCreatedUICList.Append( value );
        
        CAiUiController* controller = 
            CAiUiController::NewL( TUid::Uid( value ) );
        
        CleanupStack::PushL( controller );
        
        iUiControllerArray.AppendL( controller );
        CleanupStack::Pop( controller );
        
        // Get the secondary interface
        MAiSecondaryUiController* secController( 
                    controller->SecondaryInterface() ); 
                        
        if( secController )
            {
            MAiUiFrameworkObserver* uiFwObserver(
                    secController->UiFrameworkObserver() );
        
            if( uiFwObserver )
                {
                // Add secondary controller as UI framework event observer. 
                User::LeaveIfError( 
                        iUiFrameworkObservers.InsertInAddressOrder( uiFwObserver ) );
                }
            }
        }
    }

// ----------------------------------------------------------------------------
// CAiUiControllerManager::ConstructL()
// ----------------------------------------------------------------------------
//
void CAiUiControllerManager::ConstructL()
    {
    __HEAP("FW: Init - Create UI Ctrls");
    __TIME_MARK(t);

    CRepository* cenRep( NULL );

#if 0
    // For AI3_test    
    RProcess proc;
    // 0x102750F0 in AI3, 0x2001CB4F in AI3_Test
    TSecureId secId( proc.SecureId() ); 
                                           
    if( secId == 0x2001CB4F )
        {
        cenRep = CRepository::NewL( TUid::Uid( 0x2001952B ) );
        }   
    else
        {
        cenRep = CRepository::NewL( TUid::Uid( KCRUidActiveIdleLV ) );
        }
#else
    cenRep = CRepository::NewLC( TUid::Uid( KCRUidActiveIdleLV ) );
#endif

    LoadMainControllerL( *cenRep );
    
    // Failing on secondary is not fatal. Ignore leaves.
    TRAP_IGNORE( LoadSecondaryControllersL( *cenRep ) );
                       
    CleanupStack::PopAndDestroy( cenRep );
    
    __TIME_ENDMARK("FW: Create UI Ctrls", t);
    __HEAP("FW: Done - Create UI Ctrls");
    }

// ----------------------------------------------------------------------------
// CAiUiControllerManager::NewL()
// ----------------------------------------------------------------------------
//
CAiUiControllerManager* CAiUiControllerManager::NewL()
    {
    CAiUiControllerManager* self = new (ELeave) CAiUiControllerManager;
    
    CleanupStack::PushL( self );
    self->ConstructL();
    CleanupStack::Pop( self ); // self
    
    return self;
    }

// ----------------------------------------------------------------------------
// CAiUiControllerManager::~CAiUiControllerManager()
// ----------------------------------------------------------------------------
//
CAiUiControllerManager::~CAiUiControllerManager()
    {
    iUiControllerArray.ResetAndDestroy();
    
    iUiFrameworkObservers.Reset();
    
    iCreatedUICList.Reset();
    }

// ----------------------------------------------------------------------------
// CAiUiControllerManager::UiControllers() 
// ----------------------------------------------------------------------------
//
RPointerArray< CAiUiController >& CAiUiControllerManager::UiControllers() const
    {
    return iUiControllerArray;
    }

// ----------------------------------------------------------------------------
// CAiUiControllerManager::IsMainUiController()
// ----------------------------------------------------------------------------
//
TBool CAiUiControllerManager::IsMainUiController(
    CAiUiController& aUiController ) const
    {
    return ( aUiController.MainInterface() == iMainUiController );
    }

// ----------------------------------------------------------------------------
// CAiUiControllerManager::SetEventHandler()
// ----------------------------------------------------------------------------
//
void CAiUiControllerManager::SetEventHandler(
    MAiFwEventHandler& aEventHandler )
    {
    for ( TInt i = 0; i < iUiControllerArray.Count(); i++ )
        {
        iUiControllerArray[i]->SetEventHandler( aEventHandler );
        }
    }

// ----------------------------------------------------------------------------
// CAiUiControllerManager::RunApplicationL()
// ----------------------------------------------------------------------------
//
void CAiUiControllerManager::RunApplicationL()
    {
    iMainUiController->RunApplicationL();
    }

// ----------------------------------------------------------------------------
// CAiUiControllerManager::ActivateUI()
// ----------------------------------------------------------------------------
//
void CAiUiControllerManager::ActivateUI()
    {
    for( TInt i = 0; i < iUiControllerArray.Count(); i++ )
        {
        iUiControllerArray[i]->ActivateUI();
        }
    }
    
// ----------------------------------------------------------------------------
// CAiUiControllerManager::LoadUIDefinition()
// ----------------------------------------------------------------------------
//
void CAiUiControllerManager::LoadUIDefinition()
    {       
    for( TInt i = 0; i < iUiControllerArray.Count(); i++ )
        {
        CAiUiController* uiCtl( iUiControllerArray[i] );
        
        MAiSecondaryUiController* secIntr( uiCtl->SecondaryInterface() );
        
        if( secIntr )
            {
            secIntr->SetCoeEnv( CoeEnv() );
            }
        
        TRAPD( err, uiCtl->LoadUIDefinitionL() );
        
        if( err != KErrNone )            
            {
            if( IsMainUiController( *uiCtl ) )
                {
                // Main ui controller failing is fatal
                _LIT(KAIFWStartupFailed, "FW startup failed.");
                
                User::Panic( KAIFWStartupFailed, 0 );                
                }
            else
                {
                // Secondary UI controller failed, delete it
                delete uiCtl;
                uiCtl = NULL;
                
                iUiControllerArray.Remove( i );               
                }
            }
        }
    }

// ----------------------------------------------------------------------------
// CAiUiControllerManager::CoeEnv()
// ----------------------------------------------------------------------------
//
CCoeEnv& CAiUiControllerManager::CoeEnv() const
    {
    return iMainUiController->CoeEnv();
    }

// ----------------------------------------------------------------------------
// CAiUiControllerManager::MainUiController()
// ----------------------------------------------------------------------------
//
MAiMainUiController& CAiUiControllerManager::MainUiController() const
    {
    return *iMainUiController;
    }

// ----------------------------------------------------------------------------
// CAiUiControllerManager::DestroySecondaryUiControllers()
// ----------------------------------------------------------------------------
//
void CAiUiControllerManager::DestroySecondaryUiControllers()
    {
    for( TInt i = iUiControllerArray.Count() - 1; i >= 0; --i )
        {
        CAiUiController* uiController = iUiControllerArray[i];
        
        if( !IsMainUiController( *uiController ) )
            {
            delete uiController;
            uiController = NULL;
            
            iUiControllerArray.Remove(i);
            }
        }
    }

// ----------------------------------------------------------------------------
// CAiUiControllerManager::ExitMainController()
// ----------------------------------------------------------------------------
//
void CAiUiControllerManager::ExitMainController()
    {
    iMainUiController->Exit();
    }

// ----------------------------------------------------------------------------
// CAiUiControllerManager::AddObserverL()
// ----------------------------------------------------------------------------
//
void CAiUiControllerManager::AddObserverL( 
    MAiUiFrameworkObserver& aUiFwObserver )
    {
    User::LeaveIfError( 
            iUiFrameworkObservers.InsertInAddressOrder( &aUiFwObserver ) );
    }

// ----------------------------------------------------------------------------
// CAiUiControllerManager::RemoveObserver()
// ----------------------------------------------------------------------------
//
void CAiUiControllerManager::RemoveObserver( 
    MAiUiFrameworkObserver& aUiFwObserver )
    {
    TInt index( iUiFrameworkObservers.FindInAddressOrder( &aUiFwObserver ) );
    
    if( index != KErrNotFound )
        {
        iUiFrameworkObservers.Remove( index );
        }
    }

// ----------------------------------------------------------------------------
// CAiUiControllerManager::RemovePluginFromUI()
// ----------------------------------------------------------------------------
//
void CAiUiControllerManager::RemovePluginFromUI( CAiContentPublisher& aPlugin )
    {
    // Get MAiPropertyExtension from plugin
    MAiPropertyExtension* plugin =
        static_cast< MAiPropertyExtension* >( 
                aPlugin.Extension( KExtensionUidProperty ) );
    
    // Inform all UI controller that this plugin need to be removed from UI.
    if( plugin )
        {
        for ( TInt i = 0; i < iUiControllerArray.Count(); i++ )
            {
            iUiControllerArray[i]->RemovePluginFromUI( *plugin );
            }
        }
    }

// ----------------------------------------------------------------------------
// CAiUiControllerManager::HandleResourceChange()
// ----------------------------------------------------------------------------
//
void CAiUiControllerManager::HandleResourceChange( TInt aType )
    {
    for( TInt i = 0; i < iUiFrameworkObservers.Count(); i++ )
        {
        iUiFrameworkObservers[i]->HandleResourceChange( aType );
        }
    }

// ----------------------------------------------------------------------------
// CAiUiControllerManager::HandleForegroundEvent()
// ----------------------------------------------------------------------------
//
void CAiUiControllerManager::HandleForegroundEvent( TBool aForeground )
    {
    for( TInt i = 0; i < iUiFrameworkObservers.Count(); i++ )
        {
        iUiFrameworkObservers[i]->HandleForegroundEvent( aForeground );
        }
    }
    
// End of file