974 lines
33 KiB
Java
974 lines
33 KiB
Java
/*
|
|
* Copyright (C) 2017 The Android Open Source Project
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
package android.text;
|
|
|
|
import static java.lang.annotation.RetentionPolicy.SOURCE;
|
|
|
|
import android.annotation.CurrentTimeMillisLong;
|
|
import android.annotation.IntDef;
|
|
import android.annotation.IntRange;
|
|
import android.annotation.NonNull;
|
|
import android.annotation.Nullable;
|
|
import android.annotation.SystemApi;
|
|
import android.annotation.TestApi;
|
|
import android.compat.annotation.UnsupportedAppUsage;
|
|
import android.graphics.fonts.FontStyle;
|
|
import android.graphics.fonts.FontVariationAxis;
|
|
import android.icu.util.ULocale;
|
|
import android.os.Build;
|
|
import android.os.LocaleList;
|
|
import android.os.Parcel;
|
|
import android.os.Parcelable;
|
|
|
|
import java.io.File;
|
|
import java.lang.annotation.Retention;
|
|
import java.util.ArrayList;
|
|
import java.util.Collections;
|
|
import java.util.List;
|
|
import java.util.Locale;
|
|
import java.util.Objects;
|
|
|
|
|
|
/**
|
|
* Font configuration descriptions for System fonts.
|
|
*
|
|
* FontConfig represents the configuration for the fonts installed on the system. It is made of list
|
|
* of font families and aliases.
|
|
*
|
|
* @see FontFamily
|
|
* @see Alias
|
|
* @hide
|
|
*/
|
|
@SystemApi
|
|
@TestApi
|
|
public final class FontConfig implements Parcelable {
|
|
private final @NonNull List<FontFamily> mFamilies;
|
|
private final @NonNull List<Alias> mAliases;
|
|
private final @NonNull List<NamedFamilyList> mNamedFamilyLists;
|
|
private final @NonNull List<Customization.LocaleFallback> mLocaleFallbackCustomizations;
|
|
private final long mLastModifiedTimeMillis;
|
|
private final int mConfigVersion;
|
|
|
|
/**
|
|
* Construct a FontConfig instance.
|
|
*
|
|
* @param families a list of font families.
|
|
* @param aliases a list of aliases.
|
|
*
|
|
* @hide Only system server can create this instance and passed via IPC.
|
|
*/
|
|
public FontConfig(@NonNull List<FontFamily> families, @NonNull List<Alias> aliases,
|
|
@NonNull List<NamedFamilyList> namedFamilyLists,
|
|
@NonNull List<Customization.LocaleFallback> localeFallbackCustomizations,
|
|
long lastModifiedTimeMillis, @IntRange(from = 0) int configVersion) {
|
|
mFamilies = families;
|
|
mAliases = aliases;
|
|
mNamedFamilyLists = namedFamilyLists;
|
|
mLocaleFallbackCustomizations = localeFallbackCustomizations;
|
|
mLastModifiedTimeMillis = lastModifiedTimeMillis;
|
|
mConfigVersion = configVersion;
|
|
}
|
|
|
|
/**
|
|
* @hide Keep this constructor for reoborectric.
|
|
*/
|
|
public FontConfig(@NonNull List<FontFamily> families, @NonNull List<Alias> aliases,
|
|
long lastModifiedTimeMillis, @IntRange(from = 0) int configVersion) {
|
|
this(families, aliases, Collections.emptyList(), Collections.emptyList(),
|
|
lastModifiedTimeMillis, configVersion);
|
|
}
|
|
|
|
|
|
/**
|
|
* Returns the ordered list of font families available in the system.
|
|
*
|
|
* @return a list of font families.
|
|
* @see FontFamily
|
|
*/
|
|
public @NonNull List<FontFamily> getFontFamilies() {
|
|
return mFamilies;
|
|
}
|
|
|
|
/**
|
|
* Returns the list of aliases for mapping font families with other names.
|
|
*
|
|
* @return a list of font families.
|
|
* @see Alias
|
|
*/
|
|
public @NonNull List<Alias> getAliases() {
|
|
return mAliases;
|
|
}
|
|
|
|
public @NonNull List<NamedFamilyList> getNamedFamilyLists() {
|
|
return mNamedFamilyLists;
|
|
}
|
|
|
|
/**
|
|
* Returns a locale fallback customizations.
|
|
*
|
|
* This field is used for creating the system fallback in the system server. This field is
|
|
* always empty in the application process.
|
|
*
|
|
* @hide
|
|
*/
|
|
public @NonNull List<Customization.LocaleFallback> getLocaleFallbackCustomizations() {
|
|
return mLocaleFallbackCustomizations;
|
|
}
|
|
|
|
/**
|
|
* Returns the last modified time in milliseconds.
|
|
*
|
|
* This is a value of {@link System#currentTimeMillis()} when the system font configuration was
|
|
* modified last time.
|
|
*
|
|
* If there is no update, this return 0.
|
|
*/
|
|
public @CurrentTimeMillisLong long getLastModifiedTimeMillis() {
|
|
return mLastModifiedTimeMillis;
|
|
}
|
|
|
|
/**
|
|
* Returns the monotonically increasing config version value.
|
|
*
|
|
* The config version is reset to 0 when the system is restarted.
|
|
*/
|
|
public @IntRange(from = 0) int getConfigVersion() {
|
|
return mConfigVersion;
|
|
}
|
|
|
|
/**
|
|
* Returns the ordered list of families included in the system fonts.
|
|
* @deprecated Use getFontFamilies instead.
|
|
* @hide
|
|
*/
|
|
@Deprecated
|
|
@UnsupportedAppUsage(maxTargetSdk = Build.VERSION_CODES.R, trackingBug = 170729553)
|
|
public @NonNull FontFamily[] getFamilies() {
|
|
return mFamilies.toArray(new FontFamily[0]);
|
|
}
|
|
|
|
@Override
|
|
public int describeContents() {
|
|
return 0;
|
|
}
|
|
|
|
@Override
|
|
public void writeToParcel(@NonNull Parcel dest, int flags) {
|
|
dest.writeTypedList(mFamilies, flags);
|
|
dest.writeTypedList(mAliases, flags);
|
|
dest.writeTypedList(mNamedFamilyLists, flags);
|
|
dest.writeLong(mLastModifiedTimeMillis);
|
|
dest.writeInt(mConfigVersion);
|
|
}
|
|
|
|
public static final @NonNull Creator<FontConfig> CREATOR = new Creator<FontConfig>() {
|
|
@Override
|
|
public FontConfig createFromParcel(Parcel source) {
|
|
final List<FontFamily> families = new ArrayList<>();
|
|
source.readTypedList(families, FontFamily.CREATOR);
|
|
final List<Alias> aliases = new ArrayList<>();
|
|
source.readTypedList(aliases, Alias.CREATOR);
|
|
final List<NamedFamilyList> familyLists = new ArrayList<>();
|
|
source.readTypedList(familyLists, NamedFamilyList.CREATOR);
|
|
long lastModifiedDate = source.readLong();
|
|
int configVersion = source.readInt();
|
|
return new FontConfig(families, aliases, familyLists,
|
|
Collections.emptyList(), // Don't need to pass customization to API caller.
|
|
lastModifiedDate, configVersion);
|
|
}
|
|
|
|
@Override
|
|
public FontConfig[] newArray(int size) {
|
|
return new FontConfig[size];
|
|
}
|
|
};
|
|
|
|
@Override
|
|
public boolean equals(Object o) {
|
|
if (this == o) return true;
|
|
if (o == null || getClass() != o.getClass()) return false;
|
|
FontConfig that = (FontConfig) o;
|
|
return mLastModifiedTimeMillis == that.mLastModifiedTimeMillis
|
|
&& mConfigVersion == that.mConfigVersion
|
|
&& Objects.equals(mFamilies, that.mFamilies)
|
|
&& Objects.equals(mAliases, that.mAliases);
|
|
}
|
|
|
|
@Override
|
|
public int hashCode() {
|
|
return Objects.hash(mFamilies, mAliases, mLastModifiedTimeMillis, mConfigVersion);
|
|
}
|
|
|
|
@Override
|
|
public String toString() {
|
|
return "FontConfig{"
|
|
+ "mFamilies=" + mFamilies
|
|
+ ", mAliases=" + mAliases
|
|
+ ", mLastModifiedTimeMillis=" + mLastModifiedTimeMillis
|
|
+ ", mConfigVersion=" + mConfigVersion
|
|
+ '}';
|
|
}
|
|
|
|
/**
|
|
* Represents single font entry in system font configuration.
|
|
*
|
|
* A font is the most primitive unit of drawing character shapes. A font in system configuration
|
|
* is always referring a single OpenType compliant regular file in the file system.
|
|
*
|
|
* @see android.graphics.fonts.Font
|
|
*/
|
|
public static final class Font implements Parcelable {
|
|
private final @NonNull File mFile;
|
|
private final @Nullable File mOriginalFile;
|
|
private final @NonNull String mPostScriptName;
|
|
private final @NonNull FontStyle mStyle;
|
|
private final @IntRange(from = 0) int mIndex;
|
|
private final @NonNull String mFontVariationSettings;
|
|
private final @Nullable String mFontFamilyName;
|
|
private final @VarTypeAxes int mVarTypeAxes;
|
|
|
|
/** @hide */
|
|
@Retention(SOURCE)
|
|
@IntDef(prefix = { "VAR_TYPE_AXES_" }, value = {
|
|
VAR_TYPE_AXES_NONE,
|
|
VAR_TYPE_AXES_WGHT,
|
|
VAR_TYPE_AXES_ITAL,
|
|
})
|
|
public @interface VarTypeAxes {}
|
|
|
|
/** @hide */
|
|
public static final int VAR_TYPE_AXES_NONE = 0;
|
|
/** @hide */
|
|
public static final int VAR_TYPE_AXES_WGHT = 1;
|
|
/** @hide */
|
|
public static final int VAR_TYPE_AXES_ITAL = 2;
|
|
|
|
/**
|
|
* Construct a Font instance.
|
|
*
|
|
* @hide Only system server can create this instance and passed via IPC.
|
|
*/
|
|
public Font(@NonNull File file, @Nullable File originalFile, @NonNull String postScriptName,
|
|
@NonNull FontStyle style, @IntRange(from = 0) int index,
|
|
@NonNull String fontVariationSettings, @Nullable String fontFamilyName,
|
|
@VarTypeAxes int varTypeAxes) {
|
|
mFile = file;
|
|
mOriginalFile = originalFile;
|
|
mPostScriptName = postScriptName;
|
|
mStyle = style;
|
|
mIndex = index;
|
|
mFontVariationSettings = fontVariationSettings;
|
|
mFontFamilyName = fontFamilyName;
|
|
mVarTypeAxes = varTypeAxes;
|
|
}
|
|
|
|
@Override
|
|
public int describeContents() {
|
|
return 0;
|
|
}
|
|
|
|
@Override
|
|
public void writeToParcel(@NonNull Parcel dest, int flags) {
|
|
dest.writeString8(mFile.getAbsolutePath());
|
|
dest.writeString8(mOriginalFile == null ? null : mOriginalFile.getAbsolutePath());
|
|
dest.writeString8(mPostScriptName);
|
|
dest.writeInt(mStyle.getWeight());
|
|
dest.writeInt(mStyle.getSlant());
|
|
dest.writeInt(mIndex);
|
|
dest.writeString8(mFontVariationSettings);
|
|
dest.writeString8(mFontFamilyName);
|
|
dest.writeInt(mVarTypeAxes);
|
|
}
|
|
|
|
public static final @NonNull Creator<Font> CREATOR = new Creator<Font>() {
|
|
|
|
@Override
|
|
public Font createFromParcel(Parcel source) {
|
|
File path = new File(source.readString8());
|
|
String originalPathStr = source.readString8();
|
|
File originalPath = originalPathStr == null ? null : new File(originalPathStr);
|
|
String postScriptName = source.readString8();
|
|
int weight = source.readInt();
|
|
int slant = source.readInt();
|
|
int index = source.readInt();
|
|
String varSettings = source.readString8();
|
|
String fallback = source.readString8();
|
|
int varTypeAxes = source.readInt();
|
|
|
|
return new Font(path, originalPath, postScriptName, new FontStyle(weight, slant),
|
|
index, varSettings, fallback, varTypeAxes);
|
|
}
|
|
|
|
@Override
|
|
public Font[] newArray(int size) {
|
|
return new Font[size];
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Returns the font file.
|
|
*/
|
|
public @NonNull File getFile() {
|
|
return mFile;
|
|
}
|
|
|
|
/**
|
|
* Returns the original font file in the system directory.
|
|
*
|
|
* If the font file is not updated, returns null.
|
|
*
|
|
* @return returns the original font file in the system if the font file is updated. Returns
|
|
* null if the font file is not updated.
|
|
* @hide
|
|
*/
|
|
public @Nullable File getOriginalFile() {
|
|
return mOriginalFile;
|
|
}
|
|
|
|
/**
|
|
* Returns the font style.
|
|
*/
|
|
public @NonNull FontStyle getStyle() {
|
|
return mStyle;
|
|
}
|
|
|
|
|
|
/**
|
|
* Return a font variation settings.
|
|
*/
|
|
public @NonNull String getFontVariationSettings() {
|
|
return mFontVariationSettings;
|
|
}
|
|
|
|
/**
|
|
* A {@link Font} can be configured to be in the {@code Fallback List} for a
|
|
* {@link FontFamily}.
|
|
*
|
|
* For example a serif Hebrew [Font] can be defined in the {@code Fallback List} for
|
|
* {@code "serif"} {@link FontFamily}.
|
|
*
|
|
* If the return value is not {@code null}, then the font will be used in the
|
|
* {@code Fallback List} of that {@link FontFamily}.
|
|
*
|
|
* If the return value is {@code null}, then the font will be used in {@code Fallback List}
|
|
* of all {@link FontFamily}s.
|
|
*/
|
|
public @Nullable String getFontFamilyName() {
|
|
return mFontFamilyName;
|
|
}
|
|
|
|
/**
|
|
* Returns the index to be used to access this font when accessing a TTC file.
|
|
*/
|
|
public int getTtcIndex() {
|
|
return mIndex;
|
|
}
|
|
|
|
/**
|
|
* Returns the PostScript name of this font.
|
|
*/
|
|
public @NonNull String getPostScriptName() {
|
|
return mPostScriptName;
|
|
}
|
|
|
|
/**
|
|
* Returns the list of supported axes tags for variable family type resolution.
|
|
*
|
|
* @hide
|
|
*/
|
|
public @VarTypeAxes int getVarTypeAxes() {
|
|
return mVarTypeAxes;
|
|
}
|
|
|
|
/**
|
|
* Returns the list of axes associated to this font.
|
|
* @deprecated Use getFontVariationSettings
|
|
* @hide
|
|
*/
|
|
@Deprecated
|
|
@UnsupportedAppUsage(maxTargetSdk = Build.VERSION_CODES.R, trackingBug = 170729553)
|
|
public @NonNull FontVariationAxis[] getAxes() {
|
|
return FontVariationAxis.fromFontVariationSettings(mFontVariationSettings);
|
|
}
|
|
|
|
/**
|
|
* Returns the weight value for this font.
|
|
* @deprecated Use getStyle instead.
|
|
* @hide
|
|
*/
|
|
@Deprecated
|
|
@UnsupportedAppUsage(maxTargetSdk = Build.VERSION_CODES.R, trackingBug = 170729553)
|
|
public int getWeight() {
|
|
return getStyle().getWeight();
|
|
}
|
|
|
|
/**
|
|
* Returns whether this font is italic.
|
|
* @deprecated Use getStyle instead.
|
|
* @hide
|
|
*/
|
|
@Deprecated
|
|
@UnsupportedAppUsage(maxTargetSdk = Build.VERSION_CODES.R, trackingBug = 170729553)
|
|
public boolean isItalic() {
|
|
return getStyle().getSlant() == FontStyle.FONT_SLANT_ITALIC;
|
|
}
|
|
|
|
@Override
|
|
public boolean equals(Object o) {
|
|
if (this == o) return true;
|
|
if (o == null || getClass() != o.getClass()) return false;
|
|
Font font = (Font) o;
|
|
return mIndex == font.mIndex
|
|
&& Objects.equals(mFile, font.mFile)
|
|
&& Objects.equals(mOriginalFile, font.mOriginalFile)
|
|
&& Objects.equals(mStyle, font.mStyle)
|
|
&& Objects.equals(mFontVariationSettings, font.mFontVariationSettings)
|
|
&& Objects.equals(mFontFamilyName, font.mFontFamilyName)
|
|
&& mVarTypeAxes == font.mVarTypeAxes;
|
|
}
|
|
|
|
@Override
|
|
public int hashCode() {
|
|
return Objects.hash(mFile, mOriginalFile, mStyle, mIndex, mFontVariationSettings,
|
|
mFontFamilyName, mVarTypeAxes);
|
|
}
|
|
|
|
@Override
|
|
public String toString() {
|
|
return "Font{"
|
|
+ "mFile=" + mFile
|
|
+ ", mOriginalFile=" + mOriginalFile
|
|
+ ", mStyle=" + mStyle
|
|
+ ", mIndex=" + mIndex
|
|
+ ", mFontVariationSettings='" + mFontVariationSettings + '\''
|
|
+ ", mFontFamilyName='" + mFontFamilyName + '\''
|
|
+ ", mVarTypeAxes='" + mVarTypeAxes + '\''
|
|
+ '}';
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Alias provides an alternative name for an existing font family.
|
|
*
|
|
* In the system font configuration, a font family can be an alias of another font family with
|
|
* different font weight. For example, "sans-serif-medium" can be a medium weight of
|
|
* "sans-serif" font family. In this example, {@link #getName()} returns "sans-serif-medium" and
|
|
* {@link #getOriginal()} return "sans-serif". The font family that doesn't have name can not be
|
|
* an original of the alias.
|
|
*/
|
|
public static final class Alias implements Parcelable {
|
|
private final @NonNull String mName;
|
|
private final @NonNull String mOriginal;
|
|
private final @IntRange(from = 0, to = 1000) int mWeight;
|
|
|
|
/**
|
|
* Construct an alias instance.
|
|
*
|
|
* @param name alias for the font family.
|
|
* @param original original font family name.
|
|
* @param weight font weight of the original font family.
|
|
* @hide Only system server can create this instance and passed via IPC.
|
|
*/
|
|
public Alias(@NonNull String name, @NonNull String original,
|
|
@IntRange(from = 0, to = 1000) int weight) {
|
|
mName = name;
|
|
mOriginal = original;
|
|
mWeight = weight;
|
|
}
|
|
|
|
/**
|
|
* Alias for the font family
|
|
*/
|
|
public @NonNull String getName() {
|
|
return mName;
|
|
}
|
|
|
|
/**
|
|
* The name of the original font family.
|
|
*/
|
|
public @NonNull String getOriginal() {
|
|
return mOriginal;
|
|
}
|
|
|
|
/**
|
|
* A font weight of the referring font family.
|
|
*
|
|
* @return a font weight of the referring font family.
|
|
*/
|
|
public @IntRange(from = 0, to = 1000) int getWeight() {
|
|
return mWeight;
|
|
}
|
|
|
|
@Override
|
|
public int describeContents() {
|
|
return 0;
|
|
}
|
|
|
|
@Override
|
|
public void writeToParcel(@NonNull Parcel dest, int flags) {
|
|
dest.writeString8(mName);
|
|
dest.writeString8(mOriginal);
|
|
dest.writeInt(mWeight);
|
|
}
|
|
|
|
public static final @NonNull Creator<Alias> CREATOR = new Creator<Alias>() {
|
|
|
|
@Override
|
|
public Alias createFromParcel(Parcel source) {
|
|
String alias = source.readString8();
|
|
String referName = source.readString8();
|
|
int weight = source.readInt();
|
|
return new Alias(alias, referName, weight);
|
|
}
|
|
|
|
@Override
|
|
public Alias[] newArray(int size) {
|
|
return new Alias[size];
|
|
}
|
|
};
|
|
|
|
@Override
|
|
public boolean equals(Object o) {
|
|
if (this == o) return true;
|
|
if (o == null || getClass() != o.getClass()) return false;
|
|
Alias alias = (Alias) o;
|
|
return mWeight == alias.mWeight
|
|
&& Objects.equals(mName, alias.mName)
|
|
&& Objects.equals(mOriginal, alias.mOriginal);
|
|
}
|
|
|
|
@Override
|
|
public int hashCode() {
|
|
return Objects.hash(mName, mOriginal, mWeight);
|
|
}
|
|
|
|
@Override
|
|
public String toString() {
|
|
return "Alias{"
|
|
+ "mName='" + mName + '\''
|
|
+ ", mOriginal='" + mOriginal + '\''
|
|
+ ", mWeight=" + mWeight
|
|
+ '}';
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Represents a font family in the system font configuration.
|
|
*
|
|
* A {@link FontFamily} is a list of {@link Font}s for drawing text in various styles such as
|
|
* weight, slant.
|
|
*
|
|
* For example, a {@link FontFamily} can include the regular and bold styles of a {@link Font}.
|
|
*
|
|
* @see android.graphics.fonts.FontFamily
|
|
*/
|
|
public static final class FontFamily implements Parcelable {
|
|
private final @NonNull List<Font> mFonts;
|
|
private final @NonNull LocaleList mLocaleList;
|
|
private final @Variant int mVariant;
|
|
|
|
/** @hide */
|
|
@Retention(SOURCE)
|
|
@IntDef(prefix = { "VARIANT_" }, value = {
|
|
VARIANT_DEFAULT,
|
|
VARIANT_COMPACT,
|
|
VARIANT_ELEGANT
|
|
})
|
|
public @interface Variant {}
|
|
|
|
/**
|
|
* Value for font variant.
|
|
*
|
|
* Indicates the font has no variant attribute.
|
|
*/
|
|
public static final int VARIANT_DEFAULT = 0;
|
|
|
|
/**
|
|
* Value for font variant.
|
|
*
|
|
* Indicates the font is for compact variant.
|
|
* @see android.graphics.Paint#setElegantTextHeight
|
|
*/
|
|
public static final int VARIANT_COMPACT = 1;
|
|
|
|
/**
|
|
* Value for font variant.
|
|
*
|
|
* Indicates the font is for elegant variant.
|
|
* @see android.graphics.Paint#setElegantTextHeight
|
|
*/
|
|
public static final int VARIANT_ELEGANT = 2;
|
|
|
|
/**
|
|
* Construct a family instance.
|
|
*
|
|
* @hide Only system server can create this instance and passed via IPC.
|
|
*/
|
|
public FontFamily(@NonNull List<Font> fonts, @NonNull LocaleList localeList,
|
|
@Variant int variant) {
|
|
mFonts = fonts;
|
|
mLocaleList = localeList;
|
|
mVariant = variant;
|
|
}
|
|
|
|
/**
|
|
* Returns the list of {@link Font}s in this {@link FontFamily}.
|
|
*
|
|
* @return a list of font files.
|
|
*/
|
|
public @NonNull List<Font> getFontList() {
|
|
return mFonts;
|
|
}
|
|
|
|
/**
|
|
* Returns the name of the {@link FontFamily}.
|
|
*
|
|
* When the name of a {@link FontFamily} is not null, this name is used to create a new
|
|
* {@code Fallback List}, and that {@code Fallback List}. Fallback List is the
|
|
* main building block for a {@link android.graphics.Typeface}.
|
|
*
|
|
* For example, if the {@link FontFamily} has the name "serif", then the system will create
|
|
* a “serif” {@code Fallback List} and it can be used by creating a Typeface via
|
|
* {@code Typeface.create("serif", Typeface.NORMAL);}
|
|
*
|
|
* When the name of a {@link FontFamily} is null, it will be appended to all of the
|
|
* {@code Fallback List}s.
|
|
*
|
|
* @deprecated From API 34, this function always returns null. All font families which have
|
|
* name attribute will be reported as a {@link NamedFamilyList}.
|
|
*/
|
|
@Deprecated
|
|
public @Nullable String getName() {
|
|
return null;
|
|
}
|
|
|
|
/**
|
|
* Returns the locale list if available.
|
|
*
|
|
* The locale list will be used for deciding which font family should be used in fallback
|
|
* list.
|
|
*/
|
|
public @NonNull LocaleList getLocaleList() {
|
|
return mLocaleList;
|
|
}
|
|
|
|
/**
|
|
* Returns the text height variant.
|
|
*/
|
|
public @Variant int getVariant() {
|
|
return mVariant;
|
|
}
|
|
|
|
@Override
|
|
public int describeContents() {
|
|
return 0;
|
|
}
|
|
|
|
@Override
|
|
public void writeToParcel(@NonNull Parcel dest, int flags) {
|
|
dest.writeTypedList(mFonts, flags);
|
|
dest.writeString8(mLocaleList.toLanguageTags());
|
|
dest.writeInt(mVariant);
|
|
}
|
|
|
|
public static final @NonNull Creator<FontFamily> CREATOR = new Creator<FontFamily>() {
|
|
|
|
@Override
|
|
public FontFamily createFromParcel(Parcel source) {
|
|
List<Font> fonts = new ArrayList<>();
|
|
source.readTypedList(fonts, Font.CREATOR);
|
|
String langTags = source.readString8();
|
|
int variant = source.readInt();
|
|
|
|
return new FontFamily(fonts, LocaleList.forLanguageTags(langTags), variant);
|
|
}
|
|
|
|
@Override
|
|
public FontFamily[] newArray(int size) {
|
|
return new FontFamily[size];
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Returns the list of fonts included in this family.
|
|
* @deprecated Use getFontList instead
|
|
* @hide
|
|
*/
|
|
@Deprecated
|
|
@UnsupportedAppUsage(maxTargetSdk = Build.VERSION_CODES.R, trackingBug = 170729553)
|
|
public @Nullable Font[] getFonts() {
|
|
return mFonts.toArray(new Font[0]);
|
|
}
|
|
|
|
/**
|
|
* Returns the comma separated BCP47 compliant languages for this family. May be null.
|
|
* @deprecated Use getLocaleList instead
|
|
* @hide
|
|
*/
|
|
@Deprecated
|
|
public @NonNull String getLanguages() {
|
|
return mLocaleList.toLanguageTags();
|
|
}
|
|
|
|
@Override
|
|
public boolean equals(Object o) {
|
|
if (this == o) return true;
|
|
if (o == null || getClass() != o.getClass()) return false;
|
|
FontFamily that = (FontFamily) o;
|
|
return mVariant == that.mVariant
|
|
&& Objects.equals(mFonts, that.mFonts)
|
|
&& Objects.equals(mLocaleList, that.mLocaleList);
|
|
}
|
|
|
|
@Override
|
|
public int hashCode() {
|
|
return Objects.hash(mFonts, mLocaleList, mVariant);
|
|
}
|
|
|
|
@Override
|
|
public String toString() {
|
|
return "FontFamily{"
|
|
+ "mFonts=" + mFonts
|
|
+ ", mLocaleList=" + mLocaleList
|
|
+ ", mVariant=" + mVariant
|
|
+ '}';
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Represents list of font family in the system font configuration.
|
|
*
|
|
* In the fonts_customization.xml, it can define the list of FontFamily as a named family. The
|
|
* list of FontFamily is treated as a fallback list when drawing.
|
|
*
|
|
* @see android.graphics.fonts.FontFamily
|
|
*/
|
|
public static final class NamedFamilyList implements Parcelable {
|
|
private final List<FontFamily> mFamilies;
|
|
private final String mName;
|
|
|
|
/** @hide */
|
|
public NamedFamilyList(@NonNull List<FontFamily> families, @NonNull String name) {
|
|
mFamilies = families;
|
|
mName = name;
|
|
}
|
|
|
|
/** @hide */
|
|
public NamedFamilyList(@NonNull FontFamily family) {
|
|
mFamilies = new ArrayList<>();
|
|
mFamilies.add(family);
|
|
mName = family.getName();
|
|
}
|
|
|
|
/**
|
|
* A list of font families.
|
|
*
|
|
* @return a list of font families.
|
|
*/
|
|
public @NonNull List<FontFamily> getFamilies() {
|
|
return mFamilies;
|
|
}
|
|
|
|
/**
|
|
* Returns the name of the {@link FontFamily}.
|
|
*
|
|
* This name is used to create a new {@code Fallback List}.
|
|
*
|
|
* For example, if the {@link FontFamily} has the name "serif", then the system will create
|
|
* a “serif” {@code Fallback List} and it can be used by creating a Typeface via
|
|
* {@code Typeface.create("serif", Typeface.NORMAL);}
|
|
*/
|
|
public @NonNull String getName() {
|
|
return mName;
|
|
}
|
|
|
|
@Override
|
|
public int describeContents() {
|
|
return 0;
|
|
}
|
|
|
|
@Override
|
|
public void writeToParcel(@androidx.annotation.NonNull Parcel dest, int flags) {
|
|
dest.writeTypedList(mFamilies, flags);
|
|
dest.writeString8(mName);
|
|
}
|
|
|
|
public static final @NonNull Creator<NamedFamilyList> CREATOR = new Creator<>() {
|
|
|
|
@Override
|
|
public NamedFamilyList createFromParcel(Parcel source) {
|
|
final List<FontFamily> families = new ArrayList<>();
|
|
source.readTypedList(families, FontFamily.CREATOR);
|
|
String name = source.readString8();
|
|
return new NamedFamilyList(families, name);
|
|
}
|
|
|
|
@Override
|
|
public NamedFamilyList[] newArray(int size) {
|
|
return new NamedFamilyList[size];
|
|
}
|
|
};
|
|
|
|
@Override
|
|
public boolean equals(Object o) {
|
|
if (this == o) return true;
|
|
if (o == null || getClass() != o.getClass()) return false;
|
|
NamedFamilyList that = (NamedFamilyList) o;
|
|
return Objects.equals(mFamilies, that.mFamilies) && Objects.equals(mName,
|
|
that.mName);
|
|
}
|
|
|
|
@Override
|
|
public int hashCode() {
|
|
return Objects.hash(mFamilies, mName);
|
|
}
|
|
|
|
@Override
|
|
public String toString() {
|
|
return "NamedFamilyList{"
|
|
+ "mFamilies=" + mFamilies
|
|
+ ", mName='" + mName + '\''
|
|
+ '}';
|
|
}
|
|
}
|
|
|
|
/** @hide */
|
|
public static class Customization {
|
|
private Customization() {} // Singleton
|
|
|
|
/**
|
|
* A class that represents customization of locale fallback
|
|
*
|
|
* This class represents a vendor customization of new-locale-family.
|
|
*
|
|
* <pre>
|
|
* <family customizationType="new-locale-family" operation="prepend" lang="ja-JP">
|
|
* <font weight="400" style="normal">MyAlternativeFont.ttf
|
|
* <axis tag="wght" stylevalue="400"/>
|
|
* </font>
|
|
* </family>
|
|
* </pre>
|
|
*
|
|
* The operation can be one of prepend, replace or append. The operation prepend means that
|
|
* the new font family is inserted just before the original font family. The original font
|
|
* family is still in the fallback. The operation replace means that the original font
|
|
* family is replaced with new font family. The original font family is removed from the
|
|
* fallback. The operation append means that the new font family is inserted just after the
|
|
* original font family. The original font family is still in the fallback.
|
|
*
|
|
* The lang attribute is a BCP47 compliant language tag. The font fallback mainly uses ISO
|
|
* 15924 script code for matching. If the script code is missing, most likely script code
|
|
* will be used.
|
|
*/
|
|
public static class LocaleFallback {
|
|
private final Locale mLocale;
|
|
private final int mOperation;
|
|
private final FontFamily mFamily;
|
|
private final String mScript;
|
|
|
|
public static final int OPERATION_PREPEND = 0;
|
|
public static final int OPERATION_APPEND = 1;
|
|
public static final int OPERATION_REPLACE = 2;
|
|
|
|
/** @hide */
|
|
@Retention(SOURCE)
|
|
@IntDef(prefix = { "OPERATION_" }, value = {
|
|
OPERATION_PREPEND,
|
|
OPERATION_APPEND,
|
|
OPERATION_REPLACE
|
|
})
|
|
public @interface Operation {}
|
|
|
|
|
|
public LocaleFallback(@NonNull Locale locale, @Operation int operation,
|
|
@NonNull FontFamily family) {
|
|
mLocale = locale;
|
|
mOperation = operation;
|
|
mFamily = family;
|
|
mScript = resolveScript(locale);
|
|
}
|
|
|
|
/**
|
|
* A customization target locale.
|
|
* @return a locale
|
|
*/
|
|
public @NonNull Locale getLocale() {
|
|
return mLocale;
|
|
}
|
|
|
|
/**
|
|
* An operation to be applied to the original font family.
|
|
*
|
|
* The operation can be one of {@link #OPERATION_PREPEND}, {@link #OPERATION_REPLACE} or
|
|
* {@link #OPERATION_APPEND}.
|
|
*
|
|
* The operation prepend ({@link #OPERATION_PREPEND}) means that the new font family is
|
|
* inserted just before the original font family. The original font family is still in
|
|
* the fallback.
|
|
*
|
|
* The operation replace ({@link #OPERATION_REPLACE}) means that the original font
|
|
* family is replaced with new font family. The original font family is removed from the
|
|
* fallback.
|
|
*
|
|
* The operation append ({@link #OPERATION_APPEND}) means that the new font family is
|
|
* inserted just after the original font family. The original font family is still in
|
|
* the fallback.
|
|
*
|
|
* @return an operation.
|
|
*/
|
|
public @Operation int getOperation() {
|
|
return mOperation;
|
|
}
|
|
|
|
/**
|
|
* Returns a family to be inserted or replaced to the fallback.
|
|
*
|
|
* @return a family
|
|
*/
|
|
public @NonNull FontFamily getFamily() {
|
|
return mFamily;
|
|
}
|
|
|
|
/**
|
|
* Returns a script of the locale. If the script is missing in the given locale, the
|
|
* most likely locale is returned.
|
|
*/
|
|
public @NonNull String getScript() {
|
|
return mScript;
|
|
}
|
|
|
|
@Override
|
|
public String toString() {
|
|
return "LocaleFallback{"
|
|
+ "mLocale=" + mLocale
|
|
+ ", mOperation=" + mOperation
|
|
+ ", mFamily=" + mFamily
|
|
+ '}';
|
|
}
|
|
}
|
|
}
|
|
|
|
/** @hide */
|
|
public static String resolveScript(Locale locale) {
|
|
String script = locale.getScript();
|
|
if (script != null && !script.isEmpty()) {
|
|
return script;
|
|
}
|
|
return ULocale.addLikelySubtags(ULocale.forLocale(locale)).getScript();
|
|
}
|
|
}
|