/*

* 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:  This is the implementation of application class

 *

*/

#include <e32svr.h>

#include <s32file.h>

#include <bt_sock.h>

#include <sysutil.h>

//#include <hal.h> // for checking the MachineUID. also link to hal.lib

#include <e32std.h>

//#include <btmanclient.h>

#include <btnotif.h>

#include "bthidserver.h"

#include "bthidsession.h"

#include "bthidclientsrv.h"

#include "bthidconnection.h"

#include "socketlistener.h"

#include "bthidtypes.h"

#include "bthiddevice.h"

#include "hiddescriptorlist.h"

#include "hiddescriptor.h"

#include "bthidserver.pan"

#include "debug.h"

#include "debugconfig.h"

#include "hidgeneric.h"

#include "hidlayoutids.h"

#include "bthidPsKey.h"

#include "hidsdpclient.h"

#ifndef DBG

#ifdef _DEBUG

#define DBG(a) a

#else

#define DBG(a)

#endif

#endif

//File store location

_LIT(KFileStore,"C:\\private\\2001E301\\bthiddevices.dat");

/**  PubSub key read and write policies */

_LIT_SECURITY_POLICY_C2( KBTHIDPSKeyReadPolicy, 

                          ECapabilityLocalServices, ECapabilityReadDeviceData );

_LIT_SECURITY_POLICY_C2( KBTHIDPSKeyWritePolicy, 

                          ECapabilityLocalServices, ECapabilityWriteDeviceData );

// A version number to use when storing device information

// Only for future proofing.

const TInt KDataFileVersionNumber = 1;

CBTHidServer::CBTHidServer() :

    CGenericServer(CActive::EPriorityStandard)

    {

    // Implementation not required

    }

CBTHidServer::~CBTHidServer()

    {

    delete iShutDownTimer;

    delete iControlListener;

    delete iInterruptListener;

    delete iBTConnIndex;

    delete iMasterContIndex; // Causes deletion of iBTConnContainer

    if (iTempInterrupt)

        {

        iTempInterrupt->Close();

        delete iTempInterrupt;

        }

    if (iTempControl)

        {

        iTempControl->Close();

        delete iTempControl;

        }

    iFs.Close();

    iSocketServ.Close();

    iReqs.ResetAndDestroy();

    delete iGenHID;

    delete iHidSdpClient;

    RProperty::Delete( KPSUidBthidSrv, KBTMouseCursorState );

    }

CBTHidServer* CBTHidServer::NewL()

    {

    CBTHidServer* self = CBTHidServer::NewLC();

    CleanupStack::Pop(self);

    return self;

    }

CBTHidServer* CBTHidServer::NewLC()

    {

    CBTHidServer* self = new (ELeave) CBTHidServer;

    CleanupStack::PushL(self);

    self->ConstructL();

    return self;

    }

const TInt KShutdownDelay = 5000000;

void CBTHidServer::StartShutdownTimerIfNoSession()

    {

    if (!ConnectionCount()

            && (!iShutDownTimer || !iShutDownTimer->IsActive()))

        {

        if (!iShutDownTimer)TRAP_IGNORE(iShutDownTimer = CPeriodic::NewL(CActive::EPriorityStandard));

        if (iShutDownTimer)

            iShutDownTimer->Start(KShutdownDelay, 0, TCallBack(

                    CBTHidServer::TimerFired, this));

            TRACE_FUNC

        }

    }

TInt CBTHidServer::TimerFired(TAny* /*aThis*/)

    {

        TRACE_STATIC_FUNC

    CActiveScheduler::Stop();

    return KErrNone;

    }

void CBTHidServer::CancelShutdownTimer()

    {

        TRACE_FUNC

    delete iShutDownTimer;

    iShutDownTimer = NULL;

    }

