static BluetoothPairDeviceState::eStatus
AsyncBluetoothPairDeviceRequest__patchRegistry(
    BluetoothPairDeviceState *state)
{
    assert(state->isWorkerThread());
    BluetoothPairDeviceState::eStatus nextSubStatus= 
        state->getSubStatus_WorkerThread<BluetoothPairDeviceState::eStatus>();
    bool success= true;

    /* Windows 8 seems to require manual help with setting up the device
    * in the registry. Previous versions do this by themselves, but
    * doing it manually for them does not seem to harm them either. So we
    * do not single out Windows 8 but simply perform the necessary tweaks
    * for all versions of Windows.
    */
    SERVER_MT_LOG_INFO("AsyncBluetoothPairDeviceRequest") << "Patching the registry ...";
    patch_registry(&state->deviceInfo.Address, &state->radioInfo.address);

    // enable HID service only if necessary
    SERVER_MT_LOG_INFO("AsyncBluetoothPairDeviceRequest") << "Checking HID service";
    if(!is_hid_service_enabled(state->hRadio, &state->deviceInfo))
    {
        SERVER_MT_LOG_INFO("AsyncBluetoothPairDeviceRequest") << "HID service not enabled, attempting to enable";
        GUID service = HumanInterfaceDeviceServiceClass_UUID;
        DWORD result = BluetoothSetServiceState(state->hRadio, &state->deviceInfo, &service, BLUETOOTH_SERVICE_ENABLE);
        
        if(result == ERROR_SUCCESS)
        {
            SERVER_MT_LOG_INFO("AsyncBluetoothPairDeviceRequest") << "Patching the registry ...";
            patch_registry(&state->deviceInfo.Address, &state->radioInfo.address);
        }
        else
        {
            SERVER_MT_LOG_INFO("AsyncBluetoothPairDeviceRequest") << "Failed to enable HID service. Error code: " << result;
            success= false;
        }
    }

    if (success)
    {
        // On Success, Move on to the verify connection state
        // Reset the connection verification count before entering that state
        state->verifyConnectionCount= 0;

        nextSubStatus= BluetoothPairDeviceState::verifyConnection;
    }
    else
    {
        // On Failure, fall back to the device scanning
        nextSubStatus= BluetoothPairDeviceState::deviceScan;
    }

    return nextSubStatus;
}
示例#2
0
bool BtPCModul ::InstalDriver(NXTclass * nxtclass)
{
    BLUETOOTH_DEVICE_INFO m_device_info = {sizeof(BLUETOOTH_DEVICE_INFO),str2ba(nxtclass->BTaddr),};
    int iguid[4]=NXT_GUID;
    GUID * guid=new GUID;
    memcpy(&(guid->Data1),(int*)iguid,16);
    HRESULT re=BluetoothSetServiceState (0,&m_device_info,guid,BLUETOOTH_SERVICE_ENABLE);
    if (re==E_INVALIDARG)
    {
        printf("Driver already installed\n");
        return (nxtclass->portIsReady());
    }
    if (re==ERROR_SUCCESS)
    {
        printf("Driver successfully installed\n");
        return true;
    }
    printf("Driver instal failed\n");
    return false;
}
示例#3
0
static void
handle_windows_pre8(const BLUETOOTH_ADDRESS *move_addr, const BLUETOOTH_ADDRESS *radio_addr, const HANDLE hRadio)
{
    int connected = 0;
    while (!connected) {
        BLUETOOTH_DEVICE_INFO device_info;
        if (get_bluetooth_device_info(hRadio, move_addr, &device_info, 0) != 0) {
            WINPAIR_DEBUG("No Bluetooth device found matching the given address");
        } else {
            if (is_move_motion_controller(&device_info)) {
                WINPAIR_DEBUG("Found Move Motion Controller matching the given address");

                if (device_info.fConnected) {
                    /* enable HID service only if necessary */
                    WINPAIR_DEBUG("Checking HID service ...");
                    if (!is_hid_service_enabled(hRadio, &device_info)) {
                        WINPAIR_DEBUG("Enabling HID service ...");
                        GUID service = HumanInterfaceDeviceServiceClass_UUID;
                        DWORD result = BluetoothSetServiceState(hRadio, &device_info, &service, BLUETOOTH_SERVICE_ENABLE);
                        if (result != ERROR_SUCCESS) {
                            WINPAIR_DEBUG("Failed to enable HID service");
                        }
                    }

                    WINPAIR_DEBUG("Verifying successful connection ...");
                    if (is_connection_established(hRadio, &device_info)) {
                        /* if we have a connection, stop trying to connect this device */
                        printf("Connection verified.\n");
                        connected = 1;
                        break;
                    }
                }
            } else {
                WINPAIR_DEBUG("Bluetooth device matching the given address is not a Move Motion Controller");
            }
        }

        Sleep(SLEEP_BETWEEN_SCANS);
    }
}
示例#4
0
int
windows_register_psmove(const char *move_addr_str, const HANDLE hRadio)
{
    /* parse controller's Bluetooth device address string */
    BLUETOOTH_ADDRESS *move_addr = string_to_btaddr(move_addr_str);
    if (!move_addr) {
        WINPAIR_DEBUG("Cannot parse controller address: '%s'", move_addr_str);
        return 1;
    }

    if (set_up_bluetooth_radio(hRadio) != 0) {
        WINPAIR_DEBUG("Failed to configure Bluetooth radio for use");
        return 1;
    }

    /* Keep track of the number of times the loop iterates so we may timeout. */
    int timeout_duration = 30;  // seconds
    int sleep_interval = 1000; // msec
    int timeout_iterations = timeout_duration * 1000 / sleep_interval;
    int loop_count = 0;
    
    printf("\n" \
           "    Unplug the controller.\n" \
           "\n"
           "    Now press the controller's PS button. The red status LED\n" \
           "    will start blinking. Whenever it goes off, press the\n" \
           "    PS button again. Repeat this until the status LED finally\n" \
           "    remains lit. Press Ctrl+C to cancel anytime.\n");

    for(;;) {
        BLUETOOTH_DEVICE_INFO device_info;
        if (get_bluetooth_device_info(hRadio, move_addr, &device_info) != 0) {
            WINPAIR_DEBUG("No Bluetooth device found matching the given address");
        } else {
            if (is_move_motion_controller(&device_info)) {
                WINPAIR_DEBUG("Found Move Motion Controller matching the given address");

                if (device_info.fConnected) {
                    /* enable HID service only if necessary */
                    WINPAIR_DEBUG("Checking HID service ...");
                    if (!is_hid_service_enabled(hRadio, &device_info)) {
                        WINPAIR_DEBUG("Enabling HID service ...");
                        GUID service = HumanInterfaceDeviceServiceClass_UUID;
                        DWORD result = BluetoothSetServiceState(hRadio, &device_info, &service, BLUETOOTH_SERVICE_ENABLE);
                        if (result != ERROR_SUCCESS) {
                            WINPAIR_DEBUG("Failed to enable HID service");
                        }
                    }

                    WINPAIR_DEBUG("Verifying successful connection ...");
                    if (is_connection_established(hRadio, &device_info)) {
                        /* if we have a connection, stop trying to connect this device */
                        printf("Connection verified.\n");
                        break;
                    }
                }
            } else {
                WINPAIR_DEBUG("Bluetooth device matching the given address is not a Move Motion Controller");
            }
        }
        if (loop_count >= timeout_iterations) {
            printf("\n"
                   "    A connection could not be established. This is not\n"
                   "    unusual in Windows. Please refer to the README document\n"
                   "    for your platform for more information. Press Ctrl+C to cancel.");
        }

        /* sleep for 1 second */
        Sleep(1000);
        loop_count++;
    }

    free(move_addr);

    return 0;
}
示例#5
0
static void
handle_windows8_and_later(const BLUETOOTH_ADDRESS *move_addr, const BLUETOOTH_ADDRESS *radio_addr, const HANDLE hRadio)
{
    unsigned int scan = 0;
    int connected = 0;
    while (!connected) {
        BLUETOOTH_DEVICE_INFO device_info;
        if (get_bluetooth_device_info(hRadio, move_addr, &device_info, scan == 0) != 0) {
            WINPAIR_DEBUG("No Bluetooth device found matching the given address");
        } else {
            if (is_move_motion_controller(&device_info)) {
                WINPAIR_DEBUG("Found Move Motion Controller matching the given address");

                unsigned int conn_try;
                for (conn_try = 1; conn_try <= CONN_RETRIES; conn_try++) {
                    WINPAIR_DEBUG("Connection try %d/%d", conn_try, CONN_RETRIES);

                    if (update_device_info(hRadio, &device_info) != 0) {
                        break;
                    }

                    if (device_info.fConnected) {
                        /* Windows 8 (and later) seems to require manual help with setting up
                         * the device in the registry.
                         */
                        WINPAIR_DEBUG("Patching the registry ...");
                        if (patch_registry(move_addr, radio_addr) != 0) {
                            WINPAIR_DEBUG("Failed to patch the registry");
                        }

                        /* enable HID service only if necessary */
                        WINPAIR_DEBUG("Checking HID service ...");
                        if (!is_hid_service_enabled(hRadio, &device_info)) {
                            WINPAIR_DEBUG("Enabling HID service ...");
                            GUID service = HumanInterfaceDeviceServiceClass_UUID;
                            DWORD result = BluetoothSetServiceState(hRadio, &device_info, &service, BLUETOOTH_SERVICE_ENABLE);
                            if (result != ERROR_SUCCESS) {
                                WINPAIR_DEBUG("Failed to enable HID service");
                            }

                            WINPAIR_DEBUG("Patching the registry ...");
                            if (patch_registry(move_addr, radio_addr) != 0) {
                                WINPAIR_DEBUG("Failed to patch the registry");
                            }
                        }

                        WINPAIR_DEBUG("Verifying successful connection ...");
                        if (is_connection_established(hRadio, &device_info)) {
                            /* if we have a connection, stop trying to connect this device */
                            printf("Connection verified.\n");
                            connected = 1;
                            break;
                        }
                    }

                    Sleep(CONN_DELAY);
                }

                if(!device_info.fConnected) {
                    BluetoothRemoveDevice(&(device_info.Address));
                    WINPAIR_DEBUG("Device removed, starting all over again");
                }
            } else {
                WINPAIR_DEBUG("Bluetooth device matching the given address is not a Move Motion Controller");
            }
        }

        Sleep(SLEEP_BETWEEN_SCANS);
        scan = (scan + 1) % BT_SCAN_NEW_INQUIRY;
    }
}
int AddDevice(BLUETOOTH_DEVICE_INFO* pbtdi, wchar_t** portName)
{
	PWCHAR passKey = L"1234";
	DWORD result = BluetoothAuthenticateDevice(	NULL,
												NULL,
												pbtdi,
												passKey,
												wcslen(passKey));

	if(result != ERROR_SUCCESS)
	{
		return result;
	}

	/*PROBLEM: as far as i can tell, you can't get the port name (Ex: COM4) 
	from the windows api when adding and activating a bluetooth device.
	SOLUTION: check the registry for serial ports before and after, 
	and take the difference as being the new port
	*/

	std::vector<wchar_t*> serialPortsBefore, serialPortsAfter;

	result = GetComPortsFromRegistry(&serialPortsBefore);
	if(result != R_SUCCESS)
	{
		return R_REG_PORTS_RETRIEVAL_FAIL;
	}

	//set service state on device
	GUID service = SerialPortServiceClass_UUID;
	result = BluetoothSetServiceState(	NULL,
										pbtdi,
										&service,
										BLUETOOTH_SERVICE_ENABLE);

	if(result != ERROR_SUCCESS)
	{
		return result;
	}

	//it can take some time for the registry keys to show up, so we'll retry a couple times and delay between them
	for(int retry = 0; retry < 3;retry++)
	{
		result = GetComPortsFromRegistry(&serialPortsAfter);
		if(result != R_SUCCESS)
		{
			return R_REG_PORTS_RETRIEVAL_FAIL;
		}

		//if theres a size difference assume it's the new port and stop retrying
		if(serialPortsBefore.size() != serialPortsAfter.size())
			break;

		//wait a bit for the reg key to show up
		Sleep(2000);
	}

	std::vector<wchar_t*> diff;
	for(int i=0;i<serialPortsAfter.size();i++)
	{
		bool found = false;
		for(int j=0;j<serialPortsBefore.size();j++)
		{
			if(wcscmp(serialPortsAfter[i], serialPortsBefore[j]) == 0)
			{
				found = true;
				break;
			}
		}

		if(!found)
		{
			diff.push_back(serialPortsAfter[i]);
		}
	}

	if(diff.size() == 0)
	{
		return R_UNKNOWN_SERIAL_PORT;
	}
	else if(diff.size() > 1)
	{
		return R_UNKNOWN_SERIAL_PORT;
	}

	//copy the string to the provided buffer
	wcscpy(*portName, diff[0]);

	return result;

}