/*

* Copyright (c) 2008 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:  ?Description

 *

*/

#include <apmstd.h>

#include <s32stor.h>

#include <badesca.h>  //to use descriptor arrays

#include <eikenv.h>

#include <eikdef.h>

#include <driveinfo.h>

#include <DocumentHandler.h>

#include "logger.h"

#include "s60commonutils.h"

#include "javasymbianoslayer.h"

#include "cjavammsmessagehandler.h"

namespace java

{

namespace wma

{

const TInt KMmsMapLength = 7;

const TInt KReplyToAppIDFieldIndex = 0;

const TInt KAppIDFieldIndex = 1;

const TInt KSubjectFieldIndex = 2;

const TInt KFromFieldIndex = 3;

const TInt KToFieldIndex = 4;

const TInt KBccFieldIndex = 5;

const TInt KCcFieldIndex = 6;

const TInt KBufFlatGranularity = 10;

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

/* -----------------------------------------------------------------------------

 * CJavaMMSMessageHandler::CJavaMMSMessageHandler

 * C++ default constructor

 * -----------------------------------------------------------------------------

 */

CJavaMMSMessageHandler::CJavaMMSMessageHandler(RFs aRFs) :

        mRFs(aRFs)

{

    JELOG2(EWMA);

}

/* -----------------------------------------------------------------------------

 * Destructor

 * -----------------------------------------------------------------------------

 */

CJavaMMSMessageHandler::~CJavaMMSMessageHandler()

{

    JELOG2(EWMA);

}

/* -----------------------------------------------------------------------------

 * CJavaMMSMessageHandler::NewL

 * Two-phased constructor.

 * -----------------------------------------------------------------------------

 */

CJavaMMSMessageHandler* CJavaMMSMessageHandler::NewL(RFs aFs)

{

    JELOG2(EWMA);

    CJavaMMSMessageHandler* self = new CJavaMMSMessageHandler(aFs);

    return self;

}

/* -----------------------------------------------------------------------------

 * CJavaMMSMessageHandler::SerializeLC

 * This method serializes an MMS (as it is received from the MMS engine) into

 * a byte array which will be sent to java.

 * The format of the serialized MMS is according to the following scheme:

 *     ----------------------------------------------------------------------------------------------------------

 *     | Map | HeaderLengths | AttachmentsCount | AttachmentsLengths | StartContentFlag | Headers | Attachments |

 *     ----------------------------------------------------------------------------------------------------------

 *

 * where Map                 Represents the decimal value of a binary

 *                          representation of MMS header fields

 *                          (applicationID, Subject, From, To, Bcc, Cc)

 *                          Ex: 52 = 110101 means that 'applicationID'

 *                          is present, 'Subject' is present, 'From' is

 *                          not present,'To' is present, 'Bcc' is not

 *                          present and 'Cc' is present

 *                          The lengths of each of the MMS header

 *                          fields which are present

 *      AttachmentsCount    The number of attachments

 *      AttachmentsLengths  The lengths of each of the attachments

 *      StartContentFlag    A boolean indicating if the first

 *                          attachment should be interpreted as

 *                          startContent or not

 *      Headers             The MMS header fields

 *      Attachments         The attachments

 * -----------------------------------------------------------------------------

 */

CBufFlat& CJavaMMSMessageHandler::SerializeLC(CMMSMessageInformation& aMMS)

{

    JELOG2(EWMA);

    // mms fields

    TDesC8& replyToAppID = aMMS.ReplyToApplicationIdL();

    TDesC8& appID = aMMS.ApplicationIdL();

    TDesC8& subject = aMMS.MessageSubjectL();

    TDesC8& from = aMMS.MessageFromAddressL();

    // the address is on the cleanup stack

    HBufC8& to = BuildAddressLC(EMsvRecipientTo, aMMS);

    // the address is on the cleanup stack

    HBufC8& bcc = BuildAddressLC(EMsvRecipientBcc, aMMS);

    // the address is on the cleanup stack

    HBufC8& cc = BuildAddressLC(EMsvRecipientCc, aMMS);

    // calculate the mms Map

    TInt mmsMap = 0;

    mmsMap += CalculateMap(replyToAppID, appID, subject, from, to, bcc, cc);

    // The serialized buffer

    CBufFlat* buffer = CBufFlat::NewL(KBufFlatGranularity);

    CleanupStack::PushL(buffer);

    CCnvCharacterSetConverter* cConv = CCnvCharacterSetConverter::NewL();

    CleanupStack::PushL(cConv);

    RBufWriteStream writeStream(*buffer, 0);

    // add the mmsMap

    writeStream.WriteUint8L(mmsMap);

    // add the mms fields lengths

    WriteDes8LengthL(writeStream, replyToAppID);

    WriteDes8LengthL(writeStream, appID);

    WriteDes8LengthL(writeStream, subject);

    WriteDes8LengthL(writeStream, from);

    WriteDes8LengthL(writeStream, to);

    WriteDes8LengthL(writeStream, bcc);

    WriteDes8LengthL(writeStream, cc);

    // add the attachments count

    TInt8 attchmts = aMMS.AttachmentCount();

    writeStream.WriteUint8L(attchmts);

    // add the attachments lenghts

    TInt firstAttchmt = WriteAttachmentsLengthsL(writeStream, aMMS, *cConv);

    // add the starterCID indicator

    if (attchmts > 0)

    {

        if (firstAttchmt >= 0)

        {

            writeStream.WriteUint8L(1);

        }

        else

        {

            writeStream.WriteUint8L(0);

        }

    }

    // add the priority

    TMmsMessagePriority priority = aMMS.MessagePriority();

    switch (priority)

    {

    case EMmsPriorityLow:

        writeStream.WriteUint8L(KPriorityLow);

        break;

    case EMmsPriorityNormal:

        writeStream.WriteUint8L(KPriorityNormal);

        break;

    case EMmsPriorityHigh:

        writeStream.WriteUint8L(KPriorityHigh);

        break;

    default:

        writeStream.WriteUint8L(KPriorityNormal);

        break;

    }

    // add the date

    WriteInt64L(writeStream, aMMS.MessageTime());

    // add the mms fields

    WriteDes8L(writeStream, replyToAppID);

    WriteDes8L(writeStream, appID);

    WriteDes8L(writeStream, subject);

    WriteDes8L(writeStream, from);

    WriteDes8L(writeStream, to);

    WriteDes8L(writeStream, bcc);

    WriteDes8L(writeStream, cc);

    // add the attachments

    WriteAttachmentsL(writeStream, aMMS, *cConv, firstAttchmt);

    // cleanup

    CleanupStack::PopAndDestroy(cConv);

    CleanupStack::Pop(buffer);

    CleanupStack::PopAndDestroy(&cc);

    CleanupStack::PopAndDestroy(&bcc);

    CleanupStack::PopAndDestroy(&to);

    CleanupStack::PushL(buffer);

    return *buffer;

}

/* -----------------------------------------------------------------------------

 * CJavaMMSMessageHandler::WriteAttachmentsL

 * Writes all the attachments into the write stream.

 * -----------------------------------------------------------------------------

 */

void CJavaMMSMessageHandler::WriteAttachmentsL(RBufWriteStream& aWriteStream,

        CMMSMessageInformation& aMMS, CCnvCharacterSetConverter& aCharConv,

        TInt firstAttchmt)

{

    JELOG2(EWMA);

    TInt8 attchmts = aMMS.AttachmentCount();

    if (firstAttchmt >= 0)

    {

        WriteAttachmentL(aWriteStream, aMMS.Attachment(firstAttchmt), aCharConv);

    }

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

    {

        if (i != firstAttchmt)

        {

            WriteAttachmentL(aWriteStream, aMMS.Attachment(i), aCharConv);

        }

    }

}

/* -----------------------------------------------------------------------------

 * CJavaMMSMessageHandler::WriteAttachmentL

 * Writes an attachment into the write stream.

 * -----------------------------------------------------------------------------

 */

void CJavaMMSMessageHandler::WriteAttachmentL(RBufWriteStream& aWriteStream,

        CMMSMessageAttachment& aAttch, CCnvCharacterSetConverter& aCharConv)

{

    JELOG2(EWMA);

    // mime type

    WriteDes8L(aWriteStream, aAttch.AttachmentType());

    // content ID

    WriteDes8L(aWriteStream, aAttch.ContentIdL());

    // content location

    WriteDes8L(aWriteStream, aAttch.ContentLocationL());

    // content encoding

    TUint charSetID = aCharConv.ConvertMibEnumOfCharacterSetToIdentifierL(

                          aAttch.Encoding(), mRFs);

    HBufC8* encoding = aCharConv.ConvertCharacterSetIdentifierToStandardNameL(

                           charSetID, mRFs);

    CleanupStack::PushL(encoding);

    if (encoding)

    {

        aWriteStream.WriteL(*(encoding));

    }

    CleanupStack::PopAndDestroy(encoding);

    // content

    WriteDes8L(aWriteStream, aAttch.AttachmentData());

}

/* -----------------------------------------------------------------------------

 * CJavaMMSMessageHandler::WriteAttachmentsLengthsL

 * Writes all attachments lengths (one by one) into the write stream.

 * -----------------------------------------------------------------------------

 */

TInt CJavaMMSMessageHandler::WriteAttachmentsLengthsL(RBufWriteStream& aWriteStream,

        CMMSMessageInformation& aMMS, CCnvCharacterSetConverter& aCharConv)

{

    JELOG2(EWMA);

    TInt firstAttchmt = -1;

    TInt8 attchmts = aMMS.AttachmentCount();

    if (attchmts > 0)

    {

        // quick browse through the attachments to see if the starterCID is used

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

        {

            CMMSMessageAttachment& attch = aMMS.Attachment(i);

            if (attch.IsStarterContentId())

            {

                // put the starterCID first

                WriteAttachmentLengthsL(aWriteStream, attch, aCharConv);

                firstAttchmt = i;

                break;

            }

        }

    }

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

    {

        if (i != firstAttchmt)

        {

            WriteAttachmentLengthsL(aWriteStream, aMMS.Attachment(i), aCharConv);

        }

    }

    return firstAttchmt;

}

/* -----------------------------------------------------------------------------

 * CJavaMMSMessageHandler::WriteAttachmentLengthsL

 * Writes an attachment lengths into the write stream.

 * -----------------------------------------------------------------------------

 */

void CJavaMMSMessageHandler::WriteAttachmentLengthsL(RBufWriteStream& aWriteStream,

        CMMSMessageAttachment& aAttch, CCnvCharacterSetConverter& aCharConv)

{

    JELOG2(EWMA);

    // mime type length

    WriteDesLengthOrZeroL(aWriteStream, aAttch.AttachmentType());

    // content ID length

    WriteDesLengthOrZeroL(aWriteStream, aAttch.ContentIdL());

    // content location length

    WriteDesLengthOrZeroL(aWriteStream, aAttch.ContentLocationL());

    // content encoding length

    TUint charSetID = aCharConv.ConvertMibEnumOfCharacterSetToIdentifierL(

                          aAttch.Encoding(), mRFs);

    HBufC8* encoding = aCharConv.ConvertCharacterSetIdentifierToStandardNameL(

                           charSetID, mRFs);

    CleanupStack::PushL(encoding);

    if (encoding)

    {

        WriteIntL(aWriteStream, encoding->Length());

    }

    else

    {

        WriteIntL(aWriteStream, 0);

    }

    CleanupStack::PopAndDestroy(encoding);

    // content size

    WriteDesLengthOrZeroL(aWriteStream, aAttch.AttachmentData());

}

/* -----------------------------------------------------------------------------

 * CJavaMMSMessageHandler::BuildAddressLC

 * Concatenates all the addresses/recipients into a ";" separated

 * string/descriptor.

 * -----------------------------------------------------------------------------

 */

HBufC8& CJavaMMSMessageHandler::BuildAddressLC(

    TMsvRecipientTypeValues aAddressType, CMMSMessageInformation& aMMS)

{

    JELOG2(EWMA);

    _LIT(KAddressSep, ";");

    HBufC8* address = HBufC8::NewLC(0);

    TPtr8 AddressPtr(address->Des());

    for (int i = 0; i < aMMS.AddressesCount(aAddressType); i++)

    {

        TDesC& currentAddress = aMMS.MessageAddressL(aAddressType, i);

        HBufC8* tmp = NULL;

        if (i < aMMS.AddressesCount(aAddressType) - 1)

        {

            tmp = address->ReAllocL(address->Length() + currentAddress.Length()

                                    + 1);

        }

        else

        {

            tmp

            = address->ReAllocL(address->Length()

                                + currentAddress.Length());

        }

        CleanupStack::Pop(address);

        address = tmp;

        CleanupStack::PushL(address);

        AddressPtr.Set(address->Des());

        AddressPtr.Append(currentAddress);

        if (i < aMMS.AddressesCount(aAddressType) - 1)

        {

            AddressPtr.Append(KAddressSep);

        }

    }

    return *address;

}

/* -----------------------------------------------------------------------------

 * CJavaMMSMessageHandler::CalculateMap

 * Calculates the mms map.

 * -----------------------------------------------------------------------------

 */

TInt CJavaMMSMessageHandler::CalculateMap(TDesC8& aReplyToAppID, TDesC8& aAppID,

        TDesC8& aSubject, TDesC8& aFrom,

        HBufC8& aTo, HBufC8& aBcc, HBufC8& aCc)

{

    JELOG2(EWMA);

    TInt mmsMap = 0;

    if (&aReplyToAppID)

    {

        mmsMap += K64BitsMask;

    }

    if (&aAppID)

    {

        mmsMap += K32BitsMask;

    }

    if (&aSubject)

    {

        mmsMap += K16BitsMask;

    }

    if (&aFrom)

    {

        mmsMap += K8BitsMask;

    }

    if (&aTo)

    {

        mmsMap += K4BitsMask;

    }

    if (&aBcc)

    {

        mmsMap += K2BitsMask;

    }

    if (&aCc)

    {

        mmsMap += 1;

    }

    return mmsMap;

}

/* -----------------------------------------------------------------------------

 * CJavaMMSMessageHandler::WriteInt64L

 * Writes an integer as 8 bytes into the write stream.

 * -----------------------------------------------------------------------------

 */

void CJavaMMSMessageHandler::WriteInt64L(RBufWriteStream& aWriteStream,

        const TInt64 aInteger)

{

    JELOG2(EWMA);

    aWriteStream.WriteInt8L(aInteger >> K56BitsMask);

    aWriteStream.WriteInt8L(aInteger >> K48BitsMask);

    aWriteStream.WriteInt8L(aInteger >> K40BitsMask);

    aWriteStream.WriteInt8L(aInteger >> K32BitsMask);

    aWriteStream.WriteInt8L(aInteger >> K24BitsMask);

    aWriteStream.WriteInt8L(aInteger >> K16BitsMask);

    aWriteStream.WriteInt8L(aInteger >> K8BitsMask);

    aWriteStream.WriteInt8L(aInteger);

}

/* -----------------------------------------------------------------------------

 * CJavaMMSMessageHandler::WriteIntL

 * Writes an integer as 4 bytes into the write stream.

 * -----------------------------------------------------------------------------

 */

void CJavaMMSMessageHandler::WriteIntL(RBufWriteStream& aWriteStream,

                                       const TInt32 aInteger)

{

    JELOG2(EWMA);

    aWriteStream.WriteUint8L(aInteger >> K24BitsMask);

    aWriteStream.WriteUint8L(aInteger >> K16BitsMask);

    aWriteStream.WriteUint8L(aInteger >> K8BitsMask);

    aWriteStream.WriteUint8L(aInteger);

}

/* -----------------------------------------------------------------------------

 * CJavaMMSMessageHandler::WriteDes8L

 * Writes a descriptor (if not NULL) into the write stream.

 * -----------------------------------------------------------------------------

 */

void CJavaMMSMessageHandler::WriteDes8L(RBufWriteStream& aWriteStream,

                                        const TDesC8& aDes)

{

    JELOG2(EWMA);

    if (&aDes)

    {

        aWriteStream.WriteL(aDes);

    }

}

/* -----------------------------------------------------------------------------

 * CJavaMMSMessageHandler::WriteDes8LengthL

 * Writes a descriptor's length (if not NULL) into the write stream.

 * -----------------------------------------------------------------------------

 */

void CJavaMMSMessageHandler::WriteDes8LengthL(RBufWriteStream& aWriteStream,

        const TDesC8& aDes)

{

    JELOG2(EWMA);

    if (&aDes)

    {

        WriteIntL(aWriteStream, aDes.Length());

    }

}

/* -----------------------------------------------------------------------------

 * CJavaMMSMessageHandler::WriteDes8LengthOrZeroL

 * Writes a descriptor's length (if descriptor is not NULL) or zero (if

 * descriptor is NULL) into the write stream.

 * -----------------------------------------------------------------------------

 */

void CJavaMMSMessageHandler::WriteDes8LengthOrZeroL(RBufWriteStream& aWriteStream,

        const TDesC8& aDes)

{

    JELOG2(EWMA);

    if (&aDes)

    {

        aWriteStream.WriteUint8L(aDes.Length());

    }

    else

    {

        aWriteStream.WriteUint8L(0);

    }

}

/* -----------------------------------------------------------------------------

 * CJavaMMSMessageHandler::WriteDesLengthOrZeroL

 * Writes a descriptor's length (if descriptor is not NULL) or zero (if

 * descriptor is NULL) into the write stream.

 * -----------------------------------------------------------------------------

 */

void CJavaMMSMessageHandler::WriteDesLengthOrZeroL(RBufWriteStream& aWriteStream,

        const TDesC8& aDes)

{

    JELOG2(EWMA);

    if (&aDes)

    {

        WriteIntL(aWriteStream, aDes.Length());

    }

    else

    {

        WriteIntL(aWriteStream, 0);

    }

}

/* -----------------------------------------------------------------------------

 * CJavaMMSMessageHandler::DeSerializeL

 * This method de-serializes an MMS (as it is received java) into

 * an internal representation (used by the MMS engine proxy).

 * The format of the serialized MMS is according to the following scheme:

 *     ----------------------------------------------------------------------------------------------------------

 *     | Map | HeaderLengths | AttachmentsCount | AttachmentsLengths | StartContentFlag | Headers | Attachments |

 *     ----------------------------------------------------------------------------------------------------------