Artifact androidx.wear.tiles:tiles:1.1.0-alpha07 it located at Google repository (https://maven.google.com/)
Builders for composable layout elements that can be combined together to create renderable UI
layouts.
Horizontal alignment is undefined.
Horizontally align to the left.
Horizontally align to center.
Horizontally align to the right.
Horizontally align to the content start (left in LTR layouts, right in RTL layouts).
Horizontally align to the content end (right in LTR layouts, left in RTL layouts).
Vertical alignment is undefined.
Vertically align to the top.
Vertically align to center.
Vertically align to the bottom.
Font weight is undefined.
Normal font weight.
Medium font weight.
Bold font weight.
Font variant is undefined.
Font variant suited for title text.
Font variant suited for body text.
Alignment is undefined.
Align to the bottom of the line (descent of the largest text in this line). If there is no
text in the line containing this image, this will align to the bottom of the line, where the
line height is defined as the height of the largest image in the line.
Alignment is undefined.
Overflow behavior is undefined.
Anchor position is undefined.
Anchor at the start of the elements. This will cause elements added to an arc to begin at the
given anchor_angle, and sweep around to the right.
Anchor at the center of the elements. This will cause the center of the whole set of elements
added to an arc to be pinned at the given anchor_angle.
Anchor at the end of the elements. This will cause the set of elements inside the arc to end
at the specified anchor_angle, i.e. all elements should be to the left of anchor_angle.
Content scaling is undefined.
Content will be scaled to fit inside its bounds, proportionally. As an example, If a 10x5
image was going to be drawn inside a 50x50 LayoutElementBuilders.Image element, the actual image resource
would be drawn as a 50x25 image, centered within the 50x50 bounds.
Content will be resized proportionally so it completely fills its bounds, and anything
outside of the bounds will be cropped. As an example, if a 10x5 image was going to be drawn
inside a 50x50 LayoutElementBuilders.Image element, the image resource would be drawn as a 100x50 image,
centered within its bounds (and with 25px cropped from both the left and right sides).
Content will be resized to fill its bounds, without taking into account the aspect ratio. If
a 10x5 image was going to be drawn inside a 50x50 LayoutElementBuilders.Image element, the image would be
drawn as a 50x50 image, stretched vertically.
/*
* Copyright 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 androidx.wear.tiles;
import static java.util.stream.Collectors.toList;
import android.annotation.SuppressLint;
import androidx.annotation.IntDef;
import androidx.annotation.IntRange;
import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
import androidx.annotation.OptIn;
import androidx.annotation.RestrictTo;
import androidx.annotation.RestrictTo.Scope;
import androidx.wear.tiles.ColorBuilders.ColorProp;
import androidx.wear.tiles.DeviceParametersBuilders.DeviceParameters;
import androidx.wear.tiles.DimensionBuilders.ContainerDimension;
import androidx.wear.tiles.DimensionBuilders.DegreesProp;
import androidx.wear.tiles.DimensionBuilders.DpProp;
import androidx.wear.tiles.DimensionBuilders.EmProp;
import androidx.wear.tiles.DimensionBuilders.ImageDimension;
import androidx.wear.tiles.DimensionBuilders.SpProp;
import androidx.wear.tiles.DimensionBuilders.SpacerDimension;
import androidx.wear.tiles.ModifiersBuilders.ArcModifiers;
import androidx.wear.tiles.ModifiersBuilders.Modifiers;
import androidx.wear.tiles.ModifiersBuilders.SpanModifiers;
import androidx.wear.tiles.TypeBuilders.BoolProp;
import androidx.wear.tiles.TypeBuilders.Int32Prop;
import androidx.wear.tiles.TypeBuilders.StringProp;
import androidx.wear.tiles.proto.LayoutElementProto;
import androidx.wear.tiles.proto.TypesProto;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.util.Collections;
import java.util.List;
/**
* Builders for composable layout elements that can be combined together to create renderable UI
* layouts.
*/
public final class LayoutElementBuilders {
private LayoutElementBuilders() {}
/**
* The horizontal alignment of an element within its container.
*
* @hide
*/
@RestrictTo(RestrictTo.Scope.LIBRARY)
@IntDef({
HORIZONTAL_ALIGN_UNDEFINED,
HORIZONTAL_ALIGN_LEFT,
HORIZONTAL_ALIGN_CENTER,
HORIZONTAL_ALIGN_RIGHT,
HORIZONTAL_ALIGN_START,
HORIZONTAL_ALIGN_END
})
@Retention(RetentionPolicy.SOURCE)
public @interface HorizontalAlignment {}
/** Horizontal alignment is undefined. */
public static final int HORIZONTAL_ALIGN_UNDEFINED = 0;
/** Horizontally align to the left. */
public static final int HORIZONTAL_ALIGN_LEFT = 1;
/** Horizontally align to center. */
public static final int HORIZONTAL_ALIGN_CENTER = 2;
/** Horizontally align to the right. */
public static final int HORIZONTAL_ALIGN_RIGHT = 3;
/** Horizontally align to the content start (left in LTR layouts, right in RTL layouts). */
public static final int HORIZONTAL_ALIGN_START = 4;
/** Horizontally align to the content end (right in LTR layouts, left in RTL layouts). */
public static final int HORIZONTAL_ALIGN_END = 5;
/**
* The vertical alignment of an element within its container.
*
* @hide
*/
@RestrictTo(RestrictTo.Scope.LIBRARY)
@IntDef({
VERTICAL_ALIGN_UNDEFINED,
VERTICAL_ALIGN_TOP,
VERTICAL_ALIGN_CENTER,
VERTICAL_ALIGN_BOTTOM
})
@Retention(RetentionPolicy.SOURCE)
public @interface VerticalAlignment {}
/** Vertical alignment is undefined. */
public static final int VERTICAL_ALIGN_UNDEFINED = 0;
/** Vertically align to the top. */
public static final int VERTICAL_ALIGN_TOP = 1;
/** Vertically align to center. */
public static final int VERTICAL_ALIGN_CENTER = 2;
/** Vertically align to the bottom. */
public static final int VERTICAL_ALIGN_BOTTOM = 3;
/**
* The weight to be applied to the font.
*
* @hide
*/
@RestrictTo(RestrictTo.Scope.LIBRARY)
@IntDef({FONT_WEIGHT_UNDEFINED, FONT_WEIGHT_NORMAL, FONT_WEIGHT_MEDIUM, FONT_WEIGHT_BOLD})
@Retention(RetentionPolicy.SOURCE)
@OptIn(markerClass = TilesExperimental.class)
public @interface FontWeight {}
/** Font weight is undefined. */
public static final int FONT_WEIGHT_UNDEFINED = 0;
/** Normal font weight. */
public static final int FONT_WEIGHT_NORMAL = 400;
/** Medium font weight. */
@TilesExperimental public static final int FONT_WEIGHT_MEDIUM = 500;
/** Bold font weight. */
public static final int FONT_WEIGHT_BOLD = 700;
/**
* The variant of a font. Some renderers may use different fonts for title and body text, which
* can be selected using this field.
*
* @hide
*/
@RestrictTo(RestrictTo.Scope.LIBRARY)
@IntDef({FONT_VARIANT_UNDEFINED, FONT_VARIANT_TITLE, FONT_VARIANT_BODY})
@Retention(RetentionPolicy.SOURCE)
public @interface FontVariant {}
/** Font variant is undefined. */
public static final int FONT_VARIANT_UNDEFINED = 0;
/** Font variant suited for title text. */
public static final int FONT_VARIANT_TITLE = 1;
/** Font variant suited for body text. */
public static final int FONT_VARIANT_BODY = 2;
/**
* The alignment of a {@link SpanImage} within the line height of the surrounding {@link
* Spannable}.
*
* @hide
*/
@RestrictTo(RestrictTo.Scope.LIBRARY)
@IntDef({
SPAN_VERTICAL_ALIGN_UNDEFINED,
SPAN_VERTICAL_ALIGN_BOTTOM,
SPAN_VERTICAL_ALIGN_TEXT_BASELINE
})
@Retention(RetentionPolicy.SOURCE)
public @interface SpanVerticalAlignment {}
/** Alignment is undefined. */
public static final int SPAN_VERTICAL_ALIGN_UNDEFINED = 0;
/**
* Align to the bottom of the line (descent of the largest text in this line). If there is no
* text in the line containing this image, this will align to the bottom of the line, where the
* line height is defined as the height of the largest image in the line.
*/
public static final int SPAN_VERTICAL_ALIGN_BOTTOM = 1;
/**
* Align to the baseline of the text. Note that if the line in the {@link Spannable} which
* contains this image does not contain any text, the effects of using this alignment are
* undefined.
*/
public static final int SPAN_VERTICAL_ALIGN_TEXT_BASELINE = 2;
/**
* Alignment of a text element.
*
* @hide
*/
@RestrictTo(RestrictTo.Scope.LIBRARY)
@IntDef({TEXT_ALIGN_UNDEFINED, TEXT_ALIGN_START, TEXT_ALIGN_CENTER, TEXT_ALIGN_END})
@Retention(RetentionPolicy.SOURCE)
public @interface TextAlignment {}
/** Alignment is undefined. */
public static final int TEXT_ALIGN_UNDEFINED = 0;
/**
* Align to the "start" of the {@link Text} element (left in LTR layouts, right in RTL layouts).
*/
public static final int TEXT_ALIGN_START = 1;
/** Align to the center of the {@link Text} element. */
public static final int TEXT_ALIGN_CENTER = 2;
/**
* Align to the "end" of the {@link Text} element (right in LTR layouts, left in RTL layouts).
*/
public static final int TEXT_ALIGN_END = 3;
/**
* How text that will not fit inside the bounds of a {@link Text} element will be handled.
*
* @hide
*/
@RestrictTo(RestrictTo.Scope.LIBRARY)
@IntDef({TEXT_OVERFLOW_UNDEFINED, TEXT_OVERFLOW_TRUNCATE, TEXT_OVERFLOW_ELLIPSIZE_END})
@Retention(RetentionPolicy.SOURCE)
public @interface TextOverflow {}
/** Overflow behavior is undefined. */
public static final int TEXT_OVERFLOW_UNDEFINED = 0;
/**
* Truncate the text to fit inside of the {@link Text} element's bounds. If text is truncated,
* it will be truncated on a word boundary.
*/
public static final int TEXT_OVERFLOW_TRUNCATE = 1;
/**
* Truncate the text to fit in the {@link Text} element's bounds, but add an ellipsis (i.e. ...)
* to the end of the text if it has been truncated.
*/
public static final int TEXT_OVERFLOW_ELLIPSIZE_END = 2;
/**
* The anchor position of an {@link Arc}'s elements. This is used to specify how elements added
* to an {@link Arc} should be laid out with respect to anchor_angle.
*
* <p>As an example, assume that the following diagrams are wrapped to an arc, and each
* represents an {@link Arc} element containing a single {@link Text} element. The {@link Text}
* element's anchor_angle is "0" for all cases.
*
* <pre>{@code
* ARC_ANCHOR_START:
* -180 0 180
* Hello World!
*
*
* ARC_ANCHOR_CENTER:
* -180 0 180
* Hello World!
*
* ARC_ANCHOR_END:
* -180 0 180
* Hello World!
*
* }</pre>
*
* @hide
*/
@RestrictTo(RestrictTo.Scope.LIBRARY)
@IntDef({ARC_ANCHOR_UNDEFINED, ARC_ANCHOR_START, ARC_ANCHOR_CENTER, ARC_ANCHOR_END})
@Retention(RetentionPolicy.SOURCE)
public @interface ArcAnchorType {}
/** Anchor position is undefined. */
public static final int ARC_ANCHOR_UNDEFINED = 0;
/**
* Anchor at the start of the elements. This will cause elements added to an arc to begin at the
* given anchor_angle, and sweep around to the right.
*/
public static final int ARC_ANCHOR_START = 1;
/**
* Anchor at the center of the elements. This will cause the center of the whole set of elements
* added to an arc to be pinned at the given anchor_angle.
*/
public static final int ARC_ANCHOR_CENTER = 2;
/**
* Anchor at the end of the elements. This will cause the set of elements inside the arc to end
* at the specified anchor_angle, i.e. all elements should be to the left of anchor_angle.
*/
public static final int ARC_ANCHOR_END = 3;
/**
* How content which does not match the dimensions of its bounds (e.g. an image resource being
* drawn inside an {@link Image}) will be resized to fit its bounds.
*
* @hide
*/
@RestrictTo(RestrictTo.Scope.LIBRARY)
@IntDef({
CONTENT_SCALE_MODE_UNDEFINED,
CONTENT_SCALE_MODE_FIT,
CONTENT_SCALE_MODE_CROP,
CONTENT_SCALE_MODE_FILL_BOUNDS
})
@Retention(RetentionPolicy.SOURCE)
public @interface ContentScaleMode {}
/** Content scaling is undefined. */
public static final int CONTENT_SCALE_MODE_UNDEFINED = 0;
/**
* Content will be scaled to fit inside its bounds, proportionally. As an example, If a 10x5
* image was going to be drawn inside a 50x50 {@link Image} element, the actual image resource
* would be drawn as a 50x25 image, centered within the 50x50 bounds.
*/
public static final int CONTENT_SCALE_MODE_FIT = 1;
/**
* Content will be resized proportionally so it completely fills its bounds, and anything
* outside of the bounds will be cropped. As an example, if a 10x5 image was going to be drawn
* inside a 50x50 {@link Image} element, the image resource would be drawn as a 100x50 image,
* centered within its bounds (and with 25px cropped from both the left and right sides).
*/
public static final int CONTENT_SCALE_MODE_CROP = 2;
/**
* Content will be resized to fill its bounds, without taking into account the aspect ratio. If
* a 10x5 image was going to be drawn inside a 50x50 {@link Image} element, the image would be
* drawn as a 50x50 image, stretched vertically.
*/
public static final int CONTENT_SCALE_MODE_FILL_BOUNDS = 3;
/** An extensible {@code HorizontalAlignment} property. */
public static final class HorizontalAlignmentProp {
private final LayoutElementProto.HorizontalAlignmentProp mImpl;
private HorizontalAlignmentProp(LayoutElementProto.HorizontalAlignmentProp impl) {
this.mImpl = impl;
}
/** Gets the value. Intended for testing purposes only. */
@HorizontalAlignment
public int getValue() {
return mImpl.getValue().getNumber();
}
/** @hide */
@RestrictTo(Scope.LIBRARY_GROUP)
@NonNull
public static HorizontalAlignmentProp fromProto(
@NonNull LayoutElementProto.HorizontalAlignmentProp proto) {
return new HorizontalAlignmentProp(proto);
}
/** @hide */
@RestrictTo(Scope.LIBRARY_GROUP)
@NonNull
public LayoutElementProto.HorizontalAlignmentProp toProto() {
return mImpl;
}
/** Builder for {@link HorizontalAlignmentProp} */
public static final class Builder {
private final LayoutElementProto.HorizontalAlignmentProp.Builder mImpl =
LayoutElementProto.HorizontalAlignmentProp.newBuilder();
public Builder() {}
/** Sets the value. */
@NonNull
public Builder setValue(@HorizontalAlignment int value) {
mImpl.setValue(LayoutElementProto.HorizontalAlignment.forNumber(value));
return this;
}
/** Builds an instance from accumulated values. */
@NonNull
public HorizontalAlignmentProp build() {
return HorizontalAlignmentProp.fromProto(mImpl.build());
}
}
}
/** An extensible {@code VerticalAlignment} property. */
public static final class VerticalAlignmentProp {
private final LayoutElementProto.VerticalAlignmentProp mImpl;
private VerticalAlignmentProp(LayoutElementProto.VerticalAlignmentProp impl) {
this.mImpl = impl;
}
/** Gets the value. Intended for testing purposes only. */
@VerticalAlignment
public int getValue() {
return mImpl.getValue().getNumber();
}
/** @hide */
@RestrictTo(Scope.LIBRARY_GROUP)
@NonNull
public static VerticalAlignmentProp fromProto(
@NonNull LayoutElementProto.VerticalAlignmentProp proto) {
return new VerticalAlignmentProp(proto);
}
/** @hide */
@RestrictTo(Scope.LIBRARY_GROUP)
@NonNull
public LayoutElementProto.VerticalAlignmentProp toProto() {
return mImpl;
}
/** Builder for {@link VerticalAlignmentProp} */
public static final class Builder {
private final LayoutElementProto.VerticalAlignmentProp.Builder mImpl =
LayoutElementProto.VerticalAlignmentProp.newBuilder();
public Builder() {}
/** Sets the value. */
@NonNull
public Builder setValue(@VerticalAlignment int value) {
mImpl.setValue(LayoutElementProto.VerticalAlignment.forNumber(value));
return this;
}
/** Builds an instance from accumulated values. */
@NonNull
public VerticalAlignmentProp build() {
return VerticalAlignmentProp.fromProto(mImpl.build());
}
}
}
/** An extensible {@code FontWeight} property. */
public static final class FontWeightProp {
private final LayoutElementProto.FontWeightProp mImpl;
private FontWeightProp(LayoutElementProto.FontWeightProp impl) {
this.mImpl = impl;
}
/** Gets the value. Intended for testing purposes only. */
@FontWeight
public int getValue() {
return mImpl.getValue().getNumber();
}
/** @hide */
@RestrictTo(Scope.LIBRARY_GROUP)
@NonNull
public static FontWeightProp fromProto(@NonNull LayoutElementProto.FontWeightProp proto) {
return new FontWeightProp(proto);
}
/** @hide */
@RestrictTo(Scope.LIBRARY_GROUP)
@NonNull
public LayoutElementProto.FontWeightProp toProto() {
return mImpl;
}
/** Builder for {@link FontWeightProp} */
public static final class Builder {
private final LayoutElementProto.FontWeightProp.Builder mImpl =
LayoutElementProto.FontWeightProp.newBuilder();
public Builder() {}
/** Sets the value. */
@NonNull
public Builder setValue(@FontWeight int value) {
mImpl.setValue(LayoutElementProto.FontWeight.forNumber(value));
return this;
}
/** Builds an instance from accumulated values. */
@NonNull
public FontWeightProp build() {
return FontWeightProp.fromProto(mImpl.build());
}
}
}
/** An extensible {@code FontVariant} property. */
@TilesExperimental
public static final class FontVariantProp {
private final LayoutElementProto.FontVariantProp mImpl;
private FontVariantProp(LayoutElementProto.FontVariantProp impl) {
this.mImpl = impl;
}
/** Gets the value. Intended for testing purposes only. */
@FontVariant
public int getValue() {
return mImpl.getValue().getNumber();
}
/** @hide */
@RestrictTo(Scope.LIBRARY_GROUP)
@NonNull
public static FontVariantProp fromProto(@NonNull LayoutElementProto.FontVariantProp proto) {
return new FontVariantProp(proto);
}
/** @hide */
@RestrictTo(Scope.LIBRARY_GROUP)
@NonNull
public LayoutElementProto.FontVariantProp toProto() {
return mImpl;
}
/** Builder for {@link FontVariantProp} */
public static final class Builder {
private final LayoutElementProto.FontVariantProp.Builder mImpl =
LayoutElementProto.FontVariantProp.newBuilder();
public Builder() {}
/** Sets the value. */
@NonNull
public Builder setValue(@FontVariant int value) {
mImpl.setValue(LayoutElementProto.FontVariant.forNumber(value));
return this;
}
/** Builds an instance from accumulated values. */
@NonNull
public FontVariantProp build() {
return FontVariantProp.fromProto(mImpl.build());
}
}
}
/** An extensible {@code SpanVerticalAlignment} property. */
public static final class SpanVerticalAlignmentProp {
private final LayoutElementProto.SpanVerticalAlignmentProp mImpl;
private SpanVerticalAlignmentProp(LayoutElementProto.SpanVerticalAlignmentProp impl) {
this.mImpl = impl;
}
/** Gets the value. Intended for testing purposes only. */
@SpanVerticalAlignment
public int getValue() {
return mImpl.getValue().getNumber();
}
/** @hide */
@RestrictTo(Scope.LIBRARY_GROUP)
@NonNull
public static SpanVerticalAlignmentProp fromProto(
@NonNull LayoutElementProto.SpanVerticalAlignmentProp proto) {
return new SpanVerticalAlignmentProp(proto);
}
/** @hide */
@RestrictTo(Scope.LIBRARY_GROUP)
@NonNull
public LayoutElementProto.SpanVerticalAlignmentProp toProto() {
return mImpl;
}
/** Builder for {@link SpanVerticalAlignmentProp} */
public static final class Builder {
private final LayoutElementProto.SpanVerticalAlignmentProp.Builder mImpl =
LayoutElementProto.SpanVerticalAlignmentProp.newBuilder();
public Builder() {}
/** Sets the value. */
@NonNull
public Builder setValue(@SpanVerticalAlignment int value) {
mImpl.setValue(LayoutElementProto.SpanVerticalAlignment.forNumber(value));
return this;
}
/** Builds an instance from accumulated values. */
@NonNull
public SpanVerticalAlignmentProp build() {
return SpanVerticalAlignmentProp.fromProto(mImpl.build());
}
}
}
/** The styling of a font (e.g. font size, and metrics). */
public static final class FontStyle {
private final LayoutElementProto.FontStyle mImpl;
private FontStyle(LayoutElementProto.FontStyle impl) {
this.mImpl = impl;
}
/**
* Gets the size of the font, in scaled pixels (sp). If not specified, defaults to the size
* of the system's "body" font. Intended for testing purposes only.
*/
@Nullable
public SpProp getSize() {
if (mImpl.hasSize()) {
return SpProp.fromProto(mImpl.getSize());
} else {
return null;
}
}
/**
* Gets whether the text should be rendered in a italic typeface. If not specified, defaults
* to "false". Intended for testing purposes only.
*/
@Nullable
public BoolProp getItalic() {
if (mImpl.hasItalic()) {
return BoolProp.fromProto(mImpl.getItalic());
} else {
return null;
}
}
/**
* Gets whether the text should be rendered with an underline. If not specified, defaults to
* "false". Intended for testing purposes only.
*/
@Nullable
public BoolProp getUnderline() {
if (mImpl.hasUnderline()) {
return BoolProp.fromProto(mImpl.getUnderline());
} else {
return null;
}
}
/**
* Gets the text color. If not defined, defaults to white. Intended for testing purposes
* only.
*/
@Nullable
public ColorProp getColor() {
if (mImpl.hasColor()) {
return ColorProp.fromProto(mImpl.getColor());
} else {
return null;
}
}
/**
* Gets the weight of the font. If the provided value is not supported on a platform, the
* nearest supported value will be used. If not defined, or when set to an invalid value,
* defaults to "normal". Intended for testing purposes only.
*/
@Nullable
public FontWeightProp getWeight() {
if (mImpl.hasWeight()) {
return FontWeightProp.fromProto(mImpl.getWeight());
} else {
return null;
}
}
/**
* Gets the text letter-spacing. Positive numbers increase the space between letters while
* negative numbers tighten the space. If not specified, defaults to 0. Intended for testing
* purposes only.
*/
@Nullable
public EmProp getLetterSpacing() {
if (mImpl.hasLetterSpacing()) {
return EmProp.fromProto(mImpl.getLetterSpacing());
} else {
return null;
}
}
/**
* Gets the variant of a font. Some renderers may use different fonts for title and body
* text, which can be selected using this field. If not specified, defaults to "body".
* Intended for testing purposes only.
*/
@TilesExperimental
@Nullable
public FontVariantProp getVariant() {
if (mImpl.hasVariant()) {
return FontVariantProp.fromProto(mImpl.getVariant());
} else {
return null;
}
}
/** @hide */
@RestrictTo(Scope.LIBRARY_GROUP)
@NonNull
public static FontStyle fromProto(@NonNull LayoutElementProto.FontStyle proto) {
return new FontStyle(proto);
}
/** @hide */
@RestrictTo(Scope.LIBRARY_GROUP)
@NonNull
public LayoutElementProto.FontStyle toProto() {
return mImpl;
}
/** Builder for {@link FontStyle} */
public static final class Builder {
private final LayoutElementProto.FontStyle.Builder mImpl =
LayoutElementProto.FontStyle.newBuilder();
public Builder() {}
/**
* Sets the size of the font, in scaled pixels (sp). If not specified, defaults to the
* size of the system's "body" font.
*/
@NonNull
public Builder setSize(@NonNull SpProp size) {
mImpl.setSize(size.toProto());
return this;
}
/**
* Sets whether the text should be rendered in a italic typeface. If not specified,
* defaults to "false".
*/
@NonNull
public Builder setItalic(@NonNull BoolProp italic) {
mImpl.setItalic(italic.toProto());
return this;
}
/**
* Sets whether the text should be rendered in a italic typeface. If not specified,
* defaults to "false".
*/
@SuppressLint("MissingGetterMatchingBuilder")
@NonNull
public Builder setItalic(boolean italic) {
mImpl.setItalic(TypesProto.BoolProp.newBuilder().setValue(italic));
return this;
}
/**
* Sets whether the text should be rendered with an underline. If not specified,
* defaults to "false".
*/
@NonNull
public Builder setUnderline(@NonNull BoolProp underline) {
mImpl.setUnderline(underline.toProto());
return this;
}
/**
* Sets whether the text should be rendered with an underline. If not specified,
* defaults to "false".
*/
@SuppressLint("MissingGetterMatchingBuilder")
@NonNull
public Builder setUnderline(boolean underline) {
mImpl.setUnderline(TypesProto.BoolProp.newBuilder().setValue(underline));
return this;
}
/** Sets the text color. If not defined, defaults to white. */
@NonNull
public Builder setColor(@NonNull ColorProp color) {
mImpl.setColor(color.toProto());
return this;
}
/**
* Sets the weight of the font. If the provided value is not supported on a platform,
* the nearest supported value will be used. If not defined, or when set to an invalid
* value, defaults to "normal".
*/
@NonNull
public Builder setWeight(@NonNull FontWeightProp weight) {
mImpl.setWeight(weight.toProto());
return this;
}
/**
* Sets the weight of the font. If the provided value is not supported on a platform,
* the nearest supported value will be used. If not defined, or when set to an invalid
* value, defaults to "normal".
*/
@NonNull
public Builder setWeight(@FontWeight int weight) {
mImpl.setWeight(
LayoutElementProto.FontWeightProp.newBuilder()
.setValue(LayoutElementProto.FontWeight.forNumber(weight)));
return this;
}
/**
* Sets the text letter-spacing. Positive numbers increase the space between letters
* while negative numbers tighten the space. If not specified, defaults to 0.
*/
@NonNull
public Builder setLetterSpacing(@NonNull EmProp letterSpacing) {
mImpl.setLetterSpacing(letterSpacing.toProto());
return this;
}
/**
* Sets the variant of a font. Some renderers may use different fonts for title and body
* text, which can be selected using this field. If not specified, defaults to "body".
*/
@TilesExperimental
@NonNull
public Builder setVariant(@NonNull FontVariantProp variant) {
mImpl.setVariant(variant.toProto());
return this;
}
/**
* Sets the variant of a font. Some renderers may use different fonts for title and body
* text, which can be selected using this field. If not specified, defaults to "body".
*/
@TilesExperimental
@NonNull
public Builder setVariant(@FontVariant int variant) {
mImpl.setVariant(
LayoutElementProto.FontVariantProp.newBuilder()
.setValue(LayoutElementProto.FontVariant.forNumber(variant)));
return this;
}
/** Builds an instance from accumulated values. */
@NonNull
public FontStyle build() {
return FontStyle.fromProto(mImpl.build());
}
}
}
/** An extensible {@code TextAlignment} property. */
public static final class TextAlignmentProp {
private final LayoutElementProto.TextAlignmentProp mImpl;
private TextAlignmentProp(LayoutElementProto.TextAlignmentProp impl) {
this.mImpl = impl;
}
/** Gets the value. Intended for testing purposes only. */
@TextAlignment
public int getValue() {
return mImpl.getValue().getNumber();
}
/** @hide */
@RestrictTo(Scope.LIBRARY_GROUP)
@NonNull
public static TextAlignmentProp fromProto(
@NonNull LayoutElementProto.TextAlignmentProp proto) {
return new TextAlignmentProp(proto);
}
/** @hide */
@RestrictTo(Scope.LIBRARY_GROUP)
@NonNull
public LayoutElementProto.TextAlignmentProp toProto() {
return mImpl;
}
/** Builder for {@link TextAlignmentProp} */
public static final class Builder {
private final LayoutElementProto.TextAlignmentProp.Builder mImpl =
LayoutElementProto.TextAlignmentProp.newBuilder();
public Builder() {}
/** Sets the value. */
@NonNull
public Builder setValue(@TextAlignment int value) {
mImpl.setValue(LayoutElementProto.TextAlignment.forNumber(value));
return this;
}
/** Builds an instance from accumulated values. */
@NonNull
public TextAlignmentProp build() {
return TextAlignmentProp.fromProto(mImpl.build());
}
}
}
/** An extensible {@code TextOverflow} property. */
public static final class TextOverflowProp {
private final LayoutElementProto.TextOverflowProp mImpl;
private TextOverflowProp(LayoutElementProto.TextOverflowProp impl) {
this.mImpl = impl;
}
/** Gets the value. Intended for testing purposes only. */
@TextOverflow
public int getValue() {
return mImpl.getValue().getNumber();
}
/** @hide */
@RestrictTo(Scope.LIBRARY_GROUP)
@NonNull
public static TextOverflowProp fromProto(
@NonNull LayoutElementProto.TextOverflowProp proto) {
return new TextOverflowProp(proto);
}
/** @hide */
@RestrictTo(Scope.LIBRARY_GROUP)
@NonNull
public LayoutElementProto.TextOverflowProp toProto() {
return mImpl;
}
/** Builder for {@link TextOverflowProp} */
public static final class Builder {
private final LayoutElementProto.TextOverflowProp.Builder mImpl =
LayoutElementProto.TextOverflowProp.newBuilder();
public Builder() {}
/** Sets the value. */
@NonNull
public Builder setValue(@TextOverflow int value) {
mImpl.setValue(LayoutElementProto.TextOverflow.forNumber(value));
return this;
}
/** Builds an instance from accumulated values. */
@NonNull
public TextOverflowProp build() {
return TextOverflowProp.fromProto(mImpl.build());
}
}
}
/** An extensible {@code ArcAnchorType} property. */
public static final class ArcAnchorTypeProp {
private final LayoutElementProto.ArcAnchorTypeProp mImpl;
private ArcAnchorTypeProp(LayoutElementProto.ArcAnchorTypeProp impl) {
this.mImpl = impl;
}
/** Gets the value. Intended for testing purposes only. */
@ArcAnchorType
public int getValue() {
return mImpl.getValue().getNumber();
}
/** @hide */
@RestrictTo(Scope.LIBRARY_GROUP)
@NonNull
public static ArcAnchorTypeProp fromProto(
@NonNull LayoutElementProto.ArcAnchorTypeProp proto) {
return new ArcAnchorTypeProp(proto);
}
/** @hide */
@RestrictTo(Scope.LIBRARY_GROUP)
@NonNull
public LayoutElementProto.ArcAnchorTypeProp toProto() {
return mImpl;
}
/** Builder for {@link ArcAnchorTypeProp} */
public static final class Builder {
private final LayoutElementProto.ArcAnchorTypeProp.Builder mImpl =
LayoutElementProto.ArcAnchorTypeProp.newBuilder();
public Builder() {}
/** Sets the value. */
@NonNull
public Builder setValue(@ArcAnchorType int value) {
mImpl.setValue(LayoutElementProto.ArcAnchorType.forNumber(value));
return this;
}
/** Builds an instance from accumulated values. */
@NonNull
public ArcAnchorTypeProp build() {
return ArcAnchorTypeProp.fromProto(mImpl.build());
}
}
}
/** A text string. */
public static final class Text implements LayoutElement {
private final LayoutElementProto.Text mImpl;
private Text(LayoutElementProto.Text impl) {
this.mImpl = impl;
}
/** Gets the text to render. Intended for testing purposes only. */
@Nullable
public StringProp getText() {
if (mImpl.hasText()) {
return StringProp.fromProto(mImpl.getText());
} else {
return null;
}
}
/**
* Gets the style of font to use (size, bold etc). If not specified, defaults to the
* platform's default body font. Intended for testing purposes only.
*/
@Nullable
public FontStyle getFontStyle() {
if (mImpl.hasFontStyle()) {
return FontStyle.fromProto(mImpl.getFontStyle());
} else {
return null;
}
}
/**
* Gets {@link androidx.wear.tiles.ModifiersBuilders.Modifiers} for this element. Intended
* for testing purposes only.
*/
@Nullable
public Modifiers getModifiers() {
if (mImpl.hasModifiers()) {
return Modifiers.fromProto(mImpl.getModifiers());
} else {
return null;
}
}
/**
* Gets the maximum number of lines that can be represented by the {@link Text} element. If
* not defined, the {@link Text} element will be treated as a single-line element. Intended
* for testing purposes only.
*/
@Nullable
public Int32Prop getMaxLines() {
if (mImpl.hasMaxLines()) {
return Int32Prop.fromProto(mImpl.getMaxLines());
} else {
return null;
}
}
/**
* Gets alignment of the text within its bounds. Note that a {@link Text} element will size
* itself to wrap its contents, so this option is meaningless for single-line text (for
* that, use alignment of the outer container). For multi-line text, however, this will set
* the alignment of lines relative to the {@link Text} element bounds. If not defined,
* defaults to TEXT_ALIGN_CENTER. Intended for testing purposes only.
*/
@Nullable
public TextAlignmentProp getMultilineAlignment() {
if (mImpl.hasMultilineAlignment()) {
return TextAlignmentProp.fromProto(mImpl.getMultilineAlignment());
} else {
return null;
}
}
/**
* Gets how to handle text which overflows the bound of the {@link Text} element. A {@link
* Text} element will grow as large as possible inside its parent container (while still
* respecting max_lines); if it cannot grow large enough to render all of its text, the text
* which cannot fit inside its container will be truncated. If not defined, defaults to
* TEXT_OVERFLOW_TRUNCATE. Intended for testing purposes only.
*/
@Nullable
public TextOverflowProp getOverflow() {
if (mImpl.hasOverflow()) {
return TextOverflowProp.fromProto(mImpl.getOverflow());
} else {
return null;
}
}
/**
* Gets the explicit height between lines of text. This is equivalent to the vertical
* distance between subsequent baselines. If not specified, defaults the font's recommended
* interline spacing. Intended for testing purposes only.
*/
@Nullable
public SpProp getLineHeight() {
if (mImpl.hasLineHeight()) {
return SpProp.fromProto(mImpl.getLineHeight());
} else {
return null;
}
}
/** @hide */
@RestrictTo(Scope.LIBRARY_GROUP)
@NonNull
public static Text fromProto(@NonNull LayoutElementProto.Text proto) {
return new Text(proto);
}
/** @hide */
@RestrictTo(Scope.LIBRARY_GROUP)
@NonNull
LayoutElementProto.Text toProto() {
return mImpl;
}
/** @hide */
@Override
@RestrictTo(Scope.LIBRARY_GROUP)
@NonNull
public LayoutElementProto.LayoutElement toLayoutElementProto() {
return LayoutElementProto.LayoutElement.newBuilder().setText(mImpl).build();
}
/** Builder for {@link Text}. */
public static final class Builder implements LayoutElement.Builder {
private final LayoutElementProto.Text.Builder mImpl =
LayoutElementProto.Text.newBuilder();
public Builder() {}
/** Sets the text to render. */
@NonNull
public Builder setText(@NonNull StringProp text) {
mImpl.setText(text.toProto());
return this;
}
/** Sets the text to render. */
@NonNull
public Builder setText(@NonNull String text) {
mImpl.setText(TypesProto.StringProp.newBuilder().setValue(text));
return this;
}
/**
* Sets the style of font to use (size, bold etc). If not specified, defaults to the
* platform's default body font.
*/
@NonNull
public Builder setFontStyle(@NonNull FontStyle fontStyle) {
mImpl.setFontStyle(fontStyle.toProto());
return this;
}
/** Sets {@link androidx.wear.tiles.ModifiersBuilders.Modifiers} for this element. */
@NonNull
public Builder setModifiers(@NonNull Modifiers modifiers) {
mImpl.setModifiers(modifiers.toProto());
return this;
}
/**
* Sets the maximum number of lines that can be represented by the {@link Text} element.
* If not defined, the {@link Text} element will be treated as a single-line element.
*/
@NonNull
public Builder setMaxLines(@NonNull Int32Prop maxLines) {
mImpl.setMaxLines(maxLines.toProto());
return this;
}
/**
* Sets the maximum number of lines that can be represented by the {@link Text} element.
* If not defined, the {@link Text} element will be treated as a single-line element.
*/
@NonNull
public Builder setMaxLines(@IntRange(from = 1) int maxLines) {
mImpl.setMaxLines(TypesProto.Int32Prop.newBuilder().setValue(maxLines));
return this;
}
/**
* Sets alignment of the text within its bounds. Note that a {@link Text} element will
* size itself to wrap its contents, so this option is meaningless for single-line text
* (for that, use alignment of the outer container). For multi-line text, however, this
* will set the alignment of lines relative to the {@link Text} element bounds. If not
* defined, defaults to TEXT_ALIGN_CENTER.
*/
@NonNull
public Builder setMultilineAlignment(@NonNull TextAlignmentProp multilineAlignment) {
mImpl.setMultilineAlignment(multilineAlignment.toProto());
return this;
}
/**
* Sets alignment of the text within its bounds. Note that a {@link Text} element will
* size itself to wrap its contents, so this option is meaningless for single-line text
* (for that, use alignment of the outer container). For multi-line text, however, this
* will set the alignment of lines relative to the {@link Text} element bounds. If not
* defined, defaults to TEXT_ALIGN_CENTER.
*/
@NonNull
public Builder setMultilineAlignment(@TextAlignment int multilineAlignment) {
mImpl.setMultilineAlignment(
LayoutElementProto.TextAlignmentProp.newBuilder()
.setValue(
LayoutElementProto.TextAlignment.forNumber(
multilineAlignment)));
return this;
}
/**
* Sets how to handle text which overflows the bound of the {@link Text} element. A
* {@link Text} element will grow as large as possible inside its parent container
* (while still respecting max_lines); if it cannot grow large enough to render all of
* its text, the text which cannot fit inside its container will be truncated. If not
* defined, defaults to TEXT_OVERFLOW_TRUNCATE.
*/
@NonNull
public Builder setOverflow(@NonNull TextOverflowProp overflow) {
mImpl.setOverflow(overflow.toProto());
return this;
}
/**
* Sets how to handle text which overflows the bound of the {@link Text} element. A
* {@link Text} element will grow as large as possible inside its parent container
* (while still respecting max_lines); if it cannot grow large enough to render all of
* its text, the text which cannot fit inside its container will be truncated. If not
* defined, defaults to TEXT_OVERFLOW_TRUNCATE.
*/
@NonNull
public Builder setOverflow(@TextOverflow int overflow) {
mImpl.setOverflow(
LayoutElementProto.TextOverflowProp.newBuilder()
.setValue(LayoutElementProto.TextOverflow.forNumber(overflow)));
return this;
}
/**
* Sets the explicit height between lines of text. This is equivalent to the vertical
* distance between subsequent baselines. If not specified, defaults the font's
* recommended interline spacing.
*/
@NonNull
public Builder setLineHeight(@NonNull SpProp lineHeight) {
mImpl.setLineHeight(lineHeight.toProto());
return this;
}
@Override
@NonNull
public Text build() {
return Text.fromProto(mImpl.build());
}
}
}
/** An extensible {@code ContentScaleMode} property. */
public static final class ContentScaleModeProp {
private final LayoutElementProto.ContentScaleModeProp mImpl;
private ContentScaleModeProp(LayoutElementProto.ContentScaleModeProp impl) {
this.mImpl = impl;
}
/** Gets the value. Intended for testing purposes only. */
@ContentScaleMode
public int getValue() {
return mImpl.getValue().getNumber();
}
/** @hide */
@RestrictTo(Scope.LIBRARY_GROUP)
@NonNull
public static ContentScaleModeProp fromProto(
@NonNull LayoutElementProto.ContentScaleModeProp proto) {
return new ContentScaleModeProp(proto);
}
/** @hide */
@RestrictTo(Scope.LIBRARY_GROUP)
@NonNull
public LayoutElementProto.ContentScaleModeProp toProto() {
return mImpl;
}
/** Builder for {@link ContentScaleModeProp} */
public static final class Builder {
private final LayoutElementProto.ContentScaleModeProp.Builder mImpl =
LayoutElementProto.ContentScaleModeProp.newBuilder();
public Builder() {}
/** Sets the value. */
@NonNull
public Builder setValue(@ContentScaleMode int value) {
mImpl.setValue(LayoutElementProto.ContentScaleMode.forNumber(value));
return this;
}
/** Builds an instance from accumulated values. */
@NonNull
public ContentScaleModeProp build() {
return ContentScaleModeProp.fromProto(mImpl.build());
}
}
}
/** Filtering parameters used for images. This can be used to apply a color tint to images. */
public static final class ColorFilter {
private final LayoutElementProto.ColorFilter mImpl;
private ColorFilter(LayoutElementProto.ColorFilter impl) {
this.mImpl = impl;
}
/**
* Gets the tint color to use. If specified, the image will be tinted, using SRC_IN blending
* (that is, all color information will be stripped from the target image, and only the
* alpha channel will be blended with the requested color).
*
* <p>Note that only Android image resources can be tinted; Inline images will not be
* tinted, and this property will have no effect. Intended for testing purposes only.
*/
@Nullable
public ColorProp getTint() {
if (mImpl.hasTint()) {
return ColorProp.fromProto(mImpl.getTint());
} else {
return null;
}
}
/** @hide */
@RestrictTo(Scope.LIBRARY_GROUP)
@NonNull
public static ColorFilter fromProto(@NonNull LayoutElementProto.ColorFilter proto) {
return new ColorFilter(proto);
}
/** @hide */
@RestrictTo(Scope.LIBRARY_GROUP)
@NonNull
public LayoutElementProto.ColorFilter toProto() {
return mImpl;
}
/** Builder for {@link ColorFilter} */
public static final class Builder {
private final LayoutElementProto.ColorFilter.Builder mImpl =
LayoutElementProto.ColorFilter.newBuilder();
public Builder() {}
/**
* Sets the tint color to use. If specified, the image will be tinted, using SRC_IN
* blending (that is, all color information will be stripped from the target image, and
* only the alpha channel will be blended with the requested color).
*
* <p>Note that only Android image resources can be tinted; Inline images will not be
* tinted, and this property will have no effect.
*/
@NonNull
public Builder setTint(@NonNull ColorProp tint) {
mImpl.setTint(tint.toProto());
return this;
}
/** Builds an instance from accumulated values. */
@NonNull
public ColorFilter build() {
return ColorFilter.fromProto(mImpl.build());
}
}
}
/**
* An image.
*
* <p>Images used in this element must exist in the resource bundle that corresponds to this
* layout. Images must have their dimension specified, and will be rendered at this width and
* height, regardless of their native dimension.
*/
public static final class Image implements LayoutElement {
private final LayoutElementProto.Image mImpl;
private Image(LayoutElementProto.Image impl) {
this.mImpl = impl;
}
/**
* Gets the resource_id of the image to render. This must exist in the supplied resource
* bundle. Intended for testing purposes only.
*/
@Nullable
public StringProp getResourceId() {
if (mImpl.hasResourceId()) {
return StringProp.fromProto(mImpl.getResourceId());
} else {
return null;
}
}
/**
* Gets the width of this image. If not defined, the image will not be rendered. Intended
* for testing purposes only.
*/
@Nullable
public ImageDimension getWidth() {
if (mImpl.hasWidth()) {
return ImageDimension.fromImageDimensionProto(mImpl.getWidth());
} else {
return null;
}
}
/**
* Gets the height of this image. If not defined, the image will not be rendered. Intended
* for testing purposes only.
*/
@Nullable
public ImageDimension getHeight() {
if (mImpl.hasHeight()) {
return ImageDimension.fromImageDimensionProto(mImpl.getHeight());
} else {
return null;
}
}
/**
* Gets how to scale the image resource inside the bounds specified by width/height if its
* size does not match those bounds. Defaults to CONTENT_SCALE_MODE_FIT. Intended for
* testing purposes only.
*/
@Nullable
public ContentScaleModeProp getContentScaleMode() {
if (mImpl.hasContentScaleMode()) {
return ContentScaleModeProp.fromProto(mImpl.getContentScaleMode());
} else {
return null;
}
}
/**
* Gets {@link androidx.wear.tiles.ModifiersBuilders.Modifiers} for this element. Intended
* for testing purposes only.
*/
@Nullable
public Modifiers getModifiers() {
if (mImpl.hasModifiers()) {
return Modifiers.fromProto(mImpl.getModifiers());
} else {
return null;
}
}
/**
* Gets filtering parameters for this image. If not specified, defaults to no filtering.
*/
@Nullable
public ColorFilter getColorFilter() {
if (mImpl.hasFilter()) {
return ColorFilter.fromProto(mImpl.getFilter());
} else {
return null;
}
}
/** @hide */
@RestrictTo(Scope.LIBRARY_GROUP)
@NonNull
public static Image fromProto(@NonNull LayoutElementProto.Image proto) {
return new Image(proto);
}
/** @hide */
@RestrictTo(Scope.LIBRARY_GROUP)
@NonNull
LayoutElementProto.Image toProto() {
return mImpl;
}
/** @hide */
@Override
@RestrictTo(Scope.LIBRARY_GROUP)
@NonNull
public LayoutElementProto.LayoutElement toLayoutElementProto() {
return LayoutElementProto.LayoutElement.newBuilder().setImage(mImpl).build();
}
/** Builder for {@link Image}. */
public static final class Builder implements LayoutElement.Builder {
private final LayoutElementProto.Image.Builder mImpl =
LayoutElementProto.Image.newBuilder();
public Builder() {}
/**
* Sets the resource_id of the image to render. This must exist in the supplied resource
* bundle.
*/
@NonNull
public Builder setResourceId(@NonNull StringProp resourceId) {
mImpl.setResourceId(resourceId.toProto());
return this;
}
/**
* Sets the resource_id of the image to render. This must exist in the supplied resource
* bundle.
*/
@NonNull
public Builder setResourceId(@NonNull String resourceId) {
mImpl.setResourceId(TypesProto.StringProp.newBuilder().setValue(resourceId));
return this;
}
/** Sets the width of this image. If not defined, the image will not be rendered. */
@NonNull
public Builder setWidth(@NonNull ImageDimension width) {
mImpl.setWidth(width.toImageDimensionProto());
return this;
}
/** Sets the height of this image. If not defined, the image will not be rendered. */
@NonNull
public Builder setHeight(@NonNull ImageDimension height) {
mImpl.setHeight(height.toImageDimensionProto());
return this;
}
/**
* Sets how to scale the image resource inside the bounds specified by width/height if
* its size does not match those bounds. Defaults to CONTENT_SCALE_MODE_FIT.
*/
@NonNull
public Builder setContentScaleMode(@NonNull ContentScaleModeProp contentScaleMode) {
mImpl.setContentScaleMode(contentScaleMode.toProto());
return this;
}
/**
* Sets how to scale the image resource inside the bounds specified by width/height if
* its size does not match those bounds. Defaults to CONTENT_SCALE_MODE_FIT.
*/
@NonNull
public Builder setContentScaleMode(@ContentScaleMode int contentScaleMode) {
mImpl.setContentScaleMode(
LayoutElementProto.ContentScaleModeProp.newBuilder()
.setValue(
LayoutElementProto.ContentScaleMode.forNumber(
contentScaleMode)));
return this;
}
/** Sets {@link androidx.wear.tiles.ModifiersBuilders.Modifiers} for this element. */
@NonNull
public Builder setModifiers(@NonNull Modifiers modifiers) {
mImpl.setModifiers(modifiers.toProto());
return this;
}
/**
* Sets filtering parameters for this image. If not specified, defaults to no filtering.
*/
@NonNull
public Builder setColorFilter(@NonNull ColorFilter filter) {
mImpl.setFilter(filter.toProto());
return this;
}
@Override
@NonNull
public Image build() {
return Image.fromProto(mImpl.build());
}
}
}
/** A simple spacer, typically used to provide padding between adjacent elements. */
public static final class Spacer implements LayoutElement {
private final LayoutElementProto.Spacer mImpl;
private Spacer(LayoutElementProto.Spacer impl) {
this.mImpl = impl;
}
/**
* Gets the width of this {@link Spacer}. When this is added as the direct child of an
* {@link Arc}, this must be specified as an angular dimension, otherwise a linear dimension
* must be used. If not defined, defaults to 0. Intended for testing purposes only.
*/
@Nullable
public SpacerDimension getWidth() {
if (mImpl.hasWidth()) {
return SpacerDimension.fromSpacerDimensionProto(mImpl.getWidth());
} else {
return null;
}
}
/**
* Gets the height of this spacer. If not defined, defaults to 0. Intended for testing
* purposes only.
*/
@Nullable
public SpacerDimension getHeight() {
if (mImpl.hasHeight()) {
return SpacerDimension.fromSpacerDimensionProto(mImpl.getHeight());
} else {
return null;
}
}
/**
* Gets {@link androidx.wear.tiles.ModifiersBuilders.Modifiers} for this element. Intended
* for testing purposes only.
*/
@Nullable
public Modifiers getModifiers() {
if (mImpl.hasModifiers()) {
return Modifiers.fromProto(mImpl.getModifiers());
} else {
return null;
}
}
/** @hide */
@RestrictTo(Scope.LIBRARY_GROUP)
@NonNull
public static Spacer fromProto(@NonNull LayoutElementProto.Spacer proto) {
return new Spacer(proto);
}
/** @hide */
@RestrictTo(Scope.LIBRARY_GROUP)
@NonNull
LayoutElementProto.Spacer toProto() {
return mImpl;
}
/** @hide */
@Override
@RestrictTo(Scope.LIBRARY_GROUP)
@NonNull
public LayoutElementProto.LayoutElement toLayoutElementProto() {
return LayoutElementProto.LayoutElement.newBuilder().setSpacer(mImpl).build();
}
/** Builder for {@link Spacer}. */
public static final class Builder implements LayoutElement.Builder {
private final LayoutElementProto.Spacer.Builder mImpl =
LayoutElementProto.Spacer.newBuilder();
public Builder() {}
/**
* Sets the width of this {@link Spacer}. When this is added as the direct child of an
* {@link Arc}, this must be specified as an angular dimension, otherwise a linear
* dimension must be used. If not defined, defaults to 0.
*/
@NonNull
public Builder setWidth(@NonNull SpacerDimension width) {
mImpl.setWidth(width.toSpacerDimensionProto());
return this;
}
/** Sets the height of this spacer. If not defined, defaults to 0. */
@NonNull
public Builder setHeight(@NonNull SpacerDimension height) {
mImpl.setHeight(height.toSpacerDimensionProto());
return this;
}
/** Sets {@link androidx.wear.tiles.ModifiersBuilders.Modifiers} for this element. */
@NonNull
public Builder setModifiers(@NonNull Modifiers modifiers) {
mImpl.setModifiers(modifiers.toProto());
return this;
}
@Override
@NonNull
public Spacer build() {
return Spacer.fromProto(mImpl.build());
}
}
}
/**
* A container which stacks all of its children on top of one another. This also allows to add a
* background color, or to have a border around them with some padding.
*/
public static final class Box implements LayoutElement {
private final LayoutElementProto.Box mImpl;
private Box(LayoutElementProto.Box impl) {
this.mImpl = impl;
}
/** Gets the child element(s) to wrap. Intended for testing purposes only. */
@NonNull
public List<LayoutElement> getContents() {
return Collections.unmodifiableList(
mImpl.getContentsList().stream()
.map(LayoutElement::fromLayoutElementProto)
.collect(toList()));
}
/**
* Gets the height of this {@link Box}. If not defined, this will size itself to fit all of
* its children (i.e. a WrappedDimension). Intended for testing purposes only.
*/
@Nullable
public ContainerDimension getHeight() {
if (mImpl.hasHeight()) {
return ContainerDimension.fromContainerDimensionProto(mImpl.getHeight());
} else {
return null;
}
}
/**
* Gets the width of this {@link Box}. If not defined, this will size itself to fit all of
* its children (i.e. a WrappedDimension). Intended for testing purposes only.
*/
@Nullable
public ContainerDimension getWidth() {
if (mImpl.hasWidth()) {
return ContainerDimension.fromContainerDimensionProto(mImpl.getWidth());
} else {
return null;
}
}
/**
* Gets the horizontal alignment of the element inside this {@link Box}. If not defined,
* defaults to HORIZONTAL_ALIGN_CENTER. Intended for testing purposes only.
*/
@Nullable
public HorizontalAlignmentProp getHorizontalAlignment() {
if (mImpl.hasHorizontalAlignment()) {
return HorizontalAlignmentProp.fromProto(mImpl.getHorizontalAlignment());
} else {
return null;
}
}
/**
* Gets the vertical alignment of the element inside this {@link Box}. If not defined,
* defaults to VERTICAL_ALIGN_CENTER. Intended for testing purposes only.
*/
@Nullable
public VerticalAlignmentProp getVerticalAlignment() {
if (mImpl.hasVerticalAlignment()) {
return VerticalAlignmentProp.fromProto(mImpl.getVerticalAlignment());
} else {
return null;
}
}
/**
* Gets {@link androidx.wear.tiles.ModifiersBuilders.Modifiers} for this element. Intended
* for testing purposes only.
*/
@Nullable
public Modifiers getModifiers() {
if (mImpl.hasModifiers()) {
return Modifiers.fromProto(mImpl.getModifiers());
} else {
return null;
}
}
/** @hide */
@RestrictTo(Scope.LIBRARY_GROUP)
@NonNull
public static Box fromProto(@NonNull LayoutElementProto.Box proto) {
return new Box(proto);
}
/** @hide */
@RestrictTo(Scope.LIBRARY_GROUP)
@NonNull
LayoutElementProto.Box toProto() {
return mImpl;
}
/** @hide */
@Override
@RestrictTo(Scope.LIBRARY_GROUP)
@NonNull
public LayoutElementProto.LayoutElement toLayoutElementProto() {
return LayoutElementProto.LayoutElement.newBuilder().setBox(mImpl).build();
}
/** Builder for {@link Box}. */
public static final class Builder implements LayoutElement.Builder {
private final LayoutElementProto.Box.Builder mImpl =
LayoutElementProto.Box.newBuilder();
public Builder() {}
/** Adds one item to the child element(s) to wrap. */
@NonNull
public Builder addContent(@NonNull LayoutElement content) {
mImpl.addContents(content.toLayoutElementProto());
return this;
}
/**
* Sets the height of this {@link Box}. If not defined, this will size itself to fit all
* of its children (i.e. a WrappedDimension).
*/
@NonNull
public Builder setHeight(@NonNull ContainerDimension height) {
mImpl.setHeight(height.toContainerDimensionProto());
return this;
}
/**
* Sets the width of this {@link Box}. If not defined, this will size itself to fit all
* of its children (i.e. a WrappedDimension).
*/
@NonNull
public Builder setWidth(@NonNull ContainerDimension width) {
mImpl.setWidth(width.toContainerDimensionProto());
return this;
}
/**
* Sets the horizontal alignment of the element inside this {@link Box}. If not defined,
* defaults to HORIZONTAL_ALIGN_CENTER.
*/
@NonNull
public Builder setHorizontalAlignment(
@NonNull HorizontalAlignmentProp horizontalAlignment) {
mImpl.setHorizontalAlignment(horizontalAlignment.toProto());
return this;
}
/**
* Sets the horizontal alignment of the element inside this {@link Box}. If not defined,
* defaults to HORIZONTAL_ALIGN_CENTER.
*/
@NonNull
public Builder setHorizontalAlignment(@HorizontalAlignment int horizontalAlignment) {
mImpl.setHorizontalAlignment(
LayoutElementProto.HorizontalAlignmentProp.newBuilder()
.setValue(
LayoutElementProto.HorizontalAlignment.forNumber(
horizontalAlignment)));
return this;
}
/**
* Sets the vertical alignment of the element inside this {@link Box}. If not defined,
* defaults to VERTICAL_ALIGN_CENTER.
*/
@NonNull
public Builder setVerticalAlignment(@NonNull VerticalAlignmentProp verticalAlignment) {
mImpl.setVerticalAlignment(verticalAlignment.toProto());
return this;
}
/**
* Sets the vertical alignment of the element inside this {@link Box}. If not defined,
* defaults to VERTICAL_ALIGN_CENTER.
*/
@NonNull
public Builder setVerticalAlignment(@VerticalAlignment int verticalAlignment) {
mImpl.setVerticalAlignment(
LayoutElementProto.VerticalAlignmentProp.newBuilder()
.setValue(
LayoutElementProto.VerticalAlignment.forNumber(
verticalAlignment)));
return this;
}
/** Sets {@link androidx.wear.tiles.ModifiersBuilders.Modifiers} for this element. */
@NonNull
public Builder setModifiers(@NonNull Modifiers modifiers) {
mImpl.setModifiers(modifiers.toProto());
return this;
}
@Override
@NonNull
public Box build() {
return Box.fromProto(mImpl.build());
}
}
}
/**
* A portion of text which can be added to a {@link Span}. Two different {@link SpanText}
* elements on the same line will be aligned to the same baseline, regardless of the size of
* each {@link SpanText}.
*/
public static final class SpanText implements Span {
private final LayoutElementProto.SpanText mImpl;
private SpanText(LayoutElementProto.SpanText impl) {
this.mImpl = impl;
}
/** Gets the text to render. Intended for testing purposes only. */
@Nullable
public StringProp getText() {
if (mImpl.hasText()) {
return StringProp.fromProto(mImpl.getText());
} else {
return null;
}
}
/**
* Gets the style of font to use (size, bold etc). If not specified, defaults to the
* platform's default body font. Intended for testing purposes only.
*/
@Nullable
public FontStyle getFontStyle() {
if (mImpl.hasFontStyle()) {
return FontStyle.fromProto(mImpl.getFontStyle());
} else {
return null;
}
}
/**
* Gets {@link androidx.wear.tiles.ModifiersBuilders.Modifiers} for this element. Intended
* for testing purposes only.
*/
@Nullable
public SpanModifiers getModifiers() {
if (mImpl.hasModifiers()) {
return SpanModifiers.fromProto(mImpl.getModifiers());
} else {
return null;
}
}
/** @hide */
@RestrictTo(Scope.LIBRARY_GROUP)
@NonNull
public static SpanText fromProto(@NonNull LayoutElementProto.SpanText proto) {
return new SpanText(proto);
}
/** @hide */
@RestrictTo(Scope.LIBRARY_GROUP)
@NonNull
LayoutElementProto.SpanText toProto() {
return mImpl;
}
/** @hide */
@Override
@RestrictTo(Scope.LIBRARY_GROUP)
@NonNull
public LayoutElementProto.Span toSpanProto() {
return LayoutElementProto.Span.newBuilder().setText(mImpl).build();
}
/** Builder for {@link SpanText}. */
public static final class Builder implements Span.Builder {
private final LayoutElementProto.SpanText.Builder mImpl =
LayoutElementProto.SpanText.newBuilder();
public Builder() {}
/** Sets the text to render. */
@NonNull
public Builder setText(@NonNull StringProp text) {
mImpl.setText(text.toProto());
return this;
}
/** Sets the text to render. */
@NonNull
public Builder setText(@NonNull String text) {
mImpl.setText(TypesProto.StringProp.newBuilder().setValue(text));
return this;
}
/**
* Sets the style of font to use (size, bold etc). If not specified, defaults to the
* platform's default body font.
*/
@NonNull
public Builder setFontStyle(@NonNull FontStyle fontStyle) {
mImpl.setFontStyle(fontStyle.toProto());
return this;
}
/** Sets {@link androidx.wear.tiles.ModifiersBuilders.Modifiers} for this element. */
@NonNull
public Builder setModifiers(@NonNull SpanModifiers modifiers) {
mImpl.setModifiers(modifiers.toProto());
return this;
}
@Override
@NonNull
public SpanText build() {
return SpanText.fromProto(mImpl.build());
}
}
}
/** An image which can be added to a {@link Span}. */
public static final class SpanImage implements Span {
private final LayoutElementProto.SpanImage mImpl;
private SpanImage(LayoutElementProto.SpanImage impl) {
this.mImpl = impl;
}
/**
* Gets the resource_id of the image to render. This must exist in the supplied resource
* bundle. Intended for testing purposes only.
*/
@Nullable
public StringProp getResourceId() {
if (mImpl.hasResourceId()) {
return StringProp.fromProto(mImpl.getResourceId());
} else {
return null;
}
}
/**
* Gets the width of this image. If not defined, the image will not be rendered. Intended
* for testing purposes only.
*/
@Nullable
public DpProp getWidth() {
if (mImpl.hasWidth()) {
return DpProp.fromProto(mImpl.getWidth());
} else {
return null;
}
}
/**
* Gets the height of this image. If not defined, the image will not be rendered. Intended
* for testing purposes only.
*/
@Nullable
public DpProp getHeight() {
if (mImpl.hasHeight()) {
return DpProp.fromProto(mImpl.getHeight());
} else {
return null;
}
}
/**
* Gets {@link androidx.wear.tiles.ModifiersBuilders.Modifiers} for this element. Intended
* for testing purposes only.
*/
@Nullable
public SpanModifiers getModifiers() {
if (mImpl.hasModifiers()) {
return SpanModifiers.fromProto(mImpl.getModifiers());
} else {
return null;
}
}
/**
* Gets alignment of this image within the line height of the surrounding {@link Spannable}.
* If undefined, defaults to SPAN_VERTICAL_ALIGN_BOTTOM. Intended for testing purposes only.
*/
@Nullable
public SpanVerticalAlignmentProp getAlignment() {
if (mImpl.hasAlignment()) {
return SpanVerticalAlignmentProp.fromProto(mImpl.getAlignment());
} else {
return null;
}
}
/** @hide */
@RestrictTo(Scope.LIBRARY_GROUP)
@NonNull
public static SpanImage fromProto(@NonNull LayoutElementProto.SpanImage proto) {
return new SpanImage(proto);
}
/** @hide */
@RestrictTo(Scope.LIBRARY_GROUP)
@NonNull
LayoutElementProto.SpanImage toProto() {
return mImpl;
}
/** @hide */
@Override
@RestrictTo(Scope.LIBRARY_GROUP)
@NonNull
public LayoutElementProto.Span toSpanProto() {
return LayoutElementProto.Span.newBuilder().setImage(mImpl).build();
}
/** Builder for {@link SpanImage}. */
public static final class Builder implements Span.Builder {
private final LayoutElementProto.SpanImage.Builder mImpl =
LayoutElementProto.SpanImage.newBuilder();
public Builder() {}
/**
* Sets the resource_id of the image to render. This must exist in the supplied resource
* bundle.
*/
@NonNull
public Builder setResourceId(@NonNull StringProp resourceId) {
mImpl.setResourceId(resourceId.toProto());
return this;
}
/**
* Sets the resource_id of the image to render. This must exist in the supplied resource
* bundle.
*/
@NonNull
public Builder setResourceId(@NonNull String resourceId) {
mImpl.setResourceId(TypesProto.StringProp.newBuilder().setValue(resourceId));
return this;
}
/** Sets the width of this image. If not defined, the image will not be rendered. */
@NonNull
public Builder setWidth(@NonNull DpProp width) {
mImpl.setWidth(width.toProto());
return this;
}
/** Sets the height of this image. If not defined, the image will not be rendered. */
@NonNull
public Builder setHeight(@NonNull DpProp height) {
mImpl.setHeight(height.toProto());
return this;
}
/** Sets {@link androidx.wear.tiles.ModifiersBuilders.Modifiers} for this element. */
@NonNull
public Builder setModifiers(@NonNull SpanModifiers modifiers) {
mImpl.setModifiers(modifiers.toProto());
return this;
}
/**
* Sets alignment of this image within the line height of the surrounding {@link
* Spannable}. If undefined, defaults to SPAN_VERTICAL_ALIGN_BOTTOM.
*/
@NonNull
public Builder setAlignment(@NonNull SpanVerticalAlignmentProp alignment) {
mImpl.setAlignment(alignment.toProto());
return this;
}
/**
* Sets alignment of this image within the line height of the surrounding {@link
* Spannable}. If undefined, defaults to SPAN_VERTICAL_ALIGN_BOTTOM.
*/
@NonNull
public Builder setAlignment(@SpanVerticalAlignment int alignment) {
mImpl.setAlignment(
LayoutElementProto.SpanVerticalAlignmentProp.newBuilder()
.setValue(
LayoutElementProto.SpanVerticalAlignment.forNumber(
alignment)));
return this;
}
@Override
@NonNull
public SpanImage build() {
return SpanImage.fromProto(mImpl.build());
}
}
}
/**
* Interface defining a single {@link Span}. Each {@link Span} forms part of a larger {@link
* Spannable} widget. At the moment, the only widgets which can be added to {@link Spannable}
* containers are {@link SpanText} and {@link SpanImage} elements.
*/
public interface Span {
/**
* Get the protocol buffer representation of this object.
*
* @hide
*/
@RestrictTo(Scope.LIBRARY_GROUP)
@NonNull
LayoutElementProto.Span toSpanProto();
/**
* Return an instance of one of this object's subtypes, from the protocol buffer
* representation.
*
* @hide
*/
@RestrictTo(Scope.LIBRARY_GROUP)
@NonNull
static Span fromSpanProto(@NonNull LayoutElementProto.Span proto) {
if (proto.hasText()) {
return SpanText.fromProto(proto.getText());
}
if (proto.hasImage()) {
return SpanImage.fromProto(proto.getImage());
}
throw new IllegalStateException("Proto was not a recognised instance of Span");
}
/** Builder to create {@link Span} objects. */
@SuppressLint("StaticFinalBuilder")
interface Builder {
/** Builds an instance with values accumulated in this Builder. */
@NonNull
Span build();
}
}
/**
* A container of {@link Span} elements. Currently, this only supports {@link Text} elements,
* where each individual {@link Span} can have different styling applied to it but the resulting
* text will flow naturally. This allows sections of a paragraph of text to have different
* styling applied to it, for example, making one or two words bold or italic.
*/
public static final class Spannable implements LayoutElement {
private final LayoutElementProto.Spannable mImpl;
private Spannable(LayoutElementProto.Spannable impl) {
this.mImpl = impl;
}
/**
* Gets the {@link Span} elements that form this {@link Spannable}. Intended for testing
* purposes only.
*/
@NonNull
public List<Span> getSpans() {
return Collections.unmodifiableList(
mImpl.getSpansList().stream().map(Span::fromSpanProto).collect(toList()));
}
/**
* Gets {@link androidx.wear.tiles.ModifiersBuilders.Modifiers} for this element. Intended
* for testing purposes only.
*/
@Nullable
public Modifiers getModifiers() {
if (mImpl.hasModifiers()) {
return Modifiers.fromProto(mImpl.getModifiers());
} else {
return null;
}
}
/**
* Gets the maximum number of lines that can be represented by the {@link Spannable}
* element. If not defined, the {@link Spannable} element will be treated as a single-line
* element. Intended for testing purposes only.
*/
@Nullable
public Int32Prop getMaxLines() {
if (mImpl.hasMaxLines()) {
return Int32Prop.fromProto(mImpl.getMaxLines());
} else {
return null;
}
}
/**
* Gets alignment of the {@link Spannable} content within its bounds. Note that a {@link
* Spannable} element will size itself to wrap its contents, so this option is meaningless
* for single-line content (for that, use alignment of the outer container). For multi-line
* content, however, this will set the alignment of lines relative to the {@link Spannable}
* element bounds. If not defined, defaults to TEXT_ALIGN_CENTER. Intended for testing
* purposes only.
*/
@Nullable
public HorizontalAlignmentProp getMultilineAlignment() {
if (mImpl.hasMultilineAlignment()) {
return HorizontalAlignmentProp.fromProto(mImpl.getMultilineAlignment());
} else {
return null;
}
}
/**
* Gets how to handle content which overflows the bound of the {@link Spannable} element. A
* {@link Spannable} element will grow as large as possible inside its parent container
* (while still respecting max_lines); if it cannot grow large enough to render all of its
* content, the content which cannot fit inside its container will be truncated. If not
* defined, defaults to TEXT_OVERFLOW_TRUNCATE. Intended for testing purposes only.
*/
@Nullable
public TextOverflowProp getOverflow() {
if (mImpl.hasOverflow()) {
return TextOverflowProp.fromProto(mImpl.getOverflow());
} else {
return null;
}
}
/**
* Gets the explicit height between lines of text. This is equivalent to the vertical
* distance between subsequent baselines. If not specified, defaults the font's recommended
* interline spacing. Intended for testing purposes only.
*/
@Nullable
public SpProp getLineHeight() {
if (mImpl.hasLineHeight()) {
return SpProp.fromProto(mImpl.getLineHeight());
} else {
return null;
}
}
/** @hide */
@RestrictTo(Scope.LIBRARY_GROUP)
@NonNull
public static Spannable fromProto(@NonNull LayoutElementProto.Spannable proto) {
return new Spannable(proto);
}
/** @hide */
@RestrictTo(Scope.LIBRARY_GROUP)
@NonNull
LayoutElementProto.Spannable toProto() {
return mImpl;
}
/** @hide */
@Override
@RestrictTo(Scope.LIBRARY_GROUP)
@NonNull
public LayoutElementProto.LayoutElement toLayoutElementProto() {
return LayoutElementProto.LayoutElement.newBuilder().setSpannable(mImpl).build();
}
/** Builder for {@link Spannable}. */
public static final class Builder implements LayoutElement.Builder {
private final LayoutElementProto.Spannable.Builder mImpl =
LayoutElementProto.Spannable.newBuilder();
public Builder() {}
/** Adds one item to the {@link Span} elements that form this {@link Spannable}. */
@NonNull
public Builder addSpan(@NonNull Span span) {
mImpl.addSpans(span.toSpanProto());
return this;
}
/** Sets {@link androidx.wear.tiles.ModifiersBuilders.Modifiers} for this element. */
@NonNull
public Builder setModifiers(@NonNull Modifiers modifiers) {
mImpl.setModifiers(modifiers.toProto());
return this;
}
/**
* Sets the maximum number of lines that can be represented by the {@link Spannable}
* element. If not defined, the {@link Spannable} element will be treated as a
* single-line element.
*/
@NonNull
public Builder setMaxLines(@NonNull Int32Prop maxLines) {
mImpl.setMaxLines(maxLines.toProto());
return this;
}
/**
* Sets the maximum number of lines that can be represented by the {@link Spannable}
* element. If not defined, the {@link Spannable} element will be treated as a
* single-line element.
*/
@NonNull
public Builder setMaxLines(@IntRange(from = 1) int maxLines) {
mImpl.setMaxLines(TypesProto.Int32Prop.newBuilder().setValue(maxLines));
return this;
}
/**
* Sets alignment of the {@link Spannable} content within its bounds. Note that a {@link
* Spannable} element will size itself to wrap its contents, so this option is
* meaningless for single-line content (for that, use alignment of the outer container).
* For multi-line content, however, this will set the alignment of lines relative to the
* {@link Spannable} element bounds. If not defined, defaults to TEXT_ALIGN_CENTER.
*/
@NonNull
public Builder setMultilineAlignment(
@NonNull HorizontalAlignmentProp multilineAlignment) {
mImpl.setMultilineAlignment(multilineAlignment.toProto());
return this;
}
/**
* Sets alignment of the {@link Spannable} content within its bounds. Note that a {@link
* Spannable} element will size itself to wrap its contents, so this option is
* meaningless for single-line content (for that, use alignment of the outer container).
* For multi-line content, however, this will set the alignment of lines relative to the
* {@link Spannable} element bounds. If not defined, defaults to TEXT_ALIGN_CENTER.
*/
@NonNull
public Builder setMultilineAlignment(@HorizontalAlignment int multilineAlignment) {
mImpl.setMultilineAlignment(
LayoutElementProto.HorizontalAlignmentProp.newBuilder()
.setValue(
LayoutElementProto.HorizontalAlignment.forNumber(
multilineAlignment)));
return this;
}
/**
* Sets how to handle content which overflows the bound of the {@link Spannable}
* element. A {@link Spannable} element will grow as large as possible inside its parent
* container (while still respecting max_lines); if it cannot grow large enough to
* render all of its content, the content which cannot fit inside its container will be
* truncated. If not defined, defaults to TEXT_OVERFLOW_TRUNCATE.
*/
@NonNull
public Builder setOverflow(@NonNull TextOverflowProp overflow) {
mImpl.setOverflow(overflow.toProto());
return this;
}
/**
* Sets how to handle content which overflows the bound of the {@link Spannable}
* element. A {@link Spannable} element will grow as large as possible inside its parent
* container (while still respecting max_lines); if it cannot grow large enough to
* render all of its content, the content which cannot fit inside its container will be
* truncated. If not defined, defaults to TEXT_OVERFLOW_TRUNCATE.
*/
@NonNull
public Builder setOverflow(@TextOverflow int overflow) {
mImpl.setOverflow(
LayoutElementProto.TextOverflowProp.newBuilder()
.setValue(LayoutElementProto.TextOverflow.forNumber(overflow)));
return this;
}
/**
* Sets the explicit height between lines of text. This is equivalent to the vertical
* distance between subsequent baselines. If not specified, defaults the font's
* recommended interline spacing.
*/
@NonNull
public Builder setLineHeight(@NonNull SpProp lineHeight) {
mImpl.setLineHeight(lineHeight.toProto());
return this;
}
@Override
@NonNull
public Spannable build() {
return Spannable.fromProto(mImpl.build());
}
}
}
/**
* A column of elements. Each child element will be laid out vertically, one after another (i.e.
* stacking down). This element will size itself to the smallest size required to hold all of
* its children (e.g. if it contains three elements sized 10x10, 20x20 and 30x30, the resulting
* column will be 30x60).
*
* <p>If specified, horizontal_alignment can be used to control the gravity inside the
* container, affecting the horizontal placement of children whose width are smaller than the
* resulting column width.
*/
public static final class Column implements LayoutElement {
private final LayoutElementProto.Column mImpl;
private Column(LayoutElementProto.Column impl) {
this.mImpl = impl;
}
/**
* Gets the list of child elements to place inside this {@link Column}. Intended for testing
* purposes only.
*/
@NonNull
public List<LayoutElement> getContents() {
return Collections.unmodifiableList(
mImpl.getContentsList().stream()
.map(LayoutElement::fromLayoutElementProto)
.collect(toList()));
}
/**
* Gets the horizontal alignment of elements inside this column, if they are narrower than
* the resulting width of the column. If not defined, defaults to HORIZONTAL_ALIGN_CENTER.
* Intended for testing purposes only.
*/
@Nullable
public HorizontalAlignmentProp getHorizontalAlignment() {
if (mImpl.hasHorizontalAlignment()) {
return HorizontalAlignmentProp.fromProto(mImpl.getHorizontalAlignment());
} else {
return null;
}
}
/**
* Gets the width of this column. If not defined, this will size itself to fit all of its
* children (i.e. a WrappedDimension). Intended for testing purposes only.
*/
@Nullable
public ContainerDimension getWidth() {
if (mImpl.hasWidth()) {
return ContainerDimension.fromContainerDimensionProto(mImpl.getWidth());
} else {
return null;
}
}
/**
* Gets the height of this column. If not defined, this will size itself to fit all of its
* children (i.e. a WrappedDimension). Intended for testing purposes only.
*/
@Nullable
public ContainerDimension getHeight() {
if (mImpl.hasHeight()) {
return ContainerDimension.fromContainerDimensionProto(mImpl.getHeight());
} else {
return null;
}
}
/**
* Gets {@link androidx.wear.tiles.ModifiersBuilders.Modifiers} for this element. Intended
* for testing purposes only.
*/
@Nullable
public Modifiers getModifiers() {
if (mImpl.hasModifiers()) {
return Modifiers.fromProto(mImpl.getModifiers());
} else {
return null;
}
}
/** @hide */
@RestrictTo(Scope.LIBRARY_GROUP)
@NonNull
public static Column fromProto(@NonNull LayoutElementProto.Column proto) {
return new Column(proto);
}
/** @hide */
@RestrictTo(Scope.LIBRARY_GROUP)
@NonNull
LayoutElementProto.Column toProto() {
return mImpl;
}
/** @hide */
@Override
@RestrictTo(Scope.LIBRARY_GROUP)
@NonNull
public LayoutElementProto.LayoutElement toLayoutElementProto() {
return LayoutElementProto.LayoutElement.newBuilder().setColumn(mImpl).build();
}
/** Builder for {@link Column}. */
public static final class Builder implements LayoutElement.Builder {
private final LayoutElementProto.Column.Builder mImpl =
LayoutElementProto.Column.newBuilder();
public Builder() {}
/** Adds one item to the list of child elements to place inside this {@link Column}. */
@NonNull
public Builder addContent(@NonNull LayoutElement content) {
mImpl.addContents(content.toLayoutElementProto());
return this;
}
/**
* Sets the horizontal alignment of elements inside this column, if they are narrower
* than the resulting width of the column. If not defined, defaults to
* HORIZONTAL_ALIGN_CENTER.
*/
@NonNull
public Builder setHorizontalAlignment(
@NonNull HorizontalAlignmentProp horizontalAlignment) {
mImpl.setHorizontalAlignment(horizontalAlignment.toProto());
return this;
}
/**
* Sets the horizontal alignment of elements inside this column, if they are narrower
* than the resulting width of the column. If not defined, defaults to
* HORIZONTAL_ALIGN_CENTER.
*/
@NonNull
public Builder setHorizontalAlignment(@HorizontalAlignment int horizontalAlignment) {
mImpl.setHorizontalAlignment(
LayoutElementProto.HorizontalAlignmentProp.newBuilder()
.setValue(
LayoutElementProto.HorizontalAlignment.forNumber(
horizontalAlignment)));
return this;
}
/**
* Sets the width of this column. If not defined, this will size itself to fit all of
* its children (i.e. a WrappedDimension).
*/
@NonNull
public Builder setWidth(@NonNull ContainerDimension width) {
mImpl.setWidth(width.toContainerDimensionProto());
return this;
}
/**
* Sets the height of this column. If not defined, this will size itself to fit all of
* its children (i.e. a WrappedDimension).
*/
@NonNull
public Builder setHeight(@NonNull ContainerDimension height) {
mImpl.setHeight(height.toContainerDimensionProto());
return this;
}
/** Sets {@link androidx.wear.tiles.ModifiersBuilders.Modifiers} for this element. */
@NonNull
public Builder setModifiers(@NonNull Modifiers modifiers) {
mImpl.setModifiers(modifiers.toProto());
return this;
}
@Override
@NonNull
public Column build() {
return Column.fromProto(mImpl.build());
}
}
}
/**
* A row of elements. Each child will be laid out horizontally, one after another (i.e. stacking
* to the right). This element will size itself to the smallest size required to hold all of its
* children (e.g. if it contains three elements sized 10x10, 20x20 and 30x30, the resulting row
* will be 60x30).
*
* <p>If specified, vertical_alignment can be used to control the gravity inside the container,
* affecting the vertical placement of children whose width are smaller than the resulting row
* height.
*/
public static final class Row implements LayoutElement {
private final LayoutElementProto.Row mImpl;
private Row(LayoutElementProto.Row impl) {
this.mImpl = impl;
}
/**
* Gets the list of child elements to place inside this {@link Row}. Intended for testing
* purposes only.
*/
@NonNull
public List<LayoutElement> getContents() {
return Collections.unmodifiableList(
mImpl.getContentsList().stream()
.map(LayoutElement::fromLayoutElementProto)
.collect(toList()));
}
/**
* Gets the vertical alignment of elements inside this row, if they are narrower than the
* resulting height of the row. If not defined, defaults to VERTICAL_ALIGN_CENTER. Intended
* for testing purposes only.
*/
@Nullable
public VerticalAlignmentProp getVerticalAlignment() {
if (mImpl.hasVerticalAlignment()) {
return VerticalAlignmentProp.fromProto(mImpl.getVerticalAlignment());
} else {
return null;
}
}
/**
* Gets the width of this row. If not defined, this will size itself to fit all of its
* children (i.e. a WrappedDimension). Intended for testing purposes only.
*/
@Nullable
public ContainerDimension getWidth() {
if (mImpl.hasWidth()) {
return ContainerDimension.fromContainerDimensionProto(mImpl.getWidth());
} else {
return null;
}
}
/**
* Gets the height of this row. If not defined, this will size itself to fit all of its
* children (i.e. a WrappedDimension). Intended for testing purposes only.
*/
@Nullable
public ContainerDimension getHeight() {
if (mImpl.hasHeight()) {
return ContainerDimension.fromContainerDimensionProto(mImpl.getHeight());
} else {
return null;
}
}
/**
* Gets {@link androidx.wear.tiles.ModifiersBuilders.Modifiers} for this element. Intended
* for testing purposes only.
*/
@Nullable
public Modifiers getModifiers() {
if (mImpl.hasModifiers()) {
return Modifiers.fromProto(mImpl.getModifiers());
} else {
return null;
}
}
/** @hide */
@RestrictTo(Scope.LIBRARY_GROUP)
@NonNull
public static Row fromProto(@NonNull LayoutElementProto.Row proto) {
return new Row(proto);
}
/** @hide */
@RestrictTo(Scope.LIBRARY_GROUP)
@NonNull
LayoutElementProto.Row toProto() {
return mImpl;
}
/** @hide */
@Override
@RestrictTo(Scope.LIBRARY_GROUP)
@NonNull
public LayoutElementProto.LayoutElement toLayoutElementProto() {
return LayoutElementProto.LayoutElement.newBuilder().setRow(mImpl).build();
}
/** Builder for {@link Row}. */
public static final class Builder implements LayoutElement.Builder {
private final LayoutElementProto.Row.Builder mImpl =
LayoutElementProto.Row.newBuilder();
public Builder() {}
/** Adds one item to the list of child elements to place inside this {@link Row}. */
@NonNull
public Builder addContent(@NonNull LayoutElement content) {
mImpl.addContents(content.toLayoutElementProto());
return this;
}
/**
* Sets the vertical alignment of elements inside this row, if they are narrower than
* the resulting height of the row. If not defined, defaults to VERTICAL_ALIGN_CENTER.
*/
@NonNull
public Builder setVerticalAlignment(@NonNull VerticalAlignmentProp verticalAlignment) {
mImpl.setVerticalAlignment(verticalAlignment.toProto());
return this;
}
/**
* Sets the vertical alignment of elements inside this row, if they are narrower than
* the resulting height of the row. If not defined, defaults to VERTICAL_ALIGN_CENTER.
*/
@NonNull
public Builder setVerticalAlignment(@VerticalAlignment int verticalAlignment) {
mImpl.setVerticalAlignment(
LayoutElementProto.VerticalAlignmentProp.newBuilder()
.setValue(
LayoutElementProto.VerticalAlignment.forNumber(
verticalAlignment)));
return this;
}
/**
* Sets the width of this row. If not defined, this will size itself to fit all of its
* children (i.e. a WrappedDimension).
*/
@NonNull
public Builder setWidth(@NonNull ContainerDimension width) {
mImpl.setWidth(width.toContainerDimensionProto());
return this;
}
/**
* Sets the height of this row. If not defined, this will size itself to fit all of its
* children (i.e. a WrappedDimension).
*/
@NonNull
public Builder setHeight(@NonNull ContainerDimension height) {
mImpl.setHeight(height.toContainerDimensionProto());
return this;
}
/** Sets {@link androidx.wear.tiles.ModifiersBuilders.Modifiers} for this element. */
@NonNull
public Builder setModifiers(@NonNull Modifiers modifiers) {
mImpl.setModifiers(modifiers.toProto());
return this;
}
@Override
@NonNull
public Row build() {
return Row.fromProto(mImpl.build());
}
}
}
/**
* An arc container. This container will fill itself to a circle, which fits inside its parent
* container, and all of its children will be placed on that circle. The fields anchor_angle and
* anchor_type can be used to specify where to draw children within this circle.
*/
public static final class Arc implements LayoutElement {
private final LayoutElementProto.Arc mImpl;
private Arc(LayoutElementProto.Arc impl) {
this.mImpl = impl;
}
/** Gets contents of this container. Intended for testing purposes only. */
@NonNull
public List<ArcLayoutElement> getContents() {
return Collections.unmodifiableList(
mImpl.getContentsList().stream()
.map(ArcLayoutElement::fromArcLayoutElementProto)
.collect(toList()));
}
/**
* Gets the angle for the anchor, used with anchor_type to determine where to draw children.
* Note that 0 degrees is the 12 o clock position on a device, and the angle sweeps
* clockwise. If not defined, defaults to 0 degrees.
*
* <p>Values do not have to be clamped to the range 0-360; values less than 0 degrees will
* sweep anti-clockwise (i.e. -90 degrees is equivalent to 270 degrees), and values >360
* will be be placed at X mod 360 degrees. Intended for testing purposes only.
*/
@Nullable
public DegreesProp getAnchorAngle() {
if (mImpl.hasAnchorAngle()) {
return DegreesProp.fromProto(mImpl.getAnchorAngle());
} else {
return null;
}
}
/**
* Gets how to align the contents of this container relative to anchor_angle. If not
* defined, defaults to ARC_ANCHOR_CENTER. Intended for testing purposes only.
*/
@Nullable
public ArcAnchorTypeProp getAnchorType() {
if (mImpl.hasAnchorType()) {
return ArcAnchorTypeProp.fromProto(mImpl.getAnchorType());
} else {
return null;
}
}
/**
* Gets vertical alignment of elements within the arc. If the {@link Arc}'s thickness is
* larger than the thickness of the element being drawn, this controls whether the element
* should be drawn towards the inner or outer edge of the arc, or drawn in the center. If
* not defined, defaults to VERTICAL_ALIGN_CENTER. Intended for testing purposes only.
*/
@Nullable
public VerticalAlignmentProp getVerticalAlign() {
if (mImpl.hasVerticalAlign()) {
return VerticalAlignmentProp.fromProto(mImpl.getVerticalAlign());
} else {
return null;
}
}
/**
* Gets {@link androidx.wear.tiles.ModifiersBuilders.Modifiers} for this element. Intended
* for testing purposes only.
*/
@Nullable
public Modifiers getModifiers() {
if (mImpl.hasModifiers()) {
return Modifiers.fromProto(mImpl.getModifiers());
} else {
return null;
}
}
/** @hide */
@RestrictTo(Scope.LIBRARY_GROUP)
@NonNull
public static Arc fromProto(@NonNull LayoutElementProto.Arc proto) {
return new Arc(proto);
}
/** @hide */
@RestrictTo(Scope.LIBRARY_GROUP)
@NonNull
LayoutElementProto.Arc toProto() {
return mImpl;
}
/** @hide */
@Override
@RestrictTo(Scope.LIBRARY_GROUP)
@NonNull
public LayoutElementProto.LayoutElement toLayoutElementProto() {
return LayoutElementProto.LayoutElement.newBuilder().setArc(mImpl).build();
}
/** Builder for {@link Arc}. */
public static final class Builder implements LayoutElement.Builder {
private final LayoutElementProto.Arc.Builder mImpl =
LayoutElementProto.Arc.newBuilder();
public Builder() {}
/** Adds one item to contents of this container. */
@NonNull
public Builder addContent(@NonNull ArcLayoutElement content) {
mImpl.addContents(content.toArcLayoutElementProto());
return this;
}
/**
* Sets the angle for the anchor, used with anchor_type to determine where to draw
* children. Note that 0 degrees is the 12 o clock position on a device, and the angle
* sweeps clockwise. If not defined, defaults to 0 degrees.
*
* <p>Values do not have to be clamped to the range 0-360; values less than 0 degrees
* will sweep anti-clockwise (i.e. -90 degrees is equivalent to 270 degrees), and values
* >360 will be be placed at X mod 360 degrees.
*/
@NonNull
public Builder setAnchorAngle(@NonNull DegreesProp anchorAngle) {
mImpl.setAnchorAngle(anchorAngle.toProto());
return this;
}
/**
* Sets how to align the contents of this container relative to anchor_angle. If not
* defined, defaults to ARC_ANCHOR_CENTER.
*/
@NonNull
public Builder setAnchorType(@NonNull ArcAnchorTypeProp anchorType) {
mImpl.setAnchorType(anchorType.toProto());
return this;
}
/**
* Sets how to align the contents of this container relative to anchor_angle. If not
* defined, defaults to ARC_ANCHOR_CENTER.
*/
@NonNull
public Builder setAnchorType(@ArcAnchorType int anchorType) {
mImpl.setAnchorType(
LayoutElementProto.ArcAnchorTypeProp.newBuilder()
.setValue(LayoutElementProto.ArcAnchorType.forNumber(anchorType)));
return this;
}
/**
* Sets vertical alignment of elements within the arc. If the {@link Arc}'s thickness is
* larger than the thickness of the element being drawn, this controls whether the
* element should be drawn towards the inner or outer edge of the arc, or drawn in the
* center. If not defined, defaults to VERTICAL_ALIGN_CENTER.
*/
@NonNull
public Builder setVerticalAlign(@NonNull VerticalAlignmentProp verticalAlign) {
mImpl.setVerticalAlign(verticalAlign.toProto());
return this;
}
/**
* Sets vertical alignment of elements within the arc. If the {@link Arc}'s thickness is
* larger than the thickness of the element being drawn, this controls whether the
* element should be drawn towards the inner or outer edge of the arc, or drawn in the
* center. If not defined, defaults to VERTICAL_ALIGN_CENTER.
*/
@NonNull
public Builder setVerticalAlign(@VerticalAlignment int verticalAlign) {
mImpl.setVerticalAlign(
LayoutElementProto.VerticalAlignmentProp.newBuilder()
.setValue(
LayoutElementProto.VerticalAlignment.forNumber(
verticalAlign)));
return this;
}
/** Sets {@link androidx.wear.tiles.ModifiersBuilders.Modifiers} for this element. */
@NonNull
public Builder setModifiers(@NonNull Modifiers modifiers) {
mImpl.setModifiers(modifiers.toProto());
return this;
}
@Override
@NonNull
public Arc build() {
return Arc.fromProto(mImpl.build());
}
}
}
/** A text element that can be used in an {@link Arc}. */
public static final class ArcText implements ArcLayoutElement {
private final LayoutElementProto.ArcText mImpl;
private ArcText(LayoutElementProto.ArcText impl) {
this.mImpl = impl;
}
/** Gets the text to render. Intended for testing purposes only. */
@Nullable
public StringProp getText() {
if (mImpl.hasText()) {
return StringProp.fromProto(mImpl.getText());
} else {
return null;
}
}
/**
* Gets the style of font to use (size, bold etc). If not specified, defaults to the
* platform's default body font. Intended for testing purposes only.
*/
@Nullable
public FontStyle getFontStyle() {
if (mImpl.hasFontStyle()) {
return FontStyle.fromProto(mImpl.getFontStyle());
} else {
return null;
}
}
/**
* Gets {@link androidx.wear.tiles.ModifiersBuilders.Modifiers} for this element. Intended
* for testing purposes only.
*/
@Nullable
public ArcModifiers getModifiers() {
if (mImpl.hasModifiers()) {
return ArcModifiers.fromProto(mImpl.getModifiers());
} else {
return null;
}
}
/** @hide */
@RestrictTo(Scope.LIBRARY_GROUP)
@NonNull
public static ArcText fromProto(@NonNull LayoutElementProto.ArcText proto) {
return new ArcText(proto);
}
/** @hide */
@RestrictTo(Scope.LIBRARY_GROUP)
@NonNull
LayoutElementProto.ArcText toProto() {
return mImpl;
}
/** @hide */
@Override
@RestrictTo(Scope.LIBRARY_GROUP)
@NonNull
public LayoutElementProto.ArcLayoutElement toArcLayoutElementProto() {
return LayoutElementProto.ArcLayoutElement.newBuilder().setText(mImpl).build();
}
/** Builder for {@link ArcText}. */
public static final class Builder implements ArcLayoutElement.Builder {
private final LayoutElementProto.ArcText.Builder mImpl =
LayoutElementProto.ArcText.newBuilder();
public Builder() {}
/** Sets the text to render. */
@NonNull
public Builder setText(@NonNull StringProp text) {
mImpl.setText(text.toProto());
return this;
}
/** Sets the text to render. */
@NonNull
public Builder setText(@NonNull String text) {
mImpl.setText(TypesProto.StringProp.newBuilder().setValue(text));
return this;
}
/**
* Sets the style of font to use (size, bold etc). If not specified, defaults to the
* platform's default body font.
*/
@NonNull
public Builder setFontStyle(@NonNull FontStyle fontStyle) {
mImpl.setFontStyle(fontStyle.toProto());
return this;
}
/** Sets {@link androidx.wear.tiles.ModifiersBuilders.Modifiers} for this element. */
@NonNull
public Builder setModifiers(@NonNull ArcModifiers modifiers) {
mImpl.setModifiers(modifiers.toProto());
return this;
}
@Override
@NonNull
public ArcText build() {
return ArcText.fromProto(mImpl.build());
}
}
}
/** A line that can be used in an {@link Arc} and renders as a round progress bar. */
public static final class ArcLine implements ArcLayoutElement {
private final LayoutElementProto.ArcLine mImpl;
private ArcLine(LayoutElementProto.ArcLine impl) {
this.mImpl = impl;
}
/**
* Gets the length of this line, in degrees. If not defined, defaults to 0. Intended for
* testing purposes only.
*/
@Nullable
public DegreesProp getLength() {
if (mImpl.hasLength()) {
return DegreesProp.fromProto(mImpl.getLength());
} else {
return null;
}
}
/**
* Gets the thickness of this line. If not defined, defaults to 0. Intended for testing
* purposes only.
*/
@Nullable
public DpProp getThickness() {
if (mImpl.hasThickness()) {
return DpProp.fromProto(mImpl.getThickness());
} else {
return null;
}
}
/** Gets the color of this line. Intended for testing purposes only. */
@Nullable
public ColorProp getColor() {
if (mImpl.hasColor()) {
return ColorProp.fromProto(mImpl.getColor());
} else {
return null;
}
}
/**
* Gets {@link androidx.wear.tiles.ModifiersBuilders.Modifiers} for this element. Intended
* for testing purposes only.
*/
@Nullable
public ArcModifiers getModifiers() {
if (mImpl.hasModifiers()) {
return ArcModifiers.fromProto(mImpl.getModifiers());
} else {
return null;
}
}
/** @hide */
@RestrictTo(Scope.LIBRARY_GROUP)
@NonNull
public static ArcLine fromProto(@NonNull LayoutElementProto.ArcLine proto) {
return new ArcLine(proto);
}
/** @hide */
@RestrictTo(Scope.LIBRARY_GROUP)
@NonNull
LayoutElementProto.ArcLine toProto() {
return mImpl;
}
/** @hide */
@Override
@RestrictTo(Scope.LIBRARY_GROUP)
@NonNull
public LayoutElementProto.ArcLayoutElement toArcLayoutElementProto() {
return LayoutElementProto.ArcLayoutElement.newBuilder().setLine(mImpl).build();
}
/** Builder for {@link ArcLine}. */
public static final class Builder implements ArcLayoutElement.Builder {
private final LayoutElementProto.ArcLine.Builder mImpl =
LayoutElementProto.ArcLine.newBuilder();
public Builder() {}
/** Sets the length of this line, in degrees. If not defined, defaults to 0. */
@NonNull
public Builder setLength(@NonNull DegreesProp length) {
mImpl.setLength(length.toProto());
return this;
}
/** Sets the thickness of this line. If not defined, defaults to 0. */
@NonNull
public Builder setThickness(@NonNull DpProp thickness) {
mImpl.setThickness(thickness.toProto());
return this;
}
/** Sets the color of this line. */
@NonNull
public Builder setColor(@NonNull ColorProp color) {
mImpl.setColor(color.toProto());
return this;
}
/** Sets {@link androidx.wear.tiles.ModifiersBuilders.Modifiers} for this element. */
@NonNull
public Builder setModifiers(@NonNull ArcModifiers modifiers) {
mImpl.setModifiers(modifiers.toProto());
return this;
}
@Override
@NonNull
public ArcLine build() {
return ArcLine.fromProto(mImpl.build());
}
}
}
/** A simple spacer used to provide padding between adjacent elements in an {@link Arc}. */
public static final class ArcSpacer implements ArcLayoutElement {
private final LayoutElementProto.ArcSpacer mImpl;
private ArcSpacer(LayoutElementProto.ArcSpacer impl) {
this.mImpl = impl;
}
/**
* Gets the length of this spacer, in degrees. If not defined, defaults to 0. Intended for
* testing purposes only.
*/
@Nullable
public DegreesProp getLength() {
if (mImpl.hasLength()) {
return DegreesProp.fromProto(mImpl.getLength());
} else {
return null;
}
}
/**
* Gets the thickness of this spacer, in DP. If not defined, defaults to 0. Intended for
* testing purposes only.
*/
@Nullable
public DpProp getThickness() {
if (mImpl.hasThickness()) {
return DpProp.fromProto(mImpl.getThickness());
} else {
return null;
}
}
/**
* Gets {@link androidx.wear.tiles.ModifiersBuilders.Modifiers} for this element. Intended
* for testing purposes only.
*/
@Nullable
public ArcModifiers getModifiers() {
if (mImpl.hasModifiers()) {
return ArcModifiers.fromProto(mImpl.getModifiers());
} else {
return null;
}
}
/** @hide */
@RestrictTo(Scope.LIBRARY_GROUP)
@NonNull
public static ArcSpacer fromProto(@NonNull LayoutElementProto.ArcSpacer proto) {
return new ArcSpacer(proto);
}
/** @hide */
@RestrictTo(Scope.LIBRARY_GROUP)
@NonNull
LayoutElementProto.ArcSpacer toProto() {
return mImpl;
}
/** @hide */
@Override
@RestrictTo(Scope.LIBRARY_GROUP)
@NonNull
public LayoutElementProto.ArcLayoutElement toArcLayoutElementProto() {
return LayoutElementProto.ArcLayoutElement.newBuilder().setSpacer(mImpl).build();
}
/** Builder for {@link ArcSpacer}. */
public static final class Builder implements ArcLayoutElement.Builder {
private final LayoutElementProto.ArcSpacer.Builder mImpl =
LayoutElementProto.ArcSpacer.newBuilder();
public Builder() {}
/** Sets the length of this spacer, in degrees. If not defined, defaults to 0. */
@NonNull
public Builder setLength(@NonNull DegreesProp length) {
mImpl.setLength(length.toProto());
return this;
}
/** Sets the thickness of this spacer, in DP. If not defined, defaults to 0. */
@NonNull
public Builder setThickness(@NonNull DpProp thickness) {
mImpl.setThickness(thickness.toProto());
return this;
}
/** Sets {@link androidx.wear.tiles.ModifiersBuilders.Modifiers} for this element. */
@NonNull
public Builder setModifiers(@NonNull ArcModifiers modifiers) {
mImpl.setModifiers(modifiers.toProto());
return this;
}
@Override
@NonNull
public ArcSpacer build() {
return ArcSpacer.fromProto(mImpl.build());
}
}
}
/** A container that allows a standard {@link LayoutElement} to be added to an {@link Arc}. */
public static final class ArcAdapter implements ArcLayoutElement {
private final LayoutElementProto.ArcAdapter mImpl;
private ArcAdapter(LayoutElementProto.ArcAdapter impl) {
this.mImpl = impl;
}
/** Gets the element to adapt to an {@link Arc}. Intended for testing purposes only. */
@Nullable
public LayoutElement getContent() {
if (mImpl.hasContent()) {
return LayoutElement.fromLayoutElementProto(mImpl.getContent());
} else {
return null;
}
}
/**
* Gets whether this adapter's contents should be rotated, according to its position in the
* arc or not. As an example, assume that an {@link Image} has been added to the arc, and
* ends up at the 3 o clock position. If rotate_contents = true, the image will be placed at
* the 3 o clock position, and will be rotated clockwise through 90 degrees. If
* rotate_contents = false, the image will be placed at the 3 o clock position, but itself
* will not be rotated. If not defined, defaults to false. Intended for testing purposes
* only.
*/
@Nullable
public BoolProp getRotateContents() {
if (mImpl.hasRotateContents()) {
return BoolProp.fromProto(mImpl.getRotateContents());
} else {
return null;
}
}
/** @hide */
@RestrictTo(Scope.LIBRARY_GROUP)
@NonNull
public static ArcAdapter fromProto(@NonNull LayoutElementProto.ArcAdapter proto) {
return new ArcAdapter(proto);
}
/** @hide */
@RestrictTo(Scope.LIBRARY_GROUP)
@NonNull
LayoutElementProto.ArcAdapter toProto() {
return mImpl;
}
/** @hide */
@Override
@RestrictTo(Scope.LIBRARY_GROUP)
@NonNull
public LayoutElementProto.ArcLayoutElement toArcLayoutElementProto() {
return LayoutElementProto.ArcLayoutElement.newBuilder().setAdapter(mImpl).build();
}
/** Builder for {@link ArcAdapter}. */
public static final class Builder implements ArcLayoutElement.Builder {
private final LayoutElementProto.ArcAdapter.Builder mImpl =
LayoutElementProto.ArcAdapter.newBuilder();
public Builder() {}
/** Sets the element to adapt to an {@link Arc}. */
@NonNull
public Builder setContent(@NonNull LayoutElement content) {
mImpl.setContent(content.toLayoutElementProto());
return this;
}
/**
* Sets whether this adapter's contents should be rotated, according to its position in
* the arc or not. As an example, assume that an {@link Image} has been added to the
* arc, and ends up at the 3 o clock position. If rotate_contents = true, the image will
* be placed at the 3 o clock position, and will be rotated clockwise through 90
* degrees. If rotate_contents = false, the image will be placed at the 3 o clock
* position, but itself will not be rotated. If not defined, defaults to false.
*/
@NonNull
public Builder setRotateContents(@NonNull BoolProp rotateContents) {
mImpl.setRotateContents(rotateContents.toProto());
return this;
}
/**
* Sets whether this adapter's contents should be rotated, according to its position in
* the arc or not. As an example, assume that an {@link Image} has been added to the
* arc, and ends up at the 3 o clock position. If rotate_contents = true, the image will
* be placed at the 3 o clock position, and will be rotated clockwise through 90
* degrees. If rotate_contents = false, the image will be placed at the 3 o clock
* position, but itself will not be rotated. If not defined, defaults to false.
*/
@SuppressLint("MissingGetterMatchingBuilder")
@NonNull
public Builder setRotateContents(boolean rotateContents) {
mImpl.setRotateContents(TypesProto.BoolProp.newBuilder().setValue(rotateContents));
return this;
}
@Override
@NonNull
public ArcAdapter build() {
return ArcAdapter.fromProto(mImpl.build());
}
}
}
/**
* Interface defining the root of all layout elements. This exists to act as a holder for all of
* the actual layout elements above.
*/
public interface LayoutElement {
/**
* Get the protocol buffer representation of this object.
*
* @hide
*/
@RestrictTo(Scope.LIBRARY_GROUP)
@NonNull
LayoutElementProto.LayoutElement toLayoutElementProto();
/**
* Return an instance of one of this object's subtypes, from the protocol buffer
* representation.
*
* @hide
*/
@RestrictTo(Scope.LIBRARY_GROUP)
@NonNull
static LayoutElement fromLayoutElementProto(
@NonNull LayoutElementProto.LayoutElement proto) {
if (proto.hasColumn()) {
return Column.fromProto(proto.getColumn());
}
if (proto.hasRow()) {
return Row.fromProto(proto.getRow());
}
if (proto.hasBox()) {
return Box.fromProto(proto.getBox());
}
if (proto.hasSpacer()) {
return Spacer.fromProto(proto.getSpacer());
}
if (proto.hasText()) {
return Text.fromProto(proto.getText());
}
if (proto.hasImage()) {
return Image.fromProto(proto.getImage());
}
if (proto.hasArc()) {
return Arc.fromProto(proto.getArc());
}
if (proto.hasSpannable()) {
return Spannable.fromProto(proto.getSpannable());
}
throw new IllegalStateException("Proto was not a recognised instance of LayoutElement");
}
/** Builder to create {@link LayoutElement} objects. */
@SuppressLint("StaticFinalBuilder")
interface Builder {
/** Builds an instance with values accumulated in this Builder. */
@NonNull
LayoutElement build();
}
}
/**
* Interface defining the root of all elements that can be used in an {@link Arc}. This exists
* to act as a holder for all of the actual arc layout elements above.
*/
public interface ArcLayoutElement {
/**
* Get the protocol buffer representation of this object.
*
* @hide
*/
@RestrictTo(Scope.LIBRARY_GROUP)
@NonNull
LayoutElementProto.ArcLayoutElement toArcLayoutElementProto();
/**
* Return an instance of one of this object's subtypes, from the protocol buffer
* representation.
*
* @hide
*/
@RestrictTo(Scope.LIBRARY_GROUP)
@NonNull
static ArcLayoutElement fromArcLayoutElementProto(
@NonNull LayoutElementProto.ArcLayoutElement proto) {
if (proto.hasText()) {
return ArcText.fromProto(proto.getText());
}
if (proto.hasLine()) {
return ArcLine.fromProto(proto.getLine());
}
if (proto.hasSpacer()) {
return ArcSpacer.fromProto(proto.getSpacer());
}
if (proto.hasAdapter()) {
return ArcAdapter.fromProto(proto.getAdapter());
}
throw new IllegalStateException(
"Proto was not a recognised instance of ArcLayoutElement");
}
/** Builder to create {@link ArcLayoutElement} objects. */
@SuppressLint("StaticFinalBuilder")
interface Builder {
/** Builds an instance with values accumulated in this Builder. */
@NonNull
ArcLayoutElement build();
}
}
/** A complete layout. */
public static final class Layout {
private final LayoutElementProto.Layout mImpl;
private Layout(LayoutElementProto.Layout impl) {
this.mImpl = impl;
}
/** Gets the root element in the layout. Intended for testing purposes only. */
@Nullable
public LayoutElement getRoot() {
if (mImpl.hasRoot()) {
return LayoutElement.fromLayoutElementProto(mImpl.getRoot());
} else {
return null;
}
}
/** @hide */
@RestrictTo(Scope.LIBRARY_GROUP)
@NonNull
public static Layout fromProto(@NonNull LayoutElementProto.Layout proto) {
return new Layout(proto);
}
/** Returns the {@link Layout} object containing the given layout element. */
@NonNull
public static Layout fromLayoutElement(@NonNull LayoutElement layoutElement) {
return new Builder().setRoot(layoutElement).build();
}
/** @hide */
@RestrictTo(Scope.LIBRARY_GROUP)
@NonNull
public LayoutElementProto.Layout toProto() {
return mImpl;
}
/** Builder for {@link Layout} */
public static final class Builder {
private final LayoutElementProto.Layout.Builder mImpl =
LayoutElementProto.Layout.newBuilder();
public Builder() {}
/** Sets the root element in the layout. */
@NonNull
public Builder setRoot(@NonNull LayoutElement root) {
mImpl.setRoot(root.toLayoutElementProto());
return this;
}
/** Builds an instance from accumulated values. */
@NonNull
public Layout build() {
return Layout.fromProto(mImpl.build());
}
}
}
/** Font styles, currently set up to match Wear's font styling. */
public static class FontStyles {
private static final int LARGE_SCREEN_WIDTH_DP = 210;
private FontStyles() {
}
private static boolean isLargeScreen(@NonNull DeviceParameters deviceParameters) {
return deviceParameters.getScreenWidthDp() >= LARGE_SCREEN_WIDTH_DP;
}
/** Font style for large display text. */
@NonNull
public static FontStyle.Builder display1(@NonNull DeviceParameters deviceParameters) {
return new FontStyle.Builder()
.setWeight(FONT_WEIGHT_BOLD)
.setSize(DimensionBuilders.sp(isLargeScreen(deviceParameters) ? 54 : 50));
}
/** Font style for medium display text. */
@NonNull
public static FontStyle.Builder display2(@NonNull DeviceParameters deviceParameters) {
return new FontStyle.Builder()
.setWeight(FONT_WEIGHT_BOLD)
.setSize(DimensionBuilders.sp(isLargeScreen(deviceParameters) ? 44 : 40));
}
/** Font style for small display text. */
@NonNull
public static FontStyle.Builder display3(@NonNull DeviceParameters deviceParameters) {
return new FontStyle.Builder()
.setWeight(FONT_WEIGHT_BOLD)
.setSize(DimensionBuilders.sp(isLargeScreen(deviceParameters) ? 34 : 30));
}
/** Font style for large title text. */
@NonNull
public static FontStyle.Builder title1(@NonNull DeviceParameters deviceParameters) {
return new FontStyle.Builder()
.setWeight(FONT_WEIGHT_BOLD)
.setSize(DimensionBuilders.sp(isLargeScreen(deviceParameters) ? 26 : 24));
}
/** Font style for medium title text. */
@NonNull
public static FontStyle.Builder title2(@NonNull DeviceParameters deviceParameters) {
return new FontStyle.Builder()
.setWeight(FONT_WEIGHT_BOLD)
.setSize(DimensionBuilders.sp(isLargeScreen(deviceParameters) ? 22 : 20));
}
/** Font style for small title text. */
@NonNull
public static FontStyle.Builder title3(@NonNull DeviceParameters deviceParameters) {
return new FontStyle.Builder()
.setWeight(FONT_WEIGHT_BOLD)
.setSize(DimensionBuilders.sp(isLargeScreen(deviceParameters) ? 18 : 16));
}
/** Font style for large body text. */
@NonNull
public static FontStyle.Builder body1(@NonNull DeviceParameters deviceParameters) {
return new FontStyle.Builder()
.setSize(DimensionBuilders.sp(isLargeScreen(deviceParameters) ? 18 : 16));
}
/** Font style for medium body text. */
@NonNull
public static FontStyle.Builder body2(@NonNull DeviceParameters deviceParameters) {
return new FontStyle.Builder()
.setSize(DimensionBuilders.sp(isLargeScreen(deviceParameters) ? 16 : 14));
}
/** Font style for button text. */
@NonNull
public static FontStyle.Builder button(@NonNull DeviceParameters deviceParameters) {
return new FontStyle.Builder()
.setWeight(FONT_WEIGHT_BOLD)
.setSize(DimensionBuilders.sp(isLargeScreen(deviceParameters) ? 16 : 14));
}
/** Font style for large caption text. */
@NonNull
public static FontStyle.Builder caption1(@NonNull DeviceParameters deviceParameters) {
return new FontStyle.Builder()
.setSize(DimensionBuilders.sp(isLargeScreen(deviceParameters) ? 16 : 14));
}
/** Font style for medium caption text. */
@NonNull
public static FontStyle.Builder caption2(@NonNull DeviceParameters deviceParameters) {
return new FontStyle.Builder()
.setSize(DimensionBuilders.sp(isLargeScreen(deviceParameters) ? 14 : 12));
}
}
}