/*

* 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:  Tone class definition.

*

*/

// System Includes

#include <e32math.h>

#include <s32mem.h>

// User Includes

#include "evttoneaction.h"

#include "evtdebug.h"

// ================ Member funtions for CEvtToneAction class ======================

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

// CEvtToneAction::CEvtToneAction

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

//

EXPORT_C CEvtToneAction::CEvtToneAction():

	iToneLoop( EFalse )

    {    

    }

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

// CEvtToneAction::~CEvtToneAction

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

//

EXPORT_C CEvtToneAction::~CEvtToneAction()

    {

    delete iFileName;

    } 

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

// CEvtToneAction::NewL

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

//

EXPORT_C CEvtToneAction* CEvtToneAction::NewL()

    {

	CEvtToneAction* self = NewLC( );

	CleanupStack::Pop( self );

	return self;

    }

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

// CEvtToneAction::NewLC

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

//

EXPORT_C CEvtToneAction* CEvtToneAction::NewLC()

    {

	CEvtToneAction* self = new ( ELeave )CEvtToneAction( );

	CleanupStack::PushL( self );

	self->ConstructL( );

	return self;

    } 

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

// CEvtToneAction::ConstructL

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

//

EXPORT_C void CEvtToneAction::ConstructL()

    {

    // Allocate the Null string by default

    iFileName = KNullDesC().AllocL();

    } 

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

// CEvtToneAction::Tone

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

//

EXPORT_C TPtrC CEvtToneAction::FileName() const

    {

    return iFileName->Des();

    } 

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

// CEvtToneAction::SetToneL

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

//

EXPORT_C void CEvtToneAction::SetFileNameL( const TDesC& aFileName )

    {

    delete iFileName;

	iFileName = NULL;

    iFileName = aFileName.AllocL();

    } 

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

// CEvtToneAction::ToneLoop

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

//

EXPORT_C TBool CEvtToneAction::ToneLoop() const

    {

    return iToneLoop;

    } 

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

// CEvtToneAction::SetToneLoop

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

//

EXPORT_C void CEvtToneAction::SetToneLoop( const TBool aToneLoop )

    {

    iToneLoop = aToneLoop;

    } 

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

// CEvtToneAction::ExternalizeL

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

//

EXPORT_C void CEvtToneAction::ExternalizeL( CEvtAction&   aAction )

    {

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

    CleanupStack::PushL( buffer );

    // Allocate a common buffer for both read and write streams

    RBufWriteStream writestream( *buffer, 0 );

    // Externalize from CEvtToneAction

    ExternalizeL( writestream );

    // Covert the 8 bit Stream to 16 bit descriptor.

    TPtr8 bufPtr = buffer->Ptr(0);

    TPtrC display;

    display.Set( (TUint16*)bufPtr.Ptr(), (bufPtr.Length()>>1) );

    // Internalize from CEvtAction

    aAction.SetActionL( display );

    CleanupStack::PopAndDestroy( buffer );

    } 

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

// CEvtToneAction::InternalizeL

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

//

EXPORT_C void CEvtToneAction::InternalizeL( CEvtAction&   aAction )

    {

    // Internalize from CEvtAction

    TPtrC ptr = aAction.Action( );

    // Create a buffer of ptr's size granularity

    CBufFlat* buffer = CBufFlat::NewL( ptr.Size() );

    CleanupStack::PushL( buffer );

	// Insert the action String into buffer

    buffer->InsertL( 0, (TAny*)ptr.Ptr(), (ptr.Length()<<1) );

    // Allocate a common buffer for both read and write streams

    RBufReadStream readstream( *buffer, 0 );

    // Internalize from CEvtToneAction

    InternalizeL( readstream );

    CleanupStack::PopAndDestroy( buffer );

    } 

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

// CEvtToneAction::ExternalizeL

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

//

void CEvtToneAction::ExternalizeL( RWriteStream&   aWriteStream )

    {

    // Externalize will happen in the order of

    // - Action Type

    // - Tone String length

    // - Tone String

    // - Tone Loop

    TInt length = iFileName->Length();

    aWriteStream.WriteUint8L( EAlarm );

    aWriteStream.WriteUint32L( length );

    // Avoid WriteL, if the Tone String length is 0.

    if( 0 != length )

        aWriteStream.WriteL( iFileName->Des(), length );

    aWriteStream.WriteUint8L( iToneLoop );

    } 

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

// CEvtToneAction::InternalizeL

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

//

void CEvtToneAction::InternalizeL( RReadStream&    aReadStream )

    {

    // Internalize will happen in the order of

    // - Action Type

    // - Tone String length

    // - Tone String

    // - Tone Loop

    TEvtActionType type;    

    type = static_cast<TEvtActionType>(aReadStream.ReadUint8L());

    // Leave if the Action type is not EAlarm

    if( EAlarm != type )

        User::Leave( KErrArgument );

    // Get the length of tone String.

    TInt length = aReadStream.ReadUint32L();

    if( iFileName )

        delete iFileName;

    // Avoid ReadL, if the Tone String length is 0.

    if( 0 != length )

        {

        iFileName = HBufC::NewL( length );

        TPtr actn( iFileName->Des() );

	    // ReadL can leave if we try to read any intermediate 8 bit 

	    // descriptor. So we can ignore it.

        TRAP_IGNORE( aReadStream.ReadL(actn, length));

        }

    else

        {

        iFileName = KNullDesC().AllocL();

        }

    // Get the Toon Loop

    iToneLoop = static_cast<TBool>( aReadStream.ReadUint8L() );

    } 

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

// CEvtToneAction::TotalSize

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

//

TInt CEvtToneAction::TotalSize( )

    {

    TInt size=0;

    size += sizeof( TUint8 );                   // Type Size

    size += sizeof( TUint32 );                  // Tone Length Size

    size += iFileName->Des().MaxSize();       // Tone Size

    size += sizeof( TUint8 );                   // Loop Size

	return size;

    } 

// End of File