/*

* 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:  class to publish the data into widget

*                

*

*/

#include "cservicewidgetcontentpublisher.h"

#include <liwservicehandler.h>

#include <liwvariant.h>

#include <liwgenericparam.h>

#include <avkon.hrh>

#include <aknnotewrappers.h> 

#include "swpdebugtrace.h"

#include <liwcommon.h>

#include "servicewidgetcpglobals.h"

#include <servicewidgetpluginres.rsg>

#include <StringLoader.h>

#include <spsettings.h> 

#include <spentry.h>

#define KSW_LIST_GRANULARITY 8

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

// CServiceWidgetContentPublisher::CServiceWidgetContentPublisher

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

// 

CServiceWidgetContentPublisher::CServiceWidgetContentPublisher(MServiceWidgetEventObserver& aObserver )

   :iObserver( aObserver )

    {

   TRACE_SWP(TXT("CServiceWidgetContentPublisher::CServiceWidgetContentPublisher") );

   }

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

// CServiceWidgetContentPublisher::NewL

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

// 

CServiceWidgetContentPublisher* CServiceWidgetContentPublisher::NewL(MServiceWidgetEventObserver& aObserver)

    {

    TRACE_SWP(TXT("CServiceWidgetContentPublisher::NewL() start") );

    CServiceWidgetContentPublisher* self = NewLC(aObserver);

    CleanupStack::Pop(self);

    TRACE_SWP(TXT("CServiceWidgetContentPublisher::NewL() End") );

    return self;

    }

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

// CServiceWidgetContentPublisher::NewLC

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

// 

CServiceWidgetContentPublisher* CServiceWidgetContentPublisher::NewLC(MServiceWidgetEventObserver& aObserver)

    {

    TRACE_SWP(TXT("CServiceWidgetContentPublisher::NewLC() start") );

    CServiceWidgetContentPublisher* self =

        new (ELeave) CServiceWidgetContentPublisher(aObserver);

    CleanupStack::PushL(self);

    self->ConstructL();

    TRACE_SWP(TXT("CServiceWidgetContentPublisher::NewLC() End") );

    return self;

    }

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

// CServiceWidgetContentPublisher::ConstructL

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

// ConstructL is called by the application framework

void CServiceWidgetContentPublisher::ConstructL()

    {

    TRACE_SWP(TXT("CServiceWidgetContentPublisher::ConstructL() start") );

	iMsgInterface = GetMessagingInterfaceL();

	TRACE_SWP(TXT("CServiceWidgetContentPublisher::ConstructL() End") );

    }

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

// CServiceWidgetContentPublisher::~CServiceWidgetContentPublisher

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

CServiceWidgetContentPublisher::~CServiceWidgetContentPublisher()

    {

    TRACE_SWP(TXT("CServiceWidgetContentPublisher::~CServiceWidgetContentPublisher() start") );

    if( iMsgInterface )

    	{

		iMsgInterface->Close();

		iMsgInterface = NULL;

    	}

   	if( iServiceHandler )

    	{

    	iServiceHandler->Reset();

    	delete iServiceHandler;

    	iServiceHandler = NULL;

    	}

    TRACE_SWP(TXT("CServiceWidgetContentPublisher::~CServiceWidgetContentPublisher() End") );

    }

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

// CServiceWidgetContentPublisher::GetMessagingInterfaceL

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

MLiwInterface* CServiceWidgetContentPublisher::GetMessagingInterfaceL( )

	{

	TRACE_SWP(TXT("CServiceWidgetContentPublisher::GetMessagingInterfaceL() start") );

	if( !iServiceHandler )

		{

		iServiceHandler = CLiwServiceHandler::NewL();

		TRACE_SWP(TXT("CServiceWidgetContentPublisher::GetMessagingInterfaceL() CLiwServiceHandler created") );

		}

	CLiwGenericParamList* inParam = CLiwGenericParamList::NewL();

	CleanupStack::PushL( inParam );

	CLiwGenericParamList* outParam = CLiwGenericParamList::NewL();

	CleanupStack::PushL( outParam );

	CLiwCriteriaItem* crit = CLiwCriteriaItem::NewL( KLiwCmdAsStr, KCPContentInterface,

		KCPService  );

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

	RCriteriaArray array;

	array.AppendL(crit);    

	iServiceHandler->AttachL(array);

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

	delete crit;

	array.Reset();

	// find service interface

	TInt pos = 0;

	MLiwInterface* msgInterface = NULL;

	outParam->FindFirst( pos, KCPContentInterface );

	if ( pos != KErrNotFound ) 

	    {

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

	    }

	outParam->Reset();

	inParam->Reset();

	CleanupStack::PopAndDestroy( outParam );

	CleanupStack::PopAndDestroy( inParam );

	TRACE_SWP(TXT("CServiceWidgetContentPublisher::GetMessagingInterfaceL() End") );

	return msgInterface;

	}

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

