diff options
Diffstat (limited to 'java/src/com/android/inputmethod/latin/utils')
5 files changed, 211 insertions, 51 deletions
diff --git a/java/src/com/android/inputmethod/latin/utils/AutoCorrectionUtils.java b/java/src/com/android/inputmethod/latin/utils/AutoCorrectionUtils.java index 2fd257922..c9ecade91 100644 --- a/java/src/com/android/inputmethod/latin/utils/AutoCorrectionUtils.java +++ b/java/src/com/android/inputmethod/latin/utils/AutoCorrectionUtils.java @@ -36,6 +36,10 @@ public final class AutoCorrectionUtils { if (suggestion.isKindOf(SuggestedWordInfo.KIND_WHITELIST)) { return true; } + // TODO: return suggestion.isAprapreateForAutoCorrection(); + if (!suggestion.isAprapreateForAutoCorrection()) { + return false; + } final int autoCorrectionSuggestionScore = suggestion.mScore; // TODO: when the normalized score of the first suggestion is nearly equals to // the normalized score of the second suggestion, behave less aggressive. diff --git a/java/src/com/android/inputmethod/latin/utils/DistracterFilterCheckingExactMatchesAndSuggestions.java b/java/src/com/android/inputmethod/latin/utils/DistracterFilterCheckingExactMatchesAndSuggestions.java index 0c01a737c..9c6a94810 100644 --- a/java/src/com/android/inputmethod/latin/utils/DistracterFilterCheckingExactMatchesAndSuggestions.java +++ b/java/src/com/android/inputmethod/latin/utils/DistracterFilterCheckingExactMatchesAndSuggestions.java @@ -143,7 +143,7 @@ public class DistracterFilterCheckingExactMatchesAndSuggestions implements Distr final KeyboardLayoutSet.Builder builder = new KeyboardLayoutSet.Builder( mContext, editorInfo); final Resources res = mContext.getResources(); - final int keyboardWidth = ResourceUtils.getKeyboardFrameWidth(res); + final int keyboardWidth = ResourceUtils.getDefaultKeyboardWidth(res); final int keyboardHeight = ResourceUtils.getDefaultKeyboardHeight(res); builder.setKeyboardGeometry(keyboardWidth, keyboardHeight); builder.setSubtype(new RichInputMethodSubtype(subtype)); diff --git a/java/src/com/android/inputmethod/latin/utils/LanguageOnSpacebarUtils.java b/java/src/com/android/inputmethod/latin/utils/LanguageOnSpacebarUtils.java new file mode 100644 index 000000000..fa1583b7a --- /dev/null +++ b/java/src/com/android/inputmethod/latin/utils/LanguageOnSpacebarUtils.java @@ -0,0 +1,100 @@ +/* + * 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 com.android.inputmethod.latin.utils; + +import android.view.inputmethod.InputMethodSubtype; + +import com.android.inputmethod.latin.RichInputMethodSubtype; + +import java.util.Collections; +import java.util.List; +import java.util.Locale; + +import javax.annotation.Nonnull; + +/** + * This class determines that the language name on the spacebar should be displayed in what format. + */ +public final class LanguageOnSpacebarUtils { + public static final int FORMAT_TYPE_NONE = 0; + public static final int FORMAT_TYPE_LANGUAGE_ONLY = 1; + public static final int FORMAT_TYPE_FULL_LOCALE = 2; + public static final int FORMAT_TYPE_MULTIPLE = 3; + + private static List<InputMethodSubtype> sEnabledSubtypes = Collections.emptyList(); + private static boolean sIsSystemLanguageSameAsInputLanguage; + + private LanguageOnSpacebarUtils() { + // This utility class is not publicly instantiable. + } + + public static int getLanguageOnSpacebarFormatType( + @Nonnull final RichInputMethodSubtype subtype) { + if (subtype.isNoLanguage()) { + return FORMAT_TYPE_FULL_LOCALE; + } + // Only this subtype is enabled and equals to the system locale. + if (sEnabledSubtypes.size() < 2 && sIsSystemLanguageSameAsInputLanguage) { + return FORMAT_TYPE_NONE; + } + final Locale[] locales = subtype.getLocales(); + if (1 < locales.length) { + return FORMAT_TYPE_MULTIPLE; + } + final String keyboardLanguage = locales[0].getLanguage(); + final String keyboardLayout = subtype.getKeyboardLayoutSetName(); + int sameLanguageAndLayoutCount = 0; + for (final InputMethodSubtype ims : sEnabledSubtypes) { + final String language = SubtypeLocaleUtils.getSubtypeLocale(ims).getLanguage(); + if (keyboardLanguage.equals(language) && keyboardLayout.equals( + SubtypeLocaleUtils.getKeyboardLayoutSetName(ims))) { + sameLanguageAndLayoutCount++; + } + } + // Display full locale name only when there are multiple subtypes that have the same + // locale and keyboard layout. Otherwise displaying language name is enough. + return sameLanguageAndLayoutCount > 1 ? FORMAT_TYPE_FULL_LOCALE + : FORMAT_TYPE_LANGUAGE_ONLY; + } + + public static void setEnabledSubtypes(@Nonnull final List<InputMethodSubtype> enabledSubtypes) { + sEnabledSubtypes = enabledSubtypes; + } + + public static void onSubtypeChanged(@Nonnull final RichInputMethodSubtype subtype, + final boolean implicitlyEnabledSubtype, @Nonnull final Locale systemLocale) { + final Locale[] newLocales = subtype.getLocales(); + if (newLocales.length > 1) { + // In multi-locales mode, the system language is never the same as the input language + // because there is no single input language. + sIsSystemLanguageSameAsInputLanguage = false; + return; + } + final Locale newLocale = newLocales[0]; + if (systemLocale.equals(newLocale)) { + sIsSystemLanguageSameAsInputLanguage = true; + return; + } + if (!systemLocale.getLanguage().equals(newLocale.getLanguage())) { + sIsSystemLanguageSameAsInputLanguage = false; + return; + } + // If the subtype is enabled explicitly, the language name should be displayed even when + // the keyboard language and the system language are equal. + sIsSystemLanguageSameAsInputLanguage = implicitlyEnabledSubtype; + } +} diff --git a/java/src/com/android/inputmethod/latin/utils/NetworkConnectivityUtils.java b/java/src/com/android/inputmethod/latin/utils/NetworkConnectivityUtils.java new file mode 100644 index 000000000..101c55067 --- /dev/null +++ b/java/src/com/android/inputmethod/latin/utils/NetworkConnectivityUtils.java @@ -0,0 +1,101 @@ +/* + * 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 com.android.inputmethod.latin.utils; + +import android.content.BroadcastReceiver; +import android.content.Context; +import android.content.Intent; +import android.content.IntentFilter; +import android.net.ConnectivityManager; +import android.net.NetworkInfo; + +import javax.annotation.Nonnull; + +/** + * This class keeps track of the network connectivity state by receiving the system intent + * {@link ConnectivityManager#CONNECTIVITY_ACTION}, and invokes an registered call back to notify + * changes of the network connectivity state. + */ +public final class NetworkConnectivityUtils { + private static NetworkConnectivityReceiver sNetworkConnectivityReceiver; + + public interface NetworkStateChangeListener { + /** + * Called when the network connectivity state has changed. + */ + public void onNetworkStateChanged(); + } + + private static class NetworkConnectivityReceiver extends BroadcastReceiver { + @Nonnull + private final NetworkStateChangeListener mListener; + private boolean mIsNetworkConnected; + + public NetworkConnectivityReceiver(@Nonnull final NetworkStateChangeListener listener, + final boolean isNetworkConnected) { + mListener = listener; + mIsNetworkConnected = isNetworkConnected; + } + + public synchronized boolean isNetworkConnected() { + return mIsNetworkConnected; + } + + @Override + public void onReceive(final Context context, final Intent intent) { + final String action = intent.getAction(); + if (action.equals(ConnectivityManager.CONNECTIVITY_ACTION)) { + final boolean noConnection = intent.getBooleanExtra( + ConnectivityManager.EXTRA_NO_CONNECTIVITY, false); + synchronized (this) { + mIsNetworkConnected = !noConnection; + } + mListener.onNetworkStateChanged(); + } + } + } + + private NetworkConnectivityUtils() { + // This utility class is not publicly instantiable. + } + + public static void onCreate(@Nonnull final Context context, + @Nonnull final NetworkStateChangeListener listener) { + final ConnectivityManager connectivityManager = + (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE); + final NetworkInfo info = connectivityManager.getActiveNetworkInfo(); + final boolean isNetworkConnected = (info != null && info.isConnected()); + + // Register {@link BroadcastReceiver} for the network connectivity state change. + final NetworkConnectivityReceiver receiver = new NetworkConnectivityReceiver( + listener, isNetworkConnected); + final IntentFilter filter = new IntentFilter(); + filter.addAction(ConnectivityManager.CONNECTIVITY_ACTION); + context.registerReceiver(receiver, filter); + + sNetworkConnectivityReceiver = receiver; + } + + public static void onDestroy(final Context context) { + context.unregisterReceiver(sNetworkConnectivityReceiver); + } + + public static boolean isNetworkConnected() { + final NetworkConnectivityReceiver receiver = sNetworkConnectivityReceiver; + return receiver != null && receiver.isNetworkConnected(); + } +} diff --git a/java/src/com/android/inputmethod/latin/utils/ResourceUtils.java b/java/src/com/android/inputmethod/latin/utils/ResourceUtils.java index 0a757877a..cc0d470df 100644 --- a/java/src/com/android/inputmethod/latin/utils/ResourceUtils.java +++ b/java/src/com/android/inputmethod/latin/utils/ResourceUtils.java @@ -182,63 +182,18 @@ public final class ResourceUtils { return matchedAll; } - public static int getKeyboardFrameWidth(final Resources res) { + public static int getDefaultKeyboardWidth(final Resources res) { final DisplayMetrics dm = res.getDisplayMetrics(); return dm.widthPixels; } - public static int getKeyboardWidth(final Resources res, final SettingsValues settingsValues) { - final int frameWidth = getKeyboardFrameWidth(res); - if (settingsValues.mHasKeyboardResize) { - final float widthFraction = 1f - settingsValues.mKeyboardLeftMarginScale - - settingsValues.mKeyboardRightMarginScale; - return (int)(frameWidth * widthFraction); - } - return frameWidth; - } - - public static int getKeyboardFrameHeight(final Resources res, - final SettingsValues settingsValues) { - if (settingsValues.mHasKeyboardResize) { - return getKeyboardHeight(res, settingsValues) - + getKeyboardBottomMargin(res, settingsValues); - } - return getDefaultKeyboardHeight(res); - } - public static int getKeyboardHeight(final Resources res, final SettingsValues settingsValues) { - final int keyboardHeight = getDefaultKeyboardHeight(res); - if (settingsValues.mHasKeyboardResize) { - return (int)(keyboardHeight * settingsValues.mKeyboardHeightScale); - } - return keyboardHeight; - } - - public static int getKeyboardLeftMargin( - final Resources res, final SettingsValues settingsValues) { - if (settingsValues.mHasKeyboardResize) { - final int frameWidth = getKeyboardFrameWidth(res); - return (int)(frameWidth * settingsValues.mKeyboardLeftMarginScale); - } - return 0; - } - - public static int getKeyboardRightMargin( - final Resources res, final SettingsValues settingsValues) { - if (settingsValues.mHasKeyboardResize) { - final int frameWidth = getKeyboardFrameWidth(res); - return (int)(frameWidth * settingsValues.mKeyboardRightMarginScale); - } - return 0; - } - - public static int getKeyboardBottomMargin( - final Resources res, final SettingsValues settingsValues) { + final int defaultKeyboardHeight = getDefaultKeyboardHeight(res); if (settingsValues.mHasKeyboardResize) { - final int defaultHeight = getDefaultKeyboardHeight(res); - return (int)(defaultHeight * settingsValues.mKeyboardBottomMarginScale); + // mKeyboardHeightScale Ranges from [.5,1.2], from xml/prefs_screen_debug.xml + return (int)(defaultKeyboardHeight * settingsValues.mKeyboardHeightScale); } - return 0; + return defaultKeyboardHeight; } public static int getDefaultKeyboardHeight(final Resources res) { |