/*

* Copyright (c) 2008-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:    Media item 

*

*/

#include "glxmedia.h"

#include <glxassert.h>

#include <glxthumbnailattributeinfo.h>

#include <mpxmediacollectiondetaildefs.h>

#include <mpxmediadrmdefs.h>

#include <e32math.h>

#include <lbsposition.h>                    // for TCoordinate

#include "glxcollectiongeneraldefs.h"

#include "glxmediastaticitemdefs.h"

#include "glxthumbnailutility.h"

#include <glxtracer.h>                 //For logging

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

// Constructor

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

//

TGlxMedia::TGlxMedia( CGlxMedia& aMedia )

    {

    TRACER("TGlxMedia::Default Constructor");

    __ASSERT_DEBUG ( aMedia.Id() != KGlxIdNone, Panic( EGlxPanicIllegalArgument ) ); // Must have an id defined,

    iId = aMedia.Id();

    iItem = &aMedia;

    }

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

// Compare two media items by id

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

//

EXPORT_C TBool TGlxMedia::MatchById(const TGlxMedia& aMedia1, const TGlxMedia& aMedia2)

	{

	TRACER("TGlxMedia::MatchById");

	return aMedia1.iId == aMedia2.iId;

	}

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

// Tests to see if the Media is a static

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

EXPORT_C TBool TGlxMedia::IsStatic() const

    {

    TRACER("TGlxMedia::IsStatic");

    if ( iItem )

        {

        return iItem->IsSupported( KGlxMediaStaticItem );

        }

    return EFalse;

    }

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

// Gets the command associated with a static item

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

EXPORT_C TBool TGlxMedia::GetStaticItemCommand(TInt& aCmd) const

    {

    TRACER("TGlxMedia::GetStaticItemCommand");

    if ( iItem )

        {

        TMPXAttribute attrib(KGlxMediaIdStaticItem,

                            KGlxMediaStaticItemCommand);

        return iItem->GetValueTObject( aCmd, attrib );

        }

    // by default the cmd value is not changed    

    return EFalse;

    }

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

// Gets the date

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

EXPORT_C TBool TGlxMedia::GetDate(TTime& aDate) const

    {

    TRACER("TGlxMedia::GetDate");

    if ( iItem )

        {

        return iItem->GetValueTObject( aDate, KMPXMediaGeneralDate );

        }

    // by default the date is not changed    

    return EFalse;

    }

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

// Gets the last modified date

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

EXPORT_C TBool TGlxMedia::GetLastModifiedDate(TTime& aDate) const

    {

    TRACER("TGlxMedia::GetLastModifiedDate");

    if ( iItem )

        {

        return iItem->GetValueTObject( aDate, KGlxMediaGeneralLastModifiedDate );

        }

    // by default the date is not changed    

    return EFalse;

    }

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

// Gets the general category

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

EXPORT_C TMPXGeneralCategory TGlxMedia::Category() const

    {

    TRACER("TGlxMedia::Category");

    TMPXGeneralCategory cat =  EMPXNoCategory;

    if ( iItem )

        {

        // if this fails cat will remain as EMPXNoCategory

        iItem->GetValueTObject( cat, KMPXMediaGeneralCategory );

        }

    return cat;

    }

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

// Gets the dimensions

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

EXPORT_C TBool TGlxMedia::GetDimensions(TSize& aSize) const

    {

    TRACER("TGlxMedia::GetDimensions");

    if ( iItem )

        {

        return iItem->GetValueTObject( aSize, KGlxMediaGeneralDimensions );

        }

    // by default the size is not changed    

    return EFalse;

    }

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

// Gets the (file) size

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

    {

    TRACER("TGlxMedia::GetSize");

    if ( iItem )

        {

        return iItem->GetValueTObject( aSize, KMPXMediaGeneralSize );

        }

    // by default the size is not changed    

    return EFalse;

    }

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

// Gets the duration 

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

EXPORT_C TBool TGlxMedia::GetDuration(TReal32& aDuration) const

    {

    TRACER("TGlxMedia::GetDuration");

    if ( iItem )

        {

        return iItem->GetValueTObject( aDuration, KMPXMediaGeneralDuration );

        }

    // by default the duration is not changed    

    return EFalse;

    }

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

// Gets the frame count

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

EXPORT_C TBool TGlxMedia::GetFrameCount(TInt& aFrameCount) const

    {

    TRACER("TGlxMedia::GetFrameCount");

    if ( iItem )

        {

        return iItem->GetValueTObject( aFrameCount, KGlxMediaGeneralFramecount );

        }

    // by default the frame count is not changed    

    return EFalse;

    }

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

