2017-04-27 18:18:03 +00:00
|
|
|
// SPDX-License-Identifier: GPL-2.0
|
2011-09-20 19:40:34 +00:00
|
|
|
#ifndef LIBDIVECOMPUTER_H
|
|
|
|
|
#define LIBDIVECOMPUTER_H
|
|
|
|
|
|
2013-05-20 19:43:33 +00:00
|
|
|
|
2011-09-20 19:40:34 +00:00
|
|
|
/* libdivecomputer */
|
2015-11-18 21:46:57 +00:00
|
|
|
|
|
|
|
|
#ifdef DC_VERSION /* prevent a warning with wingdi.h */
|
|
|
|
|
#undef DC_VERSION
|
|
|
|
|
#endif
|
2013-05-14 18:50:55 +00:00
|
|
|
#include <libdivecomputer/version.h>
|
2012-07-10 19:33:44 +00:00
|
|
|
#include <libdivecomputer/device.h>
|
|
|
|
|
#include <libdivecomputer/parser.h>
|
2011-09-20 19:40:34 +00:00
|
|
|
|
2018-08-27 17:32:14 +00:00
|
|
|
// Even if we have an old libdivecomputer, Uemis uses this
|
|
|
|
|
#ifndef DC_TRANSPORT_USBSTORAGE
|
|
|
|
|
#define DC_TRANSPORT_USBSTORAGE (1 << 6)
|
2018-08-27 18:19:30 +00:00
|
|
|
#define dc_usb_storage_open(stream, context, devname) (DC_STATUS_UNSUPPORTED)
|
2018-08-27 17:32:14 +00:00
|
|
|
#endif
|
|
|
|
|
|
2013-10-07 19:45:42 +00:00
|
|
|
#include "dive.h"
|
2011-09-20 19:40:34 +00:00
|
|
|
|
2013-10-05 19:11:46 +00:00
|
|
|
#ifdef __cplusplus
|
|
|
|
|
extern "C" {
|
|
|
|
|
#endif
|
|
|
|
|
|
Switch over to SSRF_CUSTOM_IO v2
I hate changing the IO interfaces this often, but when I converted the
custom serial interface to the more generic custom IO interface, I
intentionally left the legacy serial operations alone, because I didn't
want to change something I didn't care about.
But it turns out that leaving them with the old calling convention
caused extra problems when converting the bluetooth serial code to have
the BLE GATT packet fall-back, which requires mixing two kinds of
operations.
Also, the packet_open() routine was passed a copy of the 'dc_context_t',
which makes it possible to update the 'dc_custom_io_t' field on the fly
at open time. That makes a lot of chaining operations much simpler,
since now you can chain the 'custom_io_t' at open time and then
libdivecomputer will automatically call the new routines instead of the
old ones.
That dc_context_t availability gets rid of all the
if (device && device->ops)
return device->ops->serial_xyz(..);
hackery inside the rfcomm routines - now we can just at open time do a simple
dc_context_set_custom_io(context, &ble_serial_ops);
to switch things over to the BLE version of the serial code instead.
Finally, SSRF_CUSTOM_IO v2 added an opaque "dc_user_device_t" pointer
argument to the custom_io descriptor, which gets filled in as the
custom_io is registered with the download context. Note that unlike
most opaque pointers, this one is opaque to *libdivecomputer*, and the
type is supposed to be supplied by the user.
We define the "dc_user_device_t" as our old "struct device_data_t",
making it "struct user_device_t" instead. That means that the IO
routines now get passed the device info showing what device they are
supposed to download for.
That, in turn, means that now our BLE GATT open code can take the device
type it opens for into account if it wants to. And it will want to,
since the rules for Shearwater are different from the rules for Suunto,
for example.
NOTE! Because of the interface change with libdivecomputer, this will
need a flag-day again where libdivecomputer and subsurface are updated
together. It may not be the last time, either.
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2017-06-27 18:59:11 +00:00
|
|
|
typedef struct dc_user_device_t
|
2014-02-28 04:09:57 +00:00
|
|
|
{
|
2012-06-22 20:37:39 +00:00
|
|
|
dc_descriptor_t *descriptor;
|
|
|
|
|
const char *vendor, *product, *devname;
|
2018-10-06 18:23:08 +00:00
|
|
|
const char *model, *btname;
|
use libdivecomputer 'fingerprint' to avoid downloading extra data
This opportunistically uses a cache of 'fingerprints' for already
downloaded dives.
As we download data from a dive computer, we save the fingerprint and
dive ID of the most recent dive in a per-divecopmputer fingerprint cache
file.
The next time we download from that dive computer, we will load the
cache file for that dive computer if it exists, verify that we still
have the dive that is referenced in that cachefile, and if so use the
fingerprint to let libdivecomputer potentially stop downloading dives
early.
This doesn't much matter for most dive computers, but some (like the
Scubapro G2) are not able to download one dive at a time, and need the
fingerprint to avoid doing a full dump. That is particularly noticeable
over bluetooth, where a full dump can be very slow.
NOTE! The fingerprint cache is a separate entity from the dive log
itself. Unlike the dive log, it doesn't synchronize over the cloud, so
if you download using different clients (say, your phone and your
laptop), the fingerprint cache entries are per device.
So you may still end up downloading dives you already have, because the
fingerprint code basically only works to avoid duplicate downloads on
the same installation.
Also, note that we only have a cache of one single entry per dive
computer and downloader, so if you download dives and then don't save
the end result, the fingerprint will now point to a dive that you don't
actually have in your dive list. As a result, next time you download,
the fingerprint won't match any existing dive, and we'll resort to the
old non-optimized behavior.
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2018-04-24 17:37:31 +00:00
|
|
|
unsigned char *fingerprint;
|
|
|
|
|
unsigned int fsize, fdiveid;
|
2014-12-27 16:27:16 +00:00
|
|
|
uint32_t libdc_firmware, libdc_serial;
|
2013-11-22 21:31:52 +00:00
|
|
|
uint32_t deviceid, diveid;
|
2012-06-22 20:37:39 +00:00
|
|
|
dc_device_t *device;
|
2012-08-27 22:06:58 +00:00
|
|
|
dc_context_t *context;
|
2018-04-17 01:14:59 +00:00
|
|
|
dc_iostream_t *iostream;
|
2013-10-05 07:29:09 +00:00
|
|
|
bool force_download;
|
2013-12-25 00:26:00 +00:00
|
|
|
bool libdc_log;
|
|
|
|
|
bool libdc_dump;
|
2015-07-06 13:35:13 +00:00
|
|
|
bool bluetooth_mode;
|
2014-01-07 19:38:36 +00:00
|
|
|
FILE *libdc_logfile;
|
2015-01-09 22:39:43 +00:00
|
|
|
struct dive_table *download_table;
|
2019-02-28 21:45:17 +00:00
|
|
|
struct dive_site_table *sites;
|
2011-09-20 19:40:34 +00:00
|
|
|
} device_data_t;
|
|
|
|
|
|
2015-04-03 19:33:10 +00:00
|
|
|
const char *errmsg (dc_status_t rc);
|
2013-05-20 19:43:33 +00:00
|
|
|
const char *do_libdivecomputer_import(device_data_t *data);
|
2014-10-12 10:57:32 +00:00
|
|
|
const char *do_uemis_import(device_data_t *data);
|
2015-04-03 22:51:38 +00:00
|
|
|
dc_status_t libdc_buffer_parser(struct dive *dive, device_data_t *data, unsigned char *buffer, int size);
|
2015-05-27 19:19:12 +00:00
|
|
|
void logfunc(dc_context_t *context, dc_loglevel_t loglevel, const char *file, unsigned int line, const char *function, const char *msg, void *userdata);
|
2016-12-28 19:55:53 +00:00
|
|
|
dc_descriptor_t *get_descriptor(dc_family_t type, unsigned int model);
|
2011-09-20 19:40:34 +00:00
|
|
|
|
2013-05-20 20:02:17 +00:00
|
|
|
extern int import_thread_cancelled;
|
|
|
|
|
extern const char *progress_bar_text;
|
2017-07-09 19:43:06 +00:00
|
|
|
extern void (*progress_callback)(const char *text);
|
2013-05-20 20:02:17 +00:00
|
|
|
extern double progress_bar_fraction;
|
2013-12-25 00:26:00 +00:00
|
|
|
extern char *logfile_name;
|
|
|
|
|
extern char *dumpfile_name;
|
2015-07-07 18:47:48 +00:00
|
|
|
|
2018-04-17 01:14:59 +00:00
|
|
|
dc_status_t ble_packet_open(dc_iostream_t **iostream, dc_context_t *context, const char* devaddr, void *userdata);
|
|
|
|
|
dc_status_t rfcomm_stream_open(dc_iostream_t **iostream, dc_context_t *context, const char* devaddr);
|
|
|
|
|
dc_status_t ftdi_open(dc_iostream_t **iostream, dc_context_t *context);
|
2013-05-20 20:02:17 +00:00
|
|
|
|
2018-04-17 22:57:04 +00:00
|
|
|
dc_status_t divecomputer_device_open(device_data_t *data);
|
|
|
|
|
|
2018-04-25 22:51:35 +00:00
|
|
|
unsigned int get_supported_transports(device_data_t *data);
|
|
|
|
|
|
2013-05-20 19:43:33 +00:00
|
|
|
#ifdef __cplusplus
|
|
|
|
|
}
|
2011-09-20 19:40:34 +00:00
|
|
|
#endif
|
2013-05-20 19:43:33 +00:00
|
|
|
|
2014-02-11 18:14:46 +00:00
|
|
|
#endif // LIBDIVECOMPUTER_H
|
