/*

* 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:    Class that stores the active media list pointer

*

*/

#include "glxactivemedialistregistry.h"

#include <glxtracer.h>

#include <glxpanic.h>

#include <glxsingletonstore.h>

#include <glxlog.h>

#include "mglxactivemedialistchangeobserver.h"

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

// Return an instance

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

//

EXPORT_C CGlxActiveMediaListRegistry* CGlxActiveMediaListRegistry::InstanceL(

        MGlxActiveMediaListChangeObserver* aObserver)

    {

    GLX_LOG_INFO1("CGlxActiveMediaListRegistry::InstanceL: %x", aObserver);

    CGlxActiveMediaListRegistry* obj = CGlxSingletonStore::InstanceL(&NewL);

    // Add the observer if has not already been added

    if (aObserver && KErrNotFound == obj->iObservers.Find(aObserver))

        {

        TRAPD(err, obj->iObservers.AppendL(aObserver));

        // Close tls reference and leave if AppendL leaves.

        // Otherwise there will be one reference that will be never closed

        if (KErrNone != err)

            {

            CGlxSingletonStore::Close(obj);

            User::Leave(err);

            }

        }

    return obj;

    }

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

// Return new object

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

//

CGlxActiveMediaListRegistry* CGlxActiveMediaListRegistry::NewL() 

    {

    CGlxActiveMediaListRegistry* obj = new (ELeave) CGlxActiveMediaListRegistry();

    // (No ConstructL necessary)

    return obj;    

    }

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

// Constructor

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

//

CGlxActiveMediaListRegistry::CGlxActiveMediaListRegistry()

    {

    }

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

// Destructor

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

//

CGlxActiveMediaListRegistry::~CGlxActiveMediaListRegistry()

    {

    iObservers.Close();

    }

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

// Close a reference

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

//

void CGlxActiveMediaListRegistry::Close(MGlxActiveMediaListChangeObserver* aObserver)

    {

    TRACER("CGlxActiveMediaListRegistry::Close");

    // Remove the observer if it has been added earlier

    TInt index = iObservers.Find(aObserver);

    if (KErrNotFound != index)

        {

        iObservers.Remove(index);

        }

    // Decrease reference count, and delete if last one

    // May delete this object

    CGlxSingletonStore::Close(this);

    // Member variable access not safe after CGlxTls::Close()

    }

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

// Register an active media list

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

//

EXPORT_C void CGlxActiveMediaListRegistry::RegisterActiveMediaList(MGlxMediaList* aMediaList)

    {

    GLX_LOG_INFO1("CGlxActiveMediaListRegistry::RegisterActiveMediaList: %x", aMediaList);

    // Add to registration count if the new list is the same as the existing one

    if (aMediaList == iActiveMediaList) 

        {

        __ASSERT_DEBUG(!iRegisteredTwice, Panic(EGlxPanicIllegalState)); // Cannot register three times

        GLX_LOG_INFO("CGlxActiveMediaListRegistry::RegisterActiveMediaList: Media list registered twice");

        // The same media list has been registered twice

        iRegisteredTwice = ETrue;

        }

    // If active list has changed, pick up the new list and notify observers

    if (iActiveMediaList != aMediaList)

        {

        GLX_LOG_INFO("CGlxActiveMediaListRegistry::RegisterActiveMediaList: Media list changed");

        // Pick up the new list

        iActiveMediaList = aMediaList;

        // This is the first registration

        iRegisteredTwice = EFalse;

        // Notify observers

        NotifyObservers();

        }

    }

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

// Deregister an active media list

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

//

EXPORT_C void CGlxActiveMediaListRegistry::DeregisterActiveMediaList(MGlxMediaList* aMediaList)

    {

    GLX_LOG_INFO1("CGlxActiveMediaListRegistry::DeregisterActiveMediaList: %x", aMediaList);

    // Ignore deregistration if another list has already been registered

    // (Another view was activated, and it registered a list)

    if (aMediaList == iActiveMediaList) 

        {

        // The list may be registered twice if the new and old view

        // registered the same list. 

        if (iRegisteredTwice)   

            {

            GLX_LOG_INFO("CGlxActiveMediaListRegistry::DeregisterActiveMediaList: Remove second registration");

            // Remove second registration

            iRegisteredTwice = EFalse;

            }

        else 

            {

            GLX_LOG_INFO("CGlxActiveMediaListRegistry::DeregisterActiveMediaList: Setting active list to NULL");

            // No new media list has been registered and current one is being

            // deregistered, so set active list to NULL

            iActiveMediaList = NULL;

            // Notify observers

            NotifyObservers();

            }

        }

    }

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

// Notify observers

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

//

void CGlxActiveMediaListRegistry::NotifyObservers() 

    {

    // Notify observers

    for (TInt i = iObservers.Count() - 1; i >= 0; i--)

        {

        iObservers[i]->HandleActiveMediaListChanged();

        }

    }

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

// Return active media list

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

//

MGlxMediaList* CGlxActiveMediaListRegistry::ActiveMediaList() const 

    {

    GLX_LOG_INFO("CGlxActiveMediaListRegistry::ActiveMediaList()");

    return iActiveMediaList;

    }