/*

* Copyright (c) 2007 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:  Provides albums support utilizing MDS.

*

*/

// INCLUDE FILES

#include <e32base.h>

#include <mpxlog.h>

#include <mdesession.h>

#include <mdeconstants.h>

#include <mdequery.h>

#include <mpxmedia.h>

#include <mpxmediaarray.h>

#include <mpxmediacontainerdefs.h>

#include <mpxmediageneraldefs.h>

#include "vcxmyvideosmdsalbums.h"

#include "vcxmyvideosmdsdb.h"

#include "vcxmyvideoscollectionutil.h"

#include "vcxmyvideosmdscmdqueue.h"

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

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

// Constructor

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

//

CVcxMyVideosMdsAlbums::CVcxMyVideosMdsAlbums( CVcxMyVideosMdsDb& aMdsDb,

        MVcxMyVideosMdsAlbumsObserver* aObserver )

: CActive( EPriorityStandard ), iMdsDb( aMdsDb ), iObserver(aObserver) 

    {

    }

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

// 2nd-phase constructor

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

//

void CVcxMyVideosMdsAlbums::ConstructL()

    {

    GetSchemaDefinitionsL();

    CActiveScheduler::Add( this );

    if ( iObserver )

        {

        //ENotifyAdd and ENotifyModify are not supported

                ENotifyRemove, iMdsDb.iNamespaceDef );

#if 0

        // We receive only IDs from here. We need to make query to get

        // relation objects-> slow to use. We use the response from

        // the add operation instead. This way we don't receive

        // add events if someone else adds videos to our albums

        // but the performance is the best possible.

                ENotifyAdd | ENotifyModify | ENotifyRemove );        

#endif

        }

    //TODO: do we need this?

    }

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

// Two-Phase Constructor

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

//

