/*

* 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::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 );

    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

	TRAPD( err, GetCorrectClientL( aInterfaceUid, aOperationId, aClients ) );

	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" );      

    }

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

// CRemConTspController::GetCorrectClientL

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

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

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

//

void CRemConTspController::GetCorrectClientL(

    TUid aInterfaceUid,

	TUint aKeyEvent,

	TSglQue<TClientInfo>& aClients )

	{

	COM_TRACE_1( "[REMCONTSPCONTROLLER] CRemConTspController::GetCorrectClientL() Start aInterfaceUid %d", aInterfaceUid );

	COM_TRACE_1( "[REMCONTSPCONTROLLER] CRemConTspController::GetCorrectClientL() Start aKeyEvent %d", aKeyEvent );

    TInt numOfTables = iArrayOfTables.Count();

    RArray<TInt> rulesArray;

    CleanupClosePushL( rulesArray );

    COM_TRACE_1( "[REMCONTSPCONTROLLER] CRemConTspController::GetCorrectClientL() Get Correct Table, table count %d", numOfTables );

    for( TInt i = 0; i != numOfTables; i++ )

        {

        // If an extension api event

        if( ( aInterfaceUid.iUid == KRemConExtCallHandlingApiUid ) ||

          ( aInterfaceUid.iUid == KRemConExtPocApiUid ) ||

          ( aInterfaceUid.iUid == KRemConExtSynchronizationApiUid ) ||

          ( aInterfaceUid.iUid == 0 ) )

    	    {

    	    TBool value( EFalse );

    	    if( aInterfaceUid.iUid == KRemConExtCallHandlingApiUid )

    	        {

    	        value = iArrayOfTables[ i ]->IsRemConEventInTable(

    	                       aKeyEvent, CRemConEventTable::ERemConExtEventCall );

    	        }

    	    if( aInterfaceUid.iUid == KRemConExtPocApiUid )

    	        {

    	        value = iArrayOfTables[ i ]->IsRemConEventInTable(

    	                       aKeyEvent, CRemConEventTable::ERemConExtEventPoc );

    	        }

    	    if( aInterfaceUid.iUid == KRemConExtSynchronizationApiUid )

    	        {

    	        value = iArrayOfTables[ i ]->IsRemConEventInTable(

    	                       aKeyEvent, CRemConEventTable::ERemConExtEventSync );

    	        }

    	    COM_TRACE_1( "[REMCONTSPCONTROLLER] CRemConTspController::GetCorrectClientL() Table num for extension event aKeyEvent %d ", aKeyEvent );

    	    COM_TRACE_1( "[REMCONTSPCONTROLLER] CRemConTspController::GetCorrectClientL() Table num for extension event i %d ", i );

    	    COM_TRACE_1( "[REMCONTSPCONTROLLER] CRemConTspController::GetCorrectClientL() Table num for extension event value %d ", value );

    	    if( value )

    	        {

    	        iArrayOfTables[ i ]->GetRulesForThisTable( rulesArray );

    	        numOfTables = iArrayOfTables[ i ]->TableNum();

    	        COM_TRACE_1( "[REMCONTSPCONTROLLER] CRemConTspController::GetCorrectClientL() Table num for extension event numOfTables %d ", numOfTables );

    	        break;

    	        }

    	    }

    	else // Rem con core event

    	    {

    	    if( iArrayOfTables[ i ]->IsRemConEventInTable( 

    	                        aKeyEvent, CRemConEventTable::ERemConEvent ) )

    	        {

    	        iArrayOfTables[ i ]->GetRulesForThisTable( rulesArray );

    	        numOfTables = iArrayOfTables[ i ]->TableNum();

    	        COM_TRACE_1( "[REMCONTSPCONTROLLER] CRemConTspController::GetCorrectClientL() Table num for core event numOfTables %d ", numOfTables );

    	        break;

    	        }

    	    }

        }

    COM_TRACE_( "[REMCONTSPCONTROLLER] CRemConTspController::GetCorrectClientL() Get client" );

    // Check for current transparent clients

    RPointerArray<TClientInfo> transparentClients; // Pointers are not own

    CleanupClosePushL( transparentClients );

    CRemConEventTable* table = FindRoutingTable( iArrayOfTables, numOfTables );

    if ( table )

        {

        RArray<TInt> transparentApps;

        table->GetTransparentApplicationsForTable( transparentApps );

        for ( TInt i = transparentApps.Count() - 1; i >= 0; --i )

            {

            TSecureId secureId( transparentApps[ i ] );

            TClientInfo* target = FindRemconConnection( secureId, aClients );

            if ( target )

                {

                transparentClients.Append( target ); // Ignore error

                COM_TRACE_1( "[REMCONTSPCONTROLLER] CRemConTspController::GetCorrectClientL() transparent client 0x%x found", transparentApps[ i ] );

                }

            }

        transparentApps.Close();

        }

    // If there is a rule for this key event this for is entered

    for( TInt i = 0; i != rulesArray.Count(); i++ )

        {

        TBool found( EFalse );

        switch( rulesArray[ i ] )

            {

            case CRemConEventTable::EActiveAudio:

                {

                COM_TRACE_( "[REMCONTSPCONTROLLER] CRemConTspController::GetCorrectClientL() Get active audio client" );

                found = FindActiveAudioFromAudioPolicy( aClients );

                if ( !found )

                    {

                    found = FindActiveAudioFromCustomIfL( aClients );

                    }

                break;

                }

            case CRemConEventTable::EForegroundApplication:

                {

                COM_TRACE_( "[REMCONTSPCONTROLLER] CRemConTspController::GetCorrectClientL() Get foreground client" );

                GetActiveWindowClientL();

                TSglQueIter<TClientInfo> iter( aClients );

            	TClientInfo* target = iter;

            	while( target )

			        {

            	    TProcessId processId = target->ProcessId();

            	    if( iProcessIdForeground == processId )

            	        {

            	        aClients.Reset();

            	        aClients.AddFirst( *target );

            	        found = ETrue;

            	        break;

            	        }

            	    iter++;

            	    target = iter;

            	    }

                break;

                }

            case CRemConEventTable::EDefaultApplicationGroup:

                {

                COM_TRACE_( "[REMCONTSPCONTROLLER] CRemConTspController::GetCorrectClientL() Default application client" );