// CServiceWidgetContentPublisher::HandleNotifyL

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

//  

TInt CServiceWidgetContentPublisher::HandleNotifyL( TInt aCmdId, TInt /*aEventId*/,

                                                    CLiwGenericParamList& aEventParamList,

                                                    const CLiwGenericParamList& /*aInParamList*/ 

                                                   )

    { 

    TRACE_SWP( TXT("CServiceWidgetContentPublisher::HandleNotifyL() start") );

    TInt pos(0);

    aEventParamList.FindFirst(pos, KChangeInfo);

    if (pos != KErrNotFound)

        {

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

        variant.PushL();

        const CLiwList* changeMapsList = variant.AsList();

        HBufC16* publisher  = NULL;       

        HBufC8* trigger = NULL;

        const TInt KSAPIContentNameMaxLength = 255;

        TBuf<KSAPIContentNameMaxLength> InstId;

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

            {

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

                {

                const CLiwMap* map  = variant.AsMap();

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

                    {

                    trigger = variant.AsData().AllocLC(); // trigger name                      

                    // In template case trigger name can be 

                    // active ,  resume , suspend ,inactive, deactive or item names.

                    }

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

                    {

                    publisher = variant.AsDes().AllocLC();  // ai3templatedwidget                                          

                    }

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

                    {

                    variant.Get( InstId );

                    }

                if( trigger && publisher )

                    {

                    iObserver.HandleServiceEventL( *publisher, *trigger, InstId);

                    }//

                if ( publisher )

                    {

                    CleanupStack::PopAndDestroy( publisher );

                    publisher = NULL;

                    }

                if ( trigger )

                    {

                    CleanupStack::PopAndDestroy( trigger );

                    trigger = NULL;

                    }  

                }

            }// loop

    CleanupStack::Pop(&variant);    //variant

    variant.Reset(); 

    }//if (pos != KErrNotFound)

  TRACE_SWP(TXT("CServiceWidgetContentPublisher::HandleNotifyL() end") );

  return aCmdId;

  }//End HandleNotifyL

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

// CServiceWidgetContentPublisher::RegisterWidgetL

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

//

