/*
* Copyright (c) 2007 Nokia Corporation and/or its subsidiary(-ies).
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of the License "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 Liw Device binding
*
*/


#include <config.h>
#include <value.h>
#include <interpreter.h>
#include <date_object.h>
#include <operations.h>
#include <liwServiceHandler.h>
#include <RTSecManager.h>
#include <RTSecMgrUtility.h>
#include <RTSecMgrScriptSession.h>
#include <RTSecMgrCommonDef.h>
#include <WidgetRegistryClient.h>
#include <PropertyNameArray.h>
#include <internal.h>
#include <liwvariant.h>
#include <liwbufferextension.h>

#include "DeviceLiwBinding.h"
#include "DeviceLiwPeer.h"
#include "DeviceBinding.h"
#include "ServiceObject.h"
#include "ServiceEventHandler.h"
#include "DeviceLiwInterface.h"
#include "DeviceLiwMap.h"
#include "DeviceLiwIterable.h"
#include "DeviceLiwResult.h"

using namespace KJS;
using namespace LIW;

// CONSTANTS
#define SAPISECURITYPROMPTNEEDED 0x0001
#define SAPIPROMPTLESS           0x0002
#define SAPIACCESSDENIED         0x0003

// TBD: This needs to be substituted with LIW const in LIW header
const TInt KMaxKeySize = 255;
_LIT8( KWildChar, "*" );

const TInt KTimeBufSize = 255;
_LIT( KLocaleDateTime, "%E,%D%N%Y  %1 %2, %3%-B %:0%J%:1%T%:2%S%+B" );

// JS time epoch 1st January 1970 (needed to offset from Symbian epoch)
_LIT(KJsEpoch, "19700000:000000.000000");


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

// ----------------------------------------------------------------------------
// CDeviceLiwBinding::NewL
// NewL
//
// ----------------------------------------------------------------------------
//
CDeviceLiwBinding* CDeviceLiwBinding::NewL()
    {
    CDeviceLiwBinding* bind = new (ELeave) CDeviceLiwBinding();
    CleanupStack::PushL(bind);
    bind->ConstructL();
    CleanupStack::Pop(bind);
    return bind;
    }

// ----------------------------------------------------------------------------
// CDeviceLiwBinding::ConstructL
// ConstructL sencond phace construction.
//
// ----------------------------------------------------------------------------
//
void CDeviceLiwBinding::ConstructL()
    {
        m_critArr = new (ELeave) RCriteriaArray();
        m_serviceHandler = CLiwServiceHandler::NewL();

        RWidgetRegistryClientSession widgetregistry;
        TInt ret = widgetregistry.Connect();
        if ( ret != KErrNone && ret != KErrAlreadyExists )
            {
            User::Leave( ret );
            }
        else
            {
            CleanupClosePushL( widgetregistry );
            }
        TInt aPolicyId = widgetregistry.SecurityPolicyId();
        if ( aPolicyId < 0 )
            {
            User::Leave( aPolicyId );
            }
        User::LeaveIfError(widgetregistry.Disconnect());
        CleanupStack::PopAndDestroy(); //widgetregistry

        // we need to keep main session allive, to keep sub session
        m_secMgr = CRTSecManager::NewL();

        CTrustInfo* trust = CTrustInfo::NewLC();

        // TODO: in future, to support blanket permission,
        // this function should be called at installation time.
        // TInt32 exId = secMgr->RegisterScript( aPolicyId, *trust );
        // m_scriptSession = secMgr->GetScriptSession( aPolicyId, exId );

        // check for script session validity.
        m_scriptSession = m_secMgr->GetScriptSessionL( aPolicyId, *trust );
        if ( !m_scriptSession )
            {
            User::Leave( KErrGeneral );
            }
#ifdef SECURITYMANAGER_PROMPT_ENHANCEMENT
		m_scriptSession->SetPromptOption(RTPROMPTUI_PROVIDER);   //  This is for setting the new prompting method
#endif
        CleanupStack::PopAndDestroy( trust );
    }

// ----------------------------------------------------------------------------
// CDeviceLiwBinding::~CDeviceLiwBinding
// Default destructor
//
// ----------------------------------------------------------------------------
//
CDeviceLiwBinding::~CDeviceLiwBinding()
    {
    m_critArr->ResetAndDestroy();
    m_serviceHandler->DetachL(*m_critArr);
    m_critArr->ResetAndDestroy();
    delete m_critArr;
    delete m_serviceHandler;
    delete m_scriptSession;
    delete m_secMgr;
    }


