ubuntu bluetooth 配对过程

最新推荐文章于 2024-07-16 18:49:51 发布
最新推荐文章于 2024-07-16 18:49:51 发布
阅读量2k 收藏 1
点赞数
分类专栏： 蓝牙

ubuntu bluetooth 配对过程

发表于2012/6/6 21:57:08  2601人阅读

分类： 蓝牙技术

bluetoothd运行时（main函数启动时），加载plugin（调用plugin_init函数）：

gboolean plugin_init(GKeyFile *config)
{
	GSList *list;
	GDir *dir;
	const gchar *file;
	gchar **disabled;
	unsigned int i;

	/* Make a call to BtIO API so its symbols got resolved before the
	 * plugins are loaded. */
	bt_io_error_quark();

	if (config)
		disabled = g_key_file_get_string_list(config, "General",
							"DisablePlugins",
							NULL, NULL);
	else
		disabled = NULL;

	info("Loading builtin plugins");

	//add default plugins, those plugins always need for bluetoothd runing
	//those plugins will add to the global link named plugins
	for (i = 0; __bluetooth_builtin[i]; i++) {
		if (is_disabled(__bluetooth_builtin[i]->name, disabled))
			continue;

		add_plugin(NULL,  __bluetooth_builtin[i]);
	}

	if (strlen(PLUGINDIR) == 0) {
		g_strfreev(disabled);
		goto start;
	}

	info("Loading plugins %s\n", PLUGINDIR);

	dir = g_dir_open(PLUGINDIR, 0, NULL);
	if (!dir) {
		g_strfreev(disabled);
		goto start;
	}

	//add user plugins, those plugins stored in PLUGINDIR path, and the 
	//PLUGINDIR = /usr/local/lib/bluetooth/plugins. The bluetoothd will
	//find all those plugins which name *.so, and open them, get the method
	//named bluetooth_plugin_desc, it will also add those plugins to the
	//plugins links.
	while ((file = g_dir_read_name(dir)) != NULL) {
		struct bluetooth_plugin_desc *desc;
		void *handle;
		gchar *filename;

		if (g_str_has_prefix(file, "lib") == TRUE ||
				g_str_has_suffix(file, ".so") == FALSE)
			continue;

		if (is_disabled(file, disabled))
			continue;

		filename = g_build_filename(PLUGINDIR, file, NULL);

		handle = dlopen(filename, RTLD_NOW);
		if (handle == NULL) {
			error("Can't load plugin %s: %s", filename,
								dlerror());
			g_free(filename);
			continue;
		}

		g_free(filename);

		desc = dlsym(handle, "bluetooth_plugin_desc");
		if (desc == NULL) {
			error("Can't load plugin description: %s", dlerror());
			dlclose(handle);
			continue;
		}

		if (add_plugin(handle, desc) == FALSE)
			dlclose(handle);
	}

	g_dir_close(dir);

	g_strfreev(disabled);

start:
	//init all of the plugins by calling the plugins init function
	for (list = plugins; list; list = list->next) {
		struct bluetooth_plugin *plugin = list->data;

		if (plugin->desc->init() < 0) {
			error("Failed to init %s plugin", plugin->desc->name);
			continue;
		}
		info("plugins active\n");
		plugin->active = TRUE;
	}

	return TRUE;
}
函数中__bluetooth_builtin结构体为存储加载的plugin的入口地址，这些地址是通过连接宏##连接的，其中包含hciops模块的加载。此函数将结构体中的地址加载成plugins链表，然后循环调用每个模块的初始化init函数。对应于hciops模块，调用初始化函数为hciops_init。__bluetooth_builtin结构体和连接宏定义如下： 

static struct bluetooth_plugin_desc *__bluetooth_builtin[] = {
  &__bluetooth_builtin_audio,
  &__bluetooth_builtin_input,
  &__bluetooth_builtin_serial,
  &__bluetooth_builtin_network,
  &__bluetooth_builtin_service,
  &__bluetooth_builtin_hciops,
  &__bluetooth_builtin_hal,
  &__bluetooth_builtin_storage,
  NULL
};

