/*

* Copyright (c) 2008 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of the License "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 My Videos collection Plugin interface*

*/

// INCLUDE FILES

#include <e32cmn.h>

#include <s32mem.h>

#include <mpxlog.h>

#include <mpxmediacontainerdefs.h>

#include <mpxmediageneraldefs.h>

#include <mpxmediageneralextdefs.h>

#include <mpxcollectionpluginobserver.h>

#include <mpxmessagegeneraldefs.h>

#include <mpxcommandgeneraldefs.h>

#include <mpxcollectioncommanddefs.h>

#include <mpxmessagecontainerdefs.h>

#include <vcxmyvideosuids.h>

#include <drmutility.h>

#include <bautils.h>

#include "vcxmyvideoscollectionplugin.h"

#include "vcxmyvideoscollection.hrh"

#include "vcxmyvideoscollectionutil.h"

#include "vcxmyvideosvideocache.h"

#include "vcxmyvideoscategories.h"

#include "vcxmyvideosmessagelist.h"

#include "vcxmyvideosasyncfileoperations.h"

#include "vcxmyvideosopenhandler.h"

#include "vcxmyvideosmdsalbums.h"

#include "vcxmyvideosalbums.h"

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

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

// Two-phased constructor.

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

//

CVcxMyVideosCollectionPlugin* CVcxMyVideosCollectionPlugin::NewL(

    TAny* /* aInitParams */)

    {

    MPX_FUNC("CVcxMyVideosCollectionPlugin::NewL");

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

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    return self;

    }

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

// Destructor.

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

//

CVcxMyVideosCollectionPlugin::~CVcxMyVideosCollectionPlugin()

    {

    MPX_FUNC("CVcxMyVideosCollectionPlugin::~CVcxMyVideosCollectionPlugin");

    MPX_DEBUG2("CVcxMyVideosCollectionPlugin:: this = %x", this);

    delete iMyVideosMdsDb;

    delete iCache;

    delete iMessageList;

    delete iCategories;

    delete iAsyncFileOperations;

    delete iActiveTask;

    delete iOpenHandler;

    delete iAlbums;

    iFs.Close();

    }

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

// Constructor.

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

//

CVcxMyVideosCollectionPlugin::CVcxMyVideosCollectionPlugin()

    {

    MPX_FUNC("CVcxMyVideosCollectionPlugin::CVcxMyVideosCollectionPlugin");

    MPX_DEBUG2("CVcxMyVideosCollectionPlugin:: this = %x", this);

    }

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

// Symbian 2nd phase constructor can leave.

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

//

void CVcxMyVideosCollectionPlugin::ConstructL ()

    {

    MPX_FUNC("CVcxMyVideosCollectionPlugin::ConstructL");

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

    iMyVideosMdsDb = CVcxMyVideosMdsDb::NewL( this, &AlbumsL(), iFs );    

    iActiveTask    = CVcxMyVideosActiveTask::NewL( *this );

    iCache         = CVcxMyVideosVideoCache::NewL( *this );

    iMessageList   = CVcxMyVideosMessageList::NewL( *this );

    iOpenHandler   = CVcxMyVideosOpenHandler::NewL( *this, *iCache, *iMyVideosMdsDb );

    }

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

// Navigates to the given path

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

//

void CVcxMyVideosCollectionPlugin::OpenL(

    const CMPXCollectionPath& aPath,

    const TArray<TMPXAttribute>& /* aAttrs */,

    CMPXFilter* /*aFilter*/)

    {

    iOpenHandler->OpenL( aPath );

    }

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

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

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

//

