|
1 // Copyright (c) 2003-2009 Nokia Corporation and/or its subsidiary(-ies). |
|
2 // All rights reserved. |
|
3 // This component and the accompanying materials are made available |
|
4 // under the terms of "Eclipse Public License v1.0" |
|
5 // which accompanies this distribution, and is available |
|
6 // at the URL "http://www.eclipse.org/legal/epl-v10.html". |
|
7 // |
|
8 // Initial Contributors: |
|
9 // Nokia Corporation - initial contribution. |
|
10 // |
|
11 // Contributors: |
|
12 // |
|
13 // Description: |
|
14 // Name : SdpCodecParseUtil.cpp |
|
15 // Part of : SDP Codec |
|
16 // Version : 1.0 |
|
17 // |
|
18 |
|
19 |
|
20 |
|
21 #include "SdpCodecParseUtil.h" |
|
22 #include "sdpcodecstringconstants.h" |
|
23 #include "_sdpdefs.h" |
|
24 #include <s32strm.h> |
|
25 #include "SdpUtil.h" |
|
26 #include "SdpTimeField.h" |
|
27 #include "SdpBandwidthField.h" |
|
28 #include "SdpAttributeField.h" |
|
29 #include "SdpMediaField.h" |
|
30 #include "SdpConnectionField.h" |
|
31 #include "SdpKeyField.h" |
|
32 #include "SdpOriginField.h" |
|
33 #include "SdpRepeatField.h" |
|
34 #include "SdpCodecErr.h" |
|
35 #include "SdpCodecConstants.h" |
|
36 #include "uri8.h" |
|
37 #include "uriutilscommon.h" |
|
38 #include "badesca.h" |
|
39 |
|
40 // ---------------------------------------------------------------------------- |
|
41 // CSdpCodecParseUtil::NewL |
|
42 // ---------------------------------------------------------------------------- |
|
43 // |
|
44 CSdpCodecParseUtil* |
|
45 CSdpCodecParseUtil::NewL(RStringPool aPool, const TDesC8& aValue,TInt aErrCode) |
|
46 { |
|
47 CSdpCodecParseUtil* obj = CSdpCodecParseUtil::NewLC(aPool, aValue,aErrCode); |
|
48 CleanupStack::Pop();//obj |
|
49 return obj; |
|
50 } |
|
51 |
|
52 // ---------------------------------------------------------------------------- |
|
53 // CSdpCodecParseUtil::NewLC |
|
54 // ---------------------------------------------------------------------------- |
|
55 // |
|
56 CSdpCodecParseUtil* |
|
57 CSdpCodecParseUtil::NewLC(RStringPool aPool, const TDesC8& aValue,TInt aErrCode) |
|
58 { |
|
59 CSdpCodecParseUtil* obj = new(ELeave)CSdpCodecParseUtil; |
|
60 CleanupStack::PushL(obj); |
|
61 obj->ConstructL(aPool, aValue,aErrCode); |
|
62 return obj; |
|
63 } |
|
64 |
|
65 // --------------------------------------------------------------------------- |
|
66 // CSdpCodecParseUtil::FieldLineValueL |
|
67 // --------------------------------------------------------------------------- |
|
68 // |
|
69 TPtrC8 CSdpCodecParseUtil::FieldLineValueL(const TDesC8& aValue) |
|
70 { |
|
71 __ASSERT_ALWAYS (aValue.Length() > 0, User::Leave(KErrArgument)); |
|
72 TPtrC8 lineStartBuf(aValue.Mid(2)); |
|
73 TInt lineEndPosition = lineStartBuf.Locate('\r'); |
|
74 if(lineEndPosition == KErrNotFound) |
|
75 { |
|
76 lineEndPosition = lineStartBuf.Locate('\n'); |
|
77 } |
|
78 return lineStartBuf.Left(lineEndPosition); |
|
79 } |
|
80 |
|
81 // --------------------------------------------------------------------------- |
|
82 // CSdpCodecParseUtil::CheckFieldNameL |
|
83 // --------------------------------------------------------------------------- |
|
84 // |
|
85 RArray<TPtrC8> CSdpCodecParseUtil::CheckFieldNameL(RStringPool aPool, |
|
86 TInt aIndex, |
|
87 const TDesC8& aValue, |
|
88 TInt aErrCode) |
|
89 { |
|
90 if(!aValue.Length()) |
|
91 { |
|
92 User::Leave(KErrArgument); |
|
93 } |
|
94 RArray<TPtrC8> elementArray = SdpUtil::GetElementsFromLineL(aValue, |
|
95 aErrCode); |
|
96 CleanupClosePushL(elementArray); |
|
97 RStringF name = aPool.OpenFStringL(elementArray[0]); |
|
98 CleanupClosePushL(name); |
|
99 if(name!=(aPool.StringF(aIndex, SdpCodecStringConstants::Table))) |
|
100 { |
|
101 User::Leave(KErrArgument);//parsererror |
|
102 } |
|
103 CleanupStack::Pop(2);//name, elementArray |
|
104 name.Close(); |
|
105 return elementArray; |
|
106 } |
|
107 |
|
108 // --------------------------------------------------------------------------- |
|
109 // CSdpCodecParseUtil::CheckOptionalFieldNameL |
|
110 // --------------------------------------------------------------------------- |
|
111 // |
|
112 RArray<TPtrC8> CSdpCodecParseUtil::CheckOptionalFieldNameL(RStringPool aPool, |
|
113 TInt aIndex, |
|
114 const TDesC8& aValue, |
|
115 TInt aErrCode) |
|
116 { |
|
117 RArray<TPtrC8> elementArray; |
|
118 elementArray.Reset(); |
|
119 if(aValue.Length()) |
|
120 { |
|
121 elementArray = SdpUtil::GetElementsFromLineL(aValue, aErrCode); |
|
122 CleanupClosePushL(elementArray); |
|
123 RStringF name = aPool.OpenFStringL(elementArray[0]); |
|
124 CleanupClosePushL(name); |
|
125 if(name!=(aPool.StringF(aIndex, SdpCodecStringConstants::Table))) |
|
126 { |
|
127 elementArray.Reset(); |
|
128 } |
|
129 CleanupStack::Pop(2);//name, elementArray |
|
130 name.Close(); |
|
131 } |
|
132 return elementArray; |
|
133 } |
|
134 |
|
135 // ---------------------------------------------------------------------------- |
|
136 // CSdpCodecParseUtil::CSdpCodecParseUtil |
|
137 // ---------------------------------------------------------------------------- |
|
138 // |
|
139 CSdpCodecParseUtil::CSdpCodecParseUtil() |
|
140 { |
|
141 |
|
142 } |
|
143 |
|
144 // ---------------------------------------------------------------------------- |
|
145 // CSdpCodecParseUtil::~CSdpCodecParseUtil |
|
146 // ---------------------------------------------------------------------------- |
|
147 // |
|
148 CSdpCodecParseUtil::~CSdpCodecParseUtil() |
|
149 { |
|
150 iLineArray.Reset(); |
|
151 iElementArray.Reset(); |
|
152 if(iTimeFields) |
|
153 { |
|
154 iTimeFields->ResetAndDestroy(); |
|
155 delete iTimeFields; |
|
156 } |
|
157 |
|
158 if(iBandwidthFields) |
|
159 { |
|
160 iBandwidthFields->ResetAndDestroy(); |
|
161 delete iBandwidthFields; |
|
162 } |
|
163 |
|
164 if(iAttributeFields) |
|
165 { |
|
166 iAttributeFields->ResetAndDestroy(); |
|
167 delete iAttributeFields; |
|
168 } |
|
169 |
|
170 if(iMediaFields) |
|
171 { |
|
172 iMediaFields->ResetAndDestroy(); |
|
173 delete iMediaFields; |
|
174 } |
|
175 |
|
176 if(iConnectionFields) |
|
177 { |
|
178 iConnectionFields->ResetAndDestroy(); |
|
179 delete iConnectionFields; |
|
180 } |
|
181 |
|
182 if(iEmailFields) |
|
183 { |
|
184 iEmailFields->Reset(); |
|
185 delete iEmailFields; |
|
186 } |
|
187 |
|
188 if(iPhoneFields) |
|
189 { |
|
190 iPhoneFields->Reset(); |
|
191 delete iPhoneFields; |
|
192 } |
|
193 delete iToken; |
|
194 } |
|
195 |
|
196 // ---------------------------------------------------------------------------- |
|
197 // CSdpCodecParseUtil::ConstructL |
|
198 // ---------------------------------------------------------------------------- |
|
199 // |
|
200 void CSdpCodecParseUtil::ConstructL(RStringPool aPool, const TDesC8& aValue, |
|
201 TInt aErrCode) |
|
202 { |
|
203 iPool = aPool; |
|
204 iData.Set(aValue); |
|
205 iToken = KNullDesC8().AllocL(); |
|
206 iEmailFields = new(ELeave)CDesC8ArraySeg(1); |
|
207 iPhoneFields = new(ELeave)CDesC8ArraySeg(1); |
|
208 iBandwidthFields = new(ELeave)RPointerArray<CSdpBandwidthField>; |
|
209 iTimeFields = new(ELeave)RPointerArray<CSdpTimeField>; |
|
210 iAttributeFields = new(ELeave)RPointerArray<CSdpAttributeField>; |
|
211 iMediaFields = new(ELeave)RPointerArray<CSdpMediaField>; |
|
212 iConnectionFields = new(ELeave)RPointerArray<CSdpConnectionField>; |
|
213 iLineArray = SdpUtil::DivideToLinesL(aValue,aErrCode); |
|
214 } |
|
215 |
|
216 // --------------------------------------------------------------------------- |
|
217 // CSdpCodecParseUtil::ParseSessionVersionL |
|
218 // --------------------------------------------------------------------------- |
|
219 // |
|
220 TUint CSdpCodecParseUtil::ParseSessionVersionL(TInt aErrCode) |
|
221 { |
|
222 TUint sdpVersion = 0; |
|
223 if(iLineArray.Count()) |
|
224 { |
|
225 iElementArray = CSdpCodecParseUtil::CheckFieldNameL(iPool, |
|
226 SdpCodecStringConstants::EVersion, |
|
227 iLineArray[0],aErrCode); |
|
228 if(iElementArray.Count() > 1) |
|
229 { |
|
230 TLex8 lex(iElementArray[1]); |
|
231 if(lex.Val(sdpVersion) == KErrNone) |
|
232 { |
|
233 iLineArray.Remove(0); |
|
234 iElementArray.Reset(); |
|
235 } |
|
236 else |
|
237 { |
|
238 User::Leave(KErrSdpCodecVersionField); |
|
239 } |
|
240 } |
|
241 } |
|
242 else |
|
243 { |
|
244 User::Leave(KErrSdpCodecVersionField); |
|
245 } |
|
246 return sdpVersion; |
|
247 } |
|
248 |
|
249 // --------------------------------------------------------------------------- |
|
250 // CSdpCodecParseUtil::ParseSessionOwnerL |
|
251 // --------------------------------------------------------------------------- |
|
252 // |
|
253 CSdpOriginField* CSdpCodecParseUtil::ParseSessionOwnerL(TInt aErrCode) |
|
254 { |
|
255 CSdpOriginField* sdpOriginField = NULL; |
|
256 if(iLineArray.Count()) |
|
257 { |
|
258 iElementArray = CSdpCodecParseUtil::CheckFieldNameL(iPool, |
|
259 SdpCodecStringConstants::EOrigin, |
|
260 iLineArray[0],aErrCode); |
|
261 sdpOriginField = |
|
262 CSdpOriginField::DecodeL(iLineArray[0]); |
|
263 iElementArray.Reset(); |
|
264 iLineArray.Remove(0); |
|
265 } |
|
266 else |
|
267 { |
|
268 User::Leave(KErrSdpCodecOriginField); |
|
269 } |
|
270 return sdpOriginField; |
|
271 } |
|
272 |
|
273 // --------------------------------------------------------------------------- |
|
274 // CSdpCodecParseUtil::ParseSessionNameL |
|
275 // --------------------------------------------------------------------------- |
|
276 // |
|
277 const TDesC8& CSdpCodecParseUtil::ParseSessionNameL(TInt aErrCode) |
|
278 { |
|
279 delete iToken; |
|
280 iToken = 0; |
|
281 iToken = KNullDesC8().AllocL(); |
|
282 if(iLineArray.Count()) |
|
283 { |
|
284 if(iLineArray[0].Length() < 6 && |
|
285 (iLineArray[0].CompareF(_L8("s= \r\n")) == 0 || |
|
286 iLineArray[0].CompareF(_L8("s= \n")) == 0 )) |
|
287 { |
|
288 iLineArray.Remove(0); |
|
289 delete iToken; |
|
290 iToken = 0; |
|
291 iToken = _L8(" ").AllocL(); |
|
292 return *iToken; |
|
293 } |
|
294 iElementArray = CSdpCodecParseUtil::CheckFieldNameL(iPool, |
|
295 SdpCodecStringConstants::ESession, |
|
296 iLineArray[0],aErrCode); |
|
297 __ASSERT_ALWAYS (iElementArray.Count() > 1, |
|
298 User::Leave(KErrSdpCodecSessionField)); |
|
299 delete iToken; |
|
300 iToken = 0; |
|
301 iToken = (CSdpCodecParseUtil::FieldLineValueL(iLineArray[0])).AllocL(); |
|
302 iElementArray.Reset(); |
|
303 iLineArray.Remove(0); |
|
304 } |
|
305 else |
|
306 { |
|
307 User::Leave(KErrSdpCodecSessionField); |
|
308 } |
|
309 return *iToken; |
|
310 } |
|
311 |
|
312 // --------------------------------------------------------------------------- |
|
313 // CSdpCodecParseUtil::ParseInformationL |
|
314 // --------------------------------------------------------------------------- |
|
315 // |
|
316 const TDesC8& CSdpCodecParseUtil::ParseInformationL(TInt aErrCode) |
|
317 { |
|
318 delete iToken; |
|
319 iToken = 0; |
|
320 iToken = KNullDesC8().AllocL(); |
|
321 if(iLineArray.Count()) |
|
322 { |
|
323 iElementArray = CSdpCodecParseUtil::CheckOptionalFieldNameL(iPool, |
|
324 SdpCodecStringConstants::EInfo, |
|
325 iLineArray[0],aErrCode); |
|
326 |
|
327 if(iElementArray.Count()) |
|
328 { |
|
329 __ASSERT_ALWAYS (iElementArray.Count() > 1, |
|
330 User::Leave(KErrSdpCodecInfoField)); |
|
331 delete iToken; |
|
332 iToken = 0; |
|
333 iToken = |
|
334 (CSdpCodecParseUtil::FieldLineValueL(iLineArray[0])).AllocL(); |
|
335 iElementArray.Reset(); |
|
336 iLineArray.Remove(0); |
|
337 } |
|
338 } |
|
339 return *iToken; |
|
340 } |
|
341 |
|
342 // --------------------------------------------------------------------------- |
|
343 // CSdpCodecParseUtil::ParseUriL |
|
344 // --------------------------------------------------------------------------- |
|
345 // |
|
346 CUri8* CSdpCodecParseUtil::ParseUriL(TInt aErrCode) |
|
347 { |
|
348 CUri8* uri = 0; |
|
349 if(iLineArray.Count()) |
|
350 { |
|
351 iElementArray = CSdpCodecParseUtil::CheckOptionalFieldNameL(iPool, |
|
352 SdpCodecStringConstants::EUri, |
|
353 iLineArray[0],aErrCode); |
|
354 if(iElementArray.Count()) |
|
355 { |
|
356 __ASSERT_ALWAYS (iElementArray.Count() == 2, |
|
357 User::Leave(KErrSdpCodecUriField)); |
|
358 TUriParser8 parser; |
|
359 User::LeaveIfError(parser.Parse(iElementArray[1])); |
|
360 uri = CUri8::NewL(parser); |
|
361 iElementArray.Reset(); |
|
362 iLineArray.Remove(0); |
|
363 } |
|
364 } |
|
365 return uri; |
|
366 } |
|
367 |
|
368 // --------------------------------------------------------------------------- |
|
369 // CSdpCodecParseUtil::ParseEmailL |
|
370 // --------------------------------------------------------------------------- |
|
371 // |
|
372 CDesC8ArraySeg* CSdpCodecParseUtil::ParseEmailL(TInt aErrCode) |
|
373 { |
|
374 TBool endloop = EFalse; |
|
375 while (iLineArray.Count() && !endloop) |
|
376 { |
|
377 iElementArray = CSdpCodecParseUtil::CheckOptionalFieldNameL(iPool, |
|
378 SdpCodecStringConstants::EEmail, |
|
379 iLineArray[0],aErrCode); |
|
380 if(iElementArray.Count()) |
|
381 { |
|
382 __ASSERT_ALWAYS (iElementArray.Count() > 1, |
|
383 User::Leave(KErrSdpCodecEmailField)); |
|
384 iEmailFields->AppendL( |
|
385 CSdpCodecParseUtil::FieldLineValueL(iLineArray[0])); |
|
386 iElementArray.Reset(); |
|
387 iLineArray.Remove(0); |
|
388 } |
|
389 else |
|
390 { |
|
391 endloop = ETrue; |
|
392 } |
|
393 } |
|
394 CDesC8ArraySeg* array = iEmailFields; |
|
395 iEmailFields = 0; |
|
396 return array; |
|
397 } |
|
398 |
|
399 // --------------------------------------------------------------------------- |
|
400 // CSdpCodecParseUtil::ParsePhoneL |
|
401 // --------------------------------------------------------------------------- |
|
402 // |
|
403 CDesC8ArraySeg* CSdpCodecParseUtil::ParsePhoneL(TInt aErrCode) |
|
404 { |
|
405 TBool endloop = EFalse; |
|
406 while (iLineArray.Count() && !endloop) |
|
407 { |
|
408 iElementArray = CSdpCodecParseUtil::CheckOptionalFieldNameL(iPool, |
|
409 SdpCodecStringConstants::EPhone, |
|
410 iLineArray[0],aErrCode); |
|
411 if(iElementArray.Count() != 0) |
|
412 { |
|
413 __ASSERT_ALWAYS (iElementArray.Count() > 1, |
|
414 User::Leave(KErrSdpCodecPhoneField)); |
|
415 iPhoneFields->AppendL( |
|
416 CSdpCodecParseUtil::FieldLineValueL(iLineArray[0])); |
|
417 iElementArray.Reset(); |
|
418 iLineArray.Remove(0); |
|
419 } |
|
420 else |
|
421 { |
|
422 endloop = ETrue; |
|
423 } |
|
424 } |
|
425 CDesC8ArraySeg* array = iPhoneFields; |
|
426 iPhoneFields = 0; |
|
427 return array; |
|
428 } |
|
429 |
|
430 // --------------------------------------------------------------------------- |
|
431 // CSdpCodecParseUtil::ParseConnectionL |
|
432 // --------------------------------------------------------------------------- |
|
433 // |
|
434 CSdpConnectionField* CSdpCodecParseUtil::ParseConnectionL(TInt aErrCode) |
|
435 { |
|
436 CSdpConnectionField* sdpConnectionField = NULL; |
|
437 if(iLineArray.Count()) |
|
438 { |
|
439 iElementArray = CSdpCodecParseUtil::CheckOptionalFieldNameL(iPool, |
|
440 SdpCodecStringConstants::EConnection, |
|
441 iLineArray[0],aErrCode); |
|
442 if(iElementArray.Count()) |
|
443 { |
|
444 sdpConnectionField = |
|
445 CSdpConnectionField::DecodeL(iLineArray[0]); |
|
446 iElementArray.Reset(); |
|
447 iLineArray.Remove(0); |
|
448 } |
|
449 } |
|
450 return sdpConnectionField; |
|
451 } |
|
452 |
|
453 // --------------------------------------------------------------------------- |
|
454 // CSdpCodecParseUtil::ParseBandwidthL |
|
455 // --------------------------------------------------------------------------- |
|
456 // |
|
457 RPointerArray<CSdpBandwidthField>* |
|
458 CSdpCodecParseUtil::ParseBandwidthL(TInt aErrCode) |
|
459 { |
|
460 TBool endloop = EFalse; |
|
461 CSdpBandwidthField* bandwidth = NULL; |
|
462 while (iLineArray.Count() && !endloop) |
|
463 { |
|
464 iElementArray = |
|
465 CSdpCodecParseUtil::CheckOptionalFieldNameL( |
|
466 iPool,SdpCodecStringConstants::EBandwidth, |
|
467 iLineArray[0],aErrCode); |
|
468 if(iElementArray.Count()) |
|
469 { |
|
470 bandwidth = CSdpBandwidthField::DecodeLC(iLineArray[0]); |
|
471 iBandwidthFields->AppendL(bandwidth); |
|
472 CleanupStack::Pop(bandwidth); |
|
473 iElementArray.Reset(); |
|
474 iLineArray.Remove(0); |
|
475 } |
|
476 else |
|
477 { |
|
478 endloop = ETrue; |
|
479 } |
|
480 } |
|
481 RPointerArray<CSdpBandwidthField>* array = iBandwidthFields; |
|
482 iBandwidthFields = 0; |
|
483 return array; |
|
484 } |
|
485 |
|
486 // --------------------------------------------------------------------------- |
|
487 // CSdpCodecParseUtil::ParseConnectionFieldsL |
|
488 // --------------------------------------------------------------------------- |
|
489 // |
|
490 RPointerArray<CSdpConnectionField>* |
|
491 CSdpCodecParseUtil::ParseConnectionFieldsL(TInt aErrCode) |
|
492 { |
|
493 TBool endloop = EFalse; |
|
494 CSdpConnectionField* connection = NULL; |
|
495 while(iLineArray.Count() && !endloop) |
|
496 { |
|
497 iElementArray = |
|
498 CSdpCodecParseUtil::CheckOptionalFieldNameL( |
|
499 iPool,SdpCodecStringConstants::EConnection, |
|
500 iLineArray[0],aErrCode); |
|
501 if(iElementArray.Count()) |
|
502 { |
|
503 connection = CSdpConnectionField::DecodeLC(iLineArray[0]); |
|
504 iConnectionFields->AppendL(connection); |
|
505 CleanupStack::Pop(connection); |
|
506 iElementArray.Reset(); |
|
507 iLineArray.Remove(0); |
|
508 } |
|
509 else |
|
510 { |
|
511 endloop = ETrue; |
|
512 } |
|
513 } |
|
514 RPointerArray<CSdpConnectionField>* array = iConnectionFields; |
|
515 iConnectionFields = 0; |
|
516 return array; |
|
517 } |
|
518 |
|
519 // --------------------------------------------------------------------------- |
|
520 // CSdpCodecParseUtil::ParseTimeFieldL |
|
521 // --------------------------------------------------------------------------- |
|
522 // |
|
523 RPointerArray<CSdpTimeField>* |
|
524 CSdpCodecParseUtil::ParseTimeFieldL(TInt aErrCode) |
|
525 { |
|
526 if(iLineArray.Count()) |
|
527 { |
|
528 iElementArray = CSdpCodecParseUtil::CheckFieldNameL(iPool, |
|
529 SdpCodecStringConstants::ETime, |
|
530 iLineArray[0],aErrCode); |
|
531 iElementArray.Reset(); |
|
532 CSdpTimeField* timefield = NULL; |
|
533 CSdpRepeatField* repeatfield = NULL; |
|
534 TBool endloop = EFalse; |
|
535 while(iLineArray.Count() && !endloop) |
|
536 { |
|
537 iElementArray = CSdpCodecParseUtil::CheckOptionalFieldNameL(iPool, |
|
538 SdpCodecStringConstants::ETime, |
|
539 iLineArray[0],aErrCode); |
|
540 if(iElementArray.Count()) |
|
541 { |
|
542 timefield = CSdpTimeField::DecodeLC(iLineArray[0]); |
|
543 User::LeaveIfError(iTimeFields->Append(timefield)); |
|
544 CleanupStack::Pop();//timefield |
|
545 iElementArray.Reset(); |
|
546 iLineArray.Remove(0); |
|
547 TBool repeatEnd = EFalse; |
|
548 while(iLineArray.Count() && !repeatEnd) |
|
549 { |
|
550 iElementArray = |
|
551 CSdpCodecParseUtil::CheckOptionalFieldNameL(iPool, |
|
552 SdpCodecStringConstants::ERepeat, |
|
553 iLineArray[0],aErrCode); |
|
554 if(iElementArray.Count()) |
|
555 { |
|
556 repeatfield = |
|
557 CSdpRepeatField::DecodeLC(iLineArray[0]); |
|
558 User::LeaveIfError((timefield->RepeatFields()).Append( |
|
559 repeatfield)); |
|
560 CleanupStack::Pop();//repeatfield |
|
561 repeatfield = 0; |
|
562 iElementArray.Reset(); |
|
563 iLineArray.Remove(0); |
|
564 } |
|
565 else |
|
566 { |
|
567 repeatEnd = ETrue; |
|
568 } |
|
569 } |
|
570 timefield = 0; |
|
571 } |
|
572 else |
|
573 { |
|
574 endloop = ETrue; |
|
575 } |
|
576 } |
|
577 } |
|
578 RPointerArray<CSdpTimeField>* array = iTimeFields; |
|
579 iTimeFields = 0; |
|
580 return array; |
|
581 } |
|
582 |
|
583 // --------------------------------------------------------------------------- |
|
584 // CSdpCodecParseUtil::ParseZoneAdjustmentL |
|
585 // --------------------------------------------------------------------------- |
|
586 // |
|
587 const TDesC8& CSdpCodecParseUtil::ParseZoneAdjustmentL(TInt aErrCode) |
|
588 { |
|
589 delete iToken; |
|
590 iToken = 0; |
|
591 iToken = KNullDesC8().AllocL(); |
|
592 if(iLineArray.Count()) |
|
593 { |
|
594 iElementArray = CSdpCodecParseUtil::CheckOptionalFieldNameL(iPool, |
|
595 SdpCodecStringConstants::EZone, |
|
596 iLineArray[0],aErrCode); |
|
597 if(iElementArray.Count()) |
|
598 { |
|
599 __ASSERT_ALWAYS (iElementArray.Count() > 1, |
|
600 User::Leave(KErrSdpCodecZoneField)); |
|
601 delete iToken; |
|
602 iToken = 0; |
|
603 iToken = |
|
604 (CSdpCodecParseUtil::FieldLineValueL(iLineArray[0])).AllocL(); |
|
605 iElementArray.Reset(); |
|
606 iLineArray.Remove(0); |
|
607 } |
|
608 } |
|
609 return *iToken; |
|
610 } |
|
611 |
|
612 // --------------------------------------------------------------------------- |
|
613 // CSdpCodecParseUtil::ParseEncryptionKeyL |
|
614 // --------------------------------------------------------------------------- |
|
615 // |
|
616 CSdpKeyField* CSdpCodecParseUtil::ParseEncryptionKeyL(TInt aErrCode) |
|
617 { |
|
618 CSdpKeyField* sdpKeyField = NULL; |
|
619 if(iLineArray.Count()) |
|
620 { |
|
621 iElementArray = CSdpCodecParseUtil::CheckOptionalFieldNameL(iPool, |
|
622 SdpCodecStringConstants::EKey, |
|
623 iLineArray[0],aErrCode); |
|
624 if(iElementArray.Count()) |
|
625 { |
|
626 __ASSERT_ALWAYS (iElementArray.Count() > 1, |
|
627 User::Leave(KErrSdpCodecKeyField)); |
|
628 sdpKeyField = CSdpKeyField::DecodeL(iLineArray[0]); |
|
629 iElementArray.Reset(); |
|
630 iLineArray.Remove(0); |
|
631 } |
|
632 } |
|
633 return sdpKeyField; |
|
634 } |
|
635 |
|
636 // --------------------------------------------------------------------------- |
|
637 // CSdpCodecParseUtil::ParseAttributeFieldL |
|
638 // --------------------------------------------------------------------------- |
|
639 // |
|
640 RPointerArray<CSdpAttributeField>* |
|
641 CSdpCodecParseUtil::ParseAttributeFieldL(TInt aErrCode) |
|
642 { |
|
643 TBool endloop = EFalse; |
|
644 CSdpAttributeField* attributefield = NULL; |
|
645 while(iLineArray.Count() && !endloop) |
|
646 { |
|
647 iElementArray = CSdpCodecParseUtil::CheckOptionalFieldNameL(iPool, |
|
648 SdpCodecStringConstants::EAttribute, |
|
649 iLineArray[0],aErrCode); |
|
650 if(iElementArray.Count()) |
|
651 { |
|
652 attributefield = |
|
653 CSdpAttributeField::DecodeLC(iLineArray[0]); |
|
654 User::LeaveIfError(iAttributeFields->Append(attributefield)); |
|
655 CleanupStack::Pop();//attributefield |
|
656 attributefield = NULL; |
|
657 iElementArray.Reset(); |
|
658 iLineArray.Remove(0); |
|
659 } |
|
660 else |
|
661 { |
|
662 endloop = ETrue; |
|
663 } |
|
664 } |
|
665 RPointerArray<CSdpAttributeField>* array = iAttributeFields; |
|
666 iAttributeFields = 0; |
|
667 return array; |
|
668 } |
|
669 |
|
670 // --------------------------------------------------------------------------- |
|
671 // CSdpCodecParseUtil::ParseMediaLevelL |
|
672 // --------------------------------------------------------------------------- |
|
673 // |
|
674 RPointerArray<CSdpMediaField>* |
|
675 CSdpCodecParseUtil::ParseMediaLevelL() |
|
676 { |
|
677 RStringF headername = iPool.StringF( SdpCodecStringConstants::EMedia, |
|
678 SdpCodecStringConstants::Table ); |
|
679 TInt linestartPosition = 0; |
|
680 TInt lineEndPosition = 0; |
|
681 CSdpMediaField* mediafield = NULL; |
|
682 TBool endloop = EFalse; |
|
683 while(iData.Length() > 0 && !endloop) |
|
684 { |
|
685 linestartPosition = iData.FindF(headername.DesC()); |
|
686 if(linestartPosition != KErrNotFound) |
|
687 { |
|
688 TPtrC8 firstline(iData.Mid(linestartPosition)); |
|
689 TPtrC8 templine(iData.Mid(linestartPosition + 1)); |
|
690 HBufC8* searchString = |
|
691 HBufC8::NewLC(KCRLFStr().Length() + |
|
692 headername.DesC().Length()); |
|
693 TPtr8 strPtr(searchString->Des()); |
|
694 strPtr.Append(KCRLFStr); |
|
695 strPtr.Append(headername.DesC()); |
|
696 lineEndPosition = templine.FindF(strPtr); |
|
697 CleanupStack::PopAndDestroy(searchString); |
|
698 if(lineEndPosition == KErrNotFound) |
|
699 { |
|
700 mediafield = |
|
701 CSdpMediaField::DecodeLC(iData.Mid(linestartPosition)); |
|
702 User::LeaveIfError(iMediaFields->Append(mediafield)); |
|
703 CleanupStack::Pop();//mediafield |
|
704 mediafield = 0; |
|
705 iElementArray.Reset(); |
|
706 iLineArray.Reset(); |
|
707 endloop = ETrue; |
|
708 } |
|
709 else |
|
710 { |
|
711 mediafield = |
|
712 CSdpMediaField::DecodeLC(firstline.Left( |
|
713 lineEndPosition+1+KCRLFStr().Length())); |
|
714 User::LeaveIfError(iMediaFields->Append(mediafield)); |
|
715 CleanupStack::Pop();//mediafield |
|
716 mediafield = 0; |
|
717 iData.Set(firstline.Mid(lineEndPosition+1)); |
|
718 } |
|
719 } |
|
720 else |
|
721 { |
|
722 endloop = ETrue; |
|
723 } |
|
724 } |
|
725 RPointerArray<CSdpMediaField>* array = iMediaFields; |
|
726 iMediaFields = 0; |
|
727 return array; |
|
728 } |
|
729 |
|
730 // --------------------------------------------------------------------------- |
|
731 // CSdpCodecParseUtil::FirstLineArrayElementL |
|
732 // --------------------------------------------------------------------------- |
|
733 // |
|
734 RArray<TPtrC8> CSdpCodecParseUtil::FirstLineArrayElementL(RStringPool aPool, |
|
735 TInt aIndex, |
|
736 TInt aErrCode) |
|
737 { |
|
738 if(!iLineArray.Count()) |
|
739 { |
|
740 User::Leave(aErrCode); |
|
741 } |
|
742 RArray<TPtrC8> elementArray = |
|
743 SdpUtil::GetElementsFromLineL(iLineArray[0],aErrCode); |
|
744 CleanupClosePushL(elementArray); |
|
745 RStringF name = aPool.OpenFStringL(elementArray[0]); |
|
746 CleanupClosePushL(name); |
|
747 if(name!=(aPool.StringF(aIndex, SdpCodecStringConstants::Table))) |
|
748 { |
|
749 User::Leave(aErrCode);//parsererror |
|
750 } |
|
751 CleanupStack::Pop(2);//name, elementArray |
|
752 name.Close(); |
|
753 return elementArray; |
|
754 } |
|
755 |
|
756 // --------------------------------------------------------------------------- |
|
757 // CSdpCodecParseUtil::LineArray |
|
758 // --------------------------------------------------------------------------- |
|
759 // |
|
760 RArray<TPtrC8>& CSdpCodecParseUtil::LineArray() |
|
761 { |
|
762 return iLineArray; |
|
763 } |