/*

* 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:  Implement the operation: GetObjectPropList

*

*/

#include <bautils.h>

#include <e32std.h>

#include <mtp/mmtpdataproviderframework.h>

#include <mtp/mmtpobjectmgr.h>

#include <mtp/cmtptypeobjectproplist.h>

#include <mtp/cmtptypestring.h>

#include <mtp/cmtptypearray.h>

#include <mtp/cmtpobjectmetadata.h>

#include "tobjectdescription.h"

#include "cgetobjectproplist.h"

#include "tmmmtpdppanic.h"

#include "mmmtpdplogger.h"

#include "mmmtpdpconfig.h"

#include "mmmtpdputility.h"

#include "cmmmtpdpmetadataaccesswrapper.h"

static const TUint32 KMTPAll = 0xffffffff;

// Verification data for the getObjectPropList request

const TMTPRequestElementInfo KMTPGetObjectPropListPolicy[] =

    {

        {

        TMTPTypeRequest::ERequestParameter1,

        EMTPElementTypeObjectHandle,

        EMTPElementAttrNone,

        2,

        KMTPHandleAll,

        KMTPHandleNone

        }

    };

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

// CGetObjectPropList::~CGetObjectPropList

// Destructor

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

//

EXPORT_C CGetObjectPropList::~CGetObjectPropList()

    {

    Cancel();

    delete iObject;

    delete iPropertyList;

    delete iPropertyElement;

    iHandles.Close();

    iPropertyArray.Close();

#if defined(_DEBUG) || defined(MMMTPDP_PERFLOG)

    delete iPerfLog;

#endif

    }

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

// CGetObjectPropList::CGetObjectPropList

// Standard C++ Constructor

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

//

EXPORT_C CGetObjectPropList::CGetObjectPropList( MMTPDataProviderFramework& aFramework,

    MMTPConnection& aConnection,

    MMmMtpDpConfig& aDpConfig ) :

        CRequestProcessor( aFramework,

            aConnection,

            sizeof ( KMTPGetObjectPropListPolicy ) / sizeof( TMTPRequestElementInfo ),

            KMTPGetObjectPropListPolicy ),

        iHandles ( KMmMtpRArrayGranularity ),

        iDpConfig( aDpConfig ),

        iPropertyArray( KMmMtpRArrayGranularity )

    {

    PRINT( _L( "Operation: GetObjectPropList(0x9805)" ) );

    }

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

// CGetObjectPropList::ConstructL

// 2nd Phase Constructor

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

//

EXPORT_C void CGetObjectPropList::ConstructL()

    {

    CActiveScheduler::Add( this );

    iPropertyList = CMTPTypeObjectPropList::NewL();

    SetPSStatus();

#if defined(_DEBUG) || defined(MMMTPDP_PERFLOG)

    iPerfLog = CMmMtpDpPerfLog::NewL( _L( "MediaMtpDataProviderEnumerator" ) );

#endif

    }

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

// CGetObjectPropList::CheckRequestL

// Verify the reqeust and returns it

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

//

EXPORT_C TMTPResponseCode CGetObjectPropList::CheckRequestL()

    {

    PRINT( _L( "MM MTP => CGetObjectPropList::CheckRequestL" ) );

    TMTPResponseCode result = CRequestProcessor::CheckRequestL();

    if ( result == EMTPRespCodeOK )

        {

        result = CheckFormatL();

        }

    if ( result == EMTPRespCodeOK )

        {

        result = CheckDepth();

        }

    if ( result == EMTPRespCodeOK )

        {

        result = CheckPropCodeL();

        }

    PRINT1( _L("MM MTP <= CGetObjectPropList::CheckRequestL, response 0x%x"), result );

    return result;

    }

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

// CGetObjectPropList::ServiceL

// GetObjectPropList request handler

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

//

