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_w(mwbuf, x, y, x2, y2, 2, 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_w(mwbuf, 48, 48, x, y, 2, 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_w(mwbuf, 48, 48, x, y, 2, 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, day of month\ndana h m d\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