/*

* Copyright (c) 2005-2007 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:  Native UI controller.

*

*/

// System includes

#include <bautils.h>

#include <e32property.h>

#include <ecom/ecom.h>

#include <ecom/implementationproxy.h>

#include <centralrepository.h>

#include <activeidle2domainpskeys.h>

#include <aipspropertyobserver.h>

#include <eikstart.h>

#include <avkondomainpskeys.h>

#include <AknDlgShut.h> 

// User includes

#include <aifwstatehandler.h>

#include <hscontentpublisher.h>

#include <hspublisherinfo.h>

#include "nativeuicontroller.h"

#include "ainativeui.hrh"

#include "application.h"

#include "appui.h"

#include "aiutility.h"

#include "aistrparser.h"

#include "aidevicestatuscontentmodel.h"

#include "aistatuspanel.h"

#include "ainativerenderer.h"

#include "aititlepanerenderer.h"

#include "ainavipanerenderer.h"

#include "aidialogrenderer.h"

#include "aisoftkeyrenderer.h"

#include "ainotifierrenderer.h"

#include "ainativeuiplugins.h"

#include "activeidle2domaincrkeys.h"

#include "aistatuspanetouchui.h"

#include "ainativeuistrings.h" // string literals

#include "aistrcnv.h"

using namespace AiNativeUiController;

// Constants

_LIT( KResourceDrive, "Z:" );

_LIT( KResourceFile, "ainativeui.rsc" );

_LIT( KSettingsDummyData, "" );

_LIT( KSettingsIdSeparator, "/" );

_LIT( KSettings, "Settings" );

const TInt KOneSecondInMicroS = 1000*1000;

const TInt KAI2CrKeyIncrementBy2 = 2;

#define KResourcePath KDC_APP_RESOURCE_DIR

const TImplementationProxy KImplementationTable[] =

    {

    IMPLEMENTATION_PROXY_ENTRY(KImplementationUidNativeUiController, CNativeUiController::NewL)

    };

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

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

// IsDeviceStatus()

//

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

//

TBool IsDeviceStatus( const THsPublisherInfo& aInfo )

    {

    return ( aInfo.Name() == KDeviceStatusPluginName && 

        aInfo.Uid() == KDeviceStatusPluginUid );

    }

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

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

// CNativeUiController::NewL()

//

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

//

CNativeUiController* CNativeUiController::NewL()

    {

    CNativeUiController* self = new (ELeave) CNativeUiController;

    CleanupStack::PushL( self );

    // Set Native UI Controller object to TLS for access in static

    // CNativeUiController::NewApplication

    User::LeaveIfError( Dll::SetTls( self ) );

    CleanupStack::Pop( self );

    return self;

    }

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

// CNativeUiController::Exit()

//

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

//

void CNativeUiController::Exit()

    {

    if ( iExitTimer )

        {

        iExitTimer->Cancel();

        iExitTimer->Start( 0, KOneSecondInMicroS,                       

           TCallBack( ExitTimerCallBack, this ) );

        }

    }

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

// CNativeUiController::ExitTimerCallBack()

//

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

//

TInt CNativeUiController::ExitTimerCallBack( TAny *aSelf )

    {

    CNativeUiController* self =

        static_cast<CNativeUiController*>( aSelf );

    if ( self )

        {

        self->iExitTimer->Cancel();

        self->PrepareToExit();

        self->iAppUi->Exit();

        }

    return KErrNone;

    }

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

// CNativeUiController::~CNativeUiController()

//

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

//

CNativeUiController::~CNativeUiController()

    {

    iPlugins.Reset();

    delete iExitTimer;

    PrepareToExit();

    // Reset TLS pointer to this set in NewL

    Dll::SetTls( NULL );

    }

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

// CNativeUiController::PrepareToExit()

//

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

//

void CNativeUiController::PrepareToExit()

    {

    iRenderers.ResetAndDestroy();

    delete iStatusPanel;

    iStatusPanel = NULL;

    Release( iIdleStatusObserver );

    iIdleStatusObserver = NULL;

    Release( iKeylockStatusObserver );

    iKeylockStatusObserver = NULL;

    Release( iExtHsPluginConfChange );

	iExtHsPluginConfChange = NULL;

    //If we are not the

    if( !iRunningAsMain && iResourceOffset > 0 )

        {

        iCoeEnv->DeleteResourceFile( iResourceOffset );

        iResourceOffset = KErrNotFound;

        }

    }

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

// CNativeUiController::CNativeUiController()

//

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

//

