| branch | RCL_3 |
| changeset 17 | 60e492b28869 |
| parent 12 | 2eb3b066cc7d |
| child 19 | 095bea5f582e |
| 15:ab526b8cacfb | 17:60e492b28869 |
|---|---|
28 #include "tmstarsettings.h" |
28 #include "tmstarsettings.h" |
29 |
29 |
30 using namespace TMS; |
30 using namespace TMS; |
31 |
31 |
32 // ----------------------------------------------------------------------------- |
32 // ----------------------------------------------------------------------------- |
33 // TMSCallCSAdpt::TMSCallCSAdpt |
33 // TMSCallCSAdpt::NewL |
34 // |
34 // Symbian constructor. |
35 // ----------------------------------------------------------------------------- |
35 // ----------------------------------------------------------------------------- |
36 // |
36 // |
37 TMSCallCSAdpt::TMSCallCSAdpt() |
37 TMSCallCSAdpt* TMSCallCSAdpt::NewL() |
38 { |
38 { |
39 TRACE_PRN_FN_ENT; |
39 TMSCallCSAdpt* self = new (ELeave) TMSCallCSAdpt(); |
40 |
40 CleanupStack::PushL(self); |
41 self->ConstructL(); |
|
42 CleanupStack::Pop(self); |
|
43 return self; |
|
44 } |
|
45 |
|
46 // ----------------------------------------------------------------------------- |
|
47 // TMSCallCSAdpt::ConstructL |
|
48 // 2-nd phase constructor. |
|
49 // ----------------------------------------------------------------------------- |
|
50 // |
|
51 void TMSCallCSAdpt::ConstructL() |
|
52 { |
|
53 TRACE_PRN_FN_ENT; |
|
41 iCSDownlink = NULL; |
54 iCSDownlink = NULL; |
42 iCSUplink = NULL; |
55 iCSUplink = NULL; |
43 iRouting = NULL; |
56 iRouting = NULL; |
44 iTarSettings = NULL; |
57 iTarSettings = NULL; |
45 |
58 TRACE_PRN_FN_EXT; |
46 TRACE_PRN_FN_EXT; |
59 } |
60 |
|
61 // ----------------------------------------------------------------------------- |
|
62 // TMSCallCSAdpt::TMSCallCSAdpt |
|
63 // |
|
64 // ----------------------------------------------------------------------------- |
|
65 // |
|
66 TMSCallCSAdpt::TMSCallCSAdpt() |
|
67 { |
|
47 } |
68 } |
48 |
69 |
49 // ----------------------------------------------------------------------------- |
70 // ----------------------------------------------------------------------------- |
50 // TMSCallCSAdpt::~TMSCallCSAdpt |
71 // TMSCallCSAdpt::~TMSCallCSAdpt |
51 // |
72 // |
52 // ----------------------------------------------------------------------------- |
73 // ----------------------------------------------------------------------------- |
53 // |
74 // |
54 TMSCallCSAdpt::~TMSCallCSAdpt() |
75 TMSCallCSAdpt::~TMSCallCSAdpt() |
55 { |
76 { |
56 TRACE_PRN_FN_ENT; |
77 TRACE_PRN_FN_ENT; |
57 delete iCSDownlink; |
78 |
58 delete iCSUplink; |
|
59 delete iRouting; |
79 delete iRouting; |
60 delete iTarSettings; |
80 delete iTarSettings; |
81 delete iCSUplink; |
|
82 delete iCSDownlink; |
|
61 |
83 |
62 if (iMsgQueueUp.Handle() > 0) |
84 if (iMsgQueueUp.Handle() > 0) |
63 { |
85 { |
64 iMsgQueueUp.Close(); |
86 iMsgQueueUp.Close(); |
65 } |
87 } |
66 |
|
67 if (iMsgQueueDn.Handle() > 0) |
88 if (iMsgQueueDn.Handle() > 0) |
68 { |
89 { |
69 iMsgQueueDn.Close(); |
90 iMsgQueueDn.Close(); |
70 } |
91 } |
71 |
92 |
82 TRACE_PRN_FN_ENT; |
103 TRACE_PRN_FN_ENT; |
83 gint status(TMS_RESULT_SUCCESS); |
104 gint status(TMS_RESULT_SUCCESS); |
84 iNextStreamId = 1; |
105 iNextStreamId = 1; |
85 iUplinkInitialized = FALSE; |
106 iUplinkInitialized = FALSE; |
86 iDnlinkInitialized = FALSE; |
107 iDnlinkInitialized = FALSE; |
87 |
|
88 TRACE_PRN_FN_EXT; |
108 TRACE_PRN_FN_EXT; |
89 return status; |
109 return status; |
90 } |
110 } |
91 |
111 |
92 // ----------------------------------------------------------------------------- |
112 // ----------------------------------------------------------------------------- |
93 // TMSCallCSAdpt::CreateStream |
113 // TMSCallCSAdpt::CreateStream |
94 // |
114 // |
95 // ----------------------------------------------------------------------------- |
115 // ----------------------------------------------------------------------------- |
96 // |
116 // |
97 gint TMSCallCSAdpt::CreateStream(TMSCallType /*callType*/, |
117 gint TMSCallCSAdpt::CreateStream(const TMSCallType /*callType*/, |
98 TMSStreamType strmType, gint& outStrmId) |
118 const TMSStreamType strmType, gint& outStrmId) |
99 { |
119 { |
100 TRACE_PRN_FN_ENT; |
120 TRACE_PRN_FN_ENT; |
101 gint status(TMS_RESULT_SUCCESS); |
121 gint status(TMS_RESULT_SUCCESS); |
102 switch (strmType) |
122 switch (strmType) |
103 { |
123 { |
104 case TMS_STREAM_UPLINK: |
124 case TMS_STREAM_UPLINK: |
125 { |
|
105 status = TMS_RESULT_ALREADY_EXIST; |
126 status = TMS_RESULT_ALREADY_EXIST; |
106 if (!iUplinkInitialized) |
127 if (!iUplinkInitialized) |
107 { |
128 { |
108 iUplinkInitialized = TRUE; |
|
109 iUplinkStreamId = iNextStreamId; |
129 iUplinkStreamId = iNextStreamId; |
110 outStrmId = iUplinkStreamId; |
130 outStrmId = iUplinkStreamId; |
111 iNextStreamId++; |
131 iNextStreamId++; |
112 iUplinkInitialized = TRUE; |
132 //iUplinkInitialized = TRUE; //not initialized yet! |
113 status = TMS_RESULT_SUCCESS; |
133 status = TMS_RESULT_SUCCESS; |
114 } |
134 } |
115 break; |
135 break; |
136 } |
|
116 case TMS_STREAM_DOWNLINK: |
137 case TMS_STREAM_DOWNLINK: |
138 { |
|
117 status = TMS_RESULT_ALREADY_EXIST; |
139 status = TMS_RESULT_ALREADY_EXIST; |
118 if (!iDnlinkInitialized) |
140 if (!iDnlinkInitialized) |
119 { |
141 { |
120 iDnlinkInitialized = TRUE; |
|
121 iDnlinkStreamId = iNextStreamId; |
142 iDnlinkStreamId = iNextStreamId; |
122 outStrmId = iDnlinkStreamId; |
143 outStrmId = iDnlinkStreamId; |
123 iNextStreamId++; |
144 iNextStreamId++; |
124 iDnlinkInitialized = TRUE; |
145 //iDnlinkInitialized = TRUE; //not initialized yet! |
125 status = TMS_RESULT_SUCCESS; |
146 status = TMS_RESULT_SUCCESS; |
126 } |
147 } |
127 break; |
148 break; |
149 } |
|
128 default: |
150 default: |
151 { |
|
129 status = TMS_RESULT_STREAM_TYPE_NOT_SUPPORTED; |
152 status = TMS_RESULT_STREAM_TYPE_NOT_SUPPORTED; |
130 break; |
153 break; |
154 } |
|
131 } |
155 } |
132 TRACE_PRN_FN_EXT; |
156 TRACE_PRN_FN_EXT; |
133 return status; |
157 return status; |
134 } |
158 } |
135 |
159 |
136 // ----------------------------------------------------------------------------- |
160 // ----------------------------------------------------------------------------- |
137 // TMSCallCSAdpt::InitStream |
161 // TMSCallCSAdpt::InitStream |
138 // |
162 // |
139 // ----------------------------------------------------------------------------- |
163 // ----------------------------------------------------------------------------- |
140 // |
164 // |
141 gint TMSCallCSAdpt::InitStream(TMSCallType /*callType*/, TMSStreamType strmType, |
165 gint TMSCallCSAdpt::InitStream(const TMSCallType /*callType*/, |
142 gint strmId, TMSFormatType /*frmtType*/, const RMessage2& message) |
166 const TMSStreamType strmType, const gint strmId, |
167 const TMSFormatType /*frmtType*/, const RMessage2& message) |
|
143 { |
168 { |
144 TRACE_PRN_FN_ENT; |
169 TRACE_PRN_FN_ENT; |
145 gint status(TMS_RESULT_SUCCESS); |
170 gint status(TMS_RESULT_SUCCESS); |
146 |
171 |
147 switch (strmType) |
172 switch (strmType) |
148 { |
173 { |
149 case TMS_STREAM_UPLINK: |
174 case TMS_STREAM_UPLINK: |
150 { |
175 { |
176 status = TMS_RESULT_DOES_NOT_EXIST; |
|
151 if (strmId == iUplinkStreamId) |
177 if (strmId == iUplinkStreamId) |
152 { |
178 { |
153 // Open message queue handling client-server communication |
179 // Open message queue handling client-server communication |
154 if (iMsgQueueUp.Handle() <= 0) |
180 if (iMsgQueueUp.Handle() <= 0) |
155 { |
181 { |
156 // Third argument in TMSCallProxy::InitStream |
182 // Third argument in TMSCallProxy::InitStream |
157 status = iMsgQueueUp.Open(message, 1); |
183 status = iMsgQueueUp.Open(message, 1); |
158 } |
184 } |
159 if (status == TMS_RESULT_SUCCESS) |
185 if (status == TMS_RESULT_SUCCESS) |
160 { |
186 { |
161 TRAP(status, iCSUplink = TMSCSUplink::NewL(*this)); |
187 status = InitUplink(); |
162 } |
188 } |
163 iStrmtype = TMS_STREAM_UPLINK; |
|
164 } |
189 } |
165 else |
|
166 { |
|
167 status = TMS_RESULT_DOES_NOT_EXIST; |
|
168 } |
|
169 break; |
190 break; |
170 } |
191 } |
171 case TMS_STREAM_DOWNLINK: |
192 case TMS_STREAM_DOWNLINK: |
172 { |
193 { |
194 status = TMS_RESULT_DOES_NOT_EXIST; |
|
173 if (strmId == iDnlinkStreamId) |
195 if (strmId == iDnlinkStreamId) |
174 { |
196 { |
175 // Open message queue handling client-server communication |
197 // Open message queue handling client-server communication |
176 if (iMsgQueueDn.Handle() <= 0) |
198 if (iMsgQueueDn.Handle() <= 0) |
177 { |
199 { |
178 // Third argument in TMSCallProxy::InitStream |
200 // Third argument in TMSCallProxy::InitStream |
179 status = iMsgQueueDn.Open(message, 1); |
201 status = iMsgQueueDn.Open(message, 1); |
180 } |
202 } |
181 if (status == TMS_RESULT_SUCCESS) |
203 if (status == TMS_RESULT_SUCCESS) |
182 { |
204 { |
183 TRAP(status, iCSDownlink = TMSCSDownlink::NewL(*this)); |
205 status = InitDownlink(); |
184 if (status == TMS_RESULT_SUCCESS) |
|
185 { |
|
186 TRAP(status, iRouting = |
|
187 CTelephonyAudioRouting::NewL(*this)); |
|
188 if (status == TMS_RESULT_SUCCESS) |
|
189 { |
|
190 TRAP(status, iTarSettings = TMSTarSettings::NewL()); |
|
191 } |
|
192 } |
|
193 } |
206 } |
194 iStrmtype = TMS_STREAM_DOWNLINK; |
|
195 } |
207 } |
196 else |
|
197 { |
|
198 status = TMS_RESULT_DOES_NOT_EXIST; |
|
199 } |
|
200 break; |
208 break; |
201 } |
209 } |
202 default: |
210 default: |
203 { |
211 { |
204 status = TMS_RESULT_STREAM_TYPE_NOT_SUPPORTED; |
212 status = TMS_RESULT_STREAM_TYPE_NOT_SUPPORTED; |
210 TRACE_PRN_FN_EXT; |
218 TRACE_PRN_FN_EXT; |
211 return status; |
219 return status; |
212 } |
220 } |
213 |
221 |
214 // ----------------------------------------------------------------------------- |
222 // ----------------------------------------------------------------------------- |
223 // TMSCallCSAdpt::InitUplink |
|
224 // |
|
225 // ----------------------------------------------------------------------------- |
|
226 // |
|
227 gint TMSCallCSAdpt::InitUplink() |
|
228 { |
|
229 gint status(TMS_RESULT_SUCCESS); |
|
230 if (!iCSUplink) |
|
231 { |
|
232 TRAP(status, iCSUplink = TMSCSUplink::NewL(*this)); |
|
233 } |
|
234 return status; |
|
235 } |
|
236 |
|
237 // ----------------------------------------------------------------------------- |
|
238 // TMSCallCSAdpt::InitDownlink |
|
239 // |
|
240 // ----------------------------------------------------------------------------- |
|
241 // |
|
242 gint TMSCallCSAdpt::InitDownlink() |
|
243 { |
|
244 gint status(TMS_RESULT_SUCCESS); |
|
245 |
|
246 if (!iCSDownlink) |
|
247 { |
|
248 TRAP(status, iCSDownlink = TMSCSDownlink::NewL(*this)); |
|
249 } |
|
250 if (!iRouting && status == TMS_RESULT_SUCCESS) |
|
251 { |
|
252 TRAP(status, iRouting = CTelephonyAudioRouting::NewL(*this)); |
|
253 } |
|
254 if (!iTarSettings && status == TMS_RESULT_SUCCESS) |
|
255 { |
|
256 TRAP(status, iTarSettings = TMSTarSettings::NewL()); |
|
257 } |
|
258 return status; |
|
259 } |
|
260 |
|
261 // ----------------------------------------------------------------------------- |
|
215 // TMSCallCSAdpt::StartStream |
262 // TMSCallCSAdpt::StartStream |
216 // |
263 // |
217 // ----------------------------------------------------------------------------- |
264 // ----------------------------------------------------------------------------- |
218 // |
265 // |
219 gint TMSCallCSAdpt::StartStream(TMSCallType /*callType*/, |
266 gint TMSCallCSAdpt::StartStream(const TMSCallType /*callType*/, |
220 TMSStreamType strmType, gint strmId) |
267 const TMSStreamType strmType, const gint strmId) |
221 { |
268 { |
222 TRACE_PRN_FN_ENT; |
269 TRACE_PRN_FN_ENT; |
223 gint status(TMS_RESULT_SUCCESS); |
270 gint status(TMS_RESULT_INVALID_STATE); |
224 switch (strmType) |
271 switch (strmType) |
225 { |
272 { |
226 case TMS_STREAM_UPLINK: |
273 case TMS_STREAM_UPLINK: |
274 { |
|
227 if (iCSUplink && strmId == iUplinkStreamId) |
275 if (iCSUplink && strmId == iUplinkStreamId) |
228 { |
276 { |
229 iCSUplink->Activate(); |
277 iCSUplink->Activate(); |
278 status = TMS_RESULT_SUCCESS; |
|
230 } |
279 } |
231 break; |
280 break; |
281 } |
|
232 case TMS_STREAM_DOWNLINK: |
282 case TMS_STREAM_DOWNLINK: |
283 { |
|
233 if (iCSDownlink && strmId == iDnlinkStreamId) |
284 if (iCSDownlink && strmId == iDnlinkStreamId) |
234 { |
285 { |
235 iCSDownlink->Activate(); |
286 iCSDownlink->Activate(); |
287 status = TMS_RESULT_SUCCESS; |
|
236 } |
288 } |
237 break; |
289 break; |
290 } |
|
238 default: |
291 default: |
292 { |
|
239 status = TMS_RESULT_STREAM_TYPE_NOT_SUPPORTED; |
293 status = TMS_RESULT_STREAM_TYPE_NOT_SUPPORTED; |
240 break; |
294 break; |
295 } |
|
241 } |
296 } |
242 TRACE_PRN_FN_EXT; |
297 TRACE_PRN_FN_EXT; |
243 return status; |
298 return status; |
244 } |
299 } |
245 |
300 |
246 // ----------------------------------------------------------------------------- |
301 // ----------------------------------------------------------------------------- |
247 // TMSCallCSAdpt::PauseStream |
302 // TMSCallCSAdpt::PauseStream |
248 // |
303 // |
249 // ----------------------------------------------------------------------------- |
304 // ----------------------------------------------------------------------------- |
250 // |
305 // |
251 gint TMSCallCSAdpt::PauseStream(TMSCallType /*callType*/, |
306 gint TMSCallCSAdpt::PauseStream(const TMSCallType /*callType*/, |
252 TMSStreamType /*strmType*/, gint /*strmId*/) |
307 const TMSStreamType /*strmType*/, const gint /*strmId*/) |
253 { |
308 { |
254 TRACE_PRN_FN_ENT; |
309 TRACE_PRN_FN_ENT; |
255 gint status(TMS_RESULT_SUCCESS); |
310 gint status(TMS_RESULT_FEATURE_NOT_SUPPORTED); |
256 TRACE_PRN_FN_EXT; |
311 TRACE_PRN_FN_EXT; |
257 return status; |
312 return status; |
258 } |
313 } |
259 |
314 |
260 // ----------------------------------------------------------------------------- |
315 // ----------------------------------------------------------------------------- |
261 // TMSCallCSAdpt::StopStream |
316 // TMSCallCSAdpt::StopStream |
262 // |
317 // |
263 // ----------------------------------------------------------------------------- |
318 // ----------------------------------------------------------------------------- |
264 // |
319 // |
265 gint TMSCallCSAdpt::StopStream(TMSCallType /*callType*/, TMSStreamType strmType, |
320 gint TMSCallCSAdpt::StopStream(const TMSCallType /*callType*/, |
266 gint strmId) |
321 const TMSStreamType strmType, const gint strmId) |
267 { |
322 { |
268 TRACE_PRN_FN_ENT; |
323 TRACE_PRN_FN_ENT; |
269 gint status(TMS_RESULT_SUCCESS); |
324 gint status(TMS_RESULT_INVALID_STATE); |
325 |
|
270 switch (strmType) |
326 switch (strmType) |
271 { |
327 { |
272 case TMS_STREAM_UPLINK: |
328 case TMS_STREAM_UPLINK: |
329 { |
|
273 if (iCSUplink && strmId == iUplinkStreamId) |
330 if (iCSUplink && strmId == iUplinkStreamId) |
274 { |
331 { |
275 iCSUplink->Deactivate(); |
332 iCSUplink->Deactivate(); |
276 NotifyClient(iUplinkStreamId, ECmdUplinkInitComplete, |
333 status = TMS_RESULT_SUCCESS; |
277 status, 0); |
334 NotifyClient(iUplinkStreamId, ECmdUplinkInitComplete, status); |
278 } |
335 } |
279 break; |
336 break; |
337 } |
|
280 case TMS_STREAM_DOWNLINK: |
338 case TMS_STREAM_DOWNLINK: |
339 { |
|
281 if (iCSDownlink && strmId == iDnlinkStreamId) |
340 if (iCSDownlink && strmId == iDnlinkStreamId) |
282 { |
341 { |
283 iCSDownlink->Deactivate(); |
342 iCSDownlink->Deactivate(); |
284 NotifyClient(iDnlinkStreamId, ECmdDownlinkInitComplete, |
343 status = TMS_RESULT_SUCCESS; |
285 status, 0); |
344 NotifyClient(iDnlinkStreamId, ECmdDownlinkInitComplete, status); |
286 } |
345 } |
287 break; |
346 break; |
347 } |
|
288 default: |
348 default: |
349 { |
|
289 status = TMS_RESULT_STREAM_TYPE_NOT_SUPPORTED; |
350 status = TMS_RESULT_STREAM_TYPE_NOT_SUPPORTED; |
290 break; |
351 break; |
352 } |
|
291 } |
353 } |
292 TRACE_PRN_FN_EXT; |
354 TRACE_PRN_FN_EXT; |
293 return status; |
355 return status; |
294 } |
356 } |
295 |
357 |
296 // ----------------------------------------------------------------------------- |
358 // ----------------------------------------------------------------------------- |
297 // TMSCallCSAdpt::DeinitStream |
359 // TMSCallCSAdpt::DeinitStream |
298 // |
360 // |
299 // ----------------------------------------------------------------------------- |
361 // ----------------------------------------------------------------------------- |
300 // |
362 // |
301 gint TMSCallCSAdpt::DeinitStream(TMSCallType /*callType*/, |
363 gint TMSCallCSAdpt::DeinitStream(const TMSCallType /*callType*/, |
302 TMSStreamType strmType, gint strmId) |
364 const TMSStreamType strmType, const gint strmId) |
303 { |
365 { |
304 TRACE_PRN_FN_ENT; |
366 TRACE_PRN_FN_ENT; |
305 gint status(TMS_RESULT_SUCCESS); |
367 gint status(TMS_RESULT_INVALID_STATE); |
368 |
|
306 switch (strmType) |
369 switch (strmType) |
307 { |
370 { |
308 case TMS_STREAM_UPLINK: |
371 case TMS_STREAM_UPLINK: |
372 { |
|
309 if (iCSUplink && strmId == iUplinkStreamId) |
373 if (iCSUplink && strmId == iUplinkStreamId) |
310 { |
374 { |
311 iCSUplink->Deactivate(); |
375 iCSUplink->Deactivate(); |
312 iUplinkInitialized = FALSE; |
376 iUplinkInitialized = FALSE; |
313 NotifyClient(iUplinkStreamId, ECmdUplinkDeInitComplete, |
377 status = TMS_RESULT_SUCCESS; |
314 status, 0); |
378 NotifyClient(iUplinkStreamId, ECmdUplinkDeInitComplete, status); |
315 } |
379 } |
316 break; |
380 break; |
317 case TMS_STREAM_DOWNLINK: |
381 case TMS_STREAM_DOWNLINK: |
318 if (iCSDownlink && strmId == iDnlinkStreamId) |
382 if (iCSDownlink && strmId == iDnlinkStreamId) |
319 { |
383 { |
320 iCSDownlink->Deactivate(); |
384 iCSDownlink->Deactivate(); |
321 iDnlinkInitialized = FALSE; |
385 iDnlinkInitialized = FALSE; |
386 status = TMS_RESULT_SUCCESS; |
|
322 NotifyClient(iDnlinkStreamId, ECmdDownlinkDeInitComplete, |
387 NotifyClient(iDnlinkStreamId, ECmdDownlinkDeInitComplete, |
323 status, 0); |
388 status); |
324 } |
389 } |
325 break; |
390 break; |
391 } |
|
326 default: |
392 default: |
393 { |
|
327 status = TMS_RESULT_STREAM_TYPE_NOT_SUPPORTED; |
394 status = TMS_RESULT_STREAM_TYPE_NOT_SUPPORTED; |
328 break; |
395 break; |
396 } |
|
329 } |
397 } |
330 TRACE_PRN_FN_EXT; |
398 TRACE_PRN_FN_EXT; |
331 return status; |
399 return status; |
332 } |
400 } |
333 |
401 |
334 // ----------------------------------------------------------------------------- |
402 // ----------------------------------------------------------------------------- |
335 // TMSCallCSAdpt::DeleteStream |
403 // TMSCallCSAdpt::DeleteStream |
336 // |
404 // |
337 // ----------------------------------------------------------------------------- |
405 // ----------------------------------------------------------------------------- |
338 // |
406 // |
339 gint TMSCallCSAdpt::DeleteStream(TMSCallType /*callType*/, |
407 gint TMSCallCSAdpt::DeleteStream(const TMSCallType /*callType*/, |
340 TMSStreamType strmType, gint strmId) |
408 const TMSStreamType strmType, const gint strmId) |
341 { |
409 { |
342 TRACE_PRN_FN_ENT; |
410 TRACE_PRN_FN_ENT; |
343 gint status(TMS_RESULT_SUCCESS); |
411 gint status(TMS_RESULT_SUCCESS); |
344 switch (strmType) |
412 switch (strmType) |
345 { |
413 { |
346 case TMS_STREAM_UPLINK: |
414 case TMS_STREAM_UPLINK: |
415 { |
|
347 if (strmId == iUplinkStreamId) |
416 if (strmId == iUplinkStreamId) |
348 { |
417 { |
349 iUplinkStreamId = -1; |
418 iUplinkStreamId = -1; |
350 iUplinkInitialized = FALSE; |
419 iUplinkInitialized = FALSE; |
351 } |
420 } |
352 break; |
421 break; |
422 } |
|
353 case TMS_STREAM_DOWNLINK: |
423 case TMS_STREAM_DOWNLINK: |
424 { |
|
354 if (strmId == iDnlinkStreamId) |
425 if (strmId == iDnlinkStreamId) |
355 { |
426 { |
356 iDnlinkStreamId = -1; |
427 iDnlinkStreamId = -1; |
357 iDnlinkInitialized = FALSE; |
428 iDnlinkInitialized = FALSE; |
358 } |
429 } |
359 break; |
430 break; |
431 } |
|
360 default: |
432 default: |
433 { |
|
361 status = TMS_RESULT_STREAM_TYPE_NOT_SUPPORTED; |
434 status = TMS_RESULT_STREAM_TYPE_NOT_SUPPORTED; |
362 break; |
435 break; |
436 } |
|
363 } |
437 } |
364 TRACE_PRN_FN_EXT; |
438 TRACE_PRN_FN_EXT; |
365 return status; |
439 return status; |
366 } |
440 } |
367 |
441 |
368 // ----------------------------------------------------------------------------- |
442 // ----------------------------------------------------------------------------- |
369 // TMSCallCSAdpt::DataXferBufferEmptied |
443 // TMSCallCSAdpt::DataXferBufferEmptied |
370 // |
444 // |
371 // ----------------------------------------------------------------------------- |
445 // ----------------------------------------------------------------------------- |
372 // |
446 // |
373 gint TMSCallCSAdpt::DataXferBufferEmptied(TMSCallType /*callType*/, |
447 gint TMSCallCSAdpt::DataXferBufferEmptied(const TMSCallType /*callType*/, |
374 TMSStreamType /*strmType*/, gint /*strmId*/) |
448 const TMSStreamType /*strmType*/, const gint /*strmId*/) |
375 { |
449 { |
376 TRACE_PRN_FN_ENT; |
450 TRACE_PRN_FN_ENT; |
377 gint status(TMS_RESULT_FEATURE_NOT_SUPPORTED); |
451 gint status(TMS_RESULT_FEATURE_NOT_SUPPORTED); |
378 TRACE_PRN_FN_EXT; |
452 TRACE_PRN_FN_EXT; |
379 return status; |
453 return status; |
382 // ----------------------------------------------------------------------------- |
456 // ----------------------------------------------------------------------------- |
383 // TMSCallCSAdpt::DataXferBufferFilled |
457 // TMSCallCSAdpt::DataXferBufferFilled |
384 // |
458 // |
385 // ----------------------------------------------------------------------------- |
459 // ----------------------------------------------------------------------------- |
386 // |
460 // |
387 gint TMSCallCSAdpt::DataXferBufferFilled(TMSCallType /*callType*/, |
461 gint TMSCallCSAdpt::DataXferBufferFilled(const TMSCallType /*callType*/, |
388 TMSStreamType /*strmType*/, gint /*strmId*/, guint /*datasize*/) |
462 const TMSStreamType /*strmType*/, const gint /*strmId*/, |
463 const guint /*datasize*/) |
|
389 { |
464 { |
390 TRACE_PRN_FN_ENT; |
465 TRACE_PRN_FN_ENT; |
391 gint status(TMS_RESULT_FEATURE_NOT_SUPPORTED); |
466 gint status(TMS_RESULT_FEATURE_NOT_SUPPORTED); |
392 TRACE_PRN_FN_EXT; |
467 TRACE_PRN_FN_EXT; |
393 return status; |
468 return status; |
414 // ----------------------------------------------------------------------------- |
489 // ----------------------------------------------------------------------------- |
415 // |
490 // |
416 gint TMSCallCSAdpt::GetMaxVolume(guint& volume) |
491 gint TMSCallCSAdpt::GetMaxVolume(guint& volume) |
417 { |
492 { |
418 TRACE_PRN_FN_ENT; |
493 TRACE_PRN_FN_ENT; |
419 gint status(TMS_RESULT_ILLEGAL_OPERATION); |
494 gint status(TMS_RESULT_INVALID_STATE); |
420 if (iCSDownlink && iDnlinkInitialized) |
495 if (iCSDownlink && iDnlinkInitialized) |
421 { |
496 { |
422 volume = iCSDownlink->MaxVolume(); |
497 volume = iCSDownlink->MaxVolume(); |
423 status = TMS_RESULT_SUCCESS; |
498 status = TMS_RESULT_SUCCESS; |
499 TRACE_PRN_N1(_L("TMS->TMSCallCSAdpt: GetMaxVolume [%d]"), volume); |
|
424 } |
500 } |
425 TRACE_PRN_FN_EXT; |
501 TRACE_PRN_FN_EXT; |
426 return status; |
502 return status; |
427 } |
503 } |
428 |
504 |
432 // ----------------------------------------------------------------------------- |
508 // ----------------------------------------------------------------------------- |
433 // |
509 // |
434 gint TMSCallCSAdpt::SetVolume(const guint volume) |
510 gint TMSCallCSAdpt::SetVolume(const guint volume) |
435 { |
511 { |
436 TRACE_PRN_FN_ENT; |
512 TRACE_PRN_FN_ENT; |
437 gint status(TMS_RESULT_ILLEGAL_OPERATION); |
513 gint status(TMS_RESULT_INVALID_STATE); |
438 if (iCSDownlink && iDnlinkInitialized) |
514 if (iCSDownlink && iDnlinkInitialized) |
439 { |
515 { |
440 iCSDownlink->SetVolume(volume); |
516 iCSDownlink->SetVolume(volume); |
441 status = TMS_RESULT_SUCCESS; |
517 status = TMS_RESULT_SUCCESS; |
442 NotifyClient(iDnlinkStreamId, ECmdSetVolume, status, 0); |
518 NotifyClient(iDnlinkStreamId, ECmdSetVolume, status); |
443 } |
519 } |
444 TRACE_PRN_FN_EXT; |
520 TRACE_PRN_FN_EXT; |
445 return status; |
521 return status; |
446 } |
522 } |
447 |
523 |
451 // ----------------------------------------------------------------------------- |
527 // ----------------------------------------------------------------------------- |
452 // |
528 // |
453 gint TMSCallCSAdpt::GetVolume(guint& volume) |
529 gint TMSCallCSAdpt::GetVolume(guint& volume) |
454 { |
530 { |
455 TRACE_PRN_FN_ENT; |
531 TRACE_PRN_FN_ENT; |
456 gint status(TMS_RESULT_ILLEGAL_OPERATION); |
532 gint status(TMS_RESULT_INVALID_STATE); |
457 if (iCSDownlink && iDnlinkInitialized) |
533 if (iCSDownlink && iDnlinkInitialized) |
458 { |
534 { |
459 volume = iCSDownlink->Volume(); |
535 volume = iCSDownlink->Volume(); |
460 status = TMS_RESULT_SUCCESS; |
536 status = TMS_RESULT_SUCCESS; |
461 } |
537 } |
462 |
|
463 TRACE_PRN_FN_EXT; |
538 TRACE_PRN_FN_EXT; |
464 return status; |
539 return status; |
465 } |
540 } |
466 |
541 |
467 // ----------------------------------------------------------------------------- |
542 // ----------------------------------------------------------------------------- |
470 // ----------------------------------------------------------------------------- |
545 // ----------------------------------------------------------------------------- |
471 // |
546 // |
472 gint TMSCallCSAdpt::GetMaxGain(guint& gain) |
547 gint TMSCallCSAdpt::GetMaxGain(guint& gain) |
473 { |
548 { |
474 TRACE_PRN_FN_ENT; |
549 TRACE_PRN_FN_ENT; |
475 gint status(TMS_RESULT_ILLEGAL_OPERATION); |
550 gint status(TMS_RESULT_INVALID_STATE); |
476 if (iCSUplink && iUplinkInitialized) |
551 if (iCSUplink && iUplinkInitialized) |
477 { |
552 { |
478 gain = iCSUplink->MaxGain(); |
553 gain = iCSUplink->MaxGain(); |
479 status = TMS_RESULT_SUCCESS; |
554 status = TMS_RESULT_SUCCESS; |
555 TRACE_PRN_N1(_L("TMS->TMSCallCSAdpt::GetMaxGain [%d]"), gain); |
|
480 } |
556 } |
481 TRACE_PRN_FN_EXT; |
557 TRACE_PRN_FN_EXT; |
482 return status; |
558 return status; |
483 } |
559 } |
484 |
560 |
488 // ----------------------------------------------------------------------------- |
564 // ----------------------------------------------------------------------------- |
489 // |
565 // |
490 gint TMSCallCSAdpt::SetGain(const guint gain) |
566 gint TMSCallCSAdpt::SetGain(const guint gain) |
491 { |
567 { |
492 TRACE_PRN_FN_ENT; |
568 TRACE_PRN_FN_ENT; |
493 gint status(TMS_RESULT_ILLEGAL_OPERATION); |
569 gint status(TMS_RESULT_INVALID_STATE); |
494 if (iUplinkInitialized) |
570 if (iCSUplink && iUplinkInitialized) |
495 { |
571 { |
496 iCSUplink->SetGain(gain); |
572 iCSUplink->SetGain(gain); |
497 status = TMS_RESULT_SUCCESS; |
573 status = TMS_RESULT_SUCCESS; |
498 NotifyClient(iUplinkInitialized, ECmdSetGain, status, 0); |
574 NotifyClient(iUplinkStreamId, ECmdSetGain, status); |
499 } |
575 } |
500 TRACE_PRN_FN_EXT; |
576 TRACE_PRN_FN_EXT; |
501 return status; |
577 return status; |
502 } |
578 } |
503 |
579 |
507 // ----------------------------------------------------------------------------- |
583 // ----------------------------------------------------------------------------- |
508 // |
584 // |
509 gint TMSCallCSAdpt::GetGain(guint& gain) |
585 gint TMSCallCSAdpt::GetGain(guint& gain) |
510 { |
586 { |
511 TRACE_PRN_FN_ENT; |
587 TRACE_PRN_FN_ENT; |
512 gint status(TMS_RESULT_ILLEGAL_OPERATION); |
588 gint status(TMS_RESULT_INVALID_STATE); |
513 if (iCSUplink && iUplinkInitialized) |
589 if (iCSUplink && iUplinkInitialized) |
514 { |
590 { |
515 gain = iCSUplink->Gain(); |
591 gain = iCSUplink->Gain(); |
516 status = TMS_RESULT_SUCCESS; |
592 status = TMS_RESULT_SUCCESS; |
517 } |
593 } |
525 // ----------------------------------------------------------------------------- |
601 // ----------------------------------------------------------------------------- |
526 // |
602 // |
527 gint TMSCallCSAdpt::GetGlobalMaxVolume(guint& volume) |
603 gint TMSCallCSAdpt::GetGlobalMaxVolume(guint& volume) |
528 { |
604 { |
529 TRACE_PRN_FN_ENT; |
605 TRACE_PRN_FN_ENT; |
530 gint status(TMS_RESULT_ILLEGAL_OPERATION); |
606 gint status(TMS_RESULT_INVALID_STATE); |
531 if (iCSDownlink && iDnlinkInitialized) |
607 if (iCSDownlink && iDnlinkInitialized) |
532 { |
608 { |
533 volume = iCSDownlink->MaxVolume(); |
609 volume = iCSDownlink->MaxVolume(); |
534 status = TMS_RESULT_SUCCESS; |
610 status = TMS_RESULT_SUCCESS; |
611 TRACE_PRN_N1(_L("TMS->TMSCallCSAdpt::GetGlobalMaxVolume [%d]"), volume); |
|
535 } |
612 } |
536 TRACE_PRN_FN_EXT; |
613 TRACE_PRN_FN_EXT; |
537 return status; |
614 return status; |
538 } |
615 } |
539 |
616 |
543 // ----------------------------------------------------------------------------- |
620 // ----------------------------------------------------------------------------- |
544 // |
621 // |
545 gint TMSCallCSAdpt::SetGlobalVolume(const guint volume) |
622 gint TMSCallCSAdpt::SetGlobalVolume(const guint volume) |
546 { |
623 { |
547 TRACE_PRN_FN_ENT; |
624 TRACE_PRN_FN_ENT; |
548 gint status(TMS_RESULT_SUCCESS); |
625 gint status(TMS_RESULT_INVALID_STATE); |
549 |
|
550 iGlobalVol = volume; |
626 iGlobalVol = volume; |
551 if (iCSDownlink && iDnlinkInitialized) |
627 if (iCSDownlink && iDnlinkInitialized) |
552 { |
628 { |
553 iCSDownlink->SetVolume(volume); |
629 iCSDownlink->SetVolume(volume); |
554 status = TMS_RESULT_SUCCESS; |
630 status = TMS_RESULT_SUCCESS; |
563 // ----------------------------------------------------------------------------- |
639 // ----------------------------------------------------------------------------- |
564 // |
640 // |
565 gint TMSCallCSAdpt::GetGlobalVolume(guint& volume) |
641 gint TMSCallCSAdpt::GetGlobalVolume(guint& volume) |
566 { |
642 { |
567 TRACE_PRN_FN_ENT; |
643 TRACE_PRN_FN_ENT; |
568 gint status(TMS_RESULT_ILLEGAL_OPERATION); |
644 gint status(TMS_RESULT_INVALID_STATE); |
569 if (iCSDownlink && iDnlinkInitialized) |
645 if (iCSDownlink && iDnlinkInitialized) |
570 { |
646 { |
571 volume = iCSDownlink->Volume(); |
647 volume = iCSDownlink->Volume(); |
572 status = TMS_RESULT_SUCCESS; |
648 status = TMS_RESULT_SUCCESS; |
573 } |
649 } |
574 |
|
575 TRACE_PRN_FN_EXT; |
650 TRACE_PRN_FN_EXT; |
576 return status; |
651 return status; |
577 } |
652 } |
578 |
653 |
579 // ----------------------------------------------------------------------------- |
654 // ----------------------------------------------------------------------------- |
582 // ----------------------------------------------------------------------------- |
657 // ----------------------------------------------------------------------------- |
583 // |
658 // |
584 gint TMSCallCSAdpt::GetGlobalMaxGain(guint& gain) |
659 gint TMSCallCSAdpt::GetGlobalMaxGain(guint& gain) |
585 { |
660 { |
586 TRACE_PRN_FN_ENT; |
661 TRACE_PRN_FN_ENT; |
587 gint status(TMS_RESULT_ILLEGAL_OPERATION); |
662 gint status(TMS_RESULT_INVALID_STATE); |
588 if (iCSUplink && iUplinkInitialized) |
663 if (iCSUplink && iUplinkInitialized) |
589 { |
664 { |
590 gain = iCSUplink->MaxGain(); |
665 gain = iCSUplink->MaxGain(); |
591 status = TMS_RESULT_SUCCESS; |
666 status = TMS_RESULT_SUCCESS; |
667 TRACE_PRN_N1(_L("TMS->TMSCallCSAdpt::GetGlobalMaxGain [%d]"), gain); |
|
592 } |
668 } |
593 TRACE_PRN_FN_EXT; |
669 TRACE_PRN_FN_EXT; |
594 return status; |
670 return status; |
595 } |
671 } |
596 |
672 |
600 // ----------------------------------------------------------------------------- |
676 // ----------------------------------------------------------------------------- |
601 // |
677 // |
602 gint TMSCallCSAdpt::SetGlobalGain(const guint gain) |
678 gint TMSCallCSAdpt::SetGlobalGain(const guint gain) |
603 { |
679 { |
604 TRACE_PRN_FN_ENT; |
680 TRACE_PRN_FN_ENT; |
605 gint status(TMS_RESULT_SUCCESS); |
681 gint status(TMS_RESULT_INVALID_STATE); |
606 |
|
607 iGlobalGain = gain; |
682 iGlobalGain = gain; |
608 if (iCSUplink && iUplinkInitialized) |
683 if (iCSUplink && iUplinkInitialized) |
609 { |
684 { |
610 iCSUplink->SetGain(gain); |
685 iCSUplink->SetGain(gain); |
611 status = TMS_RESULT_SUCCESS; |
686 status = TMS_RESULT_SUCCESS; |
620 // ----------------------------------------------------------------------------- |
695 // ----------------------------------------------------------------------------- |
621 // |
696 // |
622 gint TMSCallCSAdpt::GetGlobalGain(guint& gain) |
697 gint TMSCallCSAdpt::GetGlobalGain(guint& gain) |
623 { |
698 { |
624 TRACE_PRN_FN_ENT; |
699 TRACE_PRN_FN_ENT; |
625 gint status(TMS_RESULT_ILLEGAL_OPERATION); |
700 gint status(TMS_RESULT_INVALID_STATE); |
626 if (iCSUplink && iUplinkInitialized) |
701 if (iCSUplink && iUplinkInitialized) |
627 { |
702 { |
628 gain = iCSUplink->Gain(); |
703 gain = iCSUplink->Gain(); |
629 status = TMS_RESULT_SUCCESS; |
704 status = TMS_RESULT_SUCCESS; |
630 } |
705 } |
632 return status; |
707 return status; |
633 } |
708 } |
634 |
709 |
635 // ----------------------------------------------------------------------------- |
710 // ----------------------------------------------------------------------------- |
636 // TMSCallCSAdpt::GetCodecMode |
711 // TMSCallCSAdpt::GetCodecMode |
637 // |
712 // No codec format in CS call |
638 // ----------------------------------------------------------------------------- |
713 // ----------------------------------------------------------------------------- |
639 // |
714 // |
640 gint TMSCallCSAdpt::GetCodecMode(const TMSFormatType /*fmttype*/, |
715 gint TMSCallCSAdpt::GetCodecMode(const TMSFormatType /*fmttype*/, |
641 const TMSStreamType /*strmtype*/, gint& /*mode*/) |
716 const TMSStreamType /*strmtype*/, gint& /*mode*/) |
642 { |
717 { |
646 return status; |
721 return status; |
647 } |
722 } |
648 |
723 |
649 // ----------------------------------------------------------------------------- |
724 // ----------------------------------------------------------------------------- |
650 // TMSCallCSAdpt::SetCodecMode |
725 // TMSCallCSAdpt::SetCodecMode |
651 // |
726 // No codec format in CS call |
652 // ----------------------------------------------------------------------------- |
727 // ----------------------------------------------------------------------------- |
653 // |
728 // |
654 gint TMSCallCSAdpt::SetCodecMode(const TMSFormatType /*fmttype*/, |
729 gint TMSCallCSAdpt::SetCodecMode(const TMSFormatType /*fmttype*/, |
655 const TMSStreamType /*strmtype*/, const gint /*mode*/) |
730 const TMSStreamType /*strmtype*/, const gint /*mode*/) |
656 { |
731 { |
660 return status; |
735 return status; |
661 } |
736 } |
662 |
737 |
663 // ----------------------------------------------------------------------------- |
738 // ----------------------------------------------------------------------------- |
664 // TMSCallCSAdpt::GetSupportedBitRatesCount |
739 // TMSCallCSAdpt::GetSupportedBitRatesCount |
665 // |
740 // No codec format in CS call |
666 // ----------------------------------------------------------------------------- |
741 // ----------------------------------------------------------------------------- |
667 // |
742 // |
668 gint TMSCallCSAdpt::GetSupportedBitRatesCount(guint& /*count*/) |
743 gint TMSCallCSAdpt::GetSupportedBitRatesCount(guint& /*count*/) |
669 { |
744 { |
670 TRACE_PRN_FN_ENT; |
745 TRACE_PRN_FN_ENT; |
676 // ----------------------------------------------------------------------------- |
751 // ----------------------------------------------------------------------------- |
677 // TMSCallCSAdpt::GetSupportedBitRates |
752 // TMSCallCSAdpt::GetSupportedBitRates |
678 // |
753 // |
679 // ----------------------------------------------------------------------------- |
754 // ----------------------------------------------------------------------------- |
680 // |
755 // |
681 gint TMSCallCSAdpt::GetSupportedBitRates(CBufFlat*& brbuffer) |
756 gint TMSCallCSAdpt::GetSupportedBitRates(CBufFlat*& /*brbuffer*/) |
682 { |
757 { |
683 TRACE_PRN_FN_ENT; |
758 TRACE_PRN_FN_ENT; |
684 TRAPD(status, GetSupportedBitRatesL(brbuffer)); |
759 gint status(TMS_RESULT_FEATURE_NOT_SUPPORTED); |
685 TRACE_PRN_FN_EXT; |
760 TRACE_PRN_FN_EXT; |
686 return status; |
761 return status; |
687 } |
|
688 |
|
689 // ----------------------------------------------------------------------------- |
|
690 // TMSCallCSAdpt::GetSupportedBitRatesL |
|
691 // |
|
692 // GetSupportedBitRates implementation which can leave. |
|
693 // ----------------------------------------------------------------------------- |
|
694 // |
|
695 void TMSCallCSAdpt::GetSupportedBitRatesL(CBufFlat*& /*brbuffer*/) |
|
696 { |
|
697 User::Leave(TMS_RESULT_FEATURE_NOT_SUPPORTED); |
|
698 } |
762 } |
699 |
763 |
700 // ----------------------------------------------------------------------------- |
764 // ----------------------------------------------------------------------------- |
701 // TMSCallCSAdpt::GetBitRate |
765 // TMSCallCSAdpt::GetBitRate |
702 // |
766 // |
739 // ----------------------------------------------------------------------------- |
803 // ----------------------------------------------------------------------------- |
740 // TMSCallCSAdpt::SetVAD |
804 // TMSCallCSAdpt::SetVAD |
741 // |
805 // |
742 // ----------------------------------------------------------------------------- |
806 // ----------------------------------------------------------------------------- |
743 // |
807 // |
744 gint TMSCallCSAdpt::SetVAD(const TMSFormatType /*fmttype*/, const gboolean /*vad*/) |
808 gint TMSCallCSAdpt::SetVAD(const TMSFormatType /*fmttype*/, |
809 const gboolean /*vad*/) |
|
745 { |
810 { |
746 TRACE_PRN_FN_ENT; |
811 TRACE_PRN_FN_ENT; |
747 gint status(TMS_RESULT_FEATURE_NOT_SUPPORTED); |
812 gint status(TMS_RESULT_FEATURE_NOT_SUPPORTED); |
748 TRACE_PRN_FN_EXT; |
813 TRACE_PRN_FN_EXT; |
749 return status; |
814 return status; |
806 // ----------------------------------------------------------------------------- |
871 // ----------------------------------------------------------------------------- |
807 // TMSCallCSAdpt::SetOutput |
872 // TMSCallCSAdpt::SetOutput |
808 // |
873 // |
809 // ----------------------------------------------------------------------------- |
874 // ----------------------------------------------------------------------------- |
810 // |
875 // |
811 gint TMSCallCSAdpt::SetOutput(TMSAudioOutput output) |
876 gint TMSCallCSAdpt::SetOutput(const TMSAudioOutput output) |
812 { |
877 { |
813 TRACE_PRN_FN_ENT; |
878 TRACE_PRN_FN_ENT; |
814 gint status(TMS_RESULT_UNINITIALIZED_OBJECT); |
879 gint status(TMS_RESULT_UNINITIALIZED_OBJECT); |
815 |
880 |
816 if (iRouting) |
881 if (iRouting) |
877 // ----------------------------------------------------------------------------- |
942 // ----------------------------------------------------------------------------- |
878 // TMSCallCSAdpt::GetAvailableOutputsL |
943 // TMSCallCSAdpt::GetAvailableOutputsL |
879 // |
944 // |
880 // ----------------------------------------------------------------------------- |
945 // ----------------------------------------------------------------------------- |
881 // |
946 // |
882 gint TMSCallCSAdpt::GetAvailableOutputsL(gint& count, CBufFlat*& outputsbuffer) |
947 gint TMSCallCSAdpt::GetAvailableOutputsL(gint& count, CBufFlat*& outputsbuf) |
883 { |
948 { |
884 TRACE_PRN_FN_ENT; |
949 TRACE_PRN_FN_ENT; |
885 gint status(TMS_RESULT_UNINITIALIZED_OBJECT); |
950 gint status(TMS_RESULT_UNINITIALIZED_OBJECT); |
886 TMSAudioOutput tmsoutput; |
951 TMSAudioOutput tmsoutput; |
887 |
952 |
888 if (iRouting) |
953 if (iRouting) |
889 { |
954 { |
890 RBufWriteStream stream; |
955 RBufWriteStream stream; |
891 stream.Open(*outputsbuffer); |
956 stream.Open(*outputsbuf); |
892 CleanupClosePushL(stream); |
957 CleanupClosePushL(stream); |
893 |
958 |
894 TArray<CTelephonyAudioRouting::TAudioOutput> availableOutputs = |
959 TArray<CTelephonyAudioRouting::TAudioOutput> |
895 iRouting->AvailableOutputs(); |
960 availableOutputs = iRouting->AvailableOutputs(); |
896 |
961 |
897 guint numOfItems = availableOutputs.Count(); |
962 guint numOfItems = availableOutputs.Count(); |
898 count = numOfItems; |
963 count = numOfItems; |
899 for (guint i = 0; i < numOfItems; i++) |
964 for (guint i = 0; i < numOfItems; i++) |
900 { |
965 { |
913 |
978 |
914 // From TMSCSPDevSoundObserver |
979 // From TMSCSPDevSoundObserver |
915 |
980 |
916 // ----------------------------------------------------------------------------- |
981 // ----------------------------------------------------------------------------- |
917 // TMSCallCSAdpt::DownlinkInitCompleted |
982 // TMSCallCSAdpt::DownlinkInitCompleted |
918 // |
983 // From TMSCSDevSoundObserver |
919 // ----------------------------------------------------------------------------- |
984 // ----------------------------------------------------------------------------- |
920 // |
985 // |
921 void TMSCallCSAdpt::DownlinkInitCompleted(gint status) |
986 void TMSCallCSAdpt::DownlinkInitCompleted(gint status) |
922 { |
987 { |
923 TRACE_PRN_FN_ENT; |
988 TRACE_PRN_FN_ENT; |
924 NotifyClient(iDnlinkStreamId, ECmdDownlinkInitComplete, status, 0); |
989 if (status == TMS_RESULT_SUCCESS) |
990 { |
|
991 iDnlinkInitialized = TRUE; |
|
992 } |
|
993 NotifyClient(iDnlinkStreamId, ECmdDownlinkInitComplete, status); |
|
925 TRACE_PRN_FN_EXT; |
994 TRACE_PRN_FN_EXT; |
926 } |
995 } |
927 |
996 |
928 // ----------------------------------------------------------------------------- |
997 // ----------------------------------------------------------------------------- |
929 // TMSCallCSAdpt::UplinkInitCompleted |
998 // TMSCallCSAdpt::UplinkInitCompleted |
930 // |
999 // From TMSCSDevSoundObserver |
931 // ----------------------------------------------------------------------------- |
1000 // ----------------------------------------------------------------------------- |
932 // |
1001 // |
933 void TMSCallCSAdpt::UplinkInitCompleted(gint status) |
1002 void TMSCallCSAdpt::UplinkInitCompleted(gint status) |
934 { |
1003 { |
935 TRACE_PRN_FN_ENT; |
1004 TRACE_PRN_FN_ENT; |
936 NotifyClient(iUplinkStreamId, ECmdUplinkInitComplete, status, 0); |
1005 if (status == TMS_RESULT_SUCCESS) |
937 TRACE_PRN_FN_EXT; |
1006 { |
938 } |
1007 iUplinkInitialized = TRUE; |
939 |
1008 } |
940 // ----------------------------------------------------------------------------- |
1009 NotifyClient(iUplinkStreamId, ECmdUplinkInitComplete, status); |
941 // TMSCallCSAdpt::UplinkActivatedSuccessfully |
|
942 // |
|
943 // ----------------------------------------------------------------------------- |
|
944 // |
|
945 void TMSCallCSAdpt::UplinkActivatedSuccessfully() |
|
946 { |
|
947 TRACE_PRN_FN_ENT; |
|
948 NotifyClient(iUplinkStreamId, ECmdUplinkStarted, KErrNone, 0); |
|
949 TRACE_PRN_FN_EXT; |
|
950 } |
|
951 |
|
952 // ----------------------------------------------------------------------------- |
|
953 // TMSCallCSAdpt::DownlinkActivatedSuccessfully |
|
954 // |
|
955 // ----------------------------------------------------------------------------- |
|
956 // |
|
957 void TMSCallCSAdpt::DownlinkActivatedSuccessfully() |
|
958 { |
|
959 TRACE_PRN_FN_ENT; |
|
960 NotifyClient(iDnlinkStreamId, ECmdDownlinkStarted, KErrNone, 0); |
|
961 TRACE_PRN_FN_EXT; |
1010 TRACE_PRN_FN_EXT; |
962 } |
1011 } |
963 |
1012 |
964 // ----------------------------------------------------------------------------- |
1013 // ----------------------------------------------------------------------------- |
965 // TMSCallCSAdpt::UplinkActivationFailed |
1014 // TMSCallCSAdpt::UplinkActivationFailed |
966 // |
1015 // From TMSCSDevSoundObserver |
967 // ----------------------------------------------------------------------------- |
1016 // ----------------------------------------------------------------------------- |
968 // |
1017 // |
969 void TMSCallCSAdpt::UplinkActivationFailed() |
1018 void TMSCallCSAdpt::UplinkActivationCompleted(gint status) |
970 { |
1019 { |
971 TRACE_PRN_FN_ENT; |
1020 TRACE_PRN_FN_ENT; |
972 NotifyClient(iUplinkStreamId, ECmdUplinkStarted, TMS_RESULT_FATAL_ERROR, 0); |
1021 NotifyClient(iUplinkStreamId, ECmdUplinkStarted, status); |
973 TRACE_PRN_FN_EXT; |
1022 TRACE_PRN_FN_EXT; |
974 } |
1023 } |
975 |
1024 |
976 // ----------------------------------------------------------------------------- |
1025 // ----------------------------------------------------------------------------- |
977 // TMSCallCSAdpt::DownlinkActivationFailed |
1026 // TMSCallCSAdpt::DownlinkActivationFailed |
978 // |
1027 // From TMSCSDevSoundObserver |
979 // ----------------------------------------------------------------------------- |
1028 // ----------------------------------------------------------------------------- |
980 // |
1029 // |
981 void TMSCallCSAdpt::DownlinkActivationFailed() |
1030 void TMSCallCSAdpt::DownlinkActivationCompleted(gint status) |
982 { |
1031 { |
983 TRACE_PRN_FN_ENT; |
1032 TRACE_PRN_FN_ENT; |
984 NotifyClient(iDnlinkStreamId, ECmdDownlinkStarted, |
1033 NotifyClient(iDnlinkStreamId, ECmdDownlinkStarted, status); |
985 TMS_RESULT_FATAL_ERROR, 0); |
|
986 TRACE_PRN_FN_EXT; |
1034 TRACE_PRN_FN_EXT; |
987 } |
1035 } |
988 |
1036 |
989 // ----------------------------------------------------------------------------- |
1037 // ----------------------------------------------------------------------------- |
990 // TMSCallCSAdpt::AvailableOutputsChanged |
1038 // TMSCallCSAdpt::AvailableOutputsChanged |
1021 // TMSCallCSAdpt::SetOutputComplete |
1069 // TMSCallCSAdpt::SetOutputComplete |
1022 // |
1070 // |
1023 // ----------------------------------------------------------------------------- |
1071 // ----------------------------------------------------------------------------- |
1024 // |
1072 // |
1025 void TMSCallCSAdpt::SetOutputComplete( |
1073 void TMSCallCSAdpt::SetOutputComplete( |
1026 CTelephonyAudioRouting& aTelephonyAudioRouting, gint /*aError*/) |
1074 CTelephonyAudioRouting& aTelephonyAudioRouting, gint /*status*/) |
1027 { |
1075 { |
1028 TRACE_PRN_FN_ENT; |
1076 TRACE_PRN_FN_ENT; |
1029 TRoutingMsgBufPckg pckg; |
1077 TRoutingMsgBufPckg pckg; |
1030 pckg().iEvent = TMS_EVENT_ROUTING_SET_OUTPUT_COMPLETE; |
1078 pckg().iEvent = TMS_EVENT_ROUTING_SET_OUTPUT_COMPLETE; |
1031 pckg().iOutput = TOTMSOUTPUT(aTelephonyAudioRouting.Output()); |
1079 pckg().iOutput = TOTMSOUTPUT(aTelephonyAudioRouting.Output()); |