/*

* 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:  Manages collection information for the clients

*

*/

#include <driveinfo.h>

#include <sysutil.h> 

#include <mpxprivatecrkeys.h>

#include <mpxcollectionpath.h>

#include <mpxcollectionobserver.h>

#include <mpxclientlist.h>

#include <mpxcmn.h>

#include <mpxcollectiontype.h>

#include <mpxmediageneraldefs.h>

#include <mpxmediacontainerdefs.h>

#include <mpxmedia.h>

#include <mpxmediaarray.h>

#include <mpxpluginmonitor.h>

#include <mpxcollectionmessage.h>

#include <mpxcollectionplugin.hrh>

#include <mpxcollectionplugin.h>

#include <mpxcollectionmessagedefs.h>

#include <mpxmessagegeneraldefs.h>

#include <mpxmessagecontainerdefs.h>

#include <mpxmessagepluginupdatedefs.h>

#include "mpxcollectionpluginhandler.h"

#include "mpxcollectioncache.h"

#include "mpxcollectionengine.h"

// CONSTANTS

const TInt KMPXMaxCacheSizeRatio = 70;

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

/**

* Container class for the plugin reference counting mechanism.

* Instances of this class are pushed onto the engine internal stack.

*/

class TReleaseInfo

    {

    public:

        TReleaseInfo(CMPXCollectionPluginHandler* aHandler,

            CMPXCollectionPlugin* aPlugin);

    public:

        // Not owned

        CMPXCollectionPluginHandler* iHandler;

        CMPXCollectionPlugin* iPlugin;

    };

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

// Constructor.

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

//

TReleaseInfo::TReleaseInfo(

    CMPXCollectionPluginHandler* aHandler,

    CMPXCollectionPlugin* aPlugin) :

    iHandler(aHandler),

    iPlugin(aPlugin)

    {

    }

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

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

// Two-phased constructor.

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

//

EXPORT_C CMPXCollectionEngine* CMPXCollectionEngine::NewL()

    {

    CMPXCollectionEngine* p=new(ELeave)CMPXCollectionEngine();

    CleanupStack::PushL(p);

    p->ConstructL();

    CleanupStack::Pop(p);

    return p;

    }

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

// Constructor.

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

//

CMPXCollectionEngine::CMPXCollectionEngine()

    {

    }

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

// 2nd phase constructor.

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

//

void CMPXCollectionEngine::ConstructL()

    {

    iPluginHandler=CMPXCollectionPluginHandler::NewL(*this, *this);

    iCache = CMPXCollectionCache::NewL(KMPXMaxCacheSizeRatio);

    }

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

// Destructor

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

//

EXPORT_C CMPXCollectionEngine::~CMPXCollectionEngine()

    {

    iCleanupStack.Close();

    iContexts.ResetAndDestroy();

    iContexts.Close();

    delete iPluginHandler;

    delete iCache;

    }

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

// Session Initialiser

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

//

EXPORT_C CMPXCollectionClientContext& CMPXCollectionEngine::SessionInitL(

    const TUid& aModeId,

    TThreadId aClientId,

    CMPXMessageQueue* aMsgQueue)

    {

    CMPXCollectionClientContext* context(NULL);

    if (aModeId == KMcModeDefault)

        {

        // Connects the client to the collection path in its thread, or

        // creates one if it doesn't exist

        context = FindDefaultContext(aClientId);

        if (context)

            {

            MPX_DEBUG1("CMPXCollectionEngine add client into the default context");

            }

        else

            {

            // Creates a isolated collection path.

            context = CreateNewContextL(KMcModeIsolated);

            MPX_DEBUG1("CMPXCollectionEngine add client into the isolated context");

            }

        }

     else if (aModeId == KMcModeIsolated || aModeId == KMcModePlaylist)

        {

        // Creates a isolated collection path.

        context = CreateNewContextL(aModeId);

        MPX_DEBUG1("CMPXCollectionEngine add client into the isolated/playlist context");

        }

     else

        // Connects to the collection context of an application, or creates

        // it if it doesn't exist

        {

        for (TInt i=0;i<iContexts.Count();++i)

            {

            if (iContexts[i]->ModeId() == aModeId)

                {

                context = iContexts[i];

                break;

                }

            }

        if (!context)

            {

            // Create the application context

            context = CreateNewContextL(aModeId);

            }

        MPX_DEBUG1("CMPXCollectionEngine add client into the application context");

        }

    context->AddClientL(aClientId, aMsgQueue);

    MPX_DEBUG3("CMPXCollectionEngine::SessionInitL return context 0x%08x with mode 0x%08x",

               context, context->ModeId().iUid);

    return *context;

    }

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

// Notifies all contexts of an event

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

//

