/*

* 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:  Base plugin handler

*

*  CMPXPluginHandlerBase instantiates and owns a CMPXPluginMonitor to monitor

*  plugins for the designated plugin interface. When a plugin for that plugin

*  interface is added/removed, PluginsChangedL is called. This base plugin

*  handler provides a default implementation for PluginsChangedL which requests

*  child class to perform plugin resolution.

*

*  CMPXPluginHandlerBase also provides plugin selection plugin APIs. These

*  methods set up the selection criteria and then request child class to

*  resolve these selection criteria to a plugin via ResolvePluginL.

*

*

*/

#include <bamdesca.h>

#include <badesca.h>

#include <uri16.h>

#include <apgcli.h>

#include <mpxlog.h>

#include <mpxuser.h>

#include <mpxpluginmonitor.h>

#include <mpxcmn.h>

#include <mpxplugininfo.h>

#include "mpxpluginhandlerobserver.h"

#include "mpxpluginhandlerbase.h"

// CONSTANTS

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

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

// Local function to cleanup an array

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

//

static void CleanupPluginInfoArray(

    TAny* item)

    {

    ((RPointerArray<CMPXPluginInfo>*)item)->ResetAndDestroy();

    ((RPointerArray<CMPXPluginInfo>*)item)->Close();

    }

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

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

// Constructor.

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

//

EXPORT_C CMPXPluginHandlerBase::CMPXPluginHandlerBase(

    TUid aInterfaceUid,

    TPluginSelection aSelection,

    TInt aSelectionType,

    MMPXPluginHandlerObserver& aObserver,

    CMPXPluginMonitor* aPluginMonitor/*=NULL*/)

:   iObserver(aObserver),

    iInterfaceUid(aInterfaceUid),

    iPluginMonitor(aPluginMonitor),

    iSelection(aSelection),

    iSelectedType(aSelectionType)

    {

    iOwnedPluginMonitor = iPluginMonitor ? EFalse : ETrue;

    }

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

// 2nd phase constructor.

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

//

EXPORT_C void CMPXPluginHandlerBase::BaseConstructL()

    {

    CreatePluginListL();

    if (iOwnedPluginMonitor)

        {

        iPluginMonitor = CMPXPluginMonitor::NewL(iInterfaceUid);

        }

    iPluginMonitor->AddObserverL(*this);

    }

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

// Destructor.

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

//

EXPORT_C CMPXPluginHandlerBase::~CMPXPluginHandlerBase()

    {

    if ( iPluginMonitor )

        {

        TRAP_IGNORE( iPluginMonitor->RemoveObserverL( *this ) );

        }

    if (iOwnedPluginMonitor)

        {

        delete iPluginMonitor;

        }

    delete iDataType;

    delete iScheme;

    delete iExt;

    iPluginInfoArray.ResetAndDestroy();

    }

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

// Select this specific plugin

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

//

EXPORT_C void CMPXPluginHandlerBase::SelectPluginL(const TUid& aPluginUid)

    {

    MPX_DEBUG2("CMPXPluginHandlerBase::SelectPluginL(Uid 0x%08x)", aPluginUid.iUid);

    ClearSelectionCriteria();

    iSelection=ESelectionUid;

    iSelectedUid=aPluginUid;

    ResolvePluginL();

    MPX_DEBUG1("<--CMPXPluginHandlerBase::SelectPluginL() exits");

    }

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

// select the plugin with the specified name

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

//

EXPORT_C void CMPXPluginHandlerBase::SelectPluginL(const TDesC& aPluginName)

    {

    MPX_DEBUG2("CMPXPluginHandlerBase::SelectPluginL(PluginName %S)", &aPluginName);

    SelectPluginL( PluginUid( aPluginName ) );

    MPX_DEBUG1("<--CMPXPluginHandlerBase::SelectPluginL() exits");

    }

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

// Set up selection criteria, e.g. data type, extension, and scheme and then

// resolve plugin

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

//

