/*
* 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:  Implements the playback plugin handler.
*
*  There is just one plaback plugin loaded for each plugin handler / engine and
*  whenever a new plugin is selected for the engine the old one is automatically
*  unloaded. Different engines can load multiple instances of the same playback
*  plugin, however there is no connection between these instances as they
*  are tied to different songs.
*
*  There is no point in applying the reference counting mechanism for playback.
*
*
*/


#include <mpxplaybackplugin.h>
#include <mpxplaybackpluginobserver.h>
#include <mpxpluginmonitor.h>
#include <mpxlog.h>
#include "mpxplaybackplugininfo.h"
#include "mpxplaybackpluginhandler.h"

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

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

// ----------------------------------------------------------------------------
// Constructor.
// ----------------------------------------------------------------------------
//
CMPXPlaybackPluginHandler::CMPXPlaybackPluginHandler(
    CMPXPluginMonitor& aPluginMonitor,
    MMPXPlaybackPluginObserver& aPluginObserver,
    MMPXPluginHandlerObserver& aObserver)
:   CMPXPluginHandlerBase(KMPXPlaybackInterfaceUid,
                          ESelectionType,
                          EPbLocal,
                          aObserver,
                          &aPluginMonitor),
    iPluginObserver(&aPluginObserver),
    iSelectedSubPlayerIndex(KErrNotFound)
    {
    }

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

// ----------------------------------------------------------------------------
// Destructor.
// ----------------------------------------------------------------------------
//
CMPXPlaybackPluginHandler::~CMPXPlaybackPluginHandler()
    {
    MPX_FUNC_EX("CMPXPlaybackPluginHandler::Destructor");
    //close plugins
    for (TInt i = iLoadedPlugins.Count(); --i >= 0;)
        {
        CMPXPlaybackPlugin* p=iLoadedPlugins[i];
        TRAP_IGNORE(p->CommandL(EPbCmdClose));
        }
    iLoadedPlugins.ResetAndDestroy();
    iLoadedPluginsUids.Close();
    delete iDisplayName;
    }

// ----------------------------------------------------------------------------
// 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 CMPXPlaybackPluginHandler::ResolvePluginL()
    {
    MPX_FUNC_EX("CMPXPlaybackPluginHandler::ResolvePluginL()");
    //
    // Resolve plugin
    //
    TUid pluginUid( KNullUid );
    TInt index( KErrNotFound );
    TPtrC displayName;
    TInt pluginType( EPbUnknown );

    DoResolvePluginL(pluginUid, index, displayName, pluginType );

    //
    // Load resolved plug-in
    //
    CMPXPlaybackPlugin* p=CreatePlayerPluginL(pluginUid);
    UsePlugin(pluginUid);

    MPX_DEBUG5("CMPXPlaybackPluginHandler::ResolvePluginL() p(%08x), iPlugin(%08x), pluginUid 0x%08x %S",
                p, iPlugin, pluginUid.iUid, &displayName);
    if (p!=iPlugin)
        {
        if (iPlugin)
            {
            UnloadPlugin(iPluginUid);
            }
        iPlugin=p;
        iPluginUid=pluginUid;

        delete iDisplayName;
        iDisplayName=NULL;
        iDisplayName=displayName.AllocL();
        iPluginType=static_cast<TMPXPlaybackPlayerType>(pluginType);
        }

    if (iSelectedSubPlayerIndex!=KErrNotFound)
        {
        iPlugin->SelectSubPlayerL(iSelectedSubPlayerIndex);
        }
    }

// ----------------------------------------------------------------------------
// Return a plugin with the specific id
// ----------------------------------------------------------------------------
//
CMPXPlaybackPlugin* CMPXPlaybackPluginHandler::CreatePlayerPluginL(
    const TUid& aUid)
    {
    MPX_DEBUG3("==>CMPXPlaybackPluginHandler::CreatePlayerPluginL 0x%08x (aUid 0x%08x)",
               this, aUid.iUid);
    CMPXPlaybackPlugin* p=NULL;
    TInt i=iLoadedPluginsUids.Find(aUid);
    if (i==KErrNotFound)
        {
        p=CMPXPlaybackPlugin::NewL(aUid,*iPluginObserver);
        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()-1);
             User::Leave(err);
             }
        CleanupStack::Pop(p);
        }
     else
        {
        p=iLoadedPlugins[i];
        }
    MPX_DEBUG3("<==CMPXPlaybackPluginHandler::CreatePlayerPluginL 0x%08x (aUid 0x%08x)",
               this, aUid.iUid);
    return p;
    }

