bluetoothengine/bthid/bthidserver/inc/bthidserver.h
changeset 0 f63038272f30
child 9 a42ed326b458
equal deleted inserted replaced
-1:000000000000 0:f63038272f30
       
     1 /*
       
     2 * Copyright (c) 2008 Nokia Corporation and/or its subsidiary(-ies).
       
     3 * All rights reserved.
       
     4 * This component and the accompanying materials are made available
       
     5 * under the terms of "Eclipse Public License v1.0"
       
     6 * which accompanies this distribution, and is available
       
     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".
       
     8 *
       
     9 * Initial Contributors:
       
    10 * Nokia Corporation - initial contribution.
       
    11 *
       
    12 * Contributors:
       
    13 *
       
    14 * Description:  Declares main application class.
       
    15  *
       
    16 */
       
    17 
       
    18 
       
    19 #ifndef __BTHIDSERVER_H__
       
    20 #define __BTHIDSERVER_H__
       
    21 
       
    22 #include <e32base.h>
       
    23 #include <es_sock.h>
       
    24 #include <btmanclient.h>
       
    25 #include <f32file.h>
       
    26 #include <ecom/ecom.h>
       
    27 #include <btdevice.h>
       
    28 #include <e32std.h>
       
    29 #include <bttypes.h> //linkkey
       
    30 #include <btnotif.h>
       
    31 
       
    32 
       
    33 #include "hidinterfaces.h"
       
    34 #include "bthidclient.h"
       
    35 #include "btconnectionobserver.h"
       
    36 #include "listenerobserver.h"
       
    37 #include "genericserver.h"
       
    38 #include "hidlayoutids.h"
       
    39 #include "genericactive.h"
       
    40 
       
    41 class CBTConnection;
       
    42 class CSocketListener;
       
    43 class CBTHidConnection;
       
    44 class CBTHidDevice;
       
    45 class CGenericHid;
       
    46 class CBTHidNotifierHelper;
       
    47 
       
    48 /**
       
    49  *  An instance of class CBTHidServer is the main server class.
       
    50  *
       
    51  *  @since Series 60 2.6
       
    52  */
       
    53 class CBTHidServer : public CGenericServer,
       
    54         public MBTConnectionObserver,
       
    55         public MListenerObserver,
       
    56         public MTransportLayer
       
    57     {
       
    58 public:
       
    59 
       
    60     /*!
       
    61      Create a CBTHidServer object using two phase construction,
       
    62      and return a pointer to the created object
       
    63      @result Pointer to created CBTHidServer object
       
    64      */
       
    65     static CBTHidServer* NewL();
       
    66 
       
    67     /*!
       
    68      Create a CBTHidServer object using two phase construction,
       
    69      and return a pointer to the created object, leaving a pointer to the
       
    70      object on the cleanup stack.
       
    71      @result Pointer to created CBTHidServer object.
       
    72      */
       
    73     static CBTHidServer* NewLC();
       
    74 
       
    75     /*!
       
    76      Destroy the object and release all memory objects.
       
    77      */
       
    78     ~CBTHidServer();
       
    79     
       
    80     /*!
       
    81      Panic the client.
       
    82      @param aMessage the message channel to the client
       
    83      @param aReason the reason code for the panic.
       
    84      */
       
    85     static void PanicClient(const RMessage2& aMessage, TInt aReason);
       
    86 
       
    87     void StartShutdownTimerIfNoSession();
       
    88 
       
    89     void CancelShutdownTimer();
       
    90 
       
    91     /*!
       
    92      Increments the count of the active sessions for this server.
       
    93      */
       
    94     void IncrementSessions();
       
    95 
       
    96     /*!
       
    97      Decrements the count of the active sessions for this server. .
       
    98      If no more sessions are in use the server terminates.
       
    99      */
       
   100     void DecrementSessions();
       
   101 
       
   102     /*!
       
   103      Returns a count of the BT HID connections the server is managing.
       
   104      @result Number of connections
       
   105      */
       
   106     TUint ConnectionCount();
       
   107 
       
   108     /*!
       
   109      Gives access to the device details for a numbered connection.
       
   110      @param aConnID connection ID.
       
   111      @result Reference to a device details object
       
   112      */
       
   113     CBTHidDevice& ConnectionDetailsL(TInt aConnID);
       
   114 
       
   115     void CleanOldConnection(TInt aConnID);
       
   116     /*!
       
   117      Asks the server to create a new connection object.
       
   118      @result ID for the connection
       
   119      */
       
   120     TInt NewConnectionL();
       
   121 
       
   122     /*!
       
   123      Asks the server to do a first-time connection to a device.
       
   124      @param aConnID ID of the connection returned from NewConnectionL
       
   125      */
       
   126     void DoFirstConnectionL(TInt aConnID);
       
   127 
       
   128     /*!
       
   129      Asks the server to delete a new connection object
       
   130      @param aConnID ID of the connection returned from NewConnectionL
       
   131      */
       
   132     void DeleteNewConnection(TInt aConnID);
       
   133 
       
   134     /*
       
   135      * Keep the connection alive, initial reconnect from HID device available... 
       
   136      */
       
   137     void DisconnectDeviceL(const TBTDevAddr& aAddress);
       
   138     void DisconnectAllDeviceL();
       
   139 
       
   140     /**
       
   141      * Asks the server to disconnect (virtual cable unplug) a device totally, 
       
   142      * remove the connection entry from the connection container. 
       
   143      @param aAddress bluetooth address of the device to disconnect.
       
   144      */
       
   145     void CloseBluetoothConnection(const TBTDevAddr& aAddress);
       
   146     void CloseAllBluetoothConnection();
       
   147 
       
   148     /*!
       
   149      Finds out the connection status for a given Bluetooth address connected with HID profile
       
   150      @param aBDAddr reference to TBTAddr that is checked from Bluetooth registry
       
   151      @result TBTEngConnectionStatus
       
   152      */
       
   153     TBTEngConnectionStatus ConnectStatus(const TBTDevAddr& aAddress);
       
   154 
       
   155     /*!
       
   156      Panic the server.
       
   157      @param aPanic panic code
       
   158      */
       
   159     static void PanicServer(TInt aPanic);
       
   160     
       
   161     TBool GetConnectionAddress(TDes8& aAddressBuf);
       
   162 
       
   163     TBool IsAllowToConnectFromServerSide(TUint aDeviceSubClass);
       
   164     TBool IsAllowToConnectFromClientSide(TBTDevAddr devAddr);
       
   165     TUint GetDeviceSubClass(TBTDevAddr aDevAddr);
       
   166     TBool IsKeyboard(TUint aDeviceSubClass);
       
   167     TBool IsPointer(TUint aDeviceSubClass);
       
   168 
       
   169     TBTDevAddr ConflictAddress();
       
   170 
       
   171 public:
       
   172     // from MBTConnectionObserver
       
   173     void HandleControlData(TInt aConnID, const TDesC8& aBuffer);
       
   174 
       
   175     void HandleCommandAck(TInt aConnID, TInt aStatus);
       
   176 
       
   177     void HandleInterruptData(TInt aConnID, const TDesC8& aBuffer);
       
   178 
       
   179     void FirstTimeConnectionComplete(TInt aConnID, TInt aStatus);
       
   180 
       
   181     void LinkLost(TInt aConnID);
       
   182 
       
   183     void LinkRestored(TInt aConnID);
       
   184 
       
   185     void Disconnected(TInt aConnID);
       
   186 
       
   187     void Unplugged(TInt aConnID);
       
   188 
       
   189 public:
       
   190     //from MListenerObserver
       
   191     void SocketAccepted(TUint aPort, TInt aErrorCode);
       
   192 
       
   193 public:
       
   194     //from MTransportLayer
       
   195     TUint CountryCodeL(TInt aConnID);
       
   196 
       
   197     TUint VendorIdL(TInt aConnID);
       
   198 
       
   199     TUint ProductIdL(TInt aConnID);
       
   200 
       
   201     void GetProtocolL(TInt aConnID, TUint16 aInterface);
       
   202 
       
   203     void SetProtocolL(TInt aConnID, TUint16 aValue, TUint16 aInterface);
       
   204 
       
   205     void GetReportL(TInt aConnID, TUint8 aReportType, TUint8 aReportID,
       
   206             TUint16 aInterface, TUint16 aLength);
       
   207 
       
   208     void SetReportL(TInt aConnID, TUint8 aReportType, TUint8 aReportID,
       
   209             TUint16 aInterface, const TDesC8& aReport);
       
   210 
       
   211     void DataOutL(TInt aConnID, TUint8 aReportID, TUint16 aInterface,
       
   212             const TDesC8& aReport);
       
   213 
       
   214     void GetIdleL(TInt aConnID, TUint8 aReportID, TUint16 aInterface);
       
   215 
       
   216     void SetIdleL(TInt aConnID, TUint8 aDuration, TUint8 aReportID,
       
   217             TUint16 aInterface);
       
   218 
       
   219     void NotifierRequestCompleted();
       
   220     
       
   221 protected:
       
   222     // From CActive
       
   223     /*!
       
   224      Process any errors
       
   225      @param aError the leave code reported.
       
   226      */
       
   227     TInt RunError(TInt aError);
       
   228     static TInt TimerFired(TAny* aThis);
       
   229 
       
   230 private:
       
   231 
       
   232     /*!
       
   233      Perform the first phase of two phase construction 
       
   234      */
       
   235     CBTHidServer();
       
   236 
       
   237     /*!
       
   238      Perform the second phase construction of a CBTHidServer object
       
   239      */
       
   240     void ConstructL();
       
   241 
       
   242      /*!
       
   243      Shuts down socket listeners on error and inform user
       
   244      @param aError The error which caused the shutdown.
       
   245      */
       
   246     void ShutdownListeners(TInt aError);
       
   247 
       
   248     /*!
       
   249      Retrieve the Connection object for a given ID.
       
   250      @param aConnID The connection ID.
       
   251      @return A pointer to a CBTHidConnection object.
       
   252      */
       
   253     CBTHidConnection* IdentifyConnectionL(TInt aConnID) const;
       
   254 
       
   255     /*!
       
   256      Loads virtually-cabled device details from the filestore.
       
   257      @param aStoreName file to load from.
       
   258      */
       
   259     void LoadVirtuallyCabledDevicesL(const TDesC& aStoreName);
       
   260 
       
   261     /*!
       
   262      Stores virtually-cabled device details from the filestore.
       
   263      @param aStoreName file to write to.
       
   264      */
       
   265     void StoreVirtuallyCabledDevicesL(const TDesC& aStoreName);
       
   266 
       
   267     /*!
       
   268      Stores virtually-cabled device details from the filestore.
       
   269      (Non-Leaving Version)
       
   270      @param aStoreName file to write to.
       
   271      */
       
   272     void StoreVirtuallyCabledDevices(const TDesC& aStoreName);
       
   273 
       
   274     /*!
       
   275      Updates all current sessions with the current status of a connection
       
   276      @param aDeviceDetails details of the device whose status has changed 
       
   277      @param aState new state of the connection
       
   278      */
       
   279     void InformClientsOfStatusChange(const CBTHidDevice& aDeviceDetails,
       
   280             TBTHidConnState aState);
       
   281 
       
   282     void GlobalNotify(const TBTDevAddr& aDeviceAddr, TBTHidConnState aState);
       
   283 
       
   284     TInt HandleAsyncRequest(const TBTDevAddr& aDeviceAddr, TInt note);
       
   285 
       
   286     void HandleAsyncRequestL(const TBTDevAddr& aDeviceAddr, TInt aNote);
       
   287  
       
   288     void InformStatusChange(const TBTDevAddr& aAddress,
       
   289             TBTHidConnState aState);
       
   290     /*!
       
   291      Inform the Generic HID of a new connection (and start the driver if required)
       
   292      @param aConnection a CBTHidConnection object for the device connected.
       
   293      @param aStartDriver ETrue to start the driver, EFalse otherwise.
       
   294      */
       
   295     void
       
   296             GenericHIDConnectL(CBTHidConnection* aConnection,
       
   297                     TBool aStartDriver);
       
   298 
       
   299 private:
       
   300     // From CServer2
       
   301 
       
   302     /*!
       
   303      Create a time server session, and return a pointer to the created object
       
   304      @param aVersion version 
       
   305      @result Pointer to new session
       
   306      */
       
   307     CSession2* NewSessionL(const TVersion &aVersion,
       
   308             const RMessage2& aMessage) const;
       
   309 
       
   310 private:
       
   311     /* Internal function to override the security settings of Control channel
       
   312      * listener. Used if we are listening for unauthenticated/unauthorised device.
       
   313      * For example: Microsoft keyboard with Nokia 6630 PR#1 needs this.
       
   314      */
       
   315     void CheckAndSetControlListenerSecurityL(TBool aSec);
       
   316 
       
   317     /*! The active session count */
       
   318     TInt iSessionCount;
       
   319 
       
   320     /*! The file server session */
       
   321     RFs iFs;
       
   322 
       
   323     /*! The socket server session */
       
   324     RSocketServ iSocketServ;
       
   325 
       
   326     /*! A temporary socket to accept a connection on the control channel */
       
   327     RSocket* iTempControl;
       
   328 
       
   329     /*! A temporary socket to accept a connection on the interrupt channel */
       
   330     RSocket* iTempInterrupt;
       
   331 
       
   332     /*! Flag indicating the Autorisation setting on incoming connections */
       
   333     TBool iAuthorisationFlag;
       
   334 
       
   335     /*! Socket listener for the control channel */
       
   336     CSocketListener* iControlListener;
       
   337 
       
   338     /*! Socket listener for the interrupt channel */
       
   339     CSocketListener* iInterruptListener;
       
   340 
       
   341     /*! The Generic HID object */
       
   342     CGenericHid* iGenHID;
       
   343 
       
   344     /*! Main container index for the server */
       
   345     CObjectConIx* iMasterContIndex;
       
   346 
       
   347     /*! Container for BT Connection Objects */
       
   348     CObjectCon* iBTConnContainer;
       
   349 
       
   350     /*! Index for the BT Connection container */
       
   351     CObjectIx* iBTConnIndex;
       
   352 
       
   353     /*! BT address of a Bluetooth device currently connected in conflict*/
       
   354     TBTDevAddr iConflictAddr;
       
   355 
       
   356     /*! BT address of a Bluetooth device last used */
       
   357     TBTDevAddr iLastUsedAddr;
       
   358     TBool iActiveState;
       
   359 
       
   360     //Shutdown Timer
       
   361     CPeriodic* iShutDownTimer;
       
   362 
       
   363     RNotifier iNotifier;
       
   364 
       
   365     RPointerArray<CBTHidNotifierHelper> iReqs;
       
   366 
       
   367     };
       
   368 
       
   369 
       
   370 /** 
       
   371  *  This wraps up a UI Notification for the BTHidServer
       
   372  */
       
   373    
       
   374 class CBTHidNotifierHelper : public CActive
       
   375     {
       
   376 public:
       
   377 
       
   378     static CBTHidNotifierHelper* NewL(CBTHidServer& aHidServer, TInt aNote, const TBTDevAddr& aDeviceAddr);
       
   379     
       
   380     ~CBTHidNotifierHelper();
       
   381     
       
   382     void Start();
       
   383     
       
   384 private:
       
   385 
       
   386     CBTHidNotifierHelper(CBTHidServer& aHidServer, TInt aNote, const TBTDevAddr& aDeviceAddr);
       
   387     
       
   388     void ConstructL();
       
   389     void RunL();
       
   390     void DoCancel();
       
   391 
       
   392 private:
       
   393     
       
   394     CBTHidServer& iHidServer;
       
   395     
       
   396     RNotifier iNotifier;
       
   397     
       
   398     TPckgBuf<TInt> iNoResult;
       
   399     
       
   400     TBTGenericInfoNotiferParamsPckg iGenericInfoNotifierType;
       
   401     };  
       
   402 
       
   403 #endif