/*
* 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:    This class browses file system
*
*/




// INCLUDE FILES

#include "glxcollectionpluginbase.h"

#include <f32file.h>
#include <glxfilterfactory.h>
#include <glxlog.h>
#include <glxmediageneraldefs.h>
#include <glxthumbnailattributeinfo.h>
#include <mpxcollectionmessagedefs.h>
#include <mpxcollectionpath.h>
#include <mpxcollectionpluginobserver.h>
#include <mpxmedia.h>
#include <mpxmediadrmdefs.h>
#include <mpxmediageneraldefs.h>
#include <mpxmessagegeneraldefs.h>
#include <glxtracer.h>

#include "glxcommandrequest.h"
#include "glxgetrequest.h"
#include "glxidlistrequest.h"
#include "glxrequest.h"
#include "glxstringcache.h"
#include "glxthumbnailrequest.h"
#include "mglxdatasource.h"


// CONSTANTS
const TGlxThumbnailRequest::TPriorityMode KGlxDefaultThumbnailPriority = TGlxThumbnailRequest::EPrioritizeQuality;

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

// ----------------------------------------------------------------------------
// Constructor
// ----------------------------------------------------------------------------
//
EXPORT_C CGlxCollectionPluginBase::CGlxCollectionPluginBase()
    {
    TRACER("CGlxCollectionPluginBase::CGlxCollectionPluginBase()");
    }
// ----------------------------------------------------------------------------
// Destructor
// ----------------------------------------------------------------------------
//
EXPORT_C CGlxCollectionPluginBase::~CGlxCollectionPluginBase()
    {
    TRACER("CGlxCollectionPluginBase::~CGlxCollectionPluginBase()");
    if (iDataSource)
	    {
    	iDataSource->Close(*this);
	    }
	delete iPath;
	delete iStringCache;
    } 


// ----------------------------------------------------------------------------
// Executes a command on the selected collection
// ----------------------------------------------------------------------------
//
EXPORT_C void CGlxCollectionPluginBase::CommandL(TMPXCollectionCommand /*aCmd*/, TInt /*aArg*/)
    {
    TRACER("void CGlxCollectionPluginBase::CommandL(TMPXCollectionCommand /*aCmd*/, TInt /*aArg*/)");
    User::Leave(KErrNotSupported);
    }

// ----------------------------------------------------------------------------
// Executes a command on the selected collection
// ----------------------------------------------------------------------------
//
EXPORT_C void CGlxCollectionPluginBase::CommandL(CMPXCommand& aCmd)
    {
    TRACER("void CGlxCollectionPluginBase::CommandL(CMPXCommand& aCmd)");
    CGlxCommandRequest* request = CGlxCommandRequest::NewL(aCmd, Uid(), *this);
    iDataSource->DataSourceRequestL(request, *this);
    }

// ----------------------------------------------------------------------------
// Navigates to the given path
// ----------------------------------------------------------------------------
//
EXPORT_C void CGlxCollectionPluginBase::OpenL(const CMPXCollectionPath& aPath,
                   const TArray<TMPXAttribute>& /*aAttrs*/,
                   CMPXFilter* aFilter)
    {
    TRACER("void CGlxCollectionPluginBase::OpenL()");
    iPath = CMPXCollectionPath::NewL(aPath);
    if(aFilter)
        {
        if(aFilter->IsSupported(KGlxFilterGeneralNavigationalStateOnly))
            {
            RArray<TMPXItemId> mpxIds;
         	CleanupClosePushL(mpxIds);
            iPath->AppendL(mpxIds.Array());
            iObs->HandleOpen(iPath, KErrNone);
            CleanupStack::PopAndDestroy(&mpxIds);
            delete iPath;
            iPath = NULL;
            return;
            }
        }

    TGlxMediaId targetId(aPath.Id());
    if (aPath.Levels() == KGlxCollectionRootLevel)
        {
        targetId = TGlxMediaId(KGlxCollectionRootId);
        }
    TInt level = aPath.Levels() + 1; // filter applies to new level we are retrieving
    CMPXFilter* filter = TGlxFilterFactory::CreateCombinedFilterL(DefaultFilter(level), aFilter, EFalse);
    CleanupStack::PushL(filter);
    CGlxIdListRequest* request = CGlxIdListRequest::NewL(targetId, Uid(), filter, *iPath);
    CleanupStack::PopAndDestroy(filter);
    iDataSource->DataSourceRequestL(request, *this);
    }

