112 // ----------------------------------------------------------------------------- |
111 // ----------------------------------------------------------------------------- |
113 // TMSCallIPAdpt::CreateStream |
112 // TMSCallIPAdpt::CreateStream |
114 // |
113 // |
115 // ----------------------------------------------------------------------------- |
114 // ----------------------------------------------------------------------------- |
116 // |
115 // |
117 gint TMSCallIPAdpt::CreateStream(TMSCallType /*callType*/, |
116 gint TMSCallIPAdpt::CreateStream(const TMSCallType /*callType*/, |
118 TMSStreamType strmType, gint& outStrmId) |
117 const TMSStreamType strmType, gint& outStrmId) |
119 { |
118 { |
120 TRACE_PRN_FN_ENT; |
119 TRACE_PRN_FN_ENT; |
121 gint status(TMS_RESULT_SUCCESS); |
120 gint status(TMS_RESULT_SUCCESS); |
122 switch (strmType) |
121 switch (strmType) |
123 { |
122 { |
124 case TMS_STREAM_UPLINK: |
123 case TMS_STREAM_UPLINK: |
125 { |
124 { |
126 status = TMS_RESULT_ALREADY_EXIST; |
125 status = TMS_RESULT_ALREADY_EXIST; |
127 if (!iUplinkInitialized) |
126 if (!iUplinkInitialized) |
128 { |
127 { |
129 iUplinkInitialized = TRUE; |
|
130 iUplinkStreamId = iNextStreamId; |
128 iUplinkStreamId = iNextStreamId; |
131 outStrmId = iUplinkStreamId; |
129 outStrmId = iUplinkStreamId; |
132 iNextStreamId++; |
130 iNextStreamId++; |
|
131 //iUplinkInitialized = TRUE; //not initialized yet! |
133 status = TMS_RESULT_SUCCESS; |
132 status = TMS_RESULT_SUCCESS; |
134 } |
133 } |
135 break; |
134 break; |
136 } |
135 } |
137 case TMS_STREAM_DOWNLINK: |
136 case TMS_STREAM_DOWNLINK: |
138 { |
137 { |
139 status = TMS_RESULT_ALREADY_EXIST; |
138 status = TMS_RESULT_ALREADY_EXIST; |
140 if (!iDnlinkInitialized) |
139 if (!iDnlinkInitialized) |
141 { |
140 { |
142 iDnlinkInitialized = TRUE; |
|
143 iDnlinkStreamId = iNextStreamId; |
141 iDnlinkStreamId = iNextStreamId; |
144 outStrmId = iDnlinkStreamId; |
142 outStrmId = iDnlinkStreamId; |
145 iNextStreamId++; |
143 iNextStreamId++; |
|
144 //iDnlinkInitialized = TRUE; //not initialized yet! |
146 status = TMS_RESULT_SUCCESS; |
145 status = TMS_RESULT_SUCCESS; |
147 } |
146 } |
148 break; |
147 break; |
149 } |
148 } |
150 default: |
149 default: |
160 // ----------------------------------------------------------------------------- |
159 // ----------------------------------------------------------------------------- |
161 // TMSCallIPAdpt::InitStream |
160 // TMSCallIPAdpt::InitStream |
162 // |
161 // |
163 // ----------------------------------------------------------------------------- |
162 // ----------------------------------------------------------------------------- |
164 // |
163 // |
165 gint TMSCallIPAdpt::InitStream(TMSCallType /*callType*/, TMSStreamType strmType, |
164 gint TMSCallIPAdpt::InitStream(const TMSCallType /*callType*/, |
166 gint strmId, TMSFormatType frmtType, const RMessage2& message) |
165 const TMSStreamType strmType, const gint strmId, |
|
166 const TMSFormatType frmtType, const gint retrytime, |
|
167 const RMessage2& message) |
167 { |
168 { |
168 TRACE_PRN_FN_ENT; |
169 TRACE_PRN_FN_ENT; |
169 gint status(TMS_RESULT_SUCCESS); |
170 gint status(TMS_RESULT_SUCCESS); |
170 |
|
171 guint32 fourCC = TOFOURCC(frmtType); |
171 guint32 fourCC = TOFOURCC(frmtType); |
172 if (fourCC == NULL) |
172 if (fourCC == NULL) |
173 { |
173 { |
174 return TMS_RESULT_INVALID_ARGUMENT; |
174 return TMS_RESULT_INVALID_ARGUMENT; |
175 } |
175 } |
180 { |
180 { |
181 status = TMS_RESULT_DOES_NOT_EXIST; |
181 status = TMS_RESULT_DOES_NOT_EXIST; |
182 if (strmId == iUplinkStreamId) |
182 if (strmId == iUplinkStreamId) |
183 { |
183 { |
184 SetFormat(iUplinkStreamId, fourCC); |
184 SetFormat(iUplinkStreamId, fourCC); |
185 status = OpenUplinkL(message); |
185 status = OpenUplink(message, retrytime); |
186 if (status == TMS_RESULT_SUCCESS) |
186 if (status == TMS_RESULT_SUCCESS) |
187 { |
187 { |
188 status = InitDTMF(TMS_STREAM_UPLINK); |
188 status = InitDTMF(TMS_STREAM_UPLINK); |
189 } |
189 } |
190 NotifyClient(iUplinkStreamId, ECmdUplinkInitComplete, status); |
|
191 } |
190 } |
192 break; |
191 break; |
193 } |
192 } |
194 case TMS_STREAM_DOWNLINK: |
193 case TMS_STREAM_DOWNLINK: |
195 { |
194 { |
196 status = TMS_RESULT_DOES_NOT_EXIST; |
195 status = TMS_RESULT_DOES_NOT_EXIST; |
197 if (strmId == iDnlinkStreamId) |
196 if (strmId == iDnlinkStreamId) |
198 { |
197 { |
199 SetFormat(iDnlinkStreamId, fourCC); |
198 SetFormat(iDnlinkStreamId, fourCC); |
200 status = OpenDownlinkL(message); |
199 status = OpenDownlink(message, retrytime); |
201 if (status == TMS_RESULT_SUCCESS) |
200 if (status == TMS_RESULT_SUCCESS) |
202 { |
201 { |
203 status = InitDTMF(TMS_STREAM_DOWNLINK); |
202 status = InitDTMF(TMS_STREAM_DOWNLINK); |
204 } |
203 } |
205 NotifyClient(iDnlinkStreamId, ECmdDownlinkInitComplete, status); |
|
206 } |
204 } |
207 break; |
205 break; |
208 } |
206 } |
209 default: |
207 default: |
210 { |
208 { |
221 // ----------------------------------------------------------------------------- |
219 // ----------------------------------------------------------------------------- |
222 // TMSCallIPAdpt::StartStream |
220 // TMSCallIPAdpt::StartStream |
223 // |
221 // |
224 // ----------------------------------------------------------------------------- |
222 // ----------------------------------------------------------------------------- |
225 // |
223 // |
226 gint TMSCallIPAdpt::StartStream(TMSCallType /*callType*/, |
224 gint TMSCallIPAdpt::StartStream(const TMSCallType /*callType*/, |
227 TMSStreamType strmType, gint strmId) |
225 const TMSStreamType strmType, const gint strmId, const gint retrytime) |
228 { |
226 { |
229 TRACE_PRN_FN_ENT; |
227 TRACE_PRN_FN_ENT; |
230 gint status(TMS_RESULT_INVALID_STATE); |
228 gint status(TMS_RESULT_INVALID_STATE); |
231 switch (strmType) |
229 switch (strmType) |
232 { |
230 { |
233 case TMS_STREAM_UPLINK: |
231 case TMS_STREAM_UPLINK: |
234 { |
232 { |
235 if (strmId == iUplinkStreamId && iIPUplink) |
233 if (iIPUplink && strmId == iUplinkStreamId) |
236 { |
234 { |
237 iIPUplink->Start(); |
235 iIPUplink->Start(retrytime); |
238 status = TMS_RESULT_SUCCESS; |
236 status = TMS_RESULT_SUCCESS; |
239 NotifyClient(iUplinkStreamId, ECmdUplinkStarted, status); |
237 NotifyClient(iUplinkStreamId, ECmdUplinkStarted, status); |
240 } |
238 } |
241 break; |
239 break; |
242 } |
240 } |
243 case TMS_STREAM_DOWNLINK: |
241 case TMS_STREAM_DOWNLINK: |
244 { |
242 { |
245 if (strmId == iDnlinkStreamId && iIPDownlink) |
243 if (iIPDownlink && strmId == iDnlinkStreamId) |
246 { |
244 { |
247 iIPDownlink->Start(); |
245 iIPDownlink->Start(retrytime); |
248 status = TMS_RESULT_SUCCESS; |
246 status = TMS_RESULT_SUCCESS; |
249 NotifyClient(iDnlinkStreamId, ECmdDownlinkStarted, status); |
247 NotifyClient(iDnlinkStreamId, ECmdDownlinkStarted, status); |
250 } |
248 } |
251 break; |
249 break; |
252 } |
250 } |
305 // ----------------------------------------------------------------------------- |
303 // ----------------------------------------------------------------------------- |
306 // TMSCallIPAdpt::StopStream |
304 // TMSCallIPAdpt::StopStream |
307 // |
305 // |
308 // ----------------------------------------------------------------------------- |
306 // ----------------------------------------------------------------------------- |
309 // |
307 // |
310 gint TMSCallIPAdpt::StopStream(TMSCallType /*callType*/, TMSStreamType strmType, |
308 gint TMSCallIPAdpt::StopStream(const TMSCallType /*callType*/, |
311 gint strmId) |
309 const TMSStreamType strmType, const gint strmId) |
312 { |
310 { |
313 TRACE_PRN_FN_ENT; |
311 TRACE_PRN_FN_ENT; |
314 gint status(TMS_RESULT_INVALID_STATE); |
312 gint status(TMS_RESULT_INVALID_STATE); |
315 |
313 |
316 switch (strmType) |
314 switch (strmType) |
317 { |
315 { |
318 case TMS_STREAM_UPLINK: |
316 case TMS_STREAM_UPLINK: |
319 { |
317 { |
320 if (strmId == iUplinkStreamId && iIPUplink) |
318 if (iIPUplink && strmId == iUplinkStreamId) |
321 { |
319 { |
322 iIPUplink->Stop(); |
320 iIPUplink->Stop(); |
323 status = TMS_RESULT_SUCCESS; |
321 status = TMS_RESULT_SUCCESS; |
324 NotifyClient(iUplinkStreamId, ECmdUplinkInitComplete, status); |
322 NotifyClient(iUplinkStreamId, ECmdUplinkInitComplete, status); |
325 } |
323 } |
326 break; |
324 break; |
327 } |
325 } |
328 case TMS_STREAM_DOWNLINK: |
326 case TMS_STREAM_DOWNLINK: |
329 { |
327 { |
330 if (strmId == iDnlinkStreamId && iIPDownlink) |
328 if (iIPDownlink && strmId == iDnlinkStreamId) |
331 { |
329 { |
332 iIPDownlink->Stop(); |
330 iIPDownlink->Stop(); |
333 status = TMS_RESULT_SUCCESS; |
331 status = TMS_RESULT_SUCCESS; |
334 NotifyClient(iDnlinkStreamId, ECmdDownlinkInitComplete, status); |
332 NotifyClient(iDnlinkStreamId, ECmdDownlinkInitComplete, status); |
335 } |
333 } |
348 // ----------------------------------------------------------------------------- |
346 // ----------------------------------------------------------------------------- |
349 // TMSCallIPAdpt::DeinitStream |
347 // TMSCallIPAdpt::DeinitStream |
350 // |
348 // |
351 // ----------------------------------------------------------------------------- |
349 // ----------------------------------------------------------------------------- |
352 // |
350 // |
353 gint TMSCallIPAdpt::DeinitStream(TMSCallType /*callType*/, |
351 gint TMSCallIPAdpt::DeinitStream(const TMSCallType /*callType*/, |
354 TMSStreamType strmType, gint strmId) |
352 const TMSStreamType strmType, const gint strmId) |
355 { |
353 { |
356 TRACE_PRN_FN_ENT; |
354 TRACE_PRN_FN_ENT; |
357 gint status(TMS_RESULT_INVALID_STATE); |
355 gint status(TMS_RESULT_INVALID_STATE); |
358 |
356 |
359 switch (strmType) |
357 switch (strmType) |
360 { |
358 { |
361 case TMS_STREAM_UPLINK: |
359 case TMS_STREAM_UPLINK: |
362 { |
360 { |
363 if (strmId == iUplinkStreamId && iIPUplink) |
361 if (iIPUplink && strmId == iUplinkStreamId) |
364 { |
362 { |
365 iIPUplink->Stop(); |
363 iIPUplink->Stop(); |
366 //iUplinkStreamId = -1; |
364 //iUplinkStreamId = -1; |
367 iUplinkInitialized = FALSE; |
365 iUplinkInitialized = FALSE; |
368 status = TMS_RESULT_SUCCESS; |
366 status = TMS_RESULT_SUCCESS; |
369 NotifyClient(iUplinkStreamId, ECmdDownlinkDeInitComplete, |
367 NotifyClient(iUplinkStreamId, ECmdUplinkDeInitComplete, status); |
370 status); |
|
371 } |
368 } |
372 break; |
369 break; |
373 } |
370 } |
374 case TMS_STREAM_DOWNLINK: |
371 case TMS_STREAM_DOWNLINK: |
375 { |
372 { |
376 if (strmId == iDnlinkStreamId && iIPDownlink) |
373 if (iIPDownlink && strmId == iDnlinkStreamId) |
377 { |
374 { |
378 iIPDownlink->Stop(); |
375 iIPDownlink->Stop(); |
379 //iDnlinkStreamId = -1; |
376 //iDnlinkStreamId = -1; |
380 iDnlinkInitialized = FALSE; |
377 iDnlinkInitialized = FALSE; |
381 status = TMS_RESULT_SUCCESS; |
378 status = TMS_RESULT_SUCCESS; |
398 // ----------------------------------------------------------------------------- |
395 // ----------------------------------------------------------------------------- |
399 // TMSCallIPAdpt::DeleteStream |
396 // TMSCallIPAdpt::DeleteStream |
400 // |
397 // |
401 // ----------------------------------------------------------------------------- |
398 // ----------------------------------------------------------------------------- |
402 // |
399 // |
403 gint TMSCallIPAdpt::DeleteStream(TMSCallType /*callType*/, |
400 gint TMSCallIPAdpt::DeleteStream(const TMSCallType /*callType*/, |
404 TMSStreamType strmType, gint strmId) |
401 const TMSStreamType strmType, const gint strmId) |
405 { |
402 { |
406 TRACE_PRN_FN_ENT; |
403 TRACE_PRN_FN_ENT; |
407 gint status(TMS_RESULT_SUCCESS); |
404 gint status(TMS_RESULT_SUCCESS); |
408 switch (strmType) |
405 switch (strmType) |
409 { |
406 { |
410 case TMS_STREAM_UPLINK: |
407 case TMS_STREAM_UPLINK: |
411 { |
408 { |
412 // This is additional error checking |
|
413 if (strmId == iUplinkStreamId) |
409 if (strmId == iUplinkStreamId) |
414 { |
410 { |
415 iUplinkStreamId = -1; |
411 iUplinkStreamId = -1; |
416 iUplinkInitialized = FALSE; |
412 iUplinkInitialized = FALSE; |
417 } |
413 } |
418 break; |
414 break; |
419 } |
415 } |
420 case TMS_STREAM_DOWNLINK: |
416 case TMS_STREAM_DOWNLINK: |
421 { |
417 { |
422 // This is additional error checking |
|
423 if (strmId == iDnlinkStreamId) |
418 if (strmId == iDnlinkStreamId) |
424 { |
419 { |
425 iDnlinkStreamId = -1; |
420 iDnlinkStreamId = -1; |
426 iDnlinkInitialized = FALSE; |
421 iDnlinkInitialized = FALSE; |
427 } |
422 } |
1358 // |
1355 // |
1359 // ----------------------------------------------------------------------------- |
1356 // ----------------------------------------------------------------------------- |
1360 // |
1357 // |
1361 gint TMSCallIPAdpt::SetOutput(TMSAudioOutput output) |
1358 gint TMSCallIPAdpt::SetOutput(TMSAudioOutput output) |
1362 { |
1359 { |
|
1360 TRACE_PRN_FN_ENT; |
1363 gint status(TMS_RESULT_UNINITIALIZED_OBJECT); |
1361 gint status(TMS_RESULT_UNINITIALIZED_OBJECT); |
1364 if (iDnlinkInitialized && iIPDownlink) |
1362 if (iDnlinkInitialized && iIPDownlink) |
1365 { |
1363 { |
1366 TRAP(status, iIPDownlink->SetAudioDeviceL(output)); |
1364 TRAP(status, iIPDownlink->SetAudioDeviceL(output)); |
1367 } |
1365 } |
|
1366 TRACE_PRN_FN_EXT; |
1368 return status; |
1367 return status; |
1369 } |
1368 } |
1370 // ----------------------------------------------------------------------------- |
1369 // ----------------------------------------------------------------------------- |
1371 // TMSCallIPAdpt::GetOutput |
1370 // TMSCallIPAdpt::GetOutput |
1372 // |
1371 // |
1373 // ----------------------------------------------------------------------------- |
1372 // ----------------------------------------------------------------------------- |
1374 // |
1373 // |
1375 gint TMSCallIPAdpt::GetOutput(TMSAudioOutput& output) |
1374 gint TMSCallIPAdpt::GetOutput(TMSAudioOutput& output) |
1376 { |
1375 { |
|
1376 TRACE_PRN_FN_ENT; |
1377 gint status(TMS_RESULT_UNINITIALIZED_OBJECT); |
1377 gint status(TMS_RESULT_UNINITIALIZED_OBJECT); |
1378 if (iDnlinkInitialized && iIPDownlink) |
1378 if (iDnlinkInitialized && iIPDownlink) |
1379 { |
1379 { |
1380 TRAP(status, iIPDownlink->GetAudioDeviceL(output)); |
1380 TRAP(status, iIPDownlink->GetAudioDeviceL(output)); |
1381 } |
1381 } |
1382 return status; |
1382 TRACE_PRN_FN_EXT; |
1383 } |
1383 return status; |
|
1384 } |
|
1385 |
1384 // ----------------------------------------------------------------------------- |
1386 // ----------------------------------------------------------------------------- |
1385 // TMSCallIPAdpt::GetPreviousOutput |
1387 // TMSCallIPAdpt::GetPreviousOutput |
1386 // |
1388 // |
1387 // ----------------------------------------------------------------------------- |
1389 // ----------------------------------------------------------------------------- |
1388 // |
1390 // |
1414 |
1416 |
1415 if (strmtype == TMS_STREAM_DOWNLINK) |
1417 if (strmtype == TMS_STREAM_DOWNLINK) |
1416 { |
1418 { |
1417 delete iDTMFDnlinkPlayer; |
1419 delete iDTMFDnlinkPlayer; |
1418 iDTMFDnlinkPlayer = NULL; |
1420 iDTMFDnlinkPlayer = NULL; |
1419 |
|
1420 /* Clarify with adaptation team which prio/pref values should be used. |
|
1421 * 1) KAudioDTMFString -local play, no mixing |
|
1422 * KAudioPriorityDTMFString -local play, no mixing |
|
1423 * 2) KAudioPrefUnknownVoipAudioDownlink -3rd party VoIP? |
|
1424 * KAudioPriorityUnknownVoipAudioDownlink -3rd party VoIP? |
|
1425 * 3) KAudioPrefVoipAudioDownlink -NOK native VoIP? |
|
1426 * KAudioPriorityVoipAudioDownlink -NOK native VoIP? |
|
1427 */ |
|
1428 TRAP(status, iDTMFDnlinkPlayer = TMSAudioDtmfTonePlayer::NewL(*this, |
1421 TRAP(status, iDTMFDnlinkPlayer = TMSAudioDtmfTonePlayer::NewL(*this, |
1429 KAudioPrefVoipAudioDownlink, KAudioPriorityVoipAudioDownlink)); |
1422 KAudioDTMFString, KAudioPriorityDTMFString)); |
1430 } |
1423 } |
1431 else if (strmtype == TMS_STREAM_UPLINK) |
1424 else if (strmtype == TMS_STREAM_UPLINK) |
1432 { |
1425 { |
1433 delete iDTMFUplinkPlayer; |
1426 delete iDTMFUplinkPlayer; |
1434 iDTMFUplinkPlayer = NULL; |
1427 iDTMFUplinkPlayer = NULL; |
1435 |
|
1436 /* Clarify with adaptation team which prio/pref values should be used. |
|
1437 * Currently the audio policy blocks DTMF mixing with the UPL stream. |
|
1438 * 1) KAudioPrefUnknownVoipAudioUplink -3rd party VoIP? |
|
1439 * KAudioPriorityUnknownVoipAudioUplink -3rd party VoIP? |
|
1440 * KAudioPriorityUnknownVoipAudioUplinkNonSignal -??? |
|
1441 * 2) KAudioPrefVoipAudioUplink -NOK native VoIP? |
|
1442 * KAudioPrefUnknownVoipAudioUplinkNonSignal -??? |
|
1443 * KAudioPrefVoipAudioUplinkNonSignal -??? |
|
1444 * KAudioPriorityVoipAudioUplink -NOK native VoIP? |
|
1445 */ |
|
1446 TRAP(status, iDTMFUplinkPlayer = TMSAudioDtmfTonePlayer::NewL(*this, |
1428 TRAP(status, iDTMFUplinkPlayer = TMSAudioDtmfTonePlayer::NewL(*this, |
1447 KAudioPrefVoipAudioUplink, KAudioPriorityVoipAudioUplink)); |
1429 KAudioDTMFString, KAudioPriorityDTMFString)); |
1448 } |
1430 } |
1449 |
1431 |
1450 if (!iDTMFNotifier && status == TMS_RESULT_SUCCESS) |
1432 if (!iDTMFNotifier && status == TMS_RESULT_SUCCESS) |
1451 { |
1433 { |
1452 TRAP(status, iDTMFNotifier = TMSDtmfNotifier::NewL()); |
1434 TRAP(status, iDTMFNotifier = TMSDtmfNotifier::NewL()); |
1508 // ----------------------------------------------------------------------------- |
1490 // ----------------------------------------------------------------------------- |
1509 // |
1491 // |
1510 gint TMSCallIPAdpt::StopDTMF(TMSStreamType streamtype) |
1492 gint TMSCallIPAdpt::StopDTMF(TMSStreamType streamtype) |
1511 { |
1493 { |
1512 TRACE_PRN_FN_ENT; |
1494 TRACE_PRN_FN_ENT; |
1513 |
1495 gint status(TMS_RESULT_SUCCESS); |
1514 if (streamtype == TMS_STREAM_DOWNLINK) |
1496 |
|
1497 if (streamtype == TMS_STREAM_DOWNLINK && iDTMFDnlinkPlayer) |
1515 { |
1498 { |
1516 iDTMFDnlinkPlayer->Cancel(); |
1499 iDTMFDnlinkPlayer->Cancel(); |
1517 } |
1500 } |
1518 else if (streamtype == TMS_STREAM_UPLINK) |
1501 else if (streamtype == TMS_STREAM_UPLINK && iDTMFUplinkPlayer) |
1519 { |
1502 { |
|
1503 //status = iDTMFUplinkPlayer->StopDtmfTone(); |
1520 iDTMFUplinkPlayer->Cancel(); |
1504 iDTMFUplinkPlayer->Cancel(); |
1521 } |
1505 } |
1522 |
1506 |
1523 TRACE_PRN_FN_EXT; |
1507 TRACE_PRN_FN_EXT; |
1524 return TMS_RESULT_SUCCESS; |
1508 return status; |
1525 } |
1509 } |
1526 |
1510 |
1527 // ----------------------------------------------------------------------------- |
1511 // ----------------------------------------------------------------------------- |
1528 // TMSCallIPAdpt::ContinueDTMF |
1512 // TMSCallIPAdpt::ContinueDTMF |
1529 // |
1513 // |
1530 // ----------------------------------------------------------------------------- |
1514 // ----------------------------------------------------------------------------- |
1531 // |
1515 // |
1532 gint TMSCallIPAdpt::ContinueDTMF(gboolean /*continuesending*/) |
1516 gint TMSCallIPAdpt::ContinueDTMF(const gboolean /*sending*/) |
1533 { |
1517 { |
1534 return TMS_RESULT_FEATURE_NOT_SUPPORTED; |
1518 return TMS_RESULT_FEATURE_NOT_SUPPORTED; |
1535 } |
1519 } |
1536 |
1520 |
1537 //From DTMFTonePlayerObserver |
1521 //From DTMFTonePlayerObserver |
1538 // ----------------------------------------------------------------------------- |
1522 // ----------------------------------------------------------------------------- |
1539 // TMSCallIPAdpt::DTMFInitCompleted |
1523 // TMSCallIPAdpt::DTMFInitCompleted |
1540 // |
1524 // |
1541 // ----------------------------------------------------------------------------- |
1525 // ----------------------------------------------------------------------------- |
1542 // |
1526 // |
1543 void TMSCallIPAdpt::DTMFInitCompleted(gint /*error*/) |
1527 void TMSCallIPAdpt::DTMFInitCompleted(gint /*status*/) |
1544 { |
1528 { |
1545 TRACE_PRN_FN_ENT; |
1529 TRACE_PRN_FN_ENT; |
1546 //TRACE_PRN_IF_ERR(error); |
1530 // TODO: process error |
1547 TRACE_PRN_FN_EXT; |
1531 TRACE_PRN_FN_EXT; |
1548 } |
1532 } |
1549 |
1533 |
1550 // ----------------------------------------------------------------------------- |
1534 // ----------------------------------------------------------------------------- |
1551 // TMSCallIPAdpt::DTMFToneFinished |
1535 // TMSCallIPAdpt::DTMFToneFinished |
1552 // |
1536 // |
1553 // ----------------------------------------------------------------------------- |
1537 // ----------------------------------------------------------------------------- |
1554 // |
1538 // |
1555 void TMSCallIPAdpt::DTMFToneFinished(gint error) |
1539 void TMSCallIPAdpt::DTMFToneFinished(gint status) |
1556 { |
1540 { |
1557 TRACE_PRN_FN_ENT; |
1541 TRACE_PRN_FN_ENT; |
1558 TRACE_PRN_IF_ERR(error); |
1542 TRACE_PRN_IF_ERR(status); |
1559 TmsMsgBufPckg dtmfpckg; |
1543 TmsMsgBufPckg dtmfpckg; |
1560 |
1544 |
1561 // Ignore KErrUnderflow - end of DTMF playback. |
1545 // KErrUnderflow indicates end of DTMF playback. |
1562 if(error == KErrUnderflow /*|| error == KErrInUse*/) |
1546 if (status == KErrUnderflow /*|| status == KErrInUse*/) |
1563 { |
1547 { |
1564 error = TMS_RESULT_SUCCESS; |
1548 status = TMS_RESULT_SUCCESS; |
1565 } |
1549 } |
1566 dtmfpckg().iStatus = error; |
1550 dtmfpckg().iStatus = TMSUtility::TMSResult(status); |
1567 dtmfpckg().iRequest = ECmdDTMFTonePlayFinished; |
1551 dtmfpckg().iRequest = ECmdDTMFTonePlayFinished; |
1568 if (iDTMFNotifier) |
1552 if (iDTMFNotifier) |
1569 { |
1553 { |
1570 iDTMFNotifier->SetDtmf(dtmfpckg); |
1554 iDTMFNotifier->SetDtmf(dtmfpckg); |
1571 } |
1555 } |
1572 TRACE_PRN_FN_EXT; |
1556 TRACE_PRN_FN_EXT; |
1573 } |
1557 } |
1574 |
1558 |
1575 // ----------------------------------------------------------------------------- |
1559 // ----------------------------------------------------------------------------- |
|
1560 // TMSCallIPAdpt::DownlinkInitCompleted |
|
1561 // From TMSIPDevSoundObserver |
|
1562 // ----------------------------------------------------------------------------- |
|
1563 // |
|
1564 void TMSCallIPAdpt::DownlinkInitCompleted(gint status) |
|
1565 { |
|
1566 TRACE_PRN_FN_ENT; |
|
1567 if (status == TMS_RESULT_SUCCESS) |
|
1568 { |
|
1569 iDnlinkInitialized = TRUE; |
|
1570 } |
|
1571 NotifyClient(iDnlinkStreamId, ECmdDownlinkInitComplete, status); |
|
1572 TRACE_PRN_FN_EXT; |
|
1573 } |
|
1574 |
|
1575 // ----------------------------------------------------------------------------- |
|
1576 // TMSCallIPAdpt::UplinkInitCompleted |
|
1577 // From TMSIPDevSoundObserver |
|
1578 // ----------------------------------------------------------------------------- |
|
1579 // |
|
1580 void TMSCallIPAdpt::UplinkInitCompleted(gint status) |
|
1581 { |
|
1582 TRACE_PRN_FN_ENT; |
|
1583 if (status == TMS_RESULT_SUCCESS) |
|
1584 { |
|
1585 iUplinkInitialized = TRUE; |
|
1586 } |
|
1587 NotifyClient(iUplinkStreamId, ECmdUplinkInitComplete, status); |
|
1588 TRACE_PRN_FN_EXT; |
|
1589 } |
|
1590 |
|
1591 // ----------------------------------------------------------------------------- |
|
1592 // TMSCallIPAdpt::UplinkStarted |
|
1593 // From TMSIPDevSoundObserver |
|
1594 // ----------------------------------------------------------------------------- |
|
1595 // |
|
1596 void TMSCallIPAdpt::UplinkStarted(gint status) |
|
1597 { |
|
1598 TRACE_PRN_FN_ENT; |
|
1599 NotifyClient(iUplinkStreamId, ECmdUplinkStarted, status); |
|
1600 TRACE_PRN_FN_EXT; |
|
1601 } |
|
1602 |
|
1603 // ----------------------------------------------------------------------------- |
|
1604 // TMSCallIPAdpt::DownlinkStarted |
|
1605 // From TMSIPDevSoundObserver |
|
1606 // ----------------------------------------------------------------------------- |
|
1607 // |
|
1608 void TMSCallIPAdpt::DownlinkStarted(gint status) |
|
1609 { |
|
1610 TRACE_PRN_FN_ENT; |
|
1611 NotifyClient(iDnlinkStreamId, ECmdDownlinkStarted, status); |
|
1612 TRACE_PRN_FN_EXT; |
|
1613 } |
|
1614 |
|
1615 // ----------------------------------------------------------------------------- |
1576 // TMSCallIPAdpt::NotifyClient |
1616 // TMSCallIPAdpt::NotifyClient |
1577 // ----------------------------------------------------------------------------- |
1617 // ----------------------------------------------------------------------------- |
1578 // |
1618 // |
1579 void TMSCallIPAdpt::NotifyClient(const gint strmId, const gint aCommand, |
1619 void TMSCallIPAdpt::NotifyClient(const gint strmId, const gint command, |
1580 const gint aStatus, const gint64 /*aInt64*/) |
1620 const gint status, const gint64 /*int64*/) |
1581 { |
1621 { |
1582 iMsgBuffer.iRequest = aCommand; |
1622 iMsgBuffer.iRequest = command; |
1583 iMsgBuffer.iStatus = aStatus; |
1623 iMsgBuffer.iStatus = status; |
1584 |
1624 |
1585 if (strmId == iUplinkStreamId) |
1625 if (strmId == iUplinkStreamId) |
1586 { |
1626 { |
1587 iMsgQueueUp.Send(iMsgBuffer); |
1627 iMsgQueueUp.Send(iMsgBuffer); |
1588 } |
1628 } |