/*

* Copyright (c) 2005-2008 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:  GS plugin loader.

*

*/

// INCLUDE FILES

#include    <gspluginloader.h>

#include    <gsplugininterface.h>

#include    <gsprivatepluginproviderids.h>

#include    "GsLogger.h"

#include    "GSBaseDocument.h"

#include    "GSPluginWrapper.h"

#include    "GSPluginAndViewIdCache.h"

#include    <mgswatchdog.h>

#include    <aknViewAppUi.h>

#include    <AknIconArray.h>

#include    <aknlists.h> // CAknSingleLargeStyleListbox

#include    <eikclbd.h> // CColumnListBoxData

#include    <gulicon.h> // For CGulIcon

#include    <utf.h> // CnvUtfConverter

#include  	<basched.h>

#include    <AknInfoPopupNoteController.h>

//Flag for enabling/disablign compare by category feature

#undef RD_GS_COMPARE_BY_CATEGORY

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

#ifdef _DEBUG

    #pragma message("-----_DEBUG ACTIVATED IN GS!-----")

#endif //_GEBUG

#ifdef _GS_PERFORMANCE_TRACES

    #pragma message("-GS plugin load performance measurements activated-")

#endif // _GS_PERFORMANCE_TRACES

const TInt KGSCaptionSize = 256;

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

// CGSPluginLoader::NewL

//

// EPOC two-phased constructor

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

//

EXPORT_C CGSPluginLoader* CGSPluginLoader::NewL( CAknViewAppUi* aAppUi )

    {

    CGSPluginLoader* self = new( ELeave ) CGSPluginLoader;

    CleanupStack::PushL( self );

    self->ConstructL( aAppUi );

    CleanupStack::Pop( self );

    return self;

    }

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

// CGSPluginLoader::CGSPluginLoader

//

// C++ default constructor can NOT contain any code, that

// might leave.

//

//  Uses low priority for Active Object so that more bandwith is available for 

//  the most important pluginloaders. 

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

//

CGSPluginLoader::CGSPluginLoader() 

    : CActive( EPriorityLow ),

      iRequestedPriority( EPriorityLow )

    {

    __GSLOGSTRING( "[GSPlgLoader] CGSPluginLoader()" );

    }

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

// CGSPluginLoader::ConstructL

//

// EPOC default constructor can leave.

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

//

EXPORT_C void CGSPluginLoader::ConstructL( CAknViewAppUi* aAppUi )

    {

    __GSLOGSTRING( "[GSPlgLoader] ConstructL()" );

    iAppUi = aAppUi;

    iDocument = static_cast<CGSBaseDocument*>( iAppUi->Document() );

    iImplInfoArray = iDocument->GetImplInfo();

    CActiveScheduler* scheluder = CActiveScheduler::Current();

    __GSLOGSTRING1( "[GSPlgLoader] Current CActiveScheduler:0x%X", scheluder );

    __GSLOGSTRING1( "[GSPlgLoader] CActiveScheduler stackdepth: %d",

        scheluder->StackDepth() );

    CActiveScheduler::Add( this );

    iWatchDog = iDocument->WatchDog();

    }

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

// CGSPluginLoader::~CGSPluginLoader

//

// Destructor

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

//

EXPORT_C CGSPluginLoader::~CGSPluginLoader()

    {

    __GSLOGSTRING( "[GSPlgLoader] ~CGSPluginLoader()" );

    AbortAsyncLoad();

    Cancel();

    if( iErrorPopup )

        {

        iErrorPopup->HideInfoPopupNote();

        delete iErrorPopup;

        iErrorPopup = NULL;

        }

    //iPluginArray is not owned and therefore not deleted.

    }

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

// CGSPluginLoader::LoadAsync

//

//

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

//

EXPORT_C void CGSPluginLoader::LoadAsyncL(

    TUid aInterfaceUid,

    TUid aParentUid,

    CArrayPtrFlat<CGSPluginInterface>* aPluginArray )

    {

    iPluginArray = aPluginArray;

    iParentUid = aParentUid;

    __GSLOGSTRING3(

        "[GSPlgLoader] LoadAsync(). aInterfaceUid:0x%X aParentUid:0x%X, aPluginArray:0x%X",

        aInterfaceUid, aParentUid, aPluginArray );

    // Reset iterator:

    iImplInfoArrayIterator = 0;

    __GSLOGSTRING1( "[GSPlgLoader] Implementation info count: %d",

        iImplInfoArray.Count() );

    NotifyProgress();

    //Begin CActive asynchronous loop.

    CompleteOwnRequest();

    }

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

// CGSPluginLoader::LoadSyncL

//

//

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

//

CGSPluginInterface& CGSPluginLoader::LoadSyncL( TUid aInterfaceUid,

                                                TUid aImplementationUid )

    {

    Cancel();

    CGSPluginInterface* ret = NULL;

    // Get a list of all implementations, even though we only want one specific.

    // There appears to be no way to otherwise extract a specific implementation

    // info object :(

    // Search for the implementation that matches aImplementationUid

    const TInt impCount = iImplInfoArray.Count();

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

        {

        const CImplementationInformation* info = iImplInfoArray[ i ];

        if  ( info->ImplementationUid() == aImplementationUid )

            {

            ret = &CreatePluginInstanceL( *info );

            break;

            }

        }

    if  ( !ret )

        {

        User::Leave( KErrNotFound );

        }

    return *ret;

    }

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

