TnbCeBluetooth.h

[詳解]

#pragma once
#include "TnbCeBluetoothApi.h"
#include "TnbStrVector.h"
#include "TnbRegistryAccessor.h"
#include "TnbTickCount.h"
 
 
 
//TNB Library
namespace TNB{
 
 
 
#ifdef _TnbDOXYGEN  //Document作成用シンボル
typedef ULONGLONG BT_ADDR;
 
typedef unsigned short BT_HANDLE;
#else 
 #define BT_HANDLE unsigned short
#endif
 
 
 
class CBluetoothLinkKey
{
public:
 
    CBluetoothLinkKey(void)
    {
        Zero(m_key);
    }
 
    BYTE* Refer(void)
    {
        return m_key;
    }
 
    const BYTE* Refer(void) const
    {
        return m_key;
    }
 
    BYTE& operator[](INDEX index)
    {
        ASSERT( index < 16 );
        return m_key[index];
    }
 
    const BYTE& operator[](INDEX index) const
    {
        ASSERT( index < 16 );
        return m_key[index];
    }
 
private:
    BYTE    m_key[16]; 
};
 
 
 
class CBluetoothClass
{
public:
 
    enum EServiceClass
    {
        //Limited Discoverable Mode 0x0001,
        Positioning     = 0x0008,       
        Networking      = 0x0010,       
        Rendering       = 0x0020,       
        Capturing       = 0x0040,       
        ObjectTransfer  = 0x0080,       
        Audio           = 0x0100,       
        Telephony       = 0x0200,       
        Information     = 0x0400,       
    };
 
    enum EMajorDeviceClass
    {
        Miscellaneous   = 0x00,     
        Computer        = 0x01,     
        Phone           = 0x02,     
        Network         = 0x03,     
        AV              = 0x04,     
        Peripheral      = 0x05,     
        Imaging         = 0x06,     
    };
 
 
    //----------------
 
 
    CBluetoothClass(DWORD cod = 0)
    {
        m_class.cod = cod;
    }
 
    operator DWORD(void) const
    {
        return m_class.cod;
    }
 
    DWORD GetDeviceClass(void) const
    {
        return m_class.cod;
    }
 
    DWORD GetServiceClass(void) const
    {
        return m_class.serviceClass;
    }
 
    void SetServiceClass(DWORD c)
    {
        m_class.serviceClass = c;
    }
 
    DWORD GetMajorDeviceClass(void) const
    {
        return m_class.majorDeviceClass;
    }
 
    void SetMajorDeviceClass(DWORD c)
    {
        m_class.majorDeviceClass = c;
    }
 
    LPCTSTR GetMajorDeviceClassName(void) const
    {
        switch ( GetMajorDeviceClass() )
        {
        case Miscellaneous: return _T("Miscellaneous");
        case Computer:      return _T("Computer");
        case Phone:         return _T("Phone");
        case Network:       return _T("Network");
        case AV:            return _T("Audio/Video");
        case Peripheral:    return _T("Peripheral");
        case Imaging:       return _T("Imaging");
        }
        return _T("");
    }
 
    DWORD GetMinorDeviceClass(void) const
    {
        return m_class.minorDeviceClass;
    }
 
    void SetMinorDeviceClass(DWORD c)
    {
        m_class.minorDeviceClass = c;
    }
 
    LPCTSTR GetMinorDeviceClassName(void) const
    {
        switch ( GetMajorDeviceClass() )
        {
        case Computer:      return m_ComputerDeviceClassName();
        case Phone:         return m_PhoneDeviceClassName();
        case AV:            return m_AvDeviceClassName();
        case Peripheral:    return m_PeripheralDeviceClassName();
        case Imaging:       return m_ImagingDeviceClassName();
        }
        return _T("");
    }
 
private:
    LPCTSTR m_ComputerDeviceClassName(void) const
    {
        ASSERT ( GetMajorDeviceClass() == Computer );
        switch ( GetMinorDeviceClass() )
        {
        case 0: return _T("Unclassified");
        case 1: return _T("Desktop Computer");
        case 2: return _T("Server Computer");
        case 3: return _T("Laptop Computer");
        case 4: return _T("Handled Computer");
        case 5: return _T("Palm Computer");
        case 6: return _T("Wearable Computer");
        }
        return _T("");
    }
    LPCTSTR m_PhoneDeviceClassName(void) const
    {
        ASSERT ( GetMajorDeviceClass() == Phone );
        switch ( GetMinorDeviceClass() )
        {
        case 0:     return _T("Unclassified");
        case 1:     return _T("Cellular Phone");
        case 2:     return _T("Cordless Phone");
        case 3:     return _T("Smartphone");
        case 4:     return _T("Modem");
        case 5:     return _T("ISDN Phone");
        }
        return _T("");
    }
    LPCTSTR m_AvDeviceClassName(void) const
    {
        ASSERT ( GetMajorDeviceClass() == AV );
        switch ( GetMinorDeviceClass() )
        {
        case 0:     return _T("Unclassified");
        case 1:     return _T("Headset");
        case 2:     return _T("Handsfree");
        case 4:     return _T("Microphone");
        case 5:     return _T("Loudspeaker");
        case 6:     return _T("Headphone");
        case 7:     return _T("Portable Audio");
        case 8:     return _T("Car Audio");
        case 9:     return _T("Set Top Box");
        case 10:    return _T("Hifi Audio");
        case 11:    return _T("VCR");
        case 12:    return _T("Video Camera");
        case 13:    return _T("Camcoder");
        case 14:    return _T("Video Monitor");
        case 15:    return _T("Video Display & Loundspeaker");
        case 16:    return _T("Video Conferencing");
        case 18:    return _T("Gaiming Toy");
        }
        return _T("");
    }
    LPCTSTR m_PeripheralDeviceClassName(void) const
    {
        ASSERT ( GetMajorDeviceClass() == Peripheral );
        DWORD c = GetMinorDeviceClass();
        switch ( c & 0x3F )
        {
        case 0:     break;
        case 1:     return _T("Joystick");
        case 2:     return _T("Gamepad");
        case 3:     break;//return _T("Remote Control");
        case 4:     return _T("Sensing Device");
        case 5:     return _T("Digitizer Tablet");
        case 6:     return _T("Card Reader");
        }
        switch ( c & 0xC0 )
        {
        case 0x00:/*Unclassified*/  return _T("Unclassified");
        case 0x40:/*Keyboard*/      return _T("Keyboard");
        case 0x80:/*Pointer*/       return _T("Pointer");
        case 0xC0:/*Combo*/         return _T("Combo Device");
        }
        return _T("");
    }
    LPCTSTR m_ImagingDeviceClassName(void) const
    {
        ASSERT ( GetMajorDeviceClass() == Imaging );
        #if 0
            switch ( GetMinorDeviceClass() )
            {
            #define RX_COD_MINOR_IMAJING_DISPLAY_MASK  0x10
            #define RX_COD_MINOR_IMAJING_CAMERA_MASK   0x20
            #define RX_COD_MINOR_IMAJING_SCANNER_MASK  0x40
            #define RX_COD_MINOR_IMAJING_PRINTER_MASK  0x80
            }
        #endif
        return _T("");
    }
    //
    union
    {
        DWORD       cod;    
        struct
        {
            DWORD   formatType      :2;     
            DWORD   minorDeviceClass:6;     
            DWORD   majorDeviceClass:5;     
            DWORD   serviceClass    :11;    
            DWORD   padding         :8;     
        };
    } m_class;  
};
 
 
 
class CBluetoothServiceAttribute : CCopyImpossible
{
public:
 
