diff -r 22de2e391156 -r 20ac952a623c remotecontrol/remotecontrolfw/client/intermediate/public/remconinterfaceselector.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/remotecontrol/remotecontrolfw/client/intermediate/public/remconinterfaceselector.h Wed Oct 13 16:20:29 2010 +0300 @@ -0,0 +1,492 @@ +// Copyright (c) 2004-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: +// + +/** + @file + @publishedAll + @released +*/ + +#ifndef REMCONINTERFACESELECTOR_H +#define REMCONINTERFACESELECTOR_H + +#include +#include +#include +#include +#include +#include + +class CRemConInterfaceBase; +class CBulkReceiver; +class CReceiver; +class MRemConErrorObserver; +class RRemConInterfaceFeatures; +class RSpecificThreadCallBack; +class CRemConInterfaceDetailsArray; +class RNestableLock; +class RRemConController; +class RRemConTarget; +class RRemConBulk; +class RRemCon; + +// Panic information +_LIT(KRemConIfSelPanicCat, "RemConIfSel"); +enum + { + /** The client has given a bad message type. */ + ERemConIfSelBadMessageType = 0, + + /** The client has already called OpenTargetL successfully. + + This is no longer an illegal condition and so the panic will never + be raised. + */ + ERemConIfSelTargetSessionAlreadyExists = 1, + + /** The client has already called OpenControllerL successfully. + + This is no longer an illegal condition and so the panic will never + be raised. + */ + ERemConIfSelControllerSessionAlreadyExists = 2, + + /** The client has created (and registered) an outer layer interface of a + type which is already registered. */ + ERemConIfSelInterfaceOfThatTypeAlreadyRegistered = 3, + + /** The client has not offended- there is a defect in some layer of the + Remote Control system. */ + ERemConIfSelInternalError = 4, + + /** An outer-layer interface has been instantiated (and registered with + the intermediate layer) after OpenControllerL or OpenTargetL has been + successfully called. */ + ERemConIfSelTardyInterfaceRegistration = 5, + + /** OpenControllerL has not successfully been called before using an API + which expects a controller session to have been created. */ + ERemConIfSelNoControllerSession = 6, + + /** OpenTargetL has not successfully been called before using an API which + expects a target session to have been created. */ + ERemConIfSelNoTargetSession = 7, + + /** Neither OpenControllerL not OpenTargetL has been successfully called + before using an API which expects either a controller or a target session + to have been created. */ + ERemConIfSelNoSession = 8, + + /** An outer layer DLL has instantiated CRemConInterfaceBase with an + illegal client type. */ + ERemConIfSelUndefinedClientType = 9, + + /** An implementation of CRemConInterfaceBase::GetInterface does not + provide an implementation of MRemConInterfaceIf. */ + ERemConIfSelNoInterfaceImplementation = 10, + + /** A client has created bulk interfaces in multiple different threads, + all bulk interfaces must be created in the same thread*/ + ERemConIfSelMultipleBulkInterfaceThreads = 11, + }; + +/** +CRemConInterfaceSelector is only instantiable via its NewL function. It is not +derivable. +*/ +NONSHARABLE_CLASS(CRemConInterfaceSelector) : public CBase + { +public: + /** + Factory method. + @return Ownership of a new CRemConInterfaceSelector. + */ + IMPORT_C static CRemConInterfaceSelector* NewL(); + + /** Destructor. */ + IMPORT_C ~CRemConInterfaceSelector(); + +public: + /** + Register the interface with the selector. This is called by the + interface's BaseConstructL. Takes ownership of aInterface. + This function is not to be called outside of remconinterfacebase.dll. It is available for compatibility with previous + versions, but it is intended to be called only by CRemConInterfaceBase::BaseConstructL. + CRemConInterfaceBase-derived classes should indirectly perform a RegisterInterfaceL, by calling + CRemConInterfaceBase::BaseConstructL from their construction functions. + @param aInterface The interface. + */ + IMPORT_C void RegisterInterfaceL(CRemConInterfaceBase& aInterface); + + /** + Register the interface with the selector. This is called by the + interface's BaseConstructL. Takes ownership of aInterface. + This function is not to be called outside of remconinterfacebase.dll. It is available for compatibility with previous + versions, but it is intended to be called only by CRemConInterfaceBase::BaseConstructL. + CRemConInterfaceBase-derived classes should indirectly perform a RegisterInterfaceL, by calling + CRemConInterfaceBase::BaseConstructL from their construction functions. + @param aInterface The interface. + @param aRemConInterfaceFeatures The operation IDs of the interface. Ownership is retained by the caller. Any necessary + data will be copied by the interface selector. + */ + void RegisterInterfaceL(CRemConInterfaceBase& aInterface, RRemConInterfaceFeatures& aRemConInterfaceFeatures); + /** + Register an error observer. This is provided to allow the client to + discover when an error has occurred passively. + + @param aObserver An error observer to be notified on a passive error. + NULL to stop receiving notifications. + */ + IMPORT_C void RegisterErrorObserver(MRemConErrorObserver* aObserver); + + /** + Opens a controller session to RemCon. The session is connectionless until + such time as GoConnectionOriented may be called. + @leave KErrInUse If a controller session is already open. + */ + IMPORT_C void OpenControllerL(); + + /** + Makes the controller session (which must already exist- use + OpenControllerL) connection-oriented. + @param aConnection The remote to talk to. + */ + IMPORT_C void GoConnectionOrientedL(const TRemConAddress& aConnection); + + /** + Makes the controller session (which must already exist- use + OpenControllerL) connectionless. + */ + IMPORT_C void GoConnectionlessL(); + + /** + Brings up a bearer-level connection. + The controller session must already exist (use OpenControllerL) and + be connection-oriented. + @param aStatus TRequestStatus for asynchronous completion. + */ + IMPORT_C void ConnectBearer(TRequestStatus& aStatus); + + /** + Cancels interest in the completion of a ConnectBearer request. + @return KErrNone. + */ + IMPORT_C TInt ConnectBearerCancel(); + + /** + Destroys a bearer-level connection. + The controller session must already exist (use OpenControllerL) and be + connection-oriented. + @param aStatus TRequestStatus for asynchronous completion. + */ + IMPORT_C void DisconnectBearer(TRequestStatus& aStat); + + /** + Cancels interest in the completion of a DisconnectBearer request. + @return KErrNone. + */ + IMPORT_C TInt DisconnectBearerCancel(); + + /** + Opens a target session to RemCon. + @leave KErrInUse If a target session is already open. + */ + IMPORT_C void OpenTargetL(); + + /** + Opens a target session to RemCon. + @param aPlayerType The type of player + @param aPlayerSubType The sub-type of the player + @param aPlayerName The name of the player in UTF-8. + @leave KErrInUse If a target session is already open. + */ + IMPORT_C void OpenTargetL(TPlayerType aPlayerType, TPlayerSubType aPlayerSubType, const TDesC8& aPlayerName); + /** + Sends a message to the remote device(s). + There should be only one command and response outstanding at any one time. + Send cannot be called again until aStatus is completed. + @panic RemConClient 4 If a send is already outstanding + @param aStatus TRequestStatus for asynchronous completion. + @param aInterfaceUid The UID of the concrete (outer-layer) interface + sending the message. + @param aOperationId The interface-specific operation identifier. + @param aNumRemotes On success, the number of remotes the message was + successfully sent to. + @param aMsgType Whether the message is a command or a response. + @param aData Any associated message data in interface-specific format. + */ + IMPORT_C void Send(TRequestStatus& aStatus, + TUid aInterfaceUid, + TUint aOperationId, + TUint& aNumRemotes, + TRemConMessageType aMsgType, + const TDesC8& aData = KNullDesC8()); + + /** + Sends a message to the remote device(s). + @param aStatus TRequestStatus for asynchronous completion. + @param aInterfaceUid The UID of the concrete (outer-layer) interface + sending the message. + @param aOperationId The interface-specific operation identifier. + @param aNumRemotes On success, the number of remotes the message was + successfully sent to. + @param aMsgType Whether the message is a command or a response. + @param aMsgSubType The subtype of the command of response + @param aData Any associated message data in interface-specific format. + */ + IMPORT_C void Send(TRequestStatus& aStatus, + TUid aInterfaceUid, + TUint aOperationId, + TUint& aNumRemotes, + TRemConMessageType aMsgType, + TRemConMessageSubType aMsgSubType, + const TDesC8& aData = KNullDesC8()); + + /** + Sends a + */ + IMPORT_C void SendNotify(TRequestStatus& aStatus, + TUid aInterfaceUid, + TUint aOperationId, + TRemConMessageType aMsgType, + TRemConMessageSubType aMsgSubType, + const TDesC8& aData = KNullDesC8()); + + /** + This method is for internal sub-system use only and should be not be used otherwise. + Sends a message to the remote device(s), without waiting for the send to complete + @param aInterfaceUid The UID of the concrete (outer-layer) interface + sending the message. + @param aOperationId The interface-specific operation identifier. + @param aMsgType Whether the message is a command or a response. + @param aData Any associated message data in interface-specific format. + */ + IMPORT_C TInt SendUnreliable( + TUid aInterfaceUid, + TUint aOperationId, + TRemConMessageType aMsgType, + const TDesC8& aData = KNullDesC8()); + + /** + This method is for internal sub-system use only and should be not be used otherwise. + Sends a message to the remote device(s), without waiting for the send to complete + @param aInterfaceUid The UID of the concrete (outer-layer) interface + sending the message. + @param aOperationId The interface-specific operation identifier. + @param aMsgType Whether the message is a command or a response. + @param aMsgSubType The subtype of the command of response + @param aData Any associated message data in interface-specific format. + */ + IMPORT_C TInt SendUnreliable( + TUid aInterfaceUid, + TUint aOperationId, + TRemConMessageType aMsgType, + TRemConMessageSubType aMsgSubType, + const TDesC8& aData = KNullDesC8()); + + /** + Cancels interest in the completion of a Send request. + @param aMsgType The type of the message, the completion of the send of + which we are not interested in. This is needed because a single + CRemConInterfaceSelector may have two sends outstanding at once, one on + a controller session and another on a target session. + @return KErrNone. + */ + IMPORT_C TInt SendCancel(TRemConMessageType aMsgType); + + /** + This method is for internal sub-system use only and should be not be used otherwise. + Sends a message to the remote device(s) through the bulk path. + There should be only one response outstanding at any one time. + Send cannot be called again until aStatus is completed. + @panic RemConClient 4 If a send is already outstanding + @param aStatus TRequestStatus for asynchronous completion. + @param aInterfaceUid The UID of the concrete (outer-layer) interface + sending the message. + @param aOperationId The interface-specific operation identifier. + @param aData Any associated message data in interface-specific format. + */ + IMPORT_C void SendBulk(TRequestStatus& aStatus, + TUid aInterfaceUid, + TUint aOperationId, + const TDesC8& aData = KNullDesC8()); + + /** + This method is for internal sub-system use only and should be not be used otherwise. + Sends a message to the remote device(s) through the bulk path, without + waiting for the send to complete. + @param aInterfaceUid The UID of the concrete (outer-layer) interface + sending the message. + @param aOperationId The interface-specific operation identifier. + @param aData Any associated message data in interface-specific format. + */ + IMPORT_C TInt SendBulkUnreliable( + TUid aInterfaceUid, + TUint aOperationId, + const TDesC8& aData = KNullDesC8()); + + /** + This method is for internal sub-system use only and should be not be used otherwise. + Cancels interest in the completion of a BulkSend request. + @return KErrNone. + */ + IMPORT_C TInt SendBulkCancel(); + + /** + Only called internally, by the Active Object which sucks messages out of + RemCon. Note that the message type is not given- it is interpolated from + the type of the session doing the receiving. + @param aInterfaceUid Interface UID of the new message. + @param aOperationId Operation ID of the new message. + @param aMsgSubType The message subtype. + @param aRemoteAddress The address of the remote which sent the message. + @param aData Data associated with the new message. + @param aType The type of session which received the message (from which + the type of the message can be interpolated). + */ + void ReceiveComplete(TUid aInterfaceUid, + TUint aOperationId, + TRemConMessageSubType aMsgSubType, + const TRemConAddress& aRemoteAddress, + const TDesC8& aData, + TRemConClientType aType); + + /** + Only called internally, by the Active Object which sucks messages out of + RemCon. Note that the message type is not given- it is interpolated from + the type of the session doing the receiving. + @param aInterfaceUid Interface UID of the new message. + @param aOperationId Operation ID of the new message. + @param aData Data associated with the new message. + */ + void BulkReceiveComplete(TUid aInterfaceUid, + TUint aOperationId, + const TDesC8& aData); + + /** + Only called internally, by the Active Object which sucks messages out of + RemCon. This is called in the case of a session error. + + @param The error that has occurred. If this is KErrServerTerminated, the + error is fatal and the session must be restarted before any new + messages can be received. + */ + void Error(TInt aError); + + /** + Only called internally, by the Active Object which sucks messages out of + RemCon Bulk Server. This is called in the case of a session error. + + @param The error that has occurred. If this is KErrServerTerminated, the + error is fatal and the session must be restarted before any new + messages can be received. + */ + void BulkError(TInt aError); + + /** + Only called internally, by the Active Object which sucks messages out of + RemCon (bulk server). + */ + void BulkSessionConnectL(); + + /** + Getter for the current set of connections in the system (not just those + associated with this session). The client is responsible for cleaning up + aConnections- the addresses will be on the heap. + @param aConnections A collection of remote addresses, representing all the + currently extant connections. + @return Error. + */ + IMPORT_C TInt GetConnections(TSglQue& aConnections); + + /** + Notification for changes in the set of connections. + @param aStatus TRequestStatus for asynchronous completion. + */ + IMPORT_C void NotifyConnectionsChange(TRequestStatus& aStatus); + + /** + Cancels interest in the completion of an outstanding + NotifyConnectionsChange operation. + @return KErrNone. + */ + IMPORT_C TInt NotifyConnectionsChangeCancel(); + + /** + To determine if a target session has been opened. + @return EFalse if no session has been opened, ETrue otherwise. + */ + IMPORT_C TBool TargetOpened() const; + + /** + To determine if a controller session has been opened. + @return EFalse if no session has been opened, ETrue otherwise. + */ + IMPORT_C TBool ControllerOpened() const; + +private: + CRemConInterfaceSelector(); + void ConstructL(); + +private: // utility + void AssertSession(RRemCon* aSess, TInt aPanicCode) const; + TInt TryToReconnect(); + TInt TryToReconnectBulk(); + void OpenTargetCommonL(); + void RegisterInterfaceCommonL(CRemConInterfaceBase& aInterface, const TDesC8& aFeatures); + void RegisterInterestedApisL(TRemConClientType aType); + + void EstablishBulkThreadBindingL(); + + static TInt StaticBulkCleanup(TAny* aSelf); + void BulkCleanup(); + TBool BulkOpened() const; + +private: // owned + CRemConInterfaceDetailsArray* iInterfaces; + + RRemConController* iControllerSession; + RRemConTarget* iTargetSession; + RRemConBulk* iBulkSession; + + CReceiver* iTargetReceiver; + CReceiver* iControllerReceiver; + CBulkReceiver* iBulkReceiver; + + /** For all registered interfaces, this is the size of the biggest + operation-associated data lump. */ + TUint iControlMaxDataLength; + TUint iBulkMaxDataLength; + + // The session to use for NotifyConnectionsChange and + // NotifyConnectionsChangeCancel. It doesn't matter which we use- just one + // that's connected will do. The only interesting bit is that the session + // we called NotifyConnectionsChange on should be the one we call + // NotifyConnectionsChangeCancel on, but as sessions are only closed when + // 'this' comes down that's not a complication. + RRemCon* iNotificationSession; + + TRemConAddress iAddress; + + RHeap* iBulkHeap; + RThread iBulkThread; + RHeap* iSharedThreadHeap; + RSpecificThreadCallBack* iBulkCleanupCall; + RNestableLock* iLock; +private: // unowned + MRemConErrorObserver* iErrorObserver; + }; + +#endif // REMCONINTERFACESELECTOR_H