/*

* 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 <hspluginsettings.h>

#include "hspsconfiguration.h"

//#include "pluginmap.h"

#include "itemmap.h"

#include "propertymap.h"

//#include "objectmap.h"

//#include "plugininfo.h"

#include <mhomescreensettingsif.h>

#include <mhomescreensettingsobserver.h>

_LIT8( KHSPS, "Service.HSPS" );

_LIT8( KHSPSConfigurationIf, "IConfiguration" );

_LIT8( KHSPSCommandGetPluginConf, "GetPluginConf" );

_LIT8( KHSPSSetPluginSettings, "SetPluginSettings" );

_LIT8( KPluginConfKey, "pluginConf" );

_LIT8( KOutKeyStatus ,"status");

_LIT8( KHspsAppUid, "appUid" );

_LIT8( KKeyPluginId, "pluginId" );

_LIT8( KKeyStoringParams, "storingParams" );

_LIT8( KKeyStorePluginRefence, "storePluginConf" );

_LIT8( KKeyStoreAppConf, "storeAppConf" );

_LIT8( KKeyItemId, "itemId" );

_LIT8( KKeyName, "name" );

_LIT8( KKeyValue, "value" );

_LIT8( KKeyProperties, "properties" );

_LIT8( KKeySettings, "settings" );

_LIT8( KRequestNotification, "RequestNotification" );

_LIT8( KSettingsChanged, "PluginSettingsChanged" );

namespace HSPluginSettingsIf{

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

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

//

CHomescreenSettings::CHomescreenSettings(MHomeScreenSettingsObserver* aObserver, const TDesC8& aPluginId )

    : iObserver( aObserver ), iPluginId( aPluginId )

    {

    }

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

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

//

void CHomescreenSettings::ConstructL( const TDesC8& aAppUid )

    {

    // 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 CHomescreenSettings* CHomescreenSettings::NewL(

    const TDesC8& aAppUid,

    const TDesC8& aPluginId, 

    MHomeScreenSettingsObserver* aObserver)

    {

    CHomescreenSettings* self = CHomescreenSettings::NewLC(aAppUid, aPluginId, aObserver);

    CleanupStack::Pop( self );

    return self;

    }

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

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

//

EXPORT_C CHomescreenSettings* CHomescreenSettings::NewLC(

    const TDesC8& aAppUid,

    const TDesC8& aPluginId,

    MHomeScreenSettingsObserver* aObserver)

    {

    CHomescreenSettings* self = new( ELeave ) CHomescreenSettings( aObserver, aPluginId );

    CleanupStack::PushL( self );

    self->ConstructL(aAppUid);

    return self;

    }

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

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

//

EXPORT_C CHomescreenSettings::~CHomescreenSettings()

    {

    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;    

    }

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

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

//

TInt CHomescreenSettings::SetPluginSettingsL(

    const TDesC8& aPluginId, 

    const RPointerArray<CItemMap>& aSettings,

    const TDesC8& aStoringParam )

    {

    // Compose AddPlugin hsps LIW message to Service.HomeScreenPluginConfiguration

    CLiwGenericParamList& inParamList = iServiceHandler->InParamListL();

    CLiwGenericParamList& outParamList = iServiceHandler->OutParamListL();

    TLiwGenericParam pluginIdParam;

    pluginIdParam.SetNameAndValueL( KKeyPluginId, TLiwVariant(aPluginId) );

    pluginIdParam.PushL();

    inParamList.AppendL( pluginIdParam );

    CleanupStack::Pop( &pluginIdParam );

    pluginIdParam.Reset();    

    CLiwDefaultList* itemMapList = CLiwDefaultList::NewLC();

    for( int i = 0; i < aSettings.Count(); i++ )

        {

        CItemMap* itemMap = aSettings[i];

        CLiwDefaultMap* inItemMap = CLiwDefaultMap::NewLC();

        FillMapFromItemL(*inItemMap,*itemMap);

        itemMapList->AppendL( TLiwVariant(inItemMap) );

        CleanupStack::Pop(inItemMap);

        inItemMap->Close();

        }

    TLiwGenericParam settingsParam;

    settingsParam.SetNameAndValueL( KKeySettings, TLiwVariant(itemMapList) );

    settingsParam.PushL();

    inParamList.AppendL( settingsParam );

    CleanupStack::Pop( &settingsParam );

    settingsParam.Reset();

    TLiwGenericParam storingParams;

    storingParams.SetNameAndValueL( KKeyStoringParams, TLiwVariant(aStoringParam) );

    storingParams.PushL();

    inParamList.AppendL( storingParams );

    CleanupStack::Pop( &storingParams );

    storingParams.Reset();

    iHspsInterface->ExecuteCmdL( KHSPSSetPluginSettings, 

                                 inParamList, 

                                 outParamList ); 

    CleanupStack::PopAndDestroy( itemMapList );

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

    return status;

    }

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

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

//

EXPORT_C TInt CHomescreenSettings::SetSettingsL(

    const TDesC8& aPluginId, 

    const RPointerArray<CItemMap>& aSettings,

    const TBool aStoringParams)

    {

    TInt error = KErrNone;

    if( aStoringParams )

    	{

    	error = SetPluginSettingsL(aPluginId, aSettings, KKeyStorePluginRefence());

    	}

    else

    	{

    	error = SetPluginSettingsL(aPluginId, aSettings, KKeyStoreAppConf());	

    	}

    return error;

    }

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

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

//

EXPORT_C TInt CHomescreenSettings::GetSettingsL(

    const TDesC8& aPluginId, 

     RPointerArray<CItemMap>& aSettings)

    {

    TInt error = KErrNone;

    CHspsConfiguration* configuration = CHspsConfiguration::NewLC();

    // Compose AddPlugin hsps LIW message to Service.HomeScreenPluginConfiguration

    CLiwGenericParamList& inParamList = iServiceHandler->InParamListL();

    CLiwGenericParamList& outParamList = iServiceHandler->OutParamListL();

    TLiwGenericParam pluginIdParam;

    pluginIdParam.SetNameAndValueL( KKeyPluginId, TLiwVariant(aPluginId) );

    pluginIdParam.PushL();

    inParamList.AppendL( pluginIdParam );

    CleanupStack::Pop( &pluginIdParam );

    pluginIdParam.Reset();    

    iHspsInterface->ExecuteCmdL( KHSPSCommandGetPluginConf, 

                                     inParamList, 

                                     outParamList );

    inParamList.Reset();

    TInt index(0);

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

    if(conf)

        {

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

            // 2: Process Configuration map

        if(confMap)

            {

            TLiwVariant tempVariant;

            tempVariant.PushL();

            if( confMap->FindL( _L8("settings"), tempVariant ))

                {

                const CLiwList* settings_list( tempVariant.AsList() );

                if( settings_list )

                    {

                    aSettings.Reset();

                    ProcessConfigurationSettingsL(*settings_list,*configuration);

                    RPointerArray<CItemMap>& settings = configuration->Settings();

                    CItemMap* itemMapIn(0);

                    CPropertyMap* readProperty(0);

                    CPropertyMap* propertyIn(0); 

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

                        {

                        CItemMap* readItem = settings[i];

                        itemMapIn = CItemMap::NewLC(); 

                        itemMapIn->SetItemIdL(readItem->ItemId());

                        const TDesC8& itemName = readItem->ItemName();

                        itemMapIn->SetItemNameL(itemName);

                        RPointerArray<CPropertyMap>& readProperties = readItem->Properties();

                        for( TInt j=0; j < readProperties.Count(); j++ )

                            {

                            readProperty = readProperties[j];       

                            propertyIn = CPropertyMap::NewLC();

                            propertyIn->SetNameL(readProperty->Name());

                            propertyIn->SetValueL(readProperty->Value());

                            // Dispatching is based on item name 

                            itemMapIn->AddPropertyMapL(propertyIn);

                            CleanupStack::Pop(propertyIn);

                            }

                        aSettings.AppendL(itemMapIn);

                        CleanupStack::Pop(itemMapIn);

                        }

                    }

                else

                    {

                    error=KErrNotFound;

                    }

                }

            else

                {

                error= KErrNotFound;

                }

            CleanupStack::Pop(&tempVariant);

            tempVariant.Reset();

            }

        }

    outParamList.Reset();

    CleanupStack::PopAndDestroy(configuration);

    return error;

    }

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

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

//

void CHomescreenSettings::ProcessConfigurationSettingsL(

    const CLiwList& aItemList, 

    CHspsConfiguration& aTarget)

    {

    TLiwVariant itemMapVariant;

    itemMapVariant.PushL();

    for( int i=0;i<aItemList.Count();++i )

        {

        if( aItemList.AtL(i,itemMapVariant) )

            {

            const CLiwMap* itemMap( itemMapVariant.AsMap() );

            TLiwVariant itemVariant;

            itemVariant.PushL();

            if( itemMap )

                {

                CItemMap* item = CItemMap::NewLC();

                if( itemMap->FindL( _L8("itemId"),itemVariant) )

                    {

                    item->SetItemIdL( itemVariant.AsData() );

                    }

                if( itemMap->FindL( _L8("name"),itemVariant) )

                    {

                    item->SetItemNameL( itemVariant.AsData() );

                    }

                if( itemMap->FindL( _L8("properties"),itemVariant) )

                    {

                    const CLiwList* properties( itemVariant.AsList() );

                    if(properties)

                        {

                        ProcessConfItemPropertiesL(*properties,*item);

                        }

                    }

                aTarget.AddItemMapL(item);                    

                CleanupStack::Pop(item);

                }

            CleanupStack::Pop(&itemVariant);

            itemVariant.Reset();

            }

        }

    CleanupStack::Pop(&itemMapVariant);

    itemMapVariant.Reset();

    }

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

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

//

void CHomescreenSettings::ProcessConfItemPropertiesL(

    const CLiwList& aPropertyMapList,

    CItemMap& aItemMap)

    {

    TLiwVariant propertyMapVariant;

    propertyMapVariant.PushL();

    for( int i=0;i<aPropertyMapList.Count();++i )

       {

       if( aPropertyMapList.AtL(i,propertyMapVariant) )

           {

           const CLiwMap* propertyMap( propertyMapVariant.AsMap() );

           TLiwVariant propertyVariant;

           propertyVariant.PushL();

           if( propertyMap )

               {

               CPropertyMap* property = CPropertyMap::NewLC();

               if( propertyMap->FindL( _L8("name"),propertyVariant ) )

                   {

                   property->SetNameL( propertyVariant.AsData() );

                   }

               if( propertyMap->FindL( _L8("value"),propertyVariant ) )

                   {

                   property->SetValueL( propertyVariant.AsData() );

                   }

               aItemMap.AddPropertyMapL(property);                    

               CleanupStack::Pop(property);

               }

           CleanupStack::Pop(&propertyVariant);

           propertyVariant.Reset();

           }

       }

    CleanupStack::Pop(&propertyMapVariant);

    propertyMapVariant.Reset();

    }

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

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

//

void CHomescreenSettings::FillMapFromItemL( CLiwDefaultMap& aMap, const CItemMap& aItemMap )

    {

    aMap.InsertL(  KKeyItemId, TLiwVariant(aItemMap.ItemId()) );

    aMap.InsertL(  KKeyName, TLiwVariant(aItemMap.ItemName()) );

    CLiwDefaultList* inPropertyMapList = CLiwDefaultList::NewLC();

    FillMapFromPropertiesL(*inPropertyMapList,aItemMap.Properties());

    aMap.InsertL(  KKeyProperties, TLiwVariant(inPropertyMapList) );

    CleanupStack::Pop(inPropertyMapList);

    inPropertyMapList->Close();

    }

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

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

//

void CHomescreenSettings::FillMapFromPropertiesL( 

    CLiwDefaultList& aInPropertyMapList, 

    const RPointerArray<CPropertyMap>& aProperties )

    {

    for(int i=0; i<aProperties.Count(); ++i)

        {

        CLiwDefaultMap* inPropertyMap = CLiwDefaultMap::NewLC();

        inPropertyMap->InsertL(  KKeyName, TLiwVariant(aProperties[i]->Name()) );

        inPropertyMap->InsertL(  KKeyValue, TLiwVariant(aProperties[i]->Value()) );

        aInPropertyMapList.AppendL(inPropertyMap);

        CleanupStack::Pop(inPropertyMap);

        inPropertyMap->Close();

        }

    }

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

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

//    

TInt CHomescreenSettings::HandleNotifyL( TInt aCmdId, TInt aEventId,                        

    CLiwGenericParamList& aEventParamList,

    const CLiwGenericParamList& /*aInParamList*/ )