/*
* 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:    Manager of visual lists
*
*/




/**
 * @internal reviewed 03/07/2007 by Rowland Cook
 */

#include "glxdrmiconmanager.h"

#include <data_caging_path_literals.hrh>
#include <glxdrmutility.h>
#include <glxuiutility.h>
#include <glxicons.mbg> // icons
#include <glxtracer.h>
#include <glxlog.h>
#include <glxtexturemanager.h>
#include <glxuistd.h>
#include <alf/alftexture.h>
#include <alf/alfvisual.h>
#include <mglxmedialist.h>
#include <mglxvisuallist.h>
#include <mpxmediadrmdefs.h>

const TInt KGlxDrmIconSize = 16;
const TInt KGlxDrmIconBorder = 0;

// ---------------------------------------------------------------------------
// 1st phase constructor
// ---------------------------------------------------------------------------
//
EXPORT_C CGlxDrmIconManager* CGlxDrmIconManager::NewL( MGlxMediaList& aMediaList,
                                                MGlxVisualList& aVisualList)
    {
    CGlxDrmIconManager* self = 
            new(ELeave)CGlxDrmIconManager(aMediaList, aVisualList);
    CleanupStack::PushL(self);
    self->ConstructL();
    CleanupStack::Pop(self);
    return self;
    }


// ---------------------------------------------------------------------------
// Destructor
// ---------------------------------------------------------------------------
//  
EXPORT_C CGlxDrmIconManager::~CGlxDrmIconManager()
    {
    iMediaList.RemoveMediaListObserver(this);
    iVisualList.RemoveObserver(this);
    
    iThumbnailIcons.Close();
    
    if(iDRMUtility)
        {
        iDRMUtility->Close();
        }
    
    iValidDRMItems.Close();
    iInvalidDRMItems.Close();
    }

// ---------------------------------------------------------------------------
//  RemoveOverlayIcon
// ---------------------------------------------------------------------------
//  
void CGlxDrmIconManager::RemoveOverlayIcon(TInt aIndex, 
                                                TBool aInvalidIcon)
    {
    if(aInvalidIcon)
        {
        iVisualList.SetIconVisibility( aIndex,
                 *iDRMRightsExpiredTexture, EFalse );
        }
    else
        {
        iVisualList.SetIconVisibility( aIndex,
                 *iDRMSendForbidTexture, EFalse );
        }
        
    }
    
// ---------------------------------------------------------------------------
//  AddOverlayIconL
// ---------------------------------------------------------------------------
//    
void CGlxDrmIconManager::AddOverlayIconsL()
    {
    TRACER("CGlxDrmIconManager::AddOverlayIconsL");
    TInt itemCount = iMediaList.Count();
    for(TInt i = 0; i < itemCount; i++)
        {
        CAlfVisual* vis = iVisualList.Visual(i);
        if(vis)
            {
            // recheck rights as status may have changed
            CheckDRMRightsL(vis, i);
            }
        }
    }

// ---------------------------------------------------------------------------
// HandleItemAddedL
// ---------------------------------------------------------------------------
//
void CGlxDrmIconManager::HandleItemAddedL(TInt /*aStartIndex*/, 
                    TInt /*aEndIndex*/, MGlxMediaList* /*aList*/)
    {
    // No implementation
    }

// ---------------------------------------------------------------------------
// HandleMediaL
// ---------------------------------------------------------------------------
//
void CGlxDrmIconManager::HandleMediaL(TInt /*aListIndex*/, 
                                            MGlxMediaList* /*aList*/)
    {
    // No implementation
    }

// ---------------------------------------------------------------------------
// void CGlxDrmIconManager::HandleItemRemovedL(TInt /*aStartIndex*/, 

// ---------------------------------------------------------------------------
//
void CGlxDrmIconManager::HandleItemRemovedL(TInt /*aStartIndex*/, 
                        TInt /*aEndIndex*/, MGlxMediaList* /*aList*/)
    {
    // No implementation
    }
    
// ---------------------------------------------------------------------------
// HandleItemModifiedL
// ---------------------------------------------------------------------------
//
void CGlxDrmIconManager::HandleItemModifiedL(
        const RArray<TInt>& /*aItemIndexes*/, MGlxMediaList* /*aList*/)
    {
    // No implementation
    }
   
