/*

* 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 );

            }

        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 );

                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 )

    {