/*

* 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: 

*       It is the control container for the AI plugins

*

*/

// INCLUDE FILES

#include <bldvariant.hrh> //feature flags

#include <barsread.h>

#include <coecntrl.h>

#include <e32std.h>

#include <bautils.h>

#include <e32property.h>

#include <connect/sbdefs.h> // pub&sub keys and categories for backup and restore

#include <aknappui.h>

#include <AknsDrawUtils.h>

#include <AknsLayeredBackgroundControlContext.h>

#include <layoutmetadata.cdl.h>

#include <AknUtils.h>

#include <data_caging_path_literals.hrh>

#include <centralrepository.h>

#include <AIContainerDomainCRKeys.h>

#include <activeidle2domainpskeys.h>

#include "aicontainer.hrh"

#include "caiplugincontainercontrol.h"

#include "ExtrStandbyScr.h"

const TInt KActOnSendKey = 1;

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

CAIPluginContainerControl* CAIPluginContainerControl::NewL(CCoeControl *aContainer)

    {

    CAIPluginContainerControl* self =

            new (ELeave) CAIPluginContainerControl() ;

    CleanupStack::PushL( self );

    self->ConstructL(aContainer);

    CleanupStack::Pop(self);

    return self;

    }

CAIPluginContainerControl::~CAIPluginContainerControl()

    {

    AknsUtils::DeregisterControlPosition(this);

    delete iBackupObserver;

    iBackupObserver = NULL;

    if(iNotifyHandler)

        {

        iNotifyHandler->StopListening();

        }

    delete iNotifyHandler;

    delete iAIRepository;

    delete iBgContext;

    DestroyPlugins() ;

    iPlugins.ResetAndDestroy();

    iPlugins.Close();

    REComSession::FinalClose() ;

    }

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

// CAIPluginContainerControl::SetDimmed

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

//

void CAIPluginContainerControl::SetDimmed(TBool aDimmed)

    {

    MakeVisible(!aDimmed);

    if (iContentStatusChangedNotification)

        {

        iContentStatusChangedNotification = EFalse;

        CalculateRectPlugins();

        }

    }

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

// CAIPluginContainerControl::CountComponentControls

// Counts the component controls, so it returns one.

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

//

TInt CAIPluginContainerControl::CountComponentControls() const

    {

    TInt pluginsCount = 0;

    for ( TInt index = 0; index < iPlugins.Count(); index++ )

        {

        TPluginInfo* plugin = iPlugins[index];

        if (plugin->iPlugin) pluginsCount++ ;

        }

    return pluginsCount;

    }

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

// CAIPluginContainerControl::ComponentControl

// Returns components by index.

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

//

CCoeControl* CAIPluginContainerControl::ComponentControl(TInt aIndex) const

    {

    if (iPlugins.Count())

        {

        TInt pluginsPos = -1;

        for ( TInt index = 0; index < iPlugins.Count(); index++ )

            {

            TPluginInfo* plugin = iPlugins[index];

            if (plugin->iPlugin) pluginsPos++ ;

            if (pluginsPos == aIndex) return iPlugins[index]->iPlugin;

            }

        }

    return NULL ;

    }

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

// CAIPluginContainerControl::SizeChanged

// Changes the sizes of the components.

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

//

void CAIPluginContainerControl::SizeChanged()

    {

    AknsUtils::RegisterControlPosition(this);

    if(iBgContext)

        {

        iBgContext->SetRect(Rect());

        iBgContext->SetParentPos(PositionRelativeToScreen());

        }

    if (!CountComponentControls())

        {

        return ;

        }

    if ((iPrevRect.IsEmpty() || iPrevRect != Rect()))

        {

        CalculateRectPlugins() ;

        iPrevRect = Rect() ;

        }

    else

        {

//        FocusOnDefaultFocusingPlugin(EDrawNow);

        }

    }

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

// CAIPluginContainerControl::FocusChanged

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

//

void CAIPluginContainerControl::FocusChanged(TDrawNow /*aDrawNow*/)

    {

    if (iCurrentPlugin)

        {

        if (IsFocused())

            {

            TRAP_IGNORE(iCurrentPlugin->iPlugin->PrepareForFocusGainL());

            }

        else

            {

            TRAP_IGNORE(iCurrentPlugin->iPlugin->PrepareForFocusLossL());

            }

        // The flag must be drawnow because

        // the plugin focusing have to be happer/disapper

        iCurrentPlugin->iPlugin->SetFocus(IsFocused(),EDrawNow) ;

        }

    }

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

// CAIPluginContainerControl::Draw

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

//

