/*

* 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 (TSP) used by Symbian's 

*				 Remote Control Framework. TSP controls sending of operations

*			     between Series 60 components and remote targets.

*

*/

#ifndef CREMCONTSPCONTROLLER_H

#define CREMCONTSPCONTROLLER_H

//  INCLUDES

#include <e32base.h>

#include <remcon/remcontargetselectorplugin.h>

#include <remcon/remcontargetselectorplugininterface.h>

#include <e32property.h>

#include <cfclient.h>

#include <cflistener.h>

#include <AudioClientsListPSData.h>

#include "remconidlelistener.h"

#include "remconeventtable.h"

// CONSTANTS

// MACROS

// DATA TYPES

// FUNCTION PROTOTYPES

// FORWARD DECLARATIONS

class CRemConLogger;

class TClientInfo;

// CLASS DECLARATION

/**

*  Controls delivering of commands between Series 60 components and remote 

*  targets.

*

*  @lib RemConTspController.dll

*  @since Series 60 3.0

*/

class CRemConTspController : public CRemConTargetSelectorPlugin,

                 public MRemConTargetSelectorPluginInterfaceV2,

                 public MRemConTargetSelectorPluginInterfaceV3,

			     public MCFListener

	{

	public:		// Constructors and destructor

		/**

        * Two-phased constructor.

        */

		static CRemConTspController* NewL( 

			MRemConTargetSelectorPluginObserver& aObserver );

		/**

        * Destructor.

        */

		virtual ~CRemConTspController();

	public: 	// Functions from base classes

	    void CreateAfterIdleL();

	protected:  // New functions

	protected:  // Functions from base classes

	private:

		/**

        * C++ default constructor.

        */

        CRemConTspController( MRemConTargetSelectorPluginObserver& aObserver );

	private: // from CRemConTargetSelectorPlugin

		/**

        * Called by RemCon server to get a pointer to an object which 

        * implements the TSP interface with UID aUid. This is a mechanism 

        * for allowing future change to the TSP API without breaking BC 

        * in existing (non-updated) TSPs.

        * 

        * @param aUid	Queried TSP interface version.

        * @return TAny	A pointer to implementation of this TSP version, if 

        *				quaried TSP interface version is the one implemented 

        *				by this TSP. Otherwise a NULL will be returned.	

        */

		TAny* GetInterface( TUid aUid );

	private: // from MRemConTargetSelectorPluginInterface

		/**

		* Called by RemCon server to get the TSP to address an outgoing 

		* command (from a connectionless controller client) to zero or 

		* more remote targets.

		* @param aInterfaceUid 		The UID of the client interface.

		* @param aOperationId 		The operation ID of the command.

		* @param aSender The 		TClientInfo of the sending session.

		* @param aConnections 		An empty collection of connections. 

		*							TRemConAddresses must be made on the heap.

		*							RemCon takes ownership of any items in the 

		*							collection. 

		* @params aBearerSecurity 	Contains all the bearer security policies.

		* @return TAny				void 

		*/

		void AddressOutgoingCommand(

							TUid aInterfaceUid,

							TUint aOperationId, 

							const TClientInfo& aSender,

							TSglQue<TRemConAddress>& aConnections,

							TSglQue<TBearerSecurity>& aBearerSecurity );

		/**

		* Called by RemCon server to find out from the TSP whether the given 

		* connection-oriented controller client is permitted to send the given 

		* command to remote target.

		* @param aInterfaceUid 		The UID of the client interface.

		* @param aOperationId 		The operation ID of the command.

		* @param aSender 			The TClientInfo of the sending session.

		* @param aConnection 		The remote the command will be sent over if

		*							permission is granted.

		* @return void				 

		*/	

		void PermitOutgoingCommand(

							TUid aInterfaceUid,

							TUint aOperationId, 

							const TClientInfo& aSender,

							const TRemConAddress& aConnection );

		/** 

		* Called by RemCon server to cancel the current AddressOutgoingCommand 

		* or PermitOutgoingCommand command.

		* @return void 

		*/					

		void CancelOutgoingCommand();

		/**

		* Called by RemCon server to get the TSP to address an incoming command 

		* (from a remote target to zero or more Series 60 components). There's 

		* no 'cancel' method for AddressIncomingCommand.

		* @since Series 60 3.0

		* @param aInterfaceUid 	The UID of the client interface.

		* @param aOperationId 	The operation ID of the command.

		* @param aClients 		A collection of existing target clients. TSP's 

		*						responsibility is to modify this parameter, if 

		*						it wants that command will not be sent to all 

		*						proposed clients. Thus, when this method has 

		*						been finished, aClients will include those 

		*						target clients to whom command should be sent.

		* @return void  

		*/

		void AddressIncomingCommand(

							TUid aInterfaceUid,

							TUint aOperationId, 

							TSglQue<TClientInfo>& aClients );

        /**

        * Called by RemCon to get the TSP to decide which client should be

        * allowed to respond to a command.

        * @param aInterfaceUid The UID of the client interface.

        * @param aOperationId The operation ID of the command.

        * @param aClient The client which is trying to send a response

        * @param aClients A list of clients which are still expected to respond,

        *         including the one specified in aClient

        */

        void PermitOutgoingResponse(

                TUid aInterfaceUid,

                TUint aOperationId,

                const TClientInfo& aClient,

                TClientInfoConstIter& aClients); 

        /** 

        * Called by RemCon to cancel the current PermitOutgoingResponse request.

        */

        void CancelOutgoingResponse(); 

        /**

        * Called by RemCon to get the TSP to address an incoming notify (from a 

        * remote to zero or more target clients). 

        * @param aInterfaceUid The UID of the client interface.

        * @param aOperationId The operation ID of the command.

        * @param aClients A collection of existing target clients. The implementor 

        *         may wish to start a target client and call IncomingNotifyAddressed

        *         with a new TClientInfo. The new TClientInfo item must be made on the stack. 

        *         Note when creating the new TClientInfo, only the process ID needs to 

        *         be correctly populated.

        */

        void AddressIncomingNotify(

                TUid aInterfaceUid,

                TUint aOperationId,

                TSglQue<TClientInfo>& aClients); 

        // From MRemConTargetSelectorPluginInterfaceV3

        /**

        Called by RemCon to get the TSP to address an outgoing notify command (from a 

        connectionless controller client) to zero or one remote. 

        @param aInterfaceUid The UID of the client interface.

        @param aOperationId The operation ID of the command.

        @param aSender The TClientInfo of the sending session.

        @param aBearerSecurity Contains all the bearer security policies.

        */

        void AddressOutgoingNotify(

                TUid aInterfaceUid,

                TUint aOperationId, 

                const TClientInfo& aSender,

                TSglQue<TBearerSecurity>& aBearerSecurity);

        /** 

        Called by RemCon to cancel the current AddressOutgoingNotify or 

        PermitOutgoingNotifyCommand command.

        */

        void CancelOutgoingNotifyCommand();

        /**

        Called by RemCon to find out from the TSP whether the given 

        connection-oriented controller client is permitted to send the given notify

        command to the given remote at this time. 

        @param aInterfaceUid The UID of the client interface.

        @param aOperationId The operation ID of the command.

        @param aSender The TClientInfo of the sending session.

        @param aConnection The remote the command will be sent over if permission 

        is granted.

        */

        void PermitOutgoingNotifyCommand(

                TUid aInterfaceUid,

                TUint aOperationId, 

                const TClientInfo& aSender,

                const TRemConAddress& aConnection);

	    // From MCFListener

	    /**

        * Indicates a change in context for subscribed clients.

        * If client has subscribed to partial context class path,

        * only the changed context will be indicated.

        * 

        * @param aIndication: Context indication.

        * @return None

        */

        void ContextIndicationL(

            const CCFContextIndication& aChangedContext );

        /**

        * Indicates that specified action is needed to be executed.

        * When action indication is received certain rule has been triggered

        * and action is needed to be performed.

        *

        * @param aActionToExecute Action indication.

        * @return None

        */

        void ActionIndicationL(

            const CCFActionIndication& aActionToExecute );

        /**

        * Returns an extension interface.

        * The extension interface is mapped with the extension UID.

        *

        * If the client does not support the requested interface,

        * client must return NULL. Otherwise client needs to return

        * the correct interface combined with the UID.

        *

        * @since S60 5.0

        * @param aExtensionUid: The identifier of the extension.

        * @return Pointer to the extension.

        */    

        TAny* Extension( const TUid& aExtensionUid ) const;

        /**

        * Indicates that error has occured.

        * 

        * @param aError Error code.

        * @return None

        */

        void HandleContextFrameworkError( TCFError aError,

            const TDesC& aSource,

            const TDesC& aType );

        /**

        * Gets the foreground application.

        * 

        * @param aError Error code.

        * @return None

        */

        void GetActiveWindowClientL();

        /**

        * Checks if process is connected to Remcon

        */

        TClientInfo* FindRemconConnection( TProcessId aProcessId, TSglQue<TClientInfo>& aClients ) const;

        /**

        * Checks if client with given secure id is connected to Remcon

        */

        TClientInfo* FindRemconConnection( TSecureId aSecureId, TSglQue<TClientInfo>& aClients ) const;

        /**

        * Sorts the audio clients to a correct order. The last played is first.

        */

        void GetActivePidsL( RArray<TProcessId>& aArray );

#if ( defined COMPONENT_TRACE_FLAG && _DEBUG )

        void TraceAudioPolicyClients( const TUint32 aState, TAudioPolicyProcessIdList aIdList );

#endif

	public:     // Data

	protected:  // Data

	    void ConstructL();

    private:

	    void GetCorrectClientL(

            TUid aInterfaceUid,

        	TUint aKeyEvent,

        	TSglQue<TClientInfo>& aClients );

        void SetKeyEventTableL( const CCFActionIndication& aActionToExecute );        

        void ActivateApplicationL( const TUid aUid ) const;

        TBool IsStateNormal() const;

        TInt FindRoutingTablePos(

                const RPointerArray<CRemConEventTable>& aTableArray, TInt aTableNum ) const;

        CRemConEventTable* FindRoutingTable(

                const RPointerArray<CRemConEventTable>& aTableArray, TInt aTableNum ) const;

        TBool FindActiveAudioFromAudioPolicy( TSglQue<TClientInfo>& aClients );

        TBool FindActiveAudioFromCustomIfL( TSglQue<TClientInfo>& aClients );

        /**

        * Returns whether system lock is active.

        */

        TBool DeviceLocked() const;

	private:    // Data

	    // owned

		CRemConIdleListener* iIdle;

		// Interface to P&S key that returns call state

        RProperty iProperty;

        CCFClient* iCFClient;

        RPointerArray<CRemConEventTable> iArrayOfTables;

        TUid iUidForeground;

        TProcessId iProcessIdForeground;

        TProcessId iProcessIdActive;

        RPointerArray<CRemConEventTable> iArrayOfStoredTables;

	public:     // Friend classes

	protected:  // Friend classes

	private:    // Friend classes

	};

#endif		// CREMCONTSPCONTROLLER_H