/*

* Copyright (c) 2004 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:  WV Status content attribute implementation.

*

*/

// INCLUDE FILES

#include "CPEngWVAttributeConstructBase.h"

#include "CPEngWVAttributeModelBase.h"

#include "CPEngWVStatusContentModel.h"

#include "CAsync2Sync.h"

#include "PEngWVAttributeModelDataHelper.h"

#include "MPEngXMLSerializer.h"

#include "MPEngXMLParser.h"

#include <MPEngPresenceAttrModel2.h>

#include <E32Base.h>

#include <S32Strm.h>

#include <imcvcodc.h>

//LOCAL constants

namespace

    {

    _LIT( KPEngMyLogoModelPanic, "MyLogoMod" );

    enum TPEngMyLogoModelPanicReasons

        {

        EModAlreadyHasNwStatusContent,

        EModInvalidParamsHandleNewMyLogo

        };

    void PanicStatusContModel( TPEngMyLogoModelPanicReasons aPanicReason )

        {

        User::Panic( KPEngMyLogoModelPanic, aPanicReason );

        }

    }

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

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

// CPEngWVStatusContentModel

// C++ constructor can NOT contain any code, that

// might leave.

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

//

CPEngWVStatusContentModel::CPEngWVStatusContentModel( TBool aUserOwnAttribute )

        : CPEngWVAttributeModelBase( aUserOwnAttribute )

    {

    }

// Destructor

CPEngWVStatusContentModel::~CPEngWVStatusContentModel()

    {

    delete iMyLogoData;

    delete iMyLogoMimeType;

    delete iMyLogoSoureFileName;

    delete iStatusContentNW;

    delete iMyLogoConverter;    //cancels the active convert if any

    }

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

// CPEngWVStatusContentModel::GetData()

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

//

TBool CPEngWVStatusContentModel::GetData( TInt* /*aIntData*/,

                                          TPtrC8* a8Data,

                                          TPtrC16* a16Data,

                                          TInt aField,

                                          TInt aGroup ) const

    {

    TBool handled = EFalse;

    if ( aGroup == KPEngDefaultAttrValueGroup )

        {

        if ( a16Data && ( aField == EPEngMyLogoDirectContentSourceFileName ) )

            {

            DoGetDesc( iMyLogoSoureFileName, *a16Data );

            handled = ETrue;

            }

        if ( a8Data && ( aField == EPEngMyLogoDirectContentBuffer ) )

            {

            DoGetDesc( iMyLogoData, *a8Data );

            handled = ETrue;

            }

        }

    return handled;

    }

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

// CPEngWVStatusContentModel::SetDataL()

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

//

TBool CPEngWVStatusContentModel::SetDataL( TInt* /*aIntData*/,

                                           const TDesC8* a8Data,

                                           const TDesC16* a16Data,

                                           TInt aField,

                                           TInt aGroup )

    {

    CAsync2Sync* wait = CAsync2Sync::NewLC();

    TBool handled = CPEngWVStatusContentModel::SetDataAsyncL( a8Data,

                                                              a16Data,

                                                              wait->RequestStatus(),

                                                              aField,

                                                              aGroup );

    if ( handled )

        {

        wait->WaitToComplete();

        //handle all other errors than the cancel by leaving

        TInt status = wait->RequestStatus().Int();

        User::LeaveIfError( status );

        }

    CleanupStack::PopAndDestroy( wait );

    return handled;

    }

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

// CPEngWVStatusContentModel::SetDataAsyncL()

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

//