void CVcxMyVideosCollectionPlugin::MediaL(

    const CMPXCollectionPath& aPath,

    const TArray<TMPXAttribute>& aAttrs,

    const TArray<TCapability>& /*aCaps*/,

    CMPXAttributeSpecs* /*aSpecs*/)

    {

    MPX_FUNC("CVcxMyVideosCollectionPlugin::MediaL");

    MPX_DEBUG_PATH(aPath);

    RArray<TInt> supportedIds;

    CleanupClosePushL( supportedIds ); // 1->

    if ( aPath.Selection().Count() > 1 )

        {

        // it's a container if there are multiple selections, else it's not a container

        //supportedIds.AppendL(KMPXMediaIdContainer);

        //multiple selections not supported yet

        CleanupStack::PopAndDestroy( &supportedIds ); // <-1

        iObs->HandleMedia( NULL, KErrNotSupported );

        return;

        }

    RArray<TMPXItemId> ids;

    CleanupClosePushL(ids); // 2->

    aPath.SelectionL( ids );

    // MPX playback server asks it by path without selecting the media.

    if ( ids.Count() == 0 && aPath.Id() != KMPXInvalidItemId )

        {

        CMPXCollectionPath* path = CMPXCollectionPath::NewL( aPath );

        CleanupStack::PushL( path );

        path->SelectL( aPath.Id() );

        path->SelectionL( ids );

        CleanupStack::PopAndDestroy( path );

        }

    if ( ids.Count() == 0 )

        {

        MPX_DEBUG1("CVcxMyVideosCollectionPlugin:: request didn't contain any items ids, aborting");

        iObs->HandleMedia( NULL, KErrArgument );

        CleanupStack::PopAndDestroy( &ids );          // <-2

        CleanupStack::PopAndDestroy( &supportedIds ); // <-1

        return;

        }

    TBool useCachedVideo( EFalse );

    TInt pos;

    CMPXMedia* videoInCache = iCache->FindVideoByMdsIdL( ids[0].iId1, pos );

    if ( videoInCache )

        {

        // 0 attributes means "get all" -> can't use cache

        MPX_DEBUG2("CVcxMyVideosCollectionPlugin:: client is requesting %d attributes", aAttrs.Count());

        if ( aAttrs.Count() > 0 )

            {

            TBool nonSupportedAttrCanBeFoundFromMds;

            if ( TVcxMyVideosCollectionUtil::AreSupported( *videoInCache, aAttrs,

                    nonSupportedAttrCanBeFoundFromMds ) )

                {

                MPX_DEBUG1("CVcxMyVideosCollectionPlugin:: all attributes found from cache");

                useCachedVideo = ETrue;

                }

            else

                {

                MPX_DEBUG1("CVcxMyVideosCollectionPlugin:: all attributes NOT found from cache");

                if ( !nonSupportedAttrCanBeFoundFromMds )

                    {

                    MPX_DEBUG1("CVcxMyVideosCollectionPlugin:: none of the non cached attrs can be found from MDS -> use cached version");

                    useCachedVideo = ETrue;

                    }

                else

                    {

                    MPX_DEBUG1("CVcxMyVideosCollectionPlugin:: at least one of the non cached attributes can be found from MDS");

                    }

                }

            }

        }

    CMPXMedia* video;

    if ( useCachedVideo )

        {

        MPX_DEBUG1("CVcxMyVideosCollectionPlugin:: using cached video");

        video = CMPXMedia::CopyL( *videoInCache );

        }

    else

        {

        MPX_DEBUG1("CVcxMyVideosCollectionPlugin:: fetching from MDS");

        video = iMyVideosMdsDb->CreateVideoL( ids[0].iId1, ETrue /* full details */ );    

        }

    CleanupStack::PopAndDestroy( &ids );          // <-2

    CleanupStack::PopAndDestroy( &supportedIds ); // <-1

    }

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

// Cancel the pending request, this is called by mpx framework when client calls

// Cancel.

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

//

void CVcxMyVideosCollectionPlugin::CancelRequest()

    {

    MPX_FUNC("CVcxMyVideosCollectionPlugin::CancelRequest");

    iActiveTask->Cancel();

    iMyVideosMdsDb->Cancel();

    }

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

// Executes the given command on the collection

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

//