// ----------------------------------------------------------------------------
// CDeviceLiwBinding::LoadServiceProvider
// Load service provider
//
// ----------------------------------------------------------------------------
//
TInt CDeviceLiwBinding::LoadServiceProvider( ExecState* exec, const List& args )
    {
    TInt error = KErrNone;
    CLiwCriteriaItem* item;
    HBufC8* svcName = NULL;
    HBufC8* interfaceName = NULL;
    int argcount = args.size();

    if ( argcount > 0 && args[0]->type() == StringType &&
        args[0]->toString( exec ).size() > 0 )
        {
            TRAP( error,
            {
            // Get service name
            svcName = KJS::GetAsciiBufferL( args[0]->toString( exec ) );
            CleanupStack::PushL( svcName );

            // Get optional supported interface
            if ( argcount > 1 && args[1]->type() == StringType &&
                args[1]->toString( exec ).size() > 0 )
                {
                interfaceName = KJS::GetAsciiBufferL( args[1]->toString( exec ) );
                CleanupStack::PushL( interfaceName );
                }

            if ( interfaceName && interfaceName->Length() > 0 )
                {
                item = CLiwCriteriaItem::NewLC( 1, *interfaceName, *svcName );
                }
            else
                {
                item = CLiwCriteriaItem::NewLC( 1, KNullDesC8(), *svcName );
                }

            item->SetServiceClass( TUid::Uid( KLiwClassBase ) );
            RCriteriaArray crit_arr;
            crit_arr.AppendL( item );

            CleanupStack::Pop(item); // item

            // "Attach" runtime to service
            if ( m_scriptSession && m_serviceHandler )
                {
                TInt load_err;
                RWidgetRegistryClientSession widgetregistry;
                TInt ret = widgetregistry.Connect();
                if ( ret != KErrNone && ret != KErrAlreadyExists )
                    {
                    User::Leave( ret );
                    }
                else
                   {
                   CleanupClosePushL( widgetregistry );
                   }

                switch ( widgetregistry.WidgetSapiAccessState(m_Uid))
                    {
                    case SAPISECURITYPROMPTNEEDED :
                        load_err = m_serviceHandler->AttachL( crit_arr, *m_scriptSession );
                        break;
                    case SAPIPROMPTLESS :
                        load_err = m_serviceHandler->AttachL( crit_arr );
                        break;
                    case SAPIACCESSDENIED :
                        load_err = KLiwSecurityAccessCheckFailed;
                        break;
                    default :
                        load_err = KLiwSecurityAccessCheckFailed;
                        break;
                    }

                User::LeaveIfError(widgetregistry.Disconnect());
                CleanupStack::PopAndDestroy(); //widgetregistry
                // hard coded for now since the definition of TLiwLoadStatus is not exposed to common dir yet
                if ( load_err == KLiwServiceLoadSuccess || load_err == KLiwServiceAlreadyLoaded )
                    {
                    error = KErrNone; // normalize the error
                    m_critArr->AppendL( item );
                    }
                else
                    {
                    error = load_err; // pass on the TLiwLoadStatus
                    delete item;
                    }
                }

            if ( interfaceName )
                {
                CleanupStack::PopAndDestroy( interfaceName );
                }

            CleanupStack::PopAndDestroy( svcName );
            });
        }
    else
        {
        error = KErrArgument;
        }

    return error;
    }

// ---------------------------------------------------------------------------
// Convert Unload service provider
// return JSValue - javascript list
// ---------------------------------------------------------------------------
//
void CDeviceLiwBinding::UnloadServiceProvider(const TDesC8& aServiceName,const TDesC8& aInterfaceName)
    {
    TRAP_IGNORE(
        CLiwCriteriaItem* item = CLiwCriteriaItem::NewLC( 1, aInterfaceName, aServiceName );
        item->SetServiceClass( TUid::Uid( KLiwClassBase ) );
        RCriteriaArray critArray;
        critArray.AppendL( item );
        m_serviceHandler->DetachL( critArray );
        CleanupStack::Pop(item);
        critArray.ResetAndDestroy();
        for (int i = 0; i < m_critArr->Count(); i++)
            {
            if ( (*m_critArr)[i]->ServiceCmdStr() == aInterfaceName &&
                 (*m_critArr)[i]->ContentType() == aServiceName)
                m_critArr->Remove(i);
            }
        )
    }

