commit b9f566fcc8c504ecf048c04e607fca1582947d31
author Sean Kelley <smskelley@google.com> Mon Apr 25 10:24:17 2022 -0700
committer Sean Kelley <smskelley@google.com> Fri Jul 22 16:03:43 2022 -0700
tree 70da26b75f0408fb4da9f7355f99afaddc9de972
parent 6836cf1685153bbf1aee9b75c843cd56bfb285a2

Implement new DataType/DataPoint

Relnote: """Updated how data is modeled

    The data model and how DataTypes, DataPoints, and their underlying
    values are represented has been overhauled. The top level impact is
    that APIs are now much more explicit and type safe.

    Previously developers may have written code that looked like:
    ```
    exerciseUpdate.latestMetrics[DataType.LOCATION]?.forEach {
         val loc = it.value.asDoubleArray()

         val lat = loc[DataPoints.LOCATION_DATA_POINT_LATITUDE_INDEX]
         val lon = loc[DataPoints.LOCATION_DATA_POINT_LONGITUDE_INDEX]
         val alt = loc[DataPoints.LOCATION_DATA_POINT_ALTITUDE_INDEX]

         println("($lat,$lon,$alt) @ ${it.startDurationFromBoot}")
    }
    ```

    With these changes, the equivalent code would now be:
    ```
    exerciseUpdate.latestMetrics.getData(DataType.LOCATION).forEach {
         val loc = it.value
         val time = it.timeDurationFromBoot

         println("loc = [${loc.latitude}, ${loc.longitude}, ${loc.altitude}] @ $time")
    }
    ```

    There is now sufficient information embedded in the definition of a
    `DataType` and `DataPoint` for the compiler and IDE to know that
    `getData(DataType.Location)` will return a
    `List<SampleDataPoint<LocationData>>`. That enables type safety
    inside the IDE and at compile time rather than at runtime.

    DataType is now generic on the type of `DataPoint` that can represent it:
      * DeltaDataType
        * NumericDeltaDataType
      * AggregateDataType (numeric by default)

    DataPoint<D : DataType> is now generic and has subclasses
      * IntervalDataPoint<DeltaDataType>  (for e.g. DataType.STEPS)
        * Previously: DataPoint for a DataType with TimeType.INTERVAL
      * SampleDataPoint<DeltaDataType> (DataType.HEART_RATE_BPM)
        * Previously: DataPoint for a DataType with TimeType.SAMPLE
      * CumulativeDataPoint<AggregateDataType> (DataType.STEPS_TOTAL)
        * Previously: CumulativeDataPoint for DataType with TimeType.INTERVAL
      * StatisticalDataPoint<AggregateDataType> (DataType.HEART_RATE_BPM_STATS)
        * Previously: StatisticalDataPoint for DataType with TimeType.SAMPLE

    `DataPointContainer` has been added. Where previously APIs returned
      a map from DataType to DataPoint, they now return a `DataPointContainer`
      object which enables them to access DataPoints in a type safe way
      through `getData` methods.

    Location:
      Previously `DataType.LOCATION` was a `DoubleArray` with
      Latitude/Longitude/Altitude/Bearing available at indexes specified
      by constants, with Altitude/Bearing being optional and
      alternatively containing `Double.MAX_VALUE` if unavailable.

      This has now been changed such that DataType.LOCATION now maps to
      `LocationData` which has latitude/longitude/altitude/bearing
      properties, with altitude and bearing being nullable to indicate
      absence.
    `AchievedExerciseGoal` removed. It only contained the
      `exerciseGoal` property which is now inlined.
    `AggregateDataPoints` class has been removed. Utility functions
      have been moved to `DataPoints`

    ExerciseUpdate: Since ExerciseType is required, the builder now
    requires this to be specified in its constructor.
"""

Test: ./gradlew :health:health-services-client:test
Bug: 227475943

Change-Id: I287a816075bf721c9cec2471a5032366f70eee4f