/*

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

*

*/

#include <hal.h>

#include <f32file.h>

#include <xdmlogwriter.h>

#include <implementationproxy.h>

#include "XdmXmlParser.h"

#include "LocalProtocol.h"

#include "LocalDocument.h"

#include "LocalDocumentNode.h"

#include "LocalDirectory.h"

#include "XdmCredentials.h"

#include "XdmProtocolInfo.h"

#include "XdmOperationFactory.h"

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

// CLocalProtocol::CLocalProtocol

// 

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

//

CLocalProtocol::CLocalProtocol( const CXdmEngine& aXdmEngine,

                                const CXdmProtocolInfo& aProtocolInfo ) :

                                iTransferMediaOpen( EFalse ),

                                iXdmEngine( CONST_CAST( CXdmEngine&, aXdmEngine ) ),

                                iProtocolInfo( aProtocolInfo )

    {   

    }

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

// CLocalProtocol::DeleteLogFileL

// 

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

//

CLocalProtocol* CLocalProtocol::NewL( const TXdmProtocolParams& aProtocolParams )

    {

    CLocalProtocol* self = new ( ELeave ) CLocalProtocol( aProtocolParams.iXdmEngine,

                                                          aProtocolParams.iProtocolInfo );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop();

    return self;

    }

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

// CLocalProtocol::DeleteLogFileL

// 

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

//

CLocalProtocol::~CLocalProtocol()

    {

    #ifdef _DEBUG

        WriteToLog( _L8( "CLocalProtocol::~CLocalProtocol()" ) );  

    #endif

    delete iRootFolder;

    delete iXmlParser;

    delete iLogWriter;

    iFileSession.Close();

    Dll::FreeTls();

    }

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

// CLocalProtocol::ConstructL

// 

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

//

void CLocalProtocol::ConstructL()

    {

    #ifdef _DEBUG

        iLogWriter = CXdmLogWriter::NewL( KLocalEngLogFile );

        WriteToLog( _L8( "CLocalProtocol::ConstructL() " ) );  

    #endif

    iXmlParser = CXdmXmlParser::NewL();

    SetRootDirectoryL( iProtocolInfo.Root() ); 

    User::LeaveIfError( iFileSession.Connect() );

    Dll::SetTls( this );                                                                               

    }

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

// CLocalProtocol::SetRootDirectoryL

// 

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

//

void CLocalProtocol::SetRootDirectoryL( const TDesC& aRootPath )

    {

    TUid id = RProcess().Identity();

    TBuf<32> processId;

    processId.Zero();

    processId.Format( _L( "%x" ), id );

    #ifdef _DEBUG

        WriteToLog( _L8( "CLocalProtocol::SetRootDirectoryL()" ) );  

    #endif

    if( aRootPath.Length() > 0 )

        {

        iRootFolder = HBufC::NewL( aRootPath.Length() +

                                   processId.Length() + 

                                   TPtrC( KLocalEngPrivateRoot ).Length() + 4 );

        iRootFolder->Des().Copy( KLocalEngPrivateRoot );

        iRootFolder->Des().Append( processId );

        iRootFolder->Des().Append( _L( "\\" ) );

        iRootFolder->Des().Append( aRootPath );

        iRootFolder->Des().Append( _L( "\\" ) );

        }

    else

        {

        iRootFolder = HBufC::NewL( processId.Length() + 

                                   KLocalEngPrivateRoot().Length() + 2 );

        iRootFolder->Des().Copy( KLocalEngPrivateRoot );

        iRootFolder->Des().Append( processId );

        iRootFolder->Des().Append( _L( "\\" ) );

        }

    #ifdef _DEBUG

        TBuf8<256> eight;

        eight.Copy( iRootFolder->Des() );

        WriteToLog( _L8( "  Path: %S" ), &eight );  

    #endif

    }

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

// CLocalProtocol::.WriteToLog

// 

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

//

void CLocalProtocol::WriteToLog( TRefByValue<const TDesC8> aFmt,... ) const                                

    {

    VA_LIST list;

    VA_START( list, aFmt );

    TBuf8<KLogBufferMaxSize> buf;

    buf.FormatList( aFmt, list );

    iLogWriter->WriteToLog( buf );

    }

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

// CLocalProtocol::InitTransferMedia

// 

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

//

void CLocalProtocol::InitTransferMedium( TInt /*aIdleTimeout*/,

                                        TRequestStatus& aStatus )

    {

    TRequestStatus* status = &aStatus;

    User::RequestComplete( status, KErrNone );

    }

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

// CLocalProtocol::CancelTransferMediaInit

// 

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

//

void CLocalProtocol::CancelTransferMediumInit()

    {

    }

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

// CLocalProtocol::IsTransferAvailable

// 

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

//

TBool CLocalProtocol::IsTransferAvailable() const

    {

    return ETrue;

    }

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

// CLocalProtocol::RFSession

// 

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

//

RFs& CLocalProtocol::RFSession()

    {

    return iFileSession;

    }

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

// CLocalProtocol::Root

// 

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

//

TPtrC CLocalProtocol::Root()

    {

    return iRootFolder != NULL ? iRootFolder->Des() : TPtrC();

    }

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

// void CXcapProtocol::DeleteLogFileL

// 

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

//

EXPORT_C RFs& CLocalProtocol::FileSession()

    {

    TAny* ptr = Dll::Tls();

    CLocalProtocol* self = ( CLocalProtocol* )ptr;

    return self->RFSession();  

    }

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

// CLocalProtocol::RootFolder

// 

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

//

EXPORT_C TPtrC CLocalProtocol::RootFolder()

    {

    TAny* ptr = Dll::Tls();

    CLocalProtocol* self = ( CLocalProtocol* )ptr;

    return self->Root();

    }

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

// CLocalProtocol::CreateDocumentNodeL

// 

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

//

CXdmDocumentNode* CLocalProtocol::CreateDocumentNodeL()

    {

    return CLocalDocumentNode::NewL( iXdmEngine, *this );

    }

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

// CLocalProtocol::CreateDocumentL

// 

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

//

CXdmDocument* CLocalProtocol::CreateDocumentL( const TDesC& aDocumentName,

                                               const TXdmDocType /*aDocumentType*/ )

    {

    return CLocalDocument::NewL( iXdmEngine, aDocumentName, *this );

    }

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

// CLocalProtocol::CreateDirectoryL

//

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

//

CXdmDirectory* CLocalProtocol::CreateDirectoryL( const TDesC& aDirectoryPath )

    {

    TPtrC root = iRootFolder->Des();

    HBufC* fullName = HBufC::NewLC( root.Length() + aDirectoryPath.Length() );

    fullName->Des().Copy( root );

    fullName->Des().Append( aDirectoryPath );

    CXdmDirectory* dir = CLocalDirectory::NewL( fullName->Des(), iXdmEngine, *this );

    CleanupStack::PopAndDestroy();  //fullName

    return dir;

    }

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

// Map the interface UIDs to implementation factory functions

// 

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

//

const TImplementationProxy ImplementationTable[] = 

    {

    #ifdef __EABI__

        IMPLEMENTATION_PROXY_ENTRY( 0x10207424, CLocalProtocol::NewL )

    #else

        { { 0x10207424 }, CLocalProtocol::NewL }

    #endif

    };

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

// Return the implementation table & number of implementations

// 

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

//

EXPORT_C const TImplementationProxy* ImplementationGroupProxy( TInt& aTableCount )

    {

    aTableCount = sizeof( ImplementationTable ) / sizeof( TImplementationProxy );

    return ImplementationTable;

    }

// End of File