add Swedish kbd

README.md

@@ -3,25 +3,28 @@
 
 [![MPLv2 License](http://img.shields.io/badge/license-MPLv2-blue.svg?style=flat-square)](https://www.mozilla.org/MPL/2.0/)
 
-__LeanKeyKeyboard: An Keyboard for Android-based set-top boxes and TVs:__
+__LeanKeyKeyboard: Keyboard for Android-based set-top boxes and TVs:__
 
 Visit Google Play page: 
  * <a href="https://play.google.com/store/apps/details?id=org.liskovsoft.androidtv.rukeyboard" target="_blank">[APP] LeanKeyKeyboard</a>
 
-### Features:
+__NOTE: Google Play release is outdated. So I recommend to obtain new releases [here](https://github.com/yuliskov/LeanKeyKeyboard/releases).__
 
+### Features:
  * Designed for TV screens.
  * Any remote controller support.
- * Support dozens of languages through the language packs.
+ * Supports dozens of languages.
  * Doesn't depend on Google Services.
  * __No root required!__
 
-__Switch to other language performed with menu key or with long press of the space bar.__
+__Switch to other language performed with 'world' button, menu key or long press on the space bar.__
+
+### Screenshots:
+ * __[Open screenshots](#screens)__
 
 ### Install LeanKeyKeyboard:
-
-__Easy installation in less than 5 minutes with only the FireTV__
- * <a href="https://github.com/yuliskov/SmartYouTubeTV/wiki/Install-SmartYouTubeTV-(only-FireTV-needed)">Install LeanKeyKeyboard (only FireTV needed)</a>
+__Easy installation in less than 10 minutes with only FireTV__
+ * <a href="https://github.com/yuliskov/LeanKeyKeyboard/wiki/How-to-Install-LeanKeyKeyboard-on-FireTV">Install LeanKeyKeyboard (only FireTV needed)</a>
 
 __Standard installation via ADB__
  * If you don't know how to sideload/install apps via ADB, read a tutorial (e.g. <a href="http://kodi.wiki/view/HOW-TO:Install_Kodi_on_Fire_TV" target="_blank">this one</a>)
@@ -35,18 +38,20 @@ __Standard installation via ADB__
 ### Changelog:
  * [Check releases page for changelog ..](https://github.com/yuliskov/LeanKeyKeyboard/releases)
 
-### Screenshots:
+### Contributors:
+ * __[aglt](https://github.com/aglt)__ (Icelandic lang)
+ * __[rabin111](https://github.com/rabin111)__ (Thai lang)
 
-![Screenshot of LeanKeyKeyboard](img/leankeykeyboard_screenshot_01.png "Screenshot of LeanKeyKeyboard")
-![Screenshot of LeanKeyKeyboard](img/leankeykeyboard_screenshot_02.png "Screenshot of LeanKeyKeyboard")
-![Screenshot of LeanKeyKeyboard](img/leankeykeyboard_screenshot_03.png "Screenshot of LeanKeyKeyboard")
+### Developer:
+ * __[yuliskov](https://github.com/yuliskov)__ (design & coding)
 
-### Why using it:
- * LeanKeyKeyboard provides possibility to enter text with any length.
- * LeanKeyKeyboard provides support for the multiple remote controllers which allows you to enter text in a very convenient way.
- 
 ### Donation:
 If you want to support my developments you are welcome to buy me a cup of coffee :)
  * BTC: 1JAT5VVWarVBkpVbNDn8UA8HXNdrukuBSx
  * WMZ: Z375157140784
  * WMU: U449339012933
+
+### Screens:
+![Screenshot of LeanKeyKeyboard](img/leankeykeyboard_screenshot_01.png "Screenshot of LeanKeyKeyboard")
+![Screenshot of LeanKeyKeyboard](img/leankeykeyboard_screenshot_02.png "Screenshot of LeanKeyKeyboard")
+![Screenshot of LeanKeyKeyboard](img/leankeykeyboard_screenshot_03.png "Screenshot of LeanKeyKeyboard")

build.gradle

@@ -14,14 +14,14 @@ buildscript {
     // https://stackoverflow.com/questions/20404476/how-to-define-common-android-properties-for-all-modules-using-gradle
     // Gradle constants example: https://github.com/google/ExoPlayer
     ext {
-        compileSdkVersion = 27
-        buildToolsVersion = "27.0.3"
+        compileSdkVersion = 26
+        buildToolsVersion = "26.0.2"
         minSdkVersion = 14
-        targetSdkVersion = 27
-        appCompatVersion = 'com.android.support:appcompat-v7:27.+'
+        targetSdkVersion = 26
+        appCompatVersion = 'com.android.support:appcompat-v7:26.+'
         espressoCoreVersion = 'com.android.support.test.espresso:espresso-core:2.2.2'
         junitVersion = 'junit:junit:4.12'
-        supportVersion = 'com.android.support:support-v4:27.+'
+        supportVersion = 'com.android.support:support-v4:26.+'
         robolectricVersion = 'org.robolectric:robolectric:3.5.1'
         crashlyticsVersion = 'com.crashlytics.sdk.android:crashlytics:2.8.0@aar'
     }

leankeykeyboard/build.gradle

@@ -8,8 +8,8 @@ android {
         applicationId "org.liskovsoft.leankeykeyboard.pro"
         minSdkVersion project.properties.minSdkVersion
         targetSdkVersion project.properties.targetSdkVersion
-        versionCode 57
-        versionName "4.3.7"
+        versionCode 64
+        versionName "4.3.14"
 
         testInstrumentationRunner "android.support.test.runner.AndroidJUnitRunner"
 
@@ -34,6 +34,12 @@ android {
             output.outputFile = new File(output.outputFile.parent, newApkName)
         }
     }
+
+    lintOptions {
+        abortOnError true
+        disable 'MissingTranslation'
+        disable 'NewApi'
+    }
 }
 
 dependencies {

leankeykeyboard/src/main/AndroidManifest.xml

@@ -5,10 +5,9 @@
     <uses-permission android:name="android.permission.RECEIVE_BOOT_COMPLETED"/>
     <uses-permission android:name="android.permission.KILL_BACKGROUND_PROCESSES"/>
     <application android:banner="@drawable/banner_app" android:label="@string/ime_name" android:icon="@drawable/ic_launcher" tools:targetApi="21">
-        <activity android:launchMode="singleTop" android:name="com.liskovsoft.inputchooser.SettingsActivity">
+        <activity android:launchMode="singleTop" android:name="com.liskovsoft.other.SettingsActivity">
             <meta-data android:name="package" android:value="com.android.settings"/>
-            <meta-data android:name="class" android:value="com.android.settings.Settings"/>
-            <meta-data android:name="intent" android:value="android.settings.INPUT_METHOD_SETTINGS"/>
+            <meta-data android:name="class" android:value="com.android.settings.Settings$InputMethodAndLanguageSettingsActivity"/>
             <intent-filter>
                 <action android:name="android.intent.action.MAIN"/>
                 <category android:name="android.intent.category.LAUNCHER"/>
@@ -21,7 +20,7 @@
             </intent-filter>
             <meta-data android:name="android.view.im" android:resource="@xml/method"/>
         </service>
-        <receiver android:name="com.liskovsoft.inputchooser.RestartServiceReceiver" android:exported="true" android:enabled="true">
+        <receiver android:name="com.liskovsoft.other.RestartServiceReceiver" android:exported="true" android:enabled="true">
             <intent-filter>
                 <action android:name="android.intent.action.PACKAGE_ADDED" />
                 <action android:name="android.intent.action.PACKAGE_REMOVED" />

leankeykeyboard/src/main/java/com/google/android/leanback/ime/LeanbackKeyboardContainer.java

@@ -36,8 +36,8 @@ import android.widget.RelativeLayout.LayoutParams;
 import com.google.android.leanback.ime.voice.RecognizerView;
 import com.google.android.leanback.ime.voice.SpeechLevelSource;
 import com.google.leanback.ime.LeanbackImeService;
-import com.liskovsoft.inputchooser.ChooseKeyboardDialog;
-import com.liskovsoft.inputchooser.LeanKeyPreferences;
+import com.liskovsoft.other.ChooseKeyboardDialog;
+import com.liskovsoft.utils.LeanKeyPreferences;
 import com.liskovsoft.keyboardaddons.KeyboardManager;
 import com.liskovsoft.leankeykeyboard.R;
 

leankeykeyboard/src/main/java/com/google/android/leanback/ime/LeanbackKeyboardController.java

@@ -5,6 +5,7 @@ import android.graphics.Rect;
 import android.inputmethodservice.InputMethodService;
 import android.inputmethodservice.Keyboard.Key;
 import android.os.Handler;
+import android.text.InputType;
 import android.util.Log;
 import android.view.KeyEvent;
 import android.view.MotionEvent;
@@ -688,10 +689,12 @@ public class LeanbackKeyboardController implements LeanbackKeyboardContainer.Voi
             initInputView();
         }
 
-        // prevent accidental kbd pop-up on FireTV devices
-        // more info: https://forum.xda-developers.com/fire-tv/general/guide-change-screen-keyboard-to-leankey-t3527675/page2
-        int maskAction = info.imeOptions & EditorInfo.IME_MASK_ACTION;
-        mShowInput = maskAction != 0;
+        //// prevent accidental kbd pop-up on FireTV devices
+        //// more info: https://forum.xda-developers.com/fire-tv/general/guide-change-screen-keyboard-to-leankey-t3527675/page2
+        //int maskAction = info.imeOptions & EditorInfo.IME_MASK_ACTION;
+        //mShowInput = maskAction != 0;
+
+        mShowInput = info.inputType != InputType.TYPE_NULL;
     }
 
     public boolean showInputView() {

leankeykeyboard/src/main/java/com/google/android/leanback/ime/LeanbackKeyboardView.java

@@ -69,6 +69,56 @@ public class LeanbackKeyboardView extends FrameLayout {
     private int mRowCount;
     private int mShiftState;
     private final int mUnfocusStartDelay;
+    private final KeyConverter mConverter;
+
+    private class KeyConverter {
+        private static final int LOWER_CASE = 0;
+        private static final int UPPER_CASE = 1;
+
+        private void init(KeyHolder keyHolder) {
+            // store original label
+            // in case when two characters are stored in one label (e.g. "A|B")
+            if (keyHolder.key.text == null) {
+                keyHolder.key.text = keyHolder.key.label;
+            }
+        }
+
+        public void toLowerCase(KeyHolder keyHolder) {
+            extractChar(LOWER_CASE, keyHolder);
+        }
+
+        public void toUpperCase(KeyHolder keyHolder) {
+            extractChar(UPPER_CASE, keyHolder);
+        }
+
+        private void extractChar(int charCase, KeyHolder keyHolder) {
+            init(keyHolder);
+
+            CharSequence result = null;
+            CharSequence label = keyHolder.key.text;
+
+            String[] labels = splitLabels(label);
+
+            switch (charCase) {
+                case LOWER_CASE:
+                    result = labels != null ? labels[0] : label.toString().toLowerCase();
+                    break;
+                case UPPER_CASE:
+                    result = labels != null ? labels[1] : label.toString().toUpperCase();
+                    break;
+            }
+
+            keyHolder.key.label = result;
+        }
+
+        private String[] splitLabels(CharSequence label) {
+            String realLabel = label.toString();
+
+            String[] labels = realLabel.split("\\|");
+
+            return labels.length == 2 ? labels : null; // remember, we encoding two chars
+        }
+    }
 
     public LeanbackKeyboardView(Context context, AttributeSet attrs) {
         super(context, attrs);
@@ -92,29 +142,24 @@ public class LeanbackKeyboardView extends FrameLayout {
         mClickAnimDur = res.getInteger(R.integer.clicked_anim_duration);
         mUnfocusStartDelay = res.getInteger(R.integer.unfocused_anim_delay);
         mInactiveMiniKbAlpha = res.getInteger(R.integer.inactive_mini_kb_alpha);
+        mConverter = new KeyConverter();
     }
 
-    private CharSequence adjustCase(LeanbackKeyboardView.KeyHolder keyHolder) {
-        CharSequence label = keyHolder.key.label;
-        CharSequence result = label;
-        if (label != null && label.length() < 3) {
-            boolean flag;
-            if (keyHolder.isInMiniKb && keyHolder.isInvertible) {
-                flag = true;
-            } else {
-                flag = false;
-            }
+    private void adjustCase(LeanbackKeyboardView.KeyHolder keyHolder) {
+        boolean flag;
 
-            if (this.mKeyboard.isShifted() ^ flag) {
-                result = label.toString().toUpperCase();
-            } else {
-                result = label.toString().toLowerCase();
-            }
-
-            keyHolder.key.label = result;
+        if (keyHolder.isInMiniKb && keyHolder.isInvertible) {
+            flag = true;
+        } else {
+            flag = false;
         }
 
-        return result;
+        // ^ equals to !=
+        if (mKeyboard.isShifted() ^ flag) {
+            mConverter.toUpperCase(keyHolder);
+        } else {
+            mConverter.toLowerCase(keyHolder);
+        }
     }
 
     @SuppressLint("NewApi")

leankeykeyboard/src/main/java/com/google/leanback/ime/LeanbackImeService.java

@@ -18,6 +18,7 @@ import com.google.android.leanback.ime.LeanbackKeyboardController.InputListener;
 import com.google.android.leanback.ime.LeanbackKeyboardView;
 import com.google.android.leanback.ime.LeanbackSuggestionsFactory;
 import com.google.android.leanback.ime.LeanbackUtils;
+import com.liskovsoft.utils.LangUpdater;
 
 public class LeanbackImeService extends InputMethodService {
     private static final boolean DEBUG = false;
@@ -53,11 +54,19 @@ public class LeanbackImeService extends InputMethodService {
 
     @SuppressLint("NewApi")
     public LeanbackImeService() {
-        if (!this.enableHardwareAcceleration()) {
+        if (!enableHardwareAcceleration()) {
             Log.w("LbImeService", "Could not enable hardware acceleration");
         }
     }
 
+    @Override
+    public void onCreate() {
+        super.onCreate();
+        
+        LangUpdater langUpdater = new LangUpdater(this);
+        langUpdater.update();
+    }
+
     private void clearSuggestionsDelayed() {
         if (!mSuggestionsFactory.shouldSuggestionsAmend()) {
             mHandler.removeMessages(MSG_SUGGESTIONS_CLEAR);
@@ -270,10 +279,11 @@ public class LeanbackImeService extends InputMethodService {
         return isInputViewShown() && mKeyboardController.onKeyUp(keyCode, event) || super.onKeyUp(keyCode, event);
     }
 
-    @Override
-    public boolean onShowInputRequested(int flags, boolean configChange) {
-        return true;
-    }
+    // FireTV fix
+    //@Override
+    //public boolean onShowInputRequested(int flags, boolean configChange) {
+    //    return true;
+    //}
 
     @Override
     public int onStartCommand(final Intent intent, final int flags, final int startId) {
@@ -305,10 +315,11 @@ public class LeanbackImeService extends InputMethodService {
 
         // FireTV: fix accidental kbd pop-ups
         // more info: https://forum.xda-developers.com/fire-tv/general/guide-change-screen-keyboard-to-leankey-t3527675/page2
-        //if (!mKeyboardController.showInputView()) {
-        //    onHideIme();
-        //    return;
-        //}
+        updateInputViewShown();
+        if (!mKeyboardController.showInputView()) {
+            onHideIme();
+            return;
+        }
 
         mKeyboardController.onStartInputView();
         sendBroadcast(new Intent(IME_OPEN));

leankeykeyboard/src/main/java/com/liskovsoft/other/ChooseKeyboardDialog.java

@@ -1,4 +1,4 @@
-package com.liskovsoft.inputchooser;
+package com.liskovsoft.other;
 
 import android.annotation.SuppressLint;
 import android.annotation.TargetApi;

leankeykeyboard/src/main/java/com/liskovsoft/other/RestartServiceReceiver.java

@@ -1,10 +1,8 @@
-package com.liskovsoft.inputchooser;
+package com.liskovsoft.other;
 import android.app.*;
 import android.content.*;
 import android.content.res.*;
-import android.net.*;
 import android.util.*;
-import android.view.inputmethod.*;
 
 import java.util.*;
 

leankeykeyboard/src/main/java/com/liskovsoft/other/SettingsActivity.java

@@ -2,11 +2,11 @@
 // Decompiled by Procyon v0.5.30
 // 
 
-package com.liskovsoft.inputchooser;
+package com.liskovsoft.other;
 
 import android.annotation.SuppressLint;
 import android.content.ActivityNotFoundException;
-import android.content.Context;
+import android.content.pm.PackageManager;
 import android.widget.Toast;
 import android.os.Bundle;
 import android.content.ComponentName;
@@ -19,27 +19,27 @@ public class SettingsActivity extends Activity
 {
     @SuppressLint("WrongConstant")
     private void addIntentFlags(final Intent intent) {
-        intent.addFlags(67108864);
-        intent.addFlags(536870912);
+        intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
+        intent.addFlags(Intent.FLAG_ACTIVITY_SINGLE_TOP);
     }
 
     @SuppressLint("WrongConstant")
     private ActivityInfo getCurrentActivityInfo() {
         try {
-            return this.getPackageManager().getActivityInfo(this.getComponentName(), 129);
+            return getPackageManager().getActivityInfo(getComponentName(), PackageManager.GET_META_DATA | PackageManager.GET_ACTIVITIES);
         }
         catch (NameNotFoundException ex) {
             ex.printStackTrace();
-            this.makeLongToast(ex.getLocalizedMessage(), 10);
+            makeLongToast(ex.getLocalizedMessage(), 10);
             return null;
         }
     }
     
     private void launchApp() {
-        final Intent intent = this.makeIntent(this.getCurrentActivityInfo());
-        this.addIntentFlags(intent);
-        this.startIntent(intent);
-        this.finish();
+        final Intent intent = makeIntent(getCurrentActivityInfo());
+        addIntentFlags(intent);
+        startIntent(intent);
+        finish();
     }
     
     private Intent makeIntent(final ActivityInfo activityInfo) {
@@ -53,25 +53,25 @@ public class SettingsActivity extends Activity
         return intent;
     }
 
-    private void makeLongToast(final String s, int i) {
+    private void makeLongToast(final String s, int nums) {
         int n;
-        for (n = i / 2, i = 0; i < n; ++i) {
+        for (n = nums / 2, nums = 0; nums < n; ++nums) {
             Toast.makeText(this, s, Toast.LENGTH_LONG).show();
         }
     }
     
     private void startIntent(final Intent intent) {
         try {
-            this.startActivity(intent);
+            startActivity(intent);
         }
         catch (ActivityNotFoundException ex) {
             ex.printStackTrace();
-            this.makeLongToast(ex.getLocalizedMessage(), 10);
+            makeLongToast(ex.getLocalizedMessage(), 10);
         }
     }
     
     protected void onCreate(final Bundle bundle) {
         super.onCreate(bundle);
-        this.launchApp();
+        launchApp();
     }
 }

leankeykeyboard/src/main/java/com/liskovsoft/other/widgets/DialogTitle.java

@@ -21,7 +21,7 @@
 // <declare-styleable name="TextAppearance">: https://github.com/aosp-mirror/platform_frameworks_base/blob/master/core/res/res/values/attrs.xml
 
 
-package com.liskovsoft.inputchooser.widgets;
+package com.liskovsoft.other.widgets;
 
 import android.content.Context;
 import android.content.res.TypedArray;

leankeykeyboard/src/main/java/com/liskovsoft/utils/Helpers.java

@@ -0,0 +1,144 @@
+package com.liskovsoft.utils;
+
+import android.content.Context;
+import android.content.Intent;
+import android.content.pm.PackageManager;
+import android.content.pm.ResolveInfo;
+import android.os.Build;
+import android.os.Handler;
+import android.os.Looper;
+
+import java.io.ByteArrayInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.UnsupportedEncodingException;
+import java.net.URLEncoder;
+import java.nio.charset.Charset;
+import java.text.DateFormat;
+import java.util.Date;
+import java.util.List;
+import java.util.Locale;
+import java.util.Scanner;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+public class Helpers {
+    /**
+     * Simple wildcard matching routine. Implemented without regex. So you may expect huge performance boost.
+     * @param host
+     * @param mask
+     * @return
+     */
+    public static boolean matchSubstr(String host, String mask) {
+        String[] sections = mask.split("\\*");
+        String text = host;
+        for (String section : sections) {
+            int index = text.indexOf(section);
+            if (index == -1) {
+                return false;
+            }
+            text = text.substring(index + section.length());
+        }
+        return true;
+    }
+
+    public static boolean matchSubstrNoCase(String host, String mask) {
+        return matchSubstr(host.toLowerCase(), mask.toLowerCase());
+    }
+
+    public static InputStream getAsset(Context ctx, String fileName) {
+        InputStream is = null;
+        try {
+            is = ctx.getAssets().open(fileName);
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+        return is;
+    }
+
+    public static String encodeURI(byte[] data) {
+        try {
+            // make behaviour of java uri-encode the same as javascript's one
+            return URLEncoder.encode(new String(data, "UTF-8"), "UTF-8").replace("+", "%20");
+        } catch (UnsupportedEncodingException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    public static boolean floatEquals(float num1, float num2) {
+        float epsilon = 0.1f;
+        return Math.abs(num1 - num2) < epsilon;
+    }
+
+    public static String getDeviceName() {
+        return String.format("%s (%s)", Build.MODEL, Build.PRODUCT);
+    }
+
+    public static boolean deviceMatch(String[] devicesToProcess) {
+        String thisDeviceName = Helpers.getDeviceName();
+        for (String deviceName : devicesToProcess) {
+            boolean match = matchSubstrNoCase(thisDeviceName, deviceName);
+            if (match) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    public static String toString(InputStream inputStream) {
+        if (inputStream == null) {
+            return null;
+        }
+
+        Scanner s = new Scanner(inputStream).useDelimiter("\\A");
+        String result = s.hasNext() ? s.next() : "";
+        return result;
+    }
+
+    public static InputStream toStream(String content) {
+        return new ByteArrayInputStream(content.getBytes(Charset.forName("UTF8")));
+    }
+
+    public static void postOnUiThread(Runnable runnable) {
+        new Handler(Looper.getMainLooper()).post(runnable);
+    }
+
+    public static String unixToLocalDate(Context ctx, String timestamp) {
+        Locale current = ctx.getResources().getConfiguration().locale;
+        DateFormat dateFormat = DateFormat.getDateInstance(DateFormat.LONG, current);
+        Date date;
+        if (timestamp == null) {
+            date = new Date();
+        } else {
+            date = new Date((long) Integer.parseInt(timestamp) * 1000);
+        }
+        return dateFormat.format(date);
+    }
+
+    public static String runMultiMatcher(String input, String... patterns) {
+        if (input == null) {
+            return null;
+        }
+
+        Pattern regex;
+        Matcher matcher;
+        String result = null;
+        for (String pattern : patterns) {
+            regex = Pattern.compile(pattern);
+            matcher = regex.matcher(input);
+
+            if (matcher.find()) {
+                result = matcher.group(matcher.groupCount()); // get last group
+                break;
+            }
+        }
+
+        return result;
+    }
+
+    public static boolean isCallable(Context ctx, Intent intent) {
+        List<ResolveInfo> list = ctx.getPackageManager().queryIntentActivities(intent,
+                PackageManager.MATCH_DEFAULT_ONLY);
+        return list.size() > 0;
+    }
+}

leankeykeyboard/src/main/java/com/liskovsoft/utils/LangUpdater.java

@@ -0,0 +1,127 @@
+package com.liskovsoft.utils;
+
+import android.content.Context;
+import android.content.Intent;
+import android.content.pm.ResolveInfo;
+import android.content.res.Configuration;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Locale;
+import java.util.StringTokenizer;
+
+public class LangUpdater {
+    private static final String LOCALE_EN_US = "en_US";
+    private static final String LOCALE_RU = "ru_RU";
+    private Context mContext;
+    private String[] rusPackages = {"dkc.androidtv.tree", "dkc.video.fsbox", "dkc.video.hdbox", "dkc.video.uatv"};
+
+    public LangUpdater(Context ctx) {
+        mContext = ctx;
+    }
+
+    public void update() {
+        tryToEnableRussian();
+        tryToForceEnglishOnDevices();
+        tryToRestoreLanguage();
+    }
+
+    private void tryToRestoreLanguage() {
+        String langCode = getPreferredLocale();
+        if (langCode != null) {
+            forceLocale(langCode);
+        }
+    }
+
+    private void tryToForceEnglishOnDevices() {
+        String deviceName = Helpers.getDeviceName();
+        switch (deviceName) {
+            case "ChangHong Android TV (full_mst638)":
+                forceLocale(LOCALE_EN_US);
+        }
+    }
+
+    private void tryToBypassChinese() {
+        String script = LocaleUtility.getScript(Locale.getDefault());
+        if (isChineseScript(script)) {
+            forceLocale(LOCALE_EN_US);
+        }
+    }
+
+    private boolean isChineseScript(String script) {
+        switch (script) {
+            case "Hani":
+            case "Hans":
+            case "Hant":
+                return true;
+        }
+        return false;
+    }
+
+    private void tryToEnableRussian() {
+        List<String> installedPackages = getListInstalledPackages();
+        for (String pkgName : installedPackages) {
+            if (isRussianPackage(pkgName)) {
+                forceLocale(LOCALE_RU);
+            }
+        }
+    }
+
+    // short lang code. ex: "ru"
+    private void forceLocale(String langCode) {
+        if (langCode == null || langCode.isEmpty()) {
+            return;
+        }
+
+        Locale locale = parseLangCode(langCode);
+        Locale.setDefault(locale);
+        Configuration config = mContext.getResources().getConfiguration();
+        config.locale = locale;
+        mContext.getResources().updateConfiguration(config,
+                mContext.getResources().getDisplayMetrics());
+    }
+
+    private boolean isRussianPackage(String pkgName) {
+        for (String rusPackage : rusPackages) {
+            if (rusPackage.equals(pkgName)){
+                return true;
+            }
+        }
+        return false;
+    }
+
+    private List<String> getListInstalledPackages() {
+        Intent mainIntent = new Intent(Intent.ACTION_MAIN, null);
+        mainIntent.addCategory(Intent.CATEGORY_LAUNCHER);
+        List<ResolveInfo> pkgAppsList = mContext.getPackageManager().queryIntentActivities( mainIntent, 0);
+        List<String> result = new ArrayList<>();
+        for (ResolveInfo info : pkgAppsList) {
+            result.add(info.activityInfo.packageName);
+        }
+        return result;
+    }
+
+    public String getLocale() {
+        Configuration config = mContext.getResources().getConfiguration();
+        return config.locale.getLanguage();
+    }
+
+    /**
+     * Get locale as lang code (e.g. zh, ru_RU etc)
+     * @return lang code
+     */
+    public String getPreferredLocale() {
+        return LeanKeyPreferences.instance(mContext).getPreferredLanguage();
+    }
+
+    public void setPreferredLocale(String langCode) {
+        LeanKeyPreferences.instance(mContext).setPreferredLanguage(langCode);
+    }
+
+    private Locale parseLangCode(String langCode) {
+        StringTokenizer tokenizer = new StringTokenizer(langCode, "_");
+        String lang = tokenizer.nextToken();
+        String country = tokenizer.hasMoreTokens() ? tokenizer.nextToken() : "";
+        return new Locale(lang, country);
+    }
+}

leankeykeyboard/src/main/java/com/liskovsoft/utils/LeanKeyPreferences.java

@@ -1,4 +1,4 @@
-package com.liskovsoft.inputchooser;
+package com.liskovsoft.utils;
 
 import android.content.Context;
 import android.content.SharedPreferences;
@@ -6,6 +6,7 @@ import android.preference.PreferenceManager;
 
 public final class LeanKeyPreferences {
     private static final String APP_RUN_ONCE = "appRunOnce";
+    private static final String BOOTSTRAP_SELECTED_LANGUAGE = "bootstrapSelectedLanguage";
     private static LeanKeyPreferences sInstance;
     private final Context mContext;
     private SharedPreferences mPrefs;
@@ -30,4 +31,15 @@ public final class LeanKeyPreferences {
                 .putBoolean(APP_RUN_ONCE, runOnce)
                 .apply();
     }
+
+    public void setPreferredLanguage(String name) {
+        mPrefs.edit()
+                .putString(BOOTSTRAP_SELECTED_LANGUAGE, name)
+                .apply();
+    }
+
+    public String getPreferredLanguage() {
+        String name = mPrefs.getString(BOOTSTRAP_SELECTED_LANGUAGE, "");
+        return name;
+    }
 }

leankeykeyboard/src/main/java/com/liskovsoft/utils/LocaleUtility.java

@@ -0,0 +1,768 @@
+package com.liskovsoft.utils;
+
+import android.content.Context;
+import android.os.Build;
+
+import java.util.HashMap;
+import java.util.Locale;
+import java.util.Map;
+
+/*
+ * Copyright 2013 Phil Brown
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ *
+ * Get Script name by Locale
+ * <br>
+ * @author Phil Brown
+ * @since 9:47:09 AM Dec 20, 2013
+ *
+ */
+
+/*
+ * Additional info:
+ * https://en.wikipedia.org/wiki/Writing_system
+ * https://stackoverflow.com/questions/19153384/how-to-get-the-script-from-a-locale-object-on-android
+ * https://docs.oracle.com/javase/7/docs/api/java/util/Locale.html#getScript()
+ * http://unicode.org/iso15924/iso15924-codes.html
+ *
+ * Usage:
+ * String script = LocaleUtilities.getScript(Locale.getDefault());
+ * String script = LocaleUtilities.getScript(getDefaultLocale(myActivity));
+ */
+public class LocaleUtility {
+
+    public static Map<String, Map<String, String>> scriptsByLocale = new HashMap<String, Map<String, String>>();
+
+    public static Map<String, String> getScriptsMap(String... keyValuePairs) {
+        Map<String, String> languages = new HashMap<String, String>();
+        for (int i = 0; i < keyValuePairs.length; i += 2) {
+            languages.put(keyValuePairs[i], keyValuePairs[i + 1]);
+        }
+        return languages;
+    }
+
+    static {
+        scriptsByLocale.put("aa", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("ab", getScriptsMap("", "Cyrl"));
+        scriptsByLocale.put("abq", getScriptsMap("", "Cyrl"));
+        scriptsByLocale.put("abr", getScriptsMap("", ""));
+        scriptsByLocale.put("ace", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("ach", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("ada", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("ady", getScriptsMap("", "Cyrl"));
+        scriptsByLocale.put("ae", getScriptsMap("", "Avst"));
+        scriptsByLocale.put("af", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("agq", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("aii", getScriptsMap("", "Cyrl"));
+        scriptsByLocale.put("ain", getScriptsMap("", "Kana"));
+        scriptsByLocale.put("ak", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("akk", getScriptsMap("", "Xsux"));
+        scriptsByLocale.put("ale", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("alt", getScriptsMap("", "Cyrl"));
+        scriptsByLocale.put("am", getScriptsMap("", "Ethi"));
+        scriptsByLocale.put("amo", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("an", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("anp", getScriptsMap("", "Deva"));
+        scriptsByLocale.put("aoz", getScriptsMap("", ""));
+        scriptsByLocale.put("ar", getScriptsMap("", "Arab", "IR", "Syrc"));
+        scriptsByLocale.put("arc", getScriptsMap("", "Armi"));
+        scriptsByLocale.put("arn", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("arp", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("arw", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("as", getScriptsMap("", "Beng"));
+        scriptsByLocale.put("asa", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("ast", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("atj", getScriptsMap("", ""));
+        scriptsByLocale.put("av", getScriptsMap("", "Cyrl"));
+        scriptsByLocale.put("awa", getScriptsMap("", "Deva"));
+        scriptsByLocale.put("ay", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("az", getScriptsMap("", "Latn", "AZ", "Cyrl", "IR", "Arab"));
+        scriptsByLocale.put("ba", getScriptsMap("", "Cyrl"));
+        scriptsByLocale.put("bal", getScriptsMap("", "Arab", "IR", "Latn", "PK", "Latn"));
+        scriptsByLocale.put("ban", getScriptsMap("", "Latn", "ID", "Bali"));
+        scriptsByLocale.put("bap", getScriptsMap("", ""));
+        scriptsByLocale.put("bas", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("bax", getScriptsMap("", "Bamu"));
+        scriptsByLocale.put("bbc", getScriptsMap("", "Latn", "ID", "Batk"));
+        scriptsByLocale.put("bbj", getScriptsMap("", ""));
+        scriptsByLocale.put("bci", getScriptsMap("", ""));
+        scriptsByLocale.put("be", getScriptsMap("", "Cyrl"));
+        scriptsByLocale.put("bej", getScriptsMap("", "Arab"));
+        scriptsByLocale.put("bem", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("bew", getScriptsMap("", ""));
+        scriptsByLocale.put("bez", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("bfd", getScriptsMap("", ""));
+        scriptsByLocale.put("bfq", getScriptsMap("", "Taml"));
+        scriptsByLocale.put("bft", getScriptsMap("", "Arab"));
+        scriptsByLocale.put("bfy", getScriptsMap("", "Deva"));
+        scriptsByLocale.put("bg", getScriptsMap("", "Cyrl"));
+        scriptsByLocale.put("bgc", getScriptsMap("", ""));
+        scriptsByLocale.put("bgx", getScriptsMap("", ""));
+        scriptsByLocale.put("bh", getScriptsMap("", "Deva"));
+        scriptsByLocale.put("bhb", getScriptsMap("", "Deva"));
+        scriptsByLocale.put("bhi", getScriptsMap("", ""));
+        scriptsByLocale.put("bhk", getScriptsMap("", ""));
+        scriptsByLocale.put("bho", getScriptsMap("", "Deva"));
+        scriptsByLocale.put("bi", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("bik", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("bin", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("bjj", getScriptsMap("", "Deva"));
+        scriptsByLocale.put("bjn", getScriptsMap("", ""));
+        scriptsByLocale.put("bkm", getScriptsMap("", ""));
+        scriptsByLocale.put("bku", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("bla", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("blt", getScriptsMap("", "Tavt"));
+        scriptsByLocale.put("bm", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("bmq", getScriptsMap("", ""));
+        scriptsByLocale.put("bn", getScriptsMap("", "Beng"));
+        scriptsByLocale.put("bo", getScriptsMap("", "Tibt"));
+        scriptsByLocale.put("bqi", getScriptsMap("", ""));
+        scriptsByLocale.put("bqv", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("br", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("bra", getScriptsMap("", "Deva"));
+        scriptsByLocale.put("brh", getScriptsMap("", ""));
+        scriptsByLocale.put("brx", getScriptsMap("", "Deva"));
+        scriptsByLocale.put("bs", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("bss", getScriptsMap("", ""));
+        scriptsByLocale.put("bto", getScriptsMap("", ""));
+        scriptsByLocale.put("btv", getScriptsMap("", "Deva"));
+        scriptsByLocale.put("bua", getScriptsMap("", "Cyrl"));
+        scriptsByLocale.put("buc", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("bug", getScriptsMap("", "Latn", "ID", "Bugi"));
+        scriptsByLocale.put("bum", getScriptsMap("", ""));
+        scriptsByLocale.put("bvb", getScriptsMap("", ""));
+        scriptsByLocale.put("bya", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("byn", getScriptsMap("", "Ethi"));
+        scriptsByLocale.put("byv", getScriptsMap("", ""));
+        scriptsByLocale.put("bze", getScriptsMap("", ""));
+        scriptsByLocale.put("bzx", getScriptsMap("", ""));
+        scriptsByLocale.put("ca", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("cad", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("car", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("cay", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("cch", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("ccp", getScriptsMap("", "Beng"));
+        scriptsByLocale.put("ce", getScriptsMap("", "Cyrl"));
+        scriptsByLocale.put("ceb", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("cgg", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("ch", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("chk", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("chm", getScriptsMap("", "Cyrl"));
+        scriptsByLocale.put("chn", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("cho", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("chp", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("chr", getScriptsMap("", "Cher"));
+        scriptsByLocale.put("chy", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("cja", getScriptsMap("", "Arab"));
+        scriptsByLocale.put("cjm", getScriptsMap("", "Cham"));
+        scriptsByLocale.put("cjs", getScriptsMap("", "Cyrl"));
+        scriptsByLocale.put("ckb", getScriptsMap("", "Arab"));
+        scriptsByLocale.put("ckt", getScriptsMap("", "Cyrl"));
+        scriptsByLocale.put("co", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("cop", getScriptsMap("", "Arab"));
+        scriptsByLocale.put("cpe", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("cr", getScriptsMap("", "Cans"));
+        scriptsByLocale.put("crh", getScriptsMap("", "Cyrl"));
+        scriptsByLocale.put("crj", getScriptsMap("", ""));
+        scriptsByLocale.put("crk", getScriptsMap("", "Cans"));
+        scriptsByLocale.put("crl", getScriptsMap("", ""));
+        scriptsByLocale.put("crm", getScriptsMap("", ""));
+        scriptsByLocale.put("crs", getScriptsMap("", ""));
+        scriptsByLocale.put("cs", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("csb", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("csw", getScriptsMap("", ""));
+        scriptsByLocale.put("cu", getScriptsMap("", "Glag"));
+        scriptsByLocale.put("cv", getScriptsMap("", "Cyrl"));
+        scriptsByLocale.put("cy", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("da", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("daf", getScriptsMap("", ""));
+        scriptsByLocale.put("dak", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("dar", getScriptsMap("", "Cyrl"));
+        scriptsByLocale.put("dav", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("dcc", getScriptsMap("", ""));
+        scriptsByLocale.put("de", getScriptsMap("", "Latn", "BR", "Runr", "KZ", "Runr", "US", "Runr"));
+        scriptsByLocale.put("del", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("den", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("dgr", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("din", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("dje", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("dng", getScriptsMap("", "Cyrl"));
+        scriptsByLocale.put("doi", getScriptsMap("", "Arab"));
+        scriptsByLocale.put("dsb", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("dtm", getScriptsMap("", ""));
+        scriptsByLocale.put("dua", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("dv", getScriptsMap("", "Thaa"));
+        scriptsByLocale.put("dyo", getScriptsMap("", "Arab"));
+        scriptsByLocale.put("dyu", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("dz", getScriptsMap("", "Tibt"));
+        scriptsByLocale.put("ebu", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("ee", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("efi", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("egy", getScriptsMap("", "Egyp"));
+        scriptsByLocale.put("eka", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("eky", getScriptsMap("", "Kali"));
+        scriptsByLocale.put("el", getScriptsMap("", "Grek"));
+        scriptsByLocale.put("en", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("eo", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("es", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("et", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("ett", getScriptsMap("", "Ital"));
+        scriptsByLocale.put("eu", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("evn", getScriptsMap("", "Cyrl"));
+        scriptsByLocale.put("ewo", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("fa", getScriptsMap("", "Arab"));
+        scriptsByLocale.put("fan", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("ff", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("ffm", getScriptsMap("", ""));
+        scriptsByLocale.put("fi", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("fil", getScriptsMap("", "Latn", "US", "Tglg"));
+        scriptsByLocale.put("fiu", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("fj", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("fo", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("fon", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("fr", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("frr", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("frs", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("fud", getScriptsMap("", ""));
+        scriptsByLocale.put("fuq", getScriptsMap("", ""));
+        scriptsByLocale.put("fur", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("fuv", getScriptsMap("", ""));
+        scriptsByLocale.put("fy", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("ga", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("gaa", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("gag", getScriptsMap("", "Latn", "MD", "Cyrl"));
+        scriptsByLocale.put("gay", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("gba", getScriptsMap("", "Arab"));
+        scriptsByLocale.put("gbm", getScriptsMap("", "Deva"));
+        scriptsByLocale.put("gcr", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("gd", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("gez", getScriptsMap("", "Ethi"));
+        scriptsByLocale.put("ggn", getScriptsMap("", ""));
+        scriptsByLocale.put("gil", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("gjk", getScriptsMap("", ""));
+        scriptsByLocale.put("gju", getScriptsMap("", ""));
+        scriptsByLocale.put("gl", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("gld", getScriptsMap("", "Cyrl"));
+        scriptsByLocale.put("glk", getScriptsMap("", ""));
+        scriptsByLocale.put("gn", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("gon", getScriptsMap("", "Telu"));
+        scriptsByLocale.put("gor", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("gos", getScriptsMap("", ""));
+        scriptsByLocale.put("got", getScriptsMap("", "Goth"));
+        scriptsByLocale.put("grb", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("grc", getScriptsMap("", "Cprt"));
+        scriptsByLocale.put("grt", getScriptsMap("", "Beng"));
+        scriptsByLocale.put("gsw", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("gu", getScriptsMap("", "Gujr"));
+        scriptsByLocale.put("gub", getScriptsMap("", ""));
+        scriptsByLocale.put("guz", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("gv", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("gvr", getScriptsMap("", ""));
+        scriptsByLocale.put("gwi", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("ha", getScriptsMap("", "Arab", "NE", "Latn", "GH", "Latn"));
+        scriptsByLocale.put("hai", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("haw", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("haz", getScriptsMap("", ""));
+        scriptsByLocale.put("he", getScriptsMap("", "Hebr"));
+        scriptsByLocale.put("hi", getScriptsMap("", "Deva"));
+        scriptsByLocale.put("hil", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("hit", getScriptsMap("", "Xsux"));
+        scriptsByLocale.put("hmn", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("hnd", getScriptsMap("", ""));
+        scriptsByLocale.put("hne", getScriptsMap("", "Deva"));
+        scriptsByLocale.put("hnn", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("hno", getScriptsMap("", ""));
+        scriptsByLocale.put("ho", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("hoc", getScriptsMap("", "Deva"));
+        scriptsByLocale.put("hoj", getScriptsMap("", "Deva"));
+        scriptsByLocale.put("hop", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("hr", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("hsb", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("ht", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("hu", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("hup", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("hy", getScriptsMap("", "Armn"));
+        scriptsByLocale.put("hz", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("ia", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("iba", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("ibb", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("id", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("ig", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("ii", getScriptsMap("", "Yiii", "CN", "Latn"));
+        scriptsByLocale.put("ik", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("ikt", getScriptsMap("", ""));
+        scriptsByLocale.put("ilo", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("inh", getScriptsMap("", "Cyrl"));
+        scriptsByLocale.put("is", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("it", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("iu", getScriptsMap("", "Cans", "CA", "Latn"));
+        scriptsByLocale.put("ja", getScriptsMap("", "Jpan"));
+        scriptsByLocale.put("jmc", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("jml", getScriptsMap("", ""));
+        scriptsByLocale.put("jpr", getScriptsMap("", "Hebr"));
+        scriptsByLocale.put("jrb", getScriptsMap("", "Hebr"));
+        scriptsByLocale.put("jv", getScriptsMap("", "Latn", "ID", "Java"));
+        scriptsByLocale.put("ka", getScriptsMap("", "Geor"));
+        scriptsByLocale.put("kaa", getScriptsMap("", "Cyrl"));
+        scriptsByLocale.put("kab", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("kac", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("kaj", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("kam", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("kao", getScriptsMap("", ""));
+        scriptsByLocale.put("kbd", getScriptsMap("", "Cyrl"));
+        scriptsByLocale.put("kca", getScriptsMap("", "Cyrl"));
+        scriptsByLocale.put("kcg", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("kck", getScriptsMap("", ""));
+        scriptsByLocale.put("kde", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("kdt", getScriptsMap("", "Thai"));
+        scriptsByLocale.put("kea", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("kfo", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("kfr", getScriptsMap("", "Deva"));
+        scriptsByLocale.put("kfy", getScriptsMap("", ""));
+        scriptsByLocale.put("kg", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("kge", getScriptsMap("", ""));
+        scriptsByLocale.put("kgp", getScriptsMap("", ""));
+        scriptsByLocale.put("kha", getScriptsMap("", "Latn", "IN", "Beng"));
+        scriptsByLocale.put("khb", getScriptsMap("", "Talu"));
+        scriptsByLocale.put("khn", getScriptsMap("", ""));
+        scriptsByLocale.put("khq", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("kht", getScriptsMap("", "Mymr"));
+        scriptsByLocale.put("khw", getScriptsMap("", ""));
+        scriptsByLocale.put("ki", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("kj", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("kjg", getScriptsMap("", ""));
+        scriptsByLocale.put("kjh", getScriptsMap("", "Cyrl"));
+        scriptsByLocale.put("kk", getScriptsMap("", "Arab", "KZ", "Cyrl", "TR", "Cyrl"));
+        scriptsByLocale.put("kkj", getScriptsMap("", ""));
+        scriptsByLocale.put("kl", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("kln", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("km", getScriptsMap("", "Khmr"));
+        scriptsByLocale.put("kmb", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("kn", getScriptsMap("", "Knda"));
+        scriptsByLocale.put("ko", getScriptsMap("", "Kore"));
+        scriptsByLocale.put("koi", getScriptsMap("", "Cyrl"));
+        scriptsByLocale.put("kok", getScriptsMap("", "Deva"));
+        scriptsByLocale.put("kos", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("kpe", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("kpy", getScriptsMap("", "Cyrl"));
+        scriptsByLocale.put("kr", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("krc", getScriptsMap("", "Cyrl"));
+        scriptsByLocale.put("kri", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("krl", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("kru", getScriptsMap("", "Deva"));
+        scriptsByLocale.put("ks", getScriptsMap("", "Arab"));
+        scriptsByLocale.put("ksb", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("ksf", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("ksh", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("ku", getScriptsMap("", "Latn", "LB", "Arab"));
+        scriptsByLocale.put("kum", getScriptsMap("", "Cyrl"));
+        scriptsByLocale.put("kut", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("kv", getScriptsMap("", "Cyrl"));
+        scriptsByLocale.put("kvr", getScriptsMap("", ""));
+        scriptsByLocale.put("kvx", getScriptsMap("", ""));
+        scriptsByLocale.put("kw", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("kxm", getScriptsMap("", ""));
+        scriptsByLocale.put("kxp", getScriptsMap("", ""));
+        scriptsByLocale.put("ky", getScriptsMap("", "Cyrl", "CN", "Arab", "TR", "Latn"));
+        scriptsByLocale.put("kyu", getScriptsMap("", "Kali"));
+        scriptsByLocale.put("la", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("lad", getScriptsMap("", "Hebr"));
+        scriptsByLocale.put("lag", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("lah", getScriptsMap("", "Arab"));
+        scriptsByLocale.put("laj", getScriptsMap("", ""));
+        scriptsByLocale.put("lam", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("lb", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("lbe", getScriptsMap("", "Cyrl"));
+        scriptsByLocale.put("lbw", getScriptsMap("", ""));
+        scriptsByLocale.put("lcp", getScriptsMap("", "Thai"));
+        scriptsByLocale.put("lep", getScriptsMap("", "Lepc"));
+        scriptsByLocale.put("lez", getScriptsMap("", "Cyrl"));
+        scriptsByLocale.put("lg", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("li", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("lif", getScriptsMap("", "Deva"));
+        scriptsByLocale.put("lis", getScriptsMap("", "Lisu"));
+        scriptsByLocale.put("ljp", getScriptsMap("", ""));
+        scriptsByLocale.put("lki", getScriptsMap("", "Arab"));
+        scriptsByLocale.put("lkt", getScriptsMap("", ""));
+        scriptsByLocale.put("lmn", getScriptsMap("", "Telu"));
+        scriptsByLocale.put("lmo", getScriptsMap("", ""));
+        scriptsByLocale.put("ln", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("lo", getScriptsMap("", "Laoo"));
+        scriptsByLocale.put("lol", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("loz", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("lrc", getScriptsMap("", ""));
+        scriptsByLocale.put("lt", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("lu", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("lua", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("lui", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("lun", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("luo", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("lus", getScriptsMap("", "Beng"));
+        scriptsByLocale.put("lut", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("luy", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("luz", getScriptsMap("", ""));
+        scriptsByLocale.put("lv", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("lwl", getScriptsMap("", "Thai"));
+        scriptsByLocale.put("mad", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("maf", getScriptsMap("", ""));
+        scriptsByLocale.put("mag", getScriptsMap("", "Deva"));
+        scriptsByLocale.put("mai", getScriptsMap("", "Deva"));
+        scriptsByLocale.put("mak", getScriptsMap("", "Latn", "ID", "Bugi"));
+        scriptsByLocale.put("man", getScriptsMap("", "Latn", "GN", "Nkoo"));
+        scriptsByLocale.put("mas", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("maz", getScriptsMap("", ""));
+        scriptsByLocale.put("mdf", getScriptsMap("", "Cyrl"));
+        scriptsByLocale.put("mdh", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("mdr", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("mdt", getScriptsMap("", ""));
+        scriptsByLocale.put("men", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("mer", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("mfa", getScriptsMap("", ""));
+        scriptsByLocale.put("mfe", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("mg", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("mgh", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("mgp", getScriptsMap("", ""));
+        scriptsByLocale.put("mgy", getScriptsMap("", ""));
+        scriptsByLocale.put("mh", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("mi", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("mic", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("min", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("mk", getScriptsMap("", "Cyrl"));
+        scriptsByLocale.put("ml", getScriptsMap("", "Mlym"));
+        scriptsByLocale.put("mn", getScriptsMap("", "Cyrl", "CN", "Mong"));
+        scriptsByLocale.put("mnc", getScriptsMap("", "Mong"));
+        scriptsByLocale.put("mni", getScriptsMap("", "Beng", "IN", "Mtei"));
+        scriptsByLocale.put("mns", getScriptsMap("", "Cyrl"));
+        scriptsByLocale.put("mnw", getScriptsMap("", "Mymr"));
+        scriptsByLocale.put("moe", getScriptsMap("", ""));
+        scriptsByLocale.put("moh", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("mos", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("mr", getScriptsMap("", "Deva"));
+        scriptsByLocale.put("mrd", getScriptsMap("", ""));
+        scriptsByLocale.put("mrj", getScriptsMap("", ""));
+        scriptsByLocale.put("ms", getScriptsMap("", "Arab", "MY", "Latn", "SG", "Latn"));
+        scriptsByLocale.put("mt", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("mtr", getScriptsMap("", ""));
+        scriptsByLocale.put("mua", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("mus", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("mvy", getScriptsMap("", ""));
+        scriptsByLocale.put("mwk", getScriptsMap("", ""));
+        scriptsByLocale.put("mwl", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("mwr", getScriptsMap("", "Deva"));
+        scriptsByLocale.put("mxc", getScriptsMap("", ""));
+        scriptsByLocale.put("my", getScriptsMap("", "Mymr"));
+        scriptsByLocale.put("myv", getScriptsMap("", "Cyrl"));
+        scriptsByLocale.put("myx", getScriptsMap("", ""));
+        scriptsByLocale.put("myz", getScriptsMap("", "Mand"));
+        scriptsByLocale.put("na", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("nap", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("naq", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("nb", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("nbf", getScriptsMap("", ""));
+        scriptsByLocale.put("nch", getScriptsMap("", ""));
+        scriptsByLocale.put("nd", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("ndc", getScriptsMap("", ""));
+        scriptsByLocale.put("nds", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("ne", getScriptsMap("", "Deva"));
+        scriptsByLocale.put("new", getScriptsMap("", "Deva"));
+        scriptsByLocale.put("ng", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("ngl", getScriptsMap("", ""));
+        scriptsByLocale.put("nhe", getScriptsMap("", ""));
+        scriptsByLocale.put("nhw", getScriptsMap("", ""));
+        scriptsByLocale.put("nia", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("nij", getScriptsMap("", ""));
+        scriptsByLocale.put("niu", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("nl", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("nmg", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("nn", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("nnh", getScriptsMap("", ""));
+        scriptsByLocale.put("nod", getScriptsMap("", "Lana"));
+        scriptsByLocale.put("noe", getScriptsMap("", ""));
+        scriptsByLocale.put("nog", getScriptsMap("", "Cyrl"));
+        scriptsByLocale.put("nqo", getScriptsMap("", "Nkoo"));
+        scriptsByLocale.put("nr", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("nsk", getScriptsMap("", ""));
+        scriptsByLocale.put("nso", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("nus", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("nv", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("ny", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("nym", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("nyn", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("nyo", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("nzi", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("oc", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("oj", getScriptsMap("", "Cans"));
+        scriptsByLocale.put("om", getScriptsMap("", "Latn", "ET", "Ethi"));
+        scriptsByLocale.put("or", getScriptsMap("", "Orya"));
+        scriptsByLocale.put("os", getScriptsMap("", "Cyrl"));
+        scriptsByLocale.put("osa", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("osc", getScriptsMap("", "Ital"));
+        scriptsByLocale.put("otk", getScriptsMap("", "Orkh"));
+        scriptsByLocale.put("pa", getScriptsMap("", "Guru", "PK", "Arab"));
+        scriptsByLocale.put("pag", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("pal", getScriptsMap("", "Phli"));
+        scriptsByLocale.put("pam", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("pap", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("pau", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("peo", getScriptsMap("", "Xpeo"));
+        scriptsByLocale.put("phn", getScriptsMap("", "Phnx"));
+        scriptsByLocale.put("pi", getScriptsMap("", "Deva"));
+        scriptsByLocale.put("pko", getScriptsMap("", ""));
+        scriptsByLocale.put("pl", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("pon", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("pra", getScriptsMap("", "Brah"));
+        scriptsByLocale.put("prd", getScriptsMap("", "Arab"));
+        scriptsByLocale.put("prg", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("prs", getScriptsMap("", "Arab"));
+        scriptsByLocale.put("ps", getScriptsMap("", "Arab"));
+        scriptsByLocale.put("pt", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("puu", getScriptsMap("", ""));
+        scriptsByLocale.put("qu", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("raj", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("rap", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("rar", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("rcf", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("rej", getScriptsMap("", "Latn", "ID", "Rjng"));
+        scriptsByLocale.put("ria", getScriptsMap("", ""));
+        scriptsByLocale.put("rif", getScriptsMap("", ""));
+        scriptsByLocale.put("rjs", getScriptsMap("", "Deva"));
+        scriptsByLocale.put("rkt", getScriptsMap("", "Beng"));
+        scriptsByLocale.put("rm", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("rmf", getScriptsMap("", ""));
+        scriptsByLocale.put("rmo", getScriptsMap("", ""));
+        scriptsByLocale.put("rmt", getScriptsMap("", ""));
+        scriptsByLocale.put("rn", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("rng", getScriptsMap("", ""));
+        scriptsByLocale.put("ro", getScriptsMap("", "Latn", "RS", "Cyrl"));
+        scriptsByLocale.put("rob", getScriptsMap("", ""));
+        scriptsByLocale.put("rof", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("rom", getScriptsMap("", "Cyrl"));
+        scriptsByLocale.put("ru", getScriptsMap("", "Cyrl"));
+        scriptsByLocale.put("rue", getScriptsMap("", ""));
+        scriptsByLocale.put("rup", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("rw", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("rwk", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("ryu", getScriptsMap("", ""));
+        scriptsByLocale.put("sa", getScriptsMap("", "Deva"));
+        scriptsByLocale.put("sad", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("saf", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("sah", getScriptsMap("", "Cyrl"));
+        scriptsByLocale.put("sam", getScriptsMap("", "Hebr"));
+        scriptsByLocale.put("saq", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("sas", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("sat", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("saz", getScriptsMap("", "Saur"));
+        scriptsByLocale.put("sbp", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("sc", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("sck", getScriptsMap("", ""));
+        scriptsByLocale.put("scn", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("sco", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("scs", getScriptsMap("", ""));
+        scriptsByLocale.put("sd", getScriptsMap("", "Arab", "IN", "Deva"));
+        scriptsByLocale.put("sdh", getScriptsMap("", "Arab"));
+        scriptsByLocale.put("se", getScriptsMap("", "Latn", "NO", "Cyrl"));
+        scriptsByLocale.put("see", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("sef", getScriptsMap("", ""));
+        scriptsByLocale.put("seh", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("sel", getScriptsMap("", "Cyrl"));
+        scriptsByLocale.put("ses", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("sg", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("sga", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("shi", getScriptsMap("", "Tfng"));
+        scriptsByLocale.put("shn", getScriptsMap("", "Mymr"));
+        scriptsByLocale.put("si", getScriptsMap("", "Sinh"));
+        scriptsByLocale.put("sid", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("sk", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("skr", getScriptsMap("", ""));
+        scriptsByLocale.put("sl", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("sm", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("sma", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("smi", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("smj", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("smn", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("sms", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("sn", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("snk", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("so", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("son", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("sou", getScriptsMap("", ""));
+        scriptsByLocale.put("sq", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("sr", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("srn", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("srr", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("srx", getScriptsMap("", ""));
+        scriptsByLocale.put("ss", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("ssy", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("st", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("su", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("suk", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("sus", getScriptsMap("", "Latn", "GN", "Arab"));
+        scriptsByLocale.put("sv", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("sw", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("swb", getScriptsMap("", "Arab", "YT", "Latn"));
+        scriptsByLocale.put("swc", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("swv", getScriptsMap("", ""));
+        scriptsByLocale.put("sxn", getScriptsMap("", ""));
+        scriptsByLocale.put("syi", getScriptsMap("", ""));
+        scriptsByLocale.put("syl", getScriptsMap("", "Beng", "BD", "Sylo"));
+        scriptsByLocale.put("syr", getScriptsMap("", "Syrc"));
+        scriptsByLocale.put("ta", getScriptsMap("", "Taml"));
+        scriptsByLocale.put("tab", getScriptsMap("", "Cyrl"));
+        scriptsByLocale.put("taj", getScriptsMap("", ""));
+        scriptsByLocale.put("tbw", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("tcy", getScriptsMap("", "Knda"));
+        scriptsByLocale.put("tdd", getScriptsMap("", "Tale"));
+        scriptsByLocale.put("tdg", getScriptsMap("", ""));
+        scriptsByLocale.put("tdh", getScriptsMap("", ""));
+        scriptsByLocale.put("te", getScriptsMap("", "Telu"));
+        scriptsByLocale.put("tem", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("teo", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("ter", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("tet", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("tg", getScriptsMap("", "Cyrl", "PK", "Arab"));
+        scriptsByLocale.put("th", getScriptsMap("", "Thai"));
+        scriptsByLocale.put("thl", getScriptsMap("", ""));
+        scriptsByLocale.put("thq", getScriptsMap("", ""));
+        scriptsByLocale.put("thr", getScriptsMap("", ""));
+        scriptsByLocale.put("ti", getScriptsMap("", "Ethi"));
+        scriptsByLocale.put("tig", getScriptsMap("", "Ethi"));
+        scriptsByLocale.put("tiv", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("tk", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("tkl", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("tkt", getScriptsMap("", ""));
+        scriptsByLocale.put("tli", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("tmh", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("tn", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("to", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("tog", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("tpi", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("tr", getScriptsMap("", "Latn", "DE", "Arab", "MK", "Arab"));
+        scriptsByLocale.put("tru", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("trv", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("ts", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("tsf", getScriptsMap("", ""));
+        scriptsByLocale.put("tsg", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("tsi", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("tsj", getScriptsMap("", ""));
+        scriptsByLocale.put("tt", getScriptsMap("", "Cyrl"));
+        scriptsByLocale.put("ttj", getScriptsMap("", ""));
+        scriptsByLocale.put("tts", getScriptsMap("", "Thai"));
+        scriptsByLocale.put("tum", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("tut", getScriptsMap("", "Cyrl"));
+        scriptsByLocale.put("tvl", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("twq", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("ty", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("tyv", getScriptsMap("", "Cyrl"));
+        scriptsByLocale.put("tzm", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("ude", getScriptsMap("", "Cyrl"));
+        scriptsByLocale.put("udm", getScriptsMap("", "Cyrl", "RU", "Latn"));
+        scriptsByLocale.put("ug", getScriptsMap("", "Arab", "KZ", "Cyrl", "MN", "Cyrl"));
+        scriptsByLocale.put("uga", getScriptsMap("", "Ugar"));
+        scriptsByLocale.put("uk", getScriptsMap("", "Cyrl"));
+        scriptsByLocale.put("uli", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("umb", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("und", getScriptsMap("", ""));
+        scriptsByLocale.put("unr", getScriptsMap("", "Beng", "NP", "Deva"));
+        scriptsByLocale.put("unx", getScriptsMap("", "Beng"));
+        scriptsByLocale.put("ur", getScriptsMap("", "Arab"));
+        scriptsByLocale.put("uz", getScriptsMap("", "Latn", "AF", "Arab", "CN", "Cyrl"));
+        scriptsByLocale.put("vai", getScriptsMap("", "Vaii"));
+        scriptsByLocale.put("ve", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("vi", getScriptsMap("", "Latn", "US", "Hani"));
+        scriptsByLocale.put("vic", getScriptsMap("", ""));
+        scriptsByLocale.put("vmw", getScriptsMap("", ""));
+        scriptsByLocale.put("vo", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("vot", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("vun", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("wa", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("wae", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("wak", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("wal", getScriptsMap("", "Ethi"));
+        scriptsByLocale.put("war", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("was", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("wbq", getScriptsMap("", ""));
+        scriptsByLocale.put("wbr", getScriptsMap("", ""));
+        scriptsByLocale.put("wls", getScriptsMap("", ""));
+        scriptsByLocale.put("wo", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("wtm", getScriptsMap("", ""));
+        scriptsByLocale.put("xal", getScriptsMap("", "Cyrl"));
+        scriptsByLocale.put("xav", getScriptsMap("", ""));
+        scriptsByLocale.put("xcr", getScriptsMap("", "Cari"));
+        scriptsByLocale.put("xh", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("xnr", getScriptsMap("", ""));
+        scriptsByLocale.put("xog", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("xpr", getScriptsMap("", "Prti"));
+        scriptsByLocale.put("xsa", getScriptsMap("", "Sarb"));
+        scriptsByLocale.put("xsr", getScriptsMap("", "Deva"));
+        scriptsByLocale.put("xum", getScriptsMap("", "Ital"));
+        scriptsByLocale.put("yao", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("yap", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("yav", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("ybb", getScriptsMap("", ""));
+        scriptsByLocale.put("yi", getScriptsMap("", "Hebr"));
+        scriptsByLocale.put("yo", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("yrk", getScriptsMap("", "Cyrl"));
+        scriptsByLocale.put("yua", getScriptsMap("", ""));
+        scriptsByLocale.put("yue", getScriptsMap("", "Hans"));
+        scriptsByLocale.put("za", getScriptsMap("", "Latn", "CN", "Hans"));
+        scriptsByLocale.put("zap", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("zdj", getScriptsMap("", ""));
+        scriptsByLocale.put("zea", getScriptsMap("", ""));
+        scriptsByLocale.put("zen", getScriptsMap("", "Tfng"));
+        scriptsByLocale.put("zh", getScriptsMap("", "Hant", "CN", "Hans", "HK", "Hans", "MO", "Hans", "SG", "Hans", "MN", "Hans"));
+        scriptsByLocale.put("zmi", getScriptsMap("", ""));
+        scriptsByLocale.put("zu", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("zun", getScriptsMap("", "Latn"));
+        scriptsByLocale.put("zza", getScriptsMap("", "Arab"));
+    }
+
+    /**
+     * Gets the script (writing type) for the given locale. For example, if a US citizen uses German Locale,
+     * and calls this method with Locale.getDefault(), the result would be "Runr"
+     *
+     * @param locale
+     * @return
+     */
+    public static String getScript(Locale locale) {
+        String localeString = locale.toString();
+        String language = "";
+        String country = "";
+        if (localeString.contains("_")) {
+            String[] split = localeString.split("_");
+            language = split[0];
+            country = split[1];
+        } else language = localeString;
+
+        Map<String, String> scripts = scriptsByLocale.get(language);
+        String script = scripts.get(country);
+        return script == null ? scripts.get("") : script;
+
+    }
+
+    /**
+     * Obtain right locale even if the user changes their Locale in settings after your application process is running.
+     * Android N (Api level 24) update (no warnings).
+     * @param context activity
+     * @return locale
+     */
+    public static Locale getCurrentLocale(Context context){
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N){
+            return context.getResources().getConfiguration().getLocales().get(0);
+        } else{
+            //noinspection deprecation
+            return context.getResources().getConfiguration().locale;
+        }
+    }
+}

leankeykeyboard/src/main/res/values-ru/strings.xml

@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <string name="label_go_key">Перейти</string>
+    <string name="label_next_key">Следующ</string>
+    <string name="label_send_key">Послать</string>
+    <string name="label_search_key">Искать</string>
+    <string name="label_done_key">Готово</string>
+    <string name="language_dialog_title">Выберите дополнительные раскладки</string>
+    <string name="language_dialog_subtitle">Чтобы открыть этот диалог, зажмите кнопку \'земной шар\'</string>
+</resources>

leankeykeyboard/src/main/res/values/arrays.xml

@@ -12,19 +12,4 @@
         <item>1.2</item>
         <item>1.4</item>
     </string-array>
-    <string-array name="additional_languages">
-        <item>Russian|ru</item>
-        <item>Ukrainian|uk</item>
-        <item>Thai|th</item>
-        <item>Hebrew|he</item>
-        <item>Arabic|ar</item>
-        <item>Bulgarian|bg</item>
-        <item>Dutch|nl</item>
-        <item>French|fr</item>
-        <item>German|de</item>
-        <item>Greek|el</item>
-        <item>Italian|it</item>
-        <item>Persian|fa</item>
-        <item>Turkish|tr</item>
-    </string-array>
 </resources>

leankeykeyboard/src/main/res/values/languages.xml

@@ -0,0 +1,20 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <string-array name="additional_languages">
+        <item>Swedish|sv</item>
+        <item>Arabic|ar</item>
+        <item>Bulgarian|bg</item>
+        <item>Dutch|nl</item>
+        <item>French|fr</item>
+        <item>German|de</item>
+        <item>Greek|el</item>
+        <item>Hebrew|he</item>
+        <item>Icelandic|is</item>
+        <item>Italian|it</item>
+        <item>Persian|fa</item>
+        <item>Russian|ru</item>
+        <item>Thai|th</item>
+        <item>Turkish|tr</item>
+        <item>Ukrainian|uk</item>
+    </string-array>
+</resources>

leankeykeyboard/src/main/res/values/strings.xml

@@ -24,6 +24,6 @@
     <string name="keyboardview_keycode_right">Right</string>
     <string name="keyboard_headset_required_to_hear_password">Plug in a headset to hear password keys spoken.</string>
     <string name="keyboard_password_character_no_headset">Dot.</string>
-    <string name="language_dialog_title">Select additional keyboards</string>
+    <string name="language_dialog_title">Select additional layouts</string>
     <string name="language_dialog_subtitle">To open dialog next time, long press on \'world\' button</string>
 </resources>

leankeykeyboard/src/main/res/xml/accent_a_th.xml

@@ -1,9 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Keyboard android:keyWidth="@dimen/key_width" android:keyHeight="@dimen/key_height" android:horizontalGap="@dimen/keyboard_horizontal_gap" android:verticalGap="@dimen/keyboard_vertical_gap"
-          xmlns:android="http://schemas.android.com/apk/res/android">
-    <Row>
-        <Key android:keyLabel="ี" />
-        <Key android:keyLabel="๊" />
-        <Key android:keyLabel="ร" />
-    </Row>
-</Keyboard>

leankeykeyboard/src/main/res/xml/accent_c_th.xml

@@ -1,9 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Keyboard android:keyWidth="@dimen/key_width" android:keyHeight="@dimen/key_height" android:horizontalGap="@dimen/keyboard_horizontal_gap" android:verticalGap="@dimen/keyboard_vertical_gap"
-          xmlns:android="http://schemas.android.com/apk/res/android">
-    <Row>
-        <Key android:keyLabel="็" />
-        <Key android:keyLabel="่" />
-        <Key android:keyLabel="๋" />
-    </Row>
-</Keyboard>

leankeykeyboard/src/main/res/xml/accent_e_th.xml

@@ -1,9 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Keyboard android:keyWidth="@dimen/key_width" android:keyHeight="@dimen/key_height" android:horizontalGap="@dimen/keyboard_horizontal_gap" android:verticalGap="@dimen/keyboard_vertical_gap"
-          xmlns:android="http://schemas.android.com/apk/res/android">
-    <Row>
-        <Key android:keyLabel="๓" />
-        <Key android:keyLabel="๔" />
-        <Key android:keyLabel="ุ" />
-    </Row>
-</Keyboard>

leankeykeyboard/src/main/res/xml/accent_i_th.xml

@@ -1,9 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Keyboard android:keyWidth="@dimen/key_width" android:keyHeight="@dimen/key_height" android:horizontalGap="@dimen/keyboard_horizontal_gap" android:verticalGap="@dimen/keyboard_vertical_gap"
-          xmlns:android="http://schemas.android.com/apk/res/android">
-    <Row>
-        <Key android:keyLabel="๙" />
-        <Key android:keyLabel="ๆ" />
-        <Key android:keyLabel="๐" />
-    </Row>
-</Keyboard>

leankeykeyboard/src/main/res/xml/accent_is_a.xml

@@ -1,8 +1,8 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Keyboard android:keyWidth="@dimen/key_width" android:keyHeight="@dimen/key_height" android:horizontalGap="@dimen/keyboard_horizontal_gap" android:verticalGap="@dimen/keyboard_vertical_gap"
-          xmlns:android="http://schemas.android.com/apk/res/android">
-    <Row>
-        <Key android:keyLabel="ย" />
-        <Key android:keyLabel="บ" />
-    </Row>
+<?xml version="1.0" encoding="utf-8"?>
+<Keyboard android:keyWidth="@dimen/key_width" android:keyHeight="@dimen/key_height" android:horizontalGap="@dimen/keyboard_horizontal_gap" android:verticalGap="@dimen/keyboard_vertical_gap"
+  xmlns:android="http://schemas.android.com/apk/res/android">
+    <Row>
+        <Key android:codes="97" android:keyLabel="a" />
+        <Key android:codes="225" android:keyLabel="á" />
+    </Row>
 </Keyboard>

leankeykeyboard/src/main/res/xml/accent_is_e.xml

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Keyboard android:keyWidth="@dimen/key_width" android:keyHeight="@dimen/key_height" android:horizontalGap="@dimen/keyboard_horizontal_gap" android:verticalGap="@dimen/keyboard_vertical_gap"
+    xmlns:android="http://schemas.android.com/apk/res/android">
+    <Row>
+        <Key android:codes="101" android:keyLabel="e" />
+        <Key android:codes="233" android:keyLabel="é" />
+    </Row>
+</Keyboard>

leankeykeyboard/src/main/res/xml/accent_is_i.xml

@@ -1,7 +1,8 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Keyboard android:keyWidth="@dimen/key_width" android:keyHeight="@dimen/key_height" android:horizontalGap="@dimen/keyboard_horizontal_gap" android:verticalGap="@dimen/keyboard_vertical_gap"
-          xmlns:android="http://schemas.android.com/apk/res/android">
-    <Row>
-        <Key android:keyLabel="ฐ" />
-    </Row>
+<?xml version="1.0" encoding="utf-8"?>
+<Keyboard android:keyWidth="@dimen/key_width" android:keyHeight="@dimen/key_height" android:horizontalGap="@dimen/keyboard_horizontal_gap" android:verticalGap="@dimen/keyboard_vertical_gap"
+  xmlns:android="http://schemas.android.com/apk/res/android">
+    <Row>
+        <Key android:codes="105" android:keyLabel="i" />
+        <Key android:codes="237" android:keyLabel="í" />
+    </Row>
 </Keyboard>

leankeykeyboard/src/main/res/xml/accent_is_o.xml

@@ -1,7 +1,8 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Keyboard android:keyWidth="@dimen/key_width" android:keyHeight="@dimen/key_height" android:horizontalGap="@dimen/keyboard_horizontal_gap" android:verticalGap="@dimen/keyboard_vertical_gap"
-          xmlns:android="http://schemas.android.com/apk/res/android">
-    <Row>
-        <Key android:keyLabel="ล" />
-    </Row>
+<?xml version="1.0" encoding="utf-8"?>
+<Keyboard android:keyWidth="@dimen/key_width" android:keyHeight="@dimen/key_height" android:horizontalGap="@dimen/keyboard_horizontal_gap" android:verticalGap="@dimen/keyboard_vertical_gap"
+  xmlns:android="http://schemas.android.com/apk/res/android">
+    <Row>
+        <Key android:codes="111" android:keyLabel="o" />
+        <Key android:codes="243" android:keyLabel="ó" />
+    </Row>
 </Keyboard>

leankeykeyboard/src/main/res/xml/accent_is_u.xml

@@ -1,7 +1,8 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Keyboard android:keyWidth="@dimen/key_width" android:keyHeight="@dimen/key_height" android:horizontalGap="@dimen/keyboard_horizontal_gap" android:verticalGap="@dimen/keyboard_vertical_gap"
-          xmlns:android="http://schemas.android.com/apk/res/android">
-    <Row>
-        <Key android:keyLabel="ฅ" />
-    </Row>
+<?xml version="1.0" encoding="utf-8"?>
+<Keyboard android:keyWidth="@dimen/key_width" android:keyHeight="@dimen/key_height" android:horizontalGap="@dimen/keyboard_horizontal_gap" android:verticalGap="@dimen/keyboard_vertical_gap"
+  xmlns:android="http://schemas.android.com/apk/res/android">
+    <Row>
+        <Key android:codes="117" android:keyLabel="u" />
+        <Key android:codes="250" android:keyLabel="ú" />
+    </Row>
 </Keyboard>

leankeykeyboard/src/main/res/xml/accent_is_y.xml

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Keyboard android:keyWidth="@dimen/key_width" android:keyHeight="@dimen/key_height" android:horizontalGap="@dimen/keyboard_horizontal_gap" android:verticalGap="@dimen/keyboard_vertical_gap"
+  xmlns:android="http://schemas.android.com/apk/res/android">
+    <Row>
+        <Key android:codes="121" android:keyLabel="y" />
+        <Key android:codes="236" android:keyLabel="ý" />
+    </Row>
+</Keyboard>

leankeykeyboard/src/main/res/xml/accent_j_th.xml

@@ -1,7 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Keyboard android:keyWidth="@dimen/key_width" android:keyHeight="@dimen/key_height" android:horizontalGap="@dimen/keyboard_horizontal_gap" android:verticalGap="@dimen/keyboard_vertical_gap"
-          xmlns:android="http://schemas.android.com/apk/res/android">
-    <Row>
-        <Key android:keyLabel="ฃ" />
-    </Row>
-</Keyboard>

leankeykeyboard/src/main/res/xml/accent_k_th.xml

@@ -1,7 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Keyboard android:keyWidth="@dimen/key_width" android:keyHeight="@dimen/key_height" android:horizontalGap="@dimen/keyboard_horizontal_gap" android:verticalGap="@dimen/keyboard_vertical_gap"
-          xmlns:android="http://schemas.android.com/apk/res/android">
-    <Row>
-        <Key android:keyLabel="ฟ" />
-    </Row>
-</Keyboard>

leankeykeyboard/src/main/res/xml/accent_o_th.xml

@@ -1,9 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Keyboard android:keyWidth="@dimen/key_width" android:keyHeight="@dimen/key_height" android:horizontalGap="@dimen/keyboard_horizontal_gap" android:verticalGap="@dimen/keyboard_vertical_gap"
-          xmlns:android="http://schemas.android.com/apk/res/android">
-    <Row>
-        <Key android:keyLabel="ไ" />
-        <Key android:keyLabel="ำ" />
-        <Key android:keyLabel="ฎ" />
-    </Row>
-</Keyboard>

leankeykeyboard/src/main/res/xml/accent_p2_th.xml

@@ -1,9 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Keyboard android:keyWidth="@dimen/key_width" android:keyHeight="@dimen/key_height" android:horizontalGap="@dimen/keyboard_horizontal_gap" android:verticalGap="@dimen/keyboard_vertical_gap"
-          xmlns:android="http://schemas.android.com/apk/res/android">
-    <Row>
-        <Key android:keyLabel="ธ" />
-        <Key android:keyLabel="ั" />
-        <Key android:keyLabel="ํ" />
-    </Row>
-</Keyboard>

leankeykeyboard/src/main/res/xml/accent_p_th.xml

@@ -1,9 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Keyboard android:keyWidth="@dimen/key_width" android:keyHeight="@dimen/key_height" android:horizontalGap="@dimen/keyboard_horizontal_gap" android:verticalGap="@dimen/keyboard_vertical_gap"
-          xmlns:android="http://schemas.android.com/apk/res/android">
-    <Row>
-        <Key android:keyLabel="พ" />
-        <Key android:keyLabel="ฑ" />
-        <Key android:keyLabel="ะ" />
-    </Row>
-</Keyboard>

leankeykeyboard/src/main/res/xml/accent_q_th.xml

@@ -1,9 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Keyboard android:keyWidth="@dimen/key_width" android:keyHeight="@dimen/key_height" android:horizontalGap="@dimen/keyboard_horizontal_gap" android:verticalGap="@dimen/keyboard_vertical_gap"
-          xmlns:android="http://schemas.android.com/apk/res/android">
-    <Row>
-        <Key android:keyLabel="ฝ" />
-        <Key android:keyLabel="ฦ" />
-        <Key android:keyLabel="๑" />
-    </Row>
-</Keyboard>

leankeykeyboard/src/main/res/xml/accent_r_th.xml

@@ -1,9 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Keyboard android:keyWidth="@dimen/key_width" android:keyHeight="@dimen/key_height" android:horizontalGap="@dimen/keyboard_horizontal_gap" android:verticalGap="@dimen/keyboard_vertical_gap"
-          xmlns:android="http://schemas.android.com/apk/res/android">
-    <Row>
-        <Key android:keyLabel="3641" />
-        <Key android:keyLabel="3638" />
-        <Key android:keyLabel="3662" />
-    </Row>
-</Keyboard>

leankeykeyboard/src/main/res/xml/accent_s_th.xml

@@ -1,9 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Keyboard android:keyWidth="@dimen/key_width" android:keyHeight="@dimen/key_height" android:horizontalGap="@dimen/keyboard_horizontal_gap" android:verticalGap="@dimen/keyboard_vertical_gap"
-          xmlns:android="http://schemas.android.com/apk/res/android">
-    <Row>
-        <Key android:keyLabel="ณ" />
-        <Key android:keyLabel="น" />
-        <Key android:keyLabel="ฯ" />
-    </Row>
-</Keyboard>

leankeykeyboard/src/main/res/xml/accent_t_th.xml

@@ -1,9 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Keyboard android:keyWidth="@dimen/key_width" android:keyHeight="@dimen/key_height" android:horizontalGap="@dimen/keyboard_horizontal_gap" android:verticalGap="@dimen/keyboard_vertical_gap"
-          xmlns:android="http://schemas.android.com/apk/res/android">
-    <Row>
-        <Key android:keyLabel="ค" />
-        <Key android:keyLabel="๕" />
-        <Key android:keyLabel="ต" />
-    </Row>
-</Keyboard>

leankeykeyboard/src/main/res/xml/accent_u_th.xml

@@ -1,9 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Keyboard android:keyWidth="@dimen/key_width" android:keyHeight="@dimen/key_height" android:horizontalGap="@dimen/keyboard_horizontal_gap" android:verticalGap="@dimen/keyboard_vertical_gap"
-          xmlns:android="http://schemas.android.com/apk/res/android">
-    <Row>
-        <Key android:keyLabel="ข" />
-        <Key android:keyLabel="๘" />
-        <Key android:keyLabel="ช" />
-    </Row>
-</Keyboard>

leankeykeyboard/src/main/res/xml/accent_w_th.xml

@@ -1,9 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Keyboard android:keyWidth="@dimen/key_width" android:keyHeight="@dimen/key_height" android:horizontalGap="@dimen/keyboard_horizontal_gap" android:verticalGap="@dimen/keyboard_vertical_gap"
-          xmlns:android="http://schemas.android.com/apk/res/android">
-    <Row>
-        <Key android:keyLabel="๒" />
-        <Key android:keyLabel="ภ" />
-        <Key android:keyLabel="๓" />
-    </Row>
-</Keyboard>

leankeykeyboard/src/main/res/xml/accent_x_th.xml

@@ -1,9 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Keyboard android:keyWidth="@dimen/key_width" android:keyHeight="@dimen/key_height" android:horizontalGap="@dimen/keyboard_horizontal_gap" android:verticalGap="@dimen/keyboard_vertical_gap"
-          xmlns:android="http://schemas.android.com/apk/res/android">
-    <Row>
-        <Key android:keyLabel="ด" />
-        <Key android:keyLabel="ฌ" />
-        <Key android:keyLabel="้" />
-    </Row>
-</Keyboard>

leankeykeyboard/src/main/res/xml/accent_y_th.xml

@@ -1,9 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Keyboard android:keyWidth="@dimen/key_width" android:keyHeight="@dimen/key_height" android:horizontalGap="@dimen/keyboard_horizontal_gap" android:verticalGap="@dimen/keyboard_vertical_gap"
-          xmlns:android="http://schemas.android.com/apk/res/android">
-    <Row>
-        <Key android:keyLabel="๖" />
-        <Key android:keyLabel="จ" />
-        <Key android:keyLabel="๗" />
-    </Row>
-</Keyboard>

leankeykeyboard/src/main/res/xml/accent_z_th.xml

@@ -1,9 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Keyboard android:keyWidth="@dimen/key_width" android:keyHeight="@dimen/key_height" android:horizontalGap="@dimen/keyboard_horizontal_gap" android:verticalGap="@dimen/keyboard_vertical_gap"
-          xmlns:android="http://schemas.android.com/apk/res/android">
-    <Row>
-        <Key android:keyLabel="ฆ" />
-        <Key android:keyLabel="ก" />
-        <Key android:keyLabel="ฏ" />
-    </Row>
-</Keyboard>

leankeykeyboard/src/main/res/xml/qwerty_is.xml

@@ -0,0 +1,69 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Keyboard android:keyWidth="@dimen/key_width" android:keyHeight="@dimen/key_height" android:horizontalGap="@dimen/keyboard_horizontal_gap" android:verticalGap="@dimen/keyboard_vertical_gap"
+    xmlns:android="http://schemas.android.com/apk/res/android">
+    <!--     All letters needed for German and Danish are in the C0 Controls and Basic Latin and C1 Controls and Latin-1 Supplement blocks. (See Wikipedia's list of languages supported by those blocks.)
+        For Czech/Slovak, you also need Latin Extended-A.
+        You should also include General Punctuation, as well as any other symbols you may use (e.g. Arrows).
+        See http://en.wikipedia.org/wiki/Latin_characters_in_Unicode. -->
+    <Row android:rowEdgeFlags="top">
+        <Key android:codes="49" android:popupKeyboard="@xml/shift_1" android:keyEdgeFlags="left" android:keyLabel="1" />
+        <Key android:codes="50" android:popupKeyboard="@xml/shift_2" android:keyLabel="2" />
+        <Key android:codes="51" android:popupKeyboard="@xml/shift_3" android:keyLabel="3" />
+        <Key android:codes="52" android:popupKeyboard="@xml/shift_4" android:keyLabel="4" />
+        <Key android:codes="53" android:popupKeyboard="@xml/shift_5" android:keyLabel="5" />
+        <Key android:codes="54" android:popupKeyboard="@xml/shift_6" android:keyLabel="6" />
+        <Key android:codes="55" android:popupKeyboard="@xml/shift_7" android:keyLabel="7" />
+        <Key android:codes="56" android:popupKeyboard="@xml/shift_8" android:keyLabel="8" />
+        <Key android:codes="57" android:popupKeyboard="@xml/shift_9" android:keyLabel="9" />
+        <Key android:codes="48" android:popupKeyboard="@xml/shift_0" android:keyLabel="0" />
+        <Key android:codes="-5" android:keyEdgeFlags="right" android:keyLabel="@string/keyboardview_keycode_delete" android:keyIcon="@drawable/ic_ime_delete" />
+    </Row>
+    <Row>
+        <Key android:codes="113" android:keyLabel="q" android:keyEdgeFlags="left" />
+        <Key android:codes="119" android:keyLabel="w" />
+        <Key android:codes="101" android:keyLabel="e" android:popupKeyboard="@xml/accent_is_e" />
+        <Key android:codes="114" android:keyLabel="r" />
+        <Key android:codes="116" android:keyLabel="t" />
+        <Key android:codes="121" android:keyLabel="y" android:popupKeyboard="@xml/accent_is_y" />
+        <Key android:codes="117" android:keyLabel="u" android:popupKeyboard="@xml/accent_is_u" />
+        <Key android:codes="105" android:keyLabel="i" android:popupKeyboard="@xml/accent_is_i" />
+        <Key android:codes="111" android:keyLabel="o" android:popupKeyboard="@xml/accent_is_o" />
+        <Key android:codes="112" android:keyLabel="p" />
+        <Key android:codes="208" android:keyLabel="ð" android:keyEdgeFlags="right"/>
+    </Row>
+    <Row>
+        <Key android:codes="97"  android:keyLabel="a" android:popupKeyboard="@xml/accent_is_a" android:keyEdgeFlags="left" />
+        <Key android:codes="115" android:keyLabel="s" />
+        <Key android:codes="100" android:keyLabel="d" />
+        <Key android:codes="102" android:keyLabel="f" />
+        <Key android:codes="103" android:keyLabel="g" />
+        <Key android:codes="104" android:keyLabel="h" />
+        <Key android:codes="106" android:keyLabel="j" />
+        <Key android:codes="107" android:keyLabel="k" />
+        <Key android:codes="108" android:keyLabel="l" />
+        <Key android:codes="230" android:popupKeyboard="@xml/shift_ae" android:keyLabel="æ" />
+        <Key android:codes="246" android:keyLabel="ö" android:keyEdgeFlags="right" />
+
+    </Row>
+    <Row>
+        <Key android:codes="-1" android:keyEdgeFlags="left" android:keyLabel="@string/keyboardview_keycode_shift" android:keyIcon="@drawable/ic_ime_shift_off" />
+        <Key android:codes="122" android:keyLabel="z" />
+        <Key android:codes="120" android:keyLabel="x" />
+        <Key android:codes="99"  android:keyLabel="c" />
+        <Key android:codes="118" android:keyLabel="v" />
+        <Key android:codes="98"  android:keyLabel="b" />
+        <Key android:codes="110" android:keyLabel="n" />
+        <Key android:codes="109" android:keyLabel="m" />
+        <Key android:codes="231" android:keyLabel="þ" />
+        <Key android:keyLabel="." />
+        <Key android:keyLabel="/" android:keyEdgeFlags="right" />
+    </Row>
+    <Row android:rowEdgeFlags="bottom">
+        <Key android:codes="-2" android:keyEdgeFlags="left" android:keyLabel="@string/keyboardview_keycode_mode_change" android:keyIcon="@drawable/ic_ime_symbols" />
+        <Key android:keyLabel="\@" />
+        <Key android:codes="-9" android:keyLabel="@string/keyboardview_keycode_lang" android:keyIcon="@drawable/ic_ime_world" />
+        <Key android:keyWidth="@dimen/space_key_width" android:codes="32" android:keyLabel="@string/keyboardview_keycode_space" android:keyIcon="@drawable/ic_ime_space_is" />
+        <Key android:codes="-3" android:keyLabel="@string/keyboardview_keycode_left" android:keyIcon="@drawable/ic_ime_left_arrow" />
+        <Key android:codes="-4" android:keyEdgeFlags="right" android:keyLabel="@string/keyboardview_keycode_right" android:keyIcon="@drawable/ic_ime_right_arrow" />
+    </Row>
+</Keyboard>

leankeykeyboard/src/main/res/xml/qwerty_ru.xml

@@ -28,7 +28,7 @@
         <Key android:keyEdgeFlags="right" android:keyLabel="х" />
     </Row>
     <Row>
-        <Key android:popupKeyboard="@xml/accent_a" android:keyEdgeFlags="left" android:keyLabel="ф" />
+        <Key android:keyEdgeFlags="left" android:keyLabel="ф" />
         <Key android:keyLabel="ы" />
         <Key android:keyLabel="в" />
         <Key android:keyLabel="а" />
@@ -48,9 +48,9 @@
         <Key android:keyLabel="и" />
         <Key android:keyLabel="т" />
         <Key android:keyLabel="ь" />
+        <Key android:keyLabel="ъ" />
         <Key android:keyLabel="б" />
         <Key android:keyLabel="ю" />
-        <Key android:codes="45" android:keyLabel="-" />
         <Key android:codes="63" android:keyEdgeFlags="right" android:keyLabel="\?" />
     </Row>
     <Row android:rowEdgeFlags="bottom">

leankeykeyboard/src/main/res/xml/qwerty_sv.xml

@@ -56,7 +56,8 @@
     <Row android:rowEdgeFlags="bottom">
         <Key android:codes="-2" android:keyEdgeFlags="left" android:keyLabel="@string/keyboardview_keycode_mode_change" android:keyIcon="@drawable/ic_ime_symbols" />
         <Key android:codes="-1" android:keyLabel="@string/keyboardview_keycode_shift" android:keyIcon="@drawable/ic_ime_shift_off" />
-        <Key android:keyWidth="@dimen/space_key_width" android:codes="32" android:keyLabel="@string/keyboardview_keycode_space" android:keyIcon="@drawable/ic_ime_space" />
+        <Key android:codes="-9" android:keyLabel="@string/keyboardview_keycode_lang" android:keyIcon="@drawable/ic_ime_world" />
+        <Key android:keyWidth="@dimen/space_key_width" android:codes="32" android:keyLabel="@string/keyboardview_keycode_space" android:keyIcon="@drawable/ic_ime_space_sv" />
         <Key android:codes="-3" android:keyLabel="@string/keyboardview_keycode_left" android:keyIcon="@drawable/ic_ime_left_arrow" />
         <Key android:codes="-4" android:keyEdgeFlags="right" android:keyLabel="@string/keyboardview_keycode_right" android:keyIcon="@drawable/ic_ime_right_arrow" />
     </Row>

leankeykeyboard/src/main/res/xml/qwerty_th.xml

@@ -4,56 +4,58 @@
     <!-- Thai keyboard -->
     <!-- https://en.wikipedia.org/wiki/Thai_(Unicode_block) -->
     <Row android:rowEdgeFlags="top">
-        <Key android:codes="49" android:popupKeyboard="@xml/shift_1" android:keyEdgeFlags="left" android:keyLabel="1" />
-        <Key android:codes="50" android:popupKeyboard="@xml/shift_2" android:keyLabel="2" />
-        <Key android:codes="51" android:popupKeyboard="@xml/shift_3" android:keyLabel="3" />
-        <Key android:codes="52" android:popupKeyboard="@xml/shift_4" android:keyLabel="4" />
-        <Key android:codes="53" android:popupKeyboard="@xml/shift_5" android:keyLabel="5" />
-        <Key android:codes="54" android:popupKeyboard="@xml/shift_6" android:keyLabel="6" />
-        <Key android:codes="55" android:popupKeyboard="@xml/shift_7" android:keyLabel="7" />
-        <Key android:codes="56" android:popupKeyboard="@xml/shift_8" android:keyLabel="8" />
-        <Key android:codes="57" android:popupKeyboard="@xml/shift_9" android:keyLabel="9" />
-        <Key android:codes="48" android:popupKeyboard="@xml/shift_0" android:keyLabel="0" />
-        <Key android:codes="-5" android:keyEdgeFlags="right"         android:keyLabel="@string/keyboardview_keycode_delete" android:keyIcon="@drawable/ic_ime_delete" />
+        <Key android:keyEdgeFlags="left" android:keyLabel="ๆ|๑" />
+        <Key android:keyLabel="ภ|๒" />
+        <Key android:keyLabel="ถ|๓" />
+        <Key android:keyLabel="ุ|ู" />
+        <Key android:keyLabel="ึ|๔" />
+        <Key android:keyLabel="ค|๕" />
+        <Key android:keyLabel="ต|๖" />
+        <Key android:keyLabel="จ|๗" />
+        <Key android:keyLabel="ข|๘" />
+        <Key android:keyLabel="ช|๙" />
+        <Key android:codes="-5" android:keyEdgeFlags="right" android:keyLabel="@string/keyboardview_keycode_delete" android:keyIcon="@drawable/ic_ime_delete" />
     </Row>
     <Row>
-        <Key android:popupKeyboard="@xml/accent_q_th"  android:keyLabel="ฝ" android:keyEdgeFlags="left" />
-        <Key android:popupKeyboard="@xml/accent_w_th"  android:keyLabel="๒" />
-        <Key android:popupKeyboard="@xml/accent_e_th"  android:keyLabel="๓" />
-        <Key android:popupKeyboard="@xml/accent_r_th"  android:keyLabel="ู" />
-        <Key android:popupKeyboard="@xml/accent_t_th"  android:keyLabel="ค" />
-        <Key android:popupKeyboard="@xml/accent_y_th"  android:keyLabel="๖" />
-        <Key android:popupKeyboard="@xml/accent_u_th"  android:keyLabel="ข" />
-        <Key android:popupKeyboard="@xml/accent_i_th"  android:keyLabel="๙" />
-        <Key android:popupKeyboard="@xml/accent_o_th"  android:keyLabel="ไ" />
-        <Key android:popupKeyboard="@xml/accent_p_th"  android:keyLabel="พ" />
-        <Key android:popupKeyboard="@xml/accent_p2_th" android:keyLabel="ธ" android:keyEdgeFlags="right" />
+        <!-- NOTE: example of adding different chars to uppercase/lowercase states  -->
+        <!-- format is: android:keyLabel="lower_char|upper_char" e.g. android:keyLabel="ฝ|๒" -->
+        <Key android:keyLabel="ไ|๐" android:keyEdgeFlags="left" />
+        <Key android:keyLabel="ำ|ฎ" />
+        <Key android:keyLabel="พ|ฑ" />
+        <Key android:keyLabel="ะ|ธ" />
+        <Key android:keyLabel="ั|ํ" />
+        <Key android:keyLabel="ี|๊" />
+        <Key android:keyLabel="ร|ณ" />
+        <Key android:keyLabel="น|ฯ" />
+        <Key android:keyLabel="ย|ญ" />
+        <Key android:keyLabel="บ|ฐ" />
+        <Key android:keyLabel="ล|," android:keyEdgeFlags="right" />
     </Row>
     <Row>
-        <Key android:popupKeyboard="@xml/accent_a_th"  android:keyLabel="ี" android:keyEdgeFlags="left" />
-        <Key android:popupKeyboard="@xml/accent_s_th"  android:keyLabel="ณ" />
-        <Key android:popupKeyboard="@xml/accent_d_th"  android:keyLabel="ย" />
-        <Key android:popupKeyboard="@xml/accent_f_th"  android:keyLabel="ฐ" />
-        <Key android:popupKeyboard="@xml/accent_g_th"  android:keyLabel="ล" />
-        <Key android:popupKeyboard="@xml/accent_h_th"  android:keyLabel="ฅ" />
-        <Key android:popupKeyboard="@xml/accent_j_th"  android:keyLabel="ฃ" />
-        <Key                                           android:keyLabel="ฟ" />
-        <Key                                           android:keyLabel="ฤ" />
-        <Key                                           android:keyLabel="ห" />
-        <Key                                           android:keyLabel="ş" android:keyEdgeFlags="right" />
+        <Key android:keyLabel="ฟ|ฤ" android:keyEdgeFlags="left" />
+        <Key android:keyLabel="ห|ฆ" />
+        <Key android:keyLabel="ก|ฏ" />
+        <Key android:keyLabel="ด|โ" />
+        <Key android:keyLabel="เ|ฌ" />
+        <Key android:keyLabel="้|็" />
+        <Key android:keyLabel="่|๋" />
+        <Key android:keyLabel="า|ษ" />
+        <Key android:keyLabel="ส|ศ" />
+        <Key android:keyLabel="ว|ซ" />
+        <Key android:keyLabel="ง|." android:keyEdgeFlags="right" />
     </Row>
     <Row>
-        <Key android:popupKeyboard="@xml/accent_z_th"  android:keyLabel="ฆ" android:keyEdgeFlags="left" />
-        <Key android:popupKeyboard="@xml/accent_x_th"  android:keyLabel="ด" />
-        <Key android:popupKeyboard="@xml/accent_c_th"  android:keyLabel="็" />
-        <Key                                           android:keyLabel="า" />
-        <Key                                           android:keyLabel="ษ" />
-        <Key                                           android:keyLabel="ส" />
-        <Key                                           android:keyLabel="ศ" />
-        <Key                                           android:keyLabel="ว" />
-        <Key                                           android:keyLabel="ซ" />
-        <Key                                           android:keyLabel="ง" />
-        <Key                                           android:keyLabel="," android:keyEdgeFlags="right" />
+        <Key android:keyLabel="ผ|(" android:keyEdgeFlags="left" />
+        <Key android:keyLabel="ป|)" />
+        <Key android:keyLabel="แ|ฉ" />
+        <Key android:keyLabel="อ|ฮ" />
+        <Key android:keyLabel="ิ|ฺ" />
+        <Key android:keyLabel="ื|์" />
+        <Key android:keyLabel="ท|?" />
+        <Key android:keyLabel="ม|ฒ" />
+        <Key android:keyLabel="ใ|ฬ" />
+        <Key android:keyLabel="ฝ|ฦ" />
+        <Key android:keyLabel="ฃ|ฅ" android:keyEdgeFlags="right" />
     </Row>
     <Row android:rowEdgeFlags="bottom">
         <Key android:codes="-2" android:keyEdgeFlags="left" android:keyLabel="@string/keyboardview_keycode_mode_change" android:keyIcon="@drawable/ic_ime_symbols" />