/*
|
* Copyright (C) 2007 The Android Open Source Project
|
*
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
* you may not use this file except in compliance with the License.
|
* You may obtain a copy of the License at
|
*
|
* http://www.apache.org/licenses/LICENSE-2.0
|
*
|
* Unless required by applicable law or agreed to in writing, software
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
* See the License for the specific language governing permissions and
|
* limitations under the License.
|
*/
|
|
package android.text.method;
|
|
import android.content.ContentResolver;
|
import android.content.Context;
|
import android.database.ContentObserver;
|
import android.os.Handler;
|
import android.provider.Settings;
|
import android.provider.Settings.System;
|
import android.text.Editable;
|
import android.text.InputType;
|
import android.text.NoCopySpan;
|
import android.text.Selection;
|
import android.text.SpanWatcher;
|
import android.text.Spannable;
|
import android.text.TextUtils;
|
import android.view.KeyCharacterMap;
|
import android.view.KeyEvent;
|
import android.view.View;
|
|
import java.lang.ref.WeakReference;
|
|
/**
|
* This is the key listener for typing normal text. It delegates to
|
* other key listeners appropriate to the current keyboard and language.
|
* <p></p>
|
* As for all implementations of {@link KeyListener}, this class is only concerned
|
* with hardware keyboards. Software input methods have no obligation to trigger
|
* the methods in this class.
|
*/
|
public class TextKeyListener extends BaseKeyListener implements SpanWatcher {
|
private static TextKeyListener[] sInstance =
|
new TextKeyListener[Capitalize.values().length * 2];
|
|
/* package */ static final Object ACTIVE = new NoCopySpan.Concrete();
|
/* package */ static final Object CAPPED = new NoCopySpan.Concrete();
|
/* package */ static final Object INHIBIT_REPLACEMENT = new NoCopySpan.Concrete();
|
/* package */ static final Object LAST_TYPED = new NoCopySpan.Concrete();
|
|
private Capitalize mAutoCap;
|
private boolean mAutoText;
|
|
private int mPrefs;
|
private boolean mPrefsInited;
|
|
/* package */ static final int AUTO_CAP = 1;
|
/* package */ static final int AUTO_TEXT = 2;
|
/* package */ static final int AUTO_PERIOD = 4;
|
/* package */ static final int SHOW_PASSWORD = 8;
|
private WeakReference<ContentResolver> mResolver;
|
private TextKeyListener.SettingsObserver mObserver;
|
|
/**
|
* Creates a new TextKeyListener with the specified capitalization
|
* and correction properties.
|
*
|
* @param cap when, if ever, to automatically capitalize.
|
* @param autotext whether to automatically do spelling corrections.
|
*/
|
public TextKeyListener(Capitalize cap, boolean autotext) {
|
mAutoCap = cap;
|
mAutoText = autotext;
|
}
|
|
/**
|
* Returns a new or existing instance with the specified capitalization
|
* and correction properties.
|
*
|
* @param cap when, if ever, to automatically capitalize.
|
* @param autotext whether to automatically do spelling corrections.
|
*/
|
public static TextKeyListener getInstance(boolean autotext,
|
Capitalize cap) {
|
int off = cap.ordinal() * 2 + (autotext ? 1 : 0);
|
|
if (sInstance[off] == null) {
|
sInstance[off] = new TextKeyListener(cap, autotext);
|
}
|
|
return sInstance[off];
|
}
|
|
/**
|
* Returns a new or existing instance with no automatic capitalization
|
* or correction.
|
*/
|
public static TextKeyListener getInstance() {
|
return getInstance(false, Capitalize.NONE);
|
}
|
|
/**
|
* Returns whether it makes sense to automatically capitalize at the
|
* specified position in the specified text, with the specified rules.
|
*
|
* @param cap the capitalization rules to consider.
|
* @param cs the text in which an insertion is being made.
|
* @param off the offset into that text where the insertion is being made.
|
*
|
* @return whether the character being inserted should be capitalized.
|
*/
|
public static boolean shouldCap(Capitalize cap, CharSequence cs, int off) {
|
int i;
|
char c;
|
|
if (cap == Capitalize.NONE) {
|
return false;
|
}
|
if (cap == Capitalize.CHARACTERS) {
|
return true;
|
}
|
|
return TextUtils.getCapsMode(cs, off, cap == Capitalize.WORDS
|
? TextUtils.CAP_MODE_WORDS : TextUtils.CAP_MODE_SENTENCES)
|
!= 0;
|
}
|
|
public int getInputType() {
|
return makeTextContentType(mAutoCap, mAutoText);
|
}
|
|
@Override
|
public boolean onKeyDown(View view, Editable content,
|
int keyCode, KeyEvent event) {
|
KeyListener im = getKeyListener(event);
|
|
return im.onKeyDown(view, content, keyCode, event);
|
}
|
|
@Override
|
public boolean onKeyUp(View view, Editable content,
|
int keyCode, KeyEvent event) {
|
KeyListener im = getKeyListener(event);
|
|
return im.onKeyUp(view, content, keyCode, event);
|
}
|
|
@Override
|
public boolean onKeyOther(View view, Editable content, KeyEvent event) {
|
KeyListener im = getKeyListener(event);
|
|
return im.onKeyOther(view, content, event);
|
}
|
|
/**
|
* Clear all the input state (autotext, autocap, multitap, undo)
|
* from the specified Editable, going beyond Editable.clear(), which
|
* just clears the text but not the input state.
|
*
|
* @param e the buffer whose text and state are to be cleared.
|
*/
|
public static void clear(Editable e) {
|
e.clear();
|
e.removeSpan(ACTIVE);
|
e.removeSpan(CAPPED);
|
e.removeSpan(INHIBIT_REPLACEMENT);
|
e.removeSpan(LAST_TYPED);
|
|
QwertyKeyListener.Replaced[] repl = e.getSpans(0, e.length(),
|
QwertyKeyListener.Replaced.class);
|
final int count = repl.length;
|
for (int i = 0; i < count; i++) {
|
e.removeSpan(repl[i]);
|
}
|
}
|
|
public void onSpanAdded(Spannable s, Object what, int start, int end) { }
|
public void onSpanRemoved(Spannable s, Object what, int start, int end) { }
|
|
public void onSpanChanged(Spannable s, Object what, int start, int end,
|
int st, int en) {
|
if (what == Selection.SELECTION_END) {
|
s.removeSpan(ACTIVE);
|
}
|
}
|
|
private KeyListener getKeyListener(KeyEvent event) {
|
KeyCharacterMap kmap = event.getKeyCharacterMap();
|
int kind = kmap.getKeyboardType();
|
|
if (kind == KeyCharacterMap.ALPHA) {
|
return QwertyKeyListener.getInstance(mAutoText, mAutoCap);
|
} else if (kind == KeyCharacterMap.NUMERIC) {
|
return MultiTapKeyListener.getInstance(mAutoText, mAutoCap);
|
} else if (kind == KeyCharacterMap.FULL
|
|| kind == KeyCharacterMap.SPECIAL_FUNCTION) {
|
// We consider special function keyboards full keyboards as a workaround for
|
// devices that do not have built-in keyboards. Applications may try to inject
|
// key events using the built-in keyboard device id which may be configured as
|
// a special function keyboard using a default key map. Ideally, as of Honeycomb,
|
// these applications should be modified to use KeyCharacterMap.VIRTUAL_KEYBOARD.
|
return QwertyKeyListener.getInstanceForFullKeyboard();
|
}
|
|
return NullKeyListener.getInstance();
|
}
|
|
public enum Capitalize {
|
NONE, SENTENCES, WORDS, CHARACTERS,
|
}
|
|
private static class NullKeyListener implements KeyListener
|
{
|
public int getInputType() {
|
return InputType.TYPE_NULL;
|
}
|
|
public boolean onKeyDown(View view, Editable content,
|
int keyCode, KeyEvent event) {
|
return false;
|
}
|
|
public boolean onKeyUp(View view, Editable content, int keyCode,
|
KeyEvent event) {
|
return false;
|
}
|
|
public boolean onKeyOther(View view, Editable content, KeyEvent event) {
|
return false;
|
}
|
|
public void clearMetaKeyState(View view, Editable content, int states) {
|
}
|
|
public static NullKeyListener getInstance() {
|
if (sInstance != null)
|
return sInstance;
|
|
sInstance = new NullKeyListener();
|
return sInstance;
|
}
|
|
private static NullKeyListener sInstance;
|
}
|
|
public void release() {
|
if (mResolver != null) {
|
final ContentResolver contentResolver = mResolver.get();
|
if (contentResolver != null) {
|
contentResolver.unregisterContentObserver(mObserver);
|
mResolver.clear();
|
}
|
mObserver = null;
|
mResolver = null;
|
mPrefsInited = false;
|
}
|
}
|
|
private void initPrefs(Context context) {
|
final ContentResolver contentResolver = context.getContentResolver();
|
mResolver = new WeakReference<ContentResolver>(contentResolver);
|
if (mObserver == null) {
|
mObserver = new SettingsObserver();
|
contentResolver.registerContentObserver(Settings.System.CONTENT_URI, true, mObserver);
|
}
|
|
updatePrefs(contentResolver);
|
mPrefsInited = true;
|
}
|
|
private class SettingsObserver extends ContentObserver {
|
public SettingsObserver() {
|
super(new Handler());
|
}
|
|
@Override
|
public void onChange(boolean selfChange) {
|
if (mResolver != null) {
|
final ContentResolver contentResolver = mResolver.get();
|
if (contentResolver == null) {
|
mPrefsInited = false;
|
} else {
|
updatePrefs(contentResolver);
|
}
|
} else {
|
mPrefsInited = false;
|
}
|
}
|
}
|
|
private void updatePrefs(ContentResolver resolver) {
|
boolean cap = System.getInt(resolver, System.TEXT_AUTO_CAPS, 1) > 0;
|
boolean text = System.getInt(resolver, System.TEXT_AUTO_REPLACE, 1) > 0;
|
boolean period = System.getInt(resolver, System.TEXT_AUTO_PUNCTUATE, 1) > 0;
|
boolean pw = System.getInt(resolver, System.TEXT_SHOW_PASSWORD, 1) > 0;
|
|
mPrefs = (cap ? AUTO_CAP : 0) |
|
(text ? AUTO_TEXT : 0) |
|
(period ? AUTO_PERIOD : 0) |
|
(pw ? SHOW_PASSWORD : 0);
|
}
|
|
/* package */ int getPrefs(Context context) {
|
synchronized (this) {
|
if (!mPrefsInited || mResolver.get() == null) {
|
initPrefs(context);
|
}
|
}
|
|
return mPrefs;
|
}
|
}
|