#define BLUETOOTH_PLUGIN_DEFINE(name, version, priority, init, exit) \
		struct bluetooth_plugin_desc __bluetooth_builtin_ ## name = { \
			#name, version, priority, init, exit \
		};
hciops模块初始化： 
static int hciops_init(void)
{
	info("hciops_init\n");
	return btd_register_adapter_ops(&hci_ops);
}


int btd_register_adapter_ops(struct btd_adapter_ops *btd_adapter_ops)
{
	/* Already registered */
	if (adapter_ops)
		return -EALREADY;

	if (btd_adapter_ops->setup == NULL)
		return -EINVAL;

	adapter_ops = btd_adapter_ops;

	return 0;
}
这个初始化函数将静态hci_ops结构体变量赋值给了全局变量adapter_ops。hci_ops结构定义： 

static struct btd_adapter_ops hci_ops = {
	.setup = hciops_setup,
	.cleanup = hciops_cleanup,
	.start = hciops_start,
	.stop = hciops_stop,
	.set_powered = hciops_powered,
	.set_connectable = hciops_connectable,
	.set_discoverable = hciops_discoverable,
	.set_limited_discoverable = hciops_set_limited_discoverable,
	.start_discovery = hciops_start_discovery,
	.stop_discovery = hciops_stop_discovery,
	.resolve_name = hciops_resolve_name,
	.cancel_resolve_name = hciops_cancel_resolve_name,
	.set_name = hciops_set_name,
	.read_name = hciops_read_name,
	.set_class = hciops_set_class,
};
在plugin_init加载完plugins后，调用了adapter_ops_setup函数来启动HCI适配层： 

int adapter_ops_setup(void)
{
	if (!adapter_ops)
		return -EINVAL;

	return adapter_ops->setup();
}
这个函数即调用里 hci_ops静态全局变量的setup函数，看hci_ops全局变量的定义，.setup指向hciops_setup函数： 

static int hciops_setup(void)
{
	struct sockaddr_hci addr;
	struct hci_filter flt;
	GIOChannel *ctl_io, *child_io;
	int sock, err;

	info("hciops_setup\n");

	if (child_pipe[0] != -1)
		return -EALREADY;

	if (pipe(child_pipe) < 0) {
		err = errno;
		error("pipe(): %s (%d)", strerror(err), err);
		return -err;
	}

	child_io = g_io_channel_unix_new(child_pipe[0]);
	g_io_channel_set_close_on_unref(child_io, TRUE);
	child_io_id = g_io_add_watch(child_io,
				G_IO_IN | G_IO_ERR | G_IO_HUP | G_IO_NVAL,
				child_exit, NULL);
	g_io_channel_unref(child_io);

	/* Create and bind HCI socket */
	sock = socket(AF_BLUETOOTH, SOCK_RAW, BTPROTO_HCI);
	if (sock < 0) {
		err = errno;
		error("Can't open HCI socket: %s (%d)", strerror(err),
								err);
		return -err;
	}

	/* Set filter */
	hci_filter_clear(&flt);
	hci_filter_set_ptype(HCI_EVENT_PKT, &flt);
	hci_filter_set_event(EVT_STACK_INTERNAL, &flt);
	if (setsockopt(sock, SOL_HCI, HCI_FILTER, &flt,
							sizeof(flt)) < 0) {
		err = errno;
		error("Can't set filter: %s (%d)", strerror(err), err);
		return -err;
	}

	memset(&addr, 0, sizeof(addr));
	addr.hci_family = AF_BLUETOOTH;
	addr.hci_dev = HCI_DEV_NONE;
	if (bind(sock, (struct sockaddr *) &addr,
							sizeof(addr)) < 0) {
		err = errno;
		error("Can't bind HCI socket: %s (%d)",
							strerror(err), err);
		return -err;
	}

	ctl_io = g_io_channel_unix_new(sock);
	g_io_channel_set_close_on_unref(ctl_io, TRUE);

	ctl_io_id = g_io_add_watch(ctl_io, G_IO_IN, io_stack_event, NULL);

	g_io_channel_unref(ctl_io);

	/* Initialize already connected devices */
	return init_known_adapters(sock);
}
在函数的最后，调用里init_known_adapters启动里已知的hci设备，初始化HCI适配器： 