// ---------------------------------------------------------------------------
// HandleAttributesAvailableL
// ---------------------------------------------------------------------------
//
void CGlxDrmIconManager::HandleAttributesAvailableL(TInt aItemIndex,     
    const RArray<TMPXAttribute>& aAttributes, MGlxMediaList* /*aList*/)
    {
    TIdentityRelation<TMPXAttribute> match(&TMPXAttribute::Match);
	if (aAttributes.Find(KMPXMediaDrmProtected, match) != KErrNotFound) 
		{	
	    // check if we have DRM attributes
	    CAlfVisual* vis = iVisualList.Visual(aItemIndex);
	    if(vis)
	    	{
	    	CheckDRMRightsL(vis, aItemIndex, EFalse);
	    	}
		}
    }
        
// ---------------------------------------------------------------------------
// HandleFocusChangedL
// ---------------------------------------------------------------------------
//
void CGlxDrmIconManager::HandleFocusChangedL(
        NGlxListDefs::TFocusChangeType /*aType*/, 
        TInt /*aNewIndex*/, TInt /*aOldIndex*/, MGlxMediaList* /*aList*/)
    {
    // No implementation
    }

// ---------------------------------------------------------------------------
// HandleItemSelectedL
// ---------------------------------------------------------------------------
//
void CGlxDrmIconManager::HandleItemSelectedL(TInt /*aIndex*/, 
                        TBool /*aSelected*/, MGlxMediaList* /*aList*/)
    {
    // No implementation
    }

// ---------------------------------------------------------------------------
// HandleMessageL
// ---------------------------------------------------------------------------
//
void CGlxDrmIconManager::HandleMessageL(const CMPXMessage& /*aMessage*/, 
                                                    MGlxMediaList* /*aList*/)
    {
    // No implementation
    }


// ---------------------------------------------------------------------------
// HandleFocusChangedL
// ---------------------------------------------------------------------------
//
void CGlxDrmIconManager::HandleFocusChangedL( TInt /*aFocusIndex*/, 
    TReal32 /*aItemsPerSecond*/, MGlxVisualList* /*aList*/,
    NGlxListDefs::TFocusChangeType /*aType*/ )
    {
    // No implementation
    }
    
// ---------------------------------------------------------------------------
// HandleSizeChanged
// ---------------------------------------------------------------------------
//
void CGlxDrmIconManager::HandleSizeChanged( const TSize& /*aSize*/, 
    MGlxVisualList* /*aList*/ )
    {
    // No implementation
    }
    
// ---------------------------------------------------------------------------
// HandleVisualRemoved
// ---------------------------------------------------------------------------
//
void CGlxDrmIconManager::HandleVisualRemoved( 
    const CAlfVisual* /*aVisual*/,  MGlxVisualList* /*aList*/ )
    {
    // No implementation
    }
    
// ---------------------------------------------------------------------------
// HandleVisualAddedL
// ---------------------------------------------------------------------------
//
void CGlxDrmIconManager::HandleVisualAddedL( CAlfVisual* aVisual, 
    TInt aIndex, MGlxVisualList* /*aList*/ )
    {
    if(aIndex >= 0 && aIndex < iMediaList.Count() )
        {
        CheckDRMRightsL(aVisual, aIndex);
        }
    }

// ---------------------------------------------------------------------------
// Constructor
// ---------------------------------------------------------------------------
//  
CGlxDrmIconManager::CGlxDrmIconManager(MGlxMediaList& aMediaList, 
                                            MGlxVisualList& aVisualList)
    : CGlxIconManager(aMediaList, aVisualList)
    {
    // No implementation
    }

