/*

* 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:  Playlist Plugin Handler

*

*  CMPXPlaylistPluginHandler inherits from CMPXPluginHandlerBase which owns a

*  CMPXPluginMonitor that monitors playlist plugins.

*

*  CMPXPlaylistPluginHandler also contains a list of loaded playlist plugins.

*  A playlist plugin is added to the list when it's selected for the first

*  time. When a new plugin is installed, CMPXPluginMonitor notifies this plugin

*  handler through CMPXPluginMonitorObserver interface. However, the new plugin

*  will not be loaded at this time until a client explictly selects this new

*  plugin.

*

*  When a plugin is uninstalled, CMPXPluginMonitor also notifies this plugin

*  handler through CMPXPluginMonitorObserver interface. If such plugin is

*  currently loaded, it will be unloaded and removed from the list. All plugins

*  are removed when CMPXPlaylistPluginHandler is destroyed.

*

*

*/

#include <bamdesca.h>

#include <badesca.h>

#include <uri16.h>

#include <apgcli.h>

#include <mpxlog.h>

#include <mpxuser.h>

#include <mpxpluginmonitor.h>

#include <mpxpluginhandlerobserver.h>

#include "mpxplaylistenginedefs.hrh"

#include "mpxplaylistpluginhandler.h"

#include "mpxplaylistplugin.h"

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

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

// Constructor.

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

//

CMPXPlaylistPluginHandler::CMPXPlaylistPluginHandler(

    MMPXPlaylistPluginObserver& aPluginObserver,

    MMPXPluginHandlerObserver& aObserver,

    RFs& aFs,

    const CArrayFix<CCnvCharacterSetConverter::SCharacterSet>& aTopCharacterSet,

    const CArrayFix<CCnvCharacterSetConverter::SCharacterSet>& aAvailableCharacterSet)

:   CMPXPluginHandlerBase(TUid::Uid(KMPXPlaylistInterfaceUid),

                                    ESelectionType,

                                    EMPXPlaylistTypeM3U,

                         aObserver),

    iPluginObserver(aPluginObserver),

    iFs(aFs),

    iTopCharacterSet(aTopCharacterSet),

    iAvailableCharacterSet(aAvailableCharacterSet),

    iPluginUid(KNullUid),

    iPluginType(EMPXPlaylistTypeUnknown)

    {

    }

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

// 2nd phase constructor.

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

//

void CMPXPlaylistPluginHandler::ConstructL()

    {

    BaseConstructL();

    }

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

// Two-phased constructor.

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

//

EXPORT_C CMPXPlaylistPluginHandler* CMPXPlaylistPluginHandler::NewL(

    MMPXPlaylistPluginObserver& aPluginObserver,

    MMPXPluginHandlerObserver& aObserver,

    RFs& aFs,

    const CArrayFix<CCnvCharacterSetConverter::SCharacterSet>& aTopCharacterSet,

    const CArrayFix<CCnvCharacterSetConverter::SCharacterSet>& aAvailableCharacterSet)

    {

    CMPXPlaylistPluginHandler* self = new(ELeave)CMPXPlaylistPluginHandler(

            aPluginObserver, aObserver, aFs, aTopCharacterSet, aAvailableCharacterSet);

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    return self;

    }

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

// Destructor.

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

//

EXPORT_C CMPXPlaylistPluginHandler::~CMPXPlaylistPluginHandler()

    {

    iLoadedPlugins.ResetAndDestroy();

    iLoadedPluginsUids.Close();

    delete iDisplayName;

    }

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

// selects a plug-in appropriate for a Uri and data type

//

// This is a wrapper method for the base class's SelectPluginL to grant client

// access and gives the method name some context.

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

//

EXPORT_C void CMPXPlaylistPluginHandler::SelectPlaylistPluginL(

    const TDesC& aUri,

    const TDesC8& aDataType)

    {

    MPX_DEBUG2("CMPXPlaylistPluginHandler::SelectPlaylistPluginL( URI: %S, DataType )", &aUri);

    ClearSelectionCriteria();

    SelectPluginL( aUri, aDataType );

    }

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

// selects a plug-in appropriate for a file

//

// This is a wrapper method for the base class's SelectPluginL to grant client

// access and gives the method name some context.

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

//

EXPORT_C void CMPXPlaylistPluginHandler::SelectPlaylistPluginL(const RFile& aFile)

    {

    MPX_DEBUG1("CMPXPlaylistPluginHandler::SelectPlaylistPluginL(RFile)");

    ClearSelectionCriteria();

    SelectPluginL( aFile );

    }

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

// selects a plug-in appropriate for a plugin type

//

// This is a wrapper method for the base class's SelectPluginL to grant client

// access and gives the method name some context.

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

//

EXPORT_C void CMPXPlaylistPluginHandler::SelectPlaylistPluginL(

    TUint32 aPluginType)

    {

    MPX_DEBUG2("CMPXPlaylistPluginHandler::SelectPlaylistPluginL( ParserType: %x )", aPluginType);

    SelectPluginL( aPluginType );

    }

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

