/*
* 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: Implementation of ChspsLiwDump.
*
*/
#include "hspsbytebuffer.h"
#include "hspsliwdump.h"
#include "hspslogbus.h"
#include <s32mem.h>
#include <liwcommon.h>
#ifdef HSPS_BUILD_LOG_IMPLEMENTATION
// indentation delimiter
_LIT8 (KDelim8, "\t" );
_LIT( KDelim, "\t" );
_LIT( KCPlusPlusArrayStart, "const TUint8 liwDump[] = {" );
_LIT( KCPlusPlusArrayEnd, "};" );
const TInt KCPlusPlusArraySanityLimit = 16384; // 16kb.
_LIT( KByteFormat, "0x%02x" );
_LIT( KLiwListBinaryDumpStartTag, "#LIW LIST BINARY DUMP START" );
_LIT( KLiwListBinaryDumpEndTag, "#LIW LIST BINARY DUMP END" );
_LIT( KLiwListTextDumpStartTag, "#LIW LIST TEXT DUMP START" );
_LIT( KLiwListTextDumpEndTag, "#LIW LIST TEXT DUMP END" );
#endif
//------------------------------------------------------------------------------
// ChspsLiwDump::~ChspsLiwDump
//------------------------------------------------------------------------------
EXPORT_C ChspsLiwDump::~ChspsLiwDump()
{
}
//------------------------------------------------------------------------------
// ChspsLiwDump::NewLC
//------------------------------------------------------------------------------
EXPORT_C ChspsLiwDump* ChspsLiwDump::NewLC( ChspsLogBus& aLogBus )
{
ChspsLiwDump* self = new (ELeave)ChspsLiwDump( aLogBus );
CleanupStack::PushL(self);
self->ConstructL();
return self;
}
//------------------------------------------------------------------------------
// ChspsLiwDump::NewL
//------------------------------------------------------------------------------
EXPORT_C ChspsLiwDump* ChspsLiwDump::NewL( ChspsLogBus& aLogBus )
{
ChspsLiwDump* self = ChspsLiwDump::NewLC( aLogBus );
CleanupStack::Pop( self ); // self;
return self;
}
//------------------------------------------------------------------------------
// ChspsLiwDump::LogLiwListAsText
//------------------------------------------------------------------------------
#ifdef HSPS_BUILD_LOG_IMPLEMENTATION
EXPORT_C void ChspsLiwDump::LogLiwListAsText( CLiwGenericParamList& aLiwList )
{
TRAP_IGNORE( LogLiwListAsTextL( aLiwList ); );
}
#else
EXPORT_C void ChspsLiwDump::LogLiwListAsText( CLiwGenericParamList& /*aLiwList*/ )
{
}
#endif
#ifdef HSPS_BUILD_LOG_IMPLEMENTATION
//------------------------------------------------------------------------------
// ChspsLiwDump::LogLiwListAsBinary
//------------------------------------------------------------------------------
EXPORT_C void ChspsLiwDump::LogLiwListAsBinary( CLiwGenericParamList& aLiwList )
{
TRAP_IGNORE( LogLiwListAsBinaryL( aLiwList ); );
}
#else
EXPORT_C void ChspsLiwDump::LogLiwListAsBinary( CLiwGenericParamList& /*aLiwList*/ )
{
}
#endif
//------------------------------------------------------------------------------
// ChspsLiwDump::ChspsLiwDump
//------------------------------------------------------------------------------
ChspsLiwDump::ChspsLiwDump( ChspsLogBus& aLogBus ) : iLogBus( aLogBus )
{
iDepth = 0;
}
//------------------------------------------------------------------------------
// ChspsLiwDump::ConstructL
//------------------------------------------------------------------------------
void ChspsLiwDump::ConstructL()
{
}
//------------------------------------------------------------------------------
// ChspsLiwDump::LogLiwListAsTextL
//------------------------------------------------------------------------------
#ifdef HSPS_BUILD_LOG_IMPLEMENTATION
void ChspsLiwDump::LogLiwListAsTextL( CLiwGenericParamList& aLiwList )
{
iLogBus.LogText( KLiwListTextDumpStartTag );
// implementation for GetActiveAppConf and GetPluginConf that has map
// as base root.
iDepth = 0;
TInt count = aLiwList.Count();
for( TInt i = 0; i < count; i++ )
{
//get Generic param and check for param id and name.
TLiwGenericParam param = aLiwList[i];
//Check for the param identifier:
LIW::TGenericParamId identifier = param.SemanticId();
//print semanticId:
iLogBus.LogText( _L8(" SemanticId: %d"), identifier );
if( identifier == LIW::EGenericParamError )
{
iLogBus.LogText( _L8(" ERROR: EGenericParamError") );
}
//get generic param name.
//print name.
iLogBus.LogText( param.Name() );
//get Variant
TLiwVariant value = param.Value();
//get variant type.
PrintVariantL( value );
}
iLogBus.LogText( KLiwListTextDumpEndTag );
}
#else
void ChspsLiwDump::LogLiwListAsTextL( CLiwGenericParamList& /*aLiwList*/ )
{
}
#endif
#ifdef HSPS_BUILD_LOG_IMPLEMENTATION
//------------------------------------------------------------------------------
// ChspsLiwDump::LogLiwListAsBinaryL
//------------------------------------------------------------------------------
void ChspsLiwDump::LogLiwListAsBinaryL( CLiwGenericParamList& aLiwList )
{
iLogBus.LogText( KLiwListBinaryDumpStartTag );
const TInt byteSize = aLiwList.Size();
if( byteSize <= 0 )
{
User::Leave( KErrArgument );
}
// Create memory buffer.
ChspsByteBuffer* buffer = ChspsByteBuffer::NewL( byteSize );
CleanupStack::PushL( buffer );
// Wrap buffer using memory stream.
RMemWriteStream stream;
stream.Open( buffer->Buffer(), byteSize );
stream.PushL();
// Use stream that wraps buffer to enable direct-to-RAM
// streaming from CLiwGenericParamList.
aLiwList.ExternalizeL( stream );
stream.CommitL();
// Clean stream wrapper.
stream.Release();
stream.Close();
stream.Pop();
// Create C++ array and print it.
HBufC* cplusplusDump = CreateCPlusPlusDumpL( *buffer );
iLogBus.LogText( *cplusplusDump );
delete cplusplusDump;
cplusplusDump = NULL;
// Clean memory buffer
CleanupStack::PopAndDestroy( buffer );
iLogBus.LogText( KLiwListBinaryDumpEndTag );
}
#else
void ChspsLiwDump::LogLiwListAsBinaryL( CLiwGenericParamList& /*aLiwList*/ )
{
}
#endif
//------------------------------------------------------------------------------
// ChspsLiwDump::PrintVariantL
//------------------------------------------------------------------------------
#ifdef HSPS_BUILD_LOG_IMPLEMENTATION
void ChspsLiwDump::PrintVariantL( TLiwVariant value )
{
LIW::TVariantTypeId variantId = value.TypeId();
if( variantId == LIW::EVariantTypeDesC8 )
{
PrintString8L( value );
}
else if( variantId == LIW::EVariantTypeDesC )
{
PrintStringL( value );
}
else if ( variantId == LIW::EVariantTypeMap )
{
HBufC* text = GetFixedTextLC( _L("<Map>"), iDepth, KDelim );
iLogBus.LogText( *text );
CleanupStack::PopAndDestroy( text );
PrintMapL( value );
}
else if ( variantId == LIW::EVariantTypeList )
{
HBufC* text = GetFixedTextLC( _L("<List>"), iDepth, KDelim );
iLogBus.LogText( *text );
CleanupStack::PopAndDestroy( text );
PrintListL( value );
}
else
{
iLogBus.LogText( _L8("--- TODO: Unknown --- "));
}
}
#else
void ChspsLiwDump::PrintVariantL( TLiwVariant /*value*/ )
{
}
#endif
//------------------------------------------------------------------------------
// ChspsLiwDump::PrintMapL
//------------------------------------------------------------------------------
#ifdef HSPS_BUILD_LOG_IMPLEMENTATION
void ChspsLiwDump::PrintMapL( TLiwVariant value )
{
//get map from the variant.
//get map values.
const CLiwMap* map = value.AsMap();
TInt count = map->Count();
for( TInt i = 0; i < count; i++ )
{
HBufC* index = GetFixedTextLC( _L("---"), iDepth, KDelim );
iLogBus.LogText( *index );
CleanupStack::PopAndDestroy( index );
TBuf8<100> buf;
map->AtL( i, buf);
HBufC8* text = GetFixedText8LC( buf, iDepth, KDelim8 );
iLogBus.LogText( *text );
CleanupStack::PopAndDestroy( text );
TLiwVariant value;
map->FindL( buf, value );
PrintVariantL( value );
value.Reset();
}
}
#else
void ChspsLiwDump::PrintMapL( TLiwVariant /*value*/ )
{
}
#endif
//------------------------------------------------------------------------------
// ChspsLiwDump::PrintStringL
//------------------------------------------------------------------------------
#ifdef HSPS_BUILD_LOG_IMPLEMENTATION
void ChspsLiwDump::PrintStringL( TLiwVariant value )
{
TPtrC textValue = value.AsDes();
HBufC* text = GetFixedTextLC( textValue, iDepth, KDelim );
iLogBus.LogText( *text );
CleanupStack::PopAndDestroy( text );
}
#else
void ChspsLiwDump::PrintStringL( TLiwVariant /*value*/ )
{
}
#endif
//------------------------------------------------------------------------------
// ChspsLiwDump::PrintString8L
//------------------------------------------------------------------------------
#ifdef HSPS_BUILD_LOG_IMPLEMENTATION
void ChspsLiwDump::PrintString8L( TLiwVariant value )
{
TPtrC8 textValue = value.AsData();
HBufC8* text = GetFixedText8LC( textValue, iDepth, KDelim8 );
iLogBus.LogText( *text );
CleanupStack::PopAndDestroy( text );
}
#else
void ChspsLiwDump::PrintString8L( TLiwVariant /*value*/ )
{
}
#endif
//------------------------------------------------------------------------------
// ChspsLiwDump::PrintListL
//------------------------------------------------------------------------------
#ifdef HSPS_BUILD_LOG_IMPLEMENTATION
void ChspsLiwDump::PrintListL( TLiwVariant value )
{
iDepth++;
const CLiwList* list = value.AsList();
TInt count = list->Count();
for( TInt i = 0; i < count; i++ )
{
HBufC* index = GetFixedTextLC( _L("---"), iDepth, KDelim );
iLogBus.LogText( *index );
CleanupStack::PopAndDestroy( index );
TLiwVariant value;
list->AtL( i, value );
PrintVariantL( value );
value.Reset();
}
iDepth--;
}
#else
void ChspsLiwDump::PrintListL( TLiwVariant /*value*/ )
{
}
#endif
//------------------------------------------------------------------------------
// ChspsLiwDump::GetFixedText8LC
//------------------------------------------------------------------------------
#ifdef HSPS_BUILD_LOG_IMPLEMENTATION
HBufC8* ChspsLiwDump::GetFixedText8LC( const TDesC8& aText,
const TInt aDepth,
const TDesC8& aDelim )
{
HBufC8 *buf = HBufC8::NewLC( aDepth * aDelim.Length() + aText.Length() + 1 );
TInt i = 0;
for( ; i < aDepth; i++ )
{
buf->Des().Append( aDelim );
}
buf->Des().Append( aText );
return buf;
}
#else
HBufC8* ChspsLiwDump::GetFixedText8LC( const TDesC8& /*aText*/,
const TInt /*aDepth*/,
const TDesC8& /*aDelim*/ )
{
return NULL;
}
#endif
//------------------------------------------------------------------------------
// ChspsLiwDump::GetFixedTextLC
//------------------------------------------------------------------------------
#ifdef HSPS_BUILD_LOG_IMPLEMENTATION
HBufC* ChspsLiwDump::GetFixedTextLC( const TDesC& aText,
const TInt aDepth,
const TDesC& aDelim )
{
HBufC *buf = HBufC::NewLC( aDepth * aDelim.Length() + aText.Length() + 1 );
TInt i = 0;
for( ; i < aDepth; i++ )
{
buf->Des().Append( aDelim );
}
buf->Des().Append( aText );
return buf;
}
#else
HBufC* ChspsLiwDump::GetFixedTextLC( const TDesC& /*aText*/,
const TInt /*aDepth*/,
const TDesC& /*aDelim*/ )
{
return NULL;
}
#endif
//------------------------------------------------------------------------------
// ChspsLiwDump::CreateCPlusPlusDumpL
//------------------------------------------------------------------------------
#ifdef HSPS_BUILD_LOG_IMPLEMENTATION
HBufC* ChspsLiwDump::CreateCPlusPlusDumpL( ChspsByteBuffer& aBuffer ) const
{
if( aBuffer.Size() <= 0 )
{
User::Leave( KErrArgument );
}
if( aBuffer.Size() > KCPlusPlusArraySanityLimit )
{
User::Leave( KErrArgument );
}
// Calcute required space.
const TInt KOneByteFootprint = 5; // hex is like 0x00 = 4 bytes, then trailing ',' for each one.
const TInt KRequiredSpace = KCPlusPlusArrayStart().Length() +
( aBuffer.Size() * KOneByteFootprint ) +
KCPlusPlusArrayEnd().Length();
// Create descriptor.
HBufC* descriptor = HBufC::NewLC( KRequiredSpace );
TPtr16 pointer = descriptor->Des();
pointer.Append( KCPlusPlusArrayStart );
for( TInt i = 0; i < aBuffer.Size(); i++ )
{
TUint byte = ( TUint ) ( ( aBuffer.Buffer() )[i] );
pointer.AppendFormat( KByteFormat, byte );
// Add ',' for all but the last element.
if( i != ( aBuffer.Size() - 1 ) )
{
pointer.Append( TChar( ',' ) );
}
}
pointer.Append( KCPlusPlusArrayEnd );
CleanupStack::Pop( descriptor );
return descriptor;
}
#else
HBufC* ChspsLiwDump::CreateCPlusPlusDumpL( ChspsByteBuffer& /*aBuffer*/ ) const
{
return NULL;
}
#endif