    struct TValue
    {
        SDP_TYPE            type;   
        SDP_SPECIFICTYPE    spec;   
        union
        {
            SDP_LARGE_INTEGER_16    int128;     
            SDP_ULARGE_INTEGER_16   uint128;    
            GUID                    uuid128;    
            DWORD                   uuid32;     
            WORD                    uuid16;     
            LONGLONG                int64;      
            ULONGLONG               uint64;     
            LONG                    int32;      
            DWORD                   uint32;     
            SHORT                   int16;      
            WORD                    uint16;     
            CHAR                    int8;       
            BYTE                    uint8;      
            bool                    booleanVal; 
        };
        CAscii                      str;        
 
        TValue(SDP_TYPE t = SDP_TYPE_NIL, SDP_SPECIFICTYPE s = SDP_ST_NONE) : type(t), spec(s)
        {
            Zero(int128);
        }
 
        CStr ToString(CStr* pType = NULL) const
        {
            CStr value;
            CStr typeName;
            switch ( type )
            {
            case SDP_TYPE_NIL:
                break;
            case SDP_TYPE_UINT:
            case SDP_TYPE_INT:
            case SDP_TYPE_UUID:
                switch ( spec )
                {
                case SDP_ST_UINT8:
                    value.Format(_T("0x%02X"), uint8);
                    typeName = _T("UINT8");
                    break;
                case SDP_ST_UINT16:
                    value.Format(_T("0x%04X"), uint16);
                    typeName = _T("UINT16");
                    break;
                case SDP_ST_UINT32:
                    value.Format(_T("0x%08X"), uint32);
                    typeName = _T("UINT32");
                    break;
                case SDP_ST_UINT64:
                    value.Format(_T("0x%16I64X"), uint64);
                    typeName = _T("UINT64");
                    break;
                case SDP_ST_UINT128:
                    value.Format(_T("0x%16I64X%16I64X"), uint128.HighPart, uint128.LowPart);
                    typeName = _T("UINT128");
                    break;
                case SDP_ST_INT8:
                    value.Format(_T("%d"), int8);
                    typeName = _T("INT8");
                    break;
                case SDP_ST_INT16:
                    value.Format(_T("%d"), int16);
                    typeName = _T("INT16");
                    break;
                case SDP_ST_INT32:
                    value.Format(_T("%d"), int32);
                    typeName = _T("INT32");
                    break;
                case SDP_ST_INT64:
                    value.Format(_T("%16I64d\n"), int64);
                    typeName = _T("INT64");
                    break;
                case SDP_ST_INT128:
                    value.Format(_T("0x%16I64X%16I64X"), int128.HighPart, int128.LowPart);
                    typeName = _T("INT128");
                    break;
                case SDP_ST_UUID16:
                    value.Format(_T("0x%04X"), uint16);
                    typeName = _T("UUID16");
                    break;
                case SDP_ST_UUID32:
                    value.Format(_T("0x%08X"), uint32);
                    typeName = _T("UUID32");
                    break;
                case SDP_ST_UUID128:
                    value.Format(_T("%08X-%04X-%04X-%02X%02X%02X%02X%02X%02X%02X%02X")
                        , uuid128.Data1, uuid128.Data2, uuid128.Data3
                        , uuid128.Data4[0], uuid128.Data4[1], uuid128.Data4[2], uuid128.Data4[3]
                        , uuid128.Data4[4], uuid128.Data4[5], uuid128.Data4[6], uuid128.Data4[7]);
                    typeName = _T("UUID128");
                    break;
                default:
                    ASSERT( false );
                    break;
                }
                break;
            case SDP_TYPE_BOOLEAN:
                value = booleanVal ? _T("true") : _T("false");
                typeName = _T("BOOL");
                break;
            case SDP_TYPE_STRING:
                value = str;
                typeName = _T("STRING");
                break;
            case SDP_TYPE_URL:
                value = str;
                typeName = _T("URL");
                break;
            default:
                ASSERT( false );
                break;
            }
            if ( pType != NULL )
            {
                *pType = typeName;
            }
            return value;
        }
    };
 
    typedef CVectorT<WORD> TIdsList;
    typedef CVectorT<TValue> TValuesList;
 
 
    //----------------------------
 
 
    CBluetoothServiceAttribute(void) : m_ppSdpRecords(NULL), m_numRecords(0), m_lastResult(S_OK)
    {
        ::CoInitializeEx(NULL, COINIT_MULTITHREADED);
    }
    
    ~CBluetoothServiceAttribute(void)
    {
        Free();
    }
 
    void Free(void)
    {
        if ( m_ppSdpRecords != NULL )
        {
            loop ( i, m_numRecords )
            {
                m_ppSdpRecords[i]->Release();
            }
            BYTE* B = reinterpret_cast<BYTE*>(m_ppSdpRecords);
            delete[] B;
            m_ppSdpRecords = NULL;
            m_numRecords = 0;
        }
    }
 
    bool IsValid(void) const
    {
        return m_ppSdpRecords != NULL;
    }
 
    size_t GetRecordCount(void) const
    {
        return m_numRecords;
    }
 
    HRESULT GetLastResult(void) const
    {
        return m_lastResult;
    }
 
    bool Analyze(size_t size, LPCVOID lpRawData)
    {
        CWorkMem raw;
        raw.Reset(size, static_cast<const BYTE*>(lpRawData));
        Free();
        ISdpStream* pIStream = NULL;
        HRESULT hr = ::CoCreateInstance(__uuidof(SdpStream), NULL, CLSCTX_INPROC_SERVER
                                , __uuidof(ISdpStream), reinterpret_cast<LPVOID*>(&pIStream));
        if ( SUCCEEDED(hr) )
        {
            ULONG ulError;
            hr = pIStream->Validate(raw.Ref(), raw.GetSize(), &ulError);
            if ( SUCCEEDED(hr) )
            {
                hr = pIStream->VerifySequenceOf(raw.Ref(), raw.GetSize(), SDP_TYPE_SEQUENCE, NULL, &m_numRecords);
                if ( SUCCEEDED(hr) )
                {
                    ASSERT( m_numRecords > 0 );
                    BYTE* B = new BYTE[sizeof(ISdpRecord*) * m_numRecords];
                    m_ppSdpRecords = reinterpret_cast<ISdpRecord**>(B);
                    ASSERT( m_ppSdpRecords != NULL );
                    hr = pIStream->RetrieveRecords(raw.Ref(), raw.GetSize(), m_ppSdpRecords, &m_numRecords);
                }
            }
            pIStream->Release();
            pIStream = NULL;
        }
        if ( ! m_Res(hr) )
        {
            Free();
            return false;
        }
        if ( m_numRecords == 0 )
        {
            return m_Res(E_FAIL);
        }
        return SearchRecord(0);
    }
 
