/*

* 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 "glxcollectionplugincamera.h"

#include <e32cmn.h>

#include <mpxcollectionpath.h>

#include <mpxcollectionpluginobserver.h>

#include <mpxcmn.h>

#include <mpxcollectionmessagedefs.h>

#include <glxcollectionmessagedefs.h>  

#include <mpxmediageneraldefs.h>

#include <mpxmediacontainerdefs.h>

#include <mpxmedia.h>

#include <mpxmediaarray.h>

#include <glxmediageneraldefs.h>

#include <glxcollectiongeneraldefs.h>

#include <glxplugincamera.rsg>

#include <StringLoader.h>

#include <glxmediacollectioninternaldefs.h>

#include <glxpanic.h>

#include <mglxdatasource.h>

#include <glxrequest.h>

#include <glxidlistrequest.h>

#include <glxfilterfactory.h>

#include <glxlog.h>

#include <glxtracer.h>

#include "glxcollectionplugincamera.hrh"

/**

 * @internal reviewed 14/06/2007 by Alex Birkett

 */

// CONSTANTS

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

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

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

// Two-phased constructor.

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

//

CGlxCollectionPluginCamera* CGlxCollectionPluginCamera::NewL(TAny* aObs)

    {

    CGlxCollectionPluginCamera* self = new (ELeave) CGlxCollectionPluginCamera(

                            static_cast<MMPXCollectionPluginObserver*>(aObs));

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

    }

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

// Destructor

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

//

CGlxCollectionPluginCamera::~CGlxCollectionPluginCamera()

    {

    }

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

// Constructor

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

//

CGlxCollectionPluginCamera::CGlxCollectionPluginCamera(

    MMPXCollectionPluginObserver* aObs)

    {

    iObs = aObs;

    }

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

// ConstructL

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

//

void CGlxCollectionPluginCamera::ConstructL()

    {

    iDataSource = MGlxDataSource::OpenDataSourceL(KGlxDefaultDataSourceUid, *this);

	}

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

// CpiAttributeAdditionalAttributes

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

//

