707 lines
22 KiB
Java
707 lines
22 KiB
Java
/*
|
|
* Copyright (C) 2021 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.app.smartspace.uitemplatedata;
|
|
|
|
import android.annotation.NonNull;
|
|
import android.annotation.Nullable;
|
|
import android.annotation.SuppressLint;
|
|
import android.annotation.SystemApi;
|
|
import android.app.smartspace.SmartspaceTarget.FeatureType;
|
|
import android.app.smartspace.SmartspaceTarget.UiTemplateType;
|
|
import android.app.smartspace.SmartspaceUtils;
|
|
import android.os.Parcel;
|
|
import android.os.Parcelable;
|
|
import android.text.TextUtils;
|
|
|
|
import java.util.Objects;
|
|
|
|
/**
|
|
* Holds all the relevant data needed to render a Smartspace card with the default Ui Template.
|
|
* <ul>
|
|
* <li> title_text (may contain a start drawable) </li>
|
|
* <li> subtitle_text (may contain a start drawable) . supplemental_subtitle_text (may
|
|
* contain a start drawable) </li>
|
|
*
|
|
* <li> supplemental_text (contain a start drawable) . do_not_disturb_view </li>
|
|
* Or
|
|
* <li> next_alarm_text (contain a start drawable) + supplemental_alarm_text .
|
|
* do_not_disturb_view </li>
|
|
* </ul>
|
|
*
|
|
* @hide
|
|
*/
|
|
@SystemApi
|
|
@SuppressLint("ParcelNotFinal")
|
|
public class BaseTemplateData implements Parcelable {
|
|
|
|
/**
|
|
* {@link UiTemplateType} indicating the template type of this template data.
|
|
*
|
|
* @see UiTemplateType
|
|
*/
|
|
@UiTemplateType
|
|
private final int mTemplateType;
|
|
|
|
/**
|
|
* Title text and title icon are shown at the first row. When both are absent, the date view
|
|
* will be used, which has its own tap action applied to the title area.
|
|
*
|
|
* Primary tap action for the entire card, including the blank spaces, except: 1. When title is
|
|
* absent, the date view's default tap action is used; 2. Subtitle/Supplemental subtitle uses
|
|
* its own tap action if being set; 3. Secondary card uses its own tap action if being set.
|
|
*/
|
|
@Nullable
|
|
private final SubItemInfo mPrimaryItem;
|
|
|
|
|
|
/** Subtitle text and icon are shown at the second row. */
|
|
@Nullable
|
|
private final SubItemInfo mSubtitleItem;
|
|
|
|
/**
|
|
* Supplemental subtitle text and icon are shown at the second row following the subtitle text.
|
|
* Mainly used for weather info on non-weather card.
|
|
*/
|
|
@Nullable
|
|
private final SubItemInfo mSubtitleSupplementalItem;
|
|
|
|
/**
|
|
* Supplemental line is shown at the third row.
|
|
*/
|
|
@Nullable
|
|
private final SubItemInfo mSupplementalLineItem;
|
|
|
|
/**
|
|
* Supplemental alarm item is specifically used for holiday alarm, which is appended to "next
|
|
* alarm". This is also shown at the third row, but won't be shown the same time with
|
|
* mSupplementalLineItem.
|
|
*/
|
|
@Nullable
|
|
private final SubItemInfo mSupplementalAlarmItem;
|
|
|
|
/**
|
|
* The layout weight info for the card, which indicates how much space it should occupy on the
|
|
* screen. Default weight is 0.
|
|
*/
|
|
private final int mLayoutWeight;
|
|
|
|
BaseTemplateData(@NonNull Parcel in) {
|
|
mTemplateType = in.readInt();
|
|
mPrimaryItem = in.readTypedObject(SubItemInfo.CREATOR);
|
|
mSubtitleItem = in.readTypedObject(SubItemInfo.CREATOR);
|
|
mSubtitleSupplementalItem = in.readTypedObject(SubItemInfo.CREATOR);
|
|
mSupplementalLineItem = in.readTypedObject(SubItemInfo.CREATOR);
|
|
mSupplementalAlarmItem = in.readTypedObject(SubItemInfo.CREATOR);
|
|
mLayoutWeight = in.readInt();
|
|
}
|
|
|
|
/**
|
|
* Should ONLY used by subclasses. For the general instance creation, please use
|
|
* SmartspaceDefaultUiTemplateData.Builder.
|
|
*/
|
|
BaseTemplateData(@UiTemplateType int templateType,
|
|
@Nullable SubItemInfo primaryItem,
|
|
@Nullable SubItemInfo subtitleItem,
|
|
@Nullable SubItemInfo subtitleSupplementalItem,
|
|
@Nullable SubItemInfo supplementalLineItem,
|
|
@Nullable SubItemInfo supplementalAlarmItem,
|
|
int layoutWeight) {
|
|
mTemplateType = templateType;
|
|
mPrimaryItem = primaryItem;
|
|
mSubtitleItem = subtitleItem;
|
|
mSubtitleSupplementalItem = subtitleSupplementalItem;
|
|
mSupplementalLineItem = supplementalLineItem;
|
|
mSupplementalAlarmItem = supplementalAlarmItem;
|
|
mLayoutWeight = layoutWeight;
|
|
}
|
|
|
|
/** Returns the template type. By default is UNDEFINED. */
|
|
@UiTemplateType
|
|
public int getTemplateType() {
|
|
return mTemplateType;
|
|
}
|
|
|
|
/** Returns the primary item (the first line). */
|
|
@Nullable
|
|
public SubItemInfo getPrimaryItem() {
|
|
return mPrimaryItem;
|
|
}
|
|
|
|
/** Returns the subtitle item (the second line). */
|
|
@Nullable
|
|
public SubItemInfo getSubtitleItem() {
|
|
return mSubtitleItem;
|
|
}
|
|
|
|
/** Returns the subtitle's supplemental item (the second line following the subtitle). */
|
|
@Nullable
|
|
public SubItemInfo getSubtitleSupplementalItem() {
|
|
return mSubtitleSupplementalItem;
|
|
}
|
|
|
|
/** Returns the supplemental line item (the 3rd line). */
|
|
@Nullable
|
|
public SubItemInfo getSupplementalLineItem() {
|
|
return mSupplementalLineItem;
|
|
}
|
|
|
|
/** Returns the supplemental alarm item (the 3rd line). */
|
|
@Nullable
|
|
public SubItemInfo getSupplementalAlarmItem() {
|
|
return mSupplementalAlarmItem;
|
|
}
|
|
|
|
/** Returns the card layout weight info. Default weight is 0. */
|
|
public int getLayoutWeight() {
|
|
return mLayoutWeight;
|
|
}
|
|
|
|
/**
|
|
* @see Parcelable.Creator
|
|
*/
|
|
@NonNull
|
|
public static final Creator<BaseTemplateData> CREATOR =
|
|
new Creator<BaseTemplateData>() {
|
|
@Override
|
|
public BaseTemplateData createFromParcel(Parcel in) {
|
|
return new BaseTemplateData(in);
|
|
}
|
|
|
|
@Override
|
|
public BaseTemplateData[] newArray(int size) {
|
|
return new BaseTemplateData[size];
|
|
}
|
|
};
|
|
|
|
@Override
|
|
public int describeContents() {
|
|
return 0;
|
|
}
|
|
|
|
@Override
|
|
public void writeToParcel(@NonNull Parcel out, int flags) {
|
|
out.writeInt(mTemplateType);
|
|
out.writeTypedObject(mPrimaryItem, flags);
|
|
out.writeTypedObject(mSubtitleItem, flags);
|
|
out.writeTypedObject(mSubtitleSupplementalItem, flags);
|
|
out.writeTypedObject(mSupplementalLineItem, flags);
|
|
out.writeTypedObject(mSupplementalAlarmItem, flags);
|
|
out.writeInt(mLayoutWeight);
|
|
}
|
|
|
|
@Override
|
|
public boolean equals(Object o) {
|
|
if (this == o) return true;
|
|
if (!(o instanceof BaseTemplateData)) return false;
|
|
BaseTemplateData that = (BaseTemplateData) o;
|
|
return mTemplateType == that.mTemplateType && mLayoutWeight == that.mLayoutWeight
|
|
&& Objects.equals(mPrimaryItem, that.mPrimaryItem)
|
|
&& Objects.equals(mSubtitleItem, that.mSubtitleItem)
|
|
&& Objects.equals(mSubtitleSupplementalItem, that.mSubtitleSupplementalItem)
|
|
&& Objects.equals(mSupplementalLineItem, that.mSupplementalLineItem)
|
|
&& Objects.equals(mSupplementalAlarmItem, that.mSupplementalAlarmItem);
|
|
}
|
|
|
|
@Override
|
|
public int hashCode() {
|
|
return Objects.hash(mTemplateType, mPrimaryItem, mSubtitleItem, mSubtitleSupplementalItem,
|
|
mSupplementalLineItem, mSupplementalAlarmItem, mLayoutWeight);
|
|
}
|
|
|
|
@Override
|
|
public String toString() {
|
|
return "BaseTemplateData{"
|
|
+ "mTemplateType=" + mTemplateType
|
|
+ ", mPrimaryItem=" + mPrimaryItem
|
|
+ ", mSubtitleItem=" + mSubtitleItem
|
|
+ ", mSubtitleSupplementalItem=" + mSubtitleSupplementalItem
|
|
+ ", mSupplementalLineItem=" + mSupplementalLineItem
|
|
+ ", mSupplementalAlarmItem=" + mSupplementalAlarmItem
|
|
+ ", mLayoutWeight=" + mLayoutWeight
|
|
+ '}';
|
|
}
|
|
|
|
/**
|
|
* A builder for {@link BaseTemplateData} object.
|
|
*
|
|
* @hide
|
|
*/
|
|
@SystemApi
|
|
@SuppressLint("StaticFinalBuilder")
|
|
public static class Builder {
|
|
@UiTemplateType
|
|
private final int mTemplateType;
|
|
|
|
private SubItemInfo mPrimaryItem;
|
|
private SubItemInfo mSubtitleItem;
|
|
private SubItemInfo mSubtitleSupplementalItem;
|
|
private SubItemInfo mSupplementalLineItem;
|
|
private SubItemInfo mSupplementalAlarmItem;
|
|
private int mLayoutWeight;
|
|
|
|
/**
|
|
* A builder for {@link BaseTemplateData}. By default sets the layout weight to be 0.
|
|
*
|
|
* @param templateType the {@link UiTemplateType} of this template data.
|
|
*/
|
|
public Builder(@UiTemplateType int templateType) {
|
|
mTemplateType = templateType;
|
|
mLayoutWeight = 0;
|
|
}
|
|
|
|
/** Should ONLY be used by the subclasses */
|
|
@UiTemplateType
|
|
@SuppressLint("GetterOnBuilder")
|
|
int getTemplateType() {
|
|
return mTemplateType;
|
|
}
|
|
|
|
/** Should ONLY be used by the subclasses */
|
|
@Nullable
|
|
@SuppressLint("GetterOnBuilder")
|
|
SubItemInfo getPrimaryItem() {
|
|
return mPrimaryItem;
|
|
}
|
|
|
|
/** Should ONLY be used by the subclasses */
|
|
@Nullable
|
|
@SuppressLint("GetterOnBuilder")
|
|
SubItemInfo getSubtitleItem() {
|
|
return mSubtitleItem;
|
|
}
|
|
|
|
/** Should ONLY be used by the subclasses */
|
|
@Nullable
|
|
@SuppressLint("GetterOnBuilder")
|
|
SubItemInfo getSubtitleSupplemtnalItem() {
|
|
return mSubtitleSupplementalItem;
|
|
}
|
|
|
|
/** Should ONLY be used by the subclasses */
|
|
@Nullable
|
|
@SuppressLint("GetterOnBuilder")
|
|
SubItemInfo getSupplementalLineItem() {
|
|
return mSupplementalLineItem;
|
|
}
|
|
|
|
/** Should ONLY be used by the subclasses */
|
|
@Nullable
|
|
@SuppressLint("GetterOnBuilder")
|
|
SubItemInfo getSupplementalAlarmItem() {
|
|
return mSupplementalAlarmItem;
|
|
}
|
|
|
|
/** Should ONLY be used by the subclasses */
|
|
@SuppressLint("GetterOnBuilder")
|
|
int getLayoutWeight() {
|
|
return mLayoutWeight;
|
|
}
|
|
|
|
/**
|
|
* Sets the card primary item.
|
|
*/
|
|
@NonNull
|
|
public Builder setPrimaryItem(@NonNull SubItemInfo primaryItem) {
|
|
mPrimaryItem = primaryItem;
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Sets the card subtitle item.
|
|
*/
|
|
@NonNull
|
|
public Builder setSubtitleItem(@NonNull SubItemInfo subtitleItem) {
|
|
mSubtitleItem = subtitleItem;
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Sets the card subtitle's supplemental item.
|
|
*/
|
|
@NonNull
|
|
public Builder setSubtitleSupplementalItem(@NonNull SubItemInfo subtitleSupplementalItem) {
|
|
mSubtitleSupplementalItem = subtitleSupplementalItem;
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Sets the card supplemental line item.
|
|
*/
|
|
@NonNull
|
|
public Builder setSupplementalLineItem(@NonNull SubItemInfo supplementalLineItem) {
|
|
mSupplementalLineItem = supplementalLineItem;
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Sets the card supplemental alarm item.
|
|
*/
|
|
@NonNull
|
|
public Builder setSupplementalAlarmItem(@NonNull SubItemInfo supplementalAlarmItem) {
|
|
mSupplementalAlarmItem = supplementalAlarmItem;
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Sets the layout weight.
|
|
*/
|
|
@NonNull
|
|
public Builder setLayoutWeight(int layoutWeight) {
|
|
mLayoutWeight = layoutWeight;
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Builds a new SmartspaceDefaultUiTemplateData instance.
|
|
*/
|
|
@NonNull
|
|
public BaseTemplateData build() {
|
|
return new BaseTemplateData(
|
|
mTemplateType,
|
|
mPrimaryItem,
|
|
mSubtitleItem,
|
|
mSubtitleSupplementalItem,
|
|
mSupplementalLineItem,
|
|
mSupplementalAlarmItem,
|
|
mLayoutWeight);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Holds all the rendering and logging info needed for a sub item within the base card.
|
|
*/
|
|
public static final class SubItemInfo implements Parcelable {
|
|
|
|
/** The text information for the subitem, which will be rendered as it's text content. */
|
|
@Nullable
|
|
private final Text mText;
|
|
|
|
/** The icon for the subitem, which will be rendered as a drawable in front of the text. */
|
|
@Nullable
|
|
private final Icon mIcon;
|
|
|
|
/** The tap action for the subitem. */
|
|
@Nullable
|
|
private final TapAction mTapAction;
|
|
|
|
/** The logging info for the subitem. */
|
|
@Nullable
|
|
private final SubItemLoggingInfo mLoggingInfo;
|
|
|
|
SubItemInfo(@NonNull Parcel in) {
|
|
mText = in.readTypedObject(Text.CREATOR);
|
|
mIcon = in.readTypedObject(Icon.CREATOR);
|
|
mTapAction = in.readTypedObject(TapAction.CREATOR);
|
|
mLoggingInfo = in.readTypedObject(SubItemLoggingInfo.CREATOR);
|
|
}
|
|
|
|
private SubItemInfo(@Nullable Text text,
|
|
@Nullable Icon icon,
|
|
@Nullable TapAction tapAction,
|
|
@Nullable SubItemLoggingInfo loggingInfo) {
|
|
mText = text;
|
|
mIcon = icon;
|
|
mTapAction = tapAction;
|
|
mLoggingInfo = loggingInfo;
|
|
}
|
|
|
|
/** Returns the subitem's text. */
|
|
@Nullable
|
|
public Text getText() {
|
|
return mText;
|
|
}
|
|
|
|
/** Returns the subitem's icon. */
|
|
@Nullable
|
|
public Icon getIcon() {
|
|
return mIcon;
|
|
}
|
|
|
|
/** Returns the subitem's tap action. */
|
|
@Nullable
|
|
public TapAction getTapAction() {
|
|
return mTapAction;
|
|
}
|
|
|
|
/** Returns the subitem's logging info. */
|
|
@Nullable
|
|
public SubItemLoggingInfo getLoggingInfo() {
|
|
return mLoggingInfo;
|
|
}
|
|
|
|
/**
|
|
* @see Parcelable.Creator
|
|
*/
|
|
@NonNull
|
|
public static final Creator<SubItemInfo> CREATOR =
|
|
new Creator<SubItemInfo>() {
|
|
@Override
|
|
public SubItemInfo createFromParcel(Parcel in) {
|
|
return new SubItemInfo(in);
|
|
}
|
|
|
|
@Override
|
|
public SubItemInfo[] newArray(int size) {
|
|
return new SubItemInfo[size];
|
|
}
|
|
};
|
|
|
|
@Override
|
|
public int describeContents() {
|
|
return 0;
|
|
}
|
|
|
|
@Override
|
|
public void writeToParcel(@NonNull Parcel out, int flags) {
|
|
out.writeTypedObject(mText, flags);
|
|
out.writeTypedObject(mIcon, flags);
|
|
out.writeTypedObject(mTapAction, flags);
|
|
out.writeTypedObject(mLoggingInfo, flags);
|
|
}
|
|
|
|
@Override
|
|
public boolean equals(Object o) {
|
|
if (this == o) return true;
|
|
if (!(o instanceof SubItemInfo)) return false;
|
|
SubItemInfo that = (SubItemInfo) o;
|
|
return SmartspaceUtils.isEqual(mText, that.mText) && Objects.equals(mIcon,
|
|
that.mIcon) && Objects.equals(mTapAction, that.mTapAction)
|
|
&& Objects.equals(mLoggingInfo, that.mLoggingInfo);
|
|
}
|
|
|
|
@Override
|
|
public int hashCode() {
|
|
return Objects.hash(mText, mIcon, mTapAction, mLoggingInfo);
|
|
}
|
|
|
|
@Override
|
|
public String toString() {
|
|
return "SubItemInfo{"
|
|
+ "mText=" + mText
|
|
+ ", mIcon=" + mIcon
|
|
+ ", mTapAction=" + mTapAction
|
|
+ ", mLoggingInfo=" + mLoggingInfo
|
|
+ '}';
|
|
}
|
|
|
|
/**
|
|
* A builder for {@link SubItemInfo} object.
|
|
*
|
|
* @hide
|
|
*/
|
|
@SystemApi
|
|
public static final class Builder {
|
|
|
|
private Text mText;
|
|
private Icon mIcon;
|
|
private TapAction mTapAction;
|
|
private SubItemLoggingInfo mLoggingInfo;
|
|
|
|
/**
|
|
* Sets the sub item's text.
|
|
*/
|
|
@NonNull
|
|
public Builder setText(@NonNull Text text) {
|
|
mText = text;
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Sets the sub item's icon.
|
|
*/
|
|
@NonNull
|
|
public Builder setIcon(@NonNull Icon icon) {
|
|
mIcon = icon;
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Sets the sub item's tap action.
|
|
*/
|
|
@NonNull
|
|
public Builder setTapAction(@NonNull TapAction tapAction) {
|
|
mTapAction = tapAction;
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Sets the sub item's logging info.
|
|
*/
|
|
@NonNull
|
|
public Builder setLoggingInfo(@NonNull SubItemLoggingInfo loggingInfo) {
|
|
mLoggingInfo = loggingInfo;
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Builds a new {@link SubItemInfo} instance.
|
|
*
|
|
* @throws IllegalStateException if all the data field is empty.
|
|
*/
|
|
@NonNull
|
|
public SubItemInfo build() {
|
|
if (SmartspaceUtils.isEmpty(mText) && mIcon == null && mTapAction == null
|
|
&& mLoggingInfo == null) {
|
|
throw new IllegalStateException("SubItem data is empty");
|
|
}
|
|
|
|
return new SubItemInfo(mText, mIcon, mTapAction, mLoggingInfo);
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Holds all the logging info needed for a sub item within the base card. For example, the
|
|
* supplemental-subtitle part should have its own logging info.
|
|
*/
|
|
public static final class SubItemLoggingInfo implements Parcelable {
|
|
|
|
/** A unique instance id for the sub item. */
|
|
private final int mInstanceId;
|
|
|
|
/**
|
|
* {@link FeatureType} indicating the feature type of this subitem.
|
|
*
|
|
* @see FeatureType
|
|
*/
|
|
@FeatureType
|
|
private final int mFeatureType;
|
|
|
|
/** The data source's package name for this sub item. */
|
|
@Nullable
|
|
private final CharSequence mPackageName;
|
|
|
|
SubItemLoggingInfo(@NonNull Parcel in) {
|
|
mInstanceId = in.readInt();
|
|
mFeatureType = in.readInt();
|
|
mPackageName = TextUtils.CHAR_SEQUENCE_CREATOR.createFromParcel(in);
|
|
}
|
|
|
|
private SubItemLoggingInfo(int instanceId, @FeatureType int featureType,
|
|
@Nullable CharSequence packageName) {
|
|
mInstanceId = instanceId;
|
|
mFeatureType = featureType;
|
|
mPackageName = packageName;
|
|
}
|
|
|
|
public int getInstanceId() {
|
|
return mInstanceId;
|
|
}
|
|
|
|
@FeatureType
|
|
public int getFeatureType() {
|
|
return mFeatureType;
|
|
}
|
|
|
|
@Nullable
|
|
public CharSequence getPackageName() {
|
|
return mPackageName;
|
|
}
|
|
|
|
/**
|
|
* @see Parcelable.Creator
|
|
*/
|
|
@NonNull
|
|
public static final Creator<SubItemLoggingInfo> CREATOR =
|
|
new Creator<SubItemLoggingInfo>() {
|
|
@Override
|
|
public SubItemLoggingInfo createFromParcel(Parcel in) {
|
|
return new SubItemLoggingInfo(in);
|
|
}
|
|
|
|
@Override
|
|
public SubItemLoggingInfo[] newArray(int size) {
|
|
return new SubItemLoggingInfo[size];
|
|
}
|
|
};
|
|
|
|
@Override
|
|
public int describeContents() {
|
|
return 0;
|
|
}
|
|
|
|
@Override
|
|
public void writeToParcel(@NonNull Parcel out, int flags) {
|
|
out.writeInt(mInstanceId);
|
|
out.writeInt(mFeatureType);
|
|
TextUtils.writeToParcel(mPackageName, out, flags);
|
|
}
|
|
|
|
@Override
|
|
public boolean equals(Object o) {
|
|
if (this == o) return true;
|
|
if (!(o instanceof SubItemLoggingInfo)) return false;
|
|
SubItemLoggingInfo that = (SubItemLoggingInfo) o;
|
|
return mInstanceId == that.mInstanceId && mFeatureType == that.mFeatureType
|
|
&& SmartspaceUtils.isEqual(mPackageName, that.mPackageName);
|
|
}
|
|
|
|
@Override
|
|
public int hashCode() {
|
|
return Objects.hash(mInstanceId, mFeatureType, mPackageName);
|
|
}
|
|
|
|
@Override
|
|
public String toString() {
|
|
return "SubItemLoggingInfo{"
|
|
+ "mInstanceId=" + mInstanceId
|
|
+ ", mFeatureType=" + mFeatureType
|
|
+ ", mPackageName=" + mPackageName
|
|
+ '}';
|
|
}
|
|
|
|
/**
|
|
* A builder for {@link SubItemLoggingInfo} object.
|
|
*
|
|
* @hide
|
|
*/
|
|
@SystemApi
|
|
public static final class Builder {
|
|
|
|
private final int mInstanceId;
|
|
private final int mFeatureType;
|
|
private CharSequence mPackageName;
|
|
|
|
/**
|
|
* A builder for {@link SubItemLoggingInfo}.
|
|
*
|
|
* @param instanceId A unique instance id for the sub item
|
|
* @param featureType The feature type id for this sub item
|
|
*/
|
|
public Builder(int instanceId, @FeatureType int featureType) {
|
|
mInstanceId = instanceId;
|
|
mFeatureType = featureType;
|
|
}
|
|
|
|
/**
|
|
* Sets the sub item's data source package name.
|
|
*/
|
|
@NonNull
|
|
public Builder setPackageName(@NonNull CharSequence packageName) {
|
|
mPackageName = packageName;
|
|
return this;
|
|
}
|
|
|
|
/** Builds a new {@link SubItemLoggingInfo} instance. */
|
|
@NonNull
|
|
public SubItemLoggingInfo build() {
|
|
return new SubItemLoggingInfo(mInstanceId, mFeatureType, mPackageName);
|
|
}
|
|
}
|
|
}
|
|
}
|