/*

* 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"

_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( KVcxDownloadIdPropertyName, "DownloadID" );             //18

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

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

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

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

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

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

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

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

//

CVcxMyVideosMdsDb::CVcxMyVideosMdsDb( MVcxMyVideosMdsDbObserver* aObserver, RFs& aFs )

: iFs( aFs ), iMdsDbObserver(aObserver) 

    {

    }

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

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

//

void CVcxMyVideosMdsDb::ConstructL()

    {

    MPX_FUNC( "CVcxMyVideosMdsDb::ConstructL" );

    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 );    

    }

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

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

//

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::--------------------------------------------------------------'" );

    //iMdsDbObserver->HandleObjectPresentNotification();

    TObserverNotificationType type;

    if ( aPresent )

        {

        type = ENotifyAdd;

        }

    else

        {

        type = ENotifyRemove;

        }

    TRAP_IGNORE( DoHandleObjectNotificationL( type, aObjectIdArray ) );    

    }

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

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

//

CVcxMyVideosMdsDb* CVcxMyVideosMdsDb::NewL( MVcxMyVideosMdsDbObserver* aObserver, RFs& aFs )

    {

    CVcxMyVideosMdsDb* self =

            CVcxMyVideosMdsDb::NewLC( aObserver, aFs );

    CleanupStack::Pop( self );

    return self;

    }

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

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

//

CVcxMyVideosMdsDb* CVcxMyVideosMdsDb::NewLC(

        MVcxMyVideosMdsDbObserver* aObserver, RFs& aFs )

    {

    CVcxMyVideosMdsDb* self = new( ELeave ) CVcxMyVideosMdsDb( aObserver, aFs );

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

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

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

//

CVcxMyVideosMdsDb::~CVcxMyVideosMdsDb()

    {

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

    if ( iMDSSession )

        {

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

        }

    Cancel();

    delete iVideoQuery;

    delete iMDSSession;

    delete iActiveSchedulerWait;

    }

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

// CVcxMyVideosMdsDb::Cancel

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

//

void CVcxMyVideosMdsDb::Cancel()

    {

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

    if ( iVideoQuery )

        {

        iVideoQuery->Cancel();

        }

    iVideoListFetchingIsOngoing = EFalse;

    }

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

// 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->AddInt16PropertyL( *iTimeOffsetPropertyDef, timeOffset.Int() / 60 );

    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 );

    if ( object == NULL )

        {

        // 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" );

    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 ) );

            }

            break;

        }

    iVideoListFetchingIsOngoing = ETrue;

    iFullDetails = aFullDetails;

    iVideoQuery->FindL(KMdEQueryDefaultMaxCount, 500);

    aVideoList->SetTObjectValueL<TMPXGeneralType>( KMPXMediaGeneralType, EMPXGroup );            

    aVideoList->SetTObjectValueL( KMPXMediaArrayCount, mediaArray->Count() );

    iVideoList = aVideoList; // lets store the pointer, ownership stays at observer

    }

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

// From class MMdEQueryObserver.

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

//

void CVcxMyVideosMdsDb::HandleQueryNewResults(

        CMdEQuery& aQuery,

        TInt aFirstNewItemIndex,

        TInt aNewItemCount )

    {

    TRAPD( err, DoHandleQueryNewResultsL( aQuery, aFirstNewItemIndex, aNewItemCount ));

    if ( err != KErrNone )

        {

        MPX_DEBUG2("CVcxMyVideosMdsDb:: DoHandleQueryNewResultsL() left with error code: %d", err);

        }

    }

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

// Leaving version of HandleQueryNewResults.

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

//

void CVcxMyVideosMdsDb::DoHandleQueryNewResultsL(

        CMdEQuery& /*aQuery*/,

        TInt aFirstNewItemIndex,

#ifdef _DEBUG

        TInt aNewItemCount )

#else

        TInt /*aNewItemCount*/ )

#endif

    {

    MPX_FUNC("CVcxMyVideosMdsDb::HandleQueryNewResults()");

    if ( !iVideoList )

        {

        MPX_DEBUG1("CVcxMyVideosMdsDb:: iVideoList is NULL, should never happen");

        return;

        }

    MPX_DEBUG2("CVcxMyVideosMdsDb:: aFirstNewItemIndex = %d", aFirstNewItemIndex);

    MPX_DEBUG2("CVcxMyVideosMdsDb:: aNewItemCount      = %d", aNewItemCount);

    CMPXMediaArray* array = iVideoList->Value<CMPXMediaArray>( KMPXMediaArrayContents );

    CMPXMedia* media;    

    TInt count = iVideoQuery->Count();

    iVideoList->SetTObjectValueL<TInt>( KMPXMediaArrayCount, count );