// selects plug-in with the specified name

//

// This is a wrapper method for the base class's SelectPluginL to grant client

// access and gives the method name some context.

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

//

EXPORT_C void CMPXPlaylistPluginHandler::SelectPlaylistPluginL(

    const TDesC& aPluginName)

    {

    MPX_DEBUG2("CMPXPlaylistPluginHandler::SelectPlaylistPluginL( aPluginName: %S )", &aPluginName);

    SelectPluginL( aPluginName );

    }

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

// select a plugin with the specific id

//

// This is a wrapper method for the base class's SelectPluginL to grant client

// access and gives the method name some context.

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

//

EXPORT_C void CMPXPlaylistPluginHandler::SelectPlaylistPluginL(const TUid& aUid)

    {

    MPX_DEBUG2("CMPXPlaylistPluginHandler::SelectPlaylistPluginL(UID: %x)", aUid.iUid);

    SelectPluginL( aUid );

    }

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

// creates a plugin with the specific id. if already loaded, returns the reference

// without recreating it

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

//

CMPXPlaylistPlugin* CMPXPlaylistPluginHandler::CreatePlaylistPluginL(const TUid& aUid)

    {

    MPX_DEBUG2("CMPXPlaylistPluginHandler::CreatePlaylistPluginL(UID: %x)", aUid.iUid);

    CMPXPlaylistPlugin* p(NULL);

    TInt i=iLoadedPluginsUids.Find(aUid);

    if (i==KErrNotFound)

        {

        p=CMPXPlaylistPlugin::NewL(aUid, iPluginObserver, iFs, iTopCharacterSet, iAvailableCharacterSet);

        CleanupStack::PushL(p);

        iLoadedPlugins.AppendL(p);

        TInt err = iLoadedPluginsUids.Append(aUid);

        if (err != KErrNone) // if the second append failed, it should revert the first append

        	{

        	iLoadedPlugins.Remove(iLoadedPlugins.Count());

        	User::Leave(err);

        	}

        CleanupStack::Pop(p);

        }

     else

        {

        p=iLoadedPlugins[i];

        }

    return p;

    }

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

// Resolve a plugin to iPlugin, based on properties (iDataType, iExt and iScheme)

// and selection criteria.

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

//

void CMPXPlaylistPluginHandler::ResolvePluginL()

    {

    MPX_DEBUG1("CMPXPlaylistPluginHandler::ResolvePluginL");

    //

    // Resolve plugin

    //

    TUid pluginUid( KNullUid );

    TInt index( KErrNotFound );

    TPtrC displayName;

    TInt pluginType( EMPXPlaylistTypeUnknown );

    DoResolvePluginL(pluginUid, index, displayName, pluginType );

    //

    // Load resolved plug-in

    //

    CMPXPlaylistPlugin* p = CreatePlaylistPluginL(pluginUid);

    UsePlugin(pluginUid);

    if (p != iPlugin)

        {

        iPlugin = p;

        iPluginUid = pluginUid;

        delete iDisplayName;

        iDisplayName = NULL;

        iDisplayName = displayName.AllocL();

        iPluginType = pluginType;

        }

    }

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

// CMPXPlaylistPluginHandler::IsPluginLoaded

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

//

TBool CMPXPlaylistPluginHandler::IsPluginLoaded(

    const TUid& aPluginUid)

    {

    return iLoadedPluginsUids.Find(aPluginUid) != KErrNotFound;

    }

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

// CMPXPlaylistPluginHandler::LoadPluginL

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

//

void CMPXPlaylistPluginHandler::LoadPluginL(

    const TUid& aPluginUid)

    {

    (void)CreatePlaylistPluginL(aPluginUid);

    }

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

// Unloads a specified plugin.

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

//

void CMPXPlaylistPluginHandler::UnloadPlugin(

    const TUid& aPluginUid)

    {

    MPX_FUNC("CMPXPlaylistPluginHandler::UnloadPlugin");

    TInt i = iLoadedPluginsUids.Find(aPluginUid);

    if (i != KErrNotFound)

        {

        UnloadPlugin(i);

        }

    }

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

// Unloads a plugin by index.

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

//

void CMPXPlaylistPluginHandler::UnloadPlugin(

    TInt aIndex)

    {

    MPX_FUNC("CMPXPlaylistPluginHandler::UnloadPlugin");

    CMPXPlaylistPlugin* p = iLoadedPlugins[aIndex];

    if (p == iPlugin)

        {

        iPlugin = NULL;

        iPluginUid = KNullUid;

        iPluginType = EMPXPlaylistTypeUnknown;

        delete iDisplayName;

        iDisplayName = NULL;

        }

    iLoadedPlugins.Remove(aIndex);

    iLoadedPluginsUids.Remove(aIndex);

    delete p;

    }

// End of file