core/java/android/view/textservice/SpellCheckerSubtype.java - platform/frameworks/base - Git at Google

 /*
  * 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.view.textservice;

 import android.content.Context;
 import android.content.pm.ApplicationInfo;
 import android.os.Parcel;
 import android.os.Parcelable;
 import android.text.TextUtils;
 import android.util.Slog;

 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Locale;

 /**
  * This class is used to specify meta information of a subtype contained in a spell checker.
  * Subtype can describe locale (e.g. en_US, fr_FR...) used for settings.
  */
 public final class SpellCheckerSubtype implements Parcelable {
     private static final String TAG = SpellCheckerSubtype.class.getSimpleName();
     private static final String EXTRA_VALUE_PAIR_SEPARATOR = ",";
     private static final String EXTRA_VALUE_KEY_VALUE_SEPARATOR = "=";

     private final int mSubtypeHashCode;
     private final int mSubtypeNameResId;
     private final String mSubtypeLocale;
     private final String mSubtypeExtraValue;
     private HashMap<String, String> mExtraValueHashMapCache;

     /**
      * Constructor
      * @param nameId The name of the subtype
      * @param locale The locale supported by the subtype
      * @param extraValue The extra value of the subtype
      */
     public SpellCheckerSubtype(int nameId, String locale, String extraValue) {
         mSubtypeNameResId = nameId;
         mSubtypeLocale = locale != null ? locale : "";
         mSubtypeExtraValue = extraValue != null ? extraValue : "";
         mSubtypeHashCode = hashCodeInternal(mSubtypeLocale, mSubtypeExtraValue);
     }

     SpellCheckerSubtype(Parcel source) {
         String s;
         mSubtypeNameResId = source.readInt();
         s = source.readString();
         mSubtypeLocale = s != null ? s : "";
         s = source.readString();
         mSubtypeExtraValue = s != null ? s : "";
         mSubtypeHashCode = hashCodeInternal(mSubtypeLocale, mSubtypeExtraValue);
     }

     /**
      * @return the name of the subtype
      */
     public int getNameResId() {
         return mSubtypeNameResId;
     }

     /**
      * @return the locale of the subtype
      */
     public String getLocale() {
         return mSubtypeLocale;
     }

     /**
      * @return the extra value of the subtype
      */
     public String getExtraValue() {
         return mSubtypeExtraValue;
     }

     private HashMap<String, String> getExtraValueHashMap() {
         if (mExtraValueHashMapCache == null) {
             mExtraValueHashMapCache = new HashMap<String, String>();
             final String[] pairs = mSubtypeExtraValue.split(EXTRA_VALUE_PAIR_SEPARATOR);
             final int N = pairs.length;
             for (int i = 0; i < N; ++i) {
                 final String[] pair = pairs[i].split(EXTRA_VALUE_KEY_VALUE_SEPARATOR);
                 if (pair.length == 1) {
                     mExtraValueHashMapCache.put(pair[0], null);
                 } else if (pair.length > 1) {
                     if (pair.length > 2) {
                         Slog.w(TAG, "ExtraValue has two or more '='s");
                     }
                     mExtraValueHashMapCache.put(pair[0], pair[1]);
                 }
             }
         }
         return mExtraValueHashMapCache;
     }

     /**
      * The string of ExtraValue in subtype should be defined as follows:
      * example: key0,key1=value1,key2,key3,key4=value4
      * @param key the key of extra value
      * @return the subtype contains specified the extra value
      */
     public boolean containsExtraValueKey(String key) {
         return getExtraValueHashMap().containsKey(key);
     }

     /**
      * The string of ExtraValue in subtype should be defined as follows:
      * example: key0,key1=value1,key2,key3,key4=value4
      * @param key the key of extra value
      * @return the value of the specified key
      */
     public String getExtraValueOf(String key) {
         return getExtraValueHashMap().get(key);
     }

     @Override
     public int hashCode() {
         return mSubtypeHashCode;
     }

     @Override
     public boolean equals(Object o) {
         if (o instanceof SpellCheckerSubtype) {
             SpellCheckerSubtype subtype = (SpellCheckerSubtype) o;
             return (subtype.hashCode() == hashCode())
                 && (subtype.getNameResId() == getNameResId())
                 && (subtype.getLocale().equals(getLocale()))
                 && (subtype.getExtraValue().equals(getExtraValue()));
         }
         return false;
     }

     /**
      * @hide
      */
     public static Locale constructLocaleFromString(String localeStr) {
         if (TextUtils.isEmpty(localeStr))
             return null;
         String[] localeParams = localeStr.split("_", 3);
         // The length of localeStr is guaranteed to always return a 1 <= value <= 3
         // because localeStr is not empty.
         if (localeParams.length == 1) {
             return new Locale(localeParams[0]);
         } else if (localeParams.length == 2) {
             return new Locale(localeParams[0], localeParams[1]);
         } else if (localeParams.length == 3) {
             return new Locale(localeParams[0], localeParams[1], localeParams[2]);
         }
         return null;
     }

     /**
      * @param context Context will be used for getting Locale and PackageManager.
      * @param packageName The package name of the spell checker
      * @param appInfo The application info of the spell checker
      * @return a display name for this subtype. The string resource of the label (mSubtypeNameResId)
      * can have only one %s in it. If there is, the %s part will be replaced with the locale's
      * display name by the formatter. If there is not, this method simply returns the string
      * specified by mSubtypeNameResId. If mSubtypeNameResId is not specified (== 0), it's up to the
      * framework to generate an appropriate display name.
      */
     public CharSequence getDisplayName(
             Context context, String packageName, ApplicationInfo appInfo) {
         final Locale locale = constructLocaleFromString(mSubtypeLocale);
         final String localeStr = locale != null ? locale.getDisplayName() : mSubtypeLocale;
         if (mSubtypeNameResId == 0) {
             return localeStr;
         }
         final CharSequence subtypeName = context.getPackageManager().getText(
                 packageName, mSubtypeNameResId, appInfo);
         if (!TextUtils.isEmpty(subtypeName)) {
             return String.format(subtypeName.toString(), localeStr);
         } else {
             return localeStr;
         }
     }

     @Override
     public int describeContents() {
         return 0;
     }

     @Override
     public void writeToParcel(Parcel dest, int parcelableFlags) {
         dest.writeInt(mSubtypeNameResId);
         dest.writeString(mSubtypeLocale);
         dest.writeString(mSubtypeExtraValue);
     }

     public static final Parcelable.Creator<SpellCheckerSubtype> CREATOR
             = new Parcelable.Creator<SpellCheckerSubtype>() {
         @Override
         public SpellCheckerSubtype createFromParcel(Parcel source) {
             return new SpellCheckerSubtype(source);
         }

         @Override
         public SpellCheckerSubtype[] newArray(int size) {
             return new SpellCheckerSubtype[size];
         }
     };

     private static int hashCodeInternal(String locale, String extraValue) {
         return Arrays.hashCode(new Object[] {locale, extraValue});
     }

     /**
      * Sort the list of subtypes
      * @param context Context will be used for getting localized strings
      * @param flags Flags for the sort order
      * @param sci SpellCheckerInfo of which subtypes are subject to be sorted
      * @param subtypeList List which will be sorted
      * @return Sorted list of subtypes
      * @hide
      */
     public static List<SpellCheckerSubtype> sort(Context context, int flags, SpellCheckerInfo sci,
             List<SpellCheckerSubtype> subtypeList) {
         if (sci == null) return subtypeList;
         final HashSet<SpellCheckerSubtype> subtypesSet = new HashSet<SpellCheckerSubtype>(
                 subtypeList);
         final ArrayList<SpellCheckerSubtype> sortedList = new ArrayList<SpellCheckerSubtype>();
         int N = sci.getSubtypeCount();
         for (int i = 0; i < N; ++i) {
             SpellCheckerSubtype subtype = sci.getSubtypeAt(i);
             if (subtypesSet.contains(subtype)) {
                 sortedList.add(subtype);
                 subtypesSet.remove(subtype);
             }
         }
         // If subtypes in subtypesSet remain, that means these subtypes are not
         // contained in sci, so the remaining subtypes will be appended.
         for (SpellCheckerSubtype subtype: subtypesSet) {
             sortedList.add(subtype);
         }
         return sortedList;
     }
 }
	/*
	* 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.view.textservice;

	import android.content.Context;
	import android.content.pm.ApplicationInfo;
	import android.os.Parcel;
	import android.os.Parcelable;
	import android.text.TextUtils;
	import android.util.Slog;

	import java.util.ArrayList;
	import java.util.Arrays;
	import java.util.HashMap;
	import java.util.HashSet;
	import java.util.List;
	import java.util.Locale;

	/**
	* This class is used to specify meta information of a subtype contained in a spell checker.
	* Subtype can describe locale (e.g. en_US, fr_FR...) used for settings.
	*/
	public final class SpellCheckerSubtype implements Parcelable {
	private static final String TAG = SpellCheckerSubtype.class.getSimpleName();
	private static final String EXTRA_VALUE_PAIR_SEPARATOR = ",";
	private static final String EXTRA_VALUE_KEY_VALUE_SEPARATOR = "=";

	private final int mSubtypeHashCode;
	private final int mSubtypeNameResId;
	private final String mSubtypeLocale;
	private final String mSubtypeExtraValue;
	private HashMap<String, String> mExtraValueHashMapCache;

	/**
	* Constructor
	* @param nameId The name of the subtype
	* @param locale The locale supported by the subtype
	* @param extraValue The extra value of the subtype
	*/
	public SpellCheckerSubtype(int nameId, String locale, String extraValue) {
	mSubtypeNameResId = nameId;
	mSubtypeLocale = locale != null ? locale : "";
	mSubtypeExtraValue = extraValue != null ? extraValue : "";
	mSubtypeHashCode = hashCodeInternal(mSubtypeLocale, mSubtypeExtraValue);
	}

	SpellCheckerSubtype(Parcel source) {
	String s;
	mSubtypeNameResId = source.readInt();
	s = source.readString();
	mSubtypeLocale = s != null ? s : "";
	s = source.readString();
	mSubtypeExtraValue = s != null ? s : "";
	mSubtypeHashCode = hashCodeInternal(mSubtypeLocale, mSubtypeExtraValue);
	}

	/**
	* @return the name of the subtype
	*/
	public int getNameResId() {
	return mSubtypeNameResId;
	}

	/**
	* @return the locale of the subtype
	*/
	public String getLocale() {
	return mSubtypeLocale;
	}

	/**
	* @return the extra value of the subtype
	*/
	public String getExtraValue() {
	return mSubtypeExtraValue;
	}

	private HashMap<String, String> getExtraValueHashMap() {
	if (mExtraValueHashMapCache == null) {
	mExtraValueHashMapCache = new HashMap<String, String>();
	final String[] pairs = mSubtypeExtraValue.split(EXTRA_VALUE_PAIR_SEPARATOR);
	final int N = pairs.length;
	for (int i = 0; i < N; ++i) {
	final String[] pair = pairs[i].split(EXTRA_VALUE_KEY_VALUE_SEPARATOR);
	if (pair.length == 1) {
	mExtraValueHashMapCache.put(pair[0], null);
	} else if (pair.length > 1) {
	if (pair.length > 2) {
	Slog.w(TAG, "ExtraValue has two or more '='s");
	}
	mExtraValueHashMapCache.put(pair[0], pair[1]);
	}
	}
	}
	return mExtraValueHashMapCache;
	}

	/**
	* The string of ExtraValue in subtype should be defined as follows:
	* example: key0,key1=value1,key2,key3,key4=value4
	* @param key the key of extra value
	* @return the subtype contains specified the extra value
	*/
	public boolean containsExtraValueKey(String key) {
	return getExtraValueHashMap().containsKey(key);
	}

	/**
	* The string of ExtraValue in subtype should be defined as follows:
	* example: key0,key1=value1,key2,key3,key4=value4
	* @param key the key of extra value
	* @return the value of the specified key
	*/
	public String getExtraValueOf(String key) {
	return getExtraValueHashMap().get(key);
	}

	@Override
	public int hashCode() {
	return mSubtypeHashCode;
	}

	@Override
	public boolean equals(Object o) {
	if (o instanceof SpellCheckerSubtype) {
	SpellCheckerSubtype subtype = (SpellCheckerSubtype) o;
	return (subtype.hashCode() == hashCode())
	&& (subtype.getNameResId() == getNameResId())
	&& (subtype.getLocale().equals(getLocale()))
	&& (subtype.getExtraValue().equals(getExtraValue()));
	}
	return false;
	}

	/**
	* @hide
	*/
	public static Locale constructLocaleFromString(String localeStr) {
	if (TextUtils.isEmpty(localeStr))
	return null;
	String[] localeParams = localeStr.split("_", 3);
	// The length of localeStr is guaranteed to always return a 1 <= value <= 3
	// because localeStr is not empty.
	if (localeParams.length == 1) {
	return new Locale(localeParams[0]);
	} else if (localeParams.length == 2) {
	return new Locale(localeParams[0], localeParams[1]);
	} else if (localeParams.length == 3) {
	return new Locale(localeParams[0], localeParams[1], localeParams[2]);
	}
	return null;
	}

	/**
	* @param context Context will be used for getting Locale and PackageManager.
	* @param packageName The package name of the spell checker
	* @param appInfo The application info of the spell checker
	* @return a display name for this subtype. The string resource of the label (mSubtypeNameResId)
	* can have only one %s in it. If there is, the %s part will be replaced with the locale's
	* display name by the formatter. If there is not, this method simply returns the string
	* specified by mSubtypeNameResId. If mSubtypeNameResId is not specified (== 0), it's up to the
	* framework to generate an appropriate display name.
	*/
	public CharSequence getDisplayName(
	Context context, String packageName, ApplicationInfo appInfo) {
	final Locale locale = constructLocaleFromString(mSubtypeLocale);
	final String localeStr = locale != null ? locale.getDisplayName() : mSubtypeLocale;
	if (mSubtypeNameResId == 0) {
	return localeStr;
	}
	final CharSequence subtypeName = context.getPackageManager().getText(
	packageName, mSubtypeNameResId, appInfo);
	if (!TextUtils.isEmpty(subtypeName)) {
	return String.format(subtypeName.toString(), localeStr);
	} else {
	return localeStr;
	}
	}

	@Override
	public int describeContents() {
	return 0;
	}

	@Override
	public void writeToParcel(Parcel dest, int parcelableFlags) {
	dest.writeInt(mSubtypeNameResId);
	dest.writeString(mSubtypeLocale);
	dest.writeString(mSubtypeExtraValue);
	}

	public static final Parcelable.Creator<SpellCheckerSubtype> CREATOR
	= new Parcelable.Creator<SpellCheckerSubtype>() {
	@Override
	public SpellCheckerSubtype createFromParcel(Parcel source) {
	return new SpellCheckerSubtype(source);
	}

	@Override
	public SpellCheckerSubtype[] newArray(int size) {
	return new SpellCheckerSubtype[size];
	}
	};

	private static int hashCodeInternal(String locale, String extraValue) {
	return Arrays.hashCode(new Object[] {locale, extraValue});
	}

	/**
	* Sort the list of subtypes
	* @param context Context will be used for getting localized strings
	* @param flags Flags for the sort order
	* @param sci SpellCheckerInfo of which subtypes are subject to be sorted
	* @param subtypeList List which will be sorted
	* @return Sorted list of subtypes
	* @hide
	*/
	public static List<SpellCheckerSubtype> sort(Context context, int flags, SpellCheckerInfo sci,
	List<SpellCheckerSubtype> subtypeList) {
	if (sci == null) return subtypeList;
	final HashSet<SpellCheckerSubtype> subtypesSet = new HashSet<SpellCheckerSubtype>(
	subtypeList);
	final ArrayList<SpellCheckerSubtype> sortedList = new ArrayList<SpellCheckerSubtype>();
	int N = sci.getSubtypeCount();
	for (int i = 0; i < N; ++i) {
	SpellCheckerSubtype subtype = sci.getSubtypeAt(i);
	if (subtypesSet.contains(subtype)) {
	sortedList.add(subtype);
	subtypesSet.remove(subtype);
	}
	}
	// If subtypes in subtypesSet remain, that means these subtypes are not
	// contained in sci, so the remaining subtypes will be appended.
	for (SpellCheckerSubtype subtype: subtypesSet) {
	sortedList.add(subtype);
	}
	return sortedList;
	}
	}