EXPORT_C void CMPXCollectionEngine::NotifyL( TMPXCollectionBroadCastMsg aMsg,

                                             TInt aData )

    {

    MPX_FUNC("CMPXCollectionEngine::NotifyL");

    TInt command = KErrNotSupported;

    TInt data = 0;

    TBool clearCache ( EFalse );

    switch( aMsg )

        {

        case EMcMsgFormatStart:

        case EMcMsgDiskRemoved:

        case EMcMsgUSBMassStorageStart:

            {

            command = EMcCloseCollection;

            data = aData;

            // Clear the cache

            clearCache = ETrue;

            break;

            }

        case EMcMsgFormatEnd:

        case EMcMsgDiskInserted:

        case EMcMsgUSBMassStorageEnd:

            {

            command = EMcReOpenCollection;

            data = aData;

            // Clear the cache

        	clearCache = ETrue;

            break;

            }

        case EMcMsgUSBMTPStart:

            {

            iRefreshing = ETrue;

            command = EMcCmdMtpStart;

            break;

            }

        case EMcMsgUSBMTPEnd:

            {

            iRefreshing = EFalse;

            command = EMcCmdMtpEnd;

            // Clear the cache

            clearCache = ETrue;

            break;

            }

        case EMcMsgRefreshStart:

            {

            iRefreshing = ETrue;

            command = EMcRefreshStarted;

            break;

            }

        case EMcMsgRefreshEnd:

            {

            iRefreshing = EFalse;

            command = EMcRefreshEnded;

            // Clear the cache

            clearCache = ETrue;

            break;

            }

        default:

            break;

        }

    if( command != KErrNotSupported )

        {

        TArray<CMPXCollectionPlugin*> plugins = iPluginHandler->LoadedPlugins();

        for( TInt i=0; i<plugins.Count(); ++i )

            {

            CMPXCollectionPlugin* plugin = plugins[i];

            TRAP_IGNORE(plugin->CommandL( (TMPXCollectionCommand)command, data));

            }

        }

    if( clearCache )

    	{

        RFs rfs;

        User::LeaveIfError( rfs.Connect() );        

        DriveInfo::TDriveArray driveArray;

        User::LeaveIfError ( DriveInfo::GetUserVisibleDrives( rfs, driveArray ) );

        TInt count( driveArray.Count () );

        TBool diskFull( EFalse );

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

            {

            TRAP_IGNORE( diskFull = SysUtil::DiskSpaceBelowCriticalLevelL( &rfs, 0,

            		driveArray[i] ) );

            if ( diskFull )

                {

                MPX_DEBUG2("CMPXCollectionEngine::NotifyL: Disk full, driveArray[i] = %d ", driveArray[i] );

                break;

                }

            } 

        if( !diskFull )

        	{

        	iCache->Reset();

        	}

        rfs.Close();

    	}

    TInt count = iContexts.Count();

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

        {

        CMPXCollectionClientContext* context;

        context = iContexts[i];

        context->NotifyL( aMsg, aData );

        }

    }

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

// Retrieves all of the supported types in the collection

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

//

EXPORT_C void CMPXCollectionEngine::GetSupportedTypesL(

                                    RPointerArray<CMPXCollectionType>& aArray )

    {

    RArray<TUid> uids;

    CleanupClosePushL(uids);

    iPluginHandler->GetPluginUids(uids);

    for (TInt i=0; i<uids.Count();++i)

        {

        const TUid& uid = uids[i];

        CDesCArray* mimetypes =

                iPluginHandler->SupportedMimeTypesL(uid);

        CleanupStack::PushL(mimetypes);

        CDesCArray* extensions =

                iPluginHandler->SupportedExtensionsL(uid);

        CleanupStack::PushL(extensions);

        CMPXCollectionType* type = new(ELeave)CMPXCollectionType(

                                                            uid,

                                                            mimetypes,

                                                            extensions);

        CleanupStack::Pop(extensions);

        CleanupStack::Pop(mimetypes);

        CleanupStack::PushL(type);

        aArray.AppendL( type );

        CleanupStack::Pop(type);

        }

    CleanupStack::PopAndDestroy(&uids);

    }

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

// Virtual collection ID to implementation ID lookup

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

//

EXPORT_C TUid CMPXCollectionEngine::LookupCollectionPluginID( const TUid aUid )

    {

    // Lookup virtual ID and map it to an implementation ID

    TUid realId = TUid::Uid(0);

    if( aUid == KLocalCollection )

        {

        realId = TUid::Uid(0x101FFC3A);

        }

    else if( aUid == KPodcastCollection )

        {

        realId = TUid::Uid(0x101FFC3C);

        }

    else if( aUid == KInMemoryCollection )

        {

        realId = TUid::Uid(0x101FFCD8);

        }

    else

        {

        realId=TUid::Null();

        }

    return realId;

    }

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

// Resolve a collection plugin UID

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

//

EXPORT_C TUid CMPXCollectionEngine::ResolvePluginUid(const TArray<TUid>& aAry)

    {

    // Resolve the plugin ID using the plugin handler

    //

    return iPluginHandler->FindPlugin( aAry );

    }

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

// Gets a list of the plugins available by name.

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

//

