/*

* Copyright (c) 2007, 2008 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of the License "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:  

*

*/

// INCLUDE FILES

#include "wrtharvester.h"

#include "wrtharvesterregistryaccess.h"

#include "wrtharvesterpsnotifier.h"

#include "wrtharvesterpublisherobserver.h"

#include "wrtharvesterconst.h"

#include <widgetregistryconstants.h>

#include <implementationproxy.h>

#include <LiwServiceHandler.h>

#include <LiwVariant.h>

#include <LiwGenericParam.h>

#include <e32property.h>    //Publish & Subscribe

#include <AknTaskList.h>

#include <apaid.h>

#include <apacmdln.h>

#include <s32mem.h>

// TODO Check these types, should they be definedin sapidatapluginconst.h?

_LIT( KTemplatedWidget, "ai3templatedwidget");

_LIT8( KMySelected, "selected");

_LIT8( KMyActionMap, "action_map" );

_LIT8( KMyItem, "item" );

_LIT8( KMyAdd, "Add" );

_LIT8( KMyDelete, "Delete" );

_LIT8( KMyItemId, "item_id" );

_LIT8( KMyImage, "image" ); 

_LIT( KMyContType, "wideimage" );

_LIT8( KMyResultName,"mydata" );

_LIT( KMyActionName, "data" );

// ============================= LOCAL FUNCTIONS ===============================

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

// ta

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

//

static HBufC* GetAppNameLC( RApaLsSession& aSession, const TUid& aUid )

    {

    TApaAppInfo info;

    User::LeaveIfError( aSession.GetAppInfo( info, aUid ) );

    return info.iFullName.AllocLC();

    }

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

// 

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

//

static void HandleWidgetCommandL( 

    RApaLsSession& aSession, 

    const TDesC& aWidget,

    const TUid& aUid,

    TUint32 aOperation )

    {

    const TInt size( 2* aWidget.Length() + 3*sizeof( TUint32 ) );

    // Message format is <filenameLength><unicode_filename><someintegervalue>

    CApaCommandLine* cmd( CApaCommandLine::NewLC() );

    HBufC8* opaque( HBufC8::NewLC( size ) );

    RDesWriteStream stream;

    TPtr8 des( opaque->Des() );

    stream.Open( des );

    CleanupClosePushL( stream );

    // Generate the command.

    stream.WriteUint32L( aUid.iUid );

    stream.WriteUint32L( aWidget.Length() );

    stream.WriteL( reinterpret_cast< const TUint8* >( aWidget.Ptr() ),

                   aWidget.Size() );

    stream.WriteInt32L( aOperation );

    CleanupStack::PopAndDestroy( &stream );

    // Generate command.

    cmd->SetCommandL( EApaCommandBackgroundAndWithoutViews );

    cmd->SetOpaqueDataL( *opaque );    

    CleanupStack::PopAndDestroy( opaque );

    cmd->SetExecutableNameL( KLauncherApp );

    User::LeaveIfError( aSession.StartApp( *cmd ) );

    CleanupStack::PopAndDestroy( cmd );

    }

// Map the interface UIDs to implementation factory functions

const TImplementationProxy ImplementationTable[] = 

    {

    IMPLEMENTATION_PROXY_ENTRY( 0xA12345FE, CWrtHarvester::NewL )

    };

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

// Exported proxy for instantiation method resolution

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

//

EXPORT_C const TImplementationProxy* ImplementationGroupProxy(

                                                TInt& aTableCount )

    {

    aTableCount = sizeof(ImplementationTable) / sizeof(TImplementationProxy);

    return ImplementationTable;

    }

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

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

// Constructor

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

//

CWrtHarvester::CWrtHarvester( MLiwInterface* aCPSInterface ):

    iCPSInterface( aCPSInterface )

	{

	}

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

// Symbian 2nd phase constructor can leave.

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

//

void CWrtHarvester::ConstructL()

    {

    User::LeaveIfError( iApaSession.Connect() );

    iWidgetUIListener = CWrtHarvesterPSNotifier::NewL( this, EWidgetUIState );

    iWidgetRegListener = CWrtHarvesterPSNotifier::NewL( this, EWidgetRegAltered );

    iWidgetMMCListener =  CWrtHarvesterPSNotifier::NewL( this, EWidgetMMCAltered );

    }

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

// Two-phased constructor.

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

//

