@zenkit-dev/cordova-plugin-keyboard 1.2.0-dev.0

package/README.md

@@ -0,0 +1,296 @@
+# cordova-plugin-keyboard
+
+> This plugin provides the `Keyboard` object which has some functions to customize and control the keyboard. It also supports the __HideKeyboardFormAccessoryBar__ (boolean) and __KeyboardShrinksView__ (boolean) preferences in config.xml.
+
+This plugin has only been tested in Cordova 3.2 or greater, and its use in previous Cordova versions is not recommended (potential conflict with keyboard customization code present in the core in previous Cordova versions). 
+
+If you do use this plugin in an older Cordova version (again, not recommended), you have to make sure the HideKeyboardFormAccessoryBar and KeyboardShrinksView preference values are *always* false, and only use the API functions to turn things on/off.
+
+This plugin was based on this Apache [project](https://github.com/apache/cordova-plugins/tree/master/keyboard) and has a compatible API.
+
+- [Installation](#installation)
+- [Methods](#methods)
+    - [cordova.plugins.Keyboard.shrinkView](#cordovapluginskeyboardshrinkview)
+    - [cordova.plugins.Keyboard.hideFormAccessoryBar](#cordovapluginskeyboardhideformaccessorybar)
+    - [cordova.plugins.Keyboard.disableScrollingInShrinkView](#cordovapluginskeyboarddisablescrollinginshrinkview)
+    - [cordova.plugins.Keyboard.hide](#cordovapluginskeyboardhide)
+    - [cordova.plugins.Keyboard.show](#cordovapluginskeyboardshow)
+- [Properties](#properties)
+    - [cordova.plugins.Keyboard.isVisible](#cordovapluginskeyboardisvisible)
+    - [cordova.plugins.Keyboard.automaticScrollToTopOnHiding](#cordovapluginskeyboardautomaticscrolltotoponhiding)
+- [Events](#events)
+    - [keyboardDidShow](#keyboarddidshow)
+    - [keyboardDidHide](#keyboarddidhide)
+    - [keyboardWillShow](#keyboardwillshow)
+    - [keyboardWillHide](#keyboardwillhide)
+    - [keyboardHeightWillChange](#keyboardheightwillchange)
+- [Releases](#releases) 
+
+# Installation
+
+From [npm](https://www.npmjs.com/package/cordova-plugin-keyboard) (stable)
+
+`cordova plugin add cordova-plugin-keyboard`
+
+From github latest (may not be stable)
+
+`cordova plugin add https://github.com/cjpearson/cordova-plugin-keyboard`
+
+# Methods
+
+## cordova.plugins.Keyboard.shrinkView
+
+Shrink the WebView when the keyboard comes up.
+
+    cordova.plugins.Keyboard.shrinkView(value, successCallback);
+
+#### Description
+
+Set to true to shrink the WebView when the keyboard comes up. The WebView shrinks instead of the viewport shrinking and the page scrollable. This applies to apps that position their elements relative to the bottom of the WebView. This is the default behaviour on Android, and makes a lot of sense when building apps as opposed to webpages.
+
+
+#### Supported Platforms
+
+- iOS
+
+#### Quick Example
+
+    cordova.plugins.Keyboard.shrinkView(true);
+    cordova.plugins.Keyboard.shrinkView(false);
+    cordova.plugins.Keyboard.shrinkView(null, function (currentValue) { console.log(currentValue); });
+
+## cordova.plugins.Keyboard.hideFormAccessoryBar
+
+Hide the keyboard toolbar.
+
+    cordova.plugins.Keyboard.hideFormAccessoryBar(value, successCallback);
+
+#### Description
+
+Set to true to hide the additional toolbar that is on top of the keyboard. This toolbar features the Prev, Next, and Done buttons.
+
+
+#### Supported Platforms
+
+- iOS
+
+#### Quick Example
+
+    cordova.plugins.Keyboard.hideFormAccessoryBar(true);
+    cordova.plugins.Keyboard.hideFormAccessoryBar(false);
+    cordova.plugins.Keyboard.hideFormAccessoryBar(null, function (currentValue) { console.log(currentValue); });
+
+## cordova.plugins.Keyboard.disableScrollingInShrinkView
+
+Disable scrolling when the the WebView is shrunk.
+
+    cordova.plugins.Keyboard.disableScrollingInShrinkView(value, successCallback);
+
+#### Description
+
+Set to true to disable scrolling when the WebView is shrunk.
+
+
+#### Supported Platforms
+
+- iOS
+
+#### Quick Example
+
+    cordova.plugins.Keyboard.disableScrollingInShrinkView(true);
+    cordova.plugins.Keyboard.disableScrollingInShrinkView(false);
+    cordova.plugins.Keyboard.disableScrollingInShrinkView(null, function (currentValue) { console.log(currentValue); });
+ 
+## cordova.plugins.Keyboard.hide
+
+Hide the keyboard
+
+    cordova.plugins.Keyboard.hide();
+
+#### Description
+
+Call this method to hide the keyboard
+
+#### Supported Platforms
+
+- iOS
+- Android
+
+#### Quick Example
+
+    cordova.plugins.Keyboard.hide();
+
+## cordova.plugins.Keyboard.show
+
+Show the keyboard
+
+    cordova.plugins.Keyboard.show();
+
+#### Description
+
+Call this method to show the keyboard.
+
+
+#### Supported Platforms
+
+- Android
+
+#### Quick Example
+
+    cordova.plugins.Keyboard.show();
+
+# Properties
+
+## cordova.plugins.Keyboard.isVisible
+
+Determine if the keyboard is visible.
+
+    if (cordova.plugins.Keyboard.isVisible) {
+        // do something
+    }
+
+#### Description
+
+Read this property to determine if the keyboard is visible.
+
+
+#### Supported Platforms
+
+- iOS
+
+## cordova.plugins.Keyboard.automaticScrollToTopOnHiding
+
+Specifies whenether content of page would be automatically scrolled to the top of the page
+when keyboard is hiding.
+
+    cordova.plugins.Keyboard.automaticScrollToTopOnHiding = true;
+
+#### Description
+
+Set this to true if you need that page scroll to beginning when keyboard is hiding.
+This is allows to fix issue with elements declared with position: fixed,
+after keyboard is hiding.
+
+
+#### Supported Platforms
+
+- iOS
+
+# Events
+
+## keyboardDidShow
+
+This event is fired when keyboard fully shown.
+
+    window.addEventListener('keyboardDidShow', function () {
+        // Describe your logic which will be run each time keyboard is shown.
+    });
+
+#### Description
+
+Attach handler to this event to be able to receive notification when keyboard is shown.
+
+
+#### Supported Platforms
+
+- iOS
+
+## keyboardDidHide
+
+This event is fired when the keyboard is fully closed.
+
+    window.addEventListener('keyboardDidHide', function () {
+        // Describe your logic which will be run each time keyboard is closed.
+    });
+
+#### Description
+
+Attach handler to this event to be able to receive notification when keyboard is closed.
+
+
+#### Supported Platforms
+
+- iOS
+
+## keyboardWillShow
+
+This event fires before keyboard will be shown.
+
+    window.addEventListener('keyboardWillShow', function () {
+        // Describe your logic which will be run each time when keyboard is about to be shown.
+    });
+
+#### Description
+
+Attach handler to this event to be able to receive notification when keyboard is about to be shown on the screen.
+
+
+#### Supported Platforms
+
+- iOS
+
+## keyboardWillHide
+
+This event is fired when the keyboard is fully closed.
+
+    window.addEventListener('keyboardWillHide', function () {
+        // Describe your logic which will be run each time when keyboard is about to be closed.
+    });
+
+#### Description
+
+Attach handler to this event to be able to receive notification when keyboard is about to be closed.
+
+
+#### Supported Platforms
+
+- iOS
+
+## keyboardHeightWillChange
+
+This event is fired when the keyboard is fully closed.
+
+    window.addEventListener('keyboardHeightWillChange', function (event) {
+        // Describe your logic which will be run each time when keyboard is about to be closed.
+        console.log(event.keyboardHeight);
+    });
+
+#### Description
+
+Attach handler to this event to be able to receive notification when keyboard is about to be closed.
+
+
+#### Supported Platforms
+
+- iOS
+
+
+# Releases
+
+- 1.0.0 
+    - Initial NPM release
+    - Fix issues with external keyboards
+    - Support keyboard events on window
+    - Fix issues with split and undocked keyboards
+    - Add keyboardHeightWillChange event
+    - Fix issues with StatusBarOverlaysWebview
+- 1.1.0
+    - Add hide/show for Android
+    - Support original keyboard event mechanism
+- 1.1.1
+    - Make compatible with cordova-android 3 and 4 (See [#2](/../../issues/2))
+    - Add hide for iOS
+- 1.1.2
+    - Fix issues with hiding the accessory bar (See [#3](/../../issues/3))
+- 1.1.3
+    - Support hiding the accessory bar when using WKWebView as the engine (See [here](https://github.com/Telerik-Verified-Plugins/WKWebView/issues/85))
+- 1.1.4
+    - Fix page scrolling (See [#14](/../../issues/14))
+    - Prevent possible app store rejections (See [#21](/../../issues/21)) 
+- 1.1.5
+    - Fix window.innerHeight when using WKWebView (See [#32](/../../issues/32))
+- 1.2.0
+    - Return current values of shrinkView, disableScroll and hideFormAccessoryBar in a success callback
+    - Fix scroller resizing bug (See [#55](/../../issues/55))
+    - Fix iOS 11.1.1 WKWebView ShrinksView bug (See [#64](/../../issues/64))
+

package/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "@zenkit-dev/cordova-plugin-keyboard",
+  "version": "1.2.0-dev.0",
+  "description": "Cordova Keyboard Plugin",
+  "cordova": {
+    "id": "cordova-plugin-keyboard",
+    "platforms": [
+      "ios"
+    ]
+  },
+  "repository": "https://github.com/zenkit/cordova-plugin-keyboard.git",
+  "keywords": [
+    "cordova",
+    "keyboard",
+    "ecosystem:cordova",
+    "cordova-ios",
+    "cordova-android"
+  ],
+  "author": "Apache Software Foundation",
+  "license": "Apache 2.0",
+  "bugs": {
+    "url": "https://github.com/cjpearson/cordova-plugin-keyboard/issues"
+  },
+  "homepage": "https://github.com/cjpearson/cordova-plugin-keyboard#readme"
+}

package/plugin.xml

@@ -0,0 +1,41 @@
+<?xml version="1.0" encoding="UTF-8" ?>
+<plugin xmlns="http://apache.org/cordova/ns/plugins/1.0"
+    id="cordova-plugin-keyboard" version="1.2.0">
+    <name>Keyboard</name>
+    <description>Cordova Keyboard Plugin</description>
+    <license>Apache 2.0</license>
+    <keywords>cordova,keyboard</keywords>
+
+    <engines>
+        <engine name="cordova" version=">=4.0.0" />
+    </engines>
+
+    <js-module src="www/keyboard.js" name="keyboard">
+        <clobbers target="window.Keyboard" />
+        <clobbers target="cordova.plugins.Keyboard" />
+    </js-module>
+
+    <platform name="ios">
+        <config-file target="config.xml" parent="/*">
+            <feature name="Keyboard">
+                <param name="ios-package" value="CDVKeyboard" onload="true" />
+            </feature>
+        </config-file>
+
+        <header-file src="src/ios/CDVKeyboard.h" />
+        <source-file src="src/ios/CDVKeyboard.m" />
+    </platform>
+
+    <platform name="android">
+        <config-file target="config.xml" parent="/*">
+            <feature name="Keyboard">
+                <param name="android-package"
+                    value="org.apache.cordova.labs.keyboard.KeyboardPlugin" />
+                <param name="onload" value="true" />
+            </feature>
+        </config-file>
+
+        <source-file src="src/android/KeyboardPlugin.java"
+            target-dir="src/org/apache/cordova/labs/keyboard" />
+    </platform>
+</plugin>

package/src/android/KeyboardPlugin.java

@@ -0,0 +1,148 @@
+package org.apache.cordova.labs.keyboard;
+
+import android.content.Context;
+import android.graphics.Point;
+import android.graphics.Rect;
+import android.os.Build;
+import android.view.Display;
+import android.view.View;
+import android.view.ViewTreeObserver;
+import android.view.ViewTreeObserver.OnGlobalLayoutListener;
+import android.view.WindowManager;
+import android.view.inputmethod.InputMethodManager;
+import org.apache.cordova.*;
+import org.json.JSONArray;
+
+public class KeyboardPlugin extends CordovaPlugin {
+    private OnGlobalLayoutListener listener;
+    private boolean keyboardWasVisible = false;
+    private double KEYBOARD_MIN_HEIGHT_RATIO = 0.15;
+
+    private InputMethodManager getInputManager() {
+        return (InputMethodManager) cordova.getActivity().getSystemService(
+            Context.INPUT_METHOD_SERVICE);
+    }
+
+    private View getContentView() {
+        return cordova.getActivity().findViewById(android.R.id.content);
+    }
+
+    private ViewTreeObserver getRootViewTreeObserver() {
+        return getContentView().getRootView().getViewTreeObserver();
+    }
+    private ViewTreeObserver getWebViewTreeObserver() {
+        return webView.getView().getViewTreeObserver();
+    }
+
+    private void fireWindowEvent(String event) {
+        cordova.getActivity().runOnUiThread((Runnable) () -> {
+            String js = "cordova.fireWindowEvent('" + event + "');";
+            webView.getEngine().evaluateJavascript(js, null);
+        });
+    }
+    private void fireWindowEventAfterWebViewLayout(String event) {
+        getWebViewTreeObserver().addOnGlobalLayoutListener(new OnGlobalLayoutListener() {
+            @Override
+            public void onGlobalLayout() {
+                fireWindowEvent(event);
+                getWebViewTreeObserver().removeOnGlobalLayoutListener(this);
+            }
+        });
+    }
+
+    private int getScreenHeight(View root) {
+        if (Build.VERSION.SDK_INT < 21) {
+            return root.getRootView().getHeight();
+        }
+
+        Point size = new Point();
+        Display display = cordova.getActivity().getWindowManager().getDefaultDisplay();
+        display.getSize(size);
+        return size.y;
+    }
+
+    // NOTE: Determine if keyboard is visible
+    // (Implementation adapted from https://github.com/yshrsmz/KeyboardVisibilityEvent)
+    private boolean isKeyboardVisible() {
+        Rect r = new Rect();
+        View content = getContentView();
+        View root = content.getRootView();
+        root.getWindowVisibleDisplayFrame(r);
+
+        int[] location = new int[2];
+        content.getLocationOnScreen(location);
+
+        int screenHeight = getScreenHeight(root);
+        int heightDiff = screenHeight - r.height() - location[1];
+
+        return heightDiff > screenHeight * KEYBOARD_MIN_HEIGHT_RATIO;
+    }
+
+    private boolean isSoftInputAdjustNothing() {
+        int softInputMode = cordova.getActivity().getWindow().getAttributes().softInputMode;
+        int softInputAdjust = softInputMode & WindowManager.LayoutParams.SOFT_INPUT_MASK_ADJUST;
+        return (softInputAdjust & WindowManager.LayoutParams.SOFT_INPUT_ADJUST_NOTHING)
+            == WindowManager.LayoutParams.SOFT_INPUT_ADJUST_NOTHING;
+    }
+
+    @Override
+    protected void pluginInitialize() {
+        super.pluginInitialize();
+
+        // The window will not be resized in case of SOFT_INPUT_ADJUST_NOTHING
+        if (isSoftInputAdjustNothing()) {
+            return;
+        }
+
+        listener = () -> {
+            boolean keyboardIsVisible = isKeyboardVisible();
+            if (keyboardWasVisible != keyboardIsVisible) {
+                if (keyboardIsVisible) {
+                    fireWindowEvent("keyboardWillShow");
+                    fireWindowEventAfterWebViewLayout("keyboardDidShow");
+                } else {
+                    fireWindowEvent("keyboardWillHide");
+                    fireWindowEventAfterWebViewLayout("keyboardDidHide");
+                }
+            }
+            keyboardWasVisible = keyboardIsVisible;
+        };
+
+        getRootViewTreeObserver().addOnGlobalLayoutListener(listener);
+    }
+
+    @Override
+    public void onDestroy() {
+        super.onDestroy();
+        if (listener != null) {
+            getRootViewTreeObserver().removeOnGlobalLayoutListener(listener);
+        }
+    }
+
+    @Override
+    public boolean execute(String action, JSONArray args, CallbackContext callbackContext) {
+        if ("show".equals(action)) {
+            cordova.getThreadPool().execute((Runnable) () -> {
+                getInputManager().toggleSoftInput(0, InputMethodManager.HIDE_IMPLICIT_ONLY);
+                callbackContext.success();
+            });
+            return true;
+        }
+        if ("hide".equals(action)) {
+            cordova.getThreadPool().execute((Runnable) () -> {
+                View view = cordova.getActivity().getCurrentFocus();
+
+                if (view == null) {
+                    callbackContext.error("No current focus");
+                    return;
+                }
+
+                getInputManager().hideSoftInputFromWindow(
+                    view.getWindowToken(), InputMethodManager.HIDE_NOT_ALWAYS);
+                callbackContext.success();
+            });
+            return true;
+        }
+        return false;
+    }
+}

package/src/ios/CDVKeyboard.h

@@ -0,0 +1,5 @@
+#import <Cordova/CDVPlugin.h>
+
+@interface CDVKeyboard : CDVPlugin
+
+@end

package/src/ios/CDVKeyboard.m

@@ -0,0 +1,337 @@
+#import "CDVKeyboard.h"
+#import <Cordova/CDVAvailability.h>
+#import <Cordova/NSDictionary+CordovaPreferences.h>
+#import <objc/runtime.h>
+
+@interface CDVKeyboard () <UIScrollViewDelegate>
+
+@property(nonatomic, readwrite, assign) BOOL keyboardIsVisible;
+@property(readwrite, assign, nonatomic) BOOL keyboardShrinksView;
+@property(readwrite, assign, nonatomic) BOOL hideFormAccessoryBar;
+@property(readwrite, assign, nonatomic) BOOL keyboardDisablesScrolling;
+@property(readwrite, assign, nonatomic) UIKeyboardAppearance keyboardAppearance;
+
+@end
+
+@implementation CDVKeyboard
+
+#pragma mark CordovaHelper
+- (void)fireWindowEvent:(NSString *)event {
+    NSString *js = [NSString stringWithFormat:@"cordova.fireWindowEvent('%@')", event];
+    // Don't schedule the js in the run loop so the the window event handler can handle the events
+    // as soon as possible.
+    [self.commandDelegate evalJs:js scheduledOnRunLoop:false];
+}
+
+#pragma mark Initialize
+
+NSString *WKClassString;
+NSString *UITraitsClassString;
+
+- (void)pluginInitialize {
+    WKClassString = @"WKContentView";
+    UITraitsClassString = @"UITextInputTraits";
+
+    NSDictionary *settings = self.commandDelegate.settings;
+
+    self.keyboardShrinksView = [settings cordovaBoolSettingForKey:@"KeyboardShrinksView"
+                                                     defaultValue:YES];
+
+    Boolean hide = [settings cordovaBoolSettingForKey:@"HideKeyboardFormAccessoryBar"
+                                         defaultValue:YES];
+    [self setHideFormAccessoryBar:hide];
+
+    Boolean disabled = [settings cordovaBoolSettingForKey:@"KeyboardDisablesScrolling"
+                                             defaultValue:YES];
+    [self setKeyboardDisablesScrolling:disabled];
+
+    NSString *keyboardStyle = [settings cordovaSettingForKey:@"KeyboardStyle"];
+
+    if (keyboardStyle) {
+        [self setKeyboardAppearanceForStyle:keyboardStyle];
+    }
+
+    NSNotificationCenter *nc = [NSNotificationCenter defaultCenter];
+
+    [nc addObserver:self
+           selector:@selector(onKeyboardWillHide:)
+               name:UIKeyboardWillHideNotification
+             object:nil];
+    [nc addObserver:self
+           selector:@selector(onKeyboardDidHide:)
+               name:UIKeyboardDidHideNotification
+             object:nil];
+    [nc addObserver:self
+           selector:@selector(onKeyboardWillShow:)
+               name:UIKeyboardWillShowNotification
+             object:nil];
+    [nc addObserver:self
+           selector:@selector(onKeyboardDidShow:)
+               name:UIKeyboardDidShowNotification
+             object:nil];
+    [nc addObserver:self
+           selector:@selector(onKeyboardWillChangeFrame:)
+               name:UIKeyboardWillChangeFrameNotification
+             object:nil];
+
+    // Prevent WKWebView to resize window
+    [nc removeObserver:self.webView name:UIKeyboardWillHideNotification object:nil];
+    [nc removeObserver:self.webView name:UIKeyboardWillShowNotification object:nil];
+    [nc removeObserver:self.webView name:UIKeyboardWillChangeFrameNotification object:nil];
+    [nc removeObserver:self.webView name:UIKeyboardDidChangeFrameNotification object:nil];
+}
+
+#pragma mark KeyboardEvents
+
+- (void)onKeyboardWillShow:(NSNotification *)notification {
+    [self fireWindowEvent:@"keyboardWillShow"];
+    self.keyboardIsVisible = YES;
+}
+- (void)onKeyboardDidShow:(NSNotification *)notification {
+    [self fireWindowEvent:@"keyboardDidShow"];
+}
+- (void)onKeyboardWillHide:(NSNotification *)notification {
+    [self fireWindowEvent:@"keyboardWillHide"];
+    self.keyboardIsVisible = NO;
+}
+- (void)onKeyboardDidHide:(NSNotification *)notification {
+    [self fireWindowEvent:@"keyboardDidHide"];
+}
+- (void)onKeyboardWillChangeFrame:(NSNotification *)notification {
+    // If the view is not visible, we should do nothing. E.g. if the inappbrowser
+    // is open.
+    if (!(self.viewController.isViewLoaded && self.viewController.view.window)) {
+        return;
+    }
+
+    // Note: we check for _keyboardShrinksView at this point instead of the
+    // beginning of the method to handle the case where the user disabled
+    // shrinkView while the keyboard is showing.
+    if (!_keyboardShrinksView) {
+        return;
+    }
+
+    // Delay the actual resizing so the will show/hide events fire first.
+    [self performSelector:@selector(resizeView:) withObject:notification afterDelay:0];
+}
+
+#pragma mark KeyboardAppearance
+
+- (void)setKeyboardAppearance:(UIKeyboardAppearance)keyboardAppearance {
+    if (keyboardAppearance == _keyboardAppearance) {
+        return;
+    }
+
+    IMP appearanceImpl = imp_implementationWithBlock(^(id _s) {
+      return keyboardAppearance;
+    });
+
+    for (NSString *classString in @[ WKClassString, UITraitsClassString ]) {
+        Class class = NSClassFromString(classString);
+        SEL selector = @selector(keyboardAppearance);
+        Method method = class_getInstanceMethod(class, selector);
+
+        if (method != NULL) {
+            method_setImplementation(method, appearanceImpl);
+        } else {
+            class_addMethod(class, selector, appearanceImpl, "l@:");
+        }
+    }
+
+    _keyboardAppearance = keyboardAppearance;
+}
+
+- (void)setKeyboardAppearanceForStyle:(NSString *)style {
+    UIKeyboardAppearance appearance = UIKeyboardAppearanceLight;
+    if ([[style lowercaseString] isEqualToString:@"dark"]) {
+        appearance = UIKeyboardAppearanceDark;
+    }
+    [self setKeyboardAppearance:appearance];
+}
+
+#pragma mark HideFormAccessoryBar
+
+static IMP WKOriginalImp;
+
+- (void)setHideFormAccessoryBar:(BOOL)hideFormAccessoryBar {
+    if (hideFormAccessoryBar == _hideFormAccessoryBar) {
+        return;
+    }
+
+    Method WKMethod =
+        class_getInstanceMethod(NSClassFromString(WKClassString), @selector(inputAccessoryView));
+
+    if (hideFormAccessoryBar) {
+        WKOriginalImp = method_getImplementation(WKMethod);
+
+        IMP hideFormAccessoryBarImpl = imp_implementationWithBlock(^(id _s) {
+          return nil;
+        });
+
+        method_setImplementation(WKMethod, hideFormAccessoryBarImpl);
+    } else {
+        method_setImplementation(WKMethod, WKOriginalImp);
+    }
+
+    _hideFormAccessoryBar = hideFormAccessoryBar;
+}
+
+#pragma mark KeyboardShrinksView
+
+- (CGFloat)calculateFrameHeight:(NSNotification *)notification {
+    UIScreen *screen = self.webView.window.screen;
+    CGFloat superviewFrameHeight = self.webView.superview.frame.size.height;
+    CGRect keyboardEndFrame =
+        [[notification.userInfo valueForKey:UIKeyboardFrameEndUserInfoKey] CGRectValue];
+
+    // NOTE: Detect if the keyboard is attached or floating.
+    // If the keyboard is floating it's frame should not match the screen bounds.
+    BOOL keyboardAttached = screen.bounds.origin.x == keyboardEndFrame.origin.x &&
+                            screen.bounds.size.width == keyboardEndFrame.size.width;
+
+    // NOTE: If the keyboard is floating (not attached) we reset the view height.
+    if (keyboardAttached == NO) {
+        return superviewFrameHeight;
+    }
+
+    CGPoint keyboardOrigin = [self.webView convertPoint:keyboardEndFrame.origin toView:nil];
+    CGPoint relativeFrameOrigin = [self.webView convertPoint:self.webView.frame.origin
+                                           toCoordinateSpace:screen.coordinateSpace];
+
+    // NOTE: We set the web view height to the y position of keyboard,
+    // this should prevent an error in the calculation beeing carried over.
+    // (e.g. the view could already be changed because we call this with a delay)
+    // But we need to calculate the y position relative to the view position on the screem.
+    // (e.g. to account for the statusbar or the "Slide Over" multitask mode on iPads)
+    CGFloat relativeKeyboardY = keyboardOrigin.y - relativeFrameOrigin.y;
+
+    // NOTE: We don't allow the frame height to be smaller than 0 or bigger than the superview.
+    // If this happened we porbably calculated something wrong,
+    // in that case it is porbably better to reset the height.
+    if (relativeKeyboardY <= 0 || relativeKeyboardY > superviewFrameHeight) {
+        return superviewFrameHeight;
+    }
+    return relativeKeyboardY;
+}
+
+- (void)resizeView:(NSNotification *)notification {
+    CGRect frame = self.webView.frame;
+    CGFloat frameHeight = [self calculateFrameHeight:notification];
+    if (frame.size.height == frameHeight) {
+        return;
+    }
+
+    double duration =
+        [[notification.userInfo valueForKey:UIKeyboardAnimationDurationUserInfoKey] doubleValue];
+    UIViewAnimationCurve curve =
+        [[notification.userInfo valueForKey:UIKeyboardAnimationCurveUserInfoKey] integerValue];
+
+    [UIView beginAnimations:nil context:nil];
+    [UIView setAnimationDuration:duration];
+    [UIView setAnimationCurve:curve];
+    frame.size.height = frameHeight;
+    self.webView.frame = frame;
+    [UIView commitAnimations];
+}
+
+#pragma mark KeyboardDisablesScrolling
+- (void)scrollViewDidScroll:(UIScrollView *)scrollView {
+    [scrollView setContentOffset:CGPointZero];
+}
+
+- (void)setKeyboardDisablesScrolling:(BOOL)keyboardDisablesScrolling {
+    if (keyboardDisablesScrolling == _keyboardDisablesScrolling) {
+        return;
+    }
+
+    if (keyboardDisablesScrolling) {
+        self.webView.scrollView.scrollEnabled = NO;
+        self.webView.scrollView.delegate = self;
+    } else {
+        self.webView.scrollView.scrollEnabled = YES;
+        self.webView.scrollView.delegate = nil;
+    }
+
+    _keyboardDisablesScrolling = keyboardDisablesScrolling;
+}
+
+#pragma mark Plugin Interface
+
+- (void)keyboardShrinksView:(CDVInvokedUrlCommand *)command {
+    if (command.arguments.count > 0) {
+        id value = [command.arguments objectAtIndex:0];
+        if (!([value isKindOfClass:[NSNumber class]])) {
+            value = [NSNumber numberWithBool:NO];
+        }
+
+        self.keyboardShrinksView = [value boolValue];
+    }
+
+    CDVPluginResult *result = [CDVPluginResult resultWithStatus:CDVCommandStatus_OK
+                                                  messageAsBool:self.keyboardShrinksView];
+    [self.commandDelegate sendPluginResult:result callbackId:command.callbackId];
+}
+
+- (void)keyboardDisablesScrolling:(CDVInvokedUrlCommand *)command {
+    Boolean disabled = self.keyboardDisablesScrolling;
+    if (command.arguments.count > 0) {
+        id value = [command.arguments objectAtIndex:0];
+        if (!([value isKindOfClass:[NSNumber class]])) {
+            value = [NSNumber numberWithBool:NO];
+        }
+
+        disabled = [value boolValue];
+    }
+
+    [self setKeyboardDisablesScrolling:disabled];
+
+    CDVPluginResult *result = [CDVPluginResult resultWithStatus:CDVCommandStatus_OK
+                                                  messageAsBool:self.keyboardDisablesScrolling];
+    [self.commandDelegate sendPluginResult:result callbackId:command.callbackId];
+}
+
+- (void)hideFormAccessoryBar:(CDVInvokedUrlCommand *)command {
+    Boolean hide = self.hideFormAccessoryBar;
+    if (command.arguments.count > 0) {
+        id value = [command.arguments objectAtIndex:0];
+        if (!([value isKindOfClass:[NSNumber class]])) {
+            value = [NSNumber numberWithBool:NO];
+        }
+
+        hide = [value boolValue];
+    }
+
+    [self setHideFormAccessoryBar:hide];
+
+    CDVPluginResult *result = [CDVPluginResult resultWithStatus:CDVCommandStatus_OK
+                                                  messageAsBool:self.hideFormAccessoryBar];
+    [self.commandDelegate sendPluginResult:result callbackId:command.callbackId];
+}
+
+- (void)hide:(CDVInvokedUrlCommand *)command {
+    [self.webView endEditing:YES];
+
+    CDVPluginResult *result = [CDVPluginResult resultWithStatus:CDVCommandStatus_OK];
+    [self.commandDelegate sendPluginResult:result callbackId:command.callbackId];
+}
+
+- (void)setKeyboardStyle:(CDVInvokedUrlCommand *)command {
+    NSString *style = @"light";
+    id value = [command.arguments objectAtIndex:0];
+    if ([value isKindOfClass:[NSString class]]) {
+        style = (NSString *)value;
+    }
+
+    [self setKeyboardAppearanceForStyle:style];
+
+    CDVPluginResult *result = [CDVPluginResult resultWithStatus:CDVCommandStatus_OK];
+    [self.commandDelegate sendPluginResult:result callbackId:command.callbackId];
+}
+
+#pragma mark dealloc
+
+- (void)dealloc {
+    [[NSNotificationCenter defaultCenter] removeObserver:self];
+}
+
+@end

package/www/keyboard.js

@@ -0,0 +1,45 @@
+var cordova = require('cordova');
+var exec = require('cordova/exec');
+
+var isNil = function (value) {
+    return value === undefined || value === null;
+};
+
+var Keyboard = { isVisible: false };
+
+window.addEventListener('keyboardDidShow', function () {
+    Keyboard.isVisible = true;
+});
+
+window.addEventListener('keyboardDidHide', function () {
+    Keyboard.isVisible = false;
+});
+
+Keyboard.keyboardShrinksView = function (shrink, success, failure) {
+    var args = isNil(shrink) ? [] : [shrink];
+    exec(success, failure, 'Keyboard', 'keyboardShrinksView', args);
+};
+
+Keyboard.hideFormAccessoryBar = function (hide, success, failure) {
+    var args = isNil(hide) ? [] : [hide];
+    exec(success, failure, 'Keyboard', 'hideFormAccessoryBar', args);
+};
+
+Keyboard.keyboardDisablesScrolling = function (disable, success, failure) {
+    var args = isNil(disable) ? [] : [disable];
+    exec(success, failure, 'Keyboard', 'keyboardDisablesScrolling', args);
+};
+
+Keyboard.show = function (success, failure) {
+    exec(success, failure, 'Keyboard', 'show', []);
+};
+
+Keyboard.hide = function (success, failure) {
+    exec(success, failure, 'Keyboard', 'hide', []);
+};
+
+Keyboard.setKeyboardStyle = function (style) {
+    exec(null, null, 'Keyboard', 'setKeyboardStyle', [style]);
+};
+
+module.exports = Keyboard;