/*

* 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:  This class is the main interface to the RadioServer. It implements

*				 the client-side session.

*

*/

// INCLUDE FILES

#include 	<e32math.h>

#include    "RadioSession.h"

#include    "RadioClientServer.h"

#include	"RadioRequest.h"

#include	"RadioEventHandler.h"

#include    "RadioDebug.h"

// CONSTANTS

// Index to list of asynchronous requests that generates response to MRadioObserver.

const TInt KReqInternal				 = 0;

const TInt KReqRequestTunerControl   = 1;

const TInt KReqSetFrequencyRange     = 2;

const TInt KReqSetFrequency          = 3;

const TInt KReqStationSeek           = 4;

const TInt KReqPlay					 = 5;

const TInt KReqStationSeekByPTY      = 6;

const TInt KReqStationSeekByTA       = 7;

const TInt KReqStationSeekByTP       = 8;

// Max number of retries to start the server

const TInt KRadioStartRetry	= 2;

// Minimum of one for each asynchronous message + one to allow cancel

const TInt KRadioMessageSlots = 11;

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

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

// StartServer

// Static function to start the server process thread.

// Start the server process/thread which lives in an EPOCEXE object.

// Returns: TInt: KErrNone (0) if no error

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

//

static TInt StartServer()

	{

    const TUidType serverUid(KNullUid, KNullUid, KRadioServerUid3);

	// We just create a new server process. Simultaneous launching of two such

	// processes should be detected when the second one attempts to create

	// the server object, failing with KErrAlreadyExists.

    RProcess server;

    TInt r = server.Create(KRadioServerImg, KNullDesC, serverUid);

    if ( r != KErrNone )

	    {

        return r;

	    }

	TRequestStatus stat;

	server.Rendezvous(stat);

	if ( stat != KRequestPending )

		{

		server.Kill(0);		// abort startup

		}

	else

		{

		server.Resume();	// logon OK - start the server

		}

	User::WaitForRequest(stat);		// wait for start or death

	// we can't use the 'exit reason' if the server panicked as this

	// is the panic 'reason' and may be '0' which cannot be distinguished

	// from KErrNone

	r = (server.ExitType() == EExitPanic) ? KErrGeneral : stat.Int();

	server.Close();

	return r;

	}

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

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

// RRadioSession::RRadioSession

// C++ default constructor can NOT contain any code, that

// might leave.

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

//

EXPORT_C RRadioSession::RRadioSession()

	:	iConnected(EFalse),

		iDestinationPckg(TMMFMessageDestination(KRadioServerInterfaceUid, KRadioServerObjectHandle)),

		iObserver(NULL),

		iPrimaryClient(EFalse),

		iRdsNotify(EFalse)

    {

    }

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

// RRadioSession::Connect

// Create a client-side session. Start the server if not started already.

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

//

EXPORT_C TInt RRadioSession::Connect(

	MRadioObserver& aObserver,

	TBool aPrimaryClient )

	{

	// check if already connected

	if ( iConnected )

		{

		return KErrAlreadyExists;

		}

   	TInt retry = KRadioStartRetry;

   	TInt err = KErrGeneral;

   	TInt numMessageSlots = KRadioMessageSlots;

   	for (;;)

   		{

   		// Try to create a new session with the server

   		err = CreateSession(KRadioServerName, Version(), numMessageSlots);

   		if ( (err != KErrNotFound) && (err != KErrServerTerminated) )

   			{

   			break;	// Connected to existing server - ok

			}

   		if ( --retry == 0 )

   			{

			break; 	// Failed.

			}

		// Server not running, try to start it.

   		err = StartServer();

   		if ( (err != KErrNone) && (err != KErrAlreadyExists) )

   			{

			break; 	// Server not launched - propagate error

			}

   		}

	if ( err != KErrNone )

		{

		return err;

		}

	// Create active object request handlers and add it to scheduler

	TRAP(err, StartRequestHandlersL(aObserver));

	if ( err == KErrNone )

		{

		// Create active object event handlers and add it to scheduler

		TRAP(err, StartEventHandlersL(aObserver));

		if ( err == KErrNone )

			{

			iConnected = ETrue;

			iObserver = &aObserver;

			if ( aPrimaryClient )

				{

				iPrimaryClient = ETrue;

				err = SendReceive(ERadioServAddPrimaryClient, TIpcArgs(&iDestinationPckg));

				}

			}

		else

			{

			iRequests.ResetAndDestroy();

			iEventHandlers.ResetAndDestroy();

			}

		}

	else

		{

		iRequests.ResetAndDestroy();

		}

	return err;

	}

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

