multimediacommsengine/tsrc/MMCTestDriver/MCETester/src/CTcMCEMultimediaAPIObserver.cpp
/*
* Copyright (c) 2005 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: Implementation.
*
*/
#include "CTcMCEMultimediaAPIObserver.h"
#include "CTcMCEContext.h"
#include "MCEConstants.h"
#include "CTcMCEReceived.h"
#include <MceInSession.h>
#include <MCEAudioStream.h>
#include <MCESpeakerSink.h>
#include <MceMediaStream.h>
#include <MceRtpSource.h>
#include <MCEMicSource.h>
CTcMCEMultimediaAPIObserver* CTcMCEMultimediaAPIObserver::NewL(
CTcMCEContext& aContext )
{
CTcMCEMultimediaAPIObserver* self =
new (ELeave) CTcMCEMultimediaAPIObserver( aContext );
CleanupStack::PushL( self );
self->ConstructL();
CleanupStack::Pop( self );
return self;
}
CTcMCEMultimediaAPIObserver::CTcMCEMultimediaAPIObserver(
CTcMCEContext& aContext):
iContext(aContext)
{
}
void CTcMCEMultimediaAPIObserver::ConstructL()
{
iSessionQueue = CTcMCEReceiveQueue::NewL( iContext );
iUpdatedSessionQueue = CTcMCEReceiveQueue::NewL( iContext );
iStreamQueue = CTcMCEReceiveQueue::NewL( iContext );
iRTPQueue = CTcMCEReceiveQueue::NewL( iContext );
}
CTcMCEMultimediaAPIObserver::~CTcMCEMultimediaAPIObserver()
{
delete iSessionQueue;
delete iUpdatedSessionQueue;
delete iStreamQueue;
delete iRTPQueue;
}
// -- Queue getters ------------------------------------------------------------
CTcMCEReceived& CTcMCEMultimediaAPIObserver::ReceivedSessionItemL
( TInt aTimeout )
{
return iSessionQueue->ReceivedItemL( aTimeout );
}
CTcMCEReceived& CTcMCEMultimediaAPIObserver::ReceivedUpdatedSessionItemL
( TInt aTimeout )
{
return iUpdatedSessionQueue->ReceivedItemL( aTimeout );
}
CTcMCEReceived& CTcMCEMultimediaAPIObserver::ReceivedStreamItemL
( TInt aTimeout )
{
return iStreamQueue->ReceivedItemL( aTimeout );
}
CTcMCEReceived& CTcMCEMultimediaAPIObserver::ReceivedRTPItemL( TInt aTimeout )
{
return iRTPQueue->ReceivedItemL( aTimeout );
}
// -- From MMceInSessionObserver--------------------------------------------------
void CTcMCEMultimediaAPIObserver::IncomingSession(
CMceInSession* aSession,
TMceTransactionDataContainer* aContainer )
{
TRAPD( err, {
CTcMCEReceived* received = new(ELeave) CTcMCEReceived;
received->SetInSession( aSession );
received->SetTransactionData( aContainer );
iSessionQueue->QueueReceivedL( received );
} )
__ASSERT_ALWAYS( !err, User::Panic( KMceErrOOMInObserver, err ));
}
void CTcMCEMultimediaAPIObserver::IncomingUpdate(
CMceSession& aOrigSession,
CMceInSession* aUpdatedSession,
TMceTransactionDataContainer* aContainer )
{
TRAPD( err, {
CTcMCEReceived* received = new(ELeave) CTcMCEReceived;
//Can ask from incoming session if the session state is updated
received->SetIncomingUpdateSession( aOrigSession, aUpdatedSession );
received->SetTransactionData( aContainer );
iUpdatedSessionQueue->QueueReceivedL( received );
} )
__ASSERT_ALWAYS( !err, User::Panic( KMceErrOOMInObserver, err ));
}
// -- From MMceSessionObserver -------------------------------------------------
void CTcMCEMultimediaAPIObserver::SessionStateChanged(
CMceSession& aSession,
TMceTransactionDataContainer* aContainer )
{
TRAPD( err, {
// Add a message to message queue
CTcMCEReceived* received = new(ELeave) CTcMCEReceived;
received->SetSession( &aSession );
received->SetSessionState( aSession.State() );
received->SetTransactionData( aContainer );
iSessionQueue->QueueReceivedL( received );
} )
__ASSERT_ALWAYS( !err, User::Panic( KMceErrOOMInObserver, err ));
}
void CTcMCEMultimediaAPIObserver::SessionConnectionStateChanged(
CMceSession& aSession,
TBool /*aActive*/)
{
TRAPD( err, {
CTcMCEReceived* received = new(ELeave) CTcMCEReceived;
received->SetSession( &aSession );
// aActive can be asked from session
// iSessionQueue->QueueReceivedL( received ); NOT YET
} )
__ASSERT_ALWAYS( !err, User::Panic( KMceErrOOMInObserver, err ));
}
void CTcMCEMultimediaAPIObserver::Failed( CMceSession& aSession, TInt aError )
{
TRAPD( err, {
// Add an error to message queue
CTcMCEReceived* received = new(ELeave) CTcMCEReceived;
received->SetSession( &aSession );
received->SetError( aError );
iSessionQueue->QueueReceivedL( received );
} )
__ASSERT_ALWAYS( !err, User::Panic( KMceErrOOMInObserver, err ));
}
void CTcMCEMultimediaAPIObserver::UpdateFailed(
CMceSession& aSession,
TMceTransactionDataContainer* aContainer )
{
TRAPD( err, {
// Add a message to message queue
CTcMCEReceived* received = new(ELeave) CTcMCEReceived;
received->SetSession( &aSession );
received->SetSessionState( aSession.State() );
received->SetTransactionData( aContainer );
iSessionQueue->QueueReceivedL( received );
} )
__ASSERT_ALWAYS( !err, User::Panic( KMceErrOOMInObserver, err ));
}
// -- from MMceStreamObserver --------------------------------------------------
void CTcMCEMultimediaAPIObserver::StreamStateChanged( CMceMediaStream& aStream )
{
TRAPD( err, {
CTcMCEReceived* received = new(ELeave) CTcMCEReceived;
received->SetMediaStream( &aStream );
received->SetStreamState( aStream.State() );
iStreamQueue->QueueReceivedL( received );
} )
__ASSERT_ALWAYS( !err, User::Panic( KMceErrOOMInObserver, err ));
}
void CTcMCEMultimediaAPIObserver::StreamStateChanged(
CMceMediaStream& aStream,
CMceMediaSink& aSink )
{
TRAPD( err, {
CTcMCEReceived* received = new(ELeave) CTcMCEReceived;
received->SetMediaStream( &aStream );
received->SetMediaSink( &aSink );
received->SetStreamState( aStream.State() );
iStreamQueue->QueueReceivedL( received );
} )
__ASSERT_ALWAYS( !err, User::Panic( KMceErrOOMInObserver, err ));
}
void CTcMCEMultimediaAPIObserver::StreamStateChanged(
CMceMediaStream& aStream,
CMceMediaSource& aSource)
{
TRAPD( err, {
CTcMCEReceived* received = new(ELeave) CTcMCEReceived;
received->SetMediaStream( &aStream );
received->SetMediaSource( &aSource );
received->SetStreamState( aStream.State() );
iStreamQueue->QueueReceivedL( received );
} )
__ASSERT_ALWAYS( !err, User::Panic( KMceErrOOMInObserver, err ));
}
// -- from MMceRtpObserver -----------------------------------------------------
void CTcMCEMultimediaAPIObserver::SRReceived(
CMceSession& aSession,
CMceMediaStream& aStream )
{
TRAPD( err, {
CTcMCEReceived* received = new(ELeave) CTcMCEReceived;
received->SetMediaStream( &aStream );
if ( aStream.Source()->Type() == KMceRTPSource )
{
CMceRtpSource* source = static_cast<CMceRtpSource*>( aStream.Source() );
received->SetRtpSource( source );
}
received->SetSession( &aSession );
iRTPQueue->QueueReceivedL( received );
} )
__ASSERT_ALWAYS( !err, User::Panic( KMceErrOOMInObserver, err ));
}
void CTcMCEMultimediaAPIObserver::RRReceived(
CMceSession& aSession,
CMceMediaStream& aStream )
{
TRAPD( err, {
CTcMCEReceived* received = new(ELeave) CTcMCEReceived;
received->SetMediaStream( &aStream );
if ( aStream.Source()->Type() == KMceRTPSource )
{
CMceRtpSource* source = static_cast<CMceRtpSource*>( aStream.Source() );
received->SetRtpSource( source );
}
received->SetSession( &aSession );
iRTPQueue->QueueReceivedL( received );
} )
__ASSERT_ALWAYS( !err, User::Panic( KMceErrOOMInObserver, err ));
}
void CTcMCEMultimediaAPIObserver::InactivityTimeout(
CMceMediaStream& aStream,
CMceRtpSource& aSource )
{
TRAPD( err, {
CTcMCEReceived* received = new(ELeave) CTcMCEReceived;
received->SetMediaStream( &aStream );
received->SetRtpSource( &aSource );
received->SetType(KTcMceInactivityTimeout);
iRTPQueue->QueueReceivedL( received );
} )
__ASSERT_ALWAYS( !err, User::Panic( KMceErrOOMInObserver, err ));
}
void CTcMCEMultimediaAPIObserver::SsrcAdded(
CMceMediaStream& /*aStream*/,
CMceRtpSource& /*aSource*/,
TUint /*aSsrc*/ )
{
}
void CTcMCEMultimediaAPIObserver::SsrcRemoved(
CMceMediaStream& /*aStream*/,
CMceRtpSource& /*aSource*/,
TUint /*aSsrc*/ )
{
}
// -- from MMceTransactionObserver ---------------------------------------------
void CTcMCEMultimediaAPIObserver::TransactionResponse(
CMceSession& aSession,
TMceTransactionId aTransactionId,
TMceTransactionDataContainer* aContainer )
{
TRAPD( err, {
CTcMCEReceived* received = new ( ELeave ) CTcMCEReceived;
received->SetSession( &aSession );
received->SetTransactionId( aTransactionId );
received->SetTransactionData( aContainer );
// "received" must not be in CleanupStack when calling QueueReceivedL,
// which calls CTcRegistry::AddObjectL (see its comments).
// GetMessage command reads this queue.
iSessionQueue->QueueReceivedL( received );
} )
__ASSERT_ALWAYS( !err, User::Panic( KMceErrOOMInObserver, err ) );
}
void CTcMCEMultimediaAPIObserver::TransactionFailed(
CMceSession& aSession,
TMceTransactionId aTransactionId,
TInt aError )
{
TRAPD( err, {
// Add an error to message queue
CTcMCEReceived* received = new ( ELeave ) CTcMCEReceived;
received->SetSession( &aSession );
received->SetTransactionId( aTransactionId );
received->SetError( aError );
// "received" must not be in CleanupStack when calling QueueReceivedL,
// which calls CTcRegistry::AddObjectL (see its comments).
iSessionQueue->QueueReceivedL( received );
} )
__ASSERT_ALWAYS( !err, User::Panic( KMceErrOOMInObserver, err ) );
}
// -- from MMceInTransactionObserver -------------------------------------------
void CTcMCEMultimediaAPIObserver::IncomingRequest(
const TDesC8& aMethod,
CMceSession& aSession,
TMceTransactionId aTransactionId,
TMceTransactionDataContainer* aContainer )
{
TRAPD( err, {
CTcMCEReceived* received = new ( ELeave ) CTcMCEReceived;
received->SetSession( &aSession );
CleanupStack::PushL( received );
received->SetMethodL( aMethod );
CleanupStack::Pop( received );
received->SetTransactionId( aTransactionId );
received->SetTransactionData( aContainer );
// "received" must not be in CleanupStack when calling QueueReceivedL,
// which calls CTcRegistry::AddObjectL (see its comments).
iSessionQueue->QueueReceivedL( received );
} )
__ASSERT_ALWAYS( !err, User::Panic( KMceErrOOMInObserver, err ) );
}