/*

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

*

*/

#include <glxsingletonstore.h>

#include "glxaiwservicehandler.h"

#include "glxaiwmedia.h"

#include "AiwServiceHandler.h"

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

// InstanceL

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

//	

CGlxAiwServiceHandler* CGlxAiwServiceHandler::InstanceL()

    {

	return CGlxSingletonStore::InstanceL(&NewL);

    }

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

// Close

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

//

void CGlxAiwServiceHandler::Close()

	{

    CGlxSingletonStore::Close( this );

	}

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

// NewL

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

//	

CGlxAiwServiceHandler* CGlxAiwServiceHandler::NewL()

    {

    CGlxAiwServiceHandler* self = new (ELeave) CGlxAiwServiceHandler();

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    return self;

    }

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

// Constructor

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

//	

CGlxAiwServiceHandler::CGlxAiwServiceHandler()

    {

    }

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

// Destructor

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

//	

CGlxAiwServiceHandler::~CGlxAiwServiceHandler()

    {

    iAiwMediaArray.ResetAndDestroy();

    iAiwMediaArray.Close();

    delete iAiwServiceHandler;

    }

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

// 2nd phase constructor

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

//	

void CGlxAiwServiceHandler::ConstructL()

    {

    iAiwServiceHandler = CAiwServiceHandler::NewL();

    }

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

// AddParamL

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

//	

void CGlxAiwServiceHandler::AddParamL(const TGlxMediaId& aId, const TAiwGenericParam& aParam )

    {

    // This method is called to add parameters to the iInParams.

    // This should be called by each command handler before InitializeMenuPaneL is called at all.

    // This ensures that the entire list on InParams is built for all command handlers before

    // initializing the menu.

    // When InitializeMenuPaneL is called it destroys the inParams making it necessary to 

    // aquire and append to the iInParams again should this be necessary.

    if ( ENotInitialised != iInitialisedMenu )

        {

        // This is either the very first time or the first time since calling InitializeMenuPaneL

        iInitialisedMenu = ENotInitialised;

        // Set iInParams to Null. This will force a call to the service Handler to aquire

        // the pointer to the new set of InParams (yet to be appended too).

        iInParams = NULL;

        }

    if (!iInParams)

        {

        // Must aquire a pointer to the new set of InParams

        iInParams = &iAiwServiceHandler->InParamListL();

        }

    // Get the Index of the TGlxMediaId in the array

    TInt index = FindId(aId);

    CGlxAiwMedia* media = NULL;

    if (KErrNotFound == index)

        {

        // The TGlxMediaId was not found. so create a new entry

        media = new (ELeave) CGlxAiwMedia(aId);

        CleanupStack::PushL(media);

        TLinearOrder<CGlxAiwMedia> orderer (&AiwMediaOrderById);

        iAiwMediaArray.InsertInOrderL(media, orderer);

        CleanupStack::Pop(media);

        }

    else

        {

        // The TGlxMediaId was found so use the current entry

        media = iAiwMediaArray[index];

        }

    // Add the parameter (method checks for duplicates.

    media->AddParamL(aParam);

    }

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

// FindId

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

//	

TInt CGlxAiwServiceHandler::FindId(const TGlxMediaId& aId)

    {

    // Now we can find the CGlxAiwMedia in the list with an Id equal to aId

    TInt index = iAiwMediaArray.FindInOrder(aId, (&AiwMediaOrderByMediaId));

    return index;

    }

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

// AiwMediaOrderByMediaId (static method)

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

//	

TInt CGlxAiwServiceHandler::AiwMediaOrderByMediaId( const TGlxMediaId* aMediaId, const CGlxAiwMedia& aAiwMedia )

    {

    const TGlxMediaId& Id = aAiwMedia.Id();

    if (*aMediaId < Id)

        {

        return -1;

        }

    if (*aMediaId > Id)

        {

        return 1;

        }

    return 0;

    }

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

// AiwMediaOrderById (static method)

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

//	

