/*
* Copyright (c) 2006 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:  Collection plug-in handler
*
*/

#include <mpxlog.h>
#include <mpxcollectionplugin.h>
#include <mpxcollectionplugin.hrh>
#include "mpxcollectionpluginhandler.h"
#include "mpxcollectionplugininfo.h"

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

// ----------------------------------------------------------------------------
// Two-phased constructor.
// ----------------------------------------------------------------------------
//
CMPXCollectionPluginHandler* CMPXCollectionPluginHandler::NewL(
    MMPXCollectionPluginObserver& aPluginObserver,
    MMPXPluginHandlerObserver& aObserver)
    {
    CMPXCollectionPluginHandler* p=new(ELeave)CMPXCollectionPluginHandler(
        aPluginObserver, aObserver);
    CleanupStack::PushL(p);
    p->ConstructL();
    CleanupStack::Pop(p);
    return p;
    }

// ----------------------------------------------------------------------------
// Constructor.
// ----------------------------------------------------------------------------
//
CMPXCollectionPluginHandler::CMPXCollectionPluginHandler(
    MMPXCollectionPluginObserver& aPluginObserver,
    MMPXPluginHandlerObserver& aObserver)
:   CMPXPluginHandlerBase(KMPXCollectionInterfaceUid, ESelectionType, EMcLocal, aObserver),
    iPluginObserver(&aPluginObserver)
    {
    }

// ----------------------------------------------------------------------------
// 2nd phase constructor.
// ----------------------------------------------------------------------------
//
void CMPXCollectionPluginHandler::ConstructL()
    {
    BaseConstructL();
    }

// ----------------------------------------------------------------------------
// Destructor.
// ----------------------------------------------------------------------------
//
CMPXCollectionPluginHandler::~CMPXCollectionPluginHandler()
    {
    //close plugins
    for (TInt i = iLoadedPlugins.Count(); --i >= 0;)
        {
        CMPXCollectionPlugin* p=iLoadedPlugins[i];
        TRAP_IGNORE( p->CommandL(EMcCmdClose) );
        }
    iLoadedPlugins.ResetAndDestroy();
    }

// ----------------------------------------------------------------------------
// Return the list of loaded plugins
// ----------------------------------------------------------------------------
//
TArray<CMPXCollectionPlugin*> CMPXCollectionPluginHandler::LoadedPlugins()
    {
    return iLoadedPlugins.Array();
    }

// ----------------------------------------------------------------------------
// Remove tasks of a client which is the observer of tasks
// ----------------------------------------------------------------------------
//
void CMPXCollectionPluginHandler::RemoveTask(TAny* aCallback)
    {
    for (TInt i=iLoadedPlugins.Count(); --i>=0; )
        {
        CMPXCollectionPlugin* plugin(iLoadedPlugins[i]);
        if (plugin->Callback()==aCallback)
            {
            MPX_DEBUG1("CMPXCollectoinPluginHandler::RemoveTask removes active task");
            plugin->CancelRequest();
            plugin->CompleteTask();
            plugin->SetCallback(NULL);
            plugin->SetObserver(*iPluginObserver);
            }
        else
            {
            iLoadedPlugins[i]->RemoveTask(aCallback);
            }
        }
    }

// ----------------------------------------------------------------------------
// Get the list of noncacheable attributes
// ----------------------------------------------------------------------------
//
const TArray<TUid> CMPXCollectionPluginHandler::NonCacheableAttributesL(
                                                        const TUid& aPluginId )
    {
    TInt i(KErrNotFound);
    TInt count( iPluginInfoArray.Count() );
    TBool found( EFalse );
    for( i = 0; !found && i < count; ++i )
        {
        if ( iPluginInfoArray[i]->ImplementationUid() == aPluginId )
            {
            found = ETrue;
            break;
            }
        }
    if ( !found )
        {
        User::Leave( KErrNotFound );
        }

    return ((CMPXCollectionPluginInfo*)iPluginInfoArray[i])->NonCacheableAttrs();
    }

// ----------------------------------------------------------------------------
// Get whether the plugin is cacheable or not
// ----------------------------------------------------------------------------
//
TBool CMPXCollectionPluginHandler::PluginCachable( const TUid& aPluginId )
    {
    TUint flags(0);

    TInt count( iPluginInfoArray.Count() );
    for( TInt i = 0; i < count; ++i )
        {
        if ( iPluginInfoArray[i]->ImplementationUid() == aPluginId )
            {
            flags = iPluginInfoArray[i]->Flags();
            break;
            }
        }
    return ((flags&EMPXCollectionPluginFlagCacheable) != 0);
    }

// ----------------------------------------------------------------------------
// CMPXCollectionPluginHandler::LoadedPlugin
// ----------------------------------------------------------------------------
//
CMPXCollectionPlugin* CMPXCollectionPluginHandler::LoadedPlugin(const TUid& aUid)
    {
    CMPXCollectionPlugin* plugin(NULL);
    TInt index(LoadedPluginIndex(aUid));
    if (KErrNotFound != index)
        {
        plugin = iLoadedPlugins[index];
        }
    return plugin;
    }

