| // 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; |
| |
| import org.mozc.android.inputmethod.japanese.FeedbackManager.FeedbackEvent; |
| import org.mozc.android.inputmethod.japanese.FeedbackManager.FeedbackListener; |
| import org.mozc.android.inputmethod.japanese.KeycodeConverter.KeyEventInterface; |
| import org.mozc.android.inputmethod.japanese.emoji.EmojiProviderType; |
| import org.mozc.android.inputmethod.japanese.emoji.EmojiUtil; |
| import org.mozc.android.inputmethod.japanese.hardwarekeyboard.HardwareKeyboard.CompositionSwitchMode; |
| import org.mozc.android.inputmethod.japanese.hardwarekeyboard.HardwareKeyboardSpecification; |
| import org.mozc.android.inputmethod.japanese.keyboard.Keyboard.KeyboardSpecification; |
| import org.mozc.android.inputmethod.japanese.model.SelectionTracker; |
| import org.mozc.android.inputmethod.japanese.model.SymbolCandidateStorage.SymbolHistoryStorage; |
| import org.mozc.android.inputmethod.japanese.model.SymbolMajorCategory; |
| import org.mozc.android.inputmethod.japanese.mushroom.MushroomResultProxy; |
| import org.mozc.android.inputmethod.japanese.preference.ClientSidePreference; |
| import org.mozc.android.inputmethod.japanese.preference.PreferenceUtil; |
| import org.mozc.android.inputmethod.japanese.protobuf.ProtoCandidates; |
| import org.mozc.android.inputmethod.japanese.protobuf.ProtoCommands; |
| import org.mozc.android.inputmethod.japanese.protobuf.ProtoCommands.Command; |
| import org.mozc.android.inputmethod.japanese.protobuf.ProtoCommands.Context.InputFieldType; |
| import org.mozc.android.inputmethod.japanese.protobuf.ProtoCommands.DeletionRange; |
| import org.mozc.android.inputmethod.japanese.protobuf.ProtoCommands.GenericStorageEntry.StorageType; |
| import org.mozc.android.inputmethod.japanese.protobuf.ProtoCommands.Input; |
| import org.mozc.android.inputmethod.japanese.protobuf.ProtoCommands.Input.TouchEvent; |
| import org.mozc.android.inputmethod.japanese.protobuf.ProtoCommands.Output; |
| import org.mozc.android.inputmethod.japanese.protobuf.ProtoCommands.Preedit; |
| import org.mozc.android.inputmethod.japanese.protobuf.ProtoCommands.Preedit.Segment; |
| import org.mozc.android.inputmethod.japanese.protobuf.ProtoCommands.Preedit.Segment.Annotation; |
| import org.mozc.android.inputmethod.japanese.protobuf.ProtoCommands.SessionCommand; |
| import org.mozc.android.inputmethod.japanese.protobuf.ProtoCommands.SessionCommand.UsageStatsEvent; |
| import org.mozc.android.inputmethod.japanese.protobuf.ProtoConfig.Config; |
| import org.mozc.android.inputmethod.japanese.protobuf.ProtoConfig.Config.SelectionShortcut; |
| import org.mozc.android.inputmethod.japanese.protobuf.ProtoConfig.Config.SessionKeymap; |
| import org.mozc.android.inputmethod.japanese.resources.R; |
| import org.mozc.android.inputmethod.japanese.session.SessionExecutor; |
| import org.mozc.android.inputmethod.japanese.session.SessionHandlerFactory; |
| import org.mozc.android.inputmethod.japanese.util.ImeSwitcherFactory; |
| import org.mozc.android.inputmethod.japanese.util.ImeSwitcherFactory.ImeSwitcher; |
| import org.mozc.android.inputmethod.japanese.util.LauncherIconManagerFactory; |
| import com.google.common.annotations.VisibleForTesting; |
| import com.google.common.base.Optional; |
| import com.google.common.base.Preconditions; |
| import com.google.protobuf.ByteString; |
| |
| import android.annotation.SuppressLint; |
| import android.annotation.TargetApi; |
| import android.content.Context; |
| import android.content.Intent; |
| import android.content.SharedPreferences; |
| import android.content.SharedPreferences.OnSharedPreferenceChangeListener; |
| import android.content.res.Configuration; |
| import android.inputmethodservice.InputMethodService; |
| import android.media.AudioManager; |
| import android.os.Build; |
| import android.os.Handler; |
| import android.os.Message; |
| import android.os.Vibrator; |
| import android.preference.PreferenceManager; |
| import android.text.InputType; |
| import android.text.SpannableStringBuilder; |
| import android.text.Spanned; |
| import android.text.style.BackgroundColorSpan; |
| import android.text.style.CharacterStyle; |
| import android.text.style.UnderlineSpan; |
| import android.util.Log; |
| import android.view.KeyEvent; |
| import android.view.MotionEvent; |
| import android.view.View; |
| import android.view.inputmethod.CursorAnchorInfo; |
| import android.view.inputmethod.EditorInfo; |
| import android.view.inputmethod.InputBinding; |
| import android.view.inputmethod.InputConnection; |
| |
| import java.util.ArrayList; |
| import java.util.Collections; |
| import java.util.EnumMap; |
| import java.util.List; |
| import java.util.Map; |
| |
| import javax.annotation.Nullable; |
| |
| |
| /** |
| * The input method service. |
| * |
| */ |
| public class MozcService extends InputMethodService { |
| |
| /** |
| * InputMethod implementation for MozcService. |
| * This injects the composing text tracking feature by wrapping InputConnection. |
| */ |
| public class MozcInputMethod extends InputMethodService.InputMethodImpl { |
| @Override |
| public void bindInput(InputBinding binding) { |
| binding = new InputBinding( |
| ComposingTextTrackingInputConnection.newInstance(binding.getConnection()), |
| binding.getConnectionToken(), |
| binding.getUid(), |
| binding.getPid()); |
| super.bindInput(binding); |
| } |
| |
| @Override |
| public void startInput(InputConnection inputConnection, EditorInfo attribute) { |
| super.startInput( |
| ComposingTextTrackingInputConnection.newInstance(inputConnection), attribute); |
| } |
| |
| @Override |
| public void restartInput(InputConnection inputConnection, EditorInfo attribute) { |
| super.restartInput( |
| ComposingTextTrackingInputConnection.newInstance(inputConnection), attribute); |
| } |
| } |
| |
| private static class RealFeedbackListener implements FeedbackListener { |
| private final Vibrator vibrator; |
| private final AudioManager audioManager; |
| |
| private RealFeedbackListener(Vibrator vibrator, AudioManager audioManager) { |
| if (vibrator == null) { |
| MozcLog.w("vibrator must be non-null. Vibration is disabled."); |
| } |
| this.vibrator = vibrator; |
| if (audioManager == null) { |
| MozcLog.w("audioManager must be non-null. Sound feedback is disabled."); |
| } |
| this.audioManager = audioManager; |
| } |
| |
| @Override |
| public void onVibrate(long duration) { |
| if (duration < 0) { |
| MozcLog.w("duration must be >= 0 but " + duration); |
| return; |
| } |
| if (vibrator != null) { |
| vibrator.vibrate(duration); |
| } |
| } |
| |
| @Override |
| public void onSound(int soundEffectType, float volume) { |
| if (audioManager != null && soundEffectType != FeedbackManager.FeedbackEvent.NO_SOUND) { |
| audioManager.playSoundEffect(soundEffectType, volume); |
| } |
| } |
| } |
| |
| /** Adapter implementation of the symbol history manipulation. */ |
| static class SymbolHistoryStorageImpl implements SymbolHistoryStorage { |
| static final Map<SymbolMajorCategory, StorageType> STORAGE_TYPE_MAP; |
| static { |
| Map<SymbolMajorCategory, StorageType> map = |
| new EnumMap<SymbolMajorCategory, StorageType>(SymbolMajorCategory.class); |
| map.put(SymbolMajorCategory.SYMBOL, StorageType.SYMBOL_HISTORY); |
| map.put(SymbolMajorCategory.EMOTICON, StorageType.EMOTICON_HISTORY); |
| map.put(SymbolMajorCategory.EMOJI, StorageType.EMOJI_HISTORY); |
| STORAGE_TYPE_MAP = Collections.unmodifiableMap(map); |
| } |
| |
| private final SessionExecutor sessionExecutor; |
| |
| SymbolHistoryStorageImpl(SessionExecutor sessionExecutor) { |
| this.sessionExecutor = sessionExecutor; |
| } |
| |
| @Override |
| public List<String> getAllHistory(SymbolMajorCategory majorCategory) { |
| List<ByteString> historyList = |
| sessionExecutor.readAllFromStorage(STORAGE_TYPE_MAP.get(majorCategory)); |
| List<String> result = new ArrayList<String>(historyList.size()); |
| for (ByteString value : historyList) { |
| result.add(MozcUtil.utf8CStyleByteStringToString(value)); |
| } |
| return result; |
| } |
| |
| @Override |
| public void addHistory(SymbolMajorCategory majorCategory, String value) { |
| Preconditions.checkNotNull(majorCategory); |
| Preconditions.checkNotNull(value); |
| sessionExecutor.insertToStorage( |
| STORAGE_TYPE_MAP.get(majorCategory), |
| value, |
| Collections.singletonList(ByteString.copyFromUtf8(value))); |
| } |
| } |
| |
| // Called back from ViewManager |
| @VisibleForTesting class MozcEventListener implements ViewEventListener { |
| @Override |
| public void onConversionCandidateSelected(int candidateId, Optional<Integer> rowIndex) { |
| sessionExecutor.submitCandidate(candidateId, rowIndex, renderResultCallback); |
| feedbackManager.fireFeedback(FeedbackEvent.CANDIDATE_SELECTED); |
| } |
| |
| @Override |
| public void onPageUp() { |
| sessionExecutor.pageUp(renderResultCallback); |
| feedbackManager.fireFeedback(FeedbackEvent.KEY_DOWN); |
| } |
| |
| @Override |
| public void onPageDown() { |
| sessionExecutor.pageDown(renderResultCallback); |
| feedbackManager.fireFeedback(FeedbackEvent.KEY_DOWN); |
| } |
| |
| @Override |
| public void onSymbolCandidateSelected(SymbolMajorCategory majorCategory, String candidate, |
| boolean updateHistory) { |
| Preconditions.checkNotNull(majorCategory); |
| Preconditions.checkNotNull(candidate); |
| |
| // Directly commit the text. |
| commitText(candidate); |
| |
| if (updateHistory) { |
| symbolHistoryStorage.addHistory(majorCategory, candidate); |
| } |
| feedbackManager.fireFeedback(FeedbackEvent.CANDIDATE_SELECTED); |
| } |
| |
| private void commitText(String text) { |
| InputConnection inputConnection = getCurrentInputConnection(); |
| if (inputConnection == null) { |
| return; |
| } |
| inputConnection.beginBatchEdit(); |
| try { |
| inputConnection.commitText(text, MozcUtil.CURSOR_POSITION_TAIL); |
| } finally { |
| inputConnection.endBatchEdit(); |
| } |
| } |
| |
| @Override |
| public void onKeyEvent( |
| @Nullable ProtoCommands.KeyEvent mozcKeyEvent, @Nullable KeyEventInterface keyEvent, |
| @Nullable KeyboardSpecification keyboardSpecification, List<TouchEvent> touchEventList) { |
| if (mozcKeyEvent == null && keyboardSpecification == null) { |
| // We don't send a key event to Mozc native layer since {@code mozcKeyEvent} is null, and we |
| // don't need to update the keyboard specification since {@code keyboardSpecification} is |
| // also null. |
| if (keyEvent == null) { |
| // Send a usage information to Mozc native layer. |
| sessionExecutor.touchEventUsageStatsEvent(touchEventList); |
| } else { |
| // Send a key event (which is generated by Mozc in the usual case) to application. |
| Preconditions.checkArgument(touchEventList.isEmpty()); |
| sessionExecutor.sendKeyEvent(keyEvent, sendKeyToApplicationCallback); |
| } |
| return; |
| } |
| |
| sendKeyWithKeyboardSpecification(mozcKeyEvent, keyEvent, |
| keyboardSpecification, getConfiguration(), |
| touchEventList); |
| } |
| |
| @Override |
| public void onUndo(List<TouchEvent> touchEventList) { |
| sessionExecutor.undoOrRewind(touchEventList, renderResultCallback); |
| } |
| |
| @Override |
| public void onFireFeedbackEvent(FeedbackEvent event) { |
| feedbackManager.fireFeedback(event); |
| if (event.equals(FeedbackEvent.INPUTVIEW_EXPAND)) { |
| sessionExecutor.sendUsageStatsEvent(UsageStatsEvent.KEYBOARD_EXPAND_EVENT); |
| } else if (event.equals(FeedbackEvent.INPUTVIEW_FOLD)) { |
| sessionExecutor.sendUsageStatsEvent(UsageStatsEvent.KEYBOARD_FOLD_EVENT); |
| } |
| } |
| |
| @Override |
| public void onSubmitPreedit() { |
| sessionExecutor.submit(renderResultCallback); |
| } |
| |
| @Override |
| public void onExpandSuggestion() { |
| sessionExecutor.expandSuggestion(renderResultCallback); |
| } |
| |
| @Override |
| public void onShowMenuDialog(List<TouchEvent> touchEventList) { |
| sessionExecutor.touchEventUsageStatsEvent(touchEventList); |
| } |
| |
| @Override |
| public void onShowSymbolInputView(List<TouchEvent> touchEventList) { |
| changeKeyboardSpecificationAndSendKey( |
| null, null, KeyboardSpecification.SYMBOL_NUMBER, getConfiguration(), |
| Collections.<TouchEvent>emptyList()); |
| viewManager.onShowSymbolInputView(); |
| } |
| |
| @Override |
| public void onCloseSymbolInputView() { |
| viewManager.onCloseSymbolInputView(); |
| // This callback is called in two ways: one is from touch event on symbol input view. |
| // The other is from onKeyDown event by hardware keyboard. ViewManager.isNarrowMode() |
| // is abused to distinguish these two triggers where its true value indicates that |
| // onCloseSymbolInputView() is called on hardware keyboard event. In the case of hardware |
| // keyboard event, keyboard specification has been already updated so we shouldn't update it. |
| if (!viewManager.isNarrowMode()) { |
| changeKeyboardSpecificationAndSendKey( |
| null, null, viewManager.getKeyboardSpecification(), getConfiguration(), |
| Collections.<TouchEvent>emptyList()); |
| } |
| } |
| |
| @Override |
| public void onHardwareKeyboardCompositionModeChange(CompositionSwitchMode mode) { |
| viewManager.switchHardwareKeyboardCompositionMode(mode); |
| } |
| |
| @Override |
| public void onActionKey() { |
| // false means that the key is for Action and not ENTER. |
| sendEditorAction(false); |
| } |
| |
| @Override |
| public void onNarrowModeChanged(boolean newNarrowMode) { |
| if (!newNarrowMode) { |
| // Hardware keyboard to software keyboard transition: Submit composition. |
| sessionExecutor.submit(renderResultCallback); |
| } |
| updateImposedConfig(); |
| } |
| |
| @Override |
| public void onUpdateKeyboardLayoutAdjustment( |
| ViewManagerInterface.LayoutAdjustment layoutAdjustment) { |
| Preconditions.checkNotNull(layoutAdjustment); |
| Configuration configuration = getConfiguration(); |
| if (sharedPreferences == null || configuration == null) { |
| return; |
| } |
| boolean isLandscapeKeyboardSettingActive = |
| PreferenceUtil.isLandscapeKeyboardSettingActive( |
| sharedPreferences, configuration.orientation); |
| String key; |
| if (isLandscapeKeyboardSettingActive) { |
| key = PreferenceUtil.PREF_LANDSCAPE_LAYOUT_ADJUSTMENT_KEY; |
| } else { |
| key = PreferenceUtil.PREF_PORTRAIT_LAYOUT_ADJUSTMENT_KEY; |
| } |
| sharedPreferences.edit() |
| .putString(key, layoutAdjustment.toString()) |
| .apply(); |
| } |
| } |
| |
| /** |
| * Callback to render the result received from Mozc server. |
| */ |
| private class RenderResultCallback implements SessionExecutor.EvaluationCallback { |
| |
| @Override |
| public void onCompleted( |
| Optional<Command> command, Optional<KeyEventInterface> triggeringKeyEvent) { |
| Preconditions.checkArgument(Preconditions.checkNotNull(command).isPresent()); |
| Preconditions.checkNotNull(triggeringKeyEvent); |
| if (command.get().getInput().getCommand().getType() |
| != SessionCommand.CommandType.EXPAND_SUGGESTION) { |
| // For expanding suggestions, we don't need to update our rendering result. |
| renderInputConnection(command.get(), triggeringKeyEvent.orNull()); |
| } |
| // Transit to narrow mode if required (e.g., Typed 'a' key from h/w keyboard). |
| viewManager.maybeTransitToNarrowMode(command.get(), triggeringKeyEvent.orNull()); |
| viewManager.render(command.get()); |
| } |
| } |
| |
| /** |
| * Callback to send key event to a application. |
| */ |
| @VisibleForTesting |
| class SendKeyToApplicationCallback implements SessionExecutor.EvaluationCallback { |
| |
| @Override |
| public void onCompleted(Optional<Command> command, |
| Optional<KeyEventInterface> triggeringKeyEvent) { |
| Preconditions.checkArgument(!Preconditions.checkNotNull(command).isPresent()); |
| sendKeyEvent(triggeringKeyEvent.orNull()); |
| } |
| } |
| |
| /** |
| * Callback to send key event to view layer. |
| */ |
| private class SendKeyToViewCallback implements SessionExecutor.EvaluationCallback { |
| |
| @Override |
| public void onCompleted( |
| Optional<Command> command, Optional<KeyEventInterface> triggeringKeyEvent) { |
| Preconditions.checkArgument(!Preconditions.checkNotNull(command).isPresent()); |
| Preconditions.checkArgument(Preconditions.checkNotNull(triggeringKeyEvent).isPresent()); |
| viewManager.consumeKeyOnViewSynchronously(triggeringKeyEvent.get().getNativeEvent().orNull()); |
| } |
| } |
| |
| /** |
| * Callback to invoke onUpdateSelectionInternal with delay for onConfigurationChanged. |
| * See onConfigurationChanged for the details. |
| */ |
| private class ConfigurationChangeCallback implements Handler.Callback { |
| @Override |
| public boolean handleMessage(Message msg) { |
| int selectionStart = msg.arg1; |
| int selectionEnd = msg.arg2; |
| onUpdateSelectionInternal(selectionStart, selectionEnd, selectionStart, selectionEnd, -1, -1); |
| return true; |
| } |
| } |
| |
| /** |
| * We need to send SYNC_DATA command periodically. This class handles it. |
| */ |
| @SuppressLint("HandlerLeak") |
| private class SendSyncDataCommandHandler extends Handler { |
| /** |
| * The current period of sending SYNC_DATA is 15 mins (as same as desktop version). |
| */ |
| static final int SYNC_DATA_COMMAND_PERIOD = 15 * 60 * 1000; |
| |
| @Override |
| public void handleMessage(Message msg) { |
| if (sessionExecutor != null) { |
| sessionExecutor.syncData(); |
| } |
| sendEmptyMessageDelayed(0, SYNC_DATA_COMMAND_PERIOD); |
| } |
| } |
| |
| /** |
| * To trim memory, a message is handled to invoke trimMemory method |
| * 10 seconds after hiding window. |
| * |
| * This class handles callback operation. |
| * Posting and removing messages should be done in appropriate point. |
| */ |
| @SuppressLint("HandlerLeak") |
| private class MemoryTrimmingHandler extends Handler { |
| |
| /** |
| * "what" value of message. Always use this. |
| */ |
| static final int WHAT = 0; |
| |
| /** |
| * Duration after hiding window in milliseconds. |
| */ |
| static final int DURATION_MS = 10 * 1000; |
| |
| @Override |
| public void handleMessage(Message msg) { |
| trimMemory(); |
| // Other messages in the queue are removed as they will do the same thing |
| // and will affect nothing. |
| removeMessages(WHAT); |
| } |
| } |
| |
| |
| // Keys for tweak preferences. |
| private static final String PREF_TWEAK_PREFIX = "pref_tweak_"; |
| private static final String PREF_TWEAK_LOGGING_PROTOCOL_BUFFERS = |
| "pref_tweak_logging_protocol_buffers"; |
| |
| // Focused segment's attribute. |
| @VisibleForTesting static final CharacterStyle SPAN_CONVERT_HIGHLIGHT = |
| new BackgroundColorSpan(0x66EF3566); |
| |
| // Background color span for non-focused conversion segment. |
| // We don't create a static CharacterStyle instance since there are multiple segments at the same |
| // time. Otherwise, segments except for the last one cannot have style. |
| @VisibleForTesting static final int CONVERT_NORMAL_COLOR = 0x19EF3566; |
| |
| // Cursor position. |
| // Note that InputConnection seems not to be able to show cursor. This is a workaround. |
| @VisibleForTesting static final CharacterStyle SPAN_BEFORE_CURSOR = |
| new BackgroundColorSpan(0x664DB6AC); |
| |
| // Background color span for partial conversion. |
| @VisibleForTesting static final CharacterStyle SPAN_PARTIAL_SUGGESTION_COLOR = |
| new BackgroundColorSpan(0x194DB6AC); |
| |
| // Underline. |
| @VisibleForTesting static final CharacterStyle SPAN_UNDERLINE = new UnderlineSpan(); |
| |
| // Mozc's session. All session related task should be done via this instance. |
| @VisibleForTesting SessionExecutor sessionExecutor; |
| @VisibleForTesting final RenderResultCallback renderResultCallback = new RenderResultCallback(); |
| @VisibleForTesting final SendKeyToApplicationCallback sendKeyToApplicationCallback = |
| new SendKeyToApplicationCallback(); |
| private final SendKeyToViewCallback sendKeyToViewCallback = new SendKeyToViewCallback(); |
| |
| // A manager for all views and feedbacks. |
| @VisibleForTesting |
| public ViewManagerInterface viewManager; |
| @VisibleForTesting FeedbackManager feedbackManager; |
| @VisibleForTesting SymbolHistoryStorage symbolHistoryStorage; |
| |
| @VisibleForTesting SharedPreferences sharedPreferences; |
| |
| // A handler for onSharedPreferenceChanged(). |
| // Note: the handler is needed to be held by the service not to be GC'ed. |
| @VisibleForTesting final OnSharedPreferenceChangeListener sharedPreferenceChangeListener = |
| new SharedPreferenceChangeAdapter(); |
| |
| // Preference information which are propagated. Null if not propagated yet. |
| @VisibleForTesting ClientSidePreference propagatedClientSidePreference = null; |
| |
| // Track the selection. |
| @VisibleForTesting SelectionTracker selectionTracker = new SelectionTracker(); |
| |
| // A receiver to accept a notification via intents. |
| @VisibleForTesting Handler configurationChangedHandler = |
| new Handler(new ConfigurationChangeCallback()); |
| |
| // Handler to process SYNC_DATA command for storing history data. |
| @VisibleForTesting Handler sendSyncDataCommandHandler = new SendSyncDataCommandHandler(); |
| |
| // Handler to process SYNC_DATA command for storing history data. |
| private final Handler memoryTrimmingHandler = new MemoryTrimmingHandler(); |
| |
| // This is a cache of MozcUtil.isDebug. It will be set in onCreateInternal and |
| // will never be changed. |
| private boolean isDebugBuild; |
| |
| // Current KeyboardSpecification, which is determined by the last key event. |
| // Note that this might be different from what a user sees. |
| // For example when a user is in narrow mode (this field is for H/W keyboard) |
| // and (s)he taps widen button to see S/W keyboard, |
| // (s)he will see S/W keyboard but this field keep to point H/W keyboard because |
| // widen button is not a key event. |
| // This behavior is error-prone and might be a kind of bug. At least the name doesn't represent |
| // the behavior. |
| // TODO(matsuzakit): Clarify the usage of this field (change the behavior to keep the latest |
| // state or change the name to represent current behavior). |
| @VisibleForTesting KeyboardSpecification currentKeyboardSpecification = |
| KeyboardSpecification.TWELVE_KEY_TOGGLE_KANA; |
| |
| // Current HardKeyboardHidden configuration value. |
| // This is updated only when onConfigurationChanged is called and |
| // Configuration.HARDKEYBOARDHIDDEN_* differs to this. |
| private int currentHardKeyboardHidden = Configuration.HARDKEYBOARDHIDDEN_UNDEFINED; |
| |
| @VisibleForTesting boolean inputBound = false; |
| |
| private ApplicationCompatibility applicationCompatibility = |
| ApplicationCompatibility.getDefaultInstance(); |
| |
| // Listener called by views. |
| // Held for testing. |
| private ViewEventListener eventListener; |
| |
| @SuppressWarnings("deprecation") |
| @SuppressLint("NewApi") |
| public MozcService() { |
| super(); |
| if (Build.VERSION.SDK_INT >= 17) { |
| enableHardwareAcceleration(); |
| } |
| } |
| |
| @Override |
| public void onBindInput() { |
| super.onBindInput(); |
| inputBound = true; |
| } |
| |
| @Override |
| public void onUnbindInput() { |
| inputBound = false; |
| super.onUnbindInput(); |
| } |
| |
| @Override |
| public void onUpdateCursorAnchorInfo(CursorAnchorInfo cursorAnchorInfo) { |
| if (viewManager != null) { |
| viewManager.setCursorAnchorInfo(cursorAnchorInfo); |
| } |
| } |
| |
| @Override |
| public MozcInputMethod onCreateInputMethodInterface() { |
| return new MozcInputMethod(); |
| } |
| |
| @Override |
| public void onCreate() { |
| // Note: super.onCreate() is invoked in onCreateInternal. So, do not call it, here. |
| MozcLog.d("start MozcService#onCreate " + System.nanoTime()); |
| |
| // TODO(hidehiko): Restructure around initialization code in order to make tests stable. |
| // Callback object mainly used by views. |
| MozcEventListener eventListener = new MozcEventListener(); |
| SharedPreferences sharedPreferences = PreferenceManager.getDefaultSharedPreferences(this); |
| Preconditions.checkNotNull(sharedPreferences); |
| SessionExecutor sessionExecutor = |
| SessionExecutor.getInstanceInitializedIfNecessary( |
| new SessionHandlerFactory(Optional.of(sharedPreferences)), this); |
| onCreateInternal(eventListener, null, sharedPreferences, getConfiguration(), |
| sessionExecutor); |
| |
| MozcLog.d("end MozcService#onCreate " + System.nanoTime()); |
| } |
| |
| @Override |
| public void onDestroy() { |
| feedbackManager.release(); |
| if (sessionExecutor != null) { |
| sessionExecutor.syncData(); |
| } |
| super.onDestroy(); |
| } |
| |
| @VisibleForTesting |
| void onCreateInternal(ViewEventListener eventListener, @Nullable ViewManagerInterface viewManager, |
| @Nullable SharedPreferences sharedPreferences, |
| Configuration deviceConfiguration, SessionExecutor sessionExecutor) { |
| super.onCreate(); |
| |
| Context context = getApplicationContext(); |
| isDebugBuild = MozcUtil.isDebug(context); |
| |
| // TODO(hidehiko): Split following methods by functionalities to improve test coverage and |
| // test stableness. |
| this.sessionExecutor = sessionExecutor; |
| this.symbolHistoryStorage = new SymbolHistoryStorageImpl(sessionExecutor); |
| this.eventListener = eventListener; |
| prepareOnce(eventListener, symbolHistoryStorage, viewManager, sharedPreferences); |
| prepareEveryTime(sharedPreferences, deviceConfiguration); |
| |
| if (propagatedClientSidePreference == null |
| || propagatedClientSidePreference.getHardwareKeyMap() == null) { |
| HardwareKeyboardSpecification.maybeSetDetectedHardwareKeyMap( |
| sharedPreferences, deviceConfiguration, false); |
| } |
| |
| // Start sending SYNC_DATA message to mozc server periodically. |
| sendSyncDataCommandHandler.sendEmptyMessageDelayed( |
| 0, SendSyncDataCommandHandler.SYNC_DATA_COMMAND_PERIOD); |
| this.sharedPreferences = sharedPreferences; |
| } |
| |
| /** |
| * Prepares something which should be done every time when the session is newly created. |
| */ |
| private void prepareEveryTime( |
| @Nullable SharedPreferences sharedPreferences, Configuration deviceConfiguration) { |
| boolean isLogging = sharedPreferences != null |
| && sharedPreferences.getBoolean(PREF_TWEAK_LOGGING_PROTOCOL_BUFFERS, false); |
| // Force to initialize here. |
| sessionExecutor.reset( |
| new SessionHandlerFactory(Optional.fromNullable(sharedPreferences)), this); |
| sessionExecutor.setLogging(isLogging); |
| |
| updateImposedConfig(); |
| viewManager.onConfigurationChanged(getConfiguration()); |
| // Make sure that the server and the client have the same keyboard specification. |
| // User preference's keyboard will be set after this step. |
| changeKeyboardSpecificationAndSendKey( |
| null, null, currentKeyboardSpecification, deviceConfiguration, |
| Collections.<TouchEvent>emptyList()); |
| if (sharedPreferences != null) { |
| propagateClientSidePreference( |
| new ClientSidePreference( |
| sharedPreferences, getResources(), deviceConfiguration.orientation)); |
| // TODO(hidehiko): here we just set the config based on preferences. When we start |
| // to support sync on Android, we need to revisit the config related design. |
| sessionExecutor.setConfig(ConfigUtil.toConfig(sharedPreferences)); |
| sessionExecutor.preferenceUsageStatsEvent(sharedPreferences, getResources()); |
| } |
| |
| maybeSetNarrowMode(deviceConfiguration); |
| } |
| |
| /** |
| * Prepares something which should be done only once. |
| */ |
| private void prepareOnce(ViewEventListener eventListener, |
| SymbolHistoryStorage symbolHistoryStorage, |
| @Nullable ViewManagerInterface viewManager, |
| @Nullable SharedPreferences sharedPreferences) { |
| Context context = getApplicationContext(); |
| Optional<Intent> forwardIntent = |
| ApplicationInitializerFactory.createInstance(this).initialize( |
| MozcUtil.isSystemApplication(context), |
| MozcUtil.isDevChannel(context), |
| DependencyFactory.getDependency(getApplicationContext()).isWelcomeActivityPreferrable(), |
| MozcUtil.getAbiIndependentVersionCode(context), |
| LauncherIconManagerFactory.getDefaultInstance(), |
| PreferenceUtil.getDefaultPreferenceManagerStatic()); |
| if (forwardIntent.isPresent()) { |
| startActivity(forwardIntent.get()); |
| } |
| |
| // Create a ViewManager. |
| if (viewManager == null) { |
| ImeSwitcher imeSwitcher = ImeSwitcherFactory.getImeSwitcher(this); |
| viewManager = DependencyFactory.getDependency( |
| getApplicationContext()).createViewManager( |
| getApplicationContext(), |
| eventListener, |
| symbolHistoryStorage, |
| imeSwitcher, |
| new MozcMenuDialogListenerImpl(this)); |
| } |
| |
| // Setup FeedbackManager. |
| feedbackManager = new FeedbackManager(new RealFeedbackListener( |
| Vibrator.class.cast(getSystemService(Context.VIBRATOR_SERVICE)), |
| AudioManager.class.cast(getSystemService(Context.AUDIO_SERVICE)))); |
| |
| this.viewManager = viewManager; |
| |
| // Set a callback for preference changing. |
| if (sharedPreferences != null) { |
| sharedPreferences.registerOnSharedPreferenceChangeListener(sharedPreferenceChangeListener); |
| } |
| } |
| |
| @Override |
| public boolean onEvaluateInputViewShown() { |
| // TODO(matsuzakit): Implement me |
| return true; |
| } |
| |
| @Override |
| public View onCreateInputView() { |
| MozcLog.d("start MozcService#onCreateInputView " + System.nanoTime()); |
| View inputView = viewManager.createMozcView(this); |
| MozcLog.d("end MozcService#onCreateInputView " + System.nanoTime()); |
| return inputView; |
| } |
| |
| private void resetContext() { |
| if (sessionExecutor != null) { |
| sessionExecutor.resetContext(); |
| } |
| if (viewManager != null) { |
| viewManager.reset(); |
| } |
| } |
| |
| @Override |
| public void onFinishInput() { |
| // Omit rendering because the input view will soon disappear. |
| resetContext(); |
| selectionTracker.onFinishInput(); |
| applicationCompatibility = ApplicationCompatibility.getDefaultInstance(); |
| super.onFinishInput(); |
| } |
| |
| @Override |
| public void onStartInput(EditorInfo attribute, boolean restarting) { |
| super.onStartInput(attribute, restarting); |
| |
| applicationCompatibility = ApplicationCompatibility.getInstance(attribute); |
| |
| // Update full screen mode, because the application may be changed. |
| viewManager.setFullscreenMode( |
| applicationCompatibility.isFullScreenModeSupported() |
| && propagatedClientSidePreference != null |
| && propagatedClientSidePreference.isFullscreenMode()); |
| |
| // Some applications, e.g. gmail or maps, send onStartInput with restarting = true, when a user |
| // rotates a device. In such cases, we don't want to update caret positions, nor reset |
| // the context basically. However, some other applications, such as one with a webview widget |
| // like a browser, send onStartInput with restarting = true, too. Unfortunately, |
| // there seems no way to figure out which one causes this invocation. |
| // So, as a point of compromise, we reset the context every time here. Also, we'll send |
| // finishComposingText as well, in case the new attached field has already had composing text |
| // (we hit such a situation on webview, too). |
| // See also onConfigurationChanged for caret position handling on gmail-like applications' |
| // device rotation events. |
| resetContext(); |
| InputConnection connection = getCurrentInputConnection(); |
| if (connection != null) { |
| connection.finishComposingText(); |
| maybeCommitMushroomResult(attribute, connection); |
| } |
| |
| // Send the connected field's attributes to the mozc server. |
| sessionExecutor.switchInputFieldType(getInputFieldType(attribute)); |
| sessionExecutor.updateRequest( |
| EmojiUtil.createEmojiRequest( |
| Build.VERSION.SDK_INT, |
| (propagatedClientSidePreference != null && EmojiUtil.isCarrierEmojiAllowed(attribute)) |
| ? propagatedClientSidePreference.getEmojiProviderType() : EmojiProviderType.NONE), |
| Collections.<TouchEvent>emptyList()); |
| selectionTracker.onStartInput( |
| attribute.initialSelStart, attribute.initialSelEnd, isWebEditText(attribute)); |
| } |
| |
| /** |
| * Hook to support mushroom protocol. If there is pending Mushroom result for the connecting |
| * field, commit it. Then, (regardless of whether there exists pending result,) clears |
| * all remaining pending result. |
| */ |
| private static void maybeCommitMushroomResult(EditorInfo attribute, InputConnection connection) { |
| if (connection == null) { |
| return; |
| } |
| |
| MushroomResultProxy resultProxy = MushroomResultProxy.getInstance(); |
| String result; |
| synchronized (resultProxy) { |
| // We need to obtain the result and then clear the all remaining result atomically. |
| result = resultProxy.getReplaceKey(attribute.fieldId); |
| resultProxy.clear(); |
| } |
| if (result != null) { |
| // Found the pending mushroom application result to the connecting field. Commit it. |
| connection.commitText(result, MozcUtil.CURSOR_POSITION_TAIL); |
| } |
| } |
| |
| @SuppressLint("NewApi") |
| private static boolean enableCursorAnchorInfo(InputConnection connection) { |
| Preconditions.checkNotNull(connection); |
| if (Build.VERSION.SDK_INT < 21) { |
| return false; |
| } |
| return connection.requestCursorUpdates( |
| InputConnection.CURSOR_UPDATE_IMMEDIATE | InputConnection.CURSOR_UPDATE_MONITOR); |
| } |
| |
| /** |
| * @return true if connected view is WebEditText (or the application pretends it) |
| */ |
| private boolean isWebEditText(EditorInfo editorInfo) { |
| if (editorInfo == null) { |
| return false; |
| } |
| |
| if (applicationCompatibility.isPretendingWebEditText()) { |
| return true; |
| } |
| |
| // TODO(hidehiko): Refine the heuristic to check isWebEditText related stuff. |
| MozcLog.d("inputType: " + editorInfo.inputType); |
| int variation = editorInfo.inputType & InputType.TYPE_MASK_VARIATION; |
| return variation == InputType.TYPE_TEXT_VARIATION_WEB_EDIT_TEXT; |
| } |
| |
| @Override |
| public void onStartInputView(EditorInfo attribute, boolean restarting) { |
| InputConnection inputConnection = getCurrentInputConnection(); |
| if (inputConnection != null && Build.VERSION.SDK_INT >= 21) { |
| viewManager.setCursorAnchorInfoEnabled(enableCursorAnchorInfo(inputConnection)); |
| updateImposedConfig(); |
| } |
| |
| viewManager.setTextForActionButton(getTextForImeAction(attribute.imeOptions)); |
| viewManager.setEditorInfo(attribute); |
| // updateXxxxxButtonEnabled cannot be placed in onStartInput because |
| // the view might be created after onStartInput with *reset* status. |
| viewManager.updateGlobeButtonEnabled(); |
| viewManager.updateMicrophoneButtonEnabled(); |
| } |
| |
| static InputFieldType getInputFieldType(EditorInfo attribute) { |
| int inputType = attribute.inputType; |
| if (MozcUtil.isPasswordField(inputType)) { |
| return InputFieldType.PASSWORD; |
| } |
| int inputClass = inputType & InputType.TYPE_MASK_CLASS; |
| if (inputClass == InputType.TYPE_CLASS_PHONE) { |
| return InputFieldType.TEL; |
| } |
| if (inputClass == InputType.TYPE_CLASS_NUMBER) { |
| return InputFieldType.NUMBER; |
| } |
| return InputFieldType.NORMAL; |
| } |
| |
| @Override |
| public void onComputeInsets(InputMethodService.Insets outInsets) { |
| viewManager.computeInsets(getApplicationContext(), outInsets, getWindow().getWindow()); |
| } |
| |
| /** |
| * KeyDown event handler. |
| * |
| * This method is called only by the android framework e.g HOME,BACK or H/W keyboard input. |
| */ |
| @Override |
| public boolean onKeyDown(int keyCode, KeyEvent event) { |
| return onKeyDownInternal(keyCode, event, getConfiguration()); |
| } |
| |
| /** |
| * GenericMotionEvent handler. |
| * |
| * This method is called only by the android framework e.g H/W mouse, touch pad input, etc. |
| */ |
| @TargetApi(17) |
| @Override |
| public boolean onGenericMotionEvent(MotionEvent event) { |
| if (!isInputViewShown()) { |
| return super.onGenericMotionEvent(event); |
| } |
| if (viewManager.isGenericMotionToConsume(event)) { |
| return viewManager.consumeGenericMotion(event); |
| } |
| return super.onGenericMotionEvent(event); |
| } |
| |
| @SuppressLint("DefaultLocale") |
| @VisibleForTesting |
| boolean onKeyDownInternal(int keyCode, KeyEvent event, Configuration configuration) { |
| if (MozcLog.isLoggable(Log.DEBUG)) { |
| MozcLog.d( |
| String.format( |
| "onKeyDown keyCode:0x%x, metaState:0x%x, scanCode:0x%x, uniCode:0x%x, deviceId:%d", |
| event.getKeyCode(), event.getMetaState(), event.getScanCode(), |
| event.getUnicodeChar(), event.getDeviceId())); |
| } |
| |
| // Send back the event if the input view is not shown. |
| if (!isInputViewShown()) { |
| return super.onKeyDown(keyCode, event); |
| } |
| |
| // Send back the event if the event is one of the system keys, which invoke |
| // system's action. (e.g. back, home, power, volume and so on). |
| if (event.isSystem()) { |
| // Special handle for back key. We need to post it to the server and maybeProcessBackKey |
| // should handle it later. The posting the event is done in onKeyUp, so we just consume the |
| // down key event here. |
| if (keyCode == KeyEvent.KEYCODE_BACK) { |
| return true; |
| } |
| return super.onKeyDown(keyCode, event); |
| } |
| |
| // Push the event to the asynchronous execution queue if it should be processed |
| // directly in the view. |
| if (viewManager.isKeyConsumedOnViewAsynchronously(event)) { |
| sessionExecutor.sendKeyEvent(KeycodeConverter.getKeyEventInterface(event), |
| sendKeyToViewCallback); |
| return true; |
| } |
| |
| // Lazy evaluation. |
| // If hardware keyboard is not set in the preference screen, |
| // set it based on the configuration. |
| if (propagatedClientSidePreference == null |
| || propagatedClientSidePreference.getHardwareKeyMap() == null) { |
| HardwareKeyboardSpecification.maybeSetDetectedHardwareKeyMap( |
| sharedPreferences, configuration, true); |
| } |
| |
| // Here we decided to send the event to the server. |
| |
| viewManager.onHardwareKeyEvent(event); |
| return true; |
| } |
| |
| @Override |
| public boolean onKeyUp(int keyCode, KeyEvent event) { |
| if (isInputViewShown()) { |
| if (event.isSystem()) { |
| // The back key should be processed as same as the meta keys. |
| // See also comments described below. |
| if (event.getKeyCode() == KeyEvent.KEYCODE_BACK) { |
| sessionExecutor.sendKeyEvent( |
| KeycodeConverter.getKeyEventInterface(event), sendKeyToApplicationCallback); |
| return true; |
| } |
| } else { |
| if (viewManager.isKeyConsumedOnViewAsynchronously(event)) { |
| sessionExecutor.sendKeyEvent(KeycodeConverter.getKeyEventInterface(event), |
| sendKeyToViewCallback); |
| return true; |
| } |
| |
| // The IME is active and the server can handle the event so consume the event. |
| // Currently the server does not consume UP event for not meta keys. |
| // For meta keys, to guarantee that this up event is sent to InputConnection after down key, |
| // this is sent to evaluation handler. |
| if (KeycodeConverter.isMetaKey(event)) { |
| sessionExecutor.sendKeyEvent(KeycodeConverter.getKeyEventInterface(event), |
| sendKeyToApplicationCallback); |
| } |
| return true; |
| } |
| } |
| |
| // If the IME is turned off or the event should not be sent to the server, |
| // delegate to the super class. |
| // Note that delegation should be done only when needed. |
| // For example hardware keyboard's enter key should not be delegated |
| // because its DOWN event is sent to the sever. |
| // If delegated, enter key event is sent to the application twice (DOWN and UP). |
| return super.onKeyUp(keyCode, event); |
| } |
| |
| /** |
| * Sends mozcKeyEvent and/or Request to mozc server. |
| * |
| * This skips to send request if the given keyboard specification is same as before. |
| */ |
| @VisibleForTesting |
| void sendKeyWithKeyboardSpecification( |
| @Nullable ProtoCommands.KeyEvent mozcKeyEvent, @Nullable KeyEventInterface event, |
| @Nullable KeyboardSpecification keyboardSpecification, Configuration configuration, |
| List<TouchEvent> touchEventList) { |
| if (keyboardSpecification != null && currentKeyboardSpecification != keyboardSpecification) { |
| // Submit composition on the transition from software KB to hardware KB by key event. |
| if (!currentKeyboardSpecification.isHardwareKeyboard() |
| && keyboardSpecification.isHardwareKeyboard()) { |
| sessionExecutor.submit(renderResultCallback); |
| } |
| changeKeyboardSpecificationAndSendKey( |
| mozcKeyEvent, event, keyboardSpecification, configuration, touchEventList); |
| updateStatusIcon(); |
| } else if (mozcKeyEvent != null) { |
| // Send mozcKeyEvent as usual. |
| sessionExecutor.sendKey(mozcKeyEvent, event, touchEventList, renderResultCallback); |
| } else if (event != null) { |
| // Send event back to the application to handle key events which cannot be converted into Mozc |
| // key event (e.g. Shift) correctly. |
| sessionExecutor.sendKeyEvent(event, sendKeyToApplicationCallback); |
| } |
| } |
| |
| /** |
| * Sends Request for changing keyboard setting to mozc server and sends key. |
| */ |
| private void changeKeyboardSpecificationAndSendKey( |
| @Nullable ProtoCommands.KeyEvent mozcKeyEvent, @Nullable KeyEventInterface event, |
| KeyboardSpecification keyboardSpecification, Configuration configuration, |
| List<TouchEvent> touchEventList) { |
| // Send Request to change composition table. |
| sessionExecutor.updateRequest( |
| MozcUtil.getRequestBuilder(getResources(), keyboardSpecification, configuration).build(), |
| touchEventList); |
| if (mozcKeyEvent == null) { |
| // Change composition mode. |
| sessionExecutor.switchInputMode( |
| Optional.fromNullable(event), keyboardSpecification.getCompositionMode(), |
| renderResultCallback); |
| } else { |
| // Send key with composition mode change. |
| sessionExecutor.sendKey( |
| ProtoCommands.KeyEvent.newBuilder(mozcKeyEvent) |
| .setMode(keyboardSpecification.getCompositionMode()).build(), |
| event, touchEventList, renderResultCallback); |
| } |
| currentKeyboardSpecification = keyboardSpecification; |
| } |
| |
| /** |
| * Shows/Hides status icon according to the input view status. |
| */ |
| private void updateStatusIcon() { |
| if (isInputViewShown()) { |
| showStatusIcon(); |
| } else { |
| hideStatusIcon(); |
| } |
| } |
| |
| /** |
| * Shows the status icon basing on the current keyboard spec. |
| */ |
| private void showStatusIcon() { |
| switch (currentKeyboardSpecification.getCompositionMode()) { |
| case HIRAGANA: |
| showStatusIcon(R.drawable.status_icon_hiragana); |
| break; |
| default: |
| showStatusIcon(R.drawable.status_icon_alphabet); |
| break; |
| } |
| } |
| |
| @Override |
| public boolean onEvaluateFullscreenMode() { |
| return viewManager.isFullscreenMode(); |
| } |
| |
| @Override |
| public boolean onShowInputRequested(int flags, boolean configChange) { |
| boolean result = super.onShowInputRequested(flags, configChange); |
| boolean isHardwareKeyboardConnected = |
| getResources().getConfiguration().keyboard != Configuration.KEYBOARD_NOKEYS; |
| // Original result becomes false when a hardware keyboard is connected. |
| // This means that the window won't be shown in such situation. |
| // We want to show it even with a hardware keyboard so override the result here. |
| return result || isHardwareKeyboardConnected; |
| } |
| |
| @Override |
| public void onWindowShown() { |
| showStatusIcon(); |
| // Remove memory trimming message. |
| memoryTrimmingHandler.removeMessages(MemoryTrimmingHandler.WHAT); |
| // Ensure keyboard's request. |
| // The session might be deleted by trimMemory caused by onWindowHidden. |
| // Note that this logic must be placed *after* removing the messages in memoryTrimmingHandler. |
| // Otherwise the session might be unexpectedly deleted and newly re-created one will be used |
| // without appropriate request which is sent below. |
| changeKeyboardSpecificationAndSendKey( |
| null, null, currentKeyboardSpecification, getConfiguration(), |
| Collections.<TouchEvent>emptyList()); |
| } |
| |
| @Override |
| public void onWindowHidden() { |
| // "Hiding IME's window" is very similar to "Turning off IME" for PC. |
| // Thus |
| // - Committing composing text. |
| // - Removing all pending messages. |
| // - Resetting Mozc server |
| // are needed. |
| sessionExecutor.removePendingEvaluations(); |
| |
| resetContext(); |
| selectionTracker.onWindowHidden(); |
| viewManager.reset(); |
| hideStatusIcon(); |
| // MemoryTrimmingHandler.DURATION_MS from now, memory trimming will be done. |
| // If the window is shown before MemoryTrimmingHandler.DURATION_MS, |
| // the message posted here will be removed. |
| memoryTrimmingHandler.removeMessages(MemoryTrimmingHandler.WHAT); |
| memoryTrimmingHandler.sendEmptyMessageDelayed(MemoryTrimmingHandler.WHAT, |
| MemoryTrimmingHandler.DURATION_MS); |
| super.onWindowHidden(); |
| } |
| |
| /** |
| * Updates InputConnection. |
| * |
| * @param command Output message. Rendering is based on this parameter. |
| * @param keyEvent Trigger event for this calling. When direct input is |
| * needed, this event is sent to InputConnection. |
| */ |
| @VisibleForTesting |
| void renderInputConnection(Command command, @Nullable KeyEventInterface keyEvent) { |
| Preconditions.checkNotNull(command); |
| |
| InputConnection inputConnection = getCurrentInputConnection(); |
| if (inputConnection == null) { |
| return; |
| } |
| |
| Output output = command.getOutput(); |
| if (!output.hasConsumed() || !output.getConsumed()) { |
| maybeCommitText(output, inputConnection); |
| sendKeyEvent(keyEvent); |
| return; |
| } |
| |
| // Meta key may invoke a command for Mozc server like SWITCH_INPUT_MODE session command. In this |
| // case, the command is consumed by Mozc server and the application cannot get the key event. |
| // To avoid such situation, we should send the key event back to application. b/13238551 |
| // The command itself is consumed by Mozc server, so we should NOT put a return statement here. |
| if (keyEvent != null && keyEvent.getNativeEvent().isPresent() |
| && KeycodeConverter.isMetaKey(keyEvent.getNativeEvent().get())) { |
| sendKeyEvent(keyEvent); |
| } |
| |
| // Here the key is consumed by the Mozc server. |
| inputConnection.beginBatchEdit(); |
| try { |
| maybeDeleteSurroundingText(output, inputConnection); |
| maybeCommitText(output, inputConnection); |
| setComposingText(command, inputConnection); |
| maybeSetSelection(output, inputConnection); |
| selectionTracker.onRender( |
| output.hasDeletionRange() ? output.getDeletionRange() : null, |
| output.hasResult() ? output.getResult().getValue() : null, |
| output.hasPreedit() ? output.getPreedit() : null); |
| } finally { |
| inputConnection.endBatchEdit(); |
| } |
| } |
| |
| private static KeyEvent createKeyEvent( |
| KeyEvent original, long eventTime, int action, int repeatCount) { |
| return new KeyEvent( |
| original.getDownTime(), eventTime, action, original.getKeyCode(), |
| repeatCount, original.getMetaState(), original.getDeviceId(), original.getScanCode(), |
| original.getFlags()); |
| } |
| |
| /** |
| * Sends the {@code KeyEvent}, which is not consumed by the mozc server. |
| */ |
| @VisibleForTesting void sendKeyEvent(KeyEventInterface keyEvent) { |
| if (keyEvent == null) { |
| return; |
| } |
| |
| int keyCode = keyEvent.getKeyCode(); |
| // Some keys have a potential to be consumed from mozc client. |
| if (maybeProcessBackKey(keyCode) || maybeProcessActionKey(keyCode)) { |
| // The key event is consumed. |
| return; |
| } |
| |
| // Following code is to fallback to target activity. |
| Optional<KeyEvent> nativeKeyEvent = keyEvent.getNativeEvent(); |
| InputConnection inputConnection = getCurrentInputConnection(); |
| |
| if (nativeKeyEvent.isPresent() && inputConnection != null) { |
| // Meta keys are from this.onKeyDown/Up so fallback each time. |
| if (KeycodeConverter.isMetaKey(nativeKeyEvent.get())) { |
| inputConnection.sendKeyEvent(createKeyEvent( |
| nativeKeyEvent.get(), MozcUtil.getUptimeMillis(), |
| nativeKeyEvent.get().getAction(), nativeKeyEvent.get().getRepeatCount())); |
| return; |
| } |
| |
| // Other keys are from this.onKeyDown so create dummy Down/Up events. |
| inputConnection.sendKeyEvent(createKeyEvent( |
| nativeKeyEvent.get(), MozcUtil.getUptimeMillis(), KeyEvent.ACTION_DOWN, 0)); |
| |
| inputConnection.sendKeyEvent(createKeyEvent( |
| nativeKeyEvent.get(), MozcUtil.getUptimeMillis(), KeyEvent.ACTION_UP, 0)); |
| return; |
| } |
| |
| // Otherwise, just delegates the key event to the connected application. |
| sendDownUpKeyEvents(keyCode); |
| } |
| |
| /** |
| * @return true if the key event is consumed |
| */ |
| private boolean maybeProcessBackKey(int keyCode) { |
| if (keyCode != KeyEvent.KEYCODE_BACK || !isInputViewShown()) { |
| return false; |
| } |
| |
| // Special handling for back key event, to close the software keyboard or its subview. |
| // First, try to hide the subview, such as the symbol input view or the cursor view. |
| // If neither is shown, hideSubInputView would fail, then hide the whole software keyboard. |
| if (!viewManager.hideSubInputView()) { |
| requestHideSelf(0); |
| } |
| return true; |
| } |
| |
| private boolean maybeProcessActionKey(int keyCode) { |
| // Handle the event iff the enter is pressed. |
| if (keyCode != KeyEvent.KEYCODE_ENTER || !isInputViewShown()) { |
| return false; |
| } |
| return sendEditorAction(true); |
| } |
| |
| /** |
| * Sends editor action to {@code InputConnection}. |
| * <p> |
| * The difference from {@link InputMethodService#sendDefaultEditorAction(boolean)} is |
| * that if custom action label is specified {@code EditorInfo#actionId} is sent instead. |
| */ |
| private boolean sendEditorAction(boolean fromEnterKey) { |
| // If custom action label is specified (=non-null), special action id is also specified. |
| // If there is no IME_FLAG_NO_ENTER_ACTION option, we should send the id to the InputConnection. |
| EditorInfo editorInfo = getCurrentInputEditorInfo(); |
| if (editorInfo != null |
| && (editorInfo.imeOptions & EditorInfo.IME_FLAG_NO_ENTER_ACTION) == 0 |
| && editorInfo.actionLabel != null) { |
| InputConnection inputConnection = getCurrentInputConnection(); |
| if (inputConnection != null) { |
| inputConnection.performEditorAction(editorInfo.actionId); |
| return true; |
| } |
| } |
| // No custom action label is specified. Fall back to default EditorAction. |
| return sendDefaultEditorAction(fromEnterKey); |
| } |
| |
| private static void maybeDeleteSurroundingText(Output output, InputConnection inputConnection) { |
| if (!output.hasDeletionRange()) { |
| return; |
| } |
| |
| DeletionRange range = output.getDeletionRange(); |
| int leftRange = -range.getOffset(); |
| int rightRange = range.getLength() - leftRange; |
| if (leftRange < 0 || rightRange < 0) { |
| // If the range does not include the current position, do nothing |
| // because Android's API does not expect such situation. |
| MozcLog.w("Deletion range has unsupported parameters: " + range.toString()); |
| return; |
| } |
| |
| if (!inputConnection.deleteSurroundingText(leftRange, rightRange)) { |
| MozcLog.e("Failed to delete surrounding text."); |
| } |
| } |
| |
| private static void maybeCommitText(Output output, InputConnection inputConnection) { |
| if (!output.hasResult()) { |
| return; |
| } |
| |
| String outputText = output.getResult().getValue(); |
| if (outputText.equals("")) { |
| // Do nothing for an empty result string. |
| return; |
| } |
| |
| int position = MozcUtil.CURSOR_POSITION_TAIL; |
| if (output.getResult().hasCursorOffset()) { |
| if (output.getResult().getCursorOffset() |
| == -outputText.codePointCount(0, outputText.length())) { |
| position = MozcUtil.CURSOR_POSITION_HEAD; |
| } else { |
| MozcLog.e("Unsupported position: " + output.getResult().toString()); |
| } |
| } |
| |
| if (!inputConnection.commitText(outputText, position)) { |
| MozcLog.e("Failed to commit text."); |
| } |
| } |
| |
| private void setComposingText(Command command, InputConnection inputConnection) { |
| Preconditions.checkNotNull(command); |
| Preconditions.checkNotNull(inputConnection); |
| |
| Output output = command.getOutput(); |
| if (!output.hasPreedit()) { |
| // If preedit field is empty, we should clear composing text in the InputConnection |
| // because Mozc server asks us to do so. |
| // But there is special situation in Android. |
| // On onWindowShown, SWITCH_INPUT_MODE command is sent as a step of initialization. |
| // In this case we reach here with empty preedit. |
| // As described above we should clear the composing text but if we do so |
| // texts in selection range (e.g., URL in OmniBox) is always cleared. |
| // To avoid from this issue, we don't clear the composing text if the input |
| // is SWITCH_INPUT_MODE. |
| Input input = command.getInput(); |
| if (input.getType() != Input.CommandType.SEND_COMMAND |
| || input.getCommand().getType() != SessionCommand.CommandType.SWITCH_INPUT_MODE) { |
| if (!inputConnection.setComposingText("", 0)) { |
| MozcLog.e("Failed to set composing text."); |
| } |
| } |
| return; |
| } |
| |
| // Builds preedit expression. |
| Preedit preedit = output.getPreedit(); |
| |
| SpannableStringBuilder builder = new SpannableStringBuilder(); |
| for (Segment segment : preedit.getSegmentList()) { |
| builder.append(segment.getValue()); |
| } |
| |
| // Set underline for all the preedit text. |
| builder.setSpan(SPAN_UNDERLINE, 0, builder.length(), Spanned.SPAN_EXCLUSIVE_EXCLUSIVE); |
| |
| // Draw cursor if in composition mode. |
| int cursor = preedit.getCursor(); |
| int spanFlags = Spanned.SPAN_EXCLUSIVE_EXCLUSIVE | Spanned.SPAN_COMPOSING; |
| if (output.hasAllCandidateWords() |
| && output.getAllCandidateWords().hasCategory() |
| && output.getAllCandidateWords().getCategory() == ProtoCandidates.Category.CONVERSION) { |
| int offsetInString = 0; |
| for (Segment segment : preedit.getSegmentList()) { |
| int length = segment.getValue().length(); |
| builder.setSpan( |
| segment.hasAnnotation() && segment.getAnnotation() == Annotation.HIGHLIGHT |
| ? SPAN_CONVERT_HIGHLIGHT |
| : CharacterStyle.class.cast(new BackgroundColorSpan(CONVERT_NORMAL_COLOR)), |
| offsetInString, offsetInString + length, spanFlags); |
| offsetInString += length; |
| } |
| } else { |
| // We cannot show system cursor inside preedit here. |
| // Instead we change text style before the preedit's cursor. |
| int cursorOffsetInString = builder.toString().offsetByCodePoints(0, cursor); |
| if (cursor != builder.length()) { |
| builder.setSpan(SPAN_PARTIAL_SUGGESTION_COLOR, cursorOffsetInString, builder.length(), |
| spanFlags); |
| } |
| if (cursor > 0) { |
| builder.setSpan(SPAN_BEFORE_CURSOR, 0, cursorOffsetInString, spanFlags); |
| } |
| } |
| |
| // System cursor will be moved to the tail of preedit. |
| // It triggers onUpdateSelection again. |
| int cursorPosition = cursor > 0 ? MozcUtil.CURSOR_POSITION_TAIL : 0; |
| if (!inputConnection.setComposingText(builder, cursorPosition)) { |
| MozcLog.e("Failed to set composing text."); |
| } |
| } |
| |
| private void maybeSetSelection(Output output, InputConnection inputConnection) { |
| if (!output.hasPreedit()) { |
| return; |
| } |
| |
| Preedit preedit = output.getPreedit(); |
| int cursor = preedit.getCursor(); |
| if (cursor == 0 || cursor == getPreeditLength(preedit)) { |
| // The cursor is at the beginning/ending of the preedit. So we don't anything about the |
| // caret setting. |
| return; |
| } |
| |
| int caretPosition = selectionTracker.getPreeditStartPosition(); |
| if (output.hasDeletionRange()) { |
| caretPosition += output.getDeletionRange().getOffset(); |
| } |
| if (output.hasResult()) { |
| caretPosition += output.getResult().getValue().length(); |
| } |
| if (output.hasPreedit()) { |
| caretPosition += output.getPreedit().getCursor(); |
| } |
| |
| if (!inputConnection.setSelection(caretPosition, caretPosition)) { |
| MozcLog.e("Failed to set selection."); |
| } |
| } |
| |
| private static int getPreeditLength(Preedit preedit) { |
| int result = 0; |
| for (int i = 0; i < preedit.getSegmentCount(); ++i) { |
| result += preedit.getSegment(i).getValueLength(); |
| } |
| return result; |
| } |
| |
| /** |
| * Propagates the preferences which affect client-side. |
| * |
| * If the previous parameter (this.clientSidePreference) is null, |
| * all the fields in the latest parameter are propagated. |
| * If not, only differences are propagated. |
| * |
| * After the execution, {@code this.propagatedClientSidePreference} is updated. |
| * |
| * @param newPreference the ClientSidePreference to be propagated |
| */ |
| @VisibleForTesting void propagateClientSidePreference(ClientSidePreference newPreference) { |
| // TODO(matsuzakit): Receive a Config to reflect the current device configuration. |
| if (newPreference == null) { |
| MozcLog.e("newPreference must be non-null. No update is performed."); |
| return; |
| } |
| ClientSidePreference oldPreference = propagatedClientSidePreference; |
| if (oldPreference == null |
| || oldPreference.isHapticFeedbackEnabled() != newPreference.isHapticFeedbackEnabled()) { |
| feedbackManager.setHapticFeedbackEnabled(newPreference.isHapticFeedbackEnabled()); |
| } |
| if (oldPreference == null |
| || oldPreference.getHapticFeedbackDuration() != newPreference.getHapticFeedbackDuration()) { |
| feedbackManager.setHapticFeedbackDuration(newPreference.getHapticFeedbackDuration()); |
| } |
| if (oldPreference == null |
| || oldPreference.isSoundFeedbackEnabled() != newPreference.isSoundFeedbackEnabled()) { |
| feedbackManager.setSoundFeedbackEnabled(newPreference.isSoundFeedbackEnabled()); |
| } |
| if (oldPreference == null |
| || oldPreference.getSoundFeedbackVolume() != newPreference.getSoundFeedbackVolume()) { |
| // The default value is 0.4f. In order to set the 50 to the default value, divide the |
| // preference value by 125f heuristically. |
| feedbackManager.setSoundFeedbackVolume(newPreference.getSoundFeedbackVolume() / 125f); |
| } |
| if (oldPreference == null |
| || oldPreference.isPopupFeedbackEnabled() != newPreference.isPopupFeedbackEnabled()) { |
| viewManager.setPopupEnabled(newPreference.isPopupFeedbackEnabled()); |
| } |
| if (oldPreference == null |
| || oldPreference.getKeyboardLayout() != newPreference.getKeyboardLayout()) { |
| viewManager.setKeyboardLayout(newPreference.getKeyboardLayout()); |
| } |
| if (oldPreference == null |
| || oldPreference.getInputStyle() != newPreference.getInputStyle()) { |
| viewManager.setInputStyle(newPreference.getInputStyle()); |
| } |
| if (oldPreference == null |
| || oldPreference.isQwertyLayoutForAlphabet() != newPreference.isQwertyLayoutForAlphabet()) { |
| viewManager.setQwertyLayoutForAlphabet(newPreference.isQwertyLayoutForAlphabet()); |
| } |
| if (oldPreference == null |
| || oldPreference.isFullscreenMode() != newPreference.isFullscreenMode()) { |
| viewManager.setFullscreenMode( |
| applicationCompatibility.isFullScreenModeSupported() && newPreference.isFullscreenMode()); |
| } |
| if (oldPreference == null |
| || oldPreference.getFlickSensitivity() != newPreference.getFlickSensitivity()) { |
| viewManager.setFlickSensitivity(newPreference.getFlickSensitivity()); |
| } |
| if (oldPreference == null |
| || oldPreference.getEmojiProviderType() != newPreference.getEmojiProviderType()) { |
| viewManager.setEmojiProviderType(newPreference.getEmojiProviderType()); |
| } |
| if (oldPreference == null |
| || oldPreference.getHardwareKeyMap() != newPreference.getHardwareKeyMap()) { |
| viewManager.setHardwareKeyMap(newPreference.getHardwareKeyMap()); |
| } |
| if (oldPreference == null |
| || oldPreference.getSkinType() != newPreference.getSkinType()) { |
| viewManager.setSkin(newPreference.getSkinType().getSkin(getResources())); |
| } |
| if (oldPreference == null |
| || oldPreference.isMicrophoneButtonEnabled() != newPreference.isMicrophoneButtonEnabled()) { |
| viewManager.setMicrophoneButtonEnabledByPreference(newPreference.isMicrophoneButtonEnabled()); |
| } |
| if (oldPreference == null |
| || oldPreference.getLayoutAdjustment() != newPreference.getLayoutAdjustment()) { |
| viewManager.setLayoutAdjustment(newPreference.getLayoutAdjustment()); |
| } |
| if (oldPreference == null |
| || oldPreference.getKeyboardHeightRatio() != newPreference.getKeyboardHeightRatio()) { |
| viewManager.setKeyboardHeightRatio(newPreference.getKeyboardHeightRatio()); |
| } |
| |
| propagatedClientSidePreference = newPreference; |
| } |
| |
| /** |
| * Sends imposed config to the Mozc server. |
| * |
| * Some config items should be mobile ones. |
| * For example, "selection shortcut" should be disabled on software keyboard |
| * regardless of stored config if there is no hardware keyboard. |
| */ |
| private void updateImposedConfig() { |
| // TODO(hsumita): Respect Config.SelectionShortcut. |
| SelectionShortcut shortcutMode = (viewManager != null && viewManager.isFloatingCandidateMode()) |
| ? SelectionShortcut.SHORTCUT_123456789 : SelectionShortcut.NO_SHORTCUT; |
| |
| // TODO(matsuzakit): deviceConfig should be used to set following config items. |
| sessionExecutor.setImposedConfig(Config.newBuilder() |
| .setSessionKeymap(SessionKeymap.MOBILE) |
| .setSelectionShortcut(shortcutMode) |
| .setUseEmojiConversion(true) |
| .build()); |
| } |
| |
| /** |
| * A call-back to catch all the change on any preferences. |
| */ |
| private class SharedPreferenceChangeAdapter implements OnSharedPreferenceChangeListener { |
| @Override |
| public void onSharedPreferenceChanged(SharedPreferences sharedPreferences, String key) { |
| if (isDebugBuild) { |
| MozcLog.d("onSharedPreferenceChanged : " + key); |
| } |
| if (key.startsWith(PREF_TWEAK_PREFIX)) { |
| // If the key belongs to PREF_TWEAK group, re-create SessionHandler and view. |
| prepareEveryTime(sharedPreferences, getConfiguration()); |
| setInputView(onCreateInputView()); |
| return; |
| } |
| propagateClientSidePreference( |
| new ClientSidePreference( |
| sharedPreferences, getResources(), getConfiguration().orientation)); |
| sessionExecutor.setConfig(ConfigUtil.toConfig(sharedPreferences)); |
| sessionExecutor.preferenceUsageStatsEvent(sharedPreferences, getResources()); |
| } |
| } |
| |
| @VisibleForTesting void maybeSetNarrowMode(Configuration configuration) { |
| // If given hardKeyboardHidden is equal to current one, skip updating narrow mode. |
| // In other words, only hardKeyboardHidden flag changes narrow mode automatically. |
| // This behavior is beneficial for a user who want to change narrow/full mode manually |
| // because this method keeps current narrow mode unless hardware keyboard connection is changed. |
| if (viewManager != null && configuration.hardKeyboardHidden != currentHardKeyboardHidden) { |
| currentHardKeyboardHidden = configuration.hardKeyboardHidden; |
| switch (currentHardKeyboardHidden) { |
| case Configuration.HARDKEYBOARDHIDDEN_NO: |
| if (!viewManager.isNarrowMode()) { |
| viewManager.hideSubInputView(); |
| viewManager.setNarrowMode(true); |
| } |
| break; |
| case Configuration.HARDKEYBOARDHIDDEN_YES: |
| if (viewManager.isNarrowMode()) { |
| viewManager.setNarrowMode(false); |
| } |
| break; |
| case Configuration.HARDKEYBOARDHIDDEN_UNDEFINED: |
| break; |
| } |
| } |
| } |
| |
| @VisibleForTesting void onConfigurationChangedInternal(Configuration newConfig) { |
| InputConnection inputConnection = getCurrentInputConnection(); |
| if (inputConnection != null) { |
| if (inputBound) { |
| inputConnection.finishComposingText(); |
| } |
| int selectionStart = selectionTracker.getLastSelectionStart(); |
| int selectionEnd = selectionTracker.getLastSelectionEnd(); |
| if (selectionStart >= 0 && selectionEnd >= 0) { |
| // We need to keep the last caret position, but it will be soon overwritten in |
| // onStartInput. Theoretically, we should prohibit the overwriting, but unfortunately |
| // there is no good way to figure out whether the invocation of onStartInput is caused by |
| // configuration change, or not. Thus, instead, we'll make an event to invoke |
| // onUpdateSelectionInternal with an expected position after the onStartInput invocation, |
| // so that it will again overwrite the caret position. |
| // Note that, if a user rotates the device with holding preedit text, it will be committed |
| // by finishComposingText above, and onUpdateSelection will be invoked from the framework. |
| // Invoke onUpdateSelectionInternal twice with same arguments should be safe in this |
| // situation. |
| configurationChangedHandler.sendMessage( |
| configurationChangedHandler.obtainMessage(0, selectionStart, selectionEnd)); |
| } |
| } |
| resetContext(); |
| selectionTracker.onConfigurationChanged(); |
| |
| sessionExecutor.updateRequest( |
| MozcUtil.getRequestBuilder(getResources(), currentKeyboardSpecification, newConfig).build(), |
| Collections.<TouchEvent>emptyList()); |
| |
| // NOTE : This method is not called at the time when the service is started. |
| // Based on newConfig, client side preferences should be sent |
| // because they change based on device config. |
| propagateClientSidePreference(new ClientSidePreference( |
| Preconditions.checkNotNull(PreferenceManager.getDefaultSharedPreferences(this)), |
| getResources(), newConfig.orientation)); |
| maybeSetNarrowMode(newConfig); |
| viewManager.onConfigurationChanged(newConfig); |
| } |
| |
| @Override |
| public void onConfigurationChanged(Configuration newConfig) { |
| onConfigurationChangedInternal(newConfig); |
| // super.onConfigurationChanged must be called after propagateClientSidePreference |
| // to use updated MobileConfiguration. |
| super.onConfigurationChanged(newConfig); |
| } |
| |
| @VisibleForTesting |
| void onUpdateSelectionInternal(int oldSelStart, int oldSelEnd, |
| int newSelStart, int newSelEnd, |
| int candidatesStart, int candidatesEnd) { |
| MozcLog.d("start MozcService#onUpdateSelectionInternal " + System.nanoTime()); |
| if (isDebugBuild) { |
| MozcLog.d("selection updated: [" + oldSelStart + ":" + oldSelEnd + "] " |
| + "to: [" + newSelStart + ":" + newSelEnd + "] " |
| + "candidates: [" + candidatesStart + ":" + candidatesEnd + "]"); |
| } |
| |
| int updateStatus = selectionTracker.onUpdateSelection( |
| oldSelStart, oldSelEnd, newSelStart, newSelEnd, candidatesStart, candidatesEnd); |
| if (isDebugBuild) { |
| MozcLog.d(selectionTracker.toString()); |
| } |
| switch (updateStatus) { |
| case SelectionTracker.DO_NOTHING: |
| // Do nothing. |
| break; |
| case SelectionTracker.RESET_CONTEXT: { |
| sessionExecutor.resetContext(); |
| |
| // Commit the current composing text (preedit text), in case we hit an unknown state. |
| // Keeping the composing text sometimes makes it impossible for users to input characters, |
| // because it can cause consecutive mis-understanding of caret positions. |
| // We do this iff the keyboard is shown, because some other application may edit |
| // composition string, such as Google Translate. |
| if (isInputViewShown() && inputBound) { |
| InputConnection inputConnection = getCurrentInputConnection(); |
| if (inputConnection != null) { |
| inputConnection.finishComposingText(); |
| } |
| } |
| |
| // Rendering default Command causes hiding candidate window, |
| // and re-showing the keyboard view. |
| viewManager.render(Command.getDefaultInstance()); |
| break; |
| } |
| default: |
| // Otherwise, the updateStatus is the position of the cursor to be moved. |
| if (updateStatus < 0) { |
| throw new AssertionError("Unknown update status: " + updateStatus); |
| } |
| sessionExecutor.moveCursor(updateStatus, renderResultCallback); |
| break; |
| } |
| |
| MozcLog.d("end MozcService#onUpdateSelectionInternal " + System.nanoTime()); |
| } |
| |
| @Override |
| public void onUpdateSelection(int oldSelStart, int oldSelEnd, |
| int newSelStart, int newSelEnd, |
| int candidatesStart, int candidatesEnd) { |
| onUpdateSelectionInternal( |
| oldSelStart, oldSelEnd, newSelStart, newSelEnd, candidatesStart, candidatesEnd); |
| super.onUpdateSelection( |
| oldSelStart, oldSelEnd, newSelStart, newSelEnd, candidatesStart, candidatesEnd); |
| } |
| |
| private void trimMemory() { |
| // We must guarantee the contract of MemoryManageable#trimMemory. |
| if (!isInputViewShown()) { |
| MozcLog.d("Trimming memory"); |
| sessionExecutor.deleteSession(); |
| viewManager.trimMemory(); |
| } |
| } |
| |
| // To use special Configuration for testing, overriding this method might works. |
| @VisibleForTesting |
| Configuration getConfiguration() { |
| return getResources().getConfiguration(); |
| } |
| |
| @VisibleForTesting |
| ViewEventListener getViewEventListener() { |
| return eventListener; |
| } |
| |
| @Override |
| @VisibleForTesting |
| public void attachBaseContext(Context base) { |
| super.attachBaseContext(base); |
| } |
| } |