TBool CPEngWVStatusContentModel::SetDataAsyncL( const TDesC8* a8Data,

                                                const TDesC16* a16Data,

                                                TRequestStatus& aRequestStatus,

                                                TInt aField,

                                                TInt aGroup )

    {

    TBool handled = EFalse;

    if ( aGroup == KPEngDefaultAttrValueGroup )

        {

        if ( a16Data && ( aField == EPEngMakeMyLogoDirectContentFromFile ) )

            {

            __ASSERT_ALWAYS( !iMyLogoConverter, User::Leave( KErrInUse ) );

            iMyLogoConverter = CPEngMyLogoConverter::FileNewL( *a16Data, *this );

            iMyLogoConverter->IssueConvert( aRequestStatus );

            handled = ETrue;

            }

        else if ( a8Data && ( aField == EPEngMakeMyLogoDirectContentFromBuffer ) )

            {

            __ASSERT_ALWAYS( !iMyLogoConverter, User::Leave( KErrInUse ) );

            iMyLogoConverter = CPEngMyLogoConverter::DataNewL( *a8Data, *this );

            iMyLogoConverter->IssueConvert( aRequestStatus );

            handled = ETrue;

            }

        }

    return handled;

    }

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

// CPEngWVStatusContentModel::CancelSetDataAsync()

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

//

void CPEngWVStatusContentModel::CancelSetDataAsync()

    {

    delete iMyLogoConverter; //Deleting converter cancels it

    iMyLogoConverter = NULL;

    }

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

// CPEngWVStatusContentModel::EncodeDataToXmlL()

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

//

void CPEngWVStatusContentModel::EncodeDataToXmlL(

    MPEngXMLSerializer& aSerializer ) const

    {

    TPtrC8 logoData( NULL, 0 );

    TPtrC8 logoMimeType( NULL, 0 );

    DoGetDesc( iMyLogoData, logoData );

    DoGetDesc( iMyLogoMimeType, logoMimeType );

    if ( ( logoData.Length() > 0 ) && ( logoMimeType.Length() > 0 ) )

        {

        //Image & mime type for image are available

        //==>serialize them to XML

        aSerializer.StartTagL( KDirectContentXMLTag ).

        Base64DataL( logoData ).

        EndTagL( KDirectContentXMLTag );

        aSerializer.StartTagL( KContentTypeXMLTag )

        .RawValueL( logoMimeType )

        .EndTagL( KContentTypeXMLTag );

        }

    else

        {

        //write empty data

        aSerializer.StartTagL( KDirectContentXMLTag ).EndTagL( KDirectContentXMLTag );

        aSerializer.StartTagL( KContentTypeXMLTag ).EndTagL( KContentTypeXMLTag );

        }

    }

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

// CPEngWVStatusContentModel::DecodeDataFromXmlL()

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

//

void CPEngWVStatusContentModel::DecodeDataFromXmlL( MPEngXMLParser& aParser,

                                                    const TDesC8& aValueBlock )

    {

    __ASSERT_ALWAYS( !iStatusContentNW ,

                     PanicStatusContModel( EModAlreadyHasNwStatusContent ) );

    TPtrC8 mimeType( NULL, 0 );

    TPtrC8 statusContent( NULL, 0 );

    if ( aParser.DecodeL( aValueBlock, KContentTypeXMLTag, EFalse ) )

        {

        mimeType.Set( aParser.ResultL() );

        if ( aParser.DecodeL( aValueBlock, KDirectContentXMLTag, EFalse ) )

            {

            statusContent.Set( aParser.ResultL() );

            }

        }

    //Is status content MyLogo?

    if ( ( mimeType.CompareF( KPEngWVMyLogoMimeJpeg ) == 0 ) ||

         ( mimeType.CompareF( KPEngWVMyLogoMimeImageGif ) == 0 ) )

        {

        //statusContent length is big enough for decoded image

        //data, because in BASE64 decoding the result shrinks

        iStatusContentNW = HBufC8::NewL( statusContent.Length() );

        TPtr8 imageDataNW = iStatusContentNW->Des();

        TImCodecB64 base64Decoder;

        base64Decoder.Initialise();

        // Decode returns EFalse, if no more data is needed for decoding

        //==> in that case the decoding was succesful

        TBool decodeOk = !base64Decoder.Decode( statusContent, imageDataNW );

        if ( decodeOk )

            {

            iStatusContentNW = iStatusContentNW->ReAllocL( iStatusContentNW->Length() );

            }

        else

            {

            delete iStatusContentNW;

            iStatusContentNW = NULL;

            }

        }

    if ( !iStatusContentNW )

        {

        ResetDataL();

        }

    else

        {

        //there is some raw content. Verify & convert it to valid MyLogo

        TRAPD( err, CheckReceivedStatusContentL() );

        if ( err == KErrNoMemory )

            {

            User::Leave( KErrNoMemory );

            }

        else if ( ( err != KErrNone ) &&

                  ( err != KErrCancel ) )

            {

            ResetDataL();

            }

        }

    delete iStatusContentNW;

    iStatusContentNW = NULL;

    }

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

