bs_screen.c

可以搜索处于隐藏模式的蓝牙设备。 编译安装参照readme文件

			break;
		}
	}
	if (!found) {
		for (i=0; major_device_classes[i].class_name; i++) {
			if (major_device_classes[i].class_id == MAJOR_CLASS_DEFAULT) {
				strncat(buf, major_device_classes[i].class_name, SCR_BUF_SZ);
				buf[SCR_BUF_SZ-1] = 0;
				break;
			}
		}
	} else if (found && major_device_classes[majorc_id].sub_major)  {
		/* the minor */
		scp = major_device_classes[majorc_id].sub_major;
		for (found=i=0; scp[i].class_name; i++) {
			if ((minorc & major_device_classes[majorc_id].sub_major_mask)
			  == scp[i].class_id) {
				if (found)
					strncat(buf, ",", SCR_BUF_SZ);
				else
					strncat(buf, "/", SCR_BUF_SZ);
				buf[SCR_BUF_SZ-1] = 0;
				strncat(buf, scp[i].class_name, SCR_BUF_SZ);
				buf[SCR_BUF_SZ-1] = 0;
				found++;
				if (major_device_classes[majorc_id].type == CLASS_CHOOSE)
					break;
			}
		}

		if (major_device_classes[majorc_id].sub_minor) {
		/* the really minor */
		scp = major_device_classes[majorc_id].sub_minor;
		for (found=i=0; scp[i].class_name; i++) {
			if ((minorc & major_device_classes[majorc_id].sub_minor_mask)
			  == scp[i].class_id) {
				if (found)
					strncat(buf, ",", SCR_BUF_SZ);
				else
					strncat(buf, "/", SCR_BUF_SZ);
				buf[SCR_BUF_SZ-1] = 0;
				strncat(buf, scp[i].class_name, SCR_BUF_SZ);
				buf[SCR_BUF_SZ-1] = 0;
				found++;
				if (major_device_classes[majorc_id].type == CLASS_CHOOSE)
					break;
			}
		}
		/* end the really minor */
		}
	}
	

	/* print the services */
	strncat(buf, "\nServices:     ", SCR_BUF_SZ);
	buf[SCR_BUF_SZ-1] = 0;
	for (found=i=0; service_classes[i].class_name; i++) {
		if (0 != (service_classes[i].class_id & services)) {
			if(found) strncat(buf, ",", SCR_BUF_SZ);
			buf[SCR_BUF_SZ-1] = 0;
			strncat(buf, service_classes[i].class_name, SCR_BUF_SZ);
			buf[SCR_BUF_SZ-1] = 0;
			found=1;
		}
	}
	strncat(buf, "\n\nHCI probe\n---------\n", SCR_BUF_SZ);
	buf[SCR_BUF_SZ-1] = 0;
	bs_processlines(pi, buf);

	/* stuff we may have got */
	if (p->got_version) {
		snprintf(buf, SCR_BUF_SZ,
		  "LMP Version:  %s (0x%x) LMP Subversion: 0x%x\n"
		  "Manufacturer: %s (%d)\n",
		  lmp_vertostr(p->version.lmp_ver), p->version.lmp_ver,
		  p->version.lmp_subver,
		  bt_compidtostr(p->version.manufacturer), p->version.manufacturer);
	} else {
		snprintf(buf, SCR_BUF_SZ,
		  "LMP Version:  n/a (n/a) LMP Subversion: n/a\n"
		  "Manufacturer: n/a (n/a)\n");
	}
	buf[SCR_BUF_SZ-1] = 0;
	bs_processlines(pi, buf);

	if (p->got_features) {
		snprintf(buf, SCR_BUF_SZ,
		  "Features:     0x%2.2x 0x%2.2x 0x%2.2x 0x%2.2x\n%s\n",
		  p->features[0], p->features[1], p->features[2], p->features[3],
		  lmp_featurestostr(p->features, "\t", 3));
	} else {
		snprintf(buf, SCR_BUF_SZ,
		  "Features:     n/a n/a n/a n/a\n");
	}
	buf[SCR_BUF_SZ-1] = 0;
	bs_processlines(pi, buf);

	/* sdp, this is messy */
	bs_processlines(pi, "\nSDP probe\n---------\n");
	if (p->sdp_info) {
		bs_print_services(pi, p->sdp_info->sub);
	}

	bs_displaylines(pi, w);

	return 0;
}

