/*

* Copyright (c) 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:  Encapsulates hsps liw service

*

*/

#include <liwservicehandler.h>

#include <liwvariant.h>

#include <bamdesca.h>

#include <centralrepository.h>

#include <activeidle2domaincrkeys.h>

#include "hspswrapper.h"

#include "hspsconfiguration.h"

#include "pluginmap.h"

#include "itemmap.h"

#include "propertymap.h"

#include "objectmap.h"

#include "plugininfo.h"

_LIT8( KHSPS, "Service.HSPS" );

_LIT8( KHSPSConfigurationIf, "IConfiguration" );

_LIT8( KHSPSCommandGetActiveAppConf, "GetActiveAppConf" );

_LIT8( KHSPSCommandGetPluginConf, "GetPluginConf" );

_LIT8( KHSPSCommandGetPlugins, "GetPlugins" );

_LIT8( KHSPSCommandAddPlugin, "AddPlugin" );

_LIT8( KHSPSCommandRemovePlugin, "RemovePlugin" );

_LIT8( KHSPSCommandReplacePlugin, "ReplacePlugin" );

_LIT8( KHSPSCommandSetConfState, "SetConfState" );

_LIT8( KHSPSCommandGetAppConfs, "GetAppConfs" );

_LIT8( KHSPSCommandSetAppConf, "SetActiveAppConf" );

_LIT8( KHSPSMovePlugins, "MovePlugins");

_LIT8( KHSPSSetPluginSettings, "SetPluginSettings" );

_LIT8( KAppConfKey, "appConf" );

_LIT8( KAppConfsKey, "appConfs" );

_LIT8( KPluginConfKey, "pluginConf" );

_LIT8( KPluginsKey, "plugins" );

_LIT8( KConfId, "confId" );

_LIT8( KPluginUid, "pluginUid" );

_LIT8( KOutKeyStatus ,"status");

_LIT8( KHspsAppUid, "appUid" );

_LIT8( KKeyPluginId, "pluginId" );

_LIT8( KKeyConfUid, "confUid" );

_LIT8( KInterface, "interface" );

_LIT8( KType, "type" );

_LIT8( KCopyLogos, "copylogos" );

_LIT8( KKeyPlugins, "plugins" );

_LIT8( KKeyItemId, "itemId" );

_LIT8( KKeyName, "name" );

_LIT8( KKeyValue, "value" );

_LIT8( KKeyProperties, "properties" );

_LIT8( KKeySettings, "settings" );

_LIT8( KIndex, "position" );

_LIT8( KConfState, "state" );

_LIT8( KRequestNotification, "RequestNotification" );

_LIT8( KHSPSCommandRestoreConfigurations, "RestoreConfigurations" );

_LIT8( KRestore, "restore" );

_LIT8( KRestoreDefault, "default" );

_LIT8( KRestoreRom, "rom" );

_LIT8( KRestoreViews, "views" );

_LIT8( K0, "0" );

_LIT8( K1, "1" );

_LIT8( KPluginIdNotSet, "-1" );

const TInt KMaxPluginIdLen = 32;

namespace hspswrapper{

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

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

//

EXPORT_C CAddPluginResult::CAddPluginResult():iStatus(KErrNotFound)

    {}

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

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

//

EXPORT_C CAddPluginResult::~CAddPluginResult()

    {

    delete iPluginId;

    }

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

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

//

EXPORT_C CAddPluginResult* CAddPluginResult::NewL()

    {

    CAddPluginResult* self = new( ELeave ) CAddPluginResult;

    return self;

    }

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

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

//

EXPORT_C void CAddPluginResult::SetPluginIdL(

    const TDesC8& aPluginId )

    {

    delete iPluginId;

    iPluginId = NULL;

    iPluginId = aPluginId.AllocL();

    }

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

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

//

EXPORT_C const TDesC8& CAddPluginResult::PluginId()const

