// 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:

//

/**

 @file

 @internalTechnology

*/

#include <bautils.h>

#include <f32file.h>

#include <bautils.h>

#include <s32file.h>

#include <e32const.h>

#include <e32cmn.h>

#include <imageconversion.h> 

#include <mdeconstants.h>

#include <thumbnailmanager.h>

#include <mtp/mmtpobjectmgr.h>

#include <mtp/cmtpobjectmetadata.h>

#include <mtp/tmtptypeuint32.h>

#include <mtp/cmtptypestring.h>

#include <mtp/cmtptypeopaquedata.h>

#include <mtp/mmtpdataproviderframework.h>

#include <mtp/cmtptypearray.h>

#include <mtp/mmtpdataproviderframework.h>

#include <mtp/mmtpobjectmgr.h>

#include <mtp/cmtptypestring.h>

#include <mtp/mtpprotocolconstants.h>

#include "cmtpimagedp.h"

#include "cmtpimagedpobjectpropertymgr.h"

#include "cmtpimagedpthumbnailcreator.h"

#include "mtpimagedppanic.h"

#include "mtpimagedputilits.h"

#include "mtpimagedpconst.h"

#include "mtpdebug.h"

// Class constants.

__FLOG_STMT(_LIT8(KComponent,"MTPImageDpPropertyMgr");)

// Indicate how many cache can be stored

const TUint KCacheThreshold = 16;

/**

The properties cache table content.

*/

const CMTPImageDpObjectPropertyMgr::CMTPImagePropertiesCache::TElementMetaData CMTPImageDpObjectPropertyMgr::CMTPImagePropertiesCache::KElements[CMTPImageDpObjectPropertyMgr::CMTPImagePropertiesCache::ENumProperties] = 

    {

        {0, CMTPImagePropertiesCache::EUint}, // EImagePixWidth

        {1, CMTPImagePropertiesCache::EUint}, // EImagePixHeight

        {2, CMTPImagePropertiesCache::EUint}, // EImageBitDepth

        {0, CMTPImagePropertiesCache::EDesC}, // EDateCreated

    };

CMTPImageDpObjectPropertyMgr::CMTPImagePropertiesCache* CMTPImageDpObjectPropertyMgr::CMTPImagePropertiesCache::NewL()

    {

    CMTPImagePropertiesCache* self = new(ELeave) CMTPImagePropertiesCache(KElements, ENumProperties);

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    return self;

    }

/**

Destructor.

*/

CMTPImageDpObjectPropertyMgr::CMTPImagePropertiesCache::~CMTPImagePropertiesCache()

    {

    iElementsDesC.ResetAndDestroy();

    iElementsUint.Reset();

    } 

/**

Constructor.

*/

CMTPImageDpObjectPropertyMgr::CMTPImagePropertiesCache::CMTPImagePropertiesCache(const TElementMetaData* aElements, TUint aCount) :

    iElements(sizeof(TElementMetaData), const_cast<TElementMetaData*>(aElements), aCount)

    {

    }

void CMTPImageDpObjectPropertyMgr::CMTPImagePropertiesCache::ConstructL()

    {

    const TUint KCount(iElements.Count());

    for (TUint i(0); (i < KCount); i++)

        {

        const TElementMetaData& KElement(iElements[i]);

        switch (KElement.iType)

            {

        case EDesC:

            __ASSERT_DEBUG((iElementsDesC.Count() == KElement.iOffset), Panic(EMTPImageDpBadLayout));

            iElementsDesC.AppendL(KNullDesC().AllocLC());

            CleanupStack::Pop();

            break;

        case EUint:

            __ASSERT_DEBUG((iElementsUint.Count() == KElement.iOffset), Panic(EMTPImageDpBadLayout));

            iElementsUint.AppendL(0);

            break;

        default:

            //nothing to do

            __DEBUG_ONLY(User::Invariant());

            break;

            }         

        }

    }