void CBTHidServer::ConstructL()

    {

        TRACE_INFO(_L("CBTHidServer::ConstructL()..."));

    iMasterContIndex = CObjectConIx::NewL();

    iBTConnContainer = iMasterContIndex->CreateL();

    iBTConnIndex = CObjectIx::NewL();

        // Connect to the file server

        TRACE_INFO(_L("[BTHID]\tCBTHidServer::ConstructL(): Connecting to file server"));

    User::LeaveIfError(iFs.Connect());

    // Make the data storage path (if it doesn't exist)

    // If we can't create it, we can still make connections. They just won't

    // persist.

    iFs.MkDirAll(KFileStore);

        // Connect to the socket server.

        TRACE_INFO(_L("[BTHID]\tCBTHidServer::ConstructL(): Connecting to socket server"));

    User::LeaveIfError(iSocketServ.Connect());

    // Create initial sockets to accept a connection on the control

    // and interrupt channels

    iTempControl = new (ELeave) RSocket;

    iTempInterrupt = new (ELeave) RSocket;

    // Set the security required for incoming connections on the

    // control and interrupt channels. This is handled in socket level now.

    // Create Socket listeners for the control and interrupt channel

    // ETrue, authorisation from user for incoming connection is asked

    iControlListener = CSocketListener::NewL(iSocketServ, KL2CAPHidControl,

            *this, ETrue);

    //no authorisation needs to be asked,

    //since it is asked during Control channel re-connection.

    iInterruptListener = CSocketListener::NewL(iSocketServ,

            KL2CAPHidInterrupt, *this, EFalse);

        // Request to accept connections into the sockets just created

        TRACE_INFO(_L("[BTHID]\tCBTHidServer::ConstructL(): AcceptingConnections..."));

    User::LeaveIfError(iControlListener->AcceptConnection(*iTempControl));

    User::LeaveIfError(iInterruptListener->AcceptConnection(*iTempInterrupt));

        // Create the generic HID:

        TRACE_INFO(_L("[BTHID]\tCBTHidServer::ConstructL(): Creating Generic HID"));

    iGenHID = CGenericHid::NewL(this);

        // Load details of any virtually-cabled devices.

        // Trap the error, but we can live with failure to load stored

        // information. The file may be corrupt and we don't want this

        // to prevent us using the application

        TRACE_INFO(_L("[BTHID]\tCBTHidServer::ConstructL(): Loading virtually cabled devices"));

    TRAPD( err, LoadVirtuallyCabledDevicesL(KFileStore) );

    if (KErrNone != err)

        {

        err = err;

            TRACE_INFO(_L("[BTHID]\tCBTHidServer::ConstructL(): Loading virtually cabled devices FAILED"));

        }

    TRACE_INFO(_L("[BTHID]\tCBTHidServer::ConstructL(): Starting the server"));

    User::LeaveIfError( RProperty::Define( KPSUidBthidSrv,

                                            KBTMouseCursorState,

                                            RProperty::EInt,

                                            KBTHIDPSKeyReadPolicy,

                                            KBTHIDPSKeyWritePolicy) );

    StartL(KBTHidSrvName);

    iActiveState = EFalse;

        TRACE_INFO(_L("[BTHID]\tCBTHidServer::ConstructL(): Server Started."));

    }

CSession2* CBTHidServer::NewSessionL(const TVersion& aVersion,

        const RMessage2& /*aMessage*/) const

    {

    // check we're the right version

    if (!User::QueryVersionSupported(TVersion(KBTHIDServMajorVersionNumber,

            KBTHIDServMinorVersionNumber, KBTHIDServBuildVersionNumber),

            aVersion))

        {

        User::Leave(KErrNotSupported);

        }

    const_cast<CBTHidServer*> (this)->CancelShutdownTimer();

    // make new session

    return CBTHidServerSession::NewL(*const_cast<CBTHidServer*> (this));

    }

void CBTHidServer::InformClientsOfStatusChange(

        const CBTHidDevice& aDeviceDetails, TBTHidConnState aState)

    {

        TRACE_INFO( (_L("[BTHID]\tCBTHidServer::InformClientsOfStatusChange, state=%d"),aState) );

        if (aState == EBTDeviceConnected || 

	     aState == EBTDeviceLinkRestored || 

		 aState == EBTDeviceLinkLost     || 

		 aState == EBTDeviceDisconnected || 

		 aState == EBTDeviceConnectedFromRemote)

        {

        iLastUsedAddr = aDeviceDetails.iAddress;

        iActiveState = ETrue;

        }

    else

        {

        iActiveState = EFalse;

        }

    InformStatusChange(aDeviceDetails.iAddress, aState);

    GlobalNotify(aDeviceDetails.iAddress, aState);

    }

