// 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 ;
}