static int init_known_adapters(int ctl)
{
	struct hci_dev_list_req *dl;
	struct hci_dev_req *dr;
	int i, err;

	info("init_known_adapters\n");

	dl = g_try_malloc0(HCI_MAX_DEV * sizeof(struct hci_dev_req) + sizeof(uint16_t));
	if (!dl) {
		err = errno;
		error("Can't allocate devlist buffer: %s (%d)",
							strerror(err), err);
		return -err;
	}

	dl->dev_num = HCI_MAX_DEV;
	dr = dl->dev_req;

	if (ioctl(ctl, HCIGETDEVLIST, (void *) dl) < 0) {
		err = errno;
		error("Can't get device list: %s (%d)",
							strerror(err), err);
		g_free(dl);
		return -err;
	}

	for (i = 0; i < dl->dev_num; i++, dr++) {
		device_event(HCI_DEV_REG, dr->dev_id);

		if (hci_test_bit(HCI_UP, &dr->dev_opt)){
			info("here start the hci device\n");
			<span style="box-sizing: border-box; margin: 0px; padding: 0px; color: rgb(0, 0, 0);">device_event(HCI_DEV_UP, dr->dev_id);</span>
		}
	}

	g_free(dl);
	return 0;
}
这个函数通过ioctl获取系统的hci设备列表，然后用device_event(HCI_DEV_UP..)启动HCI设备。device_event接收HCI_DEV_UP消息，调用HCI设备启动函数： 

static void device_event(int event, int index)
{
	switch (event) {
	case HCI_DEV_REG:
		info("HCI dev %d registered", index);
		device_devreg_setup(index);
		break;

	case HCI_DEV_UNREG:
		info("HCI dev %d unregistered", index);
		manager_unregister_adapter(index);
		break;

<span style="box-sizing: border-box; margin: 0px; padding: 0px; color: rgb(0, 0, 0); background-color: rgb(255, 255, 255);">	case HCI_DEV_UP:
		info("HCI dev %d up", index);
		device_devup_setup(index);
		break;</span>

	case HCI_DEV_DOWN:
		info("HCI dev %d down", index);
		manager_stop_adapter(index);
		stop_security_manager(index);
		break;
	}
}

启动HCI DEV设备：

static void device_devup_setup(int index)
{
	configure_device(index);

	<span style="box-sizing: border-box; margin: 0px; padding: 0px; color: rgb(0, 0, 0);">start_security_manager</span>(index);

	/* Return value 1 means ioctl(DEVDOWN) was performed */
	if (manager_start_adapter(index) == 1)
		stop_security_manager(index);
}
开始安全管理： 