EXPORT_C void CMPXPluginHandlerBase::SelectPluginL(

    const TDesC& aUri,

    const TDesC8& aDataType)

    {

    MPX_FUNC("CMPXPluginHandlerBase::PluginL");

    delete iScheme;

    iScheme=NULL;

    delete iExt;

    iExt=NULL;

    delete iDataType;

    iDataType=NULL;

    TPtrC fullpath;

    TUriParser up;

    TParse fp;

    //

    // Is it a valid URI, or even full path (e.g. c:\\data\test.mp3")

    //

    if (up.Parse(aUri)==KErrNone)

        {

        const TDesC& uriScheme=up.Extract(EUriScheme);

        //

        // Could be just drive letter if path

        // which isn't really a scheme

        //

        if (uriScheme.Length()>1)

             {

             iScheme=MPXUser::Alloc8L(uriScheme);

             }

         else if (fp.Set(aUri,NULL,NULL)==KErrNone) // Must be a full path

             {

             fullpath.Set(fp.FullName());

             }

         else

             {

             User::Leave(KErrArgument);

             }

        //

        // Get the extension

        //

        iExt=MPXUser::Alloc8L(fp.Ext());

        }

    if (aDataType.Length())

        {

        iDataType=aDataType.AllocL();

        }

    else if (fullpath.Length())

        {

        RApaLsSession aps;

        TInt error  = aps.Connect(); // always fail in console test

        if (KErrNone == error)

            {

            CleanupClosePushL(aps);

            TDataType dataType;

            TUid ignore;

            if(aps.AppForDocument(fullpath,ignore,dataType)==KErrNone)

                {

                iDataType=dataType.Des8().AllocL();

                }

            CleanupStack::PopAndDestroy(&aps);

            } // else APPARC is not working in Console environment,

              // Always find plugin by scheme & etension

        }

    else

        {

        if ( !iScheme ) // last valid case

            {

            User::Leave(KErrArgument);

            }

        }

    ResolvePluginL();

    }

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

// Select a plugin with the specific type

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

//

EXPORT_C void CMPXPluginHandlerBase::SelectPluginL(TInt aPluginType)

    {

    MPX_DEBUG2("CMPXPluginHandlerBase::SelectPluginL(PluginType %x)", aPluginType);

    ClearSelectionCriteria();

    iSelectedType=aPluginType;

    ResolvePluginL();

    MPX_DEBUG1("<--CMPXPluginHandlerBase::SelectPluginL() exits");

    }

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

// select plug-in appropriate for a file

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

//

EXPORT_C void CMPXPluginHandlerBase::SelectPluginL(const RFile& aFile)

    {

    MPX_FUNC("CMPXPluginHandlerBase::SelectPluginL(RFile)");

    TFileName fn;

    User::LeaveIfError(aFile.FullName(fn));

    SelectPluginL(fn, KNullDesC8);

    }

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

// CMPXPluginHandlerBase::UsePlugin

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

//

EXPORT_C void CMPXPluginHandlerBase::UsePlugin(

    const TUid& aPluginUid)

    {

    MPX_FUNC_EX("CMPXPluginHandlerBase::UsePlugin");

    TInt index(IndexOf(aPluginUid));

    if (index != KErrNotFound)

        {

        iPluginInfoArray[index]->ReferenceCount()++;

        }

    }

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

// CMPXPluginHandlerBase::ReleasePlugin

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

//

EXPORT_C TBool CMPXPluginHandlerBase::ReleasePlugin(

    const TUid& aPluginUid)

    {

    MPX_FUNC_EX("CMPXPluginHandlerBase::ReleasePlugin");

    TBool unload(EFalse);

    TInt index(IndexOf(aPluginUid));

    if (index != KErrNotFound)

        {

        TInt& refCount = iPluginInfoArray[index]->ReferenceCount();

        refCount--;

        if (!refCount)

            {

            UnloadPlugin(aPluginUid);

            unload = ETrue;

            }

        }

    return unload;

    }

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

// Get current selection criteria

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

//

EXPORT_C void CMPXPluginHandlerBase::GetSelectionCriteria(

    TPluginSelection& aPluginSelection,

    TInt& aPluginType,

    TUid& aPluginUid,

    TPtrC8& aDataType,

    TPtrC8& aScheme,

    TPtrC8& aExtension)

    {

    aPluginSelection=iSelection;

    aPluginType=iSelectedType;

    aPluginUid=iSelectedUid;

    aDataType.Set(*iDataType);

    aScheme.Set(*iScheme);

    aExtension.Set(*iExt);

    }

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

// Clear current selection criteria

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

//

EXPORT_C void CMPXPluginHandlerBase::ClearSelectionCriteria()

    {

    iSelection=ESelectionType;

    iSelectedType=0; // unknown type. this info is unknown

    iSelectedUid=KNullUid;

    delete iScheme;

    iScheme=NULL;

    delete iExt;

    iExt=NULL;

    delete iDataType;

    iDataType=NULL;

    }

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

// Resolve a plugin, 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).

// TO-DO: Room for optimisation

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

//