void CServiceWidgetContentPublisher::RegisterWidgetL(const TDesC& aPublisherId,

                                                           TInt aBitmapHandle,

                                                           TInt aMaskHandle )

    {

    TRACE_SWP(TXT("CServiceWidgetContentPublisher::RegisterWidgetL() start") );

    if( iMsgInterface )

        {   

        CLiwGenericParamList* inparam = &(iServiceHandler->InParamListL());

        CLiwGenericParamList* outparam = &(iServiceHandler->OutParamListL());

        TLiwGenericParam type( KType, TLiwVariant( KPublisher ));

        inparam->AppendL( type );

        CLiwDefaultMap* cpdatamap = CLiwDefaultMap::NewLC();

        CLiwDefaultMap* datamap = CLiwDefaultMap::NewLC();

        CLiwDefaultMap* mapAction = CLiwDefaultMap::NewLC(); 

        cpdatamap->InsertL( KPublisherId, TLiwVariant( aPublisherId )); 

        cpdatamap->InsertL( KContentType, TLiwVariant( KTemplateWidget ));

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

        //Take widget name as "service name"

        //Give widget name here which will be displayed in HomeScreen Add Content menu        

        datamap->InsertL( KWidgetName, TLiwVariant( aPublisherId.Left( aPublisherId.Length()-KThemeUid().Length() ) ) );

        datamap->InsertL( KTemplateType, TLiwVariant( KServiceWidget )); 

        //To publish logo and widget description

        HBufC* text = NULL;

        text = StringLoader::LoadLC( R_QTN_SERVTAB_WIDGET_SERVDESC );

        datamap->InsertL(KWidgetDesc, TLiwVariant( *text ));

        CleanupStack::PopAndDestroy(text);//text

        datamap->InsertL(KWidgetLogo , TLiwVariant( aBitmapHandle ) ); // key - aKey, value - map (stringsMap)

        // append mask 

        // create mask key for the data item. Format is the image key with the '_mask' postfix.

        HBufC8* maskResult = HBufC8::NewLC( KWidgetLogo().Length() + KMask().Length() );

        TPtr8 maskResultPtr = maskResult ->Des();

        maskResultPtr .Append( KWidgetLogo );

        maskResultPtr .Append( KMask );

        datamap->InsertL( maskResultPtr,  TLiwVariant( aMaskHandle ) ); // key - aKey, value - map (stringsMap)

        CleanupStack::PopAndDestroy(maskResult);//maskResult

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

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

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

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

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

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

        // this will be called after clicking on widget, and generate "selected" event

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

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

        TLiwGenericParam textItem( KItem, TLiwVariant( cpdatamap ));        

        inparam->AppendL( textItem );

        iMsgInterface->ExecuteCmdL( KAdd , *inparam, *outparam);

        CleanupStack::PopAndDestroy(mapAction);

        CleanupStack::PopAndDestroy(datamap);

        CleanupStack::PopAndDestroy(cpdatamap);

        textItem.Reset();

        outparam->Reset();

        inparam->Reset(); 

        // request for active/deactive/suspend/resume notification 

        CLiwDefaultMap*  reqFilter = CLiwDefaultMap::NewLC();

        reqFilter->InsertL(KPublisherId, TLiwVariant( aPublisherId ));

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

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

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

        // fill in input list for RequestNotification command

        inparam->AppendL(TLiwGenericParam(KType, TLiwVariant(KPublisher)));

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

        iMsgInterface->ExecuteCmdL( KRequestNotification,

                                    *inparam,

                                    *outparam,

                                    0,

                                    this ) ;

        CleanupStack::PopAndDestroy(reqFilter );  

        outparam->Reset();

        inparam->Reset();

        TRACE_SWP(TXT("CServiceWidgetContentPublisher::RegisterWidgetL() Registered widget %s"), &aPublisherId );

        } 

    TRACE_SWP(TXT("CServiceWidgetContentPublisher::RegisterWidgetL() end") );

    }

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

// CServiceWidgetContentPublisher::UnregisterWidgetL

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

//

void CServiceWidgetContentPublisher::UnregisterWidgetL(const TDesC& aPublisherId )

    {

    TRACE_SWP(TXT("CServiceWidgetContentPublisher::UnregisterWidgetL() start") );

    TRACE_SWP(TXT("CServiceWidgetContentPublisher::UnregisterWidgetL() ServiceName %S"), &aPublisherId);

    CLiwGenericParamList* inparam = &(iServiceHandler->InParamListL()); 

    CLiwGenericParamList* outparam = &(iServiceHandler->OutParamListL());

    CLiwDefaultMap*  cpdatamap= CLiwDefaultMap::NewLC();

    cpdatamap->InsertL( KPublisherId, TLiwVariant( aPublisherId ));

    cpdatamap->InsertL( KContentType, TLiwVariant( KTemplateWidget ));

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

    // fill in input list for RequestNotification command

    inparam->AppendL(TLiwGenericParam(KType, TLiwVariant(KPublisher)));

    inparam->AppendL(TLiwGenericParam(KData, TLiwVariant(cpdatamap)));

    iMsgInterface->ExecuteCmdL(KDelete, *inparam, *outparam, 0, this );

    CleanupStack::PopAndDestroy(cpdatamap);      

    outparam->Reset();

    inparam->Reset();

    TRACE_SWP(TXT("CServiceWidgetContentPublisher::UnregisterWidget() end") );

    }//end UnregisterWidget

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

// CServiceWidgetContentPublisher::UnregisterAllWidgetsL

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

//