    bool SearchRecord(INDEX record)
    {
        if ( record < m_numRecords )
        {
            return m_CheckRecord(m_ppSdpRecords[record]);
        }
        m_attrIds.RemoveAll();
        m_attrDetails.RemoveAll();
        return false;
    }
 
    bool HasAttribute(WORD attributeId) const
    {
        return m_attrIds.Find(attributeId) != INVALID_INDEX;
    }
 
    const TIdsList& GetAttributeIdList(void) const
    {
        return m_attrIds;
    }
 
    const TValuesList& GetAttributeData(WORD attributeId) const
    {
        INDEX f = m_attrIds.Find(attributeId);
        if ( f != INVALID_INDEX )
        {
            return m_attrDetails[f];
        }
        return m_dummy;
    }
 
    CStrVector GetAttributeString(void) const
    {
        CStrVector vs;
        loop ( i, m_attrDetails )
        {
            const TValuesList& list = m_attrDetails[i];
            loop ( i, list )
            {
                SDP_TYPE s = list[i].type;
                if ( s == SDP_TYPE_STRING || s == SDP_TYPE_URL )
                {
                    vs.Add(CStr(list[i].str));
                }
            }
        }
        return vs;
    }
    
private:
    TIdsList                m_attrIds;          
    CVectorT<TValuesList>   m_attrDetails;      
    TValuesList             m_dummy;            
    ISdpRecord**            m_ppSdpRecords;     
    ULONG                   m_numRecords;       
    HRESULT                 m_lastResult;       
    bool m_CheckRecord(ISdpRecord* pRecord)
    {
        WORD* pList = NULL;
        ULONG listSize = 0;
        m_attrIds.RemoveAll();
        m_attrDetails.RemoveAll();
        HRESULT hr = pRecord->GetAttributeList(&pList, &listSize);
        if ( SUCCEEDED(hr) )
        {
            m_attrIds.SetSize(listSize);
            m_attrDetails.SetSize(listSize);
            loop ( i, listSize )
            {
                BYTE* pStream = NULL;
                ULONG size = 0;
                WORD aid = pList[i];
                m_attrIds[i] = aid;
                hr = pRecord->GetAttributeAsStream(aid, &pStream, &size);
                if ( SUCCEEDED(hr) )
                {
                    TTRACE1("Attrib ID %04X\n", aid);
                    hr = m_CheckSub(m_attrDetails[i], pStream, size);
                }
                if ( pStream != NULL )
                {
                    ::CoTaskMemFree(pStream);
                }
                if ( ! SUCCEEDED(hr) )
                {
                    break;
                }
            }
        }
        if ( pList != NULL )
        {
            ::CoTaskMemFree(pList);
        }
        return m_Res(hr);
    }
    void m_CheckSubUint(TValue& _val, SDP_SPECIFICTYPE specType, BYTE* pSubElement, ISdpStream* pSdpStream)
    {
        switch ( specType )
        {
        case SDP_ST_UINT8:
            _val.uint8 = *pSubElement;
            break;
        case SDP_ST_UINT16:
            pSdpStream->RetrieveUint16(pSubElement, &_val.uint16);
            _val.uint16 = SwapEndian(_val.uint16);
            break;
        case SDP_ST_UINT32:
            pSdpStream->RetrieveUint32(pSubElement, &_val.uint32);
            _val.uint32 = SwapEndian(_val.uint32);
            break;
        case SDP_ST_UINT64:
            pSdpStream->RetrieveUint64(pSubElement, &_val.uint64);
            _val.uint64 = SwapEndian(_val.uint64);
            break;
        case SDP_ST_UINT128:
            pSdpStream->RetrieveUint128(pSubElement, &_val.uint128);
            _val.uint128.LowPart  = SwapEndian(_val.uint128.LowPart);
            _val.uint128.HighPart = SwapEndian(_val.uint128.HighPart);
            break;
        default:
            ASSERT( false );
            break;
        }
    }
    void m_CheckSubInt(TValue& _val, SDP_SPECIFICTYPE specType, BYTE* pSubElement, ISdpStream* pSdpStream)
    {
        switch ( specType )
        {
        case SDP_ST_INT8:
            _val.int8 = *pSubElement;
            break;
        case SDP_ST_INT16:
            pSdpStream->RetrieveInt16(pSubElement, &_val.int16);
            _val.int16 = SwapEndian(static_cast<WORD>(_val.int16));
            break;
        case SDP_ST_INT32:
            pSdpStream->RetrieveInt32(pSubElement, &_val.int32);
            _val.int32 = SwapEndian(static_cast<DWORD>(_val.int32));
            break;
        case SDP_ST_INT64:
            pSdpStream->RetrieveInt64(pSubElement, &_val.int64);
            _val.int64 = SwapEndian(static_cast<ULONGLONG>(_val.int64));
            break;
        case SDP_ST_INT128:
            pSdpStream->RetrieveInt128(pSubElement, &_val.int128);
            _val.int128.LowPart  = SwapEndian(static_cast<ULONGLONG>(_val.int128.LowPart));
            _val.int128.HighPart = SwapEndian(static_cast<ULONGLONG>(_val.int128.HighPart));
            break;
        default:
            ASSERT( false );
            break;
        }
    }
    void m_CheckSubUuid(TValue& _val, SDP_SPECIFICTYPE specType, BYTE* pSubElement, ISdpStream* pSdpStream)
    {
        switch ( specType )
        {
        case SDP_ST_UUID16:
            pSdpStream->RetrieveUint16(pSubElement, &_val.uuid16);
            _val.uuid16 = SwapEndian(_val.uuid16);
            break;
        case SDP_ST_UUID32:
            pSdpStream->RetrieveUint32(pSubElement, &_val.uuid32);
            _val.uuid32 = SwapEndian(_val.uuid32);
            break;
        case SDP_ST_UUID128:
            pSdpStream->RetrieveUuid128(pSubElement, &_val.uuid128);
            _val.uuid128.Data1 = SwapEndian(_val.uuid128.Data1);
            _val.uuid128.Data2 = SwapEndian(_val.uuid128.Data2);
            _val.uuid128.Data3 = SwapEndian(_val.uuid128.Data3);
            break;
        default:
            ASSERT( false );
            break;
        }
    }
    bool m_CheckSub(TValuesList& _list, BYTE* pStream, ULONG size)
    {
        ISdpStream* pSdpStream = NULL;
        if ( ! m_LoadAndValidate(&pSdpStream, &pStream, &size) )
        {
            return false;
        }
        HRESULT hr = E_FAIL;
        while ( size > 0 )
        {
            SDP_TYPE type;
            SDP_SPECIFICTYPE specType;
            ULONG recordSize;
            ULONG storageSize;
            BYTE* pSubElement = NULL;
            hr = pSdpStream->RetrieveElementInfo(pStream, &type, &specType, &recordSize, &storageSize, &pSubElement);
            ASSERT( SUCCEEDED(hr) );
            if ( type == SDP_TYPE_SEQUENCE || type == SDP_TYPE_ALTERNATIVE )
            {
                if ( ! m_CheckSub(_list, pSubElement, recordSize) )
                {
                    return false;
                }
            }
            else 
            {
                TValue val(type, specType);
                switch ( type )
                {
                case SDP_TYPE_NIL:
                    break;
                case SDP_TYPE_UINT:
                    m_CheckSubUint(val, specType, pSubElement, pSdpStream);
                    break;
                case SDP_TYPE_INT:
                    m_CheckSubInt(val, specType, pSubElement, pSdpStream);
                    break;
                case SDP_TYPE_UUID:
                    m_CheckSubUuid(val, specType, pSubElement, pSdpStream);
                    break;
                case SDP_TYPE_BOOLEAN:
                    val.booleanVal = ((*pSubElement) != 0);
                    break;
                case SDP_TYPE_STRING:
                    val.str.SetFromLeft(reinterpret_cast<LPCSTR>(pSubElement), recordSize);
                    break;
                case SDP_TYPE_URL:
                    val.str.SetFromLeft(reinterpret_cast<LPCSTR>(pSubElement), recordSize);
                    break;
                default:
                    val.type = SDP_TYPE_NIL;
                    break;
                }
                if ( val.type != SDP_TYPE_NIL )
                {
                    #ifdef _DEBUG
                        CStr type;
                        CStr va = val.ToString(&type);
                        TTRACE2("  %s: %s\n", type, va);
                    #endif
                    _list.Add(val);
                }
            }
            recordSize += 1 + storageSize;
            pStream += recordSize;
            size -= recordSize;
        }
        pSdpStream->Release();
        return m_Res(hr);
    }
    bool m_LoadAndValidate(ISdpStream **ppSdpStream, BYTE **ppStream, ULONG *pSize)
    {
        HRESULT hr = ::CoCreateInstance(__uuidof(SdpStream), NULL, CLSCTX_INPROC_SERVER
                                , __uuidof(ISdpStream), reinterpret_cast<LPVOID*>(ppSdpStream));
        if ( SUCCEEDED(hr) )
        {
            ULONG_PTR sdpError;
            ASSERT( *ppSdpStream != NULL );
            hr = (*ppSdpStream)->Validate(*ppStream, *pSize, &sdpError);
        }
        return m_Res(hr);
    }
    bool m_Res(HRESULT hr)
    {
        m_lastResult = hr;
        return SUCCEEDED(hr);
    }
};
 
 
 
class CBluetoothAddress
{
public:
 
