/*

* 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 <e32debug.h>

#include "hiddebug.h"

#include "bthidconnection.h"

#include "btconnectionobserver.h"

#include "sockets.pan"

#include "socketinitiator.h"

#include "socketreader.h"

#include "socketwriter.h"

#include "datasegmenter.h"

#include "timeouttimer.h"

#include "bthidtypes.h"

#include "bthiddevice.h"

#include "hidinterfaces.h"

#include "debug.h"

CBTHidConnection* CBTHidConnection::NewL(RSocketServ& aSocketServ,

        MBTConnectionObserver& aObserver, TBTConnectionState aConnectionState)

    {

    CBTHidConnection* self = CBTHidConnection::NewLC(aSocketServ, aObserver,

            aConnectionState);

    CleanupStack::Pop(self);

    return self;

    }

CBTHidConnection* CBTHidConnection::NewLC(RSocketServ& aSocketServ,

        MBTConnectionObserver& aObserver, TBTConnectionState aConnectionState)

    {

    CBTHidConnection* self = new (ELeave) CBTHidConnection(aSocketServ,

            aObserver, aConnectionState);

    // This is a CObject derived class so must be closed to destroy it.

    CleanupClosePushL(*self);

    self->ConstructL();

    return self;

    }

CBTHidConnection::CBTHidConnection(RSocketServ& aSocketServ,

        MBTConnectionObserver& aObserver, TBTConnectionState aConnectionState) :

    iSocketServ(aSocketServ), iObserver(aObserver)

    {

    ChangeState(aConnectionState);

    }

CBTHidConnection::~CBTHidConnection()

    {

    delete iControlSocketReader;

    delete iControlSocketWriter;

    delete iInterruptSocketReader;

    delete iInterruptSocketWriter;

    delete iSocketInitiator;

    delete iCommandSegmenter;

    delete iControlDataBuffer;

    delete iInterruptDataBuffer;

    delete iInactivityTimer;

    delete iDevice;

    // Close connections in the reverse order to when they were opened

    if (iInterruptSocket)

        {

        iInterruptSocket->Close();

        delete iInterruptSocket;

        }

    if (iControlSocket)

        {

        iControlSocket->Close();

        delete iControlSocket;

        }

    }

TInt CBTHidConnection::ConnID()

    {

    return iConnID;

    }

void CBTHidConnection::SetConnID(TInt aConnID)

    {

    // We shouldn't be trying to set the id for this connection

    // after it is connected.

    __ASSERT_DEBUG(iConnectionState == ENotConnected || iConnectionState == EConnecting,

            User::Panic(KPanicBTConnection, ESocketsBadState));

    iConnID = aConnID;

    }

void CBTHidConnection::ConstructL()

    {

        TRACE_FUNC

    (_L("[BTHID]\tCBTHidConnection::ConstructL"));

    //ChangeState(ENotConnected);

    // A new hid device information object.

    iDevice = CBTHidDevice::NewL();

    // Socket readers and writer objects to perform asynchronous requests

    iControlSocketReader = CSocketReader::NewL(EControlSocketID, *this,

            KL2CAPDefaultMTU);

    iControlSocketWriter = CSocketWriter::NewL(EControlSocketID, *this);

    iInterruptSocketReader = CSocketReader::NewL(EInterruptSocketID, *this,

            KL2CAPDefaultMTU);

    iInterruptSocketWriter = CSocketWriter::NewL(EInterruptSocketID, *this);

    // Socket initiator to perform socket connections

    iSocketInitiator = CSocketInitiator::NewL(iSocketServ, *this);

    // Create a timeout timer

    iInactivityTimer = CTimeOutTimer::NewL(EPriorityHigh, *this);

    }

void CBTHidConnection::ConnectL()

    {

        TRACE_FUNC

    (_L("[BTHID]\tCBTHidConnection::ConnectL"));

    // If we aren't in the correct stiDeviceate for an initial connection Panic.

    __ASSERT_DEBUG(iConnectionState == ENotConnected || iConnectionState == EConnecting,

            User::Panic(KPanicBTConnection, ESocketsBadState));

    // Create the two sockets.

    delete iControlSocket;

    iControlSocket = 0;

    iControlSocket = new (ELeave) RSocket;

    // If we leave after this iControlSocket will not be NULL.

    // This is ok since any place where it can be set will delete it first

    // or it will be finally deleted in the destructor

    delete iInterruptSocket;

    iInterruptSocket = 0;

    iInterruptSocket = new (ELeave) RSocket;

    // If we leave after this iControlSocket & iInterruptSocket will not

    // be NULL.

    // This is ok since any place where they can be set will delete first

    // or they will be finally deleted in the destructor

    // Ask the socket initiator to connect these sockets,

    // giving it the bluetooth address of the device and a security flag.

    iSocketInitiator->ConnectSocketsL(iDevice->iAddress,

            iDevice->iUseSecurity, iControlSocket, iInterruptSocket);

    ChangeState(EFirstConnection);

    }

void CBTHidConnection::ReconnectL()

    {

        TRACE_FUNC

    (_L("[BTHID]\tCBTHidConnection::ReconnectL"));

    // If we aren't in the correct state for an reconnection Panic.

    __ASSERT_DEBUG(iConnectionState == ENotConnected,

            User::Panic(KPanicBTConnection, ESocketsBadState));

    // Expect the device to reconnect for now

    ChangeState(ELinkLost);

    }

void CBTHidConnection::Disconnect() //Virtual Cable Unplug. (this is not Bluetooth disconnect)

    {

        TRACE_FUNC

    (_L("[BTHID]\tCBTHidConnection::Disconnect (Virtual Cable Unplug)"));

    if (iConnectionState == EConnected)

        {

        //First Send VCUnplug

        iCommandBuffer.Zero();

        iCommandBuffer.Append(EHIDControlVCUnplug);

        TRequestStatus status;

        iControlSocket->Write(iCommandBuffer, status);

        User::WaitForRequest(status);

        //Then wait for a reply from Su-8W on L2CAP channel(s). If not waited, Su-8W will go mad.

        User::After(500000); //0.5 sec

        //but we never handle that acknowledgement (because it is not required by BT HID

        //specification, but Su-8W needs to send something.)

        iControlSocketWriter->Cancel();

        iControlSocketReader->Cancel();

        iInterruptSocketReader->Cancel();

        iInterruptSocketWriter->Cancel();

        }

    }

void CBTHidConnection::OfferControlSocket(const TBTDevAddr& aAddress,

        RSocket*& aSocket)

    {

        TRACE_FUNC

    (_L("[BTHID]\tCBTHidConnection::OfferControlSocket"));

    if (aAddress == iDevice->iAddress)

        {

        __ASSERT_DEBUG((iConnectionState == ELinkLost) ||

                (iConnectionState == EHIDReconnecting),

                User::Panic(KPanicBTConnection, ESocketsBadState));

        // Take ownership of this socket

        delete iControlSocket;

        iControlSocket = aSocket;

        aSocket = 0;

        // Mark that the HID Device is reconnecting to us.

        ChangeState(EHIDReconnecting);

        }

    }

void CBTHidConnection::OfferInterruptSocket(const TBTDevAddr& aAddress,

        RSocket*& aSocket)

    {

        TRACE_FUNC

    (_L("[BTHID]\tCBTHidConnection::OfferInterruptSocket"));

    if (aAddress == iDevice->iAddress)

        {

        __ASSERT_DEBUG((iConnectionState == EHIDReconnecting), //||(iConnectionState == ELinkLost) ,

                User::Panic(KPanicBTConnection, ESocketsBadState));

        // Take ownership of this socket

        delete iInterruptSocket;

        iInterruptSocket = aSocket;

        aSocket = 0;

        TRAPD(error, PrepareSocketsL());

        if (KErrNone == error)

            {

            // Mark that we are now reconnected.

            ChangeState(EConnected);

            // Inform the observer that the connection has been restored.

            iObserver.LinkRestored(iConnID);

            }

        else

            {

            // Close the sockets as they can't be used

            CloseChannels();

            ChangeState(ELinkLost);

            }

        }

    }

CBTHidDevice& CBTHidConnection::DeviceDetails()

    {

    return (*iDevice);

    }

TBool CBTHidConnection::IsConnected() const

    {

        TRACE_INFO( (_L("[BTHID]\tCBTHidConnection::IsConnected: connection state = %d"), iConnectionState) );

    return (EConnected == iConnectionState);

    }

TBTConnectionState CBTHidConnection::ConnectStatus() const

    {

        TRACE_INFO( (_L("[BTHID]\tCBTHidConnection::ConnectStatus: connection state = %d"), iConnectionState) );

    return (iConnectionState);

    }

void CBTHidConnection::StartMonitoringChannelsL()

    {

        TRACE_FUNC

    (_L("[BTHID]\tCBTHidConnection::StartMonitoringChannelsL"));

    __ASSERT_DEBUG(iConnectionState == EConnected,

            User::Panic(KPanicBTConnection, ESocketsBadState));

    iControlSocketReader->StartReadingL(iControlSocket, iControlInMTU);

    iInterruptSocketReader->StartReadingL(iInterruptSocket, iInterruptInMTU);

    // If the device will reconnect to us we are ok to drop the link

    // after a period of inactivity.

    if (iDevice->iReconnectInit)

        {

        iInactivityTimer->Cancel();

        iInactivityTimer->After(KInactivityTimeout);

        }

    }

void CBTHidConnection::DropConnection()

    {

        TRACE_FUNC

    (_L("[BTHID]\tCBTHidConnection::DropConnection"));

    // Close the Bluetooth Channels.

    CloseChannels();

    // Update the connection state.

    ChangeState(ELinkLost);

    // If a command is outstanding

    if (iCommandIssued)

        {

        // Generate an error to the parent.

        iObserver.HandleCommandAck(iConnID, KErrNotReady);

        // Reset the command flag.

        iCommandIssued = EFalse;

        // Reset this, so we don't leave it in a bad state.

        if (iCommandSegmenter)

            {

            iCommandSegmenter->Reset();

            }

        }

    }

// from MSocketObserver

void CBTHidConnection::HandleSocketError(TUint /*aSocketID*/,

        TBool aConnectionLost, TInt aErrorCode)

    {

        TRACE_INFO( (_L("[BTHID]\tCBTHidConnection::HandleSocketError: connlost %d, error code %d"), aConnectionLost, aErrorCode) );

    if (aConnectionLost)

        {

        ConnectionLost();

        }

    else

        {

        // If we failed to write to the device then inform Generic HID

        // of the failure

        if (iCommandIssued)

            {

            iCommandIssued = EFalse;

            // Reset this, so we don't leave it in a bad state.

            if (iCommandSegmenter)

                {

                iCommandSegmenter->Reset();

                }

            iObserver.HandleCommandAck(iConnID, aErrorCode);

            }

        }

    }