// CPEngWVStatusContentModel::ResetDataL()

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

//

void CPEngWVStatusContentModel::ResetDataL()

    {

    delete iMyLogoSoureFileName;

    delete iMyLogoMimeType;

    delete iMyLogoData;

    iMyLogoSoureFileName = NULL;

    iMyLogoMimeType = NULL;

    iMyLogoData = NULL;

    }

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

// CPEngWVStatusContentModel::DataExternalizeSize()

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

//

TInt CPEngWVStatusContentModel::DataExternalizeSize() const

    {

    TInt size = DoGetBufExtSize( iMyLogoData );

    size += DoGetBufExtSize( iMyLogoMimeType );

    size += DoGetBufExtSize( iMyLogoSoureFileName );

    return size;

    }

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

// CPEngWVStatusContentModel::ExternalizeDataL()

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

//

void CPEngWVStatusContentModel::ExternalizeDataL( RWriteStream& aStream ) const

    {

    DoExtrBufL( iMyLogoData, aStream );

    DoExtrBufL( iMyLogoMimeType, aStream );

    DoExtrBufL( iMyLogoSoureFileName, aStream );

    }

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

// CPEngWVStatusContentModel::InternalizeDataL()

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

//

void CPEngWVStatusContentModel::InternalizeDataL( RReadStream& aStream )

    {

    TPtr8 typeStrait8( NULL, 0 );

    DoIntrBufL( iMyLogoData, typeStrait8, aStream );

    DoIntrBufL( iMyLogoMimeType, typeStrait8, aStream );

    TPtr16 typeStrait16( NULL, 0 );

    DoIntrBufL( iMyLogoSoureFileName, typeStrait16, aStream );

    }

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

// CPEngWVStatusContentModel::CheckReceivedStatusContentL()

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

//

void CPEngWVStatusContentModel::CheckReceivedStatusContentL()

    {

    CAsync2Sync* wait = CAsync2Sync::NewLC();

    iMyLogoConverter = CPEngMyLogoConverter::DataNewL( *iStatusContentNW, *this );

    iMyLogoConverter->IssueConvert( wait->RequestStatus() );

    wait->WaitToComplete();

    User::LeaveIfError( wait->RequestStatus().Int() );

    CleanupStack::PopAndDestroy( wait );

    }

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

// CPEngWVStatusContentModel::HandleNewMyLogo()

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

//

void CPEngWVStatusContentModel::HandleNewMyLogo( HBufC8* aImageData,

                                                 HBufC8* aImageMimeType,

                                                 HBufC* aImageSoureFileName )

    {

    __ASSERT_ALWAYS( aImageData && aImageMimeType && aImageSoureFileName,

                     PanicStatusContModel( EModInvalidParamsHandleNewMyLogo ) );

    //This must take ownership of the given HBufC's in all cases

    //so no leaving allowed

    delete iMyLogoData;

    delete iMyLogoMimeType;

    delete iMyLogoSoureFileName;

    iMyLogoData = aImageData;

    iMyLogoMimeType = aImageMimeType;

    iMyLogoSoureFileName = aImageSoureFileName;

    }

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

// CPEngWVStatusContentModel::HandleConverterDestroy()

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

//

void CPEngWVStatusContentModel::HandleConverterDestroy()

    {

    iMyLogoConverter = NULL;

    }

//  End of File