// ----------------------------------------------------------------------------
// CDeviceLiwBinding::ServiceObjectPeer
// Factory method to create a peer with service name
//
//
// ----------------------------------------------------------------------------
//
MDevicePeer* CDeviceLiwBinding::ServiceObjectPeer(
    ExecState *exec,
    const List& args )
    {
    DeviceLiwPeer* peer = NULL;

    TRAPD( error,
        {
        peer = new ( ELeave ) DeviceLiwPeer(
            exec->lexicalInterpreter()->globalExec(), this, 0 );
        CleanupStack::PushL( peer );
        peer->SetServiceNameL( exec, args );
        CleanupStack::Pop(peer);
        });

    if ( error != KErrNone )
        {
        return 0;
        }

    return static_cast<MDevicePeer*>( peer );
    }

// ----------------------------------------------------------------------------
// CDeviceLiwBinding::ListProviders
// Call/Invoke the LIW function to list the providers
//
//
// ----------------------------------------------------------------------------
//
JSValue* CDeviceLiwBinding::ListProviders(
    ExecState* exec,
    const List& args )
    {
    CLiwCriteriaItem* item = NULL;
    HBufC8* cmdName = NULL;
    HBufC8* contentName = NULL;
    int argcount = args.size();

    // Get content name
    if ( argcount > 0 && args[0]->type() == StringType &&
        args[0]->toString( exec ).size() > 0 )
        {
        contentName = KJS::GetAsciiBufferL( args[0]->toString( exec ) );
        CleanupStack::PushL( contentName );
        }

    if ( argcount > 1 && args[1]->type() == StringType &&
        args[1]->toString( exec ).size() > 0 )
        {
        // Get cmd name
        cmdName = KJS::GetAsciiBufferL( args[1]->toString( exec ) );
        CleanupStack::PushL( cmdName );
        }

    if ( cmdName && cmdName->Length() > 0 )
        {
        if ( contentName && contentName->Length() > 0 )
            {
            item = CLiwCriteriaItem::NewLC( 1, *cmdName, *contentName );
            }
        else
            {
            item = CLiwCriteriaItem::NewLC( 1, *cmdName, KWildChar() );
            }
        }
    else
        {
        if ( contentName && contentName->Length() > 0 )
            {
            item = CLiwCriteriaItem::NewLC( 1, KWildChar(), *contentName );
            }
        else
            {
            item = CLiwCriteriaItem::NewLC( 1, KWildChar(), KWildChar() );
            }
        }

    RCriteriaArray critArray, providerList;
    item->SetServiceClass( TUid::Uid( KLiwClassBase ) );
    critArray.AppendL( item );
    m_serviceHandler->QueryImplementationL( critArray, providerList );
    CleanupStack::Pop();//item

    if ( contentName )
        {
        CleanupStack::PopAndDestroy();//contentName
        }

    if ( cmdName )
        {
        CleanupStack::PopAndDestroy();//cmdName
        }

    if ( providerList.Count() > 0 )
        {
        // convert to js value
        List jsList;
        jsList.append( jsNumber( providerList.Count() ) );
        JSObject * rval = exec->lexicalInterpreter()->builtinArray()->construct(
                                                            exec, jsList );

        for ( TInt i = 0; i < providerList.Count(); i++ )
            {
            List jsPair;
            jsPair.append( jsNumber( 2 ) );
            JSObject * pairVal = exec->lexicalInterpreter()->builtinArray()->construct(
                                                            exec, jsPair );

            HBufC* buf1 = HBufC::NewLC( providerList[i]->ServiceCmdStr().Length() + 1 ); // +1 for zero terminate
            buf1->Des().Copy( providerList[i]->ServiceCmdStr() );
            buf1->Des().ZeroTerminate();
            pairVal->put( exec, Identifier::from(0), jsString( UString( (UChar*) buf1->Des().Ptr(), buf1->Des().Length() ) ) );

            HBufC* buf2 = HBufC::NewLC( providerList[i]->ContentType().Length() + 1 ); // +1 for zero terminate
            buf2->Des().Copy( providerList[i]->ContentType() );
            buf2->Des().ZeroTerminate();
            pairVal->put( exec, Identifier::from(1),
            jsString( UString( (UChar*) buf2->Des().Ptr(), buf2->Des().Length() ) ) );

            rval->put( exec, Identifier::from(i), pairVal );
            CleanupStack::PopAndDestroy(2);//buf1,buf2
            }

        critArray.ResetAndDestroy();
        providerList.ResetAndDestroy();

        return( rval );
        }

    critArray.ResetAndDestroy();
    providerList.ResetAndDestroy();
    return jsUndefined();
    }

