// Copyright (c) 2006-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:

//

#include <bautils.h>

#include <mtp/cmtpobjectmetadata.h>

#include <mtp/cmtptypearray.h>

#include <mtp/cmtptypeobjectproplist.h>

#include <mtp/cmtptypestring.h>

#include <mtp/mmtpdataproviderframework.h>

#include <mtp/mmtpobjectmgr.h>

#include <mtp/mtpdatatypeconstants.h>

#include <mtp/tmtptyperequest.h>

#include "cmtpgetobjectproplist.h"

#include "cmtpfsexclusionmgr.h"

#include "mtpdpconst.h"

#include "mtpdppanic.h"

/**

Verification data for the GetNumObjects request

*/

const TMTPRequestElementInfo KMTPGetObjectPropListPolicy[] = 

    {

        {TMTPTypeRequest::ERequestParameter1, EMTPElementTypeObjectHandle, EMTPElementAttrNone, 2, KMTPHandleAll, KMTPHandleNone}

    };

EXPORT_C MMTPRequestProcessor* CMTPGetObjectPropList::NewL(MMTPDataProviderFramework& aFramework, MMTPConnection& aConnection)

    {

    CMTPGetObjectPropList* self = new (ELeave) CMTPGetObjectPropList(aFramework, aConnection);

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    return self;

    }

EXPORT_C CMTPGetObjectPropList::~CMTPGetObjectPropList()

    {

    delete iHandles;

    delete iPropertyList;

    iDpSingletons.Close();

    delete iObjMeta;

    }

void CMTPGetObjectPropList::ServiceL()

    {

    TUint32 propCode(Request().Uint32(TMTPTypeRequest::ERequestParameter3));

	TUint32 groupCode(Request().Uint32(TMTPTypeRequest::ERequestParameter4));

	if( ( propCode != 0 ) || ( (groupCode !=0) && (groupCode <= KMTPDpPropertyGroupNumber) ) )

		{

		GetObjectHandlesL();

		TInt numObjects(iHandles->NumElements());

		for (TInt i(0); (i < numObjects); i++)

			{

			TUint32 handle(iHandles->ElementUint(i));

			iFramework.ObjectMgr().ObjectL(handle, *iObjMeta);

			TFileName file(iObjMeta->DesC(CMTPObjectMetaData::ESuid));

			User::LeaveIfError(iFramework.Fs().Entry(iObjMeta->DesC(CMTPObjectMetaData::ESuid), iFileEntry));

			if (propCode == KMaxTUint)

				{

				ServiceAllPropertiesL(handle);

				}

			else if( propCode == 0)

				{		

				ServiceGroupPropertiesL(handle,groupCode);

				}

			else    

				{

				ServiceOneObjectPropertyL(handle, propCode);

				}

			}

		}

	//else

	//it means the groupcode is not supported, return EMTPRespCodeGroupNotSupported(0xA805) response.

	//but we use one empty ObjectPropList to replace the EMTPRespCodeGroupNotSupported(0xA805) response.

    SendDataL(*iPropertyList);    

    }

TMTPResponseCode CMTPGetObjectPropList::CheckRequestL()

    {

    TMTPResponseCode result = CMTPRequestProcessor::CheckRequestL();

    if (result == EMTPRespCodeOK)

        {

        result = CheckFormatL();

        }

    if (result == EMTPRespCodeOK)

        {        

        result = CheckPropCode();        

        }

    if (result == EMTPRespCodeOK)

        {

        result = CheckDepth();

        }

    return result;    

    }

CMTPGetObjectPropList::CMTPGetObjectPropList(MMTPDataProviderFramework& aFramework, MMTPConnection& aConnection) :

    CMTPRequestProcessor(aFramework, aConnection, (sizeof(KMTPGetObjectPropListPolicy) / sizeof(TMTPRequestElementInfo)), KMTPGetObjectPropListPolicy)

    {

    }

void CMTPGetObjectPropList::ConstructL()

    {

    iDpSingletons.OpenL(iFramework);

    iPropertyList = CMTPTypeObjectPropList::NewL();

	iObjMeta = CMTPObjectMetaData::NewL();

    }

TMTPResponseCode CMTPGetObjectPropList::CheckFormatL() const

    {

    TMTPResponseCode response = EMTPRespCodeOK; 

    const TUint32 KFormat = Request().Uint32(TMTPTypeRequest::ERequestParameter2);

    if ( (KFormat!=KMTPFormatsAll)&&(KFormat!=EMTPFormatCodeAssociation)&&(KFormat!=EMTPFormatCodeUndefined)&&(KFormat!=EMTPFormatCodeScript) && (iDpSingletons.ExclusionMgrL().IsFormatValid(TMTPFormatCode(KFormat))) )

        {

        response = EMTPRespCodeSpecificationByFormatUnsupported;

        }

    return response;    

    }

