//*

* Copyright (c) 2002 - 2007 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:  Implementation of collection test plugin interface

*

*/

// INCLUDE FILES

#include <e32cmn.h>

#include <mpxcmn.h>

#include <mpxcollectionpluginobserver.h>

#include <mpxmedia.h>

#include <mpxmediaarray.h>

#include <mpxcommonframeworkdefs.h>

#include <mpxmediamusicdefs.h>

#include <mpxmediadrmdefs.h>

#include <mpxmediacontainerdefs.h>

#include <mpxmessagecontainerdefs.h>

#include <mpxcommandgeneraldefs.h>

#include <mpxcollectioncommanddefs.h>

#include <stringloader.h>

#include <flogger.h>

#include "testcommonpluginuids.h"

#include "testcollectionplugin.h"

// CONSTANTS

_LIT(KFolder, "mpxt");

_LIT(KFile,   "CFwCollection.txt");

#define LOG1(a)             RFileLogger::Write(KFolder, KFile, EFileLoggingModeAppend, a)

#define LOG2(a,b)           RFileLogger::WriteFormat(KFolder, KFile, EFileLoggingModeAppend, a, b)

#define LOG3(a,b,c)         RFileLogger::WriteFormat(KFolder, KFile, EFileLoggingModeAppend, a, b, c)

#define LOG4(a,b,c,d)       RFileLogger::WriteFormat(KFolder, KFile, EFileLoggingModeAppend, a, b, c,d)

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

// print out (index, id) for each level and the first 15 ids at top level

LOCAL_C void LogPath( const CMPXCollectionPath& aPath )\

    {

    TInt levels = aPath.Levels();

    TInt count = aPath.Count();

    LOG3(_L("Collection Path debug: levels=  %d, count = %d"), levels, count);

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

        {

        LOG4(_L("Collection Path debug: Level[%d] = (index %d, id 0x%08x)"), i, 

                                                                             aPath.Index(i), 

                                                                             aPath.Id(i) );

        }

    if (count > 0)

        {

        TInt index = aPath.Index();

        CMPXCollectionPath* dpath = const_cast<CMPXCollectionPath*>(&aPath);

        dpath->SetToFirst();

        TInt c = 0;

        do

            {

            LOG3(_L("Collection Path debug top level: item %d = id 0x%08x"), c, dpath->Id());

            } while (++(*dpath) && ++c < 15 );

        dpath->Set(index);

        }

    }

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

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

// Two-phased constructor. 

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

//

CTestCollectionPlugin* CTestCollectionPlugin::NewL (TAny* /*aInitParams*/)

    {

    CTestCollectionPlugin* self = new (ELeave) CTestCollectionPlugin();

    CleanupStack::PushL (self);

    self->ConstructL ();

    CleanupStack::Pop (self);

    return self;        

    }

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

// Destructor. 

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

//

CTestCollectionPlugin::~CTestCollectionPlugin ()

    {

    }

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

// Constructor. 

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

//

CTestCollectionPlugin::CTestCollectionPlugin ()

    {

    }

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

// Symbian 2nd phase constructor can leave.

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

//

void CTestCollectionPlugin::ConstructL ()

    {

    }

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

// Navigates to the given path

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

//

