/*

* 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:  XML UI Controller main class

*

*/

// System includes

#include <ecom/implementationproxy.h>

#include <AknQueryDialog.h>

#include <eikstart.h>

#include <apgtask.h>

#include <centralrepository.h>

#include <e32property.h>

// User includes

#include <activeidle2domainpskeys.h>

#include <activeidle2domaincrkeys.h>

#include <hscontentpublisher.h>

#include <hspublisherinfo.h>

#include <aisystemuids.hrh>

#include <ai3xmlui.rsg>

#include "xmluicontroller.h"

#include "xnuiengineappif.h"

#include "xnnodeappif.h"

#include "xnproperty.h"

#include "xntype.h"

#include "aistrcnv.h"

#include "application.h"

#include "appui.h"

#include "xmlnodeidgenerator.h"

#include "aixuikoneventhandler.h"

#include "aixmluiutils.h"

#include "aiutility.h"

#include "aipluginsettings.h"

#include "aixmluiconstants.h"

#include "aifweventhandler.h"

#include "debug.h"

#include "aiconsts.h"

#include "contentrenderer.h"

#include "xmluicontrollerpanic.h"

#include "contentpublisher.h"

#include "xnplugindefs.h"

#include "ainativeuiplugins.h"

// Constants

const TInt KOneSecondInMicroS = 1000*1000;

using namespace AiXmlUiController;

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

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

// ResolveEventParameters()

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

//

static void ResolveEventParameters( const TDesC8& aEventString, 

    TPtrC8& aParam1, TPtrC8& aParam2 )

    {

    TInt  paramPos( aEventString.Locate( KEventParameterSeparator ) );

    TLex8 lex( aEventString.Mid( ++paramPos ) );

    aParam1.Set( lex.NextToken() );   // first ui element id

    TInt commaPos( aParam1.LocateReverse( KComma ) );

    if( commaPos != KErrNotFound )

        {

        // Strip comma

        aParam1.Set( aParam1.Left( commaPos ) );

        aParam2.Set( lex.NextToken() );   // second ui element id

        TInt rightParenthesis( aParam2.LocateReverse( KRightParenthesis ) );

        if( rightParenthesis != KErrNotFound )

            {

            aParam2.Set( aParam2.Left( rightParenthesis ) );

            }        

        }

    else

        {

        // Strip right parenthesis

        aParam1.Set( aParam1.Left( aParam1.Length() -1 ) );

        }

    }

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

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

// CXmlUiController::CXmlUiController()

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

//

CXmlUiController::CXmlUiController()

    {

    }

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

// CXmlUiController::ConstructL()

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

//

void CXmlUiController::ConstructL()

    {       

    iNodeIdGenerator = CXmlNodeIdGenerator::NewL();  

    iAISettingsRepository = 

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

    // Indicate to wserv plugin if it launches logs on send key or not              

    RProperty::Set( KPSUidAiInformation, KActiveIdleActOnSendKey, ETrue );                     

    }

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

// CXmlUiController::NewL()

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

//

CXmlUiController* CXmlUiController::NewL()

    {

    CXmlUiController* self = new ( ELeave ) CXmlUiController;

    CleanupStack::PushL( self );

    self->ConstructL();

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

    // CXmlUiController::NewApplication

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

    CleanupStack::Pop( self ); 

    return self;

    }

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

// CXmlUiController::~CXmlUiController()

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

//

CXmlUiController::~CXmlUiController()

    {

    delete iNodeIdGenerator;

    delete iExitTimer;

    delete iAISettingsRepository;

    delete iCPSpublisher;

    // Reset TLS pointer to this set in NewL

    Dll::SetTls( NULL );

    }

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

// CXmlUiController::Exit()

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

//

void CXmlUiController::Exit()

    {

    if( iExitTimer )

        {

        iExitTimer->Cancel();

        iExitTimer->Start( 0, KOneSecondInMicroS,           

           TCallBack( ExitTimerCallBack, this ) );

        }

    }

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

// CXmlUiController::ExitTimerCallBack()

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

//

TInt CXmlUiController::ExitTimerCallBack(TAny *aSelf)

    {

     CXmlUiController* self =

         static_cast< CXmlUiController* >( aSelf );

    if( self )

        {

        self->iExitTimer->Cancel();

        self->iAppUi->Exit();        

        }

    return KErrNone;

    }

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

// CXmlUiController::SetObserver()

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

//

void CXmlUiController::SetObserver( MAiContentObserver& aObserver )

    {

    iObserver = &aObserver;

    }

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

// CXmlUiController::SetAppUi()

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

//

void CXmlUiController::SetAppUi( CAppUi& aAppUi )

    {

    iAppUi = &aAppUi;

    }

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

// CXmlUiController::AppUi()

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

//

CAppUi* CXmlUiController::AppUi() const

    {

    return iAppUi;

    }

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

// CXmlUiController::UiEngineL()

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

//

TXnUiEngineAppIf* CXmlUiController::UiEngineL() const

    {

    return iAppUi ? iAppUi->UiEngineL() : NULL;

    }

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

// CXmlUiController::SettingsRepository()

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

//

