Merge lp:~bfiller/ubuntu-keyboard/back-to-rev-44 into lp:ubuntu-keyboard

[Bill Filler]

revert back to rev 44

revert back to rev 44

[lp:~bfiller/ubuntu-keyboard/back-to-rev-44]

48. By Bill Filler on 2013-09-26

fix changelog

49. By Bill Filler on 2013-09-26

fix changelog

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:49
http://jenkins.qa.ubuntu.com/job/ubuntu-keyboard-ci/102/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/ubuntu-keyboard-saucy-amd64-ci/103
    SUCCESS: http://jenkins.qa.ubuntu.com/job/ubuntu-keyboard-saucy-armhf-ci/102
        deb: http://jenkins.qa.ubuntu.com/job/ubuntu-keyboard-saucy-armhf-ci/102/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/ubuntu-keyboard-saucy-i386-ci/102

Click here to trigger a rebuild:
http://s-jenkins:8080/job/ubuntu-keyboard-ci/102/rebuild

review: Approve (continuous-integration)

[Bill Filler (bfiller)]

approve

review: Approve

=== modified file 'data/data.pro'
--- data/data.pro	2013-09-26 10:08:30 +0000
+++ data/data.pro	2013-09-26 16:09:59 +0000
@@ -8,10 +8,13 @@
 # make it available for testing, not intended for proper release though:
 languages.files += languages/debug/showcase.xml
 
