Remove unused classes from com.android.internal.widget (da1acefc) · Commits · e / os / android_frameworks_base

compiled-classes-phone

+0 −4

Original line number	Diff line number	Diff line
		@@ -5998,10 +5998,6 @@ com.android.internal.widget.LockPatternUtils$StrongAuthTracker$H
		com.android.internal.widget.MediaNotificationView
		com.android.internal.widget.NotificationActionListLayout
		com.android.internal.widget.NotificationActionListLayout$-void__clinit___LambdaImpl0
		com.android.internal.widget.PasswordEntryKeyboard
		com.android.internal.widget.PasswordEntryKeyboard$LatinKey
		com.android.internal.widget.PasswordEntryKeyboardHelper
		com.android.internal.widget.PasswordEntryKeyboardView
		com.android.internal.widget.PreferenceImageView
		com.android.internal.widget.ResolverDrawerLayout
		com.android.internal.widget.ResolverDrawerLayout$1

core/java/com/android/internal/widget/PasswordEntryKeyboard.java

deleted100644 → 0

+0 −267

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2010 Google Inc.
		*
		* 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.internal.widget;

		import android.content.Context;
		import android.content.res.Resources;
		import android.content.res.XmlResourceParser;
		import android.graphics.drawable.Drawable;
		import android.inputmethodservice.Keyboard;
		import android.inputmethodservice.KeyboardView;
		import com.android.internal.R;

		/**
		* A basic, embed-able keyboard designed for password entry. Allows entry of all Latin-1 characters.
		*
		* It has two modes: alpha and numeric. In alpha mode, it allows all Latin-1 characters and enables
		* an additional keyboard with symbols. In numeric mode, it shows a 12-key DTMF dialer-like
		* keypad with alpha characters hints.
		*/
		public class PasswordEntryKeyboard extends Keyboard {
		private static final int SHIFT_OFF = 0;
		private static final int SHIFT_ON = 1;
		private static final int SHIFT_LOCKED = 2;
		public static final int KEYCODE_SPACE = ' ';

		private Drawable mShiftIcon;
		private Drawable mShiftLockIcon;

		// These two arrays must be the same length
		private Drawable[] mOldShiftIcons = { null, null };
		private Key[] mShiftKeys = { null, null };

		private Key mEnterKey;
		private Key mF1Key;
		private Key mSpaceKey;
		private int mShiftState = SHIFT_OFF;

		static int sSpacebarVerticalCorrection;

		public PasswordEntryKeyboard(Context context, int xmlLayoutResId) {
		this(context, xmlLayoutResId, 0);
		}

		public PasswordEntryKeyboard(Context context, int xmlLayoutResId, int width, int height) {
		this(context, xmlLayoutResId, 0, width, height);
		}

		public PasswordEntryKeyboard(Context context, int xmlLayoutResId, int mode) {
		super(context, xmlLayoutResId, mode);
		init(context);
		}

		public PasswordEntryKeyboard(Context context, int xmlLayoutResId, int mode,
		int width, int height) {
		super(context, xmlLayoutResId, mode, width, height);
		init(context);
		}

		private void init(Context context) {
		final Resources res = context.getResources();
		mShiftIcon = context.getDrawable(R.drawable.sym_keyboard_shift);
		mShiftLockIcon = context.getDrawable(R.drawable.sym_keyboard_shift_locked);
		sSpacebarVerticalCorrection = res.getDimensionPixelOffset(
		R.dimen.password_keyboard_spacebar_vertical_correction);
		}

		public PasswordEntryKeyboard(Context context, int layoutTemplateResId,
		CharSequence characters, int columns, int horizontalPadding) {
		super(context, layoutTemplateResId, characters, columns, horizontalPadding);
		}

		@Override
		protected Key createKeyFromXml(Resources res, Row parent, int x, int y,
		XmlResourceParser parser) {
		LatinKey key = new LatinKey(res, parent, x, y, parser);
		final int code = key.codes[0];
		if (code >=0 && code != '\n' && (code < 32 \|\| code > 127)) {
		// Log.w(TAG, "Key code for " + key.label + " is not latin-1");
		key.label = " ";
		key.setEnabled(false);
		}
		switch (key.codes[0]) {
		case 10:
		mEnterKey = key;
		break;
		case PasswordEntryKeyboardView.KEYCODE_F1:
		mF1Key = key;
		break;
		case 32:
		mSpaceKey = key;
		break;
		}
		return key;
		}

		/**
		* Allows enter key resources to be overridden
		* @param res resources to grab given items from
		* @param previewId preview drawable shown on enter key
		* @param iconId normal drawable shown on enter key
		* @param labelId string shown on enter key
		*/
		void setEnterKeyResources(Resources res, int previewId, int iconId, int labelId) {
		if (mEnterKey != null) {
		// Reset some of the rarely used attributes.
		mEnterKey.popupCharacters = null;
		mEnterKey.popupResId = 0;
		mEnterKey.text = null;

		mEnterKey.iconPreview = res.getDrawable(previewId);
		mEnterKey.icon = res.getDrawable(iconId);
		mEnterKey.label = res.getText(labelId);

		// Set the initial size of the preview icon
		if (mEnterKey.iconPreview != null) {
		mEnterKey.iconPreview.setBounds(0, 0,
		mEnterKey.iconPreview.getIntrinsicWidth(),
		mEnterKey.iconPreview.getIntrinsicHeight());
		}
		}
		}

		/**
		* Allows shiftlock to be turned on. See {@link #setShiftLocked(boolean)}
		*
		*/
		void enableShiftLock() {
		int i = 0;
		for (int index : getShiftKeyIndices()) {
		if (index >= 0 && i < mShiftKeys.length) {
		mShiftKeys[i] = getKeys().get(index);
		if (mShiftKeys[i] instanceof LatinKey) {
		((LatinKey)mShiftKeys[i]).enableShiftLock();
		}
		mOldShiftIcons[i] = mShiftKeys[i].icon;
		i++;
		}
		}
		}

		/**
		* Turn on shift lock. This turns on the LED for this key, if it has one.
		* It should be followed by a call to {@link KeyboardView#invalidateKey(int)}
		* or {@link KeyboardView#invalidateAllKeys()}
		*
		* @param shiftLocked
		*/
		void setShiftLocked(boolean shiftLocked) {
		for (Key shiftKey : mShiftKeys) {
		if (shiftKey != null) {
		shiftKey.on = shiftLocked;
		shiftKey.icon = mShiftLockIcon;
		}
		}
		mShiftState = shiftLocked ? SHIFT_LOCKED : SHIFT_ON;
		}

		/**
		* Turn on shift mode. Sets shift mode and turns on icon for shift key.
		* It should be followed by a call to {@link KeyboardView#invalidateKey(int)}
		* or {@link KeyboardView#invalidateAllKeys()}
		*
		* @param shiftLocked
		*/
		@Override
		public boolean setShifted(boolean shiftState) {
		boolean shiftChanged = false;
		if (shiftState == false) {
		shiftChanged = mShiftState != SHIFT_OFF;
		mShiftState = SHIFT_OFF;
		} else if (mShiftState == SHIFT_OFF) {
		shiftChanged = mShiftState == SHIFT_OFF;
		mShiftState = SHIFT_ON;
		}
		for (int i = 0; i < mShiftKeys.length; i++) {
		if (mShiftKeys[i] != null) {
		if (shiftState == false) {
		mShiftKeys[i].on = false;
		mShiftKeys[i].icon = mOldShiftIcons[i];
		} else if (mShiftState == SHIFT_OFF) {
		mShiftKeys[i].on = false;
		mShiftKeys[i].icon = mShiftIcon;
		}
		} else {
		// return super.setShifted(shiftState);
		}
		}
		return shiftChanged;
		}

		/**
		* Whether or not keyboard is shifted.
		* @return true if keyboard state is shifted.
		*/
		@Override
		public boolean isShifted() {
		if (mShiftKeys[0] != null) {
		return mShiftState != SHIFT_OFF;
		} else {
		return super.isShifted();
		}
		}

		static class LatinKey extends Keyboard.Key {
		private boolean mShiftLockEnabled;
		private boolean mEnabled = true;

		public LatinKey(Resources res, Keyboard.Row parent, int x, int y,
		XmlResourceParser parser) {
		super(res, parent, x, y, parser);
		if (popupCharacters != null && popupCharacters.length() == 0) {
		// If there is a keyboard with no keys specified in popupCharacters
		popupResId = 0;
		}
		}

		void setEnabled(boolean enabled) {
		mEnabled = enabled;
		}

		void enableShiftLock() {
		mShiftLockEnabled = true;
		}

		@Override
		public void onReleased(boolean inside) {
		if (!mShiftLockEnabled) {
		super.onReleased(inside);
		} else {
		pressed = !pressed;
		}
		}

		/**
		* Overriding this method so that we can reduce the target area for certain keys.
		*/
		@Override
		public boolean isInside(int x, int y) {
		if (!mEnabled) {
		return false;
		}
		final int code = codes[0];
		if (code == KEYCODE_SHIFT \|\| code == KEYCODE_DELETE) {
		y -= height / 10;
		if (code == KEYCODE_SHIFT) x += width / 6;
		if (code == KEYCODE_DELETE) x -= width / 6;
		} else if (code == KEYCODE_SPACE) {
		y += PasswordEntryKeyboard.sSpacebarVerticalCorrection;
		}
		return super.isInside(x, y);
		}
		}
		}

