//audiocontext.cpp

// Copyright (c) 2006-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:

//

#include <a3f/maudiostream.h>

#include <a3f/maudiocodec.h>

#include <a3f/maudiogaincontrol.h>

#include <a3f/a3fbase.h>

#include "audiocontext.h"

#include "audioprocessingunit.h"

#include "logicalaudiostream.h"

#include "audiostreammanager.h"

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

// Default constructor

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

//

CAudioContext::CAudioContext() 

	{

	TRACE_CREATE();

	DP_CONTEXT(CAudioContext::CAudioContext *CD1*, CtxDevSound, DPLOCAL);

	DP_IN();

	iInCommit = EFalse;

	DP_OUT();

	}

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

// Symbian 2nd phase constructor

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

void CAudioContext::ConstructL()

	{

	DP_CONTEXT(CAudioContext::ConstructL *CD1*, CtxDevSound, DPLOCAL);

	DP_IN();

	// Setup Multimedia Resource Control

	User::LeaveIfError(iMMRC.Open(*this));

	User::LeaveIfError(iCriticalSection.CreateLocal());

	DP_OUT();

	}

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

// Symbian constructor

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

EXPORT_C  CAudioContext* CAudioContext::NewL()

	{

	DP_STATIC_CONTEXT(CAudioContext::NewL *CD0*, CtxDevSound, DPLOCAL);

	DP_IN();

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

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	DP0_RET(self, "0x%x");

	}

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

// Destructor

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

//

EXPORT_C CAudioContext::~CAudioContext()

	{

	DP_CONTEXT(CAudioContext::~CAudioContext *CD1*, CtxDevSound, DPLOCAL);

	DP_IN();

	iMMRC.Close();	

	iAudioContextObservers.Close();

	iAudioProcessingUnits.Close();

	if (iActualChain)

		{

		iActualChain->Release();

		};

	iCriticalSection.Close();

	DP_OUT();

	}

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

// From class MAudioContext

// CAudioContext::SetClientSettings

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

//

TInt CAudioContext::SetClientSettings(const TClientContextSettings& aSettings)

	{

	DP_CONTEXT(CAudioContext::SetClientSettings *CD1*, CtxDevSound, DPLOCAL);

	DP_IN();

	TInt err(KErrNone);

	iClientSettings = aSettings;

	if( iContextId.Id() == 0 )

		{

		TUint64 id = iMMRC.LogOn(iClientSettings.iProcessId);

		TAudioContextId temp(id);

		iContextId = temp;

		}

	else

		{

		err = KErrAlreadyExists;

		}

	DP0_RET(err, "%d");

	}

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

// From class MAudioContext

// CAudioContext::GetContextId

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

//

TAudioContextId CAudioContext::ContextId() const 

	{

	DP_CONTEXT(CAudioContext::ContextId *CD1*, CtxDevSound, DPLOCAL);

	DP_IN();

	DP_OUT();

	return iContextId;

	}

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

// From class MAudioContext

// CAudioContext::Commit

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

//

TInt CAudioContext::Commit()

	{

	DP_CONTEXT(CAudioContext::Commit *CD1*, CtxDevSound, DPLOCAL);

	DP_IN();

	TInt err(KErrNone);

	iInCommit = ETrue;

	if (iClientSettings.iProcessId.Id() == 0)

		{

		DP0_RET(KErrNotReady, "%d");

		}

	err = iMMRC.SendResourceRequest(iActualChain, iDesiredChain, this);

	DP0_RET(err, "%d");

	}

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

// From class MAudioContext

// CAudioContext::CreateAudioStream

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

//