TMTPResponseCode CMTPGetObjectPropList::CheckPropCode() const

    {

    TMTPResponseCode response = EMTPRespCodeOK; 

	TUint32 formatCode = Request().Uint32(TMTPTypeRequest::ERequestParameter2);

    TUint32 propCode = Request().Uint32(TMTPTypeRequest::ERequestParameter3);

    if (propCode == 0)

        {

        //GroupCode should be supported.

        return response;

        }

    else if (propCode != KMaxTUint)

        {

        if(propCode != EMTPObjectPropCodeAssociationType && propCode != EMTPObjectPropCodeAssociationDesc)

			{

			const TInt count = sizeof(KMTPDpSupportedProperties) / sizeof(TUint16);

			TInt i(0);

			for(i = 0; i < count; i++)

				{

				if(KMTPDpSupportedProperties[i] == propCode)

					{

					break;

					}

				}

			if(i == count)

				{

				response = EMTPRespCodeInvalidObjectPropCode;

				}		

			}

		else

			{

			if(formatCode != EMTPFormatCodeAssociation && formatCode != KMTPFormatsAll)

			response = EMTPRespCodeInvalidObjectPropCode;

			}	

        }

    return response;

    }

/**

Ensures that the requested object depth is one we support.

@return EMTPRespCodeOK, or EMTPRespCodeSpecificationByDepthUnsupported if the depth is unsupported

*/

TMTPResponseCode CMTPGetObjectPropList::CheckDepth() const

    {

    TMTPResponseCode response = EMTPRespCodeSpecificationByDepthUnsupported;

    // We either support no depth at all, or 1 depth or (0xFFFFFFFF) with objecthandle as 0x00000000 

    TUint32 handle(Request().Uint32(TMTPTypeRequest::ERequestParameter1));

    TUint32 depth = Request().Uint32(TMTPTypeRequest::ERequestParameter5);

    if ( (depth == 0) || (depth == 1 ) ||

    	 (depth == KMaxTUint && handle == KMTPHandleNone ) ) 

    	{

        response = EMTPRespCodeOK; 

        }

    return response;    

    }

void CMTPGetObjectPropList::GetObjectHandlesL()

    {

    TUint32 handle(Request().Uint32(TMTPTypeRequest::ERequestParameter1));

    TUint32 formatCode(Request().Uint32(TMTPTypeRequest::ERequestParameter2));

    TUint32 depth(Request().Uint32(TMTPTypeRequest::ERequestParameter5));

    delete iHandles;

    iHandles = NULL;

    if (handle == KMTPHandleAll)

        {

        GetObjectHandlesL(KMTPStorageAll, formatCode, KMTPHandleNone);

        }

    else if (handle == KMTPHandleNone)

        {

        GetRootObjectHandlesL(formatCode, depth);

        }

    else 

    	{

    	CMTPObjectMetaData* meta(iRequestChecker->GetObjectInfo(handle));

		__ASSERT_DEBUG(meta, Panic(EMTPDpObjectNull));

    	if ((meta->Uint(CMTPObjectMetaData::EFormatCode) == EMTPFormatCodeAssociation) &&

              (meta->Uint(CMTPObjectMetaData::EFormatSubCode) == EMTPAssociationTypeGenericFolder))

    		{

    		GetFolderObjectHandlesL(formatCode, depth, handle);

    		}

    		else	

       		{

       		GetSpecificObjectHandlesL(handle, formatCode, depth);

       		}	

    	}

    }

void CMTPGetObjectPropList::GetObjectHandlesL(TUint32 aStorageId, TUint32 aFormatCode, TUint32 aParentHandle)

    {

	RMTPObjectMgrQueryContext   context;

	RArray<TUint>               handles;

	TMTPObjectMgrQueryParams    params(aStorageId, aFormatCode, aParentHandle, iFramework.DataProviderId());

	CleanupClosePushL(context);

	CleanupClosePushL(handles);

	delete iHandles;

	iHandles = CMTPTypeArray::NewL(EMTPTypeAUINT32);

	do

	    {

    	iFramework.ObjectMgr().GetObjectHandlesL(params, context, handles);

    	iHandles->AppendL(handles);

	    }

	while (!context.QueryComplete());

	CleanupStack::PopAndDestroy(&handles);

	CleanupStack::PopAndDestroy(&context);

    }

void CMTPGetObjectPropList::GetFolderObjectHandlesL(TUint32 aFormatCode, TUint32 aDepth,TUint32 aParentHandle)

    {

    // Folder object request has been filtered by Proxy DP with setting depth as zero

    __ASSERT_DEBUG( ( 0 == aDepth ), User::Invariant() );

    GetSpecificObjectHandlesL( aParentHandle, aFormatCode, aDepth );

    }

