記事ディレクトリ

序文
1. 可視性の原則
2. 表示モードの原理

序文

Android ソフトキーボード windowSoftInputMode の使い方と原理に関する前回の記事では、windowSoftInputMode の各属性の具体的な機能を紹介しましたが、次に、各属性の実装原理をソースコードレベル (Android9 ベース) で分析します。

1. 可視性の原則

ソフトキーボードの非表示と表示を分析するには、まず Android システムのソフトキーボードアーキテクチャがどのようなものであるかを理解する必要があります。以下の図を参照してください。InputMethodManagerService (以下、IMMS とも呼ばれます) は、インプットメソッドサービス (InputMethodService は IMS と呼ばれます) のロードと切り替えを含む、システムのすべての入力メソッドの管理を担当します
ここに画像の説明を挿入
。プログラムがフォーカスを取得すると、InputMethodManager を通じて、InputMethodManagerService にフォーカスを取得したことを通知し、現在の入力メソッドにバインドするよう要求します。同時に、EditorView などの入力メソッドを必要とするプログラムのビューがフォーカスを取得すると、InputMethodManager を介して、InputMethodManagerService に入力メソッドの表示を要求します。要求を受信した InputMethodManagerService は、要求された EditText データ通信インターフェイスを現在の入力メソッドに送信し、入力メソッドの表示を要求します。インプットメソッドはリクエストを受け取ると、独自のUIダイアログを表示すると同時に対象となるビューのデータ構造を保存し、ユーザーの入力完了後、ビューのデータ通信インターフェースを通じて文字が対応するビューに直接渡されます。

さらに、Android ウィンドウ管理システムについても理解する必要があります。次の図を参照してください。
ここに画像の説明を挿入

WindowManagerService (以下、WMS とも呼びます) は非常に複雑で、システム内のすべてのウィンドウの管理を担当します。ウィンドウが変化したとき (フォーカス状態とサイズ)、アプリのプロセスに通知することだけを知っておく必要があります。