core/java/com/android/internal/widget/PasswordEntryKeyboardHelper.java

deleted100644 → 0

+0 −340

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2010 Google Inc.
		*
		* 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.internal.widget;

		import android.content.Context;
		import android.content.res.Resources;
		import android.inputmethodservice.Keyboard;
		import android.inputmethodservice.KeyboardView;
		import android.inputmethodservice.KeyboardView.OnKeyboardActionListener;
		import android.os.SystemClock;
		import android.provider.Settings;
		import android.util.Log;
		import android.view.HapticFeedbackConstants;
		import android.view.KeyCharacterMap;
		import android.view.KeyEvent;
		import android.view.View;
		import android.view.ViewGroup;
		import android.view.ViewGroup.LayoutParams;
		import android.view.ViewRootImpl;
		import com.android.internal.R;

		public class PasswordEntryKeyboardHelper implements OnKeyboardActionListener {

		public static final int KEYBOARD_MODE_ALPHA = 0;
		public static final int KEYBOARD_MODE_NUMERIC = 1;
		private static final int KEYBOARD_STATE_NORMAL = 0;
		private static final int KEYBOARD_STATE_SHIFTED = 1;
		private static final int KEYBOARD_STATE_CAPSLOCK = 2;
		private static final String TAG = "PasswordEntryKeyboardHelper";
		private int mKeyboardMode = KEYBOARD_MODE_ALPHA;
		private int mKeyboardState = KEYBOARD_STATE_NORMAL;
		private PasswordEntryKeyboard mQwertyKeyboard;
		private PasswordEntryKeyboard mQwertyKeyboardShifted;
		private PasswordEntryKeyboard mSymbolsKeyboard;
		private PasswordEntryKeyboard mSymbolsKeyboardShifted;
		private PasswordEntryKeyboard mNumericKeyboard;
		private final Context mContext;
		private final View mTargetView;
		private final KeyboardView mKeyboardView;
		private long[] mVibratePattern;
		private boolean mEnableHaptics = false;

		private static final int NUMERIC = 0;
		private static final int QWERTY = 1;
		private static final int QWERTY_SHIFTED = 2;
		private static final int SYMBOLS = 3;
		private static final int SYMBOLS_SHIFTED = 4;

		int mLayouts[] = new int[] {
		R.xml.password_kbd_numeric,
		R.xml.password_kbd_qwerty,
		R.xml.password_kbd_qwerty_shifted,
		R.xml.password_kbd_symbols,
		R.xml.password_kbd_symbols_shift
		};

		private boolean mUsingScreenWidth;

		public PasswordEntryKeyboardHelper(Context context, KeyboardView keyboardView, View targetView) {
		this(context, keyboardView, targetView, true, null);
		}

		public PasswordEntryKeyboardHelper(Context context, KeyboardView keyboardView, View targetView,
		boolean useFullScreenWidth) {
		this(context, keyboardView, targetView, useFullScreenWidth, null);
		}

		public PasswordEntryKeyboardHelper(Context context, KeyboardView keyboardView, View targetView,
		boolean useFullScreenWidth, int layouts[]) {
		mContext = context;
		mTargetView = targetView;
		mKeyboardView = keyboardView;
		mKeyboardView.setOnKeyboardActionListener(this);
		mUsingScreenWidth = useFullScreenWidth;
		if (layouts != null) {
		if (layouts.length != mLayouts.length) {
		throw new RuntimeException("Wrong number of layouts");
		}
		for (int i = 0; i < mLayouts.length; i++) {
		mLayouts[i] = layouts[i];
		}
		}
		createKeyboards();
		}

		public void createKeyboards() {
		LayoutParams lp = mKeyboardView.getLayoutParams();
		if (mUsingScreenWidth \|\| lp.width == ViewGroup.LayoutParams.MATCH_PARENT) {
		createKeyboardsWithDefaultWidth();
		} else {
		createKeyboardsWithSpecificSize(lp.width, lp.height);
		}
		}

		public void setEnableHaptics(boolean enabled) {
		mEnableHaptics = enabled;
		}

		public boolean isAlpha() {
		return mKeyboardMode == KEYBOARD_MODE_ALPHA;
		}

		private void createKeyboardsWithSpecificSize(int width, int height) {
		mNumericKeyboard = new PasswordEntryKeyboard(mContext, mLayouts[NUMERIC], width, height);
		mQwertyKeyboard = new PasswordEntryKeyboard(mContext, mLayouts[QWERTY], R.id.mode_normal,
		width, height);
		mQwertyKeyboard.enableShiftLock();

		mQwertyKeyboardShifted = new PasswordEntryKeyboard(mContext, mLayouts[QWERTY_SHIFTED],
		R.id.mode_normal, width, height);
		mQwertyKeyboardShifted.enableShiftLock();
		mQwertyKeyboardShifted.setShifted(true); // always shifted.

		mSymbolsKeyboard = new PasswordEntryKeyboard(mContext, mLayouts[SYMBOLS], width, height);
		mSymbolsKeyboard.enableShiftLock();

		mSymbolsKeyboardShifted = new PasswordEntryKeyboard(mContext, mLayouts[SYMBOLS_SHIFTED],
		width, height);
		mSymbolsKeyboardShifted.enableShiftLock();
		mSymbolsKeyboardShifted.setShifted(true); // always shifted
		}

		private void createKeyboardsWithDefaultWidth() {
		mNumericKeyboard = new PasswordEntryKeyboard(mContext, mLayouts[NUMERIC]);
		mQwertyKeyboard = new PasswordEntryKeyboard(mContext, mLayouts[QWERTY], R.id.mode_normal);
		mQwertyKeyboard.enableShiftLock();

		mQwertyKeyboardShifted = new PasswordEntryKeyboard(mContext, mLayouts[QWERTY_SHIFTED],
		R.id.mode_normal);
		mQwertyKeyboardShifted.enableShiftLock();
		mQwertyKeyboardShifted.setShifted(true); // always shifted.

		mSymbolsKeyboard = new PasswordEntryKeyboard(mContext, mLayouts[SYMBOLS]);
		mSymbolsKeyboard.enableShiftLock();

		mSymbolsKeyboardShifted = new PasswordEntryKeyboard(mContext, mLayouts[SYMBOLS_SHIFTED]);
		mSymbolsKeyboardShifted.enableShiftLock();
		mSymbolsKeyboardShifted.setShifted(true); // always shifted
		}

		public void setKeyboardMode(int mode) {
		switch (mode) {
		case KEYBOARD_MODE_ALPHA:
		mKeyboardView.setKeyboard(mQwertyKeyboard);
		mKeyboardState = KEYBOARD_STATE_NORMAL;
		final boolean visiblePassword = Settings.System.getInt(
		mContext.getContentResolver(),
		Settings.System.TEXT_SHOW_PASSWORD, 1) != 0;
		final boolean enablePreview = false; // TODO: grab from configuration
		mKeyboardView.setPreviewEnabled(visiblePassword && enablePreview);
		break;
		case KEYBOARD_MODE_NUMERIC:
		mKeyboardView.setKeyboard(mNumericKeyboard);
		mKeyboardState = KEYBOARD_STATE_NORMAL;
		mKeyboardView.setPreviewEnabled(false); // never show popup for numeric keypad
		break;
		}
		mKeyboardMode = mode;
		}

		private void sendKeyEventsToTarget(int character) {
		ViewRootImpl viewRootImpl = mTargetView.getViewRootImpl();
		KeyEvent[] events = KeyCharacterMap.load(KeyCharacterMap.VIRTUAL_KEYBOARD).getEvents(
		new char[] { (char) character });
		if (events != null) {
		final int N = events.length;
		for (int i=0; i<N; i++) {
		KeyEvent event = events[i];
		event = KeyEvent.changeFlags(event, event.getFlags()
		\| KeyEvent.FLAG_SOFT_KEYBOARD \| KeyEvent.FLAG_KEEP_TOUCH_MODE);
		viewRootImpl.dispatchInputEvent(event);
		}
		}
		}

		public void sendDownUpKeyEvents(int keyEventCode) {
		long eventTime = SystemClock.uptimeMillis();
		ViewRootImpl viewRootImpl = mTargetView.getViewRootImpl();
		viewRootImpl.dispatchKeyFromIme(
		new KeyEvent(eventTime, eventTime, KeyEvent.ACTION_DOWN, keyEventCode, 0, 0,
		KeyCharacterMap.VIRTUAL_KEYBOARD, 0,
		KeyEvent.FLAG_SOFT_KEYBOARD\|KeyEvent.FLAG_KEEP_TOUCH_MODE));
		viewRootImpl.dispatchKeyFromIme(
		new KeyEvent(eventTime, eventTime, KeyEvent.ACTION_UP, keyEventCode, 0, 0,
		KeyCharacterMap.VIRTUAL_KEYBOARD, 0,
		KeyEvent.FLAG_SOFT_KEYBOARD\|KeyEvent.FLAG_KEEP_TOUCH_MODE));
		}

		public void onKey(int primaryCode, int[] keyCodes) {
		if (primaryCode == Keyboard.KEYCODE_DELETE) {
		handleBackspace();
		} else if (primaryCode == Keyboard.KEYCODE_SHIFT) {
		handleShift();
		} else if (primaryCode == Keyboard.KEYCODE_CANCEL) {
		handleClose();
		return;
		} else if (primaryCode == Keyboard.KEYCODE_MODE_CHANGE && mKeyboardView != null) {
		handleModeChange();
		} else {
		handleCharacter(primaryCode, keyCodes);
		// Switch back to old keyboard if we're not in capslock mode
		if (mKeyboardState == KEYBOARD_STATE_SHIFTED) {
		// skip to the unlocked state
		mKeyboardState = KEYBOARD_STATE_CAPSLOCK;
		handleShift();
		}
		}
		}

		/**
		* Sets and enables vibrate pattern. If id is 0 (or can't be loaded), vibrate is disabled.
		* @param id resource id for array containing vibrate pattern.
		*/
		public void setVibratePattern(int id) {
		int[] tmpArray = null;
		try {
		tmpArray = mContext.getResources().getIntArray(id);
		} catch (Resources.NotFoundException e) {
		if (id != 0) {
		Log.e(TAG, "Vibrate pattern missing", e);
		}
		}
		if (tmpArray == null) {
		mVibratePattern = null;
		return;
		}
		mVibratePattern = new long[tmpArray.length];
		for (int i = 0; i < tmpArray.length; i++) {
		mVibratePattern[i] = tmpArray[i];
		}
		}

		private void handleModeChange() {
		final Keyboard current = mKeyboardView.getKeyboard();
		Keyboard next = null;
		if (current == mQwertyKeyboard \|\| current == mQwertyKeyboardShifted) {
		next = mSymbolsKeyboard;
		} else if (current == mSymbolsKeyboard \|\| current == mSymbolsKeyboardShifted) {
		next = mQwertyKeyboard;
		}
		if (next != null) {
		mKeyboardView.setKeyboard(next);
		mKeyboardState = KEYBOARD_STATE_NORMAL;
		}
		}

		public void handleBackspace() {
		sendDownUpKeyEvents(KeyEvent.KEYCODE_DEL);
		performHapticFeedback();
		}

		private void handleShift() {
		if (mKeyboardView == null) {
		return;
		}
		Keyboard current = mKeyboardView.getKeyboard();
		PasswordEntryKeyboard next = null;
		final boolean isAlphaMode = current == mQwertyKeyboard
		\|\| current == mQwertyKeyboardShifted;
		if (mKeyboardState == KEYBOARD_STATE_NORMAL) {
		mKeyboardState = isAlphaMode ? KEYBOARD_STATE_SHIFTED : KEYBOARD_STATE_CAPSLOCK;
		next = isAlphaMode ? mQwertyKeyboardShifted : mSymbolsKeyboardShifted;
		} else if (mKeyboardState == KEYBOARD_STATE_SHIFTED) {
		mKeyboardState = KEYBOARD_STATE_CAPSLOCK;
		next = isAlphaMode ? mQwertyKeyboardShifted : mSymbolsKeyboardShifted;
		} else if (mKeyboardState == KEYBOARD_STATE_CAPSLOCK) {
		mKeyboardState = KEYBOARD_STATE_NORMAL;
		next = isAlphaMode ? mQwertyKeyboard : mSymbolsKeyboard;
		}
		if (next != null) {
		if (next != current) {
		mKeyboardView.setKeyboard(next);
		}
		next.setShiftLocked(mKeyboardState == KEYBOARD_STATE_CAPSLOCK);
		mKeyboardView.setShifted(mKeyboardState != KEYBOARD_STATE_NORMAL);
		}
		}

		private void handleCharacter(int primaryCode, int[] keyCodes) {
		// Maybe turn off shift if not in capslock mode.
		if (mKeyboardView.isShifted() && primaryCode != ' ' && primaryCode != '\n') {
		primaryCode = Character.toUpperCase(primaryCode);
		}
		sendKeyEventsToTarget(primaryCode);
		}

		private void handleClose() {

		}

		public void onPress(int primaryCode) {
		performHapticFeedback();
		}

		private void performHapticFeedback() {
		if (mEnableHaptics) {
		mKeyboardView.performHapticFeedback(HapticFeedbackConstants.VIRTUAL_KEY,
		HapticFeedbackConstants.FLAG_IGNORE_VIEW_SETTING
		\| HapticFeedbackConstants.FLAG_IGNORE_GLOBAL_SETTING);
		}
		}

		public void onRelease(int primaryCode) {

		}

		public void onText(CharSequence text) {

		}

		public void swipeDown() {

		}

		public void swipeLeft() {

		}

		public void swipeRight() {

		}

		public void swipeUp() {

		}
		};

