Implement battery warning and bt-off message handlers and callbacks
[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 }
475
476 void process_cmd(char *cmdline, int clinep, mwdata_t *mwdata)
477 {
478         unsigned char mdata[32];
479         unsigned int intopt;
480
481         fprintf(stderr, "command: '%s'\n", cmdline);
482
483         if (strncmp(cmdline, "quit", 4) == 0) {
484                 //close(mw_fd);
485                 //exit(0);
486                 /* just in case we quit and show another screen */
487                 mw_update_display(&mwdata->mwdevice, MW_SCREEN_MODE_IDLE, 0);
488                 g_main_loop_quit (mwdata->mloop);
489         }
490         if (strncmp(cmdline, "help", 4) == 0) {
491                 print_help();
492         }
493         if (strncmp(cmdline, "ahand", 5) == 0) {
494                 intopt = atoi(cmdline+5);
495                 g_print("Advance analog hands by %d minutes\n", intopt);
496                 mdata[0] = intopt / 60;
497                 mdata[1] = intopt % 60;
498                 mdata[2] = 0;
499                 mw_send_frame(&mwdata->mwdevice, MW_ADVANCE_WATCH_HANDS, 0, mdata, 3);
500         }
501         if (strncmp(cmdline, "srtc", 4) == 0) {
502                 time_t mtime;
503                 struct tm mtm;
504
505                 mtime = time(NULL);
506                 localtime_r(&mtime, &mtm);
507
508                 fprintf(stderr, "Setting RTC from system time...");
509                 mw_set_rtc(&mwdata->mwdevice, &mtm);
510                 fprintf(stderr, "OK\n");
511         }
512         if (strncmp(cmdline, "grtc", 4) == 0) {
513                 mw_send_frame(&mwdata->mwdevice, MW_GET_REAL_TIME_CLOCK, 0, NULL, 0);
514         }
515         if (strncmp(cmdline, "gistr", 5) == 0) {
516                 intopt = cmdline[6]-0x30;
517                 if (intopt>=0 && intopt <=3)
518                         mdata[0] = intopt;
519                 else
520                         mdata[0] = 0;
521                 mw_send_frame(&mwdata->mwdevice, MW_GET_INFORMATION_STRING, 0, mdata, 1);
522         }
523         if (strncmp(cmdline, "gdtype", 6) == 0) {
524                 mw_send_frame(&mwdata->mwdevice, MW_GET_DEVICE_TYPE, 0, NULL, 0);
525         }
526         if (strncmp(cmdline, "rvbat", 5) == 0) {
527                 mw_send_frame(&mwdata->mwdevice, MW_READ_BATTERY_VOLTAGE_MSG, 0, NULL, 0);
528         }
529         if (strncmp(cmdline, "rlight", 6) == 0) {
530                 mw_send_frame(&mwdata->mwdevice, MW_READ_LIGHT_SENSOR_MSG, 0, NULL, 0);
531         }
532         if (strncmp(cmdline, "modecfg", 6) == 0) {
533                 mw_configure_watch_mode(&mwdata->mwdevice, MW_SCREEN_MODE_IDLE, 0, 4, 1);
534                 mw_update_display(&mwdata->mwdevice, MW_SCREEN_MODE_IDLE, 0);
535         }
536         if (strncmp(cmdline, "rbtcfg", 6) == 0) {
537                 intopt = cmdline[7]-0x30;
538                 mdata[0] = 0; /* idle screen */
539                 mdata[1] = intopt; /* button index */
540                 /* for reading the config those are unnecessary */
541                 mdata[2] = 0; /* button press type */
542                 mdata[3] = 0; /* callback message type */
543                 mdata[4] = 0; /* callback message option */
544                 mw_send_frame(&mwdata->mwdevice, MW_READ_BUTTON_CONFIG, 0, mdata, 5);
545         }
546         if (strncmp(cmdline, "svib", 4) == 0) {
547                 mw_set_vibrate_mode(&mwdata->mwdevice, 1, 300, 300, 5);
548         }
549         if (strncmp(cmdline, "tbmp", 4) == 0) {
550                 bitmap_test(&mwdata->mwdevice);
551         }
552         if (strncmp(cmdline, "t2bmp", 5) == 0) {
553                 bitmap_test2(&mwdata->mwdevice);
554         }
555         if (strncmp(cmdline, "text", 4) == 0) {
556                 text_test(&mwdata->mwdevice);
557         }
558         if (strncmp(cmdline, "tline", 5) == 0) {
559                 line_test(&mwdata->mwdevice);
560         }
561         if (strncmp(cmdline, "rbmp", 4) == 0) {
562                 bitmap_read(&mwdata->mwdevice);
563         }
564         if (strncmp(cmdline, "tnote", 5) == 0) {
565                 // test_notification(&mwdata->mwdevice);
566                 mw_do_notification(&mwdata->mwdevice, "TestNotification", "This is a pretty long text that needs to be broken and torn", 1);
567         }
568         if (strncmp(cmdline, "tapp", 4) == 0) {
569                 test_application(&mwdata->mwdevice);
570         }
571         if (strncmp(cmdline, "eoled", 5) == 0) {
572                 intopt = cmdline[6]-0x30;
573                 if (intopt == MW_OLED_UPPER || intopt == MW_OLED_LOWER)
574                         mw_send_frame(&mwdata->mwdevice, MW_ENABLE_OLED_DISPLAY_MSG, intopt, NULL, 0);
575         }
576         if (strncmp(cmdline, "toled", 5) == 0) {
577                 intopt = cmdline[6]-0x30;
578                 test_oled(&mwdata->mwdevice, intopt);
579                 //mw_write_oled_buffer(mwdevice, 0, 80, 0, mdata, 10);
580                 //mw_send_frame(mwdevice, MW_UPDATE_OLED_DISPLAY_MSG, 0, NULL, 0);
581         }
582         if (strncmp(cmdline, "cal", 3) == 0) {
583                 draw_idle_calendar(&mwdata->mwdevice);
584         }
585         if (strncmp(cmdline, "wet", 3) == 0) {
586                 do_weather(mwdata);
587         }
588         if (strncmp(cmdline, "c24", 3) == 0) {
589                 mdata[0] = MW_RTC_CLOCK_24HR;
590                 mw_nval_operation(&mwdata->mwdevice, MW_NVAL_OPERATION_WRITE, MW_NVAL_TIME_FORMAT, 1, mdata);
591         }
592         if (strncmp(cmdline, "g24", 3) == 0) {
593                 mdata[0] = 0;
594                 mw_nval_operation(&mwdata->mwdevice, MW_NVAL_OPERATION_READ, MW_NVAL_TIME_FORMAT, 1, mdata);
595         }
596         if (strncmp(cmdline, "sdm", 3) == 0) {
597                 mdata[0] = MW_RTC_DATE_DDMM;
598                 mw_nval_operation(&mwdata->mwdevice, MW_NVAL_OPERATION_WRITE, MW_NVAL_DATE_FORMAT, 1, mdata);
599         }
600         if (strncmp(cmdline, "gdm", 3) == 0) {
601                 mdata[0] = 0;
602                 mw_nval_operation(&mwdata->mwdevice, MW_NVAL_OPERATION_READ, MW_NVAL_TIME_FORMAT, 1, mdata);
603         }
604 }
605
606
607 int feed_menu(mwdata_t *mdata)
608 {
609         int rcvd;
610
611         rcvd = read(0, (mdata->cmdline+mdata->cmdline_pos), 1);
612         if (rcvd > 0) {
613                 if (mdata->cmdline[mdata->cmdline_pos] == '\r') {
614                         printf("\n");
615                         mdata->cmdline[mdata->cmdline_pos--] = '\0';
616                         process_cmd(mdata->cmdline, mdata->cmdline_pos, mdata);
617                         mdata->cmdline_pos = 0;
618                         memset(mdata->cmdline, 0, 128);
619                 } else {
620                         mdata->cmdline_pos++;
621                         if (mdata->cmdline_pos > 75)
622                                 mdata->cmdline_pos = 75;
623                         printf("\r> %s", mdata->cmdline);
624                         fflush(stdout);
625                 }
626         }
627         return 0;
628 }
629
630
631 gboolean handle_mw_io(GIOChannel *mw_io, GIOCondition condition, gpointer udata)
632 {
633         mwdata_t *mdata = (mwdata_t *)udata;
634         int rcvd;
635
636         rcvd = read(mdata->mwdevice.mw_fd, mdata->rcvbuf, 64);
637 #ifdef DEBUG
638         fprintf(stderr, "read %d bytes:\n", rcvd);
639 #endif
640         if (rcvd > 0) {
641 #ifdef DEBUG
642                 dump_frame(mdata->rcvbuf, rcvd);
643 #endif
644                 mw_feed_msg_buffer(&mdata->mwdevice, mdata->rcvbuf, rcvd);
645         }
646
647         return TRUE;
648 }
649
650 gboolean handle_min_io(GIOChannel *mw_io, GIOCondition condition, gpointer udata)
651 {
652         mwdata_t *mdata = (mwdata_t *)udata;
653
654         feed_menu(mdata);
655
656         return TRUE;
657 }
658
659 static DBusHandlerResult
660 signal_filter (DBusConnection *connection, DBusMessage *message, void *user_data)
661 {
662         //GMainLoop *loop = user_data;
663         mwdata_t *mdata = (mwdata_t *)user_data;
664         DBusError error;
665         char *app_name, *app_icon, *summary, *body; // **actions;
666         int replace_id; // dict, expire;
667
668         /* A signal from the bus saying we are about to be disconnected */
669         if (dbus_message_is_signal(message, "org.freedesktop.Local", "Disconnected")) {
670                 /* Tell the main loop to quit */
671                 g_main_loop_quit (mdata->mloop);
672                 /* We have handled this message, don't pass it on */
673                 return DBUS_HANDLER_RESULT_HANDLED;
674         }
675
676         if (dbus_message_is_method_call (message,"org.freedesktop.Notifications", "Notify"))    {
677                 g_print("method call\n");
678                 dbus_error_init (&error);
679                 if (dbus_message_get_args(message, &error,
680                         DBUS_TYPE_STRING, &app_name,
681                         DBUS_TYPE_UINT32, &replace_id,
682                         DBUS_TYPE_STRING, &app_icon,
683                         DBUS_TYPE_STRING, &summary,
684                         DBUS_TYPE_STRING, &body,
685                         /*  G_TYPE_STRV, &actions,
686                         DBUS_TYPE_DICT_ENTRY_AS_STRING, &dict,
687                         DBUS_TYPE_INT32, &expire, */
688                         DBUS_TYPE_INVALID)) {
689                         g_print("Notify received: from app %s, icon %s:\nSummary: %s\nBody: %s\n", app_name, app_icon, summary, body);
690                         mw_send_notify(&mdata->mwdevice, summary, body);
691                         /* we just listen, we do not handle it here */
692                         return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
693                 } else {
694                         g_print("Notify received, but error getting message: %s\n", error.message);
695                         dbus_error_free (&error);
696                 }
697         } else {
698                 g_print("Not signal received\n");
699                 return DBUS_HANDLER_RESULT_HANDLED;
700         };
701
702         return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
703 }
704
705 void mw_button_event_message_cb(mwdevice_t *mwdevice, unsigned char buttons, unsigned char options, void *user_data)
706 {
707         g_print("button event cb:0x%02x 0x%02x\n", buttons, options);
708         g_print("screen is %d\n", mwdevice->screen_mode);
709         if (mwdevice->screen_mode == MW_SCREEN_MODE_IDLE) {
710                 if (buttons == MW_BUTTON_A)
711                         test_application(mwdevice);
712         }
713         if (mwdevice->screen_mode == MW_SCREEN_MODE_APPLICATION) {
714                 if (buttons == MW_BUTTON_C)
715                         mw_update_display(mwdevice, MW_SCREEN_MODE_IDLE, 0);
716         }
717 }
718
719 int main(int argc, char **argv)
720 {
721         int mw_fd;
722         mwdata_t mdata;
723         struct termios tconfd, otconfd, tmwfd;
724         bdaddr_t btaddr;
725         GIOChannel *mw_io, *m_in;
726         DBusConnection *bus;
727         DBusError error;
728
729         if (argc != 2) {
730                 fprintf(stderr, "Usage:\n\t%s <devicename>\n", argv[0]);
731                 return 1;
732         };
733   
734         g_type_init();
735         mdata.mloop = g_main_loop_new (NULL, FALSE);
736
737         crc16ccitt_init();
738
739 #if USE_RFCOMM_FILE
740         mw_fd = open(argv[1], O_RDWR);
741         if (mw_fd < 0) {
742                 perror("open");
743                 return 1;
744         };
745 #else
746         if (str2ba(argv[1], &btaddr))
747                 return 1;
748         mw_fd = open_socket(&btaddr, 1);
749         if (mw_fd < 0) {
750                 return 1;
751         } else {
752                 fprintf(stderr, "connected to %s\n", argv[1]);
753         };
754 #endif
755         /* we have a connection, RFCOMM socket is on mw_fd */
756         /* make the tty raw */
757         tcgetattr(mw_fd, &tmwfd);
758         cfmakeraw(&tmwfd);
759         tmwfd.c_oflag |= ONLCR | OPOST;
760         tmwfd.c_lflag |= ISIG;
761         tcsetattr(mw_fd, TCSANOW, &tmwfd);
762
763         mdata.mwdevice.mw_fd = mw_fd;
764         mdata.rcvbuf_pos = 0;
765         memset(mdata.rcvbuf, 0, 128);
766
767         dbus_error_init (&error);
768         bus = dbus_bus_get (DBUS_BUS_SESSION, &error);
769
770         if (!bus) {
771                 g_warning ("Failed to connect to the D-BUS daemon: %s", error.message);
772                 dbus_error_free (&error);
773                 return 1;
774         }
775
776         dbus_connection_setup_with_g_main (bus, NULL);
777         dbus_bus_add_match (bus, "interface='org.freedesktop.Notifications'", &error);
778
779         dbus_connection_add_filter (bus, signal_filter, &mdata, NULL);
780
781         // menu(mw_fd);
782         mw_io = g_io_channel_unix_new(mw_fd);
783         g_io_add_watch(mw_io, G_IO_IN | G_IO_PRI | G_IO_ERR | G_IO_HUP, handle_mw_io, &mdata);
784
785         tcgetattr(0, &tconfd);
786         tcgetattr(0, &otconfd);
787         cfmakeraw(&tconfd);
788         tconfd.c_oflag |= ONLCR | OPOST;
789         tconfd.c_lflag |= ISIG;
790         tcsetattr(0, TCSANOW, &tconfd);
791
792         mdata.con_fd = 0;
793
794         m_in = g_io_channel_unix_new(0); /* stdin for kbd */
795         g_io_add_watch(m_in, G_IO_IN | G_IO_PRI | G_IO_ERR | G_IO_HUP, handle_min_io, &mdata);
796
797         memset(mdata.cmdline, 0, 128);
798         mdata.cmdline_pos = 0;
799
800         mw_init(&mdata.mwdevice, mw_fd);
801         mw_set_button_event_message_cb(&mdata.mwdevice, mw_button_event_message_cb, NULL);
802
803         g_main_loop_run (mdata.mloop);
804
805         fsync(mw_fd);
806         close(mw_fd);
807
808         /* reset the controlling tty again */
809         tcsetattr(0, TCSANOW, &otconfd);
810
811         return 0;
812 };
813