// ----------------------------------------------------------------------------
// CMPXPlaybackPluginHandler::IsPluginLoaded
// ----------------------------------------------------------------------------
//
TBool CMPXPlaybackPluginHandler::IsPluginLoaded(
    const TUid& aPluginUid)
    {
    MPX_FUNC_EX("CMPXPlaybackPluginHandler::IsPluginLoaded");
    return (iLoadedPluginsUids.Find(aPluginUid) != KErrNotFound);
    }

// ----------------------------------------------------------------------------
// CMPXPlaybackPluginHandler::LoadPluginL
// ----------------------------------------------------------------------------
//
void CMPXPlaybackPluginHandler::LoadPluginL(
    const TUid& aPluginUid)
    {
    MPX_DEBUG2("===>CMPXPlaybackPluginHandler::LoadPluginL 0x%08x", this);

    if (iPlugin)
        {
        UnloadPlugin(iPluginUid);
        }

    iPlugin = CreatePlayerPluginL(aPluginUid);
    iPluginUid = aPluginUid;

    delete iDisplayName;
    iDisplayName = NULL;
    iDisplayName = PluginName(aPluginUid).AllocL();
    MPX_DEBUG3("<===CMPXPlaybackPluginHandler::LoadPluginL 0x%08x plugin name %S",
               this, iDisplayName);
    }

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

// ----------------------------------------------------------------------------
// Unload the plugin
// ----------------------------------------------------------------------------
//
void CMPXPlaybackPluginHandler::UnloadPlugin(
    const TUid& aUid)
    {
    MPX_FUNC_EX("CMPXPlaybackPluginHandler::UnloadPlugin");

    TInt index(iLoadedPluginsUids.Find(aUid));
    if (index != KErrNotFound)
        {
        UnloadPlugin(index);
        }
    }

// ----------------------------------------------------------------------------
// Return player name
// ----------------------------------------------------------------------------
//
EXPORT_C const TDesC& CMPXPlaybackPluginHandler::PlayerName(
    TMPXPlaybackPlayerType aType) const
    {
    MPX_FUNC("CMPXPlaybackPluginHandler::PlayerName()");
    return PluginName(aType);
    }

// ----------------------------------------------------------------------------
// Get player list with the specific type
// ----------------------------------------------------------------------------
//
EXPORT_C void CMPXPlaybackPluginHandler::GetPlayerListL(
    RArray<TUid>& aPlayers,
    TMPXPlaybackPlayerType aType)
    {
    MPX_FUNC("CMPXPlaybackPluginHandler::GetPlayerListL()");
    GetPluginUidsL(aPlayers, aType);
    }

// ----------------------------------------------------------------------------
// Select players with the specific type
// ----------------------------------------------------------------------------
//
EXPORT_C void CMPXPlaybackPluginHandler::SelectPlayersL(
    TMPXPlaybackPlayerType aType)
    {
    MPX_FUNC("CMPXPlaybackPluginHandler::SelectPlayersL(TMPXPlaybackPlayerType aType)");
    iSelectedSubPlayerIndex=KErrNotFound;
    SelectPluginL(aType);
    }

// ----------------------------------------------------------------------------
// Returns plug-in appropriate for a Uri and data type
// ----------------------------------------------------------------------------
//
void CMPXPlaybackPluginHandler::SelectPlayerL(
    const TDesC& aUri,
    const TDesC8& aDataType)
    {
    MPX_FUNC("CMPXPlaybackPluginHandler::SelectPlayerL(const TDesC& aUri)");
    MPX_DEBUG2("CMPXPlaybackPluginHandler::SelectPlayerL(aUri %S)", &aUri);
    SelectPluginL( aUri, aDataType );
    }

// ----------------------------------------------------------------------------
// Returns plug-in appropriate for a file; may already be loaded or not
// ----------------------------------------------------------------------------
//
void CMPXPlaybackPluginHandler::SelectPlayerL(RFile& aFile)
    {
    MPX_FUNC("CMPXPlaybackPluginHandler::SelectPlayerL(RFile& aFile)");
    SelectPluginL( aFile );
    }

// ----------------------------------------------------------------------------
// Select players with the specific UID
// ----------------------------------------------------------------------------
//
EXPORT_C void CMPXPlaybackPluginHandler::SelectPlayerL(TUid aPlayerUid)
    {
    MPX_FUNC("CMPXPlaybackPluginHandler::SelectPlayerL(TUid aPlayerUid)");
    SelectSubPlayerL(aPlayerUid,KErrNotFound);
    iSelectedType = iPluginType;
    }

