mw_main.c

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