/*
* 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:    Details commmand handler
*
*/




#include "glxcommandhandlerdetails.h"

#include <AknUtils.h>
#include <bautils.h>

#include <mpxviewutility.h>

#include <data_caging_path_literals.hrh> 	//for gallery related constatns
#include <glxcommandhandlers.hrh> 			//for command id

#include <glxuiutility.h>

#include <glxuistd.h>
#include <glxuiutility.h>
#include <glxuiutilities.rsg>
#include <glxpanic.h>
#include <StringLoader.h>
#include <glxtracer.h>
#include <glxlog.h>
#include <glxicons.mbg>

#include <glxmedia.h> 
#include <glxmedialist.h> 
#include <mpxmediageneraldefs.h>            // for TMPXAttribute
#include <glxattributeretriever.h>          // for CGlxAttributeRetriever 
#include <glxattributecontext.h>            // for CGlxDefaultAttributeContext
#include <glxresourceutilities.h>           // for CGlxResourceUtilities
#include <glxfetchcontextremover.h>         // for TGlxFetchContextRemover

#include <glxviewpluginuids.hrh> //for view plugin implmentation id
#include <glxcollectionpluginimageviewer.hrh>
#include <mpxcollectionutility.h>
#include <glxmetadatadialog.h>              //for metadata dialog
#include <glximgvwrmetadatadialog.h>
#include <glxnavigationalstate.h>
#include <mpxcollectionpath.h>
// ---------------------------------------------------------------------------
// Two-phased constructor.
// ---------------------------------------------------------------------------
//
EXPORT_C CGlxCommandHandlerDetails*
CGlxCommandHandlerDetails::NewL(MGlxMediaListProvider* aMediaListProvider,
		const TDesC& aFileName)
	{
	CGlxCommandHandlerDetails* self = new (ELeave) CGlxCommandHandlerDetails(
			aMediaListProvider);
	CleanupStack::PushL(self);
	self->ConstructL(aFileName);
	CleanupStack::Pop(self);
	return self;
	}

// ---------------------------------------------------------------------------
// C++ default constructor can NOT contain any code, that
// might leave.
// ---------------------------------------------------------------------------
//	
CGlxCommandHandlerDetails::CGlxCommandHandlerDetails(MGlxMediaListProvider* aMediaListProvider )
														:CGlxMediaListCommandHandler(aMediaListProvider)
	{
	//Do nothing
	}			



// ---------------------------------------------------------------------------
// Symbian 2nd phase constructor can leave.
// ---------------------------------------------------------------------------
//	
void CGlxCommandHandlerDetails::ConstructL(const TDesC& aFileName)
	{
	// Load resource file
	GLX_FUNC("GLX_Property::ConstructL");

	iResourceOffset = CCoeEnv::Static()->AddResourceFileL(aFileName);

	// register property command in command handler
	TCommandInfo infoProp(EGlxCmdDetails);
	// Filter out static items and only allows one item to select
	infoProp.iMinSelectionLength = 1;
	infoProp.iMaxSelectionLength = 1;
	//Allow DRM
	infoProp.iDisallowDRM = EFalse;
	//Allow system items
	infoProp.iDisallowSystemItems = EFalse;
	//Allow animation
	infoProp.iStopAnimationForExecution = EFalse;
	//no category filter
	infoProp.iCategoryFilter = EMPXNoCategory;
	AddCommandL(infoProp);

	TCommandInfo infoSubMenu(EGlxCmdDetailsOption);
	infoSubMenu.iViewingState = TCommandInfo::EViewingStateBrowse;

	// register for the reset view command so that we can 
	// dismiss the dialog if it is being shown when we are activated
	// from SpaceUI 
	TCommandInfo resetViewCmd(EGlxCmdResetView);
	AddCommandL(resetViewCmd);

	// get pointer to HUI utility
	iUiUtility = CGlxUiUtility::UtilityL();
	}	
	
