// Copyright (c) 2001-2009 Nokia Corporation and/or its subsidiary(-ies).

 // All rights reserved.

 // This component and the accompanying materials are made available

 // under the terms of the License "Symbian Foundation License v1.0" to Symbian Foundation members and "Symbian Foundation End User License Agreement v1.0" to non-members

 // which accompanies this distribution, and is available

 // at the URL "http://www.symbianfoundation.org/legal/licencesv10.html".

 //

 // Initial Contributors:

 // Nokia Corporation - initial contribution.

 //

 // Contributors:

 //

 // Description:

 //

 #ifndef __MMFDATAPATHPROXY_H__

 #define __MMFDATAPATHPROXY_H__

 #include <e32base.h>

 #include <e32std.h>

 #include <ecom/ecom.h>

 #include <mmf/server/mmfdatapath.h>

 #include <mmf/server/mmfsubthreadbase.h>

 #define KMMFDataPathProxyVersion TVersion(8,0,0)

 /**

 The amount of time that is allowed for the datapath to close down before the its thread is killed.

 */

 #define  KMMFDataPathProxyShutdownTimeout TTimeIntervalMicroSeconds32(10000000)

 /**

 @publishedAll

 @released

 Mixin class that the user of the class CMMFDataPathEventMonitor must derive from.

 @since 7.0s

 */

 class MMMFDataPathEventMonitorObserver

 	{

 public:

 	/**

 	Handles an event that has been generated by the datapath.

 	Called by CMMFDataPathEventMonitor::RunL().

 	@param  aEvent

 	        The event to be handled.

 	@since  7.0s

 	*/

 	virtual void HandleEvent(const TMMFEvent& aEvent) = 0;

 	};

 class RMMFDataPathProxy; //forward reference

 /**

 @publishedAll

 @released

 Active object utility class that can be used to monitor a datapath that is running in its own

 thread for events. If an event occurs, the client will be notified via the

 MMMFDataPathEventMonitorObserver interface.

 @since  7.0s

 */

 class CMMFDataPathEventMonitor : public CActive

 	{

 public:

 	IMPORT_C static CMMFDataPathEventMonitor* NewL(MMMFDataPathEventMonitorObserver& aObserver,

 		RMMFDataPathProxy& aMMFDataPathProxy);

 	IMPORT_C ~CMMFDataPathEventMonitor();

 	IMPORT_C void Start();

 	IMPORT_C void RunL();

 protected:

 	void DoCancel();

 private:

 	/**

 	Constructs a datapath event monitor object.

 	@param  aObserver

 	        A reference to the observer of the active object. The observer will be

 	        notified when an event occurs.

 	@param  aMMFDataPathProxy

 	        A reference to the datapath proxy class.

 	@since  7.0s

 	*/

 	CMMFDataPathEventMonitor(MMMFDataPathEventMonitorObserver& aObserver, 

 		RMMFDataPathProxy& aMMFDataPathProxy);

 private:

 	MMMFDataPathEventMonitorObserver& iObserver;

 	RMMFDataPathProxy& iMMFDataPathProxy;

 	TMMFEventPckg iEventPckg;

 	};

 /**

 @publishedAll

 @released

 Proxy class used to create a datapath in a new subthread.

 */

 class RMMFDataPathProxy : public RMMFSubThreadBase

 	{

 public:

 	/**

 	Constuctor.

 	*/

 	RMMFDataPathProxy() : RMMFSubThreadBase(KMMFDataPathProxyShutdownTimeout) {};

 	IMPORT_C TInt CreateSubThread();

 	IMPORT_C TInt LoadDataPath();

 	IMPORT_C TInt LoadDataPath(TMediaId aMediaId);

 	IMPORT_C TInt LoadDataPath(TUid aCodecUid); 

 	IMPORT_C TInt LoadDataPath(TUid aCodecUid, TMediaId aMediaId);

 	IMPORT_C TInt AddDataSource(MDataSource* aSource);

 	IMPORT_C TInt AddDataSink(MDataSink* aSink);

 	IMPORT_C TInt Prime();

 	IMPORT_C TInt Play();

 	IMPORT_C TInt Pause();

 	IMPORT_C TInt Stop();

 	IMPORT_C TInt GetPosition(TTimeIntervalMicroSeconds& aPosition) const;

 	IMPORT_C TInt SetPosition(const TTimeIntervalMicroSeconds& aPosition);

 	IMPORT_C TInt SetPlayWindow( const TTimeIntervalMicroSeconds& aStart, const TTimeIntervalMicroSeconds& aEnd ) ;

 	IMPORT_C TInt ClearPlayWindow() ;

 	IMPORT_C TInt State( TInt& aState ) ;

 	IMPORT_C void Close();

 	};

 /**

 @internalComponent

 The server running in the datapath subthread.

 The subthread is owned by the main thread and shares the same heap.

 */

 class CMMFDataPathProxyServer : public CMMFSubThreadServer

 	{

 public:

 	static CMMFDataPathProxyServer* NewL();

 	~CMMFDataPathProxyServer();

 	static TInt StartThread(TAny* aAny);

 	static void DoStartThreadL();

 private:

 	CMmfIpcSession* NewSessionL(const TVersion& aVersion) const;

 	CMMFDataPathProxyServer();

 	void ConstructL();

 	};

 /**

 @internalComponent

 The session used to transmit messages between the main thread and the subthread.

 Only one session can be created with a datapath subthread.

 Once this session is closed, the subthread will be killed.

 */

 class CMMFDataPathProxySession : public CMMFSubThreadSession

 	{

 public:

 	static CMMFDataPathProxySession* NewL();

 	~CMMFDataPathProxySession();

 	void ServiceL(const RMmfIpcMessage& aMessage);

 private:

 	CMMFDataPathProxySession();

 	TBool LoadDataPathByL(const RMmfIpcMessage& aMessage);

 	TBool LoadDataPathByMediaIdL(const RMmfIpcMessage& aMessage);

 	TBool LoadDataPathByCodecUidL(const RMmfIpcMessage& aMessage);

 	TBool LoadDataPathByMediaIdCodecUidL(const RMmfIpcMessage& aMessage);

 	TBool AddDataSourceL(const RMmfIpcMessage& aMessage);

 	TBool AddDataSinkL(const RMmfIpcMessage& aMessage);

 	TBool PrimeL(const RMmfIpcMessage& aMessage);

 	TBool PlayL(const RMmfIpcMessage& aMessage);

 	TBool PauseL(const RMmfIpcMessage& aMessage);

 	TBool StopL(const RMmfIpcMessage& aMessage);

 	TBool GetPositionL(const RMmfIpcMessage& aMessage) const;

 	TBool SetPositionL(const RMmfIpcMessage& aMessage);

 	TBool SetPlayWindowL(const RMmfIpcMessage& aMessage) ;

 	TBool ClearPlayWindowL(const RMmfIpcMessage& aMessage) ;

 	TBool StateL(const RMmfIpcMessage& aMessage) ;

 	void CheckDataPathExistsL() const {if (!iDataPath) User::Leave(KErrNotReady);};

 private:

 	CMMFDataPath* iDataPath;

 	};

 #endif