+schemas.path = $${PREFIX}/share/glib-2.0/schemas
+schemas.files = schemas/*.gschema.xml
+
 styles.path = $${UBUNTU_KEYBOARD_DATA_DIR}
 styles.files = styles
 
-INSTALLS += languages styles
+INSTALLS += languages schemas styles
 
 QMAKE_EXTRA_TARGETS += check
 check.target = check
 
=== added directory 'data/schemas'
=== added file 'data/schemas/com.canonical.keyboard.maliit.gschema.xml'
--- data/schemas/com.canonical.keyboard.maliit.gschema.xml	1970-01-01 00:00:00 +0000
+++ data/schemas/com.canonical.keyboard.maliit.gschema.xml	2013-09-26 16:09:59 +0000
@@ -0,0 +1,30 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<schemalist>
+  <schema id="com.canonical.keyboard.maliit" path="/com/canonical/keyboard/maliit/">
+    <key name="enabled-languages" type="as">
+      <summary>Enabled languages</summary>
+      <description>User-defined list of activatable languages.</description>
+      <default>[]</default>
+    </key>
+    <key name="auto-capitalization" type="b">
+      <summary>Auto-capitalization</summary>
+      <description>Capitalize the first letter of each sentence.</description>
+      <default>true</default>
+    </key>
+    <key name="auto-completion" type="b">
+      <summary>Auto-completion</summary>
+      <description>Complete current word with first suggestion when hitting space.</description>
+      <default>true</default>
+    </key>
+    <key name="predictive-text" type="b">
+      <summary>Predictive text</summary>
+      <description>Suggest potential words in word ribbon.</description>
+      <default>true</default>
+    </key>
+    <key name="key-press-feedback" type="b">
+      <summary>Key press feedback</summary>
+      <description>Vibrate or emit sound on key press.</description>
+      <default>true</default>
+    </key>
+  </schema>
+</schemalist>
 
=== modified file 'debian/changelog'
--- debian/changelog	2013-09-26 10:37:17 +0000
+++ debian/changelog	2013-09-26 16:09:59 +0000
@@ -1,7 +1,11 @@
 ubuntu-keyboard (0.99.trunk.phablet2+13.10.20130926-0ubuntu1) saucy; urgency=low
-
+  
   [ Ubuntu daily release ]
-  * New rebuild forced
+  * New rebuild forced from rev 45
+
+ -- Ubuntu daily release <[e-mail]>  Thu, 26 Sep 2013 10:37:17 +0000
+
+ubuntu-keyboard (0.99.trunk.phablet2+13.10.20130925-0ubuntu1) saucy; urgency=low
 
   [ William Hua ]
   * Add GSettings schema file.
@@ -11,9 +15,9 @@
     (moving more UI code to QML).
 
   [ Ubuntu daily release ]
-  * Automatic snapshot from revision 45
+  * Automatic snapshot from revision 43
 
- -- Ubuntu daily release <[e-mail]>  Thu, 26 Sep 2013 10:37:17 +0000
+ -- Ubuntu daily release <[e-mail]>  Wed, 25 Sep 2013 11:05:45 +0000
 
 ubuntu-keyboard (0.99.trunk.phablet2+13.10.20130920-0ubuntu1) saucy; urgency=low
 
 
=== modified file 'debian/ubuntu-keyboard-data.install'
--- debian/ubuntu-keyboard-data.install	2013-09-26 10:08:30 +0000
+++ debian/ubuntu-keyboard-data.install	2013-09-26 16:09:59 +0000
@@ -1,1 +1,2 @@
+usr/share/glib-2.0/schemas/
 usr/share/maliit/plugins/com/ubuntu/
 
=== modified file 'qml/KeyboardContainer.qml'
--- qml/KeyboardContainer.qml	2013-09-26 10:08:30 +0000
+++ qml/KeyboardContainer.qml	2013-09-26 16:09:59 +0000
@@ -47,6 +47,7 @@
 
     Loader {
         id: characterKeypadLoader
+        objectName: "characterKeyPadLoader"
         anchors.fill: parent
         asynchronous: true
         source: "languages/Keyboard_en_us.qml"
@@ -59,6 +60,7 @@
 
     Loader {
         id: symbolKeypadLoader
+        objectName: "symbolKeyPadLoader"
         anchors.fill: parent
         asynchronous: true
     }
 
=== modified file 'tests/autopilot/ubuntu_keyboard/emulators/__init__.py'
--- tests/autopilot/ubuntu_keyboard/emulators/__init__.py	2013-09-26 10:08:30 +0000
+++ tests/autopilot/ubuntu_keyboard/emulators/__init__.py	2013-09-26 16:09:59 +0000
@@ -16,3 +16,9 @@
 # You should have received a copy of the GNU General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
+
+from autopilot.introspection import CustomEmulatorBase
+
+
+class UbuntuKeyboardEmulatorBase(CustomEmulatorBase):
+    """A base class for all Ubuntu Keyboard emulators."""
 
=== added file 'tests/autopilot/ubuntu_keyboard/emulators/key.py'
--- tests/autopilot/ubuntu_keyboard/emulators/key.py	1970-01-01 00:00:00 +0000
+++ tests/autopilot/ubuntu_keyboard/emulators/key.py	2013-09-26 16:09:59 +0000
@@ -0,0 +1,33 @@
+# -*- Mode: Python; coding: utf-8; indent-tabs-mode: nil; tab-width: 4 -*-
+#
+# Ubuntu Keyboard Test Suite
+# Copyright (C) 2013 Canonical
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+
+from ubuntu_keyboard.emulators import UbuntuKeyboardEmulatorBase
+
+from collections import namedtuple
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+class Key(UbuntuKeyboardEmulatorBase):
+    """An emulator that encapsulates details of a keyboard key (i.e. extended
+    characters).
+
+    """
+    Pos = namedtuple("KeyPosition", ['x', 'y', 'w', 'h'])
 
=== modified file 'tests/autopilot/ubuntu_keyboard/emulators/keyboard.py'
--- tests/autopilot/ubuntu_keyboard/emulators/keyboard.py	2013-09-26 10:08:30 +0000
+++ tests/autopilot/ubuntu_keyboard/emulators/keyboard.py	2013-09-26 16:09:59 +0000
@@ -17,7 +17,9 @@
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 
-from collections import defaultdict, namedtuple
+from ubuntu_keyboard.emulators import UbuntuKeyboardEmulatorBase
+from ubuntu_keyboard.emulators.keypad import KeyPad
+
 from time import sleep
 import logging
 
@@ -31,70 +33,69 @@
 logger = logging.getLogger(__name__)
 
 
-# Definitions of enums used within the cpp source code.
-class KeyboardState:
-    DEFAULT = 0
-    SHIFTED = 1
-    SYMBOL_1 = 2
-    SYMBOL_2 = 3
-
-
-class KeyAction:
-    INSERT = 0
-    SHIFT = 1
-    BACKSPACE = 2
-    SPACE = 3
-    SYM = 6
-    RETURN = 7
-    SWITCH = 11
-
-
-class UnsupportedKey(RuntimeError):
+class KeyPadNotLoaded(Exception):
+    pass
+
+
+class QQuickLoader(UbuntuKeyboardEmulatorBase):
+    # This is a work around so that when we select_single a KeyPad we don't get
+    # back a generic version.
     pass
 
 
 class Keyboard(object):
 
-    KeyPos = namedtuple("KeyPos", ['x', 'y', 'h', 'w'])
-
-    # Note (veebers 19-aug-13): this hardcoded right now, but will be reading
-    # data from the keyboard itself in the very near future. Moved '/' to
-    # primary symbol, default layout can have a .com instead.
-    default_keys = "qwertyuiopasdfghjklzxcvbnm."
-    shifted_keys = "QWERTYUIOPASDFGHJKLZXCVBNM."
-    primary_symbol = "1234567890*#+-=()!?@~/\\';:,."
-    secondary_symbol = u"$%<>[]`^|_{}\"&,.\u20ac\xa3\xa5\u20b9\xa7\xa1\xbf" \
-        u"\xab\xbb\u201c\u201d\u201e"
-
-    # The ability to name the non-text keys.
-    _action_id_to_text = {
-        KeyAction.SHIFT: 'SHIFT',
-        KeyAction.BACKSPACE: '\b',
-        KeyAction.SPACE: ' ',
-        KeyAction.RETURN: '\n'
+    _action_to_label = {
+        'SHIFT': 'shift',
+        '\b': 'backspace',
+        'ABC': 'symbols',
+        '?123': 'symbols',
+        ' ': 'space',
+        '\n': 'return',
     }
 
+    # mallit is a class attribute because get_proxy_object_for_existing_process
+    # clears backends for proxy objects, this means that with:
+    #   kb = Keyboard()
+    #   kb2 = Keyboard()
+    # The proxy objects in kb have had their _Backends cleared which means we
+    # can no longer query them.
+    try:
+        maliit = get_proxy_object_for_existing_process(
+            connection_name='org.maliit.server',
+            emulator_base=UbuntuKeyboardEmulatorBase
+        )
+    except ProcessSearchError as e:
+        e.args += (
+            "Unable to find maliit-server dbus object. Has it been "
+            "started with introspection enabled?",
+        )
+        raise
+
     def __init__(self, pointer=None):
         try:
-            maliit = get_proxy_object_for_existing_process(
-                connection_name='org.maliit.server'
+            self.orientation = Keyboard.maliit.select_single(
+                "OrientationHelper"
             )
-        except ProcessSearchError as e:
+            if self.orientation is None:
+                raise RuntimeError(
+                    "Unable to find the Orientation Helper, aborting."
+                )
+        except ValueError as e:
             e.args += (
-                "Unable to find maliit-server dbus object. Has it been "
-                "started with introspection enabled?",
+                "More than one OrientationHelper object was found, aborting."
             )
             raise
 
         try:
-            self.keyboard = maliit.select_single(
-                "Keyboard",
+            self.keyboard = Keyboard.maliit.select_single(
+                "QQuickItem",
                 objectName="ubuntuKeyboard"
             )
             if self.keyboard is None:
                 raise RuntimeError(
                     "Unable to find the Ubuntu Keyboard object within the "
-                    "maliit server"
+                    "maliit server."
                 )
         except ValueError as e:
             e.args += (
@@ -102,35 +103,54 @@
             )
             raise
 
-        try:
-            self.keypad = self.keyboard.select_single(
-                "QQuickItem",
-                objectName="keyboardKeypad"
-            )
-
-            if self.keypad is None:
-                raise RuntimeError(
-                    "Unable to find the keypad object within the "
-                    "maliit server"
-                )
-        except ValueError as e:
-            e.args += (
-                "There was more than one keyboard keypad object found, "
-                "aborting.",
-            )
-            raise
-
-        # Contains instructions on how to move the keyboard into a specific
-        # state/layout so that we can successfully press the required key.
-        self._state_lookup_table = self._generate_state_lookup_table()
-        # Cache the position of the keys
-        self._key_pos_table = defaultdict(dict)
+        self._character_keypad = None
+        self._symbol_keypad = None
+
+        self._store_current_orientation()
+        self._store_current_language_id()
 
         if pointer is None:
             self.pointer = Pointer(Touch.create())
         else:
             self.pointer = pointer
 
+    def _keyboard_details_changed(self):
+        return self._language_changed() or self._orientation_changed()
+
+    @property
+    def character_keypad(self):
+        if self._character_keypad is None or self._keyboard_details_changed():
+            self._character_keypad = self._get_keypad("character")
+        return self._character_keypad
+
+    @property
+    def symbol_keypad(self):
+        if (self._symbol_keypad is None
+                or (self._language_changed() or self._orientation_changed())):
+            self._symbol_keypad = self._get_keypad("symbol")
+
+        return self._symbol_keypad
+
+    def _get_keypad(self, name):
+        """Attempt to retrieve KeyPad object of either 'character' or 'symbol'
+
+        *name* must be either 'character' or 'symbol'.
+
+        Raises KeyPadNotLoaded exception if none or more than one keypad is
+        found.
+
+        """
+        objectName = "{name}KeyPadLoader".format(name=name)
+        loader = Keyboard.maliit.select_single(
+            QQuickLoader,
+            objectName=objectName
+        )
+        keypad = loader.select_single(KeyPad)
+        if keypad is None:
+            raise KeyPadNotLoaded("{name} keypad is not currently loaded.")
+
+        return keypad
+
     def dismiss(self):
         """Swipe the keyboard down to hide it.
 
@@ -150,14 +170,20 @@
 
     def is_available(self):
         """Returns true if the keyboard is shown and ready to use."""
-        return (
-            self.keyboard.state == "SHOWN"
-            and not self.keyboard.hideAnimationFinished
-        )
+        return (self.keyboard.state == "SHOWN")
 
     @property
     def current_state(self):
-        return self.keyboard.layoutState
+        return self.keyboard.state
+
+    @property
+    def active_keypad(self):
+        if self.character_keypad.enabled:
+            return self.character_keypad
+        elif self.symbol_keypad.enabled:
+            return self.symbol_keypad
+        else:
+            raise RuntimeError("There are no currently active KeyPads.")
 
     # Much like is_available, but attempts to wait for the keyboard to be
     # ready.
@@ -177,31 +203,6 @@
         except RuntimeError:
             return False
 
-    def get_key_position(self, key):
-        """Returns the global rect of the given key.
-
-        It may need to do a lookup to update the table of positions.
-
-        """
-        current_state = self.keyboard.layoutState
-        if self._key_pos_table.get(current_state) is None:
-            self._update_pos_table_for_current_state()
-
-        return self._key_pos_table[current_state][key]
-
-    def _update_pos_table_for_current_state(self):
-        all_keys = self.keypad.select_many('QQuickText')
-        current_state = self.keyboard.layoutState
-        labeled_keys = (KeyAction.INSERT, KeyAction.SWITCH, KeyAction.SYM)
-        for key in all_keys:
-            with key.no_automatic_refreshing():
-                key_pos = Keyboard.KeyPos(*key.globalRect)
-                if key.action_type in labeled_keys:
-                    self._key_pos_table[current_state][key.text] = key_pos
-                else:
-                    key_text = Keyboard._action_id_to_text[key.action_type]
-                    self._key_pos_table[current_state][key_text] = key_pos
-
     def press_key(self, key):
         """Tap on the key with the internal pointer
 
@@ -209,18 +210,31 @@
 
         :raises: *RuntimeError* if the keyboard is not available and thus not
           ready to be used.
-        :raises: *UnsupportedKey* if the supplied key cannot be found on any of
+        :raises: *ValueError* if the supplied key cannot be found on any of
           the the current keyboards layouts.
         """
         if not self.is_available():
             raise RuntimeError("Keyboard is not on screen")
 
-        if not self._is_special_key(key):
-            required_state_for_key = self._get_keys_required_state(key)
-            self._switch_keyboard_to_state(required_state_for_key)
-
-        key_rect = self.get_key_position(key)
-        self.pointer.click_object(key_rect)
+        key = self._translate_key(key)
+        active_keypad = None
+
+        try:
+            if self.character_keypad.contains_key(key):
+                self._show_character_keypad()
+                active_keypad = self.character_keypad
+            elif self.symbol_keypad.contains_key(key):
+                self._show_symbol_keypad()
+                active_keypad = self.symbol_keypad
+        except KeyPadNotLoaded:
+            pass
+
+        if active_keypad is None:
+            raise ValueError(
+                "Key '%s' was not found on the keyboard." % key
+            )
+
+        active_keypad.press_key(key)
 
     def type(self, string, delay=0.1):
         """Type the string *string* with a delay of *delay* between each key
@@ -231,7 +245,7 @@
 
         Only 'normal' or single characters can be typed this way.
 
-        :raises: *UnsupportedKey* if one of the the supplied keys cannot be
+        :raises: *ValueError* if one of the the supplied keys cannot be
           found on any of the the current keyboards layouts.
 
         """
@@ -239,108 +253,47 @@
             self.press_key(char)
             sleep(delay)
 
-    def _get_keys_required_state(self, char):
-        """Given a character determine which state the keyboard needs to be in
-        so that it is visible and can be clicked.
-
-        """
-
-        if char in Keyboard.default_keys:
-            return KeyboardState.DEFAULT
-        elif char in Keyboard.shifted_keys:
-            return KeyboardState.SHIFTED
-        elif char in Keyboard.primary_symbol:
-            return KeyboardState.SYMBOL_1
-        elif char in Keyboard.secondary_symbol:
-            return KeyboardState.SYMBOL_2
-        else:
-            raise UnsupportedKey(
-                "Don't know which state key '%s' requires" % char
-            )
-
-    def _switch_keyboard_to_state(self, target_state):
-        """Given a target_state, presses the required keys to bring the
-        keyboard into the correct state.
-
-        :raises: *RuntimeError* if unable to change the keyboard into the
-          expected state.
-
-        """
-        current_state = self.keyboard.layoutState
-
-        if target_state == current_state:
-            return
-
-        instructions = self._state_lookup_table[target_state].get(
-            current_state,
-            None
-        )
-        if instructions is None:
-            raise RuntimeError(
-                "Don't know how to get to state %d from current state (%d)"
-                % (target_state, current_state)
-            )
-
-        for step in instructions:
-            key, expected_state = step
-            self.press_key(key)
-            self.keyboard.layoutState.wait_for(expected_state)
-
-    def _is_special_key(self, key):
-        return key in ["\n", "\b", " ", "SHIFT", "?123", "ABC", "1/2", "2/2"]
-
-    # Give the state that you want and the current state, get instructions on
-    # how to move to that state.
-    # lookup_table[REQUESTED_STATE][CURRENT_STATE] -> Instructions(Key to
-    # press, Expected state after key press.)
-    def _generate_state_lookup_table(self):
-        return {
-            KeyboardState.DEFAULT: {
-                KeyboardState.SHIFTED: [
-                    ("SHIFT", KeyboardState.DEFAULT)
-                ],
-                KeyboardState.SYMBOL_1: [
-                    ("ABC", KeyboardState.DEFAULT)
-                ],
-                KeyboardState.SYMBOL_2: [
-                    ("ABC", KeyboardState.DEFAULT)
-                ],
-            },
-            KeyboardState.SHIFTED: {
-                KeyboardState.DEFAULT: [
-                    ("SHIFT", KeyboardState.SHIFTED)
-                ],
-                KeyboardState.SYMBOL_1: [
-                    ("ABC", KeyboardState.DEFAULT),
-                    ("SHIFT", KeyboardState.SHIFTED)
-                ],
-                KeyboardState.SYMBOL_2: [
-                    ("ABC", KeyboardState.DEFAULT),
-                    ("SHIFT", KeyboardState.SHIFTED)
-                ],
-            },
-            KeyboardState.SYMBOL_1: {
-                KeyboardState.DEFAULT: [
-                    ("?123", KeyboardState.SYMBOL_1)
-                ],
-                KeyboardState.SHIFTED: [
-                    ("?123", KeyboardState.SYMBOL_1)
-                ],
-                KeyboardState.SYMBOL_2: [
-                    ("2/2", KeyboardState.SYMBOL_1)
-                ],
-            },
-            KeyboardState.SYMBOL_2: {
-                KeyboardState.DEFAULT: [
-                    ("?123", KeyboardState.SYMBOL_1),
-                    ("1/2", KeyboardState.SYMBOL_2)
-                ],
-                KeyboardState.SHIFTED: [
-                    ("?123", KeyboardState.SYMBOL_1),
-                    ("1/2", KeyboardState.SYMBOL_2)
-                ],
-                KeyboardState.SYMBOL_1: [
-                    ("1/2", KeyboardState.SYMBOL_2)
-                ],
-            },
-        }
+    def _orientation_changed(self):
+        if self._stored_orientation != self.orientation.orientationAngle:
+            self._store_current_orientation()
+            return True
+        else:
+            return False
+
+    def _language_changed(self):
+        if self._stored_language_id != self.keyboard.layoutId:
+            self._store_current_language_id()
+            return True
+        else:
+            return False
+
+    def _store_current_orientation(self):
+        self._stored_orientation = self.orientation.orientationAngle
+
+    def _store_current_language_id(self):
+        self._stored_language_id = self.keyboard.layoutId
+
+    def _show_character_keypad(self):
+        """Brings the characters KeyPad to the forefront."""
+        if not self.character_keypad.enabled:
+            # If the character keypad isn't enabled than the symbol keypad must
+            # be active
+            self.symbol_keypad.press_key("symbols")
+            self.character_keypad.enabled.wait_for(True)
+            self.character_keypad.opacity.wait_for(1.0)
+
+    def _show_symbol_keypad(self):
+        """Brings the symbol KeyPad to the forefront."""
+        if not self.symbol_keypad.enabled:
+            # If the symbol keypad isn't enabled than the character keypad must
+            # be active
+            self.character_keypad.press_key("symbols")
+            self.symbol_keypad.enabled.wait_for(True)
+            self.symbol_keypad.opacity.wait_for(1.0)
+
+    def _translate_key(self, label):
+        """Get the label for a 'special key' (i.e. space) so that it can be
+        addressed and clicked.
+
+        """
+        return Keyboard._action_to_label.get(label, label)
 
=== added file 'tests/autopilot/ubuntu_keyboard/emulators/keypad.py'
--- tests/autopilot/ubuntu_keyboard/emulators/keypad.py	1970-01-01 00:00:00 +0000
+++ tests/autopilot/ubuntu_keyboard/emulators/keypad.py	2013-09-26 16:09:59 +0000
@@ -0,0 +1,174 @@
+# -*- Mode: Python; coding: utf-8; indent-tabs-mode: nil; tab-width: 4 -*-
+#
+# Ubuntu Keyboard Test Suite
+# Copyright (C) 2013 Canonical
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+
+from ubuntu_keyboard.emulators import UbuntuKeyboardEmulatorBase
+from ubuntu_keyboard.emulators.key import Key
+
+import logging
+
+from autopilot.input import Pointer, Touch
+from time import sleep
+
+logger = logging.getLogger(__name__)
+
+
+class CharKey(UbuntuKeyboardEmulatorBase):
+    pass
+
+
+class ActionKey(UbuntuKeyboardEmulatorBase):
+    pass
+
+
+class KeyPad(UbuntuKeyboardEmulatorBase):
+    """An emulator that understands the KeyPad and its internals and how to
+    interact with it.
+
+      - Which keys are displayed within it
+      - The positions of these keys
+      - The state (NORMAL/SHIFTED) the KeyPad is in
+
+    """
+
+    class State:
+        NORMAL = "NORMAL"
+        SHIFTED = "SHIFTED"
+        CAPSLOCK = "CAPSLOCK"
+
+    def __init__(self, *args):
+        super(KeyPad, self).__init__(*args)
+        self._key_pos = dict()
+        self._contained_keys = []
+        self._contained_shifted_keys = []
+
+        self.update_key_details()
+
+    def contains_key(self, label):
+        """Returns true if a key with the label *label* is contained within
+        this KeyPad.
+
+        """
+        return (label in self._contained_keys
+                or label in self._contained_shifted_keys)
+
+    def update_key_details(self):
+        def _iter_keys(key_type, label_fn):
+            for key in self.select_many(key_type):
+                with key.no_automatic_refreshing():
+                    key_pos = Key.Pos(*key.globalRect)
+                    label = label_fn(key)
+                    if label != '':
+                        self._contained_keys.append(label)
+                        self._key_pos[label] = key_pos
+                    if key.shifted != '':
+                        self._contained_shifted_keys.append(key.shifted)
+                        self._key_pos[key.shifted] = key_pos
+
+        _iter_keys(CharKey, lambda x: x.label)
+        _iter_keys(ActionKey, lambda x: x.action)
+
+    def press_key(self, key, pointer=None):
+        """Taps key *key* with *pointer*
+
+        If no pointer is passed in one is created for this purpose
+
+        raises *ValueError* if *key* is not contained within this KeyPad.
+        raises *RuntimeError* if this KeyPad is not visible.
+
+        """
+        if not self.contains_key(key):
+            raise ValueError(
+                "Key '%s' is not contained by this KeyPad (%s),"
+                " cannot press it." % (key, self.objectName)
+            )
+
+        if not self.visible:
+            raise RuntimeError(
+                "This Keypad (%s) is not visible" % self.objectName
+            )
+
+        required_state = self._get_keys_required_keypad_state(key)
+
+        self._switch_to_state(required_state, pointer)
+
+        key_rect = self.get_key_position(key)
+        self._tap_key(key_rect, pointer)
+
+    def get_key_position(self, key):
+        """Returns Key.Pos for the key with *key*.
+
+        raises *ValueError* if unable to find the stored position for *key*
+          (i.e. not contained within this KeyPad.)
+
+        """
+        key_rect = self._key_pos.get(key)
+
+        if key_rect is None:
+            raise ValueError("Unknown position for key '%s'" % key)
+
+        return key_rect
+
+    def _get_keys_required_keypad_state(self, key):
+        if key in ('shift', 'backspace', 'symbols', 'space', 'return'):
+            return self.state
+        elif key in self._contained_keys:
+            return KeyPad.State.NORMAL
+        elif key in self._contained_shifted_keys:
+            return KeyPad.State.SHIFTED
+        else:
+            raise ValueError(
+                "Don't know which state key '%s' requires." % key
+            )
+
+    def _switch_to_state(self, state, pointer):
+        """Move from one state to the other.
+
+        i.e. move from NORMAL to SHIFTED
+
+        """
+        if state == self.state:
+            return
+
+        # If shifted is needed and we're in CAPSLOCK that's fine.
+        if (state == KeyPad.State.SHIFTED
+                and self.state == KeyPad.State.CAPSLOCK):
+            logger.debug(
+                "Ignoring request to switch to SHIFTED, already in CAPSLOCK."
+            )
+            return
+
+        logger.debug("Switching from %s to %s" % (self.state, state))
+
+        if self.state == KeyPad.State.NORMAL:
+            expected_state = KeyPad.State.SHIFTED
+        else:
+            expected_state = KeyPad.State.NORMAL
+
+        key_rect = self.get_key_position("shift")
+
+        # Hack as we cannot tell when the shift key is ready to be pressed
+        # bug lp:1229003 and lp:1229001
+        sleep(.2)
+        self._tap_key(key_rect, pointer)
+        self.state.wait_for(expected_state)
+
+    def _tap_key(self, key_rect, pointer):
+        if pointer is None:
+            pointer = Pointer(Touch.create())
+        pointer.click_object(key_rect)
 
=== modified file 'tests/autopilot/ubuntu_keyboard/tests/test_keyboard.py'
--- tests/autopilot/ubuntu_keyboard/tests/test_keyboard.py	2013-09-26 10:08:30 +0000
+++ tests/autopilot/ubuntu_keyboard/tests/test_keyboard.py	2013-09-26 16:09:59 +0000
@@ -22,12 +22,14 @@
 from testtools.matchers import Equals
 from tempfile import mktemp
 from textwrap import dedent
+from time import sleep
 
 from autopilot.testcase import AutopilotTestCase
 from autopilot.input import Pointer, Touch
 from autopilot.matchers import Eventually
 
-from ubuntu_keyboard.emulators.keyboard import Keyboard, KeyboardState
+from ubuntu_keyboard.emulators.keyboard import Keyboard
+from ubuntu_keyboard.emulators.keypad import KeyPad
 
 
 class UbuntuKeyboardTests(AutopilotTestCase):
@@ -141,10 +143,12 @@
             )
         ),
         (
+            # Currently the en_us layout doesn't have ", but has \u201c and
+            # \u201d
             'punctuation',
             dict(
                 label="Puncuation",
-                input='`~!@#$%^&*()_-+={}[]|\\:;"\'<>,.?/'
+                input=u'`~!@#$%^&*()_-+={}[]|\\:;\'<>,.?/\u201c'
             )
         )
     ]
@@ -169,14 +173,18 @@
         shifted/capitalised.
 
         """
+        self.skip(
+            "Skipping as feature hasn't landed yet, refer to bug lp:1214695"
+        )
+
         text_area = self.launch_test_input_area()
         self.ensure_focus_on_input(text_area)
         keyboard = Keyboard()
         self.addCleanup(keyboard.dismiss)
 
         self.assertThat(
-            keyboard.keyboard.layoutState,
-            Eventually(Equals(KeyboardState.SHIFTED))
+            keyboard.active_keypad.state,
+            Eventually(Equals(KeyPad.State.SHIFTED))
         )
 
     def test_shift_latch(self):
@@ -194,13 +202,15 @@
         self.addCleanup(keyboard.dismiss)
 
         keyboard.type('abc')
-        keyboard.press_key('SHIFT')
-        keyboard.press_key('SHIFT')
+        # Bug lp:1229003 and lp:1229001
+        sleep(.2)
+        keyboard.press_key('shift')
+        keyboard.press_key('shift')
         keyboard.type('S')
 
         self.assertThat(
-            keyboard.keyboard.layoutState,
-            Eventually(Equals(KeyboardState.SHIFTED))
+            keyboard.active_keypad.state,
+            Eventually(Equals(KeyPad.State.CAPSLOCK))
         )
         self.assertThat(text_area.text, Eventually(Equals('abcS')))
 
@@ -224,8 +234,8 @@
         # Once the capital letter has been typed, we must be able to access the
         # lowercase letters, otherwise it's not in the correct state.
         self.assertThat(
-            keyboard.keyboard.layoutState,
-            Eventually(Equals(KeyboardState.DEFAULT))
+            keyboard.active_keypad.state,
+            Eventually(Equals(KeyPad.State.NORMAL))
         )
 
         self.assertThat(text_area.text, Eventually(Equals('abcA')))
@@ -237,6 +247,9 @@
         enter the shifted state.
 
         """
+        self.skip(
+            "Skipping as feature hasn't landed yet, refer to bug lp:1214695"
+        )
         text_area = self.launch_test_input_area()
         self.ensure_focus_on_input(text_area)
         keyboard = Keyboard()
@@ -250,8 +263,8 @@
         )
 
         self.assertThat(
-            keyboard.keyboard.layoutState,
-            Eventually(Equals(KeyboardState.SHIFTED))
+            keyboard.active_keypad.state,
+            Eventually(Equals(KeyPad.State.SHIFTED))
         )
 
     def test_switching_between_states(self):
@@ -292,14 +305,6 @@
             )
         ),
         (
-            "Password",
-            dict(
-                label="Password",
-                hints=['Qt.ImhHiddenText', 'Qt.ImhSensitiveData'],
-                expected_activeview="password"
-            )
-        ),
-        (
             "Email",
             dict(
                 label="Email",
@@ -320,7 +325,7 @@
             dict(
                 label="Telephone",
                 hints=['Qt.ImhDigitsOnly'],
-                expected_activeview="phonenumber"
+                expected_activeview="number"
             )
         ),
     ]
@@ -337,6 +342,6 @@
         self.addCleanup(keyboard.dismiss)
 
         self.assertThat(
-            keyboard.keyboard.activeView,
+            keyboard.keyboard.layoutId,
             Eventually(Equals(self.expected_activeview))
         )