void CMTPImageDpObjectPropertyMgr::CMTPImagePropertiesCache::ResetL()

    {

    SetUint(EImagePixWidth, 0);

    SetUint(EImagePixHeight, 0);

    SetUint(EImageBitDepth, 0);

    SetDesCL(EDateCreated, KNullDesC);

    }

const TDesC& CMTPImageDpObjectPropertyMgr::CMTPImagePropertiesCache::DesC(TUint aId) const

    {

    __ASSERT_DEBUG((iElements[aId].iType == EDesC), Panic(EMTPImageDpTypeMismatch));

    return *iElementsDesC[iElements[aId].iOffset];

    }  

TUint CMTPImageDpObjectPropertyMgr::CMTPImagePropertiesCache::Uint(TUint aId) const

    {

    __ASSERT_DEBUG((iElements[aId].iType == EUint), Panic(EMTPImageDpTypeMismatch));

    return iElementsUint[iElements[aId].iOffset];

    }

void CMTPImageDpObjectPropertyMgr::CMTPImagePropertiesCache::SetDesCL(TUint aId, const TDesC& aValue)

    {

    const TElementMetaData& KElement(iElements[aId]);

    __ASSERT_DEBUG((KElement.iType == EDesC), Panic(EMTPImageDpTypeMismatch));

    delete iElementsDesC[KElement.iOffset];

    iElementsDesC[KElement.iOffset] = NULL;

    iElementsDesC[KElement.iOffset] = aValue.AllocL();  

    }

void CMTPImageDpObjectPropertyMgr::CMTPImagePropertiesCache::SetUint(TUint aId, TUint aValue)

    {

    __ASSERT_DEBUG((iElements[aId].iType == EUint), Panic(EMTPImageDpTypeMismatch));

    iElementsUint[iElements[aId].iOffset] = aValue;

    }

CMTPImageDpObjectPropertyMgr* CMTPImageDpObjectPropertyMgr::NewL(MMTPDataProviderFramework& aFramework, CMTPImageDataProvider& aDataProvider)

    {

    CMTPImageDpObjectPropertyMgr* self = new (ELeave) CMTPImageDpObjectPropertyMgr(aFramework, aDataProvider);

    CleanupStack::PushL(self);

    self->ConstructL(aFramework);

    CleanupStack::Pop(self);

    return self;

    }

CMTPImageDpObjectPropertyMgr::CMTPImageDpObjectPropertyMgr(MMTPDataProviderFramework& aFramework, CMTPImageDataProvider& aDataProvider) :

    iFramework(aFramework),

    iDataProvider(aDataProvider),

    iFs(aFramework.Fs()),

    iObjectMgr(aFramework.ObjectMgr())    

    {

    __FLOG_OPEN(KMTPSubsystem, KComponent);

    }

void CMTPImageDpObjectPropertyMgr::ConstructL(MMTPDataProviderFramework& /*aFramework*/)

    {

    __FLOG(_L8("CMTPImageDpObjectPropertyMgr::ConstructL - Entry"));

    iMetaDataSession = CMdESession::NewL(*this);

    __FLOG(_L8("CMTPImageDpObjectPropertyMgr::ConstructL - Exit"));

    }

CMTPImageDpObjectPropertyMgr::~CMTPImageDpObjectPropertyMgr()

    {

    __FLOG(_L8("CMTPImageDpObjectPropertyMgr::~CMTPImageDpObjectPropertyMgr - Entry"));

    delete iObject;

    delete iMetaDataSession;

    delete iThumbnailCache.iThumbnailData;

    //Clear propreties cache map

    ClearAllCache();

    iPropretiesCacheMap.Close();

    __FLOG(_L8("CMTPImageDpObjectPropertyMgr::~CMTPImageDpObjectPropertyMgr - Exit"));

    __FLOG_CLOSE;

    }

