/*

* Copyright (c) 2009 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: CPSApiDll.cpp - main DLL source

*

*/

#include <utf.h>

#include "hswidgetpublisherimpl.h"

#include "hswidget.h"

#include "hswidgetitem.h"

#include "hsglobals.h"

#include "hsexception.h"

#include "hsserviceerrno.h"

const TInt KSAPIContentNameMaxLength = 255;

const TInt KUnicodeSize = 4;

using namespace Hs;

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

// 

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

// 

HsWidgetPublisherImpl::HsWidgetPublisherImpl()

	{

	mServiceInterface = 0;

	TInt err;

	TRAP( err,

		mServiceHandler = CLiwServiceHandler::NewL();

	    )

	if( err != KErrNone )

		{

		throw HsException( err );

		}

    RProcess process;

    iWidgetUid = process.Identity().iUid;

    process.Close();

	}

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

// 

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

// 

HsWidgetPublisherImpl::~HsWidgetPublisherImpl()

	{

   	TRAP_IGNORE( UnegisterNotificationL() );

    if( mServiceInterface )

    	{

    	mServiceInterface->Close();

    	}

   	if( mServiceHandler )

    	{

    	mServiceHandler->Reset();

    	delete mServiceHandler;

    	}

   	const int count = mWidgets.size();

    for( int index = 0; index < count; index++ )

        {

        HsWidget* const widget = mWidgets.at( index );

        mWidgets[index] = NULL;

        delete widget;

        }

	}

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

// 

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

//

HsWidget& HsWidgetPublisherImpl::CreateWidget( std::string& aTemplateName, 

	std::string& aWidgetName, std::string& aIdentifier,

	std::string& aDescription, std::string& aIconLocation)

	{

	if( CheckIfWidgetExist( aTemplateName, aWidgetName, aIdentifier, EFalse ) )

		{

		throw HsException( KErrAlreadyExists );

		}

	HsWidget* widget= new HsWidget( aTemplateName, aWidgetName, 

		aIdentifier, aDescription, aIconLocation );

	if( !widget)

		{

		throw HsException( KErrNoMemory );

		}

	mWidgets.push_back( widget);

	TInt err( KErrNone );

	TRAP( err, 

		PublishWidgetActionsL( *widget );

        RegisterNotificationL( *widget );

		)

	if( err != KErrNone )

		{

		throw HsException( err );

		}

	return *widget;

	}

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

// 

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

//

TInt HsWidgetPublisherImpl::HandleNotifyL(

    TInt /*aCmdId*/,

    TInt /*aEventId*/,

    CLiwGenericParamList& aEventParamList,

    const CLiwGenericParamList& /*aInParamList*/)

	{

	if( !mHsDataObserver )

		 {

		 return 1;

		 }

	TInt pos(0);	

    aEventParamList.FindFirst(pos, KChangeInfo);

    if (pos != KErrNotFound)

        {

        // Get list of maps

        TLiwVariant variant = (aEventParamList)[pos].Value();

        variant.PushL();

        const CLiwList* changeMapsList = variant.AsList();

		TBuf8<KSAPIContentNameMaxLength> operation;

		TBuf8<KSAPIContentNameMaxLength> trigger;

        // Iter through list content

        for (TInt index = 0; index < changeMapsList->Count(); ++index)

            {

             if ( changeMapsList->AtL(index, variant) ) 

            	 {

                 const CLiwMap* map  = variant.AsMap();

                 HsWidget* widget = GetWidgetL( map );

                 if( !widget )

                	 {

                	 break;

                	 }

                 if ( map->FindL(KOperation, variant) )

                     {// Check what triggered a notification

                     variant.Get(operation);

                     }

                 variant.Reset();

                 if ( operation == KOperationExecute )

                	 {

                	 if( map->FindL( KActionTrigger, variant) )

						 {

						 variant.Get(trigger );

						 }

                	 if( !HandleWidgetActionL( trigger, *widget ) )

                		 {

                		 break;

                		 }

                	 HandleWidgetItemActionL( trigger, *widget );

                	 }

                 }

            }

        CleanupStack::PopAndDestroy(1);

        }

    return 0;

	}

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

// 

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

//

int HsWidgetPublisherImpl::HandleWidgetActionL( const TDesC8& aActionDes,

	HsWidget& aWidget )

	{

	int ret( 1 );//not found

	IHsDataObserver::EEvent action( IHsDataObserver::EUnknown );

	TranslateObserverAction( aActionDes, action );

	if( action == IHsDataObserver::EActivate ||

		action == IHsDataObserver::EDeactivate ||

		action == IHsDataObserver::EResume ||

		action == IHsDataObserver::ESuspend )

		{

		TInt observerError = KErrNone;

		try

			{

			mHsDataObserver->handleEvent(

				aWidget.getWidgetName(), action );

			}

		catch( HsException& exception )

			{

			observerError = exception.getReason();

			}

		if ( action == IHsDataObserver::EDeactivate )

		    {

		    // remove widget data when widget removed from screen

		    CLiwDefaultMap* cpdatamap = CLiwDefaultMap::NewLC();

		    // removal may fail if the client has already removed the data

		    TRAP_IGNORE( RemoveFromCpsL( cpdatamap, KCpData ) );

		    mWidgetContentIds.erase( aWidget.getIdentifier() );

		    CleanupStack::PopAndDestroy( cpdatamap );

		    }

		User::LeaveIfError( observerError );

		ret = 0;

		}

	return ret;

	}

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

