/*

* Copyright (c) 2005-2007 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 provides GlobalManager functionality.

*

*/

// INCLUDE FILES

#include <jdebug.h>

#include "cammsglobalmanager.h"

#include "cammsmodulecontainer.h"

#include "cammssoundsource3d.h"

#include "cammseffectmodule.h"

// Audio 3d includes.

#include "cammsdopplercontrolgroup.h"

#include "cammslocationcontrolgroup.h"

// Global manager

#include "cammsreverbcontrolgroup.h"

#include "cammsequalizercontrolgroup.h"

#include "cammsvolumecontrolgroup.h"

#include "cammspancontrolgroup.h"

#include "cammscommitcontrolgroup.h"

#include "cammsorientationcontrolgroup.h"

#include "cammsplayerbuildergroup.h"

#include "cammsaudioplayerbuilder.h"

#include "cammsvolumecontrolbuilder.h"

#include "ammsconstants.h"

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

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

// CAMMSGlobalManager::NewLC

// Two-phased constructor.

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

CAMMSGlobalManager* CAMMSGlobalManager::NewLC()

{

    CAMMSGlobalManager* self = new(ELeave) CAMMSGlobalManager;

    CleanupStack::PushL(self);

    self->ConstructL();

    return self;

}

//   Destructor

CAMMSGlobalManager::~CAMMSGlobalManager()

{

    DEBUG("AMMS::CAMMSGlobalManager::~CAMMSGlobalManager");

    delete iSpectator;

    delete iEffectModules;

    delete iSoundSource3Ds;

    delete iPlayerBuilder;

}

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

// CAMMSGlobalManager::AddPlayerNotifyL

// Adds new player

// (other items were commented in a header).

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

//

void CAMMSGlobalManager::AddPlayerNotifyL(CMMAPlayer* aPlayer)

{

    DEBUG_STR("AMMS::CAMMSGlobalManager::AddPlayerNotifyL player type %S",

              aPlayer->Type());

    // Add amms controls to player.

    iPlayerBuilder->PreparePlayerL(aPlayer);

    // AddPlayerNoStateCheckL is used to add players to global manager and

    // global controls because mma player may be started or prefetched before

    // amms global manager is created.

    // Add player to global manager. All global control groups will be informed.

    AddPlayerNoStateCheckL(aPlayer);

}

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

// CAMMSGlobalManager::RemovePlayerNotify

// Removes player

// (other items were commented in a header).

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

//

void CAMMSGlobalManager::RemovePlayerNotify(CMMAPlayer* aPlayer)

{

    DEBUG_STR("AMMS::CAMMSGlobalManager::RemovePlayerNotify player type %S",

              aPlayer->Type());

    // RemovePlayer can return only KErrNotFound or KErrNone, and in this case

    // we do not need to handle KErrNotFound

    RemovePlayerNoStateCheck(aPlayer);

    // Removing player from other modules

    iEffectModules->RemovePlayer(aPlayer);

    iSoundSource3Ds->RemovePlayer(aPlayer);

}

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

// CAMMSGlobalManager::InitL

// Initializes GlobalManager.

// (other items were commented in a header).

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

//

void CAMMSGlobalManager::InitL(RPointerArray< CMMAPlayer >& aPlayers)

{

    TInt playerCount = aPlayers.Count();

    // Add all players to the global controls and to the spectator.

    for (TInt i = 0; i < playerCount; i++)

    {

        DEBUG_STR("AMMS::CAMMSGlobalManager::InitL adding controls to %S",

                  aPlayers[ i ]->Type());

        AddPlayerNotifyL(aPlayers[ i ]);

    }

}

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

// CAMMSGlobalManager::CreateSoundSource3DL

// Creates a new sound source 3D module.

// (other items were commented in a header).

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

//

CAMMSModule* CAMMSGlobalManager::CreateSoundSource3DL()

{

    // InitL must have been called before call to this methdod.

    __ASSERT_DEBUG(iSpectator, User::Invariant());

    CAMMSSoundSource3D* soundSource3D =

        CAMMSSoundSource3D::NewLC(iSpectator, this);

    iSoundSource3Ds->AppendL(soundSource3D);

    CleanupStack::Pop(soundSource3D);

    return soundSource3D;

}

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

// CAMMSGlobalManager::CreateEffectModuleL

// Creates a new effect module.

// (other items were commented in a header).

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

//

CAMMSModule* CAMMSGlobalManager::CreateEffectModuleL()

{

    CAMMSEffectModule* module = CAMMSEffectModule::NewLC(this);

    iEffectModules->AppendL(module);

    CleanupStack::Pop(module);

    return module;

}

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

// CAMMSGlobalManager::Spectator

// Returns the spectator.

// (other items were commented in a header).

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

//

CAMMSModule* CAMMSGlobalManager::Spectator()

{

    return iSpectator;

}

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

// CAMMSGlobalManager::DisposeModule

// Disposes module.

// (other items were commented in a header).

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

void CAMMSGlobalManager::DisposeModule(CAMMSModule* aModule)

