| /* |
| * Copyright (C) 2014 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.style; |
| |
| import java.text.NumberFormat; |
| import java.util.Locale; |
| |
| import android.os.Parcel; |
| import android.os.PersistableBundle; |
| import android.text.ParcelableSpan; |
| import android.text.TextUtils; |
| |
| /** |
| * A span that supplies additional meta-data for the associated text intended |
| * for text-to-speech engines. If the text is being processed by a |
| * text-to-speech engine, the engine may use the data in this span in addition |
| * to or instead of its associated text. |
| * |
| * Each instance of a TtsSpan has a type, for example {@link #TYPE_DATE} |
| * or {@link #TYPE_MEASURE}. And a list of arguments, provided as |
| * key-value pairs in a bundle. |
| * |
| * The inner classes are there for convenience and provide builders for each |
| * TtsSpan type. |
| */ |
| public class TtsSpan implements ParcelableSpan { |
| private final String mType; |
| private final PersistableBundle mArgs; |
| |
| /** |
| * This span type can be used to add morphosyntactic features to the text it |
| * spans over, or synthesize a something else than the spanned text. Use |
| * the argument {@link #ARG_TEXT} to set a different text. |
| * Accepts the arguments {@link #ARG_GENDER}, |
| * {@link #ARG_ANIMACY}, {@link #ARG_MULTIPLICITY} and |
| * {@link #ARG_CASE}. |
| */ |
| public static final String TYPE_TEXT = "android.type.text"; |
| |
| /** |
| * The text associated with this span is a cardinal. Must include the |
| * number to be synthesized with {@link #ARG_NUMBER}. |
| * Also accepts the arguments {@link #ARG_GENDER}, |
| * {@link #ARG_ANIMACY}, {@link #ARG_MULTIPLICITY} and |
| * {@link #ARG_CASE}. |
| */ |
| public static final String TYPE_CARDINAL = "android.type.cardinal"; |
| |
| /** |
| * The text associated with this span is an ordinal. Must include the |
| * number to be synthesized with {@link #ARG_NUMBER}. |
| * Also accepts the arguments {@link #ARG_GENDER}, |
| * {@link #ARG_ANIMACY}, {@link #ARG_MULTIPLICITY} and |
| * {@link #ARG_CASE}. |
| */ |
| public static final String TYPE_ORDINAL = "android.type.ordinal"; |
| |
| /** |
| * The text associated with this span is a decimal number. Must include the |
| * number to be synthesized with {@link #ARG_INTEGER_PART} and |
| * {@link #ARG_FRACTIONAL_PART}. |
| * Also accepts the arguments {@link #ARG_GENDER}, |
| * {@link #ARG_ANIMACY}, {@link #ARG_MULTIPLICITY} and |
| * {@link #ARG_CASE}. |
| */ |
| public static final String TYPE_DECIMAL = "android.type.decimal"; |
| |
| /** |
| * The text associated with this span is a fractional number. Must include |
| * the number to be synthesized with {@link #ARG_NUMERATOR} and |
| * {@link #ARG_DENOMINATOR}. {@link #ARG_INTEGER_PART} is optional |
| * Also accepts the arguments {@link #ARG_GENDER}, |
| * {@link #ARG_ANIMACY}, {@link #ARG_MULTIPLICITY} and |
| * {@link #ARG_CASE}. |
| */ |
| public static final String TYPE_FRACTION = "android.type.fraction"; |
| |
| /** |
| * The text associated with this span is a measure, consisting of a number |
| * and a unit. The number can be a cardinal, decimal or a fraction. Set the |
| * number with the same arguments as {@link #TYPE_CARDINAL}, |
| * {@link #TYPE_DECIMAL} or {@link #TYPE_FRACTION}. The unit can be |
| * specified with {@link #ARG_UNIT}. |
| * Also accepts the arguments {@link #ARG_GENDER}, |
| * {@link #ARG_ANIMACY}, {@link #ARG_MULTIPLICITY} and |
| * {@link #ARG_CASE}. |
| */ |
| public static final String TYPE_MEASURE = "android.type.measure"; |
| |
| /** |
| * The text associated with this span is a time, consisting of a number of |
| * hours and minutes, specified with {@link #ARG_HOURS} and |
| * {@link #ARG_MINUTES}. |
| * Also accepts the arguments {@link #ARG_GENDER}, |
| * {@link #ARG_ANIMACY}, {@link #ARG_MULTIPLICITY} and |
| * {@link #ARG_CASE}. |
| */ |
| public static final String TYPE_TIME = "android.type.time"; |
| |
| /** |
| * The text associated with this span is a date. At least one of the |
| * arguments {@link #ARG_MONTH} and {@link #ARG_YEAR} has to be provided. |
| * The argument {@link #ARG_DAY} is optional if {@link #ARG_MONTH} is set. |
| * The argument {@link #ARG_WEEKDAY} is optional if {@link #ARG_DAY} is set. |
| * Also accepts the arguments {@link #ARG_GENDER}, {@link #ARG_ANIMACY}, |
| * {@link #ARG_MULTIPLICITY} and {@link #ARG_CASE}. |
| */ |
| public static final String TYPE_DATE = "android.type.date"; |
| |
| /** |
| * The text associated with this span is a telephone number. The argument |
| * {@link #ARG_NUMBER_PARTS} is required. {@link #ARG_COUNTRY_CODE} and |
| * {@link #ARG_EXTENSION} are optional. |
| * Also accepts the arguments {@link #ARG_GENDER}, {@link #ARG_ANIMACY}, |
| * {@link #ARG_MULTIPLICITY} and {@link #ARG_CASE}. |
| */ |
| public static final String TYPE_TELEPHONE = "android.type.telephone"; |
| |
| /** |
| * The text associated with this span is a URI (can be used for URLs and |
| * email addresses). The full schema for URLs, which email addresses can |
| * effectively be seen as a subset of, is: |
| * protocol://username:password@domain:port/path?query_string#fragment_id |
| * Hence populating just username and domain will read as an email address. |
| * All arguments are optional, but at least one has to be provided: |
| * {@link #ARG_PROTOCOL}, {@link #ARG_USERNAME}, {@link #ARG_PASSWORD}, |
| * {@link #ARG_DOMAIN}, {@link #ARG_PORT}, {@link #ARG_PATH}, |
| * {@link #ARG_QUERY_STRING} and {@link #ARG_FRAGMENT_ID}. |
| * Also accepts the arguments {@link #ARG_GENDER}, {@link #ARG_ANIMACY}, |
| * {@link #ARG_MULTIPLICITY} and {@link #ARG_CASE}. |
| */ |
| public static final String TYPE_ELECTRONIC = "android.type.electronic"; |
| |
| /** |
| * The text associated with this span is an amount of money. Set the amount |
| * with the same arguments as {@link #TYPE_DECIMAL}. |
| * {@link #ARG_CURRENCY} is used to set the currency. {@link #ARG_QUANTITY} |
| * is optional. |
| * Also accepts the arguments {@link #ARG_GENDER}, {@link #ARG_ANIMACY}, |
| * {@link #ARG_MULTIPLICITY} and {@link #ARG_CASE}. |
| */ |
| public static final String TYPE_MONEY = "android.type.money"; |
| |
| /** |
| * The text associated with this span is a series of digits that have to be |
| * read sequentially. The digits can be set with {@link #ARG_DIGITS}. |
| * Also accepts the arguments {@link #ARG_GENDER}, {@link #ARG_ANIMACY}, |
| * {@link #ARG_MULTIPLICITY} and {@link #ARG_CASE}. |
| */ |
| public static final String TYPE_DIGITS = "android.type.digits"; |
| |
| /** |
| * The text associated with this span is a series of characters that have to |
| * be read verbatim. The engine will attempt to read out any character like |
| * punctuation but excluding whitespace. {@link #ARG_VERBATIM} is required. |
| * Also accepts the arguments {@link #ARG_GENDER}, |
| * {@link #ARG_ANIMACY}, {@link #ARG_MULTIPLICITY} and {@link #ARG_CASE}. |
| */ |
| public static final String TYPE_VERBATIM = "android.type.verbatim"; |
| |
| /** |
| * String argument supplying gender information. Can be any of |
| * {@link #GENDER_NEUTRAL}, {@link #GENDER_MALE} and |
| * {@link #GENDER_FEMALE}. |
| */ |
| public static final String ARG_GENDER = "android.arg.gender"; |
| |
| public static final String GENDER_NEUTRAL = "android.neutral"; |
| public static final String GENDER_MALE = "android.male"; |
| public static final String GENDER_FEMALE = "android.female"; |
| |
| /** |
| * String argument supplying animacy information. Can be |
| * {@link #ANIMACY_ANIMATE} or |
| * {@link #ANIMACY_INANIMATE} |
| */ |
| public static final String ARG_ANIMACY = "android.arg.animacy"; |
| |
| public static final String ANIMACY_ANIMATE = "android.animate"; |
| public static final String ANIMACY_INANIMATE = "android.inanimate"; |
| |
| /** |
| * String argument supplying multiplicity information. Can be any of |
| * {@link #MULTIPLICITY_SINGLE}, {@link #MULTIPLICITY_DUAL} and |
| * {@link #MULTIPLICITY_PLURAL} |
| */ |
| public static final String ARG_MULTIPLICITY = "android.arg.multiplicity"; |
| |
| public static final String MULTIPLICITY_SINGLE = "android.single"; |
| public static final String MULTIPLICITY_DUAL = "android.dual"; |
| public static final String MULTIPLICITY_PLURAL = "android.plural"; |
| |
| /** |
| * String argument supplying case information. Can be any of |
| * {@link #CASE_NOMINATIVE}, {@link #CASE_ACCUSATIVE}, {@link #CASE_DATIVE}, |
| * {@link #CASE_ABLATIVE}, {@link #CASE_GENITIVE}, {@link #CASE_VOCATIVE}, |
| * {@link #CASE_LOCATIVE} and {@link #CASE_INSTRUMENTAL} |
| */ |
| public static final String ARG_CASE = "android.arg.case"; |
| |
| public static final String CASE_NOMINATIVE = "android.nominative"; |
| public static final String CASE_ACCUSATIVE = "android.accusative"; |
| public static final String CASE_DATIVE = "android.dative"; |
| public static final String CASE_ABLATIVE = "android.ablative"; |
| public static final String CASE_GENITIVE = "android.genitive"; |
| public static final String CASE_VOCATIVE = "android.vocative"; |
| public static final String CASE_LOCATIVE = "android.locative"; |
| public static final String CASE_INSTRUMENTAL = "android.instrumental"; |
| |
| /** |
| * String supplying the text to be synthesized. The synthesizer is free |
| * to decide how to interpret the text. |
| * Can be used with {@link #TYPE_TEXT}. |
| */ |
| public static final String ARG_TEXT = "android.arg.text"; |
| |
| /** |
| * Argument used to specify a whole number. The value can be a string of |
| * digits of any size optionally prefixed with a - or +. |
| * Can be used with {@link #TYPE_CARDINAL} and {@link #TYPE_ORDINAL}. |
| */ |
| public static final String ARG_NUMBER = "android.arg.number"; |
| |
| /** |
| * Argument used to specify the integer part of a decimal or fraction. The |
| * value can be a string of digits of any size optionally prefixed with |
| * a - or +. |
| * Can be used with {@link #TYPE_DECIMAL} and {@link #TYPE_FRACTION}. |
| */ |
| public static final String ARG_INTEGER_PART = "android.arg.integer_part"; |
| |
| /** |
| * Argument used to specify the fractional part of a decimal. The value can |
| * be a string of digits of any size. |
| * Can be used with {@link #TYPE_DECIMAL}. |
| */ |
| public static final String ARG_FRACTIONAL_PART = |
| "android.arg.fractional_part"; |
| |
| /** |
| * Argument used to choose the suffix (thousand, million, etc) that is used |
| * to pronounce large amounts of money. For example it can be used to |
| * disambiguate between "two thousand five hundred dollars" and |
| * "two point five thousand dollars". |
| * If implemented, engines should support at least "1000", "1000000", |
| * "1000000000" and "1000000000000". |
| * Example: if the {@link #ARG_INTEGER_PART} argument is "10", the |
| * {@link #ARG_FRACTIONAL_PART} argument is "4", the {@link #ARG_QUANTITY} |
| * argument is "1000" and the {@link #ARG_CURRENCY} argument is "usd", the |
| * TTS engine may pronounce the span as "ten point four thousand dollars". |
| * With the same example but with the quantity set as "1000000" the TTS |
| * engine may pronounce the span as "ten point four million dollars". |
| * Can be used with {@link #TYPE_MONEY}. |
| */ |
| public static final String ARG_QUANTITY = |
| "android.arg.quantity"; |
| |
| /** |
| * Argument used to specify the numerator of a fraction. The value can be a |
| * string of digits of any size optionally prefixed with a - or +. |
| * Can be used with {@link #TYPE_FRACTION}. |
| */ |
| public static final String ARG_NUMERATOR = "android.arg.numerator"; |
| |
| /** |
| * Argument used to specify the denominator of a fraction. The value can be |
| * a string of digits of any size optionally prefixed with a + or -. |
| * Can be used with {@link #TYPE_FRACTION}. |
| */ |
| public static final String ARG_DENOMINATOR = "android.arg.denominator"; |
| |
| /** |
| * Argument used to specify the unit of a measure. The unit should always be |
| * specified in English singular form. Prefixes may be used. Engines will do |
| * their best to pronounce them correctly in the language used. Engines are |
| * expected to at least support the most common ones like "meter", "second", |
| * "degree celsius" and "degree fahrenheit" with some common prefixes like |
| * "milli" and "kilo". |
| * Can be used with {@link #TYPE_MEASURE}. |
| */ |
| public static final String ARG_UNIT = "android.arg.unit"; |
| |
| /** |
| * Argument used to specify the hours of a time. The hours should be |
| * provided as an integer in the range from 0 up to and including 24. |
| * Can be used with {@link #TYPE_TIME}. |
| */ |
| public static final String ARG_HOURS = "android.arg.hours"; |
| |
| /** |
| * Argument used to specify the minutes of a time. The hours should be |
| * provided as an integer in the range from 0 up to and including 59. |
| * Can be used with {@link #TYPE_TIME}. |
| */ |
| public static final String ARG_MINUTES = "android.arg.minutes"; |
| |
| /** |
| * Argument used to specify the weekday of a date. The value should be |
| * provided as an integer and can be any of {@link #WEEKDAY_SUNDAY}, |
| * {@link #WEEKDAY_MONDAY}, {@link #WEEKDAY_TUESDAY}, |
| * {@link #WEEKDAY_WEDNESDAY}, {@link #WEEKDAY_THURSDAY}, |
| * {@link #WEEKDAY_FRIDAY} and {@link #WEEKDAY_SATURDAY}. |
| * Can be used with {@link #TYPE_DATE}. |
| */ |
| public static final String ARG_WEEKDAY = "android.arg.weekday"; |
| |
| public static final int WEEKDAY_SUNDAY = 1; |
| public static final int WEEKDAY_MONDAY = 2; |
| public static final int WEEKDAY_TUESDAY = 3; |
| public static final int WEEKDAY_WEDNESDAY = 4; |
| public static final int WEEKDAY_THURSDAY = 5; |
| public static final int WEEKDAY_FRIDAY = 6; |
| public static final int WEEKDAY_SATURDAY = 7; |
| |
| /** |
| * Argument used to specify the day of the month of a date. The value should |
| * be provided as an integer in the range from 1 up to and including 31. |
| * Can be used with {@link #TYPE_DATE}. |
| */ |
| public static final String ARG_DAY = "android.arg.day"; |
| |
| /** |
| * Argument used to specify the month of a date. The value should be |
| * provided as an integer and can be any of {@link #MONTH_JANUARY}, |
| * {@link #MONTH_FEBRUARY}, {@link #MONTH_MARCH}, {@link #MONTH_APRIL}, |
| * {@link #MONTH_MAY}, {@link #MONTH_JUNE}, {@link #MONTH_JULY}, |
| * {@link #MONTH_AUGUST}, {@link #MONTH_SEPTEMBER}, {@link #MONTH_OCTOBER}, |
| * {@link #MONTH_NOVEMBER} and {@link #MONTH_DECEMBER}. |
| * Can be used with {@link #TYPE_DATE}. |
| */ |
| public static final String ARG_MONTH = "android.arg.month"; |
| |
| public static final int MONTH_JANUARY = 0; |
| public static final int MONTH_FEBRUARY = 1; |
| public static final int MONTH_MARCH = 2; |
| public static final int MONTH_APRIL = 3; |
| public static final int MONTH_MAY = 4; |
| public static final int MONTH_JUNE = 5; |
| public static final int MONTH_JULY = 6; |
| public static final int MONTH_AUGUST = 7; |
| public static final int MONTH_SEPTEMBER = 8; |
| public static final int MONTH_OCTOBER = 9; |
| public static final int MONTH_NOVEMBER = 10; |
| public static final int MONTH_DECEMBER = 11; |
| |
| /** |
| * Argument used to specify the year of a date. The value should be provided |
| * as a positive integer. |
| * Can be used with {@link #TYPE_DATE}. |
| */ |
| public static final String ARG_YEAR = "android.arg.year"; |
| |
| /** |
| * Argument used to specify the country code of a telephone number. Can be |
| * a string of digits optionally prefixed with a "+". |
| * Can be used with {@link #TYPE_TELEPHONE}. |
| */ |
| public static final String ARG_COUNTRY_CODE = "android.arg.country_code"; |
| |
| /** |
| * Argument used to specify the main number part of a telephone number. Can |
| * be a string of digits where the different parts of the telephone number |
| * can be separated with a space, '-', '/' or '.'. |
| * Can be used with {@link #TYPE_TELEPHONE}. |
| */ |
| public static final String ARG_NUMBER_PARTS = "android.arg.number_parts"; |
| |
| /** |
| * Argument used to specify the extension part of a telephone number. Can be |
| * a string of digits. |
| * Can be used with {@link #TYPE_TELEPHONE}. |
| */ |
| public static final String ARG_EXTENSION = "android.arg.extension"; |
| |
| /** |
| * Argument used to specify the protocol of a URI. Examples are "http" and |
| * "ftp". |
| * Can be used with {@link #TYPE_ELECTRONIC}. |
| */ |
| public static final String ARG_PROTOCOL = "android.arg.protocol"; |
| |
| /** |
| * Argument used to specify the username part of a URI. Should be set as a |
| * string. |
| * Can be used with {@link #TYPE_ELECTRONIC}. |
| */ |
| public static final String ARG_USERNAME = "android.arg.username"; |
| |
| /** |
| * Argument used to specify the password part of a URI. Should be set as a |
| * string. |
| * Can be used with {@link #TYPE_ELECTRONIC}. |
| */ |
| public static final String ARG_PASSWORD = "android.arg.password"; |
| |
| /** |
| * Argument used to specify the domain part of a URI. For example |
| * "source.android.com". |
| * Can be used with {@link #TYPE_ELECTRONIC}. |
| */ |
| public static final String ARG_DOMAIN = "android.arg.domain"; |
| |
| /** |
| * Argument used to specify the port number of a URI. Should be specified as |
| * an integer. |
| * Can be used with {@link #TYPE_ELECTRONIC}. |
| */ |
| public static final String ARG_PORT = "android.arg.port"; |
| |
| /** |
| * Argument used to specify the path part of a URI. For example |
| * "source/index.html". |
| * Can be used with {@link #TYPE_ELECTRONIC}. |
| */ |
| public static final String ARG_PATH = "android.arg.path"; |
| |
| /** |
| * Argument used to specify the query string of a URI. For example |
| * "arg=value&argtwo=value". |
| * Can be used with {@link #TYPE_ELECTRONIC}. |
| */ |
| public static final String ARG_QUERY_STRING = "android.arg.query_string"; |
| |
| /** |
| * Argument used to specify the fragment id of a URI. Should be specified as |
| * a string. |
| * Can be used with {@link #TYPE_ELECTRONIC}. |
| */ |
| public static final String ARG_FRAGMENT_ID = "android.arg.fragment_id"; |
| |
| /** |
| * Argument used to specify the currency. Should be a ISO4217 currency code, |
| * e.g. "USD". |
| * Can be used with {@link #TYPE_MONEY}. |
| */ |
| public static final String ARG_CURRENCY = "android.arg.money"; |
| |
| /** |
| * Argument used to specify a string of digits. |
| * Can be used with {@link #TYPE_DIGITS}. |
| */ |
| public static final String ARG_DIGITS = "android.arg.digits"; |
| |
| /** |
| * Argument used to specify a string where the characters are read verbatim, |
| * except whitespace. |
| * Can be used with {@link #TYPE_VERBATIM}. |
| */ |
| public static final String ARG_VERBATIM = "android.arg.verbatim"; |
| |
| public TtsSpan(String type, PersistableBundle args) { |
| mType = type; |
| mArgs = args; |
| } |
| |
| public TtsSpan(Parcel src) { |
| mType = src.readString(); |
| mArgs = src.readPersistableBundle(); |
| } |
| |
| /** |
| * Returns the type. |
| * @return The type of this instance. |
| */ |
| public String getType() { |
| return mType; |
| } |
| |
| /** |
| * Returns a bundle of the arguments set. |
| * @return The bundle of the arguments set. |
| */ |
| public PersistableBundle getArgs() { |
| return mArgs; |
| } |
| |
| @Override |
| public int describeContents() { |
| return 0; |
| } |
| |
| @Override |
| public void writeToParcel(Parcel dest, int flags) { |
| writeToParcelInternal(dest, flags); |
| } |
| |
| /** @hide */ |
| public void writeToParcelInternal(Parcel dest, int flags) { |
| dest.writeString(mType); |
| dest.writePersistableBundle(mArgs); |
| } |
| |
| @Override |
| public int getSpanTypeId() { |
| return getSpanTypeIdInternal(); |
| } |
| |
| /** @hide */ |
| public int getSpanTypeIdInternal() { |
| return TextUtils.TTS_SPAN; |
| } |
| |
| /** |
| * A simple builder for TtsSpans. |
| * This builder can be used directly, but the more specific subclasses of |
| * this builder like {@link TtsSpan.TextBuilder} and |
| * {@link TtsSpan.CardinalBuilder} are likely more useful. |
| * |
| * This class uses generics so methods from this class can return instances |
| * of its child classes, resulting in a fluent API (CRTP pattern). |
| */ |
| public static class Builder<C extends Builder<?>> { |
| // Holds the type of this class. |
| private final String mType; |
| |
| // Holds the arguments of this class. It only stores objects of type |
| // String, Integer and Long. |
| private PersistableBundle mArgs = new PersistableBundle(); |
| |
| public Builder(String type) { |
| mType = type; |
| } |
| |
| /** |
| * Returns a TtsSpan built from the parameters set by the setter |
| * methods. |
| * @return A TtsSpan built with parameters of this builder. |
| */ |
| public TtsSpan build() { |
| return new TtsSpan(mType, mArgs); |
| } |
| |
| /** |
| * Sets an argument to a string value. |
| * @param arg The argument name. |
| * @param value The value the argument should be set to. |
| * @return This instance. |
| */ |
| @SuppressWarnings("unchecked") |
| public C setStringArgument(String arg, String value) { |
| mArgs.putString(arg, value); |
| return (C) this; |
| } |
| |
| /** |
| * Sets an argument to an int value. |
| * @param arg The argument name. |
| * @param value The value the argument should be set to. |
| */ |
| @SuppressWarnings("unchecked") |
| public C setIntArgument(String arg, int value) { |
| mArgs.putInt(arg, value); |
| return (C) this; |
| } |
| |
| /** |
| * Sets an argument to a long value. |
| * @param arg The argument name. |
| * @param value The value the argument should be set to. |
| */ |
| @SuppressWarnings("unchecked") |
| public C setLongArgument(String arg, long value) { |
| mArgs.putLong(arg, value); |
| return (C) this; |
| } |
| } |
| |
| /** |
| * A builder for TtsSpans, has setters for morphosyntactic features. |
| * This builder can be used directly, but the more specific subclasses of |
| * this builder like {@link TtsSpan.TextBuilder} and |
| * {@link TtsSpan.CardinalBuilder} are likely more useful. |
| */ |
| public static class SemioticClassBuilder<C extends SemioticClassBuilder<?>> |
| extends Builder<C> { |
| |
| public SemioticClassBuilder(String type) { |
| super(type); |
| } |
| |
| /** |
| * Sets the gender information for this instance. |
| * @param gender Can any of {@link #GENDER_NEUTRAL}, |
| * {@link #GENDER_MALE} and {@link #GENDER_FEMALE}. |
| * @return This instance. |
| */ |
| public C setGender(String gender) { |
| return setStringArgument(TtsSpan.ARG_GENDER, gender); |
| } |
| |
| /** |
| * Sets the animacy information for this instance. |
| * @param animacy Can be any of {@link #ANIMACY_ANIMATE} and |
| * {@link #ANIMACY_INANIMATE}. |
| * @return This instance. |
| */ |
| public C setAnimacy(String animacy) { |
| return setStringArgument(TtsSpan.ARG_ANIMACY, animacy); |
| } |
| |
| /** |
| * Sets the multiplicity information for this instance. |
| * @param multiplicity Can be any of |
| * {@link #MULTIPLICITY_SINGLE}, {@link #MULTIPLICITY_DUAL} and |
| * {@link #MULTIPLICITY_PLURAL}. |
| * @return This instance. |
| */ |
| public C setMultiplicity(String multiplicity) { |
| return setStringArgument(TtsSpan.ARG_MULTIPLICITY, multiplicity); |
| } |
| |
| /** |
| * Sets the grammatical case information for this instance. |
| * @param grammaticalCase Can be any of {@link #CASE_NOMINATIVE}, |
| * {@link #CASE_ACCUSATIVE}, {@link #CASE_DATIVE}, |
| * {@link #CASE_ABLATIVE}, {@link #CASE_GENITIVE}, |
| * {@link #CASE_VOCATIVE}, {@link #CASE_LOCATIVE} and |
| * {@link #CASE_INSTRUMENTAL}. |
| * @return This instance. |
| */ |
| public C setCase(String grammaticalCase) { |
| return setStringArgument(TtsSpan.ARG_CASE, grammaticalCase); |
| } |
| } |
| |
| /** |
| * A builder for TtsSpans of type {@link #TYPE_TEXT}. |
| */ |
| public static class TextBuilder extends SemioticClassBuilder<TextBuilder> { |
| |
| /** |
| * Creates a builder for a TtsSpan of type {@link #TYPE_TEXT}. |
| */ |
| public TextBuilder() { |
| super(TtsSpan.TYPE_TEXT); |
| } |
| |
| /** |
| * Creates a TtsSpan of type {@link #TYPE_TEXT} and sets the |
| * {@link #ARG_TEXT} argument. |
| * @param text The text to be synthesized. |
| * @see #setText(String) |
| */ |
| public TextBuilder(String text) { |
| this(); |
| setText(text); |
| } |
| |
| /** |
| * Sets the {@link #ARG_TEXT} argument, the text to be synthesized. |
| * @param text The string that will be synthesized. |
| * @return This instance. |
| */ |
| public TextBuilder setText(String text) { |
| return setStringArgument(TtsSpan.ARG_TEXT, text); |
| } |
| } |
| |
| /** |
| * A builder for TtsSpans of type {@link #TYPE_CARDINAL}. |
| */ |
| public static class CardinalBuilder |
| extends SemioticClassBuilder<CardinalBuilder> { |
| |
| /** |
| * Creates a builder for a TtsSpan of type {@link #TYPE_CARDINAL}. |
| */ |
| public CardinalBuilder() { |
| super(TtsSpan.TYPE_CARDINAL); |
| } |
| |
| /** |
| * Creates a TtsSpan of type {@link #TYPE_CARDINAL} and sets the |
| * {@link #ARG_NUMBER} argument. |
| * @param number The number to synthesize. |
| * @see #setNumber(long) |
| */ |
| public CardinalBuilder(long number) { |
| this(); |
| setNumber(number); |
| } |
| |
| /** |
| * Creates a TtsSpan of type {@link #TYPE_CARDINAL} and sets the |
| * {@link #ARG_NUMBER} argument. |
| * @param number The number to synthesize. |
| * @see #setNumber(String) |
| */ |
| public CardinalBuilder(String number) { |
| this(); |
| setNumber(number); |
| } |
| |
| /** |
| * Convenience method that converts the number to a String and set it to |
| * the value for {@link #ARG_NUMBER}. |
| * @param number The number that will be synthesized. |
| * @return This instance. |
| */ |
| public CardinalBuilder setNumber(long number) { |
| return setNumber(String.valueOf(number)); |
| } |
| |
| /** |
| * Sets the {@link #ARG_NUMBER} argument. |
| * @param number A non-empty string of digits with an optional |
| * leading + or -. |
| * @return This instance. |
| */ |
| public CardinalBuilder setNumber(String number) { |
| return setStringArgument(TtsSpan.ARG_NUMBER, number); |
| } |
| } |
| |
| /** |
| * A builder for TtsSpans of type {@link #TYPE_ORDINAL}. |
| */ |
| public static class OrdinalBuilder |
| extends SemioticClassBuilder<OrdinalBuilder> { |
| |
| /** |
| * Creates a builder for a TtsSpan of type {@link #TYPE_ORDINAL}. |
| */ |
| public OrdinalBuilder() { |
| super(TtsSpan.TYPE_ORDINAL); |
| } |
| |
| /** |
| * Creates a TtsSpan of type {@link #TYPE_ORDINAL} and sets the |
| * {@link #ARG_NUMBER} argument. |
| * @param number The ordinal number to synthesize. |
| * @see #setNumber(long) |
| */ |
| public OrdinalBuilder(long number) { |
| this(); |
| setNumber(number); |
| } |
| |
| /** |
| * Creates a TtsSpan of type {@link #TYPE_ORDINAL} and sets the |
| * {@link #ARG_NUMBER} argument. |
| * @param number The number to synthesize. |
| * @see #setNumber(String) |
| */ |
| public OrdinalBuilder(String number) { |
| this(); |
| setNumber(number); |
| } |
| |
| /** |
| * Convenience method that converts the number to a String and sets it |
| * to the value for {@link #ARG_NUMBER}. |
| * @param number The ordinal number that will be synthesized. |
| * @return This instance. |
| */ |
| public OrdinalBuilder setNumber(long number) { |
| return setNumber(String.valueOf(number)); |
| } |
| |
| /** |
| * Sets the {@link #ARG_NUMBER} argument. |
| * @param number A non-empty string of digits with an optional |
| * leading + or -. |
| * @return This instance. |
| */ |
| public OrdinalBuilder setNumber(String number) { |
| return setStringArgument(TtsSpan.ARG_NUMBER, number); |
| } |
| } |
| |
| /** |
| * A builder for TtsSpans of type {@link #TYPE_DECIMAL}. |
| */ |
| public static class DecimalBuilder |
| extends SemioticClassBuilder<DecimalBuilder> { |
| |
| /** |
| * Creates a builder for a TtsSpan of type {@link #TYPE_DECIMAL}. |
| */ |
| public DecimalBuilder() { |
| super(TtsSpan.TYPE_DECIMAL); |
| } |
| |
| /** |
| * Creates a TtsSpan of type {@link #TYPE_DECIMAL} and sets the |
| * {@link #ARG_INTEGER_PART} and {@link #ARG_FRACTIONAL_PART} arguments. |
| * @see {@link #setArgumentsFromDouble(double, int, int) |
| */ |
| public DecimalBuilder(double number, |
| int minimumFractionDigits, |
| int maximumFractionDigits) { |
| this(); |
| setArgumentsFromDouble(number, |
| minimumFractionDigits, |
| maximumFractionDigits); |
| } |
| |
| /** |
| * Creates a TtsSpan of type {@link #TYPE_DECIMAL} and sets the |
| * {@link #ARG_INTEGER_PART} and {@link #ARG_FRACTIONAL_PART} arguments. |
| */ |
| public DecimalBuilder(String integerPart, String fractionalPart) { |
| this(); |
| setIntegerPart(integerPart); |
| setFractionalPart(fractionalPart); |
| } |
| |
| /** |
| * Convenience method takes a double and a maximum number of fractional |
| * digits, it sets the {@link #ARG_INTEGER_PART} and |
| * {@link #ARG_FRACTIONAL_PART} arguments. |
| * @param number The number to be synthesized. |
| * @param minimumFractionDigits The minimum number of fraction digits |
| * that are pronounced. |
| * @param maximumFractionDigits The maximum number of fraction digits |
| * that are pronounced. If maximumFractionDigits < |
| * minimumFractionDigits then minimumFractionDigits will be assumed |
| * to be equal to maximumFractionDigits. |
| * @return This instance. |
| */ |
| public DecimalBuilder setArgumentsFromDouble( |
| double number, |
| int minimumFractionDigits, |
| int maximumFractionDigits) { |
| // Format double. |
| NumberFormat formatter = NumberFormat.getInstance(Locale.US); |
| formatter.setMinimumFractionDigits(maximumFractionDigits); |
| formatter.setMaximumFractionDigits(maximumFractionDigits); |
| formatter.setGroupingUsed(false); |
| String str = formatter.format(number); |
| |
| // Split at decimal point. |
| int i = str.indexOf('.'); |
| if (i >= 0) { |
| setIntegerPart(str.substring(0, i)); |
| setFractionalPart(str.substring(i + 1)); |
| } else { |
| setIntegerPart(str); |
| } |
| return this; |
| } |
| |
| /** |
| * Convenience method that converts the number to a String and sets it |
| * to the value for {@link #ARG_INTEGER_PART}. |
| * @param integerPart The integer part of the decimal. |
| * @return This instance. |
| */ |
| public DecimalBuilder setIntegerPart(long integerPart) { |
| return setIntegerPart(String.valueOf(integerPart)); |
| } |
| |
| /** |
| * Sets the {@link #ARG_INTEGER_PART} argument. |
| * @param integerPart A non-empty string of digits with an optional |
| * leading + or -. |
| * @return This instance. |
| */ |
| public DecimalBuilder setIntegerPart(String integerPart) { |
| return setStringArgument(TtsSpan.ARG_INTEGER_PART, integerPart); |
| } |
| |
| /** |
| * Sets the {@link #ARG_FRACTIONAL_PART} argument. |
| * @param fractionalPart A non-empty string of digits. |
| * @return This instance. |
| */ |
| public DecimalBuilder setFractionalPart(String fractionalPart) { |
| return setStringArgument(TtsSpan.ARG_FRACTIONAL_PART, |
| fractionalPart); |
| } |
| } |
| |
| /** |
| * A builder for TtsSpans of type {@link #TYPE_FRACTION}. |
| */ |
| public static class FractionBuilder |
| extends SemioticClassBuilder<FractionBuilder> { |
| |
| /** |
| * Creates a builder for a TtsSpan of type {@link #TYPE_FRACTION}. |
| */ |
| public FractionBuilder() { |
| super(TtsSpan.TYPE_FRACTION); |
| } |
| |
| /** |
| * Creates a TtsSpan of type {@link #TYPE_FRACTION} and sets the |
| * {@link #ARG_INTEGER_PART}, {@link #ARG_NUMERATOR}, and |
| * {@link #ARG_DENOMINATOR} arguments. |
| */ |
| public FractionBuilder(long integerPart, |
| long numerator, |
| long denominator) { |
| this(); |
| setIntegerPart(integerPart); |
| setNumerator(numerator); |
| setDenominator(denominator); |
| } |
| |
| /** |
| * Convenience method that converts the integer to a String and sets the |
| * argument {@link #ARG_NUMBER}. |
| * @param integerPart The integer part. |
| * @return This instance. |
| */ |
| public FractionBuilder setIntegerPart(long integerPart) { |
| return setIntegerPart(String.valueOf(integerPart)); |
| } |
| |
| /** |
| * Sets the {@link #ARG_INTEGER_PART} argument. |
| * @param integerPart A non-empty string of digits with an optional |
| * leading + or -. |
| * @return This instance. |
| */ |
| public FractionBuilder setIntegerPart(String integerPart) { |
| return setStringArgument(TtsSpan.ARG_INTEGER_PART, integerPart); |
| } |
| |
| /** |
| * Convenience method that converts the numerator to a String and sets |
| * the argument {@link #ARG_NUMERATOR}. |
| * @param numerator The numerator. |
| * @return This instance. |
| */ |
| public FractionBuilder setNumerator(long numerator) { |
| return setNumerator(String.valueOf(numerator)); |
| } |
| |
| /** |
| * Sets the {@link #ARG_NUMERATOR} argument. |
| * @param numerator A non-empty string of digits with an optional |
| * leading + or -. |
| * @return This instance. |
| */ |
| public FractionBuilder setNumerator(String numerator) { |
| return setStringArgument(TtsSpan.ARG_NUMERATOR, numerator); |
| } |
| |
| /** |
| * Convenience method that converts the denominator to a String and sets |
| * the argument {@link #ARG_DENOMINATOR}. |
| * @param denominator The denominator. |
| * @return This instance. |
| */ |
| public FractionBuilder setDenominator(long denominator) { |
| return setDenominator(String.valueOf(denominator)); |
| } |
| |
| /** |
| * Sets the {@link #ARG_DENOMINATOR} argument. |
| * @param denominator A non-empty string of digits with an optional |
| * leading + or -. |
| * @return This instance. |
| */ |
| public FractionBuilder setDenominator(String denominator) { |
| return setStringArgument(TtsSpan.ARG_DENOMINATOR, denominator); |
| } |
| } |
| |
| /** |
| * A builder for TtsSpans of type {@link #TYPE_MEASURE}. |
| */ |
| public static class MeasureBuilder |
| extends SemioticClassBuilder<MeasureBuilder> { |
| |
| /** |
| * Creates a builder for a TtsSpan of type {@link #TYPE_MEASURE}. |
| */ |
| public MeasureBuilder() { |
| super(TtsSpan.TYPE_MEASURE); |
| } |
| |
| /** |
| * Convenience method that converts the number to a String and set it to |
| * the value for {@link #ARG_NUMBER}. |
| * @param number The amount of the measure. |
| * @return This instance. |
| */ |
| public MeasureBuilder setNumber(long number) { |
| return setNumber(String.valueOf(number)); |
| } |
| |
| /** |
| * Sets the {@link #ARG_NUMBER} argument. |
| * @param number A non-empty string of digits with an optional |
| * leading + or -. |
| * @return This instance. |
| */ |
| public MeasureBuilder setNumber(String number) { |
| return setStringArgument(TtsSpan.ARG_NUMBER, number); |
| } |
| |
| /** |
| * Convenience method that converts the integer part to a String and set |
| * it to the value for {@link #ARG_INTEGER_PART}. |
| * @param integerPart The integer part of a decimal or fraction. |
| * @return This instance. |
| */ |
| public MeasureBuilder setIntegerPart(long integerPart) { |
| return setNumber(String.valueOf(integerPart)); |
| } |
| |
| /** |
| * Sets the {@link #ARG_INTEGER_PART} argument. |
| * @param integerPart The integer part of a decimal or fraction; a |
| * non-empty string of digits with an optional |
| * leading + or -. |
| * @return This instance. |
| */ |
| public MeasureBuilder setIntegerPart(String integerPart) { |
| return setStringArgument(TtsSpan.ARG_INTEGER_PART, integerPart); |
| } |
| |
| /** |
| * Sets the {@link #ARG_FRACTIONAL_PART} argument. |
| * @param fractionalPart The fractional part of a decimal; a non-empty |
| * string of digits with an optional leading + or -. |
| * @return This instance. |
| */ |
| public MeasureBuilder setFractionalPart(String fractionalPart) { |
| return setStringArgument(TtsSpan.ARG_FRACTIONAL_PART, |
| fractionalPart); |
| } |
| |
| /** |
| * Convenience method that converts the numerator to a String and set it |
| * to the value for {@link #ARG_NUMERATOR}. |
| * @param numerator The numerator of a fraction. |
| * @return This instance. |
| */ |
| public MeasureBuilder setNumerator(long numerator) { |
| return setNumerator(String.valueOf(numerator)); |
| } |
| |
| /** |
| * Sets the {@link #ARG_NUMERATOR} argument. |
| * @param numerator The numerator of a fraction; a non-empty string of |
| * digits with an optional leading + or -. |
| * @return This instance. |
| */ |
| public MeasureBuilder setNumerator(String numerator) { |
| return setStringArgument(TtsSpan.ARG_NUMERATOR, numerator); |
| } |
| |
| /** |
| * Convenience method that converts the denominator to a String and set |
| * it to the value for {@link #ARG_DENOMINATOR}. |
| * @param denominator The denominator of a fraction. |
| * @return This instance. |
| */ |
| public MeasureBuilder setDenominator(long denominator) { |
| return setDenominator(String.valueOf(denominator)); |
| } |
| |
| /** |
| * Sets the {@link #ARG_DENOMINATOR} argument. |
| * @param denominator The denominator of a fraction; a non-empty string |
| * of digits with an optional leading + or -. |
| * @return This instance. |
| */ |
| public MeasureBuilder setDenominator(String denominator) { |
| return setStringArgument(TtsSpan.ARG_DENOMINATOR, denominator); |
| } |
| |
| /** |
| * Sets the {@link #ARG_UNIT} argument. |
| * @param unit The unit of the measure. |
| * @return This instance. |
| * @see {@link TtsSpan.ARG_UNIT} |
| */ |
| public MeasureBuilder setUnit(String unit) { |
| return setStringArgument(TtsSpan.ARG_UNIT, unit); |
| } |
| } |
| |
| /** |
| * A builder for TtsSpans of type {@link #TYPE_TIME}. |
| */ |
| public static class TimeBuilder |
| extends SemioticClassBuilder<TimeBuilder> { |
| |
| /** |
| * Creates a builder for a TtsSpan of type {@link #TYPE_TIME}. |
| */ |
| public TimeBuilder() { |
| super(TtsSpan.TYPE_TIME); |
| } |
| |
| /** |
| * Creates a builder for a TtsSpan of type {@link #TYPE_TIME} and |
| * sets the {@link #ARG_HOURS} and {@link #ARG_MINUTES} arguments. |
| */ |
| public TimeBuilder(int hours, int minutes) { |
| this(); |
| setHours(hours); |
| setMinutes(minutes); |
| } |
| |
| /** |
| * Sets the {@link #ARG_HOURS} argument. |
| * @param hours The value to be set for hours. See {@link #ARG_HOURS}. |
| * @return This instance. |
| * @see {@link #ARG_HOURS} |
| */ |
| public TimeBuilder setHours(int hours) { |
| return setIntArgument(TtsSpan.ARG_HOURS, hours); |
| } |
| |
| /** |
| * Sets the {@link #ARG_MINUTES} argument. |
| * @param minutes The value to be set for minutes. See |
| * {@link #ARG_MINUTES}. |
| * @return This instance. |
| * @see {@link #ARG_MINUTES} |
| */ |
| public TimeBuilder setMinutes(int minutes) { |
| return setIntArgument(TtsSpan.ARG_MINUTES, minutes); |
| } |
| } |
| |
| /** |
| * A builder for TtsSpans of type {@link #TYPE_DATE}. |
| */ |
| public static class DateBuilder |
| extends SemioticClassBuilder<DateBuilder> { |
| |
| /** |
| * Creates a builder for a TtsSpan of type {@link #TYPE_DATE}. |
| */ |
| public DateBuilder() { |
| super(TtsSpan.TYPE_DATE); |
| } |
| |
| /** |
| * Creates a builder for a TtsSpan of type {@link #TYPE_TIME} and |
| * possibly sets the {@link #ARG_WEEKDAY}, {@link #ARG_DAY}, |
| * {@link #ARG_MONTH} and {@link #ARG_YEAR} arguments. Pass null to any |
| * argument to leave it unset. |
| */ |
| public DateBuilder(Integer weekday, |
| Integer day, |
| Integer month, |
| Integer year) { |
| this(); |
| if (weekday != null) { |
| setWeekday(weekday); |
| } |
| if (day != null) { |
| setDay(day); |
| } |
| if (month != null) { |
| setMonth(month); |
| } |
| if (year != null) { |
| setYear(year); |
| } |
| } |
| |
| /** |
| * Sets the {@link #ARG_WEEKDAY} argument. |
| * @param weekday The value to be set for weekday. See |
| * {@link #ARG_WEEKDAY}. |
| * @return This instance. |
| * @see {@link #ARG_WEEKDAY} |
| */ |
| public DateBuilder setWeekday(int weekday) { |
| return setIntArgument(TtsSpan.ARG_WEEKDAY, weekday); |
| } |
| |
| /** |
| * Sets the {@link #ARG_DAY} argument. |
| * @param day The value to be set for day. See {@link #ARG_DAY}. |
| * @return This instance. |
| * @see {@link #ARG_DAY} |
| */ |
| public DateBuilder setDay(int day) { |
| return setIntArgument(TtsSpan.ARG_DAY, day); |
| } |
| |
| /** |
| * Sets the {@link #ARG_MONTH} argument. |
| * @param month The value to be set for month. See {@link #ARG_MONTH}. |
| * @return This instance. |
| * @see {@link #ARG_MONTH} |
| */ |
| public DateBuilder setMonth(int month) { |
| return setIntArgument(TtsSpan.ARG_MONTH, month); |
| } |
| |
| /** |
| * Sets the {@link #ARG_YEAR} argument. |
| * @param year The value to be set for year. See {@link #ARG_YEAR}. |
| * @return This instance. |
| * @see {@link #ARG_YEAR} |
| */ |
| public DateBuilder setYear(int year) { |
| return setIntArgument(TtsSpan.ARG_YEAR, year); |
| } |
| } |
| |
| /** |
| * A builder for TtsSpans of type {@link #TYPE_MONEY}. |
| */ |
| public static class MoneyBuilder |
| extends SemioticClassBuilder<MoneyBuilder> { |
| |
| /** |
| * Creates a TtsSpan of type {@link #TYPE_MONEY}. |
| */ |
| public MoneyBuilder() { |
| super(TtsSpan.TYPE_MONEY); |
| } |
| |
| /** |
| * Convenience method that converts the number to a String and set it to |
| * the value for {@link #ARG_INTEGER_PART}. |
| * @param integerPart The integer part of the amount. |
| * @return This instance. |
| */ |
| public MoneyBuilder setIntegerPart(long integerPart) { |
| return setIntegerPart(String.valueOf(integerPart)); |
| } |
| |
| /** |
| * Sets the {@link #ARG_INTEGER_PART} argument. |
| * @param integerPart A non-empty string of digits with an optional |
| * leading + or -. |
| * @return This instance. |
| */ |
| public MoneyBuilder setIntegerPart(String integerPart) { |
| return setStringArgument(TtsSpan.ARG_INTEGER_PART, integerPart); |
| } |
| |
| /** |
| * Sets the {@link #ARG_FRACTIONAL_PART} argument. |
| * @param fractionalPart Can be a string of digits of any size. |
| * @return This instance. |
| */ |
| public MoneyBuilder setFractionalPart(String fractionalPart) { |
| return setStringArgument(TtsSpan.ARG_FRACTIONAL_PART, fractionalPart); |
| } |
| |
| /** |
| * Sets the {@link #ARG_CURRENCY} argument. |
| * @param currency Should be a ISO4217 currency code, e.g. "USD". |
| * @return This instance. |
| */ |
| public MoneyBuilder setCurrency(String currency) { |
| return setStringArgument(TtsSpan.ARG_CURRENCY, currency); |
| } |
| |
| /** |
| * Sets the {@link #ARG_QUANTITY} argument. |
| * @param quantity |
| * @return This instance. |
| */ |
| public MoneyBuilder setQuantity(String quantity) { |
| return setStringArgument(TtsSpan.ARG_QUANTITY, quantity); |
| } |
| } |
| |
| /** |
| * A builder for TtsSpans of type {@link #TYPE_TELEPHONE}. |
| */ |
| public static class TelephoneBuilder |
| extends SemioticClassBuilder<TelephoneBuilder> { |
| |
| /** |
| * Creates a TtsSpan of type {@link #TYPE_TELEPHONE}. |
| */ |
| public TelephoneBuilder() { |
| super(TtsSpan.TYPE_TELEPHONE); |
| } |
| |
| /** |
| * Creates a TtsSpan of type {@link #TYPE_TELEPHONE} and sets the |
| * {@link #ARG_NUMBER_PARTS} argument. |
| */ |
| public TelephoneBuilder(String numberParts) { |
| this(); |
| setNumberParts(numberParts); |
| } |
| |
| /** |
| * Sets the {@link #ARG_COUNTRY_CODE} argument. |
| * @param countryCode The country code can be a series of digits |
| * optionally prefixed with a "+". |
| * @return This instance. |
| */ |
| public TelephoneBuilder setCountryCode(String countryCode) { |
| return setStringArgument(TtsSpan.ARG_COUNTRY_CODE, countryCode); |
| } |
| |
| /** |
| * Sets the {@link #ARG_NUMBER_PARTS} argument. |
| * @param numberParts The main telephone number. Can be a series of |
| * digits and letters separated by spaces, "/", "-" or ".". |
| * @return This instance. |
| */ |
| public TelephoneBuilder setNumberParts(String numberParts) { |
| return setStringArgument(TtsSpan.ARG_NUMBER_PARTS, numberParts); |
| } |
| |
| /** |
| * Sets the {@link #ARG_EXTENSION} argument. |
| * @param extension The extension can be a series of digits. |
| * @return This instance. |
| */ |
| public TelephoneBuilder setExtension(String extension) { |
| return setStringArgument(TtsSpan.ARG_EXTENSION, extension); |
| } |
| } |
| |
| /** |
| * A builder for TtsSpans of type {@link #TYPE_ELECTRONIC}. |
| */ |
| public static class ElectronicBuilder |
| extends SemioticClassBuilder<ElectronicBuilder> { |
| |
| /** |
| * Creates a TtsSpan of type {@link #TYPE_ELECTRONIC}. |
| */ |
| public ElectronicBuilder() { |
| super(TtsSpan.TYPE_ELECTRONIC); |
| } |
| |
| /** |
| * Sets the {@link #ARG_USERNAME} and {@link #ARG_DOMAIN} |
| * arguments, representing an email address. |
| * @param username The part before the @ in the email address. |
| * @param domain The part after the @ in the email address. |
| * @return This instance. |
| */ |
| public ElectronicBuilder setEmailArguments(String username, |
| String domain) { |
| return setDomain(domain).setUsername(username); |
| } |
| |
| /** |
| * Sets the {@link #ARG_PROTOCOL} argument. |
| * @param protocol The protocol of the URI. Examples are "http" and |
| * "ftp". |
| * @return This instance. |
| */ |
| public ElectronicBuilder setProtocol(String protocol) { |
| return setStringArgument(TtsSpan.ARG_PROTOCOL, protocol); |
| } |
| |
| /** |
| * Sets the {@link #ARG_USERNAME} argument. |
| * @return This instance. |
| */ |
| public ElectronicBuilder setUsername(String username) { |
| return setStringArgument(TtsSpan.ARG_USERNAME, username); |
| } |
| |
| /** |
| * Sets the {@link #ARG_PASSWORD} argument. |
| * @return This instance. |
| */ |
| public ElectronicBuilder setPassword(String password) { |
| return setStringArgument(TtsSpan.ARG_PASSWORD, password); |
| } |
| |
| /** |
| * Sets the {@link #ARG_DOMAIN} argument. |
| * @param domain The domain, for example "source.android.com". |
| * @return This instance. |
| */ |
| public ElectronicBuilder setDomain(String domain) { |
| return setStringArgument(TtsSpan.ARG_DOMAIN, domain); |
| } |
| |
| /** |
| * Sets the {@link #ARG_PORT} argument. |
| * @return This instance. |
| */ |
| public ElectronicBuilder setPort(int port) { |
| return setIntArgument(TtsSpan.ARG_PORT, port); |
| } |
| |
| /** |
| * Sets the {@link #ARG_PATH} argument. |
| * @param path For example "source/index.html". |
| * @return This instance. |
| */ |
| public ElectronicBuilder setPath(String path) { |
| return setStringArgument(TtsSpan.ARG_PATH, path); |
| } |
| |
| /** |
| * Sets the {@link #ARG_QUERY_STRING} argument. |
| * @param queryString For example "arg=value&argtwo=value". |
| * @return This instance. |
| */ |
| public ElectronicBuilder setQueryString(String queryString) { |
| return setStringArgument(TtsSpan.ARG_QUERY_STRING, queryString); |
| } |
| |
| /** |
| * Sets the {@link #ARG_FRAGMENT_ID} argument. |
| * @return This instance. |
| */ |
| public ElectronicBuilder setFragmentId(String fragmentId) { |
| return setStringArgument(TtsSpan.ARG_FRAGMENT_ID, fragmentId); |
| } |
| } |
| |
| /** |
| * A builder for TtsSpans of type {@link #TYPE_DIGITS}. |
| */ |
| public static class DigitsBuilder |
| extends SemioticClassBuilder<DigitsBuilder> { |
| |
| /** |
| * Creates a builder for a TtsSpan of type {@link #TYPE_DIGITS}. |
| */ |
| public DigitsBuilder() { |
| super(TtsSpan.TYPE_DIGITS); |
| } |
| |
| /** |
| * Creates a builder for a TtsSpan of type {@link #TYPE_DIGITS} |
| * and sets the {@link #ARG_DIGITS} argument. |
| */ |
| public DigitsBuilder(String digits) { |
| this(); |
| setDigits(digits); |
| } |
| |
| /** |
| * Sets the {@link #ARG_DIGITS} argument. |
| * @param digits A string of digits. |
| * @return This instance. |
| */ |
| public DigitsBuilder setDigits(String digits) { |
| return setStringArgument(TtsSpan.ARG_DIGITS, digits); |
| } |
| } |
| |
| /** |
| * A builder for TtsSpans of type {@link #TYPE_VERBATIM}. |
| */ |
| public static class VerbatimBuilder |
| extends SemioticClassBuilder<VerbatimBuilder> { |
| |
| /** |
| * Creates a builder for a TtsSpan of type {@link #TYPE_VERBATIM}. |
| */ |
| public VerbatimBuilder() { |
| super(TtsSpan.TYPE_VERBATIM); |
| } |
| |
| /** |
| * Creates a builder for a TtsSpan of type {@link #TYPE_VERBATIM} |
| * and sets the {@link #ARG_VERBATIM} argument. |
| */ |
| public VerbatimBuilder(String verbatim) { |
| this(); |
| setVerbatim(verbatim); |
| } |
| |
| /** |
| * Sets the {@link #ARG_VERBATIM} argument. |
| * @param verbatim A string of characters that will be read verbatim, |
| * except whitespace. |
| * @return This instance. |
| */ |
| public VerbatimBuilder setVerbatim(String verbatim) { |
| return setStringArgument(TtsSpan.ARG_VERBATIM, verbatim); |
| } |
| } |
| } |