    CBluetoothAddress(BT_ADDR btAddr = 0) : m_btAddr(btAddr)
    {
    }
 
    CBluetoothAddress(const CBluetoothAddress& other)
    {
        m_btAddr = other.m_btAddr;
    }
 
    CBluetoothAddress& operator=(const CBluetoothAddress& other)
    {
        m_btAddr = other.m_btAddr;
        return *this;
    }
 
    bool IsValid(void) const
    {
        return m_btAddr != 0;
    }
 
    operator const BT_ADDR&(void) const
    {
        return m_btAddr;
    }
 
    const BT_ADDR& GetAddress(void) const
    {
        return m_btAddr;
    }
 
    CStr GetAddressString(void) const
    {
        CStr str;
        loop ( i, 6 )
        {
            if ( i != 0 )
            {
                str += _T(":");
            }
            str += CStr::Fmt(_T("%02X"), (m_btAddr >> ((5 - i) * 8)) & 0xFF);
        }
        return str;
    }
 
    bool SetAddressString(LPCTSTR lpszAddress)
    {
        BT_ADDR a = 0;
        if ( STRLIB::GetLen(lpszAddress) == 6 * 2 + 5 )
        {
            loop ( i, 5 )
            {
                if ( lpszAddress[i * 3 + 2] != ':' )
                {
                    return false;
                }
            }
            loop ( i, 6 )
            {
                LONGLONG r = m_ToInt(&lpszAddress[i * 3]);
                if ( r < 0 || r > 255 )
                {
                    return false;
                }
                a += r << ((5 - i) * 8);
            }
            m_btAddr = a;
            return true;
        }
        return false;
    }
 
protected:
    BT_ADDR     m_btAddr;       
 
private:
    // int化
    int m_ToInt(LPCTSTR lpsz) const
    {
        int i1 = STRLIB::HexCharToInt(lpsz[0]);
        int i2 = STRLIB::HexCharToInt(lpsz[1]);
        if ( i1 >= 0 && i2 >= 0 )
        {
            return i1 << 4 | i2;
        }
        return -1;
    }
};
 
 
 
class CBluetoothLocal : private CBluetoothApi
{
    DEFSUPER(CBluetoothApi);
public:
 
    CBluetoothLocal(void)
    {
    }
 
    bool GetAddress(CBluetoothAddress& _addr) const
    {
        BT_ADDR ba;
        bool r = m_Ret(BthReadLocalAddr(&ba));
        if ( r )
        {
            _addr = ba;
        }
        return r;
    }
 
    CStr GetName(void) const
    {
        CRegistryAccessor reg(HKEY_LOCAL_MACHINE, KEY_QUERY_VALUE);
        return reg[_T("Ident")].QueryString(_T("Name"));
    }
 
    bool SetName(LPCTSTR lpszName)
    {
        CRegistryAccessor reg(HKEY_LOCAL_MACHINE);
        return reg[_T("Ident")].WriteString(_T("Name"), lpszName);
    }
 
    bool GetClass(CBluetoothClass& _class) const
    {
        UINT cl = 0;
        bool r = m_Ret(BthReadCOD(&cl));
        _class = cl;
        return r;
    }
 
    bool SetClass(const CBluetoothClass& clas)
    {
        UINT cl = clas.GetDeviceClass();
        return m_Ret(BthWriteCOD(cl));
    }
 
    bool EnableAuthentication(bool isEnable)
    {
        return m_Ret(BthWriteAuthenticationEnable(isEnable ? 1 : 0));
    }
 
    bool IsEnabledAuthentication(bool& _isEnabled) const
    {
        BYTE ae;
        bool r = m_Ret(BthReadAuthenticationEnable(&ae));
        if ( r )
        {
            _isEnabled = (ae != 0);
        }
        return r;
    }
    
    enum EMode
    {
        PowerOff            = -1,   
        DisabledAll         = 0,    
        EnabledInquiry      = 1,    
        EnabledPageScan     = 2,    
        EnabledAll          = 3,    
    };
 
    bool GetMode(EMode& _mode) const
    {
        DWORD mode = 0;
        BYTE mask = 0;
        int r = BthGetMode(&mode);
        if ( r == ERROR_SUCCESS )
        {
            if ( mode == BTH_POWER_OFF )
            {
                _mode = PowerOff;
            }
            else
            {
                r = BthReadScanEnableMask(&mask);
                if ( r == ERROR_SUCCESS )
                {
                    ASSERT( mask >= 0 && mask <= 3 );
                    _mode = static_cast<EMode>(mask);
                }
            }
        }
        return m_Ret(r);
    }
 
