/*

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

*

*

*/

#include <mmf/common/mmfcontrollerpluginresolver.h>

#include <liwservicehandler.h>

#include <f32fsys.h>

#include "hnmdbasekey.h"

#include "hnglobals.h"

#include "hnliwutils.h"

#include "hnconvutils.h"

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

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

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

EXPORT_C void HnLiwUtils::SetGenericParamListL(

    const RPointerArray<CHnMdBaseKey> & aKeys,

    CLiwGenericParamList & aInParam )

    {

    // for each key

    for ( TInt i( 0 ); i < aKeys.Count(); i++ )

        {

        CHnMdBaseKey* key = aKeys[i];

        const TDesC8& keyName = key->KeyName();

        TLiwVariant value;

        value.PushL();

        key->ToVariantL( value );

        CleanupStack::PopAndDestroy( &value );

        }

    }

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

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

//

EXPORT_C TBool HnLiwUtils::VariantToStringL(

        TLiwVariant& aVariant,

        RBuf& aBuf )

    {

    TBool accepted( ETrue );

    switch ( aVariant.TypeId() )

        {

        case LIW::EVariantTypeDesC:

            {

            aBuf.CreateL( aVariant.AsDes() );

            break;

            }

        case LIW::EVariantTypeDesC8:

            {

            HBufC* tmp = HnConvUtils::Str8ToStr( aVariant.AsData() );

            if ( !tmp )

                {

                User::Leave( KErrNoMemory );

                }

                aBuf.Assign( tmp );

            break;

            }

        case LIW::EVariantTypeTUid:

            {

            aBuf.CreateL( KMaxLength );

            aBuf.AppendNum( aVariant.AsTUid().iUid, EHex );

            break;

            }

        case LIW::EVariantTypeTInt32:

            {

            aBuf.CreateL( KMaxLength );

            aBuf.AppendNum( aVariant.AsTInt32() );

            break;

            }

        case LIW::EVariantTypeTInt64:

            {

            aBuf.CreateL( KMaxLength );

            aBuf.AppendNum( aVariant.AsTInt64() );

            break;

            }

        case LIW::EVariantTypeTUint:

            {

            aBuf.CreateL( KMaxLength );

            aBuf.AppendNum( aVariant.AsTUint() );

            break;

            }

        case LIW::EVariantTypeTBool:

            {

            aBuf.CreateL( KMaxLength );

            aBuf.AppendNum( aVariant.AsTBool() );

            break;

            }

        default:

            {

            accepted = EFalse;

            }

        }

    return accepted;

    }

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

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

//

EXPORT_C TBool HnLiwUtils::VariantToStringL(

        TLiwVariant& aVariant,

        RBuf8& aBuf )

    {

    TBool accepted( ETrue );

    switch ( aVariant.TypeId() )

        {

        case LIW::EVariantTypeDesC:

            {

            aBuf.Assign( HnConvUtils::StrToStr8L( aVariant.AsDes() ) );

            break;

            }

        case LIW::EVariantTypeDesC8:

            {

            aBuf.CreateL( aVariant.AsData() );

            break;

            }

        case LIW::EVariantTypeTUid:

            {

            aBuf.CreateL( KMaxLength );

            aBuf.AppendNum( aVariant.AsTUid().iUid, EHex );

            break;

            }

        case LIW::EVariantTypeTInt32:

            {

            aBuf.CreateL( KMaxLength );

            aBuf.AppendNum( aVariant.AsTInt32() );

            break;

            }

        case LIW::EVariantTypeTInt64:

            {

            aBuf.CreateL( KMaxLength );

            aBuf.AppendNum( aVariant.AsTInt64() );

            break;

            }

        case LIW::EVariantTypeTUint:

            {

            aBuf.CreateL( KMaxLength );

            aBuf.AppendNum( aVariant.AsTUint() );

            break;

            }

        case LIW::EVariantTypeTBool:

            {

            aBuf.CreateL( KMaxLength );

            aBuf.AppendNum( aVariant.AsTBool() );

            break;

            }

        default:

            {

            accepted = EFalse;

            }

        }

    return accepted;

    }

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

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