// ----------------------------------------------------------------------------
// Extended properties of the current file (async)
// ----------------------------------------------------------------------------
//
EXPORT_C void CGlxCollectionPluginBase::MediaL(const CMPXCollectionPath& aPath, 
                        const TArray< TMPXAttribute >& aAttrs,
                        const TArray<TCapability>& aCaps,
                        CMPXAttributeSpecs* aSpecs)
    {
    TRACER("void CGlxCollectionPluginBase::MediaL()");
	__ASSERT_DEBUG(aPath.Count(), Panic(EGlxPanicMediaRequestedWithEmptyPath));
	
	TInt bitmapId = 0;
    
    TInt count = aAttrs.Count();
    for( TInt i = 0; i < count; ++i )
        {
        if( KGlxMediaIdThumbnail == aAttrs[i].ContentId() )
            {
            bitmapId = aAttrs[i].AttributeId();
            }
        }
        
    CGlxRequest* request = NULL;
    if(aSpecs && bitmapId)
    	{
	    TBool clientHasDRM = EFalse;
	    for ( TInt i = 0; i < aCaps.Count(); ++i)
	    	{
	    	if(aCaps[i] == ECapabilityDRM)
	    		{
	    		clientHasDRM = ETrue;
	    		break;
	    		}
	    	}
	    TSize size(0,0);
	    TGlxThumbnailRequest::TPriorityMode priority = KGlxDefaultThumbnailPriority;
	    TGlxThumbnailFilter filter = EGlxThumbnailFilterNone;
	    TInt bitmapHandle = 0;
	    TRect cropRect;
		const TMPXAttributeData sizeAttrib = { KGlxMediaIdThumbnail , KGlxAttribSpecThumbnailSize };
		const TMPXAttributeData priorityAttrib = { KGlxMediaIdThumbnail , KGlxAttribSpecThumbnailQualityOverSpeed };
		const TMPXAttributeData bitmapAttrib = { KGlxMediaIdThumbnail , KGlxAttribSpecThumbnailBitmapHandle };
		const TMPXAttributeData cropAttrib = { KGlxMediaIdThumbnail , KGlxAttribSpecThumbnailCroppingRect };
		const TMPXAttributeData filterAttrib = { KGlxMediaIdThumbnail , KGlxAttribSpecThumbnailFiltering };

	    if(aSpecs->IsSupported(sizeAttrib))
	    	{
	    	size = aSpecs->ValueTObjectL<TSize>(sizeAttrib);
	    	}
	    if(aSpecs->IsSupported(priorityAttrib))
	    	{
	    	priority = aSpecs->ValueTObjectL<TBool>(priorityAttrib) ? TGlxThumbnailRequest::EPrioritizeQuality : TGlxThumbnailRequest::EPrioritizeSpeed;
	    	}
	    if(aSpecs->IsSupported(bitmapAttrib))
	    	{
	    	bitmapHandle = aSpecs->ValueTObjectL<TInt>(bitmapAttrib);
	    	}
	    if(aSpecs->IsSupported(cropAttrib))
	    	{
	    	cropRect = aSpecs->ValueTObjectL<TRect>(cropAttrib);
	    	}
	    if(aSpecs->IsSupported(filterAttrib))
	    	{
	    	filter = aSpecs->ValueTObjectL<TGlxThumbnailFilter>(filterAttrib);
	    	}
	    
	    	
	    TGlxThumbnailRequest tnRequest(TGlxMediaId(aPath.Id()), size, priority, bitmapHandle, clientHasDRM, cropRect, filter);
        CMPXFilter* defFilter = TGlxFilterFactory::CreateCombinedFilterL(DefaultFilter(aPath.Levels()), NULL, EFalse);
        CleanupStack::PushL(defFilter);
	    request = CGlxThumbnailRequest::NewL(tnRequest, Uid(), bitmapId, defFilter);
        CleanupStack::PopAndDestroy(defFilter);
        
        CleanupStack::PushL(request);
        
 	    CGlxtnFileInfo* tnFileInfo = new (ELeave) CGlxtnFileInfo;
	    CleanupStack::PushL(tnFileInfo);
	    
        TInt countInfo(0);
	    
	    if(aSpecs->IsSupported(KMPXMediaGeneralSize))
	    	{
	    	tnFileInfo->iFileSize = aSpecs->ValueTObjectL<TUint>(KMPXMediaGeneralSize);
	    	countInfo++;
	    	}
	    if(aSpecs->IsSupported(KGlxMediaGeneralLastModifiedDate))
	    	{
	    	tnFileInfo->iFileTime = aSpecs->ValueTObjectL<TInt64>(KGlxMediaGeneralLastModifiedDate);
	    	countInfo++;
	    	}
	    if(aSpecs->IsSupported(KMPXMediaDrmProtected))
	    	{
	    	tnFileInfo->iIsProtected = aSpecs->ValueTObjectL<TBool>(KMPXMediaDrmProtected);
	    	countInfo++;
	    	}
	    if(aSpecs->IsSupported(KMPXMediaGeneralUri))
	    	{
	    	tnFileInfo->SetFilePathL(aSpecs->ValueText(KMPXMediaGeneralUri));
	    	countInfo++;
	    	}
	    if(aSpecs->IsSupported(KMPXMediaGeneralCategory))
	    	{
	    	TMPXGeneralCategory category = aSpecs->ValueTObjectL<TMPXGeneralCategory>(KMPXMediaGeneralCategory);
	    	if( EMPXVideo == category )
	    	    {
    	    	tnFileInfo->iIsVideo = ETrue;
    	    	countInfo++;
	    	    }
	    	else if( EMPXImage == category )
	    	    {
    	    	tnFileInfo->iIsVideo = EFalse;
    	    	countInfo++;
	    	    }
	    	}
	    	
	    const TInt KGlxRequiredCountInfo = 5;
        CGlxThumbnailRequest* requestTn = static_cast<CGlxThumbnailRequest*>(request);
        if( KGlxRequiredCountInfo == countInfo )
            {
            requestTn->SetThumbnailInfo(tnFileInfo);
            CleanupStack::Pop(tnFileInfo);
            }
        else
            {
            CleanupStack::PopAndDestroy(tnFileInfo);
            }
        
        CleanupStack::Pop(request);
    	}
	else
		{
		request = GetRequestFactoryL(aPath, aAttrs);
		}
    iDataSource->DataSourceRequestL(request, *this);
		
    }
        