void CMTPGetObjectPropList::GetRootObjectHandlesL(TUint32 aFormatCode, TUint32 aDepth)

    {

	if (aDepth == KMaxTUint)

        {

        GetObjectHandlesL(KMTPStorageAll, aFormatCode, KMTPHandleNone);

        }

    else if (aDepth == 0)

        {

        iHandles = CMTPTypeArray::NewL(EMTPTypeAUINT32);    //empty array        

        }

    else

        {

        GetObjectHandlesL(KMTPStorageAll, aFormatCode, KMTPHandleNoParent);

        }    

	}

void CMTPGetObjectPropList::GetSpecificObjectHandlesL(TUint32 aHandle, TUint32 /*aFormatCode*/, TUint32 /*aDepth*/)

    {

    iHandles = CMTPTypeArray::NewL(EMTPTypeAUINT32);

    iHandles->AppendUintL(aHandle);

    }

void CMTPGetObjectPropList::ServiceAllPropertiesL(TUint32 aHandle)

    {

    if (iFramework.ObjectMgr().ObjectOwnerId(aHandle) == iFramework.DataProviderId())

        {

        for (TUint i(0); (i < (sizeof(KMTPDpSupportedProperties) / sizeof(TUint16))); i++)

            {

            ServiceOneObjectPropertyL(aHandle, KMTPDpSupportedProperties[i]);

            }

        }

	if (iObjMeta->Uint( CMTPObjectMetaData::EFormatCode ) == EMTPFormatCodeAssociation)

		{

        CMTPTypeObjectPropListElement& propElem1 = iPropertyList->ReservePropElemL(aHandle, static_cast<TUint16>(EMTPObjectPropCodeAssociationType));

        propElem1.SetUint16L(CMTPTypeObjectPropListElement::EValue, EMTPAssociationTypeGenericFolder);

        iPropertyList->CommitPropElemL(propElem1);

        CMTPTypeObjectPropListElement& propElem2 = iPropertyList->ReservePropElemL(aHandle, static_cast<TUint16>(EMTPObjectPropCodeAssociationDesc));

        propElem2.SetUint32L(CMTPTypeObjectPropListElement::EValue, 0);

        iPropertyList->CommitPropElemL(propElem2); 

		}

    }

void CMTPGetObjectPropList::ServiceGroupPropertiesL(TUint32 aHandle,TUint16 aGroupCode)

	{

	if (iFramework.ObjectMgr().ObjectOwnerId(aHandle) == iFramework.DataProviderId())

        {

        for (TUint propCodeIndex(0); propCodeIndex < KMTPDpPropertyNumber; propCodeIndex++)

            {

            TUint16 propCode = KMTPDpPropertyGroups[aGroupCode][propCodeIndex];  

            if(propCode != 0)

            	{

            	ServiceOneObjectPropertyL(aHandle, propCode);

            	}

            }

        }

	}

