Reading paths

The end-to-end walkthrough: capability, Info.plist keys, authorization request, first query. Everything below assumes you have done this once.

Pick the identifiers you are actually reading before you write a query, and learn which of them sum and which must be averaged.

Turn that list of types into the exact Info.plist keys and authorization call, with the read-only types flagged so you do not request a write that can never be granted.

Generate the HKStatisticsQuery with the right options for each type — the cumulative-vs-discrete choice is the one that silently produces plausible wrong numbers.

Budget for this one. A first HealthKit read on a real device returns nothing far more often than it throws, and the reasons are not what most people guess.

The simulator cannot tell you whether this works. Set up the device and fixture story before you ship rather than after the first bug report.

A read that only runs while the app is open is a demo. This is the step that turns it into a product.

Start with what the category does and does not absorb — aggregators broker OAuth and normalise payloads; they do not remove the provider approval gates.

The landscape in one page, so you are choosing between named products with known coverage rather than between marketing sites.

Pricing is per connected user on most of them, which makes the build-vs-buy answer a function of your user count. Get the number before you write code.

A concrete worked integration of one aggregator, end to end. The shape transfers to the others even if you pick a different vendor.

Aggregators push. At-least-once delivery means duplicates and out-of-order events are normal traffic, not incidents — the receiver has to be built for it.

The support ticket you will get most. Most of the delay is upstream of you, and knowing which part is which is the difference between a reply and a rewrite.

If you already have direct integrations, this is the cutover plan that keeps existing users connected through the switch.

The vocabulary first — keypoints, confidence, and what a model actually hands you, which is much less than 'it knows the exercise'.

MediaPipe, MoveNet, YOLO and the rest differ in keypoint count, speed and licence. Choosing here decides most of what follows.

This one decision sets your latency budget, your per-user cost and your privacy story all at once, so make it deliberately.

The build: camera pipeline, frame rate, coordinate spaces, and the smoothing that stops a skeleton from jittering.

The first feature worth shipping on top of keypoints, and the one where naive thresholding fails on real users.

The hard one. Ship it after rep counting, because it needs the same signal to be stable before a cue can be trusted.

The dated timeline, with what is confirmed separated from what is reported. Plan against this rather than against a blog post.

The mapping and cutover plan — the API shapes are not equivalent, and the differences decide how much of your read layer survives.

The destination platform end to end: permissions, the reads, and the Play policy that governs what you may ask for.

The Android counterpart to HealthKit's empty read, and the first thing you will hit on a real device after the integration compiles.

The reference to keep open while you rewrite the read layer — the full record set, so you can check a type exists before you plan around it.