/*

* Copyright (c) 2006 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:  The class CMPXDbCommonUtil which contains utilities functions

*

*/

// INCLUDE FILES

#include <bautils.h>

#include <caf/data.h>

#include <caf/virtualpathptr.h>

#include <hash.h>

#include <apgcli.h>

#include <apmstd.h>

#include <sqldb.h>

#include <mpxmediageneraldefs.h>

#include <mpxmediamusicdefs.h>

#include <mpxmediaaudiodefs.h>

#include <mpxmediadrmdefs.h>

#include <mpxmediacollectiondetaildefs.h>

#include <mpxmedia.h>

#include <mpxmediaarray.h>

#include <mpxlog.h>

#include "mpxdbcommonstd.h"

#include "mpxdbcommondef.h"

#include "mpxdbcommonutil.h"

// CONSTANTS

_LIT(KPathStart, ":\\");

// ============================ FILE EXTENSION TO MIME MAP ==============================

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

// Statically allocated Mime Map

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

//

_LIT( KExtensionAac,    "aac" );

_LIT( KExtensionAif,    "aif"); 

_LIT( KExtensionAifc,   "aifc"); 

_LIT( KExtensionAiff,   "aiff");

_LIT( KExtensionAmr,    "amr" );

_LIT( KExtensionAu,     "au" );

_LIT( KExtensionAwb,    "awb" );

_LIT( KExtensionMid,    "mid" );

_LIT( KExtensionMidi,   "midi" );

_LIT( KExtensionMka,    "mka" );

_LIT( KExtensionMp3,    "mp3" );

_LIT( KExtensionOgg,    "ogg");

_LIT( KExtensionRa,     "ra"); 

_LIT( KExtensionRam,    "ram"); 

_LIT( KExtensionRmi,    "rmi"); 

_LIT( KExtensionSnd,    "snd" );

_LIT( KExtensionSpMid,  "spmid" );

_LIT( KExtensionWav,    "wav" );

_LIT( KExtensionWma,    "wma" );

_LIT8( KMimeTypeAac,      "audio/aac" );

_LIT8( KMimeTypeAiff,     "audio/x-aiff");

_LIT8( KMimeTypeAmr,      "audio/amr" );

_LIT8( KMimeTypeAu,       "audio/au" );

_LIT8( KMimeTypeAwb,      "audio/amr-wb" );

_LIT8( KMimeTypeBasic,    "audio/basic");

_LIT8( KMimeTypeMatroska, "audio/x-matroska");

_LIT8( KMimeTypeMid,      "audio/mid");

_LIT8( KMimeTypeMidi,     "audio/midi" );

_LIT8( KMimeTypeMpeg,     "audio/mpeg" );

_LIT8( KMimeTypeOgg,      "audio/ogg");

_LIT8( KMimeTypeReal,     "audio/x-pn-realaudio");

_LIT8( KMimeTypeSpMidi,   "audio/sp-midi" );

_LIT8( KMimeTypeWav,      "audio/wav" ); 

_LIT8( KMimeTypeWma,      "audio/x-ms-wma");

struct TMimeMapItem {

	const TDesC  * iExt;

	const TDesC8 * iType;

};

// We need to explicitly cast here as LitC::operator& requires writable DLL data (even though it is just a cast)

#define MIME_MAP_ITEM(ext,type) { &REINTERPRET_CAST(const TDesC&, ext), &REINTERPRET_CAST(const TDesC8&, type) }

// THIS ARRAY MUST BE SORTED BY EXTENSION

