/*

* Copyright (c) 2002 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:  

*     Picture Message model and converter.

*

*/

// INCLUDE FILES

#include "gmsModel.h"

#include <txtrich.h>                //for CRichText

#include <s32file.h>

// LOCAL CONSTANTS AND MACROS

// size constants

const TInt KGmsVersionLength          = 1;

const TInt KGmsItemLengthFieldLength  = 2;

const TInt KGmsItemHeaderLength       = 3;

// tokens

const TUint8 KGmsVersionAsciiZero     = 48; // "0"

const TUint8 KGmsItemTypeLatin1       = 0;  // "0"

const TUint8 KGmsItemTypeUnicode      = 1;  // "1"

const TUint8 KGmsItemTypeOTABitmap    = 2;  // "2"

const TUint8 KGmsLF = 10;

_LIT(KGmsModelDll,"GmsModel.dll");

//  MEMBER FUNCTIONS

EXPORT_C CGmsModel* CGmsModel::NewL(RFs& aFs, TInt aLeaveCodeForCorrupt)

    {

    CGmsModel* self = new (ELeave) CGmsModel(aFs, aLeaveCodeForCorrupt);

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    return self;

    }

void CGmsModel::ConstructL()

    {

    }

EXPORT_C CGmsModel::~CGmsModel()

    {

    delete iText;

    delete iOTABitmap;

    }

EXPORT_C void CGmsModel::ImportGMSL(const TDesC8& aInput)

    {

    Reset();

    TInt index = 0;

    CheckVersionL(aInput, index); //this leaves if version is invalid

    TInt length = aInput.Length();

    while (index < length)

        {

        //either text, a picture or something unsupported

        ExtractGMSSubItemL(aInput, index);

        }

    __ASSERT_ALWAYS(HasPicture(), User::Leave(iLeaveCorrupt));

    }

EXPORT_C void CGmsModel::ImportGMSL(const CRichText& aRichText)

    {

    Reset();

    // Create a temporary HBufC16 for extracting from CRichText.

    // (CRichText has no interface for extracting to 8 bit descriptor)

    TInt docLength = aRichText.DocumentLength();

    HBufC16* buf = HBufC16::NewLC(docLength);

    TPtr16 ptr16(buf->Des());

    aRichText.Extract(ptr16, 0, docLength);

    //Create a temporary HBufC8 for importing to converter.

    HBufC8* buf8 = HBufC8::NewLC(docLength);

    TPtr8 ptr8 = buf8->Des();

    //Copy from 16 to 8 bit descriptor.

    ptr8.Copy(ptr16);

    ImportGMSL(*buf8);

    CleanupStack::PopAndDestroy(2); //buf8 buf16

    }

EXPORT_C HBufC8* CGmsModel::ExportGMS8LC()

    {

    // There has to be at least picture data.

    __ASSERT_ALWAYS(HasPicture(), Panic(EGmsMPanicNoPicData1));

    HBufC8* buf = NULL;

    buf = HBufC8::NewLC(TotalSize());

    TPtr8 gms(buf->Des());

    AppendVersionL(gms);        // <version>

    AppendTextSubItemL(gms);    // <item>

    AppendPictureSubItemL(gms); // <item>

    return buf;

    }

EXPORT_C HBufC16* CGmsModel::ExportGMS16LC()

    {

    HBufC16* buf16 = HBufC16::NewLC(TotalSize());

    TPtr ptr16(buf16->Des());

    HBufC8* buf8 = ExportGMS8LC();

    TPtr8 ptr8(buf8->Des());

    ptr16.Copy(ptr8);

    CleanupStack::PopAndDestroy(); //buf8

    return buf16;

    }

EXPORT_C HBufC* CGmsModel::TextAsHBufC16LC() const

    {

    if (iText)

        {

        return iText->AllocLC();

        }

    return KNullDesC().AllocLC();

    }

EXPORT_C void CGmsModel::SetTextL(const TDesC& aSource)

    {

    if (ContainsUnicodeL(aSource))

        {

        SetTextUnicodeL(aSource);

        }

    else

        {

        SetTextLatinL(aSource);

        }

    }

EXPORT_C void CGmsModel::SetTextLatinL(const TDesC& aSource)

    {

    HBufC* text = aSource.AllocL();

    delete iText;

    iText  = text;

    iMode = EGmsModeLatin;

    }

