/*

* 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:  Maintains sessions to paths

*

*/

#include <badesca.h>

#include <mpxcollectionpath.h>

#include <mpxclientlist.h>

#include <mpxcollectionplugin.h>

#include <mpxcollectionpath.h>

#include <mpxcollectionframeworkdefs.h>

#include <mpxcollectioncommanddefs.h>

#include <mpxcommonframeworkdefs.h>

#include <mpxcmn.h>

#include <mpxmedia.h>

#include <mpxmediaarray.h>

#include <mpxmediageneraldefs.h>

#include <mpxmediacontainerdefs.h>

#include <mpxmessagegeneraldefs.h>

#include <mpxmessagecontainerdefs.h>

#include <mpxcollectionmessage.h>

#include <mpxcollectionmessagedefs.h>

#include <mpxcommandgeneraldefs.h>

#include <mpxcollectionopenlresultdef.h>

#include <mpxcommand.h>

#include <mpxlog.h>

#include <mpxsubscription.h>

#include "mpxcollectionengineobserver.h"

#include "mpxcollectionpluginhandler.h"

#include "mpxcollectionengine.h"

#include "mpxcollectioncache.h"

#include "mpxcollectionclientcontext.h"

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

// Helper. Sets next open mode on path

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

//

LOCAL_C void SetPathOpenMode(CMPXCollectionPath& aPath, TInt aMode)

    {

    TMPXOpenMode mode=static_cast<TMPXOpenMode>(aMode);

    if (aPath.Levels())

        {

        aPath.Set(mode == EMPXOpenDefault ? aPath.OpenPreviousMode() : mode);

        }

    }

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

// Helper. Returns whether next open mode is the same as previous open

// request

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

//

LOCAL_C TBool OpenModeValid(const CMPXCollectionPath& aPath)

    {

    TMPXOpenMode next=aPath.OpenNextMode();

    return (aPath.OpenPreviousMode() == next) || (next == EMPXOpenDefault);

    }

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

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

// Two-phased constructor.

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

//

CMPXCollectionClientContext* CMPXCollectionClientContext::NewL(

    CMPXCollectionEngine& aEngine,

    CMPXCollectionCache& aCache,

    const TUid& aModeId)

    {

    CMPXCollectionClientContext* p =

                    new(ELeave) CMPXCollectionClientContext(aEngine, aCache, aModeId);

    CleanupStack::PushL(p);

    p->ConstructL();

    CleanupStack::Pop(p);

    return p;

    }

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

// C++ constructor.

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

//

CMPXCollectionClientContext::CMPXCollectionClientContext(

    CMPXCollectionEngine& aEngine,

    CMPXCollectionCache& aCache,

    const TUid& aModeId)

  : iModeId(aModeId),iFocusItemId(KMPXInvalidItemId),

    iEngine(aEngine),iCache(aCache)

    {

    }

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

// 2nd phase constructor.

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

//

void CMPXCollectionClientContext::ConstructL()

    {

    iClientList = CMPXClientList::NewL();

    iBrowsePath = CMPXCollectionPath::NewL();

    iMedia = CMPXMedia::NewL(); // empty media

    // initialize to null uid

    for (TInt index = 0; index < EContextCount; ++index)

        {

        iPluginUids.AppendL(KNullUid);

        }

    }

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

// Destructor

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

//

CMPXCollectionClientContext::~CMPXCollectionClientContext()

    {

    MPX_DEBUG2("CMPXCollectionClientContext::~CMPXCollectionClientContext %08x",

               this);

    // Release all plugins this context has references on, this could result in the

    // plugin(s) being unloaded.

    for (TInt index = 0; index < EContextCount; ++index)

        {

        if (iPluginUids[index] != KNullUid)

            {

            iEngine.ReleasePlugin(iPluginUids[index]);

            }

        }

    delete iClientList;

    delete iBrowsePath;

    delete iMediaPath;

    delete iMedia;

    delete iFilter;

    iPluginUids.Close();

    iUids.Close();

    }

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

// Open collection by path

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

//