    bool SetMode(EMode mode, DWORD timeout = 3000)
    {
        int e = ERROR_SUCCESS;
        if ( mode == PowerOff )
        {
            e = BthSetMode(BTH_POWER_OFF);
        }
        else
        {
            int status;
            e = BthGetHardwareStatus(&status);
            if ( e == ERROR_SUCCESS && status == HCI_HARDWARE_NOT_PRESENT )
            {
                e = ERROR_DEVICE_NOT_CONNECTED;
            }
            if ( e == ERROR_SUCCESS )
            {
                e = BthSetMode(BTH_DISCOVERABLE);
            }
            if ( e == ERROR_SUCCESS )
            {
                e = ERROR_TIMEOUT;
                CTickCount tick;
                do
                {
                    int e1 = BthGetHardwareStatus(&status);
                    if ( e1 != ERROR_SUCCESS )
                    {
                        e = e1;
                        break;
                    }
                    if ( status == HCI_HARDWARE_RUNNING )
                    {
                        e = BthWriteScanEnableMask(mode);
                        break;
                    }
                    ::Sleep(10);
                }
                while( ! tick.IsPassed(timeout) );
            }
        }
        return m_Ret(e);
    }
 
    bool GetPageTimeout(DWORD& _timeout) const
    {
        WORD ot = 0;
        bool r = m_Ret(BthReadPageTimeout(&ot));
        if ( r )
        {
            _timeout = ot;
        }
        return r;
    }
 
    bool SetPageTimeout(DWORD timeout)
    {
        WORD ot = static_cast<WORD>(timeout);
        return m_Ret(BthWritePageTimeout(ot));
    }
 
    bool GetPageTimeoutMs(DWORD& _timeout) const
    {
        DWORD v = 0;
        bool r = GetPageTimeout(v);
        if ( r )
        {
            double d = v;
            _timeout = static_cast<DWORD>(d * .625);
        }
        return r;
    }
 
    bool SetPageTimeoutMs(DWORD timeout)
    {
        double d = static_cast<double>(timeout);
        return SetPageTimeout(static_cast<DWORD>(d / .625));
    }
 
    int GetStatus(void) const
    {
        int s = HCI_HARDWARE_UNKNOWN;
        int e = BthGetHardwareStatus(&s);
        if ( e == ERROR_SUCCESS && s == HCI_HARDWARE_UNKNOWN )
        {
            e = ERROR_SERVICE_NOT_ACTIVE;
        }
        ::SetLastError(e);
        return s;
    }
 
    bool TerminateIdleConnections(void)
    {
        return m_Ret(BthTerminateIdleConnections());
    }
 
    bool SetInquiryFilter(const CBluetoothAddress& addr)
    {
        BT_ADDR ba = addr;
        return m_Ret(BthSetInquiryFilter(&ba));
    }
 
    bool ClearInquiryFilter(void)
    {
        return m_Ret(BthClearInquiryFilter());
    }
 
    CVectorT<BthInquiryResult> Inquiry(DWORD timeout = 1000) const
    {
        CVectorT<BthInquiryResult> vb;
        const UINT LAP = 0x9e8b33; // GIAC_LAP
        DWORD length = timeout / 1280;
        if ( length == 0 )
        {
            length = 1;
        }
        if ( length > 0x30 )
        {
            length = 0x30;
        }
        UINT got = 0;
        CWorkMemT<BthInquiryResult> ir(256);
        bool r = m_Ret(BthPerformInquiry(LAP, static_cast<BYTE>(length), 0, 256, &got, ir));
        if ( r )
        {
            vb.CopyElements(got, ir);
        }
        else
        {
            vb.Invalid();
        }
        return vb;
    }
};
 
 
 
class CBluetoothDevice : public CBluetoothAddress, private CBluetoothApi
{
    DEFSUPER(CBluetoothAddress);
public:
 
    CBluetoothDevice(const BT_ADDR& btAddr = 0) : _super(btAddr)
    {
    }
 
    CBluetoothDevice(BT_HANDLE btHandle)
    {
        if ( BthGetAddress(btHandle, &m_btAddr) != ERROR_SUCCESS )
        {
            m_btAddr = 0;
        }
    }
 
    CBluetoothDevice(const CBluetoothDevice& other)
    {
        m_btAddr = other.m_btAddr;
    }
 
    CBluetoothDevice& operator=(const CBluetoothDevice& other)
    {
        m_btAddr = other.m_btAddr;
        return *this;
    }
 
    struct TVersion
    {
        BYTE version;       
        WORD subVersion;    
        WORD manufacturer;  
        BYTE features;      
    };
 
    bool GetVersion(TVersion& _version)
    {
        BT_HANDLE h = CreateAclConnection();
        int e = BthReadRemoteVersion(&m_btAddr, 
                &_version.version, &_version.subVersion, &_version.manufacturer, &_version.features);
        if ( h != NULL )
        {
            CloseConnection(h);
        }
        return m_Ret(e);
    }
 
    bool IsExist(void) const
    {
        return ! GetName().IsEmpty();
    }
 
    bool GetClass(CBluetoothClass& _class) const
    {
        UINT cl = 0;
        BT_ADDR ba = m_btAddr;
        bool r = m_Ret(BthGetRemoteCOD(&ba, &cl));
        _class = cl;
        return r;
    }
 
    bool GetClassEx(CBluetoothClass& _class)
    {
        bool r = GetClass(_class);
        if ( ! r && ::GetLastError() == ERROR_NOT_FOUND )
        {
            BT_HANDLE h = CreateAclConnection();
            r = GetClass(_class);
            CloseConnection(h);
        }
        return r;
    }
 
    CStr GetName(void) const
    {
        BT_ADDR ba = m_btAddr;
        CUnicode str;
        const int len = 1024;
        UINT requ = 0;
        bool r = m_Ret(BthRemoteNameQuery(&ba, len, &requ, str.GetBuffer(len)));
        str.ReleaseBuffer();
        return r ? str : _T("");
    }
 
    bool Authenticate(void) const
    {
        BT_ADDR ba = m_btAddr;
        return m_Ret(BthAuthenticate(&ba));
    }
 
    BT_HANDLE CreateScoConnection(void)
    {
        BT_HANDLE h = NULL;
        if ( ! m_Ret(BthCreateSCOConnection(&m_btAddr, &h)) )
        {
            return NULL;
        }
        return h;
    }
 
    BT_HANDLE CreateAclConnection(void)
    {
        BT_HANDLE h = NULL;
        if ( ! m_Ret(BthCreateACLConnection(&m_btAddr, &h)) )
        {
            return NULL;
        }
        return h;
    }
 
    enum EMode
    {
        ACTIVE, 
        HOLD,   
        SNIFF,  
        PARK    
    };
 
    bool GetCurrentMode(EMode& _mode) const
    {
        BT_ADDR ba = m_btAddr;
        BYTE m = 0;
        bool r = m_Ret(BthGetCurrentMode(&ba, &m));
        _mode = static_cast<EMode>(m);
        return r;
    }
 
