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

//

/**

 @file

 @publishedAll

 @released

*/

#include <absolutevolumeapitarget.h>

#include <absolutevolumeapitargetobserver.h>

#include <remconinterfaceselector.h>

#include <absolutevolumeapi.h>

#include <absolutevolumeutils.h>

#include <bluetooth/logger.h>

#ifdef __FLOG_ACTIVE

_LIT8(KLogComponent, LOG_COMPONENT_REMCONABSOLUTEVOLUME);

_LIT8(KLogFormat, "Operation Id = 0x%x, Data Lengh = %d");

_LIT8(KLogNewL, "CRemConAbsoluteVolumeTarget::NewL");

#endif

/**

Allocates and constructs a new CRemConAbsoluteVolumeTarget object

@param aInterfaceSelector The interface selector. The client must have 

       created one of these first.

@param aObserver The observer through which the client will receive absolute

       volume commands from M class MRemConAbsoluteVolumeTargetObserver.

@param aVolume The initial relative volume on the client.

@param aMaxVolume The client maximum volume against which aVolume is relative.

@return A new CRemConAbsoluteVolumeTarget, owned by the interface selector.

@panic AbsoluteVolumeTarget 0 if aMaxVolume is zero

       AbsoluteVolumeTarget 1 if aVolume greater than aMaxVolume

*/