EXPORT_C void CMPXCollectionClientContext::OpenL(

    CMPXCollectionPath* aPath,

    TInt aMode,

    MMPXCollectionEngineObserver* aCallback)

    {

    MPX_DEBUG1("CMPXCollectionClientContext::OpenL 1 <--");

    MPX_ASSERT(aPath);

    if (aPath->Levels() > 0)

        {

        // Increment the plugin reference count

        CMPXCollectionPlugin*plugin = iEngine.ResolvePluginL(*aPath);

        if (!plugin)

            {

            MPX_DEBUG1("CMPXCollectionClientContext::OpenL 1 bad path plugin");

            User::Leave(KErrArgument);

            }

        iEngine.CleanupPluginPushL(plugin);

        // Ownership of aPath transferred

        MPX_DEBUG1("CMPXCollectionClientContext::OpenL 1 Add task");

        plugin->AddTaskL(EMcsOpenPath, aCallback, this,

                        aMode, NULL, plugin, aPath);

        // Pop the plugin

        iEngine.PluginPop();

        }

    else

        { // Go back to root level

        MPX_DEBUG1("CMPXCollectionClientContext::OpenL restarting path");

        iIndex=0;

        iFocusItemId = KMPXInvalidItemId;

        InitL(aCallback);

        }

    MPX_DEBUG1("CMPXCollectionClientContext::OpenL 1 -->");

    }

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

// Open collection by index

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

//

EXPORT_C void CMPXCollectionClientContext::OpenL(

    TInt aIndex,

    TInt aMode,

    const TArray<TMPXAttribute>& aAttrs,

    MMPXCollectionEngineObserver* aCallback)

    {

    MPX_DEBUG1("CMPXCollectionClientContext::OpenL 2 <--");

    if (iBrowsePath->Levels()<=0)

        {

        User::Leave(KErrNotReady);

        }

    if (aIndex<0 || aIndex>=iBrowsePath->Count())

        {

        User::Leave(KErrArgument);

        }

    iBrowsePath->Set(aIndex);

    // plugin not resolved yet

    if (iPluginUids[EContextBrowse] == KNullUid)

        {

        // Increment the new plugin reference count, decrement the old.

        // No need to push/release the plugin it is stored in a member

        // variable and will be released when that is overwritten.

        ResolvePluginL(*iBrowsePath, iPluginUids[EContextBrowse]);

        }

    if (iPluginUids[EContextBrowse] == KNullUid)

        {

        MPX_DEBUG1("CMPXCollectionClientContext::OpenL 2 bad plugin");

        User::Leave(KErrNotReady);

        }

    // add request to the queue

    MPX_DEBUG1("CMPXCollectionClientContext::OpenL 2 Add task");

    iBrowsePath->SetL(aAttrs);

    LoadedPlugin(EContextBrowse)->AddTaskL(EMcsOpenIndex, aCallback, this,

                                           aIndex, NULL, (TAny*)aMode);

    MPX_DEBUG1("CMPXCollectionClientContext::OpenL 2 -->");

    }

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

// Open collection by uids

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

//

EXPORT_C void CMPXCollectionClientContext::OpenL(

    const TArray<TUid>& aUids,

    TInt aMode,

    MMPXCollectionEngineObserver* aCallback)

    {

    // Update path for open request

    MPX_DEBUG1("CMPXCollectionClientContext::OpenL 3 <---");

    SetPathOpenMode(*iBrowsePath,aMode);

    if (!MPXUser::CompareOrderedUidArrays(iUids.Array(), aUids))

        { // the same context

        MPX_DEBUG1("CMPXCollectionClientContext::OpenL 3 return Open");

        aCallback->HandleOpen(iMedia, iIndex, ETrue, iMediaType);

        }

    else

        { // go back to root level

        MPX_DEBUG1("CMPXCollectionClientContext::OpenL 3 Going to Root");

        iUids.Reset();

        ::CopyArrayL(aUids, iUids);

        iIndex=0;

        iFocusItemId = KMPXInvalidItemId;

        InitL(aCallback);

        }

    MPX_DEBUG1("CMPXCollectionClientContext::OpenL 3 --->");

    }

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

// Request current content of browse context

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

//

