subsurface.git/subsurface-core, branch v4.6.4

Move subsurface-core to core and qt-mobile to mobile-widgets

2016-04-05T05:33:58Z

Having subsurface-core as a directory name really messes with autocomplete and is obviously redundant. Simmilarly, qt-mobile caused an autocomplete conflict and also was inconsistent with the desktop-widget name for the directory containing the "other" UI. And while cleaning up the resulting change in the path name for include files, I decided to clean up those even more to make them consistent overall. This could have been handled in more commits, but since this requires a make clean before the build, it seemed more sensible to do it all in one. Signed-off-by: Dirk Hohndel

Don't write back dive data that hasn't changed in git

2016-04-05T00:27:10Z

This caches the git ID for the dive on load, and avoids building the dive directory and hashing it on save as long as nothing has invalidated the git ID cache. That should make it much faster to write back data to the git repository, since the dive tree structure and the divecomputer blobs in particular are the bulk of it (due to all the sample data). It's not actually the git operations that are all that expensive, it's literally generating the big blob with all the snprintf() calls for the data. The git save used to be a fairly expensive with large data sets, especially noticeable on mobile with much weaker CPU's. This should speed things up by at least a factor of two. Signed-off-by: Linus Torvalds Signed-off-by: Dirk Hohndel

Use the same format for output to stderr and AppLog

2016-04-04T21:19:13Z

Signed-off-by: Dirk Hohndel

QML UI: keep cloud sync enabled state in settings

2016-04-04T21:18:51Z

So if the app gets closed and restarted, it will continue to not sync (or sync) over the network. Signed-off-by: Dirk Hohndel

Instrument the git storage code

2016-04-04T21:18:11Z

This allows fairly fine grained analysis on what part of loading from and saving to git we are spending our time. Compute performance and network speed play a significant role in how all this plays out. The routine to check if we can reach the cloud server is modified to send updates every second so we don't hang without any feedback for five seconds when there is network but we can't reach the cloud server (not an unlikely scenario in many dive locations with poor network quality) Signed-off-by: Dirk Hohndel

Change the git progress update callback signature

2016-04-04T21:17:45Z

This way we can include additional text. This will be used in later patches. Signed-off-by: Dirk Hohndel

Git storage: after successful merge push merged commit to upstream

2016-04-04T21:17:30Z

Otherwise a merge will only make it to cloud storage the second time we connect. Signed-off-by: Dirk Hohndel

Fix cylinder end pressure fixup from samples

2016-04-02T01:18:53Z

This bug admittedly hits almost nobody, but if you had multiple cylinder pressure sensors on the same cylinder (attached to multiple dive computers, of course), we would take the beginning pressure from the first dive computer, and the ending pressure from the last dive computer. That came about because we'd just walk all the dive computer samples in order, and the first time we see a relevant sample and we don't have a beginning pressure, we'd take that pressure. So the beginning pressure was from the first dive computer, and once we'd seen a valid beginning pressure, that would never change. But as we're walking along, we'd continue to update the ending pressure from the last relevant sample we see, which means that as we go on to look at the other dive computers, we'd continue to update the ending pressure with data from them. And mixing beginning/ending pressures from two different sensors just does not make sense. This changes the logic to be the same for beginning and ending pressures: we only update it once, with the first relevant sample we see. But we walk the samples twice: forwards from the beginning to find the first beginning pressure, and backwards from the end to find the ending pressure. That means that as we move on to the second dive computer, we've now filled in the ending pressure from the first one, and will no longer update it any more. NOTE! We don't stop scanning the samples (or the dive computers) just because we've found a valid pressure value. We'll always walk all the samples because there might be multiple different cylinders that get pressure data from different samples (and different dive computers). We could have some early-out logic when we've filled in all relevant cylinders, but since this just runs once per dive it's not worth it. Signed-off-by: Linus Torvalds Signed-off-by: Dirk Hohndel

Split up fixup_dive_dc() into multiple smaller independent functions

2016-04-02T01:17:40Z

fixup_dive_dc() is called for each dive computer when we add a new dive. It does various housekeeping functions, cleaning up the sample data, and fixing up dive details as a result of the sample data. The function has grown to be a monster over time, and particularly the central "walk every sample" loop has become an unreadable mess. And the thing is, this isn't even all that performance-critical: it's only done once per dive and dc, and there is no reason to have a single illegible and complex loop. So split up that loop into several smaller pieces that each will loop individually over the sample data, and do just one thing. So now we have separate functions for - fixing up the depth samples with interpolation - fixing up dive temperature data - correcting the cylinder pressure sensor index - cleaning up the actual sample pressures Yes, this way we walk the samples multiple times, but the end result is that the code is much easier to understand. There should be no actual behavioral differences from this cleanup, except for the fact that since the code is much more understandable, this cleanup also fixed a bug: In the temperature fixup, we would fix up the overall dive temperatures based on the dive computer temperatures. But we would then fix up the overall dive computer temperature based on the sample temperature *afterwards*, which wouldn't then be reflected in the overall dive temperatures. There was another non-symptomatic bug that became obvious when doing this cleanup: the code used to calculate a 'depthtime' over the dive that was never actually used. That's a historical artifact of old code that had become dead when the average depth calculations were moved to a function of their own earlier. This is preparatory for fixing the overall cylinder pressure stats, which are currently wrong for dives with multiple dive computers: we currently take the starting cylinder pressure from the *first* dive computer that has cylinder pressure information, but we take the ending cylinder pressure from the *last* dive computer with cylinder pressure information. This does not fix that bug, but without this cleanup fixing that would be a nightmare due to the previous complicated "do everything in one single loop" model. Signed-off-by: Linus Torvalds Signed-off-by: Dirk Hohndel

Be smarter about dive renumbering when merging dives

2016-03-31T01:16:19Z

We really have two different cases for merging dives: (a) downloading a new dive from a dive computer, and merging it with an existing dive that we had already created using a different dive computer. This is the "try_to_merge()" case, called from "process_dives() (b) merging two different dives into one longer dive. This is the "merge_two_dives()" case when you explicitly merge dives using the divelist. While a lot of the issues are the same, many details differ, and one of the details is how dive numbering should be handled. In particular, when you download from a dive computer and merge with an existing dive, you want too take the *maximum* dive number, because the dive computer notion of which dive it is may well not match what the user dive number is. On the other hand, when you explicitly merge in the dive list, you end up renumbering not just the dive you are merging, but also all subsequent dives, since you now have one fewer dives overall. So that case already has to be handled by the caller. Now, the simpler "download from dive computer" case was broken by commit ce3a78efcac2 ("Assign lower number to a merged dive instead of higher one"). It fixed the numbering for the divelist case, but broke the download case. So this commit reverts commit ce3a78efcac2, and instead extends and clarifies the dive renumbering that "merge_two_dives()" already did. It now explicitly renumbers not just the following dives, but also renumbers the merged dive itself, so now we can go back to the old "take the bigger dive number" for the core merging, which fixes the download case. Signed-off-by: Linus Torvalds Signed-off-by: Dirk Hohndel