/*

* 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:  Collection Utility implementation

*

*/

#include <bamdesca.h>

#include <s32mem.h>

#include <e32math.h>

#include <mpxmessagemonitor.h>

#include <mpxmedia.h>

#include <mpxcollectionobserver.h>

#include <mpxcollectionmessage.h>

#include <mpxmessagegeneraldefs.h>

#include <mpxcmn.h>

#include <mpxtaskqueue.h>

#include <mpxcollectionpath.h>

#include <mpxcollectionplaylist.h>

#include <mpxcollectiontype.h>

#include <mpxcommandgeneraldefs.h>

#include <mpxcollectioncommanddefs.h>

#include <mpxsubscription.h>

#include <mpxlog.h>

#include "mpxcollectionutilityimpl.h"

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

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

// Two phase constructor

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

// 

CMPXCollectionUtility* CMPXCollectionUtility::NewL(

    const TUid& aModeId,

    MMPXCollectionObserver* aObs)

    {

    CMPXCollectionUtility* p=new(ELeave)CMPXCollectionUtility(aObs);

    CleanupStack::PushL(p);

    p->ConstructL(aModeId);

    CleanupStack::Pop(p);

    return p;

    }

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

// Destructor

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

// 

CMPXCollectionUtility::~CMPXCollectionUtility()

    { 

    Cancel();

#ifdef _ENABLE_GUARD_TIMER

    delete iGuardTimer;

#endif

    if (iTaskQueue)

        {

        delete iTaskQueue;

        }

    delete iCurrentEntries;

    if (iMsgMonitor)

        {

        delete iMsgMonitor;

        }

    iMcs.Close();

    delete iBuffer;

    delete iArray;

    delete iMedia;

    delete iMediaOnError;

    }

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

// C++ constructor

// Create a unique name out of thread ID and this pointer: no other instance of

// this object will have the same name; used to identify this object for

// receiving messages 

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

// 

CMPXCollectionUtility::CMPXCollectionUtility(MMPXCollectionObserver* aObs)

:   CActive(EPriorityStandard),

    iObserver(aObs),

    iCallbackOngoing(EFalse)

    { 

    CActiveScheduler::Add(this); 

    TThreadId threadId=RThread().Id(); // this thread id

    } 

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

// 2nd phase constructor

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

// 

void CMPXCollectionUtility::ConstructL(const TUid& aModeId)

    {

    MPX_FUNC_EX("CMPXCollectionUtility::ConstructL");

    iTaskQueue = CMPXTaskQueue::NewL();

    User::LeaveIfError(

        iMcs.Connect(KMPXCollectionServerName,

                     KMPXCollectionServerImg,

                     TVersion(KMPXCollectionServerMajorVersionNumber,

                     KMPXCollectionServerMinorVersionNumber,

                     KMPXCollectionServerBuildVersionNumber)));

    iMcs.SendReceiveL(EMcsSetMode,TIpcArgs(aModeId.iUid)); 

    iMsgMonitor = CMPXMessageMonitor::NewL(iMcs,*this);

    iMediaOnError = CMPXMedia::NewL();

#ifdef _ENABLE_GUARD_TIMER

    iGuardTimer=CPeriodic::NewL(CActive::EPriorityStandard);

#endif

    }

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

// Return reference to collection

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

// 

MMPXCollection& CMPXCollectionUtility::Collection()

    {

    return *this;

    }

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

// Retrieves the ID of the collection resolved based on selection criteria

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

// 

TUid CMPXCollectionUtility::CollectionIDL(const TArray<TUid>& aUids)

    {

    // Buffer to transfer UIDs

    //

    CBufBase* buf=CBufFlat::NewL(KMPXBufGranularity);

    CleanupStack::PushL( buf );

    RBufWriteStream writeStream( *buf );

    CleanupClosePushL( writeStream );

    ::ExternalizeL(aUids, writeStream);

    writeStream.CommitL();

    buf->Compress();

    CleanupStack::PopAndDestroy(&writeStream);

    // IPC the data

    //

    TPtr8 des = buf->Ptr(0);

    TPckgBuf<TUid> pkg;

    iMcs.SendReceiveL( EMcsCollectionIdLookup, TIpcArgs(&des, &pkg) );

    CleanupStack::PopAndDestroy( buf );

    return pkg();

    }

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