EXPORT_C void CGetObjectPropList::ServiceL()

    {

    GetObjectHandlesL();

    TInt numOfObjects = iHandles.Count();

    PRINT2( _L( "MM MTP <> CGetObjectPropList::ServiceL, numOfObjects = %d, iPropCode = 0x%x" ),

        numOfObjects,

        iPropCode );

    if ( numOfObjects > 0

        && ( iPropCode == KMTPAll || iPropCode == EMTPObjectPropCodeUndefined ) )

        {

        // iFirstUnprocessed = 0;

        TRequestStatus* status = &iStatus;

        User::RequestComplete( status, iStatus.Int() );

        SetActive();

        }

    else

        {

        TInt err = KErrNone;

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

            {

            TUint32 handle = iHandles[i];

            if ( iFramework.ObjectMgr().ObjectOwnerId( handle )

                == iFramework.DataProviderId() )

                {

                delete iObject;

                iObject = NULL;

                iObject = CMTPObjectMetaData::NewL();

                if ( iFramework.ObjectMgr().ObjectL( handle, *iObject ) ) // Populate the object meta data

                    {

                    err = ServiceOneObjectPropertyL( handle, iPropCode );

                    if ( err != KErrNone && err != KErrNotSupported )

                        break;

                    }

                }

            }

        PRINT1( _L( "MM MTP <> CGetObjectPropList::ServiceL, one property was queried, Send data to PC! err = %d" ), err );

        if ( err == KErrNone

            || ( err == KErrNotSupported && 0 < iPropertyList->NumberOfElements() ) )

            // Make sure the dataset which is returned to pc is valid

            SendDataL( *iPropertyList );

        else if ( err == KErrNotFound || err == KErrNotSupported )

            // The object entry is not in db

            // or the ONLY required metadata is not in db.

            // The second case is the same with GetObjectPropValue and device has nothing to return.

            SendResponseL( EMTPRespCodeAccessDenied );

        else

            SendResponseL( EMTPRespCodeGeneralError );

        }

    PRINT( _L( "MM MTP <= CGetObjectPropList::ServiceL" ) );

    }

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

// CGetObjectPropList::CheckFormatL

// Ensure the object format operation parameter is valid

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

//

TMTPResponseCode CGetObjectPropList::CheckFormatL() const

    {

    TMTPResponseCode response = EMTPRespCodeOK;

    PRINT( _L( "MM MTP => CGetObjectPropList::CheckFormatL" ) );

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

    iFormatCode = formatCode;

    PRINT1( _L( "MM MTP <> CGetObjectPropList::CheckFormatL formatCode = 0x%x" ), formatCode );

    if ( formatCode != 0 )

        {

        response = EMTPRespCodeInvalidObjectFormatCode;

        const RArray<TUint>* format = iDpConfig.GetSupportedFormat();

        TInt count = format->Count();

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

            {

            if ( formatCode == (*format)[i] )

                {

                response = EMTPRespCodeOK;

                break;

                }

            }

        }

    PRINT1( _L( "MM MTP <= CGetObjectPropList::CheckFormatL, response 0x%x" ), response );

    return response;

    }

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

// CGetObjectPropList::CheckPropCodeL

// Ensure the object prop code operation parameter is valid

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

//

TMTPResponseCode CGetObjectPropList::CheckPropCodeL() const

    {

    PRINT( _L( "MM MTP => CGetObjectPropList::CheckPropCode" ) );

    TMTPResponseCode response = EMTPRespCodeOK;

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

    iPropCode = Request().Uint32( TMTPTypeRequest::ERequestParameter3 );

    PRINT1( _L( "MM MTP <> CGetObjectPropList::CheckPropCode, iPropCode = 0x%x" ), iPropCode );

    iPropertyArray.Reset();

    if ( iPropCode == EMTPObjectPropCodeUndefined )

        {

        // Get group code

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

        PRINT1( _L( "MM MTP <> CGetObjectPropList::CheckPropCode, Group Code = 0x%x" ), groupCode );

        // check if groupCode is supported

        TInt count = sizeof ( KSupportedGroupCode ) / sizeof ( KSupportedGroupCode[0] );

        TInt i = 0;

        for ( ; i < count; i++ )

            {

                break;

            }

        if ( i == count )

            response = EMTPRespCodeSpecificationByGroupUnsupported;

        }

    else if ( iPropCode != KMTPAll )

        {

        PRINT1( _L( "MM MTP <> CGetObjectPropList::CheckPropCode, Property(0x%x) was queried." ), iPropCode );

        const RArray<TUint>* properties = NULL;

        if ( formatCode == KMTPFormatsAll )

            properties = iDpConfig.GetAllSupportedProperties();

        else

            properties = iDpConfig.GetSupportedPropertiesL( formatCode );

        const TInt count = properties->Count();

        TInt i = 0;

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

            {

            if ( (*properties)[i] == iPropCode )

                {

                iPropertyArray.Append( iPropCode );

                break;

                }

            }

        if ( iPropertyArray.Count() == 0 )

            {

            response = EMTPRespCodeInvalidObjectPropCode;

            }

        }

    else

        {

        PRINT( _L( "MM MTP <> CGetObjectPropList::CheckPropCode, All properties were queried." ) );

        }

    PRINT1( _L( "MM MTP <= CGetObjectPropList::CheckPropCode, response 0x%x" ), response );

    return response;

    }

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

