/*

* 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:

*

*/

#include <string>

#include <e32base.h>

#include "logger.h"

#include "fs_methodcall.h"

#include "bluetoothconsts.h"

#include "bluetoothdevicediscoverer.h"

// Constants used to create device class

#define SERVICE_CLASS_POS    13

#define MAJOR_CLASS_POS       8

#define MINOR_CLASS_POS       2

#define SOCKETSERVER_CONNECTED 1

namespace java

{

namespace bluetooth

{

_LIT(KBTLinkManagerTxt,"BTLinkManager");

BluetoothDeviceDiscoverer* BluetoothDeviceDiscoverer::NewL(

    BluetoothFunctionServer *aFunctionServer)

{

    JELOG2(EJavaBluetooth);

    BluetoothDeviceDiscoverer *self = new BluetoothDeviceDiscoverer(

        aFunctionServer);

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    return self;

}

void BluetoothDeviceDiscoverer::ConstructL()

{

    int result = -1;

    User::LeaveIfError(mSocketServerStatus = mSocketServer.Connect());

    mSocketServer.ShareAuto();

    mSocketServerStatus = SOCKETSERVER_CONNECTED;

    result = pthread_mutex_init(&mMutex, 0);

    if (result == 0)

    {

        result = pthread_cond_init(&mCondVar, 0);

    }

    if (0 != result)

    {

        User::Leave(result);

    }

}

BluetoothDeviceDiscoverer::BluetoothDeviceDiscoverer(

    BluetoothFunctionServer *aFunctionServer) :

