/*

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

*

*/

#include "RTcFileHandler.h"

#include "FileHandlerConstants.h"

EXPORT_C RTcFileHandler::RTcFileHandler()

	: iIsConnected( EFalse )

	{

	}

EXPORT_C void RTcFileHandler::Close()

	{

	// Close the session if we are connected

	if( iIsConnected )

		{

		SendReceive( ECloseSession, TIpcArgs() );

		RHandleBase::Close();

		iIsConnected = EFalse;

		}

	}

EXPORT_C TInt RTcFileHandler::Connect()

	{

	// Are we already connected?

	if( iIsConnected )

		{

		return KErrAlreadyExists;

		}

	// Try starting the server, it is safe

	// to call StartServer() even if a server is already running.

	TRAPD( status, StartServerL() );

	// If server was started (or was already running),

	// establish a session to it.

	if( status == KErrNone )

		{

		status = CreateSession( KTcFileHandlerName,

								Version(),

								KTcFileHandlerMessageSlots );

		// if connection was established succesfully, go configure the session.

		if( status == KErrNone )

			{

			iIsConnected = ETrue;

			return SendReceive( EConfigAndStart,

								TIpcArgs() );

			}

		}

	return status;

	}

EXPORT_C TInt RTcFileHandler::CreateFile( 

    const TDesC8& aDestinationPath, 

    const TDesC8& aData )

	{

	return SendReceive( ECreateFile, TIpcArgs( &aDestinationPath, &aData ) );

	}

EXPORT_C TInt RTcFileHandler::CopyFile( 

    const TDesC8& aSourcePath,

    const TDesC8& aDestinationPath )

    {

    return SendReceive( ECopyFile, TIpcArgs( &aSourcePath, &aDestinationPath ) );

    }

EXPORT_C TInt RTcFileHandler::DeleteFile( const TDesC8& aDestinationPath )

	{

	return SendReceive( EDeleteFile, TIpcArgs( &aDestinationPath ) );

	}

EXPORT_C TVersion RTcFileHandler::Version() const

	{

	TVersion version( KTcFileHandlerMajorVersion,

					  KTcFileHandlerMinorVersion,

					  KTcFileHandlerBuildVersion );

	return version;

	}

void RTcFileHandler::StartServerL()

	{

	if( !IsServerStarted() )

		{

		// Create a global semaphore for waiting the server to start

		RSemaphore semaphore;

		TInt status = semaphore.OpenGlobal( KTcFileHandlerName );

		if( status == KErrNotFound )

			{

			User::LeaveIfError( semaphore.CreateGlobal( KTcFileHandlerName, 0 ) );

			}

		CleanupClosePushL( semaphore );

		// We need to create a thread on WINS and a new process on ARMI/THUMB.

#if ( defined (__WINS__) && !defined (EKA2) )

		// Load the server dll

		RLibrary library;

		User::LeaveIfError( library.Load( KTcFileHandlerName,

							   TUidType( KNullUid, KNullUid, KNullUid ) ) );

		CleanupClosePushL( library );

		// Look up the entry point function (always at ordinal #1)

		TLibraryFunction first = library.Lookup( 1 );

		TThreadFunction entry = reinterpret_cast< TThreadFunction >( first() );

		if( !entry )

			{

			User::Leave( KErrBadLibraryEntryPoint );

			}

		// We have to simulate the process with a thread on WINS

		RThread server;

		User::LeaveIfError( server.Create( KTcFileHandlerName,

										   entry,

										   KDefaultStackSize,

										   NULL,

										   &library,

										   NULL,

										   0x4000,

										   0x100000,

										   EOwnerProcess

										   ) );

		// If successful, server thread has handle to library now

		CleanupStack::PopAndDestroy();	// library

#else

		// Load the server executable.

		// Path (\System\Programs or \sys\bin) and extension (.exe) are added automatically

		RProcess server;

		User::LeaveIfError( server.Create( KTcFileHandlerName, 

		                                   KNullDesC, 

		                                   TUidType( KNullUid, KNullUid, KNullUid ) ) );

#endif

		CleanupClosePushL( server );

		// Start executing the server.

		server.Resume();

		// Wait until it has initialized.

		semaphore.Wait();

		// Close handles

		CleanupStack::PopAndDestroy( 2 );	// server, semaphore

		}

	}

TBool RTcFileHandler::IsServerStarted() const

	{

	TFindServer findServer( KTcFileHandlerName );

	TFullName name;

	return ( findServer.Next( name ) == KErrNone );

	}