/*
* 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;
}