void CGlxCollectionPluginCamera::CpiAttributeAdditionalAttributes(const TMPXAttribute& aCpiAttribute, RArray<TMPXAttribute>& aAttributeArray)

	{

    TRACER("CGlxCollectionPluginCamera::CpiAttributeAdditionalAttributes");

    // Only need to process KGlxMediaCollectionPluginSpecificSubTitle here as all the other attributes

    // are reading straight from resource files KGlxMediaCollectionPluginSpecificSubTitle 

    // requires a image and the Video count in the collection

	if (aCpiAttribute == KGlxMediaCollectionPluginSpecificSubTitle)

		{

		// need to add the usage count. but check first if it is already present

		TInt attrCount = aAttributeArray.Count();

		TBool found = EFalse;

#ifdef GLX_SUB_TITLE_REL8

		TBool videofound = EFalse;

		TBool imagefound = EFalse;		

		for ( TInt index = 0 ; index < attrCount ; index++)

			{

			if (aAttributeArray[index] == KMPXMediaGeneralCount)

				{

				found = ETrue;	            

				}

			else if (aAttributeArray[index] == KGlxMediaItemTypeVideo)

				{

				videofound = ETrue;	            

				}

			else if(aAttributeArray[index] == KGlxMediaItemTypeImage)	            

				{

				imagefound = ETrue;

				}

		if (!videofound)

			{

			aAttributeArray.Append(KGlxMediaItemTypeVideo);

			}

		if (!imagefound)	        

			{

			aAttributeArray.Append(KGlxMediaItemTypeImage);

			}

		if (!found)

			{

			aAttributeArray.Append(KMPXMediaGeneralCount);

			}

#else

	for ( TInt index = 0 ; index < attrCount ; index++)

			{

			if (aAttributeArray[index] == KMPXMediaGeneralCount)

				{

				found = ETrue;	            

				}			

			}			

		if (!found)

			{

			aAttributeArray.Append(KMPXMediaGeneralCount);

			}       

#endif						

		}

	}

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

// HandleCpiAttributeResponseL

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

// 

void CGlxCollectionPluginCamera::HandleCpiAttributeResponseL(CMPXMedia* aResponse, TArray<TMPXAttribute> aCpiAttributes, TArray<TGlxMediaId> /* aMediaIds */)

	{

    TRACER("CGlxCollectionPluginCamera::HandleCpiAttributeResponseL");

    _LIT(KResourceFile, "z:glxplugincamera.rsc");

	TInt count = aCpiAttributes.Count();

	for (TInt index = 0; index < count ; index++)

	    {

	    const TMPXAttribute attr = aCpiAttributes[index];

	    if (attr == KGlxMediaCollectionPluginSpecificSubTitle)

	        {

	        GLX_LOG_INFO("Attribute is :Subtitle");

	        if (!aResponse->IsSupported(KMPXMediaGeneralCount))

	            {

	            User::Leave(KErrNotSupported);

	            }

            else

				{

				TInt usageCount = aResponse->ValueTObjectL<TInt>(KMPXMediaGeneralCount);

				HBufC* tempTitle = NULL;

#ifdef GLX_SUB_TITLE_REL8

			if (!aResponse->IsSupported(KGlxMediaItemTypeImage))

	            {

	            User::Leave(KErrNotSupported);

	            }

			if (!aResponse->IsSupported(KGlxMediaItemTypeVideo))

	            {

	            User::Leave(KErrNotSupported);

	            }

				TInt videoCount = aResponse->ValueTObjectL<TInt>(KGlxMediaItemTypeVideo);

				TInt imageCount = aResponse->ValueTObjectL<TInt>(KGlxMediaItemTypeImage);

				//No Images or Videos

				if ((0 == videoCount) && (0 == imageCount ))

					{	

					GLX_LOG_INFO("ImageCount and VideoCount is 0");

					tempTitle = LoadLocalizedStringLC(KResourceFile, R_CAMERA_SUB_TITLE_NO_IMAGE_NO_VIDEO);

					aResponse->SetTextValueL(attr, *tempTitle);	

					}

				// 1 Image and multi/0 Videos                		

				else if (1 == imageCount) 

					{

					GLX_LOG_INFO1("ImageCount is 0 and VideoCount is %d",videoCount);

					tempTitle = LoadLocalizedStringLC(KResourceFile, R_CAMERA_SUB_TITLE_ONE_IMAGE_MULTI_VIDEO);

					TPtr formatString = tempTitle->Des();

					// Now create a buffer that will contain the result. needs to be length of format string plus a few extra for the number

					HBufC* title = HBufC::NewLC(formatString.Length() + 10);

					TPtr ptr = title->Des();

					StringLoader::Format(ptr, formatString, -1, videoCount);

					// Set the title in the response.	

					aResponse->SetTextValueL(attr, *title);

					CleanupStack::PopAndDestroy(title);

					}

				// Multi/0 Image and 1 Video					

				else if (1 == videoCount)

					{

					GLX_LOG_INFO1("ImageCount is %d and VideoCount is 0",imageCount);

					tempTitle = LoadLocalizedStringLC(KResourceFile, R_CAMERA_SUB_TITLE_MULTI_IMAGE_ONE_VIDEO);                	

					TPtr formatString = tempTitle->Des();

					// Now create a buffer that will contain the result. needs to be length of format string plus a few extra for the number

					HBufC* title = HBufC::NewLC(formatString.Length() + 10);

					TPtr ptr = title->Des();

					StringLoader::Format(ptr, formatString, -1, imageCount);

					// Set the title in the response.	

					aResponse->SetTextValueL(attr, *title);

					CleanupStack::PopAndDestroy(title);

					}

				// Multi Image and Multi Video

				else 

					{

					GLX_LOG_INFO2("ImageCount is %d,VideoCount is %d",imageCount,videoCount);

					tempTitle = LoadLocalizedStringLC(KResourceFile, R_CAMERA_SUB_TITLE_MULTI_IMAGE_MULTI_VIDEO);                	

					TPtr formatString = tempTitle->Des();	

					HBufC* title = HBufC::NewLC(formatString.Length() + 10);

					TPtr ptr = title->Des();

					HBufC* title1 = HBufC::NewLC(formatString.Length() + 10);

					TPtr ptr1 = title1->Des();

					StringLoader::Format(ptr, formatString, 0, imageCount);

					StringLoader::Format(ptr1, ptr, 1, videoCount);	

					// Set the title in the response.	

					aResponse->SetTextValueL(attr, *title1);

					CleanupStack::PopAndDestroy(title1);

					CleanupStack::PopAndDestroy(title);

					}	

				CleanupStack::PopAndDestroy(tempTitle);

#else

				if(0 == usageCount)

            		{

                	tempTitle = LoadLocalizedStringLC(KResourceFile, R_CAMERA_SUB_TITLE_NO_IMAGE_NO_VIDEO);                	

                	// Set the title in the response.

            		aResponse->SetTextValueL(attr, *tempTitle);  

            		CleanupStack::PopAndDestroy(tempTitle);

            		continue;                	

            		}

				// Get the format string

				else if (1 == usageCount)

                    {

                    tempTitle = LoadLocalizedStringLC(KResourceFile, R_CAMERA_SUB_TITLE_SINGLE);

                    }

                else

                    {

                    tempTitle = LoadLocalizedStringLC(KResourceFile, R_CAMERA_SUB_TITLE_MULTI);

                    }

                TPtr formatString = tempTitle->Des();

                // Now create a buffer that will contain the result. needs to be length of format string plus a few extra for the number

                HBufC* title = HBufC::NewLC(formatString.Length() + 10);

                TPtr ptr = title->Des();

                StringLoader::Format(ptr, formatString, -1, usageCount);

                // Set the title in the response.

                aResponse->SetTextValueL(attr, *title);    

                CleanupStack::PopAndDestroy(title);

                CleanupStack::PopAndDestroy(tempTitle);	

#endif                			

				}

	        }

	    else if (attr == KGlxMediaCollectionPluginSpecificSelectMediaPopupTitle)

	        {

	        GLX_LOG_INFO("Attribute is :MediaPopupTitle");

	        User::Leave(KErrNotSupported);

	        }

	    else if (attr == KGlxMediaCollectionPluginSpecificNewMediaItemTitle)

	        {

	        GLX_LOG_INFO("Attribute is :NewMediaItemTitle");

	        User::Leave(KErrNotSupported);

	        }

	    else if (attr == KGlxMediaCollectionPluginSpecificDefaultMediaTitle)

	        {

	        GLX_LOG_INFO("Attribute is :DefaultMediaTitle");

	        User::Leave(KErrNotSupported);

	        }

	    else if (attr == KMPXMediaGeneralTitle)

	        {

	        GLX_LOG_INFO("Attribute is :GenrealTitle");

	        HBufC* title = LoadLocalizedStringLC(KResourceFile, R_CAMERA_GENERAL_TITLE);

            // Set the title in the response.

            aResponse->SetTextValueL(attr, *title);  

            CleanupStack::PopAndDestroy(title); 

	        }

	    }

	aResponse->Delete(KGlxMediaItemTypeImage);

	aResponse->Delete(KGlxMediaItemTypeVideo);

	}

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

// IsUpdateMessageIgnoredL

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

// 

TBool CGlxCollectionPluginCamera::IsUpdateMessageIgnoredL(CMPXMessage& /*aMessage*/)

	{

	TRACER("CGlxCollectionPluginCamera::IsUpdateMessageIgnoredL");

	TBool ignore = EFalse;

	return ignore;

	}

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

// DefaultFilter

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

// 

TGlxFilterProperties CGlxCollectionPluginCamera::DefaultFilter(TInt aLevel)

    {

    __ASSERT_DEBUG(( (aLevel == KGlxCollectionRootLevel) || (aLevel == KGlxCollectionRootLevel+1) 

    || (aLevel == KGlxCollectionRootLevel+2) ), Panic(EGlxPanicInvalidPathLevel));

    TGlxFilterProperties filterProperties;

    filterProperties.iSortOrder = EGlxFilterSortOrderModifiedDate;

    filterProperties.iSortDirection = EGlxFilterSortDirectionDescending;

   filterProperties.iOrigin = EGlxFilterOriginCamera;

    return filterProperties;

    }	

// End of file