    bool EnterHoldMode(WORD& _interval, WORD hold_mode_max, WORD hold_mode_min)
    {
        return m_Ret(BthEnterHoldMode(&m_btAddr, hold_mode_max, hold_mode_min, &_interval));
    }
 
    bool EnterParkMode(WORD& _interval, WORD beacon_max, WORD beacon_min)
    {
        return m_Ret(BthEnterParkMode(&m_btAddr, beacon_max, beacon_min, &_interval));
    }
 
    bool EnterSniffMode(WORD& _interval, WORD sniff_mode_max, WORD sniff_mode_min, WORD sniff_attempt, WORD sniff_timeout)
    {
        return m_Ret(BthEnterSniffMode(&m_btAddr, sniff_mode_max, sniff_mode_min, sniff_attempt, sniff_timeout, &_interval));
    }
 
    bool ExitParkMode(void)
    {
        return m_Ret(BthExitParkMode(&m_btAddr));
    }
 
    bool ExitSniffMode(void)
    {
        return m_Ret(BthExitSniffMode(&m_btAddr));
    }
 
    bool GetLinkKey(CBluetoothLinkKey& _key) const
    {
        BT_ADDR ba = m_btAddr;
        return m_Ret(BthGetLinkKey(&ba, _key.Refer()));
    }
 
    bool RefusePinRequest(void)
    {
        BT_ADDR ba = m_btAddr;
        return m_Ret(BthRefusePINRequest(&ba));
    }
 
    bool PairRequest(LPCTSTR lpszPin)
    {
        CAscii pin = lpszPin;
        int len = pin.GetLength();
        if ( len == 0 )
        {
            BYTE b = 0;
            return m_Ret(BthPairRequest(&m_btAddr, 1, &b));
        }
        return m_Ret(BthPairRequest(&m_btAddr, len, reinterpret_cast<BYTE*>(pin.GetBuffer())));
    }
 
    bool RevokeLinkKey(void)
    {
        return m_Ret(BthRevokeLinkKey(&m_btAddr));
    }
 
    bool RevokePin(void)
    {
        return m_Ret(BthRevokePIN(&m_btAddr));
    }
 
    bool SetEncryption(bool isEnable)
    {
        return m_Ret(BthSetEncryption(&m_btAddr, isEnable ? 1 : 0));
    }
 
    bool SetLinkKey(const CBluetoothLinkKey& key)
    {
        CBluetoothLinkKey k = key;
        return m_Ret(BthSetLinkKey(&m_btAddr, k.Refer()));
    }
 
    bool SetPin(LPCTSTR lpszPin)
    {
        CAscii pin = lpszPin;
        int len = pin.GetLength();
        if ( len == 0 )
        {
            BYTE b = 0;
            return m_Ret(BthSetPIN(&m_btAddr, 1, &b));
        }
        return m_Ret(BthSetPIN(&m_btAddr, len, reinterpret_cast<BYTE*>(pin.GetBuffer())));
    }
 
    bool HasService(CWorkMem& _raw, WORD uuid16) const
    {
        SdpAttributeRange range = { 0, 0x200 };
        if ( m_QueryService(_raw, range, uuid16) )
        {
            return true;
        }
        return false;
    }
 
    bool HasService(CBluetoothServiceAttribute& _attr, WORD uuid16) const
    {
        CWorkMem sdp;
        if ( HasService(sdp, uuid16) )
        {
            _attr.Analyze(sdp.GetSize(), sdp.Ref());
            return true;
        }
        return false;
    }
 
    bool HasService(WORD uuid16) const
    {
        CWorkMem sdp;
        return HasService(sdp, uuid16);
    }
 
#if 0
    bool GetServicesList(CWorkMemT<WORD>& _list) const
    {
        CTickCount tick;
        CWorkMemT<WORD> v(0xFF);
        INDEX d = 0;
        loop ( i, 0x30 )
        {
            if ( HasService(i + 0x1100) )
            {
                v[d++] = i + 0x1100;
            }
        }
        loop ( i, 0x20 )
        {
            if ( HasService(i + 0x1200) )
            {
                v[d++] = i + 0x1200;
            }
        }
        _list.Reset(d, v.Ref());
        tick.OutputDebugPassedCount();
        return true;
    }
#endif
 
    bool GetServicesList(CWorkMemT<WORD>& _list, size_t baseListLength, const WORD* pBaseList) const
    {
        if ( baseListLength == 0 || pBaseList == NULL )
        {
//          return GetServicesList(_list);
            return false;
        }
        ASSERT ( ! ::IsBadReadPtr(pBaseList, sizeof(WORD) * baseListLength) );
        CWorkMemT<WORD> v(baseListLength);
        INDEX d = 0;
        loop ( i, baseListLength )
        {
            if ( HasService(pBaseList[i]) )
            {
                v[d++] = pBaseList[i];
            }
        }
        _list.Reset(d, v.Ref());
        return true;
    }
 
    static bool CloseConnection(BT_HANDLE handle)
    {
        CBluetoothApi api;
        int r = api.BthCloseConnection(handle);
        ::SetLastError(r);
        return r == ERROR_SUCCESS;
    }
 
    static bool GetBasebandConnections(CWorkMemT<BASEBAND_CONNECTION>& _connections)
    {
        CBluetoothApi api;
        const int WORKLEN = 1000;
        CWorkMemT<BASEBAND_CONNECTION> w(WORKLEN);
        int len = 0;
        int r = api.BthGetBasebandConnections(WORKLEN, w.Ref(), &len);
        if ( r == ERROR_SUCCESS )
        {
            _connections.Reset(len, w.Ref());
            return true;
        }
        return false;
    }
 
