/*

* 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:  Class for loading and handling the plugins

*

*/

#include <e32def.h>

#include <centralrepository.h>

#include <mccaparentcleaner.h>

#include <mccapluginfactory.h>

#include "Phonebook2PrivateCRKeys.h"

#include "ccappheaders.h"

#include "tccapluginsorderinfo.h"

#include "ccapluginfactoryowner.h"

#include "../../ccadetailsviewplugin/inc/ccappdetailsviewpluginuids.hrh"

#include "../../ccacommlauncherplugin/inc/ccappcommlauncherpluginuids.hrh"

// ======== CONSTANTS ==============

const TInt KMaxPlugins = 255;

//TODO: put these to common header

_LIT8( KCcaOpaqueNameDelimiter,     "\t" ); //Name=value pairs separated by tabs

_LIT8( KCcaOpaqueValueDelimiter,    "=" );  //Names and values separated by =

_LIT8( KCcaOpaqueTABP,              "TABP" );  //Tab position

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

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

// OrderOfPlugins (local function)

//

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

//

TInt OrderOfPlugins( const CImplementationInformation& aFirst,

            const CImplementationInformation& aSecond )

    {

    TInt firstVal = KMaxPlugins;

    TInt secondVal = KMaxPlugins;

    TLex8 lex( aFirst.OpaqueData() );

    lex.Val( firstVal );

    lex = aSecond.OpaqueData();

    lex.Val( secondVal );

    if( firstVal < secondVal )

        {

        return -1;

        }

    else if( firstVal == secondVal )

        {

        return 0;

        }

    else

        {

        return 1;

        }

    }

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

// CleanupResetAndDestroy (local function)

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

//

void CleanupResetAndDestroy(TAny* aObj)

    {

    if (aObj)

        {

        static_cast<RImplInfoPtrArray*>(aObj)->ResetAndDestroy();

        }

    }

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

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

// CCCAppPluginLoader::CCCAppPluginLoader

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

//

CCCAppPluginLoader::CCCAppPluginLoader(MCCAppEngine* aAppEngine) : iAppEngine(aAppEngine)

    {

    CCA_DP( KCCAppLogFile, CCA_L("CCCAppPluginData::CCCAppPluginLoader"));

    }

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

// CCCAppPluginLoader::~CCCAppPluginLoader

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

//

CCCAppPluginLoader::~CCCAppPluginLoader()

    {

    CCA_DP( KCCAppLogFile, CCA_L("->CCCAppPluginData::~CCCAppPluginLoader"));

    //Nullify pointer to AppEngine in plugins as otherwise it will point to object

    //that doesn't exist anymore at this point of execution (because views are

    //deleted after AppEngine).

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

        {

        CCCAppViewPluginBase& plugin(iPluginDataArray[i]->Plugin());

        plugin.SetAppEngine(NULL);

        }

    iPluginDataArray.ResetAndDestroy();

    delete iFactoryTempPtr;

    CCA_DP( KCCAppLogFile, CCA_L("<-CCCAppPluginData::~CCCAppPluginLoader"));

    }

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

// CCCAppPluginLoader::NewL

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

//

CCCAppPluginLoader* CCCAppPluginLoader::NewL(

    MCCAppEngine* aAppEngine,

    const TDesC8& aPluginProperties,

    const TDesC8& aTypeFilter )

    {

    CCA_DP( KCCAppLogFile, CCA_L("->CCCAppPluginData::NewL"));

    CCCAppPluginLoader* self = new( ELeave ) CCCAppPluginLoader(aAppEngine);

    CleanupStack::PushL( self );

    self->ConstructL(aPluginProperties, aTypeFilter );

    CleanupStack::Pop( self );

    CCA_DP( KCCAppLogFile, CCA_L("<-CCCAppPluginData::NewL"));

    return self;

    }

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

// CCCAppPluginLoader::ConstructL

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

//

