// 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 <mtp/mmtpobjectmgr.h>

#include <mtp/cmtpobjectmetadata.h>

#include <mtp/tmtptypeuint32.h>

#include <mtp/cmtptypestring.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 "cmtpimagedpobjectpropertymgr.h"

#include "mtpimagedppanic.h"

#include "mtpimagedputilits.h"

#include "mtpimagedpconst.h"

#include "mtpdebug.h"

// Class constants.

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

/**

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);

    self->ConstructL();

    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;

            }         

        }

    iObjectHandle = KMTPHandleNone;   

    }

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];

    }

TUint CMTPImageDpObjectPropertyMgr::CMTPImagePropertiesCache::ObjectHandle() const

    {

    return iObjectHandle;

    }

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;

    }

void CMTPImageDpObjectPropertyMgr::CMTPImagePropertiesCache::SetObjectHandle(TUint aObjectHandle)

    {

    iObjectHandle = aObjectHandle;

    }

    {

    CleanupStack::PushL(self);

    self->ConstructL(aFramework);

    CleanupStack::Pop(self);

    return self;

    }

    iFs(aFramework.Fs()),

    iObjectMgr(aFramework.ObjectMgr())

    {

    __FLOG_OPEN(KMTPSubsystem, KComponent);

    }

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

    {

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

    iPropertiesCache = CMTPImagePropertiesCache::NewL();    

    iMetaDataSession = CMdESession::NewL(*this);

    __FLOG(_L8("CMTPImageDpObjectPropertyMgr::ConstructL - Open Mde session"));

    iActiveSchedulerWait = new (ELeave) CActiveSchedulerWait();

    iActiveSchedulerWait->Start(); // wait for mdesession to start

    if (iMdeSessionError != KErrNone) 

        {

        User::Leave(iMdeSessionError);

        }

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

    }

CMTPImageDpObjectPropertyMgr::~CMTPImageDpObjectPropertyMgr()

    {

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

    delete iPropertiesCache;

    delete iObject;

    delete iMetaDataSession;

    delete iActiveSchedulerWait; 

    __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

         */

        if (iPropertiesCache->ObjectHandle() == iObjectInfo->Uint(CMTPObjectMetaData::EHandle))

            {

            iCacheHit = ETrue;

            }

        else

            iCacheHit = EFalse;

            delete iObject;

            }        

        }    

    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 (iPropertiesCache->ObjectHandle() != objectHandle)

                {

                iPropertiesCache->ResetL();

                }

            iPropertiesCache->SetObjectHandle(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:

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

        break;

    case EMTPObjectPropCodeHeight:

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

        break; 

    case EMTPObjectPropCodeImageBitDepth:

        iPropertiesCache->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);

        }

        break;

    case EMTPObjectPropCodeDateCreated://MdS property

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

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

        if (entry.IsReadOnly())

            {

            aValue = EMTPProtectionReadOnly;

            }

        else

            {

            aValue = EMTPProtectionNoProtection;

            }

        break;        

    default:

        break;

        }

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

    }

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

    {

    __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 EMTPObjectPropCodeRepresentativeSampleHeight:

        aValue = KThumbHeigth;

    case EMTPObjectPropCodeRepresentativeSampleWidth:

        aValue = KThumbWidht;

    default:

        break;  

        }

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

    }

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

    {

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

    __ASSERT_DEBUG(iObjectInfo, Panic(EMTPImageDpObjectNull));

    if (aProperty == EMTPObjectPropCodeObjectSize) 

        {