content: /*
   * Copyright (C) 2011 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.speech.tts;
  
  import static android.provider.Settings.Secure.getString;
  
  import android.annotation.NonNull;
  import android.annotation.UnsupportedAppUsage;
  import android.content.Context;
  import android.content.Intent;
  import android.content.pm.ApplicationInfo;
  import android.content.pm.PackageManager;
  import android.content.pm.PackageManager.NameNotFoundException;
  import android.content.pm.ResolveInfo;
  import android.content.pm.ServiceInfo;
  import android.content.res.Resources;
  import android.content.res.TypedArray;
  import android.content.res.XmlResourceParser;
  import android.provider.Settings;
  import android.speech.tts.TextToSpeech.Engine;
  import android.speech.tts.TextToSpeech.EngineInfo;
  import android.text.TextUtils;
  import android.util.AttributeSet;
  import android.util.Log;
  import android.util.Xml;
  
  import org.xmlpull.v1.XmlPullParserException;
  
  import java.io.IOException;
  import java.util.ArrayList;
  import java.util.Collections;
  import java.util.Comparator;
  import java.util.HashMap;
  import java.util.List;
  import java.util.Locale;
  import java.util.Map;
  import java.util.MissingResourceException;
  
  /**
   * Support class for querying the list of available engines
   * on the device and deciding which one to use etc.
   *
   * Comments in this class the use the shorthand "system engines" for engines that
   * are a part of the system image.
   *
   * This class is thread-safe/
   *
   * @hide
   */
  public class TtsEngines {
      private static final String TAG = "TtsEngines";
      private static final boolean DBG = false;
  
      /** Locale delimiter used by the old-style 3 char locale string format (like "eng-usa") */
      private static final String LOCALE_DELIMITER_OLD = "-";
  
      /** Locale delimiter used by the new-style locale string format (Locale.toString() results,
       * like "en_US") */
      private static final String LOCALE_DELIMITER_NEW = "_";
  
      private final Context mContext;
  
      /** Mapping of various language strings to the normalized Locale form */
      private static final Map<String, String> sNormalizeLanguage;
  
      /** Mapping of various country strings to the normalized Locale form */
      private static final Map<String, String> sNormalizeCountry;
  
      // Populate the sNormalize* maps
      static {
          HashMap<String, String> normalizeLanguage = new HashMap<String, String>();
          for (String language : Locale.getISOLanguages()) {
              try {
                  normalizeLanguage.put(new Locale(language).getISO3Language(), language);
              } catch (MissingResourceException e) {
                  continue;
              }
          }
          sNormalizeLanguage = Collections.unmodifiableMap(normalizeLanguage);
  
          HashMap<String, String> normalizeCountry = new HashMap<String, String>();
          for (String country : Locale.getISOCountries()) {
              try {
                  normalizeCountry.put(new Locale("", country).getISO3Country(), country);
              } catch (MissingResourceException e) {
                  continue;
              }
          }
          sNormalizeCountry = Collections.unmodifiableMap(normalizeCountry);
      }
  
      @UnsupportedAppUsage
      public TtsEngines(Context ctx) {
          mContext = ctx;
      }
  
      /**
       * @return the default TTS engine. If the user has set a default, and the engine
       *         is available on the device, the default is returned. Otherwise,
       *         the highest ranked engine is returned as per {@link EngineInfoComparator}.
       */
      public String getDefaultEngine() {
          String engine = getString(mContext.getContentResolver(),
                  Settings.Secure.TTS_DEFAULT_SYNTH);
          return isEngineInstalled(engine) ? engine : getHighestRankedEngineName();
      }
  
      /**
       * @return the package name of the highest ranked system engine, {@code null}
       *         if no TTS engines were present in the system image.
       */
      public String getHighestRankedEngineName() {
          final List<EngineInfo> engines = getEngines();
  
          if (engines.size() > 0 && engines.get(0).system) {
              return engines.get(0).name;
          }
  
          return null;
      }
  
      /**
       * Returns the engine info for a given engine name. Note that engines are
       * identified by their package name.
       */
      public EngineInfo getEngineInfo(String packageName) {
          PackageManager pm = mContext.getPackageManager();
          Intent intent = new Intent(Engine.INTENT_ACTION_TTS_SERVICE);
          intent.setPackage(packageName);
          List<ResolveInfo> resolveInfos = pm.queryIntentServices(intent,
                  PackageManager.MATCH_DEFAULT_ONLY);
          // Note that the current API allows only one engine per
          // package name. Since the "engine name" is the same as
          // the package name.
          if (resolveInfos != null && resolveInfos.size() == 1) {
              return getEngineInfo(resolveInfos.get(0), pm);
          }
  
          return null;
      }
  
      /**
       * Gets a list of all installed TTS engines.
       *
       * @return A list of engine info objects. The list can be empty, but never {@code null}.
       */
      @UnsupportedAppUsage
      public List<EngineInfo> getEngines() {
          PackageManager pm = mContext.getPackageManager();
          Intent intent = new Intent(Engine.INTENT_ACTION_TTS_SERVICE);
          List<ResolveInfo> resolveInfos =
                  pm.queryIntentServices(intent, PackageManager.MATCH_DEFAULT_ONLY);
          if (resolveInfos == null) return Collections.emptyList();
  
          List<EngineInfo> engines = new ArrayList<EngineInfo>(resolveInfos.size());
  
          for (ResolveInfo resolveInfo : resolveInfos) {
              EngineInfo engine = getEngineInfo(resolveInfo, pm);
              if (engine != null) {
                  engines.add(engine);
              }
          }
          Collections.sort(engines, EngineInfoComparator.INSTANCE);
  
          return engines;
      }
  
      private boolean isSystemEngine(ServiceInfo info) {
          final ApplicationInfo appInfo = info.applicationInfo;
          return appInfo != null && (appInfo.flags & ApplicationInfo.FLAG_SYSTEM) != 0;
      }
  
      /**
       * @return true if a given engine is installed on the system.
       */
      public boolean isEngineInstalled(String engine) {
          if (engine == null) {
              return false;
          }
  
          return getEngineInfo(engine) != null;
      }
  
      /**
       * @return an intent that can launch the settings activity for a given tts engine.
       */
      @UnsupportedAppUsage
      public Intent getSettingsIntent(String engine) {
          PackageManager pm = mContext.getPackageManager();
          Intent intent = new Intent(Engine.INTENT_ACTION_TTS_SERVICE);
          intent.setPackage(engine);
          List<ResolveInfo> resolveInfos = pm.queryIntentServices(intent,
                  PackageManager.MATCH_DEFAULT_ONLY | PackageManager.GET_META_DATA);
          // Note that the current API allows only one engine per
          // package name. Since the "engine name" is the same as
          // the package name.
          if (resolveInfos != null && resolveInfos.size() == 1) {
              ServiceInfo service = resolveInfos.get(0).serviceInfo;
              if (service != null) {
                  final String settings = settingsActivityFromServiceInfo(service, pm);
                  if (settings != null) {
                      Intent i = new Intent();
                      i.setClassName(engine, settings);
                      return i;
                  }
              }
          }
  
          return null;
      }
  
      /**
       * The name of the XML tag that text to speech engines must use to
       * declare their meta data.
       *
       * {@link com.android.internal.R.styleable#TextToSpeechEngine}
       */
      private static final String XML_TAG_NAME = "tts-engine";
  
      private String settingsActivityFromServiceInfo(ServiceInfo si, PackageManager pm) {
          XmlResourceParser parser = null;
          try {
              parser = si.loadXmlMetaData(pm, TextToSpeech.Engine.SERVICE_META_DATA);
              if (parser == null) {
                  Log.w(TAG, "No meta-data found for :" + si);
                  return null;
              }
  
              final Resources res = pm.getResourcesForApplication(si.applicationInfo);
  
              int type;
              while ((type = parser.next()) != XmlResourceParser.END_DOCUMENT) {
                  if (type == XmlResourceParser.START_TAG) {
                      if (!XML_TAG_NAME.equals(parser.getName())) {
                          Log.w(TAG, "Package " + si + " uses unknown tag :"
                                  + parser.getName());
                          return null;
                      }
  
                      final AttributeSet attrs = Xml.asAttributeSet(parser);
                      final TypedArray array = res.obtainAttributes(attrs,
                              com.android.internal.R.styleable.TextToSpeechEngine);
                      final String settings = array.getString(
                              com.android.internal.R.styleable.TextToSpeechEngine_settingsActivity);
                      array.recycle();
  
                      return settings;
                  }
              }
  
              return null;
          } catch (NameNotFoundException e) {
              Log.w(TAG, "Could not load resources for : " + si);
              return null;
          } catch (XmlPullParserException e) {
              Log.w(TAG, "Error parsing metadata for " + si + ":" + e);
              return null;
          } catch (IOException e) {
              Log.w(TAG, "Error parsing metadata for " + si + ":" + e);
              return null;
          } finally {
              if (parser != null) {
                  parser.close();
              }
          }
      }
  
      private EngineInfo getEngineInfo(ResolveInfo resolve, PackageManager pm) {
          ServiceInfo service = resolve.serviceInfo;
          if (service != null) {
              EngineInfo engine = new EngineInfo();
              // Using just the package name isn't great, since it disallows having
              // multiple engines in the same package, but that's what the existing API does.
              engine.name = service.packageName;
              CharSequence label = service.loadLabel(pm);
              engine.label = TextUtils.isEmpty(label) ? engine.name : label.toString();
              engine.icon = service.getIconResource();
              engine.priority = resolve.priority;
              engine.system = isSystemEngine(service);
              return engine;
          }
  
          return null;
      }
  
      private static class EngineInfoComparator implements Comparator<EngineInfo> {
          private EngineInfoComparator() { }
  
          static EngineInfoComparator INSTANCE = new EngineInfoComparator();
  
          /**
           * Engines that are a part of the system image are always lesser
           * than those that are not. Within system engines / non system engines
           * the engines are sorted in order of their declared priority.
           */
          @Override
          public int compare(EngineInfo lhs, EngineInfo rhs) {
              if (lhs.system && !rhs.system) {
                  return -1;
              } else if (rhs.system && !lhs.system) {
                  return 1;
              } else {
                  // Either both system engines, or both non system
                  // engines.
                  //
                  // Note, this isn't a typo. Higher priority numbers imply
                  // higher priority, but are "lower" in the sort order.
                  return rhs.priority - lhs.priority;
              }
          }
      }
  
      /**
       * Returns the default locale for a given TTS engine. Attempts to read the
       * value from {@link Settings.Secure#TTS_DEFAULT_LOCALE}, failing which the
       * default phone locale is returned.
       *
       * @param engineName the engine to return the locale for.
       * @return the locale preference for this engine. Will be non null.
       */
      @UnsupportedAppUsage
      public Locale getLocalePrefForEngine(String engineName) {
          return getLocalePrefForEngine(engineName,
                  getString(mContext.getContentResolver(), Settings.Secure.TTS_DEFAULT_LOCALE));
      }
  
      /**
       * Returns the default locale for a given TTS engine from given settings string. */
      public Locale getLocalePrefForEngine(String engineName, String prefValue) {
          String localeString = parseEnginePrefFromList(
                  prefValue,
                  engineName);
  
          if (TextUtils.isEmpty(localeString)) {
              // The new style setting is unset, attempt to return the old style setting.
              return Locale.getDefault();
          }
  
          Locale result = parseLocaleString(localeString);
          if (result == null) {
              Log.w(TAG, "Failed to parse locale " + localeString + ", returning en_US instead");
              result = Locale.US;
          }
  
          if (DBG) Log.d(TAG, "getLocalePrefForEngine(" + engineName + ")= " + result);
  
          return result;
      }
  
  
      /**
       * True if a given TTS engine uses the default phone locale as a default locale. Attempts to
       * read the value from {@link Settings.Secure#TTS_DEFAULT_LOCALE}. If
       * its  value is empty, this methods returns true.
       *
       * @param engineName the engine to return the locale for.
       */
      public boolean isLocaleSetToDefaultForEngine(String engineName) {
          return TextUtils.isEmpty(parseEnginePrefFromList(
                      getString(mContext.getContentResolver(), Settings.Secure.TTS_DEFAULT_LOCALE),
                      engineName));
      }
  
      /**
       * Parses a locale encoded as a string, and tries its best to return a valid {@link Locale}
       * object, even if the input string is encoded using the old-style 3 character format e.g.
       * "deu-deu". At the end, we test if the resulting locale can return ISO3 language and
       * country codes ({@link Locale#getISO3Language()} and {@link Locale#getISO3Country()}),
       * if it fails to do so, we return null.
       */
      @UnsupportedAppUsage
      public Locale parseLocaleString(String localeString) {
          String language = "", country = "", variant = "";
          if (!TextUtils.isEmpty(localeString)) {
              String[] split = localeString.split(
                      "[" + LOCALE_DELIMITER_OLD + LOCALE_DELIMITER_NEW + "]");
              language = split[0].toLowerCase();
              if (split.length == 0) {
                  Log.w(TAG, "Failed to convert " + localeString + " to a valid Locale object. Only" +
                              " separators");
                  return null;
              }
              if (split.length > 3) {
                  Log.w(TAG, "Failed to convert " + localeString + " to a valid Locale object. Too" +
                          " many separators");
                  return null;
              }
              if (split.length >= 2) {
                  country = split[1].toUpperCase();
              }
              if (split.length >= 3) {
                  variant = split[2];
              }
  
          }
  
          String normalizedLanguage = sNormalizeLanguage.get(language);
          if (normalizedLanguage != null) {
              language = normalizedLanguage;
          }
  
          String normalizedCountry= sNormalizeCountry.get(country);
          if (normalizedCountry != null) {
              country = normalizedCountry;
          }
  
          if (DBG) Log.d(TAG, "parseLocalePref(" + language + "," + country +
                  "," + variant +")");
  
          Locale result = new Locale(language, country, variant);
          try {
              result.getISO3Language();
              result.getISO3Country();
              return result;
          } catch(MissingResourceException e) {
              Log.w(TAG, "Failed to convert " + localeString + " to a valid Locale object.");
              return null;
          }
      }
  
      /**
       * This method tries its best to return a valid {@link Locale} object from the TTS-specific
       * Locale input (returned by {@link TextToSpeech#getLanguage}
       * and {@link TextToSpeech#getDefaultLanguage}). A TTS Locale language field contains
       * a three-letter ISO 639-2/T code (where a proper Locale would use a two-letter ISO 639-1
       * code), and the country field contains a three-letter ISO 3166 country code (where a proper
       * Locale would use a two-letter ISO 3166-1 code).
       *
       * This method tries to convert three-letter language and country codes into their two-letter
       * equivalents. If it fails to do so, it keeps the value from the TTS locale.
       */
      @UnsupportedAppUsage
      public static Locale normalizeTTSLocale(Locale ttsLocale) {
          String language = ttsLocale.getLanguage();
          if (!TextUtils.isEmpty(language)) {
              String normalizedLanguage = sNormalizeLanguage.get(language);
              if (normalizedLanguage != null) {
                  language = normalizedLanguage;
              }
          }
  
          String country = ttsLocale.getCountry();
          if (!TextUtils.isEmpty(country)) {
              String normalizedCountry= sNormalizeCountry.get(country);
              if (normalizedCountry != null) {
                  country = normalizedCountry;
              }
          }
          return new Locale(language, country, ttsLocale.getVariant());
      }
  
      /**
       * Return the old-style string form of the locale. It consists of 3 letter codes:
       * <ul>
       *   <li>"ISO 639-2/T language code" if the locale has no country entry</li>
       *   <li> "ISO 639-2/T language code{@link #LOCALE_DELIMITER}ISO 3166 country code"
       *     if the locale has no variant entry</li>
       *   <li> "ISO 639-2/T language code{@link #LOCALE_DELIMITER}ISO 3166 country
       *     code{@link #LOCALE_DELIMITER}variant" if the locale has a variant entry</li>
       * </ul>
       * If we fail to generate those codes using {@link Locale#getISO3Country()} and
       * {@link Locale#getISO3Language()}, then we return new String[]{"eng","USA",""};
       */
      static public String[] toOldLocaleStringFormat(Locale locale) {
          String[] ret = new String[]{"","",""};
          try {
              // Note that the default locale might have an empty variant
              // or language.
              ret[0] = locale.getISO3Language();
              ret[1] = locale.getISO3Country();
              ret[2] = locale.getVariant();
  
              return ret;
          } catch (MissingResourceException e) {
              // Default locale does not have a ISO 3166 and/or ISO 639-2/T codes. Return the
              // default "eng-usa" (that would be the result of Locale.getDefault() == Locale.US).
              return new String[]{"eng","USA",""};
          }
      }
  
      /**
       * Parses a comma separated list of engine locale preferences. The list is of the
       * form {@code "engine_name_1:locale_1,engine_name_2:locale2"} and so on and
       * so forth. Returns null if the list is empty, malformed or if there is no engine
       * specific preference in the list.
       */
      private static String parseEnginePrefFromList(String prefValue, String engineName) {
          if (TextUtils.isEmpty(prefValue)) {
              return null;
          }
  
          String[] prefValues = prefValue.split(",");
  
          for (String value : prefValues) {
              final int delimiter = value.indexOf(':');
              if (delimiter > 0) {
                  if (engineName.equals(value.substring(0, delimiter))) {
                      return value.substring(delimiter + 1);
                  }
              }
          }
  
          return null;
      }
  
      /**
       * Serialize the locale to a string and store it as a default locale for the given engine. If
       * the passed locale is null, an empty string will be serialized; that empty string, when
       * read back, will evaluate to {@link Locale#getDefault()}.
       */
      @UnsupportedAppUsage
      public synchronized void updateLocalePrefForEngine(
              @NonNull String engineName, Locale newLocale) {
          final String prefList = Settings.Secure.getString(mContext.getContentResolver(),
                  Settings.Secure.TTS_DEFAULT_LOCALE);
          if (DBG) {
              Log.d(TAG, "updateLocalePrefForEngine(" + engineName + ", " + newLocale +
                      "), originally: " + prefList);
          }
  
          final String newPrefList = updateValueInCommaSeparatedList(prefList,
                  engineName, (newLocale != null) ? newLocale.toString() : "");
  
          if (DBG) Log.d(TAG, "updateLocalePrefForEngine(), writing: " + newPrefList.toString());
  
          Settings.Secure.putString(mContext.getContentResolver(),
                  Settings.Secure.TTS_DEFAULT_LOCALE, newPrefList.toString());
      }
  
      /**
       * Updates the value for a given key in a comma separated list of key value pairs,
       * each of which are delimited by a colon. If no value exists for the given key,
       * the kay value pair are appended to the end of the list.
       */
      private String updateValueInCommaSeparatedList(String list, String key,
              String newValue) {
          StringBuilder newPrefList = new StringBuilder();
          if (TextUtils.isEmpty(list)) {
              // If empty, create a new list with a single entry.
              newPrefList.append(key).append(':').append(newValue);
          } else {
              String[] prefValues = list.split(",");
              // Whether this is the first iteration in the loop.
              boolean first = true;
              // Whether we found the given key.
              boolean found = false;
              for (String value : prefValues) {
                  final int delimiter = value.indexOf(':');
                  if (delimiter > 0) {
                      if (key.equals(value.substring(0, delimiter))) {
                          if (first) {
                              first = false;
                          } else {
                              newPrefList.append(',');
                          }
                          found = true;
                          newPrefList.append(key).append(':').append(newValue);
                      } else {
                          if (first) {
                              first = false;
                          } else {
                              newPrefList.append(',');
                          }
                          // Copy across the entire key + value as is.
                          newPrefList.append(value);
                      }
                  }
              }
  
              if (!found) {
                  // Not found, but the rest of the keys would have been copied
                  // over already, so just append it to the end.
                  newPrefList.append(',');
                  newPrefList.append(key).append(':').append(newValue);
              }
          }
  
          return newPrefList.toString();
      }
  }
  