void CMTPImageDpObjectPropertyMgr::SetCurrentObjectL(CMTPObjectMetaData& aObjectInfo, TBool aRequireForModify, TBool aSaveToCache)

    {

    __FLOG(_L8(">> CMTPImageDpObjectPropertyMgr::SetCurrentObjectL"));

    iObjectInfo = &aObjectInfo;

    /**

     * Image DP property manager will not directly modify properties which stored in the MdS

     */

    if(!aRequireForModify)

        {

        /**

         * determine whether the cache hit is occured

         */

        iCacheHit = FindPropertiesCache(iObjectInfo->Uint(CMTPObjectMetaData::EHandle));

        if (!iCacheHit)

            {

            delete iObject;

            iObject = NULL; 

            }          

        }    

    else

        {        

        /**

         * Set image object properties, because the cached properties are all readonly,

         * so only sendobjectproplist/sendobjectinfo operations can use cache mechanism, 

         * other operations will not use cache, such as setobjectvalue/setobjectproplist

         */

        if (aSaveToCache)

            {            

            TUint objectHandle = iObjectInfo->Uint(CMTPObjectMetaData::EHandle);

            if (FindPropertiesCache(objectHandle))

                {

                __FLOG_VA((_L16("SetCurrentObjectL - find object in cache:%u"), objectHandle));

                iCurrentPropertiesCache->ResetL();

                }

            else

                {

                if (iPropretiesCacheMap.Count() > KCacheThreshold)

                    {

                    // Find the first object handle from cache map and then destory it

                    RHashMap<TUint, CMTPImagePropertiesCache*>::TIter iter(iPropretiesCacheMap);

                    DestroyPropertiesCahce(*iter.NextKey());

                    __FLOG_VA((_L16("SetCurrentObjectL - destory object:%u"), objectHandle));

                    }                

                iCurrentPropertiesCache = CMTPImagePropertiesCache::NewL();

                iPropretiesCacheMap.Insert(objectHandle, iCurrentPropertiesCache);

                __FLOG_VA((_L16("SetCurrentObjectL - create new object:%u"), objectHandle));

                }

            }

        }

    __FLOG(_L8("<< CMTPImageDpObjectPropertyMgr::SetCurrentObjectL"));

    }

void CMTPImageDpObjectPropertyMgr::SetPropertyL(TMTPObjectPropertyCode aProperty, const TUint8 aValue)

    {

    __FLOG(_L8(">> CMTPImageDpObjectPropertyMgr::SetPropertyL"));

    __ASSERT_DEBUG(iObjectInfo, Panic(EMTPImageDpObjectNull));

    if (aProperty == EMTPObjectPropCodeNonConsumable) 

        {

        iObjectInfo->SetUint(CMTPObjectMetaData::ENonConsumable, aValue);

        }

    else

        {

        User::Leave(EMTPRespCodeObjectPropNotSupported);

        }

    __FLOG(_L8("<< CMTPImageDpObjectPropertyMgr::SetPropertyL"));

    }

void CMTPImageDpObjectPropertyMgr::SetPropertyL(TMTPObjectPropertyCode aProperty, const TUint16 aValue)

    {

    __FLOG(_L8(">> CMTPImageDpObjectPropertyMgr::SetPropertyL"));

    __ASSERT_DEBUG(iObjectInfo, Panic(EMTPImageDpObjectNull));

    switch(aProperty)

        {

    case EMTPObjectPropCodeObjectFormat:

        iObjectInfo->SetUint(CMTPObjectMetaData::EFormatCode, aValue);

        break;        

    case EMTPObjectPropCodeProtectionStatus://this property does not supported by image dp

        //nothing to do

        break;

    default:

        //nothing to do

        break;

        }

    __FLOG(_L8("<< CMTPImageDpObjectPropertyMgr::SetPropertyL"));

    }

