/*

* 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 <cpbk2applicationservices.h>

#include <MVPbkContactStoreProperties.h>

#include <VPbkContactStoreUris.h>

#include <TVPbkContactStoreUriPtr.h>

#include <MVPbkContactStore.h>

#include "Phonebook2PrivateCRKeys.h"

#include "ccappheaders.h"

#include "tccapluginsorderinfo.h"

#include "ccapluginfactoryowner.h"

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

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

#include "../inc/ccappmycardpluginuids.hrh"

#include <Pbk2DataCaging.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

_LIT(KPbk2CommandsDllResFileName,   "Pbk2Commands.rsc");

_LIT(KPbk2UiControlsDllResFileName, "Pbk2UiControls.rsc");

_LIT(KPbk2CommonUiDllResFileName,   "Pbk2CommonUi.rsc"  );

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

    iCommandsResourceFile( *CCoeEnv::Static() ),

    iUiControlsResourceFile( *CCoeEnv::Static() ),

    iCommonUiResourceFile( *CCoeEnv::Static() )

    {

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

    Release( iAppServices );

    iCommandsResourceFile.Close();

    iUiControlsResourceFile.Close();

    iCommonUiResourceFile.Close();

    }

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

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

    PreparePbk2ApplicationServicesL();

    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::IsSimStoreUri

// Determine whether a Contact Store URI is SIM Card storage.

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

//

TBool CCCAppPluginLoader::IsSimStoreUri( const TVPbkContactStoreUriPtr& aUri ) const

    {

    TBool isSimUri(EFalse);

    isSimUri = !aUri.Compare(VPbkContactStoreUris::SimGlobalAdnUri(),

                    TVPbkContactStoreUriPtr::EContactStoreUriAllComponents) ||

               !aUri.Compare(VPbkContactStoreUris::SimGlobalFdnUri(),

                    TVPbkContactStoreUriPtr::EContactStoreUriAllComponents) ||

               !aUri.Compare(VPbkContactStoreUris::SimGlobalSdnUri(),

                    TVPbkContactStoreUriPtr::EContactStoreUriAllComponents) ||

               !aUri.Compare(VPbkContactStoreUris::SimGlobalOwnNumberUri(),

                    TVPbkContactStoreUriPtr::EContactStoreUriAllComponents);

    return isSimUri;

    }

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

// CCCAppPluginLoader::IsCurrentContactStoreSupportL

// Determine whether an implementation plug-in is supported by Current Contact Store. 

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

//

TBool CCCAppPluginLoader::IsCurrentContactStoreSupportL( const TInt& aImplmentationUid ) const

    {

    TBool isCurrentContactStoreSupport(ETrue);

    if( ( KCCADetailsViewPluginImplmentationUid != aImplmentationUid )

            && ( KCCACommLauncherPluginImplmentationUid != aImplmentationUid )

            && ( KCCAMyCardPluginImplmentationUid != aImplmentationUid ) )

        {

        MVPbkContactLink* link = NULL;

        MVPbkContactLinkArray* contactArray = NULL;

        HBufC& contactData = iAppEngine->Parameter().ContactDataL();

        HBufC8* contactData8 = HBufC8::NewLC(contactData.Size());

        TPtr8 contactData8Ptr(contactData8->Des());

        contactData8Ptr.Copy(contactData.Des());

        contactArray = iAppServices->ContactManager().CreateLinksLC(contactData8Ptr);

        if (contactArray->Count() > 0)

            {

            link = contactArray->At(0).CloneLC();

            }

        if (link)

            {

            const MVPbkContactStoreProperties& storeProperties =

                    link->ContactStore().StoreProperties();

            TVPbkContactStoreUriPtr uri = storeProperties.Uri();

            isCurrentContactStoreSupport = !IsSimStoreUri( uri );

            }

        if( link )

            {

            CleanupStack::PopAndDestroy(); //link

            }

        if( contactArray )

            {

            CleanupStack::PopAndDestroy(); //contactArray

            }

        CleanupStack::PopAndDestroy(); //contactData8

        }

    return isCurrentContactStoreSupport;

    }

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

// CCCAppPluginLoader::PreparePbk2ApplicationServicesL

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

//

void CCCAppPluginLoader::PreparePbk2ApplicationServicesL()

    {   

    iCommandsResourceFile.OpenL(

        KPbk2RomFileDrive, KDC_RESOURCE_FILES_DIR, KPbk2CommandsDllResFileName );

    iUiControlsResourceFile.OpenL(

        KPbk2RomFileDrive, KDC_RESOURCE_FILES_DIR, KPbk2UiControlsDllResFileName );

    iCommonUiResourceFile.OpenL(

        KPbk2RomFileDrive, KDC_RESOURCE_FILES_DIR, KPbk2CommonUiDllResFileName );

    iAppServices = CPbk2ApplicationServices::InstanceL();

    }

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

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

        {

        TInt tempImplmentationUid = aPluginOrderInfoArray[i].iPluginInfor->ImplementationUid().iUid;

        TBool isCurrentContactStoreSupport = EFalse;

        TRAPD( err, isCurrentContactStoreSupport = IsCurrentContactStoreSupportL( tempImplmentationUid ) );

        if( err != KErrNone || !isCurrentContactStoreSupport )

            {

            /* If problems with Contact Link related operations or the Contact Link is in SIM Store,

             * don't load current plugin. Just continuing

             * to load the next one. */

            continue;

            }

        /* 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