By recording users’ keystrokes, developers can often obtain valuable data required for various purposes, from development to medical purposes. Fleksy Keyboard SDK supports capturing users’ input in detail. The developers can use the captured data in to ascertain information about users’ taps, words entered, time taken, type of layout, auto-corrected words, and much more.

When configured, the SDK starts capturing data every session and stores data after it. If the session includes multiple data points, the SDK starts storing data to reduce memory usage.

Data Object

The data captured by the Fleksy Keyboard SDK is in JSON format for easy parsing and readability and is either:

• Sent as a callback event (Session on Android, DataCollection on iOS), or
• Stored in a file with the .log extension at the given location during setup (filename: logger_typing_<timestamp>.log) as configured.

Example

The below example shows JSON data (object) in a file named logger_typing_b12b8c6a-256a-4fa0-8221-f086f80676b8.log captured after a session end.

Multiple tags have been collapsed for ease of readability. The captured file contains complete data.

{
    "sessionId": "b12b8c6a-256a-4fa0-8221-f086f80676b8",
    "startUnixTime": 1673809523412,
    "endUnixTime": 1673809546993,
    "timeZone": 5.5,
    "appContext": "co.thingthing.sample.sdksample",
    "textField": "Text",
    "language": "en-US",
    "languageVersion": "5100.0",
    "layout": "QWERTY",
    "screenSizePx": {
        "width": 1080.0,
        "height": 2400.0
    },
    "keyboardArea": {
        "x": 0.0,
        "y": 1739.0,
        "width": 1080.0,
        "height": 535.0
    },
    "screenSizeMm": {
        "width": 65.314285,
        "height": 145.14285
    },
    "performance": [],
    "keyTypes": [...
    ],
    "keyArea": [...
    ],
    "keyCode": [...
    ],
    "keyText": [...
    ],
    "pressTimes": [
        5434,
        6293,
        11365,
        12229,
        13122,
        13908,
        14523,
        15370,
        16348,
        19173,
        19847,
        20710,
        22223,
        23475
    ],
    "releaseTimes": [...
    ],
    "positionX": [...
    ],
    "positionY": [...
    ],
    "positionEndX": [...
    ],
    "positionEndY": [...
    ],
    "keyPress": [...
    ],
    "keyPressEnd": [...
    ],
    "keyCenter": [...
    ],
    "keyBounds": [...
    ],
    "emojis": [],
    "predictionTimes": [],
    "predictionLengths": [],
    "predictionWords": [],
    "autocorrectTimes": [],
    "autocorrectLengths": [],
    "autocorrectOriginalWords": [],
    "autocorrectWords": [],
    "wordsData": [
        {
            "originalWord": "",
            "word": "Trying",
            "autocorrection": false,
            "autocorrectionType": "",
            "autocorrectionValue": 0,
            "prediction": false,
            "swipe": false,
            "linkedKeyId": 0,
            "timestamp": 14608
        }
    ],
    "swipeData": [],
    "keyplaneData": {
        "switchplanes": [...
        ],
        "keyplanes": [...
        ]
    },
    "deleteData": [],
    "text": "Trying to type"
}

Initial Setup

Both Android and iOS variants of the Fleksy Keyboard SDK support capturing data which can be configured via the CaptureConfiguration block during the initial keyboard configuration. Furthermore, the data to be captured can also be configured using the FLDataConfiguration class that is taken as a parameter by the CaptureConfiguration class.

Examples

For Android:

To capture data on the Android platform, enable data capture by passing an instance of the CaptureConfiguration class. In addition, the data to be captured can be configured by using the FLDataConfiguration class as dataConfiguration parameter.

The below code sample showcases configuring data capture by storing the data in the application’s files directory.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

import co.thingthing.fleksy.core.keyboard.KeyboardConfiguration
import co.thingthing.fleksy.core.keyboard.KeyboardConfiguration.CaptureConfiguration
import co.thingthing.fleksy.core.keyboard.KeyboardConfiguration.LicenseConfiguration
import co.thingthing.fleksy.core.keyboard.KeyboardService
import co.thingthing.fleksy.core.keyboard.models.FLDataConfiguration

class SampleKeyboardService : KeyboardService() {

    override fun createConfiguration(): KeyboardConfiguration {
        return KeyboardConfiguration(
            license = LicenseConfiguration(
                licenseKey = BuildConfig.FLEKSY_LICENSE_KEY,
                licenseSecret = BuildConfig.FLEKSY_SECRET_KEY
            ),
            capture = CaptureConfiguration(
                enabled = true,
                storeData = true,
                location = this.filesDir.absolutePath,
                dataConfiguration = FLDataConfiguration()
            )
        )
    }

}

For iOS:

Similar to Android, to capture data on the iOS platform, pass an instance of the CaptureConfiguration class. In addition, the captured data can be configured using the dataConfig parameter during instantiation that takes an instance of the FLDataConfiguration class.

The below code sample showcases configuring data capture by storing the data in the application’s files directory.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55

import UIKit
import FleksyKeyboardSDK

class KeyboardViewController: FleksyKeyboardSDK.FKKeyboardViewController {

    override func viewDidLoad() {
        super.viewDidLoad()
    }

