/*

* 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 <aiscutplugindomaincrkeys.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 "pmodtiterator.h"

#include "contentpublisher.h"

#include "xnplugindefs.h"

#include "ainativeuiplugins.h"

using namespace AiXmlUiController;

const TInt KOneSecondInMicroS = 1000*1000;

const TInt KAI2CrKeyIncrementBy2 = 2;

typedef TBuf<32> TNamespace;

_LIT( KSettingsDummyData, "" );

// ======== 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()

    {

    if( iFwEventHandler )

        {

        iFwEventHandler->AppEnvReadyL();

        iFwEventHandler->HandleUiReadyEventL( *this );

        }

    if( !iCPSpublisher )

        {

        iCPSpublisher = CContentPublisher::NewL( *this );

        }

    if( !iExitTimer )

        {

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

        }

    }

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

// CXmlUiController::LoadUIDefinition()

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

//

void CXmlUiController::LoadUIDefinitionL()

    {

    // No implementation required

    }

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

// CXmlUiController::GetPluginsL()

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

//

void CXmlUiController::GetPluginsL( RAiPublisherInfoArray& /*aPlugins*/ )

    {   

    // No implementation required

    }

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

// CXmlUiController::PublisherInfo()

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

//

void CXmlUiController::PublisherInfoL( RAiPublisherInfoArray& aPlugins )

    {

    // This method returns plugins with namespace KNativeUiNamespace

    if ( iRunningAsMain )

        {

        // This plugin is used to publish data on secondary ui controller side       

        TAiPublisherInfo deviceStatus;

        deviceStatus.iUid = KDeviceStatusPluginUid;

        deviceStatus.iName.Copy( KDeviceStatusPluginName );

        deviceStatus.iNamespace.Copy( KNativeUiNamespace );

        aPlugins.AppendL( deviceStatus );               

        }        

    }

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

// CXmlUiController::PublisherInfoL()

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

//

void CXmlUiController::PublisherInfoL( CXnNodeAppIf& aSource,

    TAiPublisherInfo& 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 ) );

    if( pos != KErrNotFound )

         {

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

         // Hex parsing needs unsigned int

         TUint32 value = 0;

         const TInt parseResult = lex.Val( value, EHex );

         if ( parseResult == KErrNone )

             {

             TInt32 value32( value );

             aInfo.iUid = TUid::Uid( value32 );            

             }

         }

    // Fetch plug-in name from XML

    HBufC* pluginName( PropertyValueL( aSource, 

                AiUiDef::xml::property::KName ) ); 

    CleanupStack::PushL( pluginName );

    if ( pluginName )

        {

        aInfo.iName.Copy( *pluginName );

        }

    CleanupStack::PopAndDestroy( pluginName );

    aInfo.iNamespace.Copy( aSource.Namespace() );    

    }

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

// CXmlUiController::GetSettingsL()

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

//

void CXmlUiController::GetSettingsL( const TAiPublisherInfo& aPubInfo,     

    RAiSettingsItemArray& aSettings )

    {

    if ( aPubInfo.iNamespace == KNativeUiNamespace )

        {

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

        return;

        }

    const TDesC& classId( iNodeIdGenerator->SettingsNodeIdL( aPubInfo ) );

    TNamespace ns;

    ns.Copy( aPubInfo.iNamespace );

    // 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( aPubInfo.iUid );

            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 );

    GetSettingsFromCRL( aPubInfo, aSettings );

    GetContentModelL( aPubInfo, aSettings );

    }

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

// CXmlUiController::GetSettingsFromCRL()

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

//

void CXmlUiController::GetSettingsFromCRL( const TAiPublisherInfo& aPubInfo, 

    RAiSettingsItemArray &aPluginSettings )                            

    {

    if ( aPubInfo.iNamespace == KNativeUiNamespace )

        {

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

        return;

        }

    /*

    * The settings are stored in the cenrep starting from 0x1000. 

    * 0x1000 is the name of the plugin which this setting belongs to (for example Settings/Shortcut)

    * 0x1001 is the id of the setting (for example 1)

    * 0x1002 is the value of the setting (for example localapp:0x012345678)

    * 

    * So three keys per setting.

    * 

    * Settings from cenrep override those from XML

    */

    TUint32 crKey( KAIPluginSettingsKeyRangeStart );

    TBool moreSettings( ETrue );

    HBufC* pluginId = HBufC::NewLC(

            NCentralRepositoryConstants::KMaxUnicodeStringLength );

    HBufC* settingValue = HBufC::NewLC(

            NCentralRepositoryConstants::KMaxUnicodeStringLength );

    HBufC* settingKey = HBufC::NewLC(

            NCentralRepositoryConstants::KMaxUnicodeStringLength );

    TPtr pluginIdPtr( pluginId->Des() );

    TPtr settingValuePtr( settingValue->Des() );

    TPtr settingKeyPtr( settingKey->Des() );

    TInt32 settingId( 0 );

    TInt err( KErrNone );

    TBool settingFound( EFalse );

    while( moreSettings )

        {

        settingFound = EFalse;

        pluginIdPtr.Zero();

        settingValuePtr.Zero();

        settingKeyPtr.Zero();

        //Get the name of plugin with the Settings/ prefix

        err = iAISettingsRepository->Get( crKey++, pluginIdPtr );       

        // remove the Settings/ prefix if it is located at the start of the string

        if( pluginIdPtr.FindC( AiUiDef::xml::propertyClass::KSettings ) == 0 )

            {   

            pluginIdPtr.Delete( 0, 

                    AiUiDef::xml::id::KSettingsIdSeparator().Length() +

                    AiUiDef::xml::propertyClass::KSettings().Length() );               

            }

        // does the setting belong to this plugin

        if( err == KErrNone && pluginIdPtr == aPubInfo.iName )

            {

            // Get the settings id 

            err = iAISettingsRepository->Get( crKey++, settingKeyPtr );

            if( err == KErrNone )

                {

                err = AiUtility::ParseInt( settingId,settingKeyPtr );

                }

            if( err == KErrNone )

                {                

                // Get the actual value of the setting

                err = iAISettingsRepository->Get( crKey++, settingValuePtr );    

                // Ignore possible placeholder data in cenrep                                

                if( err == KErrNone && settingValuePtr.Compare( KSettingsDummyData ) != 0 )

                    {