// from MSocketObserver

TBool CBTHidConnection::HandleDataReceived(TUint aSocketID,

        const TDesC8& aBuffer)

    {

        TRACE_FUNC

    (_L("[BTHID]\tCBTHidConnection::HandledataReceived"));

    TBool result = ETrue;

    // Cancel the inactivity timer.

    iInactivityTimer->Cancel();

    switch (aSocketID)

        {

        case EControlSocketID:

            result = ProcessControlData(aBuffer);

            break;

        case EInterruptSocketID:

            result = ProcessInterruptData(aBuffer);

            break;

        default:

            // Shouldn't have any other socket id

            User::Panic(KPanicBTConnection, ESocketsUnknownID);

            break;

        }

    // If the device will reconnect to us we are ok to drop the link

    // after a period of inactivity.

    if ((result) && (iDevice->iReconnectInit))

        {

        iInactivityTimer->After(KInactivityTimeout);

        }

    return result;

    }

// from MSocketObserver

void CBTHidConnection::HandleWriteComplete(TUint aSocketID)

    {

        //to handle DATA Output in interrupt channel (Host to Device DATA)

        // Check the ID of the socket

        TRACE_FUNC

    (_L("[BTHID]\tCBTHidConnection::HandleWriteComplete"));

    if (aSocketID == EControlSocketID || aSocketID == EInterruptSocketID)

        {

        // Send any additional packets on the control channel

        if (iCommandSegmenter)

            {

            const HBufC8* data = iCommandSegmenter->NextPacket();

            if (data)

                {

                if (aSocketID == EControlSocketID)

                    {

                    TRAPD(err, iControlSocketWriter->IssueWriteL(*data));

                    if (KErrNone != err)

                        {

                        // Reset this, so we don't leave it in a bad state.

                        iCommandSegmenter->Reset();

                        iCommandIssued = EFalse;

                        iObserver.HandleCommandAck(iConnID, err);

                        }

                    }

                else //aSocketID == EInterruptSocketID

                    {

                    TRAPD(err, iInterruptSocketWriter->IssueWriteL(*data));

                    if (KErrNone != err)

                        {

                        // Reset this, so we don't leave it in a bad state.

                        iCommandSegmenter->Reset();

                        iCommandIssued = EFalse;

                        iObserver.HandleCommandAck(iConnID, err);

                        }

                    }

                }

            if (!data && aSocketID == EInterruptSocketID && iCommandIssued)

                { //We don't expect response from HID Device, However we'll notify GenericHID

                //that async write operation has been finished.

                iObserver.HandleCommandAck(iConnID, KErrNone); //Socket write complete!

                iCommandIssued = EFalse;

                }

            }

        }

    }

