/*

* 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:    AIW command handler base class

*

*/

#include "glxcommandhandleraiwbase.h"

#include <glxattributecontext.h>

#include <glxattributeretriever.h>

#include <mglxmedialist.h>

#include <glxuiutilities.rsg>

#include <glxgeneraluiutilities.h>

#include <glxcommandhandlers.hrh>

#include <glxtracer.h>

#include <glxassert.h>

#include <glxuistd.h>

#include "glxaiwservicehandler.h"

#include <glxresourceutilities.h>                // for CGlxResourceUtilities

#include <data_caging_path_literals.hrh>

const TInt KGlxAiwDefaultMaxSelectedItems = 200;

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

// Constructor

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

//	

CGlxCommandHandlerAiwBase::CGlxCommandHandlerAiwBase(

    MGlxMediaListProvider* aMediaListProvider, TInt aMenuResource )

        : CGlxMediaListCommandHandler( aMediaListProvider ),

            iMenuResource( aMenuResource )

    {

    iAppUi = static_cast< CAknAppUi* >( CCoeEnv::Static()->AppUi() );

    }

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

// ConstructL

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

//	

void CGlxCommandHandlerAiwBase::ConstructL()

    {

    TParse parse;

    parse.Set(KGlxUiUtilitiesResource, &KDC_APP_RESOURCE_DIR, NULL);

    TFileName resourceFile;

    resourceFile.Append(parse.FullName());

    CGlxResourceUtilities::GetResourceFilenameL(resourceFile);  

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

    iAiwServiceHandler = CGlxAiwServiceHandler::InstanceL();

    iAiwServiceHandler->AttachMenuL( iMenuResource, AiwInterestResource() ); 

   	// Add supported command

   	TCommandInfo info(CommandId());

   	// Filter out static items

    info.iMinSelectionLength = 1;

    info.iMaxSelectionLength = MaxSelectedItems();

    info.iStopAnimationForExecution = ETrue;

    info.iCategoryFilter = EMPXCommand;

    info.iCategoryRule = TCommandInfo::EForbidAll; 

   	AddCommandL(info);

    }

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

// Destructor

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

//	

CGlxCommandHandlerAiwBase::~CGlxCommandHandlerAiwBase()

    {

    if (iAiwServiceHandler)

        {

        iAiwServiceHandler->Close();

        }

    if (iResourceOffset)

        {

        CCoeEnv::Static()->DeleteResourceFile(iResourceOffset);

        }   

    }

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

// DoActivateL

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

//	

void CGlxCommandHandlerAiwBase::DoActivateL(TInt /*aViewId*/)

    {

    }

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

// Deactivate

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

//	

void CGlxCommandHandlerAiwBase::Deactivate()

    {

    }

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

// DoExecuteL

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

//

TBool CGlxCommandHandlerAiwBase::DoExecuteL(TInt aCommandId, 

        MGlxMediaList& /* aList */)

    {

    TBool consumed = EFalse;

    // Check whether we can handle this command.

    // Because BypassFiltersForExecute is enabled, we receive all command IDs.

    if (iAiwServiceHandler->IsSameCommand( aCommandId, AiwCommandId() )

            && AiwItemEnabledL() ) 

        {

        // Stop animations

        iAppUi->ProcessCommandL( EGlxCmdDisableAnimations );

        // Now gather the AIW parameters only for this service

        // The InParam list at this point is empty (and must be empty).

        GatherAiwParametersL(*iAiwServiceHandler);

        iAiwServiceHandler->AppendInParamsL();

        TRAPD( err, iAiwServiceHandler->ExecuteMenuCmdL( aCommandId, 0, this ) ); 

        // If there is an error we must restart animations. then we can leave

        if (KErrNone != err)

            {

            // Restart animations 

            iAppUi->ProcessCommandL( EGlxCmdEnableAnimations ); 

            User::Leave( err );

            }

        // After executing aiw command reset params list and menuInitialized flag

        // so that next iptions menu initialization takes new params list    

        iAiwServiceHandler->ResetMenuInitialisedFlag();

        consumed = ETrue;

        }

    return consumed;

    }

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

