107 // ----------------------------------------------------------------------------- |
105 // ----------------------------------------------------------------------------- |
108 // TMSCallIPAdpt::CreateStream |
106 // TMSCallIPAdpt::CreateStream |
109 // |
107 // |
110 // ----------------------------------------------------------------------------- |
108 // ----------------------------------------------------------------------------- |
111 // |
109 // |
112 gint TMSCallIPAdpt::CreateStream(TMSCallType /*callType*/, |
110 gint TMSCallIPAdpt::CreateStream(const TMSCallType /*callType*/, |
113 TMSStreamType strmType, gint& outStrmId) |
111 const TMSStreamType strmType, gint& outStrmId) |
114 { |
112 { |
115 TRACE_PRN_FN_ENT; |
113 TRACE_PRN_FN_ENT; |
116 gint status(TMS_RESULT_SUCCESS); |
114 gint status(TMS_RESULT_SUCCESS); |
117 switch (strmType) |
115 switch (strmType) |
118 { |
116 { |
119 case TMS_STREAM_UPLINK: |
117 case TMS_STREAM_UPLINK: |
120 { |
118 { |
121 status = TMS_RESULT_ALREADY_EXIST; |
119 status = TMS_RESULT_ALREADY_EXIST; |
122 if (!iUplinkInitialized) |
120 if (!iUplinkInitialized) |
123 { |
121 { |
124 iUplinkInitialized = TRUE; |
|
125 iUplinkStreamId = iNextStreamId; |
122 iUplinkStreamId = iNextStreamId; |
126 outStrmId = iUplinkStreamId; |
123 outStrmId = iUplinkStreamId; |
127 iNextStreamId++; |
124 iNextStreamId++; |
|
125 //iUplinkInitialized = TRUE; //not initialized yet! |
128 status = TMS_RESULT_SUCCESS; |
126 status = TMS_RESULT_SUCCESS; |
129 } |
127 } |
130 break; |
128 break; |
131 } |
129 } |
132 case TMS_STREAM_DOWNLINK: |
130 case TMS_STREAM_DOWNLINK: |
133 { |
131 { |
134 status = TMS_RESULT_ALREADY_EXIST; |
132 status = TMS_RESULT_ALREADY_EXIST; |
135 if (!iDnlinkInitialized) |
133 if (!iDnlinkInitialized) |
136 { |
134 { |
137 iDnlinkInitialized = TRUE; |
|
138 iDnlinkStreamId = iNextStreamId; |
135 iDnlinkStreamId = iNextStreamId; |
139 outStrmId = iDnlinkStreamId; |
136 outStrmId = iDnlinkStreamId; |
140 iNextStreamId++; |
137 iNextStreamId++; |
|
138 //iDnlinkInitialized = TRUE; //not initialized yet! |
141 status = TMS_RESULT_SUCCESS; |
139 status = TMS_RESULT_SUCCESS; |
142 } |
140 } |
143 break; |
141 break; |
144 } |
142 } |
145 default: |
143 default: |
155 // ----------------------------------------------------------------------------- |
153 // ----------------------------------------------------------------------------- |
156 // TMSCallIPAdpt::InitStream |
154 // TMSCallIPAdpt::InitStream |
157 // |
155 // |
158 // ----------------------------------------------------------------------------- |
156 // ----------------------------------------------------------------------------- |
159 // |
157 // |
160 gint TMSCallIPAdpt::InitStream(TMSCallType /*callType*/, TMSStreamType strmType, |
158 gint TMSCallIPAdpt::InitStream(const TMSCallType /*callType*/, |
161 gint strmId, TMSFormatType frmtType, const RMessage2& message) |
159 const TMSStreamType strmType, const gint strmId, |
|
160 const TMSFormatType frmtType, const RMessage2& message) |
162 { |
161 { |
163 TRACE_PRN_FN_ENT; |
162 TRACE_PRN_FN_ENT; |
164 gint status(TMS_RESULT_SUCCESS); |
163 gint status(TMS_RESULT_SUCCESS); |
165 |
|
166 guint32 fourCC = TOFOURCC(frmtType); |
164 guint32 fourCC = TOFOURCC(frmtType); |
167 if (fourCC == NULL) |
165 if (fourCC == NULL) |
168 { |
166 { |
169 return TMS_RESULT_INVALID_ARGUMENT; |
167 return TMS_RESULT_INVALID_ARGUMENT; |
170 } |
168 } |
175 { |
173 { |
176 status = TMS_RESULT_DOES_NOT_EXIST; |
174 status = TMS_RESULT_DOES_NOT_EXIST; |
177 if (strmId == iUplinkStreamId) |
175 if (strmId == iUplinkStreamId) |
178 { |
176 { |
179 SetFormat(iUplinkStreamId, fourCC); |
177 SetFormat(iUplinkStreamId, fourCC); |
180 status = OpenUplinkL(message); |
178 status = OpenUplink(message); |
181 NotifyClient(iUplinkStreamId, ECmdUplinkInitComplete, status); |
|
182 } |
179 } |
183 break; |
180 break; |
184 } |
181 } |
185 case TMS_STREAM_DOWNLINK: |
182 case TMS_STREAM_DOWNLINK: |
186 { |
183 { |
187 status = TMS_RESULT_DOES_NOT_EXIST; |
184 status = TMS_RESULT_DOES_NOT_EXIST; |
188 if (strmId == iDnlinkStreamId) |
185 if (strmId == iDnlinkStreamId) |
189 { |
186 { |
190 SetFormat(iDnlinkStreamId, fourCC); |
187 SetFormat(iDnlinkStreamId, fourCC); |
191 status = OpenDownlinkL(message); |
188 status = OpenDownlink(message); |
192 NotifyClient(iDnlinkStreamId, ECmdDownlinkInitComplete, status); |
|
193 } |
189 } |
194 break; |
190 break; |
195 } |
191 } |
196 default: |
192 default: |
197 { |
193 { |
208 // ----------------------------------------------------------------------------- |
204 // ----------------------------------------------------------------------------- |
209 // TMSCallIPAdpt::StartStream |
205 // TMSCallIPAdpt::StartStream |
210 // |
206 // |
211 // ----------------------------------------------------------------------------- |
207 // ----------------------------------------------------------------------------- |
212 // |
208 // |
213 gint TMSCallIPAdpt::StartStream(TMSCallType /*callType*/, |
209 gint TMSCallIPAdpt::StartStream(const TMSCallType /*callType*/, |
214 TMSStreamType strmType, gint strmId) |
210 const TMSStreamType strmType, const gint strmId) |
215 { |
211 { |
216 TRACE_PRN_FN_ENT; |
212 TRACE_PRN_FN_ENT; |
217 gint status(TMS_RESULT_INVALID_STATE); |
213 gint status(TMS_RESULT_INVALID_STATE); |
218 switch (strmType) |
214 switch (strmType) |
219 { |
215 { |
220 case TMS_STREAM_UPLINK: |
216 case TMS_STREAM_UPLINK: |
221 { |
217 { |
222 if (strmId == iUplinkStreamId && iIPUplink) |
218 if (iIPUplink && strmId == iUplinkStreamId) |
223 { |
219 { |
224 iIPUplink->Start(); |
220 iIPUplink->Start(); |
225 status = TMS_RESULT_SUCCESS; |
221 status = TMS_RESULT_SUCCESS; |
226 NotifyClient(iUplinkStreamId, ECmdUplinkStarted, status); |
222 NotifyClient(iUplinkStreamId, ECmdUplinkStarted, status); |
227 } |
223 } |
228 break; |
224 break; |
229 } |
225 } |
230 case TMS_STREAM_DOWNLINK: |
226 case TMS_STREAM_DOWNLINK: |
231 { |
227 { |
232 if (strmId == iDnlinkStreamId && iIPDownlink) |
228 if (iIPDownlink && strmId == iDnlinkStreamId) |
233 { |
229 { |
234 iIPDownlink->Start(); |
230 iIPDownlink->Start(); |
235 status = TMS_RESULT_SUCCESS; |
231 status = TMS_RESULT_SUCCESS; |
236 NotifyClient(iDnlinkStreamId, ECmdDownlinkStarted, status); |
232 NotifyClient(iDnlinkStreamId, ECmdDownlinkStarted, status); |
237 } |
233 } |
250 // ----------------------------------------------------------------------------- |
246 // ----------------------------------------------------------------------------- |
251 // TMSCallIPAdpt::PauseStream |
247 // TMSCallIPAdpt::PauseStream |
252 // |
248 // |
253 // ----------------------------------------------------------------------------- |
249 // ----------------------------------------------------------------------------- |
254 // |
250 // |
255 gint TMSCallIPAdpt::PauseStream(TMSCallType /*callType*/, |
251 gint TMSCallIPAdpt::PauseStream(const TMSCallType /*callType*/, |
256 TMSStreamType strmType, gint strmId) |
252 const TMSStreamType strmType, const gint strmId) |
257 { |
253 { |
258 TRACE_PRN_FN_ENT; |
254 TRACE_PRN_FN_ENT; |
259 gint status(TMS_RESULT_INVALID_STATE); |
255 gint status(TMS_RESULT_INVALID_STATE); |
260 switch (strmType) |
256 switch (strmType) |
261 { |
257 { |
292 // ----------------------------------------------------------------------------- |
288 // ----------------------------------------------------------------------------- |
293 // TMSCallIPAdpt::StopStream |
289 // TMSCallIPAdpt::StopStream |
294 // |
290 // |
295 // ----------------------------------------------------------------------------- |
291 // ----------------------------------------------------------------------------- |
296 // |
292 // |
297 gint TMSCallIPAdpt::StopStream(TMSCallType /*callType*/, TMSStreamType strmType, |
293 gint TMSCallIPAdpt::StopStream(const TMSCallType /*callType*/, |
298 gint strmId) |
294 const TMSStreamType strmType, const gint strmId) |
299 { |
295 { |
300 TRACE_PRN_FN_ENT; |
296 TRACE_PRN_FN_ENT; |
301 gint status(TMS_RESULT_INVALID_STATE); |
297 gint status(TMS_RESULT_INVALID_STATE); |
302 |
298 |
303 switch (strmType) |
299 switch (strmType) |
304 { |
300 { |
305 case TMS_STREAM_UPLINK: |
301 case TMS_STREAM_UPLINK: |
306 { |
302 { |
307 if (strmId == iUplinkStreamId && iIPUplink) |
303 if (iIPUplink && strmId == iUplinkStreamId) |
308 { |
304 { |
309 iIPUplink->Stop(); |
305 iIPUplink->Stop(); |
310 status = TMS_RESULT_SUCCESS; |
306 status = TMS_RESULT_SUCCESS; |
311 NotifyClient(iUplinkStreamId, ECmdUplinkInitComplete, status); |
307 NotifyClient(iUplinkStreamId, ECmdUplinkInitComplete, status); |
312 } |
308 } |
313 break; |
309 break; |
314 } |
310 } |
315 case TMS_STREAM_DOWNLINK: |
311 case TMS_STREAM_DOWNLINK: |
316 { |
312 { |
317 if (strmId == iDnlinkStreamId && iIPDownlink) |
313 if (iIPDownlink && strmId == iDnlinkStreamId) |
318 { |
314 { |
319 iIPDownlink->Stop(); |
315 iIPDownlink->Stop(); |
320 status = TMS_RESULT_SUCCESS; |
316 status = TMS_RESULT_SUCCESS; |
321 NotifyClient(iDnlinkStreamId, ECmdDownlinkInitComplete, status); |
317 NotifyClient(iDnlinkStreamId, ECmdDownlinkInitComplete, status); |
322 } |
318 } |
335 // ----------------------------------------------------------------------------- |
331 // ----------------------------------------------------------------------------- |
336 // TMSCallIPAdpt::DeinitStream |
332 // TMSCallIPAdpt::DeinitStream |
337 // |
333 // |
338 // ----------------------------------------------------------------------------- |
334 // ----------------------------------------------------------------------------- |
339 // |
335 // |
340 gint TMSCallIPAdpt::DeinitStream(TMSCallType /*callType*/, |
336 gint TMSCallIPAdpt::DeinitStream(const TMSCallType /*callType*/, |
341 TMSStreamType strmType, gint strmId) |
337 const TMSStreamType strmType, const gint strmId) |
342 { |
338 { |
343 TRACE_PRN_FN_ENT; |
339 TRACE_PRN_FN_ENT; |
344 gint status(TMS_RESULT_INVALID_STATE); |
340 gint status(TMS_RESULT_INVALID_STATE); |
345 |
341 |
346 switch (strmType) |
342 switch (strmType) |
347 { |
343 { |
348 case TMS_STREAM_UPLINK: |
344 case TMS_STREAM_UPLINK: |
349 { |
345 { |
350 if (strmId == iUplinkStreamId && iIPUplink) |
346 if (iIPUplink && strmId == iUplinkStreamId) |
351 { |
347 { |
352 iIPUplink->Stop(); |
348 iIPUplink->Stop(); |
353 //iUplinkStreamId = -1; |
349 //iUplinkStreamId = -1; |
354 iUplinkInitialized = FALSE; |
350 iUplinkInitialized = FALSE; |
355 status = TMS_RESULT_SUCCESS; |
351 status = TMS_RESULT_SUCCESS; |
356 NotifyClient(iUplinkStreamId, ECmdDownlinkDeInitComplete, |
352 NotifyClient(iUplinkStreamId, ECmdUplinkDeInitComplete, status); |
357 status); |
|
358 } |
353 } |
359 break; |
354 break; |
360 } |
355 } |
361 case TMS_STREAM_DOWNLINK: |
356 case TMS_STREAM_DOWNLINK: |
362 { |
357 { |
363 if (strmId == iDnlinkStreamId && iIPDownlink) |
358 if (iIPDownlink && strmId == iDnlinkStreamId) |
364 { |
359 { |
365 iIPDownlink->Stop(); |
360 iIPDownlink->Stop(); |
366 //iDnlinkStreamId = -1; |
361 //iDnlinkStreamId = -1; |
367 iDnlinkInitialized = FALSE; |
362 iDnlinkInitialized = FALSE; |
368 status = TMS_RESULT_SUCCESS; |
363 status = TMS_RESULT_SUCCESS; |
385 // ----------------------------------------------------------------------------- |
380 // ----------------------------------------------------------------------------- |
386 // TMSCallIPAdpt::DeleteStream |
381 // TMSCallIPAdpt::DeleteStream |
387 // |
382 // |
388 // ----------------------------------------------------------------------------- |
383 // ----------------------------------------------------------------------------- |
389 // |
384 // |
390 gint TMSCallIPAdpt::DeleteStream(TMSCallType /*callType*/, |
385 gint TMSCallIPAdpt::DeleteStream(const TMSCallType /*callType*/, |
391 TMSStreamType strmType, gint strmId) |
386 const TMSStreamType strmType, const gint strmId) |
392 { |
387 { |
393 TRACE_PRN_FN_ENT; |
388 TRACE_PRN_FN_ENT; |
394 gint status(TMS_RESULT_SUCCESS); |
389 gint status(TMS_RESULT_SUCCESS); |
395 switch (strmType) |
390 switch (strmType) |
396 { |
391 { |
397 case TMS_STREAM_UPLINK: |
392 case TMS_STREAM_UPLINK: |
398 { |
393 { |
399 // This is additional error checking |
|
400 if (strmId == iUplinkStreamId) |
394 if (strmId == iUplinkStreamId) |
401 { |
395 { |
402 iUplinkStreamId = -1; |
396 iUplinkStreamId = -1; |
403 iUplinkInitialized = FALSE; |
397 iUplinkInitialized = FALSE; |
404 } |
398 } |
405 break; |
399 break; |
406 } |
400 } |
407 case TMS_STREAM_DOWNLINK: |
401 case TMS_STREAM_DOWNLINK: |
408 { |
402 { |
409 // This is additional error checking |
|
410 if (strmId == iDnlinkStreamId) |
403 if (strmId == iDnlinkStreamId) |
411 { |
404 { |
412 iDnlinkStreamId = -1; |
405 iDnlinkStreamId = -1; |
413 iDnlinkInitialized = FALSE; |
406 iDnlinkInitialized = FALSE; |
414 } |
407 } |
427 // ----------------------------------------------------------------------------- |
420 // ----------------------------------------------------------------------------- |
428 // TMSCallIPAdpt::DataXferBufferEmptied |
421 // TMSCallIPAdpt::DataXferBufferEmptied |
429 // |
422 // |
430 // ----------------------------------------------------------------------------- |
423 // ----------------------------------------------------------------------------- |
431 // |
424 // |
432 gint TMSCallIPAdpt::DataXferBufferEmptied(TMSCallType /*callType*/, |
425 gint TMSCallIPAdpt::DataXferBufferEmptied(const TMSCallType /*callType*/, |
433 TMSStreamType strmType, gint strmId) |
426 const TMSStreamType strmType, const gint strmId) |
434 { |
427 { |
435 TRACE_PRN_FN_ENT; |
428 TRACE_PRN_FN_ENT; |
436 gint status(TMS_RESULT_SUCCESS); |
429 gint status(TMS_RESULT_SUCCESS); |
437 switch (strmType) |
430 switch (strmType) |
438 { |
431 { |
458 // ----------------------------------------------------------------------------- |
451 // ----------------------------------------------------------------------------- |
459 // TMSCallIPAdpt::DataXferBufferFilled |
452 // TMSCallIPAdpt::DataXferBufferFilled |
460 // |
453 // |
461 // ----------------------------------------------------------------------------- |
454 // ----------------------------------------------------------------------------- |
462 // |
455 // |
463 gint TMSCallIPAdpt::DataXferBufferFilled(TMSCallType /*callType*/, |
456 gint TMSCallIPAdpt::DataXferBufferFilled(const TMSCallType /*callType*/, |
464 TMSStreamType strmType, gint strmId, guint datasize) |
457 const TMSStreamType strmType, const gint strmId, const guint datasize) |
465 { |
458 { |
466 TRACE_PRN_FN_ENT; |
459 TRACE_PRN_FN_ENT; |
467 gint status(TMS_RESULT_SUCCESS); |
460 gint status(TMS_RESULT_SUCCESS); |
468 switch (strmType) |
461 switch (strmType) |
469 { |
462 { |
528 // |
521 // |
529 gint TMSCallIPAdpt::GetMaxVolume(guint& volume) |
522 gint TMSCallIPAdpt::GetMaxVolume(guint& volume) |
530 { |
523 { |
531 TRACE_PRN_FN_ENT; |
524 TRACE_PRN_FN_ENT; |
532 gint status(TMS_RESULT_INVALID_STATE); |
525 gint status(TMS_RESULT_INVALID_STATE); |
533 |
|
534 if (iDnlinkInitialized && iIPDownlink) |
526 if (iDnlinkInitialized && iIPDownlink) |
535 { |
527 { |
536 status = iIPDownlink->GetMaxVolume(volume); |
528 status = iIPDownlink->GetMaxVolume(volume); |
537 iMaxVolume = volume; |
529 iMaxVolume = volume; |
538 TRACE_PRN_N1(_L("TMS->TMSCallIPAdpt: GetMaxVolume [%d]"), iMaxVolume); |
530 TRACE_PRN_N1(_L("TMS->TMSCallIPAdpt: GetMaxVolume [%d]"), iMaxVolume); |
539 } |
531 } |
540 |
|
541 TRACE_PRN_FN_EXT; |
532 TRACE_PRN_FN_EXT; |
542 return status; |
533 return status; |
543 } |
534 } |
544 |
535 |
545 // ----------------------------------------------------------------------------- |
536 // ----------------------------------------------------------------------------- |
980 TRACE_PRN_FN_EXT; |
973 TRACE_PRN_FN_EXT; |
981 return status; |
974 return status; |
982 } |
975 } |
983 |
976 |
984 // ----------------------------------------------------------------------------- |
977 // ----------------------------------------------------------------------------- |
985 // TMSCallIPAdpt::OpenDownlinkL |
978 // TMSCallIPAdpt::OpenDownlink |
986 // Method for player initialization. |
979 // Method for player initialization. |
987 // ----------------------------------------------------------------------------- |
980 // ----------------------------------------------------------------------------- |
988 // |
981 // |
989 gint TMSCallIPAdpt::OpenDownlinkL(const RMessage2& message) |
982 gint TMSCallIPAdpt::OpenDownlink(const RMessage2& message) |
990 { |
983 { |
991 TRACE_PRN_FN_ENT; |
984 TRACE_PRN_FN_ENT; |
992 gint status(TMS_RESULT_UNINITIALIZED_OBJECT); |
985 gint status(TMS_RESULT_SUCCESS); |
993 |
986 |
994 // Clients must have MultimediaDD capability to use this priority/pref. |
987 // Clients must have MultimediaDD capability to use this priority/pref. |
995 // TODO: Also, TMS will monitor for emergency call and if detected it |
988 // TODO: Also, TMS will monitor for emergency call and if detected it |
996 // will deny access to audio resources. |
989 // will deny access to audio resources. |
997 |
990 |
1002 * KAudioPriorityVoipAudioDownlink -NOK native VoIP? |
995 * KAudioPriorityVoipAudioDownlink -NOK native VoIP? |
1003 */ |
996 */ |
1004 iPriority.iPref = KAudioPrefVoipAudioDownlink; |
997 iPriority.iPref = KAudioPrefVoipAudioDownlink; |
1005 iPriority.iPriority = KAudioPriorityVoipAudioDownlink; |
998 iPriority.iPriority = KAudioPriorityVoipAudioDownlink; |
1006 |
999 |
1007 if (!iIPDownlink) |
1000 delete iIPDownlink; |
1008 { |
1001 iIPDownlink = NULL; |
1009 iIPDownlink = TMSIPDownlink::NewL(iDnFourCC, iPriority); |
1002 TRAP(status, iIPDownlink = TMSIPDownlink::NewL(*this, iDnFourCC, |
1010 } |
1003 iPriority)); |
1011 |
1004 |
1012 if (iIPDownlink) |
1005 if (iIPDownlink && status == TMS_RESULT_SUCCESS) |
1013 { |
1006 { |
1014 // Open message queue for handling server notifications to the client |
1007 // Open message queue for handling server notifications to the client |
1015 if (iMsgQueueDn.Handle() <= 0) |
1008 if (iMsgQueueDn.Handle() <= 0) |
1016 { |
1009 { |
1017 // Second argument in TMSCallProxy::InitStream |
1010 // Second argument in TMSCallProxy::InitStream |
1028 TRACE_PRN_FN_EXT; |
1021 TRACE_PRN_FN_EXT; |
1029 return status; |
1022 return status; |
1030 } |
1023 } |
1031 |
1024 |
1032 // ----------------------------------------------------------------------------- |
1025 // ----------------------------------------------------------------------------- |
1033 // TMSCallIPAdpt::OpenUplinkL |
1026 // TMSCallIPAdpt::OpenUplink |
1034 // Method for recorder initialization. |
1027 // Method for recorder initialization. |
1035 // ----------------------------------------------------------------------------- |
1028 // ----------------------------------------------------------------------------- |
1036 // |
1029 // |
1037 gint TMSCallIPAdpt::OpenUplinkL(const RMessage2& message) |
1030 gint TMSCallIPAdpt::OpenUplink(const RMessage2& message) |
1038 { |
1031 { |
1039 TRACE_PRN_FN_ENT; |
1032 TRACE_PRN_FN_ENT; |
1040 gint status(TMS_RESULT_UNINITIALIZED_OBJECT); |
1033 gint status(TMS_RESULT_SUCCESS); |
1041 |
1034 |
1042 // Clients must have MultimediaDD capability to use this priority/pref |
1035 // Clients must have MultimediaDD capability to use this priority/pref |
1043 |
1036 |
1044 /* Clarify with adaptation team which prio/pref values should be used. |
1037 /* Clarify with adaptation team which prio/pref values should be used. |
1045 * 1) KAudioPrefUnknownVoipAudioUplink -3rd party VoIP? |
1038 * 1) KAudioPrefUnknownVoipAudioUplink -3rd party VoIP? |
1048 * KAudioPriorityVoipAudioUplink -NOK native VoIP? |
1041 * KAudioPriorityVoipAudioUplink -NOK native VoIP? |
1049 */ |
1042 */ |
1050 iPriority.iPref = KAudioPrefVoipAudioUplink; |
1043 iPriority.iPref = KAudioPrefVoipAudioUplink; |
1051 iPriority.iPriority = KAudioPriorityVoipAudioUplink; |
1044 iPriority.iPriority = KAudioPriorityVoipAudioUplink; |
1052 |
1045 |
1053 if (!iIPUplink) |
1046 delete iIPUplink; |
1054 { |
1047 iIPUplink = NULL; |
1055 iIPUplink = TMSIPUplink::NewL(iUpFourCC, iPriority); |
1048 TRAP(status, iIPUplink = TMSIPUplink::NewL(*this, iUpFourCC, iPriority)); |
1056 } |
1049 |
1057 |
1050 if (iIPUplink && status == TMS_RESULT_SUCCESS) |
1058 if (iIPUplink) |
|
1059 { |
1051 { |
1060 // Open message queue for handling server notifications to the client |
1052 // Open message queue for handling server notifications to the client |
1061 if (iMsgQueueUp.Handle() <= 0) |
1053 if (iMsgQueueUp.Handle() <= 0) |
1062 { |
1054 { |
1063 // Second argument in TMSCallProxy::InitStream |
1055 // Second argument in TMSCallProxy::InitStream |
1346 // |
1337 // |
1347 // ----------------------------------------------------------------------------- |
1338 // ----------------------------------------------------------------------------- |
1348 // |
1339 // |
1349 gint TMSCallIPAdpt::SetOutput(TMSAudioOutput output) |
1340 gint TMSCallIPAdpt::SetOutput(TMSAudioOutput output) |
1350 { |
1341 { |
|
1342 TRACE_PRN_FN_ENT; |
1351 gint status(TMS_RESULT_UNINITIALIZED_OBJECT); |
1343 gint status(TMS_RESULT_UNINITIALIZED_OBJECT); |
1352 if (iDnlinkInitialized && iIPDownlink) |
1344 if (iDnlinkInitialized && iIPDownlink) |
1353 { |
1345 { |
1354 TRAP(status, iIPDownlink->SetAudioDeviceL(output)); |
1346 TRAP(status, iIPDownlink->SetAudioDeviceL(output)); |
1355 } |
1347 } |
|
1348 TRACE_PRN_FN_EXT; |
1356 return status; |
1349 return status; |
1357 } |
1350 } |
1358 // ----------------------------------------------------------------------------- |
1351 // ----------------------------------------------------------------------------- |
1359 // TMSCallIPAdpt::GetOutput |
1352 // TMSCallIPAdpt::GetOutput |
1360 // |
1353 // |
1361 // ----------------------------------------------------------------------------- |
1354 // ----------------------------------------------------------------------------- |
1362 // |
1355 // |
1363 gint TMSCallIPAdpt::GetOutput(TMSAudioOutput& output) |
1356 gint TMSCallIPAdpt::GetOutput(TMSAudioOutput& output) |
1364 { |
1357 { |
|
1358 TRACE_PRN_FN_ENT; |
1365 gint status(TMS_RESULT_UNINITIALIZED_OBJECT); |
1359 gint status(TMS_RESULT_UNINITIALIZED_OBJECT); |
1366 if (iDnlinkInitialized && iIPDownlink) |
1360 if (iDnlinkInitialized && iIPDownlink) |
1367 { |
1361 { |
1368 TRAP(status, iIPDownlink->GetAudioDeviceL(output)); |
1362 TRAP(status, iIPDownlink->GetAudioDeviceL(output)); |
1369 } |
1363 } |
1370 return status; |
1364 TRACE_PRN_FN_EXT; |
1371 } |
1365 return status; |
|
1366 } |
|
1367 |
1372 // ----------------------------------------------------------------------------- |
1368 // ----------------------------------------------------------------------------- |
1373 // TMSCallIPAdpt::GetPreviousOutput |
1369 // TMSCallIPAdpt::GetPreviousOutput |
1374 // |
1370 // |
1375 // ----------------------------------------------------------------------------- |
1371 // ----------------------------------------------------------------------------- |
1376 // |
1372 // |
1383 // TMSCallIPAdpt::GetAvailableOutputsL |
1379 // TMSCallIPAdpt::GetAvailableOutputsL |
1384 // |
1380 // |
1385 // ----------------------------------------------------------------------------- |
1381 // ----------------------------------------------------------------------------- |
1386 // |
1382 // |
1387 gint TMSCallIPAdpt::GetAvailableOutputsL(gint& /*count*/, |
1383 gint TMSCallIPAdpt::GetAvailableOutputsL(gint& /*count*/, |
1388 CBufFlat*& /*outputsbuffer*/) |
1384 CBufFlat*& /*outputsbuf*/) |
1389 { |
1385 { |
1390 return TMS_RESULT_FEATURE_NOT_SUPPORTED; |
1386 return TMS_RESULT_FEATURE_NOT_SUPPORTED; |
1391 } |
1387 } |
1392 |
1388 |
1393 // ----------------------------------------------------------------------------- |
1389 // ----------------------------------------------------------------------------- |
|
1390 // ----------------------------------------------------------------------------- |
|
1391 // TMSCallIPAdpt::DownlinkInitCompleted |
|
1392 // From TMSIPDevSoundObserver |
|
1393 // ----------------------------------------------------------------------------- |
|
1394 // |
|
1395 void TMSCallIPAdpt::DownlinkInitCompleted(gint status) |
|
1396 { |
|
1397 TRACE_PRN_FN_ENT; |
|
1398 if (status == TMS_RESULT_SUCCESS) |
|
1399 { |
|
1400 iDnlinkInitialized = TRUE; |
|
1401 } |
|
1402 NotifyClient(iDnlinkStreamId, ECmdDownlinkInitComplete, status); |
|
1403 TRACE_PRN_FN_EXT; |
|
1404 } |
|
1405 |
|
1406 // ----------------------------------------------------------------------------- |
|
1407 // TMSCallIPAdpt::UplinkInitCompleted |
|
1408 // From TMSIPDevSoundObserver |
|
1409 // ----------------------------------------------------------------------------- |
|
1410 // |
|
1411 void TMSCallIPAdpt::UplinkInitCompleted(gint status) |
|
1412 { |
|
1413 TRACE_PRN_FN_ENT; |
|
1414 if (status == TMS_RESULT_SUCCESS) |
|
1415 { |
|
1416 iUplinkInitialized = TRUE; |
|
1417 } |
|
1418 NotifyClient(iUplinkStreamId, ECmdUplinkInitComplete, status); |
|
1419 TRACE_PRN_FN_EXT; |
|
1420 } |
|
1421 |
|
1422 // ----------------------------------------------------------------------------- |
|
1423 // TMSCallIPAdpt::UplinkStarted |
|
1424 // From TMSIPDevSoundObserver |
|
1425 // ----------------------------------------------------------------------------- |
|
1426 // |
|
1427 void TMSCallIPAdpt::UplinkStarted(gint status) |
|
1428 { |
|
1429 TRACE_PRN_FN_ENT; |
|
1430 NotifyClient(iUplinkStreamId, ECmdUplinkStarted, status); |
|
1431 TRACE_PRN_FN_EXT; |
|
1432 } |
|
1433 |
|
1434 // ----------------------------------------------------------------------------- |
|
1435 // TMSCallIPAdpt::DownlinkStarted |
|
1436 // From TMSIPDevSoundObserver |
|
1437 // ----------------------------------------------------------------------------- |
|
1438 // |
|
1439 void TMSCallIPAdpt::DownlinkStarted(gint status) |
|
1440 { |
|
1441 TRACE_PRN_FN_ENT; |
|
1442 NotifyClient(iDnlinkStreamId, ECmdDownlinkStarted, status); |
|
1443 TRACE_PRN_FN_EXT; |
|
1444 } |
|
1445 |
|
1446 // ----------------------------------------------------------------------------- |
1394 // TMSCallIPAdpt::NotifyClient |
1447 // TMSCallIPAdpt::NotifyClient |
1395 // ----------------------------------------------------------------------------- |
1448 // ----------------------------------------------------------------------------- |
1396 // |
1449 // |
1397 void TMSCallIPAdpt::NotifyClient(const gint strmId, const gint aCommand, |
1450 void TMSCallIPAdpt::NotifyClient(const gint strmId, const gint command, |
1398 const gint aStatus, const gint64 /*aInt64*/) |
1451 const gint status, const gint64 /*int64*/) |
1399 { |
1452 { |
1400 iMsgBuffer.iRequest = aCommand; |
1453 iMsgBuffer.iRequest = command; |
1401 iMsgBuffer.iStatus = aStatus; |
1454 iMsgBuffer.iStatus = status; |
1402 |
1455 |
1403 if (strmId == iUplinkStreamId) |
1456 if (strmId == iUplinkStreamId) |
1404 { |
1457 { |
1405 iMsgQueueUp.Send(iMsgBuffer); |
1458 iMsgQueueUp.Send(iMsgBuffer); |
1406 } |
1459 } |