//

EXPORT_C TInt HnLiwUtils::GetIterableItemCountL( CLiwIterable& aIterable )

    {

    TInt count = 0;

    TLiwVariant variant;

    variant.PushL();

    aIterable.Reset();

    while( aIterable.NextL(variant))

        {

        ++count;

        }

    CleanupStack::PopAndDestroy( &variant );

    return count;

    }

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

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

//

EXPORT_C TInt HnLiwUtils::GetStringL(

    const CLiwGenericParamList& aParam,

    const TDesC8& aPath,

    RBuf& aRet )

    {

    TInt ret( KErrNone );

    TLiwVariant value;

    value.PushL();

    ret = GetVariantL( aParam, aPath, value );

    if ( ret == KErrNone && !VariantToStringL( value, aRet ) )

        {

        ret = KErrBadDescriptor;

        }

    CleanupStack::PopAndDestroy( &value );

    return ret;

    }

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

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

//

EXPORT_C TInt HnLiwUtils::GetStringL(

    const CLiwGenericParamList& aParam,

    const TDesC8& aPath,

    RBuf8& aRet )

    {

    TInt ret( KErrNone );

    TLiwVariant value;

    value.PushL();

    ret = GetVariantL( aParam, aPath, value );

    if ( ret == KErrNone && !VariantToStringL( value, aRet ) )

        {

        ret = KErrBadDescriptor;

        }

    CleanupStack::PopAndDestroy( &value );

    return ret;

    }

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

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

//

EXPORT_C TInt HnLiwUtils::GetStringL( const CLiwGenericParamList& aParam,

    const TDesC8& aPath, TInt aPos, RBuf& aRet )

    {

    TInt ret( KErrNone );

    TLiwVariant value;

    value.PushL();

    ret = GetVariantL( aParam, aPath, aPos, value );

    if ( ret == KErrNone && !VariantToStringL( value, aRet ) )

        {

        ret = KErrBadDescriptor;

        }

    CleanupStack::PopAndDestroy( &value );

    return ret;

    }

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

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

//

EXPORT_C TInt HnLiwUtils::GetStringL( const CLiwGenericParamList& aParam,

    const TDesC8& aPath, TInt aPos, RBuf8& aRet )

    {

    TInt ret( KErrNone );

    TLiwVariant value;

    value.PushL();

    ret = GetVariantL( aParam, aPath, aPos, value );

    if ( ret == KErrNone && !VariantToStringL( value, aRet ) )

        {

        ret = KErrBadDescriptor;

        }

    CleanupStack::PopAndDestroy( &value );

    return ret;

    }

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

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

//

EXPORT_C TInt HnLiwUtils::GetInt64L( const CLiwGenericParamList& aParam,

    const TDesC8& aPath, TInt aPos, TInt64& aRet )

    RBuf8 buf;

    TInt err = HnLiwUtils::GetStringL( aParam, aPath, aPos, buf );

    if ( KErrNone == err )

        TInt64 value( KErrNotFound );

        TLex8 lex( buf );

    buf.Close();

    }

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

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

//

EXPORT_C TInt HnLiwUtils::GetVariantL(

    const CLiwGenericParamList& aParam,

    const TDesC8& aPath,

    TInt aPos,

    TLiwVariant& aRet )

    {

    TInt ret( KErrNone );

    RBuf8 path;

    CleanupClosePushL( path );

    path.CreateL( aPath );

    // replace index if exist in the path

    HnLiwUtils::ReplaceIndexL( path, aPos );

    // fetch variant

    ret = HnLiwUtils::GetVariantL( aParam, path, aRet );

    if ( ret == KErrNotFound )

        {

        TInt colonFound( aPath.Find( KColon8 ) );

        if ( KErrNotFound != colonFound )

            {

            /*TInt pos( 0 );

            TInt rest( aPos );

            while ( ( rest = rest / 10 ) != 0 )

                pos++;

                }*/

            TLiwVariant tempVariant;

            tempVariant.PushL();

            if ( KErrNotFound != HnLiwUtils::GetVariantL( aParam, path, aRet ) )

                {

                ret = KErrHidden;

                }

            else

                {

                ret = KErrNotFound;

                }

            CleanupStack::PopAndDestroy( &tempVariant );

            }

        }

    CleanupStack::PopAndDestroy( &path );

    return ret;

    }

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

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

