315 lines
11 KiB
Java
315 lines
11 KiB
Java
/*
|
|
* Copyright (C) 2022 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.safetycenter;
|
|
|
|
import static android.os.Build.VERSION_CODES.TIRAMISU;
|
|
|
|
import static java.util.Objects.requireNonNull;
|
|
|
|
import android.annotation.IntDef;
|
|
import android.annotation.NonNull;
|
|
import android.annotation.SystemApi;
|
|
import android.os.Parcel;
|
|
import android.os.Parcelable;
|
|
import android.text.TextUtils;
|
|
|
|
import androidx.annotation.RequiresApi;
|
|
|
|
import java.lang.annotation.Retention;
|
|
import java.lang.annotation.RetentionPolicy;
|
|
import java.util.Objects;
|
|
|
|
/**
|
|
* The overall status of the Safety Center.
|
|
*
|
|
* @hide
|
|
*/
|
|
@SystemApi
|
|
@RequiresApi(TIRAMISU)
|
|
public final class SafetyCenterStatus implements Parcelable {
|
|
|
|
/** Indicates the overall severity level of the Safety Center is not currently known. */
|
|
public static final int OVERALL_SEVERITY_LEVEL_UNKNOWN = 1000;
|
|
|
|
/**
|
|
* Indicates the overall safety status of the device is OK and there are no actionable issues.
|
|
*/
|
|
public static final int OVERALL_SEVERITY_LEVEL_OK = 1100;
|
|
|
|
/** Indicates the presence of safety recommendations which the user is encouraged to act on. */
|
|
public static final int OVERALL_SEVERITY_LEVEL_RECOMMENDATION = 1200;
|
|
|
|
/** Indicates the presence of critical safety warnings on the device. */
|
|
public static final int OVERALL_SEVERITY_LEVEL_CRITICAL_WARNING = 1300;
|
|
|
|
/**
|
|
* All possible overall severity levels for the Safety Center.
|
|
*
|
|
* <p>The overall severity level is calculated from the severity level and statuses of all
|
|
* issues and entries in the Safety Center.
|
|
*
|
|
* @hide
|
|
* @see #getSeverityLevel()
|
|
* @see Builder#setSeverityLevel(int)
|
|
*/
|
|
@Retention(RetentionPolicy.SOURCE)
|
|
@IntDef(
|
|
prefix = "OVERALL_SEVERITY_LEVEL_",
|
|
value = {
|
|
OVERALL_SEVERITY_LEVEL_UNKNOWN,
|
|
OVERALL_SEVERITY_LEVEL_OK,
|
|
OVERALL_SEVERITY_LEVEL_RECOMMENDATION,
|
|
OVERALL_SEVERITY_LEVEL_CRITICAL_WARNING,
|
|
})
|
|
public @interface OverallSeverityLevel {}
|
|
|
|
/** Indicates that no refresh is ongoing. */
|
|
public static final int REFRESH_STATUS_NONE = 0;
|
|
|
|
/**
|
|
* Indicates that a data fetch is ongoing, and Safety Sources are being asked for their current
|
|
* safety state.
|
|
*
|
|
* <p>If sources already have their safety data cached, they may provide it without triggering a
|
|
* process to fetch or recompute state which may be expensive and/or slow.
|
|
*/
|
|
public static final int REFRESH_STATUS_DATA_FETCH_IN_PROGRESS = 10100;
|
|
|
|
/**
|
|
* Indicates that a full rescan is ongoing, and Safety Sources are being asked to fetch fresh
|
|
* data for their safety state.
|
|
*
|
|
* <p>The term "fresh" here means that the sources should ensure that the safety data is
|
|
* accurate as possible at the time of providing it to Safety Center, even if it involves
|
|
* performing an expensive and/or slow process.
|
|
*/
|
|
public static final int REFRESH_STATUS_FULL_RESCAN_IN_PROGRESS = 10200;
|
|
|
|
/**
|
|
* All possible refresh states for the Safety Center.
|
|
*
|
|
* @hide
|
|
* @see #getRefreshStatus()
|
|
* @see Builder#setRefreshStatus(int)
|
|
*/
|
|
@Retention(RetentionPolicy.SOURCE)
|
|
@IntDef(
|
|
prefix = "REFRESH_STATUS_",
|
|
value = {
|
|
REFRESH_STATUS_NONE,
|
|
REFRESH_STATUS_DATA_FETCH_IN_PROGRESS,
|
|
REFRESH_STATUS_FULL_RESCAN_IN_PROGRESS,
|
|
})
|
|
public @interface RefreshStatus {}
|
|
|
|
@NonNull
|
|
public static final Creator<SafetyCenterStatus> CREATOR =
|
|
new Creator<SafetyCenterStatus>() {
|
|
@Override
|
|
public SafetyCenterStatus createFromParcel(Parcel in) {
|
|
CharSequence title = TextUtils.CHAR_SEQUENCE_CREATOR.createFromParcel(in);
|
|
CharSequence summary = TextUtils.CHAR_SEQUENCE_CREATOR.createFromParcel(in);
|
|
return new Builder(title, summary)
|
|
.setSeverityLevel(in.readInt())
|
|
.setRefreshStatus(in.readInt())
|
|
.build();
|
|
}
|
|
|
|
@Override
|
|
public SafetyCenterStatus[] newArray(int size) {
|
|
return new SafetyCenterStatus[size];
|
|
}
|
|
};
|
|
|
|
@NonNull private final CharSequence mTitle;
|
|
@NonNull private final CharSequence mSummary;
|
|
@OverallSeverityLevel private final int mSeverityLevel;
|
|
@RefreshStatus private final int mRefreshStatus;
|
|
|
|
private SafetyCenterStatus(
|
|
@NonNull CharSequence title,
|
|
@NonNull CharSequence summary,
|
|
@OverallSeverityLevel int severityLevel,
|
|
@RefreshStatus int refreshStatus) {
|
|
mTitle = title;
|
|
mSummary = summary;
|
|
mSeverityLevel = severityLevel;
|
|
mRefreshStatus = refreshStatus;
|
|
}
|
|
|
|
/** Returns the title which describes the overall safety state of the device. */
|
|
@NonNull
|
|
public CharSequence getTitle() {
|
|
return mTitle;
|
|
}
|
|
|
|
/** Returns the summary text which adds detail to the overall safety state of the device. */
|
|
@NonNull
|
|
public CharSequence getSummary() {
|
|
return mSummary;
|
|
}
|
|
|
|
/** Returns the current {@link OverallSeverityLevel} of the Safety Center. */
|
|
@OverallSeverityLevel
|
|
public int getSeverityLevel() {
|
|
return mSeverityLevel;
|
|
}
|
|
|
|
/** Returns the current {@link RefreshStatus} of the Safety Center */
|
|
@RefreshStatus
|
|
public int getRefreshStatus() {
|
|
return mRefreshStatus;
|
|
}
|
|
|
|
@Override
|
|
public boolean equals(Object o) {
|
|
if (this == o) return true;
|
|
if (!(o instanceof SafetyCenterStatus)) return false;
|
|
SafetyCenterStatus that = (SafetyCenterStatus) o;
|
|
return mSeverityLevel == that.mSeverityLevel
|
|
&& mRefreshStatus == that.mRefreshStatus
|
|
&& TextUtils.equals(mTitle, that.mTitle)
|
|
&& TextUtils.equals(mSummary, that.mSummary);
|
|
}
|
|
|
|
@Override
|
|
public int hashCode() {
|
|
return Objects.hash(mTitle, mSummary, mSeverityLevel, mRefreshStatus);
|
|
}
|
|
|
|
@Override
|
|
public String toString() {
|
|
return "SafetyCenterStatus{"
|
|
+ "mTitle="
|
|
+ mTitle
|
|
+ ", mSummary="
|
|
+ mSummary
|
|
+ ", mSeverityLevel="
|
|
+ mSeverityLevel
|
|
+ ", mRefreshStatus="
|
|
+ mRefreshStatus
|
|
+ '}';
|
|
}
|
|
|
|
@Override
|
|
public int describeContents() {
|
|
return 0;
|
|
}
|
|
|
|
@Override
|
|
public void writeToParcel(@NonNull Parcel dest, int flags) {
|
|
TextUtils.writeToParcel(mTitle, dest, flags);
|
|
TextUtils.writeToParcel(mSummary, dest, flags);
|
|
dest.writeInt(mSeverityLevel);
|
|
dest.writeInt(mRefreshStatus);
|
|
}
|
|
|
|
/** Builder class for {@link SafetyCenterStatus}. */
|
|
public static final class Builder {
|
|
|
|
@NonNull private CharSequence mTitle;
|
|
@NonNull private CharSequence mSummary;
|
|
@OverallSeverityLevel private int mSeverityLevel = OVERALL_SEVERITY_LEVEL_UNKNOWN;
|
|
@RefreshStatus private int mRefreshStatus = REFRESH_STATUS_NONE;
|
|
|
|
/**
|
|
* Creates a new {@link Builder} for a {@link SafetyCenterStatus}.
|
|
*
|
|
* @param title an overall title for the status
|
|
* @param summary a summary for the status
|
|
*/
|
|
public Builder(@NonNull CharSequence title, @NonNull CharSequence summary) {
|
|
mTitle = requireNonNull(title);
|
|
mSummary = requireNonNull(summary);
|
|
}
|
|
|
|
/** Creates a {@link Builder} with the values from the given {@link SafetyCenterStatus}. */
|
|
public Builder(@NonNull SafetyCenterStatus safetyCenterStatus) {
|
|
mTitle = safetyCenterStatus.mTitle;
|
|
mSummary = safetyCenterStatus.mSummary;
|
|
mSeverityLevel = safetyCenterStatus.mSeverityLevel;
|
|
mRefreshStatus = safetyCenterStatus.mRefreshStatus;
|
|
}
|
|
|
|
/** Sets the title for this status. */
|
|
@NonNull
|
|
public Builder setTitle(@NonNull CharSequence title) {
|
|
mTitle = requireNonNull(title);
|
|
return this;
|
|
}
|
|
|
|
/** Sets the summary text for this status. */
|
|
@NonNull
|
|
public Builder setSummary(@NonNull CharSequence summary) {
|
|
mSummary = requireNonNull(summary);
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Sets the {@link OverallSeverityLevel} of this status. Defaults to {@link
|
|
* #OVERALL_SEVERITY_LEVEL_UNKNOWN}.
|
|
*/
|
|
@NonNull
|
|
public Builder setSeverityLevel(@OverallSeverityLevel int severityLevel) {
|
|
mSeverityLevel = validateOverallSeverityLevel(severityLevel);
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Sets the {@link RefreshStatus} of this status. Defaults to {@link #REFRESH_STATUS_NONE}.
|
|
*/
|
|
@NonNull
|
|
public Builder setRefreshStatus(@RefreshStatus int refreshStatus) {
|
|
mRefreshStatus = validateRefreshStatus(refreshStatus);
|
|
return this;
|
|
}
|
|
|
|
/** Creates the {@link SafetyCenterStatus} defined by this {@link Builder}. */
|
|
@NonNull
|
|
public SafetyCenterStatus build() {
|
|
return new SafetyCenterStatus(mTitle, mSummary, mSeverityLevel, mRefreshStatus);
|
|
}
|
|
}
|
|
|
|
@OverallSeverityLevel
|
|
private static int validateOverallSeverityLevel(int value) {
|
|
switch (value) {
|
|
case OVERALL_SEVERITY_LEVEL_UNKNOWN:
|
|
case OVERALL_SEVERITY_LEVEL_OK:
|
|
case OVERALL_SEVERITY_LEVEL_RECOMMENDATION:
|
|
case OVERALL_SEVERITY_LEVEL_CRITICAL_WARNING:
|
|
return value;
|
|
default:
|
|
}
|
|
throw new IllegalArgumentException(
|
|
"Unexpected OverallSeverityLevel for SafetyCenterStatus: " + value);
|
|
}
|
|
|
|
@RefreshStatus
|
|
private static int validateRefreshStatus(int value) {
|
|
switch (value) {
|
|
case REFRESH_STATUS_NONE:
|
|
case REFRESH_STATUS_DATA_FETCH_IN_PROGRESS:
|
|
case REFRESH_STATUS_FULL_RESCAN_IN_PROGRESS:
|
|
return value;
|
|
default:
|
|
}
|
|
throw new IllegalArgumentException(
|
|
"Unexpected RefreshStatus for SafetyCenterStatus: " + value);
|
|
}
|
|
}
|