// RRadioSession::Version

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

//

EXPORT_C TVersion RRadioSession::Version() const

	{

	return(TVersion(KRadioServerVersionMajor, KRadioServerVersionMinor, KRadioServerVersionBuild));

	}

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

// RRadioSession::Close

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

//

EXPORT_C void RRadioSession::Close()

	{

	iRequests.ResetAndDestroy();

	iRequests.Close();

	iEventHandlers.ResetAndDestroy();

	iEventHandlers.Close();

	iRdsEventHandlers.ResetAndDestroy();

	iRdsEventHandlers.Close();

	if ( iConnected )

		{

		iConnected = EFalse;

		if ( iPrimaryClient )

			{

			SendReceive(ERadioServRemovePrimaryClient, TIpcArgs(&iDestinationPckg));

			}

		RSessionBase::Close();

		}

	}

//********** TunerUtility control begins

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

// RRadioSession::RequestTunerControl

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

//

EXPORT_C void RRadioSession::RequestTunerControl(

	TRsTuner aTuner )

	{

	if ( iConnected )

		{

		if ( iRequests[KReqRequestTunerControl]->IsActive() )

			{

			iRequests[KReqRequestTunerControl]->Cancel();

			}

		SendReceive(ERadioServRequestTunerControl,

					TIpcArgs(&iDestinationPckg, aTuner),

					iRequests[KReqRequestTunerControl]->iStatus);

		iRequests[KReqRequestTunerControl]->SetActive();

		}

	else

		{

		iRequests[KReqInternal]->CompleteRequest(ERadioServRequestTunerControl, KErrDisconnected);

		}

	}

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

// RRadioSession::GetTunerCapabilities

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

//

EXPORT_C TInt RRadioSession::GetTunerCapabilities(

	TRsTunerCapabilities& aCaps ) const

	{

	if ( iConnected )

		{

		TPckg<TRsTunerCapabilities> caps(aCaps);

		return SendReceive(ERadioServGetTunerCapabilities,

						   TIpcArgs(&iDestinationPckg, &caps));

		}

	else

		{

		return KErrDisconnected;

		}

	}

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

// RRadioSession::EnableTunerInOfflineMode

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

//

EXPORT_C TInt RRadioSession::EnableTunerInOfflineMode(

	TBool aEnable )

	{

	if ( iConnected )

		{

		return SendReceive(ERadioServEnableTunerInOfflineMode,

    					   TIpcArgs(&iDestinationPckg, aEnable));

		}

	else

		{

		return KErrDisconnected;

		}

	}

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

// RRadioSession::SetFrequencyRange

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

//

EXPORT_C void RRadioSession::SetFrequencyRange(

	TRsFrequencyRange aRange )

	{

	if ( iConnected )

		{

		if ( iRequests[KReqSetFrequencyRange]->IsActive() )

			{

			iRequests[KReqSetFrequencyRange]->Cancel();

			}

		SendReceive(ERadioServSetFrequencyRange,

					TIpcArgs(&iDestinationPckg, aRange),

					iRequests[KReqSetFrequencyRange]->iStatus);

		iRequests[KReqSetFrequencyRange]->SetActive();

		}

	else

		{

		iRequests[KReqInternal]->CompleteRequest(ERadioServSetFrequencyRange, KErrDisconnected);

		}

	}

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

// RRadioSession::CancelSetFrequencyRange

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

//

EXPORT_C void RRadioSession::CancelSetFrequencyRange()

	{

	if ( iConnected && iRequests[KReqSetFrequencyRange]->IsActive() )

		{

		iRequests[KReqSetFrequencyRange]->Cancel();

		}

	}

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

// RRadioSession::GetFrequencyRange

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

//

EXPORT_C TInt RRadioSession::GetFrequencyRange(

	TRsFrequencyRange& aRange,

	TInt& aMinFreq,

	TInt& aMaxFreq) const

	{

	if ( iConnected )

		{

		TPckg<TRsFrequencyRange> range(aRange);

		TPckg<TInt> min(aMinFreq);

		TPckg<TInt> max(aMaxFreq);

		return SendReceive(ERadioServGetFrequencyRange,

						   TIpcArgs(&iDestinationPckg, &range, &min, &max));

		}

	else

		{

		return KErrDisconnected;

		}

	}

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

