/*

* 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:  Media Fetch implementation plug-in loader

*

*/

#include <ecom/ecom.h>

#include "mediafetch.h"

#include "mediafetch.hrh"

#include <mediafetchimplementation.h>

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

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

// CleanupResetAndDestroy

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

//

void CleanupResetAndDestroy( TAny* aObj )

    {

    if( aObj )

        {

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

        }

    }

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

inline CMediaFetch::CMediaFetch()

    {

    }

inline void CMediaFetch::ConstructL( TInt aMediaType )

    {

    RImplInfoPtrArray implementations;

    CleanupStack::PushL( TCleanupItem( CleanupResetAndDestroy,

                                       &implementations) );

    // Get a list of all Media Fetch plug-in implementations

    REComSession::ListImplementationsL(

                            TUid::Uid(  MEDIAFETCH_ECOM_INTERFACE ),

                            implementations );

    TUid uid( TUid::Null() );

    TInt version( -1 );

    const TInt count( implementations.Count() );

    // Loop through all found implementations

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

        {

        CImplementationInformation* implInfo = implementations[i];

        // Get media types supported by the implementation

        // The value is assumed to be in hexadecimal as defined in the

        // Media Fetch Implementation API

        TUint val( 0 );

        TLex8 lex( implInfo->DataType() );

        User::LeaveIfError( lex.Val( val, EHex ) );

        // Check that the implementation supports the wanted media type(s)

        if( ( aMediaType & val ) == aMediaType )

            {

            // Pick implementation with highest version number

            if( implInfo->Version() > version )

                {

                uid = implInfo->ImplementationUid();

                version = implInfo->Version();

                }

            }

        }

	if( uid == TUid::Null() )

		{

		User::Leave( KErrNotSupported );

		}

    // Instatiate the fetcher plug-in implementation

    iFetcher = CMediaFetchImplementation::NewL( uid );

    CleanupStack::PopAndDestroy(); // implementations

    }

CMediaFetch* CMediaFetch::NewL( TInt aMediaType )

    {

    CMediaFetch* self = CMediaFetch::NewLC( aMediaType );

    CleanupStack::Pop( self );

    return self;

    }

CMediaFetch* CMediaFetch::NewLC( TInt aMediaType )

    {

    CMediaFetch* self = new( ELeave ) CMediaFetch;

    CleanupStack::PushL( self );

    self->ConstructL( aMediaType );

    return self;

    }

CMediaFetch::~CMediaFetch()

    {

    delete iFetcher;

    REComSession::FinalClose();

    }

void CMediaFetch::SetMultiSelectionL( TBool aMultiSelect )

    {

    iFetcher->SetMultiSelectionL( aMultiSelect );

    }

void CMediaFetch::SetMimeTypesL( const MDesCArray& aMimeTypes )

    {

    iFetcher->SetMimeTypesL( aMimeTypes );

    }

void CMediaFetch::SetSelectionSoftkeyL( const TDesC& aSelectionSoftkey )

    {

    iFetcher->SetSelectionSoftkeyL( aSelectionSoftkey );

    }

void CMediaFetch::SetHeadingL( const TDesC& aHeading )

    {

    iFetcher->SetHeadingL( aHeading );

    }

void CMediaFetch::SetVerifierL( MMGFetchVerifier& aVerifier )

    {

    iFetcher->SetVerifierL( aVerifier );

    }

void CMediaFetch::GetCancelerL( MMGFetchCanceler*& aCanceler )

    {

    iFetcher->GetCancelerL( aCanceler );

    }

TBool CMediaFetch::LaunchL( CDesCArray& aSelectedFiles,

                            TMediaFileType aMediaType )

    {

    return iFetcher->LaunchL( aSelectedFiles, aMediaType );

    }