/*

* Copyright (c) 2002-2009 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 "remconeventtable.h"

#include <remcon/remcontargetselectorpluginobserver.h>

#include <remconaddress.h>

#include <remcon/clientinfo.h>

#include <remcon/bearersecurity.h>

#include <RemConExtensionApi.h>

#include <ctsydomainpskeys.h>

#include <tspclientmapper.h>

#include <cfclient.h>

#include <cflistener.h>

#include <cfkeyvaluepair.h>

#include <cfactionindication.h>

#include <cfactionsubscription.h>

#include <cfcontextobject.h>

#include <w32std.h>

#include <apgwgnam.h>

#include <apgtask.h>

#include <AudioClientsListPSKeys.h>

#include <remconcoreapi.h>

#include <coemain.h>

#include <apgcli.h>

#include <apacmdln.h>

#include <startupdomainpskeys.h>

#include <coreapplicationuisdomainpskeys.h>

#include <absolutevolumeapi.h>

//Build break: Remove this once BT comes up with a solution

const TInt KRemConMediaBrowseApiUidTemp = 0x10285bbb;

// EXTERNAL DATA STRUCTURES

// EXTERNAL FUNCTION PROTOTYPES  

// MACROS

// LOCAL CONSTANTS AND MACROS

const TUint32 KUid3MusicPlayer = 0x102072C3;

//#define __MODULE_TEST__

#ifdef __MODULE_TEST__

const TUint32 KUid3BTAudioMan = 0x102073E4; // STIF

#else

const TUint32 KUid3BTAudioMan = 0x10208971;

#endif

_LIT( KRoutingTable, "routingTable" );

_LIT( KRemConKeyEvent, "keyEventRemCon*" );

_LIT( KRemConKeyEventExt, "keyEventRemConExt*" );

_LIT( KRemConKeyEventExtCall, "keyEventRemConExtCall*" );

_LIT( KRemConKeyEventExtPoc, "keyEventRemConExtPoc*" );

_LIT( KRemConKeyEventExtSync, "keyEventRemConExtSync*" );

_LIT( KRuleText, "rule*" );

_LIT( KDefaultAppText, "defaultApplication*" );

_LIT( KTransparentAppText, "transparentApplication*" );

_LIT( KRemoveRoutingTable, "removeRoutingTable" );

_LIT( KDefaultLaunchAppText, "defaultLaunchApp*" );

_LIT( KStoreRoutingTable, "storeRoutingTable" );

_LIT( KRestoreRoutingTable, "restoreRoutingTable" );

// MODULE DATA STRUCTURES

// LOCAL FUNCTION PROTOTYPES

// FORWARD DECLARATIONS

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

static TUint HexStringToInt( const TDesC& aString )

    {

    TUint ret( 0 );

    TLex lex( aString );

    lex.Val( ret, EHex ); // Ignore error

    return ret;

    }

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

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

// CRemConTspController::CRemConTspController

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

// might leave.

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

//

	{

	}

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

// CRemConTspController::NewL

// Two-phased constructor.

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

//

CRemConTspController* CRemConTspController::NewL( 

								MRemConTargetSelectorPluginObserver& aObserver )

    {

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

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

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

void CRemConTspController::ConstructL()

    {

    iIdle = CRemConIdleListener::NewL( *this );

	}

// Destructor

CRemConTspController::~CRemConTspController()

	{

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

	if( iIdle )

	    {

	    COM_TRACE_( "[REMCONTSPCONTROLLER] CRemConTspController::~CRemConTspController() - iIdle exists, destroy" );

	    delete iIdle;

	    iIdle = NULL;

	    }

	if( iCFClient )

	    {

	    COM_TRACE_( "[REMCONTSPCONTROLLER] CRemConTspController::~CRemConTspController() - iCFClient exists, destroy" );

	    delete iCFClient;

	    iCFClient = NULL;

	    }

    iArrayOfTables.ResetAndDestroy();

    iArrayOfStoredTables.ResetAndDestroy();

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

	}

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

// 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=0x%x", 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) );

		}

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

		{

		ret = reinterpret_cast<TAny*>(

			static_cast<MRemConTargetSelectorPluginInterfaceV3*>(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 = 0x%x", aSender.SecureId().iId );

			COM_TRACE_1( "[REMCONTSPCONTROLLER] Command sent to bearer 0x%x", 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 0x%x", 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 =0x%x", 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.

	}

#ifdef _DEBUG

static void TraceRemconTargets( TSglQue<TClientInfo>& aClients )

    {

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

    TSglQueIter<TClientInfo> iter( aClients );

    TClientInfo* target = iter;

    while( target )

        {

        RProcess process;

        if ( TInt err = process.Open( target->ProcessId().Id() ) == KErrNone )

            {

            TFullName name( process.FullName() );

            COM_TRACE_2( "[REMCONTSPCONTROLLER] Registered target [%S] process id=%d", &name, target->ProcessId().Id() );

            }

        else

            {

            COM_TRACE_2( "[REMCONTSPCONTROLLER] Registered target ERROR process id=%d", err , target->ProcessId().Id() );

            }

        iter++;

        target = iter;

        }

    }

#endif

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

// 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	

	TraceRemconTargets( aClients );

#endif

	Observer().IncomingCommandAddressed( err );

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

	}

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

// CRemConTspController::AddressOutgoingNotify

// Not supported right now.

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

//

void CRemConTspController::AddressOutgoingNotify(

        TUid /*aInterfaceUid*/,

        TUint /*aOperationId*/, 

        const TClientInfo& /*aSender*/,

        TSglQue<TBearerSecurity>& /*aBearerSecurity*/)

    {

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

    // Not yet implemented for connectionless controller. 

    // S60 AVRCP 1.4 controller is connection-oriented.

    Observer().OutgoingNotifyCommandAddressed( NULL, KErrNotSupported );

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

    }

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

// CRemConTspController::PermitOutgoingNotifyCommand

// 

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

//

void CRemConTspController::CancelOutgoingNotifyCommand()

    {

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

    // Nothing to do until AddressOutgoingNotify() or PermitOutgoingNotifyCommand() 

    // will be implemented asynchronously.  

    }

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

// CRemConTspController::PermitOutgoingNotifyCommand

// By default, permit all connection oriented controllers to send notify commands

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

//

void CRemConTspController::PermitOutgoingNotifyCommand(

        TUid /*aInterfaceUid*/,

        TUint /*aOperationId*/, 

        const TClientInfo& /*aSender*/,

        const TRemConAddress& /*aConnection*/)

    {

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

    // Permit all connection oriented controllers to send notify commands 

    Observer().OutgoingNotifyCommandPermitted( ETrue );

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

    }

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