void CAIPluginContainerControl::Draw( const TRect& /*aRect*/ ) const

    {

     if (IsDimmed())

        {

        return ;

        }

    TRect rect( Rect() );

    CWindowGc& gc = SystemGc();

    MAknsControlContext* cc = AknsDrawUtils::ControlContext( this);

    MAknsSkinInstance* aknsInst = AknsUtils::SkinInstance();

    // Draw background starting from correct offset

    AknsDrawUtils::Background( aknsInst, cc, this, gc, rect );

    }

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

// CAIPluginContainerControl::MopSupplyObject

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

//

TTypeUid::Ptr CAIPluginContainerControl::MopSupplyObject(TTypeUid aId)

    {

    if( aId.iUid == MAknsControlContext::ETypeId )

        {

        return MAknsControlContext::SupplyMopObject( aId, iBgContext );

        }

    return CCoeControl::MopSupplyObject( aId );

    }

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

// CAIPluginContainerControl::OfferKeyEventL

// Processes the key event for the incall view.

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

//

TKeyResponse CAIPluginContainerControl::OfferKeyEventL(

        const TKeyEvent& aKeyEvent,

        TEventCode aType )

    {

    if (iCurrentPlugin)

        {

        if (CountComponentControls() > 1)

            {

            switch( aKeyEvent.iScanCode )

                {

                case EStdKeyUpArrow:

                case EStdKeyDownArrow:

                    {

                    if( aKeyEvent.iCode == EKeyUpArrow )

                        {

                        ChangeFocusPluginL(EAIFocusUp);

                        }

                    else if( aKeyEvent.iCode == EKeyDownArrow )

                        {

                        ChangeFocusPluginL(EAIFocusDown);

                        }

                    return EKeyWasConsumed;

                    }

                }

            }

        if( aKeyEvent.iCode == EKeyPhoneEnd )

            {

            FocusOnDefaultFocusingPlugin(EDrawNow);

            }

        return iCurrentPlugin->iPlugin->OfferKeyEventL(aKeyEvent,aType);

        }

    return EKeyWasNotConsumed;

    }

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

// CAIPluginContainerControl::HandleResourceChange

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

//

void CAIPluginContainerControl::HandleResourceChange( TInt aType )

    {

    switch(aType)

        {

        case KAknsMessageSkinChange:

            {

            iPrevRect.SetSize(TSize(0,0));

            }

            break;

        case KEikDynamicLayoutVariantSwitch:

            {

            TRAP_IGNORE(UpdateBackgroundL());

            SetRect(static_cast<CAknAppUi*>(iEikonEnv->AppUi())->ClientRect());

            }

            break;

         default:

            break;

         }

    CCoeControl::HandleResourceChange( aType );

    }

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

// CAIPluginContainerControl::StartL

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

//

void CAIPluginContainerControl::StartL()

    {

    // Avoid double start calls

    if(!iStarted)

        {

        iStarted = ETrue;

        ReadPluginsConfigurationsL() ;

        LoadPluginsL();

        SizeChanged();

        }

    }

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

// CAIPluginContainerControl::SetFullScreenMode

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

//

void CAIPluginContainerControl::SetFullScreenMode(TBool aFullScreenMode)

    {

    iIsFullScreenMode = aFullScreenMode;

    TRAP_IGNORE(UpdateBackgroundL());

    }

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

// CAIPluginContainerControl::HandleControlEventL

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

//

void CAIPluginContainerControl::HandleControlEventL(CCoeControl* /*aControl*/,TCoeEvent aEventType)

    {

    if ( aEventType == EEventStateChanged )

        {

        if (IsDimmed())

            {

            iContentStatusChangedNotification = ETrue ;

            return ;

            }

        CalculateRectPlugins() ;

        //DrawNow();

        }

    }

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

// CAIPluginContainerControl::HandlePropertyChange

// From PropertyObserver

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

//

void CAIPluginContainerControl::HandlePropertyChange(const TUid& /*aCategory*/,

                                                     const TUint& /*aKey*/,

                                                     const TInt& aValue)

    {

    // see \epoc32\include\connect\sbdefs.h for enum descriptions

    const TUint backupMask( conn::KBURPartTypeMask ^ conn::EBURNormal );

    if( aValue & backupMask ) // any type of backup or restore operation

        {

        // backup or restore started

        // -> unload plugins

        if (CountComponentControls())

            {

            DestroyPlugins();

            DrawNow() ;

            }

        }

    else // aValue == conn::EBURUnset || aValue & conn::EBURNormal

        {

        // backup or restore ended

        // -> load plugin again

        if (CountComponentControls() == 0)

            {

            TRAP_IGNORE(

                    ReadPluginsConfigurationsL();

                    LoadPluginsL()

            );

            CalculateRectPlugins();

            }

        }

    }

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

