1 /* |
|
2 * Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies). |
|
3 * All rights reserved. |
|
4 * This component and the accompanying materials are made available |
|
5 * under the terms of "Eclipse Public License v1.0" |
|
6 * which accompanies this distribution, and is available |
|
7 * at the URL "http://www.eclipse.org/legal/epl-v10.html". |
|
8 * |
|
9 * Initial Contributors: |
|
10 * Nokia Corporation - initial contribution. |
|
11 * |
|
12 * Contributors: |
|
13 * |
|
14 * Description: |
|
15 */ |
|
16 |
|
17 // INCLUDE FILES |
|
18 #include <e32base.h> |
|
19 #include <badesca.h> |
|
20 #include <e32def.h> |
|
21 #include <s32file.h> |
|
22 #include <msvids.h> |
|
23 #include <mtmdef.h> |
|
24 //#include <eikenv.h> |
|
25 #include <apgcli.h> |
|
26 #include <CMsvMimeHeaders.h> |
|
27 #include <AknNoteWrappers.h> |
|
28 |
|
29 #include <mmsservercommon.h> |
|
30 #include "mmsconst.h" |
|
31 #include "mmsclient.h" |
|
32 #include "mmsheaders.h" |
|
33 #include "mmsreadfile.h" |
|
34 #include "mmsmmboxviewheaders.h" |
|
35 #include "mmsmmboxmessageheaders.h" |
|
36 #include "mmsmmboxflags.h" |
|
37 #include "mmssettings.h" |
|
38 |
|
39 |
|
40 // EXTERNAL DATA STRUCTURES |
|
41 |
|
42 // EXTERNAL FUNCTION PROTOTYPES |
|
43 |
|
44 // CONSTANTS |
|
45 const TInt KMmsGranularity = 8; |
|
46 _LIT( K1970, "19700000:000000.000000" ); // 1-Jan 1970 0:00:00 |
|
47 |
|
48 |
|
49 // MACROS |
|
50 |
|
51 // LOCAL CONSTANTS AND MACROS |
|
52 |
|
53 // MODULE DATA STRUCTURES |
|
54 |
|
55 // LOCAL FUNCTION PROTOTYPES |
|
56 |
|
57 // ==================== LOCAL FUNCTIONS ==================== |
|
58 |
|
59 |
|
60 // ================= MEMBER FUNCTIONS ======================= |
|
61 |
|
62 |
|
63 // C++ default constructor can NOT contain any code, that |
|
64 // might leave. |
|
65 // |
|
66 CMmsReadFile::CMmsReadFile() |
|
67 { |
|
68 // all member variables in a class derived from CBase |
|
69 // are automatically set to 0. |
|
70 } |
|
71 |
|
72 |
|
73 // |
|
74 void CMmsReadFile::ConstructL(RFs& aFs, RFileReadStream& aReadStream ) |
|
75 { |
|
76 // iRowBuffer = HBufC8::NewMaxL( 500 ); // Max row length!!!! |
|
77 iFs = aFs; |
|
78 iReader = &aReadStream; |
|
79 iByteBuffer = HBufC8::NewL( DefaultBufLen ); |
|
80 iAliasArray = new ( ELeave ) CDesCArrayFlat( KMmsGranularity ); |
|
81 iAttaStructures = new ( ELeave ) CArrayPtrFlat<CMmsAttaStructure>( KMmsGranularity ); |
|
82 Reset(); |
|
83 } |
|
84 |
|
85 // Two-phased constructor. |
|
86 CMmsReadFile* CMmsReadFile::NewL(RFs& aFs, RFileReadStream& aReadStream ) |
|
87 { |
|
88 CMmsReadFile* self = new ( ELeave ) CMmsReadFile(); |
|
89 CleanupStack::PushL( self ); |
|
90 self->ConstructL( aFs, aReadStream ); |
|
91 CleanupStack::Pop(); |
|
92 return self; |
|
93 } |
|
94 |
|
95 |
|
96 // Destructor |
|
97 CMmsReadFile::~CMmsReadFile() |
|
98 { |
|
99 Reset(); // resets and destroys all array data |
|
100 if (iAliasArray != NULL) iAliasArray->Reset(); |
|
101 delete iByteBuffer; |
|
102 delete iAliasArray; |
|
103 delete iAttaStructures; |
|
104 } |
|
105 |
|
106 void CMmsReadFile::Reset() |
|
107 { |
|
108 // reset all arrays |
|
109 if (iAttaStructures != NULL) iAttaStructures->ResetAndDestroy(); |
|
110 iAttaCount = 0; |
|
111 iAttaRoot = 0; |
|
112 } |
|
113 |
|
114 // --------------------------------------------------------- |
|
115 // CMmsReadFile()::CompleteTest |
|
116 // --------------------------------------------------------- |
|
117 // |
|
118 TInt CMmsReadFile::CompleteTestL( TInt aMessageCounter, CMmsHeaders& aMmsHeaders ) |
|
119 { |
|
120 Reset(); // new message |
|
121 |
|
122 TUint32 val; |
|
123 TUint limit = 1000000; |
|
124 TUint sizeLimit = 1000 * 1024; //max message size 1000 kB! |
|
125 TUint allLimit = 999999; |
|
126 TInt error; |
|
127 TRadix radix = EDecimal; |
|
128 TLex16 lex; |
|
129 TTestReadStatus readStatus = ETestUnknown; |
|
130 CMmsAttaStructure* oneAtta = NULL; |
|
131 TInt index; |
|
132 TTime y1970( K1970 ); |
|
133 TTimeIntervalMicroSeconds interval; |
|
134 TTime date; |
|
135 TInt order = 0; |
|
136 TInt16 shortInteger = 0; |
|
137 |
|
138 //iso luuppi, joka kiertää ja lukee kunnes EOF tule vastaan |
|
139 //Big Loop, which passes around and read until the EOF |
|
140 |
|
141 iMessageType = iNextMessageType; |
|
142 while(readStatus != ETestEof) |
|
143 { |
|
144 readStatus = ReadRowL(); |
|
145 if ( readStatus == ETestEof ) |
|
146 { |
|
147 return(-1); |
|
148 } |
|
149 if ( readStatus == ETestUnknown ) |
|
150 { |
|
151 // A line containing only comments, or an unknown tag |
|
152 // As using the scripts to test settings is no longer supported, |
|
153 // any old keywords used to test CMmsSettings class are ignored |
|
154 continue; |
|
155 } |
|
156 if( readStatus == ETestNewMessage ) |
|
157 { |
|
158 iNextMessageType = readStatus; |
|
159 if(aMessageCounter++) |
|
160 { |
|
161 return(NULL); |
|
162 } |
|
163 else |
|
164 { |
|
165 iMessageType = iNextMessageType; |
|
166 continue; |
|
167 } |
|
168 } |
|
169 if ( iMessageType == ETestNewMessage) |
|
170 { |
|
171 switch(readStatus) |
|
172 { |
|
173 case ETestFrom: |
|
174 aMmsHeaders.SetSenderL( iValueBuffer ); |
|
175 break; |
|
176 case ETestFromAlias: |
|
177 index = FindAlias(iValueBuffer); |
|
178 if(index >= 0) |
|
179 { |
|
180 aMmsHeaders.SetSenderL( iAliasArray->MdcaPoint(index).Mid(iAliasArray->MdcaPoint(index).Locate('=') + 1 ) ); |
|
181 } |
|
182 break; |
|
183 case ETestTo: |
|
184 aMmsHeaders.AddTypedAddresseeL( iValueBuffer, EMsvRecipientTo ); |
|
185 break; |
|
186 case ETestToAlias: |
|
187 index = FindAlias(iValueBuffer); |
|
188 if(index >= 0) |
|
189 { |
|
190 aMmsHeaders.AddTypedAddresseeL( iAliasArray->MdcaPoint(index).Mid(iAliasArray->MdcaPoint(index).Locate('=') + 1 ), EMmsTo ); |
|
191 } |
|
192 break; |
|
193 case ETestCc: |
|
194 aMmsHeaders.AddTypedAddresseeL( iValueBuffer, EMsvRecipientCc ); |
|
195 break; |
|
196 case ETestCcAlias: |
|
197 index = FindAlias(iValueBuffer); |
|
198 if(index >= 0) |
|
199 { |
|
200 aMmsHeaders.AddTypedAddresseeL( iAliasArray->MdcaPoint(index).Mid(iAliasArray->MdcaPoint(index).Locate('=') + 1 ), EMmsCc ); |
|
201 } |
|
202 break; |
|
203 case ETestBcc: |
|
204 aMmsHeaders.AddTypedAddresseeL( iValueBuffer, EMsvRecipientBcc ); |
|
205 break; |
|
206 case ETestBccAlias: |
|
207 index = FindAlias(iValueBuffer); |
|
208 if(index >= 0) |
|
209 { |
|
210 aMmsHeaders.AddTypedAddresseeL( iAliasArray->MdcaPoint(index).Mid(iAliasArray->MdcaPoint(index).Locate('=') + 1 ), EMmsBcc ); |
|
211 } |
|
212 break; |
|
213 case ETestSubject: |
|
214 aMmsHeaders.SetSubjectL( iValueBuffer ); |
|
215 break; |
|
216 case ETestExpiryRel: |
|
217 lex.Assign(iValueBuffer); |
|
218 error = lex.Val(val,radix,limit); |
|
219 if (error == KErrNone) |
|
220 { |
|
221 aMmsHeaders.SetExpiryInterval( val ); |
|
222 } |
|
223 break; |
|
224 case ETestExpiryAbs: |
|
225 error = iDate.Set(iValueBuffer); |
|
226 interval = iDate.MicroSecondsFrom( y1970 ); |
|
227 // expiry date in seconds from 1.1.1970. |
|
228 aMmsHeaders.SetExpiryDate( (interval.Int64())/1000000 ); |
|
229 break; |
|
230 case ETestDeliveryTimeRel: |
|
231 lex.Assign(iValueBuffer); |
|
232 error = lex.Val(val,radix,limit); |
|
233 if (error == KErrNone) |
|
234 { |
|
235 aMmsHeaders.SetDeliveryTimeInterval( val ); |
|
236 } |
|
237 break; |
|
238 case ETestDeliveryTimeAbs: |
|
239 error = iDate.Set(iValueBuffer); |
|
240 interval = iDate.MicroSecondsFrom( y1970 ); |
|
241 aMmsHeaders.SetDeliveryDate( (interval.Int64())/1000000 ); |
|
242 break; |
|
243 case ETestDate: |
|
244 error = iDate.Set(iValueBuffer); |
|
245 interval = iDate.MicroSecondsFrom( y1970 ); |
|
246 aMmsHeaders.SetDate( (interval.Int64())/1000000 ); |
|
247 case ETestPriority: |
|
248 val = 0; |
|
249 if ((iValueBuffer.CompareF(KLow)) == 0) |
|
250 { |
|
251 val = EMmsPriorityLow; |
|
252 } |
|
253 else if ((iValueBuffer.CompareF(KNormal)) == 0) |
|
254 { |
|
255 val = EMmsPriorityNormal; |
|
256 } |
|
257 else if ((iValueBuffer.CompareF(KHigh)) == 0) |
|
258 { |
|
259 val = EMmsPriorityHigh; |
|
260 } |
|
261 else |
|
262 { |
|
263 val = KMmsTestIllegalValue; |
|
264 } |
|
265 aMmsHeaders.SetMessagePriority( val ); |
|
266 break; |
|
267 case ETestSenderVisibility: |
|
268 val = 0; |
|
269 if ((iValueBuffer.CompareF(KHide)) == 0) |
|
270 { |
|
271 val = EMmsSenderVisibilityHide; |
|
272 } |
|
273 else if ((iValueBuffer.CompareF(KShow)) == 0) |
|
274 { |
|
275 val = EMmsSenderVisibilityShow; |
|
276 } |
|
277 else |
|
278 { |
|
279 val = KMmsTestIllegalValue; |
|
280 } |
|
281 aMmsHeaders.SetSenderVisibility( val ); |
|
282 break; |
|
283 case ETestDeliveryReport: |
|
284 val = 0; |
|
285 if ((iValueBuffer.CompareF(KYes)) == 0) |
|
286 { |
|
287 val = EMmsYes; |
|
288 } |
|
289 else if ((iValueBuffer.CompareF(KNo)) == 0) |
|
290 { |
|
291 val = EMmsNo; |
|
292 } |
|
293 else |
|
294 { |
|
295 val = KMmsTestIllegalValue; |
|
296 } |
|
297 aMmsHeaders.SetDeliveryReport( val ); |
|
298 break; |
|
299 case ETestDelivReportSendAllow: |
|
300 val = 0; |
|
301 if ((iValueBuffer.CompareF(KYes)) == 0) |
|
302 { |
|
303 val = EMmsYes; |
|
304 } |
|
305 else if ((iValueBuffer.CompareF(KNo)) == 0) |
|
306 { |
|
307 val = EMmsNo; |
|
308 } |
|
309 else |
|
310 { |
|
311 val = KMmsTestIllegalValue; |
|
312 } |
|
313 aMmsHeaders.SetReportAllowed( val ); |
|
314 break; |
|
315 |
|
316 case ETestReadReply: |
|
317 val = 0; |
|
318 if ((iValueBuffer.CompareF(KYes)) == 0) |
|
319 { |
|
320 val = EMmsYes; |
|
321 } |
|
322 else if ((iValueBuffer.CompareF(KNo)) == 0) |
|
323 { |
|
324 val = EMmsNo; |
|
325 } |
|
326 else |
|
327 { |
|
328 val = KMmsTestIllegalValue; |
|
329 } |
|
330 aMmsHeaders.SetReadReply( val ); |
|
331 break; |
|
332 case ETestNewAttachment: |
|
333 oneAtta = CMmsAttaStructure::NewL(); |
|
334 iAttaStructures->AppendL(oneAtta); |
|
335 oneAtta->iAtta->Des().Copy( iValueBuffer ); |
|
336 iAttaCount++; |
|
337 break; |
|
338 case ETestAttachmentType: |
|
339 if (oneAtta != NULL) |
|
340 { |
|
341 oneAtta->iAttaType->Des().Copy( iValueBuffer ); |
|
342 } |
|
343 break; |
|
344 case ETestAttachmentContLoc: |
|
345 if (oneAtta != NULL) |
|
346 { |
|
347 oneAtta->iAttaName->Des().Copy( iValueBuffer ); |
|
348 } |
|
349 break; |
|
350 case ETestAttaRecommendedName: |
|
351 if (oneAtta != NULL) |
|
352 { |
|
353 oneAtta->iAttaRecommendedName->Des().Copy( iValueBuffer ); |
|
354 } |
|
355 break; |
|
356 case ETestAttachmentCharset: |
|
357 lex.Assign(iValueBuffer); |
|
358 error = lex.Val(val,radix,limit); |
|
359 if (error == KErrNone) |
|
360 { |
|
361 if (oneAtta != NULL) |
|
362 { |
|
363 oneAtta->iAttaCharset = val; |
|
364 } |
|
365 } |
|
366 break; |
|
367 case ETestAttachmentCid: |
|
368 if (oneAtta != NULL) |
|
369 { |
|
370 oneAtta->iAttaCid->Des().Copy(iValueBuffer); |
|
371 } |
|
372 break; |
|
373 case ETestAttContTypeParamName: |
|
374 iByteBuffer->Des().Copy( iValueBuffer ); |
|
375 if (oneAtta != NULL) |
|
376 { |
|
377 oneAtta->iContentTypeParams->AppendL(iByteBuffer->Des()); |
|
378 } |
|
379 break; |
|
380 case ETestAttContTypeParamValue: |
|
381 iByteBuffer->Des().Copy( iValueBuffer ); |
|
382 if (oneAtta != NULL) |
|
383 { |
|
384 oneAtta->iContentTypeParams->AppendL(iByteBuffer->Des()); |
|
385 } |
|
386 break; |
|
387 case ETestAttXTypeParamName: |
|
388 iByteBuffer->Des().Copy( iValueBuffer ); |
|
389 if (oneAtta != NULL) |
|
390 { |
|
391 oneAtta->iXTypeParams->AppendL(iByteBuffer->Des()); |
|
392 } |
|
393 break; |
|
394 case ETestAttXTypeParamValue: |
|
395 iByteBuffer->Des().Copy( iValueBuffer ); |
|
396 if (oneAtta != NULL) |
|
397 { |
|
398 oneAtta->iXTypeParams->AppendL(iByteBuffer->Des()); |
|
399 } |
|
400 break; |
|
401 case ETestAttachmentRoot: |
|
402 iAttaRoot = iAttaCount; |
|
403 break; |
|
404 case ETestAlias: |
|
405 // all aliases are global even if they appear |
|
406 // in the middle of a message |
|
407 iAliasArray->AppendL( iValueBuffer ); |
|
408 iAliasCount++; |
|
409 break; |
|
410 case ETestMessageClass: // should be handled! |
|
411 val = EMmsClassPersonal; |
|
412 if ((iValueBuffer.CompareF(KPersonal)) == 0) |
|
413 { |
|
414 val = EMmsClassPersonal; |
|
415 } |
|
416 else if ((iValueBuffer.CompareF(KAdvertisement)) == 0) |
|
417 { |
|
418 val = EMmsClassAdvertisement; |
|
419 } |
|
420 else if ((iValueBuffer.CompareF(KInformational)) == 0) |
|
421 { |
|
422 val = EMmsClassInformational; |
|
423 } |
|
424 else if ((iValueBuffer.CompareF(KAuto)) == 0) |
|
425 { |
|
426 val = EMmsClassAuto; |
|
427 } |
|
428 else |
|
429 { |
|
430 val = (TMmsMessageClass)KMmsTestIllegalValue; |
|
431 } |
|
432 aMmsHeaders.SetMessageClass( val ); |
|
433 break; |
|
434 case ETestReplyCharging: |
|
435 val = 0; |
|
436 if ((iValueBuffer.CompareF(KRequested)) == 0) |
|
437 { |
|
438 val = KMmsReplyChargingRequested; |
|
439 } |
|
440 else if ((iValueBuffer.CompareF(KReqTextOnly)) == 0) |
|
441 { |
|
442 val = KMmsReplyChargingRequestedTextOnly; |
|
443 } |
|
444 else if ((iValueBuffer.CompareF(KAccepted)) == 0) |
|
445 { |
|
446 val = KMmsReplyChargingAccepted; |
|
447 } |
|
448 else if ((iValueBuffer.CompareF(KAccTextOnly)) == 0) |
|
449 { |
|
450 val = KMmsReplyChargingAcceptedTextOnly; |
|
451 } |
|
452 else |
|
453 { |
|
454 val = KMmsTestIllegalValue; |
|
455 } |
|
456 aMmsHeaders.SetReplyCharging( val ); |
|
457 break; |
|
458 case ETestReplyChargAbs: |
|
459 error = date.Set(iValueBuffer); |
|
460 if ( error == KErrNone ) |
|
461 { |
|
462 interval = date.MicroSecondsFrom( y1970 ); |
|
463 aMmsHeaders.SetReplyChargingDate( (interval.Int64())/1000000 ); |
|
464 } |
|
465 break; |
|
466 case ETestReplyChargRel: |
|
467 lex.Assign(iValueBuffer); |
|
468 error = lex.Val(val,radix,limit); |
|
469 if (error == KErrNone) |
|
470 { |
|
471 aMmsHeaders.SetReplyChargingInterval( val ); |
|
472 } |
|
473 break; |
|
474 case ETestReplyChargSize: |
|
475 lex.Assign(iValueBuffer); |
|
476 error = lex.Val(val,radix,sizeLimit); |
|
477 if (error == KErrNone) |
|
478 { |
|
479 aMmsHeaders.SetReplyChargingSize( val ); |
|
480 } |
|
481 break; |
|
482 case ETestReplyChargID: |
|
483 iByteBuffer->Des().Copy( iValueBuffer ); |
|
484 aMmsHeaders.SetReplyChargingIdL( iByteBuffer->Des() ); |
|
485 break; |
|
486 case ETestTID: |
|
487 iByteBuffer->Des().Copy( iValueBuffer ); |
|
488 aMmsHeaders.SetTidL( iByteBuffer->Des() ); |
|
489 break; |
|
490 case ETestContentLocation: |
|
491 iByteBuffer->Des().Copy( iValueBuffer ); |
|
492 if ( aMmsHeaders.MessageType() == KMmsMessageTypeMboxViewReq || |
|
493 aMmsHeaders.MessageType() == KMmsMessageTypeMboxViewConf || |
|
494 aMmsHeaders.MessageType() == KMmsMessageTypeMBoxDeleteReq ) |
|
495 { |
|
496 aMmsHeaders.MMBoxMessageHeadersL().ContentLocationList().AppendL( iByteBuffer->Des() ); |
|
497 } |
|
498 else if ( aMmsHeaders.MessageType() == KMmsMessageTypeMBoxDeleteConf ) |
|
499 { |
|
500 aMmsHeaders.InsertDeleteContentLocationL( order, iByteBuffer->Des() ); |
|
501 } |
|
502 else |
|
503 { |
|
504 aMmsHeaders.SetContentLocationL( iByteBuffer->Des() ); |
|
505 } |
|
506 break; |
|
507 case ETestPreviouslySentIndex: |
|
508 lex.Assign(iValueBuffer); |
|
509 error = lex.Val(val,radix,limit); |
|
510 order = val; |
|
511 break; |
|
512 case ETestPreviouslySentBy: |
|
513 aMmsHeaders.InsertPreviouslySentByL( order, iValueBuffer ); |
|
514 break; |
|
515 case ETestPreviouslySentDate: |
|
516 error = date.Set(iValueBuffer); |
|
517 if ( error == KErrNone ) |
|
518 { |
|
519 interval = date.MicroSecondsFrom( y1970 ); |
|
520 aMmsHeaders.InsertPreviouslySentDateL( order, (interval.Int64())/1000000 ); |
|
521 } |
|
522 break; |
|
523 case ETestMessageId: |
|
524 iByteBuffer->Des().Copy( iValueBuffer ); |
|
525 aMmsHeaders.SetMessageIdL( iByteBuffer->Des() ); |
|
526 break; |
|
527 case ETestMessageSize: |
|
528 lex.Assign(iValueBuffer); |
|
529 error = lex.Val(val,radix,sizeLimit); |
|
530 if (error == KErrNone) |
|
531 { |
|
532 aMmsHeaders.SetMessageSize( val ); |
|
533 } |
|
534 break; |
|
535 case ETestVersion: |
|
536 lex.Assign(iValueBuffer); |
|
537 error = lex.Val(val,EHex,limit); |
|
538 shortInteger = TInt16( val ); |
|
539 if (error == KErrNone) |
|
540 { |
|
541 aMmsHeaders.SetMmsVersion( shortInteger ); |
|
542 } |
|
543 break; |
|
544 case ETestReadStatus: |
|
545 val = 0; |
|
546 if ((iValueBuffer.CompareF(KRead)) == 0) |
|
547 { |
|
548 val = KMmsReadStatusRead; |
|
549 } |
|
550 else if ((iValueBuffer.CompareF(KDelNotRead)) == 0) |
|
551 { |
|
552 val = KMmsReadStatusDeletedWithoutBeingRead; |
|
553 } |
|
554 else |
|
555 { |
|
556 val = KMmsTestIllegalValue; |
|
557 } |
|
558 aMmsHeaders.SetReadStatus( val ); |
|
559 break; |
|
560 case ETestResponseStatus: |
|
561 val = 0; |
|
562 if ((iValueBuffer.CompareF(KOk)) == 0) |
|
563 { |
|
564 val = KMmsStatusOk; |
|
565 } |
|
566 else if ((iValueBuffer.CompareF(KErrUnspecified)) == 0) |
|
567 { |
|
568 val = KMmsErrorUnspecified; |
|
569 } |
|
570 else if ((iValueBuffer.CompareF(KErrServiceDenied)) == 0) |
|
571 { |
|
572 val = KMmsErrorServiceDenied; |
|
573 } |
|
574 else if ((iValueBuffer.CompareF(KErrMessageFormatCorrupt)) == 0) |
|
575 { |
|
576 val = KMmsErrorMessageFormatCorrupt; |
|
577 } |
|
578 else if ((iValueBuffer.CompareF(KErrAddressUnresolved)) == 0) |
|
579 { |
|
580 val = KMmsErrorSendingAddressUnresolved; |
|
581 } |
|
582 else if ((iValueBuffer.CompareF(KErrMessageNotFound)) == 0) |
|
583 { |
|
584 val = KMmsErrorMessageNotFound; |
|
585 } |
|
586 else if ((iValueBuffer.CompareF(KErrNetworkProblem)) == 0) |
|
587 { |
|
588 val = KMmsErrorNetworkProblem; |
|
589 } |
|
590 else if ((iValueBuffer.CompareF(KErrContentNotAccepted)) == 0) |
|
591 { |
|
592 val = KMmsErrorNoContentAccepted; |
|
593 } |
|
594 else if ((iValueBuffer.CompareF(KErrUnsupportedMessage)) == 0) |
|
595 { |
|
596 val = KMmsErrorUnsupportedMessage; |
|
597 } |
|
598 else if ((iValueBuffer.CompareF(KErrTransient)) == 0) |
|
599 { |
|
600 val = KMmsErrorTransientFailure; |
|
601 } |
|
602 else if ((iValueBuffer.CompareF(KErrTransientAddressUnresolved)) == 0) |
|
603 { |
|
604 val = KMmsErrorTransientSendingAddressUnresolved; |
|
605 } |
|
606 else if ((iValueBuffer.CompareF(KErrTransientNotFound)) == 0) |
|
607 { |
|
608 val = KMmsErrorTransientMessageNotFound; |
|
609 } |
|
610 else if ((iValueBuffer.CompareF(KErrTransientNetworkproblem)) == 0) |
|
611 { |
|
612 val = KMmsErrorTransientNetworkProblem; |
|
613 } |
|
614 else if ((iValueBuffer.CompareF(KErrPermanent)) == 0) |
|
615 { |
|
616 val = KMmsErrorPermanentFailure; |
|
617 } |
|
618 else if ((iValueBuffer.CompareF(KErrPermanentServiceDenied)) == 0) |
|
619 { |
|
620 val = KMmsErrorPermanentServiceDenied; |
|
621 } |
|
622 else if ((iValueBuffer.CompareF(KErrPermanentMessageFormatCorrupt)) == 0) |
|
623 { |
|
624 val = KMmsErrorPermanentMessageFormatCorrupt; |
|
625 } |
|
626 else if ((iValueBuffer.CompareF(KErrPermanentAddressUnresolved)) == 0) |
|
627 { |
|
628 val = KMmsErrorPermanentSendingAddressUnresolved; |
|
629 } |
|
630 else if ((iValueBuffer.CompareF(KErrPermanentNotFound)) == 0) |
|
631 { |
|
632 val = KMmsErrorPermanentMessageNotFound; |
|
633 } |
|
634 else if ((iValueBuffer.CompareF(KErrPermanentContentNotAccepted)) == 0) |
|
635 { |
|
636 val = KMmsErrorPermanentContentNotAccepted; |
|
637 } |
|
638 else if ((iValueBuffer.CompareF(KErrReplyChargingLimitNotMet)) == 0) |
|
639 { |
|
640 val = KMmsErrorPermanentReplyChargingLimitationsNotMet; |
|
641 } |
|
642 else if ((iValueBuffer.CompareF(KErrReplyChargingRequestNotAccepted)) == 0) |
|
643 { |
|
644 val = KMmsErrorPermanentReplyChargingRequestNotAccepted; |
|
645 } |
|
646 else if ((iValueBuffer.CompareF(KErrReplyChargingForwardingDenied)) == 0) |
|
647 { |
|
648 val = KMmsErrorPermanentReplyChargingForwardingDenied; |
|
649 } |
|
650 else if ((iValueBuffer.CompareF(KErrReplyChargingNotSupported)) == 0) |
|
651 { |
|
652 val = KMmsErrorPermanentReplyChargingNotSupported; |
|
653 } |
|
654 else if ((iValueBuffer.CompareF(KErrTransientPartialSuccess)) == 0) |
|
655 { |
|
656 val = KMmsErrorTransientPartialSuccess; |
|
657 } |
|
658 else if ((iValueBuffer.CompareF(KErrAddressHidingNotSupported)) == 0) |
|
659 { |
|
660 val = KMmsErrorPermanentAddressHidingNotSupported; |
|
661 } |
|
662 else |
|
663 { |
|
664 val = KMmsTestIllegalValue; |
|
665 } |
|
666 if ( aMmsHeaders.MessageType() == KMmsMessageTypeMBoxDeleteConf ) |
|
667 { |
|
668 aMmsHeaders.InsertDeleteStatusL( order, val ); |
|
669 } |
|
670 else |
|
671 { |
|
672 aMmsHeaders.SetResponseStatus( val ); |
|
673 } |
|
674 break; |
|
675 case ETestResponseText: |
|
676 if ( aMmsHeaders.MessageType() == KMmsMessageTypeMBoxDeleteConf ) |
|
677 { |
|
678 aMmsHeaders.InsertDeleteResponseTextL( order, iValueBuffer ); |
|
679 } |
|
680 else |
|
681 { |
|
682 aMmsHeaders.SetResponseTextL( iValueBuffer ); |
|
683 } |
|
684 break; |
|
685 case ETestRetrieveStatus: |
|
686 val = 0; |
|
687 if ((iValueBuffer.CompareF(KOk)) == 0) |
|
688 { |
|
689 val = KMmsStatusOk; |
|
690 } |
|
691 else if ((iValueBuffer.CompareF(KErrTransient)) == 0) |
|
692 { |
|
693 val = KMmsErrorTransientFailure; |
|
694 } |
|
695 else if ((iValueBuffer.CompareF(KErrTransientNotFound)) == 0) |
|
696 { |
|
697 val = KMmsErrorReceiveTransientMessageNotFound; |
|
698 } |
|
699 else if ((iValueBuffer.CompareF(KErrTransientNetworkproblem)) == 0) |
|
700 { |
|
701 val = KMmsErrorReceiveTransientNetworkProblem; |
|
702 } |
|
703 else if ((iValueBuffer.CompareF(KErrPermanent)) == 0) |
|
704 { |
|
705 val = KMmsErrorPermanentFailure; |
|
706 } |
|
707 else if ((iValueBuffer.CompareF(KErrPermanentServiceDenied)) == 0) |
|
708 { |
|
709 val = KMmsErrorPermanentServiceDenied; |
|
710 } |
|
711 else if ((iValueBuffer.CompareF(KErrPermanentNotFound)) == 0) |
|
712 { |
|
713 val = KMmsErrorReceivePermanentMessageNotFound; |
|
714 } |
|
715 else if ((iValueBuffer.CompareF(KErrRetrieveContentUnsupported)) == 0) |
|
716 { |
|
717 val = KMmsErrorReceivePermanentContentUnsupported; |
|
718 } |
|
719 else |
|
720 { |
|
721 val = KMmsTestIllegalValue; |
|
722 } |
|
723 aMmsHeaders.SetResponseStatus( val ); |
|
724 break; |
|
725 case ETestRetrieveText: |
|
726 aMmsHeaders.SetResponseTextL( iValueBuffer ); |
|
727 break; |
|
728 case ETestStatus: |
|
729 val = 0; |
|
730 if ((iValueBuffer.CompareF(KDeferred)) == 0) |
|
731 { |
|
732 val = KMmsMessageStatusDeferred; |
|
733 } |
|
734 else if ((iValueBuffer.CompareF(KExpired)) == 0) |
|
735 { |
|
736 val = KMmsMessageStatusExpired; |
|
737 } |
|
738 else if ((iValueBuffer.CompareF(KRetrieved)) == 0) |
|
739 { |
|
740 val = KMmsMessageStatusRetrieved; |
|
741 } |
|
742 else if ((iValueBuffer.CompareF(KRejected)) == 0) |
|
743 { |
|
744 val = KMmsMessageStatusRejected; |
|
745 } |
|
746 else if ((iValueBuffer.CompareF(KUnrecognized)) == 0) |
|
747 { |
|
748 val = KMmsMessageStatusUnrecognized; |
|
749 } |
|
750 else if ((iValueBuffer.CompareF(KIndeterminate)) == 0) |
|
751 { |
|
752 val = KMmsMessageStatusIndeterminate; |
|
753 } |
|
754 else if ((iValueBuffer.CompareF(KForwarded)) == 0) |
|
755 { |
|
756 val = KMmsMessageStatusForwarded; |
|
757 } |
|
758 else if ((iValueBuffer.CompareF(KUnreachable)) == 0) |
|
759 { |
|
760 val = KMmsMessageStatusUnreachable; |
|
761 } |
|
762 else |
|
763 { |
|
764 val = KMmsTestIllegalValue; |
|
765 } |
|
766 aMmsHeaders.SetStatus( val ); |
|
767 break; |
|
768 case ETestMessageType: |
|
769 val = 0; |
|
770 if ((iValueBuffer.CompareF(KSendReq)) == 0) |
|
771 { |
|
772 val = KMmsMessageTypeMSendReq; |
|
773 } |
|
774 else if ((iValueBuffer.CompareF(KSendConf)) == 0) |
|
775 { |
|
776 val = KMmsMessageTypeMSendConf; |
|
777 } |
|
778 else if ((iValueBuffer.CompareF(KNotifInd)) == 0) |
|
779 { |
|
780 val = KMmsMessageTypeMNotificationInd; |
|
781 } |
|
782 else if ((iValueBuffer.CompareF(KNotifResp)) == 0) |
|
783 { |
|
784 val = KMmsMessageTypeMNotifyRespInd; |
|
785 } |
|
786 else if ((iValueBuffer.CompareF(KRetrConf)) == 0) |
|
787 { |
|
788 val = KMmsMessageTypeMRetrieveConf; |
|
789 } |
|
790 else if ((iValueBuffer.CompareF(KAckInd)) == 0) |
|
791 { |
|
792 val = KMmsMessageTypeAcknowledgeInd; |
|
793 } |
|
794 else if ((iValueBuffer.CompareF(KDelInd)) == 0) |
|
795 { |
|
796 val = KMmsMessageTypeDeliveryInd; |
|
797 } |
|
798 else if ((iValueBuffer.CompareF(KReadReqInd)) == 0) |
|
799 { |
|
800 val = KMmsMessageTypeReadRecInd; |
|
801 } |
|
802 else if ((iValueBuffer.CompareF(KReadOrigInd)) == 0) |
|
803 { |
|
804 val = KMmsMessageTypeReadOrigInd; |
|
805 } |
|
806 else if ((iValueBuffer.CompareF(KForwardRec)) == 0) |
|
807 { |
|
808 val = KMmsMessageTypeForwardReq; |
|
809 } |
|
810 else if ((iValueBuffer.CompareF(KForwardConf)) == 0) |
|
811 { |
|
812 val = KMmsMessageTypeForwardConf; |
|
813 } |
|
814 else if ((iValueBuffer.CompareF(KMBoxStoreReq)) == 0) |
|
815 { |
|
816 val = KMmsMessageTypeMboxStoreReq; |
|
817 } |
|
818 else if ((iValueBuffer.CompareF(KMBoxStoreConf)) == 0) |
|
819 { |
|
820 val = KMmsMessageTypeMboxStoreConf; |
|
821 } |
|
822 else if ((iValueBuffer.CompareF(KMBoxViewReq)) == 0) |
|
823 { |
|
824 val = KMmsMessageTypeMboxViewReq; |
|
825 } |
|
826 else if ((iValueBuffer.CompareF(KMBoxViewConf)) == 0) |
|
827 { |
|
828 val = KMmsMessageTypeMboxViewConf; |
|
829 } |
|
830 else if ((iValueBuffer.CompareF(KMBoxUploadReq)) == 0) |
|
831 { |
|
832 val = KMmsMessageTypeMBoxUploadReq; |
|
833 } |
|
834 else if ((iValueBuffer.CompareF(KMBoxUploadConf)) == 0) |
|
835 { |
|
836 val = KMmsMessageTypeMBoxUploadConf; |
|
837 } |
|
838 else if ((iValueBuffer.CompareF(KMBoxDeleteReq)) == 0) |
|
839 { |
|
840 val = KMmsMessageTypeMBoxDeleteReq; |
|
841 } |
|
842 else if ((iValueBuffer.CompareF(KMBoxDeleteConf)) == 0) |
|
843 { |
|
844 val = KMmsMessageTypeMBoxDeleteConf; |
|
845 } |
|
846 else if ((iValueBuffer.CompareF(KMBoxDescr)) == 0) |
|
847 { |
|
848 val = KMmsMessageTypeMBoxDescr; |
|
849 } |
|
850 else if ((iValueBuffer.CompareF(KDeleteReq)) == 0) |
|
851 { |
|
852 val = KMmsMessageTypeDeleteReq; |
|
853 } |
|
854 else if ((iValueBuffer.CompareF(KDeleteConf)) == 0) |
|
855 { |
|
856 val = KMmsMessageTypeDeleteConf; |
|
857 } |
|
858 else if ((iValueBuffer.CompareF(KCancelReq)) == 0) |
|
859 { |
|
860 val = KMmsMessageTypeCancelReq; |
|
861 } |
|
862 else if ((iValueBuffer.CompareF(KCancelResp)) == 0) |
|
863 { |
|
864 val = KMmsMessageTypeCancelConf; |
|
865 } |
|
866 else |
|
867 { |
|
868 val = KMmsTestIllegalValue; |
|
869 } |
|
870 aMmsHeaders.SetMessageType( val ); |
|
871 break; |
|
872 case ETestAttribute: |
|
873 val = 0; |
|
874 iByteBuffer->Des().Copy( iValueBuffer ); |
|
875 if ((iByteBuffer->Des().CompareF(KTestBcc)) == 0) |
|
876 { |
|
877 val = KMmsAssignedBcc; |
|
878 } |
|
879 else if ((iByteBuffer->Des().CompareF(KTestCc)) == 0) |
|
880 { |
|
881 val = KMmsAssignedCc; |
|
882 } |
|
883 else if ((iByteBuffer->Des().CompareF(KTestContent)) == 0) |
|
884 { |
|
885 val = KMmsAssignedContent; |
|
886 } |
|
887 else if ((iByteBuffer->Des().CompareF(KTestContentType)) == 0) |
|
888 { |
|
889 val = KMmsAssignedContentType; |
|
890 } |
|
891 else if ((iByteBuffer->Des().CompareF(KTestDate)) == 0) |
|
892 { |
|
893 val = KMmsAssignedDate; |
|
894 } |
|
895 else if ((iByteBuffer->Des().CompareF(KTestDeliveryReport)) == 0) |
|
896 { |
|
897 val = KMmsAssignedDeliveryReport; |
|
898 } |
|
899 else if ((iByteBuffer->Des().CompareF(KTestDeliveryTime)) == 0) |
|
900 { |
|
901 val = KMmsAssignedDeliveryTime; |
|
902 } |
|
903 else if ((iByteBuffer->Des().CompareF(KTestExpiry)) == 0) |
|
904 { |
|
905 val = KMmsAssignedExpiry; |
|
906 } |
|
907 else if ((iByteBuffer->Des().CompareF(KTestFrom)) == 0) |
|
908 { |
|
909 val = KMmsAssignedFrom; |
|
910 } |
|
911 else if ((iByteBuffer->Des().CompareF(KTestMessageClass)) == 0) |
|
912 { |
|
913 val = KMmsAssignedMessageClass; |
|
914 } |
|
915 else if ((iByteBuffer->Des().CompareF(KTestMessageId)) == 0) |
|
916 { |
|
917 val = KMmsAssignedMessageId; |
|
918 } |
|
919 else if ((iByteBuffer->Des().CompareF(KTestMessageSize)) == 0) |
|
920 { |
|
921 val = KMmsAssignedMessageSize; |
|
922 } |
|
923 else if ((iByteBuffer->Des().CompareF(KTestPriority)) == 0) |
|
924 { |
|
925 val = KMmsAssignedPriority; |
|
926 } |
|
927 else if ((iByteBuffer->Des().CompareF(KTestReadReply)) == 0) |
|
928 { |
|
929 val = KMmsAssignedReadReply; |
|
930 } |
|
931 else if ((iByteBuffer->Des().CompareF(KTestSubject)) == 0) |
|
932 { |
|
933 val = KMmsAssignedSubject; |
|
934 } |
|
935 else if ((iByteBuffer->Des().CompareF(KTestTo)) == 0) |
|
936 { |
|
937 val = KMmsAssignedTo; |
|
938 } |
|
939 else if ((iByteBuffer->Des().CompareF(KTestReplyCharging)) == 0) |
|
940 { |
|
941 val = KMmsAssignedReplyCharging; |
|
942 } |
|
943 else if ((iByteBuffer->Des().CompareF(KTestReplyChargID)) == 0) |
|
944 { |
|
945 val = KMmsAssignedReplyChargingID; |
|
946 } |
|
947 else if ((iByteBuffer->Des().CompareF(KTestReplyCharg)) == 0) |
|
948 { |
|
949 val = KMmsAssignedReplyChargingDeadline; |
|
950 } |
|
951 else if ((iByteBuffer->Des().CompareF(KTestReplyChargSize)) == 0) |
|
952 { |
|
953 val = KMmsAssignedReplyChargingSize; |
|
954 } |
|
955 else if ((iByteBuffer->Des().CompareF(KTestPreviouslySentBy)) == 0) |
|
956 { |
|
957 val = KMmsAssignedPreviouslySentBy; |
|
958 } |
|
959 else if ((iByteBuffer->Des().CompareF(KTestPreviouslySentDate)) == 0) |
|
960 { |
|
961 val = KMmsAssignedPreviouslySentDate; |
|
962 } |
|
963 else if ((iByteBuffer->Des().CompareF(KTestAdditionalHeaders)) == 0) |
|
964 { |
|
965 val = KMmsAssignedAdditionalHeaders; |
|
966 } |
|
967 else |
|
968 { |
|
969 val = KMmsTestIllegalValue; |
|
970 } |
|
971 aMmsHeaders.MMBoxViewHeadersL().AttributeArray().InsertInOrder(val); |
|
972 break; |
|
973 case ETestDistributionIndicator: |
|
974 val = 0; |
|
975 if ((iValueBuffer.CompareF(KYes)) == 0) |
|
976 { |
|
977 val = KMmsYes; |
|
978 } |
|
979 else if ((iValueBuffer.CompareF(KNo)) == 0) |
|
980 { |
|
981 val = KMmsNo; |
|
982 } |
|
983 else |
|
984 { |
|
985 val = KMmsTestIllegalValue; |
|
986 } |
|
987 aMmsHeaders.SetDistributionIndicator( val ); |
|
988 break; |
|
989 case ETestLimit: |
|
990 aMmsHeaders.MMBoxViewHeadersL().SetMmsLimit(KMaxTUint32); |
|
991 lex.Assign(iValueBuffer); |
|
992 error = lex.Val(val,radix,limit); |
|
993 if ( val > allLimit ) |
|
994 { |
|
995 val = KMaxTUint32; // this is too hard to type, more than 999999 means "all" |
|
996 } |
|
997 if( error == KErrNone ) |
|
998 { |
|
999 aMmsHeaders.MMBoxViewHeadersL().SetMmsLimit(val); |
|
1000 } |
|
1001 break; |
|
1002 case ETestMessageQuota: |
|
1003 aMmsHeaders.MMBoxViewHeadersL().SetMMBoxQuotaNumber(KMaxTUint32); |
|
1004 lex.Assign(iValueBuffer); |
|
1005 error = lex.Val(val,radix,limit); |
|
1006 if ( val > allLimit ) |
|
1007 { |
|
1008 val = KMaxTUint32; // this is too hard to type, more than 999999 means "all" |
|
1009 } |
|
1010 if (error == KErrNone) |
|
1011 { |
|
1012 aMmsHeaders.MMBoxViewHeadersL().SetMMBoxQuotaNumber(val); |
|
1013 } |
|
1014 break; |
|
1015 case ETestSizeQuota: |
|
1016 aMmsHeaders.MMBoxViewHeadersL().SetMMBoxQuotaSize(KMaxTUint32); |
|
1017 lex.Assign(iValueBuffer); |
|
1018 error = lex.Val(val,radix,limit); |
|
1019 if ( val > allLimit ) |
|
1020 { |
|
1021 val = KMaxTUint32; // this is too hard to type, more than 999999 means "all" |
|
1022 } |
|
1023 if (error == KErrNone) |
|
1024 { |
|
1025 aMmsHeaders.MMBoxViewHeadersL().SetMMBoxQuotaSize(val); |
|
1026 } |
|
1027 break; |
|
1028 case ETestMessageTotal: |
|
1029 aMmsHeaders.MMBoxViewHeadersL().SetMMBoxTotalNumber(KMaxTUint32); |
|
1030 lex.Assign(iValueBuffer); |
|
1031 error = lex.Val(val,radix,limit); |
|
1032 if ( val > allLimit ) |
|
1033 { |
|
1034 val = KMaxTUint32; // this is too hard to type, more than 999999 means "all" |
|
1035 } |
|
1036 if (error == KErrNone) |
|
1037 { |
|
1038 aMmsHeaders.MMBoxViewHeadersL().SetMMBoxTotalNumber(val); |
|
1039 } |
|
1040 break; |
|
1041 case ETestSizeTotal: |
|
1042 aMmsHeaders.MMBoxViewHeadersL().SetMMBoxTotalSize(KMaxTUint32); |
|
1043 lex.Assign(iValueBuffer); |
|
1044 error = lex.Val(val,radix,limit); |
|
1045 if ( val > allLimit ) |
|
1046 { |
|
1047 val = KMaxTUint32; // this is too hard to type, more than 999999 means "all" |
|
1048 } |
|
1049 if (error == KErrNone) |
|
1050 { |
|
1051 aMmsHeaders.MMBoxViewHeadersL().SetMMBoxTotalSize(val); |
|
1052 } |
|
1053 break; |
|
1054 case ETestMessageCount: |
|
1055 aMmsHeaders.MMBoxViewHeadersL().SetMmsMessageCount(KMaxTUint32); |
|
1056 lex.Assign(iValueBuffer); |
|
1057 error = lex.Val(val,radix,limit); |
|
1058 if ( val > allLimit ) |
|
1059 { |
|
1060 val = KMaxTUint32; // this is too hard to type, more than 999999 means "all" |
|
1061 } |
|
1062 if (error == KErrNone) |
|
1063 { |
|
1064 aMmsHeaders.MMBoxViewHeadersL().SetMmsMessageCount(val); |
|
1065 } |
|
1066 break; |
|
1067 case ETestAddKeyword: |
|
1068 aMmsHeaders.MMBoxMessageHeadersL().AppendKeywordItemL(KMmsAddToken, iValueBuffer); |
|
1069 break; |
|
1070 case ETestRemoveKeyword: |
|
1071 aMmsHeaders.MMBoxMessageHeadersL().AppendKeywordItemL(KMmsRemoveToken, iValueBuffer); |
|
1072 break; |
|
1073 case ETestFilterKeyword: |
|
1074 aMmsHeaders.MMBoxMessageHeadersL().AppendKeywordItemL(KMmsFilterToken, iValueBuffer); |
|
1075 break; |
|
1076 case ETestMMState: |
|
1077 val = 0; |
|
1078 if ((iValueBuffer.CompareF(KDraft)) == 0) |
|
1079 { |
|
1080 val = KMmsDraft; |
|
1081 } |
|
1082 else if ((iValueBuffer.CompareF(KSent)) == 0) |
|
1083 { |
|
1084 val = KMmsSent; |
|
1085 } |
|
1086 else if ((iValueBuffer.CompareF(KNew)) == 0) |
|
1087 { |
|
1088 val = KMmsNew; |
|
1089 } |
|
1090 else if ((iValueBuffer.CompareF(KRetrieved)) == 0) |
|
1091 { |
|
1092 val = KMmsRetrieved; |
|
1093 } |
|
1094 else if ((iValueBuffer.CompareF(KForwarded)) == 0) |
|
1095 { |
|
1096 val = KMmsForwarded; |
|
1097 } |
|
1098 else |
|
1099 { |
|
1100 val = KMmsTestIllegalValue; |
|
1101 } |
|
1102 if ( aMmsHeaders.MessageType() == KMmsMessageTypeMboxViewReq || |
|
1103 aMmsHeaders.MessageType() == KMmsMessageTypeMboxViewConf ) |
|
1104 { |
|
1105 aMmsHeaders.MMBoxViewHeadersL().MMStateArray().InsertInOrder( val ); |
|
1106 } |
|
1107 else |
|
1108 { |
|
1109 aMmsHeaders.MMBoxMessageHeadersL().SetMMState( val ); |
|
1110 } |
|
1111 break; |
|
1112 case ETestQuota: |
|
1113 val = 0; |
|
1114 if ((iValueBuffer.CompareF(KYes)) == 0) |
|
1115 { |
|
1116 val = KMmsYes; |
|
1117 } |
|
1118 else if ((iValueBuffer.CompareF(KNo)) == 0) |
|
1119 { |
|
1120 val = KMmsNo; |
|
1121 } |
|
1122 else |
|
1123 { |
|
1124 val = KMmsTestIllegalValue; |
|
1125 } |
|
1126 aMmsHeaders.MMBoxViewHeadersL().SetMmsQuotas( val ); |
|
1127 break; |
|
1128 case ETestStart: |
|
1129 lex.Assign(iValueBuffer); |
|
1130 error = lex.Val(val,radix,limit); |
|
1131 if (error == KErrNone) |
|
1132 { |
|
1133 aMmsHeaders.MMBoxViewHeadersL().SetMmsStart(val); |
|
1134 } |
|
1135 break; |
|
1136 case ETestStore: |
|
1137 val = 0; |
|
1138 if ((iValueBuffer.CompareF(KYes)) == 0) |
|
1139 { |
|
1140 val = KMmsYes; |
|
1141 } |
|
1142 else if ((iValueBuffer.CompareF(KNo)) == 0) |
|
1143 { |
|
1144 val = KMmsNo; |
|
1145 } |
|
1146 else |
|
1147 { |
|
1148 val = KMmsTestIllegalValue; |
|
1149 } |
|
1150 aMmsHeaders.MMBoxMessageHeadersL().SetMmsStore( val ); |
|
1151 break; |
|
1152 case ETestStored: |
|
1153 val = 0; |
|
1154 if ((iValueBuffer.CompareF(KYes)) == 0) |
|
1155 { |
|
1156 val = KMmsYes; |
|
1157 } |
|
1158 else if ((iValueBuffer.CompareF(KNo)) == 0) |
|
1159 { |
|
1160 val = KMmsNo; |
|
1161 } |
|
1162 else |
|
1163 { |
|
1164 val = KMmsTestIllegalValue; |
|
1165 } |
|
1166 aMmsHeaders.MMBoxMessageHeadersL().SetMmsStored( val ); |
|
1167 break; |
|
1168 case ETestStoreStatus: |
|
1169 val = 0; |
|
1170 if ((iValueBuffer.CompareF(KOk)) == 0) |
|
1171 { |
|
1172 val = KMmsStatusOk; |
|
1173 } |
|
1174 else if ((iValueBuffer.CompareF(KErrTransient)) == 0) |
|
1175 { |
|
1176 val = KMmsErrorTransientFailure; |
|
1177 } |
|
1178 else if ((iValueBuffer.CompareF(KErrTransientNetworkproblem)) == 0) |
|
1179 { |
|
1180 val = KMmsErrorStoreStatusTransientNetworkProblem; |
|
1181 } |
|
1182 else if ((iValueBuffer.CompareF(KErrPermanent)) == 0) |
|
1183 { |
|
1184 val = KMmsErrorPermanentFailure; |
|
1185 } |
|
1186 else if ((iValueBuffer.CompareF(KErrPermanentServiceDenied)) == 0) |
|
1187 { |
|
1188 val = KMmsErrorPermanentServiceDenied; |
|
1189 } |
|
1190 else if ((iValueBuffer.CompareF(KErrPermanentMessageFormatCorrupt)) == 0) |
|
1191 { |
|
1192 val = KMmsErrorPermanentMessageFormatCorrupt; |
|
1193 } |
|
1194 else if ((iValueBuffer.CompareF(KErrPermanentNotFound)) == 0) |
|
1195 { |
|
1196 val = KMmsErrorStoreStatusPermanentMessageNotFound; |
|
1197 } |
|
1198 else if ((iValueBuffer.CompareF(KErrMMBoxFull)) == 0) |
|
1199 { |
|
1200 val = KMmsErrorStoreStatusPermanentMmboxFull; |
|
1201 } |
|
1202 else |
|
1203 { |
|
1204 val = KMmsTestIllegalValue; |
|
1205 } |
|
1206 aMmsHeaders.MMBoxMessageHeadersL().SetMmsStoreStatus( val ); |
|
1207 break; |
|
1208 case ETestStoreStatusText: |
|
1209 aMmsHeaders.MMBoxMessageHeadersL().SetMmsStoreStatusTextL( iValueBuffer ); |
|
1210 break; |
|
1211 case ETestTotals: |
|
1212 val = 0; |
|
1213 if ((iValueBuffer.CompareF(KYes)) == 0) |
|
1214 { |
|
1215 val = KMmsYes; |
|
1216 } |
|
1217 else if ((iValueBuffer.CompareF(KNo)) == 0) |
|
1218 { |
|
1219 val = KMmsNo; |
|
1220 } |
|
1221 else |
|
1222 { |
|
1223 val = KMmsTestIllegalValue; |
|
1224 } |
|
1225 aMmsHeaders.MMBoxViewHeadersL().SetMmsTotals( val ); |
|
1226 break; |
|
1227 |
|
1228 case ETestDeleteInfoIndex: |
|
1229 lex.Assign(iValueBuffer); |
|
1230 error = lex.Val(val,radix,limit); |
|
1231 order = val; |
|
1232 break; |
|
1233 |
|
1234 case ETestApplicId: |
|
1235 aMmsHeaders.SetApplicIdL( iValueBuffer ); |
|
1236 break; |
|
1237 case ETestReplyApplicId: |
|
1238 aMmsHeaders.SetReplyApplicIdL( iValueBuffer ); |
|
1239 break; |
|
1240 case ETestApplicInfo: |
|
1241 iByteBuffer->Des().Copy( iValueBuffer ); |
|
1242 aMmsHeaders.SetAuxApplicInfoL( iByteBuffer->Des() ); |
|
1243 break; |
|
1244 case ETestContentClass: |
|
1245 val = 0; |
|
1246 if ((iValueBuffer.CompareF(KText)) == 0) |
|
1247 { |
|
1248 val = KMmsContentClassText; |
|
1249 } |
|
1250 else if ((iValueBuffer.CompareF(KImageBasic)) == 0) |
|
1251 { |
|
1252 val = KMmsContentClassImageBasic; |
|
1253 } |
|
1254 else if ((iValueBuffer.CompareF(KImageRich)) == 0) |
|
1255 { |
|
1256 val = KMmsContentClassImageRich; |
|
1257 } |
|
1258 else if ((iValueBuffer.CompareF(KVideoBasic)) == 0) |
|
1259 { |
|
1260 val = KMmsContentClassVideoBasic; |
|
1261 } |
|
1262 else if ((iValueBuffer.CompareF(KVideoRich)) == 0) |
|
1263 { |
|
1264 val = KMmsContentClassVideoRich; |
|
1265 } |
|
1266 else if ((iValueBuffer.CompareF(KMegaPixel)) == 0) |
|
1267 { |
|
1268 val = KMmsContentClassMegaPixel; |
|
1269 } |
|
1270 else if ((iValueBuffer.CompareF(KContentBasic)) == 0) |
|
1271 { |
|
1272 val = KMmsContentClassContentBasic; |
|
1273 } |
|
1274 else if ((iValueBuffer.CompareF(KContentRich)) == 0) |
|
1275 { |
|
1276 val = KMmsContentClassContentRich; |
|
1277 } |
|
1278 else |
|
1279 { |
|
1280 val = KMmsTestIllegalValue; |
|
1281 } |
|
1282 aMmsHeaders.SetContentClass( val ); |
|
1283 break; |
|
1284 case ETestDrmContent: |
|
1285 val = 0; |
|
1286 if ((iValueBuffer.CompareF(KYes)) == 0) |
|
1287 { |
|
1288 val = KMmsYes; |
|
1289 } |
|
1290 else if ((iValueBuffer.CompareF(KNo)) == 0) |
|
1291 { |
|
1292 val = KMmsNo; |
|
1293 } |
|
1294 else |
|
1295 { |
|
1296 val = KMmsTestIllegalValue; |
|
1297 } |
|
1298 aMmsHeaders.SetDrmContent( val ); |
|
1299 break; |
|
1300 case ETestAdaptationAllowed: |
|
1301 val = 0; |
|
1302 if ((iValueBuffer.CompareF(KYes)) == 0) |
|
1303 { |
|
1304 val = KMmsYes; |
|
1305 } |
|
1306 else if ((iValueBuffer.CompareF(KNo)) == 0) |
|
1307 { |
|
1308 val = KMmsNo; |
|
1309 } |
|
1310 else |
|
1311 { |
|
1312 val = KMmsTestIllegalValue; |
|
1313 } |
|
1314 aMmsHeaders.SetAdaptationAllowed( val ); |
|
1315 break; |
|
1316 case ETestRecommendedRetrievalMode: |
|
1317 val = 0; |
|
1318 if ((iValueBuffer.CompareF(KManual)) == 0) |
|
1319 { |
|
1320 val = KMmsRecommendedRetrievalModeManual; |
|
1321 } |
|
1322 else |
|
1323 { |
|
1324 val = KMmsTestIllegalValue; |
|
1325 } |
|
1326 aMmsHeaders.SetRecommendedRetrievalMode( val ); |
|
1327 break; |
|
1328 case ETestRecRetrievalModeText: |
|
1329 aMmsHeaders.SetRecommendedRetrievalModeTextL( iValueBuffer ); |
|
1330 break; |
|
1331 case ETestReplaceId: |
|
1332 iByteBuffer->Des().Copy( iValueBuffer ); |
|
1333 aMmsHeaders.SetReplaceCancelIdL( iByteBuffer->Des() ); |
|
1334 break; |
|
1335 case ETestStatusText: |
|
1336 aMmsHeaders.SetResponseTextL( iValueBuffer ); |
|
1337 break; |
|
1338 case ETestCancelId: |
|
1339 iByteBuffer->Des().Copy( iValueBuffer ); |
|
1340 aMmsHeaders.SetReplaceCancelIdL( iByteBuffer->Des() ); |
|
1341 break; |
|
1342 case ETestCancelStatus: |
|
1343 val = 0; |
|
1344 if ((iValueBuffer.CompareF(KCancelSuccessful)) == 0) |
|
1345 { |
|
1346 val = KMmsCancelRequestSuccessfullyReceived; |
|
1347 } |
|
1348 else if ((iValueBuffer.CompareF(KCancelCorrupted)) == 0) |
|
1349 { |
|
1350 val = KMmsCancelRequestCorrupted; |
|
1351 } |
|
1352 else |
|
1353 { |
|
1354 val = KMmsTestIllegalValue; |
|
1355 } |
|
1356 aMmsHeaders.SetCancelStatus( val ); |
|
1357 break; |
|
1358 default: |
|
1359 break; |
|
1360 } |
|
1361 } |
|
1362 else |
|
1363 { |
|
1364 switch(readStatus) |
|
1365 { |
|
1366 case ETestAlias: |
|
1367 iAliasArray->AppendL( iValueBuffer ); |
|
1368 iAliasCount++; |
|
1369 break; |
|
1370 |
|
1371 default: |
|
1372 break; |
|
1373 } |
|
1374 |
|
1375 } |
|
1376 } |
|
1377 return(-1); |
|
1378 } |
|
1379 |
|
1380 // --------------------------------------------------------- |
|
1381 // CMmsReadFile()::ReadRowL |
|
1382 // --------------------------------------------------------- |
|
1383 // |
|
1384 TTestReadStatus CMmsReadFile::ReadRowL() |
|
1385 { |
|
1386 |
|
1387 TBuf8<DefaultBufLen> RowBuffer; |
|
1388 TBuf8<32> KeyBuffer; |
|
1389 |
|
1390 // READ ONE ROW AND DROP CR+LF FROM THE END OF LINE |
|
1391 TChar delim( 10 ); |
|
1392 iReader->ReadL( RowBuffer, delim); |
|
1393 TInt length = RowBuffer.Length(); |
|
1394 if ( RowBuffer.Length() < 2 ) |
|
1395 { |
|
1396 return ETestEof; |
|
1397 } |
|
1398 RowBuffer.Delete(length - 2,2); |
|
1399 |
|
1400 // DROP POSSIBLE COMMENT OUT |
|
1401 TInt pos = RowBuffer.Locate( ';' ); |
|
1402 if ( pos >= 0 ) RowBuffer.Delete( pos, length-pos-2 ); |
|
1403 |
|
1404 if ( RowBuffer.Length() == 0 ) |
|
1405 { |
|
1406 // the line contained only comment |
|
1407 return ETestUnknown; |
|
1408 } |
|
1409 |
|
1410 // First split the row (:) |
|
1411 pos = RowBuffer.Locate( ':' ); |
|
1412 if (pos > 0) |
|
1413 { |
|
1414 TPtrC8 p = RowBuffer.Mid( pos+1 ); |
|
1415 length = p.Length(); |
|
1416 iValueBuffer.Zero(); |
|
1417 for (TInt i=0; i < length; ++i) |
|
1418 { |
|
1419 iValueBuffer.Append(p[i]); |
|
1420 } |
|
1421 iValueBuffer.Trim(); |
|
1422 TPtrC8 pp = RowBuffer.Left(pos); |
|
1423 KeyBuffer.CopyUC(pp); |
|
1424 KeyBuffer.Trim(); |
|
1425 } |
|
1426 // TRY TO FIND CORRECT TAG |
|
1427 if ((KeyBuffer.CompareF(KTestNewMessage)) == 0) return(ETestNewMessage); |
|
1428 if ((KeyBuffer.CompareF(KTestMessageType)) == 0) return ETestMessageType; |
|
1429 if ((KeyBuffer.CompareF(KTestDate)) == 0) return ETestDate; |
|
1430 if ((KeyBuffer.CompareF(KTestFrom)) == 0) return ETestFrom; |
|
1431 if ((KeyBuffer.CompareF(KTestTo)) == 0) return ETestTo; |
|
1432 if ((KeyBuffer.CompareF(KTestCc)) == 0) return ETestCc; |
|
1433 if ((KeyBuffer.CompareF(KTestBcc)) == 0) return ETestBcc; |
|
1434 if ((KeyBuffer.CompareF(KTestSubject)) == 0) return ETestSubject; |
|
1435 if ((KeyBuffer.CompareF(KTestExpiryRel)) == 0) return ETestExpiryRel; |
|
1436 if ((KeyBuffer.CompareF(KTestExpiryAbs)) == 0) return ETestExpiryAbs; |
|
1437 if ((KeyBuffer.CompareF(KTestDeliveryTimeRel)) == 0) return ETestDeliveryTimeRel; |
|
1438 if ((KeyBuffer.CompareF(KTestDeliveryTimeAbs)) == 0) return ETestDeliveryTimeAbs; |
|
1439 if ((KeyBuffer.CompareF(KTestPriority)) == 0) return ETestPriority; |
|
1440 if ((KeyBuffer.CompareF(KTestSenderVisibility)) == 0) return ETestSenderVisibility; |
|
1441 if ((KeyBuffer.CompareF(KTestDeliveryReport)) == 0) return ETestDeliveryReport; |
|
1442 if ((KeyBuffer.CompareF(KTestReadReply)) == 0) return ETestReadReply; |
|
1443 if ((KeyBuffer.CompareF(KTestNewAttachment)) == 0) return ETestNewAttachment; |
|
1444 if ((KeyBuffer.CompareF(KTestAttachmentName)) == 0) return ETestAttaRecommendedName; |
|
1445 if ((KeyBuffer.CompareF(KTestAttachmentContLoc)) == 0) return ETestAttachmentContLoc; |
|
1446 if ((KeyBuffer.CompareF(KTestAttachmentType)) == 0) return ETestAttachmentType; |
|
1447 if ((KeyBuffer.CompareF(KTestAttachmentCharset)) == 0) return ETestAttachmentCharset; |
|
1448 if ((KeyBuffer.CompareF(KTestAttachmentCid)) == 0) return ETestAttachmentCid; |
|
1449 if ((KeyBuffer.CompareF(KTestAttachmentRoot)) == 0) return ETestAttachmentRoot; |
|
1450 if ((KeyBuffer.CompareF(KTestEndOfFile)) == 0) return ETestEof; |
|
1451 if ((KeyBuffer.CompareF(KTestMessageClass)) == 0) return ETestMessageClass; |
|
1452 if ((KeyBuffer.CompareF(KTestDelivRepSendAllow)) == 0) return ETestDelivReportSendAllow; |
|
1453 if ((KeyBuffer.CompareF(KTestAlias)) == 0 ) return ETestAlias; |
|
1454 if ((KeyBuffer.CompareF(KTestFromAlias)) == 0 ) return ETestFromAlias; |
|
1455 if ((KeyBuffer.CompareF(KTestToAlias)) == 0 ) return ETestToAlias; |
|
1456 if ((KeyBuffer.CompareF(KTestCcAlias)) == 0 ) return ETestCcAlias; |
|
1457 if ((KeyBuffer.CompareF(KTestBccAlias)) == 0 ) return ETestBccAlias; |
|
1458 if ((KeyBuffer.CompareF(KTestReplyCharging)) == 0 ) return ETestReplyCharging; |
|
1459 if ((KeyBuffer.CompareF(KTestReplyChargAbs)) == 0 ) return ETestReplyChargAbs; |
|
1460 if ((KeyBuffer.CompareF(KTestReplyChargRel)) == 0 ) return ETestReplyChargRel; |
|
1461 if ((KeyBuffer.CompareF(KTestReplyChargSize)) == 0 ) return ETestReplyChargSize; |
|
1462 if ((KeyBuffer.CompareF(KTestReplyChargID)) == 0 ) return ETestReplyChargID; |
|
1463 if ((KeyBuffer.CompareF(KTestTID)) == 0 ) return ETestTID; |
|
1464 if ((KeyBuffer.CompareF(KTestContentLocation)) == 0 ) return ETestContentLocation; |
|
1465 if ((KeyBuffer.CompareF(KTestPreviouslySentIndex)) == 0 ) return ETestPreviouslySentIndex; |
|
1466 if ((KeyBuffer.CompareF(KTestPreviouslySentBy)) == 0 ) return ETestPreviouslySentBy; |
|
1467 if ((KeyBuffer.CompareF(KTestPreviouslySentDate)) == 0 ) return ETestPreviouslySentDate; |
|
1468 if ((KeyBuffer.CompareF(KTestMessageId)) == 0 ) return ETestMessageId; |
|
1469 if ((KeyBuffer.CompareF(KTestMessageSize)) == 0 ) return ETestMessageSize; |
|
1470 if ((KeyBuffer.CompareF(KTestVersion)) == 0 ) return ETestVersion; |
|
1471 if ((KeyBuffer.CompareF(KTestReadStatus)) == 0 ) return ETestReadStatus; |
|
1472 if ((KeyBuffer.CompareF(KTestResponseStatus)) == 0 ) return ETestResponseStatus; |
|
1473 if ((KeyBuffer.CompareF(KTestResponseText)) == 0 ) return ETestResponseText; |
|
1474 if ((KeyBuffer.CompareF(KTestRetrieveStatus)) == 0 ) return ETestRetrieveStatus; |
|
1475 if ((KeyBuffer.CompareF(KTestRetrieveText)) == 0 ) return ETestRetrieveText; |
|
1476 if ((KeyBuffer.CompareF(KTestStatus)) == 0 ) return ETestStatus; |
|
1477 if ((KeyBuffer.CompareF(KTestAttribute)) == 0 ) return ETestAttribute; |
|
1478 if ((KeyBuffer.CompareF(KTestDistributionIndicator)) == 0 ) return ETestDistributionIndicator; |
|
1479 if ((KeyBuffer.CompareF(KTestLimit)) == 0 ) return ETestLimit; |
|
1480 if ((KeyBuffer.CompareF(KTestMessageQuota)) == 0 ) return ETestMessageQuota; |
|
1481 if ((KeyBuffer.CompareF(KTestSizeQuota)) == 0 ) return ETestSizeQuota; |
|
1482 if ((KeyBuffer.CompareF(KTestMessageTotal)) == 0 ) return ETestMessageTotal; |
|
1483 if ((KeyBuffer.CompareF(KTestSizeTotal)) == 0 ) return ETestSizeTotal; |
|
1484 if ((KeyBuffer.CompareF(KTestMessageCount)) == 0 ) return ETestMessageCount; |
|
1485 if ((KeyBuffer.CompareF(KTestAddKeyword)) == 0 ) return ETestAddKeyword; |
|
1486 if ((KeyBuffer.CompareF(KTestRemoveKeyword)) == 0 ) return ETestRemoveKeyword; |
|
1487 if ((KeyBuffer.CompareF(KTestFilterKeyword)) == 0 ) return ETestFilterKeyword; |
|
1488 if ((KeyBuffer.CompareF(KTestMMState)) == 0 ) return ETestMMState; |
|
1489 if ((KeyBuffer.CompareF(KTestQuota)) == 0 ) return ETestQuota; |
|
1490 if ((KeyBuffer.CompareF(KTestStart)) == 0 ) return ETestStart; |
|
1491 if ((KeyBuffer.CompareF(KTestStore)) == 0 ) return ETestStore; |
|
1492 if ((KeyBuffer.CompareF(KTestStored)) == 0 ) return ETestStored; |
|
1493 if ((KeyBuffer.CompareF(KTestStoreStatus)) == 0 ) return ETestStoreStatus; |
|
1494 if ((KeyBuffer.CompareF(KTestStoreStatusText)) == 0 ) return ETestStoreStatusText; |
|
1495 if ((KeyBuffer.CompareF(KTestTotals)) == 0 ) return ETestTotals; |
|
1496 if ((KeyBuffer.CompareF(KTestDeleteInfoIndex)) == 0 ) return ETestDeleteInfoIndex; |
|
1497 if ((KeyBuffer.CompareF(KTestApplicId)) == 0 ) return ETestApplicId; |
|
1498 if ((KeyBuffer.CompareF(KTestReplyApplicId)) == 0 ) return ETestReplyApplicId; |
|
1499 if ((KeyBuffer.CompareF(KTestApplicInfo)) == 0 ) return ETestApplicInfo; |
|
1500 if ((KeyBuffer.CompareF(KTestContentClass)) == 0 ) return ETestContentClass; |
|
1501 if ((KeyBuffer.CompareF(KTestDrmContent)) == 0 ) return ETestDrmContent; |
|
1502 if ((KeyBuffer.CompareF(KTestAdaptationAllowed)) == 0 ) return ETestAdaptationAllowed; |
|
1503 if ((KeyBuffer.CompareF(KTestRecommendedRetrievalMode)) == 0 ) return ETestRecommendedRetrievalMode; |
|
1504 if ((KeyBuffer.CompareF(KTestRecRetrievalModeText)) == 0 ) return ETestRecRetrievalModeText; |
|
1505 if ((KeyBuffer.CompareF(KTestReplaceId)) == 0 ) return ETestReplaceId; |
|
1506 if ((KeyBuffer.CompareF(KTestStatusText)) == 0 ) return ETestStatusText; |
|
1507 if ((KeyBuffer.CompareF(KTestCancelId)) == 0 ) return ETestCancelId; |
|
1508 if ((KeyBuffer.CompareF(KTestCancelStatus)) == 0 ) return ETestCancelStatus; |
|
1509 if ((KeyBuffer.CompareF(KTestAttContTypeParamName)) == 0 ) return ETestAttContTypeParamName; |
|
1510 if ((KeyBuffer.CompareF(KTestAttContTypeParamValue)) == 0 ) return ETestAttContTypeParamValue; |
|
1511 if ((KeyBuffer.CompareF(KTestAttXTypeParamName)) == 0 ) return ETestAttXTypeParamName; |
|
1512 if ((KeyBuffer.CompareF(KTestAttXTypeParamValue)) == 0 ) return ETestAttXTypeParamValue; |
|
1513 return ETestUnknown; |
|
1514 } |
|
1515 |
|
1516 // --------------------------------------------------------- |
|
1517 // CMmsReadFile()::CreateMessageL |
|
1518 // program build a message from given parts |
|
1519 // --------------------------------------------------------- |
|
1520 // |
|
1521 void CMmsReadFile::CreateMessageL( CMmsClientMtm* aMmsClient, CMmsHeaders* aMmsHeaders ) |
|
1522 { |
|
1523 |
|
1524 // Reset inactivity timer to keem viewServer from crashing |
|
1525 User::ResetInactivityTime(); |
|
1526 |
|
1527 TInt i; |
|
1528 TInt error = KErrNone; |
|
1529 RFile attaFile; |
|
1530 _LIT8(KLeftAngle, "<"); |
|
1531 _LIT8(KRightAngle, ">"); |
|
1532 // we can't use "seconds from" as it only returns a |
|
1533 // 32 bit signed integer. If fails in 2038. |
|
1534 // "microseconds from" returns a 64 bit signed integer |
|
1535 |
|
1536 CMsvStore* store = aMmsClient->Entry().EditStoreL(); |
|
1537 CleanupStack::PushL(store); |
|
1538 aMmsHeaders->StoreL(*store); |
|
1539 store->CommitL(); |
|
1540 CleanupStack::PopAndDestroy( store ); |
|
1541 store = NULL; |
|
1542 |
|
1543 aMmsClient->LoadMessageL(); // read store is needed to do this |
|
1544 |
|
1545 store = aMmsClient->Entry().EditStoreL(); |
|
1546 CleanupStack::PushL(store); |
|
1547 CMsvAttachment* attaInfo = NULL; |
|
1548 TMsvAttachmentId attaId = 0; |
|
1549 |
|
1550 for ( i=0; i < iAttaStructures->Count(); ++i) |
|
1551 { |
|
1552 attaId = KMsvNullIndexEntryId; |
|
1553 iFilename.Copy(iAttaStructures->At(i)->iAtta->Des()); |
|
1554 |
|
1555 error = attaFile.Open( iFs, iFilename, EFileShareReadersOnly | EFileRead ); |
|
1556 User::LeaveIfError( error ); |
|
1557 |
|
1558 CleanupClosePushL(attaFile); |
|
1559 |
|
1560 CMsvMimeHeaders* mimeHeaders = CMsvMimeHeaders::NewL(); |
|
1561 CleanupStack::PushL( mimeHeaders ); |
|
1562 TPtrC8 contentType = iAttaStructures->At(i)->iAttaType->Des(); |
|
1563 |
|
1564 TDataRecognitionResult result; |
|
1565 result.Reset(); // make sure that it is cleared |
|
1566 |
|
1567 if(iAttaStructures->At(i)->iAttaCid->Length()) |
|
1568 { |
|
1569 TPtr8 attaCID = iAttaStructures->At(i)->iAttaCid->Des(); |
|
1570 if (attaCID.Find(KLeftAngle) == 0 && |
|
1571 attaCID.Find(KRightAngle) == attaCID.Length()-1 ) |
|
1572 { |
|
1573 // remove angle brackets from cid |
|
1574 attaCID = attaCID.Mid(1,attaCID.Length()-2); |
|
1575 } |
|
1576 mimeHeaders->SetContentIdL(attaCID); |
|
1577 } |
|
1578 |
|
1579 if (iAttaStructures->At(i)->iAttaCharset) |
|
1580 { |
|
1581 mimeHeaders->SetMimeCharset(iAttaStructures->At(i)->iAttaCharset); |
|
1582 } |
|
1583 |
|
1584 if (iAttaStructures->At(i)->iAttaName->Length()) |
|
1585 { |
|
1586 iFilename.Copy(iAttaStructures->At(i)->iAttaName->Des()); |
|
1587 } |
|
1588 iParse.Set( iFilename, NULL, NULL ); |
|
1589 iFilename.Copy( iParse.NameAndExt() ); |
|
1590 |
|
1591 mimeHeaders->SetContentLocationL( iFilename ); |
|
1592 |
|
1593 // if Mime type has not been set, use RapaRecognizer |
|
1594 if ( iAttaStructures->At(i)->iAttaType->Length() == 0 && iFilename.Length() > 0) |
|
1595 { |
|
1596 // TO BE IMPLEMENTED |
|
1597 |
|
1598 RApaLsSession lsSession; |
|
1599 |
|
1600 if ( lsSession.Connect() == KErrNone ) |
|
1601 { |
|
1602 CleanupClosePushL( lsSession ); |
|
1603 |
|
1604 iFilename.Copy(iAttaStructures->At(i)->iAtta->Des()); |
|
1605 if ( lsSession.RecognizeData( iFilename, TPtrC8(), result ) == KErrNone ) |
|
1606 { |
|
1607 // Check confidence level. Recognization must be at least |
|
1608 // "EProbable". We don't accept the result if it is "EPossible" |
|
1609 // or "EUnlikely" or "ENotRecognized"! |
|
1610 |
|
1611 if ( result.iConfidence < CApaDataRecognizerType::EProbable ) |
|
1612 { |
|
1613 result.Reset(); // clear buffer and try again with longer buffer |
|
1614 } |
|
1615 |
|
1616 TPtrC8 mimeBuf8 = result.iDataType.Des8(); |
|
1617 |
|
1618 if ( mimeBuf8.Length() == 0 ) |
|
1619 { |
|
1620 // Open file buffer and try again.. |
|
1621 |
|
1622 TInt bufSize = 0; |
|
1623 (void)lsSession.GetMaxDataBufSize( bufSize ); // ignore errors |
|
1624 if ( bufSize <= 0 ) |
|
1625 { |
|
1626 bufSize = 30; |
|
1627 } |
|
1628 HBufC8* buf = HBufC8::NewLC( bufSize ); |
|
1629 TPtr8 des = buf->Des(); |
|
1630 |
|
1631 RFile file; |
|
1632 TInt err=file.Open( iFs, iFilename, EFileShareReadersOnly ); |
|
1633 if ( err == KErrNone ) |
|
1634 { |
|
1635 err = file.Read( des ); |
|
1636 file.Close(); |
|
1637 if ( err == KErrNone ) |
|
1638 { |
|
1639 if ( ( lsSession.RecognizeData( iFilename, des, result ) ) == KErrNone ) |
|
1640 { |
|
1641 mimeBuf8.Set( result.iDataType.Des8() ); |
|
1642 } |
|
1643 } |
|
1644 |
|
1645 } |
|
1646 CleanupStack::PopAndDestroy(); // buf |
|
1647 } |
|
1648 if ( mimeBuf8.Length() > 0 && |
|
1649 result.iConfidence >= CApaDataRecognizerType::EProbable ) |
|
1650 { |
|
1651 contentType.Set( result.iDataType.Des8() ); |
|
1652 } |
|
1653 } |
|
1654 CleanupStack::PopAndDestroy(1); // lssession |
|
1655 } |
|
1656 } |
|
1657 |
|
1658 if ( contentType.Length() > 0 ) |
|
1659 { |
|
1660 TInt position = contentType.Find( KMmsSlash8 ); |
|
1661 if ( position >= 0 ) |
|
1662 { |
|
1663 mimeHeaders->SetContentTypeL( contentType.Left( position ) ); |
|
1664 } |
|
1665 if ( position < contentType.Length() - 1 ) |
|
1666 { |
|
1667 mimeHeaders->SetContentSubTypeL( contentType.Mid( position + 1 ) ); |
|
1668 } |
|
1669 // CreateAttachment2L sets the content type to attaInfo |
|
1670 // attaInfo->SetMimeTypeL( contentType ); |
|
1671 } |
|
1672 |
|
1673 if (iAttaStructures->At(i)->iAttaRecommendedName->Length()) |
|
1674 { |
|
1675 iFilename.Copy(iAttaStructures->At(i)->iAttaRecommendedName->Des()); |
|
1676 iParse.Set( iFilename, NULL, NULL ); |
|
1677 iFilename.Copy( iParse.NameAndExt() ); |
|
1678 mimeHeaders->SetSuggestedFilenameL( iFilename ); |
|
1679 } |
|
1680 |
|
1681 TInt j = 0; |
|
1682 for ( j = 0; j < iAttaStructures->At(i)->iContentTypeParams->MdcaCount(); ++j ) |
|
1683 { |
|
1684 mimeHeaders->ContentTypeParams().AppendL( iAttaStructures->At(i)->iContentTypeParams->MdcaPoint( j ) ); |
|
1685 } |
|
1686 for ( j = 0; j < iAttaStructures->At(i)->iXTypeParams->MdcaCount(); ++j ) |
|
1687 { |
|
1688 mimeHeaders->XTypeParams().AppendL( iAttaStructures->At(i)->iXTypeParams->MdcaPoint( j ) ); |
|
1689 } |
|
1690 |
|
1691 attaInfo = CMsvAttachment::NewL(CMsvAttachment::EMsvFile); |
|
1692 // attaInfo does not go onto cleaunpstack because ownership will |
|
1693 // be transferred to attachment manager. |
|
1694 |
|
1695 aMmsClient->CreateAttachment2L( |
|
1696 *store, |
|
1697 attaFile, |
|
1698 contentType, |
|
1699 *mimeHeaders, |
|
1700 attaInfo, |
|
1701 attaId); |
|
1702 attaInfo = NULL; // ownership transferred |
|
1703 |
|
1704 CleanupStack::PopAndDestroy(); // mimeHeaders |
|
1705 CleanupStack::PopAndDestroy(); // attaFile.Close() |
|
1706 |
|
1707 if ( iAttaRoot > 0 && iAttaRoot == ( i + 1 ) ) |
|
1708 { |
|
1709 aMmsClient->SetMessageRootL( attaId ); |
|
1710 } |
|
1711 } |
|
1712 |
|
1713 store->CommitL(); |
|
1714 CleanupStack::PopAndDestroy(); // store |
|
1715 |
|
1716 // This frees all memory and resets all values |
|
1717 Reset(); |
|
1718 // Reset inactivity timer to keem viewServer from crashing |
|
1719 User::ResetInactivityTime(); |
|
1720 } |
|
1721 |
|
1722 |
|
1723 // --------------------------------------------------------- |
|
1724 // CMmsReadFile()::FindAlias |
|
1725 // program build a message from given parts |
|
1726 // --------------------------------------------------------- |
|
1727 // |
|
1728 TInt CMmsReadFile::FindAlias( TPtrC aAlias ) |
|
1729 { |
|
1730 TBuf<DefaultBufLen> abuf; |
|
1731 for( TInt i=0; i < iAliasCount; ++i ) |
|
1732 { |
|
1733 abuf.Copy( iAliasArray->MdcaPoint(i) ); |
|
1734 abuf.SetLength( abuf.Locate('=') ); |
|
1735 if( ( abuf.CompareF( aAlias ) ) == 0 ) return( i ); |
|
1736 } |
|
1737 return( -1 ); |
|
1738 } |
|
1739 |
|
1740 |
|
1741 // C++ default constructor can NOT contain any code, that |
|
1742 // might leave. |
|
1743 // |
|
1744 CMmsAttaStructure::CMmsAttaStructure() |
|
1745 { |
|
1746 iAtta = NULL; |
|
1747 iAttaType = NULL; |
|
1748 iAttaName = NULL; |
|
1749 iAttaCid = NULL; |
|
1750 iAttaRecommendedName = NULL; |
|
1751 } |
|
1752 |
|
1753 |
|
1754 // |
|
1755 void CMmsAttaStructure::ConstructL() |
|
1756 { |
|
1757 iAtta = HBufC8::NewL(DefaultBufLen); |
|
1758 iAttaType = HBufC8::NewL(DefaultBufLen); |
|
1759 iAttaName = HBufC8::NewL(DefaultBufLen); |
|
1760 iAttaCid = HBufC8::NewL(DefaultBufLen); |
|
1761 iAttaRecommendedName = HBufC::NewL(DefaultBufLen); |
|
1762 iAttaCharset = 0; |
|
1763 iXTypeParams = new(ELeave) CDesC8ArrayFlat(4); |
|
1764 iContentTypeParams = new(ELeave) CDesC8ArrayFlat(4); |
|
1765 |
|
1766 } |
|
1767 |
|
1768 // Two-phased constructor. |
|
1769 CMmsAttaStructure* CMmsAttaStructure::NewL() |
|
1770 { |
|
1771 CMmsAttaStructure* self = new ( ELeave ) CMmsAttaStructure; |
|
1772 CleanupStack::PushL( self ); |
|
1773 self->ConstructL(); |
|
1774 CleanupStack::Pop(); |
|
1775 return self; |
|
1776 } |
|
1777 |
|
1778 // Destructor |
|
1779 CMmsAttaStructure::~CMmsAttaStructure() |
|
1780 { |
|
1781 delete iAtta; |
|
1782 delete iAttaName; |
|
1783 delete iAttaType; |
|
1784 delete iAttaCid; |
|
1785 delete iAttaRecommendedName; |
|
1786 if ( iContentTypeParams ) |
|
1787 { |
|
1788 iContentTypeParams->Reset(); |
|
1789 } |
|
1790 delete iContentTypeParams; |
|
1791 if ( iXTypeParams ) |
|
1792 { |
|
1793 iXTypeParams->Reset(); |
|
1794 } |
|
1795 delete iXTypeParams; |
|
1796 } |
|
1797 |
|
1798 |
|
1799 // End of File |
|