// Copyright (c) 2002-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 <e32math.h>

 #include <mmf/server/mmfdatapathproxy.h>

 #ifdef SYMBIAN_ENABLE_SPLIT_HEADERS

 #include <mmf/server/mmfdatapathproxyserver.h>

 #endif

 /**

 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 client datapath proxy class.

 @return A pointer to the new event monitor.

 @since 7.0s

 */

 EXPORT_C CMMFDataPathEventMonitor* CMMFDataPathEventMonitor::NewL(MMMFDataPathEventMonitorObserver& aObserver,

 															 RMMFDataPathProxy& aMMFDataPathProxy)

 	{

 	return (new(ELeave) CMMFDataPathEventMonitor(aObserver, aMMFDataPathProxy));

 	}

 CMMFDataPathEventMonitor::CMMFDataPathEventMonitor(MMMFDataPathEventMonitorObserver& aObserver, 

 													   RMMFDataPathProxy& aMMFDataPathProxy) :

 	CActive(EPriorityStandard),

 	iObserver(aObserver), 

 	iMMFDataPathProxy(aMMFDataPathProxy)

 	{

 	CActiveScheduler::Add(this);

 	}

 /**

 Destructor.

 Calls Cancel().

 */

 EXPORT_C CMMFDataPathEventMonitor::~CMMFDataPathEventMonitor()

 	{

 	Cancel();

 	}

 /**

 Tells the datapath event monitor to start listening for events.

 The datapath proxy must have been opened before this method is called.

 @since  7.0s

 */

 EXPORT_C void CMMFDataPathEventMonitor::Start()

 	{

 	iMMFDataPathProxy.ReceiveEvents(iEventPckg, iStatus);

 	SetActive();

 	}

 /**

 Internal active object function.

 Starts the data path event monitor and handles an event if there is no error status.

 Calls HandleEvent on iObserver.

 @since  7.0s

 */

 EXPORT_C void CMMFDataPathEventMonitor::RunL()

 	{

 	if (iStatus.Int() == KErrNone)

 		{

 		iObserver.HandleEvent(iEventPckg());

 		Start();

 		}

 	else

 		{

 		//something's gone wrong with trying to receive events (e.g. server died etc)

 		TMMFEvent event(KMMFErrorCategoryDataPathGeneralError, iStatus.Int());

 		iObserver.HandleEvent(event);

 		//we don't want to receive events again here...

 		}

 	}

 /**

 Cancels the outstanding request on iMMFDataPathProxy.

 @since  7.0s

 */

 void CMMFDataPathEventMonitor::DoCancel()

 	{

 	iMMFDataPathProxy.CancelReceiveEvents();

 	}

 /**

 Creates a subthread that will contain the datapath.

 @return An error code indicating if the function call was successful. KErrNone on success, otherwise

         another of the system-wide error codes.

 @since 7.0s

 */

 EXPORT_C TInt RMMFDataPathProxy::CreateSubThread()

 	{

 	//start the subthread with a unique name

 	TName subThreadName(_L("MMFDataPathThread"));

 	subThreadName.AppendNum(Math::Random(),EHex);

 	TInt error = DoCreateSubThread(subThreadName, &CMMFDataPathProxyServer::StartThread);

 	if (error)

 		return error;

 	//now create a session with the subthread

 	error = CreateSession(subThreadName, KMMFDataPathProxyVersion);

 	return error;

 	}

 // Note: in the following, we can pass straight addresses for writing since both client and server

 // are in the same process.

 /**

 Load the datapath in the new thread. Use this method if the codec UID is not known

 and there is no datapath ambiguity, ie. only one datapath is possible.

 @return An error code indicating if the function call was successful. KErrNone on success, otherwise

         another of the system-wide error codes.

 @since 7.0s

 */

 EXPORT_C TInt RMMFDataPathProxy::LoadDataPath()

 	{

 	return SendReceive(EMMFDataPathProxyLoadDataPathBy);

 	}

 /**

 Load the datapath in the new thread. 

 Use this method if the codec UID is not known but the TMediaId can be used to select which codec 

 to use.

 @param  aMediaId

 	    The type of media to be handled by this datapath.

 @return An error code indicating if the function call was successful. KErrNone on success, otherwise

         another of the system-wide error codes.

 @since  7.0s

 */

 EXPORT_C TInt RMMFDataPathProxy::LoadDataPath(TMediaId aMediaId)

 	{

 	return SendReceive (EMMFDataPathProxyLoadDataPathByMediaId, TInt(&aMediaId));

 	}

 /**

 Load the datapath in the new thread. 

 Use this method if the codec UID is known and there is no datapath ambiguity, ie. only one datapath

 is possible.

 @param  aCodecUid

         The UID of the codec plugin to be used by the datapath.

 @return An error code indicating if the function call was successful. KErrNone on success, otherwise

         another of the system-wide error codes.

 @since  7.0s

 */

 EXPORT_C TInt RMMFDataPathProxy::LoadDataPath(TUid aCodecUid) 

 	{

 	return SendReceive(EMMFDataPathProxyLoadDataPathByCodecUid, TInt(&aCodecUid));

 	}

 /**

 Loads the datapath in the new thread. 

 Use this method if the codec UID is known and there is datapath ambiguity. The TMediaId will be

 used to choose the correct path.

 @param  aCodecUid

         The UID of the codec plugin to be used by the datapath.

 @param  aMediaId

         The type of media to be handled by this datapath.

 @return An error code indicating if the function call was successful. KErrNone on success, otherwise

         another of the system-wide error codes.

 @since  7.0s

 */

 EXPORT_C TInt RMMFDataPathProxy::LoadDataPath(TUid aCodecUid, TMediaId aMediaId)

 	{

 	return SendReceive(EMMFDataPathProxyLoadDataPathByMediaIdCodecUid, TInt(&aCodecUid), TInt(&aMediaId));

 	}

 /**

 Specify the data source for this datapath.

 If the sink already exists, this function tries to establish a connection between the source and 

 sink. Note that only one data source can be added to the datapath.

 @param  aSource

         A pointer to the data source.

 @return An error code indicating if the function call was successful. KErrNone on success, otherwise

         another of the system-wide error codes.

 @since 7.0s

 */

 EXPORT_C TInt RMMFDataPathProxy::AddDataSource(MDataSource* aSource)

 	{

 	return SendReceive(EMMFDataPathProxyAddDataSource, TInt(aSource));

 	}

 /**

 Specify the data sink for this datapath.  

 If the source already exists, this function tries to establish a connection between the source and 

 the sink. Note that only one data sink can be added to the datapath.

 @param  aSink

         A pointer to the data sink.

 @return An error code indicating if the function call was successful. KErrNone on success, otherwise

         another of the system-wide error codes.

 @since  7.0s

 */

 EXPORT_C TInt RMMFDataPathProxy::AddDataSink(MDataSink* aSink)

 	{

 	return SendReceive(EMMFDataPathProxyAddDataSink, TInt(aSink));

 	}

 /**

 Transfer the datapath from the stopped into the primed state.

 This function allocates buffers in preparation to play and must be called before calling PlayL().

 @return An error code indicating if the function call was successful. KErrNone on success, otherwise

         another of the system-wide error codes.

 @since  7.0s

 */

 EXPORT_C TInt RMMFDataPathProxy::Prime()

 	{

 	return SendReceive(EMMFDataPathProxyPrime);

 	}

 /**

 Transfer the datapath from the primed into the playing state.

 This function starts an active scheduler play loop and can only play from the primed state.

 @return An error code indicating if the function call was successful. KErrNone on success, otherwise

         another of the system-wide error codes.

 @since 7.0s

 */

 EXPORT_C TInt RMMFDataPathProxy::Play()

 	{

 	return SendReceive(EMMFDataPathProxyPlay);

 	}

 /**

 Pauses playing.

 This function transfers the datapath from the playing into the primed state and sends 

 KMMFErrorCategoryDataPathGeneralError to the client if an error occurs.

 @return An error code indicating if the function call was successful. KErrNone on success, otherwise

         another of the system-wide error codes.

 @since  7.0s

 */

 EXPORT_C TInt RMMFDataPathProxy::Pause()

 	{

 	return SendReceive(EMMFDataPathProxyPause);

 	}

 /**

 Stops playing.

 This function transfers the datapath from the primed into the stopped state and resets the data 

 path position, but does not clean up buffers. It also sends KMMFErrorCategoryDataPathGeneralError 

 to the client if an error occurs.

 @return An error code indicating if the function call was successful. KErrNone on success, otherwise

         another of the system-wide error codes.

 @since  7.0s

 */

 EXPORT_C TInt RMMFDataPathProxy::Stop()

 	{

 	return SendReceive(EMMFDataPathProxyStop);

 	}

 /**

 Gets the current position of the datapath in units of time.

 @param  aPosition

         The current position in micro seconds will be copied into this variable.

 @return An error code indicating if the function call was successful. KErrNone on success, otherwise

         another of the system-wide error codes.

 @since  7.0s

 */

 EXPORT_C TInt RMMFDataPathProxy::GetPosition(TTimeIntervalMicroSeconds& aPosition) const

 	{

 	return SendReceive(EMMFDataPathProxyGetPosition, TInt(&aPosition));

 	}

 /**

 Sets the current position of the datapath in units of time.

 @param  aPosition

         The required position in micro seconds.

 @return An error code indicating if the function call was successful. KErrNone on success, otherwise

         another of the system-wide error codes.

 @since 7.0s

 **/

 EXPORT_C TInt RMMFDataPathProxy::SetPosition(const TTimeIntervalMicroSeconds& aPosition)

 	{

 	return SendReceive(EMMFDataPathProxySetPosition, TInt(&aPosition));

 	}

 /**

 Sets the play window relative to the start of the entire clip.

 @param  aStart

         The start position in micro seconds relative to the start of the clip.

 @param  aEnd

         The end position in micro seconds relative to the start of the clip.

 @return An error code indicating if the function call was successful. KErrNone on success, otherwise

         another of the system-wide error codes.

 @since  7.0s

 */

 EXPORT_C TInt RMMFDataPathProxy::SetPlayWindow( const TTimeIntervalMicroSeconds& aStart, const TTimeIntervalMicroSeconds& aEnd )

 	{

 	return SendReceive( EMMFDataPathProxySetPlayWindow, TInt(&aStart), TInt(&aEnd)) ;

 	}

 /**

 Removes a previously defined play window.

 @return An error code indicating if the function call was successful. KErrNone on success, otherwise

         another of the system-wide error codes.

 @since  7.0s

 */

 EXPORT_C TInt RMMFDataPathProxy::ClearPlayWindow()

 	{

 	return SendReceive( EMMFDataPathProxyClearPlayWindow) ;

 	}

 /**

 Gets the current datapath state.

 @param  aState

         The current state of the datapath will be copied into this variable.

 @return An error code indicating if the function call was successful. KErrNone on success, otherwise

         another of the system-wide error codes.

 @since  7.0s

 */

 EXPORT_C TInt RMMFDataPathProxy::State( TInt& aState )

 	{

 	return SendReceive( EMMFDataPathProxyState, TInt(&aState) ) ; // pass address, not value

 	}

 /**

 Deletes the datapath and shuts down the datapath proxy thread.

 Calls RMMFSubThreadBase::Shutdown(). This function will not return until the subthread has 

 exited, or a timeout has occurred.

 @since  7.0s

 */

 EXPORT_C void RMMFDataPathProxy::Close()

 	{

 	Shutdown();

 	}

 CMMFDataPathProxyServer* CMMFDataPathProxyServer::NewL()

 	{

 	CMMFDataPathProxyServer* s = new(ELeave) CMMFDataPathProxyServer();

 	CleanupStack::PushL(s);

 	s->ConstructL();

 	CleanupStack::Pop();

 	return s;

 	}

 CMMFDataPathProxyServer::CMMFDataPathProxyServer() :

 	CMMFSubThreadServer(EPriorityStandard)

 	{

 	}

 void CMMFDataPathProxyServer::ConstructL()

 	{

 	//just need to call baseclass's constructL here

 	CMMFSubThreadServer::ConstructL();

 	}

 CMMFDataPathProxyServer::~CMMFDataPathProxyServer()

 	{

 	}

 CMmfIpcSession* CMMFDataPathProxyServer::NewSessionL(const TVersion& aVersion) const

 	{

 	if (!User::QueryVersionSupported(KMMFDataPathProxyVersion, aVersion))

 		User::Leave(KErrNotSupported);

 	return CMMFDataPathProxySession::NewL();

 	}

 TInt CMMFDataPathProxyServer::StartThread(TAny*)

 	{

 	TInt err = KErrNone;

 	//create cleanupstack

 	CTrapCleanup* cleanup=CTrapCleanup::New(); // get clean-up stack

 	if (!cleanup)

 		err = KErrNoMemory;

 	if (!err)

 		{

 		TRAP(err, DoStartThreadL());

 		}

 	delete cleanup;

 	return err;

 	}

 void CMMFDataPathProxyServer::DoStartThreadL()

 	{

 	// create and install the active scheduler we need

 	CActiveScheduler* s=new(ELeave) CActiveScheduler;

 	CleanupStack::PushL(s);

 	CActiveScheduler::Install(s);

 	// create the server (leave it on the cleanup stack)

 	CleanupStack::PushL(CMMFDataPathProxyServer::NewL());

 	// Initialisation complete, now signal the client

 	RThread::Rendezvous(KErrNone);

 	// Ready to run

 	CActiveScheduler::Start();

 	// Cleanup the server and scheduler

 	CleanupStack::PopAndDestroy(2);

 	REComSession::FinalClose(); // fix 047933

 	}

 CMMFDataPathProxySession* CMMFDataPathProxySession::NewL()

 	{

 	return new(ELeave) CMMFDataPathProxySession();

 	}

 CMMFDataPathProxySession::CMMFDataPathProxySession()

 	{

 	}

 CMMFDataPathProxySession::~CMMFDataPathProxySession()

 	{

 	delete iDataPath;

 	}

 void CMMFDataPathProxySession::ServiceL(const RMmfIpcMessage& aMessage)

 	{

 	TBool complete = EFalse;

 	switch(aMessage.Function())

 		{

 	case EMMFDataPathProxyLoadDataPathBy:

 		complete = LoadDataPathByL(aMessage);

 		break;

 	case EMMFDataPathProxyLoadDataPathByMediaId:

 		complete = LoadDataPathByMediaIdL(aMessage);

 		break;

 	case EMMFDataPathProxyLoadDataPathByCodecUid:

 		complete = LoadDataPathByCodecUidL(aMessage);

 		break;

 	case EMMFDataPathProxyLoadDataPathByMediaIdCodecUid:

 		complete = LoadDataPathByMediaIdCodecUidL(aMessage);

 		break;

 	case EMMFDataPathProxyAddDataSource:

 		complete = AddDataSourceL(aMessage);

 		break;

 	case EMMFDataPathProxyAddDataSink:

 		complete = AddDataSinkL(aMessage);

 		break;

 	case EMMFDataPathProxyPrime:

 		complete = PrimeL(aMessage);

 		break;

 	case EMMFDataPathProxyPlay:

 		complete = PlayL(aMessage);

 		break;

 	case EMMFDataPathProxyPause:

 		complete = PauseL(aMessage);

 		break;

 	case EMMFDataPathProxyStop:

 		complete = StopL(aMessage);

 		break;

 	case EMMFDataPathProxyGetPosition:

 		complete = GetPositionL(aMessage);

 		break;

 	case EMMFDataPathProxySetPosition:

 		complete = SetPositionL(aMessage);

 		break;

 	case EMMFDataPathProxySetPlayWindow :

 		complete = SetPlayWindowL(aMessage) ;

 		break;

 	case EMMFDataPathProxyClearPlayWindow:

 		complete = ClearPlayWindowL(aMessage);

 		break;

 	case EMMFDataPathProxyState:

 		complete = StateL(aMessage);

 		break;

 	case EMMFSubThreadReceiveEvents:

 		complete = ReceiveEventsL(aMessage);//provided by baseclass

 		break;

 	case EMMFSubThreadCancelReceiveEvents:

 		complete = CancelReceiveEvents();//provided by baseclass

 		break;

 	case EMMFSubThreadShutdown:

 		complete = ShutDown();//provided by baseclass

 		break;

 	default:

 		User::Leave(KErrNotSupported);

 		break;

 		}

 	if (complete)

 		aMessage.Complete(KErrNone);

 	}

 TBool CMMFDataPathProxySession::LoadDataPathByL(const RMmfIpcMessage& /*aMessage*/)

 	{

 	if (iDataPath)

 		User::Leave(KErrAlreadyExists);

 	iDataPath = CMMFDataPath::NewL(*this);

 	return ETrue;

 	}

 TBool CMMFDataPathProxySession::LoadDataPathByMediaIdL(const RMmfIpcMessage& aMessage)

 	{

 	if (iDataPath)

 		User::Leave(KErrAlreadyExists);

 	TMediaId* mediaId = REINTERPRET_CAST(TMediaId*, aMessage.Int0());

 	iDataPath = CMMFDataPath::NewL(*mediaId, *this);

 	return ETrue;

 	}

 TBool CMMFDataPathProxySession::LoadDataPathByCodecUidL(const RMmfIpcMessage& aMessage)

 	{

 	if (iDataPath)

 		User::Leave(KErrAlreadyExists);

 	TUid* uid = REINTERPRET_CAST(TUid*, aMessage.Int0());

 	iDataPath = CMMFDataPath::NewL(*uid, *this);

 	return ETrue;

 	}

 TBool CMMFDataPathProxySession::LoadDataPathByMediaIdCodecUidL(const RMmfIpcMessage& aMessage)

 	{

 	if (iDataPath)

 		User::Leave(KErrAlreadyExists);

 	TUid* uid = REINTERPRET_CAST(TUid*, aMessage.Int0());

 	TMediaId* mediaId = REINTERPRET_CAST(TMediaId*, aMessage.Int1());

 	iDataPath = CMMFDataPath::NewL(*uid, *mediaId, *this);

 	return ETrue;

 	}

 TBool CMMFDataPathProxySession::AddDataSourceL(const RMmfIpcMessage& aMessage)

 	{

 	CheckDataPathExistsL();

 	MDataSource* source = REINTERPRET_CAST(MDataSource*, aMessage.Int0());

 	iDataPath->AddDataSourceL(source);

 	return ETrue;

 	}

 TBool CMMFDataPathProxySession::AddDataSinkL(const RMmfIpcMessage& aMessage)

 	{

 	CheckDataPathExistsL();

 	MDataSink* sink = REINTERPRET_CAST(MDataSink*, aMessage.Int0());

 	iDataPath->AddDataSinkL(sink);

 	return ETrue;

 	}

 TBool CMMFDataPathProxySession::PrimeL(const RMmfIpcMessage& /*aMessage*/)

 	{

 	CheckDataPathExistsL();

 	iDataPath->PrimeL();

 	return ETrue;

 	}

 TBool CMMFDataPathProxySession::PlayL(const RMmfIpcMessage& /*aMessage*/)

 	{

 	CheckDataPathExistsL();

 	iDataPath->PlayL();

 	return ETrue;

 	}

 TBool CMMFDataPathProxySession::PauseL(const RMmfIpcMessage& /*aMessage*/)

 	{

 	CheckDataPathExistsL();

 	iDataPath->Pause();

 	return ETrue;

 	}

 TBool CMMFDataPathProxySession::StopL(const RMmfIpcMessage& /*aMessage*/)

 	{

 	CheckDataPathExistsL();

 	iDataPath->Stop();

 	return ETrue;

 	}

 TBool CMMFDataPathProxySession::GetPositionL(const RMmfIpcMessage& aMessage) const

 	{

 	CheckDataPathExistsL();

 	TTimeIntervalMicroSeconds* t = REINTERPRET_CAST(TTimeIntervalMicroSeconds*, aMessage.Int0());

 	*t = iDataPath->Position();

 	return ETrue;

 	}

 TBool CMMFDataPathProxySession::SetPositionL(const RMmfIpcMessage& aMessage)

 	{

 	CheckDataPathExistsL();

 	TTimeIntervalMicroSeconds* t = REINTERPRET_CAST(TTimeIntervalMicroSeconds*, aMessage.Int0());

 	iDataPath->SetPositionL(*t);

 	return ETrue;

 	}

 TBool CMMFDataPathProxySession::SetPlayWindowL(const RMmfIpcMessage& aMessage) 

 	{

 	CheckDataPathExistsL() ;

 	TTimeIntervalMicroSeconds* start = REINTERPRET_CAST( TTimeIntervalMicroSeconds*, aMessage.Int0() ) ;

 	TTimeIntervalMicroSeconds* end = REINTERPRET_CAST( TTimeIntervalMicroSeconds*, aMessage.Int1() ) ;

 	iDataPath->SetPlayWindowL( *start, *end ) ;

 	return ETrue;

 	}

 TBool CMMFDataPathProxySession::ClearPlayWindowL(const RMmfIpcMessage& /*aMessage*/)

 	{

 	CheckDataPathExistsL() ;

 	iDataPath->ClearPlayWindowL() ;

 	return ETrue ;

 	}

 TBool CMMFDataPathProxySession::StateL(const RMmfIpcMessage& aMessage)

 	{

 	CheckDataPathExistsL() ;

 	TInt* state = REINTERPRET_CAST( TInt*, aMessage.Int0() ) ;

 	*state = iDataPath->State();

 	return ETrue ;

 	}