/* update the rssi value and stuff */
int bs_screen_update_link_info(device_t *p)
{
	/* location: stdscr(y,x): 1,1 */
	int y,x;
	getmaxyx(stdscr, y, x);
	wmove(stdscr, 1, 1);
	wclrtoeol(stdscr);

	if (p->rssi_status)
		wprintw(stdscr, "RSSI: ERR");
	else
		wprintw(stdscr, "RSSI: %+4d", p->rssi);

	if (p->lq_status)
		wprintw(stdscr, "   Link q: ERR");
	else
		wprintw(stdscr, "   Link q: %03d", p->lq);

	mvwaddch(stdscr, 1, x-1, ACS_VLINE);
	return 0;
}


/* see if we can get more info */
int bs_screen_query_device(WINDOW *w, struct proc_info *pi, int dnum, int *dl)
{
	int i, ch, ret, runscan, lc;
	device_t *p;
	int o_gf, o_gv;
	int x,y;

	ret = 0;
	/* clear the window ready for the content */
	werase(w);
	getmaxyx(w, y, x);
	pi->scr_lines_start = 0;
	pi->scr_lines_end = y;

	/* find the right device */
	pthread_mutex_lock(&(pi->dhead_mutex));
	for (i=0, p=pi->dhead; i != dnum && p; i++, p=p->next);
	pthread_mutex_unlock(&(pi->dhead_mutex));

	if (NULL == p) {
		mvwaddstr(w, 0, 0, "Unable to find the bluetooth device address");
		ret = -1;
		goto bs_screen_query_device_leave;
	}

	pthread_mutex_lock(&(pi->proc_info_mutex));
	if(p) bacpy(&(pi->query_bd), &(p->bdaddr));
	pthread_mutex_unlock(&(pi->proc_info_mutex));

	runscan = 1;
	lc = o_gf = o_gv = 0;
	while (*dl && runscan) {

/*
		pthread_mutex_lock(&(pi->proc_info_mutex));
		if (pi->info_error) {
			werase(w);
			mvwaddstr(w, 0,0, pi->info_error);
			free(pi->info_error);
			pi->info_error = NULL;
		}
		pthread_mutex_unlock(&(pi->proc_info_mutex));
*/

		pthread_mutex_lock(&(pi->dhead_mutex));
		/* add the advanced details to w */
		if (o_gf != p->got_features || o_gv != p->got_version || 0==lc) {
			bs_screen_show_details(w, pi, p);
			o_gf = p->got_features;
			o_gv = p->got_version;
		}

		/* add the rssi/lq to stdscr */
		bs_screen_update_link_info(p);

		pthread_mutex_unlock(&(pi->dhead_mutex));

		/* refresh */
		wrefresh(w);
		wrefresh(stdscr);
		lc++;

		ch = wgetch(w);
		switch(ch) {
		case 'q':
			runscan = 0;
			break;
		case KEY_RESIZE:
			bs_screen_resize();
			bs_screen_subwin_resize(stdscr, w);
			/* scrolling help */
			getmaxyx(w, y, x);
			pi->scr_lines_start = 0;
			pi->scr_lines_end = y;

			if(bs_screen_checksize()) {
				*dl = 0;
				werase(stdscr);
				mvwaddstr(stdscr, 0, 0, "Screen too small");
				wrefresh(stdscr);
				sleep(1);
				break;
			}
			bs_screen_cbt(stdscr, pi->title, pi->tlen);
			lc=0;
			break;
		case KEY_UP:
			lc = 0;
			getmaxyx(w, y, x);
			if (pi->scr_lines_start > 0) {
				pi->scr_lines_start--;
				pi->scr_lines_end = pi->scr_lines_start+y;
			}
			break;
		case KEY_DOWN:
			lc = 0;
			getmaxyx(w, y, x);
			if (pi->scr_lines_end < pi->scr_lines) {
				pi->scr_lines_start++;
				pi->scr_lines_end = pi->scr_lines_start+y;
			}
			break;
		}
	}


	bs_screen_query_device_leave:
	werase(w);
	bs_freelines(pi);

	/* dont scan anymore */
	pthread_mutex_lock(&(pi->proc_info_mutex));
	memset(&(pi->query_bd), 0, sizeof(bdaddr_t));

	/* print the query info, or the error */
	if (pi->scanner_error) {
		mvwaddstr(w, 0, 0, "Error: ");
		waddstr(w, pi->info_error);
		ret = 1;
	}
	pthread_mutex_unlock(&(pi->proc_info_mutex));

	/* if an error, show it */
	if (ret == -1) {
		wrefresh(w);
		sleep(1);
	}

	return ret;
}