void CCCAppPluginLoader::ConstructL(

    const TDesC8& aPluginProperties,

    const TDesC8& aTypeFilter )

    {

    CCA_DP( KCCAppLogFile, CCA_L("->CCCAppPluginData::ConstructL"));

    //PERFORMANCE LOGGING: 3. Loading plugins

    WriteToPerfLog();

    RPointerArray<CImplementationInformation> oldImplInfoArray;

    CleanupStack::PushL(TCleanupItem(CleanupResetAndDestroy, &oldImplInfoArray));

    RPointerArray<CImplementationInformation> newImplInfoArray;

    CleanupStack::PushL(TCleanupItem(CleanupResetAndDestroy, &newImplInfoArray));

    FeatureManager::InitializeLibL();

    const TBool myCardSupported( 

            FeatureManager::FeatureSupported( KFeatureIdffContactsMycard ) );    

    FeatureManager::UnInitializeLib();

    // A. List legacy and new implementations

    if( myCardSupported && 

            aTypeFilter.Length() > 0 )

        {

        TEComResolverParams params;

        params.SetDataType( aTypeFilter );

        REComSession::ListImplementationsL( 

                TUid::Uid(KCCAppViewPluginBaseInterfaceUID),

            params, oldImplInfoArray );

        REComSession::ListImplementationsL( KCCAppViewFactoryInterfaceUID,

            params, newImplInfoArray );

        }

    else

        {

        REComSession::ListImplementationsL( 

                TUid::Uid(KCCAppViewPluginBaseInterfaceUID),

            oldImplInfoArray );

        REComSession::ListImplementationsL( KCCAppViewFactoryInterfaceUID,

            newImplInfoArray );

        }

    if ( !myCardSupported && 

            !oldImplInfoArray.Count() )  //At least one legacy plugin needed

        {// no plugins, nothing can be done

        CCA_DP( KCCAppLogFile, CCA_L( "::ConstructL - no plugins found!"));

        User::Leave( KErrNotFound );

        }

    // B. Sort implementations into same order as are in Phonebook

    // each stores pluginInfo (from oldImplInfoArray) address and order

    RArray<TCCAPluginsOrderInfo> pluginOrderArray;

    CleanupClosePushL( pluginOrderArray );

    RArray<TPtrC> nameArray; // stores phonebooksXPExtension plugins name

    CleanupClosePushL(nameArray);

    // store phonebook mainview sXPExtension's name from CenRep to nameArray

    CRepository* repository = CRepository::NewLC( TUid::Uid(KCRUidPhonebook));

    HBufC* names = HBufC::NewLC(NCentralRepositoryConstants::KMaxUnicodeStringLength);

    TPtr namesPtr = names->Des();

    // get key value, which stores phonebook sXPExtension Plugins name

    TInt error = repository->Get(KPhonebooksXPExtensionPluginsName, namesPtr);

    // e.g if the bey value is "MSN|Ovi|Sonera|....",then MSN, Ovi and Sonera

    // will be appended to aPbksXPExtesionNamesArray

    GetPbksXPExtesionNamesL(nameArray, *names); //parses names to namearray

    // copy CImplementationInformation's address from oldImplInfoArray to pluginOrderArray

    GetPluginsInfoL(pluginOrderArray, nameArray, oldImplInfoArray, newImplInfoArray);

    SortPluginsOrderInfoL( pluginOrderArray, nameArray );

    // C. Load implementations in defined order

    LoadAllPlugins(pluginOrderArray, aPluginProperties);

    CleanupStack::PopAndDestroy(names);

    CleanupStack::PopAndDestroy(repository);

    CleanupStack::PopAndDestroy(); //nameArray

    CleanupStack::PopAndDestroy(); //pluginOrderArray

    CleanupStack::PopAndDestroy(&newImplInfoArray);

    CleanupStack::PopAndDestroy(&oldImplInfoArray);

    //PERFORMANCE LOGGING: 4. Plugins loaded

    WriteToPerfLog();

    CCA_DP( KCCAppLogFile, CCA_L("<-CCCAppPluginData::ConstructL"));

    }

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

// CCCAppPluginLoader::LoadOneMultiViewPluginL

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

//

