| // Copyright 2010-2014, Google Inc. |
| // All rights reserved. |
| // |
| // Redistribution and use in source and binary forms, with or without |
| // modification, are permitted provided that the following conditions are |
| // met: |
| // |
| // * Redistributions of source code must retain the above copyright |
| // notice, this list of conditions and the following disclaimer. |
| // * Redistributions in binary form must reproduce the above |
| // copyright notice, this list of conditions and the following disclaimer |
| // in the documentation and/or other materials provided with the |
| // distribution. |
| // * Neither the name of Google Inc. nor the names of its |
| // contributors may be used to endorse or promote products derived from |
| // this software without specific prior written permission. |
| // |
| // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
| // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
| // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
| // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
| // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
| // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
| // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
| // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| |
| package org.mozc.android.inputmethod.japanese.userdictionary; |
| |
| import org.mozc.android.inputmethod.japanese.MozcUtil; |
| import org.mozc.android.inputmethod.japanese.protobuf.ProtoUserDictionaryStorage.UserDictionary.Entry; |
| import org.mozc.android.inputmethod.japanese.protobuf.ProtoUserDictionaryStorage.UserDictionary.PosType; |
| import org.mozc.android.inputmethod.japanese.protobuf.ProtoUserDictionaryStorage.UserDictionaryCommandStatus.Status; |
| import org.mozc.android.inputmethod.japanese.resources.R; |
| import com.google.common.base.Preconditions; |
| |
| import android.app.AlertDialog; |
| import android.app.Dialog; |
| import android.content.Context; |
| import android.content.DialogInterface; |
| import android.content.Intent; |
| import android.content.res.Resources; |
| import android.net.Uri; |
| import android.os.Bundle; |
| import android.os.Message; |
| import android.util.AttributeSet; |
| import android.view.LayoutInflater; |
| import android.view.View; |
| import android.view.WindowManager; |
| import android.view.inputmethod.InputMethodManager; |
| import android.widget.ArrayAdapter; |
| import android.widget.EditText; |
| import android.widget.Spinner; |
| import android.widget.TextView; |
| |
| import java.io.IOException; |
| import java.io.RandomAccessFile; |
| import java.io.UnsupportedEncodingException; |
| import java.nio.ByteBuffer; |
| import java.nio.CharBuffer; |
| import java.nio.channels.FileChannel; |
| import java.nio.channels.FileChannel.MapMode; |
| import java.nio.charset.Charset; |
| import java.nio.charset.CodingErrorAction; |
| import java.util.ArrayList; |
| import java.util.Collections; |
| import java.util.EnumMap; |
| import java.util.List; |
| import java.util.Map; |
| |
| /** |
| * Utilities (of, especially, UI related stuff) for the user dictionary tool. |
| * |
| */ |
| class UserDictionaryUtil { |
| |
| /** |
| * Callback which is called when the "positive button" on a dialog is clicked. |
| */ |
| private interface UserDictionaryBaseDialogListener { |
| public Status onPositiveButtonClicked(View view); |
| } |
| |
| /** |
| * Base implementation of popup dialog on user dictionary tool. |
| * |
| * This class has: |
| * <ul> |
| * <li>Title messaging |
| * <li>Content view based on the given resource id |
| * <li>Cancel and OK buttons |
| * </ul> |
| * |
| * When the OK button is clicked, UserDictionaryBaseDialogListener callback is invoked. |
| * The expected usage is invoke something action by interacting with the mozc server. |
| * If the interaction fails (in more precise, the returned status is not |
| * USER_DICTIONARY_COMMAND_SUCCESS), this class will show a toast message, and the popup dialog |
| * won't be dismissed. |
| */ |
| private static class UserDictionaryBaseDialog extends AlertDialog { |
| private final UserDictionaryBaseDialogListener listener; |
| private final ToastManager toastManager; |
| |
| UserDictionaryBaseDialog(Context context, int titleResourceId, int viewResourceId, |
| UserDictionaryBaseDialogListener listener, |
| ToastManager toastManager) { |
| super(context); |
| this.listener = listener; |
| this.toastManager = toastManager; |
| |
| // Initialize the view. Set the title, the content view and ok, cancel buttons. |
| setTitle(titleResourceId); |
| setView(LayoutInflater.from(context).inflate(viewResourceId, null)); |
| |
| // Set a dummy Message instance to fix crashing issue on Android 2.1. |
| // On Android 2.1, com.android.internal.app.AlertController wrongly checks the message |
| // for the availability of button view. So without the dummy message, |
| // getButton(BUTTON_POSITIVE) used in onCreate would return null. |
| setButton(DialogInterface.BUTTON_POSITIVE, context.getText(android.R.string.ok), |
| Message.obtain()); |
| setButton(DialogInterface.BUTTON_NEGATIVE, context.getText(android.R.string.cancel), |
| DialogInterface.OnClickListener.class.cast(null)); |
| setCancelable(true); |
| } |
| |
| @Override |
| protected void onCreate(Bundle savedInstance) { |
| super.onCreate(savedInstance); |
| |
| // To override the default behavior that the dialog is dismissed after user's clicking |
| // a button regardless of any action inside listener, we set the callback directly |
| // to the button and manage dismissing behavior. |
| // Note that it is necessary to do this here, instead of in the constructor, |
| // because the UI is initialized in super class's onCreate method, and we cannot obtain |
| // the button until the initialization. |
| getButton(DialogInterface.BUTTON_POSITIVE).setOnClickListener(new View.OnClickListener() { |
| @Override |
| public void onClick(View view) { |
| Status status = listener.onPositiveButtonClicked(view); |
| toastManager.maybeShowMessageShortly(status); |
| if (status == Status.USER_DICTIONARY_COMMAND_SUCCESS) { |
| // Dismiss the dialog, iff the operation is successfully done. |
| dismiss(); |
| } |
| } |
| }); |
| } |
| } |
| |
| /** |
| * Simple class to show the internationalized POS names on a spinner. |
| */ |
| private static class PosItem { |
| final PosType posType; |
| final String name; |
| |
| PosItem(PosType posType, String name) { |
| this.posType = posType; |
| this.name = name; |
| } |
| |
| // This is a hook to show the appropriate (internationalized) items on spinner. |
| @Override |
| public String toString() { |
| return name; |
| } |
| } |
| |
| /** |
| * Spinner implementation which has a list of POS. |
| * |
| * To keep users out from confusing UI, this class hides the IME when the list dialog is |
| * shown by user's tap. |
| */ |
| public static class PosSpinner extends Spinner { |
| public PosSpinner(Context context) { |
| super(context); |
| } |
| public PosSpinner(Context context, AttributeSet attrs) { |
| super(context, attrs); |
| } |
| public PosSpinner(Context context, AttributeSet attrs, int defStyle) { |
| super(context, attrs, defStyle); |
| } |
| |
| @Override |
| protected void onFinishInflate() { |
| // Set adapter containing a list of POS types. |
| ArrayAdapter<PosItem> adapter = new ArrayAdapter<PosItem>( |
| getContext(), android.R.layout.simple_spinner_item, createPosItemList(getResources())); |
| adapter.setDropDownViewResource(android.R.layout.simple_spinner_dropdown_item); |
| setAdapter(adapter); |
| } |
| |
| private static List<PosItem> createPosItemList(Resources resources) { |
| PosType[] posTypeValues = PosType.values(); |
| List<PosItem> result = new ArrayList<PosItem>(posTypeValues.length); |
| for (PosType posType : posTypeValues) { |
| result.add(new PosItem(posType, |
| resources.getText(getPosStringResourceId(posType)).toString())); |
| } |
| return result; |
| } |
| |
| @Override |
| public boolean performClick() { |
| // When the spinner is tapped (i.e. when the popup dialog is shown), |
| // we hide the soft input method. |
| // This is because the list of the POS is long so if the soft input is shown |
| // continuously, a part of list would be out of the display. |
| InputMethodManager imm = InputMethodManager.class.cast( |
| getContext().getSystemService(Context.INPUT_METHOD_SERVICE)); |
| imm.hideSoftInputFromWindow(getWindowToken(), 0); |
| |
| return super.performClick(); |
| } |
| } |
| |
| interface WordRegisterDialogListener { |
| |
| /** |
| * Callback to be called when the positive button is clicked. |
| * @return result status of the executed command. |
| */ |
| public Status onPositiveButtonClicked(String word, String reading, PosType pos); |
| } |
| |
| /** |
| * Word Register Dialog implementation for adding/editing entries. |
| * |
| * The dialog should have: |
| * <ul> |
| * <li>A EditText for "word" editing, |
| * <li>A EditText for "reading" editing, and |
| * <li>A Spinner for "pos" selecting. |
| */ |
| static class WordRegisterDialog extends UserDictionaryBaseDialog { |
| WordRegisterDialog(Context context, int titleResourceId, |
| final WordRegisterDialogListener listener, |
| ToastManager toastManager) { |
| super(context, titleResourceId, R.layout.user_dictionary_tool_word_register_dialog_view, |
| new UserDictionaryBaseDialogListener() { |
| @Override |
| public Status onPositiveButtonClicked(View view) { |
| return listener.onPositiveButtonClicked( |
| getText(view, R.id.user_dictionary_tool_word_register_dialog_word), |
| getText(view, R.id.user_dictionary_tool_word_register_dialog_reading), |
| getPos(view, R.id.user_dictionary_tool_word_register_dialog_pos)); |
| } |
| }, toastManager); |
| // TODO(hidehiko): Attach a callback for un-focused event on "word" EditText. |
| // and invoke reverse conversion (if necessary) to fill reading automatically. |
| } |
| |
| /** |
| * Sets the entry so that users can see it when the dialog is shown. |
| * To make editing convenient, select all region. |
| */ |
| void setEntry(Entry entry) { |
| EditText wordEditText = EditText.class.cast( |
| findViewById(R.id.user_dictionary_tool_word_register_dialog_word)); |
| wordEditText.setText(entry.getValue()); |
| EditText.class.cast(findViewById(R.id.user_dictionary_tool_word_register_dialog_reading)) |
| .setText(entry.getKey()); |
| Spinner posSpinner = Spinner.class.cast( |
| findViewById(R.id.user_dictionary_tool_word_register_dialog_pos)); |
| int numItems = posSpinner.getCount(); |
| for (int i = 0; i < numItems; ++i) { |
| if (PosItem.class.cast(posSpinner.getItemAtPosition(i)).posType == entry.getPos()) { |
| posSpinner.setSelection(i); |
| break; |
| } |
| } |
| |
| // Focus "word" field by default. |
| wordEditText.requestFocus(); |
| } |
| } |
| |
| interface DictionaryNameDialogListener { |
| |
| /** |
| * Callback to be called when the positive button is clicked. |
| * @param dictionaryName the text which is filled in EditText on the dialog. |
| * @return result status of the executed command. |
| */ |
| public Status onPositiveButtonClicked(String dictionaryName); |
| } |
| |
| /** |
| * Dialog implementation which has one edit box for dictionary name editing. |
| */ |
| static class DictionaryNameDialog extends UserDictionaryBaseDialog { |
| DictionaryNameDialog(Context context, int titleResourceId, |
| final DictionaryNameDialogListener listener, |
| ToastManager toastManager) { |
| super(context, titleResourceId, R.layout.user_dictionary_tool_dictionary_name_dialog_view, |
| new UserDictionaryBaseDialogListener() { |
| @Override |
| public Status onPositiveButtonClicked(View view) { |
| return listener.onPositiveButtonClicked( |
| getText(view, R.id.user_dictionary_tool_dictionary_name_dialog_name)); |
| } |
| }, toastManager); |
| } |
| |
| /** |
| * Sets the dictionaryName so that users can see it when the dialog is shown. |
| * To make editing convenient, select all region. |
| */ |
| void setDictionaryName(String dictionaryName) { |
| EditText editText = EditText.class.cast( |
| findViewById(R.id.user_dictionary_tool_dictionary_name_dialog_name)); |
| editText.setText(dictionaryName); |
| editText.selectAll(); |
| } |
| } |
| |
| /** A map from PosType to the string resource id for i18n. */ |
| private static final Map<PosType, Integer> POS_RESOURCE_MAP; |
| static { |
| EnumMap<PosType, Integer> map = new EnumMap<PosType, Integer>(PosType.class); |
| map.put(PosType.NOUN, R.string.japanese_pos_noun); |
| map.put(PosType.ABBREVIATION, R.string.japanese_pos_abbreviation); |
| map.put(PosType.SUGGESTION_ONLY, R.string.japanese_pos_suggestion_only); |
| map.put(PosType.PROPER_NOUN, R.string.japanese_pos_proper_noun); |
| map.put(PosType.PERSONAL_NAME, R.string.japanese_pos_personal_name); |
| map.put(PosType.FAMILY_NAME, R.string.japanese_pos_family_name); |
| map.put(PosType.FIRST_NAME, R.string.japanese_pos_first_name); |
| map.put(PosType.ORGANIZATION_NAME, R.string.japanese_pos_organization_name); |
| map.put(PosType.PLACE_NAME, R.string.japanese_pos_place_name); |
| map.put(PosType.SA_IRREGULAR_CONJUGATION_NOUN, |
| R.string.japanese_pos_sa_irregular_conjugation_noun); |
| map.put(PosType.ADJECTIVE_VERBAL_NOUN, R.string.japanese_pos_adjective_verbal_noun); |
| map.put(PosType.NUMBER, R.string.japanese_pos_number); |
| map.put(PosType.ALPHABET, R.string.japanese_pos_alphabet); |
| map.put(PosType.SYMBOL, R.string.japanese_pos_symbol); |
| map.put(PosType.EMOTICON, R.string.japanese_pos_emoticon); |
| map.put(PosType.ADVERB, R.string.japanese_pos_adverb); |
| map.put(PosType.PRENOUN_ADJECTIVAL, R.string.japanese_pos_prenoun_adjectival); |
| map.put(PosType.CONJUNCTION, R.string.japanese_pos_conjunction); |
| map.put(PosType.INTERJECTION, R.string.japanese_pos_interjection); |
| map.put(PosType.PREFIX, R.string.japanese_pos_prefix); |
| map.put(PosType.COUNTER_SUFFIX, R.string.japanese_pos_counter_suffix); |
| map.put(PosType.GENERIC_SUFFIX, R.string.japanese_pos_generic_suffix); |
| map.put(PosType.PERSON_NAME_SUFFIX, R.string.japanese_pos_person_name_suffix); |
| map.put(PosType.PLACE_NAME_SUFFIX, R.string.japanese_pos_place_name_suffix); |
| map.put(PosType.WA_GROUP1_VERB, R.string.japanese_pos_wa_group1_verb); |
| map.put(PosType.KA_GROUP1_VERB, R.string.japanese_pos_ka_group1_verb); |
| map.put(PosType.SA_GROUP1_VERB, R.string.japanese_pos_sa_group1_verb); |
| map.put(PosType.TA_GROUP1_VERB, R.string.japanese_pos_ta_group1_verb); |
| map.put(PosType.NA_GROUP1_VERB, R.string.japanese_pos_na_group1_verb); |
| map.put(PosType.MA_GROUP1_VERB, R.string.japanese_pos_ma_group1_verb); |
| map.put(PosType.RA_GROUP1_VERB, R.string.japanese_pos_ra_group1_verb); |
| map.put(PosType.GA_GROUP1_VERB, R.string.japanese_pos_ga_group1_verb); |
| map.put(PosType.BA_GROUP1_VERB, R.string.japanese_pos_ba_group1_verb); |
| map.put(PosType.HA_GROUP1_VERB, R.string.japanese_pos_ha_group1_verb); |
| map.put(PosType.GROUP2_VERB, R.string.japanese_pos_group2_verb); |
| map.put(PosType.KURU_GROUP3_VERB, R.string.japanese_pos_kuru_group3_verb); |
| map.put(PosType.SURU_GROUP3_VERB, R.string.japanese_pos_suru_group3_verb); |
| map.put(PosType.ZURU_GROUP3_VERB, R.string.japanese_pos_zuru_group3_verb); |
| map.put(PosType.RU_GROUP3_VERB, R.string.japanese_pos_ru_group3_verb); |
| map.put(PosType.ADJECTIVE, R.string.japanese_pos_adjective); |
| map.put(PosType.SENTENCE_ENDING_PARTICLE, R.string.japanese_pos_sentence_ending_particle); |
| map.put(PosType.PUNCTUATION, R.string.japanese_pos_punctuation); |
| map.put(PosType.FREE_STANDING_WORD, R.string.japanese_pos_free_standing_word); |
| map.put(PosType.SUPPRESSION_WORD, R.string.japanese_pos_suppression_word); |
| |
| if (map.size() != PosType.values().length) { |
| // There seems something unknown POS. |
| throw new AssertionError(); |
| } |
| POS_RESOURCE_MAP = Collections.unmodifiableMap(map); |
| } |
| |
| /** A map from PosType to the string resource id dictionary export. */ |
| private static final Map<PosType, Integer> POS_RESOURCE_MAP_FOR_DICTIONARY_EXPORT; |
| static { |
| EnumMap<PosType, Integer> map = new EnumMap<PosType, Integer>(PosType.class); |
| map.put(PosType.NOUN, R.string.japanese_pos_for_dictionary_export_noun); |
| map.put(PosType.ABBREVIATION, R.string.japanese_pos_for_dictionary_export_abbreviation); |
| map.put(PosType.SUGGESTION_ONLY, R.string.japanese_pos_for_dictionary_export_suggestion_only); |
| map.put(PosType.PROPER_NOUN, R.string.japanese_pos_for_dictionary_export_proper_noun); |
| map.put(PosType.PERSONAL_NAME, R.string.japanese_pos_for_dictionary_export_personal_name); |
| map.put(PosType.FAMILY_NAME, R.string.japanese_pos_for_dictionary_export_family_name); |
| map.put(PosType.FIRST_NAME, R.string.japanese_pos_for_dictionary_export_first_name); |
| map.put(PosType.ORGANIZATION_NAME, |
| R.string.japanese_pos_for_dictionary_export_organization_name); |
| map.put(PosType.PLACE_NAME, R.string.japanese_pos_for_dictionary_export_place_name); |
| map.put(PosType.SA_IRREGULAR_CONJUGATION_NOUN, |
| R.string.japanese_pos_for_dictionary_export_sa_irregular_conjugation_noun); |
| map.put(PosType.ADJECTIVE_VERBAL_NOUN, |
| R.string.japanese_pos_for_dictionary_export_adjective_verbal_noun); |
| map.put(PosType.NUMBER, R.string.japanese_pos_for_dictionary_export_number); |
| map.put(PosType.ALPHABET, R.string.japanese_pos_for_dictionary_export_alphabet); |
| map.put(PosType.SYMBOL, R.string.japanese_pos_for_dictionary_export_symbol); |
| map.put(PosType.EMOTICON, R.string.japanese_pos_for_dictionary_export_emoticon); |
| map.put(PosType.ADVERB, R.string.japanese_pos_for_dictionary_export_adverb); |
| map.put(PosType.PRENOUN_ADJECTIVAL, |
| R.string.japanese_pos_for_dictionary_export_prenoun_adjectival); |
| map.put(PosType.CONJUNCTION, R.string.japanese_pos_for_dictionary_export_conjunction); |
| map.put(PosType.INTERJECTION, R.string.japanese_pos_for_dictionary_export_interjection); |
| map.put(PosType.PREFIX, R.string.japanese_pos_for_dictionary_export_prefix); |
| map.put(PosType.COUNTER_SUFFIX, R.string.japanese_pos_for_dictionary_export_counter_suffix); |
| map.put(PosType.GENERIC_SUFFIX, R.string.japanese_pos_for_dictionary_export_generic_suffix); |
| map.put(PosType.PERSON_NAME_SUFFIX, |
| R.string.japanese_pos_for_dictionary_export_person_name_suffix); |
| map.put(PosType.PLACE_NAME_SUFFIX, |
| R.string.japanese_pos_for_dictionary_export_place_name_suffix); |
| map.put(PosType.WA_GROUP1_VERB, R.string.japanese_pos_for_dictionary_export_wa_group1_verb); |
| map.put(PosType.KA_GROUP1_VERB, R.string.japanese_pos_for_dictionary_export_ka_group1_verb); |
| map.put(PosType.SA_GROUP1_VERB, R.string.japanese_pos_for_dictionary_export_sa_group1_verb); |
| map.put(PosType.TA_GROUP1_VERB, R.string.japanese_pos_for_dictionary_export_ta_group1_verb); |
| map.put(PosType.NA_GROUP1_VERB, R.string.japanese_pos_for_dictionary_export_na_group1_verb); |
| map.put(PosType.MA_GROUP1_VERB, R.string.japanese_pos_for_dictionary_export_ma_group1_verb); |
| map.put(PosType.RA_GROUP1_VERB, R.string.japanese_pos_for_dictionary_export_ra_group1_verb); |
| map.put(PosType.GA_GROUP1_VERB, R.string.japanese_pos_for_dictionary_export_ga_group1_verb); |
| map.put(PosType.BA_GROUP1_VERB, R.string.japanese_pos_for_dictionary_export_ba_group1_verb); |
| map.put(PosType.HA_GROUP1_VERB, R.string.japanese_pos_for_dictionary_export_ha_group1_verb); |
| map.put(PosType.GROUP2_VERB, R.string.japanese_pos_for_dictionary_export_group2_verb); |
| map.put(PosType.KURU_GROUP3_VERB, R.string.japanese_pos_for_dictionary_export_kuru_group3_verb); |
| map.put(PosType.SURU_GROUP3_VERB, R.string.japanese_pos_for_dictionary_export_suru_group3_verb); |
| map.put(PosType.ZURU_GROUP3_VERB, R.string.japanese_pos_for_dictionary_export_zuru_group3_verb); |
| map.put(PosType.RU_GROUP3_VERB, R.string.japanese_pos_for_dictionary_export_ru_group3_verb); |
| map.put(PosType.ADJECTIVE, |
| R.string.japanese_pos_for_dictionary_export_adjective); |
| map.put(PosType.SENTENCE_ENDING_PARTICLE, |
| R.string.japanese_pos_for_dictionary_export_sentence_ending_particle); |
| map.put(PosType.PUNCTUATION, R.string.japanese_pos_for_dictionary_export_punctuation); |
| map.put(PosType.FREE_STANDING_WORD, |
| R.string.japanese_pos_for_dictionary_export_free_standing_word); |
| map.put(PosType.SUPPRESSION_WORD, R.string.japanese_pos_for_dictionary_export_suppression_word); |
| |
| if (map.size() != PosType.values().length) { |
| // There seems something unknown POS. |
| throw new AssertionError(); |
| } |
| POS_RESOURCE_MAP_FOR_DICTIONARY_EXPORT = Collections.unmodifiableMap(map); |
| } |
| |
| /** |
| * List of Japanese encodings to convert text for data importing. |
| * These encodings are tries in the order, in other words, UTF-8 is the most high-prioritized |
| * encoding. |
| */ |
| private static final String[] JAPANESE_ENCODING_LIST = { |
| "UTF-8", "EUC-JP", "ISO-2022-JP", "Shift_JIS", "UTF-16", |
| }; |
| |
| private UserDictionaryUtil() { |
| } |
| |
| /** |
| * Returns the text content of the view with the given resourceId. |
| */ |
| private static String getText(View view, int resourceId) { |
| view = view.getRootView(); |
| TextView textView = TextView.class.cast(view.findViewById(resourceId)); |
| return textView.getText().toString(); |
| } |
| |
| /** |
| * Returns the PosType of the view with the given resourceId. |
| */ |
| private static PosType getPos(View view, int resourceId) { |
| view = view.getRootView(); |
| Spinner spinner = Spinner.class.cast(view.findViewById(resourceId)); |
| return PosItem.class.cast(spinner.getSelectedItem()).posType; |
| } |
| |
| /** |
| * Returns string resource id for the given {@code pos}. |
| */ |
| static int getPosStringResourceId(PosType pos) { |
| return POS_RESOURCE_MAP.get(Preconditions.checkNotNull(pos)); |
| } |
| |
| /** |
| * Returns string resource id for the given {@code pos} for dictionary export. |
| */ |
| static int getPosStringResourceIdForDictionaryExport(PosType pos) { |
| return POS_RESOURCE_MAP_FOR_DICTIONARY_EXPORT.get(Preconditions.checkNotNull(pos)); |
| } |
| |
| /** |
| * Returns the instance for Word Register Dialog. |
| */ |
| static WordRegisterDialog createWordRegisterDialog( |
| Context context, int titleResourceId, WordRegisterDialogListener listener, |
| ToastManager toastManager) { |
| return new WordRegisterDialog(context, titleResourceId, listener, toastManager); |
| } |
| |
| /** |
| * Returns a new instance for Dictionary Name Dialog. |
| */ |
| static DictionaryNameDialog createDictionaryNameDialog( |
| Context context, int titleResourceId, DictionaryNameDialogListener listener, |
| ToastManager toastManager) { |
| return new DictionaryNameDialog(context, titleResourceId, listener, toastManager); |
| } |
| |
| /** |
| * Returns a new instance for a dialog to select a file in a zipfile. |
| */ |
| static Dialog createZipFileSelectionDialog( |
| Context context, int titleResourceId, |
| DialogInterface.OnClickListener positiveButtonListener, |
| DialogInterface.OnClickListener negativeButtonListener, |
| DialogInterface.OnCancelListener cancelListener) { |
| return createSimpleSpinnerDialog( |
| context, titleResourceId, positiveButtonListener, negativeButtonListener, |
| cancelListener); |
| } |
| |
| /** |
| * Returns a new instance for a dialog to select import destination. |
| */ |
| static Dialog createImportDictionarySelectionDialog( |
| Context context, int titleResourceId, |
| DialogInterface.OnClickListener positiveButtonListener, |
| DialogInterface.OnClickListener negativeButtonListener, |
| DialogInterface.OnCancelListener cancelListener) { |
| return createSimpleSpinnerDialog( |
| context, titleResourceId, positiveButtonListener, negativeButtonListener, cancelListener); |
| } |
| |
| private static Dialog createSimpleSpinnerDialog( |
| Context context, int titleResourceId, |
| DialogInterface.OnClickListener positiveButtonListener, |
| DialogInterface.OnClickListener negativeButtonListener, |
| DialogInterface.OnCancelListener cancelListener) { |
| View view = LayoutInflater.from(context).inflate( |
| R.layout.user_dictionary_tool_simple_spinner_dialog_view, null); |
| AlertDialog dialog = new AlertDialog.Builder(context) |
| .setTitle(titleResourceId) |
| .setView(view) |
| .setPositiveButton(android.R.string.ok, positiveButtonListener) |
| .setNegativeButton(android.R.string.cancel, negativeButtonListener) |
| .setOnCancelListener(cancelListener) |
| .setCancelable(true) |
| .create(); |
| return dialog; |
| } |
| |
| /** |
| * Sets the parameter to show IME when the given dialog is shown. |
| */ |
| static void showInputMethod(Dialog dialog) { |
| dialog.getWindow().setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_STATE_VISIBLE); |
| } |
| |
| /** |
| * Returns the {@code String} instance with detecting the Japanese encoding. |
| * @throws UnsupportedEncodingException if it fails to detect the encoding. |
| */ |
| static String toStringWithEncodingDetection(ByteBuffer buffer) |
| throws UnsupportedEncodingException { |
| for (String encoding : JAPANESE_ENCODING_LIST) { |
| buffer.position(0); |
| try { |
| Charset charset = Charset.forName(encoding); |
| CharBuffer result = charset.newDecoder() |
| .onMalformedInput(CodingErrorAction.REPORT) |
| .onUnmappableCharacter(CodingErrorAction.REPORT) |
| .decode(buffer); |
| String str = result.toString(); |
| if (str.length() > 0 && str.charAt(0) == 0xFEFF) { |
| // Remove leading BOM if necessary. |
| str = str.substring(1); |
| } |
| return str; |
| } catch (Exception e) { |
| // Ignore exceptions, and retry next encoding. |
| } |
| } |
| |
| throw new UnsupportedEncodingException("Failed to detect encoding"); |
| } |
| |
| /** |
| * Reads the text file with detecting the file encoding. |
| */ |
| static String readFromFile(String path) throws IOException { |
| RandomAccessFile file = new RandomAccessFile(path, "r"); |
| boolean succeeded = false; |
| try { |
| String result = readFromFileInternal(file); |
| succeeded = true; |
| return result; |
| } finally { |
| MozcUtil.close(file, !succeeded); |
| } |
| } |
| |
| private static String readFromFileInternal(RandomAccessFile file) throws IOException { |
| FileChannel channel = file.getChannel(); |
| boolean succeeded = false; |
| try { |
| String result = toStringWithEncodingDetection( |
| channel.map(MapMode.READ_ONLY, 0, channel.size())); |
| succeeded = true; |
| return result; |
| } finally { |
| MozcUtil.close(channel, !succeeded); |
| } |
| } |
| |
| /** |
| * Returns import source uri based on the Intent. |
| */ |
| static Uri getImportUri(Intent intent) { |
| String action = intent.getAction(); |
| if (Intent.ACTION_SEND.equals(action)) { |
| return intent.getParcelableExtra(Intent.EXTRA_STREAM); |
| } |
| if (Intent.ACTION_VIEW.equals(action)) { |
| return intent.getData(); |
| } |
| return null; |
| } |
| |
| /** |
| * Returns a name for a new dictionary based on import URI. |
| */ |
| static String generateDictionaryNameByUri(Uri importUri, List<String> dictionaryNameList) { |
| String name = importUri.getLastPathSegment(); |
| |
| // Strip extension |
| { |
| int index = name.lastIndexOf('.'); |
| if (index > 0) { |
| // Keep file path beginning with '.'. |
| name = name.substring(0, index); |
| } |
| } |
| |
| if (!dictionaryNameList.contains(name)) { |
| // No-dupped dictionary name. |
| return name; |
| } |
| |
| // The names extracted from uri is dupped. So look for alternative names by adding |
| // number suffix, such as "pathname (1)". |
| int suffix = 1; |
| while (true) { |
| String candidate = name + " (" + suffix + ")"; |
| if (!dictionaryNameList.contains(candidate)) { |
| return candidate; |
| } |
| // The limit of the number of dictionaries is much smaller than Integer.MAX_VALUE, |
| // so this while loop should stop eventually. |
| ++suffix; |
| } |
| } |
| } |