アプリのウィンドウ、つまりページのフォーカス状態が変化すると (たとえば、新しいウィンドウに入り、このウィンドウのフォーカス状態が true になり、前のウィンドウが false になる)、イベントは ViewRootImpl の WindowInputEventReceiver にコールバックされます。一連の呼び出しの後、IMMS の startInputOrWindowGainedFocusInternalLocked メソッドに入ります。このメソッドのコアコードを見てください。

    @NonNull
    private InputBindResult startInputOrWindowGainedFocusInternalLocked(
            @StartInputReason int startInputReason, IInputMethodClient client,
            @NonNull IBinder windowToken, @StartInputFlags int startInputFlags,
            @SoftInputModeFlags int softInputMode, int windowFlags, EditorInfo attribute,
            IInputContext inputContext, @MissingMethodFlags int missingMethods,
            int unverifiedTargetSdkVersion, @UserIdInt int userId) {
    
    
            
        ......省略........
        
        InputBindResult res = null;
        switch (softInputMode & LayoutParams.SOFT_INPUT_MASK_STATE) {
    
    
            case LayoutParams.SOFT_INPUT_STATE_UNSPECIFIED:
                if (!isTextEditor || !doAutoShow) {
    
    
                    if (LayoutParams.mayUseInputMethod(windowFlags)) {
    
    
                        // There is no focus view, and this window will
                        // be behind any soft input window, so hide the
                        // soft input window if it is shown.
                        if (DEBUG) Slog.v(TAG, "Unspecified window will hide input");
                        hideCurrentInputLocked(
                                mCurFocusedWindow, InputMethodManager.HIDE_NOT_ALWAYS, null,
                                SoftInputShowHideReason.HIDE_UNSPECIFIED_WINDOW);

                        // If focused display changed, we should unbind current method
                        // to make app window in previous display relayout after Ime
                        // window token removed.
                        // Note that we can trust client's display ID as long as it matches
                        // to the display ID obtained from the window.
                        if (cs.selfReportedDisplayId != mCurTokenDisplayId) {
    
    
                            unbindCurrentMethodLocked();
                        }
                    }
                } else if (isTextEditor && doAutoShow
                        && (softInputMode & LayoutParams.SOFT_INPUT_IS_FORWARD_NAVIGATION) != 0) {
    
    
                    // There is a focus view, and we are navigating forward
                    // into the window, so show the input window for the user.
                    // We only do this automatically if the window can resize
                    // to accommodate the IME (so what the user sees will give
                    // them good context without input information being obscured
                    // by the IME) or if running on a large screen where there
                    // is more room for the target window + IME.
                    if (DEBUG) Slog.v(TAG, "Unspecified window will show input");
                    if (attribute != null) {
    
    
                        res = startInputUncheckedLocked(cs, inputContext, missingMethods,
                                attribute, startInputFlags, startInputReason);
                        didStart = true;
                    }
                    showCurrentInputLocked(windowToken, InputMethodManager.SHOW_IMPLICIT, null,
                            SoftInputShowHideReason.SHOW_AUTO_EDITOR_FORWARD_NAV);
                }
                break;
            case LayoutParams.SOFT_INPUT_STATE_UNCHANGED:
                // Do nothing.
                break;
            case LayoutParams.SOFT_INPUT_STATE_HIDDEN:
                if ((softInputMode & LayoutParams.SOFT_INPUT_IS_FORWARD_NAVIGATION) != 0) {
    
    
                    if (DEBUG) Slog.v(TAG, "Window asks to hide input going forward");
                    hideCurrentInputLocked(mCurFocusedWindow, 0, null,
                            SoftInputShowHideReason.HIDE_STATE_HIDDEN_FORWARD_NAV);
                }
                break;
            case LayoutParams.SOFT_INPUT_STATE_ALWAYS_HIDDEN:
                if (DEBUG) Slog.v(TAG, "Window asks to hide input");
                hideCurrentInputLocked(mCurFocusedWindow, 0, null,
                        SoftInputShowHideReason.HIDE_ALWAYS_HIDDEN_STATE);
                break;
            case LayoutParams.SOFT_INPUT_STATE_VISIBLE:
                if ((softInputMode & LayoutParams.SOFT_INPUT_IS_FORWARD_NAVIGATION) != 0) {
    
    
                    if (DEBUG) Slog.v(TAG, "Window asks to show input going forward");
                    if (InputMethodUtils.isSoftInputModeStateVisibleAllowed(
                            unverifiedTargetSdkVersion, startInputFlags)) {
    
    
                        if (attribute != null) {
    
    
                            res = startInputUncheckedLocked(cs, inputContext, missingMethods,
                                    attribute, startInputFlags, startInputReason);
                            didStart = true;
                        }
                        showCurrentInputLocked(windowToken, InputMethodManager.SHOW_IMPLICIT, null,
                                SoftInputShowHideReason.SHOW_STATE_VISIBLE_FORWARD_NAV);
                    } else {
    
    
                        Slog.e(TAG, "SOFT_INPUT_STATE_VISIBLE is ignored because"
                                + " there is no focused view that also returns true from"
                                + " View#onCheckIsTextEditor()");
                    }
                }
                break;
            case LayoutParams.SOFT_INPUT_STATE_ALWAYS_VISIBLE:
                if (DEBUG) Slog.v(TAG, "Window asks to always show input");
                if (InputMethodUtils.isSoftInputModeStateVisibleAllowed(
                        unverifiedTargetSdkVersion, startInputFlags)) {
    
    
                    if (attribute != null) {
    
    
                        res = startInputUncheckedLocked(cs, inputContext, missingMethods,
                                attribute, startInputFlags, startInputReason);
                        didStart = true;
                    }
                    showCurrentInputLocked(windowToken, InputMethodManager.SHOW_IMPLICIT, null,
                            SoftInputShowHideReason.SHOW_STATE_ALWAYS_VISIBLE);
                } else {
    
    
                    Slog.e(TAG, "SOFT_INPUT_STATE_ALWAYS_VISIBLE is ignored because"
                            + " there is no focused view that also returns true from"
                            + " View#onCheckIsTextEditor()");
                }
                break;
        }

ここでは windowSoftInputMode の 6 つの stateXXX が処理されていることが分かりますが、ウィンドウのフォーカス状態が true (前方でも後方でも) になった場合はここに移ります。それらを 1 つずつ分析してみましょう。

1.状態は変化なし

アクティビティが表示または非表示にされたときに、ソフトキーボードが最後にあった状態を保持します。

case LayoutParams.SOFT_INPUT_STATE_UNCHANGED:
                // Do nothing.
                break;

ここでの予約状態はDo nothingで何も操作が行われていないことがわかります。以前は表示されていましたが、hiddenは非表示になっています。

2.stateHidden および stateAlwaysHidden

ユーザーがアクティビティを選択するとき、つまりユーザーが別のアクティビティから戻るのではなく、実際にアクティビティに進むとき、ソフトキーボードは非表示になります。

 case LayoutParams.SOFT_INPUT_STATE_HIDDEN:
                if ((softInputMode & LayoutParams.SOFT_INPUT_IS_FORWARD_NAVIGATION) != 0) {
    
    
                    if (DEBUG) Slog.v(TAG, "Window asks to hide input going forward");
                    hideCurrentInputLocked(mCurFocusedWindow, 0, null,
                            SoftInputShowHideReason.HIDE_STATE_HIDDEN_FORWARD_NAV);
                }
                break;
 case LayoutParams.SOFT_INPUT_STATE_ALWAYS_HIDDEN:
                if (DEBUG) Slog.v(TAG, "Window asks to hide input");
                hideCurrentInputLocked(mCurFocusedWindow, 0, null,
                        SoftInputShowHideReason.HIDE_ALWAYS_HIDDEN_STATE);
                break;

コードの観点から見ると、stateHidden は、stateAlwaysHidden よりも LayoutParams.SOFT_INPUT_IS_FORWARD_NAVIGATION の判定が 1 つだけ多いだけです。LayoutParams.SOFT_INPUT_IS_FORWARD_NAVIGATION は、前に移動することによって得られるフォーカスがウィンドウであることを示します。簡単に言えば、現在のページに戻るのではなく、新しいページにジャンプすることです。stateHidden は、前にジャンプするときにのみ HideCurrentInputL を呼び出します。 ocked メソッドはインプットメソッドを非表示にしますが、stateAlwaysHidden にはその判断がありませんが、いずれの場合もウィンドウがフォーカスを取得し、インプットメソッドを非表示にします。

3.stateVisible と stateAlwaysVisible

ユーザーがアクティビティを選択するとき、つまりユーザーが別のアクティビティから戻るのではなく、実際にアクティビティに進むとき、ソフトキーボードが表示されます。
アクティビティのメインウィンドウに入力フォーカスがある場合は、常にソフトキーボードを表示します。

case LayoutParams.SOFT_INPUT_STATE_VISIBLE:
                if ((softInputMode & LayoutParams.SOFT_INPUT_IS_FORWARD_NAVIGATION) != 0) {
    
    
                    if (DEBUG) Slog.v(TAG, "Window asks to show input going forward");
                    if (InputMethodUtils.isSoftInputModeStateVisibleAllowed(
                            unverifiedTargetSdkVersion, startInputFlags)) {
    
    
                        if (attribute != null) {
    
    
                            res = startInputUncheckedLocked(cs, inputContext, missingMethods,
                                    attribute, startInputFlags, startInputReason);
                            didStart = true;
                        }
                        showCurrentInputLocked(windowToken, InputMethodManager.SHOW_IMPLICIT, null,
                                SoftInputShowHideReason.SHOW_STATE_VISIBLE_FORWARD_NAV);
                    } else {
    
    
                        Slog.e(TAG, "SOFT_INPUT_STATE_VISIBLE is ignored because"
                                + " there is no focused view that also returns true from"
                                + " View#onCheckIsTextEditor()");
                    }
                }
                break;
 case LayoutParams.SOFT_INPUT_STATE_ALWAYS_VISIBLE:
                if (DEBUG) Slog.v(TAG, "Window asks to always show input");
                if (InputMethodUtils.isSoftInputModeStateVisibleAllowed(
                        unverifiedTargetSdkVersion, startInputFlags)) {
    
    
                    if (attribute != null) {
    
    
                        res = startInputUncheckedLocked(cs, inputContext, missingMethods,
                                attribute, startInputFlags, startInputReason);
                        didStart = true;
                    }
                    showCurrentInputLocked(windowToken, InputMethodManager.SHOW_IMPLICIT, null,
                            SoftInputShowHideReason.SHOW_STATE_ALWAYS_VISIBLE);
                } else {
    
    
                    Slog.e(TAG, "SOFT_INPUT_STATE_ALWAYS_VISIBLE is ignored because"
                            + " there is no focused view that also returns true from"
                            + " View#onCheckIsTextEditor()");
                }
                break;

非表示と同様に、表示も同じルーチンなので、ここでは詳しく説明しません。
表示されると、 isSoftInputModeStateVisibleAllowed メソッドを呼び出して、表示が許可されているかどうかを判断します。このメソッドを見てください。

    static boolean isSoftInputModeStateVisibleAllowed(int targetSdkVersion,
            @StartInputFlags int startInputFlags) {
    
    
        if (targetSdkVersion < Build.VERSION_CODES.P) {
    
    
            // for compatibility.
            return true;
        }
        if ((startInputFlags & StartInputFlags.VIEW_HAS_FOCUS) == 0) {
    
    
            return false;
        }
        if ((startInputFlags & StartInputFlags.IS_TEXT_EDITOR) == 0) {
    
    
            return false;
        }
        return true;
    }

Android 9 以下では直接 true を返しますが、Android 9 以降では 2 つの判定が追加されています Android 9 以降、ソフトキーボードが自動でポップアップしなくなる原因については、こちらで説明しています。
判定入力後、インプットメソッド処理が有効かどうかを判定し、有効でない場合はstartInputUncheckedLockedを呼び出して有効にし、有効にした後はshowCurrentInputLockedで表示されているソフトキーボードを削除します。

4.状態未指定

ソフトキーボードの状態 (非表示または表示) は指定されません。適切な状態を選択するか、テーマの設定に依存するかはシステム次第です。
表示・非表示はシステムが勝手に決めるのでここでは紹介しませんが、興味のある方はご自身で勉強してください。

case LayoutParams.SOFT_INPUT_STATE_UNSPECIFIED:
                if (!isTextEditor || !doAutoShow) {
    
    
                    if (LayoutParams.mayUseInputMethod(windowFlags)) {
    
    
                        // There is no focus view, and this window will
                        // be behind any soft input window, so hide the
                        // soft input window if it is shown.
                        if (DEBUG) Slog.v(TAG, "Unspecified window will hide input");
                        hideCurrentInputLocked(
                                mCurFocusedWindow, InputMethodManager.HIDE_NOT_ALWAYS, null,
                                SoftInputShowHideReason.HIDE_UNSPECIFIED_WINDOW);

                        // If focused display changed, we should unbind current method
                        // to make app window in previous display relayout after Ime
                        // window token removed.
                        // Note that we can trust client's display ID as long as it matches
                        // to the display ID obtained from the window.
                        if (cs.selfReportedDisplayId != mCurTokenDisplayId) {
    
    
                            unbindCurrentMethodLocked();
                        }
                    }
                } else if (isTextEditor && doAutoShow
                        && (softInputMode & LayoutParams.SOFT_INPUT_IS_FORWARD_NAVIGATION) != 0) {
    
    
                    // There is a focus view, and we are navigating forward
                    // into the window, so show the input window for the user.
                    // We only do this automatically if the window can resize
                    // to accommodate the IME (so what the user sees will give
                    // them good context without input information being obscured
                    // by the IME) or if running on a large screen where there
                    // is more room for the target window + IME.
                    if (DEBUG) Slog.v(TAG, "Unspecified window will show input");
                    if (attribute != null) {
    
    
                        res = startInputUncheckedLocked(cs, inputContext, missingMethods,
                                attribute, startInputFlags, startInputReason);
                        didStart = true;
                    }
                    showCurrentInputLocked(windowToken, InputMethodManager.SHOW_IMPLICIT, null,
                            SoftInputShowHideReason.SHOW_AUTO_EDITOR_FORWARD_NAV);
                }
                break;

2. 表示モードの原理

表示メソッドはより複雑で、多くの側面が含まれます。まず、PhoneWindowManager のlayoutWindowLw メソッド (システムプロセスに属する) では、このメソッドは主にウィンドウの位置とサイズのパラメータを設定します。ソフトキーボードがポップアップするか閉じられると、ここに移動してウィンドウのサイズをリセットします。簡略化した関連コードを見てください:

public void layoutWindowLw(WindowState win, WindowState attached, DisplayFrames displayFrames) {
    
    

        final int type = attrs.type;
        final int fl = PolicyControl.getWindowFlags(win, attrs);
        final int pfl = attrs.privateFlags;
        final int sim = attrs.softInputMode;
        final int requestedSysUiFl = PolicyControl.getSystemUiVisibility(null, attrs);
        final int sysUiFl = requestedSysUiFl | getImpliedSysUiFlagsForLayout(attrs);

        final Rect pf = mTmpParentFrame;
        final Rect df = mTmpDisplayFrame;
        final Rect of = mTmpOverscanFrame;
        final Rect cf = mTmpContentFrame;
        final Rect vf = mTmpVisibleFrame;
        final Rect dcf = mTmpDecorFrame;
        final Rect sf = mTmpStableFrame;
        Rect osf = null;
        dcf.setEmpty();

        final boolean hasNavBar = (isDefaultDisplay && mHasNavigationBar
                && mNavigationBar != null && mNavigationBar.isVisibleLw());

        final int adjust = sim & SOFT_INPUT_MASK_ADJUST;

        final boolean requestedFullscreen = (fl & FLAG_FULLSCREEN) != 0
                || (requestedSysUiFl & View.SYSTEM_UI_FLAG_FULLSCREEN) != 0;

        final boolean layoutInScreen = (fl & FLAG_LAYOUT_IN_SCREEN) == FLAG_LAYOUT_IN_SCREEN;
        final boolean layoutInsetDecor = (fl & FLAG_LAYOUT_INSET_DECOR) == FLAG_LAYOUT_INSET_DECOR;

        sf.set(displayFrames.mStable);

        if (adjust != SOFT_INPUT_ADJUST_RESIZE) {
    
    
            cf.set(displayFrames.mDock);
        } else {
    
    
            cf.set(displayFrames.mContent);
        }
        applyStableConstraints(sysUiFl, fl, cf, displayFrames);
        if (adjust != SOFT_INPUT_ADJUST_NOTHING) {
    
    
            vf.set(displayFrames.mCurrent);
        } else {
    
    
            vf.set(cf);
        }
    }

首先方法里有很多Rect类型的参数被mTmpXXXFrame赋值，我们知道Rect是用来表示一个矩形区域，这里就是用来表示窗口尺寸的，我们需要关注Rect cf = mTmpContentFrame和Rect vf = mTmpVisibleFrame; 这两个参数，cf表示的是窗口内容区域的尺寸（可以理解为可供开发者使用的区域），vf表示的是窗口可见区域的尺寸；当输入法弹出或收起时根据设置的windowSoftInputMode不同这里的尺寸会发生变化，最终窗口大小的改变会回调到应用进程的ViewRootImpl中，最后到ViewRootHandler中的MSG_RESIZED事件里。

1.調整サイズ変更

上記のコードによると、 SOFT_INPUT_ADJUST_RESIZE を設定すると、cf (コンテンツ領域) が displayFrames.mContent (表示領域) に設定され、vf (可視領域) が displayFrames.mCurrent に設定されることがわかりました。混同しやすいところがあるので注意してください。 cf と displayFrames.mContent は別のことを表現しています。ソフトキーボードがポップアップすると、アプリウィンドウの表示領域が小さくなることがわかります、しかし、コンテンツ領域は小さくなりません。ソフトキーボードで覆われていますが、コンテンツ領域はまだ使用できます。
ここでは、 cf は displayFrames.mContent に設定されています。これは、ソフトキーボードで覆われた場所を使用しないことを意味します。最後に、この cf は MSG_RESIZED にコールバックされます。コードを見てみましょう:

    public void handleMessage(Message msg) {
    
    
        switch (msg.what) {
    
    
            ........
            case MSG_RESIZED: {
    
    
                // Recycled in the fall through...
                SomeArgs args = (SomeArgs) msg.obj;
                if (mWinFrame.equals(args.arg1)
                        && mPendingOverscanInsets.equals(args.arg5)
                        && mPendingContentInsets.equals(args.arg2)
                        && mPendingStableInsets.equals(args.arg6)
                        && mPendingDisplayCutout.get().equals(args.arg9)
                        && mPendingVisibleInsets.equals(args.arg3)
                        && mPendingOutsets.equals(args.arg7)
                        && mPendingBackDropFrame.equals(args.arg8)
                        && args.arg4 == null
                        && args.argi1 == 0
                        && mDisplay.getDisplayId() == args.argi3) {
    
    
                    break;
                }
            } // fall through...
            case MSG_RESIZED_REPORT:
                if (mAdded) {
    
    
                    SomeArgs args = (SomeArgs) msg.obj;

                    final int displayId = args.argi3;
                    MergedConfiguration mergedConfiguration = (MergedConfiguration) args.arg4;
                    final boolean displayChanged = mDisplay.getDisplayId() != displayId;

                    if (!mLastReportedMergedConfiguration.equals(mergedConfiguration)) {
    
    
                        // If configuration changed - notify about that and, maybe,
                        // about move to display.
                        performConfigurationChange(mergedConfiguration, false /* force */,
                                displayChanged
                                        ? displayId : INVALID_DISPLAY /* same display */);
                    } else if (displayChanged) {
    
    
                        // Moved to display without config change - report last applied one.
                        onMovedToDisplay(displayId, mLastConfigurationFromResources);
                    }

                    final boolean framesChanged = !mWinFrame.equals(args.arg1)
                            || !mPendingOverscanInsets.equals(args.arg5)
                            || !mPendingContentInsets.equals(args.arg2)
                            || !mPendingStableInsets.equals(args.arg6)
                            || !mPendingDisplayCutout.get().equals(args.arg9)
                            || !mPendingVisibleInsets.equals(args.arg3)
                            || !mPendingOutsets.equals(args.arg7);

                    mWinFrame.set((Rect) args.arg1);
                    mPendingOverscanInsets.set((Rect) args.arg5);
                    mPendingContentInsets.set((Rect) args.arg2);
                    mPendingStableInsets.set((Rect) args.arg6);
                    mPendingDisplayCutout.set((DisplayCutout) args.arg9);
                    mPendingVisibleInsets.set((Rect) args.arg3);
                    mPendingOutsets.set((Rect) args.arg7);
                    mPendingBackDropFrame.set((Rect) args.arg8);
                    mForceNextWindowRelayout = args.argi1 != 0;
                    mPendingAlwaysConsumeNavBar = args.argi2 != 0;

                    args.recycle();

                    if (msg.what == MSG_RESIZED_REPORT) {
    
    
                        reportNextDraw();
                    }

                    if (mView != null && framesChanged) {
    
    
                        forceLayout(mView);
                    }
                    requestLayout();
                }
                break;
            .........
        }
    }

SomeArgs の args.arg2 は前に設定した cf です
1. MSG_RESIZED を入力すると、SomeArgs のパラメータが以前と同じかどうかを判断し、異なる場合は MSG_RESIZED_REPORT に行きます 2. ここでサイズ情報を保存した後、forceLayout(mView) を呼び出して、ViewTree の View/ViewGroup ごとにマークレイアウトと描画を実行します。最後に、requestLayout()—> が 3 つの主要なプロセスの実行をトリガーします
。

サイズの変更が文書化されたので、これらの値がどのように使用されるかを追跡してください。requestLayout() を呼び出すと、performTraversals() メソッドの実行がトリガーされます。

#ViewRootImpl.java
    private void performTraversals() {
    
    
        if (mFirst || windowShouldResize || insetsChanged ||
                viewVisibilityChanged || params != null || mForceNextWindowRelayout) {
    
    
            ...
            boolean hwInitialized = false;
            //内容边界是否发生变化
            boolean contentInsetsChanged = false;
            try {
    
    
                ...
                //内容区域变化----------->1
                contentInsetsChanged = !mPendingContentInsets.equals(
                        mAttachInfo.mContentInsets);

                if (contentInsetsChanged || mLastSystemUiVisibility !=
                        mAttachInfo.mSystemUiVisibility || mApplyInsetsRequested
                        || mLastOverscanRequested != mAttachInfo.mOverscanRequested
                        || outsetsChanged) {
    
    
                    ...
                    //分发Inset----------->2
                    dispatchApplyInsets(host);
                    contentInsetsChanged = true;
                }
                ...
            } catch (RemoteException e) {
    
    
            }
            ...
        }
        ...
    }

1. SOFT_INPUT_ADJUST_RESIZE が設定されている場合、キーボードがポップアップするときにコンテンツ領域が変更されるため、dispatchApplyInsets()が実行されます。
2. インセットを配布します。
これらのレコードの値は、AttachInfo に対応する変数に格納されます。
このメソッドのコールスタックは次のとおりです
ここに画像の説明を挿入
。dispatchApplyWindowInsets(WindowInsets insets)のインセットは、計算前のmPendingXXに記録されている境界値で構成されます。
最後に fitSystemWindowsInt() を呼び出します。

#View.java
    private boolean fitSystemWindowsInt(Rect insets) {
    
    
        //FITS_SYSTEM_WINDOWS 为xml里设置     android:fitsSystemWindows="true"
        //对于DecorView的子布局LinearLayout来说，默认fitsSystemWindows=true
        if ((mViewFlags & FITS_SYSTEM_WINDOWS) == FITS_SYSTEM_WINDOWS) {
    
    
            ...
            //设置View的padding
            internalSetPadding(localInsets.left, localInsets.top,
                    localInsets.right, localInsets.bottom);
            return res;
        }
        return false;
    }

    protected void internalSetPadding(int left, int top, int right, int bottom) {
    
    
        ...
        if (mPaddingLeft != left) {
    
    
            changed = true;
            mPaddingLeft = left;
        }
        if (mPaddingTop != top) {
    
    
            changed = true;
            mPaddingTop = top;
        }
        if (mPaddingRight != right) {
    
    
            changed = true;
            mPaddingRight = right;
        }
        if (mPaddingBottom != bottom) {
    
    
            changed = true;
            mPaddingBottom = bottom;
        }

        if (changed) {
    
    
            requestLayout();
            invalidateOutline();
        }
    }

この回答を見て、答えは出る準備ができています。DecorView のサブレイアウト LinearLayout はパディングを設定します。これは最終的に LinearLayout サブレイアウトの高さに影響します。レイヤーごとに渡されると、デモのアクティビティレイアウトファイルの高さに影響します。

概要
SOFT_INPUT_ADJUST_RESIZE を設定すると、DecorView のサブレイアウトのパディングが変更され、最終的には子孫レイアウトの高さに影響します。

2.パンを調整する

SOFT_INPUT_ADJUST_PAN が設定されている場合、cf (コンテンツ領域) は displayFrames.mDock に設定され、vf (表示領域) も displayFrames.mCurrent に設定されます。

    /** During layout, the current screen borders along which input method windows are placed. */
    public final Rect mDock = new Rect();

レイアウト中、インプットメソッドウィンドウが配置されている現在の画面の境界線です。アプリはナビゲーションバーとステータスバーを除くコンテンツ領域を使用できることを理解しています。その後、ブレークポイントの検証を通じて、確かに SOFT_INPUT_ADJUST_RESIZE が cf を表示領域として設定し、SOFT_INPUT_ADJUST_PAN ここで cf がコンテンツ領域として設定されています。これは、アプリがインプットメソッドによってブロックされている部分を使用できることを意味します。
最終的には、
SomeArgs の MSG_RESIZED: args.arg2 にも移動します。つまり、cf のサイズは変更されていませんが、args.arg3、つまり vf は変更されているため、引き続き MSG_RESIZED_REPORT に入り、forceLayout(mView) と requestLayout() を呼び出し、3 つの主要なプロセスの実行をトリガーします。

ただし、コンテンツ領域は変更されていないため、ここではdispatchApplyInsets()は実行されません。SOFT_INPUT_ADJUST_PANの処理はどこにあるのでしょうか？
SOFT_INPUT_ADJUST_PAN の効果は、ページ全体を上に移動することであることがわかります。レイアウトの移動は、座標の変更またはコンテンツのスクロールにすぎません。移動の効果を実現するには、形式に関係なく、Canvas を移動する必要があります。PerformDraw->draw メソッドには、scrollToRectOrFocus メソッドがあります。

#View.java
    boolean scrollToRectOrFocus(Rect rectangle, boolean immediate) {
    
    
        //窗口内容区域
        final Rect ci = mAttachInfo.mContentInsets;
        //窗口可见区域
        final Rect vi = mAttachInfo.mVisibleInsets;
        //滚动距离
        int scrollY = 0;
        boolean handled = false;

        if (vi.left > ci.left || vi.top > ci.top
                || vi.right > ci.right || vi.bottom > ci.bottom) {
    
    
            scrollY = mScrollY;
            //找到当前有焦点的View------------>(1)
            final View focus = mView.findFocus();
            ...
            if (focus == lastScrolledFocus && !mScrollMayChange && rectangle == null) {
    
    
                //焦点没有发生切换，不做操作
            } else {
    
    
                // We need to determine if the currently focused view is
                // within the visible part of the window and, if not, apply
                // a pan so it can be seen.
                mLastScrolledFocus = new WeakReference<View>(focus);
                mScrollMayChange = false;
                if (DEBUG_INPUT_RESIZE) Log.v(mTag, "Need to scroll?");
                // Try to find the rectangle from the focus view.
                if (focus.getGlobalVisibleRect(mVisRect, null)) {
    
    
                    ...
                    //找到当前焦点与可见区域的相交部分
                    //mVisRect 为当前焦点在Window里的可见部分
                    if (mTempRect.intersect(mVisRect)) {
    
    
                        if (mTempRect.height() >
                                (mView.getHeight()-vi.top-vi.bottom)) {
    
    
                            ...
                        }
                        else if (mTempRect.top < vi.top) {
    
    
                            //如果当前焦点位置在窗口可见区域上边，说明焦点View应该往下移动到可见区域里边
                            scrollY = mTempRect.top - vi.top;
                        } else if (mTempRect.bottom > (mView.getHeight()-vi.bottom)) {
    
    
                            //如果当前焦点位置在窗口可见区域之下，说明其应该往上移动到可见区域里边------->(2)
                            scrollY = mTempRect.bottom - (mView.getHeight()-vi.bottom);
                        } else {
    
    
                            //无需滚动------->(3)
                            scrollY = 0;
                        }
                        handled = true;
                    }
                }
            }
        }

        if (scrollY != mScrollY) {
    
    
            //滚动距离发生变化
            if (!immediate) {
    
    
                if (mScroller == null) {
    
    
                    mScroller = new Scroller(mView.getContext());
                }
                //开始设置滚动----------->(4)
                mScroller.startScroll(0, mScrollY, 0, scrollY-mScrollY);
            } else if (mScroller != null) {
    
    
                mScroller.abortAnimation();
            }
            //赋值给成员变量
            mScrollY = scrollY;
        }
        return handled;
    }

1. 上記のデモでは、現在のフォーカスビューは EditText であり、クリックされた EditText がフォーカスを取得します。
2. 入力ボックス 2 については、キーボードがポップアップしてそれを覆うため、計算は「現在のフォーカス位置がウィンドウの可視領域の下にあり、可視領域まで移動する必要があることを示している」という条件を満たしているため、ゆっくりと > 0 となります。
3. 入力ボックス 1 については、キーボードがポップアップすると、キーボードによってブロックされずに else 分岐に進むため、scrollY = 0 になります。
4. スクロールは Scoller.java クラスを使用して行われます。

上記の操作は実際にはスクロール値を確認してメンバ変数 mScrollY に記録する操作ですが、引き続きスクロール値の使い方を見てみましょう。

#ViewRootImpl.java
    private boolean draw(boolean fullRedrawNeeded) {
    
    
        ...
        boolean animating = mScroller != null && mScroller.computeScrollOffset();
        final int curScrollY;
        //获取当前需要滚动的scroll值
        if (animating) {
    
    
            curScrollY = mScroller.getCurrY();
        } else {
    
    
            curScrollY = mScrollY;
        }
        ...
        
        int xOffset = -mCanvasOffsetX;
        //记录在yOffset里
        int yOffset = -mCanvasOffsetY + curScrollY;
        
        boolean useAsyncReport = false;
        if (!dirty.isEmpty() || mIsAnimating || accessibilityFocusDirty) {
    
    
            if (mAttachInfo.mThreadedRenderer != null && mAttachInfo.mThreadedRenderer.isEnabled()) {
    
    
                ...
                //对于走硬件加速绘制
                if (mHardwareYOffset != yOffset || mHardwareXOffset != xOffset) {
    
    
                    //记录偏移量到mHardwareYOffset里
                    mHardwareYOffset = yOffset;
                    mHardwareXOffset = xOffset;
                    invalidateRoot = true;
                }
                ..
                mAttachInfo.mThreadedRenderer.draw(mView, mAttachInfo, this);
            } else {
    
    
                //软件绘制
                //传入yOffset
                if (!drawSoftware(surface, mAttachInfo, xOffset, yOffset,
                        scalingRequired, dirty, surfaceInsets)) {
    
    
                    return false;
                }
            }
        }
        ...
        return useAsyncReport;
    }

スクロール値はハードウェアアクセラレーション描画ブランチとソフトウェア描画ブランチにそれぞれ渡され、キャンバスはそれぞれのブランチで変換されます。変換の実行方法についてはここでは詳しく説明しません。コード分析を続けることができます。

まとめ

1. SOFT_INPUT_ADJUST_PAN が設定されている場合、キーボードが現在フォーカスされている View を覆っていることが判明した場合、フォーカスされている View が表示領域に表示されるまで RootView の Canvas (ここでは Demo の DecorView を RootView として使用します) が変換されます。
2. 入力ボックス 2 をクリックすると、レイアウト全体が上に移動するのはこのためです。

3.何も調整しない

SOFT_INPUT_ADJUST_NOTHING に設定すると、cf (コンテンツ領域) が displayFrames.mDock に設定され、vf (表示領域) が cf に設定されます。実際、これはウィンドウサイズパラメータが変更されていないことを意味するため、MSG_RESIZED にコールバックされず、自然なレイアウトは変更されません。

4.未指定の調整

SOFT_INPUT_ADJUST_UNSPECIFIED が設定されているため、内部的には SOFT_INPUT_ADJUST_PAN および SOFT_INPUT_ADJUST_RESIZE のいずれかを表示に使用することになります。次に、選択基準が何であるかを見てみましょう。
SoftInputMode が設定されていない場合、デフォルトは SOFT_INPUT_ADJUST_UNSPECIFIED モードです。
引き続き ViewRootImpl.java の PerformTraversals() メソッドから分析を開始します。

    private void performTraversals() {
    
    
        ...
        if (mFirst || mAttachInfo.mViewVisibilityChanged) {
    
    
            mAttachInfo.mViewVisibilityChanged = false;
            //先查看有没有提前设置了模式
            int resizeMode = mSoftInputMode &
                    WindowManager.LayoutParams.SOFT_INPUT_MASK_ADJUST;
            
            //如果没有设置，那么默认为0，也就是SOFT_INPUT_ADJUST_UNSPECIFIED
            if (resizeMode == WindowManager.LayoutParams.SOFT_INPUT_ADJUST_UNSPECIFIED) {
    
    
                //查看mScrollContainers 数组有没有元素(View 作为元素) -------->(1)
                final int N = mAttachInfo.mScrollContainers.size();
                for (int i=0; i<N; i++) {
    
    
                    if (mAttachInfo.mScrollContainers.get(i).isShown()) {
    
    
                        //如果有元素，则设置为SOFT_INPUT_ADJUST_RESIZE 模式
                        resizeMode = WindowManager.LayoutParams.SOFT_INPUT_ADJUST_RESIZE;
                    }
                }
                if (resizeMode == 0) {
    
    
                    //如果没有设置为resize模式，则设置pan模式
                    resizeMode = WindowManager.LayoutParams.SOFT_INPUT_ADJUST_PAN;
                }
                if ((lp.softInputMode &
                        WindowManager.LayoutParams.SOFT_INPUT_MASK_ADJUST) != resizeMode) {
    
    
                    lp.softInputMode = (lp.softInputMode &
                            ~WindowManager.LayoutParams.SOFT_INPUT_MASK_ADJUST) |
                            resizeMode;
                    //最后赋值给params，让Window属性生效
                    params = lp;
                }
            }
        }
        ...
    }

前回の記事で述べたように、ここでは主に mAttachInfo.mScrollContainers を通じてスクロール可能なビューがあるかどうかを判断し、ある場合は SOFT_INPUT_ADJUST_RESIZE に設定し、ない場合は SOFT_INPUT_ADJUST_PAN に設定します。

Androidソフトキーボードの使い方と原理 windowSoftInputMode（原理）