InputManager

ACTION_QUERY_KEYBOARD_LAYOUTS

static val ACTION_QUERY_KEYBOARD_LAYOUTS: String

Broadcast Action: Query available keyboard layouts.

The input manager service locates available keyboard layouts by querying broadcast receivers that are registered for this action. An application can offer additional keyboard layouts to the user by declaring a suitable broadcast receiver in its manifest.

Here is an example broadcast receiver declaration that an application might include in its AndroidManifest.xml to advertise keyboard layouts. The meta-data specifies a resource that contains a description of each keyboard layout that is provided by the application.

<code>
  &lt;receiver android:name=".InputDeviceReceiver"
          android:label="@string/keyboard_layouts_label"&gt;
      &lt;intent-filter&gt;
          &lt;action android:name="android.hardware.input.action.QUERY_KEYBOARD_LAYOUTS" /&gt;
      &lt;/intent-filter&gt;
      &lt;meta-data android:name="android.hardware.input.metadata.KEYBOARD_LAYOUTS"
              android:resource="@xml/keyboard_layouts" /&gt;
  &lt;/receiver&gt;
  </code>

In the above example, the @xml/keyboard_layouts resource refers to an XML resource whose root element is <keyboard-layouts> that contains zero or more <keyboard-layout> elements. Each <keyboard-layout> element specifies the name, label, and location of a key character map for a particular keyboard layout. The label on the receiver is used to name the collection of keyboard layouts provided by this receiver in the keyboard layout settings.

<code>
  &lt;?xml version="1.0" encoding="utf-8"?&gt;
  &lt;keyboard-layouts xmlns:android="http://schemas.android.com/apk/res/android"&gt;
      &lt;keyboard-layout android:name="keyboard_layout_english_us"
              android:label="@string/keyboard_layout_english_us_label"
              android:keyboardLayout="@raw/keyboard_layout_english_us" /&gt;
  &lt;/keyboard-layouts&gt;
  </code>

The android:name attribute specifies an identifier by which the keyboard layout will be known in the package. The android:label attribute specifies a human-readable descriptive label to describe the keyboard layout in the user interface, such as "English (US)". The android:keyboardLayout attribute refers to a key character map resource that defines the keyboard layout. The android:keyboardLocale attribute specifies a comma separated list of BCP 47 language tags depicting the locales supported by the keyboard layout. This attribute is optional and will be used for auto layout selection for external physical keyboards. The android:keyboardLayoutType attribute specifies the layoutType for the keyboard layout. This can be either empty or one of the following supported layout types: qwerty, qwertz, azerty, dvorak, colemak, workman, extended, turkish_q, turkish_f. This attribute is optional and will be used for auto layout selection for external physical keyboards.

Value: "android.hardware.input.action.QUERY_KEYBOARD_LAYOUTS"

META_DATA_KEYBOARD_LAYOUTS

static val META_DATA_KEYBOARD_LAYOUTS: String

Metadata Key: Keyboard layout metadata associated with ACTION_QUERY_KEYBOARD_LAYOUTS.

Specifies the resource id of a XML resource that describes the keyboard layouts that are provided by the application.

Value: "android.hardware.input.metadata.KEYBOARD_LAYOUTS"

addPeripheralCustomization

fun addPeripheralCustomization(
    vendorId: Int, 
    productId: Int, 
    trigger: CustomizationTrigger, 
    action: CustomizationAction
): Unit

Adds a new peripheral customization for a given vendor ID and product ID.

This will remap a key on all connected peripheral devices matching the vendor and product ID to a different action.
Requires android.Manifest.permission#MANAGE_PERIPHERAL_CUSTOMIZATION

getAllPeripheralCustomizations

fun getAllPeripheralCustomizations(
    vendorId: Int, 
    productId: Int
): MutableMap<CustomizationTrigger!, CustomizationAction!>

Retrieves all input customizations for a specific peripheral device.
Requires android.Manifest.permission#MANAGE_PERIPHERAL_CUSTOMIZATION