// CGSPluginLoader::AbortAsyncLoad

//

//

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

//

EXPORT_C void CGSPluginLoader::AbortAsyncLoad()

    {

    __GSLOGSTRING( "[GSPlgLoader] AbortAsyncLoad()" );

    Cancel();

    }

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

// CGSPluginLoader::RunL

//

//

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

//

void CGSPluginLoader::RunL()

    {

    iRunLDebugCount++;

    // This must be done only in RunL or otherwise request might be 

    // outstanding.

    if( iRequestedPriority != Priority() )

        {

        __GSLOGSTRING3(

            "[CGSPluginLoader::RunL] 0x%X original priority:%d requested priority:%d", 

            iParentUid.iUid, 

            Priority(),

            iRequestedPriority );

        SetPriority( iRequestedPriority );

        }

    LoadNextPluginL();

    // Check if there are still more plugins to be loaded:

    if ( iImplInfoArrayIterator < iImplInfoArray.Count() )

        {

        NotifyProgress();

        // Continue CActive asynchronous loop.

        CompleteOwnRequest();

        }

    else

        {

        // All plugins loaded:

        __GSLOGSTRING( "[GSPlgLoader] Loading plugins finished." );

        NotifyFinished();

        }

    }

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

// CScGenreItemConstructionConductor::CompleteOwnRequest

//

// Issue request complete notification.

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

void CGSPluginLoader::CompleteOwnRequest()

    {

    TRequestStatus* status = &iStatus;

    User::RequestComplete( status, KErrNone );

    SetActive();

    }

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

// CGSPluginLoader::RunError

//

//

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

//

TInt CGSPluginLoader::RunError( TInt aError )

    {

    // This method is called when a plugin loading fails.

    // Always "fake" the return value so that ActiveSchedule

    // keeps running and later plugins are continued to be loaded.

    // Check if still plugins to be loaded:

    if( iImplInfoArrayIterator < iImplInfoArray.Count() )

        {

        NotifyProgress();

        //Continue CActive asynchronous loop.

        CompleteOwnRequest();

        }

    else // All plugins loaded:

        {

        NotifyFinished();

        }

    if ( aError == KLeaveExit )

        {

        return KLeaveExit;

        }

    return KErrNone;

    }

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

// CGSPluginLoader::DoCancel

//

//

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

//

void CGSPluginLoader::DoCancel()

    {

    }

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

// CGSPluginLoader::NotifyProgress

//

//

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

//

void CGSPluginLoader::NotifyProgress()

    {

    if( iObserver )

        {

        iObserver->HandlePluginLoaded( MGSPluginLoadObserver::EGSSuccess);

        }

    }

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

// CGSPluginLoader::NotifyFinished

//

//

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

//

void CGSPluginLoader::NotifyFinished()

    {

    #ifdef _GS_PLUGINLOADER_FINAL_SORTING_TRACES

        TRAP_IGNORE( PrintOrderTracesL( iPluginArray ) );

    #endif // _GS_PLUGINLOADER_FINAL_SORTING_TRACES

    // I have finished loading: No need to keep me in the expensive scheduler

    // queue.

    Deque();

    if( iObserver )

        {

        iObserver->HandlePluginLoaded( MGSPluginLoadObserver::EGSFinished );

        }

    __GSLOGSTRING1( "[CGSPluginLoader::NotifyFinished] 0x%X", 

                    iParentUid.iUid );

    }

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

// CGSPluginLoader::SetObserver

//

//

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

//

EXPORT_C void CGSPluginLoader::SetObserver(MGSPluginLoadObserver* aObserver)

    {

    __GSLOGSTRING1("[GSPlgLoader] Observer set:0x%X", aObserver);

    iObserver = aObserver;

    }

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

// CGSPluginLoader::ParseToUid

// Parses a UID from descriptor of form '0xNNNNNNNN' where N is hexadecimal.

//

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

//

TInt CGSPluginLoader::ParseToUid( const TDesC8& aSource, TUid& aTarget )

    {

    // Remove "0x" from the descriptor if it exists

    _LIT8(KHexPrefix, "0x");

    TPtrC8 pSource( aSource );

    const TInt prefixPosition = pSource.Find( KHexPrefix );

    if  ( prefixPosition != KErrNotFound )

        {

        pSource.Set( aSource.Mid( prefixPosition + KHexPrefix().Length() ) );

        }

    // Parse to integer

    TLex8 lex( pSource );

    TUint integer = 0;

    // Parse using TRadix::EHex as radix:

    const TInt err = lex.Val( integer, EHex );

    aTarget.iUid = integer;

    if( err != KErrNone )

        {

        // If parsing parent UID failed, do not load plugin:

        __GSLOGSTRING1(

            "[GSPlgLoader] Parsing parent UID failed. Error code:%d",

            err );

        }

    return err;

    }

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