void CCCAppPluginLoader::LoadOneMultiViewPluginL(

    CImplementationInformation* aImplementationInformation)

    {

    __ASSERT_DEBUG(!iFactoryTempPtr, User::Panic(_L("CCCAppPluginLoad"), KErrAlreadyExists));

    iFactoryTempPtr = CcaPluginFactoryOwner::NewL(aImplementationInformation);

    CcaPluginFactoryOwner* factory = iFactoryTempPtr;

    for(TInt j=0; j < factory->Factory().TabViewCount(); j++)

        {

        CCCAppViewPluginBase* plugin = factory->Factory().CreateTabViewL(j);

        CleanupStack::PushL(plugin);

        CCCAppPluginData* data = CCCAppPluginData::NewLC(*plugin); //Handles plugin ownership

        CleanupStack::Pop(2, plugin);

        CleanupStack::PushL(data);

        iPluginDataArray.AppendL( data );

        CleanupStack::Pop(data);

        data->SetPluginVisibility( CCCAppPluginData::EPluginHidden );

        //Hand over ownership of factoryOwner (shared ownership among tabs created by factory)

        factory->AddedChild();

        plugin->TakeSharedOwnerShip( factory );

        iFactoryTempPtr = NULL; //ownership given

        }

    //If ownership was not given

    delete iFactoryTempPtr;

    iFactoryTempPtr = NULL;

   }

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

// CCCAppPluginLoader::LoadAllPlugins

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

//

void CCCAppPluginLoader::LoadAllPlugins(

        const RArray<TCCAPluginsOrderInfo>& aPluginOrderInfoArray, const TDesC8& aPluginProperties )

    {

    CCA_DP( KCCAppLogFile, CCA_L("->CCCAppPluginData::LoadAllPlugins"));

    const TInt count = aPluginOrderInfoArray.Count();

    CCA_DP( KCCAppLogFile, CCA_L("::LoadAllPlugins - plugin count: %d"), count );

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

        {

        /* If problems with plugin loading, that plugin is

         * not included to the plugin array. Just continuing

         * and trying to load the next one. */

        TRAP_IGNORE( CheckAndLoadPluginL(

                aPluginOrderInfoArray[i], aPluginProperties ));

        }

    CCA_DP( KCCAppLogFile, CCA_L("<-CCCAppPluginData::LoadAllPlugins"));

    }

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

// CCCAppPluginLoader::CheckAndLoadPluginL

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

//

void CCCAppPluginLoader::CheckAndLoadPluginL(

    const TCCAPluginsOrderInfo& aPluginsOrderInfo,

    const TDesC8& aPluginProperties )

    {

    HBufC8* match = GetmachingPropertiesLC(

            aPluginsOrderInfo.iPluginInfor->OpaqueData(),

            aPluginProperties,

            EFalse );

    TBool loadThis = match->Length() > 0;

    CleanupStack::PopAndDestroy(match);

    //Fallback1 for old plugins that provide only number in opaque data: load them always

    //The below if{} can be removed when legacy plugins support new format of OpaqueData

    if(!loadThis)

        {

        loadThis = OpaqueValueFrom( *aPluginsOrderInfo.iPluginInfor ) > 0;

        }

    if( loadThis )

        {

        TUid uid = aPluginsOrderInfo.iPluginInfor->ImplementationUid();

        if( aPluginsOrderInfo.iOldInterFaceType )

            {

            LoadPluginL(uid);   //lecacy implementations

            }

        else

            {

            LoadOneMultiViewPluginL( aPluginsOrderInfo.iPluginInfor ); //New implementations

            }

        CCA_DP( KCCAppLogFile, CCA_L("::LoadAllPlugins - plugin loaded uid: %d"), uid.iUid );

        }

    }

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

// CCCAppPluginLoader::LoadPluginL

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

//