// ----------------------------------------------------------------------------
// CDeviceLiwBinding::InvokeOpInternal
// Call/Invoke the SAPI function
//
//
// ----------------------------------------------------------------------------
//
JSValue* CDeviceLiwBinding::InvokeOpInternal(
    ExecState* exec,
    const Identifier& propertyName,
    const List& args,
    MDevicePeer* peer )
    {
    TUint cmdOption = 0;
    JSValue* rval = jsUndefined();
    int argcount = args.size();
    DeviceLiwPeer* callBack = NULL;

    if ( argcount > 1 )
        {
        cmdOption = KLiwOptASyncronous;
        if( args[1]->isObject() )
            {
            callBack = static_cast<DeviceLiwPeer*>( peer );
            }
        }
    if (propertyName == "Cancel")
        {
        cmdOption = KLiwOptCancel;
        }
    // Must have at least an operation name
    if ( propertyName.ustring().size() > 0 )
        {
        // Operation on a service interface object
        if ( peer && static_cast<DeviceLiwPeer*>( peer )->Interface() )
            {
            TRAPD( error,
                {
                CLiwGenericParamList* inps = CLiwGenericParamList::NewL(); // We manage this memory
                CleanupStack::PushL( inps );
                CLiwGenericParamList* outps = CLiwGenericParamList::NewL(); // And this
                CleanupStack::PushL( outps );

                // Collect args from first parameter. Note that args are
                // passed as an associative array.
                if ( argcount >= 1 )
                    {
                    JsList2LiwGenericParamListL( exec, args[0], *inps );
                    }

                // Get the operation name
                HBufC8* oper = KJS::GetAsciiBufferL( propertyName.ustring() );
                CleanupStack::PushL( oper );

                // Call the interface operation

                TTrapHandler* ____t = User::MarkCleanupStack();
                static_cast<DeviceLiwPeer*>( peer )->Interface()->ExecuteCmdL(
                                            *oper, *inps, *outps, cmdOption,
                                            callBack );
                User::UnMarkCleanupStack(____t);
                inps->Reset();
                rval = LiwGenericParamList2JsArray( exec, outps, ETrue );
                outps->Reset();
                CleanupStack::PopAndDestroy( oper ); // map
                CleanupStack::Pop();// outps
                CleanupStack::PopAndDestroy(  );// inps
               });

            if ( error != KErrNone )
                {
                return throwError(exec, GeneralError);
                }
            }
        }

    return rval;
    }


// ----------------------------------------------------------------------------
// CDeviceLiwBinding::InvokeOp
// Call/Invoke the SAPI function
//
//
// ----------------------------------------------------------------------------
//
JSValue* CDeviceLiwBinding::InvokeOp(
    ExecState* exec,
    const Identifier& propertyName,
    const List& args,
    MDevicePeer* peer )
    {
    return InvokeOpInternal( exec, propertyName, args, peer );
    }


// ----------------------------------------------------------------------------
// CDeviceLiwBinding::CreateInterface
// Create SAPI interface
//
//
// ----------------------------------------------------------------------------
//
JSValue* CDeviceLiwBinding::CreateInterface(
    ExecState* exec, HBufC8* serviceName, const Identifier& interfaceName )
    {
    JSValue* rval = jsUndefined();
    TInt error = KErrNone;

    if ( m_serviceHandler && serviceName->Length() > 0 && interfaceName.ustring().size() > 0 )
        {
        // Since this is called from JS context, set up our own trap harness
        TRAP( error,
            {
            CLiwGenericParamList& inps = m_serviceHandler->InParamListL(); // LIW manages this memory
            CleanupStack::PushL( &inps );
            CLiwGenericParamList& outps = m_serviceHandler->OutParamListL(); // LIW manages this memory
            CleanupStack::PushL( &outps );

            HBufC8* ifaceName = KJS::GetAsciiBufferL( interfaceName.ustring() );
            CleanupStack::PushL( ifaceName );

            const HBufC8* hsvc = serviceName;

            // Create LIW params
            CLiwCriteriaItem* item = CLiwCriteriaItem::NewLC( 1, *ifaceName,
                                        TPtrC8( hsvc->Ptr(), hsvc->Size() ) );

            item->SetServiceClass( TUid::Uid( KLiwClassBase ) );

            // Call the service command operation
            m_serviceHandler->ExecuteServiceCmdL(
                *item, inps, outps, NULL );

            // Convert results into JS array
            rval = LiwGenericParamList2JsArray( exec, &outps );
            CleanupStack::PopAndDestroy( 2 ); //item, ifaceName
            CleanupStack::Pop( 2 );//inps, outps
        });

        if ( error != KErrNone)
            {
            return throwError(exec, GeneralError);
            }
        }

    return rval;
    }


//TBD: replace this with a generic object type discovery method