// ---------------------------------------------------------------------------
// 2nd phase construction
// ---------------------------------------------------------------------------
//  
void CGlxDrmIconManager::ConstructL()
    {
    TRACER("CGlxDrmIconManager::ConstructL");
    BaseConstructL();
    
    TFileName mifFile( KDC_APP_BITMAP_DIR );
    mifFile.Append( KGlxIconsFilename );
       
    GLX_LOG_INFO("CGlxDrmIconManager::ConstructL create valid icon");   
    // ask texture manager to create DRM valid icon
    iDRMSendForbidTexture = &(iUiUtility->GlxTextureManager().
             CreateIconTextureL( EMbmGlxiconsQgn_prop_drm_rights_valid_super, 
                            mifFile, TSize( KGlxDrmIconSize, KGlxDrmIconSize ) ) );
    GLX_LOG_INFO("CGlxDrmIconManager::ConstructL create invalid icon");                            
    
    // ask texture manager to create DRM invalid icon                        
    iDRMRightsExpiredTexture = &(iUiUtility->GlxTextureManager().
             CreateIconTextureL( EMbmGlxiconsQgn_prop_drm_rights_exp_super, 
                            mifFile, TSize( KGlxDrmIconSize, KGlxDrmIconSize ) ) );
    
    
    
    // add as observers
    iMediaList.AddMediaListObserverL(this); 
    iVisualList.AddObserverL(this);
    
    GLX_LOG_INFO("CGlxDrmIconManager::ConstructL create DRM utility");
    iDRMUtility = CGlxDRMUtility::InstanceL();
    
    // check for any visual already present in list
    TInt itemCount = iMediaList.Count();
    for(TInt i = 0; i < itemCount; i++)
        {
        CAlfVisual* vis = iVisualList.Visual( i );
        if(vis)
            {
            CheckDRMRightsL(vis, i);
            }
        }
        
    }

// ---------------------------------------------------------------------------
// IconAlreadyAdded
// ---------------------------------------------------------------------------
//  
TInt CGlxDrmIconManager::ThumbnailIconArrayPos(TIconInfo& aIconInfo)
    {
    // check if icon already generated
    TInt pos = KErrNotFound;
    TInt count = iThumbnailIcons.Count();
    for(TInt i=0; i<count; i++)
        {
        if((aIconInfo.bmpfile==iThumbnailIcons[i].bmpfile) &&
            (aIconInfo.bitmapId==iThumbnailIcons[i].bitmapId))
            {
            pos = i;
            break;
            }
        }
    return pos;
    }
    
// ---------------------------------------------------------------------------
// CheckDRMRightsL
// ---------------------------------------------------------------------------
//       
void CGlxDrmIconManager::CheckDRMRightsL(CAlfVisual* /*aVisual*/,
                                    TInt aIndex, TBool aForceIcon)
    {
    TRACER("CGlxDrmIconManager::CheckDRMRightsL");
    const TGlxMedia&  item = iMediaList.Item(aIndex);
    TGlxMediaId id = item.Id();
    
    GLX_LOG_INFO1("CGlxDrmIconManager::CheckDRMRightsL item idx (%d)",aIndex);
    // Do not assume DRM protected by default. In default case add no icon.
    // So cannot use TGlxMedia::IsDrmProtected()
    TBool drm = EFalse;
    if(item.GetDrmProtected(drm) && drm)
        {
        const TDesC& uri = item.Uri();
        if(uri.Length() > 0)
            {
            TGlxVisualIcon iconType;        
            if(iDRMUtility->IsForwardLockedL(uri))
                {
                GLX_LOG_INFO("CGlxDrmIconManager::CheckDRMRightsL forward locked");
                if(aForceIcon || !ShouldHaveIcon(id, iconType))
                    {
                    GLX_LOG_INFO("CGlxDrmIconManager::CheckDRMRightsL forward locked add icon");
                    AddValidIconL(id);
                    iVisualList.AddIconL( aIndex, *iDRMSendForbidTexture, 
                        NGlxIconMgrDefs::EGlxIconBottomRight, ETrue, EFalse, KGlxDrmIconBorder );
                        
                    iVisualList.SetIconVisibility( aIndex, *iDRMSendForbidTexture, ETrue );
                    }
               
                }
            else 
                {
                
                TMPXGeneralCategory  cat = item.Category();
                    
                TBool checkViewRights = (cat==EMPXImage);
                
                if(iDRMUtility->CheckOpenRightsL(uri, checkViewRights))
                    {
                    GLX_LOG_INFO("CGlxDrmIconManager::CheckDRMRightsL valid rights");
                    if(aForceIcon ||!ShouldHaveIcon(id, iconType))
                        {
                        GLX_LOG_INFO("CGlxDrmIconManager::CheckDRMRightsL valid rights add icon");
                        AddValidIconL(id);
                        iVisualList.AddIconL( aIndex, *iDRMSendForbidTexture, 
                                            NGlxIconMgrDefs::EGlxIconBottomRight, 
                                            ETrue, EFalse, KGlxDrmIconBorder );
                                            
                        iVisualList.SetIconVisibility( aIndex, *iDRMSendForbidTexture, ETrue );
                        }
                    }
                 else
                    {
                    GLX_LOG_INFO("CGlxDrmIconManager::CheckDRMRightsL invalid rights");
                    
                    if(aForceIcon ||!ShouldHaveIcon(id, iconType))
                        {
                        iVisualList.RemoveIcon( aIndex, *iDRMSendForbidTexture );
                        GLX_LOG_INFO("CGlxDrmIconManager::CheckDRMRightsL add invalid icon");
                        AddInvalidIconL(id);
                        iVisualList.AddIconL( aIndex, *iDRMRightsExpiredTexture, 
                                            NGlxIconMgrDefs::EGlxIconBottomRight, 
                                                ETrue, EFalse, KGlxDrmIconBorder );
                
                        iVisualList.SetIconVisibility( aIndex, *iDRMRightsExpiredTexture, ETrue );                                                
                        }
                    }
                 }
            }
        }
    }

