/*

* Copyright (c) 2002-2004 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:  $Description: $

*

*/

// INCLUDE FILES

#include "TARMDmStreamAdapter.h"

#include "debug.h"

#include <featmgr.h>

_LIT( KTempFilePath, "C:\\system\\temp\\" );

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

///////////////////////////////////////////////////////////////////////////////////////////////////

//

// CTARMDmStreamAdapter

//

///////////////////////////////////////////////////////////////////////////////////////////////////

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

// CTARMDmStreamAdapter::CTARMDmStreamAdapter

// 

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

//

CTARMDmStreamAdapter::CTARMDmStreamAdapter( MSmlDmCallback* aCallback )

	: CTARMDmAdapter( aCallback )

	, iActionInfo( 0 )

	{

	RDEBUG( "CTARMDmStreamAdapter::CTARMDmStreamAdapter" );

	if(!iFs.Connect())

		{

			RDEBUG( "CTARMDmStreamAdapter::CTARMDmStreamAdapter unable to connect to the fileserver" );

		}

	}

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

// CTARMDmStreamAdapter::~CTARMDmStreamAdapter

// 

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

//

CTARMDmStreamAdapter::~CTARMDmStreamAdapter()

	{

	RDEBUG( "CTARMDmStreamAdapter::~CTARMDmStreamAdapter >" );

	ClearActionInfo();

    iFs.Close();

	RDEBUG( "CTARMDmStreamAdapter::~CTARMDmStreamAdapter <" );

	}

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

// CTARMDmStreamAdapter::

// 

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

//

void CTARMDmStreamAdapter::UpdateLeafObjectL( const TDesC8& aURI, const TDesC8& aLUID, RWriteStream*& aStream, const TDesC8& aType, TInt aStatusRef )

	{

	RDEBUG( "CTARMDmStreamAdapter::UpdateLeafObjectL >" );

//#ifdef __SAP_POLICY_MANAGEMENT

TRAPD( errf, FeatureManager::InitializeLibL() );

	if( errf != KErrNone )

	{

		User::Leave(errf);

	}

if(FeatureManager::FeatureSupported(KFeatureIdSapPolicyManagement ))

{

	if (CheckPolicyL( aURI ) != KErrNone)

		{

		Callback().SetStatusL( aStatusRef, EError );

		return;

		}

}

FeatureManager::UnInitializeLib();

//#endif

	SetActionInfoL(CTARMDmStreamAdapterBuffer::ETARMActionUpdate,

	               aURI,

	               aLUID,

	               aType,

	               aStatusRef,

	               -1); // No result ref

    TInt itemSize;

    TAdapterStreamType streamType = EStreamToNone;

	if( StreamingSupport( itemSize ) )

	    {

	    streamType = StreamType( aURI );

	    }

    if( EStreamToNone != streamType )

        {

        if( EStreamToFile == streamType )

            {

            StreamToFileL( aStream );

            }

        else

        if( EStreamToBuffer == streamType )

            {

            StreamToBufferL( aStream );

            }

        Callback().SetStatusL( aStatusRef, EOk );  

        }

    else

        {

    	_UpdateLeafObjectL( aURI, aLUID, aStream, aType, aStatusRef );

        }

	RDEBUG( "CTARMDmStreamAdapter::UpdateLeafObjectL <" );

	}

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

// CTARMDmStreamAdapter::

// 

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

//

