/*
* Copyright (c) 2007 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:   Implements an observer to CPS
*
*/


// INCLUDE FILES
#include <LiwCommon.h>
#include <LiwServiceHandler.h>
#include <LiwVariant.h>
#include <LiwGenericParam.h>

#include "cpsobserver.h"
#include "cpswrapper.h"
#include "cpsconst.h"

namespace cpswrapper
    {
	
	// =============================================================================
	// --------------------------------------------------------------------------
	// Cleanup utility for RPointerArray
	// --------------------------------------------------------------------------
	//
	static void DoCleanup( TAny* aPtr )
		{
		__ASSERT_DEBUG( aPtr, User::Invariant() );
		static_cast< RCriteriaArray* >( aPtr )->ResetAndDestroy();
		}
	
	// ============================ MEMBER FUNCTIONS ==============================
	
	// ----------------------------------------------------------------------------
	// Constructor
	// ----------------------------------------------------------------------------
	//
	CCpsObserver::CCpsObserver( CCpsWrapper* aCpsWrapper )
		: iCpsWrapper( aCpsWrapper )
		{
		}
	
	// ----------------------------------------------------------------------------
	// Two-phased constructor.
	// ----------------------------------------------------------------------------
	//
	CCpsObserver* CCpsObserver::NewLC( CCpsWrapper* aCpsWrapper )
		{
		CCpsObserver* self( 
			new( ELeave ) CCpsObserver( aCpsWrapper ) );
			
		CleanupStack::PushL( self );
		self->ConstructL();
		return self;
		}
	
	// ---------------------------------------------------------------------------
	// Destructor
	// ---------------------------------------------------------------------------
	//
	CCpsObserver::~CCpsObserver()
		{
		ReleaseL();
		ReleaseLiw();
		}
	
	// ----------------------------------------------------------------------------
	// Symbian 2nd phase constructor can leave.
	// ----------------------------------------------------------------------------
	//
	void CCpsObserver::ConstructL()
		{
		InitLiwL();
		}
	
	// ---------------------------------------------------------------------------
	// CCpsObserver::HandleNotifyL
	//
	// Handles Published content notification
	// ---------------------------------------------------------------------------
	//
	TInt CCpsObserver::HandleNotifyL( 
		TInt /*aErrorCode */, 
		TInt /*aEventId*/,
		CLiwGenericParamList& aEventParamList, 
		const CLiwGenericParamList& /*aInParamList*/ )
		{
	    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() );

			// Iter through list content
			for ( TInt i = 0; i < changeMapsList->Count(); ++i )
				{
				TLiwVariant changeMap;
				changeMap.PushL();
				if ( changeMapsList->AtL( i, changeMap ) )
					{
					const CLiwMap* map = changeMap.AsMap();

					if ( map->FindL( KContentType, changeMap ) )
						{
						HBufC* publisher = NULL;
						HBufC* contentType = NULL;
						
						contentType = changeMap.AsDes().AllocLC();
						if ( KHSTemplate() == contentType &&
							 map->FindL( KPublisher, changeMap ) )
							{
                            publisher = changeMap.AsDes().AllocLC();

                            if ( map->FindL( KOperation, changeMap ) )
                                {
                                HBufC* operation = changeMap.AsDes().AllocLC();
                                
                                // unregitered publisher's widget
                                // from home screen if exist or add
                                // new widget to widgetmanager
                                iCpsWrapper->HandleChangedPublisherL( *publisher,
                                        *operation );
                                CleanupStack::PopAndDestroy( operation );
                                }
							CleanupStack::PopAndDestroy( publisher );
							}
						else if( KWRTTemplate() == contentType  &&
								  map->FindL( KContentId, changeMap ) )
							 {
                             publisher = changeMap.AsDes().AllocLC();
                             if ( map->FindL( KOperation, changeMap ) )
                                 {
                                 HBufC* operation = changeMap.AsDes().AllocLC();
                                 
                                 // unregitered publisher's widget
                                 // from home screen if exist or add
                                 // new widget to widgetmanager
                                 iCpsWrapper->HandleChangedPublisherL( *publisher,
                                         *operation );
                                 CleanupStack::PopAndDestroy( operation );
                                 }
                             CleanupStack::PopAndDestroy( publisher );
							 }
						CleanupStack::PopAndDestroy( contentType );
						}
					}
				CleanupStack::PopAndDestroy( &changeMap );
				}

			CleanupStack::PopAndDestroy( &variant );
			}
		return KErrNone;
		}
	
	// ---------------------------------------------------------------------------
	// CCpsObserver::RegisterL
	//
	// Register for notifications
	// ---------------------------------------------------------------------------
	//
	void CCpsObserver::RegisterL( CLiwDefaultMap* aFilter, const TDesC& aRegistry )
		{
		CLiwGenericParamList* inParamList( CLiwGenericParamList::NewLC() );
		CLiwGenericParamList* outParamList( CLiwGenericParamList::NewLC() );
		
		// Fill in input list for RequestNotification command
		inParamList->AppendL(TLiwGenericParam(KType,TLiwVariant( aRegistry )));
		inParamList->AppendL(TLiwGenericParam(KFilter ,TLiwVariant( aFilter )));
			
		iInterface->ExecuteCmdL( KRequestNotification,  *inParamList,
											 *outParamList, 0, this );
		
		CleanupStack::PopAndDestroy( outParamList );
		CleanupStack::PopAndDestroy( inParamList ); 
		}
	
	// ---------------------------------------------------------------------------
	// CCpsObserver::ReleaseL
	//
	// Sing off to notification
	// ---------------------------------------------------------------------------
	//
	void CCpsObserver::ReleaseL()
		{
		if( iInterface )
			{
			CLiwGenericParamList* inParamList = CLiwGenericParamList::NewL();
			CleanupStack::PushL( inParamList );
			CLiwGenericParamList* outParamList = CLiwGenericParamList::NewL();
			CleanupStack::PushL( outParamList );
			
			iInterface->ExecuteCmdL( KRequestNotification, *inParamList, *outParamList,
													 KLiwOptCancel, this );
	
			CleanupStack::PopAndDestroy( outParamList );
			CleanupStack::PopAndDestroy( inParamList );
			}
		}
	
	
	// ------------------------------------------------------------------------
	// CCpsObserver::InitLiwL
	//
	// Init LIW interface.
	// ------------------------------------------------------------------------
	void CCpsObserver::InitLiwL()
		{
		if ( !iLiwHandler )
			{
			TInt error( KErrNone );
			CLiwGenericParamList* in( NULL );
			CLiwGenericParamList* out( NULL );
			CLiwCriteriaItem* criterion( NULL );
	
			RCriteriaArray array( 1 );
			TCleanupItem cleanup( DoCleanup, &array );
			CleanupStack::PushL( cleanup );
	
			// Do the basic initialization.
			iLiwHandler = CLiwServiceHandler::NewL();
	
			// Get iCPSIface.
			in = CLiwGenericParamList::NewLC();
			out = CLiwGenericParamList::NewLC();
	
			criterion = CLiwCriteriaItem::NewL( 
				KLiwCmdAsStr,
				KCPSConfigurationIf, 
				KCPS );
				
			error = array.Append( criterion );
			if ( error )
				{
				delete criterion; 
				criterion = NULL;
				User::Leave( error );
				}
	
			criterion->SetServiceClass( TUid::Uid( KLiwClassBase ) );
				
			iLiwHandler->AttachL( array );
			iLiwHandler->ExecuteServiceCmdL( *criterion, *in, *out ); 
	
			out->FindFirst( error, KCPSConfigurationIf );
			User::LeaveIfError( error );
	
			iInterface = (*out)[ error ].Value().AsInterface();
	
			CleanupStack::PopAndDestroy( 3 );
			}
		}
	
	// ---------------------------------------------------------------------------
	// CCpsObserver::ReleaseLiw
	// ---------------------------------------------------------------------------
	//
	void CCpsObserver::ReleaseLiw()
		{    
		if ( iInterface )
			{
			iInterface->Close();
			iInterface = NULL;
			}
			
		delete iLiwHandler;
		iLiwHandler = NULL;
		}
}
 //  End of File