// 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:

 //

 #include "a3fcistubextn.h"

 #include <ecom/ecom.h>

 #include <ecom/implementationproxy.h>

 #include "a3fcistubextn.hrh"

 #include <a3f/maudiocontext.h>

 #include <a3f/maudiostream.h>

 #include <a3f/maudioprocessingunit.h>

 #include <a3f/maudiogaincontrol.h>

 #include <a3f/audioprocessingunittypeuids.h>

 //      

 #include "a3fbackdooraccess.h"

 #ifdef SYMBIAN_ENABLE_SPLIT_HEADERS

 #include <mmf/common/mmfipcserver.h>

 #endif

 // __________________________________________________________________________

 // Client-side extension

 MDevSoundCIClientExtension* CA3fClientCiStubExtn::NewL()

 	{

 	CA3fClientCiStubExtn* self = new (ELeave) CA3fClientCiStubExtn;

 	return self;

 	}

 CA3fClientCiStubExtn::~CA3fClientCiStubExtn()

 	{

 	delete iDummyBuffer;

 	REComSession::DestroyedImplementation(iKey);

 	}

 TInt CA3fClientCiStubExtn::Setup(MCustomCommand& aCustomCommand)

 	{

 	iCommand = &aCustomCommand;

 	iDummyBuffer=KNullDesC().Alloc(); // dummy buffer simulates some allocs

 	if (!iDummyBuffer)

 		{

 		return KErrNoMemory;

 		}

 	return KErrNone;

 	}

 TInt CA3fClientCiStubExtn::CustomInterfaceExtension(TUid aUid, TAny*& aInterface)

 	{

 	if (aUid==KUidTestSetVolIf)

 		{

 		MTestSetVolIf* interface = this;

 		aInterface = interface;

 		return KErrNone;

 		}

 	return KErrNotSupported;

 	}

 void CA3fClientCiStubExtn::Release()

 	{

 	delete this;

 	}

 void CA3fClientCiStubExtn::PassDestructorKey(TUid aDestructorKey)

 	{

 	iKey = aDestructorKey;

 	}

 TInt CA3fClientCiStubExtn::SetVol(TInt aVol)

 	{

 	// the key here is the destination package, which represets SetVol. Apart from value

 	// the rest of the parameters can be ignored

 	TPckgBuf<TInt> volumePkg (aVol);

 	TMMFMessageDestinationPckg setVolDest (TMMFMessageDestination(KUidTestSetVolIf, 0));

 	TInt result = iCommand->CustomCommandSync(setVolDest, ETestSetVolIfSetVolCommand, volumePkg, KNullDesC8);

 	return result;

 	}

 TInt CA3fClientCiStubExtn::Vol(TInt aMaxVol)

     {

     // again the key is is the destination package

     TPckgBuf<TInt> maxVolPkg (aMaxVol);

     TMMFMessageDestinationPckg setVolDest (TMMFMessageDestination(KUidTestSetVolIf, 0));

     TInt result = iCommand->CustomCommandSync(setVolDest, ETestSetVolIfVolCommand, maxVolPkg, KNullDesC8);

     return result;

     }

 // __________________________________________________________________________

 // Server-side extension

 MDevSoundCIServerExtension* CA3fServerCiStubExtn::NewL()

 	{

 	CA3fServerCiStubExtn* self = new (ELeave) CA3fServerCiStubExtn;

 	return self;

 	}

 CA3fServerCiStubExtn::~CA3fServerCiStubExtn()

 	{

 	delete iDummyBuffer;

 	delete iSetVol;

 	REComSession::DestroyedImplementation(iKey);

 	}

 TInt CA3fServerCiStubExtn::Setup(MCustomInterface& aCustomInterface)

 	{

 	iInterface = &aCustomInterface;

 	iDummyBuffer=KNullDesC().Alloc(); // dummy buffer simulates some allocs

 	if (!iDummyBuffer)

 		{

 		return KErrNoMemory;

 		}

 	return KErrNone;

 	}

 TInt CA3fServerCiStubExtn::HandleMessageL(const RMmfIpcMessage& aMessage)

 	{

 	TMMFMessageDestinationPckg destinationPckg;

 	MmfMessageUtil::ReadL(aMessage, 0, destinationPckg);

 	if (destinationPckg().InterfaceId()==KUidTestSetVolIf)

 		{

 		CSetVol* volHandler = CSetVol::NewL(*iInterface);

 		CleanupStack::PushL(volHandler);

 		TInt result = volHandler->HandleMessageL(aMessage);

 		CleanupStack::Pop(volHandler);

 		return result;

 		}

 	return KErrNotSupported;

 	}

 void CA3fServerCiStubExtn::Release()

 	{

 	delete this;

 	}

 void CA3fServerCiStubExtn::PassDestructorKey(TUid aDestructorKey)

 	{

 	iKey = aDestructorKey;

 	}

 // CSetVol

 CSetVol* CSetVol::NewL(MCustomInterface& aCustomInterface)

 	{

 	CSetVol* self = new (ELeave) CSetVol(aCustomInterface);

 	CleanupStack::PushL(self);

 	self->ConstructL();

 	CleanupStack::Pop(self);

 	return self;

 	}

 CSetVol::CSetVol(MCustomInterface& aCustomInterface):

 	iInterface(&aCustomInterface)

 	{

 	// do nothing

 	}

 void CSetVol::ConstructL()

 	{

 	iWait = new (ELeave) CActiveSchedulerWait();

 	}

 CSetVol::~CSetVol()

 	{

 	delete iWait;

 	}

 TInt CSetVol::HandleMessageL(const RMmfIpcMessage& aMessage)

 	{

     switch (aMessage.Function())

         {

         case ETestSetVolIfSetVolCommand:

             {

             TPckgBuf<TInt> volPckg;

             MmfMessageUtil::ReadL(aMessage, 1, volPckg);

             UpdateA3fPointers(); // grab pointers to context, stream etc

             SetVolumeL(volPckg());

             User::LeaveIfError(iContext->RegisterAudioContextObserver(*this));

             TInt error = iContext->Commit();

             if (!error)

                 {

                 iError = KErrNone;

                 iWait->Start();

                 error = iError;

                 }

             (void) iContext->UnregisterAudioContextObserver(*this);

             aMessage.Complete(error);

             return KErrNone; // KErrNone says we've handled the message

             }

         case ETestSetVolIfVolCommand:

             {

             TPckgBuf<TInt> maxVolPckg;

             MmfMessageUtil::ReadL(aMessage, 1, maxVolPckg);

             UpdateA3fPointers(); // grab pointers to context, stream etc

             TInt result = VolumeL(maxVolPckg());

             aMessage.Complete(result);

             return KErrNone; // KErrNone says we've handled the message

             }

         default:

             return KErrArgument;

         }

 	}

 void CSetVol::UpdateA3fPointers()

 	{

 	MA3FBackdoorAccessIf* backdoor = 

 		static_cast<MA3FBackdoorAccessIf*>(iInterface->CustomInterface(KA3FBackdoorAccessIfUid));

 	if (backdoor)

 		{

 		iContext = backdoor->AudioContext();

 		iStream = backdoor->AudioStream();

 		iGain = backdoor->ProcessingUnit(KUidAudioGainControl);

 		}

 	else

 		{

 		iContext = NULL;

 		iStream = NULL;

 		iGain = NULL;

 		}

 	}

 void CSetVol::SetVolumeL(TInt aVolume)

 	{

 	RArray<TAudioChannelGain>	channelGains;

 	CleanupClosePushL(channelGains);

 	TAudioChannelGain left;

 	TAudioChannelGain right;	

 	left.iLocation = TAudioChannelGain::ELeft;

 	right.iLocation = TAudioChannelGain::ERight;

 	left.iGain = right.iGain = aVolume;

 	User::LeaveIfError(channelGains.Append(left)); // assumed element 0 in rest of code

 	User::LeaveIfError(channelGains.Append(right)); // assumed element 1 in rest of code

 	MAudioGainControl* gainControl = static_cast<MAudioGainControl*>(iGain->Interface(KUidAudioGainControl));

 	User::LeaveIfError(gainControl->SetGain(channelGains));	

 	CleanupStack::PopAndDestroy(&channelGains);

 	}

 TInt CSetVol::VolumeL(TInt aMaxVolume)

     {

     RArray<TAudioChannelGain>   channelGains;

     CleanupClosePushL(channelGains);

     TInt maxGain;

     MAudioGainControl* gainControl = static_cast<MAudioGainControl*>(iGain->Interface(KUidAudioGainControl));

     User::LeaveIfError(gainControl->GetGain(channelGains));

     User::LeaveIfError(gainControl->GetMaxGain(maxGain));

     TInt basicVolume = (channelGains[0].iGain + channelGains[1].iGain) / 2;

     TInt result = basicVolume * aMaxVolume / maxGain; // scale to 0 to maxVolume

     CleanupStack::PopAndDestroy(&channelGains);

     return result;

     }

 void CSetVol::ContextEvent(TUid aEvent, TInt aError)

 	{

 	if (aEvent==KUidA3FContextUpdateComplete || aEvent==KUidA3FContextAbort)

 		{

 		// we are going to assume the SetGain() works and use the end of

 		// the ContextEvent. Really should observe the gain itself

 		if (aError)

 			{

 			iError = aError;

 			}

 		iWait->AsyncStop();

 		}

 	}

 //

 // ImplementationTable

 //

 const TImplementationProxy ImplementationTable[] = 

 	{

 	IMPLEMENTATION_PROXY_ENTRY(KUidA3fClientCiStubExtn, CA3fClientCiStubExtn::NewL),

 	IMPLEMENTATION_PROXY_ENTRY(KUidA3fServerCiStubExtn, CA3fServerCiStubExtn::NewL),

 	};

 //

 // ImplementationGroupProxy

 //

 //

 EXPORT_C const TImplementationProxy* ImplementationGroupProxy(TInt& aTableCount)

 	{

 	aTableCount = sizeof(ImplementationTable) / sizeof(TImplementationProxy);

 	return ImplementationTable;

 	}