// ----------------------------------------------------------------------------
// Select subplayer
// ----------------------------------------------------------------------------
//
EXPORT_C void CMPXPlaybackPluginHandler::SelectSubPlayerL(
    TUid aPlayerUid,
    TInt aSubPlayerIndex)
    {
    MPX_FUNC("CMPXPlaybackPluginHandler::SelectPlayerL(TUid aPlayerUid, TInt aSubPlayerIndex)");
    MPX_DEBUG3("CMPXPlaybackPluginHandler::SelectPlayerL(0x%08x, %d)", aPlayerUid.iUid, aSubPlayerIndex);
    iSelectedSubPlayerIndex=aSubPlayerIndex;
    SelectPluginL(aPlayerUid);
    }

// ----------------------------------------------------------------------------
// Clear selection
// ----------------------------------------------------------------------------
//
EXPORT_C void CMPXPlaybackPluginHandler::ClearSelectPlayersL()
    {
    MPX_FUNC("CMPXPlaybackPluginHandler::ClearSelectPlayersL()");
    SelectPlayersL(EPbLocal);
    }

// ----------------------------------------------------------------------------
// Get current selection
// ----------------------------------------------------------------------------
//
EXPORT_C void CMPXPlaybackPluginHandler::GetSelection(
    TMPXPlaybackPlayerType& aType,
    TUid& aPlayer,
    TInt& aSubPlayerIndex,
    TPtrC& aSubPlayerName)
    {
    MPX_FUNC("CMPXPlaybackPluginHandler::GetSelectionL()");
    aType=iPluginType;
    aPlayer=iSelectedUid;
    aSubPlayerIndex=iSelectedSubPlayerIndex;
    if ( iPlugin )
        {
        aSubPlayerName.Set(iPlugin->SubPlayerName());
        }
    else
        {
        aSubPlayerName.Set(KNullDesC);
        }
    }

// ----------------------------------------------------------------------------
// Return a list of interfaces supported by the plugins
// ----------------------------------------------------------------------------
//
EXPORT_C CDesCArray* CMPXPlaybackPluginHandler::SupportedInterfacesL()
    {
    CDesCArray* descArray = new(ELeave)CDesCArrayFlat(KMPXArrayGranularity);
    for(TInt i=iPluginInfoArray.Count();--i>=0;)
        {
        CMPXPlaybackPluginInfo* pi = 
            static_cast<CMPXPlaybackPluginInfo*>(iPluginInfoArray[i]);
        MPXUser::MergeArray(pi->SupportedInterfaces(), *descArray);
        }
    return descArray;
    }

// ----------------------------------------------------------------------------
// Return a list of interfaces supported by the plugins
// ----------------------------------------------------------------------------
//
EXPORT_C CDesCArray* CMPXPlaybackPluginHandler::SupportedInterfacesL(const TUid& aUid)
    {
    CDesCArray* descArray = new(ELeave)CDesCArrayFlat(KMPXArrayGranularity);
    CleanupStack::PushL(descArray);
    for(TInt i=iPluginInfoArray.Count();--i>=0;)
        {
        if (aUid == iPluginInfoArray[i]->ImplementationUid())
            {
            CMPXPlaybackPluginInfo* pi = 
                static_cast<CMPXPlaybackPluginInfo*>(iPluginInfoArray[i]);            
            MPXUser::CopyArrayL(pi->SupportedInterfaces(), *descArray);
            break;
            }
        }
    CleanupStack::Pop(descArray);
    return descArray;
    }

// ----------------------------------------------------------------------------
// CMPXPlaybackPluginHandler::UnloadPlugin
// ----------------------------------------------------------------------------
//
void CMPXPlaybackPluginHandler::UnloadPlugin(
    TInt aIndex)
    {
    CMPXPlaybackPlugin* p = iLoadedPlugins[aIndex];
    TRAP_IGNORE(p->CommandL(EPbCmdClose));
    iLoadedPlugins.Remove(aIndex);
    iLoadedPluginsUids.Remove(aIndex);
    if (p == iPlugin)
        {
        iPlugin = NULL;
        }
    delete p;
    }

#ifdef SYMBIAN_ENABLE_64_BIT_FILE_SERVER_API
// ----------------------------------------------------------------------------
// Returns plug-in appropriate for a file; may already be loaded or not
// ----------------------------------------------------------------------------
//
void CMPXPlaybackPluginHandler::SelectPlayer64L(RFile64& aFile)
    {
    MPX_FUNC("CMPXPlaybackPluginHandler::SelectPlayer64L(RFile64& aFile)");
    SelectPlugin64L( aFile );
    }
#endif // SYMBIAN_ENABLE_64_BIT_FILE_SERVER_API

// end of file