1 /*

     2 * Copyright (c) 2005 Nokia Corporation and/or its subsidiary(-ies).

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:    Implementation.

    15 *

    16 */

    17 

    18 

    19 

    20 

    21 #include "CTcMCEMultimediaAPIObserver.h"

    22 #include "CTcMCEContext.h"

    23 

    24 #include "MCEConstants.h"

    25 

    26 #include "CTcMCEReceived.h"

    27 

    28 #include <MceInSession.h>

    29 #include <MCEAudioStream.h>

    30 #include <MCESpeakerSink.h>

    31 #include <MceMediaStream.h>

    32 #include <MceRtpSource.h>

    33 #include <MCEMicSource.h>

    34 

    35 

    36 

    37 CTcMCEMultimediaAPIObserver* CTcMCEMultimediaAPIObserver::NewL( 

    38 			CTcMCEContext& aContext )

    39 	{

    40 	CTcMCEMultimediaAPIObserver* self = 

    41 			new (ELeave) CTcMCEMultimediaAPIObserver( aContext );

    42 			

    43 	CleanupStack::PushL( self );

    44 	self->ConstructL();

    45 	CleanupStack::Pop( self );

    46 	

    47 	return self;

    48 	}

    49 

    50 CTcMCEMultimediaAPIObserver::CTcMCEMultimediaAPIObserver(

    51 			CTcMCEContext& aContext):

    52 	iContext(aContext)

    53 	{

    54 	}

    55 

    56 void CTcMCEMultimediaAPIObserver::ConstructL()

    57 	{

    58 	iSessionQueue = CTcMCEReceiveQueue::NewL( iContext );

    59 	iUpdatedSessionQueue = CTcMCEReceiveQueue::NewL( iContext );

    60 	iStreamQueue = CTcMCEReceiveQueue::NewL( iContext );

    61 	iRTPQueue = CTcMCEReceiveQueue::NewL( iContext );

    62 	}

    63 

    64 CTcMCEMultimediaAPIObserver::~CTcMCEMultimediaAPIObserver()

    65 	{

    66 	delete iSessionQueue;

    67 	delete iUpdatedSessionQueue;

    68 	delete iStreamQueue;

    69 	delete iRTPQueue;

    70 	}

    71 

    72 

    73 // -- Queue getters ------------------------------------------------------------

    74 

    75 CTcMCEReceived& CTcMCEMultimediaAPIObserver::ReceivedSessionItemL

    76 		( TInt aTimeout )

    77 	{

    78 	return iSessionQueue->ReceivedItemL( aTimeout );	

    79 	}

    80 

    81 CTcMCEReceived& CTcMCEMultimediaAPIObserver::ReceivedUpdatedSessionItemL

    82 		( TInt aTimeout )

    83 	{

    84 	return iUpdatedSessionQueue->ReceivedItemL( aTimeout );	

    85 	}

    86 

    87 

    88 CTcMCEReceived& CTcMCEMultimediaAPIObserver::ReceivedStreamItemL

    89 		( TInt aTimeout )

    90 	{

    91 	return iStreamQueue->ReceivedItemL( aTimeout );	

    92 	}

    93 

    94 CTcMCEReceived& CTcMCEMultimediaAPIObserver::ReceivedRTPItemL( TInt aTimeout )

    95 	{

    96 	return iRTPQueue->ReceivedItemL( aTimeout );	

    97 	}

    98 		

    99 

   100 // -- From MMceInSessionObserver--------------------------------------------------

   101 

   102 void CTcMCEMultimediaAPIObserver::IncomingSession(

   103 			CMceInSession* aSession,

   104             TMceTransactionDataContainer* aContainer )

   105 	{

   106 	TRAPD( err, {	

   107 

   108 		CTcMCEReceived* received = new(ELeave) CTcMCEReceived;

   109 				

   110 		received->SetInSession( aSession ); 

   111         received->SetTransactionData( aContainer );

   112     

   113 		iSessionQueue->QueueReceivedL( received );	

   114 	 

   115 	    } )	

   116 	__ASSERT_ALWAYS( !err, User::Panic( KMceErrOOMInObserver, err ));		

   117 	}

   118 

   119 void CTcMCEMultimediaAPIObserver::IncomingUpdate(

   120 					CMceSession& aOrigSession, 

   121 					CMceInSession* aUpdatedSession,

   122     				TMceTransactionDataContainer* aContainer ) 

   123 	{

   124 	TRAPD( err, {	

   125 

   126 		CTcMCEReceived* received = new(ELeave) CTcMCEReceived;

   127 		//Can ask from incoming session if the session state is updated		

   128 		received->SetIncomingUpdateSession( aOrigSession, aUpdatedSession ); 

   129         received->SetTransactionData( aContainer );

   130     

   131 		iUpdatedSessionQueue->QueueReceivedL( received );	

   132 	 

   133 	    } )	

   134 	__ASSERT_ALWAYS( !err, User::Panic( KMceErrOOMInObserver, err ));

   135 	}

   136 

   137 

   138 // -- From MMceSessionObserver -------------------------------------------------

   139 	

   140 void CTcMCEMultimediaAPIObserver::SessionStateChanged(

   141             CMceSession& aSession,

   142             TMceTransactionDataContainer* aContainer )

   143 	{

   144 	TRAPD( err, {		

   145 		// Add a message to message queue	

   146 		CTcMCEReceived* received = new(ELeave) CTcMCEReceived;

   147 		received->SetSession( &aSession );

   148 		received->SetSessionState( aSession.State() );

   149         received->SetTransactionData( aContainer );

   150 

   151 		iSessionQueue->QueueReceivedL( received );		

   152 		} )	

   153 	__ASSERT_ALWAYS( !err, User::Panic( KMceErrOOMInObserver, err ));

   154 	}

   155 		

   156 void CTcMCEMultimediaAPIObserver::SessionConnectionStateChanged(

   157             CMceSession& aSession,

   158             TBool /*aActive*/) 

   159 	{

   160 	TRAPD( err, {	

   161 		CTcMCEReceived* received = new(ELeave) CTcMCEReceived;

   162 		received->SetSession( &aSession );

   163 		// aActive can be asked from session

   164 		// iSessionQueue->QueueReceivedL( received ); NOT YET	

   165 		} )	

   166 	__ASSERT_ALWAYS( !err, User::Panic( KMceErrOOMInObserver, err ));	

   167 	}

   168                     

   169 void CTcMCEMultimediaAPIObserver::Failed( CMceSession& aSession, TInt aError )

   170 	{

   171  	TRAPD( err, {	   

   172 	    // Add an error to message queue	

   173 		CTcMCEReceived* received = new(ELeave) CTcMCEReceived;

   174 		received->SetSession( &aSession );

   175 	    received->SetError( aError );	

   176 

   177 		iSessionQueue->QueueReceivedL( received );	

   178 		} )	

   179 	__ASSERT_ALWAYS( !err, User::Panic( KMceErrOOMInObserver, err ));		

   180     }

   181 

   182 void CTcMCEMultimediaAPIObserver::UpdateFailed(

   183 	    			CMceSession& aSession,

   184 	    			TMceTransactionDataContainer* aContainer ) 

   185 	{

   186 	TRAPD( err, {		

   187 		// Add a message to message queue	

   188 		CTcMCEReceived* received = new(ELeave) CTcMCEReceived;

   189 		received->SetSession( &aSession );

   190 		received->SetSessionState( aSession.State() );

   191         received->SetTransactionData( aContainer );

   192 

   193 		iSessionQueue->QueueReceivedL( received );		

   194 		} )	

   195 	__ASSERT_ALWAYS( !err, User::Panic( KMceErrOOMInObserver, err ));	

   196 	}

   197 

   198 // -- from MMceStreamObserver --------------------------------------------------

   199 

   200 void CTcMCEMultimediaAPIObserver::StreamStateChanged( CMceMediaStream& aStream )

   201 	{

   202  	TRAPD( err, {	    

   203 		CTcMCEReceived* received = new(ELeave) CTcMCEReceived;

   204 		received->SetMediaStream( &aStream );

   205 		received->SetStreamState( aStream.State() );

   206 

   207 		iStreamQueue->QueueReceivedL( received );

   208 		} )

   209 	__ASSERT_ALWAYS( !err, User::Panic( KMceErrOOMInObserver, err ));

   210 	}

   211 	

   212 void CTcMCEMultimediaAPIObserver::StreamStateChanged( 

   213 			CMceMediaStream& aStream, 

   214 			CMceMediaSink& aSink )

   215     {

   216 	TRAPD( err, {	   	

   217 		CTcMCEReceived* received = new(ELeave) CTcMCEReceived;

   218 		received->SetMediaStream( &aStream );

   219 		received->SetMediaSink( &aSink );

   220 		received->SetStreamState( aStream.State() );

   221 		

   222 		iStreamQueue->QueueReceivedL( received );	 

   223 		} )	

   224 	__ASSERT_ALWAYS( !err, User::Panic( KMceErrOOMInObserver, err ));

   225 	}

   226 	

   227 void CTcMCEMultimediaAPIObserver::StreamStateChanged( 

   228 			CMceMediaStream& aStream, 

   229 			CMceMediaSource& aSource)

   230 	{

   231 	TRAPD( err, {	   	

   232 		CTcMCEReceived* received = new(ELeave) CTcMCEReceived;

   233 		received->SetMediaStream( &aStream );

   234 		received->SetMediaSource( &aSource );

   235 		received->SetStreamState( aStream.State() );

   236 		

   237 		iStreamQueue->QueueReceivedL( received );	 

   238 		} )	

   239 	__ASSERT_ALWAYS( !err, User::Panic( KMceErrOOMInObserver, err ));

   240 	}

   241 

   242 

   243 // -- from MMceRtpObserver -----------------------------------------------------

   244 

   245 void CTcMCEMultimediaAPIObserver::SRReceived( 

   246 			CMceSession& aSession,

   247 			CMceMediaStream& aStream )

   248 	{

   249 	TRAPD( err, {	   

   250 		CTcMCEReceived* received = new(ELeave) CTcMCEReceived;

   251 		received->SetMediaStream( &aStream );

   252 		if ( aStream.Source()->Type() == KMceRTPSource )

   253 			{

   254 			CMceRtpSource* source = static_cast<CMceRtpSource*>( aStream.Source() );

   255 			received->SetRtpSource( source );			

   256 			}

   257 		received->SetSession( &aSession );

   258 		iRTPQueue->QueueReceivedL( received );	 

   259 		} )	

   260 	__ASSERT_ALWAYS( !err, User::Panic( KMceErrOOMInObserver, err ));

   261 	}

   262 

   263 void CTcMCEMultimediaAPIObserver::RRReceived( 

   264 			CMceSession& aSession,

   265 			CMceMediaStream& aStream )

   266 	{

   267 	TRAPD( err, {	   

   268 		CTcMCEReceived* received = new(ELeave) CTcMCEReceived;

   269 		received->SetMediaStream( &aStream );

   270 		if ( aStream.Source()->Type() == KMceRTPSource )

   271 			{

   272 			CMceRtpSource* source = static_cast<CMceRtpSource*>( aStream.Source() );

   273 			received->SetRtpSource( source );			

   274 			}

   275 		received->SetSession( &aSession );

   276 		iRTPQueue->QueueReceivedL( received );	 

   277 		} )	

   278 	__ASSERT_ALWAYS( !err, User::Panic( KMceErrOOMInObserver, err ));

   279 	}

   280 		

   281 void CTcMCEMultimediaAPIObserver::InactivityTimeout( 

   282 			CMceMediaStream& aStream,

   283 			CMceRtpSource& aSource )

   284 	{

   285 	TRAPD( err, {	   

   286 		CTcMCEReceived* received = new(ELeave) CTcMCEReceived;

   287 		received->SetMediaStream( &aStream );

   288 		received->SetRtpSource( &aSource );

   289 		received->SetType(KTcMceInactivityTimeout);

   290 		iRTPQueue->QueueReceivedL( received );	 

   291 		} )	

   292 	__ASSERT_ALWAYS( !err, User::Panic( KMceErrOOMInObserver, err ));

   293 	}

   294 

   295 void CTcMCEMultimediaAPIObserver::SsrcAdded( 

   296 			CMceMediaStream& /*aStream*/,

   297 			CMceRtpSource& /*aSource*/,

   298 			TUint /*aSsrc*/ )

   299 	{

   300 	}

   301 

   302 void CTcMCEMultimediaAPIObserver::SsrcRemoved( 

   303 			CMceMediaStream& /*aStream*/,

   304 			CMceRtpSource& /*aSource*/,

   305 			TUint /*aSsrc*/ )

   306 	{

   307 	}

   308 

   309 

   310 // -- from MMceTransactionObserver ---------------------------------------------

   311 

   312 void CTcMCEMultimediaAPIObserver::TransactionResponse(

   313 	CMceSession& aSession,

   314 	TMceTransactionId aTransactionId,

   315 	TMceTransactionDataContainer* aContainer )

   316 	{

   317 	TRAPD( err, {

   318 		CTcMCEReceived* received = new ( ELeave ) CTcMCEReceived;

   319 		received->SetSession( &aSession );

   320 		received->SetTransactionId( aTransactionId );

   321         received->SetTransactionData( aContainer );

   322 

   323         // "received" must not be in CleanupStack when calling QueueReceivedL,

   324         // which calls CTcRegistry::AddObjectL (see its comments).

   325 

   326     	// GetMessage command reads this queue.

   327 		iSessionQueue->QueueReceivedL( received );

   328 	    } )	

   329 	__ASSERT_ALWAYS( !err, User::Panic( KMceErrOOMInObserver, err ) );

   330 	}

   331 

   332 void CTcMCEMultimediaAPIObserver::TransactionFailed(

   333     CMceSession& aSession,

   334 	TMceTransactionId aTransactionId, 

   335 	TInt aError )

   336 	{

   337 	TRAPD( err, {	   

   338 	    // Add an error to message queue	

   339 		CTcMCEReceived* received = new ( ELeave ) CTcMCEReceived;

   340 		received->SetSession( &aSession );

   341 		received->SetTransactionId( aTransactionId );

   342 	    received->SetError( aError );	

   343 

   344 		// "received" must not be in CleanupStack when calling QueueReceivedL,

   345         // which calls CTcRegistry::AddObjectL (see its comments).

   346 		iSessionQueue->QueueReceivedL( received );

   347 		} )	

   348 	__ASSERT_ALWAYS( !err, User::Panic( KMceErrOOMInObserver, err ) );

   349 	}

   350 

   351 

   352 // -- from MMceInTransactionObserver -------------------------------------------

   353 

   354 void CTcMCEMultimediaAPIObserver::IncomingRequest(

   355 	const TDesC8& aMethod,

   356 	CMceSession& aSession,

   357 	TMceTransactionId aTransactionId,

   358 	TMceTransactionDataContainer* aContainer )

   359 	{

   360 	TRAPD( err, {

   361 		CTcMCEReceived* received = new ( ELeave ) CTcMCEReceived;

   362 		received->SetSession( &aSession );

   363 

   364 		CleanupStack::PushL( received );

   365 		received->SetMethodL( aMethod );

   366 		CleanupStack::Pop( received );

   367 

   368 		received->SetTransactionId( aTransactionId );

   369         received->SetTransactionData( aContainer );

   370 

   371     	// "received" must not be in CleanupStack when calling QueueReceivedL,

   372         // which calls CTcRegistry::AddObjectL (see its comments).

   373 		iSessionQueue->QueueReceivedL( received );

   374 	    } )	

   375 	__ASSERT_ALWAYS( !err, User::Panic( KMceErrOOMInObserver, err ) );

   376 	}