CNativeUiController::CNativeUiController() 

    : iResourceOffset( KErrNotFound )

    {

    }

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

// CNativeUiController::SetAppUi()

//

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

//

void CNativeUiController::SetAppUi( CAppUi* aAppUi )

    {

    iAppUi = aAppUi;

    }

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

// CNativeUiController::AddRendererL()

//

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

//

void CNativeUiController::AddRendererL( CAiNativeRenderer* aRenderer )

    {

    User::LeaveIfError( iRenderers.Append( aRenderer ) );

    }

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

// CNativeUiController::RemoveRenderer()

//

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

//

TBool CNativeUiController::RemoveRenderer( CAiNativeRenderer *aRenderer, 

    TBool aDelete )

    {

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

        {

        if ( aRenderer == iRenderers[i] )

            {

            if ( aDelete )

                {

                delete aRenderer;

                }

            iRenderers.Remove(i);

            return ETrue;

            }

        }

    return EFalse;

    }

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

// CNativeUiController::DoPublish()

//

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

//

template<class T>

TInt CNativeUiController::DoPublish( CHsContentPublisher& aPlugin,

    TInt aContent, T& aData, TInt aIndex )

    {

    const THsPublisherInfo& info( aPlugin.PublisherInfo() );

    if ( !IsDeviceStatus( info ) && info.Namespace() != KNativeUiNamespace )

        {

        return KErrNotSupported;

        }

    const TInt count( iRenderers.Count() );

    TInt err( KErrNone );

    for( TInt i( 0 ); i < count; i++ )

        {

        err = iRenderers[i]->Publish( aPlugin, aContent, aData, aIndex );

        if( err == KErrNone )

            {

            //data published

            return KErrNone;

            }

        if( err != KErrNotFound )

            {

            return err;

            }

        }

    return err;

    }

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

// CNativeUiController::HandleIdleStateEvent()

//

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

//

TInt CNativeUiController::HandleIdleStateEvent( TAny* aPtr )

    {

    CNativeUiController* self = 

        reinterpret_cast< CNativeUiController* >( aPtr );

    if( self )

        {

        TInt idleState = EPSAiBackground;

        self->iIdleStatusObserver->Get( idleState );

        const TInt count = self->iRenderers.Count();

        if( idleState == EPSAiForeground )

            {

            for( TInt i( 0 ); i < count; i++ )

                {

                TRAP_IGNORE( self->iRenderers[i]->FocusObtainedL() );

                }

            }

        else

            {

            for( TInt j( 0 ); j < count; j++ )

                {

                TRAP_IGNORE( self->iRenderers[j]->FocusLostL() );

                }

            }

        }

    return KErrNone;

    }

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

// CNativeUiController::HandleKeylockStateEvent()

//

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

//

TInt CNativeUiController::HandleKeylockStateEvent( TAny* aPtr )

    {

    CNativeUiController* self = 

        reinterpret_cast< CNativeUiController* >( aPtr );

    if( self )

        {

        TInt keylockState = EKeyguardNotActive;

        self->iKeylockStatusObserver->Get( keylockState );

        const TInt count = self->iRenderers.Count();

        if( keylockState != EKeyguardNotActive )

            {

            TRAP_IGNORE(

                // Run dialog shutter to shut any open dialogs

                AknDialogShutter::ShutDialogsL( 

                    *static_cast< CEikonEnv* >( CCoeEnv::Static() ) ); 

                TKeyEvent key;

                key.iCode = 0;

                key.iModifiers = 0;

                key.iScanCode = EStdKeyNo;

                CCoeEnv::Static()->SimulateKeyEventL( key, EEventKey );

                );

            for( TInt i( 0 ); i < count; i++ )

                {

                TRAP_IGNORE( self->iRenderers[i]->KeylockEnabledL() );

                }

            }

        else

            {

            for( TInt i( 0 ); i < count; i++ )

                {

                TRAP_IGNORE( self->iRenderers[i]->KeylockDisabledL() );

                }

            }

        }

    return KErrNone;

	}

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

// CNativeUiController::HandlePluginConfChange()

//

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

//

TInt CNativeUiController::HandlePluginConfChange( TAny* aPtr )

	{

	CNativeUiController* self = 

        reinterpret_cast< CNativeUiController* >( aPtr );

    TInt value( 0 );

    RProperty::Get( KPSUidAiInformation, 

        KActiveIdleExtHS_PluginConfChange, value );

    if( self && value )

        {

        self->iAppUi->ExtHSThemeChanged();

        }

    return KErrNone;

	}

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