// ---------------------------------------------------------------------------
// Destructor
// ---------------------------------------------------------------------------
//
EXPORT_C CGlxCommandHandlerDetails::~CGlxCommandHandlerDetails()
	{
	TRACER("GLX_Property::~CGlxCommandHandlerDetails");
	if ( iResourceOffset )
        {
        CCoeEnv::Static()->DeleteResourceFile(iResourceOffset);
        }
        
    if ( iUiUtility )
        {
        iUiUtility->Close();
        }
	}

// -----------------------------------------------------------------------------
// DoExecuteL
// -----------------------------------------------------------------------------
//	
TBool CGlxCommandHandlerDetails::DoExecuteL( TInt aCommandId, MGlxMediaList& aList )
	{
	TBool consume(EFalse);
	TRACER("GLX_Property::DoExecuteL");
	GLX_LOG_INFO1("GLX_Property::DoExecuteL::DoExecuteL %d",aCommandId);
	switch(aCommandId)
		{
		case EGlxCmdDetails:
			{
			GLX_LOG_INFO("GLX_Property::DoExecuteL::Launch UMP");

			CGlxDefaultAttributeContext* attrContext = CGlxDefaultAttributeContext::NewL();
			CleanupStack::PushL(attrContext);

			attrContext->AddAttributeL(KMPXMediaGeneralUri);

			aList.AddContextL(attrContext, KGlxFetchContextPriorityBlocking);	

			// TGlxContextRemover will remove the context when it goes out of scope
			// Used here to avoid a trap and still have safe cleanup
			TGlxFetchContextRemover contextRemover (attrContext, aList);

			CleanupClosePushL( contextRemover);

			TInt err = GlxAttributeRetriever::RetrieveL(*attrContext,aList,ETrue);

			// context off the list
			CleanupStack::PopAndDestroy( &contextRemover );

			iAvkonAppUi->ProcessCommandL(EGlxCmdDialogLaunched);

			if ( err == KErrNone )
				{
				TInt focusIndex = aList.FocusIndex();
				TGlxMedia item = aList.Item(focusIndex);
				const CGlxMedia* media = item.Properties();

				TBool isDrm = aList.Item(focusIndex).IsDrmProtected();
				TBool isVideo = EFalse;

				TMPXGeneralCategory type = MediaList().Item( focusIndex ).Category();
				if(type == EMPXVideo)   
					{
					isVideo = ETrue;
					}


				//check media support uri attribute
				if(media && media->IsSupported(KMPXMediaGeneralUri))
					{
					const TDesC& uri = media->ValueText(KMPXMediaGeneralUri);

					HBufC* uriBuf = HBufC::NewLC(uri.Length()+2);

					TPtr uriPtr (uriBuf->Des());
					uriPtr = uri;
					uriPtr.Append( isDrm );
					uriPtr.Append( isVideo );

					GLX_DEBUG2("GLX_Property::DoExecuteL::URI:%S:",&uri);

                    iUiUtility->SetViewNavigationDirection(EGlxNavigationForwards); 
                    if (aList.Collection().UidL().iUid == 
                            KGlxCollectionPluginImageViewerImplementationUid)
                        {
                        CGlxImgVwrMetadataDialog* dialog  = CGlxImgVwrMetadataDialog::NewL( uri);
                        dialog->ExecuteLD();
                        }
                    else
                        {
                        CGlxMetadataDialog* dialog  = CGlxMetadataDialog::NewL( uri );    
                        dialog->ExecuteLD();
                        }

                    
                    CleanupStack::PopAndDestroy(uriBuf);
                    }
                }
            CleanupStack::PopAndDestroy( attrContext );

            iAvkonAppUi->ProcessCommandL(EGlxCmdResetView);

            consume = ETrue;
            break;
            }// contextRemover goes out of scope and removes the context from media list
        default:
            {
            break;		
            }
        }

	return consume;
	}