// ---------------------------------------------------------------------------
// AddValidIcon
// ---------------------------------------------------------------------------
//           
void CGlxDrmIconManager::AddValidIconL(TGlxMediaId& aId)
    {
    TInt count = iValidDRMItems.Count();
    TBool present = EFalse;
    for(TInt i=0; i<count; i++)
        {
        if(iValidDRMItems[i]==aId)
            {
            present = ETrue;
            break;
            }
        }
    
    if(present == EFalse)
        {
        iValidDRMItems.AppendL(aId);
        }
    
    // remove from list of items with broken thumbnails
    // if necessary    
    count = iInvalidDRMItems.Count();
    for(TInt j=0;j<count;j++)
        {
        if(iInvalidDRMItems[j]==aId)
            {
            iInvalidDRMItems.Remove(j);
            break;
            }
        }
    }

// ---------------------------------------------------------------------------
// AddInvalidIcon
// ---------------------------------------------------------------------------
//          
void CGlxDrmIconManager::AddInvalidIconL(TGlxMediaId& aId)
    {
    TInt count = iInvalidDRMItems.Count();
    TBool present = EFalse;
    for(TInt i=0; i<count; i++)
        {
        if(iInvalidDRMItems[i]==aId)
            {
            present = ETrue;
            break;
            }
        }
    
    if(present == EFalse)
        {
        iInvalidDRMItems.AppendL(aId);
        }
    
    // remove from list of items with broken thumbnails
    // if necessary    
    count = iValidDRMItems.Count();
    for(TInt j=0;j<count;j++)
        {
        if(iValidDRMItems[j]==aId)
            {
            iValidDRMItems.Remove(j);
            break;
            }
        }
    }

// ---------------------------------------------------------------------------
// ShouldHaveIcon
// ---------------------------------------------------------------------------
//       
TBool CGlxDrmIconManager::ShouldHaveIcon(TGlxMediaId& aId, 
                                        TGlxVisualIcon& aType)
    {
    TBool hasIcon = EFalse;
    
    TInt count = iValidDRMItems.Count();
    for(TInt i=0; i<count; i++)
        {
        if(iValidDRMItems[i]==aId)
            {
            hasIcon = ETrue;
            aType = EDRMRightsValidIcon;
            break;
            }
        }
        
    if(hasIcon == EFalse)
        {
        count = iInvalidDRMItems.Count();
        for(TInt i=0; i<count; i++)
            {
            if(iInvalidDRMItems[i]==aId)
                {
                hasIcon = ETrue;
                aType = EDRMRightsInvalidIcon;
                break;
                }
            }
        }
    return hasIcon;
    }