/*

* Copyright (c) 2002-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:  Implements Target Selector Plugin used by Symbian's Remote 

*				 Control Framework. TSP controls sending of operations between 

*				 Series 60 components and remote targets (e.g. headset).

*

*				 This version doesn't really self specify receiver for 

*				 a message but accepts all receivers suggested by RemCon server.

*

*

*/

// INCLUDE FILES

#include "RemConDebug.h"

#include "remcontspcontroller.h"

#include <remcontargetselectorpluginobserver.h>

#include <remconaddress.h>

#include <clientinfo.h>

#include <bearersecurity.h>

#include <remconextensionapi.h>

#include <ctsydomainpskeys.h>

// EXTERNAL DATA STRUCTURES

// EXTERNAL FUNCTION PROTOTYPES  

// CONSTANTS

#ifdef __ACCESSORY_FW

// UID3 of process (Accessory Server) which loads PhoneCmdHandler.dll

const TUint32 KUid3 = 0x10205030;

#else

// UID3 of process (Phone) which loads PhoneCmdHandler.dll

const TUint32 KUid3 = 0x100058B3;

#endif

const TUint32 KUid3MusicPlayer = 0x102072C3;

// MACROS

// LOCAL CONSTANTS AND MACROS

// MODULE DATA STRUCTURES

// LOCAL FUNCTION PROTOTYPES

// FORWARD DECLARATIONS

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

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

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

// CRemConTspController::CRemConTspController

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

// might leave.

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

//

CRemConTspController::CRemConTspController( 

								MRemConTargetSelectorPluginObserver& aObserver )

:	CRemConTargetSelectorPlugin( aObserver )

	{

	}

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

// CRemConTspController::NewL

// Two-phased constructor.

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

//

CRemConTspController* CRemConTspController::NewL( 

								MRemConTargetSelectorPluginObserver& aObserver )

	{

	COM_TRACE_( "[REMCONTSPCONTROLLER] CRemConTspController::NewL()" );

	CRemConTspController* self = new(ELeave) CRemConTspController( aObserver );

	return self;

	}

// Destructor

CRemConTspController::~CRemConTspController()

	{

	COM_TRACE_( "[REMCONTSPCONTROLLER] CRemConTspController::~CRemConTspController()" );

	}

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

// CRemConTspController::GetInterface

// Provides implementation of this (TSP) interface. 

// (other items were commented in a header).

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

//

TAny* CRemConTspController::GetInterface( TUid aUid )

	{

	COM_TRACE_2( "[REMCONTSPCONTROLLER] CRemConTspController::GetInterface() this=%d, aUid=%d", this, aUid );

	TAny* ret = NULL;

	// TSP interface is asked ?

	if ( aUid == TUid::Uid( KRemConTargetSelectorInterface1 ) )

		{

		// convert this object to TAny

		ret = reinterpret_cast< TAny* >( 

				static_cast< MRemConTargetSelectorPluginInterface*>(this) );

		}

	else if ( aUid == TUid::Uid(KRemConTargetSelectorInterface2) )

		{

		ret = reinterpret_cast<TAny*>(

			static_cast<MRemConTargetSelectorPluginInterfaceV2*>(this)

			);

		}

	COM_TRACE_1( "[REMCONTSPCONTROLLER] CRemConTspController::GetInterface() this=%d", ret );

	return ret;

	}

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

// CRemConTspController::AddressOutgoingCommand

// Defines bearers (represents remote target) to which command will be sent. 

// (other items were commented in a header).

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

//

