/*

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

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of "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:  Meta data Video access

*

*/

#include <ContentListingFactory.h>

#include <MCLFContentListingEngine.h>

#include <driveinfo.h>

#include <pathinfo.h>

#include <bautils.h>

// from Symbian MTP

#include <mtp/tmtptypeuint16.h>

#include <mtp/tmtptypeuint32.h>

#include <mtp/tmtptypeuint64.h>

#include <mtp/tmtptypeuint128.h>

#include <mtp/cmtptypestring.h>

#include <mtp/cmtptypearray.h>

#include <mtp/cmtpobjectmetadata.h>

#include <mtp/mmtpdataproviderframework.h>

#include <mtp/mmtpreferencemgr.h>

#include <mtp/mtpprotocolconstants.h>

#include "cmmmtpdpmetadatavideoaccess.h"

#include "mmmtpdplogger.h"

#include "mmmtpdputility.h"

#include "tmmmtpdppanic.h"

#include "mmmtpvideodbdefs.h"

static const TInt KMtpMaxStringLength = 255;

static const TInt KMtpMaxDescriptionLength = 0x200;

const TInt KStorageRootMaxLength = 10;

#ifdef _DEBUG

static const TInt KMtpMaxStringDescLength = KMtpMaxStringLength - 1;

#endif

_LIT( KEmptyText, "" );

// Database interface

_LIT( KSelect, "SELECT " );

_LIT( KAllColumns, "*" );

_LIT( KFrom, " FROM " );

_LIT( KWhere, " WHERE " );

_LIT( KNot, " NOT " );

_LIT( KEquals, " = " );

_LIT( KTrue, "1" );

const TInt KMaxQueryLength = 512;

const TInt KMtpCompactInterval = 50;  // Compact every ....

CMmMtpDpMetadataVideoAccess* CMmMtpDpMetadataVideoAccess::NewL( RFs& aRfs )

    {

    CMmMtpDpMetadataVideoAccess* me = new(ELeave) CMmMtpDpMetadataVideoAccess( aRfs );

    CleanupStack::PushL(me);

    me->ConstructL();

    CleanupStack::Pop(me);

    return me;

    }

CMmMtpDpMetadataVideoAccess::CMmMtpDpMetadataVideoAccess( RFs& aRfs ) : iRfs(aRfs),

                                                    iDbState(ENoRecord),

                                                    iDbOpened(EFalse)

    {

    }

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

// CMmMtpDpMetadataMpxAccess::ConstructL

// Second-phase

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

//

void CMmMtpDpMetadataVideoAccess::ConstructL()

    {

    iQueryText = HBufC::NewL( KMaxQueryLength );

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

    TInt err = DriveInfo::GetDefaultDrive( DriveInfo::EDefaultPhoneMemory,

        iStoreNum );

    err = OpenDatabase();

    if ( KErrNone != err )

        {

        PRINT1( _L( "CMmMtpDpMetadataVideoAccess::ConstructL OpenDatabase err = %d" ), err );

        }

    }

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

// CMmMtpDpMetadataMpxAccess::OpenDatabase

// Open data base

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

//

