/*

* 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:   MPX My Videos collection plugin's MDS database class*

*/

//#include <harvesterclient.h>

#include <mpxlog.h>

#include <mdeconstants.h>

#include <mdequery.h>

#include <bautils.h>

#include <mpxmedia.h>

#include <vcxmyvideosdefs.h>

#include <mpxmediacontainerdefs.h>

#include <mpxmediageneraldefs.h>

#include <mpxmediageneralextdefs.h>

#include <mpxmediaarray.h>

#include <mpxmediavideodefs.h>

#include "vcxmyvideosmdsdb.h"

#include "vcxmyvideoscollectionutil.h"

#include "vcxmyvideosmdsalbums.h"

#include "vcxmyvideoscollectionutil.h"

#include "vcxmyvideosmdscmdqueue.h"

_LIT( KVcxVideoObjectName, "Video" );

                                                              //1 (ID)

_LIT( KVcxTitlePropertyName, "Title" );                       //2

_LIT( KVcxDescriptionPropertyName, "Description" );           //3

                                                              //4 (file path = URI)

_LIT( KVcxSizePropertyName, "Size" );                         //11 (5 also for compatibility)

_LIT( KVcxCreationDatePropertyName, "CreationDate" );         //6 creation date is saved to 2 properties

_LIT( KVcxTimeOffsetPropertyName, "TimeOffset" );             //6

_LIT( KVcxFlagsPropertyName, "RecordingFlags" );              //7 flags are saved

_LIT( KVcxDrmPropertyName, "DRM");                            //7 to both of these

_LIT( KVcxCopyrightPropertyName, "Copyright" );               //8

_LIT( KVcxItemTypePropertyName, "ItemType" );                 //9 (mime type)

_LIT( KVcxLastModifiedDatePropertyName, "LastModifiedDate" ); //12

_LIT( KVcxAgeProfilePropertyName, "AgeProfile" );             //13

_LIT( KVcxAudioLanguagePropertyName, "AudioLanguage" );       //14

_LIT( KVcxAuthorPropertyName, "Author" );                     //15

_LIT( KVcxOriginPropertyName, "Origin" );                     //16

_LIT( KVcxDurationPropertyName, "Duration" );                 //17

_LIT( KVcxLastPlayPositionPropertyName, "LastPlayPosition" ); //10

_LIT( KVcxRatingPropertyName, "Rating" );                     //19

_LIT( KVcxBitratePropertyName, "Bitrate" );                   //20

_LIT( KVcxAudioFourCcPropertyName, "AudioFourCC" );           //21

_LIT( KVcxWidthPropertyName, "Width" );                       //22

_LIT( KVcxHeightPropertyName, "Height" );                     //23

_LIT( KVcxArtistPropertyName, "Artist" );                     //24

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

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

//

    {

    }

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

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

//

void CVcxMyVideosMdsDb::ConstructL()

    {

    MPX_FUNC( "CVcxMyVideosMdsDb::ConstructL" );

    iCmdQueue = CVcxMyVideosMdsCmdQueue::NewL( *this );

    iActiveSchedulerWait = new (ELeave) CActiveSchedulerWait;

    MPX_DEBUG1( "CVcxMyVideosMdsDb::ConstructL CMdESession::NewL" );

    //  Create session

    iMdsError = KErrNone;

    iMdsSession = CMdESession::NewL( *this );

    if (!iMdsSession)

        {

        //  Failed to create session, leave

        User::Leave( iMdsError );

        }

    //  Wait until session opened

    iActiveSchedulerWait->Start();

    MPX_DEBUG1( "CVcxMyVideosMdsDb::ConstructL iActiveSchedulerWait->Start done" );

    if ( iMdsError != KErrNone )

        {

        MPX_DEBUG2("Failed to create session to MDS: %d", iMdsError);

        User::LeaveIfError( iMdsError );

        }

    //  Get the schema definitions

    iMdsError = KErrNone;

    GetSchemaDefinitionsL();

    //  Is schema ok

    if ( iMdsError != KErrNone )

        {

        //  Schema not loaded, abort

        User::Leave( iMdsError );

        }

    MPX_DEBUG1( "CVcxMyVideosMdsDb::ConstructL Adding observers" );

    // We order all object notifications. If we set video condition, then we wont

    // receive remove notifications at all (mds feature). Extra notifications

    // do not bother us much since we try to fetch the item from the db

    // after the add notification anyways, and then we use video condition.

    // Eventually extra events are ignored.    

    iMdsSession->AddObjectObserverL( *this, NULL );

    iMdsSession->AddObjectPresentObserverL( *this );

    TCallBack callBack( AsyncHandleQueryCompleted, this );    

    iAsyncHandleQueryCompleteCaller = new (ELeave) CAsyncCallBack( callBack,

            CActive::EPriorityStandard );

    }

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

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