TInt CAudioContext::CreateAudioStream(MAudioStream *&aStream) 

	{

	DP_CONTEXT(CAudioContext::CreateAudioStream *CD1*, CtxDevSound, DPLOCAL);

	DP_IN();

	TInt err(KErrNone);

	CAudioStreamManager* manager(NULL);

	// Create desired logical chain

	TRAP(err, manager = CAudioStreamManager::NewL(KUidAudioStream));

	if(err == KErrNone)

		{

		aStream = static_cast<MAudioStream*>(manager);

		// Use this as desired chain (this is the one that the client modify)

		CLogicalAudioStream* logicalAudioStream = static_cast<CLogicalAudioStream*>(aStream);

		iDesiredChain = static_cast<MLogicalChain*>(logicalAudioStream); 

		logicalAudioStream->SetParentContext(*this);

		if (iActualChain)

			{

			iActualChain->Release();

			iActualChain=NULL;

			}

		TRAP(err, iActualChain = iDesiredChain->CloneL());

		}

	DP0_RET(err, "%d");

	}

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

// From class MAudioContext

// CAudioContext::DeleteAudioStream

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

//

void CAudioContext::DeleteAudioStream(MAudioStream *&aStream)

	{

	DP_CONTEXT(CAudioContext::DeleteAudioStream *CD1*, CtxDevSound, DPLOCAL);

	DP_IN();

	CAudioStreamManager* manager = static_cast<CAudioStreamManager*>(aStream);

	delete manager;

	DP_OUT();

	}

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

// From class MAudioContext

// CAudioContext::CreateAudioProcessingUnit

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

//

TInt CAudioContext::CreateAudioProcessingUnit(TUid aTypeId, MAudioProcessingUnit *&aProcessingUnit)

	{

	DP_CONTEXT(CAudioContext::CreateAudioProcessingUnit *CD1*, CtxDevSound, DPLOCAL);

	DP_IN();

	TInt err(KErrNone);

	TAudioComponentId unitInstance = GetAndSetInstanceID();

	CAudioProcessingUnit* pUnit=NULL;

	TComponentParameters cParameters;

	cParameters.iTypeUid = aTypeId;

	cParameters.iInstanceId = unitInstance;

	cParameters.iContextId = iContextId;

	cParameters.iSettingsObserver = this;

	TRAP(err, pUnit = CAudioProcessingUnit::NewL(cParameters));

	if (err==KErrNone)

		{

		aProcessingUnit = static_cast<MAudioProcessingUnit*>(pUnit);

		err = iAudioProcessingUnits.Append(aProcessingUnit);

		if(err!=KErrNone)

			{

			delete pUnit;

			aProcessingUnit = NULL;

			}

		}

	DP0_RET(err, "%d");

	}

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

// From class MAudioContext

// CAudioContext::DeleteAudioProcessingUnit

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

//

void CAudioContext::DeleteAudioProcessingUnit(

	MAudioProcessingUnit *&aProcessingUnit)

	{

	DP_CONTEXT(CAudioContext::DeleteAudioProcessingUnit *CD1*, CtxDevSound, DPLOCAL);

	DP_IN();

	DP_OUT();

	CAudioProcessingUnit* cUnit = static_cast<CAudioProcessingUnit*>(aProcessingUnit);

	TAudioComponentId param = aProcessingUnit->InstanceId();

	TUint count= iAudioProcessingUnits.Count();

	for ( TUint i(0); i < count; i++ )

		{

		// find and delete component

		if( iAudioProcessingUnits[i]->InstanceId() == param)

			{

			iAudioProcessingUnits.Remove(i);

			delete cUnit;

			break;

			}

		}

	}

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

// From class MAudioContext

// CAudioContext::RegisterAudioContextObserver

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

//

TInt CAudioContext::RegisterAudioContextObserver(

	MAudioContextObserver& aObserver)

	{

	DP_CONTEXT(CAudioContext::RegisterAudioContextObserver *CD1*, CtxDevSound, DPLOCAL);

	DP_IN();

	TInt err = iAudioContextObservers.Find(&aObserver);

	if( err != KErrNotFound )

		{

		err = KErrAlreadyExists;

		}

	else

		{

		err = iAudioContextObservers.Append(&aObserver);

		}

	DP0_RET(err, "%d");

	}

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