EXPORT_C void CGmsModel::SetTextUnicodeL(const TDesC& aSource)

    {

    HBufC* text = aSource.AllocL();

    delete iText;

    iText  = text;

    iMode = EGmsModeUnicode;

    }

TBool CGmsModel::ContainsUnicodeL(const TDesC& aInputString) const

    {

    TInt length = aInputString.Length();

    const TUint KGmsHighestLatin1 = 255;

    for (TInt n = 0; n < length; n++)

        {

        TUint16 ch = aInputString[n];

        // Latin-1 occupies dec. values 0 to 255 of Unicode. (U+0000..U+00FF)

        if (ch > KGmsHighestLatin1 && ch != CEditableText::EParagraphDelimiter)

            {        

            return ETrue;

            }

        }

    return EFalse;

    }

EXPORT_C void CGmsModel::ExportOTABitmapL(RWriteStream& aOutStream)

    {

    __ASSERT_ALWAYS(HasPicture(), Panic(EGmsMPanicNoPictureToExport));

    aOutStream.WriteL(*iOTABitmap);

    }

/// Assumes an 8 bit data stream

EXPORT_C void CGmsModel::ImportOTABitmapL(RReadStream& aReadStream)

    {

    MStreamBuf* streamBuf = NULL;

    streamBuf = aReadStream.Source();

    User::LeaveIfNull(streamBuf);

    TInt size = streamBuf->SizeL();

    __ASSERT_ALWAYS(size > 0,

        Panic(EGmsMPanicStreamIsEmpty));

    HBufC8* bitmap = HBufC8::NewLC(size);

    TPtr8 bitmapPtr(bitmap->Des());

    aReadStream.ReadL(bitmapPtr, size);

    // This leaves with iLeaveCorrupt if the bitmap is bad.

    HBufC8* buf8 = CheckedAndFixedOtaBitmapL(*bitmap);

    CleanupStack::PopAndDestroy(bitmap);

    delete iOTABitmap;

    iOTABitmap = buf8;

    }

EXPORT_C TInt CGmsModel::SizeOfCompleteMsgExcludingTextAndPic() const

    {

    return (KGmsVersionLength + KGmsItemHeaderLength*2);

    }

EXPORT_C TBool CGmsModel::HasText() const

    {

    if (!iText || iText->Length() <= 0)

        {

        return EFalse;

        }

    // length > 0

    return ETrue;

    }

// This does not verify that the data is valid

EXPORT_C TBool CGmsModel::HasPicture() const

    {

    if (!iOTABitmap || iOTABitmap->Length() <= 0)

        {

        return EFalse;

        }

    // length > 0

    return ETrue;

    }

EXPORT_C TBool CGmsModel::IsTextLatin() const

    {

    return (iMode == EGmsModeLatin);

    }

EXPORT_C TInt CGmsModel::TotalSizeExcludingText() const

    {

    TInt bitmapSize = 0;

    if (iOTABitmap)

        {

        bitmapSize = iOTABitmap->Size();

        }

    return bitmapSize + SizeOfCompleteMsgExcludingTextAndPic();

    }

EXPORT_C TInt CGmsModel::TotalSize() const

    {

    TInt textSize(0);

    textSize = Textlength();

    if (iMode == EGmsModeUnicode)

        {

        textSize *= 2; // (two bytes per char)

        }

    return TotalSizeExcludingText() + textSize;

    }

EXPORT_C TInt CGmsModel::Textlength() const

    {

    if (iText)

        {

        return iText->Length();

        }

    return 0;

    }

EXPORT_C TInt CGmsModel::PictureSize() const

    {

    if (iOTABitmap)

        {

        return iOTABitmap->Size();

        }

    return 0;

    }

EXPORT_C void CGmsModel::Reset()

    {

    delete iText;

    iText = NULL;

    delete iOTABitmap;

    iOTABitmap = NULL;

    }

EXPORT_C TInt CGmsModel::_TestingL(TInt /*aCode1*/, TInt& /*aCode2*/, const TDesC8& /*aDes1*/, const TDesC16& /*aDes2*/)

    {

    // Nothing here.

    return 0;

    }

// Deprecated. Do not use.

//

