iOS: Refactor text input handling to standalone responder

Instead of coupling the visibility of the virtual keyboard to
the first-responder status of the currently active QUIView, we
now treat first-responder as a separate state, tied directly
to QWindow activation. This fits better with the concept of
first-responders in iOS, as a UIView can become first-responder
without dealing with text input, eg when dealing with touch
events or menu actions.

The decision point on whether or not to show the virtual
keyboard is then handled by implementing the conformsToProtocol
method and selectively returning YES for the UIKeyInput protocol.
iOS internally calls _requiresKeyboardWhenFirstResponder on the
UIResponder to determine this, but since we can't override a
private method (like WKContentView in WebKit does) we have to
rely on the fact that the implementation of the method uses the
protocol conformance to make its decision.

Once the virtual keyboard is up, we then need to react to changes
to its configuration, such as keyboard type or the type of return
key. Normally this would be a simple call to [view reloadInputViews],
but iOS will not reload the built-in keyboards unless the UIResponder
returns YES for _requiresKeyboardResetOnReload. Since we again can't
override this private method (like WebKit does), we work around it
by taking advantage of the fact that iOS will treat any change to
the first-responder as a reason to do a keyboard reset. By using
a stand-alone UIResponder for text input we can init and destroy
these responders as needed, so that every call to reloadInputViews
will trigger a reset, as the responder has not been seen before.

We keep track of changes to the input-method-query, and detect
whether or not we need to bring up a new UIResponder for text
handling.

As part of this refactoring we now tie the visibility of the
virtual keyboard to the presence of a focus object that has
input-methods enabled. This means that we automatically will
track changes to input-elements through the focus changes,
and reconfigure or hide the keyboard as appropriate. As a
result the hide() method of QInputMethod becomes a no-op on
iOS.

Change-Id: I4c4834df490bc8b0bac32aeedbd819780bd5aaba
Reviewed-by: Richard Moe Gustavsen <richard.gustavsen@digia.com>

1 files changed, 117 insertions, 60 deletions

diff --git a/src/plugins/platforms/ios/qiosinputcontext.mm b/src/plugins/platforms/ios/qiosinputcontext.mm
index 064098157d..cbf3fb4ff2 100644
--- a/src/plugins/platforms/ios/qiosinputcontext.mm
+++ b/src/plugins/platforms/ios/qiosinputcontext.mm
@@ -44,8 +44,10 @@
 #import <UIKit/UIGestureRecognizerSubclass.h>
 
 #include "qiosglobal.h"
+#include "qiostextresponder.h"
 #include "qioswindow.h"
 #include "quiview.h"
+
 #include <QGuiApplication>
 #include <QtGui/private/qwindow_p.h>
 
