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
|
|
|
|
|
|
2019-08-05 17:41:15 +00:00
|
|
|
#include <stdint.h>
|
2019-08-09 00:38:47 +00:00
|
|
|
#include <stdio.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-05 19:11:46 +00:00
|
|
|
#ifdef __cplusplus
|
|
|
|
|
extern "C" {
|
2019-08-05 17:41:15 +00:00
|
|
|
#else
|
|
|
|
|
#include <stdbool.h>
|
2013-10-05 19:11:46 +00:00
|
|
|
#endif
|
|
|
|
|
|
2019-08-05 17:41:15 +00:00
|
|
|
struct dive;
|
2022-11-12 11:44:29 +00:00
|
|
|
struct divelog;
|
2019-08-05 17:41:15 +00:00
|
|
|
struct dive_computer;
|
2020-10-19 17:19:32 +00:00
|
|
|
struct devices;
|
2019-08-05 17:41:15 +00:00
|
|
|
|
2020-10-19 16:42:43 +00:00
|
|
|
typedef struct {
|
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;
|
Re-do the libdivecomputer fingerprint save/load code
This tries to make our fingerprinting code work better, by avoiding
using the "deviceid" field that has always been unreliable because we've
calculated it multiple different ways, and even for the same version of
subsurface, it ends up changing in the middle (ie we calculate one value
initially, then re-calculate it when we have a proper serial number
string).
So instead, the fingerprinting code will look up and save the
fingerprint file using purely "stable" information that is available
early during the download:
- the device model name (which is a string with vendor and product name
separated by a space)
- the DC_EVENT_DEVINFO 32-bit 'serial' number (which is not necessarily
a real serial number at all, but hopefully at least a unique number
for the particular product)
but because the model name is not necessarily a good filename (think
slashes and other possibly invalid characters), we hash that model name
and use the resulting hex number in the fingerprint file name.
This way the fingerprint file is unambiguous at load and save time, and
depends purely on libdivecomputer data.
But because we also need to verify that we have the actual _dive_
associated with that fingerprint, we also need to save the final
deviceid and diveid when saving the fingerprint file, so that when we
load it again we can look up the dive and verify that we have it before
we use the fingerprint data.
To do that, the fingerprint file itself contains not just the
fingerprint data from libdivecomputer, but the last 8 bytes of the file
are the (subsurface) deviceid and the diveid of the dive that is
associated with the fingerprint.
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2021-09-19 01:52:50 +00:00
|
|
|
unsigned int fsize, fdeviceid, fdiveid;
|
|
|
|
|
struct dc_event_devinfo_t devinfo;
|
|
|
|
|
uint32_t 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;
|
2022-11-12 11:44:29 +00:00
|
|
|
struct divelog *log;
|
2020-03-15 01:11:46 +00:00
|
|
|
void *androidUsbDeviceDescriptor;
|
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);
|
2020-03-15 01:11:46 +00:00
|
|
|
dc_status_t serial_usb_android_open(dc_iostream_t **iostream, dc_context_t *context, void *androidUsbDevice);
|
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
|