// CMPXCollectionUtility::AddSubscriptionL

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

// 

void CMPXCollectionUtility::AddSubscriptionL(

    const CMPXSubscription& aSubscription)

    {

    const CMPXMediaArray* items = aSubscription.ItemsL();

    CMPXCommand* cmd = CMPXCommand::NewL();

    CleanupStack::PushL(cmd);

    cmd->SetTObjectValueL(KMPXCommandGeneralId, KMPXCommandSubscriptionAdd);

    cmd->SetCObjectValueL(KMPXCommandSubscriptionAddItems, items);

    cmd->SetTObjectValueL(KMPXCommandGeneralDoSync, ETrue);

    CommandL(*cmd);

    CleanupStack::PopAndDestroy(cmd); 

    }

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

// CMPXCollectionUtility::RemoveSubscriptionL

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

// 

void CMPXCollectionUtility::RemoveSubscriptionL(

    const CMPXSubscription& aSubscription)

    {

    const CMPXMediaArray* items = aSubscription.ItemsL();

    CMPXCommand* cmd = CMPXCommand::NewL();

    CleanupStack::PushL(cmd);

    cmd->SetTObjectValueL(KMPXCommandGeneralId, KMPXCommandSubscriptionRemove);

    cmd->SetCObjectValueL(KMPXCommandSubscriptionAddItems, items);

    cmd->SetTObjectValueL(KMPXCommandGeneralDoSync, ETrue);

    CommandL(*cmd);

    CleanupStack::PopAndDestroy(cmd); 

    }

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

// CMPXCollectionUtility::ClearSubscriptionsL

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

// 

void CMPXCollectionUtility::ClearSubscriptionsL()

    {

    CMPXCommand* cmd = CMPXCommand::NewL();

    CleanupStack::PushL(cmd);

    cmd->SetTObjectValueL(KMPXCommandGeneralId, KMPXCommandSubscriptionRemoveAll);

    cmd->SetTObjectValueL(KMPXCommandGeneralDoSync, ETrue);

    CommandL(*cmd);

    CleanupStack::PopAndDestroy(cmd);

    } 

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

// Destroy this object

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

// 

void CMPXCollectionUtility::Close()

    {

    MPX_DEBUG2("CMPXCollectionUtility::Close %08x", this);

    iMsgMonitor->Cancel();

    delete this;

    } 

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

//  Open's collection with the mode. Data returned in callback

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

//

void CMPXCollectionUtility::OpenL(TMPXOpenMode aMode)

    {

    MPX_DEBUG2("CMPXCollectionUtility::OpenL with mode %d", aMode);

    AddRequestL(EMcsOpen, NULL, aMode);

    }

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

// Open a collection

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

// 

void CMPXCollectionUtility::OpenL(TInt aIndex,TMPXOpenMode aMode)

    {

    RArray<TMPXAttribute> dummy;

    CleanupClosePushL(dummy);

    OpenL(aIndex, dummy.Array(), aMode);

    CleanupStack::PopAndDestroy(&dummy); 

    }

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

// Open a collection by path

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

// 

void CMPXCollectionUtility::OpenL(

    const CMPXCollectionPath& aPath,

    TMPXOpenMode aMode)

    {

    RArray<TMPXAttribute> dummy;

    CleanupClosePushL(dummy);

    OpenL(aPath, dummy.Array(), aMode);

    CleanupStack::PopAndDestroy(&dummy); 

    }

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

//  Opens the collection at a specific index 

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

//

