/*
* Copyright (c) 2008 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:  Declares main application class.
 *
*/


#ifndef __BTHIDSERVER_H__
#define __BTHIDSERVER_H__

#include <e32base.h>
#include <es_sock.h>
#include <btmanclient.h>
#include <f32file.h>
#include <ecom/ecom.h>
#include <btdevice.h>
#include <e32std.h>
#include <bttypes.h> //linkkey
#include <btnotif.h>


#include "hidinterfaces.h"
#include "bthidclient.h"
#include "btconnectionobserver.h"
#include "listenerobserver.h"
#include "genericserver.h"
#include "hidlayoutids.h"
#include "genericactive.h"
#include "hidsdpobserver.h"
#include "bthidconnection.h"

class CBTConnection;
class CSocketListener;
class CBTHidConnection;
class CBTHidDevice;
class CGenericHid;
class CHidSdpClient;
class CBTHidNotifierHelper;

/**
 *  An instance of class CBTHidServer is the main server class.
 *
 *  @since Series 60 2.6
 */
class CBTHidServer : public CGenericServer,
        public MBTConnectionObserver,
        public MListenerObserver,
        public MTransportLayer,
        public MHidSdpObserver
    {
public:

    /*!
     Create a CBTHidServer object using two phase construction,
     and return a pointer to the created object
     @result Pointer to created CBTHidServer object
     */
    static CBTHidServer* NewL();

    /*!
     Create a CBTHidServer object using two phase construction,
     and return a pointer to the created object, leaving a pointer to the
     object on the cleanup stack.
     @result Pointer to created CBTHidServer object.
     */
    static CBTHidServer* NewLC();

    /*!
     Destroy the object and release all memory objects.
     */
    ~CBTHidServer();
    
    /*!
     Panic the client.
     @param aMessage the message channel to the client
     @param aReason the reason code for the panic.
     */
    static void PanicClient(const RMessage2& aMessage, TInt aReason);

    void StartShutdownTimerIfNoSession();

    void CancelShutdownTimer();

    /*!
     Increments the count of the active sessions for this server.
     */
    void IncrementSessions();

    /*!
     Decrements the count of the active sessions for this server. .
     If no more sessions are in use the server terminates.
     */
    void DecrementSessions();

    /*!
     Returns a count of the BT HID connections the server is managing.
     @result Number of connections
     */
    TUint ConnectionCount();

    /*!
     Gives access to the device details for a numbered connection.
     @param aConnID connection ID.
     @result Reference to a device details object
     */
    CBTHidDevice& ConnectionDetailsL(TInt aConnID);

    void CleanOldConnection(TInt aConnID);
    /*!
     Asks the server to create a new connection object.
     @result ID for the connection
     */
    TInt NewConnectionL(TBTConnectionState aConnectionState);

    /*!
     Asks the server to do a first-time connection to a device.
     @param aConnID ID of the connection returned from NewConnectionL
     */
    void DoFirstConnectionL(TInt aConnID);

    /*!
     Asks the server to delete a new connection object
     @param aConnID ID of the connection returned from NewConnectionL
     */
    void DeleteNewConnection(TInt aConnID);

    /*
     * Keep the connection alive, initial reconnect from HID device available... 
     */
    void DisconnectDeviceL(const TBTDevAddr& aAddress);
    void DisconnectAllDeviceL();

    /**
     * Asks the server to disconnect (virtual cable unplug) a device totally, 
     * remove the connection entry from the connection container. 
     @param aAddress bluetooth address of the device to disconnect.
     */
    void CloseBluetoothConnection(const TBTDevAddr& aAddress);
    void CloseAllBluetoothConnection();

    /*!
     Finds out the connection status for a given Bluetooth address connected with HID profile
     @param aBDAddr reference to TBTAddr that is checked from Bluetooth registry
     @result TBTEngConnectionStatus
     */
    TBTEngConnectionStatus ConnectStatus(const TBTDevAddr& aAddress);
    
    /*!
     Finds out the connection status for a given Bluetooth address connected with HID profile
     @param aBDAddr reference to TBTAddr that is checked from Bluetooth registry
     @result ETrue  device is found from Container
             EFalse  device is not found from Container
         */    
    TBool DeviceExistInContainer(const TBTDevAddr& aAddress);
    
    /*!
     Panic the server.
     @param aPanic panic code
     */
    static void PanicServer(TInt aPanic);
    
    TBool GetConnectionAddress(TDes8& aAddressBuf);

    TBool IsAllowToConnectFromServerSide(TUint aDeviceSubClass);
    TBool IsAllowToConnectFromClientSide(TBTDevAddr devAddr);
    TUint GetDeviceSubClass(TBTDevAddr aDevAddr);
    TBool IsKeyboard(TUint aDeviceSubClass);
    TBool IsPointer(TUint aDeviceSubClass);

    TBTDevAddr ConflictAddress();

public:
    // from MBTConnectionObserver
    void HandleControlData(TInt aConnID, const TDesC8& aBuffer);

    void HandleCommandAck(TInt aConnID, TInt aStatus);

    void HandleInterruptData(TInt aConnID, const TDesC8& aBuffer);

    void FirstTimeConnectionComplete(TInt aConnID, TInt aStatus);
    
    void FirstTimeConnectionCompleteFromRemote(TInt aConnID, TInt aStatus);

    void LinkLost(TInt aConnID);

    void LinkRestored(TInt aConnID);

    void Disconnected(TInt aConnID);

    void Unplugged(TInt aConnID);
    
    void StartSDPSearch(TInt aConnID);

public:
    //from MListenerObserver
    void SocketAccepted(TUint aPort, TInt aErrorCode);
    
public:
    // from MHidSdpObserver

    void HidSdpSearchComplete(TInt aResult);

public:
    //from MTransportLayer
    TUint CountryCodeL(TInt aConnID);

    TUint VendorIdL(TInt aConnID);

    TUint ProductIdL(TInt aConnID);

    void GetProtocolL(TInt aConnID, TUint16 aInterface);

    void SetProtocolL(TInt aConnID, TUint16 aValue, TUint16 aInterface);

    void GetReportL(TInt aConnID, TUint8 aReportType, TUint8 aReportID,
            TUint16 aInterface, TUint16 aLength);

    void SetReportL(TInt aConnID, TUint8 aReportType, TUint8 aReportID,
            TUint16 aInterface, const TDesC8& aReport);

    void DataOutL(TInt aConnID, TUint8 aReportID, TUint16 aInterface,
            const TDesC8& aReport);

    void GetIdleL(TInt aConnID, TUint8 aReportID, TUint16 aInterface);

    void SetIdleL(TInt aConnID, TUint8 aDuration, TUint8 aReportID,
            TUint16 aInterface);

    void NotifierRequestCompleted();
    
protected:
    // From CActive
    /*!
     Process any errors
     @param aError the leave code reported.
     */
    TInt RunError(TInt aError);
    static TInt TimerFired(TAny* aThis);

private:

    /*!
     Perform the first phase of two phase construction 
     */
    CBTHidServer();

    /*!
     Perform the second phase construction of a CBTHidServer object
     */
    void ConstructL();

     /*!
     Shuts down socket listeners on error and inform user
     @param aError The error which caused the shutdown.
     */
    void ShutdownListeners(TInt aError);

    /*!
     Retrieve the Connection object for a given ID.
     @param aConnID The connection ID.
     @return A pointer to a CBTHidConnection object.
     */
    CBTHidConnection* IdentifyConnectionL(TInt aConnID) const;

    /*!
     Loads virtually-cabled device details from the filestore.
     @param aStoreName file to load from.
     */
    void LoadVirtuallyCabledDevicesL(const TDesC& aStoreName);

    /*!
     Stores virtually-cabled device details from the filestore.
     @param aStoreName file to write to.
     */
    void StoreVirtuallyCabledDevicesL(const TDesC& aStoreName);

    /*!
     Stores virtually-cabled device details from the filestore.
     (Non-Leaving Version)
     @param aStoreName file to write to.
     */
    void StoreVirtuallyCabledDevices(const TDesC& aStoreName);

    /*!
     Updates all current sessions with the current status of a connection
     @param aDeviceDetails details of the device whose status has changed 
     @param aState new state of the connection
     */
    void InformClientsOfStatusChange(const CBTHidDevice& aDeviceDetails,
            TBTHidConnState aState);

    void GlobalNotify(const TBTDevAddr& aDeviceAddr, TBTHidConnState aState);

    TInt HandleAsyncRequest(const TBTDevAddr& aDeviceAddr, TInt note);

    void HandleAsyncRequestL(const TBTDevAddr& aDeviceAddr, TInt aNote);
 
    void InformStatusChange(const TBTDevAddr& aAddress,
            TBTHidConnState aState);
    /*!
     Inform the Generic HID of a new connection (and start the driver if required)
     @param aConnection a CBTHidConnection object for the device connected.
     @param aStartDriver ETrue to start the driver, EFalse otherwise.
     */
    void
            GenericHIDConnectL(CBTHidConnection* aConnection,
                    TBool aStartDriver);

private:
    // From CServer2

    /*!
     Create a time server session, and return a pointer to the created object
     @param aVersion version 
     @result Pointer to new session
     */
    CSession2* NewSessionL(const TVersion &aVersion,
            const RMessage2& aMessage) const;

private:
    /* Internal function to override the security settings of Control channel
     * listener. Used if we are listening for unauthenticated/unauthorised device.
     * For example: Microsoft keyboard with Nokia 6630 PR#1 needs this.
     */
    void CheckAndSetControlListenerSecurityL(TBool aSec);

    /*! The active session count */
    TInt iSessionCount;

    /*! The file server session */
    RFs iFs;

    /*! The socket server session */
    RSocketServ iSocketServ;

    /*! A temporary socket to accept a connection on the control channel */
    RSocket* iTempControl;

    /*! A temporary socket to accept a connection on the interrupt channel */
    RSocket* iTempInterrupt;

    /*! Flag indicating the Autorisation setting on incoming connections */
    TBool iAuthorisationFlag;

    /*! Socket listener for the control channel */
    CSocketListener* iControlListener;

    /*! Socket listener for the interrupt channel */
    CSocketListener* iInterruptListener;

    /*! The Generic HID object */
    CGenericHid* iGenHID;

    /*! Main container index for the server */
    CObjectConIx* iMasterContIndex;

    /*! Container for BT Connection Objects */
    CObjectCon* iBTConnContainer;

    /*! Index for the BT Connection container */
    CObjectIx* iBTConnIndex;

    /*! BT address of a Bluetooth device currently connected in conflict*/
    TBTDevAddr iConflictAddr;

    /*! BT address of a Bluetooth device last used */
    TBTDevAddr iLastUsedAddr;
    TBool iActiveState;

    //Shutdown Timer
    CPeriodic* iShutDownTimer;

    RNotifier iNotifier;

    RPointerArray<CBTHidNotifierHelper> iReqs;
    
    /*! The ID given to this connection */
    TInt iConnID;
    
    /*! A hid sdp client */
    CHidSdpClient* iHidSdpClient;
    };


/** 
 *  This wraps up a UI Notification for the BTHidServer
 */
   
class CBTHidNotifierHelper : public CActive
    {
public:

    static CBTHidNotifierHelper* NewL(CBTHidServer& aHidServer, TInt aNote, const TBTDevAddr& aDeviceAddr);
    
    ~CBTHidNotifierHelper();
    
    void Start();
    
private:

    CBTHidNotifierHelper(CBTHidServer& aHidServer, TInt aNote, const TBTDevAddr& aDeviceAddr);
    
    void ConstructL();
    void RunL();
    void DoCancel();

private:
    
    CBTHidServer& iHidServer;
    
    RNotifier iNotifier;
    
    TPckgBuf<TInt> iNoResult;
    
    TBTGenericInfoNotiferParamsPckg iGenericInfoNotifierType;
    };  

#endif