diff -r 000000000000 -r 4e1aa6a622a0 accessoryservices/remotecontrolfw/server/inc/session.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/accessoryservices/remotecontrolfw/server/inc/session.h Tue Feb 02 00:53:00 2010 +0200 @@ -0,0 +1,394 @@ +// 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 + @internalComponent +*/ + +#ifndef REMCONSESSION_H +#define REMCONSESSION_H + +#include +#include +#include +#include +#include +#include +#include + +class CRemConServer; +class CBearerManager; +class CRemConMessage; +class CActiveHelper; +class CMessageQueue; +class CRemConInterfaceDetailsArray; +class CRemConInterfaceDetails; + +/** +Rem Con session. +*/ +NONSHARABLE_CLASS(CRemConSession) : public CSession2 + { +public: + /** + Factory method. + @param aServer The server. + @param aBearerManager The bearer manager. + @param aMessage Handle on the client message triggering this session creation. + @param aId The unique ID of the new session. + @return Ownership of a new session. + */ + static CRemConSession* NewL(CRemConServer& aServer, + CBearerManager& aBearerManager, + const RMessage2& aMessage, + TUint aId); + + /** Destructor. */ + ~CRemConSession(); + +public: // called by the server + /** + @return The number of remotes the current 'send' has gone to successfully. + */ + inline TUint& NumRemotes(); + + /** + @return The number of remotes the current 'send' is supposed to be going + to. NB This is decremented as the sends actually occur. + */ + inline TInt& NumRemotesToTry(); + + /** + @return The error the current 'send' will be completed with. + */ + inline TInt& SendError(); + + /** + @return Information about the client using this session. + */ + inline TClientInfo& ClientInfo(); + + /** + @return Information about the client using this session. + */ + inline const TClientInfo& ClientInfo() const; + + /** + @return This session's type. + */ + inline TRemConClientType Type() const; + + /** + @return This session's unique identifier. + */ + inline TUint Id() const; + + /** + Used by the server to complete a client send request. + @param aError Error. + */ + void CompleteSend(); + + /** + Used by the server to complete a client send notify request. + */ + void CompleteSendNotify(); + + /** + Checks if this message is supported by the session + @return ETrue if it is, EFalse otherwise + */ + TBool SupportedMessage(const CRemConMessage& aMsg); + + /** + Writes aMsg to the client's Receive message (NB RMessage2::Write may fail) + and completes the client's Receive message with any error. + @return Error. + */ + TInt WriteMessageToClient(const CRemConMessage& aMsg); + + /** + Accessor for the currently outstanding client Send message. This is used + to check the client's capabilities to send over a particular bearer. + @return Handle to client's send message. + */ + inline const RMessage2& CurrentSendMessage() const; + + /** + Accessor for the currently outstanding client Receive message. + @return Handle to client's receive message. + */ + inline const RMessage2& CurrentReceiveMessage() const; + + inline const TPlayerType& PlayerType() const; + inline const TPlayerSubType& PlayerSubType() const; + + inline const TDesC8& Name() const; + + TInt SupportedInterfaces(RArray& aUids); + TInt SupportedBulkInterfaces(RArray& aUids); + TInt SupportedOperations(TUid aInterfaceUid, RArray& aOperations); + + /** + Panics the client's current Send message with the given code. + */ + void PanicSend(TRemConClientPanic aCode); + +public: // called by the bearer manager + /** + Indicates that a connect request has been completed. The request was not + necessarily from this session- the session must check that the connected + address is one it has asked to be connected. If it is, and we have a + connect request outstanding, the connect request should be completed. + @param aAddr The connected address. + @param aError The error with which the connection attempt was completed. + */ + void CompleteConnect(const TRemConAddress& aAddr, TInt aError); + + /** + Indicates that a disconnect request has been completed. The request was + not necessarily from this session- the session must check that the + disconnected address is one it has asked to be disconnected. If it is, and + we have a disconnect request outstanding, the disconnect request should be + completed. + @param aAddr The disconnected address. + @param aError The error with which the disconnection attempt was + completed. + */ + void CompleteDisconnect(const TRemConAddress& aAddr, TInt aError); + + /** + Indicates that a connection has come up or down. If the session has a + 'connections notification' outstanding, it should be completed. Note that, + when a connection comes up or down, ConnectionsChanged is called before + CompleteConnect or DisconnectComplete. These functions are called + synchronously by the connection-handling code. + */ + void ConnectionsChanged(); + +public: // called by the active helper + /** + Process pending messages. + */ + void ProcessPendingMsgL(); + +private: + /** + Constructor. + @param aServer The server. + @param aBearerManager The bearer manager. + @param aId The unique ID of the new session. + */ + CRemConSession(CRemConServer& aServer, + CBearerManager& aBearerManager, + TUint aId); + + /** + 2nd-phase construction. + @param aMessage The message received from the client. + */ + void ConstructL(const RMessage2& aMessage); + +private: // from CSession2 + /** + Called when a message is received from the client. + @param aMessage Message received from the client. + */ + void ServiceL(const RMessage2& aMessage); + +private: // utility- IPC command handlers + void SetClientType(const RMessage2& aMessage); + void GoConnectionOriented(const RMessage2& aMessage); + void GoConnectionless(const RMessage2& aMessage); + void ConnectBearer(const RMessage2& aMessage); + void ConnectBearerCancel(const RMessage2& aMessage); + void DisconnectBearer(const RMessage2& aMessage); + void DisconnectBearerCancel(const RMessage2& aMessage); + void Send(const RMessage2& aMessage); + void SendNotify(const RMessage2& aMessage); + void SendUnreliable(const RMessage2& aMessage); + void SendCancel(const RMessage2& aMessage); + void Receive(const RMessage2& aMessage); + void ReceiveCancel(const RMessage2& aMessage); + void GetConnectionCount(const RMessage2& aMessage); + void GetConnections(const RMessage2& aMessage); + void NotifyConnectionsChange(const RMessage2& aMessage); + void NotifyConnectionsChangeCancel(const RMessage2& aMessage); + void RegisterInterestedAPIs(const RMessage2& aMessage); + +private: // utility + /** + Utility to complete the given message with the given error code. + @param aMessage Message to complete. + @param aError Error to complete with. + */ + void CompleteClient(const RMessage2& aMessage, TInt aError); + + void DoSendL(const RMessage2& aMessage); + void DoSendNotifyL(const RMessage2& aMessage); + CRemConMessage* DoCreateUnreliableMessageL(const RMessage2& aMessage); + void DoRegisterInterestedAPIsL(const RMessage2& aMessage); + void DoSetClientTypeL(const RMessage2& aMessage); + void DoSendCancel(); + + CRemConInterfaceDetails* FindInterfaceByUid(TUid aUid) const; + + void SendToServer(CRemConMessage& aMsg); + + void CheckForPendingMsg() const; + + static TInt SendNextCb(TAny* aThis); + + void DoSendNext(); + + void EmptySendQueue(); + + void WriteMessageToClientL(const CRemConMessage& aMsg); + +private: // unowned + CRemConServer& iServer; + CBearerManager& iBearerManager; + +private: // message handles for asynchronous IPC requests + RMessage2 iConnectBearerMsg; + RMessage2 iDisconnectBearerMsg; + RMessage2 iSendMsg; + RMessage2 iReceiveMsg; + RMessage2 iNotifyConnectionsChangeMsg; + // Stores pending connect/disconnect request + // There can be only one pending request at any time + RMessage2 iPendingMsg; + + CMessageQueue* iSendQueue; + +private: // owned + // Address of remote device associated with this session (only relevant + // for controllers). A null remote address indicates a connectionless + // controller; a non-null UID indicates a connection-oriented controller. + TRemConAddress iRemoteAddress; + + TRemConClientType iType; + + // The client's process ID, secure ID and caps. + TClientInfo iClientInfo; + + // Unique session identifier. + const TUint iId; + + // Used to control the completion of the client's send request until we + // know the correct values of iNumSuccessfulRemotes and iSendError to use. + // Generally 0. + // 1 when sending a connection-oriented command or a response. + // N when sending a connectionless command (where N is the number of + // remotes the TSP addressed it to). + // While processing outgoing commands to multiple remotes, + // iNumRemotesToTry is decremented each time we finish trying to address a + // remote. This may be at the connection stage or the actual send stage. + // -1 means that the client's send has been completed already. This is + // useful due to the potentially recursive processing of multiple + // connections. + TInt iNumRemotesToTry; + // For completion of the current send request. NB A send may be completed + // only after numerous asynchronous stages. + TUint iNumRemotes; + TInt iSendError; + + CRemConInterfaceDetailsArray* iInterestedAPIs; + // the player type information + TPlayerTypeInformation iPlayerType; + //the player name + RBuf8 iPlayerName; + + // Helps with session's async connect/disconnect requests + CActiveHelper *iPendingMsgProcessor; + + CAsyncCallBack* iSendNextCallBack; + + enum TRemConSessionSending + { + ENotSending, + ESendingReliable, + ESendingUnreliable + }; + + TRemConSessionSending iSending; + + }; + +// Inlines + +TInt& CRemConSession::NumRemotesToTry() + { + return iNumRemotesToTry; + } + +TUint& CRemConSession::NumRemotes() + { + return iNumRemotes; + } + +TInt& CRemConSession::SendError() + { + return iSendError; + } + +TClientInfo& CRemConSession::ClientInfo() + { + return iClientInfo; + } + +const TClientInfo& CRemConSession::ClientInfo() const + { + return iClientInfo; + } + +TRemConClientType CRemConSession::Type() const + { + return iType; + } + +TUint CRemConSession::Id() const + { + return iId; + } + +const RMessage2& CRemConSession::CurrentSendMessage() const + { + return iSendMsg; + } + +const RMessage2& CRemConSession::CurrentReceiveMessage() const + { + return iReceiveMsg; + } + +const TPlayerType& CRemConSession::PlayerType() const + { + return iPlayerType.iPlayerType; + } + +const TPlayerSubType& CRemConSession::PlayerSubType() const + { + return iPlayerType.iPlayerSubType; + } + +const TDesC8& CRemConSession::Name() const + { + return iPlayerName; + } + +#endif // REMCONSESSION_H +