void CTARMDmStreamAdapter::ExecuteCommandL( const TDesC8& aURI, const TDesC8& aLUID, RWriteStream*& aStream, const TDesC8& aType, TInt aStatusRef )

	{

	RDEBUG( "CTARMDmStreamAdapter::ExecuteCommandL (stream) >" );

//#ifdef __SAP_POLICY_MANAGEMENT

TRAPD( errf, FeatureManager::InitializeLibL() );

	if( errf != KErrNone )

	{

		User::Leave(errf);

	}

if(FeatureManager::FeatureSupported(KFeatureIdSapPolicyManagement ))

{

	if (CheckPolicyL( aURI ) != KErrNone)

		{

		Callback().SetStatusL( aStatusRef, EError );

		return;

		}

}

FeatureManager::UnInitializeLib();

//#endif		

	SetActionInfoL(CTARMDmStreamAdapterBuffer::ETARMActionExecute,

	               aURI,

	               aLUID,

	               aType,

	               aStatusRef,

	               -1); // no result ref

    TInt itemSize;

    TAdapterStreamType streamType = CTARMDmStreamAdapter::EStreamToNone;

	if( StreamingSupport( itemSize ) )

	    {

	    streamType = StreamType( aURI );

	    }

    if( CTARMDmStreamAdapter::EStreamToNone != streamType )

        {

        if( CTARMDmStreamAdapter::EStreamToFile == streamType )

            {

            StreamToFileL( aStream );

            }

        else

        if( CTARMDmStreamAdapter::EStreamToBuffer == streamType )

            {

            StreamToBufferL( aStream );

            }

        Callback().SetStatusL( aStatusRef, EOk ); 

        }

    else

        {

        _ExecuteCommandL( aURI, aLUID, aStream, aType, aStatusRef );

        }

	RDEBUG( "CTARMDmStreamAdapter::ExecuteCommandL (stream) <" );

	}

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

// CTARMDmStreamAdapter::StreamType

// 

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

//

CTARMDmStreamAdapter::TAdapterStreamType CTARMDmStreamAdapter::StreamType( const TDesC8& /*aURI*/ )

    {

	RDEBUG( "CTARMDmStreamAdapter::StreamType ><" );

    return CTARMDmStreamAdapter::EStreamToNone;

    }

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

// CTARMDmStreamAdapter::StreamToBufferL

// 

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

//

void CTARMDmStreamAdapter::StreamToBufferL( RWriteStream*& aStream )

    {

	RDEBUG( "CTARMDmStreamAdapter::StreamToBufferL >" );

    User::LeaveIfError( iWriteStream.Temp(

                    iFs,

                    KTempFilePath(),

                    iFileStoreFileName,

                    EFileWrite

                    ));

    aStream = &iWriteStream;

    // StreamCommittedL is called when stream is complete

    iStreamType = CTARMDmStreamAdapter::EStreamToBuffer;

	RDEBUG( "CTARMDmStreamAdapter::StreamToBufferL <" );

    }

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

// CTARMDmStreamAdapter::StreamToFileL

// 

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

//

void CTARMDmStreamAdapter::StreamToFileL( RWriteStream*& aStream )

    {

	RDEBUG( "CTARMDmStreamAdapter::StreamToFileL >" );

    User::LeaveIfError( iWriteStream.Temp(

                    iFs,

                    KTempFilePath(),

                    iFileStoreFileName,

                    EFileWrite

                    ));

    aStream = &iWriteStream;

    // StreamCommittedL is called when stream is complete

    iStreamType = CTARMDmStreamAdapter::EStreamToFile;

	RDEBUG( "CTARMDmStreamAdapter::StreamToFileL <" );

    }

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

// CTARMDmStreamAdapter::StreamCommittedL

// 

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

//

#ifdef __TARM_SYMBIAN_CONVERGENCY	

void CTARMDmStreamAdapter::StreamCommittedL( RWriteStream& /*aStream*/ )

#else

void CTARMDmStreamAdapter::StreamCommittedL()