// From class MAudioContext

// CAudioContext::UnregisterAudioContextObserver

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

//

void CAudioContext::UnregisterAudioContextObserver(

	MAudioContextObserver& aObserver)

	{

	DP_CONTEXT(CAudioContext::UnregisterAudioContextObserver *CD1*, CtxDevSound, DPLOCAL);

	DP_IN();

	TInt idxOrErr = iAudioContextObservers.Find(&aObserver);

	if( idxOrErr != KErrNotFound )

		{

		iAudioContextObservers.Remove(idxOrErr);

		}

	DP_OUT();

	}

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

// From class MAudioContext

// CAudioContext::Interface

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

//

TAny* CAudioContext::Interface(TUid aType)

	{

	DP_CONTEXT(CAudioContext::Interface *CD1*, CtxDevSound, DPLOCAL);

	DP_IN();

	TAny* interface = NULL;

	if(aType == KUIdAudioResourceNotification)

		{

		#ifndef SYMBIAN_DISABLE_ARN

		interface = static_cast<MA3FDevSoundAutoPauseResume*>(this);

		#else

		interface = NULL;

		#endif

		}

	else

		{

		interface = NULL;

		}

	DP_OUT();

	return interface;

	}

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

// From class MAudioContext

// CAudioContext::Reset

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

//

TInt CAudioContext::Reset()

	{

	DP_CONTEXT(CAudioContext::Reset *CD1*, CtxDevSound, DPLOCAL);

	DP_IN();

	TInt err = KErrNone;

	if (iInCommit)

		{

		err = KErrNotReady;

		}

	iDesiredChain->ResetMessage();

	iDesiredChain->CopySettings(*iActualChain);

	DP0_RET(err, "%d");

	}

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

// From class MMultimediaResourceControlObserver

// CAudioContext::ReceiveResourceResponse

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

//

void CAudioContext::ReceiveResourceResponse(MLogicalChain* aAppliedChain, TInt aError)

	{

	DP_CONTEXT(CAudioContext::ReceiveResourceResponse *CD1*, CtxDevSound, DPLOCAL);

	DP_IN();

	iCriticalSection.Wait();

	iMsgVersion++;

	iMMRC.ResetMessages();

	iCriticalSection.Signal();

	if ( aError == KErrNone || iPreempted )

		{

		if ( iPreempted )

			{

			iPreempted = EFalse;

			}

		// Desired chain was commited succesfully

		TInt err;

		MLogicalChain* lc = NULL;

		TRAP(err, lc = aAppliedChain->CloneL());

		DP1(DLERR,"ECloneLeftWhenReceivingResourceResponse %d", err);

		__ASSERT_DEBUG(err == KErrNone, Panic(ECloneLeftWhenReceivingResourceResponse));

		if ( iActualChain )

			{

			iActualChain->Release();

			}

		iActualChain = lc;

		}

	else

		{

		iDesiredChain->CopySettings(*iActualChain);

		}

	iDesiredChain->ResetMessage();

	ContextEventSignal(KUidA3FContextUpdateComplete, aError);

	iInCommit = EFalse;

	DP_OUT();

	}

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

// From class MMultimediaResourceControlObserver

// CAudioContext::ReceiveResourceUpdate

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

//

void CAudioContext::ReceiveResourceUpdate(MLogicalChain* /*aMessage*/, TInt aError)

	{

	DP_CONTEXT(CAudioContext::ReceiveResourceUpdate *CD1*, CtxDevSound, DPLOCAL);

	DP_IN();

	ContextEventSignal(KUidA3FContextCommitUpdate, aError);	

	DP_OUT();

	}

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

// From class MMultimediaResourceControlObserver

// CAudioContext::ReceivePreemptionUpdate

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

//