// ----------------------------------------------------------------------------
// CDeviceLiwBinding::IsAList
// Check if javascript list
//
//
// ----------------------------------------------------------------------------
//
TBool CDeviceLiwBinding::IsAList( ExecState* exec, JSValue* aValue )
    {
    if(!aValue->isObject())
        return EFalse;
    PropertyNameArray propertyNames;
    aValue->toObject( exec )->getPropertyNames( exec, propertyNames );
    unsigned size = static_cast<unsigned>(propertyNames.size());

    for (unsigned i = 0; i < size; i++)
    {
        bool rval;
        propertyNames[i].toArrayIndex( &rval );
        if ( rval )
            {
            return ETrue;
            }
    }

    return EFalse;
    }


// ----------------------------------------------------------------------------
// CDeviceLiwBinding::JsVal2LiwVariant
// Convert from javascript value to LiwVariant
//
//
// ----------------------------------------------------------------------------
//
TBool CDeviceLiwBinding::JsVal2LiwVariant(
    ExecState* exec,
    JSValue* aValue,
    TLiwVariant& variant )
    {
    TBool ret = ETrue;
    TInt error = KErrNone;

    switch ( aValue->type() )
        {
        case StringType:
            {
            // Pass as TPtrC and let SAPI do the conversion to 8 bit if needed.
            TRAP( error,
                {
                variant.SetL( TLiwVariant(
                    TPtrC16( ( unsigned short* ) aValue->toString( exec ).data(),
                    aValue->toString( exec ).size() ) ) );
                });
            break;
            }
        case NumberType:
            {
            if (isNaN(aValue->getNumber()) || isInf(aValue->getNumber()))
            {
                ret = EFalse;
                break;
            }
            TInt32 intVal = aValue->toInt32( exec );
            double doubleVal = aValue->toNumber( exec );
            if ( intVal != doubleVal )
            {
                variant.Set( (TReal)doubleVal );
            }
            else
            {
                // this is not fully correct due to the limitation of js number
                variant.Set( intVal );
            }
            break;
            }
        case ObjectType:
            {
            JSObject* anObj = aValue->toObject( exec );

            // Handle date
            if(anObj->className().find(UString("Date"),0) == 0)
                {
                double d = aValue->toNumber( exec );  // get UTC milli seconds
                if( isNaN(d) || isInf(d) )
                {
                    ret = EFalse;
                    break;
                }

                //Get the JS time in integer seconds
                const TInt64 dateVal = d;

                // Set JS epoch offset from Symbian epoch
                TTime sTime(KJsEpoch);
                TTimeIntervalMicroSeconds dateMicroSecs(dateVal*1000);  // convert to UTC micro seconds
                sTime += dateMicroSecs;

                // uncomment following to debug time
                //TBuf<100> date;
                //sTime.FormatL(date,KLocaleDateTime);

                // Set the LIW Variant time
                variant.Set( sTime );

                break;
            }
            // Boolean object
            else if(anObj->className().find(UString("Boolean"),0) == 0)
                {
                TBool val = aValue->toNumber( exec );
                variant.Set( val );
                break;
                }
            // Number object
            else if(anObj->className().find(UString("Number"),0) == 0)
                {
                double d = aValue->toNumber( exec );
                if (isNaN(d) || isInf(d))
                    {
                    ret = EFalse;
                    break;
                    }
                TInt32 intVal = aValue->toInt32( exec );
                if ( intVal != d )
                    {
                    variant.Set( (TReal)d );
                    }
                else
                    {
                    // this is not fully correct due to the limitation of js number
                    variant.Set( intVal );
                    }
                break;
                }
            // String object
            else if(anObj->className().find(UString("String"),0) == 0)
                {
                // Pass as TPtrC and let SAPI do the conversion to 8 bit if needed.
                TRAP( error,
                    {
                    variant.SetL( TLiwVariant(
                        TPtrC16( ( unsigned short* ) aValue->toString( exec ).data(),
                        aValue->toString( exec ).size() ) ) );
                    });
                break;
                }
            PropertyNameArray prop_names;
            aValue->toObject( exec )->getPropertyNames( exec, prop_names );
            unsigned size = static_cast<unsigned>(prop_names.size());

            // handle array
            if ( IsAList( exec, aValue ) )
                {
                CLiwList* liwList = NULL;

                TRAP( error, { liwList = CLiwDefaultList::NewL(); } );
                if ( error != KErrNone )
                    {
                    break;
                    }
                CleanupStack::PushL( liwList );

                for (unsigned i = 0; i < size; i++)
                    {
                    bool rval;
                    prop_names[i].toArrayIndex( &rval );

                    if ( rval )
                        {
                        TLiwVariant vv;
                        JSValue* v = aValue->toObject( exec )->get(exec, prop_names[i]);

                        if ( JsVal2LiwVariant( exec, v, vv ) )
                            {
                            TRAP( error, { liwList->AppendL( vv ); } );  // makes a copy
                            vv.Reset();

                            if ( error != KErrNone )
                                {
                                break; //from while
                                }
                            }
                        }
                    }//end of while

                if ( error == KErrNone )
                    {
                    if( liwList->Count() ) // do not set variant if list is empty
                        {
                        TRAP( error, { variant.SetL( liwList ); } );
                        }
                    }

                CleanupStack::Pop( liwList );
                liwList->DecRef();
                }
            // handle other objects
            else
                { // Map
                TRAP( error,
                    {
                    CLiwMap* liwMap = CLiwDefaultMap::NewL();
                    CleanupClosePushL( *liwMap );

                    for (unsigned i = 0; i < size; i++)
                        {
                        HBufC8* keyName = KJS::GetAsciiBufferL(
                                        prop_names[i].ustring() );
                        CleanupStack::PushL( keyName );

                        TLiwVariant vv;
                        JSValue* v = aValue->toObject( exec )->get(exec, prop_names[i]);

                        if (!keyName || !keyName->Length() )
                            continue;

                        if ( !JsVal2LiwVariant( exec, v, vv )  )
                            {
                            // error converting js value to liw variant, throw debugging error
                            UString err_txt( "Invalid value:[" );
                            err_txt.append( v->toString(exec) );
                            err_txt.append( "] for key:[" );
                            err_txt.append( (const char *)keyName->Des().PtrZ() );
                            err_txt.append( "].\0" );
                            throwError( exec, GeneralError, err_txt );
                            }
                            else if ( !vv.IsEmpty() )
                            {
                            liwMap->InsertL( *keyName, vv );//makes a copy
                            vv.Reset();
                            }

                        CleanupStack::PopAndDestroy( keyName );
                        }

                    if( liwMap->Count() ) //do notset variant if map is empty
                        {
                        variant.SetL( liwMap );
                        }
                    CleanupStack::PopAndDestroy(); // this will call liwMap->close
                    });
                }
            break;
            }
        case BooleanType:
            {
            TBool val = aValue->toNumber( exec );
            variant.Set( val );
            break;
            }
        case NullType:
        case UnspecifiedType:
        case UndefinedType:
        default:
            ret = EFalse;
            break;
        }

    if ( error != KErrNone )
        {
        ret = EFalse;
        }

    return ret;
    }


