/*

* Copyright (c) 2002,2010 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of "Eclipse Public License v1.0"

* which accompanies this distribution, and is available

* at the URL "http://www.eclipse.org/legal/epl-v10.html".

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description: 

*

*/

// INCLUDE FILES

#include "obexutilsmessagehandler.h"

#include "obexutilsuilayer.h"

#include "obexutilsdebug.h"

#include "obexutilsentryhandler.h"

#include <msvids.h>

#include <msvuids.h>

#include <apgcli.h>

#include <txtrich.h>

#include <biouids.h>

#include <Obexutils.rsg>

#include <bautils.h>

#include <e32property.h>

#include <UikonInternalPSKeys.h>

#include <mmsvattachmentmanagersync.h>

#include <mmsvattachmentmanager.h>

#include <centralrepository.h>

#include <btengdomaincrkeys.h>

#include "updatemusiccollection.h"

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

#ifdef __BT_SAP

 #include "vMessageHandler.h"

#endif // __BT_SAP

// CONSTANT

const TInt KFFSBelowCritical = -2;

const TInt KRenameOffSet = 4 ;

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

// -----------------------------------------------------------------------------

// RemoveObexBuffer  Removes Obex buffer object.

// -----------------------------------------------------------------------------

//

void TObexUtilsMessageHandler::RemoveObexBuffer(CObexBufObject* &aBufObject)

    {

    if (aBufObject)

        {

        delete aBufObject;

        aBufObject = NULL;

        }

    }

// -----------------------------------------------------------------------------

// CreateMsvSessionLC  Creates MSV session

// -----------------------------------------------------------------------------

//

void TObexUtilsMessageHandler::CreateMsvSessionLC(

    CDummySessionObserver* &aSessionObs,

    CMsvSession* &aMsvSession)

    {

    aSessionObs = new( ELeave )CDummySessionObserver;

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

    aMsvSession = CMsvSession::OpenSyncL( *aSessionObs );

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

    }

// -----------------------------------------------------------------------------

// CreateMsvSessionLC  Creates MSV session to selected destination

// -----------------------------------------------------------------------------

//

void TObexUtilsMessageHandler::CreateMsvSessionLC(

    CDummySessionObserver* &aSessionObs,

    CMsvSession* &aMsvSession,

    CMsvEntry* &aDestination,

    TMsvId aMsvId)

    {

    CreateMsvSessionLC(aSessionObs, aMsvSession);

    aDestination = aMsvSession->GetEntryL( aMsvId );

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

    }

// -----------------------------------------------------------------------------

// GetCenRepKeyIntValueL Gets integer repository value

// Returns: Error

// -----------------------------------------------------------------------------

//

EXPORT_C TInt TObexUtilsMessageHandler::GetCenRepKeyIntValueL(

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

    TUint32 aId,          // Central repository's ID value

    TInt& aVal)           // Returned integer value

    {

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

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

    if (retval != KErrNone)

        {

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

        }

    CleanupStack::PopAndDestroy( storage );

    return retval;

    }

// -----------------------------------------------------------------------------

// GetCurrentTime Gets current time

// Returns: Current time

// -----------------------------------------------------------------------------

//

TTime TObexUtilsMessageHandler::GetCurrentTime()

    {

    TTime time;

    time.UniversalTime();

    return time;

    }

// -----------------------------------------------------------------------------

// StoreAsRichTextL Change message content to Richtext

// Returns: None.

// -----------------------------------------------------------------------------

//

void TObexUtilsMessageHandler::StoreAsRichTextL( 

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

    RFile& aFile)             // New file to store

    {

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

    TInt fileLength = 0;

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

    // Calculate the number of blocks to read

    const TInt blockSize = 128 * 1024;

    TInt fullBlockCnt = fileLength / blockSize;

    if (fileLength % blockSize > 0)

        {

        fullBlockCnt++;

        }

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

    RBuf8 buffer8;

    CleanupClosePushL(buffer8);  // 4th push

    buffer8.CreateL( blockSize );

    RBuf buffer16;

    CleanupClosePushL(buffer16); // 5th push

    buffer16.CreateL(blockSize);

    // Read the file into buffer in small chunks  

    TInt readBytes = 0;

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

        {

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

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

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

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

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

        buffer16.Copy( buffer8 );

        richText->InsertL(readBytes, buffer16);

        readBytes += buffer8.Length();

        }

    CleanupStack::PopAndDestroy(2, &buffer8);

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

    CMsvStore* parentStore = aParentEntry->EditStoreL();

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

    parentStore->StoreBodyTextL(*richText);

    parentStore->CommitL();

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

                                     // richCharFormatLayer

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

    }

