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