//

void CVcxMyVideosMdsDb::HandleObjectPresentNotification( CMdESession& /*aSession*/,

        TBool aPresent, const RArray<TItemId>& aObjectIdArray)

    {

    MPX_DEBUG1( "CVcxMyVideosMdsDb::--------------------------------------------------------------." );

    MPX_DEBUG3( "CVcxMyVideosMdsDb::HandleObjectPresentNotification( aPresent = %1d, count = %3d) |", aPresent, aObjectIdArray.Count() );

    MPX_DEBUG1( "CVcxMyVideosMdsDb::--------------------------------------------------------------'" );

    TObserverNotificationType type;

    if ( aPresent )

        {

        type = ENotifyAdd;

        }

    else

        {

        type = ENotifyRemove;

        }

    TRAP_IGNORE( DoHandleObjectNotificationL( type, aObjectIdArray ) );    

    }

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

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

//

    {

    CVcxMyVideosMdsDb* self =

    CleanupStack::Pop( self );

    return self;

    }

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

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

//

    {

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

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

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

//

CVcxMyVideosMdsDb::~CVcxMyVideosMdsDb()

    {

    MPX_FUNC( "CVcxMyVideosMdsDb::~CVcxMyVideosMdsDb()" );

    Cancel();

    delete iCmdQueue;    

    if ( iMdsSession )

        {

        TRAP_IGNORE( iMdsSession->RemoveObjectObserverL( *this ) );        

        }

    delete iVideoQuery;

    delete iAlbums;

    delete iMdsSession;

    delete iActiveSchedulerWait;

    delete iAsyncHandleQueryCompleteCaller;

    }

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

// CVcxMyVideosMdsDb::Cancel

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

//

void CVcxMyVideosMdsDb::Cancel( TRequestType aType )

    {

    MPX_FUNC("CVcxMyVideosMdsDb::Cancel()");

    iCmdQueue->Cancel( aType );

    if ( aType == EAll || aType == EGetVideoList )

        {

        if ( iVideoQuery )

            {

            iVideoQuery->Cancel();

            }

        iVideoListFetchingIsOngoing = EFalse;

        }

    iAlbums->Cancel( aType );    

    }

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

// CVcxMyVideosMdsDb::AddVideoL

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

//

void CVcxMyVideosMdsDb::AddVideoL(

        CMPXMedia& aVideo, 

        TUint32& aMdsId )

    {

    MPX_FUNC( "CVcxMyVideosMdsDb::AddVideoL" );

    if ( !iMdsSession )

        {

        MPX_DEBUG2("CVcxMyVideosMdsDb:: no mds session(%d), leaving", iMdsError);

        User::Leave( iMdsError );

        }

    CMdEObject* object = iMdsSession->NewObjectLC(

            *iVideoObjectDef, aVideo.ValueText( KMPXMediaGeneralUri ) ); // 1->

    // check if the file exists and use the creation time from the file

    TTime time;

    time.UniversalTime();

	TTimeIntervalSeconds timeOffset = User::UTCOffset();

	TTime localTime = time + timeOffset;

    object->AddTimePropertyL( *iCreationDatePropertyDef, localTime ); 

    object->AddTimePropertyL( *iLastModifiedDatePropertyDef, localTime );

    object->AddUint8PropertyL( *iOriginPropertyDef,

            aVideo.ValueTObjectL<TUint8>( KVcxMediaMyVideosOrigin ) );

    CMdEProperty* property;

    //  Type can not be modified normally, so set it here

    if ( aVideo.IsSupported( KMPXMediaGeneralMimeType ) )

        {

        if (KErrNotFound != object->Property( *iItemTypePropertyDef, property, 0 ))

            {

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

                    aVideo.ValueText( KMPXMediaGeneralMimeType ) );

            }

        else

            {

            object->AddTextPropertyL(

                *iItemTypePropertyDef,

                aVideo.ValueText( KMPXMediaGeneralMimeType ) );

            }

        }

    Media2ObjectL( aVideo, *object );

    TRAPD( err, aMdsId = iMdsSession->AddObjectL( *object ) );

    if ( err != KErrNone )

        {

        MPX_DEBUG2( "CVcxMyVideosMdsDb:: iMdsSession->AddObjectL leaved with error: %d", err );

        User::Leave( err );

        }

    if ( aMdsId == KNoId )

        {

        MPX_DEBUG1( "CVcxMyVideosMdsDb::AddVideoL could not add new video" );

        User::Leave( KErrGeneral );

        }

    else

        {

        MPX_DEBUG2( "CVcxMyVideosMdsDb::AddVideoL video created, mds id: %d", aMdsId );

        }        

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

    }

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