// ----------------------------------------------------------------------------
// Resolve a plugin to iPlugin, based on properties (iDataType, iExt and iScheme)
// and selection criteria. If selection is by type, then there is always a
// plug-in resolved (if there are any of that type). Room for optimisation!
// ----------------------------------------------------------------------------
//
void CMPXCollectionPluginHandler::ResolvePluginL()
    {
    //
    // Resolve plugin
    //
    TUid pluginUid( KNullUid );
    TInt index( KErrNotFound );
    TPtrC displayName;
    TInt pluginType( EMcUnknown );

    DoResolvePluginL(pluginUid, index, displayName, pluginType );

    iPlugin = CreateCollectionPluginL(pluginUid);
    if(iPlugin != NULL)
    UsePlugin(pluginUid);
    }
// ----------------------------------------------------------------------------
// CMPXCollectionPluginHandler::IsPluginLoaded
// ----------------------------------------------------------------------------
//
TBool CMPXCollectionPluginHandler::IsPluginLoaded(
    const TUid& aPluginUid)
    {
    return LoadedPluginIndex(aPluginUid) != KErrNotFound;
    }

// ----------------------------------------------------------------------------
// CMPXCollectionPluginHandler::LoadPluginL
// ----------------------------------------------------------------------------
//
void CMPXCollectionPluginHandler::LoadPluginL(
    const TUid& aPluginUid)
    {
    (void)CreateCollectionPluginL(aPluginUid);
    }

// ----------------------------------------------------------------------------
// Constructs the collection plugin info class
// ----------------------------------------------------------------------------
//
CMPXPluginInfo* CMPXCollectionPluginHandler::ConstructPluginInfoLC(
                                     const CImplementationInformation& aData  )
    {
    return CMPXCollectionPluginInfo::NewLC( aData );
    }

// ----------------------------------------------------------------------------
// Unloads a specified plugin.
// ----------------------------------------------------------------------------
//
void CMPXCollectionPluginHandler::UnloadPlugin(
    const TUid& aUid)
    {
    MPX_DEBUG3("===>CMPXCollectionPluginHandler::UnloadPlugin 0x%08x uid 0x%08x",
               this, aUid.iUid);
    TInt index(LoadedPluginIndex(aUid));
    if (index != KErrNotFound)
        {
        UnloadPlugin(index);
        }
    MPX_DEBUG3("<===CMPXCollectionPluginHandler::UnloadPlugin 0x%08x uid 0x%08x",
               this, aUid.iUid);
    }

// ----------------------------------------------------------------------------
// Return a plugin controller with the specific id
// ----------------------------------------------------------------------------
//
CMPXCollectionPlugin*
CMPXCollectionPluginHandler::CreateCollectionPluginL(const TUid& aUid)
    {
    MPX_DEBUG3("===>CMPXCollectionPluginHandler::CreateCollectionPluginL 0x%08x uid 0x%08x",
               this, aUid.iUid);

    CMPXCollectionPlugin* p=NULL;

    TInt index(LoadedPluginIndex(aUid));
    if (index == KErrNotFound)
        {
        MPX_DEBUG3("CMPXCollectionPluginHandler::CreateCollectionPluginL create a new plugin 0x%08x uid 0x%08x",
                   this, aUid.iUid);
        TRAPD(err, p = CMPXCollectionPlugin::NewL(aUid, *iPluginObserver));
        if(err == KErrNone)
            {
        CleanupStack::PushL(p);
        iLoadedPlugins.AppendL(p);
        CleanupStack::Pop(p);
            }
        else
            {
            MPX_DEBUG3("CMPXCollectionPluginHandler::CreateCollectionPluginL error creating plugin %d uid 0x%08x",
                               err, aUid.iUid);
            User::Leave(err);
            }
        }
     else
        {
        p = iLoadedPlugins[index];
        }

    MPX_DEBUG3("<===CMPXCollectionPluginHandler::CreateCollectionPluginL 0x%08x uid 0x%08x",
               this, aUid.iUid);

    return p;
    }

// ----------------------------------------------------------------------------
// CMPXCollectionPluginHandler::LoadedPluginIndex
// ----------------------------------------------------------------------------
//
TInt CMPXCollectionPluginHandler::LoadedPluginIndex(const TUid& aUid)
    {
    TInt index(KErrNotFound);

    for (TInt i = iLoadedPlugins.Count(); --i >= 0; )
        {
        if (iLoadedPlugins[i]->Uid() == aUid)
            {
            index = i;
            break;
            }
        }

    return index;
    }

// ----------------------------------------------------------------------------
// CMPXCollectionPluginHandler::UnloadPlugin
// ----------------------------------------------------------------------------
//
void CMPXCollectionPluginHandler::UnloadPlugin(TInt aIndex)
    {
    MPX_DEBUG3("===>CMPXCollectionPluginHandler::UnloadPlugin 0x%08x index 0x%08x",
               this, aIndex);
    CMPXCollectionPlugin* p = iLoadedPlugins[aIndex];
    TRAP_IGNORE(p->CommandL(EMcCmdClose));
    iLoadedPlugins.Remove(aIndex);
    delete p;
    MPX_DEBUG3("<===CMPXCollectionPluginHandler::UnloadPlugin 0x%08x index 0x%08x",
               this, aIndex);
    }

// End of file