// RRadioSession::SetFrequency

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

//

EXPORT_C void RRadioSession::SetFrequency(

	TInt aFrequency )

	{

	if ( iConnected )

		{

		if ( iRequests[KReqSetFrequency]->IsActive() )

			{

			iRequests[KReqSetFrequency]->Cancel();

			}

		SendReceive(ERadioServSetFrequency,

					TIpcArgs(&iDestinationPckg, aFrequency),

					iRequests[KReqSetFrequency]->iStatus);

		iRequests[KReqSetFrequency]->SetActive();

		}

	else

		{

		iRequests[KReqInternal]->CompleteRequest(ERadioServSetFrequency, KErrDisconnected);

		}

	}

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

// RRadioSession::CancelSetFrequency

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

//

EXPORT_C void RRadioSession::CancelSetFrequency()

	{

	if ( iConnected && iRequests[KReqSetFrequency]->IsActive() )

		{

		iRequests[KReqSetFrequency]->Cancel();

		}

	}

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

// RRadioSession::GetFrequency

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

//

EXPORT_C TInt RRadioSession::GetFrequency(

	TInt& aFrequency ) const

	{

	if ( iConnected )

		{

		TPckg<TInt> frequency(aFrequency);

		return SendReceive(ERadioServGetFrequency,

						   TIpcArgs(&iDestinationPckg, &frequency));

		}

	else

		{

		return KErrDisconnected;

		}

	}

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

// RRadioSession::StationSeek

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

EXPORT_C void RRadioSession::StationSeek(

	TBool aUpwards )

	{

	if ( iConnected )

		{

		if ( iRequests[KReqStationSeek]->IsActive() )

			{

			iRequests[KReqStationSeek]->Cancel();

			}

		SendReceive(ERadioServStationSeek,

					TIpcArgs(&iDestinationPckg, aUpwards, &(iRequests[KReqStationSeek]->iIntPckg)),

					iRequests[KReqStationSeek]->iStatus);

		iRequests[KReqStationSeek]->SetActive();

		}

	else

		{

		iRequests[KReqInternal]->CompleteRequest(ERadioServStationSeek, KErrDisconnected);

		}

	}

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

// RRadioSession::CancelStationSeek

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

EXPORT_C void RRadioSession::CancelStationSeek()

	{

	if ( iConnected && iRequests[KReqStationSeek]->IsActive() )

		{

		iRequests[KReqStationSeek]->Cancel();

		}

	}

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

// RRadioSession::GetSignalStrength

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

EXPORT_C TInt RRadioSession::GetSignalStrength(

	TInt& aSignalStrength ) const

	{

	if ( iConnected )

		{

		TPckg<TInt> strength(aSignalStrength);

		return SendReceive(ERadioServGetSignalStrength,

						   TIpcArgs(&iDestinationPckg, &strength));

		}

	else

		{

		return KErrDisconnected;

		}

	}

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

// RRadioSession::GetMaxSignalStrength

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

EXPORT_C TInt RRadioSession::GetMaxSignalStrength(

	TInt& aMaxSignalStrength ) const

	{

	if ( iConnected )

		{

		TPckg<TInt> maxStrength(aMaxSignalStrength);

		return SendReceive(ERadioServGetMaxSignalStrength,

						   TIpcArgs(&iDestinationPckg, &maxStrength));

		}

	else

		{

		return KErrDisconnected;

		}

	}

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

// RRadioSession::GetStereoMode

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

EXPORT_C TInt RRadioSession::GetStereoMode(

	TBool& aStereo ) const

	{

	if ( iConnected )

		{

		TPckg<TBool> stereo(aStereo);

		return SendReceive(ERadioServGetStereoMode,

						   TIpcArgs(&iDestinationPckg, &stereo));

		}

	else

		{

		return KErrDisconnected;

		}

	}

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

// RRadioSession::ForceMonoReception

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

EXPORT_C TInt RRadioSession::ForceMonoReception(

	TBool aForcedMono )

	{

	if ( iConnected )

		{

		return SendReceive(ERadioServForceMonoReception,

						   TIpcArgs(&iDestinationPckg, aForcedMono));

		}

	else

		{

		return KErrDisconnected;

		}

	}

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

// RRadioSession::GetForceMonoReception

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

EXPORT_C TInt RRadioSession::GetForceMonoReception(

	TBool& aForcedMono ) const

	{