// ----------------------------------------------------------------------------
// CDeviceLiwBinding::DeviceLiwVariant2JsVal
// Convert from LiwVariant to javascript value of the same type
//
//
// ----------------------------------------------------------------------------
//
JSValue* CDeviceLiwBinding::LiwVariant2JsVal(
    ExecState* exec,
    const TLiwVariant& variant )
    {
    switch ( variant.TypeId() )
        {
        case EVariantTypeTInt32:
            {
            return jsNumber( variant.AsTInt32() );
            }
        case EVariantTypeDesC:
            {
            return jsString( UString(
                (UChar*) variant.AsDes().Ptr(), variant.AsDes().Length() ) );
            }
        case EVariantTypeDesC8:// this is something wrong
            {
            JSValue* rval = jsUndefined();
            TRAPD( error,
                {
                HBufC* buf = HBufC::NewLC( variant.AsData().Length() + 1 ); // +1 for zero terminate
                TPtr bufDes = buf->Des();
                bufDes.Copy( variant.AsData() );
                bufDes.ZeroTerminate();
                rval = jsString( UString( (UChar*) bufDes.Ptr(), bufDes.Length() ) );
                CleanupStack::PopAndDestroy();//buf
                });
                return rval;
            }
        case EVariantTypeList:
            {
            TLiwVariant v;
            List jsList;
            jsList.append( jsNumber( variant.AsList()->Count() ) );
            JSObject * rval = exec->lexicalInterpreter()->builtinArray()->construct(
                exec, jsList );

            for ( TInt i = 0; i < variant.AsList()->Count(); i++ )
                {
                TRAPD( error, { variant.AsList()->AtL( i, v ); } );
                rval->put(
                    exec, Identifier::from(i), LiwVariant2JsVal( exec, v ) );
                }
            v.Reset();
            return rval;
            }
        case EVariantTypeMap:
            {
            TLiwVariant v;
            List jsList;
            jsList.append( jsNumber( variant.AsMap()->Count() ) );
            JSObject * rval = new DeviceLiwMap(exec->lexicalInterpreter()->builtinArray()->construct(
                exec, jsList ), variant.AsMap(), this);
            
            DevicePrivateBase* pMapData = (static_cast<DeviceLiwMap*> (rval))->getMapData();
            
            for ( TInt i = 0; i < variant.AsMap()->Count(); i++ )
                {
                TBuf8<KMaxKeySize> name;
                TRAPD( error,
                    {
                    if ( variant.AsMap()->AtL( i, name ) )
                        {
                        variant.AsMap()->FindL( name, v );
                        JSValue* jsval = LiwVariant2JsVal( exec, v );
                        rval->put( exec,
                                   Identifier( ( const char* ) name.PtrZ() ),
                                   jsval );
                        if ( v.TypeId() == EVariantTypeIterable )
                            {
                            DeviceLiwIterable* itObj = static_cast<DeviceLiwIterable*> (jsval);
                            DevicePrivateBase* itData = itObj->getIterableData();
                            itData->SetParent( pMapData );
                            pMapData->AddChild( itData );
                            }                   
                        else if ( v.TypeId() == EVariantTypeMap )    
                            {
                            DeviceLiwMap* mapObj = static_cast<DeviceLiwMap*> (jsval);
                            DevicePrivateBase* mapData = mapObj->getMapData();
                            mapData->SetParent( pMapData ); 
                            pMapData->AddChild( mapData );
                            }
                        }
                    });
                // No error processing
                }
            v.Reset();
            return rval;
            }
        case EVariantTypeInterface:
            {
            // new DeviceLiwPeer() might fail, in which case the service JSObject * peer will be null
            DeviceLiwPeer* peer = new DeviceLiwPeer(
                                exec->lexicalInterpreter()->globalExec(),
                                this, variant.AsInterface() );
            if ( !peer )
                {
                return jsUndefined();
                }

            JSObject* impl = new DeviceLiwInterface( exec, this, peer );
            return impl;
            }
        case EVariantTypeIterable:
            {
            return new DeviceLiwIterable(exec, this, variant.AsIterable());
            }
        case EVariantTypeTReal:
            {
            TReal realValue;
            variant.Get( realValue );
            return jsNumber( realValue );
            }
        case EVariantTypeTBool:
            {
            TBool boolValue;
            variant.Get( boolValue );
            return jsBoolean( boolValue );
            }
            //Note that unmarshaling to String here is not symetrical with marshaling from Date
            //but JS application can easily construct a Date if it wants one
        case EVariantTypeTTime:
            {
            TTime UTCTime;
            TBuf<KTimeBufSize> buf;
            variant.Get( UTCTime );

            TTime utcNow;
            utcNow.UniversalTime();
            TTime localNow;
            localNow.HomeTime();
            // convert UTC time to local time
            TTimeIntervalMicroSeconds diff = localNow.MicroSecondsFrom(utcNow);
            TTime localTime = UTCTime + diff;
            // format the time to output string
            localTime.FormatL( buf, KLocaleDateTime );
            const UChar *p = (const UChar*)buf.Ptr();
            return jsString( UString( p, buf.Length() ) );
            }
        case EVariantTypeBuffer: // this is something i don't what to do
            {
            return jsUndefined();
                /*
            CLiwBuffer* buf = variant.AsBuffer();
            switch (buf->TypeID())
                {
                case KLiwBufferFile:
                    {
                    RFile file = ((CLiwFileBuffer*)buf)->AsFile();
                    TFileName fileName;
                    file.FullName(fileName);
                    return jsString( UString((UChar*) fileName.Ptr(), fileName.Length() ) );
                    }
                case KLiwBufferBitmap:
                    {
                    return jsUndefined();
                    }
                default:
                    return jsUndefined();
                }*/
            }
        case EVariantTypeTUid:
        case EVariantTypeFileHandle:
        default:
            return jsUndefined();
        }
    }


