/*

* Copyright (c) 2005-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:  Plug-in main class

*

*/

#include <liwservicehandler.h>

#include <liwvariant.h>

#include <liwgenericparam.h>

#include "sapidata.h"

#include "sapidataobserver.h"

#include "sapidatapluginconst.h"

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

// Constructor

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

//

CSapiDataObserver::CSapiDataObserver ()

    {

    }

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

// Destructor

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

//

CSapiDataObserver ::~CSapiDataObserver ()

    {

    iInterface = NULL;

    iData = NULL;

    }

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

// Register for notifications

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

//

void CSapiDataObserver::RegisterL( CLiwDefaultMap* aFilter, const TDesC& aRegistry )

    {

    CLiwGenericParamList* inParamList = CLiwGenericParamList::NewL();

    CleanupStack::PushL( inParamList );

    CLiwGenericParamList* outParamList = CLiwGenericParamList::NewL();

    CleanupStack::PushL( outParamList );

    // Fill in input list for RequestNotification command

    inParamList->AppendL(TLiwGenericParam(KType,TLiwVariant(aRegistry)));

    inParamList->AppendL(TLiwGenericParam(KFilter ,TLiwVariant(aFilter)));

    iError = KErrNone;

    TRAP( iError, iInterface->ExecuteCmdL( 

                KRequestNotification,

                *inParamList,

                *outParamList,

                0,

                this ) );

    CleanupStack::PopAndDestroy( outParamList );

    CleanupStack::PopAndDestroy( inParamList ); 

    }

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

// Sing off to notification

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

//

void CSapiDataObserver ::ReleaseL()

    {

    if( iInterface )

        {

        CLiwGenericParamList* inParamList = CLiwGenericParamList::NewL();

        CleanupStack::PushL( inParamList );

        CLiwGenericParamList* outParamList = CLiwGenericParamList::NewL();

        CleanupStack::PushL( outParamList );

        TInt err(KErrNone);

        TRAP(err, iInterface->ExecuteCmdL( 

                KRequestNotification,

                *inParamList,

                *outParamList,

                KLiwOptCancel,

                this ));

        CleanupStack::PopAndDestroy( outParamList );

        CleanupStack::PopAndDestroy( inParamList );

        }

    }

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

// Factory method construction

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

//

CSapiDataObserver * CSapiDataObserver::NewL( MLiwInterface* aInterface, CSapiData* aData )

    {

    CSapiDataObserver * self = new (ELeave) CSapiDataObserver();

    CleanupStack::PushL( self );

    self->ConstructL( aInterface, aData );

    CleanupStack::Pop( self );

    return self;    

    }

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

// 2n phase constructor

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

//

void CSapiDataObserver::ConstructL( MLiwInterface* aInterface, CSapiData* aData )

    {

    iData = aData;

    iInterface = aInterface;

    }

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

// Handles Published content notification

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

//

TInt CSapiDataObserver::HandleNotifyL(

        TInt aErrorCode,

        TInt /*aEventId*/,

        CLiwGenericParamList& aEventParamList,

        const CLiwGenericParamList& /*aInParamList*/ )

    {

    // Is plugin active to refresh the published data

	iError = aErrorCode;        

	TInt count(0);

	TInt pos(0);

	const TLiwGenericParam* param(NULL);

	CLiwDefaultList* listOfMaps = CLiwDefaultList::NewLC();

	param = aEventParamList.FindFirst(pos,KChangeInfo);

	if( param )

		{

		 User::LeaveIfError( param->Value().Get( *listOfMaps ) );

		 count = listOfMaps->Count();

		}

	TLiwVariant variant;

	// Extract the data from the map 

	for(TInt i = 0;i < count; i++)

		{

		listOfMaps->AtL(i,variant);

		HBufC* operation = NULL;

		CLiwDefaultMap *map = CLiwDefaultMap::NewLC();

		variant.Get( *map );

		TBool found;

		found = map->FindL( KOperation, variant );

		if (found)

		   {

		   operation = variant.AsDes().AllocLC();

		   }

		variant.Reset();

		if( operation && ( operation->Des() != KOperationExecute ) )

		   {

		   // Nothing to update for execute action

		   HBufC* publisher = NULL; 

		   HBufC* contentType = NULL;

		   HBufC* contentId = NULL;

		   found = map->FindL( KPublisherId, variant );

		   if (found)

			   {

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

			   }

		   variant.Reset();

		   found = map->FindL( KFLAG, variant );

		   if ( found)

			   {

			   // notification from publisher registry

			  if ( operation->Des() !=  KOperationDelete )

				  {

				  iData->UpdatePublisherStatusL( *publisher );

				  }

			   }

		   else if ( iData->IsPluginActive() ) 

			   { 

			   // notification from content registry

			   found = map->FindL( KContentType, variant );

			   if (found)

				  {

				  contentType = variant.AsDes().AllocLC();

				  }

			   variant.Reset();

			   found = map->FindL( KContentId, variant );

			   if (found)

				  {

				  contentId = variant.AsDes().AllocLC();

				  }

			   variant.Reset();

			   iData->RefreshL( *publisher, *contentType, *contentId, *operation );

			   if ( contentId )

				   {

				   CleanupStack::PopAndDestroy( contentId );

				   }

			  if ( contentType )

				   {

				   CleanupStack::PopAndDestroy( contentType );

				   }

			   }

		   else

			   {

			   // remember update if plugin is in suspend mode

			   iData->SetUpdateNeeded( ETrue );

			   }

			variant.Reset();

			 if ( publisher )

			   {

			   CleanupStack::PopAndDestroy( publisher );

			   }

		   }

		if ( operation )

			{

			CleanupStack::PopAndDestroy( operation );

			}

		CleanupStack::PopAndDestroy( map );

		}

	CleanupStack::PopAndDestroy( listOfMaps );

    return aErrorCode;

    }