void CServiceWidgetContentPublisher::UnregisterAllWidgetsL(RArray<TInt>* aServiceArray)

    {

    TRACE_SWP(TXT("CServiceWidgetContentPublisher::UnregisterAllWidgetsL() start") );

    CDesC16ArrayFlat* servicesExisting = new (ELeave) CDesC16ArrayFlat( KSW_LIST_GRANULARITY );

    CleanupStack::PushL( servicesExisting );

    if(aServiceArray && aServiceArray->Count() > 0)

    	{

		CSPSettings* settings = CSPSettings::NewLC();

		for(TInt i=0; i<aServiceArray->Count();i++)

			{

			CSPEntry* entry = CSPEntry::NewLC();

			settings->FindEntryL( (*aServiceArray)[i], *entry ) ;			

			servicesExisting->AppendL(entry->GetServiceName());

			CleanupStack::PopAndDestroy(entry);

			}

		CleanupStack::PopAndDestroy(settings);

    	}

    CLiwGenericParamList* inparam = &(iServiceHandler->InParamListL()); 

    CLiwGenericParamList* outparam = &(iServiceHandler->OutParamListL());

    CLiwDefaultMap*  cpdatamap= CLiwDefaultMap::NewLC();    

    cpdatamap->InsertL( KPublisherId, TLiwVariant( KAll ));

    cpdatamap->InsertL( KContentType, TLiwVariant( KTemplateWidget ));

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

    // fill in input list for GetList command

    inparam->AppendL(TLiwGenericParam(KType, TLiwVariant(KPublisher)));

    inparam->AppendL(TLiwGenericParam(KData, TLiwVariant(cpdatamap)));    

    iMsgInterface->ExecuteCmdL(KGetList, *inparam, *outparam, 0, this );

    CDesC16ArrayFlat* serviceNames = new (ELeave) CDesC16ArrayFlat( KSW_LIST_GRANULARITY );

    CleanupStack::PushL( serviceNames );

    if(outparam)

		{		

		TInt pos(0);		

		outparam->FindFirst(pos,KResults);

		if(pos != KErrNotFound)

			{

			HBufC* uidStr = KThemeUid().AllocLC();

			TLiwVariant variant = (*outparam)[pos].Value();

			variant.PushL();

			CLiwIterable* iterable = variant.AsIterable();

			iterable->Reset();

			while ( iterable->NextL( variant ) )

			  {

			  CLiwDefaultMap *map = CLiwDefaultMap::NewLC();

			  variant.Get( *map );

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

				  {				  

				  if(variant.AsDes().Length() >= KThemeUid().Length())

					  {

					  TPtrC tempUidStr;

					  tempUidStr.Set(variant.AsDes().Right(KThemeUid().Length()));

					  if( 0 == tempUidStr.Compare(uidStr->Des()))

						  {

						  //If publisher id has KThemeUid, then this services is 

						  //registered by this component

						  TBool serviceExisting = EFalse;

						  if(servicesExisting && servicesExisting->Count() > 0)

							  {							  

							  for(TInt i=0; i<servicesExisting->Count(); i++)

								  {

								  TPtrC serviceName;

								  serviceName.Set(variant.AsDes().Left(variant.AsDes().Length()-KThemeUid().Length()));								  

								  if(serviceName.Compare((*servicesExisting)[i]) == 0)

									  {

									  serviceExisting = ETrue;

									  break;

									  }

								  }							  

							  }

						  if(!serviceExisting)

							  {

							  serviceNames->AppendL(variant.AsDes());

							  }

						  }

					  }

				  }

				  CleanupStack::PopAndDestroy( map );

				 } //End of while

			CleanupStack::PopAndDestroy( &variant );

			CleanupStack::PopAndDestroy( uidStr );

			} //End of if(pos != KErrNotFound)

		}

    TRACE_SWP(TXT("CServiceWidgetContentPublisher::UnregisterAllWidgetsL():ServiceCountForDeletion %d"), serviceNames->Count());

    for(TInt i=0; i<serviceNames->Count();i++)

		{		

		UnregisterWidgetL((*serviceNames)[i]);

		}

    CleanupStack::PopAndDestroy(serviceNames);

    CleanupStack::PopAndDestroy(cpdatamap);

    CleanupStack::PopAndDestroy(servicesExisting);

    outparam->Reset();

    inparam->Reset();

    TRACE_SWP(TXT("CServiceWidgetContentPublisher::UnregisterAllWidgetsL() end") );

    }

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

