Android车载多屏应用：如何检测IME位置并提示其在其他屏使用

Great question—handling multi-display IME behavior is a common pain point for Android automotive apps. Here's a step-by-step implementation approach that balances reliability and user experience:

1. Use AccessibilityService to Monitor IME Window Changes #

The most reliable way to track the IME's display position is via an AccessibilityService, which can observe window state changes across all displays. This avoids restricted permissions and works consistently across Android versions.

First, create the service class:

class ImeDisplayMonitorService : AccessibilityService() {
    var currentImeDisplayId: Int = Display.DEFAULT_DISPLAY
        private set

    override fun onAccessibilityEvent(event: AccessibilityEvent) {
        if (event.eventType == AccessibilityEvent.TYPE_WINDOW_STATE_CHANGED) {
            event.source?.windowInfo?.let { windowInfo ->
                // Check if this is the IME window
                if (windowInfo.type == AccessibilityWindowInfo.TYPE_INPUT_METHOD) {
                    val newDisplayId = windowInfo.displayId
                    if (newDisplayId != currentImeDisplayId) {
                        currentImeDisplayId = newDisplayId
                        // Notify your app components of the change
                        ImeDisplayListener.onImeDisplayChanged(newDisplayId)
                    }
                }
            }
        }
    }

    override fun onInterrupt() {}

    // Interface to broadcast IME display changes to your app
    interface ImeDisplayListener {
        companion object {
            var onImeDisplayChanged: (Int) -> Unit = {}
        }
    }
}

Register the service in your AndroidManifest.xml:

<service
    android:name=".ImeDisplayMonitorService"
    android:permission="android.permission.BIND_ACCESSIBILITY_SERVICE">
    <intent-filter>
        <action android:name="android.accessibilityservice.AccessibilityService" />
    </intent-filter>
    <meta-data
        android:name="android.accessibilityservice"
        android:resource="@xml/accessibility_service_config" />
</service>

Create the accessibility config file (res/xml/accessibility_service_config.xml):

<?xml version="1.0" encoding="utf-8"?>
<accessibility-service xmlns:android="http://schemas.android.com/apk/res/android"
    android:accessibilityEventTypes="typeWindowStateChanged"
    android:accessibilityFeedbackType="feedbackGeneric"
    android:accessibilityFlags="flagDefault"
    android:canRetrieveWindowContent="true"
    android:description="@string/accessibility_service_description" />

Important: Users need to enable accessibility for your app. Add a prompt to guide them to Settings > Accessibility > [Your App] if the service isn't active.

2. Track IME Focus Changes in Your Input Views #

Add focus listeners to all your input fields (e.g., EditText) to detect when the user tries to use the keyboard while it's on another display:

yourDashboardEditText.setOnFocusChangeListener { view, hasFocus ->
    if (hasFocus) {
        val currentDisplayId = view.display.displayId
        val imeDisplayId = ImeDisplayMonitorService.currentImeDisplayId
        
        if (currentDisplayId != imeDisplayId) {
            // Trigger the prompt dialog
            showImeOnOtherDisplayPrompt(view.context, currentDisplayId, imeDisplayId)
        }
    }
}

3. Show the User Prompt Dialog #

Create a clear, user-friendly dialog that appears on the display the user is currently interacting with:

fun showImeOnOtherDisplayPrompt(context: Context, userDisplayId: Int, imeDisplayId: Int) {
    // Get display names for better readability (e.g., "Center Console" instead of ID 1)
    val displayManager = context.getSystemService(Context.DISPLAY_SERVICE) as DisplayManager
    val userDisplay = displayManager.getDisplay(userDisplayId)
    val imeDisplay = displayManager.getDisplay(imeDisplayId)
    
    val dialogMessage = "The keyboard is currently active on the ${imeDisplay?.name ?: "secondary display"}. Please switch to that screen to use it, or dismiss this to continue."

    val dialog = AlertDialog.Builder(context)
        .setTitle("Keyboard on Another Screen")
        .setMessage(dialogMessage)
        .setPositiveButton("Got it") { dialog, _ -> dialog.dismiss() }
        .create()

    // Attach dialog to the user's current display
    dialog.window?.apply {
        setType(WindowManager.LayoutParams.TYPE_APPLICATION_OVERLAY)
        display = userDisplay
    }
    dialog.show()
}

4. Alternative: WindowManager Direct Check (Restricted Permission) #

If accessibility isn't ideal, you can use WindowManager to periodically scan for the IME window. This requires the android.permission.ACCESS_WINDOW_CONTENT permission (restricted on Android 10+), so it's less recommended:

fun getCurrentImeDisplayId(context: Context): Int {
    val windowManager = context.getSystemService(Context.WINDOW_SERVICE) as WindowManager
    windowManager.currentWindowMetrics.forEach { windowMetrics ->
        val attrs = windowMetrics.windowAttributes
        if (attrs.type == WindowManager.LayoutParams.TYPE_INPUT_METHOD) {
            return attrs.displayId
        }
    }
    return Display.DEFAULT_DISPLAY
}

Key Considerations #

• Display Naming: Use Display.name to show user-friendly display labels instead of raw IDs.
• Edge Cases: Handle scenarios where the IME is closed, or when the app is running on multiple displays at once.
• Dialog Placement: Always show the prompt on the display the user is interacting with, not the one hosting the IME.

内容的提问来源于stack exchange，提问作者Jitendra_Rupeja