Research on Soft Keyboard State Monitoring and Dynamic View Management in Android

Technical Background of Soft Keyboard State Monitoring

In Android application development, monitoring the display and hide states of the soft keyboard is a common but complex technical requirement. Since the Android system does not provide an official API for soft keyboard state monitoring, developers need to adopt indirect methods to achieve this functionality. Based on best practices from the Stack Overflow community, this article focuses on analyzing technical solutions for detecting keyboard states through layout changes.

Core Implementation Principle

The core principle of soft keyboard state monitoring is based on a key observation: when the soft keyboard is displayed, the system adjusts the layout dimensions of the application window. By monitoring global layout changes of the root layout, this dimensional adjustment can be detected, thereby inferring the display state of the soft keyboard.

The specific implementation requires meeting the following conditions: First, the Activity's android:windowSoftInputMode attribute must be set to adjustResize in AndroidManifest.xml to ensure that the system adjusts the application layout when the soft keyboard is displayed. Second, the root layout view of the application needs to be obtained, and a global layout listener needs to be added to it.

Complete Implementation Solution

The following is a complete BaseActivity base class implementation that provides the basic framework for soft keyboard state monitoring:

public class BaseActivity extends Activity {
    private ViewTreeObserver.OnGlobalLayoutListener keyboardLayoutListener = new ViewTreeObserver.OnGlobalLayoutListener() {
        @Override
        public void onGlobalLayout() {
            int heightDiff = rootLayout.getRootView().getHeight() - rootLayout.getHeight();
            int contentViewTop = getWindow().findViewById(Window.ID_ANDROID_CONTENT).getTop();

            LocalBroadcastManager broadcastManager = LocalBroadcastManager.getInstance(BaseActivity.this);

            if(heightDiff <= contentViewTop){
                onHideKeyboard();

                Intent intent = new Intent("KeyboardWillHide");
                broadcastManager.sendBroadcast(intent);
            } else {
                int keyboardHeight = heightDiff - contentViewTop;
                onShowKeyboard(keyboardHeight);

                Intent intent = new Intent("KeyboardWillShow");
                intent.putExtra("KeyboardHeight", keyboardHeight);
                broadcastManager.sendBroadcast(intent);
            }
        }
    };

    private boolean keyboardListenersAttached = false;
    private ViewGroup rootLayout;

    protected void onShowKeyboard(int keyboardHeight) {}
    protected void onHideKeyboard() {}

    protected void attachKeyboardListeners() {
        if (keyboardListenersAttached) {
            return;
        }

        rootLayout = (ViewGroup) findViewById(R.id.rootLayout);
        rootLayout.getViewTreeObserver().addOnGlobalLayoutListener(keyboardLayoutListener);

        keyboardListenersAttached = true;
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();

        if (keyboardListenersAttached) {
            rootLayout.getViewTreeObserver().removeGlobalOnLayoutListener(keyboardLayoutListener);
        }
    }
}

Specific Application Example

In practical applications, developers can inherit from BaseActivity and override relevant methods to implement specific business logic. The following is a typical application scenario implementation:

public class TestActivity extends BaseActivity {
    private LinearLayout bottomContainer;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.test_activity);

        bottomContainer = (LinearLayout) findViewById(R.id.bottomContainer);
        attachKeyboardListeners();
    }

    @Override
    protected void onShowKeyboard(int keyboardHeight) {
        // Processing logic when keyboard is shown
        bottomContainer.setVisibility(View.GONE);
    }

    @Override
    protected void onHideKeyboard() {
        // Processing logic when keyboard is hidden
        bottomContainer.setVisibility(View.VISIBLE);
    }        
}

Layout File Configuration

The corresponding layout file needs to contain a root layout with a specific ID:

<?xml version="1.0" encoding="utf-8"?>

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
              android:id="@+id/rootLayout"
              android:layout_width="match_parent"
              android:layout_height="match_parent"
              android:orientation="vertical">              

    <ScrollView
        android:id="@+id/scrollView"
        android:layout_width="match_parent"
        android:layout_height="0dp"
        android:layout_weight="1"
        >

        <!-- Other view content omitted -->

    </ScrollView>

    <LinearLayout android:id="@+id/bottomContainer"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:orientation="vertical"
        >

        <!-- Other view content omitted -->

    </LinearLayout>

</LinearLayout>

Technical Key Points Analysis

The key technical points of this implementation solution include: height difference calculation detects keyboard state by comparing the total height of the root view with the visible layout height; content view top position is used to accurately determine the keyboard display threshold; local broadcast mechanism allows transmitting keyboard state information within the application; memory management ensures proper removal of listeners when the Activity is destroyed to avoid memory leaks.

Alternative Solution Comparison

In addition to the core solution mentioned above, the community provides several other implementation methods: third-party library solutions like KeyboardVisibilityEvent offer simpler APIs but add external dependencies; focus listener solutions indirectly infer keyboard state through EditText focus changes but have limited accuracy; direct layout listener solutions may have compatibility issues across different Android versions and devices.

Compatibility Considerations

When implementing soft keyboard state monitoring, compatibility across different Android versions needs to be considered. Particularly for AppCompatActivity, height calculation logic may need adjustment to account for status bar and navigation bar heights. Additionally, customized ROMs from different manufacturers may impact soft keyboard behavior, requiring thorough testing and validation.

Performance Optimization Recommendations

Since the global layout listener triggers with every layout change, it's essential to ensure that the logic in callback methods is as efficient as possible. It's recommended to avoid time-consuming operations in callback methods; for complex business logic, consider using Handler for delayed processing or asynchronous execution. Additionally, properly manage the lifecycle of listeners to avoid unnecessary memory usage.