    {

    if(iPluginId)

        {

        return *iPluginId;

        }

    else

        {

        return KNullDesC8;

        }

    }

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

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

//

EXPORT_C void CAddPluginResult::SetStatus(TInt aStatus )

    {

    iStatus = aStatus;

    }

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

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

//

EXPORT_C TInt CAddPluginResult::Status()const

    {

    return iStatus;

    }

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

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

//

CHspsWrapper::CHspsWrapper(MHspsWrapperObserver* aObserver)

    : iObserver( aObserver )

    {

    }

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

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

//

void CHspsWrapper::ConstructL(const TDesC8& aAppUid)

    {    

    // Read active view.

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

    LoadActivePluginIdL();

    // Attach to HSPS:

    iServiceHandler = CLiwServiceHandler::NewL();

    iHspsService = CLiwCriteriaItem::NewL( 1, KHSPSConfigurationIf, KHSPS );

    iHspsService->SetServiceClass( TUid::Uid( KLiwClassBase ) );

    RCriteriaArray interestList;

    interestList.AppendL( iHspsService );

    iServiceHandler->AttachL( interestList );

    interestList.Reset();

    CLiwGenericParamList& inParamList = iServiceHandler->InParamListL();

    CLiwGenericParamList& outParamList = iServiceHandler->OutParamListL();

    TLiwGenericParam appUid;

    TLiwVariant uidVar;

    uidVar.Set( aAppUid );

    appUid.SetNameAndValueL( KHspsAppUid, uidVar );

    appUid.PushL();

    inParamList.AppendL( appUid );

    CleanupStack::Pop();

    appUid.Reset();

    iServiceHandler->ExecuteServiceCmdL( *iHspsService,inParamList,outParamList );

    inParamList.Reset();

    TInt pos = 0;

    outParamList.FindFirst( pos, KHSPSConfigurationIf );

    if( pos != KErrNotFound )

        {

        iHspsInterface = outParamList[ pos ].Value().AsInterface();    

        outParamList.Reset();        

        }

    else

        {

        outParamList.Reset();       

        User::Leave( KErrNotFound );

        }   

    inParamList.Reset();

    outParamList.Reset();

    if( iObserver )

        {

        iTransactionId = -1;

        iHspsInterface->ExecuteCmdL( KRequestNotification,

                                     inParamList,

                                     outParamList,

                                     KLiwOptASyncronous,

                                     this );   

        const TLiwGenericParam* outParam( NULL );

       TInt pos( 0 );

       outParam = outParamList.FindFirst( pos, _L8("status") );

       if ( outParam )

           {

           TInt retval;

           retval = outParam->Value().AsTInt32();

           if(retval == KErrNone )

               {

               pos = 0;

               outParam = outParamList.FindFirst( pos, _L8("TransactionID") );

               if( outParam )

                   {

                   retval = outParam->Value().AsTInt32();

                   iTransactionId = retval;

                   }

               }

           }

        }

    }

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

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

//

EXPORT_C CHspsWrapper* CHspsWrapper::NewL(const TDesC8& aAppUid,

                                          MHspsWrapperObserver* aObserver)

    {

    CHspsWrapper* self = CHspsWrapper::NewLC(aAppUid, aObserver);

    CleanupStack::Pop( self );

    return self;

    }

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

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

//

EXPORT_C CHspsWrapper* CHspsWrapper::NewLC(const TDesC8& aAppUid,

                                           MHspsWrapperObserver* aObserver)

    {

    CHspsWrapper* self = new( ELeave ) CHspsWrapper( aObserver );

    CleanupStack::PushL( self );

    self->ConstructL(aAppUid);

    return self;

    }

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

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

//

EXPORT_C CHspsWrapper::~CHspsWrapper()

    {

    if( iHspsInterface )

        {

        // Close interface

        iHspsInterface->Close();       

        }

    if( iServiceHandler && iHspsService )

        {

        // Detach services from the handler

        RCriteriaArray interestList;

        TRAP_IGNORE( interestList.AppendL( iHspsService ) );

        TRAP_IGNORE( iServiceHandler->DetachL( interestList ) );   

        interestList.Reset();        

        }

    delete iHspsService;

    delete iServiceHandler;    

    delete iRepository;

    delete iActivePluginId;

    }

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

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

//

EXPORT_C CHspsConfiguration* CHspsWrapper::GetAppConfigurationL()