void CRemConTspController::AddressOutgoingCommand(

		TUid aInterfaceUid,

		TUint aOperationId, 

		const TClientInfo& aSender,

		TSglQue<TRemConAddress>& aConnections,

		TSglQue<TBearerSecurity>& aBearerSecurity)

	{

	COM_TRACE_( "[REMCONTSPCONTROLLER] CRemConTspController::AddressOutgoingCommand() starts" );

	// Avoid warnings for unused parameters

	(void)aInterfaceUid;

	(void)aOperationId;

	(void)aSender;

	TInt err = KErrNotFound;

	TSglQueIter<TBearerSecurity> iter( aBearerSecurity );

	TBearerSecurity* sec = iter;

	// Go through all bearers

	while( sec )

		{

		// No security check in this version.

		// Could maybe be smth like "if ( sec->SecurityPolicy().CheckPolicy( aSender.Message() ) )"

		// Address command to all given bearers

		TRemConAddress* conn = NULL;

		conn = new TRemConAddress;

		if ( conn )

			{

			COM_TRACE_1( "[REMCONTSPCONTROLLER] Sender's secure id = %d", aSender.SecureId().iId );

			COM_TRACE_1( "[REMCONTSPCONTROLLER] Command sent to bearer %d", sec->BearerUid().iUid );

			conn->BearerUid().iUid = sec->BearerUid().iUid; 

			// No connection-specific data for this bearer.

			// Ownership of conn is passed back to RemCon.

			aConnections.AddLast( *conn );

			err = KErrNone;

			}

		else

			{

			COM_TRACE_1( "[REMCONTSPCONTROLLER] Memory allocation failed for bearer %d", sec->BearerUid().iUid );

			err = KErrNoMemory;

			break;	// Get out from while() and return KErrNoMemory

			}

		iter++;

		sec = iter;

		}

	COM_TRACE_1( "[REMCONTSPCONTROLLER] CRemConTspController::AddressOutgoingCommand() err=%d", err );

	Observer().OutgoingCommandAddressed( err );

	COM_TRACE_( "[REMCONTSPCONTROLLER] CRemConTspController::AddressOutgoingCommand() ends" );

	}

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

// CRemConTspController::PermitOutgoingCommand

// Defines whether connection-oriented controller can send a command to bearer.

// (other items were commented in a header).

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

//

void CRemConTspController::PermitOutgoingCommand(

		TUid aInterfaceUid,

		TUint aOperationId, 

		const TClientInfo& aSender,

		const TRemConAddress& aConnection )

	{

	COM_TRACE_( "[REMCONTSPCONTROLLER] CRemConTspController::PermitOutgoingCommand()" );

	COM_TRACE_( "[REMCONTSPCONTROLLER] CRemConTspController::PermitOutgoingCommand() start" );

	COM_TRACE_2( "[REMCONTSPCONTROLLER] aInterfaceUid = %d, aOperationId = %d", aInterfaceUid.iUid, aOperationId );

	COM_TRACE_1( "[REMCONTSPCONTROLLER] sender's secure id =%d", aSender.SecureId().iId );

	// Avoid warnings for unused parameters

	(void)aInterfaceUid;

	(void)aOperationId;

	(void)aSender;

	(void)aConnection;

	// Permit all connection oriented controllers to send commands 

	Observer().OutgoingCommandPermitted( ETrue );

	COM_TRACE_( "[REMCONTSPCONTROLLER] CRemConTspController::PermitOutgoingCommand() ends" );

	}

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

// CRemConTspController::CancelOutgoingCommand

// Cancels the current AddressOutgoingCommand or PermitOutgoingCommand command.

// (other items were commented in a header).

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

//

void CRemConTspController::CancelOutgoingCommand()

	{

	COM_TRACE_( "[REMCONTSPCONTROLLER] CRemConTspController::CancelOutgoingCommand()" );

	// Nothing to do until AddressOutgoingCommand() and/or PermitOutgoingCommand() 

	// will be implemented asynchronously.

	}

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

// CRemConTspController::AddressIncomingCommand

// Defines remote targets to which command will be sent.

// (other items were commented in a header).

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

//