// CGetObjectPropList::CheckDepth

// Ensure the depth operation parameter is valid

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

//

TMTPResponseCode CGetObjectPropList::CheckDepth() const

    {

    TMTPResponseCode response = EMTPRespCodeSpecificationByDepthUnsupported;

    PRINT( _L( "MM MTP => CGetObjectPropList::CheckDepth" ) );

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

    iHandle = Request().Uint32( TMTPTypeRequest::ERequestParameter1 );

    PRINT1( _L( "MM MTP <> CGetObjectPropList::CheckDepth iHandle = 0x%x" ), iHandle );

    iDepth = Request().Uint32( TMTPTypeRequest::ERequestParameter5 );

    PRINT1( _L( "MM MTP <> CGetObjectPropList::CheckDepth iDepth = 0x%x" ), iDepth );

    if ( ( iDepth == 0 )

        || ( iDepth == 1 )

        || ( iDepth == KMTPAll && iHandle == KMTPHandleNone ) )

        {

        response = EMTPRespCodeOK;

        }

    PRINT1( _L( "MM MTP <= CGetObjectPropList::CheckDepth, response 0x%x" ), response );

    return response;

    }

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

// CGetObjectPropList::GetObjectHandlesL

// Get the handles for the objects that we want the properties for

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

//

void CGetObjectPropList::GetObjectHandlesL()

    {

    PRINT( _L( "MM MTP => CGetObjectPropList::GetObjectHandlesL" ) );

    iHandles.Reset();

    if ( iHandle == KMTPHandleAll )

        {

        GetObjectHandlesL( KMTPStorageAll, KMTPHandleNone );

        }

    else if ( iHandle == KMTPHandleNone )

        {

        GetRootObjectHandlesL( iDepth, iFormatCode );

        }

    else

        {

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

        TPtrC suid( meta->DesC( CMTPObjectMetaData::ESuid ) );

        __ASSERT_DEBUG( meta, Panic( EMmMTPDpObjectNull ) );

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

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

            {

            GetFolderObjectHandlesL( iDepth, iHandle );

            }

        else

            {

            iHandles.Append( iHandle );

            }

        }

    PRINT( _L( "MM MTP <= CGetObjectPropList::GetObjectHandlesL" ) );

    }

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

// CGetObjectPropList::GetObjectHandlesL

// Get all object handles (for GetObjectHandlesL)

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

//

