#include <wrtharvester.rsg>

#include <APGTASK.H>

#include <coemain.h>

#include <bautils.h>

#include <f32file.h>

#include <e32std.h>

#include <AknNotify.h>

#include <aknglobalconfirmationquery.h>

#include <StringLoader.h>

#include <data_caging_path_literals.hrh>

// CONSTANTS

_LIT( KResourceFileName, "\\resource\\wrtharvester.rsc" );

_LIT( KResourceDir, "Z:wrtharvester.rsc" );

/**

* Utility class to show the prompt for platform security access.

*

* The class exists only to provide platform security access prompt

* for the widgets which are launched in minview 

*/

class CGlobalQueryHandlerAO : public CActive

    {

public:

    /**

    * Startup.

    *

    * @param aManager Window Manager.

    * @param aWindow Window.

    * @param aMessage Message to be prompted.

    * @param aSoftkeys for prompt.

    * @param aWrtHarvester for callback

    */

    static CGlobalQueryHandlerAO* StartLD (

                            TUid& aUid,

                            const TDesC& aMessage, 

                            TInt aSoftkeys,

                            CWrtHarvester* aWrtHarvester);

    /**

    * ShowGlobalQueryDialogL.

    *

    * @param aMessage Message to be prompted.

    * @param aSoftkeys for prompt.

    */

    void ShowGlobalQueryDialogL ( 

                            const TDesC& aMessage, 

                            TInt aSoftkeys );

protected: // From CActive

    /**

    * Execute asynchronous operation.

    */

    void RunL();

    /**

    * Provide cancellation methods.

    */

    void DoCancel();

private:

    /**

    * Constructor.

    *

    * @param aManager Manager.

    * @param aWindow Window.

    * @param aMessage Message for prompt.

    * @param aSoftkeys for prompt.

    * @param aWrtHarvester for callback    

    */

    CGlobalQueryHandlerAO (

            TUid& aUid,

            const TDesC& aMessage, 

            TInt aSoftkeys,

            CWrtHarvester* aWrtHarvester);

    /**

    * Destructor. 

    *

    * Private on purpose.

    */

    ~CGlobalQueryHandlerAO();

private:

    TUid iWidgetUid;

    CAknGlobalConfirmationQuery* iGlobalConfirmationQuery ;

    HBufC* iConfirmationText;

    CWrtHarvester* iWrtHarvester;

    };

// Returns the app full name

// Sends the command to Widget launcher

    iCPSInterface( aCPSInterface ),

    iHSCount(0)

    iWidgetUsbListener = CWrtHarvesterPSNotifier::NewL( this, EWidgetMassStorageMode );

    TFileName resourceFileName;  

    TParse parse;    

    Dll::FileName (resourceFileName);           

    parse.Set(KResourceFileName, &resourceFileName, NULL); 

    resourceFileName = parse.FullName(); 

    CCoeEnv* coeEnv = CCoeEnv::Static(); 

    BaflUtils::NearestLanguageFile(coeEnv->FsSession(), resourceFileName); 

    if ( !BaflUtils::FileExists( coeEnv->FsSession(), resourceFileName ) )

        { 

        // Use resource file on the Z drive instead  

        parse.Set( KResourceDir, &KDC_RESOURCE_FILES_DIR, NULL ); 

        resourceFileName = parse.FullName();  

        BaflUtils::NearestLanguageFile( coeEnv->FsSession(),resourceFileName );            

        } 

    iResourceFileOffset = coeEnv->AddResourceFileL(resourceFileName);

    if ( iResourceFileOffset )

        {

        CCoeEnv::Static()->DeleteResourceFile( iResourceFileOffset );

        }

    iWidgetInfo.ResetAll();

    iWidgetStateArray.ResetAll();

    delete iWidgetUsbListener;

    iWidgetOperations.Close();

// Is called by Content Harvester server

