/*

* 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:    Provide Icon File Considering Requirement

*

*/

#include "glxmuliconprovider.h"               // Icon details

#include <avkon.mbg>

#include <e32math.h>                          // A collection of mathematical functions

#include <glxicons.mbg>

#include "glxdrmutility.h"                   // DRM utility class to provide DRM-related functionality 

#include "glxmedia.h"                        // Reference to a media item in the item pool

#include <glxlog.h>                          // Logging

#include <lbsposition.h> // TCoordinate

#include <pathinfo.h> 

#include <driveinfo.h> // Added for DriveInfo class

#include <data_caging_path_literals.hrh>

#include <glxtracer.h>

#include <glxerrormanager.h>

#include <glxthumbnailattributeinfo.h>

_LIT(KGlxIconsFilename, "glxicons.mif");

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

// ConstructL

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

//

void CGlxMulIconProvider::ConstructL()

    {

    TRACER("CGlxMulIconProvider::ConstructL");

    iResFileName.Copy(KDC_APP_BITMAP_DIR);

    iResFileName.Append(KGlxIconsFilename);

    //iResFileName.Copy(resFile);

    }

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

// ResourceFileName

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

//

const TDesC& CGlxMulIconProvider::ResourceFileName() const

    {

    TRACER("CGlxMulIconProvider::ResourceFileName");

    return iResFileName;

    }

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

// NewL

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

//   

EXPORT_C CGlxMulLocationIconProvider* CGlxMulLocationIconProvider::NewL( ) 

    {

    TRACER("CGlxMulLocationIconProvider::NewL");

    CGlxMulLocationIconProvider* self = new (ELeave) CGlxMulLocationIconProvider();

    CleanupStack::PushL( self );

    self->ConstructL(  );

    CleanupStack::Pop( self );

    return self;

    }

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

// Destructor

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

//   

CGlxMulLocationIconProvider::~CGlxMulLocationIconProvider()

	{

	}

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

// NewL

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

//   

EXPORT_C CGlxMulDriveIconProvider* CGlxMulDriveIconProvider::NewL( )

    {

    TRACER("CGlxMulDriveIconProvider::NewL");

    CGlxMulDriveIconProvider* self = new (ELeave) CGlxMulDriveIconProvider();

    CleanupStack::PushL( self );

    self->ConstructL( );

    CleanupStack::Pop( self );

    return self;

    }

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

// Destructor

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

//   

CGlxMulDriveIconProvider::~CGlxMulDriveIconProvider()

	{

	}

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

// IconIdL

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

//   

TInt CGlxMulLocationIconProvider::IconIdL( const TGlxMedia& aMedia ) const

    {

    TRACER("CGlxMulLocationIconProvider::IconIdL");

    const CGlxMedia* media = aMedia.Properties();

    if( media->IsSupported( KGlxMediaGeneralLocation ) )

        {

        TCoordinate cordinate = media->ValueTObject<TCoordinate>(KGlxMediaGeneralLocation);	 

        //Check for valid co-ordinates

        if( (!Math::IsNaN(cordinate.Latitude())) && (!Math::IsNaN(cordinate.Longitude())) ) 

            {

            return EMbmGlxiconsQgn_indi_cam4_geotag_on;

            }

      }

     return EMbmAvkonQgn_note_empty;

    }

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

// IconIdL

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

//   

TInt CGlxMulDriveIconProvider::IconIdL( const TGlxMedia& aMedia ) const

    {

    TRACER("CGlxMulDriveIconProvider::IconIdL");

    // by default set icon for internal mass storage

    const CGlxMedia* media = aMedia.Properties();

    TInt iconId= EMbmGlxiconsQgn_indi_fmgr_ms_add;

    if( media->IsSupported( KMPXMediaGeneralDrive ) )

        {

    const TDesC& drive =  media->ValueText(KMPXMediaGeneralDrive);

    if(0 == drive.CompareF(

    PathInfo::PhoneMemoryRootPath().Left( KMaxDriveName )))

        {

        // in phone memory

        iconId = EMbmGlxiconsQgn_indi_phone_add;

        }

    else 

        {

        RFs fsSession;

        User::LeaveIfError(fsSession.Connect());

        TUint drvStatus( 0 );

        TDriveUnit driveNumber(drive);

        User::LeaveIfError(DriveInfo::GetDriveStatus

        ( fsSession, driveNumber, drvStatus ) );

        // To get the entire status of the Drive as "drvStatus"

        fsSession.Close();

        if(drvStatus & DriveInfo::EDriveRemovable)

        // Do a AND operation to check that the status of the drive is "Removable" or not

            {

            // in mmc memory

            iconId = EMbmGlxiconsQgn_indi_mmc_add;

                }

            }

        }

    return iconId;    

    }

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

// Constructor

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

//   

CGlxMulStaticIconProvider::CGlxMulStaticIconProvider(TInt aResourceIconId)

    {

    TRACER("CGlxMulStaticIconProvider::CGlxMulStaticIconProvider");

    iIconId = aResourceIconId;

    }

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

// NewL

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

//   