// Gets the general count

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

EXPORT_C TBool TGlxMedia::GetContainedItemCount(TInt& aGeneralCount) const

    {

    TRACER("TGlxMedia::GetContainedItemCount");

    if ( iItem )

        {

        return iItem->GetValueTObject( aGeneralCount, KMPXMediaGeneralCount );

        }

    // by default the frame count is not changed    

    return EFalse;

    }

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

// Gets the general count

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

EXPORT_C TBool TGlxMedia::GetSlideshowPlayableContainedItemCount(TInt& aGeneralCount) const

    {

    TRACER("TGlxMedia::GetSlideshowPlayableContainedItemCount");

    if ( iItem )

        {

        return iItem->GetValueTObject( aGeneralCount, KGlxMediaGeneralSlideshowableContent );

        }

    // by default the frame count is not changed    

    return EFalse;

    }

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

// Gets the coordinate value

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

EXPORT_C TBool TGlxMedia::GetCoordinate(TCoordinate& aCoordinate) const

    {

    TRACER("TGlxMedia::GetCoordinate");

    TBool isSupported = EFalse;

    if ( iItem )

        {

        if (iItem->GetValueTObject( aCoordinate, KGlxMediaGeneralLocation ))

            {

            isSupported = ETrue;

            if ( Math::IsNaN( aCoordinate.Latitude() ) ||

                 Math::IsNaN( aCoordinate.Longitude() )  ||

                 aCoordinate.Datum() != KPositionDatumWgs84 )

                {

                isSupported = EFalse;

                }

            }

        }

    // by default the coodinate is not changed    

    return isSupported;

    }

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

// Gets the IconInfo

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

EXPORT_C TBool TGlxMedia::GetIconInfo(TIconInfo& aInfo) const

    {

    TRACER("TGlxMedia::GetIconInfo");

    if ( iItem )

        {

        return iItem->GetValueTObject( aInfo, KMPXMediaGeneralIcon );

        }

    // by default aInfo is not changed    

    return EFalse;

    }

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

// Returns the DRM protection indication - defaults to ETrue if not found

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

EXPORT_C TBool TGlxMedia::IsDrmProtected() const

    {

    TRACER("TGlxMedia::IsDrmProtected");

    TBool isDrmProtected = EFalse;

    if ( iItem )

        {

        // ignore return value. Failure leaves isDrmProtected unchanged as ETrue

        iItem->GetValueTObject( isDrmProtected, KMPXMediaDrmProtected );

        }

    // by default is protected

    return isDrmProtected;

    }

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

// Gets the DRM protection

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

EXPORT_C TBool TGlxMedia::GetDrmProtected(TBool& aIsProtected) const

    {

    TRACER("TGlxMedia::GetDrmProtected");

    if ( iItem )

        {

        return iItem->GetValueTObject( aIsProtected, 

                                       KMPXMediaDrmProtected );

        }

    // by default aIsProtected is not changed

    return EFalse;

    }

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

// Gets the DRM protection

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

EXPORT_C TBool TGlxMedia::GetDrmValidity(TGlxMediaGeneralRightsValidity& aIsValid) const

    {

    if ( iItem )

        {

        return iItem->GetValueTObject( aIsValid, 

                                       KGlxMediaGeneralDRMRightsValid );

        }

    // by default aIsValid is not changed

    return EFalse;

    }

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

// Gets the System Item indicator

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

EXPORT_C TBool TGlxMedia::GetSystemItem(TBool& aIsSystemItem) const

    {

    TRACER("TGlxMedia::GetSystemItem");

    if ( iItem )

        {

        return iItem->GetValueTObject( aIsSystemItem, 

                                       KGlxMediaGeneralSystemItem );

        }

    // by default aIsSystemItem is not changed

    return EFalse;

    }

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

// Gets the title

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

EXPORT_C const TDesC& TGlxMedia::Title() const

    {

    TRACER("TGlxMedia::Title");

    if ( iItem )

        {

        return iItem->ValueText( KMPXMediaGeneralTitle );

        }

    return KNullDesC;    

    }

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

// Gets the subtitle

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

EXPORT_C const TDesC& TGlxMedia::SubTitle() const

    {

    TRACER("TGlxMedia::SubTitle");

    if ( iItem )

        {

        return iItem->ValueText( KGlxMediaCollectionPluginSpecificSubTitle );

        }

    return KNullDesC;    

    }

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

// Gets the comment

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

