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

//

#ifndef __A2DPBTHEADSETAUDIOIFSERVER_H__

#define __A2DPBTHEADSETAUDIOIFSERVER_H__

#include <e32base.h>

#include <mmf/common/mmfipc.h>

#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS

#include <mmf/common/mmfipcserver.h>

#endif

#include "A2dpBTHeadsetAudioIfClientServer.h"

class CA2dpBTHeadsetAudioInterface; // fwd declaration

class TFourCC;

class TRange;

/**

 *	CA2dpBTHeadsetAudioIfServer definition

 */

class CA2dpBTHeadsetAudioIfServer : public CMmfIpcServer

	{

public:

	IMPORT_C static TInt StartThread(TAny* aParms);	// thread entry point

	static CA2dpBTHeadsetAudioIfServer* NewL();

	~CA2dpBTHeadsetAudioIfServer();

	CMmfIpcSession* NewSessionL(const TVersion &aVersion) const;

private:

	CA2dpBTHeadsetAudioIfServer();

	void ConstructL();

private:

	CA2dpBTHeadsetAudioInterface* iBTAudioInterface;

	};

/**

 *	CA2dpBTHeadsetIfEventHandler

 */

class CA2dpBTHeadsetIfEventHandler : public CActive

	{

public:

	static CA2dpBTHeadsetIfEventHandler* NewL();

	~CA2dpBTHeadsetIfEventHandler();

	void StartL(const RMmfIpcMessage& aMessage);

	void Stop();

private:

	CA2dpBTHeadsetIfEventHandler();

	void RunL();

	void DoCancel();

	void ConstructL();

private:

	RMmfIpcMessage* iMessage;	

	};

/**

 *	CA2dpBTHeadsetAudioIfSession definition

 */

class CA2dpBTHeadsetAudioIfSession : public CMmfIpcSession

	{

public:

	static CA2dpBTHeadsetAudioIfSession* NewL(CA2dpBTHeadsetAudioInterface* aBTAudioInterface);

 	~CA2dpBTHeadsetAudioIfSession();

	void ServiceL(const RMessage2& aMessage);

private:

	CA2dpBTHeadsetAudioIfSession(CA2dpBTHeadsetAudioInterface* aBTAudioInterface);

	void ConstructL();

	TBool DoInitializeL(const RMmfIpcMessage& aMessage);

	TBool DoCancelInitializeL(const RMmfIpcMessage& aMessage);

	TBool DoCopyFourCCArrayDataL(const RMmfIpcMessage& aMessage);

	TBool DoCopyUintArrayDataL(const RMmfIpcMessage& aMessage, RArray<TUint> aArray);

	TBool DoCopyChannelsArrayDataL(const RMmfIpcMessage& aMessage);

	TInt  DoGetSupportedDataTypesL(const RMmfIpcMessage& aMessage);// returns error value

	TInt  DoGetSupportedSampleRatesL(const RMmfIpcMessage& aMessage);

	TBool DoGetSupportedSampleRatesDiscreteL(const RMmfIpcMessage& aMessage);

	TBool DoGetSupportedSampleRatesRangeL(const RMmfIpcMessage& aMessage);

	TInt  DoGetSupportedChannelsL(const RMmfIpcMessage& aMessage);

	TBool DoGetStereoSupportL(const RMmfIpcMessage& aMessage);

	TInt DoSetDataTypeL(const RMmfIpcMessage& aMessage);	// returns error value

	TInt DoSetSampleRateL(const RMmfIpcMessage& aMessage);// returns error value

	TInt DoSetChannelsL(const RMmfIpcMessage& aMessage);// returns error value

	TBool DoOpenDeviceL(const RMmfIpcMessage& aMessage);

	TBool DoCancelOpenDevice(const RMmfIpcMessage& aMessage);

	TBool DoCloseDeviceL(const RMmfIpcMessage& aMessage);

	TBool DoVolumeL(const RMmfIpcMessage& aMessage);

	TInt DoSetVolumeL(const RMmfIpcMessage& aMessage);// returns error value

	TBool DoPlayDataL(const RMmfIpcMessage& aMessage);

	TBool DoCancelPlayDataL(const RMmfIpcMessage& aMessage);

	TBool DoFlushBufferL(const RMmfIpcMessage& aMessage);

	TBool DoBytesPlayedL(const RMmfIpcMessage& aMessage);

	TBool DoResetBytesPlayedL(const RMmfIpcMessage& aMessage);

	TBool DoPauseBufferL(const RMmfIpcMessage& aMessage);

	TBool DoResumePlayingL(const RMmfIpcMessage& aMessage);

	TBool DoNotifyErrorL(const RMmfIpcMessage& aMessage);

	TBool DoCancelNotifyErrorL(const RMmfIpcMessage& aMessage);

private:

	CA2dpBTHeadsetAudioInterface* iBTAudioInterface;	// Not owned

	// Hmm - one handler per asynch call and then no need to store messages?

	CA2dpBTHeadsetIfEventHandler* iInitHandler;	// AO to manage asynch calls to the interface

	CA2dpBTHeadsetIfEventHandler* iOpenDeviceHandler;	// AO to manage asynch calls to the interface

	CA2dpBTHeadsetIfEventHandler* iCloseDeviceHandler;	// AO to manage asynch calls to the interface

	CA2dpBTHeadsetIfEventHandler* iPlayDataHandler;	// AO to manage asynch calls to the interface

	CA2dpBTHeadsetIfEventHandler* iNotifyErrorHandler;	// AO to manage asynch calls to the interface

	RArray<TFourCC> iFourCCArray;

	RArray<TUint> iDiscreteArray;

	RArray<TRange> iRangeArray;

	RArray<TUint> iStereoSupportArray;

	};

#endif