core/java/com/android/internal/widget/PasswordEntryKeyboardView.java

deleted100644 → 0

+0 −55

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2010 Google Inc.
		*
		* 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.internal.widget;

		import android.content.Context;
		import android.inputmethodservice.KeyboardView;
		import android.util.AttributeSet;

		public class PasswordEntryKeyboardView extends KeyboardView {

		static final int KEYCODE_OPTIONS = -100;
		static final int KEYCODE_SHIFT_LONGPRESS = -101;
		static final int KEYCODE_VOICE = -102;
		static final int KEYCODE_F1 = -103;
		static final int KEYCODE_NEXT_LANGUAGE = -104;

		public PasswordEntryKeyboardView(Context context, AttributeSet attrs) {
		this(context, attrs, 0);
		}

		public PasswordEntryKeyboardView(Context context, AttributeSet attrs, int defStyleAttr) {
		this(context, attrs, defStyleAttr, 0);
		}

		public PasswordEntryKeyboardView(
		Context context, AttributeSet attrs, int defStyleAttr, int defStyleRes) {
		super(context, attrs, defStyleAttr, defStyleRes);
		}

		@Override
		public boolean setShifted(boolean shifted) {
		boolean result = super.setShifted(shifted);
		// invalidate both shift keys
		int[] indices = getKeyboard().getShiftKeyIndices();
		for (int index : indices) {
		invalidateKey(index);
		}
		return result;
		}

		}

core/java/com/android/internal/widget/RotarySelector.java

deleted100644 → 0

+0 −780

File deleted.

Preview size limit exceeded, changes collapsed.