void CCCAppPluginLoader::LoadPluginL(

        TUid aImplementationUid )

    {

    CCA_DP( KCCAppLogFile, CCA_L("->CCCAppPluginData::LoadPluginL"));

    CCCAppViewPluginBase* plugin =

            CCCAppViewPluginBase::NewL( aImplementationUid );

    plugin->SetAppEngine(iAppEngine);

    CCA_DP( KCCAppLogFile, CCA_L("::LoadPluginL - plugin created"));

    CleanupStack::PushL( plugin );

    User::LeaveIfError( aImplementationUid == plugin->Id() ? KErrNone : KErrArgument );

    CCCAppPluginData* data = CCCAppPluginData::NewLC( *plugin );

    data->SetPluginVisibility( CCCAppPluginData::EPluginHidden );

    iPluginDataArray.AppendL( data );

    CCA_DP( KCCAppLogFile, CCA_L("::LoadPluginL - plugin added to iPluginDataArray"));

    CleanupStack::Pop( 2, plugin );// data, plugin

    CCA_DP( KCCAppLogFile, CCA_L("<-CCCAppPluginData::LoadPluginL"));

    }

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

// CCCAppPluginLoader::NextPlugin

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

//

CCCAppPluginData* CCCAppPluginLoader::NextPlugin( TBool aOnlyVisiblePlugins )

    {

    CCA_DP( KCCAppLogFile, CCA_L("->CCCAppPluginData::NextPlugin"));

    CCA_DP( KCCAppLogFile, CCA_L("::NextPlugin - iCurrentPlugin: %d"), iCurrentPlugin );

    for(TInt i = iCurrentPlugin+1; i < PluginsCount(); i++)

        {

        if( !aOnlyVisiblePlugins )

            {

            return iPluginDataArray[iCurrentPlugin = i];

            }

        else if( iPluginDataArray[i]->PluginVisibility() == CCCAppPluginData::EPluginVisible )

            {

            return iPluginDataArray[iCurrentPlugin = i];

            }

        }

        CCA_DP( KCCAppLogFile, CCA_L("<-CCCAppPluginData::NextPlugin - no next"));

        return NULL;

    }

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

// CCCAppPluginLoader::PreviousPlugin

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

//

CCCAppPluginData* CCCAppPluginLoader::PreviousPlugin( TBool aOnlyVisiblePlugins )

    {

    CCA_DP( KCCAppLogFile, CCA_L("->CCCAppPluginData::PreviousPlugin"));

    CCA_DP( KCCAppLogFile, CCA_L("::PreviousPlugin - iCurrentPlugin: %d"), iCurrentPlugin );

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

        {

        if( !aOnlyVisiblePlugins )

            {

            return iPluginDataArray[iCurrentPlugin = i];

            }

        else if( iPluginDataArray[i]->PluginVisibility() == CCCAppPluginData::EPluginVisible )

            {

            return iPluginDataArray[iCurrentPlugin = i];

            }

        }

        CCA_DP( KCCAppLogFile, CCA_L("<-CCCAppPluginData::PreviousPlugin - no previous"));

        return NULL;

    }

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

// CCCAppPluginLoader::SetPluginInFocus

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

//

TInt CCCAppPluginLoader::SetPluginInFocus( const TUid aUid )

    {

    CCA_DP( KCCAppLogFile, CCA_L("->CCCAppPluginData::SetPluginInFocus"));

    CCA_DP( KCCAppLogFile, CCA_L("::SetPluginInFocus - searching aUid: %d"), aUid );

    TInt index = KErrNotFound;

    // no need to search if no uid provided

    if ( TUid::Null() == aUid )

        return index;

    const TInt count = iPluginDataArray.Count();

    CCA_DP( KCCAppLogFile, CCA_L("::SetPluginInFocus - plugin count: %d"), count );

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

        {

        TUid uid( iPluginDataArray[i]->Plugin().Id() );

        CCA_DP( KCCAppLogFile, CCA_L("::SetPluginInFocus - uid: %d found"), uid );

        if( aUid == uid )

            {

            index = i;

            iCurrentPlugin = i;

            break;// found, no need to loop all through

            }

        }

    CCA_DP( KCCAppLogFile, CCA_L("::SetPluginInFocus - index after searching the array %d"), index );

    CCA_DP( KCCAppLogFile, CCA_L("<-CCCAppPluginData::SetPluginInFocus"));

    return index;

    }

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