EXPORT_C HBufC* CGmsModel::ExtractTextFromMsgLC(const TDesC& /*aMsg*/, TInt /*aAmount*/)

    {

    return NULL; // for compiler

    }

EXPORT_C TBool CGmsModel::IsPictureValidL()

    {

    // Deprecated

    return ETrue;

    }

TBool CGmsModel::ImportOtaBitmapL(const TDesC& aFileName)

    {

    RFileReadStream readStream;

    User::LeaveIfError(readStream.Open(

        iFs,

        aFileName,

        EFileStream));

    readStream.PushL();

    MStreamBuf* buf = readStream.Source();

    User::LeaveIfNull(buf);

    TInt size = buf->SizeL();

    __ASSERT_ALWAYS(size > 0,

        Panic(EGmsNull1));

    HBufC8* data = HBufC8::NewLC(size);

    TPtr8 dataPtr(data->Des());

    readStream.ReadL(dataPtr, size);

    TBool success;

    HBufC8* buf8 = NULL;

    buf8 = CheckedAndFixedOtaBitmapL(*data, success);

    CleanupStack::PopAndDestroy(data);

    CleanupStack::PopAndDestroy(); //(closes readStream)

    if (success)

        {

        delete iOTABitmap;

        iOTABitmap = buf8;

        return ETrue;

        }

    else

        {

        __ASSERT_DEBUG(!buf8, Panic(EGmsProblem1));

        return EFalse;

        }

    }

// Call this as the first extraction method.

void CGmsModel::CheckVersionL(const TDesC8& aInput, TInt& aIndex)

    {

    __ASSERT_ALWAYS(aInput.Length() >= KGmsVersionLength,

        User::Leave(iLeaveCorrupt));

    // To be a valid msg, its version identifier must be zero

    if (aInput[0] != KGmsVersionAsciiZero)

        {

        User::Leave(iLeaveCorrupt);

        }

    aIndex++;

    }

void CGmsModel::ExtractGMSSubItemL(const TDesC8& aInput, TInt& aIndex)

    {

    ExtractGMSSubItemL(aInput, aIndex, EFalse);

    }

void CGmsModel::ExtractGMSSubItemL(const TDesC8& aInput, TInt& aIndex,

    TBool aSkipBitmap)

    {

    __ASSERT_ALWAYS(aInput.Length() >= aIndex + KGmsItemHeaderLength,

        User::Leave(iLeaveCorrupt));

    //Get GMS item type. It should be one of the following:

    //  "00" <GMS-item-length> <ISO-8859-1-char>*     = LATIN TEXT ITEM

    //  "01" <GMS-item-length> <UNICODE-char>*        = UNICODE TEXT ITEM

    //  "02" <GMS-item-length> <OTA-bitmap>           = PICTURE ITEM

    TBuf8<1> msgItemType;

    msgItemType = aInput.Mid(aIndex, 1); //pos, length

    aIndex += 1;

    if (KGmsItemTypeLatin1 == msgItemType[0])       // "00"

        {

        ExtractLatin1L(aInput, aIndex);

        }

    else if (KGmsItemTypeUnicode == msgItemType[0]) // "01"

        {

        ExtractUnicodeL(aInput, aIndex);

        }

    else if (KGmsItemTypeOTABitmap == msgItemType[0]) // "02"

        {

        if (aSkipBitmap)

            {

            ExtractUnknownL(aInput, aIndex); //just skips over it

            }

        else

            {

            ExtractOTABitmapL(aInput, aIndex);

            }

        }

    else

        {

        ExtractUnknownL(aInput, aIndex); //just skips over the part

        }

    }

void CGmsModel::ExtractLatin1L(const TDesC8& aInput, TInt& aIndex)

    {

    TInt length = ExtractLengthL(aInput, aIndex);

    __ASSERT_ALWAYS(aInput.Length() >= aIndex + length,

        User::Leave(iLeaveCorrupt));

    delete iText;

    iText = NULL;

    iText = HBufC::NewL(length);

    iText->Des().Copy(aInput.Mid(aIndex, length));

    aIndex += length;

    iMode = EGmsModeLatin;

    }