EXPORT_C void CMPXCollectionClientContext::OpenL(

    TInt aMode,

    MMPXCollectionEngineObserver* aCallback)

    {

    // Update path for open request

    MPX_DEBUG1("CMPXCollectionClientContext::OpenL 4 <---");

    SetPathOpenMode(*iBrowsePath,aMode);

    if (iPluginUids[EContextBrowse] == KNullUid)

        {// No plug-in has been resolved

        if (iBrowsePath->Levels() == 0)

            //

            // Open called at root level: just need to list the plug-ins,

            // no need to resolve any plugin. Open request doesn't apply

            // at this level

            {

            MPX_DEBUG1("CMPXCollectionClientContext::OpenL 4 InitL()");

            iIndex=0;

            iFocusItemId = KMPXInvalidItemId;

            InitL(aCallback);

            }

        else if (OpenModeValid(*iBrowsePath) && !iPathUpdated)

            //

            // The existing media is still valid (no change

            // in the request for entries

            //

            {

            MPX_DEBUG1("CMPXCollectionClientContext::OpenL 4 return media");

            aCallback->HandleOpen(iMedia,

                                  iIndex, ETrue,

                                  iMediaType);

            }

           else // Open mode has changed and open NOT called at root level

               {

               MPX_DEBUG1("CMPXCollectionClientContext::OpenL 4 add task different open mode");

               ResolvePluginL(*iBrowsePath, iPluginUids[EContextBrowse]); // Find a plug-in

               if (iPluginUids[EContextBrowse] != KNullUid)

                {

                LoadedPlugin(EContextBrowse)->AddTaskL(EMcsOpen, aCallback, this);

                }

               }

        }

    else

        {

        MPX_DEBUG1("CMPXCollectionClientContext::OpenL 4 add task");

        LoadedPlugin(EContextBrowse)->AddTaskL(EMcsOpen, aCallback,this);

        }

    MPX_DEBUG1("CMPXCollectionClientContext::OpenL 4 --->");

    }

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

// Media request by collection path

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

//

EXPORT_C void CMPXCollectionClientContext::BackL(

    MMPXCollectionEngineObserver* aCallback)

    {

    MPX_DEBUG1("CMPXCollectionClientContext::BackL()");

    if (iPluginUids[EContextBrowse]==KNullUid)

        {

        User::Leave(KErrNotReady);

        }

    MPX_DEBUG1("CMPXCollectionClientContext::BackL() -- Add task");

    LoadedPlugin(EContextBrowse)->AddTaskL(EMcsBack, aCallback, this);

    }

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

// MediaL command

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

//

EXPORT_C void CMPXCollectionClientContext::MediaL(

    const CMPXCommand& aCmd,

    MMPXCollectionEngineObserver* aCallback)

    {

    CMPXCollectionPath* path =

        aCmd.ValueCObjectL<CMPXCollectionPath>(KMPXCommandGeneralTargetIds);

    CleanupStack::PushL(path);

    // Increment the plugin reference count

    CMPXCollectionPlugin*plugin = iEngine.ResolvePluginL(*path);

    if (!plugin)

        {

        User::Leave(KErrArgument);

        }

    iEngine.CleanupPluginPushL(plugin);

    CMPXCommand* cmd = CMPXCommand::NewL(aCmd); // make a copy

    CleanupStack::PushL(cmd);

    plugin->AddTaskL(EMcsMediaByPath, aCallback, this,

                     0, NULL, plugin, cmd, path);

    CleanupStack::Pop(cmd); // Ownership transferred to the task queue

    iEngine.PluginPop();    // Pop the plugin

    CleanupStack::Pop(path);// Ownership transferred to the task queue

    }

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

// Add a media

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

//

EXPORT_C void CMPXCollectionClientContext::AddL(const CMPXMedia& aMedia)

    {

    DoUpdateMediaL( EMcsAddItem, aMedia );

    }

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

// Remove a media

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

//

EXPORT_C void CMPXCollectionClientContext::RemoveL(const CMPXMedia& aMedia)

    {

    DoUpdateMediaL( EMcsRemoveItem, aMedia );

    }

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

