nyancrimew/LatinIME
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity

am 5eac728b: [CB06] Fix a design error.

Browse source 
* commit '5eac728b4aba43b8f4dabbb0dbc50acdbaaa5f22':
  [CB06] Fix a design error.
This commit is contained in:
Jean Chalard 2014-03-17 05:59:19 -07:00 committed by Android Git Automerger
commit 85657a39c9
6 changed files with 35 additions and 146 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
java/src/com/android/inputmethod/event/Event.java
View file

@ -168,4 +168,8 @@ public class Event {
public boolean isCommittable() {
return EVENT_INPUT_KEYPRESS == mType || EVENT_MODE_KEY == mType || EVENT_TOGGLE == mType;
}
public boolean isHandled() {
return EVENT_NOT_HANDLED != mType;
}
}

81
java/src/com/android/inputmethod/event/EventInterpreter.java
View file

@ -16,11 +16,6 @@
package com.android.inputmethod.event;
import android.util.SparseArray;
import android.view.KeyEvent;
import com.android.inputmethod.latin.Constants;
import com.android.inputmethod.latin.LatinIME;
import com.android.inputmethod.latin.utils.CollectionUtils;
import java.util.ArrayList;
@ -37,25 +32,9 @@ public class EventInterpreter {
// TODO: Implement an object pool for events, as we'll create a lot of them
// TODO: Create a combiner
// TODO: Create an object type to represent input material + visual feedback + decoding state
// TODO: Create an interface to call back to Latin IME through the above object
final EventDecoderSpec mDecoderSpec;
final SparseArray<HardwareEventDecoder> mHardwareEventDecoders;
final SoftwareEventDecoder mSoftwareEventDecoder;
final LatinIME mLatinIme;
final ArrayList<Combiner> mCombiners;
/**
* Create a default interpreter.
*
* This creates a default interpreter that does nothing. A default interpreter should normally
* only be used for fallback purposes, when we really don't know what we want to do with input.
*
* @param latinIme a reference to the ime.
*/
public EventInterpreter(final LatinIME latinIme) {
this(null, latinIme);
}
private final EventDecoderSpec mDecoderSpec;
private final ArrayList<Combiner> mCombiners;
/**
* Create an event interpreter according to a specification.
@ -70,64 +49,10 @@ public class EventInterpreter {
* interpreter that does no specific combining, and assumes the most common cases.
*
* @param specification the specification for event interpretation. null for default.
* @param latinIme a reference to the ime.
*/
public EventInterpreter(final EventDecoderSpec specification, final LatinIME latinIme) {
public EventInterpreter(final EventDecoderSpec specification) {
mDecoderSpec = null != specification ? specification : new EventDecoderSpec();
// For both, we expect to have only one decoder in almost all cases, hence the default
// capacity of 1.
mHardwareEventDecoders = new SparseArray<HardwareEventDecoder>(1);
mSoftwareEventDecoder = new SoftwareKeyboardEventDecoder();
mCombiners = CollectionUtils.newArrayList();
mCombiners.add(new DeadKeyCombiner());
mLatinIme = latinIme;
}
// Helper method to decode a hardware key event into a generic event, and execute any
// necessary action.
public boolean onHardwareKeyEvent(final KeyEvent hardwareKeyEvent) {
final Event decodedEvent = getHardwareKeyEventDecoder(hardwareKeyEvent.getDeviceId())
.decodeHardwareKey(hardwareKeyEvent);
return onEvent(decodedEvent);
}
public boolean onSoftwareEvent() {
final Event decodedEvent = getSoftwareEventDecoder().decodeSoftwareEvent();
return onEvent(decodedEvent);
}
private HardwareEventDecoder getHardwareKeyEventDecoder(final int deviceId) {
final HardwareEventDecoder decoder = mHardwareEventDecoders.get(deviceId);
if (null != decoder) return decoder;
// TODO: create the decoder according to the specification
final HardwareEventDecoder newDecoder = new HardwareKeyboardEventDecoder(deviceId);
mHardwareEventDecoders.put(deviceId, newDecoder);
return newDecoder;
}
private SoftwareEventDecoder getSoftwareEventDecoder() {
// Within the context of Latin IME, since we never present several software interfaces
// at the time, we should never need multiple software event decoders at a time.
return mSoftwareEventDecoder;
}
private boolean onEvent(final Event event) {
Event currentlyProcessingEvent = event;
boolean processed = false;
for (int i = 0; i < mCombiners.size(); ++i) {
currentlyProcessingEvent = mCombiners.get(i).combine(event);
}
while (null != currentlyProcessingEvent) {
if (currentlyProcessingEvent.isCommittable()) {
mLatinIme.onCodeInput(currentlyProcessingEvent.mCodePoint,
Constants.EXTERNAL_KEYBOARD_COORDINATE,
Constants.EXTERNAL_KEYBOARD_COORDINATE);
processed = true;
} else if (event.isDead()) {
processed = true;
}
currentlyProcessingEvent = currentlyProcessingEvent.mNextEvent;
}
return processed;
}
}

29
java/src/com/android/inputmethod/event/SoftwareEventDecoder.java
View file

@ -1,29 +0,0 @@
/*
* Copyright (C) 2012 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.event;
/**
* An event decoder for events out of a software keyboard.
*
* This defines the interface for an event decoder that supports events out of a software keyboard.
* This differs significantly from hardware keyboard event decoders in several respects. First,
* a software keyboard does not have a scancode/layout system; the keypresses that insert
* characters output unicode characters directly.
*/
public interface SoftwareEventDecoder extends EventDecoder {
public Event decodeSoftwareEvent();
}

27
java/src/com/android/inputmethod/event/SoftwareKeyboardEventDecoder.java
View file

@ -1,27 +0,0 @@
/*
* Copyright (C) 2012 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.event;
/**
* A decoder for events from software keyboard, like the ones displayed by Latin IME.
*/
public class SoftwareKeyboardEventDecoder implements SoftwareEventDecoder {
@Override
public Event decodeSoftwareEvent() {
return null;
}
}

37
java/src/com/android/inputmethod/latin/LatinIME.java
View file

@ -45,6 +45,7 @@ import android.text.TextUtils;
import android.util.Log;
import android.util.PrintWriterPrinter;
import android.util.Printer;
import android.util.SparseArray;
import android.view.KeyEvent;
import android.view.View;
import android.view.ViewGroup.LayoutParams;
@ -60,6 +61,8 @@ import com.android.inputmethod.annotations.UsedForTesting;
import com.android.inputmethod.compat.InputMethodServiceCompatUtils;
import com.android.inputmethod.dictionarypack.DictionaryPackConstants;
import com.android.inputmethod.event.Event;
import com.android.inputmethod.event.HardwareEventDecoder;
import com.android.inputmethod.event.HardwareKeyboardEventDecoder;
import com.android.inputmethod.event.InputTransaction;
import com.android.inputmethod.keyboard.Keyboard;
import com.android.inputmethod.keyboard.KeyboardActionListener;
@ -120,6 +123,10 @@ public class LatinIME extends InputMethodService implements KeyboardActionListen
private final Settings mSettings;
private final InputLogic mInputLogic = new InputLogic(this /* LatinIME */,
this /* SuggestionStripViewAccessor */);
// We expect to have only one decoder in almost all cases, hence the default capacity of 1.
// If it turns out we need several, it will get grown seamlessly.
final SparseArray<HardwareEventDecoder> mHardwareEventDecoders
= new SparseArray<HardwareEventDecoder>(1);
private View mExtractArea;
private View mKeyPreviewBackingView;
@ -1588,19 +1595,31 @@ public class LatinIME extends InputMethodService implements KeyboardActionListen
}
}
private HardwareEventDecoder getHardwareKeyEventDecoder(final int deviceId) {
final HardwareEventDecoder decoder = mHardwareEventDecoders.get(deviceId);
if (null != decoder) return decoder;
// TODO: create the decoder according to the specification
final HardwareEventDecoder newDecoder = new HardwareKeyboardEventDecoder(deviceId);
mHardwareEventDecoders.put(deviceId, newDecoder);
return newDecoder;
}
// Hooks for hardware keyboard
@Override
public boolean onKeyDown(final int keyCode, final KeyEvent event) {
if (!ProductionFlag.IS_HARDWARE_KEYBOARD_SUPPORTED) return super.onKeyDown(keyCode, event);
// onHardwareKeyEvent, like onKeyDown returns true if it handled the event, false if
// it doesn't know what to do with it and leave it to the application. For example,
// hardware key events for adjusting the screen's brightness are passed as is.
if (mInputLogic.mEventInterpreter.onHardwareKeyEvent(event)) {
final long keyIdentifier = event.getDeviceId() << 32 + event.getKeyCode();
mInputLogic.mCurrentlyPressedHardwareKeys.add(keyIdentifier);
public boolean onKeyDown(final int keyCode, final KeyEvent keyEvent) {
if (!ProductionFlag.IS_HARDWARE_KEYBOARD_SUPPORTED) {
return super.onKeyDown(keyCode, keyEvent);
}
final Event event = getHardwareKeyEventDecoder(
keyEvent.getDeviceId()).decodeHardwareKey(keyEvent);
// If the event is not handled by LatinIME, we just pass it to the parent implementation.
// If it's handled, we return true because we did handle it.
if (event.isHandled()) {
mInputLogic.onCodeInput(mSettings.getCurrent(), event,
mKeyboardSwitcher.getKeyboardShiftMode(), mHandler);
return true;
}
return super.onKeyDown(keyCode, event);
return super.onKeyDown(keyCode, keyEvent);
}
@Override

3
java/src/com/android/inputmethod/latin/inputlogic/InputLogic.java
View file

@ -80,8 +80,6 @@ public final class InputLogic {
public SuggestedWords mSuggestedWords = SuggestedWords.EMPTY;
// TODO: mSuggest should be touched by a single thread.
public volatile Suggest mSuggest;
// The event interpreter should never be null.
public final EventInterpreter mEventInterpreter;
public LastComposedWord mLastComposedWord = LastComposedWord.NOT_A_COMPOSED_WORD;
public final WordComposer mWordComposer;
@ -104,7 +102,6 @@ public final class InputLogic {
mLatinIME = latinIME;
mSuggestionStripViewAccessor = suggestionStripViewAccessor;
mWordComposer = new WordComposer();
mEventInterpreter = new EventInterpreter(latinIME);
mConnection = new RichInputConnection(latinIME);
mInputLogicHandler = InputLogicHandler.NULL_HANDLER;
}