//

TInt HnLiwUtils::ExtractNameSpaceL(

    const TDesC8& aNameSpace,

    TLiwVariant& aRet )

    {

        TInt pos( 0 );

        const TLiwGenericParam* param;

        if ( &aParam != NULL )

        else

        return pos;

    }

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

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

//

EXPORT_C TInt HnLiwUtils::GetVariantL(

    const CLiwGenericParamList& aParam,

    const TDesC8& aPath,

    TLiwVariant& aRet )

    {

    RArray< TPtrC8 > path;

    CleanupClosePushL( path );

    TInt ret( KErrNone );

    TLiwVariant variant;

    TLiwVariant lastVariant;

    variant.PushL();

    lastVariant.PushL();

    aRet.SetL( TLiwVariant( aPath ) );

    ParsePathL( aPath, path );

    if ( path.Count() > 0

        && ExtractNameSpaceL( aParam, path[0], lastVariant ) != KErrNotFound )

        {

        TBool found( ETrue );

        for ( TInt i( 1 ); i < path.Count() && found; i++ )

            {

            TPtrC8 name = path[ i ];

            LIW::TVariantTypeId typeId = lastVariant.TypeId();

            // LIW::Type ID 7

                {

                TInt pos( GetPosition( name ) );

                found = (pos != KErrNotFound) ? lastVariant.AsList()->AtL( pos, variant ) : EFalse;

                }

            // LIW::Type ID 8

                {

                found = lastVariant.AsMap()->FindL( name, variant );

                }

            // LIW::Type ID 9

                {

                TInt pos( GetPosition( name ) );

                found = GetIterableByPositionL( *lastVariant.AsIterable(), pos, variant );

                }

            }

        ret = found ? KErrNone : KErrNotFound;

        //aRet.SetL( ( ret != KErrNotFound ) ? variant : TLiwVariant( aPath ) );

        if ( found == 0 )

        else

        }

    CleanupStack::PopAndDestroy( &lastVariant );

    CleanupStack::PopAndDestroy( &variant );

    CleanupStack::PopAndDestroy( &path );

    return ret;

    }

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

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

//

void HnLiwUtils::ParsePathL(

    RArray< TPtrC8 >& aPathParts )

    {

    TChar ch; // token separator

    TInt colonPos = aPath.Find( KColon8 );

    if ( colonPos > 0 )

        {

        TLex8 lex( aPath );

        while ( !lex.Eos() )

            {

            ch = lex.Get();

            // namespace

            if ( ch == KColon()[0] )

                {

                lex.UnGet();

                TPtrC8 nextToken = lex.MarkedToken();

                lex.SkipAndMark( 1 );

                aPathParts.AppendL( nextToken );

                }

            // list or map

            else if ( ch == KSlash()[0] )

                {

                lex.UnGet();

                TPtrC8 nextToken = lex.MarkedToken();

                lex.SkipAndMark( 1 );

                aPathParts.AppendL( nextToken );

                }

            // last token

            else if ( lex.Eos() )

                {

                TPtrC8 nextToken = lex.MarkedToken();

                aPathParts.AppendL( nextToken );

                break;

                }

            }

        }

    }

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

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

//

                                          TLiwVariant & aVariant )

    TBool ret(EFalse);

    if ( pos >= 0 )

        {

        TInt counter = 0;

        aIterable.Reset();

        ret = aIterable.NextL( aVariant );

        while ( ret )