54 |
54 |
55 using namespace QTMS; |
55 using namespace QTMS; |
56 using namespace TMS; |
56 using namespace TMS; |
57 |
57 |
58 QTMSFactoryImpl::QTMSFactoryImpl() |
58 QTMSFactoryImpl::QTMSFactoryImpl() |
59 { |
59 { |
60 TRACE_PRN_FN_ENT; |
60 TRACE_PRN_FN_ENT; |
61 TMSVer* ver = NULL; |
61 TMSVer* ver = NULL; |
62 TMSFactory::CreateFactory(iFactory, *ver); |
62 TMSFactory::CreateFactory(iFactory, *ver); |
63 TRACE_PRN_FN_EXT; |
63 TRACE_PRN_FN_EXT; |
64 } |
64 } |
65 |
65 |
66 QTMSFactoryImpl::~QTMSFactoryImpl() |
66 QTMSFactoryImpl::~QTMSFactoryImpl() |
67 { |
67 { |
68 TRACE_PRN_FN_ENT; |
68 TRACE_PRN_FN_ENT; |
69 delete iFactory; |
69 delete iFactory; |
70 TRACE_PRN_FN_EXT; |
70 TRACE_PRN_FN_EXT; |
71 } |
71 } |
72 |
72 |
73 gint QTMSFactoryImpl::CreateCall(QTMSCallType ctype, QTMSCall*& qtmscall, |
73 gint QTMSFactoryImpl::CreateCall(QTMSCallType ctype, QTMSCall*& qtmscall, guint /*ctxid*/) |
74 guint /*ctxid*/) |
74 { |
75 { |
|
76 TRACE_PRN_FN_ENT; |
75 TRACE_PRN_FN_ENT; |
77 gint ret(QTMS_RESULT_UNINITIALIZED_OBJECT); |
76 gint ret(QTMS_RESULT_UNINITIALIZED_OBJECT); |
78 |
77 |
79 TMSCall* tmscall(NULL); |
78 TMSCall* tmscall(NULL); |
80 if (iFactory) |
79 if (iFactory) { |
81 { |
|
82 ret = iFactory->CreateCall((TMSCallType) ctype, tmscall); |
80 ret = iFactory->CreateCall((TMSCallType) ctype, tmscall); |
83 |
81 |
84 if (ret == TMS_RESULT_SUCCESS) |
82 if (ret == TMS_RESULT_SUCCESS) { |
85 { |
|
86 ret = QTMSCallImpl::Create(qtmscall, tmscall); |
83 ret = QTMSCallImpl::Create(qtmscall, tmscall); |
87 } |
84 } |
88 } |
85 } |
89 TRACE_PRN_FN_EXT; |
86 TRACE_PRN_FN_EXT; |
90 return ret; |
87 return ret; |
91 } |
88 } |
92 |
89 |
93 gint QTMSFactoryImpl::DeleteCall(QTMSCall*& qtmscall) |
90 gint QTMSFactoryImpl::DeleteCall(QTMSCall*& qtmscall) |
94 { |
91 { |
95 TRACE_PRN_FN_ENT; |
92 TRACE_PRN_FN_ENT; |
96 gint ret(QTMS_RESULT_SUCCESS); |
93 gint ret(QTMS_RESULT_SUCCESS); |
97 delete qtmscall; |
94 delete qtmscall; |
98 qtmscall = NULL; |
95 qtmscall = NULL; |
99 TRACE_PRN_FN_EXT; |
96 TRACE_PRN_FN_EXT; |
100 return ret; |
97 return ret; |
101 } |
98 } |
102 |
99 |
103 gint QTMSFactoryImpl::IsCallTypeSupported(QTMSCallType ctype, gboolean& flag) |
100 gint QTMSFactoryImpl::IsCallTypeSupported(QTMSCallType ctype, gboolean& flag) |
104 { |
101 { |
105 gint ret(QTMS_RESULT_SUCCESS); |
102 gint ret(QTMS_RESULT_SUCCESS); |
106 |
103 |
107 switch (ctype) |
104 switch (ctype) { |
108 { |
105 case QTMS_CALL_CS: |
109 case QTMS_CALL_CS: |
106 case QTMS_CALL_IP: |
110 case QTMS_CALL_IP: |
107 flag = ETrue; |
111 flag = ETrue; |
108 break; |
112 break; |
109 case QTMS_CALL_ECS: //from TB 10.1 |
113 case QTMS_CALL_ECS: //from TB 10.1 |
110 default: |
114 default: |
111 flag = EFalse; |
115 flag = EFalse; |
112 break; |
116 break; |
113 } |
117 } |
114 return ret; |
118 return ret; |
115 } |
119 } |
116 |
120 |
117 gint QTMSFactoryImpl::GetSupportedFormats(const QTMSStreamType strmtype, FormatVector& fmtlist) |
121 gint QTMSFactoryImpl::GetSupportedFormats(const QTMSStreamType strmtype, |
118 { |
122 FormatVector& fmtlist) |
|
123 { |
|
124 TRACE_PRN_FN_ENT; |
119 TRACE_PRN_FN_ENT; |
125 gint ret(QTMS_RESULT_UNINITIALIZED_OBJECT); |
120 gint ret(QTMS_RESULT_UNINITIALIZED_OBJECT); |
126 TMS::FormatVector tmsfmtlist; |
121 TMS::FormatVector tmsfmtlist; |
127 if (iFactory) |
122 if (iFactory) { |
128 { |
123 ret = iFactory->GetSupportedFormats((TMSStreamType) strmtype, tmsfmtlist); |
129 ret = iFactory->GetSupportedFormats((TMSStreamType) strmtype, |
124 } |
130 tmsfmtlist); |
|
131 } |
|
132 |
125 |
133 std::vector<TMSFormat*>::iterator itCodecs = tmsfmtlist.begin(); |
126 std::vector<TMSFormat*>::iterator itCodecs = tmsfmtlist.begin(); |
134 TMSFormatType fmttype; |
127 TMSFormatType fmttype; |
135 for (; itCodecs < tmsfmtlist.end(); itCodecs++) |
128 for (; itCodecs < tmsfmtlist.end(); itCodecs++) { |
136 { |
|
137 (*itCodecs)->GetType(fmttype); |
129 (*itCodecs)->GetType(fmttype); |
138 QTMSFormat* qtmsfmt(NULL); |
130 QTMSFormat* qtmsfmt(NULL); |
139 switch (fmttype) |
131 switch (fmttype) { |
140 { |
132 case QTMS_FORMAT_PCM: |
|
133 ret = QTMSPCMFormatImpl::Create(qtmsfmt, *itCodecs); |
|
134 break; |
|
135 case QTMS_FORMAT_AMR: |
|
136 ret = QTMSAMRFormatImpl::Create(qtmsfmt, *itCodecs); |
|
137 break; |
|
138 case QTMS_FORMAT_G711: |
|
139 ret = QTMSG711FormatImpl::Create(qtmsfmt, *itCodecs); |
|
140 break; |
|
141 case QTMS_FORMAT_G729: |
|
142 ret = QTMSG729FormatImpl::Create(qtmsfmt, *itCodecs); |
|
143 break; |
|
144 case QTMS_FORMAT_ILBC: |
|
145 ret = QTMSILBCFormatImpl::Create(qtmsfmt, *itCodecs); |
|
146 break; |
|
147 default: |
|
148 break; |
|
149 } |
|
150 |
|
151 if (qtmsfmt) { |
|
152 fmtlist.push_back(qtmsfmt); |
|
153 } |
|
154 } |
|
155 TRACE_PRN_FN_EXT; |
|
156 return ret; |
|
157 } |
|
158 |
|
159 gint QTMSFactoryImpl::CreateFormat(QTMSFormatType fmttype, QTMSFormat*& qtmsfmt) |
|
160 { |
|
161 TRACE_PRN_FN_ENT; |
|
162 gint ret(QTMS_RESULT_UNINITIALIZED_OBJECT); |
|
163 TMSFormat* tmsformat(NULL); |
|
164 |
|
165 if (iFactory) { |
|
166 ret = iFactory->CreateFormat((TMSFormatType) fmttype, tmsformat); |
|
167 |
|
168 if (ret == TMS_RESULT_SUCCESS) { |
|
169 switch (fmttype) { |
141 case QTMS_FORMAT_PCM: |
170 case QTMS_FORMAT_PCM: |
142 ret = QTMSPCMFormatImpl::Create(qtmsfmt,*itCodecs); |
171 ret = QTMSPCMFormatImpl::Create(qtmsfmt, tmsformat); |
143 break; |
172 break; |
144 case QTMS_FORMAT_AMR: |
173 case QTMS_FORMAT_AMR: |
145 ret = QTMSAMRFormatImpl::Create(qtmsfmt,*itCodecs); |
174 ret = QTMSAMRFormatImpl::Create(qtmsfmt, tmsformat); |
146 break; |
175 break; |
147 case QTMS_FORMAT_G711: |
176 case QTMS_FORMAT_G711: |
148 ret = QTMSG711FormatImpl::Create(qtmsfmt,*itCodecs); |
177 ret = QTMSG711FormatImpl::Create(qtmsfmt, tmsformat); |
149 break; |
178 break; |
150 case QTMS_FORMAT_G729: |
179 case QTMS_FORMAT_G729: |
151 ret = QTMSG729FormatImpl::Create(qtmsfmt,*itCodecs); |
180 ret = QTMSG729FormatImpl::Create(qtmsfmt, tmsformat); |
152 break; |
181 break; |
153 case QTMS_FORMAT_ILBC: |
182 case QTMS_FORMAT_ILBC: |
154 ret = QTMSILBCFormatImpl::Create(qtmsfmt,*itCodecs); |
183 ret = QTMSILBCFormatImpl::Create(qtmsfmt, tmsformat); |
155 break; |
184 break; |
156 default: |
185 default: |
|
186 ret = QTMS_RESULT_FORMAT_TYPE_NOT_SUPPORTED; |
157 break; |
187 break; |
158 } |
188 } |
159 |
189 } |
160 if (qtmsfmt) |
190 } |
161 { |
191 TRACE_PRN_FN_EXT; |
162 fmtlist.push_back(qtmsfmt); |
192 return ret; |
163 } |
193 } |
164 } |
|
165 TRACE_PRN_FN_EXT; |
|
166 return ret; |
|
167 } |
|
168 |
|
169 gint QTMSFactoryImpl::CreateFormat(QTMSFormatType fmttype, |
|
170 QTMSFormat*& qtmsfmt) |
|
171 { |
|
172 TRACE_PRN_FN_ENT; |
|
173 gint ret(QTMS_RESULT_UNINITIALIZED_OBJECT); |
|
174 TMSFormat* tmsformat(NULL); |
|
175 |
|
176 if (iFactory) |
|
177 { |
|
178 ret = iFactory->CreateFormat((TMSFormatType) fmttype, tmsformat); |
|
179 |
|
180 if (ret == TMS_RESULT_SUCCESS) |
|
181 { |
|
182 switch (fmttype) |
|
183 { |
|
184 case QTMS_FORMAT_PCM: |
|
185 ret = QTMSPCMFormatImpl::Create(qtmsfmt, tmsformat); |
|
186 break; |
|
187 case QTMS_FORMAT_AMR: |
|
188 ret = QTMSAMRFormatImpl::Create(qtmsfmt, tmsformat); |
|
189 break; |
|
190 case QTMS_FORMAT_G711: |
|
191 ret = QTMSG711FormatImpl::Create(qtmsfmt, tmsformat); |
|
192 break; |
|
193 case QTMS_FORMAT_G729: |
|
194 ret = QTMSG729FormatImpl::Create(qtmsfmt, tmsformat); |
|
195 break; |
|
196 case QTMS_FORMAT_ILBC: |
|
197 ret = QTMSILBCFormatImpl::Create(qtmsfmt, tmsformat); |
|
198 break; |
|
199 default: |
|
200 ret = QTMS_RESULT_FORMAT_TYPE_NOT_SUPPORTED; |
|
201 break; |
|
202 } |
|
203 } |
|
204 } |
|
205 TRACE_PRN_FN_EXT; |
|
206 return ret; |
|
207 } |
|
208 |
194 |
209 gint QTMSFactoryImpl::DeleteFormat(QTMSFormat*& qtmsfmt) |
195 gint QTMSFactoryImpl::DeleteFormat(QTMSFormat*& qtmsfmt) |
210 { |
196 { |
211 TRACE_PRN_FN_ENT; |
197 TRACE_PRN_FN_ENT; |
212 __ASSERT_ALWAYS(qtmsfmt, PANIC(QTMS_RESULT_NULL_ARGUMENT)); |
198 __ASSERT_ALWAYS(qtmsfmt, PANIC(QTMS_RESULT_NULL_ARGUMENT)); |
213 |
199 |
214 gint ret(QTMS_RESULT_SUCCESS); |
200 gint ret(QTMS_RESULT_SUCCESS); |
215 QTMSFormatType fmttype; |
201 QTMSFormatType fmttype; |
216 ret = qtmsfmt->GetType(fmttype); |
202 ret = qtmsfmt->GetType(fmttype); |
217 switch (fmttype) |
203 switch (fmttype) { |
218 { |
204 case QTMS_FORMAT_PCM: |
219 case QTMS_FORMAT_PCM: |
205 delete (static_cast<QTMSPCMFormatImpl*> (qtmsfmt)); |
220 delete (static_cast<QTMSPCMFormatImpl*>(qtmsfmt)); |
206 qtmsfmt = NULL; |
221 qtmsfmt = NULL; |
207 break; |
222 break; |
208 case QTMS_FORMAT_AMR: |
223 case QTMS_FORMAT_AMR: |
209 delete (static_cast<QTMSAMRFormatImpl*> (qtmsfmt)); |
224 delete (static_cast<QTMSAMRFormatImpl*>(qtmsfmt)); |
210 qtmsfmt = NULL; |
225 qtmsfmt = NULL; |
211 break; |
226 break; |
212 case QTMS_FORMAT_G711: |
227 case QTMS_FORMAT_G711: |
213 delete (static_cast<QTMSG711FormatImpl*> (qtmsfmt)); |
228 delete (static_cast<QTMSG711FormatImpl*>(qtmsfmt)); |
214 qtmsfmt = NULL; |
229 qtmsfmt = NULL; |
215 break; |
230 break; |
216 case QTMS_FORMAT_G729: |
231 case QTMS_FORMAT_G729: |
217 delete (static_cast<QTMSG729FormatImpl*> (qtmsfmt)); |
232 delete (static_cast<QTMSG729FormatImpl*>(qtmsfmt)); |
218 qtmsfmt = NULL; |
233 qtmsfmt = NULL; |
219 break; |
234 break; |
220 case QTMS_FORMAT_ILBC: |
235 case QTMS_FORMAT_ILBC: |
221 delete (static_cast<QTMSILBCFormatImpl*> (qtmsfmt)); |
236 delete (static_cast<QTMSILBCFormatImpl*>(qtmsfmt)); |
222 qtmsfmt = NULL; |
237 qtmsfmt = NULL; |
223 break; |
238 break; |
224 default: |
239 default: |
225 ret = QTMS_RESULT_FORMAT_TYPE_NOT_SUPPORTED; |
240 ret = QTMS_RESULT_FORMAT_TYPE_NOT_SUPPORTED; |
226 break; |
241 break; |
227 } |
242 } |
228 TRACE_PRN_FN_EXT; |
243 TRACE_PRN_FN_EXT; |
229 return ret; |
244 return ret; |
230 } |
245 } |
231 |
246 |
232 gint QTMSFactoryImpl::CreateEffect(QTMSEffectType tmseffecttype, QTMSEffect*& qtmseffect) |
247 gint QTMSFactoryImpl::CreateEffect(QTMSEffectType tmseffecttype, |
233 { |
248 QTMSEffect*& qtmseffect) |
|
249 { |
|
250 TRACE_PRN_FN_ENT; |
234 TRACE_PRN_FN_ENT; |
251 gint ret(QTMS_RESULT_UNINITIALIZED_OBJECT); |
235 gint ret(QTMS_RESULT_UNINITIALIZED_OBJECT); |
252 TMSEffect* tmseffect(NULL); |
236 TMSEffect* tmseffect(NULL); |
253 |
237 |
254 if (iFactory) |
238 if (iFactory) { |
255 { |
|
256 ret = iFactory->CreateEffect((TMSEffectType) tmseffecttype, tmseffect); |
239 ret = iFactory->CreateEffect((TMSEffectType) tmseffecttype, tmseffect); |
257 |
240 |
258 if (ret == TMS_RESULT_SUCCESS) |
241 if (ret == TMS_RESULT_SUCCESS) { |
259 { |
242 switch (tmseffecttype) { |
260 switch (tmseffecttype) |
243 case TMS_EFFECT_VOLUME: |
261 { |
244 ret = QTMSVolumeEffectImpl::Create(qtmseffect, tmseffect); |
262 case TMS_EFFECT_VOLUME: |
245 break; |
263 ret = QTMSVolumeEffectImpl::Create(qtmseffect, tmseffect); |
246 case TMS_EFFECT_GAIN: |
264 break; |
247 ret = QTMSGainEffectImpl::Create(qtmseffect, tmseffect); |
265 case TMS_EFFECT_GAIN: |
248 break; |
266 ret = QTMSGainEffectImpl::Create(qtmseffect, tmseffect); |
249 case TMS_EFFECT_GLOBAL_VOL: |
267 break; |
250 ret = QTMSGlobalVolEffectImpl::Create(qtmseffect, tmseffect); |
268 case TMS_EFFECT_GLOBAL_VOL: |
251 break; |
269 ret = QTMSGlobalVolEffectImpl::Create(qtmseffect, |
252 case TMS_EFFECT_GLOBAL_GAIN: |
270 tmseffect); |
253 ret = QTMSGlobalGainEffectImpl::Create(qtmseffect, tmseffect); |
271 break; |
254 break; |
272 case TMS_EFFECT_GLOBAL_GAIN: |
255 default: |
273 ret = QTMSGlobalGainEffectImpl::Create(qtmseffect, |
256 ret = TMS_RESULT_EFFECT_TYPE_NOT_SUPPORTED; |
274 tmseffect); |
257 break; |
275 break; |
|
276 default: |
|
277 ret = TMS_RESULT_EFFECT_TYPE_NOT_SUPPORTED; |
|
278 break; |
|
279 } |
|
280 } |
258 } |
281 } |
259 } |
282 TRACE_PRN_FN_EXT; |
260 } |
283 return ret; |
261 TRACE_PRN_FN_EXT; |
284 } |
262 return ret; |
|
263 } |
285 |
264 |
286 gint QTMSFactoryImpl::DeleteEffect(QTMSEffect*& qtmseffect) |
265 gint QTMSFactoryImpl::DeleteEffect(QTMSEffect*& qtmseffect) |
287 { |
266 { |
288 TRACE_PRN_FN_ENT; |
267 TRACE_PRN_FN_ENT; |
289 gint ret(QTMS_RESULT_SUCCESS); |
268 gint ret(QTMS_RESULT_SUCCESS); |
290 |
269 |
291 QTMSEffectType effecttype; |
270 QTMSEffectType effecttype; |
292 ret = qtmseffect->GetType(effecttype); |
271 ret = qtmseffect->GetType(effecttype); |
293 switch (effecttype) |
272 switch (effecttype) { |
294 { |
273 case QTMS_EFFECT_VOLUME: |
295 case QTMS_EFFECT_VOLUME: |
274 delete (static_cast<QTMSVolumeEffectImpl*> (qtmseffect)); |
296 delete (static_cast<QTMSVolumeEffectImpl*> (qtmseffect)); |
275 qtmseffect = NULL; |
297 qtmseffect = NULL; |
276 break; |
298 break; |
277 case QTMS_EFFECT_GAIN: |
299 case QTMS_EFFECT_GAIN: |
278 delete (static_cast<QTMSGainEffectImpl*> (qtmseffect)); |
300 delete (static_cast<QTMSGainEffectImpl*> (qtmseffect)); |
279 qtmseffect = NULL; |
301 qtmseffect = NULL; |
280 break; |
302 break; |
281 case QTMS_EFFECT_GLOBAL_VOL: |
303 case QTMS_EFFECT_GLOBAL_VOL: |
282 delete (static_cast<QTMSGlobalVolEffectImpl*> (qtmseffect)); |
304 delete (static_cast<QTMSGlobalVolEffectImpl*> (qtmseffect)); |
283 qtmseffect = NULL; |
305 qtmseffect = NULL; |
284 break; |
306 break; |
285 case QTMS_EFFECT_GLOBAL_GAIN: |
307 case QTMS_EFFECT_GLOBAL_GAIN: |
286 delete (static_cast<QTMSGlobalGainEffectImpl*> (qtmseffect)); |
308 delete (static_cast<QTMSGlobalGainEffectImpl*> (qtmseffect)); |
287 qtmseffect = NULL; |
309 qtmseffect = NULL; |
288 break; |
310 break; |
289 default: |
311 default: |
290 ret = QTMS_RESULT_EFFECT_TYPE_NOT_SUPPORTED; |
312 ret = QTMS_RESULT_EFFECT_TYPE_NOT_SUPPORTED; |
291 break; |
313 break; |
292 } |
314 } |
293 TRACE_PRN_FN_EXT; |
315 TRACE_PRN_FN_EXT; |
294 return ret; |
316 return ret; |
295 } |
317 } |
296 |
318 |
297 gint QTMSFactoryImpl::CreateBuffer(QTMSBufferType buffertype, guint size, QTMSBuffer*& buffer) |
319 gint QTMSFactoryImpl::CreateBuffer(QTMSBufferType buffertype, guint size, |
298 { |
320 QTMSBuffer*& buffer) |
|
321 { |
|
322 TRACE_PRN_FN_ENT; |
299 TRACE_PRN_FN_ENT; |
323 gint ret(QTMS_RESULT_UNINITIALIZED_OBJECT); |
300 gint ret(QTMS_RESULT_UNINITIALIZED_OBJECT); |
324 TMSBuffer* tmsbuffer(NULL); |
301 TMSBuffer* tmsbuffer(NULL); |
325 if (iFactory) |
302 if (iFactory) { |
326 { |
303 ret = iFactory->CreateBuffer((TMSBufferType) buffertype, size, tmsbuffer); |
327 ret = iFactory->CreateBuffer((TMSBufferType) buffertype, size, |
304 if (ret == TMS_RESULT_SUCCESS) { |
328 tmsbuffer); |
305 switch (buffertype) { |
329 if (ret == TMS_RESULT_SUCCESS) |
306 case QTMS_BUFFER_MEMORY: |
330 { |
307 ret = QTMSBufferImpl::Create(buffertype, buffer, tmsbuffer); |
331 switch (buffertype) |
308 break; |
332 { |
309 default: |
333 case QTMS_BUFFER_MEMORY: |
310 ret = QTMS_RESULT_BUFFER_TYPE_NOT_SUPPORTED; |
334 ret = QTMSBufferImpl::Create(buffertype, buffer, tmsbuffer); |
311 break; |
335 break; |
|
336 default: |
|
337 ret = QTMS_RESULT_BUFFER_TYPE_NOT_SUPPORTED; |
|
338 break; |
|
339 } |
|
340 } |
312 } |
341 } |
313 } |
342 |
314 } |
343 TRACE_PRN_FN_EXT; |
315 |
344 return ret; |
316 TRACE_PRN_FN_EXT; |
345 } |
317 return ret; |
|
318 } |
346 |
319 |
347 gint QTMSFactoryImpl::DeleteBuffer(QTMSBuffer*& qtmsbuffer) |
320 gint QTMSFactoryImpl::DeleteBuffer(QTMSBuffer*& qtmsbuffer) |
348 { |
321 { |
349 TRACE_PRN_FN_ENT; |
322 TRACE_PRN_FN_ENT; |
350 gint ret(QTMS_RESULT_SUCCESS); |
323 gint ret(QTMS_RESULT_SUCCESS); |
351 delete qtmsbuffer; |
324 delete qtmsbuffer; |
352 qtmsbuffer = NULL; |
325 qtmsbuffer = NULL; |
353 TRACE_PRN_FN_EXT; |
326 TRACE_PRN_FN_EXT; |
354 return ret; |
327 return ret; |
355 } |
328 } |
356 |
329 |
357 gint QTMSFactoryImpl::CreateSource(QTMSSourceType srctype, |
330 gint QTMSFactoryImpl::CreateSource(QTMSSourceType srctype, QTMSSource*& qtmssrc) |
358 QTMSSource*& qtmssrc) |
331 { |
359 { |
|
360 TRACE_PRN_FN_ENT; |
332 TRACE_PRN_FN_ENT; |
361 gint ret(QTMS_RESULT_UNINITIALIZED_OBJECT); |
333 gint ret(QTMS_RESULT_UNINITIALIZED_OBJECT); |
362 |
334 |
363 TMS::TMSSource* tmssource(NULL); |
335 TMS::TMSSource* tmssource(NULL); |
364 if (iFactory) |
336 if (iFactory) { |
365 { |
|
366 ret = iFactory->CreateSource((TMSSourceType) srctype, tmssource); |
337 ret = iFactory->CreateSource((TMSSourceType) srctype, tmssource); |
367 |
338 |
368 if (ret == TMS_RESULT_SUCCESS) |
339 if (ret == TMS_RESULT_SUCCESS) { |
369 { |
340 switch (srctype) { |
370 switch (srctype) |
341 case QTMS_SOURCE_CLIENT: |
371 { |
342 ret = QTMSClientSourceImpl::Create(qtmssrc, tmssource); |
372 case QTMS_SOURCE_CLIENT: |
343 break; |
373 ret = QTMSClientSourceImpl::Create(qtmssrc, tmssource); |
344 case QTMS_SOURCE_MODEM: |
374 break; |
345 ret = QTMSModemSourceImpl::Create(qtmssrc, tmssource); |
375 case QTMS_SOURCE_MODEM: |
346 break; |
376 ret = QTMSModemSourceImpl::Create(qtmssrc, tmssource); |
347 case QTMS_SOURCE_MIC: |
377 break; |
348 ret = QTMSMicSourceImpl::Create(qtmssrc, tmssource); |
378 case QTMS_SOURCE_MIC: |
349 break; |
379 ret = QTMSMicSourceImpl::Create(qtmssrc, tmssource); |
350 default: |
380 break; |
351 ret = TMS_RESULT_SOURCE_TYPE_NOT_SUPPORTED; |
381 default: |
352 break; |
382 ret = TMS_RESULT_SOURCE_TYPE_NOT_SUPPORTED; |
|
383 break; |
|
384 } |
|
385 } |
353 } |
386 } |
354 } |
387 TRACE_PRN_FN_EXT; |
355 } |
388 return ret; |
356 TRACE_PRN_FN_EXT; |
389 } |
357 return ret; |
|
358 } |
390 |
359 |
391 gint QTMSFactoryImpl::DeleteSource(QTMSSource*& qtmssrc) |
360 gint QTMSFactoryImpl::DeleteSource(QTMSSource*& qtmssrc) |
392 { |
361 { |
393 TRACE_PRN_FN_ENT; |
362 TRACE_PRN_FN_ENT; |
394 __ASSERT_ALWAYS(qtmssrc, PANIC(QTMS_RESULT_NULL_ARGUMENT)); |
363 __ASSERT_ALWAYS(qtmssrc, PANIC(QTMS_RESULT_NULL_ARGUMENT)); |
395 |
364 |
396 gint ret(QTMS_RESULT_SUCCESS); |
365 gint ret(QTMS_RESULT_SUCCESS); |
397 QTMSSourceType sourcetype; |
366 QTMSSourceType sourcetype; |
398 ret = qtmssrc->GetType(sourcetype); |
367 ret = qtmssrc->GetType(sourcetype); |
399 switch (sourcetype) |
368 switch (sourcetype) { |
400 { |
369 case QTMS_SOURCE_CLIENT: |
401 case QTMS_SOURCE_CLIENT: |
370 delete (static_cast<QTMSClientSourceImpl*> (qtmssrc)); |
402 delete (static_cast<QTMSClientSourceImpl*>(qtmssrc)); |
371 qtmssrc = NULL; |
403 qtmssrc = NULL; |
372 break; |
404 break; |
373 case QTMS_SOURCE_MODEM: |
405 case QTMS_SOURCE_MODEM: |
374 { |
406 { |
375 delete (static_cast<QTMSModemSourceImpl*> (qtmssrc)); |
407 delete (static_cast<QTMSModemSourceImpl*>(qtmssrc)); |
376 qtmssrc = NULL; |
408 qtmssrc = NULL; |
377 } |
|
378 break; |
|
379 case TMS_SOURCE_MIC: |
|
380 { |
|
381 delete (static_cast<QTMSMicSourceImpl*> (qtmssrc)); |
|
382 qtmssrc = NULL; |
|
383 } |
|
384 break; |
|
385 default: |
|
386 ret = TMS_RESULT_SOURCE_TYPE_NOT_SUPPORTED; |
|
387 break; |
|
388 } |
|
389 |
|
390 TRACE_PRN_FN_EXT; |
|
391 return ret; |
|
392 } |
|
393 |
|
394 gint QTMSFactoryImpl::CreateSink(QTMSSinkType sinktype, QTMSSink*& qtmssink) |
|
395 { |
|
396 TRACE_PRN_FN_ENT; |
|
397 gint ret(QTMS_RESULT_UNINITIALIZED_OBJECT); |
|
398 |
|
399 TMS::TMSSink* tmssink(NULL); |
|
400 |
|
401 if (iFactory) { |
|
402 ret = iFactory->CreateSink((TMSSinkType) sinktype, tmssink); |
|
403 |
|
404 if (ret == TMS_RESULT_SUCCESS) { |
|
405 switch (sinktype) { |
|
406 case QTMS_SINK_CLIENT: |
|
407 ret = QTMSClientSinkImpl::Create(qtmssink, tmssink); |
|
408 break; |
|
409 case QTMS_SINK_MODEM: |
|
410 ret = QTMSModemSinkImpl::Create(qtmssink, tmssink); |
|
411 break; |
|
412 case QTMS_SINK_SPEAKER: |
|
413 ret = QTMSSpeakerSinkImpl::Create(qtmssink, tmssink); |
|
414 break; |
|
415 default: |
|
416 ret = TMS_RESULT_SINK_TYPE_NOT_SUPPORTED; |
|
417 break; |
409 } |
418 } |
410 break; |
419 } |
411 case TMS_SOURCE_MIC: |
420 } |
412 { |
421 TRACE_PRN_FN_EXT; |
413 delete (static_cast<QTMSMicSourceImpl*>(qtmssrc)); |
422 return ret; |
414 qtmssrc = NULL; |
423 } |
415 } |
|
416 break; |
|
417 default: |
|
418 ret = TMS_RESULT_SOURCE_TYPE_NOT_SUPPORTED; |
|
419 break; |
|
420 } |
|
421 |
|
422 TRACE_PRN_FN_EXT; |
|
423 return ret; |
|
424 } |
|
425 |
|
426 gint QTMSFactoryImpl::CreateSink(QTMSSinkType sinktype, QTMSSink*& qtmssink) |
|
427 { |
|
428 TRACE_PRN_FN_ENT; |
|
429 gint ret(QTMS_RESULT_UNINITIALIZED_OBJECT); |
|
430 |
|
431 TMS::TMSSink* tmssink(NULL); |
|
432 |
|
433 if (iFactory) |
|
434 { |
|
435 ret = iFactory->CreateSink((TMSSinkType) sinktype, tmssink); |
|
436 |
|
437 if (ret == TMS_RESULT_SUCCESS) |
|
438 { |
|
439 switch (sinktype) |
|
440 { |
|
441 case QTMS_SINK_CLIENT: |
|
442 ret = QTMSClientSinkImpl::Create(qtmssink, tmssink); |
|
443 break; |
|
444 case QTMS_SINK_MODEM: |
|
445 ret = QTMSModemSinkImpl::Create(qtmssink, tmssink); |
|
446 break; |
|
447 case QTMS_SINK_SPEAKER: |
|
448 ret = QTMSSpeakerSinkImpl::Create(qtmssink, tmssink); |
|
449 break; |
|
450 default: |
|
451 ret = TMS_RESULT_SINK_TYPE_NOT_SUPPORTED; |
|
452 break; |
|
453 } |
|
454 } |
|
455 } |
|
456 TRACE_PRN_FN_EXT; |
|
457 return ret; |
|
458 } |
|
459 |
424 |
460 gint QTMSFactoryImpl::DeleteSink(QTMSSink*& qtmssink) |
425 gint QTMSFactoryImpl::DeleteSink(QTMSSink*& qtmssink) |
461 { |
426 { |
462 TRACE_PRN_FN_ENT; |
427 TRACE_PRN_FN_ENT; |
463 __ASSERT_ALWAYS(qtmssink, PANIC(QTMS_RESULT_NULL_ARGUMENT)); |
428 __ASSERT_ALWAYS(qtmssink, PANIC(QTMS_RESULT_NULL_ARGUMENT)); |
464 |
429 |
465 gint ret(QTMS_RESULT_SUCCESS); |
430 gint ret(QTMS_RESULT_SUCCESS); |
466 QTMSSinkType sinktype; |
431 QTMSSinkType sinktype; |
467 ret = qtmssink->GetType(sinktype); |
432 ret = qtmssink->GetType(sinktype); |
468 switch (sinktype) |
433 switch (sinktype) { |
469 { |
434 case QTMS_SINK_CLIENT: |
470 case QTMS_SINK_CLIENT: |
435 { |
471 { |
436 delete (static_cast<QTMSClientSinkImpl*> (qtmssink)); |
472 delete (static_cast<QTMSClientSinkImpl*>(qtmssink)); |
437 qtmssink = NULL; |
473 qtmssink = NULL; |
438 } |
474 } |
439 break; |
475 break; |
440 case QTMS_SINK_MODEM: |
476 case QTMS_SINK_MODEM: |
441 { |
477 { |
442 delete (static_cast<QTMSModemSinkImpl*> (qtmssink)); |
478 delete (static_cast<QTMSModemSinkImpl*>(qtmssink)); |
443 qtmssink = NULL; |
479 qtmssink = NULL; |
444 } |
480 } |
445 break; |
481 break; |
446 case QTMS_SINK_SPEAKER: |
482 case QTMS_SINK_SPEAKER: |
447 { |
483 { |
448 delete (static_cast<QTMSSpeakerSinkImpl*> (qtmssink)); |
484 delete (static_cast<QTMSSpeakerSinkImpl*>(qtmssink)); |
449 qtmssink = NULL; |
485 qtmssink = NULL; |
450 } |
486 } |
451 break; |
487 break; |
452 default: |
488 default: |
453 ret = QTMS_RESULT_SINK_TYPE_NOT_SUPPORTED; |
489 ret = QTMS_RESULT_SINK_TYPE_NOT_SUPPORTED; |
454 break; |
490 break; |
455 } |
491 } |
456 TRACE_PRN_FN_EXT; |
492 TRACE_PRN_FN_EXT; |
457 return ret; |
493 return ret; |
458 } |
494 } |
|
495 |
459 |
496 gint QTMSFactoryImpl::CreateGlobalRouting(QTMSGlobalRouting*& qrouting) |
460 gint QTMSFactoryImpl::CreateGlobalRouting(QTMSGlobalRouting*& qrouting) |
497 { |
461 { |
498 TRACE_PRN_FN_ENT; |
462 TRACE_PRN_FN_ENT; |
499 gint ret(QTMS_RESULT_UNINITIALIZED_OBJECT); |
463 gint ret(QTMS_RESULT_UNINITIALIZED_OBJECT); |
500 |
464 |
501 TMS::TMSGlobalRouting* tmsrouting(NULL); |
465 TMS::TMSGlobalRouting* tmsrouting(NULL); |
502 if (iFactory) |
466 if (iFactory) { |
503 { |
|
504 ret = iFactory->CreateGlobalRouting(tmsrouting); |
467 ret = iFactory->CreateGlobalRouting(tmsrouting); |
505 |
468 |
506 if (ret == TMS_RESULT_SUCCESS) |
469 if (ret == TMS_RESULT_SUCCESS) { |
507 { |
|
508 ret = QTMSGlobalRoutingImpl::Create(qrouting, tmsrouting); |
470 ret = QTMSGlobalRoutingImpl::Create(qrouting, tmsrouting); |
509 } |
471 } |
510 } |
472 } |
511 TRACE_PRN_FN_EXT; |
473 TRACE_PRN_FN_EXT; |
512 return ret; |
474 return ret; |
513 } |
475 } |
514 |
476 |
515 gint QTMSFactoryImpl::DeleteGlobalRouting(QTMSGlobalRouting*& globalrouting) |
477 gint QTMSFactoryImpl::DeleteGlobalRouting(QTMSGlobalRouting*& globalrouting) |
516 { |
478 { |
517 TRACE_PRN_FN_ENT; |
479 TRACE_PRN_FN_ENT; |
518 gint ret(QTMS_RESULT_SUCCESS); |
480 gint ret(QTMS_RESULT_SUCCESS); |
519 delete (static_cast<QTMSGlobalRoutingImpl*>(globalrouting)); |
481 delete (static_cast<QTMSGlobalRoutingImpl*> (globalrouting)); |
520 globalrouting = NULL; |
482 globalrouting = NULL; |
521 TRACE_PRN_FN_EXT; |
483 TRACE_PRN_FN_EXT; |
522 return ret; |
484 return ret; |
523 } |
485 } |
524 |
486 |
525 gint QTMSFactoryImpl::CreateDTMF(QTMSStreamType streamtype, QTMSDTMF*& qdtmf) |
487 gint QTMSFactoryImpl::CreateDTMF(QTMSStreamType streamtype, QTMSDTMF*& qdtmf) |
526 { |
488 { |
527 TRACE_PRN_FN_ENT; |
489 TRACE_PRN_FN_ENT; |
528 gint ret(QTMS_RESULT_UNINITIALIZED_OBJECT); |
490 gint ret(QTMS_RESULT_UNINITIALIZED_OBJECT); |
529 |
491 |
530 TMS::TMSDTMF* tmsdtmf = NULL; |
492 TMS::TMSDTMF* tmsdtmf = NULL; |
531 |
493 |
532 if (iFactory) |
494 if (iFactory) { |
533 { |
|
534 ret = iFactory->CreateDTMF((TMSStreamType) streamtype, tmsdtmf); |
495 ret = iFactory->CreateDTMF((TMSStreamType) streamtype, tmsdtmf); |
535 |
496 |
536 if (ret == TMS_RESULT_SUCCESS) |
497 if (ret == TMS_RESULT_SUCCESS) { |
537 { |
|
538 ret = QTMSDTMFImpl::Create(qdtmf, tmsdtmf); |
498 ret = QTMSDTMFImpl::Create(qdtmf, tmsdtmf); |
539 } |
499 } |
540 } |
500 } |
541 TRACE_PRN_FN_EXT; |
501 TRACE_PRN_FN_EXT; |
542 return ret; |
502 return ret; |
543 } |
503 } |
544 |
504 |
545 gint QTMSFactoryImpl::DeleteDTMF(QTMSDTMF*& dtmf) |
505 gint QTMSFactoryImpl::DeleteDTMF(QTMSDTMF*& dtmf) |
546 { |
506 { |
547 TRACE_PRN_FN_ENT; |
507 TRACE_PRN_FN_ENT; |
548 gint ret(QTMS_RESULT_SUCCESS); |
508 gint ret(QTMS_RESULT_SUCCESS); |
549 delete (static_cast<QTMSDTMFImpl*>(dtmf)); |
509 delete (static_cast<QTMSDTMFImpl*> (dtmf)); |
550 dtmf = NULL; |
510 dtmf = NULL; |
551 TRACE_PRN_FN_EXT; |
511 TRACE_PRN_FN_EXT; |
552 return ret; |
512 return ret; |
553 } |
513 } |
554 |
514 |
555 gint QTMSFactoryImpl::CreateRingTonePlayer(QTMSRingTone*& rt) |
515 gint QTMSFactoryImpl::CreateRingTonePlayer(QTMSRingTone*& rt) |
556 { |
516 { |
557 TRACE_PRN_FN_ENT; |
517 TRACE_PRN_FN_ENT; |
558 gint ret(QTMS_RESULT_UNINITIALIZED_OBJECT); |
518 gint ret(QTMS_RESULT_UNINITIALIZED_OBJECT); |
559 |
519 |
560 TMS::TMSRingTone* tmsrt = NULL; |
520 TMS::TMSRingTone* tmsrt = NULL; |
561 |
521 |
562 if (iFactory) |
522 if (iFactory) { |
563 { |
|
564 ret = iFactory->CreateRingTonePlayer(tmsrt); |
523 ret = iFactory->CreateRingTonePlayer(tmsrt); |
565 |
524 |
566 if (ret == TMS_RESULT_SUCCESS) |
525 if (ret == TMS_RESULT_SUCCESS) { |
567 { |
|
568 ret = QTMSRingToneImpl::Create(rt, tmsrt); |
526 ret = QTMSRingToneImpl::Create(rt, tmsrt); |
569 } |
527 } |
570 } |
528 } |
571 TRACE_PRN_FN_EXT; |
529 TRACE_PRN_FN_EXT; |
572 return ret; |
530 return ret; |
573 } |
531 } |
574 |
532 |
575 gint QTMSFactoryImpl::DeleteRingTonePlayer(QTMSRingTone*& rt) |
533 gint QTMSFactoryImpl::DeleteRingTonePlayer(QTMSRingTone*& rt) |
576 { |
534 { |
577 TRACE_PRN_FN_ENT; |
535 TRACE_PRN_FN_ENT; |
578 gint ret(QTMS_RESULT_SUCCESS); |
536 gint ret(QTMS_RESULT_SUCCESS); |
579 delete (static_cast<QTMSRingToneImpl*>(rt)); |
537 delete (static_cast<QTMSRingToneImpl*> (rt)); |
580 rt = NULL; |
538 rt = NULL; |
581 TRACE_PRN_FN_EXT; |
539 TRACE_PRN_FN_EXT; |
582 return ret; |
540 return ret; |
583 } |
541 } |
584 |
542 |
585 gint QTMSFactoryImpl::CreateInbandTonePlayer(QTMSInbandTone*& qinbandtone) |
543 gint QTMSFactoryImpl::CreateInbandTonePlayer(QTMSInbandTone*& qinbandtone) |
586 { |
544 { |
587 TRACE_PRN_FN_ENT; |
545 TRACE_PRN_FN_ENT; |
588 gint ret(QTMS_RESULT_UNINITIALIZED_OBJECT); |
546 gint ret(QTMS_RESULT_UNINITIALIZED_OBJECT); |
589 |
547 |
590 TMS::TMSInbandTone* tmsinband = NULL; |
548 TMS::TMSInbandTone* tmsinband = NULL; |
591 if (iFactory) |
549 if (iFactory) { |
592 { |
|
593 ret = iFactory->CreateInbandTonePlayer(tmsinband); |
550 ret = iFactory->CreateInbandTonePlayer(tmsinband); |
594 |
551 |
595 if (ret == TMS_RESULT_SUCCESS) |
552 if (ret == TMS_RESULT_SUCCESS) { |
596 { |
|
597 ret = QTMSInbandToneImpl::Create(qinbandtone, tmsinband); |
553 ret = QTMSInbandToneImpl::Create(qinbandtone, tmsinband); |
598 } |
554 } |
599 } |
555 } |
600 TRACE_PRN_FN_EXT; |
556 TRACE_PRN_FN_EXT; |
601 return ret; |
557 return ret; |
602 } |
558 } |
603 |
559 |
604 gint QTMSFactoryImpl::DeleteInbandTonePlayer(QTMSInbandTone*& inbandtone) |
560 gint QTMSFactoryImpl::DeleteInbandTonePlayer(QTMSInbandTone*& inbandtone) |
605 { |
561 { |
606 TRACE_PRN_FN_ENT; |
562 TRACE_PRN_FN_ENT; |
607 gint ret(QTMS_RESULT_SUCCESS); |
563 gint ret(QTMS_RESULT_SUCCESS); |
608 delete (static_cast<QTMSInbandToneImpl*>(inbandtone)); |
564 delete (static_cast<QTMSInbandToneImpl*> (inbandtone)); |
609 inbandtone = NULL; |
565 inbandtone = NULL; |
610 TRACE_PRN_FN_EXT; |
566 TRACE_PRN_FN_EXT; |
611 return ret; |
567 return ret; |
612 } |
568 } |
613 |
569 |
614 // End of file |
570 // End of file |