/*

* 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:  Updates CPS storage

*

*/

// INCLUDE FILES

#include "mcpharvesterpublisherobserver.h"

#include "musiccontentpublisher.h"

#include "sapidatapluginconst.h"

#include <liwservicehandler.h>

#include <liwvariant.h>

#include <liwgenericparam.h>

_LIT( KPublisher, "publisher" );

_LIT8( KCPContentInterface, "IContentPublishing" );

_LIT8( KCPService, "Service.ContentPublishing" );

_LIT( KMyOperationExecute, "execute" );

// =============================================================================

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

// Cleanup utility for RPointerArray

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

//

static void DoCleanup( TAny* aPtr )

    {

    __ASSERT_DEBUG( aPtr, User::Invariant() );

    static_cast< RCriteriaArray* >( aPtr )->ResetAndDestroy();

    }

// ============================ MEMBER FUNCTIONS ==============================

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

// Constructor

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

//

CMCPHarvesterPublisherObserver::CMCPHarvesterPublisherObserver( CMusicContentPublisher* aHarvester )

    : iHarvester( aHarvester )

	{

	}

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

// Two-phased constructor.

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

//

CMCPHarvesterPublisherObserver* CMCPHarvesterPublisherObserver::NewL( 

        CMusicContentPublisher* aHarvester )

    {

    CMCPHarvesterPublisherObserver* self = CMCPHarvesterPublisherObserver::NewLC( aHarvester ) ;

    CleanupStack::Pop( self );

    return self;

    }

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

CMCPHarvesterPublisherObserver* CMCPHarvesterPublisherObserver::NewLC( 

        CMusicContentPublisher* aHarvester )

    {

    CMCPHarvesterPublisherObserver* self( 

        new( ELeave ) CMCPHarvesterPublisherObserver( aHarvester ) );

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

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

// Destructor

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

//

CMCPHarvesterPublisherObserver::~CMCPHarvesterPublisherObserver()

    {

    ReleaseLiw();

    }

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

// Symbian 2nd phase constructor can leave.

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

//

void CMCPHarvesterPublisherObserver::ConstructL()

    {

    InitLiwL();

    }

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

// Handles Published content notification

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

//

TInt CMCPHarvesterPublisherObserver::HandleNotifyL( 

    TInt /*aErrorCode */, 

    TInt /*aEventId*/,

    CLiwGenericParamList& aEventParamList, 

    const CLiwGenericParamList& /*aInParamList*/ )

    {

    //__UHEAP_MARK;

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

        TPtrC publisher;

        TPtrC operation;

        TPtrC8 trigger;

        // Iter through list content

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

            {

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

                 {

                 const CLiwMap* map  = variant.AsMap();

                 // Check what triggered a notification

                 variant.Reset();

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

                     {

                     operation.Set( variant.AsDes()); 

                     }

                 if ( operation == KMyOperationExecute )

                     {

                     variant.Reset();

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

                         {

                         trigger.Set( variant.AsData()); 

                         }

                     TLiwVariant pubVariant;

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

                         {

                         publisher.Set( pubVariant.AsDes());

                         }

                     pubVariant.PushL();

                     if( publisher.Length() && trigger.Length())

                         {

                         iHarvester->HandlePublisherNotificationL( publisher, trigger );

                         }

                     CleanupStack::PopAndDestroy( &pubVariant );

                     }

                 }

            }

        CleanupStack::PopAndDestroy( &variant );

        }

    //__UHEAP_MARKEND;

    return KErrNone;

    }

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

// Register for notifications

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

//

void CMCPHarvesterPublisherObserver::RegisterL( CLiwDefaultMap* aFilter )

    {

    CLiwGenericParamList* inParamList( CLiwGenericParamList::NewLC() );

    CLiwGenericParamList* outParamList( CLiwGenericParamList::NewLC() );

    // Fill in input list for RequestNotification command

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

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

    iError = KErrNone;

    TRAP( iError, iInterface->ExecuteCmdL( 

                KRequestNotification,

                *inParamList,

                *outParamList,

                0,

                this ) );

    CleanupStack::PopAndDestroy( outParamList );

    CleanupStack::PopAndDestroy( inParamList ); 

    }

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

// CWidgetUiWindowManager::FindObserver

//

// Init LIW interface.

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

void CMCPHarvesterPublisherObserver::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,

            KCPContentInterface, 

            KCPService );

        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, KCPContentInterface );

        User::LeaveIfError( error );

        iInterface = (*out)[ error ].Value().AsInterface();

        CleanupStack::PopAndDestroy( 3 );

        }

    }

void CMCPHarvesterPublisherObserver::ReleaseLiw()

    {    

    if ( iInterface )

        {

        iInterface->Close();

        iInterface = NULL;

        }

    delete iLiwHandler;

    iLiwHandler = NULL;

    }

 //  End of File