void CBTHidServer::InformStatusChange(const TBTDevAddr& aAddress,

        TBTHidConnState aState)

    {

        TRACE_INFO( (_L("[BTHID]\tCBTHidServer::InformStatusChange, state=%d"),aState) );

    THIDStateUpdateBuf updateBuf;

    THIDStateUpdate& update = updateBuf();

    update.iDeviceAddress = aAddress;

    update.iState = aState;

    // Send to all clients

    iSessionIter.SetToFirst();

    for (;;)

        {

        CBTHidServerSession* session;

        session = reinterpret_cast<CBTHidServerSession*> (iSessionIter++);

        if (!session)

            {

            break;

            }

        session->InformStatusChange(updateBuf);

        }

    }

void CBTHidServer::GlobalNotify(const TBTDevAddr& aDeviceAddr,

        TBTHidConnState aState)

    {

    switch (aState)

        {

        case EBTDeviceLinkRestored:

        case EBTDeviceConnectedFromRemote:

            {

            HandleAsyncRequest(aDeviceAddr, EBTConnected);

            break;

            }

        case EBTDeviceLinkLost:

        case EBTDeviceDisconnected:

        case EBTDeviceUnplugged:

            {

            HandleAsyncRequest(aDeviceAddr, EBTDisconnected);

            break;

            }

        default:

            //No need to bother

            break;

        }

    }

TInt CBTHidServer::HandleAsyncRequest(const TBTDevAddr& aDeviceAddr,

        TInt aNote)

    {

      TRAPD(err, HandleAsyncRequestL(aDeviceAddr, aNote));

      return err;

    }

void CBTHidServer::HandleAsyncRequestL(const TBTDevAddr& aDeviceAddr,

        TInt aNote)

    {

    CBTHidNotifierHelper* notifier = CBTHidNotifierHelper::NewL(*this, aNote, aDeviceAddr);

    CleanupStack::PushL(notifier);

    iReqs.AppendL(notifier);

    CleanupStack::Pop(notifier);

    if (iReqs.Count() == 1) // only display our notifier if there's nothing already showing

        {

        notifier->Start();

        }

    }

void CBTHidServer::NotifierRequestCompleted()

    {

    delete iReqs[0];

    iReqs.Remove(0);

    if (iReqs.Count())

        {

        iReqs[0]->Start();

        }

    }

void CBTHidServer::GenericHIDConnectL(CBTHidConnection* aConnection,

        TBool aStartDriver)

    {

        TRACE_INFO(_L("[BTHID]\tCBTHidServer::GenericHIDConnectL"));

    CBTHidDevice& devDetails = aConnection->DeviceDetails();

    // Search for the first report descriptor and give this

    // to Generic HID

    TBool foundRepDesc = EFalse;

    TInt i = 0;

    while ((i < devDetails.iDescList->DescriptorCount()) && (!foundRepDesc))

        {

        // Get the next descriptor.

        const CHidDescriptor& desc =

                (*(aConnection->DeviceDetails().iDescList))[i];

        if (desc.DescriptorType() == CHidDescriptor::EReportDescriptor)

            {

            foundRepDesc = ETrue;

            User::LeaveIfError(iGenHID->ConnectedL(aConnection->ConnID(),

                    desc.RawData()));

            // Try to start the driver if required.

            if (aStartDriver)

                {

                User::LeaveIfError(iGenHID->DriverActive(

                        aConnection->ConnID(), CHidTransport::EActive));

                }

            }

        i++;

        }

    // If we didn't find a report descriptor, the device information is corrupt

    if (!foundRepDesc)

        {

        User::Leave(KErrCorrupt);

        }

    }

void CBTHidServer::IncrementSessions()

    {

    iSessionCount++;

    CancelShutdownTimer();

    }

