1 // Copyright (c) 2008-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 //

    15 

    16 

    17 /**

    18  * HEADER FILES

    19  */

    20 

    21 #include "cmsvversion1version2converter.h"

    22 #include "cmessageconvertermanager.h"

    23 #include "CMsvCachedStore.h"

    24 #include "MSVUTILS.H"

    25 #include "txtrich.h"

    26 

    27 

    28 // constants

    29 const TInt KArrayGranularity = 16;

    30 const TInt KMaxImHeaderStringLength = 1000;

    31 const TInt KMaxImMimeFieldLength	= 1000;

    32 const TInt KDesCArrayGranularity = 8;

    33 const TInt KMaxBufferLength = 1000;

    34 const TInt KDBCommitCount = 50;

    35 const TInt KMaxLengthOfRecipientField = 50;

    36 const TInt KSmcmSmsNumberMaxNumberLength = 21;

    37 const TInt KSmcmSmsNumberMaxNameLength = 256;							

    38 const TUid KUidMsvSmsEmailFieldsStream	= {0x10204C9D};

    39 const TUid KUidSMSHeaderStream = {0x10001834};

    40 const TUid KMsvEntryFileForSms={0x10003C68};

    41 const TUid KUidMsgFileIMailHeader	= {0x100001D8}; // mail header UID

    42 const TUid KUidMsgFileIMailEncodedHeader = {0x101FD0E3};

    43 const TUid KUidMsgFileMimeHeader	= {0x1000160F};		// 268441103 decimal

    44 const TInt KMaxConverterNumber = 100;

    45 const TInt KMaxPathConverter = 1000;

    46 

    47 //Literals

    48 _LIT16(KSeparator,";");

    49 _LIT16(KComma,",");

    50 _LIT16(KDetails,"");

    51 _LIT16(KSpace,"");

    52 _LIT16(KDelimiter, ";");

    53 

    54 // Sms header fields

    55 _LIT16(KSmsHeadearversion , "SmsHeadearversion");

    56 _LIT16(KSmsRecipientCount , "RecipientCount");

    57 _LIT16(KRecipients , "To");

    58 _LIT16(KSmsFlags , "SmsFlags");

    59 _LIT16(KTextBioMsgIdType,"BioMsgIdType");

    60 

    61 

    62 // global function declaration

    63 extern void ExternalizeL(const CDesC8Array& anArray,RWriteStream& aStream);

    64 extern void InternalizeL(CDesC8Array& anArray,RReadStream& aStream);

    65 extern void ExternalizeL(const CDesC16Array& anArray,RWriteStream& aStream);

    66 extern void InternalizeL(CDesC16Array& anArray,RReadStream& aStream);

    67 

    68 /**

    69 InternalizeL()

    70 

    71 @param anArray: A reference to an array of 16 bit descriptor arrays

    72 @param aStream: The read stream interface

    73 @retun None.

    74 */

    75 void InternalizeL(CDesC8Array& anArray,RReadStream& aStream)

    76 	{

    77 	TCardinality card;

    78 	aStream >> card;

    79 	TInt count=card;

    80 	anArray.Reset();

    81 	for (TInt ii=0;ii<count;++ii)

    82 		{

    83 		HBufC8* buf=HBufC8::NewLC(aStream,KMaxImHeaderStringLength);

    84 		anArray.CArrayFixBase::InsertL(ii,&buf);

    85 		CleanupStack::Pop();

    86 		}

    87 	}

    88 

    89 /**

    90 InternalizeL()

    91 

    92 @param anArray: A reference to an array of 16 bit descriptor arrays

    93 @param aStream: The read stream interface

    94 @retun None.

    95 */

    96 void InternalizeL(CDesC16Array& anArray,RReadStream& aStream)

    97 	{

    98 	TCardinality card;

    99 	aStream >> card;

   100 	TInt count=card;

   101 	anArray.Reset();

   102 	for (TInt ii=0;ii<count;++ii)

   103 		{

   104 		HBufC16* buf=HBufC16::NewLC(aStream,KMaxImHeaderStringLength);

   105 		anArray.CArrayFixBase::InsertL(ii,&buf);

   106 		CleanupStack::Pop();

   107 		}

   108 	}

   109 

   110 /**

   111 HMsvReadBuffer()

   112 

   113 @param aBuf: 8-bit non-modifiable descriptors

   114 @retun None.

   115 */

   116 HMsvReadBuffer::HMsvReadBuffer(const TDesC8 &aBuf)

   117 	{ 

   118 	TUint8* ptr=(TUint8 *)aBuf.Ptr();

   119 	Set(ptr,ptr+aBuf.Length(),ERead);

   120 	}	

   121 	

   122 void HMsvReadBuffer::DoRelease()

   123 	{

   124 	delete this;

   125 	}

   126 	

   127 	

   128 //****************************************************************************************

   129 //              Class TImHeaderEncodingInfo Functions

   130 //****************************************************************************************

   131 

   132 TImHeaderEncodingInfo::TImHeaderEncodingInfo() :  

   133 		iType(ENoEncoding), iAddSpace(EFalse), iCharsetUid(0)

   134 	{

   135 	}

   136 

   137 

   138 /** 

   139 TImHeaderEncodingInfo()

   140 Copy constructor.

   141 

   142 @param aFrom: Object to copy 

   143 */

   144 TImHeaderEncodingInfo::TImHeaderEncodingInfo(const TImHeaderEncodingInfo& aFrom) 

   145 	{

   146 	SetField( aFrom.Field() );

   147 	SetOffset( aFrom.Offset() );

   148 	SetLength( aFrom.Length() );

   149 	SetEncodingType( aFrom.EncodingType() );

   150 	SetArrayValue( aFrom.ArrayValue() );

   151 	SetCharsetUid(aFrom.CharsetUid());

   152 	SetAddSpace( aFrom.AddSpace() ); 

   153 	SetEncodedLength( aFrom.EncodedLength() ); 

   154 	}

   155 

   156 

   157 /** 

   158 InternalizeL()

   159 Internalises the object from the specified stream.

   160 

   161 @param aReadStream Stream to read from */

   162 void TImHeaderEncodingInfo::InternalizeL( RReadStream& aReadStream )

   163 	{

   164 	SetField( (TFieldList) aReadStream.ReadUint16L());

   165 	SetOffset( aReadStream.ReadUint16L());

   166 	SetLength( aReadStream.ReadUint16L());

   167 	SetEncodingType( (TEncodingType) aReadStream.ReadUint16L());

   168 	SetArrayValue( aReadStream.ReadUint16L());

   169 	SetCharsetUid( aReadStream.ReadUint32L());

   170 	SetAddSpace( aReadStream.ReadUint16L());

   171 	SetEncodedLength( aReadStream.ReadUint8L());

   172 	}

   173 

   174 void TImHeaderEncodingInfo::SetField(const TFieldList aField)

   175 	{

   176 	iField = aField;

   177 	}

   178 	

   179 /** 

   180 Gets the field type.

   181 

   182 @return Field type 

   183 */

   184 TImHeaderEncodingInfo::TFieldList TImHeaderEncodingInfo::Field() const

   185 	{

   186 	return iField;

   187 	}

   188 

   189 /** 

   190 Sets the field offset.

   191 

   192 @param aOffset Field offset 

   193 */

   194 void TImHeaderEncodingInfo::SetOffset(const TInt aOffset)

   195 	{

   196 	iOffset = (TUint16)aOffset;

   197 	}

   198 

   199 /** 

   200 Gets the field offset.

   201 

   202 @return Field offset 

   203 */

   204 TInt TImHeaderEncodingInfo::Offset() const

   205 	{

   206 	return iOffset;

   207 	}

   208 

   209 /** 

   210 Sets the field length.

   211 

   212 @param aLength Field length 

   213 */

   214 void TImHeaderEncodingInfo::SetLength(const TInt aLength)

   215 	{

   216 	iLength = (TUint16)aLength;

   217 	}

   218 

   219 /** 

   220 Gets the field length.

   221 

   222 @return Field length 

   223 */

   224 TInt TImHeaderEncodingInfo::Length()  const

   225 	{

   226 	return iLength;

   227 	}

   228 

   229 /** Sets the character set UID.

   230 

   231 @param aUid Character set UID 

   232 */

   233 void TImHeaderEncodingInfo::SetCharsetUid(const TUint aUid)

   234 	{

   235 	iCharsetUid = aUid;

   236 	}

   237 

   238 /** 

   239 Gets the character set UID.

   240 @return Character set UID 

   241 */

   242 TUint TImHeaderEncodingInfo::CharsetUid() const

   243 	{

   244 	return iCharsetUid;

   245 	}

   246 

   247 /** 

   248 Sets the encoding type (string).

   249 @param aChar Encoding type 

   250 */

   251 void TImHeaderEncodingInfo::SetEncodingType(const TDesC8& aChar)

   252 	{

   253 	// If invalid, defaults to QPEncoding

   254 	if (aChar[0] == 'b' || aChar[0] == 'B')

   255 		iType = TImHeaderEncodingInfo::EBase64;

   256 	else if (aChar[0] == 'q' || aChar[0] == 'Q')

   257 		iType = TImHeaderEncodingInfo::EQP;

   258 	else

   259 		iType = TImHeaderEncodingInfo::ENoEncoding;

   260 	}

   261 

   262 /**

   263 Sets the encoding type (enumeration).

   264 

   265 @param aType Encoding type

   266 */

   267 void TImHeaderEncodingInfo::SetEncodingType(const TEncodingType aType)

   268 	{

   269 	iType = aType;

   270 	}

   271 

   272 /** 

   273 Gets the encoding type (enumeration).

   274 

   275 @return Encoding type 

   276 */

   277 TImHeaderEncodingInfo::TEncodingType TImHeaderEncodingInfo::EncodingType()  const

   278 	{

   279 	return iType;

   280 	}

   281 

   282 /** 

   283 Sets the array value.

   284 

   285 @param aValue Array value 

   286 */

   287 void TImHeaderEncodingInfo::SetArrayValue(const TInt aValue)

   288 	{

   289 	iArrayValue = (TUint16)aValue;

   290 	}

   291 

   292 /** 

   293 Gets the array value.

   294 

   295 @return Array value 

   296 */

   297 TInt TImHeaderEncodingInfo::ArrayValue()  const

   298 	{

   299 	return iArrayValue;

   300 	}

   301 

   302 /** 

   303 Sets if a space character needs adding between two adjoining encoded-words.

   304 

   305 @param atrueFalse True to add a space character 

   306 */

   307 void TImHeaderEncodingInfo::SetAddSpace(const TBool atrueFalse)

   308 	{

   309 	iAddSpace = atrueFalse;

   310 	}

   311 

   312 /** 

   313 Tests if the add space character flag is set.

   314 

   315 @return True for added space characters 

   316 */

   317  TBool TImHeaderEncodingInfo::AddSpace() const

   318 	{

   319 	return iAddSpace;

   320 	}

   321 

   322 /** 

   323 Sets the encoded length.

   324 

   325 @param aLength Encoded length 

   326 */

   327 void TImHeaderEncodingInfo::SetEncodedLength(const TInt aLength)

   328 	{

   329 	iEncodedLength = (TInt8) aLength;

   330 	}

   331 

   332 /** 

   333 Gets the encoded length.

   334 

   335 @return Encoded length 

   336 */

   337 TInt TImHeaderEncodingInfo::EncodedLength() const

   338 	{

   339 	return iEncodedLength + (AddSpace() ? 1 : 0);

   340 	}

   341 

   342 

   343 

   344 //****************************************************************************************

   345 //              Class CMsvVersion1Version2Converter Functions

   346 //****************************************************************************************

   347 

   348 

   349 /*

   350 CMsvVersion1Version2Converter()

   351 

   352 @param aDBAdapter: 

   353 @param aMesasgeDBAdapter: 

   354 @retun None.

   355 @internalComponent

   356 */

   357 CMsvVersion1Version2Converter::CMsvVersion1Version2Converter(CMsvDBAdapter& aDBAdapter,CMsvMessageDBAdapter& aMessageDBAdapter,TDriveNumber aDriveNum,TBool aConversionResume)

   358 : iDBAdapter(aDBAdapter),iMessageDBAdapter(aMessageDBAdapter)

   359 	{

   360 	iResume = aConversionResume;

   361 	iDrive = aDriveNum;

   362 	}

   363 

   364 /**

   365 NewL()

   366 

   367 @param aDBAdapter: 

   368 @param aMesasgeDBAdapter: 

   369 @retun None.

   370 @internalComponent

   371 */

   372 CMsvVersion1Version2Converter* CMsvVersion1Version2Converter::NewL(CMsvDBAdapter& aDBAdapter,CMsvMessageDBAdapter& aMessageDBAdapter,TDriveNumber aDriveNum,TBool aConversionResume)

   373 	{

   374 	CMsvVersion1Version2Converter* self = new (ELeave) CMsvVersion1Version2Converter(aDBAdapter,aMessageDBAdapter,aDriveNum,aConversionResume);

   375 	CleanupStack::PushL(self);

   376 	

   377 	self->ConstructL();

   378 

   379 	CleanupStack::Pop(self);

   380 	return self;

   381 	}

   382 

   383 /**

   384 ~CMsvVersion1Version2Converter()

   385 

   386 @param None: 

   387 @retun None.

   388 @internalComponent

   389 */

   390 CMsvVersion1Version2Converter::~CMsvVersion1Version2Converter()

   391 	{

   392 	iConvertedMtmArray.Close();

   393 

   394 	delete iSmsRecipientAddressFields;

   395 	iSmsRecipientAddressFields = NULL;

   396 			

   397 	iRecipientDetails.Close();

   398 	iEmailOverSmsAddress.Close();

   399 

   400 	iEmailfieldPairList.ResetAndDestroy();	

   401 	iEmailfieldPairList.Close();

   402 	iTableFieldPairList.ResetAndDestroy();

   403 	iTableFieldPairList.Close();

   404 		

   405 	delete iEncodingInfo;

   406 	iEncodingInfo = NULL;

   407 	

   408 	iServiceIdArray.Close();

   409 	}	

   410 

   411 /**

   412 ConstructL()

   413 

   414 @param None: 

   415 @retun None.

   416 @internalComponent

   417 */	

   418 void CMsvVersion1Version2Converter::ConstructL()

   419 	{

   420 	iResumeStatus.lastId = 0;

   421 	iResumeStatus.mtmId.iUid = 0;

   422 	iResumeStatus.serviceId = 0;

   423 	iResumeStatus.sourceVersion = 1;

   424 	iResumeStatus.targetVersion = 2;

   425 	iResumeStatus.remainingCount = 0;

   426 	

   427 	iEncodingInfo = new (ELeave) CArrayFixFlat<TImHeaderEncodingInfo>(KArrayGranularity);

   428 	}

   429 

   430 /*

   431 GetPropertyValue()

   432 Gets the value of RProperty object. This value is used to check if cancel request is 

   433 issued for the store conversion in progress

   434 

   435 @param None

   436 @return: Value of the property

   437 @internalComponent

   438 */

   439 TInt CMsvVersion1Version2Converter::GetPropertyValue()

   440 	{

   441 	TInt value;

   442 	TInt err = RProperty::Get(KMyPropertyCat,KMyPropertyName, value);

   443 	return value;

   444 	}

   445 

   446 

   447 /**

   448 ConvertMessageStoreL()

   449 Starts conversion of version 1 message store to version 2

   450 It is responsible for the conversion of sms, imap and pop messages.

   451 It sequentially converts the above MTM's, reading messages and inserting the same in database table

   452 Header tables for MTM's are created only if a service entry is found for it.

   453 It takes care of resuming conversion (RESTART), updation/removal of conversion status table entries,

   454 creation of header tables etc.

   455 

   456 @param None:

   457 @retun None.

   458 @internalComponent

   459 */

   460 void CMsvVersion1Version2Converter::ConvertMessageStoreL()

   461 	{

   462 	// this class will take care of converting all mtms for v1 to v2

   463 

   464 	iConvertedMtmArray.AppendL(KUidMsvSmsMtm);

   465 	iConvertedMtmArray.AppendL(KUidMsgTypeIMAP4); // imap

   466 	iConvertedMtmArray.AppendL(KUidMsgTypePOP3); // pop/smtpKUidMsgTypeSMTP

   467 	iConvertedMtmArray.AppendL(KUidMsgTypeSMTP); // pop/smtpKUidMsgTypeSMTP

   468 			

   469 	TInt pos=0;

   470 	if(iResume)

   471 		{

   472 		iDBAdapter.GetConversionStatusL(iResumeStatus);

   473 		pos = iConvertedMtmArray.Find(iResumeStatus.mtmId);

   474 		

   475 		if (pos == KErrNotFound)// nothing found

   476 			{

   477 			pos = 0;

   478 			iResume = EFalse;

   479 			}		

   480 		}

   481 	

   482 	while(pos < iConvertedMtmArray.Count())

   483 		{

   484 

   485 		TInt mtmId = iConvertedMtmArray[pos].iUid;

   486 		

   487 		switch(mtmId)

   488 			{

   489 			case 0x1000102C: // sms

   490 				{

   491 					/*

   492 					1. Read TMsvIds

   493 					2. Construct path

   494 					3. Create header table for header part

   495 					4. Open file and Read header part and Email over sms part

   496 					5. Insert Header and Email Over sms part into the header table

   497 					6  Open file and Read body part 

   498 					7. Insert body part into the body table

   499 					8. commit the changes.	

   500 					*/

   501 				iResumeStatus.mtmId.iUid = iConvertedMtmArray[pos].iUid;

   502 				iDBAdapter.BeginTransactionL();

   503 				if(iResume)

   504 					{

   505 					// Resume conversion from the last point

   506 					iDBAdapter.GetRemainingServiceIdsL(iServiceIdArray);

   507 					iResume = EFalse;

   508 					}

   509 				else

   510 					{	

   511 					// get all serviceIds belong to sms mtm.

   512 					iDBAdapter.GetAllServiceIDsForMtmL(iConvertedMtmArray[pos].iUid,iServiceIdArray);

   513 					

   514 					//Lets create resume status for all the serviceids

   515 					iResumeStatus.mtmId.iUid = iConvertedMtmArray[pos].iUid;

   516 			

   517 					for(TInt j =0; j < iServiceIdArray.Count(); j++)

   518 						{

   519 						iResumeStatus.lastId = 0;

   520 						

   521 						iResumeStatus.serviceId = iServiceIdArray[j];

   522 						iResumeStatus.sourceVersion = 1;

   523 						iResumeStatus.targetVersion = 2;

   524 						iResumeStatus.remainingCount = iDBAdapter.GetMessageCountL(iServiceIdArray[j]);

   525 						iDBAdapter.AddConversionStatusEntryL(iResumeStatus);

   526 						}

   527 					if(iServiceIdArray.Count() !=0)

   528 						{

   529 						CreateSmsHeaderTableL();

   530 						iMessageDBAdapter.CreateHeaderTableL(TUid::Uid(iResumeStatus.mtmId.iUid),iTableFieldPairList,iLastErrorMessage);

   531 						iTableFieldPairList.ResetAndDestroy();

   532 						}

   533 					}	

   534 	

   535 				iDBAdapter.CommitTransactionL();						

   536 											

   537 				for(TInt serviceIdPosition = 0;serviceIdPosition<iServiceIdArray.Count();serviceIdPosition++)

   538 					{

   539 					/* Read and Insert Header and Body part of Sms Mesasge */

   540 					InternalizeSmsMessageL(iServiceIdArray[serviceIdPosition],iResumeStatus.mtmId.iUid);

   541 					}

   542 				/* remove all conversion status entries */

   543 				for(TInt serviceIdPosition = 0;serviceIdPosition<iServiceIdArray.Count();serviceIdPosition++)

   544 					{

   545 					iDBAdapter.RemoveConversionStatusEntriesL();							

   546 					}

   547 							

   548 				iServiceIdArray.Reset();	

   549 				pos++; // next one is imap

   550 				

   551 				// get all service ids for IMAP

   552 				iDBAdapter.GetAllServiceIDsForMtmL(iConvertedMtmArray[pos].iUid,iServiceIdArray);

   553 				}

   554 			   break;

   555 			case 0x1000102A: // imap

   556 				{

   557 				ConvertEMailImapMessagesL(pos);

   558 			

   559 				iServiceIdArray.Reset();

   560 				pos++; // next one is pop

   561 							

   562 				// get all service ids for POP

   563 				iDBAdapter.GetAllServiceIDsForMtmL(iConvertedMtmArray[pos].iUid,iServiceIdArray);

   564 				

   565 				break;// imap conversion

   566 				}

   567 			

   568 			case 0x10001029:  //email pop/smtp

   569 				{

   570 				ConvertEMailPopMessagesL(pos);

   571 				iServiceIdArray.Reset();

   572 				pos++;

   573 				// get all service ids for POP

   574 				iDBAdapter.GetAllServiceIDsForMtmL(iConvertedMtmArray[pos].iUid,iServiceIdArray);

   575 				

   576 				break;

   577 				}

   578 			

   579 			case 0x10001028:

   580 				{

   581 				ConvertEMailSmtpMessagesL(pos);

   582 				iServiceIdArray.Reset();

   583 				pos++;

   584 				}

   585 			}

   586 		}

   587 	}

   588 

   589 /**

   590 ConvertEMailImapMessagesL()

   591 Converts IMAP message headers

   592 

   593 @param None: 

   594 @retun None.

   595 @internalComponent

   596 */

   597 void CMsvVersion1Version2Converter::ConvertEMailImapMessagesL(TInt aConvertedMtmArrayIndex)

   598 	{

   599 	if(iResume)

   600 		{

   601 		// Resume conversion from the last point

   602 		iDBAdapter.GetRemainingServiceIdsL(iServiceIdArray);

   603 							

   604 		iResume = EFalse;

   605 		}

   606 	else 	// new conversion request

   607 		{

   608 		if(iServiceIdArray.Count())

   609 			{

   610 			/* New request for Imap messages.

   611 			 iServiceIdArray array is filled with all service ids prior to this function call.

   612 			 This ensures we periodically update the conversion resume table and commit the open 

   613 			 transaction with the database*/

   614 			 

   615 			iDBAdapter.BeginTransactionL();

   616 			

   617 			//Lets create resume status for all the serviceids

   618 			iResumeStatus.mtmId.iUid = iConvertedMtmArray[aConvertedMtmArrayIndex].iUid;

   619 

   620 			for(TInt j =0; j < iServiceIdArray.Count(); j++)

   621 				{

   622 				iResumeStatus.lastId = 0;

   623 				

   624 				iResumeStatus.serviceId = iServiceIdArray[j];

   625 				iResumeStatus.sourceVersion = 1;

   626 				iResumeStatus.targetVersion = 2;

   627 				iResumeStatus.remainingCount = iDBAdapter.GetMessageCountL(iServiceIdArray[j]);

   628 				iDBAdapter.AddConversionStatusEntryL(iResumeStatus);

   629 				}

   630 			

   631 			// Create header table

   632 			CreateEMailHeaderTableL(iConvertedMtmArray[aConvertedMtmArrayIndex]);	

   633 						

   634 			iDBAdapter.CommitTransactionL();// done

   635 			}

   636 		}

   637 	iResumeStatus.mtmId.iUid = iConvertedMtmArray[aConvertedMtmArrayIndex].iUid;

   638 	

   639 	StartEMailMessageConversionL(iResumeStatus.mtmId.iUid);

   640 

   641 	// remove all conversion status entries

   642 	iDBAdapter.RemoveConversionStatusEntriesL();	

   643 	}

   644 

   645 /**

   646 ConvertEMailPopMessagesL()

   647 Converts POP message headers.

   648 

   649 @param None:

   650 @retun None.

   651 @internalComponent

   652 */

   653 void CMsvVersion1Version2Converter::ConvertEMailPopMessagesL(TInt aConvertedMtmArrayIndex)

   654 	{

   655 	

   656 	iResumeStatus.mtmId.iUid = iConvertedMtmArray[aConvertedMtmArrayIndex].iUid;

   657 		

   658 	if(iResume)

   659 		{

   660 		// Resume conversion from the last point

   661 		iDBAdapter.GetRemainingServiceIdsL(iServiceIdArray);

   662 		iDBAdapter.GetConversionStatusL(iResumeStatus);

   663 		iResume = EFalse;

   664 		}

   665 	else

   666 		{

   667 		if(iServiceIdArray.Count())

   668 			{

   669 			/* New request for pop messages.

   670 			 iServiceIdArray array is filled with all service ids prior to this function call.

   671 			 This ensures we periodically update the conversion resume table and commit the open 

   672 			 transaction with the database */

   673 			 

   674 			iDBAdapter.BeginTransactionL();

   675 			 

   676 			iTableFieldPairList.ResetAndDestroy();

   677 	

   678 			// Create header table

   679 			CreateEMailHeaderTableL(iConvertedMtmArray[aConvertedMtmArrayIndex]);	

   680 						

   681 			//Lets create resume status for all the serviceids

   682 			iResumeStatus.mtmId.iUid = iConvertedMtmArray[aConvertedMtmArrayIndex].iUid;

   683 			

   684 			for(TInt j =0; j < iServiceIdArray.Count(); j++)

   685 				{

   686 				iResumeStatus.lastId = 0;

   687 				

   688 				iResumeStatus.serviceId = iServiceIdArray[j];

   689 				iResumeStatus.sourceVersion = 1;

   690 				iResumeStatus.targetVersion = 2;

   691 				iResumeStatus.remainingCount = iDBAdapter.GetMessageCountL(iServiceIdArray[j]);

   692 				iDBAdapter.AddConversionStatusEntryL(iResumeStatus);

   693 				}

   694 

   695 			iDBAdapter.CommitTransactionL();// done

   696 			}

   697 		}

   698 	StartEMailMessageConversionL(iResumeStatus.mtmId.iUid);

   699 	

   700 	// remove all conversion ststus entries

   701 	iDBAdapter.RemoveConversionStatusEntriesL();							

   702 	

   703 	}

   704 

   705 /**

   706 ConvertEMailPopMessagesL()

   707 Converts POP message headers.

   708 

   709 @param None:

   710 @retun None.

   711 @internalComponent

   712 */

   713 void CMsvVersion1Version2Converter::ConvertEMailSmtpMessagesL(TInt aConvertedMtmArrayIndex)

   714 	{

   715 	

   716 	iResumeStatus.mtmId.iUid = iConvertedMtmArray[aConvertedMtmArrayIndex].iUid;

   717 		

   718 	if(iResume)

   719 		{

   720 		// Resume conversion from the last point

   721 		iDBAdapter.GetRemainingServiceIdsL(iServiceIdArray);

   722 		iDBAdapter.GetConversionStatusL(iResumeStatus);

   723 		iResume = EFalse;

   724 		}

   725 	else

   726 		{

   727 		if(iServiceIdArray.Count())

   728 			{

   729 			/* New request for smtp messages.

   730 			 iServiceIdArray array is filled with all service ids prior to this function call.

   731 			 This ensures we periodically update the conversion resume table and commit the open 

   732 			 transaction with the database*/

   733 			iDBAdapter.BeginTransactionL();	

   734 			iTableFieldPairList.ResetAndDestroy();

   735 									

   736 			//Lets create resume status for all the serviceids

   737 			iResumeStatus.mtmId.iUid = iConvertedMtmArray[aConvertedMtmArrayIndex].iUid;

   738 			

   739 			TBool messagesFound = EFalse;

   740 			for(TInt j =0; j < iServiceIdArray.Count(); j++)

   741 				{

   742 				iResumeStatus.lastId = 0;

   743 				

   744 				iResumeStatus.serviceId = iServiceIdArray[j];

   745 				iResumeStatus.sourceVersion = 1;

   746 				iResumeStatus.targetVersion = 2;

   747 				iResumeStatus.remainingCount = iDBAdapter.GetMessageCountL(iServiceIdArray[j]);

   748 				if(iResumeStatus.remainingCount != 0)

   749 					{

   750 					messagesFound = ETrue;

   751 					}

   752 				iDBAdapter.AddConversionStatusEntryL(iResumeStatus);

   753 				}

   754 			

   755 			// Create header table if only we have some messages anywhere in the message store

   756 			if(messagesFound)

   757 				{

   758 				CreateEMailHeaderTableL(iConvertedMtmArray[aConvertedMtmArrayIndex]);	

   759 				}

   760 

   761 			iDBAdapter.CommitTransactionL();// done

   762 			}

   763 		}

   764 	StartEMailMessageConversionL(iResumeStatus.mtmId.iUid);

   765 	

   766 	// remove all conversion ststus entries

   767 	iDBAdapter.RemoveConversionStatusEntriesL();							

   768 	

   769 	}

   770 /**

   771 AddFieldL()

   772 Appends a CFieldPair  object for common header fields to RPointerArray of CFieldPair objects

   773 

   774 @param aField: Commonly used header fields

   775 @retun None.

   776 @internalComponent

   777 */

   778 void CMsvVersion1Version2Converter::AddFieldL(TCommonHeaderField aField)

   779 	{

   780 	CFieldPair *fieldObject = new(ELeave) CFieldPair();

   781 	CleanupStack::PushL(fieldObject);

   782 	

   783 	fieldObject->iFieldType = ETextField;

   784 	switch (aField)

   785 		{

   786 		case EFrom:

   787 			_LIT16(KFromText, "From");

   788 			fieldObject->iFieldName = KFromText().AllocL();

   789 			break;

   790 		

   791 		case ETo:

   792 			_LIT16(KToText, "To");

   793 			fieldObject->iFieldName = KToText().AllocL();

   794 			break;

   795 		

   796 		case ECC:

   797 			_LIT16(KCCText, "CC");

   798 			fieldObject->iFieldName = KCCText().AllocL();

   799 			break;

   800 		

   801 		case EBCC:

   802 			_LIT16(KBCCText, "BCC");

   803 			fieldObject->iFieldName = KBCCText().AllocL();

   804 			break;

   805 	

   806 		case ESubject:

   807 			_LIT16(KSubjectText, "Subject");

   808 			fieldObject->iFieldName = KSubjectText().AllocL();

   809 			break;

   810 		

   811 		default:

   812 			User::Leave(KErrArgument);

   813 		}

   814 		

   815 	iTableFieldPairList.AppendL(fieldObject);

   816 	CleanupStack::Pop(fieldObject);

   817 	}

   818 

   819 /**

   820 AddFieldL()

   821 Appends a CFieldPair  object to RPointerArray of CFieldPair objects

   822 

   823 @param aFieldName: Name of the field

   824 @param aFieldType: Field type

   825 @retun None.

   826 @internalComponent

   827 */

   828 void CMsvVersion1Version2Converter::AddFieldL(HBufC* aFieldName, EFieldType aFieldType)

   829 	{

   830 	if(NULL == aFieldName)

   831 		{

   832 		User::Leave(KErrArgument);

   833 		}

   834 

   835 	CFieldPair *fieldObject = new(ELeave) CFieldPair();

   836 	CleanupStack::PushL(fieldObject);

   837 	

   838 	fieldObject->iFieldType = aFieldType;

   839 	fieldObject->iFieldName = aFieldName;

   840 	

   841 	iTableFieldPairList.AppendL(fieldObject);

   842 	CleanupStack::Pop(fieldObject);

   843 	}

   844 

   845 

   846 /**

   847 StartEMailMessageConversionL()

   848 Gets all message IDs for each service entry for the mtm that is being converted.

   849 It creates the path of the message, reads the message and inserts them in database.

   850 For Mime conversion, it checks if the message has attachments and if so than converts its mime information

   851 It periodically updates the conversion status entries in the database and commits the same on the main database.

   852 

   853 @param None:

   854 @retun None.

   855 @internalComponent

   856 */

   857 void CMsvVersion1Version2Converter::StartEMailMessageConversionL(TInt32 aMtm)

   858 	{

   859 	TMsvId iD;

   860 	for(TInt pos = 0; pos<iServiceIdArray.Count();pos++)

   861 		{

   862 		

   863 		

   864 		iDBAdapter.BeginTransactionL();

   865 		

   866 		RArray<TMsvId> iDArray;

   867 		CleanupClosePushL (iDArray);

   868 				

   869 		// Get ids from the last point

   870 		// Note : if we are resuming than value of iResumeStatus.lastId is set to the last

   871 		// message id that was converted, else it is Zero.

   872 		iDBAdapter.GetAllMessageIdsL(iServiceIdArray[pos],iDArray,aMtm, iResumeStatus.lastId);

   873 		iResumeStatus.remainingCount = iDArray.Count();

   874 			

   875 		TInt i=0;

   876 		for (;i<iDArray.Count();i++)

   877 			{

   878 			iResumeStatus.lastId = iDArray[i];

   879 			iResumeStatus.remainingCount--;

   880 						

   881 			iDBAdapter.GetOwningServiceL(iDArray[i],iD);

   882 						

   883 			RBuf path;

   884 			CleanupClosePushL(path);

   885 			path.CreateL(KMaxPath);

   886 						

   887 			CreatePathL(path,iDArray[i],iD);

   888 					

   889 			//Read the message

   890 			TInt headerError = ReadEMailMessageHeaderL(path);

   891 			TInt encodeHeaderError = ReadEMailMessageEncodedHeaderL(path);

   892 	

   893 			if(headerError == KErrNone || encodeHeaderError == KErrNone)

   894 				{

   895 				iMessageDBAdapter.CreateHeaderEntryL(TUid::Uid(iResumeStatus.mtmId.iUid), iDArray[i], iEmailfieldPairList); //header

   896  				iEmailfieldPairList.ResetAndDestroy();

   897 				}

   898 			

   899 			path.Close();

   900 			path.CreateL(KMaxPathConverter);

   901 			// check if this has mime

   902 			

   903 			RArray<TMsvId> mimeIdArray;

   904 			CleanupClosePushL(mimeIdArray);

   905 			

   906 			mimeIdArray.Append(iDArray[i]);

   907 			iDBAdapter.GetAllMimeIdsL(iDArray[i],mimeIdArray);

   908 						

   909 			if(mimeIdArray.Count())

   910 				{

   911 				for(TInt index = 0; index < mimeIdArray.Count();index++)

   912 					{

   913 										

   914 					CreatePathL(path,mimeIdArray[index],iD);

   915 					

   916 					TInt error = ReadEmailMimeHeaderL(path);

   917 					if(!error)

   918 						{

   919 						iMessageDBAdapter.CreateHeaderEntryL(iResumeStatus.mtmId, mimeIdArray[index], iEmailfieldPairList); //header

   920 						iEmailfieldPairList.ResetAndDestroy();

   921 						}

   922 					path.Zero();

   923 					}

   924 				}

   925 			CleanupStack::PopAndDestroy(&mimeIdArray);		

   926 			CleanupStack::PopAndDestroy(); //path	

   927 

   928 			//check if we have a request for cancellation

   929 			TInt cancel = GetPropertyValue();

   930 			if(cancel == KErrCancel	)

   931 				{

   932 				User::Leave(KErrCancel);

   933 				}

   934 				

   935 			//update the conversion status

   936 			if(i % KDBCommitCount == 0 && i != 0)

   937 				{

   938 				iResumeStatus.lastId = iDArray[i];

   939 				iResumeStatus.serviceId = iServiceIdArray[pos];

   940 				iResumeStatus.remainingCount -= KDBCommitCount; 

   941 				

   942 				iDBAdapter.UpdateConversionStatusEntryL(iResumeStatus);

   943 				iDBAdapter.CommitTransactionL();

   944 				iDBAdapter.BeginTransactionL();

   945 				}

   946 			}

   947 		

   948 		CleanupStack::PopAndDestroy(&iDArray);

   949 	

   950 		//update status for this service id

   951 		iResumeStatus.lastId = 0;

   952 		iResumeStatus.serviceId = iServiceIdArray[pos];

   953 		iResumeStatus.remainingCount = 0; 

   954 		iDBAdapter.UpdateConversionStatusEntryL(iResumeStatus);

   955 		iDBAdapter.CommitTransactionL();

   956 		}	

   957 	}

   958 

   959 

   960 

   961 

   962 /**

   963 CreatePathL()

   964 Creates path of aessage. The path is constructed based on the message id and its owning service id.

   965 

   966 @param aMessagePath: Message path

   967 @param aId: Message id

   968 @param aOwningId: owning id.

   969 @retun None.

   970 @internalComponent

   971 */

   972 void CMsvVersion1Version2Converter::CreatePathL(TDes& aMessagePath, TMsvId aId,TMsvId& aOwningId)

   973 	{

   974 	// Construct the mail path for this message entry

   975 	_LIT16(KMessageFilePath,"\\private\\1000484b\\mail2\\");

   976 	TBuf<KMaxPath> src;

   977 	TPtrC drive(TDriveUnit(iDrive).Name());

   978 				

   979 	aMessagePath.Append(drive);

   980 	aMessagePath.Append(KMessageFilePath);

   981 	

   982 	TBuf<KFileNameFixedWidth> dir;

   983 	dir.NumFixedWidth(aOwningId, EHex, KFileNameFixedWidth);

   984 	_LIT16(KMsvDirectoryExt, "_S\\");

   985 	aMessagePath.Append(dir);

   986 	aMessagePath.Append(KMsvDirectoryExt);

   987 		

   988 	_LIT16(KDirSep,"\\");

   989 	TBuf<KFileNameFixedWidth> dir1;

   990 	

   991 	dir1.NumFixedWidth(aId&0xf, EHex,1);

   992 	aMessagePath.Append(dir1);

   993 	aMessagePath.Append(KDirSep);

   994 	dir.NumFixedWidth(aId, EHex, KFileNameFixedWidth);	

   995 	aMessagePath.Append(dir);

   996 	}

   997 

   998 /**

   999 CreateEMailHeaderTableL()

  1000 Creates structure necessary to create email header table.

  1001 

  1002 @param aMtmId: mtm Id of email component.

  1003 @retun None.

  1004 @internalComponent

  1005 */

  1006 void CMsvVersion1Version2Converter::CreateEMailHeaderTableL(const TUid aMtmId)

  1007 	{

  1008 	CreateEMailHeaderTableStructureL();

  1009 	iMessageDBAdapter.CreateHeaderTableL(aMtmId,iTableFieldPairList,iLastErrorMessage);

  1010 	}

  1011 

  1012 /**

  1013 CreateEMailHeaderTableStructureL()

  1014 Creates structure necessary to create email header table.

  1015 

  1016 @param None:

  1017 @retun None.

  1018 @internalComponent

  1019 */

  1020 void CMsvVersion1Version2Converter::CreateEMailHeaderTableStructureL()

  1021 	{

  1022 	_LIT16(KEmailHeaderVersion , "Version");

  1023 	AddFieldL(KEmailHeaderVersion().AllocL(),EIntegerField); //0

  1024 	

  1025 	_LIT16(KReceiptAddress , "ReceiptAddress");

  1026 	AddFieldL(KReceiptAddress().AllocL(),ETextField);//1

  1027 	

  1028 	_LIT16(KImMsgId , "ImMsgId");

  1029 	AddFieldL(KImMsgId().AllocL(),ETextField);//2

  1030 

  1031 	AddFieldL(EFrom);//3

  1032 	

  1033 	_LIT16(KReplyTo , "ReplyTo");

  1034 	AddFieldL(KReplyTo().AllocL(),ETextField);//4

  1035 	

  1036 	AddFieldL(ESubject);//5

  1037 

  1038 	_LIT16(KiRemoteSize , "iRemoteSize");

  1039 	AddFieldL(KiRemoteSize().AllocL(),EIntegerField);//6

  1040 	

  1041 	AddFieldL(ETo);//7

  1042 	

  1043 	AddFieldL(ECC);//8

  1044 				

  1045 	AddFieldL(EBCC);//9

  1046 

  1047 	_LIT16(KEncodingInfo , "EncodingInfo");

  1048 	AddFieldL(KEncodingInfo().AllocL(),ETextField);//10

  1049 	

  1050 	_LIT16(KResentMsgId , "ResentMsgId");

  1051 	AddFieldL(KResentMsgId().AllocL(),ETextField);//11

  1052 

  1053 	_LIT16(KResentFrom , "ResentFrom");

  1054 	AddFieldL(KResentFrom().AllocL(),ETextField);//12

  1055 

  1056 	_LIT16(KResentToRecipients , "ResentToRecipients");

  1057 	AddFieldL(KResentToRecipients().AllocL(),ETextField);//13

  1058 

  1059 	_LIT16(KResentCcRecipients , "ResentCcRecipients");

  1060 	AddFieldL(KResentCcRecipients().AllocL(),ETextField);//14

  1061 	

  1062 	_LIT16(KResentBccRecipients , "ResentBccRecipients");

  1063 	AddFieldL(KResentBccRecipients().AllocL(),ETextField);//15

  1064 

  1065 	_LIT16(KInReplyTo , "InReplyTo");

  1066 	AddFieldL(KInReplyTo().AllocL(),ETextField);//16

  1067 

  1068 	_LIT16(KBodyEncoding , "BodyEncoding");

  1069 	AddFieldL(KBodyEncoding().AllocL(),EIntegerField);//17

  1070 

  1071 	_LIT16(KCharset , "Charset");

  1072 	AddFieldL(KCharset().AllocL(),EIntegerField);//18

  1073 	}

  1074 

  1075 /**

  1076 EncodingInfo()

  1077 Returns TImHeaderEncodingInfo header encoding info.

  1078 

  1079 @param None:

  1080 @retun None.

  1081 @internalComponent

  1082 */

  1083 CArrayFix<TImHeaderEncodingInfo>& CMsvVersion1Version2Converter::EncodingInfo()

  1084 	{

  1085 	return *iEncodingInfo;

  1086 	}

  1087 

  1088 /**

  1089 ReadEMailMessageHeaderL()

  1090 Reads an email message header from the specified path and fills 	RPointerArray of CHeaderFields

  1091 from the header objects.

  1092 

  1093 @param aMessagePath: Message path.

  1094 @retun None.

  1095 @internalComponent

  1096 */

  1097 TInt CMsvVersion1Version2Converter::ReadEMailMessageHeaderL(TDesC& aMessagePath)

  1098 	{

  1099 	RFs fs;

  1100 	User::LeaveIfError(fs.Connect());

  1101 	CleanupClosePushL(fs);	

  1102 	

  1103 	RFile file;

  1104 	TInt error = file.Open(fs,aMessagePath,EFileRead);

  1105 	

  1106 	if(error != KErrNone)

  1107 		{

  1108 		CleanupStack::PopAndDestroy(&fs); //fs

  1109 		file.Close();

  1110 		fs.Close();

  1111 		return EFalse;

  1112 		}

  1113 	

  1114 	CleanupClosePushL(file);

  1115 	

  1116 	RFileReadStream in(file);

  1117 	in.PushL();

  1118 

  1119 	TCheckedUid check;

  1120 	in >> check;

  1121 	if(check.UidType().IsValid()==EFalse) 

  1122 		return EFalse;

  1123 	

  1124 	CArrayFix<TPairedTUidHBufC8>* iStreams = new(ELeave) CArrayFixFlat<TPairedTUidHBufC8>(5);

  1125 	in >> *iStreams;; 

  1126 

  1127 	// check if this stream is present

  1128 	TPairedTUidHBufC8 entry;

  1129 	entry.iUid=KUidMsgFileIMailHeader;

  1130 	TKeyArrayFix key(_FOFF(TPairedTUidHBufC8,iUid),ECmpTInt32);

  1131 	

  1132 	TInt pos;

  1133 	TInt found = (iStreams->FindIsq(entry,key,pos));

  1134