EXPORT_C CGlxMulStaticIconProvider* CGlxMulStaticIconProvider::NewL(TInt aResourceIconId )

    {

    TRACER("CGlxMulStaticIconProvider::NewL");

    CGlxMulStaticIconProvider* self = new (ELeave) CGlxMulStaticIconProvider(aResourceIconId);

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// IconIdL

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

//   

TInt CGlxMulStaticIconProvider::IconIdL(const TGlxMedia& /*aMedia*/ ) const

    {

    TRACER("CGlxMulStaticIconProvider::IconIdL");

    return iIconId;

    }

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

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

// Constructor

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

//  

CGlxMulDRMIconProvider::CGlxMulDRMIconProvider()

    {

    }

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

// Destructor

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

//   

CGlxMulDRMIconProvider::~CGlxMulDRMIconProvider()

    {

    TRACER("CGlxMulDRMIconProvider::~CGlxMulDRMIconProvider");

    if(iDRMUtility)

        {

    iDRMUtility->Close();    // Memory Leak Fix

    }

    }

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

// NewL

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

//   

EXPORT_C CGlxMulDRMIconProvider* CGlxMulDRMIconProvider::NewL( )

    {

    TRACER("CGlxMulDRMIconProvider::NewL");

    CGlxMulDRMIconProvider* self = new (ELeave) CGlxMulDRMIconProvider;

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// ConstructL

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

// 

void CGlxMulDRMIconProvider::ConstructL()

    {

    TRACER("CGlxMulDRMIconProvider::ConstructL");

    iDRMUtility = CGlxDRMUtility::InstanceL();

    iIconId = EMbmAvkonQgn_note_empty;

    iMifFileName.Copy( KDC_APP_BITMAP_DIR );

    iMifFileName.Append( KGlxIconsFilename );

    }

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

// IconIdL

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

//   

TInt CGlxMulDRMIconProvider::IconIdL(const TGlxMedia& aMedia/**/ ) const

    {

    TRACER("CGlxMulDRMIconProvider::IconIdL");

    if( aMedia.IsDrmProtected() )

        {

        const TDesC& uri = aMedia.Uri();

        if( uri.Length() > 0)

            {

            if(iDRMUtility->IsForwardLockedL(uri))

                {

                return EMbmGlxiconsQgn_prop_drm_rights_valid_super;

                }

            else 

                {

                TMPXGeneralCategory  cat = aMedia.Category();                  

                TBool checkViewRights = (cat==EMPXImage);

                if(iDRMUtility->CheckOpenRightsL(uri, checkViewRights))

                        {

                        return EMbmGlxiconsQgn_prop_drm_rights_valid_super;        

                        }

                     else

                        {

                        return EMbmGlxiconsQgn_prop_drm_rights_exp_super;

                        }

                }

            }

        }

    return iIconId;

    }

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

// ResourceFileName

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

//   

const TDesC& CGlxMulDRMIconProvider::ResourceFileName() const

    {

    TRACER("CGlxMulDRMIconProvider::ResourceFileName");

    return iMifFileName;

    }

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

// Constructor

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

//  

CGlxMulVideoIconProvider::CGlxMulVideoIconProvider(TBool aIsFullscreen)

	: iIsFullscreen(aIsFullscreen)

    {

    }

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

// Destructor

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

//   

CGlxMulVideoIconProvider::~CGlxMulVideoIconProvider()

    {

    TRACER("CGlxMulVideoIconProvider::~CGlxMulVideoIconProviderr");

    }

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

// NewL

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

//   

EXPORT_C CGlxMulVideoIconProvider* CGlxMulVideoIconProvider::NewL(TBool aIsFullscreen)

    {

    TRACER("CGlxMulVideoIconProvider::NewL");

    CGlxMulVideoIconProvider* self = new (ELeave) CGlxMulVideoIconProvider(aIsFullscreen);

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// ConstructL

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

// 

void CGlxMulVideoIconProvider::ConstructL()

    {

    TRACER("CGlxMulVideoIconProvider::ConstructL");

    iIconId = EMbmAvkonQgn_note_empty;

    iMifFileName.Copy( KDC_APP_BITMAP_DIR );

    iMifFileName.Append( KGlxIconsFilename );

    }

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

// IconIdL

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

//   

TInt CGlxMulVideoIconProvider::IconIdL(const TGlxMedia& aMedia) const

    {

    TRACER("CGlxMulVideoIconProvider::IconIdL");

    if((aMedia.Category() == EMPXVideo) && (GlxErrorManager::HasAttributeErrorL(aMedia.Properties(), KGlxMediaIdThumbnail ) == KErrNone))

        {

		if (iIsFullscreen)

            {                       	        	

		    return EMbmGlxiconsQgn_indi_media_fullscreen_play;			                

            }        

    	return EMbmGlxiconsQgn_indi_media_thumbnail;      

        }   

    return iIconId;

    }

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

// ResourceFileName

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

//   

const TDesC& CGlxMulVideoIconProvider::ResourceFileName() const

    {

    TRACER("CGlxMulVideoIconProvider::ResourceFileName");

    return iMifFileName;

    }