/*

* 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 <centralrepository.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

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

// CVcxMdsShutdownMonitor::NewL()

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

//

CVcxMdsShutdownMonitor* CVcxMdsShutdownMonitor::NewL( MVcxMdsShutdownMonitorObserver& aObserver,

                                                const TUid& aKeyCategory,

                                                const TInt aPropertyKey,

                                                TBool aDefineKey)

    {

    CVcxMdsShutdownMonitor* self = new( ELeave )CVcxMdsShutdownMonitor( aObserver, 

                                                                  aKeyCategory,

                                                                  aPropertyKey,

                                                                  aDefineKey);

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CVcxMdsShutdownMonitor::CVcxMdsShutdownMonitor()

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

//

CVcxMdsShutdownMonitor::CVcxMdsShutdownMonitor( MVcxMdsShutdownMonitorObserver& aObserver,

                                          const TUid& aKeyCategory,

                                          const TInt aPropertyKey,

                                          TBool aDefineKey)

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

      iKeyCategory( aKeyCategory ), iPropertyKey(aPropertyKey), iDefineKey( aDefineKey )

    {   

    CActiveScheduler::Add( this );

    }

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

// CVcxMdsShutdownMonitor::ConstructL()

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

//

void CVcxMdsShutdownMonitor::ConstructL()

    { 

    // define P&S property types

    if ( iDefineKey )

        {

        RProperty::Define( iKeyCategory, iPropertyKey,

                          RProperty::EInt, KAllowAllPolicy, KPowerMgmtPolicy );

        }

    // attach to the property

    TInt err = iProperty.Attach( iKeyCategory, iPropertyKey,EOwnerThread );

    User::LeaveIfError( err );

    // wait for the previously attached property to be updated

    iProperty.Subscribe( iStatus );

    SetActive();

    }

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

// CVcxMdsShutdownMonitor::~CVcxMdsShutdownMonitor()

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

//

CVcxMdsShutdownMonitor::~CVcxMdsShutdownMonitor()

    {

    Cancel();

    iProperty.Close();

    }

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

// CVcxMdsShutdownMonitor::RunL()

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

//

void CVcxMdsShutdownMonitor::RunL()

    {

    // resubscribe before processing new value to prevent missing updates

    iProperty.Subscribe( iStatus );

    SetActive();

    // retrieve the value

    TInt value = 0;

    TInt err = iProperty.Get( value );

    MPX_DEBUG2("CVcxMyVideosMdsDb::RunL(): iProperty.Get(value); returns %d", err);

    User::LeaveIfError( err );

    iObserver.ShutdownNotification( value );    

    }

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

// CVcxMdsShutdownMonitor::DoCancel()

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

//

void CVcxMdsShutdownMonitor::DoCancel()

    {

    iProperty.Cancel();

    }

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

// CVcxMyVideosMdsDb::CVcxMyVideosMdsDb

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

//

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

: iFs( aFs ), iMdsDbObserver(aObserver) 

    {

    }

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

// CVcxMyVideosMdsDb::ConstructL

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

//

void CVcxMyVideosMdsDb::ConstructL()

    {

    MPX_DEBUG1( "CVcxMyVideosMdsDb::ConstructL start" );

    iActiveSchedulerWait = new (ELeave) CActiveSchedulerWait;

    OpenMdsSessionL();

    iMdsShutdownMonitor = CVcxMdsShutdownMonitor::NewL(

            *this, KHarvesterPSShutdown, KMdSShutdown, EFalse );

    MPX_DEBUG1( "CVcxMyVideosMdsDb::ConstructL exit" );

    }

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

// CVcxMyVideosMdsDb::OpenMdsSessionL

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

//

void CVcxMyVideosMdsDb::OpenMdsSessionL()

    {

    MPX_DEBUG1( "CVcxMyVideosMdsDb::OpenMdsSessionL() start" );

    iMdsSessionError = KErrNone;

    delete iMdsSession;

    iMdsSession = NULL;

    iMdsSession = CMdESession::NewL( *this );

    if ( !iMdsSession )

        {

        User::Leave( KErrGeneral );

        }

    //  Wait until session opened

    iActiveSchedulerWait->Start();    

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

    if ( iMdsSessionError == KErrNone )

        {

        MPX_DEBUG1( "CVcxMyVideosMdsDb:: session opened ok, 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 );

        GetSchemaDefinitionsL();

        }

    else

        {

        MPX_DEBUG2( "CVcxMyVideosMdsDb:: session opening failed: %d", iMdsSessionError );

        iMdsSessionError = KErrGeneral; // this ensures that next time when mds is tried to use, it tries to open session again

        delete iMdsSession;

        iMdsSession = NULL;        

        }

    MPX_DEBUG1( "CVcxMyVideosMdsDb::OpenMdsSessionL() exit" );

    }

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

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

//

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_DEBUG1( "CVcxMyVideosMdsDb::~CVcxMyVideosMdsDb() start" );

    Cancel();

    delete iVideoQuery;

    delete iMdsSession;

    delete iActiveSchedulerWait;

    delete iRepository;

    delete iMdsShutdownMonitor;

    MPX_DEBUG1( "CVcxMyVideosMdsDb::~CVcxMyVideosMdsDb() exit" );

    }

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

// CVcxMyVideosMdsDb::Cancel

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

//

void CVcxMyVideosMdsDb::Cancel()

    {

    MPX_DEBUG1("CVcxMyVideosMdsDb::Cancel() start");

    if ( iVideoQuery )

        {

        iVideoQuery->Cancel();

        }

    iVideoListFetchingIsOngoing = EFalse;

    MPX_DEBUG1("CVcxMyVideosMdsDb::Cancel() exit");

    }

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

// CVcxMyVideosMdsDb::AddVideoL

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

//

void CVcxMyVideosMdsDb::AddVideoL(

        CMPXMedia& aVideo, 

        TUint32& aMdsId )

    {

    MPX_DEBUG1( "CVcxMyVideosMdsDb::AddVideoL() start" );

    CMdEObject* object = MdsSessionL().NewObjectLC(

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

    // Value from aVideo is taken in use in Media2ObjectL if aVideo contains creation date

    SetCreationAndModifiedDatesL( *object ); // use current time

    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 = MdsSessionL().AddObjectL( *object ) );

    if ( err != KErrNone )

        {

        MPX_DEBUG2( "CVcxMyVideosMdsDb:: MdsSessionL().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

    MPX_DEBUG1( "CVcxMyVideosMdsDb::AddVideoL() exit" );

    }

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

// CVcxMyVideosMdsDb::RemoveVideo

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

//

TInt CVcxMyVideosMdsDb::RemoveVideo( TUint32 aMdsId )

    {

    MPX_DEBUG1( "CVcxMyVideosMdsDb::RemoveVideoL() start" );

    TInt retValue( KErrNone );

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

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

    TRAPD( err,  id = MdsSessionL().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:: MdsSessionL().RemoveObjectL left: %d", err );

        retValue = err;        

        }

    MPX_DEBUG1( "CVcxMyVideosMdsDb::RemoveVideoL() exit" );        

    return retValue;

    }

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

// CVcxMyVideosMdsDb::UpdateVideoL

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

//

void CVcxMyVideosMdsDb::UpdateVideoL( CMPXMedia& aVideo )

    {

    MPX_DEBUG1( "CVcxMyVideosMdsDb::UpdateVideoL() start" );

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

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

    CMdEObject* object =

            MdsSessionL().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 );

            MdsSessionL().CommitObjectL(*object);

            CleanupStack::PopAndDestroy(object);

            }

        else

            {

            // Object is already locked!

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

            delete object;

            User::Leave( KErrInUse );

            }

        }

    MPX_DEBUG1( "CVcxMyVideosMdsDb::UpdateVideoL() exit" );

    }

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

// CVcxMyVideosMdsDb::CreateVideoListL

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

//

void CVcxMyVideosMdsDb::CreateVideoListL( TVcxMyVideosSortingOrder aSortingOrder,

        TBool aAscending, TBool aFullDetails, CMPXMedia*& aVideoList )

    {

    MPX_DEBUG1( "CVcxMyVideosMdsDb::CreateVideoListL() start" );

    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 = MdsSessionL().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(