TInt CMmMtpDpMetadataVideoAccess::OpenDatabase()

    {

    PRINT( _L( "MM MTP => CMmMtpDpMetadataVideoAccess::OpenDatabase" ) );

    iRfs.CreatePrivatePath( iStoreNum );

    TInt err = iRfs.SetSessionToPrivate( iStoreNum );

    if ( err == KErrNone )

        {

        TRAP( err, iFileStore = CPermanentFileStore::OpenL( iRfs, KMtpVideoDb, EFileRead | EFileWrite ) );

        if ( err == KErrNone )

            TRAP( err, iFileStore->SetTypeL( iFileStore->Layout() ) );

        if ( err == KErrNone )

            {

            TRAP( err, iDatabase.OpenL( iFileStore, iFileStore->Root() ) );

            PRINT1( _L( "MM MTP <> OpenDatabase RDbNamedDatabase::OpenL, err = %d" ), err );

            }

        if ( err != KErrNone )

            {

            iRfs.Delete( KMtpVideoDb );   // delete first before creating a new one

            TRAP( err, iFileStore = CPermanentFileStore::CreateL( iRfs, KMtpVideoDb, EFileRead | EFileWrite ) );

            PRINT1( _L( "MM MTP <> OpenDatabase RDbNamedDatabase::CreateL, err = %d" ), err );

            if ( err == KErrNone )

                {

                TRAP( err, iFileStore->SetTypeL( iFileStore->Layout() ) );

                TStreamId streamId = 0;

                if ( err == KErrNone )

                    TRAP( err, streamId = iDatabase.CreateL( iFileStore ) );

                if ( err == KErrNone )

                    TRAP( err, iFileStore->SetRootL( streamId ) );

                if ( err == KErrNone )

                    TRAP( err, CreateDatabaseTablesL() );

                if ( KErrNone != err )

                    {

                    iDatabase.Close();

                    iRfs.Delete( KMtpVideoDb );

                    }

                }

            }

        }

    TBuf<KStorageRootMaxLength> storeRoot;

    err = PathInfo::GetRootPath( storeRoot, iStoreNum );

    iRfs.SetSessionPath( storeRoot );

    if ( err == KErrNone )

        {

        iDbOpened = ETrue;

        }

    PRINT( _L( "MM MTP <= CMmMtpDpMetadataVideoAccess::OpenDatabase" ) );

    return err;

    }

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

// CMmMtpDpMetadataMpxAccess::OpenDatabaseL

// Open data base

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

//

void CMmMtpDpMetadataVideoAccess::OpenDatabaseL()

    {

    PRINT( _L( "MM MTP => CMmMtpDpMetadataVideoAccess::OpenDatabaseL" ) );

    if ( OpenDatabase() != KErrNone )

        User::Leave( KErrGeneral );

    PRINT( _L( "MM MTP <= CMmMtpDpMetadataVideoAccess::OpenDatabaseL" ) );

    }

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

// CMmMtpDpMetadataMpxAccess::~CMmMtpDpMetadataVideoAccess

// Destructor

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

//

CMmMtpDpMetadataVideoAccess::~CMmMtpDpMetadataVideoAccess()

    {

    delete iQueryText;

    delete iColSet;

    iRecordSet.Close();

    iDatabase.Close();

    iDbsSession.Close();

    delete iFileStore;

    }

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

// CMmMtpDpMetadataMpxAccess::CreateDatabaseTablesL

// Case where a new memory card is used and the player has not been opened

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

//

