f2597eea550bffc9bcef1ad474085ef695a2a056
[metawatch.git] / 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 }