// CNativeUiController::LoadUIDefinitionL()

//

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

//

void CNativeUiController::LoadUIDefinitionL()

    {

    if ( iUiLoaded )

        {

        TInt count( iRenderers.Count() );

        for( TInt i( 0 ); i < count; i++ )

            {

            iRenderers[i]->LoadUIDefinitionL();

            }

        return;

        }

    if ( !iExitTimer )

        {

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

        }

    // This method is called upon startup. We'll need to:

    iRenderers.ResetAndDestroy();

    if( !iStatusPanel )

        {

        // 2) Initialize status pane for publishing in general

        iStatusPanel = CAiStatusPanel::NewL();

        }

    // 3) Create renderers that handle publishing to title pane...

    AddRendererL( CAiTitlePaneRenderer::NewLC( *iStatusPanel ) );

    CleanupStack::Pop();//CAiTitlePaneRenderer

    // ...navi pane...

    AddRendererL( CAiNaviPaneRenderer::NewLC( *iStatusPanel ) );

    CleanupStack::Pop();//CAiNaviPaneRenderer

    // ...dialogs and.

    AddRendererL( CAiDialogRenderer::NewLC() );

    CleanupStack::Pop();//CAiDialogRenderer

    AddRendererL( CAiNotifierRenderer::NewLC() );

    CleanupStack::Pop();//CAiNotifierRenderer

    // ...touch ui.

    AddRendererL( CAiStatusPaneTouchUi::NewLC( *iStatusPanel, *iFwEventHandler ) );

    CleanupStack::Pop();//CAiStatusPaneTouchUi

    if( iRunningAsMain )

        {

        AddRendererL( CAiSoftKeyRenderer::NewLC() );

        CleanupStack::Pop();//CAiSoftKeyRenderer

        // Toolbar shown only when we are not the main ui controller

        //DeleteToolbarRenderer();

        THsPublisherInfo deviceStatus( KDeviceStatusPluginUid, 

            KDeviceStatusPluginName, KNativeUiNamespace );

        iPlugins.Append( deviceStatus );

        iFwStateHandler->LoadPlugin( deviceStatus, EAiFwSystemStartup );

        THsPublisherInfo profile( KProfilePluginUid, 

            KProfilePluginName, KNativeUiNamespace );

        iPlugins.Append( profile );

        iFwStateHandler->LoadPlugin( profile, EAiFwSystemStartup );

	    TRAP_IGNORE( iAppUi->StartL() );	        

        }

    // We need to load the resource file here if we are not main controller.

    // If we are the main controller the loading is done in appui

    // Also the toolbar renderer is loaded here.

    else

        {

        //Load resources file for resource publishing

        TFullName resourceFile( KResourceDrive );

        resourceFile.Append( KResourcePath );

        resourceFile.Append( KResourceFile );

        BaflUtils::NearestLanguageFile( CCoeEnv::Static()->FsSession(), resourceFile );

        if( iCoeEnv && iResourceOffset == KErrNotFound )

            {

            iResourceOffset = iCoeEnv->AddResourceFileL( resourceFile );

            }

        // Create the toolbar renderer

        //RecreateToolbarRendererL();

        }

    // 4) Add an observer that informs us about the focus transition changes

    if( !iIdleStatusObserver )

        {

        iIdleStatusObserver = AiUtility::CreatePSPropertyObserverL(

                                    TCallBack( HandleIdleStateEvent, this ),

                                    KPSUidAiInformation,

                                    KActiveIdleState );

        }

    if( !iKeylockStatusObserver )

        {

        iKeylockStatusObserver = AiUtility::CreatePSPropertyObserverL(

                                    TCallBack( HandleKeylockStateEvent, this ),

                                    KPSUidAvkonDomain,

                                    KAknKeyguardStatus );

        }

	if( !iExtHsPluginConfChange )

		{

		iExtHsPluginConfChange = AiUtility::CreatePSPropertyObserverL( 

		                            TCallBack( HandlePluginConfChange, this ),

       		                    	KPSUidAiInformation, 

       		                    	KActiveIdleExtHS_PluginConfChange );

		}

    iUiLoaded = ETrue;

    }

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

// CNativeUiController::GetSettingsL()

//

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

//

void CNativeUiController::GetSettingsL( const THsPublisherInfo& aPublisherInfo,

    RAiSettingsItemArray& aSettings )

    {

    if ( aPublisherInfo.Namespace() != KNativeUiNamespace )

        {

        return;

        }

    if( iRunningAsMain && aPublisherInfo.Uid() == KShortcutPluginUid )