void CBTHidConnection::SocketsConnected()

    {

        TRACE_FUNC

    (_L("[BTHID]\tCBTHidConnection::SocketsConnected"));

    TRAPD(error, PrepareSocketsL());

    if (KErrNone == error)

        {

        switch (iConnectionState)

            {

            case EFirstConnection:

                // We are now connected

                ChangeState(EConnected);

                // If this was an initial connection inform the observer

                iObserver.FirstTimeConnectionComplete(iConnID, KErrNone);

                break;

            case EHostReconnecting:

                // We are now connected

                ChangeState(EConnected);

                iObserver.LinkRestored(iConnID);

                break;

            default:

                User::Panic(KPanicBTConnection, ESocketsBadState);

                break;

            }

        }

    else

        {

        SocketsConnFailed(error);

        }

    }

void CBTHidConnection::SocketsConnFailed(TInt aStatus)

    {

        TRACE_INFO( (_L("[BTHID]\tCBTHidConnection::SocketsConnFailed(%d)"),aStatus) );

    switch (iConnectionState)

        {

        case EFirstConnection:

            // We are not connected

            ChangeState(ENotConnected);

            // If this was an initial connection inform the observer

            iObserver.FirstTimeConnectionComplete(iConnID, aStatus);

            break;

        case EHostReconnecting:

            ChangeState(ELinkLost);

            break;

        default:

            // we don't expect to be connecting in any other state.

            User::Panic(KPanicBTConnection, ESocketsBadState);

            break;

        }

    }

void CBTHidConnection::TimerExpired()

    {

    // Inactivity timer has expired.

    // Drop the connection.

    DropConnection();

    // Inform the observer of the state change.

    iObserver.Disconnected(iConnID);

    }

void CBTHidConnection::GetProtocolL()

    {

    LeaveIfCommandNotReadyL();

    iCommandBuffer.Zero();

    iCommandBuffer.Append(EGetProtocol);

    iControlSocketWriter->IssueWriteL(iCommandBuffer);

    iCommandIssued = ETrue;

    }

void CBTHidConnection::SetProtocolL(TUint16 aValue)

    {

    LeaveIfCommandNotReadyL();

    iCommandBuffer.Zero();

    // Value should be

    // 0 for boot