android-34/android/health/connect/accesslog/AccessLog.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.accesslog;

import android.annotation.IntDef;
import android.annotation.NonNull;
import android.annotation.SystemApi;
import android.health.connect.Constants;
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 java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.time.Instant;
import java.util.ArrayList;
import java.util.List;
import java.util.Objects;

/**
 * A class to represent access log which is logged whenever a package requests a read on a record
 * type
 *
 * @hide
 */
@SystemApi
public final class AccessLog implements Parcelable {
    private final List<Class<? extends Record>> mRecordTypesList = new ArrayList<>();
    private final String mPackageName;
    private final Instant mAccessTime;
    @OperationType.OperationTypes private final int mOperationType;

    /**
     * Creates an access logs object that can be used to get access log request for {@code
     * packageName}
     *
     * @param packageName name of the package that requested an access
     * @param recordTypes List of Record class type the was accessed
     * @param accessTimeInMillis time when the access was requested
     * @param operationType Type of access
     * @hide
     */
    public AccessLog(
            @NonNull String packageName,
            @NonNull @RecordTypeIdentifier.RecordType List<Integer> recordTypes,
            long accessTimeInMillis,
            @OperationType.OperationTypes int operationType) {
        Objects.requireNonNull(packageName);
        Objects.requireNonNull(recordTypes);

        mPackageName = packageName;
        RecordMapper recordMapper = RecordMapper.getInstance();
        for (@RecordTypeIdentifier.RecordType int recordType : recordTypes) {
            mRecordTypesList.add(
                    recordMapper.getRecordIdToExternalRecordClassMap().get(recordType));
        }
        mAccessTime = Instant.ofEpochMilli(accessTimeInMillis);
        mOperationType = operationType;
    }

    private AccessLog(Parcel in) {
        RecordMapper recordMapper = RecordMapper.getInstance();
        for (@RecordTypeIdentifier.RecordType int recordType : in.createIntArray()) {
            mRecordTypesList.add(
                    recordMapper.getRecordIdToExternalRecordClassMap().get(recordType));
        }
        mPackageName = in.readString();
        mAccessTime = Instant.ofEpochMilli(in.readLong());
        mOperationType = in.readInt();
    }

    @NonNull
    public static final Creator<AccessLog> CREATOR =
            new Creator<>() {
                @Override
                public AccessLog createFromParcel(Parcel in) {
                    return new AccessLog(in);
                }

                @Override
                public AccessLog[] newArray(int size) {
                    return new AccessLog[size];
                }
            };

    /** Returns List of Record types that was accessed by the app */
    @NonNull
    public List<Class<? extends Record>> getRecordTypes() {
        return mRecordTypesList;
    }

    /** Returns package name of app that accessed the records */
    @NonNull
    public String getPackageName() {
        return mPackageName;
    }

    /** Returns the instant at which the app accessed the record */
    @NonNull
    public Instant getAccessTime() {
        return mAccessTime;
    }

    /** Returns the type of operation performed by the app */
    @OperationType.OperationTypes
    public int getOperationType() {
        return mOperationType;
    }

    /** Identifier for Operation type. */
    public static final class OperationType {

        /** Identifier for read operation done on user health data. */
        public static final int OPERATION_TYPE_READ = Constants.READ;

        /** Identifier for update or insert operation done on user health data. */
        public static final int OPERATION_TYPE_UPSERT = Constants.UPSERT;

        /** Identifier for delete operation done on user health data. */
        public static final int OPERATION_TYPE_DELETE = Constants.DELETE;

        /** @hide */
        @IntDef({OPERATION_TYPE_UPSERT, OPERATION_TYPE_DELETE, OPERATION_TYPE_READ})
        @Retention(RetentionPolicy.SOURCE)
        public @interface OperationTypes {}

        private OperationType() {}
    }

    @Override
    public int describeContents() {
        return 0;
    }

    /**
     * Flatten this object in to a Parcel.
     *
     * @param dest The Parcel in which the object should be written.
     * @param flags Additional flags about how the object should be written. May be 0 or {@link
     *     #PARCELABLE_WRITE_RETURN_VALUE}.
     */
    @Override
    public void writeToParcel(@NonNull Parcel dest, int flags) {
        int recordTypeCount = mRecordTypesList.size();
        RecordMapper recordMapper = RecordMapper.getInstance();
        @RecordTypeIdentifier.RecordType int[] recordTypes = new int[recordTypeCount];
        for (int i = 0; i < recordTypeCount; i++) {
            recordTypes[i] = recordMapper.getRecordType(mRecordTypesList.get(i));
        }
        dest.writeIntArray(recordTypes);
        dest.writeString(mPackageName);
        dest.writeLong(mAccessTime.toEpochMilli());
        dest.writeInt(mOperationType);
    }
}