// ----------------------------------------------------------------------------
// CDeviceLiwBinding::JsList2LiwGenericParamListL
// Convert javascript array (list) to LiwGenericParamList
//
//
// ----------------------------------------------------------------------------
//
void CDeviceLiwBinding::JsList2LiwGenericParamListL(
    ExecState* exec,
    JSValue* aValue,
    CLiwGenericParamList& aLiwList )
    {
    if (!aValue->isObject())
        return;
    PropertyNameArray propertyNames;
    aValue->toObject( exec )->getPropertyNames( exec, propertyNames );
    int size = static_cast<unsigned>(propertyNames.size());

    for (unsigned i = 0; i < size; i++)
        {
        HBufC8* name = KJS::GetAsciiBufferL(propertyNames[i].ustring() );
        if ( !name->Length() )
            break;
        CleanupStack::PushL( name );
        JSValue* v = aValue->toObject( exec )->get( exec, propertyNames[i] );;
        TLiwVariant vv;

        if (  !JsVal2LiwVariant( exec, v, vv ) ) // error occurred
            {
            throwError(exec, GeneralError);
            }
        else if ( !vv.IsEmpty() )
            {
            aLiwList.AppendL( TLiwGenericParam( *name, vv ) );
            vv.Reset();
            }

        CleanupStack::PopAndDestroy(); //name
        }
    }


