1 /*

     2 * Copyright (c) 2002,2010 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 

    18 

    19 // INCLUDE FILES

    20 #include "obexutilsmessagehandler.h"

    21 #include "obexutilsdebug.h"

    22 #include "obexutilsentryhandler.h"

    23 

    24 #include <msvids.h>

    25 #include <msvuids.h>

    26 #include <apgcli.h>

    27 #include <txtrich.h>

    28 

    29 #include <biouids.h>

    30 #include <bautils.h>

    31 

    32 #include <e32property.h>

    33 #include <UikonInternalPSKeys.h>

    34 

    35 #include <mmsvattachmentmanagersync.h>

    36 #include <mmsvattachmentmanager.h>

    37 

    38 #include <centralrepository.h>

    39 #include <btengdomaincrkeys.h>

    40 #include "updatemusiccollection.h"

    41 

    42 #include <pathinfo.h>          // provides interface for quering system paths 

    43 

    44 #ifdef __BT_SAP

    45  #include "vMessageHandler.h"

    46 #endif // __BT_SAP

    47 

    48 // CONSTANT

    49 const TInt KFFSBelowCritical = -2;

    50 const TInt KRenameOffSet = 4 ;

    51 

    52 // todo @ QT migration: take official definition from Messaging at app layer (btmsgtypeuid.h)

    53 const TUid KUidMsgTypeBt = {0x10009ED5};

    54 

    55 const TInt KObexUtilsMaxCharToFromField = 256;

    56 

    57 const TInt32 KUidMsgTypeBtTInt32 = 0x10009ED5;

    58 

    59 // ============================= LOCAL FUNCTIONS ===============================

    60 

    61 // -----------------------------------------------------------------------------

    62 // RemoveObexBuffer  Removes Obex buffer object.

    63 // -----------------------------------------------------------------------------

    64 //

    65 void TObexUtilsMessageHandler::RemoveObexBuffer(CObexBufObject* &aBufObject)

    66     {

    67     if (aBufObject)

    68         {

    69         delete aBufObject;

    70         aBufObject = NULL;

    71         }

    72     }

    73 

    74 // -----------------------------------------------------------------------------

    75 // CreateMsvSessionLC  Creates MSV session

    76 // -----------------------------------------------------------------------------

    77 //

    78 void TObexUtilsMessageHandler::CreateMsvSessionLC(

    79     CDummySessionObserver* &aSessionObs,

    80     CMsvSession* &aMsvSession)

    81     {

    82     aSessionObs = new( ELeave )CDummySessionObserver;

    83     CleanupStack::PushL( aSessionObs );  //1st push

    84     aMsvSession = CMsvSession::OpenSyncL( *aSessionObs );

    85     CleanupStack::PushL( aMsvSession );  //2nd push

    86     }

    87 

    88 // -----------------------------------------------------------------------------

    89 // CreateMsvSessionLC  Creates MSV session to selected destination

    90 // -----------------------------------------------------------------------------

    91 //

    92 void TObexUtilsMessageHandler::CreateMsvSessionLC(

    93     CDummySessionObserver* &aSessionObs,

    94     CMsvSession* &aMsvSession,

    95     CMsvEntry* &aDestination,

    96     TMsvId aMsvId)

    97     {

    98     CreateMsvSessionLC(aSessionObs, aMsvSession);

    99     aDestination = aMsvSession->GetEntryL( aMsvId );

   100     CleanupStack::PushL( aDestination );  //3rd push

   101     }

   102 

   103 // -----------------------------------------------------------------------------

   104 // GetCenRepKeyIntValueL Gets integer repository value

   105 // Returns: Error

   106 // -----------------------------------------------------------------------------

   107 //

   108 EXPORT_C TInt TObexUtilsMessageHandler::GetCenRepKeyIntValueL(

   109     TUid aRepositoryUid,  // aRepositoryUid Central repository's UID value

   110     TUint32 aId,          // Central repository's ID value

   111     TInt& aVal)           // Returned integer value

   112     {

   113     CRepository* storage = CRepository::NewLC( aRepositoryUid );

   114     TInt retval = storage->Get( aId, aVal );

   115     if (retval != KErrNone)

   116         {

   117         FLOG(_L("[OBEXUTILS]\t GetCenRepKeyIntValueL() Get failed"));

   118         }

   119     CleanupStack::PopAndDestroy( storage );

   120     return retval;

   121     }

   122 

   123 // -----------------------------------------------------------------------------

   124 // GetCurrentTime Gets current time

   125 // Returns: Current time

   126 // -----------------------------------------------------------------------------

   127 //

   128 TTime TObexUtilsMessageHandler::GetCurrentTime()

   129     {

   130     TTime time;

   131     time.UniversalTime();

   132     return time;

   133     }

   134 

   135 // -----------------------------------------------------------------------------

   136 // StoreAsRichTextL Change message content to Richtext

   137 // Returns: None.

   138 // -----------------------------------------------------------------------------

   139 //

   140 void TObexUtilsMessageHandler::StoreAsRichTextL( 

   141     CMsvEntry* aParentEntry,  // A pointer to new message server entry.

   142     RFile& aFile)             // New file to store

   143     {

   144     FLOG(_L("[OBEXUTILS]\t StoreAsRichTextL()"));

   145 

   146     TInt fileLength = 0;

   147     User::LeaveIfError( aFile.Size( fileLength ) );

   148 

   149     // Calculate the number of blocks to read

   150     const TInt blockSize = 128 * 1024;

   151     TInt fullBlockCnt = fileLength / blockSize;

   152     if (fileLength % blockSize > 0)

   153         {

   154         fullBlockCnt++;

   155         }

   156 

   157     CRichText* richText = ConstructRichTextLC(); // 1st, 2nd, 3rd push

   158 

   159     RBuf8 buffer8;

   160     CleanupClosePushL(buffer8);  // 4th push

   161     buffer8.CreateL( blockSize );

   162     RBuf buffer16;

   163     CleanupClosePushL(buffer16); // 5th push

   164     buffer16.CreateL(blockSize);

   165     

   166     // Read the file into buffer in small chunks  

   167     TInt readBytes = 0;

   168     for (TInt i = 0; i < fullBlockCnt; ++i)

   169         {

   170         User::LeaveIfError( aFile.Read( buffer8 ) );

   171     

   172         // In order for Bio to understand 8-bit binary data, 

   173         // it needs to be stored in wide rich text object

   174         // in the low byte of each word with the upper byte as 0.

   175         // Do not use UTF8, just convert 8-bit to 16-bit.  

   176         buffer16.Copy( buffer8 );

   177         

   178         richText->InsertL(readBytes, buffer16);

   179         readBytes += buffer8.Length();

   180         }

   181     CleanupStack::PopAndDestroy(2, &buffer8);

   182     // -2 pop: free unused memory before StoreBodyTextL()

   183 

   184     CMsvStore* parentStore = aParentEntry->EditStoreL();

   185     CleanupStack::PushL(parentStore);   // 4th push

   186     parentStore->StoreBodyTextL(*richText);

   187     parentStore->CommitL();

   188 

   189     CleanupStack::PopAndDestroy(4);  // parentStore, richText, richParaFormatLayer,

   190                                      // richCharFormatLayer

   191 

   192     FLOG(_L("[OBEXUTILS]\t StoreAsRichTextL() completed"));

   193     }

   194 

   195 // -----------------------------------------------------------------------------

   196 // UpdateAttachmentInformationL Add the obex object as a file attachment.

   197 // Returns: None.

   198 // -----------------------------------------------------------------------------

   199 //

   200 void TObexUtilsMessageHandler::UpdateAttachmentInformationL(

   201     TReceivedData& aRecData,      // The obex received data

   202     CMsvEntry* aAttachEntry,      // Attachment entry

   203     CMsvAttachment* aAttachInfo,  // Attachment information

   204     CMsvStore* aStore)            // Message store (attachment)

   205     {

   206     FLOG(_L("[OBEXUTILS]\t UpdateAttachmentInformationL()"));

   207 

   208     TMsvEntry attachTEntry = aAttachEntry->Entry();

   209 

   210     SetDetailsLC(attachTEntry.iDescription, aAttachInfo->MimeType());

   211     attachTEntry.iSize = aRecData.bytesReceived;

   212     attachTEntry.iDate = aRecData.recTime;

   213     aAttachEntry->ChangeL(attachTEntry);  // Save properties.

   214     CleanupStack::PopAndDestroy(); // unicode in SetDetailsLC

   215 

   216     aAttachInfo->SetSize(aRecData.bytesReceived);

   217     aAttachInfo->SetAttachmentNameL(aRecData.msgName);

   218     aAttachInfo->SetComplete(ETrue);

   219 

   220     aStore->AttachmentManagerExtensionsL().ModifyAttachmentInfoL(aAttachInfo);

   221     

   222     FLOG(_L("[OBEXUTILS]\t UpdateAttachmentInformation() completed"));

   223     }

   224 

   225 // -----------------------------------------------------------------------------

   226 // FinaliseMessageL Save the size of all the attachments and make visible.

   227 // Returns: None.

   228 // -----------------------------------------------------------------------------

   229 //

   230 void TObexUtilsMessageHandler::FinaliseMessageL(

   231     CMsvEntry* aParentEntry,  // Parent entry

   232     TReceivedData& aRecData,  // The obex received data

   233     CMsvStore* aStore,        // Attachment's store

   234     TBool aIsBioMsg)          // Is BIO message?

   235     {

   236     FLOG(_L("[OBEXUTILS]\t FinaliseMessageL()"));

   237     // Save the size of all the attachment & make visible.   

   238     TMsvEntry parentTEntry = aParentEntry->Entry();

   239     parentTEntry.iDate = GetCurrentTime();

   240     parentTEntry.iSize = aRecData.bytesReceived;

   241     parentTEntry.SetUnread(ETrue);

   242     

   243     // Saved OK. Make the entry visible and flag it as complete.

   244     parentTEntry.SetVisible(ETrue);                   // visible

   245     parentTEntry.SetInPreparation(EFalse);            // complete

   246     if (!aIsBioMsg)

   247         {

   248         parentTEntry.iDescription.Set(aRecData.msgName);  // "Subject"

   249         }

   250     aParentEntry->ChangeL(parentTEntry);              // commit changes

   251 

   252     aStore->CommitL();

   253     

   254     FLOG(_L("[OBEXUTILS]\t FinaliseMessageL() completed"));

   255     }

   256 

   257 // -----------------------------------------------------------------------------

   258 // FinaliseMessageL Save the size of all the attachments and make visible.

   259 // for Saving file received via BT/IR directly to file system.

   260 // Returns: None.

   261 // -----------------------------------------------------------------------------

   262 //

   263 void TObexUtilsMessageHandler::FinaliseMessageL(

   264     CMsvEntry* aParentEntry,

   265     CMsvStore* aStore,

   266     TEntry& aFileEntry,

   267     TParse& aFileNameParser)

   268     {

   269     FLOG(_L("[OBEXUTILS]\t FinaliseMessageL() new "));

   270     

   271     // Save the size of all the attachment & make visible.

   272     TMsvEntry parentTEntry = aParentEntry->Entry();

   273     parentTEntry.iDate = GetCurrentTime();

   274     parentTEntry.iSize = aFileEntry.iSize;  

   275     // Saved OK. Make the entry visible and flag it as complete.

   276     parentTEntry.SetVisible(ETrue);                   // visible

   277     parentTEntry.SetUnread(ETrue);

   278     parentTEntry.SetInPreparation(EFalse);            // complete

   279     parentTEntry.iDescription.Set(aFileNameParser.FullName());        // "Subject" 

   280     aParentEntry->ChangeL(parentTEntry);              // commit changes

   281     aStore->CommitL();

   282     

   283     FLOG(_L("[OBEXUTILS]\t FinaliseMessageL() new completed "));

   284     }

   285 

   286 // -----------------------------------------------------------------------------

   287 // StoreAndUpdateBioMessageL Stores and updates a BIO message

   288 // Returns: None.

   289 // -----------------------------------------------------------------------------

   290 //

   291 void TObexUtilsMessageHandler::StoreAndUpdateBioMessageL(

   292     CBIODatabase* aBioDB,     // Bio database

   293     TUid aBioMsgId,           // Bio message ID

   294     CMsvEntry* parentEntry,   // Parent message entry

   295     RFile& aFile)             // File to attachment

   296     {

   297     FLOG(_L("[OBEXUTILS]\t StoreAndUpdateBioMessageL()"));

   298     

   299     TInt index;

   300     aBioDB->GetBioIndexWithMsgIDL(aBioMsgId, index);

   301     

   302     StoreAsRichTextL( parentEntry, aFile );

   303     

   304     TMsvEntry parentTEntry = parentEntry->Entry();

   305     parentTEntry.iMtm = KUidBIOMessageTypeMtm;

   306     parentTEntry.iServiceId = KMsvLocalServiceIndexEntryId;  

   307     parentTEntry.iBioType = aBioMsgId.iUid;

   308     parentTEntry.iMtmData1 = KUidMsgTypeBtTInt32;

   309     parentTEntry.iDescription.Set(aBioDB->BifReader(index).Description());

   310     parentEntry->ChangeL(parentTEntry);

   311     

   312     FLOG(_L("[OBEXUTILS]\t StoreAndUpdateBioMessageL() completed"));

   313     }

   314 

   315 // -----------------------------------------------------------------------------

   316 // RecogniseObjectsL Recognised objects if no type field has been given.

   317 // Returns: None.

   318 // -----------------------------------------------------------------------------

   319 //

   320 void TObexUtilsMessageHandler::RecogniseObjectsL(

   321     TFileName& aFileName,

   322     CMsvAttachment* aAttachInfo)  // Attachment information

   323     {

   324     FLOG(_L("[OBEXUTILS]\t RecogniseObjectsL()"));

   325 

   326     TPtrC8 mimeType;

   327     RApaLsSession lsSess;

   328     User::LeaveIfError( lsSess.Connect() );

   329     CleanupClosePushL(lsSess);

   330     TDataType appDataType;

   331     TUid appUid;

   332     if (lsSess.AppForDocument(aFileName, appUid, appDataType) == KErrNone)

   333         {

   334         mimeType.Set(appDataType.Des8());

   335         }

   336     else

   337         {

   338         // Don't trust on sender's MIME type here. Just set to empty.

   339         mimeType.Set(KNullDesC8);

   340         FLOG(_L("[OBEXUTILS]\t RecogniseObjectsL() MIME check failed"));

   341         }

   342     CleanupStack::PopAndDestroy();  // lsSess

   343     HBufC* buf16 = HBufC::NewLC(mimeType.Length());

   344     buf16->Des().Copy(mimeType);

   345     TPtrC mimeType16(buf16->Des());

   346     CleanupStack::PopAndDestroy();   //   buf16

   347     

   348     CUpdateMusicCollection* updateMusicCollection = CUpdateMusicCollection::NewL();

   349     CleanupStack::PushL(updateMusicCollection);    

   350     if (updateMusicCollection->isSupported(mimeType16))

   351         {

   352         updateMusicCollection->addToCollectionL(aFileName);

   353         }

   354     CleanupStack::PopAndDestroy();  // updateMusicCollection

   355     

   356     aAttachInfo->SetMimeTypeL( mimeType );

   357     

   358     FLOG(_L("[OBEXUTILS]\t RecogniseObjectsL() completed"));

   359     }

   360 

   361 // -----------------------------------------------------------------------------

   362 // SaveMimeAndGetBioLC Saves MIME type and gets BIO database for that MIME

   363 // Returns: BIO database if BIO message

   364 // -----------------------------------------------------------------------------

   365 //

   366 CBIODatabase* TObexUtilsMessageHandler::SaveMimeAndGetBioLC(

   367     TFileName& aFileName,

   368     RFs& aFsSess,                 // File session

   369     CMsvAttachment* aAttachInfo,  // Attachment information

   370     TUid &aBioMsgId)              // BIO message ID for data

   371     {

   372     FLOG(_L("[OBEXUTILS]\t TObexUtilsMessageHandler::SaveMimeAndGetBioLC()"));

   373     

   374     RecogniseObjectsL( aFileName, aAttachInfo );

   375 

   376     // For attachments / BIO check.

   377     CBIODatabase* bioDB = CBIODatabase::NewLC( aFsSess );  // 1st push

   378     

   379     // Run through the data objects, seeing if they can be accepted by BIO.

   380     // Check if they are bio objects

   381 

   382     TBioMsgIdText bioMessageIdText;

   383     SetBioDataTextL( bioMessageIdText, aAttachInfo->MimeType() );

   384 

   385     // Remove any zero termination on mime type

   386     //

   387     TInt zeroTermination = bioMessageIdText.Locate( TChar(0) ); 

   388     

   389     if ( zeroTermination != KErrNotFound )

   390         {

   391         bioMessageIdText.SetLength( zeroTermination );

   392         }

   393 

   394     TInt bioMsgErr = bioDB->IsBioMessageL( EBioMsgIdIana, bioMessageIdText, NULL, aBioMsgId );

   395     FLOG(_L("[OBEXUTILS]\t TObexUtilsMessageHandler::SaveMimeAndGetBioLC() completed"));

   396     if (bioMsgErr != KErrNone)

   397         {

   398         return NULL;

   399         }

   400     return bioDB;

   401     }

   402 

   403 // ============================ MEMBER FUNCTIONS ===============================

   404 

   405 // -----------------------------------------------------------------------------

   406 // CreateInboxAttachmentL Creates inbox entry and attachment for it

   407 // If this leaves, it means the entry and obex object have already been deleted.

   408 // In this case aMsvIdParent has been set to zero.

   409 // Returns: None.

   410 // -----------------------------------------------------------------------------

   411 //

   412 EXPORT_C void TObexUtilsMessageHandler::CreateInboxAttachmentL(

   413     CObexBufObject* &aBufObject,  // Obex object

   414     const TUid aMtmId,            // Mtm ID of the message

   415     TMsvId &aMsvIdParent,         // Message ID of the parent message entry

   416     RFile &aFile)                 // File to the attachment

   417     {

   418     TMsvId msvId = 0;

   419     TRAPD(retTrap, DoCreateInboxAttachmentL(aMtmId, msvId, aFile,KNullDesC))

   420     if (retTrap != KErrNone)

   421         {

   422         aMsvIdParent = 0;

   423         if (msvId)

   424             {

   425             RemoveInboxEntriesL(aBufObject, msvId);

   426             }

   427         User::Leave(retTrap);

   428         }

   429     aMsvIdParent = msvId;

   430     }

   431 

   432 // -----------------------------------------------------------------------------

   433 // CreateInboxAttachmentL Creates inbox entry and attachment for it

   434 // If this leaves, it means the entry and obex object have already been deleted.

   435 // In this case aMsvIdParent has been set to zero.

   436 // Returns: None.

   437 // -----------------------------------------------------------------------------

   438 //

   439 EXPORT_C void TObexUtilsMessageHandler::CreateInboxAttachmentL(

   440     CObexBufObject* &aBufObject,  // Obex object

   441     const TUid aMtmId,            // Mtm ID of the message

   442     TMsvId &aMsvIdParent,         // Message ID of the parent message entry

   443     RFile &aFile,                 // File to the attachment

   444     const TDesC& aRemoteBluetoothName)  // bluetooth name of remote device

   445     {

   446     TMsvId msvId = 0;

   447     TRAPD(retTrap, DoCreateInboxAttachmentL(aMtmId, msvId, aFile,aRemoteBluetoothName))

   448     if (retTrap != KErrNone)

   449         {

   450         aMsvIdParent = 0;

   451         if (msvId)

   452             {

   453             RemoveInboxEntriesL(aBufObject, msvId);

   454             }

   455         User::Leave(retTrap);

   456         }

   457     aMsvIdParent = msvId;

   458     }

   459 

   460 // -----------------------------------------------------------------------------

   461 // DoCreateInboxAttachmentL Creates inbox entry and attachment for it (private)

   462 // Returns: None.

   463 // -----------------------------------------------------------------------------

   464 //

   465 void TObexUtilsMessageHandler::DoCreateInboxAttachmentL(

   466     const TUid aMtmId,     // Mtm ID of the message

   467     TMsvId &aMsvIdParent,  // Message ID of the parent message entry

   468     RFile &aFile,          // File to the attachment

   469     const TDesC& aRemoteBluetoothName)  // bluetooth name of remote device

   470     {

   471     FLOG(_L("[OBEXUTILS]\t TObexUtilsMessageHandler::CreateInboxAttachmentL()"));

   472     

   473     CDummySessionObserver* sessionObs;

   474     CMsvSession* msvSession;

   475     CMsvEntry* inbox;

   476     CreateMsvSessionLC(sessionObs, msvSession, inbox, KMsvGlobalInBoxIndexEntryId);

   477     // 1st, 2nd, 3rd push

   478 

   479     TBuf<KObexUtilsMaxCharToFromField> toFrom;

   480 

   481     // todo @ QT migration: load from string id for localization

   482     if (aMtmId == KUidMsgTypeBt)

   483         {

   484         _LIT(KBluetoothMsg, "Bluetooth message");

   485         toFrom.Copy(KBluetoothMsg);

   486         }

   487     else

   488         {

   489         _LIT(KInfraredMsg, "Infrared message");

   490         toFrom.Copy(KInfraredMsg);    

   491         }

   492     

   493     TMsvEntry parentTEntry;

   494     parentTEntry.iMtm = aMtmId;

   495     parentTEntry.SetVisible(EFalse); // Make invisible..

   496     parentTEntry.SetUnread(ETrue);

   497     

   498     // ...and in preparation to make sure it gets cleaned up on errors.

   499     //

   500     parentTEntry.SetInPreparation(ETrue); 

   501     parentTEntry.iType = KUidMsvMessageEntry;

   502     parentTEntry.iServiceId = KMsvUnknownServiceIndexEntryId;

   503     // iDate & iSize will be set later

   504     if ( aRemoteBluetoothName.Length() > 0 )

   505         {

   506         parentTEntry.iDetails.Set(aRemoteBluetoothName);

   507         }

   508     else

   509         {

   510         parentTEntry.iDetails.Set(toFrom);

   511         }

   512     inbox->CreateL(parentTEntry);

   513     

   514     aMsvIdParent = parentTEntry.Id();

   515     

   516     // Create attachment for the inbox entry

   517     

   518     TMsvEntry attachTEntry;

   519     attachTEntry.iType      = KUidMsvAttachmentEntry;

   520     attachTEntry.iServiceId = KMsvUnknownServiceIndexEntryId;   

   521     attachTEntry.iMtm       = aMtmId;

   522     

   523     CMsvEntry* parentEntry = msvSession->GetEntryL(aMsvIdParent);

   524     CleanupStack::PushL(parentEntry);  // 4th push

   525     parentEntry->CreateL(attachTEntry);  // create attachment as child of parent

   526     

   527     // create the v2 attachment, save RFile

   528     

   529     CMsvEntry* attachEntry = msvSession->GetEntryL(attachTEntry.Id());

   530     CleanupStack::PushL(attachEntry);  // 5th push

   531     

   532     CMsvStore* store = attachEntry->EditStoreL();

   533     CleanupStack::PushL(store);  // 6th push

   534     CMsvAttachment* attachment = CMsvAttachment::NewL(CMsvAttachment::EMsvFile);

   535     CleanupStack::PushL(attachment);  // 7th push

   536      

   537     store->AttachmentManagerExtensionsL().CreateAttachmentL(_L("Unnamed"), aFile, attachment);

   538     CleanupStack::Pop(attachment);

   539     store->CommitL();

   540     // CommitL() required here otherwise EditStoreL() will fail in SaveObjToInbox()

   541     

   542     CleanupStack::PopAndDestroy(6);

   543     // store, attachEntry, parentEntry, inbox, msvSession, sessionObs

   544 

   545     FLOG(_L("[OBEXUTILS]\t TObexUtilsMessageHandler::CreateInboxAttachmentL() completed"));

   546     }

   547 

   548 // -----------------------------------------------------------------------------

   549 // CObexUtilsMessageHandler::RemoveInboxEntriesL

   550 // -----------------------------------------------------------------------------

   551 EXPORT_C void TObexUtilsMessageHandler::RemoveInboxEntriesL(

   552     CObexBufObject* &aBufObject, // Obex object

   553     TMsvId aMsvIdParent)         // Message ID of the parent message entry

   554     {

   555     FLOG(_L("[OBEXUTILS]\t TObexUtilsMessageHandler::RemoveInboxEntriesL()"));

   556     

   557     CDummySessionObserver* sessionObs;

   558     CMsvSession* msvSession;

   559     CMsvEntry* inbox;

   560     CreateMsvSessionLC(sessionObs, msvSession, inbox, KMsvGlobalInBoxIndexEntryId);

   561     // 1st, 2nd, 3rd push

   562     

   563     // Close file

   564     

   565     RemoveObexBuffer(aBufObject);

   566     

   567     // Delete parent and descendants

   568     if ( aMsvIdParent )

   569         {

   570         inbox->DeleteL(aMsvIdParent);

   571         }

   572     

   573     CleanupStack::PopAndDestroy(3);

   574     

   575     FLOG(_L("[OBEXUTILS]\t TObexUtilsMessageHandler::RemoveInboxEntriesL() completed"));

   576     }

   577 

   578 // -----------------------------------------------------------------------------

   579 // CObexUtilsMessageHandler::SaveObjToInboxL

   580 // -----------------------------------------------------------------------------

   581 //

   582 EXPORT_C void TObexUtilsMessageHandler::SaveObjToInboxL( 

   583     CObexBufObject* /*aReceivedObject*/, const TDesC16& /*aPath*/, const TUid /*aMtmID*/ )

   584     {

   585     }

   586 

   587 // -----------------------------------------------------------------------------

   588 // CObexUtilsMessageHandler::SaveObjToInboxL

   589 // -----------------------------------------------------------------------------

   590 //

   591 EXPORT_C void TObexUtilsMessageHandler::SaveObjToInboxL(

   592     CObexBufObject* &aReceivedObject, // Obex object

   593     RFile  &aFile,         

   594     TMsvId aMsvIdParent)              // Message ID of the parent message entry

   595     {

   596     FLOG(_L("[OBEXUTILS]\t TObexUtilsMessageHandler::SaveObjToInboxL()"));

   597 

   598     // Open session. 

   599     CDummySessionObserver* sessionObs;

   600     CMsvSession* msvSession;

   601     CreateMsvSessionLC(sessionObs, msvSession);  // 1st, 2nd push

   602 

   603     CMsvEntry* parentEntry = msvSession->GetEntryL(aMsvIdParent);

   604     CleanupStack::PushL( parentEntry );  // 3rd push

   605 

   606 #ifdef __BT_SAP

   607     if(CSapVMessageParser::HandleMessageL(aReceivedObject, parentEntry->Entry().iMtm,

   608         aFile, msvSession, GetCurrentTime()))

   609         {

   610         RemoveObexBuffer(aReceivedObject);

   611         CMsvEntry* inbox = msvSession->GetEntryL( KMsvGlobalInBoxIndexEntryId );

   612         CleanupStack::PushL( inbox );         //4th push

   613         inbox->DeleteL(aMsvIdParent);

   614         // Close session etc.

   615         CleanupStack::PopAndDestroy(4, sessionObs);  // inbox, parentEntry, session, sessionObs

   616         FLOG(_L("[OBEXUTILS]\t TObexUtilsMessageHandler::SaveObjToInboxL() completed"));

   617         return;

   618         }

   619 #endif // __BT_SAP

   620     CMsvEntry* attachEntry = msvSession->GetEntryL(((*parentEntry)[0]).Id());

   621     CleanupStack::PushL(attachEntry); // 4th push

   622 

   623     CMsvStore* store = attachEntry->EditStoreL();

   624     CleanupStack::PushL( store );  // 5th push

   625 

   626     // Collect obex received data before obex buffer deletion

   627 

   628     TReceivedData receivedData;

   629     receivedData.bytesReceived = aReceivedObject->BytesReceived();

   630     receivedData.recTime = aReceivedObject->Time();

   631 

   632     RFs& fsSess = msvSession->FileSession();

   633     receivedData.msgName = aReceivedObject->Name();

   634     MakeValidFileName(fsSess, receivedData.msgName);

   635 

   636     // Rename attachment for MIME type checking

   637     

   638     RemoveObexBuffer(aReceivedObject);

   639     store->AttachmentManagerExtensionsL().RenameAttachmentL(0, receivedData.msgName);

   640     RFile newFile = store->AttachmentManagerL().GetAttachmentFileL(0);

   641     CleanupClosePushL(newFile);  // 6th push

   642     

   643     // RenameAttachmentL() modified attachment info, so read it now

   644     

   645     CMsvAttachment* attachInfo = store->AttachmentManagerL().GetAttachmentInfoL(0);

   646     CleanupStack::PushL( attachInfo ); // 7th push

   647 

   648     TUid bioMsgId;  // SaveMimeAndGetBioLC modifies this

   649     TFileName fileName;

   650     newFile.FullName(fileName);

   651     CBIODatabase* bioDB = SaveMimeAndGetBioLC( fileName, fsSess, attachInfo, bioMsgId );

   652     // 8th push

   653     if (bioDB)  // bio message

   654         {

   655         FLOG(_L("[OBEXUTILS]\t TObexUtilsMessageHandler::SaveObjToInboxL() BIO"));

   656         StoreAndUpdateBioMessageL( bioDB, bioMsgId, parentEntry, newFile );

   657         FinaliseMessageL(parentEntry, receivedData, store, ETrue);

   658         TMsvId attachId = attachEntry->EntryId();

   659         CleanupStack::PopAndDestroy(5);  // bioDB, attachInfo, newFile (close),

   660                                          // store, attachEntry

   661         // PopAndDestroying here because open store locks the entry,

   662         // it can be deleted only after destroying the store pointer

   663         parentEntry->DeleteL(attachId);  // invalidate unused attachment

   664         CleanupStack::PopAndDestroy(3);  // parentEntry, msvSession, sessionObs

   665         FLOG(_L("[OBEXUTILS]\t TObexUtilsMessageHandler::SaveObjToInboxL() BIO completed"));

   666         }

   667     else  // attachment message

   668         {

   669         FLOG(_L("[OBEXUTILS]\t TObexUtilsMessageHandler::SaveObjToInboxL() Attachment"));

   670         CleanupStack::PopAndDestroy();   // bioDB

   671         UpdateAttachmentInformationL(receivedData, attachEntry, attachInfo, store);

   672         CleanupStack::Pop(attachInfo);   // ownership taken by ModifyAttachmentInfoL()

   673         FinaliseMessageL(parentEntry, receivedData, store, EFalse);

   674         CleanupStack::PopAndDestroy(6);  // newFile (close), store, attachEntry,

   675                                          // parentEntry, msvSession, sessionObs

   676         FLOG(_L("[OBEXUTILS]\t TObexUtilsMessageHandler::SaveObjToInboxL() Attachment completed"));

   677         }

   678 

   679     FLOG(_L("[OBEXUTILS]\t TObexUtilsMessageHandler::SaveObjToInboxL() completed"));

   680     }

   681 

   682 

   683 // -----------------------------------------------------------------------------

   684 // GetCenRepKeyStringValueL Gets integer repository value

   685 // Returns: Error

   686 // -----------------------------------------------------------------------------

   687 //

   688 EXPORT_C TInt TObexUtilsMessageHandler::GetCenRepKeyStringValueL(

   689     TUid aRepositoryUid,  // aRepositoryUid Central repository's UID value

   690     TUint32 aId,          // Central repository's ID value

   691     TDes& aVal)           // Returned String

   692     {

   693     CRepository* storage = CRepository::NewLC( aRepositoryUid );

   694     TInt retval = storage->Get( aId, aVal );

   695     if (retval != KErrNone)

   696         {

   697         FLOG(_L("[OBEXUTILS]\t GetCenRepKeyStringValueL() Get failed"));

   698         }

   699     CleanupStack::PopAndDestroy( storage );

   700     return retval;

   701     }

   702 

   703 // -----------------------------------------------------------------------------

   704 // CreateReceiveBufferL Creates an Obex receive buffer object and RFile object.

   705 // Returns: Symbian error code

   706 // -----------------------------------------------------------------------------

   707 //

   708 

   709 EXPORT_C TInt TObexUtilsMessageHandler::CreateReceiveBufferAndRFileL(

   710     RFile& aFile,

   711     const TDesC& aPath,

   712     TFileName& aFullName, 

   713     CBufFlat* &aReceiveObject, 

   714     const TInt aBufSize )  

   715     {

   716     

   717     FLOG(_L("[OBEXUTILS]\t TObexUtilsMessageHandler::CreateReceiveBufferAndRFileL()"));

   718     

   719     aReceiveObject = CBufFlat::NewL(aBufSize); 

   720     aReceiveObject->ResizeL(aBufSize);

   721     

   722     

   723     RFs rfs;

   724     User::LeaveIfError( rfs.Connect() );

   725     if ( !BaflUtils::FolderExists( rfs, aPath ) )

   726         {

   727         User::LeaveIfError(rfs.MkDirAll(aPath));

   728         }

   729     User::LeaveIfError( aFile.Temp( rfs, aPath, aFullName, EFileWrite) );

   730     // Set temp file  hidden file.

   731     //

   732     TUint setAttMask(0);

   733     TUint clearAttMask(0);

   734     aFile.SetAtt(setAttMask | KEntryAttHidden, clearAttMask);

   735     aFile.Flush();

   736     aFile.Close();

   737     

   738     RFile logFile;

   739     TFileName logFilePath;

   740     TFileName cenRepFolder;

   741     GetCenRepKeyStringValueL(KCRUidBluetoothEngine, KLCReceiveFolder,cenRepFolder);

   742     

   743     logFilePath.Zero();

   744     logFilePath.Append(PathInfo::PhoneMemoryRootPath());

   745     logFilePath.Append(cenRepFolder);

   746     

   747     if ( !BaflUtils::FolderExists(rfs , logFilePath) )

   748         {

   749         User::LeaveIfError(rfs.MkDirAll(logFilePath));

   750         }

   751     logFilePath.Append(_L("log.txt"));

   752     if ( !BaflUtils::FileExists( rfs, logFilePath ))

   753         {

   754         logFile.Create(rfs, logFilePath, EFileWrite);

   755         }

   756     else

   757         {

   758         User::LeaveIfError(logFile.Open(rfs, logFilePath, EFileWrite));

   759         }

   760     

   761     FLOG(_L("[OBEXUTILS]\t TObexUtilsMessageHandler::CreateReceiveBufferAndRFileL()    log.txt is created"));

   762     TFileText ft;              

   763     ft.Set(logFile);

   764     ft.Write(aFullName);    // restore tempfilename in logfile

   765 

   766     // Set log file 

   767     logFile.SetAtt(setAttMask | KEntryAttHidden, clearAttMask);

   768     logFile.Flush();

   769     logFile.Close();

   770     rfs.Close();

   771     

   772     FLOG(_L("[OBEXUTILS]\t TObexUtilsMessageHandler::CreateReceiveBufferAndRFileL() completed"));

   773     

   774     return KErrNone;

   775     }

   776 

   777 // -----------------------------------------------------------------------------

   778 // CObexUtilsMessageHandler::RemoveTemporaryRFileL

   779 // -----------------------------------------------------------------------------

   780 //

   781 EXPORT_C void TObexUtilsMessageHandler::RemoveTemporaryRFileL ( const TFileName& aFullName )

   782     {

   783     FLOG(_L("[OBEXUTILS]\t TObexUtilsMessageHandler::RemoveTemporaryRFileL()"));

   784     RFs rfs;

   785     User::LeaveIfError(rfs.Connect());

   786     

   787     TParse fileNameParser;

   788     User::LeaveIfError(fileNameParser.Set(aFullName, NULL, NULL));

   789     

   790     TFileName logFilePath;

   791     TFileName cenRepFolder;

   792     GetCenRepKeyStringValueL(KCRUidBluetoothEngine, KLCReceiveFolder,cenRepFolder);

   793     logFilePath.Zero();

   794     logFilePath.Append(PathInfo::PhoneMemoryRootPath());

   795     logFilePath.Append(cenRepFolder);

   796     logFilePath.Append(_L("log.txt"));

   797             

   798     if ( fileNameParser.Ext().Compare(_L(".$$$")) == 0  )                                                                           

   799         {

   800         // aFullName is a temp file name, we need to remove it.        

   801         rfs.Delete( aFullName );

   802         FLOG(_L("[OBEXUTILS]\t TObexUtilsMessageHandler::RemoveTemporaryRFileL() temp file is removed (bt off)"));

   803         }

   804     else if ( (aFullName.Length() == 0) && BaflUtils::FileExists(rfs, logFilePath))

   805         {

   806         RFile logFile;

   807         User::LeaveIfError(logFile.Open(rfs, logFilePath, EFileRead));

   808         TFileText ft;

   809         ft.Set(logFile);

   810         TFileName tempFileName;

   811         ft.Read(tempFileName);  // read tempfile name stored in logfile.

   812         

   813         if ( tempFileName.Length() > 0 )

   814             {

   815             rfs.Delete(tempFileName);

   816             }

   817         logFile.Close();   

   818         FLOG(_L("[OBEXUTILS]\t TObexUtilsMessageHandler::RemoveTemporaryRFileL() temp files are removed (reboot)"));

   819         }              

   820     rfs.Delete( logFilePath );

   821     rfs.Close();

   822     FLOG(_L("[OBEXUTILS]\t TObexUtilsMessageHandler::RemoveTemporaryRFileL() completed"));

   823     }

   824 // -----------------------------------------------------------------------------

   825 // CObexUtilsMessageHandler::SaveFileToFileSystemL

   826 // -----------------------------------------------------------------------------

   827 //

   828 EXPORT_C void TObexUtilsMessageHandler::SaveFileToFileSystemL(

   829     CObexBufObject* &aReceivedObject,

   830     const TUid aMtmId,

   831     TMsvId& aMsvIdParent,

   832     TFileName& aFullName, 

   833     RFile& aFile,

   834     const TDesC& aSenderBluetoothName)

   835     {

   836    

   837     FLOG(_L("[OBEXUTILS]\t TObexUtilsMessageHandler::SaveFileToFileSystemL()"));

   838     // Create inbox entry ( this was done in CreateAttachment() before )

   839     //

   840     CDummySessionObserver* sessionObs;

   841     CMsvSession* msvSession;

   842     CMsvEntry* inbox;

   843     CreateMsvSessionLC(sessionObs, msvSession, inbox, KMsvGlobalInBoxIndexEntryId);

   844     // 1st, 2nd, 3rd push

   845 

   846     TBuf<KObexUtilsMaxCharToFromField> toFrom;

   847 

   848     // todo @ QT migration: load from string id for localization

   849     if (aMtmId == KUidMsgTypeBt)

   850         {

   851         _LIT(KBluetoothMsg, "Bluetooth message");

   852         toFrom.Copy(KBluetoothMsg);

   853         }

   854     else

   855         {

   856         _LIT(KInfraredMsg, "Infrared message");

   857         toFrom.Copy(KInfraredMsg);    

   858         }

   859     

   860     // NOTE: toFrom will be updated to Bluetooth sender's bt name in the future.

   861 

   862     TMsvEntry parentTEntry;   

   863     parentTEntry.iMtm = aMtmId;

   864     parentTEntry.SetVisible(EFalse); // Make invisible..

   865     parentTEntry.SetUnread(ETrue);  //  Set msg to Unread

   866         

   867     // ...and in preparation to make sure it gets cleaned up on errors.

   868     //

   869     parentTEntry.SetInPreparation(ETrue); 

   870     parentTEntry.iType = KUidMsvMessageEntry;

   871     parentTEntry.iServiceId = KMsvUnknownServiceIndexEntryId;

   872     // iDate & iSize will be set later

   873     if ( aSenderBluetoothName.Length() > 0 )

   874         {

   875         parentTEntry.iDetails.Set(aSenderBluetoothName);

   876         }

   877     else

   878         {

   879         parentTEntry.iDetails.Set(toFrom);

   880         }

   881     inbox->CreateL(parentTEntry);

   882         

   883     aMsvIdParent = parentTEntry.Id();

   884         

   885     // Create attachment for the inbox entry

   886     

   887     TMsvEntry attachTEntry;

   888     attachTEntry.iType      = KUidMsvAttachmentEntry;

   889     attachTEntry.iServiceId = KMsvUnknownServiceIndexEntryId;   

   890     attachTEntry.iMtm       = aMtmId;

   891      

   892     CMsvEntry* parentEntry = msvSession->GetEntryL(aMsvIdParent);

   893     CleanupStack::PushL(parentEntry);  // 4th push

   894     parentEntry->CreateL(attachTEntry);  // create attachment as child of parent

   895   

   896     // Check if message is sap message

   897     // If we delete parent entry in sap, we have to delete the RFile object ourself as well )

   898     //

   899     RFs& fsSess = msvSession->FileSession();

   900     TFileName tempFullName;

   901     aFile.FullName(tempFullName);

   902     

   903 #ifdef __BT_SAP   

   904     if(CSapVMessageParser::HandleMessageL(aReceivedObject, parentEntry->Entry().iMtm,

   905             aFile, msvSession, GetCurrentTime()))

   906         {

   907         RemoveObexBuffer(aReceivedObject);

   908         CMsvEntry* inbox = msvSession->GetEntryL( KMsvGlobalInBoxIndexEntryId );

   909         CleanupStack::PushL( inbox );         //5th push

   910         inbox->DeleteL(aMsvIdParent);

   911         fsSess.Delete(tempFullName);  // we have to use fullname to delete the file object in file system 

   912         // Close session etc.

   913         CleanupStack::PopAndDestroy(5, sessionObs);  // inbox, parentEntry, session, sessionObs

   914         FLOG(_L("[OBEXUTILS]\t TObexUtilsMessageHandler::SaveFileToFileSystemL() completed"));

   915         return;

   916         }

   917 #endif // __BT_SAP

   918 

   919     // Collect obex received data before obex buffer deletion

   920     TReceivedData receivedData;

   921     receivedData.bytesReceived = aReceivedObject->BytesReceived();

   922     receivedData.recTime = aReceivedObject->Time();

   923     receivedData.msgName = aReceivedObject->Name();

   924     

   925     TFileName filename;

   926     TParse parse;

   927     parse.Set(aFullName, NULL, NULL);

   928     filename.Copy(receivedData.msgName);

   929     FixExtremeLongFileName(filename, parse.DriveAndPath());

   930     MakeValidFileName( fsSess, filename);     

   931     RemoveObexBuffer(aReceivedObject);

   932 

   933     // We set file to visible before renaming 

   934     // so that photo/music app can scan the media files we recevie. 

   935     //

   936     // Set file back to visible

   937     //

   938     TUint setAttMask(0);

   939     TUint clearAttMask(0);

   940     User::LeaveIfError(aFile.Open(fsSess,tempFullName,EFileWrite));

   941     User::LeaveIfError(aFile.SetAtt(setAttMask , clearAttMask | KEntryAttHidden));

   942     aFile.Close();

   943     

   944     

   945     // Move file to the actual drive and directory

   946     // as well rename the file with the correct file name instead of temporary name 

   947     // tempFullName will be updated in RenameFileL()    

   948     TInt error = RenameFileL(tempFullName, filename, parse.DriveAndPath(), fsSess);

   949     

   950     if ( error != KErrNone )

   951         {

   952         fsSess.Delete(tempFullName);   // If rename fails, we remove the temp RFile object.

   953         }

   954     aFullName = tempFullName; // assign new full Name back to aFullName,which goes back to caller

   955     

   956     CleanupStack::PopAndDestroy(4);         // parentEntry, inbox, msvSession, sessionObs

   957      

   958     FLOG(_L("[OBEXUTILS]\t TObexUtilsMessageHandler::SaveFileToFileSystemL() completed"));

   959     }

   960 

   961 // -----------------------------------------------------------------------------

   962 // CObexUtilsMessageHandler::AddEntryToInboxL

   963 // -----------------------------------------------------------------------------

   964 //

   965 EXPORT_C void TObexUtilsMessageHandler::AddEntryToInboxL( 

   966     TMsvId& aMsvIdParent,

   967     TFileName& aFullName)

   968     {

   969     FLOG(_L("[OBEXUTILS]\t TObexUtilsMessageHandler::AddEntryToInboxL() "));

   970         

   971     CDummySessionObserver* sessionObs;

   972     CMsvSession* msvSession;

   973     CreateMsvSessionLC(sessionObs, msvSession);

   974     // 1st, 2nd push

   975         

   976     CMsvEntry* parentEntry = msvSession->GetEntryL(aMsvIdParent);

   977     CleanupStack::PushL(parentEntry);  // 3th push

   978     

   979     CMsvEntry* attachEntry = msvSession->GetEntryL(((*parentEntry)[0]).Id());

   980     CleanupStack::PushL(attachEntry); // 4th push

   981             

   982     CMsvStore* store = attachEntry->EditStoreL();

   983     CleanupStack::PushL( store );  // 5th push

   984         

   985     CObexutilsEntryhandler* entryHandler = CObexutilsEntryhandler::NewL();

   986     CleanupStack::PushL(entryHandler);  // 6th push  

   987                 

   988     CMsvAttachment* attachInfo = CMsvAttachment::NewL(CMsvAttachment::EMsvLinkedFile);

   989     CleanupStack::PushL(attachInfo);  // 7th push

   990            

   991     // Create attachment Info

   992     //

   993     RFs& fsSess = msvSession->FileSession();

   994         

   995     TParse fileNameParser;

   996     User::LeaveIfError(fileNameParser.Set(aFullName, NULL, NULL));

   997     attachInfo->SetAttachmentNameL( fileNameParser.FullName());

   998                  

   999     TEntry fileEntry;

  1000     User::LeaveIfError(fsSess.Entry( fileNameParser.FullName(), fileEntry) );

  1001     attachInfo->SetSize(fileEntry.iSize);

  1002             

  1003     // check if it's the bio message

  1004            

  1005     TUid bioMsgId;  // SaveMimeAndGetBioLC modifies this

  1006     CBIODatabase* bioDB = SaveMimeAndGetBioLC( aFullName, fsSess, attachInfo, bioMsgId );

  1007     // 8th push

  1008     if (bioDB)  // bio message

  1009         {

  1010         FLOG(_L("[OBEXUTILS]\t TObexUtilsMessageHandler::AddEntryToInboxL() BIO"));

  1011     

  1012         RFile file;

  1013         User::LeaveIfError(file.Open(fsSess,aFullName,EFileShareReadersOnly));

  1014         TReceivedData receivedData;

  1015         receivedData.bytesReceived = fileEntry.iSize;

  1016         receivedData.recTime = fileEntry.iModified;

  1017         receivedData.msgName = fileNameParser.Name();     

  1018                     

  1019         StoreAndUpdateBioMessageL( bioDB, bioMsgId, parentEntry, file );

  1020         FinaliseMessageL(parentEntry, receivedData, store, ETrue);

  1021         TMsvId attachId = attachEntry->EntryId();

  1022         file.Close();

  1023         fsSess.Delete(aFullName);

  1024         CleanupStack::PopAndDestroy(5);  // bioDB, attachInfo, linkHandler,

  1025                                              // store, attachEntry

  1026             

  1027         // PopAndDestroying here because open store locks the entry,

  1028         // it can be deleted only after destroying the store pointer

  1029         parentEntry->DeleteL(attachId);  // invalidate unused attachment

  1030         CleanupStack::PopAndDestroy(3);  // parentEntry, msvSession, sessionObs

  1031         FLOG(_L("[OBEXUTILS]\t TObexUtilsMessageHandler::AddEntryToInboxL() BIO completed"));

  1032         }

  1033     else

  1034         {

  1035 

  1036         CleanupStack::PopAndDestroy();  // bioDB

  1037         // Add entry to Inbox

  1038         entryHandler->AddEntryAttachment(aFullName, attachInfo, store);

  1039         CleanupStack::Pop(attachInfo);   // attachInfo, Pass ownership to store

  1040         CleanupStack::PopAndDestroy(entryHandler);  // entryHandler

  1041         FinaliseMessageL(parentEntry, store,fileEntry, fileNameParser);

  1042         CleanupStack::PopAndDestroy(5);         // linkHandler, attachInfo, store, attachEntry,

  1043                                                     // parentEntry, msvSession, sessionObs                            

  1044         FLOG(_L("[OBEXUTILS]\t TObexUtilsMessageHandler::AddEntryToInboxL() completed "));

  1045         }

  1046     }

  1047 

  1048 // -----------------------------------------------------------------------------

  1049 // CObexUtilsMessageHandler::AddEntryToInboxL

  1050 // -----------------------------------------------------------------------------

  1051 //

  1052 EXPORT_C void TObexUtilsMessageHandler::AddEntryToInboxL( 

  1053     TMsvId& aMsvIdParent,

  1054     TFileName& aFullName,

  1055     RArray<TMsvId>* aMsvIdArray)

  1056     {

  1057     AddEntryToInboxL(aMsvIdParent, aFullName);

  1058     aMsvIdArray->Append(aMsvIdParent);

  1059     }

  1060 

  1061 // -----------------------------------------------------------------------------

  1062 // CObexUtilsMessageHandler::UpdateEntryAttachmentL

  1063 // -----------------------------------------------------------------------------

  1064 //

  1065 EXPORT_C void TObexUtilsMessageHandler::UpdateEntryAttachmentL ( 

  1066     TFileName& aFullName,

  1067     CMsvEntry* aParentEntry)

  1068     {

  1069     FLOG(_L("[OBEXUTILS]\t TObexUtilsMessageHandler::UpdateEntryAttachmentL() "));

  1070     CDummySessionObserver* sessionObs;

  1071     CMsvSession* msvSession;

  1072     CreateMsvSessionLC(sessionObs, msvSession);

  1073     // 1st, 2nd push

  1074       

  1075     CMsvEntry* attachEntry = msvSession->GetEntryL(((*aParentEntry)[0]).Id());

  1076     CleanupStack::PushL(attachEntry); // 3th push

  1077             

  1078     CMsvStore* store = attachEntry->EditStoreL();

  1079     CleanupStack::PushL( store );  // 4th push

  1080   

  1081     CObexutilsEntryhandler* entryHandler = CObexutilsEntryhandler::NewL();

  1082     CleanupStack::PushL(entryHandler);  // 5th push  

  1083     

  1084     // Note:

  1085     // Because setFilePath() in CMsvAttachment is not implementated by Symbian yet, 

  1086     // we have to delete the original attachment and add another new one to fix the broken link.

  1087     //

  1088     

  1089     // remove the old attachment first.

  1090     //

  1091     store->AttachmentManagerExtensionsL().RemoveAttachmentL(0);

  1092     // Create a new attachment.

  1093     //

  1094     CMsvAttachment* attachInfo = CMsvAttachment::NewL(CMsvAttachment::EMsvLinkedFile);

  1095     CleanupStack::PushL(attachInfo);  // 6th  push

  1096     

  1097     // Get mime type

  1098     //

  1099     RecogniseObjectsL(aFullName, attachInfo);

  1100     RFs& fsSess = msvSession->FileSession();

  1101     

  1102     TParse fileNameParser;

  1103     User::LeaveIfError(fileNameParser.Set(aFullName, NULL, NULL));

  1104     attachInfo->SetAttachmentNameL(fileNameParser.NameAndExt());

  1105     TEntry fileEntry;

  1106     User::LeaveIfError(fsSess.Entry( fileNameParser.FullName(), fileEntry) );

  1107     attachInfo->SetSize(fileEntry.iSize);

  1108 

  1109     entryHandler->AddEntryAttachment(aFullName,attachInfo, store);

  1110     CleanupStack::Pop(attachInfo);   // attachInfo, Pass ownership to store

  1111     CleanupStack::PopAndDestroy(entryHandler);  // entryHandler

  1112     FinaliseMessageL(aParentEntry, store,fileEntry, fileNameParser);

  1113     CleanupStack::PopAndDestroy(4);   // store, 

  1114                                       // attachEntry, msvSession, sessionObs

  1115     FLOG(_L("[OBEXUTILS]\t TObexUtilsMessageHandler::UpdateEntryAttachmentL() completed "));

  1116     }

  1117 

  1118 

  1119 // Common methods

  1120 

  1121 // -----------------------------------------------------------------------------

  1122 // ConstructRichTextLC Handles rich text initialisation.

  1123 // Returns: CRichText* A pointer to the rich text.

  1124 // -----------------------------------------------------------------------------

  1125 //

  1126 CRichText* TObexUtilsMessageHandler::ConstructRichTextLC()

  1127     {

  1128     FLOG(_L("[OBEXUTILS]\t ConstructRichTextLC()"));

  1129 

  1130     CParaFormatLayer* richParaFormatLayer = CParaFormatLayer::NewL();

  1131     CleanupStack::PushL( richParaFormatLayer );

  1132 

  1133     CCharFormatLayer* richCharFormatLayer = CCharFormatLayer::NewL(); 

  1134     CleanupStack::PushL( richCharFormatLayer );