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


#include <ecom/ecom.h>
#include <mmf/common/mmfcontrollerpluginresolver.h>
#include "cpluginvalidator.h"

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

// ----------------------------------------------------------------------------
//
// ----------------------------------------------------------------------------
//
EXPORT_C CPluginValidator* CPluginValidator::NewL( TUid aUid, 
                                                   TAny *aParameter )
    {
    CPluginValidator* self = CPluginValidator::NewLC( aUid , aParameter );
    CleanupStack::Pop( self );
    return self;
    }

// ----------------------------------------------------------------------------
//
// ----------------------------------------------------------------------------
//
EXPORT_C CPluginValidator* CPluginValidator::NewLC( TUid aUid,
                                                    TAny *aParameter )
    {
    CPluginValidator* self = new( ELeave ) CPluginValidator( aUid, 
                                                             aParameter );
    CleanupStack::PushL( self );
    self->ConstructL();
    return self;
    }

// ----------------------------------------------------------------------------
//
// ----------------------------------------------------------------------------
//
EXPORT_C TAny* CPluginValidator::GetImplementation( TUid aUid )
    {
    TPluginInfo pluginInfo;
    pluginInfo.iImplementationUid = aUid;
    TInt index = iPluginArray.Find( pluginInfo, 
    			TIdentityRelation< TPluginInfo >(UidMatch) );    
    return GetImplementation( index );
    }

// ----------------------------------------------------------------------------
//
// ----------------------------------------------------------------------------
//
EXPORT_C TAny* CPluginValidator::GetImplementation( TInt aIndex )
    {
    TAny* ret( NULL ); 
    if (( aIndex != KErrNotFound ) && ( aIndex < iPluginArray.Count() ))
    	{
    	ret= iPluginArray[aIndex].iPlugin;
    	}
    return ret;    
    }

// ----------------------------------------------------------------------------
//
// ----------------------------------------------------------------------------
//
EXPORT_C TInt CPluginValidator::GetCount( )
    {
    return iPluginArray.Count();
    }

// ---------------------------------------------------------------------------
// destructor
// ---------------------------------------------------------------------------
CPluginValidator::~CPluginValidator()
    {
    Cancel();
    CleanPluginsTable();
    iPluginArray.Close( );
    if( iSession )
        {
        iSession->Close();
        }
    REComSession::FinalClose( );
    }
    
// ----------------------------------------------------------------------------
//
// ----------------------------------------------------------------------------
//
void CPluginValidator::RunL()
    {
    ManagePluginsL();
    iSession->NotifyOnChange( iStatus );
    SetActive();    
    }

// ----------------------------------------------------------------------------
//
// ----------------------------------------------------------------------------
//
void CPluginValidator::DoCancel()
    {
    iSession->CancelNotifyOnChange( iStatus );
    }

// ----------------------------------------------------------------------------
//
// ----------------------------------------------------------------------------
//
TInt CPluginValidator::RunError( TInt /*aError*/)
    {
    return KErrNone;
    }
// ----------------------------------------------------------------------------
//
// ----------------------------------------------------------------------------
//
CPluginValidator::CPluginValidator( TUid aUid, TAny* aParameter ): 
                                                  CActive(EPriorityStandard),
                                                  iUid( aUid ),
                                                  iParameter( aParameter )
    {
    
    }

// ----------------------------------------------------------------------------
//
// ----------------------------------------------------------------------------
//
void CPluginValidator::ConstructL()
    {
    iSession = &REComSession::OpenL();
    ManagePluginsL();
    iSession->NotifyOnChange( iStatus );
    CActiveScheduler::Add( this );
    SetActive();
    }

// ----------------------------------------------------------------------------
//
// ----------------------------------------------------------------------------
//
TBool CPluginValidator::PresentInArrayL( TPluginInfo aPluginInfo, 
		const RImplInfoPtrArray& aInfoArray )
	{
	TBool result(EFalse);
	for ( TInt i = 0; i< aInfoArray.Count(); i++ )
		{
		if ( aPluginInfo.iImplementationUid.iUid == 
						aInfoArray[i]->ImplementationUid().iUid)
			{
			result = ETrue;
			break;
			}
		}
	return result;
	}

// ----------------------------------------------------------------------------
//
// ----------------------------------------------------------------------------
//        
void CPluginValidator::DestroyPlugin( TInt aIndex )    
    {
    CBase* plugin = static_cast<CBase*>( iPluginArray[aIndex].iPlugin );
    delete plugin;
    REComSession::DestroyedImplementation( 
    		iPluginArray[aIndex].iDtor_ID_Key );
    }

// ----------------------------------------------------------------------------
//
// ----------------------------------------------------------------------------
//        
void CPluginValidator::CleanPluginsTable()    
    {
    for ( TInt i = 0; i < iPluginArray.Count(); i++ )
    	{
    	DestroyPlugin( i );
    	}
    }

// ----------------------------------------------------------------------------
//
// ----------------------------------------------------------------------------
//
void CPluginValidator::ManagePluginsL()    
    {
    // Read info about all implementations into infoArray
    RImplInfoPtrArray infoArray;
    CleanupResetAndDestroyPushL( infoArray );
	
    REComSession::ListImplementationsL( iUid , infoArray );
    TPluginInfo pluginInfo;   
    //Load new plugins
    for ( TInt i = 0; i < infoArray.Count( ); i++ )
        {
        pluginInfo.iImplementationUid = infoArray[i]->ImplementationUid( );
        pluginInfo.iVersion = infoArray[i]->Version();
        
        TInt index = iPluginArray.Find( pluginInfo, 
        			TIdentityRelation< TPluginInfo >(UidMatch) );
        
        if ( index == KErrNotFound )
        	{
        	//plugin wasn't present, we load it now
			LoadPluginL( pluginInfo );
        	}
        else if ( pluginInfo.iVersion > iPluginArray[index].iVersion )
        	{
        	//plugin was present but it is a newer version, 
        	//remove old and load a new one
			DestroyPlugin( index );
			iPluginArray.Remove( index );
			LoadPluginL( pluginInfo );
        	}
        }
    //Remove old plugins
    for ( TInt i = iPluginArray.Count() - 1 ; i >= 0; i-- )
    	{
    	pluginInfo = iPluginArray[i];
    	if ( !PresentInArrayL( pluginInfo, infoArray ) )
    		{
    		DestroyPlugin( i );
    	    iPluginArray.Remove( i );
    		}
    	}
    CleanupStack::PopAndDestroy( &infoArray );    
    }

// ----------------------------------------------------------------------------
//
// ----------------------------------------------------------------------------
//
void CPluginValidator::LoadPluginL( TPluginInfo& aPluginInfo )    
    {
	TAny* plug ( NULL );
	TInt err( KErrNone );
	TRAP( err, plug = REComSession::CreateImplementationL( 
										aPluginInfo.iImplementationUid, 
										aPluginInfo.iDtor_ID_Key, iParameter ) );
	if( err==KErrNone && plug ) 
		{
		CleanupStack::PushL( plug );
		aPluginInfo.iPlugin = plug;
		iPluginArray.AppendL( aPluginInfo );
		CleanupStack::Pop( plug );
		}
   	}