// DoDynInitMenuPaneL

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

//	

void CGlxCommandHandlerAiwBase::DoDynInitMenuPaneL(TInt aResourceId, 

        CEikMenuPane* aMenuPane)

    {

    if (aMenuPane)

        {

        if (iAiwServiceHandler->HandleSubmenuL( *aMenuPane ))

            {

            // AIW handles AIW sub-menus so do nothing else here

            return;

            }

        TInt err = KErrNone;

        TInt itemPos = 0;

        if (aMenuPane->MenuItemExists(CommandId(), itemPos))

            {

            if (!AiwItemEnabledL())

                {

                err = KErrGeneral;

                }

            }

        if (err == KErrNone && iAiwServiceHandler->IsAiwMenu(aResourceId) )

            {    

            AiwDoDynInitMenuPaneL(aResourceId, aMenuPane);

            // Initialize menu pane

            TRAP(err, iAiwServiceHandler->InitializeMenuPaneL(

                     *aMenuPane, aResourceId, EGlxCmdAiwBase));

            }

        if (err != KErrNone)

            {

            // If there's been any error (e.g. incomplete attributes due to 

            // user cancellation), then remove command from menu

            TInt pos;

            if (aMenuPane->MenuItemExists(CommandId(), pos))

                {

                aMenuPane->SetItemDimmed(CommandId(), ETrue);

                }

            }

        }

    }

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

// AppendDefaultAiwParameterL

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

//	

/// parameter should also be of format aParameter, so glxAiwServiceHandler => aAiwServiceHandler

TBool CGlxCommandHandlerAiwBase::AppendDefaultAiwParameterL(const TGlxMedia& aItem, 

                                                            CGlxAiwServiceHandler& aAiwServiceHandler,

                                                            TBool aAddUri,

                                                            TBool aAddMimeType)

    {

    TBool successUri = ETrue;

    TBool successMimeType = ETrue;

    // First check to see if we need to add the Uri

    if (aAddUri)

        {

        successUri = AppendTextParameterL(aItem, aAiwServiceHandler, aItem.Uri(), EGenericParamFile);

        }

    // Then check to see if we need the mime type  

    if (aAddMimeType)

        {

        successMimeType = AppendTextParameterL(aItem, aAiwServiceHandler, aItem.MimeType(), EGenericParamMIMEType);

        }

    return successUri && successMimeType;

    }

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

// AppendTextParameterL

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

//	

TBool CGlxCommandHandlerAiwBase::AppendTextParameterL(const TGlxMedia& aItem,

                                                    CGlxAiwServiceHandler& aAiwServiceHandler,

                                                    const TDesC& aText,

                                                    TGenericParamIdValue aGenericParamIdValue)

    {

    TBool success = EFalse;

    if (aText != KNullDesC)

        {

        aAiwServiceHandler.AddParamL(aItem.Id(), TAiwGenericParam( aGenericParamIdValue, TAiwVariant( aText ) ) );

        success = ETrue;

        }

    return success;

    }

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

// BypassFiltersForExecute

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

//	

TBool CGlxCommandHandlerAiwBase::BypassFiltersForExecute() const

    {

    // We need to bypass the MediaListCommandHandler filters for execution.

    // Because Aiw assigns its own IDs for items added to the menu, we don't 

    // know which command IDs we actually support.

    // By returning true, we receive all commands in DoExecuteL.

    return ETrue;

    }

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

// BypassFiltersForExecute

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

//	

TBool CGlxCommandHandlerAiwBase::BypassFiltersForMenu() const

    {

    // We need to bypass the MediaListCommandHandler filters for menu init.

    // Due to the AIW commands appearing in a submenu, we need to make sure

    // they are not automatically filtered out because they aren't

    // listed in our "Supported" command set

    // (We don't know which command values will be assigned by AIW)

    return ETrue;

    }

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