void CVcxMyVideosCollectionPlugin::CommandL(

    CMPXCommand& aCmd)

    {

    MPX_FUNC("CVcxMyVideosCollectionPlugin::CommandL 2");

    if ( !aCmd.IsSupported( KMPXCommandGeneralId ) )

        {

        User::Leave( KErrArgument );

        }

    TMPXCommandId commandId = *aCmd.Value<TMPXCommandId>(KMPXCommandGeneralId);

    TBool syncOp( EFalse );

    if( aCmd.IsSupported( KMPXCommandGeneralDoSync ) )

        {

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

        }

    if ( !syncOp )

        {

        // async

        iActiveTask->StartL( commandId, aCmd );        

        }

    else

        {

        // sync, operations to a single media object only

        TMPXCommandId commandId = *aCmd.Value<TMPXCommandId>(KMPXCommandGeneralId);

        switch ( commandId )

            {

            case KMPXCommandIdCollectionAdd:

                {

                MPX_DEBUG1("CVcxMyVideosCollectionPlugin:: sync KMPXCommandIdCollectionAdd arrived");

#ifdef _DEBUG

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

                TUint32 mdsId( 0 );

                iMyVideosMdsDb->AddVideoL( *video, mdsId );

#else

                User::Leave( KErrNotSupported );

#endif

                }

                break;

            case KMPXCommandIdCollectionSet:

                {

                MPX_DEBUG1("CVcxMyVideosCollectionPlugin:: sync KMPXCommandIdCollectionSet arrived");

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

                }

                break;

            case KVcxCommandIdMyVideos:

                {

                switch ( aCmd.ValueTObjectL<TUint32>( KVcxMediaMyVideosCommandId ) )

                    {

                    case KVcxCommandMyVideosCancelMoveOrCopy:

                        {

                        MPX_DEBUG1("CVcxMyVideosCollectionPlugin:: sync KVcxCommandMyVideosCancelMoveOrCopy arrived");

                        iActiveTask->Cancel();

                        }

                        break;

                    case KVcxCommandMyVideosCancelDelete:

                        {

                        MPX_DEBUG1("CVcxMyVideosCollectionPlugin:: sync KVcxCommandMyVideosCancelDelete arrived");

                        iActiveTask->Cancel();

                        }

                        break;

                    case KVcxCommandMyVideosAddAlbum:

                        {

                        MPX_DEBUG1("CVcxMyVideosCollectionPlugin:: sync KVcxCommandMyVideosAddAlbum arrived");

                        AlbumsL().AddAlbumL( aCmd );

                        }

                        break;

                    }

                }

                break;

            default:

                {

                MPX_DEBUG1("CVcxMyVideosCollectionPlugin:: UNKNOWN SYNC COMMAND ARRIVED");

                User::Leave( KErrNotSupported );

                }

            }

        }

    }

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

// Find the items matching the media specifications

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

//

void CVcxMyVideosCollectionPlugin::FindAllL(

    const CMPXMedia& /* aCriteria */,

    const TArray<TMPXAttribute>& /* aAttrs */)

    {

    MPX_FUNC("CVcxMyVideosCollectionPlugin::FindAllL");

    }

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

// Find the items matching the media specifications

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

//

CMPXMedia* CVcxMyVideosCollectionPlugin::FindAllSyncL(

    const CMPXMedia& /* aCriteria */,

    const TArray<TMPXAttribute>& /* aAttrs */)

    {

    MPX_FUNC("CVcxMyVideosCollectionPlugin::FindAllSyncL");

    return NULL;

    }

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

// Get the list of supported capabilities

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

//

TCollectionCapability CVcxMyVideosCollectionPlugin::GetCapabilities()

    {

    // This one supports simple search

    return EMcSearch;

    }

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

// CVcxMyVideosCollectionPlugin::SendMessages

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

//

void CVcxMyVideosCollectionPlugin::SendMessages( CMPXMessage& aMessages )

    {

#if _DEBUG

    TRAP_IGNORE(

    if ( aMessages.IsSupported( KMPXMessageArrayContents ) )

        {

        const CMPXMessageArray* messageArray =

            aMessages.Value<CMPXMessageArray>(KMPXMessageArrayContents);

        for( TInt i = 0; i < messageArray->Count(); i++ )

            {            

            MPX_DEBUG2("CVcxMyVideosCollectionPlugin:: sending message ID: %d in array", ++iTotalMessagesSent);

            messageArray->AtL( i )->SetTObjectValueL<TUint32>( KVcxMediaMyVideosMessageId, iTotalMessagesSent );

            iMessagesInArraySent++;

            }    

        MPX_DEBUG3("CVcxMyVideosCollectionPlugin:: total messages sent (MSG ID): %d, messages in array sent: %d",

            iTotalMessagesSent, iMessagesInArraySent);

        }

    else

        {

        MPX_DEBUG1("CVcxMyVideosCollectionPlugin:: NO ARRAY IN MESSAGE!!!");

        return;

        }

    );

#endif

    iObs->HandleMessage( aMessages );

    }

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

