/*

* 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, ":\\");

// ============================ 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))

        {

        if ( aCategory == EMPXAlbum && aChangeType == EMPXItemModified )

            {

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

            }

        else

            {

            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

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

//

EXPORT_C TInt MPXDbCommonUtil::FindItemChangedMessageL(

    const CMPXMessageArray& aMessageArray,

    const CMPXMessage& aMessage)

    {

    MPX_FUNC("MPXDbCommonUtil::FindItemChangedMessageL");

    TInt index(KErrNotFound);

    TInt messageCount(aMessageArray.Count());

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

        {

        CMPXMessage* message = aMessageArray.AtL(i);

        if (message->IsSupported(KMPXMessageGeneralId) &&

            message->IsSupported(KMPXMessageCollectionId) &&

            message->IsSupported(KMPXMessageChangeEventType) &&

            message->IsSupported(KMPXMessageMediaGeneralCategory) &&

            message->IsSupported(KMPXMessageMediaGeneralId) &&

            aMessage.IsSupported(KMPXMessageGeneralId) &&

            aMessage.IsSupported(KMPXMessageCollectionId) &&

            aMessage.IsSupported(KMPXMessageChangeEventType) &&

            aMessage.IsSupported(KMPXMessageMediaGeneralCategory) &&

            aMessage.IsSupported(KMPXMessageMediaGeneralId))

            {

            if (message->ValueTObjectL<TMPXMessageId>(KMPXMessageGeneralId) == aMessage.ValueTObjectL<TMPXMessageId>(KMPXMessageGeneralId) &&

                message->ValueTObjectL<TUid>(KMPXMessageCollectionId) == aMessage.ValueTObjectL<TUid>(KMPXMessageCollectionId) &&

                message->ValueTObjectL<TMPXChangeEventType>(KMPXMessageChangeEventType) == aMessage.ValueTObjectL<TMPXChangeEventType>(KMPXMessageChangeEventType) &&

                message->ValueTObjectL<TMPXGeneralCategory>(KMPXMessageMediaGeneralCategory) == aMessage.ValueTObjectL<TMPXGeneralCategory>(KMPXMessageMediaGeneralCategory) &&

                message->ValueTObjectL<TMPXItemId>(KMPXMessageMediaGeneralId) == aMessage.ValueTObjectL<TMPXItemId>(KMPXMessageMediaGeneralId))

                {

                if (!message->IsSupported(KMPXMessageMediaDeprecatedId) &&

                    !aMessage.IsSupported(KMPXMessageMediaDeprecatedId))

                    {

                    index = i;

                    break;

                    }

                else if (message->IsSupported(KMPXMessageMediaDeprecatedId) &&

                         aMessage.IsSupported(KMPXMessageMediaDeprecatedId))

                    {

                    if (message->ValueTObjectL<TMPXItemId>(KMPXMessageMediaDeprecatedId) ==

                        aMessage.ValueTObjectL<TMPXItemId>(KMPXMessageMediaDeprecatedId))

                        {

                        index = i;

                        break;

                       }

                    }

                else

                    {

                    // else do nothing

                    }

                }

            }

        }

    return index;

    }

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

// Get the DRM protection type of the file

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

//

EXPORT_C TMCDrmType MPXDbCommonUtil::GetDRMTypeL(const TDesC& aFile)

    {

    MPX_FUNC("MPXDbCommonUtil::GetDRMTypeL");

    using namespace ContentAccess;

    TInt drmProtected(0);

    TVirtualPathPtr virtualPath(aFile, KDefaultContentObject);

    CData* content = CData::NewL(virtualPath, EPeek, EContentShareReadOnly);

    CleanupStack::PushL(content);

    User::LeaveIfError(content->GetAttribute(EIsProtected, drmProtected));

    CleanupStack::PopAndDestroy( content );

    return drmProtected? EMCDrmOmaDrm : EMCDrmNone;

    }

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

// MPXDbUtil::ProcessSingleQuotesLC

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

//

EXPORT_C HBufC* MPXDbCommonUtil::ProcessSingleQuotesLC(

    const TDesC& aString)

    {

    MPX_FUNC("MPXDbCommonUtil::ProcessSingleQuotesLC");

    // reserve space for all single quotes (double the size)

    HBufC* value = HBufC::NewLC(aString.Length() * 2);

    TPtr valuePtr(value->Des());

    MPXDbCommonUtil::FindAndReplaceSingleQuote(aString, valuePtr);

    return value;

    }

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

// MPXDbUtil::ProcessPatternCharsLC

// 1) a percentage needs to be escaped for sqlite followed by

//    another percentage sign for escaping % for descriptor formatting, i.e.

//    % --> %% (this percentage will be treated as a percentage instead of

//    pattern matching)

// 2) since back slash is used for escaping the pattern characters, user

//    specified back slash should be escapped as well, i.e. \ --> \\

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

//

EXPORT_C HBufC* MPXDbCommonUtil::ProcessPatternCharsLC(

    const TDesC& aString)

    {

    MPX_FUNC("MPXDbCommonUtil::ProcessPatternCharsLC");

    // reserve space for all percentage signs (triple the size because % should

    // be replaced by %%)

    TInt srcLen(aString.Length());

    HBufC* targetString = HBufC::NewLC(aString.Length() * 3);

    TPtr targetStringPtr(targetString->Des());

    TPtrC ch;

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

        {