Ooops - fix typo
[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 #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