static const TMimeMapItem KMimeMap [] = {

    MIME_MAP_ITEM( KExtensionAac,   KMimeTypeAac),

    MIME_MAP_ITEM( KExtensionAif,   KMimeTypeAiff ),

    MIME_MAP_ITEM( KExtensionAifc,  KMimeTypeAiff ),

    MIME_MAP_ITEM( KExtensionAiff,  KMimeTypeAiff ),

    MIME_MAP_ITEM( KExtensionAmr,   KMimeTypeAmr ),

    MIME_MAP_ITEM( KExtensionAu,    KMimeTypeAu ), // KMimeTypeAudioBasic?  "audio/x-au"?

    MIME_MAP_ITEM( KExtensionAwb,   KMimeTypeAwb ),

    MIME_MAP_ITEM( KExtensionMid,   KMimeTypeMidi ),

    MIME_MAP_ITEM( KExtensionMidi,  KMimeTypeMidi ),

    MIME_MAP_ITEM( KExtensionMka,   KMimeTypeMatroska ),

    MIME_MAP_ITEM( KExtensionMp3,   KMimeTypeMpeg ),

    MIME_MAP_ITEM( KExtensionOgg,   KMimeTypeOgg ),

    MIME_MAP_ITEM( KExtensionRa,    KMimeTypeReal ),

    MIME_MAP_ITEM( KExtensionRam,   KMimeTypeReal ),

    MIME_MAP_ITEM( KExtensionRmi,   KMimeTypeMid ),

    MIME_MAP_ITEM( KExtensionSnd,   KMimeTypeBasic ),

    MIME_MAP_ITEM( KExtensionSpMid, KMimeTypeSpMidi ),

    MIME_MAP_ITEM( KExtensionWav,   KMimeTypeWav ), // "audio/x-wav"?

    MIME_MAP_ITEM( KExtensionWma,   KMimeTypeWma )

};

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

// Look for Mime Type from map by file extension

// Returns NULL if file extension is not known

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

//

static const TDesC8 * FindMimeTypeFromMap ( const TDesC& aFilename )

    {

    // extract extension

   	TPtrC extension;

    TInt pos = aFilename.LocateReverseF( '.' );

    if ( pos < 0  || ++pos >= aFilename.Length() )

        {

        return NULL;

        }

    extension.Set( aFilename.Mid( pos ) );

    // binary search from Mime Map

    TUint begin = 0;

    TUint end = sizeof KMimeMap / sizeof (TMimeMapItem);

    while (begin < end)

        {

        TUint at = (begin + end) / 2;

        const TMimeMapItem & item = KMimeMap[at];

        TInt r = item.iExt->CompareF(extension);

        if (r == 0)

            {

            return item.iType;

            }

        else if (r > 0)

            {

            end = at;

            }

        else

            {

            begin = at + 1;

            }

        }

    return NULL;

}

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

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

// Set HBufC data member.

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

//

EXPORT_C TInt MPXDbCommonUtil::SetHBuf(

    HBufC*& aBuf,

    const TDesC* aSource,

    TInt aMaxLen /*= -1*/)

    {

    TInt ret( KErrNone );

    delete aBuf;

    aBuf = NULL;

    if (aSource)

        {

        if (aMaxLen != -1 && aSource->Length() > aMaxLen)

            {

            aBuf = aSource->Left(aMaxLen).Alloc();

            ret = KErrOverflow;

            }

        else

            {

            aBuf = aSource->Alloc();

            }

        }

    else

        {

        aBuf = HBufC::New(0);

        }

    if (!aBuf)

        {

        ret = KErrNoMemory;

        }

    return ret;

    }

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

// Replace single quotes `'` with two single quotes `''` as text queries are

// delimited by single quotes

// also replace 0x00 and '\t' as they will cause crash in SQLite and UI respectively

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

//

EXPORT_C void MPXDbCommonUtil::FindAndReplaceSingleQuote(const TDesC& aSrc, TDes& aTrg)

    {

    TText ch;

    TInt srcLen(aSrc.Length());

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

        {

        ch = aSrc[i];

        if((ch == 0) || (ch == TText('\t')))

            {

            aTrg.Append(TText(' '));

            }

        else

            {

            aTrg.Append(ch);

            if (ch == TText('\''))

                {

                aTrg.Append(ch);

                }

            }

        }

    }

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

// Delete file from file system

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

//

EXPORT_C TInt MPXDbCommonUtil::DeleteFile(

    RFs& aFs,

    const TDesC& aFile)

    {

    TInt ret(KErrNone);

    if(BaflUtils::FileExists(aFs, aFile))

        {

         ret = aFs.Delete(aFile);

        if (ret == KErrAccessDenied)

            {

            aFs.SetAtt(aFile,KEntryAttNormal,KEntryAttReadOnly);

            ret = aFs.Delete(aFile);

            }

        }

    return ret;

    }

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

// Get the drive Id with a given volume unique Id

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

//

