/*
* 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 "RTcWatcher.h"
#include "WatcherConstants.h"

EXPORT_C RTcWatcher::RTcWatcher()
	: iIsConnected( EFalse )
	{
	}

EXPORT_C void RTcWatcher::Close()
	{
	// Close the session if we are connected
	if( iIsConnected )
		{
		SendReceive( ECloseSession,
#ifdef __IPC_V2_PRESENT__
					 TIpcArgs()
#else
					 NULL
#endif
					 );
				
		RHandleBase::Close();
		iIsConnected = EFalse;
		}
	}

EXPORT_C TInt RTcWatcher::Connect( const TDesC& aAppName, TInt aTimeout )
	{
	// 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( KTcWatcherName,
								Version(),
								KTcWatcherMessageSlots );

		// if connection was established succesfully, go configure the session.
		if( status == KErrNone )
			{
			iIsConnected = ETrue;

#ifdef __IPC_V2_PRESENT__
			return SendReceive( EConfigAndStart,
								TIpcArgs( &aAppName, aTimeout ) );
#else
			TInt p[ KMaxMessageArguments ] =
					{
					(TInt)const_cast< TDesC*>( &aAppName ),
					aTimeout
					};
			status = SendReceive( EConfigAndStart, p );
#endif

			if( status != KErrNone )
				{
				Close();
				}
			}
		}

	return status;
	}

EXPORT_C TInt RTcWatcher::Ping()
	{
	return SendReceive( EPing,
#ifdef __IPC_V2_PRESENT__
						TIpcArgs()
#else
						NULL
#endif
						);
	}

EXPORT_C TVersion RTcWatcher::Version() const
	{
	TVersion version( KTcWatcherMajorVersion,
					  KTcWatcherMinorVersion,
					  KTcWatcherBuildVersion );
	return version;
	}

void RTcWatcher::StartServerL()
	{
	// Let the server have a change at dying if it was just doing so :-)
	if( IsServerStarted() )
		{
		User::After( KTcServerDyingTime );
		}

	if( !IsServerStarted() )
		{
		// Create a global semaphore for waiting the server to start
		RSemaphore semaphore;
		TInt status = semaphore.OpenGlobal( KTcWatcherName );
		if( status == KErrNotFound )
			{
			User::LeaveIfError( semaphore.CreateGlobal( KTcWatcherName, 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( KTcWatcherName,
							   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( KTcWatcherName,
										   entry,
										   KDefaultStackSize,
										   NULL,
										   &library,
										   NULL,
										   KTcDefaultHeapSize,
										   KTcMaxHeapSize,
										   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( KTcWatcherName, 
		                                   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 RTcWatcher::IsServerStarted() const
	{
	TFindServer findServer( KTcWatcherName );
	TFullName name;
	return ( findServer.Next( name ) == KErrNone );
	}