// ----------------------------------------------------------------------------
// Cancel outstanding request
// ----------------------------------------------------------------------------
//
EXPORT_C void CGlxCollectionPluginBase::CancelRequest()
    {
    TRACER("void CGlxCollectionPluginBase::CancelRequest()");
    iDataSource->CancelRequest(*this);
    }

// ----------------------------------------------------------------------------
// Adds an item to the collection
// ----------------------------------------------------------------------------
//
EXPORT_C void CGlxCollectionPluginBase::AddL(const CMPXMedia& /*aNewMedia*/)
    {
    TRACER("void CGlxCollectionPluginBase::AddL()");
    User::Leave(KErrNotSupported);
    }

// ----------------------------------------------------------------------------
// Remove an item or items under a group from the collection
// ----------------------------------------------------------------------------
//
EXPORT_C void CGlxCollectionPluginBase::RemoveL(const CMPXCollectionPath& /*aPath*/)
    {
    TRACER("void CGlxCollectionPluginBase::RemoveL()");
    User::Leave(KErrNotSupported);
    }

// ----------------------------------------------------------------------------
// Remove an item or items under a group from the collection
// ----------------------------------------------------------------------------
//
EXPORT_C void CGlxCollectionPluginBase::RemoveL(const CMPXMedia& /*aMedia*/)
    {
    TRACER("void CGlxCollectionPluginBase::RemoveL()");
    User::Leave(KErrNotSupported);
    }

// ----------------------------------------------------------------------------
// Sets/updates the media for the item
// ----------------------------------------------------------------------------
//
EXPORT_C void CGlxCollectionPluginBase::SetL(const CMPXMedia& /*aMedia*/)
    {
    TRACER("void CGlxCollectionPluginBase::SetL(const CMPXMedia& /*aMedia*/)");
    User::Leave(KErrNotSupported);
    }

