Acknowledged
2 months ago

Given that a newer SDK is required to build for CIQ 5.x devices, what does this mean for existing apps on devices that were upgraded from CIQ 4 to CIQ 5 (e.g. FR955, Fenix 7, etc)? Do these apps just break?

Background:

- it has always by my understanding that if you build an app for a device with a given SDK, then that app should continue to work regardless of future firmware updates (in general). This ofc excludes situations where:

  - the new firmware update has a bug or breaking change

  - the existing app has a dormant bug which is exposed by a legit change in new firmware. e.g. newer firmware has a change where Weather.CurrentConditions.observationLocationName is null, and this caused several existing watchfaces to crash because they assume that field will never be null. But that's an application error, since that field has always been typed to be possibly null

- CIQ 5.* devices require various 7.X (or 8.X) SDKs to run properly

- Compilers have a check to ensure you don't try to build a a too-new device with a too-old device

- Due to a bug in this check, where older compilers (pre 7.2.0) seem to incorrectly believe that SDK version X can build any device with CIQ version X (or lower), it's possible for an SDK 6.X compiler to build an app for CIQ 5 devices. However, it's very possible that such an app will crash when it's run in the simulator or the device (we've already seen "bug reports" about this

- The existing crop of devices that came out with CIQ 4 (e.g. fr955, fr965, fenix7) have all been updated to CIQ 5. As far as I know, this is the first time that existing devices have received a major CIQ update since the move from CIQ 1 to CIQ 2.

- Someone in the CIQ team already clarified that CIQ 5 devices require apps to be built with newer SDKs.

So here's what I don't understand.

The two following statements seem to be mutually exclusive:

- If an app is built for a device with an existing SDK (e.g. SDK 6.4.0) it will continue (in general) to work on the device for all future firmware updates

- Devices with CIQ 5.* require a 7.X or 8.X SDK

The problem is that it was entirely possible to build an app for an fr955 (for example) with SDK 6.4.0 in the past, when fr955 was only on CIQ 4. If I installed such an app on my fr955 when it had CIQ 4, it would expect it to continue to work now that my device is on CIQ 5.

So how can it be possible that going forward, a 7.X or 8.X SDK is required to build for my fr955?

What am I missing? Has something also changed with the device files that's relevant here?

FlowState
  • 1 month ago

    Thanks for all of the discussion here—the use case is clear to me, so I'll get this reported to the team for discussion because I agree we need some kind of solution to this.

    As an interesting side note, we used to distribute devices with each SDK release, so you could switch between SDKs and build without having this problem. The reason we separated the device configs from the SDK is because the device configs update much more frequently than the SDK, so we were often forced to do an SDK point release just to add or update devices.

  • 1 month ago in reply to FlowState

    I'd like to add my voice to those who would like to stick with the SDK they are building with when a new SDK is released. 

    My most recent build was done with SDK 7.4.3 but after downloading SDK 8.1.0 I was no longer able to build for some watch modes with SDK 7.4.3 even though that SDK 7.4.3 was still selected. To me, that seems like a problem in two respects:

    1) I can select an SDK to build with that cannot succeed

    2) I am forced to begin building with the newest SDK which may have problems that have not yet been discovered. I am not a fan of using the latest, low-mileage release until it has some time on it.

    It makes sense to me to make changes to the system to allow a developer to stay with an SDK that they've tested with, even when a new version is released and provide the developer a completely viable option to stay with what they know works until they decide to begin testing with the newest SDK, or they feel they must move to the newest SDK in order to support newer devices.

  • 1 month ago

    > This is especially relevant if the dev only targets old devices 

    Speaking of this, a related feature request is the ability to use combine builds in an IQ file so that old devices were built with an old SDK and new devices were built with a new SDK, so devs can have their cake and eat it too.

    While I realize it's highly unlikely that this will ever be officially supported, it has come up before and shows that there is a real desire amongst devs to (conservatively) avoid changing the version of the SDK that's used to build existing devices. It makes sense since any change at all can be considered a risk (or additional work/testing) compared to no change.

    For example, suppose I have a complex app which has been built and tested for dozens of old devices on an old SDK (say, 6.4.2). This could even include currently-supported devices like FR955 and FR965, back when they were on CIQ 4.x. But crucially, it also includes a ton of old CIQ 2/3 devices like FR235, FR935 and FR945 which will never receive a major (or minor) CIQ update.

    Now I want to add support for CIQ 5 devices (like Fenix 8 and newly-updated FR955/FR965), which obligates me to update to SDK 8.1.0 and use it build for *all* devices. Other than changing the SDK version, I do not change anything else about my app.

    Given that I did change the SDK version, it seems that I should now go back and test my app for all devices (at least in the sim) - or at least certain groups of devices - to make sure nothing broke simply due to updating the SDK.

    Sure, nothing is *supposed* to break, but that's not a great assumption to make, right?

    And if old devices could be built with the old SDK version (same as last build), then there would be no reason to re-test the old devices at all. (Unless you have the physical devices handy, and you want to test with new firmware. But it's impractical for most devs to have a significant number of devices lying around.)

    So to be clear, simply using a newer SDK is a perceived risk, when you've already built and tested your app for old devices on an old SDK.

    That's why devices which are medically certified (for example) receive fewer updates than usual - because they would have to be re-certified every time something changes, right? Isn't that why Garmin LTE devices (945LTE and VA3 LTE) received fewer updates at longer intervals compared to other devices?

  • 1 month ago

    Based on recurring forum discussions (this comes up all the time), I think the possible use cases are:

    1) the dev doesn't want to use a newer SDK because it has a known issue, but the new device files obligate them to do so. Or the dev perceives some risk/harm to using the latest SDK, such as increased memory usage. 

    This is especially relevant if the dev only targets old devices which are no longer receiving firmware updates and usually cannot benefit from SDK changes. Yes, I realize that there are cases when even these old devices can benefit, such as new compiler optimizations or bugfixes in the SDK. But in the past, I have seen increased memory usage in a data field just by updating my SDK. It was hard to know if this was a "real" increase that would actually be reflected on the real device though. It was especially concerning for old devices with very limited memory for data fields (I had some data fields that were riding the edge of the limit - where adding a little bit of code would cause crash. No, not a good policy, but I wanted to pack as much features as possible into those old devices.)

    2) the dev doesn't want to force users to update to the latest firmware, but the new device files obligate them to do so

    Bonus "use case":

    - the dev doesn't understand why they have to update to the latest SDK

    I understand that Garmin wants devs to use the latest SDK and users to use the latest firmware, but these issues come up over and over again. And there's often a misunderstanding among devs and users about how the following checks work:

    - the SDK compiler check which prevents old SDKs from building apps for devices with updated device configurations (device CIQ version is too new). (Indeed this check was broken until SDK 7.2)

    - the store check which prevents users with outdated firmware from installing apps that were built with the new device configurations (device firmware / CIQ version is too old)

  • 2 months ago in reply to FlowState

    There isn't a system in place to distribute old device configurations files. The goal of the device configuration files is to maintain parity with the physical devices firmware releases. If someone had old device configuration files with CIQ 4 then it should work the same as before. As soon as you update your device configurations and it has a newer CIQ version then the compiler will see that it has access to newer APIs that weren't previously available. There also isn't a system in place to build for a CIQ version while excluding knowledge of newer APIs as this is fundamental to how the compiler checks for API support.

    Is there a specific use case that you believe would be beneficial? I don't believe it is likely that a system will be built to distribute old device configurations, but if there are common enough use-cases then it is worth opening discussion with development to see if a solution can be found.