#endif	

    {

	RDEBUG( "CTARMDmStreamAdapter::StreamCommittedL >" );

    TInt itemSize = 0;

    if( StreamingSupport( itemSize ) )

        {

        TAdapterStreamType type = iStreamType;

        iStreamType = CTARMDmStreamAdapter::EStreamToNone;

        if(CTARMDmStreamAdapter::EStreamToNone == type )

            {

            ClearActionInfo();

            User::Leave( KErrGeneral );

            }

        iWriteStream.Close();

        if(CTARMDmStreamAdapter::EStreamToBuffer == type )

            {           

            // Load file to memory

            RFile f;

            User::LeaveIfError( f.Open( iFs, iFileStoreFileName, EFileRead ) );

            CleanupClosePushL( f );

            TInt size;

            User::LeaveIfError( f.Size( size ) );

            HBufC8* buf = HBufC8::NewLC( size );

            TPtr8 ptr8( buf->Des() );

            User::LeaveIfError( f.Read( ptr8 ) );

            // Pass data as argument

            CommitActionL( ptr8 );

            CleanupStack::PopAndDestroy( buf );

            CleanupStack::PopAndDestroy( &f );

            }

         else

            {

            // Streamed to file, no data in arguments

            CommitActionL( KNullDesC8() );

            }

        iFs.Delete( iFileStoreFileName );

        }

    ClearActionInfo();

	RDEBUG( "CTARMDmStreamAdapter::StreamCommittedL <" );

    }

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

// CTARMDmStreamAdapter::SetActionInfoL

// 

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

//

void CTARMDmStreamAdapter::SetActionInfoL( CTARMDmStreamAdapterBuffer::TTARMDMAction aAction,

                                     const TDesC8& aURI,

                                     const TDesC8& aLUID,

                                     const TDesC8& aType,

                                     TInt aStatusRef,

                                     TInt aResultRef )

    {

	RDEBUG( "CTARMDmStreamAdapter::SetActionInfoL >" );

    ClearActionInfo();

    iActionInfo = CTARMDmStreamAdapterBuffer::NewL(

                        aURI,

                        aLUID,

                        aType,

                        aStatusRef,

                        aResultRef,

                        aAction

                        );

	RDEBUG( "CTARMDmStreamAdapter::SetActionInfoL <" );

    }

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

// CTARMDmStreamAdapter::ClearActionInfo

// 

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

//

void CTARMDmStreamAdapter::ClearActionInfo()

    {

	RDEBUG( "CTARMDmStreamAdapter::ClearActionInfo >" );

    delete iActionInfo;

    iActionInfo = 0;

	RDEBUG( "CTARMDmStreamAdapter::ClearActionInfo <" );

    }

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

// CTARMDmStreamAdapter::ActionInfoL

// 

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

//

CTARMDmStreamAdapter::CTARMDmStreamAdapterBuffer& CTARMDmStreamAdapter::ActionInfoL()

    {

	RDEBUG( "CTARMDmStreamAdapter::ActionInfoL >" );

    if( 0 == iActionInfo )

        {

        User::Leave( KErrNotFound );

        }

	RDEBUG( "CTARMDmStreamAdapter::ActionInfoL <" );

    return *iActionInfo;

    }

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

// CTARMDmStreamAdapter::CommitActionL

// 

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

//

void CTARMDmStreamAdapter::CommitActionL( const TDesC8 &aObject )

    {

	RDEBUG( "CTARMDmStreamAdapter::CommitActionL >" );

    CTARMDmStreamAdapterBuffer& action = ActionInfoL();

    switch( action.Action() )

        {

        case CTARMDmStreamAdapterBuffer::ETARMActionUpdate:

    	_UpdateLeafObjectL(

    	            action.URI(),

    	            action.LUID(),

    	            aObject,

    	            action.Type(),

    	            action.StatusRef()

    	            );

        break;

        case CTARMDmStreamAdapterBuffer::ETARMActionExecute:

        _ExecuteCommandL(

    	            action.URI(),

    	            action.LUID(),

    	            aObject,

    	            action.Type(),

    	            action.StatusRef() 

                    );

        break;

        default:

        User::Leave( KErrNotSupported );

        break;

        }

	RDEBUG( "CTARMDmStreamAdapter::CommitActionL <" );

    }

// End of File