EXPORT_C const TDesC& TGlxMedia::Comment() const

    {

    TRACER("TGlxMedia::Comment");

    if ( iItem )

        {

        return iItem->ValueText( KMPXMediaGeneralComment );

        }

    return KNullDesC;    

    }

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

// Gets the URI indicating the success in the return value

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

EXPORT_C const TDesC&  TGlxMedia::Uri() const

    {

    TRACER("TGlxMedia::Uri");

    if( iItem )

        {

        return iItem->ValueText( KMPXMediaGeneralUri);

        }

    // by default descriptor pointer is unchanged

    return KNullDesC;

    }

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

// Gets the MimeType indicating the success in the return value

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

EXPORT_C const TDesC&  TGlxMedia::MimeType() const

    {

    TRACER("TGlxMedia::MimeType");

    if( iItem )

        {

        return iItem->ValueText( KMPXMediaGeneralMimeType);

        }

    // by default descriptor pointer is unchanged

    return KNullDesC;

    }

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

// Gets a thumbnail attribute

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

EXPORT_C const CGlxThumbnailAttribute* TGlxMedia::ThumbnailAttribute(

                                                TMPXAttribute& aAttribute) const

    {

    TRACER("TGlxMedia::ThumbnailAttribute");

    if( iItem && KGlxMediaIdThumbnail == aAttribute.ContentId() )

        {

        return static_cast<const CGlxThumbnailAttribute*>

                                  ( iItem->ValueCObject(aAttribute) );

        }

    else

        {

        return NULL;

        }

    }

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

// GetClosestThumbnail

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

//

EXPORT_C TBool TGlxMedia::GetClosestThumbnail( TMPXAttribute& aAttribute,

                            const TSize& aDesiredSize, TBool aDrmValid ) const

    {

    TRACER("TGlxMedia::GetClosestThumbnail");

    if ( iItem )

        {

        TInt index = GlxThumbnailUtility::ClosestThumbnail( aDesiredSize,

                                                        *iItem, aDrmValid );

        if ( index >= 0 )

            {

            aAttribute = iItem->Attribute(index);

            return ETrue;

            }

        }

    return EFalse;

    }

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

// Is the media playable in slideshow

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

//

EXPORT_C TBool TGlxMedia::IsSlideShowPlayableContent() const

    {

    TRACER("TGlxMedia::IsSlideShowPlayableContent");

    if (iItem)

        {

    	// Only DRM protected images are allowed

        if (iItem->IsSupported(KMPXMediaGeneralCategory) && 

            iItem->IsSupported(KMPXMediaDrmProtected) && 

            iItem->IsSupported(KGlxMediaGeneralFramecount))

            {

            if (iItem->ValueTObject<TInt>(KMPXMediaGeneralCategory) == EMPXImage &&

                !iItem->ValueTObject<TInt>(KMPXMediaDrmProtected) && 

                iItem->ValueTObject<TInt>(KGlxMediaGeneralFramecount) == 1)

            	{

                return ETrue;                	

            	}

            }

        // The media item is either not DRM protected, a video or an animated gif    

        }

    return EFalse;    			

    }

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

// Returns the IdSpaceId associated with the media

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

//

EXPORT_C TGlxIdSpaceId TGlxMedia::IdSpaceId() const

    {

    TRACER("TGlxMedia::IdSpaceId");

    TGlxIdSpaceId idSpaceId( KGlxIdNone );

    if ( iItem )

        {

        iItem->GetValueTObject( idSpaceId, KMPXMediaColDetailSpaceId );

        }

    return idSpaceId;

    }

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

// Set media pointer

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

//

void TGlxMedia::SetMedia( CGlxMedia* aMedia, MGlxMediaUser& aMediaUser, TInt aIndex )

	{

	TRACER("TGlxMedia::SetMedia");

    __ASSERT_DEBUG( aMedia == NULL || !iItem , Panic(EGlxPanicAlreadyInitialised ) ); // Already has media

    if ( aMedia )

        {

        // Media object being added

    	aMedia->AddUser( aMediaUser, aIndex );

        }

    else if ( iItem )

        {

        // Media object being set to null, remove since old media object exists

    	iItem->RemoveUser( aMediaUser );

        }

	iItem = aMedia;

	}

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

// Update media

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

//

void TGlxMedia::UpdateMedia( MGlxMediaUser& aMediaUser, TInt aIndex )

    {

    TRACER("TGlxMedia::UpdateMedia");

    if ( iItem )

        {

        iItem->UpdateUser( aMediaUser, aIndex );

        }