// -----------------------------------------------------------------------------

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

// Returns: None.

// -----------------------------------------------------------------------------

//

void TObexUtilsMessageHandler::UpdateAttachmentInformationL(

    TReceivedData& aRecData,      // The obex received data

    CMsvEntry* aAttachEntry,      // Attachment entry

    CMsvAttachment* aAttachInfo,  // Attachment information

    CMsvStore* aStore)            // Message store (attachment)

    {

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

    TMsvEntry attachTEntry = aAttachEntry->Entry();

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

    attachTEntry.iSize = aRecData.bytesReceived;

    attachTEntry.iDate = aRecData.recTime;

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

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

    aAttachInfo->SetSize(aRecData.bytesReceived);

    aAttachInfo->SetAttachmentNameL(aRecData.msgName);

    aAttachInfo->SetComplete(ETrue);

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

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

    }

// -----------------------------------------------------------------------------

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

// Returns: None.

// -----------------------------------------------------------------------------

//

void TObexUtilsMessageHandler::FinaliseMessageL(

    CMsvEntry* aParentEntry,  // Parent entry

    TReceivedData& aRecData,  // The obex received data

    CMsvStore* aStore,        // Attachment's store

    TBool aIsBioMsg)          // Is BIO message?

    {

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

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

    TMsvEntry parentTEntry = aParentEntry->Entry();

    parentTEntry.iDate = GetCurrentTime();

    parentTEntry.iSize = aRecData.bytesReceived;

    parentTEntry.SetUnread(ETrue);

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

    parentTEntry.SetVisible(ETrue);                   // visible

    parentTEntry.SetInPreparation(EFalse);            // complete

    if (!aIsBioMsg)

        {

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

        }

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

    aStore->CommitL();

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

    }

// -----------------------------------------------------------------------------

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

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

// Returns: None.

// -----------------------------------------------------------------------------

//

void TObexUtilsMessageHandler::FinaliseMessageL(

    CMsvEntry* aParentEntry,

    CMsvStore* aStore,

    TEntry& aFileEntry,

    TParse& aFileNameParser)

    {

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

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

    TMsvEntry parentTEntry = aParentEntry->Entry();

    parentTEntry.iDate = GetCurrentTime();

    parentTEntry.iSize = aFileEntry.iSize;  

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

    parentTEntry.SetVisible(ETrue);                   // visible

    parentTEntry.SetUnread(ETrue);

    parentTEntry.SetInPreparation(EFalse);            // complete

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

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

    aStore->CommitL();

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

    }

// -----------------------------------------------------------------------------

// StoreAndUpdateBioMessageL Stores and updates a BIO message

// Returns: None.

// -----------------------------------------------------------------------------

//

void TObexUtilsMessageHandler::StoreAndUpdateBioMessageL(

    CBIODatabase* aBioDB,     // Bio database

    TUid aBioMsgId,           // Bio message ID

    CMsvEntry* parentEntry,   // Parent message entry

    RFile& aFile)             // File to attachment

    {

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

    TInt index;

    aBioDB->GetBioIndexWithMsgIDL(aBioMsgId, index);

    StoreAsRichTextL( parentEntry, aFile );

    TMsvEntry parentTEntry = parentEntry->Entry();

    parentTEntry.iMtm = KUidBIOMessageTypeMtm;

    parentTEntry.iServiceId = KMsvLocalServiceIndexEntryId;  

    parentTEntry.iBioType = aBioMsgId.iUid;

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

    parentEntry->ChangeL(parentTEntry);

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

    }

// -----------------------------------------------------------------------------

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

// Returns: None.

// -----------------------------------------------------------------------------

//

void TObexUtilsMessageHandler::RecogniseObjectsL(

    TFileName& aFileName,

    CMsvAttachment* aAttachInfo)  // Attachment information

    {

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

    TPtrC8 mimeType;

    RApaLsSession lsSess;

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

    CleanupClosePushL(lsSess);

    TDataType appDataType;

    TUid appUid;

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

        {

        mimeType.Set(appDataType.Des8());

        }

    else

        {

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

        mimeType.Set(KNullDesC8);

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

        }

    CleanupStack::PopAndDestroy();  // lsSess

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

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

    TPtrC mimeType16(buf16->Des());

    CleanupStack::PopAndDestroy();   //   buf16

    CUpdateMusicCollection* updateMusicCollection = CUpdateMusicCollection::NewL() ;

    if (updateMusicCollection->isSupported(mimeType16))

        {

        updateMusicCollection->addToCollectionL(aFileName);

        }

    aAttachInfo->SetMimeTypeL( mimeType );

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

    }