void CGetObjectPropList::GetObjectHandlesL( TUint32 aStorageId,

    TUint32 aParentHandle,

    {

    PRINT2( _L( "MM MTP => CGetObjectPropList::GetObjectHandlesL, aStorageId = 0x%x, aParentHandle = 0x%x" ),

        aStorageId,

        aParentHandle );

    RMTPObjectMgrQueryContext context;

    CleanupClosePushL( context ); // + context

    iHandles.Reset();

    if ( aFormat )

        {

        TMTPObjectMgrQueryParams params( aStorageId, aFormat, aParentHandle );

        do

            {

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

            }

        while ( !context.QueryComplete() );

        }

    else

        {

        TMTPObjectMgrQueryParams params( aStorageId,

            KMTPFormatsAll,

            aParentHandle );

        do

            {

            RArray<TUint> handles;

            CleanupClosePushL( handles ); // + handles

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

            for ( TInt i = 0; i < handles.Count(); i++ )

                {

                if ( iFramework.ObjectMgr().ObjectOwnerId( handles[i ] )

                    == iFramework.DataProviderId() )

                    iHandles.Append( handles[i ] );

                }

            CleanupStack::PopAndDestroy( &handles ); // - handles

            }

        while ( !context.QueryComplete() );

        }

    CleanupStack::PopAndDestroy( &context ); // - context

    PRINT( _L( "MM MTP <= CGetObjectPropList::GetObjectHandlesL" ) );

    }

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

// CGetObjectPropList::GetFolderObjectHandlesL

// Gets a folder object handle

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

//

void CGetObjectPropList::GetFolderObjectHandlesL( TUint32 aDepth,

    TUint32 aParentHandle )

    {

    PRINT2( _L( "MM MTP => CGetObjectPropList::GetFolderObjectHandlesL aDepth = 0x%x, aParentHandle = 0x%x" ),

        aDepth,

        aParentHandle );

    if ( aDepth == 0 )

        {

        // Do Nothing!!!

        }

    else //if(aDepth ==1)

        {

        GetObjectHandlesL( KMTPStorageAll, aParentHandle, iFormatCode );

        }

    PRINT( _L( "MM MTP <= CGetObjectPropList::GetFolderObjectHandlesL" ) );

    }

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

// CGetObjectPropList::GetRootObjectHandlesL

// Gets the handles of all objects on the root

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

//

void CGetObjectPropList::GetRootObjectHandlesL( TUint32 aDepth, TUint16 aFormat )

    {

    PRINT2( _L( "MM MTP => CGetObjectPropList::GetRootObjectHandlesL aDepth = 0x%x, aFormat = 0x%x" ), aDepth , aFormat);

    if ( aDepth == KMaxTUint )

        {

        GetObjectHandlesL( KMTPStorageAll, KMTPHandleNone, aFormat );

        }

    else if ( aDepth == 0 )

        {

        // Return empty set to PC according to spec 0.96, folder is handled by device dp

        iHandles.Reset();

        }

    else

        {

        GetObjectHandlesL( KMTPStorageAll, KMTPHandleNoParent, aFormat );

        }

    PRINT( _L( "MM MTP <= CGetObjectPropList::GetRootObjectHandlesL" ) );

    }

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

// CGetObjectPropList::ServiceAllPropertiesL

//  Gets a list of all the properties supported

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

//

TInt CGetObjectPropList::ServiceAllPropertiesL( TUint32 aHandle )

    {

    PRINT1( _L( "MM MTP => CGetObjectPropList::ServiceAllPropertiesL aHandle = 0x%x" ), aHandle );

    // Append the current object info onto our list

    TFileName fileName( iObject->DesC( CMTPObjectMetaData::ESuid ) );

    TUint32 formatCode = iObject->Uint( CMTPObjectMetaData::EFormatCode );

    PRINT2( _L( "MM MTP <> CGetObjectPropList::ServiceAllPropertiesL, fileName = %S, formatCode = 0x%x" ),

        &fileName,

        formatCode );

    const RArray<TUint>* properties = NULL;

    if ( formatCode == KMTPFormatsAll )

        properties = iDpConfig.GetAllSupportedProperties();

    else

        properties = iDpConfig.GetSupportedPropertiesL( formatCode );

    const TInt count = properties->Count();

    TInt err = KErrNone;

    TBool successQuery = EFalse;

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

        {

        // no need to do the trap anymore, this is being handle internally in Media DP's ServiceSpecificObjectPropertyL,

        // also, this base class should not know too much of different handling between different formats

        err = ServiceOneObjectPropertyL( aHandle, (*properties)[i] );

        if ( err == KErrNone )

            successQuery = ETrue;

        if ( err == KErrNotSupported || err == KErrNotFound )  // Skip

            err = KErrNone;

        if ( err != KErrNone )

            break;

        }

    // In PC Suite combined mode, a file that was found at the beginning could be deleted by PC Suite protocol

    // Need to fail it here.