// GatherAiwParametersL

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

//

TBool CGlxCommandHandlerAiwBase::GatherAiwParametersL(CGlxAiwServiceHandler& aAiwServiceHandler)

    {

    TRACER("CGlxCommandHandlerAiwBase::GatherAiwParametersL()");

    TInt allFound = ETrue;

    MGlxMediaList& mediaList = MediaList();

    // Iterate through selected items to gather the parameters for AIW

	TGlxSelectionIterator iterator;

	iterator.SetToFirst(&mediaList);

	TInt index = KErrNotFound;

	while (KErrNotFound != (index = iterator++) && allFound)

	    {

    	allFound = AppendAiwParameterL(mediaList.Item(index), aAiwServiceHandler);

	    }

    return allFound;        

    }

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

// PreDynInitMenuPaneL

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

//	

void CGlxCommandHandlerAiwBase::PreDynInitMenuPaneL( TInt aResourceId )

    {

    if( AiwItemEnabledL() && iAiwServiceHandler->IsAiwMenu( aResourceId ) )

        { 

        GatherAiwParametersL(*iAiwServiceHandler);

        }

    }

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

// MaxSelectedItems

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

//	

TInt CGlxCommandHandlerAiwBase::MaxSelectedItems() const

    {

    return KGlxAiwDefaultMaxSelectedItems;

    }

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

// HandleNotifyL

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

//	

TInt CGlxCommandHandlerAiwBase::HandleNotifyL(

        TInt /*aCmdId*/,

        TInt aEventId,

        CAiwGenericParamList& /*aEventParamList*/,

        const CAiwGenericParamList& /*aInParamList*/)

    {

    switch ( aEventId )

        {

        case KAiwEventCompleted:

        case KAiwEventCanceled:

        case KAiwEventError:

        case KAiwEventStopped:

            {

            // Restart animations

            iAppUi->ProcessCommandL(EGlxCmdEnableAnimations);

            }

            break;

        }

    return KErrNone;

    }

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

// AiwDoDynInitMenuPaneL

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

//	

void CGlxCommandHandlerAiwBase::AiwDoDynInitMenuPaneL(TInt /*aResourceId*/, 

        CEikMenuPane* /*aMenuPane*/)

    {

    // Do nothing by default, may be overridden

    }

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

// AiwItemEnabledL

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

//	

TBool CGlxCommandHandlerAiwBase::AiwItemEnabledL()

    {

    TBool enabled = EFalse;

    MGlxMediaList& mediaList = MediaList();

    if (mediaList.Count() == 0)

        {

        return EFalse;	

        }

    if ( mediaList.SelectionCount() == 0 )

        {

        // No items in selection list. Check if focus item is static

        TInt focusIndex = mediaList.FocusIndex();

        if(focusIndex != KErrNotFound)

            {

            if (!mediaList.Item(focusIndex).IsStatic())

                {

                // Not static - so enable

                enabled = ETrue;

                }

            }

        }

    else if ( mediaList.SelectionCount() <= MaxSelectedItems() )

        {

        // Count of selected items within range, so enable

        enabled = ETrue;

        }

    return enabled;

    }

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

// AiwMenuCmdIdL

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

//	

TInt CGlxCommandHandlerAiwBase::AiwMenuCmdIdL( const TDesC& aMenuItemText, 

                                CEikMenuPane* aMenuPane )

    {

    TInt index = 0;

    TInt cmdId = KErrNotFound;

    TInt count = aMenuPane->NumberOfItemsInPane();

    // Traverse through menupane until menu text required is found 

    // or there are no more items in menupane 

    while( index < count && aMenuItemText.CompareC( aMenuPane->

            ItemDataByIndexL( index ).iText ) )

        {

        index++;

        }

    // if count less than count then required item text is found, so get commandId for it    

    if( index < count )

        {

        cmdId = aMenuPane->ItemDataByIndexL( index ).iCommandId ;

        }

    return cmdId;

    }