getHostUsiVersion

fun getHostUsiVersion(display: Display): HostUsiVersion?

Reports the version of the Universal Stylus Initiative (USI) protocol supported by the given display, if any.

getInputDevice

fun getInputDevice(id: Int): InputDevice?

Gets information about the input device with the specified id.

getInputDeviceIds

fun getInputDeviceIds(): IntArray!

Gets the ids of all input devices in the system.

getInputDeviceViewBehavior

fun getInputDeviceViewBehavior(deviceId: Int): InputDevice.ViewBehavior?

Gets the InputDevice.ViewBehavior of the input device with a given id.

Use this API to query a fresh view behavior instance whenever the input device changes.

getMaximumObscuringOpacityForTouch

fun getMaximumObscuringOpacityForTouch(): Float

Returns the maximum allowed obscuring opacity per UID to propagate touches.

For certain window types (eg. LayoutParams.TYPE_APPLICATION_OVERLAY), the decision of honoring LayoutParams.FLAG_NOT_TOUCHABLE or not depends on the combined obscuring opacity of the windows above the touch-consuming window, per UID. Check documentation of LayoutParams.FLAG_NOT_TOUCHABLE for more details.

The value returned is between 0 (inclusive) and 1 (inclusive).

getPeripheralCustomization

fun getPeripheralCustomization(
    vendorId: Int, 
    productId: Int, 
    trigger: CustomizationTrigger
): CustomizationAction?

Retrieves a specific peripheral customization action for a given trigger.
Requires android.Manifest.permission#MANAGE_PERIPHERAL_CUSTOMIZATION

isButtonAllowedForCustomization

fun isButtonAllowedForCustomization(
    vendorId: Int, 
    productId: Int, 
    buttonCode: Int
): Boolean

Checks if a specific button is allowed for customization on the device(s).
Requires android.Manifest.permission#MANAGE_PERIPHERAL_CUSTOMIZATION

isKeyAllowedForCustomization

fun isKeyAllowedForCustomization(
    vendorId: Int, 
    productId: Int, 
    keyCode: Int
): Boolean

Gets whether a keycode can be customized on a device.
Requires android.Manifest.permission#MANAGE_PERIPHERAL_CUSTOMIZATION

isStylusPointerIconEnabled

fun isStylusPointerIconEnabled(): Boolean

Check if showing a android.view.PointerIcon for styluses is enabled.

registerInputDeviceListener

fun registerInputDeviceListener(
    listener: InputManager.InputDeviceListener!, 
    handler: Handler!
): Unit

Registers an input device listener to receive notifications about when input devices are added, removed or changed.

removeAllPeripheralCustomizations

fun removeAllPeripheralCustomizations(
    vendorId: Int, 
    productId: Int
): Unit

Remove all peripheral customizations for a given vendor ID and product ID.

This will remove all customizations on all connected peripheral devices matching the vendor and product ID. If no customizations exist, this method does nothing.
Requires android.Manifest.permission#MANAGE_PERIPHERAL_CUSTOMIZATION

removePeripheralCustomization

fun removePeripheralCustomization(
    vendorId: Int, 
    productId: Int, 
    trigger: CustomizationTrigger
): Unit

Removes a peripheral customization for a given vendor ID and product ID.

This will remove a specific customization on all connected peripheral devices matching the vendor and product ID. If the specified customization does not exist, this method does nothing.
Requires android.Manifest.permission#MANAGE_PERIPHERAL_CUSTOMIZATION

unregisterInputDeviceListener

fun unregisterInputDeviceListener(listener: InputManager.InputDeviceListener!): Unit

Unregisters an input device listener.

verifyInputEvent

fun verifyInputEvent(event: InputEvent): VerifiedInputEvent?

Verify the details of an android.view.InputEvent that came from the system. If the event did not come from the system, or its details could not be verified, then this will return null. Receiving null does not mean that the event did not originate from the system, just that we were unable to verify it. This can happen for a number of reasons during normal operation.