EXPORT_C CRemConAbsoluteVolumeTarget* CRemConAbsoluteVolumeTarget::NewL(

		CRemConInterfaceSelector& aInterfaceSelector, 

		MRemConAbsoluteVolumeTargetObserver& aObserver,

		TUint32 aVolume, 

		TUint32 aMaxVolume)

	{

	LOG(KLogNewL);

	__ASSERT_ALWAYS(aMaxVolume > 0, 

			User::Panic(KAbsoluteVolumeTargetPanicName, 

					ETargetInvalidMaxVolume)

			);

	__ASSERT_ALWAYS(aVolume <= aMaxVolume, 

			User::Panic(KAbsoluteVolumeTargetPanicName, 

					ETargetVolumeBeyondMaxVolume)

			);

	CRemConAbsoluteVolumeTarget* self = 

	new(ELeave) CRemConAbsoluteVolumeTarget(aInterfaceSelector, 

			aObserver, aVolume, aMaxVolume);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

/** 

Constructor.

@param aInterfaceSelector The interface selector.

@param aObserver The observer of this interface.

@param aVolume The initial relative volume on the client

@param aMaxVolume The maximum volume on the client against which 

       aVolume is relative.

*/

CRemConAbsoluteVolumeTarget::CRemConAbsoluteVolumeTarget(

		CRemConInterfaceSelector& aInterfaceSelector, 

		MRemConAbsoluteVolumeTargetObserver& aObserver,

		TUint32 aVolume, 

		TUint32 aMaxVolume)

:	CRemConInterfaceBase(TUid::Uid(KRemConAbsoluteVolumeTargetApiUid),

		KAbsoluteVolumeRequestDataSize, 

		aInterfaceSelector,

		ERemConClientTypeTarget), 

	iObserver(aObserver),

	iAbsoluteVolumeNotificationRequest(EFalse),

	iClientVolume(aVolume),

	iClientMaxVolume(aMaxVolume)

	{

	}

void CRemConAbsoluteVolumeTarget::ConstructL()

	{

	iOutBuf.CreateL(KAbsoluteVolumeResponseDataSize);

	//Mandate the following features supported.

	RRemConInterfaceFeatures features;

	User::LeaveIfError(features.Open());

	CleanupClosePushL(features);

	features.AddOperationL(KRemConSetAbsoluteVolume);

	BaseConstructL(features);

	CleanupStack::PopAndDestroy(&features);

	}

EXPORT_C CRemConAbsoluteVolumeTarget::~CRemConAbsoluteVolumeTarget()

	{

	iOutBuf.Close();

	}

TAny* CRemConAbsoluteVolumeTarget::GetInterfaceIf(TUid aUid)

	{

	TAny* ret = NULL;

	if ( aUid == TUid::Uid(KRemConInterfaceIf2) )

		{

		ret = reinterpret_cast<TAny*>(

			static_cast<MRemConInterfaceIf2*>(this)

			);

		}

	return ret;

	}

/** 

Called by the client in response to a MrcavtoSetAbsoluteVolume() call.

@param aVolume The relative volume against the client maximum volume.  

@param aErr The error code.

     - KErrNone if the client has changed its absolute volume.

     - System wide error code otherwise.

@panic AbsoluteVolumeTarget 1, if volume is greater than max volume.

*/

EXPORT_C void CRemConAbsoluteVolumeTarget::SetAbsoluteVolumeResponse(

		TUint32 aVolume, 

		TInt aErr)

	{

	__ASSERT_ALWAYS(aVolume <= iClientMaxVolume, 

			User::Panic(KAbsoluteVolumeTargetPanicName, 

					ETargetVolumeBeyondMaxVolume)

			);

	RRemConAbsoluteVolumeResponse response;

	response.iError = KErrNone;

	response.iVolume = aVolume;

	response.iMaxVolume = iClientMaxVolume;

	TRAPD(error, response.WriteL(iOutBuf));

	if (error != KErrNone)

		{

		SendError(KErrAbsoluteVolumeInternalError, KRemConSetAbsoluteVolume);

		return;

		}

	if (aErr == KErrNone)

		{

		// send the response back to the CT

		error = InterfaceSelector().SendUnreliable(

				TUid::Uid(KRemConAbsoluteVolumeTargetApiUid),

				KRemConSetAbsoluteVolume, ERemConResponse, iOutBuf );

		}

	else

		{

		SendError(KErrAbsoluteVolumeInternalError, KRemConSetAbsoluteVolume);

		}

	}

/** 

Must be called each time the volume changes on the client.

It is used to inform the controller if it has requested updates on the client

volume change.

@param aVolume The relative volume against the client maximum volume. 

@panic AbsoluteVolume 1, if volume greater than the client max volume.

*/

EXPORT_C void CRemConAbsoluteVolumeTarget::AbsoluteVolumeChanged(

		TUint32 aVolume)

	{

	__ASSERT_ALWAYS(aVolume <= iClientMaxVolume, 

			User::Panic(KAbsoluteVolumeTargetPanicName, 

					ETargetVolumeBeyondMaxVolume)

			);

	if (aVolume != iClientVolume)

		{

		// Records the current volume each time

		// when the client absolute volume is changed

		iClientVolume = aVolume;

		if (iAbsoluteVolumeNotificationRequest)

			{

			iAbsoluteVolumeNotificationRequest = EFalse;

			SendNotificationResponse(ERemConNotifyResponseChanged);

			}

		}

	}

// From MRemConInterfaceIf

void CRemConAbsoluteVolumeTarget::SendError(TInt aError, TUint aOperationId)

	{

	TInt error = KErrNone;

	RRemConAbsoluteVolumeResponse errRsp;

	errRsp.iError = aError;

	TRAP(error, errRsp.WriteL(iOutBuf));

	if (error == KErrNone)

		{

		InterfaceSelector().SendUnreliable(

				TUid::Uid(KRemConAbsoluteVolumeTargetApiUid),

				aOperationId, ERemConResponse, iOutBuf);

		}

	}

void CRemConAbsoluteVolumeTarget::MrcibNewMessage(TUint aOperationId, 

		const TDesC8& aData, 

		TRemConMessageSubType aMsgSubType)

	{

	LOG_FUNC

	LOG2(KLogFormat, aOperationId, aData.Length());

	switch(aOperationId)

		{

	case KRemConSetAbsoluteVolume:

		{

		ProcessSetAbsoluteVolume(aData);

		break;

		}

	case KRemConAbsoluteVolumeNotification:

		{

		// register for Notifications

		if (aMsgSubType == ERemConNotifyCommandAwaitingInterim)

			{

			ProcessGetStatusAndBeginObserving();

			}

		else if (aMsgSubType == ERemConNotifyCommandAwaitingChanged)

			{

			ProcessGetStatus();

			}

	 	break;

		}

	default:

		break; 

		};

	}

/**

Processes the request for setting absolute volume.

@param aData The absolute volume data to be setted.

*/

void CRemConAbsoluteVolumeTarget::ProcessSetAbsoluteVolume(

		const TDesC8& aData)

	{	

	TInt error;

	RRemConAbsoluteVolumeRequest request;

	TRAP(error, request.ReadL(aData));

	if ( error == KErrNone)

		{

		iObserver.MrcavtoSetAbsoluteVolumeRequest(request.iVolume, 

				request.iMaxVolume);

		}

	else

		{

		SendError(KErrAbsoluteVolumeInternalError, KRemConSetAbsoluteVolume);

		}

	}

/**

Processes the request for notify command waiting interim.

*/

void CRemConAbsoluteVolumeTarget::ProcessGetStatusAndBeginObserving()

	{

	//Flag is ETure to indicate the request for absolute volume change 

	//notification has been received.

	iAbsoluteVolumeNotificationRequest = ETrue;

	//send the interim response with the current absolute volume.

	SendNotificationResponse(ERemConNotifyResponseInterim);

	}

/**

Processes the request for notify command waiting changed.

*/

void CRemConAbsoluteVolumeTarget::ProcessGetStatus()

	{

	// send the current value

	SendNotificationResponse(ERemConNotifyResponseChanged);

	}

/**

Sends absolute volume interim or change response according to the message 

type aMsgSubType

@param aMsgSubType The remcon submessage type.

*/

void CRemConAbsoluteVolumeTarget::SendNotificationResponse(

		TRemConMessageSubType aMsgSubType)

	{

	LOG_FUNC

	TInt error = 0;

	RRemConAbsoluteVolumeResponse response;

	response.iError = KErrNone;

	response.iVolume = iClientVolume;

	response.iMaxVolume = iClientMaxVolume;

	TRAP(error, response.WriteL(iOutBuf));

	if (error == KErrNone)

		{

		error = InterfaceSelector().SendUnreliable(

				TUid::Uid(KRemConAbsoluteVolumeTargetApiUid),

				KRemConAbsoluteVolumeNotification, 

				ERemConResponse, 

				aMsgSubType,

				iOutBuf);

		}

	}