// CVcxMyVideosCollectionPlugin::HandleMyVideosDbEvent

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

//

void CVcxMyVideosCollectionPlugin::HandleMyVideosDbEvent(

        TMPXChangeEventType aEvent,

        RArray<TUint32>& aId )

    {

    //MPX_FUNC("CVcxMyVideosCollectionPlugin::HandleMyVideosDbEvent");

    TRAPD( err, DoHandleMyVideosDbEventL( aEvent, aId ));

    if ( err != KErrNone )

        {

        MPX_DEBUG2("CVcxMyVideosCollectionPlugin::DoHandleMyVideosDbEventL() leaved with error code: %d", err);

        }

    }

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

// CVcxMyVideosCollectionPlugin::DoHandleMyVideosDbEventL

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

//

void CVcxMyVideosCollectionPlugin::DoHandleMyVideosDbEventL(

        TMPXChangeEventType aEvent,

        RArray<TUint32>& aId )

    {

    MPX_FUNC("CVcxMyVideosCollectionPlugin::DoHandleMyVideosDbEventL");

    RArray<TUint32> nonVideoIds;

    nonVideoIds.Reset();

    CleanupClosePushL( nonVideoIds );

    switch ( aEvent )

        {

        case EMPXItemDeleted:

            {

            MPX_DEBUG1("CVcxMyVideosCollectionPlugin::DoHandleMyVideosDbEventL() --------------------------------------------.");

            MPX_DEBUG1("CVcxMyVideosCollectionPlugin::DoHandleMyVideosDbEventL() Items from MDS deleted, deleting from cache |" );

            MPX_DEBUG1("CVcxMyVideosCollectionPlugin::DoHandleMyVideosDbEventL() --------------------------------------------'");

            iCache->RemoveL( aId );

            AlbumsL().RemoveAlbumsL( aId );

            }

            break;

        case EMPXItemInserted:

            {

            MPX_DEBUG1("CVcxMyVideosCollectionPlugin::DoHandleMyVideosDbEventL() ------------------------------------.");

            MPX_DEBUG1("CVcxMyVideosCollectionPlugin::DoHandleMyVideosDbEventL() Items added to MDS, adding to cache |");

            MPX_DEBUG1("CVcxMyVideosCollectionPlugin::DoHandleMyVideosDbEventL() ------------------------------------'");

            if ( iMyVideosMdsDb->iVideoListFetchingIsOngoing )

                {

                MPX_DEBUG1("CVcxMyVideosCollectionPlugin:: video list fetching is ongoing, ignoring add event");

                CleanupStack::PopAndDestroy( &nonVideoIds );

                return;

                }

            TBool videoListFetchingWasCancelled = EFalse;

            // After the call, aId will contain only items which were actually inserted to cache.

            // We receive add events for all object types. When fetching the item from MDS we use

            // video condition and only video objects are added to cache. Items which were detected

            // to not be videos are added to nonVideoIds.

            iCache->AddVideosFromMdsL( aId, videoListFetchingWasCancelled, &nonVideoIds );

#if 0 //TODO: do this if we want to support albums which are being added by someone else than My Videos Collection

            //After the call nonVideoIds will contain only items which were actually added

            //to albums.

            AlbumsL().AddAlbumsFromMdsL( nonVideoIds );

#endif

            if ( videoListFetchingWasCancelled )

                {

                RestartVideoListFetchingL();

                }

            }

            break;

        case EMPXItemModified:

            {

            MPX_DEBUG1("CVcxMyVideosCollectionPlugin::DoHandleMyVideosDbEventL() --------------------------------------.");

            MPX_DEBUG1("CVcxMyVideosCollectionPlugin::DoHandleMyVideosDbEventL() Items modified in MDS, updating cache |");

            MPX_DEBUG1("CVcxMyVideosCollectionPlugin::DoHandleMyVideosDbEventL() --------------------------------------'");

            CMPXMedia* video;

                {

                video = iMyVideosMdsDb->CreateVideoL( aId[i], ETrue /* full details */ );

                if ( video )

                    {

                    CleanupStack::PushL( video ); // 1->

                    iCache->UpdateVideoL( *video );

                    CleanupStack::PopAndDestroy( video ); // <-1

                    }

                else