// 

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

//

void HsWidgetPublisherImpl::TranslateObserverAction( const TDesC8& aActionDes,

	IHsDataObserver::EEvent& aAction )

	{

	if( !aActionDes.Compare( KActive() ) )

		{

		aAction = IHsDataObserver::EActivate;

		}

	if( !aActionDes.Compare( KDeActive() ) )

		{

		aAction = IHsDataObserver::EDeactivate;

		}

	if( !aActionDes.Compare( KSuspend() ) )

		{

		aAction = IHsDataObserver::ESuspend;

		}

	if( !aActionDes.Compare( KResume() ) )

		{

		aAction = IHsDataObserver::EResume;

		}

	}

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

// 

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

//

int HsWidgetPublisherImpl::HandleWidgetItemActionL( const TDesC8& aActionDes,

		HsWidget& aWidget )

	{

	int ret( 1 );

	TBuf8<KSAPIContentNameMaxLength> itemName( aActionDes );

	std::string strItemName( (char*) itemName.PtrZ() );

	if( aWidget.checkIfWidgetItemExist(  strItemName ) )

		{

		std::string widgetName( aWidget.getWidgetName() );

		try

			{

			mHsDataObserver->handleItemEvent( widgetName,

				strItemName, 

				IHsDataObserver::ESelect );

			}

		catch( HsException& exception )

			{

			User::Leave( exception.getReason() );

			}

		ret = 0;

		}

	else if (aActionDes.Compare(KSelected) == 0)

	    {

        std::string widgetName( aWidget.getWidgetName() );

	    int count = aWidget.itemsCount();

        for (int index = 0; index < count; index++)

            {

            HsWidgetItem* const item = aWidget.getWidgetItem( index );

            try

                {

                mHsDataObserver->handleItemEvent( widgetName,

                    item->getItemName(), 

                    IHsDataObserver::ESelect );

                }

            catch( HsException& exception )

                {

                User::Leave( exception.getReason() );

                }

            }

	        ret = 0;

	    }

	return ret;

	}

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

// 

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

//

MLiwInterface* HsWidgetPublisherImpl::GetServiceInterfaceL( )

	{

	CLiwGenericParamList* inParam = CLiwGenericParamList::NewL();

	CleanupStack::PushL( inParam );

	CLiwGenericParamList* outParam = CLiwGenericParamList::NewL();

	CleanupStack::PushL( outParam );

	CLiwCriteriaItem* crit = CLiwCriteriaItem::NewL( KLiwCmdAsStr, 

		KCPInterface, KCPService );

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

	RCriteriaArray a;

	a.AppendL(crit);    

	mServiceHandler->AttachL(a);

	mServiceHandler->ExecuteServiceCmdL( *crit, *inParam, *outParam ); 

	delete crit;

	a.Reset();

	// find service interface

	TInt pos = 0;

	MLiwInterface* msgInterface( 0 );

	outParam->FindFirst( pos, KCPInterface );

	if ( pos != KErrNotFound ) 

	    {

	    msgInterface = (*outParam)[pos].Value().AsInterface(); 

	    }

	outParam->Reset();

	inParam->Reset();

	CleanupStack::PopAndDestroy( outParam );

	CleanupStack::PopAndDestroy( inParam );

	return msgInterface;

	}

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

// 

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

//

void HsWidgetPublisherImpl::SetDataObserver( IHsDataObserver* aDataObserver )

	{

	__ASSERT_ALWAYS( aDataObserver, User::Panic( KStartUpFailed, 0) );

	mHsDataObserver = aDataObserver;

	TInt err( KErrNone );

	TRAP( err,

		mServiceInterface = GetServiceInterfaceL();

		);

	if( err != KErrNone )

		{

		throw HsException( err );

		}

	}

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

// 

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

//

