Spell checking (#1137)

This adds dictionary-based spell checking to the keyboard. The keyboard looks at the word being typed and matches it against a dictionary to either complete the rest of the word or find alternative spellings.

The core of this feature is implemented in cdict, which is included as a
submodule in vendor/cidct.

Cdict is developped at https://github.com/Julow/cdict
The dictionaries are hosted at https://github.com/Julow/Unexpected-Keyboard-dictionaries/
The wordlists used to build the dictionaries are the same ones used by
HeliBoard from https://codeberg.org/Helium314/aosp-dictionaries

- Add an activity accessible from the launcher app that lists available
  dictionaries with a download button.
  The DictionaryListView view shows the list of available dictionaries and
  handles downloading and installing them.

- The Dictionaries class manages installed dictionaries. Dictionaries are
  installed as individual files into the app's private directory.

- Available dictionaries are listed in dictionaries.xml, which is generated
  when building Unexpected-Keyboard-dictionaries.
  method.xml mentions the dictionary name for each locales.

4 files changed, 388 insertions, 0 deletions

diff --git a/srcs/juloo.keyboard2/dict/Dictionaries.java b/srcs/juloo.keyboard2/dict/Dictionaries.java
new file mode 100644
index 0000000..ac43c9b
--- /dev/null
+++ b/srcs/juloo.keyboard2/dict/Dictionaries.java
@@ -0,0 +1,149 @@
+package juloo.keyboard2.dict;
+
+import android.content.Context;
+import android.content.SharedPreferences;
+import android.content.res.Resources;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Set;
+import java.util.TreeMap;
+import juloo.cdict.Cdict;
+import juloo.keyboard2.Logs;
+import juloo.keyboard2.Utils;
+
+/** Manage and load installed dictionaries. */
+public final class Dictionaries
+{
+  public static Dictionaries instance(Context ctx)
+  {
+    if (_instance == null)
+      _instance = new Dictionaries(ctx);
+    return _instance;
+  }
+
+  /** Util for finding a dictionary by name. Returns [null] if not found. */
+  public static Cdict find_by_name(Cdict[] dicts, String name)
+  {
+    for (Cdict d : dicts)
+      if (d.name.equals(name))
+        return d;
+    return null;
+  }
+
+  /** Load an installed dictionary. Return [null] if the requested dictionary
+      is not installed or the dictionary couldn't be loaded. */
+  public Cdict[] load(String dict_name)
+  {
+    if (_loaded_dictionaries.containsKey(dict_name))
+      return _loaded_dictionaries.get(dict_name);
+    Cdict[] dict = load_uncached(dict_name);
+    _loaded_dictionaries.put(dict_name, dict);
+    return dict;
+  }
+
+  public Set<String> get_installed() { return _installed_dictionaries; }
+
+  public void install(String dict_name, byte[] data) throws IOException
+  {
+    FileOutputStream outp = _context.openFileOutput(dict_file_name(dict_name),
+        Context.MODE_PRIVATE);
+    outp.write(data);
+    outp.close();
+    set_installed(dict_name);
+  }
+
+  /** Return the absolute path used to store the dictionary with the given
+      name. Return the same result whether the dictionary is installed or not. */
+  public File get_install_location(String dict_name)
+  {
+    return _context.getFileStreamPath(dict_file_name(dict_name));
+  }
+
+  /** Declare a dictionary as installed. A dictionary file must exist at the
+      path returned by [get_install_location(dict_name)]. */
+  public void set_installed(String dict_name)
+  {
+    _installed_dictionaries.add(dict_name);
+    _loaded_dictionaries.remove(dict_name);
+    save();
+  }
+
+  public void uninstall(String dict_name)
+  {
+    _context.deleteFile(dict_file_name(dict_name));
+    _installed_dictionaries.remove(dict_name);
+    _loaded_dictionaries.remove(dict_name);
+    save();
+  }
+
+  /** Private */
+
+  Context _context;
+  Set<String> _installed_dictionaries;
+  /** Might be 'null' when safe storage is not available. */
+  SharedPreferences _shared_prefs;
+  Map<String, Cdict[]> _loaded_dictionaries;
+
+  static Dictionaries _instance = null;
+
+  static final String PREF_INSTALLED_DICTS = "installed";
+
+  Dictionaries(Context ctx)
+  {
+    _context = ctx;
+    _installed_dictionaries = new HashSet();
+    _loaded_dictionaries = new TreeMap<String, Cdict[]>();
+    load_prefs();
+  }
+
+  void load_prefs()
+  {
+    _shared_prefs = null;
+    try
+    {
+      _shared_prefs =
+        _context.getSharedPreferences("dictionaries", Context.MODE_PRIVATE);
+      Set<String> s = _shared_prefs.getStringSet(PREF_INSTALLED_DICTS, null);
+      if (s != null)
+        _installed_dictionaries.addAll(s);
+    }
+    catch (Exception e)
+    {
+      Logs.exn("", e);
+    }
+  }
+
+  Cdict[] load_uncached(String dict_name)
+  {
+    if (!_installed_dictionaries.contains(dict_name))
+      return null;
+    try
+    {
+      FileInputStream inp = _context.openFileInput(dict_file_name(dict_name));
+      byte[] data = Utils.read_all_bytes(inp);
+      inp.close();
+      return Cdict.of_bytes(data);
+    }
+    catch (IOException e) { return null; }
+    catch (Cdict.ConstructionError e) { return null; }
+  }
+
+  void save()
+  {
+    if (_shared_prefs == null)
+      return;
+    _shared_prefs.edit()
+      .putStringSet(PREF_INSTALLED_DICTS, _installed_dictionaries)
+      .commit();
+  }
+
+  static String dict_file_name(String dict_name)
+  {
+    return dict_name + ".dict";
+  }
+}
diff --git a/srcs/juloo.keyboard2/dict/DictionariesActivity.java b/srcs/juloo.keyboard2/dict/DictionariesActivity.java
new file mode 100644
index 0000000..4143107
--- /dev/null
+++ b/srcs/juloo.keyboard2/dict/DictionariesActivity.java
@@ -0,0 +1,15 @@
+package juloo.keyboard2.dict;
+
+import android.app.Activity;
+import android.os.Bundle;
+import juloo.keyboard2.R;
+
+public class DictionariesActivity extends Activity
+{
+  @Override
+  public void onCreate(Bundle savedInstanceState)
+  {
+    super.onCreate(savedInstanceState);
+    setContentView(R.layout.dictionaries_activity);
+  }
+}
diff --git a/srcs/juloo.keyboard2/dict/DictionaryListView.java b/srcs/juloo.keyboard2/dict/DictionaryListView.java
new file mode 100644
index 0000000..465d373
--- /dev/null
+++ b/srcs/juloo.keyboard2/dict/DictionaryListView.java
@@ -0,0 +1,191 @@
+package juloo.keyboard2.dict;
+
+import android.content.Context;
+import android.util.AttributeSet;
+import android.view.View;
+import android.widget.LinearLayout;
+import android.widget.TextView;
+import android.widget.Toast;
+import java.io.IOException;
+import java.net.MalformedURLException;
+import java.net.URL;
+import java.net.URLConnection;
+import java.text.NumberFormat;
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+import java.util.zip.GZIPInputStream;
+import juloo.cdict.Cdict;
+import juloo.keyboard2.Config;
+import juloo.keyboard2.DeviceLocales;
+import juloo.keyboard2.Logs;
+import juloo.keyboard2.R;
+import juloo.keyboard2.Utils;
+
+public class DictionaryListView extends LinearLayout
+{
+  List<DictView> _dict_views;
+  Dictionaries _dictionaries;
+  Set<String> _pending = new HashSet();
+
+  public DictionaryListView(Context ctx, AttributeSet attrs)
+  {
+    super(ctx, attrs);
+    setOrientation(LinearLayout.VERTICAL);
+    _dictionaries = Dictionaries.instance(ctx);
+    inflate_views(ctx);
+  }
+
+  void inflate_views(Context ctx)
+  {
+    DeviceLocales locales = DeviceLocales.load(ctx);
+    SupportedDictionaries ds = new SupportedDictionaries(ctx.getResources());
+    DownloadBtnListener listener = this.new DownloadBtnListener();
+    _dict_views = new ArrayList<DictView>();
+    for (DeviceLocales.Loc loc : locales.installed)
+    {
+      int idx = (loc.dictionary != null) ? ds.find(loc.dictionary) : -1;
+      if (idx >= 0)
+      {
+        DictView dv = new DictView(ctx, ds, idx, listener);
+        addView(dv.view);
+        _dict_views.add(dv);
+      }
+    }
+    refresh();
+  }
+
+  /** Update the "installed" status of item views. Meaning whether the
+      "download" or "delete" button is shown. */
+  void refresh()
+  {
+    Set<String> installed = _dictionaries.get_installed();
+    for (DictView d : _dict_views)
+      d.refresh(installed, _pending);
+  }
+
+  void toggle_installed(String dict_name)
+  {
+    run_dictionary_action(dict_name, new Runnable()
+        {
+          public void run()
+          {
+            if (_dictionaries.get_installed().contains(dict_name))
+              _dictionaries.uninstall(dict_name);
+            else if (install_dictionary_from_internet(dict_name))
+              post_toast(R.string.dictionaries_download_success);
+            else
+              post_toast(R.string.dictionaries_download_failed);
+          }
+        });
+  }
+
+  /** Run action [r] for dictionary [name] if no action is already running for
+      that dictionary. Calls [refresh] after the action completed. */
+  void run_dictionary_action(String name, Runnable r)
+  {
+    if (_pending.contains(name))
+      return;
+    _pending.add(name);
+    (new Thread()
+     {
+       public void run()
+       {
+         r.run();
+         post(new Runnable()
+             {
+               public void run()
+               {
+                 _pending.remove(name);
+                 refresh();
+               }
+             });
+       }
+     }).start();
+    refresh();
+  }
+
+  final class DownloadBtnListener implements View.OnClickListener
+  {
+    @Override
+    public void onClick(View v)
+    {
+      for (DictView dv : _dict_views)
+        if (dv.download_button == v)
+          toggle_installed(dv.dict_name);
+    }
+  }
+
+  static final class DictView
+  {
+    public final View view;
+    public final String dict_name;
+    public final View download_button;
+
+    public DictView(Context ctx, SupportedDictionaries ds, int dict_index,
+        DownloadBtnListener on_click)
+    {
+      view = View.inflate(ctx, R.layout.dictionary_download_item, null);
+      dict_name = ds.dict_name(dict_index);
+      float size_mb = ds.size(dict_index) / 1048576.f;
+      ((TextView)view.findViewById(R.id.dictionary_download_locale))
+        .setText(ds.display_name(dict_index));
+      ((TextView)view.findViewById(R.id.dictionary_download_size))
+        .setText(NumberFormat.getInstance().format(size_mb) + "MB");
+      download_button = view.findViewById(R.id.dictionary_download_button);
+      download_button.setOnClickListener(on_click);
+    }
+
+    public void refresh(Set<String> installed, Set<String> pending)
+    {
+      download_button.setBackgroundResource(installed.contains(dict_name)
+          ? R.drawable.ic_delete : R.drawable.ic_download);
+      download_button.setVisibility(pending.contains(dict_name)
+          ? View.GONE : View.VISIBLE);
+    }
+  }
+
+  static final String DICT_REPO_URL =
+    "https://github.com/Julow/Unexpected-Keyboard-dictionaries/raw/refs/heads/main";
+
+  static URL url_of_dictionary(String dict_name)
+      throws MalformedURLException
+  {
+    int format_version = 0;
+    return new URL(DICT_REPO_URL + "/v" + format_version + "/" + dict_name
+        + ".dict");
+  }
+
+  /** Returns [true] on success. */
+  boolean install_dictionary_from_internet(String dict_name)
+  {
+    try
+    {
+      // Remote files are compressed with gzip at rest. Do not use server side
+      // compression and force decompression.
+      URLConnection con = url_of_dictionary(dict_name).openConnection();
+      con.setRequestProperty("Accept-Encoding", "identity");
+      byte[] data = Utils.read_all_bytes(new GZIPInputStream(con.getInputStream()));
+      Cdict.of_bytes(data); // Check that the dictionary can load.
+      _dictionaries.install(dict_name, data);
+      return true;
+    }
+    catch (Exception e)
+    {
+      Logs.exn("", e);
+      return false;
+    }
+  }
+
+  void post_toast(int msg_id)
+  {
+    post(new Runnable()
+        {
+          public void run()
+          {
+            Toast.makeText(getContext(), msg_id, Toast.LENGTH_SHORT).show();
+          }
+        });
+  }
+}
diff --git a/srcs/juloo.keyboard2/dict/SupportedDictionaries.java b/srcs/juloo.keyboard2/dict/SupportedDictionaries.java
new file mode 100644
index 0000000..879fccd
--- /dev/null
+++ b/srcs/juloo.keyboard2/dict/SupportedDictionaries.java
@@ -0,0 +1,33 @@
+package juloo.keyboard2.dict;
+
+import android.content.res.Resources;
+import java.util.Arrays;
+import juloo.keyboard2.R;
+
+/** Access arrays in [dictionaries.xml]. */
+public class SupportedDictionaries
+{
+  public String[] locales;
+  public String[] names;
+  public int[] sizes;
+
+  public SupportedDictionaries(Resources res)
+  {
+    locales = res.getStringArray(R.array.dictionaries_locale);
+    names = res.getStringArray(R.array.dictionaries_name);
+    sizes = res.getIntArray(R.array.dictionaries_size);
+  }
+
+  /** Find the index for a given dictionary name. Return [-1] if not found. */
+  public int find(String dict_name)
+  {
+    int i = Arrays.binarySearch(locales, dict_name);
+    return (i < 0) ? -1 : i;
+  }
+
+  public int length() { return locales.length; }
+
+  public String dict_name(int i) { return locales[i]; }
+  public String display_name(int i) { return names[i]; }
+  public int size(int i) { return sizes[i]; }
+}