// Update a media

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

//

EXPORT_C void CMPXCollectionClientContext::SetL(const CMPXMedia& aMedia)

    {

    DoUpdateMediaL( EMcsSetMedia, aMedia );

    }

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

// Remove media by path

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

//

EXPORT_C void CMPXCollectionClientContext::RemoveL(

    CMPXCollectionPath* aPath,

    MMPXCollectionEngineObserver* aCallback)

    {

    TInt id(aPath->Id(CMPXCollectionPath::ECollectionUid));

    // Increment the plugin reference count

    CMPXCollectionPlugin* plugin = iEngine.ResolvePluginL(TUid::Uid(id));

    if (!plugin)

        {

        User::Leave(KErrArgument);

        }

    iEngine.CleanupPluginPushL(plugin);

    // Ownership of aPath transferred

    plugin->AddTaskL(EMcsRemovePath, aCallback, this, 0, NULL, plugin, aPath);

    iEngine.PluginPop();

    }

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

// Return current plugin id

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

//

EXPORT_C TUid CMPXCollectionClientContext::PluginId() const

    {

    return iPluginUids[EContextBrowse];

    }

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

// Handle async request from client

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

//

EXPORT_C const CMPXCollectionPath& CMPXCollectionClientContext::Path() const

    {

    return *iBrowsePath;

    }

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

// Cancel request

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

//

EXPORT_C void CMPXCollectionClientContext::CancelRequest(

    MMPXCollectionEngineObserver* aCallback)

    {

    MPX_DEBUG3("CMPXCollectionClientContext::CancelRequest, this %08x, aCallback %08x",

               this, aCallback);

    iEngine.RemoveTask(aCallback);

    }

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

// Add a client

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

//

EXPORT_C void CMPXCollectionClientContext::AddClientL(

    TThreadId aId,

    CMPXMessageQueue* aMsgQueue)

    {

    iClientList->AddClientL(aId, aMsgQueue);

    }

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

// Remove a client

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

//

EXPORT_C void CMPXCollectionClientContext::RemoveClient(

    const CMPXMessageQueue& aMsgQueue)

    {

    MPX_DEBUG2("CMPXCollectionClientContext::RemoveClient with the message queue 0x%08x",

               &aMsgQueue);

    TInt index(iClientList->Find(aMsgQueue));

    if (KErrNotFound != index)

        {

        iClientList->RemoveClient(index);

        }

    if (!iClientList->ClientCount())

        {

        iEngine.RemoveContext(*this);

        }

    }

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

// Gets the supported capabilities of the current browse plugin

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

//

EXPORT_C TCollectionCapability CMPXCollectionClientContext::GetCapabilities()

    {

    TCollectionCapability cap(0);

    if (iPluginUids[EContextBrowse]!=KNullUid)

        {

        LoadedPlugin(EContextBrowse)->GetCapabilities();

        }

    return cap;

    }

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

// Find all aSync

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

//

EXPORT_C void CMPXCollectionClientContext::FindAllL(

    const CMPXMedia& aMedia,

    CBufBase* aBuf,

    MMPXCollectionEngineObserver* aCallback)

    {

    CMPXCollectionPlugin* plugin(NULL); // Not owned

    // Increment the plugin reference count

    ResolvePluginL(aMedia, plugin);

    if (!plugin)

        {

        User::Leave(KErrNotFound);  // found nothing

        }

    iEngine.CleanupPluginPushL(plugin);

    // Add the task

    CMPXMedia* media = CMPXMedia::NewL(aMedia);

    CleanupStack::PushL(media);

    plugin->AddTaskL(EMcsFindAll, aCallback, this, 0, aBuf, plugin, media);

    CleanupStack::Pop(media); // Ownership transferred

    iEngine.PluginPop();

    }

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

// Find all sync

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

//

EXPORT_C CMPXMedia* CMPXCollectionClientContext::FindAllSyncL(

    const CMPXMedia& aMedia,

    const CBufBase& aBuf)

    {

    CMPXCollectionPlugin* plugin(NULL); // Not owned

    // Increment the plugin reference count

    ResolvePluginL(aMedia, plugin);