void HsWidgetPublisherImpl::RegisterNotificationL( HsWidget& aWidget )

	{

	CLiwGenericParamList* inParam = &(mServiceHandler->InParamListL());

	CLiwGenericParamList* outParam = &(mServiceHandler->OutParamListL());

	CLiwDefaultMap* reqFilter = CLiwDefaultMap::NewLC();

	HBufC* publisherName = StdStringToUnicodeLC( GetPublisherNameL( aWidget ) );

	reqFilter->InsertL( KPublisherId, TLiwVariant( *publisherName ) );

	reqFilter->InsertL( KContentType, TLiwVariant( KAll ) );

	reqFilter->InsertL( KContentId, TLiwVariant( KAll ));

	reqFilter->InsertL( KOperation, TLiwVariant( KOperationExecute ));

	inParam->AppendL(TLiwGenericParam(KType, TLiwVariant( 

		KContentAndPublisher_Registry)));

	inParam->AppendL(TLiwGenericParam(KFilter, TLiwVariant(reqFilter)));

	mServiceInterface->ExecuteCmdL( KRequestNotification,

		*inParam, *outParam, 0, this );

	TInt ret = ObtainErrorCode( *outParam );

	outParam->Reset();

	inParam->Reset();

	CleanupStack::PopAndDestroy( publisherName );

	CleanupStack::PopAndDestroy( reqFilter );

	User::LeaveIfError( ret );

	}

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

// 

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

//

void HsWidgetPublisherImpl::UnegisterNotificationL()

	{

	CLiwGenericParamList* inParam = &(mServiceHandler->InParamListL());

	CLiwGenericParamList* outParam = &(mServiceHandler->OutParamListL());

	mServiceInterface->ExecuteCmdL( KRequestNotification,

		*inParam, *outParam, KLiwOptCancel, this ); 

	TInt ret= ObtainErrorCode( *outParam );

	outParam->Reset();

	inParam->Reset();	

	User::LeaveIfError( ret );

	}

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

// 

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

//

void HsWidgetPublisherImpl::PublishWidget( HsWidget& aWidget )

	{

	TRAPD( err,

		PublishWidgetDataL( aWidget );

		);

	if( err != KErrNone )

		{

		throw HsException( err );

		}

	}

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

// 

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

//

void HsWidgetPublisherImpl::PublishWidgetDataL( HsWidget& aWidget )

        // add to CPS

    }

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

// 

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

//

void HsWidgetPublisherImpl::PublishWidgetActionsL( HsWidget& aWidget )

	{

	CLiwGenericParamList* inParam = &(mServiceHandler->InParamListL());

	CLiwGenericParamList* outParam = &(mServiceHandler->OutParamListL());

	TLiwGenericParam type(KType, TLiwVariant(KPublisher));

	inParam->AppendL(type);

	CLiwDefaultMap* cpdatamap = CLiwDefaultMap::NewLC();

	InsertWidgetIdentifiersL( aWidget, cpdatamap );

	CLiwDefaultMap* mapAction = CLiwDefaultMap::NewLC();

	CLiwDefaultMap* activateAction = CLiwDefaultMap::NewLC();

	activateAction->InsertL( KPluginId, TLiwVariant( KCASpaAppLauncherPlugin ) );

	CLiwDefaultMap* activate = CLiwDefaultMap::NewLC();

	activate->InsertL( KType, TLiwVariant( KActionValueLaunchApplication ) );

	activate->InsertL( KLaunchMethod, TLiwVariant( KLaunchMethodValueCmdLine ) );

	activate->InsertL( KApplicationUid, TLiwVariant( iWidgetUid ) );

	activate->InsertL( KApaCommand, TLiwVariant( KApaCommandBackground ) );

	activateAction->InsertL( KData, TLiwVariant( activate ) );

	mapAction->InsertL(KActive, TLiwVariant( activateAction ));

    mapAction->InsertL(KDeActive, TLiwVariant(KTriggerMap));

    mapAction->InsertL(KSuspend, TLiwVariant(KTriggerMap));

    mapAction->InsertL(KResume, TLiwVariant(KTriggerMap));

    mapAction->InsertL(KSelected, TLiwVariant(activateAction));

    cpdatamap->InsertL( KActionMap, TLiwVariant( mapAction ) );

	CLiwDefaultMap* datamap = CLiwDefaultMap::NewLC();

	InsertWidgetInfoL( aWidget, datamap );

	cpdatamap->InsertL( KDataMap, TLiwVariant( datamap ) );

	InsertWidgetACLL( cpdatamap );

	TLiwGenericParam item( KItem, TLiwVariant( cpdatamap ));	    

	inParam->AppendL( item );

	mServiceInterface->ExecuteCmdL( KAdd, *inParam, *outParam);

	TInt ret= ObtainErrorCode( *outParam );

	CleanupStack::PopAndDestroy( datamap );

	CleanupStack::PopAndDestroy( activate );

	CleanupStack::PopAndDestroy( activateAction );

	CleanupStack::PopAndDestroy( mapAction );

	CleanupStack::PopAndDestroy( cpdatamap );

	item.Reset();

	type.Reset();	

	outParam->Reset();

	inParam->Reset();

	User::LeaveIfError( ret );

	}

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

// 

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

//

void HsWidgetPublisherImpl::RemoveWidget( std::string& aTemplateName, 

	std::string& aWidgetName,

	std::string& aIdentifier )

	{

	HsWidget* ret( 0 );

	int count = mWidgets.size();