gtk-gui/mw-client.c

   1 #include <stdio.h>
   2 #include <sys/types.h>
   3 #include <sys/stat.h>
   4 #include <fcntl.h>
   5 #include <unistd.h>
   6 #include <stdlib.h>
   7 #include <string.h>
   8 #include <time.h>
   9 #include <termios.h>
  10 #include <ctype.h>
  11
  12 #include <errno.h>
  13
  14 #include <bluetooth/bluetooth.h>
  15 #include <bluetooth/rfcomm.h>
  16
  17 #include <glib.h>
  18 #include <dbus/dbus.h>
  19 #include <dbus/dbus-glib.h>
  20 #include <dbus/dbus-glib-lowlevel.h>
  21
  22 #include <gtk/gtk.h>
  23
  24 #include <metawatch.h>
  25 #include <crc16ccitt.h>
  26 #include <mw_utility.h>
  27
  28 typedef struct {
  29         // GMainLoop *mloop;
  30         GtkBuilder *builder;
  31         mwdevice_t mwdevice;
  32         unsigned char rcvbuf[128];
  33         int rcvbuf_pos;
  34         int con_fd;             /* console input fd */
  35         char cmdline[128];
  36         int cmdline_pos;
  37         int bat_timeout_id;
  38 } mwdata_t;
  39
  40
  41 gboolean battery_level_get_timeout(gpointer user_data)
  42 {
  43         mwdata_t *mdata = (mwdata_t *)user_data;
  44
  45         mw_send_frame(&mdata->mwdevice, MW_READ_BATTERY_VOLTAGE_MSG, 0, NULL, 0);
  46         return TRUE;
  47 }
  48
  49 void mw_get_battery_voltage_response_cb(mwdevice_t *mwdevice, unsigned short *voltage, unsigned char *pgood, unsigned char *charging, void *user_data)
  50 {
  51         mwdata_t *mdata = (mwdata_t *)user_data;
  52         gdouble volt = *voltage;
  53         GtkAdjustment *batadjust;
  54         GtkProgressBar *batbar;
  55         gchar batstr[32];
  56
  57         batadjust = GTK_ADJUSTMENT(gtk_builder_get_object (mdata->builder, "bat_adjust"));
  58         gtk_adjustment_set_value(batadjust, volt);
  59         batbar = GTK_PROGRESS_BAR(gtk_builder_get_object (mdata->builder, "battery_status_bar"));
  60         snprintf(batstr, 32, "%4.0fmV", volt);
  61         gtk_progress_bar_set_text(batbar, batstr);
  62 }
  63
  64 void on_rtc_button_clicked (GtkButton *button, gpointer user_data)
  65 {
  66         mwdata_t *mdata = (mwdata_t *)user_data;
  67
  68         mw_send_frame(&mdata->mwdevice, MW_GET_REAL_TIME_CLOCK, 0, NULL, 0);
  69 }
  70
  71 void on_notify_button_clicked (GtkButton *button, gpointer user_data)
  72 {
  73         mwdata_t *mdata = (mwdata_t *)user_data;
  74
  75 }
  76
  77 void bitmap_read(mwdevice_t *mwdevice, char *filename)
  78 {
  79         int ffd, ret;
  80         char rbuf[256];
  81         unsigned int width, height, i;
  82 #ifdef DEBUG
  83         unsigned int x, y;
  84 #endif
  85         unsigned int rowlength;
  86         unsigned char *bmapbuf;
  87         // unsigned char mw_buf[24];
  88
  89         ffd = open(filename, O_RDONLY);
  90         if (ffd < 0) {
  91                 perror("open");
  92                 return;
  93         };
  94         ret = read(ffd, rbuf, 3);
  95         if (rbuf[0] != 'P' || rbuf[1] != '4') {
  96                 fprintf(stderr, "not a PBM file\n");
  97                 return;
  98         }
  99         memset(rbuf, 0, 256);
 100         i = 0;
 101         do {
 102                 ret = read(ffd, (rbuf+i), 1);
 103         } while (!isspace(rbuf[i++]));
 104         width = atoi(rbuf);
 105
 106         memset(rbuf, 0, 256);
 107         i = 0;
 108         do {
 109                 ret = read(ffd, (rbuf+i), 1);
 110         } while (!isspace(rbuf[i++]));
 111         height = atoi(rbuf);
 112
 113         rowlength = ((width / 8) + 1);
 114
 115         bmapbuf = malloc(rowlength * height);
 116
 117         ret = read(ffd, bmapbuf, rowlength * height);
 118         close(ffd);
 119
 120 #ifdef DEBUG
 121         fprintf(stderr, "row length = %d bytes\n", rowlength);
 122         fprintf(stderr, "bitmap resolution is %d x %d\n", width, height);
 123         fprintf(stderr, "read %d of %d bytes\n", ret, rowlength * height);
 124         fprintf(stderr, "\n");
 125         for (y=0; y<height; y++) {
 126                 for (x=0; x<rowlength; x++) {
 127                         for (i=0; i<8; i++)
 128                                 fprintf(stderr, "%c", (bmapbuf[(y*rowlength)+x] & (1<<(7-i))) ? '.' : ' ');
 129                 }
 130                 fprintf(stderr, "\n");
 131         }
 132         fprintf(stderr, "\n");
 133 #endif
 134
 135         /* reverse bits and invert the bmap */
 136         bmap_buffer_flipinvert(1, 1, bmapbuf, rowlength * height);
 137         /* send the buffer to the watch */
 138         mw_send_bitmap(mwdevice, MW_SCREEN_MODE_IDLE, width, height, 31, bmapbuf, rowlength * height);
 139         /* update the display */
 140         mw_update_display(mwdevice, MW_SCREEN_MODE_IDLE, 1);
 141
 142         free(bmapbuf);
 143 }
 144
 145 void on_bitmap_button_clicked (GtkButton *button, gpointer user_data)
 146 {
 147         mwdata_t *mdata = (mwdata_t *)user_data;
 148         GtkWindow *mwin;
 149         GtkWidget *dialog;
 150
 151         mwin = GTK_WINDOW (gtk_builder_get_object (mdata->builder, "main_win"));
 152         dialog = gtk_file_chooser_dialog_new("Bitmap File", mwin, GTK_FILE_CHOOSER_ACTION_OPEN,
 153                                                 GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
 154                                                 GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT,
 155                                                 NULL);
 156         if (gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT) {
 157                 gchar *filename;
 158                 filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog));
 159                 /* send bitmap file */
 160                 bitmap_read(&mdata->mwdevice, filename);
 161         }
 162         gtk_widget_destroy(dialog);
 163 }
 164
 165 void mw_get_real_time_clock_response_cb(mwdevice_t *mwdevice, struct tm *mw_tm, void *user_data)
 166 {
 167         mwdata_t *mdata = (mwdata_t *)user_data;
 168         GtkButton *rtc_button;
 169         gchar label_str[256];
 170
 171         //g_print("watch RTC is %s\n", asctime(mw_tm));
 172         rtc_button = GTK_BUTTON (gtk_builder_get_object (mdata->builder, "rtc_button"));
 173         snprintf(label_str, 256, "RTC\n%s", asctime(mw_tm));
 174         label_str[strlen(label_str)-1] = 0;
 175         gtk_button_set_label(rtc_button, label_str);
 176 }
 177
 178 int open_socket(bdaddr_t *bdaddr, uint8_t channel)
 179 {
 180         struct sockaddr_rc addr;
 181         int sk, opt;
 182
 183         sk = socket(PF_BLUETOOTH, SOCK_STREAM, BTPROTO_RFCOMM);
 184         if (sk < 0) {
 185                 fprintf(stderr, "Can't create socket: %s (%d)\n",
 186                         strerror(errno), errno);
 187                 return -1;
 188         }
 189
 190 /*
 191         f = 1;
 192         if (setsockopt(sk, SOL_BLUETOOTH, BT_FLUSHABLE, &f, sizeof(f)) < 0) {
 193                 fprintf(stderr, "Can't set flushable: %s (%d)\n",
 194                         strerror(errno), errno);
 195                 return -1;
 196         }
 197 */
 198         memset(&addr, 0, sizeof(addr));
 199         addr.rc_family = AF_BLUETOOTH;
 200         bacpy(&addr.rc_bdaddr, BDADDR_ANY);
 201
 202         if (bind(sk, (struct sockaddr *) &addr, sizeof(addr)) < 0) {
 203                 fprintf(stderr, "Can't bind socket: %s (%d)\n",
 204                                                         strerror(errno), errno);
 205                 close(sk);
 206                 return -1;
 207         }
 208
 209        /* Set link mode */
 210         opt = 0;
 211         opt |= RFCOMM_LM_MASTER;
 212         opt |= RFCOMM_LM_AUTH;
 213 /*
 214         opt |= RFCOMM_LM_ENCRYPT;
 215         opt |= RFCOMM_LM_SECURE;
 216 */
 217         if (opt && setsockopt(sk, SOL_RFCOMM, RFCOMM_LM, &opt, sizeof(opt)) < 0) {
 218                 fprintf(stderr, "Can't set RFCOMM link mode: %s (%d)",
 219                                                         strerror(errno), errno);
 220                 close(sk);
 221                 return -1;
 222         }
 223
 224         memset(&addr, 0, sizeof(addr));
 225         addr.rc_family = AF_BLUETOOTH;
 226         bacpy(&addr.rc_bdaddr, bdaddr);
 227         addr.rc_channel = channel;
 228
 229         if (connect(sk, (struct sockaddr *) &addr, sizeof(addr)) < 0) {
 230                 fprintf(stderr, "Can't connect: %s (%d)\n",
 231                                                         strerror(errno), errno);
 232                 close(sk);
 233                 return -1;
 234         }
 235
 236         return sk;
 237 }
 238
 239 void baswap(bdaddr_t *dst, const bdaddr_t *src)
 240 {
 241         register unsigned char *d = (unsigned char *) dst;
 242         register const unsigned char *s = (const unsigned char *) src;
 243         register int i;
 244
 245         for (i = 0; i < 6; i++)
 246                 d[i] = s[5-i];
 247 }
 248
 249 int bachk(const char *str)
 250 {
 251         if (!str)
 252                 return -1;
 253
 254         if (strlen(str) != 17)
 255                 return -1;
 256
 257         while (*str) {
 258                 if (!isxdigit(*str++))
 259                         return -1;
 260
 261                 if (!isxdigit(*str++))
 262                         return -1;
 263
 264                 if (*str == 0)
 265                         break;
 266
 267                 if (*str++ != ':')
 268                         return -1;
 269         }
 270
 271         return 0;
 272 }
 273
 274 int str2ba(const char *str, bdaddr_t *ba)
 275 {
 276         bdaddr_t b;
 277         int i;
 278
 279         if (bachk(str) < 0) {
 280                 memset(ba, 0, sizeof(*ba));
 281                 return -1;
 282         }
 283
 284         for (i = 0; i < 6; i++, str += 3)
 285                 b.b[i] = strtol(str, NULL, 16);
 286
 287         baswap(ba, &b);
 288
 289         return 0;
 290 }
 291
 292 gboolean handle_mw_io(GIOChannel *mw_io, GIOCondition condition, gpointer udata)
 293 {
 294         mwdata_t *mdata = (mwdata_t *)udata;
 295         int rcvd;
 296         int processed;
 297
 298         rcvd = read(mdata->mwdevice.mw_fd, mdata->rcvbuf+mdata->rcvbuf_pos, 64);
 299 #ifdef DEBUG
 300         fprintf(stderr, "read %d bytes:\n", rcvd);
 301 #endif
 302         if (rcvd > 0) {
 303 #ifdef DEBUG
 304                 dump_frame(mdata->rcvbuf, rcvd);
 305 #endif
 306                 processed = decode_frame(&mdata->mwdevice, mdata->rcvbuf, rcvd);
 307                 if (processed > 0) {
 308                         mdata->rcvbuf_pos -= processed;
 309                         if (mdata->rcvbuf_pos > 0)
 310                                 g_print("Warning: RCV buffer not yet empty\n");
 311                 } else {
 312                         /* we should rather seek forward for a next potential frame start */
 313                         mdata->rcvbuf_pos = 0;
 314                 }
 315         }
 316
 317         return TRUE;
 318 }
 319
 320 void
 321 on_window_destroy (GtkObject *object, gpointer user_data)
 322 {
 323         gtk_main_quit ();
 324 }
 325
 326
 327
 328 int
 329 main (int argc, char *argv[])
 330 {
 331         GtkBuilder *builder;
 332         GtkWidget *window;
 333         GIOChannel *mw_io;
 334         bdaddr_t btaddr;
 335         int mw_fd;
 336         struct termios tmwfd;
 337         mwdata_t mdata;
 338
 339
 340         if (argc != 2) {
 341                 fprintf(stderr, "Usage:\n\t%s <devicename>\n", argv[0]);
 342                 return 1;
 343         };
 344
 345         crc16ccitt_init();
 346
 347         if (str2ba(argv[1], &btaddr))
 348                 return 1;
 349         mw_fd = open_socket(&btaddr, 1);
 350         if (mw_fd < 0) {
 351                 return 1;
 352         } else {
 353                 fprintf(stderr, "connected to %s\n", argv[1]);
 354         };
 355
 356         /* we have a connection, RFCOMM socket is on mw_fd */
 357         /* make the tty raw */
 358         tcgetattr(mw_fd, &tmwfd);
 359         cfmakeraw(&tmwfd);
 360         tmwfd.c_oflag |= ONLCR | OPOST;
 361         tmwfd.c_lflag |= ISIG;
 362         tcsetattr(mw_fd, TCSANOW, &tmwfd);
 363
 364         mdata.mwdevice.mw_fd = mw_fd;
 365         mdata.rcvbuf_pos = 0;
 366         memset(mdata.rcvbuf, 0, 128);
 367
 368         gtk_init (&argc, &argv);
 369
 370         builder = gtk_builder_new ();
 371         gtk_builder_add_from_file (builder, "mw-client.glade", NULL);
 372         mdata.builder = builder;
 373         window = GTK_WIDGET (gtk_builder_get_object (builder, "main_win"));
 374         gtk_builder_connect_signals (builder, &mdata);
 375
 376         //g_object_unref (G_OBJECT (builder));
 377
 378         gtk_widget_show (window);
 379
 380         mw_io = g_io_channel_unix_new(mw_fd);
 381         g_io_add_watch(mw_io, G_IO_IN | G_IO_PRI | G_IO_ERR | G_IO_HUP, handle_mw_io, &mdata);
 382
 383         mw_init(&mdata.mwdevice, mw_fd);
 384
 385         mw_set_get_real_time_clock_response_cb(&mdata.mwdevice, mw_get_real_time_clock_response_cb, &mdata);
 386         mw_set_get_battery_voltage_response_cb(&mdata.mwdevice, mw_get_battery_voltage_response_cb, &mdata);
 387
 388         // mw_send_frame(&mdata.mwdevice, MW_READ_BATTERY_VOLTAGE_MSG, 0, NULL, 0);
 389
 390         mdata.bat_timeout_id = g_timeout_add_seconds(10, battery_level_get_timeout, &mdata);
 391
 392         gtk_main ();
 393
 394         return 0;
 395 }