    {

    CHspsConfiguration* configuration = CHspsConfiguration::NewLC();

    // Fetch from liw service

    CLiwGenericParamList& inParamList = iServiceHandler->InParamListL();

    CLiwGenericParamList& outParamList = iServiceHandler->OutParamListL();

    iHspsInterface->ExecuteCmdL( KHSPSCommandGetActiveAppConf, 

                                 inParamList, 

                                 outParamList );

    inParamList.Reset();

    // 1: get appConf map

    TInt index(0);

    const TLiwGenericParam* conf = outParamList.FindFirst(index,KAppConfKey);

    if(conf)

        {

        const CLiwMap* confMap  = conf->Value().AsMap();

        // 2: Process Configuration map

        if(confMap)

           {

           ProcessConfigurationMapL( *confMap, *configuration, ETrue );

           }

        }

    outParamList.Reset();

    CleanupStack::Pop(configuration);

    return configuration;

    }

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

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

//

EXPORT_C void CHspsWrapper::GetAppConfigurationsL(

    RPointerArray<CPluginInfo>& aPlugins )        

    {

    // Fetch from liw service

    CLiwGenericParamList& inParamList = iServiceHandler->InParamListL();

    CLiwGenericParamList& outParamList = iServiceHandler->OutParamListL();

    iHspsInterface->ExecuteCmdL( KHSPSCommandGetAppConfs, 

                                 inParamList, 

                                 outParamList );

    inParamList.Reset();

    TInt index(0);

    const TLiwGenericParam* confs = outParamList.FindFirst(index,KAppConfsKey);

    if(confs)

        {

        const CLiwList* list = confs->Value().AsList();

        if(list)

            {

            TInt listCount = list->Count();

            TLiwVariant mapVar;

            mapVar.PushL();

            for ( TInt index(0); list->AtL( index, mapVar ); ++index )

                {                               

                const CLiwMap* confMap = mapVar.AsMap();

                if ( confMap )

                    {

                    CPluginInfo* plugin = CPluginInfo::NewLC();

                    TLiwVariant confVar;

                    confVar.PushL();

                    if( confMap->FindL( _L8("uid"), confVar ) )

                        {

                        plugin->SetUidL( confVar.AsData() );

                        }

                    confVar.Reset();

                    if( confMap->FindL(_L8("name"), confVar ) )

                        {

                        plugin->SetNameL( confVar.AsData() );

                        }

                    CleanupStack::Pop(&confVar);

                    confVar.Reset();

                    plugin->SetTypeL( _L8("application") );

                    aPlugins.AppendL( plugin );

                    CleanupStack::Pop( plugin );

                    }

                }

            CleanupStack::Pop(&mapVar);

            mapVar.Reset();

            }

        }

    outParamList.Reset();

    }

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

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

//

EXPORT_C TInt CHspsWrapper::SetAppConfigurationL(

    const TDesC8& aConfigurationUid )