// Is called when Homescreen sends events to publisher

    TUid uid( WidgetUid( aContentId ) );

    TWidgetOperations operation( Uninitialized );

    if( aTrigger == KActive )

        iHSCount++;	

        // queue the activated state event only for network accessing widgets

        if ( CheckNetworkAccessL( uid) )

            TWrtState* widgetState = NULL;

            widgetState = new TWrtState( uid, EActivatedState );

            if ( widgetState )

                {

                iWidgetStateArray.AppendL( widgetState );

                }

        operation = LaunchMiniview;

        }

    else if ( aTrigger == KDeActive )

        {

        iHSCount--;

        operation = Deactivate;

        }

    else if( aTrigger == KSuspend )

        {

        operation = WidgetSuspend;

        }

    else if( aTrigger == KResume )

        {

        TInt idx = FindWidget( uid );

        // if unable to find the widget, queue the resume as usual

        if ( idx == -1 )

            QueueResumeL( uid );

        else

            iWidgetStateArray[idx]->iState = EResumeState;

        return;

        }

    else if( aTrigger == KSelected )

        {

        operation = WidgetSelect;

    else if( aTrigger == KHSOnline )

        {

        ProcessNetworkModeL( uid, WidgetOnline );

        return;

        }

    else if( aTrigger == KHSOffline )

        {

        ProcessNetworkModeL( uid, WidgetOffline );

        return;

        }

    QueueOperationL( operation, uid );

    iRegistryAccess.WidgetInfosL( iWidgetInfo );

    RemoveObsoletePublishersL();

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

        {

        // Register the observer first as notification may be

        // received immediately after registration

        RequestForNotificationL( *iWidgetInfo[i] );

        TInt id = RegisterPublisherL( *iWidgetInfo[i] );

        if( id == KErrNotFound )

            {

            // remove the observer as the publisher registration failed

            RemoveObserver( *iWidgetInfo[i]->iBundleId);

            }

        }

    }

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

// 

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

//

void CWrtHarvester::RemoveObsoletePublishersL() 

    {

    RWrtArray<HBufC> publishers;

    publishers.PushL();

    RegisteredPublishersL( publishers );

    TInt count = publishers.Count();

    for( TInt i = count - 1; i >= 0; --i )

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

            if( *publishers[i] == iWidgetInfo[j]->iBundleId )

            RemovePublisherAndObserverL( *publishers[i] );

    CleanupStack::PopAndDestroy( &publishers );

void CWrtHarvester::RegisteredPublishersL( RPointerArray<HBufC>& publishers )

    publishers.ResetAndDestroy();

    CLiwGenericParamList* publisherList( CLiwGenericParamList::NewLC() );

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

    TLiwGenericParam type( KType, TLiwVariant( KPubData ));

    inParamList->AppendL( type );

    CLiwDefaultMap* filter = CLiwDefaultMap::NewLC();

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

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

    //append filter to input param

    TLiwGenericParam item( KFilter, TLiwVariant( filter ));

    inParamList->AppendL( item );

    // Get all publishers from CPS

    iCPSInterface->ExecuteCmdL( KGetList, *inParamList, *publisherList ); 

    CleanupStack::PopAndDestroy( filter );

    CleanupStack::PopAndDestroy( inParamList );

    TInt pos = 0;

    publisherList->FindFirst( pos, KResults );

    if( pos != KErrNotFound )

        {

        //extract iterator on results list

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

        CLiwIterable* iterable = variant.AsIterable();

        iterable->Reset();

        //get all the templated widget publishers

        while( iterable->NextL( variant ) )

            {

            //extract content map

            CLiwDefaultMap* publisherMap = CLiwDefaultMap::NewLC();         

            variant.Get( *publisherMap );

            variant.Reset();

            if( publisherMap && publisherMap->FindL( KContentId , variant ))

                {

                 HBufC* bundleId = variant.AsDes().AllocLC();

                 publishers.AppendL( bundleId );

                 CleanupStack::Pop( bundleId );

                 }

             CleanupStack::PopAndDestroy( publisherMap );     

             }

        variant.Reset();

        }

    CleanupStack::PopAndDestroy( publisherList );

    }

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

// 

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

//

TInt CWrtHarvester::RegisterPublisherL( CWrtInfo& wrtInfo )

    {

    TBool networkAccess = CheckNetworkAccessL( wrtInfo.iUid );

    __UHEAP_MARK;

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

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

        cpdatamap->InsertL( KContentId, TLiwVariant( wrtInfo.iBundleId ));

        // Widget info map

    	CLiwDefaultMap* widgetInfo = CLiwDefaultMap::NewLC();

		widgetInfo->InsertL( KTemplateType, TLiwVariant( KTemplateName ));

		widgetInfo->InsertL( KWidgetName, TLiwVariant( wrtInfo.iDisplayName ));

		datamap->InsertL( KWidgetInfo , TLiwVariant( widgetInfo ));

		CleanupStack::PopAndDestroy( widgetInfo );

		// Take dynamic menu items into use

		if (networkAccess)

		    {

		    CLiwDefaultMap* mapMenu = CLiwDefaultMap::NewLC();

		    mapMenu->InsertL( KItemOnlineOffline, TLiwVariant( KMyActionName ));

		    datamap->InsertL( KMenuItems, TLiwVariant( mapMenu ));