void CMmMtpDpMetadataVideoAccess::CreateDatabaseTablesL()

    {

    PRINT( _L( "MM MTP => CMmMtpDpMetadataVideoAccess::CreateDatabaseTablesL" ) );

    // Video table

    RBuf formatBuf;

    User::LeaveIfError( formatBuf.Create( 5 * KMaxQueryLength ) );

    CleanupClosePushL( formatBuf ); // + foramtBuf

    formatBuf.Append( KMtpVideoStartCreateTable );

    formatBuf.Append( KMtpVideoTable );

    formatBuf.Append( KMtpVideoOpenBracket );

    formatBuf.Append( KMtpVideoLocation );

    formatBuf.Append( KMtpVideoLocationType );

    formatBuf.Append( KMtpVideoCommaSign );

    formatBuf.Append( KMtpVideoName );

    formatBuf.Append( KMtpVideoNameType );

    formatBuf.Append( KMtpVideoCommaSign );

    formatBuf.Append( KMtpVideoArtist );

    formatBuf.Append( KMtpVideoArtistType );

    formatBuf.Append( KMtpVideoCommaSign );

    formatBuf.Append( KMtpVideoTrack );

    formatBuf.Append( KMtpVideoTrackType );

    formatBuf.Append( KMtpVideoCommaSign );

    formatBuf.Append( KMtpVideoGenre );

    formatBuf.Append( KMtpVideoGenreType );

    formatBuf.Append( KMtpVideoCommaSign );

    formatBuf.Append( KMtpVideoAlbumName );

    formatBuf.Append( KMtpVideoAlbumNameType );

    formatBuf.Append( KMtpVideoCommaSign );

    formatBuf.Append( KMtpVideoComposer );

    formatBuf.Append( KMtpVideoComposerType );

    formatBuf.Append( KMtpVideoCommaSign );

    formatBuf.Append( KMtpVideoOrigReleaseDate );

    formatBuf.Append( KMtpVideoOrigReleaseDateType );

    formatBuf.Append( KMtpVideoCommaSign );

    formatBuf.Append( KMtpVideoComment );

    formatBuf.Append( KMtpVideoCommentType );

    formatBuf.Append( KMtpVideoCommaSign );

    formatBuf.Append( KMtpVideoWidth );

    formatBuf.Append( KMtpVideoWidthType );

    formatBuf.Append( KMtpVideoCommaSign );

    formatBuf.Append( KMtpVideoHeight );

    formatBuf.Append( KMtpVideoHeightType );

    formatBuf.Append( KMtpVideoCommaSign );

    formatBuf.Append( KMtpVideoDuration );

    formatBuf.Append( KMtpVideoDurationType );

    formatBuf.Append( KMtpVideoCommaSign );

    formatBuf.Append( KMtpVideoSampleRate );

    formatBuf.Append( KMtpVideoSampleRateType );

    formatBuf.Append( KMtpVideoCommaSign );

    formatBuf.Append( KMtpVideoNumberOfChannels );

    formatBuf.Append( KMtpVideoNumberOfChannelsType );

    formatBuf.Append( KMtpVideoCommaSign );

    formatBuf.Append( KMtpVideoAudioCodec );

    formatBuf.Append( KMtpVideoAudioCodecType );

    formatBuf.Append( KMtpVideoCommaSign );

    formatBuf.Append( KMtpVideoAudioBitrate );

    formatBuf.Append( KMtpVideoAudioBitrateType );

    formatBuf.Append( KMtpVideoCommaSign );

    formatBuf.Append( KMtpVideoVideoCodec );

    formatBuf.Append( KMtpVideoVideoCodecType );

    formatBuf.Append( KMtpVideoCommaSign );

    formatBuf.Append( KMtpVideoVideoBitrate );

    formatBuf.Append( KMtpVideoVideoBitrateType );

    formatBuf.Append( KMtpVideoCommaSign );

    formatBuf.Append( KMtpVideoFramesPer1000Sec );

    formatBuf.Append( KMtpVideoFramesPer1000SecType );

    formatBuf.Append( KMtpVideoCommaSign );

    formatBuf.Append( KMtpVideoKeyFrameDistance );

    formatBuf.Append( KMtpVideoKeyFrameDistanceType );

    formatBuf.Append( KMtpVideoCommaSign );

    formatBuf.Append( KMtpVideoScanType );

    formatBuf.Append( KMtpVideoScanTypeType );

    formatBuf.Append( KMtpVideoCommaSign );

    formatBuf.Append( KMtpVideoEncodingProfile );

    formatBuf.Append( KMtpVideoEncodingProfileType );

    formatBuf.Append( KMtpVideoCommaSign );

    formatBuf.Append( KMtpVideoParentalRating );

    formatBuf.Append( KMtpVideoParentalRatingType );

    formatBuf.Append( KMtpVideoCommaSign );

    formatBuf.Append( KMtpVideoUseCount );

    formatBuf.Append( KMtpVideoUseCountType );

    formatBuf.Append( KMtpVideoCommaSign );

    formatBuf.Append( KMtpVideoDRM );

    formatBuf.Append( KMtpVideoDRMType );

    formatBuf.Append( KMtpVideoCommaSign );

    formatBuf.Append( KMtpVideoDeleted );

    formatBuf.Append( KMtpVideoDeletedType );

    formatBuf.Append( KMtpVideoCloseBracket );

    // Execute the SQL statement.

    User::LeaveIfError( iDatabase.Execute( formatBuf ) );

    PRINT( _L( "MM MTP <> Video Table Created" ) );

    CleanupStack::PopAndDestroy( &formatBuf ); // - foramtBuf

    PRINT( _L( "MM MTP <= CMmMtpDpMetadataVideoAccess::CreateDatabaseTablesL" ) );

    }