    static CStr ServiceToString(WORD serviceUuid16)
    {
        CStr s;
        switch ( serviceUuid16 )
        {
        case 0x0001:// SDP
            s = _T("SDP");
            break;
        case 0x0003:// RFCOMM
            s = _T("RFCOMM");
            break;
        case 0x0011:// HIDP
            s = _T("HIDP");
            break;
        case 0x0100:// L2CAP
            s = _T("L2CAP");
            break;
        case PublicBrowseGroupServiceClassID_UUID16:
            s = _T("Public Browse Group");
            break;
        case SerialPortServiceClassID_UUID16:
            s = _T("Serial Port");
            break;
        case LANAccessUsingPPPServiceClassID_UUID16:
            s = _T("LAN Access Using PPP");
            break;
        case DialupNetworkingServiceClassID_UUID16:
            s = _T("Dialup Net working");
            break;
        case IrMCSyncServiceClassID_UUID16:
            s = _T("IrMC Sync");
            break;
        case OBEXObjectPushServiceClassID_UUID16:
            s = _T("OBEX Object Push");
            break;
        case OBEXFileTransferServiceClassID_UUID16:
            s = _T("OBEX File Transfer");
            break;
        case IrMcSyncCommandServiceClassID_UUID16:
            s = _T("IrMc Sync Command");
            break;
        case HeadsetServiceClassID_UUID16:
            s = _T("Headset");
            break;
        case CordlessServiceClassID_UUID16:
            s = _T("Cordless");
            break;
        case AudioSourceServiceClassID_UUID16:
            s = _T("Audio Source");
            break;
        case AudioSinkServiceClassID_UUID16:
            s = _T("Audio Sink");
            break;
        case AV_RemoteControlTargetServiceClassID_UUID16:
            s = _T("A/V Remote Control Target");
            break;
        case AdvancedAudioDistributionServiceClassID_UUID16:
            s = _T("Advanced Audio Distribution");
            break;
        case AV_RemoteControlServiceClassID_UUID16:
            s = _T("A/V Remote Control");
            break;
        case VideoConferencingServiceClassID_UUID16:
            s = _T("Video Conferencing");
            break;
        case IntercomServiceClassID_UUID16:
            s = _T("Intercom");
            break;
        case FaxServiceClassID_UUID16:
            s = _T("Fax");
            break;
        case HeadsetAudioGatewayServiceClassID_UUID16:
            s = _T("Headset Audio Gateway");
            break;
        case PANUServiceClassID_UUID16:
            s = _T("PANU");
            break;
        case NAPServiceClassID_UUID16:
            s = _T("NAP");
            break;
        case GNServiceClassID_UUID16:
            s = _T("GN");
            break;
        case HandsfreeServiceClassID_UUID16:
            s = _T("Handsfree");
            break;
        case HandsfreeAudioGatewayServiceClassID_UUID16:
            s = _T("Handsfree Audio Gateway");
            break;
        case PnPInformationServiceClassID_UUID16:
            s = _T("PnP Information");
            break;
        case GenericNetworkingServiceClassID_UUID16:
            s = _T("Generic Networking");
            break;
        case GenericFileTransferServiceClassID_UUID16:
            s = _T("Generic File Transfer");
            break;
        case GenericAudioServiceClassID_UUID16:
            s = _T("Generic Audio");
            break;
        case GenericTelephonyServiceClassID_UUID16:
            s = _T("Generic Telephony");
            break;
        case 0x1113://WAP
            s = _T("WAP");
            break;
        case 0x1114://WAP_CLIENT
            s = _T("WAP Client");
            break;
        case 0x1118://DIRECT_PRINTING
            s = _T("Direct Printing");
            break;
        case 0x1119://REFERENCE_PRINTING
            s = _T("Reference Printing");
            break;
        case 0x111a://IMAGING
            s = _T("Imaging");
            break;
        case 0x111b://IMAGING_RESPONDER
            s = _T("Imaging Responder");
            break;
        case 0x111c://IMAGING_AUTOMATIC_ARCHIVE
            s = _T("Imaging Automatic Archive");
            break;
        case 0x111d://IMAGING_REFERENCE_OBJECTS
            s = _T("Imaging Reference Objects");
            break;
        case 0x1124://HID (HumanInterfaceDeviceService)
            s = _T("HID");
            break;
        case 0x112F://PBAP PSE (Phonebook Access Profile,Phonebook Server Equipment)
            s = _T("PBAP PSE");
            break;
        }
        return s;
    }
 
private:
 
    // サービス問い合わせ
    bool m_QueryService(CWorkMem& _sdp, const SdpAttributeRange& range, WORD uuid16) const
    {
        // BLOB Data 準備
        BTHNS_RESTRICTIONBLOB resb = { 0 };
        resb.type = SDP_SERVICE_SEARCH_ATTRIBUTE_REQUEST;
        resb.numRange = 1;
        resb.pRange[0] = range;
        resb.uuids[0].uuidType = SDP_ST_UUID16;
        resb.uuids[0].u.uuid16 = uuid16;
        // BLOB 設定
        BLOB blob = { 0 };
        blob.cbSize = sizeof(BTHNS_RESTRICTIONBLOB);
        blob.pBlobData = reinterpret_cast<BYTE*>(&resb);
        // アドレス設定
        SOCKADDR_BTH sa = { 0 };
        sa.btAddr = m_btAddr;
        sa.addressFamily = AF_BT;
        CSADDR_INFO csai = { 0 };
        csai.RemoteAddr.lpSockaddr = reinterpret_cast<sockaddr*>(&sa);
        csai.RemoteAddr.iSockaddrLength = sizeof(sa);
        // QUERYSET設定
        WSAQUERYSET wsaq = { 0 };
        wsaq.dwSize = sizeof(wsaq);
        wsaq.dwNameSpace = NS_BTH;
        wsaq.lpBlob = &blob;
        wsaq.lpcsaBuffer = &csai;
        // 検索開始
        HANDLE hLookup = NULL;
        int ret = BthNsLookupServiceBegin(&wsaq, 0, &hLookup);
        if ( ret == ERROR_SUCCESS )
        {
            // バッファ確保
            CWorkMem work(1000);
            work.Fill(0);
            DWORD dwSize = work.GetSize();
            // デバイス検索
            WSAQUERYSET* pResults = reinterpret_cast<WSAQUERYSET*>(work.Ref());
            pResults->dwSize = sizeof(WSAQUERYSET);
            pResults->dwNameSpace = NS_BTH;
            int ret = BthNsLookupServiceNext(hLookup, 0, &dwSize, pResults);
            int ec = ::GetLastError();
            if ( ret != ERROR_SUCCESS && ec == ERROR_NOT_ENOUGH_MEMORY )
            {
                // 足りなかった.再確保＆検索
                work.Resize(dwSize);
                work.Fill(0);
                pResults = reinterpret_cast<WSAQUERYSET*>(work.Ref());
                pResults->dwSize = sizeof(WSAQUERYSET);
                pResults->dwNameSpace = NS_BTH;
                ret = BthNsLookupServiceNext(hLookup, 0, &dwSize, pResults);
                ec = ::GetLastError();
            }
            BthNsLookupServiceEnd(hLookup);
            if ( ret == ERROR_SUCCESS )
            {
                if ( (pResults->lpBlob->cbSize) >= 4 )
                {
                    _sdp.Reset(pResults->lpBlob->cbSize, pResults->lpBlob->pBlobData);
                    return true;
                }
                ::SetLastError(WSASERVICE_NOT_FOUND);
                return false;
            }
            ::SetLastError(ec);
            _GetLastError("BthNsLookupServiceNext");
            return false;
        }
        _GetLastError("BthNsLookupServiceBegin");
        return false;
    }
};
 
 
 
class CBluetoothFinder : CBluetoothApi
{
    DEFSUPER(CBluetoothApi);
public:
 
    CBluetoothFinder(void) : m_hLookup(NULL)
    {
    }
 
    ~CBluetoothFinder(void)
    {
        Finish();
    }
 
    bool SetFilter(const CBluetoothAddress& addr)
    {
        BT_ADDR ba = addr;
        int r = BthSetInquiryFilter(&ba);
        ::SetLastError(r);
        return r == ERROR_SUCCESS;
    }
 
    bool ResetFilter(void)
    {
        int r = BthClearInquiryFilter();
        ::SetLastError(r);
        return r == ERROR_SUCCESS;
    }
 