@@ -158,8 +160,6 @@
 
 - (void) keyboardWillShow:(NSNotification *)notification
 {
-    if ([QUIView inUpdateKeyboardLayout])
-        return;
     // Note that UIKeyboardWillShowNotification is only sendt when the keyboard is docked.
     m_keyboardVisibleAndDocked = YES;
     m_keyboardEndRect = [self getKeyboardRect:notification];
@@ -173,8 +173,6 @@
 
 - (void) keyboardWillHide:(NSNotification *)notification
 {
-    if ([QUIView inUpdateKeyboardLayout])
-        return;
     // Note that UIKeyboardWillHideNotification is also sendt when the keyboard is undocked.
     m_keyboardVisibleAndDocked = NO;
     m_keyboardEndRect = [self getKeyboardRect:notification];
@@ -207,7 +205,7 @@
     QPointF p = fromCGPoint([[touches anyObject] locationInView:m_viewController.view]);
     if (m_keyboardRect.contains(p)) {
         m_keyboardHiddenByGesture = YES;
-        m_context->hideInputPanel();
+        m_context->hideVirtualKeyboard();
     }
 
     [super touchesMoved:touches withEvent:event];
@@ -253,11 +251,43 @@
 
 @end
 
+// -------------------------------------------------------------------------
+
+Qt::InputMethodQueries ImeState::update(Qt::InputMethodQueries properties)
+{
+    if (!properties)
+        return 0;
+
+    QInputMethodQueryEvent newState(properties);
+
+    if (qApp && qApp->focusObject())
+        QCoreApplication::sendEvent(qApp->focusObject(), &newState);
+
+    Qt::InputMethodQueries updatedProperties;
+    for (uint i = 0; i < (sizeof(Qt::ImQueryAll) * CHAR_BIT); ++i) {
+        if (Qt::InputMethodQuery property = Qt::InputMethodQuery(int(properties & (1 << i)))) {
+            if (newState.value(property) != currentState.value(property)) {
+                updatedProperties |= property;
+                currentState.setValue(property, newState.value(property));
+            }
+        }
+    }
+
+    return updatedProperties;
+}
+
+// -------------------------------------------------------------------------
+
+static QUIView *focusView()
+{
+    return qApp->focusWindow() ?
+        reinterpret_cast<QUIView *>(qApp->focusWindow()->handle()->winId()) : 0;
+}
+
 QIOSInputContext::QIOSInputContext()
     : QPlatformInputContext()
     , m_keyboardListener([[QIOSKeyboardListener alloc] initWithQIOSInputContext:this])
-    , m_focusView(0)
-    , m_hasPendingHideRequest(false)
+    , m_textResponder(0)
 {
     if (isQtApplication())
         connect(qGuiApp->inputMethod(), &QInputMethod::cursorRectangleChanged, this, &QIOSInputContext::cursorRectangleChanged);
@@ -267,7 +297,7 @@ QIOSInputContext::QIOSInputContext()
 QIOSInputContext::~QIOSInputContext()
 {
     [m_keyboardListener release];
-    [m_focusView release];
+    [m_textResponder release];
 }
 
 QRectF QIOSInputContext::keyboardRect() const
@@ -277,61 +307,22 @@ QRectF QIOSInputContext::keyboardRect() const
 
 void QIOSInputContext::showInputPanel()
 {
-    if (m_keyboardListener->m_keyboardHiddenByGesture) {
-        // We refuse to re-show the keyboard until the touch
-        // sequence that triggered the gesture has ended.
-        return;
-    }
-
-    // Documentation tells that one should call (and recall, if necessary) becomeFirstResponder/resignFirstResponder
-    // to show/hide the keyboard. This is slightly inconvenient, since there exist no API to get the current first
-    // responder. Rather than searching for it from the top, we let the active QIOSWindow tell us which view to use.
-    // Note that Qt will forward keyevents to whichever QObject that needs it, regardless of which UIView the input
-    // actually came from. So in this respect, we're undermining iOS' responder chain.
-    m_hasPendingHideRequest = false;
-    [m_focusView becomeFirstResponder];
+    // No-op, keyboard controlled fully by platform based on focus
 }
 
 void QIOSInputContext::hideInputPanel()
 {
-    // Delay hiding the keyboard for cases where the user is transferring focus between
-    // 'line edits'. In that case the 'line edit' that lost focus will close the input
-    // panel, just to see that the new 'line edit' will open it again:
-    m_hasPendingHideRequest = true;
-    dispatch_async(dispatch_get_main_queue(), ^{
-        if (m_hasPendingHideRequest)
-            [m_focusView resignFirstResponder];
-    });
+    // No-op, keyboard controlled fully by platform based on focus
 }
 
-bool QIOSInputContext::isInputPanelVisible() const
+void QIOSInputContext::hideVirtualKeyboard()
 {
-    return m_keyboardListener->m_keyboardVisible;
+    static_cast<QWindowPrivate *>(QObjectPrivate::get(qApp->focusWindow()))->clearFocusObject();
 }
 
-void QIOSInputContext::setFocusObject(QObject *focusObject)
-{
-    if (!focusObject || !m_focusView || !m_focusView.isFirstResponder) {
-        scroll(0);
-        return;
-    }
-
-    reset();
-
-    if (m_keyboardListener->m_keyboardVisibleAndDocked)
-        scrollToCursor();
-}
-
-void QIOSInputContext::focusWindowChanged(QWindow *focusWindow)
+bool QIOSInputContext::isInputPanelVisible() const
 {
-    QUIView *view = focusWindow ? reinterpret_cast<QUIView *>(focusWindow->handle()->winId()) : 0;
-    if ([m_focusView isFirstResponder])
-        [view becomeFirstResponder];
-    [m_focusView release];
-    m_focusView = [view retain];
-
-    if (view.window != m_keyboardListener->m_viewController.view)
-        scroll(0);
+    return m_keyboardListener->m_keyboardVisible;
 }
 
 void QIOSInputContext::cursorRectangleChanged()
@@ -353,7 +344,7 @@ void QIOSInputContext::cursorRectangleChanged()
 
 void QIOSInputContext::scrollToCursor()
 {
-    if (!isQtApplication() || !m_focusView)
+    if (!isQtApplication())
         return;
 
     if (m_keyboardListener->m_touchPressWhileKeyboardVisible) {
@@ -364,12 +355,12 @@ void QIOSInputContext::scrollToCursor()
     }
 
     UIView *view = m_keyboardListener->m_viewController.view;
-    if (view.window != m_focusView.window)
+    if (view.window != focusView().window)
         return;
 
     const int margin = 20;
     QRectF translatedCursorPos = qApp->inputMethod()->cursorRectangle();
-    translatedCursorPos.translate(m_focusView.qwindow->geometry().topLeft());
+    translatedCursorPos.translate(focusView().qwindow->geometry().topLeft());
     qreal keyboardY = m_keyboardListener->m_keyboardEndRect.y();
     int statusBarY = qGuiApp->primaryScreen()->availableGeometry().y();
 
@@ -398,18 +389,84 @@ void QIOSInputContext::scroll(int y)
     ];
 }
 
-void QIOSInputContext::update(Qt::InputMethodQueries query)
+// -------------------------------------------------------------------------
+
+void QIOSInputContext::setFocusObject(QObject *focusObject)
+{
+    Q_UNUSED(focusObject);
+
+    reset();
+
+    if (m_keyboardListener->m_keyboardVisibleAndDocked)
+        scrollToCursor();
+}
+
+void QIOSInputContext::focusWindowChanged(QWindow *focusWindow)
+{
+    Q_UNUSED(focusWindow);
+
+    reset();
+
+    if (m_keyboardListener->m_keyboardVisibleAndDocked)
+        scrollToCursor();
+}
+
+/*!
+    Called by the input item to inform the platform input methods when there has been
+    state changes in editor's input method query attributes. When calling the function
+    \a queries parameter has to be used to tell what has changes, which input method
+    can use to make queries for attributes it's interested with QInputMethodQueryEvent.
+*/
+void QIOSInputContext::update(Qt::InputMethodQueries updatedProperties)
 {
-    [m_focusView updateInputMethodWithQuery:query];
+    // Mask for properties that we are interested in and see if any of them changed
+    updatedProperties &= (Qt::ImEnabled | Qt::ImHints | Qt::ImQueryInput);
+
+    Qt::InputMethodQueries changedProperties = m_imeState.update(updatedProperties);
+    if (changedProperties & (Qt::ImEnabled | Qt::ImHints)) {
+        // Changes to enablement or hints require virtual keyboard reconfigure
+        [m_textResponder release];
+        m_textResponder = [[QIOSTextInputResponder alloc] initWithInputContext:this];
+        [m_textResponder reloadInputViews];
+    } else {
+        [m_textResponder notifyInputDelegate:changedProperties];
+    }
 }
 
+/*!
+    Called by the input item to reset the input method state.
+*/
 void QIOSInputContext::reset()
 {
-    [m_focusView reset];
+    update(Qt::ImQueryAll);
+
+    [m_textResponder setMarkedText:@"" selectedRange:NSMakeRange(0, 0)];
+    [m_textResponder notifyInputDelegate:Qt::ImQueryInput];
 }
 
+/*!
+    Commits the word user is currently composing to the editor. The function is
+    mostly needed by the input methods with text prediction features and by the
+    methods where the script used for typing characters is different from the
+    script that actually gets appended to the editor. Any kind of action that
+    interrupts the text composing needs to flush the composing state by calling the
+    commit() function, for example when the cursor is moved elsewhere.
+*/
 void QIOSInputContext::commit()
 {
-    [m_focusView commit];
+    [m_textResponder unmarkText];
+    [m_textResponder notifyInputDelegate:Qt::ImSurroundingText];
 }
 
+// -------------------------------------------------------------------------
+
+@interface QUIView (InputMethods)
+- (void)reloadInputViews;
+@end
+
+@implementation QUIView (InputMethods)
+- (void)reloadInputViews
+{
+    qApp->inputMethod()->reset();
+}
+@end