    override func createConfiguration() -> KeyboardConfiguration {

        // CAPTURE DATA
        // Capturing by default
        // if we want to disable it, pass false instead
        let dataConfig = FLDataConfiguration(
            configFormat: .dataConfigFormat_groupByTap,
            accelerometer: true
        )
        let capture = CaptureConfiguration(
            true,
            output: enumCaptureOutput.captureOutput_string,
            dataConfig: dataConfig
        )

        let style = StyleConfiguration()

        let appPopup = AppearancePopup()
        let appLongpress = AppearanceLongPress()
        let appearance = AppearanceConfiguration(
            objPopup: appPopup,
            objTouch: nil,
            objLongpress: appLongpress
        )

        let typing = TypingConfiguration()
        let panelConfig = PanelConfiguration()
        let debugConfig = DebugConfiguration(debug: ())

        let licenseConfig = LicenseConfiguration(
            licenseKey: "<your-license-key>",
            licenseSecret: "<your-license-secret>"
        )

        return KeyboardConfiguration(
            panel: panelConfig,
            capture: capture,
            style: style,
            appearance: appearance,
            typing: typing,
            specialKeys: nil,
            license: licenseConfig,
            debug: debugConfig
        )
    }
}

Properties

A data object has the following properties:

accelerometerData

Position (x,y,z,timestamp) of the accelerometer every x Hz. It contains an <Array> of <accelerometerObj>.

An instance of accelerometerObj contains the following values:

deleteData

Record all delete events. It contains an <Array> of <deleteObj>.

An instance of deleteObj contains the following values:

interKeyTimeHistogram

This histogram will be stored as <Array> of 21 <Numbers> as [Integer]. It indicates the count of interkey times in a typing session that are in each of the bins as specified below:

• The first bin 0-0.05 sec,
• The second 0.05 to 0.10 sec,
• The third 0.10-0.15 sec,
• …,
• The 20th bin 0.95-1.0 sec.

keyArea

Description of the area where the user has pressed. Values from 0 to 5.

This object contains the following values:

• “1” for letters QWASZ
• “2” for letters ERDFXC
• “3” for letters TYGV
• “4” for letters UIHJBN
• “5” for letters OPKLM

keyCode

Keystroke character equivalent UTF8 Unicode in Decimal. First characters its equivalent to ASCII32.

Note: Number 900 makes reference to emoji. The transcription of this emoji it is in the array of emojis, by order.

Note: Number 901 makes reference to a prediction.

keyTypes

Key type indicating character family.

This object contains the following values:

• “an”: Alphanumeric
• “pt”: Symbols and punctuation
• “sp”: Space bar
• “bk”: Backspace
• “en”: Enter
• “md”: Modifier key
• “shf”: Shift
• “atcshf”: Automatic shift
• “atcmd”: Automatic numbers
• “eksw”: Emoji button / keyboard from emoji
• “pred”: Prediction from the topbar
• “sugg”: Suggestion from the topbar
• “ukn”: Others

keyplaneData

Record all key plane events change + the center and bounds of each key of the plane. It contains an <Array> of <switchplanesObj> and <Array> of <keyplanesObj>.

For example:

{
    "keyplaneData": {
        "switchplanes": [
            {
                "keyplane": 0,
                "label": "",
                "keytype": "atcshf",
                "timestamp": 5554
            }
        ],
        "keyplanes": [
            {
                "keyplane": 0,
                "keys": [
                    {
                        "center": {
                            "x": 54.0,
                            "y": 1805.8749980926514
                        },
                        "bounds": {
                            "x": 0.0,
                            "y": 1739.0,
                            "width": 108.0,
                            "height": 133.74999618530273
                        },
                        "label": "q"
                    },
                    {
                        "center": {
                            "x": 162.0,
                            "y": 1805.8749980926514
                        },
                        "bounds": {
                            "x": 108.0,
                            "y": 1739.0,
                            "width": 108.0,
                            "height": 133.74999618530273
                        },
                        "label": "w"
                    }
                ]
            }
        ]
    },
    ...
  },
}

An instance of switchplanesObj contains the following values:

An instance of keyplanesObj contains the following values:

An instance of KeysObj contains the following values:

swipeData

Collection of all data related to a trace on top of the keyboard to detect a word. It contains an <Array> of <swipeObj>.

An instance of swipeObj contains the following values:

An instance of Points contains the following values:

An instance of Candidates contains the following values:

tapEvent

The tapEvent object gets generated in case of selecting the option of “Format group by tap”, which groups all keyStroks in one object per key stroke.

The properties touchBegin and touchEnd contains the following values:

• “press”: <obj> | position of the press
  • “x”: <number> | x position
  • “y”: <number> | y position
• “distance”: <obj> | distance from between the center of the key and the press position
  • “x”: <number> | x position
  • “y”: <number> | y position
• “timestamp”: <number> | time from the start of the session

textField

Current Textfield where the user wrote.

This object contains the following values:

• “Text”: Regular Text field
• “Pwd”: Password text field
• “Url”: URL text field
• “Email”: Email text field
• “Numbers”: Numbers text field
• “Twitter”: Twitter text field, used in Twitter/Slack / …
• “Websearch”: Websearch textfield
• “Text_ACOFF”: Regular text field without Autocorrection
• “Twitter_ACOFF”: Twitter text field without AC

wordsData

Information related to each of the words. It contains an <Array> of <wordsObj>.

For example:

{
    "wordsData": [
        {
            "originalWord": "",
            "word": "Trying",
            "autocorrection": false,
            "autocorrectionType": "",
            "autocorrectionValue": 0,
            "prediction": false,
            "swipe": false,
            "linkedKeyId": 0,
            "timestamp": 14608
        }
    ],
    ...
  },
}

An instance of wordsObj contains the following values:

Additional Resources

For more information, consider checking out the API reference documentation for the respective platform, which documents all the available methods to customize the keyboard built with Fleksy Keyboard SDK.

• Android API Reference
• iOS API Reference