/*
* Copyright (c) 2008-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:  Plugin manager, responsible to load the plugins.
*
*/

#include <mpxlog.h>                     // MPX_DEBUG
#include <ecom/ecom.h>
// for CeanupResetAndDestroyPushL
#include <mmf/common/mmfcontrollerpluginresolver.h>

#include "musiccontentpublisher.h"
#include "pluginmanager.h"

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

// ---------------------------------------------------------------------------
// Constructor
// ---------------------------------------------------------------------------
//
CPluginManager::CPluginManager( TUid aUid, 
        TAny* aParameter, 
        CMusicContentPublisher* aContentPublisher) :
                CActive( EPriorityStandard ), 
                iUid( aUid ), 
                iParameter( aParameter ), 
                iContentPublisher(aContentPublisher)
    {
    }

// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
void CPluginManager::ConstructL()
    {
    MPX_DEBUG1("CPluginManager::ConstructL <---");
    iSession = &REComSession::OpenL();
    LoadPluginsL();
    iSession->NotifyOnChange( iStatus );
    CActiveScheduler::Add( this );
    SetActive();
    MPX_DEBUG1("CPluginManager::ConstructL --->");
    }

// ---------------------------------------------------------------------------
// Two-phased constructor.
// ---------------------------------------------------------------------------
//
CPluginManager* CPluginManager::NewL( TUid aUid, 
        TAny *aParameter, 
        CMusicContentPublisher* aContentPublisher )
    {
    CPluginManager* self = CPluginManager::NewLC( aUid, 
            aParameter, 
            aContentPublisher );
    CleanupStack::Pop( self );
    return self;
    }

// ---------------------------------------------------------------------------
// Two-phased constructor.
// ---------------------------------------------------------------------------
//
CPluginManager* CPluginManager::NewLC( TUid aUid, 
        TAny *aParameter,
        CMusicContentPublisher* aContentPublisher )
    {
    CPluginManager* self = new( ELeave ) CPluginManager( aUid, 
            aParameter, 
            aContentPublisher );
    CleanupStack::PushL( self );
    self->ConstructL();
    return self;
    }

// ---------------------------------------------------------------------------
// destructor
// ---------------------------------------------------------------------------
CPluginManager::~CPluginManager()
    {
    MPX_DEBUG1("CPluginManager::~CPluginManager <---");
    Cancel();
    CleanPluginsTable();
    iPluginMap.Close();
    if ( iSession )
        {
        iSession->Close();
        }
    REComSession::FinalClose();
    MPX_DEBUG1("CPluginManager::~CPluginManager --->");
    }

// ---------------------------------------------------------------------------
// Retuns a plugin by UID
// ---------------------------------------------------------------------------
//
TAny* CPluginManager::GetImplementation( TUid aUid )
    {
    TInt32 key = aUid.iUid;
    TAny* ret= NULL;
    TAny** imp= NULL;
    imp = iPluginMap.Find( key );
    if ( imp )
        {
        ret = *imp;
        }
    return ret;
    }

// ---------------------------------------------------------------------------
// Retuns a plugin by index
// ---------------------------------------------------------------------------
//
TAny* CPluginManager::GetImplementation( TInt aIndex )
    {
    TAny* ret= NULL;
    THashMapIter<TInt32, TAny*> iter( iPluginMap );
    TAny*const* ptr = iter.NextValue();
    for ( TInt i( 0 ); ptr; i++ )
        {
        if ( i == aIndex )
            {
            ret = *ptr;
            break;
            }
        ptr = iter.NextValue();
        }
    return ret;
    }

// ---------------------------------------------------------------------------
// Returns the count of the plug-ins.
// ---------------------------------------------------------------------------
//
TInt CPluginManager::GetCount()
    {
    return iPluginMap.Count();
    }

// ---------------------------------------------------------------------------
// Loads the plugins.
// ---------------------------------------------------------------------------
//
void CPluginManager::LoadPluginsL()
    {
    MPX_DEBUG1("CPluginManager::LoadPluginsL <---");
    // Read info about all implementations into infoArray
    RImplInfoPtrArray infoArray;
    CleanupResetAndDestroyPushL( infoArray );

    REComSession::ListImplementationsL( iUid, infoArray );
    for ( TInt i = 0; i < infoArray.Count(); i++ )
        {
        TUid current_plugin = infoArray[i]->ImplementationUid();
        TAny* plug( NULL );
        TUid temp;
        TInt err( KErrNone );
        TRAP( err, plug = REComSession::CreateImplementationL(
                        current_plugin,
                        temp,
                        iParameter ) );
        if ( err == KErrNone && plug )
            {
            CleanupStack::PushL( plug );
            TInt32 key = current_plugin.iUid;
            iPluginMap.InsertL( key, plug );
            CleanupStack::Pop( plug );
            }
        }

    CleanupStack::PopAndDestroy( &infoArray );
    MPX_DEBUG1("CPluginManager::LoadPluginsL --->");
    }

// ---------------------------------------------------------------------------
// Unloads the plgugins.
// ---------------------------------------------------------------------------
//        
void CPluginManager::CleanPluginsTable()
    {
    MPX_DEBUG1("CPluginManager::CleanPluginsTable <---");
    THashMapIter<TInt32, TAny*> iter( iPluginMap );
    TAny*const* ptr = iter.NextValue();
    CBase* plug( NULL );
    const TInt32* pluginUid( NULL );
    while ( ptr )
        {
        plug = static_cast<CBase*>( *ptr );
        delete plug;
        plug = NULL;
        pluginUid = iter.CurrentKey();
        REComSession::DestroyedImplementation( TUid::Uid( *pluginUid ) );
        ptr = iter.NextValue();
        pluginUid = NULL;
        }
    MPX_DEBUG1("CPluginManager::CleanPluginsTable --->");
    }

// ---------------------------------------------------------------------------
//From CActive
// ---------------------------------------------------------------------------
//
void CPluginManager::RunL()
    {
    MPX_DEBUG1("CPluginManager::RunL <---");
    CleanPluginsTable();
    iPluginMap.Close();
    iContentPublisher->ResetL();
    LoadPluginsL();
    iSession->NotifyOnChange( iStatus );
    SetActive();
    MPX_DEBUG1("CPluginManager::RunL --->");
    }

// ---------------------------------------------------------------------------
//From CActive
// ---------------------------------------------------------------------------
//
void CPluginManager::DoCancel()
    {
    MPX_DEBUG1("CPluginManager::DoCancel <---");
    iSession->CancelNotifyOnChange( iStatus );
    MPX_DEBUG1("CPluginManager::DoCancel --->");
    }

// ---------------------------------------------------------------------------
//From CActive
// ---------------------------------------------------------------------------
//
TInt CPluginManager::RunError( TInt /*aError*/ )
    {
    MPX_DEBUG1("CPluginManager::RunError <---");
    MPX_DEBUG1("CPluginManager::RunError --->");
    return KErrNone;
    }

//  End of File