void CMPXCollectionUtility::OpenL(

    TInt aIndex,

    const TArray<TMPXAttribute>& aAttrs,

    TMPXOpenMode aMode)

    {

    // Externalize parameters

    //

    CBufBase* buf=CBufFlat::NewL(KMPXBufGranularity);

    CleanupStack::PushL( buf );

    RBufWriteStream writeStream( *buf );

    CleanupClosePushL( writeStream );

    // Mode

    writeStream.WriteInt32L(aMode); 

    // externalize attributes array

    ::ExternalizeL(aAttrs, writeStream);

    // Close and compress buffer

    writeStream.CommitL();

    buf->Compress();

    CleanupStack::PopAndDestroy(&writeStream);

    // Async version, Add request to the task queue 

    AddRequestL(EMcsOpenIndex, NULL, aIndex, buf);

    CleanupStack::Pop( buf );  // ownership transferred to the queue

    }

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

//  Opens the collection at a specific level 

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

// 

void CMPXCollectionUtility::OpenL(

    const CMPXCollectionPath& aPath,

    const TArray<TMPXAttribute>& aAttrs,

    TMPXOpenMode aMode)

    {

    MPX_FUNC("CMPXCollectionUtility::OpenL(const CMPXCollectionPath& aPath)");

    MPX_DEBUG_PATH(aPath);

    CBufBase* buffer=CBufFlat::NewL(KMPXBufGranularity);

    CleanupStack::PushL( buffer );

    RBufWriteStream writeStream( *buffer );

    CleanupClosePushL( writeStream );

    //collection path 

    writeStream << aPath; 

    // externalize open mode

    writeStream.WriteInt32L(aMode);

    // externalize attributes array

    ::ExternalizeL(aAttrs, writeStream);

    writeStream.CommitL();

    buffer->Compress();

    CleanupStack::PopAndDestroy(&writeStream);

    AddRequestL(EMcsOpenPath, NULL, 0, buffer);

    CleanupStack::Pop(buffer); //buffer ownership transferred

    }

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

//  Opens the collection in its current state, or if aUids do not

//  apply to currently opened collection, then the state will

//  revert back to root level

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

// 

void CMPXCollectionUtility::OpenL(

    const TArray<TUid>& aUids,

    TMPXOpenMode aMode)

    {

    MPX_FUNC_EX("CMPXCollectionUtility::OpenL(aUids, aMode)");

    CBufBase* buf=CBufFlat::NewL(KMPXBufGranularity);

    CleanupStack::PushL( buf );

    // Externalize parameters

    //

    RArray<TUid> uids;

    CleanupClosePushL(uids);

    TInt count(aUids.Count());

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

        { // sort uids

        uids.InsertInOrderL(aUids[i], MPXUser::CompareUids);

        }

    RBufWriteStream writeStream( *buf );

    CleanupClosePushL( writeStream );

    // Mode

    writeStream.WriteInt32L(aMode); 

    // Uids

    ::ExternalizeL(uids.Array(), writeStream);

    // Close and compress buffer

    writeStream.CommitL();

    buf->Compress();

    CleanupStack::PopAndDestroy(&writeStream);

    CleanupStack::PopAndDestroy(&uids);

    // Async version, Add request to the task queue 

    AddRequestL(EMcsOpenByUids, NULL, 0, buf);

    CleanupStack::Pop( buf );  // ownership transferred to the queue

    }

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

//  Opens the collection in its current state, or if aUid does not

//  apply to currently opened collection, then the state will

//  revert back to root level

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

// 

void CMPXCollectionUtility::OpenL(

    const TUid& aUid,

    TMPXOpenMode aMode)

    {

    RArray<TUid> uids;

    CleanupClosePushL(uids);

    uids.AppendL(aUid);

    OpenL(uids.Array(),aMode);

    CleanupStack::PopAndDestroy(&uids);

    }

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

//  Apply a filter to collection browsing; all subsequent calls

//  to OpenL() will have this filter applied

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

// 

void CMPXCollectionUtility::SetFilterL(CMPXFilter* aFilter)

    {

    if (aFilter)

        { // Send filter to server

        CBufBase* buf=NULL;

        ::CreateBufferL<CMPXFilter>(*aFilter,buf);

        CleanupStack::PushL(buf);

        TPtr8 ptr=buf->Ptr(0);

        iMcs.SendReceiveL(EMcsSetFilter,TIpcArgs(&ptr));

        CleanupStack::PopAndDestroy(buf);

        }

    else

        { // Else send zero length descriptor

        iMcs.SendReceiveL(EMcsSetFilter,TIpcArgs(&KNullDesC8));

        }

    }

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