void start_security_manager(int hdev)
{
	GIOChannel *chan = io_data[hdev].channel;
	struct hci_dev_info *di;
	struct hci_filter flt;
	read_stored_link_key_cp cp;
	int dev;

	if (chan)
		return;

	info("Starting security manager %d", hdev);

	if ((dev = hci_open_dev(hdev)) < 0) {
		error("Can't open device hci%d: %s (%d)",
						hdev, strerror(errno), errno);
		return;
	}

	/* Set filter */
	hci_filter_clear(&flt);
	hci_filter_set_ptype(HCI_EVENT_PKT, &flt);
	hci_filter_set_event(EVT_CMD_STATUS, &flt);
	hci_filter_set_event(EVT_CMD_COMPLETE, &flt);
	hci_filter_set_event(EVT_PIN_CODE_REQ, &flt);
	hci_filter_set_event(EVT_LINK_KEY_REQ, &flt);
	hci_filter_set_event(EVT_LINK_KEY_NOTIFY, &flt);
	hci_filter_set_event(EVT_RETURN_LINK_KEYS, &flt);
	hci_filter_set_event(EVT_IO_CAPABILITY_REQUEST, &flt);
	hci_filter_set_event(EVT_IO_CAPABILITY_RESPONSE, &flt);
	hci_filter_set_event(EVT_USER_CONFIRM_REQUEST, &flt);
	hci_filter_set_event(EVT_USER_PASSKEY_REQUEST, &flt);
	hci_filter_set_event(EVT_REMOTE_OOB_DATA_REQUEST, &flt);
	hci_filter_set_event(EVT_USER_PASSKEY_NOTIFY, &flt);
	hci_filter_set_event(EVT_KEYPRESS_NOTIFY, &flt);
	hci_filter_set_event(EVT_SIMPLE_PAIRING_COMPLETE, &flt);
	hci_filter_set_event(EVT_AUTH_COMPLETE, &flt);
	hci_filter_set_event(EVT_REMOTE_NAME_REQ_COMPLETE, &flt);
	hci_filter_set_event(EVT_READ_REMOTE_VERSION_COMPLETE, &flt);
	hci_filter_set_event(EVT_READ_REMOTE_FEATURES_COMPLETE, &flt);
	hci_filter_set_event(EVT_REMOTE_HOST_FEATURES_NOTIFY, &flt);
	hci_filter_set_event(EVT_INQUIRY_COMPLETE, &flt);
	hci_filter_set_event(EVT_INQUIRY_RESULT, &flt);
	hci_filter_set_event(EVT_INQUIRY_RESULT_WITH_RSSI, &flt);
	hci_filter_set_event(EVT_EXTENDED_INQUIRY_RESULT, &flt);
	hci_filter_set_event(EVT_CONN_REQUEST, &flt);
	hci_filter_set_event(EVT_CONN_COMPLETE, &flt);
	hci_filter_set_event(EVT_DISCONN_COMPLETE, &flt);
	if (setsockopt(dev, SOL_HCI, HCI_FILTER, &flt, sizeof(flt)) < 0) {
		error("Can't set filter on hci%d: %s (%d)",
						hdev, strerror(errno), errno);
		close(dev);
		return;
	}

	di = g_new(struct hci_dev_info, 1);
	if (hci_devinfo(hdev, di) < 0) {
		error("Can't get device info: %s (%d)",
							strerror(errno), errno);
		close(dev);
		g_free(di);
		return;
	}

	chan = g_io_channel_unix_new(dev);
	g_io_channel_set_close_on_unref(chan, TRUE);
	io_data[hdev].watch_id = g_io_add_watch_full(chan, G_PRIORITY_LOW,
						G_IO_IN | G_IO_NVAL | G_IO_HUP | G_IO_ERR,
						<span style="box-sizing: border-box; margin: 0px; padding: 0px; color: rgb(0, 0, 0);">io_security_event</span>, di, (GDestroyNotify) g_free);//注册消息处理函数
	io_data[hdev].channel = chan;
	io_data[hdev].pin_length = -1;

	if (hci_test_bit(HCI_RAW, &di->flags))
		return;

	bacpy(&cp.bdaddr, BDADDR_ANY);
	cp.read_all = 1;

	hci_send_cmd(dev, OGF_HOST_CTL, OCF_READ_STORED_LINK_KEY,
			READ_STORED_LINK_KEY_CP_SIZE, (void *) &cp);
}

这个函数打开里hci dev设备（实际上就是一个socket），设置处理消息类型，然后创建channel，最后用io_security_event函数侦听远程设备发送过来的消息（socket数据）。接收消息函数：

