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 #include <bt_helper.h>
  28
  29 typedef struct {
  30         // GMainLoop *mloop;
  31         GtkBuilder *builder;
  32         mwdevice_t mwdevice;
  33         unsigned char rcvbuf[128];
  34         int rcvbuf_pos;
  35         int con_fd;             /* console input fd */
  36         char cmdline[128];
  37         int cmdline_pos;
  38         int bat_timeout_id;
  39 } mwdata_t;
  40
  41
  42 gboolean battery_level_get_timeout(gpointer user_data)
  43 {
  44         mwdata_t *mdata = (mwdata_t *)user_data;
  45
  46         mw_send_frame(&mdata->mwdevice, MW_READ_BATTERY_VOLTAGE_MSG, 0, NULL, 0);
  47         return TRUE;
  48 }
  49
  50 void mw_get_battery_voltage_response_cb(mwdevice_t *mwdevice, unsigned short *voltage, unsigned char *pgood, unsigned char *charging, void *user_data)
  51 {
  52         mwdata_t *mdata = (mwdata_t *)user_data;
  53         gdouble volt = *voltage;
  54         GtkAdjustment *batadjust;
  55         GtkProgressBar *batbar;
  56         gchar batstr[32];
  57
  58         batadjust = GTK_ADJUSTMENT(gtk_builder_get_object (mdata->builder, "bat_adjust"));
  59         gtk_adjustment_set_value(batadjust, volt);
  60         batbar = GTK_PROGRESS_BAR(gtk_builder_get_object (mdata->builder, "battery_status_bar"));
  61         snprintf(batstr, 32, "%4.0fmV", volt);
  62         gtk_progress_bar_set_text(batbar, batstr);
  63 }
  64
  65 void on_notify_ok_clicked (GtkButton *button, gpointer user_data)
  66 {
  67         mwdata_t *mdata = (mwdata_t *)user_data;
  68         GtkWidget *notify_win;
  69         GtkTextView *tview;
  70         GtkTextBuffer *tbuf;
  71         GtkTextIter siter, eiter;
  72         gchar *text;
  73
  74         tview = GTK_TEXT_VIEW (gtk_builder_get_object (mdata->builder, "notify_textview"));
  75         tbuf = gtk_text_view_get_buffer(tview);
  76         gtk_text_buffer_get_start_iter(tbuf, &siter);
  77         gtk_text_buffer_get_end_iter(tbuf, &eiter);
  78
  79         text = gtk_text_buffer_get_text(tbuf, &siter, &eiter, FALSE);
  80
  81         mw_do_notification(&mdata->mwdevice, "Notification", text, 2);
  82
  83         notify_win = GTK_WIDGET (gtk_builder_get_object (mdata->builder, "notify_win"));
  84         gtk_widget_hide (notify_win);
  85 }
  86
  87 void on_notify_cancel_clicked (GtkButton *button, gpointer user_data)
  88 {
  89         mwdata_t *mdata = (mwdata_t *)user_data;
  90         GtkWidget *notify_win;
  91
  92         notify_win = GTK_WIDGET (gtk_builder_get_object (mdata->builder, "notify_win"));
  93         gtk_widget_hide (notify_win);
  94 }
  95
  96
  97 void on_rtc_button_clicked (GtkButton *button, gpointer user_data)
  98 {
  99         mwdata_t *mdata = (mwdata_t *)user_data;
 100
 101         mw_send_frame(&mdata->mwdevice, MW_GET_REAL_TIME_CLOCK, 0, NULL, 0);
 102 }
 103
 104 void on_notify_button_clicked (GtkButton *button, gpointer user_data)
 105 {
 106         mwdata_t *mdata = (mwdata_t *)user_data;
 107         GtkWidget *notify_win;
 108
 109         notify_win = GTK_WIDGET (gtk_builder_get_object (mdata->builder, "notify_win"));
 110         gtk_widget_show (notify_win);
 111 }
 112
 113 void bitmap_read(mwdevice_t *mwdevice, char *filename)
 114 {
 115         int ffd, ret;
 116         char rbuf[256];
 117         unsigned int width, height, i;
 118 #ifdef DEBUG
 119         unsigned int x, y;
 120 #endif
 121         unsigned int rowlength;
 122         unsigned char *bmapbuf;
 123         // unsigned char mw_buf[24];
 124
 125         ffd = open(filename, O_RDONLY);
 126         if (ffd < 0) {
 127                 perror("open");
 128                 return;
 129         };
 130         ret = read(ffd, rbuf, 3);
 131         if (rbuf[0] != 'P' || rbuf[1] != '4') {
 132                 fprintf(stderr, "not a PBM file\n");
 133                 return;
 134         }
 135         memset(rbuf, 0, 256);
 136         i = 0;
 137         do {
 138                 ret = read(ffd, (rbuf+i), 1);
 139         } while (!isspace(rbuf[i++]));
 140         width = atoi(rbuf);
 141
 142         memset(rbuf, 0, 256);
 143         i = 0;
 144         do {
 145                 ret = read(ffd, (rbuf+i), 1);
 146         } while (!isspace(rbuf[i++]));
 147         height = atoi(rbuf);
 148
 149         rowlength = ((width / 8) + 1);
 150
 151         bmapbuf = malloc(rowlength * height);
 152
 153         ret = read(ffd, bmapbuf, rowlength * height);
 154         close(ffd);
 155
 156 #ifdef DEBUG
 157         fprintf(stderr, "row length = %d bytes\n", rowlength);
 158         fprintf(stderr, "bitmap resolution is %d x %d\n", width, height);
 159         fprintf(stderr, "read %d of %d bytes\n", ret, rowlength * height);
 160         fprintf(stderr, "\n");
 161         for (y=0; y<height; y++) {
 162                 for (x=0; x<rowlength; x++) {
 163                         for (i=0; i<8; i++)
 164                                 fprintf(stderr, "%c", (bmapbuf[(y*rowlength)+x] & (1<<(7-i))) ? '.' : ' ');
 165                 }
 166                 fprintf(stderr, "\n");
 167         }
 168         fprintf(stderr, "\n");
 169 #endif
 170
 171         /* reverse bits and invert the bmap */
 172         bmap_buffer_flipinvert(1, 1, bmapbuf, rowlength * height);
 173         /* send the buffer to the watch */
 174         mw_send_bitmap(mwdevice, MW_SCREEN_MODE_IDLE, width, height, 31, bmapbuf, rowlength * height);
 175         /* update the display */
 176         mw_update_display(mwdevice, MW_SCREEN_MODE_IDLE, 1);
 177
 178         free(bmapbuf);
 179 }
 180
 181 void on_vibrate_button_clicked (GtkButton *button, gpointer user_data)
 182 {
 183         mwdata_t *mdata = (mwdata_t *)user_data;
 184 }
 185
 186 void on_set_hands_clicked (GtkButton *button, gpointer user_data)
 187 {
 188         mwdata_t *mdata = (mwdata_t *)user_data;
 189         time_t mtime;
 190         struct tm mtm;
 191         unsigned short hour;
 192
 193         mtime = time(NULL);
 194         localtime_r(&mtime, &mtm);
 195
 196         hour = (unsigned char) mtm.tm_hour;
 197         if (hour > 12)
 198                 hour -= 12;
 199
 200         mw_advance_watch_hands(&mdata->mwdevice, hour, (unsigned char) mtm.tm_min, (unsigned char) mtm.tm_sec);
 201 }
 202
 203 void on_bitmap_button_clicked (GtkButton *button, gpointer user_data)
 204 {
 205         mwdata_t *mdata = (mwdata_t *)user_data;
 206         GtkWindow *mwin;
 207         GtkWidget *dialog;
 208
 209         mwin = GTK_WINDOW (gtk_builder_get_object (mdata->builder, "main_win"));
 210         dialog = gtk_file_chooser_dialog_new("Bitmap File", mwin, GTK_FILE_CHOOSER_ACTION_OPEN,
 211                                                 GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
 212                                                 GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT,
 213                                                 NULL);
 214         if (gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT) {
 215                 gchar *filename;
 216                 filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog));
 217                 /* send bitmap file */
 218                 bitmap_read(&mdata->mwdevice, filename);
 219         }
 220         gtk_widget_destroy(dialog);
 221 }
 222
 223 void setup_watchtype_gui(mwdata_t *mdata)
 224 {
 225         GtkWidget *w;
 226
 227         if (mdata->mwdevice.devtype == MW_DEVICE_TYPE_DIGITAL || mdata->mwdevice.devtype == MW_DEVICE_TYPE_DEVB_DIGI) {
 228                 w = GTK_WIDGET (gtk_builder_get_object (mdata->builder, "set_hands"));
 229                 gtk_widget_hide(w);
 230         }
 231         if (mdata->mwdevice.devtype == MW_DEVICE_TYPE_ANA_DIGI || mdata->mwdevice.devtype == MW_DEVICE_TYPE_DEVB_ANA_DIGI) {
 232                 w = GTK_WIDGET (gtk_builder_get_object (mdata->builder, "F_button_label"));
 233                 gtk_widget_hide(w);
 234                 w = GTK_WIDGET (gtk_builder_get_object (mdata->builder, "E_button_label"));
 235                 gtk_widget_hide(w);
 236                 w = GTK_WIDGET (gtk_builder_get_object (mdata->builder, "D_button_label"));
 237                 gtk_widget_hide(w);
 238         }
 239 }
 240
 241 void mw_get_device_type_response_cb(mwdevice_t *mwdevice, unsigned char devtype, void *user_data)
 242 {
 243         mwdata_t *mdata = (mwdata_t *)user_data;
 244
 245         setup_watchtype_gui(mdata);
 246 }
 247
 248 void mw_get_real_time_clock_response_cb(mwdevice_t *mwdevice, struct tm *mw_tm, void *user_data)
 249 {
 250         mwdata_t *mdata = (mwdata_t *)user_data;
 251         GtkButton *rtc_button;
 252         gchar label_str[256];
 253
 254         //g_print("watch RTC is %s\n", asctime(mw_tm));
 255         rtc_button = GTK_BUTTON (gtk_builder_get_object (mdata->builder, "rtc_button"));
 256         snprintf(label_str, 256, "RTC\n%s", asctime(mw_tm));
 257         label_str[strlen(label_str)-1] = 0;
 258         gtk_button_set_label(rtc_button, label_str);
 259 }
 260
 261 gboolean handle_mw_io(GIOChannel *mw_io, GIOCondition condition, gpointer udata)
 262 {
 263         mwdata_t *mdata = (mwdata_t *)udata;
 264         int rcvd;
 265         int processed;
 266
 267         rcvd = read(mdata->mwdevice.mw_fd, mdata->rcvbuf/*+mdata->rcvbuf_pos*/, 64);
 268 #ifdef DEBUG
 269         fprintf(stderr, "read %d bytes:\n", rcvd);
 270 #endif
 271         if (rcvd > 0) {
 272 #ifdef DEBUG
 273                 dump_frame(mdata->rcvbuf, rcvd);
 274 #endif
 275                 processed = decode_frame(&mdata->mwdevice, mdata->rcvbuf, rcvd);
 276                 if (processed > 0) {
 277                         mdata->rcvbuf_pos -= processed;
 278                         if (mdata->rcvbuf_pos > 0)
 279                                 g_print("Warning: RCV buffer not yet empty\n");
 280                 } else {
 281                         /* we should rather seek forward for a next potential frame start */
 282                         mdata->rcvbuf_pos = 0;
 283                 }
 284         }
 285
 286         return TRUE;
 287 }
 288
 289 void
 290 on_window_destroy (GtkObject *object, gpointer user_data)
 291 {
 292         gtk_main_quit ();
 293 }
 294
 295
 296 int main (int argc, char *argv[])
 297 {
 298         GtkBuilder *builder;
 299         GtkWidget *window;
 300         GIOChannel *mw_io;
 301         bdaddr_t btaddr;
 302         int mw_fd;
 303         struct termios tmwfd;
 304         mwdata_t mdata;
 305
 306
 307         if (argc != 2) {
 308                 fprintf(stderr, "Usage:\n\t%s <devicename>\n", argv[0]);
 309                 return 1;
 310         };
 311
 312         crc16ccitt_init();
 313
 314         if (str2ba(argv[1], &btaddr))
 315                 return 1;
 316         mw_fd = open_socket(&btaddr, 1);
 317         if (mw_fd < 0) {
 318                 return 1;
 319         } else {
 320                 fprintf(stderr, "connected to %s\n", argv[1]);
 321         };
 322
 323         /* we have a connection, RFCOMM socket is on mw_fd */
 324         /* make the tty raw */
 325         tcgetattr(mw_fd, &tmwfd);
 326         cfmakeraw(&tmwfd);
 327         tmwfd.c_oflag |= ONLCR | OPOST;
 328         tmwfd.c_lflag |= ISIG;
 329         tcsetattr(mw_fd, TCSANOW, &tmwfd);
 330
 331         mdata.mwdevice.mw_fd = mw_fd;
 332         mdata.rcvbuf_pos = 0;
 333         memset(mdata.rcvbuf, 0, 128);
 334
 335         gtk_init (&argc, &argv);
 336
 337         builder = gtk_builder_new ();
 338         gtk_builder_add_from_file (builder, "mw-client.glade", NULL);
 339         mdata.builder = builder;
 340         window = GTK_WIDGET (gtk_builder_get_object (builder, "main_win"));
 341         gtk_builder_connect_signals (builder, &mdata);
 342
 343         //g_object_unref (G_OBJECT (builder));
 344
 345         gtk_widget_show (window);
 346
 347         mw_io = g_io_channel_unix_new(mw_fd);
 348         g_io_add_watch(mw_io, G_IO_IN | G_IO_PRI | G_IO_ERR | G_IO_HUP, handle_mw_io, &mdata);
 349
 350         mw_init(&mdata.mwdevice, mw_fd);
 351
 352         mw_set_get_device_type_response_cb(&mdata.mwdevice, mw_get_device_type_response_cb, &mdata);
 353         mw_set_get_real_time_clock_response_cb(&mdata.mwdevice, mw_get_real_time_clock_response_cb, &mdata);
 354         mw_set_get_battery_voltage_response_cb(&mdata.mwdevice, mw_get_battery_voltage_response_cb, &mdata);
 355
 356         // mw_send_frame(&mdata.mwdevice, MW_READ_BATTERY_VOLTAGE_MSG, 0, NULL, 0);
 357
 358         mdata.bat_timeout_id = g_timeout_add_seconds(10, battery_level_get_timeout, &mdata);
 359
 360         // setup_watchtype_gui(&mdata);
 361         gtk_main ();
 362
 363         return 0;
 364 }
 365