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

	}