/*

* 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:  Access to content and data attributes

*

*/

// Includes

#include <apgcli.h>

#include <f32file.h>

#include <charconv.h>

#include <caf.h>

#include <caf/attributeset.h>

#include <caf/stringattributeset.h>

#include <caf/virtualpath.h>

#include <caf/caferr.h>

#include <caf/caftypes.h>

#include <utf.h>

#include <drmagents.h>

#include <oma2agent.h>

#include <wmdrmagent.h>

#include "wmdrmagentattributes.h"

#include "asf.h"

#include "logfn.h"

using namespace ContentAccess;

// ============================ MEMBER FUNCTIONS ===============================

// PointerArrayResetDestroyAndClose

// Template method used to push RPointerArrays to the cleanup stack. Takes

// care of deleting all pointers in the array.

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

template<class S>

void PointerArrayResetDestroyAndClose(TAny* aPtr)

        {

    (reinterpret_cast<RPointerArray<S>*>(aPtr))->ResetAndDestroy();

    (reinterpret_cast<RPointerArray<S>*>(aPtr))->Close();

        }

// ============================ MEMBER FUNCTIONS ===============================

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

TInt TWmDrmAgentAttributes::GetAttributeL(

    CAsf* /*aAsfFile*/,

    TInt aAttribute,

    TInt& aValue,

    const TVirtualPathPtr& /*aVirtualPath*/,

    TBool /*aReusePreviousQuery*/ )

    {

    TInt r = KErrNone;

    LOGFNR( "TWmDrmAgentAttributes::GetAttributeL", r );

    aValue = ETrue;

    switch ( aAttribute )

        {

        case DRM::EDrmAgentUid:

            aValue = DRM::EDrmWmAgent;

            break;

        case ECanPlay:

        case ECanView:

            aValue = EFalse;

            r = KErrCANotSupported;

            break;

        case ERightsStateless:

        case ERightsConsumable:

            aValue = EFalse;

            r = KErrCANotSupported;

            break;

        case ECanAutomaticConsume:

            aValue = EFalse;

            r = KErrCANotSupported;

            break;

        case EIsForwardable:

        case EIsCopyable:

        case ECanRewind:

        case ECopyPaste:

        case ECanMove:

        case ECanRename:

            aValue = ETrue;

            break;

        case EIsModifyable:

        case ECanPrint:

        case ECanExecute:

        case EPreviewAvailable:

            aValue = EFalse;

            break;

        case EIsProtected:

            r = KErrCANotSupported;

            break;

        case EContentCDataInUse:

            aValue = ETrue;

            break;

        case EFileType:

            aValue = EAsf;

            break;

        case DRM::EDrmFileType:

            aValue = DRM::EDrmWMFile;

            break;

        case DRM::EDrmAllowedOutputs:

            aValue = 0;

            r = KErrCANotSupported;

           break;

        default:

            r = KErrCANotSupported;

            break;

        };

    LOG3( "Attribute: %d, value: %d", aAttribute, aValue );

    return r;

    }

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

TInt TWmDrmAgentAttributes::GetAttributeSetL(

    CAsf* aAsfFile,

    RAttributeSet& aAttributeSet,

    const TVirtualPathPtr& aVirtualPath )

    {

    TInt i = 0;

    TInt attribute = 0;

    TInt value=0;

    TInt err = KErrNone;

    TInt numAttributes = aAttributeSet.Count();

    LOGFN( "TWmDrmAgentAttributes::GetAttributeSetL" );

    // loop through all the attriutes in the set and find their values

    for ( i = 0; i < numAttributes && err == KErrNone; i++ )

        {

        attribute = aAttributeSet[i];

        err = GetAttributeL( aAsfFile, attribute,

            value, aVirtualPath, ETrue );

        err = aAttributeSet.SetValue( attribute, value, err );

        }

    return err;

    }

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