static gboolean io_security_event(GIOChannel *chan, GIOCondition cond,
								gpointer data)
{
	unsigned char buf[HCI_MAX_EVENT_SIZE], *ptr = buf;
	struct hci_dev_info *di = data;
	int type, dev;
	size_t len;
	hci_event_hdr *eh;
	GIOError err;
	evt_cmd_status *evt;

	if (cond & (G_IO_NVAL | G_IO_HUP | G_IO_ERR)) {
		delete_channel(chan);
		return FALSE;
	}

	if ((err = g_io_channel_read(chan, (gchar *) buf, sizeof(buf), &len))) {
		if (err == G_IO_ERROR_AGAIN)
			return TRUE;
		delete_channel(chan);
		return FALSE;
	}

	type = *ptr++;

	if (type != HCI_EVENT_PKT)
		return TRUE;

	eh = (hci_event_hdr *) ptr;
	ptr += HCI_EVENT_HDR_SIZE;

	dev = g_io_channel_unix_get_fd(chan);

	ioctl(dev, HCIGETDEVINFO, (void *) di);

	if (hci_test_bit(HCI_RAW, &di->flags))
		return TRUE;

	hci_cmd_print(eh->evt);

	switch (eh->evt) {
	case EVT_CMD_STATUS://命令状态
		cmd_status(dev, &di->bdaddr, ptr);
		break;

	case EVT_CMD_COMPLETE://命令完成
		cmd_complete(dev, &di->bdaddr, ptr);
		break;

	case EVT_REMOTE_NAME_REQ_COMPLETE://获取远程设备名
		remote_name_information(dev, &di->bdaddr, ptr);
		break;

	case EVT_READ_REMOTE_VERSION_COMPLETE:
		remote_version_information(dev, &di->bdaddr, ptr);
		break;

	case EVT_READ_REMOTE_FEATURES_COMPLETE://读取远程设备属性
		remote_features_information(dev, &di->bdaddr, ptr);
		break;

	case EVT_REMOTE_HOST_FEATURES_NOTIFY:
		remote_features_notify(dev, &di->bdaddr, ptr);
		break;

	case EVT_INQUIRY_COMPLETE:
		evt = (evt_cmd_status *) ptr;
		inquiry_complete(&di->bdaddr, evt->status, FALSE);
		break;

	case EVT_INQUIRY_RESULT:
		inquiry_result(dev, &di->bdaddr, eh->plen, ptr);
		break;

	case EVT_INQUIRY_RESULT_WITH_RSSI:
		inquiry_result_with_rssi(dev, &di->bdaddr, eh->plen, ptr);
		break;

	case EVT_EXTENDED_INQUIRY_RESULT:
		extended_inquiry_result(dev, &di->bdaddr, eh->plen, ptr);
		break;

	case EVT_CONN_COMPLETE://连接完成
		conn_complete(dev, di->dev_id, &di->bdaddr, ptr);
		break;

	case EVT_DISCONN_COMPLETE://断开连接
		disconn_complete(dev, &di->bdaddr, ptr);
		break;

	case EVT_AUTH_COMPLETE:
		auth_complete(dev, &di->bdaddr, ptr);
		break;

	case EVT_SIMPLE_PAIRING_COMPLETE:
		simple_pairing_complete(dev, &di->bdaddr, ptr);
		break;

	case EVT_CONN_REQUEST://配对请求
		conn_request(dev, &di->bdaddr, ptr);
		break;
	}

	/* Check for pending command request */
	check_pending_hci_req(di->dev_id, eh->evt);
	switch (eh->evt) {
	case EVT_PIN_CODE_REQ://PIN码请求
		pin_code_request(dev, &di->bdaddr, (bdaddr_t *) ptr);
		break;

	case EVT_LINK_KEY_REQ:
		link_key_request(dev, &di->bdaddr, (bdaddr_t *) ptr);
		break;

	case EVT_LINK_KEY_NOTIFY://linkkey通知
		link_key_notify(dev, &di->bdaddr, ptr);
		break;

	case EVT_RETURN_LINK_KEYS:
		return_link_keys(dev, &di->bdaddr, ptr);
		break;

	case EVT_IO_CAPABILITY_REQUEST:
		io_capa_request(dev, &di->bdaddr, (bdaddr_t *) ptr);
		break;

	case EVT_IO_CAPABILITY_RESPONSE:
		io_capa_response(dev, &di->bdaddr, ptr);
		break;

	case EVT_USER_CONFIRM_REQUEST:
		user_confirm_request(dev, &di->bdaddr, ptr);
		break;

	case EVT_USER_PASSKEY_REQUEST:
		user_passkey_request(dev, &di->bdaddr, ptr);
		break;

	case EVT_USER_PASSKEY_NOTIFY:
		user_passkey_notify(dev, &di->bdaddr, ptr);
		break;

	case EVT_REMOTE_OOB_DATA_REQUEST:
		remote_oob_data_request(dev, &di->bdaddr, ptr);
		break;
	}

	return TRUE;
}

这个函数接收到远程设备发送过来的socket数据，然后解析出cmd，并执行对应的操作。在这里，用9510和PC配对，PC收到如下消息：

