1 /* 2 * Copyright (C) 2023 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 package android.text.style; 18 19 import static com.android.text.flags.Flags.FLAG_NO_BREAK_NO_HYPHENATION_SPAN; 20 21 import android.annotation.FlaggedApi; 22 import android.annotation.NonNull; 23 import android.graphics.text.LineBreakConfig; 24 import android.os.Parcel; 25 import android.text.ParcelableSpan; 26 import android.text.TextUtils; 27 28 import java.util.Objects; 29 30 /** 31 * LineBreakSpan for changing line break style of the specific region of the text. 32 */ 33 @FlaggedApi(FLAG_NO_BREAK_NO_HYPHENATION_SPAN) 34 @android.ravenwood.annotation.RavenwoodKeepWholeClass 35 public final class LineBreakConfigSpan implements ParcelableSpan { 36 private final LineBreakConfig mLineBreakConfig; 37 38 /** 39 * Construct a new {@link LineBreakConfigSpan} 40 * @param lineBreakConfig a line break config 41 */ 42 @FlaggedApi(FLAG_NO_BREAK_NO_HYPHENATION_SPAN) LineBreakConfigSpan(@onNull LineBreakConfig lineBreakConfig)43 public LineBreakConfigSpan(@NonNull LineBreakConfig lineBreakConfig) { 44 mLineBreakConfig = lineBreakConfig; 45 } 46 47 /** 48 * Gets an associated line break config. 49 * @return associated line break config. 50 */ 51 @FlaggedApi(FLAG_NO_BREAK_NO_HYPHENATION_SPAN) getLineBreakConfig()52 public @NonNull LineBreakConfig getLineBreakConfig() { 53 return mLineBreakConfig; 54 } 55 56 /** 57 * A specialized {@link LineBreakConfigSpan} that used for preventing line break. 58 * 59 * This is useful when you want to preserve some words in the same line. 60 * Note that even if this style is specified, the grapheme based line break is still performed 61 * for preventing clipping text. 62 * 63 * @see LineBreakConfigSpan 64 */ 65 @FlaggedApi(FLAG_NO_BREAK_NO_HYPHENATION_SPAN) createNoBreakSpan()66 public static @NonNull LineBreakConfigSpan createNoBreakSpan() { 67 return new LineBreakConfigSpan(sNoBreakConfig); 68 } 69 70 /** 71 * A specialized {@link LineBreakConfigSpan} that used for preventing hyphenation. 72 */ 73 @FlaggedApi(FLAG_NO_BREAK_NO_HYPHENATION_SPAN) createNoHyphenationSpan()74 public static @NonNull LineBreakConfigSpan createNoHyphenationSpan() { 75 return new LineBreakConfigSpan(sNoHyphenationConfig); 76 } 77 78 @Override equals(Object o)79 public boolean equals(Object o) { 80 if (this == o) return true; 81 if (!(o instanceof LineBreakConfigSpan)) return false; 82 LineBreakConfigSpan that = (LineBreakConfigSpan) o; 83 return Objects.equals(mLineBreakConfig, that.mLineBreakConfig); 84 } 85 86 @Override hashCode()87 public int hashCode() { 88 return Objects.hash(mLineBreakConfig); 89 } 90 91 @Override toString()92 public String toString() { 93 return "LineBreakConfigSpan{mLineBreakConfig=" + mLineBreakConfig + '}'; 94 } 95 96 private static final LineBreakConfig sNoHyphenationConfig = new LineBreakConfig.Builder() 97 .setHyphenation(LineBreakConfig.HYPHENATION_DISABLED) 98 .build(); 99 100 private static final LineBreakConfig sNoBreakConfig = new LineBreakConfig.Builder() 101 .setLineBreakStyle(LineBreakConfig.LINE_BREAK_STYLE_NO_BREAK) 102 .build(); 103 104 @Override describeContents()105 public int describeContents() { 106 return 0; 107 } 108 109 @Override writeToParcel(@onNull Parcel dest, int flags)110 public void writeToParcel(@NonNull Parcel dest, int flags) { 111 writeToParcelInternal(dest, flags); 112 } 113 114 @Override getSpanTypeId()115 public int getSpanTypeId() { 116 return getSpanTypeIdInternal(); 117 } 118 119 /** @hide */ 120 @Override getSpanTypeIdInternal()121 public int getSpanTypeIdInternal() { 122 return TextUtils.LINE_BREAK_CONFIG_SPAN; 123 } 124 125 /** @hide */ 126 @Override writeToParcelInternal(@onNull Parcel dest, int flags)127 public void writeToParcelInternal(@NonNull Parcel dest, int flags) { 128 dest.writeParcelable(mLineBreakConfig, flags); 129 } 130 131 @NonNull 132 public static final Creator<LineBreakConfigSpan> CREATOR = new Creator<>() { 133 134 @Override 135 public LineBreakConfigSpan createFromParcel(Parcel source) { 136 LineBreakConfig lbc = source.readParcelable( 137 LineBreakConfig.class.getClassLoader(), LineBreakConfig.class); 138 return new LineBreakConfigSpan(lbc); 139 } 140 141 @Override 142 public LineBreakConfigSpan[] newArray(int size) { 143 return new LineBreakConfigSpan[size]; 144 } 145 }; 146 } 147