// ----------------------------------------------------------------------------
// CDeviceLiwBinding::LiwGenericParamList2JsArray
// Convert LiwGenericParamList to javascript array (list)
//
//
// ----------------------------------------------------------------------------
//
JSValue* CDeviceLiwBinding::LiwGenericParamList2JsArray(
    ExecState* exec,
    CLiwGenericParamList* aLiwList, TBool managed )
    {
    // the output param list should not be empty, if it is, return an undefined js obj.
    if ( aLiwList->Count() == 0 )
        return jsUndefined();

    List jsList;

    jsList.append( jsNumber( aLiwList->Count() ) );

    JSObject * rval = new DeviceLiwResult(exec->lexicalInterpreter()->builtinArray()->construct(
                exec, jsList ));

    DevicePrivateBase* retData =(static_cast<DeviceLiwResult*> (rval))->getResultData();

    for ( TInt i = 0; i < aLiwList->Count(); i++ )
        {
        TBuf8<KMaxKeySize> name( (*aLiwList)[i].Name() );
        JSValue* jsval = LiwVariant2JsVal( exec, (*aLiwList)[i].Value() );
        // connect DeviceLiwResult to DeviceLiwIterable  
        if ( managed )
            { 
            if ( (*aLiwList)[i].Value().TypeId() == EVariantTypeIterable )
                {
                DeviceLiwIterable* itObj = static_cast<DeviceLiwIterable*> (jsval);
                DevicePrivateBase* itData = itObj->getIterableData();
                itData->SetParent( retData ); 
                retData->AddChild( itData );
                }
            else if ( (*aLiwList)[i].Value().TypeId() == EVariantTypeMap )
                {
                DeviceLiwMap* mapObj = static_cast<DeviceLiwMap*> (jsval);
                DevicePrivateBase* mapData = mapObj->getMapData();
                mapData->SetParent( retData ); 
                retData->AddChild( mapData );
                }    
            }
        rval->put( exec, Identifier( (const char*) name.PtrZ() ), jsval);  //??? should call AtL?
        }

    return rval;
    }

// ----------------------------------------------------------------------------
// CDeviceLiwBinding::SetUid
// Sets the widget uid
//
//
// ----------------------------------------------------------------------------
//
void CDeviceLiwBinding::SetUid( const TUint& aValue)
    {
    m_Uid.iUid = aValue;
#ifdef SECURITYMANAGER_PROMPT_ENHANCEMENT    
    SetAppName();
#endif    
    }
#ifdef SECURITYMANAGER_PROMPT_ENHANCEMENT
// ----------------------------------------------------------------------------
// CDeviceLiwBinding::SetAppName
// Sets the widget display name
//
// ----------------------------------------------------------------------------
//
void CDeviceLiwBinding::SetAppName()
    {
    RWidgetRegistryClientSession widgetregistry;
    TRAP_IGNORE(
    TInt ret = widgetregistry.Connect();
    if ( ret == KErrNone || ret == KErrAlreadyExists )
        {
        CleanupClosePushL( widgetregistry );
        }
    else
        {
        User::Leave( ret );
        }
    
    CWidgetPropertyValue* displayname = widgetregistry.GetWidgetPropertyValueL(m_Uid, EBundleDisplayName );
    User::LeaveIfError(widgetregistry.Disconnect());
    CleanupStack::PopAndDestroy(); //widgetregistry

    if ( displayname && displayname->iType == EWidgetPropTypeString )
        {
        m_scriptSession->SetApplicationNameL(*displayname);
        }
    );
    }
#endif

// ----------------------------------------------------------------------------
// KJS::GetAsciiBufferL
// Convert the Unicode string to plain ASCII chars chopping of any higher bytes
//
//
// ----------------------------------------------------------------------------
//
HBufC8* KJS::GetAsciiBufferL( const UString& aBuf )
    {
    int length = aBuf.size();
    HBufC8* buf = HBufC8::NewL( length + 1 ); // +1 for zero terminate
    TPtr8 bufDes8 = buf->Des();
    const UChar* p = aBuf.data();
    const UChar *limit = p + length;

    while ( p != limit )
        {
        TChar c = p->uc;
        bufDes8.Append( c );
        ++p;
        }

    bufDes8.ZeroTerminate();
    return buf;
    }

//END OF FILE