EXPORT_C TInt MPXDbCommonUtil::GetDriveIdMatchVolIdL(

    RFs& aFs,

    TUint aVolumeId)

    {

    TDriveList driveList;

    TBool found(EFalse);

    TInt driveNum(EDriveA);

    User::LeaveIfError(aFs.DriveList(driveList));

    for (; driveNum <= EDriveZ; ++driveNum)

        {

        if (driveList[driveNum])

            {

            TVolumeInfo volInfo;

            if ((aFs.Volume(volInfo, driveNum) == KErrNone) &&

                (volInfo.iUniqueID == aVolumeId))

                {

                found = ETrue;

                break;

                }

            }

        }

    if (!found)

        {

        driveNum = KErrNotFound;

        }

    return driveNum;

    }

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

// Get the volume Id with a given drive Id

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

//

EXPORT_C TUint MPXDbCommonUtil::GetVolIdMatchDriveIdL(

    RFs& aFs,

    TInt aDriveId)

    {

    TUint volId (0);

    TVolumeInfo volInfo;

    TInt err = aFs.Volume(volInfo, aDriveId);

    if (err == KErrNone)

        {

        volId = volInfo.iUniqueID;

        }

    else if (err == KErrNotReady)

        {

        volId = 0;

        }

    else

        {

        User::Leave(err);

        }

    return volId;

    }

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

// Generate a 32bits Unique Id with MD5

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

//

EXPORT_C TUint32 MPXDbCommonUtil::GenerateUniqueIdL(

    RFs& aFs,

    TMPXGeneralCategory aTableId,

    const TDesC& aName,

    TBool aCaseSensitive)

    {

    MPX_FUNC("MPXDbCommonUtil::GenerateUniqueIdL");

    TInt extractPos(0);

    if( aName.Find(KPathStart) == KMCPathStartWithColon )

        {

        // aName is a filename

        extractPos = KMCPathStartPos;     // c:\..., include first '\' of the path

        }

    TBuf<KMaxFileName+KMCIntegerLen> fileName;

    if( extractPos )

        {

        // append volume's unique Id to path to maintain uniqueness

        TDriveUnit driveUnit( aName );

        TUint volId = MPXDbCommonUtil::GetVolIdMatchDriveIdL(aFs, driveUnit);

        if( volId )

            {

            fileName.AppendNum( volId );

            }

        else

            {

            // If media/drive doesn't exist, using whole path

            extractPos = 0;

            }

        }

    // append the path part

    fileName.Append( aName.Mid( extractPos ) );

    if( !aCaseSensitive )

        {

        fileName.LowerCase();

        }

    TInt narrowFileLen(0);

    TPtrC8 narrowFileName;

    #if defined(_UNICODE)

        narrowFileLen = fileName.Length() * 2;

        narrowFileName.Set((TUint8*)fileName.Ptr(), narrowFileLen);

    #else

        narrowFileLen = fileName.Length();

        narrowFileName.Set(fileName.Ptr(), narrowFileLen);

    #endif

    CMD5* hasher = CMD5::NewL();

    CleanupStack::PushL( hasher );

    hasher->Reset();

    TBuf8<16> hash( hasher->Hash( narrowFileName ) );   //hashed to 128bits

    CleanupStack::PopAndDestroy( hasher );

    const TText8* ptr = hash.Ptr();

    TUint32 uniqueId(0);

    uniqueId = aTableId << 28;

    uniqueId |= (ptr[3]&0x0F)<<24 | (ptr[2]<<16) | (ptr[1]<<8) | ptr[0];

    return uniqueId;

    }

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

// Append an item into the media array

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

//

EXPORT_C void MPXDbCommonUtil::AppendMediaL(

    CMPXMediaArray& aArray,

    const TDesC& aTitle,

    TMPXGeneralType aType,

    TMPXGeneralCategory aCat,

    TMPXItemId aId,

    TInt aNonPermissibleActions,

    TUint aDbflag)

    {

    MPX_FUNC("MPXDbCommonUtil::AppendMediaL");

    CMPXMedia* entry = ConstructMediaLC(aTitle, aType, aCat, aId, aNonPermissibleActions, aDbflag);

    aArray.AppendL(*entry);

    CleanupStack::PopAndDestroy(entry);

    }

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

// Append an item into the media array

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

//

