* [PATCH v3 1/5] android: Add haltest skeleton
2013-10-16 14:00 [PATCH v3 0/5] Stack independent BT HAL test tool Jerzy Kasenberg
@ 2013-10-16 14:00 ` Jerzy Kasenberg
2013-10-16 14:00 ` [PATCH v3 2/5] android: Add line editing to haltest Jerzy Kasenberg
` (4 subsequent siblings)
5 siblings, 0 replies; 7+ messages in thread
From: Jerzy Kasenberg @ 2013-10-16 14:00 UTC (permalink / raw)
To: linux-bluetooth; +Cc: Jerzy Kasenberg
This tool will be used to test Android Bluetooth HAL implementation.
---
android/Android.mk | 17 ++++++
android/client/haltest.c | 51 ++++++++++++++++++
android/client/pollhandler.c | 123 ++++++++++++++++++++++++++++++++++++++++++
android/client/pollhandler.h | 26 +++++++++
4 files changed, 217 insertions(+)
create mode 100644 android/client/haltest.c
create mode 100644 android/client/pollhandler.c
create mode 100644 android/client/pollhandler.h
diff --git a/android/Android.mk b/android/Android.mk
index 0e025ac..c2a0797 100644
--- a/android/Android.mk
+++ b/android/Android.mk
@@ -49,3 +49,20 @@ LOCAL_MODULE_TAGS := optional
LOCAL_MODULE_CLASS := SHARED_LIBRARIES
include $(BUILD_SHARED_LIBRARY)
+
+#
+# haltest
+#
+
+include $(CLEAR_VARS)
+
+LOCAL_SRC_FILES := \
+ client/haltest.c \
+ client/pollhandler.c \
+
+LOCAL_SHARED_LIBRARIES := libhardware
+
+LOCAL_MODULE_TAGS := optional
+LOCAL_MODULE := haltest
+
+include $(BUILD_EXECUTABLE)
diff --git a/android/client/haltest.c b/android/client/haltest.c
new file mode 100644
index 0000000..11cdd97
--- /dev/null
+++ b/android/client/haltest.c
@@ -0,0 +1,51 @@
+/*
+ * Copyright (C) 2013 Intel Corporation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#include <stdlib.h>
+#include <poll.h>
+#include <unistd.h>
+
+#include "pollhandler.h"
+
+
+/* called when there is something on stdin */
+static void stdin_handler(struct pollfd *pollfd)
+{
+ char buf[10];
+
+ if (pollfd->revents & POLLIN) {
+ int count = read(0, buf, 10);
+
+ if (count > 0) {
+ int i;
+
+ for (i = 0; i < count; ++i) {
+ /* TODO: process input */
+ }
+ }
+ }
+}
+
+int main(int argc, char **argv)
+{
+ /* Register command line handler */
+ poll_register_fd(0, POLLIN, stdin_handler);
+
+ poll_dispatch_loop();
+
+ return 0;
+}
diff --git a/android/client/pollhandler.c b/android/client/pollhandler.c
new file mode 100644
index 0000000..4e982b8
--- /dev/null
+++ b/android/client/pollhandler.c
@@ -0,0 +1,123 @@
+/*
+ * Copyright (C) 2013 Intel Corporation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#include <stdio.h>
+#include <errno.h>
+#include <poll.h>
+
+#include "pollhandler.h"
+
+/*
+ * Code that allows to poll multiply file descriptors for events
+ * File descriptors can be added and removed at runtime
+ *
+ * Call poll_register_fd function first to add file descriptors to monitor
+ * Then call poll_dispatch_loop that will poll all registered file descriptors
+ * as long as they are not unregistered.
+ *
+ * When event happen on given fd appropriate user supplied handler is called
+ */
+
+/* Maximum number of files to monitor */
+#define MAX_OPEN_FD 10
+
+/* Storage for pollfd structures for monitored file descriptors */
+static struct pollfd fds[MAX_OPEN_FD];
+static poll_handler fds_handler[MAX_OPEN_FD];
+/* Number of registered file descriptors */
+static int fds_count = 0;
+
+/*
+ * Function polls file descriptor in loop and calls appropriate handler
+ * on event. Function returns when there is no more file descriptor to
+ * monitor
+ */
+void poll_dispatch_loop(void)
+{
+ while (fds_count > 0) {
+ int i;
+ int cur_fds_count = fds_count;
+ int ready = poll(fds, fds_count, 1000);
+
+ for (i = 0; i < fds_count && ready > 0; ++i) {
+ if (fds[i].revents == 0)
+ continue;
+
+ fds_handler[i](fds + i);
+ ready--;
+ /*
+ * If handler was remove from table
+ * just skip the rest and poll again
+ * This is due to reordering of tables in
+ * register/unregister functions
+ */
+ if (cur_fds_count != fds_count)
+ break;
+ }
+ /*
+ * This seems to be needed for correct output handling
+ * when all waiting is performed in poll
+ */
+ fflush(stdout);
+ }
+}
+
+/*
+ * Registers file descriptor to be monitored for events (see man poll(2))
+ * for events.
+ *
+ * return non negative value on success
+ * -EMFILE when there are to much descriptors
+ */
+int poll_register_fd(int fd, short events, poll_handler ph)
+{
+ if (fds_count >= MAX_OPEN_FD)
+ return -EMFILE;
+
+ fds_handler[fds_count] = ph;
+ fds[fds_count].fd = fd;
+ fds[fds_count].events = events;
+ fds_count++;
+
+ return fds_count;
+}
+
+/*
+ * Unregisters file descriptor
+ * Both fd and ph must match previously registered data
+ *
+ * return 0 if unregister succeeded
+ * -EBADF if arguments do not match any register handler
+ */
+int poll_unregister_fd(int fd, poll_handler ph)
+{
+ int i;
+
+ for (i = 0; i < fds_count; ++i) {
+ if (fds_handler[i] == ph && fds[i].fd == fd) {
+ fds_count--;
+ if (i < fds_count) {
+ fds[i].fd = fds[fds_count].fd;
+ fds[i].events = fds[fds_count].events;
+ fds_handler[i] = fds_handler[fds_count];
+ }
+ return 0;
+ }
+ }
+ return -EBADF;
+}
+
diff --git a/android/client/pollhandler.h b/android/client/pollhandler.h
new file mode 100644
index 0000000..e2f22df
--- /dev/null
+++ b/android/client/pollhandler.h
@@ -0,0 +1,26 @@
+/*
+ * Copyright (C) 2013 Intel Corporation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#include <poll.h>
+
+/* Function to be called when there are event for some descriptor */
+typedef void (*poll_handler)(struct pollfd *pollfd);
+
+int poll_register_fd(int fd, short events, poll_handler ph);
+int poll_unregister_fd(int fd, poll_handler ph);
+
+void poll_dispatch_loop(void);
--
1.7.9.5
^ permalink raw reply related [flat|nested] 7+ messages in thread* [PATCH v3 2/5] android: Add line editing to haltest
2013-10-16 14:00 [PATCH v3 0/5] Stack independent BT HAL test tool Jerzy Kasenberg
2013-10-16 14:00 ` [PATCH v3 1/5] android: Add haltest skeleton Jerzy Kasenberg
@ 2013-10-16 14:00 ` Jerzy Kasenberg
2013-10-16 14:00 ` [PATCH v3 3/5] android: Add history to line editor in haltest Jerzy Kasenberg
` (3 subsequent siblings)
5 siblings, 0 replies; 7+ messages in thread
From: Jerzy Kasenberg @ 2013-10-16 14:00 UTC (permalink / raw)
To: linux-bluetooth; +Cc: Jerzy Kasenberg
Android does not have readline.
This patch allows to edit command line.
---
android/Android.mk | 1 +
android/client/haltest.c | 39 +++-
android/client/terminal.c | 431 +++++++++++++++++++++++++++++++++++++++++++++
android/client/terminal.h | 59 +++++++
4 files changed, 527 insertions(+), 3 deletions(-)
create mode 100644 android/client/terminal.c
create mode 100644 android/client/terminal.h
diff --git a/android/Android.mk b/android/Android.mk
index c2a0797..2eac3ec 100644
--- a/android/Android.mk
+++ b/android/Android.mk
@@ -59,6 +59,7 @@ include $(CLEAR_VARS)
LOCAL_SRC_FILES := \
client/haltest.c \
client/pollhandler.c \
+ client/terminal.c \
LOCAL_SHARED_LIBRARIES := libhardware
diff --git a/android/client/haltest.c b/android/client/haltest.c
index 11cdd97..de98079 100644
--- a/android/client/haltest.c
+++ b/android/client/haltest.c
@@ -19,8 +19,40 @@
#include <poll.h>
#include <unistd.h>
+#include "terminal.h"
#include "pollhandler.h"
+/*
+ * This function changes input parameter line_buffer so it has
+ * null termination after each token (due to strtok)
+ * Output argv is filled with pointers to arguments
+ * returns number of tokens parsed - argc
+ */
+static int command_line_to_argv(char *line_buffer,
+ char *argv[], int argv_size)
+{
+ static const char *token_breaks = "\r\n\t ";
+ char *token;
+ int argc = 0;
+
+ token = strtok(line_buffer, token_breaks);
+ while (token != NULL && argc < (int) argv_size) {
+ argv[argc++] = token;
+ token = strtok(NULL, token_breaks);
+ }
+
+ return argc;
+}
+
+static void process_line(char *line_buffer)
+{
+ char *argv[10];
+ int argc;
+
+ argc = command_line_to_argv(line_buffer, argv, 10);
+
+ /* TODO: process command line */
+}
/* called when there is something on stdin */
static void stdin_handler(struct pollfd *pollfd)
@@ -33,15 +65,16 @@ static void stdin_handler(struct pollfd *pollfd)
if (count > 0) {
int i;
- for (i = 0; i < count; ++i) {
- /* TODO: process input */
- }
+ for (i = 0; i < count; ++i)
+ terminal_process_char(buf[i], process_line);
}
}
}
int main(int argc, char **argv)
{
+ terminal_setup();
+
/* Register command line handler */
poll_register_fd(0, POLLIN, stdin_handler);
diff --git a/android/client/terminal.c b/android/client/terminal.c
new file mode 100644
index 0000000..95108a0
--- /dev/null
+++ b/android/client/terminal.c
@@ -0,0 +1,431 @@
+/*
+ * Copyright (C) 2013 Intel Corporation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#include <stdio.h>
+#include <string.h>
+#include <ctype.h>
+#include <stdbool.h>
+#include <termios.h>
+
+#include "terminal.h"
+
+/*
+ * Character sequences recognized by code in this file
+ * Leading ESC 0x1B is not included
+ */
+#define SEQ_INSERT "[2~"
+#define SEQ_DELETE "[3~"
+#define SEQ_HOME "OH"
+#define SEQ_END "OF"
+#define SEQ_PGUP "[5~"
+#define SEQ_PGDOWN "[6~"
+#define SEQ_LEFT "[D"
+#define SEQ_RIGHT "[C"
+#define SEQ_UP "[A"
+#define SEQ_DOWN "[B"
+#define SEQ_STAB "[Z"
+#define SEQ_M_n "n"
+#define SEQ_M_p "p"
+#define SEQ_CLEFT "[1;5D"
+#define SEQ_CRIGHT "[1;5C"
+#define SEQ_CUP "[1;5A"
+#define SEQ_CDOWN "[1;5B"
+#define SEQ_SLEFT "[1;2D"
+#define SEQ_SRIGHT "[1;2C"
+#define SEQ_SUP "[1;2A"
+#define SEQ_SDOWN "[1;2B"
+#define SEQ_MLEFT "[1;3D"
+#define SEQ_MRIGHT "[1;3C"
+#define SEQ_MUP "[1;3A"
+#define SEQ_MDOWN "[1;3B"
+
+#define KEY_SEQUENCE(k) { KEY_##k, SEQ_##k }
+struct ansii_sequence {
+ int code;
+ const char *sequence;
+};
+
+/* Table connects single int key codes with character sequences */
+static const struct ansii_sequence ansii_sequnces[] = {
+ KEY_SEQUENCE(INSERT),
+ KEY_SEQUENCE(DELETE),
+ KEY_SEQUENCE(HOME),
+ KEY_SEQUENCE(END),
+ KEY_SEQUENCE(PGUP),
+ KEY_SEQUENCE(PGDOWN),
+ KEY_SEQUENCE(LEFT),
+ KEY_SEQUENCE(RIGHT),
+ KEY_SEQUENCE(UP),
+ KEY_SEQUENCE(DOWN),
+ KEY_SEQUENCE(CLEFT),
+ KEY_SEQUENCE(CRIGHT),
+ KEY_SEQUENCE(CUP),
+ KEY_SEQUENCE(CDOWN),
+ KEY_SEQUENCE(SLEFT),
+ KEY_SEQUENCE(SRIGHT),
+ KEY_SEQUENCE(SUP),
+ KEY_SEQUENCE(SDOWN),
+ KEY_SEQUENCE(MLEFT),
+ KEY_SEQUENCE(MRIGHT),
+ KEY_SEQUENCE(MUP),
+ KEY_SEQUENCE(MDOWN),
+ KEY_SEQUENCE(STAB),
+ KEY_SEQUENCE(M_p),
+ KEY_SEQUENCE(M_n),
+ { 0, NULL }
+};
+
+#define isseqence(c) ((c) == 0x1B)
+
+/*
+ * Number of characters that consist of ANSII sequence
+ * Should not be less then longest string in ansii_sequnces
+ */
+#define MAX_ASCII_SEQUENCE 10
+
+static char current_sequence[MAX_ASCII_SEQUENCE];
+static int current_sequence_len = -1;
+
+/* single line typed by user goes here */
+static char line_buf[LINE_BUF_MAX];
+/* index of cursor in input line */
+static int line_buf_ix = 0;
+/* current length of input line */
+static int line_len = 0;
+
+/*
+ * Moves cursor to right or left
+ *
+ * n - positive - moves cursor right
+ * n - negative - moves cursor left
+ */
+static void terminal_move_cursor(int n)
+{
+ if (n < 0) {
+ for (; n < 0; n++)
+ putchar('\b');
+ } else if (n > 0) {
+ printf("%*s", n, line_buf + line_buf_ix);
+ }
+}
+
+/* Draw command line */
+void terminal_draw_command_line(void)
+{
+ /*
+ * this needs to be checked here since line_buf is not cleard
+ * before parsing event though line_len and line_buf_ix are
+ */
+ if (line_len > 0)
+ printf(">%s", line_buf);
+ else
+ putchar('>');
+
+ /* move cursor to it's place */
+ terminal_move_cursor(line_len - line_buf_ix);
+}
+
+/* inserts string into command line at cursor position */
+void terminal_insert_into_command_line(const char *p)
+{
+ int len = strlen(p);
+
+ if (line_len == line_buf_ix) {
+ strcat(line_buf, p);
+ printf("%s", p);
+ line_len = line_len + len;
+ line_buf_ix = line_len;
+ } else {
+ memmove(line_buf + line_buf_ix + len,
+ line_buf + line_buf_ix, line_len - line_buf_ix + 1);
+ memmove(line_buf + line_buf_ix, p, len);
+ printf("%s", line_buf + line_buf_ix);
+ line_buf_ix += len;
+ line_len += len;
+ terminal_move_cursor(line_buf_ix - line_len);
+ }
+}
+
+/* Prints string and redraws command line */
+int terminal_print(const char *format, ...)
+{
+ va_list args;
+ int ret;
+
+ va_start(args, format);
+
+ ret = terminal_vprint(format, args);
+
+ va_end(args);
+ return ret;
+}
+
+/* Prints string and redraws command line */
+int terminal_vprint(const char *format, va_list args)
+{
+ int ret;
+
+ printf("\r%*s\r", (int) line_len + 1, " ");
+
+ ret = vprintf(format, args);
+
+ terminal_draw_command_line();
+
+ return ret;
+}
+
+/*
+ * Converts terminal character sequences to single value representing
+ * keyboard keys
+ */
+static int terminal_convert_sequence(int c)
+{
+ int i;
+
+ /* Not in sequence yet? */
+ if (current_sequence_len == -1) {
+ /* Is ansii sequence detected by 0x1B ? */
+ if (isseqence(c)) {
+ current_sequence_len++;
+ return 0;
+ }
+ return c;
+ }
+ /* Inside sequence */
+ current_sequence[current_sequence_len++] = c;
+ current_sequence[current_sequence_len] = '\0';
+ for (i = 0; ansii_sequnces[i].code; ++i) {
+ /* Matches so far? */
+ if (0 != strncmp(current_sequence, ansii_sequnces[i].sequence,
+ current_sequence_len))
+ continue;
+
+ /* Matches as a whole? */
+ if (ansii_sequnces[i].sequence[current_sequence_len] == 0) {
+ current_sequence_len = -1;
+ return ansii_sequnces[i].code;
+ }
+ /* partial match (not whole sequence yet) */
+ return 0;
+ }
+ terminal_print("ansii char 0x%X %c\n", c);
+ /*
+ * Sequence does not match
+ * mark that no in sequence any more, return char
+ */
+ current_sequence_len = -1;
+ return c;
+}
+
+void terminal_process_char(int c, void (*process_line)(char *line))
+{
+ int refresh_from = -1;
+ int old_pos;
+
+ c = terminal_convert_sequence(c);
+
+ switch (c) {
+ case 0:
+ break;
+ case KEY_LEFT:
+ /* if not at the beginning move to previous character */
+ if (line_buf_ix <= 0)
+ break;
+ line_buf_ix--;
+ terminal_move_cursor(-1);
+ break;
+ case KEY_RIGHT:
+ /*
+ * If not at the end, just print current character
+ * and modify position
+ */
+ if (line_buf_ix < line_len)
+ putchar(line_buf[line_buf_ix++]);
+ break;
+ case KEY_HOME:
+ /* move to beginning of line and update position */
+ putchar('\r');
+ putchar('>');
+ line_buf_ix = 0;
+ break;
+ case KEY_END:
+ /* if not at the end of line */
+ if (line_buf_ix < line_len) {
+ /* print everything from cursor */
+ printf("%s", line_buf + line_buf_ix);
+ /* just modify current position */
+ line_buf_ix = line_len;
+ }
+ break;
+ case KEY_DELETE:
+ /* delete character under cursor if not at the very end */
+ if (line_buf_ix >= line_len)
+ break;
+ /*
+ * Prepare buffer with one character missing
+ * trailing 0 is moved
+ */
+ line_len--;
+ memmove(line_buf + line_buf_ix,
+ line_buf + line_buf_ix + 1,
+ line_len - line_buf_ix + 1);
+ /* print rest of line from current cursor position */
+ printf("%s \b", line_buf + line_buf_ix);
+ /* move back cursor */
+ terminal_move_cursor(line_buf_ix - line_len);
+ break;
+ case KEY_CLEFT:
+ /*
+ * Move by word left
+ *
+ * Are we at the beginning of line?
+ */
+ if (line_buf_ix <= 0)
+ break;
+
+ old_pos = line_buf_ix;
+ line_buf_ix--;
+ /* skip spaces left */
+ while (line_buf_ix && isspace(line_buf[line_buf_ix]))
+ line_buf_ix--;
+ /* skip all non spaces to the left */
+ while (line_buf_ix > 0 &&
+ !isspace(line_buf[line_buf_ix - 1]))
+ line_buf_ix--;
+ /* move cursor to new position */
+ terminal_move_cursor(line_buf_ix - old_pos);
+ break;
+ case KEY_CRIGHT:
+ /*
+ * Move by word right
+ *
+ * are we at the end of line?
+ */
+ if (line_buf_ix >= line_len)
+ break;
+
+ old_pos = line_buf_ix;
+ /* skip all spaces */
+ while (line_buf_ix < line_len &&
+ isspace(line_buf[line_buf_ix]))
+ line_buf_ix++;
+ /* skip all non spaces */
+ while (line_buf_ix < line_len &&
+ !isspace(line_buf[line_buf_ix]))
+ line_buf_ix++;
+ /*
+ * Move cursor to right by printing text
+ * between old cursor and new
+ */
+ if (line_buf_ix > old_pos)
+ printf("%.*s", (int) (line_buf_ix - old_pos),
+ line_buf + old_pos);
+ break;
+ case KEY_UP:
+ case KEY_DOWN:
+ break;
+ case '\n':
+ case '\r':
+ line_len = 0;
+ line_buf_ix = 0;
+ /* print new line */
+ putchar(c);
+ process_line(line_buf);
+ /* clear current line */
+ line_buf[0] = '\0';
+ putchar('>');
+ break;
+ case '\t':
+ /* tab processing */
+ /* TODO Add completion here */
+ break;
+ case KEY_BACKSPACE:
+ if (line_buf_ix <= 0)
+ break;
+
+ if (line_buf_ix == line_len) {
+ printf("\b \b");
+ line_len = --line_buf_ix;
+ line_buf[line_len] = 0;
+ } else {
+ putchar('\b');
+ refresh_from = --line_buf_ix;
+ line_len--;
+ memmove(line_buf + line_buf_ix,
+ line_buf + line_buf_ix + 1,
+ line_len - line_buf_ix + 1);
+ }
+ break;
+ case KEY_INSERT:
+ case KEY_PGUP:
+ case KEY_PGDOWN:
+ case KEY_CUP:
+ case KEY_CDOWN:
+ case KEY_SLEFT:
+ case KEY_SRIGHT:
+ case KEY_MLEFT:
+ case KEY_MRIGHT:
+ case KEY_MUP:
+ case KEY_MDOWN:
+ case KEY_STAB:
+ case KEY_M_n:
+ case KEY_M_p:
+ break;
+ default:
+ if (!isprint(c)) {
+ /*
+ * TODO: remove this print once all meaningful sequences
+ * are identified
+ */
+ printf("char-0x%02x\n", c);
+ break;
+ }
+ if (line_buf_ix < LINE_BUF_MAX - 1) {
+ if (line_len == line_buf_ix) {
+ putchar(c);
+ line_buf[line_buf_ix++] = (char) c;
+ line_len++;
+ line_buf[line_len] = '\0';
+ } else {
+ memmove(line_buf + line_buf_ix + 1,
+ line_buf + line_buf_ix,
+ line_len - line_buf_ix + 1);
+ line_buf[line_buf_ix] = c;
+ refresh_from = line_buf_ix++;
+ line_len++;
+ }
+ }
+ break;
+ }
+
+ if (refresh_from >= 0) {
+ printf("%s \b", line_buf + refresh_from);
+ terminal_move_cursor(line_buf_ix - line_len);
+ }
+}
+
+void terminal_setup(void)
+{
+ struct termios tios;
+
+ /* Turn off echo since all editing is done by hand */
+ tcgetattr(0, &tios);
+ tios.c_lflag &= ~(ICANON | ECHO);
+ tcsetattr(0, TCSANOW, &tios);
+ putchar('>');
+}
+
diff --git a/android/client/terminal.h b/android/client/terminal.h
new file mode 100644
index 0000000..e53750f
--- /dev/null
+++ b/android/client/terminal.h
@@ -0,0 +1,59 @@
+/*
+ * Copyright (C) 2013 Intel Corporation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#include <stdarg.h>
+
+/* size of supported line */
+#define LINE_BUF_MAX 1024
+
+enum key_codes {
+ KEY_BACKSPACE = 0x7F,
+ KEY_INSERT = 1000, /* arbitrary value */
+ KEY_DELETE,
+ KEY_HOME,
+ KEY_END,
+ KEY_PGUP,
+ KEY_PGDOWN,
+ KEY_LEFT,
+ KEY_RIGHT,
+ KEY_UP,
+ KEY_DOWN,
+ KEY_CLEFT,
+ KEY_CRIGHT,
+ KEY_CUP,
+ KEY_CDOWN,
+ KEY_SLEFT,
+ KEY_SRIGHT,
+ KEY_SUP,
+ KEY_SDOWN,
+ KEY_MLEFT,
+ KEY_MRIGHT,
+ KEY_MUP,
+ KEY_MDOWN,
+ KEY_STAB,
+ KEY_M_p,
+ KEY_M_n
+};
+
+void terminal_setup(void);
+int terminal_print(const char *format, ...);
+int terminal_vprint(const char *format, va_list args);
+void terminal_process_char(int c, void (*process_line)(char *line));
+void terminal_insert_into_command_line(const char *p);
+void terminal_draw_command_line(void);
+
+void process_tab(const char *line, int len);
--
1.7.9.5
^ permalink raw reply related [flat|nested] 7+ messages in thread* [PATCH v3 3/5] android: Add history to line editor in haltest
2013-10-16 14:00 [PATCH v3 0/5] Stack independent BT HAL test tool Jerzy Kasenberg
2013-10-16 14:00 ` [PATCH v3 1/5] android: Add haltest skeleton Jerzy Kasenberg
2013-10-16 14:00 ` [PATCH v3 2/5] android: Add line editing to haltest Jerzy Kasenberg
@ 2013-10-16 14:00 ` Jerzy Kasenberg
2013-10-16 14:00 ` [PATCH v3 4/5] android: Add text conversion helpers to haltest Jerzy Kasenberg
` (2 subsequent siblings)
5 siblings, 0 replies; 7+ messages in thread
From: Jerzy Kasenberg @ 2013-10-16 14:00 UTC (permalink / raw)
To: linux-bluetooth; +Cc: Jerzy Kasenberg
Added simple history to editor to save time.
---
android/Android.mk | 1 +
android/client/history.c | 98 +++++++++++++++++++++++++++++++++++++++++
android/client/history.h | 21 +++++++++
android/client/terminal.c | 107 +++++++++++++++++++++++++++++++++++++++++++++
4 files changed, 227 insertions(+)
create mode 100644 android/client/history.c
create mode 100644 android/client/history.h
diff --git a/android/Android.mk b/android/Android.mk
index 2eac3ec..d49056c 100644
--- a/android/Android.mk
+++ b/android/Android.mk
@@ -60,6 +60,7 @@ LOCAL_SRC_FILES := \
client/haltest.c \
client/pollhandler.c \
client/terminal.c \
+ client/history.c \
LOCAL_SHARED_LIBRARIES := libhardware
diff --git a/android/client/history.c b/android/client/history.c
new file mode 100644
index 0000000..90d9952
--- /dev/null
+++ b/android/client/history.c
@@ -0,0 +1,98 @@
+/*
+ * Copyright (C) 2013 Intel Corporation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+#include <ctype.h>
+
+#include "history.h"
+
+/*
+ * Very simple history storage for easy usage of tool
+ */
+
+#define HISTORY_DEPTH 20
+#define LINE_SIZE 100
+static char lines[HISTORY_DEPTH][LINE_SIZE];
+static int last_line = 0;
+static int history_size = 0;
+
+/* TODO: Storing history not implemented yet */
+void history_store(const char *filename)
+{
+}
+
+/* Restoring history from file */
+void history_restore(const char *filename)
+{
+ char line[1000];
+ FILE *f = fopen(filename, "rt");
+
+ if (f == NULL)
+ return;
+
+ for (;;) {
+ if (fgets(line, 1000, f) != NULL) {
+ int l = strlen(line);
+ while (l > 0 && isspace(line[--l]))
+ line[l] = 0;
+ if (l > 0)
+ history_add_line(line);
+ } else
+ break;
+ }
+ fclose(f);
+}
+
+/* Add new line to history buffer */
+void history_add_line(const char *line)
+{
+ if (line == NULL || strlen(line) == 0)
+ return;
+
+ if (strcmp(line, lines[last_line]) == 0)
+ return;
+
+ last_line = (last_line + 1) % HISTORY_DEPTH;
+ strncpy(&lines[last_line][0], line, LINE_SIZE - 1);
+ if (history_size < HISTORY_DEPTH)
+ history_size++;
+}
+
+/*
+ * Get n-th line from history
+ * 0 - means latest
+ * -1 - means oldest
+ * return -1 if there is no such line
+ */
+int history_get_line(int n, char *buf, int buf_size)
+{
+ if (n == -1)
+ n = history_size - 1;
+
+ if (n >= history_size || buf_size == 0 || n < 0)
+ return -1;
+
+ strncpy(buf,
+ &lines[(HISTORY_DEPTH + last_line - n) % HISTORY_DEPTH][0],
+ buf_size - 1);
+ buf[buf_size - 1] = 0;
+
+ return n;
+}
+
diff --git a/android/client/history.h b/android/client/history.h
new file mode 100644
index 0000000..26085b5
--- /dev/null
+++ b/android/client/history.h
@@ -0,0 +1,21 @@
+/*
+ * Copyright (C) 2013 Intel Corporation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+void history_store(const char *filename);
+void history_restore(const char *filename);
+void history_add_line(const char *line);
+int history_get_line(int n, char *buf, int buf_size);
diff --git a/android/client/terminal.c b/android/client/terminal.c
index 95108a0..9352328 100644
--- a/android/client/terminal.c
+++ b/android/client/terminal.c
@@ -22,6 +22,7 @@
#include <termios.h>
#include "terminal.h"
+#include "history.h"
/*
* Character sequences recognized by code in this file
@@ -107,6 +108,9 @@ static int line_buf_ix = 0;
/* current length of input line */
static int line_len = 0;
+/* line index used for fetching lines from history */
+static int line_index = 0;
+
/*
* Moves cursor to right or left
*
@@ -189,6 +193,87 @@ int terminal_vprint(const char *format, va_list args)
}
/*
+ * Call this when text in line_buf was changed
+ * and line needs to be redrawn
+ */
+static void terminal_line_replaced(void)
+{
+ int len = strlen(line_buf);
+
+ /* line is shorter that previous */
+ if (len < line_len) {
+ /* if new line is shorter move cursor to end of new end */
+ while (line_buf_ix > len) {
+ putchar('\b');
+ line_buf_ix--;
+ }
+ /* If cursor was not at the end, move it to the end */
+ if (line_buf_ix < line_len)
+ printf("%.*s", line_len - line_buf_ix,
+ line_buf + line_buf_ix);
+ /* over write end of previous line */
+ while (line_len >= len++)
+ putchar(' ');
+ }
+ /* draw new line */
+ printf("\r>%s", line_buf);
+ /* set up indexes to new line */
+ line_len = strlen(line_buf);
+ line_buf_ix = line_len;
+}
+
+/*
+ * Function tries to replace current line with specified line in history
+ * new_line_index - new line to show, -1 to show oldest
+ */
+static void terminal_get_line_from_history(int new_line_index)
+{
+ new_line_index = history_get_line(new_line_index,
+ line_buf, LINE_BUF_MAX);
+
+ if (new_line_index >= 0) {
+ terminal_line_replaced();
+ line_index = new_line_index;
+ }
+}
+
+/*
+ * Function searches history back or forward for command line that starts
+ * with characters up to cursor position
+ *
+ * back - true - searches backward
+ * back - false - searches forward (more recent commands)
+ */
+static void terminal_match_hitory(bool back)
+{
+ char buf[line_buf_ix + 1];
+ int line;
+ int matching_line = -1;
+ int dir = back ? 1 : -1;
+
+ line = line_index + dir;
+ while (matching_line == -1 && line >= 0) {
+ int new_line_index;
+
+ new_line_index = history_get_line(line, buf, line_buf_ix + 1);
+ if (new_line_index < 0)
+ break;
+
+ if (0 == strncmp(line_buf, buf, line_buf_ix))
+ matching_line = line;
+ line += dir;
+ }
+
+ if (matching_line >= 0) {
+ int pos = line_buf_ix;
+ terminal_get_line_from_history(matching_line);
+ /* move back to cursor position to origianl place */
+ line_buf_ix = pos;
+ terminal_move_cursor(pos - line_len);
+ }
+}
+
+/*
* Converts terminal character sequences to single value representing
* keyboard keys
*/
@@ -335,13 +420,30 @@ void terminal_process_char(int c, void (*process_line)(char *line))
printf("%.*s", (int) (line_buf_ix - old_pos),
line_buf + old_pos);
break;
+ case KEY_SUP:
+ terminal_get_line_from_history(-1);
+ break;
+ case KEY_SDOWN:
+ if (line_index > 0)
+ terminal_get_line_from_history(0);
+ break;
case KEY_UP:
+ terminal_get_line_from_history(line_index + 1);
+ break;
case KEY_DOWN:
+ if (line_index > 0)
+ terminal_get_line_from_history(line_index - 1);
break;
case '\n':
case '\r':
+ /*
+ * On new line add line to history
+ * forget history position
+ */
+ history_add_line(line_buf);
line_len = 0;
line_buf_ix = 0;
+ line_index = -1;
/* print new line */
putchar(c);
process_line(line_buf);
@@ -383,7 +485,12 @@ void terminal_process_char(int c, void (*process_line)(char *line))
case KEY_MDOWN:
case KEY_STAB:
case KEY_M_n:
+ /* Search history forward */
+ terminal_match_hitory(false);
+ break;
case KEY_M_p:
+ /* Search history backward */
+ terminal_match_hitory(true);
break;
default:
if (!isprint(c)) {
--
1.7.9.5
^ permalink raw reply related [flat|nested] 7+ messages in thread* [PATCH v3 4/5] android: Add text conversion helpers to haltest
2013-10-16 14:00 [PATCH v3 0/5] Stack independent BT HAL test tool Jerzy Kasenberg
` (2 preceding siblings ...)
2013-10-16 14:00 ` [PATCH v3 3/5] android: Add history to line editor in haltest Jerzy Kasenberg
@ 2013-10-16 14:00 ` Jerzy Kasenberg
2013-10-16 14:00 ` [PATCH v3 5/5] android: Add calls to adapter methods in haltest Jerzy Kasenberg
2013-10-16 15:34 ` [PATCH v3 0/5] Stack independent BT HAL test tool Johan Hedberg
5 siblings, 0 replies; 7+ messages in thread
From: Jerzy Kasenberg @ 2013-10-16 14:00 UTC (permalink / raw)
To: linux-bluetooth; +Cc: Jerzy Kasenberg
Application uses a lot of text in the form of defines found in header
files to represent arguments and output.
Conversion helpers keep functionality of converting string as
bt_status_t or uuid in one place.
---
android/Android.mk | 1 +
android/client/textconv.c | 205 +++++++++++++++++++++++++++++++++++++++++++++
android/client/textconv.h | 113 +++++++++++++++++++++++++
3 files changed, 319 insertions(+)
create mode 100644 android/client/textconv.c
create mode 100644 android/client/textconv.h
diff --git a/android/Android.mk b/android/Android.mk
index d49056c..6931c9c 100644
--- a/android/Android.mk
+++ b/android/Android.mk
@@ -61,6 +61,7 @@ LOCAL_SRC_FILES := \
client/pollhandler.c \
client/terminal.c \
client/history.c \
+ client/textconv.c \
LOCAL_SHARED_LIBRARIES := libhardware
diff --git a/android/client/textconv.c b/android/client/textconv.c
new file mode 100644
index 0000000..eebad70
--- /dev/null
+++ b/android/client/textconv.c
@@ -0,0 +1,205 @@
+/*
+ * Copyright (C) 2013 Intel Corporation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#include <string.h>
+#include <stdio.h>
+#include <hardware/bluetooth.h>
+
+#include "textconv.h"
+
+/*
+ * Following are maps of defines found in bluetooth header files to strings
+ *
+ * Those mappings are used to accurately use defines as input parameters in
+ * command line as well as for printing of statuses
+ */
+
+INTMAP(bt_status_t, -1, "(unknown)")
+ DELEMENT(BT_STATUS_SUCCESS),
+ DELEMENT(BT_STATUS_FAIL),
+ DELEMENT(BT_STATUS_NOT_READY),
+ DELEMENT(BT_STATUS_NOMEM),
+ DELEMENT(BT_STATUS_BUSY),
+ DELEMENT(BT_STATUS_DONE),
+ DELEMENT(BT_STATUS_UNSUPPORTED),
+ DELEMENT(BT_STATUS_PARM_INVALID),
+ DELEMENT(BT_STATUS_UNHANDLED),
+ DELEMENT(BT_STATUS_AUTH_FAILURE),
+ DELEMENT(BT_STATUS_RMT_DEV_DOWN),
+ENDMAP
+
+INTMAP(bt_state_t, -1, "(unknown)")
+ DELEMENT(BT_STATE_OFF),
+ DELEMENT(BT_STATE_ON),
+ENDMAP
+
+INTMAP(bt_device_type_t, -1, "(unknown)")
+ DELEMENT(BT_DEVICE_DEVTYPE_BREDR),
+ DELEMENT(BT_DEVICE_DEVTYPE_BLE),
+ DELEMENT(BT_DEVICE_DEVTYPE_DUAL),
+ENDMAP
+
+INTMAP(bt_scan_mode_t, -1, "(unknown)")
+ DELEMENT(BT_SCAN_MODE_NONE),
+ DELEMENT(BT_SCAN_MODE_CONNECTABLE),
+ DELEMENT(BT_SCAN_MODE_CONNECTABLE_DISCOVERABLE),
+ENDMAP
+
+INTMAP(bt_discovery_state_t, -1, "(unknown)")
+ DELEMENT(BT_DISCOVERY_STOPPED),
+ DELEMENT(BT_DISCOVERY_STARTED),
+ENDMAP
+
+INTMAP(bt_acl_state_t, -1, "(unknown)")
+ DELEMENT(BT_ACL_STATE_CONNECTED),
+ DELEMENT(BT_ACL_STATE_DISCONNECTED),
+ENDMAP
+
+INTMAP(bt_bond_state_t, -1, "(unknown)")
+ DELEMENT(BT_BOND_STATE_NONE),
+ DELEMENT(BT_BOND_STATE_BONDING),
+ DELEMENT(BT_BOND_STATE_BONDED),
+ENDMAP
+
+INTMAP(bt_ssp_variant_t, -1, "(unknown)")
+ DELEMENT(BT_SSP_VARIANT_PASSKEY_CONFIRMATION),
+ DELEMENT(BT_SSP_VARIANT_PASSKEY_ENTRY),
+ DELEMENT(BT_SSP_VARIANT_CONSENT),
+ DELEMENT(BT_SSP_VARIANT_PASSKEY_NOTIFICATION),
+ENDMAP
+
+INTMAP(bt_property_type_t, -1, "(unknown)")
+ DELEMENT(BT_PROPERTY_BDNAME),
+ DELEMENT(BT_PROPERTY_BDADDR),
+ DELEMENT(BT_PROPERTY_UUIDS),
+ DELEMENT(BT_PROPERTY_CLASS_OF_DEVICE),
+ DELEMENT(BT_PROPERTY_TYPE_OF_DEVICE),
+ DELEMENT(BT_PROPERTY_SERVICE_RECORD),
+ DELEMENT(BT_PROPERTY_ADAPTER_SCAN_MODE),
+ DELEMENT(BT_PROPERTY_ADAPTER_BONDED_DEVICES),
+ DELEMENT(BT_PROPERTY_ADAPTER_DISCOVERY_TIMEOUT),
+ DELEMENT(BT_PROPERTY_REMOTE_FRIENDLY_NAME),
+ DELEMENT(BT_PROPERTY_REMOTE_RSSI),
+ DELEMENT(BT_PROPERTY_REMOTE_VERSION_INFO),
+ DELEMENT(BT_PROPERTY_REMOTE_DEVICE_TIMESTAMP),
+ENDMAP
+
+INTMAP(bt_cb_thread_evt, -1, "(unknown)")
+ DELEMENT(ASSOCIATE_JVM),
+ DELEMENT(DISASSOCIATE_JVM),
+ENDMAP
+
+/* Find first index of given value in table m */
+int int2str_findint(int v, const struct int2str m[])
+{
+ int i;
+
+ for (i = 0; m[i].str; ++i) {
+ if (m[i].val == v)
+ return i;
+ }
+ return -1;
+}
+
+/* Find first index of given string in table m */
+int int2str_findstr(const char *str, const struct int2str m[])
+{
+ int i;
+
+ for (i = 0; m[i].str; ++i) {
+ if (strcmp(m[i].str, str) == 0)
+ return i;
+ }
+ return -1;
+}
+
+/*
+ * convert bd_addr to string
+ * buf must be at least 18 char long
+ *
+ * returns buf
+ */
+char *bt_bdaddr_t2str(const bt_bdaddr_t *bd_addr, char *buf)
+{
+ const char *p = (const char *) bd_addr;
+
+ snprintf(buf, 18, "%02x:%02x:%02x:%02x:%02x:%02x",
+ p[0], p[1], p[2], p[3], p[4], p[5]);
+
+ return buf;
+}
+
+/* converts string to bt_bdaddr_t */
+void str2bt_bdaddr_t(const char *str, bt_bdaddr_t *bd_addr)
+{
+ char *p = (char *) bd_addr;
+
+ sscanf(str, "%02hhx:%02hhx:%02hhx:%02hhx:%02hhx:%02hhx",
+ &p[0], &p[1], &p[2], &p[3], &p[4], &p[5]);
+}
+
+static const char BT_BASE_UUID[] = {
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00,
+ 0x80, 0x00, 0x00, 0x80, 0x5f, 0x9b, 0x34, 0xfb
+};
+
+/*
+ * converts uuid to string
+ * buf should be at least 39 bytes
+ *
+ * returns string representation of uuid
+ */
+char *bt_uuid_t2str(const bt_uuid_t *uuid, char *buf)
+{
+ int shift = 0;
+ int i;
+ int is_bt;
+
+ is_bt = !memcmp(&uuid->uu[4], &BT_BASE_UUID[4], sizeof(bt_uuid_t) - 4);
+
+ for (i = 0; i < (int) sizeof(bt_uuid_t); i++) {
+ if (i == 4 && is_bt)
+ break;
+
+ if (i == 4 || i == 6 || i == 8 || i == 10) {
+ buf[i * 2 + shift] = '-';
+ shift++;
+ }
+ sprintf(buf + i * 2 + shift, "%02x", uuid->uu[i]);
+ }
+
+ return buf;
+}
+
+/* converts string to uuid */
+void str2bt_uuid_t(const char *str, bt_uuid_t *uuid)
+{
+ int i = 0;
+
+ memcpy(uuid, BT_BASE_UUID, sizeof(bt_uuid_t));
+
+ while (*str && i < (int) sizeof(bt_uuid_t)) {
+ while (*str == '-')
+ str++;
+
+ if (sscanf(str, "%02hhx", &uuid->uu[i]) != 1)
+ break;
+
+ i++;
+ str += 2;
+ }
+}
diff --git a/android/client/textconv.h b/android/client/textconv.h
new file mode 100644
index 0000000..8fe976c
--- /dev/null
+++ b/android/client/textconv.h
@@ -0,0 +1,113 @@
+/*
+ * Copyright (C) 2013 Intel Corporation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+/**
+ * Begin mapping section
+ *
+ * There are some mappings between integer values (enums) and strings
+ * to be presented to user. To make it easier to convert between those two
+ * set of macros is given. It is specially useful when we want to have
+ * strings that match constants from header files like:
+ * BT_STATUS_SUCCESS (0) and corresponding "BT_STATUS_SUCCESS"
+ * Example of usage:
+ *
+ * INTMAP(int, -1, "invalid")
+ * DELEMENT(BT_STATUS_SUCCESS)
+ * DELEMENT(BT_STATUS_FAIL)
+ * MELEMENT(123, "Some strange value")
+ * ENDMAP
+ *
+ * Just by doing this we have mapping table plus two functions:
+ * int str2int(const char *str);
+ * const char *int2str(int v);
+ *
+ * second argument to INTMAP specifies value to be returned from
+ * str2int function when there is not mapping for such number
+ * third argument specifies default value to be returned from int2str
+ *
+ * If same mapping is to be used in several source files put
+ * INTMAP in c file and DECINTMAP in h file.
+ *
+ * For mappings that are to be used in single file only
+ * use SINTMAP which will create the same but everything will be marked
+ * as static.
+ */
+
+struct int2str {
+ int val; /* int value */
+ const char *str; /* corresponding string */
+};
+
+int int2str_findint(int v, const struct int2str m[]);
+int int2str_findstr(const char *str, const struct int2str m[]);
+
+#define DECINTMAP(type) \
+extern struct int2str __##type##2str[]; \
+const char *type##2##str(type v); \
+type str##2##type(const char *str); \
+
+#define INTMAP(type, deft, defs) \
+const char *type##2##str(type v) \
+{ \
+ int i = int2str_findint((int) v, __##type##2str); \
+ return (i < 0) ? defs : __##type##2str[i].str; \
+} \
+type str##2##type(const char *str) \
+{ \
+ int i = int2str_findstr(str, __##type##2str); \
+ return (i < 0) ? (type) deft : (type) (__##type##2str[i].val); \
+} \
+struct int2str __##type##2str[] = {
+
+#define SINTMAP(type, deft, defs) \
+static struct int2str __##type##2str[]; \
+static inline const char *type##2##str(type v) \
+{ \
+ int i = int2str_findint((int) v, __##type##2str); \
+ return (i < 0) ? defs : __##type##2str[i].str; \
+} \
+static inline type str##2##type(const char *str) \
+{ \
+ int i = int2str_findstr(str, __##type##2str); \
+ return (i < 0) ? (type) deft : (type) (__##type##2str[i].val); \
+} \
+static struct int2str __##type##2str[] = {
+
+#define ENDMAP {0, NULL} };
+
+/* use this to generate string from header file constant */
+#define MELEMENT(v, s) {v, s}
+/* use this to have arbitrary mapping from int to string */
+#define DELEMENT(s) {s, #s}
+/* End of mapping section */
+
+char *bt_bdaddr_t2str(const bt_bdaddr_t *bd_addr, char *buf);
+void str2bt_bdaddr_t(const char *str, bt_bdaddr_t *bd_addr);
+
+char *bt_uuid_t2str(const bt_uuid_t *uuid, char *buf);
+void str2bt_uuid_t(const char *str, bt_uuid_t *uuid);
+
+DECINTMAP(bt_status_t);
+DECINTMAP(bt_state_t);
+DECINTMAP(bt_device_type_t);
+DECINTMAP(bt_scan_mode_t);
+DECINTMAP(bt_discovery_state_t);
+DECINTMAP(bt_acl_state_t);
+DECINTMAP(bt_bond_state_t);
+DECINTMAP(bt_ssp_variant_t);
+DECINTMAP(bt_property_type_t);
+DECINTMAP(bt_cb_thread_evt);
--
1.7.9.5
^ permalink raw reply related [flat|nested] 7+ messages in thread* [PATCH v3 5/5] android: Add calls to adapter methods in haltest
2013-10-16 14:00 [PATCH v3 0/5] Stack independent BT HAL test tool Jerzy Kasenberg
` (3 preceding siblings ...)
2013-10-16 14:00 ` [PATCH v3 4/5] android: Add text conversion helpers to haltest Jerzy Kasenberg
@ 2013-10-16 14:00 ` Jerzy Kasenberg
2013-10-16 15:34 ` [PATCH v3 0/5] Stack independent BT HAL test tool Johan Hedberg
5 siblings, 0 replies; 7+ messages in thread
From: Jerzy Kasenberg @ 2013-10-16 14:00 UTC (permalink / raw)
To: linux-bluetooth; +Cc: Jerzy Kasenberg
This is first code that actually calls HAL functions.
Functions defined in bt_interface_t can be executed.
---
android/Android.mk | 1 +
android/client/haltest.c | 79 +++++-
android/client/if-bt.c | 631 ++++++++++++++++++++++++++++++++++++++++++++++
android/client/if-main.h | 99 ++++++++
4 files changed, 809 insertions(+), 1 deletion(-)
create mode 100644 android/client/if-bt.c
create mode 100644 android/client/if-main.h
diff --git a/android/Android.mk b/android/Android.mk
index 6931c9c..88cb960 100644
--- a/android/Android.mk
+++ b/android/Android.mk
@@ -62,6 +62,7 @@ LOCAL_SRC_FILES := \
client/terminal.c \
client/history.c \
client/textconv.c \
+ client/if-bt.c \
LOCAL_SHARED_LIBRARIES := libhardware
diff --git a/android/client/haltest.c b/android/client/haltest.c
index de98079..6dcabbc 100644
--- a/android/client/haltest.c
+++ b/android/client/haltest.c
@@ -16,11 +16,53 @@
*/
#include <stdlib.h>
+#include <stdbool.h>
+#include <string.h>
+#include <stdio.h>
+#include <stdarg.h>
+#include <unistd.h>
#include <poll.h>
#include <unistd.h>
+#include "if-main.h"
#include "terminal.h"
#include "pollhandler.h"
+#include "history.h"
+
+const struct interface *interfaces[] = {
+ &bluetooth_if,
+ NULL
+};
+
+int haltest_error(const char *format, ...)
+{
+ va_list args;
+ int ret;
+ va_start(args, format);
+ ret = terminal_vprint(format, args);
+ va_end(args);
+ return ret;
+}
+
+int haltest_info(const char *format, ...)
+{
+ va_list args;
+ int ret;
+ va_start(args, format);
+ ret = terminal_vprint(format, args);
+ va_end(args);
+ return ret;
+}
+
+int haltest_warn(const char *format, ...)
+{
+ va_list args;
+ int ret;
+ va_start(args, format);
+ ret = terminal_vprint(format, args);
+ va_end(args);
+ return ret;
+}
/*
* This function changes input parameter line_buffer so it has
@@ -48,10 +90,44 @@ static void process_line(char *line_buffer)
{
char *argv[10];
int argc;
+ int i = 0;
+ int j;
argc = command_line_to_argv(line_buffer, argv, 10);
+ if (argc < 1)
+ return;
+
+ while (interfaces[i] != NULL) {
+ if (strcmp(interfaces[i]->name, argv[0])) {
+ i++;
+ continue;
+ }
+ if (argc < 2 || strcmp(argv[1], "?") == 0) {
+ j = 0;
+ while (strcmp(interfaces[i]->methods[j].name, "")) {
+ haltest_info("%s %s\n", argv[0],
+ interfaces[i]->methods[j].name);
+ ++j;
+ }
+ return;
+ }
+ j = 0;
+ while (strcmp(interfaces[i]->methods[j].name, "")) {
+ if (strcmp(interfaces[i]->methods[j].name, argv[1])) {
+ j++;
+ continue;
+ }
+ interfaces[i]->methods[j].func(argc,
+ (const char **)argv);
+ break;
+ }
+ if (strcmp(interfaces[i]->methods[j].name, "") == 0)
+ printf("No function %s found\n", argv[1]);
+ break;
+ }
- /* TODO: process command line */
+ if (interfaces[i] == NULL)
+ printf("No such interface %s\n", argv[0]);
}
/* called when there is something on stdin */
@@ -74,6 +150,7 @@ static void stdin_handler(struct pollfd *pollfd)
int main(int argc, char **argv)
{
terminal_setup();
+ history_restore(".haltest_history");
/* Register command line handler */
poll_register_fd(0, POLLIN, stdin_handler);
diff --git a/android/client/if-bt.c b/android/client/if-bt.c
new file mode 100644
index 0000000..a0a4bd9
--- /dev/null
+++ b/android/client/if-bt.c
@@ -0,0 +1,631 @@
+/*
+ * Copyright (C) 2013 Intel Corporation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#include "if-main.h"
+
+const bt_interface_t *if_bluetooth;
+
+static char *bdaddr2str(const bt_bdaddr_t *bd_addr)
+{
+ static char buf[18];
+
+ return bt_bdaddr_t2str(bd_addr, buf);
+}
+
+static char *btuuid2str(const bt_uuid_t *uuid)
+{
+ static char buf[39];
+
+ return bt_uuid_t2str(uuid, buf);
+}
+
+static bt_scan_mode_t str2btscanmode(const char *str)
+{
+ bt_scan_mode_t v = str2bt_scan_mode_t(str);
+
+ if ((int) v != -1)
+ return v;
+
+ haltest_warn("WARN: %s cannot convert %s\n", __func__, str);
+ return (bt_scan_mode_t) atoi(str);
+}
+
+static bt_ssp_variant_t str2btsspvariant(const char *str)
+{
+ bt_ssp_variant_t v = str2bt_ssp_variant_t(str);
+
+ if ((int) v != -1)
+ return v;
+
+ haltest_warn("WARN: %s cannot convert %s\n", __func__, str);
+ return (bt_ssp_variant_t) atoi(str);
+}
+
+static bt_property_type_t str2btpropertytype(const char *str)
+{
+ bt_property_type_t v = str2bt_property_type_t(str);
+
+ if ((int) v != -1)
+ return v;
+
+ haltest_warn("WARN: %s cannot convert %s\n", __func__, str);
+ return (bt_property_type_t) atoi(str);
+}
+
+static char *btproperty2str(bt_property_t property)
+{
+ static char buf[4096];
+ char *p;
+
+ p = buf + sprintf(buf, "type=%s len=%d val=",
+ bt_property_type_t2str(property.type), property.len);
+
+ switch (property.type) {
+ case BT_PROPERTY_BDNAME:
+ case BT_PROPERTY_REMOTE_FRIENDLY_NAME:
+ sprintf(p, "%*s", property.len,
+ ((bt_bdname_t *) property.val)->name);
+ break;
+
+ case BT_PROPERTY_BDADDR:
+ sprintf(p, "%s", bdaddr2str((bt_bdaddr_t *) property.val));
+ break;
+
+ case BT_PROPERTY_CLASS_OF_DEVICE:
+ sprintf(p, "%06x", *((int *) property.val));
+ break;
+
+ case BT_PROPERTY_TYPE_OF_DEVICE:
+ sprintf(p, "%s", bt_device_type_t2str(
+ *((bt_device_type_t *) property.val)));
+ break;
+
+ case BT_PROPERTY_REMOTE_RSSI:
+ sprintf(p, "%d", *((char *) property.val));
+ break;
+
+ case BT_PROPERTY_ADAPTER_SCAN_MODE:
+ sprintf(p, "%s",
+ bt_scan_mode_t2str(*((bt_scan_mode_t *) property.val)));
+ break;
+
+ case BT_PROPERTY_ADAPTER_DISCOVERY_TIMEOUT:
+ sprintf(p, "%d", *((int *) property.val));
+ break;
+
+ case BT_PROPERTY_ADAPTER_BONDED_DEVICES:
+ {
+ int count = property.len / sizeof(bt_bdaddr_t);
+ char *ptr = property.val;
+
+ strcat(p, "{");
+
+ while (count--) {
+ strcat(p, bdaddr2str((bt_bdaddr_t *) ptr));
+ if (count)
+ strcat(p, ", ");
+ ptr += sizeof(bt_bdaddr_t);
+ }
+
+ strcat(p, "}");
+
+ }
+ break;
+
+ case BT_PROPERTY_UUIDS:
+ {
+ int count = property.len / sizeof(bt_uuid_t);
+ char *ptr = property.val;
+
+ strcat(p, "{");
+
+ while (count--) {
+ strcat(p, btuuid2str((bt_uuid_t *) ptr));
+ if (count)
+ strcat(p, ", ");
+ ptr += sizeof(bt_uuid_t);
+ }
+
+ strcat(p, "}");
+
+ }
+ break;
+
+ case BT_PROPERTY_SERVICE_RECORD:
+ {
+ bt_service_record_t *rec = property.val;
+
+ sprintf(p, "{%s, %d, %s}", btuuid2str(&rec->uuid),
+ rec->channel, rec->name);
+ }
+ break;
+
+ default:
+ sprintf(p, "%p", property.val);
+ }
+
+ return buf;
+}
+
+static void dump_properties(int num_properties, bt_property_t *properties)
+{
+ int i;
+
+ for (i = 0; i < num_properties; i++) {
+ /*
+ * properities sometimes come unaligned hence memcp to
+ * aligned buffer
+ */
+ bt_property_t prop;
+ memcpy(&prop, properties + i, sizeof(prop));
+
+ haltest_info("prop: %s\n", btproperty2str(prop));
+ }
+}
+
+static void adapter_state_changed_cb(bt_state_t state)
+{
+ haltest_info("%s: state=%s\n", __func__, bt_state_t2str(state));
+}
+
+static void adapter_properties_cb(bt_status_t status,
+ int num_properties, bt_property_t *properties)
+{
+ haltest_info("%s: status=%s num_properties=%d\n",
+ __func__, bt_status_t2str(status), num_properties);
+
+ dump_properties(num_properties, properties);
+}
+
+static void remote_device_properties_cb(bt_status_t status,
+ bt_bdaddr_t *bd_addr, int num_properties, bt_property_t *properties)
+{
+ haltest_info("%s: status=%s bd_addr=%s num_properties=%d\n",
+ __func__, bt_status_t2str(status), bdaddr2str(bd_addr),
+ num_properties);
+
+ dump_properties(num_properties, properties);
+}
+
+static void device_found_cb(int num_properties, bt_property_t *properties)
+{
+ haltest_info("%s: num_properties=%d\n", __func__, num_properties);
+
+ dump_properties(num_properties, properties);
+}
+
+static void discovery_state_changed_cb(bt_discovery_state_t state)
+{
+ haltest_info("%s: state=%s\n", __func__,
+ bt_discovery_state_t2str(state));
+}
+
+static void pin_request_cb(bt_bdaddr_t *remote_bd_addr, bt_bdname_t *bd_name,
+ uint32_t cod)
+{
+ haltest_info("%s: remote_bd_addr=%s bd_name=%s cod=%06x\n", __func__,
+ bdaddr2str(remote_bd_addr), bd_name->name, cod);
+}
+
+static void ssp_request_cb(bt_bdaddr_t *remote_bd_addr, bt_bdname_t *bd_name,
+ uint32_t cod, bt_ssp_variant_t pairing_variant,
+ uint32_t pass_key)
+{
+ haltest_info("%s: remote_bd_addr=%s bd_name=%s cod=%06x pairing_variant=%s pass_key=%d\n",
+ __func__, bdaddr2str(remote_bd_addr), bd_name->name, cod,
+ bt_ssp_variant_t2str(pairing_variant), pass_key);
+}
+
+static void bond_state_changed_cb(bt_status_t status,
+ bt_bdaddr_t *remote_bd_addr,
+ bt_bond_state_t state)
+{
+ haltest_info("%s: status=%s remote_bd_addr=%s state=%s\n", __func__,
+ bt_status_t2str(status), bdaddr2str(remote_bd_addr),
+ bt_bond_state_t2str(state));
+}
+
+static void acl_state_changed_cb(bt_status_t status,
+ bt_bdaddr_t *remote_bd_addr,
+ bt_acl_state_t state)
+{
+ haltest_info("%s: status=%s remote_bd_addr=%s state=%s\n", __func__,
+ bt_status_t2str(status), bdaddr2str(remote_bd_addr),
+ bt_acl_state_t2str(state));
+}
+
+static void thread_evt_cb(bt_cb_thread_evt evt)
+{
+ haltest_info("%s: evt=%s\n", __func__, bt_cb_thread_evt2str(evt));
+}
+
+static void dut_mode_recv_cb(uint16_t opcode, uint8_t *buf, uint8_t len)
+{
+ haltest_info("%s\n", __func__);
+}
+
+static void le_test_mode_cb(bt_status_t status, uint16_t num_packets)
+{
+ haltest_info("%s %s %d\n", __func__, bt_state_t2str(status),
+ num_packets);
+}
+
+static bt_callbacks_t bt_callbacks = {
+ .size = sizeof(bt_callbacks),
+ .adapter_state_changed_cb = adapter_state_changed_cb,
+ .adapter_properties_cb = adapter_properties_cb,
+ .remote_device_properties_cb = remote_device_properties_cb,
+ .device_found_cb = device_found_cb,
+ .discovery_state_changed_cb = discovery_state_changed_cb,
+ .pin_request_cb = pin_request_cb,
+ .ssp_request_cb = ssp_request_cb,
+ .bond_state_changed_cb = bond_state_changed_cb,
+ .acl_state_changed_cb = acl_state_changed_cb,
+ .thread_evt_cb = thread_evt_cb,
+ .dut_mode_recv_cb = dut_mode_recv_cb,
+ .le_test_mode_cb = le_test_mode_cb
+};
+
+static void init_p(int argc, const char **argv)
+{
+ int err;
+ const hw_module_t *module;
+ hw_device_t *device;
+
+ err = hw_get_module(BT_HARDWARE_MODULE_ID, &module);
+ if (err) {
+ haltest_error("he_get_module returned %d\n", err);
+ return;
+ }
+
+ err = module->methods->open(module, BT_HARDWARE_MODULE_ID, &device);
+ if (err) {
+ haltest_error("module->methods->open returned %d\n", err);
+ return;
+ }
+
+ if_bluetooth =
+ ((bluetooth_device_t *) device)->get_bluetooth_interface();
+ if (!if_bluetooth) {
+ haltest_error("get_bluetooth_interface returned NULL\n");
+ return;
+ }
+
+ EXEC(if_bluetooth->init, &bt_callbacks);
+}
+
+static void cleanup_p(int argc, const char **argv)
+{
+ RETURN_IF_NULL(if_bluetooth);
+
+ EXECV(if_bluetooth->cleanup);
+
+ if_bluetooth = NULL;
+}
+
+static void enable_p(int argc, const char **argv)
+{
+ RETURN_IF_NULL(if_bluetooth);
+
+ EXEC(if_bluetooth->enable);
+}
+
+static void disable_p(int argc, const char **argv)
+{
+ RETURN_IF_NULL(if_bluetooth);
+
+ EXEC(if_bluetooth->disable);
+}
+
+static void get_adapter_properties_p(int argc, const char **argv)
+{
+ RETURN_IF_NULL(if_bluetooth);
+
+ EXEC(if_bluetooth->get_adapter_properties);
+}
+
+static void get_adapter_property_p(int argc, const char **argv)
+{
+ int type = str2btpropertytype(argv[2]);
+
+ RETURN_IF_NULL(if_bluetooth);
+
+ EXEC(if_bluetooth->get_adapter_property, type);
+}
+
+static void set_adapter_property_p(int argc, const char **argv)
+{
+ bt_property_t property;
+ bt_scan_mode_t mode;
+ int timeout;
+
+ RETURN_IF_NULL(if_bluetooth);
+
+ property.type = str2btpropertytype(argv[2]);
+
+ switch (property.type) {
+ case BT_PROPERTY_BDNAME:
+ property.len = strlen(argv[3]) + 1;
+ property.val = (char *) argv[3];
+ break;
+
+ case BT_PROPERTY_ADAPTER_SCAN_MODE:
+ mode = str2btscanmode(argv[3]);
+ property.len = sizeof(bt_scan_mode_t);
+ property.val = &mode;
+ break;
+
+ case BT_PROPERTY_ADAPTER_DISCOVERY_TIMEOUT:
+ timeout = atoi(argv[3]);
+ property.val = &timeout;
+ property.len = sizeof(timeout);
+ break;
+
+ default:
+ haltest_error("Invalid property %s\n", argv[3]);
+ return;
+ }
+
+ EXEC(if_bluetooth->set_adapter_property, &property);
+}
+
+static void get_remote_device_properties_p(int argc, const char **argv)
+{
+ bt_bdaddr_t addr;
+
+ RETURN_IF_NULL(if_bluetooth);
+
+ str2bt_bdaddr_t(argv[2], &addr);
+
+ EXEC(if_bluetooth->get_remote_device_properties, &addr);
+}
+
+static void get_remote_device_property_p(int argc, const char **argv)
+{
+ bt_property_type_t type;
+ bt_bdaddr_t addr;
+
+ RETURN_IF_NULL(if_bluetooth);
+
+ str2bt_bdaddr_t(argv[2], &addr);
+ type = str2btpropertytype(argv[3]);
+
+ EXEC(if_bluetooth->get_remote_device_property, &addr, type);
+}
+
+static void set_remote_device_property_p(int argc, const char **argv)
+{
+ bt_property_t property;
+ bt_bdaddr_t addr;
+
+ RETURN_IF_NULL(if_bluetooth);
+
+ str2bt_bdaddr_t(argv[2], &addr);
+ property.type = str2btpropertytype(argv[3]);
+
+ switch (property.type) {
+ case BT_PROPERTY_REMOTE_FRIENDLY_NAME:
+ property.len = strlen(argv[4]);
+ property.val = (char *) argv[4];
+ break;
+
+ default:
+ return;
+ }
+
+ EXEC(if_bluetooth->set_remote_device_property, &addr, &property);
+}
+
+static void get_remote_service_record_p(int argc, const char **argv)
+{
+ bt_bdaddr_t addr;
+ bt_uuid_t uuid;
+
+ RETURN_IF_NULL(if_bluetooth);
+
+ str2bt_bdaddr_t(argv[2], &addr);
+ str2bt_uuid_t(argv[3], &uuid);
+
+ EXEC(if_bluetooth->get_remote_service_record, &addr, &uuid);
+}
+
+static void get_remote_services_p(int argc, const char **argv)
+{
+ bt_bdaddr_t addr;
+
+ RETURN_IF_NULL(if_bluetooth);
+
+ str2bt_bdaddr_t(argv[2], &addr);
+
+ EXEC(if_bluetooth->get_remote_services, &addr);
+}
+
+static void start_discovery_p(int argc, const char **argv)
+{
+ RETURN_IF_NULL(if_bluetooth);
+
+ EXEC(if_bluetooth->start_discovery);
+}
+
+static void cancel_discovery_p(int argc, const char **argv)
+{
+ RETURN_IF_NULL(if_bluetooth);
+
+ EXEC(if_bluetooth->cancel_discovery);
+}
+
+static void create_bond_p(int argc, const char **argv)
+{
+ bt_bdaddr_t addr;
+
+ RETURN_IF_NULL(if_bluetooth);
+
+ str2bt_bdaddr_t(argv[2], &addr);
+
+ EXEC(if_bluetooth->create_bond, &addr);
+}
+
+static void remove_bond_p(int argc, const char **argv)
+{
+ bt_bdaddr_t addr;
+
+ RETURN_IF_NULL(if_bluetooth);
+
+ str2bt_bdaddr_t(argv[2], &addr);
+
+ EXEC(if_bluetooth->remove_bond, &addr);
+}
+
+static void cancel_bond_p(int argc, const char **argv)
+{
+ bt_bdaddr_t addr;
+
+ RETURN_IF_NULL(if_bluetooth);
+
+ str2bt_bdaddr_t(argv[2], &addr);
+
+ EXEC(if_bluetooth->cancel_bond, &addr);
+}
+
+static void pin_reply_p(int argc, const char **argv)
+{
+ bt_bdaddr_t addr;
+ bt_pin_code_t pin;
+ int pin_len = 0;
+ int accept;
+
+ RETURN_IF_NULL(if_bluetooth);
+
+ if (argc < 3) {
+ haltest_error("No address specified\n");
+ return;
+ }
+ str2bt_bdaddr_t(argv[2], &addr);
+
+ if (argc >= 4) {
+ accept = 1;
+ pin_len = strlen(argv[3]);
+ memcpy(pin.pin, argv[3], pin_len);
+ }
+
+ EXEC(if_bluetooth->pin_reply, &addr, accept, pin_len, &pin);
+}
+
+static void ssp_reply_p(int argc, const char **argv)
+{
+ bt_bdaddr_t addr;
+ bt_ssp_variant_t var;
+ int accept;
+ int passkey;
+
+ RETURN_IF_NULL(if_bluetooth);
+
+ if (argc < 3) {
+ haltest_error("No address specified\n");
+ return;
+ }
+ str2bt_bdaddr_t(argv[2], &addr);
+ if (argc < 4) {
+ haltest_error("No ssp variant specified\n");
+ return;
+ }
+ var = str2btsspvariant(argv[3]);
+ if (argc < 5) {
+ haltest_error("No accept value specified\n");
+ return;
+ }
+ accept = atoi(argv[4]);
+ passkey = 0;
+
+ if (accept && var == BT_SSP_VARIANT_PASSKEY_ENTRY && argc >= 5)
+ passkey = atoi(argv[4]);
+
+ EXEC(if_bluetooth->ssp_reply, &addr, var, accept, passkey);
+}
+
+static void get_profile_interface_p(int argc, const char **argv)
+{
+ const char *id = argv[2];
+ const void **pif = NULL;
+ const void *dummy = NULL;
+
+ RETURN_IF_NULL(if_bluetooth);
+
+ if (strcmp(BT_PROFILE_HANDSFREE_ID, id) == 0)
+ pif = &dummy; /* TODO: chenge when if_hf is there */
+ else if (strcmp(BT_PROFILE_ADVANCED_AUDIO_ID, id) == 0)
+ pif = &dummy; /* TODO: chenge when if_av is there */
+ else if (strcmp(BT_PROFILE_HEALTH_ID, id) == 0)
+ pif = &dummy; /* TODO: chenge when if_hl is there */
+ else if (strcmp(BT_PROFILE_SOCKETS_ID, id) == 0)
+ pif = &dummy; /* TODO: chenge when if_sock is there */
+ else if (strcmp(BT_PROFILE_HIDHOST_ID, id) == 0)
+ pif = &dummy; /* TODO: chenge when if_hh is there */
+ else if (strcmp(BT_PROFILE_PAN_ID, id) == 0)
+ pif = &dummy; /* TODO: chenge when if_pan is there */
+ else if (strcmp(BT_PROFILE_AV_RC_ID, id) == 0)
+ pif = &dummy; /* TODO: chenge when if_rc is there */
+ else
+ haltest_error("%s is not correct for get_profile_interface\n",
+ id);
+
+ if (pif != NULL) {
+ *pif = if_bluetooth->get_profile_interface(id);
+ haltest_info("get_profile_interface(%s) : %p\n", id, *pif);
+ }
+}
+
+static void dut_mode_configure_p(int argc, const char **argv)
+{
+ uint8_t mode;
+
+ RETURN_IF_NULL(if_bluetooth);
+
+ mode = strtol(argv[2], NULL, 0);
+
+ EXEC(if_bluetooth->dut_mode_configure, mode);
+}
+
+static struct method methods[] = {
+ STD_METHOD(init),
+ STD_METHOD(cleanup),
+ STD_METHOD(enable),
+ STD_METHOD(disable),
+ STD_METHOD(get_adapter_properties),
+ STD_METHOD(get_adapter_property),
+ STD_METHOD(set_adapter_property),
+ STD_METHOD(get_remote_device_properties),
+ STD_METHOD(get_remote_device_property),
+ STD_METHOD(set_remote_device_property),
+ STD_METHOD(get_remote_service_record),
+ STD_METHOD(get_remote_services),
+ STD_METHOD(start_discovery),
+ STD_METHOD(cancel_discovery),
+ STD_METHOD(create_bond),
+ STD_METHOD(remove_bond),
+ STD_METHOD(cancel_bond),
+ STD_METHOD(pin_reply),
+ STD_METHOD(ssp_reply),
+ STD_METHOD(get_profile_interface),
+ STD_METHOD(dut_mode_configure),
+ END_METHOD
+};
+
+const struct interface bluetooth_if = {
+ .name = "adapter",
+ .methods = methods
+};
diff --git a/android/client/if-main.h b/android/client/if-main.h
new file mode 100644
index 0000000..9cac7ef
--- /dev/null
+++ b/android/client/if-main.h
@@ -0,0 +1,99 @@
+/*
+ * Copyright (C) 2013 Intel Corporation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdbool.h>
+#include <signal.h>
+#include <fcntl.h>
+#include <errno.h>
+#include <sys/socket.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <sys/time.h>
+#include <sys/un.h>
+#include <poll.h>
+
+#include <hardware/bluetooth.h>
+#include <hardware/bt_av.h>
+#include <hardware/bt_hh.h>
+#include <hardware/bt_pan.h>
+#include <hardware/bt_sock.h>
+#include <hardware/bt_hf.h>
+#include <hardware/bt_hl.h>
+#include <hardware/bt_rc.h>
+
+#include "textconv.h"
+
+/* Interfaces from hal that can be populated during application lifetime */
+extern const bt_interface_t *if_bluetooth;
+
+/*
+ * Structure defines top level interfaces that can be used in test tool
+ * this will contain values as: adapter, av, gatt, sock, pan...
+ */
+struct interface {
+ const char *name; /* interface name */
+ struct method *methods; /* methods available for this interface */
+};
+
+extern const struct interface bluetooth_if;
+
+/* Interfaces that will show up in tool (first part of command line) */
+extern const struct interface *interfaces[];
+
+#define METHOD(name, func) {name, func}
+#define STD_METHOD(m) {#m, m##_p}
+#define END_METHOD {"", NULL}
+
+/*
+ * Function to parse argument for function, argv[0] and argv[1] are already
+ * parsed before this function is called and contain interface and method name
+ * up to argc - 1 arguments are finished and should be used to decide which
+ * function enumeration function to return
+ */
+typedef void (*parse_and_call)(int argc, const char **argv);
+
+/*
+ * For each method there is name and two functions to parse command line
+ * and call proper hal function on.
+ */
+struct method {
+ const char *name;
+ parse_and_call func;
+};
+
+int haltest_error(const char *format, ...);
+int haltest_info(const char *format, ...);
+int haltest_warn(const char *format, ...);
+
+/* Helper macro for executing function on interface and printing BT_STATUS */
+#define EXEC(f, ...) \
+ { \
+ int err = f(__VA_ARGS__); \
+ haltest_info("%s: %s\n", #f, bt_status_t2str(err)); \
+ }
+
+/* Helper macro for executing void function on interface */
+#define EXECV(f, ...) \
+ { \
+ (void) f(__VA_ARGS__); \
+ haltest_info("%s: void\n", #f); \
+ }
+
+#define RETURN_IF_NULL(x) \
+ do { if (!x) { haltest_error("%s is NULL\n", #x); return; } } while (0)
--
1.7.9.5
^ permalink raw reply related [flat|nested] 7+ messages in thread* Re: [PATCH v3 0/5] Stack independent BT HAL test tool
2013-10-16 14:00 [PATCH v3 0/5] Stack independent BT HAL test tool Jerzy Kasenberg
` (4 preceding siblings ...)
2013-10-16 14:00 ` [PATCH v3 5/5] android: Add calls to adapter methods in haltest Jerzy Kasenberg
@ 2013-10-16 15:34 ` Johan Hedberg
5 siblings, 0 replies; 7+ messages in thread
From: Johan Hedberg @ 2013-10-16 15:34 UTC (permalink / raw)
To: Jerzy Kasenberg; +Cc: linux-bluetooth
Hi Jerzy,
On Wed, Oct 16, 2013, Jerzy Kasenberg wrote:
> v3:
> - underscores changed to dash in file names.
> - corrected cast style (space after cast).
> - structure initialization with explicit filed names.
> v2:
> - license changed to apache
> - source folder changed to hal-client (underscore to dash)
> v1:
> This tool is for testing Android HAL interfaces from command line.
> Due to lack of readline on Android simple equivalent is hand coded.
> This tool can be used with bluedroid stack so no glib dependency.
>
> Tool source code is in folder hal_client, please comment if it should be
> somewhere else.
>
> Comments welcome.
>
> Best regards
> Jerzy Kasenberg
>
> Jerzy Kasenberg (5):
> android: Add haltest skeleton
> android: Add line editing to haltest
> android: Add history to line editor in haltest
> android: Add text conversion helpers to haltest
> android: Add calls to adapter methods in haltest
>
> android/Android.mk | 21 ++
> android/client/haltest.c | 161 +++++++++++
> android/client/history.c | 98 +++++++
> android/client/history.h | 21 ++
> android/client/if-bt.c | 631 ++++++++++++++++++++++++++++++++++++++++++
> android/client/if-main.h | 99 +++++++
> android/client/pollhandler.c | 123 ++++++++
> android/client/pollhandler.h | 26 ++
> android/client/terminal.c | 538 +++++++++++++++++++++++++++++++++++
> android/client/terminal.h | 59 ++++
> android/client/textconv.c | 205 ++++++++++++++
> android/client/textconv.h | 113 ++++++++
> 12 files changed, 2095 insertions(+)
> create mode 100644 android/client/haltest.c
> create mode 100644 android/client/history.c
> create mode 100644 android/client/history.h
> create mode 100644 android/client/if-bt.c
> create mode 100644 android/client/if-main.h
> create mode 100644 android/client/pollhandler.c
> create mode 100644 android/client/pollhandler.h
> create mode 100644 android/client/terminal.c
> create mode 100644 android/client/terminal.h
> create mode 100644 android/client/textconv.c
> create mode 100644 android/client/textconv.h
All five patches have been pushed upstream. I did have to fix "empty
line before EOL" errors for each of the first three patches though, so
please avoid that in the future.
Johan
^ permalink raw reply [flat|nested] 7+ messages in thread