void CGmsModel::ExtractUnicodeL(const TDesC8& aInput, TInt& aIndex)

    {

    TInt length = ExtractLengthL(aInput, aIndex);

    __ASSERT_ALWAYS(aInput.Length() >= aIndex + length,

        User::Leave(iLeaveCorrupt));

    __ASSERT_ALWAYS((length % 2) == 0, User::Leave(iLeaveCorrupt));//even nr.

    delete iText;

    iText = NULL;

    iText = HBufC::NewL(length / 2);

    //

    // The data has to be reassembled from UCS-2 to 16 bit Unicode.

    //

    TPtr ptr(iText->Des());

    for (TInt n = aIndex; n < aIndex + length; n += 2)

        {

        TUint16 lower = aInput[n + 1];

        TUint16 upper = aInput[n];

        upper = TUint16(upper << 8);

        TUint16 ch = 0;

        ch = TUint16(upper | lower);

        ptr.Append(ch);

        }

    aIndex += length;

    iMode = EGmsModeUnicode;

    }

void CGmsModel::ExtractOTABitmapL(const TDesC8& aInput, TInt& aIndex)

    {

    TInt length = ExtractLengthL(aInput, aIndex);

    __ASSERT_ALWAYS(aInput.Length() >= aIndex + length,

        User::Leave(iLeaveCorrupt));

    delete iOTABitmap;

    iOTABitmap = NULL;

    // This leaves with iLeaveCorrupt if the bitmap is bad.

    iOTABitmap = CheckedAndFixedOtaBitmapL(aInput.Mid(aIndex, length));

    aIndex += length;

    }

void CGmsModel::ExtractUnknownL(const TDesC8& aInput, TInt& aIndex)

    {

    TInt length = ExtractLengthL(aInput, aIndex);

    __ASSERT_ALWAYS(aInput.Length() >= aIndex + length,

        User::Leave(iLeaveCorrupt));

    aIndex += length; // Skip the unknown item.

    }

TInt CGmsModel::ExtractLengthL(const TDesC8& aInput, TInt& aIndex)

    {

    __ASSERT_ALWAYS(aInput.Length() >= aIndex + KGmsItemLengthFieldLength,

        User::Leave(iLeaveCorrupt));

    // (KGmsItemLengthFieldLength = 2)

    TBuf8<KGmsItemLengthFieldLength> itemLength;

    itemLength.Copy(aInput.Mid(aIndex, KGmsItemLengthFieldLength));

    aIndex += KGmsItemLengthFieldLength;

    TUint16 length = 0;

    length = TUint16 ((itemLength[0]&0x000000FF));

    length = TUint16 (length<<8);

    length |= TUint16 ((itemLength[1]&0x000000FF));

    return length;

    }

CGmsModel::CGmsModel(RFs& aFs, TInt aLeaveCodeForCorrupt) :

    iFs(aFs),

    iLeaveCorrupt(aLeaveCodeForCorrupt)

    {

    }

void CGmsModel::AppendVersionL(TDes8& aGms)

    {

    TBuf8<1> gmsVersion;

    _LIT(KEmpty1, "0");

    gmsVersion.Copy(KEmpty1);

    gmsVersion[0] = KGmsVersionAsciiZero;

    aGms.Append(gmsVersion);

    }

void CGmsModel::AppendTextSubItemL(TDes8& aGms)

    {

    TBuf8<3> itemHeader;

    _LIT(KEmpty3, "000");

    itemHeader.Copy(KEmpty3);

    if (iMode == EGmsModeLatin)

        {

        itemHeader[0] = KGmsItemTypeLatin1; // entity type identifier.

        }

    else

        {

        // Unicode

        itemHeader[0] = KGmsItemTypeUnicode; // entity type identifier.

        }

    TInt sizeT = 0;

    if (iText)

        {

        sizeT = iText->Length();

        if (iMode == EGmsModeUnicode)

            {

            sizeT *= 2;

            }

        }

    // The text header is added even if there is no text.

    TInt lowerT = sizeT;

    lowerT &= TInt(0x000000FF);

    TUint upperT = sizeT;

    upperT = TInt(upperT >> 8);

    upperT &= TInt(0x000000FF);

    itemHeader[1] = TInt8(upperT); //First byte of <Item-length>

    itemHeader[2] = TInt8(lowerT); //Second byte of <Item-length>

    aGms.Append(itemHeader);

    if (iText)

        {