void CRemConTspController::AddressIncomingCommand(

		TUid aInterfaceUid,

		TUint aOperationId, 

		TSglQue<TClientInfo>& aClients )

	{

	COM_TRACE_( "[REMCONTSPCONTROLLER] CRemConTspController::AddressIncomingCommand() start" );

	COM_TRACE_2( "[REMCONTSPCONTROLLER] aInterfaceUid = %d, aOperationId = %d", aInterfaceUid.iUid, aOperationId );

	#ifdef _DEBUG

	// For debuging purpose write all remote target ids to trace

	TSglQueIter<TClientInfo> iter( aClients );

	TClientInfo* target = iter;

	TInt number(0);

	while( target )

		{

		COM_TRACE_2( "[REMCONTSPCONTROLLER] %d. client secureId = %d", ++number, target->SecureId().iId );

		iter++;

		target = iter;

		}

	#endif

	TInt err( KErrNone );

	// This version sends operation to all existing clients with following 

	// exception: If there's an incoming or ongoing voice call, 

	// RemConExtensionApi's command ERemConExtAnswerEnd is sent only to 

	// PhoneCmdHandler. 

	if( aInterfaceUid.iUid == KRemConExtCallHandlingApiUid && 

		aOperationId == ERemConExtAnswerEnd 

	  )

		{

		TInt callState( EPSCTsyCallStateUninitialized );

    	TInt err( KErrNone );

    	err = iProperty.Get( KPSUidCtsyCallInformation, 

    						 KCTsyCallState, 

    						 callState ); 

    	if( ( err == KErrNone ) && 

    	    ( callState == EPSCTsyCallStateRinging ||

    	      callState == EPSCTsyCallStateConnected )

    	  )

			{

			TSglQueIter<TClientInfo> iter( aClients );

			TClientInfo* target = iter;

			while( target )

				{

				if( target->SecureId().iId == KUid3 )

					{

					COM_TRACE_1( "[REMCONTSPCONTROLLER] Command is sent only to PhoneCmdHandler running in process identified by secure id=%d", target->SecureId().iId );

					// Add PhoneCmdHandler as the only remote target to 

					// receive ERemConExtAnswerEnd command. 

					aClients.Reset();

					aClients.AddFirst( *target );

					break;	// get out from while-loop

					}

				iter++;

				target = iter;

				}

			}

		}

	Observer().IncomingCommandAddressed( err );

	COM_TRACE_( "[REMCONTSPCONTROLLER] CRemConTspController::AddressIncomingCommand() ends" );

	}

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

// CRemConTspController::PermitOutgoingResponse

// Defines which client can send a response to a command to bearer.

// (other items were commented in a header).

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

//

void CRemConTspController::PermitOutgoingResponse(

		TUid aInterfaceUid,

		TUint aOperationId,

		const TClientInfo& aClient,

		TClientInfoConstIter& aClients)

	{

	COM_TRACE_( "[REMCONTSPCONTROLLER] CRemConTspController::PermitOutgoingResponse()" );

	COM_TRACE_( "[REMCONTSPCONTROLLER] CRemConTspController::PermitOutgoingResponse() start" );

	COM_TRACE_2( "[REMCONTSPCONTROLLER] aInterfaceUid = %d, aOperationId = %d", aInterfaceUid.iUid, aOperationId );

	// Avoid warnings for unused parameters

	(void)aInterfaceUid;

	(void)aOperationId;

	(void)aClient;

	(void)aClients;

	Observer().OutgoingResponsePermitted(ETrue);

	COM_TRACE_( "[REMCONTSPCONTROLLER] CRemConTspController::PermitOutgoingResponse() ends" );

	}

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

// CRemConTspController::CancelOutgoingResponse

// Called by RemCon to cancel the current PermitOutgoingResponse request.

// (other items were commented in a header).

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

//

void CRemConTspController::CancelOutgoingResponse()

	{

	COM_TRACE_( "[REMCONTSPCONTROLLER] CRemConTspController::CancelOutgoingCommand()" );

	// Nothing to do until PermitOutgoingResponse() 

	// will be implemented asynchronously.

	}

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

// CRemConTspController::AddressIncomingNotify

// Defines remote targets to which notify will be sent.

// (other items were commented in a header).

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

//

void CRemConTspController::AddressIncomingNotify(

		TUid aInterfaceUid,

		TUint aOperationId,

		TSglQue<TClientInfo>& aClients)

	{

	COM_TRACE_( "[REMCONTSPCONTROLLER] CRemConTspController::AddressIncomingNotify() start" );

	COM_TRACE_2( "[REMCONTSPCONTROLLER] aInterfaceUid = %d, aOperationId = %d", aInterfaceUid.iUid, aOperationId );

	(void)aInterfaceUid;

	(void)aOperationId;

	TClientInfo* clientInfo = aClients.First();

	TSglQueIter<TClientInfo> iter( aClients );

	TClientInfo* target = iter;

	while( target )

		{

		if( target->SecureId().iId == KUid3MusicPlayer )

			{

			COM_TRACE_1( "[REMCONTSPCONTROLLER] Command is sent only to PlaybackUI running in process identified by secure id=%d", target->SecureId().iId );

			break;	// get out from while-loop

			}

		iter++;

		target = iter;

		}

	Observer().IncomingNotifyAddressed(target, KErrNone);

	COM_TRACE_( "[REMCONTSPCONTROLLER] CRemConTspController::AddressIncomingCommand() ends" );

	}

//

// End of file