CWrtHarvester* CWrtHarvester::NewL(  MLiwInterface* aCPSInterface )

    {

    CWrtHarvester* self = new ( ELeave ) CWrtHarvester( aCPSInterface );

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    return self;

    }

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

// Destructor

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

//

CWrtHarvester::~CWrtHarvester()

    {

    iObservers.ResetAll();

    delete iWidgetUIListener;

    delete iWidgetRegListener;

    delete iWidgetMMCListener;

    iWidgetUids.Close();

    iApaSession.Close();

    }

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

// 

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

//	

void CWrtHarvester::UpdateL() 

	{

	UpdatePublishersL();

	} 

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

// 

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

//  

void CWrtHarvester::HandlePublisherNotificationL( const TDesC& aContentId, const TDesC8& aTrigger )

    {

    TUid uid( iRegistryAccess.WidgetUid( aContentId ) );

    if( aTrigger == KActive() )

        {

        StartWidgetL( uid );

        }

    else

        {

        TWidgetOperations operation( Uninitialized );

        if ( aTrigger == KDeActive )

            {

            operation = Deactivate;

            }

        else if( aTrigger == KSuspend )

            {

            operation = WidgetSuspend;

            }

        else if( aTrigger == KResume )

            {

            operation = WidgetResume;

            }

        else if( aTrigger == KMySelected )

            {

            operation = WidgetSelect;

            }

        LaunchWidgetL( operation, uid );

        }

    }

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

// 

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

//

void CWrtHarvester::UpdatePublishersL() 

    {

    RPointerArray< HBufC > bundleNames;

    // The array contain references.

    CleanupClosePushL( bundleNames );

    iRegistryAccess.WidgetBundleNamesL( bundleNames );

    // Remove observer and CPS registry entry of uninstalled widget

    for( TInt i = 0; i < iObservers.Count(); i++ )

        {

        TBool found( EFalse );

        for( TInt j = 0; j < bundleNames.Count(); j++ )

            {

            if( iObservers[i]->Name() == bundleNames[j] )

                {

                found = ETrue;

                break;

                }

            }

        if( found == EFalse )

            {

            RemovePublisherL( KTemplatedWidget, iObservers[i]->Name(), KMyContType );

            delete iObservers[i];

            iObservers.Remove( i );

            }

        }

    for( TInt i = bundleNames.Count() - 1; i >= 0; --i )

        {

        TInt id = RegisterPublisherL( 

            KTemplatedWidget,

            *( bundleNames[ i ] ), 

            KMyContType, 

            KMyImage );

        if( id != KErrNotFound )

            {

            RequestForNotificationL( KTemplatedWidget, *( bundleNames[ i ] ), KMyContType );

            }

        }

    CleanupStack::PopAndDestroy( &bundleNames ); 

    }

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

// 

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

//

TInt CWrtHarvester::RegisterPublisherL( 

    const TDesC& aPublisherId, 

    const TDesC& aContentId,

    const TDesC& aContentType, 

    const TDesC8& aResultType )

    {

    TInt id( KErrNotFound );

    if( iCPSInterface )

        {   

        CLiwGenericParamList* inparam( CLiwGenericParamList::NewLC() );

        CLiwGenericParamList* outparam( CLiwGenericParamList::NewLC() );

        TLiwGenericParam type( KType, TLiwVariant( KPubData ));

        inparam->AppendL( type );

        CLiwDefaultMap* cpdatamap = CLiwDefaultMap::NewLC();

        CLiwDefaultMap* datamap = CLiwDefaultMap::NewLC();

        CLiwDefaultMap* actionmap( NULL );

        // Create the data map for publisher registry

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

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

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

        datamap->InsertL( KMyResultName, TLiwVariant( aResultType ));

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

        // Create the action map for publisher registry

        actionmap = CLiwDefaultMap::NewLC();

        actionmap->InsertL(KActive, TLiwVariant( KMyActionName ));

        actionmap->InsertL(KDeActive, TLiwVariant( KMyActionName ));

        actionmap->InsertL(KSuspend, TLiwVariant( KMyActionName ));

        actionmap->InsertL(KResume, TLiwVariant( KMyActionName ));

        actionmap->InsertL(KMySelected, TLiwVariant( KMyActionName ));

        cpdatamap->InsertL( KMyActionMap, TLiwVariant(actionmap));

        CleanupStack::PopAndDestroy( actionmap );

        TLiwGenericParam item( KMyItem, TLiwVariant( cpdatamap ));        

        inparam->AppendL( item );

        iCPSInterface->ExecuteCmdL( KMyAdd , *inparam, *outparam);

        id = ExtractItemId(*outparam);

        CleanupStack::PopAndDestroy( datamap );

        CleanupStack::PopAndDestroy( cpdatamap );

        item.Reset();

        type.Reset();   

        CleanupStack::PopAndDestroy(outparam);

        CleanupStack::PopAndDestroy(inparam);

        }   

    return id;

    }

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

