/*
* Copyright (c) 2007 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 "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: Offers interface to RMsgQueue in civilized manner.*
*/
// INCLUDE FILES
#include "CCRMsgQueueObserver.h"
#include <ipvideo/MCREngineObserver.h>
#include <ipvideo/CRTypeDefs.h>
#include "videoserviceutilsLogger.h"
// CONSTANTS
// None
// ============================ MEMBER FUNCTIONS ===============================
// -----------------------------------------------------------------------------
// CCRMsgQueueObserver::NewL
// Two-phased constructor.
// -----------------------------------------------------------------------------
//
CCRMsgQueueObserver* CCRMsgQueueObserver::NewL()
{
CCRMsgQueueObserver* self = new( ELeave ) CCRMsgQueueObserver();
CleanupStack::PushL( self );
self->ConstructL();
CleanupStack::Pop( self );
return self;
}
// -----------------------------------------------------------------------------
// CCRMsgQueueObserver::CCRMsgQueueObserver()
// C++ default constructor can NOT contain any code, that might leave.
// -----------------------------------------------------------------------------
//
CCRMsgQueueObserver::CCRMsgQueueObserver() : CActive( EPriorityAbsoluteHigh )
{
// Note! CActive's priority must be absolute high for ensure that
// the messages are arrived in right order to VIA.
CActiveScheduler::Add( this );
}
// -----------------------------------------------------------------------------
// CCRMsgQueueObserver::ConstructL()
// Symbian 2nd phase constructor can leave.
// -----------------------------------------------------------------------------
//
void CCRMsgQueueObserver::ConstructL()
{
LOG( "CCRMsgQueueObserver::ConstructL() in" );
RProcess process;
TInt handleId( process.Handle() );
TBuf<KCRQueueNameLength> queueName;
queueName.Format(KCRMsgQueueName, handleId);
queueName.Trim();
TInt err( iQueue.CreateGlobal( queueName,
sizeof( SCRQueueEntry ) ) );
LOG2( "CCRMsgQueueObserver createglobal %S = %d", &queueName, err );
err = iQueue.OpenGlobal( queueName ) ;
LOG1( "CCRMsgQueueObserver openglobal = %d", err );
User::LeaveIfError( err );
iQueue.NotifyDataAvailable( iStatus );
LOG1( "CCRMsgQueueObserver queue message size is %d", iQueue.MessageSize() );
SetActive();
LOG( "CCRMsgQueueObserver::ConstructL() out" );
}
// -----------------------------------------------------------------------------
// CCRMsgQueueObserver::~CCRMsgQueueObserver()
// Destructor.
// -----------------------------------------------------------------------------
//
CCRMsgQueueObserver::~CCRMsgQueueObserver()
{
LOG( "CCRMsgQueueObserver::~CCRMsgQueueObserver() in" );
Cancel();
iQueue.Close();
iObservers.Reset();
iObservers.Close();
LOG( "CCRMsgQueueObserver::~CCRMsgQueueObserver() out" );
}
// -----------------------------------------------------------------------------
// CCRMsgQueueObserver::RunL()
// From CActive
// -----------------------------------------------------------------------------
//
void CCRMsgQueueObserver::RunL()
{
LOG1( "CCRMsgQueueObserver::RunL() in, iStatus: %d", iStatus.Int() );
if ( iStatus.Int() == KErrNone )
{
TInt i( 0 );
if ( iQueue.Receive( iReceivedMessage ) == KErrNone )
{
if ( !iReceivedMessage.iSessionId || // or our id has not been set yet
iReceivedMessage.iSessionId == iSessionId ) // if the id matches
{
switch ( iReceivedMessage.iMsg )
{
case ECRMsgQueueAuthenticationNeeded:
LOG( "CCRMsgQueueObserver EAuthenticationFailed" );
SCRObserverMsg authNotify;
authNotify.iMsg = ECRAuthenticationNeeded;
authNotify.iErr = iReceivedMessage.iErr;
for ( i = 0; i < iObservers.Count(); i ++ )
{
TRAP_IGNORE( iObservers[i]->NotifyL( authNotify ) );
}
break;
case ECRMsgQueueAttachCompleted:
{
LOG( "CCRMsgQueueObserver ECRMsgQueueAttachCompleted" );
SCRObserverMsg iapNotify;
iapNotify.iMsg = ECRAttachCompleted;
iapNotify.iErr = iReceivedMessage.iErr;
for ( i = 0; i < iObservers.Count(); i ++ )
{
TRAP_IGNORE( iObservers[i]->NotifyL( iapNotify ) );
}
}
break;
case ECRMsgQueueConnectionError:
{
LOG1( "CCRMsgQueueObserver ECRMsgQueueConnectionError, iReceivedMessage.iErr: %d",
iReceivedMessage.iErr );
SCRObserverMsg iapNotify;
iapNotify.iMsg = ECRConnectionError;
iapNotify.iErr = iReceivedMessage.iErr;
for ( i = 0; i < iObservers.Count(); i ++ )
{
TRAP_IGNORE( iObservers[i]->NotifyL( iapNotify ) );
}
}
break;
case ECRMsgQueueNotEnoughBandwidth:
{
LOG( "CCRMsgQueueObserver ECRMsgQueueNotEnoughBandwidth" );
SCRObserverMsg iapNotify;
iapNotify.iMsg = ECRNotEnoughBandwidth;
iapNotify.iErr = iReceivedMessage.iErr;
for ( i = 0; i < iObservers.Count(); i ++ )
{
TRAP_IGNORE( iObservers[i]->NotifyL( iapNotify ) );
}
}
break;
case ECRMsgQueueSwitchingToTcp:
{
LOG( "CCRMsgQueueObserver ECRMsgQueueSwitchingToTcp" );
SCRObserverMsg iapNotify;
iapNotify.iMsg = ECRSwitchingToTcp;
iapNotify.iErr = iReceivedMessage.iErr;
for ( i = 0; i < iObservers.Count(); i ++ )
{
TRAP_IGNORE( iObservers[i]->NotifyL( iapNotify ) );
}
}
break;
case ECRMsgQueueNormalEndOfStream:
{
LOG( "CCRMsgQueueObserver ECRMsgQueueNormalEndOfStream" );
SCRObserverMsg iapNotify;
iapNotify.iMsg = ECRNormalEndOfStream;
iapNotify.iErr = iReceivedMessage.iErr;
for ( i = 0; i < iObservers.Count(); i ++ )
{
TRAP_IGNORE( iObservers[i]->NotifyL( iapNotify ) );
}
}
break;
case ECRMsgQueueStreamIsLiveStream:
{
LOG( "CCRMsgQueueObserver ECRMsgStreamIsLiveStream" );
SCRObserverMsg liveStreamNotify;
liveStreamNotify.iMsg = ECRStreamIsLiveStream;
liveStreamNotify.iErr = iReceivedMessage.iErr;
for ( i = 0; i < iObservers.Count(); i ++ )
{
TRAP_IGNORE( iObservers[i]->NotifyL( liveStreamNotify ) );
}
}
break;
case ECRMsgQueueStreamIsRealMedia:
{
LOG( "CCRMsgQueueObserver ECRMsgQueueStreamIsRealMedia" );
SCRObserverMsg realStreamNotify;
realStreamNotify.iMsg = ECRRealNetworksStream;
realStreamNotify.iErr = iReceivedMessage.iErr;
for ( i = 0; i < iObservers.Count(); i ++ )
{
TRAP_IGNORE( iObservers[i]->NotifyL( realStreamNotify ) );
}
}
break;
case ECRMsgQueueTestSinkData:
{
LOG( "CCRMsgQueueObserver ECRMsgQueueTestSinkData" );
SCRObserverMsg testSinkDataNotify;
testSinkDataNotify.iMsg = ECRTestSinkData;
testSinkDataNotify.iErr = iReceivedMessage.iErr;
for ( i = 0; i < iObservers.Count(); i ++ )
{
TRAP_IGNORE( iObservers[i]->NotifyL( testSinkDataNotify ) );
}
}
break;
case ECRMsgQueueSdpAvailable:
{
LOG( "CCRMsgQueueObserver ECRMsgQueueSdpAvailable" );
SCRObserverMsg sdpAvailableNotify;
sdpAvailableNotify.iMsg = ECRSdpAvailable;
sdpAvailableNotify.iErr = iReceivedMessage.iErr;
for ( i = 0; i < iObservers.Count(); i ++ )
{
TRAP_IGNORE( iObservers[i]->NotifyL( sdpAvailableNotify ) );
}
}
break;
case ECRMsgQueueReadyToSeek:
{
LOG( "CCRMsgQueueObserver ECRMsgQueueReadyToSeek" );
SCRObserverMsg readyToSeekNotify;
readyToSeekNotify.iMsg = ECRReadyToSeek;
readyToSeekNotify.iErr = iReceivedMessage.iErr;
for ( i = 0; i < iObservers.Count(); i ++ )
{
TRAP_IGNORE( iObservers[i]->NotifyL( readyToSeekNotify ) );
}
}
break;
case ECRMsgQueueRecordingStarted:
{
LOG( "CCRMsgQueueObserver ECRMsgQueueRecordingStarted" );
SCRObserverMsg realStreamNotify;
realStreamNotify.iMsg = ECRRecordingStarted;
realStreamNotify.iErr = iReceivedMessage.iErr;
for ( i = 0; i < iObservers.Count(); i ++ )
{
TRAP_IGNORE( iObservers[i]->NotifyL( realStreamNotify ) );
}
}
break;
case ECRMsgQueueRecordingPaused:
{
LOG( "CCRMsgQueueObserver ECRMsgQueueRecordingState" );
SCRObserverMsg realStreamNotify;
realStreamNotify.iMsg = ECRRecordingPaused;
realStreamNotify.iErr = iReceivedMessage.iErr;
for ( i = 0; i < iObservers.Count(); i ++ )
{
TRAP_IGNORE( iObservers[i]->NotifyL( realStreamNotify ) );
}
}
break;
case ECRMsgQueueRecordingEnded:
{
LOG( "CCRMsgQueueObserver ECRMsgQueueRecordingState" );
SCRObserverMsg realStreamNotify;
realStreamNotify.iMsg = ECRRecordingEnded;
realStreamNotify.iErr = iReceivedMessage.iErr;
for ( i = 0; i < iObservers.Count(); i ++ )
{
TRAP_IGNORE( iObservers[i]->NotifyL( realStreamNotify ) );
}
}
break;
default:
{
LOG1( "Unknown message: %d", iReceivedMessage.iMsg );
}
break;
}
}
else // message belongs to different session
{
LOG2( "Ignoring message: msg.sessionId=%d, iSessionId=%d",
iReceivedMessage.iSessionId, iSessionId );
}
}
}
iQueue.NotifyDataAvailable( iStatus );
SetActive();
LOG( "CCRMsgQueueObserver::RunL() out" );
}
// -----------------------------------------------------------------------------
// CCRMsgQueueObserver::RunError()
// From CActive
// -----------------------------------------------------------------------------
//
TInt CCRMsgQueueObserver::RunError( TInt aError )
{
LOG1( "CCRMsgQueueObserver::RunError(), aError: %d", aError );
return aError;
}
// -----------------------------------------------------------------------------
// CCRMsgQueueObserver::DoCancel()
// From CActive
// -----------------------------------------------------------------------------
//
void CCRMsgQueueObserver::DoCancel()
{
LOG( "CCRMsgQueueObserver::DoCancel()" );
iQueue.CancelDataAvailable();
}
// -----------------------------------------------------------------------------
// CCRMsgQueueObserver::AddMsgQueueObserverL()
// Addes object to observer array
// -----------------------------------------------------------------------------
//
void CCRMsgQueueObserver::AddMsgQueueObserverL( MCREngineObserver* aObserver )
{
User::LeaveIfError( iObservers.Append( aObserver ) );
}
// -----------------------------------------------------------------------------
// CCRMsgQueueObserver::SetSessionId()
// Sets session id to listen to
// -----------------------------------------------------------------------------
//
void CCRMsgQueueObserver::SetSessionId( TInt aSessionId )
{
iSessionId = aSessionId;
}
// End of File