path: root/tests/cts/utils/HealthConnectTestUtils/src/android/healthconnect/cts/utils/TestUtils.java

/*
 * Copyright (C) 2023 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package android.healthconnect.cts.utils;

import static android.content.pm.PackageManager.GET_PERMISSIONS;
import static android.health.connect.HealthDataCategory.ACTIVITY;
import static android.health.connect.HealthDataCategory.BODY_MEASUREMENTS;
import static android.health.connect.HealthDataCategory.CYCLE_TRACKING;
import static android.health.connect.HealthDataCategory.NUTRITION;
import static android.health.connect.HealthDataCategory.SLEEP;
import static android.health.connect.HealthDataCategory.VITALS;
import static android.health.connect.HealthPermissionCategory.BASAL_METABOLIC_RATE;
import static android.health.connect.HealthPermissionCategory.EXERCISE;
import static android.health.connect.HealthPermissionCategory.HEART_RATE;
import static android.health.connect.HealthPermissionCategory.STEPS;
import static android.health.connect.datatypes.Metadata.RECORDING_METHOD_ACTIVELY_RECORDED;
import static android.health.connect.datatypes.RecordTypeIdentifier.RECORD_TYPE_BASAL_METABOLIC_RATE;
import static android.health.connect.datatypes.RecordTypeIdentifier.RECORD_TYPE_HEART_RATE;
import static android.health.connect.datatypes.RecordTypeIdentifier.RECORD_TYPE_STEPS;
import static android.healthconnect.test.app.TestAppReceiver.EXTRA_SENDER_PACKAGE_NAME;

import static com.android.compatibility.common.util.FeatureUtil.AUTOMOTIVE_FEATURE;
import static com.android.compatibility.common.util.FeatureUtil.hasSystemFeature;
import static com.android.compatibility.common.util.SystemUtil.runShellCommand;
import static com.android.compatibility.common.util.SystemUtil.runWithShellPermissionIdentity;

import static com.google.common.truth.Truth.assertThat;

import static java.util.Objects.requireNonNull;

import android.app.UiAutomation;
import android.content.Context;
import android.content.Intent;
import android.content.pm.PackageInfo;
import android.content.pm.PackageManager;
import android.health.connect.AggregateRecordsGroupedByDurationResponse;
import android.health.connect.AggregateRecordsGroupedByPeriodResponse;
import android.health.connect.AggregateRecordsRequest;
import android.health.connect.AggregateRecordsResponse;
import android.health.connect.ApplicationInfoResponse;
import android.health.connect.DeleteUsingFiltersRequest;
import android.health.connect.FetchDataOriginsPriorityOrderResponse;
import android.health.connect.HealthConnectDataState;
import android.health.connect.HealthConnectException;
import android.health.connect.HealthConnectManager;
import android.health.connect.HealthPermissionCategory;
import android.health.connect.HealthPermissions;
import android.health.connect.InsertRecordsResponse;
import android.health.connect.ReadRecordsRequest;
import android.health.connect.ReadRecordsRequestUsingIds;
import android.health.connect.ReadRecordsResponse;
import android.health.connect.RecordIdFilter;
import android.health.connect.RecordTypeInfoResponse;
import android.health.connect.TimeInstantRangeFilter;
import android.health.connect.UpdateDataOriginPriorityOrderRequest;
import android.health.connect.accesslog.AccessLog;
import android.health.connect.changelog.ChangeLogTokenRequest;
import android.health.connect.changelog.ChangeLogTokenResponse;
import android.health.connect.changelog.ChangeLogsRequest;
import android.health.connect.changelog.ChangeLogsResponse;
import android.health.connect.datatypes.ActiveCaloriesBurnedRecord;
import android.health.connect.datatypes.AppInfo;
import android.health.connect.datatypes.BasalBodyTemperatureRecord;
import android.health.connect.datatypes.BasalMetabolicRateRecord;
import android.health.connect.datatypes.BloodGlucoseRecord;
import android.health.connect.datatypes.BloodPressureRecord;
import android.health.connect.datatypes.BodyFatRecord;
import android.health.connect.datatypes.BodyTemperatureRecord;
import android.health.connect.datatypes.BodyWaterMassRecord;
import android.health.connect.datatypes.BoneMassRecord;
import android.health.connect.datatypes.CervicalMucusRecord;
import android.health.connect.datatypes.CyclingPedalingCadenceRecord;
import android.health.connect.datatypes.DataOrigin;
import android.health.connect.datatypes.Device;
import android.health.connect.datatypes.DistanceRecord;
import android.health.connect.datatypes.ElevationGainedRecord;
import android.health.connect.datatypes.ExerciseLap;
import android.health.connect.datatypes.ExerciseRoute;
import android.health.connect.datatypes.ExerciseSegment;
import android.health.connect.datatypes.ExerciseSegmentType;
import android.health.connect.datatypes.ExerciseSessionRecord;
import android.health.connect.datatypes.ExerciseSessionType;
import android.health.connect.datatypes.FloorsClimbedRecord;
import android.health.connect.datatypes.HeartRateRecord;
import android.health.connect.datatypes.HeartRateVariabilityRmssdRecord;
import android.health.connect.datatypes.HeightRecord;
import android.health.connect.datatypes.HydrationRecord;
import android.health.connect.datatypes.IntermenstrualBleedingRecord;
import android.health.connect.datatypes.LeanBodyMassRecord;
import android.health.connect.datatypes.MenstruationFlowRecord;
import android.health.connect.datatypes.MenstruationPeriodRecord;
import android.health.connect.datatypes.Metadata;
import android.health.connect.datatypes.NutritionRecord;
import android.health.connect.datatypes.OvulationTestRecord;
import android.health.connect.datatypes.OxygenSaturationRecord;
import android.health.connect.datatypes.PowerRecord;
import android.health.connect.datatypes.Record;
import android.health.connect.datatypes.RespiratoryRateRecord;
import android.health.connect.datatypes.RestingHeartRateRecord;
import android.health.connect.datatypes.SexualActivityRecord;
import android.health.connect.datatypes.SleepSessionRecord;
import android.health.connect.datatypes.SpeedRecord;
import android.health.connect.datatypes.StepsCadenceRecord;
import android.health.connect.datatypes.StepsRecord;
import android.health.connect.datatypes.TotalCaloriesBurnedRecord;
import android.health.connect.datatypes.Vo2MaxRecord;
import android.health.connect.datatypes.WeightRecord;
import android.health.connect.datatypes.WheelchairPushesRecord;
import android.health.connect.datatypes.units.Length;
import android.health.connect.datatypes.units.Power;
import android.health.connect.migration.MigrationException;
import android.healthconnect.test.app.TestAppReceiver;
import android.os.Bundle;
import android.os.OutcomeReceiver;
import android.os.ParcelFileDescriptor;
import android.os.UserHandle;
import android.util.Log;

import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
import androidx.test.core.app.ApplicationProvider;
import androidx.test.platform.app.InstrumentationRegistry;

import com.android.compatibility.common.util.SystemUtil;
import com.android.cts.install.lib.TestApp;

import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.Serializable;
import java.time.Duration;
import java.time.Instant;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.Period;
import java.time.ZoneId;
import java.time.ZoneOffset;
import java.time.format.DateTimeFormatter;
import java.time.temporal.ChronoUnit;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.UUID;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicReference;
import java.util.stream.Collectors;

public final class TestUtils {
    public static final String MANAGE_HEALTH_PERMISSIONS =
            HealthPermissions.MANAGE_HEALTH_PERMISSIONS;
    public static final String READ_EXERCISE_ROUTE_PERMISSION =
            "android.permission.health.READ_EXERCISE_ROUTE";
    private static final String HEALTH_PERMISSION_PREFIX = "android.permission.health.";
    public static final String MANAGE_HEALTH_DATA = HealthPermissions.MANAGE_HEALTH_DATA_PERMISSION;
    public static final Instant SESSION_START_TIME = Instant.now().minus(10, ChronoUnit.DAYS);
    public static final Instant SESSION_END_TIME =
            Instant.now().minus(10, ChronoUnit.DAYS).plus(1, ChronoUnit.HOURS);
    private static final String TAG = "HCTestUtils";
    private static final int TIMEOUT_SECONDS = 5;

    private static final String PKG_TEST_APP = "android.healthconnect.test.app";
    private static final String TEST_APP_RECEIVER =
            PKG_TEST_APP + "." + TestAppReceiver.class.getSimpleName();

    public static boolean isHardwareAutomotive() {
        return hasSystemFeature(AUTOMOTIVE_FEATURE);
    }

    public static ChangeLogTokenResponse getChangeLogToken(ChangeLogTokenRequest request)
            throws InterruptedException {
        return getChangeLogToken(request, ApplicationProvider.getApplicationContext());
    }

    public static ChangeLogTokenResponse getChangeLogToken(
            ChangeLogTokenRequest request, Context context) throws InterruptedException {
        HealthConnectReceiver<ChangeLogTokenResponse> receiver = new HealthConnectReceiver<>();
        getHealthConnectManager(context)
                .getChangeLogToken(request, Executors.newSingleThreadExecutor(), receiver);
        return receiver.getResponse();
    }

    public static String insertRecordAndGetId(Record record) throws InterruptedException {
        return insertRecords(Collections.singletonList(record)).get(0).getMetadata().getId();
    }

    public static String insertRecordAndGetId(Record record, Context context)
            throws InterruptedException {
        return insertRecords(Collections.singletonList(record), context)
                .get(0)
                .getMetadata()
                .getId();
    }

    /**
     * Inserts records to the database.
     *
     * @param records records to insert
     * @return inserted records
     */
    public static List<Record> insertRecords(List<Record> records) throws InterruptedException {
        return insertRecords(records, ApplicationProvider.getApplicationContext());
    }

    public static List<Record> insertRecords(List<Record> records, Context context)
            throws InterruptedException {
        HealthConnectReceiver<InsertRecordsResponse> receiver = new HealthConnectReceiver<>();
        getHealthConnectManager(context)
                .insertRecords(records, Executors.newSingleThreadExecutor(), receiver);
        List<Record> returnedRecords = receiver.getResponse().getRecords();
        assertThat(returnedRecords).hasSize(records.size());
        return returnedRecords;
    }

    public static List<RecordTypeAndRecordIds> insertRecordsAndGetIds(
            List<Record> records, Context context) throws InterruptedException {
        List<Record> insertedRecords = insertRecords(records, context);

        Map<String, List<String>> recordTypeToRecordIdsMap = new HashMap<>();
        for (Record record : insertedRecords) {
            recordTypeToRecordIdsMap.putIfAbsent(record.getClass().getName(), new ArrayList<>());
            recordTypeToRecordIdsMap
                    .get(record.getClass().getName())
                    .add(record.getMetadata().getId());
        }

        List<RecordTypeAndRecordIds> recordTypeAndRecordIdsList = new ArrayList<>();
        for (String recordType : recordTypeToRecordIdsMap.keySet()) {
            recordTypeAndRecordIdsList.add(
                    new RecordTypeAndRecordIds(
                            recordType, recordTypeToRecordIdsMap.get(recordType)));
        }

        return recordTypeAndRecordIdsList;
    }

    public static void updateRecords(List<Record> records) throws InterruptedException {
        updateRecords(records, ApplicationProvider.getApplicationContext());
    }

    public static void updateRecords(List<Record> records, Context context)
            throws InterruptedException {
        HealthConnectReceiver<Void> receiver = new HealthConnectReceiver<>();
        getHealthConnectManager(context)
                .updateRecords(records, Executors.newSingleThreadExecutor(), receiver);
        receiver.verifyNoExceptionOrThrow();
    }

    public static ChangeLogsResponse getChangeLogs(ChangeLogsRequest changeLogsRequest)
            throws InterruptedException {
        return getChangeLogs(changeLogsRequest, ApplicationProvider.getApplicationContext());
    }

    public static ChangeLogsResponse getChangeLogs(
            ChangeLogsRequest changeLogsRequest, Context context) throws InterruptedException {
        HealthConnectReceiver<ChangeLogsResponse> receiver = new HealthConnectReceiver<>();
        getHealthConnectManager(context)
                .getChangeLogs(changeLogsRequest, Executors.newSingleThreadExecutor(), receiver);
        return receiver.getResponse();
    }

    public static Device buildDevice() {
        return new Device.Builder()
                .setManufacturer("google")
                .setModel("Pixel4a")
                .setType(2)
                .build();
    }

    private static Metadata buildSessionMetadata(String packageName, double clientId) {
        Device device =
                new Device.Builder().setManufacturer("google").setModel("Pixel").setType(1).build();
        DataOrigin dataOrigin = new DataOrigin.Builder().setPackageName(packageName).build();
        return new Metadata.Builder()
                .setDevice(device)
                .setDataOrigin(dataOrigin)
                .setClientRecordId(String.valueOf(clientId))
                .build();
    }

    public static List<Record> getTestRecords() {
        return Arrays.asList(
                getStepsRecord(),
                getHeartRateRecord(),
                getBasalMetabolicRateRecord(),
                buildExerciseSession());
    }

    public static List<Record> getTestRecords(String packageName) {
        double clientId = Math.random();
        return getTestRecords(packageName, clientId);
    }

    public static List<Record> getTestRecords(String packageName, Double clientId) {
        return Arrays.asList(
                getExerciseSessionRecord(packageName, clientId, /* withRoute= */ true),
                getStepsRecord(packageName, clientId),
                getHeartRateRecord(packageName, clientId),
                getBasalMetabolicRateRecord(packageName, clientId));
    }

    public static List<RecordAndIdentifier> getRecordsAndIdentifiers() {
        return Arrays.asList(
                new RecordAndIdentifier(RECORD_TYPE_STEPS, getStepsRecord()),
                new RecordAndIdentifier(RECORD_TYPE_HEART_RATE, getHeartRateRecord()),
                new RecordAndIdentifier(
                        RECORD_TYPE_BASAL_METABOLIC_RATE, getBasalMetabolicRateRecord()));
    }

    public static ExerciseRoute.Location buildLocationTimePoint(Instant startTime) {
        return new ExerciseRoute.Location.Builder(
                        Instant.ofEpochMilli(
                                (long) (startTime.toEpochMilli() + 10 + Math.random() * 50)),
                        Math.random() * 50,
                        Math.random() * 50)
                .build();
    }

    public static ExerciseRoute buildExerciseRoute() {
        return new ExerciseRoute(
                List.of(
                        buildLocationTimePoint(SESSION_START_TIME),
                        buildLocationTimePoint(SESSION_START_TIME),
                        buildLocationTimePoint(SESSION_START_TIME)));
    }

    public static StepsRecord getStepsRecord() {
        double clientId = Math.random();
        String packageName = ApplicationProvider.getApplicationContext().getPackageName();
        return getStepsRecord(packageName, clientId);
    }

    public static StepsRecord getStepsRecord(String packageName, double clientId) {
        Device device =
                new Device.Builder().setManufacturer("google").setModel("Pixel").setType(1).build();
        DataOrigin dataOrigin = new DataOrigin.Builder().setPackageName(packageName).build();
        return new StepsRecord.Builder(
                        new Metadata.Builder()
                                .setDevice(device)
                                .setDataOrigin(dataOrigin)
                                .setClientRecordId("SR" + clientId)
                                .build(),
                        Instant.now(),
                        Instant.now().plusMillis(1000),
                        10)
                .build();
    }

    public static StepsRecord getStepsRecord(String id) {
        Context context = ApplicationProvider.getApplicationContext();
        Device device =
                new Device.Builder().setManufacturer("google").setModel("Pixel").setType(1).build();
        DataOrigin dataOrigin =
                new DataOrigin.Builder().setPackageName(context.getPackageName()).build();
        return new StepsRecord.Builder(
                        new Metadata.Builder()
                                .setDevice(device)
                                .setId(id)
                                .setDataOrigin(dataOrigin)
                                .build(),
                        Instant.now(),
                        Instant.now().plusMillis(1000),
                        10)
                .build();
    }

    public static HeartRateRecord getHeartRateRecord() {
        String packageName = ApplicationProvider.getApplicationContext().getPackageName();
        double clientId = Math.random();
        return getHeartRateRecord(packageName, clientId);
    }

    public static HeartRateRecord getHeartRateRecord(String packageName, double clientId) {
        HeartRateRecord.HeartRateSample heartRateSample =
                new HeartRateRecord.HeartRateSample(72, Instant.now().plusMillis(100));
        ArrayList<HeartRateRecord.HeartRateSample> heartRateSamples = new ArrayList<>();
        heartRateSamples.add(heartRateSample);
        heartRateSamples.add(heartRateSample);
        Device device =
                new Device.Builder().setManufacturer("google").setModel("Pixel").setType(1).build();
        DataOrigin dataOrigin = new DataOrigin.Builder().setPackageName(packageName).build();

        return new HeartRateRecord.Builder(
                        new Metadata.Builder()
                                .setDevice(device)
                                .setDataOrigin(dataOrigin)
                                .setClientRecordId("HR" + clientId)
                                .build(),
                        Instant.now(),
                        Instant.now().plusMillis(500),
                        heartRateSamples)
                .build();
    }

    public static HeartRateRecord getHeartRateRecord(int heartRate) {
        HeartRateRecord.HeartRateSample heartRateSample =
                new HeartRateRecord.HeartRateSample(heartRate, Instant.now().plusMillis(100));
        ArrayList<HeartRateRecord.HeartRateSample> heartRateSamples = new ArrayList<>();
        heartRateSamples.add(heartRateSample);
        heartRateSamples.add(heartRateSample);

        return new HeartRateRecord.Builder(
                        new Metadata.Builder().build(),
                        Instant.now(),
                        Instant.now().plusMillis(500),
                        heartRateSamples)
                .build();
    }

    public static HeartRateRecord getHeartRateRecord(int heartRate, Instant instant) {
        HeartRateRecord.HeartRateSample heartRateSample =
                new HeartRateRecord.HeartRateSample(heartRate, instant);
        ArrayList<HeartRateRecord.HeartRateSample> heartRateSamples = new ArrayList<>();
        heartRateSamples.add(heartRateSample);
        heartRateSamples.add(heartRateSample);

        return new HeartRateRecord.Builder(
                        new Metadata.Builder().build(),
                        instant,
                        instant.plusMillis(1000),
                        heartRateSamples)
                .build();
    }

    public static BasalMetabolicRateRecord getBasalMetabolicRateRecord() {
        String packageName = ApplicationProvider.getApplicationContext().getPackageName();
        double clientId = Math.random();

        return getBasalMetabolicRateRecord(packageName, clientId);
    }

    public static BasalMetabolicRateRecord getBasalMetabolicRateRecord(
            String packageName, double clientId) {
        Device device =
                new Device.Builder()
                        .setManufacturer("google")
                        .setModel("Pixel4a")
                        .setType(2)
                        .build();
        DataOrigin dataOrigin = new DataOrigin.Builder().setPackageName(packageName).build();
        return new BasalMetabolicRateRecord.Builder(
                        new Metadata.Builder()
                                .setDevice(device)
                                .setDataOrigin(dataOrigin)
                                .setClientRecordId("BMR" + clientId)
                                .build(),
                        Instant.now(),
                        Power.fromWatts(100.0))
                .build();
    }

    public static ExerciseSessionRecord getExerciseSessionRecord(
            String packageName, double clientId, boolean withRoute) {
        Instant startTime = Instant.now().minusSeconds(3000).truncatedTo(ChronoUnit.MILLIS);
        Instant endTime = Instant.now();
        ExerciseSessionRecord.Builder builder =
                new ExerciseSessionRecord.Builder(
                                buildSessionMetadata(packageName, clientId),
                                startTime,
                                endTime,
                                ExerciseSessionType.EXERCISE_SESSION_TYPE_OTHER_WORKOUT)
                        .setEndZoneOffset(ZoneOffset.MAX)
                        .setStartZoneOffset(ZoneOffset.MIN)
                        .setNotes("notes")
                        .setTitle("title");

        if (withRoute) {
            builder.setRoute(
                    new ExerciseRoute(
                            List.of(
                                    new ExerciseRoute.Location.Builder(startTime, 50., 50.).build(),
                                    new ExerciseRoute.Location.Builder(
                                                    startTime.plusSeconds(2), 51., 51.)
                                            .build())));
        }
        return builder.build();
    }

    public static StepsRecord buildStepsRecord(
            String startTime, String endTime, int stepsCount, String packageName) {
        Device device =
                new Device.Builder().setManufacturer("google").setModel("Pixel").setType(1).build();
        DataOrigin dataOrigin = new DataOrigin.Builder().setPackageName(packageName).build();
        return new StepsRecord.Builder(
                        new Metadata.Builder().setDevice(device).setDataOrigin(dataOrigin).build(),
                        getInstantTime(startTime),
                        getInstantTime(endTime),
                        stepsCount)
                .build();
    }

    public static ExerciseSessionRecord buildExerciseSession(
            String sessionStartTime, String sessionEndTime, Context context) {
        return new ExerciseSessionRecord.Builder(
                        new Metadata.Builder()
                                .setDataOrigin(
                                        new DataOrigin.Builder()
                                                .setPackageName(context.getPackageName())
                                                .build())
                                .setId("ExerciseSession" + Math.random())
                                .setClientRecordId("ExerciseSessionClient" + Math.random())
                                .build(),
                        getInstantTime(sessionStartTime),
                        getInstantTime(sessionEndTime),
                        ExerciseSessionType.EXERCISE_SESSION_TYPE_FOOTBALL_AMERICAN)
                .build();
    }

    public static ExerciseSessionRecord buildExerciseSession(
            String sessionStartTime,
            String sessionEndTime,
            String pauseStart,
            String pauseEnd,
            Context context) {
        List<ExerciseSegment> segmentList =
                List.of(
                        new ExerciseSegment.Builder(
                                        getInstantTime(sessionStartTime),
                                        getInstantTime(pauseStart),
                                        ExerciseSegmentType.EXERCISE_SEGMENT_TYPE_OTHER_WORKOUT)
                                .setRepetitionsCount(10)
                                .build(),
                        new ExerciseSegment.Builder(
                                        getInstantTime(pauseStart),
                                        getInstantTime(pauseEnd),
                                        ExerciseSegmentType.EXERCISE_SEGMENT_TYPE_PAUSE)
                                .build());

        if (getInstantTime(sessionEndTime).compareTo(getInstantTime(pauseEnd)) > 0) {
            segmentList.add(
                    new ExerciseSegment.Builder(
                                    getInstantTime(pauseEnd),
                                    getInstantTime(sessionEndTime),
                                    ExerciseSegmentType.EXERCISE_SEGMENT_TYPE_OTHER_WORKOUT)
                            .setRepetitionsCount(10)
                            .build());
        }

        return new ExerciseSessionRecord.Builder(
                        new Metadata.Builder()
                                .setDataOrigin(
                                        new DataOrigin.Builder()
                                                .setPackageName(context.getPackageName())
                                                .build())
                                .setId("ExerciseSession" + Math.random())
                                .setClientRecordId("ExerciseSessionClient" + Math.random())
                                .build(),
                        getInstantTime(sessionStartTime),
                        getInstantTime(sessionEndTime),
                        ExerciseSessionType.EXERCISE_SESSION_TYPE_FOOTBALL_AMERICAN)
                .setSegments(segmentList)
                .build();
    }

    public static Instant getInstantTime(String time) {
        return LocalDateTime.parse(
                        time + " Mon 5/15/2023",
                        DateTimeFormatter.ofPattern("hh:mm a EEE M/d/uuuu", Locale.US))
                .atZone(ZoneId.of("America/Toronto"))
                .toInstant();
    }

    public static <T> AggregateRecordsResponse<T> getAggregateResponse(
            AggregateRecordsRequest<T> request) throws InterruptedException {
        HealthConnectReceiver<AggregateRecordsResponse<T>> receiver =
                new HealthConnectReceiver<AggregateRecordsResponse<T>>();
        getHealthConnectManager().aggregate(request, Executors.newSingleThreadExecutor(), receiver);
        return receiver.getResponse();
    }

    public static <T> AggregateRecordsResponse<T> getAggregateResponse(
            AggregateRecordsRequest<T> request, List<Record> recordsToInsert)
            throws InterruptedException {
        if (recordsToInsert != null) {
            insertRecords(recordsToInsert);
        }

        HealthConnectReceiver<AggregateRecordsResponse<T>> receiver = new HealthConnectReceiver<>();
        getHealthConnectManager().aggregate(request, Executors.newSingleThreadExecutor(), receiver);
        return receiver.getResponse();
    }

    public static <T>
            List<AggregateRecordsGroupedByDurationResponse<T>> getAggregateResponseGroupByDuration(
                    AggregateRecordsRequest<T> request, Duration duration)
                    throws InterruptedException {
        HealthConnectReceiver<List<AggregateRecordsGroupedByDurationResponse<T>>> receiver =
                new HealthConnectReceiver<>();
        getHealthConnectManager()
                .aggregateGroupByDuration(
                        request, duration, Executors.newSingleThreadExecutor(), receiver);
        return receiver.getResponse();
    }

    public static <T>
            List<AggregateRecordsGroupedByPeriodResponse<T>> getAggregateResponseGroupByPeriod(
                    AggregateRecordsRequest<T> request, Period period) throws InterruptedException {
        HealthConnectReceiver<List<AggregateRecordsGroupedByPeriodResponse<T>>> receiver =
                new HealthConnectReceiver<>();
        getHealthConnectManager()
                .aggregateGroupByPeriod(
                        request, period, Executors.newSingleThreadExecutor(), receiver);
        return receiver.getResponse();
    }

    public static <T extends Record> List<T> readRecords(ReadRecordsRequest<T> request)
            throws InterruptedException {
        return readRecords(request, ApplicationProvider.getApplicationContext());
    }

    public static <T extends Record> List<T> readRecords(
            ReadRecordsRequest<T> request, Context context) throws InterruptedException {
        assertThat(request.getRecordType()).isNotNull();
        HealthConnectReceiver<ReadRecordsResponse<T>> receiver = new HealthConnectReceiver<>();
        getHealthConnectManager(context)
                .readRecords(request, Executors.newSingleThreadExecutor(), receiver);
        return receiver.getResponse().getRecords();
    }

    public static <T extends Record> void assertRecordNotFound(String uuid, Class<T> recordType)
            throws InterruptedException {
        assertThat(
                        readRecords(
                                new ReadRecordsRequestUsingIds.Builder<>(recordType)
                                        .addId(uuid)
                                        .build()))
                .isEmpty();
    }

    public static <T extends Record> void assertRecordFound(String uuid, Class<T> recordType)
            throws InterruptedException {
        assertThat(
                        readRecords(
                                new ReadRecordsRequestUsingIds.Builder<>(recordType)
                                        .addId(uuid)
                                        .build()))
                .isNotEmpty();
    }

    public static <T extends Record> ReadRecordsResponse<T> readRecordsWithPagination(
            ReadRecordsRequest<T> request) throws InterruptedException {
        HealthConnectReceiver<ReadRecordsResponse<T>> receiver = new HealthConnectReceiver<>();
        getHealthConnectManager()
                .readRecords(request, Executors.newSingleThreadExecutor(), receiver);
        return receiver.getResponse();
    }

    public static void setAutoDeletePeriod(int period) throws InterruptedException {
        UiAutomation uiAutomation = InstrumentationRegistry.getInstrumentation().getUiAutomation();
        uiAutomation.adoptShellPermissionIdentity(MANAGE_HEALTH_DATA);
        try {
            HealthConnectReceiver<Void> receiver = new HealthConnectReceiver<>();
            getHealthConnectManager()
                    .setRecordRetentionPeriodInDays(
                            period, Executors.newSingleThreadExecutor(), receiver);
            receiver.verifyNoExceptionOrThrow();
        } finally {
            uiAutomation.dropShellPermissionIdentity();
        }
    }

    public static void verifyDeleteRecords(DeleteUsingFiltersRequest request)
            throws InterruptedException {
        UiAutomation uiAutomation = InstrumentationRegistry.getInstrumentation().getUiAutomation();
        uiAutomation.adoptShellPermissionIdentity(MANAGE_HEALTH_DATA);
        try {
            HealthConnectReceiver<Void> receiver = new HealthConnectReceiver<>();
            getHealthConnectManager()
                    .deleteRecords(request, Executors.newSingleThreadExecutor(), receiver);
            receiver.verifyNoExceptionOrThrow();
        } finally {
            uiAutomation.dropShellPermissionIdentity();
        }
    }

    public static void verifyDeleteRecords(List<RecordIdFilter> request)
            throws InterruptedException {
        verifyDeleteRecords(request, ApplicationProvider.getApplicationContext());
    }

    public static void verifyDeleteRecords(List<RecordIdFilter> request, Context context)
            throws InterruptedException {
        HealthConnectReceiver<Void> receiver = new HealthConnectReceiver<>();
        getHealthConnectManager(context)
                .deleteRecords(request, Executors.newSingleThreadExecutor(), receiver);
        receiver.verifyNoExceptionOrThrow();
    }

    public static void verifyDeleteRecords(
            Class<? extends Record> recordType, TimeInstantRangeFilter timeRangeFilter)
            throws InterruptedException {
        HealthConnectReceiver<Void> receiver = new HealthConnectReceiver<>();
        getHealthConnectManager()
                .deleteRecords(
                        recordType, timeRangeFilter, Executors.newSingleThreadExecutor(), receiver);
        receiver.verifyNoExceptionOrThrow();
    }

    public static void deleteRecords(List<Record> records) throws InterruptedException {
        List<RecordIdFilter> recordIdFilters =
                records.stream()
                        .map(
                                (record ->
                                        RecordIdFilter.fromId(
                                                record.getClass(), record.getMetadata().getId())))
                        .collect(Collectors.toList());
        verifyDeleteRecords(recordIdFilters);
    }

    public static List<AccessLog> queryAccessLogs() throws InterruptedException {
        UiAutomation uiAutomation = InstrumentationRegistry.getInstrumentation().getUiAutomation();
        uiAutomation.adoptShellPermissionIdentity(MANAGE_HEALTH_DATA);
        try {
            HealthConnectReceiver<List<AccessLog>> receiver = new HealthConnectReceiver<>();
            getHealthConnectManager()
                    .queryAccessLogs(Executors.newSingleThreadExecutor(), receiver);
            return receiver.getResponse();
        } finally {
            uiAutomation.dropShellPermissionIdentity();
        }
    }

    public static Map<Class<? extends Record>, RecordTypeInfoResponse> queryAllRecordTypesInfo()
            throws InterruptedException, NullPointerException {
        UiAutomation uiAutomation = InstrumentationRegistry.getInstrumentation().getUiAutomation();
        uiAutomation.adoptShellPermissionIdentity(MANAGE_HEALTH_DATA);
        try {
            HealthConnectReceiver<Map<Class<? extends Record>, RecordTypeInfoResponse>> receiver =
                    new HealthConnectReceiver<>();
            getHealthConnectManager()
                    .queryAllRecordTypesInfo(Executors.newSingleThreadExecutor(), receiver);
            return receiver.getResponse();
        } finally {
            uiAutomation.dropShellPermissionIdentity();
        }
    }

    public static List<LocalDate> getActivityDates(List<Class<? extends Record>> recordTypes)
            throws InterruptedException {
        UiAutomation uiAutomation = InstrumentationRegistry.getInstrumentation().getUiAutomation();
        uiAutomation.adoptShellPermissionIdentity(MANAGE_HEALTH_DATA);
        try {
            HealthConnectReceiver<List<LocalDate>> receiver = new HealthConnectReceiver<>();
            getHealthConnectManager()
                    .queryActivityDates(recordTypes, Executors.newSingleThreadExecutor(), receiver);
            return receiver.getResponse();
        } finally {
            uiAutomation.dropShellPermissionIdentity();
        }
    }

    public static ExerciseSessionRecord buildExerciseSession() {
        return buildExerciseSession(buildExerciseRoute(), "Morning training", "rain");
    }

    public static SleepSessionRecord buildSleepSession() {
        return new SleepSessionRecord.Builder(
                        generateMetadata(), SESSION_START_TIME, SESSION_END_TIME)
                .setNotes("warm")
                .setTitle("Afternoon nap")
                .setStages(
                        List.of(
                                new SleepSessionRecord.Stage(
                                        SESSION_START_TIME,
                                        SESSION_START_TIME.plusSeconds(300),
                                        SleepSessionRecord.StageType.STAGE_TYPE_SLEEPING_LIGHT),
                                new SleepSessionRecord.Stage(
                                        SESSION_START_TIME.plusSeconds(300),
                                        SESSION_START_TIME.plusSeconds(600),
                                        SleepSessionRecord.StageType.STAGE_TYPE_SLEEPING_REM),
                                new SleepSessionRecord.Stage(
                                        SESSION_START_TIME.plusSeconds(900),
                                        SESSION_START_TIME.plusSeconds(1200),
                                        SleepSessionRecord.StageType.STAGE_TYPE_SLEEPING_DEEP)))
                .build();
    }

    public static void startMigration() throws InterruptedException {
        MigrationReceiver receiver = new MigrationReceiver();
        getHealthConnectManager().startMigration(Executors.newSingleThreadExecutor(), receiver);
        receiver.verifyNoExceptionOrThrow();
    }

    public static void finishMigration() throws InterruptedException {
        MigrationReceiver receiver = new MigrationReceiver();
        getHealthConnectManager().finishMigration(Executors.newSingleThreadExecutor(), receiver);
        receiver.verifyNoExceptionOrThrow();
    }

    public static void insertMinDataMigrationSdkExtensionVersion(int version)
            throws InterruptedException {
        MigrationReceiver receiver = new MigrationReceiver();
        getHealthConnectManager()
                .insertMinDataMigrationSdkExtensionVersion(
                        version, Executors.newSingleThreadExecutor(), receiver);
        receiver.verifyNoExceptionOrThrow();
    }

    public static void deleteAllStagedRemoteData() {
        HealthConnectManager service = getHealthConnectManager();
        runWithShellPermissionIdentity(
                () ->
                        // TODO(b/241542162): Avoid reflection once TestApi can be called from CTS
                        service.getClass().getMethod("deleteAllStagedRemoteData").invoke(service),
                "android.permission.DELETE_STAGED_HEALTH_CONNECT_REMOTE_DATA");
    }

    public static int getHealthConnectDataMigrationState() throws InterruptedException {
        HealthConnectReceiver<HealthConnectDataState> receiver = new HealthConnectReceiver<>();
        getHealthConnectManager()
                .getHealthConnectDataState(Executors.newSingleThreadExecutor(), receiver);
        return receiver.getResponse().getDataMigrationState();
    }

    public static int getHealthConnectDataRestoreState() throws InterruptedException {
        HealthConnectReceiver<HealthConnectDataState> receiver = new HealthConnectReceiver<>();
        runWithShellPermissionIdentity(
                () ->
                        getHealthConnectManager()
                                .getHealthConnectDataState(
                                        Executors.newSingleThreadExecutor(), receiver),
                MANAGE_HEALTH_DATA);
        return receiver.getResponse().getDataRestoreState();
    }

    public static List<AppInfo> getApplicationInfo() throws InterruptedException {
        HealthConnectReceiver<ApplicationInfoResponse> receiver = new HealthConnectReceiver<>();
        getHealthConnectManager()
                .getContributorApplicationsInfo(Executors.newSingleThreadExecutor(), receiver);
        return receiver.getResponse().getApplicationInfoList();
    }

    public static <T extends Record> T getRecordById(List<T> list, String id) {
        for (T record : list) {
            if (record.getMetadata().getId().equals(id)) {
                return record;
            }
        }

        throw new AssertionError("Record not found with id: " + id);
    }

    public static Metadata generateMetadata() {
        Context context = ApplicationProvider.getApplicationContext();
        return new Metadata.Builder()
                .setDevice(buildDevice())
                .setId(UUID.randomUUID().toString())
                .setClientRecordId("clientRecordId" + Math.random())
                .setDataOrigin(
                        new DataOrigin.Builder().setPackageName(context.getPackageName()).build())
                .setDevice(buildDevice())
                .setRecordingMethod(Metadata.RECORDING_METHOD_UNKNOWN)
                .build();
    }

    public static HeartRateRecord getHugeHeartRateRecord() {
        Device device =
                new Device.Builder()
                        .setManufacturer("google")
                        .setModel("Pixel4a")
                        .setType(2)
                        .build();
        DataOrigin dataOrigin =
                new DataOrigin.Builder().setPackageName("android.healthconnect.cts").build();
        Metadata.Builder testMetadataBuilder = new Metadata.Builder();
        testMetadataBuilder.setDevice(device).setDataOrigin(dataOrigin);
        testMetadataBuilder.setClientRecordId("HRR" + Math.random());
        testMetadataBuilder.setRecordingMethod(Metadata.RECORDING_METHOD_ACTIVELY_RECORDED);

        HeartRateRecord.HeartRateSample heartRateRecord =
                new HeartRateRecord.HeartRateSample(10, Instant.now().plusMillis(100));
        ArrayList<HeartRateRecord.HeartRateSample> heartRateRecords =
                new ArrayList<>(Collections.nCopies(85000, heartRateRecord));

        return new HeartRateRecord.Builder(
                        testMetadataBuilder.build(),
                        Instant.now(),
                        Instant.now().plusMillis(500),
                        heartRateRecords)
                .build();
    }

    public static StepsRecord getCompleteStepsRecord() {
        Device device =
                new Device.Builder().setManufacturer("google").setModel("Pixel").setType(1).build();
        DataOrigin dataOrigin =
                new DataOrigin.Builder().setPackageName("android.healthconnect.cts").build();

        Metadata.Builder testMetadataBuilder = new Metadata.Builder();
        testMetadataBuilder.setDevice(device).setDataOrigin(dataOrigin);
        testMetadataBuilder.setClientRecordId("SR" + Math.random());
        testMetadataBuilder.setRecordingMethod(RECORDING_METHOD_ACTIVELY_RECORDED);
        Metadata testMetaData = testMetadataBuilder.build();
        assertThat(testMetaData.getRecordingMethod()).isEqualTo(RECORDING_METHOD_ACTIVELY_RECORDED);
        return new StepsRecord.Builder(
                        testMetaData, Instant.now(), Instant.now().plusMillis(1000), 10)
                .build();
    }

    public static StepsRecord getStepsRecord_update(
            Record record, String id, String clientRecordId) {
        Metadata metadata = record.getMetadata();
        Metadata metadataWithId =
                new Metadata.Builder()
                        .setId(id)
                        .setClientRecordId(clientRecordId)
                        .setClientRecordVersion(metadata.getClientRecordVersion())
                        .setDataOrigin(metadata.getDataOrigin())
                        .setDevice(metadata.getDevice())
                        .setLastModifiedTime(metadata.getLastModifiedTime())
                        .build();
        return new StepsRecord.Builder(
                        metadataWithId, Instant.now(), Instant.now().plusMillis(2000), 20)
                .setStartZoneOffset(ZoneOffset.systemDefault().getRules().getOffset(Instant.now()))
                .setEndZoneOffset(ZoneOffset.systemDefault().getRules().getOffset(Instant.now()))
                .build();
    }

    private static ExerciseSessionRecord buildExerciseSession(
            ExerciseRoute route, String title, String notes) {
        return new ExerciseSessionRecord.Builder(
                        generateMetadata(),
                        SESSION_START_TIME,
                        SESSION_END_TIME,
                        ExerciseSessionType.EXERCISE_SESSION_TYPE_OTHER_WORKOUT)
                .setRoute(route)
                .setLaps(
                        List.of(
                                new ExerciseLap.Builder(
                                                SESSION_START_TIME,
                                                SESSION_START_TIME.plusSeconds(20))
                                        .setLength(Length.fromMeters(10))
                                        .build(),
                                new ExerciseLap.Builder(
                                                SESSION_END_TIME.minusSeconds(20), SESSION_END_TIME)
                                        .build()))
                .setSegments(
                        List.of(
                                new ExerciseSegment.Builder(
                                                SESSION_START_TIME.plusSeconds(1),
                                                SESSION_START_TIME.plusSeconds(10),
                                                ExerciseSegmentType
                                                        .EXERCISE_SEGMENT_TYPE_BENCH_PRESS)
                                        .build(),
                                new ExerciseSegment.Builder(
                                                SESSION_START_TIME.plusSeconds(21),
                                                SESSION_START_TIME.plusSeconds(124),
                                                ExerciseSegmentType.EXERCISE_SEGMENT_TYPE_BURPEE)
                                        .setRepetitionsCount(15)
                                        .build()))
                .setEndZoneOffset(ZoneOffset.MAX)
                .setStartZoneOffset(ZoneOffset.MIN)
                .setNotes(notes)
                .setTitle(title)
                .build();
    }

    public static void populateAndResetExpectedResponseMap(
            HashMap<Class<? extends Record>, RecordTypeInfoTestResponse> expectedResponseMap) {
        expectedResponseMap.put(
                ElevationGainedRecord.class,
                new RecordTypeInfoTestResponse(
                        ACTIVITY, HealthPermissionCategory.ELEVATION_GAINED, new ArrayList<>()));
        expectedResponseMap.put(
                OvulationTestRecord.class,
                new RecordTypeInfoTestResponse(
                        CYCLE_TRACKING,
                        HealthPermissionCategory.OVULATION_TEST,
                        new ArrayList<>()));
        expectedResponseMap.put(
                DistanceRecord.class,
                new RecordTypeInfoTestResponse(
                        ACTIVITY, HealthPermissionCategory.DISTANCE, new ArrayList<>()));
        expectedResponseMap.put(
                SpeedRecord.class,
                new RecordTypeInfoTestResponse(
                        ACTIVITY, HealthPermissionCategory.SPEED, new ArrayList<>()));

        expectedResponseMap.put(
                Vo2MaxRecord.class,
                new RecordTypeInfoTestResponse(
                        ACTIVITY, HealthPermissionCategory.VO2_MAX, new ArrayList<>()));
        expectedResponseMap.put(
                OxygenSaturationRecord.class,
                new RecordTypeInfoTestResponse(
                        VITALS, HealthPermissionCategory.OXYGEN_SATURATION, new ArrayList<>()));
        expectedResponseMap.put(
                TotalCaloriesBurnedRecord.class,
                new RecordTypeInfoTestResponse(
                        ACTIVITY,
                        HealthPermissionCategory.TOTAL_CALORIES_BURNED,
                        new ArrayList<>()));
        expectedResponseMap.put(
                HydrationRecord.class,
                new RecordTypeInfoTestResponse(
                        NUTRITION, HealthPermissionCategory.HYDRATION, new ArrayList<>()));
        expectedResponseMap.put(
                StepsRecord.class,
                new RecordTypeInfoTestResponse(ACTIVITY, STEPS, new ArrayList<>()));
        expectedResponseMap.put(
                CervicalMucusRecord.class,
                new RecordTypeInfoTestResponse(
                        CYCLE_TRACKING,
                        HealthPermissionCategory.CERVICAL_MUCUS,
                        new ArrayList<>()));
        expectedResponseMap.put(
                ExerciseSessionRecord.class,
                new RecordTypeInfoTestResponse(ACTIVITY, EXERCISE, new ArrayList<>()));
        expectedResponseMap.put(
                HeartRateRecord.class,
                new RecordTypeInfoTestResponse(VITALS, HEART_RATE, new ArrayList<>()));
        expectedResponseMap.put(
                RespiratoryRateRecord.class,
                new RecordTypeInfoTestResponse(
                        VITALS, HealthPermissionCategory.RESPIRATORY_RATE, new ArrayList<>()));
        expectedResponseMap.put(
                BasalBodyTemperatureRecord.class,
                new RecordTypeInfoTestResponse(
                        VITALS,
                        HealthPermissionCategory.BASAL_BODY_TEMPERATURE,
                        new ArrayList<>()));
        expectedResponseMap.put(
                WheelchairPushesRecord.class,
                new RecordTypeInfoTestResponse(
                        ACTIVITY, HealthPermissionCategory.WHEELCHAIR_PUSHES, new ArrayList<>()));
        expectedResponseMap.put(
                PowerRecord.class,
                new RecordTypeInfoTestResponse(
                        ACTIVITY, HealthPermissionCategory.POWER, new ArrayList<>()));
        expectedResponseMap.put(
                BodyWaterMassRecord.class,
                new RecordTypeInfoTestResponse(
                        BODY_MEASUREMENTS,
                        HealthPermissionCategory.BODY_WATER_MASS,
                        new ArrayList<>()));
        expectedResponseMap.put(
                WeightRecord.class,
                new RecordTypeInfoTestResponse(
                        BODY_MEASUREMENTS, HealthPermissionCategory.WEIGHT, new ArrayList<>()));
        expectedResponseMap.put(
                BoneMassRecord.class,
                new RecordTypeInfoTestResponse(
                        BODY_MEASUREMENTS, HealthPermissionCategory.BONE_MASS, new ArrayList<>()));
        expectedResponseMap.put(
                RestingHeartRateRecord.class,
                new RecordTypeInfoTestResponse(
                        VITALS, HealthPermissionCategory.RESTING_HEART_RATE, new ArrayList<>()));
        expectedResponseMap.put(
                ActiveCaloriesBurnedRecord.class,
                new RecordTypeInfoTestResponse(
                        ACTIVITY,
                        HealthPermissionCategory.ACTIVE_CALORIES_BURNED,
                        new ArrayList<>()));
        expectedResponseMap.put(
                BodyFatRecord.class,
                new RecordTypeInfoTestResponse(
                        BODY_MEASUREMENTS, HealthPermissionCategory.BODY_FAT, new ArrayList<>()));
        expectedResponseMap.put(
                BodyTemperatureRecord.class,
                new RecordTypeInfoTestResponse(
                        VITALS, HealthPermissionCategory.BODY_TEMPERATURE, new ArrayList<>()));
        expectedResponseMap.put(
                NutritionRecord.class,
                new RecordTypeInfoTestResponse(
                        NUTRITION, HealthPermissionCategory.NUTRITION, new ArrayList<>()));
        expectedResponseMap.put(
                LeanBodyMassRecord.class,
                new RecordTypeInfoTestResponse(
                        BODY_MEASUREMENTS,
                        HealthPermissionCategory.LEAN_BODY_MASS,
                        new ArrayList<>()));
        expectedResponseMap.put(
                HeartRateVariabilityRmssdRecord.class,
                new RecordTypeInfoTestResponse(
                        VITALS,
                        HealthPermissionCategory.HEART_RATE_VARIABILITY,
                        new ArrayList<>()));
        expectedResponseMap.put(
                MenstruationFlowRecord.class,
                new RecordTypeInfoTestResponse(
                        CYCLE_TRACKING, HealthPermissionCategory.MENSTRUATION, new ArrayList<>()));
        expectedResponseMap.put(
                BloodGlucoseRecord.class,
                new RecordTypeInfoTestResponse(
                        VITALS, HealthPermissionCategory.BLOOD_GLUCOSE, new ArrayList<>()));
        expectedResponseMap.put(
                BloodPressureRecord.class,
                new RecordTypeInfoTestResponse(
                        VITALS, HealthPermissionCategory.BLOOD_PRESSURE, new ArrayList<>()));
        expectedResponseMap.put(
                CyclingPedalingCadenceRecord.class,
                new RecordTypeInfoTestResponse(ACTIVITY, EXERCISE, new ArrayList<>()));
        expectedResponseMap.put(
                IntermenstrualBleedingRecord.class,
                new RecordTypeInfoTestResponse(
                        CYCLE_TRACKING,
                        HealthPermissionCategory.INTERMENSTRUAL_BLEEDING,
                        new ArrayList<>()));
        expectedResponseMap.put(
                FloorsClimbedRecord.class,
                new RecordTypeInfoTestResponse(
                        ACTIVITY, HealthPermissionCategory.FLOORS_CLIMBED, new ArrayList<>()));
        expectedResponseMap.put(
                StepsCadenceRecord.class,
                new RecordTypeInfoTestResponse(ACTIVITY, STEPS, new ArrayList<>()));
        expectedResponseMap.put(
                HeightRecord.class,
                new RecordTypeInfoTestResponse(
                        BODY_MEASUREMENTS, HealthPermissionCategory.HEIGHT, new ArrayList<>()));
        expectedResponseMap.put(
                SexualActivityRecord.class,
                new RecordTypeInfoTestResponse(
                        CYCLE_TRACKING,
                        HealthPermissionCategory.SEXUAL_ACTIVITY,
                        new ArrayList<>()));
        expectedResponseMap.put(
                MenstruationPeriodRecord.class,
                new RecordTypeInfoTestResponse(
                        CYCLE_TRACKING, HealthPermissionCategory.MENSTRUATION, new ArrayList<>()));
        expectedResponseMap.put(
                SleepSessionRecord.class,
                new RecordTypeInfoTestResponse(
                        SLEEP, HealthPermissionCategory.SLEEP, new ArrayList<>()));
        expectedResponseMap.put(
                BasalMetabolicRateRecord.class,
                new RecordTypeInfoTestResponse(
                        BODY_MEASUREMENTS, BASAL_METABOLIC_RATE, new ArrayList<>()));
    }

    public static FetchDataOriginsPriorityOrderResponse fetchDataOriginsPriorityOrder(
            int dataCategory) throws InterruptedException {
        HealthConnectReceiver<FetchDataOriginsPriorityOrderResponse> receiver =
                new HealthConnectReceiver<>();
        getHealthConnectManager()
                .fetchDataOriginsPriorityOrder(
                        dataCategory, Executors.newSingleThreadExecutor(), receiver);
        return receiver.getResponse();
    }

    public static void updateDataOriginPriorityOrder(UpdateDataOriginPriorityOrderRequest request)
            throws InterruptedException {
        HealthConnectReceiver<Void> receiver = new HealthConnectReceiver<>();
        getHealthConnectManager()
                .updateDataOriginPriorityOrder(
                        request, Executors.newSingleThreadExecutor(), receiver);
        receiver.verifyNoExceptionOrThrow();
    }

    public static void grantPermission(String pkgName, String permission) {
        HealthConnectManager service = getHealthConnectManager();
        runWithShellPermissionIdentity(
                () ->
                        service.getClass()
                                .getMethod("grantHealthPermission", String.class, String.class)
                                .invoke(service, pkgName, permission),
                MANAGE_HEALTH_PERMISSIONS);
    }

    public static void revokePermission(String pkgName, String permission) {
        HealthConnectManager service = getHealthConnectManager();
        runWithShellPermissionIdentity(
                () ->
                        service.getClass()
                                .getMethod(
                                        "revokeHealthPermission",
                                        String.class,
                                        String.class,
                                        String.class)
                                .invoke(service, pkgName, permission, null),
                MANAGE_HEALTH_PERMISSIONS);
    }

    /**
     * Utility method to call {@link HealthConnectManager#revokeAllHealthPermissions(String,
     * String)}.
     */
    public static void revokeAllPermissions(String packageName, @Nullable String reason) {
        HealthConnectManager service = getHealthConnectManager();
        runWithShellPermissionIdentity(
                () ->
                        service.getClass()
                                .getMethod("revokeAllHealthPermissions", String.class, String.class)
                                .invoke(service, packageName, reason),
                MANAGE_HEALTH_PERMISSIONS);
    }

    /**
     * Same as {@link #revokeAllPermissions(String, String)} but with a delay to wait for grant time
     * to be updated.
     */
    public static void revokeAllPermissionsWithDelay(String packageName, @Nullable String reason)
            throws InterruptedException {
        revokeAllPermissions(packageName, reason);
        Thread.sleep(500);
    }

    /**
     * Utility method to call {@link
     * HealthConnectManager#getHealthDataHistoricalAccessStartDate(String)}.
     */
    public static Instant getHealthDataHistoricalAccessStartDate(String packageName) {
        HealthConnectManager service = getHealthConnectManager();
        return (Instant)
                runWithShellPermissionIdentity(
                        () ->
                                service.getClass()
                                        .getMethod(
                                                "getHealthDataHistoricalAccessStartDate",
                                                String.class)
                                        .invoke(service, packageName),
                        MANAGE_HEALTH_PERMISSIONS);
    }

    public static void revokeHealthPermissions(String packageName) {
        runWithShellPermissionIdentity(() -> revokeHealthPermissionsPrivileged(packageName));
    }

    private static void revokeHealthPermissionsPrivileged(String packageName)
            throws PackageManager.NameNotFoundException {
        final Context targetContext = androidx.test.InstrumentationRegistry.getTargetContext();
        final PackageManager packageManager = targetContext.getPackageManager();
        final UserHandle user = targetContext.getUser();

        final PackageInfo packageInfo =
                packageManager.getPackageInfo(
                        packageName,
                        PackageManager.PackageInfoFlags.of(PackageManager.GET_PERMISSIONS));

        final String[] permissions = packageInfo.requestedPermissions;
        if (permissions == null) {
            return;
        }

        for (String permission : permissions) {
            if (permission.startsWith(HEALTH_PERMISSION_PREFIX)) {
                packageManager.revokeRuntimePermission(packageName, permission, user);
            }
        }
    }

    public static List<String> getGrantedHealthPermissions(String pkgName) {
        final PackageInfo pi = getAppPackageInfo(pkgName);
        final String[] requestedPermissions = pi.requestedPermissions;
        final int[] requestedPermissionsFlags = pi.requestedPermissionsFlags;

        if (requestedPermissions == null) {
            return List.of();
        }

        final List<String> permissions = new ArrayList<>();

        for (int i = 0; i < requestedPermissions.length; i++) {
            if ((requestedPermissionsFlags[i] & PackageInfo.REQUESTED_PERMISSION_GRANTED) != 0) {
                if (requestedPermissions[i].startsWith(HEALTH_PERMISSION_PREFIX)) {
                    permissions.add(requestedPermissions[i]);
                }
            }
        }

        return permissions;
    }

    private static PackageInfo getAppPackageInfo(String pkgName) {
        final Context targetContext = androidx.test.InstrumentationRegistry.getTargetContext();
        return runWithShellPermissionIdentity(
                () ->
                        targetContext
                                .getPackageManager()
                                .getPackageInfo(
                                        pkgName,
                                        PackageManager.PackageInfoFlags.of(GET_PERMISSIONS)));
    }

    public static void deleteTestData() throws InterruptedException {
        verifyDeleteRecords(
                new DeleteUsingFiltersRequest.Builder()
                        .setTimeRangeFilter(
                                new TimeInstantRangeFilter.Builder()
                                        .setStartTime(Instant.EPOCH)
                                        .setEndTime(Instant.now().plus(10, ChronoUnit.DAYS))
                                        .build())
                        .addRecordType(ExerciseSessionRecord.class)
                        .addRecordType(StepsRecord.class)
                        .addRecordType(HeartRateRecord.class)
                        .addRecordType(BasalMetabolicRateRecord.class)
                        .build());
    }

    public static void revokeAndThenGrantHealthPermissions(TestApp testApp) {
        List<String> healthPerms = getGrantedHealthPermissions(testApp.getPackageName());

        revokeHealthPermissions(testApp.getPackageName());

        for (String perm : healthPerms) {
            grantPermission(testApp.getPackageName(), perm);
        }
    }

    public static String runShellCommand(String command) throws IOException {
        UiAutomation uiAutomation =
                androidx.test.platform.app.InstrumentationRegistry.getInstrumentation()
                        .getUiAutomation();
        uiAutomation.adoptShellPermissionIdentity();
        final ParcelFileDescriptor stdout = uiAutomation.executeShellCommand(command);
        StringBuilder output = new StringBuilder();

        try (BufferedReader reader =
                new BufferedReader(
                        new InputStreamReader(new FileInputStream(stdout.getFileDescriptor())))) {
            char[] buffer = new char[4096];
            int bytesRead;
            while ((bytesRead = reader.read(buffer)) != -1) {
                output.append(buffer, 0, bytesRead);
            }
        } catch (FileNotFoundException e) {
            Log.e(TAG, e.getMessage());
        }

        return output.toString();
    }

    @NonNull
    private static HealthConnectManager getHealthConnectManager() {
        return getHealthConnectManager(ApplicationProvider.getApplicationContext());
    }

    @NonNull
    private static HealthConnectManager getHealthConnectManager(Context context) {
        return requireNonNull(context.getSystemService(HealthConnectManager.class));
    }

    public static String getDeviceConfigValue(String key) {
        return SystemUtil.runShellCommand("device_config get health_fitness " + key);
    }

    public static void setDeviceConfigValue(String key, String value) {
        SystemUtil.runShellCommand("device_config put health_fitness " + key + " " + value);
    }

    public static void sendCommandToTestAppReceiver(Context context, String action) {
        sendCommandToTestAppReceiver(context, action, /*extras=*/ null);
    }

    public static void sendCommandToTestAppReceiver(Context context, String action, Bundle extras) {
        final Intent intent = new Intent(action).setClassName(PKG_TEST_APP, TEST_APP_RECEIVER);
        intent.putExtra(EXTRA_SENDER_PACKAGE_NAME, context.getPackageName());
        if (extras != null) {
            intent.putExtras(extras);
        }
        context.sendBroadcast(intent);
    }

    public static final class RecordAndIdentifier {
        private final int mId;
        private final Record mRecordClass;

        public RecordAndIdentifier(int id, Record recordClass) {
            this.mId = id;
            this.mRecordClass = recordClass;
        }

        public int getId() {
            return mId;
        }

        public Record getRecordClass() {
            return mRecordClass;
        }
    }

    public static class RecordTypeInfoTestResponse {
        private final int mRecordTypePermission;
        private final ArrayList<String> mContributingPackages;
        private final int mRecordTypeCategory;

        RecordTypeInfoTestResponse(
                int recordTypeCategory,
                int recordTypePermission,
                ArrayList<String> contributingPackages) {
            mRecordTypeCategory = recordTypeCategory;
            mRecordTypePermission = recordTypePermission;
            mContributingPackages = contributingPackages;
        }

        public int getRecordTypeCategory() {
            return mRecordTypeCategory;
        }

        public int getRecordTypePermission() {
            return mRecordTypePermission;
        }

        public ArrayList<String> getContributingPackages() {
            return mContributingPackages;
        }
    }

    public static class RecordTypeAndRecordIds implements Serializable {
        private String mRecordType;
        private List<String> mRecordIds;

        public RecordTypeAndRecordIds(String recordType, List<String> ids) {
            mRecordType = recordType;
            mRecordIds = ids;
        }

        public String getRecordType() {
            return mRecordType;
        }

        public List<String> getRecordIds() {
            return mRecordIds;
        }
    }

    private static class TestReceiver<T, E extends RuntimeException>
            implements OutcomeReceiver<T, E> {
        private final CountDownLatch mLatch = new CountDownLatch(1);
        private final AtomicReference<T> mResponse = new AtomicReference<>();
        private final AtomicReference<E> mException = new AtomicReference<>();

        public T getResponse() throws InterruptedException {
            verifyNoExceptionOrThrow();
            return mResponse.get();
        }

        public void verifyNoExceptionOrThrow() throws InterruptedException {
            assertThat(mLatch.await(TIMEOUT_SECONDS, TimeUnit.SECONDS)).isTrue();
            if (mException.get() != null) {
                throw mException.get();
            }
        }

        @Override
        public void onResult(T result) {
            mResponse.set(result);
            mLatch.countDown();
        }

        @Override
        public void onError(@NonNull E error) {
            mException.set(error);
            Log.e(TAG, error.getMessage());
            mLatch.countDown();
        }
    }

    private static final class HealthConnectReceiver<T>
            extends TestReceiver<T, HealthConnectException> {}

    private static final class MigrationReceiver extends TestReceiver<Void, MigrationException> {}
}