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,da,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, 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_APPLICATION, MW_BUTTON_A, MW_BUTTON_IMMEDIATE, MW_BUTTON_EVENT_MESSAGE, MW_BUTTON_A);
 400         mw_configure_watch_mode(mwdevice, MW_SCREEN_MODE_APPLICATION, 0, 30, 0);
 401
 402         mwbuf = mw_alloc_pbuffer(96, 96, 1);
 403         mw_buf_clear(mwbuf, MW_BLACK);
 404
 405         mw_buf_print(mwbuf, 0,  0, "  Application   ", 0, MW_BLACK, MW_WHITE);
 406         mw_buf_print(mwbuf, 0,  9, "0123456789012345", 0, MW_WHITE, MW_BLACK);
 407         mw_buf_print(mwbuf, 0, 18, "0123456789g12345", 0, MW_WHITE, MW_BLACK);
 408         mw_buf_print(mwbuf, 0, 27, "0123456789012345", 0, MW_WHITE, MW_BLACK);
 409         mw_buf_print(mwbuf, 0, 36, "0123456789012345", 0, MW_WHITE, MW_BLACK);
 410         mw_buf_print(mwbuf, 0, 45, "0123456789012345", 0, MW_WHITE, MW_BLACK);
 411         mw_buf_print(mwbuf, 0, 54, "0123456789g12345", 0, MW_WHITE, MW_BLACK);
 412         mw_buf_print(mwbuf, 0, 63, "0123456789012345", 0, MW_WHITE, MW_BLACK);
 413         mw_buf_print(mwbuf, 0, 72, "0123456789012345", 0, MW_WHITE, MW_BLACK);
 414         mw_buf_print(mwbuf, 0, 81, "0123456789012345", 0, MW_WHITE, MW_BLACK);
 415
 416         bbuf = mw_make_mw_buffer(mwbuf, &len);
 417         mw_send_bitmap(mwdevice, MW_SCREEN_MODE_APPLICATION, 96, 96, 0, bbuf, len);
 418         mw_update_display(mwdevice, MW_SCREEN_MODE_APPLICATION, 1);
 419         mw_free_pbuffer(mwbuf);
 420 }
 421
 422 void test_oled(mwdevice_t *mwdevice, unsigned char oled)
 423 {
 424         mw_buffer *mwbuf;
 425         unsigned char *bbuf;
 426         int len, i;
 427
 428         mwbuf = mw_alloc_pbuffer(80, 16, 1);
 429         mw_buf_clear(mwbuf, MW_BLACK);
 430
 431         mw_buf_print(mwbuf, 0,  0, "Application", 0, MW_WHITE, MW_BLACK);
 432         mw_buf_print(mwbuf, 0,  8, "012345678901234", 0, MW_WHITE, MW_BLACK);
 433
 434         bbuf = mw_make_mw_oled_buffer(mwbuf, &len);
 435         mw_write_oled_buffer(mwdevice, 0, oled, 80, 0, bbuf, len);
 436
 437         mw_free_pbuffer(mwbuf);
 438 }
 439
 440 static void
 441 weather_soup_callback (SoupSession *session, SoupMessage *msg, gpointer user_data)
 442 {
 443         xmlDocPtr xdoc;
 444
 445         /* Handle the response here */
 446         if (msg->response_body->data != NULL && msg->response_body->length != 0) {
 447                 fprintf(stderr, "%s\n", msg->response_body->data);
 448                 xdoc = xmlReadMemory(msg->response_body->data, msg->response_body->length, "noname.xml", NULL, 0);
 449                 if (xdoc == NULL) {
 450                         fprintf(stderr, "Failed to parse document\n");
 451                         return;
 452                 }
 453                 xmlFreeDoc(xdoc);
 454                 xmlCleanupParser();
 455         }
 456 }
 457
 458 void do_weather(mwdata_t *mwdata)
 459 {
 460         mwdata->msoup = soup_session_async_new();
 461         mwdata->smsg = soup_message_new ("GET", "http://www.google.com/ig/api?weather=siegen&hl=de");
 462         soup_session_send_message (mwdata->msoup, mwdata->smsg);
 463         soup_session_queue_message (mwdata->msoup, mwdata->smsg, weather_soup_callback, mwdata);
 464 }
 465
 466 void print_help(void)
 467 {
 468 }
 469
 470 void process_cmd(char *cmdline, int clinep, mwdata_t *mwdata)
 471 {
 472         unsigned char mdata[32];
 473         unsigned int intopt;
 474
 475         fprintf(stderr, "command: '%s'\n", cmdline);
 476
 477         if (strncmp(cmdline, "quit", 4) == 0) {
 478                 //close(mw_fd);
 479                 //exit(0);
 480                 g_main_loop_quit (mwdata->mloop);
 481         }
 482         if (strncmp(cmdline, "help", 4) == 0) {
 483                 print_help();
 484         }
 485         if (strncmp(cmdline, "ahand", 5) == 0) {
 486                 intopt = atoi(cmdline+5);
 487                 g_print("Advance analog hands by %d minutes\n", intopt);
 488                 mdata[0] = intopt / 60;
 489                 mdata[1] = intopt % 60;
 490                 mdata[2] = 0;
 491                 mw_send_frame(&mwdata->mwdevice, MW_ADVANCE_WATCH_HANDS, 0, mdata, 3);
 492         }
 493         if (strncmp(cmdline, "srtc", 4) == 0) {
 494                 fprintf(stderr, "Setting RTC from system time...");
 495                 mw_set_rtc(&mwdata->mwdevice, MW_RTC_CLOCK_24HR, MW_RTC_DATE_DDMM);
 496                 fprintf(stderr, "OK\n");
 497         }
 498         if (strncmp(cmdline, "grtc", 4) == 0) {
 499                 mw_send_frame(&mwdata->mwdevice, MW_GET_REAL_TIME_CLOCK, 0, NULL, 0);
 500         }
 501         if (strncmp(cmdline, "gistr", 5) == 0) {
 502                 intopt = cmdline[6]-0x30;
 503                 if (intopt>=0 && intopt <=3)
 504                         mdata[0] = intopt;
 505                 else
 506                         mdata[0] = 0;
 507                 mw_send_frame(&mwdata->mwdevice, MW_GET_INFORMATION_STRING, 0, mdata, 1);
 508         }
 509         if (strncmp(cmdline, "gdtype", 6) == 0) {
 510                 mw_send_frame(&mwdata->mwdevice, MW_GET_DEVICE_TYPE, 0, NULL, 0);
 511         }
 512         if (strncmp(cmdline, "rvbat", 5) == 0) {
 513                 mw_send_frame(&mwdata->mwdevice, MW_READ_BATTERY_VOLTAGE_MSG, 0, NULL, 0);
 514         }
 515         if (strncmp(cmdline, "rlight", 6) == 0) {
 516                 mw_send_frame(&mwdata->mwdevice, MW_READ_LIGHT_SENSOR_MSG, 0, NULL, 0);
 517         }
 518         if (strncmp(cmdline, "modecfg", 6) == 0) {
 519                 mw_configure_watch_mode(&mwdata->mwdevice, MW_SCREEN_MODE_IDLE, 0, 4, 1);
 520                 mw_update_display(&mwdata->mwdevice, MW_SCREEN_MODE_IDLE, 0);
 521         }
 522         if (strncmp(cmdline, "rbtcfg", 6) == 0) {
 523                 intopt = cmdline[7]-0x30;
 524                 mdata[0] = 0; /* idle screen */
 525                 mdata[1] = intopt; /* button index */
 526                 /* for reading the config those are unnecessary */
 527                 mdata[2] = 0; /* button press type */
 528                 mdata[3] = 0; /* callback message type */
 529                 mdata[4] = 0; /* callback message option */
 530                 mw_send_frame(&mwdata->mwdevice, MW_READ_BUTTON_CONFIG, 0, mdata, 5);
 531         }
 532         if (strncmp(cmdline, "svib", 4) == 0) {
 533                 mw_set_vibrate_mode(&mwdata->mwdevice, 1, 300, 300, 5);
 534         }
 535         if (strncmp(cmdline, "tbmp", 4) == 0) {
 536                 bitmap_test(&mwdata->mwdevice);
 537         }
 538         if (strncmp(cmdline, "t2bmp", 5) == 0) {
 539                 bitmap_test2(&mwdata->mwdevice);
 540         }
 541         if (strncmp(cmdline, "text", 4) == 0) {
 542                 text_test(&mwdata->mwdevice);
 543         }
 544         if (strncmp(cmdline, "tline", 5) == 0) {
 545                 line_test(&mwdata->mwdevice);
 546         }
 547         if (strncmp(cmdline, "rbmp", 4) == 0) {
 548                 bitmap_read(&mwdata->mwdevice);
 549         }
 550         if (strncmp(cmdline, "tnote", 5) == 0) {
 551                 // test_notification(&mwdata->mwdevice);
 552                 mw_do_notification(&mwdata->mwdevice, "TestNotification", "This is a pretty long text that needs to be broken and torn", 1);
 553         }
 554         if (strncmp(cmdline, "tapp", 4) == 0) {
 555                 test_application(&mwdata->mwdevice);
 556         }
 557         if (strncmp(cmdline, "eoled", 5) == 0) {
 558                 intopt = cmdline[6]-0x30;
 559                 if (intopt == MW_OLED_UPPER || intopt == MW_OLED_LOWER)
 560                         mw_send_frame(&mwdata->mwdevice, MW_ENABLE_OLED_DISPLAY_MSG, intopt, NULL, 0);
 561         }
 562         if (strncmp(cmdline, "toled", 5) == 0) {
 563                 intopt = cmdline[6]-0x30;
 564                 test_oled(&mwdata->mwdevice, intopt);
 565                 //mw_write_oled_buffer(mwdevice, 0, 80, 0, mdata, 10);
 566                 //mw_send_frame(mwdevice, MW_UPDATE_OLED_DISPLAY_MSG, 0, NULL, 0);
 567         }
 568         if (strncmp(cmdline, "cal", 3) == 0) {
 569                 draw_idle_calendar(&mwdata->mwdevice);
 570         }
 571         if (strncmp(cmdline, "wet", 3) == 0) {
 572                 do_weather(mwdata);
 573         }
 574         if (strncmp(cmdline, "c24", 3) == 0) {
 575                 mdata[0] = MW_RTC_CLOCK_24HR;
 576                 mw_nval_operation(&mwdata->mwdevice, MW_NVAL_OPERATION_WRITE, MW_NVAL_TIME_FORMAT, 1, mdata);
 577         }
 578         if (strncmp(cmdline, "g24", 3) == 0) {
 579                 mdata[0] = 0;
 580                 mdata[1] = 0;
 581                 mw_nval_operation(&mwdata->mwdevice, MW_NVAL_OPERATION_READ, MW_NVAL_TIME_FORMAT, 2, mdata);
 582         }
 583 }
 584
 585
 586 int feed_menu(mwdata_t *mdata)
 587 {
 588         int rcvd;
 589
 590         rcvd = read(0, (mdata->cmdline+mdata->cmdline_pos), 1);
 591         if (rcvd > 0) {
 592                 if (mdata->cmdline[mdata->cmdline_pos] == '\r') {
 593                         printf("\n");
 594                         mdata->cmdline[mdata->cmdline_pos--] = '\0';
 595                         process_cmd(mdata->cmdline, mdata->cmdline_pos, mdata);
 596                         mdata->cmdline_pos = 0;
 597                         memset(mdata->cmdline, 0, 128);
 598                 } else {
 599                         mdata->cmdline_pos++;
 600                         if (mdata->cmdline_pos > 75)
 601                                 mdata->cmdline_pos = 75;
 602                         printf("\r> %s", mdata->cmdline);
 603                         fflush(stdout);
 604                 }
 605         }
 606         return 0;
 607 }
 608
 609
 610 gboolean handle_mw_io(GIOChannel *mw_io, GIOCondition condition, gpointer udata)
 611 {
 612         mwdata_t *mdata = (mwdata_t *)udata;
 613         int rcvd;
 614
 615         rcvd = read(mdata->mwdevice.mw_fd, mdata->rcvbuf, 64);
 616 #ifdef DEBUG
 617         fprintf(stderr, "read %d bytes:\n", rcvd);
 618 #endif
 619         if (rcvd > 0) {
 620 #ifdef DEBUG
 621                 dump_frame(mdata->rcvbuf, rcvd);
 622 #endif
 623                 mw_feed_msg_buffer(&mdata->mwdevice, mdata->rcvbuf, rcvd);
 624         }
 625
 626         return TRUE;
 627 }
 628
 629 gboolean handle_min_io(GIOChannel *mw_io, GIOCondition condition, gpointer udata)
 630 {
 631         mwdata_t *mdata = (mwdata_t *)udata;
 632
 633         feed_menu(mdata);
 634
 635         return TRUE;
 636 }
 637
 638 static DBusHandlerResult
 639 signal_filter (DBusConnection *connection, DBusMessage *message, void *user_data)
 640 {
 641         //GMainLoop *loop = user_data;
 642         mwdata_t *mdata = (mwdata_t *)user_data;
 643         DBusError error;
 644         char *app_name, *app_icon, *summary, *body; // **actions;
 645         int replace_id; // dict, expire;
 646
 647         /* A signal from the bus saying we are about to be disconnected */
 648         if (dbus_message_is_signal(message, "org.freedesktop.Local", "Disconnected")) {
 649                 /* Tell the main loop to quit */
 650                 g_main_loop_quit (mdata->mloop);
 651                 /* We have handled this message, don't pass it on */
 652                 return DBUS_HANDLER_RESULT_HANDLED;
 653         }
 654
 655         if (dbus_message_is_method_call (message,"org.freedesktop.Notifications", "Notify"))    {
 656                 g_print("method call\n");
 657                 dbus_error_init (&error);
 658                 if (dbus_message_get_args(message, &error,
 659                         DBUS_TYPE_STRING, &app_name,
 660                         DBUS_TYPE_UINT32, &replace_id,
 661                         DBUS_TYPE_STRING, &app_icon,
 662                         DBUS_TYPE_STRING, &summary,
 663                         DBUS_TYPE_STRING, &body,
 664                         /*  G_TYPE_STRV, &actions,
 665                         DBUS_TYPE_DICT_ENTRY_AS_STRING, &dict,
 666                         DBUS_TYPE_INT32, &expire, */
 667                         DBUS_TYPE_INVALID)) {
 668                         g_print("Notify received: from app %s, icon %s:\nSummary: %s\nBody: %s\n", app_name, app_icon, summary, body);
 669                         mw_send_notify(&mdata->mwdevice, summary, body);
 670                         /* we just listen, we do not handle it here */
 671                         return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 672                 } else {
 673                         g_print("Notify received, but error getting message: %s\n", error.message);
 674                         dbus_error_free (&error);
 675                 }
 676         } else {
 677                 g_print("Not signal received\n");
 678                 return DBUS_HANDLER_RESULT_HANDLED;
 679         };
 680
 681         return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 682 }
 683
 684 int main(int argc, char **argv)
 685 {
 686         int mw_fd;
 687         mwdata_t mdata;
 688         struct termios tconfd, otconfd, tmwfd;
 689         bdaddr_t btaddr;
 690         GIOChannel *mw_io, *m_in;
 691         DBusConnection *bus;
 692         DBusError error;
 693
 694         if (argc != 2) {
 695                 fprintf(stderr, "Usage:\n\t%s <devicename>\n", argv[0]);
 696                 return 1;
 697         };
 698
 699         g_type_init();
 700         mdata.mloop = g_main_loop_new (NULL, FALSE);
 701
 702         crc16ccitt_init();
 703
 704 #if USE_RFCOMM_FILE
 705         mw_fd = open(argv[1], O_RDWR);
 706         if (mw_fd < 0) {
 707                 perror("open");
 708                 return 1;
 709         };
 710 #else
 711         if (str2ba(argv[1], &btaddr))
 712                 return 1;
 713         mw_fd = open_socket(&btaddr, 1);
 714         if (mw_fd < 0) {
 715                 return 1;
 716         } else {
 717                 fprintf(stderr, "connected to %s\n", argv[1]);
 718         };
 719 #endif
 720         /* we have a connection, RFCOMM socket is on mw_fd */
 721         /* make the tty raw */
 722         tcgetattr(mw_fd, &tmwfd);
 723         cfmakeraw(&tmwfd);
 724         tmwfd.c_oflag |= ONLCR | OPOST;
 725         tmwfd.c_lflag |= ISIG;
 726         tcsetattr(mw_fd, TCSANOW, &tmwfd);
 727
 728         mdata.mwdevice.mw_fd = mw_fd;
 729         mdata.rcvbuf_pos = 0;
 730         memset(mdata.rcvbuf, 0, 128);
 731
 732         dbus_error_init (&error);
 733         bus = dbus_bus_get (DBUS_BUS_SESSION, &error);
 734
 735         if (!bus) {
 736                 g_warning ("Failed to connect to the D-BUS daemon: %s", error.message);
 737                 dbus_error_free (&error);
 738                 return 1;
 739         }
 740
 741         dbus_connection_setup_with_g_main (bus, NULL);
 742         dbus_bus_add_match (bus, "interface='org.freedesktop.Notifications'", &error);
 743
 744         dbus_connection_add_filter (bus, signal_filter, &mdata, NULL);
 745
 746         // menu(mw_fd);
 747         mw_io = g_io_channel_unix_new(mw_fd);
 748         g_io_add_watch(mw_io, G_IO_IN | G_IO_PRI | G_IO_ERR | G_IO_HUP, handle_mw_io, &mdata);
 749
 750         tcgetattr(0, &tconfd);
 751         tcgetattr(0, &otconfd);
 752         cfmakeraw(&tconfd);
 753         tconfd.c_oflag |= ONLCR | OPOST;
 754         tconfd.c_lflag |= ISIG;
 755         tcsetattr(0, TCSANOW, &tconfd);
 756
 757         mdata.con_fd = 0;
 758
 759         m_in = g_io_channel_unix_new(0); /* stdin for kbd */
 760         g_io_add_watch(m_in, G_IO_IN | G_IO_PRI | G_IO_ERR | G_IO_HUP, handle_min_io, &mdata);
 761
 762         memset(mdata.cmdline, 0, 128);
 763         mdata.cmdline_pos = 0;
 764
 765         mw_init(&mdata.mwdevice, mw_fd);
 766
 767         g_main_loop_run (mdata.mloop);
 768
 769         fsync(mw_fd);
 770         close(mw_fd);
 771
 772         /* reset the controlling tty again */
 773         tcsetattr(0, TCSANOW, &otconfd);
 774
 775         return 0;
 776 };
 777