CVcxMyVideosMdsAlbums* CVcxMyVideosMdsAlbums::NewL( CVcxMyVideosMdsDb& aMdsDb,

        MVcxMyVideosMdsAlbumsObserver* aObserver )

    {

    CVcxMyVideosMdsAlbums* self = new(ELeave) CVcxMyVideosMdsAlbums( aMdsDb, aObserver );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// Destructor

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

//

CVcxMyVideosMdsAlbums::~CVcxMyVideosMdsAlbums()

    {

    CancelQueries();

    delete iAlbumQuery;

    delete iVideoQuery;

    delete iRelationQuery;

    iItemArray.Close();

    iResultBuffer.Close();

    }

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

// CVcxMyVideosMdsAlbums::CancelQueries

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

//

void CVcxMyVideosMdsAlbums::CancelQueries( CVcxMyVideosMdsDb::TRequestType aType )

    {

    MPX_DEBUG1("CVcxMyVideosMdsAlbums::CancelQueries() start");

    if ( aType == CVcxMyVideosMdsDb::EAll || aType == CVcxMyVideosMdsDb::EGetAlbums )

        {

        if ( iAlbumQuery )

            {

            iAlbumQuery->Cancel();

            }

        }

    if ( aType == CVcxMyVideosMdsDb::EAll || aType == CVcxMyVideosMdsDb::EGetAlbumContentIds )

        {

        if ( iRelationQuery )

            {

            iRelationQuery->Cancel();

            }

        }

    if ( aType == CVcxMyVideosMdsDb::EAll || aType == CVcxMyVideosMdsDb::EGetAlbumContentVideos )

        {

        if ( iVideoQuery )

            {

            iVideoQuery->Cancel();

            }

        }

    if ( aType == CVcxMyVideosMdsDb::EAll || aType == CVcxMyVideosMdsDb::EAddVideosToAlbum

            || aType == CVcxMyVideosMdsDb::ERemoveRelations

            || aType == CVcxMyVideosMdsDb::ERemoveAlbums )

        {

        // MDS does not offer cancel for these

        //Cancel();

        }

    MPX_DEBUG1("CVcxMyVideosMdsAlbums::CancelQueries() exit");

    }

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

// From CActive

// CVcxMyVideosMdsAlbums::DoCancel

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

//

void CVcxMyVideosMdsAlbums::DoCancel()

    {

    MPX_DEBUG1("CVcxMyVideosMdsAlbums::DoCancel() start");

    MPX_DEBUG1("CVcxMyVideosMdsAlbums::DoCancel() exit");

    }

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

// CVcxMyVideosMdsAlbums::GetAlbumsL

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

//

void CVcxMyVideosMdsAlbums::GetAlbumsL( CMPXMedia* aAlbumList,

        MVcxMyVideosMdsAlbumsObserver& aClient )

    {

    CVcxMyVideosMdsCmdGetAlbums* cmd = new (ELeave) CVcxMyVideosMdsCmdGetAlbums;

    CleanupStack::PushL( cmd );

    cmd->iCmdType   = CVcxMyVideosMdsDb::EGetAlbums;

    cmd->iClient    = &aClient;

    cmd->iAlbumList = aAlbumList;

    iMdsDb.iCmdQueue->ExecuteCmdL( cmd ); //owneship moves

    CleanupStack::Pop( cmd );

    }

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

// CVcxMyVideosMdsAlbums::GetAlbumL

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

//

CMPXMedia* CVcxMyVideosMdsAlbums::GetAlbumL( TUint32 aId )

    {

    CMdEObject* object = iMdsDb.ObjectL( aId, EFalse /* is not video, is album */);

    if ( !object )

        {

        MPX_DEBUG2("CVcxMyVideosMdsAlbums:: mds id %d not found from mds", aId);

        return NULL;

        }

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

    CMPXMedia* album = CMPXMedia::NewL( );

    CleanupStack::PushL( album ); // 2->

    Object2MediaL( *object, *album );

    CleanupStack::Pop( album );            // <-2

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

    return album;

    }

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

// CVcxMyVideosMdsAlbums::DoGetAlbumsL

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

//

void CVcxMyVideosMdsAlbums::DoGetAlbumsL( CMPXMedia* aAlbumList,

        MVcxMyVideosMdsAlbumsObserver& aClient )

    {

    MPX_DEBUG1("CVcxMyVideosMdsAlbums::DoGetAlbumsL() start");

    iAlbumList = aAlbumList; //store pointer to album list, we do not own this

    iClient    = &aClient;

    delete iAlbumQuery;

    iAlbumQuery = NULL;

    CMdELogicCondition& rootCondition = iAlbumQuery->Conditions();

    rootCondition.SetOperator( ELogicConditionOperatorOr );

    rootCondition.AddObjectConditionL( *iAlbumObjectDef );

    rootCondition.AddPropertyConditionL( *iTypePropertyDef,

            TMdEIntRange( MdeConstants::Album::EAlbumUser, MdeConstants::Album::EAlbumUser,

            EMdERangeTypeEqual ) );

    iAlbumQuery->FindL();

    MPX_DEBUG1("CVcxMyVideosMdsAlbums::DoGetAlbumsL() exit");

    }

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

// CVcxMyVideosMdsAlbums::GetAlbumContentIdsL

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

//

void CVcxMyVideosMdsAlbums::GetAlbumContentIdsL( TUint32 aAlbumId,

        RArray<TVcxMyVideosAlbumVideo>& aContentArray,

        MVcxMyVideosMdsAlbumsObserver& aClient )

    {

    CVcxMyVideosMdsCmdGetAlbumContentIds* cmd = new (ELeave) CVcxMyVideosMdsCmdGetAlbumContentIds;

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

    cmd->iCmdType      = CVcxMyVideosMdsDb::EGetAlbumContentIds;

    cmd->iClient       = &aClient;

    cmd->iAlbumId      = aAlbumId;

    cmd->iAlbumContent = &aContentArray;

    iMdsDb.iCmdQueue->ExecuteCmdL( cmd ); //owneship moves

    CleanupStack::Pop( cmd ); // <-1

    }

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

// CVcxMyVideosMdsAlbums::DoGetAlbumContentIdsL

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

//

void CVcxMyVideosMdsAlbums::DoGetAlbumContentIdsL( TUint32 aAlbumId,

        RArray<TVcxMyVideosAlbumVideo>& aContentArray,

        MVcxMyVideosMdsAlbumsObserver& aClient )

    {

    MPX_DEBUG1("CVcxMyVideosMdsAlbums::DoGetAlbumContentIdsL() start");

    delete iRelationQuery;

    iRelationQuery = NULL;

    iClient       = &aClient;

    iAlbumId      = aAlbumId;

    iAlbumContent = &aContentArray;

    CMdELogicCondition& rootCondition = iRelationQuery->Conditions();

    //relation left side contains and...

    CMdERelationCondition& relationCondition =

        rootCondition.AddRelationConditionL( *iContainsRelationDef, ERelationConditionSideLeft); // "AND"

    CMdELogicCondition& leftCondition = relationCondition.LeftL();

    CMdELogicCondition& rightCondition = relationCondition.RightL();

    //...left side is album...

    leftCondition.AddObjectConditionL( *iAlbumObjectDef );

    //...and left id is aAlbumId..

    leftCondition.AddObjectConditionL( aAlbumId );

    //Right side is video

    rightCondition.AddObjectConditionL( *iMdsDb.iVideoObjectDef ); 

    iRelationQuery->FindL();

    MPX_DEBUG1("CVcxMyVideosMdsAlbums::DoGetAlbumContentIdsL() exit");

    }

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

// CVcxMyVideosMdsAlbums::GetAlbumContentVideosL

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

//

void CVcxMyVideosMdsAlbums::GetAlbumContentVideosL( TUint32 aAlbumId, CMPXMedia& aVideoList,

        MVcxMyVideosMdsAlbumsObserver& aClient )

    {

    MPX_DEBUG1("CVcxMyVideosMdsAlbums::GetAlbumContentVideosL() start");

    CVcxMyVideosMdsCmdGetAlbumContentVideos* cmd = new (ELeave) CVcxMyVideosMdsCmdGetAlbumContentVideos;

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

    cmd->iCmdType            = CVcxMyVideosMdsDb::EGetAlbumContentVideos;

    cmd->iClient             = &aClient;

    cmd->iAlbumId            = aAlbumId;

    cmd->iAlbumContentVideos = &aVideoList;

    iMdsDb.iCmdQueue->ExecuteCmdL( cmd ); //owneship moves

    CleanupStack::Pop( cmd ); // <-1

    MPX_DEBUG1("CVcxMyVideosMdsAlbums::GetAlbumContentVideosL() exit");

    }

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

// CVcxMyVideosMdsAlbums::DoGetAlbumContentVideosL

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

//

void CVcxMyVideosMdsAlbums::DoGetAlbumContentVideosL( TUint32 aAlbumId, CMPXMedia& aVideoList,

        MVcxMyVideosMdsAlbumsObserver& aClient )

    {

    MPX_DEBUG1("CVcxMyVideosMdsAlbums::DoGetAlbumContentVideosL() start");

    delete iVideoQuery;

    iVideoQuery = NULL;

    iClient    = &aClient;

    iVideoList = &aVideoList;

    iAlbumId   = aAlbumId;

    CMdELogicCondition& rootCondition = iVideoQuery->Conditions();

    CMdERelationCondition& relationCondition = 

            rootCondition.AddRelationConditionL( *iContainsRelationDef );

    CMdELogicCondition& leftCondition = relationCondition.LeftL();

    //...left side is an album...

    leftCondition.AddObjectConditionL( *iAlbumObjectDef );

    //...and left id is aAlbumId..

    leftCondition.AddObjectConditionL( aAlbumId );

    //and queried object is on the right side of the relation

    relationCondition.SetSide( ERelationConditionSideRight );

    const TInt maxItemsInQueryResult = 500;

    iVideoQuery->FindL( KMdEQueryDefaultMaxCount, maxItemsInQueryResult );

    MPX_DEBUG1("CVcxMyVideosMdsAlbums::DoGetAlbumContentVideosL() exit");

    }

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

// CVcxMyVideosMdsAlbums::GetSchemaDefinitionsL

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

//

void CVcxMyVideosMdsAlbums::GetSchemaDefinitionsL()

    {

    _LIT( KVcxAlbumObjectName, "Album" );

    iAlbumObjectDef = &(iNamespaceDef->GetObjectDefL( KVcxAlbumObjectName ));

    _LIT( KVcxTypePropertyName, "Type" );

    iTypePropertyDef = &(iAlbumObjectDef->GetPropertyDefL( KVcxTypePropertyName ));

    _LIT( KVcxContainsRelationName, "Contains" );

    iContainsRelationDef =

        &(iNamespaceDef->GetRelationDefL( KVcxContainsRelationName ));

    }

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

// CVcxMyVideosMdsAlbums::Object2MediaL

// For album objects only.

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

//

void CVcxMyVideosMdsAlbums::Object2MediaL(

        CMdEObject& aObject,

        CMPXMedia& aAlbum )

    {    

    aAlbum.SetTObjectValueL<TMPXGeneralType>(KMPXMediaGeneralType, EMPXGroup );

    CMdEProperty* property = NULL;

    // ID

    TMPXItemId mpxId;

    mpxId.iId1 = aObject.Id();

    mpxId.iId2 = KVcxMvcMediaTypeAlbum;

    aAlbum.SetTObjectValueL<TMPXItemId>( KMPXMediaGeneralId, mpxId );

    // TITLE

    if ( aObject.Property( *iMdsDb.iTitlePropertyDef, property, 0 ) != KErrNotFound )

        {

        aAlbum.SetTextValueL( KMPXMediaGeneralTitle,

                static_cast<CMdETextProperty*>(property)->Value());

        }

    // CREATION DATE

    if ( aObject.Property( *iMdsDb.iCreationDatePropertyDef, property, 0 ) != KErrNotFound )

        {

        aAlbum.SetTObjectValueL<TInt64>( KMPXMediaGeneralDate,

                static_cast<CMdETimeProperty*>(property)->Value().Int64() );

        }

    // MODIFIED DATE

    if ( aObject.Property( *iMdsDb.iLastModifiedDatePropertyDef, property, 0 ) != KErrNotFound )

        {

        aAlbum.SetTObjectValueL<TInt64>( KVcxMediaMyVideosModifiedDate,

                static_cast<CMdETimeProperty*>(property)->Value().Int64() );

        }

#if 0 //TODO

    // ALBUM TYPE

    if ( aObject.Property( *iTypePropertyDef, property, 0 ) != KErrNotFound )

        {

        aAlbum.SetTObjectValueL<TUint16>( KVcxMediaMyVideosAlbumType,

                static_cast<CMdETUint16Property*>(property)->Value() );

        }

#endif

    //TODO: usage count

    aAlbum.SetTObjectValueL( KMPXMediaGeneralType, EMPXGroup );

    aAlbum.SetTObjectValueL( KMPXMediaGeneralCategory, EMPXNoCategory );

    aAlbum.SetTObjectValueL( KVcxMediaMyVideosCategoryItemCount, 0 );

    aAlbum.SetTObjectValueL( KVcxMediaMyVideosCategoryNewItemCount, 0 );

    }

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

// CVcxMyVideosMdsAlbums::Media2ObjectL

// Called by AddAlbumL()

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

//

void CVcxMyVideosMdsAlbums::Media2ObjectL(

        CMPXMedia& aAlbum,

        CMdEObject& aObject)

    {

    CMdEProperty* property;

    // MDS ID

    // TITLE (NAME)

    if ( aAlbum.IsSupported( KMPXMediaGeneralTitle ) )

        {

        if ( aObject.Property( *iMdsDb.iTitlePropertyDef, property, 0 ) != KErrNotFound )

            {

            static_cast<CMdETextProperty*>(property)->SetValueL(

                    aAlbum.ValueText( KMPXMediaGeneralTitle ) );

            }

        else

            {

            aObject.AddTextPropertyL(

                    *iMdsDb.iTitlePropertyDef, aAlbum.ValueText( KMPXMediaGeneralTitle ) );

            }

        }

    // KMPXMediaGeneralDate ( creation date )

    if ( aAlbum.IsSupported( KMPXMediaGeneralDate ) )

        {

        TInt64 creationDateInt64 = 0;

        creationDateInt64 = aAlbum.ValueTObjectL<TInt64>( KMPXMediaGeneralDate );

        TTime creationDate( creationDateInt64 );

        if ( aObject.Property( *iMdsDb.iCreationDatePropertyDef, property, 0 ) != KErrNotFound )

            {

            static_cast<CMdETimeProperty*>(property)->SetValueL( creationDate );

            }

        else

            {

            aObject.AddTimePropertyL( *iMdsDb.iCreationDatePropertyDef, creationDate );

            }

        }

    // KVcxMediaMyVideosModifiedDate

    if ( aAlbum.IsSupported( KVcxMediaMyVideosModifiedDate ) )

        {

        TInt64 modifiedDateInt64 = aAlbum.ValueTObjectL<TInt64>( KVcxMediaMyVideosModifiedDate );

        TTime modifiedDate( modifiedDateInt64 );

        if ( aObject.Property( *iMdsDb.iLastModifiedDatePropertyDef, property, 0 ) != KErrNotFound )

            {

            static_cast<CMdETimeProperty*>(property)->SetValueL( modifiedDate );

            }

        else

            {

            aObject.AddTimePropertyL( *iMdsDb.iLastModifiedDatePropertyDef, modifiedDate );

            }

        }        

    }

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

// CVcxMyVideosMdsAlbums::GetSchemaDefinitionsL

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

//

void CVcxMyVideosMdsAlbums::HandleQueryNewResults(CMdEQuery& aQuery,

            TInt aFirstNewItemIndex,

            TInt aNewItemCount )

    {

    if ( &aQuery == iVideoQuery )

        {

        TRAPD( err, HandleVideoQueryResultsL( aQuery, KErrNone,

                aFirstNewItemIndex, aNewItemCount, EFalse /* completed */ ) );

        if ( err != KErrNone )

            {

            MPX_DEBUG2("CVcxMyVideosMdsAlbums:: HandleVideoQueryResultsL() left: %d", err);

            }

        }

    }

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

// CVcxMyVideosMdsAlbums::HandleQueryCompleted

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

//

void CVcxMyVideosMdsAlbums::HandleQueryCompleted( CMdEQuery& aQuery, TInt aError )

    {

    if ( &aQuery == iAlbumQuery )

        {

        TRAPD( err, HandleAlbumQueryCompletedL( aQuery, aError ) );

        if ( err != KErrNone )

            {

            MPX_DEBUG2("CVcxMyVideosMdsAlbums:: HandleAlbumQueryCompletedL() left: %d", err);

            }

        }

    else if ( &aQuery == iVideoQuery )

        {

        TRAPD( err, HandleVideoQueryResultsL( aQuery, aError, 0, 0, ETrue /* completed */ ) );

        if ( err != KErrNone )