/*

* 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 "socketinitiator.h"

#include "sockinitnotifier.h"

#include "timeouttimer.h"

#include "bthidtypes.h"

#include "sockets.pan"

#include "debug.h"

// The transport protocol of the sockets used by this object.

_LIT(KTransportProtocol, "L2CAP");

// 60*2 seconds socket connect time-out (initially this was 10 seconds, but was changed due to end-user feedback)

const TInt CSocketInitiator::KTimeOut = 120000000;

CSocketInitiator* CSocketInitiator::NewL(RSocketServ& aSocketServ,

        MSockInitNotifier& aNotifier)

    {

    CSocketInitiator* self = NewLC(aSocketServ, aNotifier);

    CleanupStack::Pop(self);

    return self;

    }

CSocketInitiator* CSocketInitiator::NewLC(RSocketServ& aSocketServ,

        MSockInitNotifier& aNotifier)

    {

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

            aNotifier);

    CleanupStack::PushL(self);

    self->ConstructL();

    return self;

    }

CSocketInitiator::CSocketInitiator(RSocketServ& aSocketServ,

        MSockInitNotifier& aNotifier) :

    CActive(CActive::EPriorityStandard), iSocketServ(aSocketServ), iNotifier(

            aNotifier), iState(EIdle)

    {

    CActiveScheduler::Add(this);

    }

CSocketInitiator::~CSocketInitiator()

    {

        TRACE_INFO((_L("[BTHID]\tCSocketInitiator::~CSocketInitiator()")));

    Cancel(); // Causes DoCancel

    delete iTimer;

    }

void CSocketInitiator::ConnectSocketsL(const TBTDevAddr& aAddress,

        TBool aUseSecurity, RSocket* aControlSocket,

        RSocket* aInterruptSocket)

    {

        TRACE_INFO((_L("[BTHID]\tCSocketInitiator::ConnectSocketsL")));

    // Store the params for later

    iControlSocket = aControlSocket;

    iInterruptSocket = aInterruptSocket;

    iUseSecurity = aUseSecurity;

    // First close the sockets

    iControlSocket->Close();

    iInterruptSocket->Close();

    // Try to open the sockets as L2CAP

    User::LeaveIfError(iControlSocket->Open(iSocketServ, KTransportProtocol));

    User::LeaveIfError(

            iInterruptSocket->Open(iSocketServ, KTransportProtocol));

    iSockAddress.SetBTAddr(aAddress);

    // First connect the control channel

    iSockAddress.SetPort(KL2CAPHidControl);

    // Set security requirements for the Control channel.

    TBTServiceSecurity sec;

    sec.SetAuthentication(aUseSecurity); //Require authentication

    sec.SetEncryption(aUseSecurity); //and encryption.

    sec.SetAuthorisation(EFalse); //and authorisation (This not needed for out-going connections)

    iSockAddress.SetSecurity(sec);

    // Start a timer to timeout the connect request

    if (!iTimer->IsActive())

        iTimer->After(KTimeOut);

    // Issue the connect request

    iControlSocket->Connect(iSockAddress, iStatus);

    // Update the connect state

    iState = EConnectingControl;

#ifdef __WINS__

    User::After(1); // Fix to allow emulator client to connect to server

#endif

    // Start this active object

    SetActive();

    }

void CSocketInitiator::TimerExpired()

    {

        TRACE_INFO((_L("[BTHID]\tCSocketInitiator::TimerExpired()")));

    // Cancel the operation in progress

    Cancel();

    // Inform the observer of this object that a failure occurred

    // due to a timeout

    iNotifier.SocketsConnFailed(KErrTimedOut);

    }

void CSocketInitiator::ConstructL()

    {

    // Create a timer

    iTimer = CTimeOutTimer::NewL(EPriorityStandard, *this);

    }

void CSocketInitiator::DoCancel()

    {

        TRACE_INFO((_L("[BTHID]\tCSocketInitiator::DoCancel()")));

    // Cancel appropriate request

    switch (iState)

        {

        case EConnectingControl:

            {

            iControlSocket->CancelConnect();

            break;

            }

        case EConnectingInterrupt:

            {

            iInterruptSocket->CancelConnect();

            break;

            }

        default:

            {

            User::Panic(KPanicBTConnection, ESocketsBadStatus);

            break;

            }

        }

    //Close the sockets

    iInterruptSocket->Close();

    iControlSocket->Close();

    // Set the connect state back to idle

    iState = EIdle;

    }

void CSocketInitiator::RunL()

    {

    // Cancel any outstanding timer

    iTimer->Cancel();

    // Any error stops us dead.

    if (iStatus != KErrNone)

        {

        //Close the sockets

        iControlSocket->Close();

        iInterruptSocket->Close();

        // Set the connect state back to idle

        iState = EIdle;

        // Inform the observer that a failure occurred

        iNotifier.SocketsConnFailed(iStatus.Int());

        }

    else

        {

        switch (iState)

            {

            case EConnectingControl:

                {

                    TRACE_INFO((_L("[BTHID]\tCSocketInitiator::RunL(): Control channel connection request")));

                ConnectInterruptSocket();

                }

                break;

            case EConnectingInterrupt:

                // L2CAP Interrupt channel connection request

                // We are connected

                // Set the connect state back to idle

                {

                    TRACE_INFO((_L("[BTHID]\tCSocketInitiator::RunL(): Interrupt channel connection request")));

                iState = EIdle;

                // Inform the observer that connection is complete

                iNotifier.SocketsConnected();

                break;

                }

            default:

                {

                User::Panic(KPanicBTConnection, ESocketsBadState);

                break;

                }

            };

        }

    }

void CSocketInitiator::ConnectInterruptSocket()

    {

        // Connect the interrupt channel.

        TRACE_INFO((_L("[BTHID]\tCSocketInitiator::ConnectInterruptSocket()")));

    ///for BT Stack v2.0, use authentication and encryption

    TBTServiceSecurity sec;

    sec.SetAuthentication(iUseSecurity); // 2nd L2cap channel should need no authentication.

    sec.SetEncryption(iUseSecurity); // but we need encryption.

    iSockAddress.SetSecurity(sec);

    ////

    iSockAddress.SetPort(KL2CAPHidInterrupt);

    // Start a timer to timeout the connect request

    if (!iTimer->IsActive())

        iTimer->After(KTimeOut);

    // Issue the connect request

    iInterruptSocket->Connect(iSockAddress, iStatus);

    // Update the connect state

    iState = EConnectingInterrupt;

#ifdef __WINS__

    User::After(1); // Fix to allow emulator client to connect to server

#endif

    SetActive();

    }