/*

* 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 <wrtharvester.rsg>

#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>

#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;

    };

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

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

// Returns the app full name

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

//

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

    {

    TApaAppInfo info;

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

    return info.iFullName.AllocLC();

    }

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

// Sends the command to Widget launcher

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

//

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

    iHSCount(0)

	{

	}

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

// Symbian 2nd phase constructor can leave.

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

//

void CWrtHarvester::ConstructL()

    {

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

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

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

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

    iWidgetUsbListener = CWrtUsbHandler::NewL( this, iFs );

    iWidgetUsbListener->Start();

    SetMSMode(0);

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

    }

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

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

    {

    if ( iResourceFileOffset )

        {

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

        }

    iObservers.ResetAll();

    iWidgetInfo.ResetAll();

    iWidgetStateArray.ResetAll();

    delete iWidgetUIListener;

    delete iWidgetRegListener;

    delete iWidgetMMCListener;

    delete iWidgetUsbListener;

    iWidgetOperations.Close();

    iHSWidgets.ResetAndDestroy();

    iApaSession.Close();

    }

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

// Is called by Content Harvester server

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

//	

void CWrtHarvester::UpdateL() 

	{

	UpdatePublishersL();

	} 

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

// Is called when Homescreen sends events to publisher

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

//  

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

    {

    //Do not send the Operations to the Widgets when in Mass storage mode.. . .  

    if( IsInMSMode() == 1 )

        {

         if(aTrigger == KDeActive)

         RemovePublisherAndObserverL(aContentId);

         return;              

        }

    TUid uid( WidgetUid( aContentId ) );

    TWidgetOperations operation( Uninitialized );

    if( aTrigger == KActive )

        {

        HBufC* temp = aContentId.Alloc();

        iHSWidgets.Append( temp );

        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;

        HBufC *temp = aContentId.Alloc();

        TPtr ptr (temp->Des());

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

          {

          if( ! ptr.Compare(iHSWidgets[i]->Des()))

            {

            iHSWidgets.Remove(i);

            break;

            }

          }

        delete temp;        

        }

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

    }

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

// 

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

//

void CWrtHarvester::UpdatePublishersL() 

    {

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

    // Remove observer and CPS registry entry of uninstalled widget

    TInt count = publishers.Count();

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

        {

        TBool found( EFalse );

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

            {

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

                {

                found = ETrue;

                break;

                }

            }

        if( found == EFalse )

            {

            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;

    TInt id( KErrNotFound );