// 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 <bluetooth/logger.h>
#include <remcon/avrcpspec.h>
#include <remconmediainformationtarget.h>
#include <remconmediainformationtargetobserver.h>
#include <remconinterfaceselector.h>
#include <avcframe.h>

#include "mediainformation.h"

#ifdef __FLOG_ACTIVE
_LIT8(KLogComponent, LOG_COMPONENT_AVRCP_MEDIA_INFO);
#endif

EXPORT_C CRemConMediaInformationTarget* CRemConMediaInformationTarget::NewL(CRemConInterfaceSelector& aInterfaceSelector, 
		MRemConMediaInformationTargetObserver& aObserver)
	{
	LOG_STATIC_FUNC

	CRemConMediaInformationTarget* self = new(ELeave) CRemConMediaInformationTarget(aInterfaceSelector, aObserver);
	CleanupStack::PushL(self);
	self->ConstructL();
	CleanupStack::Pop(self);
	return self;
	}

CRemConMediaInformationTarget::CRemConMediaInformationTarget(CRemConInterfaceSelector& aInterfaceSelector, 
		MRemConMediaInformationTargetObserver& aObserver)
:	CRemConInterfaceBase(TUid::Uid(KRemConMediaInformationApiUid), 
						 KMaxLengthMediaInformationMsg, 
						 aInterfaceSelector,
						 ERemConClientTypeTarget), 
	iObserver(aObserver),
	iAttributeIterator(iMediaAttributeIDs),
	iMsgQueue(_FOFF(CRemConMediaInformationQueuedMessage, iLink))
	{
	}
	
void CRemConMediaInformationTarget::ConstructL()
	{
	iResponse = new(ELeave)RRemConGetElementAttributesResponse();
	TCallBack cb(&NextMessageCb, this);
	iNextMessageCallBack = new (ELeave) CAsyncCallBack(cb, CActive::EPriorityStandard);
	BaseConstructL();
	}
	

/** Destructor.

@publishedAll
@released
*/
EXPORT_C CRemConMediaInformationTarget::~CRemConMediaInformationTarget()
	{
	iMediaAttributeIDs.Close();
	iResponse->Close();
	delete iResponse;
	iNextMessageCallBack->Cancel();
	delete iNextMessageCallBack;
	TSglQueIter<CRemConMediaInformationQueuedMessage> iter(iMsgQueue);
	CRemConMediaInformationQueuedMessage* msg;
	iter.SetToFirst();
	while ((msg = iter++) != NULL)
		{
		iMsgQueue.Remove(*msg);
		delete msg;
		}
	}

/** Gets a pointer to a specific interface version.

@return A pointer to the interface, NULL if not supported.
@internalComponent
@released
*/
TAny* CRemConMediaInformationTarget::GetInterfaceIf(TUid aUid)
	{
	TAny* ret = NULL;
	if ( aUid == TUid::Uid(KRemConInterfaceIf1) )
		{
		ret = reinterpret_cast<TAny*>(
			static_cast<MRemConInterfaceIf*>(this)
			);
		}

	return ret;
	}

EXPORT_C TInt CRemConMediaInformationTarget::AttributeValue( TMediaAttributeId aAttributeId, TDesC8& aAttributeData )
	{
	// check that the values supplied were requested
	if ( KErrNotFound == iMediaAttributeIDs.Find( aAttributeId ) )
		{
		return KErrNotFound;
		}
		
	REAResponse resp;
	resp.iAttributeId = aAttributeId;
	resp.iCharset = KUtf8MibEnum;
	resp.iStringLen = aAttributeData.Length();
	resp.iString = aAttributeData.Alloc();
	if (resp.iString == NULL)
		{
		return KErrNoMemory;
		}
	TInt status = iResponse->iAttributes.Append(resp);
	if (status != KErrNone)
		{
		resp.Close();  // make sure heap string is de-allocated
		}
	return status;
	}

// from MRemConInterfaceIf
void CRemConMediaInformationTarget::SendError(TInt aError)
	{
	RBuf8 outBuf;
	if (outBuf.Create(KAVCFrameMaxLength) != KErrNone)
		{
		// On OOM drop the message
		return;
		}
	
	TInt error = 0;
	RAvrcpIPCError response;
	response.iError = aError;
	TRAP(error, response.WriteL(outBuf));   // Don't send error if OOM
	if (error == KErrNone)
		{
		InterfaceSelector().SendUnreliable(TUid::Uid(KRemConMediaInformationApiUid),
							EGetElementAttributes, ERemConResponse, outBuf);
		}
	outBuf.Close();
	}

// from MRemConInterfaceIf
void CRemConMediaInformationTarget::MrcibNewMessage(TUint aOperationId, const TDesC8& aData )
	{
	LOG1(_L("\taOperationId = 0x%02x"), aOperationId);
	LOG1(_L("\taData.Length = %d"), aData.Length());

	(void) aOperationId; // ignore warning about this variable being unused
	
	if (!iInProgress && iMsgQueue.IsEmpty())
		{
		ProcessMessage(aData);
		}
	else
		{
		CRemConMediaInformationQueuedMessage* msg = NULL;
		TRAPD(err, msg = CRemConMediaInformationQueuedMessage::NewL(aData));
		if (err == KErrNone)
			{
			iMsgQueue.AddLast(*msg);
			}
		}
	}
	