void CTestCollectionPlugin::OpenL(const CMPXCollectionPath& aPath,

                                      const TArray<TMPXAttribute>& aAttrs,

                                      CMPXFilter* aFilter)

    {

    LOG1(_L("CTestCollectionPlugin::OpenL"));

    LogPath( aPath );

    TMPXOpenMode openMode = aPath.OpenNextMode();

    TInt idIndex = aPath.Levels() - 1;

    LOG2(_L("TMPXOpendMode=%d"), openMode);

    LOG2(_L("aFilter=%x"), aFilter);

    RArray<TInt> supportedIds;

    CleanupClosePushL(supportedIds);

    supportedIds.AppendL(KMPXMediaIdContainer);

    supportedIds.AppendL(KMPXMediaIdGeneral);

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

    CleanupStack::PopAndDestroy(&supportedIds);  

    CleanupStack::PushL(entries);

    entries->SetTObjectValueL<TMPXItemId>(TMPXAttribute(KMPXMediaIdGeneral,EMPXMediaGeneralId), aPath.Id(idIndex));

    if(aPath.Levels() == 1)

        {

        // Plugin's root level

        RArray<TInt> ids;

        CleanupClosePushL( ids );

        ids.Append( 11 );

        ids.Append( 12 );

        ids.Append( 13 );

        ids.Append( 990 );  // for Playback Framework Test

        RArray<TMPXAttribute> attrs;

        CleanupClosePushL( attrs );

        attrs.Append( KMPXMediaGeneralId );

        attrs.Append( KMPXMediaGeneralUri );

        attrs.Append( KMPXMediaGeneralTitle );

        CMPXMediaArray* array=CMPXMediaArray::NewL();

        CleanupStack::PushL( array );

        const TArray<TMPXAttribute>& tempRef = aAttrs.Count() == 0? attrs.Array() : aAttrs;

        AddMediaL(*array, ids, tempRef);

        FilterMediaArray(*array, aFilter);

        entries->SetCObjectValueL (TMPXAttribute(KMPXMediaIdContainer,EMPXMediaArrayContents),array);

        entries->SetTObjectValueL (TMPXAttribute(KMPXMediaIdContainer,EMPXMediaArrayCount),array->Count());

        iObs->HandleOpen (entries, KErrNone);  

        CleanupStack::PopAndDestroy(3, &ids);   // attrs, array, ids

        }

    else if(aPath.Levels() == 2)

        {

        // Opening plugin's root menu

        TInt topLevId = aPath.Id(1);

        RArray<TInt> ids;

        CleanupClosePushL( ids );

        RArray<TMPXAttribute> attrs;

        CleanupClosePushL( attrs );

        CMPXMediaArray* array=CMPXMediaArray::NewL();

        CleanupStack::PushL( array );

        attrs.Append( KMPXMediaGeneralId );

        attrs.Append( KMPXMediaGeneralUri );

        attrs.Append( KMPXMediaGeneralTitle );                    

        if(topLevId == 11)

            {

            ids.Append( 211 );

            ids.Append( 212 );

            ids.Append( 213 );

            }

        else if(topLevId == 12)

            {

            ids.Append( 221 );

            }

        else if(topLevId == 13)

            {

            ids.Append( 231 );

            ids.Append( 232 );

            }

        else if(topLevId == 990)

            {

            ids.Append( 9901 );

            ids.Append( 9902 );

            ids.Append( 9903 );

            ids.Append( 9904 );

            ids.Append( 9905 );

            ids.Append( 9906 );

            ids.Append( 9907 );

            }

        const TArray<TMPXAttribute>& tempRef = aAttrs.Count() == 0? attrs.Array() : aAttrs;

        AddMediaL(*array, ids, tempRef);

        FilterMediaArray(*array, aFilter);

        entries->SetCObjectValueL (TMPXAttribute(KMPXMediaIdContainer,EMPXMediaArrayContents),array);

        entries->SetTObjectValueL (TMPXAttribute(KMPXMediaIdContainer,EMPXMediaArrayCount),array->Count());

        iObs->HandleOpen (entries, KErrNone);  

        CleanupStack::PopAndDestroy(3, &ids);   // attrs, array, ids

        }

    else if(aPath.Levels() == 3)

        {

        // Opening plugin's 2nd 

        TInt secLevId = aPath.Id(2);

        RArray<TInt> ids;

        CleanupClosePushL( ids );

        RArray<TMPXAttribute> attrs;

        CleanupClosePushL( attrs );

        CMPXMediaArray* array=CMPXMediaArray::NewL();

        CleanupStack::PushL( array );

        attrs.Append( KMPXMediaGeneralId );

        attrs.Append( KMPXMediaGeneralUri );

        attrs.Append( KMPXMediaGeneralTitle );

        switch( secLevId )

            {

            case 211:

                ids.Append( 3111 );

                break;

            case 212:

                ids.Append( 3121 );

                break;

            case 213:

                ids.Append( 3131 );

                break;

            case 221:

                // Empty

                break;

            case 231:

                ids.Append( 3311 );

                break;

            case 232:

                ids.Append( 3321 );

                break;

            };

        const TArray<TMPXAttribute>& tempRef = aAttrs.Count() == 0? attrs.Array() : aAttrs;

        AddMediaL(*array, ids, tempRef);

        FilterMediaArray(*array, aFilter);

        entries->SetCObjectValueL (TMPXAttribute(KMPXMediaIdContainer,EMPXMediaArrayContents),array);

        entries->SetTObjectValueL (TMPXAttribute(KMPXMediaIdContainer,EMPXMediaArrayCount),array->Count());

        iObs->HandleOpen (entries, KErrNone);  

        CleanupStack::PopAndDestroy(3, &ids);   // attrs, array, ids

        }

    else

        {

        User::Leave( KErrNotFound );

        }

    CleanupStack::PopAndDestroy( entries );

    }

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

// Get the extended properties of the current file (async) 

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

//