// CGSPluginLoader::ParseOrderNumber

//

//

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

//

TInt CGSPluginLoader::ParseOrderNumber( const TDesC8& aSource, TInt& aOrderNumber )

    {

    // Parse plugin's order number from opaque_data:

    TLex8 lex( aSource );

    const TInt orderErr = lex.Val( aOrderNumber );

    return orderErr;

    }

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

// CGSPluginLoader::PrintInfoDebug

// Print CImplementationInformation to log. Used for debugging.

//

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

//

void CGSPluginLoader::PrintInfoDebugL( const CImplementationInformation& aInfo,

                                      TInt aIterator,

                                      TInt aPluginCount )

    {

    #pragma message("-CGSPluginLoader verbose traces activated-")

    __GSLOGSTRING2( "[GSPlgLoader::LoadNextPluginL] %d/%d",

                    aIterator,

                    aPluginCount);

    __GSLOGSTRING1( "[GSPlgLoader] --Plugin 0x%X info--", &aInfo);

    __GSLOGSTRING1( "[GSPlgLoader] DisplayName:%S", &aInfo.DisplayName() );

    __GSLOGSTRING1( "[GSPlgLoader] ImplementationUid:0x%X",

                    aInfo.ImplementationUid() );

    const TInt KMaxEComDataLength = 256;

    HBufC* dataType = HBufC::New( KMaxEComDataLength );

    HBufC* opaqueData = HBufC::New( KMaxEComDataLength );

    dataType->Des().Copy( aInfo.DataType() );

    opaqueData->Des().Copy( aInfo.OpaqueData() );

    __GSLOGSTRING1( "[GSPlgLoader] DataType:%S", dataType );

    __GSLOGSTRING1( "[GSPlgLoader] OpaqueData:%S", opaqueData );

    delete opaqueData;

    delete dataType;

    }

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

// CGSPluginLoader::LoadNextPluginL

// Iterate through iImplInfoArray. Load the plugin if it is eligible for

// loading. Loaded plugin is added to iPluginArray. Each time a plugin is

// loaded, iObserver is notified.

//

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

//

EXPORT_C void CGSPluginLoader::LoadNextPluginL()

    {

    // Iterate through iImplInfoArray. This loop continues between function

    // calls. Therefore member variable iImplInfoArrayIterator is used as a

    // counter. Loop will break when match is found and continues on next RunL.

    for( ; iImplInfoArrayIterator < iImplInfoArray.Count();  )

        {

        const CImplementationInformation* info =

            iImplInfoArray[ iImplInfoArrayIterator ];

        iImplInfoArrayIterator++;

        #ifdef _GS_PLUGINLOADER_VERBOSE_TRACES

            PrintInfoDebugL( *info, iImplInfoArrayIterator, iImplInfoArray.Count() );

        #endif //_GS_PLUGINLOADER_VERBOSE_TRACES

        // Parse parent UID from default_data:

        TUid parentUid;

        const TInt uidErr = ParseToUid( info->DataType(), parentUid );

        if( uidErr == KErrNone  && iParentUid == parentUid )

            {

            // If this plugin is OK -> load it:

            __GSLOGSTRING2( "[GSPlgLoader] %S eligible for parent 0x%X",

                    &info->DisplayName(), iParentUid.iUid );

            CGSPluginInterface* plugin = NULL;

            TInt error = KErrCancel;

            if( !iWatchDog->IsInBlackList( info->ImplementationUid() ) )

                {

                // Only panics move quarantined plugins to blacklist. Leaving is

                // normal programmatic functionality and therefore does not move

                // plugin to blacklist.

                iWatchDog->QuarantineL( info->ImplementationUid() );

                #ifdef _GS_PERFORMANCE_TRACES

                    TTime timeStart;

                    TTime timeEnd;

                    timeStart.HomeTime();

                #endif //_GS_PERFORMANCE_TRACES

                // Create plugin. Trap leave for debugging purposes.

                TRAP( error, plugin = &CreatePluginInstanceL( *info ); );

                #ifdef _GS_PERFORMANCE_TRACES

                    timeEnd.HomeTime();

                    TTimeIntervalMicroSeconds funcDuration = timeEnd.MicroSecondsFrom( timeStart );

                    __GSLOGSTRING2( "[GSPlgLoader::LoadNextPluginL/perf] %Ld    (%S)", funcDuration, &info->DisplayName() );

                #endif //_GS_PERFORMANCE_TRACES

                TRAP_IGNORE( iWatchDog->RemoveFromQuarantineL( info->ImplementationUid() ); );

                }

            if( error == KErrNone )

                {

                // Plugin ownership is transfered to iPluginArray

                InsertPluginInOrderL( plugin, iPluginArray );

                }

            else if( error == KLeaveExit )

                {

                __GSLOGSTRING( "[GSPlgLoader::LoadNextPluginL] LEAVE: KLeaveExit!!!" );

                // Must pass KLeaveExit through or otherwise Exit-command will

                // not be handled.

                User::Leave( KLeaveExit );

                }

            else

                {

                // Error note is displayed even if plugin is not loaded

                // -> plugin is in blacklist -> blacklist note displayed.