// CVcxMyVideosMdsDb::RemoveVideo

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

//

TInt CVcxMyVideosMdsDb::RemoveVideo( TUint32 aMdsId )

    {

    MPX_FUNC( "CVcxMyVideosMdsDb::RemoveVideoL" );

    if ( !iMdsSession )

        {

        MPX_DEBUG2("CVcxMyVideosMdsDb:: no mds session, returning %d", iMdsError);

        return iMdsError;

        }

    TInt retValue( KErrNone );

    TItemId id( 0 ); //init to avoid warning

    MPX_DEBUG2( "CVcxMyVideosMdsDb:: removing object %d", aMdsId );

    TRAPD( err,  id = iMdsSession->RemoveObjectL( aMdsId ) );

    if ( err == KErrNone )

        {

        if ( id == KNoId )

            {

            MPX_DEBUG1( "CVcxMyVideosMdsDb:: video not found" );

            retValue = KErrNotFound;

            }

        else

            {

            MPX_DEBUG1( "CVcxMyVideosMdsDb:: remove successful" );

            }

        }

    else

        {

        MPX_DEBUG2( "CVcxMyVideosMdsDb:: iMdsSession->RemoveObjectL left: %d", err );

        retValue = err;        

        }

    return retValue;

    }

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

// CVcxMyVideosMdsDb::UpdateVideoL

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

//

void CVcxMyVideosMdsDb::UpdateVideoL( CMPXMedia& aVideo )

    {

    MPX_FUNC( "CVcxMyVideosMdsDb::UpdateVideoL" );

    if ( !iMdsSession )

        {

        MPX_DEBUG2("CVcxMyVideosMdsDb:: no mds session(%d), leaving", iMdsError);

        User::Leave( iMdsError );

        }

    TMPXItemId mpxId = aVideo.ValueTObjectL<TMPXItemId>( KMPXMediaGeneralId );

    MPX_DEBUG2("CVcxMyVideosMdsDb::UpdateVideoL updating object %d ", mpxId.iId1);

    CMdEObject* object =

            iMdsSession->OpenObjectL( mpxId.iId1, *iVideoObjectDef );

        {

        // No object with this ID was found!

        MPX_DEBUG1("CVcxMyVideosMdsDb::UpdateVideoL no object found");

        User::Leave( KErrNotFound );

        }

    else

        {

        MPX_DEBUG1("CVcxMyVideosMdsDb::UpdateVideoL object found");

        if ( object->OpenForModifications() )

            {

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

            Media2ObjectL( aVideo, *object );

            iMdsSession->CommitObjectL(*object);

            CleanupStack::PopAndDestroy(object);

            }

        else

            {

            // Object is already locked!

            MPX_DEBUG1("CVcxMyVideosMdsDb::UpdateVideoL object was locked!");

            delete object;

            User::Leave( KErrInUse );

            }

        }

    }

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