void CMTPImageDpObjectPropertyMgr::SetPropertyL(TMTPObjectPropertyCode aProperty, const TUint32 aValue)

    {

    __FLOG(_L8(">> CMTPImageDpObjectPropertyMgr::SetPropertyL"));

    __ASSERT_DEBUG(iObjectInfo, Panic(EMTPImageDpObjectNull));

    switch(aProperty)

        {

    case EMTPObjectPropCodeStorageID:

        iObjectInfo->SetUint(CMTPObjectMetaData::EStorageId, aValue);

        break;

    case EMTPObjectPropCodeParentObject:

        iObjectInfo->SetUint(CMTPObjectMetaData::EParentHandle, aValue);

        break;

    case EMTPObjectPropCodeWidth:

        if (iCurrentPropertiesCache != NULL)

            {

            iCurrentPropertiesCache->SetUint(CMTPImageDpObjectPropertyMgr::CMTPImagePropertiesCache::EImagePixWidth, aValue);

            }

        break;

    case EMTPObjectPropCodeHeight:

        if (iCurrentPropertiesCache != NULL)

            {        

            iCurrentPropertiesCache->SetUint(CMTPImageDpObjectPropertyMgr::CMTPImagePropertiesCache::EImagePixHeight, aValue);

            }

        break; 

    case EMTPObjectPropCodeImageBitDepth:

        if (iCurrentPropertiesCache != NULL)

            {        

            iCurrentPropertiesCache->SetUint(CMTPImageDpObjectPropertyMgr::CMTPImagePropertiesCache::EImageBitDepth, aValue);

            }

        break;          

    default:

        //nothing to do

        break;

        }

    __FLOG(_L8("<< CMTPImageDpObjectPropertyMgr::SetPropertyL"));

    }

void CMTPImageDpObjectPropertyMgr::SetPropertyL(TMTPObjectPropertyCode aProperty, const TDesC& aValue)

    {

    __FLOG(_L8(">> CMTPImageDpObjectPropertyMgr::SetPropertyL"));

    __ASSERT_DEBUG(iObjectInfo, Panic(EMTPImageDpObjectNull));

    switch(aProperty)

        {

    case EMTPObjectPropCodeObjectFileName:

        {

        TParsePtrC oldUri = TParsePtrC(iObjectInfo->DesC(CMTPObjectMetaData::ESuid));

        //calculate new file name length

        TInt len = oldUri.DriveAndPath().Length() + aValue.Length();

        //allocate memory for the new uri

        RBuf  newUri;

        newUri.CleanupClosePushL();

        newUri.CreateL(len);

        //create the new uri

        newUri.Append(oldUri.DriveAndPath());

        newUri.Append(aValue);

        newUri.Trim();

        //ask fs to rename file, leave if err returned from fs

        User::LeaveIfError(iFs.Rename(oldUri.FullName(), newUri));

        iObjectInfo->SetDesCL(CMTPObjectMetaData::ESuid, newUri);

        CleanupStack::PopAndDestroy(&newUri);        

        }

        break;

    case EMTPObjectPropCodeName:

        iObjectInfo->SetDesCL(CMTPObjectMetaData::EName, aValue);

        break;

    case EMTPObjectPropCodeDateModified:

        {

        TTime modifiedTime;

        ConvertMTPTimeStr2TTimeL(aValue, modifiedTime);

        iFs.SetModified(iObjectInfo->DesC(CMTPObjectMetaData::ESuid), modifiedTime);            

        }

        break;

    case EMTPObjectPropCodeDateCreated://MdS property

        if (iCurrentPropertiesCache != NULL)

            {

            iCurrentPropertiesCache->SetDesCL(CMTPImageDpObjectPropertyMgr::CMTPImagePropertiesCache::EDateCreated, aValue);

            }

        break;

    default:

        //nothing to do

        break;

        }

    __FLOG(_L8("<< CMTPImageDpObjectPropertyMgr::SetPropertyL"));

    }

void CMTPImageDpObjectPropertyMgr::GetPropertyL(TMTPObjectPropertyCode aProperty, TUint8 &aValue)

    {

    __FLOG(_L8(">> CMTPImageDpObjectPropertyMgr::GetPropertyL"));

    __ASSERT_DEBUG(iObjectInfo, Panic(EMTPImageDpObjectNull));

    if (aProperty == EMTPObjectPropCodeNonConsumable) 

        {

        aValue = iObjectInfo->Uint(CMTPObjectMetaData::ENonConsumable);       

        }

    else

        {

        User::Leave(EMTPRespCodeObjectPropNotSupported);

        }     

    __FLOG(_L8("<< CMTPImageDpObjectPropertyMgr::GetPropertyL"));

    }