void CTestCollectionPlugin::MediaL (const CMPXCollectionPath& aPath, 

                                        const TArray<TMPXAttribute>& aAttrs,

                                        const TArray<TCapability>& aCaps,

                                        CMPXAttributeSpecs* aSpecs)

    {

    LOG1(_L("CTestCollectionPlugin::MediaL"));

    LogPath( aPath );

    TMPXOpenMode openMode = aPath.OpenNextMode();

    //TInt idIndex = aPath.Levels() - 1;

    LOG2(_L("TMPXOpendMode=%d"), openMode);

    LOG2(_L("aAttrs.Count()=%d"), aAttrs.Count());

    LOG2(_L("aCaps.Count()=%d"), aCaps.Count());

    LOG2(_L("aSpecs=0x%x"), aSpecs);

    switch( (TInt)aPath.Id(1) )

        {

        case 14:    // Test0146

            {

            iObs->HandleMedia(NULL, KErrNone);

            break;

            }

        case 15:    // Test0147

            {

            CMPXMedia* media = CMPXMedia::NewL();

            CleanupStack::PushL( media );

            iObs->HandleMedia(media, KErrNone);

            CleanupStack::PopAndDestroy( media );

            break;

            }

        case 16:    // Test0148

            {

            CMPXMedia* media = CMPXMedia::NewL();

            CleanupStack::PushL( media );

            iObs->HandleMedia(media, KErrNotFound);

            CleanupStack::PopAndDestroy( media );

            break;

            }

        case 17:    // Test0149

            {

            CMPXMedia* media = CMPXMedia::NewL();

            CleanupStack::PushL( media );

            (*media) = *aSpecs;

            iObs->HandleMedia(media, KErrNone);

            CleanupStack::PopAndDestroy( media );

            break;

            }

        case 990:   // Test data for playback framework teests

            {

            CMPXMedia* media = CMPXMedia::NewL();

            CleanupStack::PushL( media );

            switch( (TInt)aPath.Id(2) )

                {

                case 9901:

                    AddAttrbuteL(*media, 9901, _L("song9901"), _L("\\song9901.ts"), aAttrs);

                    AddAttributePlaybackFwTestL(*media, 9901, aAttrs);

                    break;

                case 9902:

                    AddAttrbuteL(*media, 9902, _L("song9902"), _L("\\song9902.ts"), aAttrs);

                    AddAttributePlaybackFwTestL(*media, 9902, aAttrs);

                    break;

                case 9903:

                    AddAttrbuteL(*media, 9903, _L("song9903"), _L("\\song9903.ts"), aAttrs);

                    AddAttributePlaybackFwTestL(*media, 9903, aAttrs);

                    break;

                case 9904:

                    AddAttrbuteL(*media, 9904, _L("song9904"), _L("\\song9904.ts"), aAttrs);

                    AddAttributePlaybackFwTestL(*media, 9904, aAttrs);

                    break;

                case 9905:

                    AddAttrbuteL(*media, 9905, _L("song9905"), _L("\\song9905.ts"), aAttrs);

                    AddAttributePlaybackFwTestL(*media, 9905, aAttrs);

                    break;

                case 9906:

                    AddAttrbuteL(*media, 9906, _L("song9906"), _L("\\song9906.ts"), aAttrs);

                    AddAttributePlaybackFwTestL(*media, 9906, aAttrs);

                    break;

                case 9907:

                    AddAttrbuteL(*media, 9907, _L("song9907"), _L("\\song9907.ts"), aAttrs);

                    AddAttributePlaybackFwTestL(*media, 9907, aAttrs);

                    break;

                };

            iObs->HandleMedia(media, KErrNone);

            CleanupStack::PopAndDestroy( media );

            break;

            }

        default:    

            User::Leave( KErrNotFound );

        };    

    }

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

// Cancel outstanding request 

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

//

void CTestCollectionPlugin::CancelRequest()

    {

    LOG1(_L("CTestCollectionPlugin::CancelRequest"));

    }

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

// Executes the given command on the collection 

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

//

void CTestCollectionPlugin::CommandL(TMPXCollectionCommand aCmd, TInt aArg )

    {

    LOG1(_L("CTestCollectionPlugin::CommandL"));

    LOG3(_L("TMPXCollectionCommand=%d; aArg=%d"), aCmd, aArg);

    switch( aCmd )

        {

        case EMcCmdClose:

            LOG1( _L("McCmdClose command received"));

            break;

        case EMcCmdRefresh:

            LOG1( _L("EMcCmdRefresh command received"));

            break;

        case EMcCmdRemoveAll:

            LOG1( _L("EMcCmdRemoveAll command received"));

            break;

        case EMcCloseCollection:

            LOG1( _L("EMcCloseCollection command received"));

            break;

        case EMcReOpenCollection:

            LOG1( _L("EMcReOpenCollection command received"));

            break;

        case EMcRefreshStarted:

            LOG1( _L("EMcRefreshStarted command received"));

            break;

        case EMcRefreshEnded:

            LOG1( _L("EMcRefreshEnded command received"));

            break;

        case EMcCmdReCreateDB:

            LOG1( _L("EMcCmdReCreateDB command received"));

            break;

        case EMcCmdSelect:

            LOG1( _L("EMcCmdSelect command received"));

            break;

        case EMcCmdDbCorrupted:

            LOG1( _L("EMcCmdDbCorrupted command received"));

            break;

        case EMcCmdCollectionInit:

            LOG1( _L("EMcCmdCollectionInit command received"));

            break;

        case EMcCmdCollectionResyn:

            LOG1( _L("EMcCmdCollectionResyn command received"));

            break;

        default:

            break;

        };

    }

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