手机端输入PIN码前：

EVT_CONN_REQUEST
EVT_CMD_STATUS
EVT_PIN_CODE_REQ
bluetoothd[2395]: pin_code_request (sba=00:1C:26:FB:26:DC, dba=36:15:00:EF:80:6E)
手机端输入PIN码后：
EVT_CMD_COMPLETE
EVT_LINK_KEY_NOTIFY
bluetoothd[2395]: link_key_notify (sba=00:1C:26:FB:26:DC, dba=36:15:00:EF:80:6E, type=0)
EVT_CONN_COMPLETE
EVT_CMD_STATUS
EVT_READ_REMOTE_FEATURES_COMPLETE
EVT_CMD_STATUS
EVT_REMOTE_NAME_REQ_COMPLETE
EVT_CMD_STATUS
EVT_REMOTE_NAME_REQ_COMPLETE
EVT_CMD_STATUS
EVT_DISCONN_COMPLETE

下面看以下各个CMD是啥意思。


EVT_CONN_REQUEST:

static inline void conn_request(int dev, bdaddr_t *sba, void *ptr)
{
	evt_conn_request *evt = ptr;
	uint32_t class = evt->dev_class[0] | (evt->dev_class[1] << 8)
				| (evt->dev_class[2] << 16);

	hcid_dbus_remote_class(sba, &evt->bdaddr, class);//从本地/var/lib/buetooth/bdaddr/classes文件中读取来配对地址的class值，如果有变化，dbus通知

	write_remote_class(sba, &evt->bdaddr, class);//将class写入/var/lib/buetooth/bdaddr/classes文件
}



EVT_CMD_STATUS：