// CAIPluginContainerControl::HandleNotifyGeneric

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

//

void CAIPluginContainerControl::HandleNotifyGeneric(TUint32 aId)

    {

    if(aId != NCentralRepositoryConstants::KInvalidNotificationId)

        {

        if(aId != KAINumOfOperatorPlugins)

            {

            RProperty::Set( KPSUidAiInformation, KActiveIdleExtHS_LSKLocked, KNullDesC );

            RProperty::Set( KPSUidAiInformation, KActiveIdleExtHS_RSKLocked, KNullDesC );

            DestroyPlugins();

            TRAP_IGNORE(ReadPluginsConfigurationsL(); LoadPluginsL(););            

            CalculateRectPlugins();

            RProperty::Set( KPSUidAiInformation, KActiveIdleExtHS_PluginConfChange, 1 );

            }

        }

    }

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

// CAIPluginContainerControl::ReadPluginsConfigurationsL

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

//

void CAIPluginContainerControl::ReadPluginsConfigurationsL()

    {

    TInt numOfPlugins = 0;

    TInt error(KErrNone);

    error = iAIRepository->Get( KAINumOfOperatorPlugins, numOfPlugins );

    if( error == KErrNone )

        {

        // Reset old array

        iPlugins.ResetAndDestroy();

        // Load operator plug-in UIDs

        TInt uid = 0;

        for(TInt i = 1; i <= numOfPlugins; i++)

            {

            error = iAIRepository->Get( KAINumOfOperatorPlugins+i, uid );

            if( error == KErrNone )

                {

                TPluginInfo* pluginItem = new ( ELeave ) TPluginInfo;

                CleanupStack::PushL( pluginItem );

                // Define values

                ResetToDefault( *pluginItem );

                pluginItem->iPluginId.iUid = TUid::Uid(uid).iUid;

                iPlugins.AppendL( pluginItem );

                CleanupStack::Pop(); // pluginItem

                }

            }

        }

    iIndexDefaultFocusingPlugin = 0;

    }

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

// CAIPluginContainerControl::LoadPluginsL

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

//

void CAIPluginContainerControl::LoadPluginsL()

    {

    // Set send key functionality to default

    RProperty::Set(

            KPSUidAiInformation,

            KActiveIdleActOnSendKey,

            KActOnSendKey );

    for ( TInt index = 0; index < iPlugins.Count() ; index++)

        {

        LoadPluginL(index) ;

        }

    }

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

// CAIPluginContainerControl::LoadPluginL

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

//

void CAIPluginContainerControl::LoadPluginL(TInt aIndex)

    {

    CExtrStandbyScr* currentPlugin = NULL;

    TPluginInfo *pluginItem = iPlugins[aIndex];

    if (pluginItem->iState == EAIPluginOn)

        {

        TRAPD(err, currentPlugin = CExtrStandbyScr::NewL(pluginItem->iPluginId,this)) ;

        if ( err != KErrNone )

            {

            pluginItem->iState = EAIPluginError ;

            }

        else

            {

            if ( err == KErrNone )

                {

                TSize MinSize = currentPlugin->GetMinSize() ;

                TSize MaxSize = currentPlugin->GetMaxSize() ;

                pluginItem->iResizeable = MinSize != MaxSize ;

                currentPlugin->SetObserver(this) ;

                TRAP_IGNORE(currentPlugin->LoadEngineL()) ;

                }

            if ( err != KErrNone )

                {

                delete currentPlugin ;

                pluginItem->iState = EAIPluginError ;

                }

            else

                {

                //currentPlugin->SetDimmed(ETrue) ;

                pluginItem->iPlugin = currentPlugin ;

                pluginItem->iPlugin->ActivateL();

                }

            }

        }

    }

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

// CAIPluginContainerControl::DestroyPluginsL

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

//

void CAIPluginContainerControl::DestroyPlugins()

    {

    TInt index;

    for ( index = 0; index < iPlugins.Count(); index++ )

        {

        TPluginInfo* plugin = iPlugins[index];

        if (plugin->iPlugin)

            {

            delete plugin->iPlugin;

            plugin->iPlugin = NULL;

            }

        }

    iPlugins.ResetAndDestroy();

    iIndexPlugin = -1;

    iCurrentPlugin = NULL ;

    }

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

// CAIPluginContainerControl::ResetToDefault

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

//

void CAIPluginContainerControl::ResetToDefault( TPluginInfo& aPluginInfo )

    {

    aPluginInfo.iPlugin = NULL;