        CActive(EPriorityStandard)

{

    CActiveScheduler::Add(this);

    mFunctionServer = aFunctionServer;

}

BluetoothDeviceDiscoverer::~BluetoothDeviceDiscoverer()

{

    JELOG2(EJavaBluetooth);

    mHostResolver.Close();

    if (SOCKETSERVER_CONNECTED == mSocketServerStatus)

        mSocketServer.Close();

    clearQueue();

    pthread_mutex_destroy(&mMutex);

    pthread_cond_destroy(&mCondVar);

}

/**

 * Searches for the next device.

 * If found, then returns the discovered device information

 * Otherwise, in case of error or completion, returns INQUIRY_COMAPLETED

 * and in case of cancele, returnsn INQUIRY_TERMINATED

 */

int BluetoothDeviceDiscoverer::getNextDevice(

    DiscoveredDevice &aDiscoveredDevice)

{

    JELOG2(EJavaBluetooth);

    dequeue(aDiscoveredDevice);

    return aDiscoveredDevice.mInquiryStatus;

}

/**

 * Starts the searching for the next device

 */

void BluetoothDeviceDiscoverer::setNext()

{

    JELOG2(EJavaBluetooth);

    if (!IsActive())

    {

        // Get next discovered device

        mHostResolver.Next(mNameEntry, iStatus);

        SetActive();

    }

}

/**

 * Initializes the device inquiry

 */

void BluetoothDeviceDiscoverer::DiscoverDevicesL(int aAccessCode)

{

    JELOG2(EJavaBluetooth);

    TInquirySockAddr inquirySockAddr;

    if (!IsActive())

    {

        LOG(EJavaBluetooth, EInfo,

            "+ BluetoothDeviceDiscoverer::DiscoverDevicesL Finding protocol");

        // Load protocol for discovery

        TProtocolDesc pdesc;

        User::LeaveIfError(mSocketServer.FindProtocol(KBTLinkManagerTxt(),

                           pdesc));

        // Initialize host resolver

        mHostResolver.Close();

        User::LeaveIfError(mHostResolver.Open(mSocketServer, pdesc.iAddrFamily,

                                              pdesc.iProtocol));

        // Start device discovery by invoking remote address lookup

        if (KGIAC == aAccessCode)

            LOG(EJavaBluetooth, EInfo,

                "  BluetoothDeviceDiscoverer::DiscoverDevicesL GIAC");

        else if (KLIAC == aAccessCode)

            LOG(EJavaBluetooth, EInfo,

                "  BluetoothDeviceDiscoverer::DiscoverDevicesL LIAC");

        else

            LOG1(EJavaBluetooth, EInfo,

                 "  BluetoothDeviceDiscoverer::DiscoverDevicesL Val: %X",

                 aAccessCode);

        inquirySockAddr.SetIAC(aAccessCode);

        inquirySockAddr.SetAction(KHostResInquiry | KHostResName

                                  | KHostResIgnoreCache);

        mHostResolver.GetByAddress(inquirySockAddr, mNameEntry, iStatus);

        SetActive();

    }

    else

    {

        ELOG(EJavaBluetooth,

             "- BluetoothDeviceDiscoverer::DiscoverDevicesL Leaving. Not ready!");

        User::Leave(KErrNotReady);

    }

}

void BluetoothDeviceDiscoverer::RunL()

{

    JELOG2(EJavaBluetooth);

    bool continueFlag = false;

    DiscoveredDevice *discoveredDevice = new DiscoveredDevice();

    if (iStatus.Int() == KErrCancel)

    {

        RThread thread;

        int error = thread.Open(mThreadName, EOwnerProcess);

        if (error == KErrNone)

        {

            thread.RequestSignal();

        }

        clearQueue();

        discoveredDevice->mInquiryStatus = INQUIRY_TERMINATED;

    }

    else if (KErrNone == iStatus.Int())

    {

        fillDeviceInfo(*discoveredDevice);

        continueFlag = true;

    }

    else

    {

        discoveredDevice->mInquiryStatus = INQUIRY_COMPLETED;

    }

    discoveredDevice->mErrVal = iStatus.Int();

    enqueue(discoveredDevice);

    if (continueFlag)

    {

        setNext();

    }

}

void BluetoothDeviceDiscoverer::DoCancel()

{

    JELOG2(EJavaBluetooth);

    RThread thread;

    thread.FullName(mThreadName);

    mHostResolver.Cancel();

}

/**

 * Fills the discovered device information into DiscoveredDevice object

 */

void BluetoothDeviceDiscoverer::fillDeviceInfo(

    DiscoveredDevice &aDiscoveredDevice)

{

    JELOG2(EJavaBluetooth);

    // Filling inquiry status

    aDiscoveredDevice.mInquiryStatus = STATUS_DEVICE_FOUND;

    // Filling device name

    std::wstring *deviceName = new std::wstring(

        (wchar_t*) mNameEntry().iName.Ptr());

    deviceName->resize(mNameEntry().iName.Length());

    aDiscoveredDevice.mDeviceName = deviceName;

    LOG1(EJavaBluetooth, EInfo,

         "  BluetoothDeviceDiscoverer::fillDeviceInfo Device Name %S",

         deviceName->c_str());

    // Filling device address

    TBTDevAddr add = static_cast<TBTSockAddr>(mNameEntry().iAddr).BTAddr();

    TBuf<20> buff;

    add.GetReadable(buff);

    std::wstring *deviceAddr = new std::wstring((wchar_t*) buff.Ptr());

    deviceAddr->resize(buff.Length());

    aDiscoveredDevice.mDeviceAddr = deviceAddr;

    LOG1(EJavaBluetooth, EInfo,

         "  BluetoothDeviceDiscoverer::fillDeviceInfo Device Address %S",

         deviceAddr->c_str());

    // Filling device class

    TInquirySockAddr& dev = TInquirySockAddr::Cast(mNameEntry().iAddr);

    int deviceClass = (dev.MajorServiceClass() << SERVICE_CLASS_POS)

                      | (dev.MajorClassOfDevice() << MAJOR_CLASS_POS)

                      | (dev.MajorClassOfDevice() << MINOR_CLASS_POS);

    aDiscoveredDevice.mDeviceClass = deviceClass;

    LOG1(EJavaBluetooth, EInfo,

         "  BluetoothDeviceDiscoverer::fillDeviceInfo DeviceClass %d",

         deviceClass);

}

void BluetoothDeviceDiscoverer::enqueue(DiscoveredDevice *aDiscoveredDevice)

{

    JELOG2(EJavaBluetooth);

    pthread_mutex_lock(&mMutex);

    mDiscoveredDevicesQueue.push(aDiscoveredDevice);

    if (mWaiting)

    {

        LOG(EJavaBluetooth, EInfo,

            "- BluetoothDeviceDiscoverer::enqueue NOTIFYING");

        pthread_cond_signal(&mCondVar);

    }

    mWaiting = false;

    pthread_mutex_unlock(&mMutex);

}

void BluetoothDeviceDiscoverer::dequeue(DiscoveredDevice& aDiscoveredDevice)

{

    JELOG2(EJavaBluetooth);

    LOG1(EJavaBluetooth, EInfo, "+ BluetoothDeviceDiscoverer::dequeue :%d",

         mDiscoveredDevicesQueue.empty());

    DiscoveredDevice ret;

    pthread_mutex_lock(&mMutex);

    if (mDiscoveredDevicesQueue.empty())

    {

        LOG(EJavaBluetooth, EInfo,

            "- BluetoothDeviceDiscoverer::dequeue WAITING");

        mWaiting = true;

        while (mWaiting)

        {

            pthread_cond_wait(&mCondVar, &mMutex);

        }

    }

    DiscoveredDevice *ptr = mDiscoveredDevicesQueue.front();

    aDiscoveredDevice = *ptr;

    delete ptr;   // pop doesn't invoke the destructor

    mDiscoveredDevicesQueue.pop();

    pthread_mutex_unlock(&mMutex);

}

void BluetoothDeviceDiscoverer::clearQueue()

{

    JELOG2(EJavaBluetooth);

    pthread_mutex_lock(&mMutex);

    while (!mDiscoveredDevicesQueue.empty())

    {

        mDiscoveredDevicesQueue.pop();

    }

    pthread_mutex_unlock(&mMutex);

}

} //end namespace java

} //end namespace bluetooth