CRepository& CXmlUiController::SettingsRepository() const

    {

    return *iAISettingsRepository;

    }

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

// CXmlUiController::CreateXuikonEventHandlerL()

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

//

CAIXuikonEventHandler* CXmlUiController::CreateXuikonEventHandlerL(

    CContentRenderer& aRenderer )

    {

    CAIXuikonEventHandler* eventHandler = 

        CAIXuikonEventHandler::NewL( *this, aRenderer );

    eventHandler->SetFwEventHandler( iFwEventHandler );

    eventHandler->SetUiEventHandler( this );

    return eventHandler;

    }

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

// CXmlUiController::NotifyAppEnvReadyL()

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

//

void CXmlUiController::NotifyAppEnvReadyL()

    {    

    iCPSpublisher = CContentPublisher::NewL( *this );

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

    if( iFwEventHandler )

        {

        iFwEventHandler->AppEnvReadyL();        

        }          

    }

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

// CXmlUiController::LoadUIDefinition()

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

//

void CXmlUiController::LoadUIDefinitionL()

    {          

    }

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

// CXmlUiController::PublisherInfoL()

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

//

void CXmlUiController::PublisherInfoL( CXnNodeAppIf& aSource,

    THsPublisherInfo& aInfo )

    {

    // Fetch uid from XML and convert it to TUid

    const TDesC8* uid( PropertyValue( aSource, 

        AiUiDef::xml::property::KValue ) ); 

    if ( !uid )

        {

        return;

        }

    _LIT8( KPrefix, "0x" );

    const TInt pos( uid->FindF( KPrefix ) );

    TInt32 uidValue( 0 );

    if( pos != KErrNotFound )

         {

         TLex8 lex( uid->Mid( pos + KPrefix().Length() ) );

         // Hex parsing needs unsigned int

         TUint32 value( 0 );

         TInt err( lex.Val( value, EHex ) );

         if ( err == KErrNone )

             {

             uidValue = value;

             }

         }

    // Fetch plug-in name from XML

    HBufC* name( PropertyValueL( aSource, AiUiDef::xml::property::KName ) ); 

    TUid pluginuid( TUid::Uid( uidValue ) );

    aInfo = THsPublisherInfo( pluginuid, *name, aSource.Namespace() );

    delete name;

    name = NULL;

    }

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

// CXmlUiController::GetSettingsL()

//

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

//

void CXmlUiController::GetSettingsL( const THsPublisherInfo& aPublisherInfo,     

    RAiSettingsItemArray& aSettings )

    {

    if ( aPublisherInfo.Namespace() == KNativeUiNamespace )

        {

        // This controller doesn't provide settings for native ui namespace

        return;

        }

    const TDesC& classId( 

        iNodeIdGenerator->SettingsNodeIdL( aPublisherInfo ) ); 

    TBuf< KHsPublisherNamespaceMaxLength > ns;

    ns.Copy( aPublisherInfo.Namespace() );

    // Find settings nodes

    RPointerArray< CXnNodeAppIf > nodes( 

        UiEngineL()->FindNodeByClassL( classId, ns ) );

    CleanupClosePushL( nodes );

    // Reserve space for settings

    aSettings.ReserveL( aSettings.Count() + nodes.Count() );

    // Collect settings

    TInt count( nodes.Count() );

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

        {

        CXnNodeAppIf* node( nodes[i] );

        const TDesC8* name( 

            PropertyValue( *node, AiUiDef::xml::property::KName ) );

        HBufC* value( 

            PropertyValueL( *node, AiUiDef::xml::property::KValue ) );        

        CleanupStack::PushL( value );

        if( name && value )

            {

            MAiPluginSettings* settings( AiUtility::CreatePluginSettingsL() );

            CleanupDeletePushL( settings );

            MAiPluginSettingsItem& item( settings->AiPluginSettingsItem() ); 

            item.SetPublisherId( aPublisherInfo.Uid() );

            TInt32 key( 0 );

            User::LeaveIfError( AiUtility::ParseInt( key, *name ) );

            item.SetKey( key );            

            item.SetValueL( *value, EFalse );

            // Append settings into array.

            // This can not fail because space has been reserved.

            aSettings.Append( settings );            

            CleanupStack::Pop( settings );

            }

        CleanupStack::PopAndDestroy( value );

        }

    CleanupStack::PopAndDestroy( &nodes );

    GetContentModelL( aPublisherInfo, aSettings );

    }

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

// CXmlUiController::GetContentModelL()

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

//

void CXmlUiController::GetContentModelL( const THsPublisherInfo& aPublisherInfo,         

    RAiSettingsItemArray& aSettings )

    {

    if ( aPublisherInfo.Namespace() == KNativeUiNamespace )

        {

        // This controller doesn't provide content model for native ui namespace

        return;

        }

    RPointerArray<CXnNodeAppIf> list( 

        UiEngineL()->FindContentSourceNodesL( aPublisherInfo.Namespace() ) );

    CleanupClosePushL( list );

    if ( list.Count() > 0 )

        {

        }

    CleanupStack::PopAndDestroy( &list );

        {

        return;

        }

        {

                {