Improve cmd parameter parsing and handling
[metawatch.git] / mw_main.c
1 /*
2  * (c) 2011 Siegen, Germany by Nils Faerber <nils.faerber@kernelconcepts.de>
3  *
4  * license LGPL
5  */
6
7 #include <stdio.h>
8 #include <sys/types.h>
9 #include <sys/stat.h>
10 #include <fcntl.h>
11 #include <unistd.h>
12 #include <stdlib.h>
13 #include <string.h>
14 #include <time.h>
15 #include <termios.h>
16 #include <ctype.h>
17
18 #include <errno.h>
19
20 #include <bluetooth/bluetooth.h>
21 #include <bluetooth/rfcomm.h>
22
23 #include <glib.h>
24 #include <dbus/dbus.h>
25 #include <dbus/dbus-glib.h>
26 #include <dbus/dbus-glib-lowlevel.h>
27
28 #include <libsoup/soup.h>
29
30 #include <libxml/tree.h>
31 #include <libxml/parser.h>
32
33 /*
34 #include <bluetooth/sdp.h>
35 #include <bluetooth/sdp_lib.h>
36 */
37
38 #include "metawatch.h"
39 #include "crc16ccitt.h"
40 #include "mw_utility.h"
41
42 #include "bt_helper.h"
43
44 typedef struct {
45         GMainLoop *mloop;
46         mwdevice_t mwdevice;
47         unsigned char rcvbuf[128];
48         int rcvbuf_pos;
49         int con_fd;             /* console input fd */
50         char cmdline[128];
51         int cmdline_pos;
52         SoupSession *msoup;
53         SoupMessage *smsg;
54 } mwdata_t;
55
56 void bitmap_test(mwdevice_t *mwdevice)
57 {
58         /* a nice checker-board pattern */
59         unsigned char checkbuf[24] = {
60                 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
61                 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
62                 0x55, 0x55, 0x55, 0x55, 0x55, 0x55,
63                 0x55, 0x55, 0x55, 0x55, 0x55, 0x55,
64         };
65         mw_write_buffer(mwdevice, MW_SCREEN_MODE_IDLE, 0, 31, checkbuf, 24);
66         mw_write_buffer(mwdevice, MW_SCREEN_MODE_IDLE, 0, 33, checkbuf, 24);
67         mw_write_buffer(mwdevice, MW_SCREEN_MODE_IDLE, 0, 35, checkbuf, 24);
68         mw_write_buffer(mwdevice, MW_SCREEN_MODE_IDLE, 0, 37, checkbuf, 24);
69
70         mw_update_display(mwdevice, MW_SCREEN_MODE_IDLE, 1);
71 }
72
73 void bitmap_test2(mwdevice_t *mwdevice)
74 {
75         mw_buffer *mwbuf1, *mwbuf2;
76         unsigned char *bbuf;
77         int len, x;
78
79         mwbuf1 = mw_alloc_pbuffer(96, 66, 1);
80         mwbuf2 = mw_alloc_pbuffer(96, 66, 1);
81
82         mw_buf_clear(mwbuf1, MW_BLACK);
83         mw_buf_clear(mwbuf2, MW_WHITE);
84
85         for (x=0; x<66; x++) {
86                 //mw_buf_clear(mwbuf1, MW_BLACK);
87                 mw_buf_draw_pixel(mwbuf1, x, x, MW_WHITE);
88                 mw_dump_mw_buffer(mwbuf1);
89                 bbuf = mw_make_mw_buffer(mwbuf1, &len);
90                 mw_send_bitmap(mwdevice, MW_SCREEN_MODE_IDLE, 96, 65, 31, bbuf, len);
91                 mw_update_display(mwdevice, MW_SCREEN_MODE_IDLE, 1);
92                 getchar();
93         };
94
95         mw_free_pbuffer(mwbuf1);
96         mw_free_pbuffer(mwbuf2);
97 }
98
99 void text_test(mwdevice_t *mwdevice)
100 {
101         mw_buffer *mwbuf;
102         unsigned char *bbuf;
103         int len;
104
105         mwbuf = mw_alloc_pbuffer(96, 66, 1);
106         mw_buf_clear(mwbuf, MW_BLACK);
107
108         mw_buf_print(mwbuf, 1, 10, "Font 0", 0, MW_WHITE, MW_BLACK);
109         mw_buf_print(mwbuf, 1, 20, "Font 1", 1, MW_WHITE, MW_BLACK);
110         mw_buf_print(mwbuf, 1, 30, "Font 2", 2, MW_WHITE, MW_BLACK);
111         mw_buf_print(mwbuf, 1, 45, "Big Fat Clipping", 2, MW_BLACK, MW_WHITE);
112
113         bbuf = mw_make_mw_buffer(mwbuf, &len);
114         mw_send_bitmap(mwdevice, MW_SCREEN_MODE_IDLE, 96, 65, 31, bbuf, len);
115         mw_update_display(mwdevice, MW_SCREEN_MODE_IDLE, 1);
116         mw_free_pbuffer(mwbuf);
117 }
118
119 void line_test(mwdevice_t *mwdevice)
120 {
121         mw_buffer *mwbuf;
122         unsigned char *bbuf;
123         int len, p;
124
125         mwbuf = mw_alloc_pbuffer(96, 66, 1);
126         mw_buf_clear(mwbuf, MW_BLACK);
127
128         for (p=0; p<=96; p+=8)
129                 mw_buf_draw_line_bresenham(mwbuf, p, 0, 95-p, 65, MW_WHITE);
130
131         bbuf = mw_make_mw_buffer(mwbuf, &len);
132         mw_send_bitmap(mwdevice, MW_SCREEN_MODE_IDLE, 96, 65, 31, bbuf, len);
133         mw_update_display(mwdevice, MW_SCREEN_MODE_IDLE, 1);
134         mw_free_pbuffer(mwbuf);
135 }
136
137 void bitmap_read(mwdevice_t *mwdevice)
138 {
139         int ffd, ret;
140         char rbuf[256];
141         unsigned int width, height, i;
142 #ifdef DEBUG
143         unsigned int x, y;
144 #endif
145         unsigned int rowlength;
146         unsigned char *bmapbuf;
147         // unsigned char mw_buf[24];
148
149         ffd = open("test.pbm", O_RDONLY);
150         if (ffd < 0) {
151                 perror("open");
152                 return;
153         };
154         ret = read(ffd, rbuf, 3);
155         if (rbuf[0] != 'P' || rbuf[1] != '4') {
156                 fprintf(stderr, "not a PBM file\n");
157                 return;
158         }
159         memset(rbuf, 0, 256);
160         i = 0;
161         do {
162                 ret = read(ffd, (rbuf+i), 1);
163         } while (!isspace(rbuf[i++]));
164         width = atoi(rbuf);
165
166         memset(rbuf, 0, 256);
167         i = 0;
168         do {
169                 ret = read(ffd, (rbuf+i), 1);
170         } while (!isspace(rbuf[i++]));
171         height = atoi(rbuf);
172
173         rowlength = ((width / 8) + 1);
174
175         bmapbuf = malloc(rowlength * height);
176
177         ret = read(ffd, bmapbuf, rowlength * height);
178         close(ffd);
179
180 #ifdef DEBUG
181         fprintf(stderr, "row length = %d bytes\n", rowlength);
182         fprintf(stderr, "bitmap resolution is %d x %d\n", width, height);
183         fprintf(stderr, "read %d of %d bytes\n", ret, rowlength * height);
184         fprintf(stderr, "\n");
185         for (y=0; y<height; y++) {
186                 for (x=0; x<rowlength; x++) {
187                         for (i=0; i<8; i++)
188                                 fprintf(stderr, "%c", (bmapbuf[(y*rowlength)+x] & (1<<(7-i))) ? '.' : ' ');
189                 }
190                 fprintf(stderr, "\n");
191         }
192         fprintf(stderr, "\n");
193 #endif
194
195         /* reverse bits and invert the bmap */
196         bmap_buffer_flipinvert(1, 1, bmapbuf, rowlength * height);
197         /* send the buffer to the watch */
198         mw_send_bitmap(mwdevice, MW_SCREEN_MODE_IDLE, width, height, 31, bmapbuf, rowlength * height);
199         /* update the display */
200         mw_update_display(mwdevice, MW_SCREEN_MODE_IDLE, 1);
201
202         free(bmapbuf);
203 }
204
205 void test_notification(mwdevice_t *mwdevice)
206 {
207         mw_buffer *mwbuf;
208         unsigned char *bbuf;
209         int len;
210
211         mwbuf = mw_alloc_pbuffer(96, 96, 1);
212         mw_buf_clear(mwbuf, MW_BLACK);
213
214         mw_buf_draw_line_bresenham(mwbuf, 2, 0, 93, 0, MW_WHITE);
215         mw_buf_draw_line_bresenham(mwbuf, 0, 1, 95, 1, MW_WHITE);
216         mw_buf_draw_line_bresenham(mwbuf, 0, 94, 95, 94, MW_WHITE);
217         mw_buf_draw_line_bresenham(mwbuf, 2, 95, 93, 95, MW_WHITE);
218
219         mw_buf_draw_line_bresenham(mwbuf, 0, 2, 0, 93, MW_WHITE);
220         mw_buf_draw_line_bresenham(mwbuf, 1, 0, 1, 95, MW_WHITE);
221         mw_buf_draw_line_bresenham(mwbuf, 95, 2, 95, 93, MW_WHITE);
222         mw_buf_draw_line_bresenham(mwbuf, 94, 0, 94, 95, MW_WHITE);
223
224         mw_buf_print(mwbuf, 4,  4, "012345678901234", 0, MW_WHITE, MW_BLACK);
225         mw_buf_print(mwbuf, 4, 13, "012345678901234", 0, MW_WHITE, MW_BLACK);
226         mw_buf_print(mwbuf, 4, 22, "0123456789g1234", 0, MW_WHITE, MW_BLACK);
227         mw_buf_print(mwbuf, 4, 31, "012345678901234", 0, MW_WHITE, MW_BLACK);
228         mw_buf_print(mwbuf, 4, 40, "012345678901234", 0, MW_WHITE, MW_BLACK);
229         mw_buf_print(mwbuf, 4, 49, "012345678901234", 0, MW_WHITE, MW_BLACK);
230         mw_buf_print(mwbuf, 4, 58, "0123456789g1234", 0, MW_WHITE, MW_BLACK);
231         mw_buf_print(mwbuf, 4, 67, "012345678901234", 0, MW_WHITE, MW_BLACK);
232         mw_buf_print(mwbuf, 4, 76, "012345678901234", 0, MW_WHITE, MW_BLACK);
233         mw_buf_print(mwbuf, 4, 85, "012345678901234", 0, MW_WHITE, MW_BLACK);
234
235         bbuf = mw_make_mw_buffer(mwbuf, &len);
236         mw_send_bitmap(mwdevice, MW_SCREEN_MODE_NOTIFICATION, 96, 96, 0, bbuf, len);
237         mw_update_display(mwdevice, MW_SCREEN_MODE_NOTIFICATION, 1);
238         mw_free_pbuffer(mwbuf);
239
240         mw_set_vibrate_mode(mwdevice, 1, 300, 300, 3);
241 }
242
243 int days(int m1, int y1)
244 {
245         int d;
246         if(m1==1 || m1==3 || m1==5 || m1==7 || m1==8 || m1==10 || m1==12)
247                 d=31;
248         else if(m1==4 || m1==6 || m1==9 || m1==11)
249                 d=30;
250         else if((y1%100!=0 && y1%4==0) || y1%400==0)
251                 d=29;
252         else
253                 d=28;
254         return d;
255 }
256
257 void draw_idle_calendar(mwdevice_t *mwdevice)
258 {
259         long unsigned int t;
260         unsigned int y,y1,m,m1,d,i,j,k;
261         /* const char a[12][20]={"January","February","March","April","May","June","July","August","September","October","November","December"}; */
262         const char dnames[7][3] = { "Mo", "Di", "Mi", "Do", "Fr", "Sa", "So" };
263         mw_buffer *mwbuf;
264         unsigned char *bbuf;
265         int len, px, py;
266         char pnum[32];
267         int today;
268         time_t mtime;
269         struct tm mtm;
270                                
271         mtime = time(NULL);
272         localtime_r(&mtime, &mtm);
273
274         today = mtm.tm_mday;
275         y = mtm.tm_year + 1900;
276         m = mtm.tm_mon + 1;
277
278         mwbuf = mw_alloc_pbuffer(96, 66, 1);
279         mw_buf_clear(mwbuf, MW_BLACK);
280
281         if (y < 0)
282                 y = -y;
283         if (m <= 0 || m >= 13)
284                 m = 1;
285         y1 = 0;
286         t = 0;
287         while (y1 < y) {
288                 if (((y1 % 100) != 0 && (y1 % 4) == 0) || (y1 % 400) == 0)
289                         t += 366;
290                 else
291                         t += 365;
292                 y1++;
293         }
294         m1 = 1;
295         while (m1 < m) {
296                 d = days(m1, y);
297                 t = t + d;
298                 m1++;
299         };
300 #if 0
301         printf("Year: '%u'\n",y);
302         printf("Month: '%s'\n",a[m-1]);
303
304         printf("%6s%6s%6s%6s%6s%6s%6s\n","Sun","Mon","Tue","Wed","Thu","Fri","Sat");
305 #endif
306
307         k = 1;
308         /* 0 = 1st day is Monday, 1 = 1st day is Sunday */
309         d = (t % 7)-1;
310         px=0;
311         py=3;
312         for (i=0; i<7; i++) {
313                 snprintf(pnum, 3, "%s", dnames[i]);
314                 mw_buf_print(mwbuf, px, py, pnum, 0, MW_WHITE, MW_BLACK);
315                 px += 14;
316         };
317         px = 0;
318         py += 10;
319         for (i = 1; i <= days(m,y); i++, k++) {
320                 if (i == 1) {
321                         if (d == 0) {
322                                 for (j = 1; j < 7; j++, k++) {
323                                         printf("+--"); //printf("%3s","");
324                                         px += 14;
325                                 }
326                         } else {
327                                 for (j = 1; j < d; j++, k++) {
328                                         px += 14;
329                                         printf("--+"); //printf("%3s","");
330                                 }
331                         }
332                 }
333                 snprintf(pnum, 8, "%2d", i);
334                 if (i == today)
335                         mw_buf_print(mwbuf, px, py, pnum, 0, MW_BLACK, MW_WHITE);
336                 else
337                         mw_buf_print(mwbuf, px, py, pnum, 0, MW_WHITE, MW_BLACK);
338                 px += 12;
339                 printf("%2d", i);
340                 if ((k % 7) == 0) {
341                         printf("\n");
342                         px = 0;
343                         py += 10;
344                 } else {
345                         printf("+");
346                         px += 2;
347                 }
348         }
349         // printf("\n");
350
351         //mw_buf_print(mwbuf, 1, 10, "Font 0", 0, MW_WHITE, MW_BLACK);
352
353         bbuf = mw_make_mw_buffer(mwbuf, &len);
354         mw_send_bitmap(mwdevice, MW_SCREEN_MODE_IDLE, 96, 65, 31, bbuf, len);
355         mw_update_display(mwdevice, MW_SCREEN_MODE_IDLE, 1);
356         mw_free_pbuffer(mwbuf);
357 }
358
359 void mw_send_notify(mwdevice_t *mwdevice, char *header, char *body)
360 {
361         mw_buffer *mwbuf;
362         unsigned char *bbuf;
363         int len,i,c,r;
364         char sstr[32];
365
366         mwbuf = mw_alloc_pbuffer(96, 96, 1);
367         mw_buf_clear(mwbuf, MW_BLACK);
368
369         mw_buf_print(mwbuf, 0,  0, header, 0, MW_BLACK, MW_WHITE);
370
371         i=0;
372         c=0; r=1;
373         memset(sstr,0,32);
374         while (i<strlen(body)) {
375                 sstr[c++] = body[i++];
376                 if (c>=16 || i>=strlen(body)) {
377                         mw_buf_print(mwbuf, 0,  r*9, sstr, 0, MW_WHITE, MW_BLACK);
378                         memset(sstr,0,32);
379                         c=0; r++;
380                         if (r>10)
381                                 break;
382                 };
383         };
384
385         bbuf = mw_make_mw_buffer(mwbuf, &len);
386         mw_send_bitmap(mwdevice, MW_SCREEN_MODE_APPLICATION, 96, 96, 0, bbuf, len);
387         mw_update_display(mwdevice, MW_SCREEN_MODE_APPLICATION, 1);
388         mw_free_pbuffer(mwbuf);
389
390         mw_set_vibrate_mode(mwdevice, 1, 300, 300, 2);
391 }
392
393 void test_application(mwdevice_t *mwdevice)
394 {
395         mw_buffer *mwbuf;
396         unsigned char *bbuf;
397         int len;
398
399         mw_enable_button(mwdevice, MW_SCREEN_MODE_IDLE, MW_BUTTON_A, MW_BUTTON_IMMEDIATE, MW_BUTTON_EVENT_MESSAGE, MW_BUTTON_A);
400
401         mw_enable_button(mwdevice, MW_SCREEN_MODE_APPLICATION, MW_BUTTON_A, MW_BUTTON_IMMEDIATE, MW_BUTTON_EVENT_MESSAGE, MW_BUTTON_A);
402         mw_enable_button(mwdevice, MW_SCREEN_MODE_APPLICATION, MW_BUTTON_B, MW_BUTTON_IMMEDIATE, MW_BUTTON_EVENT_MESSAGE, MW_BUTTON_B);
403         mw_enable_button(mwdevice, MW_SCREEN_MODE_APPLICATION, MW_BUTTON_C, MW_BUTTON_IMMEDIATE, MW_BUTTON_EVENT_MESSAGE, MW_BUTTON_C);
404         mw_enable_button(mwdevice, MW_SCREEN_MODE_APPLICATION, MW_BUTTON_E, MW_BUTTON_IMMEDIATE, MW_BUTTON_EVENT_MESSAGE, MW_BUTTON_E);
405         mw_enable_button(mwdevice, MW_SCREEN_MODE_APPLICATION, MW_BUTTON_F, MW_BUTTON_IMMEDIATE, MW_BUTTON_EVENT_MESSAGE, MW_BUTTON_F);
406         mw_configure_watch_mode(mwdevice, MW_SCREEN_MODE_APPLICATION, 0, 30, 0);
407
408         mwbuf = mw_alloc_pbuffer(96, 96, 1);
409         mw_buf_clear(mwbuf, MW_BLACK);
410
411         mw_buf_print(mwbuf, 0,  0, "  Application   ", 0, MW_BLACK, MW_WHITE);
412         mw_buf_print(mwbuf, 0,  9, "0123456789012345", 0, MW_WHITE, MW_BLACK);
413         mw_buf_print(mwbuf, 0, 18, "0123456789g12345", 0, MW_WHITE, MW_BLACK);
414         mw_buf_print(mwbuf, 0, 27, "0123456789012345", 0, MW_WHITE, MW_BLACK);
415         mw_buf_print(mwbuf, 0, 36, "0123456789012345", 0, MW_WHITE, MW_BLACK);
416         mw_buf_print(mwbuf, 0, 45, "0123456789012345", 0, MW_WHITE, MW_BLACK);
417         mw_buf_print(mwbuf, 0, 54, "0123456789g12345", 0, MW_WHITE, MW_BLACK);
418         mw_buf_print(mwbuf, 0, 63, "0123456789012345", 0, MW_WHITE, MW_BLACK);
419         mw_buf_print(mwbuf, 0, 72, "0123456789012345", 0, MW_WHITE, MW_BLACK);
420         mw_buf_print(mwbuf, 0, 81, "0123456789012345", 0, MW_WHITE, MW_BLACK);
421
422         bbuf = mw_make_mw_buffer(mwbuf, &len);
423         mw_send_bitmap(mwdevice, MW_SCREEN_MODE_APPLICATION, 96, 96, 0, bbuf, len);
424         mw_update_display(mwdevice, MW_SCREEN_MODE_APPLICATION, 1);
425         mw_free_pbuffer(mwbuf);
426 }
427
428 void test_oled(mwdevice_t *mwdevice, unsigned char oled)
429 {
430         mw_buffer *mwbuf;
431         unsigned char *bbuf;
432         int len;
433
434         mwbuf = mw_alloc_pbuffer(80, 16, 1);
435         mw_buf_clear(mwbuf, MW_BLACK);
436
437         mw_buf_print(mwbuf, 0,  0, "Application", 0, MW_WHITE, MW_BLACK);
438         mw_buf_print(mwbuf, 0,  8, "012345678901234", 0, MW_WHITE, MW_BLACK);
439
440         bbuf = mw_make_mw_oled_buffer(mwbuf, &len);
441         mw_write_oled_buffer(mwdevice, 0, oled, 80, 0, bbuf, len);
442
443         mw_free_pbuffer(mwbuf);
444 }
445
446 static void
447 weather_soup_callback (SoupSession *session, SoupMessage *msg, gpointer user_data)
448 {
449         xmlDocPtr xdoc;
450
451         /* Handle the response here */
452         if (msg->response_body->data != NULL && msg->response_body->length != 0) {
453                 fprintf(stderr, "%s\n", msg->response_body->data);
454                 xdoc = xmlReadMemory(msg->response_body->data, msg->response_body->length, "noname.xml", NULL, 0);
455                 if (xdoc == NULL) {
456                         fprintf(stderr, "Failed to parse document\n");
457                         return;
458                 }
459                 xmlFreeDoc(xdoc);
460                 xmlCleanupParser();
461         }
462 }
463
464 void do_weather(mwdata_t *mwdata)
465 {
466         mwdata->msoup = soup_session_async_new();
467         mwdata->smsg = soup_message_new ("GET", "http://www.google.com/ig/api?weather=siegen&hl=de");
468         soup_session_send_message (mwdata->msoup, mwdata->smsg);
469         soup_session_queue_message (mwdata->msoup, mwdata->smsg, weather_soup_callback, mwdata);
470 }
471
472 void print_help(void)
473 {
474         g_print("Not yet implemented..\n");
475 }
476
477 #define PARAMS_MAX 8
478 #define PARAMS_LEN 16
479
480 static int separate_params(char *params[], char *pbuf)
481 {
482         char *ret;
483         char tbuf[128];
484         int cnt = 0;
485
486         memset(tbuf, 0, 128);
487         strncpy(tbuf, pbuf, strlen(pbuf));
488         // strdump(tbuf, strlen(tbuf));
489         /* we know we do have at least one parameter */
490         ret = strtok(tbuf, " ");
491         while (ret != NULL) {
492                 // dbg_printf("tok '%s'\n", ret);
493                 strncpy(params[cnt++], ret, PARAMS_LEN-1);
494                 if (cnt > PARAMS_MAX)
495                         break;
496                 ret = strtok(NULL, " ");
497         }
498
499         return cnt;
500 }
501
502 static void params_free(char **params)
503 {
504         int i;
505         for (i=0; i < PARAMS_MAX; i++)
506                 free(params[i]);
507 }
508
509 void process_cmd(char *cmdline, int clinep, mwdata_t *mwdata)
510 {
511         unsigned char mdata[32];
512         unsigned int intopt;
513         char cmd[128], pbuf[128], *params[PARAMS_MAX];
514         int i, pcnt;
515         char *inbuf = cmdline;
516
517         g_print("command: '%s'\n", cmdline);
518
519         for (i=0; i<PARAMS_MAX; i++) {
520                 params[i] = malloc(PARAMS_LEN);
521                 memset(params[i], 0, PARAMS_LEN);
522         }
523         memset(cmd, 0, 128);
524         memset(pbuf, 0, 128);
525         i = 0;
526         do {
527                 char c;
528                 c = *(inbuf++);
529                 cmd[i++] = c;
530         } while (*inbuf != 0 && *inbuf != 0x20);
531         i = 0;
532         if (inbuf != NULL && *inbuf == 0x20) {
533                 inbuf++;
534                 do {
535                         pbuf[i++] = *(inbuf++);
536                 } while (*inbuf != 0);
537         };
538         if (strlen(pbuf) > 0)
539                 pcnt = separate_params(params, pbuf);
540         else
541                 pcnt = 0;
542
543         if (strncmp(cmd, "quit", 4) == 0) {
544                 //close(mw_fd);
545                 //exit(0);
546                 /* just in case we quit and show another screen */
547                 mw_update_display(&mwdata->mwdevice, MW_SCREEN_MODE_IDLE, 0);
548                 params_free(params);
549                 g_main_loop_quit (mwdata->mloop);
550         }
551         if (strncmp(cmd, "help", 4) == 0) {
552                 print_help();
553         }
554         if (strncmp(cmd, "ahand", 5) == 0) {
555                 if (pcnt > 0) {
556                         intopt = atoi(params[0]); /*atoi(cmdline+5);*/
557                         g_print("Advance analog hands by %d minutes\n", intopt);
558                         mdata[0] = intopt / 60;
559                         mdata[1] = intopt % 60;
560                         mdata[2] = 0;
561                         mw_send_frame(&mwdata->mwdevice, MW_ADVANCE_WATCH_HANDS, 0, mdata, 3);
562                 } else
563                         g_print("missing argument\n ahand # - # = no. of minutes\n");
564         }
565         if (strncmp(cmd, "srtc", 4) == 0) {
566                 time_t mtime;
567                 struct tm mtm;
568
569                 mtime = time(NULL);
570                 localtime_r(&mtime, &mtm);
571
572                 g_print("Setting RTC from system time...");
573                 mw_set_rtc(&mwdata->mwdevice, &mtm);
574                 g_print("OK\n");
575         }
576         if (strncmp(cmd, "grtc", 4) == 0) {
577                 mw_send_frame(&mwdata->mwdevice, MW_GET_REAL_TIME_CLOCK, 0, NULL, 0);
578         }
579         if (strncmp(cmd, "gistr", 5) == 0) {
580                 if (pcnt > 0)
581                         intopt = atoi(params[0]);
582                 if (intopt >= 0 && intopt <= 3)
583                         mdata[0] = intopt;
584                 else
585                         mdata[0] = 0;
586                 mw_send_frame(&mwdata->mwdevice, MW_GET_INFORMATION_STRING, 0, mdata, 1);
587         }
588         if (strncmp(cmd, "gdtype", 6) == 0) {
589                 mw_send_frame(&mwdata->mwdevice, MW_GET_DEVICE_TYPE, 0, NULL, 0);
590         }
591         if (strncmp(cmd, "rvbat", 5) == 0) {
592                 mw_send_frame(&mwdata->mwdevice, MW_READ_BATTERY_VOLTAGE_MSG, 0, NULL, 0);
593         }
594         if (strncmp(cmd, "rlight", 6) == 0) {
595                 mw_send_frame(&mwdata->mwdevice, MW_READ_LIGHT_SENSOR_MSG, 0, NULL, 0);
596         }
597         if (strncmp(cmd, "modecfg", 6) == 0) {
598                 mw_configure_watch_mode(&mwdata->mwdevice, MW_SCREEN_MODE_IDLE, 0, 4, 1);
599                 mw_update_display(&mwdata->mwdevice, MW_SCREEN_MODE_IDLE, 0);
600         }
601 #if 0
602         if (strncmp(cmdline, "rbtcfg", 6) == 0) {
603                 intopt = cmdline[7]-0x30;
604                 mdata[0] = 0; /* idle screen */
605                 mdata[1] = intopt; /* button index */
606                 /* for reading the config those are unnecessary */
607                 mdata[2] = 0; /* button press type */
608                 mdata[3] = 0; /* callback message type */
609                 mdata[4] = 0; /* callback message option */
610                 mw_send_frame(&mwdata->mwdevice, MW_READ_BUTTON_CONFIG, 0, mdata, 5);
611         }
612 #endif
613         if (strncmp(cmd, "svib", 4) == 0) {
614                 mw_set_vibrate_mode(&mwdata->mwdevice, 1, 300, 300, 5);
615         }
616         if (strncmp(cmd, "tbmp", 4) == 0) {
617                 bitmap_test(&mwdata->mwdevice);
618         }
619         if (strncmp(cmd, "t2bmp", 5) == 0) {
620                 bitmap_test2(&mwdata->mwdevice);
621         }
622         if (strncmp(cmd, "text", 4) == 0) {
623                 text_test(&mwdata->mwdevice);
624         }
625         if (strncmp(cmd, "tline", 5) == 0) {
626                 line_test(&mwdata->mwdevice);
627         }
628         if (strncmp(cmd, "rbmp", 4) == 0) {
629                 bitmap_read(&mwdata->mwdevice);
630         }
631         if (strncmp(cmd, "tnote", 5) == 0) {
632                 // test_notification(&mwdata->mwdevice);
633                 mw_do_notification(&mwdata->mwdevice, "TestNotification", "This is a pretty long text that needs to be broken and torn", 1);
634         }
635         if (strncmp(cmd, "tapp", 4) == 0) {
636                 test_application(&mwdata->mwdevice);
637         }
638         if (strncmp(cmd, "eoled", 5) == 0) {
639                 if (pcnt > 0) {
640                         intopt = atoi(params[0]);
641                         if (intopt == MW_OLED_UPPER || intopt == MW_OLED_LOWER)
642                                 mw_send_frame(&mwdata->mwdevice, MW_ENABLE_OLED_DISPLAY_MSG, intopt, NULL, 0);
643                 }
644         }
645         if (strncmp(cmd, "toled", 5) == 0) {
646                 intopt = atoi(params[0]);
647                 test_oled(&mwdata->mwdevice, intopt);
648                 //mw_write_oled_buffer(mwdevice, 0, 80, 0, mdata, 10);
649                 //mw_send_frame(mwdevice, MW_UPDATE_OLED_DISPLAY_MSG, 0, NULL, 0);
650         }
651         if (strncmp(cmd, "cal", 3) == 0) {
652                 draw_idle_calendar(&mwdata->mwdevice);
653         }
654         if (strncmp(cmd, "wet", 3) == 0) {
655                 do_weather(mwdata);
656         }
657         if (strncmp(cmd, "c24", 3) == 0) {
658                 mdata[0] = MW_RTC_CLOCK_24HR;
659                 mw_nval_operation(&mwdata->mwdevice, MW_NVAL_OPERATION_WRITE, MW_NVAL_TIME_FORMAT, 1, mdata);
660         }
661         if (strncmp(cmd, "g24", 3) == 0) {
662                 mdata[0] = 0;
663                 mw_nval_operation(&mwdata->mwdevice, MW_NVAL_OPERATION_READ, MW_NVAL_TIME_FORMAT, 1, mdata);
664         }
665         if (strncmp(cmd, "sdm", 3) == 0) {
666                 mdata[0] = MW_RTC_DATE_DDMM;
667                 mw_nval_operation(&mwdata->mwdevice, MW_NVAL_OPERATION_WRITE, MW_NVAL_DATE_FORMAT, 1, mdata);
668         }
669         if (strncmp(cmd, "gdm", 3) == 0) {
670                 mdata[0] = 0;
671                 mw_nval_operation(&mwdata->mwdevice, MW_NVAL_OPERATION_READ, MW_NVAL_DATE_FORMAT, 1, mdata);
672         }
673         params_free(params);
674 }
675
676 int feed_menu(mwdata_t *mdata)
677 {
678         int rcvd;
679
680         rcvd = read(0, (mdata->cmdline+mdata->cmdline_pos), 1);
681         if (rcvd > 0) {
682                 if (mdata->cmdline[mdata->cmdline_pos] == '\r') {
683                         printf("\n");
684                         mdata->cmdline[mdata->cmdline_pos--] = '\0';
685                         process_cmd(mdata->cmdline, mdata->cmdline_pos, mdata);
686                         mdata->cmdline_pos = 0;
687                         memset(mdata->cmdline, 0, 128);
688                 } else {
689                         mdata->cmdline_pos++;
690                         if (mdata->cmdline_pos > 75)
691                                 mdata->cmdline_pos = 75;
692                         printf("\r> %s", mdata->cmdline);
693                         fflush(stdout);
694                 }
695         }
696         return 0;
697 }
698
699
700 gboolean handle_mw_io(GIOChannel *mw_io, GIOCondition condition, gpointer udata)
701 {
702         mwdata_t *mdata = (mwdata_t *)udata;
703         int rcvd;
704
705         rcvd = read(mdata->mwdevice.mw_fd, mdata->rcvbuf, 64);
706 #ifdef DEBUG
707         fprintf(stderr, "read %d bytes:\n", rcvd);
708 #endif
709         if (rcvd > 0) {
710 #ifdef DEBUG
711                 dump_frame(mdata->rcvbuf, rcvd);
712 #endif
713                 mw_feed_msg_buffer(&mdata->mwdevice, mdata->rcvbuf, rcvd);
714         }
715
716         return TRUE;
717 }
718
719 gboolean handle_min_io(GIOChannel *mw_io, GIOCondition condition, gpointer udata)
720 {
721         mwdata_t *mdata = (mwdata_t *)udata;
722
723         feed_menu(mdata);
724
725         return TRUE;
726 }
727
728 static DBusHandlerResult
729 signal_filter (DBusConnection *connection, DBusMessage *message, void *user_data)
730 {
731         //GMainLoop *loop = user_data;
732         mwdata_t *mdata = (mwdata_t *)user_data;
733         DBusError error;
734         char *app_name, *app_icon, *summary, *body; // **actions;
735         int replace_id; // dict, expire;
736
737         /* A signal from the bus saying we are about to be disconnected */
738         if (dbus_message_is_signal(message, "org.freedesktop.Local", "Disconnected")) {
739                 /* Tell the main loop to quit */
740                 g_main_loop_quit (mdata->mloop);
741                 /* We have handled this message, don't pass it on */
742                 return DBUS_HANDLER_RESULT_HANDLED;
743         }
744
745         if (dbus_message_is_method_call (message,"org.freedesktop.Notifications", "Notify"))    {
746                 g_print("method call\n");
747                 dbus_error_init (&error);
748                 if (dbus_message_get_args(message, &error,
749                         DBUS_TYPE_STRING, &app_name,
750                         DBUS_TYPE_UINT32, &replace_id,
751                         DBUS_TYPE_STRING, &app_icon,
752                         DBUS_TYPE_STRING, &summary,
753                         DBUS_TYPE_STRING, &body,
754                         /*  G_TYPE_STRV, &actions,
755                         DBUS_TYPE_DICT_ENTRY_AS_STRING, &dict,
756                         DBUS_TYPE_INT32, &expire, */
757                         DBUS_TYPE_INVALID)) {
758                         g_print("Notify received: from app %s, icon %s:\nSummary: %s\nBody: %s\n", app_name, app_icon, summary, body);
759                         mw_send_notify(&mdata->mwdevice, summary, body);
760                         /* we just listen, we do not handle it here */
761                         return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
762                 } else {
763                         g_print("Notify received, but error getting message: %s\n", error.message);
764                         dbus_error_free (&error);
765                 }
766         } else {
767                 g_print("Not signal received\n");
768                 return DBUS_HANDLER_RESULT_HANDLED;
769         };
770
771         return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
772 }
773
774 void mw_button_event_message_cb(mwdevice_t *mwdevice, unsigned char buttons, unsigned char options, void *user_data)
775 {
776         g_print("button event cb:0x%02x 0x%02x\n", buttons, options);
777         g_print("screen is %d\n", mwdevice->screen_mode);
778         if (mwdevice->screen_mode == MW_SCREEN_MODE_IDLE) {
779                 if (buttons == MW_BUTTON_A)
780                         test_application(mwdevice);
781         }
782         if (mwdevice->screen_mode == MW_SCREEN_MODE_APPLICATION) {
783                 if (buttons == MW_BUTTON_C)
784                         mw_update_display(mwdevice, MW_SCREEN_MODE_IDLE, 0);
785         }
786 }
787
788 int main(int argc, char **argv)
789 {
790         int mw_fd;
791         mwdata_t mdata;
792         struct termios tconfd, otconfd, tmwfd;
793         bdaddr_t btaddr;
794         GIOChannel *mw_io, *m_in;
795         DBusConnection *bus;
796         DBusError error;
797
798         if (argc != 2) {
799                 fprintf(stderr, "Usage:\n\t%s <devicename>\n", argv[0]);
800                 return 1;
801         };
802   
803         g_type_init();
804         mdata.mloop = g_main_loop_new (NULL, FALSE);
805
806         crc16ccitt_init();
807
808 #if USE_RFCOMM_FILE
809         mw_fd = open(argv[1], O_RDWR);
810         if (mw_fd < 0) {
811                 perror("open");
812                 return 1;
813         };
814 #else
815         if (str2ba(argv[1], &btaddr))
816                 return 1;
817         mw_fd = open_socket(&btaddr, 1);
818         if (mw_fd < 0) {
819                 return 1;
820         } else {
821                 fprintf(stderr, "connected to %s\n", argv[1]);
822         };
823 #endif
824         /* we have a connection, RFCOMM socket is on mw_fd */
825         /* make the tty raw */
826         tcgetattr(mw_fd, &tmwfd);
827         cfmakeraw(&tmwfd);
828         tmwfd.c_oflag |= ONLCR | OPOST;
829         tmwfd.c_lflag |= ISIG;
830         tcsetattr(mw_fd, TCSANOW, &tmwfd);
831
832         mdata.mwdevice.mw_fd = mw_fd;
833         mdata.rcvbuf_pos = 0;
834         memset(mdata.rcvbuf, 0, 128);
835
836         dbus_error_init (&error);
837         bus = dbus_bus_get (DBUS_BUS_SESSION, &error);
838
839         if (!bus) {
840                 g_warning ("Failed to connect to the D-BUS daemon: %s", error.message);
841                 dbus_error_free (&error);
842                 return 1;
843         }
844
845         dbus_connection_setup_with_g_main (bus, NULL);
846         dbus_bus_add_match (bus, "interface='org.freedesktop.Notifications'", &error);
847
848         dbus_connection_add_filter (bus, signal_filter, &mdata, NULL);
849
850         // menu(mw_fd);
851         mw_io = g_io_channel_unix_new(mw_fd);
852         g_io_add_watch(mw_io, G_IO_IN | G_IO_PRI | G_IO_ERR | G_IO_HUP, handle_mw_io, &mdata);
853
854         tcgetattr(0, &tconfd);
855         tcgetattr(0, &otconfd);
856         cfmakeraw(&tconfd);
857         tconfd.c_oflag |= ONLCR | OPOST;
858         tconfd.c_lflag |= ISIG;
859         tcsetattr(0, TCSANOW, &tconfd);
860
861         mdata.con_fd = 0;
862
863         m_in = g_io_channel_unix_new(0); /* stdin for kbd */
864         g_io_add_watch(m_in, G_IO_IN | G_IO_PRI | G_IO_ERR | G_IO_HUP, handle_min_io, &mdata);
865
866         memset(mdata.cmdline, 0, 128);
867         mdata.cmdline_pos = 0;
868
869         mw_init(&mdata.mwdevice, mw_fd);
870         mw_set_button_event_message_cb(&mdata.mwdevice, mw_button_event_message_cb, NULL);
871
872         g_main_loop_run (mdata.mloop);
873
874         fsync(mw_fd);
875         close(mw_fd);
876
877         /* reset the controlling tty again */
878         tcsetattr(0, TCSANOW, &otconfd);
879
880         return 0;
881 };
882