//  Current filter that is applied to collection browsing

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

// 

CMPXFilter* CMPXCollectionUtility::FilterL()

    {

    TInt size=iMcs.SendReceiveL(EMcsFilter);

    // 

    // Transfer results from server

    //

    CMPXMedia* filter=NULL;

    if (size)

        {

        ::TransferBufferFromServerL(iMcs,EMcsGetSyncBuffer,size,iBuffer);

        ::NewFromBufferL<CMPXFilter>(*iBuffer,filter); 

        }

    return filter;

    }

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

// The UID identifying this collection

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

// 

TUid CMPXCollectionUtility::UidL() const

    {

    TPckgBuf<TInt> uidPkg; 

    iMcs.SendReceiveL(EMcsGetUid, TIpcArgs(&uidPkg));

    return TUid::Uid(uidPkg());

    }

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

// Return current collection path

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

// 

CMPXCollectionPath* CMPXCollectionUtility::PathL()

    {

    CMPXCollectionPath* path = NULL;

    TInt size = iMcs.SendReceiveL(EMcsGetPath);

    if (size >0)

        {

        ::TransferBufferFromServerL(iMcs, EMcsGetSyncBuffer, size, iBuffer);

        ::NewFromBufferL<CMPXCollectionPath>(*iBuffer, path);

        }

    return path;

    }

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

// Back to upper level

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

// 

void CMPXCollectionUtility::BackL()

    {

    AddRequestL(EMcsBack, NULL);

    }

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

// Is remote collection path

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

// 

TBool CMPXCollectionUtility::IsRemote(const CMPXCollectionPath& aPath)

    {

    (void)aPath; 

    return EFalse; 

    }

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

// Remove outstanding requests

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

// 

void CMPXCollectionUtility::CancelRequest()

    {

    Cancel();

    iTaskQueue->Reset();

    }

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

// Add item(s)

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

//

void CMPXCollectionUtility::AddL(const CMPXMedia& aNewProperties)

    {

    delete iMedia;

    iMedia=NULL;

    iMedia=CMPXMedia::NewL(aNewProperties);

    CBufBase* buf(NULL);

    ::CreateBufferL<CMPXMedia>( aNewProperties, buf );

    CleanupStack::PushL( buf );

    TPtr8 ptr = buf->Ptr(0);

    iMcs.SendReceiveL( EMcsAddItem, TIpcArgs(&ptr));

    CleanupStack::PopAndDestroy( buf );

    }

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

// Remove a single item

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

// 

void CMPXCollectionUtility::RemoveL( 

    const CMPXCollectionPath& aPath,

    MMPXCollectionRemoveObserver* aObs )

    {

    // Serialize the path and send it to the collection

    //

    if (aPath.Levels()<=0)

        {

        User::Leave(KErrArgument);

        }

    CBufBase* buf(NULL);

    ::CreateBufferL<CMPXCollectionPath>( aPath, buf );

    CleanupStack::PushL(buf);

    AddRequestL(EMcsRemovePath, aObs, 0, buf);  // buf ownership transferred

    CleanupStack::Pop(buf);

    }

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

// Remove a list of items

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

// 

void CMPXCollectionUtility::RemoveL(const CMPXMedia& aProperties)

    {

    delete iMedia;

    iMedia=NULL;

    iMedia=CMPXMedia::NewL(aProperties);

    CBufBase* buf(NULL);

    ::CreateBufferL<CMPXMedia>( aProperties, buf );

    CleanupStack::PushL( buf );

    TPtr8 ptr = buf->Ptr(0);

    iMcs.SendReceiveL( EMcsRemoveItem, TIpcArgs(&ptr));

    CleanupStack::PopAndDestroy( buf );

    }

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

// Set properties

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