// -----------------------------------------------------------------------------
// LaunchViewL
// -----------------------------------------------------------------------------
//		
void CGlxCommandHandlerDetails::LaunchViewL(TUid aViewPluginId,const TDesC& aURI)
	{
	TRACER("GLX_UMP::CGlxCommandHandlerDetails:LaunchViewL");
	
	MMPXViewUtility* viewUtility = MMPXViewUtility::UtilityL();
	CleanupClosePushL(*viewUtility);
	
	if( aURI.Length() > 0 )
		{
		//following is to preserve unicode format of filename
		//Convert aURI 16 bit descriptor to 8 bit descriptor
		TPtrC8 ptr8((TUint8*)aURI.Ptr(),aURI.Length());
		GLX_LOG_INFO1("GLX_UMP::CGlxCommandHandlerDetails:ActivateViewL::ptr8:%S:",&ptr8);
		
		//convert back to 16 bit descriptor
		TPtrC16 ptr16((TUint16*)ptr8.Ptr(),ptr8.Length());
		GLX_LOG_INFO1("GLX_UMP::CGlxCommandHandlerDetails:ActivateViewL::ptr16:%S:",&ptr16);	
		
		viewUtility->ActivateViewL(aViewPluginId,&ptr16);
		}
	else
		{
		viewUtility->ActivateViewL(aViewPluginId,&KNullDesC);
		}

	CleanupStack::PopAndDestroy(viewUtility); 
	}
// -----------------------------------------------------------------------------
// DoActivateL
// -----------------------------------------------------------------------------
//		
void CGlxCommandHandlerDetails::DoActivateL( TInt /*aViewId*/ )
	{
	
	}

// -----------------------------------------------------------------------------
// DoIsDisabled
// -----------------------------------------------------------------------------
//
TBool CGlxCommandHandlerDetails::DoIsDisabled(TInt aCommandId, 
                                        MGlxMediaList& aList) const 
    {
    TRACER("CGlxCommandHandlerDetails:DoIsDisabled");
    TBool fullscreenViewingMode = EFalse;
    CGlxNavigationalState* aNavigationalState = CGlxNavigationalState::InstanceL();
    CMPXCollectionPath* naviState = aNavigationalState->StateLC();
    
    if ( naviState->Levels() >= 1)
        {
        if (aNavigationalState->ViewingMode() == NGlxNavigationalState::EBrowse) 
            {
            // For image viewer collection, goto view mode
            if (naviState->Id() == TMPXItemId(KGlxCollectionPluginImageViewerImplementationUid))
                {
                //it means we are in img viewer.so details will be available
                fullscreenViewingMode = ETrue;
                }
            else
                {
                //it means we are in grid view.so details will be not beavailable
                fullscreenViewingMode = EFalse;
                }
            } 
        else 
            {
            //it means we are in Fullscreen.so details will be available
            fullscreenViewingMode = ETrue;
            }                
        }
    CleanupStack::PopAndDestroy( naviState );
    aNavigationalState->Close();
    
	// If fullscreen view is there but media item dont have yet
	// data to be shown in detail than hide detail option
    if(fullscreenViewingMode && !IsThumbnailAvailable(aList))
       {
       return ETrue;
       }	   
	
    if(EGlxCmdDetails==aCommandId && (0 == aList.Count() || 1 != aList.SelectionCount())
            && !fullscreenViewingMode )
        {   
        return ETrue;
        }
    return EFalse;
    }

// -----------------------------------------------------------------------------
// IsThumbnailAvailable
// -----------------------------------------------------------------------------
//
TBool CGlxCommandHandlerDetails::IsThumbnailAvailable(MGlxMediaList& aList) const 
    {
    TRACER("CGlxCommandHandlerDetails::IsThumbnailAvailable");
    if (0 == aList.Count())
        {
        return EFalse;
        }

    TMPXAttribute attr;
    TSize size = iUiUtility->DisplaySize();
    GLX_LOG_INFO2(
            "CGlxCommandHandlerDetails::IsThumbnailAvailable() w(%d) h(%d)",
            size.iWidth, size.iHeight);
    return aList.Item(aList.FocusIndex()).GetClosestThumbnail(attr, size,
            EFalse);
    }
	
//End of file