    bool Start(void)
    {
        Finish();
        WSAQUERYSET wsaq = { 0 };
        wsaq.dwSize = sizeof(WSAQUERYSET);
        wsaq.dwNameSpace = NS_BTH;
        int ret = BthNsLookupServiceBegin(&wsaq, LUP_CONTAINERS, &m_hLookup);
        if ( ret != ERROR_SUCCESS )
        {
            m_hLookup = NULL;
            return false;
        }
        return Next();
    }
 
    bool Next(void)
    {
        // バッファ確保
        CWorkMem work(1000);
        work.Fill(0);
        DWORD dwSize = work.GetSize();
        // デバイス検索
        DWORD flag = LUP_RETURN_NAME | LUP_RETURN_ADDR | LUP_RETURN_BLOB;
        WSAQUERYSET* pResults = reinterpret_cast<WSAQUERYSET*>(work.Ref());
        pResults->dwSize = sizeof(WSAQUERYSET);
        pResults->dwNameSpace = NS_BTH;
        int ret = BthNsLookupServiceNext(m_hLookup, flag, &dwSize, pResults);
        if ( ret != ERROR_SUCCESS && ::GetLastError() == ERROR_NOT_ENOUGH_MEMORY )
        {
            // 足りなかった.再確保＆検索
            work.Resize(dwSize);
            work.Fill(0);
            pResults = reinterpret_cast<WSAQUERYSET*>(work.Ref());
            pResults->dwSize = sizeof(WSAQUERYSET);
            pResults->dwNameSpace = NS_BTH;
            ret = BthNsLookupServiceNext(m_hLookup, flag, &dwSize, pResults);
        }
        if ( ret != ERROR_SUCCESS )
        {
            if ( ::GetLastError() != WSA_E_NO_MORE )
            {
                _GetLastError("BthNsLookupServiceNext");
            }
            return false;
        }
        BT_ADDR ba = 0;
        if ( pResults->dwNumberOfCsAddrs == 1 )
        {
            LPSOCKADDR lpszAddr = pResults->lpcsaBuffer->RemoteAddr.lpSockaddr;
            SOCKADDR_BTH* P = reinterpret_cast<SOCKADDR_BTH*>(lpszAddr);
            ba = P->btAddr;
        }
        ASSERT( pResults->lpBlob->cbSize == sizeof(BthInquiryResult) );
        BthInquiryResult* pInqRes = reinterpret_cast<BthInquiryResult*>(pResults->lpBlob->pBlobData);
        // 情報記憶
        m_foundDevice = ba;
        m_foundName = pResults->lpszServiceInstanceName;
        m_foundClass = pInqRes->cod;
        return m_foundDevice.IsValid();
    }
 
    void Finish(void)
    {
        if ( m_hLookup != NULL )
        {
            BthNsLookupServiceEnd(m_hLookup);
            m_hLookup = NULL;
        }
    }
 
    const CBluetoothDevice& GetFoundDevice(void) const
    {
        return m_foundDevice;
    }
 
    const CBluetoothClass& GetFoundDeviceClass(void) const
    {
        return m_foundClass;
    }
 
    LPCTSTR GetFoundDeviceName(void) const
    {
        return m_foundName;
    }
 
private:
    HANDLE              m_hLookup;      
    CBluetoothDevice    m_foundDevice;  
    CStr                m_foundName;    
    CBluetoothClass     m_foundClass;   
};
 
 
 
class CBluetoothAudioGatewayService
{
public:
 
    bool Disconnect(void)
    {
        CBag ag;
        return ag.Control(IOCTL_AG_CLOSE_CONTROL);
    }
 
    bool Connect(void)
    {
        CBag ag;
        return ag.Control(IOCTL_AG_OPEN_CONTROL);
    }
 
    bool AutoAnswer(void)
    {
        CBag ag;
        DWORD dwData = 1;
        return ag.Control(IOCTL_AG_SET_USE_HF_AUDIO, &dwData, sizeof(dwData));
    }
 
    bool OpenAudio(void)
    {
        CBag ag;
        return ag.Control(IOCTL_AG_OPEN_AUDIO);
    }
 
    bool CloseAudio(void)
    {
        CBag ag;
        return ag.Control(IOCTL_AG_CLOSE_AUDIO);
    }
 
    bool SetInbandRing(bool isOn = true)
    {
        CBag ag;
        DWORD dwData = isOn ? 1 : 0;
        return ag.Control(IOCTL_AG_SET_INBAND_RING, &dwData, sizeof(dwData));
    }
 
    bool SetPowerSaveMode(bool isOn = true)
    {
        CBag ag;
        DWORD dwData = isOn ? 1 : 0;
        return ag.Control(IOCTL_AG_SET_POWER_MODE, &dwData, sizeof(dwData));
    }
 
    bool GetPowerSaveMode(bool& _isOn)
    {
        CBag ag;
        DWORD dwData = 0;
        bool r = ag.Control(IOCTL_AG_GET_POWER_MODE, NULL, 0, &dwData, sizeof(dwData));
        _isOn = (dwData != 0);
        return r;
    }
 
    bool SetSpeakerVolume(int vol)
    {
        CBag ag;
        return ag.Control(IOCTL_AG_SET_SPEAKER_VOL, &vol, sizeof(vol));
    }
 
    bool GetSpeakerVolume(int& _vol)
    {
        CBag ag;
        return ag.Control(IOCTL_AG_GET_SPEAKER_VOL, NULL, 0, &_vol, sizeof(_vol));
    }
 
    bool SetMicVolume(int vol)
    {
        CBag ag;
        return ag.Control(IOCTL_AG_SET_MIC_VOL, &vol, sizeof(vol));
    }
 
    bool GetMicVolume(int& _vol)
    {
        CBag ag;
        return ag.Control(IOCTL_AG_GET_MIC_VOL, NULL, 0, &_vol, sizeof(_vol));
    }
 
private:
    class CBag
    {
    public:
        CBag(void) : m_handle(::CreateFile(_T("BAG0:"), 0, 0, NULL, OPEN_EXISTING, 0, NULL))
        {
        }
        ~CBag(void)
        {
            if ( m_handle != INVALID_HANDLE_VALUE )
            {
                ::CloseHandle(m_handle);
                m_handle = INVALID_HANDLE_VALUE;
            }
        }
        bool Control(DWORD dwIoControlCode, LPVOID lpInBuffer = NULL, DWORD nInBufferSize = 0, LPVOID lpOutBuffer = NULL, DWORD nOutBufferSize = 0, LPDWORD lpBytesReturned = NULL, LPOVERLAPPED lpOverlapped = NULL)
        {
            bool r = !! ::DeviceIoControl(m_handle, dwIoControlCode, lpInBuffer, nInBufferSize, lpOutBuffer, nOutBufferSize, lpBytesReturned, lpOverlapped);
            if ( ! r )
            {
                _GetLastError("DeviceIoControl");
            }
            return r;
        }
    private:
        HANDLE m_handle; 
    };
};
 
 
 
#if 0
 
    CE の SDP は、一個ずつしか検索できない。
 
#endif
 
};//TNB