void CRemConMediaInformationTarget::ProcessMessage(const TDesC8& aData)
	{
	iInProgress = ETrue;
	// Try to read the incoming request
	TInt error = KErrNone;
	RRemConGetElementAttributesRequest request;
	TRAP(error, request.ReadL(aData));

	// Couldn't parse the request; tell them it was invalid
	if (error != KErrNone)
		{
		request.Close();
		return SendError(KErrAvrcpMetadataParameterNotFound);
		}

	// Specification section 5.3.1 (page 49) says unique id
	// must be 0x0. All other values are currently reserved
	if (request.iElement != 0)
		{
		request.Close();
		return SendError(KErrAvrcpMetadataInvalidParameter);
		}

	// this may have been used by a previous GetElementAttributes, so
	iMediaAttributeIDs.Reset();

	if (request.iNumberAttributes == 0)
		{
		// spec says this is a request for all attribs
		// current spec has 7 specified (0x01 to 0x07)
		for (TInt i = 1; i <= 7; i++)
			{
			if (iMediaAttributeIDs.Append((TMediaAttributeId)i) != KErrNone)
				{
				request.Close();
				return SendError(KErrAvrcpMetadataInternalError);
				}
			}
		}
	else
		{
		// No need to check request.iNumberAttributes == request.iAttributes.Count()
		// as this must be correct or request.ReadL(aData) leaves
		for (TInt i = 0; i < request.iNumberAttributes; i++)
			{
			TUint8 value = request.iAttributes[i];
			if (value > 0 && value <= KMaxMediaAttributeValue )
				{
				if (iMediaAttributeIDs.Append((TMediaAttributeId)value) != KErrNone)
					{
						request.Close();
						return SendError(KErrAvrcpMetadataInternalError);
					}
				}
			}
		}
	request.Close();

	// check that some valid attribute ids have been found
	if (iMediaAttributeIDs.Count())
		{
		// if the client has not yet called Completed() on the last request
		// clear the the attributes from the previous response
		iResponse->Close();
		
		// reset the interator to the start, as it may have been used before
		iAttributeIterator.Start();
		
		// call the client API to get the client value.
		iObserver.MrcmitoGetCurrentlyPlayingMetadata(iAttributeIterator);
		}
	else
		{
		// no valid attribute ids found so return an error to bearer
		SendError(KErrAvrcpMetadataParameterNotFound);
		}
	}

// The client application has signaled that all attributes have been returned so 
// response can now be sent
EXPORT_C void CRemConMediaInformationTarget::Completed()
	{
	if (!iInProgress)
		{
		return;
		}
	// Finalise response; update number of attributes returned
	iResponse->iNumberAttributes = iResponse->iAttributes.Count();

	//Check the bound of the number of attributes, zero is not permitted
	if (iResponse->iNumberAttributes == 0)
		{
		return SendError(KErrAvrcpMetadataInternalError);
		}
	
	// Allocate a buffer for the formatted message
	RBuf8 messageBuffer;
	if ( messageBuffer.Create(iResponse->Size()) != KErrNone )
		{
		// On OOM drop the message
		iResponse->Close();
		return;
		}
		
	// send the result back to the CT
	TInt error = KErrNone;
	TRAP(error, iResponse->WriteL(messageBuffer));
	if (error == KErrNone)
		{
		InterfaceSelector().SendUnreliable(TUid::Uid(KRemConMediaInformationApiUid),
								EGetElementAttributes, ERemConResponse, messageBuffer);
		}
	
	// Make sure attribute list is reset for next time
	iResponse->Close();
	messageBuffer.Close();
	
	iInProgress = EFalse;
	if (!iMsgQueue.IsEmpty())
		{
		iNextMessageCallBack->CallBack();
		}
	
	}

int CRemConMediaInformationTarget::NextMessageCb(TAny* aThis)
	{
	static_cast<CRemConMediaInformationTarget*>(aThis)->DoNextMessage();
	return KErrNone;
	}

void CRemConMediaInformationTarget::DoNextMessage()
	{
	CRemConMediaInformationQueuedMessage* msg = iMsgQueue.First();
	iMsgQueue.Remove(*msg);
	ProcessMessage(msg->Data());
	delete msg;
	}

EXPORT_C TMediaAttributeIter::TMediaAttributeIter(RArray<TMediaAttributeId>& aMediaAttributeIDs) :
    iMediaAttributeIDs(aMediaAttributeIDs),
    iterator(0)
	{
	}

EXPORT_C void TMediaAttributeIter::Start()
	{
	iterator = 0;
	}

EXPORT_C TBool TMediaAttributeIter::Next(TMediaAttributeId& aId)
	{
	TInt count = iMediaAttributeIDs.Count();
	if (iterator > count - 1)
		{
		return EFalse;
		}
	aId = iMediaAttributeIDs[iterator];
	iterator++;
	return ETrue;
	}

CRemConMediaInformationQueuedMessage* CRemConMediaInformationQueuedMessage::NewL(const TDesC8& aData)
	{
	CRemConMediaInformationQueuedMessage* self = new (ELeave) CRemConMediaInformationQueuedMessage();
	CleanupStack::PushL(self);
	self->ConstructL(aData);
	CleanupStack::Pop(self);
	return self;
	}

CRemConMediaInformationQueuedMessage::CRemConMediaInformationQueuedMessage()
	{
	
	}

void CRemConMediaInformationQueuedMessage::ConstructL(const TDesC8& aData)
	{
	iData.CreateL(aData);
	}

CRemConMediaInformationQueuedMessage::~CRemConMediaInformationQueuedMessage()
	{
	iData.Close();
	}

const TDesC8& CRemConMediaInformationQueuedMessage::Data()
	{
	return iData;
	}