// For performance, better to regularly compact the MC database.

void CMmMtpDpMetadataVideoAccess::CompactDbIfNecessaryL()

    {

    iRecordCount++;

    if ( iRecordCount > KMtpCompactInterval )

        {

        iRecordCount = 0;

        PRINT( _L( "MM MTP <> Compacting database file..." ) );

        if ( IsDatabaseOpened() )

            User::LeaveIfError( iDatabase.Compact() );

        }

    }

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

// CMmMtpDpMetadataMpxAccess::CleanupDbIfNecessaryL

// Cleanup Database

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

//

void CMmMtpDpMetadataVideoAccess::CleanupDbIfNecessaryL()

    {

    PRINT( _L( "MM MTP => CMmMtpDpMetadataVideoAccess::CleanupDbIfNecessaryL" ) );

    ExecuteQueryL( KAllColumns, KMtpVideoTable, KMtpVideoDeleted, KTrue, EFalse, EFalse );

    PRINT1( _L( "MM MTP <> CleanupDbIfNecessaryL Database deleted count = %d" ), iRecordSet.CountL() );

    for ( iRecordSet.FirstL(); iRecordSet.AtRow(); iRecordSet.NextL() )

        {

        HBufC* data = ReadLongTextL( KMtpVideoLocation );

        CleanupStack::PushL( data );

        PRINT1( _L( "MM MTP <> CleanupDbIfNecessaryL removing %S from database" ), data );

        iRecordSet.DeleteL();

        CleanupStack::PopAndDestroy( data );

        }

    delete iColSet;

    iColSet = NULL;

    iRecordSet.Close();

    PRINT( _L( "MM MTP <= CMmMtpDpMetadataVideoAccess::CleanupDbIfNecessaryL" ) );

    }

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

// CMmMtpDpMetadataMpxAccess::IdentifyDeletedFilesL

// Identify deleted files

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

//

void CMmMtpDpMetadataVideoAccess::IdentifyDeletedFilesL()

    {

    PRINT( _L( "MM MTP => CMmMtpDpMetadataVideoAccess::IdentifyDeletedFilesL" ) );

    ExecuteQueryL( KAllColumns, KMtpVideoTable, KMtpVideoLocation, KNullDesC, ETrue );

    PRINT1( _L( "MM MTP <> CleanupDbIfNecessaryL Database total count = %d" ), iRecordSet.CountL() );

    for ( iRecordSet.FirstL(); iRecordSet.AtRow(); iRecordSet.NextL( ))

        {

        HBufC* data = ReadLongTextL( KMtpVideoLocation );

        CleanupStack::PushL( data );

        if ( !FileExists( *data ) )

            {

            iRecordSet.UpdateL();

            PRINT1( _L( "MM MTP <> IdentifyDeletedFilesL marking %S as deleted" ), data );

            TDbColNo num = iColSet->ColNo( KMtpVideoDeleted );

            iRecordSet.SetColL( num, 1 );

            iRecordSet.PutL();

            }

        CleanupStack::PopAndDestroy( data );

        }

    delete iColSet;

    iColSet = NULL;

    iRecordSet.Close();

    PRINT( _L( "MM MTP <= CMmMtpDpMetadataVideoAccess::IdentifyDeletedFilesL" ) );

    }

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

// CMmMtpDpMetadataMpxAccess::ReadLongTextL

// Read from Data base

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

//