void CMTPGetObjectPropList::ServiceOneObjectPropertyL(TUint32 aHandle, TUint32 aPropCode)

    {

    if (iFramework.ObjectMgr().ObjectOwnerId(aHandle) == iFramework.DataProviderId())

        {

        switch(aPropCode)

            {

        case EMTPObjectPropCodeNonConsumable:

            {

            TUint8 value = iObjMeta->Uint(CMTPObjectMetaData::ENonConsumable);

            CMTPTypeObjectPropListElement& propElem = iPropertyList->ReservePropElemL(aHandle, aPropCode);

            propElem.SetUint8L(CMTPTypeObjectPropListElement::EValue, value);

            iPropertyList->CommitPropElemL(propElem);

            }        

            break;

        case EMTPObjectPropCodeObjectFormat:

        	{

            TUint16 value = iObjMeta->Uint(CMTPObjectMetaData::EFormatCode);

            CMTPTypeObjectPropListElement& propElem = iPropertyList->ReservePropElemL(aHandle, aPropCode);

            propElem.SetUint16L(CMTPTypeObjectPropListElement::EValue, value);

            iPropertyList->CommitPropElemL(propElem);

        	}

        	break;

        case EMTPObjectPropCodeProtectionStatus:

            {

            TUint16 value = iFileEntry.IsReadOnly();

            CMTPTypeObjectPropListElement& propElem = iPropertyList->ReservePropElemL(aHandle, aPropCode);

            propElem.SetUint16L(CMTPTypeObjectPropListElement::EValue, value);

            iPropertyList->CommitPropElemL(propElem);

            }

            break;

        case EMTPObjectPropCodeStorageID:

        	{

            TUint32 value = iObjMeta->Uint(CMTPObjectMetaData::EStorageId);

            CMTPTypeObjectPropListElement& propElem = iPropertyList->ReservePropElemL(aHandle, aPropCode);

            propElem.SetUint32L(CMTPTypeObjectPropListElement::EValue, value);

            iPropertyList->CommitPropElemL(propElem);

        	}

        	break;

        case EMTPObjectPropCodeParentObject:

            {

            TUint32 parentHandle = iObjMeta->Uint(CMTPObjectMetaData::EParentHandle);

            // refer to Appendix B.2.11 of MTP Spec 1.0 

            if (parentHandle == KMTPHandleNoParent)

                {

                parentHandle = 0;

                }

            CMTPTypeObjectPropListElement& propElem = iPropertyList->ReservePropElemL(aHandle, aPropCode);

            propElem.SetUint32L(CMTPTypeObjectPropListElement::EValue, parentHandle);

            iPropertyList->CommitPropElemL(propElem);

            }

            break;

        case EMTPObjectPropCodeObjectSize:

            {

            TUint64 value = iFileEntry.FileSize();

            CMTPTypeObjectPropListElement& propElem = iPropertyList->ReservePropElemL(aHandle, aPropCode);

            propElem.SetUint64L(CMTPTypeObjectPropListElement::EValue, value);

            iPropertyList->CommitPropElemL(propElem);

            }

            break;

        case EMTPObjectPropCodePersistentUniqueObjectIdentifier:

            {

            TMTPTypeUint128 value = iFramework.ObjectMgr().PuidL(aHandle);

            CMTPTypeObjectPropListElement& propElem = iPropertyList->ReservePropElemL(aHandle, aPropCode);

            propElem.SetUint128L(CMTPTypeObjectPropListElement::EValue, value.UpperValue(), value.LowerValue());

            iPropertyList->CommitPropElemL(propElem); 

            }        

            break;

        case EMTPObjectPropCodeDateModified:

        	{

            TBuf<64> dateString;    

            iDpSingletons.MTPUtility().TTime2MTPTimeStr(iFileEntry.iModified, dateString);        	

            CMTPTypeString* value = CMTPTypeString::NewLC(dateString);

            CMTPTypeObjectPropListElement& propElem = iPropertyList->ReservePropElemL(aHandle, aPropCode);

            propElem.SetStringL(CMTPTypeObjectPropListElement::EValue, value->StringChars());

            iPropertyList->CommitPropElemL(propElem);

            CleanupStack::PopAndDestroy(value);

        	}

        	break;

        case EMTPObjectPropCodeObjectFileName:

        	{

            CMTPTypeString* value = CMTPTypeString::NewLC(iFileEntry.iName);

            CMTPTypeObjectPropListElement& propElem = iPropertyList->ReservePropElemL(aHandle, aPropCode);

            propElem.SetStringL(CMTPTypeObjectPropListElement::EValue, value->StringChars());

            iPropertyList->CommitPropElemL(propElem);

            CleanupStack::PopAndDestroy(value);

        	}

        	break;

        case EMTPObjectPropCodeName:

            {

            CMTPTypeString* value = CMTPTypeString::NewLC(iObjMeta->DesC(CMTPObjectMetaData::EName));

            CMTPTypeObjectPropListElement& propElem = iPropertyList->ReservePropElemL(aHandle, aPropCode);

            propElem.SetStringL(CMTPTypeObjectPropListElement::EValue, value->StringChars());

            iPropertyList->CommitPropElemL(propElem);

            CleanupStack::PopAndDestroy(value);

            }

            break;

        case EMTPObjectPropCodeAssociationType:

        	{        		

        	if (iObjMeta->Uint( CMTPObjectMetaData::EFormatCode ) == EMTPFormatCodeAssociation)

				{

				TUint16 value = iObjMeta->Uint(CMTPObjectMetaData::EFormatSubCode);

                CMTPTypeObjectPropListElement& propElem = iPropertyList->ReservePropElemL(aHandle, aPropCode);

                propElem.SetUint16L(CMTPTypeObjectPropListElement::EValue, value);

                iPropertyList->CommitPropElemL(propElem);

				}

        	}

        	break;

         case EMTPObjectPropCodeAssociationDesc:

        	{

			if (iObjMeta->Uint( CMTPObjectMetaData::EFormatCode ) == EMTPFormatCodeAssociation)

				{

                CMTPTypeObjectPropListElement& propElem = iPropertyList->ReservePropElemL(aHandle, aPropCode);

                propElem.SetUint32L(CMTPTypeObjectPropListElement::EValue, 0x0000);

                iPropertyList->CommitPropElemL(propElem);  

				}

        	}

        	break;    

        default:

            Panic(EMTPDpUnsupportedProperty);

            break;

            }       

        } 

    }