Improve handling of built-in keyboard.

The window manager policy made some incorrect assumptions about the
meaning of the Configuration.keyboard field.  We need to be more
careful about distinguishing between built-in and external keyboards.

Most of this change is to move the determination of the parts of
the Configuration related to input devices into the WindowManagerService
leveraging new features of the InputManagerService to good effect.

Then we plumb through the flag that indicates whether a device
is internal or external so that we can be more particular about
how the lid switch effects changes to the Configuration.

Bug: 6424373
Change-Id: I36a1c22ade35e578955465a25940a33f227b9763

Author: Jeff Brown

core/java/android/view/InputDevice.java

@@ -46,6 +46,7 @@ public final class InputDevice implements Parcelable {
     private final int mGeneration;
     private final String mName;
     private final String mDescriptor;
+    private final boolean mIsExternal;
     private final int mSources;
     private final int mKeyboardType;
     private final KeyCharacterMap mKeyCharacterMap;
@@ -322,12 +323,14 @@ public InputDevice[] newArray(int size) {
     };
 
     // Called by native code.
-    private InputDevice(int id, int generation, String name, String descriptor, int sources,
+    private InputDevice(int id, int generation, String name, String descriptor,
+            boolean isExternal, int sources,
             int keyboardType, KeyCharacterMap keyCharacterMap, boolean hasVibrator) {
         mId = id;
         mGeneration = generation;
         mName = name;
         mDescriptor = descriptor;
+        mIsExternal = isExternal;
         mSources = sources;
         mKeyboardType = keyboardType;
         mKeyCharacterMap = keyCharacterMap;
@@ -339,6 +342,7 @@ private InputDevice(Parcel in) {
         mGeneration = in.readInt();
         mName = in.readString();
         mDescriptor = in.readString();
+        mIsExternal = in.readInt() != 0;
         mSources = in.readInt();
         mKeyboardType = in.readInt();
         mKeyCharacterMap = KeyCharacterMap.CREATOR.createFromParcel(in);
@@ -414,7 +418,7 @@ public int getGeneration() {
      * has a trackpad.  Alternately, it may be that the input devices are simply
      * indistinguishable, such as two keyboards made by the same manufacturer.
      * </p><p>
-     * The input device descriptor returned by {@link #getDescriptor} should only bt
+     * The input device descriptor returned by {@link #getDescriptor} should only be
      * used when an application needs to remember settings associated with a particular
      * input device.  For all other purposes when referring to a logical
      * {@link InputDevice} instance at runtime use the id returned by {@link #getId()}.
@@ -442,6 +446,18 @@ public boolean isVirtual() {
         return mId < 0;
     }
 
+    /**
+     * Returns true if the device is external (connected to USB or Bluetooth or some other
+     * peripheral bus), otherwise it is built-in.
+     *
+     * @return True if the device is external.
+     *
+     * @hide
+     */
+    public boolean isExternal() {
+        return mIsExternal;
+    }
+
     /**
      * Gets the name of this input device.
      * @return The input device name.
@@ -660,6 +676,7 @@ public void writeToParcel(Parcel out, int flags) {
         out.writeInt(mGeneration);
         out.writeString(mName);
         out.writeString(mDescriptor);
+        out.writeInt(mIsExternal ? 1 : 0);
         out.writeInt(mSources);
         out.writeInt(mKeyboardType);
         mKeyCharacterMap.writeToParcel(out, flags);
@@ -689,6 +706,7 @@ public String toString() {
         description.append("Input Device ").append(mId).append(": ").append(mName).append("\n");
         description.append("  Descriptor: ").append(mDescriptor).append("\n");
         description.append("  Generation: ").append(mGeneration).append("\n");
+        description.append("  Location: ").append(mIsExternal ? "external" : "built-in").append("\n");
 
         description.append("  Keyboard Type: ");
         switch (mKeyboardType) {

core/java/android/view/WindowManagerPolicy.java

@@ -91,6 +91,11 @@ public interface WindowManagerPolicy {
     public final static int FLAG_BRIGHT_HERE = 0x20000000;
     public final static int FLAG_PASS_TO_USER = 0x40000000;
 
+    // Flags used for indicating whether the internal and/or external input devices
+    // of some type are available.
+    public final static int PRESENCE_INTERNAL = 1 << 0;
+    public final static int PRESENCE_EXTERNAL = 1 << 1;
+
     public final static boolean WATCH_POINTER = false;
 
     /**
@@ -500,8 +505,13 @@ public void init(Context context, IWindowManager windowManager,
      * 
      * @param config The Configuration being computed, for you to change as
      * desired.
+     * @param keyboardPresence Flags that indicate whether internal or external
+     * keyboards are present.
+     * @param navigationPresence Flags that indicate whether internal or external
+     * navigation devices are present.
      */
-    public void adjustConfigurationLw(Configuration config);
+    public void adjustConfigurationLw(Configuration config, int keyboardPresence,
+            int navigationPresence);
 
     /**
      * Assign a window type to a layer.  Allows you to control how different

core/jni/android_view_InputDevice.cpp

@@ -55,7 +55,7 @@ jobject android_view_InputDevice_create(JNIEnv* env, const InputDeviceInfo& devi
 
     ScopedLocalRef<jobject> inputDeviceObj(env, env->NewObject(gInputDeviceClassInfo.clazz,
             gInputDeviceClassInfo.ctor, deviceInfo.getId(), deviceInfo.getGeneration(),
-            nameObj.get(), descriptorObj.get(),
+            nameObj.get(), descriptorObj.get(), deviceInfo.isExternal(),
             deviceInfo.getSources(), deviceInfo.getKeyboardType(),
             kcmObj.get(), deviceInfo.hasVibrator()));
 
@@ -87,7 +87,7 @@ int register_android_view_InputDevice(JNIEnv* env)
     gInputDeviceClassInfo.clazz = jclass(env->NewGlobalRef(gInputDeviceClassInfo.clazz));
 
     GET_METHOD_ID(gInputDeviceClassInfo.ctor, gInputDeviceClassInfo.clazz,
-            "<init>", "(IILjava/lang/String;Ljava/lang/String;IILandroid/view/KeyCharacterMap;Z)V");
+            "<init>", "(IILjava/lang/String;Ljava/lang/String;ZIILandroid/view/KeyCharacterMap;Z)V");
 
     GET_METHOD_ID(gInputDeviceClassInfo.addMotionRange, gInputDeviceClassInfo.clazz,
             "addMotionRange", "(IIFFFF)V");

include/androidfw/Input.h

@@ -156,37 +156,6 @@ enum {
     POLICY_FLAG_PASS_TO_USER = 0x40000000,
 };
 
-/*
- * Describes the basic configuration of input devices that are present.
- */
-struct InputConfiguration {
-    enum {
-        TOUCHSCREEN_UNDEFINED = 0,
-        TOUCHSCREEN_NOTOUCH = 1,
-        TOUCHSCREEN_STYLUS = 2,
-        TOUCHSCREEN_FINGER = 3
-    };
-
-    enum {
-        KEYBOARD_UNDEFINED = 0,
-        KEYBOARD_NOKEYS = 1,
-        KEYBOARD_QWERTY = 2,
-        KEYBOARD_12KEY = 3
-    };
-
-    enum {
-        NAVIGATION_UNDEFINED = 0,
-        NAVIGATION_NONAV = 1,
-        NAVIGATION_DPAD = 2,
-        NAVIGATION_TRACKBALL = 3,
-        NAVIGATION_WHEEL = 4
-    };
-
-    int32_t touchScreen;
-    int32_t keyboard;
-    int32_t navigation;
-};
-
 /*
  * Pointer coordinate data.
  */

include/androidfw/InputDevice.h

@@ -67,7 +67,7 @@ class InputDeviceInfo {
     };
 
     void initialize(int32_t id, int32_t generation, const InputDeviceIdentifier& identifier,
-            const String8& alias);
+            const String8& alias, bool isExternal);
 
     inline int32_t getId() const { return mId; }
     inline int32_t getGeneration() const { return mGeneration; }
@@ -76,6 +76,7 @@ class InputDeviceInfo {
     inline const String8& getDisplayName() const {
         return mAlias.isEmpty() ? mIdentifier.name : mAlias;
     }
+    inline bool isExternal() const { return mIsExternal; }
     inline uint32_t getSources() const { return mSources; }
 
     const MotionRange* getMotionRange(int32_t axis, uint32_t source) const;
@@ -108,6 +109,7 @@ class InputDeviceInfo {
     int32_t mGeneration;
     InputDeviceIdentifier mIdentifier;
     String8 mAlias;
+    bool mIsExternal;
     uint32_t mSources;
     int32_t mKeyboardType;
     sp<KeyCharacterMap> mKeyCharacterMap;

libs/androidfw/InputDevice.cpp

@@ -127,12 +127,12 @@ String8 getInputDeviceConfigurationFilePathByName(
 // --- InputDeviceInfo ---
 
 InputDeviceInfo::InputDeviceInfo() {
-    initialize(-1, -1, InputDeviceIdentifier(), String8());
+    initialize(-1, -1, InputDeviceIdentifier(), String8(), false);
 }
 
 InputDeviceInfo::InputDeviceInfo(const InputDeviceInfo& other) :
         mId(other.mId), mGeneration(other.mGeneration), mIdentifier(other.mIdentifier),
-        mAlias(other.mAlias), mSources(other.mSources),
+        mAlias(other.mAlias), mIsExternal(other.mIsExternal), mSources(other.mSources),
         mKeyboardType(other.mKeyboardType),
         mKeyCharacterMap(other.mKeyCharacterMap),
         mHasVibrator(other.mHasVibrator),
@@ -143,11 +143,12 @@ InputDeviceInfo::~InputDeviceInfo() {
 }
 
 void InputDeviceInfo::initialize(int32_t id, int32_t generation,
-        const InputDeviceIdentifier& identifier, const String8& alias) {
+        const InputDeviceIdentifier& identifier, const String8& alias, bool isExternal) {
     mId = id;
     mGeneration = generation;
     mIdentifier = identifier;
     mAlias = alias;
+    mIsExternal = isExternal;
     mSources = 0;
     mKeyboardType = AINPUT_KEYBOARD_TYPE_NONE;
     mHasVibrator = false;

policy/src/com/android/internal/policy/impl/PhoneWindowManager.java

@@ -38,6 +38,7 @@
 import android.graphics.PixelFormat;
 import android.graphics.Rect;
 import android.graphics.RectF;
+import android.hardware.input.InputManager;
 import android.media.AudioManager;
 import android.media.IAudioService;
 import android.os.BatteryManager;
@@ -332,6 +333,7 @@ public class PhoneWindowManager implements WindowManagerPolicy {
     int mRecentAppsDialogHeldModifiers;
 
     int mLidState = LID_ABSENT;
+    boolean mHaveBuiltInKeyboard;
 
     boolean mSystemReady;
     boolean mSystemBooted;
@@ -1259,46 +1261,42 @@ void readLidState() {
         mLidState = mWindowManagerFuncs.getLidState();
     }
 
-    private int determineHiddenState(int mode, int hiddenValue, int visibleValue) {
-        if (mLidState != LID_ABSENT) {
-            switch (mode) {
-                case 1:
-                    return mLidState == LID_OPEN ? visibleValue : hiddenValue;
-                case 2:
-                    return mLidState == LID_OPEN ? hiddenValue : visibleValue;
-            }
+    private boolean isHidden(int accessibilityMode) {
+        switch (accessibilityMode) {
+            case 1:
+                return mLidState == LID_CLOSED;
+            case 2:
+                return mLidState == LID_OPEN;
+            default:
+                return false;
         }
-        return visibleValue;
     }
 
-    private boolean isKeyboardVisible() {
-        return determineHiddenState(mLidKeyboardAccessibility, 0, 1) == 1
-                || determineHiddenState(mLidNavigationAccessibility, 0, 1) == 1;
+    private boolean isBuiltInKeyboardVisible() {
+        return mHaveBuiltInKeyboard && !isHidden(mLidKeyboardAccessibility);
     }
 
     /** {@inheritDoc} */
-    public void adjustConfigurationLw(Configuration config) {
+    public void adjustConfigurationLw(Configuration config, int keyboardPresence,
+            int navigationPresence) {
+        mHaveBuiltInKeyboard = (keyboardPresence & PRESENCE_INTERNAL) != 0;
+
         readLidState();
         applyLidSwitchState();
 
-        if (config.keyboard == Configuration.KEYBOARD_NOKEYS) {
+        if (config.keyboard == Configuration.KEYBOARD_NOKEYS
+                || (keyboardPresence == PRESENCE_INTERNAL
+                        && isHidden(mLidKeyboardAccessibility))) {
             config.hardKeyboardHidden = Configuration.HARDKEYBOARDHIDDEN_YES;
-        } else {
-            config.hardKeyboardHidden = determineHiddenState(mLidKeyboardAccessibility,
-                    Configuration.HARDKEYBOARDHIDDEN_YES, Configuration.HARDKEYBOARDHIDDEN_NO);
+            if (!mHasSoftInput) {
+                config.keyboardHidden = Configuration.KEYBOARDHIDDEN_YES;
+            }
         }
 
-        if (config.navigation == Configuration.NAVIGATION_NONAV) {
+        if (config.navigation == Configuration.NAVIGATION_NONAV
+                || (navigationPresence == PRESENCE_INTERNAL
+                        && isHidden(mLidNavigationAccessibility))) {
             config.navigationHidden = Configuration.NAVIGATIONHIDDEN_YES;
-        } else {
-            config.navigationHidden = determineHiddenState(mLidNavigationAccessibility,
-                    Configuration.NAVIGATIONHIDDEN_YES, Configuration.NAVIGATIONHIDDEN_NO);
-        }
-
-        if (mHasSoftInput || config.hardKeyboardHidden == Configuration.HARDKEYBOARDHIDDEN_NO) {
-            config.keyboardHidden = Configuration.KEYBOARDHIDDEN_NO;
-        } else {
-            config.keyboardHidden = Configuration.KEYBOARDHIDDEN_YES;
         }
     }
 
@@ -3890,7 +3888,8 @@ public void enableScreenAfterBoot() {
     }
 
     private void applyLidSwitchState() {
-        mPowerManager.setKeyboardVisibility(isKeyboardVisible());
+        mPowerManager.setKeyboardVisibility(isBuiltInKeyboardVisible());
+
         if (mLidState == LID_CLOSED && mLidControlsSleep) {
             mPowerManager.goToSleep(SystemClock.uptimeMillis());
         }

services/input/InputReader.cpp

@@ -250,7 +250,6 @@ InputReader::InputReader(const sp<EventHubInterface>& eventHub,
 
         refreshConfigurationLocked(0);
         updateGlobalMetaStateLocked();
-        updateInputConfigurationLocked();
     } // release lock
 }
 
@@ -502,9 +501,6 @@ void InputReader::handleConfigurationChangedLocked(nsecs_t when) {
     // Reset global meta state because it depends on the list of all configured devices.
     updateGlobalMetaStateLocked();
 
-    // Update input configuration.
-    updateInputConfigurationLocked();
-
     // Enqueue configuration changed.
     NotifyConfigurationChangedArgs args(when);
     mQueuedListener->notifyConfigurationChanged(&args);
@@ -542,36 +538,6 @@ int32_t InputReader::getGlobalMetaStateLocked() {
     return mGlobalMetaState;
 }
 
-void InputReader::updateInputConfigurationLocked() {
-    int32_t touchScreenConfig = InputConfiguration::TOUCHSCREEN_NOTOUCH;
-    int32_t keyboardConfig = InputConfiguration::KEYBOARD_NOKEYS;
-    int32_t navigationConfig = InputConfiguration::NAVIGATION_NONAV;
-    InputDeviceInfo deviceInfo;
-    for (size_t i = 0; i < mDevices.size(); i++) {
-        InputDevice* device = mDevices.valueAt(i);
-        if (!(device->getClasses() & INPUT_DEVICE_CLASS_VIRTUAL)) {
-            device->getDeviceInfo(& deviceInfo);
-            uint32_t sources = deviceInfo.getSources();
-
-            if ((sources & AINPUT_SOURCE_TOUCHSCREEN) == AINPUT_SOURCE_TOUCHSCREEN) {
-                touchScreenConfig = InputConfiguration::TOUCHSCREEN_FINGER;
-            }
-            if ((sources & AINPUT_SOURCE_TRACKBALL) == AINPUT_SOURCE_TRACKBALL) {
-                navigationConfig = InputConfiguration::NAVIGATION_TRACKBALL;
-            } else if ((sources & AINPUT_SOURCE_DPAD) == AINPUT_SOURCE_DPAD) {
-                navigationConfig = InputConfiguration::NAVIGATION_DPAD;
-            }
-            if (deviceInfo.getKeyboardType() == AINPUT_KEYBOARD_TYPE_ALPHABETIC) {
-                keyboardConfig = InputConfiguration::KEYBOARD_QWERTY;
-            }
-        }
-    }
-
-    mInputConfiguration.touchScreen = touchScreenConfig;
-    mInputConfiguration.keyboard = keyboardConfig;
-    mInputConfiguration.navigation = navigationConfig;
-}
-
 void InputReader::disableVirtualKeysUntilLocked(nsecs_t time) {
     mDisableVirtualKeysTimeout = time;
 }
@@ -608,12 +574,6 @@ int32_t InputReader::bumpGenerationLocked() {
     return ++mGeneration;
 }
 
-void InputReader::getInputConfiguration(InputConfiguration* outConfiguration) {
-    AutoMutex _l(mLock);
-
-    *outConfiguration = mInputConfiguration;
-}
-
 void InputReader::getInputDevices(Vector<InputDeviceInfo>& outInputDevices) {
     AutoMutex _l(mLock);
     getInputDevicesLocked(outInputDevices);
@@ -1049,7 +1009,7 @@ void InputDevice::timeoutExpired(nsecs_t when) {
 }
 
 void InputDevice::getDeviceInfo(InputDeviceInfo* outDeviceInfo) {
-    outDeviceInfo->initialize(mId, mGeneration, mIdentifier, mAlias);
+    outDeviceInfo->initialize(mId, mGeneration, mIdentifier, mAlias, mIsExternal);
 
     size_t numMappers = mMappers.size();
     for (size_t i = 0; i < numMappers; i++) {