    {

    SetActivePluginL( KPluginIdNotSet );

#ifdef _XN_PERFORMANCE_TEST_

    RDebug::Print( _L( "CHspsWrapper::SetAppConfigurationL() - start" ) );

#endif //_XN_PERFORMANCE_TEST_        

    CLiwGenericParamList& inParamList = iServiceHandler->InParamListL();

    CLiwGenericParamList& outParamList = iServiceHandler->OutParamListL();

    // Compose Liw message

    TLiwGenericParam confIdParam;

    confIdParam.SetNameAndValueL( KKeyConfUid, TLiwVariant(aConfigurationUid) );

    confIdParam.PushL();

    inParamList.AppendL( confIdParam );

    CleanupStack::Pop(&confIdParam);

    confIdParam.Reset();

    iHspsInterface->ExecuteCmdL( KHSPSCommandSetAppConf, 

                                 inParamList, 

                                 outParamList ); 

    inParamList.Reset();

    // check success

    const TLiwGenericParam* outParam = NULL;

    TInt pos(0);

    outParam = outParamList.FindFirst( pos, KOutKeyStatus );

    TInt status(KErrGeneral);

    if ( outParam )

        {

        status = outParam->Value().AsTInt32();

        }

    outParamList.Reset();

#ifdef _XN_PERFORMANCE_TEST_

    RDebug::Print( _L( "CHspsWrapper::SetAppConfigurationL() - end" ) );

#endif //_XN_PERFORMANCE_TEST_            

    return status;

    }

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

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

//

EXPORT_C CHspsConfiguration* CHspsWrapper::GetPluginConfigurationL(

    const TDesC8& aPluginId)

    {

    CHspsConfiguration* configuration = CHspsConfiguration::NewLC();

    // Fetch from liw service

    CLiwGenericParamList& inParamList = iServiceHandler->InParamListL();

    CLiwGenericParamList& outParamList = iServiceHandler->OutParamListL();

    // Form input message

    TLiwGenericParam pluginIdParam;

    TLiwVariant pluginIdVar;

    pluginIdVar.Set( aPluginId );

    pluginIdParam.SetNameAndValueL( KKeyPluginId, pluginIdVar );

    pluginIdParam.PushL();

    inParamList.AppendL( pluginIdParam );

    CleanupStack::Pop(&pluginIdParam);

    pluginIdParam.Reset();

    iHspsInterface->ExecuteCmdL( KHSPSCommandGetPluginConf, 

                                 inParamList, 

                                 outParamList );

    inParamList.Reset();

    // 1: get pluginConf map

    TInt index(0);

    const TLiwGenericParam* conf = outParamList.FindFirst(index,KPluginConfKey);

    if(conf)

        {

        const CLiwMap* confMap  = conf->Value().AsMap();

        // 2: Process Configuration map

        if(confMap)

           {

           ProcessConfigurationMapL( *confMap, *configuration, EFalse );

           }

        }

    outParamList.Reset();

    CleanupStack::Pop(configuration);

    return configuration;

    } 

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

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

//

EXPORT_C void CHspsWrapper::GetPluginsL(

    RPointerArray<CPluginInfo>& aPlugins,

    const TDesC8& aPluginInterface,

    const TDesC8& aPluginType)

    {

    CLiwGenericParamList& inParamList = iServiceHandler->InParamListL();

    CLiwGenericParamList& outParamList = iServiceHandler->OutParamListL();

    // plugin interface

    TLiwGenericParam interfaceParam( KInterface, TLiwVariant( aPluginInterface ) );

    interfaceParam.PushL();

    inParamList.AppendL( interfaceParam );

    CleanupStack::Pop(&interfaceParam);

    interfaceParam.Reset();

    // plugin type

    TLiwGenericParam typeParam;

    typeParam.SetNameAndValueL( KType, TLiwVariant(aPluginType ) );

    typeParam.PushL();

    inParamList.AppendL( typeParam );

    CleanupStack::Pop(&typeParam);

    typeParam.Reset();

    TLiwGenericParam logosParam;

    logosParam.SetNameAndValueL( KCopyLogos, TLiwVariant( ETrue ) );

    logosParam.PushL();

    inParamList.AppendL( logosParam );

    CleanupStack::Pop(&logosParam);

    logosParam.Reset();

    iHspsInterface->ExecuteCmdL( KHSPSCommandGetPlugins, inParamList, outParamList ); 

    inParamList.Reset();

    TInt index(0);

    const TLiwGenericParam* plugins = outParamList.FindFirst(index,KPluginsKey);

    if(plugins)

        {

        const CLiwList* list = plugins->Value().AsList();

        if(list)

            {

            ProcessPluginsL(*list,aPlugins);