QVariant FeedItem::data(int role) const
{
switch(role) {
case UidRole:
return uid();
case TitleRole:
return title();
case ContentRole:
return content();
case LinkRole:
return link();
case UrlRole:
return url();
case IconRole:
return icon();
case StreamIdRole:
return streamId();
case UnreadRole:
return unread();
case ReadRole:
return read();
case ReadlaterRole:
return readlater();
case FreshRole:
return fresh();
default:
return QVariant();
}
}
// ---------------------------------------------------------------------------
// CStunTurnTests::TestCreateWrapperL
// ---------------------------------------------------------------------------
//
void CStunTurnTests::TestCreateWrapperL()
{
TUint sessionId( 0 );
TUint streamId( 0 );
MNATFWSocketMediaConnWrapper* wrapperIF;
RDebug::Print( _L( "TEST PRINT: Create session and stream" ) );
sessionId = iNat.CreateSessionL( iTestIapId, iTestDomain->Des() );
iIfStub.StartActiveSchedulerL();
streamId = iNat.CreateStreamL( sessionId, iProtocol, KDefaultQos );
RDebug::Print( _L( "\nTEST CASE: Create wrapper" ) );
wrapperIF = &iNat.CreateWrapperL( sessionId, streamId );
if ( wrapperIF->StreamId() != streamId )
{
RDebug::Print( _L( "TEST PRINT: CStunTurnTests::TestCreateWrapperL, streamId is not equal" ) );
User::Leave( KErrCompletion );
}
RDebug::Print( _L( "TEST PRINT: Close stream and session" ) );
iNat.CloseStreamL( sessionId, streamId );
iNat.CloseSessionL( sessionId );
}
void PluginTransfer::onStreamsRequestFinished() {
if (m_streamsRequest->status() == ResourcesRequest::Ready) {
QVariantList list = m_streamsRequest->result().toMap().value("items").toList();
foreach (QVariant v, list) {
QVariantMap stream = v.toMap();
if (stream.value("id") == streamId()) {
startDownload(stream.value("url").toString());
return;
}
}
// ---------------------------------------------------------------------------
// CTestDtmf::TestStreamCreationL
// ---------------------------------------------------------------------------
//
void CTestDtmf::TestStreamCreationL( TDtmfSignalType aSigType )
{
TMccNetSettings tempSettings = iNetsettings;
CMccInterfaceStub* stub = CMccInterfaceStub::NewL();
CleanupStack::PushL( stub );
CMccInterface* interface = CMccInterface::NewL( *stub );
CleanupStack::PushL( interface );
TUint32 sessionId;
User::LeaveIfError( interface->CreateSession( sessionId ) );
TUint32 linkId;
TInt linkType( KMccLinkGeneral );
User::LeaveIfError( interface->CreateLink( sessionId, linkType, linkId,
tempSettings ) );
stub->WaitForEvent( sessionId, linkId, 0, KMccLinkCreated );
CMccCodecInformation* cInfo
= FetchCodecByMimeSubtypeNameL( *interface, KTxtDtmf );
CleanupStack::PushL( cInfo );
if ( aSigType == EInbandSignal )
{
cInfo->SetCodecMode( EDTMFModeInband );
}
else
{
cInfo->SetCodecMode( EDTMFModeEvent );
}
TUint32 streamId( 0 );
TUint32 endpointId1( 0 ), endpointId2( 0 );
User::LeaveIfError(
interface->AddDataSink( KMccRtpSinkUid, KNullDesC8, endpointId1 ) );
User::LeaveIfError(
interface->AddDataSource( KMccRtpSourceUid, KNullDesC8, endpointId2 ) );
User::LeaveIfError( interface->CreateStream( sessionId, linkId, streamId,
KMccDtmfStream, *cInfo ) );
User::LeaveIfError( interface->DeleteStream( sessionId, linkId, streamId ) );
//interface->RemoveDataSink( endpointId1 );
//interface->RemoveDataSource( endpointId1 );
User::LeaveIfError( interface->CloseLink( sessionId, linkId ) );
User::LeaveIfError( interface->CloseSession( sessionId ) );
CleanupStack::PopAndDestroy( cInfo );
CleanupStack::PopAndDestroy( interface );
CleanupStack::PopAndDestroy( stub );
}
// ---------------------------------------------------------------------------
// CNcmSession::CreateStreamL
// ---------------------------------------------------------------------------
//
TUint CNcmSession::CreateStreamL( TInt aQos,
TUint aProtocol )
{
TUint streamId( GenerateStreamId() );
CNcmStream* item = CNcmStream::NewL(
iSessionId, streamId, aQos, aProtocol );
CleanupStack::PushL( item );
iStreams.AppendL( item );
CleanupStack::Pop( item );
return item->StreamId();
}
void PluginTransfer::onStreamsRequestFinished() {
if (m_streamsRequest->status() == ResourcesRequest::Ready) {
const QVariantMap result = m_streamsRequest->result().toMap();
if (result.contains("items")) {
const QVariantList list = result.value("items").toList();
foreach (const QVariant &v, list) {
const QVariantMap stream = v.toMap();
if (stream.value("id") == streamId()) {
const QFileInfo info(downloadPath() + fileName());
QString suffix = info.suffix();
if (suffix.isEmpty()) {
suffix = stream.value("ext").toString();
if (!suffix.isEmpty()) {
if (!suffix.startsWith(".")) {
suffix.prepend(".");
}
setFileName(info.completeBaseName() + suffix);
}
}
startDownload(stream.value("url").toString());
return;
}
}
}
else if (result.contains("service")) {
const QString service = result.value("service").toString();
if (service == Resources::SOUNDCLOUD) {
soundcloudStreamsRequest()->get(result.value("id").toString());
}
else {
setErrorString(tr("Attempted redirect to unsupported service '%1'").arg(service));
Logger::log("PluginTransfer::onStreamsRequestFinished(). Error: " + errorString());
setStatus(Failed);
}
return;
}
}
STDMETHODIMP_(DeviceStreamState) CCustomPin::SetState(
_In_ DeviceStreamState State
)
{
HRESULT hr = S_OK;
DMFTRACE(DMFT_GENERAL, TRACE_LEVEL_INFORMATION, "%!FUNC! Id:%d Transition into state: %d ", streamId(), State);
DeviceStreamState oldState = setPreferredStreamState( State );
if ( oldState != State )
{
ComPtr<IMFMediaType> preferredMediaType = nullptr;
if (State == DeviceStreamState_Run)
{
GetMediaTypeAt(0, preferredMediaType.ReleaseAndGetAddressOf());
}
setPreferredMediaType(preferredMediaType.Get());
setPreferredStreamState( State );
{
//
// Notify the device transform manager that we have changed state
//
ComPtr<IMFMediaEvent> pEvent = nullptr;
DMFTCHECKHR_GOTO( MFCreateMediaEvent(METransformInputStreamStateChanged, GUID_NULL, S_OK, NULL, pEvent.ReleaseAndGetAddressOf()), done );
DMFTCHECKHR_GOTO( pEvent->SetUINT32(MF_EVENT_MFT_INPUT_STREAM_ID, streamId()), done );
DMFTCHECKHR_GOTO( Parent()->QueueEvent(pEvent.Get()), done );
}
//
// Wait to be notified back from the pipeline.
//
DMFTCHECKHR_GOTO( WaitForSetInputPinMediaChange(),done );
}
done:
DMFTRACE(DMFT_GENERAL, TRACE_LEVEL_INFORMATION, "%!FUNC! exiting %x = %!HRESULT!", hr, hr);
return oldState;
}
// ---------------------------------------------------------------------------
// CStunTurnTests::TestCreateStreamL
// ---------------------------------------------------------------------------
//
void CStunTurnTests::TestCreateStreamL()
{
TUint sessionId( 0 );
TUint sessionId2( 0 );
TUint streamId( 0 );
TUint streamId2( 0 );
sessionId = iNat.CreateSessionL( iTestIapId, iTestDomain->Des() );
iIfStub.StartActiveSchedulerL();
RDebug::Print( _L( "\nTEST CASE: Create stream 1 in the session 1" ) );
streamId = iNat.CreateStreamL( sessionId, iProtocol, KDefaultQos );
RDebug::Print( _L( "\nTEST CASE: Create stream 2 in the session 1" ) );
streamId2 = iNat.CreateStreamL( sessionId, iProtocol, KDefaultQos );
RDebug::Print( _L( "TEST PRINT: CStunTurnTests::TestCreateStreamL, close stream 1" ) );
iNat.CloseStreamL( sessionId, streamId );
sessionId2 = iNat.CreateSessionL( iTestIapId, iTestDomain->Des() );
iIfStub.StartActiveSchedulerL();
RDebug::Print( _L( "\nTEST CASE: Create stream 3 in the session 2" ) );
streamId = iNat.CreateStreamL( sessionId2, iProtocol, KDefaultQos );
RDebug::Print( _L( "TEST PRINT: CStunTurnTests::TestCreateSessionL, close stream 3" ) );
iNat.CloseStreamL( sessionId2, streamId );
RDebug::Print( _L( "TEST PRINT: CStunTurnTests::TestCreateSessionL, close stream 2" ) );
iNat.CloseStreamL( sessionId, streamId2 );
RDebug::Print( _L( "TEST PRINT: CStunTurnTests::TestCreateSessionL, close session 1" ) );
iNat.CloseSessionL( sessionId );
RDebug::Print( _L( "TEST PRINT: CStunTurnTests::TestCreateSessionL, close session 2" ) );
iNat.CloseSessionL( sessionId2 );
}
static void StoreLongTermICEStatisticsImpl_m(
nsresult result,
nsAutoPtr<RTCStatsQuery> query) {
if (NS_FAILED(result) ||
!query->error.empty() ||
!query->report->mIceCandidateStats.WasPassed()) {
return;
}
query->report->mClosed.Construct(true);
// First, store stuff in telemetry
enum {
REMOTE_GATHERED_SERVER_REFLEXIVE = 1,
REMOTE_GATHERED_TURN = 1 << 1,
LOCAL_GATHERED_SERVER_REFLEXIVE = 1 << 2,
LOCAL_GATHERED_TURN_UDP = 1 << 3,
LOCAL_GATHERED_TURN_TCP = 1 << 4,
LOCAL_GATHERED_TURN_TLS = 1 << 5,
LOCAL_GATHERED_TURN_HTTPS = 1 << 6,
};
// TODO([email protected]): Do we need to watch out for cases where the
// components within a stream didn't have the same types of relayed
// candidates? I have a feeling that late trickle could cause this, but right
// now we don't have enough information to detect it (we would need to know
// the ICE component id for each candidate pair and candidate)
std::map<std::string, StreamResult> streamResults;
// Build list of streams, and whether or not they failed.
for (size_t i = 0;
i < query->report->mIceCandidatePairStats.Value().Length();
++i) {
const RTCIceCandidatePairStats &pair =
query->report->mIceCandidatePairStats.Value()[i];
if (!pair.mState.WasPassed() || !pair.mComponentId.WasPassed()) {
MOZ_CRASH();
continue;
}
// Note: this is not a "component" in the ICE definition, this is really a
// stream ID. This is just the way the stats API is standardized right now.
// Very confusing.
std::string streamId(
NS_ConvertUTF16toUTF8(pair.mComponentId.Value()).get());
streamResults[streamId].streamSucceeded |=
pair.mState.Value() == RTCStatsIceCandidatePairState::Succeeded;
}
for (size_t i = 0;
i < query->report->mIceCandidateStats.Value().Length();
++i) {
const RTCIceCandidateStats &cand =
query->report->mIceCandidateStats.Value()[i];
if (!cand.mType.WasPassed() ||
!cand.mCandidateType.WasPassed() ||
!cand.mComponentId.WasPassed()) {
// Crash on debug, ignore this candidate otherwise.
MOZ_CRASH();
continue;
}
// Note: this is not a "component" in the ICE definition, this is really a
// stream ID. This is just the way the stats API is standardized right now
// Very confusing.
std::string streamId(
NS_ConvertUTF16toUTF8(cand.mComponentId.Value()).get());
if (cand.mCandidateType.Value() == RTCStatsIceCandidateType::Relayed) {
if (cand.mType.Value() == RTCStatsType::Localcandidate) {
NS_ConvertUTF16toUTF8 transport(cand.mMozLocalTransport.Value());
if (transport == kNrIceTransportUdp) {
streamResults[streamId].candidateTypeBitpattern |=
LOCAL_GATHERED_TURN_UDP;
} else if (transport == kNrIceTransportTcp) {
streamResults[streamId].candidateTypeBitpattern |=
LOCAL_GATHERED_TURN_TCP;
}
} else {
streamResults[streamId].candidateTypeBitpattern |= REMOTE_GATHERED_TURN;
}
} else if (cand.mCandidateType.Value() ==
RTCStatsIceCandidateType::Serverreflexive) {
if (cand.mType.Value() == RTCStatsType::Localcandidate) {
streamResults[streamId].candidateTypeBitpattern |=
LOCAL_GATHERED_SERVER_REFLEXIVE;
} else {
streamResults[streamId].candidateTypeBitpattern |=
REMOTE_GATHERED_SERVER_REFLEXIVE;
}
}
}
for (auto i = streamResults.begin(); i != streamResults.end(); ++i) {
if (i->second.streamSucceeded) {
Telemetry::Accumulate(Telemetry::WEBRTC_CANDIDATE_TYPES_GIVEN_SUCCESS,
i->second.candidateTypeBitpattern);
} else {
Telemetry::Accumulate(Telemetry::WEBRTC_CANDIDATE_TYPES_GIVEN_FAILURE,
i->second.candidateTypeBitpattern);
}
}
PeerConnectionCtx *ctx = GetPeerConnectionCtx();
if (ctx) {
ctx->mStatsForClosedPeerConnections.AppendElement(*query->report);
}
}
// ---------------------------------------------------------------------------
// CNATFWStunConnectionHandler::SetSendingStateL
// ---------------------------------------------------------------------------
//
void CNATFWStunConnectionHandler::SetSendingStateL(
const CNATFWCandidate& aLocalCandidate,
TNATFWStreamingState aState,
const TInetAddr& /*aDestAddr*/ )
{
__STUNPLUGIN( "CNATFWStunConnectionHandler::SetSendingStateL start" )
TUint streamId( aLocalCandidate.StreamId() );
TUint connId( 0 );
TConnectionData* connection = NULL;
TRAPD( err, GetConnectionIdL( aLocalCandidate, streamId, connId ) );
if ( !err )
{
TInt streamInd( IndexByStreamId( streamId ) );
connection = ConnectionById( streamInd, connId );
}
/*if ( connection )
{
// Client controls media connection, set address filtering
iConnMux->SetAcceptedFromAddressL( streamId, connId, aDestAddr );
if ( EStreamingStateActive == aState )
{
if ( connection->iSendingActivated && connection->iDestAddr.
CmpAddr( aDestAddr ) )
{
iAsyncCallback->MakeCallbackL( TStunPluginCallbackInfo::
EActiveSending, streamId, KErrNone, NULL );
}
else
{
connection->iDestAddr.SetAddress( aDestAddr.Address() );
connection->iDestAddr.SetPort( aDestAddr.Port() );
iConnMux->SetSendingStateL( streamId, connId, aDestAddr,
EStreamingStateActive );
}
}
else
{
if ( !connection->iSendingActivated )
{
iAsyncCallback->MakeCallbackL( TStunPluginCallbackInfo::
EDeactiveSending, streamId, KErrNone, NULL );
}
else
{
iConnMux->SetSendingStateL( streamId, connId, aDestAddr,
EStreamingStatePassive );
}
}
}
else
{*/
if ( EStreamingStateActive == aState )
{
iAsyncCallback->MakeCallbackL( TStunPluginCallbackInfo::
EActiveSending, streamId, KErrNone, NULL );
}
else
{
iAsyncCallback->MakeCallbackL( TStunPluginCallbackInfo::
EDeactiveSending, streamId, KErrNone, NULL );
}
//}
__STUNPLUGIN( "CNATFWStunConnectionHandler::SetSendingStateL end" )
}
// ---------------------------------------------------------------------------
// CNATFWStunConnectionHandler::SetReceivingStateL
// ---------------------------------------------------------------------------
//
void CNATFWStunConnectionHandler::SetReceivingStateL(
const CNATFWCandidate& aLocalCandidate,
TNATFWStreamingState aState )
{
__STUNPLUGIN( "CNATFWStunConnectionHandler::SetReceivingStateL start" )
TUint streamId( aLocalCandidate.StreamId() );
TUint connId( 0 );
TConnectionData* connection = NULL;
TRAPD( err, GetConnectionIdL( aLocalCandidate, streamId, connId ) );
if ( !err )
{
TInt streamInd( IndexByStreamId( streamId ) );
connection = ConnectionById( streamInd, connId );
}
/*if ( connection )
{
if ( EStreamingStateActive == aState )
{
if ( connection->iReceivingActivated )
{
iAsyncCallback->MakeCallbackL( TStunPluginCallbackInfo::
EActiveReceiving, streamId, KErrNone, NULL );
}
else
{
iConnMux->SetReceivingStateL( streamId, connId,
EStreamingStateActive );
}
}
else
{
if ( !connection->iReceivingActivated )
{
iAsyncCallback->MakeCallbackL( TStunPluginCallbackInfo::
EDeactiveReceiving, streamId, KErrNone, NULL );
}
else
{
iConnMux->SetReceivingStateL( streamId, connId,
EStreamingStatePassive );
}
}
}
else
{*/
if ( EStreamingStateActive == aState )
{
iAsyncCallback->MakeCallbackL( TStunPluginCallbackInfo::
EActiveReceiving, streamId, KErrNone, NULL );
}
else
{
iAsyncCallback->MakeCallbackL( TStunPluginCallbackInfo::
EDeactiveReceiving, streamId, KErrNone, NULL );
}
//}
__STUNPLUGIN( "CNATFWStunConnectionHandler::SetReceivingStateL end" )
}
//
// Process input calls the pin here.. In this code sample we
// don't send it anywhere. It is simply shortcircuited back to the pipeline
//
STDMETHODIMP CCustomPin::SendSample(
_In_ IMFSample *pSample
)
{
//
// Log sample and exit.. The pipeline will just keep on churning more samples till
// We go into the stop state
//
DMFTRACE(DMFT_GENERAL, TRACE_LEVEL_INFORMATION, "%!FUNC! Custom Pin %d recieved Sample %p", streamId(), pSample);
return S_OK;
}
void UT_CMccRtpDataSource::UT_CMccRtpDataSource_ValidatePacketL()
{
TRtpId streamId( KNullId );
TRtpRecvHeader header;
TBuf8<5> data5;
TBuf8<15> data15;
data5.Format( _L8( "foo42" ) );
data15.Format( _L8( "foo42foo42foo42" ) );
// Data too big, stream ok, wrong payload type
EUNIT_ASSERT_LEAVE( iSource->ValidatePacketL( streamId, header, data15 ) );
// Data ok, stream ok, wrong payload type
EUNIT_ASSERT_LEAVE( iSource->ValidatePacketL( streamId, header, data5 ) );
header.iPayloadType = KMccPayloadTypeMax;
// header not OK
CMMFDataBuffer* buffer = CMMFDataBuffer::NewL(10);
CleanupStack::PushL( buffer );
iSource->iBufferToFill = buffer;
EUNIT_ASSERT_LEAVE( iSource->ValidatePacketL( streamId, header, data5 ) );
// Get a new source
//Teardown();
if( iRtpKeepaliveMechanism )
{
delete iRtpKeepaliveMechanism;
iRtpKeepaliveMechanism = NULL;
}
if ( iSource )
{
delete iSource;
iSource = NULL;
}
//SetupL();
TUid dummyUid( TUid::Uid( 42 ) );
TBuf8<5> dummyBuf( _L8( "foo" ) );
iSource = static_cast<CMccRtpDataSource*>(
CMccRtpDataSource::NewSourceL( dummyUid, dummyBuf ) );
TMccRtpSourceSetting setting;
setting.iStandByTimerValue = 3000;
TMccRtpSourceSettingBuf settingBuf( setting );
iSource->ConstructSourceL( settingBuf );
MAsyncEventHandler* eventHandler = NULL;
TRtpId rtpSessionId(0);
iRtpKeepaliveMechanism =
CMccRtpKeepaliveContainer::NewL( *eventHandler,
*iRtpApi,
rtpSessionId );
TMccRtpSessionParams params;
params.iRtpAPI = iRtpApi;
params.iSessionId = iSession;
params.iEnableRTCP = EFalse;
params.iRtpKeepalive = iRtpKeepaliveMechanism;
EUNIT_ASSERT_NO_LEAVE( iSource->SetSessionParamsL( params ) );
TMccCodecInfo cInfo;
cInfo.iFourCC = TFourCC( KMccFourCCIdG711 );
cInfo.iEnableDTX = ETrue;
TMccCodecInfoBuffer cInfoBuf( cInfo );
EUNIT_ASSERT_NO_LEAVE( iSource->ConfigureL( cInfoBuf, iRtpMediaClock ) );
header.iPayloadType = KPcmuPayloadType;
// Data ok, stream ok, payload type ok
CAmrPayloadFormatRead* amrPfRead = CAmrPayloadFormatRead::NewL( NULL );
CleanupStack::PushL( amrPfRead );
RArray<TUint> payloads;
CleanupClosePushL( payloads );
payloads.AppendL( KPcmuPayloadType );
iSource->RegisterPayloadTypesL( payloads );
iSource->FillBufferL( buffer, amrPfRead, TMediaId() );
EUNIT_ASSERT_NO_LEAVE( iSource->ValidatePacketL( streamId, header, data5 ) );
CleanupStack::PopAndDestroy( &payloads );
CleanupStack::PopAndDestroy( amrPfRead );
CleanupStack::PopAndDestroy( buffer );
}
// ---------------------------------------------------------------------------
// CStunTurnTests::TestFetchCandidateL
// ---------------------------------------------------------------------------
//
void CStunTurnTests::TestFetchCandidateL()
{
TUint sessionId( 0 );
TUint sessionId2( 0 );
TUint streamId( 0 );
TUint streamId2( 0 );
TUint streamId3( 0 );
TInt error;
TInt loadedPluginInd( 0 );
RDebug::Print( _L( "TEST PRINT: Create session" ) );
sessionId = iNat.CreateSessionL( iTestIapId, iTestDomain->Des() );
iIfStub.StartActiveSchedulerL();
RDebug::Print( _L( "TEST PRINT: Create stream" ) );
streamId = iNat.CreateStreamL( sessionId, iProtocol, KDefaultQos );
RDebug::Print( _L( "TEST PRINT: Load plugin" ) );
iNat.LoadPluginL( sessionId, *iPlugins, loadedPluginInd );
iIfStub.StartActiveSchedulerL( KPluginLoadTime );
RDebug::Print( _L( "\nTEST CASE: Fetch Candidate to the stream" ) );
TRAPD( err, iNat.FetchCandidateL( sessionId, streamId, KAfInet ) );
if ( err )
{
RDebug::Print( _L( "\nTEST PRINT: CNATFWClient::FetchCandidateL LEAVE %d" ), err );
iNat.CloseStreamL( sessionId, streamId );
iNat.CloseSessionL( sessionId );
User::Leave( err );
}
error = iIfStub.StartActiveSchedulerL( /*KRunningTime*/ );
RDebug::Print( _L( "TEST PRINT: Close the stream and the session" ) );
iNat.CloseStreamL( sessionId, streamId );
iNat.CloseSessionL( sessionId );
__ASSERT_ALWAYS( !error, User::Leave( error ));
RDebug::Print( _L( "TEST PRINT: Create session 1" ) );
sessionId = iNat.CreateSessionL( iTestIapId, iTestDomain->Des() );
iIfStub.StartActiveSchedulerL();
RDebug::Print( _L( "TEST PRINT: Load plugin to session 1" ) );
iNat.LoadPluginL( sessionId, *iPlugins, loadedPluginInd );
iIfStub.StartActiveSchedulerL( KPluginLoadTime );
RDebug::Print( _L( "TEST PRINT: Create stream 1 to the session 1" ) );
streamId = iNat.CreateStreamL( sessionId, iProtocol, KDefaultQos );
RDebug::Print( _L( "\nTEST CASE: Fetch Candidate to the stream 1 in the session 1" ) );
TRAP( err, iNat.FetchCandidateL( sessionId, streamId, KAfInet ) );
if( err )
{
RDebug::Print( _L( "\nTEST PRINT: CNATFWClient::FetchCandidateL LEAVE %d" ), err );
iNat.CloseStreamL( sessionId, streamId );
iNat.CloseSessionL( sessionId );
User::Leave( err );
}
iIfStub.StartActiveSchedulerL();
RDebug::Print( _L( "TEST PRINT: Create stream 2 to the session 1" ) );
streamId2 = iNat.CreateStreamL( sessionId, iProtocol, KDefaultQos );
RDebug::Print( _L( "\nTEST CASE: Fetch Candidate to the stream 2 in the session 1" ) );
TRAP( err, iNat.FetchCandidateL( sessionId, streamId2, KAfInet ) );
if( err )
{
RDebug::Print( _L( "\nTEST PRINT: CNATFWClient::FetchCandidateL LEAVE %d" ), err );
iNat.CloseStreamL( sessionId, streamId );
iNat.CloseStreamL( sessionId, streamId2 );
iNat.CloseSessionL( sessionId );
User::Leave( err );
}
error = iIfStub.StartActiveSchedulerL( KRunningTime );
if( !error )
{
RDebug::Print( _L( "TEST PRINT: Create session 2" ) );
sessionId2 = iNat.CreateSessionL( iTestIapId, iTestDomain->Des() );
iIfStub.StartActiveSchedulerL();
RDebug::Print( _L( "TEST PRINT: Load plugin to session 2" ) );
iNat.LoadPluginL( sessionId2, *iPlugins, loadedPluginInd );
iIfStub.StartActiveSchedulerL( KPluginLoadTime );
RDebug::Print( _L( "TEST PRINT: Create stream 3 to the session 2" ) );
streamId3 = iNat.CreateStreamL( sessionId2, iProtocol, KDefaultQos );
RDebug::Print( _L( "\nTEST CASE: Fetch Candidate to the stream 3 in the session 2" ) );
TRAP( err, iNat.FetchCandidateL( sessionId2, streamId3, KAfInet ) );
if( err )
{
RDebug::Print( _L( "\nTEST PRINT: CNATFWClient::FetchCandidateL LEAVE %d" ), err );
iNat.CloseStreamL( sessionId2, streamId3 );
iNat.CloseSessionL( sessionId2 );
iNat.CloseStreamL( sessionId, streamId );
iNat.CloseStreamL( sessionId, streamId2 );
iNat.CloseSessionL( sessionId );
User::Leave( err );
}
iIfStub.StartActiveSchedulerL( KRunningTime );
RDebug::Print( _L( "TEST PRINT: Close stream 3 and session 2" ) );
iNat.CloseStreamL( sessionId2, streamId3 );
iNat.CloseSessionL( sessionId2 );
}
RDebug::Print( _L( "TEST PRINT: Close streams 1 & 2 and session 1" ) );
iNat.CloseStreamL( sessionId, streamId );
iNat.CloseStreamL( sessionId, streamId2 );
iNat.CloseSessionL( sessionId );
__ASSERT_ALWAYS( !error, User::Leave( error ));
}
void Transfer::setStreamId(const QString &si) {
if (si != streamId()) {
m_streamId = si;
emit streamIdChanged();
}
}
// ---------------------------------------------------------------------------
// CTestDtmf::TestStreamControlL
// ---------------------------------------------------------------------------
//
void CTestDtmf::TestStreamControlL( TDtmfSignalType aSigType )
{
TMccNetSettings tempSettings = iNetsettings;
CMccInterfaceStub* stub = CMccInterfaceStub::NewL();
CleanupStack::PushL( stub );
CMccInterface* interface = CMccInterface::NewL( *stub );
CleanupStack::PushL( interface );
TUint32 sessionId;
User::LeaveIfError( interface->CreateSession( sessionId ) );
TUint32 linkId;
TInt linkType( KMccLinkGeneral );
User::LeaveIfError( interface->CreateLink( sessionId, linkType, linkId,
tempSettings ) );
stub->WaitForEvent( sessionId, linkId, 0, KMccLinkCreated );
CMccCodecInformation* cInfo
= FetchCodecByMimeSubtypeNameL( *interface, KTxtDtmf );
CleanupStack::PushL( cInfo );
if ( aSigType == EInbandSignal )
{
cInfo->SetCodecMode( EDTMFModeInband );
}
else
{
cInfo->SetCodecMode( EDTMFModeEvent );
}
TUint32 streamId( 0 );
TUint32 sinkId( 0 ), sourceId( 0 );
interface->AddDataSink( KMccRtpSinkUid, KNullDesC8, sinkId );
interface->AddDataSource( KMccRtpSourceUid, KNullDesC8, sourceId );
User::LeaveIfError( interface->CreateStream( sessionId, linkId, streamId,
KMccDtmfStream, *cInfo ) );
// TEST CORRECT CONTROL PATHS
User::LeaveIfError ( interface->PrepareStream( sessionId, linkId, streamId ) );
stub->WaitForEvent( sessionId, linkId, streamId, KMccStreamPrepared );
stub->WaitForEvent( sessionId, linkId, streamId, KMccStreamPrepared );
User::LeaveIfError ( interface->StartStream( sessionId, linkId, streamId ) );
stub->WaitForEvent( sessionId, linkId, streamId, KMccStreamStarted );
stub->WaitForEvent( sessionId, linkId, streamId, KMccStreamStarted );
User::LeaveIfError ( interface->PauseStream( sessionId, linkId, streamId ) );
stub->WaitForEvent( sessionId, linkId, streamId, KMccStreamPaused );
stub->WaitForEvent( sessionId, linkId, streamId, KMccStreamPaused );
User::LeaveIfError ( interface->ResumeStream( sessionId, linkId, streamId ) );
stub->WaitForEvent( sessionId, linkId, streamId, KMccStreamResumed );
stub->WaitForEvent( sessionId, linkId, streamId, KMccStreamResumed );
User::LeaveIfError ( interface->StopStream( sessionId, linkId, streamId ) );
stub->WaitForEvent( sessionId, linkId, streamId, KMccStreamStopped );
stub->WaitForEvent( sessionId, linkId, streamId, KMccStreamStopped );
// TBD: TEST INVALID CONTROL PATHS
User::LeaveIfError( interface->DeleteStream( sessionId, linkId, streamId ) );
User::LeaveIfError( interface->CloseLink( sessionId, linkId ) );
User::LeaveIfError( interface->CloseSession( sessionId ) );
CleanupStack::PopAndDestroy( cInfo );
CleanupStack::PopAndDestroy( interface );
CleanupStack::PopAndDestroy( stub );
}