/* run the screen thread */
void *bs_runscreen(void *arg)
{
	struct proc_info *pi = (struct proc_info*)arg;
	char bas[32];
	int i, ch, itemsel, nitems, y, x;
	int *doloop = NULL;
	sigset_t sset;
	WINDOW *cw = NULL;

	if (NULL == pi)
		goto bs_runscreen_leave;

	doloop = (int*)malloc(sizeof(int));
	if (NULL == doloop)
		goto bs_runscreen_leave;
	*doloop = 1;
	if (0 != (i = pthread_setspecific(doloop_key, doloop)))
		goto bs_runscreen_leave;

	/* copy the init stuff */
	pthread_mutex_lock(&(pi->proc_info_mutex));
	ba2str(&(pi->dev_bd), bas);
	pthread_mutex_unlock(&(pi->proc_info_mutex));

	if (0 == *doloop)
		goto bs_runscreen_leave;

	/* signals */
	memset (&sset, 0, sizeof(sset));
	sigfillset(&sset);
	sigdelset(&sset, SIGKILL);
	sigdelset(&sset, SIGSTOP);
	sigdelset(&sset, SIGTERM);
	sigdelset(&sset, SIGINT);
	sigdelset(&sset, SIGSEGV);
	sigdelset(&sset, SIGUSR1);
	if (0 != pthread_sigmask(SIG_SETMASK, &sset, NULL))
		goto bs_runscreen_leave;


	/* initialise the screen */
	bs_screen_on();

	/* check to the min screen width */
	if(bs_screen_checksize()) {
		mvwaddstr(stdscr, 0, 0, "Screen too small");
		wrefresh(stdscr);
		sleep(1);
		goto bs_runscreen_leave;
	}

	/* make the title */
	pi->tlen = strlen(bas) + 16;
	pi->title = (char*)malloc(pi->tlen*sizeof(char));
	if (NULL == pi->title)
		goto bs_runscreen_leave;
	snprintf(pi->title, pi->tlen, "Base Address: %s", bas);
	pi->title[pi->tlen-1] = 0;

	/* create the content window */
	cw = bs_screen_subwin(stdscr);
	if(NULL == cw) {
		mvwaddstr(stdscr, 0, 0, "Unable to make subwindow");
		wrefresh(stdscr);
		sleep(1);
		goto bs_runscreen_leave;
	}
	/* scrolling help */
	getmaxyx(cw, y, x);
	pi->scr_lines_start = 0;
	pi->scr_lines_end = y;

	/* draw the title */
	bs_screen_cbt(stdscr, pi->title, pi->tlen);
	/* ... and the footer */
	itemsel = nitems = 0;
	bs_screen_footer(stdscr, nitems);


	/* loop */
	while (*doloop) {
		/* draw the content */
		werase(cw);
		nitems = bs_screen_drawlist(cw, pi, itemsel);
		bs_screen_footer(stdscr, nitems);

		/* refresh */
		wrefresh(cw);
		wrefresh(stdscr);

		ch = wgetch(cw);
		switch (ch) {
		case 'q':
			*doloop = 0;
			break;
		case KEY_RESIZE:
			bs_screen_resize();
			bs_screen_subwin_resize(stdscr, cw);
			/* scrolling help */
			getmaxyx(cw, y, x);
			pi->scr_lines_start = 0;
			pi->scr_lines_end = y;

			if(bs_screen_checksize()) {
				*doloop = 0;
				werase(stdscr);
				mvwaddstr(stdscr, 0, 0, "Screen too small");
				wrefresh(stdscr);
				sleep(1);
				break;
			}
			bs_screen_cbt(stdscr, pi->title, pi->tlen);
			break;
		case KEY_UP:
			if (nitems > 0)
				if(itemsel == 0) {
					itemsel = nitems-1;
				} else {
					itemsel--; itemsel %= nitems;
				}
			else
				itemsel = 0;
			break;
		case KEY_DOWN:
			if (nitems > 0) {
				itemsel++; itemsel %= nitems;
			} else
				itemsel = 0;
			break;
		case 13:
			bs_screen_query_device(cw, pi, itemsel, doloop);
			werase(cw);
			bs_screen_cbt(stdscr, pi->title, pi->tlen);
			/* more info needed, connect and get details */
			break;
		}
	}

	/* byebye */
	bs_runscreen_leave:
	if(doloop) free(doloop);
	if (cw) delwin(cw);
	bs_screen_off();
	if (pi->title) free(pi->title);
	pthread_mutex_lock(&(pi->proc_info_mutex));
	for (i=0; i<MAX_WORK_THREADS; i++) {
		if (pi->thr_ids[i] == pthread_self()) {
			pi->thr_died[i] = 1;
			break;
		}
	}
	pthread_mutex_unlock(&(pi->proc_info_mutex));
	pthread_exit(0);
}