EXPORT_C void MPXDbCommonUtil::PrependMediaL(

    CMPXMediaArray& aArray,

    const TDesC& aTitle,

    TMPXGeneralType aType,

    TMPXGeneralCategory aCat,

    TMPXItemId aId /* = 0 */,

    TInt aNonPermissibleActions /* = 0 */,

    TUint aDbflag /* = 0 */,

    TInt aPos /* = 0 */)

    {

    MPX_FUNC("MPXDbCommonUtil::PrependMediaL");

    CMPXMedia* entry = ConstructMediaLC(aTitle, aType, aCat, aId, aNonPermissibleActions, aDbflag);

    User::LeaveIfError(aArray.Insert(*entry, aPos));

    CleanupStack::PopAndDestroy(entry);

    }

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

// Append an item into the media array

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

//

EXPORT_C void MPXDbCommonUtil::FillInSupportedUIDsL(

    const TArray<TMPXAttribute>& aAttrs,

    RArray<TInt>& aSupportedIds)

    {

    MPX_FUNC("MPXDbCommonUtil::FillInSupportedUIDs");

    TInt attrCount(aAttrs.Count());

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

        {

        if (aAttrs[i].ContentId() == KMPXMediaIdGeneral)

            {

            aSupportedIds.AppendL(KMPXMediaIdGeneral);

            }

        else if (aAttrs[i].ContentId() == KMPXMediaIdMusic)

            {

            aSupportedIds.AppendL(KMPXMediaIdMusic);

            }

        else if (aAttrs[i].ContentId() == KMPXMediaIdAudio)

            {

            aSupportedIds.AppendL(KMPXMediaIdAudio);

            }

        else if (aAttrs[i].ContentId() == KMPXMediaIdDrm)

            {

            aSupportedIds.AppendL(KMPXMediaIdDrm);

            }

        else if (aAttrs[i].ContentId() == KMPXMediaIdCollectionDetails)

            {

            aSupportedIds.AppendL(KMPXMediaIdCollectionDetails);

            }

        else

            {

            // ignore attribute

            }

        }

    }

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

// Fill in change event message with the given info

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

//

EXPORT_C void MPXDbCommonUtil::FillItemChangedMessageL(

    CMPXMessage& aMessage,

    TMPXItemId aId,

    TMPXChangeEventType aChangeType,

    TMPXGeneralCategory aCategory,

    TUint aUid,

    TMPXItemId aDeprecatedId)

    {

    MPX_FUNC("MPXDbCommonUtil::FillItemChangedMessageL");

    MPX_DEBUG5("MPXDbCommonUtil::FillItemChangedMessageL: type [%d], category [%d], id[0x%x], oldId[0x%x]",

               aChangeType, aCategory, aId.iId1, aDeprecatedId.iId1);

    aMessage.SetTObjectValueL<TMPXMessageId>(KMPXMessageGeneralId, KMPXMessageIdItemChanged);

    aMessage.SetTObjectValueL<TUid>(KMPXMessageCollectionId, TUid::Uid(aUid));

    aMessage.SetTObjectValueL<TMPXChangeEventType>(KMPXMessageChangeEventType, aChangeType);

    aMessage.SetTObjectValueL<TMPXGeneralCategory>(KMPXMessageMediaGeneralCategory, aCategory);

    aMessage.SetTObjectValueL<TMPXItemId>(KMPXMessageMediaGeneralId, aId);

    if ((aDeprecatedId != 0) && (aId != aDeprecatedId))

        {

        aMessage.SetTObjectValueL<TMPXItemId>(KMPXMessageMediaDeprecatedId, aDeprecatedId);

        }

    }

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

// Add an item changed message to the message array

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

//

EXPORT_C void MPXDbCommonUtil::AddItemChangedMessageL(

    CMPXMessageArray& aMessageArray,

    TMPXItemId aId,

    TMPXChangeEventType aChangeType,

    TMPXGeneralCategory aCategory,

    TUint aUid,

    TMPXItemId aDeprecatedId /* = 0 */)

    {

    MPX_FUNC("MPXDbCommonUtil::AddItemChangedMessageL");

    CMPXMessage* message = CMPXMedia::NewL();

    CleanupStack::PushL(message);

    FillItemChangedMessageL(*message, aId, aChangeType, aCategory, aUid, aDeprecatedId);

    if (FindItemChangedMessageL(aMessageArray, *message) == KErrNotFound)

        {

        aMessageArray.AppendL(*message); // ownership xfer

        }

    CleanupStack::PopAndDestroy(message);

    }

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

// Find the message in the array, if not KErrNotFound is returned; otherwise the

// index of the first matching message is returned

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

//