void CMTPImageDpObjectPropertyMgr::GetPropertyL(TMTPObjectPropertyCode aProperty, TUint16 &aValue)

    {

    __FLOG(_L8(">> CMTPImageDpObjectPropertyMgr::GetPropertyL"));

    __ASSERT_DEBUG(iObjectInfo, Panic(EMTPImageDpObjectNull));

    TEntry entry;

    switch(aProperty)

        {

    case EMTPObjectPropCodeObjectFormat:

        aValue = iObjectInfo->Uint(CMTPObjectMetaData::EFormatCode);

        break;

    case EMTPObjectPropCodeRepresentativeSampleFormat:

        aValue = KThumbFormatCode;

       break;        

    case EMTPObjectPropCodeProtectionStatus:

        {

        TInt err = iFs.Entry(iObjectInfo->DesC(CMTPObjectMetaData::ESuid), entry);        

        if ( err == KErrNone && entry.IsReadOnly())

            {

            aValue = EMTPProtectionReadOnly;

            }

        else

            {

            aValue = EMTPProtectionNoProtection;

            }        

        }    

    default:

        aValue = 0;//initialization

        //ingore the failure if we can't get properties form MdS

        TRAP_IGNORE(GetPropertyFromMdsL(aProperty, &aValue));

        break;

        }

    __FLOG(_L8("<< CMTPImageDpObjectPropertyMgr::GetPropertyL"));

    }

void CMTPImageDpObjectPropertyMgr::GetPropertyL(TMTPObjectPropertyCode aProperty, TUint32 &aValue, TBool alwaysCreate/* = ETrue*/)

    {

    __FLOG(_L8(">> CMTPImageDpObjectPropertyMgr::GetPropertyL"));

    __ASSERT_DEBUG(iObjectInfo, Panic(EMTPImageDpObjectNull));

    switch(aProperty)

        {

    case EMTPObjectPropCodeStorageID:

        aValue = iObjectInfo->Uint(CMTPObjectMetaData::EStorageId);

        break;

    case EMTPObjectPropCodeParentObject:

        aValue = iObjectInfo->Uint(CMTPObjectMetaData::EParentHandle);

        break;        

    case EMTPObjectPropCodeRepresentativeSampleSize:

        {

        __FLOG_VA((_L16("Query smaple size from MdS - URI:%S"), &iObjectInfo->DesC(CMTPObjectMetaData::ESuid)));

        ClearThumnailCache();                                

        /**

         * try to query thumbnail from TNM, and then store thumbnail to cache

         */

        TEntry fileEntry;

        TInt err = iFs.Entry(iObjectInfo->DesC(CMTPObjectMetaData::ESuid), fileEntry);

        CMTPImageDpThumbnailCreator* tnc = iDataProvider.ThumbnailManager();

        if (err == KErrNone && tnc != NULL)

            {

            if(fileEntry.FileSize() > KFileSizeMax || !alwaysCreate)

                {

                tnc->GetThumbMgr()->SetFlagsL(CThumbnailManager::EDoNotCreate);

                }

            else

                {

                tnc->GetThumbMgr()->SetFlagsL(CThumbnailManager::EDefaultFlags);

                }

            /**

             * trap the leave to avoid return general error when PC get object property list

             */

            TRAP(err, tnc->GetThumbnailL(iObjectInfo->DesC(CMTPObjectMetaData::ESuid), iThumbnailCache.iThumbnailData, err));

            if (err == KErrNone)

                {

                iThumbnailCache.iObjectHandle = iObjectInfo->Uint(CMTPObjectMetaData::EHandle);                        

                if (iThumbnailCache.iThumbnailData != NULL)

                    {

                    aValue = static_cast<TUint32>(iThumbnailCache.iThumbnailData->Size());

                    }

                if (aValue <= 0)

                    {