// CCCAppPluginLoader::PluginInFocus

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

//

CCCAppPluginData* CCCAppPluginLoader::PluginInFocus( )

    {

    CCA_DP( KCCAppLogFile, CCA_L("->CCCAppPluginData::PluginInFocus"));

    CCA_DP( KCCAppLogFile, CCA_L("::PluginInFocus - iCurrentPlugin: %d"), iCurrentPlugin );

    if ( 0 > iCurrentPlugin || iCurrentPlugin > PluginsCount()-1 )

        {

        CCA_DP( KCCAppLogFile, CCA_L("<-CCCAppPluginData::PluginInFocus - not in range"));

        return NULL;

        }

    else

        {

        CCA_DP( KCCAppLogFile, CCA_L("<-CCCAppPluginData::PluginInFocus - found in range"));

        return iPluginDataArray[ iCurrentPlugin ];

        }

    }

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

// CCCAppPluginLoader::PluginsCount

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

//

TInt CCCAppPluginLoader::PluginsCount( ) const

    {

    CCA_DP( KCCAppLogFile, CCA_L("->CCCAppPluginData::PluginsCount"));

    const TInt count = iPluginDataArray.Count();

    CCA_DP( KCCAppLogFile, CCA_L("::PluginsCount - count %d"), count );

    CCA_DP( KCCAppLogFile, CCA_L("<-CCCAppPluginData::PluginsCount"));

    return count;

    }

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

// CCCAppPluginLoader::VisiblePluginCount

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

//

TInt CCCAppPluginLoader::VisiblePluginCount( ) const

    {

    CCA_DP( KCCAppLogFile, CCA_L("->CCCAppPluginData::VisiblePluginCount"));

    TInt count(0);

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

        {

        CCCAppPluginData* dta = iPluginDataArray[i];

        if( dta->PluginVisibility() == CCCAppPluginData::EPluginVisible)

            {

            count++;

            }

        }

    CCA_DP( KCCAppLogFile, CCA_L("::VisiblePluginCount - count %d"), count );

    CCA_DP( KCCAppLogFile, CCA_L("<-CCCAppPluginData::VisiblePluginCount"));

    return count;

    }

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

// CCCAppPluginLoader::VisiblePlugin

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

//

CCCAppPluginData* CCCAppPluginLoader::VisiblePlugin( TInt aIndex, TBool aChangefocus )

    {

    CCA_DP( KCCAppLogFile, CCA_L("->CCCAppPluginData::VisiblePluginAt"));

    CCA_DP( KCCAppLogFile, CCA_L("::VisiblePluginAt - aIndex %d"), aIndex );

    TInt visiblePlugin(KErrNotFound);

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

        {

        if( iPluginDataArray[i]->PluginVisibility() == CCCAppPluginData::EPluginVisible )

            {

            visiblePlugin++;

            }

        if( visiblePlugin == aIndex )

            {

            CCA_DP( KCCAppLogFile, CCA_L("<-CCCAppPluginData::VisiblePluginAt - found in range"));

            return PluginAt( i, aChangefocus );

            }

        }

        CCA_DP( KCCAppLogFile, CCA_L("<-CCCAppPluginData::VisiblePluginAt - not in visible range"));

        return NULL;

    }

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

// CCCAppPluginLoader::PluginAt

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

//

CCCAppPluginData* CCCAppPluginLoader::PluginAt( TInt aIndex, TBool aChangefocus )

    {

    CCA_DP( KCCAppLogFile, CCA_L("->CCCAppPluginData::PluginAt"));

    CCA_DP( KCCAppLogFile, CCA_L("::PluginAt - aIndex %d"), aIndex );

    const TInt count = PluginsCount();

    if ( 0 == count || 0 > aIndex || (count - 1) < aIndex )

        {

        CCA_DP( KCCAppLogFile, CCA_L("<-CCCAppPluginData::PluginAt - not in range"));

        return NULL;

        }

    else

        {

        CCA_DP( KCCAppLogFile, CCA_L("<-CCCAppPluginData::PluginAt - found in range"));