[Android] Focus/Blur contents when window focus changes

content/public/android/java/src/org/chromium/content/browser/ContentViewCore.java

 // Copyright 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 package org.chromium.content.browser;
 
 import android.annotation.SuppressLint;
 import android.annotation.TargetApi;
 import android.app.assist.AssistStructure.ViewNode;
 import android.content.ClipData;
@@ skipping 342 matching lines @@
     // screen orientation.
     private boolean mFullscreenRequiredForOrientationLock = true;
 
     // A ViewAndroidDelegate that delegates to the current container view.
     private ViewAndroidDelegate mViewAndroidDelegate;
 
     // NOTE: This object will not be released by Android framework until the matching
     // ResultReceiver in the InputMethodService (IME app) gets gc'ed.
     private ShowKeyboardResultReceiver mShowKeyboardResultReceiver;
 
+    // Whether this ContentViewCore has view focus.
+    private boolean mHasViewFocus;
+    // Whether this ContentViewCore has window focus.
+    private boolean mHasWindowFocus;
+
     // The list of observers that are notified when ContentViewCore changes its WindowAndroid.
     private final ObserverList<WindowAndroidChangedObserver> mWindowAndroidChangedObservers;
 
     /**
      * @param webContents The {@link WebContents} to find a {@link ContentViewCore} of.
      * @return            A {@link ContentViewCore} that is connected to {@code webContents} or
      *                    {@code null} if none exists.
      */
     public static ContentViewCore fromWebContents(WebContents webContents) {
         return nativeFromWebContentsAndroid(webContents);
@@ skipping 172 matching lines @@
     // is a vital component of the ContentViewCore, so embedders must exercise caution in what
     // they do with the ContentViewCore before calling initialize().
     // We supply the nativeWebContents pointer here rather than in the constructor to allow us
     // to set the private browsing mode at a later point for the WebView implementation.
     // Note that the caller remains the owner of the nativeWebContents and is responsible for
     // deleting it after destroying the ContentViewCore.
     public void initialize(ViewAndroidDelegate viewDelegate,
             InternalAccessDelegate internalDispatcher, WebContents webContents,
             WindowAndroid windowAndroid) {
         mViewAndroidDelegate = viewDelegate;
-        setContainerView(viewDelegate.getContainerView());
+        setContainerView(viewDelegate.getContainerView(), false);

[aelias_OOO_until_Jul13, 2017/04/03 21:57:56]

Could you try just moving this to the end of the constructor instead?  Most of
the other objects being constructed in this method take the View as an argument
directly so it should be fine.  If there are any leftovers that use
ContentViewCore.getContainerView(), please change them to use the argument model
or just leave them null and initialize them in
ContentViewCore.setContainerView().

[mthiesse, 2017/04/05 14:11:23]

Done.

         long windowNativePointer = windowAndroid.getNativePointer();
         assert windowNativePointer != 0;
 
         final float dipScale = windowAndroid.getDisplay().getDipScale();
 
         mRenderCoordinates.reset();
         mRenderCoordinates.setDeviceScaleFactor(dipScale, windowAndroid.getContext());
 
         mNativeContentViewCore = nativeInit(webContents, mViewAndroidDelegate, windowNativePointer,
                 dipScale, mRetainedJavaScriptObjects);
         mWebContents = nativeGetWebContentsAndroid(mNativeContentViewCore);
 
         setContainerViewInternals(internalDispatcher);
 
         initPopupZoomer(mContext);
         mImeAdapter = createImeAdapter();
         attachImeAdapter();
 
         mSelectionPopupController = new SelectionPopupController(mContext, windowAndroid,
                 webContents, viewDelegate.getContainerView(), mRenderCoordinates, mImeAdapter);
         mSelectionPopupController.setCallback(ActionModeCallbackHelper.EMPTY_CALLBACK);
         mSelectionPopupController.setContainerView(getContainerView());
 
         mWebContentsObserver = new ContentViewWebContentsObserver(this);
 
         mShouldRequestUnbufferedDispatch = Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP
                 && ContentFeatureList.isEnabled(ContentFeatureList.REQUEST_UNBUFFERED_DISPATCH);
+
+        onFocusChangedInternal(getRealWindowFocusedState(), mContainerView.hasFocus(),
+                false /* hideKeyboardOnBlur */);
     }
 
     /**
      * Updates the native {@link ContentViewCore} with a new window. This moves the NativeView and
      * attached it to the new NativeWindow linked with the given {@link WindowAndroid}.
      * @param windowAndroid The new {@link WindowAndroid} for this {@link ContentViewCore}.
      */
     public void updateWindowAndroid(WindowAndroid windowAndroid) {
         removeDisplayAndroidObserver();
         long windowNativePointer = windowAndroid == null ? 0 : windowAndroid.getNativePointer();
@@ skipping 39 matching lines @@
     }
 
     private void removeDisplayAndroidObserver() {
         WindowAndroid windowAndroid = getWindowAndroid();
         if (windowAndroid != null) {
             windowAndroid.getDisplay().removeObserver(this);
         }
     }
 
     /**
-     * Sets a new container view for this {@link ContentViewCore}.
+     * Replaces the container view for this {@link ContentViewCore}. This ContentViewCore must
+     * already have been initialized.
      *
-     * <p>WARNING: This method can also be used to replace the existing container view,
-     * but you should only do it if you have a very good reason to. Replacing the
-     * container view has been designed to support fullscreen in the Webview so it
-     * might not be appropriate for other use cases.
+     * <p>WARNING: You should only use this method if you have a very good reason to. Replacing the
+     * container view has been designed to support fullscreen in the Webview so it might not be
+     * appropriate for other use cases.
      *
      * <p>This method only performs a small part of replacing the container view and
      * embedders are responsible for:
      * <ul>
      *     <li>Disconnecting the old container view from this ContentViewCore</li>
      *     <li>Updating the InternalAccessDelegate</li>
      *     <li>Reconciling the state of this ContentViewCore with the new container view</li>
      *     <li>Tearing down and recreating the native GL rendering where appropriate</li>
      *     <li>etc.</li>
      * </ul>
      */
-    public void setContainerView(ViewGroup containerView) {
+    public void replaceContainerView(ViewGroup containerView) {
+        assert mContainerView != null;
+        setContainerView(containerView, true);
+    }
+
+    /**
+     * Sets the container view for this {@link ContentViewCore}.
+     */
+    private void setContainerView(ViewGroup containerView, boolean initialized) {
         try {
             TraceEvent.begin("ContentViewCore.setContainerView");
             if (mContainerView != null) {
                 hideSelectPopupWithCancelMessage();
                 mPopupZoomer.hide(false);
             }
 
             mContainerView = containerView;
             mContainerView.setClickable(true);
             if (mSelectionPopupController != null) {
                 mSelectionPopupController.setContainerView(containerView);
             }
             if (mJoystickScrollProvider != null) {
                 mJoystickScrollProvider.setContainerView(containerView);
             }
             if (mJoystickZoomProvider != null) {
                 mJoystickZoomProvider.setContainerView(containerView);
             }
+            if (initialized) {
+                onFocusChangedInternal(getRealWindowFocusedState(), mContainerView.hasFocus(),
+                        false /* hideKeyboardOnBlur */);
+            }
         } finally {
             TraceEvent.end("ContentViewCore.setContainerView");
         }
     }
 
+    /**
+     * Note: We don't use View#hasWindowFocus() because it returns incorrect values when the View
+     * doesn't have View focus.
+     * @return Whether the containerView actually has Window focus.
+     */
+    private boolean getRealWindowFocusedState() {
+        int[] states = mContainerView.getDrawableState();
+        for (int state : states) {
+            if ((state & android.R.attr.state_window_focused) != 0) return true;
+        }
+        return false;
+    }
+
     @CalledByNative
     private void onNativeContentViewCoreDestroyed(long nativeContentViewCore) {
         assert nativeContentViewCore == mNativeContentViewCore;
         mNativeContentViewCore = 0;
     }
 
     /**
      * Set the Container view Internals.
      * @param internalDispatcher Handles dispatching all hidden or super methods to the
      *                           containerView.
@@ skipping 627 matching lines @@
     }
 
     private void cancelRequestToScrollFocusedEditableNodeIntoView() {
         // Zero-ing the rect will prevent |updateAfterSizeChanged()| from
         // issuing the delayed form focus event.
         mFocusPreOSKViewportRect.setEmpty();
     }
 
     /**
      * @see View#onWindowFocusChanged(boolean)
+     *
+     * This function must only be called after this ContentViewCore has been initialized.
      */
     public void onWindowFocusChanged(boolean hasWindowFocus) {
+        if (mHasWindowFocus == hasWindowFocus) return;
         mImeAdapter.onWindowFocusChanged(hasWindowFocus);
         if (!hasWindowFocus) resetGestureDetection();
         mSelectionPopupController.onWindowFocusChanged(hasWindowFocus);
         for (mGestureStateListenersIterator.rewind(); mGestureStateListenersIterator.hasNext();) {
             mGestureStateListenersIterator.next().onWindowFocusChanged(hasWindowFocus);
         }
+        onFocusChangedInternal(hasWindowFocus, mHasViewFocus, true /* hideKeyboardOnBlur */);
     }
 
-    public void onFocusChanged(boolean gainFocus, boolean hideKeyboardOnBlur) {
-        mImeAdapter.onViewFocusChanged(gainFocus, hideKeyboardOnBlur);
+    /**
+     * Called when the View focus for this ContentViewCore changes.
+     *
+     * This function must only be called after this ContentViewCore has been initialized.
+     */
+    public void onFocusChanged(boolean hasViewFocus, boolean hideKeyboardOnBlur) {
+        if (mHasViewFocus == hasViewFocus) return;
+        mImeAdapter.onViewFocusChanged(hasViewFocus, hideKeyboardOnBlur);
+        onFocusChangedInternal(mHasWindowFocus, hasViewFocus, hideKeyboardOnBlur);
+    }
+
+    private void onFocusChangedInternal(
+            boolean hasWindowFocus, boolean hasViewFocus, boolean hideKeyboardOnBlur) {
+        boolean hadInputFocus = mHasWindowFocus && mHasViewFocus;
+        boolean hasInputFocus = hasWindowFocus && hasViewFocus;
+        mHasWindowFocus = hasWindowFocus;
+        mHasViewFocus = hasViewFocus;
+        if (hasInputFocus == hadInputFocus) return;
 
         if (mJoystickScrollProvider != null) {
-            mJoystickScrollProvider.setEnabled(gainFocus && !isFocusedNodeEditable());
+            mJoystickScrollProvider.setEnabled(hasInputFocus && !isFocusedNodeEditable());
         }
 
-        if (gainFocus) {
+        if (hasInputFocus) {
             restoreSelectionPopupsIfNecessary();
         } else {
             cancelRequestToScrollFocusedEditableNodeIntoView();
             if (mPreserveSelectionOnNextLossOfFocus) {
                 mPreserveSelectionOnNextLossOfFocus = false;
                 hidePopupsAndPreserveSelection();
             } else {
                 hidePopupsAndClearSelection();
                 // Clear the selection. The selection is cleared on destroying IME
                 // and also here since we may receive destroy first, for example
                 // when focus is lost in webview.
                 clearSelection();
             }
         }
-        if (mNativeContentViewCore != 0) nativeSetFocus(mNativeContentViewCore, gainFocus);
+        if (mNativeContentViewCore != 0) nativeSetFocus(mNativeContentViewCore, hasInputFocus);
     }
 
     /**
      * @see View#onKeyUp(int, KeyEvent)
      */
     public boolean onKeyUp(int keyCode, KeyEvent event) {
         if (mPopupZoomer.isShowing() && keyCode == KeyEvent.KEYCODE_BACK) {
             mPopupZoomer.backButtonPressed();
             return true;
         }
@@ skipping 1312 matching lines @@
     private native void nativeSetTextTrackSettings(long nativeContentViewCoreImpl,
             boolean textTracksEnabled, String textTrackBackgroundColor, String textTrackFontFamily,
             String textTrackFontStyle, String textTrackFontVariant, String textTrackTextColor,
             String textTrackTextShadow, String textTrackTextSize);
 
     private native void nativeSetBackgroundOpaque(long nativeContentViewCoreImpl, boolean opaque);
     private native boolean nativeIsTouchDragDropEnabled(long nativeContentViewCoreImpl);
     private native void nativeOnDragEvent(long nativeContentViewCoreImpl, int action, int x, int y,
             int screenX, int screenY, String[] mimeTypes, String content);
 }