// -----------------------------------------------------------------------------

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

// Returns: BIO database if BIO message

// -----------------------------------------------------------------------------

//

CBIODatabase* TObexUtilsMessageHandler::SaveMimeAndGetBioLC(

    TFileName& aFileName,

    RFs& aFsSess,                 // File session

    CMsvAttachment* aAttachInfo,  // Attachment information

    TUid &aBioMsgId)              // BIO message ID for data

    {

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

    RecogniseObjectsL( aFileName, aAttachInfo );

    // For attachments / BIO check.

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

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

    // Check if they are bio objects

    TBioMsgIdText bioMessageIdText;

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

    // Remove any zero termination on mime type

    //

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

    if ( zeroTermination != KErrNotFound )

        {

        bioMessageIdText.SetLength( zeroTermination );

        }

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

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

    if (bioMsgErr != KErrNone)

        {

        return NULL;

        }

    return bioDB;

    }

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

// -----------------------------------------------------------------------------

// CreateInboxAttachmentL Creates inbox entry and attachment for it

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

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

// Returns: None.

// -----------------------------------------------------------------------------

//

EXPORT_C void TObexUtilsMessageHandler::CreateInboxAttachmentL(

    CObexBufObject* &aBufObject,  // Obex object

    const TUid aMtmId,            // Mtm ID of the message

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

    RFile &aFile)                 // File to the attachment

    {

    TMsvId msvId = 0;

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

    if (retTrap != KErrNone)

        {

        aMsvIdParent = 0;

        if (msvId)

            {

            RemoveInboxEntriesL(aBufObject, msvId);

            }

        User::Leave(retTrap);

        }

    aMsvIdParent = msvId;

    }

// -----------------------------------------------------------------------------

// CreateInboxAttachmentL Creates inbox entry and attachment for it

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

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

// Returns: None.

// -----------------------------------------------------------------------------

//

EXPORT_C void TObexUtilsMessageHandler::CreateInboxAttachmentL(

    CObexBufObject* &aBufObject,  // Obex object

    const TUid aMtmId,            // Mtm ID of the message

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

    RFile &aFile,                 // File to the attachment

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

    {

    TMsvId msvId = 0;

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

    if (retTrap != KErrNone)

        {

        aMsvIdParent = 0;

        if (msvId)

            {

            RemoveInboxEntriesL(aBufObject, msvId);

            }

        User::Leave(retTrap);

        }

    aMsvIdParent = msvId;

    }

// -----------------------------------------------------------------------------

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

// Returns: None.

// -----------------------------------------------------------------------------

//

void TObexUtilsMessageHandler::DoCreateInboxAttachmentL(

    const TUid aMtmId,     // Mtm ID of the message

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

    RFile &aFile,          // File to the attachment

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

    {

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

    CDummySessionObserver* sessionObs;

    CMsvSession* msvSession;

    CMsvEntry* inbox;

    CreateMsvSessionLC(sessionObs, msvSession, inbox, KMsvGlobalInBoxIndexEntryId);

    // 1st, 2nd, 3rd push

    TBuf<KObexUtilsMaxCharToFromField> toFrom;

    TInt resourceId;

    if (aMtmId == KUidMsgTypeBt)

        {

        resourceId = R_BT_TO_FROM_IN_INBOX;

        }

    else

        {

        resourceId = R_IR_TO_FROM_IN_INBOX;

        }

    TObexUtilsUiLayer::ReadResourceL( toFrom, resourceId );

    TMsvEntry parentTEntry;

    parentTEntry.iMtm = aMtmId;

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

    parentTEntry.SetUnread(ETrue);

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

    //

    parentTEntry.SetInPreparation(ETrue); 

    parentTEntry.iType = KUidMsvMessageEntry;

    parentTEntry.iServiceId = KMsvUnknownServiceIndexEntryId;

    // iDate & iSize will be set later

    if ( aRemoteBluetoothName.Length() > 0 )

        {

        parentTEntry.iDetails.Set(aRemoteBluetoothName);

        }

    else

        {

        parentTEntry.iDetails.Set(toFrom);

        }

    inbox->CreateL(parentTEntry);

    aMsvIdParent = parentTEntry.Id();

    // Create attachment for the inbox entry

    TMsvEntry attachTEntry;

    attachTEntry.iType      = KUidMsvAttachmentEntry;

    attachTEntry.iServiceId = KMsvUnknownServiceIndexEntryId;   

    attachTEntry.iMtm       = aMtmId;

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

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

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

    // create the v2 attachment, save RFile

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

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

    CMsvStore* store = attachEntry->EditStoreL();

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

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

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

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