// ----------------------------------------------------------------------------
// FindAllL
// ----------------------------------------------------------------------------
//
EXPORT_C void CGlxCollectionPluginBase::FindAllL(const CMPXMedia& /*aCriteria*/, const TArray<TMPXAttribute>& /*aAttrs*/)
    {
    TRACER("void CGlxCollectionPluginBase::FindAllL()");
    User::Leave(KErrNotSupported);
    }

// ----------------------------------------------------------------------------
// FindAllL
// ----------------------------------------------------------------------------
//
EXPORT_C CMPXMedia* CGlxCollectionPluginBase::FindAllSyncL(const CMPXMedia& /*aCriteria*/,
                                    const TArray<TMPXAttribute>& /*aAttrs*/)
	{
    TRACER("CMPXMedia* CGlxCollectionPluginBase::FindAllSyncL()");
    User::Leave(KErrNotSupported);
    return NULL;
	}

    
// ----------------------------------------------------------------------------
// GetCapabilities
// ----------------------------------------------------------------------------
//
EXPORT_C TCollectionCapability CGlxCollectionPluginBase::GetCapabilities()
	{
    TRACER("TCollectionCapability CGlxCollectionPluginBase::GetCapabilities()");
	return 0;
	}

EXPORT_C void CGlxCollectionPluginBase::HandleResponse(CMPXMedia* aResponse, CGlxRequest* aRequest, const TInt& aError)
	{
    TRACER("void CGlxCollectionPluginBase::HandleResponse()");
	
    if (dynamic_cast<CGlxIdListRequest*>(aRequest))
	// iRequest is a CGlxIdListRequest
	    {
      iObs->HandleOpen(iPath, aError);
      delete iPath;
      iPath = NULL;
	    }
	else if (dynamic_cast<CGlxThumbnailRequest*>(aRequest))
	// iRequest is a CGlxThumbnailRequest
        {
 		iObs->HandleMedia(aResponse, aError); 
	    }
	else if (dynamic_cast<CGlxGetRequest*>(aRequest))
	// iRequest is a CGlxGetRequest
        {
		TInt error = aError;
        CGlxGetRequest* getRequest = static_cast<CGlxGetRequest*>(aRequest);
		TBool b = getRequest->CpiAttributesSet();
        if(b  && ( KErrNone == error ))
        	{
        	TRAP(error, HandleCpiAttributeResponseL(aResponse, getRequest->CpiAttributes(), getRequest->MediaIds().Array()));
        	}
		iObs->HandleMedia(aResponse, error); 
	    }
	else if (dynamic_cast<CGlxCommandRequest*>(aRequest))
	// iRequest is a CGlxCommandRequest
        {
		iObs->HandleCommandComplete(aResponse, aError); 
	    }
	else
		{
		// Other request types not handled
		Panic(EGlxPanicLogicError); 
		}
	}