void CMPXCollectionEngine::ListPluginsL(

    CMPXMedia& aEntries,

    const TArray<TUid>& aSupportedUids)

    {

    MPX_FUNC("CMPXCollectionEngine::ListPluginsL");

#ifdef _DEBUG

    for (TInt ii=0; ii < aSupportedUids.Count(); ++ii)

        {

        MPX_DEBUG2("Supported uid 0x%08x", aSupportedUids[ii]);

        }

#endif

    RArray<TInt> supportedIds;

    CleanupClosePushL(supportedIds);

    supportedIds.AppendL(KMPXMediaIdGeneral);

    CMPXMediaArray* array=CMPXMediaArray::NewL();

    CleanupStack::PushL(array);

    RArray<TUid> pluginList;

    CleanupClosePushL(pluginList);

    iPluginHandler->GetPluginUids(pluginList);

    RArray<TInt> pluginTypes;

    CleanupClosePushL(pluginTypes);

    iPluginHandler->GetPluginTypes(pluginTypes);

    TInt count=pluginList.Count();

    MPX_ASSERT(pluginTypes.Count() >= count);

    TInt arrayCount(0);

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

        {

        // Show only visible plugins

        //

        if(pluginTypes[i] != EMPXCollectionPluginHidden &&

           iPluginHandler->SupportUids(pluginList[i], aSupportedUids))

            {

            CMPXMedia* entry=CMPXMedia::NewL(supportedIds.Array());

            CleanupStack::PushL(entry);

            entry->SetTextValueL(KMPXMediaGeneralTitle,

                                 iPluginHandler->PluginName(pluginList[i]));

            entry->SetTObjectValueL(KMPXMediaGeneralType, EMPXGroup);

            entry->SetTObjectValueL(KMPXMediaGeneralCategory,

                                    EMPXCollection);

            entry->SetTObjectValueL<TMPXItemId>(KMPXMediaGeneralId,

                                                TMPXItemId(pluginList[i].iUid));

            array->AppendL(entry);

            CleanupStack::Pop(entry);

            ++arrayCount;

            }

        }

    aEntries.SetCObjectValueL(KMPXMediaArrayContents,array);

    aEntries.SetTObjectValueL(KMPXMediaArrayCount,arrayCount);

    CleanupStack::PopAndDestroy(&pluginTypes);

    CleanupStack::PopAndDestroy(&pluginList);

    CleanupStack::PopAndDestroy(array);

    CleanupStack::PopAndDestroy(&supportedIds);

    }

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

// Find a plugin from collection path

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

//

CMPXCollectionPlugin* CMPXCollectionEngine::ResolvePluginL(

    const CMPXCollectionPath& aPath)

    {

    return ResolvePluginL(TUid::Uid(aPath.Id(CMPXCollectionPath::ECollectionUid)));

    }

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

// Find a plugin from collection uid

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

//

CMPXCollectionPlugin* CMPXCollectionEngine::ResolvePluginL(

    const TUid& aUid)

    {

    iPluginHandler->SelectPluginL(aUid);

    return iPluginHandler->Plugin();

    }

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

// Find a plugin from uri

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

//

CMPXCollectionPlugin* CMPXCollectionEngine::ResolvePluginL(

    const TDesC& aUri)

    {

    iPluginHandler->ClearSelectionCriteria();

    iPluginHandler->SelectPluginL(aUri, KNullDesC8);

    return iPluginHandler->Plugin();

    }

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

// CMPXCollectionEngine::UsePlugin

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

//

void CMPXCollectionEngine::UsePlugin(

    const TUid& aPluginUid)

    {

    iPluginHandler->UsePlugin(aPluginUid);

    }

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

// CMPXCollectionEngine::ReleasePlugin

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

//

TBool CMPXCollectionEngine::ReleasePlugin(

    const TUid& aPluginUid )

    {

    MPX_FUNC("CMPXCollectionEngine::ReleasePlugin");

    TBool unloaded(iPluginHandler->ReleasePlugin(aPluginUid));

    if (unloaded)

        {

        HandlePluginUnloaded(aPluginUid);

        }

    return unloaded;

    }

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

// CMPXCollectionEngine::CleanupPluginPushL

//

// Pushes the plugin release information onto the cleanup stack. Both the plugin

// handler and the plugin itself have to be pushed and therefore cannot use the

// cleanup stack alone. Even if it would create a dynamic TReleaseInfo instance

// and push that onto the cleanup stack, CleanupStack::Pop would not take care

// of deleting it and therefore a separate stack has to be used for the release

// info.

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

//

void CMPXCollectionEngine::CleanupPluginPushL(

    CMPXCollectionPlugin* aPlugin)

    {

    MPX_FUNC("CMPXCollectionEngine::CleanupPluginPushL");

    // add the release information to the internal stack

    iCleanupStack.AppendL(TReleaseInfo(iPluginHandler, aPlugin));

    // push a pointer to the engine onto the cleanup stack

    CleanupStack::PushL(TCleanupItem(ReleasePlugin, this));

    }

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

// CMPXCollectionEngine::PluginPop

//

// Has to be called instead of CleanupStack::Pop for cleaning up correctly

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

//

void CMPXCollectionEngine::PluginPop()

    {

    MPX_FUNC("CMPXCollectionEngine::PluginPop");

    // remove from the cleanup stack

    CleanupStack::Pop(this);

    // remove from the internal stack

    iCleanupStack.Remove(iCleanupStack.Count() - 1);

    }

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