// CServiceWidgetContentPublisher::RemoveWidgetDataL

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

// 

void CServiceWidgetContentPublisher::RemoveWidgetDataL(const TDesC& aPublisherId, const TDesC& aInstId)

    {

    TRACE_SWP(TXT("CServiceWidgetContentPublisher::RemoveWidgetData() start") );

    CLiwGenericParamList* inparam = &(iServiceHandler->InParamListL());

    CLiwGenericParamList* outparam = &(iServiceHandler->OutParamListL());

    CLiwDefaultMap* cpdatamap = CLiwDefaultMap::NewLC();

    cpdatamap->InsertL( KPublisherId, TLiwVariant( aPublisherId ));

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

    cpdatamap->InsertL( KContentId, TLiwVariant( aInstId ));

    // fill in input list for RequestNotification command

    inparam->AppendL(TLiwGenericParam(KType, TLiwVariant(KCpData)));

    inparam->AppendL(TLiwGenericParam(KData, TLiwVariant(cpdatamap)));

    TInt err = KErrNone;

    // if you have only one combination of publisher,content_type, contenid 

    // then all the items will be remove from your widget

    TRAP(err,iMsgInterface->ExecuteCmdL( KDelete , *inparam, *outparam, 0 , this));

    CleanupStack::PopAndDestroy( cpdatamap );

    outparam->Reset();

    inparam->Reset();

    TRACE_SWP(TXT("CServiceWidgetContentPublisher::RemoveWidgetData() end") );

    }

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

// CServiceWidgetContentPublisher::PublishDataWithActionL

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

// 

void CServiceWidgetContentPublisher::PublishDataWithActionL( const TDesC& aPublisherId,

                                                             const TDesC& aInstId,

                                                             const TDesC& aOwnTextToAdd, 

                                                             const TDesC& aStatusTextToAdd,

                                                             TInt aBitmapHandle,

                                                             TInt aMaskHandle,

                                                             TInt aSericonbitmapHandle, 

                                                             TInt aSericonmaskHandle

													         )

    {

    TRACE_SWP(TXT("CServiceWidgetContentPublisher::PublishDataWithActionL() start") );

    CLiwGenericParamList* inparam = &(iServiceHandler->InParamListL());

    CLiwGenericParamList* outparam = &(iServiceHandler->OutParamListL());

    inparam->Reset();

    outparam->Reset();

    if( iMsgInterface )

        {

         TLiwGenericParam type( KType,TLiwVariant(KCpData));

         inparam->AppendL( type );

         CLiwDefaultMap* cpdatamap = CLiwDefaultMap::NewLC();

         CLiwDefaultMap* datamap = CLiwDefaultMap::NewLC();

         cpdatamap->InsertL( KPublisherId, TLiwVariant( aPublisherId ));

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

         cpdatamap->InsertL( KContentId, TLiwVariant( aInstId ));

         //adding data to the map

         //add service icon data

         datamap->InsertL(KServiceImageKey , TLiwVariant( aSericonbitmapHandle ) ); // key - aKey, value - map (stringsMap)

         // append mask 

         // create mask key for the data item. Format is the image key with the '_mask' postfix.

         HBufC8* maskResult1 = HBufC8::NewLC( KServiceImageKey().Length() + KMask().Length() );

         TPtr8 maskResultPtr1 = maskResult1 ->Des();

         maskResultPtr1.Append( KServiceImageKey );

         maskResultPtr1.Append( KMask );

         datamap->InsertL( maskResultPtr1,  TLiwVariant( aSericonmaskHandle ) ); // key - aKey, value - map (stringsMap)

         CleanupStack::PopAndDestroy(maskResult1);//maskResult 

         //Add status icon data

         datamap->InsertL(KStatusIconKey , TLiwVariant( aBitmapHandle ) ); // key - aKey, value - map (stringsMap)

         // append mask 

         // create mask key for the data item. Format is the image key with the '_mask' postfix.