libdivecomputer.c

   1 #include <stdio.h>
   2 #include <gtk/gtk.h>
   3
   4 #include "dive.h"
   5 #include "display.h"
   6
   7 /* libdivecomputer */
   8 #include <device.h>
   9 #include <suunto.h>
  10 #include <reefnet.h>
  11 #include <uwatec.h>
  12 #include <oceanic.h>
  13 #include <mares.h>
  14 #include <hw.h>
  15 #include <cressi.h>
  16 #include <zeagle.h>
  17 #include <atomics.h>
  18 #include <utils.h>
  19
  20 static void error(const char *fmt, ...)
  21 {
  22         va_list args;
  23         GError *error;
  24
  25         va_start(args, fmt);
  26         error = g_error_new_valist(
  27                 g_quark_from_string("divelog"),
  28                 DIVE_ERROR_PARSE, fmt, args);
  29         va_end(args);
  30         report_error(error);
  31         g_error_free(error);
  32 }
  33
  34 typedef struct device_data_t {
  35         device_type_t type;
  36         const char *name;
  37         device_devinfo_t devinfo;
  38         device_clock_t clock;
  39 } device_data_t;
  40
  41 static parser_status_t create_parser(device_data_t *devdata, parser_t **parser)
  42 {
  43         switch (devdata->type) {
  44         case DEVICE_TYPE_SUUNTO_SOLUTION:
  45                 return suunto_solution_parser_create(parser);
  46
  47         case DEVICE_TYPE_SUUNTO_EON:
  48                 return suunto_eon_parser_create(parser, 0);
  49
  50         case DEVICE_TYPE_SUUNTO_VYPER:
  51                 if (devdata->devinfo.model == 0x01)
  52                         return suunto_eon_parser_create(parser, 1);
  53                 return suunto_vyper_parser_create(parser);
  54
  55         case DEVICE_TYPE_SUUNTO_VYPER2:
  56         case DEVICE_TYPE_SUUNTO_D9:
  57                 return suunto_d9_parser_create(parser, devdata->devinfo.model);
  58
  59         case DEVICE_TYPE_UWATEC_ALADIN:
  60         case DEVICE_TYPE_UWATEC_MEMOMOUSE:
  61                 return uwatec_memomouse_parser_create(parser, devdata->clock.devtime, devdata->clock.systime);
  62
  63         case DEVICE_TYPE_UWATEC_SMART:
  64                 return uwatec_smart_parser_create(parser, devdata->devinfo.model, devdata->clock.devtime, devdata->clock.systime);
  65
  66         case DEVICE_TYPE_REEFNET_SENSUS:
  67                 return reefnet_sensus_parser_create(parser, devdata->clock.devtime, devdata->clock.systime);
  68
  69         case DEVICE_TYPE_REEFNET_SENSUSPRO:
  70                 return reefnet_sensuspro_parser_create(parser, devdata->clock.devtime, devdata->clock.systime);
  71
  72         case DEVICE_TYPE_REEFNET_SENSUSULTRA:
  73                 return reefnet_sensusultra_parser_create(parser, devdata->clock.devtime, devdata->clock.systime);
  74
  75         case DEVICE_TYPE_OCEANIC_VTPRO:
  76                 return oceanic_vtpro_parser_create(parser);
  77
  78         case DEVICE_TYPE_OCEANIC_VEO250:
  79                 return oceanic_veo250_parser_create(parser, devdata->devinfo.model);
  80
  81         case DEVICE_TYPE_OCEANIC_ATOM2:
  82                 return oceanic_atom2_parser_create(parser, devdata->devinfo.model);
  83
  84         case DEVICE_TYPE_MARES_NEMO:
  85         case DEVICE_TYPE_MARES_PUCK:
  86                 return mares_nemo_parser_create(parser, devdata->devinfo.model);
  87
  88         case DEVICE_TYPE_MARES_ICONHD:
  89                 return mares_iconhd_parser_create(parser);
  90
  91         case DEVICE_TYPE_HW_OSTC:
  92                 return hw_ostc_parser_create(parser);
  93
  94         case DEVICE_TYPE_CRESSI_EDY:
  95         case DEVICE_TYPE_ZEAGLE_N2ITION3:
  96                 return cressi_edy_parser_create(parser, devdata->devinfo.model);
  97
  98         case DEVICE_TYPE_ATOMICS_COBALT:
  99                 return atomics_cobalt_parser_create(parser);
 100
 101         default:
 102                 return PARSER_STATUS_ERROR;
 103         }
 104 }
 105
 106 static int dive_cb(const unsigned char *data, unsigned int size,
 107         const unsigned char *fingerprint, unsigned int fsize,
 108         void *userdata)
 109 {
 110         int rc;
 111         parser_t *parser = NULL;
 112         device_data_t *devdata = userdata;
 113         dc_datetime_t dt = {0};
 114
 115         rc = create_parser(devdata, &parser);
 116         if (rc != PARSER_STATUS_SUCCESS) {
 117                 error("Unable to create parser for %s", devdata->name);
 118                 return rc;
 119         }
 120
 121         rc = parser_set_data(parser, data, size);
 122         if (rc != PARSER_STATUS_SUCCESS) {
 123                 error("Error registering the data.");
 124                 parser_destroy(parser);
 125                 return rc;
 126         }
 127
 128         rc = parser_get_datetime(parser, &dt);
 129         if (rc != PARSER_STATUS_SUCCESS && rc != PARSER_STATUS_UNSUPPORTED) {
 130                 error("Error parsing the datetime.");
 131                 parser_destroy (parser);
 132                 return rc;
 133         }
 134
 135         printf("<datetime>%04i-%02i-%02i %02i:%02i:%02i</datetime>\n",
 136                 dt.year, dt.month, dt.day,
 137                 dt.hour, dt.minute, dt.second);
 138
 139         parser_destroy(parser);
 140         return PARSER_STATUS_SUCCESS;
 141 }
 142
 143
 144 static device_status_t import_device_data(device_t *device, device_data_t *devicedata)
 145 {
 146         return device_foreach(device, dive_cb, devicedata);
 147 }
 148
 149 static device_status_t device_open(const char *devname,
 150         device_type_t type,
 151         device_t **device)
 152 {
 153         switch (type) {
 154         case DEVICE_TYPE_SUUNTO_SOLUTION:
 155                 return suunto_solution_device_open(device, devname);
 156
 157         case DEVICE_TYPE_SUUNTO_EON:
 158                 return suunto_eon_device_open(device, devname);
 159
 160         case DEVICE_TYPE_SUUNTO_VYPER:
 161                 return suunto_vyper_device_open(device, devname);
 162
 163         case DEVICE_TYPE_SUUNTO_VYPER2:
 164                 return suunto_vyper2_device_open(device, devname);
 165
 166         case DEVICE_TYPE_SUUNTO_D9:
 167                 return suunto_d9_device_open(device, devname);
 168
 169         case DEVICE_TYPE_UWATEC_ALADIN:
 170                 return uwatec_aladin_device_open(device, devname);
 171
 172         case DEVICE_TYPE_UWATEC_MEMOMOUSE:
 173                 return uwatec_memomouse_device_open(device, devname);
 174
 175         case DEVICE_TYPE_UWATEC_SMART:
 176                 return uwatec_smart_device_open(device);
 177
 178         case DEVICE_TYPE_REEFNET_SENSUS:
 179                 return reefnet_sensus_device_open(device, devname);
 180
 181         case DEVICE_TYPE_REEFNET_SENSUSPRO:
 182                 return reefnet_sensuspro_device_open(device, devname);
 183
 184         case DEVICE_TYPE_REEFNET_SENSUSULTRA:
 185                 return reefnet_sensusultra_device_open(device, devname);
 186
 187         case DEVICE_TYPE_OCEANIC_VTPRO:
 188                 return oceanic_vtpro_device_open(device, devname);
 189
 190         case DEVICE_TYPE_OCEANIC_VEO250:
 191                 return oceanic_veo250_device_open(device, devname);
 192
 193         case DEVICE_TYPE_OCEANIC_ATOM2:
 194                 return oceanic_atom2_device_open(device, devname);
 195
 196         case DEVICE_TYPE_MARES_NEMO:
 197                 return mares_nemo_device_open(device, devname);
 198
 199         case DEVICE_TYPE_MARES_PUCK:
 200                 return mares_puck_device_open(device, devname);
 201
 202         case DEVICE_TYPE_MARES_ICONHD:
 203                 return mares_iconhd_device_open(device, devname);
 204
 205         case DEVICE_TYPE_HW_OSTC:
 206                 return hw_ostc_device_open(device, devname);
 207
 208         case DEVICE_TYPE_CRESSI_EDY:
 209                 return cressi_edy_device_open(device, devname);
 210
 211         case DEVICE_TYPE_ZEAGLE_N2ITION3:
 212                 return zeagle_n2ition3_device_open(device, devname);
 213
 214         case DEVICE_TYPE_ATOMICS_COBALT:
 215                 return atomics_cobalt_device_open(device);
 216
 217         default:
 218                 return DEVICE_STATUS_ERROR;
 219         }
 220 }
 221
 222 static void
 223 event_cb (device_t *device, device_event_t event, const void *data, void *userdata)
 224 {
 225 }
 226
 227 static int
 228 cancel_cb (void *userdata)
 229 {
 230         return 0;
 231 }
 232
 233 static void do_import(const char *computer, device_type_t type)
 234 {
 235         /* FIXME! Needs user input! */
 236         const char *devname = "/dev/ttyUSB0";
 237         device_t *device = NULL;
 238         device_status_t rc;
 239         device_data_t devicedata = {
 240                 .type = type,
 241                 .name = computer,
 242         };
 243
 244         rc = device_open(devname, type, &device);
 245         if (rc != DEVICE_STATUS_SUCCESS) {
 246                 error("Unable to open %s (%s)", computer, devname);
 247                 return;
 248         }
 249
 250         // Register the event handler.
 251         int events = DEVICE_EVENT_WAITING | DEVICE_EVENT_PROGRESS | DEVICE_EVENT_DEVINFO | DEVICE_EVENT_CLOCK;
 252         rc = device_set_events(device, events, event_cb, &devicedata);
 253         if (rc != DEVICE_STATUS_SUCCESS) {
 254                 error("Error registering the event handler.");
 255                 device_close(device);
 256                 return;
 257         }
 258
 259         // Register the cancellation handler.
 260         rc = device_set_cancel(device, cancel_cb, &devicedata);
 261         if (rc != DEVICE_STATUS_SUCCESS) {
 262                 error("Error registering the cancellation handler.");
 263                 device_close(device);
 264                 return;
 265         }
 266
 267         rc = import_device_data(device, &devicedata);
 268         if (rc != DEVICE_STATUS_SUCCESS) {
 269                 error("Dive data import error");
 270                 device_close(device);
 271                 return;
 272         }
 273
 274         device_close(device);
 275 }
 276
 277 /*
 278  * Taken from 'example.c' in libdivecomputer.
 279  *
 280  * I really wish there was some way to just have
 281  * libdivecomputer tell us what devices it supports,
 282  * rather than have the application have to know..
 283  */
 284 struct device_list {
 285         const char *name;
 286         device_type_t type;
 287 } device_list[] = {
 288         { "Suunto Solution",    DEVICE_TYPE_SUUNTO_SOLUTION },
 289         { "Suunto Eon",         DEVICE_TYPE_SUUNTO_EON },
 290         { "Suunto Vyper",       DEVICE_TYPE_SUUNTO_VYPER },
 291         { "Suunto Vyper Air",   DEVICE_TYPE_SUUNTO_VYPER2 },
 292         { "Suunto D9",          DEVICE_TYPE_SUUNTO_D9 },
 293         { "Uwatec Aladin",      DEVICE_TYPE_UWATEC_ALADIN },
 294         { "Uwatec Memo Mouse",  DEVICE_TYPE_UWATEC_MEMOMOUSE },
 295         { "Uwatec Smart",       DEVICE_TYPE_UWATEC_SMART },
 296         { "ReefNet Sensus",     DEVICE_TYPE_REEFNET_SENSUS },
 297         { "ReefNet Sensus Pro", DEVICE_TYPE_REEFNET_SENSUSPRO },
 298         { "ReefNet Sensus Ultra",DEVICE_TYPE_REEFNET_SENSUSULTRA },
 299         { "Oceanic VT Pro",     DEVICE_TYPE_OCEANIC_VTPRO },
 300         { "Oceanic Veo250",     DEVICE_TYPE_OCEANIC_VEO250 },
 301         { "Oceanic Atom 2",     DEVICE_TYPE_OCEANIC_ATOM2 },
 302         { "Mares Nemo",         DEVICE_TYPE_MARES_NEMO },
 303         { "Mares Puck",         DEVICE_TYPE_MARES_PUCK },
 304         { "Mares Icon HD",      DEVICE_TYPE_MARES_ICONHD },
 305         { "OSTC",               DEVICE_TYPE_HW_OSTC },
 306         { "Cressi Edy",         DEVICE_TYPE_CRESSI_EDY },
 307         { "Zeagle N2iTiON 3",   DEVICE_TYPE_ZEAGLE_N2ITION3 },
 308         { "Atomics Cobalt",     DEVICE_TYPE_ATOMICS_COBALT },
 309         { NULL }
 310 };
 311
 312 static void fill_computer_list(GtkListStore *store)
 313 {
 314         GtkTreeIter iter;
 315         struct device_list *list = device_list;
 316
 317         for (list = device_list ; list->name ; list++) {
 318                 gtk_list_store_append(store, &iter);
 319                 gtk_list_store_set(store, &iter,
 320                         0, list->name,
 321                         1, list->type,
 322                         -1);
 323         }
 324 }
 325
 326 static GtkComboBox *dive_computer_selector(GtkWidget *dialog)
 327 {
 328         GtkWidget *hbox, *combo_box;
 329         GtkListStore *model;
 330         GtkCellRenderer *renderer;
 331
 332         hbox = gtk_hbox_new(FALSE, 6);
 333         gtk_container_add(GTK_CONTAINER(GTK_DIALOG(dialog)->vbox), hbox);
 334
 335         model = gtk_list_store_new(2, G_TYPE_STRING, G_TYPE_INT);
 336         fill_computer_list(model);
 337
 338         combo_box = gtk_combo_box_new_with_model(GTK_TREE_MODEL(model));
 339         gtk_box_pack_start(GTK_BOX(hbox), combo_box, FALSE, TRUE, 3);
 340
 341         renderer = gtk_cell_renderer_text_new();
 342         gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(combo_box), renderer, TRUE);
 343         gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(combo_box), renderer, "text", 0, NULL);
 344
 345         return GTK_COMBO_BOX(combo_box);
 346 }
 347
 348 void import_dialog(GtkWidget *w, gpointer data)
 349 {
 350         int result;
 351         GtkWidget *dialog;
 352         GtkComboBox *computer;
 353
 354         dialog = gtk_dialog_new_with_buttons("Import from dive computer",
 355                 GTK_WINDOW(main_window),
 356                 GTK_DIALOG_DESTROY_WITH_PARENT,
 357                 GTK_STOCK_OK, GTK_RESPONSE_ACCEPT,
 358                 GTK_STOCK_CANCEL, GTK_RESPONSE_REJECT,
 359                 NULL);
 360
 361         computer = dive_computer_selector(dialog);
 362
 363         gtk_widget_show_all(dialog);
 364         result = gtk_dialog_run(GTK_DIALOG(dialog));
 365         switch (result) {
 366                 int type;
 367                 GtkTreeIter iter;
 368                 GtkTreeModel *model;
 369                 const char *comp;
 370         case GTK_RESPONSE_ACCEPT:
 371                 if (!gtk_combo_box_get_active_iter(computer, &iter))
 372                         break;
 373                 model = gtk_combo_box_get_model(computer);
 374                 gtk_tree_model_get(model, &iter,
 375                         0, &comp,
 376                         1, &type,
 377                         -1);
 378                 do_import(comp, type);
 379                 break;
 380         default:
 381                 break;
 382         }
 383         gtk_widget_destroy(dialog);
 384 }
 385