void CAudioContext::ReceivePreemptionUpdate(MLogicalChain* /*aMessage*/, TInt aError)

	{

	DP_CONTEXT(CAudioContext::ReceivePreemptionUpdate *CD1*, CtxDevSound, DPLOCAL);

	DP_IN();

	iPreempted = ETrue;

	if(iInCommit)

		{

		// Send only one callback

		ContextEventSignal(KUidA3FContextPreEmptedCommit, aError);

		}

	else

		{

		// Send two callbacks

		ContextEventSignal(KUidA3FContextPreEmption, aError);

		ContextEventSignal(KUidA3FContextPreEmptionUpdate, aError);

		}

	DP_OUT();

	}

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

// From class MLogicalSettingObserver

// CAudioContext::ReceiveComponentSettingsChange

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

void CAudioContext::ReceiveComponentSettingsChange(TUid /*aId*/, TMMRCMessageType aMessageType)

	{

	iDesiredChain->SetMessageType(aMessageType);

	}

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

// Internals

// CAudioContext::GetAndSetInstanceID

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

TAudioComponentId CAudioContext::GetAndSetInstanceID()

	{

	DP_CONTEXT(CAudioContext::GetAndSetInstanceID *CD1*, CtxDevSound, DPLOCAL);

	DP_IN();

	TUint id(1); // start ID count from 1

	TAudioComponentId idComponent(1);

	TUint count = iAudioProcessingUnits.Count();

	if ( count < KMaxTUint )

		{

		id = ++count;

		}

	idComponent = id;

	DP_OUT();

	return idComponent;

	}

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

// Internals

// CAudioContext::ContextEventSignal

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

void CAudioContext::ContextEventSignal(TUid aEvent, TInt aError)

	{

	DP_CONTEXT(CAudioContext::ContextEventSignal *CD1*, CtxDevSound, DPLOCAL);

	DP_IN();

	TUint count = iAudioContextObservers.Count();

	for ( TUint idx(0); idx < count; idx++ )

		{

		iAudioContextObservers[idx]->ContextEvent(aEvent, aError);

		}

	DP_OUT();

	}

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

// CAudioContext::GetLogicalChain

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

EXPORT_C MLogicalChain* CAudioContext::GetLogicalChain(TInt aIndex)

	{

	DP_CONTEXT(CAudioContext::GetLogicalChain *CD1*, CtxDevSound, DPLOCAL);

	DP_IN();

	MLogicalChain* logChain = NULL;

	if (aIndex == 0)

		{

		logChain = iDesiredChain;

		}

	else

		{

		logChain = iActualChain;

		}

	DP_OUT();

	return logChain;

	}

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

// CAudioContext::RegisterAsClient

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

TInt CAudioContext::RegisterAsClient(TUid aEventType, const TDesC8& aNotificationRegistrationData, MA3FDevSoundAutoPauseResumeObserver* aObserverPtr)

	{

	DP_CONTEXT(CAudioContext::RegisterAsClient *CD1*, CtxDevSound, DPLOCAL);

	DP_IN();

	TInt err(KErrNone);

	iObserverPtr = aObserverPtr;

	err = iMMRC.RegisterAsClient(aEventType, aNotificationRegistrationData);

	DP0_RET(err, "%d");

	}

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

// CAudioContext::CancelRegisterAsClient

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

TInt CAudioContext::CancelRegisterAsClient(TUid aEventType)

	{

	DP_CONTEXT(CAudioContext::CancelRegisterAsClient *CD1*, CtxDevSound, DPLOCAL);

	DP_IN();

	TInt err(KErrNone);

	err = iMMRC.CancelRegisterAsClient(aEventType);

	DP0_RET(err, "%d");

	}

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

// CAudioContext::WillResumePlay

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

TInt CAudioContext::WillResumePlay()

	{

	DP_CONTEXT(CAudioContext::WillResumePlay *CD1*, CtxDevSound, DPLOCAL);

	DP_IN();

	TInt err(KErrNone);

	err = iMMRC.WillResumePlay();

	DP0_RET(err, "%d");

	}