// Executes the given command on the collection 

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

//

void CTestCollectionPlugin::CommandL(CMPXCommand& aCmd)

    {

    LOG1(_L("CTestCollectionPlugin::CommandL"));

    const TDesC& title = aCmd.ValueText( KMPXMediaGeneralTitle );

    TMPXCommandId cmdId = aCmd.ValueTObjectL<TMPXCommandId>(KMPXCommandGeneralId);

    LOG2(_L("CommandId = %d"), cmdId);

    if(title == _L("CollectionPluginTest0175") )

        {

        }

    else if(title == _L("CollectionPluginTest0176") )

        {

        iObs->HandleCommandComplete(NULL, KErrNone);

        }

    else if(title == _L("CollectionPluginTest0177") )

        {

        iObs->HandleCommandComplete(NULL, KErrGeneral);

        }

    else if(title == _L("CollectionPluginTest0183") )

        {

        }

    else if(title == _L("CollectionPluginTest0184") )

        {

        CMPXCommand* newCmd = CMPXCommand::NewL();

        CleanupStack::PushL( newCmd );

        *newCmd = aCmd;

        iObs->HandleCommandComplete(newCmd, KErrNone);

        CleanupStack::PopAndDestroy( newCmd );

        }

    else

        {

        TBool syncOp(EFalse);

        if( aCmd.IsSupported(KMPXCommandGeneralDoSync) )

            {

            syncOp = *aCmd.Value<TBool>(KMPXCommandGeneralDoSync);

            }

        switch( cmdId )

            {

            case KMPXCommandIdCollectionRetrieveUriForDeletion:

                { // TODO

                LOG1(_L("CTestCollectionPlugin::CommandL - KMPXCommandIdCollectionRetrieveUriForDeletion"));

                //DoRetrieveUriForDeletionL(aCmd);

                break;

                }        

            case KMPXCommandIdCollectionRemove:

                {

                LOG1(_L("CTestCollectionPlugin::CommandL - KMPXCommandIdCollectionRemove"));

                //DoRemovePathL(aCmd);

                break;    

                }

            case KMPXCommandIdCollectionRemoveMedia:

                {

                LOG1(_L("CTestCollectionPlugin::CommandL - KMPXCommandIdCollectionRemoveMedia"));

                //DoRemoveMediaL(aCmd);

                break;

                }

            case KMPXCommandIdCollectionCleanupDeletedMedias:

                {

                LOG1(_L("CTestCollectionPlugin::CommandL - KMPXCommandIdCollectionCleanupDeletedMedias"));

                //DoCleanupDeletedMediasL(aCmd);

                break;

                }

            case KMPXCommandIdCollectionAdd:

                {

                LOG1(_L("CTestCollectionPlugin::CommandL - KMPXCommandIdCollectioAdd"));

                CMPXMedia& media = *aCmd.Value<CMPXMedia>(KMPXCommandColAddMedia);

                AddL(media);

                break;

                }

            case KMPXCommandIdCollectionSet:

                {

                LOG1(_L("CTestCollectionPlugin::CommandL - KMPXCommandIdCollectionSet"));

                CMPXMedia& media = *aCmd.Value<CMPXMedia>(KMPXCommandColSetMedia);

                SetL( media );

                break;

                }

            case KMPXCommandIdCollectionCompleteDelete:

                {

                LOG1(_L("CTestCollectionPlugin::CommandL - KMPXCommandIdCollectionCompleteDelete"));

                //DoHandleDeleteCompleteL( aCmd );

                break;    

                }

            default:

                {

                User::Panic(_L("CTestCollectionPlugin::CommandL panic"), 1); // magic number

                }

            }

        if (!syncOp)

            {    

            iObs->HandleCommandComplete( NULL, KErrNone );

            }

        }

    }

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

// Adds an item (song or playlist) to the collection

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

//

void CTestCollectionPlugin::AddL (const CMPXMedia& aMedia)

    {

    LOG1(_L("CTestCollectionPlugin::AddL"));