31 #include "tmsdtmfnotifier.h" |
31 #include "tmsdtmfnotifier.h" |
32 |
32 |
33 using namespace TMS; |
33 using namespace TMS; |
34 |
34 |
35 // ----------------------------------------------------------------------------- |
35 // ----------------------------------------------------------------------------- |
36 // TMSCallCSAdpt::TMSCallCSAdpt |
36 // TMSCallCSAdpt::NewL |
37 // |
37 // Symbian constructor. |
38 // ----------------------------------------------------------------------------- |
38 // ----------------------------------------------------------------------------- |
39 // |
39 // |
40 TMSCallCSAdpt::TMSCallCSAdpt() |
40 TMSCallCSAdpt* TMSCallCSAdpt::NewL() |
41 { |
41 { |
42 TRACE_PRN_FN_ENT; |
42 TMSCallCSAdpt* self = new (ELeave) TMSCallCSAdpt(); |
43 |
43 CleanupStack::PushL(self); |
|
44 self->ConstructL(); |
|
45 CleanupStack::Pop(self); |
|
46 return self; |
|
47 } |
|
48 |
|
49 // ----------------------------------------------------------------------------- |
|
50 // TMSCallCSAdpt::ConstructL |
|
51 // 2-nd phase constructor. |
|
52 // ----------------------------------------------------------------------------- |
|
53 // |
|
54 void TMSCallCSAdpt::ConstructL() |
|
55 { |
|
56 TRACE_PRN_FN_ENT; |
44 iCSDownlink = NULL; |
57 iCSDownlink = NULL; |
45 iCSUplink = NULL; |
58 iCSUplink = NULL; |
46 iRouting = NULL; |
59 iRouting = NULL; |
47 iTarSettings = NULL; |
60 iTarSettings = NULL; |
48 iDTMFDnlinkPlayer = NULL; |
61 iDTMFDnlinkPlayer = NULL; |
49 iDTMFUplinkPlayer = NULL; |
62 iDTMFUplinkPlayer = NULL; |
50 iDTMFNotifier = NULL; |
63 iDTMFNotifier = NULL; |
51 |
64 TRACE_PRN_FN_EXT; |
52 TRACE_PRN_FN_EXT; |
65 } |
|
66 |
|
67 // ----------------------------------------------------------------------------- |
|
68 // TMSCallCSAdpt::TMSCallCSAdpt |
|
69 // |
|
70 // ----------------------------------------------------------------------------- |
|
71 // |
|
72 TMSCallCSAdpt::TMSCallCSAdpt() |
|
73 { |
53 } |
74 } |
54 |
75 |
55 // ----------------------------------------------------------------------------- |
76 // ----------------------------------------------------------------------------- |
56 // TMSCallCSAdpt::~TMSCallCSAdpt |
77 // TMSCallCSAdpt::~TMSCallCSAdpt |
57 // |
78 // |
58 // ----------------------------------------------------------------------------- |
79 // ----------------------------------------------------------------------------- |
59 // |
80 // |
60 TMSCallCSAdpt::~TMSCallCSAdpt() |
81 TMSCallCSAdpt::~TMSCallCSAdpt() |
61 { |
82 { |
62 TRACE_PRN_FN_ENT; |
83 TRACE_PRN_FN_ENT; |
63 delete iCSDownlink; |
84 |
64 delete iCSUplink; |
|
65 delete iRouting; |
85 delete iRouting; |
66 delete iTarSettings; |
86 delete iTarSettings; |
|
87 delete iDTMFUplinkPlayer; |
67 delete iDTMFDnlinkPlayer; |
88 delete iDTMFDnlinkPlayer; |
68 delete iDTMFUplinkPlayer; |
|
69 delete iDTMFNotifier; |
89 delete iDTMFNotifier; |
|
90 delete iCSUplink; |
|
91 delete iCSDownlink; |
70 |
92 |
71 if (iMsgQueueUp.Handle() > 0) |
93 if (iMsgQueueUp.Handle() > 0) |
72 { |
94 { |
73 iMsgQueueUp.Close(); |
95 iMsgQueueUp.Close(); |
74 } |
96 } |
75 |
|
76 if (iMsgQueueDn.Handle() > 0) |
97 if (iMsgQueueDn.Handle() > 0) |
77 { |
98 { |
78 iMsgQueueDn.Close(); |
99 iMsgQueueDn.Close(); |
79 } |
100 } |
80 |
101 |
91 TRACE_PRN_FN_ENT; |
112 TRACE_PRN_FN_ENT; |
92 gint status(TMS_RESULT_SUCCESS); |
113 gint status(TMS_RESULT_SUCCESS); |
93 iNextStreamId = 1; |
114 iNextStreamId = 1; |
94 iUplinkInitialized = FALSE; |
115 iUplinkInitialized = FALSE; |
95 iDnlinkInitialized = FALSE; |
116 iDnlinkInitialized = FALSE; |
96 |
|
97 TRACE_PRN_FN_EXT; |
117 TRACE_PRN_FN_EXT; |
98 return status; |
118 return status; |
99 } |
119 } |
100 |
120 |
101 // ----------------------------------------------------------------------------- |
121 // ----------------------------------------------------------------------------- |
102 // TMSCallCSAdpt::CreateStream |
122 // TMSCallCSAdpt::CreateStream |
103 // |
123 // |
104 // ----------------------------------------------------------------------------- |
124 // ----------------------------------------------------------------------------- |
105 // |
125 // |
106 gint TMSCallCSAdpt::CreateStream(TMSCallType /*callType*/, |
126 gint TMSCallCSAdpt::CreateStream(const TMSCallType /*callType*/, |
107 TMSStreamType strmType, gint& outStrmId) |
127 const TMSStreamType strmType, gint& outStrmId) |
108 { |
128 { |
109 TRACE_PRN_FN_ENT; |
129 TRACE_PRN_FN_ENT; |
110 gint status(TMS_RESULT_SUCCESS); |
130 gint status(TMS_RESULT_SUCCESS); |
111 switch (strmType) |
131 switch (strmType) |
112 { |
132 { |
113 case TMS_STREAM_UPLINK: |
133 case TMS_STREAM_UPLINK: |
|
134 { |
114 status = TMS_RESULT_ALREADY_EXIST; |
135 status = TMS_RESULT_ALREADY_EXIST; |
115 if (!iUplinkInitialized) |
136 if (!iUplinkInitialized) |
116 { |
137 { |
117 iUplinkInitialized = TRUE; |
|
118 iUplinkStreamId = iNextStreamId; |
138 iUplinkStreamId = iNextStreamId; |
119 outStrmId = iUplinkStreamId; |
139 outStrmId = iUplinkStreamId; |
120 iNextStreamId++; |
140 iNextStreamId++; |
121 iUplinkInitialized = TRUE; |
141 //iUplinkInitialized = TRUE; //not initialized yet! |
122 status = TMS_RESULT_SUCCESS; |
142 status = TMS_RESULT_SUCCESS; |
123 } |
143 } |
124 break; |
144 break; |
|
145 } |
125 case TMS_STREAM_DOWNLINK: |
146 case TMS_STREAM_DOWNLINK: |
|
147 { |
126 status = TMS_RESULT_ALREADY_EXIST; |
148 status = TMS_RESULT_ALREADY_EXIST; |
127 if (!iDnlinkInitialized) |
149 if (!iDnlinkInitialized) |
128 { |
150 { |
129 iDnlinkInitialized = TRUE; |
|
130 iDnlinkStreamId = iNextStreamId; |
151 iDnlinkStreamId = iNextStreamId; |
131 outStrmId = iDnlinkStreamId; |
152 outStrmId = iDnlinkStreamId; |
132 iNextStreamId++; |
153 iNextStreamId++; |
133 iDnlinkInitialized = TRUE; |
154 //iDnlinkInitialized = TRUE; //not initialized yet! |
134 status = TMS_RESULT_SUCCESS; |
155 status = TMS_RESULT_SUCCESS; |
135 } |
156 } |
136 break; |
157 break; |
|
158 } |
137 default: |
159 default: |
|
160 { |
138 status = TMS_RESULT_STREAM_TYPE_NOT_SUPPORTED; |
161 status = TMS_RESULT_STREAM_TYPE_NOT_SUPPORTED; |
139 break; |
162 break; |
|
163 } |
140 } |
164 } |
141 TRACE_PRN_FN_EXT; |
165 TRACE_PRN_FN_EXT; |
142 return status; |
166 return status; |
143 } |
167 } |
144 |
168 |
145 // ----------------------------------------------------------------------------- |
169 // ----------------------------------------------------------------------------- |
146 // TMSCallCSAdpt::InitStream |
170 // TMSCallCSAdpt::InitStream |
147 // |
171 // |
148 // ----------------------------------------------------------------------------- |
172 // ----------------------------------------------------------------------------- |
149 // |
173 // |
150 gint TMSCallCSAdpt::InitStream(TMSCallType /*callType*/, TMSStreamType strmType, |
174 gint TMSCallCSAdpt::InitStream(const TMSCallType /*callType*/, |
151 gint strmId, TMSFormatType /*frmtType*/, const RMessage2& message) |
175 const TMSStreamType strmType, const gint strmId, |
|
176 const TMSFormatType /*frmtType*/, const gint retrytime, |
|
177 const RMessage2& message) |
152 { |
178 { |
153 TRACE_PRN_FN_ENT; |
179 TRACE_PRN_FN_ENT; |
154 gint status(TMS_RESULT_SUCCESS); |
180 gint status(TMS_RESULT_SUCCESS); |
155 |
181 |
156 switch (strmType) |
182 switch (strmType) |
157 { |
183 { |
158 case TMS_STREAM_UPLINK: |
184 case TMS_STREAM_UPLINK: |
159 { |
185 { |
|
186 status = TMS_RESULT_DOES_NOT_EXIST; |
160 if (strmId == iUplinkStreamId) |
187 if (strmId == iUplinkStreamId) |
161 { |
188 { |
162 // Open message queue handling client-server communication |
189 // Open message queue handling client-server communication |
163 if (iMsgQueueUp.Handle() <= 0) |
190 if (iMsgQueueUp.Handle() <= 0) |
164 { |
191 { |
165 // Third argument in TMSCallProxy::InitStream |
192 // Third argument in TMSCallProxy::InitStream |
166 status = iMsgQueueUp.Open(message, 1); |
193 status = iMsgQueueUp.Open(message, 1); |
167 } |
194 } |
168 if (status == TMS_RESULT_SUCCESS) |
195 if (status == TMS_RESULT_SUCCESS) |
169 { |
196 { |
170 TRAP(status, iCSUplink = TMSCSUplink::NewL(*this)); |
197 status = InitUplink(retrytime); |
171 |
|
172 if (status == TMS_RESULT_SUCCESS) |
|
173 { |
|
174 TRAP(status, iDTMFUplinkPlayer = |
|
175 TMSDTMFProvider::NewL()); |
|
176 iDTMFUplinkPlayer->AddObserver(*this); |
|
177 if (!iDTMFNotifier) |
|
178 { |
|
179 TRAP(status, iDTMFNotifier = |
|
180 TMSDtmfNotifier::NewL()); |
|
181 } |
|
182 } |
|
183 } |
198 } |
184 iStrmtype = TMS_STREAM_UPLINK; |
|
185 } |
199 } |
186 else |
|
187 { |
|
188 status = TMS_RESULT_DOES_NOT_EXIST; |
|
189 } |
|
190 break; |
200 break; |
191 } |
201 } |
192 case TMS_STREAM_DOWNLINK: |
202 case TMS_STREAM_DOWNLINK: |
193 { |
203 { |
|
204 status = TMS_RESULT_DOES_NOT_EXIST; |
194 if (strmId == iDnlinkStreamId) |
205 if (strmId == iDnlinkStreamId) |
195 { |
206 { |
196 // Open message queue handling client-server communication |
207 // Open message queue handling client-server communication |
197 if (iMsgQueueDn.Handle() <= 0) |
208 if (iMsgQueueDn.Handle() <= 0) |
198 { |
209 { |
199 // Third argument in TMSCallProxy::InitStream |
210 // Third argument in TMSCallProxy::InitStream |
200 status = iMsgQueueDn.Open(message, 1); |
211 status = iMsgQueueDn.Open(message, 1); |
201 } |
212 } |
202 if (status == TMS_RESULT_SUCCESS) |
213 if (status == TMS_RESULT_SUCCESS) |
203 { |
214 { |
204 TRAP(status, iCSDownlink = TMSCSDownlink::NewL(*this)); |
215 status = InitDownlink(retrytime); |
205 if (status == TMS_RESULT_SUCCESS) |
|
206 { |
|
207 TRAP(status, iRouting = |
|
208 CTelephonyAudioRouting::NewL(*this)); |
|
209 if (status == TMS_RESULT_SUCCESS) |
|
210 { |
|
211 TRAP(status, iTarSettings = TMSTarSettings::NewL()); |
|
212 } |
|
213 if (status == TMS_RESULT_SUCCESS) |
|
214 { |
|
215 TRAP(status, iDTMFDnlinkPlayer = |
|
216 TMSAudioDtmfTonePlayer::NewL(*this, |
|
217 KAudioDTMFString, |
|
218 KAudioPriorityDTMFString)); |
|
219 |
|
220 if (!iDTMFNotifier) |
|
221 { |
|
222 TRAP(status, iDTMFNotifier = |
|
223 TMSDtmfNotifier::NewL()); |
|
224 } |
|
225 } |
|
226 } |
|
227 } |
216 } |
228 iStrmtype = TMS_STREAM_DOWNLINK; |
|
229 } |
217 } |
230 else |
|
231 { |
|
232 status = TMS_RESULT_DOES_NOT_EXIST; |
|
233 } |
|
234 break; |
218 break; |
235 } |
219 } |
236 default: |
220 default: |
237 { |
221 { |
238 status = TMS_RESULT_STREAM_TYPE_NOT_SUPPORTED; |
222 status = TMS_RESULT_STREAM_TYPE_NOT_SUPPORTED; |
244 TRACE_PRN_FN_EXT; |
228 TRACE_PRN_FN_EXT; |
245 return status; |
229 return status; |
246 } |
230 } |
247 |
231 |
248 // ----------------------------------------------------------------------------- |
232 // ----------------------------------------------------------------------------- |
|
233 // TMSCallCSAdpt::InitUplink |
|
234 // |
|
235 // ----------------------------------------------------------------------------- |
|
236 // |
|
237 gint TMSCallCSAdpt::InitUplink(const gint retrytime) |
|
238 { |
|
239 gint status(TMS_RESULT_SUCCESS); |
|
240 |
|
241 if (!iCSUplink) |
|
242 { |
|
243 TRAP(status, iCSUplink = TMSCSUplink::NewL(*this, retrytime)); |
|
244 } |
|
245 if (!iDTMFUplinkPlayer && status == TMS_RESULT_SUCCESS) |
|
246 { |
|
247 TRAP(status, iDTMFUplinkPlayer = TMSDTMFProvider::NewL()); |
|
248 iDTMFUplinkPlayer->AddObserver(*this); |
|
249 } |
|
250 if (!iDTMFNotifier && status == TMS_RESULT_SUCCESS) |
|
251 { |
|
252 TRAP(status, iDTMFNotifier = TMSDtmfNotifier::NewL()); |
|
253 } |
|
254 return status; |
|
255 } |
|
256 |
|
257 // ----------------------------------------------------------------------------- |
|
258 // TMSCallCSAdpt::InitDownlink |
|
259 // |
|
260 // ----------------------------------------------------------------------------- |
|
261 // |
|
262 gint TMSCallCSAdpt::InitDownlink(const gint retrytime) |
|
263 { |
|
264 gint status(TMS_RESULT_SUCCESS); |
|
265 |
|
266 if (!iCSDownlink) |
|
267 { |
|
268 TRAP(status, iCSDownlink = TMSCSDownlink::NewL(*this, retrytime)); |
|
269 } |
|
270 if (!iRouting && status == TMS_RESULT_SUCCESS) |
|
271 { |
|
272 TRAP(status, iRouting = CTelephonyAudioRouting::NewL(*this)); |
|
273 } |
|
274 if (!iTarSettings && status == TMS_RESULT_SUCCESS) |
|
275 { |
|
276 TRAP(status, iTarSettings = TMSTarSettings::NewL()); |
|
277 } |
|
278 if (!iDTMFDnlinkPlayer && status == TMS_RESULT_SUCCESS) |
|
279 { |
|
280 TRAP(status, iDTMFDnlinkPlayer = TMSAudioDtmfTonePlayer::NewL(*this, |
|
281 KAudioDTMFString, KAudioPriorityDTMFString)); |
|
282 } |
|
283 if (!iDTMFNotifier && status == TMS_RESULT_SUCCESS) |
|
284 { |
|
285 TRAP(status, iDTMFNotifier = TMSDtmfNotifier::NewL()); |
|
286 } |
|
287 return status; |
|
288 } |
|
289 |
|
290 // ----------------------------------------------------------------------------- |
249 // TMSCallCSAdpt::StartStream |
291 // TMSCallCSAdpt::StartStream |
250 // |
292 // |
251 // ----------------------------------------------------------------------------- |
293 // ----------------------------------------------------------------------------- |
252 // |
294 // |
253 gint TMSCallCSAdpt::StartStream(TMSCallType /*callType*/, |
295 gint TMSCallCSAdpt::StartStream(const TMSCallType /*callType*/, |
254 TMSStreamType strmType, gint strmId) |
296 const TMSStreamType strmType, const gint strmId, const gint retrytime) |
255 { |
297 { |
256 TRACE_PRN_FN_ENT; |
298 TRACE_PRN_FN_ENT; |
257 gint status(TMS_RESULT_SUCCESS); |
299 gint status(TMS_RESULT_INVALID_STATE); |
258 switch (strmType) |
300 switch (strmType) |
259 { |
301 { |
260 case TMS_STREAM_UPLINK: |
302 case TMS_STREAM_UPLINK: |
|
303 { |
261 if (iCSUplink && strmId == iUplinkStreamId) |
304 if (iCSUplink && strmId == iUplinkStreamId) |
262 { |
305 { |
263 iCSUplink->Activate(); |
306 iCSUplink->Activate(retrytime); |
|
307 status = TMS_RESULT_SUCCESS; |
264 } |
308 } |
265 break; |
309 break; |
|
310 } |
266 case TMS_STREAM_DOWNLINK: |
311 case TMS_STREAM_DOWNLINK: |
|
312 { |
267 if (iCSDownlink && strmId == iDnlinkStreamId) |
313 if (iCSDownlink && strmId == iDnlinkStreamId) |
268 { |
314 { |
269 iCSDownlink->Activate(); |
315 iCSDownlink->Activate(retrytime); |
|
316 status = TMS_RESULT_SUCCESS; |
270 } |
317 } |
271 break; |
318 break; |
|
319 } |
272 default: |
320 default: |
|
321 { |
273 status = TMS_RESULT_STREAM_TYPE_NOT_SUPPORTED; |
322 status = TMS_RESULT_STREAM_TYPE_NOT_SUPPORTED; |
274 break; |
323 break; |
|
324 } |
275 } |
325 } |
276 TRACE_PRN_FN_EXT; |
326 TRACE_PRN_FN_EXT; |
277 return status; |
327 return status; |
278 } |
328 } |
279 |
329 |
280 // ----------------------------------------------------------------------------- |
330 // ----------------------------------------------------------------------------- |
281 // TMSCallCSAdpt::PauseStream |
331 // TMSCallCSAdpt::PauseStream |
282 // |
332 // |
283 // ----------------------------------------------------------------------------- |
333 // ----------------------------------------------------------------------------- |
284 // |
334 // |
285 gint TMSCallCSAdpt::PauseStream(TMSCallType /*callType*/, |
335 gint TMSCallCSAdpt::PauseStream(const TMSCallType /*callType*/, |
286 TMSStreamType /*strmType*/, gint /*strmId*/) |
336 const TMSStreamType /*strmType*/, const gint /*strmId*/) |
287 { |
337 { |
288 TRACE_PRN_FN_ENT; |
338 TRACE_PRN_FN_ENT; |
289 gint status(TMS_RESULT_SUCCESS); |
339 gint status(TMS_RESULT_FEATURE_NOT_SUPPORTED); |
290 TRACE_PRN_FN_EXT; |
340 TRACE_PRN_FN_EXT; |
291 return status; |
341 return status; |
292 } |
342 } |
293 |
343 |
294 // ----------------------------------------------------------------------------- |
344 // ----------------------------------------------------------------------------- |
295 // TMSCallCSAdpt::StopStream |
345 // TMSCallCSAdpt::StopStream |
296 // |
346 // |
297 // ----------------------------------------------------------------------------- |
347 // ----------------------------------------------------------------------------- |
298 // |
348 // |
299 gint TMSCallCSAdpt::StopStream(TMSCallType /*callType*/, TMSStreamType strmType, |
349 gint TMSCallCSAdpt::StopStream(const TMSCallType /*callType*/, |
300 gint strmId) |
350 const TMSStreamType strmType, const gint strmId) |
301 { |
351 { |
302 TRACE_PRN_FN_ENT; |
352 TRACE_PRN_FN_ENT; |
303 gint status(TMS_RESULT_SUCCESS); |
353 gint status(TMS_RESULT_INVALID_STATE); |
|
354 |
304 switch (strmType) |
355 switch (strmType) |
305 { |
356 { |
306 case TMS_STREAM_UPLINK: |
357 case TMS_STREAM_UPLINK: |
|
358 { |
307 if (iCSUplink && strmId == iUplinkStreamId) |
359 if (iCSUplink && strmId == iUplinkStreamId) |
308 { |
360 { |
309 iCSUplink->Deactivate(); |
361 iCSUplink->Deactivate(); |
310 NotifyClient(iUplinkStreamId, ECmdUplinkInitComplete, |
362 status = TMS_RESULT_SUCCESS; |
311 status, 0); |
363 NotifyClient(iUplinkStreamId, ECmdUplinkInitComplete, status); |
312 } |
364 } |
313 break; |
365 break; |
|
366 } |
314 case TMS_STREAM_DOWNLINK: |
367 case TMS_STREAM_DOWNLINK: |
|
368 { |
315 if (iCSDownlink && strmId == iDnlinkStreamId) |
369 if (iCSDownlink && strmId == iDnlinkStreamId) |
316 { |
370 { |
317 iCSDownlink->Deactivate(); |
371 iCSDownlink->Deactivate(); |
318 NotifyClient(iDnlinkStreamId, ECmdDownlinkInitComplete, |
372 status = TMS_RESULT_SUCCESS; |
319 status, 0); |
373 NotifyClient(iDnlinkStreamId, ECmdDownlinkInitComplete, status); |
320 } |
374 } |
321 break; |
375 break; |
|
376 } |
322 default: |
377 default: |
|
378 { |
323 status = TMS_RESULT_STREAM_TYPE_NOT_SUPPORTED; |
379 status = TMS_RESULT_STREAM_TYPE_NOT_SUPPORTED; |
324 break; |
380 break; |
|
381 } |
325 } |
382 } |
326 TRACE_PRN_FN_EXT; |
383 TRACE_PRN_FN_EXT; |
327 return status; |
384 return status; |
328 } |
385 } |
329 |
386 |
330 // ----------------------------------------------------------------------------- |
387 // ----------------------------------------------------------------------------- |
331 // TMSCallCSAdpt::DeinitStream |
388 // TMSCallCSAdpt::DeinitStream |
332 // |
389 // |
333 // ----------------------------------------------------------------------------- |
390 // ----------------------------------------------------------------------------- |
334 // |
391 // |
335 gint TMSCallCSAdpt::DeinitStream(TMSCallType /*callType*/, |
392 gint TMSCallCSAdpt::DeinitStream(const TMSCallType /*callType*/, |
336 TMSStreamType strmType, gint strmId) |
393 const TMSStreamType strmType, const gint strmId) |
337 { |
394 { |
338 TRACE_PRN_FN_ENT; |
395 TRACE_PRN_FN_ENT; |
339 gint status(TMS_RESULT_SUCCESS); |
396 gint status(TMS_RESULT_INVALID_STATE); |
|
397 |
340 switch (strmType) |
398 switch (strmType) |
341 { |
399 { |
342 case TMS_STREAM_UPLINK: |
400 case TMS_STREAM_UPLINK: |
|
401 { |
343 if (iCSUplink && strmId == iUplinkStreamId) |
402 if (iCSUplink && strmId == iUplinkStreamId) |
344 { |
403 { |
345 iCSUplink->Deactivate(); |
404 iCSUplink->Deactivate(); |
346 iUplinkInitialized = FALSE; |
405 iUplinkInitialized = FALSE; |
347 NotifyClient(iUplinkStreamId, ECmdUplinkDeInitComplete, |
406 status = TMS_RESULT_SUCCESS; |
348 status, 0); |
407 NotifyClient(iUplinkStreamId, ECmdUplinkDeInitComplete, status); |
349 } |
408 } |
350 break; |
409 break; |
351 case TMS_STREAM_DOWNLINK: |
410 case TMS_STREAM_DOWNLINK: |
352 if (iCSDownlink && strmId == iDnlinkStreamId) |
411 if (iCSDownlink && strmId == iDnlinkStreamId) |
353 { |
412 { |
354 iCSDownlink->Deactivate(); |
413 iCSDownlink->Deactivate(); |
355 iDnlinkInitialized = FALSE; |
414 iDnlinkInitialized = FALSE; |
|
415 status = TMS_RESULT_SUCCESS; |
356 NotifyClient(iDnlinkStreamId, ECmdDownlinkDeInitComplete, |
416 NotifyClient(iDnlinkStreamId, ECmdDownlinkDeInitComplete, |
357 status, 0); |
417 status); |
358 } |
418 } |
359 break; |
419 break; |
|
420 } |
360 default: |
421 default: |
|
422 { |
361 status = TMS_RESULT_STREAM_TYPE_NOT_SUPPORTED; |
423 status = TMS_RESULT_STREAM_TYPE_NOT_SUPPORTED; |
362 break; |
424 break; |
|
425 } |
363 } |
426 } |
364 TRACE_PRN_FN_EXT; |
427 TRACE_PRN_FN_EXT; |
365 return status; |
428 return status; |
366 } |
429 } |
367 |
430 |
368 // ----------------------------------------------------------------------------- |
431 // ----------------------------------------------------------------------------- |
369 // TMSCallCSAdpt::DeleteStream |
432 // TMSCallCSAdpt::DeleteStream |
370 // |
433 // |
371 // ----------------------------------------------------------------------------- |
434 // ----------------------------------------------------------------------------- |
372 // |
435 // |
373 gint TMSCallCSAdpt::DeleteStream(TMSCallType /*callType*/, |
436 gint TMSCallCSAdpt::DeleteStream(const TMSCallType /*callType*/, |
374 TMSStreamType strmType, gint strmId) |
437 const TMSStreamType strmType, const gint strmId) |
375 { |
438 { |
376 TRACE_PRN_FN_ENT; |
439 TRACE_PRN_FN_ENT; |
377 gint status(TMS_RESULT_SUCCESS); |
440 gint status(TMS_RESULT_SUCCESS); |
378 switch (strmType) |
441 switch (strmType) |
379 { |
442 { |
380 case TMS_STREAM_UPLINK: |
443 case TMS_STREAM_UPLINK: |
|
444 { |
381 if (strmId == iUplinkStreamId) |
445 if (strmId == iUplinkStreamId) |
382 { |
446 { |
383 iUplinkStreamId = -1; |
447 iUplinkStreamId = -1; |
384 iUplinkInitialized = FALSE; |
448 iUplinkInitialized = FALSE; |
385 } |
449 } |
386 break; |
450 break; |
|
451 } |
387 case TMS_STREAM_DOWNLINK: |
452 case TMS_STREAM_DOWNLINK: |
|
453 { |
388 if (strmId == iDnlinkStreamId) |
454 if (strmId == iDnlinkStreamId) |
389 { |
455 { |
390 iDnlinkStreamId = -1; |
456 iDnlinkStreamId = -1; |
391 iDnlinkInitialized = FALSE; |
457 iDnlinkInitialized = FALSE; |
392 } |
458 } |
393 break; |
459 break; |
|
460 } |
394 default: |
461 default: |
|
462 { |
395 status = TMS_RESULT_STREAM_TYPE_NOT_SUPPORTED; |
463 status = TMS_RESULT_STREAM_TYPE_NOT_SUPPORTED; |
396 break; |
464 break; |
|
465 } |
397 } |
466 } |
398 TRACE_PRN_FN_EXT; |
467 TRACE_PRN_FN_EXT; |
399 return status; |
468 return status; |
400 } |
469 } |
401 |
470 |
402 // ----------------------------------------------------------------------------- |
471 // ----------------------------------------------------------------------------- |
403 // TMSCallCSAdpt::DataXferBufferEmptied |
472 // TMSCallCSAdpt::DataXferBufferEmptied |
404 // |
473 // |
405 // ----------------------------------------------------------------------------- |
474 // ----------------------------------------------------------------------------- |
406 // |
475 // |
407 gint TMSCallCSAdpt::DataXferBufferEmptied(TMSCallType /*callType*/, |
476 gint TMSCallCSAdpt::DataXferBufferEmptied(const TMSCallType /*callType*/, |
408 TMSStreamType /*strmType*/, gint /*strmId*/) |
477 const TMSStreamType /*strmType*/, const gint /*strmId*/) |
409 { |
478 { |
410 TRACE_PRN_FN_ENT; |
479 TRACE_PRN_FN_ENT; |
411 gint status(TMS_RESULT_FEATURE_NOT_SUPPORTED); |
480 gint status(TMS_RESULT_FEATURE_NOT_SUPPORTED); |
412 TRACE_PRN_FN_EXT; |
481 TRACE_PRN_FN_EXT; |
413 return status; |
482 return status; |
947 // ----------------------------------------------------------------------------- |
1007 // ----------------------------------------------------------------------------- |
948 // TMSCallCSAdpt::StartDTMF |
1008 // TMSCallCSAdpt::StartDTMF |
949 // |
1009 // |
950 // ----------------------------------------------------------------------------- |
1010 // ----------------------------------------------------------------------------- |
951 // |
1011 // |
952 gint TMSCallCSAdpt::StartDTMF(TMSStreamType strmtype, TDes& dtmfstring) |
1012 gint TMSCallCSAdpt::StartDTMF(const TMSStreamType strmtype, TDes& dtmfstring) |
953 { |
1013 { |
954 TRACE_PRN_FN_ENT; |
1014 TRACE_PRN_FN_ENT; |
955 gint status(TMS_RESULT_SUCCESS); |
1015 gint status(TMS_RESULT_STREAM_TYPE_NOT_SUPPORTED); |
956 |
|
957 TmsMsgBufPckg dtmfpckg; |
1016 TmsMsgBufPckg dtmfpckg; |
|
1017 dtmfpckg().iStatus = status; |
|
1018 dtmfpckg().iRequest = ECmdDTMFTonePlayFinished; |
958 |
1019 |
959 if (strmtype == TMS_STREAM_DOWNLINK && iDnlinkInitialized) |
1020 if (strmtype == TMS_STREAM_DOWNLINK && iDnlinkInitialized) |
960 { |
1021 { |
961 if (iDTMFDnlinkPlayer) |
1022 if (iDTMFDnlinkPlayer) |
962 { |
1023 { |
963 iDTMFDnlinkPlayer->PlayDtmfTone(dtmfstring); |
1024 iDTMFDnlinkPlayer->PlayDtmfTone(dtmfstring); |
964 } |
1025 status = TMS_RESULT_SUCCESS; |
965 |
1026 } |
966 dtmfpckg().iStatus = TMS_RESULT_SUCCESS; |
1027 dtmfpckg().iStatus = TMS_RESULT_SUCCESS; |
967 dtmfpckg().iRequest = ECmdDTMFToneDnlPlayStarted; |
1028 dtmfpckg().iRequest = ECmdDTMFToneDnlPlayStarted; |
968 if (iDTMFNotifier) |
|
969 { |
|
970 iDTMFNotifier->SetDtmf(dtmfpckg, TRUE); |
|
971 } |
|
972 } |
1029 } |
973 else if (strmtype == TMS_STREAM_UPLINK && iUplinkInitialized) |
1030 else if (strmtype == TMS_STREAM_UPLINK && iUplinkInitialized) |
974 { |
1031 { |
975 //use etel for uplink |
1032 //use etel for uplink |
976 if (iDTMFUplinkPlayer) |
1033 if (iDTMFUplinkPlayer) |
977 { |
1034 { |
978 status = iDTMFUplinkPlayer->SendDtmfToneString(dtmfstring); |
1035 status = iDTMFUplinkPlayer->SendDtmfToneString(dtmfstring); |
979 } |
1036 status = TMS_RESULT_SUCCESS; |
980 |
1037 } |
981 dtmfpckg().iStatus = TMSUtility::EtelToTMSResult(status); |
1038 dtmfpckg().iStatus = TMSUtility::EtelToTMSResult(status); |
982 dtmfpckg().iRequest = ECmdDTMFToneUplPlayStarted; |
1039 dtmfpckg().iRequest = ECmdDTMFToneUplPlayStarted; |
983 |
1040 } |
984 if (iDTMFNotifier) |
1041 |
985 { |
1042 if (iDTMFNotifier) |
986 iDTMFNotifier->SetDtmf(dtmfpckg, TRUE); |
1043 { |
987 } |
1044 iDTMFNotifier->SetDtmf(dtmfpckg); |
988 } |
1045 } |
989 |
1046 |
|
1047 TRACE_PRN_IF_ERR(status); |
990 TRACE_PRN_FN_EXT; |
1048 TRACE_PRN_FN_EXT; |
991 return status; |
1049 return status; |
992 } |
1050 } |
993 |
1051 |
994 // ----------------------------------------------------------------------------- |
1052 // ----------------------------------------------------------------------------- |
995 // TMSCallCSAdpt::StopDTMF |
1053 // TMSCallCSAdpt::StopDTMF |
996 // |
1054 // |
997 // ----------------------------------------------------------------------------- |
1055 // ----------------------------------------------------------------------------- |
998 // |
1056 // |
999 gint TMSCallCSAdpt::StopDTMF(TMSStreamType streamtype) |
1057 gint TMSCallCSAdpt::StopDTMF(const TMSStreamType streamtype) |
1000 { |
1058 { |
1001 TRACE_PRN_FN_ENT; |
1059 TRACE_PRN_FN_ENT; |
1002 gint status(TMS_RESULT_SUCCESS); |
1060 gint status(TMS_RESULT_SUCCESS); |
1003 |
1061 |
1004 if (streamtype == TMS_STREAM_DOWNLINK && iDTMFDnlinkPlayer) |
1062 if (streamtype == TMS_STREAM_DOWNLINK && iDTMFDnlinkPlayer) |
1051 // ----------------------------------------------------------------------------- |
1109 // ----------------------------------------------------------------------------- |
1052 // TMSCallCSAdpt::DTMFToneFinished |
1110 // TMSCallCSAdpt::DTMFToneFinished |
1053 // |
1111 // |
1054 // ----------------------------------------------------------------------------- |
1112 // ----------------------------------------------------------------------------- |
1055 // |
1113 // |
1056 void TMSCallCSAdpt::DTMFToneFinished(gint error) |
1114 void TMSCallCSAdpt::DTMFToneFinished(gint status) |
1057 { |
1115 { |
1058 TRACE_PRN_FN_ENT; |
1116 TRACE_PRN_FN_ENT; |
|
1117 TRACE_PRN_IF_ERR(status); |
1059 TmsMsgBufPckg dtmfpckg; |
1118 TmsMsgBufPckg dtmfpckg; |
1060 |
1119 |
1061 if (error == KErrUnderflow || error == KErrInUse) |
1120 // KErrUnderflow indicates end of DTMF playback. |
1062 { |
1121 if (status == KErrUnderflow || status == KErrInUse) |
1063 error = TMS_RESULT_SUCCESS; |
1122 { |
1064 } |
1123 status = TMS_RESULT_SUCCESS; |
1065 |
1124 } |
1066 dtmfpckg().iStatus = TMSUtility::TMSResult(error); |
1125 dtmfpckg().iStatus = TMSUtility::TMSResult(status); |
1067 dtmfpckg().iRequest = ECmdDTMFTonePlayFinished; |
1126 dtmfpckg().iRequest = ECmdDTMFTonePlayFinished; |
1068 if (iDTMFNotifier) |
1127 if (iDTMFNotifier) |
1069 { |
1128 { |
1070 iDTMFNotifier->SetDtmf(dtmfpckg, TRUE); |
1129 iDTMFNotifier->SetDtmf(dtmfpckg); |
1071 } |
1130 } |
1072 |
|
1073 TRACE_PRN_FN_EXT; |
1131 TRACE_PRN_FN_EXT; |
1074 } |
1132 } |
1075 |
1133 |
1076 // ----------------------------------------------------------------------------- |
1134 // ----------------------------------------------------------------------------- |
1077 // TMSCallCSAdpt::HandleDTMFEvent |
1135 // TMSCallCSAdpt::HandleDTMFEvent |
1078 // |
1136 // |
1079 // ----------------------------------------------------------------------------- |
1137 // ----------------------------------------------------------------------------- |
1080 // |
1138 // |
1081 void TMSCallCSAdpt::HandleDTMFEvent( |
1139 void TMSCallCSAdpt::HandleDTMFEvent( |
1082 const TMSDTMFObserver::TCCPDtmfEvent aEvent, const gint aError, |
1140 const TMSDTMFObserver::TCCPDtmfEvent event, const gint status, |
1083 const TChar /*aTone*/) |
1141 const TChar /*tone*/) |
1084 { |
1142 { |
1085 TRACE_PRN_FN_ENT; |
1143 TRACE_PRN_FN_ENT; |
1086 TmsMsgBufPckg dtmfpckg; |
1144 TmsMsgBufPckg dtmfpckg; |
1087 |
1145 |
1088 TRACE_PRN_N1(_L("**TMS TMSCallCSAdpt::HandleDTMFEvent error:%d"),aError); |
1146 TRACE_PRN_N1(_L("**TMS TMSCallCSAdpt::HandleDTMFEvent error:%d"), status); |
1089 |
1147 |
1090 dtmfpckg().iStatus = TMSUtility::EtelToTMSResult(aError); |
1148 dtmfpckg().iStatus = TMSUtility::EtelToTMSResult(status); |
1091 |
1149 |
1092 switch (aEvent) |
1150 switch (event) |
1093 { |
1151 { |
1094 |
|
1095 case ECCPDtmfUnknown: //Unknown |
1152 case ECCPDtmfUnknown: //Unknown |
1096 break; |
1153 break; |
1097 case ECCPDtmfManualStart: //DTMF sending started manually |
1154 case ECCPDtmfManualStart: //DTMF sending started manually |
1098 case ECCPDtmfSequenceStart: //Automatic DTMF sending initialized |
1155 case ECCPDtmfSequenceStart: //Automatic DTMF sending initialized |
1099 dtmfpckg().iRequest = ECmdDTMFToneUplPlayStarted; |
1156 dtmfpckg().iRequest = ECmdDTMFToneUplPlayStarted; |
1115 iDTMFNotifier->SetDtmf(dtmfpckg, TRUE); |
1172 iDTMFNotifier->SetDtmf(dtmfpckg, TRUE); |
1116 } |
1173 } |
1117 TRACE_PRN_FN_EXT; |
1174 TRACE_PRN_FN_EXT; |
1118 } |
1175 } |
1119 |
1176 |
1120 // From TMSCSPDevSoundObserver |
|
1121 |
|
1122 // ----------------------------------------------------------------------------- |
1177 // ----------------------------------------------------------------------------- |
1123 // TMSCallCSAdpt::DownlinkInitCompleted |
1178 // TMSCallCSAdpt::DownlinkInitCompleted |
1124 // |
1179 // From TMSCSDevSoundObserver |
1125 // ----------------------------------------------------------------------------- |
1180 // ----------------------------------------------------------------------------- |
1126 // |
1181 // |
1127 void TMSCallCSAdpt::DownlinkInitCompleted(gint status) |
1182 void TMSCallCSAdpt::DownlinkInitCompleted(gint status) |
1128 { |
1183 { |
1129 TRACE_PRN_FN_ENT; |
1184 TRACE_PRN_FN_ENT; |
1130 NotifyClient(iDnlinkStreamId, ECmdDownlinkInitComplete, status, 0); |
1185 if (status == TMS_RESULT_SUCCESS) |
|
1186 { |
|
1187 iDnlinkInitialized = TRUE; |
|
1188 } |
|
1189 NotifyClient(iDnlinkStreamId, ECmdDownlinkInitComplete, status); |
1131 TRACE_PRN_FN_EXT; |
1190 TRACE_PRN_FN_EXT; |
1132 } |
1191 } |
1133 |
1192 |
1134 // ----------------------------------------------------------------------------- |
1193 // ----------------------------------------------------------------------------- |
1135 // TMSCallCSAdpt::UplinkInitCompleted |
1194 // TMSCallCSAdpt::UplinkInitCompleted |
1136 // |
1195 // From TMSCSDevSoundObserver |
1137 // ----------------------------------------------------------------------------- |
1196 // ----------------------------------------------------------------------------- |
1138 // |
1197 // |
1139 void TMSCallCSAdpt::UplinkInitCompleted(gint status) |
1198 void TMSCallCSAdpt::UplinkInitCompleted(gint status) |
1140 { |
1199 { |
1141 TRACE_PRN_FN_ENT; |
1200 TRACE_PRN_FN_ENT; |
1142 NotifyClient(iUplinkStreamId, ECmdUplinkInitComplete, status, 0); |
1201 if (status == TMS_RESULT_SUCCESS) |
1143 TRACE_PRN_FN_EXT; |
1202 { |
1144 } |
1203 iUplinkInitialized = TRUE; |
1145 |
1204 } |
1146 // ----------------------------------------------------------------------------- |
1205 NotifyClient(iUplinkStreamId, ECmdUplinkInitComplete, status); |
1147 // TMSCallCSAdpt::UplinkActivatedSuccessfully |
|
1148 // |
|
1149 // ----------------------------------------------------------------------------- |
|
1150 // |
|
1151 void TMSCallCSAdpt::UplinkActivatedSuccessfully() |
|
1152 { |
|
1153 TRACE_PRN_FN_ENT; |
|
1154 NotifyClient(iUplinkStreamId, ECmdUplinkStarted, KErrNone, 0); |
|
1155 TRACE_PRN_FN_EXT; |
|
1156 } |
|
1157 |
|
1158 // ----------------------------------------------------------------------------- |
|
1159 // TMSCallCSAdpt::DownlinkActivatedSuccessfully |
|
1160 // |
|
1161 // ----------------------------------------------------------------------------- |
|
1162 // |
|
1163 void TMSCallCSAdpt::DownlinkActivatedSuccessfully() |
|
1164 { |
|
1165 TRACE_PRN_FN_ENT; |
|
1166 NotifyClient(iDnlinkStreamId, ECmdDownlinkStarted, KErrNone, 0); |
|
1167 TRACE_PRN_FN_EXT; |
1206 TRACE_PRN_FN_EXT; |
1168 } |
1207 } |
1169 |
1208 |
1170 // ----------------------------------------------------------------------------- |
1209 // ----------------------------------------------------------------------------- |
1171 // TMSCallCSAdpt::UplinkActivationFailed |
1210 // TMSCallCSAdpt::UplinkActivationFailed |
1172 // |
1211 // From TMSCSDevSoundObserver |
1173 // ----------------------------------------------------------------------------- |
1212 // ----------------------------------------------------------------------------- |
1174 // |
1213 // |
1175 void TMSCallCSAdpt::UplinkActivationFailed() |
1214 void TMSCallCSAdpt::UplinkActivationCompleted(gint status) |
1176 { |
1215 { |
1177 TRACE_PRN_FN_ENT; |
1216 TRACE_PRN_FN_ENT; |
1178 NotifyClient(iUplinkStreamId, ECmdUplinkStarted, TMS_RESULT_FATAL_ERROR, 0); |
1217 NotifyClient(iUplinkStreamId, ECmdUplinkStarted, status); |
1179 TRACE_PRN_FN_EXT; |
1218 TRACE_PRN_FN_EXT; |
1180 } |
1219 } |
1181 |
1220 |
1182 // ----------------------------------------------------------------------------- |
1221 // ----------------------------------------------------------------------------- |
1183 // TMSCallCSAdpt::DownlinkActivationFailed |
1222 // TMSCallCSAdpt::DownlinkActivationFailed |
1184 // |
1223 // From TMSCSDevSoundObserver |
1185 // ----------------------------------------------------------------------------- |
1224 // ----------------------------------------------------------------------------- |
1186 // |
1225 // |
1187 void TMSCallCSAdpt::DownlinkActivationFailed() |
1226 void TMSCallCSAdpt::DownlinkActivationCompleted(gint status) |
1188 { |
1227 { |
1189 TRACE_PRN_FN_ENT; |
1228 TRACE_PRN_FN_ENT; |
1190 NotifyClient(iDnlinkStreamId, ECmdDownlinkStarted, |
1229 NotifyClient(iDnlinkStreamId, ECmdDownlinkStarted, status); |
1191 TMS_RESULT_FATAL_ERROR, 0); |
|
1192 TRACE_PRN_FN_EXT; |
1230 TRACE_PRN_FN_EXT; |
1193 } |
1231 } |
1194 |
1232 |
1195 // ----------------------------------------------------------------------------- |
1233 // ----------------------------------------------------------------------------- |
1196 // TMSCallCSAdpt::AvailableOutputsChanged |
1234 // TMSCallCSAdpt::AvailableOutputsChanged |