// CVcxMyVideosMdsDb::CreateVideoListL

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

//

void CVcxMyVideosMdsDb::CreateVideoListL( TVcxMyVideosSortingOrder aSortingOrder,

        TBool aAscending, TBool aFullDetails, CMPXMedia*& aVideoList )

    {

    MPX_FUNC( "CVcxMyVideosMdsDb::CreateVideoListL" );

    cmd->iCmdType      = CVcxMyVideosMdsDb::EGetVideoList;

    cmd->iSortingOrder = aSortingOrder;

    cmd->iAscending    = aAscending;

    cmd->iFullDetails  = aFullDetails;

    cmd->iVideoList    = &aVideoList;

    iCmdQueue->ExecuteCmdL( cmd ); //ownership moves

    }

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

// CVcxMyVideosMdsDb::DoCreateVideoListL

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

//

void CVcxMyVideosMdsDb::DoCreateVideoListL( TVcxMyVideosSortingOrder aSortingOrder,

        TBool aAscending, TBool aFullDetails, CMPXMedia*& aVideoList )

    {

    MPX_FUNC( "CVcxMyVideosMdsDb::DoCreateVideoListL" );

    if ( !iMdsSession )

        {

        MPX_DEBUG2("CVcxMyVideosMdsDb:: no mds session(%d), leaving", iMdsError);

        User::Leave( iMdsError );

        }

    if ( iVideoListFetchingIsOngoing )

        {

        MPX_DEBUG1("CVcxMyVideosMdsDb:: video list fetching already going on, returning current list");

        aVideoList = iVideoList;

        }

    if ( !aVideoList )

        {

        aVideoList = TVcxMyVideosCollectionUtil::CreateEmptyMediaListL();

        }

    CMPXMediaArray* mediaArray = aVideoList->Value<CMPXMediaArray>( KMPXMediaArrayContents );

    delete iVideoQuery;

    iVideoQuery = NULL;

    iVideoQuery = iMdsSession->NewObjectQueryL(

            *iNamespaceDef,

            *iVideoObjectDef,

            this);

    iVideoQuery->SetResultMode( EQueryResultModeItem );

    TMdESortOrder direction;

    if ( aAscending )

        {

        direction = ESortAscending;

        }

    else

        {

        direction = ESortDescending;

        }

    switch ( aSortingOrder )

        {

        case EVcxMyVideosSortingId:

            {

            MPX_DEBUG1("CVcxMyVideosMdsDb:: EVcxMyVideosSortingId"); 

            iVideoQuery->AppendOrderRuleL(

                TMdEOrderRule( EOrderRuleTypeItemID, direction ) );

            }

            break;

        case EVcxMyVideosSortingCreationDate:

            {

            MPX_DEBUG1("CVcxMyVideosMdsDb:: EVcxMyVideosSortingCreationDate"); 

            iVideoQuery->AppendOrderRuleL(

                TMdEOrderRule( *iCreationDatePropertyDef/*EOrderRuleTypeCreationTime*/, direction ) );

            }

            break;

        case EVcxMyVideosSortingModified:

            {

            MPX_DEBUG1("CVcxMyVideosMdsDb:: EVcxMyVideosSortingModified"); 

            iVideoQuery->AppendOrderRuleL(

                TMdEOrderRule( *iLastModifiedDatePropertyDef/*EOrderRuleTypeLastModifiedDate*/, direction ) );

            }

            break;

        case EVcxMyVideosSortingName:

            {

            MPX_DEBUG1("CVcxMyVideosMdsDb:: EVcxMyVideosSortingName"); 

            TMdEOrderRule orderRule( *iTitlePropertyDef, direction );

            orderRule.SetCaseSensitive( EFalse /* insensitive */);

            iVideoQuery->AppendOrderRuleL( orderRule );

            }

            break;

        case EVcxMyVideosSortingSize:

            {

            MPX_DEBUG1("CVcxMyVideosMdsDb:: EVcxMyVideosSortingSize"); 

            iVideoQuery->AppendOrderRuleL(

                TMdEOrderRule( *iSizePropertyDef, direction ) );

            }