// 

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

//

void CWrtHarvester::RemovePublisherL( const TDesC& aPublisherId, const TDesC& aContentId,

        const TDesC& aContentType )

    {

    if( iCPSInterface )

        {

        CLiwGenericParamList* inparam = CLiwGenericParamList::NewLC();

        CLiwGenericParamList* outparam = CLiwGenericParamList::NewLC();

        TLiwGenericParam type( KType, TLiwVariant( KPubData ));

        inparam->AppendL( type );

        CLiwDefaultMap* cpdatamap = CLiwDefaultMap::NewLC();

        CLiwDefaultMap* datamap = CLiwDefaultMap::NewLC();

        // Create data map

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

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

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

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

        TLiwGenericParam item( KMyItem, TLiwVariant( cpdatamap ));        

        inparam->AppendL( item );

        iCPSInterface->ExecuteCmdL( KMyDelete , *inparam, *outparam);

        CleanupStack::PopAndDestroy( datamap );

        CleanupStack::PopAndDestroy( cpdatamap );

        item.Reset();

        type.Reset();

        CleanupStack::PopAndDestroy(outparam);

        CleanupStack::PopAndDestroy(inparam);

        }

    }

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

// 

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

//

void CWrtHarvester::RequestForNotificationL( const TDesC& aPublisherId, const TDesC& aContentId,

        const TDesC& aContentType )

    {

    // Preventing duplicate entries.

    for( TInt i = 0; i < iObservers.Count(); i++ )

        {

        if( iObservers[i]->Name() == aContentId )

            {

            return;

            }

        }

    CWrtHarvesterPublisherObserver* observer( NULL );

    CLiwDefaultMap* filter = CLiwDefaultMap::NewLC();

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

    filter->InsertL( KContentId, TLiwVariant( aContentId ) );

    filter->InsertL( KContentType, TLiwVariant( aContentType ) );

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

    observer = CWrtHarvesterPublisherObserver::NewLC( aContentId, this );

    observer->RegisterL(filter);

    iObservers.AppendL( observer );

    CleanupStack::Pop( observer );

    CleanupStack::PopAndDestroy(filter);

    }

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

// 

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

//

void CWrtHarvester::StartWidgetL( TUid aUid )

    {

    iWidgetUids.Append( aUid );

    TryLaunchNextWidgetL();

    }

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

// 

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

//

void CWrtHarvester::TryLaunchNextWidgetL()

    {

    TInt value = KErrNone;

    TInt error = iWidgetUIListener->GetValue(value);

    if( error == KErrNone && value == 1 && iWidgetUids.Count() != 0 )

        {

        // Set value to 0 so that next widget is not launched before Widget App sets value to 1.

        iWidgetUIListener->SetValue( 0 );

        //Always launch the first widget

        LaunchWidgetL( LaunchMiniview, iWidgetUids[0] );

        iWidgetUids.Remove( 0 );

        }

    }

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

// 

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

//

TInt CWrtHarvester::ExtractItemId( const CLiwGenericParamList& aInParamList )

    {

    TInt result ( KErrNotFound );

    TInt pos( 0 );

    aInParamList.FindFirst( pos, KMyItemId );

    if( pos != KErrNotFound )

        {

        // item id present - extract and return

        TUint uResult = 0;

        if ( aInParamList[pos].Value().Get( uResult ) )

            {

            result = uResult;

            }

        }

    return result;

    }

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

// 

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

//

void CWrtHarvester::LaunchWidgetL( TWidgetOperations aOperation, TUid aUid )

    {

    HBufC* widgetName( GetAppNameLC( iApaSession, aUid) );

    HandleWidgetCommandL( iApaSession, *widgetName, aUid, aOperation );

    CleanupStack::PopAndDestroy( widgetName );

    }

 //  End of File