TInt CGlxAiwServiceHandler::AiwMediaOrderById( const CGlxAiwMedia& aAiwMedia1, const CGlxAiwMedia& aAiwMedia2 )

    {

    const TGlxMediaId& mediaId = aAiwMedia1.Id();

    return AiwMediaOrderByMediaId(&mediaId, aAiwMedia2);

    }

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

// AppendInParamsL

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

//	

void CGlxAiwServiceHandler::AppendInParamsL()

    {

    // Iterate through array backwards because removing the last tem causes

    // little effort.

    TInt count = 0;

    while ((count = iAiwMediaArray.Count()) > 0)

        {

        // get the last element

        CGlxAiwMedia* media = iAiwMediaArray[count - 1];

        // Now get all the parameters associated with the element

        media->AppendToInParamsL(*iInParams);

        // Remove it from array

        iAiwMediaArray.Remove(count - 1);

        // Destroy the CGlxAiwMedia

        delete media;

        }

    // Tidy up the array

    iAiwMediaArray.ResetAndDestroy();

    }

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

// ResetMenuInitialisedFlag

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

//

void CGlxAiwServiceHandler::ResetMenuInitialisedFlag()

    {

    iInitialisedMenu = ENotInitialised;

    // Also set params list to NULL before creating new params list

    iInParams = NULL;    

    }    

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

// InitializeMenuPaneL

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

//	

void CGlxAiwServiceHandler::InitializeMenuPaneL(CEikMenuPane& aMenuPane, TInt aResourceId, TInt aBaseMenuCmdId)

    {

    // All the parameters for all command handlers should now be appended in iInParams

    // Calling InitializeMenuPaneL will destroy the values in iInParams. Hence the need to 

    // record when this is done by using iIsMenuInitialized.

    if ( ENotInitialised == iInitialisedMenu )

        {

        AppendInParamsL();

        if(iInParams)

            {

            iAiwServiceHandler->InitializeMenuPaneL(aMenuPane, aResourceId, aBaseMenuCmdId, *iInParams);

            }

        iInitialisedMenu = EMainMenuInitialised;

        }

    }

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

// AttachMenuL

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

//	

void CGlxAiwServiceHandler::AttachMenuL(TInt aMenuResource, TInt aAiwInterestResource)

    {

    iAiwServiceHandler->AttachMenuL( aMenuResource, aAiwInterestResource ); 

    }

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

// IsSameCommand

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

//	

TBool CGlxAiwServiceHandler::IsSameCommand(TInt aCommandId, TInt aAiwCommandId)

    {

    return ( iAiwServiceHandler->ServiceCmdByMenuCmd( aCommandId ) == aAiwCommandId );

    }

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

// ExecuteMenuCmdL

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

//	

void CGlxAiwServiceHandler::ExecuteMenuCmdL(TInt aMenuCmdId, TUint aCmdOptions, MAiwNotifyCallback* aCallback)

    {

    CAiwGenericParamList& outParams = iAiwServiceHandler->OutParamListL();

    iAiwServiceHandler->ExecuteMenuCmdL(aMenuCmdId, *iInParams, outParams, aCmdOptions, aCallback);

    }

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

// HandleSubmenuL

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

//

TBool CGlxAiwServiceHandler::HandleSubmenuL(CEikMenuPane& aPane)

    {

    // If main menu is initialize then only check for submenu

    if ( EMainMenuInitialised == iInitialisedMenu )

        {

        if ( iAiwServiceHandler->HandleSubmenuL(aPane) )

            {

            iInitialisedMenu = ESubMenuInitialised;

            }

        }    

    return ( ESubMenuInitialised == iInitialisedMenu );

    }

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

// IsAiwMenu

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

//	

TBool CGlxAiwServiceHandler::IsAiwMenu(TInt aMenuResourceId)

    {

    return iAiwServiceHandler->IsAiwMenu(aMenuResourceId);

    }

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

// GetInParams (for testing only)

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

//	

CAiwGenericParamList& CGlxAiwServiceHandler::GetInParams()

    {

    return *iInParams;

    }