{

    // Remove the module from the module containers.

    iSoundSource3Ds->RemoveModule(aModule);

    iEffectModules->RemoveModule(aModule);

    // Delete the module itself.

    delete aModule;

}

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

// CAMMSGlobalManager::PlayerAddingAllowed

// Checks whether the given player can be added to a module.

// (other items were commented in a header).

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

TInt CAMMSGlobalManager::PlayerAddingAllowed(CMMAPlayer* aPlayer)

{

    DEBUG_INT("AMMS::CAMMSGlobalManager::PlayerAddingAllowed %d +",

              (TInt)aPlayer);

    TInt result = KErrNone;

    // Check whether the player can be added according to SoundSource3Ds.

    TInt modules = iSoundSource3Ds->Count();

    for (TInt i = 0; (result == KErrNone) && (i < modules); i++)

    {

        CAMMSModule* module = iSoundSource3Ds->At(i);

        result = PlayerAddingAllowed(aPlayer, module);

    }

    // Check whether the player can be added according to EffectModules.

    modules = iEffectModules->Count();

    for (TInt i = 0; (result == KErrNone) && (i < modules); i++)

    {

        CAMMSModule* module = iEffectModules->At(i);

        result = PlayerAddingAllowed(aPlayer, module);

    }

    DEBUG_INT("AMMS::CAMMSGlobalManager::PlayerAddingAllowed %d -", result);

    return result;

}

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

// CAMMSGlobalManager::CAMMSGlobalManager

// C++ default constructor can NOT contain any code, that

// might leave.

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

CAMMSGlobalManager::CAMMSGlobalManager()

{

}

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

// CAMMSGlobalManager::ConstructL

// Symbian 2nd phase constructor can leave.

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

void CAMMSGlobalManager::ConstructL()

{

    DEBUG("AMMS::CAMMSGlobalManager::ConstructL +");

    CAMMSModule::ConstructL();

    iSoundSource3Ds = new(ELeave) CAMMSModuleContainer();

    iEffectModules = new(ELeave) CAMMSModuleContainer();

    iPlayerBuilder = CAMMSPlayerBuilderGroup::NewL();

    iPlayerBuilder->AddBuilderAndPopL(CAMMSAudioPlayerBuilder::NewLC());

    iPlayerBuilder->AddBuilderAndPopL(CAMMSVolumeControlBuilder::NewLC());

    // Add control groups to global manager

    AddControlGroupAndPopL(CAMMSReverbControlGroup::NewLC());

    AddControlGroupAndPopL(CAMMSEqualizerControlGroup::NewLC());

    AddControlGroupAndPopL(CAMMSVolumeControlGroup::NewLC(

                               KAMMSGlobalVolume));

#ifndef __WINS__

    // PanControl is not supported in WINSCW builds.

    // This is because of limited pan support in DirectX.

    AddControlGroupAndPopL(CAMMSPanControlGroup::NewLC());

#endif // __WINS__

    // Create spectator and add controls.

    iSpectator = CAMMSModule::NewL();

    iSpectator->AddControlGroupAndPopL(CAMMSLocationControlGroup::NewLC(

                                           EAMMSSpectatorControl));

    iSpectator->AddControlGroupAndPopL(CAMMSOrientationControlGroup::NewLC());

    iSpectator->AddControlGroupAndPopL(CAMMSDopplerControlGroup::NewLC(

                                           EAMMSSpectatorControl));

    // Add Commit control group to global manager, and pass required references

    AddControlGroupAndPopL(CAMMSCommitControlGroup::NewLC(

                               *iSpectator,

                               *iSoundSource3Ds));

    DEBUG("AMMS::CAMMSGlobalManager::ConstructL -");

}

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

// CAMMSGlobalManager::PlayerAddingAllowed

// Checks whether the given player can be added to a module.

// (other items were commented in a header).

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

TInt CAMMSGlobalManager::PlayerAddingAllowed(CMMAPlayer* aPlayer,

        CAMMSModule* aModule)

{

    DEBUG_INT2("AMMS::CAMMSGlobalManager::PlayerAddingAllowed %d %d +",

               (TInt)aPlayer, (TInt)aModule);

    TBool playerExists = aModule->HasPlayer(aPlayer);

    TInt result = (playerExists ? KAMMSPlayerAlreadyInModuleError : KErrNone);

// WINSCW build does not support audio mixing.

// Thus, check in WINSCW build that there is not any non-closed player

// in the module. If there is any non-closed player in the module,

// adding a new player is not allowed to ANY module.

// However, allow a player to be in CLOSED state, because it cannot be started

// anymore and cannot thus reserve any resources anymore.

#ifdef __WINS__

    if (result == KErrNone)

    {

        TInt players = aModule->PlayerCount(CMMAPlayer::EUnrealized,

                                            CMMAPlayer::EStarted);

        DEBUG_INT("AMMS::CAMMSGlobalManager::PlayerAddingAllowed players=%d",

                  players);

        result = (players == 0 ? KErrNone : KAMMSMixingNotSupported);

    }

#endif  // __WINS__

    DEBUG_INT("AMMS::CAMMSGlobalManager::PlayerAddingAllowed %d -", result);

    return result;

}

//  End of File