void CBTHidServer::DecrementSessions()

    {

    iSessionCount--;

    __ASSERT_DEBUG(iSessionCount >= 0, PanicServer(EMainSchedulerError));

    if (iSessionCount <= 0)

        {

        iSessionCount = 0;

        StartShutdownTimerIfNoSession();

        }

    }

TInt CBTHidServer::RunError(TInt aError)

    {

    if (aError == KErrBadDescriptor)

        {

        // A bad descriptor error implies a badly programmed client,

        // so panic it;

        // otherwise report the error to the client

        PanicClient(Message(), EBadDescriptor);

        }

    else

        {

        Message().Complete(aError);

        }

    // The leave will result in an early return from CServer::RunL(), skipping

    // the call to request another message. So do that now in order to keep the

    // server running.

    ReStart();

    return KErrNone; // handled the error fully

    }

void CBTHidServer::PanicClient(const RMessage2& aMessage, TInt aPanic)

    {

        TRACE_INFO( (_L("[BTHID]\tCBTHidServer::PanicClient(%d)"), aPanic) );

    aMessage.Panic(KBTHIDServer, aPanic);

    }

void CBTHidServer::PanicServer(TInt aPanic)

    {

        TRACE_INFO( (_L("[BTHID]\tCBTHidServer::PanicServer( %d )"), aPanic) );

    User::Panic(KBTHIDServer, aPanic);

    }

void CBTHidServer::ShutdownListeners(TInt aError)

    {

        // Shutdown listeners and close accepting sockets

        TRACE_INFO( (_L("[BTHID]\tCBTHidServer::ShutdownListeners(%d)"), aError) )

    (void) aError;

    iControlListener->Cancel();

    iInterruptListener->Cancel();

    if (iTempInterrupt)

        {

        iTempInterrupt->Close();

        }

    if (iTempControl)

        {

        iTempControl->Close();

        }

    }

TUint CBTHidServer::ConnectionCount()

    {

    return iBTConnContainer->Count();

    }

CBTHidDevice& CBTHidServer::ConnectionDetailsL(TInt aConnID)

    {

    CBTHidConnection *connection = IdentifyConnectionL(aConnID);

    return connection->DeviceDetails();

    }

TBTEngConnectionStatus CBTHidServer::ConnectStatus(const TBTDevAddr& aAddress)

    {

    TInt i = 0;

    TBool foundItem = EFalse;

    TBTEngConnectionStatus retVal = EBTEngNotConnected;

    TInt BTConnectionObjCount = iBTConnContainer->Count();

        TRACE_INFO(_L("[BTHID]\tCBTHidServer::ConnectStatus()"));

    while ((i < BTConnectionObjCount) && (!foundItem))

        {

        CBTHidConnection *connection =

                static_cast<CBTHidConnection*> ((*iBTConnContainer)[i]);

        if (connection)

            {

            CBTHidDevice& devDetails = connection->DeviceDetails();

            if (devDetails.iAddress == aAddress)

                {

                foundItem = ETrue;

                TBTConnectionState HidConnectionStatus =

                        connection->ConnectStatus();

                if ( (EFirstConnection   == HidConnectionStatus) || 

				     (EConnecting        == HidConnectionStatus) || 

                     (EHIDReconnecting   == HidConnectionStatus) || 

                     (EHostReconnecting  == HidConnectionStatus) || 

                     (EHIDInitConnecting == HidConnectionStatus) )

                    {

                    retVal = EBTEngConnecting;

                    }

                if (EConnected == HidConnectionStatus)

                    {

                    retVal = EBTEngConnected;

                    }

                }

            }

        i++;

        }

    return retVal;

    }

TBool CBTHidServer::DeviceExistInContainer(const TBTDevAddr& aAddress)

    {

    TInt i = 0;

    TBool foundItem = EFalse;

    TInt BTConnectionObjCount = iBTConnContainer->Count();

    TRACE_INFO(_L("[BTHID]\tCBTHidServer::DeviceExistInContainer()"));

    while ((i < BTConnectionObjCount) && (!foundItem))

        {

        CBTHidConnection *connection =

                static_cast<CBTHidConnection*> ((*iBTConnContainer)[i]);