script-astra/Android/Sdk/sources/android-35/android/health/connect/changelog/ChangeLogTokenRequest.java
localadmin 4380f00a78 init
2025-01-20 18:15:20 +03:00

214 lines
7.2 KiB
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.health.connect.changelog;
import android.annotation.NonNull;
import android.health.connect.HealthConnectManager;
import android.health.connect.datatypes.DataOrigin;
import android.health.connect.datatypes.Record;
import android.health.connect.datatypes.RecordTypeIdentifier;
import android.health.connect.internal.datatypes.utils.RecordMapper;
import android.os.Parcel;
import android.os.Parcelable;
import android.util.ArraySet;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Objects;
import java.util.Set;
import java.util.stream.Collectors;
/**
* A class to request changelog token using {@link HealthConnectManager#getChangeLogToken}
*
* @see HealthConnectManager#getChangeLogToken
*/
public final class ChangeLogTokenRequest implements Parcelable {
private final Set<DataOrigin> mDataOriginFilters;
private final Set<Class<? extends Record>> mRecordTypes;
/**
* @param dataOriginFilters list of package names to filter the data
* @param recordTypes list of records for which change log is required
*/
private ChangeLogTokenRequest(
@NonNull Set<DataOrigin> dataOriginFilters,
@NonNull Set<Class<? extends Record>> recordTypes) {
Objects.requireNonNull(recordTypes);
verifyRecordTypes(recordTypes);
Objects.requireNonNull(dataOriginFilters);
mDataOriginFilters = dataOriginFilters;
mRecordTypes = recordTypes;
}
private void verifyRecordTypes(Set<Class<? extends Record>> recordTypes) {
if (recordTypes.isEmpty()) {
throw new IllegalArgumentException("Requested record types must not be empty");
}
Set<String> invalidRecordTypes =
recordTypes.stream()
.filter(recordType -> !RecordMapper.getInstance().hasRecordType(recordType))
.map(Class::getName)
.collect(Collectors.toSet());
if (!invalidRecordTypes.isEmpty()) {
throw new IllegalArgumentException(
"Requested record types must not contain any of " + invalidRecordTypes);
}
}
private ChangeLogTokenRequest(@NonNull Parcel in) {
RecordMapper recordMapper = RecordMapper.getInstance();
Set<Class<? extends Record>> recordTypes = new ArraySet<>();
for (@RecordTypeIdentifier.RecordType int recordType : in.createIntArray()) {
recordTypes.add(recordMapper.getRecordIdToExternalRecordClassMap().get(recordType));
}
mRecordTypes = recordTypes;
Set<DataOrigin> dataOrigin = new ArraySet<>();
for (String packageName : in.createStringArrayList()) {
dataOrigin.add(new DataOrigin.Builder().setPackageName(packageName).build());
}
mDataOriginFilters = dataOrigin;
}
@NonNull
public static final Creator<ChangeLogTokenRequest> CREATOR =
new Creator<ChangeLogTokenRequest>() {
@Override
public ChangeLogTokenRequest createFromParcel(@NonNull Parcel in) {
return new ChangeLogTokenRequest(in);
}
@Override
public ChangeLogTokenRequest[] newArray(int size) {
return new ChangeLogTokenRequest[size];
}
};
/** Returns list of package names corresponding to which the logs are required */
@NonNull
public Set<DataOrigin> getDataOriginFilters() {
return mDataOriginFilters;
}
/** Returns list of record classes for which the logs are to be fetched */
@NonNull
public Set<Class<? extends Record>> getRecordTypes() {
return mRecordTypes;
}
/**
* Returns List of Record types for which logs are to be fetched
*
* @hide
*/
@NonNull
public int[] getRecordTypesArray() {
return getRecordTypesAsInteger();
}
/**
* Returns List of Record types for which logs are to be fetched
*
* @hide
*/
@NonNull
public List<Integer> getRecordTypesList() {
return Arrays.stream(getRecordTypesAsInteger()).boxed().collect(Collectors.toList());
}
/**
* Returns list of package names corresponding to which the logs are required
*
* @hide
*/
@NonNull
public List<String> getPackageNamesToFilter() {
return getPackageNames();
}
@Override
public int describeContents() {
return 0;
}
@Override
public void writeToParcel(@NonNull Parcel dest, int flags) {
dest.writeIntArray(getRecordTypesAsInteger());
dest.writeStringList(getPackageNames());
}
@NonNull
private int[] getRecordTypesAsInteger() {
int[] recordTypes = new int[mRecordTypes.size()];
int index = 0;
for (Class<? extends Record> recordClass : mRecordTypes) {
recordTypes[index++] = RecordMapper.getInstance().getRecordType(recordClass);
}
return recordTypes;
}
@NonNull
private List<String> getPackageNames() {
List<String> packageNamesToFilter = new ArrayList<>(mDataOriginFilters.size());
mDataOriginFilters.forEach(
(dataOrigin) -> packageNamesToFilter.add(dataOrigin.getPackageName()));
return packageNamesToFilter;
}
/** Builder for {@link ChangeLogTokenRequest} */
public static final class Builder {
private final Set<Class<? extends Record>> mRecordTypes = new ArraySet<>();
private final Set<DataOrigin> mDataOriginFilters = new ArraySet<>();
/**
* @param recordType type of record for which change log is required. At least one record
* type must be set.
*/
@NonNull
public Builder addRecordType(@NonNull Class<? extends Record> recordType) {
Objects.requireNonNull(recordType);
mRecordTypes.add(recordType);
return this;
}
/**
* @param dataOriginFilter list of package names on which to filter the data.
* <p>If not set logs from all the sources will be returned
*/
@NonNull
public Builder addDataOriginFilter(@NonNull DataOrigin dataOriginFilter) {
Objects.requireNonNull(dataOriginFilter);
mDataOriginFilters.add(dataOriginFilter);
return this;
}
/**
* Returns Object of {@link ChangeLogTokenRequest}
*
* @throws IllegalArgumentException if record types are empty
*/
@NonNull
public ChangeLogTokenRequest build() {
return new ChangeLogTokenRequest(mDataOriginFilters, mRecordTypes);
}
}
}