EXPORT_C void CMPXPluginHandlerBase::DoResolvePluginL(

    TUid& aPluginUid,

    TInt& aIndex,

    TPtrC& aDisplayName,

    TInt& aPluginType)

    {

    MPX_DEBUG2("===>CMPXPluginHandlerBase::DoResolvePluginL 0x%08x", this);

    TInt index=KErrNotFound;

    if (iSelection==ESelectionUid)

        {

        index=IndexOf(iSelectedUid);

        }

    else // if (iSelection==ESelectionType)

        {

        TInt score=0;

        TInt maxScore=0;

        TInt count(iPluginInfoArray.Count());

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

            {

            // Must scan from beginning of plugin info array, because plugins

            // sorted by priority descendingly

            score=0;

            //

            // First, try scheme then data type, then extension

            // and total up the points

            //

            HBufC* hbuf = NULL;

            TInt pos(0);

            const CDesCArray& schemas = iPluginInfoArray[i]->SupportedSchemas();

            if (schemas.MdcaCount() && iScheme)

                {

                if (iScheme->Length())

                    {

                    hbuf = MPXUser::AllocL(*iScheme);

                    if (!schemas.FindIsq(*hbuf, pos))

                        { // schema supported by the plugin

                        score+=4;

                        }

                    delete hbuf;

                    hbuf=NULL;

                    }

                } // else schema not supported

            if (iDataType)

                {

                hbuf = MPXUser::AllocL(*iDataType);

                if (!iPluginInfoArray[i]->SupportedMimeTypes().FindIsq(*hbuf, pos))

                    { // mime type supported by the plugin

                    score+=3;

                    }

                delete hbuf;

                hbuf=NULL;

                }

            if (iExt)

                {

                hbuf = MPXUser::AllocL(*iExt);

                if (!iPluginInfoArray[i]->SupportedExtensions().FindIsq(*hbuf, pos))

                    { // extension supported by the plugin

                    score+=2;

                    }

                delete hbuf;

                hbuf=NULL;

                }

            if (iSelectedType == iPluginInfoArray[i]->PluginType().iUid)

                {

                score+=1; // Just for being the right "type"

                }

            if (score > maxScore)

                {

                maxScore=score;

                index=i;

                }

            }

        }

    if (index==KErrNotFound)

        {

        User::Leave(KErrNotSupported);

        }

    //

    // set return values

    //

    aPluginUid = iPluginInfoArray[index]->ImplementationUid();

    aIndex = index;

    aDisplayName.Set(iPluginInfoArray[index]->DisplayName());

    aPluginType = iPluginInfoArray[index]->PluginType().iUid;

#ifdef _DEBUG

    PrintPluginInfo();

#endif

    MPX_DEBUG5("<===CMPXPluginHandlerBase::DoResolvePluginL 0x%08x (aPluginUid 0x%08x, aIndex %d, aDisplayName %S)",

               this, aPluginUid.iUid, aIndex, &aDisplayName);

    }

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

// Handles request completion event

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

//

EXPORT_C void CMPXPluginHandlerBase::PluginsChangedL()

    {

    MPX_DEBUG2("===> CMPXPluginHandlerBase::PluginsChangedL 0x%08x", this);

    CreatePluginListL();

    ResolvePluginL();

    MPX_DEBUG2("<=== CMPXPluginHandlerBase::PluginsChangedL 0x%08x", this);

    }

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

// Handles a plugin unload request

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

//

EXPORT_C void CMPXPluginHandlerBase::HandlePluginUnload(

    const TUid& aPluginUid)

    {

    UnloadPlugin(aPluginUid);

    }

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

// Resolve a plugin

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

//

EXPORT_C void CMPXPluginHandlerBase::ResolvePluginL()

    {

    // Do nothing in base class

    }

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

// CMPXPluginHandlerBase::IsPluginLoaded

// This method had to be made virtual (and not pure virtual) because

// the playlist engine instantiates the base class.

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

//

EXPORT_C TBool CMPXPluginHandlerBase::IsPluginLoaded(

    const TUid& /* aPluginUid */)

    {

    return EFalse;

    }

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

// CMPXPluginHandlerBase::LoadPluginL

// This method had to be made virtual (and not pure virtual) because

// the playlist engine instantiates the base class.

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

//

EXPORT_C void CMPXPluginHandlerBase::LoadPluginL(

    const TUid& /* aPluginUid */)

    {

    // do nothing

    }

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

// CMPXPluginHandlerBase::UnloadPlugin

// This method had to be made virtual (and not pure virtual) because

// the playlist engine instantiates the base class.

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

//

EXPORT_C void CMPXPluginHandlerBase::UnloadPlugin(

    const TUid& /* aPluginUid */)

    {

    // do nothing

    }

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

// Return a new instance of the plugin info class

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

//

EXPORT_C CMPXPluginInfo* CMPXPluginHandlerBase::ConstructPluginInfoLC(

                                     const CImplementationInformation& aData  )

    {

    return CMPXPluginInfo::NewLC( aData );

    }

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

// Return plugin name which supports the specified type

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

//

EXPORT_C const TDesC& CMPXPluginHandlerBase::PluginName(

    TInt aPluginType) const

    {

    const TDesC* name=&KNullDesC;

    for ( TInt i=iPluginInfoArray.Count(); --i >= 0 ; )

        {

        if ( aPluginType == iPluginInfoArray[i]->PluginType().iUid )

            {