HBufC* CMmMtpDpMetadataVideoAccess::ReadLongTextL( const TDesC& aColumn )

    {

    TDbColNo num = iColSet->ColNo( aColumn );

    // The row must have previously been read into the rowset

    // using RDbRowSet::GetL().

    iRecordSet.GetL();

    TInt len = iRecordSet.ColLength( num );

    HBufC* buf = HBufC::NewLC( len ); // + buf

    TPtr value( buf->Des() );

    if ( len > 0 )

        {

        RDbColReadStream strm;

        strm.OpenLC( iRecordSet, num );

        strm.ReadL( value, len );

        strm.Close();

        CleanupStack::PopAndDestroy( &strm );

        }

    else

        {

        value.SetLength( 0 );

        }

    CleanupStack::Pop( buf ); // - buf

    PRINT2( _L( "MM MTP <> ReadLongTextL Metadata value for %S is \"%S\"" ), &aColumn, buf );

    return buf;

    }

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

// CMmMtpDpMetadataMpxAccess::WriteLongTextL

// Utility to write to the database

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

//

void CMmMtpDpMetadataVideoAccess::WriteLongTextL( const TDesC& aColumn, const TDesC& aValue )

    {

    PRINT2( _L( "MM MTP <> WriteLongTextL Metadata value for %S is \"%S\"" ), &aColumn, &aValue );

    TDbColNo num = iColSet->ColNo( aColumn );

    RDbColWriteStream strm;

    strm.OpenLC( iRecordSet, num );

    strm.WriteL( aValue );

    strm.Close();

    CleanupStack::PopAndDestroy( &strm );

    }

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

// CMmMtpDpMetadataMpxAccess::ExecuteQueryL

// Executes a query on the database and sets the cursor at the start of the recordset

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

//

void CMmMtpDpMetadataVideoAccess::ExecuteQueryL( const TDesC& aSelectThese, const TDesC& aFromTable,

                                       const TDesC& aColumnToMatch, const TDesC& aMatchCriteria,

                                       const TBool aIfNot, const TBool aNeedQuotes )

    {

    PRINT( _L( "MM MTP => CMmMtpDpMetadataVideoAccess::ExecuteQueryL" ) );

    delete iColSet;

    iColSet = NULL;

    iRecordSet.Close();

    //__ASSERT_DEBUG(!iColSet, _MTP_PANIC(KMtpPrtPncCat, ENullPointer)); // Must have iColSet == NULL

    // Make sure any quotes in the aMatchCriteria are doubled...

    HBufC* matchText = HBufC::NewLC( 2 * aMatchCriteria.Length() );

    TPtr pMatchText( matchText->Des() );

    TInt srcLen = aMatchCriteria.Length();

    TPtrC ch;

    for ( TInt i = 0; i < srcLen; ++i )

        {

        ch.Set( &aMatchCriteria[i], 1 );

        pMatchText.Append( ch );

        if ( ch.CompareF( KMtpVideoSingleQuote ) == 0 )

            {

            pMatchText.Append( ch );

            }

        }

    TPtr query( iQueryText->Des() );

    query.Zero();

    query.Append( KSelect );

    query.Append( aSelectThese );

    query.Append( KFrom );

    query.Append( aFromTable );

    if ( aColumnToMatch.Length() != 0 )

        {

        query.Append( KWhere );

        if ( aIfNot )

            query.Append( KNot );

        query.Append( aColumnToMatch );

        query.Append( KEquals );

        if ( aNeedQuotes )

            query.Append( KMtpVideoSingleQuote );

        query.Append( *matchText );

        if ( aNeedQuotes )

            query.Append( KMtpVideoSingleQuote );

        }

    TDbQuery dbQuery( query );

    PRINT1( _L( "MM MTP <> ExecuteQueryL Query is \"%S\"" ), &query );

    // Execute the query

    User::LeaveIfError( iRecordSet.Prepare( iDatabase, dbQuery ) );

    User::LeaveIfError( iRecordSet.EvaluateAll() );

    iRecordSet.FirstL();

    iColSet = iRecordSet.ColSetL();

    CleanupStack::PopAndDestroy( matchText );