CGlxRequest* CGlxCollectionPluginBase::GetRequestFactoryL(const CMPXCollectionPath& aPath, const TArray<TMPXAttribute>& aAttrs)
	{
    TRACER("CGlxRequest* CGlxCollectionPluginBase::GetRequestFactoryL()");
	TBool doNotNeedDataSource = EFalse;
	RArray<TGlxMediaId> mediaIdArray;
	
	CleanupClosePushL(mediaIdArray);
	
	if( aPath.Levels() == KGlxCollectionRootLevel)
		{
		__ASSERT_DEBUG(Uid().iUid == (TUint32)aPath.Id(), Panic(EGlxPanicIllegalArgument));
		mediaIdArray.AppendL(TGlxMediaId(KGlxCollectionRootId));
		doNotNeedDataSource = ETrue;
		}
	else
		{
		// Add the media Ids to the iMediaIdArray
		TArray<TInt> selection = aPath.Selection();
		TInt selectedCount = selection.Count();
		if (selectedCount)
		// Items are selected; We require the attributes for the selected items.
			{
			for (TInt i = 0; i < selectedCount; i++)
				{
				const TMPXItemId& itemId = aPath.IdOfIndex(selection[i]);
				mediaIdArray.AppendL(TGlxMediaId(itemId));
				}
			}
		else // No items are selected; We will use the current item
			{
			mediaIdArray.AppendL(TGlxMediaId(aPath.Id()));
			}
		
		}
	
	// Add the attributes to the attributeArray
	RArray<TMPXAttribute> attributeArray;
	CleanupClosePushL(attributeArray);
	RArray<TMPXAttribute> cpiAttributeArray;
	CleanupClosePushL(cpiAttributeArray);
	
	for (TInt i = 0; i < aAttrs.Count(); i++)
		{
        if( KGlxMediaIdCollectionPluginSpecific == aAttrs[i].ContentId())
        	{
			cpiAttributeArray.AppendL(aAttrs[i]);
			CpiAttributeAdditionalAttributes(aAttrs[i], attributeArray);  
			doNotNeedDataSource = EFalse;   	
        	}
        else 
        	{
        	if ( aAttrs[i] == KMPXMediaGeneralCount )
        	    {
        	    doNotNeedDataSource = EFalse;
        	    }
			attributeArray.AppendL(aAttrs[i]);	       	
        	}
		}
	
    CMPXFilter* filter = TGlxFilterFactory::CreateCombinedFilterL(DefaultFilter(aPath.Levels()), NULL, EFalse);
    CleanupStack::PushL(filter);
	CGlxRequest* request = CGlxGetRequest::NewL(mediaIdArray, attributeArray, cpiAttributeArray, Uid(), filter, doNotNeedDataSource); // Array contents ownership transferred
    CleanupStack::PopAndDestroy(filter);
	CleanupStack::Pop(&cpiAttributeArray);
	CleanupStack::Pop(&attributeArray);
	CleanupStack::Pop(&mediaIdArray);
	return request;
	}	


 EXPORT_C void CGlxCollectionPluginBase::HandleMessage(CMPXMessage& aMessage)
	{
    TRACER("void CGlxCollectionPluginBase::HandleMessage(CMPXMessage& aMessage)");
	aMessage.SetTObjectValueL<TUid>(KMPXMessageCollectionId, Uid());
	iObs->HandleMessage(&aMessage, KErrNone);
	}

EXPORT_C TBool CGlxCollectionPluginBase::IsUpdateMessageIgnored(CMPXMessage& /*aMessage*/)
	{
    TRACER("TBool CGlxCollectionPluginBase::IsUpdateMessageIgnored(CMPXMessage& /*aMessage*/)");
	// Default implementation ignores all update messages
	return ETrue;
	}

EXPORT_C void CGlxCollectionPluginBase::CpiAttributeAdditionalAttributes(const TMPXAttribute& /*aCpiAttribute*/, RArray<TMPXAttribute>& /*aAttributeArray*/)
	{
    TRACER("void CGlxCollectionPluginBase::CpiAttributeAdditionalAttributes()");
	// Default implementation does not require additional attributes	
	}

EXPORT_C void CGlxCollectionPluginBase::HandleCpiAttributeResponseL(CMPXMedia* /*aResponse*/, TArray<TMPXAttribute> /*aCpiAttributes*/, TArray<TGlxMediaId> /* aMediaIds */)
	{
    TRACER("void CGlxCollectionPluginBase::HandleCpiAttributeResponseL()");
	// Base class does not support CPI specific attributes, deriving class must override.
	User::Leave(KErrNotSupported);
	}

EXPORT_C HBufC* CGlxCollectionPluginBase::LoadLocalizedStringLC(const TDesC& aResourceFile, const TInt aResourceId)
    {
	TRACER("void CGlxCollectionPluginBase::LoadLocalizedStringLC()");
	
	if (!iStringCache)
        {
        iStringCache = CGlxStringCache::NewL();
        }        
	return (iStringCache->LoadLocalizedStringLC(aResourceFile,aResourceId));
    }
    

EXPORT_C TGlxFilterProperties CGlxCollectionPluginBase::DefaultFilter(TInt /*aLevel*/)
    {
    TRACER("TGlxFilterProperties CGlxCollectionPluginBase::DefaultFilter(TInt /*aLevel*/)");
    TGlxFilterProperties filterProperties;
    filterProperties.iSortOrder = EGlxFilterSortOrderCaptureDate;
    filterProperties.iSortDirection = EGlxFilterSortDirectionDescending;
    
    return filterProperties;
    }
    


// End of file