/*

* Copyright (c) 2006-2007 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 OMA DM adapter, allows to configure SW Installer

*

*/

#include <smldmadapter.h>

#include <data_caging_path_literals.hrh>

#include <centralrepository.h>

#include <SWInstallerInternalCRKeys.h>

#include "cswinstadapter.h"

_LIT8( KIntType, "int" ); // Leaf inputs

_LIT8( KTextType, "text/plain" ); // Leaf inputs

_LIT8( KSWInstDMAdapterVersion, "1.0" ); // Adapter version

_LIT8( KSWInstRootNode, "SWInstaller" ); // root URI

_LIT8( KSWInstRootURI, "SWInstaller" );

_LIT8( KAllowUnsignedNode, "AllowUnsigned" ); // URI postfix

_LIT8( KAllowUnsignedURI, "SWInstaller/AllowUnsigned" );

_LIT8( KAllowUnsignedDescription, "This node tells whether unsigned \

    applications are allowed to be installed" ); // Description

static const TUint32 KSizeOfSettingId = 0x8; // Contanst size declaration

// ============================= LOCAL FUNCTIONS  =============================

#ifdef _DEBUG

#define DEBUG( x ) x

#else

#define DEBUG( x )

#endif

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

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

// CSWInstAdapter::NewL

// Symbian 1st phase contructor

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

//

CSWInstAdapter* CSWInstAdapter::NewL( MSmlDmCallback* aCallback )

    {

    CSWInstAdapter* self = NewLC( aCallback );

    CleanupStack::Pop( self );

    return self;

    }

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

// CSWInstAdapter::NewLC

// Symbian 1st phase contructor. Push object to cleanup-stack

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

//

CSWInstAdapter* CSWInstAdapter::NewLC( MSmlDmCallback* aCallback )

    {

    CSWInstAdapter* self = new ( ELeave ) CSWInstAdapter( aCallback );

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

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

// CSWInstAdapter::CSWInstAdapter()

// C++ Constructor

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

CSWInstAdapter::CSWInstAdapter( TAny* aEcomArguments )

    : CSmlDmAdapter::CSmlDmAdapter( aEcomArguments )

    {

    DEBUG( RDebug::Print( _L( "CSWInstAdapter Constructor" ) ) );

    }

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

// CSWInstAdapter::ConstructL

// 2nd phase contructor

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

//

void CSWInstAdapter::ConstructL()

    {

    DEBUG( RDebug::Print( _L( "CSWInstAdapter::ConstructL" ) ) );

    iSettingsCenRep = CRepository::NewL( KCRUidSWInstallerSettings );

    iLocalVarCenRep = CRepository::NewL( KCRUidSWInstallerLV );

    }

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

// CSWInstAdapter::~CSWInstAdapter()

// C++ Destructor

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

//

CSWInstAdapter::~CSWInstAdapter()

    {

    DEBUG( RDebug::Print( _L( "CSWInstAdapter Destructor" ) ) );

    delete iSettingsCenRep;

    delete iLocalVarCenRep;

    }

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

// CSWInstAdapter::DDFVersionL

// Return DM plug-in version

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

//

void CSWInstAdapter::DDFVersionL( CBufBase& aDDFVersion )

    {

    // Insert version information

    DEBUG( RDebug::Print( _L( "CSWInstAdapter::DDFVersionL" ) ) );

    aDDFVersion.InsertL( 0, KSWInstDMAdapterVersion );

    }

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

// CSWInstAdapter::DDFStructureL

// Return DM plug-in structure

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

//

void CSWInstAdapter::DDFStructureL( MSmlDmDDFObject& aDDF )

    {

    // Declare accesses

    DEBUG( RDebug::Print( _L( "CSWInstAdapter::DDFStructureL" ) ) );

    TSmlDmAccessTypes accessTypes;

    accessTypes.SetGet();

    // Create root node 

    MSmlDmDDFObject& root = aDDF.AddChildObjectL( KSWInstRootNode );

    FillNodeInfoL( root,

                   accessTypes,

                   MSmlDmDDFObject::EPermanent,

                   MSmlDmDDFObject::ENode,

                   MSmlDmDDFObject::EOne,

                   KNullDesC8(),

                   KTextType );

    accessTypes.SetReplace();

    MSmlDmDDFObject& allowUnsignedNode = root.AddChildObjectL( KAllowUnsignedNode );

    FillNodeInfoL( allowUnsignedNode,

                   accessTypes,

                   MSmlDmDDFObject::EPermanent,

                   MSmlDmDDFObject::EChr,

                   MSmlDmDDFObject::EOne,

                   KAllowUnsignedDescription,

                   KTextType );

    DEBUG( RDebug::Print( _L( "CSWInstAdapter::DDFStructureL done" ) ) );

    }

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

// CSWInstAdapter::StreamingSupport

// Return streaming support status, set supported item size

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

//

TBool CSWInstAdapter::StreamingSupport( TInt& /* aItemSize */ )

    {

    // Not supported

    DEBUG( RDebug::Print( _L( "CSWInstAdapter::StreamingSupport" ) ) );

    return EFalse;

    }

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

// CSWInstAdapter::StreamCommittedL

// Commit stream buffer

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

//

void CSWInstAdapter::StreamCommittedL()

    {        

    DEBUG( RDebug::Print( _L( "CSWInstAdapter::StreamCommitted" ) ) );

    // Intentionally left empty 

    }

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

// CSWInstAdapter::CompleteOutstandingCmdsL

// Complete outstanding commands

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

//

void CSWInstAdapter::CompleteOutstandingCmdsL()

    {

    DEBUG( RDebug::Print( _L( "CSWInstAdapter::CompleteOutstandingCmdsL" ) ) );

    }

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

// CSWInstAdapter::FillNodeInfoL

// Fill node info

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

//

void CSWInstAdapter::FillNodeInfoL( MSmlDmDDFObject& aDDFObject, 

                                    TSmlDmAccessTypes& aAccessTypes, 

                                    MSmlDmDDFObject::TScope aScope,

                                    MSmlDmDDFObject::TDFFormat aFormat, 

                                    MSmlDmDDFObject::TOccurence aOccurence,

                                    const TDesC8& aDescription,

                                    const TDesC8& aMIMEType )

    {

    DEBUG( RDebug::Print( _L( "CSWInstAdapter::FillNodeInfoL" ) ) );

    aDDFObject.SetAccessTypesL( aAccessTypes );

    aDDFObject.SetScopeL( aScope );

    aDDFObject.SetOccurenceL( aOccurence );

    aDDFObject.SetDFFormatL( aFormat );

    aDDFObject.SetDescriptionL( aDescription );

    if ( aFormat != MSmlDmDDFObject::ENode )

        {

        aDDFObject.AddDFTypeMimeTypeL( aMIMEType );

        }

    DEBUG( RDebug::Print( _L( "CSWInstAdapter::FillNodeInfoL done" ) ) );

    }

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

// CSWInstAdapter::CopyCommandL

// Copy object

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

//

void CSWInstAdapter::CopyCommandL( const TDesC8& /*aTargetURI*/, 

                               const TDesC8& /*aTargetLUID*/,

                               const TDesC8& /*aSourceURI*/, 

                               const TDesC8& /*aSourceLUID*/,

                               const TDesC8& /*aType*/, 

                               TInt aStatusRef )

    {

    // Not supported

    DEBUG( RDebug::Print( _L( "CSWInstAdapter::CopyCommandL" ) ) );

    Callback().SetStatusL( aStatusRef, CSmlDmAdapter::EError );

    }

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

// DeleteObjectL

// Delete object

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

//

void CSWInstAdapter::DeleteObjectL( const TDesC8& /* aURI */, 

                                    const TDesC8& /* aLUID */,

                                    TInt aStatusRef )

    {

    // Not supported

    DEBUG( RDebug::Print( _L( "CSWInstAdapter::DeleteObjectL" ) ) );

    Callback().SetStatusL( aStatusRef, CSmlDmAdapter::EError );

    }

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

// CSWInstAdapter::FetchLeafObjectL

// Fetch leaf

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

//

void CSWInstAdapter::FetchLeafObjectL( const TDesC8& aURI, 

                                   const TDesC8& /* aLUID */,

                                   const TDesC8& aType, 

                                   TInt aResultsRef,

                                   TInt aStatusRef )

    {

    DEBUG( RDebug::Print( _L( "CSWInstAdapter::FetchLeafObjectL" ) ) );

    MSmlDmAdapter::TError retValue = CSmlDmAdapter::EOk;

    if ( aURI.Compare( KAllowUnsignedURI ) == 0 )

        {

        TInt cenRepValue;

        TInt ret = iLocalVarCenRep->Get( KSWInstallerHideUntrustedIns, cenRepValue );

        DEBUG( RDebug::Print( _L("CSWInstAdapter: CenRep ret = %d, val = %d" ), ret, !cenRepValue ) );

        if ( ret == KErrNone )

            {

            TBuf8<KSizeOfSettingId> buf;

            buf.AppendNum( !cenRepValue );

            CBufBase* bufBase = CBufFlat::NewL( 1 );

            CleanupStack::PushL( bufBase );

            bufBase->InsertL( 0, buf );

            Callback().SetResultsL( aResultsRef, *bufBase, aType );

            CleanupStack::PopAndDestroy( bufBase );

            }

        else

            {

            retValue = CSmlDmAdapter::EError;          

            }

        }

    else

        {

        retValue = CSmlDmAdapter::EError;

        }

    // Respond

    Callback().SetStatusL( aStatusRef, retValue );

    DEBUG( RDebug::Print( _L( "CSWInstAdapter::FetchLeafObjectL done" ) ) );

    }    

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

// CSWInstAdapter::FetchLeafObjectSizeL

// Calculate leaf object size

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

//

void CSWInstAdapter::FetchLeafObjectSizeL( const TDesC8& aURI, 

                                           const TDesC8& /* aLUID */,

                                           const TDesC8& /* aType */, 

                                           TInt aResultsRef,

                                           TInt aStatusRef )

    {

    DEBUG( RDebug::Print( _L( "CSWInstAdapter::FetchLeafObjectSizeL" ) ) );

    MSmlDmAdapter::TError retValue = CSmlDmAdapter::EOk;

    if ( aURI.Compare( KAllowUnsignedURI ) == 0 )

        {

        TBuf8<KSizeOfSettingId> buf;

        CBufBase* bufBase = CBufFlat::NewL( KSizeOfSettingId );

        CleanupStack::PushL( bufBase );

        buf.AppendNum( sizeof(TInt) );

        bufBase->InsertL( 0, buf );

        Callback().SetResultsL( aResultsRef, *bufBase, KIntType );

        CleanupStack::PopAndDestroy( bufBase );

        }

    else

        {

        retValue = CSmlDmAdapter::ENotFound;

        }

    // Respond

    Callback().SetStatusL( aStatusRef, retValue );

    DEBUG( RDebug::Print( _L( "CSWInstAdapter::FetchLeafObjectSizeL done" ) ) );

    }    

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

// CSWInstAdapter::ChildURIListL

// Create child URI list

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

//

void CSWInstAdapter::ChildURIListL( const TDesC8& aURI, 

                                const TDesC8& /* aLUID */,

                                const CArrayFix<TSmlDmMappingInfo>& /* aPreviousURISegmentList */,

                                TInt aResultsRef, 

                                TInt aStatusRef )

    {

    DEBUG( RDebug::Print( _L( "CSWInstAdapter::ChildURIListL" ) ) );

    MSmlDmAdapter::TError retValue = CSmlDmAdapter::EOk;

    if ( aURI.Compare( KSWInstRootURI ) == 0)

        {

        CBufBase* buf = CBufFlat::NewL( 1 );

        CleanupStack::PushL( buf );

        buf->InsertL( 0, KAllowUnsignedNode );

        Callback().SetResultsL( aResultsRef, *buf, KNullDesC8 );

        CleanupStack::PopAndDestroy( buf );

        }

    else

        {

        retValue = CSmlDmAdapter::ENotFound;

        }

    // Respond

    Callback().SetStatusL( aStatusRef, retValue );

    DEBUG( RDebug::Print( _L( "CSWInstAdapter::ChildURIListL done" ) ) );

    }    

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

// CSWInstAdapter::AddNodeObjectL

// Add node

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

//

void CSWInstAdapter::AddNodeObjectL( const TDesC8& /* aURI */,

                                     const TDesC8& /* aParentLUID */,

                                     TInt aStatusRef )

    {

    // Not supported

    DEBUG( RDebug::Print( _L( "CSWInstAdapter::AddNodeObjectL" ) ) );

    Callback().SetStatusL( aStatusRef, CSmlDmAdapter::EError );

    }    

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

// CSWInstAdapter::ExecuteCommandL

// Execute command

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

//

void CSWInstAdapter::ExecuteCommandL( const TDesC8& /* aURI */, 

                                      const TDesC8& /* aLUID */,

                                      const TDesC8& /* aArgument */, 

                                      const TDesC8& /* aType */,

                                      TInt aStatusRef )

    {

    // Not supported

    DEBUG( RDebug::Print( _L( "CSWInstAdapter::ExecuteCommandL" ) ) );

    Callback().SetStatusL( aStatusRef, CSmlDmAdapter::EError );

    }    

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

// CSWInstAdapter::ExecuteCommandL

// Execute command, streaming enabled

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

//

void CSWInstAdapter::ExecuteCommandL( const TDesC8& /* aURI */, 

                                      const TDesC8& /* aLUID */,

                                      RWriteStream*& /* aStream */,

                                      const TDesC8& /* aType */,

                                      TInt aStatusRef )

    {

    // Not supported

    DEBUG( RDebug::Print( _L( "CSWInstAdapter::ExecuteCommandL (streaming)" ) ) );

    Callback().SetStatusL( aStatusRef, CSmlDmAdapter::EError );

    }    

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

// CSWInstAdapter::UpdateLeafObjectL

// Update leaf object

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

//

void CSWInstAdapter::UpdateLeafObjectL( const TDesC8& aURI, 

                                        const TDesC8& /* aLUID */,

                                        const TDesC8& aObject,

                                        const TDesC8& /* aType */,

                                        TInt aStatusRef )

    {

    DEBUG( RDebug::Print( _L( "CSWInstAdapter::UpdateLeafObjectL" ) ) );

    MSmlDmAdapter::TError retValue = CSmlDmAdapter::EOk;

    if ( aURI.Compare( KAllowUnsignedURI ) == 0 )

        {

        TLex8 lex( aObject );

        TInt value;

        TInt ret;

        if ( lex.Val( value ) != KErrNone )

            {

            DEBUG( RDebug::Print( _L( "CSWInstAdapter: lex.Val failed" ) ) );

            retValue = CSmlDmAdapter::EInvalidObject;

            }

        else

            {

            TInt allow = !!value; // make sure it's 0 or 1

            TInt hide  = !value;

            ret = iSettingsCenRep->Set( KSWInstallerAllowUntrusted, allow );

            DEBUG( RDebug::Print( _L( "CSWInstAdapter: KSWInstallerAllowUntrusted set to %d, ret %d" ), allow, ret ) );

            ret |= iLocalVarCenRep->Set( KSWInstallerHideUntrustedIns, hide );

            DEBUG( RDebug::Print( _L( "CSWInstAdapter: KSWInstallerHideUntrustedIns set to %d, ret %d" ), hide, ret ) );

            if ( ret != KErrNone )

                {

                retValue = CSmlDmAdapter::EError;

                }

            }

        }

    else

        {

        retValue = CSmlDmAdapter::ENotFound;

        }

    // Respond

    Callback().SetStatusL( aStatusRef, retValue );

    DEBUG( RDebug::Print( _L( "CSWInstAdapter::UpdateLeafObjectL done" ) ) );

    }

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

// CSWInstAdapter::UpdateLeafObjectL

// Update leaf object, streaming enabled

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

//

void CSWInstAdapter::UpdateLeafObjectL( const TDesC8& /* aURI */, 

                                    const TDesC8& /* aLUID */,

                                    RWriteStream*& /* aStream */, 

                                    const TDesC8& /* aType */,

                                    TInt aStatusRef

                                  )

    {

    // Not supported

    DEBUG( RDebug::Print( _L( "CSWInstAdapter::UpdateLeafObjectL (streaming)" ) ) );

    Callback().SetStatusL( aStatusRef, CSmlDmAdapter::EError );

    }

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

// CSWInstAdapter::StartAtomicL

// Start atomic

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

//

void CSWInstAdapter::StartAtomicL()

    {

    }

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

// CSWInstAdapter::CommitAtomicL

// Commit atomic commands

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

//

void CSWInstAdapter::CommitAtomicL()

    {

    }

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

// CSWInstAdapter::RollbackAtomicL

// Lose all modifications after 'StartAtomicL' command

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

//

void CSWInstAdapter::RollbackAtomicL()

    {

    }    

// End of File