TInt TWmDrmAgentAttributes::GetStringAttributeL(

    CAsf* aAsfFile,

    TInt aAttribute,

    TDes& aValue,

    const TVirtualPathPtr& /*aVirtualPath*/,

    TBool /*aReusePreviousQuery*/ )

    {

    TInt err = KErrNone;

    HBufC* b = NULL;

    HBufC* allocated = NULL;

    TFileName fileName;

    LOGFNR( "TWmDrmAgentAttributes::GetStringAttributeL", err );

    // Initialise the attribute value to be zero length in case it's not

    // supported or an error occurs

    aValue.SetLength( 0 );

    switch( aAttribute )

        {

        case EIconURI:

        case EPreviewURI:

        case EContentURI:

        case EInfoURL:

        case EPendingRightsETA:

            err = KErrCANotSupported;

            break;

        case EMimeType:

            aValue.Copy( aAsfFile->iMimeType );

            break;

        case EDescription:

            if (aAsfFile->iDescription)

                {

                b = aAsfFile->iDescription;

                }

            break;

        case ETitle:

            if (aAsfFile->iTitle)

                {

                b = aAsfFile->iTitle;

                }

            break;

        case EPerformer:

        case EAuthor:

            if (aAsfFile->iAuthor)

                {

                b = aAsfFile->iAuthor;

                }

            break;

        case EContentID:

            if (aAsfFile->iUniqueFileID)

                {

                b = aAsfFile->iUniqueFileID;

                }

            break;

        case ECopyright:

            if (aAsfFile->iCopyright)

                {

                b = aAsfFile->iCopyright;

                }

            break;

        case ERating:

        case DRM::EDrmRatingInfo:

            if (aAsfFile->iRating)

                {

                b = aAsfFile->iRating;

                }

            break;

        case EAlbumTitle:

            if (aAsfFile->iAlbumTitle)

                {

                b = aAsfFile->iAlbumTitle;

                }

            break;

        case EPicture:

            if (aAsfFile->iPicture)

                {

                b = aAsfFile->iPicture;

                }

            break;

        case EText:

            if (aAsfFile->iText)

                {

                b = aAsfFile->iText;

                }

            break;

        case EComposer:

            if (aAsfFile->iComposer)

                {

                b = aAsfFile->iComposer;

                }

            break;

        case EGenre:

            if (aAsfFile->iGenre)

                {

                b = aAsfFile->iGenre;

                }

            break;

        case EYear:

        case DRM::EDrmRecordingYear:

            if (aAsfFile->iYear)

                {

                b = aAsfFile->iYear;

                }

            break;

        case EOriginalArtist:

        case DRM::EDrmOriginalArtist:

            if (aAsfFile->iOriginalArtist)

                {

                b = aAsfFile->iOriginalArtist;

                }

            break;

        case EWmTrackNumber:

        case DRM::EDrmTrackNumber:

            if (aAsfFile->iTrackNumber)

                {

                b = aAsfFile->iTrackNumber;

                }

            break;

        case EAudioFileUrl:

            if (aAsfFile->iAudioFileUrl)

                {

                b = aAsfFile->iAudioFileUrl;

                }

            break;

        case ESharedUserRating:

            if (aAsfFile->iSharedUserRating)

                {

                b = aAsfFile->iSharedUserRating;

                }

            break;

        case EDate:

            if (aAsfFile->iDate)

                {

                b = aAsfFile->iDate;

                }

            break;

        case DRM::EDrmAgentName:

            allocated = DRM::KDrmWMAgentName().AllocL();

            break;

        case DRM::EDrmFileName:

            err = aAsfFile->iFile.Name( fileName );

            if( aValue.MaxLength() < fileName.Length() )

                {

                return KErrOverflow;

                }

            aValue.Copy( fileName );

            break;

        case DRM::EDrmFullName:

            err = aAsfFile->iFile.FullName( fileName );

            if ( aValue.MaxLength() < fileName.Length() )

                {

                return KErrOverflow;

                }

            aValue.Copy( fileName );

            break;

        default:

            err = KErrCANotSupported;

            break;

        };

    if (b != NULL)

        {

        if( b->Length() > aValue.MaxLength() )

            {

            return KErrOverflow;

            }

        err = KErrNone;

        aValue.Copy(*b);

        }

    else if( allocated )

        {

        if( allocated->Length() <= aValue.MaxLength() )

            {

            err = KErrNone;

            aValue.Copy(*allocated);

            }

        else

            {

            err = KErrOverflow;

            }

        delete allocated;

        allocated = NULL;

        }

    LOG2( "Attribute: %d", aAttribute );

    return err;

    }

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

TInt TWmDrmAgentAttributes::GetStringAttributeSetL(

    CAsf* aAsfFile,

    RStringAttributeSet& aStringAttributeSet,

    const TVirtualPathPtr& aVirtualPath )

    {

    TInt i = 0;

    TInt attribute = 0;

    TInt err = KErrNone;

    TBuf <KMaxDataTypeLength> buf;

    LOGFN( "TWmDrmAgentAttributes::GetStringAttributeSetL" );

    TInt numAttributes = aStringAttributeSet.Count();

    // loop through all the attriutes in the set and find their values

    for ( i = 0; i < numAttributes && err==KErrNone; i++ )

        {

        buf.SetLength( 0 );

        attribute = aStringAttributeSet[i];

        err = GetStringAttributeL( aAsfFile, attribute, buf, aVirtualPath );

        err = aStringAttributeSet.SetValue(attribute,buf, err);

        }

    return err;

    }

// End of file