static inline void cmd_status(int dev, bdaddr_t *sba, void *ptr)
{
	evt_cmd_status *evt = ptr;
	uint16_t opcode = btohs(evt->opcode);

	if (opcode == cmd_opcode_pack(OGF_LINK_CTL, OCF_INQUIRY))
		start_inquiry(sba, evt->status, FALSE);
}
linuxheik
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
bose_qc35-ubuntu：通过蓝牙将Bose QuietComfort 35与Ubuntu配对
02-06
对于音频爱好者来说，能够将自己的设备，如Bose QuietComfort 35（简称Bose QC35）无线耳机，与Ubuntu系统完美配对是一项基本需求。本文将详细解释如何在Ubuntu上配置蓝牙连接，特别是针对Bose QC35耳机。 首先，...
ubuntu蓝牙连接问题
lvh98的博客
06-05 1615
之前我发现电脑有蓝牙图标，且能打开关闭，就以为蓝牙默认已经配置好了，直到有一天我尝试连接我的蓝牙耳机才发现，电脑根本搜不到蓝牙设备。于是我在网上搜了一些资料，现在终于解决了。安装驱动后，电脑已经可以搜索到蓝牙设备了，但是此时我的蓝牙耳机依然连接不上。按照参考博客的说法可能是因为耳机不能在MAC地址和多个设备联系的情况下工作。当你的蓝牙搜索不到设备，可以检查一下你的蓝牙是否安装驱动。mac地址可以在蓝牙设置里面找到，只要能搜索到设备。此时可以得知，我的电脑确实是缺少蓝牙驱动。按照readme中的步骤即可。
bluetoothd源码剖析(一)启动流程
weixin_41069709的博客
06-23 2569
bluetoothd启动流程详解
Ubuntu系统设置显示蓝牙已禁用
最新发布
dreaming_song的博客
07-16 458
解决Ubuntu显示蓝牙已禁用的问题。
蓝牙bluetooth基础知识介绍+实战调试
a2591748032的博客
01-14 3593
蓝牙bluetooth基础知识介绍+实战调试
Linux-bluetooth蓝牙
Paper_Love的博客
11-02 902
bluetooth
ubuntu基本操作.pdf
03-03
- **背景**: 双系统环境下，特别是Ubuntu与Windows共存时，蓝牙键盘的配对可能会出现问题。 - **步骤**: - 配置蓝牙链接键文件，例如`sudo vim /var/lib/bluetooth/DC:85:DE:C8:19:B8/linkkeys`。 - 具体操作参考...
实战Linux Bluetooth编程
07-24
6. **安全与配对**：理解蓝牙的安全模型很重要，包括PIN码、密钥协商和授权过程。blueZ支持多种安全模式和配对方法，确保数据的安全传输。 7. **事件处理**：通过注册回调函数或使用D-Bus消息系统，监听设备状态...
Ubuntu20.04 lts Linux 蓝牙驱动
01-28
在Ubuntu中，可以使用`sudo systemctl start bluetooth`启动蓝牙服务，`sudo systemctl enable bluetooth`设置开机启动。 6. **测试驱动**：最后，通过`bluetoothctl`或图形界面进行蓝牙设备配对和连接测试，验证...
解决ubuntu 20 和windows10 双系统蓝牙鼠标重新匹配.docx
03-09
标题中的“解决ubuntu 20 和windows10 双系统蓝牙鼠标重新匹配”是指在运行Ubuntu 20.04和Windows 10的双系统环境下，用户在切换操作系统时发现蓝牙鼠标需要重新进行配对才能正常使用的问题。这个问题通常由于两个...
[Android源码分析]bluez internal event的处理
836811384
11-19 264
在上面2.1中是hci dev的注册和up，2.3中有bluez的初始化，这两者是有一个交集的，那就是说bluez初始化后会监听hci dev的一些event，主要有HCI_DEV_REG和HCI_DEV_UP两个比较重要，那本集就是主要分析这两个event带来的影响。 从上面的分析中，我们已经知道，这两个event的处理函数是io_stack_event： static gbool...
【蓝牙】基于Bluez的Bluetoothctl BLE开发
love131452098的博客
04-29 8984
对于BLE的开发，大部分的BLE开发者都是在BLE芯片原厂的SDK基础上进行BLE的应用开发，跟更多的是基于SDK的应用开发而对于BLE的协议、框架知之甚少. 另外芯片原厂也不会暴露过多底层的接口给到开发者，开发者想要深入理解也无法下手，然后Linux平台提供了一个开源的蓝牙协议栈(传统蓝牙+BLE), 给了BLE开发者一个深入理解的入口，无论你是Linux还是RTOS的开发人员，只要希望能够对BLE有更深入的理解，都希望能开始接触到Linux下的BLE Over Bluez的开发、学习. 本篇文章主要.
bluez plugins
Luohsh1的专栏
08-30 1768
When Bluetoothd initializing, it will load plugins in /usr/lib/bluetooth/plugins by default. Actually, most of bluetooth profiles are implemented as plugins in BlueZ. In plugin.h, it defines:
Bluetoothd-dbus学习
hjj801006的专栏
05-17 508
dbus-glib安装调试
BlueZ调试工具的使用
Dokin
04-01 6978
1. bluetoothctl 在编译BlueZ时，如果configure配置添加了“–enable-client”，就会编译生成Bluetoothctl工具。如果类比于WiFi，bluetoothd相当于wpa_supplicant，bluetoothctl相当于wpa_cli。 bluetoothctl内部集成了一个shell交互功能，直接在命令行运行bluetoothctl工具即可进入该工具的内部shell，输入help可以查看该工具支持的命令。 [bluetooth]# help Menu main
linux如何进行蓝牙调试,ubuntu bluetooth 调试
weixin_35691715的博客
05-16 2194
configure: error: D-Bus library is required解决方法：sudo apt-get install libdbus-1-dev libdbus-glib-1-devmake -j4最终产生bluetoothd，在src/.libs/目录下。运行在ubuntu下，系统启动时默认已经启动里了bluetoothd，只是这个bluetoothd位于/usr/sbin/...
bluetoothd的启动流程
badogyang的博客
11-28 339
梳理bluetoothd的启动流程，总结一下。
Ubuntu 蓝牙GPS配对OpenCPN指南
对于Ubuntu 12.04，配置过程略有不同，包括与GPS设备通过蓝牙图标配对，断开连接，获取设备ID，以及通过sdptool records命令查找GPS通道。在编辑/etc/bluetooth/rfcomm.conf文件中，用户可以设置GPS的连接参数。 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值